Merge ../linus

299 files changed, 22054 insertions, 33064 deletions

diff --git a/drivers/char/.gitignore b/drivers/char/.gitignore
index 73dfdcebfbba..83683a2d8e6a 100644
--- a/drivers/char/.gitignore
+++ b/drivers/char/.gitignore
@@ -1,3 +1,2 @@
 consolemap_deftbl.c
 defkeymap.c
-qtronixmap.c
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 52ea94b891f5..b10f4d8fdc7f 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -201,6 +201,21 @@ config MOXA_SMARTIO
           The module will be called mxser. If you want to do that, say M
           here.
 
+config MOXA_SMARTIO_NEW
+        tristate "Moxa SmartIO support v. 2.0 (EXPERIMENTAL)"
+        depends on SERIAL_NONSTANDARD
+        help
+          Say Y here if you have a Moxa SmartIO multiport serial card and/or
+          want to help develop a new version of this driver.
+
+          This is upgraded (1.9.1) driver from original Moxa drivers with
+          changes finally resulting in PCI probing.
+
+          Use at your own risk.
+
+          This driver can also be built as a module. The module will be called
+          mxser_new. If you want to do that, say M here.
+
 config ISI
         tristate "Multi-Tech multiport card support (EXPERIMENTAL)"
         depends on SERIAL_NONSTANDARD
@@ -371,36 +386,6 @@ config AU1000_SERIAL_CONSOLE
           If you have an Alchemy AU1000 processor (MIPS based) and you want
           to use a console on a serial port, say Y.  Otherwise, say N.
 
-config QTRONIX_KEYBOARD
-        bool "Enable Qtronix 990P Keyboard Support"
-        depends on IT8712
-        help
-          Images of Qtronix keyboards are at
-          <http://www.qtronix.com/keyboard.html>.
-
-config IT8172_CIR
-        bool
-        depends on QTRONIX_KEYBOARD
-        default y
-
-config IT8172_SCR0
-        bool "Enable Smart Card Reader 0 Support "
-        depends on IT8712
-        help
-          Say Y here to support smart-card reader 0 (SCR0) on the Integrated
-          Technology Express, Inc. ITE8172 SBC.  Vendor page at
-          <http://www.ite.com.tw/ia/brief_it8172bsp.htm>; picture of the
-          board at <http://www.mvista.com/partners/semiconductor/ite.html>.
-
-config IT8172_SCR1
-        bool "Enable Smart Card Reader 1 Support "
-        depends on IT8712
-        help
-          Say Y here to support smart-card reader 1 (SCR1) on the Integrated
-          Technology Express, Inc. ITE8172 SBC.  Vendor page at
-          <http://www.ite.com.tw/ia/brief_it8172bsp.htm>; picture of the
-          board at <http://www.mvista.com/partners/semiconductor/ite.html>.
-
 config A2232
         tristate "Commodore A2232 serial support (EXPERIMENTAL)"
         depends on EXPERIMENTAL && ZORRO && BROKEN_ON_SMP
@@ -739,7 +724,7 @@ config NVRAM
 
 config RTC
         tristate "Enhanced Real Time Clock Support"
-        depends on !PPC && !PARISC && !IA64 && !M68K && (!SPARC || PCI) && !FRV && !ARM
+        depends on !PPC && !PARISC && !IA64 && !M68K && (!SPARC || PCI) && !FRV && !ARM && !SUPERH
         ---help---
           If you say Y here and create a character special file /dev/rtc with
           major number 10 and minor number 135 using mknod ("man mknod"), you
@@ -823,14 +808,6 @@ config DS1302
           will get access to the real time clock (or hardware clock) built
           into your computer.
 
-config S3C2410_RTC
-        bool "S3C2410 RTC Driver"
-        depends on ARCH_S3C2410
-        help
-          RTC (Realtime Clock) driver for the clock inbuilt into the
-          Samsung S3C2410. This can provide periodic interrupt rates
-          from 1Hz to 64Hz for user programs, and wakeup from Alarm.
-
 config COBALT_LCD
         bool "Support for Cobalt LCD"
         depends on MIPS_COBALT
@@ -893,39 +870,6 @@ config TANBAC_TB0219
         depends TANBAC_TB022X
         select GPIO_VR41XX
 
-menu "Ftape, the floppy tape device driver"
-
-config FTAPE
-        tristate "Ftape (QIC-80/Travan) support"
-        depends on BROKEN_ON_SMP && (ALPHA || X86)
-        ---help---
-          If you have a tape drive that is connected to your floppy
-          controller, say Y here.
-
-          Some tape drives (like the Seagate "Tape Store 3200" or the Iomega
-          "Ditto 3200" or the Exabyte "Eagle TR-3") come with a "high speed"
-          controller of their own. These drives (and their companion
-          controllers) are also supported if you say Y here.
-
-          If you have a special controller (such as the CMS FC-10, FC-20,
-          Mountain Mach-II, or any controller that is based on the Intel 82078
-          FDC like the high speed controllers by Seagate and Exabyte and
-          Iomega's "Ditto Dash") you must configure it by selecting the
-          appropriate entries from the "Floppy tape controllers" sub-menu
-          below and possibly modify the default values for the IRQ and DMA
-          channel and the IO base in ftape's configuration menu.
-
-          If you want to use your floppy tape drive on a PCI-bus based system,
-          please read the file <file:drivers/char/ftape/README.PCI>.
-
-          The ftape kernel driver is also available as a runtime loadable
-          module. To compile this driver as a module, choose M here: the
-          module will be called ftape.
-
-source "drivers/char/ftape/Kconfig"
-
-endmenu
-
 source "drivers/char/agp/Kconfig"
 
 source "drivers/char/drm/Kconfig"
@@ -1006,6 +950,7 @@ config GPIO_VR41XX
 
 config RAW_DRIVER
         tristate "RAW driver (/dev/raw/rawN) (OBSOLETE)"
+        depends on BLOCK
         help
           The raw driver permits block devices to be bound to /dev/raw/rawN. 
           Once bound, I/O against /dev/raw/rawN uses efficient zero-copy I/O. 
@@ -1031,7 +976,7 @@ config HPET
         help
           If you say Y here, you will have a miscdevice named "/dev/hpet/".  Each
           open selects one of the timers supported by the HPET.  The timers are
-          non-periodioc and/or periodic.
+          non-periodic and/or periodic.
 
 config HPET_RTC_IRQ
         bool "HPET Control RTC IRQ" if !HPET_EMULATE_RTC
@@ -1075,7 +1020,7 @@ source "drivers/char/tpm/Kconfig"
 
 config TELCLOCK
         tristate "Telecom clock driver for MPBL0010 ATCA SBC"
-        depends on EXPERIMENTAL
+        depends on EXPERIMENTAL && X86
         default n
         help
           The telecom clock device is specific to the MPBL0010 ATCA computer and
diff --git a/drivers/char/Makefile b/drivers/char/Makefile
index 8c6dfc621520..fc110637ced6 100644
--- a/drivers/char/Makefile
+++ b/drivers/char/Makefile
@@ -31,6 +31,7 @@ obj-$(CONFIG_MOXA_INTELLIO)	+= moxa.o
 obj-$(CONFIG_A2232)             += ser_a2232.o generic_serial.o
 obj-$(CONFIG_ATARI_DSP56K)      += dsp56k.o
 obj-$(CONFIG_MOXA_SMARTIO)      += mxser.o
+obj-$(CONFIG_MOXA_SMARTIO_NEW)  += mxser_new.o
 obj-$(CONFIG_COMPUTONE)         += ip2/
 obj-$(CONFIG_RISCOM8)           += riscom8.o
 obj-$(CONFIG_ISI)               += isicom.o
@@ -47,6 +48,7 @@ obj-$(CONFIG_HVC_RTAS)		+= hvc_rtas.o
 obj-$(CONFIG_HVC_DRIVER)        += hvc_console.o
 obj-$(CONFIG_RAW_DRIVER)        += raw.o
 obj-$(CONFIG_SGI_SNSC)          += snsc.o snsc_event.o
+obj-$(CONFIG_MSPEC)             += mspec.o
 obj-$(CONFIG_MMTIMER)           += mmtimer.o
 obj-$(CONFIG_VIOCONS)           += viocons.o
 obj-$(CONFIG_VIOTAPE)           += viotape.o
@@ -68,7 +70,6 @@ obj-$(CONFIG_EFI_RTC)		+= efirtc.o
 obj-$(CONFIG_SGI_DS1286)        += ds1286.o
 obj-$(CONFIG_SGI_IP27_RTC)      += ip27-rtc.o
 obj-$(CONFIG_DS1302)            += ds1302.o
-obj-$(CONFIG_S3C2410_RTC)       += s3c2410-rtc.o
 ifeq ($(CONFIG_GENERIC_NVRAM),y)
   obj-$(CONFIG_NVRAM)   += generic_nvram.o
 else
@@ -78,7 +79,6 @@ obj-$(CONFIG_TOSHIBA)		+= toshiba.o
 obj-$(CONFIG_I8K)               += i8k.o
 obj-$(CONFIG_DS1620)            += ds1620.o
 obj-$(CONFIG_HW_RANDOM)         += hw_random/
-obj-$(CONFIG_FTAPE)             += ftape/
 obj-$(CONFIG_COBALT_LCD)        += lcd.o
 obj-$(CONFIG_PPDEV)             += ppdev.o
 obj-$(CONFIG_NWBUTTON)          += nwbutton.o
@@ -102,7 +102,7 @@ obj-$(CONFIG_HANGCHECK_TIMER)	+= hangcheck-timer.o
 obj-$(CONFIG_TCG_TPM)           += tpm/
 
 # Files generated that shall be removed upon make clean
-clean-files := consolemap_deftbl.c defkeymap.c qtronixmap.c
+clean-files := consolemap_deftbl.c defkeymap.c
 
 quiet_cmd_conmk = CONMK   $@
       cmd_conmk = scripts/conmakehash $< > $@
@@ -112,8 +112,6 @@ $(obj)/consolemap_deftbl.c: $(src)/$(FONTMAPFILE)
 
 $(obj)/defkeymap.o:  $(obj)/defkeymap.c
 
-$(obj)/qtronixmap.o: $(obj)/qtronixmap.c
-
 # Uncomment if you're changing the keymap and have an appropriate
 # loadkeys version for the map. By default, we'll use the shipped
 # versions.
@@ -121,7 +119,7 @@ $(obj)/qtronixmap.o: $(obj)/qtronixmap.c
 
 ifdef GENERATE_KEYMAP
 
-$(obj)/defkeymap.c $(obj)/qtronixmap.c: $(obj)/%.c: $(src)/%.map
+$(obj)/defkeymap.c $(obj)/%.c: $(src)/%.map
         loadkeys --mktable $< > $@.tmp
         sed -e 's/^static *//' $@.tmp > $@
         rm $@.tmp
diff --git a/drivers/char/agp/Kconfig b/drivers/char/agp/Kconfig
index 3d7cad7841de..a9f9c48c2424 100644
--- a/drivers/char/agp/Kconfig
+++ b/drivers/char/agp/Kconfig
@@ -1,6 +1,6 @@
 config AGP
         tristate "/dev/agpgart (AGP Support)"
-        depends on ALPHA || IA64 || PPC || X86
+        depends on ALPHA || IA64 || PARISC || PPC || X86
         depends on PCI
         ---help---
           AGP (Accelerated Graphics Port) is a bus system mainly used to
@@ -122,6 +122,14 @@ config AGP_HP_ZX1
           This option gives you AGP GART support for the HP ZX1 chipset
           for IA64 processors.
 
+config AGP_PARISC
+        tristate "HP Quicksilver AGP support"
+        depends on AGP && PARISC && 64BIT
+        help
+          This option gives you AGP GART support for the HP Quicksilver
+          AGP bus adapter on HP PA-RISC machines (Ok, just on the C8000
+          workstation...)
+
 config AGP_ALPHA_CORE
         tristate "Alpha AGP support"
         depends on AGP && (ALPHA_GENERIC || ALPHA_TITAN || ALPHA_MARVEL)
diff --git a/drivers/char/agp/Makefile b/drivers/char/agp/Makefile
index d33a22f2fa0b..3e581603d0a8 100644
--- a/drivers/char/agp/Makefile
+++ b/drivers/char/agp/Makefile
@@ -8,6 +8,7 @@ obj-$(CONFIG_AGP_AMD64)		+= amd64-agp.o
 obj-$(CONFIG_AGP_ALPHA_CORE)    += alpha-agp.o
 obj-$(CONFIG_AGP_EFFICEON)      += efficeon-agp.o
 obj-$(CONFIG_AGP_HP_ZX1)        += hp-agp.o
+obj-$(CONFIG_AGP_PARISC)        += parisc-agp.o
 obj-$(CONFIG_AGP_I460)          += i460-agp.o
 obj-$(CONFIG_AGP_INTEL)         += intel-agp.o
 obj-$(CONFIG_AGP_NVIDIA)        += nvidia-agp.o
diff --git a/drivers/char/agp/generic.c b/drivers/char/agp/generic.c
index ca4629f66d17..883a36a27833 100644
--- a/drivers/char/agp/generic.c
+++ b/drivers/char/agp/generic.c
@@ -1079,7 +1079,7 @@ void *agp_generic_alloc_page(struct agp_bridge_data *bridge)
 {
         struct page * page;
 
-        page = alloc_page(GFP_KERNEL);
+        page = alloc_page(GFP_KERNEL | GFP_DMA32);
         if (page == NULL)
                 return NULL;
 
diff --git a/drivers/char/agp/intel-agp.c b/drivers/char/agp/intel-agp.c
index d1ede7db5a12..555b3a8ab49c 100644
--- a/drivers/char/agp/intel-agp.c
+++ b/drivers/char/agp/intel-agp.c
@@ -169,7 +169,7 @@ static void *i8xx_alloc_pages(void)
 {
         struct page * page;
 
-        page = alloc_pages(GFP_KERNEL, 2);
+        page = alloc_pages(GFP_KERNEL | GFP_DMA32, 2);
         if (page == NULL)
                 return NULL;
 
@@ -387,11 +387,7 @@ static void intel_i830_init_gtt_entries(void)
         /* We obtain the size of the GTT, which is also stored (for some
          * reason) at the top of stolen memory. Then we add 4KB to that
          * for the video BIOS popup, which is also stored in there. */
-
-        if (IS_I965)
-                size = 512 + 4;
-        else
-                size = agp_bridge->driver->fetch_size() + 4;
+        size = agp_bridge->driver->fetch_size() + 4;
 
         if (agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82830_HB ||
             agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82845G_HB) {
@@ -805,6 +801,26 @@ static int intel_i915_create_gatt_table(struct agp_bridge_data *bridge)
 
         return 0;
 }
+
+/*
+ * The i965 supports 36-bit physical addresses, but to keep
+ * the format of the GTT the same, the bits that don't fit
+ * in a 32-bit word are shifted down to bits 4..7.
+ *
+ * Gcc is smart enough to notice that "(addr >> 28) & 0xf0"
+ * is always zero on 32-bit architectures, so no need to make
+ * this conditional.
+ */
+static unsigned long intel_i965_mask_memory(struct agp_bridge_data *bridge,
+        unsigned long addr, int type)
+{
+        /* Shift high bits down */
+        addr |= (addr >> 28) & 0xf0;
+
+        /* Type checking must be done elsewhere */
+        return addr | bridge->driver->masks[type].mask;
+}
+
 static int intel_i965_fetch_size(void)
 {
        struct aper_size_info_fixed *values;
@@ -832,7 +848,8 @@ static int intel_i965_fetch_size(void)
 
        agp_bridge->previous_size = agp_bridge->current_size = (void *)(values + offset);
 
-       return values[offset].size;
+        /* The i965 GTT is always sized as if it had a 512kB aperture size */
+        return 512;
 }
 
 /* The intel i965 automatically initializes the agp aperture during POST.
@@ -1584,7 +1601,7 @@ static struct agp_bridge_driver intel_i965_driver = {
        .fetch_size             = intel_i965_fetch_size,
        .cleanup                = intel_i915_cleanup,
        .tlb_flush              = intel_i810_tlbflush,
-       .mask_memory            = intel_i810_mask_memory,
+       .mask_memory            = intel_i965_mask_memory,
        .masks                  = intel_i810_masks,
        .agp_enable             = intel_i810_agp_enable,
        .cache_flush            = global_cache_flush,
diff --git a/drivers/char/agp/parisc-agp.c b/drivers/char/agp/parisc-agp.c
new file mode 100644
index 000000000000..17c50b0f83f0
--- /dev/null
+++ b/drivers/char/agp/parisc-agp.c
@@ -0,0 +1,416 @@
+/*
+ * HP Quicksilver AGP GART routines
+ *
+ * Copyright (c) 2006, Kyle McMartin <kyle@parisc-linux.org>
+ *
+ * Based on drivers/char/agpgart/hp-agp.c which is
+ * (c) Copyright 2002, 2003 Hewlett-Packard Development Company, L.P.
+ *      Bjorn Helgaas <bjorn.helgaas@hp.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/klist.h>
+#include <linux/agp_backend.h>
+
+#include <asm-parisc/parisc-device.h>
+#include <asm-parisc/ropes.h>
+
+#include "agp.h"
+
+#define DRVNAME "quicksilver"
+#define DRVPFX  DRVNAME ": "
+
+#ifndef log2
+#define log2(x)         ffz(~(x))
+#endif
+
+#define AGP8X_MODE_BIT          3
+#define AGP8X_MODE              (1 << AGP8X_MODE_BIT)
+
+static struct _parisc_agp_info {
+        void __iomem *ioc_regs;
+        void __iomem *lba_regs;
+
+        int lba_cap_offset;
+
+        u64 *gatt;
+        u64 gatt_entries;
+
+        u64 gart_base;
+        u64 gart_size;
+
+        int io_page_size;
+        int io_pages_per_kpage;
+} parisc_agp_info;
+
+static struct gatt_mask parisc_agp_masks[] =
+{
+        {
+                .mask = SBA_PDIR_VALID_BIT,
+                .type = 0
+        }
+};
+
+static struct aper_size_info_fixed parisc_agp_sizes[] =
+{
+        {0, 0, 0},              /* filled in by parisc_agp_fetch_size() */
+};
+
+static int
+parisc_agp_fetch_size(void)
+{
+        int size;
+
+        size = parisc_agp_info.gart_size / MB(1);
+        parisc_agp_sizes[0].size = size;
+        agp_bridge->current_size = (void *) &parisc_agp_sizes[0];
+
+        return size;
+}
+
+static int
+parisc_agp_configure(void)
+{
+        struct _parisc_agp_info *info = &parisc_agp_info;
+
+        agp_bridge->gart_bus_addr = info->gart_base;
+        agp_bridge->capndx = info->lba_cap_offset;
+        agp_bridge->mode = readl(info->lba_regs+info->lba_cap_offset+PCI_AGP_STATUS);
+
+        return 0;
+}
+
+static void
+parisc_agp_tlbflush(struct agp_memory *mem)
+{
+        struct _parisc_agp_info *info = &parisc_agp_info;
+
+        writeq(info->gart_base | log2(info->gart_size), info->ioc_regs+IOC_PCOM);
+        readq(info->ioc_regs+IOC_PCOM); /* flush */
+}
+
+static int
+parisc_agp_create_gatt_table(struct agp_bridge_data *bridge)
+{
+        struct _parisc_agp_info *info = &parisc_agp_info;
+        int i;
+
+        for (i = 0; i < info->gatt_entries; i++) {
+                info->gatt[i] = (unsigned long)agp_bridge->scratch_page;
+        }
+
+        return 0;
+}
+
+static int
+parisc_agp_free_gatt_table(struct agp_bridge_data *bridge)
+{
+        struct _parisc_agp_info *info = &parisc_agp_info;
+
+        info->gatt[0] = SBA_AGPGART_COOKIE;
+
+        return 0;
+}
+
+static int
+parisc_agp_insert_memory(struct agp_memory *mem, off_t pg_start, int type)
+{
+        struct _parisc_agp_info *info = &parisc_agp_info;
+        int i, k;
+        off_t j, io_pg_start;
+        int io_pg_count;
+
+        if (type != 0 || mem->type != 0) {
+                return -EINVAL;
+        }
+
+        io_pg_start = info->io_pages_per_kpage * pg_start;
+        io_pg_count = info->io_pages_per_kpage * mem->page_count;
+        if ((io_pg_start + io_pg_count) > info->gatt_entries) {
+                return -EINVAL;
+        }
+
+        j = io_pg_start;
+        while (j < (io_pg_start + io_pg_count)) {
+                if (info->gatt[j])
+                        return -EBUSY;
+                j++;
+        }
+
+        if (mem->is_flushed == FALSE) {
+                global_cache_flush();
+                mem->is_flushed = TRUE;
+        }
+
+        for (i = 0, j = io_pg_start; i < mem->page_count; i++) {
+                unsigned long paddr;
+
+                paddr = mem->memory[i];
+                for (k = 0;
+                     k < info->io_pages_per_kpage;
+                     k++, j++, paddr += info->io_page_size) {
+                        info->gatt[j] =
+                                agp_bridge->driver->mask_memory(agp_bridge,
+                                        paddr, type);
+                }
+        }
+
+        agp_bridge->driver->tlb_flush(mem);
+
+        return 0;
+}
+
+static int
+parisc_agp_remove_memory(struct agp_memory *mem, off_t pg_start, int type)
+{
+        struct _parisc_agp_info *info = &parisc_agp_info;
+        int i, io_pg_start, io_pg_count;
+
+        if (type != 0 || mem->type != 0) {
+                return -EINVAL;
+        }
+
+        io_pg_start = info->io_pages_per_kpage * pg_start;
+        io_pg_count = info->io_pages_per_kpage * mem->page_count;
+        for (i = io_pg_start; i < io_pg_count + io_pg_start; i++) {
+                info->gatt[i] = agp_bridge->scratch_page;
+        }
+
+        agp_bridge->driver->tlb_flush(mem);
+        return 0;
+}
+
+static unsigned long
+parisc_agp_mask_memory(struct agp_bridge_data *bridge,
+                    unsigned long addr, int type)
+{
+        return SBA_PDIR_VALID_BIT | addr;
+}
+
+static void
+parisc_agp_enable(struct agp_bridge_data *bridge, u32 mode)
+{
+        struct _parisc_agp_info *info = &parisc_agp_info;
+        u32 command;
+
+        command = readl(info->lba_regs + info->lba_cap_offset + PCI_AGP_STATUS);
+
+        command = agp_collect_device_status(bridge, mode, command);
+        command |= 0x00000100;
+
+        writel(command, info->lba_regs + info->lba_cap_offset + PCI_AGP_COMMAND);
+
+        agp_device_command(command, (mode & AGP8X_MODE) != 0);
+}
+
+struct agp_bridge_driver parisc_agp_driver = {
+        .owner                  = THIS_MODULE,
+        .size_type              = FIXED_APER_SIZE,
+        .configure              = parisc_agp_configure,
+        .fetch_size             = parisc_agp_fetch_size,
+        .tlb_flush              = parisc_agp_tlbflush,
+        .mask_memory            = parisc_agp_mask_memory,
+        .masks                  = parisc_agp_masks,
+        .agp_enable             = parisc_agp_enable,
+        .cache_flush            = global_cache_flush,
+        .create_gatt_table      = parisc_agp_create_gatt_table,
+        .free_gatt_table        = parisc_agp_free_gatt_table,
+        .insert_memory          = parisc_agp_insert_memory,
+        .remove_memory          = parisc_agp_remove_memory,
+        .alloc_by_type          = agp_generic_alloc_by_type,
+        .free_by_type           = agp_generic_free_by_type,
+        .agp_alloc_page         = agp_generic_alloc_page,
+        .agp_destroy_page       = agp_generic_destroy_page,
+        .cant_use_aperture      = 1,
+};
+
+static int __init
+agp_ioc_init(void __iomem *ioc_regs)
+{
+        struct _parisc_agp_info *info = &parisc_agp_info;
+        u64 *iova_base, *io_pdir, io_tlb_ps;
+        int io_tlb_shift;
+
+        printk(KERN_INFO DRVPFX "IO PDIR shared with sba_iommu\n");
+
+        info->ioc_regs = ioc_regs;
+
+        io_tlb_ps = readq(info->ioc_regs+IOC_TCNFG);
+        switch (io_tlb_ps) {
+        case 0: io_tlb_shift = 12; break;
+        case 1: io_tlb_shift = 13; break;
+        case 2: io_tlb_shift = 14; break;
+        case 3: io_tlb_shift = 16; break;
+        default:
+                printk(KERN_ERR DRVPFX "Invalid IOTLB page size "
+                       "configuration 0x%llx\n", io_tlb_ps);
+                info->gatt = NULL;
+                info->gatt_entries = 0;
+                return -ENODEV;
+        }
+        info->io_page_size = 1 << io_tlb_shift;
+        info->io_pages_per_kpage = PAGE_SIZE / info->io_page_size;
+
+        iova_base = readq(info->ioc_regs+IOC_IBASE) & ~0x1;
+        info->gart_base = iova_base + PLUTO_IOVA_SIZE - PLUTO_GART_SIZE;
+
+        info->gart_size = PLUTO_GART_SIZE;
+        info->gatt_entries = info->gart_size / info->io_page_size;
+
+        io_pdir = phys_to_virt(readq(info->ioc_regs+IOC_PDIR_BASE));
+        info->gatt = &io_pdir[(PLUTO_IOVA_SIZE/2) >> PAGE_SHIFT];
+
+        if (info->gatt[0] != SBA_AGPGART_COOKIE) {
+                info->gatt = NULL;
+                info->gatt_entries = 0;
+                printk(KERN_ERR DRVPFX "No reserved IO PDIR entry found; "
+                       "GART disabled\n");
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static int
+lba_find_capability(int cap)
+{
+        struct _parisc_agp_info *info = &parisc_agp_info;
+        u16 status;
+        u8 pos, id;
+        int ttl = 48;
+
+        status = readw(info->lba_regs + PCI_STATUS);
+        if (!(status & PCI_STATUS_CAP_LIST))
+                return 0;
+        pos = readb(info->lba_regs + PCI_CAPABILITY_LIST);
+        while (ttl-- && pos >= 0x40) {
+                pos &= ~3;
+                id = readb(info->lba_regs + pos + PCI_CAP_LIST_ID);
+                if (id == 0xff)
+                        break;
+                if (id == cap)
+                        return pos;
+                pos = readb(info->lba_regs + pos + PCI_CAP_LIST_NEXT);
+        }
+        return 0;
+}
+
+static int __init
+agp_lba_init(void __iomem *lba_hpa)
+{
+        struct _parisc_agp_info *info = &parisc_agp_info;
+        int cap;
+
+        info->lba_regs = lba_hpa;
+        info->lba_cap_offset = lba_find_capability(PCI_CAP_ID_AGP);
+
+        cap = readl(lba_hpa + info->lba_cap_offset) & 0xff;
+        if (cap != PCI_CAP_ID_AGP) {
+                printk(KERN_ERR DRVPFX "Invalid capability ID 0x%02x at 0x%x\n",
+                       cap, info->lba_cap_offset);
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static int __init
+parisc_agp_setup(void __iomem *ioc_hpa, void __iomem *lba_hpa)
+{
+        struct pci_dev *fake_bridge_dev = NULL;
+        struct agp_bridge_data *bridge;
+        int error = 0;
+
+        fake_bridge_dev = kmalloc(sizeof (struct pci_dev), GFP_KERNEL);
+        if (!fake_bridge_dev) {
+                error = -ENOMEM;
+                goto fail;
+        }
+
+        error = agp_ioc_init(ioc_hpa);
+        if (error)
+                goto fail;
+
+        error = agp_lba_init(lba_hpa);
+        if (error)
+                goto fail;
+
+        bridge = agp_alloc_bridge();
+        if (!bridge) {
+                error = -ENOMEM;
+                goto fail;
+        }
+        bridge->driver = &parisc_agp_driver;
+
+        fake_bridge_dev->vendor = PCI_VENDOR_ID_HP;
+        fake_bridge_dev->device = PCI_DEVICE_ID_HP_PCIX_LBA;
+        bridge->dev = fake_bridge_dev;
+
+        error = agp_add_bridge(bridge);
+
+fail:
+        return error;
+}
+
+static struct device *next_device(struct klist_iter *i) {
+        struct klist_node * n = klist_next(i);
+        return n ? container_of(n, struct device, knode_parent) : NULL;
+}
+
+static int
+parisc_agp_init(void)
+{
+        extern struct sba_device *sba_list;
+
+        int err = -1;
+        struct parisc_device *sba = NULL, *lba = NULL;
+        struct lba_device *lbadev = NULL;
+        struct device *dev = NULL;
+        struct klist_iter i;
+
+        if (!sba_list)
+                goto out;
+
+        /* Find our parent Pluto */
+        sba = sba_list->dev;
+        if (!IS_PLUTO(sba)) {
+                printk(KERN_INFO DRVPFX "No Pluto found, so no AGPGART for you.\n");
+                goto out;
+        }
+
+        /* Now search our Pluto for our precious AGP device... */
+        klist_iter_init(&sba->dev.klist_children, &i);
+        while ((dev = next_device(&i))) {
+                struct parisc_device *padev = to_parisc_device(dev);
+                if (IS_QUICKSILVER(padev))
+                        lba = padev;
+        }
+        klist_iter_exit(&i);
+
+        if (!lba) {
+                printk(KERN_INFO DRVPFX "No AGP devices found.\n");
+                goto out;
+        }
+
+        lbadev = parisc_get_drvdata(lba);
+
+        /* w00t, let's go find our cookies... */
+        parisc_agp_setup(sba_list->ioc[0].ioc_hpa, lbadev->hba.base_addr);
+
+        return 0;
+
+out:
+        return err;
+}
+
+module_init(parisc_agp_init);
+
+MODULE_AUTHOR("Kyle McMartin <kyle@parisc-linux.org>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/char/amiserial.c b/drivers/char/amiserial.c
index 9d6713a93ed7..feb4ac802a0d 100644
--- a/drivers/char/amiserial.c
+++ b/drivers/char/amiserial.c
@@ -104,7 +104,7 @@ static struct async_struct *IRQ_ports;
 
 static unsigned char current_ctl_bits;
 
-static void change_speed(struct async_struct *info, struct termios *old);
+static void change_speed(struct async_struct *info, struct ktermios *old);
 static void rs_wait_until_sent(struct tty_struct *tty, int timeout);
 
 
@@ -112,17 +112,6 @@ static struct serial_state rs_table[1];
 
 #define NR_PORTS ARRAY_SIZE(rs_table)
 
-/*
- * tmp_buf is used as a temporary buffer by serial_write.  We need to
- * lock it in case the copy_from_user 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;
-
 #include <asm/uaccess.h>
 
 #define serial_isroot() (capable(CAP_SYS_ADMIN))
@@ -458,7 +447,7 @@ static void check_modem_status(struct async_struct *info)
         }
 }
 
-static irqreturn_t ser_vbl_int( int irq, void *data, struct pt_regs *regs)
+static irqreturn_t ser_vbl_int( int irq, void *data)
 {
         /* vbl is just a periodic interrupt we tie into to update modem status */
         struct async_struct * info = IRQ_ports;
@@ -471,7 +460,7 @@ static irqreturn_t ser_vbl_int( int irq, void *data, struct pt_regs *regs)
         return IRQ_HANDLED;
 }
 
-static irqreturn_t ser_rx_int(int irq, void *dev_id, struct pt_regs * regs)
+static irqreturn_t ser_rx_int(int irq, void *dev_id)
 {
         struct async_struct * info;
 
@@ -491,7 +480,7 @@ static irqreturn_t ser_rx_int(int irq, void *dev_id, struct pt_regs * regs)
         return IRQ_HANDLED;
 }
 
-static irqreturn_t ser_tx_int(int irq, void *dev_id, struct pt_regs * regs)
+static irqreturn_t ser_tx_int(int irq, void *dev_id)
 {
         struct async_struct * info;
 
@@ -705,7 +694,7 @@ static void shutdown(struct async_struct * info)
  * the specified baud rate for a serial port.
  */
 static void change_speed(struct async_struct *info,
-                         struct termios *old_termios)
+                         struct ktermios *old_termios)
 {
         int     quot = 0, baud_base, baud;
         unsigned cflag, cval = 0;
@@ -912,7 +901,7 @@ static int rs_write(struct tty_struct * tty, const unsigned char *buf, int count
         if (serial_paranoia_check(info, tty->name, "rs_write"))
                 return 0;
 
-        if (!info->xmit.buf || !tmp_buf)
+        if (!info->xmit.buf)
                 return 0;
 
         local_save_flags(flags);
@@ -1376,7 +1365,7 @@ static int rs_ioctl(struct tty_struct *tty, struct file * file,
         return 0;
 }
 
-static void rs_set_termios(struct tty_struct *tty, struct termios *old_termios)
+static void rs_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
 {
         struct async_struct *info = (struct async_struct *)tty->driver_data;
         unsigned long flags;
@@ -1778,7 +1767,6 @@ static int rs_open(struct tty_struct *tty, struct file * filp)
 {
         struct async_struct     *info;
         int                     retval, line;
-        unsigned long           page;
 
         line = tty->index;
         if ((line < 0) || (line >= NR_PORTS)) {
@@ -1798,17 +1786,6 @@ static int rs_open(struct tty_struct *tty, struct file * filp)
 #endif
         info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
 
-        if (!tmp_buf) {
-                page = get_zeroed_page(GFP_KERNEL);
-                if (!page) {
-                        return -ENOMEM;
-                }
-                if (tmp_buf)
-                        free_page(page);
-                else
-                        tmp_buf = (unsigned char *) page;
-        }
-
         /*
          * If the port is the middle of closing, bail out now
          */
@@ -1958,7 +1935,7 @@ static void show_serial_version(void)
 }
 
 
-static struct tty_operations serial_ops = {
+static const struct tty_operations serial_ops = {
         .open = rs_open,
         .close = rs_close,
         .write = rs_write,
@@ -2090,11 +2067,6 @@ static __exit void rs_exit(void)
           kfree(info);
         }
 
-        if (tmp_buf) {
-                free_page((unsigned long) tmp_buf);
-                tmp_buf = NULL;
-        }
-
         release_mem_region(CUSTOM_PHYSADDR+0x30, 4);
 }
 
diff --git a/drivers/char/applicom.c b/drivers/char/applicom.c
index 10a389dafd60..1f0b752e5de1 100644
--- a/drivers/char/applicom.c
+++ b/drivers/char/applicom.c
@@ -110,7 +110,7 @@ static ssize_t ac_read (struct file *, char __user *, size_t, loff_t *);
 static ssize_t ac_write (struct file *, const char __user *, size_t, loff_t *);
 static int ac_ioctl(struct inode *, struct file *, unsigned int,
                     unsigned long);
-static irqreturn_t ac_interrupt(int, void *, struct pt_regs *);
+static irqreturn_t ac_interrupt(int, void *);
 
 static const struct file_operations ac_fops = {
         .owner = THIS_MODULE,
@@ -617,7 +617,7 @@ static ssize_t ac_read (struct file *filp, char __user *buf, size_t count, loff_
         } 
 }
 
-static irqreturn_t ac_interrupt(int vec, void *dev_instance, struct pt_regs *regs)
+static irqreturn_t ac_interrupt(int vec, void *dev_instance)
 {
         unsigned int i;
         unsigned int FlagInt;
diff --git a/drivers/char/briq_panel.c b/drivers/char/briq_panel.c
index b8c22255f6ad..9f8082f8dd29 100644
--- a/drivers/char/briq_panel.c
+++ b/drivers/char/briq_panel.c
@@ -11,7 +11,6 @@
 #include <linux/sched.h>
 #include <linux/tty.h>
 #include <linux/timer.h>
-#include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/wait.h>
 #include <linux/string.h>
diff --git a/drivers/char/cs5535_gpio.c b/drivers/char/cs5535_gpio.c
index 8ce3f34cfc22..c02d9e99e050 100644
--- a/drivers/char/cs5535_gpio.c
+++ b/drivers/char/cs5535_gpio.c
@@ -82,7 +82,7 @@ static inline u32 cs5535_lowhigh_base(int reg)
 static ssize_t cs5535_gpio_write(struct file *file, const char __user *data,
                                  size_t len, loff_t *ppos)
 {
-        u32     m = iminor(file->f_dentry->d_inode);
+        u32     m = iminor(file->f_path.dentry->d_inode);
         int     i, j;
         u32     base = gpio_base + cs5535_lowhigh_base(m);
         u32     m0, m1;
@@ -117,7 +117,7 @@ static ssize_t cs5535_gpio_write(struct file *file, const char __user *data,
 static ssize_t cs5535_gpio_read(struct file *file, char __user *buf,
                                 size_t len, loff_t *ppos)
 {
-        u32     m = iminor(file->f_dentry->d_inode);
+        u32     m = iminor(file->f_path.dentry->d_inode);
         u32     base = gpio_base + cs5535_lowhigh_base(m);
         int     rd_bit = 1 << (m & 0x0f);
         int     i;
diff --git a/drivers/char/cyclades.c b/drivers/char/cyclades.c
index c1c67281750d..3ffa0807754c 100644
--- a/drivers/char/cyclades.c
+++ b/drivers/char/cyclades.c
@@ -1,8 +1,6 @@
 #undef  BLOCKMOVE
 #define Z_WAKE
 #undef  Z_EXT_CHARS_IN_BUFFER
-static char rcsid[] =
-"$Revision: 2.3.2.20 $$Date: 2004/02/25 18:14:16 $";
 
 /*
  *  linux/drivers/char/cyclades.c
@@ -593,18 +591,20 @@ static char rcsid[] =
  *
  */
 
+#define CY_VERSION      "2.4"
+
 /* If you need to install more boards than NR_CARDS, change the constant
    in the definition below. No other change is necessary to support up to
    eight boards. Beyond that you'll have to extend cy_isa_addresses. */
 
-#define NR_CARDS        4
+#define NR_CARDS        4
 
 /*
    If the total number of ports is larger than NR_PORTS, change this
    constant in the definition below. No other change is necessary to
    support more boards/ports. */
 
-#define NR_PORTS        256
+#define NR_PORTS        256
 
 #define ZE_V1_NPORTS    64
 #define ZO_V1   0
@@ -625,9 +625,9 @@ static char rcsid[] =
 #undef  CY_PCI_DEBUG
 
 #if 0
-#define PAUSE __asm__("nop");
+#define PAUSE __asm__("nop")
 #else
-#define PAUSE ;
+#define PAUSE do {} while (0)
 #endif
 
 /*
@@ -663,7 +663,7 @@ static char rcsid[] =
                 do {                                            \
                 spin_lock_irqsave(&cy_card[info->card].card_lock, flags); \
                 } while (0)
-                
+
 #define CY_UNLOCK(info,flags)                                   \
                 do {                                            \
                 spin_unlock_irqrestore(&cy_card[info->card].card_lock, flags); \
@@ -676,14 +676,14 @@ static char rcsid[] =
 #include <linux/stat.h>
 #include <linux/proc_fs.h>
 
-static void cy_throttle (struct tty_struct *tty);
-static void cy_send_xchar (struct tty_struct *tty, char ch);
+static void cy_throttle(struct tty_struct *tty);
+static void cy_send_xchar(struct tty_struct *tty, char ch);
 
 #define IS_CYC_Z(card) ((card).num_chips == -1)
 
 #define Z_FPGA_CHECK(card) \
-    ((cy_readl(&((struct RUNTIME_9060 __iomem *) \
-                 ((card).ctl_addr))->init_ctrl) & (1<<17)) != 0)
+        ((cy_readl(&((struct RUNTIME_9060 __iomem *) \
+                ((card).ctl_addr))->init_ctrl) & (1<<17)) != 0)
 
 #define ISZLOADED(card) (((ZO_V1==cy_readl(&((struct RUNTIME_9060 __iomem *) \
                         ((card).ctl_addr))->mail_box_0)) || \
@@ -698,8 +698,6 @@ static void cy_send_xchar (struct tty_struct *tty, char ch);
 
 #define STD_COM_FLAGS (0)
 
-#define JIFFIES_DIFF(n, j)      ((j) - (n))
-
 static struct tty_driver *cy_serial_driver;
 
 #ifdef CONFIG_ISA
@@ -713,27 +711,28 @@ static struct tty_driver *cy_serial_driver;
 */
 
 static unsigned int cy_isa_addresses[] = {
-        0xD0000,
-        0xD2000,
-        0xD4000,
-        0xD6000,
-        0xD8000,
-        0xDA000,
-        0xDC000,
-        0xDE000,
-        0,0,0,0,0,0,0,0
+        0xD0000,
+        0xD2000,
+        0xD4000,
+        0xD6000,
+        0xD8000,
+        0xDA000,
+        0xDC000,
+        0xDE000,
+        0, 0, 0, 0, 0, 0, 0, 0
 };
+
 #define NR_ISA_ADDRS ARRAY_SIZE(cy_isa_addresses)
 
 #ifdef MODULE
 static long maddr[NR_CARDS] = { 0, };
-static int irq[NR_CARDS]  = { 0, };
+static int irq[NR_CARDS] = { 0, };
 
 module_param_array(maddr, long, NULL, 0);
 module_param_array(irq, int, NULL, 0);
 #endif
 
-#endif /* CONFIG_ISA */
+#endif                          /* CONFIG_ISA */
 
 /* This is the per-card data structure containing address, irq, number of
    channels, etc. This driver supports a maximum of NR_CARDS cards.
@@ -745,19 +744,7 @@ static struct cyclades_card cy_card[NR_CARDS];
 */
 static struct cyclades_port cy_port[NR_PORTS];
 
-static int cy_next_channel; /* next minor available */
-
-/*
- * tmp_buf is used as a temporary buffer by serial_write.  We need to
- * lock it in case the copy_from_user 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.  This buffer is
- * allocated when the first cy_open occurs.
- */
-static unsigned char *tmp_buf;
+static int cy_next_channel;     /* next minor available */
 
 /*
  * This is used to look up the divisor speeds and the timeouts
@@ -769,36 +756,42 @@ static unsigned char *tmp_buf;
  *     20
  */
 static int baud_table[] = {
-       0,    50,    75,   110,   134,   150,   200,   300,   600,  1200,
-    1800,  2400,  4800,  9600, 19200, 38400, 57600, 76800,115200,150000,
-  230400,     0};
-
-static char baud_co_25[] = {  /* 25 MHz clock option table */
-    /* value =>    00    01   02    03    04 */
-    /* divide by    8    32   128   512  2048 */
-    0x00,  0x04,  0x04,  0x04,  0x04,  0x04,  0x03,  0x03,  0x03,  0x02,
-    0x02,  0x02,  0x01,  0x01,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00};
-
-static char baud_bpr_25[] = {  /* 25 MHz baud rate period table */
-    0x00,  0xf5,  0xa3,  0x6f,  0x5c,  0x51,  0xf5,  0xa3,  0x51,  0xa3,
-    0x6d,  0x51,  0xa3,  0x51,  0xa3,  0x51,  0x36,  0x29,  0x1b,  0x15};
-
-static char baud_co_60[] = {  /* 60 MHz clock option table (CD1400 J) */
-    /* value =>    00    01   02    03    04 */
-    /* divide by    8    32   128   512  2048 */
-    0x00,  0x00,  0x00,  0x04,  0x04,  0x04,  0x04,  0x04,  0x03,  0x03,
-    0x03,  0x02,  0x02,  0x01,  0x01,  0x00,  0x00,  0x00,  0x00,  0x00,
-    0x00};
-
-static char baud_bpr_60[] = {  /* 60 MHz baud rate period table (CD1400 J) */
-    0x00,  0x82,  0x21,  0xff,  0xdb,  0xc3,  0x92,  0x62,  0xc3,  0x62,
-    0x41,  0xc3,  0x62,  0xc3,  0x62,  0xc3,  0x82,  0x62,  0x41,  0x32,
-    0x21};
-
-static char baud_cor3[] = {  /* receive threshold */
-    0x0a,  0x0a,  0x0a,  0x0a,  0x0a,  0x0a,  0x0a,  0x0a,  0x0a,  0x0a,
-    0x0a,  0x0a,  0x0a,  0x09,  0x09,  0x08,  0x08,  0x08,  0x08,  0x07,
-    0x07};
+        0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
+        1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800, 115200, 150000,
+        230400, 0
+};
+
+static char baud_co_25[] = {    /* 25 MHz clock option table */
+        /* value =>    00    01   02    03    04 */
+        /* divide by    8    32   128   512  2048 */
+        0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02,
+        0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+static char baud_bpr_25[] = {   /* 25 MHz baud rate period table */
+        0x00, 0xf5, 0xa3, 0x6f, 0x5c, 0x51, 0xf5, 0xa3, 0x51, 0xa3,
+        0x6d, 0x51, 0xa3, 0x51, 0xa3, 0x51, 0x36, 0x29, 0x1b, 0x15
+};
+
+static char baud_co_60[] = {    /* 60 MHz clock option table (CD1400 J) */
+        /* value =>    00    01   02    03    04 */
+        /* divide by    8    32   128   512  2048 */
+        0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03,
+        0x03, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00
+};
+
+static char baud_bpr_60[] = {   /* 60 MHz baud rate period table (CD1400 J) */
+        0x00, 0x82, 0x21, 0xff, 0xdb, 0xc3, 0x92, 0x62, 0xc3, 0x62,
+        0x41, 0xc3, 0x62, 0xc3, 0x62, 0xc3, 0x82, 0x62, 0x41, 0x32,
+        0x21
+};
+
+static char baud_cor3[] = {     /* receive threshold */
+        0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+        0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07,
+        0x07
+};
 
 /*
  * The Cyclades driver implements HW flow control as any serial driver.
@@ -811,42 +804,42 @@ static char baud_cor3[] = {  /* receive threshold */
  * cables.
  */
 
-static char rflow_thr[] = {  /* rflow threshold */
-    0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
-    0x00,  0x00,  0x00,  0x0a,  0x0a,  0x0a,  0x0a,  0x0a,  0x0a,  0x0a,
-    0x0a};
+static char rflow_thr[] = {     /* rflow threshold */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+        0x0a
+};
 
 /*  The Cyclom-Ye has placed the sequential chips in non-sequential
  *  address order.  This look-up table overcomes that problem.
  */
-static int cy_chip_offset [] =
-    { 0x0000,
-      0x0400,
-      0x0800,
-      0x0C00,
-      0x0200,
-      0x0600,
-      0x0A00,
-      0x0E00
-    };
+static int cy_chip_offset[] = { 0x0000,
+        0x0400,
+        0x0800,
+        0x0C00,
+        0x0200,
+        0x0600,
+        0x0A00,
+        0x0E00
+};
 
 /* PCI related definitions */
 
-static unsigned short   cy_pci_nboard;
-static unsigned short   cy_isa_nboard;
-static unsigned short   cy_nboard;
+static unsigned short cy_pci_nboard;
+static unsigned short cy_isa_nboard;
+static unsigned short cy_nboard;
 #ifdef CONFIG_PCI
-static unsigned short   cy_pci_dev_id[] = {
-                            PCI_DEVICE_ID_CYCLOM_Y_Lo,  /* PCI < 1Mb */
-                            PCI_DEVICE_ID_CYCLOM_Y_Hi,  /* PCI > 1Mb */
-                            PCI_DEVICE_ID_CYCLOM_4Y_Lo, /* 4Y PCI < 1Mb */
-                            PCI_DEVICE_ID_CYCLOM_4Y_Hi, /* 4Y PCI > 1Mb */
-                            PCI_DEVICE_ID_CYCLOM_8Y_Lo, /* 8Y PCI < 1Mb */
-                            PCI_DEVICE_ID_CYCLOM_8Y_Hi, /* 8Y PCI > 1Mb */
-                            PCI_DEVICE_ID_CYCLOM_Z_Lo,  /* Z PCI < 1Mb */
-                            PCI_DEVICE_ID_CYCLOM_Z_Hi,  /* Z PCI > 1Mb */
-                            0                           /* end of table */
-                        };
+static unsigned short cy_pci_dev_id[] = {
+        PCI_DEVICE_ID_CYCLOM_Y_Lo,      /* PCI < 1Mb */
+        PCI_DEVICE_ID_CYCLOM_Y_Hi,      /* PCI > 1Mb */
+        PCI_DEVICE_ID_CYCLOM_4Y_Lo,     /* 4Y PCI < 1Mb */
+        PCI_DEVICE_ID_CYCLOM_4Y_Hi,     /* 4Y PCI > 1Mb */
+        PCI_DEVICE_ID_CYCLOM_8Y_Lo,     /* 8Y PCI < 1Mb */
+        PCI_DEVICE_ID_CYCLOM_8Y_Hi,     /* 8Y PCI > 1Mb */
+        PCI_DEVICE_ID_CYCLOM_Z_Lo,      /* Z PCI < 1Mb */
+        PCI_DEVICE_ID_CYCLOM_Z_Hi,      /* Z PCI > 1Mb */
+        0                       /* end of table */
+};
 #endif
 
 static void cy_start(struct tty_struct *);
@@ -854,9 +847,9 @@ static void set_line_char(struct cyclades_port *);
 static int cyz_issue_cmd(struct cyclades_card *, uclong, ucchar, uclong);
 #ifdef CONFIG_ISA
 static unsigned detect_isa_irq(void __iomem *);
-#endif /* CONFIG_ISA */
+#endif                          /* CONFIG_ISA */
 
-static int cyclades_get_proc_info(char *, char **, off_t , int , int *, void *);
+static int cyclades_get_proc_info(char *, char **, off_t, int, int *, void *);
 
 #ifndef CONFIG_CYZ_INTR
 static void cyz_poll(unsigned long);
@@ -867,41 +860,36 @@ static long cyz_polling_cycle = CZ_DEF_POLL;
 static int cyz_timeron = 0;
 static DEFINE_TIMER(cyz_timerlist, cyz_poll, 0, 0);
 
-#else /* CONFIG_CYZ_INTR */
+#else                           /* CONFIG_CYZ_INTR */
 static void cyz_rx_restart(unsigned long);
 static struct timer_list cyz_rx_full_timer[NR_PORTS];
-#endif /* CONFIG_CYZ_INTR */
+#endif                          /* CONFIG_CYZ_INTR */
 
-static inline int
-serial_paranoia_check(struct cyclades_port *info,
-                        char *name, const char *routine)
+static inline int serial_paranoia_check(struct cyclades_port *info,
+                char *name, const char *routine)
 {
 #ifdef SERIAL_PARANOIA_CHECK
-    static const char *badmagic =
-        "cyc Warning: bad magic number for serial struct (%s) in %s\n";
-    static const char *badinfo =
-        "cyc Warning: null cyclades_port for (%s) in %s\n";
-    static const char *badrange =
-        "cyc Warning: cyclades_port out of range for (%s) in %s\n";
-
-    if (!info) {
-        printk(badinfo, name, routine);
-        return 1;
-    }
-
-    if( (long)info < (long)(&cy_port[0])
-    || (long)(&cy_port[NR_PORTS]) < (long)info ){
-        printk(badrange, name, routine);
-        return 1;
-    }
-
-    if (info->magic != CYCLADES_MAGIC) {
-        printk(badmagic, name, routine);
-        return 1;
-    }
+        if (!info) {
+                printk("cyc Warning: null cyclades_port for (%s) in %s\n",
+                                name, routine);
+                return 1;
+        }
+
+        if ((long)info < (long)(&cy_port[0]) ||
+                        (long)(&cy_port[NR_PORTS]) < (long)info) {
+                printk("cyc Warning: cyclades_port out of range for (%s) in "
+                                "%s\n", name, routine);
+                return 1;
+        }
+
+        if (info->magic != CYCLADES_MAGIC) {
+                printk("cyc Warning: bad magic number for serial struct (%s) "
+                                "in %s\n", name, routine);
+                return 1;
+        }
 #endif
-        return 0;
-} /* serial_paranoia_check */
+        return 0;
+}                               /* serial_paranoia_check */
 
 /*
  * This routine is used by the interrupt handler to schedule
@@ -909,13 +897,11 @@ serial_paranoia_check(struct cyclades_port *info,
  * (also known as the "bottom half").  This can be called any
  * number of times for any channel without harm.
  */
-static inline void
-cy_sched_event(struct cyclades_port *info, int event)
+static inline void cy_sched_event(struct cyclades_port *info, int event)
 {
-    info->event |= 1 << event; /* remember what kind of event and who */
-    schedule_work(&info->tqueue);
-} /* cy_sched_event */
-
+        info->event |= 1 << event; /* remember what kind of event and who */
+        schedule_work(&info->tqueue);
+}                               /* cy_sched_event */
 
 /*
  * This routine is used to handle the "bottom half" processing for the
@@ -938,44 +924,40 @@ cy_sched_event(struct cyclades_port *info, int event)
  * had to poll every port to see if that port needed servicing.
  */
 static void
-do_softint(void *private_)
+do_softint(struct work_struct *work)
 {
-  struct cyclades_port *info = (struct cyclades_port *) private_;
-  struct tty_struct    *tty;
-
-    tty = info->tty;
-    if (!tty)
-        return;
-
-    if (test_and_clear_bit(Cy_EVENT_HANGUP, &info->event)) {
-        tty_hangup(info->tty);
-        wake_up_interruptible(&info->open_wait);
-        info->flags &= ~ASYNC_NORMAL_ACTIVE;
-    }
-    if (test_and_clear_bit(Cy_EVENT_OPEN_WAKEUP, &info->event)) {
-        wake_up_interruptible(&info->open_wait);
-    }
+        struct cyclades_port *info =
+                container_of(work, struct cyclades_port, tqueue);
+        struct tty_struct    *tty;
+
+        tty = info->tty;
+        if (!tty)
+                return;
+
+        if (test_and_clear_bit(Cy_EVENT_HANGUP, &info->event)) {
+                tty_hangup(info->tty);
+                wake_up_interruptible(&info->open_wait);
+                        info->flags &= ~ASYNC_NORMAL_ACTIVE;
+        }
+        if (test_and_clear_bit(Cy_EVENT_OPEN_WAKEUP, &info->event))
+                wake_up_interruptible(&info->open_wait);
 #ifdef CONFIG_CYZ_INTR
-    if (test_and_clear_bit(Cy_EVENT_Z_RX_FULL, &info->event)) {
-        if (cyz_rx_full_timer[info->line].function == NULL) {
-            cyz_rx_full_timer[info->line].expires = jiffies + 1;
-            cyz_rx_full_timer[info->line].function = cyz_rx_restart;
-            cyz_rx_full_timer[info->line].data = (unsigned long)info;
-            add_timer(&cyz_rx_full_timer[info->line]);
+        if (test_and_clear_bit(Cy_EVENT_Z_RX_FULL, &info->event)) {
+                if (cyz_rx_full_timer[info->line].function == NULL) {
+                        cyz_rx_full_timer[info->line].expires = jiffies + 1;
+                        cyz_rx_full_timer[info->line].function = cyz_rx_restart;
+                        cyz_rx_full_timer[info->line].data =
+                                                (unsigned long)info;
+                        add_timer(&cyz_rx_full_timer[info->line]);
+                }
         }
-    }
 #endif
-    if (test_and_clear_bit(Cy_EVENT_DELTA_WAKEUP, &info->event)) {
-        wake_up_interruptible(&info->delta_msr_wait);
-    }
-    if (test_and_clear_bit(Cy_EVENT_WRITE_WAKEUP, &info->event)) {
-        tty_wakeup(tty);
-        wake_up_interruptible(&tty->write_wait);
-    }
+        if (test_and_clear_bit(Cy_EVENT_DELTA_WAKEUP, &info->event))
+                wake_up_interruptible(&info->delta_msr_wait);
+        tty_wakeup(tty);
 #ifdef Z_WAKE
-    if (test_and_clear_bit(Cy_EVENT_SHUTDOWN_WAKEUP, &info->event)) {
-        wake_up_interruptible(&info->shutdown_wait);
-    }
+        if (test_and_clear_bit(Cy_EVENT_SHUTDOWN_WAKEUP, &info->event))
+                wake_up_interruptible(&info->shutdown_wait);
 #endif
 } /* do_softint */
 
@@ -990,341 +972,339 @@ do_softint(void *private_)
 
    This function is only called from inside spinlock-protected code.
  */
-static int
-cyy_issue_cmd(void __iomem *base_addr, u_char cmd, int index)
+static int cyy_issue_cmd(void __iomem * base_addr, u_char cmd, int index)
 {
-  volatile int  i;
+        volatile int i;
 
-    /* Check to see that the previous command has completed */
-    for(i = 0 ; i < 100 ; i++){
-        if (cy_readb(base_addr+(CyCCR<<index)) == 0){
-            break;
+        /* Check to see that the previous command has completed */
+        for (i = 0; i < 100; i++) {
+                if (cy_readb(base_addr + (CyCCR << index)) == 0) {
+                        break;
+                }
+                udelay(10L);
         }
-        udelay(10L);
-    }
-    /* if the CCR never cleared, the previous command
-       didn't finish within the "reasonable time" */
-    if (i == 100)       return (-1);
+        /* if the CCR never cleared, the previous command
+           didn't finish within the "reasonable time" */
+        if (i == 100)
+                return -1;
 
-    /* Issue the new command */
-    cy_writeb(base_addr+(CyCCR<<index), cmd);
+        /* Issue the new command */
+        cy_writeb(base_addr + (CyCCR << index), cmd);
 
-    return(0);
-} /* cyy_issue_cmd */
+        return 0;
+}                               /* cyy_issue_cmd */
 
 #ifdef CONFIG_ISA
 /* ISA interrupt detection code */
-static unsigned 
-detect_isa_irq(void __iomem *address)
+static unsigned detect_isa_irq(void __iomem * address)
 {
-  int irq;
-  unsigned long irqs, flags;
-  int save_xir, save_car;
-  int index = 0; /* IRQ probing is only for ISA */
-
-    /* forget possible initially masked and pending IRQ */
-    irq = probe_irq_off(probe_irq_on());
-
-    /* Clear interrupts on the board first */
-    cy_writeb(address + (Cy_ClrIntr<<index), 0);
-                              /* Cy_ClrIntr is 0x1800 */
-
-    irqs = probe_irq_on();
-    /* Wait ... */
-    udelay(5000L);
-
-    /* Enable the Tx interrupts on the CD1400 */
-    local_irq_save(flags);
-        cy_writeb(address + (CyCAR<<index), 0);
-        cyy_issue_cmd(address, CyCHAN_CTL|CyENB_XMTR, index);
-
-        cy_writeb(address + (CyCAR<<index), 0);
-        cy_writeb(address + (CySRER<<index), 
-                cy_readb(address + (CySRER<<index)) | CyTxRdy);
-    local_irq_restore(flags);
-
-    /* Wait ... */
-    udelay(5000L);
-
-    /* Check which interrupt is in use */
-    irq = probe_irq_off(irqs);
-
-    /* Clean up */
-    save_xir = (u_char) cy_readb(address + (CyTIR<<index));
-    save_car = cy_readb(address + (CyCAR<<index));
-    cy_writeb(address + (CyCAR<<index), (save_xir & 0x3));
-    cy_writeb(address + (CySRER<<index),
-        cy_readb(address + (CySRER<<index)) & ~CyTxRdy);
-    cy_writeb(address + (CyTIR<<index), (save_xir & 0x3f));
-    cy_writeb(address + (CyCAR<<index), (save_car));
-    cy_writeb(address + (Cy_ClrIntr<<index), 0);
-                              /* Cy_ClrIntr is 0x1800 */
-
-    return (irq > 0)? irq : 0;
+        int irq;
+        unsigned long irqs, flags;
+        int save_xir, save_car;
+        int index = 0;          /* IRQ probing is only for ISA */
+
+        /* forget possible initially masked and pending IRQ */
+        irq = probe_irq_off(probe_irq_on());
+
+        /* Clear interrupts on the board first */
+        cy_writeb(address + (Cy_ClrIntr << index), 0);
+        /* Cy_ClrIntr is 0x1800 */
+
+        irqs = probe_irq_on();
+        /* Wait ... */
+        udelay(5000L);
+
+        /* Enable the Tx interrupts on the CD1400 */
+        local_irq_save(flags);
+        cy_writeb(address + (CyCAR << index), 0);
+        cyy_issue_cmd(address, CyCHAN_CTL | CyENB_XMTR, index);
+
+        cy_writeb(address + (CyCAR << index), 0);
+        cy_writeb(address + (CySRER << index),
+                  cy_readb(address + (CySRER << index)) | CyTxRdy);
+        local_irq_restore(flags);
+
+        /* Wait ... */
+        udelay(5000L);
+
+        /* Check which interrupt is in use */
+        irq = probe_irq_off(irqs);
+
+        /* Clean up */
+        save_xir = (u_char) cy_readb(address + (CyTIR << index));
+        save_car = cy_readb(address + (CyCAR << index));
+        cy_writeb(address + (CyCAR << index), (save_xir & 0x3));
+        cy_writeb(address + (CySRER << index),
+                  cy_readb(address + (CySRER << index)) & ~CyTxRdy);
+        cy_writeb(address + (CyTIR << index), (save_xir & 0x3f));
+        cy_writeb(address + (CyCAR << index), (save_car));
+        cy_writeb(address + (Cy_ClrIntr << index), 0);
+        /* Cy_ClrIntr is 0x1800 */
+
+        return (irq > 0) ? irq : 0;
 }
-#endif /* CONFIG_ISA */
+#endif                          /* CONFIG_ISA */
 
-/* The real interrupt service routine is called
-   whenever the card wants its hand held--chars
-   received, out buffer empty, modem change, etc.
- */
-static irqreturn_t
-cyy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
+                        void __iomem * base_addr, int status, int index)
 {
-  struct tty_struct *tty;
-  int status;
-  struct cyclades_card *cinfo;
-  struct cyclades_port *info;
-  void __iomem *base_addr, *card_base_addr;
-  int chip;
-  int save_xir, channel, save_car;
-  char data;
-  volatile int char_count;
-  int outch;
-  int i,j,index;
-  int too_many;
-  int had_work;
-  int mdm_change;
-  int mdm_status;
-  int len;
-    if((cinfo = (struct cyclades_card *)dev_id) == 0){
+        struct cyclades_port *info;
+        struct tty_struct *tty;
+        volatile int char_count;
+        int i, j, len, mdm_change, mdm_status, outch;
+        int save_xir, channel, save_car;
+        char data;
+
+        if (status & CySRReceive) {     /* reception interrupt */
 #ifdef CY_DEBUG_INTERRUPTS
-        printk("cyy_interrupt: spurious interrupt %d\n\r", irq);
+                printk("cyy_interrupt: rcvd intr, chip %d\n\r", chip);
 #endif
-        return IRQ_NONE; /* spurious interrupt */
-    }
-
-    card_base_addr = cinfo->base_addr;
-    index = cinfo->bus_index;
-
-
-    /* This loop checks all chips in the card.  Make a note whenever
-       _any_ chip had some work to do, as this is considered an
-       indication that there will be more to do.  Only when no chip
-       has any work does this outermost loop exit.
-     */
-    do{
-        had_work = 0;
-        for ( chip = 0 ; chip < cinfo->num_chips ; chip ++) {
-            base_addr = cinfo->base_addr + (cy_chip_offset[chip]<<index);
-            too_many = 0;
-            while ( (status = cy_readb(base_addr+(CySVRR<<index))) != 0x00) {
-                had_work++;
-                /* The purpose of the following test is to ensure that
-                   no chip can monopolize the driver.  This forces the
-                   chips to be checked in a round-robin fashion (after
-                   draining each of a bunch (1000) of characters).
-                 */
-                if(1000<too_many++){
-                    break;
-                }
-                if (status & CySRReceive) { /* reception interrupt */
-#ifdef CY_DEBUG_INTERRUPTS
-                    printk("cyy_interrupt: rcvd intr, chip %d\n\r", chip);
-#endif
-                    /* determine the channel & change to that context */
-                    spin_lock(&cinfo->card_lock);
-                    save_xir = (u_char) cy_readb(base_addr+(CyRIR<<index));
-                    channel = (u_short ) (save_xir & CyIRChannel);
-                    i = channel + chip * 4 + cinfo->first_line;
-                    info = &cy_port[i];
-                    info->last_active = jiffies;
-                    save_car = cy_readb(base_addr+(CyCAR<<index));
-                    cy_writeb(base_addr+(CyCAR<<index), save_xir);
-
-                    /* if there is nowhere to put the data, discard it */
-                    if(info->tty == 0){
-                        j = (cy_readb(base_addr+(CyRIVR<<index)) & CyIVRMask);
-                        if ( j == CyIVRRxEx ) { /* exception */
-                            data = cy_readb(base_addr+(CyRDSR<<index));
-                        } else { /* normal character reception */
-                            char_count = cy_readb(base_addr+(CyRDCR<<index));
-                            while(char_count--){
-                                data = cy_readb(base_addr+(CyRDSR<<index));
-                            }
-                        }
-                    }else{ /* there is an open port for this data */
-                        tty = info->tty;
-                        j = (cy_readb(base_addr+(CyRIVR<<index)) & CyIVRMask);
-                        if ( j == CyIVRRxEx ) { /* exception */
-                            data = cy_readb(base_addr+(CyRDSR<<index));
-
-                            /* For statistics only */
-                            if (data & CyBREAK)
-                                info->icount.brk++;
-                            else if(data & CyFRAME)
-                                info->icount.frame++;
-                            else if(data & CyPARITY)
-                                info->icount.parity++;
-                            else if(data & CyOVERRUN)
-                                info->icount.overrun++;
-
-                            if(data & info->ignore_status_mask){
-                                info->icount.rx++;
-                                continue;
-                            }
-                            if (tty_buffer_request_room(tty, 1)) {
-                                if (data & info->read_status_mask){
-                                    if(data & CyBREAK){
-                                        tty_insert_flip_char(tty, cy_readb(base_addr+(CyRDSR<<index)), TTY_BREAK);
-                                        info->icount.rx++;
-                                        if (info->flags & ASYNC_SAK){
-                                            do_SAK(tty);
-                                        }
-                                    }else if(data & CyFRAME){
-                                        tty_insert_flip_char(tty, cy_readb(base_addr+(CyRDSR<<index)), TTY_FRAME);
-                                        info->icount.rx++;
-                                        info->idle_stats.frame_errs++;
-                                    }else if(data & CyPARITY){
-                                        /* Pieces of seven... */
-                                        tty_insert_flip_char(tty, cy_readb(base_addr+(CyRDSR<<index)), TTY_PARITY);
-                                        info->icount.rx++;
-                                        info->idle_stats.parity_errs++;
-                                    }else if(data & CyOVERRUN){
-                                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                /* determine the channel & change to that context */
+                spin_lock(&cinfo->card_lock);
+                save_xir = (u_char) cy_readb(base_addr + (CyRIR << index));
+                channel = (u_short) (save_xir & CyIRChannel);
+                i = channel + chip * 4 + cinfo->first_line;
+                info = &cy_port[i];
+                info->last_active = jiffies;
+                save_car = cy_readb(base_addr + (CyCAR << index));
+                cy_writeb(base_addr + (CyCAR << index), save_xir);
+
+                /* if there is nowhere to put the data, discard it */
+                if (info->tty == 0) {
+                        j = (cy_readb(base_addr + (CyRIVR << index)) &
+                                CyIVRMask);
+                        if (j == CyIVRRxEx) {   /* exception */
+                                data = cy_readb(base_addr + (CyRDSR << index));
+                        } else {        /* normal character reception */
+                                char_count = cy_readb(base_addr +
+                                                (CyRDCR << index));
+                                while (char_count--) {
+                                        data = cy_readb(base_addr +
+                                                (CyRDSR << index));
+                                }
+                        }
+                } else {        /* there is an open port for this data */
+                        tty = info->tty;
+                        j = (cy_readb(base_addr + (CyRIVR << index)) &
+                                        CyIVRMask);
+                        if (j == CyIVRRxEx) {   /* exception */
+                                data = cy_readb(base_addr + (CyRDSR << index));
+
+                                /* For statistics only */
+                                if (data & CyBREAK)
+                                        info->icount.brk++;
+                                else if (data & CyFRAME)
+                                        info->icount.frame++;
+                                else if (data & CyPARITY)
+                                        info->icount.parity++;
+                                else if (data & CyOVERRUN)
+                                        info->icount.overrun++;
+
+                                if (data & info->ignore_status_mask) {
                                         info->icount.rx++;
-                                        /* If the flip buffer itself is
-                                           overflowing, we still lose
-                                           the next incoming character.
-                                         */
-                                        tty_insert_flip_char(tty, cy_readb(base_addr+(CyRDSR<<index)), TTY_FRAME);
-                                        info->icount.rx++;
+                                        return;
+                                }
+                                if (tty_buffer_request_room(tty, 1)) {
+                                        if (data & info->read_status_mask) {
+                                                if (data & CyBREAK) {
+                                                        tty_insert_flip_char(
+                                                                tty,
+                                                                cy_readb(
+                                                                base_addr +
+                                                                (CyRDSR <<
+                                                                        index)),
+                                                                TTY_BREAK);
+                                                        info->icount.rx++;
+                                                        if (info->flags &
+                                                            ASYNC_SAK) {
+                                                                do_SAK(tty);
+                                                        }
+                                                } else if (data & CyFRAME) {
+                                                        tty_insert_flip_char(
+                                                                tty,
+                                                                cy_readb(
+                                                                base_addr +
+                                                                (CyRDSR <<
+                                                                        index)),
+                                                                TTY_FRAME);
+                                                        info->icount.rx++;
+                                                        info->idle_stats.
+                                                                frame_errs++;
+                                                } else if (data & CyPARITY) {
+                                                        /* Pieces of seven... */
+                                                        tty_insert_flip_char(
+                                                                tty,
+                                                                cy_readb(
+                                                                base_addr +
+                                                                (CyRDSR <<
+                                                                        index)),
+                                                                TTY_PARITY);
+                                                        info->icount.rx++;
+                                                        info->idle_stats.
+                                                                parity_errs++;
+                                                } else if (data & CyOVERRUN) {
+                                                        tty_insert_flip_char(
+                                                                tty, 0,
+                                                                TTY_OVERRUN);
+                                                        info->icount.rx++;
+                                                /* If the flip buffer itself is
+                                                   overflowing, we still lose
+                                                   the next incoming character.
+                                                 */
+                                                        tty_insert_flip_char(
+                                                                tty,
+                                                                cy_readb(
+                                                                base_addr +
+                                                                (CyRDSR <<
+                                                                        index)),
+                                                                TTY_FRAME);
+                                                        info->icount.rx++;
+                                                        info->idle_stats.
+                                                                overruns++;
+                                        /* These two conditions may imply */
+                                        /* a normal read should be done. */
+                                        /* }else if(data & CyTIMEOUT){ */
+                                        /* }else if(data & CySPECHAR){ */
+                                                } else {
+                                                        tty_insert_flip_char(
+                                                                tty, 0,
+                                                                TTY_NORMAL);
+                                                        info->icount.rx++;
+                                                }
+                                        } else {
+                                                tty_insert_flip_char(tty, 0,
+                                                                TTY_NORMAL);
+                                                info->icount.rx++;
+                                        }
+                                } else {
+                                        /* there was a software buffer
+                                           overrun and nothing could be
+                                           done about it!!! */
+                                        info->icount.buf_overrun++;
                                         info->idle_stats.overruns++;
-                                    /* These two conditions may imply */
-                                    /* a normal read should be done. */
-                                    /* }else if(data & CyTIMEOUT){ */
-                                    /* }else if(data & CySPECHAR){ */
-                                    }else {
-                                        tty_insert_flip_char(tty, 0, TTY_NORMAL);
-                                        info->icount.rx++;
-                                    }
-                                }else{
-                                    tty_insert_flip_char(tty, 0, TTY_NORMAL);
-                                    info->icount.rx++;
-                                }
-                            }else{
-                                /* there was a software buffer
-                                   overrun and nothing could be
-                                   done about it!!! */
-                                info->icount.buf_overrun++;
-                                info->idle_stats.overruns++;
-                            }
-                        } else { /* normal character reception */
-                            /* load # chars available from the chip */
-                            char_count = cy_readb(base_addr+(CyRDCR<<index));
+                                }
+                        } else {        /* normal character reception */
+                                /* load # chars available from the chip */
+                                char_count = cy_readb(base_addr +
+                                                (CyRDCR << index));
 
 #ifdef CY_ENABLE_MONITORING
-                            ++info->mon.int_count;
-                            info->mon.char_count += char_count;
-                            if (char_count > info->mon.char_max)
-                               info->mon.char_max = char_count;
-                            info->mon.char_last = char_count;
+                                ++info->mon.int_count;
+                                info->mon.char_count += char_count;
+                                if (char_count > info->mon.char_max)
+                                        info->mon.char_max = char_count;
+                                info->mon.char_last = char_count;
 #endif
-                            len = tty_buffer_request_room(tty, char_count);
-                            while(len--){
-                                data = cy_readb(base_addr+(CyRDSR<<index));
-                                tty_insert_flip_char(tty, data, TTY_NORMAL);
-                                info->idle_stats.recv_bytes++;
-                                info->icount.rx++;
+                                len = tty_buffer_request_room(tty, char_count);
+                                while (len--) {
+                                        data = cy_readb(base_addr +
+                                                        (CyRDSR << index));
+                                        tty_insert_flip_char(tty, data,
+                                                        TTY_NORMAL);
+                                        info->idle_stats.recv_bytes++;
+                                        info->icount.rx++;
 #ifdef CY_16Y_HACK
-                                udelay(10L);
+                                        udelay(10L);
 #endif
-                            }
-                             info->idle_stats.recv_idle = jiffies;
-                        }
+                                }
+                                info->idle_stats.recv_idle = jiffies;
+                        }
                         tty_schedule_flip(tty);
-                    }
-                    /* end of service */
-                    cy_writeb(base_addr+(CyRIR<<index), (save_xir & 0x3f));
-                    cy_writeb(base_addr+(CyCAR<<index), (save_car));
-                    spin_unlock(&cinfo->card_lock);
-                }
-
-
-                if (status & CySRTransmit) { /* transmission interrupt */
-                    /* Since we only get here when the transmit buffer
-                       is empty, we know we can always stuff a dozen
-                       characters. */
+                }
+                /* end of service */
+                cy_writeb(base_addr + (CyRIR << index), (save_xir & 0x3f));
+                cy_writeb(base_addr + (CyCAR << index), (save_car));
+                spin_unlock(&cinfo->card_lock);
+        }
+
+        if (status & CySRTransmit) {    /* transmission interrupt */
+                /* Since we only get here when the transmit buffer
+                   is empty, we know we can always stuff a dozen
+                   characters. */
 #ifdef CY_DEBUG_INTERRUPTS
-                    printk("cyy_interrupt: xmit intr, chip %d\n\r", chip);
+                printk("cyy_interrupt: xmit intr, chip %d\n\r", chip);
 #endif
 
-                    /* determine the channel & change to that context */
-                    spin_lock(&cinfo->card_lock);
-                    save_xir = (u_char) cy_readb(base_addr+(CyTIR<<index));
-                    channel = (u_short ) (save_xir & CyIRChannel);
-                    i = channel + chip * 4 + cinfo->first_line;
-                    save_car = cy_readb(base_addr+(CyCAR<<index));
-                    cy_writeb(base_addr+(CyCAR<<index), save_xir);
-
-                    /* validate the port# (as configured and open) */
-                    if( (i < 0) || (NR_PORTS <= i) ){
-                        cy_writeb(base_addr+(CySRER<<index),
-                             cy_readb(base_addr+(CySRER<<index)) & ~CyTxRdy);
-                        goto txend;
-                    }
-                    info = &cy_port[i];
-                    info->last_active = jiffies;
-                    if(info->tty == 0){
-                        cy_writeb(base_addr+(CySRER<<index),
-                             cy_readb(base_addr+(CySRER<<index)) & ~CyTxRdy);
-                        goto txdone;
-                    }
-
-                    /* load the on-chip space for outbound data */
-                    char_count = info->xmit_fifo_size;
-
-                    if(info->x_char) { /* send special char */
-                        outch = info->x_char;
-                        cy_writeb(base_addr+(CyTDR<<index), outch);
-                        char_count--;
+                /* determine the channel & change to that context */
+                spin_lock(&cinfo->card_lock);
+                save_xir = (u_char) cy_readb(base_addr + (CyTIR << index));
+                channel = (u_short) (save_xir & CyIRChannel);
+                i = channel + chip * 4 + cinfo->first_line;
+                save_car = cy_readb(base_addr + (CyCAR << index));
+                cy_writeb(base_addr + (CyCAR << index), save_xir);
+
+                /* validate the port# (as configured and open) */
+                if ((i < 0) || (NR_PORTS <= i)) {
+                        cy_writeb(base_addr + (CySRER << index),
+                                  cy_readb(base_addr + (CySRER << index)) &
+                                  ~CyTxRdy);
+                        goto txend;
+                }
+                info = &cy_port[i];
+                info->last_active = jiffies;
+                if (info->tty == 0) {
+                        cy_writeb(base_addr + (CySRER << index),
+                                  cy_readb(base_addr + (CySRER << index)) &
+                                  ~CyTxRdy);
+                        goto txdone;
+                }
+
+                /* load the on-chip space for outbound data */
+                char_count = info->xmit_fifo_size;
+
+                if (info->x_char) {     /* send special char */
+                        outch = info->x_char;
+                        cy_writeb(base_addr + (CyTDR << index), outch);
+                        char_count--;
                         info->icount.tx++;
-                        info->x_char = 0;
-                    }
+                        info->x_char = 0;
+                }
 
-                    if (info->breakon || info->breakoff) {
+                if (info->breakon || info->breakoff) {
                         if (info->breakon) {
-                            cy_writeb(base_addr + (CyTDR<<index), 0); 
-                            cy_writeb(base_addr + (CyTDR<<index), 0x81);
-                            info->breakon = 0;
-                            char_count -= 2;
+                                cy_writeb(base_addr + (CyTDR << index), 0);
+                                cy_writeb(base_addr + (CyTDR << index), 0x81);
+                                info->breakon = 0;
+                                char_count -= 2;
                         }
                         if (info->breakoff) {
-                            cy_writeb(base_addr + (CyTDR<<index), 0); 
-                            cy_writeb(base_addr + (CyTDR<<index), 0x83);
-                            info->breakoff = 0;
-                            char_count -= 2;
+                                cy_writeb(base_addr + (CyTDR << index), 0);
+                                cy_writeb(base_addr + (CyTDR << index), 0x83);
+                                info->breakoff = 0;
+                                char_count -= 2;
                         }
-                    }
-
-                    while (char_count-- > 0){
-                        if (!info->xmit_cnt){
-                            if (cy_readb(base_addr+(CySRER<<index))&CyTxMpty) {
-                                cy_writeb(base_addr+(CySRER<<index),
-                                          cy_readb(base_addr+(CySRER<<index)) &
-                                          ~CyTxMpty);
-                            } else {
-                                cy_writeb(base_addr+(CySRER<<index),
-                                          ((cy_readb(base_addr+(CySRER<<index))
-                                            & ~CyTxRdy)
-                                           | CyTxMpty));
-                            }
-                            goto txdone;
+                }
+
+                while (char_count-- > 0) {
+                        if (!info->xmit_cnt) {
+                                if (cy_readb(base_addr + (CySRER << index)) &
+                                                CyTxMpty) {
+                                        cy_writeb(base_addr + (CySRER << index),
+                                                cy_readb(base_addr +
+                                                        (CySRER << index)) &
+                                                ~CyTxMpty);
+                                } else {
+                                        cy_writeb(base_addr + (CySRER << index),
+                                                (cy_readb(base_addr +
+                                                        (CySRER << index)) &
+                                                ~CyTxRdy) | CyTxMpty);
+                                }
+                                goto txdone;
                         }
-                        if (info->xmit_buf == 0){
-                            cy_writeb(base_addr+(CySRER<<index),
-                                cy_readb(base_addr+(CySRER<<index)) & 
+                        if (info->xmit_buf == 0) {
+                                cy_writeb(base_addr + (CySRER << index),
+                                        cy_readb(base_addr + (CySRER << index))&
                                         ~CyTxRdy);
-                            goto txdone;
+                                goto txdone;
                         }
-                        if (info->tty->stopped || info->tty->hw_stopped){
-                            cy_writeb(base_addr+(CySRER<<index),
-                                cy_readb(base_addr+(CySRER<<index)) & 
+                        if (info->tty->stopped || info->tty->hw_stopped) {
+                                cy_writeb(base_addr + (CySRER << index),
+                                        cy_readb(base_addr + (CySRER << index))&
                                         ~CyTxRdy);
-                            goto txdone;
+                                goto txdone;
                         }
-                        /* Because the Embedded Transmit Commands have
-                           been enabled, we must check to see if the
+                        /* Because the Embedded Transmit Commands have
+                           been enabled, we must check to see if the
                            escape character, NULL, is being sent.  If it
                            is, we must ensure that there is room for it
                            to be doubled in the output stream.  Therefore
@@ -1333,125 +1313,182 @@ cyy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                            after the check for a NULL output character.
                            This is necessary because there may not be
                            room for the two chars needed to send a NULL.)
-                         */
-                        outch = info->xmit_buf[info->xmit_tail];
-                        if( outch ){
-                            info->xmit_cnt--;
-                            info->xmit_tail = (info->xmit_tail + 1)
-                                                      & (SERIAL_XMIT_SIZE - 1);
-                            cy_writeb(base_addr+(CyTDR<<index), outch);
-                            info->icount.tx++;
-                        }else{
-                            if(char_count > 1){
-                                info->xmit_cnt--;
-                                info->xmit_tail = (info->xmit_tail + 1)
-                                                      & (SERIAL_XMIT_SIZE - 1);
-                                cy_writeb(base_addr+(CyTDR<<index), 
-                                          outch);
-                                cy_writeb(base_addr+(CyTDR<<index), 0);
+                         */
+                        outch = info->xmit_buf[info->xmit_tail];
+                        if (outch) {
+                                info->xmit_cnt--;
+                                info->xmit_tail = (info->xmit_tail + 1) &
+                                                (SERIAL_XMIT_SIZE - 1);
+                                cy_writeb(base_addr + (CyTDR << index), outch);
                                 info->icount.tx++;
-                                char_count--;
-                            }else{
-                            }
-                        }
-                    }
-
-        txdone:
-                    if (info->xmit_cnt < WAKEUP_CHARS) {
-                        cy_sched_event(info, Cy_EVENT_WRITE_WAKEUP);
-                    }
-        txend:
-                    /* end of service */
-                    cy_writeb(base_addr+(CyTIR<<index), 
-                              (save_xir & 0x3f));
-                    cy_writeb(base_addr+(CyCAR<<index), (save_car));
-                    spin_unlock(&cinfo->card_lock);
-                }
-
-                if (status & CySRModem) {        /* modem interrupt */
-
-                    /* determine the channel & change to that context */
-                    spin_lock(&cinfo->card_lock);
-                    save_xir = (u_char) cy_readb(base_addr+(CyMIR<<index));
-                    channel = (u_short ) (save_xir & CyIRChannel);
-                    info = &cy_port[channel + chip * 4
-                                           + cinfo->first_line];
-                    info->last_active = jiffies;
-                    save_car = cy_readb(base_addr+(CyCAR<<index));
-                    cy_writeb(base_addr+(CyCAR<<index), save_xir);
-
-                    mdm_change = cy_readb(base_addr+(CyMISR<<index));
-                    mdm_status = cy_readb(base_addr+(CyMSVR1<<index));
-
-                    if(info->tty == 0){/* no place for data, ignore it*/
-                        ;
-                    }else{
+                        } else {
+                                if (char_count > 1) {
+                                        info->xmit_cnt--;
+                                        info->xmit_tail = (info->xmit_tail + 1)&
+                                                (SERIAL_XMIT_SIZE - 1);
+                                        cy_writeb(base_addr + (CyTDR << index),
+                                                outch);
+                                        cy_writeb(base_addr + (CyTDR << index),
+                                                0);
+                                        info->icount.tx++;
+                                        char_count--;
+                                } else {
+                                }
+                        }
+                }
+
+txdone:
+                if (info->xmit_cnt < WAKEUP_CHARS) {
+                        cy_sched_event(info, Cy_EVENT_WRITE_WAKEUP);
+                }
+txend:
+                /* end of service */
+                cy_writeb(base_addr + (CyTIR << index), (save_xir & 0x3f));
+                cy_writeb(base_addr + (CyCAR << index), (save_car));
+                spin_unlock(&cinfo->card_lock);
+        }
+
+        if (status & CySRModem) {       /* modem interrupt */
+
+                /* determine the channel & change to that context */
+                spin_lock(&cinfo->card_lock);
+                save_xir = (u_char) cy_readb(base_addr + (CyMIR << index));
+                channel = (u_short) (save_xir & CyIRChannel);
+                info = &cy_port[channel + chip * 4 + cinfo->first_line];
+                info->last_active = jiffies;
+                save_car = cy_readb(base_addr + (CyCAR << index));
+                cy_writeb(base_addr + (CyCAR << index), save_xir);
+
+                mdm_change = cy_readb(base_addr + (CyMISR << index));
+                mdm_status = cy_readb(base_addr + (CyMSVR1 << index));
+
+                if (info->tty == 0) {   /* no place for data, ignore it */
+                        ;
+                } else {
                         if (mdm_change & CyANY_DELTA) {
-                            /* For statistics only */
-                            if (mdm_change & CyDCD)     info->icount.dcd++;
-                            if (mdm_change & CyCTS)     info->icount.cts++;
-                            if (mdm_change & CyDSR)     info->icount.dsr++;
-                            if (mdm_change & CyRI)      info->icount.rng++;
+                                /* For statistics only */
+                                if (mdm_change & CyDCD)
+                                        info->icount.dcd++;
+                                if (mdm_change & CyCTS)
+                                        info->icount.cts++;
+                                if (mdm_change & CyDSR)
+                                        info->icount.dsr++;
+                                if (mdm_change & CyRI)
+                                        info->icount.rng++;
+
+                                cy_sched_event(info, Cy_EVENT_DELTA_WAKEUP);
+                        }
+
+                        if ((mdm_change & CyDCD) &&
+                                        (info->flags & ASYNC_CHECK_CD)) {
+                                if (mdm_status & CyDCD) {
+                                        cy_sched_event(info,
+                                                        Cy_EVENT_OPEN_WAKEUP);
+                                } else {
+                                        cy_sched_event(info, Cy_EVENT_HANGUP);
+                                }
+                        }
+                        if ((mdm_change & CyCTS) &&
+                                        (info->flags & ASYNC_CTS_FLOW)) {
+                                if (info->tty->hw_stopped) {
+                                        if (mdm_status & CyCTS) {
+                                                /* cy_start isn't used
+                                                   because... !!! */
+                                                info->tty->hw_stopped = 0;
+                                                cy_writeb(base_addr +
+                                                        (CySRER << index),
+                                                        cy_readb(base_addr +
+                                                                (CySRER <<
+                                                                        index))|
+                                                        CyTxRdy);
+                                                cy_sched_event(info,
+                                                        Cy_EVENT_WRITE_WAKEUP);
+                                        }
+                                } else {
+                                        if (!(mdm_status & CyCTS)) {
+                                                /* cy_stop isn't used
+                                                   because ... !!! */
+                                                info->tty->hw_stopped = 1;
+                                                cy_writeb(base_addr +
+                                                        (CySRER << index),
+                                                        cy_readb(base_addr +
+                                                                (CySRER <<
+                                                                index)) &
+                                                        ~CyTxRdy);
+                                        }
+                                }
+                        }
+                        if (mdm_change & CyDSR) {
+                        }
+                        if (mdm_change & CyRI) {
+                        }
+                }
+                /* end of service */
+                cy_writeb(base_addr + (CyMIR << index), (save_xir & 0x3f));
+                cy_writeb(base_addr + (CyCAR << index), save_car);
+                spin_unlock(&cinfo->card_lock);
+        }
+}
+
+/* The real interrupt service routine is called
+   whenever the card wants its hand held--chars
+   received, out buffer empty, modem change, etc.
+ */
+static irqreturn_t cyy_interrupt(int irq, void *dev_id)
+{
+        int status;
+        struct cyclades_card *cinfo;
+        void __iomem *base_addr, *card_base_addr;
+        int chip;
+        int index;
+        int too_many;
+        int had_work;
+
+        if ((cinfo = (struct cyclades_card *)dev_id) == 0) {
+#ifdef CY_DEBUG_INTERRUPTS
+                printk("cyy_interrupt: spurious interrupt %d\n\r", irq);
+#endif
+                return IRQ_NONE;        /* spurious interrupt */
+        }
+
+        card_base_addr = cinfo->base_addr;
+        index = cinfo->bus_index;
 
-                            cy_sched_event(info, Cy_EVENT_DELTA_WAKEUP);
+        /* This loop checks all chips in the card.  Make a note whenever
+           _any_ chip had some work to do, as this is considered an
+           indication that there will be more to do.  Only when no chip
+           has any work does this outermost loop exit.
+         */
+        do {
+                had_work = 0;
+                for (chip = 0; chip < cinfo->num_chips; chip++) {
+                        base_addr = cinfo->base_addr +
+                                        (cy_chip_offset[chip] << index);
+                        too_many = 0;
+                        while ((status = cy_readb(base_addr +
+                                                (CySVRR << index))) != 0x00) {
+                                had_work++;
+                        /* The purpose of the following test is to ensure that
+                           no chip can monopolize the driver.  This forces the
+                           chips to be checked in a round-robin fashion (after
+                           draining each of a bunch (1000) of characters).
+                         */
+                                if (1000 < too_many++) {
+                                        break;
+                                }
+                                cyy_intr_chip(cinfo, chip, base_addr, status,
+                                                index);
                         }
+                }
+        } while (had_work);
 
-                        if((mdm_change & CyDCD)
-                        && (info->flags & ASYNC_CHECK_CD)){
-                            if(mdm_status & CyDCD){
-                                cy_sched_event(info,
-                                    Cy_EVENT_OPEN_WAKEUP);
-                            }else{
-                                cy_sched_event(info,
-                                    Cy_EVENT_HANGUP);
-                            }
-                        }
-                        if((mdm_change & CyCTS)
-                        && (info->flags & ASYNC_CTS_FLOW)){
-                            if(info->tty->hw_stopped){
-                                if(mdm_status & CyCTS){
-                                    /* cy_start isn't used
-                                         because... !!! */
-                                    info->tty->hw_stopped = 0;
-                                  cy_writeb(base_addr+(CySRER<<index),
-                                       cy_readb(base_addr+(CySRER<<index)) | 
-                                       CyTxRdy);
-                                    cy_sched_event(info,
-                                        Cy_EVENT_WRITE_WAKEUP);
-                                }
-                            }else{
-                                if(!(mdm_status & CyCTS)){
-                                    /* cy_stop isn't used
-                                         because ... !!! */
-                                    info->tty->hw_stopped = 1;
-                                  cy_writeb(base_addr+(CySRER<<index),
-                                       cy_readb(base_addr+(CySRER<<index)) & 
-                                       ~CyTxRdy);
-                                }
-                            }
-                        }
-                        if(mdm_change & CyDSR){
-                        }
-                        if(mdm_change & CyRI){
-                        }
-                    }
-                    /* end of service */
-                    cy_writeb(base_addr+(CyMIR<<index), 
-                              (save_xir & 0x3f));
-                    cy_writeb(base_addr+(CyCAR<<index), save_car);
-                    spin_unlock(&cinfo->card_lock);
-                }
-            }          /* end while status != 0 */
-        }            /* end loop for chips... */
-    } while(had_work);
-
-   /* clear interrupts */
-   spin_lock(&cinfo->card_lock);
-   cy_writeb(card_base_addr + (Cy_ClrIntr<<index), 0);
-                                /* Cy_ClrIntr is 0x1800 */
-   spin_unlock(&cinfo->card_lock);
-   return IRQ_HANDLED;
-} /* cyy_interrupt */
+        /* clear interrupts */
+        spin_lock(&cinfo->card_lock);
+        cy_writeb(card_base_addr + (Cy_ClrIntr << index), 0);
+        /* Cy_ClrIntr is 0x1800 */
+        spin_unlock(&cinfo->card_lock);
+        return IRQ_HANDLED;
+}                               /* cyy_interrupt */
 
 /***********************************************************/
 /********* End of block of Cyclom-Y specific code **********/
@@ -1459,643 +1496,655 @@ cyy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 /***********************************************************/
 
 static int
-cyz_fetch_msg( struct cyclades_card *cinfo,
-            uclong *channel, ucchar *cmd, uclong *param)
+cyz_fetch_msg(struct cyclades_card *cinfo,
+                uclong * channel, ucchar * cmd, uclong * param)
 {
-  struct FIRM_ID __iomem *firm_id;
-  struct ZFW_CTRL __iomem *zfw_ctrl;
-  struct BOARD_CTRL __iomem *board_ctrl;
-  unsigned long loc_doorbell;
-
-    firm_id = cinfo->base_addr + ID_ADDRESS;
-    if (!ISZLOADED(*cinfo)){
-        return (-1);
-    }
-    zfw_ctrl = cinfo->base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-    board_ctrl = &zfw_ctrl->board_ctrl;
-
-    loc_doorbell = cy_readl(&((struct RUNTIME_9060 __iomem *)
-                     (cinfo->ctl_addr))->loc_doorbell);
-    if (loc_doorbell){
-        *cmd = (char)(0xff & loc_doorbell);
-        *channel = cy_readl(&board_ctrl->fwcmd_channel);
-        *param = (uclong)cy_readl(&board_ctrl->fwcmd_param);
-        cy_writel(&((struct RUNTIME_9060 __iomem *)(cinfo->ctl_addr))->loc_doorbell, 
-                 0xffffffff);
-        return 1;
-    }
-    return 0;
-} /* cyz_fetch_msg */
+        struct FIRM_ID __iomem *firm_id;
+        struct ZFW_CTRL __iomem *zfw_ctrl;
+        struct BOARD_CTRL __iomem *board_ctrl;
+        unsigned long loc_doorbell;
+
+        firm_id = cinfo->base_addr + ID_ADDRESS;
+        if (!ISZLOADED(*cinfo)) {
+                return -1;
+        }
+        zfw_ctrl = cinfo->base_addr + (cy_readl(&firm_id->zfwctrl_addr) &
+                        0xfffff);
+        board_ctrl = &zfw_ctrl->board_ctrl;
+
+        loc_doorbell = cy_readl(&((struct RUNTIME_9060 __iomem *)
+                                  (cinfo->ctl_addr))->loc_doorbell);
+        if (loc_doorbell) {
+                *cmd = (char)(0xff & loc_doorbell);
+                *channel = cy_readl(&board_ctrl->fwcmd_channel);
+                *param = (uclong) cy_readl(&board_ctrl->fwcmd_param);
+                cy_writel(&((struct RUNTIME_9060 __iomem *)(cinfo->ctl_addr))->
+                          loc_doorbell, 0xffffffff);
+                return 1;
+        }
+        return 0;
+}                               /* cyz_fetch_msg */
 
 static int
-cyz_issue_cmd( struct cyclades_card *cinfo,
-            uclong channel, ucchar cmd, uclong param)
+cyz_issue_cmd(struct cyclades_card *cinfo,
+                uclong channel, ucchar cmd, uclong param)
 {
-  struct FIRM_ID __iomem *firm_id;
-  struct ZFW_CTRL __iomem *zfw_ctrl;
-  struct BOARD_CTRL __iomem *board_ctrl;
-  unsigned long __iomem *pci_doorbell;
-  int index;
-
-    firm_id = cinfo->base_addr + ID_ADDRESS;
-    if (!ISZLOADED(*cinfo)){
-        return (-1);
-    }
-    zfw_ctrl = cinfo->base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-    board_ctrl = &zfw_ctrl->board_ctrl;
-
-    index = 0;
-    pci_doorbell = &((struct RUNTIME_9060 __iomem *) (cinfo->ctl_addr))->pci_doorbell;
-    while( (cy_readl(pci_doorbell) & 0xff) != 0){
-        if (index++ == 1000){
-            return((int)(cy_readl(pci_doorbell) & 0xff));
-        }
-        udelay(50L);
-    }
-    cy_writel(&board_ctrl->hcmd_channel, channel);
-    cy_writel(&board_ctrl->hcmd_param , param);
-    cy_writel(pci_doorbell, (long)cmd);
-
-    return(0);
-} /* cyz_issue_cmd */
+        struct FIRM_ID __iomem *firm_id;
+        struct ZFW_CTRL __iomem *zfw_ctrl;
+        struct BOARD_CTRL __iomem *board_ctrl;
+        unsigned long __iomem *pci_doorbell;
+        int index;
+
+        firm_id = cinfo->base_addr + ID_ADDRESS;
+        if (!ISZLOADED(*cinfo)) {
+                return -1;
+        }
+        zfw_ctrl = cinfo->base_addr + (cy_readl(&firm_id->zfwctrl_addr) &
+                        0xfffff);
+        board_ctrl = &zfw_ctrl->board_ctrl;
+
+        index = 0;
+        pci_doorbell =
+            &((struct RUNTIME_9060 __iomem *)(cinfo->ctl_addr))->pci_doorbell;
+        while ((cy_readl(pci_doorbell) & 0xff) != 0) {
+                if (index++ == 1000) {
+                        return (int)(cy_readl(pci_doorbell) & 0xff);
+                }
+                udelay(50L);
+        }
+        cy_writel(&board_ctrl->hcmd_channel, channel);
+        cy_writel(&board_ctrl->hcmd_param, param);
+        cy_writel(pci_doorbell, (long)cmd);
+
+        return 0;
+}                               /* cyz_issue_cmd */
 
 static void
 cyz_handle_rx(struct cyclades_port *info,
-              volatile struct CH_CTRL __iomem *ch_ctrl,
-              volatile struct BUF_CTRL __iomem *buf_ctrl)
+                volatile struct CH_CTRL __iomem * ch_ctrl,
+                volatile struct BUF_CTRL __iomem * buf_ctrl)
 {
-  struct cyclades_card *cinfo = &cy_card[info->card];
-  struct tty_struct *tty = info->tty;
-  volatile int char_count;
-  int len;
+        struct cyclades_card *cinfo = &cy_card[info->card];
+        struct tty_struct *tty = info->tty;
+        volatile int char_count;
+        int len;
 #ifdef BLOCKMOVE
-  int small_count;
+        int small_count;
 #else
-  char data;
+        char data;
 #endif
-  volatile uclong rx_put, rx_get, new_rx_get, rx_bufsize, rx_bufaddr;
+        volatile uclong rx_put, rx_get, new_rx_get, rx_bufsize, rx_bufaddr;
 
-    rx_get = new_rx_get = cy_readl(&buf_ctrl->rx_get);
-    rx_put = cy_readl(&buf_ctrl->rx_put);
-    rx_bufsize = cy_readl(&buf_ctrl->rx_bufsize);
-    rx_bufaddr = cy_readl(&buf_ctrl->rx_bufaddr);
-    if (rx_put >= rx_get)
-        char_count = rx_put - rx_get;
-    else
-        char_count = rx_put - rx_get + rx_bufsize;
+        rx_get = new_rx_get = cy_readl(&buf_ctrl->rx_get);
+        rx_put = cy_readl(&buf_ctrl->rx_put);
+        rx_bufsize = cy_readl(&buf_ctrl->rx_bufsize);
+        rx_bufaddr = cy_readl(&buf_ctrl->rx_bufaddr);
+        if (rx_put >= rx_get)
+                char_count = rx_put - rx_get;
+        else
+                char_count = rx_put - rx_get + rx_bufsize;
 
-    if ( char_count ) {
-        info->last_active = jiffies;
-        info->jiffies[1] = jiffies;
+        if (char_count) {
+                info->last_active = jiffies;
+                info->jiffies[1] = jiffies;
 
 #ifdef CY_ENABLE_MONITORING
-        info->mon.int_count++;
-        info->mon.char_count += char_count;
-        if (char_count > info->mon.char_max)
-            info->mon.char_max = char_count;
-        info->mon.char_last = char_count;
+                info->mon.int_count++;
+                info->mon.char_count += char_count;
+                if (char_count > info->mon.char_max)
+                        info->mon.char_max = char_count;
+                info->mon.char_last = char_count;
 #endif
-        if(tty == 0){
-            /* flush received characters */
-            new_rx_get = (new_rx_get + char_count) & (rx_bufsize - 1);
-            info->rflush_count++;
-        }else{
+                if (tty == 0) {
+                        /* flush received characters */
+                        new_rx_get = (new_rx_get + char_count) &
+                                        (rx_bufsize - 1);
+                        info->rflush_count++;
+                } else {
 #ifdef BLOCKMOVE
-            /* we'd like to use memcpy(t, f, n) and memset(s, c, count)
-               for performance, but because of buffer boundaries, there
-               may be several steps to the operation */
-            while(0 < (small_count = 
-                       min_t(unsigned int, (rx_bufsize - new_rx_get),
-                       min_t(unsigned int, (TTY_FLIPBUF_SIZE - tty->flip.count), char_count))
-                 )) {
-                memcpy_fromio(tty->flip.char_buf_ptr,
-                              (char *)(cinfo->base_addr
-                                       + rx_bufaddr + new_rx_get),
-                              small_count);
-
-                tty->flip.char_buf_ptr += small_count;
-                memset(tty->flip.flag_buf_ptr, TTY_NORMAL, small_count);
-                tty->flip.flag_buf_ptr += small_count;
-                new_rx_get = (new_rx_get + small_count) & (rx_bufsize - 1);
-                char_count -= small_count;
-                info->icount.rx += small_count;
-                info->idle_stats.recv_bytes += small_count;
-                tty->flip.count += small_count;
-            }
+                /* we'd like to use memcpy(t, f, n) and memset(s, c, count)
+                   for performance, but because of buffer boundaries, there
+                   may be several steps to the operation */
+                        while (0 < (small_count = min_t(unsigned int,
+                                        rx_bufsize - new_rx_get,
+                                        min_t(unsigned int, TTY_FLIPBUF_SIZE -
+                                                tty->flip.count, char_count)))){
+                                memcpy_fromio(tty->flip.char_buf_ptr,
+                                        (char *)(cinfo->base_addr + rx_bufaddr +
+                                                new_rx_get),
+                                        small_count);
+
+                                tty->flip.char_buf_ptr += small_count;
+                                memset(tty->flip.flag_buf_ptr, TTY_NORMAL,
+                                        small_count);
+                                tty->flip.flag_buf_ptr += small_count;
+                                new_rx_get = (new_rx_get + small_count) &
+                                                (rx_bufsize - 1);
+                                char_count -= small_count;
+                                info->icount.rx += small_count;
+                                info->idle_stats.recv_bytes += small_count;
+                                tty->flip.count += small_count;
+                        }
 #else
-            len = tty_buffer_request_room(tty, char_count);
-            while(len--){
-                data = cy_readb(cinfo->base_addr + rx_bufaddr + new_rx_get);
-                new_rx_get = (new_rx_get + 1) & (rx_bufsize - 1);
-                tty_insert_flip_char(tty, data, TTY_NORMAL);
-                info->idle_stats.recv_bytes++;
-                info->icount.rx++;
-            }
+                        len = tty_buffer_request_room(tty, char_count);
+                        while (len--) {
+                                data = cy_readb(cinfo->base_addr + rx_bufaddr +
+                                                new_rx_get);
+                                new_rx_get = (new_rx_get + 1)& (rx_bufsize - 1);
+                                tty_insert_flip_char(tty, data, TTY_NORMAL);
+                                info->idle_stats.recv_bytes++;
+                                info->icount.rx++;
+                        }
 #endif
 #ifdef CONFIG_CYZ_INTR
-            /* Recalculate the number of chars in the RX buffer and issue
-               a cmd in case it's higher than the RX high water mark */
-            rx_put = cy_readl(&buf_ctrl->rx_put);
-            if (rx_put >= rx_get)
-                char_count = rx_put - rx_get;
-            else
-                char_count = rx_put - rx_get + rx_bufsize;
-            if(char_count >= cy_readl(&buf_ctrl->rx_threshold)) {
-                cy_sched_event(info, Cy_EVENT_Z_RX_FULL);
-            }
+                /* Recalculate the number of chars in the RX buffer and issue
+                   a cmd in case it's higher than the RX high water mark */
+                        rx_put = cy_readl(&buf_ctrl->rx_put);
+                        if (rx_put >= rx_get)
+                                char_count = rx_put - rx_get;
+                        else
+                                char_count = rx_put - rx_get + rx_bufsize;
+                        if (char_count >= (int)cy_readl(&buf_ctrl->
+                                        rx_threshold)) {
+                                cy_sched_event(info, Cy_EVENT_Z_RX_FULL);
+                        }
 #endif
-            info->idle_stats.recv_idle = jiffies;
-            tty_schedule_flip(tty);
+                        info->idle_stats.recv_idle = jiffies;
+                        tty_schedule_flip(tty);
+                }
+                /* Update rx_get */
+                cy_writel(&buf_ctrl->rx_get, new_rx_get);
         }
-        /* Update rx_get */
-        cy_writel(&buf_ctrl->rx_get, new_rx_get);
-    }
 }
 
 static void
 cyz_handle_tx(struct cyclades_port *info,
-              volatile struct CH_CTRL __iomem *ch_ctrl,
-              volatile struct BUF_CTRL __iomem *buf_ctrl)
+                volatile struct CH_CTRL __iomem * ch_ctrl,
+                volatile struct BUF_CTRL __iomem * buf_ctrl)
 {
-  struct cyclades_card *cinfo = &cy_card[info->card];
-  struct tty_struct *tty = info->tty;
-  char data;
-  volatile int char_count;
+        struct cyclades_card *cinfo = &cy_card[info->card];
+        struct tty_struct *tty = info->tty;
+        char data;
+        volatile int char_count;
 #ifdef BLOCKMOVE
-  int small_count;
+        int small_count;
 #endif
-  volatile uclong tx_put, tx_get, tx_bufsize, tx_bufaddr;
+        volatile uclong tx_put, tx_get, tx_bufsize, tx_bufaddr;
 
-    if (info->xmit_cnt <= 0)    /* Nothing to transmit */
-        return;
+        if (info->xmit_cnt <= 0)        /* Nothing to transmit */
+                return;
 
-    tx_get = cy_readl(&buf_ctrl->tx_get);
-    tx_put = cy_readl(&buf_ctrl->tx_put);
-    tx_bufsize = cy_readl(&buf_ctrl->tx_bufsize);
-    tx_bufaddr = cy_readl(&buf_ctrl->tx_bufaddr);
-    if (tx_put >= tx_get)
-        char_count = tx_get - tx_put - 1 + tx_bufsize;
-    else
-        char_count = tx_get - tx_put - 1;
+        tx_get = cy_readl(&buf_ctrl->tx_get);
+        tx_put = cy_readl(&buf_ctrl->tx_put);
+        tx_bufsize = cy_readl(&buf_ctrl->tx_bufsize);
+        tx_bufaddr = cy_readl(&buf_ctrl->tx_bufaddr);
+        if (tx_put >= tx_get)
+                char_count = tx_get - tx_put - 1 + tx_bufsize;
+        else
+                char_count = tx_get - tx_put - 1;
 
-    if ( char_count ) {
+        if (char_count) {
 
-        if( tty == 0 ){
-            goto ztxdone;
-        }
+                if (tty == 0) {
+                        goto ztxdone;
+                }
 
-        if(info->x_char) { /* send special char */
-            data = info->x_char;
+                if (info->x_char) {     /* send special char */
+                        data = info->x_char;
 
-            cy_writeb((cinfo->base_addr + tx_bufaddr + tx_put), data);
-            tx_put = (tx_put + 1) & (tx_bufsize - 1);
-            info->x_char = 0;
-            char_count--;
-            info->icount.tx++;
-            info->last_active = jiffies;
-            info->jiffies[2] = jiffies;
-        }
+                        cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
+                        tx_put = (tx_put + 1) & (tx_bufsize - 1);
+                        info->x_char = 0;
+                        char_count--;
+                        info->icount.tx++;
+                        info->last_active = jiffies;
+                        info->jiffies[2] = jiffies;
+                }
 #ifdef BLOCKMOVE
-        while(0 < (small_count = 
-                   min_t(unsigned int, (tx_bufsize - tx_put),
-                       min_t(unsigned int, (SERIAL_XMIT_SIZE - info->xmit_tail),
-                           min_t(unsigned int, info->xmit_cnt, char_count))))) {
-
-            memcpy_toio((char *)(cinfo->base_addr + tx_bufaddr + tx_put),
-                        &info->xmit_buf[info->xmit_tail],
-                        small_count);
-
-            tx_put = (tx_put + small_count) & (tx_bufsize - 1);
-            char_count -= small_count;
-            info->icount.tx += small_count;
-            info->xmit_cnt -= small_count;
-            info->xmit_tail = 
-                (info->xmit_tail + small_count) & (SERIAL_XMIT_SIZE - 1);
-            info->last_active = jiffies;
-            info->jiffies[2] = jiffies;
-        }
+                while (0 < (small_count = min_t(unsigned int,
+                                tx_bufsize - tx_put, min_t(unsigned int,
+                                        (SERIAL_XMIT_SIZE - info->xmit_tail),
+                                        min_t(unsigned int, info->xmit_cnt,
+                                                char_count))))) {
+
+                        memcpy_toio((char *)(cinfo->base_addr + tx_bufaddr +
+                                        tx_put),
+                                        &info->xmit_buf[info->xmit_tail],
+                                        small_count);
+
+                        tx_put = (tx_put + small_count) & (tx_bufsize - 1);
+                        char_count -= small_count;
+                        info->icount.tx += small_count;
+                        info->xmit_cnt -= small_count;
+                        info->xmit_tail = (info->xmit_tail + small_count) &
+                                        (SERIAL_XMIT_SIZE - 1);
+                        info->last_active = jiffies;
+                        info->jiffies[2] = jiffies;
+                }
 #else
-        while (info->xmit_cnt && char_count){
-            data = info->xmit_buf[info->xmit_tail];
-            info->xmit_cnt--;
-            info->xmit_tail = (info->xmit_tail + 1) & (SERIAL_XMIT_SIZE - 1);
-
-            cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
-            tx_put = (tx_put + 1) & (tx_bufsize - 1);
-            char_count--;
-            info->icount.tx++;
-            info->last_active = jiffies;
-            info->jiffies[2] = jiffies;
-        }
+                while (info->xmit_cnt && char_count) {
+                        data = info->xmit_buf[info->xmit_tail];
+                        info->xmit_cnt--;
+                        info->xmit_tail = (info->xmit_tail + 1) &
+                                        (SERIAL_XMIT_SIZE - 1);
+
+                        cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
+                        tx_put = (tx_put + 1) & (tx_bufsize - 1);
+                        char_count--;
+                        info->icount.tx++;
+                        info->last_active = jiffies;
+                        info->jiffies[2] = jiffies;
+                }
 #endif
-    ztxdone:
-        if (info->xmit_cnt < WAKEUP_CHARS) {
-            cy_sched_event(info, Cy_EVENT_WRITE_WAKEUP);
+ztxdone:
+                if (info->xmit_cnt < WAKEUP_CHARS) {
+                        cy_sched_event(info, Cy_EVENT_WRITE_WAKEUP);
+                }
+                /* Update tx_put */
+                cy_writel(&buf_ctrl->tx_put, tx_put);
         }
-        /* Update tx_put */
-        cy_writel(&buf_ctrl->tx_put, tx_put);
-    }
 }
 
-static void
-cyz_handle_cmd(struct cyclades_card *cinfo)
+static void cyz_handle_cmd(struct cyclades_card *cinfo)
 {
-  struct tty_struct *tty;
-  struct cyclades_port *info;
-  static volatile struct FIRM_ID __iomem *firm_id;
-  static volatile struct ZFW_CTRL __iomem *zfw_ctrl;
-  static volatile struct BOARD_CTRL __iomem *board_ctrl;
-  static volatile struct CH_CTRL __iomem *ch_ctrl;
-  static volatile struct BUF_CTRL __iomem *buf_ctrl;
-  uclong channel;
-  ucchar cmd;
-  uclong param;
-  uclong hw_ver, fw_ver;
-  int special_count;
-  int delta_count;
-
-    firm_id = cinfo->base_addr + ID_ADDRESS;
-    zfw_ctrl = cinfo->base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-    board_ctrl = &zfw_ctrl->board_ctrl;
-    fw_ver = cy_readl(&board_ctrl->fw_version);
-    hw_ver = cy_readl(&((struct RUNTIME_9060 __iomem *)(cinfo->ctl_addr))->mail_box_0);
-
-
-    while(cyz_fetch_msg(cinfo, &channel, &cmd, &param) == 1) {
-        special_count = 0;
-        delta_count = 0;
-        info = &cy_port[channel + cinfo->first_line];
-        if((tty = info->tty) == 0) {
-            continue;
-        }
-        ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
-        buf_ctrl = &(zfw_ctrl->buf_ctrl[channel]);
-
-        switch(cmd) {
-            case C_CM_PR_ERROR:
-                tty_insert_flip_char(tty, 0, TTY_PARITY);
-                info->icount.rx++;
-                special_count++;
-                break;
-            case C_CM_FR_ERROR:
-                tty_insert_flip_char(tty, 0, TTY_FRAME);
-                info->icount.rx++;
-                special_count++;
-                break;
-            case C_CM_RXBRK:
-                tty_insert_flip_char(tty, 0, TTY_BREAK);
-                info->icount.rx++;
-                special_count++;
-                break;
-            case C_CM_MDCD:
-                info->icount.dcd++;
-                delta_count++;
-                if (info->flags & ASYNC_CHECK_CD){
-                    if ((fw_ver > 241 ? 
-                          ((u_long)param) : 
-                          cy_readl(&ch_ctrl->rs_status)) & C_RS_DCD) {
-                        cy_sched_event(info, Cy_EVENT_OPEN_WAKEUP);
-                    }else{
-                        cy_sched_event(info, Cy_EVENT_HANGUP);
-                    }
+        struct tty_struct *tty;
+        struct cyclades_port *info;
+        static volatile struct FIRM_ID __iomem *firm_id;
+        static volatile struct ZFW_CTRL __iomem *zfw_ctrl;
+        static volatile struct BOARD_CTRL __iomem *board_ctrl;
+        static volatile struct CH_CTRL __iomem *ch_ctrl;
+        static volatile struct BUF_CTRL __iomem *buf_ctrl;
+        uclong channel;
+        ucchar cmd;
+        uclong param;
+        uclong hw_ver, fw_ver;
+        int special_count;
+        int delta_count;
+
+        firm_id = cinfo->base_addr + ID_ADDRESS;
+        zfw_ctrl = cinfo->base_addr + (cy_readl(&firm_id->zfwctrl_addr) &
+                        0xfffff);
+        board_ctrl = &zfw_ctrl->board_ctrl;
+        fw_ver = cy_readl(&board_ctrl->fw_version);
+        hw_ver = cy_readl(&((struct RUNTIME_9060 __iomem *)(cinfo->ctl_addr))->
+                        mail_box_0);
+
+        while (cyz_fetch_msg(cinfo, &channel, &cmd, &param) == 1) {
+                special_count = 0;
+                delta_count = 0;
+                info = &cy_port[channel + cinfo->first_line];
+                if ((tty = info->tty) == 0) {
+                        continue;
                 }
-                break;
-            case C_CM_MCTS:
-                info->icount.cts++;
-                delta_count++;
-                break;
-            case C_CM_MRI:
-                info->icount.rng++;
-                delta_count++;
-                break;
-            case C_CM_MDSR:
-                info->icount.dsr++;
-                delta_count++;
-                break;
+                ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
+                buf_ctrl = &(zfw_ctrl->buf_ctrl[channel]);
+
+                switch (cmd) {
+                case C_CM_PR_ERROR:
+                        tty_insert_flip_char(tty, 0, TTY_PARITY);
+                        info->icount.rx++;
+                        special_count++;
+                        break;
+                case C_CM_FR_ERROR:
+                        tty_insert_flip_char(tty, 0, TTY_FRAME);
+                        info->icount.rx++;
+                        special_count++;
+                        break;
+                case C_CM_RXBRK:
+                        tty_insert_flip_char(tty, 0, TTY_BREAK);
+                        info->icount.rx++;
+                        special_count++;
+                        break;
+                case C_CM_MDCD:
+                        info->icount.dcd++;
+                        delta_count++;
+                        if (info->flags & ASYNC_CHECK_CD) {
+                                if ((fw_ver > 241 ? ((u_long) param) :
+                                                cy_readl(&ch_ctrl->rs_status)) &
+                                                C_RS_DCD) {
+                                        cy_sched_event(info,
+                                                        Cy_EVENT_OPEN_WAKEUP);
+                                } else {
+                                        cy_sched_event(info, Cy_EVENT_HANGUP);
+                                }
+                        }
+                        break;
+                case C_CM_MCTS:
+                        info->icount.cts++;
+                        delta_count++;
+                        break;
+                case C_CM_MRI:
+                        info->icount.rng++;
+                        delta_count++;
+                        break;
+                case C_CM_MDSR:
+                        info->icount.dsr++;
+                        delta_count++;
+                        break;
 #ifdef Z_WAKE
-            case C_CM_IOCTLW:
-                cy_sched_event(info, Cy_EVENT_SHUTDOWN_WAKEUP);
-                break;
+                case C_CM_IOCTLW:
+                        cy_sched_event(info, Cy_EVENT_SHUTDOWN_WAKEUP);
+                        break;
 #endif
 #ifdef CONFIG_CYZ_INTR
-            case C_CM_RXHIWM:
-            case C_CM_RXNNDT:
-            case C_CM_INTBACK2:
-                /* Reception Interrupt */
+                case C_CM_RXHIWM:
+                case C_CM_RXNNDT:
+                case C_CM_INTBACK2:
+                        /* Reception Interrupt */
 #ifdef CY_DEBUG_INTERRUPTS
-                printk("cyz_interrupt: rcvd intr, card %d, port %ld\n\r", 
-                        info->card, channel);
+                        printk("cyz_interrupt: rcvd intr, card %d, "
+                                        "port %ld\n\r", info->card, channel);
 #endif
-                cyz_handle_rx(info, ch_ctrl, buf_ctrl);
-                break;
-            case C_CM_TXBEMPTY:
-            case C_CM_TXLOWWM:
-            case C_CM_INTBACK:
-                /* Transmission Interrupt */
+                        cyz_handle_rx(info, ch_ctrl, buf_ctrl);
+                        break;
+                case C_CM_TXBEMPTY:
+                case C_CM_TXLOWWM:
+                case C_CM_INTBACK:
+                        /* Transmission Interrupt */
 #ifdef CY_DEBUG_INTERRUPTS
-                printk("cyz_interrupt: xmit intr, card %d, port %ld\n\r", 
-                        info->card, channel);
+                        printk("cyz_interrupt: xmit intr, card %d, "
+                                        "port %ld\n\r", info->card, channel);
 #endif
-                cyz_handle_tx(info, ch_ctrl, buf_ctrl);
-                break;
-#endif /* CONFIG_CYZ_INTR */
-            case C_CM_FATAL:
-                /* should do something with this !!! */
-                break;
-            default:
-                break;
+                        cyz_handle_tx(info, ch_ctrl, buf_ctrl);
+                        break;
+#endif                          /* CONFIG_CYZ_INTR */
+                case C_CM_FATAL:
+                        /* should do something with this !!! */
+                        break;
+                default:
+                        break;
+                }
+                if (delta_count)
+                        cy_sched_event(info, Cy_EVENT_DELTA_WAKEUP);
+                if (special_count)
+                        tty_schedule_flip(tty);
         }
-        if(delta_count)
-            cy_sched_event(info, Cy_EVENT_DELTA_WAKEUP);
-        if(special_count)
-            tty_schedule_flip(tty);
-    }
 }
 
 #ifdef CONFIG_CYZ_INTR
-static irqreturn_t
-cyz_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t cyz_interrupt(int irq, void *dev_id)
 {
-  struct cyclades_card *cinfo;
+        struct cyclades_card *cinfo;
 
-    if((cinfo = (struct cyclades_card *)dev_id) == 0){
+        if ((cinfo = (struct cyclades_card *)dev_id) == 0) {
 #ifdef CY_DEBUG_INTERRUPTS
-        printk("cyz_interrupt: spurious interrupt %d\n\r", irq);
+                printk("cyz_interrupt: spurious interrupt %d\n\r", irq);
 #endif
-        return IRQ_NONE; /* spurious interrupt */
-    }
+                return IRQ_NONE;        /* spurious interrupt */
+        }
 
-    if (!ISZLOADED(*cinfo)) {
+        if (!ISZLOADED(*cinfo)) {
 #ifdef CY_DEBUG_INTERRUPTS
-        printk("cyz_interrupt: board not yet loaded (IRQ%d).\n\r", irq);
+                printk("cyz_interrupt: board not yet loaded (IRQ%d).\n\r", irq);
 #endif
-        return IRQ_NONE;
-    }
+                return IRQ_NONE;
+        }
 
-    /* Handle the interrupts */
-    cyz_handle_cmd(cinfo);
+        /* Handle the interrupts */
+        cyz_handle_cmd(cinfo);
 
-    return IRQ_HANDLED;
-} /* cyz_interrupt */
+        return IRQ_HANDLED;
+}                               /* cyz_interrupt */
 
-static void
-cyz_rx_restart(unsigned long arg)
+static void cyz_rx_restart(unsigned long arg)
 {
-    struct cyclades_port *info = (struct cyclades_port *)arg;
-    int retval;
-    int card = info->card;
-    uclong channel = (info->line) - (cy_card[card].first_line);
-    unsigned long flags;
-
-    CY_LOCK(info, flags);
-    retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_INTBACK2, 0L);
-    if (retval != 0){
-        printk("cyc:cyz_rx_restart retval on ttyC%d was %x\n", 
-               info->line, retval);
-    }
-    cyz_rx_full_timer[info->line].function = NULL;
-    CY_UNLOCK(info, flags);
+        struct cyclades_port *info = (struct cyclades_port *)arg;
+        int retval;
+        int card = info->card;
+        uclong channel = (info->line) - (cy_card[card].first_line);
+        unsigned long flags;
+
+        CY_LOCK(info, flags);
+        retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_INTBACK2, 0L);
+        if (retval != 0) {
+                printk("cyc:cyz_rx_restart retval on ttyC%d was %x\n",
+                        info->line, retval);
+        }
+        cyz_rx_full_timer[info->line].function = NULL;
+        CY_UNLOCK(info, flags);
 }
 
-#else /* CONFIG_CYZ_INTR */
+#else                           /* CONFIG_CYZ_INTR */
 
-static void
-cyz_poll(unsigned long arg)
+static void cyz_poll(unsigned long arg)
 {
-  struct cyclades_card *cinfo;
-  struct cyclades_port *info;
-  struct tty_struct *tty;
-  static volatile struct FIRM_ID *firm_id;
-  static volatile struct ZFW_CTRL *zfw_ctrl;
-  static volatile struct BOARD_CTRL *board_ctrl;
-  static volatile struct CH_CTRL *ch_ctrl;
-  static volatile struct BUF_CTRL *buf_ctrl;
-  int card, port;
-
-    cyz_timerlist.expires = jiffies + (HZ);
-    for (card = 0 ; card < NR_CARDS ; card++){
-        cinfo = &cy_card[card];
-
-        if (!IS_CYC_Z(*cinfo)) continue;
-        if (!ISZLOADED(*cinfo)) continue;
+        struct cyclades_card *cinfo;
+        struct cyclades_port *info;
+        struct tty_struct *tty;
+        static volatile struct FIRM_ID *firm_id;
+        static volatile struct ZFW_CTRL *zfw_ctrl;
+        static volatile struct BOARD_CTRL *board_ctrl;
+        static volatile struct CH_CTRL *ch_ctrl;
+        static volatile struct BUF_CTRL *buf_ctrl;
+        int card, port;
 
-        firm_id = cinfo->base_addr + ID_ADDRESS;
-        zfw_ctrl = cinfo->base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-        board_ctrl = &(zfw_ctrl->board_ctrl);
+        cyz_timerlist.expires = jiffies + (HZ);
+        for (card = 0; card < NR_CARDS; card++) {
+                cinfo = &cy_card[card];
+
+                if (!IS_CYC_Z(*cinfo))
+                        continue;
+                if (!ISZLOADED(*cinfo))
+                        continue;
+
+                firm_id = cinfo->base_addr + ID_ADDRESS;
+                zfw_ctrl = cinfo->base_addr +
+                                (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+                board_ctrl = &(zfw_ctrl->board_ctrl);
 
         /* Skip first polling cycle to avoid racing conditions with the FW */
-        if (!cinfo->intr_enabled) {
-            cinfo->nports = (int) cy_readl(&board_ctrl->n_channel);
-            cinfo->intr_enabled = 1;
-            continue;
-        }
+                if (!cinfo->intr_enabled) {
+                        cinfo->nports = (int)cy_readl(&board_ctrl->n_channel);
+                        cinfo->intr_enabled = 1;
+                        continue;
+                }
 
-        cyz_handle_cmd(cinfo);
+                cyz_handle_cmd(cinfo);
 
-        for (port = 0 ; port < cinfo->nports ; port++) {
-            info = &cy_port[ port + cinfo->first_line ];
-            tty = info->tty;
-            ch_ctrl = &(zfw_ctrl->ch_ctrl[port]);
-            buf_ctrl = &(zfw_ctrl->buf_ctrl[port]);
+                for (port = 0; port < cinfo->nports; port++) {
+                        info = &cy_port[port + cinfo->first_line];
+                        tty = info->tty;
+                        ch_ctrl = &(zfw_ctrl->ch_ctrl[port]);
+                        buf_ctrl = &(zfw_ctrl->buf_ctrl[port]);
 
-            if (!info->throttle)
-                cyz_handle_rx(info, ch_ctrl, buf_ctrl);
-            cyz_handle_tx(info, ch_ctrl, buf_ctrl);
+                        if (!info->throttle)
+                                cyz_handle_rx(info, ch_ctrl, buf_ctrl);
+                        cyz_handle_tx(info, ch_ctrl, buf_ctrl);
+                }
+                /* poll every 'cyz_polling_cycle' period */
+                cyz_timerlist.expires = jiffies + cyz_polling_cycle;
         }
-        /* poll every 'cyz_polling_cycle' period */
-        cyz_timerlist.expires = jiffies + cyz_polling_cycle;
-    }
-    add_timer(&cyz_timerlist);
-
-    return;
-} /* cyz_poll */
+        add_timer(&cyz_timerlist);
+}                               /* cyz_poll */
 
-#endif /* CONFIG_CYZ_INTR */
+#endif                          /* CONFIG_CYZ_INTR */
 
 /********** End of block of Cyclades-Z specific code *********/
 /***********************************************************/
 
-
 /* This is called whenever a port becomes active;
    interrupts are enabled and DTR & RTS are turned on.
  */
-static int
-startup(struct cyclades_port * info)
+static int startup(struct cyclades_port *info)
 {
-  unsigned long flags;
-  int retval = 0;
-  void __iomem *base_addr;
-  int card,chip,channel,index;
-  unsigned long page;
+        unsigned long flags;
+        int retval = 0;
+        void __iomem *base_addr;
+        int card, chip, channel, index;
+        unsigned long page;
 
-    card = info->card;
-    channel = (info->line) - (cy_card[card].first_line);
+        card = info->card;
+        channel = (info->line) - (cy_card[card].first_line);
 
-    page = get_zeroed_page(GFP_KERNEL);
-    if (!page)
-        return -ENOMEM;
+        page = get_zeroed_page(GFP_KERNEL);
+        if (!page)
+                return -ENOMEM;
 
-    CY_LOCK(info, flags);
+        CY_LOCK(info, flags);
 
-    if (info->flags & ASYNC_INITIALIZED){
-        free_page(page);
-        goto errout;
-    }
+        if (info->flags & ASYNC_INITIALIZED) {
+                free_page(page);
+                goto errout;
+        }
 
-    if (!info->type){
-        if (info->tty){
-            set_bit(TTY_IO_ERROR, &info->tty->flags);
-        }
-        free_page(page);
-        goto errout;
-    }
+        if (!info->type) {
+                if (info->tty) {
+                        set_bit(TTY_IO_ERROR, &info->tty->flags);
+                }
+                free_page(page);
+                goto errout;
+        }
 
-    if (info->xmit_buf)
-        free_page(page);
-    else
-        info->xmit_buf = (unsigned char *) page;
+        if (info->xmit_buf)
+                free_page(page);
+        else
+                info->xmit_buf = (unsigned char *)page;
 
-    CY_UNLOCK(info, flags);
+        CY_UNLOCK(info, flags);
 
-    set_line_char(info);
+        set_line_char(info);
 
-    if (!IS_CYC_Z(cy_card[card])) {
-        chip = channel>>2;
-        channel &= 0x03;
-        index = cy_card[card].bus_index;
-        base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
+        if (!IS_CYC_Z(cy_card[card])) {
+                chip = channel >> 2;
+                channel &= 0x03;
+                index = cy_card[card].bus_index;
+                base_addr = cy_card[card].base_addr +
+                                (cy_chip_offset[chip] << index);
 
 #ifdef CY_DEBUG_OPEN
-        printk("cyc startup card %d, chip %d, channel %d, base_addr %lx\n",
-             card, chip, channel, (long)base_addr);/**/
+                printk("cyc startup card %d, chip %d, channel %d, "
+                                "base_addr %lx\n",
+                                card, chip, channel, (long)base_addr);
+                /**/
 #endif
+                CY_LOCK(info, flags);
 
-        CY_LOCK(info, flags);
-
-        cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
+                cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
 
-        cy_writeb(base_addr+(CyRTPR<<index), (info->default_timeout
-                 ? info->default_timeout : 0x02)); /* 10ms rx timeout */
+                cy_writeb(base_addr + (CyRTPR << index),
+                        (info->default_timeout ? info->default_timeout : 0x02));
+                /* 10ms rx timeout */
 
-        cyy_issue_cmd(base_addr,CyCHAN_CTL|CyENB_RCVR|CyENB_XMTR,index);
+                cyy_issue_cmd(base_addr, CyCHAN_CTL | CyENB_RCVR | CyENB_XMTR,
+                                index);
 
-        cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-        cy_writeb(base_addr+(CyMSVR1<<index), CyRTS);
-        cy_writeb(base_addr+(CyMSVR2<<index), CyDTR);
+                cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
+                cy_writeb(base_addr + (CyMSVR1 << index), CyRTS);
+                cy_writeb(base_addr + (CyMSVR2 << index), CyDTR);
 
 #ifdef CY_DEBUG_DTR
-        printk("cyc:startup raising DTR\n");
-        printk("     status: 0x%x, 0x%x\n",
-                cy_readb(base_addr+(CyMSVR1<<index)), 
-                cy_readb(base_addr+(CyMSVR2<<index)));
+                printk("cyc:startup raising DTR\n");
+                printk("     status: 0x%x, 0x%x\n",
+                        cy_readb(base_addr + (CyMSVR1 << index)),
+                        cy_readb(base_addr + (CyMSVR2 << index)));
 #endif
 
-        cy_writeb(base_addr+(CySRER<<index),
-                cy_readb(base_addr+(CySRER<<index)) | CyRxData);
-        info->flags |= ASYNC_INITIALIZED;
+                cy_writeb(base_addr + (CySRER << index),
+                        cy_readb(base_addr + (CySRER << index)) | CyRxData);
+                info->flags |= ASYNC_INITIALIZED;
 
-        if (info->tty){
-            clear_bit(TTY_IO_ERROR, &info->tty->flags);
-        }
-        info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
-        info->breakon = info->breakoff = 0;
-        memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
-        info->idle_stats.in_use    =
-        info->idle_stats.recv_idle =
-        info->idle_stats.xmit_idle = jiffies;
+                if (info->tty) {
+                        clear_bit(TTY_IO_ERROR, &info->tty->flags);
+                }
+                info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
+                info->breakon = info->breakoff = 0;
+                memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
+                info->idle_stats.in_use =
+                info->idle_stats.recv_idle =
+                info->idle_stats.xmit_idle = jiffies;
 
-        CY_UNLOCK(info, flags);
+                CY_UNLOCK(info, flags);
 
-    } else {
-      struct FIRM_ID __iomem *firm_id;
-      struct ZFW_CTRL __iomem *zfw_ctrl;
-      struct BOARD_CTRL __iomem *board_ctrl;
-      struct CH_CTRL __iomem *ch_ctrl;
-      int retval;
+        } else {
+                struct FIRM_ID __iomem *firm_id;
+                struct ZFW_CTRL __iomem *zfw_ctrl;
+                struct BOARD_CTRL __iomem *board_ctrl;
+                struct CH_CTRL __iomem *ch_ctrl;
+                int retval;
 
-        base_addr = cy_card[card].base_addr;
+                base_addr = cy_card[card].base_addr;
 
-        firm_id = base_addr + ID_ADDRESS;
-        if (!ISZLOADED(cy_card[card])){
-            return -ENODEV;
-        }
+                firm_id = base_addr + ID_ADDRESS;
+                if (!ISZLOADED(cy_card[card])) {
+                        return -ENODEV;
+                }
 
-        zfw_ctrl = cy_card[card].base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-        board_ctrl = &zfw_ctrl->board_ctrl;
-        ch_ctrl = zfw_ctrl->ch_ctrl;
+                zfw_ctrl = cy_card[card].base_addr +
+                                (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+                board_ctrl = &zfw_ctrl->board_ctrl;
+                ch_ctrl = zfw_ctrl->ch_ctrl;
 
 #ifdef CY_DEBUG_OPEN
-        printk("cyc startup Z card %d, channel %d, base_addr %lx\n",
-             card, channel, (long)base_addr);/**/
+                printk("cyc startup Z card %d, channel %d, base_addr %lx\n",
+                        card, channel, (long)base_addr);
+                /**/
 #endif
+                CY_LOCK(info, flags);
 
-        CY_LOCK(info, flags);
-
-        cy_writel(&ch_ctrl[channel].op_mode, C_CH_ENABLE);
+                cy_writel(&ch_ctrl[channel].op_mode, C_CH_ENABLE);
 #ifdef Z_WAKE
 #ifdef CONFIG_CYZ_INTR
-        cy_writel(&ch_ctrl[channel].intr_enable, 
-                  C_IN_TXBEMPTY|C_IN_TXLOWWM|C_IN_RXHIWM|C_IN_RXNNDT|
-                  C_IN_IOCTLW|
-                  C_IN_MDCD);
+                cy_writel(&ch_ctrl[channel].intr_enable,
+                          C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
+                          C_IN_RXNNDT | C_IN_IOCTLW | C_IN_MDCD);
 #else
-        cy_writel(&ch_ctrl[channel].intr_enable, 
-                  C_IN_IOCTLW|
-                  C_IN_MDCD);
-#endif /* CONFIG_CYZ_INTR */
+                cy_writel(&ch_ctrl[channel].intr_enable,
+                          C_IN_IOCTLW | C_IN_MDCD);
+#endif                          /* CONFIG_CYZ_INTR */
 #else
 #ifdef CONFIG_CYZ_INTR
-        cy_writel(&ch_ctrl[channel].intr_enable, 
-                  C_IN_TXBEMPTY|C_IN_TXLOWWM|C_IN_RXHIWM|C_IN_RXNNDT|
-                  C_IN_MDCD);
+                cy_writel(&ch_ctrl[channel].intr_enable,
+                          C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
+                          C_IN_RXNNDT | C_IN_MDCD);
 #else
-        cy_writel(&ch_ctrl[channel].intr_enable, 
-                  C_IN_MDCD);
-#endif /* CONFIG_CYZ_INTR */
-#endif /* Z_WAKE */
-
-        retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_IOCTL, 0L);
-        if (retval != 0){
-            printk("cyc:startup(1) retval on ttyC%d was %x\n",
-                   info->line, retval);
-        }
+                cy_writel(&ch_ctrl[channel].intr_enable, C_IN_MDCD);
+#endif                          /* CONFIG_CYZ_INTR */
+#endif                          /* Z_WAKE */
+
+                retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_IOCTL, 0L);
+                if (retval != 0) {
+                        printk("cyc:startup(1) retval on ttyC%d was %x\n",
+                                info->line, retval);
+                }
 
-        /* Flush RX buffers before raising DTR and RTS */
-        retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_FLUSH_RX, 0L);
-        if (retval != 0){
-            printk("cyc:startup(2) retval on ttyC%d was %x\n",
-                   info->line, retval);
-        }
+                /* Flush RX buffers before raising DTR and RTS */
+                retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_FLUSH_RX,
+                                0L);
+                if (retval != 0) {
+                        printk("cyc:startup(2) retval on ttyC%d was %x\n",
+                                info->line, retval);
+                }
 
-        /* set timeout !!! */
-        /* set RTS and DTR !!! */
-        cy_writel(&ch_ctrl[channel].rs_control,
-             cy_readl(&ch_ctrl[channel].rs_control) | C_RS_RTS | C_RS_DTR) ;
-        retval = cyz_issue_cmd(&cy_card[info->card],
-            channel, C_CM_IOCTLM, 0L);
-        if (retval != 0){
-            printk("cyc:startup(3) retval on ttyC%d was %x\n",
-                   info->line, retval);
-        }
+                /* set timeout !!! */
+                /* set RTS and DTR !!! */
+                cy_writel(&ch_ctrl[channel].rs_control,
+                        cy_readl(&ch_ctrl[channel].rs_control) | C_RS_RTS |
+                        C_RS_DTR);
+                retval = cyz_issue_cmd(&cy_card[info->card], channel,
+                                C_CM_IOCTLM, 0L);
+                if (retval != 0) {
+                        printk("cyc:startup(3) retval on ttyC%d was %x\n",
+                                info->line, retval);
+                }
 #ifdef CY_DEBUG_DTR
-            printk("cyc:startup raising Z DTR\n");
+                printk("cyc:startup raising Z DTR\n");
 #endif
 
-        /* enable send, recv, modem !!! */
+                /* enable send, recv, modem !!! */
 
-        info->flags |= ASYNC_INITIALIZED;
-        if (info->tty){
-            clear_bit(TTY_IO_ERROR, &info->tty->flags);
-        }
-        info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
-        info->breakon = info->breakoff = 0;
-        memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
-        info->idle_stats.in_use    =
-        info->idle_stats.recv_idle =
-        info->idle_stats.xmit_idle = jiffies;
+                info->flags |= ASYNC_INITIALIZED;
+                if (info->tty) {
+                        clear_bit(TTY_IO_ERROR, &info->tty->flags);
+                }
+                info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
+                info->breakon = info->breakoff = 0;
+                memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
+                info->idle_stats.in_use =
+                info->idle_stats.recv_idle =
+                info->idle_stats.xmit_idle = jiffies;
 
-        CY_UNLOCK(info, flags);
-    }
+                CY_UNLOCK(info, flags);
+        }
 
 #ifdef CY_DEBUG_OPEN
         printk(" cyc startup done\n");
@@ -2105,165 +2154,165 @@ startup(struct cyclades_port * info)
 errout:
         CY_UNLOCK(info, flags);
         return retval;
-} /* startup */
+}                               /* startup */
 
-
-static void
-start_xmit( struct cyclades_port *info )
+static void start_xmit(struct cyclades_port *info)
 {
-  unsigned long flags;
-  void __iomem *base_addr;
-  int card,chip,channel,index;
-
-    card = info->card;
-    channel = (info->line) - (cy_card[card].first_line);
-    if (!IS_CYC_Z(cy_card[card])) {
-        chip = channel>>2;
-        channel &= 0x03;
-        index = cy_card[card].bus_index;
-        base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
+        unsigned long flags;
+        void __iomem *base_addr;
+        int card, chip, channel, index;
 
-        CY_LOCK(info, flags);
-            cy_writeb(base_addr+(CyCAR<<index), channel);
-            cy_writeb(base_addr+(CySRER<<index), 
-               cy_readb(base_addr+(CySRER<<index)) | CyTxRdy);
-        CY_UNLOCK(info, flags);
-    } else {
+        card = info->card;
+        channel = (info->line) - (cy_card[card].first_line);
+        if (!IS_CYC_Z(cy_card[card])) {
+                chip = channel >> 2;
+                channel &= 0x03;
+                index = cy_card[card].bus_index;
+                base_addr = cy_card[card].base_addr +
+                                (cy_chip_offset[chip] << index);
+
+                CY_LOCK(info, flags);
+                cy_writeb(base_addr + (CyCAR << index), channel);
+                cy_writeb(base_addr + (CySRER << index),
+                        cy_readb(base_addr + (CySRER << index)) | CyTxRdy);
+                CY_UNLOCK(info, flags);
+        } else {
 #ifdef CONFIG_CYZ_INTR
-      int retval;
+                int retval;
 
-        CY_LOCK(info, flags);
-            retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_INTBACK, 0L);
-            if (retval != 0){
-                printk("cyc:start_xmit retval on ttyC%d was %x\n",
-                       info->line, retval);
-            }
-        CY_UNLOCK(info, flags);
-#else /* CONFIG_CYZ_INTR */
-        /* Don't have to do anything at this time */
-#endif /* CONFIG_CYZ_INTR */
-    }
-} /* start_xmit */
+                CY_LOCK(info, flags);
+                retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_INTBACK,
+                                0L);
+                if (retval != 0) {
+                        printk("cyc:start_xmit retval on ttyC%d was %x\n",
+                                info->line, retval);
+                }
+                CY_UNLOCK(info, flags);
+#else                           /* CONFIG_CYZ_INTR */
+                /* Don't have to do anything at this time */
+#endif                          /* CONFIG_CYZ_INTR */
+        }
+}                               /* start_xmit */
 
 /*
  * This routine shuts down a serial port; interrupts are disabled,
  * and DTR is dropped if the hangup on close termio flag is on.
  */
-static void
-shutdown(struct cyclades_port * info)
+static void shutdown(struct cyclades_port *info)
 {
-  unsigned long flags;
-  void __iomem *base_addr;
-  int card,chip,channel,index;
-
-    if (!(info->flags & ASYNC_INITIALIZED)){
-        return;
-    }
-
-    card = info->card;
-    channel = info->line - cy_card[card].first_line;
-    if (!IS_CYC_Z(cy_card[card])) {
-        chip = channel>>2;
-        channel &= 0x03;
-        index = cy_card[card].bus_index;
-        base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
+        unsigned long flags;
+        void __iomem *base_addr;
+        int card, chip, channel, index;
+
+        if (!(info->flags & ASYNC_INITIALIZED)) {
+                return;
+        }
+
+        card = info->card;
+        channel = info->line - cy_card[card].first_line;
+        if (!IS_CYC_Z(cy_card[card])) {
+                chip = channel >> 2;
+                channel &= 0x03;
+                index = cy_card[card].bus_index;
+                base_addr = cy_card[card].base_addr +
+                                (cy_chip_offset[chip] << index);
 
 #ifdef CY_DEBUG_OPEN
-    printk("cyc shutdown Y card %d, chip %d, channel %d, base_addr %lx\n",
-                card, chip, channel, (long)base_addr);
+                printk("cyc shutdown Y card %d, chip %d, channel %d, "
+                                "base_addr %lx\n",
+                                card, chip, channel, (long)base_addr);
 #endif
 
-        CY_LOCK(info, flags);
+                CY_LOCK(info, flags);
 
-            /* Clear delta_msr_wait queue to avoid mem leaks. */
-            wake_up_interruptible(&info->delta_msr_wait);
-
-            if (info->xmit_buf){
-                unsigned char * temp;
-                temp = info->xmit_buf;
-                info->xmit_buf = NULL;
-                free_page((unsigned long) temp);
-            }
-            cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-            if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
-                cy_writeb(base_addr+(CyMSVR1<<index), ~CyRTS);
-                cy_writeb(base_addr+(CyMSVR2<<index), ~CyDTR);
+                /* Clear delta_msr_wait queue to avoid mem leaks. */
+                wake_up_interruptible(&info->delta_msr_wait);
+
+                if (info->xmit_buf) {
+                        unsigned char *temp;
+                        temp = info->xmit_buf;
+                        info->xmit_buf = NULL;
+                        free_page((unsigned long)temp);
+                }
+                cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
+                if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
+                        cy_writeb(base_addr + (CyMSVR1 << index), ~CyRTS);
+                        cy_writeb(base_addr + (CyMSVR2 << index), ~CyDTR);
 #ifdef CY_DEBUG_DTR
-                printk("cyc shutdown dropping DTR\n");
-                printk("     status: 0x%x, 0x%x\n",
-                    cy_readb(base_addr+(CyMSVR1<<index)), 
-                    cy_readb(base_addr+(CyMSVR2<<index)));
+                        printk("cyc shutdown dropping DTR\n");
+                        printk("     status: 0x%x, 0x%x\n",
+                                cy_readb(base_addr + (CyMSVR1 << index)),
+                                cy_readb(base_addr + (CyMSVR2 << index)));
 #endif
-            }
-            cyy_issue_cmd(base_addr,CyCHAN_CTL|CyDIS_RCVR,index);
-             /* it may be appropriate to clear _XMIT at
-               some later date (after testing)!!! */
-
-            if (info->tty){
-                set_bit(TTY_IO_ERROR, &info->tty->flags);
-            }
-            info->flags &= ~ASYNC_INITIALIZED;
-        CY_UNLOCK(info, flags);
-    } else {
-      struct FIRM_ID __iomem *firm_id;
-      struct ZFW_CTRL __iomem *zfw_ctrl;
-      struct BOARD_CTRL __iomem *board_ctrl;
-      struct CH_CTRL __iomem *ch_ctrl;
-      int retval;
-
-        base_addr = cy_card[card].base_addr;
+                }
+                cyy_issue_cmd(base_addr, CyCHAN_CTL | CyDIS_RCVR, index);
+                /* it may be appropriate to clear _XMIT at
+                   some later date (after testing)!!! */
+
+                if (info->tty) {
+                        set_bit(TTY_IO_ERROR, &info->tty->flags);
+                }
+                info->flags &= ~ASYNC_INITIALIZED;
+                CY_UNLOCK(info, flags);
+        } else {
+                struct FIRM_ID __iomem *firm_id;
+                struct ZFW_CTRL __iomem *zfw_ctrl;
+                struct BOARD_CTRL __iomem *board_ctrl;
+                struct CH_CTRL __iomem *ch_ctrl;
+                int retval;
+
+                base_addr = cy_card[card].base_addr;
 #ifdef CY_DEBUG_OPEN
-    printk("cyc shutdown Z card %d, channel %d, base_addr %lx\n",
-                card, channel, (long)base_addr);
+                printk("cyc shutdown Z card %d, channel %d, base_addr %lx\n",
+                        card, channel, (long)base_addr);
 #endif
 
-        firm_id = base_addr + ID_ADDRESS;
-        if (!ISZLOADED(cy_card[card])) {
-            return;
-        }
+                firm_id = base_addr + ID_ADDRESS;
+                if (!ISZLOADED(cy_card[card])) {
+                        return;
+                }
 
-        zfw_ctrl = cy_card[card].base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-        board_ctrl = &zfw_ctrl->board_ctrl;
-        ch_ctrl = zfw_ctrl->ch_ctrl;
+                zfw_ctrl = cy_card[card].base_addr +
+                                (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+                board_ctrl = &zfw_ctrl->board_ctrl;
+                ch_ctrl = zfw_ctrl->ch_ctrl;
 
-        CY_LOCK(info, flags);
+                CY_LOCK(info, flags);
 
-            if (info->xmit_buf){
-                unsigned char * temp;
-                temp = info->xmit_buf;
-                info->xmit_buf = NULL;
-                free_page((unsigned long) temp);
-            }
-            
-            if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
-                cy_writel(&ch_ctrl[channel].rs_control,
-                   (uclong)(cy_readl(&ch_ctrl[channel].rs_control) & 
-                   ~(C_RS_RTS | C_RS_DTR)));
-                retval = cyz_issue_cmd(&cy_card[info->card],
-                        channel, C_CM_IOCTLM, 0L);
-                if (retval != 0){
-                    printk("cyc:shutdown retval on ttyC%d was %x\n",
-                           info->line, retval);
+                if (info->xmit_buf) {
+                        unsigned char *temp;
+                        temp = info->xmit_buf;
+                        info->xmit_buf = NULL;
+                        free_page((unsigned long)temp);
                 }
+
+                if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
+                        cy_writel(&ch_ctrl[channel].rs_control,
+                                (uclong)(cy_readl(&ch_ctrl[channel].rs_control)&
+                                        ~(C_RS_RTS | C_RS_DTR)));
+                        retval = cyz_issue_cmd(&cy_card[info->card], channel,
+                                        C_CM_IOCTLM, 0L);
+                        if (retval != 0) {
+                                printk("cyc:shutdown retval on ttyC%d was %x\n",
+                                        info->line, retval);
+                        }
 #ifdef CY_DEBUG_DTR
-                printk("cyc:shutdown dropping Z DTR\n");
+                        printk("cyc:shutdown dropping Z DTR\n");
 #endif
-            }
-            
-            if (info->tty){
-                set_bit(TTY_IO_ERROR, &info->tty->flags);
-            }
-            info->flags &= ~ASYNC_INITIALIZED;
+                }
 
-        CY_UNLOCK(info, flags);
-    }
+                if (info->tty) {
+                        set_bit(TTY_IO_ERROR, &info->tty->flags);
+                }
+                info->flags &= ~ASYNC_INITIALIZED;
+
+                CY_UNLOCK(info, flags);
+        }
 
 #ifdef CY_DEBUG_OPEN
-    printk(" cyc shutdown done\n");
+        printk(" cyc shutdown done\n");
 #endif
-    return;
-} /* shutdown */
-
+}                               /* shutdown */
 
 /*
  * ------------------------------------------------------------
@@ -2272,537 +2321,546 @@ shutdown(struct cyclades_port * info)
  */
 
 static int
-block_til_ready(struct tty_struct *tty, struct file * filp,
-                           struct cyclades_port *info)
+block_til_ready(struct tty_struct *tty, struct file *filp,
+                struct cyclades_port *info)
 {
-  DECLARE_WAITQUEUE(wait, current);
-  struct cyclades_card *cinfo;
-  unsigned long flags;
-  int chip, channel,index;
-  int retval;
-  void __iomem *base_addr;
-
-    cinfo = &cy_card[info->card];
-    channel = info->line - cinfo->first_line;
-
-    /*
-     * If the device is in the middle of being closed, then block
-     * until it's done, and then try again.
-     */
-    if (tty_hung_up_p(filp) || (info->flags & ASYNC_CLOSING)) {
-        if (info->flags & ASYNC_CLOSING) {
-            interruptible_sleep_on(&info->close_wait);
+        DECLARE_WAITQUEUE(wait, current);
+        struct cyclades_card *cinfo;
+        unsigned long flags;
+        int chip, channel, index;
+        int retval;
+        void __iomem *base_addr;
+
+        cinfo = &cy_card[info->card];
+        channel = info->line - cinfo->first_line;
+
+        /*
+         * If the device is in the middle of being closed, then block
+         * until it's done, and then try again.
+         */
+        if (tty_hung_up_p(filp) || (info->flags & ASYNC_CLOSING)) {
+                if (info->flags & ASYNC_CLOSING) {
+                        interruptible_sleep_on(&info->close_wait);
+                }
+                return (info->flags & ASYNC_HUP_NOTIFY) ? -EAGAIN: -ERESTARTSYS;
+        }
+
+        /*
+         * If non-blocking mode is set, then make the check up front
+         * and then exit.
+         */
+        if ((filp->f_flags & O_NONBLOCK) || (tty->flags & (1 << TTY_IO_ERROR))) {
+                info->flags |= ASYNC_NORMAL_ACTIVE;
+                return 0;
         }
-        return ((info->flags & ASYNC_HUP_NOTIFY) ? -EAGAIN : -ERESTARTSYS);
-    }
-
-    /*
-     * If non-blocking mode is set, then make the check up front
-     * and then exit.
-     */
-    if ((filp->f_flags & O_NONBLOCK) ||
-        (tty->flags & (1 << TTY_IO_ERROR))) {
-        info->flags |= ASYNC_NORMAL_ACTIVE;
-        return 0;
-    }
-
-    /*
-     * Block waiting for the carrier detect and the line to become
-     * free (i.e., not in use by the callout).  While we are in
-     * this loop, info->count is dropped by one, so that
-     * cy_close() knows when to free things.  We restore it upon
-     * exit, either normal or abnormal.
-     */
-    retval = 0;
-    add_wait_queue(&info->open_wait, &wait);
+
+        /*
+         * Block waiting for the carrier detect and the line to become
+         * free (i.e., not in use by the callout).  While we are in
+         * this loop, info->count is dropped by one, so that
+         * cy_close() knows when to free things.  We restore it upon
+         * exit, either normal or abnormal.
+         */
+        retval = 0;
+        add_wait_queue(&info->open_wait, &wait);
 #ifdef CY_DEBUG_OPEN
-    printk("cyc block_til_ready before block: ttyC%d, count = %d\n",
-           info->line, info->count);/**/
+        printk("cyc block_til_ready before block: ttyC%d, count = %d\n",
+                info->line, info->count);
+        /**/
 #endif
-    CY_LOCK(info, flags);
-    if (!tty_hung_up_p(filp))
-        info->count--;
-    CY_UNLOCK(info, flags);
+        CY_LOCK(info, flags);
+        if (!tty_hung_up_p(filp))
+                info->count--;
+        CY_UNLOCK(info, flags);
 #ifdef CY_DEBUG_COUNT
-    printk("cyc block_til_ready: (%d): decrementing count to %d\n",
-        current->pid, info->count);
+        printk("cyc block_til_ready: (%d): decrementing count to %d\n",
+                current->pid, info->count);
 #endif
-    info->blocked_open++;
-
-    if (!IS_CYC_Z(*cinfo)) {
-        chip = channel>>2;
-        channel &= 0x03;
-        index = cinfo->bus_index;
-        base_addr = cinfo->base_addr + (cy_chip_offset[chip]<<index);
-
-        while (1) {
-            CY_LOCK(info, flags);
-                if ((tty->termios->c_cflag & CBAUD)){
-                    cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-                    cy_writeb(base_addr+(CyMSVR1<<index), CyRTS);
-                    cy_writeb(base_addr+(CyMSVR2<<index), CyDTR);
+        info->blocked_open++;
+
+        if (!IS_CYC_Z(*cinfo)) {
+                chip = channel >> 2;
+                channel &= 0x03;
+                index = cinfo->bus_index;
+                base_addr = cinfo->base_addr + (cy_chip_offset[chip] << index);
+
+                while (1) {
+                        CY_LOCK(info, flags);
+                        if ((tty->termios->c_cflag & CBAUD)) {
+                                cy_writeb(base_addr + (CyCAR << index),
+                                          (u_char) channel);
+                                cy_writeb(base_addr + (CyMSVR1 << index),
+                                          CyRTS);
+                                cy_writeb(base_addr + (CyMSVR2 << index),
+                                          CyDTR);
 #ifdef CY_DEBUG_DTR
-                    printk("cyc:block_til_ready raising DTR\n");
-                    printk("     status: 0x%x, 0x%x\n",
-                        cy_readb(base_addr+(CyMSVR1<<index)), 
-                        cy_readb(base_addr+(CyMSVR2<<index)));
+                                printk("cyc:block_til_ready raising DTR\n");
+                                printk("     status: 0x%x, 0x%x\n",
+                                        cy_readb(base_addr +
+                                                (CyMSVR1 << index)),
+                                        cy_readb(base_addr +
+                                                (CyMSVR2 << index)));
 #endif
-                }
-            CY_UNLOCK(info, flags);
+                        }
+                        CY_UNLOCK(info, flags);
 
-            set_current_state(TASK_INTERRUPTIBLE);
-            if (tty_hung_up_p(filp)
-            || !(info->flags & ASYNC_INITIALIZED) ){
-                retval = ((info->flags & ASYNC_HUP_NOTIFY) ? 
-                    -EAGAIN : -ERESTARTSYS);
-                break;
-            }
+                        set_current_state(TASK_INTERRUPTIBLE);
+                        if (tty_hung_up_p(filp) ||
+                                        !(info->flags & ASYNC_INITIALIZED)) {
+                                retval = ((info->flags & ASYNC_HUP_NOTIFY) ?
+                                          -EAGAIN : -ERESTARTSYS);
+                                break;
+                        }
 
-            CY_LOCK(info, flags);
-                cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-                if (!(info->flags & ASYNC_CLOSING)
-                && (C_CLOCAL(tty)
-                    || (cy_readb(base_addr+(CyMSVR1<<index)) & CyDCD))) {
+                        CY_LOCK(info, flags);
+                        cy_writeb(base_addr + (CyCAR << index),
+                                  (u_char) channel);
+                        if (!(info->flags & ASYNC_CLOSING) && (C_CLOCAL(tty) ||
+                                        (cy_readb(base_addr +
+                                                (CyMSVR1 << index)) & CyDCD))) {
+                                CY_UNLOCK(info, flags);
+                                break;
+                        }
                         CY_UNLOCK(info, flags);
-                        break;
-                }
-            CY_UNLOCK(info, flags);
 
-            if (signal_pending(current)) {
-                retval = -ERESTARTSYS;
-                break;
-            }
+                        if (signal_pending(current)) {
+                                retval = -ERESTARTSYS;
+                                break;
+                        }
 #ifdef CY_DEBUG_OPEN
-            printk("cyc block_til_ready blocking: ttyC%d, count = %d\n",
-                   info->line, info->count);/**/
+                        printk("cyc block_til_ready blocking: ttyC%d, "
+                                        "count = %d\n",
+                                        info->line, info->count);
+                        /**/
 #endif
-            schedule();
-        }
-    } else {
-      struct FIRM_ID __iomem *firm_id;
-      struct ZFW_CTRL __iomem *zfw_ctrl;
-      struct BOARD_CTRL __iomem *board_ctrl;
-      struct CH_CTRL __iomem *ch_ctrl;
-      int retval;
-
-        base_addr = cinfo->base_addr;
-        firm_id = base_addr + ID_ADDRESS;
-        if (!ISZLOADED(*cinfo)){
-            current->state = TASK_RUNNING;
-            remove_wait_queue(&info->open_wait, &wait);
-            return -EINVAL;
-        }
-
-        zfw_ctrl = base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-        board_ctrl = &zfw_ctrl->board_ctrl;
-        ch_ctrl = zfw_ctrl->ch_ctrl;
-
-        while (1) {
-            if ((tty->termios->c_cflag & CBAUD)){
-                cy_writel(&ch_ctrl[channel].rs_control,
-                        cy_readl(&ch_ctrl[channel].rs_control) |
-                        (C_RS_RTS | C_RS_DTR));
-                retval = cyz_issue_cmd(&cy_card[info->card],
-                                       channel, C_CM_IOCTLM, 0L);
-                if (retval != 0){
-                    printk("cyc:block_til_ready retval on ttyC%d was %x\n",
-                           info->line, retval);
+                        schedule();
+                }
+        } else {
+                struct FIRM_ID __iomem *firm_id;
+                struct ZFW_CTRL __iomem *zfw_ctrl;
+                struct BOARD_CTRL __iomem *board_ctrl;
+                struct CH_CTRL __iomem *ch_ctrl;
+                int retval;
+
+                base_addr = cinfo->base_addr;
+                firm_id = base_addr + ID_ADDRESS;
+                if (!ISZLOADED(*cinfo)) {
+                        current->state = TASK_RUNNING;
+                        remove_wait_queue(&info->open_wait, &wait);
+                        return -EINVAL;
                 }
+
+                zfw_ctrl = base_addr + (cy_readl(&firm_id->zfwctrl_addr) &
+                                0xfffff);
+                board_ctrl = &zfw_ctrl->board_ctrl;
+                ch_ctrl = zfw_ctrl->ch_ctrl;
+
+                while (1) {
+                        if ((tty->termios->c_cflag & CBAUD)) {
+                                cy_writel(&ch_ctrl[channel].rs_control,
+                                          cy_readl(&ch_ctrl[channel].
+                                                   rs_control) | (C_RS_RTS |
+                                                                  C_RS_DTR));
+                                retval = cyz_issue_cmd(&cy_card[info->card],
+                                                channel, C_CM_IOCTLM, 0L);
+                                if (retval != 0) {
+                                        printk("cyc:block_til_ready retval on "
+                                                "ttyC%d was %x\n",
+                                                info->line, retval);
+                                }
 #ifdef CY_DEBUG_DTR
-                printk("cyc:block_til_ready raising Z DTR\n");
+                                printk("cyc:block_til_ready raising Z DTR\n");
 #endif
-            }
+                        }
 
-            set_current_state(TASK_INTERRUPTIBLE);
-            if (tty_hung_up_p(filp)
-            || !(info->flags & ASYNC_INITIALIZED) ){
-                retval = ((info->flags & ASYNC_HUP_NOTIFY) ?
-                    -EAGAIN : -ERESTARTSYS);
-                break;
-            }
-            if (!(info->flags & ASYNC_CLOSING)
-            && (C_CLOCAL(tty)
-              || (cy_readl(&ch_ctrl[channel].rs_status) & C_RS_DCD))) {
-                break;
-            }
-            if (signal_pending(current)) {
-                retval = -ERESTARTSYS;
-                break;
-            }
+                        set_current_state(TASK_INTERRUPTIBLE);
+                        if (tty_hung_up_p(filp) ||
+                                        !(info->flags & ASYNC_INITIALIZED)) {
+                                retval = ((info->flags & ASYNC_HUP_NOTIFY) ?
+                                          -EAGAIN : -ERESTARTSYS);
+                                break;
+                        }
+                        if (!(info->flags & ASYNC_CLOSING) && (C_CLOCAL(tty) ||
+                                        (cy_readl(&ch_ctrl[channel].rs_status) &
+                                                C_RS_DCD))) {
+                                break;
+                        }
+                        if (signal_pending(current)) {
+                                retval = -ERESTARTSYS;
+                                break;
+                        }
 #ifdef CY_DEBUG_OPEN
-            printk("cyc block_til_ready blocking: ttyC%d, count = %d\n",
-                   info->line, info->count);/**/
+                        printk("cyc block_til_ready blocking: ttyC%d, "
+                                        "count = %d\n",
+                                        info->line, info->count);
+                        /**/
 #endif
-            schedule();
+                        schedule();
+                }
         }
-    }
-    current->state = TASK_RUNNING;
-    remove_wait_queue(&info->open_wait, &wait);
-    if (!tty_hung_up_p(filp)){
-        info->count++;
+        current->state = TASK_RUNNING;
+        remove_wait_queue(&info->open_wait, &wait);
+        if (!tty_hung_up_p(filp)) {
+                info->count++;
 #ifdef CY_DEBUG_COUNT
-        printk("cyc:block_til_ready (%d): incrementing count to %d\n",
-            current->pid, info->count);
+                printk("cyc:block_til_ready (%d): incrementing count to %d\n",
+                        current->pid, info->count);
 #endif
-    }
-    info->blocked_open--;
+        }
+        info->blocked_open--;
 #ifdef CY_DEBUG_OPEN
-    printk("cyc:block_til_ready after blocking: ttyC%d, count = %d\n",
-           info->line, info->count);/**/
+        printk("cyc:block_til_ready after blocking: ttyC%d, count = %d\n",
+                info->line, info->count);
+        /**/
 #endif
-    if (retval)
-        return retval;
-    info->flags |= ASYNC_NORMAL_ACTIVE;
-    return 0;
-} /* block_til_ready */
-
+        if (retval)
+                return retval;
+        info->flags |= ASYNC_NORMAL_ACTIVE;
+        return 0;
+}                               /* block_til_ready */
 
 /*
  * This routine is called whenever a serial port is opened.  It
  * performs the serial-specific initialization for the tty structure.
  */
-static int
-cy_open(struct tty_struct *tty, struct file * filp)
+static int cy_open(struct tty_struct *tty, struct file *filp)
 {
-  struct cyclades_port  *info;
-  int retval, line;
-  unsigned long page;
-
-    line = tty->index;
-    if ((line < 0) || (NR_PORTS <= line)){
-        return -ENODEV;
-    }
-    info = &cy_port[line];
-    if (info->line < 0){
-        return -ENODEV;
-    }
-    
-    /* If the card's firmware hasn't been loaded,
-       treat it as absent from the system.  This
-       will make the user pay attention.
-    */
-    if (IS_CYC_Z(cy_card[info->card])) {
-        struct cyclades_card *cinfo = &cy_card[info->card];
-        struct FIRM_ID __iomem *firm_id = cinfo->base_addr + ID_ADDRESS;
-
-        if (!ISZLOADED(*cinfo)) {
-            if (((ZE_V1 ==cy_readl(&((struct RUNTIME_9060 __iomem *)
-                (cinfo->ctl_addr))->mail_box_0)) &&
-                Z_FPGA_CHECK (*cinfo)) &&
-                (ZFIRM_HLT == cy_readl (&firm_id->signature)))
-            {
-                printk ("cyc:Cyclades-Z Error: you need an external power supply for this number of ports.\n\rFirmware halted.\r\n");
-            } else {
-                printk("cyc:Cyclades-Z firmware not yet loaded\n");
-            }
-            return -ENODEV;
-        }
-#ifdef CONFIG_CYZ_INTR
-        else {
-            /* In case this Z board is operating in interrupt mode, its 
-               interrupts should be enabled as soon as the first open happens 
-               to one of its ports. */
-            if (!cinfo->intr_enabled) {
-                struct ZFW_CTRL __iomem *zfw_ctrl;
-                struct BOARD_CTRL __iomem *board_ctrl;
-
-                zfw_ctrl = cinfo->base_addr + (cy_readl (&firm_id->zfwctrl_addr) & 0xfffff);
+        struct cyclades_port *info;
+        int retval, line;
 
-                board_ctrl = &zfw_ctrl->board_ctrl;
+        line = tty->index;
+        if ((line < 0) || (NR_PORTS <= line)) {
+                return -ENODEV;
+        }
+        info = &cy_port[line];
+        if (info->line < 0) {
+                return -ENODEV;
+        }
 
-                /* Enable interrupts on the PLX chip */
-                cy_writew(cinfo->ctl_addr+0x68,
-                        cy_readw(cinfo->ctl_addr+0x68)|0x0900);
-                /* Enable interrupts on the FW */
-                retval = cyz_issue_cmd(cinfo,
-                                        0, C_CM_IRQ_ENBL, 0L);
-                if (retval != 0){
-                    printk("cyc:IRQ enable retval was %x\n", retval);
+        /* If the card's firmware hasn't been loaded,
+           treat it as absent from the system.  This
+           will make the user pay attention.
+         */
+        if (IS_CYC_Z(cy_card[info->card])) {
+                struct cyclades_card *cinfo = &cy_card[info->card];
+                struct FIRM_ID __iomem *firm_id = cinfo->base_addr + ID_ADDRESS;
+
+                if (!ISZLOADED(*cinfo)) {
+                        if (((ZE_V1 == cy_readl(
+                                        &((struct RUNTIME_9060 __iomem *)
+                                         (cinfo->ctl_addr))->mail_box_0)) &&
+                                        Z_FPGA_CHECK(*cinfo)) &&
+                                        (ZFIRM_HLT == cy_readl(
+                                                &firm_id->signature))) {
+                                printk("cyc:Cyclades-Z Error: you need an "
+                                        "external power supply for this number "
+                                        "of ports.\n\rFirmware halted.\r\n");
+                        } else {
+                                printk("cyc:Cyclades-Z firmware not yet "
+                                        "loaded\n");
+                        }
+                        return -ENODEV;
+                }
+#ifdef CONFIG_CYZ_INTR
+                else {
+                /* In case this Z board is operating in interrupt mode, its
+                   interrupts should be enabled as soon as the first open
+                   happens to one of its ports. */
+                        if (!cinfo->intr_enabled) {
+                                struct ZFW_CTRL __iomem *zfw_ctrl;
+                                struct BOARD_CTRL __iomem *board_ctrl;
+
+                                zfw_ctrl = cinfo->base_addr +
+                                        (cy_readl(&firm_id->zfwctrl_addr) &
+                                                0xfffff);
+
+                                board_ctrl = &zfw_ctrl->board_ctrl;
+
+                                /* Enable interrupts on the PLX chip */
+                                cy_writew(cinfo->ctl_addr + 0x68,
+                                          cy_readw(cinfo->ctl_addr +
+                                                   0x68) | 0x0900);
+                                /* Enable interrupts on the FW */
+                                retval = cyz_issue_cmd(cinfo, 0,
+                                                C_CM_IRQ_ENBL, 0L);
+                                if (retval != 0) {
+                                        printk("cyc:IRQ enable retval was %x\n",
+                                                retval);
+                                }
+                                cinfo->nports =
+                                        (int)cy_readl(&board_ctrl->n_channel);
+                                cinfo->intr_enabled = 1;
+                        }
                 }
-                cinfo->nports = (int) cy_readl (&board_ctrl->n_channel);
-                cinfo->intr_enabled = 1;
-            }
+#endif                          /* CONFIG_CYZ_INTR */
+                /* Make sure this Z port really exists in hardware */
+                if (info->line > (cinfo->first_line + cinfo->nports - 1))
+                        return -ENODEV;
         }
-#endif /* CONFIG_CYZ_INTR */
-        /* Make sure this Z port really exists in hardware */
-        if (info->line > (cinfo->first_line + cinfo->nports - 1))
-                return -ENODEV;
-    }
 #ifdef CY_DEBUG_OTHER
-    printk("cyc:cy_open ttyC%d\n", info->line); /* */
+        printk("cyc:cy_open ttyC%d\n", info->line);     /* */
 #endif
-    tty->driver_data = info;
-    info->tty = tty;
-    if (serial_paranoia_check(info, tty->name, "cy_open")){
-        return -ENODEV;
-    }
+        tty->driver_data = info;
+        info->tty = tty;
+        if (serial_paranoia_check(info, tty->name, "cy_open")) {
+                return -ENODEV;
+        }
 #ifdef CY_DEBUG_OPEN
-    printk("cyc:cy_open ttyC%d, count = %d\n",
-        info->line, info->count);/**/
+        printk("cyc:cy_open ttyC%d, count = %d\n", info->line, info->count);
+        /**/
 #endif
-    info->count++;
+        info->count++;
 #ifdef CY_DEBUG_COUNT
-    printk("cyc:cy_open (%d): incrementing count to %d\n",
-        current->pid, info->count);
+        printk("cyc:cy_open (%d): incrementing count to %d\n",
+                current->pid, info->count);
 #endif
-    if (!tmp_buf) {
-        page = get_zeroed_page(GFP_KERNEL);
-        if (!page)
-            return -ENOMEM;
-        if (tmp_buf)
-            free_page(page);
-        else
-            tmp_buf = (unsigned char *) page;
-    }
-
-    /*
-     * If the port is the middle of closing, bail out now
-     */
-    if (tty_hung_up_p(filp) || (info->flags & ASYNC_CLOSING)) {
-        if (info->flags & ASYNC_CLOSING)
-            interruptible_sleep_on(&info->close_wait);
-        return ((info->flags & ASYNC_HUP_NOTIFY) ? -EAGAIN : -ERESTARTSYS);
-    }
-
-    /*
-     * Start up serial port
-     */
-    retval = startup(info);
-    if (retval){
-        return retval;
-    }
-
-    retval = block_til_ready(tty, filp, info);
-    if (retval) {
-#ifdef CY_DEBUG_OPEN
-        printk("cyc:cy_open returning after block_til_ready with %d\n",
-               retval);
-#endif
-        return retval;
-    }
 
-    info->throttle = 0;
+        /*
+         * If the port is the middle of closing, bail out now
+         */
+        if (tty_hung_up_p(filp) || (info->flags & ASYNC_CLOSING)) {
+                if (info->flags & ASYNC_CLOSING)
+                        interruptible_sleep_on(&info->close_wait);
+                return (info->flags & ASYNC_HUP_NOTIFY) ? -EAGAIN: -ERESTARTSYS;
+        }
+
+        /*
+         * Start up serial port
+         */
+        retval = startup(info);
+        if (retval) {
+                return retval;
+        }
 
+        retval = block_til_ready(tty, filp, info);
+        if (retval) {
 #ifdef CY_DEBUG_OPEN
-    printk(" cyc:cy_open done\n");/**/
+                printk("cyc:cy_open returning after block_til_ready with %d\n",
+                        retval);
 #endif
+                return retval;
+        }
 
-    return 0;
-} /* cy_open */
+        info->throttle = 0;
 
+#ifdef CY_DEBUG_OPEN
+        printk(" cyc:cy_open done\n");
+        /**/
+#endif
+        return 0;
+}                               /* cy_open */
 
 /*
  * cy_wait_until_sent() --- wait until the transmitter is empty
  */
-static void 
-cy_wait_until_sent(struct tty_struct *tty, int timeout)
+static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
 {
-  struct cyclades_port * info = (struct cyclades_port *)tty->driver_data;
-  void __iomem *base_addr;
-  int card,chip,channel,index;
-  unsigned long orig_jiffies;
-  int char_time;
-        
-    if (serial_paranoia_check(info, tty->name, "cy_wait_until_sent"))
-        return;
-
-    if (info->xmit_fifo_size == 0)
-        return; /* Just in case.... */
-
-
-    orig_jiffies = jiffies;
-    /*
-     * Set the check interval to be 1/5 of the estimated time to
-     * send a single character, and make it at least 1.  The check
-     * interval should also be less than the timeout.
-     * 
-     * Note: we have to use pretty tight timings here to satisfy
-     * the NIST-PCTS.
-     */
-    char_time = (info->timeout - HZ/50) / info->xmit_fifo_size;
-    char_time = char_time / 5;
-    if (char_time <= 0)
-        char_time = 1;
-    if (timeout < 0)
-        timeout = 0;
-    if (timeout)
-        char_time = min(char_time, timeout);
-    /*
-     * If the transmitter hasn't cleared in twice the approximate
-     * amount of time to send the entire FIFO, it probably won't
-     * ever clear.  This assumes the UART isn't doing flow
-     * control, which is currently the case.  Hence, if it ever
-     * takes longer than info->timeout, this is probably due to a
-     * UART bug of some kind.  So, we clamp the timeout parameter at
-     * 2*info->timeout.
-     */
-    if (!timeout || timeout > 2*info->timeout)
-        timeout = 2*info->timeout;
+        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        void __iomem *base_addr;
+        int card, chip, channel, index;
+        unsigned long orig_jiffies;
+        int char_time;
+
+        if (serial_paranoia_check(info, tty->name, "cy_wait_until_sent"))
+                return;
+
+        if (info->xmit_fifo_size == 0)
+                return;         /* Just in case.... */
+
+        orig_jiffies = jiffies;
+        /*
+         * Set the check interval to be 1/5 of the estimated time to
+         * send a single character, and make it at least 1.  The check
+         * interval should also be less than the timeout.
+         *
+         * Note: we have to use pretty tight timings here to satisfy
+         * the NIST-PCTS.
+         */
+        char_time = (info->timeout - HZ / 50) / info->xmit_fifo_size;
+        char_time = char_time / 5;
+        if (char_time <= 0)
+                char_time = 1;
+        if (timeout < 0)
+                timeout = 0;
+        if (timeout)
+                char_time = min(char_time, timeout);
+        /*
+         * If the transmitter hasn't cleared in twice the approximate
+         * amount of time to send the entire FIFO, it probably won't
+         * ever clear.  This assumes the UART isn't doing flow
+         * control, which is currently the case.  Hence, if it ever
+         * takes longer than info->timeout, this is probably due to a
+         * UART bug of some kind.  So, we clamp the timeout parameter at
+         * 2*info->timeout.
+         */
+        if (!timeout || timeout > 2 * info->timeout)
+                timeout = 2 * info->timeout;
 #ifdef CY_DEBUG_WAIT_UNTIL_SENT
-    printk("In cy_wait_until_sent(%d) check=%lu...", timeout, char_time);
-    printk("jiff=%lu...", jiffies);
+        printk("In cy_wait_until_sent(%d) check=%lu...", timeout, char_time);
+        printk("jiff=%lu...", jiffies);
 #endif
-    card = info->card;
-    channel = (info->line) - (cy_card[card].first_line);
-    if (!IS_CYC_Z(cy_card[card])) {
-        chip = channel>>2;
-        channel &= 0x03;
-        index = cy_card[card].bus_index;
-        base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
-        while (cy_readb(base_addr+(CySRER<<index)) & CyTxRdy) {
+        card = info->card;
+        channel = (info->line) - (cy_card[card].first_line);
+        if (!IS_CYC_Z(cy_card[card])) {
+                chip = channel >> 2;
+                channel &= 0x03;
+                index = cy_card[card].bus_index;
+                base_addr =
+                    cy_card[card].base_addr + (cy_chip_offset[chip] << index);
+                while (cy_readb(base_addr + (CySRER << index)) & CyTxRdy) {
 #ifdef CY_DEBUG_WAIT_UNTIL_SENT
-            printk("Not clean (jiff=%lu)...", jiffies);
+                        printk("Not clean (jiff=%lu)...", jiffies);
 #endif
-            if (msleep_interruptible(jiffies_to_msecs(char_time)))
-                break;
-            if (timeout && time_after(jiffies, orig_jiffies + timeout))
-                break;
+                        if (msleep_interruptible(jiffies_to_msecs(char_time)))
+                                break;
+                        if (timeout && time_after(jiffies, orig_jiffies +
+                                        timeout))
+                                break;
+                }
+        } else {
+                /* Nothing to do! */
         }
-    } else {
-        // Nothing to do!
-    }
-    /* Run one more char cycle */
-    msleep_interruptible(jiffies_to_msecs(char_time * 5));
+        /* Run one more char cycle */
+        msleep_interruptible(jiffies_to_msecs(char_time * 5));
 #ifdef CY_DEBUG_WAIT_UNTIL_SENT
-    printk("Clean (jiff=%lu)...done\n", jiffies);
+        printk("Clean (jiff=%lu)...done\n", jiffies);
 #endif
 }
 
 /*
  * This routine is called when a particular tty device is closed.
  */
-static void
-cy_close(struct tty_struct *tty, struct file *filp)
+static void cy_close(struct tty_struct *tty, struct file *filp)
 {
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-  unsigned long flags;
+        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        unsigned long flags;
 
 #ifdef CY_DEBUG_OTHER
-    printk("cyc:cy_close ttyC%d\n", info->line);
+        printk("cyc:cy_close ttyC%d\n", info->line);
 #endif
 
-    if (!info || serial_paranoia_check(info, tty->name, "cy_close")){
-        return;
-    }
+        if (!info || serial_paranoia_check(info, tty->name, "cy_close")) {
+                return;
+        }
 
-    CY_LOCK(info, flags);
-    /* If the TTY is being hung up, nothing to do */
-    if (tty_hung_up_p(filp)) {
-        CY_UNLOCK(info, flags);
-        return;
-    }
-        
+        CY_LOCK(info, flags);
+        /* If the TTY is being hung up, nothing to do */
+        if (tty_hung_up_p(filp)) {
+                CY_UNLOCK(info, flags);
+                return;
+        }
 #ifdef CY_DEBUG_OPEN
-    printk("cyc:cy_close ttyC%d, count = %d\n", info->line, info->count);
+        printk("cyc:cy_close ttyC%d, count = %d\n", info->line, info->count);
 #endif
-    if ((tty->count == 1) && (info->count != 1)) {
-        /*
-         * Uh, oh.  tty->count is 1, which means that the tty
-         * structure will be freed.  Info->count should always
-         * be one in these conditions.  If it's greater than
-         * one, we've got real problems, since it means the
-         * serial port won't be shutdown.
-         */
-        printk("cyc:cy_close: bad serial port count; tty->count is 1, "
-           "info->count is %d\n", info->count);
-        info->count = 1;
-    }
+        if ((tty->count == 1) && (info->count != 1)) {
+                /*
+                 * Uh, oh.  tty->count is 1, which means that the tty
+                 * structure will be freed.  Info->count should always
+                 * be one in these conditions.  If it's greater than
+                 * one, we've got real problems, since it means the
+                 * serial port won't be shutdown.
+                 */
+                printk("cyc:cy_close: bad serial port count; tty->count is 1, "
+                        "info->count is %d\n", info->count);
+                info->count = 1;
+        }
 #ifdef CY_DEBUG_COUNT
-    printk("cyc:cy_close at (%d): decrementing count to %d\n",
-        current->pid, info->count - 1);
+        printk("cyc:cy_close at (%d): decrementing count to %d\n",
+                current->pid, info->count - 1);
 #endif
-    if (--info->count < 0) {
+        if (--info->count < 0) {
 #ifdef CY_DEBUG_COUNT
-    printk("cyc:cyc_close setting count to 0\n");
+                printk("cyc:cyc_close setting count to 0\n");
 #endif
-        info->count = 0;
-    }
-    if (info->count) {
-        CY_UNLOCK(info, flags);
-        return;
-    }
-    info->flags |= ASYNC_CLOSING;
-
-    /*
-    * Now we wait for the transmit buffer to clear; and we notify
-    * the line discipline to only process XON/XOFF characters.
-    */
-    tty->closing = 1;
-    CY_UNLOCK(info, flags);
-    if (info->closing_wait != CY_CLOSING_WAIT_NONE) {
-        tty_wait_until_sent(tty, info->closing_wait);
-    }
-    CY_LOCK(info, flags);
-
-    if (!IS_CYC_Z(cy_card[info->card])) {
-        int channel = info->line - cy_card[info->card].first_line;
-        int index = cy_card[info->card].bus_index;
-        void __iomem *base_addr = cy_card[info->card].base_addr + (cy_chip_offset[channel>>2] << index);
-        /* Stop accepting input */
-        channel &= 0x03;
-        cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-        cy_writeb(base_addr+(CySRER<<index),
-                        cy_readb(base_addr+(CySRER<<index)) & ~CyRxData);
-        if (info->flags & ASYNC_INITIALIZED) {
-            /* Waiting for on-board buffers to be empty before closing 
-               the port */
-            CY_UNLOCK(info, flags);
-            cy_wait_until_sent(tty, info->timeout);
-            CY_LOCK(info, flags);
+                info->count = 0;
         }
-    } else {
-#ifdef Z_WAKE
-        /* Waiting for on-board buffers to be empty before closing the port */
-        void __iomem *base_addr = cy_card[info->card].base_addr;
-        struct FIRM_ID __iomem *firm_id = base_addr + ID_ADDRESS;
-        struct ZFW_CTRL __iomem *zfw_ctrl = base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-        struct CH_CTRL __iomem *ch_ctrl = zfw_ctrl->ch_ctrl;
-        int channel = info->line - cy_card[info->card].first_line;
-        int retval;
+        if (info->count) {
+                CY_UNLOCK(info, flags);
+                return;
+        }
+        info->flags |= ASYNC_CLOSING;
 
-        if (cy_readl(&ch_ctrl[channel].flow_status) != C_FS_TXIDLE) {
-            retval = cyz_issue_cmd(&cy_card[info->card], channel, 
-                                   C_CM_IOCTLW, 0L);
-            if (retval != 0){
-                printk("cyc:cy_close retval on ttyC%d was %x\n",
-                       info->line, retval);
-            }
-            CY_UNLOCK(info, flags);
-            interruptible_sleep_on(&info->shutdown_wait);
-            CY_LOCK(info, flags);
+        /*
+         * Now we wait for the transmit buffer to clear; and we notify
+         * the line discipline to only process XON/XOFF characters.
+         */
+        tty->closing = 1;
+        CY_UNLOCK(info, flags);
+        if (info->closing_wait != CY_CLOSING_WAIT_NONE) {
+                tty_wait_until_sent(tty, info->closing_wait);
         }
+        CY_LOCK(info, flags);
+
+        if (!IS_CYC_Z(cy_card[info->card])) {
+                int channel = info->line - cy_card[info->card].first_line;
+                int index = cy_card[info->card].bus_index;
+                void __iomem *base_addr = cy_card[info->card].base_addr +
+                        (cy_chip_offset[channel >> 2] << index);
+                /* Stop accepting input */
+                channel &= 0x03;
+                cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
+                cy_writeb(base_addr + (CySRER << index),
+                          cy_readb(base_addr + (CySRER << index)) & ~CyRxData);
+                if (info->flags & ASYNC_INITIALIZED) {
+                        /* Waiting for on-board buffers to be empty before closing
+                           the port */
+                        CY_UNLOCK(info, flags);
+                        cy_wait_until_sent(tty, info->timeout);
+                        CY_LOCK(info, flags);
+                }
+        } else {
+#ifdef Z_WAKE
+                /* Waiting for on-board buffers to be empty before closing the port */
+                void __iomem *base_addr = cy_card[info->card].base_addr;
+                struct FIRM_ID __iomem *firm_id = base_addr + ID_ADDRESS;
+                struct ZFW_CTRL __iomem *zfw_ctrl =
+                    base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+                struct CH_CTRL __iomem *ch_ctrl = zfw_ctrl->ch_ctrl;
+                int channel = info->line - cy_card[info->card].first_line;
+                int retval;
+
+                if (cy_readl(&ch_ctrl[channel].flow_status) != C_FS_TXIDLE) {
+                        retval = cyz_issue_cmd(&cy_card[info->card], channel,
+                                                C_CM_IOCTLW, 0L);
+                        if (retval != 0) {
+                                printk("cyc:cy_close retval on ttyC%d was %x\n",
+                                        info->line, retval);
+                        }
+                        CY_UNLOCK(info, flags);
+                        interruptible_sleep_on(&info->shutdown_wait);
+                        CY_LOCK(info, flags);
+                }
 #endif
-    }
-
-    CY_UNLOCK(info, flags);
-    shutdown(info);
-    if (tty->driver->flush_buffer)
-        tty->driver->flush_buffer(tty);
-    tty_ldisc_flush(tty);        
-    CY_LOCK(info, flags);
-
-    tty->closing = 0;
-    info->event = 0;
-    info->tty = NULL;
-    if (info->blocked_open) {
+        }
+
         CY_UNLOCK(info, flags);
-        if (info->close_delay) {
-            msleep_interruptible(jiffies_to_msecs(info->close_delay));
-        }
-        wake_up_interruptible(&info->open_wait);
+        shutdown(info);
+        if (tty->driver->flush_buffer)
+                tty->driver->flush_buffer(tty);
+        tty_ldisc_flush(tty);
         CY_LOCK(info, flags);
-    }
-    info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
-    wake_up_interruptible(&info->close_wait);
+
+        tty->closing = 0;
+        info->event = 0;
+        info->tty = NULL;
+        if (info->blocked_open) {
+                CY_UNLOCK(info, flags);
+                if (info->close_delay) {
+                        msleep_interruptible(jiffies_to_msecs
+                                                (info->close_delay));
+                }
+                wake_up_interruptible(&info->open_wait);
+                CY_LOCK(info, flags);
+        }
+        info->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
+        wake_up_interruptible(&info->close_wait);
 
 #ifdef CY_DEBUG_OTHER
-    printk(" cyc:cy_close done\n");
+        printk(" cyc:cy_close done\n");
 #endif
 
-    CY_UNLOCK(info, flags);
-    return;
-} /* cy_close */
-
+        CY_UNLOCK(info, flags);
+}                               /* cy_close */
 
 /* This routine gets called when tty_write has put something into
  * the write_queue.  The characters may come from user space or
@@ -2817,50 +2875,49 @@ cy_close(struct tty_struct *tty, struct file *filp)
  * If the port is already active, there is no need to kick it.
  *
  */
-static int
-cy_write(struct tty_struct * tty, const unsigned char *buf, int count)
+static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
 {
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-  unsigned long flags;
-  int c, ret = 0;
+        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        unsigned long flags;
+        int c, ret = 0;
 
 #ifdef CY_DEBUG_IO
-    printk("cyc:cy_write ttyC%d\n", info->line); /* */
+        printk("cyc:cy_write ttyC%d\n", info->line);    /* */
 #endif
 
-    if (serial_paranoia_check(info, tty->name, "cy_write")){
-        return 0;
-    }
-        
-    if (!info->xmit_buf || !tmp_buf)
-        return 0;
+        if (serial_paranoia_check(info, tty->name, "cy_write")) {
+                return 0;
+        }
+
+        if (!info->xmit_buf)
+                return 0;
 
-    CY_LOCK(info, flags);
-    while (1) {
-        c = min(count, min((int)(SERIAL_XMIT_SIZE - info->xmit_cnt - 1),
-                        (int)(SERIAL_XMIT_SIZE - info->xmit_head)));
-                
-        if (c <= 0)
-            break;
-
-        memcpy(info->xmit_buf + info->xmit_head, buf, c);
-        info->xmit_head = (info->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
-        info->xmit_cnt += c;
-        buf += c;
-        count -= c;
-        ret += c;
-    }
-    CY_UNLOCK(info, flags);
-
-    info->idle_stats.xmit_bytes += ret;
-    info->idle_stats.xmit_idle   = jiffies;
-
-    if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped) {
-        start_xmit(info);
-    }
-    return ret;
-} /* cy_write */
+        CY_LOCK(info, flags);
+        while (1) {
+                c = min(count, min((int)(SERIAL_XMIT_SIZE - info->xmit_cnt - 1),
+                                   (int)(SERIAL_XMIT_SIZE - info->xmit_head)));
 
+                if (c <= 0)
+                        break;
+
+                memcpy(info->xmit_buf + info->xmit_head, buf, c);
+                info->xmit_head = (info->xmit_head + c) &
+                        (SERIAL_XMIT_SIZE - 1);
+                info->xmit_cnt += c;
+                buf += c;
+                count -= c;
+                ret += c;
+        }
+        CY_UNLOCK(info, flags);
+
+        info->idle_stats.xmit_bytes += ret;
+        info->idle_stats.xmit_idle = jiffies;
+
+        if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped) {
+                start_xmit(info);
+        }
+        return ret;
+}                               /* cy_write */
 
 /*
  * This routine is called by the kernel to write a single
@@ -2869,60 +2926,56 @@ cy_write(struct tty_struct * tty, const unsigned char *buf, int count)
  * done stuffing characters into the driver.  If there is no room
  * in the queue, the character is ignored.
  */
-static void
-cy_put_char(struct tty_struct *tty, unsigned char ch)
+static void cy_put_char(struct tty_struct *tty, unsigned char ch)
 {
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-  unsigned long flags;
+        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        unsigned long flags;
 
 #ifdef CY_DEBUG_IO
-    printk("cyc:cy_put_char ttyC%d\n", info->line);
+        printk("cyc:cy_put_char ttyC%d\n", info->line);
 #endif
 
-    if (serial_paranoia_check(info, tty->name, "cy_put_char"))
-        return;
+        if (serial_paranoia_check(info, tty->name, "cy_put_char"))
+                return;
 
-    if (!info->xmit_buf)
-        return;
+        if (!info->xmit_buf)
+                return;
 
-    CY_LOCK(info, flags);
-        if (info->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
-            CY_UNLOCK(info, flags);
-            return;
-        }
+        CY_LOCK(info, flags);
+        if (info->xmit_cnt >= (int)(SERIAL_XMIT_SIZE - 1)) {
+                CY_UNLOCK(info, flags);
+                return;
+        }
 
-        info->xmit_buf[info->xmit_head++] = ch;
-        info->xmit_head &= SERIAL_XMIT_SIZE - 1;
-        info->xmit_cnt++;
+        info->xmit_buf[info->xmit_head++] = ch;
+        info->xmit_head &= SERIAL_XMIT_SIZE - 1;
+        info->xmit_cnt++;
         info->idle_stats.xmit_bytes++;
         info->idle_stats.xmit_idle = jiffies;
-    CY_UNLOCK(info, flags);
-} /* cy_put_char */
-
+        CY_UNLOCK(info, flags);
+}                               /* cy_put_char */
 
 /*
  * This routine is called by the kernel after it has written a
  * series of characters to the tty device using put_char().  
  */
-static void
-cy_flush_chars(struct tty_struct *tty)
+static void cy_flush_chars(struct tty_struct *tty)
 {
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-                                
+        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+
 #ifdef CY_DEBUG_IO
-    printk("cyc:cy_flush_chars ttyC%d\n", info->line); /* */
+        printk("cyc:cy_flush_chars ttyC%d\n", info->line);      /* */
 #endif
 
-    if (serial_paranoia_check(info, tty->name, "cy_flush_chars"))
-        return;
-
-    if (info->xmit_cnt <= 0 || tty->stopped
-    || tty->hw_stopped || !info->xmit_buf)
-        return;
+        if (serial_paranoia_check(info, tty->name, "cy_flush_chars"))
+                return;
 
-    start_xmit(info);
-} /* cy_flush_chars */
+        if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
+                        !info->xmit_buf)
+                return;
 
+        start_xmit(info);
+}                               /* cy_flush_chars */
 
 /*
  * This routine returns the numbers of characters the tty driver
@@ -2930,75 +2983,70 @@ cy_flush_chars(struct tty_struct *tty)
  * to change as output buffers get emptied, or if the output flow
  * control is activated.
  */
-static int
-cy_write_room(struct tty_struct *tty)
+static int cy_write_room(struct tty_struct *tty)
 {
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-  int   ret;
-                                
+        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        int ret;
+
 #ifdef CY_DEBUG_IO
-    printk("cyc:cy_write_room ttyC%d\n", info->line); /* */
+        printk("cyc:cy_write_room ttyC%d\n", info->line);       /* */
 #endif
 
-    if (serial_paranoia_check(info, tty->name, "cy_write_room"))
-        return 0;
-    ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
-    if (ret < 0)
-        ret = 0;
-    return ret;
-} /* cy_write_room */
+        if (serial_paranoia_check(info, tty->name, "cy_write_room"))
+                return 0;
+        ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
+        if (ret < 0)
+                ret = 0;
+        return ret;
+}                               /* cy_write_room */
 
-
-static int
-cy_chars_in_buffer(struct tty_struct *tty)
+static int cy_chars_in_buffer(struct tty_struct *tty)
 {
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-  int card, channel;
-                                
-    if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
-        return 0;
+        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        int card, channel;
+
+        if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
+                return 0;
 
-    card = info->card;
-    channel = (info->line) - (cy_card[card].first_line);
+        card = info->card;
+        channel = (info->line) - (cy_card[card].first_line);
 
 #ifdef Z_EXT_CHARS_IN_BUFFER
-    if (!IS_CYC_Z(cy_card[card])) {
-#endif /* Z_EXT_CHARS_IN_BUFFER */
+        if (!IS_CYC_Z(cy_card[card])) {
+#endif                          /* Z_EXT_CHARS_IN_BUFFER */
 #ifdef CY_DEBUG_IO
-        printk("cyc:cy_chars_in_buffer ttyC%d %d\n",
-                info->line, info->xmit_cnt); /* */
+                printk("cyc:cy_chars_in_buffer ttyC%d %d\n", info->line, info->xmit_cnt);       /* */
 #endif
-        return info->xmit_cnt;
+                return info->xmit_cnt;
 #ifdef Z_EXT_CHARS_IN_BUFFER
-    } else {
-        static volatile struct FIRM_ID *firm_id;
-        static volatile struct ZFW_CTRL *zfw_ctrl;
-        static volatile struct CH_CTRL *ch_ctrl;
-        static volatile struct BUF_CTRL *buf_ctrl;
-        int char_count;
-        volatile uclong tx_put, tx_get, tx_bufsize;
-
-        firm_id = cy_card[card].base_addr + ID_ADDRESS;
-        zfw_ctrl = cy_card[card].base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-        ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
-        buf_ctrl = &(zfw_ctrl->buf_ctrl[channel]);
-
-        tx_get = cy_readl(&buf_ctrl->tx_get);
-        tx_put = cy_readl(&buf_ctrl->tx_put);
-        tx_bufsize = cy_readl(&buf_ctrl->tx_bufsize);
-        if (tx_put >= tx_get)
-            char_count = tx_put - tx_get;
-        else
-            char_count = tx_put - tx_get + tx_bufsize;
+        } else {
+                static volatile struct FIRM_ID *firm_id;
+                static volatile struct ZFW_CTRL *zfw_ctrl;
+                static volatile struct CH_CTRL *ch_ctrl;
+                static volatile struct BUF_CTRL *buf_ctrl;
+                int char_count;
+                volatile uclong tx_put, tx_get, tx_bufsize;
+
+                firm_id = cy_card[card].base_addr + ID_ADDRESS;
+                zfw_ctrl = cy_card[card].base_addr +
+                        (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+                ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
+                buf_ctrl = &(zfw_ctrl->buf_ctrl[channel]);
+
+                tx_get = cy_readl(&buf_ctrl->tx_get);
+                tx_put = cy_readl(&buf_ctrl->tx_put);
+                tx_bufsize = cy_readl(&buf_ctrl->tx_bufsize);
+                if (tx_put >= tx_get)
+                        char_count = tx_put - tx_get;
+                else
+                        char_count = tx_put - tx_get + tx_bufsize;
 #ifdef CY_DEBUG_IO
-        printk("cyc:cy_chars_in_buffer ttyC%d %d\n",
-                info->line, info->xmit_cnt + char_count); /* */
+                printk("cyc:cy_chars_in_buffer ttyC%d %d\n", info->line, info->xmit_cnt + char_count);  /* */
 #endif
-        return (info->xmit_cnt + char_count);
-    }
-#endif /* Z_EXT_CHARS_IN_BUFFER */
-} /* cy_chars_in_buffer */
-
+                return info->xmit_cnt + char_count;
+        }
+#endif                          /* Z_EXT_CHARS_IN_BUFFER */
+}                               /* cy_chars_in_buffer */
 
 /*
  * ------------------------------------------------------------
@@ -3006,178 +3054,179 @@ cy_chars_in_buffer(struct tty_struct *tty)
  * ------------------------------------------------------------
  */
 
-static void
-cyy_baud_calc(struct cyclades_port *info, uclong baud)
+static void cyy_baud_calc(struct cyclades_port *info, uclong baud)
 {
-    int co, co_val, bpr;
-    uclong cy_clock = ((info->chip_rev >= CD1400_REV_J) ? 60000000 : 25000000);
-
-    if (baud == 0) {
-        info->tbpr = info->tco = info->rbpr = info->rco = 0;
-        return;
-    }
-
-    /* determine which prescaler to use */
-    for (co = 4, co_val = 2048; co; co--, co_val >>= 2) {
-        if (cy_clock / co_val / baud > 63)
-            break;
-    }
-
-    bpr = (cy_clock / co_val * 2 / baud + 1) / 2;
-    if (bpr > 255)
-        bpr = 255;
-
-    info->tbpr = info->rbpr = bpr;
-    info->tco = info->rco = co;
+        int co, co_val, bpr;
+        uclong cy_clock = ((info->chip_rev >= CD1400_REV_J) ? 60000000 :
+                        25000000);
+
+        if (baud == 0) {
+                info->tbpr = info->tco = info->rbpr = info->rco = 0;
+                return;
+        }
+
+        /* determine which prescaler to use */
+        for (co = 4, co_val = 2048; co; co--, co_val >>= 2) {
+                if (cy_clock / co_val / baud > 63)
+                        break;
+        }
+
+        bpr = (cy_clock / co_val * 2 / baud + 1) / 2;
+        if (bpr > 255)
+                bpr = 255;
+
+        info->tbpr = info->rbpr = bpr;
+        info->tco = info->rco = co;
 }
 
 /*
  * This routine finds or computes the various line characteristics.
  * It used to be called config_setup
  */
-static void
-set_line_char(struct cyclades_port * info)
+static void set_line_char(struct cyclades_port *info)
 {
-  unsigned long flags;
-  void __iomem *base_addr;
-  int card,chip,channel,index;
-  unsigned cflag, iflag;
-  unsigned short chip_number;
-  int baud, baud_rate = 0;
-  int   i;
-
-
-    if (!info->tty || !info->tty->termios){
-        return;
-    }
-    if (info->line == -1){
-        return;
-    }
-    cflag = info->tty->termios->c_cflag;
-    iflag = info->tty->termios->c_iflag;
-
-    /*
-     * Set up the tty->alt_speed kludge
-     */
-    if (info->tty) {
-        if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
-            info->tty->alt_speed = 57600;
-        if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
-            info->tty->alt_speed = 115200;
-        if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
-            info->tty->alt_speed = 230400;
-        if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
-            info->tty->alt_speed = 460800;
-    }
-
-    card = info->card;
-    channel = (info->line) - (cy_card[card].first_line);
-    chip_number = channel / 4;
-
-    if (!IS_CYC_Z(cy_card[card])) {
-
-        index = cy_card[card].bus_index;
-
-        /* baud rate */
-        baud = tty_get_baud_rate(info->tty);
-        if ((baud == 38400) &&
-            ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)) {
-            if (info->custom_divisor)
-                baud_rate = info->baud / info->custom_divisor;
-            else
-                baud_rate = info->baud;
-        } else if (baud > CD1400_MAX_SPEED) {
-            baud = CD1400_MAX_SPEED;
+        unsigned long flags;
+        void __iomem *base_addr;
+        int card, chip, channel, index;
+        unsigned cflag, iflag;
+        unsigned short chip_number;
+        int baud, baud_rate = 0;
+        int i;
+
+        if (!info->tty || !info->tty->termios) {
+                return;
         }
-        /* find the baud index */
-        for (i = 0; i < 20; i++) {
-            if (baud == baud_table[i]) {
-                break;
-            }
+        if (info->line == -1) {
+                return;
         }
-        if (i == 20) {
-            i = 19; /* CD1400_MAX_SPEED */
-        } 
+        cflag = info->tty->termios->c_cflag;
+        iflag = info->tty->termios->c_iflag;
 
-        if ((baud == 38400) &&
-            ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)) {
-            cyy_baud_calc(info, baud_rate);
-        } else {
-            if(info->chip_rev >= CD1400_REV_J) {
-                /* It is a CD1400 rev. J or later */
-                info->tbpr = baud_bpr_60[i]; /* Tx BPR */
-                info->tco = baud_co_60[i]; /* Tx CO */
-                info->rbpr = baud_bpr_60[i]; /* Rx BPR */
-                info->rco = baud_co_60[i]; /* Rx CO */
-            } else {
-                info->tbpr = baud_bpr_25[i]; /* Tx BPR */
-                info->tco = baud_co_25[i]; /* Tx CO */
-                info->rbpr = baud_bpr_25[i]; /* Rx BPR */
-                info->rco = baud_co_25[i]; /* Rx CO */
-            }
-        }
-        if (baud_table[i] == 134) {
-            /* get it right for 134.5 baud */
-            info->timeout = (info->xmit_fifo_size*HZ*30/269) + 2;
-        } else if ((baud == 38400) &&
-                   ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)) {
-            info->timeout = (info->xmit_fifo_size*HZ*15/baud_rate) + 2;
-        } else if (baud_table[i]) {
-            info->timeout = (info->xmit_fifo_size*HZ*15/baud_table[i]) + 2;
-            /* this needs to be propagated into the card info */
-        } else {
-            info->timeout = 0;
-        }
-        /* By tradition (is it a standard?) a baud rate of zero
-           implies the line should be/has been closed.  A bit
-           later in this routine such a test is performed. */
-
-        /* byte size and parity */
-        info->cor5 = 0;
-        info->cor4 = 0;
-        info->cor3 = (info->default_threshold
-                      ? info->default_threshold
-                      : baud_cor3[i]); /* receive threshold */
-        info->cor2 = CyETC;
-        switch(cflag & CSIZE){
-        case CS5:
-            info->cor1 = Cy_5_BITS;
-            break;
-        case CS6:
-            info->cor1 = Cy_6_BITS;
-            break;
-        case CS7:
-            info->cor1 = Cy_7_BITS;
-            break;
-        case CS8:
-            info->cor1 = Cy_8_BITS;
-            break;
-        }
-        if(cflag & CSTOPB){
-            info->cor1 |= Cy_2_STOP;
-        }
-        if (cflag & PARENB){
-            if (cflag & PARODD){
-                info->cor1 |= CyPARITY_O;
-            }else{
-                info->cor1 |= CyPARITY_E;
-            }
-        }else{
-            info->cor1 |= CyPARITY_NONE;
-        }
-            
-        /* CTS flow control flag */
-        if (cflag & CRTSCTS){
-            info->flags |= ASYNC_CTS_FLOW;
-            info->cor2 |= CyCtsAE;
-        }else{
-            info->flags &= ~ASYNC_CTS_FLOW;
-            info->cor2 &= ~CyCtsAE;
+        /*
+         * Set up the tty->alt_speed kludge
+         */
+        if (info->tty) {
+                if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
+                        info->tty->alt_speed = 57600;
+                if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
+                        info->tty->alt_speed = 115200;
+                if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
+                        info->tty->alt_speed = 230400;
+                if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
+                        info->tty->alt_speed = 460800;
         }
-        if (cflag & CLOCAL)
-            info->flags &= ~ASYNC_CHECK_CD;
-        else
-            info->flags |= ASYNC_CHECK_CD;
+
+        card = info->card;
+        channel = (info->line) - (cy_card[card].first_line);
+        chip_number = channel / 4;
+
+        if (!IS_CYC_Z(cy_card[card])) {
+
+                index = cy_card[card].bus_index;
+
+                /* baud rate */
+                baud = tty_get_baud_rate(info->tty);
+                if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
+                                ASYNC_SPD_CUST) {
+                        if (info->custom_divisor)
+                                baud_rate = info->baud / info->custom_divisor;
+                        else
+                                baud_rate = info->baud;
+                } else if (baud > CD1400_MAX_SPEED) {
+                        baud = CD1400_MAX_SPEED;
+                }
+                /* find the baud index */
+                for (i = 0; i < 20; i++) {
+                        if (baud == baud_table[i]) {
+                                break;
+                        }
+                }
+                if (i == 20) {
+                        i = 19; /* CD1400_MAX_SPEED */
+                }
+
+                if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
+                                ASYNC_SPD_CUST) {
+                        cyy_baud_calc(info, baud_rate);
+                } else {
+                        if (info->chip_rev >= CD1400_REV_J) {
+                                /* It is a CD1400 rev. J or later */
+                                info->tbpr = baud_bpr_60[i];    /* Tx BPR */
+                                info->tco = baud_co_60[i];      /* Tx CO */
+                                info->rbpr = baud_bpr_60[i];    /* Rx BPR */
+                                info->rco = baud_co_60[i];      /* Rx CO */
+                        } else {
+                                info->tbpr = baud_bpr_25[i];    /* Tx BPR */
+                                info->tco = baud_co_25[i];      /* Tx CO */
+                                info->rbpr = baud_bpr_25[i];    /* Rx BPR */
+                                info->rco = baud_co_25[i];      /* Rx CO */
+                        }
+                }
+                if (baud_table[i] == 134) {
+                        /* get it right for 134.5 baud */
+                        info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
+                                        2;
+                } else if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
+                                ASYNC_SPD_CUST) {
+                        info->timeout = (info->xmit_fifo_size * HZ * 15 /
+                                        baud_rate) + 2;
+                } else if (baud_table[i]) {
+                        info->timeout = (info->xmit_fifo_size * HZ * 15 /
+                                        baud_table[i]) + 2;
+                        /* this needs to be propagated into the card info */
+                } else {
+                        info->timeout = 0;
+                }
+                /* By tradition (is it a standard?) a baud rate of zero
+                   implies the line should be/has been closed.  A bit
+                   later in this routine such a test is performed. */
+
+                /* byte size and parity */
+                info->cor5 = 0;
+                info->cor4 = 0;
+                /* receive threshold */
+                info->cor3 = (info->default_threshold ?
+                                info->default_threshold : baud_cor3[i]);
+                info->cor2 = CyETC;
+                switch (cflag & CSIZE) {
+                case CS5:
+                        info->cor1 = Cy_5_BITS;
+                        break;
+                case CS6:
+                        info->cor1 = Cy_6_BITS;
+                        break;
+                case CS7:
+                        info->cor1 = Cy_7_BITS;
+                        break;
+                case CS8:
+                        info->cor1 = Cy_8_BITS;
+                        break;
+                }
+                if (cflag & CSTOPB) {
+                        info->cor1 |= Cy_2_STOP;
+                }
+                if (cflag & PARENB) {
+                        if (cflag & PARODD) {
+                                info->cor1 |= CyPARITY_O;
+                        } else {
+                                info->cor1 |= CyPARITY_E;
+                        }
+                } else {
+                        info->cor1 |= CyPARITY_NONE;
+                }
+
+                /* CTS flow control flag */
+                if (cflag & CRTSCTS) {
+                        info->flags |= ASYNC_CTS_FLOW;
+                        info->cor2 |= CyCtsAE;
+                } else {
+                        info->flags &= ~ASYNC_CTS_FLOW;
+                        info->cor2 &= ~CyCtsAE;
+                }
+                if (cflag & CLOCAL)
+                        info->flags &= ~ASYNC_CHECK_CD;
+                else
+                        info->flags |= ASYNC_CHECK_CD;
 
          /***********************************************
             The hardware option, CyRtsAO, presents RTS when
@@ -3189,300 +3238,319 @@ set_line_char(struct cyclades_port * info)
             cable.  Contact Marcio Saito for details.
          ***********************************************/
 
-        chip = channel>>2;
-        channel &= 0x03;
-        base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
+                chip = channel >> 2;
+                channel &= 0x03;
+                base_addr = cy_card[card].base_addr +
+                        (cy_chip_offset[chip] << index);
 
-        CY_LOCK(info, flags);
-            cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-
-           /* tx and rx baud rate */
-
-            cy_writeb(base_addr+(CyTCOR<<index), info->tco);
-            cy_writeb(base_addr+(CyTBPR<<index), info->tbpr);
-            cy_writeb(base_addr+(CyRCOR<<index), info->rco);
-            cy_writeb(base_addr+(CyRBPR<<index), info->rbpr);
-
-            /* set line characteristics  according configuration */
-
-            cy_writeb(base_addr+(CySCHR1<<index), 
-                      START_CHAR(info->tty));
-            cy_writeb(base_addr+(CySCHR2<<index), 
-                      STOP_CHAR(info->tty));
-            cy_writeb(base_addr+(CyCOR1<<index), info->cor1);
-            cy_writeb(base_addr+(CyCOR2<<index), info->cor2);
-            cy_writeb(base_addr+(CyCOR3<<index), info->cor3);
-            cy_writeb(base_addr+(CyCOR4<<index), info->cor4);
-            cy_writeb(base_addr+(CyCOR5<<index), info->cor5);
-
-            cyy_issue_cmd(base_addr,
-                     CyCOR_CHANGE|CyCOR1ch|CyCOR2ch|CyCOR3ch,index);
-
-            cy_writeb(base_addr+(CyCAR<<index), 
-                      (u_char)channel); /* !!! Is this needed? */
-            cy_writeb(base_addr+(CyRTPR<<index), (info->default_timeout
-                                                 ? info->default_timeout
-                                                 : 0x02)); /* 10ms rx timeout */
-
-            if (C_CLOCAL(info->tty)) {
-                /* without modem intr */
-                cy_writeb(base_addr+(CySRER<<index),
-                   cy_readb(base_addr+(CySRER<<index)) | CyMdmCh); 
-                                        /* act on 1->0 modem transitions */
-                if ((cflag & CRTSCTS) && info->rflow) {
-                        cy_writeb(base_addr+(CyMCOR1<<index), 
-                                  (CyCTS|rflow_thr[i]));
-                } else {
-                        cy_writeb(base_addr+(CyMCOR1<<index), CyCTS);
-                }
-                                        /* act on 0->1 modem transitions */
-                cy_writeb(base_addr+(CyMCOR2<<index), CyCTS);
-            } else {
-                /* without modem intr */
-                cy_writeb(base_addr+(CySRER<<index),
-                   cy_readb(base_addr+(CySRER<<index)) | CyMdmCh); 
-                                        /* act on 1->0 modem transitions */
-                if ((cflag & CRTSCTS) && info->rflow) {
-                        cy_writeb(base_addr+(CyMCOR1<<index), 
-                                  (CyDSR|CyCTS|CyRI|CyDCD|rflow_thr[i]));
-                } else {
-                        cy_writeb(base_addr+(CyMCOR1<<index), 
-                                  CyDSR|CyCTS|CyRI|CyDCD);
-                }
-                                        /* act on 0->1 modem transitions */
-                cy_writeb(base_addr+(CyMCOR2<<index), 
-                          CyDSR|CyCTS|CyRI|CyDCD);
-            }
-
-            if(i == 0){ /* baud rate is zero, turn off line */
-                if (info->rtsdtr_inv) {
-                        cy_writeb(base_addr+(CyMSVR1<<index), ~CyRTS);
+                CY_LOCK(info, flags);
+                cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
+
+                /* tx and rx baud rate */
+
+                cy_writeb(base_addr + (CyTCOR << index), info->tco);
+                cy_writeb(base_addr + (CyTBPR << index), info->tbpr);
+                cy_writeb(base_addr + (CyRCOR << index), info->rco);
+                cy_writeb(base_addr + (CyRBPR << index), info->rbpr);
+
+                /* set line characteristics  according configuration */
+
+                cy_writeb(base_addr + (CySCHR1 << index),
+                          START_CHAR(info->tty));
+                cy_writeb(base_addr + (CySCHR2 << index), STOP_CHAR(info->tty));
+                cy_writeb(base_addr + (CyCOR1 << index), info->cor1);
+                cy_writeb(base_addr + (CyCOR2 << index), info->cor2);
+                cy_writeb(base_addr + (CyCOR3 << index), info->cor3);
+                cy_writeb(base_addr + (CyCOR4 << index), info->cor4);
+                cy_writeb(base_addr + (CyCOR5 << index), info->cor5);
+
+                cyy_issue_cmd(base_addr, CyCOR_CHANGE | CyCOR1ch | CyCOR2ch |
+                                CyCOR3ch, index);
+
+                cy_writeb(base_addr + (CyCAR << index), (u_char) channel);      /* !!! Is this needed? */
+                cy_writeb(base_addr + (CyRTPR << index),
+                        (info->default_timeout ? info->default_timeout : 0x02));
+                /* 10ms rx timeout */
+
+                if (C_CLOCAL(info->tty)) {
+                        /* without modem intr */
+                        cy_writeb(base_addr + (CySRER << index),
+                                  cy_readb(base_addr +
+                                           (CySRER << index)) | CyMdmCh);
+                        /* act on 1->0 modem transitions */
+                        if ((cflag & CRTSCTS) && info->rflow) {
+                                cy_writeb(base_addr + (CyMCOR1 << index),
+                                          (CyCTS | rflow_thr[i]));
+                        } else {
+                                cy_writeb(base_addr + (CyMCOR1 << index),
+                                          CyCTS);
+                        }
+                        /* act on 0->1 modem transitions */
+                        cy_writeb(base_addr + (CyMCOR2 << index), CyCTS);
                 } else {
-                        cy_writeb(base_addr+(CyMSVR2<<index), ~CyDTR);
+                        /* without modem intr */
+                        cy_writeb(base_addr + (CySRER << index),
+                                  cy_readb(base_addr +
+                                           (CySRER << index)) | CyMdmCh);
+                        /* act on 1->0 modem transitions */
+                        if ((cflag & CRTSCTS) && info->rflow) {
+                                cy_writeb(base_addr + (CyMCOR1 << index),
+                                          (CyDSR | CyCTS | CyRI | CyDCD |
+                                           rflow_thr[i]));
+                        } else {
+                                cy_writeb(base_addr + (CyMCOR1 << index),
+                                          CyDSR | CyCTS | CyRI | CyDCD);
+                        }
+                        /* act on 0->1 modem transitions */
+                        cy_writeb(base_addr + (CyMCOR2 << index),
+                                  CyDSR | CyCTS | CyRI | CyDCD);
                 }
+
+                if (i == 0) {   /* baud rate is zero, turn off line */
+                        if (info->rtsdtr_inv) {
+                                cy_writeb(base_addr + (CyMSVR1 << index),
+                                          ~CyRTS);
+                        } else {
+                                cy_writeb(base_addr + (CyMSVR2 << index),
+                                          ~CyDTR);
+                        }
 #ifdef CY_DEBUG_DTR
-                printk("cyc:set_line_char dropping DTR\n");
-                printk("     status: 0x%x, 0x%x\n", 
-                    cy_readb(base_addr+(CyMSVR1<<index)),
-                    cy_readb(base_addr+(CyMSVR2<<index)));
+                        printk("cyc:set_line_char dropping DTR\n");
+                        printk("     status: 0x%x, 0x%x\n",
+                                cy_readb(base_addr + (CyMSVR1 << index)),
+                                cy_readb(base_addr + (CyMSVR2 << index)));
 #endif
-            }else{
-                if (info->rtsdtr_inv) {
-                        cy_writeb(base_addr+(CyMSVR1<<index), CyRTS);
-                } else {
-                        cy_writeb(base_addr+(CyMSVR2<<index), CyDTR);
-                }
+                } else {
+                        if (info->rtsdtr_inv) {
+                                cy_writeb(base_addr + (CyMSVR1 << index),
+                                          CyRTS);
+                        } else {
+                                cy_writeb(base_addr + (CyMSVR2 << index),
+                                          CyDTR);
+                        }
 #ifdef CY_DEBUG_DTR
-                printk("cyc:set_line_char raising DTR\n");
-                printk("     status: 0x%x, 0x%x\n",
-                    cy_readb(base_addr+(CyMSVR1<<index)),
-                    cy_readb(base_addr+(CyMSVR2<<index)));
+                        printk("cyc:set_line_char raising DTR\n");
+                        printk("     status: 0x%x, 0x%x\n",
+                                cy_readb(base_addr + (CyMSVR1 << index)),
+                                cy_readb(base_addr + (CyMSVR2 << index)));
 #endif
-            }
-
-            if (info->tty){
-                clear_bit(TTY_IO_ERROR, &info->tty->flags);
-            }
-        CY_UNLOCK(info, flags);
+                }
 
-    } else {
-      struct FIRM_ID __iomem *firm_id;
-      struct ZFW_CTRL __iomem *zfw_ctrl;
-      struct BOARD_CTRL __iomem *board_ctrl;
-      struct CH_CTRL __iomem *ch_ctrl;
-      struct BUF_CTRL __iomem *buf_ctrl;
-      uclong sw_flow;
-      int retval;
-
-        firm_id = cy_card[card].base_addr + ID_ADDRESS;
-        if (!ISZLOADED(cy_card[card])) {
-            return;
-        }
+                if (info->tty) {
+                        clear_bit(TTY_IO_ERROR, &info->tty->flags);
+                }
+                CY_UNLOCK(info, flags);
 
-        zfw_ctrl = cy_card[card].base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-        board_ctrl = &zfw_ctrl->board_ctrl;
-        ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
-        buf_ctrl = &zfw_ctrl->buf_ctrl[channel];
-
-        /* baud rate */
-        baud = tty_get_baud_rate(info->tty);
-        if ((baud == 38400) &&
-            ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)) {
-            if (info->custom_divisor)
-                baud_rate = info->baud / info->custom_divisor;
-            else
-                baud_rate = info->baud;
-        } else if (baud > CYZ_MAX_SPEED) {
-            baud = CYZ_MAX_SPEED;
-        }
-        cy_writel(&ch_ctrl->comm_baud , baud);
-
-        if (baud == 134) {
-            /* get it right for 134.5 baud */
-            info->timeout = (info->xmit_fifo_size*HZ*30/269) + 2;
-        } else if ((baud == 38400) &&
-                   ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)) {
-            info->timeout = (info->xmit_fifo_size*HZ*15/baud_rate) + 2;
-        } else if (baud) {
-            info->timeout = (info->xmit_fifo_size*HZ*15/baud) + 2;
-            /* this needs to be propagated into the card info */
         } else {
-            info->timeout = 0;
-        }
+                struct FIRM_ID __iomem *firm_id;
+                struct ZFW_CTRL __iomem *zfw_ctrl;
+                struct BOARD_CTRL __iomem *board_ctrl;
+                struct CH_CTRL __iomem *ch_ctrl;
+                struct BUF_CTRL __iomem *buf_ctrl;
+                uclong sw_flow;
+                int retval;
+
+                firm_id = cy_card[card].base_addr + ID_ADDRESS;
+                if (!ISZLOADED(cy_card[card])) {
+                        return;
+                }
 
-        /* byte size and parity */
-        switch(cflag & CSIZE){
-        case CS5: cy_writel(&ch_ctrl->comm_data_l , C_DL_CS5); break;
-        case CS6: cy_writel(&ch_ctrl->comm_data_l , C_DL_CS6); break;
-        case CS7: cy_writel(&ch_ctrl->comm_data_l , C_DL_CS7); break;
-        case CS8: cy_writel(&ch_ctrl->comm_data_l , C_DL_CS8); break;
-        }
-        if(cflag & CSTOPB){
-            cy_writel(&ch_ctrl->comm_data_l,
-               cy_readl(&ch_ctrl->comm_data_l) | C_DL_2STOP);
-        }else{
-            cy_writel(&ch_ctrl->comm_data_l,
-               cy_readl(&ch_ctrl->comm_data_l) | C_DL_1STOP);
-        }
-        if (cflag & PARENB){
-            if (cflag & PARODD){
-                cy_writel(&ch_ctrl->comm_parity , C_PR_ODD);
-            }else{
-                cy_writel(&ch_ctrl->comm_parity , C_PR_EVEN);
-            }
-        }else{
-            cy_writel(&ch_ctrl->comm_parity , C_PR_NONE);
-        }
+                zfw_ctrl = cy_card[card].base_addr +
+                        (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+                board_ctrl = &zfw_ctrl->board_ctrl;
+                ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
+                buf_ctrl = &zfw_ctrl->buf_ctrl[channel];
+
+                /* baud rate */
+                baud = tty_get_baud_rate(info->tty);
+                if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
+                                ASYNC_SPD_CUST) {
+                        if (info->custom_divisor)
+                                baud_rate = info->baud / info->custom_divisor;
+                        else
+                                baud_rate = info->baud;
+                } else if (baud > CYZ_MAX_SPEED) {
+                        baud = CYZ_MAX_SPEED;
+                }
+                cy_writel(&ch_ctrl->comm_baud, baud);
+
+                if (baud == 134) {
+                        /* get it right for 134.5 baud */
+                        info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
+                                        2;
+                } else if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
+                                ASYNC_SPD_CUST) {
+                        info->timeout = (info->xmit_fifo_size * HZ * 15 /
+                                        baud_rate) + 2;
+                } else if (baud) {
+                        info->timeout = (info->xmit_fifo_size * HZ * 15 /
+                                        baud) + 2;
+                        /* this needs to be propagated into the card info */
+                } else {
+                        info->timeout = 0;
+                }
 
-        /* CTS flow control flag */
-        if (cflag & CRTSCTS){
-            cy_writel(&ch_ctrl->hw_flow,
-               cy_readl(&ch_ctrl->hw_flow) | C_RS_CTS | C_RS_RTS);
-        }else{
-            cy_writel(&ch_ctrl->hw_flow,
-               cy_readl(&ch_ctrl->hw_flow) & ~(C_RS_CTS | C_RS_RTS));
-        }
-        /* As the HW flow control is done in firmware, the driver doesn't
-           need to care about it */
-        info->flags &= ~ASYNC_CTS_FLOW;
-
-        /* XON/XOFF/XANY flow control flags */
-        sw_flow = 0;
-        if (iflag & IXON){
-            sw_flow |= C_FL_OXX;
-            if (iflag & IXANY)
-                sw_flow |= C_FL_OIXANY;
-        }
-        cy_writel(&ch_ctrl->sw_flow, sw_flow);
+                /* byte size and parity */
+                switch (cflag & CSIZE) {
+                case CS5:
+                        cy_writel(&ch_ctrl->comm_data_l, C_DL_CS5);
+                        break;
+                case CS6:
+                        cy_writel(&ch_ctrl->comm_data_l, C_DL_CS6);
+                        break;
+                case CS7:
+                        cy_writel(&ch_ctrl->comm_data_l, C_DL_CS7);
+                        break;
+                case CS8:
+                        cy_writel(&ch_ctrl->comm_data_l, C_DL_CS8);
+                        break;
+                }
+                if (cflag & CSTOPB) {
+                        cy_writel(&ch_ctrl->comm_data_l,
+                                  cy_readl(&ch_ctrl->comm_data_l) | C_DL_2STOP);
+                } else {
+                        cy_writel(&ch_ctrl->comm_data_l,
+                                  cy_readl(&ch_ctrl->comm_data_l) | C_DL_1STOP);
+                }
+                if (cflag & PARENB) {
+                        if (cflag & PARODD) {
+                                cy_writel(&ch_ctrl->comm_parity, C_PR_ODD);
+                        } else {
+                                cy_writel(&ch_ctrl->comm_parity, C_PR_EVEN);
+                        }
+                } else {
+                        cy_writel(&ch_ctrl->comm_parity, C_PR_NONE);
+                }
 
-        retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_IOCTL, 0L);
-        if (retval != 0){
-            printk("cyc:set_line_char retval on ttyC%d was %x\n",
-                   info->line, retval);
-        }
+                /* CTS flow control flag */
+                if (cflag & CRTSCTS) {
+                        cy_writel(&ch_ctrl->hw_flow,
+                                  cy_readl(&ch_ctrl->
+                                           hw_flow) | C_RS_CTS | C_RS_RTS);
+                } else {
+                        cy_writel(&ch_ctrl->hw_flow,
+                                  cy_readl(&ch_ctrl->
+                                           hw_flow) & ~(C_RS_CTS | C_RS_RTS));
+                }
+                /* As the HW flow control is done in firmware, the driver
+                   doesn't need to care about it */
+                info->flags &= ~ASYNC_CTS_FLOW;
+
+                /* XON/XOFF/XANY flow control flags */
+                sw_flow = 0;
+                if (iflag & IXON) {
+                        sw_flow |= C_FL_OXX;
+                        if (iflag & IXANY)
+                                sw_flow |= C_FL_OIXANY;
+                }
+                cy_writel(&ch_ctrl->sw_flow, sw_flow);
 
-        /* CD sensitivity */
-        if (cflag & CLOCAL){
-            info->flags &= ~ASYNC_CHECK_CD;
-        }else{
-            info->flags |= ASYNC_CHECK_CD;
-        }
+                retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_IOCTL, 0L);
+                if (retval != 0) {
+                        printk("cyc:set_line_char retval on ttyC%d was %x\n",
+                                info->line, retval);
+                }
 
-        if(baud == 0){ /* baud rate is zero, turn off line */
-            cy_writel(&ch_ctrl->rs_control,
-               cy_readl(&ch_ctrl->rs_control) & ~C_RS_DTR);
+                /* CD sensitivity */
+                if (cflag & CLOCAL) {
+                        info->flags &= ~ASYNC_CHECK_CD;
+                } else {
+                        info->flags |= ASYNC_CHECK_CD;
+                }
+
+                if (baud == 0) {        /* baud rate is zero, turn off line */
+                        cy_writel(&ch_ctrl->rs_control,
+                                  cy_readl(&ch_ctrl->rs_control) & ~C_RS_DTR);
 #ifdef CY_DEBUG_DTR
-            printk("cyc:set_line_char dropping Z DTR\n");
+                        printk("cyc:set_line_char dropping Z DTR\n");
 #endif
-        }else{
-            cy_writel(&ch_ctrl->rs_control,
-               cy_readl(&ch_ctrl->rs_control) | C_RS_DTR);
+                } else {
+                        cy_writel(&ch_ctrl->rs_control,
+                                  cy_readl(&ch_ctrl->rs_control) | C_RS_DTR);
 #ifdef CY_DEBUG_DTR
-            printk("cyc:set_line_char raising Z DTR\n");
+                        printk("cyc:set_line_char raising Z DTR\n");
 #endif
-        }
+                }
 
-        retval = cyz_issue_cmd( &cy_card[card], channel, C_CM_IOCTLM, 0L);
-        if (retval != 0){
-            printk("cyc:set_line_char(2) retval on ttyC%d was %x\n",
-                   info->line, retval);
-        }
+                retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_IOCTLM,0L);
+                if (retval != 0) {
+                        printk("cyc:set_line_char(2) retval on ttyC%d was %x\n",
+                                info->line, retval);
+                }
 
-        if (info->tty){
-            clear_bit(TTY_IO_ERROR, &info->tty->flags);
+                if (info->tty) {
+                        clear_bit(TTY_IO_ERROR, &info->tty->flags);
+                }
         }
-    }
-} /* set_line_char */
-
+}                               /* set_line_char */
 
 static int
-get_serial_info(struct cyclades_port * info,
-                           struct serial_struct __user * retinfo)
+get_serial_info(struct cyclades_port *info,
+                struct serial_struct __user * retinfo)
 {
-  struct serial_struct tmp;
-  struct cyclades_card *cinfo = &cy_card[info->card];
-
-    if (!retinfo)
-            return -EFAULT;
-    memset(&tmp, 0, sizeof(tmp));
-    tmp.type = info->type;
-    tmp.line = info->line;
-    tmp.port = info->card * 0x100 + info->line - cinfo->first_line;
-    tmp.irq = cinfo->irq;
-    tmp.flags = info->flags;
-    tmp.close_delay = info->close_delay;
-    tmp.baud_base = info->baud;
-    tmp.custom_divisor = info->custom_divisor;
-    tmp.hub6 = 0;               /*!!!*/
-    return copy_to_user(retinfo,&tmp,sizeof(*retinfo))?-EFAULT:0;
-} /* get_serial_info */
+        struct serial_struct tmp;
+        struct cyclades_card *cinfo = &cy_card[info->card];
 
+        if (!retinfo)
+                return -EFAULT;
+        memset(&tmp, 0, sizeof(tmp));
+        tmp.type = info->type;
+        tmp.line = info->line;
+        tmp.port = info->card * 0x100 + info->line - cinfo->first_line;
+        tmp.irq = cinfo->irq;
+        tmp.flags = info->flags;
+        tmp.close_delay = info->close_delay;
+        tmp.baud_base = info->baud;
+        tmp.custom_divisor = info->custom_divisor;
+        tmp.hub6 = 0;           /*!!! */
+        return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
+}                               /* get_serial_info */
 
 static int
-set_serial_info(struct cyclades_port * info,
-                           struct serial_struct __user * new_info)
+set_serial_info(struct cyclades_port *info,
+                struct serial_struct __user * new_info)
 {
-  struct serial_struct new_serial;
-  struct cyclades_port old_info;
-
-    if (copy_from_user(&new_serial,new_info,sizeof(new_serial)))
-        return -EFAULT;
-    old_info = *info;
-
-    if (!capable(CAP_SYS_ADMIN)) {
-            if ((new_serial.close_delay != info->close_delay) ||
-                (new_serial.baud_base != info->baud) ||
-                ((new_serial.flags & ASYNC_FLAGS & ~ASYNC_USR_MASK) !=
-                 (info->flags & ASYNC_FLAGS & ~ASYNC_USR_MASK)))
-                    return -EPERM;
-            info->flags = ((info->flags & ~ASYNC_USR_MASK) |
-                           (new_serial.flags & ASYNC_USR_MASK));
-            info->baud = new_serial.baud_base;
-            info->custom_divisor = new_serial.custom_divisor;
-            goto check_and_exit;
-    }
-
-
-    /*
-     * OK, past this point, all the error checking has been done.
-     * At this point, we start making changes.....
-     */
-
-    info->baud = new_serial.baud_base;
-    info->custom_divisor = new_serial.custom_divisor;
-    info->flags = ((info->flags & ~ASYNC_FLAGS) |
-                    (new_serial.flags & ASYNC_FLAGS));
-    info->close_delay = new_serial.close_delay * HZ/100;
-    info->closing_wait = new_serial.closing_wait * HZ/100;
+        struct serial_struct new_serial;
+        struct cyclades_port old_info;
+
+        if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
+                return -EFAULT;
+        old_info = *info;
+
+        if (!capable(CAP_SYS_ADMIN)) {
+                if (new_serial.close_delay != info->close_delay ||
+                                new_serial.baud_base != info->baud ||
+                                (new_serial.flags & ASYNC_FLAGS &
+                                        ~ASYNC_USR_MASK) !=
+                                (info->flags & ASYNC_FLAGS & ~ASYNC_USR_MASK))
+                        return -EPERM;
+                info->flags = (info->flags & ~ASYNC_USR_MASK) |
+                                (new_serial.flags & ASYNC_USR_MASK);
+                info->baud = new_serial.baud_base;
+                info->custom_divisor = new_serial.custom_divisor;
+                goto check_and_exit;
+        }
+
+        /*
+         * OK, past this point, all the error checking has been done.
+         * At this point, we start making changes.....
+         */
+
+        info->baud = new_serial.baud_base;
+        info->custom_divisor = new_serial.custom_divisor;
+        info->flags = (info->flags & ~ASYNC_FLAGS) |
+                        (new_serial.flags & ASYNC_FLAGS);
+        info->close_delay = new_serial.close_delay * HZ / 100;
+        info->closing_wait = new_serial.closing_wait * HZ / 100;
 
 check_and_exit:
-    if (info->flags & ASYNC_INITIALIZED){
-        set_line_char(info);
-        return 0;
-    }else{
-        return startup(info);
-    }
-} /* set_serial_info */
+        if (info->flags & ASYNC_INITIALIZED) {
+                set_line_char(info);
+                return 0;
+        } else {
+                return startup(info);
+        }
+}                               /* set_serial_info */
 
 /*
  * get_lsr_info - get line status register info
@@ -3494,441 +3562,452 @@ check_and_exit:
  *          transmit holding register is empty.  This functionality
  *          allows an RS485 driver to be written in user space.
  */
-static int get_lsr_info(struct cyclades_port *info, unsigned int __user *value)
+static int get_lsr_info(struct cyclades_port *info, unsigned int __user * value)
 {
-    int card, chip, channel, index;
-    unsigned char status;
-    unsigned int result;
-    unsigned long flags;
-    void __iomem *base_addr;
-
-    card = info->card;
-    channel = (info->line) - (cy_card[card].first_line);
-    if (!IS_CYC_Z(cy_card[card])) {
-        chip = channel>>2;
-        channel &= 0x03;
-        index = cy_card[card].bus_index;
-        base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
+        int card, chip, channel, index;
+        unsigned char status;
+        unsigned int result;
+        unsigned long flags;
+        void __iomem *base_addr;
 
-        CY_LOCK(info, flags);
-        status = cy_readb(base_addr+(CySRER<<index)) & (CyTxRdy|CyTxMpty);
-        CY_UNLOCK(info, flags);
-        result = (status ? 0 : TIOCSER_TEMT);
-    } else {
-        /* Not supported yet */
-        return -EINVAL;
-    }
-    return put_user(result, (unsigned long __user *) value);
+        card = info->card;
+        channel = (info->line) - (cy_card[card].first_line);
+        if (!IS_CYC_Z(cy_card[card])) {
+                chip = channel >> 2;
+                channel &= 0x03;
+                index = cy_card[card].bus_index;
+                base_addr =
+                    cy_card[card].base_addr + (cy_chip_offset[chip] << index);
+
+                CY_LOCK(info, flags);
+                status = cy_readb(base_addr + (CySRER << index)) &
+                                (CyTxRdy | CyTxMpty);
+                CY_UNLOCK(info, flags);
+                result = (status ? 0 : TIOCSER_TEMT);
+        } else {
+                /* Not supported yet */
+                return -EINVAL;
+        }
+        return put_user(result, (unsigned long __user *)value);
 }
 
-static int
-cy_tiocmget(struct tty_struct *tty, struct file *file)
+static int cy_tiocmget(struct tty_struct *tty, struct file *file)
 {
-  struct cyclades_port * info = (struct cyclades_port *)tty->driver_data;
-  int card,chip,channel,index;
-  void __iomem *base_addr;
-  unsigned long flags;
-  unsigned char status;
-  unsigned long lstatus;
-  unsigned int result;
-  struct FIRM_ID __iomem *firm_id;
-  struct ZFW_CTRL __iomem *zfw_ctrl;
-  struct BOARD_CTRL __iomem *board_ctrl;
-  struct CH_CTRL __iomem *ch_ctrl;
-
-    if (serial_paranoia_check(info, tty->name, __FUNCTION__))
-        return -ENODEV;
-
-    card = info->card;
-    channel = (info->line) - (cy_card[card].first_line);
-    if (!IS_CYC_Z(cy_card[card])) {
-        chip = channel>>2;
-        channel &= 0x03;
-        index = cy_card[card].bus_index;
-        base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
+        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        int card, chip, channel, index;
+        void __iomem *base_addr;
+        unsigned long flags;
+        unsigned char status;
+        unsigned long lstatus;
+        unsigned int result;
+        struct FIRM_ID __iomem *firm_id;
+        struct ZFW_CTRL __iomem *zfw_ctrl;
+        struct BOARD_CTRL __iomem *board_ctrl;
+        struct CH_CTRL __iomem *ch_ctrl;
+
+        if (serial_paranoia_check(info, tty->name, __FUNCTION__))
+                return -ENODEV;
 
-        CY_LOCK(info, flags);
-            cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-            status = cy_readb(base_addr+(CyMSVR1<<index));
-            status |= cy_readb(base_addr+(CyMSVR2<<index));
-        CY_UNLOCK(info, flags);
+        card = info->card;
+        channel = (info->line) - (cy_card[card].first_line);
+        if (!IS_CYC_Z(cy_card[card])) {
+                chip = channel >> 2;
+                channel &= 0x03;
+                index = cy_card[card].bus_index;
+                base_addr =
+                    cy_card[card].base_addr + (cy_chip_offset[chip] << index);
+
+                CY_LOCK(info, flags);
+                cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
+                status = cy_readb(base_addr + (CyMSVR1 << index));
+                status |= cy_readb(base_addr + (CyMSVR2 << index));
+                CY_UNLOCK(info, flags);
 
-        if (info->rtsdtr_inv) {
-            result =  ((status  & CyRTS) ? TIOCM_DTR : 0)
-                    | ((status  & CyDTR) ? TIOCM_RTS : 0);
+                if (info->rtsdtr_inv) {
+                        result = ((status & CyRTS) ? TIOCM_DTR : 0) |
+                                ((status & CyDTR) ? TIOCM_RTS : 0);
+                } else {
+                        result = ((status & CyRTS) ? TIOCM_RTS : 0) |
+                                ((status & CyDTR) ? TIOCM_DTR : 0);
+                }
+                result |= ((status & CyDCD) ? TIOCM_CAR : 0) |
+                        ((status & CyRI) ? TIOCM_RNG : 0) |
+                        ((status & CyDSR) ? TIOCM_DSR : 0) |
+                        ((status & CyCTS) ? TIOCM_CTS : 0);
         } else {
-            result =  ((status  & CyRTS) ? TIOCM_RTS : 0)
-                    | ((status  & CyDTR) ? TIOCM_DTR : 0);
-        }
-        result |=  ((status  & CyDCD) ? TIOCM_CAR : 0)
-                 | ((status  & CyRI) ? TIOCM_RNG : 0)
-                 | ((status  & CyDSR) ? TIOCM_DSR : 0)
-                 | ((status  & CyCTS) ? TIOCM_CTS : 0);
-    } else {
-        base_addr = cy_card[card].base_addr;
-
-        if (cy_card[card].num_chips != -1){
-            return -EINVAL;
-        }
+                base_addr = cy_card[card].base_addr;
 
-        firm_id = cy_card[card].base_addr + ID_ADDRESS;
-        if (ISZLOADED(cy_card[card])) {
-            zfw_ctrl = cy_card[card].base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-            board_ctrl = &zfw_ctrl->board_ctrl;
-            ch_ctrl = zfw_ctrl->ch_ctrl;
-            lstatus = cy_readl(&ch_ctrl[channel].rs_status);
-            result =  ((lstatus  & C_RS_RTS) ? TIOCM_RTS : 0)
-                    | ((lstatus  & C_RS_DTR) ? TIOCM_DTR : 0)
-                    | ((lstatus  & C_RS_DCD) ? TIOCM_CAR : 0)
-                    | ((lstatus  & C_RS_RI) ? TIOCM_RNG : 0)
-                    | ((lstatus  & C_RS_DSR) ? TIOCM_DSR : 0)
-                    | ((lstatus  & C_RS_CTS) ? TIOCM_CTS : 0);
-        }else{
-            result = 0;
-            return -ENODEV;
-        }
+                if (cy_card[card].num_chips != -1) {
+                        return -EINVAL;
+                }
 
-    }
-    return result;
-} /* cy_tiomget */
+                firm_id = cy_card[card].base_addr + ID_ADDRESS;
+                if (ISZLOADED(cy_card[card])) {
+                        zfw_ctrl = cy_card[card].base_addr +
+                                (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+                        board_ctrl = &zfw_ctrl->board_ctrl;
+                        ch_ctrl = zfw_ctrl->ch_ctrl;
+                        lstatus = cy_readl(&ch_ctrl[channel].rs_status);
+                        result = ((lstatus & C_RS_RTS) ? TIOCM_RTS : 0) |
+                                ((lstatus & C_RS_DTR) ? TIOCM_DTR : 0) |
+                                ((lstatus & C_RS_DCD) ? TIOCM_CAR : 0) |
+                                ((lstatus & C_RS_RI) ? TIOCM_RNG : 0) |
+                                ((lstatus & C_RS_DSR) ? TIOCM_DSR : 0) |
+                                ((lstatus & C_RS_CTS) ? TIOCM_CTS : 0);
+                } else {
+                        result = 0;
+                        return -ENODEV;
+                }
 
+        }
+        return result;
+}                               /* cy_tiomget */
 
 static int
 cy_tiocmset(struct tty_struct *tty, struct file *file,
-            unsigned int set, unsigned int clear)
+                unsigned int set, unsigned int clear)
 {
-  struct cyclades_port * info = (struct cyclades_port *)tty->driver_data;
-  int card,chip,channel,index;
-  void __iomem *base_addr;
-  unsigned long flags;
-  struct FIRM_ID __iomem *firm_id;
-  struct ZFW_CTRL __iomem *zfw_ctrl;
-  struct BOARD_CTRL __iomem *board_ctrl;
-  struct CH_CTRL __iomem *ch_ctrl;
-  int retval;
-
-    if (serial_paranoia_check(info, tty->name, __FUNCTION__))
-        return -ENODEV;
-
-    card = info->card;
-    channel = (info->line) - (cy_card[card].first_line);
-    if (!IS_CYC_Z(cy_card[card])) {
-        chip = channel>>2;
-        channel &= 0x03;
-        index = cy_card[card].bus_index;
-        base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
-
-        if (set & TIOCM_RTS){
-                CY_LOCK(info, flags);
-                cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-                if (info->rtsdtr_inv) {
-                        cy_writeb(base_addr+(CyMSVR2<<index), CyDTR);
-                } else {
-                        cy_writeb(base_addr+(CyMSVR1<<index), CyRTS);
-                }
-                CY_UNLOCK(info, flags);
-        }
-        if (clear & TIOCM_RTS) {
-                CY_LOCK(info, flags);
-                cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-                if (info->rtsdtr_inv) {
-                        cy_writeb(base_addr+(CyMSVR2<<index), ~CyDTR);
-                } else {
-                        cy_writeb(base_addr+(CyMSVR1<<index), ~CyRTS);
-                }
-                CY_UNLOCK(info, flags);
-        }
-        if (set & TIOCM_DTR){
-                CY_LOCK(info, flags);
-                cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-                if (info->rtsdtr_inv) {
-                        cy_writeb(base_addr+(CyMSVR1<<index), CyRTS);
-                } else {
-                        cy_writeb(base_addr+(CyMSVR2<<index), CyDTR);
-                }
+        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        int card, chip, channel, index;
+        void __iomem *base_addr;
+        unsigned long flags;
+        struct FIRM_ID __iomem *firm_id;
+        struct ZFW_CTRL __iomem *zfw_ctrl;
+        struct BOARD_CTRL __iomem *board_ctrl;
+        struct CH_CTRL __iomem *ch_ctrl;
+        int retval;
+
+        if (serial_paranoia_check(info, tty->name, __FUNCTION__))
+                return -ENODEV;
+
+        card = info->card;
+        channel = (info->line) - (cy_card[card].first_line);
+        if (!IS_CYC_Z(cy_card[card])) {
+                chip = channel >> 2;
+                channel &= 0x03;
+                index = cy_card[card].bus_index;
+                base_addr =
+                    cy_card[card].base_addr + (cy_chip_offset[chip] << index);
+
+                if (set & TIOCM_RTS) {
+                        CY_LOCK(info, flags);
+                        cy_writeb(base_addr + (CyCAR << index),
+                                  (u_char) channel);
+                        if (info->rtsdtr_inv) {
+                                cy_writeb(base_addr + (CyMSVR2 << index),
+                                          CyDTR);
+                        } else {
+                                cy_writeb(base_addr + (CyMSVR1 << index),
+                                          CyRTS);
+                        }
+                        CY_UNLOCK(info, flags);
+                }
+                if (clear & TIOCM_RTS) {
+                        CY_LOCK(info, flags);
+                        cy_writeb(base_addr + (CyCAR << index),
+                                  (u_char) channel);
+                        if (info->rtsdtr_inv) {
+                                cy_writeb(base_addr + (CyMSVR2 << index),
+                                          ~CyDTR);
+                        } else {
+                                cy_writeb(base_addr + (CyMSVR1 << index),
+                                          ~CyRTS);
+                        }
+                        CY_UNLOCK(info, flags);
+                }
+                if (set & TIOCM_DTR) {
+                        CY_LOCK(info, flags);
+                        cy_writeb(base_addr + (CyCAR << index),
+                                  (u_char) channel);
+                        if (info->rtsdtr_inv) {
+                                cy_writeb(base_addr + (CyMSVR1 << index),
+                                          CyRTS);
+                        } else {
+                                cy_writeb(base_addr + (CyMSVR2 << index),
+                                          CyDTR);
+                        }
 #ifdef CY_DEBUG_DTR
-                printk("cyc:set_modem_info raising DTR\n");
-                printk("     status: 0x%x, 0x%x\n",
-                    cy_readb(base_addr+(CyMSVR1<<index)), 
-                    cy_readb(base_addr+(CyMSVR2<<index)));
+                        printk("cyc:set_modem_info raising DTR\n");
+                        printk("     status: 0x%x, 0x%x\n",
+                                cy_readb(base_addr + (CyMSVR1 << index)),
+                                cy_readb(base_addr + (CyMSVR2 << index)));
 #endif
-                CY_UNLOCK(info, flags);
-        }
-        if (clear & TIOCM_DTR) {
-                CY_LOCK(info, flags);
-                cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-                if (info->rtsdtr_inv) {
-                        cy_writeb(base_addr+(CyMSVR1<<index), ~CyRTS);
-                } else {
-                        cy_writeb(base_addr+(CyMSVR2<<index), ~CyDTR);
-                }
+                        CY_UNLOCK(info, flags);
+                }
+                if (clear & TIOCM_DTR) {
+                        CY_LOCK(info, flags);
+                        cy_writeb(base_addr + (CyCAR << index),
+                                  (u_char) channel);
+                        if (info->rtsdtr_inv) {
+                                cy_writeb(base_addr + (CyMSVR1 << index),
+                                          ~CyRTS);
+                        } else {
+                                cy_writeb(base_addr + (CyMSVR2 << index),
+                                          ~CyDTR);
+                        }
 
 #ifdef CY_DEBUG_DTR
-                printk("cyc:set_modem_info dropping DTR\n");
-                printk("     status: 0x%x, 0x%x\n",
-                    cy_readb(base_addr+(CyMSVR1<<index)), 
-                    cy_readb(base_addr+(CyMSVR2<<index)));
+                        printk("cyc:set_modem_info dropping DTR\n");
+                        printk("     status: 0x%x, 0x%x\n",
+                                cy_readb(base_addr + (CyMSVR1 << index)),
+                                cy_readb(base_addr + (CyMSVR2 << index)));
 #endif
-                CY_UNLOCK(info, flags);
-        }
-    } else {
-        base_addr = cy_card[card].base_addr;
-
-        firm_id = cy_card[card].base_addr + ID_ADDRESS;
-        if (ISZLOADED(cy_card[card])) {
-            zfw_ctrl = cy_card[card].base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-            board_ctrl = &zfw_ctrl->board_ctrl;
-            ch_ctrl = zfw_ctrl->ch_ctrl;
-
-            if (set & TIOCM_RTS){
-                    CY_LOCK(info, flags);
-                    cy_writel(&ch_ctrl[channel].rs_control,
-                       cy_readl(&ch_ctrl[channel].rs_control) | C_RS_RTS);
-                    CY_UNLOCK(info, flags);
-            }
-            if (clear & TIOCM_RTS) {
-                    CY_LOCK(info, flags);
-                    cy_writel(&ch_ctrl[channel].rs_control,
-                       cy_readl(&ch_ctrl[channel].rs_control) & ~C_RS_RTS);
-                    CY_UNLOCK(info, flags);
-            }
-            if (set & TIOCM_DTR){
-                    CY_LOCK(info, flags);
-                    cy_writel(&ch_ctrl[channel].rs_control,
-                       cy_readl(&ch_ctrl[channel].rs_control) | C_RS_DTR);
+                        CY_UNLOCK(info, flags);
+                }
+        } else {
+                base_addr = cy_card[card].base_addr;
+
+                firm_id = cy_card[card].base_addr + ID_ADDRESS;
+                if (ISZLOADED(cy_card[card])) {
+                        zfw_ctrl = cy_card[card].base_addr +
+                                (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+                        board_ctrl = &zfw_ctrl->board_ctrl;
+                        ch_ctrl = zfw_ctrl->ch_ctrl;
+
+                        if (set & TIOCM_RTS) {
+                                CY_LOCK(info, flags);
+                                cy_writel(&ch_ctrl[channel].rs_control,
+                                          cy_readl(&ch_ctrl[channel].
+                                                   rs_control) | C_RS_RTS);
+                                CY_UNLOCK(info, flags);
+                        }
+                        if (clear & TIOCM_RTS) {
+                                CY_LOCK(info, flags);
+                                cy_writel(&ch_ctrl[channel].rs_control,
+                                          cy_readl(&ch_ctrl[channel].
+                                                   rs_control) & ~C_RS_RTS);
+                                CY_UNLOCK(info, flags);
+                        }
+                        if (set & TIOCM_DTR) {
+                                CY_LOCK(info, flags);
+                                cy_writel(&ch_ctrl[channel].rs_control,
+                                          cy_readl(&ch_ctrl[channel].
+                                                   rs_control) | C_RS_DTR);
 #ifdef CY_DEBUG_DTR
-                    printk("cyc:set_modem_info raising Z DTR\n");
+                                printk("cyc:set_modem_info raising Z DTR\n");
 #endif
-                    CY_UNLOCK(info, flags);
-            }
-            if (clear & TIOCM_DTR) {
-                    CY_LOCK(info, flags);
-                    cy_writel(&ch_ctrl[channel].rs_control,
-                       cy_readl(&ch_ctrl[channel].rs_control) & ~C_RS_DTR);
+                                CY_UNLOCK(info, flags);
+                        }
+                        if (clear & TIOCM_DTR) {
+                                CY_LOCK(info, flags);
+                                cy_writel(&ch_ctrl[channel].rs_control,
+                                          cy_readl(&ch_ctrl[channel].
+                                                   rs_control) & ~C_RS_DTR);
 #ifdef CY_DEBUG_DTR
-                    printk("cyc:set_modem_info clearing Z DTR\n");
+                                printk("cyc:set_modem_info clearing Z DTR\n");
 #endif
-                    CY_UNLOCK(info, flags);
-            }
-        }else{
-            return -ENODEV;
-        }
-        CY_LOCK(info, flags);
-        retval = cyz_issue_cmd(&cy_card[info->card],
-                                    channel, C_CM_IOCTLM,0L);
-        if (retval != 0){
-            printk("cyc:set_modem_info retval on ttyC%d was %x\n",
-                   info->line, retval);
+                                CY_UNLOCK(info, flags);
+                        }
+                } else {
+                        return -ENODEV;
+                }
+                CY_LOCK(info, flags);
+                retval = cyz_issue_cmd(&cy_card[info->card],
+                                        channel, C_CM_IOCTLM, 0L);
+                if (retval != 0) {
+                        printk("cyc:set_modem_info retval on ttyC%d was %x\n",
+                                info->line, retval);
+                }
+                CY_UNLOCK(info, flags);
         }
-        CY_UNLOCK(info, flags);
-    }
-    return 0;
-} /* cy_tiocmset */
+        return 0;
+}                               /* cy_tiocmset */
 
 /*
  * cy_break() --- routine which turns the break handling on or off
  */
-static void
-cy_break(struct tty_struct *tty, int break_state)
+static void cy_break(struct tty_struct *tty, int break_state)
 {
-    struct cyclades_port * info = (struct cyclades_port *)tty->driver_data;
-    unsigned long flags;
-
-    if (serial_paranoia_check(info, tty->name, "cy_break"))
-        return;
-
-    CY_LOCK(info, flags);
-    if (!IS_CYC_Z(cy_card[info->card])) {
-        /* Let the transmit ISR take care of this (since it
-           requires stuffing characters into the output stream).
-        */
-        if (break_state == -1) {
-            if (!info->breakon) {
-                info->breakon = 1;
-                if (!info->xmit_cnt) {
-                    CY_UNLOCK(info, flags);
-                    start_xmit(info);
-                    CY_LOCK(info, flags);
+        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        unsigned long flags;
+
+        if (serial_paranoia_check(info, tty->name, "cy_break"))
+                return;
+
+        CY_LOCK(info, flags);
+        if (!IS_CYC_Z(cy_card[info->card])) {
+                /* Let the transmit ISR take care of this (since it
+                   requires stuffing characters into the output stream).
+                 */
+                if (break_state == -1) {
+                        if (!info->breakon) {
+                                info->breakon = 1;
+                                if (!info->xmit_cnt) {
+                                        CY_UNLOCK(info, flags);
+                                        start_xmit(info);
+                                        CY_LOCK(info, flags);
+                                }
+                        }
+                } else {
+                        if (!info->breakoff) {
+                                info->breakoff = 1;
+                                if (!info->xmit_cnt) {
+                                        CY_UNLOCK(info, flags);
+                                        start_xmit(info);
+                                        CY_LOCK(info, flags);
+                                }
+                        }
                 }
-            }
         } else {
-            if (!info->breakoff) {
-                info->breakoff = 1;
-                if (!info->xmit_cnt) {
-                    CY_UNLOCK(info, flags);
-                    start_xmit(info);
-                    CY_LOCK(info, flags);
+                int retval;
+
+                if (break_state == -1) {
+                        retval = cyz_issue_cmd(&cy_card[info->card],
+                                info->line - cy_card[info->card].first_line,
+                                C_CM_SET_BREAK, 0L);
+                        if (retval != 0) {
+                                printk("cyc:cy_break (set) retval on ttyC%d "
+                                        "was %x\n", info->line, retval);
+                        }
+                } else {
+                        retval = cyz_issue_cmd(&cy_card[info->card],
+                                info->line - cy_card[info->card].first_line,
+                                C_CM_CLR_BREAK, 0L);
+                        if (retval != 0) {
+                                printk("cyc:cy_break (clr) retval on ttyC%d "
+                                        "was %x\n", info->line, retval);
+                        }
                 }
-            }
-        }
-    } else {
-        int retval;
-
-        if (break_state == -1) {
-            retval = cyz_issue_cmd(&cy_card[info->card],
-                (info->line) - (cy_card[info->card].first_line),
-                C_CM_SET_BREAK, 0L);
-            if (retval != 0) {
-                printk("cyc:cy_break (set) retval on ttyC%d was %x\n",
-                       info->line, retval);
-            }
-        } else {
-            retval = cyz_issue_cmd(&cy_card[info->card],
-                (info->line) - (cy_card[info->card].first_line),
-                C_CM_CLR_BREAK, 0L);
-            if (retval != 0) {
-                printk("cyc:cy_break (clr) retval on ttyC%d was %x\n",
-                       info->line, retval);
-            }
         }
-    }
-    CY_UNLOCK(info, flags);
-} /* cy_break */
+        CY_UNLOCK(info, flags);
+}                               /* cy_break */
 
 static int
-get_mon_info(struct cyclades_port * info, struct cyclades_monitor __user * mon)
+get_mon_info(struct cyclades_port *info, struct cyclades_monitor __user * mon)
 {
 
-    if(copy_to_user(mon, &info->mon, sizeof(struct cyclades_monitor)))
-        return -EFAULT;
-    info->mon.int_count  = 0;
-    info->mon.char_count = 0;
-    info->mon.char_max   = 0;
-    info->mon.char_last  = 0;
-    return 0;
-}/* get_mon_info */
-
+        if (copy_to_user(mon, &info->mon, sizeof(struct cyclades_monitor)))
+                return -EFAULT;
+        info->mon.int_count = 0;
+        info->mon.char_count = 0;
+        info->mon.char_max = 0;
+        info->mon.char_last = 0;
+        return 0;
+}                               /* get_mon_info */
 
-static int
-set_threshold(struct cyclades_port * info, unsigned long value)
+static int set_threshold(struct cyclades_port *info, unsigned long value)
 {
-  void __iomem *base_addr;
-  int card,channel,chip,index;
-  unsigned long flags;
-   
-    card = info->card;
-    channel = info->line - cy_card[card].first_line;
-    if (!IS_CYC_Z(cy_card[card])) {
-        chip = channel>>2;
-        channel &= 0x03;
-        index = cy_card[card].bus_index;
-        base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
-
-        info->cor3 &= ~CyREC_FIFO;
-        info->cor3 |= value & CyREC_FIFO;
+        void __iomem *base_addr;
+        int card, channel, chip, index;
+        unsigned long flags;
 
-        CY_LOCK(info, flags);
-            cy_writeb(base_addr+(CyCOR3<<index), info->cor3);
-            cyy_issue_cmd(base_addr,CyCOR_CHANGE|CyCOR3ch,index);
-        CY_UNLOCK(info, flags);
-    } else {
-        // Nothing to do!
-    }
-    return 0;
-}/* set_threshold */
+        card = info->card;
+        channel = info->line - cy_card[card].first_line;
+        if (!IS_CYC_Z(cy_card[card])) {
+                chip = channel >> 2;
+                channel &= 0x03;
+                index = cy_card[card].bus_index;
+                base_addr =
+                    cy_card[card].base_addr + (cy_chip_offset[chip] << index);
 
+                info->cor3 &= ~CyREC_FIFO;
+                info->cor3 |= value & CyREC_FIFO;
 
-static int
-get_threshold(struct cyclades_port * info, unsigned long __user *value)
-{
-  void __iomem *base_addr;
-  int card,channel,chip,index;
-  unsigned long tmp;
-   
-    card = info->card;
-    channel = info->line - cy_card[card].first_line;
-    if (!IS_CYC_Z(cy_card[card])) {
-        chip = channel>>2;
-        channel &= 0x03;
-        index = cy_card[card].bus_index;
-        base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
-
-        tmp = cy_readb(base_addr+(CyCOR3<<index)) & CyREC_FIFO;
-        return put_user(tmp,value);
-    } else {
-        // Nothing to do!
+                CY_LOCK(info, flags);
+                cy_writeb(base_addr + (CyCOR3 << index), info->cor3);
+                cyy_issue_cmd(base_addr, CyCOR_CHANGE | CyCOR3ch, index);
+                CY_UNLOCK(info, flags);
+        } else {
+                /* Nothing to do! */
+        }
         return 0;
-    }
-}/* get_threshold */
-
+}                               /* set_threshold */
 
 static int
-set_default_threshold(struct cyclades_port * info, unsigned long value)
+get_threshold(struct cyclades_port *info, unsigned long __user * value)
 {
-    info->default_threshold = value & 0x0f;
-    return 0;
-}/* set_default_threshold */
+        void __iomem *base_addr;
+        int card, channel, chip, index;
+        unsigned long tmp;
 
+        card = info->card;
+        channel = info->line - cy_card[card].first_line;
+        if (!IS_CYC_Z(cy_card[card])) {
+                chip = channel >> 2;
+                channel &= 0x03;
+                index = cy_card[card].bus_index;
+                base_addr =
+                    cy_card[card].base_addr + (cy_chip_offset[chip] << index);
+
+                tmp = cy_readb(base_addr + (CyCOR3 << index)) & CyREC_FIFO;
+                return put_user(tmp, value);
+        } else {
+                /* Nothing to do! */
+                return 0;
+        }
+}                               /* get_threshold */
 
 static int
-get_default_threshold(struct cyclades_port * info, unsigned long __user *value)
+set_default_threshold(struct cyclades_port *info, unsigned long value)
 {
-    return put_user(info->default_threshold,value);
-}/* get_default_threshold */
-
+        info->default_threshold = value & 0x0f;
+        return 0;
+}                               /* set_default_threshold */
 
 static int
-set_timeout(struct cyclades_port * info, unsigned long value)
+get_default_threshold(struct cyclades_port *info, unsigned long __user * value)
 {
-  void __iomem *base_addr;
-  int card,channel,chip,index;
-  unsigned long flags;
-   
-    card = info->card;
-    channel = info->line - cy_card[card].first_line;
-    if (!IS_CYC_Z(cy_card[card])) {
-        chip = channel>>2;
-        channel &= 0x03;
-        index = cy_card[card].bus_index;
-        base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
+        return put_user(info->default_threshold, value);
+}                               /* get_default_threshold */
 
-        CY_LOCK(info, flags);
-            cy_writeb(base_addr+(CyRTPR<<index), value & 0xff);
-        CY_UNLOCK(info, flags);
-    } else {
-        // Nothing to do!
-    }
-    return 0;
-}/* set_timeout */
+static int set_timeout(struct cyclades_port *info, unsigned long value)
+{
+        void __iomem *base_addr;
+        int card, channel, chip, index;
+        unsigned long flags;
 
+        card = info->card;
+        channel = info->line - cy_card[card].first_line;
+        if (!IS_CYC_Z(cy_card[card])) {
+                chip = channel >> 2;
+                channel &= 0x03;
+                index = cy_card[card].bus_index;
+                base_addr =
+                    cy_card[card].base_addr + (cy_chip_offset[chip] << index);
 
-static int
-get_timeout(struct cyclades_port * info, unsigned long __user *value)
-{
-  void __iomem *base_addr;
-  int card,channel,chip,index;
-  unsigned long tmp;
-   
-    card = info->card;
-    channel = info->line - cy_card[card].first_line;
-    if (!IS_CYC_Z(cy_card[card])) {
-        chip = channel>>2;
-        channel &= 0x03;
-        index = cy_card[card].bus_index;
-        base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
-
-        tmp = cy_readb(base_addr+(CyRTPR<<index));
-        return put_user(tmp,value);
-    } else {
-        // Nothing to do!
+                CY_LOCK(info, flags);
+                cy_writeb(base_addr + (CyRTPR << index), value & 0xff);
+                CY_UNLOCK(info, flags);
+        } else {
+                /* Nothing to do! */
+        }
         return 0;
-    }
-}/* get_timeout */
-
+}                               /* set_timeout */
 
-static int
-set_default_timeout(struct cyclades_port * info, unsigned long value)
+static int get_timeout(struct cyclades_port *info, unsigned long __user * value)
 {
-    info->default_timeout = value & 0xff;
-    return 0;
-}/* set_default_timeout */
+        void __iomem *base_addr;
+        int card, channel, chip, index;
+        unsigned long tmp;
 
+        card = info->card;
+        channel = info->line - cy_card[card].first_line;
+        if (!IS_CYC_Z(cy_card[card])) {
+                chip = channel >> 2;
+                channel &= 0x03;
+                index = cy_card[card].bus_index;
+                base_addr =
+                    cy_card[card].base_addr + (cy_chip_offset[chip] << index);
+
+                tmp = cy_readb(base_addr + (CyRTPR << index));
+                return put_user(tmp, value);
+        } else {
+                /* Nothing to do! */
+                return 0;
+        }
+}                               /* get_timeout */
+
+static int set_default_timeout(struct cyclades_port *info, unsigned long value)
+{
+        info->default_timeout = value & 0xff;
+        return 0;
+}                               /* set_default_timeout */
 
 static int
-get_default_timeout(struct cyclades_port * info, unsigned long __user *value)
+get_default_timeout(struct cyclades_port *info, unsigned long __user * value)
 {
-    return put_user(info->default_timeout,value);
-}/* get_default_timeout */
+        return put_user(info->default_timeout, value);
+}                               /* get_default_timeout */
 
 /*
  * This routine allows the tty driver to implement device-
@@ -3936,184 +4015,193 @@ get_default_timeout(struct cyclades_port * info, unsigned long __user *value)
  * not recognized by the driver, it should return ENOIOCTLCMD.
  */
 static int
-cy_ioctl(struct tty_struct *tty, struct file * file,
-            unsigned int cmd, unsigned long arg)
+cy_ioctl(struct tty_struct *tty, struct file *file,
+         unsigned int cmd, unsigned long arg)
 {
-  struct cyclades_port * info = (struct cyclades_port *)tty->driver_data;
-  struct cyclades_icount cprev, cnow;           /* kernel counter temps */
-  struct serial_icounter_struct __user *p_cuser;        /* user space */
-  int ret_val = 0;
-  unsigned long flags;
-  void __user *argp = (void __user *)arg;
-
-    if (serial_paranoia_check(info, tty->name, "cy_ioctl"))
-        return -ENODEV;
+        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        struct cyclades_icount cprev, cnow;     /* kernel counter temps */
+        struct serial_icounter_struct __user *p_cuser;  /* user space */
+        int ret_val = 0;
+        unsigned long flags;
+        void __user *argp = (void __user *)arg;
+
+        if (serial_paranoia_check(info, tty->name, "cy_ioctl"))
+                return -ENODEV;
 
 #ifdef CY_DEBUG_OTHER
-    printk("cyc:cy_ioctl ttyC%d, cmd = %x arg = %lx\n",
-        info->line, cmd, arg); /* */
+        printk("cyc:cy_ioctl ttyC%d, cmd = %x arg = %lx\n", info->line, cmd, arg);      /* */
 #endif
 
-    switch (cmd) {
-        case CYGETMON:
-            ret_val = get_mon_info(info, argp);
-            break;
-        case CYGETTHRESH:
-            ret_val = get_threshold(info, argp);
-            break;
-        case CYSETTHRESH:
-            ret_val = set_threshold(info, arg);
-            break;
-        case CYGETDEFTHRESH:
-            ret_val = get_default_threshold(info, argp);
-            break;
-        case CYSETDEFTHRESH:
-            ret_val = set_default_threshold(info, arg);
-            break;
-        case CYGETTIMEOUT:
-            ret_val = get_timeout(info, argp);
-            break;
-        case CYSETTIMEOUT:
-            ret_val = set_timeout(info, arg);
-            break;
-        case CYGETDEFTIMEOUT:
-            ret_val = get_default_timeout(info, argp);
-            break;
-        case CYSETDEFTIMEOUT:
-            ret_val = set_default_timeout(info, arg);
-            break;
+        switch (cmd) {
+        case CYGETMON:
+                ret_val = get_mon_info(info, argp);
+                break;
+        case CYGETTHRESH:
+                ret_val = get_threshold(info, argp);
+                break;
+        case CYSETTHRESH:
+                ret_val = set_threshold(info, arg);
+                break;
+        case CYGETDEFTHRESH:
+                ret_val = get_default_threshold(info, argp);
+                break;
+        case CYSETDEFTHRESH:
+                ret_val = set_default_threshold(info, arg);
+                break;
+        case CYGETTIMEOUT:
+                ret_val = get_timeout(info, argp);
+                break;
+        case CYSETTIMEOUT:
+                ret_val = set_timeout(info, arg);
+                break;
+        case CYGETDEFTIMEOUT:
+                ret_val = get_default_timeout(info, argp);
+                break;
+        case CYSETDEFTIMEOUT:
+                ret_val = set_default_timeout(info, arg);
+                break;
         case CYSETRFLOW:
-            info->rflow = (int)arg;
-            ret_val = 0;
-            break;
+                info->rflow = (int)arg;
+                ret_val = 0;
+                break;
         case CYGETRFLOW:
-            ret_val = info->rflow;
-            break;
+                ret_val = info->rflow;
+                break;
         case CYSETRTSDTR_INV:
-            info->rtsdtr_inv = (int)arg;
-            ret_val = 0;
-            break;
+                info->rtsdtr_inv = (int)arg;
+                ret_val = 0;
+                break;
         case CYGETRTSDTR_INV:
-            ret_val = info->rtsdtr_inv;
-            break;
+                ret_val = info->rtsdtr_inv;
+                break;
         case CYGETCARDINFO:
-            if (copy_to_user(argp, &cy_card[info->card], 
-                        sizeof (struct cyclades_card))) {
-                ret_val = -EFAULT;
+                if (copy_to_user(argp, &cy_card[info->card],
+                                 sizeof(struct cyclades_card))) {
+                        ret_val = -EFAULT;
+                        break;
+                }
+                ret_val = 0;
                 break;
-            }
-            ret_val = 0;
-            break;
         case CYGETCD1400VER:
-            ret_val = info->chip_rev;
-            break;
+                ret_val = info->chip_rev;
+                break;
 #ifndef CONFIG_CYZ_INTR
         case CYZSETPOLLCYCLE:
-            cyz_polling_cycle = (arg * HZ) / 1000;
-            ret_val = 0;
-            break;
+                cyz_polling_cycle = (arg * HZ) / 1000;
+                ret_val = 0;
+                break;
         case CYZGETPOLLCYCLE:
-            ret_val = (cyz_polling_cycle * 1000) / HZ;
-            break;
-#endif /* CONFIG_CYZ_INTR */
+                ret_val = (cyz_polling_cycle * 1000) / HZ;
+                break;
+#endif                          /* CONFIG_CYZ_INTR */
         case CYSETWAIT:
-            info->closing_wait = (unsigned short)arg * HZ/100;
-            ret_val = 0;
-            break;
+                info->closing_wait = (unsigned short)arg *HZ / 100;
+                ret_val = 0;
+                break;
         case CYGETWAIT:
-            ret_val = info->closing_wait / (HZ/100);
-            break;
-        case TIOCGSERIAL:
-            ret_val = get_serial_info(info, argp);
-            break;
-        case TIOCSSERIAL:
-            ret_val = set_serial_info(info, argp);
-            break;
-        case TIOCSERGETLSR: /* Get line status register */
-            ret_val = get_lsr_info(info, argp);
-            break;
-        /*
-         * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change 
-         * - mask passed in arg for lines of interest
-         *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
-         * Caller should use TIOCGICOUNT to see which one it was
-         */
+                ret_val = info->closing_wait / (HZ / 100);
+                break;
+        case TIOCGSERIAL:
+                ret_val = get_serial_info(info, argp);
+                break;
+        case TIOCSSERIAL:
+                ret_val = set_serial_info(info, argp);
+                break;
+        case TIOCSERGETLSR:     /* Get line status register */
+                ret_val = get_lsr_info(info, argp);
+                break;
+                /*
+                 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
+                 * - mask passed in arg for lines of interest
+                 *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
+                 * Caller should use TIOCGICOUNT to see which one it was
+                 */
         case TIOCMIWAIT:
-            CY_LOCK(info, flags);
-            /* note the counters on entry */
-            cprev = info->icount;
-            CY_UNLOCK(info, flags);
-            while (1) {
-                interruptible_sleep_on(&info->delta_msr_wait);
-                /* see if a signal did it */
-                if (signal_pending(current)) {
-                    return -ERESTARTSYS;
-                }
-
                 CY_LOCK(info, flags);
-                cnow = info->icount; /* atomic copy */
+                /* note the counters on entry */
+                cprev = info->icount;
                 CY_UNLOCK(info, flags);
+                while (1) {
+                        interruptible_sleep_on(&info->delta_msr_wait);
+                        /* see if a signal did it */
+                        if (signal_pending(current)) {
+                                return -ERESTARTSYS;
+                        }
 
-                if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr && 
-                    cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) {
-                    return -EIO; /* no change => error */
-                }
-                if ( ((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) || 
-                     ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) || 
-                     ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) || 
-                     ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) {
-                    return 0;
-                }
-                cprev = cnow;
-            }
-            /* NOTREACHED */
+                        CY_LOCK(info, flags);
+                        cnow = info->icount;    /* atomic copy */
+                        CY_UNLOCK(info, flags);
 
-        /*
-         * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
-         * Return: write counters to the user passed counter struct
-         * NB: both 1->0 and 0->1 transitions are counted except for
-         *     RI where only 0->1 is counted.
-         */
+                        if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
+                            cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) {
+                                return -EIO;    /* no change => error */
+                        }
+                        if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
+                            ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
+                            ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
+                            ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
+                                return 0;
+                        }
+                        cprev = cnow;
+                }
+                /* NOTREACHED */
+
+                /*
+                 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
+                 * Return: write counters to the user passed counter struct
+                 * NB: both 1->0 and 0->1 transitions are counted except for
+                 *     RI where only 0->1 is counted.
+                 */
         case TIOCGICOUNT:
-            CY_LOCK(info, flags);
-            cnow = info->icount;
-            CY_UNLOCK(info, flags);
-            p_cuser = argp;
-            ret_val = put_user(cnow.cts, &p_cuser->cts);
-            if (ret_val) return ret_val;
-            ret_val = put_user(cnow.dsr, &p_cuser->dsr);
-            if (ret_val) return ret_val;
-            ret_val = put_user(cnow.rng, &p_cuser->rng);
-            if (ret_val) return ret_val;
-            ret_val = put_user(cnow.dcd, &p_cuser->dcd);
-            if (ret_val) return ret_val;
-            ret_val = put_user(cnow.rx, &p_cuser->rx);
-            if (ret_val) return ret_val;
-            ret_val = put_user(cnow.tx, &p_cuser->tx);
-            if (ret_val) return ret_val;
-            ret_val = put_user(cnow.frame, &p_cuser->frame);
-            if (ret_val) return ret_val;
-            ret_val = put_user(cnow.overrun, &p_cuser->overrun);
-            if (ret_val) return ret_val;
-            ret_val = put_user(cnow.parity, &p_cuser->parity);
-            if (ret_val) return ret_val;
-            ret_val = put_user(cnow.brk, &p_cuser->brk);
-            if (ret_val) return ret_val;
-            ret_val = put_user(cnow.buf_overrun, &p_cuser->buf_overrun);
-            if (ret_val) return ret_val;
-            ret_val = 0;
-            break;
-        default:
-            ret_val = -ENOIOCTLCMD;
-    }
+                CY_LOCK(info, flags);
+                cnow = info->icount;
+                CY_UNLOCK(info, flags);
+                p_cuser = argp;
+                ret_val = put_user(cnow.cts, &p_cuser->cts);
+                if (ret_val)
+                        return ret_val;
+                ret_val = put_user(cnow.dsr, &p_cuser->dsr);
+                if (ret_val)
+                        return ret_val;
+                ret_val = put_user(cnow.rng, &p_cuser->rng);
+                if (ret_val)
+                        return ret_val;
+                ret_val = put_user(cnow.dcd, &p_cuser->dcd);
+                if (ret_val)
+                        return ret_val;
+                ret_val = put_user(cnow.rx, &p_cuser->rx);
+                if (ret_val)
+                        return ret_val;
+                ret_val = put_user(cnow.tx, &p_cuser->tx);
+                if (ret_val)
+                        return ret_val;
+                ret_val = put_user(cnow.frame, &p_cuser->frame);
+                if (ret_val)
+                        return ret_val;
+                ret_val = put_user(cnow.overrun, &p_cuser->overrun);
+                if (ret_val)
+                        return ret_val;
+                ret_val = put_user(cnow.parity, &p_cuser->parity);
+                if (ret_val)
+                        return ret_val;
+                ret_val = put_user(cnow.brk, &p_cuser->brk);
+                if (ret_val)
+                        return ret_val;
+                ret_val = put_user(cnow.buf_overrun, &p_cuser->buf_overrun);
+                if (ret_val)
+                        return ret_val;
+                ret_val = 0;
+                break;
+        default:
+                ret_val = -ENOIOCTLCMD;
+        }
 
 #ifdef CY_DEBUG_OTHER
-    printk(" cyc:cy_ioctl done\n");
+        printk(" cyc:cy_ioctl done\n");
 #endif
 
-    return ret_val;
-} /* cy_ioctl */
-
+        return ret_val;
+}                               /* cy_ioctl */
 
 /*
  * This routine allows the tty driver to be notified when
@@ -4121,66 +4209,64 @@ cy_ioctl(struct tty_struct *tty, struct file * file,
  * well-designed tty driver should be prepared to accept the case
  * where old == NULL, and try to do something rational.
  */
-static void
-cy_set_termios(struct tty_struct *tty, struct termios * old_termios)
+static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
 {
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
 
 #ifdef CY_DEBUG_OTHER
-    printk("cyc:cy_set_termios ttyC%d\n", info->line);
+        printk("cyc:cy_set_termios ttyC%d\n", info->line);
 #endif
 
-    if ((tty->termios->c_cflag == old_termios->c_cflag) &&
-        ((tty->termios->c_iflag & (IXON|IXANY)) == 
-         (old_termios->c_iflag & (IXON|IXANY))))
-        return;
-    set_line_char(info);
-
-    if ((old_termios->c_cflag & CRTSCTS) &&
-        !(tty->termios->c_cflag & CRTSCTS)) {
-            tty->hw_stopped = 0;
-            cy_start(tty);
-    }
+        if (tty->termios->c_cflag == old_termios->c_cflag &&
+                        (tty->termios->c_iflag & (IXON | IXANY)) ==
+                        (old_termios->c_iflag & (IXON | IXANY)))
+                return;
+        set_line_char(info);
+
+        if ((old_termios->c_cflag & CRTSCTS) &&
+                        !(tty->termios->c_cflag & CRTSCTS)) {
+                tty->hw_stopped = 0;
+                cy_start(tty);
+        }
 #if 0
-    /*
-     * No need to wake up processes in open wait, since they
-     * sample the CLOCAL flag once, and don't recheck it.
-     * XXX  It's not clear whether the current behavior is correct
-     * or not.  Hence, this may change.....
-     */
-    if (!(old_termios->c_cflag & CLOCAL) &&
-        (tty->termios->c_cflag & CLOCAL))
-            wake_up_interruptible(&info->open_wait);
+        /*
+         * No need to wake up processes in open wait, since they
+         * sample the CLOCAL flag once, and don't recheck it.
+         * XXX  It's not clear whether the current behavior is correct
+         * or not.  Hence, this may change.....
+         */
+        if (!(old_termios->c_cflag & CLOCAL) &&
+            (tty->termios->c_cflag & CLOCAL))
+                wake_up_interruptible(&info->open_wait);
 #endif
-
-    return;
-} /* cy_set_termios */
+}                               /* cy_set_termios */
 
 /* This function is used to send a high-priority XON/XOFF character to
    the device.
 */
-static void
-cy_send_xchar (struct tty_struct *tty, char ch)
+static void cy_send_xchar(struct tty_struct *tty, char ch)
 {
-        struct cyclades_port *info = (struct cyclades_port *) tty->driver_data;
+        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
         int card, channel;
 
-        if (serial_paranoia_check (info, tty->name, "cy_send_xchar"))
+        if (serial_paranoia_check(info, tty->name, "cy_send_xchar"))
                 return;
 
-        info->x_char = ch;
+        info->x_char = ch;
 
         if (ch)
-                cy_start (tty);
+                cy_start(tty);
 
         card = info->card;
         channel = info->line - cy_card[card].first_line;
 
-        if (IS_CYC_Z (cy_card[card])) {
-                if (ch == STOP_CHAR (tty))
-                        cyz_issue_cmd (&cy_card[card], channel, C_CM_SENDXOFF, 0L);
-                else if (ch == START_CHAR (tty))
-                        cyz_issue_cmd (&cy_card[card], channel, C_CM_SENDXON, 0L);
+        if (IS_CYC_Z(cy_card[card])) {
+                if (ch == STOP_CHAR(tty))
+                        cyz_issue_cmd(&cy_card[card], channel, C_CM_SENDXOFF,
+                                        0L);
+                else if (ch == START_CHAR(tty))
+                        cyz_issue_cmd(&cy_card[card], channel, C_CM_SENDXON,
+                                        0L);
         }
 }
 
@@ -4188,260 +4274,248 @@ cy_send_xchar (struct tty_struct *tty, char ch)
    that incoming characters should be throttled because the input
    buffers are close to full.
  */
-static void
-cy_throttle(struct tty_struct * tty)
+static void cy_throttle(struct tty_struct *tty)
 {
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-  unsigned long flags;
-  void __iomem *base_addr;
-  int card,chip,channel,index;
+        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        unsigned long flags;
+        void __iomem *base_addr;
+        int card, chip, channel, index;
 
 #ifdef CY_DEBUG_THROTTLE
-  char buf[64];
+        char buf[64];
 
-    printk("cyc:throttle %s: %d....ttyC%d\n", 
-           tty_name(tty, buf),
-           tty->ldisc.chars_in_buffer(tty), info->line);
+        printk("cyc:throttle %s: %d....ttyC%d\n", tty_name(tty, buf),
+                        tty->ldisc.chars_in_buffer(tty), info->line);
 #endif
 
-    if (serial_paranoia_check(info, tty->name, "cy_throttle")){
-            return;
-    }
-
-    card = info->card;
-
-    if (I_IXOFF(tty)) {
-        if (!IS_CYC_Z (cy_card[card]))
-            cy_send_xchar (tty, STOP_CHAR (tty));
-        else
-            info->throttle = 1;
-    }
-
-    if (tty->termios->c_cflag & CRTSCTS) {
-        channel = info->line - cy_card[card].first_line;
-        if (!IS_CYC_Z(cy_card[card])) {
-            chip = channel>>2;
-            channel &= 0x03;
-            index = cy_card[card].bus_index;
-            base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
-
-            CY_LOCK(info, flags);
-            cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-            if (info->rtsdtr_inv) {
-                cy_writeb(base_addr+(CyMSVR2<<index), ~CyDTR);
-             } else {
-                cy_writeb(base_addr+(CyMSVR1<<index), ~CyRTS);
-             }
-            CY_UNLOCK(info, flags);
-        } else {
-            info->throttle = 1;
-        }
-    }
+        if (serial_paranoia_check(info, tty->name, "cy_throttle")) {
+                return;
+        }
+
+        card = info->card;
 
-    return;
-} /* cy_throttle */
+        if (I_IXOFF(tty)) {
+                if (!IS_CYC_Z(cy_card[card]))
+                        cy_send_xchar(tty, STOP_CHAR(tty));
+                else
+                        info->throttle = 1;
+        }
 
+        if (tty->termios->c_cflag & CRTSCTS) {
+                channel = info->line - cy_card[card].first_line;
+                if (!IS_CYC_Z(cy_card[card])) {
+                        chip = channel >> 2;
+                        channel &= 0x03;
+                        index = cy_card[card].bus_index;
+                        base_addr = cy_card[card].base_addr +
+                                (cy_chip_offset[chip] << index);
+
+                        CY_LOCK(info, flags);
+                        cy_writeb(base_addr + (CyCAR << index),
+                                  (u_char) channel);
+                        if (info->rtsdtr_inv) {
+                                cy_writeb(base_addr + (CyMSVR2 << index),
+                                          ~CyDTR);
+                        } else {
+                                cy_writeb(base_addr + (CyMSVR1 << index),
+                                          ~CyRTS);
+                        }
+                        CY_UNLOCK(info, flags);
+                } else {
+                        info->throttle = 1;
+                }
+        }
+}                               /* cy_throttle */
 
 /*
  * This routine notifies the tty driver that it should signal
  * that characters can now be sent to the tty without fear of
  * overrunning the input buffers of the line disciplines.
  */
-static void
-cy_unthrottle(struct tty_struct * tty)
+static void cy_unthrottle(struct tty_struct *tty)
 {
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-  unsigned long flags;
-  void __iomem *base_addr;
-  int card,chip,channel,index;
+        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        unsigned long flags;
+        void __iomem *base_addr;
+        int card, chip, channel, index;
 
 #ifdef CY_DEBUG_THROTTLE
-  char buf[64];
-        
-    printk("cyc:unthrottle %s: %d....ttyC%d\n", 
-           tty_name(tty, buf),
-           tty->ldisc.chars_in_buffer(tty), info->line);
-#endif
+        char buf[64];
 
-    if (serial_paranoia_check(info, tty->name, "cy_unthrottle")){
-            return;
-    }
+        printk("cyc:unthrottle %s: %d....ttyC%d\n", tty_name(tty, buf),
+                tty->ldisc.chars_in_buffer(tty), info->line);
+#endif
 
-    if (I_IXOFF(tty)) {
-        if (info->x_char)
-            info->x_char = 0;
-        else
-            cy_send_xchar (tty, START_CHAR (tty));
-    }
-
-    if (tty->termios->c_cflag & CRTSCTS) {
-        card = info->card;
-        channel = info->line - cy_card[card].first_line;
-        if (!IS_CYC_Z(cy_card[card])) {
-            chip = channel>>2;
-            channel &= 0x03;
-            index = cy_card[card].bus_index;
-            base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
-
-            CY_LOCK(info, flags);
-            cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-            if (info->rtsdtr_inv) {
-                    cy_writeb(base_addr+(CyMSVR2<<index), CyDTR);
-            } else {
-                    cy_writeb(base_addr+(CyMSVR1<<index), CyRTS);
-            }
-            CY_UNLOCK(info, flags);
-        } else {
-            info->throttle = 0;
+        if (serial_paranoia_check(info, tty->name, "cy_unthrottle")) {
+                return;
         }
-    }
 
-    return;
-} /* cy_unthrottle */
+        if (I_IXOFF(tty)) {
+                if (info->x_char)
+                        info->x_char = 0;
+                else
+                        cy_send_xchar(tty, START_CHAR(tty));
+        }
 
+        if (tty->termios->c_cflag & CRTSCTS) {
+                card = info->card;
+                channel = info->line - cy_card[card].first_line;
+                if (!IS_CYC_Z(cy_card[card])) {
+                        chip = channel >> 2;
+                        channel &= 0x03;
+                        index = cy_card[card].bus_index;
+                        base_addr = cy_card[card].base_addr +
+                                (cy_chip_offset[chip] << index);
+
+                        CY_LOCK(info, flags);
+                        cy_writeb(base_addr + (CyCAR << index),
+                                  (u_char) channel);
+                        if (info->rtsdtr_inv) {
+                                cy_writeb(base_addr + (CyMSVR2 << index),
+                                          CyDTR);
+                        } else {
+                                cy_writeb(base_addr + (CyMSVR1 << index),
+                                          CyRTS);
+                        }
+                        CY_UNLOCK(info, flags);
+                } else {
+                        info->throttle = 0;
+                }
+        }
+}                               /* cy_unthrottle */
 
 /* cy_start and cy_stop provide software output flow control as a
    function of XON/XOFF, software CTS, and other such stuff.
 */
-static void
-cy_stop(struct tty_struct *tty)
+static void cy_stop(struct tty_struct *tty)
 {
-  struct cyclades_card *cinfo;
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-  void __iomem *base_addr;
-  int chip,channel,index;
-  unsigned long flags;
+        struct cyclades_card *cinfo;
+        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        void __iomem *base_addr;
+        int chip, channel, index;
+        unsigned long flags;
 
 #ifdef CY_DEBUG_OTHER
-    printk("cyc:cy_stop ttyC%d\n", info->line); /* */
+        printk("cyc:cy_stop ttyC%d\n", info->line);     /* */
 #endif
 
-    if (serial_paranoia_check(info, tty->name, "cy_stop"))
-        return;
-        
-    cinfo = &cy_card[info->card];
-    channel = info->line - cinfo->first_line;
-    if (!IS_CYC_Z(*cinfo)) {
-        index = cinfo->bus_index;
-        chip = channel>>2;
-        channel &= 0x03;
-        base_addr = cy_card[info->card].base_addr + (cy_chip_offset[chip]<<index);
-
-        CY_LOCK(info, flags);
-            cy_writeb(base_addr+(CyCAR<<index),
-               (u_char)(channel & 0x0003)); /* index channel */
-            cy_writeb(base_addr+(CySRER<<index), 
-               cy_readb(base_addr+(CySRER<<index)) & ~CyTxRdy);
-        CY_UNLOCK(info, flags);
-    } else {
-        // Nothing to do!
-    }
+        if (serial_paranoia_check(info, tty->name, "cy_stop"))
+                return;
 
-    return;
-} /* cy_stop */
+        cinfo = &cy_card[info->card];
+        channel = info->line - cinfo->first_line;
+        if (!IS_CYC_Z(*cinfo)) {
+                index = cinfo->bus_index;
+                chip = channel >> 2;
+                channel &= 0x03;
+                base_addr = cy_card[info->card].base_addr +
+                        (cy_chip_offset[chip] << index);
 
+                CY_LOCK(info, flags);
+                cy_writeb(base_addr + (CyCAR << index),
+                        (u_char)(channel & 0x0003)); /* index channel */
+                cy_writeb(base_addr + (CySRER << index),
+                          cy_readb(base_addr + (CySRER << index)) & ~CyTxRdy);
+                CY_UNLOCK(info, flags);
+        } else {
+                /* Nothing to do! */
+        }
+}                               /* cy_stop */
 
-static void
-cy_start(struct tty_struct *tty)
+static void cy_start(struct tty_struct *tty)
 {
-  struct cyclades_card *cinfo;
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-  void __iomem *base_addr;
-  int chip,channel,index;
-  unsigned long flags;
+        struct cyclades_card *cinfo;
+        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        void __iomem *base_addr;
+        int chip, channel, index;
+        unsigned long flags;
 
 #ifdef CY_DEBUG_OTHER
-    printk("cyc:cy_start ttyC%d\n", info->line); /* */
+        printk("cyc:cy_start ttyC%d\n", info->line);    /* */
 #endif
 
-    if (serial_paranoia_check(info, tty->name, "cy_start"))
-        return;
-        
-    cinfo = &cy_card[info->card];
-    channel = info->line - cinfo->first_line;
-    index = cinfo->bus_index;
-    if (!IS_CYC_Z(*cinfo)) {
-        chip = channel>>2;
-        channel &= 0x03;
-        base_addr = cy_card[info->card].base_addr + (cy_chip_offset[chip]<<index);
-
-        CY_LOCK(info, flags);
-            cy_writeb(base_addr+(CyCAR<<index),
-               (u_char)(channel & 0x0003)); /* index channel */
-            cy_writeb(base_addr+(CySRER<<index), 
-               cy_readb(base_addr+(CySRER<<index)) | CyTxRdy);
-        CY_UNLOCK(info, flags);
-    } else {
-        // Nothing to do!
-    }
+        if (serial_paranoia_check(info, tty->name, "cy_start"))
+                return;
 
-    return;
-} /* cy_start */
+        cinfo = &cy_card[info->card];
+        channel = info->line - cinfo->first_line;
+        index = cinfo->bus_index;
+        if (!IS_CYC_Z(*cinfo)) {
+                chip = channel >> 2;
+                channel &= 0x03;
+                base_addr = cy_card[info->card].base_addr +
+                        (cy_chip_offset[chip] << index);
 
+                CY_LOCK(info, flags);
+                cy_writeb(base_addr + (CyCAR << index), (u_char) (channel & 0x0003));   /* index channel */
+                cy_writeb(base_addr + (CySRER << index),
+                          cy_readb(base_addr + (CySRER << index)) | CyTxRdy);
+                CY_UNLOCK(info, flags);
+        } else {
+                /* Nothing to do! */
+        }
+}                               /* cy_start */
 
-static void
-cy_flush_buffer(struct tty_struct *tty)
+static void cy_flush_buffer(struct tty_struct *tty)
 {
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-  int card, channel, retval;
-  unsigned long flags;
-                                
+        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        int card, channel, retval;
+        unsigned long flags;
+
 #ifdef CY_DEBUG_IO
-    printk("cyc:cy_flush_buffer ttyC%d\n", info->line); /* */
+        printk("cyc:cy_flush_buffer ttyC%d\n", info->line);     /* */
 #endif
 
-    if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
-        return;
-
-    card = info->card;
-    channel = (info->line) - (cy_card[card].first_line);
+        if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
+                return;
 
-    CY_LOCK(info, flags);
-    info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
-    CY_UNLOCK(info, flags);
+        card = info->card;
+        channel = (info->line) - (cy_card[card].first_line);
 
-    if (IS_CYC_Z(cy_card[card])) { /* If it is a Z card, flush the on-board 
-                                      buffers as well */
         CY_LOCK(info, flags);
-        retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_FLUSH_TX, 0L);
-        if (retval != 0) {
-            printk("cyc: flush_buffer retval on ttyC%d was %x\n",
-                   info->line, retval);
-        }
+        info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
         CY_UNLOCK(info, flags);
-    }
-    tty_wakeup(tty);
-    wake_up_interruptible(&tty->write_wait);
-} /* cy_flush_buffer */
 
+        if (IS_CYC_Z(cy_card[card])) {  /* If it is a Z card, flush the on-board
+                                           buffers as well */
+                CY_LOCK(info, flags);
+                retval =
+                    cyz_issue_cmd(&cy_card[card], channel, C_CM_FLUSH_TX, 0L);
+                if (retval != 0) {
+                        printk("cyc: flush_buffer retval on ttyC%d was %x\n",
+                                info->line, retval);
+                }
+                CY_UNLOCK(info, flags);
+        }
+        tty_wakeup(tty);
+        wake_up_interruptible(&tty->write_wait);
+}                               /* cy_flush_buffer */
 
 /*
  * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
  */
-static void
-cy_hangup(struct tty_struct *tty)
+static void cy_hangup(struct tty_struct *tty)
 {
-  struct cyclades_port * info = (struct cyclades_port *)tty->driver_data;
-        
+        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+
 #ifdef CY_DEBUG_OTHER
-    printk("cyc:cy_hangup ttyC%d\n", info->line); /* */
+        printk("cyc:cy_hangup ttyC%d\n", info->line);   /* */
 #endif
 
-    if (serial_paranoia_check(info, tty->name, "cy_hangup"))
-        return;
+        if (serial_paranoia_check(info, tty->name, "cy_hangup"))
+                return;
 
-    cy_flush_buffer(tty);
-    shutdown(info);
-    info->event = 0;
-    info->count = 0;
+        cy_flush_buffer(tty);
+        shutdown(info);
+        info->event = 0;
+        info->count = 0;
 #ifdef CY_DEBUG_COUNT
-    printk("cyc:cy_hangup (%d): setting count to 0\n", current->pid);
+        printk("cyc:cy_hangup (%d): setting count to 0\n", current->pid);
 #endif
-    info->tty = NULL;
-    info->flags &= ~ASYNC_NORMAL_ACTIVE;
-    wake_up_interruptible(&info->open_wait);
-} /* cy_hangup */
-
+        info->tty = NULL;
+        info->flags &= ~ASYNC_NORMAL_ACTIVE;
+        wake_up_interruptible(&info->open_wait);
+}                               /* cy_hangup */
 
 /*
  * ---------------------------------------------------------------------
@@ -4454,82 +4528,84 @@ cy_hangup(struct tty_struct *tty)
 /* initialize chips on Cyclom-Y card -- return number of valid
    chips (which is number of ports/4) */
 static unsigned short __init
-cyy_init_card(void __iomem *true_base_addr,int index)
+cyy_init_card(void __iomem * true_base_addr, int index)
 {
-  unsigned int chip_number;
-  void __iomem *base_addr;
-
-    cy_writeb(true_base_addr+(Cy_HwReset<<index), 0); 
-                                                /* Cy_HwReset is 0x1400 */
-    cy_writeb(true_base_addr+(Cy_ClrIntr<<index), 0); 
-                                                /* Cy_ClrIntr is 0x1800 */
-    udelay(500L);
-
-    for(chip_number=0; chip_number<CyMAX_CHIPS_PER_CARD; chip_number++){
-        base_addr = true_base_addr + (cy_chip_offset[chip_number]<<index);
-        mdelay(1);
-        if(cy_readb(base_addr+(CyCCR<<index)) != 0x00){
-            /*************
-            printk(" chip #%d at %#6lx is never idle (CCR != 0)\n",
-               chip_number, (unsigned long)base_addr);
-            *************/
-            return chip_number;
-        }
-
-        cy_writeb(base_addr+(CyGFRCR<<index), 0);
-        udelay(10L);
-
-        /* The Cyclom-16Y does not decode address bit 9 and therefore
-           cannot distinguish between references to chip 0 and a non-
-           existent chip 4.  If the preceding clearing of the supposed
-           chip 4 GFRCR register appears at chip 0, there is no chip 4
-           and this must be a Cyclom-16Y, not a Cyclom-32Ye.
-        */
-        if (chip_number == 4
-        && cy_readb(true_base_addr
-            + (cy_chip_offset[0]<<index)
-            + (CyGFRCR<<index)) == 0){
-            return chip_number;
-        }
-
-        cy_writeb(base_addr+(CyCCR<<index), CyCHIP_RESET);
-        mdelay(1);
-
-        if(cy_readb(base_addr+(CyGFRCR<<index)) == 0x00){
-            /*
-            printk(" chip #%d at %#6lx is not responding ",
-               chip_number, (unsigned long)base_addr);
-            printk("(GFRCR stayed 0)\n",
-            */
-            return chip_number;
-        }
-        if((0xf0 & (cy_readb(base_addr+(CyGFRCR<<index)))) != 0x40){
-            /*
-            printk(" chip #%d at %#6lx is not valid (GFRCR == %#2x)\n",
-               chip_number, (unsigned long)base_addr,
-               base_addr[CyGFRCR<<index]);
-            */
-            return chip_number;
-        }
-        cy_writeb(base_addr+(CyGCR<<index), CyCH0_SERIAL);
-        if (cy_readb(base_addr+(CyGFRCR<<index)) >= CD1400_REV_J){
-            /* It is a CD1400 rev. J or later */
-            /* Impossible to reach 5ms with this chip. 
-               Changed to 2ms instead (f = 500 Hz). */
-            cy_writeb(base_addr+(CyPPR<<index), CyCLOCK_60_2MS);
-        } else {
-            /* f = 200 Hz */
-            cy_writeb(base_addr+(CyPPR<<index), CyCLOCK_25_5MS);
-        }
+        unsigned int chip_number;
+        void __iomem *base_addr;
+
+        cy_writeb(true_base_addr + (Cy_HwReset << index), 0);
+        /* Cy_HwReset is 0x1400 */
+        cy_writeb(true_base_addr + (Cy_ClrIntr << index), 0);
+        /* Cy_ClrIntr is 0x1800 */
+        udelay(500L);
+
+        for (chip_number = 0; chip_number < CyMAX_CHIPS_PER_CARD; chip_number++) {
+                base_addr =
+                    true_base_addr + (cy_chip_offset[chip_number] << index);
+                mdelay(1);
+                if (cy_readb(base_addr + (CyCCR << index)) != 0x00) {
+                        /*************
+                        printk(" chip #%d at %#6lx is never idle (CCR != 0)\n",
+                        chip_number, (unsigned long)base_addr);
+                        *************/
+                        return chip_number;
+                }
+
+                cy_writeb(base_addr + (CyGFRCR << index), 0);
+                udelay(10L);
+
+                /* The Cyclom-16Y does not decode address bit 9 and therefore
+                   cannot distinguish between references to chip 0 and a non-
+                   existent chip 4.  If the preceding clearing of the supposed
+                   chip 4 GFRCR register appears at chip 0, there is no chip 4
+                   and this must be a Cyclom-16Y, not a Cyclom-32Ye.
+                 */
+                if (chip_number == 4 && cy_readb(true_base_addr +
+                                (cy_chip_offset[0] << index) +
+                                (CyGFRCR << index)) == 0) {
+                        return chip_number;
+                }
+
+                cy_writeb(base_addr + (CyCCR << index), CyCHIP_RESET);
+                mdelay(1);
 
-    /*
-        printk(" chip #%d at %#6lx is rev 0x%2x\n",
-               chip_number, (unsigned long)base_addr,
-               cy_readb(base_addr+(CyGFRCR<<index)));
-    */
-    }
-    return chip_number;
-} /* cyy_init_card */
+                if (cy_readb(base_addr + (CyGFRCR << index)) == 0x00) {
+                        /*
+                           printk(" chip #%d at %#6lx is not responding ",
+                           chip_number, (unsigned long)base_addr);
+                           printk("(GFRCR stayed 0)\n",
+                         */
+                        return chip_number;
+                }
+                if ((0xf0 & (cy_readb(base_addr + (CyGFRCR << index)))) !=
+                                0x40) {
+                        /*
+                        printk(" chip #%d at %#6lx is not valid (GFRCR == "
+                                        "%#2x)\n",
+                                        chip_number, (unsigned long)base_addr,
+                                        base_addr[CyGFRCR<<index]);
+                         */
+                        return chip_number;
+                }
+                cy_writeb(base_addr + (CyGCR << index), CyCH0_SERIAL);
+                if (cy_readb(base_addr + (CyGFRCR << index)) >= CD1400_REV_J) {
+                        /* It is a CD1400 rev. J or later */
+                        /* Impossible to reach 5ms with this chip.
+                           Changed to 2ms instead (f = 500 Hz). */
+                        cy_writeb(base_addr + (CyPPR << index), CyCLOCK_60_2MS);
+                } else {
+                        /* f = 200 Hz */
+                        cy_writeb(base_addr + (CyPPR << index), CyCLOCK_25_5MS);
+                }
+
+                /*
+                   printk(" chip #%d at %#6lx is rev 0x%2x\n",
+                   chip_number, (unsigned long)base_addr,
+                   cy_readb(base_addr+(CyGFRCR<<index)));
+                 */
+        }
+        return chip_number;
+}                               /* cyy_init_card */
 
 /*
  * ---------------------------------------------------------------------
@@ -4537,126 +4613,124 @@ cyy_init_card(void __iomem *true_base_addr,int index)
  * sets global variables and return the number of ISA boards found.
  * ---------------------------------------------------------------------
  */
-static int __init
-cy_detect_isa(void)
+static int __init cy_detect_isa(void)
 {
 #ifdef CONFIG_ISA
-  unsigned short        cy_isa_irq,nboard;
-  void __iomem          *cy_isa_address;
-  unsigned short        i,j,cy_isa_nchan;
+        unsigned short cy_isa_irq, nboard;
+        void __iomem *cy_isa_address;
+        unsigned short i, j, cy_isa_nchan;
 #ifdef MODULE
-  int isparam = 0;
+        int isparam = 0;
 #endif
 
-        nboard = 0;
+        nboard = 0;
 
 #ifdef MODULE
         /* Check for module parameters */
-        for(i = 0 ; i < NR_CARDS; i++) {
-            if (maddr[i] || i) {
-                isparam = 1;
-                cy_isa_addresses[i] = maddr[i];
-            }
-            if (!maddr[i])
-                break;
+        for (i = 0; i < NR_CARDS; i++) {
+                if (maddr[i] || i) {
+                        isparam = 1;
+                        cy_isa_addresses[i] = maddr[i];
+                }
+                if (!maddr[i])
+                        break;
         }
 #endif
 
-        /* scan the address table probing for Cyclom-Y/ISA boards */
-        for (i = 0 ; i < NR_ISA_ADDRS ; i++) {
-                unsigned int isa_address = cy_isa_addresses[i];
-                if (isa_address  == 0x0000) {
-                        return(nboard);
-                }
+        /* scan the address table probing for Cyclom-Y/ISA boards */
+        for (i = 0; i < NR_ISA_ADDRS; i++) {
+                unsigned int isa_address = cy_isa_addresses[i];
+                if (isa_address == 0x0000) {
+                        return nboard;
+                }
 
-                /* probe for CD1400... */
+                /* probe for CD1400... */
                 cy_isa_address = ioremap(isa_address, CyISA_Ywin);
-                cy_isa_nchan = CyPORTS_PER_CHIP * 
-                     cyy_init_card(cy_isa_address,0);
-                if (cy_isa_nchan == 0) {
-                        continue;
-                }
-
+                cy_isa_nchan = CyPORTS_PER_CHIP *
+                        cyy_init_card(cy_isa_address, 0);
+                if (cy_isa_nchan == 0) {
+                        continue;
+                }
 #ifdef MODULE
                 if (isparam && irq[i])
-                    cy_isa_irq = irq[i];
+                        cy_isa_irq = irq[i];
                 else
 #endif
-                /* find out the board's irq by probing */
-                cy_isa_irq = detect_isa_irq(cy_isa_address);
-                if (cy_isa_irq == 0) {
-                        printk("Cyclom-Y/ISA found at 0x%lx ",
-                                (unsigned long) cy_isa_address);
-                        printk("but the IRQ could not be detected.\n");
-                        continue;
-                }
-
-                if((cy_next_channel+cy_isa_nchan) > NR_PORTS) {
-                        printk("Cyclom-Y/ISA found at 0x%lx ",
-                                (unsigned long) cy_isa_address);
-                        printk("but no more channels are available.\n");
-                        printk("Change NR_PORTS in cyclades.c and recompile kernel.\n");
-                        return(nboard);
-                }
-                /* fill the next cy_card structure available */
-                for (j = 0 ; j < NR_CARDS ; j++) {
-                        if (cy_card[j].base_addr == 0)  break;
-                }
-                if (j == NR_CARDS) {    /* no more cy_cards available */
-                        printk("Cyclom-Y/ISA found at 0x%lx ",
-                                (unsigned long) cy_isa_address);
-                        printk("but no more cards can be used .\n");
-                        printk("Change NR_CARDS in cyclades.c and recompile kernel.\n");
-                        return(nboard);
-                }
-
-                /* allocate IRQ */
-                if(request_irq(cy_isa_irq, cyy_interrupt,
-                                   IRQF_DISABLED, "Cyclom-Y", &cy_card[j]))
-                {
-                        printk("Cyclom-Y/ISA found at 0x%lx ",
-                                (unsigned long) cy_isa_address);
-                        printk("but could not allocate IRQ#%d.\n",
-                                cy_isa_irq);
-                        return(nboard);
-                }
-
-                /* set cy_card */
-                cy_card[j].base_addr = cy_isa_address;
-                cy_card[j].ctl_addr = NULL;
-                cy_card[j].irq = (int) cy_isa_irq;
-                cy_card[j].bus_index = 0;
-                cy_card[j].first_line = cy_next_channel;
-                cy_card[j].num_chips = cy_isa_nchan/4;
-                nboard++;
-                        
-                /* print message */
-                printk("Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d, ",
-                    j+1, (unsigned long) cy_isa_address,
-                    (unsigned long)(cy_isa_address + (CyISA_Ywin - 1)),
-                    cy_isa_irq);
-                printk("%d channels starting from port %d.\n",
-                        cy_isa_nchan, cy_next_channel);
-                cy_next_channel += cy_isa_nchan;
-        }
-        return(nboard);
+                        /* find out the board's irq by probing */
+                        cy_isa_irq = detect_isa_irq(cy_isa_address);
+                if (cy_isa_irq == 0) {
+                        printk("Cyclom-Y/ISA found at 0x%lx ",
+                                (unsigned long)cy_isa_address);
+                        printk("but the IRQ could not be detected.\n");
+                        continue;
+                }
+
+                if ((cy_next_channel + cy_isa_nchan) > NR_PORTS) {
+                        printk("Cyclom-Y/ISA found at 0x%lx ",
+                                (unsigned long)cy_isa_address);
+                        printk("but no more channels are available.\n");
+                        printk("Change NR_PORTS in cyclades.c and recompile "
+                                        "kernel.\n");
+                        return nboard;
+                }
+                /* fill the next cy_card structure available */
+                for (j = 0; j < NR_CARDS; j++) {
+                        if (cy_card[j].base_addr == 0)
+                                break;
+                }
+                if (j == NR_CARDS) {    /* no more cy_cards available */
+                        printk("Cyclom-Y/ISA found at 0x%lx ",
+                                (unsigned long)cy_isa_address);
+                        printk("but no more cards can be used .\n");
+                        printk("Change NR_CARDS in cyclades.c and recompile "
+                                        "kernel.\n");
+                        return nboard;
+                }
+
+                /* allocate IRQ */
+                if (request_irq(cy_isa_irq, cyy_interrupt,
+                                IRQF_DISABLED, "Cyclom-Y", &cy_card[j])) {
+                        printk("Cyclom-Y/ISA found at 0x%lx ",
+                                (unsigned long)cy_isa_address);
+                        printk("but could not allocate IRQ#%d.\n", cy_isa_irq);
+                        return nboard;
+                }
+
+                /* set cy_card */
+                cy_card[j].base_addr = cy_isa_address;
+                cy_card[j].ctl_addr = NULL;
+                cy_card[j].irq = (int)cy_isa_irq;
+                cy_card[j].bus_index = 0;
+                cy_card[j].first_line = cy_next_channel;
+                cy_card[j].num_chips = cy_isa_nchan / 4;
+                nboard++;
+
+                /* print message */
+                printk("Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d, ",
+                        j + 1, (unsigned long)cy_isa_address,
+                        (unsigned long)(cy_isa_address + (CyISA_Ywin - 1)),
+                        cy_isa_irq);
+                printk("%d channels starting from port %d.\n",
+                        cy_isa_nchan, cy_next_channel);
+                cy_next_channel += cy_isa_nchan;
+        }
+        return nboard;
 #else
-        return(0);
-#endif /* CONFIG_ISA */
-} /* cy_detect_isa */
+        return 0;
+#endif                          /* CONFIG_ISA */
+}                               /* cy_detect_isa */
 
-static void 
-plx_init(void __iomem *addr, uclong initctl)
+static void plx_init(void __iomem * addr, uclong initctl)
 {
-    /* Reset PLX */
-    cy_writel(addr + initctl, cy_readl(addr + initctl) | 0x40000000);
-    udelay(100L);
-    cy_writel(addr + initctl, cy_readl(addr + initctl) & ~0x40000000);
-
-    /* Reload Config. Registers from EEPROM */
-    cy_writel(addr + initctl, cy_readl(addr + initctl) | 0x20000000);
-    udelay(100L);
-    cy_writel(addr + initctl, cy_readl(addr + initctl) & ~0x20000000);
+        /* Reset PLX */
+        cy_writel(addr + initctl, cy_readl(addr + initctl) | 0x40000000);
+        udelay(100L);
+        cy_writel(addr + initctl, cy_readl(addr + initctl) & ~0x40000000);
+
+        /* Reload Config. Registers from EEPROM */
+        cy_writel(addr + initctl, cy_readl(addr + initctl) | 0x20000000);
+        udelay(100L);
+        cy_writel(addr + initctl, cy_readl(addr + initctl) & ~0x20000000);
 }
 
 /*
@@ -4665,43 +4739,42 @@ plx_init(void __iomem *addr, uclong initctl)
  * sets global variables and return the number of PCI boards found.
  * ---------------------------------------------------------------------
  */
-static int __init
-cy_detect_pci(void)
+static int __init cy_detect_pci(void)
 {
 #ifdef CONFIG_PCI
 
-  struct pci_dev        *pdev = NULL;
-  unsigned char         cyy_rev_id;
-  unsigned char         cy_pci_irq = 0;
-  uclong                cy_pci_phys0, cy_pci_phys2;
-  void __iomem          *cy_pci_addr0, *cy_pci_addr2;
-  unsigned short        i,j,cy_pci_nchan, plx_ver;
-  unsigned short        device_id,dev_index = 0;
-  uclong                mailbox;
-  uclong                ZeIndex = 0;
-  void __iomem          *Ze_addr0[NR_CARDS], *Ze_addr2[NR_CARDS];
-  uclong                Ze_phys0[NR_CARDS], Ze_phys2[NR_CARDS];
-  unsigned char         Ze_irq[NR_CARDS];
-  struct pci_dev        *Ze_pdev[NR_CARDS];
-
-        for (i = 0; i < NR_CARDS; i++) {
-                /* look for a Cyclades card by vendor and device id */
-                while((device_id = cy_pci_dev_id[dev_index]) != 0) {
-                        if((pdev = pci_get_device(PCI_VENDOR_ID_CYCLADES,
-                                        device_id, pdev)) == NULL) {
-                                dev_index++;    /* try next device id */
-                        } else {
-                                break;          /* found a board */
-                        }
-                }
+        struct pci_dev *pdev = NULL;
+        unsigned char cyy_rev_id;
+        unsigned char cy_pci_irq = 0;
+        uclong cy_pci_phys0, cy_pci_phys2;
+        void __iomem *cy_pci_addr0, *cy_pci_addr2;
+        unsigned short i, j, cy_pci_nchan, plx_ver;
+        unsigned short device_id, dev_index = 0;
+        uclong mailbox;
+        uclong ZeIndex = 0;
+        void __iomem *Ze_addr0[NR_CARDS], *Ze_addr2[NR_CARDS];
+        uclong Ze_phys0[NR_CARDS], Ze_phys2[NR_CARDS];
+        unsigned char Ze_irq[NR_CARDS];
+        struct pci_dev *Ze_pdev[NR_CARDS];
+
+        for (i = 0; i < NR_CARDS; i++) {
+                /* look for a Cyclades card by vendor and device id */
+                while ((device_id = cy_pci_dev_id[dev_index]) != 0) {
+                        if ((pdev = pci_get_device(PCI_VENDOR_ID_CYCLADES,
+                                                   device_id, pdev)) == NULL) {
+                                dev_index++;    /* try next device id */
+                        } else {
+                                break;  /* found a board */
+                        }
+                }
 
                 if (device_id == 0)
-                    break;
+                        break;
 
                 if (pci_enable_device(pdev))
-                    continue;
+                        continue;
 
-                /* read PCI configuration area */
+                /* read PCI configuration area */
                 cy_pci_irq = pdev->irq;
                 cy_pci_phys0 = pci_resource_start(pdev, 0);
                 cy_pci_phys2 = pci_resource_start(pdev, 2);
@@ -4709,482 +4782,497 @@ cy_detect_pci(void)
 
                 device_id &= ~PCI_DEVICE_ID_MASK;
 
-    if ((device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo)
-           || (device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi)){
+                if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
+                                device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
 #ifdef CY_PCI_DEBUG
-            printk("Cyclom-Y/PCI (bus=0x0%x, pci_id=0x%x, ",
-                pdev->bus->number, pdev->devfn);
-            printk("rev_id=%d) IRQ%d\n",
-                cyy_rev_id, (int)cy_pci_irq);
-            printk("Cyclom-Y/PCI:found  winaddr=0x%lx ctladdr=0x%lx\n",
-                (ulong)cy_pci_phys2, (ulong)cy_pci_phys0);
+                        printk("Cyclom-Y/PCI (bus=0x0%x, pci_id=0x%x, ",
+                                pdev->bus->number, pdev->devfn);
+                        printk("rev_id=%d) IRQ%d\n",
+                                cyy_rev_id, (int)cy_pci_irq);
+                        printk("Cyclom-Y/PCI:found  winaddr=0x%lx "
+                                "ctladdr=0x%lx\n",
+                                (ulong)cy_pci_phys2, (ulong)cy_pci_phys0);
 #endif
 
-                if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
-                    printk("  Warning: PCI I/O bit incorrectly set. "
-                           "Ignoring it...\n");
-                    pdev->resource[2].flags &= ~IORESOURCE_IO;
-                }
-
-                /* Although we don't use this I/O region, we should
-                   request it from the kernel anyway, to avoid problems
-                   with other drivers accessing it. */
-                if (pci_request_regions(pdev, "Cyclom-Y") != 0) {
-                        printk(KERN_ERR "cyclades: failed to reserve PCI resources\n");
-                        continue;
-                }
+                        if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
+                                printk("  Warning: PCI I/O bit incorrectly "
+                                        "set. Ignoring it...\n");
+                                pdev->resource[2].flags &= ~IORESOURCE_IO;
+                        }
 
+                        /* Although we don't use this I/O region, we should
+                           request it from the kernel anyway, to avoid problems
+                           with other drivers accessing it. */
+                        if (pci_request_regions(pdev, "Cyclom-Y") != 0) {
+                                printk(KERN_ERR "cyclades: failed to reserve "
+                                                "PCI resources\n");
+                                continue;
+                        }
 #if defined(__alpha__)
-                if (device_id  == PCI_DEVICE_ID_CYCLOM_Y_Lo) { /* below 1M? */
-                    printk("Cyclom-Y/PCI (bus=0x0%x, pci_id=0x%x, ",
-                        pdev->bus->number, pdev->devfn);
-                    printk("rev_id=%d) IRQ%d\n",
-                        cyy_rev_id, (int)cy_pci_irq);
-                    printk("Cyclom-Y/PCI:found  winaddr=0x%lx ctladdr=0x%lx\n",
-                        (ulong)cy_pci_phys2, (ulong)cy_pci_phys0);
-                    printk("Cyclom-Y/PCI not supported for low addresses in "
-                           "Alpha systems.\n");
-                    i--;
-                    continue;
-                }
+                        if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo) {   /* below 1M? */
+                                printk("Cyclom-Y/PCI (bus=0x0%x, pci_id=0x%x, ",
+                                        pdev->bus->number, pdev->devfn);
+                                printk("rev_id=%d) IRQ%d\n",
+                                        cyy_rev_id, (int)cy_pci_irq);
+                                printk("Cyclom-Y/PCI:found  winaddr=0x%lx "
+                                        "ctladdr=0x%lx\n",
+                                        (ulong)cy_pci_phys2,
+                                        (ulong)cy_pci_phys0);
+                                printk("Cyclom-Y/PCI not supported for low "
+                                        "addresses in Alpha systems.\n");
+                                i--;
+                                continue;
+                        }
 #endif
-                cy_pci_addr0 = ioremap(cy_pci_phys0, CyPCI_Yctl);
-                cy_pci_addr2 = ioremap(cy_pci_phys2, CyPCI_Ywin);
+                        cy_pci_addr0 = ioremap(cy_pci_phys0, CyPCI_Yctl);
+                        cy_pci_addr2 = ioremap(cy_pci_phys2, CyPCI_Ywin);
 
 #ifdef CY_PCI_DEBUG
-            printk("Cyclom-Y/PCI: relocate winaddr=0x%lx ctladdr=0x%lx\n",
-                (u_long)cy_pci_addr2, (u_long)cy_pci_addr0);
+                        printk("Cyclom-Y/PCI: relocate winaddr=0x%lx "
+                                "ctladdr=0x%lx\n",
+                                (u_long)cy_pci_addr2, (u_long)cy_pci_addr0);
 #endif
-                cy_pci_nchan = (unsigned short)(CyPORTS_PER_CHIP * 
-                       cyy_init_card(cy_pci_addr2, 1));
-                if(cy_pci_nchan == 0) {
-                        printk("Cyclom-Y PCI host card with ");
-                        printk("no Serial-Modules at 0x%lx.\n",
-                            (ulong) cy_pci_phys2);
-                        i--;
-                        continue;
-                }
-                if((cy_next_channel+cy_pci_nchan) > NR_PORTS) {
-                        printk("Cyclom-Y/PCI found at 0x%lx ",
-                            (ulong) cy_pci_phys2);
-                        printk("but no channels are available.\n");
-                        printk("Change NR_PORTS in cyclades.c and recompile kernel.\n");
-                        return(i);
-                }
-                /* fill the next cy_card structure available */
-                for (j = 0 ; j < NR_CARDS ; j++) {
-                        if (cy_card[j].base_addr == 0)  break;
-                }
-                if (j == NR_CARDS) {    /* no more cy_cards available */
-                        printk("Cyclom-Y/PCI found at 0x%lx ",
-                            (ulong) cy_pci_phys2);
-                        printk("but no more cards can be used.\n");
-                        printk("Change NR_CARDS in cyclades.c and recompile kernel.\n");
-                        return(i);
-                }
-
-                /* allocate IRQ */
-                if(request_irq(cy_pci_irq, cyy_interrupt,
-                        IRQF_SHARED, "Cyclom-Y", &cy_card[j]))
-                {
-                        printk("Cyclom-Y/PCI found at 0x%lx ",
-                            (ulong) cy_pci_phys2);
-                        printk("but could not allocate IRQ%d.\n",
-                            cy_pci_irq);
-                        return(i);
-                }
-
-                /* set cy_card */
-                cy_card[j].base_phys = (ulong)cy_pci_phys2;
-                cy_card[j].ctl_phys = (ulong)cy_pci_phys0;
-                cy_card[j].base_addr = cy_pci_addr2;
-                cy_card[j].ctl_addr = cy_pci_addr0;
-                cy_card[j].irq = (int) cy_pci_irq;
-                cy_card[j].bus_index = 1;
-                cy_card[j].first_line = cy_next_channel;
-                cy_card[j].num_chips = cy_pci_nchan/4;
-                cy_card[j].pdev = pdev;
-        
-                /* enable interrupts in the PCI interface */
-                plx_ver = cy_readb(cy_pci_addr2 + CyPLX_VER) & 0x0f;
-                switch (plx_ver) {
-                    case PLX_9050:
-
-                    cy_writeb(cy_pci_addr0+0x4c, 0x43);
-                    break;
-
-                    case PLX_9060:
-                    case PLX_9080:
-                    default: /* Old boards, use PLX_9060 */
-
-                    plx_init(cy_pci_addr0, 0x6c);
-                    /* For some yet unknown reason, once the PLX9060 reloads
-                       the EEPROM, the IRQ is lost and, thus, we have to
-                       re-write it to the PCI config. registers.
-                       This will remain here until we find a permanent fix. */
-                    pci_write_config_byte(pdev, PCI_INTERRUPT_LINE, cy_pci_irq);
-
-                    cy_writew(cy_pci_addr0+0x68, 
-                        cy_readw(cy_pci_addr0+0x68)|0x0900);
-                    break;
-                }
+                        cy_pci_nchan = (unsigned short)(CyPORTS_PER_CHIP *
+                                        cyy_init_card(cy_pci_addr2, 1));
+                        if (cy_pci_nchan == 0) {
+                                printk("Cyclom-Y PCI host card with ");
+                                printk("no Serial-Modules at 0x%lx.\n",
+                                        (ulong) cy_pci_phys2);
+                                i--;
+                                continue;
+                        }
+                        if ((cy_next_channel + cy_pci_nchan) > NR_PORTS) {
+                                printk("Cyclom-Y/PCI found at 0x%lx ",
+                                        (ulong) cy_pci_phys2);
+                                printk("but no channels are available.\n");
+                                printk("Change NR_PORTS in cyclades.c and "
+                                                "recompile kernel.\n");
+                                return i;
+                        }
+                        /* fill the next cy_card structure available */
+                        for (j = 0; j < NR_CARDS; j++) {
+                                if (cy_card[j].base_addr == 0)
+                                        break;
+                        }
+                        if (j == NR_CARDS) {    /* no more cy_cards available */
+                                printk("Cyclom-Y/PCI found at 0x%lx ",
+                                        (ulong) cy_pci_phys2);
+                                printk("but no more cards can be used.\n");
+                                printk("Change NR_CARDS in cyclades.c and "
+                                                "recompile kernel.\n");
+                                return i;
+                        }
+
+                        /* allocate IRQ */
+                        if (request_irq(cy_pci_irq, cyy_interrupt,
+                                        IRQF_SHARED, "Cyclom-Y", &cy_card[j])) {
+                                printk("Cyclom-Y/PCI found at 0x%lx ",
+                                        (ulong) cy_pci_phys2);
+                                printk("but could not allocate IRQ%d.\n",
+                                        cy_pci_irq);
+                                return i;
+                        }
+
+                        /* set cy_card */
+                        cy_card[j].base_phys = (ulong) cy_pci_phys2;
+                        cy_card[j].ctl_phys = (ulong) cy_pci_phys0;
+                        cy_card[j].base_addr = cy_pci_addr2;
+                        cy_card[j].ctl_addr = cy_pci_addr0;
+                        cy_card[j].irq = (int)cy_pci_irq;
+                        cy_card[j].bus_index = 1;
+                        cy_card[j].first_line = cy_next_channel;
+                        cy_card[j].num_chips = cy_pci_nchan / 4;
+                        cy_card[j].pdev = pdev;
+
+                        /* enable interrupts in the PCI interface */
+                        plx_ver = cy_readb(cy_pci_addr2 + CyPLX_VER) & 0x0f;
+                        switch (plx_ver) {
+                        case PLX_9050:
+
+                                cy_writeb(cy_pci_addr0 + 0x4c, 0x43);
+                                break;
+
+                        case PLX_9060:
+                        case PLX_9080:
+                        default:        /* Old boards, use PLX_9060 */
+
+                                plx_init(cy_pci_addr0, 0x6c);
+                        /* For some yet unknown reason, once the PLX9060 reloads
+                           the EEPROM, the IRQ is lost and, thus, we have to
+                           re-write it to the PCI config. registers.
+                           This will remain here until we find a permanent
+                           fix. */
+                                pci_write_config_byte(pdev, PCI_INTERRUPT_LINE,
+                                                cy_pci_irq);
+
+                                cy_writew(cy_pci_addr0 + 0x68,
+                                          cy_readw(cy_pci_addr0 +
+                                                   0x68) | 0x0900);
+                                break;
+                        }
 
-                /* print message */
-                printk("Cyclom-Y/PCI #%d: 0x%lx-0x%lx, IRQ%d, ",
-                       j+1, 
-                       (ulong)cy_pci_phys2, 
-                       (ulong)(cy_pci_phys2 + CyPCI_Ywin - 1),
-                       (int)cy_pci_irq);
-                printk("%d channels starting from port %d.\n",
-                    cy_pci_nchan, cy_next_channel);
-
-                cy_next_channel += cy_pci_nchan;
-    }else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Lo){
-            /* print message */
-                printk("Cyclades-Z/PCI (bus=0x0%x, pci_id=0x%x, ",
-                    pdev->bus->number, pdev->devfn);
-                printk("rev_id=%d) IRQ%d\n",
-                    cyy_rev_id, (int)cy_pci_irq);
-                printk("Cyclades-Z/PCI: found winaddr=0x%lx ctladdr=0x%lx\n",
-                    (ulong)cy_pci_phys2, (ulong)cy_pci_phys0);
-            printk("Cyclades-Z/PCI not supported for low addresses\n");
-            break;
-    }else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Hi){
+                        /* print message */
+                        printk("Cyclom-Y/PCI #%d: 0x%lx-0x%lx, IRQ%d, ",
+                                j + 1, (ulong)cy_pci_phys2,
+                                (ulong) (cy_pci_phys2 + CyPCI_Ywin - 1),
+                                (int)cy_pci_irq);
+                        printk("%d channels starting from port %d.\n",
+                                cy_pci_nchan, cy_next_channel);
+
+                        cy_next_channel += cy_pci_nchan;
+                } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Lo) {
+                        /* print message */
+                        printk("Cyclades-Z/PCI (bus=0x0%x, pci_id=0x%x, ",
+                                pdev->bus->number, pdev->devfn);
+                        printk("rev_id=%d) IRQ%d\n",
+                                cyy_rev_id, (int)cy_pci_irq);
+                        printk("Cyclades-Z/PCI: found winaddr=0x%lx "
+                                "ctladdr=0x%lx\n",
+                                (ulong)cy_pci_phys2, (ulong)cy_pci_phys0);
+                        printk("Cyclades-Z/PCI not supported for low "
+                                "addresses\n");
+                        break;
+                } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Hi) {
 #ifdef CY_PCI_DEBUG
-            printk("Cyclades-Z/PCI (bus=0x0%x, pci_id=0x%x, ",
-                pdev->bus->number, pdev->devfn);
-            printk("rev_id=%d) IRQ%d\n",
-                cyy_rev_id, (int)cy_pci_irq);
-            printk("Cyclades-Z/PCI: found winaddr=0x%lx ctladdr=0x%lx\n",
-                (ulong)cy_pci_phys2, (ulong)cy_pci_phys0);
+                        printk("Cyclades-Z/PCI (bus=0x0%x, pci_id=0x%x, ",
+                                pdev->bus->number, pdev->devfn);
+                        printk("rev_id=%d) IRQ%d\n",
+                                cyy_rev_id, (int)cy_pci_irq);
+                        printk("Cyclades-Z/PCI: found winaddr=0x%lx "
+                                "ctladdr=0x%lx\n",
+                                (ulong) cy_pci_phys2, (ulong) cy_pci_phys0);
 #endif
-                cy_pci_addr0 = ioremap(cy_pci_phys0, CyPCI_Zctl);
-
-                /* Disable interrupts on the PLX before resetting it */
-                cy_writew(cy_pci_addr0+0x68,
-                        cy_readw(cy_pci_addr0+0x68) & ~0x0900);
-
-                plx_init(cy_pci_addr0, 0x6c);
-                /* For some yet unknown reason, once the PLX9060 reloads
-                   the EEPROM, the IRQ is lost and, thus, we have to
-                   re-write it to the PCI config. registers.
-                   This will remain here until we find a permanent fix. */
-                pci_write_config_byte(pdev, PCI_INTERRUPT_LINE, cy_pci_irq);
-
-                mailbox = (uclong)cy_readl(&((struct RUNTIME_9060 __iomem *) 
-                           cy_pci_addr0)->mail_box_0);
-
-                if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
-                    printk("  Warning: PCI I/O bit incorrectly set. "
-                           "Ignoring it...\n");
-                    pdev->resource[2].flags &= ~IORESOURCE_IO;
-                }
+                        cy_pci_addr0 = ioremap(cy_pci_phys0, CyPCI_Zctl);
+
+                        /* Disable interrupts on the PLX before resetting it */
+                        cy_writew(cy_pci_addr0 + 0x68,
+                                cy_readw(cy_pci_addr0 + 0x68) & ~0x0900);
+
+                        plx_init(cy_pci_addr0, 0x6c);
+                        /* For some yet unknown reason, once the PLX9060 reloads
+                           the EEPROM, the IRQ is lost and, thus, we have to
+                           re-write it to the PCI config. registers.
+                           This will remain here until we find a permanent
+                           fix. */
+                        pci_write_config_byte(pdev, PCI_INTERRUPT_LINE,
+                                                cy_pci_irq);
+
+                        mailbox =
+                            (uclong)cy_readl(&((struct RUNTIME_9060 __iomem *)
+                                                cy_pci_addr0)->mail_box_0);
+
+                        if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
+                                printk("  Warning: PCI I/O bit incorrectly "
+                                        "set. Ignoring it...\n");
+                                pdev->resource[2].flags &= ~IORESOURCE_IO;
+                        }
 
-                /* Although we don't use this I/O region, we should
-                   request it from the kernel anyway, to avoid problems
-                   with other drivers accessing it. */
-                if (pci_request_regions(pdev, "Cyclades-Z") != 0) {
-                        printk(KERN_ERR "cyclades: failed to reserve PCI resources\n");
-                        continue;
-                }
-        
-                if (mailbox == ZE_V1) {
-                    cy_pci_addr2 = ioremap(cy_pci_phys2, CyPCI_Ze_win);
-                    if (ZeIndex == NR_CARDS) {
-                        printk("Cyclades-Ze/PCI found at 0x%lx ",
-                                (ulong)cy_pci_phys2);
-                        printk("but no more cards can be used.\n");
-                        printk("Change NR_CARDS in cyclades.c and recompile kernel.\n");
-                    } else {
-                        Ze_phys0[ZeIndex] = cy_pci_phys0;
-                        Ze_phys2[ZeIndex] = cy_pci_phys2;
-                        Ze_addr0[ZeIndex] = cy_pci_addr0;
-                        Ze_addr2[ZeIndex] = cy_pci_addr2;
-                        Ze_irq[ZeIndex] = cy_pci_irq;
-                        Ze_pdev[ZeIndex] = pdev;
-                        ZeIndex++;
-                    }
-                    i--;
-                    continue;
-                } else {
-                    cy_pci_addr2 = ioremap(cy_pci_phys2, CyPCI_Zwin);
-                }
+                        /* Although we don't use this I/O region, we should
+                           request it from the kernel anyway, to avoid problems
+                           with other drivers accessing it. */
+                        if (pci_request_regions(pdev, "Cyclades-Z") != 0) {
+                                printk(KERN_ERR "cyclades: failed to reserve "
+                                        "PCI resources\n");
+                                continue;
+                        }
+
+                        if (mailbox == ZE_V1) {
+                                cy_pci_addr2 = ioremap(cy_pci_phys2,
+                                                CyPCI_Ze_win);
+                                if (ZeIndex == NR_CARDS) {
+                                        printk("Cyclades-Ze/PCI found at "
+                                                "0x%lx but no more cards can "
+                                                "be used.\nChange NR_CARDS in "
+                                                "cyclades.c and recompile "
+                                                "kernel.\n",
+                                                (ulong)cy_pci_phys2);
+                                } else {
+                                        Ze_phys0[ZeIndex] = cy_pci_phys0;
+                                        Ze_phys2[ZeIndex] = cy_pci_phys2;
+                                        Ze_addr0[ZeIndex] = cy_pci_addr0;
+                                        Ze_addr2[ZeIndex] = cy_pci_addr2;
+                                        Ze_irq[ZeIndex] = cy_pci_irq;
+                                        Ze_pdev[ZeIndex] = pdev;
+                                        ZeIndex++;
+                                }
+                                i--;
+                                continue;
+                        } else {
+                                cy_pci_addr2 = ioremap(cy_pci_phys2,CyPCI_Zwin);
+                        }
 
 #ifdef CY_PCI_DEBUG
-            printk("Cyclades-Z/PCI: relocate winaddr=0x%lx ctladdr=0x%lx\n",
-                (ulong)cy_pci_addr2, (ulong)cy_pci_addr0);
-            if (mailbox == ZO_V1) {
-                cy_writel(&((struct RUNTIME_9060 *)
-                          (cy_pci_addr0))->loc_addr_base, WIN_CREG);
-                PAUSE
-                printk("Cyclades-8Zo/PCI: FPGA id %lx, ver %lx\n",
-                       (ulong)(0xff & cy_readl(&((struct CUSTOM_REG *)
-                        (cy_pci_addr2))->fpga_id)),
-                       (ulong)(0xff & cy_readl(&((struct CUSTOM_REG *)
-                        (cy_pci_addr2))->fpga_version)));
-                cy_writel(&((struct RUNTIME_9060 *)
-                          (cy_pci_addr0))->loc_addr_base, WIN_RAM);
-            } else {
-                printk("Cyclades-Z/PCI: New Cyclades-Z board.  FPGA not loaded\n");
-            }
+                        printk("Cyclades-Z/PCI: relocate winaddr=0x%lx "
+                                "ctladdr=0x%lx\n",
+                                (ulong) cy_pci_addr2, (ulong) cy_pci_addr0);
+                        if (mailbox == ZO_V1) {
+                                cy_writel(&((struct RUNTIME_9060 *)
+                                        (cy_pci_addr0))->loc_addr_base,
+                                        WIN_CREG);
+                                PAUSE;
+                                printk("Cyclades-8Zo/PCI: FPGA id %lx, ver "
+                                        "%lx\n", (ulong) (0xff &
+                                        cy_readl(&((struct CUSTOM_REG *)
+                                                (cy_pci_addr2))->fpga_id)),
+                                        (ulong)(0xff &
+                                        cy_readl(&((struct CUSTOM_REG *)
+                                                (cy_pci_addr2))->
+                                                        fpga_version)));
+                                cy_writel(&((struct RUNTIME_9060 *)
+                                        (cy_pci_addr0))->loc_addr_base,
+                                        WIN_RAM);
+                        } else {
+                                printk("Cyclades-Z/PCI: New Cyclades-Z board.  "
+                                                "FPGA not loaded\n");
+                        }
 #endif
-            /* The following clears the firmware id word.  This ensures
-               that the driver will not attempt to talk to the board
-               until it has been properly initialized.
-             */
-                PAUSE
-                if ((mailbox == ZO_V1) || (mailbox == ZO_V2))
-                    cy_writel(cy_pci_addr2 + ID_ADDRESS, 0L);
-
-                /* This must be a Cyclades-8Zo/PCI.  The extendable
-                   version will have a different device_id and will
-                   be allocated its maximum number of ports. */
-                cy_pci_nchan = 8;
-
-                if((cy_next_channel+cy_pci_nchan) > NR_PORTS) {
-                        printk("Cyclades-8Zo/PCI found at 0x%lx ",
-                            (ulong)cy_pci_phys2);
-                        printk("but no channels are available.\n");
-                        printk("Change NR_PORTS in cyclades.c and recompile kernel.\n");
-                        return(i);
-                }
-
-                /* fill the next cy_card structure available */
-                for (j = 0 ; j < NR_CARDS ; j++) {
-                        if (cy_card[j].base_addr == 0)  break;
-                }
-                if (j == NR_CARDS) {    /* no more cy_cards available */
-                    printk("Cyclades-8Zo/PCI found at 0x%lx ",
-                        (ulong)cy_pci_phys2);
-                    printk("but no more cards can be used.\n");
-                    printk("Change NR_CARDS in cyclades.c and recompile kernel.\n");
-                    return(i);
-                }
+                        /* The following clears the firmware id word.  This
+                           ensures that the driver will not attempt to talk to
+                           the board until it has been properly initialized.
+                         */
+                        PAUSE;
+                        if ((mailbox == ZO_V1) || (mailbox == ZO_V2))
+                                cy_writel(cy_pci_addr2 + ID_ADDRESS, 0L);
+
+                        /* This must be a Cyclades-8Zo/PCI.  The extendable
+                           version will have a different device_id and will
+                           be allocated its maximum number of ports. */
+                        cy_pci_nchan = 8;
+
+                        if ((cy_next_channel + cy_pci_nchan) > NR_PORTS) {
+                                printk("Cyclades-8Zo/PCI found at 0x%lx but"
+                                        "no channels are available.\nChange "
+                                        "NR_PORTS in cyclades.c and recompile "
+                                        "kernel.\n", (ulong)cy_pci_phys2);
+                                return i;
+                        }
 
+                        /* fill the next cy_card structure available */
+                        for (j = 0; j < NR_CARDS; j++) {
+                                if (cy_card[j].base_addr == 0)
+                                        break;
+                        }
+                        if (j == NR_CARDS) {    /* no more cy_cards available */
+                                printk("Cyclades-8Zo/PCI found at 0x%lx but"
+                                        "no more cards can be used.\nChange "
+                                        "NR_CARDS in cyclades.c and recompile "
+                                        "kernel.\n", (ulong)cy_pci_phys2);
+                                return i;
+                        }
+#ifdef CONFIG_CYZ_INTR
+                        /* allocate IRQ only if board has an IRQ */
+                        if ((cy_pci_irq != 0) && (cy_pci_irq != 255)) {
+                                if (request_irq(cy_pci_irq, cyz_interrupt,
+                                                IRQF_SHARED, "Cyclades-Z",
+                                                &cy_card[j])) {
+                                        printk("Cyclom-8Zo/PCI found at 0x%lx "
+                                                "but could not allocate "
+                                                "IRQ%d.\n", (ulong)cy_pci_phys2,
+                                                cy_pci_irq);
+                                        return i;
+                                }
+                        }
+#endif                          /* CONFIG_CYZ_INTR */
+
+                        /* set cy_card */
+                        cy_card[j].base_phys = cy_pci_phys2;
+                        cy_card[j].ctl_phys = cy_pci_phys0;
+                        cy_card[j].base_addr = cy_pci_addr2;
+                        cy_card[j].ctl_addr = cy_pci_addr0;
+                        cy_card[j].irq = (int)cy_pci_irq;
+                        cy_card[j].bus_index = 1;
+                        cy_card[j].first_line = cy_next_channel;
+                        cy_card[j].num_chips = -1;
+                        cy_card[j].pdev = pdev;
+
+                        /* print message */
 #ifdef CONFIG_CYZ_INTR
-                /* allocate IRQ only if board has an IRQ */
-                if( (cy_pci_irq != 0) && (cy_pci_irq != 255) ) {
-                    if(request_irq(cy_pci_irq, cyz_interrupt,
-                        IRQF_SHARED, "Cyclades-Z", &cy_card[j]))
-                    {
-                        printk("Cyclom-8Zo/PCI found at 0x%lx ",
-                            (ulong) cy_pci_phys2);
-                        printk("but could not allocate IRQ%d.\n",
-                            cy_pci_irq);
-                        return(i);
-                    }
+                        /* don't report IRQ if board is no IRQ */
+                        if ((cy_pci_irq != 0) && (cy_pci_irq != 255))
+                                printk("Cyclades-8Zo/PCI #%d: 0x%lx-0x%lx, "
+                                        "IRQ%d, ", j + 1, (ulong)cy_pci_phys2,
+                                        (ulong) (cy_pci_phys2 + CyPCI_Zwin - 1),
+                                        (int)cy_pci_irq);
+                        else
+#endif                          /* CONFIG_CYZ_INTR */
+                                printk("Cyclades-8Zo/PCI #%d: 0x%lx-0x%lx, ",
+                                        j + 1, (ulong)cy_pci_phys2,
+                                        (ulong)(cy_pci_phys2 + CyPCI_Zwin - 1));
+
+                        printk("%d channels starting from port %d.\n",
+                                        cy_pci_nchan, cy_next_channel);
+                        cy_next_channel += cy_pci_nchan;
                 }
-#endif /* CONFIG_CYZ_INTR */
-
-
-                /* set cy_card */
-                cy_card[j].base_phys = cy_pci_phys2;
-                cy_card[j].ctl_phys = cy_pci_phys0;
-                cy_card[j].base_addr = cy_pci_addr2;
-                cy_card[j].ctl_addr = cy_pci_addr0;
-                cy_card[j].irq = (int) cy_pci_irq;
-                cy_card[j].bus_index = 1;
-                cy_card[j].first_line = cy_next_channel;
-                cy_card[j].num_chips = -1;
-                cy_card[j].pdev = pdev;
+        }
 
-                /* print message */
-#ifdef CONFIG_CYZ_INTR
-                /* don't report IRQ if board is no IRQ */
-                if( (cy_pci_irq != 0) && (cy_pci_irq != 255) )
-                    printk("Cyclades-8Zo/PCI #%d: 0x%lx-0x%lx, IRQ%d, ",
-                        j+1,(ulong)cy_pci_phys2,
-                        (ulong)(cy_pci_phys2 + CyPCI_Zwin - 1),
-                        (int)cy_pci_irq);
-                else
-#endif /* CONFIG_CYZ_INTR */
-                    printk("Cyclades-8Zo/PCI #%d: 0x%lx-0x%lx, ",
-                        j+1,(ulong)cy_pci_phys2,
-                        (ulong)(cy_pci_phys2 + CyPCI_Zwin - 1));
-
-                printk("%d channels starting from port %d.\n",
-                    cy_pci_nchan,cy_next_channel);
-                cy_next_channel += cy_pci_nchan;
-            }
-        }
-
-        for (; ZeIndex != 0 && i < NR_CARDS; i++) {
-            cy_pci_phys0 = Ze_phys0[0];
-            cy_pci_phys2 = Ze_phys2[0];
-            cy_pci_addr0 = Ze_addr0[0];
-            cy_pci_addr2 = Ze_addr2[0];
-            cy_pci_irq = Ze_irq[0];
-            pdev = Ze_pdev[0];
-            for (j = 0 ; j < ZeIndex-1 ; j++) {
-                Ze_phys0[j] = Ze_phys0[j+1];
-                Ze_phys2[j] = Ze_phys2[j+1];
-                Ze_addr0[j] = Ze_addr0[j+1];
-                Ze_addr2[j] = Ze_addr2[j+1];
-                Ze_irq[j] = Ze_irq[j+1];
-                Ze_pdev[j] = Ze_pdev[j+1];
-            }
-            ZeIndex--;
-                mailbox = (uclong)cy_readl(&((struct RUNTIME_9060 __iomem *) 
-                                           cy_pci_addr0)->mail_box_0);
+        for (; ZeIndex != 0 && i < NR_CARDS; i++) {
+                cy_pci_phys0 = Ze_phys0[0];
+                cy_pci_phys2 = Ze_phys2[0];
+                cy_pci_addr0 = Ze_addr0[0];
+                cy_pci_addr2 = Ze_addr2[0];
+                cy_pci_irq = Ze_irq[0];
+                pdev = Ze_pdev[0];
+                for (j = 0; j < ZeIndex - 1; j++) {
+                        Ze_phys0[j] = Ze_phys0[j + 1];
+                        Ze_phys2[j] = Ze_phys2[j + 1];
+                        Ze_addr0[j] = Ze_addr0[j + 1];
+                        Ze_addr2[j] = Ze_addr2[j + 1];
+                        Ze_irq[j] = Ze_irq[j + 1];
+                        Ze_pdev[j] = Ze_pdev[j + 1];
+                }
+                ZeIndex--;
+                mailbox = (uclong)cy_readl(&((struct RUNTIME_9060 __iomem *)
+                                                cy_pci_addr0)->mail_box_0);
 #ifdef CY_PCI_DEBUG
-            printk("Cyclades-Z/PCI: relocate winaddr=0x%lx ctladdr=0x%lx\n",
-                (ulong)cy_pci_addr2, (ulong)cy_pci_addr0);
-            printk("Cyclades-Z/PCI: New Cyclades-Z board.  FPGA not loaded\n");
+                printk("Cyclades-Z/PCI: relocate winaddr=0x%lx ctladdr=0x%lx\n",
+                        (ulong)cy_pci_addr2, (ulong)cy_pci_addr0);
+                printk("Cyclades-Z/PCI: New Cyclades-Z board.  FPGA not "
+                                "loaded\n");
 #endif
-                PAUSE
-                /* This must be the new Cyclades-Ze/PCI. */
-                cy_pci_nchan = ZE_V1_NPORTS;
-
-                if((cy_next_channel+cy_pci_nchan) > NR_PORTS) {
-                        printk("Cyclades-Ze/PCI found at 0x%lx ",
-                            (ulong)cy_pci_phys2);
-                        printk("but no channels are available.\n");
-                        printk("Change NR_PORTS in cyclades.c and recompile kernel.\n");
-                        return(i);
-                }
-
-                /* fill the next cy_card structure available */
-                for (j = 0 ; j < NR_CARDS ; j++) {
-                        if (cy_card[j].base_addr == 0)  break;
-                }
-                if (j == NR_CARDS) {    /* no more cy_cards available */
-                    printk("Cyclades-Ze/PCI found at 0x%lx ",
-                        (ulong)cy_pci_phys2);
-                    printk("but no more cards can be used.\n");
-                    printk("Change NR_CARDS in cyclades.c and recompile kernel.\n");
-                    return(i);
-                }
+                PAUSE;
+                /* This must be the new Cyclades-Ze/PCI. */
+                cy_pci_nchan = ZE_V1_NPORTS;
+
+                if ((cy_next_channel + cy_pci_nchan) > NR_PORTS) {
+                        printk("Cyclades-Ze/PCI found at 0x%lx but no channels "
+                                "are available.\nChange NR_PORTS in cyclades.c "
+                                "and recompile kernel.\n",
+                                (ulong) cy_pci_phys2);
+                        return i;
+                }
 
+                /* fill the next cy_card structure available */
+                for (j = 0; j < NR_CARDS; j++) {
+                        if (cy_card[j].base_addr == 0)
+                                break;
+                }
+                if (j == NR_CARDS) {    /* no more cy_cards available */
+                        printk("Cyclades-Ze/PCI found at 0x%lx but no more "
+                                "cards can be used.\nChange NR_CARDS in "
+                                "cyclades.c and recompile kernel.\n",
+                                (ulong) cy_pci_phys2);
+                        return i;
+                }
 #ifdef CONFIG_CYZ_INTR
-                /* allocate IRQ only if board has an IRQ */
-                if( (cy_pci_irq != 0) && (cy_pci_irq != 255) ) {
-                    if(request_irq(cy_pci_irq, cyz_interrupt,
-                        IRQF_SHARED, "Cyclades-Z", &cy_card[j]))
-                    {
-                        printk("Cyclom-Ze/PCI found at 0x%lx ",
-                            (ulong) cy_pci_phys2);
-                        printk("but could not allocate IRQ%d.\n",
-                            cy_pci_irq);
-                        return(i);
-                    }
+                /* allocate IRQ only if board has an IRQ */
+                if ((cy_pci_irq != 0) && (cy_pci_irq != 255)) {
+                        if (request_irq(cy_pci_irq, cyz_interrupt,
+                                        IRQF_SHARED, "Cyclades-Z",
+                                        &cy_card[j])) {
+                                printk("Cyclom-Ze/PCI found at 0x%lx ",
+                                        (ulong) cy_pci_phys2);
+                                printk("but could not allocate IRQ%d.\n",
+                                        cy_pci_irq);
+                                return i;
+                        }
                 }
-#endif /* CONFIG_CYZ_INTR */
-
-                /* set cy_card */
-                cy_card[j].base_phys = cy_pci_phys2;
-                cy_card[j].ctl_phys = cy_pci_phys0;
-                cy_card[j].base_addr = cy_pci_addr2;
-                cy_card[j].ctl_addr = cy_pci_addr0;
-                cy_card[j].irq = (int) cy_pci_irq;
-                cy_card[j].bus_index = 1;
-                cy_card[j].first_line = cy_next_channel;
-                cy_card[j].num_chips = -1;
+#endif                          /* CONFIG_CYZ_INTR */
+
+                /* set cy_card */
+                cy_card[j].base_phys = cy_pci_phys2;
+                cy_card[j].ctl_phys = cy_pci_phys0;
+                cy_card[j].base_addr = cy_pci_addr2;
+                cy_card[j].ctl_addr = cy_pci_addr0;
+                cy_card[j].irq = (int)cy_pci_irq;
+                cy_card[j].bus_index = 1;
+                cy_card[j].first_line = cy_next_channel;
+                cy_card[j].num_chips = -1;
                 cy_card[j].pdev = pdev;
 
-                /* print message */
+                /* print message */
 #ifdef CONFIG_CYZ_INTR
                 /* don't report IRQ if board is no IRQ */
-                if( (cy_pci_irq != 0) && (cy_pci_irq != 255) )
-                    printk("Cyclades-Ze/PCI #%d: 0x%lx-0x%lx, IRQ%d, ",
-                        j+1,(ulong)cy_pci_phys2,
-                        (ulong)(cy_pci_phys2 + CyPCI_Ze_win - 1),
-                        (int)cy_pci_irq);
+                if ((cy_pci_irq != 0) && (cy_pci_irq != 255))
+                        printk("Cyclades-Ze/PCI #%d: 0x%lx-0x%lx, IRQ%d, ",
+                                j + 1, (ulong) cy_pci_phys2,
+                                (ulong) (cy_pci_phys2 + CyPCI_Ze_win - 1),
+                                (int)cy_pci_irq);
                 else
-#endif /* CONFIG_CYZ_INTR */
-                    printk("Cyclades-Ze/PCI #%d: 0x%lx-0x%lx, ",
-                        j+1,(ulong)cy_pci_phys2,
-                        (ulong)(cy_pci_phys2 + CyPCI_Ze_win - 1));
-
-                printk("%d channels starting from port %d.\n",
-                    cy_pci_nchan,cy_next_channel);
-                cy_next_channel += cy_pci_nchan;
-        }
+#endif                          /* CONFIG_CYZ_INTR */
+                        printk("Cyclades-Ze/PCI #%d: 0x%lx-0x%lx, ",
+                                j + 1, (ulong) cy_pci_phys2,
+                                (ulong) (cy_pci_phys2 + CyPCI_Ze_win - 1));
+
+                printk("%d channels starting from port %d.\n",
+                        cy_pci_nchan, cy_next_channel);
+                cy_next_channel += cy_pci_nchan;
+        }
         if (ZeIndex != 0) {
-            printk("Cyclades-Ze/PCI found at 0x%x ",
-                (unsigned int) Ze_phys2[0]);
-            printk("but no more cards can be used.\n");
-            printk("Change NR_CARDS in cyclades.c and recompile kernel.\n");
+                printk("Cyclades-Ze/PCI found at 0x%x but no more cards can be "
+                        "used.\nChange NR_CARDS in cyclades.c and recompile "
+                        "kernel.\n", (unsigned int)Ze_phys2[0]);
         }
-        return(i);
+        return i;
 #else
-        return(0);
-#endif /* ifdef CONFIG_PCI */
-} /* cy_detect_pci */
-
+        return 0;
+#endif                          /* ifdef CONFIG_PCI */
+}                               /* cy_detect_pci */
 
 /*
  * This routine prints out the appropriate serial driver version number
  * and identifies which options were configured into this driver.
  */
-static inline void
-show_version(void)
+static inline void show_version(void)
 {
-  char *rcsvers, *rcsdate, *tmp;
-    rcsvers = strchr(rcsid, ' '); rcsvers++;
-    tmp = strchr(rcsvers, ' '); *tmp++ = '\0';
-    rcsdate = strchr(tmp, ' '); rcsdate++;
-    tmp = strrchr(rcsdate, ' '); *tmp = '\0';
-    printk("Cyclades driver %s %s\n",
-        rcsvers, rcsdate);
-    printk("        built %s %s\n",
-        __DATE__, __TIME__);
-} /* show_version */
-
-static int 
+        printk("Cyclades driver " CY_VERSION "\n");
+        printk("        built %s %s\n", __DATE__, __TIME__);
+}                               /* show_version */
+
+static int
 cyclades_get_proc_info(char *buf, char **start, off_t offset, int length,
-                       int *eof, void *data)
+                int *eof, void *data)
 {
-    struct cyclades_port  *info;
-    int i;
-    int len=0;
-    off_t begin=0;
-    off_t pos=0;
-    int size;
-    __u32 cur_jifs = jiffies;
-
-    size = sprintf(buf, "Dev TimeOpen   BytesOut  IdleOut    BytesIn   IdleIn  Overruns  Ldisc\n");
-
-    pos += size;
-    len += size;
-
-    /* Output one line for each known port */
-    for (i = 0; i < NR_PORTS && cy_port[i].line >= 0; i++) {
-        info = &cy_port[i];
-
-        if (info->count)
-            size = sprintf(buf+len,
-                        "%3d %8lu %10lu %8lu %10lu %8lu %9lu %6ld\n",
-                        info->line,
-                        JIFFIES_DIFF(info->idle_stats.in_use, cur_jifs) / HZ,
-                        info->idle_stats.xmit_bytes,
-                        JIFFIES_DIFF(info->idle_stats.xmit_idle, cur_jifs) / HZ,
-                        info->idle_stats.recv_bytes,
-                        JIFFIES_DIFF(info->idle_stats.recv_idle, cur_jifs) / HZ,
-                        info->idle_stats.overruns,
-                        (long) info->tty->ldisc.num);
-        else
-            size = sprintf(buf+len,
-                        "%3d %8lu %10lu %8lu %10lu %8lu %9lu %6ld\n",
-                        info->line, 0L, 0L, 0L, 0L, 0L, 0L, 0L);
+        struct cyclades_port *info;
+        int i;
+        int len = 0;
+        off_t begin = 0;
+        off_t pos = 0;
+        int size;
+        __u32 cur_jifs = jiffies;
+
+        size = sprintf(buf, "Dev TimeOpen   BytesOut  IdleOut    BytesIn   "
+                        "IdleIn  Overruns  Ldisc\n");
+
+        pos += size;
         len += size;
-        pos = begin + len;
 
-        if (pos < offset) {
-            len   = 0;
-            begin = pos;
+        /* Output one line for each known port */
+        for (i = 0; i < NR_PORTS && cy_port[i].line >= 0; i++) {
+                info = &cy_port[i];
+
+                if (info->count)
+                        size = sprintf(buf + len, "%3d %8lu %10lu %8lu %10lu "
+                                "%8lu %9lu %6ld\n", info->line,
+                                (cur_jifs - info->idle_stats.in_use) / HZ,
+                                info->idle_stats.xmit_bytes,
+                                (cur_jifs - info->idle_stats.xmit_idle) / HZ,
+                                info->idle_stats.recv_bytes,
+                                (cur_jifs - info->idle_stats.recv_idle) / HZ,
+                                info->idle_stats.overruns,
+                                (long)info->tty->ldisc.num);
+                else
+                        size = sprintf(buf + len, "%3d %8lu %10lu %8lu %10lu "
+                                "%8lu %9lu %6ld\n",
+                                info->line, 0L, 0L, 0L, 0L, 0L, 0L, 0L);
+                len += size;
+                pos = begin + len;
+
+                if (pos < offset) {
+                        len = 0;
+                        begin = pos;
+                }
+                if (pos > offset + length)
+                        goto done;
         }
-        if (pos > offset + length)
-            goto done;
-    }
-    *eof = 1;
+        *eof = 1;
 done:
-    *start = buf + (offset - begin);    /* Start of wanted data */
-    len -= (offset - begin);            /* Start slop */
-    if (len > length)
-        len = length;                   /* Ending slop */
-    if (len < 0)
-        len = 0;
-    return len;
+        *start = buf + (offset - begin);        /* Start of wanted data */
+        len -= (offset - begin);        /* Start slop */
+        if (len > length)
+                len = length;   /* Ending slop */
+        if (len < 0)
+                len = 0;
+        return len;
 }
 
 /* The serial driver boot-time initialization code!
@@ -5205,295 +5293,289 @@ done:
     extra ports are ignored.
  */
 
-static struct tty_operations cy_ops = {
-    .open = cy_open,
-    .close = cy_close,
-    .write = cy_write,
-    .put_char = cy_put_char,
-    .flush_chars = cy_flush_chars,
-    .write_room = cy_write_room,
-    .chars_in_buffer = cy_chars_in_buffer,
-    .flush_buffer = cy_flush_buffer,
-    .ioctl = cy_ioctl,
-    .throttle = cy_throttle,
-    .unthrottle = cy_unthrottle,
-    .set_termios = cy_set_termios,
-    .stop = cy_stop,
-    .start = cy_start,
-    .hangup = cy_hangup,
-    .break_ctl = cy_break,
-    .wait_until_sent = cy_wait_until_sent,
-    .read_proc = cyclades_get_proc_info,
-    .tiocmget = cy_tiocmget,
-    .tiocmset = cy_tiocmset,
+static const struct tty_operations cy_ops = {
+        .open = cy_open,
+        .close = cy_close,
+        .write = cy_write,
+        .put_char = cy_put_char,
+        .flush_chars = cy_flush_chars,
+        .write_room = cy_write_room,
+        .chars_in_buffer = cy_chars_in_buffer,
+        .flush_buffer = cy_flush_buffer,
+        .ioctl = cy_ioctl,
+        .throttle = cy_throttle,
+        .unthrottle = cy_unthrottle,
+        .set_termios = cy_set_termios,
+        .stop = cy_stop,
+        .start = cy_start,
+        .hangup = cy_hangup,
+        .break_ctl = cy_break,
+        .wait_until_sent = cy_wait_until_sent,
+        .read_proc = cyclades_get_proc_info,
+        .tiocmget = cy_tiocmget,
+        .tiocmset = cy_tiocmset,
 };
 
-static int __init
-cy_init(void)
+static int __init cy_init(void)
 {
-  struct cyclades_port  *info;
-  struct cyclades_card *cinfo;
-  int number_z_boards = 0;
-  int board,port,i,index;
-  unsigned long mailbox;
-  unsigned short chip_number;
-  int nports;
-
-    cy_serial_driver = alloc_tty_driver(NR_PORTS);
-    if (!cy_serial_driver)
-        return -ENOMEM;
-    show_version();
-
-    /* Initialize the tty_driver structure */
-    
-    cy_serial_driver->owner = THIS_MODULE;
-    cy_serial_driver->driver_name = "cyclades";
-    cy_serial_driver->name = "ttyC";
-    cy_serial_driver->major = CYCLADES_MAJOR;
-    cy_serial_driver->minor_start = 0;
-    cy_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
-    cy_serial_driver->subtype = SERIAL_TYPE_NORMAL;
-    cy_serial_driver->init_termios = tty_std_termios;
-    cy_serial_driver->init_termios.c_cflag =
-            B9600 | CS8 | CREAD | HUPCL | CLOCAL;
-    cy_serial_driver->flags = TTY_DRIVER_REAL_RAW;
-    tty_set_operations(cy_serial_driver, &cy_ops);
-
-    if (tty_register_driver(cy_serial_driver))
-            panic("Couldn't register Cyclades serial driver\n");
-
-    for (i = 0; i < NR_CARDS; i++) {
-            /* base_addr=0 indicates board not found */
-            cy_card[i].base_addr = NULL;
-    }
-
-    /* the code below is responsible to find the boards. Each different
-       type of board has its own detection routine. If a board is found,
-       the next cy_card structure available is set by the detection
-       routine. These functions are responsible for checking the
-       availability of cy_card and cy_port data structures and updating
-       the cy_next_channel. */
-
-    /* look for isa boards */
-    cy_isa_nboard = cy_detect_isa();
-
-    /* look for pci boards */
-    cy_pci_nboard = cy_detect_pci();
-
-    cy_nboard = cy_isa_nboard + cy_pci_nboard;
-
-    /* invalidate remaining cy_card structures */
-    for (i = 0 ; i < NR_CARDS ; i++) {
-        if (cy_card[i].base_addr == 0) {
-                cy_card[i].first_line = -1;
-                cy_card[i].ctl_addr = NULL;
-                cy_card[i].irq = 0;
-                cy_card[i].bus_index = 0;
-                cy_card[i].first_line = 0;
-                cy_card[i].num_chips = 0;
-        }
-    }
-    /* invalidate remaining cy_port structures */
-    for (i = cy_next_channel ; i < NR_PORTS ; i++) {
-        cy_port[i].line = -1;
-        cy_port[i].magic = -1;
-    }
-
-    /* initialize per-port data structures for each valid board found */
-    for (board = 0 ; board < cy_nboard ; board++) {
-            cinfo = &cy_card[board];
-            if (cinfo->num_chips == -1) { /* Cyclades-Z */
-                number_z_boards++;
-                mailbox = cy_readl(&((struct RUNTIME_9060 __iomem *)
-                             cy_card[board].ctl_addr)->mail_box_0);
-                nports = (mailbox == ZE_V1) ? ZE_V1_NPORTS : 8;
-                cinfo->intr_enabled = 0;
-                cinfo->nports = 0; /* Will be correctly set later, after 
-                                      Z FW is loaded */
-                spin_lock_init(&cinfo->card_lock);
-                for (port = cinfo->first_line ;
-                     port < cinfo->first_line + nports;
-                     port++)
-                {
-                    info = &cy_port[port];
-                    info->magic = CYCLADES_MAGIC;
-                    info->type = PORT_STARTECH;
-                    info->card = board;
-                    info->line = port;
-                    info->chip_rev = 0;
-                    info->flags = STD_COM_FLAGS;
-                    info->tty = NULL;
-                    if (mailbox == ZO_V1)
-                        info->xmit_fifo_size = CYZ_FIFO_SIZE;
-                    else
-                        info->xmit_fifo_size = 4 * CYZ_FIFO_SIZE;
-                    info->cor1 = 0;
-                    info->cor2 = 0;
-                    info->cor3 = 0;
-                    info->cor4 = 0;
-                    info->cor5 = 0;
-                    info->tbpr = 0;
-                    info->tco = 0;
-                    info->rbpr = 0;
-                    info->rco = 0;
-                    info->custom_divisor = 0;
-                    info->close_delay = 5*HZ/10;
-                    info->closing_wait = CLOSING_WAIT_DELAY;
-                    info->icount.cts = info->icount.dsr = 
-                        info->icount.rng = info->icount.dcd = 0;
-                    info->icount.rx = info->icount.tx = 0;
-                    info->icount.frame = info->icount.parity = 0;
-                    info->icount.overrun = info->icount.brk = 0;
-                    info->x_char = 0;
-                    info->event = 0;
-                    info->count = 0;
-                    info->blocked_open = 0;
-                    info->default_threshold = 0;
-                    info->default_timeout = 0;
-                    INIT_WORK(&info->tqueue, do_softint, info);
-                    init_waitqueue_head(&info->open_wait);
-                    init_waitqueue_head(&info->close_wait);
-                    init_waitqueue_head(&info->shutdown_wait);
-                    init_waitqueue_head(&info->delta_msr_wait);
-                    /* info->session */
-                    /* info->pgrp */
-                    info->read_status_mask = 0;
-                    /* info->timeout */
-                    /* Bentson's vars */
-                    info->jiffies[0] = 0;
-                    info->jiffies[1] = 0;
-                    info->jiffies[2] = 0;
-                    info->rflush_count = 0;
+        struct cyclades_port *info;
+        struct cyclades_card *cinfo;
+        int number_z_boards = 0;
+        int board, port, i, index;
+        unsigned long mailbox;
+        unsigned short chip_number;
+        int nports;
+
+        cy_serial_driver = alloc_tty_driver(NR_PORTS);
+        if (!cy_serial_driver)
+                return -ENOMEM;
+        show_version();
+
+        /* Initialize the tty_driver structure */
+
+        cy_serial_driver->owner = THIS_MODULE;
+        cy_serial_driver->driver_name = "cyclades";
+        cy_serial_driver->name = "ttyC";
+        cy_serial_driver->major = CYCLADES_MAJOR;
+        cy_serial_driver->minor_start = 0;
+        cy_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
+        cy_serial_driver->subtype = SERIAL_TYPE_NORMAL;
+        cy_serial_driver->init_termios = tty_std_termios;
+        cy_serial_driver->init_termios.c_cflag =
+            B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+        cy_serial_driver->flags = TTY_DRIVER_REAL_RAW;
+        tty_set_operations(cy_serial_driver, &cy_ops);
+
+        if (tty_register_driver(cy_serial_driver))
+                panic("Couldn't register Cyclades serial driver\n");
+
+        for (i = 0; i < NR_CARDS; i++) {
+                /* base_addr=0 indicates board not found */
+                cy_card[i].base_addr = NULL;
+        }
+
+        /* the code below is responsible to find the boards. Each different
+           type of board has its own detection routine. If a board is found,
+           the next cy_card structure available is set by the detection
+           routine. These functions are responsible for checking the
+           availability of cy_card and cy_port data structures and updating
+           the cy_next_channel. */
+
+        /* look for isa boards */
+        cy_isa_nboard = cy_detect_isa();
+
+        /* look for pci boards */
+        cy_pci_nboard = cy_detect_pci();
+
+        cy_nboard = cy_isa_nboard + cy_pci_nboard;
+
+        /* invalidate remaining cy_card structures */
+        for (i = 0; i < NR_CARDS; i++) {
+                if (cy_card[i].base_addr == 0) {
+                        cy_card[i].first_line = -1;
+                        cy_card[i].ctl_addr = NULL;
+                        cy_card[i].irq = 0;
+                        cy_card[i].bus_index = 0;
+                        cy_card[i].first_line = 0;
+                        cy_card[i].num_chips = 0;
+                }
+        }
+        /* invalidate remaining cy_port structures */
+        for (i = cy_next_channel; i < NR_PORTS; i++) {
+                cy_port[i].line = -1;
+                cy_port[i].magic = -1;
+        }
+
+        /* initialize per-port data structures for each valid board found */
+        for (board = 0; board < cy_nboard; board++) {
+                cinfo = &cy_card[board];
+                if (cinfo->num_chips == -1) {   /* Cyclades-Z */
+                        number_z_boards++;
+                        mailbox = cy_readl(&((struct RUNTIME_9060 __iomem *)
+                                             cy_card[board].ctl_addr)->
+                                           mail_box_0);
+                        nports = (mailbox == ZE_V1) ? ZE_V1_NPORTS : 8;
+                        cinfo->intr_enabled = 0;
+                        cinfo->nports = 0;      /* Will be correctly set later, after 
+                                                   Z FW is loaded */
+                        spin_lock_init(&cinfo->card_lock);
+                        for (port = cinfo->first_line;
+                             port < cinfo->first_line + nports; port++) {
+                                info = &cy_port[port];
+                                info->magic = CYCLADES_MAGIC;
+                                info->type = PORT_STARTECH;
+                                info->card = board;
+                                info->line = port;
+                                info->chip_rev = 0;
+                                info->flags = STD_COM_FLAGS;
+                                info->tty = NULL;
+                                if (mailbox == ZO_V1)
+                                        info->xmit_fifo_size = CYZ_FIFO_SIZE;
+                                else
+                                        info->xmit_fifo_size =
+                                            4 * CYZ_FIFO_SIZE;
+                                info->cor1 = 0;
+                                info->cor2 = 0;
+                                info->cor3 = 0;
+                                info->cor4 = 0;
+                                info->cor5 = 0;
+                                info->tbpr = 0;
+                                info->tco = 0;
+                                info->rbpr = 0;
+                                info->rco = 0;
+                                info->custom_divisor = 0;
+                                info->close_delay = 5 * HZ / 10;
+                                info->closing_wait = CLOSING_WAIT_DELAY;
+                                info->icount.cts = info->icount.dsr =
+                                    info->icount.rng = info->icount.dcd = 0;
+                                info->icount.rx = info->icount.tx = 0;
+                                info->icount.frame = info->icount.parity = 0;
+                                info->icount.overrun = info->icount.brk = 0;
+                                info->x_char = 0;
+                                info->event = 0;
+                                info->count = 0;
+                                info->blocked_open = 0;
+                                info->default_threshold = 0;
+                                info->default_timeout = 0;
+                                INIT_WORK(&info->tqueue, do_softint);
+                                init_waitqueue_head(&info->open_wait);
+                                init_waitqueue_head(&info->close_wait);
+                                init_waitqueue_head(&info->shutdown_wait);
+                                init_waitqueue_head(&info->delta_msr_wait);
+                                /* info->session */
+                                /* info->pgrp */
+                                info->read_status_mask = 0;
+                                /* info->timeout */
+                                /* Bentson's vars */
+                                info->jiffies[0] = 0;
+                                info->jiffies[1] = 0;
+                                info->jiffies[2] = 0;
+                                info->rflush_count = 0;
 #ifdef CONFIG_CYZ_INTR
-                    init_timer(&cyz_rx_full_timer[port]);
-                    cyz_rx_full_timer[port].function = NULL;
+                                init_timer(&cyz_rx_full_timer[port]);
+                                cyz_rx_full_timer[port].function = NULL;
 #endif
-                }
-                continue;
-            }else{ /* Cyclom-Y of some kind*/
-                index = cinfo->bus_index;
-                spin_lock_init(&cinfo->card_lock);
-                cinfo->nports = CyPORTS_PER_CHIP * cinfo->num_chips;
-                for (port = cinfo->first_line ;
-                     port < cinfo->first_line + cinfo->nports ;
-                     port++)
-                {
-                    info = &cy_port[port];
-                    info->magic = CYCLADES_MAGIC;
-                    info->type = PORT_CIRRUS;
-                    info->card = board;
-                    info->line = port;
-                    info->flags = STD_COM_FLAGS;
-                    info->tty = NULL;
-                    info->xmit_fifo_size = CyMAX_CHAR_FIFO;
-                    info->cor1 = CyPARITY_NONE|Cy_1_STOP|Cy_8_BITS;
-                    info->cor2 = CyETC;
-                    info->cor3 = 0x08; /* _very_ small rcv threshold */
-                    info->cor4 = 0;
-                    info->cor5 = 0;
-                    info->custom_divisor = 0;
-                    info->close_delay = 5*HZ/10;
-                    info->closing_wait = CLOSING_WAIT_DELAY;
-                    info->icount.cts = info->icount.dsr = 
-                        info->icount.rng = info->icount.dcd = 0;
-                    info->icount.rx = info->icount.tx = 0;
-                    info->icount.frame = info->icount.parity = 0;
-                    info->icount.overrun = info->icount.brk = 0;
-                    chip_number = (port - cinfo->first_line) / 4;
-                    if ((info->chip_rev =
-                         cy_readb(cinfo->base_addr +
-                                  (cy_chip_offset[chip_number]<<index) +
-                                  (CyGFRCR<<index))) >= CD1400_REV_J) {
-                        /* It is a CD1400 rev. J or later */
-                        info->tbpr = baud_bpr_60[13]; /* Tx BPR */
-                        info->tco = baud_co_60[13]; /* Tx CO */
-                        info->rbpr = baud_bpr_60[13]; /* Rx BPR */
-                        info->rco = baud_co_60[13]; /* Rx CO */
-                        info->rflow = 0;
-                        info->rtsdtr_inv = 1;
-                    } else {
-                        info->tbpr = baud_bpr_25[13]; /* Tx BPR */
-                        info->tco = baud_co_25[13]; /* Tx CO */
-                        info->rbpr = baud_bpr_25[13]; /* Rx BPR */
-                        info->rco = baud_co_25[13]; /* Rx CO */
-                        info->rflow = 0;
-                        info->rtsdtr_inv = 0;
-                    }
-                    info->x_char = 0;
-                    info->event = 0;
-                    info->count = 0;
-                    info->blocked_open = 0;
-                    info->default_threshold = 0;
-                    info->default_timeout = 0;
-                    INIT_WORK(&info->tqueue, do_softint, info);
-                    init_waitqueue_head(&info->open_wait);
-                    init_waitqueue_head(&info->close_wait);
-                    init_waitqueue_head(&info->shutdown_wait);
-                    init_waitqueue_head(&info->delta_msr_wait);
-                    /* info->session */
-                    /* info->pgrp */
-                    info->read_status_mask =
-                                  CyTIMEOUT| CySPECHAR| CyBREAK
-                                  | CyPARITY| CyFRAME| CyOVERRUN;
-                    /* info->timeout */
-                }
-            }
-    }
+                        }
+                        continue;
+                } else {        /* Cyclom-Y of some kind */
+                        index = cinfo->bus_index;
+                        spin_lock_init(&cinfo->card_lock);
+                        cinfo->nports = CyPORTS_PER_CHIP * cinfo->num_chips;
+                        for (port = cinfo->first_line;
+                             port < cinfo->first_line + cinfo->nports; port++) {
+                                info = &cy_port[port];
+                                info->magic = CYCLADES_MAGIC;
+                                info->type = PORT_CIRRUS;
+                                info->card = board;
+                                info->line = port;
+                                info->flags = STD_COM_FLAGS;
+                                info->tty = NULL;
+                                info->xmit_fifo_size = CyMAX_CHAR_FIFO;
+                                info->cor1 =
+                                    CyPARITY_NONE | Cy_1_STOP | Cy_8_BITS;
+                                info->cor2 = CyETC;
+                                info->cor3 = 0x08;      /* _very_ small rcv threshold */
+                                info->cor4 = 0;
+                                info->cor5 = 0;
+                                info->custom_divisor = 0;
+                                info->close_delay = 5 * HZ / 10;
+                                info->closing_wait = CLOSING_WAIT_DELAY;
+                                info->icount.cts = info->icount.dsr =
+                                    info->icount.rng = info->icount.dcd = 0;
+                                info->icount.rx = info->icount.tx = 0;
+                                info->icount.frame = info->icount.parity = 0;
+                                info->icount.overrun = info->icount.brk = 0;
+                                chip_number = (port - cinfo->first_line) / 4;
+                                if ((info->chip_rev =
+                                     cy_readb(cinfo->base_addr +
+                                              (cy_chip_offset[chip_number] <<
+                                               index) + (CyGFRCR << index))) >=
+                                    CD1400_REV_J) {
+                                        /* It is a CD1400 rev. J or later */
+                                        info->tbpr = baud_bpr_60[13];   /* Tx BPR */
+                                        info->tco = baud_co_60[13];     /* Tx CO */
+                                        info->rbpr = baud_bpr_60[13];   /* Rx BPR */
+                                        info->rco = baud_co_60[13];     /* Rx CO */
+                                        info->rflow = 0;
+                                        info->rtsdtr_inv = 1;
+                                } else {
+                                        info->tbpr = baud_bpr_25[13];   /* Tx BPR */
+                                        info->tco = baud_co_25[13];     /* Tx CO */
+                                        info->rbpr = baud_bpr_25[13];   /* Rx BPR */
+                                        info->rco = baud_co_25[13];     /* Rx CO */
+                                        info->rflow = 0;
+                                        info->rtsdtr_inv = 0;
+                                }
+                                info->x_char = 0;
+                                info->event = 0;
+                                info->count = 0;
+                                info->blocked_open = 0;
+                                info->default_threshold = 0;
+                                info->default_timeout = 0;
+                                INIT_WORK(&info->tqueue, do_softint);
+                                init_waitqueue_head(&info->open_wait);
+                                init_waitqueue_head(&info->close_wait);
+                                init_waitqueue_head(&info->shutdown_wait);
+                                init_waitqueue_head(&info->delta_msr_wait);
+                                /* info->session */
+                                /* info->pgrp */
+                                info->read_status_mask =
+                                    CyTIMEOUT | CySPECHAR | CyBREAK
+                                    | CyPARITY | CyFRAME | CyOVERRUN;
+                                /* info->timeout */
+                        }
+                }
+        }
 
 #ifndef CONFIG_CYZ_INTR
-    if (number_z_boards && !cyz_timeron){
-        cyz_timeron++;
-        cyz_timerlist.expires = jiffies + 1;
-        add_timer(&cyz_timerlist);
+        if (number_z_boards && !cyz_timeron) {
+                cyz_timeron++;
+                cyz_timerlist.expires = jiffies + 1;
+                add_timer(&cyz_timerlist);
 #ifdef CY_PCI_DEBUG
-        printk("Cyclades-Z polling initialized\n");
+                printk("Cyclades-Z polling initialized\n");
 #endif
-    }
-#endif /* CONFIG_CYZ_INTR */
+        }
+#endif                          /* CONFIG_CYZ_INTR */
+
+        return 0;
 
-    return 0;
-    
-} /* cy_init */
+}                               /* cy_init */
 
-static void __exit
-cy_cleanup_module(void)
+static void __exit cy_cleanup_module(void)
 {
-    int i, e1;
+        int i, e1;
 
 #ifndef CONFIG_CYZ_INTR
-    if (cyz_timeron){
-        cyz_timeron = 0;
-        del_timer(&cyz_timerlist);
-    }
+        if (cyz_timeron){
+                cyz_timeron = 0;
+                del_timer(&cyz_timerlist);
+        }
 #endif /* CONFIG_CYZ_INTR */
 
-    if ((e1 = tty_unregister_driver(cy_serial_driver)))
-            printk("cyc: failed to unregister Cyclades serial driver(%d)\n",
-                e1);
+        if ((e1 = tty_unregister_driver(cy_serial_driver)))
+                printk("cyc: failed to unregister Cyclades serial driver(%d)\n",
+                        e1);
 
-    put_tty_driver(cy_serial_driver);
+        put_tty_driver(cy_serial_driver);
 
-    for (i = 0; i < NR_CARDS; i++) {
-        if (cy_card[i].base_addr) {
-            iounmap(cy_card[i].base_addr);
-            if (cy_card[i].ctl_addr)
-                iounmap(cy_card[i].ctl_addr);
-            if (cy_card[i].irq
+        for (i = 0; i < NR_CARDS; i++) {
+                if (cy_card[i].base_addr) {
+                        iounmap(cy_card[i].base_addr);
+                        if (cy_card[i].ctl_addr)
+                                iounmap(cy_card[i].ctl_addr);
+                        if (cy_card[i].irq
 #ifndef CONFIG_CYZ_INTR
-                && cy_card[i].num_chips != -1 /* not a Z card */
+                                && cy_card[i].num_chips != -1 /* not a Z card */
 #endif /* CONFIG_CYZ_INTR */
-            )
-                free_irq(cy_card[i].irq, &cy_card[i]);
+                                )
+                                free_irq(cy_card[i].irq, &cy_card[i]);
 #ifdef CONFIG_PCI
-                if (cy_card[i].pdev)
-                        pci_release_regions(cy_card[i].pdev);
+                        if (cy_card[i].pdev)
+                                pci_release_regions(cy_card[i].pdev);
 #endif
-        }
-    }
-    if (tmp_buf) {
-        free_page((unsigned long) tmp_buf);
-        tmp_buf = NULL;
-    }
+                }
+        }
 } /* cy_cleanup_module */
 
 module_init(cy_init);
diff --git a/drivers/char/decserial.c b/drivers/char/decserial.c
index 85f404e25c73..8ea2bea2b183 100644
--- a/drivers/char/decserial.c
+++ b/drivers/char/decserial.c
@@ -23,20 +23,12 @@
 extern int zs_init(void);
 #endif
 
-#ifdef CONFIG_DZ
-extern int dz_init(void);
-#endif
-
 #ifdef CONFIG_SERIAL_CONSOLE
 
 #ifdef CONFIG_ZS
 extern void zs_serial_console_init(void);
 #endif
 
-#ifdef CONFIG_DZ
-extern void dz_serial_console_init(void);
-#endif
-
 #endif
 
 /* rs_init - starts up the serial interface -
@@ -46,23 +38,11 @@ extern void dz_serial_console_init(void);
 
 int __init rs_init(void)
 {
-
-#if defined(CONFIG_ZS) && defined(CONFIG_DZ)
+#ifdef CONFIG_ZS
     if (IOASIC)
         return zs_init();
-    else
-        return dz_init();
-#else
-
-#ifdef CONFIG_ZS
-    return zs_init();
-#endif
-
-#ifdef CONFIG_DZ
-    return dz_init();
-#endif
-
 #endif
+    return -ENXIO;
 }
 
 __initcall(rs_init);
@@ -76,21 +56,9 @@ __initcall(rs_init);
  */
 static int __init decserial_console_init(void)
 {
-#if defined(CONFIG_ZS) && defined(CONFIG_DZ)
+#ifdef CONFIG_ZS
     if (IOASIC)
         zs_serial_console_init();
-    else
-        dz_serial_console_init();
-#else
-
-#ifdef CONFIG_ZS
-    zs_serial_console_init();
-#endif
-
-#ifdef CONFIG_DZ
-    dz_serial_console_init();
-#endif
-
 #endif
     return 0;
 }
diff --git a/drivers/char/drm/Kconfig b/drivers/char/drm/Kconfig
index 5278c388d3e7..ef833a1c27eb 100644
--- a/drivers/char/drm/Kconfig
+++ b/drivers/char/drm/Kconfig
@@ -60,7 +60,9 @@ config DRM_I830
           Choose this option if you have a system that has Intel 830M, 845G,
           852GM, 855GM or 865G integrated graphics.  If M is selected, the
           module will be called i830.  AGP support is required for this driver
-          to work. This driver will eventually be replaced by the i915 one.
+          to work. This driver is used by the older X releases X.org 6.7 and
+          XFree86 4.3. If unsure, build this and i915 as modules and the X server
+          will load the correct one.
 
 config DRM_I915
         tristate "i915 driver"
@@ -68,8 +70,9 @@ config DRM_I915
           Choose this option if you have a system that has Intel 830M, 845G,
           852GM, 855GM 865G or 915G integrated graphics.  If M is selected, the
           module will be called i915.  AGP support is required for this driver
-          to work. This driver will eventually replace the I830 driver, when
-          later release of X start to use the new DDX and DRI.
+          to work. This driver is used by the Intel driver in X.org 6.8 and
+          XFree86 4.4 and above. If unsure, build this and i830 as modules and 
+          the X server will load the correct one.
         
 endchoice
 
diff --git a/drivers/char/drm/Makefile b/drivers/char/drm/Makefile
index 9d180c42816c..3ad0f648c6b2 100644
--- a/drivers/char/drm/Makefile
+++ b/drivers/char/drm/Makefile
@@ -6,7 +6,7 @@ drm-objs    :=	drm_auth.o drm_bufs.o drm_context.o drm_dma.o drm_drawable.o \
                 drm_drv.o drm_fops.o drm_ioctl.o drm_irq.o \
                 drm_lock.o drm_memory.o drm_proc.o drm_stub.o drm_vm.o \
                 drm_agpsupport.o drm_scatter.o ati_pcigart.o drm_pci.o \
-                drm_sysfs.o
+                drm_sysfs.o drm_hashtab.o drm_sman.o drm_mm.o
 
 tdfx-objs   := tdfx_drv.o
 r128-objs   := r128_drv.o r128_cce.o r128_state.o r128_irq.o
@@ -16,9 +16,9 @@ i830-objs   := i830_drv.o i830_dma.o i830_irq.o
 i915-objs   := i915_drv.o i915_dma.o i915_irq.o i915_mem.o
 radeon-objs := radeon_drv.o radeon_cp.o radeon_state.o radeon_mem.o radeon_irq.o r300_cmdbuf.o
 ffb-objs    := ffb_drv.o ffb_context.o
-sis-objs    := sis_drv.o sis_ds.o sis_mm.o
+sis-objs    := sis_drv.o sis_mm.o
 savage-objs := savage_drv.o savage_bci.o savage_state.o
-via-objs    := via_irq.o via_drv.o via_ds.o via_map.o via_mm.o via_dma.o via_verifier.o via_video.o via_dmablit.o
+via-objs    := via_irq.o via_drv.o via_map.o via_mm.o via_dma.o via_verifier.o via_video.o via_dmablit.o
 
 ifeq ($(CONFIG_COMPAT),y)
 drm-objs    += drm_ioc32.o
diff --git a/drivers/char/drm/drm.h b/drivers/char/drm/drm.h
index 5642ac43e0f5..8db9041e306c 100644
--- a/drivers/char/drm/drm.h
+++ b/drivers/char/drm/drm.h
@@ -117,6 +117,14 @@ typedef struct drm_clip_rect {
 } drm_clip_rect_t;
 
 /**
+ * Drawable information.
+ */
+typedef struct drm_drawable_info {
+        unsigned int num_rects;
+        drm_clip_rect_t *rects;
+} drm_drawable_info_t;
+
+/**
  * Texture region,
  */
 typedef struct drm_tex_region {
@@ -348,7 +356,8 @@ typedef struct drm_buf_desc {
                 _DRM_PAGE_ALIGN = 0x01, /**< Align on page boundaries for DMA */
                 _DRM_AGP_BUFFER = 0x02, /**< Buffer is in AGP space */
                 _DRM_SG_BUFFER = 0x04,  /**< Scatter/gather memory buffer */
-                _DRM_FB_BUFFER = 0x08   /**< Buffer is in frame buffer */
+                _DRM_FB_BUFFER = 0x08,  /**< Buffer is in frame buffer */
+                _DRM_PCI_BUFFER_RO = 0x10 /**< Map PCI DMA buffer read-only */
         } flags;
         unsigned long agp_start; /**<
                                   * Start address of where the AGP buffers are
@@ -444,6 +453,20 @@ typedef struct drm_draw {
 } drm_draw_t;
 
 /**
+ * DRM_IOCTL_UPDATE_DRAW ioctl argument type.
+ */
+typedef enum {
+        DRM_DRAWABLE_CLIPRECTS,
+} drm_drawable_info_type_t;
+
+typedef struct drm_update_draw {
+        drm_drawable_t handle;
+        unsigned int type;
+        unsigned int num;
+        unsigned long long data;
+} drm_update_draw_t;
+
+/**
  * DRM_IOCTL_GET_MAGIC and DRM_IOCTL_AUTH_MAGIC ioctl argument type.
  */
 typedef struct drm_auth {
@@ -465,10 +488,14 @@ typedef struct drm_irq_busid {
 typedef enum {
         _DRM_VBLANK_ABSOLUTE = 0x0,     /**< Wait for specific vblank sequence number */
         _DRM_VBLANK_RELATIVE = 0x1,     /**< Wait for given number of vblanks */
+        _DRM_VBLANK_NEXTONMISS = 0x10000000,    /**< If missed, wait for next vblank */
+        _DRM_VBLANK_SECONDARY = 0x20000000,     /**< Secondary display controller */
         _DRM_VBLANK_SIGNAL = 0x40000000 /**< Send signal instead of blocking */
 } drm_vblank_seq_type_t;
 
-#define _DRM_VBLANK_FLAGS_MASK _DRM_VBLANK_SIGNAL
+#define _DRM_VBLANK_TYPES_MASK (_DRM_VBLANK_ABSOLUTE | _DRM_VBLANK_RELATIVE)
+#define _DRM_VBLANK_FLAGS_MASK (_DRM_VBLANK_SIGNAL | _DRM_VBLANK_SECONDARY | \
+                                _DRM_VBLANK_NEXTONMISS)
 
 struct drm_wait_vblank_request {
         drm_vblank_seq_type_t type;
@@ -623,6 +650,8 @@ typedef struct drm_set_version {
 
 #define DRM_IOCTL_WAIT_VBLANK           DRM_IOWR(0x3a, drm_wait_vblank_t)
 
+#define DRM_IOCTL_UPDATE_DRAW           DRM_IOW(0x3f, drm_update_draw_t)
+
 /**
  * Device specific ioctls should only be in their respective headers
  * The device specific ioctl range is from 0x40 to 0x79.
diff --git a/drivers/char/drm/drmP.h b/drivers/char/drm/drmP.h
index d2a56182bc35..0bbb04f2390f 100644
--- a/drivers/char/drm/drmP.h
+++ b/drivers/char/drm/drmP.h
@@ -79,6 +79,7 @@
 #define __OS_HAS_MTRR (defined(CONFIG_MTRR))
 
 #include "drm_os_linux.h"
+#include "drm_hashtab.h"
 
 /***********************************************************************/
 /** \name DRM template customization defaults */
@@ -96,6 +97,7 @@
 #define DRIVER_IRQ_VBL     0x100
 #define DRIVER_DMA_QUEUE   0x200
 #define DRIVER_FB_DMA      0x400
+#define DRIVER_IRQ_VBL2    0x800
 
 /***********************************************************************/
 /** \name Begin the DRM... */
@@ -104,7 +106,7 @@
 #define DRM_DEBUG_CODE 2          /**< Include debugging code if > 1, then
                                      also include looping detection. */
 
-#define DRM_HASH_SIZE         16 /**< Size of key hash table. Must be power of 2. */
+#define DRM_MAGIC_HASH_ORDER  4  /**< Size of key hash table. Must be power of 2. */
 #define DRM_KERNEL_CONTEXT    0  /**< Change drm_resctx if changed */
 #define DRM_RESERVED_CONTEXTS 1  /**< Change drm_resctx if changed */
 #define DRM_LOOPING_LIMIT     5000000
@@ -134,19 +136,12 @@
 #define DRM_MEM_CTXBITMAP 18
 #define DRM_MEM_STUB      19
 #define DRM_MEM_SGLISTS   20
-#define DRM_MEM_CTXLIST  21
+#define DRM_MEM_CTXLIST   21
+#define DRM_MEM_MM        22
+#define DRM_MEM_HASHTAB   23
 
 #define DRM_MAX_CTXBITMAP (PAGE_SIZE * 8)
-
-/*@}*/
-
-/***********************************************************************/
-/** \name Backward compatibility section */
-/*@{*/
-
-#define DRM_RPR_ARG(vma) vma,
-
-#define VM_OFFSET(vma) ((vma)->vm_pgoff << PAGE_SHIFT)
+#define DRM_MAP_HASH_OFFSET 0x10000000
 
 /*@}*/
 
@@ -211,8 +206,6 @@
 /*@{*/
 
 #define DRM_ARRAY_SIZE(x) ARRAY_SIZE(x)
-#define DRM_MIN(a,b) min(a,b)
-#define DRM_MAX(a,b) max(a,b)
 
 #define DRM_LEFTCOUNT(x) (((x)->rp + (x)->count - (x)->wp) % ((x)->count + 1))
 #define DRM_BUFCOUNT(x) ((x)->count - DRM_LEFTCOUNT(x))
@@ -286,7 +279,8 @@ typedef struct drm_devstate {
 } drm_devstate_t;
 
 typedef struct drm_magic_entry {
-        drm_magic_t magic;
+        drm_hash_item_t hash_item;
+        struct list_head head;
         struct drm_file *priv;
         struct drm_magic_entry *next;
 } drm_magic_entry_t;
@@ -437,7 +431,8 @@ typedef struct drm_device_dma {
         enum {
                 _DRM_DMA_USE_AGP = 0x01,
                 _DRM_DMA_USE_SG = 0x02,
-                _DRM_DMA_USE_FB = 0x04
+                _DRM_DMA_USE_FB = 0x04,
+                _DRM_DMA_USE_PCI_RO = 0x08
         } flags;
 
 } drm_device_dma_t;
@@ -493,6 +488,7 @@ typedef struct drm_sigdata {
  */
 typedef struct drm_map_list {
         struct list_head head;          /**< list head */
+        drm_hash_item_t hash;
         drm_map_t *map;                 /**< mapping */
         unsigned int user_token;
 } drm_map_list_t;
@@ -527,6 +523,22 @@ typedef struct ati_pcigart_info {
         drm_local_map_t mapping;
 } drm_ati_pcigart_info;
 
+/*
+ * Generic memory manager structs
+ */
+typedef struct drm_mm_node {
+        struct list_head fl_entry;
+        struct list_head ml_entry;
+        int free;
+        unsigned long start;
+        unsigned long size;
+        void *private;
+} drm_mm_node_t;
+
+typedef struct drm_mm {
+        drm_mm_node_t root_node;
+} drm_mm_t;
+
 /**
  * DRM driver structure. This structure represent the common code for
  * a family of cards. There will one drm_device for each card present
@@ -552,6 +564,7 @@ struct drm_driver {
         void (*kernel_context_switch_unlock) (struct drm_device * dev,
                                               drm_lock_t *lock);
         int (*vblank_wait) (struct drm_device * dev, unsigned int *sequence);
+        int (*vblank_wait2) (struct drm_device * dev, unsigned int *sequence);
         int (*dri_library_name) (struct drm_device *dev, char *buf);
 
         /**
@@ -646,13 +659,15 @@ typedef struct drm_device {
         /*@{ */
         drm_file_t *file_first;         /**< file list head */
         drm_file_t *file_last;          /**< file list tail */
-        drm_magic_head_t magiclist[DRM_HASH_SIZE];      /**< magic hash table */
+        drm_open_hash_t magiclist;      /**< magic hash table */
+        struct list_head magicfree;
         /*@} */
 
         /** \name Memory management */
         /*@{ */
         drm_map_list_t *maplist;        /**< Linked list of regions */
         int map_count;                  /**< Number of mappable regions */
+        drm_open_hash_t map_hash;       /**< User token hash table for maps */
 
         /** \name Context handle management */
         /*@{ */
@@ -696,9 +711,13 @@ typedef struct drm_device {
 
         wait_queue_head_t vbl_queue;    /**< VBLANK wait queue */
         atomic_t vbl_received;
+        atomic_t vbl_received2;         /**< number of secondary VBLANK interrupts */
         spinlock_t vbl_lock;
         drm_vbl_sig_t vbl_sigs;         /**< signal list to send on VBLANK */
+        drm_vbl_sig_t vbl_sigs2;        /**< signals to send on secondary VBLANK */
         unsigned int vbl_pending;
+        spinlock_t tasklet_lock;        /**< For drm_locked_tasklet */
+        void (*locked_tasklet_func)(struct drm_device *dev);
 
         /*@} */
         cycles_t ctx_start;
@@ -711,10 +730,8 @@ typedef struct drm_device {
         drm_agp_head_t *agp;    /**< AGP data */
 
         struct pci_dev *pdev;           /**< PCI device structure */
-        int pci_domain;                 /**< PCI bus domain number */
-        int pci_bus;                    /**< PCI bus number */
-        int pci_slot;                   /**< PCI slot number */
-        int pci_func;                   /**< PCI function number */
+        int pci_vendor;                 /**< PCI vendor id */
+        int pci_device;                 /**< PCI device id */
 #ifdef __alpha__
         struct pci_controller *hose;
 #endif
@@ -728,6 +745,15 @@ typedef struct drm_device {
         drm_local_map_t *agp_buffer_map;
         unsigned int agp_buffer_token;
         drm_head_t primary;             /**< primary screen head */
+
+        /** \name Drawable information */
+        /*@{ */
+        spinlock_t drw_lock;
+        unsigned int drw_bitfield_length;
+        u32 *drw_bitfield;
+        unsigned int drw_info_length;
+        drm_drawable_info_t **drw_info;
+        /*@} */
 } drm_device_t;
 
 static __inline__ int drm_core_check_feature(struct drm_device *dev,
@@ -736,6 +762,12 @@ static __inline__ int drm_core_check_feature(struct drm_device *dev,
         return ((dev->driver->driver_features & feature) ? 1 : 0);
 }
 
+#ifdef __alpha__
+#define drm_get_pci_domain(dev) dev->hose->bus->number
+#else
+#define drm_get_pci_domain(dev) 0
+#endif
+
 #if __OS_HAS_AGP
 static inline int drm_core_has_AGP(struct drm_device *dev)
 {
@@ -869,6 +901,10 @@ extern int drm_adddraw(struct inode *inode, struct file *filp,
                        unsigned int cmd, unsigned long arg);
 extern int drm_rmdraw(struct inode *inode, struct file *filp,
                       unsigned int cmd, unsigned long arg);
+extern int drm_update_drawable_info(struct inode *inode, struct file *filp,
+                       unsigned int cmd, unsigned long arg);
+extern drm_drawable_info_t *drm_get_drawable_info(drm_device_t *dev,
+                                                  drm_drawable_t id);
 
                                 /* Authentication IOCTL support (drm_auth.h) */
 extern int drm_getmagic(struct inode *inode, struct file *filp,
@@ -933,6 +969,7 @@ extern int drm_wait_vblank(struct inode *inode, struct file *filp,
                            unsigned int cmd, unsigned long arg);
 extern int drm_vblank_wait(drm_device_t * dev, unsigned int *vbl_seq);
 extern void drm_vbl_send_signals(drm_device_t * dev);
+extern void drm_locked_tasklet(drm_device_t *dev, void(*func)(drm_device_t*));
 
                                 /* AGP/GART support (drm_agpsupport.h) */
 extern drm_agp_head_t *drm_agp_init(drm_device_t * dev);
@@ -1011,6 +1048,18 @@ 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);
 
+/*
+ * Basic memory manager support (drm_mm.c)
+ */
+extern drm_mm_node_t *drm_mm_get_block(drm_mm_node_t * parent,
+                                       unsigned long size,
+                                       unsigned alignment);
+extern void drm_mm_put_block(drm_mm_t *mm, drm_mm_node_t *cur);
+extern drm_mm_node_t *drm_mm_search_free(const drm_mm_t *mm, unsigned long size,
+                                         unsigned alignment, int best_match);
+extern int drm_mm_init(drm_mm_t *mm, unsigned long start, unsigned long size);
+extern void drm_mm_takedown(drm_mm_t *mm);
+
 /* Inline replacements for DRM_IOREMAP macros */
 static __inline__ void drm_core_ioremap(struct drm_map *map,
                                         struct drm_device *dev)
diff --git a/drivers/char/drm/drm_auth.c b/drivers/char/drm/drm_auth.c
index 2a37586a7ee8..c7b19d35bcd6 100644
--- a/drivers/char/drm/drm_auth.c
+++ b/drivers/char/drm/drm_auth.c
@@ -36,20 +36,6 @@
 #include "drmP.h"
 
 /**
- * Generate a hash key from a magic.
- *
- * \param magic magic.
- * \return hash key.
- *
- * The key is the modulus of the hash table size, #DRM_HASH_SIZE, which must be
- * a power of 2.
- */
-static int drm_hash_magic(drm_magic_t magic)
-{
-        return magic & (DRM_HASH_SIZE - 1);
-}
-
-/**
  * Find the file with the given magic number.
  *
  * \param dev DRM device.
@@ -63,14 +49,12 @@ static drm_file_t *drm_find_file(drm_device_t * dev, drm_magic_t magic)
 {
         drm_file_t *retval = NULL;
         drm_magic_entry_t *pt;
-        int hash = drm_hash_magic(magic);
+        drm_hash_item_t *hash;
 
         mutex_lock(&dev->struct_mutex);
-        for (pt = dev->magiclist[hash].head; pt; pt = pt->next) {
-                if (pt->magic == magic) {
-                        retval = pt->priv;
-                        break;
-                }
+        if (!drm_ht_find_item(&dev->magiclist, (unsigned long)magic, &hash)) {
+                pt = drm_hash_entry(hash, drm_magic_entry_t, hash_item);
+                retval = pt->priv;
         }
         mutex_unlock(&dev->struct_mutex);
         return retval;
@@ -90,28 +74,20 @@ static drm_file_t *drm_find_file(drm_device_t * dev, drm_magic_t magic)
 static int drm_add_magic(drm_device_t * dev, drm_file_t * priv,
                          drm_magic_t magic)
 {
-        int hash;
         drm_magic_entry_t *entry;
 
         DRM_DEBUG("%d\n", magic);
 
-        hash = drm_hash_magic(magic);
         entry = drm_alloc(sizeof(*entry), DRM_MEM_MAGIC);
         if (!entry)
                 return -ENOMEM;
         memset(entry, 0, sizeof(*entry));
-        entry->magic = magic;
         entry->priv = priv;
-        entry->next = NULL;
 
+        entry->hash_item.key = (unsigned long)magic;
         mutex_lock(&dev->struct_mutex);
-        if (dev->magiclist[hash].tail) {
-                dev->magiclist[hash].tail->next = entry;
-                dev->magiclist[hash].tail = entry;
-        } else {
-                dev->magiclist[hash].head = entry;
-                dev->magiclist[hash].tail = entry;
-        }
+        drm_ht_insert_item(&dev->magiclist, &entry->hash_item);
+        list_add_tail(&entry->head, &dev->magicfree);
         mutex_unlock(&dev->struct_mutex);
 
         return 0;
@@ -128,34 +104,24 @@ static int drm_add_magic(drm_device_t * dev, drm_file_t * priv,
  */
 static int drm_remove_magic(drm_device_t * dev, drm_magic_t magic)
 {
-        drm_magic_entry_t *prev = NULL;
         drm_magic_entry_t *pt;
-        int hash;
+        drm_hash_item_t *hash;
 
         DRM_DEBUG("%d\n", magic);
-        hash = drm_hash_magic(magic);
 
         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) {
-                                dev->magiclist[hash].head = pt->next;
-                        }
-                        if (dev->magiclist[hash].tail == pt) {
-                                dev->magiclist[hash].tail = prev;
-                        }
-                        if (prev) {
-                                prev->next = pt->next;
-                        }
-                        mutex_unlock(&dev->struct_mutex);
-                        return 0;
-                }
+        if (drm_ht_find_item(&dev->magiclist, (unsigned long)magic, &hash)) {
+                mutex_unlock(&dev->struct_mutex);
+                return -EINVAL;
         }
+        pt = drm_hash_entry(hash, drm_magic_entry_t, hash_item);
+        drm_ht_remove_item(&dev->magiclist, hash);
+        list_del(&pt->head);
         mutex_unlock(&dev->struct_mutex);
 
         drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC);
 
-        return -EINVAL;
+        return 0;
 }
 
 /**
diff --git a/drivers/char/drm/drm_bufs.c b/drivers/char/drm/drm_bufs.c
index 006b06d29727..9f65f5697ba8 100644
--- a/drivers/char/drm/drm_bufs.c
+++ b/drivers/char/drm/drm_bufs.c
@@ -65,43 +65,29 @@ static drm_map_list_t *drm_find_matching_map(drm_device_t *dev,
         return NULL;
 }
 
-/*
- * Used to allocate 32-bit handles for mappings.
- */
-#define START_RANGE 0x10000000
-#define END_RANGE 0x40000000
-
-#ifdef _LP64
-static __inline__ unsigned int HandleID(unsigned long lhandle,
-                                        drm_device_t *dev)
+static int drm_map_handle(drm_device_t *dev, drm_hash_item_t *hash,
+                          unsigned long user_token, int hashed_handle)
 {
-        static unsigned int map32_handle = START_RANGE;
-        unsigned int hash;
-
-        if (lhandle & 0xffffffff00000000) {
-                hash = map32_handle;
-                map32_handle += PAGE_SIZE;
-                if (map32_handle > END_RANGE)
-                        map32_handle = START_RANGE;
-        } else
-                hash = lhandle;
-
-        while (1) {
-                drm_map_list_t *_entry;
-                list_for_each_entry(_entry, &dev->maplist->head, head) {
-                        if (_entry->user_token == hash)
-                                break;
-                }
-                if (&_entry->head == &dev->maplist->head)
-                        return hash;
+        int use_hashed_handle;
+#if (BITS_PER_LONG == 64)
+        use_hashed_handle = ((user_token & 0xFFFFFFFF00000000UL) || hashed_handle);
+#elif (BITS_PER_LONG == 32)
+        use_hashed_handle = hashed_handle;
+#else
+#error Unsupported long size. Neither 64 nor 32 bits.
+#endif
 
-                hash += PAGE_SIZE;
-                map32_handle += PAGE_SIZE;
+        if (!use_hashed_handle) {
+                int ret;
+                hash->key = user_token;
+                ret = drm_ht_insert_item(&dev->map_hash, hash);
+                if (ret != -EINVAL)
+                        return ret;
         }
+        return drm_ht_just_insert_please(&dev->map_hash, hash,
+                                         user_token, 32 - PAGE_SHIFT - 3,
+                                         PAGE_SHIFT, DRM_MAP_HASH_OFFSET);
 }
-#else
-# define HandleID(x,dev) (unsigned int)(x)
-#endif
 
 /**
  * Ioctl to specify a range of memory that is available for mapping by a non-root process.
@@ -123,6 +109,8 @@ static int drm_addmap_core(drm_device_t * dev, unsigned int offset,
         drm_map_t *map;
         drm_map_list_t *list;
         drm_dma_handle_t *dmah;
+        unsigned long user_token;
+        int ret;
 
         map = drm_alloc(sizeof(*map), DRM_MEM_MAPS);
         if (!map)
@@ -249,6 +237,8 @@ static int drm_addmap_core(drm_device_t * dev, unsigned int offset,
 
         list = drm_alloc(sizeof(*list), DRM_MEM_MAPS);
         if (!list) {
+                if (map->type == _DRM_REGISTERS)
+                        drm_ioremapfree(map->handle, map->size, dev);
                 drm_free(map, sizeof(*map), DRM_MEM_MAPS);
                 return -EINVAL;
         }
@@ -257,11 +247,22 @@ static int drm_addmap_core(drm_device_t * dev, unsigned int offset,
 
         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_mutex protects the increment */
-        list->user_token = HandleID(map->type == _DRM_SHM
-                                    ? (unsigned long)map->handle
-                                    : map->offset, dev);
+        user_token = (map->type == _DRM_SHM) ? (unsigned long)map->handle :
+                map->offset;
+        ret = drm_map_handle(dev, &list->hash, user_token, 0);
+        if (ret) {
+                if (map->type == _DRM_REGISTERS)
+                        drm_ioremapfree(map->handle, map->size, dev);
+                drm_free(map, sizeof(*map), DRM_MEM_MAPS);
+                drm_free(list, sizeof(*list), DRM_MEM_MAPS);
+                mutex_unlock(&dev->struct_mutex);
+                return ret;
+        }
+
+        list->user_token = list->hash.key;
         mutex_unlock(&dev->struct_mutex);
 
         *maplist = list;
@@ -346,6 +347,7 @@ int drm_rmmap_locked(drm_device_t *dev, drm_local_map_t *map)
 
                 if (r_list->map == map) {
                         list_del(list);
+                        drm_ht_remove_key(&dev->map_hash, r_list->user_token);
                         drm_free(list, sizeof(*list), DRM_MEM_MAPS);
                         break;
                 }
@@ -441,8 +443,10 @@ int drm_rmmap_ioctl(struct inode *inode, struct file *filp,
                 return -EINVAL;
         }
 
-        if (!map)
+        if (!map) {
+                mutex_unlock(&dev->struct_mutex);
                 return -EINVAL;
+        }
 
         /* Register and framebuffer maps are permanent */
         if ((map->type == _DRM_REGISTERS) || (map->type == _DRM_FRAME_BUFFER)) {
@@ -883,6 +887,9 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
         request->count = entry->buf_count;
         request->size = size;
 
+        if (request->flags & _DRM_PCI_BUFFER_RO)
+                dma->flags = _DRM_DMA_USE_PCI_RO;
+
         atomic_dec(&dev->buf_alloc);
         return 0;
 
@@ -1467,9 +1474,10 @@ int drm_freebufs(struct inode *inode, struct file *filp,
  * \param arg pointer to a drm_buf_map structure.
  * \return zero on success or a negative number on failure.
  *
- * Maps the AGP or SG buffer region with do_mmap(), and copies information
- * about each buffer into user space. The PCI buffers are already mapped on the
- * addbufs_pci() call.
+ * Maps the AGP, SG or PCI buffer region with do_mmap(), and copies information
+ * about each buffer into user space. For PCI buffers, it calls do_mmap() with
+ * offset equal to 0, which drm_mmap() interpretes as PCI buffers and calls
+ * drm_mmap_dma().
  */
 int drm_mapbufs(struct inode *inode, struct file *filp,
                 unsigned int cmd, unsigned long arg)
diff --git a/drivers/char/drm/drm_core.h b/drivers/char/drm/drm_core.h
index f4f9db6c7ed4..316739036079 100644
--- a/drivers/char/drm/drm_core.h
+++ b/drivers/char/drm/drm_core.h
@@ -24,11 +24,11 @@
 
 #define CORE_NAME               "drm"
 #define CORE_DESC               "DRM shared core routines"
-#define CORE_DATE               "20051102"
+#define CORE_DATE               "20060810"
 
 #define DRM_IF_MAJOR    1
-#define DRM_IF_MINOR    2
+#define DRM_IF_MINOR    3
 
 #define CORE_MAJOR      1
-#define CORE_MINOR      0
-#define CORE_PATCHLEVEL 1
+#define CORE_MINOR      1
+#define CORE_PATCHLEVEL 0
diff --git a/drivers/char/drm/drm_drawable.c b/drivers/char/drm/drm_drawable.c
index 7857453c4f48..de37d5f74563 100644
--- a/drivers/char/drm/drm_drawable.c
+++ b/drivers/char/drm/drm_drawable.c
@@ -4,6 +4,7 @@
  *
  * \author Rickard E. (Rik) Faith <faith@valinux.com>
  * \author Gareth Hughes <gareth@valinux.com>
+ * \author Michel Dänzer <michel@tungstengraphics.com>
  */
 
 /*
@@ -11,6 +12,7 @@
  *
  * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
  * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
+ * Copyright 2006 Tungsten Graphics, Inc., Bismarck, North Dakota.
  * All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
@@ -35,22 +37,294 @@
 
 #include "drmP.h"
 
-/** No-op. */
-int drm_adddraw(struct inode *inode, struct file *filp,
-                unsigned int cmd, unsigned long arg)
+/**
+ * Allocate drawable ID and memory to store information about it.
+ */
+int drm_adddraw(DRM_IOCTL_ARGS)
 {
+        DRM_DEVICE;
+        unsigned long irqflags;
+        int i, j;
+        u32 *bitfield = dev->drw_bitfield;
+        unsigned int bitfield_length = dev->drw_bitfield_length;
+        drm_drawable_info_t **info = dev->drw_info;
+        unsigned int info_length = dev->drw_info_length;
         drm_draw_t draw;
 
-        draw.handle = 0;        /* NOOP */
+        for (i = 0, j = 0; i < bitfield_length; i++) {
+                if (bitfield[i] == ~0)
+                        continue;
+
+                for (; j < 8 * sizeof(*bitfield); j++)
+                        if (!(bitfield[i] & (1 << j)))
+                                goto done;
+        }
+done:
+
+        if (i == bitfield_length) {
+                bitfield_length++;
+
+                bitfield = drm_alloc(bitfield_length * sizeof(*bitfield),
+                                     DRM_MEM_BUFS);
+
+                if (!bitfield) {
+                        DRM_ERROR("Failed to allocate new drawable bitfield\n");
+                        return DRM_ERR(ENOMEM);
+                }
+
+                if (8 * sizeof(*bitfield) * bitfield_length > info_length) {
+                        info_length += 8 * sizeof(*bitfield);
+
+                        info = drm_alloc(info_length * sizeof(*info),
+                                         DRM_MEM_BUFS);
+
+                        if (!info) {
+                                DRM_ERROR("Failed to allocate new drawable info"
+                                          " array\n");
+
+                                drm_free(bitfield,
+                                         bitfield_length * sizeof(*bitfield),
+                                         DRM_MEM_BUFS);
+                                return DRM_ERR(ENOMEM);
+                        }
+                }
+
+                bitfield[i] = 0;
+        }
+
+        draw.handle = i * 8 * sizeof(*bitfield) + j + 1;
         DRM_DEBUG("%d\n", draw.handle);
-        if (copy_to_user((drm_draw_t __user *) arg, &draw, sizeof(draw)))
-                return -EFAULT;
+
+        spin_lock_irqsave(&dev->drw_lock, irqflags);
+
+        bitfield[i] |= 1 << j;
+        info[draw.handle - 1] = NULL;
+
+        if (bitfield != dev->drw_bitfield) {
+                memcpy(bitfield, dev->drw_bitfield, dev->drw_bitfield_length *
+                       sizeof(*bitfield));
+                drm_free(dev->drw_bitfield, sizeof(*bitfield) *
+                         dev->drw_bitfield_length, DRM_MEM_BUFS);
+                dev->drw_bitfield = bitfield;
+                dev->drw_bitfield_length = bitfield_length;
+        }
+
+        if (info != dev->drw_info) {
+                memcpy(info, dev->drw_info, dev->drw_info_length *
+                       sizeof(*info));
+                drm_free(dev->drw_info, sizeof(*info) * dev->drw_info_length,
+                         DRM_MEM_BUFS);
+                dev->drw_info = info;
+                dev->drw_info_length = info_length;
+        }
+
+        spin_unlock_irqrestore(&dev->drw_lock, irqflags);
+
+        DRM_COPY_TO_USER_IOCTL((drm_draw_t __user *)data, draw, sizeof(draw));
+
         return 0;
 }
 
-/** No-op. */
-int drm_rmdraw(struct inode *inode, struct file *filp,
-               unsigned int cmd, unsigned long arg)
+/**
+ * Free drawable ID and memory to store information about it.
+ */
+int drm_rmdraw(DRM_IOCTL_ARGS)
 {
-        return 0;               /* NOOP */
+        DRM_DEVICE;
+        drm_draw_t draw;
+        int id, idx;
+        unsigned int shift;
+        unsigned long irqflags;
+        u32 *bitfield = dev->drw_bitfield;
+        unsigned int bitfield_length = dev->drw_bitfield_length;
+        drm_drawable_info_t **info = dev->drw_info;
+        unsigned int info_length = dev->drw_info_length;
+
+        DRM_COPY_FROM_USER_IOCTL(draw, (drm_draw_t __user *) data,
+                                 sizeof(draw));
+
+        id = draw.handle - 1;
+        idx = id / (8 * sizeof(*bitfield));
+        shift = id % (8 * sizeof(*bitfield));
+
+        if (idx < 0 || idx >= bitfield_length ||
+            !(bitfield[idx] & (1 << shift))) {
+                DRM_DEBUG("No such drawable %d\n", draw.handle);
+                return 0;
+        }
+
+        spin_lock_irqsave(&dev->drw_lock, irqflags);
+
+        bitfield[idx] &= ~(1 << shift);
+
+        spin_unlock_irqrestore(&dev->drw_lock, irqflags);
+
+        if (info[id]) {
+                drm_free(info[id]->rects, info[id]->num_rects *
+                         sizeof(drm_clip_rect_t), DRM_MEM_BUFS);
+                drm_free(info[id], sizeof(**info), DRM_MEM_BUFS);
+        }
+
+        /* Can we shrink the arrays? */
+        if (idx == bitfield_length - 1) {
+                while (idx >= 0 && !bitfield[idx])
+                        --idx;
+
+                bitfield_length = idx + 1;
+
+                if (idx != id / (8 * sizeof(*bitfield)))
+                        bitfield = drm_alloc(bitfield_length *
+                                             sizeof(*bitfield), DRM_MEM_BUFS);
+
+                if (!bitfield && bitfield_length) {
+                        bitfield = dev->drw_bitfield;
+                        bitfield_length = dev->drw_bitfield_length;
+                }
+        }
+
+        if (bitfield != dev->drw_bitfield) {
+                info_length = 8 * sizeof(*bitfield) * bitfield_length;
+
+                info = drm_alloc(info_length * sizeof(*info), DRM_MEM_BUFS);
+
+                if (!info && info_length) {
+                        info = dev->drw_info;
+                        info_length = dev->drw_info_length;
+                }
+
+                spin_lock_irqsave(&dev->drw_lock, irqflags);
+
+                memcpy(bitfield, dev->drw_bitfield, bitfield_length *
+                       sizeof(*bitfield));
+                drm_free(dev->drw_bitfield, sizeof(*bitfield) *
+                         dev->drw_bitfield_length, DRM_MEM_BUFS);
+                dev->drw_bitfield = bitfield;
+                dev->drw_bitfield_length = bitfield_length;
+
+                if (info != dev->drw_info) {
+                        memcpy(info, dev->drw_info, info_length *
+                               sizeof(*info));
+                        drm_free(dev->drw_info, sizeof(*info) *
+                                 dev->drw_info_length, DRM_MEM_BUFS);
+                        dev->drw_info = info;
+                        dev->drw_info_length = info_length;
+                }
+
+                spin_unlock_irqrestore(&dev->drw_lock, irqflags);
+        }
+
+        DRM_DEBUG("%d\n", draw.handle);
+        return 0;
+}
+
+int drm_update_drawable_info(DRM_IOCTL_ARGS) {
+        DRM_DEVICE;
+        drm_update_draw_t update;
+        unsigned int id, idx, shift;
+        u32 *bitfield = dev->drw_bitfield;
+        unsigned long irqflags, bitfield_length = dev->drw_bitfield_length;
+        drm_drawable_info_t *info;
+        drm_clip_rect_t *rects;
+        int err;
+
+        DRM_COPY_FROM_USER_IOCTL(update, (drm_update_draw_t __user *) data,
+                                 sizeof(update));
+
+        id = update.handle - 1;
+        idx = id / (8 * sizeof(*bitfield));
+        shift = id % (8 * sizeof(*bitfield));
+
+        if (idx < 0 || idx >= bitfield_length ||
+            !(bitfield[idx] & (1 << shift))) {
+                DRM_ERROR("No such drawable %d\n", update.handle);
+                return DRM_ERR(EINVAL);
+        }
+
+        info = dev->drw_info[id];
+
+        if (!info) {
+                info = drm_calloc(1, sizeof(drm_drawable_info_t), DRM_MEM_BUFS);
+
+                if (!info) {
+                        DRM_ERROR("Failed to allocate drawable info memory\n");
+                        return DRM_ERR(ENOMEM);
+                }
+        }
+
+        switch (update.type) {
+        case DRM_DRAWABLE_CLIPRECTS:
+                if (update.num != info->num_rects) {
+                        rects = drm_alloc(update.num * sizeof(drm_clip_rect_t),
+                                         DRM_MEM_BUFS);
+                } else
+                        rects = info->rects;
+
+                if (update.num && !rects) {
+                        DRM_ERROR("Failed to allocate cliprect memory\n");
+                        err = DRM_ERR(ENOMEM);
+                        goto error;
+                }
+
+                if (update.num && DRM_COPY_FROM_USER(rects,
+                                                     (drm_clip_rect_t __user *)
+                                                     (unsigned long)update.data,
+                                                     update.num *
+                                                     sizeof(*rects))) {
+                        DRM_ERROR("Failed to copy cliprects from userspace\n");
+                        err = DRM_ERR(EFAULT);
+                        goto error;
+                }
+
+                spin_lock_irqsave(&dev->drw_lock, irqflags);
+
+                if (rects != info->rects) {
+                        drm_free(info->rects, info->num_rects *
+                                 sizeof(drm_clip_rect_t), DRM_MEM_BUFS);
+                }
+
+                info->rects = rects;
+                info->num_rects = update.num;
+                dev->drw_info[id] = info;
+
+                spin_unlock_irqrestore(&dev->drw_lock, irqflags);
+
+                DRM_DEBUG("Updated %d cliprects for drawable %d\n",
+                          info->num_rects, id);
+                break;
+        default:
+                DRM_ERROR("Invalid update type %d\n", update.type);
+                return DRM_ERR(EINVAL);
+        }
+
+        return 0;
+
+error:
+        if (!dev->drw_info[id])
+                drm_free(info, sizeof(*info), DRM_MEM_BUFS);
+        else if (rects != dev->drw_info[id]->rects)
+                drm_free(rects, update.num *
+                         sizeof(drm_clip_rect_t), DRM_MEM_BUFS);
+
+        return err;
+}
+
+/**
+ * Caller must hold the drawable spinlock!
+ */
+drm_drawable_info_t *drm_get_drawable_info(drm_device_t *dev, drm_drawable_t id) {
+        u32 *bitfield = dev->drw_bitfield;
+        unsigned int idx, shift;
+
+        id--;
+        idx = id / (8 * sizeof(*bitfield));
+        shift = id % (8 * sizeof(*bitfield));
+
+        if (idx < 0 || idx >= dev->drw_bitfield_length ||
+            !(bitfield[idx] & (1 << shift))) {
+                DRM_DEBUG("No such drawable %d\n", id);
+                return NULL;
+        }
+
+        return dev->drw_info[id];
 }
+EXPORT_SYMBOL(drm_get_drawable_info);
diff --git a/drivers/char/drm/drm_drv.c b/drivers/char/drm/drm_drv.c
index 3c0b882a8e72..a70af0de4453 100644
--- a/drivers/char/drm/drm_drv.c
+++ b/drivers/char/drm/drm_drv.c
@@ -116,9 +116,11 @@ static drm_ioctl_desc_t drm_ioctls[] = {
         [DRM_IOCTL_NR(DRM_IOCTL_SG_FREE)] = {drm_sg_free, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
 
         [DRM_IOCTL_NR(DRM_IOCTL_WAIT_VBLANK)] = {drm_wait_vblank, 0},
+
+        [DRM_IOCTL_NR(DRM_IOCTL_UPDATE_DRAW)] = {drm_update_drawable_info, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
 };
 
-#define DRIVER_IOCTL_COUNT      DRM_ARRAY_SIZE( drm_ioctls )
+#define DRIVER_IOCTL_COUNT      ARRAY_SIZE( drm_ioctls )
 
 /**
  * Take down the DRM device.
@@ -151,16 +153,29 @@ int drm_lastclose(drm_device_t * dev)
         if (dev->irq_enabled)
                 drm_irq_uninstall(dev);
 
+        /* Free drawable information memory */
+        for (i = 0; i < dev->drw_bitfield_length / sizeof(*dev->drw_bitfield);
+             i++) {
+                drm_drawable_info_t *info = drm_get_drawable_info(dev, i);
+
+                if (info) {
+                        drm_free(info->rects, info->num_rects *
+                                 sizeof(drm_clip_rect_t), DRM_MEM_BUFS);
+                        drm_free(info, sizeof(*info), DRM_MEM_BUFS);
+                }
+        }
+
         mutex_lock(&dev->struct_mutex);
         del_timer(&dev->timer);
 
         /* Clear pid list */
-        for (i = 0; i < DRM_HASH_SIZE; i++) {
-                for (pt = dev->magiclist[i].head; pt; pt = next) {
-                        next = pt->next;
+        if (dev->magicfree.next) {
+                list_for_each_entry_safe(pt, next, &dev->magicfree, head) {
+                        list_del(&pt->head);
+                        drm_ht_remove_item(&dev->magiclist, &pt->hash_item);
                         drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC);
                 }
-                dev->magiclist[i].head = dev->magiclist[i].tail = NULL;
+                drm_ht_remove(&dev->magiclist);
         }
 
         /* Clear AGP information */
@@ -299,6 +314,7 @@ static void drm_cleanup(drm_device_t * dev)
         if (dev->maplist) {
                 drm_free(dev->maplist, sizeof(*dev->maplist), DRM_MEM_MAPS);
                 dev->maplist = NULL;
+                drm_ht_remove(&dev->map_hash);
         }
 
         drm_ctxbitmap_cleanup(dev);
diff --git a/drivers/char/drm/drm_fops.c b/drivers/char/drm/drm_fops.c
index b7f7951c4587..898f47dafec0 100644
--- a/drivers/char/drm/drm_fops.c
+++ b/drivers/char/drm/drm_fops.c
@@ -53,6 +53,8 @@ static int drm_setup(drm_device_t * dev)
                         return ret;
         }
 
+        dev->magicfree.next = NULL;
+
         /* prebuild the SAREA */
         i = drm_addmap(dev, 0, SAREA_MAX, _DRM_SHM, _DRM_CONTAINS_LOCK, &map);
         if (i != 0)
@@ -69,13 +71,11 @@ static int drm_setup(drm_device_t * dev)
                         return i;
         }
 
-        for (i = 0; i < DRM_ARRAY_SIZE(dev->counts); i++)
+        for (i = 0; i < ARRAY_SIZE(dev->counts); i++)
                 atomic_set(&dev->counts[i], 0);
 
-        for (i = 0; i < DRM_HASH_SIZE; i++) {
-                dev->magiclist[i].head = NULL;
-                dev->magiclist[i].tail = NULL;
-        }
+        drm_ht_create(&dev->magiclist, DRM_MAGIC_HASH_ORDER);
+        INIT_LIST_HEAD(&dev->magicfree);
 
         dev->ctxlist = drm_alloc(sizeof(*dev->ctxlist), DRM_MEM_CTXLIST);
         if (dev->ctxlist == NULL)
diff --git a/drivers/char/drm/drm_hashtab.c b/drivers/char/drm/drm_hashtab.c
new file mode 100644
index 000000000000..a0b2d6802ae4
--- /dev/null
+++ b/drivers/char/drm/drm_hashtab.c
@@ -0,0 +1,190 @@
+/**************************************************************************
+ *
+ * Copyright 2006 Tungsten Graphics, Inc., Bismarck, ND. USA.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ *
+ **************************************************************************/
+/*
+ * Simple open hash tab implementation.
+ *
+ * Authors:
+ * Thomas Hellström <thomas-at-tungstengraphics-dot-com>
+ */
+
+#include "drmP.h"
+#include "drm_hashtab.h"
+#include <linux/hash.h>
+
+int drm_ht_create(drm_open_hash_t *ht, unsigned int order)
+{
+        unsigned int i;
+
+        ht->size = 1 << order;
+        ht->order = order;
+        ht->fill = 0;
+        ht->table = vmalloc(ht->size*sizeof(*ht->table));
+        if (!ht->table) {
+                DRM_ERROR("Out of memory for hash table\n");
+                return -ENOMEM;
+        }
+        for (i=0; i< ht->size; ++i) {
+                INIT_HLIST_HEAD(&ht->table[i]);
+        }
+        return 0;
+}
+
+void drm_ht_verbose_list(drm_open_hash_t *ht, unsigned long key)
+{
+        drm_hash_item_t *entry;
+        struct hlist_head *h_list;
+        struct hlist_node *list;
+        unsigned int hashed_key;
+        int count = 0;
+
+        hashed_key = hash_long(key, ht->order);
+        DRM_DEBUG("Key is 0x%08lx, Hashed key is 0x%08x\n", key, hashed_key);
+        h_list = &ht->table[hashed_key];
+        hlist_for_each(list, h_list) {
+                entry = hlist_entry(list, drm_hash_item_t, head);
+                DRM_DEBUG("count %d, key: 0x%08lx\n", count++, entry->key);
+        }
+}
+
+static struct hlist_node *drm_ht_find_key(drm_open_hash_t *ht, 
+                                          unsigned long key)
+{
+        drm_hash_item_t *entry;
+        struct hlist_head *h_list;
+        struct hlist_node *list;
+        unsigned int hashed_key;
+
+        hashed_key = hash_long(key, ht->order);
+        h_list = &ht->table[hashed_key];
+        hlist_for_each(list, h_list) {
+                entry = hlist_entry(list, drm_hash_item_t, head);
+                if (entry->key == key)
+                        return list;
+                if (entry->key > key)
+                        break;
+        }
+        return NULL;
+}
+
+
+int drm_ht_insert_item(drm_open_hash_t *ht, drm_hash_item_t *item)
+{
+        drm_hash_item_t *entry;
+        struct hlist_head *h_list;
+        struct hlist_node *list, *parent;
+        unsigned int hashed_key;
+        unsigned long key = item->key;
+
+        hashed_key = hash_long(key, ht->order);
+        h_list = &ht->table[hashed_key];
+        parent = NULL;
+        hlist_for_each(list, h_list) {
+                entry = hlist_entry(list, drm_hash_item_t, head);
+                if (entry->key == key)
+                        return -EINVAL;
+                if (entry->key > key)
+                        break;
+                parent = list;
+        }
+        if (parent) {
+                hlist_add_after(parent, &item->head);
+        } else {
+                hlist_add_head(&item->head, h_list);
+        }
+        return 0;
+}
+
+/*
+ * Just insert an item and return any "bits" bit key that hasn't been 
+ * used before.
+ */
+int drm_ht_just_insert_please(drm_open_hash_t *ht, drm_hash_item_t *item,
+                              unsigned long seed, int bits, int shift,
+                              unsigned long add)
+{
+        int ret;
+        unsigned long mask = (1 << bits) - 1;
+        unsigned long first, unshifted_key;
+
+        unshifted_key = hash_long(seed, bits);
+        first = unshifted_key;
+        do {
+                item->key = (unshifted_key << shift) + add;
+                ret = drm_ht_insert_item(ht, item);
+                if (ret)
+                        unshifted_key = (unshifted_key + 1) & mask;
+        } while(ret && (unshifted_key != first));
+
+        if (ret) {
+                DRM_ERROR("Available key bit space exhausted\n");
+                return -EINVAL;
+        }
+        return 0;
+}
+
+int drm_ht_find_item(drm_open_hash_t *ht, unsigned long key,
+                     drm_hash_item_t **item)
+{
+        struct hlist_node *list;
+
+        list = drm_ht_find_key(ht, key);
+        if (!list)
+                return -EINVAL;
+
+        *item = hlist_entry(list, drm_hash_item_t, head);
+        return 0;
+}
+
+int drm_ht_remove_key(drm_open_hash_t *ht, unsigned long key)
+{
+        struct hlist_node *list;
+
+        list = drm_ht_find_key(ht, key);
+        if (list) {
+                hlist_del_init(list);
+                ht->fill--;
+                return 0;
+        }
+        return -EINVAL;
+}
+
+int drm_ht_remove_item(drm_open_hash_t *ht, drm_hash_item_t *item)
+{
+        hlist_del_init(&item->head);
+        ht->fill--;
+        return 0;
+}
+
+void drm_ht_remove(drm_open_hash_t *ht)
+{
+        if (ht->table) {
+                vfree(ht->table);
+                ht->table = NULL;
+        }
+}
+
diff --git a/drivers/char/drm/drm_hashtab.h b/drivers/char/drm/drm_hashtab.h
new file mode 100644
index 000000000000..40afec05bff8
--- /dev/null
+++ b/drivers/char/drm/drm_hashtab.h
@@ -0,0 +1,67 @@
+/**************************************************************************
+ *
+ * Copyright 2006 Tungsten Graphics, Inc., Bismack, ND. USA.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ *
+ **************************************************************************/
+/*
+ * Simple open hash tab implementation.
+ *
+ * Authors:
+ * Thomas Hellström <thomas-at-tungstengraphics-dot-com>
+ */
+
+#ifndef DRM_HASHTAB_H
+#define DRM_HASHTAB_H
+
+#define drm_hash_entry(_ptr, _type, _member) container_of(_ptr, _type, _member)
+
+typedef struct drm_hash_item{
+        struct hlist_node head;
+        unsigned long key;
+} drm_hash_item_t;
+
+typedef struct drm_open_hash{
+        unsigned int size;
+        unsigned int order;
+        unsigned int fill;
+        struct hlist_head *table;
+} drm_open_hash_t;
+
+
+extern int drm_ht_create(drm_open_hash_t *ht, unsigned int order);
+extern int drm_ht_insert_item(drm_open_hash_t *ht, drm_hash_item_t *item);
+extern int drm_ht_just_insert_please(drm_open_hash_t *ht, drm_hash_item_t *item,
+                                     unsigned long seed, int bits, int shift,
+                                     unsigned long add);
+extern int drm_ht_find_item(drm_open_hash_t *ht, unsigned long key, drm_hash_item_t **item);
+
+extern void drm_ht_verbose_list(drm_open_hash_t *ht, unsigned long key);
+extern int drm_ht_remove_key(drm_open_hash_t *ht, unsigned long key);
+extern int drm_ht_remove_item(drm_open_hash_t *ht, drm_hash_item_t *item);
+extern void drm_ht_remove(drm_open_hash_t *ht);
+
+
+#endif
+
diff --git a/drivers/char/drm/drm_ioc32.c b/drivers/char/drm/drm_ioc32.c
index e9e2db18952d..fafeb34f89d5 100644
--- a/drivers/char/drm/drm_ioc32.c
+++ b/drivers/char/drm/drm_ioc32.c
@@ -102,7 +102,7 @@ static int compat_drm_version(struct file *file, unsigned int cmd,
                           &version->desc))
                 return -EFAULT;
 
-        err = drm_ioctl(file->f_dentry->d_inode, file,
+        err = drm_ioctl(file->f_path.dentry->d_inode, file,
                         DRM_IOCTL_VERSION, (unsigned long)version);
         if (err)
                 return err;
@@ -143,7 +143,7 @@ static int compat_drm_getunique(struct file *file, unsigned int cmd,
                           &u->unique))
                 return -EFAULT;
 
-        err = drm_ioctl(file->f_dentry->d_inode, file,
+        err = drm_ioctl(file->f_path.dentry->d_inode, file,
                         DRM_IOCTL_GET_UNIQUE, (unsigned long)u);
         if (err)
                 return err;
@@ -172,7 +172,7 @@ static int compat_drm_setunique(struct file *file, unsigned int cmd,
                           &u->unique))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_SET_UNIQUE, (unsigned long)u);
 }
 
@@ -203,7 +203,7 @@ static int compat_drm_getmap(struct file *file, unsigned int cmd,
         if (__put_user(idx, &map->offset))
                 return -EFAULT;
 
-        err = drm_ioctl(file->f_dentry->d_inode, file,
+        err = drm_ioctl(file->f_path.dentry->d_inode, file,
                         DRM_IOCTL_GET_MAP, (unsigned long)map);
         if (err)
                 return err;
@@ -244,7 +244,7 @@ static int compat_drm_addmap(struct file *file, unsigned int cmd,
             || __put_user(m32.flags, &map->flags))
                 return -EFAULT;
 
-        err = drm_ioctl(file->f_dentry->d_inode, file,
+        err = drm_ioctl(file->f_path.dentry->d_inode, file,
                         DRM_IOCTL_ADD_MAP, (unsigned long)map);
         if (err)
                 return err;
@@ -282,7 +282,7 @@ static int compat_drm_rmmap(struct file *file, unsigned int cmd,
         if (__put_user((void *)(unsigned long)handle, &map->handle))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_RM_MAP, (unsigned long)map);
 }
 
@@ -312,7 +312,7 @@ static int compat_drm_getclient(struct file *file, unsigned int cmd,
         if (__put_user(idx, &client->idx))
                 return -EFAULT;
 
-        err = drm_ioctl(file->f_dentry->d_inode, file,
+        err = drm_ioctl(file->f_path.dentry->d_inode, file,
                         DRM_IOCTL_GET_CLIENT, (unsigned long)client);
         if (err)
                 return err;
@@ -349,7 +349,7 @@ static int compat_drm_getstats(struct file *file, unsigned int cmd,
         if (!access_ok(VERIFY_WRITE, stats, sizeof(*stats)))
                 return -EFAULT;
 
-        err = drm_ioctl(file->f_dentry->d_inode, file,
+        err = drm_ioctl(file->f_path.dentry->d_inode, file,
                         DRM_IOCTL_GET_STATS, (unsigned long)stats);
         if (err)
                 return err;
@@ -393,7 +393,7 @@ static int compat_drm_addbufs(struct file *file, unsigned int cmd,
             || __put_user(agp_start, &buf->agp_start))
                 return -EFAULT;
 
-        err = drm_ioctl(file->f_dentry->d_inode, file,
+        err = drm_ioctl(file->f_path.dentry->d_inode, file,
                         DRM_IOCTL_ADD_BUFS, (unsigned long)buf);
         if (err)
                 return err;
@@ -425,7 +425,7 @@ static int compat_drm_markbufs(struct file *file, unsigned int cmd,
             || __put_user(b32.high_mark, &buf->high_mark))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_MARK_BUFS, (unsigned long)buf);
 }
 
@@ -467,7 +467,7 @@ static int compat_drm_infobufs(struct file *file, unsigned int cmd,
             || __put_user(list, &request->list))
                 return -EFAULT;
 
-        err = drm_ioctl(file->f_dentry->d_inode, file,
+        err = drm_ioctl(file->f_path.dentry->d_inode, file,
                         DRM_IOCTL_INFO_BUFS, (unsigned long)request);
         if (err)
                 return err;
@@ -529,7 +529,7 @@ static int compat_drm_mapbufs(struct file *file, unsigned int cmd,
             || __put_user(list, &request->list))
                 return -EFAULT;
 
-        err = drm_ioctl(file->f_dentry->d_inode, file,
+        err = drm_ioctl(file->f_path.dentry->d_inode, file,
                         DRM_IOCTL_MAP_BUFS, (unsigned long)request);
         if (err)
                 return err;
@@ -576,7 +576,7 @@ static int compat_drm_freebufs(struct file *file, unsigned int cmd,
                           &request->list))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_FREE_BUFS, (unsigned long)request);
 }
 
@@ -603,7 +603,7 @@ static int compat_drm_setsareactx(struct file *file, unsigned int cmd,
                           &request->handle))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_SET_SAREA_CTX, (unsigned long)request);
 }
 
@@ -626,7 +626,7 @@ static int compat_drm_getsareactx(struct file *file, unsigned int cmd,
         if (__put_user(ctx_id, &request->ctx_id))
                 return -EFAULT;
 
-        err = drm_ioctl(file->f_dentry->d_inode, file,
+        err = drm_ioctl(file->f_path.dentry->d_inode, file,
                         DRM_IOCTL_GET_SAREA_CTX, (unsigned long)request);
         if (err)
                 return err;
@@ -662,7 +662,7 @@ static int compat_drm_resctx(struct file *file, unsigned int cmd,
                           &res->contexts))
                 return -EFAULT;
 
-        err = drm_ioctl(file->f_dentry->d_inode, file,
+        err = drm_ioctl(file->f_path.dentry->d_inode, file,
                         DRM_IOCTL_RES_CTX, (unsigned long)res);
         if (err)
                 return err;
@@ -716,7 +716,7 @@ static int compat_drm_dma(struct file *file, unsigned int cmd,
                           &d->request_sizes))
                 return -EFAULT;
 
-        err = drm_ioctl(file->f_dentry->d_inode, file,
+        err = drm_ioctl(file->f_path.dentry->d_inode, file,
                         DRM_IOCTL_DMA, (unsigned long)d);
         if (err)
                 return err;
@@ -749,7 +749,7 @@ static int compat_drm_agp_enable(struct file *file, unsigned int cmd,
         if (put_user(m32.mode, &mode->mode))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_AGP_ENABLE, (unsigned long)mode);
 }
 
@@ -779,7 +779,7 @@ static int compat_drm_agp_info(struct file *file, unsigned int cmd,
         if (!access_ok(VERIFY_WRITE, info, sizeof(*info)))
                 return -EFAULT;
 
-        err = drm_ioctl(file->f_dentry->d_inode, file,
+        err = drm_ioctl(file->f_path.dentry->d_inode, file,
                         DRM_IOCTL_AGP_INFO, (unsigned long)info);
         if (err)
                 return err;
@@ -825,7 +825,7 @@ static int compat_drm_agp_alloc(struct file *file, unsigned int cmd,
             || __put_user(req32.type, &request->type))
                 return -EFAULT;
 
-        err = drm_ioctl(file->f_dentry->d_inode, file,
+        err = drm_ioctl(file->f_path.dentry->d_inode, file,
                         DRM_IOCTL_AGP_ALLOC, (unsigned long)request);
         if (err)
                 return err;
@@ -833,7 +833,7 @@ static int compat_drm_agp_alloc(struct file *file, unsigned int cmd,
         if (__get_user(req32.handle, &request->handle)
             || __get_user(req32.physical, &request->physical)
             || copy_to_user(argp, &req32, sizeof(req32))) {
-                drm_ioctl(file->f_dentry->d_inode, file,
+                drm_ioctl(file->f_path.dentry->d_inode, file,
                           DRM_IOCTL_AGP_FREE, (unsigned long)request);
                 return -EFAULT;
         }
@@ -854,7 +854,7 @@ static int compat_drm_agp_free(struct file *file, unsigned int cmd,
             || __put_user(handle, &request->handle))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_AGP_FREE, (unsigned long)request);
 }
 
@@ -879,7 +879,7 @@ static int compat_drm_agp_bind(struct file *file, unsigned int cmd,
             || __put_user(req32.offset, &request->offset))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_AGP_BIND, (unsigned long)request);
 }
 
@@ -896,7 +896,7 @@ static int compat_drm_agp_unbind(struct file *file, unsigned int cmd,
             || __put_user(handle, &request->handle))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_AGP_UNBIND, (unsigned long)request);
 }
 #endif                          /* __OS_HAS_AGP */
@@ -921,7 +921,7 @@ static int compat_drm_sg_alloc(struct file *file, unsigned int cmd,
             || __put_user(x, &request->size))
                 return -EFAULT;
 
-        err = drm_ioctl(file->f_dentry->d_inode, file,
+        err = drm_ioctl(file->f_path.dentry->d_inode, file,
                         DRM_IOCTL_SG_ALLOC, (unsigned long)request);
         if (err)
                 return err;
@@ -948,7 +948,7 @@ static int compat_drm_sg_free(struct file *file, unsigned int cmd,
             || __put_user(x << PAGE_SHIFT, &request->handle))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_SG_FREE, (unsigned long)request);
 }
 
@@ -988,7 +988,7 @@ static int compat_drm_wait_vblank(struct file *file, unsigned int cmd,
             || __put_user(req32.request.signal, &request->request.signal))
                 return -EFAULT;
 
-        err = drm_ioctl(file->f_dentry->d_inode, file,
+        err = drm_ioctl(file->f_path.dentry->d_inode, file,
                         DRM_IOCTL_WAIT_VBLANK, (unsigned long)request);
         if (err)
                 return err;
@@ -1051,7 +1051,7 @@ long drm_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
         drm_ioctl_compat_t *fn;
         int ret;
 
-        if (nr >= DRM_ARRAY_SIZE(drm_compat_ioctls))
+        if (nr >= ARRAY_SIZE(drm_compat_ioctls))
                 return -ENOTTY;
 
         fn = drm_compat_ioctls[nr];
@@ -1060,7 +1060,7 @@ long drm_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
         if (fn != NULL)
                 ret = (*fn) (filp, cmd, arg);
         else
-                ret = drm_ioctl(filp->f_dentry->d_inode, filp, cmd, arg);
+                ret = drm_ioctl(filp->f_path.dentry->d_inode, filp, cmd, arg);
         unlock_kernel();
 
         return ret;
diff --git a/drivers/char/drm/drm_ioctl.c b/drivers/char/drm/drm_ioctl.c
index 555f323b8a32..565895547d75 100644
--- a/drivers/char/drm/drm_ioctl.c
+++ b/drivers/char/drm/drm_ioctl.c
@@ -127,9 +127,10 @@ int drm_setunique(struct inode *inode, struct file *filp,
         domain = bus >> 8;
         bus &= 0xff;
 
-        if ((domain != dev->pci_domain) ||
-            (bus != dev->pci_bus) ||
-            (slot != dev->pci_slot) || (func != dev->pci_func))
+        if ((domain != drm_get_pci_domain(dev)) ||
+            (bus != dev->pdev->bus->number) ||
+            (slot != PCI_SLOT(dev->pdev->devfn)) ||
+            (func != PCI_FUNC(dev->pdev->devfn)))
                 return -EINVAL;
 
         return 0;
@@ -140,15 +141,17 @@ static int drm_set_busid(drm_device_t * dev)
         int len;
 
         if (dev->unique != NULL)
-                return EBUSY;
+                return 0;
 
         dev->unique_len = 40;
         dev->unique = drm_alloc(dev->unique_len + 1, DRM_MEM_DRIVER);
         if (dev->unique == NULL)
-                return ENOMEM;
+                return -ENOMEM;
 
         len = snprintf(dev->unique, dev->unique_len, "pci:%04x:%02x:%02x.%d",
-                 dev->pci_domain, dev->pci_bus, dev->pci_slot, dev->pci_func);
+                       drm_get_pci_domain(dev), dev->pdev->bus->number,
+                       PCI_SLOT(dev->pdev->devfn),
+                       PCI_FUNC(dev->pdev->devfn));
 
         if (len > dev->unique_len)
                 DRM_ERROR("Unique buffer overflowed\n");
@@ -157,7 +160,7 @@ static int drm_set_busid(drm_device_t * dev)
             drm_alloc(strlen(dev->driver->pci_driver.name) + dev->unique_len +
                       2, DRM_MEM_DRIVER);
         if (dev->devname == NULL)
-                return ENOMEM;
+                return -ENOMEM;
 
         sprintf(dev->devname, "%s@%s", dev->driver->pci_driver.name,
                 dev->unique);
@@ -330,27 +333,32 @@ int drm_setversion(DRM_IOCTL_ARGS)
         drm_set_version_t retv;
         int if_version;
         drm_set_version_t __user *argp = (void __user *)data;
+        int ret;
 
-        DRM_COPY_FROM_USER_IOCTL(sv, argp, sizeof(sv));
+        if (copy_from_user(&sv, argp, sizeof(sv)))
+                return -EFAULT;
 
         retv.drm_di_major = DRM_IF_MAJOR;
         retv.drm_di_minor = DRM_IF_MINOR;
         retv.drm_dd_major = dev->driver->major;
         retv.drm_dd_minor = dev->driver->minor;
 
-        DRM_COPY_TO_USER_IOCTL(argp, retv, sizeof(sv));
+        if (copy_to_user(argp, &retv, sizeof(retv)))
+                return -EFAULT;
 
         if (sv.drm_di_major != -1) {
                 if (sv.drm_di_major != DRM_IF_MAJOR ||
                     sv.drm_di_minor < 0 || sv.drm_di_minor > DRM_IF_MINOR)
-                        return EINVAL;
+                        return -EINVAL;
                 if_version = DRM_IF_VERSION(sv.drm_di_major, sv.drm_di_minor);
-                dev->if_version = DRM_MAX(if_version, dev->if_version);
+                dev->if_version = max(if_version, dev->if_version);
                 if (sv.drm_di_minor >= 1) {
                         /*
                          * Version 1.1 includes tying of DRM to specific device
                          */
-                        drm_set_busid(dev);
+                        ret = drm_set_busid(dev);
+                        if (ret)
+                                return ret;
                 }
         }
 
@@ -358,7 +366,7 @@ int drm_setversion(DRM_IOCTL_ARGS)
                 if (sv.drm_dd_major != dev->driver->major ||
                     sv.drm_dd_minor < 0
                     || sv.drm_dd_minor > dev->driver->minor)
-                        return EINVAL;
+                        return -EINVAL;
 
                 if (dev->driver->set_version)
                         dev->driver->set_version(dev, &sv);
diff --git a/drivers/char/drm/drm_irq.c b/drivers/char/drm/drm_irq.c
index ebdb7182c4fd..9d00c51fe2c4 100644
--- a/drivers/char/drm/drm_irq.c
+++ b/drivers/char/drm/drm_irq.c
@@ -64,9 +64,9 @@ int drm_irq_by_busid(struct inode *inode, struct file *filp,
         if (copy_from_user(&p, argp, sizeof(p)))
                 return -EFAULT;
 
-        if ((p.busnum >> 8) != dev->pci_domain ||
-            (p.busnum & 0xff) != dev->pci_bus ||
-            p.devnum != dev->pci_slot || p.funcnum != dev->pci_func)
+        if ((p.busnum >> 8) != drm_get_pci_domain(dev) ||
+            (p.busnum & 0xff) != dev->pdev->bus->number ||
+            p.devnum != PCI_SLOT(dev->pdev->devfn) || p.funcnum != PCI_FUNC(dev->pdev->devfn))
                 return -EINVAL;
 
         p.irq = dev->irq;
@@ -121,6 +121,7 @@ static int drm_irq_install(drm_device_t * dev)
                 spin_lock_init(&dev->vbl_lock);
 
                 INIT_LIST_HEAD(&dev->vbl_sigs.head);
+                INIT_LIST_HEAD(&dev->vbl_sigs2.head);
 
                 dev->vbl_pending = 0;
         }
@@ -175,6 +176,8 @@ int drm_irq_uninstall(drm_device_t * dev)
 
         free_irq(dev->irq, dev);
 
+        dev->locked_tasklet_func = NULL;
+
         return 0;
 }
 
@@ -247,19 +250,34 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
         drm_wait_vblank_t vblwait;
         struct timeval now;
         int ret = 0;
-        unsigned int flags;
+        unsigned int flags, seq;
 
-        if (!drm_core_check_feature(dev, DRIVER_IRQ_VBL))
+        if (!dev->irq)
                 return -EINVAL;
 
-        if (!dev->irq)
+        if (copy_from_user(&vblwait, argp, sizeof(vblwait)))
+                return -EFAULT;
+
+        if (vblwait.request.type &
+            ~(_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK)) {
+                DRM_ERROR("Unsupported type value 0x%x, supported mask 0x%x\n",
+                          vblwait.request.type,
+                          (_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK));
                 return -EINVAL;
+        }
 
-        DRM_COPY_FROM_USER_IOCTL(vblwait, argp, sizeof(vblwait));
+        flags = vblwait.request.type & _DRM_VBLANK_FLAGS_MASK;
 
-        switch (vblwait.request.type & ~_DRM_VBLANK_FLAGS_MASK) {
+        if (!drm_core_check_feature(dev, (flags & _DRM_VBLANK_SECONDARY) ?
+                                    DRIVER_IRQ_VBL2 : DRIVER_IRQ_VBL))
+                return -EINVAL;
+
+        seq = atomic_read((flags & _DRM_VBLANK_SECONDARY) ? &dev->vbl_received2
+                          : &dev->vbl_received);
+
+        switch (vblwait.request.type & _DRM_VBLANK_TYPES_MASK) {
         case _DRM_VBLANK_RELATIVE:
-                vblwait.request.sequence += atomic_read(&dev->vbl_received);
+                vblwait.request.sequence += seq;
                 vblwait.request.type &= ~_DRM_VBLANK_RELATIVE;
         case _DRM_VBLANK_ABSOLUTE:
                 break;
@@ -267,26 +285,30 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
                 return -EINVAL;
         }
 
-        flags = vblwait.request.type & _DRM_VBLANK_FLAGS_MASK;
+        if ((flags & _DRM_VBLANK_NEXTONMISS) &&
+            (seq - vblwait.request.sequence) <= (1<<23)) {
+                vblwait.request.sequence = seq + 1;
+        }
 
         if (flags & _DRM_VBLANK_SIGNAL) {
                 unsigned long irqflags;
+                drm_vbl_sig_t *vbl_sigs = (flags & _DRM_VBLANK_SECONDARY)
+                                      ? &dev->vbl_sigs2 : &dev->vbl_sigs;
                 drm_vbl_sig_t *vbl_sig;
 
-                vblwait.reply.sequence = atomic_read(&dev->vbl_received);
-
                 spin_lock_irqsave(&dev->vbl_lock, irqflags);
 
                 /* Check if this task has already scheduled the same signal
                  * for the same vblank sequence number; nothing to be done in
                  * that case
                  */
-                list_for_each_entry(vbl_sig, &dev->vbl_sigs.head, head) {
+                list_for_each_entry(vbl_sig, &vbl_sigs->head, head) {
                         if (vbl_sig->sequence == vblwait.request.sequence
                             && vbl_sig->info.si_signo == vblwait.request.signal
                             && vbl_sig->task == current) {
                                 spin_unlock_irqrestore(&dev->vbl_lock,
                                                        irqflags);
+                                vblwait.reply.sequence = seq;
                                 goto done;
                         }
                 }
@@ -314,11 +336,16 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
 
                 spin_lock_irqsave(&dev->vbl_lock, irqflags);
 
-                list_add_tail((struct list_head *)vbl_sig, &dev->vbl_sigs.head);
+                list_add_tail((struct list_head *)vbl_sig, &vbl_sigs->head);
 
                 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
+
+                vblwait.reply.sequence = seq;
         } else {
-                if (dev->driver->vblank_wait)
+                if (flags & _DRM_VBLANK_SECONDARY) {
+                        if (dev->driver->vblank_wait2)
+                                ret = dev->driver->vblank_wait2(dev, &vblwait.request.sequence);
+                } else if (dev->driver->vblank_wait)
                         ret =
                             dev->driver->vblank_wait(dev,
                                                      &vblwait.request.sequence);
@@ -329,7 +356,8 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
         }
 
       done:
-        DRM_COPY_TO_USER_IOCTL(argp, vblwait, sizeof(vblwait));
+        if (copy_to_user(argp, &vblwait, sizeof(vblwait)))
+                return -EFAULT;
 
         return ret;
 }
@@ -345,25 +373,32 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
  */
 void drm_vbl_send_signals(drm_device_t * dev)
 {
-        struct list_head *list, *tmp;
-        drm_vbl_sig_t *vbl_sig;
-        unsigned int vbl_seq = atomic_read(&dev->vbl_received);
         unsigned long flags;
+        int i;
 
         spin_lock_irqsave(&dev->vbl_lock, flags);
 
-        list_for_each_safe(list, tmp, &dev->vbl_sigs.head) {
-                vbl_sig = list_entry(list, drm_vbl_sig_t, head);
-                if ((vbl_seq - vbl_sig->sequence) <= (1 << 23)) {
-                        vbl_sig->info.si_code = vbl_seq;
-                        send_sig_info(vbl_sig->info.si_signo, &vbl_sig->info,
-                                      vbl_sig->task);
+        for (i = 0; i < 2; i++) {
+                struct list_head *list, *tmp;
+                drm_vbl_sig_t *vbl_sig;
+                drm_vbl_sig_t *vbl_sigs = i ? &dev->vbl_sigs2 : &dev->vbl_sigs;
+                unsigned int vbl_seq = atomic_read(i ? &dev->vbl_received2 :
+                                                   &dev->vbl_received);
+
+                list_for_each_safe(list, tmp, &vbl_sigs->head) {
+                        vbl_sig = list_entry(list, drm_vbl_sig_t, head);
+                        if ((vbl_seq - vbl_sig->sequence) <= (1 << 23)) {
+                                vbl_sig->info.si_code = vbl_seq;
+                                send_sig_info(vbl_sig->info.si_signo,
+                                              &vbl_sig->info, vbl_sig->task);
 
-                        list_del(list);
+                                list_del(list);
 
-                        drm_free(vbl_sig, sizeof(*vbl_sig), DRM_MEM_DRIVER);
+                                drm_free(vbl_sig, sizeof(*vbl_sig),
+                                         DRM_MEM_DRIVER);
 
-                        dev->vbl_pending--;
+                                dev->vbl_pending--;
+                        }
                 }
         }
 
@@ -371,3 +406,77 @@ void drm_vbl_send_signals(drm_device_t * dev)
 }
 
 EXPORT_SYMBOL(drm_vbl_send_signals);
+
+/**
+ * Tasklet wrapper function.
+ *
+ * \param data DRM device in disguise.
+ *
+ * Attempts to grab the HW lock and calls the driver callback on success. On
+ * failure, leave the lock marked as contended so the callback can be called
+ * from drm_unlock().
+ */
+static void drm_locked_tasklet_func(unsigned long data)
+{
+        drm_device_t *dev = (drm_device_t*)data;
+        unsigned long irqflags;
+
+        spin_lock_irqsave(&dev->tasklet_lock, irqflags);
+
+        if (!dev->locked_tasklet_func ||
+            !drm_lock_take(&dev->lock.hw_lock->lock,
+                           DRM_KERNEL_CONTEXT)) {
+                spin_unlock_irqrestore(&dev->tasklet_lock, irqflags);
+                return;
+        }
+
+        dev->lock.lock_time = jiffies;
+        atomic_inc(&dev->counts[_DRM_STAT_LOCKS]);
+
+        dev->locked_tasklet_func(dev);
+
+        drm_lock_free(dev, &dev->lock.hw_lock->lock,
+                      DRM_KERNEL_CONTEXT);
+
+        dev->locked_tasklet_func = NULL;
+
+        spin_unlock_irqrestore(&dev->tasklet_lock, irqflags);
+}
+
+/**
+ * Schedule a tasklet to call back a driver hook with the HW lock held.
+ *
+ * \param dev DRM device.
+ * \param func Driver callback.
+ *
+ * This is intended for triggering actions that require the HW lock from an
+ * interrupt handler. The lock will be grabbed ASAP after the interrupt handler
+ * completes. Note that the callback may be called from interrupt or process
+ * context, it must not make any assumptions about this. Also, the HW lock will
+ * be held with the kernel context or any client context.
+ */
+void drm_locked_tasklet(drm_device_t *dev, void (*func)(drm_device_t*))
+{
+        unsigned long irqflags;
+        static DECLARE_TASKLET(drm_tasklet, drm_locked_tasklet_func, 0);
+
+        if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ) ||
+            test_bit(TASKLET_STATE_SCHED, &drm_tasklet.state))
+                return;
+
+        spin_lock_irqsave(&dev->tasklet_lock, irqflags);
+
+        if (dev->locked_tasklet_func) {
+                spin_unlock_irqrestore(&dev->tasklet_lock, irqflags);
+                return;
+        }
+
+        dev->locked_tasklet_func = func;
+
+        spin_unlock_irqrestore(&dev->tasklet_lock, irqflags);
+
+        drm_tasklet.data = (unsigned long)dev;
+
+        tasklet_hi_schedule(&drm_tasklet);
+}
+EXPORT_SYMBOL(drm_locked_tasklet);
diff --git a/drivers/char/drm/drm_lock.c b/drivers/char/drm/drm_lock.c
index f9e45303498d..116ed0f2ac09 100644
--- a/drivers/char/drm/drm_lock.c
+++ b/drivers/char/drm/drm_lock.c
@@ -155,6 +155,7 @@ int drm_unlock(struct inode *inode, struct file *filp,
         drm_file_t *priv = filp->private_data;
         drm_device_t *dev = priv->head->dev;
         drm_lock_t lock;
+        unsigned long irqflags;
 
         if (copy_from_user(&lock, (drm_lock_t __user *) arg, sizeof(lock)))
                 return -EFAULT;
@@ -165,6 +166,16 @@ int drm_unlock(struct inode *inode, struct file *filp,
                 return -EINVAL;
         }
 
+        spin_lock_irqsave(&dev->tasklet_lock, irqflags);
+
+        if (dev->locked_tasklet_func) {
+                dev->locked_tasklet_func(dev);
+
+                dev->locked_tasklet_func = NULL;
+        }
+
+        spin_unlock_irqrestore(&dev->tasklet_lock, irqflags);
+
         atomic_inc(&dev->counts[_DRM_STAT_UNLOCKS]);
 
         /* kernel_context_switch isn't used by any of the x86 drm
diff --git a/drivers/char/drm/drm_mm.c b/drivers/char/drm/drm_mm.c
new file mode 100644
index 000000000000..617526bd5b0c
--- /dev/null
+++ b/drivers/char/drm/drm_mm.c
@@ -0,0 +1,201 @@
+/**************************************************************************
+ *
+ * Copyright 2006 Tungsten Graphics, Inc., Bismarck, ND., USA.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ *
+ **************************************************************************/
+
+/*
+ * Generic simple memory manager implementation. Intended to be used as a base
+ * class implementation for more advanced memory managers.
+ *
+ * Note that the algorithm used is quite simple and there might be substantial
+ * performance gains if a smarter free list is implemented. Currently it is just an
+ * unordered stack of free regions. This could easily be improved if an RB-tree
+ * is used instead. At least if we expect heavy fragmentation.
+ *
+ * Aligned allocations can also see improvement.
+ *
+ * Authors:
+ * Thomas Hellström <thomas-at-tungstengraphics-dot-com>
+ */
+
+#include "drmP.h"
+
+drm_mm_node_t *drm_mm_get_block(drm_mm_node_t * parent,
+                                unsigned long size, unsigned alignment)
+{
+
+        drm_mm_node_t *child;
+
+        if (alignment)
+                size += alignment - 1;
+
+        if (parent->size == size) {
+                list_del_init(&parent->fl_entry);
+                parent->free = 0;
+                return parent;
+        } else {
+                child = (drm_mm_node_t *) drm_alloc(sizeof(*child), DRM_MEM_MM);
+                if (!child)
+                        return NULL;
+
+                INIT_LIST_HEAD(&child->ml_entry);
+                INIT_LIST_HEAD(&child->fl_entry);
+
+                child->free = 0;
+                child->size = size;
+                child->start = parent->start;
+
+                list_add_tail(&child->ml_entry, &parent->ml_entry);
+                parent->size -= size;
+                parent->start += size;
+        }
+        return child;
+}
+
+/*
+ * Put a block. Merge with the previous and / or next block if they are free.
+ * Otherwise add to the free stack.
+ */
+
+void drm_mm_put_block(drm_mm_t * mm, drm_mm_node_t * cur)
+{
+
+        drm_mm_node_t *list_root = &mm->root_node;
+        struct list_head *cur_head = &cur->ml_entry;
+        struct list_head *root_head = &list_root->ml_entry;
+        drm_mm_node_t *prev_node = NULL;
+        drm_mm_node_t *next_node;
+
+        int merged = 0;
+
+        if (cur_head->prev != root_head) {
+                prev_node = list_entry(cur_head->prev, drm_mm_node_t, ml_entry);
+                if (prev_node->free) {
+                        prev_node->size += cur->size;
+                        merged = 1;
+                }
+        }
+        if (cur_head->next != root_head) {
+                next_node = list_entry(cur_head->next, drm_mm_node_t, ml_entry);
+                if (next_node->free) {
+                        if (merged) {
+                                prev_node->size += next_node->size;
+                                list_del(&next_node->ml_entry);
+                                list_del(&next_node->fl_entry);
+                                drm_free(next_node, sizeof(*next_node),
+                                         DRM_MEM_MM);
+                        } else {
+                                next_node->size += cur->size;
+                                next_node->start = cur->start;
+                                merged = 1;
+                        }
+                }
+        }
+        if (!merged) {
+                cur->free = 1;
+                list_add(&cur->fl_entry, &list_root->fl_entry);
+        } else {
+                list_del(&cur->ml_entry);
+                drm_free(cur, sizeof(*cur), DRM_MEM_MM);
+        }
+}
+
+drm_mm_node_t *drm_mm_search_free(const drm_mm_t * mm,
+                                  unsigned long size,
+                                  unsigned alignment, int best_match)
+{
+        struct list_head *list;
+        const struct list_head *free_stack = &mm->root_node.fl_entry;
+        drm_mm_node_t *entry;
+        drm_mm_node_t *best;
+        unsigned long best_size;
+
+        best = NULL;
+        best_size = ~0UL;
+
+        if (alignment)
+                size += alignment - 1;
+
+        list_for_each(list, free_stack) {
+                entry = list_entry(list, drm_mm_node_t, fl_entry);
+                if (entry->size >= size) {
+                        if (!best_match)
+                                return entry;
+                        if (size < best_size) {
+                                best = entry;
+                                best_size = entry->size;
+                        }
+                }
+        }
+
+        return best;
+}
+
+int drm_mm_init(drm_mm_t * mm, unsigned long start, unsigned long size)
+{
+        drm_mm_node_t *child;
+
+        INIT_LIST_HEAD(&mm->root_node.ml_entry);
+        INIT_LIST_HEAD(&mm->root_node.fl_entry);
+        child = (drm_mm_node_t *) drm_alloc(sizeof(*child), DRM_MEM_MM);
+        if (!child)
+                return -ENOMEM;
+
+        INIT_LIST_HEAD(&child->ml_entry);
+        INIT_LIST_HEAD(&child->fl_entry);
+
+        child->start = start;
+        child->size = size;
+        child->free = 1;
+
+        list_add(&child->fl_entry, &mm->root_node.fl_entry);
+        list_add(&child->ml_entry, &mm->root_node.ml_entry);
+
+        return 0;
+}
+
+EXPORT_SYMBOL(drm_mm_init);
+
+void drm_mm_takedown(drm_mm_t * mm)
+{
+        struct list_head *bnode = mm->root_node.fl_entry.next;
+        drm_mm_node_t *entry;
+
+        entry = list_entry(bnode, drm_mm_node_t, fl_entry);
+
+        if (entry->ml_entry.next != &mm->root_node.ml_entry ||
+            entry->fl_entry.next != &mm->root_node.fl_entry) {
+                DRM_ERROR("Memory manager not clean. Delaying takedown\n");
+                return;
+        }
+
+        list_del(&entry->fl_entry);
+        list_del(&entry->ml_entry);
+
+        drm_free(entry, sizeof(*entry), DRM_MEM_MM);
+}
+
+EXPORT_SYMBOL(drm_mm_takedown);
diff --git a/drivers/char/drm/drm_os_linux.h b/drivers/char/drm/drm_os_linux.h
index 695115d70382..2908b72daa6e 100644
--- a/drivers/char/drm/drm_os_linux.h
+++ b/drivers/char/drm/drm_os_linux.h
@@ -38,7 +38,7 @@
                         drm_device_t    *dev    = priv->head->dev
 
 /** IRQ handler arguments and return type and values */
-#define DRM_IRQ_ARGS            int irq, void *arg, struct pt_regs *regs
+#define DRM_IRQ_ARGS            int irq, void *arg
 
 /** AGP types */
 #if __OS_HAS_AGP
diff --git a/drivers/char/drm/drm_pciids.h b/drivers/char/drm/drm_pciids.h
index b1bb3c7b568d..09398d5fbd3f 100644
--- a/drivers/char/drm/drm_pciids.h
+++ b/drivers/char/drm/drm_pciids.h
@@ -3,13 +3,13 @@
    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_RV380|CHIP_IS_MOBILITY}, \
-        {0x1002, 0x3152, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x3154, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x3E50, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x3E54, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_NEW_MEMMAP}, \
-        {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, 0x3150, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \
+        {0x1002, 0x3152, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x3154, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x3E50, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x3E54, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x4136, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS100|RADEON_IS_IGP}, \
+        {0x1002, 0x4137, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS200|RADEON_IS_IGP}, \
         {0x1002, 0x4144, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R300}, \
         {0x1002, 0x4145, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R300}, \
         {0x1002, 0x4146, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R300}, \
@@ -25,35 +25,35 @@
         {0x1002, 0x4154, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350}, \
         {0x1002, 0x4155, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350}, \
         {0x1002, 0x4156, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350}, \
-        {0x1002, 0x4237, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS200|CHIP_IS_IGP}, \
+        {0x1002, 0x4237, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS200|RADEON_IS_IGP}, \
         {0x1002, 0x4242, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R200}, \
         {0x1002, 0x4243, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R200}, \
-        {0x1002, 0x4336, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS100|CHIP_IS_IGP|CHIP_IS_MOBILITY}, \
-        {0x1002, 0x4337, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS200|CHIP_IS_IGP|CHIP_IS_MOBILITY}, \
-        {0x1002, 0x4437, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS200|CHIP_IS_IGP|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x4336, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS100|RADEON_IS_IGP|RADEON_IS_MOBILITY}, \
+        {0x1002, 0x4337, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS200|RADEON_IS_IGP|RADEON_IS_MOBILITY}, \
+        {0x1002, 0x4437, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS200|RADEON_IS_IGP|RADEON_IS_MOBILITY}, \
         {0x1002, 0x4966, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV250}, \
         {0x1002, 0x4967, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV250}, \
-        {0x1002, 0x4A48, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x4A49, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x4A4A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x4A4B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x4A4C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x4A4D, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x4A4E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x4A4F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x4A50, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x4A54, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x4B49, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x4B4A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x4B4B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x4B4C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x4C57, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV200|CHIP_IS_MOBILITY}, \
-        {0x1002, 0x4C58, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV200|CHIP_IS_MOBILITY}, \
-        {0x1002, 0x4C59, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100|CHIP_IS_MOBILITY}, \
-        {0x1002, 0x4C5A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100|CHIP_IS_MOBILITY}, \
-        {0x1002, 0x4C64, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV250|CHIP_IS_MOBILITY}, \
-        {0x1002, 0x4C66, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV250|CHIP_IS_MOBILITY}, \
-        {0x1002, 0x4C67, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV250|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x4A48, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x4A49, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x4A4A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x4A4B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x4A4C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x4A4D, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x4A4E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x4A4F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x4A50, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x4A54, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x4B49, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x4B4A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x4B4B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x4B4C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x4C57, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV200|RADEON_IS_MOBILITY}, \
+        {0x1002, 0x4C58, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV200|RADEON_IS_MOBILITY}, \
+        {0x1002, 0x4C59, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100|RADEON_IS_MOBILITY}, \
+        {0x1002, 0x4C5A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100|RADEON_IS_MOBILITY}, \
+        {0x1002, 0x4C64, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV250|RADEON_IS_MOBILITY}, \
+        {0x1002, 0x4C66, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV250|RADEON_IS_MOBILITY}, \
+        {0x1002, 0x4C67, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV250|RADEON_IS_MOBILITY}, \
         {0x1002, 0x4E44, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R300}, \
         {0x1002, 0x4E45, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R300}, \
         {0x1002, 0x4E46, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R300}, \
@@ -62,16 +62,16 @@
         {0x1002, 0x4E49, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R350}, \
         {0x1002, 0x4E4A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R350}, \
         {0x1002, 0x4E4B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R350}, \
-        {0x1002, 0x4E50, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|CHIP_IS_MOBILITY}, \
-        {0x1002, 0x4E51, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|CHIP_IS_MOBILITY}, \
-        {0x1002, 0x4E52, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|CHIP_IS_MOBILITY}, \
-        {0x1002, 0x4E53, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|CHIP_IS_MOBILITY}, \
-        {0x1002, 0x4E54, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|CHIP_IS_MOBILITY}, \
-        {0x1002, 0x4E56, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|CHIP_IS_MOBILITY}, \
-        {0x1002, 0x5144, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R100|CHIP_SINGLE_CRTC}, \
-        {0x1002, 0x5145, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R100|CHIP_SINGLE_CRTC}, \
-        {0x1002, 0x5146, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R100|CHIP_SINGLE_CRTC}, \
-        {0x1002, 0x5147, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R100|CHIP_SINGLE_CRTC}, \
+        {0x1002, 0x4E50, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|RADEON_IS_MOBILITY}, \
+        {0x1002, 0x4E51, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|RADEON_IS_MOBILITY}, \
+        {0x1002, 0x4E52, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|RADEON_IS_MOBILITY}, \
+        {0x1002, 0x4E53, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|RADEON_IS_MOBILITY}, \
+        {0x1002, 0x4E54, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|RADEON_IS_MOBILITY}, \
+        {0x1002, 0x4E56, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|RADEON_IS_MOBILITY}, \
+        {0x1002, 0x5144, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R100|RADEON_SINGLE_CRTC}, \
+        {0x1002, 0x5145, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R100|RADEON_SINGLE_CRTC}, \
+        {0x1002, 0x5146, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R100|RADEON_SINGLE_CRTC}, \
+        {0x1002, 0x5147, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R100|RADEON_SINGLE_CRTC}, \
         {0x1002, 0x5148, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R200}, \
         {0x1002, 0x514C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R200}, \
         {0x1002, 0x514D, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R200}, \
@@ -80,59 +80,59 @@
         {0x1002, 0x5159, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100}, \
         {0x1002, 0x515A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100}, \
         {0x1002, 0x515E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100}, \
-        {0x1002, 0x5460, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_IS_MOBILITY}, \
-        {0x1002, 0x5462, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_IS_MOBILITY}, \
-        {0x1002, 0x5464, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_IS_MOBILITY}, \
-        {0x1002, 0x5548, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5549, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x554A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x554B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x554C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x554D, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x554E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x554F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5550, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5551, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5552, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5554, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x564A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x564B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x564F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5652, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5653, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5834, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|CHIP_IS_IGP}, \
-        {0x1002, 0x5835, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|CHIP_IS_IGP|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x5460, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \
+        {0x1002, 0x5462, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \
+        {0x1002, 0x5464, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \
+        {0x1002, 0x5548, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5549, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x554A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x554B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x554C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x554D, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x554E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x554F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5550, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5551, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5552, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5554, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x564A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x564B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x564F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5652, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5653, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5834, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|RADEON_IS_IGP}, \
+        {0x1002, 0x5835, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|RADEON_IS_IGP|RADEON_IS_MOBILITY}, \
         {0x1002, 0x5960, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280}, \
         {0x1002, 0x5961, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280}, \
         {0x1002, 0x5962, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280}, \
         {0x1002, 0x5964, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280}, \
         {0x1002, 0x5965, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280}, \
         {0x1002, 0x5969, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100}, \
-        {0x1002, 0x5b60, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5b62, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5b63, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5b64, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5b65, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5c61, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280|CHIP_IS_MOBILITY}, \
-        {0x1002, 0x5c63, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280|CHIP_IS_MOBILITY}, \
-        {0x1002, 0x5d48, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5d49, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5d4a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5d4c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5d4d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5d4e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5d4f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5d50, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5d52, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5d57, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5e48, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5e4a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5e4b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5e4c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5e4d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x5e4f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x7834, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|CHIP_IS_IGP|CHIP_NEW_MEMMAP}, \
-        {0x1002, 0x7835, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|CHIP_IS_IGP|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5b60, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5b62, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5b63, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5b64, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5b65, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5c61, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280|RADEON_IS_MOBILITY}, \
+        {0x1002, 0x5c63, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280|RADEON_IS_MOBILITY}, \
+        {0x1002, 0x5d48, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5d49, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5d4a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5d4c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5d4d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5d4e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5d4f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5d50, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5d52, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5d57, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5e48, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5e4a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5e4b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5e4c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5e4d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x5e4f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x7834, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|RADEON_IS_IGP|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x7835, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|RADEON_IS_IGP|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
         {0, 0, 0}
 
 #define r128_PCI_IDS \
@@ -209,6 +209,7 @@
         {0x1039, 0x0300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
         {0x1039, 0x5300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
         {0x1039, 0x6300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
+        {0x1039, 0x6330, PCI_ANY_ID, PCI_ANY_ID, 0, 0, SIS_CHIP_315}, \
         {0x1039, 0x7300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
         {0, 0, 0}
 
@@ -227,6 +228,10 @@
         {0x1106, 0x3122, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
         {0x1106, 0x7205, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
         {0x1106, 0x3108, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
+        {0x1106, 0x3304, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
+        {0x1106, 0x3157, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
+        {0x1106, 0x3344, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
+        {0x1106, 0x7204, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
         {0, 0, 0}
 
 #define i810_PCI_IDS \
@@ -285,5 +290,9 @@
         {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}, \
+        {0x8086, 0x2972, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
+        {0x8086, 0x2982, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
+        {0x8086, 0x2992, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
+        {0x8086, 0x29a2, 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 362a270af0f1..62d5fe15f046 100644
--- a/drivers/char/drm/drm_proc.c
+++ b/drivers/char/drm/drm_proc.c
@@ -510,7 +510,7 @@ static int drm__vma_info(char *buf, char **start, off_t offset, int request,
                                vma->vm_flags & VM_MAYSHARE ? 's' : 'p',
                                vma->vm_flags & VM_LOCKED ? 'l' : '-',
                                vma->vm_flags & VM_IO ? 'i' : '-',
-                               VM_OFFSET(vma));
+                               vma->vm_pgoff << PAGE_SHIFT);
 
 #if defined(__i386__)
                 pgprot = pgprot_val(vma->vm_page_prot);
diff --git a/drivers/char/drm/drm_sman.c b/drivers/char/drm/drm_sman.c
new file mode 100644
index 000000000000..19c81d2e13d0
--- /dev/null
+++ b/drivers/char/drm/drm_sman.c
@@ -0,0 +1,353 @@
+/**************************************************************************
+ *
+ * Copyright 2006 Tungsten Graphics, Inc., Bismarck., ND., USA.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ *
+ **************************************************************************/
+/*
+ * Simple memory manager interface that keeps track on allocate regions on a
+ * per "owner" basis. All regions associated with an "owner" can be released
+ * with a simple call. Typically if the "owner" exists. The owner is any
+ * "unsigned long" identifier. Can typically be a pointer to a file private
+ * struct or a context identifier.
+ *
+ * Authors:
+ * Thomas Hellström <thomas-at-tungstengraphics-dot-com>
+ */
+
+#include "drm_sman.h"
+
+typedef struct drm_owner_item {
+        drm_hash_item_t owner_hash;
+        struct list_head sman_list;
+        struct list_head mem_blocks;
+} drm_owner_item_t;
+
+void drm_sman_takedown(drm_sman_t * sman)
+{
+        drm_ht_remove(&sman->user_hash_tab);
+        drm_ht_remove(&sman->owner_hash_tab);
+        if (sman->mm)
+                drm_free(sman->mm, sman->num_managers * sizeof(*sman->mm),
+                         DRM_MEM_MM);
+}
+
+EXPORT_SYMBOL(drm_sman_takedown);
+
+int
+drm_sman_init(drm_sman_t * sman, unsigned int num_managers,
+              unsigned int user_order, unsigned int owner_order)
+{
+        int ret = 0;
+
+        sman->mm = (drm_sman_mm_t *) drm_calloc(num_managers, sizeof(*sman->mm),
+                                                DRM_MEM_MM);
+        if (!sman->mm) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        sman->num_managers = num_managers;
+        INIT_LIST_HEAD(&sman->owner_items);
+        ret = drm_ht_create(&sman->owner_hash_tab, owner_order);
+        if (ret)
+                goto out1;
+        ret = drm_ht_create(&sman->user_hash_tab, user_order);
+        if (!ret)
+                goto out;
+
+        drm_ht_remove(&sman->owner_hash_tab);
+out1:
+        drm_free(sman->mm, num_managers * sizeof(*sman->mm), DRM_MEM_MM);
+out:
+        return ret;
+}
+
+EXPORT_SYMBOL(drm_sman_init);
+
+static void *drm_sman_mm_allocate(void *private, unsigned long size,
+                                  unsigned alignment)
+{
+        drm_mm_t *mm = (drm_mm_t *) private;
+        drm_mm_node_t *tmp;
+
+        tmp = drm_mm_search_free(mm, size, alignment, 1);
+        if (!tmp) {
+                return NULL;
+        }
+        tmp = drm_mm_get_block(tmp, size, alignment);
+        return tmp;
+}
+
+static void drm_sman_mm_free(void *private, void *ref)
+{
+        drm_mm_t *mm = (drm_mm_t *) private;
+        drm_mm_node_t *node = (drm_mm_node_t *) ref;
+
+        drm_mm_put_block(mm, node);
+}
+
+static void drm_sman_mm_destroy(void *private)
+{
+        drm_mm_t *mm = (drm_mm_t *) private;
+        drm_mm_takedown(mm);
+        drm_free(mm, sizeof(*mm), DRM_MEM_MM);
+}
+
+static unsigned long drm_sman_mm_offset(void *private, void *ref)
+{
+        drm_mm_node_t *node = (drm_mm_node_t *) ref;
+        return node->start;
+}
+
+int
+drm_sman_set_range(drm_sman_t * sman, unsigned int manager,
+                   unsigned long start, unsigned long size)
+{
+        drm_sman_mm_t *sman_mm;
+        drm_mm_t *mm;
+        int ret;
+
+        BUG_ON(manager >= sman->num_managers);
+
+        sman_mm = &sman->mm[manager];
+        mm = drm_calloc(1, sizeof(*mm), DRM_MEM_MM);
+        if (!mm) {
+                return -ENOMEM;
+        }
+        sman_mm->private = mm;
+        ret = drm_mm_init(mm, start, size);
+
+        if (ret) {
+                drm_free(mm, sizeof(*mm), DRM_MEM_MM);
+                return ret;
+        }
+
+        sman_mm->allocate = drm_sman_mm_allocate;
+        sman_mm->free = drm_sman_mm_free;
+        sman_mm->destroy = drm_sman_mm_destroy;
+        sman_mm->offset = drm_sman_mm_offset;
+
+        return 0;
+}
+
+EXPORT_SYMBOL(drm_sman_set_range);
+
+int
+drm_sman_set_manager(drm_sman_t * sman, unsigned int manager,
+                     drm_sman_mm_t * allocator)
+{
+        BUG_ON(manager >= sman->num_managers);
+        sman->mm[manager] = *allocator;
+
+        return 0;
+}
+EXPORT_SYMBOL(drm_sman_set_manager);
+
+static drm_owner_item_t *drm_sman_get_owner_item(drm_sman_t * sman,
+                                                 unsigned long owner)
+{
+        int ret;
+        drm_hash_item_t *owner_hash_item;
+        drm_owner_item_t *owner_item;
+
+        ret = drm_ht_find_item(&sman->owner_hash_tab, owner, &owner_hash_item);
+        if (!ret) {
+                return drm_hash_entry(owner_hash_item, drm_owner_item_t,
+                                      owner_hash);
+        }
+
+        owner_item = drm_calloc(1, sizeof(*owner_item), DRM_MEM_MM);
+        if (!owner_item)
+                goto out;
+
+        INIT_LIST_HEAD(&owner_item->mem_blocks);
+        owner_item->owner_hash.key = owner;
+        if (drm_ht_insert_item(&sman->owner_hash_tab, &owner_item->owner_hash))
+                goto out1;
+
+        list_add_tail(&owner_item->sman_list, &sman->owner_items);
+        return owner_item;
+
+out1:
+        drm_free(owner_item, sizeof(*owner_item), DRM_MEM_MM);
+out:
+        return NULL;
+}
+
+drm_memblock_item_t *drm_sman_alloc(drm_sman_t *sman, unsigned int manager,
+                                    unsigned long size, unsigned alignment,
+                                    unsigned long owner)
+{
+        void *tmp;
+        drm_sman_mm_t *sman_mm;
+        drm_owner_item_t *owner_item;
+        drm_memblock_item_t *memblock;
+
+        BUG_ON(manager >= sman->num_managers);
+
+        sman_mm = &sman->mm[manager];
+        tmp = sman_mm->allocate(sman_mm->private, size, alignment);
+
+        if (!tmp) {
+                return NULL;
+        }
+
+        memblock = drm_calloc(1, sizeof(*memblock), DRM_MEM_MM);
+
+        if (!memblock)
+                goto out;
+
+        memblock->mm_info = tmp;
+        memblock->mm = sman_mm;
+        memblock->sman = sman;
+
+        if (drm_ht_just_insert_please
+            (&sman->user_hash_tab, &memblock->user_hash,
+             (unsigned long)memblock, 32, 0, 0))
+                goto out1;
+
+        owner_item = drm_sman_get_owner_item(sman, owner);
+        if (!owner_item)
+                goto out2;
+
+        list_add_tail(&memblock->owner_list, &owner_item->mem_blocks);
+
+        return memblock;
+
+out2:
+        drm_ht_remove_item(&sman->user_hash_tab, &memblock->user_hash);
+out1:
+        drm_free(memblock, sizeof(*memblock), DRM_MEM_MM);
+out:
+        sman_mm->free(sman_mm->private, tmp);
+
+        return NULL;
+}
+
+EXPORT_SYMBOL(drm_sman_alloc);
+
+static void drm_sman_free(drm_memblock_item_t *item)
+{
+        drm_sman_t *sman = item->sman;
+
+        list_del(&item->owner_list);
+        drm_ht_remove_item(&sman->user_hash_tab, &item->user_hash);
+        item->mm->free(item->mm->private, item->mm_info);
+        drm_free(item, sizeof(*item), DRM_MEM_MM);
+}
+
+int drm_sman_free_key(drm_sman_t *sman, unsigned int key)
+{
+        drm_hash_item_t *hash_item;
+        drm_memblock_item_t *memblock_item;
+
+        if (drm_ht_find_item(&sman->user_hash_tab, key, &hash_item))
+                return -EINVAL;
+
+        memblock_item = drm_hash_entry(hash_item, drm_memblock_item_t, user_hash);
+        drm_sman_free(memblock_item);
+        return 0;
+}
+
+EXPORT_SYMBOL(drm_sman_free_key);
+
+static void drm_sman_remove_owner(drm_sman_t *sman,
+                                  drm_owner_item_t *owner_item)
+{
+        list_del(&owner_item->sman_list);
+        drm_ht_remove_item(&sman->owner_hash_tab, &owner_item->owner_hash);
+        drm_free(owner_item, sizeof(*owner_item), DRM_MEM_MM);
+}
+
+int drm_sman_owner_clean(drm_sman_t *sman, unsigned long owner)
+{
+
+        drm_hash_item_t *hash_item;
+        drm_owner_item_t *owner_item;
+
+        if (drm_ht_find_item(&sman->owner_hash_tab, owner, &hash_item)) {
+                return -1;
+        }
+
+        owner_item = drm_hash_entry(hash_item, drm_owner_item_t, owner_hash);
+        if (owner_item->mem_blocks.next == &owner_item->mem_blocks) {
+                drm_sman_remove_owner(sman, owner_item);
+                return -1;
+        }
+
+        return 0;
+}
+
+EXPORT_SYMBOL(drm_sman_owner_clean);
+
+static void drm_sman_do_owner_cleanup(drm_sman_t *sman,
+                                      drm_owner_item_t *owner_item)
+{
+        drm_memblock_item_t *entry, *next;
+
+        list_for_each_entry_safe(entry, next, &owner_item->mem_blocks,
+                                 owner_list) {
+                drm_sman_free(entry);
+        }
+        drm_sman_remove_owner(sman, owner_item);
+}
+
+void drm_sman_owner_cleanup(drm_sman_t *sman, unsigned long owner)
+{
+
+        drm_hash_item_t *hash_item;
+        drm_owner_item_t *owner_item;
+
+        if (drm_ht_find_item(&sman->owner_hash_tab, owner, &hash_item)) {
+
+                return;
+        }
+
+        owner_item = drm_hash_entry(hash_item, drm_owner_item_t, owner_hash);
+        drm_sman_do_owner_cleanup(sman, owner_item);
+}
+
+EXPORT_SYMBOL(drm_sman_owner_cleanup);
+
+void drm_sman_cleanup(drm_sman_t *sman)
+{
+        drm_owner_item_t *entry, *next;
+        unsigned int i;
+        drm_sman_mm_t *sman_mm;
+
+        list_for_each_entry_safe(entry, next, &sman->owner_items, sman_list) {
+                drm_sman_do_owner_cleanup(sman, entry);
+        }
+        if (sman->mm) {
+                for (i = 0; i < sman->num_managers; ++i) {
+                        sman_mm = &sman->mm[i];
+                        if (sman_mm->private) {
+                                sman_mm->destroy(sman_mm->private);
+                                sman_mm->private = NULL;
+                        }
+                }
+        }
+}
+
+EXPORT_SYMBOL(drm_sman_cleanup);
diff --git a/drivers/char/drm/drm_sman.h b/drivers/char/drm/drm_sman.h
new file mode 100644
index 000000000000..ddc732a1bf27
--- /dev/null
+++ b/drivers/char/drm/drm_sman.h
@@ -0,0 +1,176 @@
+/**************************************************************************
+ *
+ * Copyright 2006 Tungsten Graphics, Inc., Bismarck, ND., USA.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ *
+ **************************************************************************/
+/*
+ * Simple memory MANager interface that keeps track on allocate regions on a
+ * per "owner" basis. All regions associated with an "owner" can be released
+ * with a simple call. Typically if the "owner" exists. The owner is any
+ * "unsigned long" identifier. Can typically be a pointer to a file private
+ * struct or a context identifier.
+ *
+ * Authors:
+ * Thomas Hellström <thomas-at-tungstengraphics-dot-com>
+ */
+
+#ifndef DRM_SMAN_H
+#define DRM_SMAN_H
+
+#include "drmP.h"
+#include "drm_hashtab.h"
+
+/*
+ * A class that is an abstration of a simple memory allocator.
+ * The sman implementation provides a default such allocator
+ * using the drm_mm.c implementation. But the user can replace it.
+ * See the SiS implementation, which may use the SiS FB kernel module
+ * for memory management.
+ */
+
+typedef struct drm_sman_mm {
+        /* private info. If allocated, needs to be destroyed by the destroy
+           function */
+        void *private;
+
+        /* Allocate a memory block with given size and alignment.
+           Return an opaque reference to the memory block */
+
+        void *(*allocate) (void *private, unsigned long size,
+                           unsigned alignment);
+
+        /* Free a memory block. "ref" is the opaque reference that we got from
+           the "alloc" function */
+
+        void (*free) (void *private, void *ref);
+
+        /* Free all resources associated with this allocator */
+
+        void (*destroy) (void *private);
+
+        /* Return a memory offset from the opaque reference returned from the
+           "alloc" function */
+
+        unsigned long (*offset) (void *private, void *ref);
+} drm_sman_mm_t;
+
+typedef struct drm_memblock_item {
+        struct list_head owner_list;
+        drm_hash_item_t user_hash;
+        void *mm_info;
+        drm_sman_mm_t *mm;
+        struct drm_sman *sman;
+} drm_memblock_item_t;
+
+typedef struct drm_sman {
+        drm_sman_mm_t *mm;
+        int num_managers;
+        drm_open_hash_t owner_hash_tab;
+        drm_open_hash_t user_hash_tab;
+        struct list_head owner_items;
+} drm_sman_t;
+
+/*
+ * Take down a memory manager. This function should only be called after a
+ * successful init and after a call to drm_sman_cleanup.
+ */
+
+extern void drm_sman_takedown(drm_sman_t * sman);
+
+/*
+ * Allocate structures for a manager.
+ * num_managers are the number of memory pools to manage. (VRAM, AGP, ....)
+ * user_order is the log2 of the number of buckets in the user hash table.
+ *          set this to approximately log2 of the max number of memory regions
+ *          that will be allocated for _all_ pools together.
+ * owner_order is the log2 of the number of buckets in the owner hash table.
+ *          set this to approximately log2 of
+ *          the number of client file connections that will
+ *          be using the manager.
+ *
+ */
+
+extern int drm_sman_init(drm_sman_t * sman, unsigned int num_managers,
+                         unsigned int user_order, unsigned int owner_order);
+
+/*
+ * Initialize a drm_mm.c allocator. Should be called only once for each
+ * manager unless a customized allogator is used.
+ */
+
+extern int drm_sman_set_range(drm_sman_t * sman, unsigned int manager,
+                              unsigned long start, unsigned long size);
+
+/*
+ * Initialize a customized allocator for one of the managers.
+ * (See the SiS module). The object pointed to by "allocator" is copied,
+ * so it can be destroyed after this call.
+ */
+
+extern int drm_sman_set_manager(drm_sman_t * sman, unsigned int mananger,
+                                drm_sman_mm_t * allocator);
+
+/*
+ * Allocate a memory block. Aligment is not implemented yet.
+ */
+
+extern drm_memblock_item_t *drm_sman_alloc(drm_sman_t * sman,
+                                           unsigned int manager,
+                                           unsigned long size,
+                                           unsigned alignment,
+                                           unsigned long owner);
+/*
+ * Free a memory block identified by its user hash key.
+ */
+
+extern int drm_sman_free_key(drm_sman_t * sman, unsigned int key);
+
+/*
+ * returns 1 iff there are no stale memory blocks associated with this owner.
+ * Typically called to determine if we need to idle the hardware and call
+ * drm_sman_owner_cleanup. If there are no stale memory blocks, it removes all
+ * resources associated with owner.
+ */
+
+extern int drm_sman_owner_clean(drm_sman_t * sman, unsigned long owner);
+
+/*
+ * Frees all stale memory blocks associated with this owner. Note that this
+ * requires that the hardware is finished with all blocks, so the graphics engine
+ * should be idled before this call is made. This function also frees
+ * any resources associated with "owner" and should be called when owner
+ * is not going to be referenced anymore.
+ */
+
+extern void drm_sman_owner_cleanup(drm_sman_t * sman, unsigned long owner);
+
+/*
+ * Frees all stale memory blocks associated with the memory manager.
+ * See idling above.
+ */
+
+extern void drm_sman_cleanup(drm_sman_t * sman);
+
+#endif
diff --git a/drivers/char/drm/drm_stub.c b/drivers/char/drm/drm_stub.c
index 9a842a36bb27..5fd6dc0870cf 100644
--- a/drivers/char/drm/drm_stub.c
+++ b/drivers/char/drm/drm_stub.c
@@ -60,27 +60,29 @@ static int drm_fill_in_dev(drm_device_t * dev, struct pci_dev *pdev,
         int retcode;
 
         spin_lock_init(&dev->count_lock);
+        spin_lock_init(&dev->drw_lock);
+        spin_lock_init(&dev->tasklet_lock);
         init_timer(&dev->timer);
         mutex_init(&dev->struct_mutex);
         mutex_init(&dev->ctxlist_mutex);
 
         dev->pdev = pdev;
+        dev->pci_device = pdev->device;
+        dev->pci_vendor = pdev->vendor;
 
 #ifdef __alpha__
         dev->hose = pdev->sysdata;
-        dev->pci_domain = dev->hose->bus->number;
-#else
-        dev->pci_domain = 0;
 #endif
-        dev->pci_bus = pdev->bus->number;
-        dev->pci_slot = PCI_SLOT(pdev->devfn);
-        dev->pci_func = PCI_FUNC(pdev->devfn);
         dev->irq = pdev->irq;
 
         dev->maplist = drm_calloc(1, sizeof(*dev->maplist), DRM_MEM_MAPS);
         if (dev->maplist == NULL)
                 return -ENOMEM;
         INIT_LIST_HEAD(&dev->maplist->head);
+        if (drm_ht_create(&dev->map_hash, 12)) {
+                drm_free(dev->maplist, sizeof(*dev->maplist), DRM_MEM_MAPS);
+                return -ENOMEM;
+        }
 
         /* the DRM has 6 basic counters */
         dev->counters = 6;
diff --git a/drivers/char/drm/drm_sysfs.c b/drivers/char/drm/drm_sysfs.c
index 51ad98c685c3..ba4b8de83cf0 100644
--- a/drivers/char/drm/drm_sysfs.c
+++ b/drivers/char/drm/drm_sysfs.c
@@ -42,13 +42,24 @@ static CLASS_ATTR(version, S_IRUGO, version_show, NULL);
 struct class *drm_sysfs_create(struct module *owner, char *name)
 {
         struct class *class;
+        int err;
 
         class = class_create(owner, name);
-        if (!class)
-                return class;
+        if (!class) {
+                err = -ENOMEM;
+                goto err_out;
+        }
+
+        err = class_create_file(class, &class_attr_version);
+        if (err)
+                goto err_out_class;
 
-        class_create_file(class, &class_attr_version);
         return class;
+
+err_out_class:
+        class_destroy(class);
+err_out:
+        return ERR_PTR(err);
 }
 
 /**
@@ -96,20 +107,36 @@ static struct class_device_attribute class_device_attrs[] = {
 struct class_device *drm_sysfs_device_add(struct class *cs, drm_head_t *head)
 {
         struct class_device *class_dev;
-        int i;
+        int i, j, err;
 
         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;
+        if (!class_dev) {
+                err = -ENOMEM;
+                goto err_out;
+        }
 
         class_set_devdata(class_dev, head);
 
-        for (i = 0; i < ARRAY_SIZE(class_device_attrs); i++)
-                class_device_create_file(class_dev, &class_device_attrs[i]);
+        for (i = 0; i < ARRAY_SIZE(class_device_attrs); i++) {
+                err = class_device_create_file(class_dev,
+                                               &class_device_attrs[i]);
+                if (err)
+                        goto err_out_files;
+        }
+
         return class_dev;
+
+err_out_files:
+        if (i > 0)
+                for (j = 0; j < i; j++)
+                        class_device_remove_file(class_dev,
+                                                 &class_device_attrs[i]);
+        class_device_unregister(class_dev);
+err_out:
+        return ERR_PTR(err);
 }
 
 /**
diff --git a/drivers/char/drm/drm_vm.c b/drivers/char/drm/drm_vm.c
index ffd0800ed601..b9cfc077f6bc 100644
--- a/drivers/char/drm/drm_vm.c
+++ b/drivers/char/drm/drm_vm.c
@@ -59,7 +59,7 @@ static __inline__ struct page *drm_do_vm_nopage(struct vm_area_struct *vma,
         drm_device_t *dev = priv->head->dev;
         drm_map_t *map = NULL;
         drm_map_list_t *r_list;
-        struct list_head *list;
+        drm_hash_item_t *hash;
 
         /*
          * Find the right map
@@ -70,14 +70,11 @@ static __inline__ struct page *drm_do_vm_nopage(struct vm_area_struct *vma,
         if (!dev->agp || !dev->agp->cant_use_aperture)
                 goto vm_nopage_error;
 
-        list_for_each(list, &dev->maplist->head) {
-                r_list = list_entry(list, drm_map_list_t, head);
-                map = r_list->map;
-                if (!map)
-                        continue;
-                if (r_list->user_token == VM_OFFSET(vma))
-                        break;
-        }
+        if (drm_ht_find_item(&dev->map_hash, vma->vm_pgoff << PAGE_SHIFT, &hash))
+                goto vm_nopage_error;
+
+        r_list = drm_hash_entry(hash, drm_map_list_t, hash);
+        map = r_list->map;
 
         if (map && map->type == _DRM_AGP) {
                 unsigned long offset = address - vma->vm_start;
@@ -150,14 +147,14 @@ static __inline__ struct page *drm_do_vm_shm_nopage(struct vm_area_struct *vma,
         if (address > vma->vm_end)
                 return NOPAGE_SIGBUS;   /* Disallow mremap */
         if (!map)
-                return NOPAGE_OOM;      /* Nothing allocated */
+                return NOPAGE_SIGBUS;   /* Nothing allocated */
 
         offset = address - vma->vm_start;
         i = (unsigned long)map->handle + offset;
         page = (map->type == _DRM_CONSISTENT) ?
                 virt_to_page((void *)i) : vmalloc_to_page((void *)i);
         if (!page)
-                return NOPAGE_OOM;
+                return NOPAGE_SIGBUS;
         get_page(page);
 
         DRM_DEBUG("shm_nopage 0x%lx\n", address);
@@ -275,7 +272,7 @@ static __inline__ struct page *drm_do_vm_dma_nopage(struct vm_area_struct *vma,
         if (address > vma->vm_end)
                 return NOPAGE_SIGBUS;   /* Disallow mremap */
         if (!dma->pagelist)
-                return NOPAGE_OOM;      /* Nothing allocated */
+                return NOPAGE_SIGBUS;   /* Nothing allocated */
 
         offset = address - vma->vm_start;       /* vm_[pg]off[set] should be 0 */
         page_nr = offset >> PAGE_SHIFT;
@@ -313,7 +310,7 @@ static __inline__ struct page *drm_do_vm_sg_nopage(struct vm_area_struct *vma,
         if (address > vma->vm_end)
                 return NOPAGE_SIGBUS;   /* Disallow mremap */
         if (!entry->pagelist)
-                return NOPAGE_OOM;      /* Nothing allocated */
+                return NOPAGE_SIGBUS;   /* Nothing allocated */
 
         offset = address - vma->vm_start;
         map_offset = map->offset - (unsigned long)dev->sg->virtual;
@@ -467,7 +464,7 @@ static int drm_mmap_dma(struct file *filp, struct vm_area_struct *vma)
         dev = priv->head->dev;
         dma = dev->dma;
         DRM_DEBUG("start = 0x%lx, end = 0x%lx, offset = 0x%lx\n",
-                  vma->vm_start, vma->vm_end, VM_OFFSET(vma));
+                  vma->vm_start, vma->vm_end, vma->vm_pgoff << PAGE_SHIFT);
 
         /* Length must match exact page count */
         if (!dma || (length >> PAGE_SHIFT) != dma->page_count) {
@@ -476,6 +473,22 @@ static int drm_mmap_dma(struct file *filp, struct vm_area_struct *vma)
         }
         unlock_kernel();
 
+        if (!capable(CAP_SYS_ADMIN) &&
+            (dma->flags & _DRM_DMA_USE_PCI_RO)) {
+                vma->vm_flags &= ~(VM_WRITE | VM_MAYWRITE);
+#if defined(__i386__) || defined(__x86_64__)
+                pgprot_val(vma->vm_page_prot) &= ~_PAGE_RW;
+#else
+                /* Ye gads this is ugly.  With more thought
+                   we could move this up higher and use
+                   `protection_map' instead.  */
+                vma->vm_page_prot =
+                    __pgprot(pte_val
+                             (pte_wrprotect
+                              (__pte(pgprot_val(vma->vm_page_prot)))));
+#endif
+        }
+
         vma->vm_ops = &drm_vm_dma_ops;
 
         vma->vm_flags |= VM_RESERVED;   /* Don't swap */
@@ -521,12 +534,11 @@ int drm_mmap(struct file *filp, struct vm_area_struct *vma)
         drm_file_t *priv = filp->private_data;
         drm_device_t *dev = priv->head->dev;
         drm_map_t *map = NULL;
-        drm_map_list_t *r_list;
         unsigned long offset = 0;
-        struct list_head *list;
+        drm_hash_item_t *hash;
 
         DRM_DEBUG("start = 0x%lx, end = 0x%lx, offset = 0x%lx\n",
-                  vma->vm_start, vma->vm_end, VM_OFFSET(vma));
+                  vma->vm_start, vma->vm_end, vma->vm_pgoff << PAGE_SHIFT);
 
         if (!priv->authenticated)
                 return -EACCES;
@@ -535,7 +547,7 @@ int drm_mmap(struct file *filp, struct vm_area_struct *vma)
          * the AGP mapped at physical address 0
          * --BenH.
          */
-        if (!VM_OFFSET(vma)
+        if (!(vma->vm_pgoff << PAGE_SHIFT)
 #if __OS_HAS_AGP
             && (!dev->agp
                 || dev->agp->agp_info.device->vendor != PCI_VENDOR_ID_APPLE)
@@ -543,23 +555,12 @@ int drm_mmap(struct file *filp, struct vm_area_struct *vma)
             )
                 return drm_mmap_dma(filp, vma);
 
-        /* A sequential search of a linked list is
-           fine here because: 1) there will only be
-           about 5-10 entries in the list and, 2) a
-           DRI client only has to do this mapping
-           once, so it doesn't have to be optimized
-           for performance, even if the list was a
-           bit longer. */
-        list_for_each(list, &dev->maplist->head) {
-
-                r_list = list_entry(list, drm_map_list_t, head);
-                map = r_list->map;
-                if (!map)
-                        continue;
-                if (r_list->user_token == VM_OFFSET(vma))
-                        break;
+        if (drm_ht_find_item(&dev->map_hash, vma->vm_pgoff << PAGE_SHIFT, &hash)) {
+                DRM_ERROR("Could not find map\n");
+                return -EINVAL;
         }
 
+        map = drm_hash_entry(hash, drm_map_list_t, hash)->map;
         if (!map || ((map->flags & _DRM_RESTRICTED) && !capable(CAP_SYS_ADMIN)))
                 return -EPERM;
 
@@ -620,7 +621,7 @@ int drm_mmap(struct file *filp, struct vm_area_struct *vma)
                 offset = dev->driver->get_reg_ofs(dev);
 #ifdef __sparc__
                 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
-                if (io_remap_pfn_range(DRM_RPR_ARG(vma) vma->vm_start,
+                if (io_remap_pfn_range(vma, vma->vm_start,
                                        (map->offset + offset) >> PAGE_SHIFT,
                                        vma->vm_end - vma->vm_start,
                                        vma->vm_page_prot))
diff --git a/drivers/char/drm/i810_dma.c b/drivers/char/drm/i810_dma.c
index c658dde3633b..fa2de70f7401 100644
--- a/drivers/char/drm/i810_dma.c
+++ b/drivers/char/drm/i810_dma.c
@@ -106,7 +106,7 @@ static int i810_mmap_buffers(struct file *filp, struct vm_area_struct *vma)
         unlock_kernel();
 
         if (io_remap_pfn_range(vma, vma->vm_start,
-                               VM_OFFSET(vma) >> PAGE_SHIFT,
+                               vma->vm_pgoff,
                                vma->vm_end - vma->vm_start, vma->vm_page_prot))
                 return -EAGAIN;
         return 0;
@@ -141,10 +141,10 @@ static int i810_map_buffer(drm_buf_t * buf, struct file *filp)
                                             MAP_SHARED, buf->bus_address);
         dev_priv->mmap_buffer = NULL;
         filp->f_op = old_fops;
-        if ((unsigned long)buf_priv->virtual > -1024UL) {
+        if (IS_ERR(buf_priv->virtual)) {
                 /* Real error */
                 DRM_ERROR("mmap error\n");
-                retcode = (signed int)buf_priv->virtual;
+                retcode = PTR_ERR(buf_priv->virtual);
                 buf_priv->virtual = NULL;
         }
         up_write(&current->mm->mmap_sem);
@@ -808,7 +808,7 @@ static void i810_dma_dispatch_vertex(drm_device_t * dev,
                     ((GFX_OP_PRIMITIVE | prim | ((used / 4) - 2)));
 
                 if (used & 4) {
-                        *(u32 *) ((u32) buf_priv->kernel_virtual + used) = 0;
+                        *(u32 *) ((char *) buf_priv->kernel_virtual + used) = 0;
                         used += 4;
                 }
 
@@ -1166,7 +1166,7 @@ static void i810_dma_dispatch_mc(drm_device_t * dev, drm_buf_t * buf, int used,
 
         if (buf_priv->currently_mapped == I810_BUF_MAPPED) {
                 if (used & 4) {
-                        *(u32 *) ((u32) buf_priv->virtual + used) = 0;
+                        *(u32 *) ((char *) buf_priv->virtual + used) = 0;
                         used += 4;
                 }
 
diff --git a/drivers/char/drm/i830_dma.c b/drivers/char/drm/i830_dma.c
index b0f815d8cea8..4f0e5746ab33 100644
--- a/drivers/char/drm/i830_dma.c
+++ b/drivers/char/drm/i830_dma.c
@@ -108,7 +108,7 @@ static int i830_mmap_buffers(struct file *filp, struct vm_area_struct *vma)
         unlock_kernel();
 
         if (io_remap_pfn_range(vma, vma->vm_start,
-                               VM_OFFSET(vma) >> PAGE_SHIFT,
+                               vma->vm_pgoff,
                                vma->vm_end - vma->vm_start, vma->vm_page_prot))
                 return -EAGAIN;
         return 0;
@@ -146,7 +146,7 @@ static int i830_map_buffer(drm_buf_t * buf, struct file *filp)
         if (IS_ERR((void *)virtual)) {  /* ugh */
                 /* Real error */
                 DRM_ERROR("mmap error\n");
-                retcode = virtual;
+                retcode = PTR_ERR((void *)virtual);
                 buf_priv->virtual = NULL;
         } else {
                 buf_priv->virtual = (void __user *)virtual;
diff --git a/drivers/char/drm/i915_dma.c b/drivers/char/drm/i915_dma.c
index a94233bdbc0e..9354ce3b0093 100644
--- a/drivers/char/drm/i915_dma.c
+++ b/drivers/char/drm/i915_dma.c
@@ -31,6 +31,11 @@
 #include "i915_drm.h"
 #include "i915_drv.h"
 
+#define IS_I965G(dev) (dev->pci_device == 0x2972 || \
+                       dev->pci_device == 0x2982 || \
+                       dev->pci_device == 0x2992 || \
+                       dev->pci_device == 0x29A2)
+
 /* Really want an OS-independent resettable timer.  Would like to have
  * this loop run for (eg) 3 sec, but have the timer reset every time
  * the head pointer changes, so that EBUSY only happens if the ring
@@ -157,6 +162,7 @@ static int i915_initialize(drm_device_t * dev,
 
         dev_priv->ring.virtual_start = dev_priv->ring.map.handle;
 
+        dev_priv->cpp = init->cpp;
         dev_priv->back_offset = init->back_offset;
         dev_priv->front_offset = init->front_offset;
         dev_priv->current_page = 0;
@@ -255,7 +261,7 @@ static int i915_dma_init(DRM_IOCTL_ARGS)
                 retcode = i915_dma_resume(dev);
                 break;
         default:
-                retcode = -EINVAL;
+                retcode = DRM_ERR(EINVAL);
                 break;
         }
 
@@ -347,7 +353,7 @@ static int i915_emit_cmds(drm_device_t * dev, int __user * buffer, int dwords)
         if ((dwords+1) * sizeof(int) >= dev_priv->ring.Size - 8)
                 return DRM_ERR(EINVAL);
 
-        BEGIN_LP_RING(((dwords+1)&~1));
+        BEGIN_LP_RING((dwords+1)&~1);
 
         for (i = 0; i < dwords;) {
                 int cmd, sz;
@@ -386,7 +392,7 @@ static int i915_emit_box(drm_device_t * dev,
         RING_LOCALS;
 
         if (DRM_COPY_FROM_USER_UNCHECKED(&box, &boxes[i], sizeof(box))) {
-                return EFAULT;
+                return DRM_ERR(EFAULT);
         }
 
         if (box.y2 <= box.y1 || box.x2 <= box.x1 || box.y2 <= 0 || box.x2 <= 0) {
@@ -395,24 +401,40 @@ static int i915_emit_box(drm_device_t * dev,
                 return DRM_ERR(EINVAL);
         }
 
-        BEGIN_LP_RING(6);
-        OUT_RING(GFX_OP_DRAWRECT_INFO);
-        OUT_RING(DR1);
-        OUT_RING((box.x1 & 0xffff) | (box.y1 << 16));
-        OUT_RING(((box.x2 - 1) & 0xffff) | ((box.y2 - 1) << 16));
-        OUT_RING(DR4);
-        OUT_RING(0);
-        ADVANCE_LP_RING();
+        if (IS_I965G(dev)) {
+                BEGIN_LP_RING(4);
+                OUT_RING(GFX_OP_DRAWRECT_INFO_I965);
+                OUT_RING((box.x1 & 0xffff) | (box.y1 << 16));
+                OUT_RING(((box.x2 - 1) & 0xffff) | ((box.y2 - 1) << 16));
+                OUT_RING(DR4);
+                ADVANCE_LP_RING();
+        } else {
+                BEGIN_LP_RING(6);
+                OUT_RING(GFX_OP_DRAWRECT_INFO);
+                OUT_RING(DR1);
+                OUT_RING((box.x1 & 0xffff) | (box.y1 << 16));
+                OUT_RING(((box.x2 - 1) & 0xffff) | ((box.y2 - 1) << 16));
+                OUT_RING(DR4);
+                OUT_RING(0);
+                ADVANCE_LP_RING();
+        }
 
         return 0;
 }
 
+/* XXX: Emitting the counter should really be moved to part of the IRQ
+ * emit. For now, do it in both places:
+ */
+
 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++;
+        dev_priv->sarea_priv->last_enqueue = ++dev_priv->counter;
+
+        if (dev_priv->counter > 0x7FFFFFFFUL)
+                dev_priv->sarea_priv->last_enqueue = dev_priv->counter = 1;
 
         BEGIN_LP_RING(4);
         OUT_RING(CMD_STORE_DWORD_IDX);
@@ -761,6 +783,7 @@ drm_ioctl_desc_t i915_ioctls[] = {
         [DRM_IOCTL_NR(DRM_I915_DESTROY_HEAP)] = { i915_mem_destroy_heap, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY },
         [DRM_IOCTL_NR(DRM_I915_SET_VBLANK_PIPE)] = { i915_vblank_pipe_set, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY },
         [DRM_IOCTL_NR(DRM_I915_GET_VBLANK_PIPE)] = { i915_vblank_pipe_get, DRM_AUTH },
+        [DRM_IOCTL_NR(DRM_I915_VBLANK_SWAP)] = {i915_vblank_swap, DRM_AUTH},
 };
 
 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 5aa3e0e3bb45..96a468886a7a 100644
--- a/drivers/char/drm/i915_drm.h
+++ b/drivers/char/drm/i915_drm.h
@@ -98,6 +98,21 @@ typedef struct _drm_i915_sarea {
         int rotated_size;
         int rotated_pitch;
         int virtualX, virtualY;
+
+        unsigned int front_tiled;
+        unsigned int back_tiled;
+        unsigned int depth_tiled;
+        unsigned int rotated_tiled;
+        unsigned int rotated2_tiled;
+
+        int pipeA_x;
+        int pipeA_y;
+        int pipeA_w;
+        int pipeA_h;
+        int pipeB_x;
+        int pipeB_y;
+        int pipeB_w;
+        int pipeB_h;
 } drm_i915_sarea_t;
 
 /* Flags for perf_boxes
@@ -126,6 +141,7 @@ typedef struct _drm_i915_sarea {
 #define DRM_I915_DESTROY_HEAP   0x0c
 #define DRM_I915_SET_VBLANK_PIPE        0x0d
 #define DRM_I915_GET_VBLANK_PIPE        0x0e
+#define DRM_I915_VBLANK_SWAP    0x0f
 
 #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)
@@ -142,6 +158,7 @@ typedef struct _drm_i915_sarea {
 #define DRM_IOCTL_I915_DESTROY_HEAP     DRM_IOW( DRM_COMMAND_BASE + DRM_I915_DESTROY_HEAP, drm_i915_mem_destroy_heap_t)
 #define DRM_IOCTL_I915_SET_VBLANK_PIPE  DRM_IOW( DRM_COMMAND_BASE + DRM_I915_SET_VBLANK_PIPE, drm_i915_vblank_pipe_t)
 #define DRM_IOCTL_I915_GET_VBLANK_PIPE  DRM_IOR( DRM_COMMAND_BASE + DRM_I915_GET_VBLANK_PIPE, drm_i915_vblank_pipe_t)
+#define DRM_IOCTL_I915_VBLANK_SWAP      DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_VBLANK_SWAP, drm_i915_vblank_swap_t)
 
 /* Allow drivers to submit batchbuffers directly to hardware, relying
  * on the security mechanisms provided by hardware.
@@ -237,4 +254,12 @@ typedef struct drm_i915_vblank_pipe {
         int pipe;
 } drm_i915_vblank_pipe_t;
 
+/* Schedule buffer swap at given vertical blank:
+ */
+typedef struct drm_i915_vblank_swap {
+        drm_drawable_t drawable;
+        drm_vblank_seq_type_t seqtype;
+        unsigned int sequence;
+} drm_i915_vblank_swap_t;
+
 #endif                          /* _I915_DRM_H_ */
diff --git a/drivers/char/drm/i915_drv.c b/drivers/char/drm/i915_drv.c
index 8e2e6095c4b3..85bcc276f804 100644
--- a/drivers/char/drm/i915_drv.c
+++ b/drivers/char/drm/i915_drv.c
@@ -44,12 +44,14 @@ static struct drm_driver driver = {
          */
         .driver_features =
             DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | /* DRIVER_USE_MTRR |*/
-            DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | DRIVER_IRQ_VBL,
+            DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | DRIVER_IRQ_VBL |
+            DRIVER_IRQ_VBL2,
         .load = i915_driver_load,
         .lastclose = i915_driver_lastclose,
         .preclose = i915_driver_preclose,
         .device_is_agp = i915_driver_device_is_agp,
         .vblank_wait = i915_driver_vblank_wait,
+        .vblank_wait2 = i915_driver_vblank_wait2,
         .irq_preinstall = i915_driver_irq_preinstall,
         .irq_postinstall = i915_driver_irq_postinstall,
         .irq_uninstall = i915_driver_irq_uninstall,
diff --git a/drivers/char/drm/i915_drv.h b/drivers/char/drm/i915_drv.h
index 2d565031c002..93cdcfe6aa84 100644
--- a/drivers/char/drm/i915_drv.h
+++ b/drivers/char/drm/i915_drv.h
@@ -46,9 +46,11 @@
  * 1.3: Add vblank support
  * 1.4: Fix cmdbuffer path, add heap destroy
  * 1.5: Add vblank pipe configuration
+ * 1.6: - New ioctl for scheduling buffer swaps on vertical blank
+ *      - Support vertical blank on secondary display pipe
  */
 #define DRIVER_MAJOR            1
-#define DRIVER_MINOR            5
+#define DRIVER_MINOR            6
 #define DRIVER_PATCHLEVEL       0
 
 typedef struct _drm_i915_ring_buffer {
@@ -71,6 +73,13 @@ struct mem_block {
         DRMFILE filp;           /* 0: free, -1: heap, other: real files */
 };
 
+typedef struct _drm_i915_vbl_swap {
+        struct list_head head;
+        drm_drawable_t drw_id;
+        unsigned int pipe;
+        unsigned int sequence;
+} drm_i915_vbl_swap_t;
+
 typedef struct drm_i915_private {
         drm_local_map_t *sarea;
         drm_local_map_t *mmio_map;
@@ -83,6 +92,7 @@ typedef struct drm_i915_private {
         dma_addr_t dma_status_page;
         unsigned long counter;
 
+        unsigned int cpp;
         int back_offset;
         int front_offset;
         int current_page;
@@ -98,6 +108,10 @@ typedef struct drm_i915_private {
         struct mem_block *agp_heap;
         unsigned int sr01, adpa, ppcr, dvob, dvoc, lvds;
         int vblank_pipe;
+
+        spinlock_t swaps_lock;
+        drm_i915_vbl_swap_t vbl_swaps;
+        unsigned int swaps_pending;
 } drm_i915_private_t;
 
 extern drm_ioctl_desc_t i915_ioctls[];
@@ -117,12 +131,14 @@ extern int i915_irq_emit(DRM_IOCTL_ARGS);
 extern int i915_irq_wait(DRM_IOCTL_ARGS);
 
 extern int i915_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence);
+extern int i915_driver_vblank_wait2(drm_device_t *dev, unsigned int *sequence);
 extern irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS);
 extern void i915_driver_irq_preinstall(drm_device_t * dev);
 extern void i915_driver_irq_postinstall(drm_device_t * dev);
 extern void i915_driver_irq_uninstall(drm_device_t * dev);
 extern int i915_vblank_pipe_set(DRM_IOCTL_ARGS);
 extern int i915_vblank_pipe_get(DRM_IOCTL_ARGS);
+extern int i915_vblank_swap(DRM_IOCTL_ARGS);
 
 /* i915_mem.c */
 extern int i915_mem_alloc(DRM_IOCTL_ARGS);
@@ -146,9 +162,9 @@ extern void i915_mem_release(drm_device_t * dev,
 #define BEGIN_LP_RING(n) do {                           \
         if (I915_VERBOSE)                               \
                 DRM_DEBUG("BEGIN_LP_RING(%d) in %s\n",  \
-                          n, __FUNCTION__);             \
-        if (dev_priv->ring.space < n*4)                 \
-                i915_wait_ring(dev, n*4, __FUNCTION__);         \
+                          (n), __FUNCTION__);           \
+        if (dev_priv->ring.space < (n)*4)                       \
+                i915_wait_ring(dev, (n)*4, __FUNCTION__);               \
         outcount = 0;                                   \
         outring = dev_priv->ring.tail;                  \
         ringmask = dev_priv->ring.tail_mask;            \
@@ -157,7 +173,7 @@ extern void i915_mem_release(drm_device_t * dev,
 
 #define OUT_RING(n) do {                                        \
         if (I915_VERBOSE) DRM_DEBUG("   OUT_RING %x\n", (int)(n));      \
-        *(volatile unsigned int *)(virt + outring) = n;         \
+        *(volatile unsigned int *)(virt + outring) = (n);       \
         outcount++;                                             \
         outring += 4;                                           \
         outring &= ringmask;                                    \
@@ -254,6 +270,12 @@ extern int i915_wait_ring(drm_device_t * dev, int n, const char *caller);
 #define GFX_OP_DESTBUFFER_VARS   ((0x3<<29)|(0x1d<<24)|(0x85<<16)|0x0)
 #define GFX_OP_DRAWRECT_INFO     ((0x3<<29)|(0x1d<<24)|(0x80<<16)|(0x3))
 
+#define GFX_OP_DRAWRECT_INFO_I965 ((0x7900<<16)|0x2)
+
+#define XY_SRC_COPY_BLT_CMD             ((2<<29)|(0x53<<22)|6)
+#define XY_SRC_COPY_BLT_WRITE_ALPHA     (1<<21)
+#define XY_SRC_COPY_BLT_WRITE_RGB       (1<<20)
+
 #define MI_BATCH_BUFFER         ((0x30<<23)|1)
 #define MI_BATCH_BUFFER_START   (0x31<<23)
 #define MI_BATCH_BUFFER_END     (0xA<<23)
diff --git a/drivers/char/drm/i915_ioc32.c b/drivers/char/drm/i915_ioc32.c
index 296248cdc767..1fe68a251b75 100644
--- a/drivers/char/drm/i915_ioc32.c
+++ b/drivers/char/drm/i915_ioc32.c
@@ -66,7 +66,7 @@ static int compat_i915_batchbuffer(struct file *file, unsigned int cmd,
                           &batchbuffer->cliprects))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_I915_BATCHBUFFER,
                          (unsigned long)batchbuffer);
 }
@@ -102,7 +102,7 @@ static int compat_i915_cmdbuffer(struct file *file, unsigned int cmd,
                           &cmdbuffer->cliprects))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_I915_CMDBUFFER, (unsigned long)cmdbuffer);
 }
 
@@ -125,7 +125,7 @@ static int compat_i915_irq_emit(struct file *file, unsigned int cmd,
                           &request->irq_seq))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_I915_IRQ_EMIT, (unsigned long)request);
 }
 typedef struct drm_i915_getparam32 {
@@ -149,7 +149,7 @@ static int compat_i915_getparam(struct file *file, unsigned int cmd,
                           &request->value))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_I915_GETPARAM, (unsigned long)request);
 }
 
@@ -178,7 +178,7 @@ static int compat_i915_alloc(struct file *file, unsigned int cmd,
                           &request->region_offset))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_I915_ALLOC, (unsigned long)request);
 }
 
@@ -215,7 +215,7 @@ long i915_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
         if (fn != NULL)
                 ret = (*fn) (filp, cmd, arg);
         else
-                ret = drm_ioctl(filp->f_dentry->d_inode, filp, cmd, arg);
+                ret = drm_ioctl(filp->f_path.dentry->d_inode, filp, cmd, arg);
         unlock_kernel();
 
         return ret;
diff --git a/drivers/char/drm/i915_irq.c b/drivers/char/drm/i915_irq.c
index cd96cfa430db..e5463b111fc0 100644
--- a/drivers/char/drm/i915_irq.c
+++ b/drivers/char/drm/i915_irq.c
@@ -37,6 +37,99 @@
 
 #define MAX_NOPID ((u32)~0)
 
+/**
+ * Emit blits for scheduled buffer swaps.
+ *
+ * This function will be called with the HW lock held.
+ */
+static void i915_vblank_tasklet(drm_device_t *dev)
+{
+        drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+        unsigned long irqflags;
+        struct list_head *list, *tmp;
+
+        DRM_DEBUG("\n");
+
+        spin_lock_irqsave(&dev_priv->swaps_lock, irqflags);
+
+        list_for_each_safe(list, tmp, &dev_priv->vbl_swaps.head) {
+                drm_i915_vbl_swap_t *vbl_swap =
+                        list_entry(list, drm_i915_vbl_swap_t, head);
+                atomic_t *counter = vbl_swap->pipe ? &dev->vbl_received2 :
+                        &dev->vbl_received;
+
+                if ((atomic_read(counter) - vbl_swap->sequence) <= (1<<23)) {
+                        drm_drawable_info_t *drw;
+
+                        spin_unlock(&dev_priv->swaps_lock);
+
+                        spin_lock(&dev->drw_lock);
+
+                        drw = drm_get_drawable_info(dev, vbl_swap->drw_id);
+                                
+                        if (drw) {
+                                int i, num_rects = drw->num_rects;
+                                drm_clip_rect_t *rect = drw->rects;
+                                drm_i915_sarea_t *sarea_priv =
+                                    dev_priv->sarea_priv;
+                                u32 cpp = dev_priv->cpp;
+                                u32 cmd = (cpp == 4) ? (XY_SRC_COPY_BLT_CMD |
+                                                        XY_SRC_COPY_BLT_WRITE_ALPHA |
+                                                        XY_SRC_COPY_BLT_WRITE_RGB)
+                                                     : XY_SRC_COPY_BLT_CMD;
+                                u32 pitchropcpp = (sarea_priv->pitch * cpp) |
+                                                  (0xcc << 16) | (cpp << 23) |
+                                                  (1 << 24);
+                                RING_LOCALS;
+
+                                i915_kernel_lost_context(dev);
+
+                                BEGIN_LP_RING(6);
+
+                                OUT_RING(GFX_OP_DRAWRECT_INFO);
+                                OUT_RING(0);
+                                OUT_RING(0);
+                                OUT_RING(sarea_priv->width |
+                                         sarea_priv->height << 16);
+                                OUT_RING(sarea_priv->width |
+                                         sarea_priv->height << 16);
+                                OUT_RING(0);
+
+                                ADVANCE_LP_RING();
+
+                                sarea_priv->ctxOwner = DRM_KERNEL_CONTEXT;
+
+                                for (i = 0; i < num_rects; i++, rect++) {
+                                        BEGIN_LP_RING(8);
+
+                                        OUT_RING(cmd);
+                                        OUT_RING(pitchropcpp);
+                                        OUT_RING((rect->y1 << 16) | rect->x1);
+                                        OUT_RING((rect->y2 << 16) | rect->x2);
+                                        OUT_RING(sarea_priv->front_offset);
+                                        OUT_RING((rect->y1 << 16) | rect->x1);
+                                        OUT_RING(pitchropcpp & 0xffff);
+                                        OUT_RING(sarea_priv->back_offset);
+
+                                        ADVANCE_LP_RING();
+                                }
+                        }
+
+                        spin_unlock(&dev->drw_lock);
+
+                        spin_lock(&dev_priv->swaps_lock);
+
+                        list_del(list);
+
+                        drm_free(vbl_swap, sizeof(*vbl_swap), DRM_MEM_DRIVER);
+
+                        dev_priv->swaps_pending--;
+                }
+        }
+
+        spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
+}
+
 irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
 {
         drm_device_t *dev = (drm_device_t *) arg;
@@ -60,9 +153,26 @@ irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
                 DRM_WAKEUP(&dev_priv->irq_queue);
 
         if (temp & (VSYNC_PIPEA_FLAG | VSYNC_PIPEB_FLAG)) {
-                atomic_inc(&dev->vbl_received);
+                int vblank_pipe = dev_priv->vblank_pipe;
+
+                if ((vblank_pipe &
+                     (DRM_I915_VBLANK_PIPE_A | DRM_I915_VBLANK_PIPE_B))
+                    == (DRM_I915_VBLANK_PIPE_A | DRM_I915_VBLANK_PIPE_B)) {
+                        if (temp & VSYNC_PIPEA_FLAG)
+                                atomic_inc(&dev->vbl_received);
+                        if (temp & VSYNC_PIPEB_FLAG)
+                                atomic_inc(&dev->vbl_received2);
+                } else if (((temp & VSYNC_PIPEA_FLAG) &&
+                            (vblank_pipe & DRM_I915_VBLANK_PIPE_A)) ||
+                           ((temp & VSYNC_PIPEB_FLAG) &&
+                            (vblank_pipe & DRM_I915_VBLANK_PIPE_B)))
+                        atomic_inc(&dev->vbl_received);
+
                 DRM_WAKEUP(&dev->vbl_queue);
                 drm_vbl_send_signals(dev);
+
+                if (dev_priv->swaps_pending > 0)
+                        drm_locked_tasklet(dev, i915_vblank_tasklet);
         }
 
         return IRQ_HANDLED;
@@ -71,21 +181,27 @@ irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
 static int i915_emit_irq(drm_device_t * dev)
 {
         drm_i915_private_t *dev_priv = dev->dev_private;
-        u32 ret;
         RING_LOCALS;
 
         i915_kernel_lost_context(dev);
 
         DRM_DEBUG("%s\n", __FUNCTION__);
 
-        ret = dev_priv->counter;
+        dev_priv->sarea_priv->last_enqueue = ++dev_priv->counter;
 
-        BEGIN_LP_RING(2);
+        if (dev_priv->counter > 0x7FFFFFFFUL)
+                dev_priv->sarea_priv->last_enqueue = dev_priv->counter = 1;
+
+        BEGIN_LP_RING(6);
+        OUT_RING(CMD_STORE_DWORD_IDX);
+        OUT_RING(20);
+        OUT_RING(dev_priv->counter);
+        OUT_RING(0);
         OUT_RING(0);
         OUT_RING(GFX_OP_USER_INTERRUPT);
         ADVANCE_LP_RING();
-
-        return ret;
+        
+        return dev_priv->counter;
 }
 
 static int i915_wait_irq(drm_device_t * dev, int irq_nr)
@@ -114,7 +230,8 @@ static int i915_wait_irq(drm_device_t * dev, int irq_nr)
         return ret;
 }
 
-int i915_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence)
+static int i915_driver_vblank_do_wait(drm_device_t *dev, unsigned int *sequence,
+                                      atomic_t *counter)
 {
         drm_i915_private_t *dev_priv = dev->dev_private;
         unsigned int cur_vblank;
@@ -126,7 +243,7 @@ int i915_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence)
         }
 
         DRM_WAIT_ON(ret, dev->vbl_queue, 3 * DRM_HZ,
-                    (((cur_vblank = atomic_read(&dev->vbl_received))
+                    (((cur_vblank = atomic_read(counter))
                         - *sequence) <= (1<<23)));
         
         *sequence = cur_vblank;
@@ -135,6 +252,16 @@ int i915_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence)
 }
 
 
+int i915_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence)
+{
+        return i915_driver_vblank_do_wait(dev, sequence, &dev->vbl_received);
+}
+
+int i915_driver_vblank_wait2(drm_device_t *dev, unsigned int *sequence)
+{
+        return i915_driver_vblank_do_wait(dev, sequence, &dev->vbl_received2);
+}
+
 /* Needs the lock as it touches the ring.
  */
 int i915_irq_emit(DRM_IOCTL_ARGS)
@@ -183,7 +310,7 @@ int i915_irq_wait(DRM_IOCTL_ARGS)
         return i915_wait_irq(dev, irqwait.irq_seq);
 }
 
-static int i915_enable_interrupt (drm_device_t *dev)
+static void i915_enable_interrupt (drm_device_t *dev)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
         u16 flag;
@@ -193,13 +320,8 @@ static int i915_enable_interrupt (drm_device_t *dev)
                 flag |= VSYNC_PIPEA_FLAG;
         if (dev_priv->vblank_pipe & DRM_I915_VBLANK_PIPE_B)
                 flag |= VSYNC_PIPEB_FLAG;
-        if (dev_priv->vblank_pipe & ~(DRM_I915_VBLANK_PIPE_A|DRM_I915_VBLANK_PIPE_B)) {
-                DRM_ERROR("%s called with invalid pipe 0x%x\n",
-                          __FUNCTION__, dev_priv->vblank_pipe);
-                return DRM_ERR(EINVAL);
-        }
+
         I915_WRITE16(I915REG_INT_ENABLE_R, USER_INT_FLAG | flag);
-        return 0;
 }
 
 /* Set the vblank monitor pipe
@@ -218,8 +340,17 @@ int i915_vblank_pipe_set(DRM_IOCTL_ARGS)
         DRM_COPY_FROM_USER_IOCTL(pipe, (drm_i915_vblank_pipe_t __user *) data,
                                  sizeof(pipe));
 
+        if (pipe.pipe & ~(DRM_I915_VBLANK_PIPE_A|DRM_I915_VBLANK_PIPE_B)) {
+                DRM_ERROR("%s called with invalid pipe 0x%x\n", 
+                          __FUNCTION__, pipe.pipe);
+                return DRM_ERR(EINVAL);
+        }
+
         dev_priv->vblank_pipe = pipe.pipe;
-        return i915_enable_interrupt (dev);
+
+        i915_enable_interrupt (dev);
+
+        return 0;
 }
 
 int i915_vblank_pipe_get(DRM_IOCTL_ARGS)
@@ -245,6 +376,118 @@ int i915_vblank_pipe_get(DRM_IOCTL_ARGS)
         return 0;
 }
 
+/**
+ * Schedule buffer swap at given vertical blank.
+ */
+int i915_vblank_swap(DRM_IOCTL_ARGS)
+{
+        DRM_DEVICE;
+        drm_i915_private_t *dev_priv = dev->dev_private;
+        drm_i915_vblank_swap_t swap;
+        drm_i915_vbl_swap_t *vbl_swap;
+        unsigned int pipe, seqtype, curseq;
+        unsigned long irqflags;
+        struct list_head *list;
+
+        if (!dev_priv) {
+                DRM_ERROR("%s called with no initialization\n", __func__);
+                return DRM_ERR(EINVAL);
+        }
+
+        if (dev_priv->sarea_priv->rotation) {
+                DRM_DEBUG("Rotation not supported\n");
+                return DRM_ERR(EINVAL);
+        }
+
+        DRM_COPY_FROM_USER_IOCTL(swap, (drm_i915_vblank_swap_t __user *) data,
+                                 sizeof(swap));
+
+        if (swap.seqtype & ~(_DRM_VBLANK_RELATIVE | _DRM_VBLANK_ABSOLUTE |
+                             _DRM_VBLANK_SECONDARY | _DRM_VBLANK_NEXTONMISS)) {
+                DRM_ERROR("Invalid sequence type 0x%x\n", swap.seqtype);
+                return DRM_ERR(EINVAL);
+        }
+
+        pipe = (swap.seqtype & _DRM_VBLANK_SECONDARY) ? 1 : 0;
+
+        seqtype = swap.seqtype & (_DRM_VBLANK_RELATIVE | _DRM_VBLANK_ABSOLUTE);
+
+        if (!(dev_priv->vblank_pipe & (1 << pipe))) {
+                DRM_ERROR("Invalid pipe %d\n", pipe);
+                return DRM_ERR(EINVAL);
+        }
+
+        spin_lock_irqsave(&dev->drw_lock, irqflags);
+
+        if (!drm_get_drawable_info(dev, swap.drawable)) {
+                spin_unlock_irqrestore(&dev->drw_lock, irqflags);
+                DRM_ERROR("Invalid drawable ID %d\n", swap.drawable);
+                return DRM_ERR(EINVAL);
+        }
+
+        spin_unlock_irqrestore(&dev->drw_lock, irqflags);
+
+        curseq = atomic_read(pipe ? &dev->vbl_received2 : &dev->vbl_received);
+
+        if (seqtype == _DRM_VBLANK_RELATIVE)
+                swap.sequence += curseq;
+
+        if ((curseq - swap.sequence) <= (1<<23)) {
+                if (swap.seqtype & _DRM_VBLANK_NEXTONMISS) {
+                        swap.sequence = curseq + 1;
+                } else {
+                        DRM_DEBUG("Missed target sequence\n");
+                        return DRM_ERR(EINVAL);
+                }
+        }
+
+        spin_lock_irqsave(&dev_priv->swaps_lock, irqflags);
+
+        list_for_each(list, &dev_priv->vbl_swaps.head) {
+                vbl_swap = list_entry(list, drm_i915_vbl_swap_t, head);
+
+                if (vbl_swap->drw_id == swap.drawable &&
+                    vbl_swap->pipe == pipe &&
+                    vbl_swap->sequence == swap.sequence) {
+                        spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
+                        DRM_DEBUG("Already scheduled\n");
+                        return 0;
+                }
+        }
+
+        spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
+
+        if (dev_priv->swaps_pending >= 100) {
+                DRM_DEBUG("Too many swaps queued\n");
+                return DRM_ERR(EBUSY);
+        }
+
+        vbl_swap = drm_calloc(1, sizeof(vbl_swap), DRM_MEM_DRIVER);
+
+        if (!vbl_swap) {
+                DRM_ERROR("Failed to allocate memory to queue swap\n");
+                return DRM_ERR(ENOMEM);
+        }
+
+        DRM_DEBUG("\n");
+
+        vbl_swap->drw_id = swap.drawable;
+        vbl_swap->pipe = pipe;
+        vbl_swap->sequence = swap.sequence;
+
+        spin_lock_irqsave(&dev_priv->swaps_lock, irqflags);
+
+        list_add_tail((struct list_head *)vbl_swap, &dev_priv->vbl_swaps.head);
+        dev_priv->swaps_pending++;
+
+        spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
+
+        DRM_COPY_TO_USER_IOCTL((drm_i915_vblank_swap_t __user *) data, swap,
+                               sizeof(swap));
+
+        return 0;
+}
+
 /* drm_dma.h hooks
 */
 void i915_driver_irq_preinstall(drm_device_t * dev)
@@ -260,6 +503,12 @@ void i915_driver_irq_postinstall(drm_device_t * dev)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
 
+        dev_priv->swaps_lock = SPIN_LOCK_UNLOCKED;
+        INIT_LIST_HEAD(&dev_priv->vbl_swaps.head);
+        dev_priv->swaps_pending = 0;
+
+        if (!dev_priv->vblank_pipe)
+                dev_priv->vblank_pipe = DRM_I915_VBLANK_PIPE_A;
         i915_enable_interrupt(dev);
         DRM_INIT_WAITQUEUE(&dev_priv->irq_queue);
 }
diff --git a/drivers/char/drm/mga_drv.c b/drivers/char/drm/mga_drv.c
index e30f556b79f1..be49dbb9ec3f 100644
--- a/drivers/char/drm/mga_drv.c
+++ b/drivers/char/drm/mga_drv.c
@@ -47,6 +47,7 @@ static struct drm_driver driver = {
             DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_PCI_DMA |
             DRIVER_HAVE_DMA | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED |
             DRIVER_IRQ_VBL,
+        .dev_priv_size = sizeof(drm_mga_buf_priv_t),
         .load = mga_driver_load,
         .unload = mga_driver_unload,
         .lastclose = mga_driver_lastclose,
diff --git a/drivers/char/drm/mga_ioc32.c b/drivers/char/drm/mga_ioc32.c
index 54a18eb2fc04..30d00478ddee 100644
--- a/drivers/char/drm/mga_ioc32.c
+++ b/drivers/char/drm/mga_ioc32.c
@@ -100,7 +100,7 @@ static int compat_mga_init(struct file *file, unsigned int cmd,
         if (err)
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_MGA_INIT, (unsigned long)init);
 }
 
@@ -125,7 +125,7 @@ static int compat_mga_getparam(struct file *file, unsigned int cmd,
                           &getparam->value))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_MGA_GETPARAM, (unsigned long)getparam);
 }
 
@@ -166,7 +166,7 @@ static int compat_mga_dma_bootstrap(struct file *file, unsigned int cmd,
             || __put_user(dma_bootstrap32.agp_size, &dma_bootstrap->agp_size))
                 return -EFAULT;
 
-        err = drm_ioctl(file->f_dentry->d_inode, file,
+        err = drm_ioctl(file->f_path.dentry->d_inode, file,
                         DRM_IOCTL_MGA_DMA_BOOTSTRAP,
                         (unsigned long)dma_bootstrap);
         if (err)
@@ -224,7 +224,7 @@ long mga_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
         if (fn != NULL)
                 ret = (*fn) (filp, cmd, arg);
         else
-                ret = drm_ioctl(filp->f_dentry->d_inode, filp, cmd, arg);
+                ret = drm_ioctl(filp->f_path.dentry->d_inode, filp, cmd, arg);
         unlock_kernel();
 
         return ret;
diff --git a/drivers/char/drm/r128_ioc32.c b/drivers/char/drm/r128_ioc32.c
index 9dd6d4116e47..d3cb676eee84 100644
--- a/drivers/char/drm/r128_ioc32.c
+++ b/drivers/char/drm/r128_ioc32.c
@@ -95,7 +95,7 @@ static int compat_r128_init(struct file *file, unsigned int cmd,
                           &init->agp_textures_offset))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_R128_INIT, (unsigned long)init);
 }
 
@@ -129,7 +129,7 @@ static int compat_r128_depth(struct file *file, unsigned int cmd,
                           &depth->mask))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_R128_DEPTH, (unsigned long)depth);
 
 }
@@ -153,7 +153,7 @@ static int compat_r128_stipple(struct file *file, unsigned int cmd,
                           &stipple->mask))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_R128_STIPPLE, (unsigned long)stipple);
 }
 
@@ -178,7 +178,7 @@ static int compat_r128_getparam(struct file *file, unsigned int cmd,
                           &getparam->value))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_R128_GETPARAM, (unsigned long)getparam);
 }
 
@@ -214,7 +214,7 @@ long r128_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
         if (fn != NULL)
                 ret = (*fn) (filp, cmd, arg);
         else
-                ret = drm_ioctl(filp->f_dentry->d_inode, filp, cmd, arg);
+                ret = drm_ioctl(filp->f_path.dentry->d_inode, filp, cmd, arg);
         unlock_kernel();
 
         return ret;
diff --git a/drivers/char/drm/r300_cmdbuf.c b/drivers/char/drm/r300_cmdbuf.c
index 26bdf2ca59d7..d14477ba3679 100644
--- a/drivers/char/drm/r300_cmdbuf.c
+++ b/drivers/char/drm/r300_cmdbuf.c
@@ -538,6 +538,36 @@ static __inline__ int r300_emit_bitblt_multi(drm_radeon_private_t *dev_priv,
         return 0;
 }
 
+static __inline__ int r300_emit_indx_buffer(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[1] & 0x8000ffff) != 0x80000810) {
+                DRM_ERROR("Invalid indx_buffer reg address %08X\n", cmd[1]);
+                return DRM_ERR(EINVAL);
+        }
+        ret = r300_check_offset(dev_priv, cmd[2]);
+        if (ret) {
+                DRM_ERROR("Invalid indx_buffer offset is %08X\n", cmd[2]);
+                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)
 {
@@ -578,10 +608,11 @@ static __inline__ int r300_emit_raw_packet3(drm_radeon_private_t *dev_priv,
         case RADEON_CNTL_BITBLT_MULTI:
                 return r300_emit_bitblt_multi(dev_priv, cmdbuf);
 
+        case RADEON_CP_INDX_BUFFER:     /* DRAW_INDX_2 without INDX_BUFFER seems to lock up the gpu */
+                return r300_emit_indx_buffer(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 */
-        case RADEON_CP_INDX_BUFFER:     /* DRAW_INDX_2 without INDX_BUFFER seems to lock up the gpu */
         case RADEON_WAIT_FOR_IDLE:
         case RADEON_CP_NOP:
                 /* these packets are safe */
diff --git a/drivers/char/drm/radeon_cp.c b/drivers/char/drm/radeon_cp.c
index 5ad43ba7b5aa..5ed965688293 100644
--- a/drivers/char/drm/radeon_cp.c
+++ b/drivers/char/drm/radeon_cp.c
@@ -864,13 +864,13 @@ static int radeon_do_pixcache_flush(drm_radeon_private_t * dev_priv)
 
         dev_priv->stats.boxes |= RADEON_BOX_WAIT_IDLE;
 
-        tmp = RADEON_READ(RADEON_RB2D_DSTCACHE_CTLSTAT);
-        tmp |= RADEON_RB2D_DC_FLUSH_ALL;
-        RADEON_WRITE(RADEON_RB2D_DSTCACHE_CTLSTAT, tmp);
+        tmp = RADEON_READ(RADEON_RB3D_DSTCACHE_CTLSTAT);
+        tmp |= RADEON_RB3D_DC_FLUSH_ALL;
+        RADEON_WRITE(RADEON_RB3D_DSTCACHE_CTLSTAT, tmp);
 
         for (i = 0; i < dev_priv->usec_timeout; i++) {
-                if (!(RADEON_READ(RADEON_RB2D_DSTCACHE_CTLSTAT)
-                      & RADEON_RB2D_DC_BUSY)) {
+                if (!(RADEON_READ(RADEON_RB3D_DSTCACHE_CTLSTAT)
+                      & RADEON_RB3D_DC_BUSY)) {
                         return 0;
                 }
                 DRM_UDELAY(1);
@@ -1130,7 +1130,7 @@ static void radeon_cp_init_ring_buffer(drm_device_t * dev,
                              | (dev_priv->fb_location >> 16));
 
 #if __OS_HAS_AGP
-        if (dev_priv->flags & CHIP_IS_AGP) {
+        if (dev_priv->flags & RADEON_IS_AGP) {
                 RADEON_WRITE(RADEON_AGP_BASE, (unsigned int)dev->agp->base);
                 RADEON_WRITE(RADEON_MC_AGP_LOCATION,
                              (((dev_priv->gart_vm_start - 1 +
@@ -1158,7 +1158,7 @@ static void radeon_cp_init_ring_buffer(drm_device_t * dev,
         dev_priv->ring.tail = cur_read_ptr;
 
 #if __OS_HAS_AGP
-        if (dev_priv->flags & CHIP_IS_AGP) {
+        if (dev_priv->flags & RADEON_IS_AGP) {
                 RADEON_WRITE(RADEON_CP_RB_RPTR_ADDR,
                              dev_priv->ring_rptr->offset
                              - dev->agp->base + dev_priv->gart_vm_start);
@@ -1258,6 +1258,13 @@ static void radeon_test_writeback(drm_radeon_private_t * dev_priv)
                 dev_priv->writeback_works = 0;
                 DRM_INFO("writeback forced off\n");
         }
+
+        if (!dev_priv->writeback_works) {
+                /* Disable writeback to avoid unnecessary bus master transfer */
+                RADEON_WRITE(RADEON_CP_RB_CNTL, RADEON_READ(RADEON_CP_RB_CNTL) |
+                             RADEON_RB_NO_UPDATE);
+                RADEON_WRITE(RADEON_SCRATCH_UMSK, 0);
+        }
 }
 
 /* Enable or disable PCI-E GART on the chip */
@@ -1295,7 +1302,7 @@ static void radeon_set_pcigart(drm_radeon_private_t * dev_priv, int on)
 {
         u32 tmp;
 
-        if (dev_priv->flags & CHIP_IS_PCIE) {
+        if (dev_priv->flags & RADEON_IS_PCIE) {
                 radeon_set_pciegart(dev_priv, on);
                 return;
         }
@@ -1333,20 +1340,22 @@ static int radeon_do_init_cp(drm_device_t * dev, drm_radeon_init_t * init)
         DRM_DEBUG("\n");
 
         /* if we require new memory map but we don't have it fail */
-        if ((dev_priv->flags & CHIP_NEW_MEMMAP) && !dev_priv->new_memmap)
-        {
-                DRM_ERROR("Cannot initialise DRM on this card\nThis card requires a new X.org DDX\n");
+        if ((dev_priv->flags & RADEON_NEW_MEMMAP) && !dev_priv->new_memmap) {
+                DRM_ERROR("Cannot initialise DRM on this card\nThis card requires a new X.org DDX for 3D\n");
                 radeon_do_cleanup_cp(dev);
                 return DRM_ERR(EINVAL);
         }
 
-        if (init->is_pci && (dev_priv->flags & CHIP_IS_AGP))
-        {
+        if (init->is_pci && (dev_priv->flags & RADEON_IS_AGP)) {
                 DRM_DEBUG("Forcing AGP card to PCI mode\n");
-                dev_priv->flags &= ~CHIP_IS_AGP;
+                dev_priv->flags &= ~RADEON_IS_AGP;
+        } else if (!(dev_priv->flags & (RADEON_IS_AGP | RADEON_IS_PCI | RADEON_IS_PCIE))
+                   && !init->is_pci) {
+                DRM_DEBUG("Restoring AGP flag\n");
+                dev_priv->flags |= RADEON_IS_AGP;
         }
 
-        if ((!(dev_priv->flags & CHIP_IS_AGP)) && !dev->sg) {
+        if ((!(dev_priv->flags & RADEON_IS_AGP)) && !dev->sg) {
                 DRM_ERROR("PCI GART memory not allocated!\n");
                 radeon_do_cleanup_cp(dev);
                 return DRM_ERR(EINVAL);
@@ -1489,7 +1498,7 @@ static int radeon_do_init_cp(drm_device_t * dev, drm_radeon_init_t * init)
                                     init->sarea_priv_offset);
 
 #if __OS_HAS_AGP
-        if (dev_priv->flags & CHIP_IS_AGP) {
+        if (dev_priv->flags & RADEON_IS_AGP) {
                 drm_core_ioremap(dev_priv->cp_ring, dev);
                 drm_core_ioremap(dev_priv->ring_rptr, dev);
                 drm_core_ioremap(dev->agp_buffer_map, dev);
@@ -1548,7 +1557,7 @@ static int radeon_do_init_cp(drm_device_t * dev, drm_radeon_init_t * init)
                  * align it down.
                  */
 #if __OS_HAS_AGP
-                if (dev_priv->flags & CHIP_IS_AGP) {
+                if (dev_priv->flags & RADEON_IS_AGP) {
                         base = dev->agp->base;
                         /* Check if valid */
                         if ((base + dev_priv->gart_size) > dev_priv->fb_location &&
@@ -1578,7 +1587,7 @@ static int radeon_do_init_cp(drm_device_t * dev, drm_radeon_init_t * init)
         }
 
 #if __OS_HAS_AGP
-        if (dev_priv->flags & CHIP_IS_AGP)
+        if (dev_priv->flags & RADEON_IS_AGP)
                 dev_priv->gart_buffers_offset = (dev->agp_buffer_map->offset
                                                  - dev->agp->base
                                                  + dev_priv->gart_vm_start);
@@ -1604,7 +1613,7 @@ static int radeon_do_init_cp(drm_device_t * dev, drm_radeon_init_t * init)
         dev_priv->ring.high_mark = RADEON_RING_HIGH_MARK;
 
 #if __OS_HAS_AGP
-        if (dev_priv->flags & CHIP_IS_AGP) {
+        if (dev_priv->flags & RADEON_IS_AGP) {
                 /* Turn off PCI GART */
                 radeon_set_pcigart(dev_priv, 0);
         } else
@@ -1624,7 +1633,7 @@ static int radeon_do_init_cp(drm_device_t * dev, drm_radeon_init_t * init)
                             dev_priv->gart_info.mapping.handle;
 
                         dev_priv->gart_info.is_pcie =
-                            !!(dev_priv->flags & CHIP_IS_PCIE);
+                            !!(dev_priv->flags & RADEON_IS_PCIE);
                         dev_priv->gart_info.gart_table_location =
                             DRM_ATI_GART_FB;
 
@@ -1636,7 +1645,7 @@ static int radeon_do_init_cp(drm_device_t * dev, drm_radeon_init_t * init)
                             DRM_ATI_GART_MAIN;
                         dev_priv->gart_info.addr = NULL;
                         dev_priv->gart_info.bus_addr = 0;
-                        if (dev_priv->flags & CHIP_IS_PCIE) {
+                        if (dev_priv->flags & RADEON_IS_PCIE) {
                                 DRM_ERROR
                                     ("Cannot use PCI Express without GART in FB memory\n");
                                 radeon_do_cleanup_cp(dev);
@@ -1678,7 +1687,7 @@ static int radeon_do_cleanup_cp(drm_device_t * dev)
                 drm_irq_uninstall(dev);
 
 #if __OS_HAS_AGP
-        if (dev_priv->flags & CHIP_IS_AGP) {
+        if (dev_priv->flags & RADEON_IS_AGP) {
                 if (dev_priv->cp_ring != NULL) {
                         drm_core_ioremapfree(dev_priv->cp_ring, dev);
                         dev_priv->cp_ring = NULL;
@@ -1733,7 +1742,7 @@ static int radeon_do_resume_cp(drm_device_t * dev)
         DRM_DEBUG("Starting radeon_do_resume_cp()\n");
 
 #if __OS_HAS_AGP
-        if (dev_priv->flags & CHIP_IS_AGP) {
+        if (dev_priv->flags & RADEON_IS_AGP) {
                 /* Turn off PCI GART */
                 radeon_set_pcigart(dev_priv, 0);
         } else
@@ -2177,13 +2186,15 @@ int radeon_driver_load(struct drm_device *dev, unsigned long flags)
         dev->dev_private = (void *)dev_priv;
         dev_priv->flags = flags;
 
-        switch (flags & CHIP_FAMILY_MASK) {
+        switch (flags & RADEON_FAMILY_MASK) {
         case CHIP_R100:
         case CHIP_RV200:
         case CHIP_R200:
         case CHIP_R300:
+        case CHIP_R350:
         case CHIP_R420:
-                dev_priv->flags |= CHIP_HAS_HIERZ;
+        case CHIP_RV410:
+                dev_priv->flags |= RADEON_HAS_HIERZ;
                 break;
         default:
                 /* all other chips have no hierarchical z buffer */
@@ -2191,13 +2202,14 @@ int radeon_driver_load(struct drm_device *dev, unsigned long flags)
         }
 
         if (drm_device_is_agp(dev))
-                dev_priv->flags |= CHIP_IS_AGP;
-
-        if (drm_device_is_pcie(dev))
-                dev_priv->flags |= CHIP_IS_PCIE;
+                dev_priv->flags |= RADEON_IS_AGP;
+        else if (drm_device_is_pcie(dev))
+                dev_priv->flags |= RADEON_IS_PCIE;
+        else
+                dev_priv->flags |= RADEON_IS_PCI;
 
         DRM_DEBUG("%s card detected\n",
-                  ((dev_priv->flags & CHIP_IS_AGP) ? "AGP" : (((dev_priv->flags & CHIP_IS_PCIE) ? "PCIE" : "PCI"))));
+                  ((dev_priv->flags & RADEON_IS_AGP) ? "AGP" : (((dev_priv->flags & RADEON_IS_PCIE) ? "PCIE" : "PCI"))));
         return ret;
 }
 
diff --git a/drivers/char/drm/radeon_drv.c b/drivers/char/drm/radeon_drv.c
index eb985c2a31e9..2eb652ec6745 100644
--- a/drivers/char/drm/radeon_drv.c
+++ b/drivers/char/drm/radeon_drv.c
@@ -44,7 +44,7 @@ module_param_named(no_wb, radeon_no_wb, int, 0444);
 static int dri_library_name(struct drm_device *dev, char *buf)
 {
         drm_radeon_private_t *dev_priv = dev->dev_private;
-        int family = dev_priv->flags & CHIP_FAMILY_MASK;
+        int family = dev_priv->flags & RADEON_FAMILY_MASK;
 
         return snprintf(buf, PAGE_SIZE, "%s\n",
                         (family < CHIP_R200) ? "radeon" :
diff --git a/drivers/char/drm/radeon_drv.h b/drivers/char/drm/radeon_drv.h
index e5a256f5429c..f45cd7f147a5 100644
--- a/drivers/char/drm/radeon_drv.h
+++ b/drivers/char/drm/radeon_drv.h
@@ -133,15 +133,16 @@ enum radeon_cp_microcode_version {
  * Chip flags
  */
 enum radeon_chip_flags {
-        CHIP_FAMILY_MASK = 0x0000ffffUL,
-        CHIP_FLAGS_MASK = 0xffff0000UL,
-        CHIP_IS_MOBILITY = 0x00010000UL,
-        CHIP_IS_IGP = 0x00020000UL,
-        CHIP_SINGLE_CRTC = 0x00040000UL,
-        CHIP_IS_AGP = 0x00080000UL,
-        CHIP_HAS_HIERZ = 0x00100000UL,
-        CHIP_IS_PCIE = 0x00200000UL,
-        CHIP_NEW_MEMMAP = 0x00400000UL,
+        RADEON_FAMILY_MASK = 0x0000ffffUL,
+        RADEON_FLAGS_MASK = 0xffff0000UL,
+        RADEON_IS_MOBILITY = 0x00010000UL,
+        RADEON_IS_IGP = 0x00020000UL,
+        RADEON_SINGLE_CRTC = 0x00040000UL,
+        RADEON_IS_AGP = 0x00080000UL,
+        RADEON_HAS_HIERZ = 0x00100000UL,
+        RADEON_IS_PCIE = 0x00200000UL,
+        RADEON_NEW_MEMMAP = 0x00400000UL,
+        RADEON_IS_PCI = 0x00800000UL,
 };
 
 #define GET_RING_HEAD(dev_priv) (dev_priv->writeback_works ? \
@@ -424,6 +425,8 @@ extern int r300_do_cp_cmdbuf(drm_device_t * dev, DRMFILE filp,
 #define RADEON_RB3D_COLOROFFSET         0x1c40
 #define RADEON_RB3D_COLORPITCH          0x1c48
 
+#define RADEON_SRC_X_Y                  0x1590
+
 #define RADEON_DP_GUI_MASTER_CNTL       0x146c
 #       define RADEON_GMC_SRC_PITCH_OFFSET_CNTL (1 << 0)
 #       define RADEON_GMC_DST_PITCH_OFFSET_CNTL (1 << 1)
@@ -441,6 +444,7 @@ extern int r300_do_cp_cmdbuf(drm_device_t * dev, DRMFILE filp,
 #       define RADEON_ROP3_S                    0x00cc0000
 #       define RADEON_ROP3_P                    0x00f00000
 #define RADEON_DP_WRITE_MASK            0x16cc
+#define RADEON_SRC_PITCH_OFFSET         0x1428
 #define RADEON_DST_PITCH_OFFSET         0x142c
 #define RADEON_DST_PITCH_OFFSET_C       0x1c80
 #       define RADEON_DST_TILE_LINEAR           (0 << 30)
@@ -545,6 +549,11 @@ extern int r300_do_cp_cmdbuf(drm_device_t * dev, DRMFILE filp,
 #       define RADEON_RB3D_ZC_FREE              (1 << 2)
 #       define RADEON_RB3D_ZC_FLUSH_ALL         0x5
 #       define RADEON_RB3D_ZC_BUSY              (1 << 31)
+#define RADEON_RB3D_DSTCACHE_CTLSTAT    0x325c
+#       define RADEON_RB3D_DC_FLUSH             (3 << 0)
+#       define RADEON_RB3D_DC_FREE              (3 << 2)
+#       define RADEON_RB3D_DC_FLUSH_ALL         0xf
+#       define RADEON_RB3D_DC_BUSY              (1 << 31)
 #define RADEON_RB3D_ZSTENCILCNTL        0x1c2c
 #       define RADEON_Z_TEST_MASK               (7 << 4)
 #       define RADEON_Z_TEST_ALWAYS             (7 << 4)
@@ -681,6 +690,7 @@ extern int r300_do_cp_cmdbuf(drm_device_t * dev, DRMFILE filp,
 #define RADEON_CP_RB_BASE               0x0700
 #define RADEON_CP_RB_CNTL               0x0704
 #       define RADEON_BUF_SWAP_32BIT            (2 << 16)
+#       define RADEON_RB_NO_UPDATE              (1 << 27)
 #define RADEON_CP_RB_RPTR_ADDR          0x070c
 #define RADEON_CP_RB_RPTR               0x0710
 #define RADEON_CP_RB_WPTR               0x0714
@@ -986,13 +996,13 @@ do {									\
 } while (0)
 
 #define RADEON_FLUSH_CACHE() do {                                       \
-        OUT_RING( CP_PACKET0( RADEON_RB2D_DSTCACHE_CTLSTAT, 0 ) );      \
-        OUT_RING( RADEON_RB2D_DC_FLUSH );                               \
+        OUT_RING( CP_PACKET0( RADEON_RB3D_DSTCACHE_CTLSTAT, 0 ) );      \
+        OUT_RING( RADEON_RB3D_DC_FLUSH );                               \
 } while (0)
 
 #define RADEON_PURGE_CACHE() do {                                       \
-        OUT_RING( CP_PACKET0( RADEON_RB2D_DSTCACHE_CTLSTAT, 0 ) );      \
-        OUT_RING( RADEON_RB2D_DC_FLUSH_ALL );                           \
+        OUT_RING( CP_PACKET0( RADEON_RB3D_DSTCACHE_CTLSTAT, 0 ) );      \
+        OUT_RING( RADEON_RB3D_DC_FLUSH_ALL );                           \
 } while (0)
 
 #define RADEON_FLUSH_ZCACHE() do {                                      \
diff --git a/drivers/char/drm/radeon_ioc32.c b/drivers/char/drm/radeon_ioc32.c
index 0ccfd3618ff1..1f1f9cc055a4 100644
--- a/drivers/char/drm/radeon_ioc32.c
+++ b/drivers/char/drm/radeon_ioc32.c
@@ -92,7 +92,7 @@ static int compat_radeon_cp_init(struct file *file, unsigned int cmd,
                           &init->gart_textures_offset))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_RADEON_CP_INIT, (unsigned long)init);
 }
 
@@ -125,7 +125,7 @@ static int compat_radeon_cp_clear(struct file *file, unsigned int cmd,
                           &clr->depth_boxes))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_RADEON_CLEAR, (unsigned long)clr);
 }
 
@@ -149,7 +149,7 @@ static int compat_radeon_cp_stipple(struct file *file, unsigned int cmd,
                           &request->mask))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_RADEON_STIPPLE, (unsigned long)request);
 }
 
@@ -204,7 +204,7 @@ static int compat_radeon_cp_texture(struct file *file, unsigned int cmd,
                           &image->data))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_RADEON_TEXTURE, (unsigned long)request);
 }
 
@@ -238,7 +238,7 @@ static int compat_radeon_cp_vertex2(struct file *file, unsigned int cmd,
                           &request->prim))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_RADEON_VERTEX2, (unsigned long)request);
 }
 
@@ -268,7 +268,7 @@ static int compat_radeon_cp_cmdbuf(struct file *file, unsigned int cmd,
                           &request->boxes))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_RADEON_CMDBUF, (unsigned long)request);
 }
 
@@ -293,7 +293,7 @@ static int compat_radeon_cp_getparam(struct file *file, unsigned int cmd,
                           &request->value))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_RADEON_GETPARAM, (unsigned long)request);
 }
 
@@ -322,7 +322,7 @@ static int compat_radeon_mem_alloc(struct file *file, unsigned int cmd,
                           &request->region_offset))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_RADEON_ALLOC, (unsigned long)request);
 }
 
@@ -345,7 +345,7 @@ static int compat_radeon_irq_emit(struct file *file, unsigned int cmd,
                           &request->irq_seq))
                 return -EFAULT;
 
-        return drm_ioctl(file->f_dentry->d_inode, file,
+        return drm_ioctl(file->f_path.dentry->d_inode, file,
                          DRM_IOCTL_RADEON_IRQ_EMIT, (unsigned long)request);
 }
 
@@ -386,7 +386,7 @@ long radeon_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
         if (fn != NULL)
                 ret = (*fn) (filp, cmd, arg);
         else
-                ret = drm_ioctl(filp->f_dentry->d_inode, filp, cmd, arg);
+                ret = drm_ioctl(filp->f_path.dentry->d_inode, filp, cmd, arg);
         unlock_kernel();
 
         return ret;
diff --git a/drivers/char/drm/radeon_state.c b/drivers/char/drm/radeon_state.c
index 39a7f685e3fd..6e04fdd732ac 100644
--- a/drivers/char/drm/radeon_state.c
+++ b/drivers/char/drm/radeon_state.c
@@ -42,7 +42,11 @@ static __inline__ int radeon_check_and_fixup_offset(drm_radeon_private_t *
                                                     drm_file_t * filp_priv,
                                                     u32 *offset)
 {
-        u32 off = *offset;
+        u64 off = *offset;
+        u32 fb_start = dev_priv->fb_location;
+        u32 fb_end = fb_start + dev_priv->fb_size - 1;
+        u32 gart_start = dev_priv->gart_vm_start;
+        u32 gart_end = gart_start + dev_priv->gart_size - 1;
         struct drm_radeon_driver_file_fields *radeon_priv;
 
         /* Hrm ... the story of the offset ... So this function converts
@@ -62,10 +66,8 @@ static __inline__ int radeon_check_and_fixup_offset(drm_radeon_private_t *
         /* First, the best case, the offset already lands in either the
          * framebuffer or the GART mapped space
          */
-        if ((off >= dev_priv->fb_location &&
-             off < (dev_priv->fb_location + dev_priv->fb_size)) ||
-            (off >= dev_priv->gart_vm_start &&
-             off < (dev_priv->gart_vm_start + dev_priv->gart_size)))
+        if ((off >= fb_start && off <= fb_end) ||
+            (off >= gart_start && off <= gart_end))
                 return 0;
 
         /* Ok, that didn't happen... now check if we have a zero based
@@ -78,16 +80,13 @@ static __inline__ int radeon_check_and_fixup_offset(drm_radeon_private_t *
         }
 
         /* Finally, assume we aimed at a GART offset if beyond the fb */
-        if (off > (dev_priv->fb_location + dev_priv->fb_size))
-                off = off - (dev_priv->fb_location + dev_priv->fb_size) +
-                        dev_priv->gart_vm_start;
+        if (off > fb_end)
+                off = off - fb_end - 1 + gart_start;
 
         /* Now recheck and fail if out of bounds */
-        if ((off >= dev_priv->fb_location &&
-             off < (dev_priv->fb_location + dev_priv->fb_size)) ||
-            (off >= dev_priv->gart_vm_start &&
-             off < (dev_priv->gart_vm_start + dev_priv->gart_size))) {
-                DRM_DEBUG("offset fixed up to 0x%x\n", off);
+        if ((off >= fb_start && off <= fb_end) ||
+            (off >= gart_start && off <= gart_end)) {
+                DRM_DEBUG("offset fixed up to 0x%x\n", (unsigned int)off);
                 *offset = off;
                 return 0;
         }
@@ -276,6 +275,8 @@ static __inline__ int radeon_check_and_fixup_packet3(drm_radeon_private_t *
                                                      unsigned int *cmdsz)
 {
         u32 *cmd = (u32 *) cmdbuf->buf;
+        u32 offset, narrays;
+        int count, i, k;
 
         *cmdsz = 2 + ((cmd[0] & RADEON_CP_PACKET_COUNT_MASK) >> 16);
 
@@ -289,10 +290,106 @@ static __inline__ int radeon_check_and_fixup_packet3(drm_radeon_private_t *
                 return DRM_ERR(EINVAL);
         }
 
-        /* Check client state and fix it up if necessary */
-        if (cmd[0] & 0x8000) {  /* MSB of opcode: next DWORD GUI_CNTL */
-                u32 offset;
+        switch(cmd[0] & 0xff00) {
+        /* XXX Are there old drivers needing other packets? */
 
+        case RADEON_3D_DRAW_IMMD:
+        case RADEON_3D_DRAW_VBUF:
+        case RADEON_3D_DRAW_INDX:
+        case RADEON_WAIT_FOR_IDLE:
+        case RADEON_CP_NOP:
+        case RADEON_3D_CLEAR_ZMASK:
+/*      case RADEON_CP_NEXT_CHAR:
+        case RADEON_CP_PLY_NEXTSCAN:
+        case RADEON_CP_SET_SCISSORS: */ /* probably safe but will never need them? */
+                /* these packets are safe */
+                break;
+
+        case RADEON_CP_3D_DRAW_IMMD_2:
+        case RADEON_CP_3D_DRAW_VBUF_2:
+        case RADEON_CP_3D_DRAW_INDX_2:
+        case RADEON_3D_CLEAR_HIZ:
+                /* safe but r200 only */
+                if (dev_priv->microcode_version != UCODE_R200) {
+                        DRM_ERROR("Invalid 3d packet for r100-class chip\n");
+                        return DRM_ERR(EINVAL);
+                }
+                break;
+
+        case RADEON_3D_LOAD_VBPNTR:
+                count = (cmd[0] >> 16) & 0x3fff;
+
+                if (count > 18) { /* 12 arrays max */
+                        DRM_ERROR("Too large payload in 3D_LOAD_VBPNTR (count=%d)\n",
+                                  count);
+                        return DRM_ERR(EINVAL);
+                }
+
+                /* carefully check packet contents */
+                narrays = cmd[1] & ~0xc000;
+                k = 0;
+                i = 2;
+                while ((k < narrays) && (i < (count + 2))) {
+                        i++;            /* skip attribute field */
+                        if (radeon_check_and_fixup_offset(dev_priv, filp_priv, &cmd[i])) {
+                                DRM_ERROR
+                                    ("Invalid offset (k=%d i=%d) in 3D_LOAD_VBPNTR packet.\n",
+                                     k, i);
+                                return DRM_ERR(EINVAL);
+                        }
+                        k++;
+                        i++;
+                        if (k == narrays)
+                                break;
+                        /* have one more to process, they come in pairs */
+                        if (radeon_check_and_fixup_offset(dev_priv, filp_priv, &cmd[i])) {
+                                DRM_ERROR
+                                    ("Invalid offset (k=%d i=%d) in 3D_LOAD_VBPNTR packet.\n",
+                                     k, i);
+                                return DRM_ERR(EINVAL);
+                        }
+                        k++;
+                        i++;
+                }
+                /* do the counts match what we expect ? */
+                if ((k != narrays) || (i != (count + 2))) {
+                        DRM_ERROR
+                            ("Malformed 3D_LOAD_VBPNTR packet (k=%d i=%d narrays=%d count+1=%d).\n",
+                              k, i, narrays, count + 1);
+                        return DRM_ERR(EINVAL);
+                }
+                break;
+
+        case RADEON_3D_RNDR_GEN_INDX_PRIM:
+                if (dev_priv->microcode_version != UCODE_R100) {
+                        DRM_ERROR("Invalid 3d packet for r200-class chip\n");
+                        return DRM_ERR(EINVAL);
+                }
+                if (radeon_check_and_fixup_offset(dev_priv, filp_priv, &cmd[1])) {
+                                DRM_ERROR("Invalid rndr_gen_indx offset\n");
+                                return DRM_ERR(EINVAL);
+                }
+                break;
+
+        case RADEON_CP_INDX_BUFFER:
+                if (dev_priv->microcode_version != UCODE_R200) {
+                        DRM_ERROR("Invalid 3d packet for r100-class chip\n");
+                        return DRM_ERR(EINVAL);
+                }
+                if ((cmd[1] & 0x8000ffff) != 0x80000810) {
+                        DRM_ERROR("Invalid indx_buffer reg address %08X\n", cmd[1]);
+                        return DRM_ERR(EINVAL);
+                }
+                if (radeon_check_and_fixup_offset(dev_priv, filp_priv, &cmd[2])) {
+                        DRM_ERROR("Invalid indx_buffer offset is %08X\n", cmd[2]);
+                        return DRM_ERR(EINVAL);
+                }
+                break;
+
+        case RADEON_CNTL_HOSTDATA_BLT:
+        case RADEON_CNTL_PAINT_MULTI:
+        case RADEON_CNTL_BITBLT_MULTI:
+                /* MSB of opcode: next DWORD GUI_CNTL */
                 if (cmd[1] & (RADEON_GMC_SRC_PITCH_OFFSET_CNTL
                               | RADEON_GMC_DST_PITCH_OFFSET_CNTL)) {
                         offset = cmd[2] << 10;
@@ -314,6 +411,11 @@ static __inline__ int radeon_check_and_fixup_packet3(drm_radeon_private_t *
                         }
                         cmd[3] = (cmd[3] & 0xffc00000) | offset >> 10;
                 }
+                break;
+
+        default:
+                DRM_ERROR("Invalid packet type %x\n", cmd[0] & 0xff00);
+                return DRM_ERR(EINVAL);
         }
 
         return 0;
@@ -869,7 +971,7 @@ static void radeon_cp_dispatch_clear(drm_device_t * dev,
                  */
                 dev_priv->sarea_priv->ctx_owner = 0;
 
-                if ((dev_priv->flags & CHIP_HAS_HIERZ)
+                if ((dev_priv->flags & RADEON_HAS_HIERZ)
                     && (flags & RADEON_USE_HIERZ)) {
                         /* FIXME : reverse engineer that for Rx00 cards */
                         /* FIXME : the mask supposedly contains low-res z values. So can't set
@@ -914,7 +1016,7 @@ static void radeon_cp_dispatch_clear(drm_device_t * dev,
                 for (i = 0; i < nbox; i++) {
                         int tileoffset, nrtilesx, nrtilesy, j;
                         /* it looks like r200 needs rv-style clears, at least if hierz is not enabled? */
-                        if ((dev_priv->flags & CHIP_HAS_HIERZ)
+                        if ((dev_priv->flags & RADEON_HAS_HIERZ)
                             && !(dev_priv->microcode_version == UCODE_R200)) {
                                 /* FIXME : figure this out for r200 (when hierz is enabled). Or
                                    maybe r200 actually doesn't need to put the low-res z value into
@@ -998,7 +1100,7 @@ static void radeon_cp_dispatch_clear(drm_device_t * dev,
                 }
 
                 /* TODO don't always clear all hi-level z tiles */
-                if ((dev_priv->flags & CHIP_HAS_HIERZ)
+                if ((dev_priv->flags & RADEON_HAS_HIERZ)
                     && (dev_priv->microcode_version == UCODE_R200)
                     && (flags & RADEON_USE_HIERZ))
                         /* r100 and cards without hierarchical z-buffer have no high-level z-buffer */
@@ -1270,9 +1372,9 @@ static void radeon_cp_dispatch_swap(drm_device_t * dev)
 
                 DRM_DEBUG("dispatch swap %d,%d-%d,%d\n", x, y, w, h);
 
-                BEGIN_RING(7);
+                BEGIN_RING(9);
 
-                OUT_RING(CP_PACKET3(RADEON_CNTL_BITBLT_MULTI, 5));
+                OUT_RING(CP_PACKET0(RADEON_DP_GUI_MASTER_CNTL, 0));
                 OUT_RING(RADEON_GMC_SRC_PITCH_OFFSET_CNTL |
                          RADEON_GMC_DST_PITCH_OFFSET_CNTL |
                          RADEON_GMC_BRUSH_NONE |
@@ -1284,6 +1386,7 @@ static void radeon_cp_dispatch_swap(drm_device_t * dev)
 
                 /* Make this work even if front & back are flipped:
                  */
+                OUT_RING(CP_PACKET0(RADEON_SRC_PITCH_OFFSET, 1));
                 if (dev_priv->current_page == 0) {
                         OUT_RING(dev_priv->back_pitch_offset);
                         OUT_RING(dev_priv->front_pitch_offset);
@@ -1292,6 +1395,7 @@ static void radeon_cp_dispatch_swap(drm_device_t * dev)
                         OUT_RING(dev_priv->back_pitch_offset);
                 }
 
+                OUT_RING(CP_PACKET0(RADEON_SRC_X_Y, 2));
                 OUT_RING((x << 16) | y);
                 OUT_RING((x << 16) | y);
                 OUT_RING((w << 16) | h);
@@ -2987,16 +3091,21 @@ static int radeon_cp_getparam(DRM_IOCTL_ARGS)
         case RADEON_PARAM_GART_TEX_HANDLE:
                 value = dev_priv->gart_textures_offset;
                 break;
-        
+        case RADEON_PARAM_SCRATCH_OFFSET:
+                if (!dev_priv->writeback_works)
+                        return DRM_ERR(EINVAL);
+                value = RADEON_SCRATCH_REG_OFFSET;
+                break;
         case RADEON_PARAM_CARD_TYPE:
-                if (dev_priv->flags & CHIP_IS_PCIE)
+                if (dev_priv->flags & RADEON_IS_PCIE)
                         value = RADEON_CARD_PCIE;
-                else if (dev_priv->flags & CHIP_IS_AGP)
+                else if (dev_priv->flags & RADEON_IS_AGP)
                         value = RADEON_CARD_AGP;
                 else
                         value = RADEON_CARD_PCI;
                 break;
         default:
+                DRM_DEBUG("Invalid parameter %d\n", param.param);
                 return DRM_ERR(EINVAL);
         }
 
diff --git a/drivers/char/drm/savage_bci.c b/drivers/char/drm/savage_bci.c
index 59c7520bf9a2..a9a84f88df5e 100644
--- a/drivers/char/drm/savage_bci.c
+++ b/drivers/char/drm/savage_bci.c
@@ -728,6 +728,7 @@ static int savage_do_init_bci(drm_device_t * dev, drm_savage_init_t * init)
                 dev_priv->status = NULL;
         }
         if (dev_priv->dma_type == SAVAGE_DMA_AGP && init->buffers_offset) {
+                dev->agp_buffer_token = init->buffers_offset;
                 dev->agp_buffer_map = drm_core_findmap(dev,
                                                        init->buffers_offset);
                 if (!dev->agp_buffer_map) {
diff --git a/drivers/char/drm/savage_state.c b/drivers/char/drm/savage_state.c
index ef2581d16146..1ca1e9cb5a33 100644
--- a/drivers/char/drm/savage_state.c
+++ b/drivers/char/drm/savage_state.c
@@ -994,7 +994,7 @@ int savage_bci_cmdbuf(DRM_IOCTL_ARGS)
         if (cmdbuf.size) {
                 kcmd_addr = drm_alloc(cmdbuf.size * 8, DRM_MEM_DRIVER);
                 if (kcmd_addr == NULL)
-                        return ENOMEM;
+                        return DRM_ERR(ENOMEM);
 
                 if (DRM_COPY_FROM_USER(kcmd_addr, cmdbuf.cmd_addr,
                                        cmdbuf.size * 8))
diff --git a/drivers/char/drm/sis_drv.c b/drivers/char/drm/sis_drv.c
index 5e9dc86f2956..3d5b3218b6ff 100644
--- a/drivers/char/drm/sis_drv.c
+++ b/drivers/char/drm/sis_drv.c
@@ -35,11 +35,44 @@ static struct pci_device_id pciidlist[] = {
         sisdrv_PCI_IDS
 };
 
+static int sis_driver_load(drm_device_t *dev, unsigned long chipset)
+{
+        drm_sis_private_t *dev_priv;
+        int ret;
+
+        dev_priv = drm_calloc(1, sizeof(drm_sis_private_t), DRM_MEM_DRIVER);
+        if (dev_priv == NULL)
+                return DRM_ERR(ENOMEM);
+
+        dev->dev_private = (void *)dev_priv;
+        dev_priv->chipset = chipset;
+        ret = drm_sman_init(&dev_priv->sman, 2, 12, 8);
+        if (ret) {
+                drm_free(dev_priv, sizeof(dev_priv), DRM_MEM_DRIVER);
+        }
+
+        return ret;
+}
+
+static int sis_driver_unload(drm_device_t *dev)
+{
+        drm_sis_private_t *dev_priv = dev->dev_private;
+
+        drm_sman_takedown(&dev_priv->sman);
+        drm_free(dev_priv, sizeof(*dev_priv), DRM_MEM_DRIVER);
+
+        return 0;
+}
+
 static struct drm_driver driver = {
         .driver_features = DRIVER_USE_AGP | DRIVER_USE_MTRR,
-        .context_ctor = sis_init_context,
-        .context_dtor = sis_final_context,
-        .reclaim_buffers = drm_core_reclaim_buffers,
+        .load = sis_driver_load,
+        .unload = sis_driver_unload,
+        .context_dtor = NULL,
+        .dma_quiescent = sis_idle,
+        .reclaim_buffers = NULL,
+        .reclaim_buffers_locked = sis_reclaim_buffers_locked,
+        .lastclose = sis_lastclose,
         .get_map_ofs = drm_core_get_map_ofs,
         .get_reg_ofs = drm_core_get_reg_ofs,
         .ioctls = sis_ioctls,
diff --git a/drivers/char/drm/sis_drv.h b/drivers/char/drm/sis_drv.h
index e218e5269503..2b8d6f6ed7c0 100644
--- a/drivers/char/drm/sis_drv.h
+++ b/drivers/char/drm/sis_drv.h
@@ -31,23 +31,39 @@
 /* General customization:
  */
 
-#define DRIVER_AUTHOR           "SIS"
+#define DRIVER_AUTHOR           "SIS, Tungsten Graphics"
 #define DRIVER_NAME             "sis"
 #define DRIVER_DESC             "SIS 300/630/540"
-#define DRIVER_DATE             "20030826"
+#define DRIVER_DATE             "20060704"
 #define DRIVER_MAJOR            1
-#define DRIVER_MINOR            1
-#define DRIVER_PATCHLEVEL       0
+#define DRIVER_MINOR            2
+#define DRIVER_PATCHLEVEL       1
 
-#include "sis_ds.h"
+enum sis_family {
+        SIS_OTHER = 0,
+        SIS_CHIP_315 = 1,
+};
+
+#include "drm_sman.h"
+
+#define SIS_BASE (dev_priv->mmio)
+#define SIS_READ(reg)         DRM_READ32(SIS_BASE, reg);
+#define SIS_WRITE(reg, val)   DRM_WRITE32(SIS_BASE, reg, val);
 
 typedef struct drm_sis_private {
-        memHeap_t *AGPHeap;
-        memHeap_t *FBHeap;
+        drm_local_map_t *mmio;
+        unsigned int idle_fault;
+        drm_sman_t sman;
+        unsigned int chipset;
+        int vram_initialized;
+        int agp_initialized;
+        unsigned long vram_offset;
+        unsigned long agp_offset;
 } drm_sis_private_t;
 
-extern int sis_init_context(drm_device_t * dev, int context);
-extern int sis_final_context(drm_device_t * dev, int context);
+extern int sis_idle(drm_device_t *dev);
+extern void sis_reclaim_buffers_locked(drm_device_t *dev, struct file *filp);
+extern void sis_lastclose(drm_device_t *dev);
 
 extern drm_ioctl_desc_t sis_ioctls[];
 extern int sis_max_ioctl;
diff --git a/drivers/char/drm/sis_ds.c b/drivers/char/drm/sis_ds.c
deleted file mode 100644
index 2e485d482943..000000000000
--- a/drivers/char/drm/sis_ds.c
+++ /dev/null
@@ -1,299 +0,0 @@
-/* sis_ds.c -- Private header for Direct Rendering Manager -*- linux-c -*-
- * Created: Mon Jan  4 10:05:05 1999 by sclin@sis.com.tw
- *
- * Copyright 2000 Silicon Integrated Systems Corp, Inc., HsinChu, Taiwan.
- * All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- *    Sung-Ching Lin <sclin@sis.com.tw>
- *
- */
-
-#include "drmP.h"
-#include "drm.h"
-#include "sis_ds.h"
-
-/* Set Data Structure, not check repeated value
- * temporarily used
- */
-
-set_t *setInit(void)
-{
-        int i;
-        set_t *set;
-
-        set = (set_t *) drm_alloc(sizeof(set_t), DRM_MEM_DRIVER);
-        if (set != NULL) {
-                for (i = 0; i < SET_SIZE; i++) {
-                        set->list[i].free_next = i + 1;
-                        set->list[i].alloc_next = -1;
-                }
-                set->list[SET_SIZE - 1].free_next = -1;
-                set->free = 0;
-                set->alloc = -1;
-                set->trace = -1;
-        }
-        return set;
-}
-
-int setAdd(set_t * set, ITEM_TYPE item)
-{
-        int free = set->free;
-
-        if (free != -1) {
-                set->list[free].val = item;
-                set->free = set->list[free].free_next;
-        } else {
-                return 0;
-        }
-
-        set->list[free].alloc_next = set->alloc;
-        set->alloc = free;
-        set->list[free].free_next = -1;
-
-        return 1;
-}
-
-int setDel(set_t * set, ITEM_TYPE item)
-{
-        int alloc = set->alloc;
-        int prev = -1;
-
-        while (alloc != -1) {
-                if (set->list[alloc].val == item) {
-                        if (prev != -1)
-                                set->list[prev].alloc_next =
-                                    set->list[alloc].alloc_next;
-                        else
-                                set->alloc = set->list[alloc].alloc_next;
-                        break;
-                }
-                prev = alloc;
-                alloc = set->list[alloc].alloc_next;
-        }
-
-        if (alloc == -1)
-                return 0;
-
-        set->list[alloc].free_next = set->free;
-        set->free = alloc;
-        set->list[alloc].alloc_next = -1;
-
-        return 1;
-}
-
-/* setFirst -> setAdd -> setNext is wrong */
-
-int setFirst(set_t * set, ITEM_TYPE * item)
-{
-        if (set->alloc == -1)
-                return 0;
-
-        *item = set->list[set->alloc].val;
-        set->trace = set->list[set->alloc].alloc_next;
-
-        return 1;
-}
-
-int setNext(set_t * set, ITEM_TYPE * item)
-{
-        if (set->trace == -1)
-                return 0;
-
-        *item = set->list[set->trace].val;
-        set->trace = set->list[set->trace].alloc_next;
-
-        return 1;
-}
-
-int setDestroy(set_t * set)
-{
-        drm_free(set, sizeof(set_t), DRM_MEM_DRIVER);
-
-        return 1;
-}
-
-/*
- * GLX Hardware Device Driver common code
- * Copyright (C) 1999 Wittawat Yamwong
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
- * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-
-#define ISFREE(bptr) ((bptr)->free)
-
-memHeap_t *mmInit(int ofs, int size)
-{
-        PMemBlock blocks;
-
-        if (size <= 0)
-                return NULL;
-
-        blocks = (TMemBlock *) drm_calloc(1, sizeof(TMemBlock), DRM_MEM_DRIVER);
-        if (blocks != NULL) {
-                blocks->ofs = ofs;
-                blocks->size = size;
-                blocks->free = 1;
-                return (memHeap_t *) blocks;
-        } else
-                return NULL;
-}
-
-/* Checks if a pointer 'b' is part of the heap 'heap' */
-int mmBlockInHeap(memHeap_t * heap, PMemBlock b)
-{
-        TMemBlock *p;
-
-        if (heap == NULL || b == NULL)
-                return 0;
-
-        p = heap;
-        while (p != NULL && p != b) {
-                p = p->next;
-        }
-        if (p == b)
-                return 1;
-        else
-                return 0;
-}
-
-static TMemBlock *SliceBlock(TMemBlock * p,
-                             int startofs, int size,
-                             int reserved, int alignment)
-{
-        TMemBlock *newblock;
-
-        /* break left */
-        if (startofs > p->ofs) {
-                newblock = (TMemBlock *) drm_calloc(1, sizeof(TMemBlock),
-                                                    DRM_MEM_DRIVER);
-                newblock->ofs = startofs;
-                newblock->size = p->size - (startofs - p->ofs);
-                newblock->free = 1;
-                newblock->next = p->next;
-                p->size -= newblock->size;
-                p->next = newblock;
-                p = newblock;
-        }
-
-        /* break right */
-        if (size < p->size) {
-                newblock = (TMemBlock *) drm_calloc(1, sizeof(TMemBlock),
-                                                    DRM_MEM_DRIVER);
-                newblock->ofs = startofs + size;
-                newblock->size = p->size - size;
-                newblock->free = 1;
-                newblock->next = p->next;
-                p->size = size;
-                p->next = newblock;
-        }
-
-        /* p = middle block */
-        p->align = alignment;
-        p->free = 0;
-        p->reserved = reserved;
-        return p;
-}
-
-PMemBlock mmAllocMem(memHeap_t * heap, int size, int align2, int startSearch)
-{
-        int mask, startofs, endofs;
-        TMemBlock *p;
-
-        if (heap == NULL || align2 < 0 || size <= 0)
-                return NULL;
-
-        mask = (1 << align2) - 1;
-        startofs = 0;
-        p = (TMemBlock *) heap;
-        while (p != NULL) {
-                if (ISFREE(p)) {
-                        startofs = (p->ofs + mask) & ~mask;
-                        if (startofs < startSearch) {
-                                startofs = startSearch;
-                        }
-                        endofs = startofs + size;
-                        if (endofs <= (p->ofs + p->size))
-                                break;
-                }
-                p = p->next;
-        }
-        if (p == NULL)
-                return NULL;
-        p = SliceBlock(p, startofs, size, 0, mask + 1);
-        p->heap = heap;
-        return p;
-}
-
-static __inline__ int Join2Blocks(TMemBlock * p)
-{
-        if (p->free && p->next && p->next->free) {
-                TMemBlock *q = p->next;
-                p->size += q->size;
-                p->next = q->next;
-                drm_free(q, sizeof(TMemBlock), DRM_MEM_DRIVER);
-                return 1;
-        }
-        return 0;
-}
-
-int mmFreeMem(PMemBlock b)
-{
-        TMemBlock *p, *prev;
-
-        if (b == NULL)
-                return 0;
-        if (b->heap == NULL)
-                return -1;
-
-        p = b->heap;
-        prev = NULL;
-        while (p != NULL && p != b) {
-                prev = p;
-                p = p->next;
-        }
-        if (p == NULL || p->free || p->reserved)
-                return -1;
-
-        p->free = 1;
-        Join2Blocks(p);
-        if (prev)
-                Join2Blocks(prev);
-        return 0;
-}
diff --git a/drivers/char/drm/sis_ds.h b/drivers/char/drm/sis_ds.h
deleted file mode 100644
index 94f2b4728b63..000000000000
--- a/drivers/char/drm/sis_ds.h
+++ /dev/null
@@ -1,146 +0,0 @@
-/* sis_ds.h -- Private header for Direct Rendering Manager -*- linux-c -*- 
- * Created: Mon Jan  4 10:05:05 1999 by sclin@sis.com.tw
- */
-/*
- * Copyright 2000 Silicon Integrated Systems Corp, Inc., HsinChu, Taiwan.
- * All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- *    Sung-Ching Lin <sclin@sis.com.tw>
- *
- */
-
-#ifndef __SIS_DS_H__
-#define __SIS_DS_H__
-
-/* Set Data Structure */
-
-#define SET_SIZE 5000
-
-typedef unsigned long ITEM_TYPE;
-
-typedef struct {
-        ITEM_TYPE val;
-        int alloc_next, free_next;
-} list_item_t;
-
-typedef struct {
-        int alloc;
-        int free;
-        int trace;
-        list_item_t list[SET_SIZE];
-} set_t;
-
-set_t *setInit(void);
-int setAdd(set_t * set, ITEM_TYPE item);
-int setDel(set_t * set, ITEM_TYPE item);
-int setFirst(set_t * set, ITEM_TYPE * item);
-int setNext(set_t * set, ITEM_TYPE * item);
-int setDestroy(set_t * set);
-
-/*
- * GLX Hardware Device Driver common code
- * Copyright (C) 1999 Wittawat Yamwong
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
- * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-
-struct mem_block_t {
-        struct mem_block_t *next;
-        struct mem_block_t *heap;
-        int ofs, size;
-        int align;
-        unsigned int free:1;
-        unsigned int reserved:1;
-};
-typedef struct mem_block_t TMemBlock;
-typedef struct mem_block_t *PMemBlock;
-
-/* a heap is just the first block in a chain */
-typedef struct mem_block_t memHeap_t;
-
-static __inline__ int mmBlockSize(PMemBlock b)
-{
-        return b->size;
-}
-
-static __inline__ int mmOffset(PMemBlock b)
-{
-        return b->ofs;
-}
-
-static __inline__ void mmMarkReserved(PMemBlock b)
-{
-        b->reserved = 1;
-}
-
-/*
- * input: total size in bytes
- * return: a heap pointer if OK, NULL if error
- */
-memHeap_t *mmInit(int ofs, int size);
-
-/*
- * Allocate 'size' bytes with 2^align2 bytes alignment,
- * restrict the search to free memory after 'startSearch'
- * depth and back buffers should be in different 4mb banks
- * to get better page hits if possible
- * input:       size = size of block
- *              align2 = 2^align2 bytes alignment
- *              startSearch = linear offset from start of heap to begin search
- * return: pointer to the allocated block, 0 if error
- */
-PMemBlock mmAllocMem(memHeap_t * heap, int size, int align2, int startSearch);
-
-/*
- * Returns 1 if the block 'b' is part of the heap 'heap'
- */
-int mmBlockInHeap(PMemBlock heap, PMemBlock b);
-
-/*
- * Free block starts at offset
- * input: pointer to a block
- * return: 0 if OK, -1 if error
- */
-int mmFreeMem(PMemBlock b);
-
-/* For debuging purpose. */
-void mmDumpMemInfo(memHeap_t * mmInit);
-
-#endif                          /* __SIS_DS_H__ */
diff --git a/drivers/char/drm/sis_mm.c b/drivers/char/drm/sis_mm.c
index 5e9936bc307f..d26f5dbb7853 100644
--- a/drivers/char/drm/sis_mm.c
+++ b/drivers/char/drm/sis_mm.c
@@ -1,414 +1,348 @@
-/* sis_mm.c -- Private header for Direct Rendering Manager -*- linux-c -*-
- * Created: Mon Jan  4 10:05:05 1999 by sclin@sis.com.tw
+/**************************************************************************
  *
- * Copyright 2000 Silicon Integrated Systems Corp, Inc., HsinChu, Taiwan.
- * All rights reserved.
+ * Copyright 2006 Tungsten Graphics, Inc., Bismarck, ND., USA.
+ * All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
  *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
  *
- * Authors:
- *    Sung-Ching Lin <sclin@sis.com.tw>
  *
+ **************************************************************************/
+
+/*
+ * Authors:
+ *    Thomas Hellström <thomas-at-tungstengraphics-dot-com>
  */
 
 #include "drmP.h"
 #include "sis_drm.h"
 #include "sis_drv.h"
-#include "sis_ds.h"
-#if defined(__linux__) && defined(CONFIG_FB_SIS)
+
 #include <video/sisfb.h>
-#endif
 
-#define MAX_CONTEXT 100
 #define VIDEO_TYPE 0
 #define AGP_TYPE 1
 
-typedef struct {
-        int used;
-        int context;
-        set_t *sets[2];         /* 0 for video, 1 for AGP */
-} sis_context_t;
 
-static sis_context_t global_ppriv[MAX_CONTEXT];
+#if defined(CONFIG_FB_SIS)
+/* fb management via fb device */
 
-static int add_alloc_set(int context, int type, unsigned int val)
-{
-        int i, retval = 0;
+#define SIS_MM_ALIGN_SHIFT 0
+#define SIS_MM_ALIGN_MASK 0
 
-        for (i = 0; i < MAX_CONTEXT; i++) {
-                if (global_ppriv[i].used && global_ppriv[i].context == context) {
-                        retval = setAdd(global_ppriv[i].sets[type], val);
-                        break;
-                }
-        }
-        return retval;
-}
-
-static int del_alloc_set(int context, int type, unsigned int val)
+static void *sis_sman_mm_allocate(void *private, unsigned long size,
+                                  unsigned alignment)
 {
-        int i, retval = 0;
+        struct sis_memreq req;
 
-        for (i = 0; i < MAX_CONTEXT; i++) {
-                if (global_ppriv[i].used && global_ppriv[i].context == context) {
-                        retval = setDel(global_ppriv[i].sets[type], val);
-                        break;
-                }
-        }
-        return retval;
+        req.size = size;
+        sis_malloc(&req);
+        if (req.size == 0)
+                return NULL;
+        else
+                return (void *)~req.offset;
 }
 
-/* fb management via fb device */
-#if defined(__linux__) && defined(CONFIG_FB_SIS)
-
-static int sis_fb_init(DRM_IOCTL_ARGS)
+static void sis_sman_mm_free(void *private, void *ref)
 {
-        return 0;
+        sis_free(~((unsigned long)ref));
 }
 
-static int sis_fb_alloc(DRM_IOCTL_ARGS)
+static void sis_sman_mm_destroy(void *private)
 {
-        drm_sis_mem_t fb;
-        struct sis_memreq req;
-        drm_sis_mem_t __user *argp = (drm_sis_mem_t __user *)data;
-        int retval = 0;
-
-        DRM_COPY_FROM_USER_IOCTL(fb, argp, sizeof(fb));
-
-        req.size = fb.size;
-        sis_malloc(&req);
-        if (req.offset) {
-                /* TODO */
-                fb.offset = req.offset;
-                fb.free = req.offset;
-                if (!add_alloc_set(fb.context, VIDEO_TYPE, fb.free)) {
-                        DRM_DEBUG("adding to allocation set fails\n");
-                        sis_free(req.offset);
-                        retval = DRM_ERR(EINVAL);
-                }
-        } else {
-                fb.offset = 0;
-                fb.size = 0;
-                fb.free = 0;
-        }
-
-        DRM_COPY_TO_USER_IOCTL(argp, fb, sizeof(fb));
-
-        DRM_DEBUG("alloc fb, size = %d, offset = %d\n", fb.size, req.offset);
-
-        return retval;
+        ;
 }
 
-static int sis_fb_free(DRM_IOCTL_ARGS)
+static unsigned long sis_sman_mm_offset(void *private, void *ref)
 {
-        drm_sis_mem_t fb;
-        int retval = 0;
-
-        DRM_COPY_FROM_USER_IOCTL(fb, (drm_sis_mem_t __user *) data, sizeof(fb));
-
-        if (!fb.free)
-                return DRM_ERR(EINVAL);
+        return ~((unsigned long)ref);
+}
 
-        if (!del_alloc_set(fb.context, VIDEO_TYPE, fb.free))
-                retval = DRM_ERR(EINVAL);
-        sis_free(fb.free);
+#else /* CONFIG_FB_SIS */
 
-        DRM_DEBUG("free fb, offset = 0x%lx\n", fb.free);
+#define SIS_MM_ALIGN_SHIFT 4
+#define SIS_MM_ALIGN_MASK ( (1 << SIS_MM_ALIGN_SHIFT) - 1)
 
-        return retval;
-}
+#endif /* CONFIG_FB_SIS */
 
-#else
-
-/* Called by the X Server to initialize the FB heap.  Allocations will fail
- * unless this is called.  Offset is the beginning of the heap from the
- * framebuffer offset (MaxXFBMem in XFree86).
- *
- * Memory layout according to Thomas Winischofer:
- * |------------------|DDDDDDDDDDDDDDDDDDDDDDDDDDDDD|HHHH|CCCCCCCCCCC|
- *
- *    X driver/sisfb                                  HW-   Command-
- *  framebuffer memory           DRI heap           Cursor   queue
- */
 static int sis_fb_init(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_sis_private_t *dev_priv = dev->dev_private;
         drm_sis_fb_t fb;
+        int ret;
 
         DRM_COPY_FROM_USER_IOCTL(fb, (drm_sis_fb_t __user *) data, sizeof(fb));
 
-        if (dev_priv == NULL) {
-                dev->dev_private = drm_calloc(1, sizeof(drm_sis_private_t),
-                                              DRM_MEM_DRIVER);
-                dev_priv = dev->dev_private;
-                if (dev_priv == NULL)
-                        return ENOMEM;
+        mutex_lock(&dev->struct_mutex);
+#if defined(CONFIG_FB_SIS)
+        {
+                drm_sman_mm_t sman_mm;
+                sman_mm.private = (void *)0xFFFFFFFF;
+                sman_mm.allocate = sis_sman_mm_allocate;
+                sman_mm.free = sis_sman_mm_free;
+                sman_mm.destroy = sis_sman_mm_destroy;
+                sman_mm.offset = sis_sman_mm_offset;
+                ret =
+                    drm_sman_set_manager(&dev_priv->sman, VIDEO_TYPE, &sman_mm);
         }
+#else
+        ret = drm_sman_set_range(&dev_priv->sman, VIDEO_TYPE, 0,
+                                 fb.size >> SIS_MM_ALIGN_SHIFT);
+#endif
 
-        if (dev_priv->FBHeap != NULL)
-                return DRM_ERR(EINVAL);
+        if (ret) {
+                DRM_ERROR("VRAM memory manager initialisation error\n");
+                mutex_unlock(&dev->struct_mutex);
+                return ret;
+        }
 
-        dev_priv->FBHeap = mmInit(fb.offset, fb.size);
+        dev_priv->vram_initialized = 1;
+        dev_priv->vram_offset = fb.offset;
 
+        mutex_unlock(&dev->struct_mutex);
         DRM_DEBUG("offset = %u, size = %u", fb.offset, fb.size);
 
         return 0;
 }
 
-static int sis_fb_alloc(DRM_IOCTL_ARGS)
+static int sis_drm_alloc(drm_device_t * dev, drm_file_t * priv,
+                         unsigned long data, int pool)
 {
-        DRM_DEVICE;
         drm_sis_private_t *dev_priv = dev->dev_private;
-        drm_sis_mem_t __user *argp = (drm_sis_mem_t __user *)data;
-        drm_sis_mem_t fb;
-        PMemBlock block;
+        drm_sis_mem_t __user *argp = (drm_sis_mem_t __user *) data;
+        drm_sis_mem_t mem;
         int retval = 0;
+        drm_memblock_item_t *item;
+
+        DRM_COPY_FROM_USER_IOCTL(mem, argp, sizeof(mem));
 
-        if (dev_priv == NULL || dev_priv->FBHeap == NULL)
+        mutex_lock(&dev->struct_mutex);
+
+        if (0 == ((pool == 0) ? dev_priv->vram_initialized :
+                      dev_priv->agp_initialized)) {
+                DRM_ERROR
+                    ("Attempt to allocate from uninitialized memory manager.\n");
                 return DRM_ERR(EINVAL);
+        }
 
-        DRM_COPY_FROM_USER_IOCTL(fb, argp, sizeof(fb));
-
-        block = mmAllocMem(dev_priv->FBHeap, fb.size, 0, 0);
-        if (block) {
-                /* TODO */
-                fb.offset = block->ofs;
-                fb.free = (unsigned long)block;
-                if (!add_alloc_set(fb.context, VIDEO_TYPE, fb.free)) {
-                        DRM_DEBUG("adding to allocation set fails\n");
-                        mmFreeMem((PMemBlock) fb.free);
-                        retval = DRM_ERR(EINVAL);
-                }
+        mem.size = (mem.size + SIS_MM_ALIGN_MASK) >> SIS_MM_ALIGN_SHIFT;
+        item = drm_sman_alloc(&dev_priv->sman, pool, mem.size, 0,
+                              (unsigned long)priv);
+
+        mutex_unlock(&dev->struct_mutex);
+        if (item) {
+                mem.offset = ((pool == 0) ?
+                              dev_priv->vram_offset : dev_priv->agp_offset) +
+                    (item->mm->
+                     offset(item->mm, item->mm_info) << SIS_MM_ALIGN_SHIFT);
+                mem.free = item->user_hash.key;
+                mem.size = mem.size << SIS_MM_ALIGN_SHIFT;
         } else {
-                fb.offset = 0;
-                fb.size = 0;
-                fb.free = 0;
+                mem.offset = 0;
+                mem.size = 0;
+                mem.free = 0;
+                retval = DRM_ERR(ENOMEM);
         }
 
-        DRM_COPY_TO_USER_IOCTL(argp, fb, sizeof(fb));
+        DRM_COPY_TO_USER_IOCTL(argp, mem, sizeof(mem));
 
-        DRM_DEBUG("alloc fb, size = %d, offset = %d\n", fb.size, fb.offset);
+        DRM_DEBUG("alloc %d, size = %d, offset = %d\n", pool, mem.size,
+                  mem.offset);
 
         return retval;
 }
 
-static int sis_fb_free(DRM_IOCTL_ARGS)
+static int sis_drm_free(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_sis_private_t *dev_priv = dev->dev_private;
-        drm_sis_mem_t fb;
+        drm_sis_mem_t mem;
+        int ret;
 
-        if (dev_priv == NULL || dev_priv->FBHeap == NULL)
-                return DRM_ERR(EINVAL);
+        DRM_COPY_FROM_USER_IOCTL(mem, (drm_sis_mem_t __user *) data,
+                                 sizeof(mem));
 
-        DRM_COPY_FROM_USER_IOCTL(fb, (drm_sis_mem_t __user *) data, sizeof(fb));
+        mutex_lock(&dev->struct_mutex);
+        ret = drm_sman_free_key(&dev_priv->sman, mem.free);
+        mutex_unlock(&dev->struct_mutex);
+        DRM_DEBUG("free = 0x%lx\n", mem.free);
 
-        if (!mmBlockInHeap(dev_priv->FBHeap, (PMemBlock) fb.free))
-                return DRM_ERR(EINVAL);
-
-        if (!del_alloc_set(fb.context, VIDEO_TYPE, fb.free))
-                return DRM_ERR(EINVAL);
-        mmFreeMem((PMemBlock) fb.free);
-
-        DRM_DEBUG("free fb, free = 0x%lx\n", fb.free);
-
-        return 0;
+        return ret;
 }
 
-#endif
-
-/* agp memory management */
+static int sis_fb_alloc(DRM_IOCTL_ARGS)
+{
+        DRM_DEVICE;
+        return sis_drm_alloc(dev, priv, data, VIDEO_TYPE);
+}
 
 static int sis_ioctl_agp_init(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_sis_private_t *dev_priv = dev->dev_private;
         drm_sis_agp_t agp;
-
-        if (dev_priv == NULL) {
-                dev->dev_private = drm_calloc(1, sizeof(drm_sis_private_t),
-                                              DRM_MEM_DRIVER);
-                dev_priv = dev->dev_private;
-                if (dev_priv == NULL)
-                        return ENOMEM;
-        }
-
-        if (dev_priv->AGPHeap != NULL)
-                return DRM_ERR(EINVAL);
+        int ret;
+        dev_priv = dev->dev_private;
 
         DRM_COPY_FROM_USER_IOCTL(agp, (drm_sis_agp_t __user *) data,
                                  sizeof(agp));
+        mutex_lock(&dev->struct_mutex);
+        ret = drm_sman_set_range(&dev_priv->sman, AGP_TYPE, 0,
+                                 agp.size >> SIS_MM_ALIGN_SHIFT);
+
+        if (ret) {
+                DRM_ERROR("AGP memory manager initialisation error\n");
+                mutex_unlock(&dev->struct_mutex);
+                return ret;
+        }
 
-        dev_priv->AGPHeap = mmInit(agp.offset, agp.size);
+        dev_priv->agp_initialized = 1;
+        dev_priv->agp_offset = agp.offset;
+        mutex_unlock(&dev->struct_mutex);
 
         DRM_DEBUG("offset = %u, size = %u", agp.offset, agp.size);
-
         return 0;
 }
 
 static int sis_ioctl_agp_alloc(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
-        drm_sis_private_t *dev_priv = dev->dev_private;
-        drm_sis_mem_t __user *argp = (drm_sis_mem_t __user *)data;
-        drm_sis_mem_t agp;
-        PMemBlock block;
-        int retval = 0;
 
-        if (dev_priv == NULL || dev_priv->AGPHeap == NULL)
-                return DRM_ERR(EINVAL);
+        return sis_drm_alloc(dev, priv, data, AGP_TYPE);
+}
 
-        DRM_COPY_FROM_USER_IOCTL(agp, argp, sizeof(agp));
-
-        block = mmAllocMem(dev_priv->AGPHeap, agp.size, 0, 0);
-        if (block) {
-                /* TODO */
-                agp.offset = block->ofs;
-                agp.free = (unsigned long)block;
-                if (!add_alloc_set(agp.context, AGP_TYPE, agp.free)) {
-                        DRM_DEBUG("adding to allocation set fails\n");
-                        mmFreeMem((PMemBlock) agp.free);
-                        retval = -1;
+static drm_local_map_t *sis_reg_init(drm_device_t *dev)
+{
+        drm_map_list_t *entry;
+        drm_local_map_t *map;
+
+        list_for_each_entry(entry, &dev->maplist->head, head) {
+                map = entry->map;
+                if (!map)
+                        continue;
+                if (map->type == _DRM_REGISTERS) {
+                        return map;
                 }
-        } else {
-                agp.offset = 0;
-                agp.size = 0;
-                agp.free = 0;
         }
-
-        DRM_COPY_TO_USER_IOCTL(argp, agp, sizeof(agp));
-
-        DRM_DEBUG("alloc agp, size = %d, offset = %d\n", agp.size, agp.offset);
-
-        return retval;
+        return NULL;
 }
 
-static int sis_ioctl_agp_free(DRM_IOCTL_ARGS)
+int sis_idle(drm_device_t *dev)
 {
-        DRM_DEVICE;
         drm_sis_private_t *dev_priv = dev->dev_private;
-        drm_sis_mem_t agp;
-
-        if (dev_priv == NULL || dev_priv->AGPHeap == NULL)
-                return DRM_ERR(EINVAL);
+        uint32_t idle_reg;
+        unsigned long end;
+        int i;
 
-        DRM_COPY_FROM_USER_IOCTL(agp, (drm_sis_mem_t __user *) data,
-                                 sizeof(agp));
+        if (dev_priv->idle_fault)
+                return 0;
 
-        if (!mmBlockInHeap(dev_priv->AGPHeap, (PMemBlock) agp.free))
-                return DRM_ERR(EINVAL);
+        if (dev_priv->mmio == NULL) {
+                dev_priv->mmio = sis_reg_init(dev);
+                if (dev_priv->mmio == NULL) {
+                        DRM_ERROR("Could not find register map.\n");
+                        return 0;
+                }
+        }
+        
+        /*
+         * Implement a device switch here if needed
+         */
+
+        if (dev_priv->chipset != SIS_CHIP_315)
+                return 0;
+
+        /*
+         * Timeout after 3 seconds. We cannot use DRM_WAIT_ON here
+         * because its polling frequency is too low.
+         */
+
+        end = jiffies + (DRM_HZ * 3);
+
+        for (i=0; i<4; ++i) {
+                do {
+                        idle_reg = SIS_READ(0x85cc);
+                } while ( !time_after_eq(jiffies, end) &&
+                          ((idle_reg & 0x80000000) != 0x80000000));
+        }
 
-        mmFreeMem((PMemBlock) agp.free);
-        if (!del_alloc_set(agp.context, AGP_TYPE, agp.free))
-                return DRM_ERR(EINVAL);
+        if (time_after_eq(jiffies, end)) {
+                DRM_ERROR("Graphics engine idle timeout. "
+                          "Disabling idle check\n");
+                dev_priv->idle_fault = 1;
+        }
 
-        DRM_DEBUG("free agp, free = 0x%lx\n", agp.free);
+        /*
+         * The caller never sees an error code. It gets trapped
+         * in libdrm.
+         */
 
         return 0;
 }
 
-int sis_init_context(struct drm_device *dev, int context)
-{
-        int i;
 
-        for (i = 0; i < MAX_CONTEXT; i++) {
-                if (global_ppriv[i].used &&
-                    (global_ppriv[i].context == context))
-                        break;
-        }
+void sis_lastclose(struct drm_device *dev)
+{
+        drm_sis_private_t *dev_priv = dev->dev_private;
 
-        if (i >= MAX_CONTEXT) {
-                for (i = 0; i < MAX_CONTEXT; i++) {
-                        if (!global_ppriv[i].used) {
-                                global_ppriv[i].context = context;
-                                global_ppriv[i].used = 1;
-                                global_ppriv[i].sets[0] = setInit();
-                                global_ppriv[i].sets[1] = setInit();
-                                DRM_DEBUG("init allocation set, socket=%d, "
-                                          "context = %d\n", i, context);
-                                break;
-                        }
-                }
-                if ((i >= MAX_CONTEXT) || (global_ppriv[i].sets[0] == NULL) ||
-                    (global_ppriv[i].sets[1] == NULL)) {
-                        return 0;
-                }
-        }
+        if (!dev_priv)
+                return;
 
-        return 1;
+        mutex_lock(&dev->struct_mutex);
+        drm_sman_cleanup(&dev_priv->sman);
+        dev_priv->vram_initialized = 0;
+        dev_priv->agp_initialized = 0;
+        dev_priv->mmio = NULL;
+        mutex_unlock(&dev->struct_mutex);
 }
 
-int sis_final_context(struct drm_device *dev, int context)
+void sis_reclaim_buffers_locked(drm_device_t * dev, struct file *filp)
 {
-        int i;
+        drm_sis_private_t *dev_priv = dev->dev_private;
+        drm_file_t *priv = filp->private_data;
 
-        for (i = 0; i < MAX_CONTEXT; i++) {
-                if (global_ppriv[i].used &&
-                    (global_ppriv[i].context == context))
-                        break;
+        mutex_lock(&dev->struct_mutex);
+        if (drm_sman_owner_clean(&dev_priv->sman, (unsigned long)priv)) {
+                mutex_unlock(&dev->struct_mutex);
+                return;
         }
 
-        if (i < MAX_CONTEXT) {
-                set_t *set;
-                ITEM_TYPE item;
-                int retval;
-
-                DRM_DEBUG("find socket %d, context = %d\n", i, context);
-
-                /* Video Memory */
-                set = global_ppriv[i].sets[0];
-                retval = setFirst(set, &item);
-                while (retval) {
-                        DRM_DEBUG("free video memory 0x%lx\n", item);
-#if defined(__linux__) && defined(CONFIG_FB_SIS)
-                        sis_free(item);
-#else
-                        mmFreeMem((PMemBlock) item);
-#endif
-                        retval = setNext(set, &item);
-                }
-                setDestroy(set);
-
-                /* AGP Memory */
-                set = global_ppriv[i].sets[1];
-                retval = setFirst(set, &item);
-                while (retval) {
-                        DRM_DEBUG("free agp memory 0x%lx\n", item);
-                        mmFreeMem((PMemBlock) item);
-                        retval = setNext(set, &item);
-                }
-                setDestroy(set);
-
-                global_ppriv[i].used = 0;
+        if (dev->driver->dma_quiescent) {
+                dev->driver->dma_quiescent(dev);
         }
 
-        return 1;
+        drm_sman_owner_cleanup(&dev_priv->sman, (unsigned long)priv);
+        mutex_unlock(&dev->struct_mutex);
+        return;
 }
 
 drm_ioctl_desc_t sis_ioctls[] = {
         [DRM_IOCTL_NR(DRM_SIS_FB_ALLOC)] = {sis_fb_alloc, DRM_AUTH},
-        [DRM_IOCTL_NR(DRM_SIS_FB_FREE)] = {sis_fb_free, DRM_AUTH},
-        [DRM_IOCTL_NR(DRM_SIS_AGP_INIT)] = {sis_ioctl_agp_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
+        [DRM_IOCTL_NR(DRM_SIS_FB_FREE)] = {sis_drm_free, DRM_AUTH},
+        [DRM_IOCTL_NR(DRM_SIS_AGP_INIT)] =
+            {sis_ioctl_agp_init, DRM_AUTH | DRM_MASTER | DRM_ROOT_ONLY},
         [DRM_IOCTL_NR(DRM_SIS_AGP_ALLOC)] = {sis_ioctl_agp_alloc, DRM_AUTH},
-        [DRM_IOCTL_NR(DRM_SIS_AGP_FREE)] = {sis_ioctl_agp_free, DRM_AUTH},
-        [DRM_IOCTL_NR(DRM_SIS_FB_INIT)] = {sis_fb_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY}
+        [DRM_IOCTL_NR(DRM_SIS_AGP_FREE)] = {sis_drm_free, DRM_AUTH},
+        [DRM_IOCTL_NR(DRM_SIS_FB_INIT)] =
+            {sis_fb_init, DRM_AUTH | DRM_MASTER | DRM_ROOT_ONLY}
 };
 
 int sis_max_ioctl = DRM_ARRAY_SIZE(sis_ioctls);
diff --git a/drivers/char/drm/via_dmablit.c b/drivers/char/drm/via_dmablit.c
index 78a81a4a99c5..806f9ce5f47b 100644
--- a/drivers/char/drm/via_dmablit.c
+++ b/drivers/char/drm/via_dmablit.c
@@ -41,9 +41,9 @@
 
 #include <linux/pagemap.h>
 
-#define VIA_PGDN(x)             (((unsigned long)(x)) & PAGE_MASK)
-#define VIA_PGOFF(x)            (((unsigned long)(x)) & ~PAGE_MASK)
-#define VIA_PFN(x)              ((unsigned long)(x) >> PAGE_SHIFT)
+#define VIA_PGDN(x)          (((unsigned long)(x)) & PAGE_MASK)
+#define VIA_PGOFF(x)        (((unsigned long)(x)) & ~PAGE_MASK)
+#define VIA_PFN(x)            ((unsigned long)(x) >> PAGE_SHIFT)
 
 typedef struct _drm_via_descriptor {
         uint32_t mem_addr;
@@ -121,19 +121,19 @@ via_map_blit_for_device(struct pci_dev *pdev,
                 
                 while (line_len > 0) {
 
-                        remaining_len = min(PAGE_SIZE-VIA_PGOFF(cur_mem), line_len);
+                        remaining_len = min(PAGE_SIZE-VIA_PGOFF(cur_mem), line_len);
                         line_len -= remaining_len;
 
                         if (mode == 1) {
-                                desc_ptr->mem_addr = 
+                                desc_ptr->mem_addr = 
                                         dma_map_page(&pdev->dev, 
                                                      vsg->pages[VIA_PFN(cur_mem) - 
                                                                 VIA_PFN(first_addr)],
                                                      VIA_PGOFF(cur_mem), remaining_len, 
                                                      vsg->direction);
-                                desc_ptr->dev_addr = cur_fb;
+                                desc_ptr->dev_addr = cur_fb;
                                 
-                                desc_ptr->size = remaining_len;
+                                desc_ptr->size = remaining_len;
                                 desc_ptr->next = (uint32_t) next;
                                 next = dma_map_single(&pdev->dev, desc_ptr, sizeof(*desc_ptr), 
                                                       DMA_TO_DEVICE);
@@ -162,7 +162,7 @@ via_map_blit_for_device(struct pci_dev *pdev,
 
 /*
  * Function that frees up all resources for a blit. It is usable even if the 
- * blit info has only be partially built as long as the status enum is consistent
+ * blit info has only been partially built as long as the status enum is consistent
  * with the actual status of the used resources.
  */
 
@@ -238,8 +238,11 @@ via_lock_all_dma_pages(drm_via_sg_info_t *vsg,  drm_via_dmablit_t *xfer)
                 return DRM_ERR(ENOMEM);
         memset(vsg->pages, 0, sizeof(struct page *) * vsg->num_pages);
         down_read(&current->mm->mmap_sem);
-        ret = get_user_pages(current, current->mm, (unsigned long) xfer->mem_addr,
-                             vsg->num_pages, vsg->direction, 0, vsg->pages, NULL);
+        ret = get_user_pages(current, current->mm,
+                             (unsigned long)xfer->mem_addr,
+                             vsg->num_pages,
+                             (vsg->direction == DMA_FROM_DEVICE),
+                             0, vsg->pages, NULL);
 
         up_read(&current->mm->mmap_sem);
         if (ret != vsg->num_pages) {
@@ -475,9 +478,15 @@ via_dmablit_timer(unsigned long data)
         if (!timer_pending(&blitq->poll_timer)) {
                 blitq->poll_timer.expires = jiffies+1;
                 add_timer(&blitq->poll_timer);
-        }
-        via_dmablit_handler(dev, engine, 0);
 
+               /*
+                * Rerun handler to delete timer if engines are off, and
+                * to shorten abort latency. This is a little nasty.
+                */
+
+               via_dmablit_handler(dev, engine, 0);
+
+        }
 }
 
 
@@ -491,9 +500,9 @@ via_dmablit_timer(unsigned long data)
 
 
 static void 
-via_dmablit_workqueue(void *data)
+via_dmablit_workqueue(struct work_struct *work)
 {
-        drm_via_blitq_t *blitq = (drm_via_blitq_t *) data;
+        drm_via_blitq_t *blitq = container_of(work, drm_via_blitq_t, wq);
         drm_device_t *dev = blitq->dev;
         unsigned long irqsave;
         drm_via_sg_info_t *cur_sg;
@@ -562,7 +571,7 @@ via_init_dmablit(drm_device_t *dev)
                         DRM_INIT_WAITQUEUE(blitq->blit_queue + j);
                 }
                 DRM_INIT_WAITQUEUE(&blitq->busy_queue);
-                INIT_WORK(&blitq->wq, via_dmablit_workqueue, blitq);
+                INIT_WORK(&blitq->wq, via_dmablit_workqueue);
                 init_timer(&blitq->poll_timer);
                 blitq->poll_timer.function = &via_dmablit_timer;
                 blitq->poll_timer.data = (unsigned long) blitq;
@@ -597,15 +606,27 @@ via_build_sg_info(drm_device_t *dev, drm_via_sg_info_t *vsg, drm_via_dmablit_t *
          * (Not a big limitation anyway.)
          */
 
-        if (((xfer->mem_stride - xfer->line_length) >= PAGE_SIZE) ||
-            (xfer->mem_stride > 2048*4)) {
+        if ((xfer->mem_stride - xfer->line_length) >= PAGE_SIZE) {
                 DRM_ERROR("Too large system memory stride. Stride: %d, "
                           "Length: %d\n", xfer->mem_stride, xfer->line_length);
                 return DRM_ERR(EINVAL);
         }
 
-        if (xfer->num_lines > 2048) {
-                DRM_ERROR("Too many PCI DMA bitblt lines.\n");
+        if ((xfer->mem_stride == xfer->line_length) &&
+           (xfer->fb_stride == xfer->line_length)) {
+                xfer->mem_stride *= xfer->num_lines;
+                xfer->line_length = xfer->mem_stride;
+                xfer->fb_stride = xfer->mem_stride;
+                xfer->num_lines = 1;
+        }
+
+        /*
+         * Don't lock an arbitrary large number of pages, since that causes a
+         * DOS security hole.
+         */
+
+        if (xfer->num_lines > 2048 || (xfer->num_lines*xfer->mem_stride > (2048*2048*4))) {
+                DRM_ERROR("Too large PCI DMA bitblt.\n");
                 return DRM_ERR(EINVAL);
         }               
 
@@ -628,16 +649,17 @@ via_build_sg_info(drm_device_t *dev, drm_via_sg_info_t *vsg, drm_via_dmablit_t *
 
 #ifdef VIA_BUGFREE
         if ((((unsigned long)xfer->mem_addr & 3) != ((unsigned long)xfer->fb_addr & 3)) ||
-            ((xfer->mem_stride & 3) != (xfer->fb_stride & 3))) {
+            ((xfer->num_lines > 1) && ((xfer->mem_stride & 3) != (xfer->fb_stride & 3)))) {
                 DRM_ERROR("Invalid DRM bitblt alignment.\n");
-                return DRM_ERR(EINVAL);
+                return DRM_ERR(EINVAL);
         }
 #else
         if ((((unsigned long)xfer->mem_addr & 15) ||
-            ((unsigned long)xfer->fb_addr & 3)) || (xfer->mem_stride & 15) ||
-            (xfer->fb_stride & 3)) {
+              ((unsigned long)xfer->fb_addr & 3)) ||
+           ((xfer->num_lines > 1) && 
+           ((xfer->mem_stride & 15) || (xfer->fb_stride & 3)))) {
                 DRM_ERROR("Invalid DRM bitblt alignment.\n");
-                return DRM_ERR(EINVAL);
+                return DRM_ERR(EINVAL);
         }       
 #endif
 
@@ -715,7 +737,7 @@ via_dmablit(drm_device_t *dev, drm_via_dmablit_t *xfer)
         drm_via_private_t *dev_priv = (drm_via_private_t *)dev->dev_private;
         drm_via_sg_info_t *vsg;
         drm_via_blitq_t *blitq;
-        int ret;
+        int ret;
         int engine;
         unsigned long irqsave;
 
@@ -756,7 +778,7 @@ via_dmablit(drm_device_t *dev, drm_via_dmablit_t *xfer)
 
 /*
  * Sync on a previously submitted blit. Note that the X server use signals extensively, and
- * that there is a very big proability that this IOCTL will be interrupted by a signal. In that
+ * that there is a very big probability that this IOCTL will be interrupted by a signal. In that
  * case it returns with -EAGAIN for the signal to be delivered. 
  * The caller should then reissue the IOCTL. This is similar to what is being done for drmGetLock().
  */
diff --git a/drivers/char/drm/via_drm.h b/drivers/char/drm/via_drm.h
index 47f0b5b26379..e4ee97d7156f 100644
--- a/drivers/char/drm/via_drm.h
+++ b/drivers/char/drm/via_drm.h
@@ -250,6 +250,12 @@ typedef struct drm_via_blitsync {
         unsigned engine;
 } drm_via_blitsync_t;
 
+/* - * Below,"flags" is currently unused but will be used for possible future
+ * extensions like kernel space bounce buffers for bad alignments and
+ * blit engine busy-wait polling for better latency in the absence of
+ * interrupts.
+ */
+
 typedef struct drm_via_dmablit {
         uint32_t num_lines;
         uint32_t line_length;
@@ -260,7 +266,7 @@ typedef struct drm_via_dmablit {
         unsigned char *mem_addr;
         uint32_t mem_stride;
 
-        int bounce_buffer;
+        uint32_t flags;
         int to_fb;
 
         drm_via_blitsync_t sync;
diff --git a/drivers/char/drm/via_drv.c b/drivers/char/drm/via_drv.c
index b3d364d793d7..bb9dde8b1911 100644
--- a/drivers/char/drm/via_drv.c
+++ b/drivers/char/drm/via_drv.c
@@ -43,7 +43,6 @@ static struct drm_driver driver = {
             DRIVER_IRQ_SHARED | DRIVER_IRQ_VBL,
         .load = via_driver_load,
         .unload = via_driver_unload,
-        .context_ctor = via_init_context,
         .context_dtor = via_final_context,
         .vblank_wait = via_driver_vblank_wait,
         .irq_preinstall = via_driver_irq_preinstall,
@@ -53,6 +52,8 @@ static struct drm_driver driver = {
         .dma_quiescent = via_driver_dma_quiescent,
         .dri_library_name = dri_library_name,
         .reclaim_buffers = drm_core_reclaim_buffers,
+        .reclaim_buffers_locked = via_reclaim_buffers_locked,
+        .lastclose = via_lastclose,
         .get_map_ofs = drm_core_get_map_ofs,
         .get_reg_ofs = drm_core_get_reg_ofs,
         .ioctls = via_ioctls,
diff --git a/drivers/char/drm/via_drv.h b/drivers/char/drm/via_drv.h
index 52bcc7b1ba45..d21b5b75da0f 100644
--- a/drivers/char/drm/via_drv.h
+++ b/drivers/char/drm/via_drv.h
@@ -24,15 +24,16 @@
 #ifndef _VIA_DRV_H_
 #define _VIA_DRV_H_
 
+#include "drm_sman.h"
 #define DRIVER_AUTHOR   "Various"
 
 #define DRIVER_NAME             "via"
 #define DRIVER_DESC             "VIA Unichrome / Pro"
-#define DRIVER_DATE             "20051116"
+#define DRIVER_DATE             "20060529"
 
 #define DRIVER_MAJOR            2
-#define DRIVER_MINOR            7
-#define DRIVER_PATCHLEVEL       4
+#define DRIVER_MINOR            10
+#define DRIVER_PATCHLEVEL       0
 
 #include "via_verifier.h"
 
@@ -85,6 +86,12 @@ typedef struct drm_via_private {
         uint32_t irq_enable_mask;
         uint32_t irq_pending_mask;
         int *irq_map;
+        unsigned int idle_fault;
+        drm_sman_t sman;
+        int vram_initialized;
+        int agp_initialized;
+        unsigned long vram_offset;
+        unsigned long agp_offset;
         drm_via_blitq_t blit_queues[VIA_NUM_BLIT_ENGINES];
 } drm_via_private_t;
 
@@ -135,6 +142,9 @@ 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 void via_reclaim_buffers_locked(drm_device_t *dev, struct file *filp);
+extern void via_lastclose(drm_device_t *dev);
+
 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_ds.c b/drivers/char/drm/via_ds.c
deleted file mode 100644
index 9429736b3b96..000000000000
--- a/drivers/char/drm/via_ds.c
+++ /dev/null
@@ -1,273 +0,0 @@
-/*
- * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.
- * Copyright 2001-2003 S3 Graphics, Inc. All Rights Reserved.
- * Copyright 2000 Silicon Integrated Systems Corp, Inc., HsinChu, Taiwan.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sub license,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
- * VIA, S3 GRAPHICS, AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include "drmP.h"
-
-#include "via_ds.h"
-extern unsigned int VIA_DEBUG;
-
-set_t *via_setInit(void)
-{
-        int i;
-        set_t *set;
-        set = (set_t *) drm_alloc(sizeof(set_t), DRM_MEM_DRIVER);
-        for (i = 0; i < SET_SIZE; i++) {
-                set->list[i].free_next = i + 1;
-                set->list[i].alloc_next = -1;
-        }
-        set->list[SET_SIZE - 1].free_next = -1;
-        set->free = 0;
-        set->alloc = -1;
-        set->trace = -1;
-        return set;
-}
-
-int via_setAdd(set_t * set, ITEM_TYPE item)
-{
-        int free = set->free;
-        if (free != -1) {
-                set->list[free].val = item;
-                set->free = set->list[free].free_next;
-        } else {
-                return 0;
-        }
-        set->list[free].alloc_next = set->alloc;
-        set->alloc = free;
-        set->list[free].free_next = -1;
-        return 1;
-}
-
-int via_setDel(set_t * set, ITEM_TYPE item)
-{
-        int alloc = set->alloc;
-        int prev = -1;
-
-        while (alloc != -1) {
-                if (set->list[alloc].val == item) {
-                        if (prev != -1)
-                                set->list[prev].alloc_next =
-                                    set->list[alloc].alloc_next;
-                        else
-                                set->alloc = set->list[alloc].alloc_next;
-                        break;
-                }
-                prev = alloc;
-                alloc = set->list[alloc].alloc_next;
-        }
-
-        if (alloc == -1)
-                return 0;
-
-        set->list[alloc].free_next = set->free;
-        set->free = alloc;
-        set->list[alloc].alloc_next = -1;
-
-        return 1;
-}
-
-/* setFirst -> setAdd -> setNext is wrong */
-
-int via_setFirst(set_t * set, ITEM_TYPE * item)
-{
-        if (set->alloc == -1)
-                return 0;
-
-        *item = set->list[set->alloc].val;
-        set->trace = set->list[set->alloc].alloc_next;
-
-        return 1;
-}
-
-int via_setNext(set_t * set, ITEM_TYPE * item)
-{
-        if (set->trace == -1)
-                return 0;
-
-        *item = set->list[set->trace].val;
-        set->trace = set->list[set->trace].alloc_next;
-
-        return 1;
-}
-
-int via_setDestroy(set_t * set)
-{
-        drm_free(set, sizeof(set_t), DRM_MEM_DRIVER);
-
-        return 1;
-}
-
-#define ISFREE(bptr) ((bptr)->free)
-
-#define fprintf(fmt, arg...) do{}while(0)
-
-memHeap_t *via_mmInit(int ofs, int size)
-{
-        PMemBlock blocks;
-
-        if (size <= 0)
-                return NULL;
-
-        blocks = (TMemBlock *) drm_calloc(1, sizeof(TMemBlock), DRM_MEM_DRIVER);
-
-        if (blocks) {
-                blocks->ofs = ofs;
-                blocks->size = size;
-                blocks->free = 1;
-                return (memHeap_t *) blocks;
-        } else
-                return NULL;
-}
-
-static TMemBlock *SliceBlock(TMemBlock * p,
-                             int startofs, int size,
-                             int reserved, int alignment)
-{
-        TMemBlock *newblock;
-
-        /* break left */
-        if (startofs > p->ofs) {
-                newblock =
-                    (TMemBlock *) drm_calloc(1, sizeof(TMemBlock),
-                                             DRM_MEM_DRIVER);
-                newblock->ofs = startofs;
-                newblock->size = p->size - (startofs - p->ofs);
-                newblock->free = 1;
-                newblock->next = p->next;
-                p->size -= newblock->size;
-                p->next = newblock;
-                p = newblock;
-        }
-
-        /* break right */
-        if (size < p->size) {
-                newblock =
-                    (TMemBlock *) drm_calloc(1, sizeof(TMemBlock),
-                                             DRM_MEM_DRIVER);
-                newblock->ofs = startofs + size;
-                newblock->size = p->size - size;
-                newblock->free = 1;
-                newblock->next = p->next;
-                p->size = size;
-                p->next = newblock;
-        }
-
-        /* p = middle block */
-        p->align = alignment;
-        p->free = 0;
-        p->reserved = reserved;
-        return p;
-}
-
-PMemBlock via_mmAllocMem(memHeap_t * heap, int size, int align2,
-                         int startSearch)
-{
-        int mask, startofs, endofs;
-        TMemBlock *p;
-
-        if (!heap || align2 < 0 || size <= 0)
-                return NULL;
-
-        mask = (1 << align2) - 1;
-        startofs = 0;
-        p = (TMemBlock *) heap;
-
-        while (p) {
-                if (ISFREE(p)) {
-                        startofs = (p->ofs + mask) & ~mask;
-
-                        if (startofs < startSearch)
-                                startofs = startSearch;
-
-                        endofs = startofs + size;
-
-                        if (endofs <= (p->ofs + p->size))
-                                break;
-                }
-
-                p = p->next;
-        }
-
-        if (!p)
-                return NULL;
-
-        p = SliceBlock(p, startofs, size, 0, mask + 1);
-        p->heap = heap;
-
-        return p;
-}
-
-static __inline__ int Join2Blocks(TMemBlock * p)
-{
-        if (p->free && p->next && p->next->free) {
-                TMemBlock *q = p->next;
-                p->size += q->size;
-                p->next = q->next;
-                drm_free(q, sizeof(TMemBlock), DRM_MEM_DRIVER);
-
-                return 1;
-        }
-
-        return 0;
-}
-
-int via_mmFreeMem(PMemBlock b)
-{
-        TMemBlock *p, *prev;
-
-        if (!b)
-                return 0;
-
-        if (!b->heap) {
-                fprintf(stderr, "no heap\n");
-
-                return -1;
-        }
-
-        p = b->heap;
-        prev = NULL;
-
-        while (p && p != b) {
-                prev = p;
-                p = p->next;
-        }
-
-        if (!p || p->free || p->reserved) {
-                if (!p)
-                        fprintf(stderr, "block not found in heap\n");
-                else if (p->free)
-                        fprintf(stderr, "block already free\n");
-                else
-                        fprintf(stderr, "block is reserved\n");
-
-                return -1;
-        }
-
-        p->free = 1;
-        Join2Blocks(p);
-
-        if (prev)
-                Join2Blocks(prev);
-
-        return 0;
-}
diff --git a/drivers/char/drm/via_ds.h b/drivers/char/drm/via_ds.h
deleted file mode 100644
index d2bb9f37ca38..000000000000
--- a/drivers/char/drm/via_ds.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.
- * Copyright 2001-2003 S3 Graphics, Inc. All Rights Reserved.
- * Copyright 2000 Silicon Integrated Systems Corp, Inc., HsinChu, Taiwan.
- * All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sub license,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
- * VIA, S3 GRAPHICS, AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef _via_ds_h_
-#define _via_ds_h_
-
-#include "drmP.h"
-
-/* Set Data Structure */
-#define SET_SIZE 5000
-typedef unsigned long ITEM_TYPE;
-
-typedef struct {
-        ITEM_TYPE val;
-        int alloc_next, free_next;
-} list_item_t;
-
-typedef struct {
-        int alloc;
-        int free;
-        int trace;
-        list_item_t list[SET_SIZE];
-} set_t;
-
-set_t *via_setInit(void);
-int via_setAdd(set_t * set, ITEM_TYPE item);
-int via_setDel(set_t * set, ITEM_TYPE item);
-int via_setFirst(set_t * set, ITEM_TYPE * item);
-int via_setNext(set_t * set, ITEM_TYPE * item);
-int via_setDestroy(set_t * set);
-
-#endif
-
-#ifndef MM_INC
-#define MM_INC
-
-struct mem_block_t {
-        struct mem_block_t *next;
-        struct mem_block_t *heap;
-        int ofs, size;
-        int align;
-        unsigned int free:1;
-        unsigned int reserved:1;
-};
-typedef struct mem_block_t TMemBlock;
-typedef struct mem_block_t *PMemBlock;
-
-/* a heap is just the first block in a chain */
-typedef struct mem_block_t memHeap_t;
-
-static __inline__ int mmBlockSize(PMemBlock b)
-{
-        return b->size;
-}
-
-static __inline__ int mmOffset(PMemBlock b)
-{
-        return b->ofs;
-}
-
-static __inline__ void mmMarkReserved(PMemBlock b)
-{
-        b->reserved = 1;
-}
-
-/*
- * input: total size in bytes
- * return: a heap pointer if OK, NULL if error
- */
-memHeap_t *via_mmInit(int ofs, int size);
-
-PMemBlock via_mmAllocMem(memHeap_t * heap, int size, int align2,
-                         int startSearch);
-
-/*
- * Free block starts at offset
- * input: pointer to a block
- * return: 0 if OK, -1 if error
- */
-int via_mmFreeMem(PMemBlock b);
-
-#endif
diff --git a/drivers/char/drm/via_map.c b/drivers/char/drm/via_map.c
index c6a08e96285b..782011e0a58d 100644
--- a/drivers/char/drm/via_map.c
+++ b/drivers/char/drm/via_map.c
@@ -98,6 +98,7 @@ int via_map_init(DRM_IOCTL_ARGS)
 int via_driver_load(drm_device_t *dev, unsigned long chipset)
 {
         drm_via_private_t *dev_priv;
+        int ret = 0;
 
         dev_priv = drm_calloc(1, sizeof(drm_via_private_t), DRM_MEM_DRIVER);
         if (dev_priv == NULL)
@@ -108,13 +109,19 @@ int via_driver_load(drm_device_t *dev, unsigned long chipset)
         if (chipset == VIA_PRO_GROUP_A)
                 dev_priv->pro_group_a = 1;
 
-        return 0;
+        ret = drm_sman_init(&dev_priv->sman, 2, 12, 8);
+        if (ret) {
+                drm_free(dev_priv, sizeof(*dev_priv), DRM_MEM_DRIVER);
+        }
+        return ret;
 }
 
 int via_driver_unload(drm_device_t *dev)
 {
         drm_via_private_t *dev_priv = dev->dev_private;
 
+        drm_sman_takedown(&dev_priv->sman);
+
         drm_free(dev_priv, sizeof(drm_via_private_t), DRM_MEM_DRIVER);
 
         return 0;
diff --git a/drivers/char/drm/via_mm.c b/drivers/char/drm/via_mm.c
index 33e0cb12e4c3..2fcf0577a7aa 100644
--- a/drivers/char/drm/via_mm.c
+++ b/drivers/char/drm/via_mm.c
@@ -1,6 +1,6 @@
 /*
- * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.
- * Copyright 2001-2003 S3 Graphics, Inc. All Rights Reserved.
+ * Copyright 2006 Tungsten Graphics Inc., Bismarck, ND., USA.
+ * All rights reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -16,347 +16,194 @@
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
- * VIA, S3 GRAPHICS, AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * THE AUTHORS OR COPYRIGHT HOLDERS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  * DEALINGS IN THE SOFTWARE.
  */
+/*
+ * Authors: Thomas Hellström <thomas-at-tungstengraphics-dot-com>
+ */
+
 #include "drmP.h"
 #include "via_drm.h"
 #include "via_drv.h"
-#include "via_ds.h"
-#include "via_mm.h"
-
-#define MAX_CONTEXT 100
-
-typedef struct {
-        int used;
-        int context;
-        set_t *sets[2];         /* 0 for frame buffer, 1 for AGP , 2 for System */
-} via_context_t;
-
-static via_context_t global_ppriv[MAX_CONTEXT];
+#include "drm_sman.h"
 
-static int via_agp_alloc(drm_via_mem_t * mem);
-static int via_agp_free(drm_via_mem_t * mem);
-static int via_fb_alloc(drm_via_mem_t * mem);
-static int via_fb_free(drm_via_mem_t * mem);
-
-static int add_alloc_set(int context, int type, unsigned long val)
-{
-        int i, retval = 0;
-
-        for (i = 0; i < MAX_CONTEXT; i++) {
-                if (global_ppriv[i].used && global_ppriv[i].context == context) {
-                        retval = via_setAdd(global_ppriv[i].sets[type], val);
-                        break;
-                }
-        }
-
-        return retval;
-}
-
-static int del_alloc_set(int context, int type, unsigned long val)
-{
-        int i, retval = 0;
-
-        for (i = 0; i < MAX_CONTEXT; i++)
-                if (global_ppriv[i].used && global_ppriv[i].context == context) {
-                        retval = via_setDel(global_ppriv[i].sets[type], val);
-                        break;
-                }
-
-        return retval;
-}
-
-/* agp memory management */
-static memHeap_t *AgpHeap = NULL;
+#define VIA_MM_ALIGN_SHIFT 4
+#define VIA_MM_ALIGN_MASK ( (1 << VIA_MM_ALIGN_SHIFT) - 1)
 
 int via_agp_init(DRM_IOCTL_ARGS)
 {
+        DRM_DEVICE;
         drm_via_agp_t agp;
+        drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
+        int ret;
 
         DRM_COPY_FROM_USER_IOCTL(agp, (drm_via_agp_t __user *) data,
                                  sizeof(agp));
+        mutex_lock(&dev->struct_mutex);
+        ret = drm_sman_set_range(&dev_priv->sman, VIA_MEM_AGP, 0,
+                                 agp.size >> VIA_MM_ALIGN_SHIFT);
+
+        if (ret) {
+                DRM_ERROR("AGP memory manager initialisation error\n");
+                mutex_unlock(&dev->struct_mutex);
+                return ret;
+        }
 
-        AgpHeap = via_mmInit(agp.offset, agp.size);
-
-        DRM_DEBUG("offset = %lu, size = %lu", (unsigned long)agp.offset,
-                  (unsigned long)agp.size);
+        dev_priv->agp_initialized = 1;
+        dev_priv->agp_offset = agp.offset;
+        mutex_unlock(&dev->struct_mutex);
 
+        DRM_DEBUG("offset = %u, size = %u", agp.offset, agp.size);
         return 0;
 }
 
-/* fb memory management */
-static memHeap_t *FBHeap = NULL;
-
 int via_fb_init(DRM_IOCTL_ARGS)
 {
+        DRM_DEVICE;
         drm_via_fb_t fb;
+        drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
+        int ret;
 
         DRM_COPY_FROM_USER_IOCTL(fb, (drm_via_fb_t __user *) data, sizeof(fb));
 
-        FBHeap = via_mmInit(fb.offset, fb.size);
+        mutex_lock(&dev->struct_mutex);
+        ret = drm_sman_set_range(&dev_priv->sman, VIA_MEM_VIDEO, 0,
+                                 fb.size >> VIA_MM_ALIGN_SHIFT);
 
-        DRM_DEBUG("offset = %lu, size = %lu", (unsigned long)fb.offset,
-                  (unsigned long)fb.size);
+        if (ret) {
+                DRM_ERROR("VRAM memory manager initialisation error\n");
+                mutex_unlock(&dev->struct_mutex);
+                return ret;
+        }
 
-        return 0;
-}
+        dev_priv->vram_initialized = 1;
+        dev_priv->vram_offset = fb.offset;
 
-int via_init_context(struct drm_device *dev, int context)
-{
-        int i;
-
-        for (i = 0; i < MAX_CONTEXT; i++)
-                if (global_ppriv[i].used &&
-                    (global_ppriv[i].context == context))
-                        break;
-
-        if (i >= MAX_CONTEXT) {
-                for (i = 0; i < MAX_CONTEXT; i++) {
-                        if (!global_ppriv[i].used) {
-                                global_ppriv[i].context = context;
-                                global_ppriv[i].used = 1;
-                                global_ppriv[i].sets[0] = via_setInit();
-                                global_ppriv[i].sets[1] = via_setInit();
-                                DRM_DEBUG("init allocation set, socket=%d,"
-                                          " context = %d\n", i, context);
-                                break;
-                        }
-                }
-
-                if ((i >= MAX_CONTEXT) || (global_ppriv[i].sets[0] == NULL) ||
-                    (global_ppriv[i].sets[1] == NULL)) {
-                        return 0;
-                }
-        }
+        mutex_unlock(&dev->struct_mutex);
+        DRM_DEBUG("offset = %u, size = %u", fb.offset, fb.size);
+
+        return 0;
 
-        return 1;
 }
 
 int via_final_context(struct drm_device *dev, int context)
 {
-        int i;
         drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
 
-        for (i = 0; i < MAX_CONTEXT; i++)
-                if (global_ppriv[i].used &&
-                    (global_ppriv[i].context == context))
-                        break;
-
-        if (i < MAX_CONTEXT) {
-                set_t *set;
-                ITEM_TYPE item;
-                int retval;
-
-                DRM_DEBUG("find socket %d, context = %d\n", i, context);
-
-                /* Video Memory */
-                set = global_ppriv[i].sets[0];
-                retval = via_setFirst(set, &item);
-                while (retval) {
-                        DRM_DEBUG("free video memory 0x%lx\n", item);
-                        via_mmFreeMem((PMemBlock) item);
-                        retval = via_setNext(set, &item);
-                }
-                via_setDestroy(set);
-
-                /* AGP Memory */
-                set = global_ppriv[i].sets[1];
-                retval = via_setFirst(set, &item);
-                while (retval) {
-                        DRM_DEBUG("free agp memory 0x%lx\n", item);
-                        via_mmFreeMem((PMemBlock) item);
-                        retval = via_setNext(set, &item);
-                }
-                via_setDestroy(set);
-                global_ppriv[i].used = 0;
-        }
         via_release_futex(dev_priv, context);
 
-#if defined(__linux__)
         /* Linux specific until context tracking code gets ported to BSD */
         /* Last context, perform cleanup */
         if (dev->ctx_count == 1 && dev->dev_private) {
                 DRM_DEBUG("Last Context\n");
                 if (dev->irq)
                         drm_irq_uninstall(dev);
-
                 via_cleanup_futex(dev_priv);
                 via_do_cleanup_map(dev);
         }
-#endif
-
         return 1;
 }
 
+void via_lastclose(struct drm_device *dev)
+{
+        drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
+
+        if (!dev_priv)
+                return;
+
+        mutex_lock(&dev->struct_mutex);
+        drm_sman_cleanup(&dev_priv->sman);
+        dev_priv->vram_initialized = 0;
+        dev_priv->agp_initialized = 0;
+        mutex_unlock(&dev->struct_mutex);
+}       
+
 int via_mem_alloc(DRM_IOCTL_ARGS)
 {
+        DRM_DEVICE;
+
         drm_via_mem_t mem;
+        int retval = 0;
+        drm_memblock_item_t *item;
+        drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
+        unsigned long tmpSize;
 
         DRM_COPY_FROM_USER_IOCTL(mem, (drm_via_mem_t __user *) data,
                                  sizeof(mem));
 
-        switch (mem.type) {
-        case VIA_MEM_VIDEO:
-                if (via_fb_alloc(&mem) < 0)
-                        return -EFAULT;
-                DRM_COPY_TO_USER_IOCTL((drm_via_mem_t __user *) data, mem,
-                                       sizeof(mem));
-                return 0;
-        case VIA_MEM_AGP:
-                if (via_agp_alloc(&mem) < 0)
-                        return -EFAULT;
-                DRM_COPY_TO_USER_IOCTL((drm_via_mem_t __user *) data, mem,
-                                       sizeof(mem));
-                return 0;
+        if (mem.type > VIA_MEM_AGP) {
+                DRM_ERROR("Unknown memory type allocation\n");
+                return DRM_ERR(EINVAL);
         }
-
-        return -EFAULT;
-}
-
-static int via_fb_alloc(drm_via_mem_t * mem)
-{
-        drm_via_mm_t fb;
-        PMemBlock block;
-        int retval = 0;
-
-        if (!FBHeap)
-                return -1;
-
-        fb.size = mem->size;
-        fb.context = mem->context;
-
-        block = via_mmAllocMem(FBHeap, fb.size, 5, 0);
-        if (block) {
-                fb.offset = block->ofs;
-                fb.free = (unsigned long)block;
-                if (!add_alloc_set(fb.context, VIA_MEM_VIDEO, fb.free)) {
-                        DRM_DEBUG("adding to allocation set fails\n");
-                        via_mmFreeMem((PMemBlock) fb.free);
-                        retval = -1;
-                }
-        } else {
-                fb.offset = 0;
-                fb.size = 0;
-                fb.free = 0;
-                retval = -1;
+        mutex_lock(&dev->struct_mutex);
+        if (0 == ((mem.type == VIA_MEM_VIDEO) ? dev_priv->vram_initialized :
+                      dev_priv->agp_initialized)) {
+                DRM_ERROR
+                    ("Attempt to allocate from uninitialized memory manager.\n");
+                mutex_unlock(&dev->struct_mutex);
+                return DRM_ERR(EINVAL);
         }
 
-        mem->offset = fb.offset;
-        mem->index = fb.free;
-
-        DRM_DEBUG("alloc fb, size = %d, offset = %d\n", fb.size,
-                  (int)fb.offset);
-
-        return retval;
-}
-
-static int via_agp_alloc(drm_via_mem_t * mem)
-{
-        drm_via_mm_t agp;
-        PMemBlock block;
-        int retval = 0;
-
-        if (!AgpHeap)
-                return -1;
-
-        agp.size = mem->size;
-        agp.context = mem->context;
-
-        block = via_mmAllocMem(AgpHeap, agp.size, 5, 0);
-        if (block) {
-                agp.offset = block->ofs;
-                agp.free = (unsigned long)block;
-                if (!add_alloc_set(agp.context, VIA_MEM_AGP, agp.free)) {
-                        DRM_DEBUG("adding to allocation set fails\n");
-                        via_mmFreeMem((PMemBlock) agp.free);
-                        retval = -1;
-                }
+        tmpSize = (mem.size + VIA_MM_ALIGN_MASK) >> VIA_MM_ALIGN_SHIFT;
+        item = drm_sman_alloc(&dev_priv->sman, mem.type, tmpSize, 0,
+                              (unsigned long)priv);
+        mutex_unlock(&dev->struct_mutex);
+        if (item) {
+                mem.offset = ((mem.type == VIA_MEM_VIDEO) ?
+                              dev_priv->vram_offset : dev_priv->agp_offset) +
+                    (item->mm->
+                     offset(item->mm, item->mm_info) << VIA_MM_ALIGN_SHIFT);
+                mem.index = item->user_hash.key;
         } else {
-                agp.offset = 0;
-                agp.size = 0;
-                agp.free = 0;
+                mem.offset = 0;
+                mem.size = 0;
+                mem.index = 0;
+                DRM_DEBUG("Video memory allocation failed\n");
+                retval = DRM_ERR(ENOMEM);
         }
+        DRM_COPY_TO_USER_IOCTL((drm_via_mem_t __user *) data, mem, sizeof(mem));
 
-        mem->offset = agp.offset;
-        mem->index = agp.free;
-
-        DRM_DEBUG("alloc agp, size = %d, offset = %d\n", agp.size,
-                  (unsigned int)agp.offset);
         return retval;
 }
 
 int via_mem_free(DRM_IOCTL_ARGS)
 {
+        DRM_DEVICE;
+        drm_via_private_t *dev_priv = dev->dev_private;
         drm_via_mem_t mem;
+        int ret;
 
         DRM_COPY_FROM_USER_IOCTL(mem, (drm_via_mem_t __user *) data,
                                  sizeof(mem));
 
-        switch (mem.type) {
+        mutex_lock(&dev->struct_mutex);
+        ret = drm_sman_free_key(&dev_priv->sman, mem.index);
+        mutex_unlock(&dev->struct_mutex);
+        DRM_DEBUG("free = 0x%lx\n", mem.index);
 
-        case VIA_MEM_VIDEO:
-                if (via_fb_free(&mem) == 0)
-                        return 0;
-                break;
-        case VIA_MEM_AGP:
-                if (via_agp_free(&mem) == 0)
-                        return 0;
-                break;
-        }
-
-        return -EFAULT;
+        return ret;
 }
 
-static int via_fb_free(drm_via_mem_t * mem)
-{
-        drm_via_mm_t fb;
-        int retval = 0;
-
-        if (!FBHeap) {
-                return -1;
-        }
-
-        fb.free = mem->index;
-        fb.context = mem->context;
-
-        if (!fb.free) {
-                return -1;
-
-        }
-
-        via_mmFreeMem((PMemBlock) fb.free);
-
-        if (!del_alloc_set(fb.context, VIA_MEM_VIDEO, fb.free)) {
-                retval = -1;
-        }
-
-        DRM_DEBUG("free fb, free = %ld\n", fb.free);
 
-        return retval;
-}
-
-static int via_agp_free(drm_via_mem_t * mem)
+void via_reclaim_buffers_locked(drm_device_t * dev, struct file *filp)
 {
-        drm_via_mm_t agp;
-
-        int retval = 0;
+        drm_via_private_t *dev_priv = dev->dev_private;
+        drm_file_t *priv = filp->private_data;
 
-        agp.free = mem->index;
-        agp.context = mem->context;
-
-        if (!agp.free)
-                return -1;
-
-        via_mmFreeMem((PMemBlock) agp.free);
-
-        if (!del_alloc_set(agp.context, VIA_MEM_AGP, agp.free)) {
-                retval = -1;
+        mutex_lock(&dev->struct_mutex);
+        if (drm_sman_owner_clean(&dev_priv->sman, (unsigned long)priv)) {
+                mutex_unlock(&dev->struct_mutex);
+                return;
         }
 
-        DRM_DEBUG("free agp, free = %ld\n", agp.free);
+        if (dev->driver->dma_quiescent) {
+                dev->driver->dma_quiescent(dev);
+        }
 
-        return retval;
+        drm_sman_owner_cleanup(&dev_priv->sman, (unsigned long)priv);
+        mutex_unlock(&dev->struct_mutex);
+        return;
 }
diff --git a/drivers/char/ds1286.c b/drivers/char/ds1286.c
index 21c8229f5443..6d58b0370802 100644
--- a/drivers/char/ds1286.c
+++ b/drivers/char/ds1286.c
@@ -104,7 +104,7 @@ static int ds1286_ioctl(struct inode *inode, struct file *file,
         switch (cmd) {
         case RTC_AIE_OFF:       /* Mask alarm int. enab. bit    */
         {
-                unsigned int flags;
+                unsigned long flags;
                 unsigned char val;
 
                 if (!capable(CAP_SYS_TIME))
@@ -120,7 +120,7 @@ static int ds1286_ioctl(struct inode *inode, struct file *file,
         }
         case RTC_AIE_ON:        /* Allow alarm interrupts.      */
         {
-                unsigned int flags;
+                unsigned long flags;
                 unsigned char val;
 
                 if (!capable(CAP_SYS_TIME))
@@ -136,7 +136,7 @@ static int ds1286_ioctl(struct inode *inode, struct file *file,
         }
         case RTC_WIE_OFF:       /* Mask watchdog int. enab. bit */
         {
-                unsigned int flags;
+                unsigned long flags;
                 unsigned char val;
 
                 if (!capable(CAP_SYS_TIME))
@@ -152,7 +152,7 @@ static int ds1286_ioctl(struct inode *inode, struct file *file,
         }
         case RTC_WIE_ON:        /* Allow watchdog interrupts.   */
         {
-                unsigned int flags;
+                unsigned long flags;
                 unsigned char val;
 
                 if (!capable(CAP_SYS_TIME))
@@ -434,7 +434,7 @@ static inline unsigned char ds1286_is_updating(void)
 static void ds1286_get_time(struct rtc_time *rtc_tm)
 {
         unsigned char save_control;
-        unsigned int flags;
+        unsigned long flags;
         unsigned long uip_watchdog = jiffies;
 
         /*
@@ -494,7 +494,8 @@ static int ds1286_set_time(struct rtc_time *rtc_tm)
 {
         unsigned char mon, day, hrs, min, sec, leap_yr;
         unsigned char save_control;
-        unsigned int yrs, flags;
+        unsigned int yrs;
+        unsigned long flags;
 
 
         yrs = rtc_tm->tm_year + 1900;
@@ -552,7 +553,7 @@ static int ds1286_set_time(struct rtc_time *rtc_tm)
 static void ds1286_get_alm_time(struct rtc_time *alm_tm)
 {
         unsigned char cmd;
-        unsigned int flags;
+        unsigned long flags;
 
         /*
          * Only the values that we read from the RTC are set. That
diff --git a/drivers/char/dsp56k.c b/drivers/char/dsp56k.c
index 9b1bf60ffbe7..06f2dbf17710 100644
--- a/drivers/char/dsp56k.c
+++ b/drivers/char/dsp56k.c
@@ -201,7 +201,7 @@ static int dsp56k_upload(u_char __user *bin, int len)
 static ssize_t dsp56k_read(struct file *file, char __user *buf, size_t count,
                            loff_t *ppos)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         int dev = iminor(inode) & 0x0f;
 
         switch(dev)
@@ -264,7 +264,7 @@ static ssize_t dsp56k_read(struct file *file, char __user *buf, size_t count,
 static ssize_t dsp56k_write(struct file *file, const char __user *buf, size_t count,
                             loff_t *ppos)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         int dev = iminor(inode) & 0x0f;
 
         switch(dev)
@@ -420,7 +420,7 @@ static int dsp56k_ioctl(struct inode *inode, struct file *file,
 #if 0
 static unsigned int dsp56k_poll(struct file *file, poll_table *wait)
 {
-        int dev = iminor(file->f_dentry->d_inode) & 0x0f;
+        int dev = iminor(file->f_path.dentry->d_inode) & 0x0f;
 
         switch(dev)
         {
diff --git a/drivers/char/dtlk.c b/drivers/char/dtlk.c
index 5e82c3bad2e3..d4005e94fe5f 100644
--- a/drivers/char/dtlk.c
+++ b/drivers/char/dtlk.c
@@ -122,7 +122,7 @@ static void dtlk_timer_tick(unsigned long data);
 static ssize_t dtlk_read(struct file *file, char __user *buf,
                          size_t count, loff_t * ppos)
 {
-        unsigned int minor = iminor(file->f_dentry->d_inode);
+        unsigned int minor = iminor(file->f_path.dentry->d_inode);
         char ch;
         int i = 0, retries;
 
@@ -174,7 +174,7 @@ static ssize_t dtlk_write(struct file *file, const char __user *buf,
         }
 #endif
 
-        if (iminor(file->f_dentry->d_inode) != DTLK_MINOR)
+        if (iminor(file->f_path.dentry->d_inode) != DTLK_MINOR)
                 return -EINVAL;
 
         while (1) {
diff --git a/drivers/char/ec3104_keyb.c b/drivers/char/ec3104_keyb.c
index abac18b1871c..77f58ed6d59a 100644
--- a/drivers/char/ec3104_keyb.c
+++ b/drivers/char/ec3104_keyb.c
@@ -370,7 +370,7 @@ static void e5_receive(struct e5_struct *k)
         }
 }
 
-static void ec3104_keyb_interrupt(int irq, void *data, struct pt_regs *regs)
+static void ec3104_keyb_interrupt(int irq, void *data)
 {
         struct e5_struct *k = &ec3104_keyb;
         u8 msr, lsr;
diff --git a/drivers/char/epca.c b/drivers/char/epca.c
index 86d290e9f307..a0f822c9d74d 100644
--- a/drivers/char/epca.c
+++ b/drivers/char/epca.c
@@ -199,8 +199,8 @@ static int pc_ioctl(struct tty_struct *, struct file *,
                     unsigned int, unsigned long);
 static int info_ioctl(struct tty_struct *, struct file *,
                     unsigned int, unsigned long);
-static void pc_set_termios(struct tty_struct *, struct termios *);
-static void do_softint(void *);
+static void pc_set_termios(struct tty_struct *, struct ktermios *);
+static void do_softint(struct work_struct *work);
 static void pc_stop(struct tty_struct *);
 static void pc_start(struct tty_struct *);
 static void pc_throttle(struct tty_struct * tty);
@@ -1113,11 +1113,8 @@ static void __exit epca_module_exit(void)
                 ch = card_ptr[crd];
                 for (count = 0; count < bd->numports; count++, ch++) 
                 { /* Begin for each port */
-                        if (ch) {
-                                if (ch->tty)
-                                        tty_hangup(ch->tty);
-                                kfree(ch->tmp_buf);
-                        }
+                        if (ch && ch->tty)
+                                tty_hangup(ch->tty);
                 } /* End for each port */
         } /* End for each card */
         pci_unregister_driver (&epca_driver);
@@ -1125,7 +1122,7 @@ static void __exit epca_module_exit(void)
 
 module_exit(epca_module_exit);
 
-static struct tty_operations pc_ops = {
+static const struct tty_operations pc_ops = {
         .open = pc_open,
         .close = pc_close,
         .write = pc_write,
@@ -1160,6 +1157,7 @@ static int __init pc_init(void)
         int crd;
         struct board_info *bd;
         unsigned char board_id = 0;
+        int err = -ENOMEM;
 
         int pci_boards_found, pci_count;
 
@@ -1167,13 +1165,11 @@ static int __init pc_init(void)
 
         pc_driver = alloc_tty_driver(MAX_ALLOC);
         if (!pc_driver)
-                return -ENOMEM;
+                goto out1;
 
         pc_info = alloc_tty_driver(MAX_ALLOC);
-        if (!pc_info) {
-                put_tty_driver(pc_driver);
-                return -ENOMEM;
-        }
+        if (!pc_info)
+                goto out2;
 
         /* -----------------------------------------------------------------------
                 If epca_setup has not been ran by LILO set num_cards to defaults; copy
@@ -1240,6 +1236,8 @@ static int __init pc_init(void)
         pc_driver->init_termios.c_oflag = 0;
         pc_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;
         pc_driver->init_termios.c_lflag = 0;
+        pc_driver->init_termios.c_ispeed = 9600;
+        pc_driver->init_termios.c_ospeed = 9600;
         pc_driver->flags = TTY_DRIVER_REAL_RAW;
         tty_set_operations(pc_driver, &pc_ops);
 
@@ -1254,6 +1252,8 @@ static int __init pc_init(void)
         pc_info->init_termios.c_oflag = 0;
         pc_info->init_termios.c_lflag = 0;
         pc_info->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL;
+        pc_info->init_termios.c_ispeed = 9600;
+        pc_info->init_termios.c_ospeed = 9600;
         pc_info->flags = TTY_DRIVER_REAL_RAW;
         tty_set_operations(pc_info, &info_ops);
 
@@ -1373,11 +1373,17 @@ static int __init pc_init(void)
 
         } /* End for each card */
 
-        if (tty_register_driver(pc_driver))
-                panic("Couldn't register Digi PC/ driver");
+        err = tty_register_driver(pc_driver);
+        if (err) {
+                printk(KERN_ERR "Couldn't register Digi PC/ driver");
+                goto out3;
+        }
 
-        if (tty_register_driver(pc_info))
-                panic("Couldn't register Digi PC/ info ");
+        err = tty_register_driver(pc_info);
+        if (err) {
+                printk(KERN_ERR "Couldn't register Digi PC/ info ");
+                goto out4;
+        }
 
         /* -------------------------------------------------------------------
            Start up the poller to check for events on all enabled boards
@@ -1388,6 +1394,15 @@ static int __init pc_init(void)
         mod_timer(&epca_timer, jiffies + HZ/25);
         return 0;
 
+out4:
+        tty_unregister_driver(pc_driver);
+out3:
+        put_tty_driver(pc_info);
+out2:
+        put_tty_driver(pc_driver);
+out1:
+        return err;
+
 } /* End pc_init */
 
 /* ------------------ Begin post_fep_init  ---------------------- */
@@ -1494,7 +1509,7 @@ static void post_fep_init(unsigned int crd)
 
                 ch->brdchan        = bc;
                 ch->mailbox        = gd; 
-                INIT_WORK(&ch->tqueue, do_softint, ch);
+                INIT_WORK(&ch->tqueue, do_softint);
                 ch->board          = &boards[crd];
 
                 spin_lock_irqsave(&epca_lock, flags);
@@ -1635,16 +1650,6 @@ static void post_fep_init(unsigned int crd)
                 init_waitqueue_head(&ch->close_wait);
 
                 spin_unlock_irqrestore(&epca_lock, flags);
-
-                ch->tmp_buf = kmalloc(ch->txbufsize,GFP_KERNEL);
-                if (!ch->tmp_buf) {
-                        printk(KERN_ERR "POST FEP INIT : kmalloc failed for port 0x%x\n",i);
-                        release_region((int)bd->port, 4);
-                        while(i-- > 0)
-                                kfree((ch--)->tmp_buf);
-                        return;
-                } else
-                        memset((void *)ch->tmp_buf,0,ch->txbufsize);
         } /* End for each port */
 
         printk(KERN_INFO 
@@ -1998,7 +2003,7 @@ static void epcaparam(struct tty_struct *tty, struct channel *ch)
 { /* Begin epcaparam */
 
         unsigned int cmdHead;
-        struct termios *ts;
+        struct ktermios *ts;
         struct board_chan __iomem *bc;
         unsigned mval, hflow, cflag, iflag;
 
@@ -2113,7 +2118,7 @@ static void receive_data(struct channel *ch)
 { /* Begin receive_data */
 
         unchar *rptr;
-        struct termios *ts = NULL;
+        struct ktermios *ts = NULL;
         struct tty_struct *tty;
         struct board_chan __iomem *bc;
         int dataToRead, wrapgap, bytesAvailable;
@@ -2361,12 +2366,14 @@ static int pc_ioctl(struct tty_struct *tty, struct file * file,
         switch (cmd) 
         { /* Begin switch cmd */
 
+#if 0   /* Handled by calling layer properly */
                 case TCGETS:
-                        if (copy_to_user(argp, tty->termios, sizeof(struct termios)))
+                        if (copy_to_user(argp, tty->termios, sizeof(struct ktermios)))
                                 return -EFAULT;
                         return 0;
                 case TCGETA:
                         return get_termio(tty, argp);
+#endif
                 case TCSBRK:    /* SVID version: non-zero arg --> no break */
                         retval = tty_check_change(tty);
                         if (retval)
@@ -2535,7 +2542,7 @@ static int pc_ioctl(struct tty_struct *tty, struct file * file,
 
 /* --------------------- Begin pc_set_termios  ----------------------- */
 
-static void pc_set_termios(struct tty_struct *tty, struct termios *old_termios)
+static void pc_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
 { /* Begin pc_set_termios */
 
         struct channel *ch;
@@ -2565,9 +2572,9 @@ static void pc_set_termios(struct tty_struct *tty, struct termios *old_termios)
 
 /* --------------------- Begin do_softint  ----------------------- */
 
-static void do_softint(void *private_)
+static void do_softint(struct work_struct *work)
 { /* Begin do_softint */
-        struct channel *ch = (struct channel *) private_;
+        struct channel *ch = container_of(work, struct channel, tqueue);
         /* Called in response to a modem change event */
         if (ch && ch->magic == EPCA_MAGIC)  { /* Begin EPCA_MAGIC */
                 struct tty_struct *tty = ch->tty;
diff --git a/drivers/char/epca.h b/drivers/char/epca.h
index 456d6c8f94a8..a297238cd3ba 100644
--- a/drivers/char/epca.h
+++ b/drivers/char/epca.h
@@ -130,7 +130,6 @@ struct channel
         unsigned long  c_oflag;
         unsigned char __iomem *txptr;
         unsigned char __iomem *rxptr;
-        unsigned char *tmp_buf;
         struct board_info           *board;
         struct board_chan           __iomem *brdchan;
         struct digi_struct          digiext;
diff --git a/drivers/char/esp.c b/drivers/char/esp.c
index afcd83d9984b..d1bfbaa2aa02 100644
--- a/drivers/char/esp.c
+++ b/drivers/char/esp.c
@@ -615,8 +615,7 @@ static inline void check_modem_status(struct esp_struct *info)
 /*
  * This is the serial driver's interrupt routine
  */
-static irqreturn_t rs_interrupt_single(int irq, void *dev_id,
-                                        struct pt_regs *regs)
+static irqreturn_t rs_interrupt_single(int irq, void *dev_id)
 {
         struct esp_struct * info;
         unsigned err_status;
@@ -724,9 +723,10 @@ static irqreturn_t rs_interrupt_single(int irq, void *dev_id,
  * -------------------------------------------------------------------
  */
 
-static void do_softint(void *private_)
+static void do_softint(struct work_struct *work)
 {
-        struct esp_struct       *info = (struct esp_struct *) private_;
+        struct esp_struct       *info =
+                container_of(work, struct esp_struct, tqueue);
         struct tty_struct       *tty;
         
         tty = info->tty;
@@ -747,9 +747,10 @@ static void do_softint(void *private_)
  *      do_serial_hangup() -> tty->hangup() -> esp_hangup()
  * 
  */
-static void do_serial_hangup(void *private_)
+static void do_serial_hangup(struct work_struct *work)
 {
-        struct esp_struct       *info = (struct esp_struct *) private_;
+        struct esp_struct       *info =
+                container_of(work, struct esp_struct, tqueue_hangup);
         struct tty_struct       *tty;
         
         tty = info->tty;
@@ -1914,7 +1915,7 @@ static int rs_ioctl(struct tty_struct *tty, struct file * file,
         return 0;
 }
 
-static void rs_set_termios(struct tty_struct *tty, struct termios *old_termios)
+static void rs_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
 {
         struct esp_struct *info = (struct esp_struct *)tty->driver_data;
         unsigned long flags;
@@ -2376,7 +2377,7 @@ static inline int autoconfig(struct esp_struct * info)
         return (port_detected);
 }
 
-static struct tty_operations esp_ops = {
+static const struct tty_operations esp_ops = {
         .open = esp_open,
         .close = rs_close,
         .write = rs_write,
@@ -2502,8 +2503,8 @@ static int __init espserial_init(void)
                 info->magic = ESP_MAGIC;
                 info->close_delay = 5*HZ/10;
                 info->closing_wait = 30*HZ;
-                INIT_WORK(&info->tqueue, do_softint, info);
-                INIT_WORK(&info->tqueue_hangup, do_serial_hangup, info);
+                INIT_WORK(&info->tqueue, do_softint);
+                INIT_WORK(&info->tqueue_hangup, do_serial_hangup);
                 info->config.rx_timeout = rx_timeout;
                 info->config.flow_on = flow_on;
                 info->config.flow_off = flow_off;
diff --git a/drivers/char/ftape/Kconfig b/drivers/char/ftape/Kconfig
deleted file mode 100644
index 0d65189a7ae8..000000000000
--- a/drivers/char/ftape/Kconfig
+++ /dev/null
@@ -1,330 +0,0 @@
-#
-# Ftape configuration
-#
-config ZFTAPE
-        tristate "Zftape, the VFS interface"
-        depends on FTAPE
-        ---help---
-          Normally, you want to say Y or M. DON'T say N here or you
-          WON'T BE ABLE TO USE YOUR FLOPPY TAPE DRIVE.
-
-          The ftape module itself no longer contains the routines necessary
-          to interface with the kernel VFS layer (i.e. to actually write data
-          to and read data from the tape drive).  Instead the file system
-          interface (i.e. the hardware independent part of the driver) has
-          been moved to a separate module.
-
-          To compile this driver as a module, choose M here: the
-          module will be called zftape.
-
-          Regardless of whether you say Y or M here, an additional runtime
-          loadable module called `zft-compressor' which contains code to
-          support user transparent on-the-fly compression based on Ross
-          William's lzrw3 algorithm will be produced.  If you have enabled the
-          kernel module loader (i.e. have said Y to "Kernel module loader
-          support", above) then `zft-compressor' will be loaded
-          automatically by zftape when needed.
-
-          Despite its name, zftape does NOT use compression by default.
-
-config ZFT_DFLT_BLK_SZ
-        int "Default block size"
-        depends on ZFTAPE
-        default "10240"
-        ---help---
-          If unsure leave this at its default value, i.e. 10240. Note that
-          you specify only the default block size here. The block size can be
-          changed at run time using the MTSETBLK tape operation with the
-          MTIOCTOP ioctl (i.e. with "mt -f /dev/qft0 setblk #BLKSZ" from the
-          shell command line).
-
-          The probably most striking difference between zftape and previous
-          versions of ftape is the fact that all data must be written or read
-          in multiples of a fixed block size. The block size defaults to
-          10240 which is what GNU tar uses. The values for the block size
-          should be either 1 or multiples of 1024 up to a maximum value of
-          63488 (i.e. 62 K). If you specify `1' then zftape's builtin
-          compression will be disabled.
-
-          Reasonable values are `10240' (GNU tar's default block size),
-          `5120' (afio's default block size), `32768' (default block size some
-          backup programs assume for SCSI tape drives) or `1' (no restriction
-          on block size, but disables builtin compression).
-
-comment "The compressor will be built as a module only!"
-        depends on FTAPE && ZFTAPE
-
-config ZFT_COMPRESSOR
-        tristate
-        depends on FTAPE!=n && ZFTAPE!=n
-        default m
-
-config FT_NR_BUFFERS
-        int "Number of ftape buffers (EXPERIMENTAL)"
-        depends on FTAPE && EXPERIMENTAL
-        default "3"
-        help
-          Please leave this at `3' unless you REALLY know what you are doing.
-          It is not necessary to change this value. Values below 3 make the
-          proper use of ftape impossible, values greater than 3 are a waste of
-          memory. You can change the amount of DMA memory used by ftape at
-          runtime with "mt -f /dev/qft0 setdrvbuffer #NUMBUFFERS". Each buffer
-          wastes 32 KB of memory. Please note that this memory cannot be
-          swapped out.
-
-config FT_PROC_FS
-        bool "Enable procfs status report (+2kb)"
-        depends on FTAPE && PROC_FS
-        ---help---
-          Optional. Saying Y will result in creation of a directory
-          `/proc/ftape' under the /proc file system. The files can be viewed
-          with your favorite pager (i.e. use "more /proc/ftape/history" or
-          "less /proc/ftape/history" or simply "cat /proc/ftape/history"). The
-          file will contain some status information about the inserted
-          cartridge, the kernel driver, your tape drive, the floppy disk
-          controller and the error history for the most recent use of the
-          kernel driver. Saying Y will enlarge the size of the ftape driver
-          by approximately 2 KB.
-
-          WARNING: When compiling ftape as a module (i.e. saying M to "Floppy
-          tape drive") it is dangerous to use ftape's /proc file system
-          interface. Accessing `/proc/ftape' while the module is unloaded will
-          result in a kernel Oops. This cannot be fixed from inside ftape.
-
-choice
-        prompt "Debugging output"
-        depends on FTAPE
-        default FT_NORMAL_DEBUG
-
-config FT_NORMAL_DEBUG
-        bool "Normal"
-        ---help---
-          This option controls the amount of debugging output the ftape driver
-          is ABLE to produce; it does not increase or diminish the debugging
-          level itself. If unsure, leave this at its default setting,
-          i.e. choose "Normal".
-
-          Ftape can print lots of debugging messages to the system console
-          resp. kernel log files. Reducing the amount of possible debugging
-          output reduces the size of the kernel module by some KB, so it might
-          be a good idea to use "None" for emergency boot floppies.
-
-          If you want to save memory then the following strategy is
-          recommended: leave this option at its default setting "Normal" until
-          you know that the driver works as expected, afterwards reconfigure
-          the kernel, this time specifying "Reduced" or "None" and recompile
-          and install the kernel as usual. Note that choosing "Excessive"
-          debugging output does not increase the amount of debugging output
-          printed to the console but only makes it possible to produce
-          "Excessive" debugging output.
-
-          Please read <file:Documentation/ftape.txt> for a short description
-          how to control the amount of debugging output.
-
-config FT_FULL_DEBUG
-        bool "Excessive"
-        help
-          Extremely verbose output for driver debugging purposes.
-
-config FT_NO_TRACE
-        bool "Reduced"
-        help
-          Reduced tape driver debugging output.
-
-config FT_NO_TRACE_AT_ALL
-        bool "None"
-        help
-          Suppress all debugging output from the tape drive.
-
-endchoice
-
-comment "Hardware configuration"
-        depends on FTAPE
-
-choice
-        prompt "Floppy tape controllers"
-        depends on FTAPE
-        default FT_STD_FDC
-
-config FT_STD_FDC
-        bool "Standard"
-        ---help---
-          Only change this setting if you have a special controller. If you
-          didn't plug any add-on card into your computer system but just
-          plugged the floppy tape cable into the already existing floppy drive
-          controller then you don't want to change the default setting,
-          i.e. choose "Standard".
-
-          Choose "MACH-2" if you have a Mountain Mach-2 controller.
-          Choose "FC-10/FC-20" if you have a Colorado FC-10 or FC-20
-          controller.
-          Choose "Alt/82078" if you have another controller that is located at
-          an IO base address different from the standard floppy drive
-          controller's base address of `0x3f0', or uses an IRQ (interrupt)
-          channel different from `6', or a DMA channel different from
-          `2'. This is necessary for any controller card that is based on
-          Intel's 82078 FDC such as Seagate's, Exabyte's and Iomega's "high
-          speed" controllers.
-
-          If you choose something other than "Standard" then please make
-          sure that the settings for the IO base address and the IRQ and DMA
-          channel in the configuration menus below are correct. Use the manual
-          of your tape drive to determine the correct settings!
-
-          If you are already successfully using your tape drive with another
-          operating system then you definitely should use the same settings
-          for the IO base, the IRQ and DMA channel that have proven to work
-          with that other OS.
-
-          Note that this menu lets you specify only the default setting for
-          the hardware setup. The hardware configuration can be changed at
-          boot time (when ftape is compiled into the kernel, i.e. if you
-          have said Y to "Floppy tape drive") or module load time (i.e. if you
-          have said M to "Floppy tape drive").
-
-          Please read also the file <file:Documentation/ftape.txt> which
-          contains a short description of the parameters that can be set at
-          boot or load time. If you want to use your floppy tape drive on a
-          PCI-bus based system, please read the file
-          <file:drivers/char/ftape/README.PCI>.
-
-config FT_MACH2
-        bool "MACH-2"
-
-config FT_PROBE_FC10
-        bool "FC-10/FC-20"
-
-config FT_ALT_FDC
-        bool "Alt/82078"
-
-endchoice
-
-comment "Consult the manuals of your tape drive for the correct settings!"
-        depends on FTAPE && !FT_STD_FDC
-
-config FT_FDC_BASE
-        hex "IO base of the floppy disk controller"
-        depends on FTAPE && !FT_STD_FDC
-        default "0"
-        ---help---
-          You don't need to specify a value if the following default
-          settings for the base IO address are correct:
-          <<< MACH-2     : 0x1E0 >>>
-          <<< FC-10/FC-20: 0x180 >>>
-          <<< Secondary  : 0x370 >>>
-          Secondary refers to a secondary FDC controller like the "high speed"
-          controllers delivered by Seagate or Exabyte or Iomega's Ditto Dash.
-          Please make sure that the setting for the IO base address
-          specified here is correct. USE THE MANUAL OF YOUR TAPE DRIVE OR
-          CONTROLLER CARD TO DETERMINE THE CORRECT SETTING. If you are already
-          successfully using the tape drive with another operating system then
-          you definitely should use the same settings for the IO base that has
-          proven to work with that other OS.
-
-          Note that this menu lets you specify only the default setting for
-          the IO base. The hardware configuration can be changed at boot time
-          (when ftape is compiled into the kernel, i.e. if you specified Y to
-          "Floppy tape drive") or module load time (i.e. if you have said M to
-          "Floppy tape drive").
-
-          Please read also the file <file:Documentation/ftape.txt> which
-          contains a short description of the parameters that can be set at
-          boot or load time.
-
-config FT_FDC_IRQ
-        int "IRQ channel of the floppy disk controller"
-        depends on FTAPE && !FT_STD_FDC
-        default "0"
-        ---help---
-          You don't need to specify a value if the following default
-          settings for the interrupt channel are correct:
-          <<< MACH-2     : 6 >>>
-          <<< FC-10/FC-20: 9 >>>
-          <<< Secondary  : 6 >>>
-          Secondary refers to secondary a FDC controller like the "high speed"
-          controllers delivered by Seagate or Exabyte or Iomega's Ditto Dash.
-          Please make sure that the setting for the IO base address
-          specified here is correct. USE THE MANUAL OF YOUR TAPE DRIVE OR
-          CONTROLLER CARD TO DETERMINE THE CORRECT SETTING. If you are already
-          successfully using the tape drive with another operating system then
-          you definitely should use the same settings for the IO base that has
-          proven to work with that other OS.
-
-          Note that this menu lets you specify only the default setting for
-          the IRQ channel. The hardware configuration can be changed at boot
-          time (when ftape is compiled into the kernel, i.e. if you said Y to
-          "Floppy tape drive") or module load time (i.e. if you said M to
-          "Floppy tape drive").
-
-          Please read also the file <file:Documentation/ftape.txt> which
-          contains a short description of the parameters that can be set at
-          boot or load time.
-
-config FT_FDC_DMA
-        int "DMA channel of the floppy disk controller"
-        depends on FTAPE && !FT_STD_FDC
-        default "0"
-        ---help---
-          You don't need to specify a value if the following default
-          settings for the DMA channel are correct:
-          <<< MACH-2     : 2 >>>
-          <<< FC-10/FC-20: 3 >>>
-          <<< Secondary  : 2 >>>
-          Secondary refers to a secondary FDC controller like the "high speed"
-          controllers delivered by Seagate or Exabyte or Iomega's Ditto Dash.
-          Please make sure that the setting for the IO base address
-          specified here is correct. USE THE MANUAL OF YOUR TAPE DRIVE OR
-          CONTROLLER CARD TO DETERMINE THE CORRECT SETTING. If you are already
-          successfully using the tape drive with another operating system then
-          you definitely should use the same settings for the IO base that has
-          proven to work with that other OS.
-
-          Note that this menu lets you specify only the default setting for
-          the DMA channel. The hardware configuration can be changed at boot
-          time (when ftape is compiled into the kernel, i.e. if you said Y to
-          "Floppy tape drive") or module load time (i.e. if you said M to
-          "Floppy tape drive").
-
-          Please read also the file <file:Documentation/ftape.txt> which
-          contains a short description of the parameters that can be set at
-          boot or load time.
-
-config FT_FDC_THR
-        int "Default FIFO threshold (EXPERIMENTAL)"
-        depends on FTAPE && EXPERIMENTAL
-        default "8"
-        help
-          Set the FIFO threshold of the FDC. If this is higher the DMA
-          controller may serve the FDC after a higher latency time. If this is
-          lower, fewer DMA transfers occur leading to less bus contention.
-          You may try to tune this if ftape annoys you with "reduced data
-          rate because of excessive overrun errors" messages. However, this
-          doesn't seem to have too much effect.
-
-          If unsure, don't touch the initial value, i.e. leave it at "8".
-
-config FT_FDC_MAX_RATE
-        int "Maximal data rate to use (EXPERIMENTAL)"
-        depends on FTAPE && EXPERIMENTAL
-        default "2000"
-        ---help---
-          With some motherboard/FDC combinations ftape will not be able to
-          run your FDC/tape drive combination at the highest available
-          speed. If this is the case you'll encounter "reduced data rate
-          because of excessive overrun errors" messages and lots of retries
-          before ftape finally decides to reduce the data rate.
-
-          In this case it might be desirable to tell ftape beforehand that
-          it need not try to run the tape drive at the highest available
-          speed. If unsure, leave this disabled, i.e. leave it at 2000
-          bits/sec.
-
-config FT_ALPHA_CLOCK
-        int "CPU clock frequency of your DEC Alpha" if ALPHA
-        depends on FTAPE
-        default "0"
-        help
-          On some DEC Alpha machines the CPU clock frequency cannot be
-          determined automatically, so you need to specify it here ONLY if
-          running a DEC Alpha, otherwise this setting has no effect.
-
diff --git a/drivers/char/ftape/Makefile b/drivers/char/ftape/Makefile
deleted file mode 100644
index 0e67d2f8b7ec..000000000000
--- a/drivers/char/ftape/Makefile
+++ /dev/null
@@ -1,28 +0,0 @@
-#
-#       Copyright (C) 1997 Claus Heine.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2, or (at your option)
-# any later version.
-# 
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-# 
-# You should have received a copy of the GNU General Public License
-# along with this program; see the file COPYING.  If not, write to
-# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-#
-# $Source: /homes/cvs/ftape-stacked/ftape/Makefile,v $
-# $Revision: 1.4 $
-# $Date: 1997/10/05 19:17:56 $
-#
-#      Makefile for the QIC-40/80/3010/3020 floppy-tape driver for
-#      Linux.
-#
-
-obj-$(CONFIG_FTAPE)             += lowlevel/
-obj-$(CONFIG_ZFTAPE)            += zftape/
-obj-$(CONFIG_ZFT_COMPRESSOR)    += compressor/
diff --git a/drivers/char/ftape/README.PCI b/drivers/char/ftape/README.PCI
deleted file mode 100644
index 18de159d36e0..000000000000
--- a/drivers/char/ftape/README.PCI
+++ /dev/null
@@ -1,81 +0,0 @@
-Some notes for ftape users with PCI motherboards:
-=================================================
-
-The problem:
-------------
-
-There have been some problem reports from people using PCI-bus based
-systems getting overrun errors.
-I wasn't able to reproduce these until I ran ftape on a Intel Plato
-(Premiere PCI II) motherboard with bios version 1.00.08AX1.
-It turned out that if GAT (Guaranteed Access Timing) is enabled (?)
-ftape gets a lot of overrun errors.
-The problem disappears when disabling GAT in the bios.
-Note that Intel removed this setting (permanently disabled) from the
-1.00.10AX1 bios !
-
-It looks like that if GAT is enabled there are often large periods
-(greater than 120 us !??) on the ISA bus that the DMA controller cannot
-service the floppy disk controller.
-I cannot imagine this being acceptable in a decent PCI implementation.
-Maybe this is a `feature' of the chipset. I can only speculate why
-Intel choose to remove the option from the latest Bios...
-
-The lesson of this all is that there may be other motherboard
-implementations having the same of similar problems.
-If you experience a lot of overrun errors during a backup to tape,
-see if there is some setting in the Bios that may influence the
-bus timing.
-
-I judge this a hardware problem and not a limitation of ftape ;-)
-My DOS backup software seems to be suffering from the same problems
-and even refuses to run at 1 Mbps !
-Ftape will reduce the data-rate from 1 Mbps to 500 Kbps if the number
-of overrun errors on a track exceeds a threshold.
-
-
-Possible solutions:
--------------------
-
-Some of the problems were solved by upgrading the (flash) bios.
-Other suggest that it has to do with the FDC being on the PCI
-bus, but that is not the case with the Intel Premiere II boards.
-[If upgrading the bios doesn't solve the problem you could try
-a floppy disk controller on the isa-bus].
-
-Here is a list of systems and recommended BIOS settings:
-
-
-        Intel Premiere PCI (Revenge):
-
-Bios version 1.00.09.AF2 is reported to work.
-
-
-
-        Intel Premiere PCI II (Plato):
-
-Bios version 1.00.10.AX1 and version 11 beta are ok.
-If using version 1.00.08.AX1, GAT must be disabled !
-
-
-
-        ASUS PCI/I-SP3G:
-
-Preferred settings:     ISA-GAT-mode : disabled
-                        DMA-linebuffer-mode : standard
-                        ISA-masterbuffer-mode : standard
-
-
-        DELL Dimension XPS P90
-
-Bios version A2 is reported to be broken, while bios version A5 works.
-You can get a flash bios upgrade from http://www.dell.com
-
-
-To see if you're having the GAT problem, try making a backup
-under DOS. If it's very slow and often repositions you're
-probably having this problem.
-
-                        --//--
- LocalWords:  ftape PCI bios GAT ISA DMA chipset Mbps Kbps FDC isa AF ok ASUS
- LocalWords:  SP linebuffer masterbuffer XPS http www com
diff --git a/drivers/char/ftape/RELEASE-NOTES b/drivers/char/ftape/RELEASE-NOTES
deleted file mode 100644
index 03799dbc05a4..000000000000
--- a/drivers/char/ftape/RELEASE-NOTES
+++ /dev/null
@@ -1,966 +0,0 @@
-Hey, Emacs, we're -*-Text-*- mode!
-
-===== Release notes for ftape-3.04d 25/11/97 =====
-- The correct pre-processor statement for "else if" is "#elif" not
-  "elsif".
-- Need to call zft_reset_position() when overwriting cartridges
-  previously written with ftape-2.x, sftape, or ancient
-  (pre-ftape-3.x) versions of zftape.
-
-===== Release notes for ftape-3.04c 16/11/97 =====
-- fdc_probe() was calling DUMPREGS with a result length of "1" which
-  was just fine. Undo previous change.
-
-===== Release notes for ftape-3.04b 14/11/97 =====
-
-- patches/2.x.x/floppy.c.diff was somewhat broken, releasing i/o
-  regions it never had allocated.
-- fdc_probe() was calling DUMPREGS with a result length of "1" instead
-  of "10"
-- Writing deleted data marks if the first segents on track zero are
-  should work now.
-- ftformat should now be able to handle those cases where the tape
-  drive sets the read only status bit (QIC-40/80 cartridges with
-  QIC-3010/3020 tape drives) because the header segment is damaged.
-- the MTIOCFTCMD ioctl may now be issued by the superuser ONLY.
-
-===== Release notes for ftape-3.04a 12/11/97 =====
-- Fix an "infinite loop can't be killed by signal" bug in
-  ftape_get_drive_status(). Only relevant when trying to access
-  buggy/misconfigured hardware
-- Try to compensate a bug in the HP Colorado T3000's firmware: it
-  doesn't set the write protect bit for QIC80/QIC40 cartridges.
-
-===== Release notes for ftape-3.04 06/11/97 =====
-- If positioning with fast seeking fails fall back to a slow seek
-  before giving up.
-- (nearly) no retries on "no data errors" when verifying after
-  formatting. Improved tuning of the bad sector map after formatting.
-- the directory layout has changed again to allow for easier kernel
-  integration
-- Module parameter "ftape_tracing" now is called "ft_tracing" because
-  the "ftape_tracing" variable has the version checksum attached to it.
-- `/proc/ftape' interface for 2.0.* kernels. `/proc/ftape' no longer
-  is a directory but a file that contains all the information formerly
-  provided in separate files under the `/proc/ftape/' directory.
-- Most of the configuration options have been prefixed by "CONFIG_FT_"
-  in preparation of the kernel inclusion. The Makefiles under
-  "./ftape/" should be directly usable by the kernel.
-- The MODVERSIONS stuff is now auto-detected.
-- Broke backslashed multi line options in MCONFIG into separate lines
-  using GNU-make's "+=" feature.
-- The html and dvi version of the manual is now installed under
-  '/usr/doc/ftape` with 'make install`
-- New SMP define in MCONFIG. ftape works with SMP if this is defined.
-- attempt to cope with "excessive overrun errors" by gradually
-  increasing FDC FIFO threshold. But this doesn't seem to have too
-  much an effect.
-- New load time configuration parameter "ft_fdc_rate_limit". If you
-  encounter too many overrun errors with a 2Mb controller then you
-  might want to set this to 1000.
-- overrun errors on the last sector in a segment sometimes result in
-  a zero DMA residue. Dunno why, but compensate for it.
-- there were still fdc_read() timeout errors. I think I have fixed it
-  now, please FIXME.
-- Sometimes ftape_write() failed to re-start the tape drive when a
-  segment without a good sector was reached ("wait for empty segment
-  failed"). This is fixed. Especially important for > QIC-3010.
-- sftape (aka ftape-2.x) has vanished. I didn't work on it for
-  ages. It is probably still possible to use the old code with
-  ftape-3.04, if one really needs it (BUT RECOMPILE IT)
-- zftape no longer alters the contents of already existing volume
-  table entries, which makes it possible to fill in missing fields,
-  like time stamps using some user space program.
-- ./contrib/vtblc/ contains such a program.
-- new perl script ./contrib/scripts/listtape that list the contents of a
-  floppy tape cartridge parsing the output of "mt volinfo" + "mt fsf"
-- the MTWEOF implementation has changed a little bit (after I had a
-  look at amanda). Calling MTWEOF while the tape is still held open
-  after writing something to the tape now will terminate the current
-  volume, and start a new one at the current position.
-- the volume table maintained by zftape now is a doubly linked list
-  that grows dynamically as needed.
-
-  formatting floppy tape cartridges
-  ---------------------------------
-  * there is a new user space formatting program that does most of the
-    dirty work in user space (auto-detect, computing the sector
-    coordinates, adjusting time stamps and statistics). It has a
-    simple command line interface.
-  * ftape-format.o has vanished, it has been folded into the low level
-    ftape.o module, and the ioctl interface into zftape.o. Most of the
-    complicated stuff has been moved to user space, so there was no
-    need for a separate module anymore.
-  * there is a new ioctl MTIOCFTCMD that sends a bare QIC-117 command
-    to the tape drive.
-  * there is a new mmap() feature to map the dma buffers into user
-    space to be used by the user level formatting program.
-  * Formatting of yet unformatted or totally degaussed cartridges
-    should be possible now. FIXME.
-
-===== Release notes for ftape-3.03b, <forgot the exact date> ====
-
-ftape-3.03b was released as a beta release only. Its main new feature
-was support of the DITTO-2GB drive. This was made possible by reverse
-engineering done by <fill in his name> after Iomega failed to support
-ftape. Although they had promised to do so (this makes me feel a bit
-sad and uncomfortable about Iomega).
-
-===== Release notes for ftape-3.03a, 22/05/97 ====
-
-- Finally fixed auto-un-loading of modules for kernels > 2.1.18
-- Add an "uninstall" target to the Makefile
-- removed the kdtime hack
-- texi2www didn't properly set the back-reference from a footnote back
-  to the regular text.
-
-  zftape specific
-  ---------------
-  * hide the old compression map volume. Taper doesn't accept the
-    presence of non-Taper volumes and Taper-written volume on the same
-    tape.
-  * EOD (End Of Data) handling was still broken: the expected behavior
-    is to return a zero byte count at the first attempt to read past
-    EOD, return a zero byte count at the second attempt to read past
-    EOD and THEN return -EIO.
-  
-  ftape-format specific
-  ---------------------
-  * Detection of QIC-40 cartridges in select_tape_format() was broken
-    and made it impossible to format QIC-3010/3020 cartridges.
-  * There are strange "TR-1 Extra" cartridges out there which weren't
-    detected properly because the don't strictly conform to the
-    QIC-80, Rev. N, spec.
-
-===== Release notes for ftape-3.03, 30/04/97 =====
-
-- Removed kernel integration code from the package. I plan to provide
-  a package that can be integrated into the stock kernel separately
-  (hopefully soon).
-  As a result, a simple `make' command now will build everything.
-- ALL compile time configuration options have been moved to the file
-  `MCONFIG'.
-- Quite a few `low level' changes to allow formatting of cartridges.
-- formatting is implemented as a separate module `ftape-format.o'. The
-  modified `mt' program contains sample code that shows how to use it.
-- The VFS interface has been moved from the `ftape.o' module to the
-  high level modules `zftape.o' resp. `sftape.o'. `ftape.o' contains
-  the hardware support only.
-- A bit of /proc support for kernels > 2.1.28
-- Moved documentation to Doc subdir. INSTALL now contains some real
-  installation notes.
-- `install' target in Makefile.
-
-zftape specific:
-----------------
-
-- zftape works for large cartridges now ( > 2^31 bytes)
-- MTIOCVOLINFO and MTIOCGETSIZE now return the size in KILOBYTES,
-  NO LONGER in bytes.
-
-- permissions for write access to a cartridge have changed:
-  * zftape now also takes the file access mode into account
-  * zftape no longer allows writing in the middle of the recorded
-    media. The tape has to be positioned at BOT or EOD for write
-    access.
-
-- MTBSF has changed. It used to position at the beginning of the
-  previous file when called with count 1. This was different from the
-  expected behavior for other Un*x tape drivers (i.e. SCSI). MTBSF
-  with count 1 should merely position at the beginning of the current
-  volume. Fixed. As a result, `tar --verify' now produces the desired
-  result: it verifies the last written volume, not the pre-last
-  written volume.
-
-- The compression map has vanished --> no need for `mt erase' any
-  more. Fast seeking in a compressed volume is still be possible, but
-  takes slightly longer. As a side effect, you may experience an
-  additional volume showing up in front of all others for old
-  cartridges. This is the tape volume that holds the compression map.
-
-- The compression support for zftape has been moved to a separate
-  module `zft-compressor'. DON'T forget to load it before trying to
-  read back compressed volumes. The stock `zftape.o' module probes for
-  the module `zft-compressor' using the kerneld message channel; you
-  have to install `zft-compressor.o' in a place where modprobe can
-  find it if you want to use this.
-
-- New experimental feature that tries to get the broken down GMT time
-  from user space via a kernel daemon message channel. You need to
-  compile and start the `kdtime' daemon contained in the contrib
-  directory to use it. Needed (?) for time stamps in the header
-  segments and the volume table.
-
-- variable block size mode via MTSETBLK 0
-
-- keep modules locked in memory after the block size has been changed
-
-sftape specific:
-----------------
-
-- end of tape handling should be fixed, i.e. multi volume archives
-  written with `afio' can be read back now.
-
-
-===== Release notes for ftape-3.02a, 09/01/97 =====
-
-No big news:
-- call zft_init() resp. sft_init() when compiling the entire stuff
-  into the kernel image.
-- fix bug in ftape-setup.c when NO_TRACE_AT_ALL was defined.
-- fix bug in sftape-eof.c/zftape-eof.c for old kernels (1.2.*)
-- add support for new module interface for recent kernels
-
-===== Release notes for ftape-3.02, 16/12/96 =====
-- Fixed the `FDC unlock command failed' bug in fdc-io.c. When the FIFO
-  was already locked when ftape was loaded, ftape failed to unlock it.
-- Fixed compilation of `contrib/gnumt'. It now finds `mtio.h' even if
-  ftape is NOT included into the kernel source tree.
-- fc-10.c: include <asm/io.h> for inb() and outb().
-- ftape/sftape/zftape: all global variable now have either a `ftape_',
-  a `ft_', `sft_', `zft_' or `qic_' prefix to prevent name clashes
-  with other parts of the kernel when including ftape into the kernel
-  source tree.
-- Kerneld support has changed. `ftape' now searches for a module
-  `ftape-frontend' when none of the frontend (`sftape' or `zftape') is
-  loaded. Please refer to the `Installation/Loading ftape' section of
-  the TeXinfo manual.
-- Add load resp. boot-time configuration of ftape. There are now
-  variables ft_fdc_base, ft_fdc_dma and ft_fdc_irq corresponding to
-  the former FDC_BASE etc. compile time definitions. One can also use
-  the kernel command line parameters to configure the driver if it is
-  compiled into the kernel. Also, the FC-10/FC-20 support is load-time
-  configurable now as well as the MACH-II hack (ft_probe_fc10,
-  resp. ft_mach2). Please refer to the section `Installation/Configure
-  ftape' of the TeXinfo manual.
-- I removed the MODVERSIONS option from `Makefile.module'. Let me alone
-  with ftape and MODVERSIONS unless you include the ftape sources into
-  the kernel source tree.
-- new vendors in `vendors.h':
-  * HP Colorado T3000 
-  * ComByte DoublePlay (including a bug fix for their broken
-    formatting software, thanks to whraven@njackn.com)
-  * Iomega DITTO 2GIG. NOTE: this drive cannot work with ftape because
-    the logical data layout of the cartridges used by this drive does
-    NOT conform to the QIC standards, it is a special Iomega specific
-    format. I've sent mail to Iomega but didn't receive an answer
-    yet. If you want this drive to be supported by ftape, ask Iomega
-    to give me information about it.
-- zftape:
-  * re-introduced the MTIOC_ZFTAPE_GETBLKSZ ioctl for compatibility
-    with zftape 1.06a and earlier. Please don't use it when writing
-    new software, use the MTIOCVOLINFO ioctl instead.
-  * Major overhaul of the code that updates the header segments. Never
-    change the tape label unless erasing the tape. Thus we almost
-    never need to write the header segments, unless we would modify
-    the bad sector map which isn't done yet. Updating of volume table
-    and compression map more secure now although it takes a bit
-    longer.
-  * Fixed bug when aborting a write operation with a signal: zftape
-    now finishes the current volume (i.e. writes an eof marker) at the
-    current position. It didn't before which led to somehow *strange*
-    behavior in this cases.
-  * Keep module locked in memory when using it with  the non-rewinding
-    devices and the tape is not logical at BOT. Needed for kerneld
-    support.
-- sftape:
-  * Keep module locked in memory when using it with  the non-rewinding
-    devices and the tape is not logical at BOT. Needed for kerneld
-    support.
-
-===== Release notes for ftape-3.01, 14/11/96 =====
-
-- Fixed silly bugs in ftape-3.00:
-  * MAKEDEV.ftape: major device number must be 27, not 23 
-  * sftape/sftape-read.c: sftape_read_header_segments() called 
-    itself recursively instead of calling ftape_read_header_segment()
-  * zftape/qic-vtbl.h: conversion of ftape's file marks to zftape's
-    internal volume table was broken.
-  * patches/2.x.x/linux-2.0.21.dif: my RCS (resp. CVS) system replaced
-    the `$Revison:' etc. macros in the `ftape.h' concerning part of the
-    patch :-( Fixed.
-  * info/ftape.info: Fixed misspellings (`cp' <-> `cp -r' etc.)
-  * when ftape/sftape or ftape/zftape was compiled into the kernel the
-    variable ftape_status was declared twice. Fixed.
-  * removed reference to undeclared variable kernel_version when not
-    compiling as module
-  * fixed a bug introduced by the use of bit-fields for some flags
-    (i.e. write_protected, no_cartridge, formatted)
-  * flag `header_read' is now reset correctly to zero when tape is
-    removed.
-- fixed a bug in sftape/sftape-eof.c that was already in the original
-  ftape code. MTFSF/BSF was not handled correctly when positioned
-  right before the file mark (think of tar)
-- Changed TRACE macros (following a suggestion of Marcin Dalecki) to use
-  the predefined __FUNCTION__ macro of GCC. Spares about 4k of code.
-- added new vendor id for Iomega DITTO 2GIG
-- fixed a bug already present in zftape-1.06 when aborting a write
-  with a signal: we now finish the current volume at that
-  position. Header segments remain NOT up to date until an explicit call
-  to MTREW or MTOFFL is done.  
-
-===== Release notes for ftape-3.00, 14/10/96 =====
-
-- Merged ftape with zftape. There are three modules now:
-  ftape for the hardware support, sftape for the implementation of the
-  original ftape eof mark stuff and zftape that implements zftape's way
-  of handling things (compression, volume table, tape blocks of
-  constant length)
-- Documentation in TeXinfo format in the `info' subdirectory.
-- New ioctls for zftape. See zftape/zftape.h
-- Dummy formatting ioctl for ftape. See ftape.h
-- Kernel patch files for the 2.*.* series to include ftape-3.00 in the
-  kernel source tree. These includes a kernel compatible Config.in
-  script and fairly large online information for the kernel configure
-  script.
-- Support for compiling with Linux-1.2.13. 
-- Modified GNU mt from their cpio package that can handle the new
-  ioctls.
-- ftape/sftape/zftape is kerneld save now!
-
-Notes on sftape:
-- sftape implements the eof handling code of the original ftape. If
-  you like to stick with the original ftape stuff, you have to use
-  this module, not zftape.
-- sftape is kerneld save, unlike the original ftape.
-- we keep the entire header segment now in memory, so no need to read
-  it before updating the header segments. Additional memory
-  consumption: 256 bytes. 
-
-Notes for zftape:
-- zftape has support for tapes with format code 6 now, which use a
-  slightly different volume table format compared with other floppy
-  tapes.
-- new ioctls for zftape. Have a look at zftape/zftape.h
-- The internal volume table representation has changed for zftape. Old
-  cartridges are converted automatically.
-- zftape no longer uses compression map segments, which have vanished
-  from the QIC specs, but creates volume table entry that reserves
-  enough space for the compression map. 
-- zftape is kerneld save now.
-- we keep the entire header segment now in memory, so no need to read
-  it before updating the header segments. Additional memory
-  consumption: 256 bytes. 
-
-Notes for contrib/gnumt:
-- modified mt from the GNU cpio package that supports all the new
-  ioctls of zftape.
-Notes for contrib/swapout:
-- This contains the swapout.c program that was written by Kai
-  Harrekilde-Pederson. I simply added a Makefile.
-
-===== Release notes for ftape-2.10, 14/10/96 =====
-
-The ftape maintainer has changed. 
-Kai Harrekilde-Petersen <khp@dolphinics.no>
-has resigned from maintaining ftape, and I,
-Claus-Justus Heine <claus@momo.math.rwth-aachen.de>,
-have taken over.
-
-- Added support for tapes with `format code 6', i.e. QIC-3020 tapes
-  with more than 2^16 segments.
-- merged changes made by Bas Laarhoven with ftape-2.09. Refer
-  to his release notes below. I've included them into this
-  file unchanged for your reference.
-- disabled call stack back trace for now. This new feature
-  introduced by the interim release 2.0.x still seems to
-  be buggy.
-- Tried to minimize differences between the ftape version
-  to be included into the kernel source tree and the standalone
-  module version.
-- Reintroduced support for Linux-1.2.13. Please refer to the
-  Install-guide. 
-
-===== Release notes for ftape-2.09, 16/06/96 =====
-
-There aren't any really big news in this release, mostly just that I
-(the maintainer) have changed my email address (due to a new job).  My
-new address is <khp@dolphinics.no>
-
-- The CLK_48MHZ and FDC_82078SL options has gone (all 2Mbps cards seem
-  to use a 48MHz oscillator anyway and I haven't heard of an 'SL
-  chip out there).
-- The S82078B has been `downgraded' to i82077AA compability.
-- TESTING option revived.  Right now, it'll enable the (seriously broken)
-  2Mbps code.  If you enable it, you'll experience a tape drive that's
-  *really* out to lunch!
-- Some (bold) changes in the init code.  Please notify me if they
-  break things for you.
-
-===== Release notes for ftape-2.08, 14/03/96 =====
-
-If you correct a problem with ftape, please send your patch to
-khp@dolphinics.no too.
-
-- Updated to reflect that NR_MEM_LISTS is gone in 1.3.74
-- Teac 700 added to list of known drives.
-- The registered device name is now "ft" rather than "ftape".
-
-===== Release notes for ftape-2.07a, 14/03/96 =====
-
-Bugfixes by Marcin Dalecki <dalecki@namu03.gwdg.de>:
-- In the last release it just compiled against 1.3.70;
-  now the params to request_irq() and free_irq are() are fixed, so it also 
-  works in 1.3.73 :-)
-- Support for modules is now correct for newer kernels.
-
-===== Release notes for ftape-2.07, 04/03/96 =====
-
-
-- ftape updated to compile against 1.3.70.
-- Iomega 700 and Wangtek 3200 recognised.
-
-
-===== Release notes for ftape-2.06b, 13/02/96 =====
-
-Another simple bugfix version.
-
-- Jumbo 700 recognised.
-- Typo in vendors.h fixed.
-
-
-===== Release notes for ftape-2.06a, 10/02/96 =====
-
-This release is a simple bugfix version.
-
-- Linux/SMP: ftape *should* work.
-- FC-10/20: Only accepts IRQs 3-7, or 9.  If IRQ 9, properly tell the card
-  to use IRQ 2.  Thanks to Greg Crider (gcrider@iclnet.org) for finding and
-  locating this bug and testing the patch.
-- Insight drive recognised correctly again.
-- Motor-on wakeup version of the Iomega 250 drive added
-
-
-===== Release notes for ftape-2.06, 28/01/96 =====
-
-Special thanks go to Neal Friedman and Steven Sorbom for their
-help in producing and testing this release.
-
-I have continued to clean up the code, with an eye towards inclusion
-of ftape in Linus' official kernel (In fact, as I type this, I am
-running on a kernel with ftape support statically linked).  I have
-test-compiled ftape against my 1.2.13 tree without problems.
-Hopefully, everything should be OK for the v1.2.x people.
-
-WARNING! Alan Cox has mailed me that ftape does *NOT* work with
-Linux/SMP.  If you try to run ftape under Linux/SMP, it will cause a
-kernel deadlock (which is worse than a panic).
-
-- QIC-3020/TR-3: 1Mbps support works.  Neal is capable of reading and
-  writing data to a tape.  ftape will automatically detect the type of
-  tape (e.g. TR-3 vs QIC-80) and move the fdc in and out of
-  "perpendicular mode" as necessary.
-- 2Mbps support is disabled by default, since it is not fully
-  debugged.  If you are adventurous, remove -DFDC_82078SL in the
-  Makefile and see what happens :-)
-- fdc detection: silly bugs removed (Only 2Mbps fdcs were affected)
-  and added detection of the National Semiconductors PC8744 fdc chip
-  (used in the PC873xx "super-IO" chips).
-- Removed warning about incompatible types when compiling with Linux
-  1.2.x.
-- README.PCI updated with info about the DELL Dimension XPS P90.
-- Connor TST3200R added to detected drives.
-- `swapout' utility added to distribution.  It will dirty 5Meg of
-  memory, trying to swap out other programs.  Just say `make swapout'
-  to build it.  ftape will do this automatically Real Soon Now (ie:
-  when I have found out which kernel memory alloc function to call).
-
-
-===== Release notes for ftape-2.05, 08/01/96 =====
-
-- For v1.2.x Kernels, you must apply the patch linux-1.2/ksyms.patch to
-  the kernel and rebuild it (it adds the __get_dma_pages symbol to
-  ksyms.c).
-- Included new asm-i386/io.h file from v1.3.x kernel series, to enable
-  gcc v.2.7.[12] to compile v1.2.x kernels (linux-1.2/io.h).
-- Module versions: If you wish to compile ftape as a versioned module,
-  you must first compile your kernel with CONFIG_MODVERSIONS=y.
-  Otherwise, you will get complaints that <linux/modversions.h> does not
-  exist (if that happens, a `touch modversions.h' will help you out).
-- CLK_48MHZ: new define in the Makefile (default: non-zero).  If you have
-  a tape controller card that uses the i82078(-1) chip, but cannot get
-  it to work with ftape, try set it to 0 (and please report this).
-- QIC-3010/3020: Complete support is still missing, but will hopefully
-  come soon.  Steven Sorbom has kindly provided me with hints about
-  this.  Writing of QIC-3020 tapes definitely does NOT work (do not try
-  it! - the drive will not be in "perpendicular mode" and this will ruin
-  the formatting info on the tape).
-- ftape_num_buffers is out of fashion: use NR_BUFFERS instead (and
-  recompile if you want to change it :-).
-
-
-===== Release notes for ftape-2.04, 01/01/96 =====
-
-This version by Kai Harrekilde-Petersen <khp@dolphinics.no>
-
-- ALERT! Support for Kernels earlier then v1.1.85 is about to go away.
-  I intend to clean up some of the code (getting rid of an annoyingly
-  large numbers of #ifdef mostly), which means that support for
-  pre-1.1.85 kernels must go as well.
-- NR_FTAPE_BUFFERS is gone; You can instead select the number of dma
-  buffers by saying `insmod ftape.o ftape_num_buffer=<n>' instead.
-- Configure script gone.  ftape will now automagically determine your
-  kernel version by /usr/include/linux/version.h instead.
-- CONFIG_MODVERSIONS now work.  All combinations of versioned /
-  unversioned kernel and ftape module works (at least with my 1.3.52
-  kernel).
-- If you have problems with inserting ftape into an old (1.2.x)
-  kernel (e.g. insmod says "1.2.8 does not match 1.2.8), recompile
-  your modules utilities with your new compiler.
-- Reveal TB1400 drive added to vendors.h
-- Support for the i82078-1 (2Mbps) chip is coming along.  The
-  biggest problem is that I don't have such a card, which makes
-  testing / debugging somewhat problematic.  The second biggest
-  problem is that I do not have the QIC-3010/3020 standards either.
-  Status right now is that the chip is detected, and it should be
-  possible to put it into 2Mbps mode.  However, I do not know what
-  "extras" are needed to complete the support.  Although putting the
-  i82078 into 1Mbps mode ought to work out of the box, it doesn't
-  (right now, ftape complains about id am errors).
-
-
-===== Release notes for ftape-2.04beta5, 29/12/95 =====
-
-Bas offline linux-tape
-----------------------
-For reasons only known to the majordomo mail list processor, Bas was
-kicked off the linux-tape list sometime during the summer.  Being
-overworked at his for-pay job, he didn't notice it much.  Instead I
-(Kai, khp@dolphinics.no) has worked on ftape to produce the 2.04(beta)
-version.
-
-zftape
-------
-Note that there exists a much improved version of ftape, written by
-Claus-Justus Heine <claus@willi.math.rwth-aachen.de> which is named
-zftape, which conforms to the QIC-80 specs on how to mark backups, and
-is capable of doing automatic compression.  However, zftape makes
-substantial changes to ftape, and I (Kai) have therefore declined to
-integrate zftape into ftape.  Hopefully, this will happen soon.
-
-CONFIG_QIC117 removed from the kernel
--------------------------------------
-The biggest change of all is that ftape now will allocate its dma
-buffers when it is inserted.  The means that the CONFIG_QIC117 option
-has disappeared from the Linux kernel as of v1.3.34.  If you have an
-earlier kernel, simply answer 'no' to the question will do the trick
-(if you get complains about __get_free_pages() missing, contact the
-linux-tape mailing list).
-
-Note that ftape-2.04beta will work equally well on kernels with and
-without `ftape support'.  The only catch is, that you will waste
-around 96-128Kb of precious DMA'able memory on a box that has ftape
-support compiled in.
-
-Now for the real changes:
-
-- FC-20 can now use DMA channels 1, 2, and 3. Thanks to Daniel
-  Cohen, catman@wpi.edu.
-- ftape no longer requires a (gigantic) 96Kb buffer to be statically
-  allocated by the kernel.
-- Added new Iomega drive (8882) to vendors.h
-- -fno-strength-reduce added to Makefile, since GCC is broken.
-- i82078-1 (2Mbps) FDC support started.
-
-
-===== Release notes for ftape-2.03b, 27/05/95 =====
-
-- Prevented verify_area to return error if called with zero length.
-- Fixed a bug in flush_buffers that caused too much padding to be
-  written when a final segment had bad sectors.
-- Increased maximum fast-seek overshoot value from 5 to 10 segments.
-- Breaking loop after 5 retries when positioning fails.
-- Fixed wrong calculation of tape length for QIC-3010 and QIC-3020
-  tapes (densities were swapped).
-- Fixed wrong calculation of overshoot on seek_forward: Wrong sign
-  of error.
-- Suppress (false) error message due to new tape loaded.
-- Added two new CMS drives (11c3 and 11c5) to vendors.h.
-
-
-===== Release notes for ftape-2.03a, 09/05/95 =====
-
-- Fixed display of old error (even if already cleared) in ftape_open.
-- Improved tape length detection, ioctls would fail for 425 ft tapes.
-  Until the tape length is calculated with data from the header
-  segment, we'll use worst-case values.
-- Clear eof_mark after rewinding ioctls.
-- Fixed wrong version message (2.03 had 2.02g id).
-- Fixed bug that caused the fdc to be reset very frequently.
-  This shouldn't affect normal operation but the timing of the
-  report routines has changed again and that may cause problems.
-  We'll just have to find out....
-- Implemented correct write precompensation setting for QIC-3010/3020.
-- Cleaned up fdc_interrupt_wait routine. Hope it still works :-)
-- Finally removed (already disabled) special eof mark handling for
-  gnu tar.
-- Changed order of get_dma_residue and disable_dma in fdc-isr.c
-  because the current order would fail on at least one system.
-  We're back to the original order again, hope (and expect) this
-  doesn't break any other system.
-
-
-===== Release notes for ftape-2.03, 07/05/95 =====
-
-(Changes refer to the first ftape-2.02 release)
-
-Support for wide and extended length tapes
-------------------------------------------
-The Conner TSM 420 and 850 drives are reported to be working.
-I haven't received any reports about other brands; the TSM 420
-and 850 seem to be the most widely used wide drives.
-Extended length tapes (425 ft) with normal QIC-80 drives
-are operating too (At least I've had no reports stating otherwise).
-_Not_ yet completely supported (although they may work) are
-QIC-3020 drives and 2 Mbps floppy disk controllers won't work at
-the highest speed.
-If someone is kind enough to send me one of these, I'll include
-support for it too ;-)
-
-Easier configuration
---------------------
-Problems due to wrong settings in the Makefile are prevented
-by using a configuration script that sets the necessary (kernel
-version dependent) compile time options.
-This kernel version is now determined from the sources found
-at /usr/src/linux, or if not found, the old way using
-/proc/version.
-Versioned modules will be used automatically when supported
-by- and configured in- the kernel.
-Note that the current modules code (1.1.87) is still broken
-and _needs_ the fix included in the insmod directory.
-Please don't send me any more Oops reports caused by insmod :-(
-
-Reduced module size
--------------------
-The standard module size is much reduced and some compile time
-options can even reduce it further. (I don't recommend this
-for normal use but it can be handy for rescue diskettes)
-
-Option:           Approx. module size:
-
-<standard>             150 Kb
-NO_TRACE               125 Kb
-NO_TRACE_AT_ALL         67 Kb
-
-
-Much improved driver interruption
----------------------------------
-Most possible loops have been broken and signal detection
-has been improved.
-In most cases the driver can be aborted by ^C (SIGINT) and
-SIGKILL (kill -9) will generate be a sure kill.
-(Note that aborting a tape operation may damage the last
-data written to tape)
-
-Improved error recovery
------------------------
-Ftape now returns an error (ENODATA) to the application if
-a segment proves to be unrecoverable and then skips the
-bad segment.
-This causes most applications to continue to work (tar
-and afio) loosing only a small amount (up to 29 Kb) of data.
-Retried read operations will now be done slightly off-track
-to improve the chance of success. Serious head off-track
-errors will be detected.
-
-FC-10 and FC-20 controllers
----------------------------
-Ftape now supports both the old CMS FC-10 and the newer FC-20
-controllers.
-Because the operation of these cards is still undocumented,
-thus far they will only work with the default settings (See
-Makefile). Any feed-back on how to use them with other settings
-will be welcome !
-Compilation will fail if one changes the settings to illegal
-values.
-
-Kernels and compilers
----------------------
-Ftape is currently being developed using the 2.5.8 compiler.
-The older 2.4.5 probably works too (Set option in Makefile!).
-I have no experience with any later compilers nor Elf support.
-Any information on this is welcome.
-The latest kernel I have tested ftape with is 1.2.6.
-
-Compression
------------
-An impressive collection of changes for ftape including
-on-the-fly compression is still lying on my desk.
-If 2.03 proves to be reliable I might start integrating these
-but as usual, I'm short in time :-(
-
-Formatting
-----------
-There is still no way to format tapes under Linux. As far as
-I know all attempts to write such a program have died now.
-Since formatted tapes are rather common now, I think all we
-need is a utility that writes a worst case pattern and verifies
-that with the drive put in verify mode, reducing margins.
-Any takers ?
-
-Furthermore
------------
-Cleaned up messages.
-Prepared to support multiple tape drives on one fdc.
-Thanks to all the people who sent bug reports and helped me
-improve the driver. Without trying to be complete I'll mention
-Gary Anderson (without his accurate reports and unreliable
-hardware there wouldn't be a 2.03), Stefan Kneifel (FC-20),
-Robert Broughton (FC-20, you were almost there ;-), Bjorn
-Ekwall (for the versioned modules and buggy insmod ;-), Peter
-Fox, Christopher Oliver, Ralph Whittaker and not the least
-Linus Torvalds (for Linux and keeping me busy because of
-changes to the kernel ;-)
-Thanks to anyone I forgot, for the bug reports, the ftape
-bashing and the mental support...
-
-
-That's it for now. Have Fun,
-
-Bas.
-
-
-===== Release notes for ftape-2.02g, 06/05/95 =====
-
-- Added extra test to break read-id loop with signal.
-- Changed rewind code to handle negative overshoot for drives
-  that take very long to start or stop.
-- Let use of get/set i/o-regions depend on kernel version.
-- Changed code to use a more general test for conditional
-  compilations depending on kernel version.
-- Improved micro-step functionality to go off-track only
-  while reading (id & data).
-- Added failure on tape-not-referenced bit in ftape_command.
-- Added FOREVER option to read-wait routine.
-- Changed read-id to use shorter timeout causing smaller
-  rewinds on timeout.
-- Made kernel-interface functions static.
-
-
-===== Release notes for ftape-2.02f, 03/05/95 =====
-
-- Added support for dual tape drives on my system, extended Configure
-  script to detect host 'dodo'.
-- Log media defect in history if ecc failed and no data was returned.
-- Fixed Configure script that was failing for kernel versions with
-  double digit version or revision numbers.
-
-
-===== Release notes for ftape-2.02e, 01/05/95 =====
-
-- Fixed reposition loop at logical eot (failing read_id).
-- Fixed 34 segment offset when rewinding.
-- Added fast seek capability for more than 255 segments.
-- Fixed wrong busy result from ftape_command causing reverse
-  seek to fail.
-- Added breakout from infinite rewind loop (if something fails).
-
-
-===== Release notes for ftape-2.02d, 30/04/95 =====
-
-- Improved abortion on signals: Interrupt will make a graceful
-  exit, Kill will be less nice and should be used if everything
-  else fails.
-- Included check for tape-head off track.
-- Implemented exit from tape-start loop.
-- Added kernel io-port registration.
-- Implemented skip of failing segment (ENODATA) on ecc failure.
-  This allows afio and tar to continue when the tape is damaged.
-- Made distinction between drive names with different codes.
-
-
-===== Release notes for ftape-2.02c, 22/04/95 =====
-
-- Fixed too tight command queueing after tape stop/pause command
-  issued from within interrupt service routine (Showed as timeout
-  on Acknowledge errors during retries on some systems)
-- Tried to fix timeouts when using 425 ft tape because the extended
-  length doesn't seem to be detected by the hardware.
-  We now use the format code from the header segment so adjust the
-  timing after reading the header segment.
-- Fixed some messages stating 'unexpected something...' being not
-  unexpected anymore.
-- Started preparations for merge of dynamic buffer allocation and
-  compression code.
-- Changed some debug messages to include relevant segment information
-  at level 4.
-- Included early bail-out when drive offline, preventing a lot of
-  false messages.
-- Moved ftape_parameter_xxx() offsets into function instead of in calls.
-- Removed 'weird, drive busy but no data' error when caused by
-  an error during a read-id.
-- Improved 'timeout on acknowledge' diagnostics.
-- Moved MODULE option into Configure.
-- Reduced code size when no tracing at all was set (Claus Heine).
-- No longer log error code 0 (no error) as an error.
-
-
-===== Release notes for ftape-2.02b, 09/04/95 =====
-
-- Relaxed timing for status operation and displaying
-  abnormal results. Hopefully this shows what's going
-  wrong with the Conner TSM850R drives.
-- Created script for configuration, using version number
-  of kernel source if available, otherwise /proc/version.
-- Fixed conditionals in kernel-interface.c.
-- Removed unavoidable TRACE output.
-
-
-===== Release notes for ftape-2.02a, 01/04/95 =====
-
-- Implemented `new-style' (versioned) modules support for new
-  kernels.
-- Reduced size of module by moving static data to bss.
-- Now using version number of kernel source instead of running
-  kernel for kernel versions >= 1.1.82
-- Added feedback on drive speeds to vendor information.
-- Included fixed insmod sources to distribution (Let's hope
-  the modules distribution get fixed soon :-/).
-
-Note that I haven't yet implemented any of the code extension I
-received. I hope to find some time to do this soon.
-
-
-===== Release notes for ftape-2.02, 15/01/95 =====
-
-
-- Fixed failing repositioning when overshoot was incremented.
-- Fixed rate selection: Because of a deficiency in the QIC-117
-  specification one cannot distinguish between a not implemented
-  and a failing command. Therefor we now try to find out if the
-  drive does support this command before usage.
-- Fixed error retry using wrong offset in fdc-isr.
-- Improved retry code to retry only once on a single no-data
-  error in a segment.
-- Validate sector number extracted from eof mark because an
-  invalid file mark (due to ???) could cause kernel panic.
-- Split ftape-io.c into ftape-io.c and ftape-ctl.c files.
-- Corrected too high media error count after writing to
-  a bad tape.
-- Added #include <asm/segment.h> again because old kernel versions
-  need it.
-- Fixed fdc not being disabled when open failed because no tape
-  drive was found.
-- Fixed problem with soft error in sector 32 (shift operator with
-  shiftcount 32 is not defined).
-
-
-===== Release notes for ftape-2.01, 08/01/95 =====
-
-
-- Removed TESTING setting from distributed Makefile.
-- Fixed `mt asf' failure: Rewind was deferred to close which
-  overruled the fsf ioctl.
-- Prevented non-interruptible commands being interrupted.
-- Added missing timeout.pause setting.
-- Maximum tape speed read from drive type information table.
-  If the information is not in the table (0) the drive will
-  determine the speed itself and put a message in the logfile.
-  This information should then be added to the table in the
-  vendors.h file (and reported to me).
-- Added call to ftape_init_drive after soft reset for those
-  (antique) drives that don't do an implicit seek_load_point
-  after a reset or power up.
-- Don't try to set data rate if reset failed.
-- Prevent update of seek variables when starting from the
-  beginning or the end of the tape.
-- Fixed wrong adjustment of overshoot in seek_forward().
-- Added sync to Makefile (again).
-- Added code to diagnose timer problems (calibr.c).
-- Replaced time differences by timediff calls.
-- Removed reference to do_floppy from object for recent kernels.
-- Fixed wrong display of 'failing dma controller' message.
-- Removed various no longer used #include statements.
-- Added max. tape speed value to vendor-struct.
-- Changed ftape-command to check pre-conditions and wait
-  if needed.
-- Further updated qic117.h to rev G.
-- Combined command name table and restrictions table to one.
-  Extended this table with some new fields.
-- Increased timeout on Ack timer value and included code to
-  report out of spec behaviour.
-- Increased rewind timeout margin to calculated + 20%.
-- Improved data rate selection so it won't fail on some
-  older (pre standard) drives.
-- Changed initialisation code so drive will be rewound if the
-  driver is reloaded and the tape is not at bot.
-- Moved some of the flush operations from close to the ioctls.
-- Added exit code value to failing verify area message.
-- Loop until tape halted in smart-stop.
-- Fast seek handled specially if located at bot or eot.
-- Being more conservative on overshoot value.
-
-
-===== Release notes for ftape-2.00, 31/12/94 =====
-
-  The Install-guide is completely rewritten and now also includes
-some information on how to use the driver. If you're either new
-to ftape or new to Unix tape devices make sure to read it !
-
-  If you own a pci system and experience problems with the
-ftape driver make sure to read the README.PCI file. It contains
-some hints on how to fix your hardware.
-
-  For anybody who hasn't noticed: The version number of the
-driver has been incremented (The latest released version has
-been version 1.14d).
-  This has been done for two major reasons:
-
-  o  A new (better) error recovery scheme is implemented.
-  o  Support for new drive types has been added.
-
-  All these improvements/changes will probably include a couple
-of new (and old?) bugs. If you encounter any problems that you think
-I'm not yet aware of, feel free to send a report to <bas@vimec.nl>.
-  I recommend keeping a version of ftape-1.14d available, just
-in case ;-)
-
-  This version should work with all kernel versions from 1.0.9 up
-to 1.1.72 (and probably earlier and later versions too).
-
-
-Major new features:
-
-- Better handling of tapes with defects: When a sector repeatedly
-  (SOFT_RETRIES in ftape.h) cannot be written to or read from it is
-  marked as an hard error and gets skipped.
-  The error correction code can handle up to three of these hard
-  errors provided there are no other errors in that segment (32 Kb).
-  
-- Allows writing to tapes with defects (although the risk of loosing
-  data increases !)
-  Look for the media-defects entry printed with the statistics when
-  the tape is closed. A non-zero value here shows a bad tape.
-  [the actual count is wrong (too high), this is a known bug].
-
-- Use of backup header segment if first one is failing.
-
-- Support for extended length tapes with QIC-80: both 425 and 1100 ft.
-  0.25 inch tapes are now recognized and handled.
-
-- Support for new QIC-80 drives with 8 mm `wide' tapes (e.g. Conner
-  TSM 420).
-
-- Support for new QIC-3010 and QIC-3020 drives (experimental) with
-  both 0.25 inch and 8 mm tapes.
-
-Some minor features were added, a couple of small bugs were fixed and
-probably some new ones introduced ;-).
-
-[lseek() didn't make it into this version]
-
-Have fun,
-
-Bas.
-----
- LocalWords:  ftape MCONFIG mt VFS zftape resp sftape proc subdir MTIOCVOLINFO
- LocalWords:  MTIOCGETSIZE BOT EOD MTBSF zft kerneld modprobe kdtime contrib TR
- LocalWords:  MTSETBLK afio uninstall texi www EIO QIC init sft eof aka dma GB
- LocalWords:  SIGKILL MTIOCFTCMD mmap Iomega FDC fdc io gnumt mtio fc asm inb
- LocalWords:  outb ft qic frontend TeXinfo irq mach MODVERSIONS CONFIG html dvi
- LocalWords:  usr doc SMP Mb Dunno FIXME vtblc perl listtape volinfo fsf MTWEOF
- LocalWords:  amanda degaussed ComByte DoublePlay whraven njackn com MTIOC vtbl
- LocalWords:  GETBLKSZ MAKEDEV zftape's linux dif CVS Revison cp MTREW MTOFFL
- LocalWords:  MTFSF BSF Marcin Dalecki GCC Config cpio swapout Kai Harrekilde
- LocalWords:  Pederson khp dolphinics Justus claus momo rwth aachen Laarhoven
diff --git a/drivers/char/ftape/compressor/Makefile b/drivers/char/ftape/compressor/Makefile
deleted file mode 100644
index 1fbd6c4019db..000000000000
--- a/drivers/char/ftape/compressor/Makefile
+++ /dev/null
@@ -1,31 +0,0 @@
-#
-#       Copyright (C) 1997 Claus-Justus Heine.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2, or (at your option)
-# any later version.
-# 
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-# 
-# You should have received a copy of the GNU General Public License
-# along with this program; see the file COPYING.  If not, write to
-# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-#
-# $Source: /homes/cvs/ftape-stacked/ftape/compressor/Makefile,v $
-# $Revision: 1.1 $
-# $Date: 1997/10/05 19:12:28 $
-#
-#      Makefile for the optional compressor for th zftape VFS
-#      interface to the QIC-40/80/3010/3020 floppy-tape driver for
-#      Linux.
-#
-
-obj-$(CONFIG_ZFT_COMPRESSOR) += zft-compressor.o
-
-zft-compressor-objs := zftape-compress.o lzrw3.o
-
-CFLAGS_lzrw3.o  := -O6 -funroll-all-loops
diff --git a/drivers/char/ftape/compressor/lzrw3.c b/drivers/char/ftape/compressor/lzrw3.c
deleted file mode 100644
index a032a0ee2a99..000000000000
--- a/drivers/char/ftape/compressor/lzrw3.c
+++ /dev/null
@@ -1,743 +0,0 @@
-/*
- * $Source: /homes/cvs/ftape-stacked/ftape/compressor/lzrw3.c,v $
- * $Revision: 1.1 $
- * $Date: 1997/10/05 19:12:29 $
- *
- * Implementation of Ross Williams lzrw3 algorithm. Adaption for zftape.
- *
- */
-
-#include "../compressor/lzrw3.h"       /* Defines single exported function "compress".   */
-
-/******************************************************************************/
-/*                                                                            */
-/*                                    LZRW3.C                                 */
-/*                                                                            */
-/******************************************************************************/
-/*                                                                            */
-/* Author  : Ross Williams.                                                   */
-/* Date    : 30-Jun-1991.                                                     */
-/* Release : 1.                                                               */
-/*                                                                            */
-/******************************************************************************/
-/*                                                                            */
-/* This file contains an implementation of the LZRW3 data compression         */
-/* algorithm in C.                                                            */
-/*                                                                            */
-/* The algorithm is a general purpose compression algorithm that runs fast    */
-/* and gives reasonable compression. The algorithm is a member of the Lempel  */
-/* Ziv family of algorithms and bases its compression on the presence in the  */
-/* data of repeated substrings.                                               */
-/*                                                                            */
-/* This algorithm is unpatented and the code is public domain. As the         */
-/* algorithm is based on the LZ77 class of algorithms, it is unlikely to be   */
-/* the subject of a patent challenge.                                         */
-/*                                                                            */
-/* Unlike the LZRW1 and LZRW1-A algorithms, the LZRW3 algorithm is            */
-/* deterministic and is guaranteed to yield the same compressed               */
-/* representation for a given file each time it is run.                       */
-/*                                                                            */
-/* The LZRW3 algorithm was originally designed and implemented                */
-/* by Ross Williams on 31-Dec-1990.                                           */
-/*                                                                            */
-/* Here are the results of applying this code, compiled under THINK C 4.0     */
-/* and running on a Mac-SE (8MHz 68000), to the standard calgary corpus.      */
-/*                                                                            */
-/*    +----------------------------------------------------------------+      */
-/*    | DATA COMPRESSION TEST                                          |      */
-/*    | =====================                                          |      */
-/*    | Time of run     : Sun 30-Jun-1991 09:31PM                      |      */
-/*    | Timing accuracy : One part in 100                              |      */
-/*    | Context length  : 262144 bytes (= 256.0000K)                   |      */
-/*    | Test suite      : Calgary Corpus Suite                         |      */
-/*    | Files in suite  : 14                                           |      */
-/*    | Algorithm       : LZRW3                                        |      */
-/*    | Note: All averages are calculated from the un-rounded values.  |      */
-/*    +----------------------------------------------------------------+      */
-/*    | File Name   Length  CxB  ComLen  %Remn  Bits  Com K/s  Dec K/s |      */
-/*    | ----------  ------  ---  ------  -----  ----  -------  ------- |      */
-/*    | rpus:Bib.D  111261    1   55033   49.5  3.96    19.46    32.27 |      */
-/*    | us:Book1.D  768771    3  467962   60.9  4.87    17.03    31.07 |      */
-/*    | us:Book2.D  610856    3  317102   51.9  4.15    19.39    34.15 |      */
-/*    | rpus:Geo.D  102400    1   82424   80.5  6.44    11.65    18.18 |      */
-/*    | pus:News.D  377109    2  205670   54.5  4.36    17.14    27.47 |      */
-/*    | pus:Obj1.D   21504    1   13027   60.6  4.85    13.40    18.95 |      */
-/*    | pus:Obj2.D  246814    1  116286   47.1  3.77    19.31    30.10 |      */
-/*    | s:Paper1.D   53161    1   27522   51.8  4.14    18.60    31.15 |      */
-/*    | s:Paper2.D   82199    1   45160   54.9  4.40    18.45    32.84 |      */
-/*    | rpus:Pic.D  513216    2  122388   23.8  1.91    35.29    51.05 |      */
-/*    | us:Progc.D   39611    1   19669   49.7  3.97    18.87    30.64 |      */
-/*    | us:Progl.D   71646    1   28247   39.4  3.15    24.34    40.66 |      */
-/*    | us:Progp.D   49379    1   19377   39.2  3.14    23.91    39.23 |      */
-/*    | us:Trans.D   93695    1   33481   35.7  2.86    25.48    40.37 |      */
-/*    +----------------------------------------------------------------+      */
-/*    | Average     224401    1  110953   50.0  4.00    20.17    32.72 |      */
-/*    +----------------------------------------------------------------+      */
-/*                                                                            */
-/******************************************************************************/
-
-/******************************************************************************/
-
-/* The following structure is returned by the "compress" function below when  */
-/* the user asks the function to return identifying information.              */
-/* The most important field in the record is the working memory field which   */
-/* tells the calling program how much working memory should be passed to      */
-/* "compress" when it is called to perform a compression or decompression.    */
-/* LZRW3 uses the same amount of memory during compression and decompression. */
-/* For more information on this structure see "compress.h".                   */
-  
-#define U(X)            ((ULONG) X)
-#define SIZE_P_BYTE     (U(sizeof(UBYTE *)))
-#define SIZE_WORD       (U(sizeof(UWORD  )))
-#define ALIGNMENT_FUDGE (U(16))
-#define MEM_REQ ( U(4096)*(SIZE_P_BYTE) + ALIGNMENT_FUDGE )
-
-static struct compress_identity identity =
-{
- U(0x032DDEA8),                           /* Algorithm identification number. */
- MEM_REQ,                                 /* Working memory (bytes) required. */
- "LZRW3",                                 /* Name of algorithm.               */
- "1.0",                                   /* Version number of algorithm.     */
- "31-Dec-1990",                           /* Date of algorithm.               */
- "Public Domain",                         /* Copyright notice.                */
- "Ross N. Williams",                      /* Author of algorithm.             */
- "Renaissance Software",                  /* Affiliation of author.           */
- "Public Domain"                          /* Vendor of algorithm.             */
-};
- 
-LOCAL void compress_compress  (UBYTE *,UBYTE *,ULONG,UBYTE *, LONG *);
-LOCAL void compress_decompress(UBYTE *,UBYTE *,LONG, UBYTE *, ULONG *);
-
-/******************************************************************************/
-
-/* This function is the only function exported by this module.                */
-/* Depending on its first parameter, the function can be requested to         */
-/* compress a block of memory, decompress a block of memory, or to identify   */
-/* itself. For more information, see the specification file "compress.h".     */
-
-EXPORT void lzrw3_compress(
-        UWORD     action,      /* Action to be performed.               */
-        UBYTE   *wrk_mem,       /* Address of working memory we can use.*/
-        UBYTE   *src_adr,       /* Address of input data.               */
-        LONG     src_len,       /* Length  of input data.               */
-        UBYTE   *dst_adr,       /* Address to put output data.          */
-        void  *p_dst_len        /* Address of longword for length of output data.*/
-)
-{
- switch (action)
-   {
-    case COMPRESS_ACTION_IDENTITY:
-       *((struct compress_identity **)p_dst_len)= &identity;
-       break;
-    case COMPRESS_ACTION_COMPRESS:
-       compress_compress(wrk_mem,src_adr,src_len,dst_adr,(LONG *)p_dst_len);
-       break;
-    case COMPRESS_ACTION_DECOMPRESS:
-       compress_decompress(wrk_mem,src_adr,src_len,dst_adr,(LONG *)p_dst_len);
-       break;
-   }
-}
-
-/******************************************************************************/
-/*                                                                            */
-/* BRIEF DESCRIPTION OF THE LZRW3 ALGORITHM                                   */
-/* ========================================                                   */
-/* The LZRW3 algorithm is identical to the LZRW1-A algorithm except that      */
-/* instead of transmitting history offsets, it transmits hash table indexes.  */
-/* In order to decode the indexes, the decompressor must maintain an          */
-/* identical hash table. Copy items are straightforward:when the decompressor */
-/* receives a copy item, it simply looks up the hash table to translate the   */
-/* index into a pointer into the data already decompressed. To update the     */
-/* hash table, it replaces the same table entry with a pointer to the start   */
-/* of the newly decoded phrase. The tricky part is with literal items, for at */
-/* the time that the decompressor receives a literal item the decompressor    */
-/* does not have the three bytes in the Ziv (that the compressor has) to      */
-/* perform the three-byte hash. To solve this problem, in LZRW3, both the     */
-/* compressor and decompressor are wired up so that they "buffer" these       */
-/* literals and update their hash tables only when three bytes are available. */
-/* This makes the maximum buffering 2 bytes.                                  */
-/*                                                                            */
-/* Replacement of offsets by hash table indexes yields a few percent extra    */
-/* compression at the cost of some speed. LZRW3 is slower than LZRW1, LZRW1-A */
-/* and LZRW2, but yields better compression.                                  */
-/*                                                                            */
-/* Extra compression could be obtained by using a hash table of depth two.    */
-/* However, increasing the depth above one incurs a significant decrease in   */
-/* compression speed which was not considered worthwhile. Another reason for  */
-/* keeping the depth down to one was to allow easy comparison with the        */
-/* LZRW1-A and LZRW2 algorithms so as to demonstrate the exact effect of the  */
-/* use of direct hash indexes.                                                */
-/*                                                                            */
-/*                                  +---+                                     */
-/*                                  |___|4095                                 */
-/*                                  |___|                                     */
-/*              +---------------------*_|<---+   /----+---\                   */
-/*              |                   |___|    +---|Hash    |                   */
-/*              |                   |___|        |Function|                   */
-/*              |                   |___|        \--------/                   */
-/*              |                   |___|0            ^                       */
-/*              |                   +---+             |                       */
-/*              |                   Hash        +-----+                       */
-/*              |                   Table       |                             */
-/*              |                              ---                            */
-/*              v                              ^^^                            */
-/*      +-------------------------------------|----------------+              */
-/*      ||||||||||||||||||||||||||||||||||||||||||||||||||||||||              */
-/*      +-------------------------------------|----------------+              */
-/*      |                                     |1......18|      |              */
-/*      |<------- Lempel=History ------------>|<--Ziv-->|      |              */
-/*      |     (=bytes already processed)      |<-Still to go-->|              */
-/*      |<-------------------- INPUT BLOCK ------------------->|              */
-/*                                                                            */
-/* The diagram above for LZRW3 looks almost identical to the diagram for      */
-/* LZRW1. The difference is that in LZRW3, the compressor transmits hash      */
-/* table indices instead of Lempel offsets. For this to work, the             */
-/* decompressor must maintain a hash table as well as the compressor and both */
-/* compressor and decompressor must "buffer" literals, as the decompressor    */
-/* cannot hash phrases commencing with a literal until another two bytes have */
-/* arrived.                                                                   */
-/*                                                                            */
-/*  LZRW3 Algorithm Execution Summary                                         */
-/*  ---------------------------------                                         */
-/*  1. Hash the first three bytes of the Ziv to yield a hash table index h.   */
-/*  2. Look up the hash table yielding history pointer p.                     */
-/*  3. Match where p points with the Ziv. If there is a match of three or     */
-/*     more bytes, code those bytes (in the Ziv) as a copy item, otherwise    */
-/*     code the next byte in the Ziv as a literal item.                       */
-/*  4. Update the hash table as possible subject to the constraint that only  */
-/*     phrases commencing three bytes back from the Ziv can be hashed and     */
-/*     entered into the hash table. (This enables the decompressor to keep    */
-/*     pace). See the description and code for more details.                  */
-/*                                                                            */
-/******************************************************************************/
-/*                                                                            */
-/*                     DEFINITION OF COMPRESSED FILE FORMAT                   */
-/*                     ====================================                   */
-/*  * A compressed file consists of a COPY FLAG followed by a REMAINDER.      */
-/*  * The copy flag CF uses up four bytes with the first byte being the       */
-/*    least significant.                                                      */
-/*  * If CF=1, then the compressed file represents the remainder of the file  */
-/*    exactly. Otherwise CF=0 and the remainder of the file consists of zero  */
-/*    or more GROUPS, each of which represents one or more bytes.             */
-/*  * Each group consists of two bytes of CONTROL information followed by     */
-/*    sixteen ITEMs except for the last group which can contain from one      */
-/*    to sixteen items.                                                       */
-/*  * An item can be either a LITERAL item or a COPY item.                    */
-/*  * Each item corresponds to a bit in the control bytes.                    */
-/*  * The first control byte corresponds to the first 8 items in the group    */
-/*    with bit 0 corresponding to the first item in the group and bit 7 to    */
-/*    the eighth item in the group.                                           */
-/*  * The second control byte corresponds to the second 8 items in the group  */
-/*    with bit 0 corresponding to the ninth item in the group and bit 7 to    */
-/*    the sixteenth item in the group.                                        */
-/*  * A zero bit in a control word means that the corresponding item is a     */
-/*    literal item. A one bit corresponds to a copy item.                     */
-/*  * A literal item consists of a single byte which represents itself.       */
-/*  * A copy item consists of two bytes that represent from 3 to 18 bytes.    */
-/*  * The first  byte in a copy item will be denoted C1.                      */
-/*  * The second byte in a copy item will be denoted C2.                      */
-/*  * Bits will be selected using square brackets.                            */
-/*    For example: C1[0..3] is the low nibble of the first control byte.      */
-/*    of copy item C1.                                                        */
-/*  * The LENGTH of a copy item is defined to be C1[0..3]+3 which is a number */
-/*    in the range [3,18].                                                    */
-/*  * The INDEX of a copy item is defined to be C1[4..7]*256+C2[0..8] which   */
-/*    is a number in the range [0,4095].                                      */
-/*  * A copy item represents the sequence of bytes                            */
-/*       text[POS-OFFSET..POS-OFFSET+LENGTH-1] where                          */
-/*          text   is the entire text of the uncompressed string.             */
-/*          POS    is the index in the text of the character following the    */
-/*                   string represented by all the items preceeding the item  */
-/*                   being defined.                                           */
-/*          OFFSET is obtained from INDEX by looking up the hash table.       */
-/*                                                                            */
-/******************************************************************************/
-
-/* The following #define defines the length of the copy flag that appears at  */
-/* the start of the compressed file. The value of four bytes was chosen       */
-/* because the fast_copy routine on my Macintosh runs faster if the source    */
-/* and destination blocks are relatively longword aligned.                    */
-/* The actual flag data appears in the first byte. The rest are zeroed so as  */
-/* to normalize the compressed representation (i.e. not non-deterministic).   */
-#define FLAG_BYTES 4
-
-/* The following #defines define the meaning of the values of the copy        */
-/* flag at the start of the compressed file.                                  */
-#define FLAG_COMPRESS 0     /* Signals that output was result of compression. */
-#define FLAG_COPY     1     /* Signals that output was simply copied over.    */
-
-/* The 68000 microprocessor (on which this algorithm was originally developed */
-/* is fussy about non-aligned arrays of words. To avoid these problems the    */
-/* following macro can be used to "waste" from 0 to 3 bytes so as to align    */
-/* the argument pointer.                                                      */
-#define ULONG_ALIGN_UP(X) ((((ULONG)X)+sizeof(ULONG)-1)&~(sizeof(ULONG)-1))
-
-
-/* The following constant defines the maximum length of an uncompressed item. */
-/* This definition must not be changed; its value is hardwired into the code. */
-/* The longest number of bytes that can be spanned by a single item is 18     */
-/* for the longest copy item.                                                 */
-#define MAX_RAW_ITEM (18)
-
-/* The following constant defines the maximum length of an uncompressed group.*/
-/* This definition must not be changed; its value is hardwired into the code. */
-/* A group contains at most 16 items which explains this definition.          */
-#define MAX_RAW_GROUP (16*MAX_RAW_ITEM)
-
-/* The following constant defines the maximum length of a compressed group.   */
-/* This definition must not be changed; its value is hardwired into the code. */
-/* A compressed group consists of two control bytes followed by up to 16      */
-/* compressed items each of which can have a maximum length of two bytes.     */
-#define MAX_CMP_GROUP (2+16*2)
-
-/* The following constant defines the number of entries in the hash table.    */
-/* This definition must not be changed; its value is hardwired into the code. */
-#define HASH_TABLE_LENGTH (4096)
-
-/* LZRW3, unlike LZRW1(-A), must initialize its hash table so as to enable    */
-/* the compressor and decompressor to stay in step maintaining identical hash */
-/* tables. In an early version of the algorithm, the tables were simply       */
-/* initialized to zero and a check for zero was included just before the      */
-/* matching code. However, this test costs time. A better solution is to      */
-/* initialize all the entries in the hash table to point to a constant        */
-/* string. The decompressor does the same. This solution requires no extra    */
-/* test. The contents of the string do not matter so long as the string is    */
-/* the same for the compressor and decompressor and contains at least         */
-/* MAX_RAW_ITEM bytes. I chose consecutive decimal digits because they do not */
-/* have white space problems (e.g. there is no chance that the compiler will  */
-/* replace more than one space by a TAB) and because they make the length of  */
-/* the string obvious by inspection.                                          */
-#define START_STRING_18 ((UBYTE *) "123456789012345678")
-
-/* In this algorithm, hash values have to be calculated at more than one      */
-/* point. The following macro neatens the code up for this.                   */
-#define HASH(PTR) \
-   (((40543*(((*(PTR))<<8)^((*((PTR)+1))<<4)^(*((PTR)+2))))>>4) & 0xFFF)
-
-/******************************************************************************/
-
-/* Input  : Hand over the required amount of working memory in p_wrk_mem.     */
-/* Input  : Specify input block using p_src_first and src_len.                */
-/* Input  : Point p_dst_first to the start of the output zone (OZ).           */
-/* Input  : Point p_dst_len to a ULONG to receive the output length.          */
-/* Input  : Input block and output zone must not overlap.                     */
-/* Output : Length of output block written to *p_dst_len.                     */
-/* Output : Output block in Mem[p_dst_first..p_dst_first+*p_dst_len-1]. May   */
-/* Output : write in OZ=Mem[p_dst_first..p_dst_first+src_len+MAX_CMP_GROUP-1].*/
-/* Output : Upon completion guaranteed *p_dst_len<=src_len+FLAG_BYTES.        */
-LOCAL void compress_compress(UBYTE *p_wrk_mem,
-                             UBYTE *p_src_first, ULONG  src_len,
-                             UBYTE *p_dst_first, LONG  *p_dst_len)
-{
- /* p_src and p_dst step through the source and destination blocks.           */
- register UBYTE *p_src = p_src_first;
- register UBYTE *p_dst = p_dst_first;
- 
- /* The following variables are never modified and are used in the            */
- /* calculations that determine when the main loop terminates.                */
- UBYTE *p_src_post  = p_src_first+src_len;
- UBYTE *p_dst_post  = p_dst_first+src_len;
- UBYTE *p_src_max1  = p_src_first+src_len-MAX_RAW_ITEM;
- UBYTE *p_src_max16 = p_src_first+src_len-MAX_RAW_ITEM*16;
- 
- /* The variables 'p_control' and 'control' are used to buffer control bits.  */
- /* Before each group is processed, the next two bytes of the output block    */
- /* are set aside for the control word for the group about to be processed.   */
- /* 'p_control' is set to point to the first byte of that word. Meanwhile,    */
- /* 'control' buffers the control bits being generated during the processing  */
- /* of the group. Instead of having a counter to keep track of how many items */
- /* have been processed (=the number of bits in the control word), at the     */
- /* start of each group, the top word of 'control' is filled with 1 bits.     */
- /* As 'control' is shifted for each item, the 1 bits in the top word are     */
- /* absorbed or destroyed. When they all run out (i.e. when the top word is   */
- /* all zero bits, we know that we are at the end of a group.                 */
-# define TOPWORD 0xFFFF0000
- UBYTE *p_control;
- register ULONG control=TOPWORD;
- 
- /* THe variable 'hash' always points to the first element of the hash table. */
- UBYTE **hash= (UBYTE **)  ULONG_ALIGN_UP(p_wrk_mem);
- 
- /* The following two variables represent the literal buffer. p_h1 points to  */
- /* the hash table entry corresponding to the youngest literal. p_h2 points   */
- /* to the hash table entry corresponding to the second youngest literal.     */
- /* Note: p_h1=0=>p_h2=0 because zero values denote absence of a pending      */
- /* literal. The variables are initialized to zero meaning an empty "buffer". */
- UBYTE **p_h1=NULL;
- UBYTE **p_h2=NULL;
-  
- /* To start, we write the flag bytes. Being optimistic, we set the flag to   */
- /* FLAG_COMPRESS. The remaining flag bytes are zeroed so as to keep the      */
- /* algorithm deterministic.                                                  */
- *p_dst++=FLAG_COMPRESS;
- {UWORD i; for (i=2;i<=FLAG_BYTES;i++) *p_dst++=0;}
-
- /* Reserve the first word of output as the control word for the first group. */
- /* Note: This is undone at the end if the input block is empty.              */
- p_control=p_dst; p_dst+=2;
- 
- /* Initialize all elements of the hash table to point to a constant string.  */
- /* Use of an unrolled loop speeds this up considerably.                      */
- {UWORD i; UBYTE **p_h=hash;
-#  define ZH *p_h++=START_STRING_18
-  for (i=0;i<256;i++)     /* 256=HASH_TABLE_LENGTH/16. */
-    {ZH;ZH;ZH;ZH;
-     ZH;ZH;ZH;ZH;
-     ZH;ZH;ZH;ZH;
-     ZH;ZH;ZH;ZH;}
- }
-
- /* The main loop processes either 1 or 16 items per iteration. As its        */
- /* termination logic is complicated, I have opted for an infinite loop       */
- /* structure containing 'break' and 'goto' statements.                       */
- while (TRUE)
-   {/* Begin main processing loop. */
-   
-    /* Note: All the variables here except unroll should be defined within    */
-    /*       the inner loop. Unfortunately the loop hasn't got a block.       */
-     register UBYTE *p;         /* Scans through targ phrase during matching. */
-     register UBYTE *p_ziv= NULL ;     /* Points to first byte of current Ziv.       */
-     register UWORD unroll;     /* Loop counter for unrolled inner loop.      */
-     register UWORD index;      /* Index of current hash table entry.         */
-     register UBYTE **p_h0 = NULL ;     /* Pointer to current hash table entry.       */
-     
-    /* Test for overrun and jump to overrun code if necessary.                */
-    if (p_dst>p_dst_post)
-       goto overrun;
-       
-    /* The following cascade of if statements efficiently catches and deals   */
-    /* with varying degrees of closeness to the end of the input block.       */
-    /* When we get very close to the end, we stop updating the table and      */
-    /* code the remaining bytes as literals. This makes the code simpler.     */
-    unroll=16;
-    if (p_src>p_src_max16)
-      {
-       unroll=1;
-       if (p_src>p_src_max1)
-         {
-          if (p_src==p_src_post)
-             break;
-          else
-             goto literal;
-         }
-      }
-         
-    /* This inner unrolled loop processes 'unroll' (whose value is either 1   */
-    /* or 16) items. I have chosen to implement this loop with labels and     */
-    /* gotos to heighten the ease with which the loop may be implemented with */
-    /* a single decrement and branch instruction in assembly language and     */
-    /* also because the labels act as highly readable place markers.          */
-    /* (Also because we jump into the loop for endgame literals (see above)). */
-    
-    begin_unrolled_loop:
-    
-       /* To process the next phrase, we hash the next three bytes and use    */
-       /* the resultant hash table index to look up the hash table. A pointer */
-       /* to the entry is stored in p_h0 so as to avoid an array lookup. The  */
-       /* hash table entry *p_h0 is looked up yielding a pointer p to a       */
-       /* potential match of the Ziv in the history.                          */
-       index=HASH(p_src);
-       p_h0=&hash[index];
-       p=*p_h0;
-       
-       /* Having looked up the candidate position, we are in a position to    */
-       /* attempt a match. The match loop has been unrolled using the PS      */
-       /* macro so that failure within the first three bytes automatically    */
-       /* results in the literal branch being taken. The coding is simple.    */
-       /* p_ziv saves p_src so we can let p_src wander.                       */
-#       define PS *p++!=*p_src++
-       p_ziv=p_src;
-       if (PS || PS || PS)
-         {
-          /* Literal. */
-          
-          /* Code the literal byte as itself and a zero control bit.          */
-          p_src=p_ziv; literal: *p_dst++=*p_src++; control&=0xFFFEFFFF;
-          
-          /* We have just coded a literal. If we had two pending ones, that   */
-          /* makes three and we can update the hash table.                    */
-          if (p_h2!=0)
-             {*p_h2=p_ziv-2;}
-             
-          /* In any case, rotate the hash table pointers for next time. */
-          p_h2=p_h1; p_h1=p_h0;
-          
-         }
-       else
-         {
-          /* Copy */
-          
-          /* Match up to 15 remaining bytes using an unrolled loop and code. */
-#if 0
-          PS || PS || PS || PS || PS || PS || PS || PS ||
-          PS || PS || PS || PS || PS || PS || PS || p_src++;
-#else     
-          if (
-               !( PS || PS || PS || PS || PS || PS || PS || PS ||
-                  PS || PS || PS || PS || PS || PS || PS ) 
-             ) p_src++;
-#endif
-          *p_dst++=((index&0xF00)>>4)|(--p_src-p_ziv-3);
-          *p_dst++=index&0xFF;
-          
-          /* As we have just coded three bytes, we are now in a position to   */
-          /* update the hash table with the literal bytes that were pending   */
-          /* upon the arrival of extra context bytes.                         */
-          if (p_h1!=0)
-            {
-             if (p_h2)
-               {*p_h2=p_ziv-2; p_h2=NULL;}
-             *p_h1=p_ziv-1; p_h1=NULL;
-            }
-            
-          /* In any case, we can update the hash table based on the current   */
-          /* position as we just coded at least three bytes in a copy items.  */
-          *p_h0=p_ziv;
-          
-         }
-       control>>=1;
-                
-       /* This loop is all set up for a decrement and jump instruction! */
-#ifndef linux
-`    end_unrolled_loop: if (--unroll) goto begin_unrolled_loop;
-#else
-    /* end_unrolled_loop: */ if (--unroll) goto begin_unrolled_loop;
-#endif
-
-    /* At this point it will nearly always be the end of a group in which     */
-    /* case, we have to do some control-word processing. However, near the    */
-    /* end of the input block, the inner unrolled loop is only executed once. */
-    /* This necessitates the 'if' test.                                       */
-    if ((control&TOPWORD)==0)
-      {
-       /* Write the control word to the place we saved for it in the output. */
-       *p_control++=  control     &0xFF;
-       *p_control  = (control>>8) &0xFF;
-
-       /* Reserve the next word in the output block for the control word */
-       /* for the group about to be processed.                           */
-       p_control=p_dst; p_dst+=2;
-       
-       /* Reset the control bits buffer. */
-       control=TOPWORD;
-      }
-          
-   } /* End main processing loop. */
-   
- /* After the main processing loop has executed, all the input bytes have     */
- /* been processed. However, the control word has still to be written to the  */
- /* word reserved for it in the output at the start of the most recent group. */
- /* Before writing, the control word has to be shifted so that all the bits   */
- /* are in the right place. The "empty" bit positions are filled with 1s      */
- /* which partially fill the top word.                                        */
- while(control&TOPWORD) control>>=1;
- *p_control++= control     &0xFF;
- *p_control++=(control>>8) &0xFF;
- 
- /* If the last group contained no items, delete the control word too.        */
- if (p_control==p_dst) p_dst-=2;
- 
- /* Write the length of the output block to the dst_len parameter and return. */
- *p_dst_len=p_dst-p_dst_first;                           
- return;
- 
- /* Jump here as soon as an overrun is detected. An overrun is defined to     */
- /* have occurred if p_dst>p_dst_first+src_len. That is, the moment the       */
- /* length of the output written so far exceeds the length of the input block.*/
- /* The algorithm checks for overruns at least at the end of each group       */
- /* which means that the maximum overrun is MAX_CMP_GROUP bytes.              */
- /* Once an overrun occurs, the only thing to do is to set the copy flag and  */
- /* copy the input over.                                                      */
- overrun:
-#if 0
- *p_dst_first=FLAG_COPY;
- fast_copy(p_src_first,p_dst_first+FLAG_BYTES,src_len);
- *p_dst_len=src_len+FLAG_BYTES;
-#else
- fast_copy(p_src_first,p_dst_first,src_len);
- *p_dst_len= -src_len; /* return a negative number to indicate uncompressed data */
-#endif
-}
-
-/******************************************************************************/
-
-/* Input  : Hand over the required amount of working memory in p_wrk_mem.     */
-/* Input  : Specify input block using p_src_first and src_len.                */
-/* Input  : Point p_dst_first to the start of the output zone.                */
-/* Input  : Point p_dst_len to a ULONG to receive the output length.          */
-/* Input  : Input block and output zone must not overlap. User knows          */
-/* Input  : upperbound on output block length from earlier compression.       */
-/* Input  : In any case, maximum expansion possible is nine times.            */
-/* Output : Length of output block written to *p_dst_len.                     */
-/* Output : Output block in Mem[p_dst_first..p_dst_first+*p_dst_len-1].       */
-/* Output : Writes only  in Mem[p_dst_first..p_dst_first+*p_dst_len-1].       */
-LOCAL void compress_decompress( UBYTE *p_wrk_mem,
-                                UBYTE *p_src_first, LONG   src_len,
-                                UBYTE *p_dst_first, ULONG *p_dst_len)
-{
- /* Byte pointers p_src and p_dst scan through the input and output blocks.   */
- register UBYTE *p_src = p_src_first+FLAG_BYTES;
- register UBYTE *p_dst = p_dst_first;
- /* we need to avoid a SEGV when trying to uncompress corrupt data */
- register UBYTE *p_dst_post = p_dst_first + *p_dst_len;
-
- /* The following two variables are never modified and are used to control    */
- /* the main loop.                                                            */
- UBYTE *p_src_post  = p_src_first+src_len;
- UBYTE *p_src_max16 = p_src_first+src_len-(MAX_CMP_GROUP-2);
- 
- /* The hash table is the only resident of the working memory. The hash table */
- /* contains HASH_TABLE_LENGTH=4096 pointers to positions in the history. To  */
- /* keep Macintoshes happy, it is longword aligned.                           */
- UBYTE **hash = (UBYTE **) ULONG_ALIGN_UP(p_wrk_mem);
-
- /* The variable 'control' is used to buffer the control bits which appear in */
- /* groups of 16 bits (control words) at the start of each compressed group.  */
- /* When each group is read, bit 16 of the register is set to one. Whenever   */
- /* a new bit is needed, the register is shifted right. When the value of the */
- /* register becomes 1, we know that we have reached the end of a group.      */
- /* Initializing the register to 1 thus instructs the code to follow that it  */
- /* should read a new control word immediately.                               */
- register ULONG control=1;
- 
- /* The value of 'literals' is always in the range 0..3. It is the number of  */
- /* consecutive literal items just seen. We have to record this number so as  */
- /* to know when to update the hash table. When literals gets to 3, there     */
- /* have been three consecutive literals and we can update at the position of */
- /* the oldest of the three.                                                  */
- register UWORD literals=0;
- 
- /* Check the leading copy flag to see if the compressor chose to use a copy  */
- /* operation instead of a compression operation. If a copy operation was     */
- /* used, then all we need to do is copy the data over, set the output length */
- /* and return.                                                               */
-#if 0
- if (*p_src_first==FLAG_COPY)
-   {
-    fast_copy(p_src_first+FLAG_BYTES,p_dst_first,src_len-FLAG_BYTES);
-    *p_dst_len=src_len-FLAG_BYTES;
-    return;
-   }
-#else
-  if ( src_len < 0 )
-  {                                            
-   fast_copy(p_src_first,p_dst_first,-src_len );
-   *p_dst_len = (ULONG)-src_len;
-   return;
-  }
-#endif
-   
- /* Initialize all elements of the hash table to point to a constant string.  */
- /* Use of an unrolled loop speeds this up considerably.                      */
- {UWORD i; UBYTE **p_h=hash;
-#  define ZJ *p_h++=START_STRING_18
-  for (i=0;i<256;i++)     /* 256=HASH_TABLE_LENGTH/16. */
-    {ZJ;ZJ;ZJ;ZJ;
-     ZJ;ZJ;ZJ;ZJ;
-     ZJ;ZJ;ZJ;ZJ;
-     ZJ;ZJ;ZJ;ZJ;}
- }
-
- /* The outer loop processes either 1 or 16 items per iteration depending on  */
- /* how close p_src is to the end of the input block.                         */
- while (p_src!=p_src_post)
-   {/* Start of outer loop */
-   
-    register UWORD unroll;   /* Counts unrolled loop executions.              */
-    
-    /* When 'control' has the value 1, it means that the 16 buffered control  */
-    /* bits that were read in at the start of the current group have all been */
-    /* shifted out and that all that is left is the 1 bit that was injected   */
-    /* into bit 16 at the start of the current group. When we reach the end   */
-    /* of a group, we have to load a new control word and inject a new 1 bit. */
-    if (control==1)
-      {
-       control=0x10000|*p_src++;
-       control|=(*p_src++)<<8;
-      }
-
-    /* If it is possible that we are within 16 groups from the end of the     */
-    /* input, execute the unrolled loop only once, else process a whole group */
-    /* of 16 items by looping 16 times.                                       */
-    unroll= p_src<=p_src_max16 ? 16 : 1;
-
-    /* This inner loop processes one phrase (item) per iteration. */
-    while (unroll--)
-      { /* Begin unrolled inner loop. */
-      
-       /* Process a literal or copy item depending on the next control bit. */
-       if (control&1)
-         {
-          /* Copy item. */
-          
-          register UBYTE *p;           /* Points to place from which to copy. */
-          register UWORD lenmt;        /* Length of copy item minus three.    */
-          register UBYTE **p_hte;      /* Pointer to current hash table entry.*/
-          register UBYTE *p_ziv=p_dst; /* Pointer to start of current Ziv.    */
-          
-          /* Read and dismantle the copy word. Work out from where to copy.   */
-          lenmt=*p_src++;
-          p_hte=&hash[((lenmt&0xF0)<<4)|*p_src++];
-          p=*p_hte;
-          lenmt&=0xF;
-          
-          /* Now perform the copy using a half unrolled loop. */
-          *p_dst++=*p++;
-          *p_dst++=*p++;
-          *p_dst++=*p++;
-          while (lenmt--)
-             *p_dst++=*p++;
-                 
-          /* Because we have just received 3 or more bytes in a copy item     */
-          /* (whose bytes we have just installed in the output), we are now   */
-          /* in a position to flush all the pending literal hashings that had */
-          /* been postponed for lack of bytes.                                */
-          if (literals>0)
-            {
-             register UBYTE *r=p_ziv-literals;
-             hash[HASH(r)]=r;
-             if (literals==2)
-                {r++; hash[HASH(r)]=r;}
-             literals=0;
-            }
-            
-          /* In any case, we can immediately update the hash table with the   */
-          /* current position. We don't need to do a HASH(...) to work out    */
-          /* where to put the pointer, as the compressor just told us!!!      */
-          *p_hte=p_ziv;
-          
-         }
-       else
-         {
-          /* Literal item. */
-          
-          /* Copy over the literal byte. */
-          *p_dst++=*p_src++;
-          
-          /* If we now have three literals waiting to be hashed into the hash */
-          /* table, we can do one of them now (because there are three).      */
-          if (++literals == 3)
-             {register UBYTE *p=p_dst-3; hash[HASH(p)]=p; literals=2;}
-         }
-          
-       /* Shift the control buffer so the next control bit is in bit 0. */
-       control>>=1;
-#if 1
-       if (p_dst > p_dst_post) 
-       {
-               /* Shit: we tried to decompress corrupt data */
-               *p_dst_len = 0;
-               return;
-       }
-#endif
-      } /* End unrolled inner loop. */
-               
-   } /* End of outer loop */
-   
- /* Write the length of the decompressed data before returning. */
-  *p_dst_len=p_dst-p_dst_first;
-}
-
-/******************************************************************************/
-/*                               End of LZRW3.C                               */
-/******************************************************************************/
diff --git a/drivers/char/ftape/compressor/lzrw3.h b/drivers/char/ftape/compressor/lzrw3.h
deleted file mode 100644
index 533feba47526..000000000000
--- a/drivers/char/ftape/compressor/lzrw3.h
+++ /dev/null
@@ -1,253 +0,0 @@
-#ifndef _LZRW3_H
-#define _LZRW3_H
-/*
- * $Source: /homes/cvs/ftape-stacked/ftape/compressor/lzrw3.h,v $
- * $Revision: 1.1 $
- * $Date: 1997/10/05 19:12:30 $
- *
- *  include files for lzrw3. Only slighty modified from the original
- *  version. Assembles the three include files compress.h, port.h and
- *  fastcopy.h from the original lzrw3 package.
- *
- */
-
-#include <linux/types.h>
-#include <linux/string.h>
-
-/******************************************************************************/
-/*                                                                            */
-/*                                 COMPRESS.H                                 */
-/*                                                                            */
-/******************************************************************************/
-/*                                                                            */
-/* Author : Ross Williams.                                                    */
-/* Date   : December 1989.                                                    */
-/*                                                                            */
-/* This header file defines the interface to a set of functions called        */
-/* 'compress', each member of which implements a particular data compression  */
-/* algorithm.                                                                 */
-/*                                                                            */
-/* Normally in C programming, for each .H file, there is a corresponding .C   */
-/* file that implements the functions promised in the .H file.                */
-/* Here, there are many .C files corresponding to this header file.           */
-/* Each comforming implementation file contains a single function             */
-/* called 'compress' that implements a single data compression                */
-/* algorithm that conforms with the interface specified in this header file.  */
-/* Only one algorithm can be linked in at a time in this organization.        */
-/*                                                                            */
-/******************************************************************************/
-/*                                                                            */
-/*                    DEFINITION OF FUNCTION COMPRESS                         */
-/*                    ===============================                         */
-/*                                                                            */
-/* Summary of Function Compress                                               */
-/* ----------------------------                                               */
-/* The action that 'compress' takes depends on its first argument called      */
-/* 'action'.  The function provides three actions:                            */
-/*                                                                            */
-/*    - Return information about the algorithm.                               */
-/*    - Compress   a block of memory.                                         */
-/*    - Decompress a block of memory.                                         */
-/*                                                                            */
-/* Parameters                                                                 */
-/* ----------                                                                 */
-/* See the formal C definition later for a description of the parameters.     */
-/*                                                                            */
-/* Constants                                                                  */
-/* ---------                                                                  */
-/* COMPRESS_OVERRUN: The constant COMPRESS_OVERRUN defines by how many bytes  */
-/* an algorithm is allowed to expand a block during a compression operation.  */
-/*                                                                            */
-/* Although compression algorithms usually compress data, there will always   */
-/* be data that a given compressor will expand (this can be proven).          */
-/* Fortunately, the degree of expansion can be limited to a single bit, by    */
-/* copying over the input data if the data gets bigger during compression.    */
-/* To allow for this possibility, the first bit of a compressed               */
-/* representation can be used as a flag indicating whether the                */
-/* input data was copied over, or truly compressed. In practice, the first    */
-/* byte would be used to store this bit so as to maintain byte alignment.     */
-/*                                                                            */
-/* Unfortunately, in general, the only way to tell if an algorithm will       */
-/* expand a particular block of data is to run the algorithm on the data.     */
-/* If the algorithm does not continuously monitor how many output bytes it    */
-/* has written, it might write an output block far larger than the input      */
-/* block before realizing that it has done so.                                */
-/* On the other hand, continuous checks on output length are inefficient.     */
-/*                                                                            */
-/* To cater for all these problems, this interface definition:                */
-/* > Allows a compression algorithm to return an output block that is up to   */
-/*   COMPRESS_OVERRUN bytes longer than the input block.                      */
-/* > Allows a compression algorithm to write up to COMPRESS_OVERRUN bytes     */
-/*   more than the length of the input block to the memory of the output      */
-/*   block regardless of the length of the output block eventually returned.  */
-/*   This allows an algorithm to overrun the length of the input block in the */
-/*   output block by up to COMPRESS_OVERRUN bytes between expansion checks.   */
-/*                                                                            */
-/* The problem does not arise for decompression.                              */
-/*                                                                            */
-/* Identity Action                                                            */
-/* ---------------                                                            */
-/* > action must be COMPRESS_ACTION_IDENTITY.                                 */
-/* > p_dst_len must point to a longword to receive a longword address.        */
-/* > The value of the other parameters does not matter.                       */
-/* > After execution, the longword that p_dst_len points to will be a pointer */
-/*   to a structure of type compress_identity.                                */
-/*   Thus, for example, after the call, (*p_dst_len)->memory will return the  */
-/*   number of bytes of working memory that the algorithm requires to run.    */
-/* > The values of the identity structure returned are fixed constant         */
-/*   attributes of the algorithm and must not vary from call to call.         */
-/*                                                                            */
-/* Common Requirements for Compression and Decompression Actions              */
-/* -------------------------------------------------------------              */
-/* > wrk_mem must point to an unused block of memory of a length specified in */
-/*   the algorithm's identity block. The identity block can be obtained by    */
-/*   making a separate call to compress, specifying the identity action.      */
-/* > The INPUT BLOCK is defined to be Memory[src_addr,src_addr+src_len-1].    */
-/* > dst_len will be used to denote *p_dst_len.                               */
-/* > dst_len is not read by compress, only written.                           */
-/* > The value of dst_len is defined only upon termination.                   */
-/* > The OUTPUT BLOCK is defined to be Memory[dst_addr,dst_addr+dst_len-1].   */
-/*                                                                            */
-/* Compression Action                                                         */
-/* ------------------                                                         */
-/* > action must be COMPRESS_ACTION_COMPRESS.                                 */
-/* > src_len must be in the range [0,COMPRESS_MAX_ORG].                       */
-/* > The OUTPUT ZONE is defined to be                                         */
-/*      Memory[dst_addr,dst_addr+src_len-1+COMPRESS_OVERRUN].                 */
-/* > The function can modify any part of the output zone regardless of the    */
-/*   final length of the output block.                                        */
-/* > The input block and the output zone must not overlap.                    */
-/* > dst_len will be in the range [0,src_len+COMPRESS_OVERRUN].               */
-/* > dst_len will be in the range [0,COMPRESS_MAX_COM] (from prev fact).      */
-/* > The output block will consist of a representation of the input block.    */
-/*                                                                            */
-/* Decompression Action                                                       */
-/* --------------------                                                       */
-/* > action must be COMPRESS_ACTION_DECOMPRESS.                               */
-/* > The input block must be the result of an earlier compression operation.  */
-/* > If the previous fact is true, the following facts must also be true:     */
-/*   > src_len will be in the range [0,COMPRESS_MAX_COM].                     */
-/*   > dst_len will be in the range [0,COMPRESS_MAX_ORG].                     */
-/* > The input and output blocks must not overlap.                            */
-/* > Only the output block is modified.                                       */
-/* > Upon termination, the output block will consist of the bytes contained   */
-/*   in the input block passed to the earlier compression operation.          */
-/*                                                                            */
-/******************************************************************************/
-
-/******************************************************************************/
-/*                                                                            */
-/*                                    PORT.H                                  */
-/*                                                                            */
-/******************************************************************************/
-/*                                                                            */
-/* This module contains macro definitions and types that are likely to        */
-/* change between computers.                                                  */
-/*                                                                            */
-/******************************************************************************/
-
-#ifndef DONE_PORT       /* Only do this if not previously done.               */
-
-   #ifdef THINK_C
-      #define UBYTE unsigned char      /* Unsigned byte                       */
-      #define UWORD unsigned int       /* Unsigned word (2 bytes)             */
-      #define ULONG unsigned long      /* Unsigned word (4 bytes)             */
-      #define BOOL  unsigned char      /* Boolean                             */
-      #define FOPEN_BINARY_READ  "rb"  /* Mode string for binary reading.     */
-      #define FOPEN_BINARY_WRITE "wb"  /* Mode string for binary writing.     */
-      #define FOPEN_TEXT_APPEND  "a"   /* Mode string for text appending.     */
-      #define REAL double              /* USed for floating point stuff.      */
-   #endif
-   #if defined(LINUX) || defined(linux)
-      #define UBYTE __u8               /* Unsigned byte                       */
-      #define UWORD __u16              /* Unsigned word (2 bytes)             */
-      #define ULONG __u32              /* Unsigned word (4 bytes)             */
-      #define LONG  __s32              /* Signed   word (4 bytes)             */
-      #define BOOL  is not used here   /* Boolean                             */
-      #define FOPEN_BINARY_READ  not used  /* Mode string for binary reading. */
-      #define FOPEN_BINARY_WRITE not used  /* Mode string for binary writing. */
-      #define FOPEN_TEXT_APPEND  not used  /* Mode string for text appending. */
-      #define REAL not used                /* USed for floating point stuff.  */
-      #ifndef TRUE
-      #define TRUE 1
-      #endif
-   #endif
-
-   #define DONE_PORT                   /* Don't do all this again.            */
-   #define MALLOC_FAIL NULL            /* Failure status from malloc()        */
-   #define LOCAL static                /* For non-exported routines.          */
-   #define EXPORT                      /* Signals exported function.          */
-   #define then                        /* Useful for aligning ifs.            */
-
-#endif
-
-/******************************************************************************/
-/*                              End of PORT.H                                 */
-/******************************************************************************/
-
-#define COMPRESS_ACTION_IDENTITY   0
-#define COMPRESS_ACTION_COMPRESS   1
-#define COMPRESS_ACTION_DECOMPRESS 2
-
-#define COMPRESS_OVERRUN 1024
-#define COMPRESS_MAX_COM 0x70000000
-#define COMPRESS_MAX_ORG (COMPRESS_MAX_COM-COMPRESS_OVERRUN)
-
-#define COMPRESS_MAX_STRLEN 255
-
-/* The following structure provides information about the algorithm.         */
-/* > The top bit of id must be zero. The remaining bits must be chosen by    */
-/*   the author of the algorithm by tossing a coin 31 times.                 */
-/* > The amount of memory requested by the algorithm is specified in bytes   */
-/*   and must be in the range [0,0x70000000].                                */
-/* > All strings s must be such that strlen(s)<=COMPRESS_MAX_STRLEN.         */
-struct compress_identity
-  {
-   ULONG id;           /* Identifying number of algorithm.            */
-   ULONG memory;       /* Number of bytes of working memory required. */
-
-   char  *name;        /* Name of algorithm.                          */
-   char  *version;     /* Version number.                             */
-   char  *date;        /* Date of release of this version.            */
-   char  *copyright;   /* Copyright message.                          */
-
-   char  *author;      /* Author of algorithm.                        */
-   char  *affiliation; /* Affiliation of author.                      */
-   char  *vendor;      /* Where the algorithm can be obtained.        */
-  };
-
-void  lzrw3_compress(        /* Single function interface to compression algorithm. */
-UWORD     action,      /* Action to be performed.                             */
-UBYTE   *wrk_mem,      /* Working memory temporarily given to routine to use. */
-UBYTE   *src_adr,      /* Address of input  data.                             */
-LONG     src_len,      /* Length  of input  data.                             */
-UBYTE   *dst_adr,      /* Address of output data.                             */
-void  *p_dst_len       /* Pointer to a longword where routine will write:     */
-                       /*    If action=..IDENTITY   => Adr of id structure.   */
-                       /*    If action=..COMPRESS   => Length of output data. */
-                       /*    If action=..DECOMPRESS => Length of output data. */
-);
-
-/******************************************************************************/
-/*                             End of COMPRESS.H                              */
-/******************************************************************************/
-
-
-/******************************************************************************/
-/*                                  fast_copy.h                               */
-/******************************************************************************/
-
-/* This function copies a block of memory very quickly.                       */
-/* The exact speed depends on the relative alignment of the blocks of memory. */
-/* PRE  : 0<=src_len<=(2^32)-1 .                                              */
-/* PRE  : Source and destination blocks must not overlap.                     */
-/* POST : MEM[dst_adr,dst_adr+src_len-1]=MEM[src_adr,src_adr+src_len-1].      */
-/* POST : MEM[dst_adr,dst_adr+src_len-1] is the only memory changed.          */
-
-#define fast_copy(src,dst,len) memcpy(dst,src,len)
-
-/******************************************************************************/
-/*                               End of fast_copy.h                           */
-/******************************************************************************/
-
-#endif
diff --git a/drivers/char/ftape/compressor/zftape-compress.c b/drivers/char/ftape/compressor/zftape-compress.c
deleted file mode 100644
index 65ffc0be3df9..000000000000
--- a/drivers/char/ftape/compressor/zftape-compress.c
+++ /dev/null
@@ -1,1203 +0,0 @@
-/*
- *      Copyright (C) 1994-1997 Claus-Justus Heine
-
- This program is free software; you can redistribute it and/or
- modify it under the terms of the GNU General Public License as
- published by the Free Software Foundation; either version 2, or (at
- your option) any later version.
- 
- This program is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- General Public License for more details.
- 
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
- USA.
- 
- *
- *     This file implements a "generic" interface between the *
- *     zftape-driver and a compression-algorithm. The *
- *     compression-algorithm currently used is a LZ77. I use the *
- *     implementation lzrw3 by Ross N. Williams (Renaissance *
- *     Software). The compression program itself is in the file
- *     lzrw3.c * and lzrw3.h.  To adopt another compression algorithm
- *     the functions * zft_compress() and zft_uncompress() must be
- *     changed * appropriately. See below.
- */
-
-#include <linux/errno.h>
-#include <linux/mm.h>
-#include <linux/module.h>
-
-#include <linux/zftape.h>
-
-#include <asm/uaccess.h>
-
-#include "../zftape/zftape-init.h"
-#include "../zftape/zftape-eof.h"
-#include "../zftape/zftape-ctl.h"
-#include "../zftape/zftape-write.h"
-#include "../zftape/zftape-read.h"
-#include "../zftape/zftape-rw.h"
-#include "../compressor/zftape-compress.h"
-#include "../zftape/zftape-vtbl.h"
-#include "../compressor/lzrw3.h"
-
-/*
- *   global variables
- */
-
-/* I handle the allocation of this buffer as a special case, because
- * it's size varies depending on the tape length inserted.
- */
-
-/* local variables 
- */
-static void *zftc_wrk_mem = NULL;
-static __u8 *zftc_buf     = NULL;
-static void *zftc_scratch_buf  = NULL;
-
-/* compression statistics 
- */
-static unsigned int zftc_wr_uncompressed = 0;
-static unsigned int zftc_wr_compressed   = 0;
-static unsigned int zftc_rd_uncompressed = 0;
-static unsigned int zftc_rd_compressed   = 0;
-
-/* forward */
-static int  zftc_write(int *write_cnt,
-                       __u8 *dst_buf, const int seg_sz,
-                       const __u8 __user *src_buf, const int req_len,
-                       const zft_position *pos, const zft_volinfo *volume);
-static int  zftc_read(int *read_cnt,
-                      __u8  __user *dst_buf, const int to_do,
-                      const __u8 *src_buf, const int seg_sz,
-                      const zft_position *pos, const zft_volinfo *volume);
-static int  zftc_seek(unsigned int new_block_pos, 
-                      zft_position *pos, const zft_volinfo *volume,
-                      __u8 *buffer);
-static void zftc_lock   (void);
-static void zftc_reset  (void);
-static void zftc_cleanup(void);
-static void zftc_stats      (void);
-
-/* compressed segment. This conforms to QIC-80-MC, Revision K.
- * 
- * Rev. K applies to tapes with `fixed length format' which is
- * indicated by format code 2,3 and 5. See below for format code 4 and 6
- *
- * 2 bytes: offset of compression segment structure
- *          29k > offset >= 29k-18: data from previous segment ens in this
- *                                  segment and no compressed block starts
- *                                  in this segment
- *                     offset == 0: data from previous segment occupies entire
- *                                  segment and continues in next segment
- * n bytes: remainder from previous segment
- * 
- * Rev. K:  
- * 4 bytes: 4 bytes: files set byte offset
- * Post Rev. K and QIC-3020/3020:
- * 8 bytes: 8 bytes: files set byte offset
- * 2 bytes: byte count N (amount of data following)
- *          bit 15 is set if data is compressed, bit 15 is not
- *          set if data is uncompressed
- * N bytes: data (as much as specified in the byte count)
- * 2 bytes: byte count N_1 of next cluster
- * N_1 bytes: data of next cluset
- * 2 bytes: byte count N_2 of next cluster
- * N_2 bytes: ...  
- *
- * Note that the `N' byte count accounts only for the bytes that in the
- * current segment if the cluster spans to the next segment.
- */
-
-typedef struct
-{
-        int cmpr_pos;             /* actual position in compression buffer */
-        int cmpr_sz;              /* what is left in the compression buffer
-                                   * when copying the compressed data to the
-                                   * deblock buffer
-                                   */
-        unsigned int first_block; /* location of header information in
-                                   * this segment
-                                   */
-        unsigned int count;       /* amount of data of current block
-                                   * contained in current segment 
-                                   */
-        unsigned int offset;      /* offset in current segment */
-        unsigned int spans:1;     /* might continue in next segment */
-        unsigned int uncmpr;      /* 0x8000 if this block contains
-                                   * uncompressed data 
-                                   */
-        __s64 foffs;              /* file set byte offset, same as in 
-                                   * compression map segment
-                                   */
-} cmpr_info;
-
-static cmpr_info cseg; /* static data. Must be kept uptodate and shared by 
-                        * read, write and seek functions
-                        */
-
-#define DUMP_CMPR_INFO(level, msg, info)                                \
-        TRACE(level, msg "\n"                                           \
-              KERN_INFO "cmpr_pos   : %d\n"                             \
-              KERN_INFO "cmpr_sz    : %d\n"                             \
-              KERN_INFO "first_block: %d\n"                             \
-              KERN_INFO "count      : %d\n"                             \
-              KERN_INFO "offset     : %d\n"                             \
-              KERN_INFO "spans      : %d\n"                             \
-              KERN_INFO "uncmpr     : 0x%04x\n"                         \
-              KERN_INFO "foffs      : " LL_X,                           \
-              (info)->cmpr_pos, (info)->cmpr_sz, (info)->first_block,   \
-              (info)->count, (info)->offset, (info)->spans == 1,        \
-              (info)->uncmpr, LL((info)->foffs))
-
-/*   dispatch compression segment info, return error code
- *  
- *   afterwards, cseg->offset points to start of data of the NEXT
- *   compressed block, and cseg->count contains the amount of data
- *   left in the actual compressed block. cseg->spans is set to 1 if
- *   the block is continued in the following segment. Otherwise it is
- *   set to 0. 
- */
-static int get_cseg (cmpr_info *cinfo, const __u8 *buff, 
-                     const unsigned int seg_sz,
-                     const zft_volinfo *volume)
-{
-        TRACE_FUN(ft_t_flow);
-
-        cinfo->first_block = GET2(buff, 0);
-        if (cinfo->first_block == 0) { /* data spans to next segment */
-                cinfo->count  = seg_sz - sizeof(__u16);
-                cinfo->offset = seg_sz;
-                cinfo->spans = 1;
-        } else { /* cluster definetely ends in this segment */
-                if (cinfo->first_block > seg_sz) {
-                        /* data corrupted */
-                        TRACE_ABORT(-EIO, ft_t_err, "corrupted data:\n"
-                                    KERN_INFO "segment size: %d\n"
-                                    KERN_INFO "first block : %d",
-                                    seg_sz, cinfo->first_block);
-                }
-                cinfo->count  = cinfo->first_block - sizeof(__u16);
-                cinfo->offset = cinfo->first_block;
-                cinfo->spans = 0;
-        }
-        /* now get the offset the first block should have in the
-         * uncompressed data stream.
-         *
-         * For this magic `18' refer to CRF-3 standard or QIC-80MC,
-         * Rev. K.  
-         */
-        if ((seg_sz - cinfo->offset) > 18) {
-                if (volume->qic113) { /* > revision K */
-                        TRACE(ft_t_data_flow, "New QIC-113 compliance");
-                        cinfo->foffs = GET8(buff, cinfo->offset);
-                        cinfo->offset += sizeof(__s64); 
-                } else {
-                        TRACE(/* ft_t_data_flow */ ft_t_noise, "pre QIC-113 version");
-                        cinfo->foffs   = (__s64)GET4(buff, cinfo->offset);
-                        cinfo->offset += sizeof(__u32); 
-                }
-        }
-        if (cinfo->foffs > volume->size) {
-                TRACE_ABORT(-EIO, ft_t_err, "Inconsistency:\n"
-                            KERN_INFO "offset in current volume: %d\n"
-                            KERN_INFO "size of current volume  : %d",
-                            (int)(cinfo->foffs>>10), (int)(volume->size>>10));
-        }
-        if (cinfo->cmpr_pos + cinfo->count > volume->blk_sz) {
-                TRACE_ABORT(-EIO, ft_t_err, "Inconsistency:\n"
-                            KERN_INFO "block size : %d\n"
-                            KERN_INFO "data record: %d",
-                            volume->blk_sz, cinfo->cmpr_pos + cinfo->count);
-        }
-        DUMP_CMPR_INFO(ft_t_noise /* ft_t_any */, "", cinfo);
-        TRACE_EXIT 0;
-}
-
-/*  This one is called, when a new cluster starts in same segment.
- *  
- *  Note: if this is the first cluster in the current segment, we must
- *  not check whether there are more than 18 bytes available because
- *  this have already been done in get_cseg() and there may be less
- *  than 18 bytes available due to header information.
- * 
- */
-static void get_next_cluster(cmpr_info *cluster, const __u8 *buff, 
-                             const int seg_sz, const int finish)
-{
-        TRACE_FUN(ft_t_flow);
-
-        if (seg_sz - cluster->offset > 18 || cluster->foffs != 0) {
-                cluster->count   = GET2(buff, cluster->offset);
-                cluster->uncmpr  = cluster->count & 0x8000;
-                cluster->count  -= cluster->uncmpr;
-                cluster->offset += sizeof(__u16);
-                cluster->foffs   = 0;
-                if ((cluster->offset + cluster->count) < seg_sz) {
-                        cluster->spans = 0;
-                } else if (cluster->offset + cluster->count == seg_sz) {
-                        cluster->spans = !finish;
-                } else {
-                        /* either an error or a volume written by an 
-                         * old version. If this is a data error, then we'll
-                         * catch it later.
-                         */
-                        TRACE(ft_t_data_flow, "Either error or old volume");
-                        cluster->spans = 1;
-                        cluster->count = seg_sz - cluster->offset;
-                }
-        } else {
-                cluster->count = 0;
-                cluster->spans = 0;
-                cluster->foffs = 0;
-        }
-        DUMP_CMPR_INFO(ft_t_noise /* ft_t_any */ , "", cluster);
-        TRACE_EXIT;
-}
-
-static void zftc_lock(void)
-{
-}
-
-/*  this function is needed for zftape_reset_position in zftape-io.c 
- */
-static void zftc_reset(void)
-{
-        TRACE_FUN(ft_t_flow);
-
-        memset((void *)&cseg, '\0', sizeof(cseg));
-        zftc_stats();
-        TRACE_EXIT;
-}
-
-static int cmpr_mem_initialized = 0;
-static unsigned int alloc_blksz = 0;
-
-static int zft_allocate_cmpr_mem(unsigned int blksz)
-{
-        TRACE_FUN(ft_t_flow);
-
-        if (cmpr_mem_initialized && blksz == alloc_blksz) {
-                TRACE_EXIT 0;
-        }
-        TRACE_CATCH(zft_vmalloc_once(&zftc_wrk_mem, CMPR_WRK_MEM_SIZE),
-                    zftc_cleanup());
-        TRACE_CATCH(zft_vmalloc_always(&zftc_buf, blksz + CMPR_OVERRUN),
-                    zftc_cleanup());
-        alloc_blksz = blksz;
-        TRACE_CATCH(zft_vmalloc_always(&zftc_scratch_buf, blksz+CMPR_OVERRUN),
-                    zftc_cleanup());
-        cmpr_mem_initialized = 1;
-        TRACE_EXIT 0;
-}
-
-static void zftc_cleanup(void)
-{
-        TRACE_FUN(ft_t_flow);
-
-        zft_vfree(&zftc_wrk_mem, CMPR_WRK_MEM_SIZE);
-        zft_vfree(&zftc_buf, alloc_blksz + CMPR_OVERRUN);
-        zft_vfree(&zftc_scratch_buf, alloc_blksz + CMPR_OVERRUN);
-        cmpr_mem_initialized = alloc_blksz = 0;
-        TRACE_EXIT;
-}
-
-/*****************************************************************************
- *                                                                           *
- *  The following two functions "ftape_compress()" and                       *
- *  "ftape_uncompress()" are the interface to the actual compression         *
- *  algorithm (i.e. they are calling the "compress()" function from          *
- *  the lzrw3 package for now). These routines could quite easily be         *
- *  changed to adopt another compression algorithm instead of lzrw3,         *
- *  which currently is used.                                                 *
- *                                                                           *
- *****************************************************************************/
-
-/* called by zft_compress_write() to perform the compression. Must
- * return the size of the compressed data.
- *
- * NOTE: The size of the compressed data should not exceed the size of
- *       the uncompressed data. Most compression algorithms have means
- *       to store data unchanged if the "compressed" data amount would
- *       exceed the original one. Mostly this is done by storing some
- *       flag-bytes in front of the compressed data to indicate if it
- *       is compressed or not. Thus the worst compression result
- *       length is the original length plus those flag-bytes.
- *
- *       We don't want that, as the QIC-80 standard provides a means
- *       of marking uncompressed blocks by simply setting bit 15 of
- *       the compressed block's length. Thus a compessed block can
- *       have at most a length of 2^15-1 bytes. The QIC-80 standard
- *       restricts the block-length even further, allowing only 29k -
- *       6 bytes.
- *
- *       Currently, the maximum blocksize used by zftape is 28k.
- *
- *       In short: don't exceed the length of the input-package, set
- *       bit 15 of the compressed size to 1 if you have copied data
- *       instead of compressing it.
- */
-static int zft_compress(__u8 *in_buffer, unsigned int in_sz, __u8 *out_buffer)
-{ 
-        __s32 compressed_sz;
-        TRACE_FUN(ft_t_flow);
-        
-
-        lzrw3_compress(COMPRESS_ACTION_COMPRESS, zftc_wrk_mem,
-                       in_buffer, in_sz, out_buffer, &compressed_sz);
-        if (TRACE_LEVEL >= ft_t_info) {
-                /*  the compiler will optimize this away when
-                 *  compiled with NO_TRACE_AT_ALL option
-                 */
-                TRACE(ft_t_data_flow, "\n"
-                      KERN_INFO "before compression: %d bytes\n"
-                      KERN_INFO "after compresison : %d bytes", 
-                      in_sz, 
-                      (int)(compressed_sz < 0 
-                      ? -compressed_sz : compressed_sz));
-                /*  for statistical purposes
-                 */
-                zftc_wr_compressed   += (compressed_sz < 0 
-                                           ? -compressed_sz : compressed_sz);
-                zftc_wr_uncompressed += in_sz;
-        }
-        TRACE_EXIT (int)compressed_sz;
-}
-
-/* called by zft_compress_read() to decompress the data. Must
- * return the size of the decompressed data for sanity checks
- * (compared with zft_blk_sz)
- *
- * NOTE: Read the note for zft_compress() above!  If bit 15 of the
- *       parameter in_sz is set, then the data in in_buffer isn't
- *       compressed, which must be handled by the un-compression
- *       algorithm. (I changed lzrw3 to handle this.)
- *
- *  The parameter max_out_sz is needed to prevent buffer overruns when 
- *  uncompressing corrupt data.
- */
-static unsigned int zft_uncompress(__u8 *in_buffer, 
-                                   int in_sz, 
-                                   __u8 *out_buffer,
-                                   unsigned int max_out_sz)
-{ 
-        TRACE_FUN(ft_t_flow);
-        
-        lzrw3_compress(COMPRESS_ACTION_DECOMPRESS, zftc_wrk_mem,
-                       in_buffer, (__s32)in_sz,
-                       out_buffer, (__u32 *)&max_out_sz);
-        
-        if (TRACE_LEVEL >= ft_t_info) {
-                TRACE(ft_t_data_flow, "\n"
-                      KERN_INFO "before decompression: %d bytes\n"
-                      KERN_INFO "after decompression : %d bytes", 
-                      in_sz < 0 ? -in_sz : in_sz,(int)max_out_sz);
-                /*  for statistical purposes
-                 */
-                zftc_rd_compressed   += in_sz < 0 ? -in_sz : in_sz;
-                zftc_rd_uncompressed += max_out_sz;
-        }
-        TRACE_EXIT (unsigned int)max_out_sz;
-}
-
-/* print some statistics about the efficiency of the compression to
- * the kernel log 
- */
-static void zftc_stats(void)
-{
-        TRACE_FUN(ft_t_flow);
-
-        if (TRACE_LEVEL < ft_t_info) {
-                TRACE_EXIT;
-        }
-        if (zftc_wr_uncompressed != 0) {
-                if (zftc_wr_compressed > (1<<14)) {
-                        TRACE(ft_t_info, "compression statistics (writing):\n"
-                              KERN_INFO " compr./uncmpr.   : %3d %%",
-                              (((zftc_wr_compressed>>10) * 100)
-                               / (zftc_wr_uncompressed>>10)));
-                } else {
-                        TRACE(ft_t_info, "compression statistics (writing):\n"
-                              KERN_INFO " compr./uncmpr.   : %3d %%",
-                              ((zftc_wr_compressed * 100)
-                               / zftc_wr_uncompressed));
-                }
-        }
-        if (zftc_rd_uncompressed != 0) {
-                if (zftc_rd_compressed > (1<<14)) {
-                        TRACE(ft_t_info, "compression statistics (reading):\n"
-                              KERN_INFO " compr./uncmpr.   : %3d %%",
-                              (((zftc_rd_compressed>>10) * 100)
-                               / (zftc_rd_uncompressed>>10)));
-                } else {
-                        TRACE(ft_t_info, "compression statistics (reading):\n"
-                              KERN_INFO " compr./uncmpr.   : %3d %%",
-                              ((zftc_rd_compressed * 100)
-                               / zftc_rd_uncompressed));
-                }
-        }
-        /* only print it once: */
-        zftc_wr_uncompressed = 
-                zftc_wr_compressed  =
-                zftc_rd_uncompressed =
-                zftc_rd_compressed   = 0;
-        TRACE_EXIT;
-}
-
-/* start new compressed block 
- */
-static int start_new_cseg(cmpr_info *cluster, 
-                          char *dst_buf, 
-                          const zft_position *pos,
-                          const unsigned int blk_sz,
-                          const char *src_buf,
-                          const int this_segs_sz,
-                          const int qic113)
-{
-        int size_left;
-        int cp_cnt;
-        int buf_pos;
-        TRACE_FUN(ft_t_flow);
-
-        size_left = this_segs_sz - sizeof(__u16) - cluster->cmpr_sz;
-        TRACE(ft_t_data_flow,"\n" 
-              KERN_INFO "segment size   : %d\n"
-              KERN_INFO "compressed_sz: %d\n"
-              KERN_INFO "size_left      : %d",
-              this_segs_sz, cluster->cmpr_sz, size_left);
-        if (size_left > 18) { /* start a new cluseter */
-                cp_cnt = cluster->cmpr_sz;
-                cluster->cmpr_sz = 0;
-                buf_pos = cp_cnt + sizeof(__u16);
-                PUT2(dst_buf, 0, buf_pos);
-
-                if (qic113) {
-                        __s64 foffs = pos->volume_pos;
-                        if (cp_cnt) foffs += (__s64)blk_sz;
-
-                        TRACE(ft_t_data_flow, "new style QIC-113 header");
-                        PUT8(dst_buf, buf_pos, foffs);
-                        buf_pos += sizeof(__s64);
-                } else {
-                        __u32 foffs = (__u32)pos->volume_pos;
-                        if (cp_cnt) foffs += (__u32)blk_sz;
-                        
-                        TRACE(ft_t_data_flow, "old style QIC-80MC header");
-                        PUT4(dst_buf, buf_pos, foffs);
-                        buf_pos += sizeof(__u32);
-                }
-        } else if (size_left >= 0) {
-                cp_cnt = cluster->cmpr_sz;
-                cluster->cmpr_sz = 0;
-                buf_pos = cp_cnt + sizeof(__u16);
-                PUT2(dst_buf, 0, buf_pos);  
-                /* zero unused part of segment. */
-                memset(dst_buf + buf_pos, '\0', size_left);
-                buf_pos = this_segs_sz;
-        } else { /* need entire segment and more space */
-                PUT2(dst_buf, 0, 0); 
-                cp_cnt = this_segs_sz - sizeof(__u16);
-                cluster->cmpr_sz  -= cp_cnt;
-                buf_pos = this_segs_sz;
-        }
-        memcpy(dst_buf + sizeof(__u16), src_buf + cluster->cmpr_pos, cp_cnt);
-        cluster->cmpr_pos += cp_cnt;
-        TRACE_EXIT buf_pos;
-}
-
-/* return-value: the number of bytes removed from the user-buffer
- *               `src_buf' or error code
- *
- *  int *write_cnt           : how much actually has been moved to the
- *                             dst_buf. Need not be initialized when
- *                             function returns with an error code
- *                             (negativ return value) 
- *  __u8 *dst_buf            : kernel space buffer where the has to be
- *                             copied to. The contents of this buffers
- *                             goes to a specific segment.
- *  const int seg_sz         : the size of the segment dst_buf will be
- *                             copied to.
- *  const zft_position *pos  : struct containing the coordinates in
- *                             the current volume (byte position,
- *                             segment id of current segment etc)
- *  const zft_volinfo *volume: information about the current volume,
- *                             size etc.
- *  const __u8 *src_buf      : user space buffer that contains the
- *                             data the user wants to be written to
- *                             tape.
- *  const int req_len        : the amount of data the user wants to be
- *                             written to tape.
- */
-static int zftc_write(int *write_cnt,
-                      __u8 *dst_buf, const int seg_sz,
-                      const __u8 __user *src_buf, const int req_len,
-                      const zft_position *pos, const zft_volinfo *volume)
-{
-        int req_len_left = req_len;
-        int result;
-        int len_left;
-        int buf_pos_write = pos->seg_byte_pos;
-        TRACE_FUN(ft_t_flow);
-        
-        /* Note: we do not unlock the module because
-         * there are some values cached in that `cseg' variable.  We
-         * don't don't want to use this information when being
-         * unloaded by kerneld even when the tape is full or when we
-         * cannot allocate enough memory.
-         */
-        if (pos->tape_pos > (volume->size-volume->blk_sz-ZFT_CMPR_OVERHEAD)) {
-                TRACE_EXIT -ENOSPC;
-        }    
-        if (zft_allocate_cmpr_mem(volume->blk_sz) < 0) {
-                /* should we unlock the module? But it shouldn't 
-                 * be locked anyway ...
-                 */
-                TRACE_EXIT -ENOMEM;
-        }
-        if (buf_pos_write == 0) { /* fill a new segment */
-                *write_cnt = buf_pos_write = start_new_cseg(&cseg,
-                                                            dst_buf,
-                                                            pos,
-                                                            volume->blk_sz,
-                                                            zftc_buf, 
-                                                            seg_sz,
-                                                            volume->qic113);
-                if (cseg.cmpr_sz == 0 && cseg.cmpr_pos != 0) {
-                        req_len_left -= result = volume->blk_sz;
-                        cseg.cmpr_pos  = 0;
-                } else {
-                        result = 0;
-                }
-        } else {
-                *write_cnt = result = 0;
-        }
-        
-        len_left = seg_sz - buf_pos_write;
-        while ((req_len_left > 0) && (len_left > 18)) {
-                /* now we have some size left for a new compressed
-                 * block.  We know, that the compression buffer is
-                 * empty (else there wouldn't be any space left).  
-                 */
-                if (copy_from_user(zftc_scratch_buf, src_buf + result, 
-                                   volume->blk_sz) != 0) {
-                        TRACE_EXIT -EFAULT;
-                }
-                req_len_left -= volume->blk_sz;
-                cseg.cmpr_sz = zft_compress(zftc_scratch_buf, volume->blk_sz, 
-                                            zftc_buf);
-                if (cseg.cmpr_sz < 0) {
-                        cseg.uncmpr = 0x8000;
-                        cseg.cmpr_sz = -cseg.cmpr_sz;
-                } else {
-                        cseg.uncmpr = 0;
-                }
-                /* increment "result" iff we copied the entire
-                 * compressed block to the zft_deblock_buf 
-                 */
-                len_left -= sizeof(__u16);
-                if (len_left >= cseg.cmpr_sz) {
-                        len_left -= cseg.count = cseg.cmpr_sz;
-                        cseg.cmpr_pos = cseg.cmpr_sz = 0;
-                        result += volume->blk_sz;
-                } else {
-                        cseg.cmpr_sz       -= 
-                                cseg.cmpr_pos =
-                                cseg.count    = len_left;
-                        len_left = 0;
-                }
-                PUT2(dst_buf, buf_pos_write, cseg.uncmpr | cseg.count);
-                buf_pos_write += sizeof(__u16);
-                memcpy(dst_buf + buf_pos_write, zftc_buf, cseg.count);
-                buf_pos_write += cseg.count;
-                *write_cnt    += cseg.count + sizeof(__u16);
-                FT_SIGNAL_EXIT(_DONT_BLOCK);
-        }
-        /* erase the remainder of the segment if less than 18 bytes
-         * left (18 bytes is due to the QIC-80 standard) 
-         */
-        if (len_left <= 18) {
-                memset(dst_buf + buf_pos_write, '\0', len_left);
-                (*write_cnt) += len_left;
-        }
-        TRACE(ft_t_data_flow, "returning %d", result);
-        TRACE_EXIT result;
-}   
-
-/* out:
- *
- * int *read_cnt: the number of bytes we removed from the zft_deblock_buf
- *                (result)
- * int *to_do   : the remaining size of the read-request.
- *
- * in:
- *
- * char *buff          : buff is the address of the upper part of the user
- *                       buffer, that hasn't been filled with data yet.
-
- * int buf_pos_read    : copy of from _ftape_read()
- * int buf_len_read    : copy of buf_len_rd from _ftape_read()
- * char *zft_deblock_buf: zft_deblock_buf
- * unsigned short blk_sz: the block size valid for this volume, may differ
- *                            from zft_blk_sz.
- * int finish: if != 0 means that this is the last segment belonging
- *  to this volume
- * returns the amount of data actually copied to the user-buffer
- *
- * to_do MUST NOT SHRINK except to indicate an EOF. In this case *to_do has to
- * be set to 0 
- */
-static int zftc_read (int *read_cnt, 
-                      __u8  __user *dst_buf, const int to_do, 
-                      const __u8 *src_buf, const int seg_sz, 
-                      const zft_position *pos, const zft_volinfo *volume)
-{          
-        int uncompressed_sz;         
-        int result = 0;
-        int remaining = to_do;
-        TRACE_FUN(ft_t_flow);
-
-        TRACE_CATCH(zft_allocate_cmpr_mem(volume->blk_sz),);
-        if (pos->seg_byte_pos == 0) {
-                /* new segment just read
-                 */
-                TRACE_CATCH(get_cseg(&cseg, src_buf, seg_sz, volume),
-                            *read_cnt = 0);
-                memcpy(zftc_buf + cseg.cmpr_pos, src_buf + sizeof(__u16), 
-                       cseg.count);
-                cseg.cmpr_pos += cseg.count;
-                *read_cnt      = cseg.offset;
-                DUMP_CMPR_INFO(ft_t_noise /* ft_t_any */, "", &cseg);
-        } else {
-                *read_cnt = 0;
-        }
-        /* loop and uncompress until user buffer full or
-         * deblock-buffer empty 
-         */
-        TRACE(ft_t_data_flow, "compressed_sz: %d, compos : %d, *read_cnt: %d",
-              cseg.cmpr_sz, cseg.cmpr_pos, *read_cnt);
-        while ((cseg.spans == 0) && (remaining > 0)) {
-                if (cseg.cmpr_pos  != 0) { /* cmpr buf is not empty */
-                        uncompressed_sz = 
-                                zft_uncompress(zftc_buf,
-                                               cseg.uncmpr == 0x8000 ?
-                                               -cseg.cmpr_pos : cseg.cmpr_pos,
-                                               zftc_scratch_buf,
-                                               volume->blk_sz);
-                        if (uncompressed_sz != volume->blk_sz) {
-                                *read_cnt = 0;
-                                TRACE_ABORT(-EIO, ft_t_warn,
-                                      "Uncompressed blk (%d) != blk size (%d)",
-                                      uncompressed_sz, volume->blk_sz);
-                        }       
-                        if (copy_to_user(dst_buf + result, 
-                                         zftc_scratch_buf, 
-                                         uncompressed_sz) != 0 ) {
-                                TRACE_EXIT -EFAULT;
-                        }
-                        remaining      -= uncompressed_sz;
-                        result     += uncompressed_sz;
-                        cseg.cmpr_pos  = 0;
-                }                                              
-                if (remaining > 0) {
-                        get_next_cluster(&cseg, src_buf, seg_sz, 
-                                         volume->end_seg == pos->seg_pos);
-                        if (cseg.count != 0) {
-                                memcpy(zftc_buf, src_buf + cseg.offset,
-                                       cseg.count);
-                                cseg.cmpr_pos = cseg.count;
-                                cseg.offset  += cseg.count;
-                                *read_cnt += cseg.count + sizeof(__u16);
-                        } else {
-                                remaining = 0;
-                        }
-                }
-                TRACE(ft_t_data_flow, "\n" 
-                      KERN_INFO "compressed_sz: %d\n"
-                      KERN_INFO "compos       : %d\n"
-                      KERN_INFO "*read_cnt    : %d",
-                      cseg.cmpr_sz, cseg.cmpr_pos, *read_cnt);
-        }
-        if (seg_sz - cseg.offset <= 18) {
-                *read_cnt += seg_sz - cseg.offset;
-                TRACE(ft_t_data_flow, "expanding read cnt to: %d", *read_cnt);
-        }
-        TRACE(ft_t_data_flow, "\n"
-              KERN_INFO "segment size   : %d\n"
-              KERN_INFO "read count     : %d\n"
-              KERN_INFO "buf_pos_read   : %d\n"
-              KERN_INFO "remaining      : %d",
-                seg_sz, *read_cnt, pos->seg_byte_pos, 
-                seg_sz - *read_cnt - pos->seg_byte_pos);
-        TRACE(ft_t_data_flow, "returning: %d", result);
-        TRACE_EXIT result;
-}                
-
-/* seeks to the new data-position. Reads sometimes a segment.
- *  
- * start_seg and end_seg give the boundaries of the current volume
- * blk_sz is the blk_sz of the current volume as stored in the
- * volume label
- *
- * We don't allow blocksizes less than 1024 bytes, therefore we don't need
- * a 64 bit argument for new_block_pos.
- */
-
-static int seek_in_segment(const unsigned int to_do, cmpr_info  *c_info,
-                           const char *src_buf, const int seg_sz, 
-                           const int seg_pos, const zft_volinfo *volume);
-static int slow_seek_forward_until_error(const unsigned int distance,
-                                         cmpr_info *c_info, zft_position *pos, 
-                                         const zft_volinfo *volume, __u8 *buf);
-static int search_valid_segment(unsigned int segment,
-                                const unsigned int end_seg,
-                                const unsigned int max_foffs,
-                                zft_position *pos, cmpr_info *c_info,
-                                const zft_volinfo *volume, __u8 *buf);
-static int slow_seek_forward(unsigned int dest, cmpr_info *c_info,
-                             zft_position *pos, const zft_volinfo *volume,
-                             __u8 *buf);
-static int compute_seg_pos(unsigned int dest, zft_position *pos,
-                           const zft_volinfo *volume);
-
-#define ZFT_SLOW_SEEK_THRESHOLD  10 /* segments */
-#define ZFT_FAST_SEEK_MAX_TRIALS 10 /* times */
-#define ZFT_FAST_SEEK_BACKUP     10 /* segments */
-
-static int zftc_seek(unsigned int new_block_pos,
-                     zft_position *pos, const zft_volinfo *volume, __u8 *buf)
-{
-        unsigned int dest;
-        int limit;
-        int distance;
-        int result = 0;
-        int seg_dist;
-        int new_seg;
-        int old_seg = 0;
-        int fast_seek_trials = 0;
-        TRACE_FUN(ft_t_flow);
-
-        if (new_block_pos == 0) {
-                pos->seg_pos      = volume->start_seg;
-                pos->seg_byte_pos = 0;
-                pos->volume_pos   = 0;
-                zftc_reset();
-                TRACE_EXIT 0;
-        }
-        dest = new_block_pos * (volume->blk_sz >> 10);
-        distance = dest - (pos->volume_pos >> 10);
-        while (distance != 0) {
-                seg_dist = compute_seg_pos(dest, pos, volume);
-                TRACE(ft_t_noise, "\n"
-                      KERN_INFO "seg_dist: %d\n"
-                      KERN_INFO "distance: %d\n"
-                      KERN_INFO "dest    : %d\n"
-                      KERN_INFO "vpos    : %d\n"
-                      KERN_INFO "seg_pos : %d\n"
-                      KERN_INFO "trials  : %d",
-                      seg_dist, distance, dest,
-                      (unsigned int)(pos->volume_pos>>10), pos->seg_pos,
-                      fast_seek_trials);
-                if (distance > 0) {
-                        if (seg_dist < 0) {
-                                TRACE(ft_t_bug, "BUG: distance %d > 0, "
-                                      "segment difference %d < 0",
-                                      distance, seg_dist);
-                                result = -EIO;
-                                break;
-                        }
-                        new_seg = pos->seg_pos + seg_dist;
-                        if (new_seg > volume->end_seg) {
-                                new_seg = volume->end_seg;
-                        }
-                        if (old_seg == new_seg || /* loop */
-                            seg_dist <= ZFT_SLOW_SEEK_THRESHOLD ||
-                            fast_seek_trials >= ZFT_FAST_SEEK_MAX_TRIALS) {
-                                TRACE(ft_t_noise, "starting slow seek:\n"
-                                   KERN_INFO "fast seek failed too often: %s\n"
-                                   KERN_INFO "near target position      : %s\n"
-                                   KERN_INFO "looping between two segs  : %s",
-                                      (fast_seek_trials >= 
-                                       ZFT_FAST_SEEK_MAX_TRIALS)
-                                      ? "yes" : "no",
-                                      (seg_dist <= ZFT_SLOW_SEEK_THRESHOLD) 
-                                      ? "yes" : "no",
-                                      (old_seg == new_seg)
-                                      ? "yes" : "no");
-                                result = slow_seek_forward(dest, &cseg, 
-                                                           pos, volume, buf);
-                                break;
-                        }
-                        old_seg = new_seg;
-                        limit = volume->end_seg;
-                        fast_seek_trials ++;
-                        for (;;) {
-                                result = search_valid_segment(new_seg, limit,
-                                                              volume->size,
-                                                              pos, &cseg,
-                                                              volume, buf);
-                                if (result == 0 || result == -EINTR) {
-                                        break;
-                                }
-                                if (new_seg == volume->start_seg) {
-                                        result = -EIO; /* set errror 
-                                                        * condition
-                                                        */
-                                        break;
-                                }
-                                limit    = new_seg;
-                                new_seg -= ZFT_FAST_SEEK_BACKUP;
-                                if (new_seg < volume->start_seg) {
-                                        new_seg = volume->start_seg;
-                                }
-                        }
-                        if (result < 0) {
-                                TRACE(ft_t_warn,
-                                      "Couldn't find a readable segment");
-                                break;
-                        }
-                } else /* if (distance < 0) */ {
-                        if (seg_dist > 0) {
-                                TRACE(ft_t_bug, "BUG: distance %d < 0, "
-                                      "segment difference %d >0",
-                                      distance, seg_dist);
-                                result = -EIO;
-                                break;
-                        }
-                        new_seg = pos->seg_pos + seg_dist;
-                        if (fast_seek_trials > 0 && seg_dist == 0) {
-                                /* this avoids sticking to the same
-                                 * segment all the time. On the other hand:
-                                 * if we got here for the first time, and the
-                                 * deblock_buffer still contains a valid
-                                 * segment, then there is no need to skip to 
-                                 * the previous segment if the desired position
-                                 * is inside this segment.
-                                 */
-                                new_seg --;
-                        }
-                        if (new_seg < volume->start_seg) {
-                                new_seg = volume->start_seg;
-                        }
-                        limit   = pos->seg_pos;
-                        fast_seek_trials ++;
-                        for (;;) {
-                                result = search_valid_segment(new_seg, limit,
-                                                              pos->volume_pos,
-                                                              pos, &cseg,
-                                                              volume, buf);
-                                if (result == 0 || result == -EINTR) {
-                                        break;
-                                }
-                                if (new_seg == volume->start_seg) {
-                                        result = -EIO; /* set errror 
-                                                        * condition
-                                                        */
-                                        break;
-                                }
-                                limit    = new_seg;
-                                new_seg -= ZFT_FAST_SEEK_BACKUP;
-                                if (new_seg < volume->start_seg) {
-                                        new_seg = volume->start_seg;
-                                }
-                        }
-                        if (result < 0) {
-                                TRACE(ft_t_warn,
-                                      "Couldn't find a readable segment");
-                                break;
-                        }
-                }
-                distance = dest - (pos->volume_pos >> 10);
-        }
-        TRACE_EXIT result;
-}
-
-
-/*  advance inside the given segment at most to_do bytes.
- *  of kilobytes moved
- */
-
-static int seek_in_segment(const unsigned int to_do,
-                           cmpr_info  *c_info,
-                           const char *src_buf, 
-                           const int seg_sz, 
-                           const int seg_pos,
-                           const zft_volinfo *volume)
-{
-        int result = 0;
-        int blk_sz = volume->blk_sz >> 10;
-        int remaining = to_do;
-        TRACE_FUN(ft_t_flow);
-
-        if (c_info->offset == 0) {
-                /* new segment just read
-                 */
-                TRACE_CATCH(get_cseg(c_info, src_buf, seg_sz, volume),);
-                c_info->cmpr_pos += c_info->count;
-                DUMP_CMPR_INFO(ft_t_noise, "", c_info);
-        }
-        /* loop and uncompress until user buffer full or
-         * deblock-buffer empty 
-         */
-        TRACE(ft_t_noise, "compressed_sz: %d, compos : %d",
-              c_info->cmpr_sz, c_info->cmpr_pos);
-        while (c_info->spans == 0 && remaining > 0) {
-                if (c_info->cmpr_pos  != 0) { /* cmpr buf is not empty */
-                        result       += blk_sz;
-                        remaining    -= blk_sz;
-                        c_info->cmpr_pos = 0;
-                }
-                if (remaining > 0) {
-                        get_next_cluster(c_info, src_buf, seg_sz, 
-                                         volume->end_seg == seg_pos);
-                        if (c_info->count != 0) {
-                                c_info->cmpr_pos = c_info->count;
-                                c_info->offset  += c_info->count;
-                        } else {
-                                break;
-                        }
-                }
-                /*  Allow escape from this loop on signal!
-                 */
-                FT_SIGNAL_EXIT(_DONT_BLOCK);
-                DUMP_CMPR_INFO(ft_t_noise, "", c_info);
-                TRACE(ft_t_noise, "to_do: %d", remaining);
-        }
-        if (seg_sz - c_info->offset <= 18) {
-                c_info->offset = seg_sz;
-        }
-        TRACE(ft_t_noise, "\n"
-              KERN_INFO "segment size   : %d\n"
-              KERN_INFO "buf_pos_read   : %d\n"
-              KERN_INFO "remaining      : %d",
-              seg_sz, c_info->offset,
-              seg_sz - c_info->offset);
-        TRACE_EXIT result;
-}                
-
-static int slow_seek_forward_until_error(const unsigned int distance,
-                                         cmpr_info *c_info,
-                                         zft_position *pos, 
-                                         const zft_volinfo *volume,
-                                         __u8 *buf)
-{
-        unsigned int remaining = distance;
-        int seg_sz;
-        int seg_pos;
-        int result;
-        TRACE_FUN(ft_t_flow);
-        
-        seg_pos = pos->seg_pos;
-        do {
-                TRACE_CATCH(seg_sz = zft_fetch_segment(seg_pos, buf, 
-                                                       FT_RD_AHEAD),);
-                /* now we have the contents of the actual segment in
-                 * the deblock buffer
-                 */
-                TRACE_CATCH(result = seek_in_segment(remaining, c_info, buf,
-                                                     seg_sz, seg_pos,volume),);
-                remaining        -= result;
-                pos->volume_pos  += result<<10;
-                pos->seg_pos      = seg_pos;
-                pos->seg_byte_pos = c_info->offset;
-                seg_pos ++;
-                if (seg_pos <= volume->end_seg && c_info->offset == seg_sz) {
-                        pos->seg_pos ++;
-                        pos->seg_byte_pos = 0;
-                        c_info->offset = 0;
-                }
-                /*  Allow escape from this loop on signal!
-                 */
-                FT_SIGNAL_EXIT(_DONT_BLOCK);
-                TRACE(ft_t_noise, "\n"
-                      KERN_INFO "remaining:  %d\n"
-                      KERN_INFO "seg_pos:    %d\n"
-                      KERN_INFO "end_seg:    %d\n"
-                      KERN_INFO "result:     %d",
-                      remaining, seg_pos, volume->end_seg, result);  
-        } while (remaining > 0 && seg_pos <= volume->end_seg);
-        TRACE_EXIT 0;
-}
-
-/* return segment id of next segment containing valid data, -EIO otherwise
- */
-static int search_valid_segment(unsigned int segment,
-                                const unsigned int end_seg,
-                                const unsigned int max_foffs,
-                                zft_position *pos,
-                                cmpr_info *c_info,
-                                const zft_volinfo *volume,
-                                __u8 *buf)
-{
-        cmpr_info tmp_info;
-        int seg_sz;
-        TRACE_FUN(ft_t_flow);
-        
-        memset(&tmp_info, 0, sizeof(cmpr_info));
-        while (segment <= end_seg) {
-                FT_SIGNAL_EXIT(_DONT_BLOCK);
-                TRACE(ft_t_noise,
-                      "Searching readable segment between %d and %d",
-                      segment, end_seg);
-                seg_sz = zft_fetch_segment(segment, buf, FT_RD_AHEAD);
-                if ((seg_sz > 0) &&
-                    (get_cseg (&tmp_info, buf, seg_sz, volume) >= 0) &&
-                    (tmp_info.foffs != 0 || segment == volume->start_seg)) {
-                        if ((tmp_info.foffs>>10) > max_foffs) {
-                                TRACE_ABORT(-EIO, ft_t_noise, "\n"
-                                            KERN_INFO "cseg.foff: %d\n"
-                                            KERN_INFO "dest     : %d",
-                                            (int)(tmp_info.foffs >> 10),
-                                            max_foffs);
-                        }
-                        DUMP_CMPR_INFO(ft_t_noise, "", &tmp_info);
-                        *c_info           = tmp_info;
-                        pos->seg_pos      = segment;
-                        pos->volume_pos   = c_info->foffs;
-                        pos->seg_byte_pos = c_info->offset;
-                        TRACE(ft_t_noise, "found segment at %d", segment);
-                        TRACE_EXIT 0;
-                }
-                segment++;
-        }
-        TRACE_EXIT -EIO;
-}
-
-static int slow_seek_forward(unsigned int dest,
-                             cmpr_info *c_info,
-                             zft_position *pos,
-                             const zft_volinfo *volume,
-                             __u8 *buf)
-{
-        unsigned int distance;
-        int result = 0;
-        TRACE_FUN(ft_t_flow);
-                
-        distance = dest - (pos->volume_pos >> 10);
-        while ((distance > 0) &&
-               (result = slow_seek_forward_until_error(distance,
-                                                       c_info,
-                                                       pos,
-                                                       volume,
-                                                       buf)) < 0) {
-                if (result == -EINTR) {
-                        break;
-                }
-                TRACE(ft_t_noise, "seg_pos: %d", pos->seg_pos);
-                /* the failing segment is either pos->seg_pos or
-                 * pos->seg_pos + 1. There is no need to further try
-                 * that segment, because ftape_read_segment() already
-                 * has tried very much to read it. So we start with
-                 * following segment, which is pos->seg_pos + 1
-                 */
-                if(search_valid_segment(pos->seg_pos+1, volume->end_seg, dest,
-                                        pos, c_info,
-                                        volume, buf) < 0) {
-                        TRACE(ft_t_noise, "search_valid_segment() failed");
-                        result = -EIO;
-                        break;
-                }
-                distance = dest - (pos->volume_pos >> 10);
-                result = 0;
-                TRACE(ft_t_noise, "segment: %d", pos->seg_pos);
-                /* found valid segment, retry the seek */
-        }
-        TRACE_EXIT result;
-}
-
-static int compute_seg_pos(const unsigned int dest,
-                           zft_position *pos,
-                           const zft_volinfo *volume)
-{
-        int segment;
-        int distance = dest - (pos->volume_pos >> 10);
-        unsigned int raw_size;
-        unsigned int virt_size;
-        unsigned int factor;
-        TRACE_FUN(ft_t_flow);
-
-        if (distance >= 0) {
-                raw_size  = volume->end_seg - pos->seg_pos + 1;
-                virt_size = ((unsigned int)(volume->size>>10) 
-                             - (unsigned int)(pos->volume_pos>>10)
-                             + FT_SECTORS_PER_SEGMENT - FT_ECC_SECTORS - 1);
-                virt_size /= FT_SECTORS_PER_SEGMENT - FT_ECC_SECTORS;
-                if (virt_size == 0 || raw_size == 0) {
-                        TRACE_EXIT 0;
-                }
-                if (raw_size >= (1<<25)) {
-                        factor = raw_size/(virt_size>>7);
-                } else {
-                        factor = (raw_size<<7)/virt_size;
-                }
-                segment = distance/(FT_SECTORS_PER_SEGMENT-FT_ECC_SECTORS);
-                segment = (segment * factor)>>7;
-        } else {
-                raw_size  = pos->seg_pos - volume->start_seg + 1;
-                virt_size = ((unsigned int)(pos->volume_pos>>10)
-                             + FT_SECTORS_PER_SEGMENT - FT_ECC_SECTORS - 1);
-                virt_size /= FT_SECTORS_PER_SEGMENT - FT_ECC_SECTORS;
-                if (virt_size == 0 || raw_size == 0) {
-                        TRACE_EXIT 0;
-                }
-                if (raw_size >= (1<<25)) {
-                        factor = raw_size/(virt_size>>7);
-                } else {
-                        factor = (raw_size<<7)/virt_size;
-                }
-                segment = distance/(FT_SECTORS_PER_SEGMENT-FT_ECC_SECTORS);
-        }
-        TRACE(ft_t_noise, "factor: %d/%d", factor, 1<<7);
-        TRACE_EXIT segment;
-}
-
-static struct zft_cmpr_ops cmpr_ops = {
-        zftc_write,
-        zftc_read,
-        zftc_seek,
-        zftc_lock,
-        zftc_reset,
-        zftc_cleanup
-};
-
-int zft_compressor_init(void)
-{
-        TRACE_FUN(ft_t_flow);
-        
-#ifdef MODULE
-        printk(KERN_INFO "zftape compressor v1.00a 970514 for " FTAPE_VERSION "\n");
-        if (TRACE_LEVEL >= ft_t_info) {
-                printk(
-KERN_INFO "(c) 1997 Claus-Justus Heine (claus@momo.math.rwth-aachen.de)\n"
-KERN_INFO "Compressor for zftape (lzrw3 algorithm)\n");
-        }
-#else /* !MODULE */
-        /* print a short no-nonsense boot message */
-        printk(KERN_INFO "zftape compressor v1.00a 970514\n");
-        printk(KERN_INFO "For use with " FTAPE_VERSION "\n");
-#endif /* MODULE */
-        TRACE(ft_t_info, "zft_compressor_init @ 0x%p", zft_compressor_init);
-        TRACE(ft_t_info, "installing compressor for zftape ...");
-        TRACE_CATCH(zft_cmpr_register(&cmpr_ops),);
-        TRACE_EXIT 0;
-}
-
-#ifdef MODULE
-
-MODULE_AUTHOR(
-        "(c) 1996, 1997 Claus-Justus Heine (claus@momo.math.rwth-aachen.de");
-MODULE_DESCRIPTION(
-"Compression routines for zftape. Uses the lzrw3 algorithm by Ross Williams");
-MODULE_LICENSE("GPL");
-
-/* Called by modules package when installing the driver
- */
-int init_module(void)
-{
-        return zft_compressor_init();
-}
-
-#endif /* MODULE */
diff --git a/drivers/char/ftape/compressor/zftape-compress.h b/drivers/char/ftape/compressor/zftape-compress.h
deleted file mode 100644
index f200741e33bf..000000000000
--- a/drivers/char/ftape/compressor/zftape-compress.h
+++ /dev/null
@@ -1,83 +0,0 @@
-#ifndef _ZFTAPE_COMPRESS_H
-#define _ZFTAPE_COMPRESS_H
-/*
- *      Copyright (c) 1994-1997 Claus-Justus Heine
-
- This program is free software; you can redistribute it and/or
- modify it under the terms of the GNU General Public License as
- published by the Free Software Foundation; either version 2, or (at
- your option) any later version.
- 
- This program is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- General Public License for more details.
- 
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
- USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/compressor/zftape-compress.h,v $
- * $Revision: 1.1 $
- * $Date: 1997/10/05 19:12:32 $
- *
- * This file contains macros and definitions for zftape's
- * builtin compression code.
- *
- */
-
-#include "../zftape/zftape-buffers.h"
-#include "../zftape/zftape-vtbl.h"
-#include "../compressor/lzrw3.h"
-
-/* CMPR_WRK_MEM_SIZE gives the size of the compression wrk_mem */
-/* I got these out of lzrw3.c */
-#define U(X)            ((__u32) X)
-#define SIZE_P_BYTE     (U(sizeof(__u8 *)))
-#define ALIGNMENT_FUDGE (U(16))
-
-#define CMPR_WRK_MEM_SIZE (U(4096)*(SIZE_P_BYTE) + ALIGNMENT_FUDGE)
-
-/* the maximum number of bytes the size of the "compressed" data can
- * exceed the uncompressed data. As it is quite useless to compress
- * data twice it is sometimes the case that it is more efficient to
- * copy a block of data but to feed it to the "compression"
- * algorithm. In this case there are some flag bytes or the like
- * proceding the "compressed" data.  THAT MUST NOT BE THE CASE for the
- * algorithm we use for this driver. Instead, the high bit 15 of
- * compressed_size:
- *
- * compressed_size = ftape_compress()
- *
- * must be set in such a case.
- *
- * Nevertheless, it might also be as for lzrw3 that there is an
- * "intermediate" overrun that exceeds the amount of the compressed
- * data that is actually produced. During the algorithm we need in the
- * worst case MAX_CMP_GROUP bytes more than the input-size.
- */
-#define MAX_CMP_GROUP (2+16*2) /* from lzrw3.c */
-
-#define CMPR_OVERRUN      MAX_CMP_GROUP /* during compression */
-
-/****************************************************/
-
-#define     CMPR_BUFFER_SIZE (MAX_BLOCK_SIZE + CMPR_OVERRUN)
-
-/* the compression map stores the byte offset compressed blocks within
- * the current volume for catridges with format code 2,3 and 5
- * (and old versions of zftape) and the offset measured in kilobytes for
- * format code 4 and 6. This gives us a possible max. size of a 
- * compressed volume of 1024*4GIG which should be enough.
- */
-typedef __u32 CmprMap;
-
-/* globals 
- */
-
-/* exported functions
- */
-
-#endif /* _ZFTAPE_COMPRESS_H */
diff --git a/drivers/char/ftape/lowlevel/Makefile b/drivers/char/ftape/lowlevel/Makefile
deleted file mode 100644
index febab07ba427..000000000000
--- a/drivers/char/ftape/lowlevel/Makefile
+++ /dev/null
@@ -1,43 +0,0 @@
-#
-#       Copyright (C) 1996, 1997 Clau-Justus Heine.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2, or (at your option)
-# any later version.
-# 
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-# 
-# You should have received a copy of the GNU General Public License
-# along with this program; see the file COPYING.  If not, write to
-# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-#
-# $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/Makefile,v $
-# $Revision: 1.4 $
-# $Date: 1997/10/07 09:26:02 $
-#
-#      Makefile for the lowlevel part QIC-40/80/3010/3020 floppy-tape
-#      driver for Linux.
-#
-
-obj-$(CONFIG_FTAPE) += ftape.o
-
-ftape-objs := ftape-init.o fdc-io.o fdc-isr.o \
-              ftape-bsm.o ftape-ctl.o ftape-read.o ftape-rw.o \
-              ftape-write.o ftape-io.o ftape-calibr.o ftape-ecc.o fc-10.o \
-              ftape-buffer.o ftape-format.o ftape_syms.o
-
-ifeq ($(CONFIG_FTAPE),y)
-ftape-objs += ftape-setup.o
-endif
-
-ifndef CONFIG_FT_NO_TRACE_AT_ALL
-ftape-objs += ftape-tracing.o
-endif
-
-ifeq ($(CONFIG_FT_PROC_FS),y)
-ftape-objs += ftape-proc.o
-endif
diff --git a/drivers/char/ftape/lowlevel/fc-10.c b/drivers/char/ftape/lowlevel/fc-10.c
deleted file mode 100644
index 9bc1cddade76..000000000000
--- a/drivers/char/ftape/lowlevel/fc-10.c
+++ /dev/null
@@ -1,175 +0,0 @@
-/*
- *
-
-   Copyright (C) 1993,1994 Jon Tombs.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   The entire guts of this program was written by dosemu, modified to
-   record reads and writes to the ports in the 0x180-0x188 address space,
-   while running the CMS program TAPE.EXE V2.0.5 supplied with the drive.
-
-   Modified to use an array of addresses and generally cleaned up (made
-   much shorter) 4 June 94, dosemu isn't that good at writing short code it
-   would seem :-). Made independent of 0x180, but I doubt it will work
-   at any other address.
-
-   Modified for distribution with ftape source. 21 June 94, SJL.
-
-   Modifications on 20 October 95, by Daniel Cohen (catman@wpi.edu):
-   Modified to support different DMA, IRQ, and IO Ports.  Borland's
-   Turbo Debugger in virtual 8086 mode (TD386.EXE with hardware breakpoints
-   provided by the TDH386.SYS Device Driver) was used on the CMS program
-   TAPE V4.0.5.  I set breakpoints on I/O to ports 0x180-0x187.  Note that
-   CMS's program will not successfully configure the tape drive if you set
-   breakpoints on IO Reads, but you can set them on IO Writes without problems.
-   Known problems:
-   - You can not use DMA Channels 5 or 7.
-
-   Modification on 29 January 96, by Daniel Cohen (catman@wpi.edu):
-   Modified to only accept IRQs 3 - 7, or 9.  Since we can only send a 3 bit
-   number representing the IRQ to the card, special handling is required when
-   IRQ 9 is selected.  IRQ 2 and 9 are the same, and we should request IRQ 9
-   from the kernel while telling the card to use IRQ 2.  Thanks to Greg
-   Crider (gcrider@iclnet.org) for finding and locating this bug, as well as
-   testing the patch.
-
-   Modification on 11 December 96, by Claus Heine (claus@momo.math.rwth-aachen.de):
-   Modified a little to use variahle ft_fdc_base, ft_fdc_irq, ft_fdc_dma 
-   instead of preprocessor symbols. Thus we can compile this into the module
-   or kernel and let the user specify the options as command line arguments.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/fc-10.c,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:18:04 $
- *
- *      This file contains code for the CMS FC-10/FC-20 card.
- */
-
-#include <asm/io.h>
-#include <linux/ftape.h>
-#include "../lowlevel/ftape-tracing.h"
-#include "../lowlevel/fdc-io.h"
-#include "../lowlevel/fc-10.h"
-
-static __u16 inbs_magic[] = {
-        0x3, 0x3, 0x0, 0x4, 0x7, 0x2, 0x5, 0x3, 0x1, 0x4,
-        0x3, 0x5, 0x2, 0x0, 0x3, 0x7, 0x4, 0x2,
-        0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7
-};
-
-static __u16 fc10_ports[] = {
-        0x180, 0x210, 0x2A0, 0x300, 0x330, 0x340, 0x370
-};
-
-int fc10_enable(void)
-{
-        int i;
-        __u8 cardConfig = 0x00;
-        __u8 x;
-        TRACE_FUN(ft_t_flow);
-
-/*  This code will only work if the FC-10 (or FC-20) is set to
- *  use DMA channels 1, 2, or 3.  DMA channels 5 and 7 seem to be 
- *  initialized by the same command as channels 1 and 3, respectively.
- */
-        if (ft_fdc_dma > 3) {
-                TRACE_ABORT(0, ft_t_err,
-"Error: The FC-10/20 must be set to use DMA channels 1, 2, or 3!");
-        }
-/*  Only allow the FC-10/20 to use IRQ 3-7, or 9.  Note that CMS's program
- *  only accepts IRQ's 2-7, but in linux, IRQ 2 is the same as IRQ 9.
- */
-        if (ft_fdc_irq < 3 || ft_fdc_irq == 8 || ft_fdc_irq > 9) {
-                TRACE_ABORT(0, ft_t_err, 
-"Error: The FC-10/20 must be set to use IRQ levels 3 - 7, or 9!\n"
-KERN_INFO "Note: IRQ 9 is the same as IRQ 2");
-        }
-        /*  Clear state machine ???
-         */
-        for (i = 0; i < NR_ITEMS(inbs_magic); i++) {
-                inb(ft_fdc_base + inbs_magic[i]);
-        }
-        outb(0x0, ft_fdc_base);
-
-        x = inb(ft_fdc_base);
-        if (x == 0x13 || x == 0x93) {
-                for (i = 1; i < 8; i++) {
-                        if (inb(ft_fdc_base + i) != x) {
-                                TRACE_EXIT 0;
-                        }
-                }
-        } else {
-                TRACE_EXIT 0;
-        }
-
-        outb(0x8, ft_fdc_base);
-
-        for (i = 0; i < 8; i++) {
-                if (inb(ft_fdc_base + i) != 0x0) {
-                        TRACE_EXIT 0;
-                }
-        }
-        outb(0x10, ft_fdc_base);
-
-        for (i = 0; i < 8; i++) {
-                if (inb(ft_fdc_base + i) != 0xff) {
-                        TRACE_EXIT 0;
-                }
-        }
-
-        /*  Okay, we found a FC-10 card ! ???
-         */
-        outb(0x0, fdc.ccr);
-
-        /*  Clear state machine again ???
-         */
-        for (i = 0; i < NR_ITEMS(inbs_magic); i++) {
-                inb(ft_fdc_base + inbs_magic[i]);
-        }
-        /* Send io port */
-        for (i = 0; i < NR_ITEMS(fc10_ports); i++)
-                if (ft_fdc_base == fc10_ports[i])
-                        cardConfig = i + 1;
-        if (cardConfig == 0) {
-                TRACE_EXIT 0;   /* Invalid I/O Port */
-        }
-        /* and IRQ - If using IRQ 9, tell the FC card it is actually IRQ 2 */
-        if (ft_fdc_irq != 9)
-                cardConfig |= ft_fdc_irq << 3;
-        else
-                cardConfig |= 2 << 3;
-
-        /* and finally DMA Channel */
-        cardConfig |= ft_fdc_dma << 6;
-        outb(cardConfig, ft_fdc_base);  /* DMA [2 bits]/IRQ [3 bits]/BASE [3 bits] */
-
-        /*  Enable FC-10 ???
-         */
-        outb(0, fdc.ccr);
-        outb(0, fdc.dor2);
-        outb(FDC_DMA_MODE /* 8 */, fdc.dor);
-        outb(FDC_DMA_MODE /* 8 */, fdc.dor);
-        outb(1, fdc.dor2);
-
-        /*************************************
-         *
-         * cH: why the hell should this be necessary? This is done 
-         *     by fdc_reset()!!!
-         *
-         *************************************/
-        /*  Initialize fdc, select drive B:
-         */
-        outb(FDC_DMA_MODE, fdc.dor);    /* assert reset, dma & irq enabled */
-        /*       0x08    */
-        outb(FDC_DMA_MODE|FDC_RESET_NOT, fdc.dor);      /* release reset */
-        /*       0x08    |   0x04   = 0x0c */
-        outb(FDC_DMA_MODE|FDC_RESET_NOT|FDC_MOTOR_1|FTAPE_SEL_B, fdc.dor);
-        /*       0x08    |   0x04      |  0x20     |  0x01  = 0x2d */    
-        /* select drive 1 */ /* why not drive 0 ???? */
-        TRACE_EXIT (x == 0x93) ? 2 : 1;
-}
diff --git a/drivers/char/ftape/lowlevel/fc-10.h b/drivers/char/ftape/lowlevel/fc-10.h
deleted file mode 100644
index da7b88bca889..000000000000
--- a/drivers/char/ftape/lowlevel/fc-10.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#ifndef _FC_10_H
-#define _FC_10_H
-
-/*
- * Copyright (C) 1994-1996 Bas Laarhoven.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/fc-10.h,v $
- * $Revision: 1.1 $
- * $Date: 1997/09/19 09:05:22 $
- *
- *      This file contains definitions for the FC-10 code
- *      of the QIC-40/80 floppy-tape driver for Linux.
- */
-
-/*
- *      fc-10.c defined global vars.
- */
-
-/*
- *      fc-10.c defined global functions.
- */
-extern int fc10_enable(void);
-
-#endif
diff --git a/drivers/char/ftape/lowlevel/fdc-io.c b/drivers/char/ftape/lowlevel/fdc-io.c
deleted file mode 100644
index 65c9d2ec60bd..000000000000
--- a/drivers/char/ftape/lowlevel/fdc-io.c
+++ /dev/null
@@ -1,1350 +0,0 @@
-/*
- * Copyright (C) 1993-1996 Bas Laarhoven,
- *           (C) 1996-1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/fdc-io.c,v $
- * $Revision: 1.7.4.2 $
- * $Date: 1997/11/16 14:48:17 $
- *
- *      This file contains the low-level floppy disk interface code
- *      for the QIC-40/80/3010/3020 floppy-tape driver "ftape" for
- *      Linux.
- */
-
-#include <linux/config.h> /* for CONFIG_FT_* */
-#include <linux/errno.h>
-#include <linux/sched.h>
-#include <linux/ioport.h>
-#include <linux/interrupt.h>
-#include <linux/kernel.h>
-#include <asm/system.h>
-#include <asm/io.h>
-#include <asm/dma.h>
-#include <asm/irq.h>
-
-#include <linux/ftape.h>
-#include <linux/qic117.h>
-#include "../lowlevel/ftape-tracing.h"
-#include "../lowlevel/fdc-io.h"
-#include "../lowlevel/fdc-isr.h"
-#include "../lowlevel/ftape-io.h"
-#include "../lowlevel/ftape-rw.h"
-#include "../lowlevel/ftape-ctl.h"
-#include "../lowlevel/ftape-calibr.h"
-#include "../lowlevel/fc-10.h"
-
-/*      Global vars.
- */
-static int ftape_motor;
-volatile int ftape_current_cylinder = -1;
-volatile fdc_mode_enum fdc_mode = fdc_idle;
-fdc_config_info fdc;
-DECLARE_WAIT_QUEUE_HEAD(ftape_wait_intr);
-
-unsigned int ft_fdc_base       = CONFIG_FT_FDC_BASE;
-unsigned int ft_fdc_irq        = CONFIG_FT_FDC_IRQ;
-unsigned int ft_fdc_dma        = CONFIG_FT_FDC_DMA;
-unsigned int ft_fdc_threshold  = CONFIG_FT_FDC_THR;  /* bytes */
-unsigned int ft_fdc_rate_limit = CONFIG_FT_FDC_MAX_RATE; /* bits/sec */
-int ft_probe_fc10        = CONFIG_FT_PROBE_FC10;
-int ft_mach2             = CONFIG_FT_MACH2;
-
-/*      Local vars.
- */
-static spinlock_t fdc_io_lock; 
-static unsigned int fdc_calibr_count;
-static unsigned int fdc_calibr_time;
-static int fdc_status;
-volatile __u8 fdc_head;         /* FDC head from sector id */
-volatile __u8 fdc_cyl;          /* FDC track from sector id */
-volatile __u8 fdc_sect;         /* FDC sector from sector id */
-static int fdc_data_rate = 500; /* data rate (Kbps) */
-static int fdc_rate_code;       /* data rate code (0 == 500 Kbps) */
-static int fdc_seek_rate = 2;   /* step rate (msec) */
-static void (*do_ftape) (void);
-static int fdc_fifo_state;      /* original fifo setting - fifo enabled */
-static int fdc_fifo_thr;        /* original fifo setting - threshold */
-static int fdc_lock_state;      /* original lock setting - locked */
-static int fdc_fifo_locked;     /* has fifo && lock set ? */
-static __u8 fdc_precomp;        /* default precomp. value (nsec) */
-static __u8 fdc_prec_code;      /* fdc precomp. select code */
-
-static char ftape_id[] = "ftape";  /* used by request irq and free irq */
-
-static int fdc_set_seek_rate(int seek_rate);
-
-void fdc_catch_stray_interrupts(int count)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&fdc_io_lock, flags);
-        if (count == 0) {
-                ft_expected_stray_interrupts = 0;
-        } else {
-                ft_expected_stray_interrupts += count;
-        }
-        spin_unlock_irqrestore(&fdc_io_lock, flags);
-}
-
-/*  Wait during a timeout period for a given FDC status.
- *  If usecs == 0 then just test status, else wait at least for usecs.
- *  Returns -ETIME on timeout. Function must be calibrated first !
- */
-static int fdc_wait(unsigned int usecs, __u8 mask, __u8 state)
-{
-        int count_1 = (fdc_calibr_count * usecs +
-                       fdc_calibr_count - 1) / fdc_calibr_time;
-
-        do {
-                fdc_status = inb_p(fdc.msr);
-                if ((fdc_status & mask) == state) {
-                        return 0;
-                }
-        } while (count_1-- >= 0);
-        return -ETIME;
-}
-
-int fdc_ready_wait(unsigned int usecs)
-{
-        return fdc_wait(usecs, FDC_DATA_READY | FDC_BUSY, FDC_DATA_READY);
-}
-
-/* Why can't we just use udelay()?
- */
-static void fdc_usec_wait(unsigned int usecs)
-{
-        fdc_wait(usecs, 0, 1);  /* will always timeout ! */
-}
-
-static int fdc_ready_out_wait(unsigned int usecs)
-{
-        fdc_usec_wait(FT_RQM_DELAY);    /* wait for valid RQM status */
-        return fdc_wait(usecs, FDC_DATA_OUT_READY, FDC_DATA_OUT_READY);
-}
-
-void fdc_wait_calibrate(void)
-{
-        ftape_calibrate("fdc_wait",
-                        fdc_usec_wait, &fdc_calibr_count, &fdc_calibr_time); 
-}
-
-/*  Wait for a (short) while for the FDC to become ready
- *  and transfer the next command byte.
- *  Return -ETIME on timeout on getting ready (depends on hardware!).
- */
-static int fdc_write(const __u8 data)
-{
-        fdc_usec_wait(FT_RQM_DELAY);    /* wait for valid RQM status */
-        if (fdc_wait(150, FDC_DATA_READY_MASK, FDC_DATA_IN_READY) < 0) {
-                return -ETIME;
-        } else {
-                outb(data, fdc.fifo);
-                return 0;
-        }
-}
-
-/*  Wait for a (short) while for the FDC to become ready
- *  and transfer the next result byte.
- *  Return -ETIME if timeout on getting ready (depends on hardware!).
- */
-static int fdc_read(__u8 * data)
-{
-        fdc_usec_wait(FT_RQM_DELAY);    /* wait for valid RQM status */
-        if (fdc_wait(150, FDC_DATA_READY_MASK, FDC_DATA_OUT_READY) < 0) {
-                return -ETIME;
-        } else {
-                *data = inb(fdc.fifo);
-                return 0;
-        }
-}
-
-/*  Output a cmd_len long command string to the FDC.
- *  The FDC should be ready to receive a new command or
- *  an error (EBUSY or ETIME) will occur.
- */
-int fdc_command(const __u8 * cmd_data, int cmd_len)
-{
-        int result = 0;
-        unsigned long flags;
-        int count = cmd_len;
-        int retry = 0;
-#ifdef TESTING
-        static unsigned int last_time;
-        unsigned int time;
-#endif
-        TRACE_FUN(ft_t_any);
-
-        fdc_usec_wait(FT_RQM_DELAY);    /* wait for valid RQM status */
-        spin_lock_irqsave(&fdc_io_lock, flags);
-        if (!in_interrupt())
-                /* Yes, I know, too much comments inside this function
-                 * ...
-                 * 
-                 * Yet another bug in the original driver. All that
-                 * havoc is caused by the fact that the isr() sends
-                 * itself a command to the floppy tape driver (pause,
-                 * micro step pause).  Now, the problem is that
-                 * commands are transmitted via the fdc_seek
-                 * command. But: the fdc performs seeks in the
-                 * background i.e. it doesn't signal busy while
-                 * sending the step pulses to the drive. Therefore the
-                 * non-interrupt level driver has no chance to tell
-                 * whether the isr() just has issued a seek. Therefore
-                 * we HAVE TO have a look at the ft_hide_interrupt
-                 * flag: it signals the non-interrupt level part of
-                 * the driver that it has to wait for the fdc until it
-                 * has completet seeking.
-                 *
-                 * THIS WAS PRESUMABLY THE REASON FOR ALL THAT
-                 * "fdc_read timeout" errors, I HOPE :-)
-                 */
-                if (ft_hide_interrupt) {
-                        restore_flags(flags);
-                        TRACE(ft_t_info,
-                              "Waiting for the isr() completing fdc_seek()");
-                        if (fdc_interrupt_wait(2 * FT_SECOND) < 0) {
-                                TRACE(ft_t_warn,
-                      "Warning: timeout waiting for isr() seek to complete");
-                        }
-                        if (ft_hide_interrupt || !ft_seek_completed) {
-                                /* There cannot be another
-                                 * interrupt. The isr() only stops
-                                 * the tape and the next interrupt
-                                 * won't come until we have send our
-                                 * command to the drive.
-                                 */
-                                TRACE_ABORT(-EIO, ft_t_bug,
-                                            "BUG? isr() is still seeking?\n"
-                                            KERN_INFO "hide: %d\n"
-                                            KERN_INFO "seek: %d",
-                                            ft_hide_interrupt,
-                                            ft_seek_completed);
-
-                        }
-                        fdc_usec_wait(FT_RQM_DELAY);    /* wait for valid RQM status */
-                        spin_lock_irqsave(&fdc_io_lock, flags);
-                }
-        fdc_status = inb(fdc.msr);
-        if ((fdc_status & FDC_DATA_READY_MASK) != FDC_DATA_IN_READY) {
-                spin_unlock_irqrestore(&fdc_io_lock, flags);
-                TRACE_ABORT(-EBUSY, ft_t_err, "fdc not ready");
-        } 
-        fdc_mode = *cmd_data;   /* used by isr */
-#ifdef TESTING
-        if (fdc_mode == FDC_SEEK) {
-                time = ftape_timediff(last_time, ftape_timestamp());
-                if (time < 6000) {
-        TRACE(ft_t_bug,"Warning: short timeout between seek commands: %d",
-              time);
-                }
-        }
-#endif
-        if (!in_interrupt()) {
-                /* shouldn't be cleared if called from isr
-                 */
-                ft_interrupt_seen = 0;
-        }
-        while (count) {
-                result = fdc_write(*cmd_data);
-                if (result < 0) {
-                        TRACE(ft_t_fdc_dma,
-                              "fdc_mode = %02x, status = %02x at index %d",
-                              (int) fdc_mode, (int) fdc_status,
-                              cmd_len - count);
-                        if (++retry <= 3) {
-                                TRACE(ft_t_warn, "fdc_write timeout, retry");
-                        } else {
-                                TRACE(ft_t_err, "fdc_write timeout, fatal");
-                                /* recover ??? */
-                                break;
-                        }
-                } else {
-                        --count;
-                        ++cmd_data;
-                }
-        }
-#ifdef TESTING
-        if (fdc_mode == FDC_SEEK) {
-                last_time = ftape_timestamp();
-        }
-#endif
-        spin_unlock_irqrestore(&fdc_io_lock, flags);
-        TRACE_EXIT result;
-}
-
-/*  Input a res_len long result string from the FDC.
- *  The FDC should be ready to send the result or an error
- *  (EBUSY or ETIME) will occur.
- */
-int fdc_result(__u8 * res_data, int res_len)
-{
-        int result = 0;
-        unsigned long flags;
-        int count = res_len;
-        int retry = 0;
-        TRACE_FUN(ft_t_any);
-
-        spin_lock_irqsave(&fdc_io_lock, flags);
-        fdc_status = inb(fdc.msr);
-        if ((fdc_status & FDC_DATA_READY_MASK) != FDC_DATA_OUT_READY) {
-                TRACE(ft_t_err, "fdc not ready");
-                result = -EBUSY;
-        } else while (count) {
-                if (!(fdc_status & FDC_BUSY)) {
-                        spin_unlock_irqrestore(&fdc_io_lock, flags);
-                        TRACE_ABORT(-EIO, ft_t_err, "premature end of result phase");
-                }
-                result = fdc_read(res_data);
-                if (result < 0) {
-                        TRACE(ft_t_fdc_dma,
-                              "fdc_mode = %02x, status = %02x at index %d",
-                              (int) fdc_mode,
-                              (int) fdc_status,
-                              res_len - count);
-                        if (++retry <= 3) {
-                                TRACE(ft_t_warn, "fdc_read timeout, retry");
-                        } else {
-                                TRACE(ft_t_err, "fdc_read timeout, fatal");
-                                /* recover ??? */
-                                break;
-                                ++retry;
-                        }
-                } else {
-                        --count;
-                        ++res_data;
-                }
-        }
-        spin_unlock_irqrestore(&fdc_io_lock, flags);
-        fdc_usec_wait(FT_RQM_DELAY);    /* allow FDC to negate BSY */
-        TRACE_EXIT result;
-}
-
-/*      Handle command and result phases for
- *      commands without data phase.
- */
-static int fdc_issue_command(const __u8 * out_data, int out_count,
-                      __u8 * in_data, int in_count)
-{
-        TRACE_FUN(ft_t_any);
-
-        if (out_count > 0) {
-                TRACE_CATCH(fdc_command(out_data, out_count),);
-        }
-        /* will take 24 - 30 usec for fdc_sense_drive_status and
-         * fdc_sense_interrupt_status commands.
-         *    35 fails sometimes (5/9/93 SJL)
-         * On a loaded system it incidentally takes longer than
-         * this for the fdc to get ready ! ?????? WHY ??????
-         * So until we know what's going on use a very long timeout.
-         */
-        TRACE_CATCH(fdc_ready_out_wait(500 /* usec */),);
-        if (in_count > 0) {
-                TRACE_CATCH(fdc_result(in_data, in_count),
-                            TRACE(ft_t_err, "result phase aborted"));
-        }
-        TRACE_EXIT 0;
-}
-
-/*      Wait for FDC interrupt with timeout (in milliseconds).
- *      Signals are blocked so the wait will not be aborted.
- *      Note: interrupts must be enabled ! (23/05/93 SJL)
- */
-int fdc_interrupt_wait(unsigned int time)
-{
-        DECLARE_WAITQUEUE(wait,current);
-        sigset_t old_sigmask;   
-        static int resetting;
-        long timeout;
-
-        TRACE_FUN(ft_t_fdc_dma);
-
-        if (waitqueue_active(&ftape_wait_intr)) {
-                TRACE_ABORT(-EIO, ft_t_err, "error: nested call");
-        }
-        /* timeout time will be up to USPT microseconds too long ! */
-        timeout = (1000 * time + FT_USPT - 1) / FT_USPT;
-
-        spin_lock_irq(&current->sighand->siglock);
-        old_sigmask = current->blocked;
-        sigfillset(&current->blocked);
-        recalc_sigpending();
-        spin_unlock_irq(&current->sighand->siglock);
-
-        set_current_state(TASK_INTERRUPTIBLE);
-        add_wait_queue(&ftape_wait_intr, &wait);
-        while (!ft_interrupt_seen && timeout)
-                timeout = schedule_timeout_interruptible(timeout);
-
-        spin_lock_irq(&current->sighand->siglock);
-        current->blocked = old_sigmask;
-        recalc_sigpending();
-        spin_unlock_irq(&current->sighand->siglock);
-        
-        remove_wait_queue(&ftape_wait_intr, &wait);
-        /*  the following IS necessary. True: as well
-         *  wake_up_interruptible() as the schedule() set TASK_RUNNING
-         *  when they wakeup a task, BUT: it may very well be that
-         *  ft_interrupt_seen is already set to 1 when we enter here
-         *  in which case schedule() gets never called, and
-         *  TASK_RUNNING never set. This has the funny effect that we
-         *  execute all the code until we leave kernel space, but then
-         *  the task is stopped (a task CANNOT be preempted while in
-         *  kernel mode. Sending a pair of SIGSTOP/SIGCONT to the
-         *  tasks wakes it up again. Funny! :-)
-         */
-        current->state = TASK_RUNNING; 
-        if (ft_interrupt_seen) { /* woken up by interrupt */
-                ft_interrupt_seen = 0;
-                TRACE_EXIT 0;
-        }
-        /*  Original comment:
-         *  In first instance, next statement seems unnecessary since
-         *  it will be cleared in fdc_command. However, a small part of
-         *  the software seems to rely on this being cleared here
-         *  (ftape_close might fail) so stick to it until things get fixed !
-         */
-        /*  My deeply sought of knowledge:
-         *  Behold NO! It is obvious. fdc_reset() doesn't call fdc_command()
-         *  but nevertheless uses fdc_interrupt_wait(). OF COURSE this needs to
-         *  be reset here.
-         */
-        ft_interrupt_seen = 0;  /* clear for next call */
-        if (!resetting) {
-                resetting = 1;  /* break infinite recursion if reset fails */
-                TRACE(ft_t_any, "cleanup reset");
-                fdc_reset();
-                resetting = 0;
-        }
-        TRACE_EXIT (signal_pending(current)) ? -EINTR : -ETIME;
-}
-
-/*      Start/stop drive motor. Enable DMA mode.
- */
-void fdc_motor(int motor)
-{
-        int unit = ft_drive_sel;
-        int data = unit | FDC_RESET_NOT | FDC_DMA_MODE;
-        TRACE_FUN(ft_t_any);
-
-        ftape_motor = motor;
-        if (ftape_motor) {
-                data |= FDC_MOTOR_0 << unit;
-                TRACE(ft_t_noise, "turning motor %d on", unit);
-        } else {
-                TRACE(ft_t_noise, "turning motor %d off", unit);
-        }
-        if (ft_mach2) {
-                outb_p(data, fdc.dor2);
-        } else {
-                outb_p(data, fdc.dor);
-        }
-        ftape_sleep(10 * FT_MILLISECOND);
-        TRACE_EXIT;
-}
-
-static void fdc_update_dsr(void)
-{
-        TRACE_FUN(ft_t_any);
-
-        TRACE(ft_t_flow, "rate = %d Kbps, precomp = %d ns",
-              fdc_data_rate, fdc_precomp);
-        if (fdc.type >= i82077) {
-                outb_p((fdc_rate_code & 0x03) | fdc_prec_code, fdc.dsr);
-        } else {
-                outb_p(fdc_rate_code & 0x03, fdc.ccr);
-        }
-        TRACE_EXIT;
-}
-
-void fdc_set_write_precomp(int precomp)
-{
-        TRACE_FUN(ft_t_any);
-
-        TRACE(ft_t_noise, "New precomp: %d nsec", precomp);
-        fdc_precomp = precomp;
-        /*  write precompensation can be set in multiples of 41.67 nsec.
-         *  round the parameter to the nearest multiple and convert it
-         *  into a fdc setting. Note that 0 means default to the fdc,
-         *  7 is used instead of that.
-         */
-        fdc_prec_code = ((fdc_precomp + 21) / 42) << 2;
-        if (fdc_prec_code == 0 || fdc_prec_code > (6 << 2)) {
-                fdc_prec_code = 7 << 2;
-        }
-        fdc_update_dsr();
-        TRACE_EXIT;
-}
-
-/*  Reprogram the 82078 registers to use Data Rate Table 1 on all drives.
- */
-static void fdc_set_drive_specs(void)
-{
-        __u8 cmd[] = { FDC_DRIVE_SPEC, 0x00, 0x00, 0x00, 0x00, 0xc0};
-        int result;
-        TRACE_FUN(ft_t_any);
-
-        TRACE(ft_t_flow, "Setting of drive specs called");
-        if (fdc.type >= i82078_1) {
-                cmd[1] = (0 << 5) | (2 << 2);
-                cmd[2] = (1 << 5) | (2 << 2);
-                cmd[3] = (2 << 5) | (2 << 2);
-                cmd[4] = (3 << 5) | (2 << 2);
-                result = fdc_command(cmd, NR_ITEMS(cmd));
-                if (result < 0) {
-                        TRACE(ft_t_err, "Setting of drive specs failed");
-                }
-        }
-        TRACE_EXIT;
-}
-
-/* Select clock for fdc, must correspond with tape drive setting !
- * This also influences the fdc timing so we must adjust some values.
- */
-int fdc_set_data_rate(int rate)
-{
-        int bad_rate = 0;
-        TRACE_FUN(ft_t_any);
-
-        /* Select clock for fdc, must correspond with tape drive setting !
-         * This also influences the fdc timing so we must adjust some values.
-         */
-        TRACE(ft_t_fdc_dma, "new rate = %d", rate);
-        switch (rate) {
-        case 250:
-                fdc_rate_code = fdc_data_rate_250;
-                break;
-        case 500:
-                fdc_rate_code = fdc_data_rate_500;
-                break;
-        case 1000:
-                if (fdc.type < i82077) {
-                        bad_rate = 1;
-                } else {
-                        fdc_rate_code = fdc_data_rate_1000;
-                }
-                break;
-        case 2000:
-                if (fdc.type < i82078_1) {
-                        bad_rate = 1;
-                } else {
-                        fdc_rate_code = fdc_data_rate_2000;
-                }
-                break;
-        default:
-                bad_rate = 1;
-        }
-        if (bad_rate) {
-                TRACE_ABORT(-EIO,
-                            ft_t_fdc_dma, "%d is not a valid data rate", rate);
-        }
-        fdc_data_rate = rate;
-        fdc_update_dsr();
-        fdc_set_seek_rate(fdc_seek_rate);  /* clock changed! */
-        ftape_udelay(1000);
-        TRACE_EXIT 0;
-}
-
-/*  keep the unit select if keep_select is != 0,
- */
-static void fdc_dor_reset(int keep_select)
-{
-        __u8 fdc_ctl = ft_drive_sel;
-
-        if (keep_select != 0) {
-                fdc_ctl |= FDC_DMA_MODE;
-                if (ftape_motor) {
-                        fdc_ctl |= FDC_MOTOR_0 << ft_drive_sel;
-                }
-        }
-        ftape_udelay(10); /* ??? but seems to be necessary */
-        if (ft_mach2) {
-                outb_p(fdc_ctl & 0x0f, fdc.dor);
-                outb_p(fdc_ctl, fdc.dor2);
-        } else {
-                outb_p(fdc_ctl, fdc.dor);
-        }
-        fdc_usec_wait(10); /* delay >= 14 fdc clocks */
-        if (keep_select == 0) {
-                fdc_ctl = 0;
-        }
-        fdc_ctl |= FDC_RESET_NOT;
-        if (ft_mach2) {
-                outb_p(fdc_ctl & 0x0f, fdc.dor);
-                outb_p(fdc_ctl, fdc.dor2);
-        } else {
-                outb_p(fdc_ctl, fdc.dor);
-        }
-}
-
-/*      Reset the floppy disk controller. Leave the ftape_unit selected.
- */
-void fdc_reset(void)
-{
-        int st0;
-        int i;
-        int dummy;
-        unsigned long flags;
-        TRACE_FUN(ft_t_any);
-
-        spin_lock_irqsave(&fdc_io_lock, flags);
-
-        fdc_dor_reset(1); /* keep unit selected */
-
-        fdc_mode = fdc_idle;
-
-        /*  maybe the spin_lock_irq* pair is not necessary, BUT:
-         *  the following line MUST be here. Otherwise fdc_interrupt_wait()
-         *  won't wait. Note that fdc_reset() is called from 
-         *  ftape_dumb_stop() when the fdc is busy transferring data. In this
-         *  case fdc_isr() MOST PROBABLY sets ft_interrupt_seen, and tries
-         *  to get the result bytes from the fdc etc. CLASH.
-         */
-        ft_interrupt_seen = 0;
-        
-        /*  Program data rate
-         */
-        fdc_update_dsr();               /* restore data rate and precomp */
-
-        spin_unlock_irqrestore(&fdc_io_lock, flags);
-
-        /*
-         *      Wait for first polling cycle to complete
-         */
-        if (fdc_interrupt_wait(1 * FT_SECOND) < 0) {
-                TRACE(ft_t_err, "no drive polling interrupt!");
-        } else {        /* clear all disk-changed statuses */
-                for (i = 0; i < 4; ++i) {
-                        if(fdc_sense_interrupt_status(&st0, &dummy) != 0) {
-                                TRACE(ft_t_err, "sense failed for %d", i);
-                        }
-                        if (i == ft_drive_sel) {
-                                ftape_current_cylinder = dummy;
-                        }
-                }
-                TRACE(ft_t_noise, "drive polling completed");
-        }
-        /*
-         *      SPECIFY COMMAND
-         */
-        fdc_set_seek_rate(fdc_seek_rate);
-        /*
-         *      DRIVE SPECIFICATION COMMAND (if fdc type known)
-         */
-        if (fdc.type >= i82078_1) {
-                fdc_set_drive_specs();
-        }
-        TRACE_EXIT;
-}
-
-#if !defined(CLK_48MHZ)
-# define CLK_48MHZ 1
-#endif
-
-/*  When we're done, put the fdc into reset mode so that the regular
- *  floppy disk driver will figure out that something is wrong and
- *  initialize the controller the way it wants.
- */
-void fdc_disable(void)
-{
-        __u8 cmd1[] = {FDC_CONFIGURE, 0x00, 0x00, 0x00};
-        __u8 cmd2[] = {FDC_LOCK};
-        __u8 cmd3[] = {FDC_UNLOCK};
-        __u8 stat[1];
-        TRACE_FUN(ft_t_flow);
-
-        if (!fdc_fifo_locked) {
-                fdc_reset();
-                TRACE_EXIT;
-        }
-        if (fdc_issue_command(cmd3, 1, stat, 1) < 0 || stat[0] != 0x00) {
-                fdc_dor_reset(0);
-                TRACE_ABORT(/**/, ft_t_bug, 
-                "couldn't unlock fifo, configuration remains changed");
-        }
-        fdc_fifo_locked = 0;
-        if (CLK_48MHZ && fdc.type >= i82078) {
-                cmd1[0] |= FDC_CLK48_BIT;
-        }
-        cmd1[2] = ((fdc_fifo_state) ? 0 : 0x20) + (fdc_fifo_thr - 1);
-        if (fdc_command(cmd1, NR_ITEMS(cmd1)) < 0) {
-                fdc_dor_reset(0);
-                TRACE_ABORT(/**/, ft_t_bug,
-                "couldn't reconfigure fifo to old state");
-        }
-        if (fdc_lock_state &&
-            fdc_issue_command(cmd2, 1, stat, 1) < 0) {
-                fdc_dor_reset(0);
-                TRACE_ABORT(/**/, ft_t_bug, "couldn't lock old state again");
-        }
-        TRACE(ft_t_noise, "fifo restored: %sabled, thr. %d, %slocked",
-              fdc_fifo_state ? "en" : "dis",
-              fdc_fifo_thr, (fdc_lock_state) ? "" : "not ");
-        fdc_dor_reset(0);
-        TRACE_EXIT;
-}
-
-/*      Specify FDC seek-rate (milliseconds)
- */
-static int fdc_set_seek_rate(int seek_rate)
-{
-        /* set step rate, dma mode, and minimal head load and unload times
-         */
-        __u8 in[3] = { FDC_SPECIFY, 1, (1 << 1)};
- 
-        fdc_seek_rate = seek_rate;
-        in[1] |= (16 - (fdc_data_rate * fdc_seek_rate) / 500) << 4;
-
-        return fdc_command(in, 3);
-}
-
-/*      Sense drive status: get unit's drive status (ST3)
- */
-int fdc_sense_drive_status(int *st3)
-{
-        __u8 out[2];
-        __u8 in[1];
-        TRACE_FUN(ft_t_any);
-
-        out[0] = FDC_SENSED;
-        out[1] = ft_drive_sel;
-        TRACE_CATCH(fdc_issue_command(out, 2, in, 1),);
-        *st3 = in[0];
-        TRACE_EXIT 0;
-}
-
-/*      Sense Interrupt Status command:
- *      should be issued at the end of each seek.
- *      get ST0 and current cylinder.
- */
-int fdc_sense_interrupt_status(int *st0, int *current_cylinder)
-{
-        __u8 out[1];
-        __u8 in[2];
-        TRACE_FUN(ft_t_any);
-
-        out[0] = FDC_SENSEI;
-        TRACE_CATCH(fdc_issue_command(out, 1, in, 2),);
-        *st0 = in[0];
-        *current_cylinder = in[1];
-        TRACE_EXIT 0;
-}
-
-/*      step to track
- */
-int fdc_seek(int track)
-{
-        __u8 out[3];
-        int st0, pcn;
-#ifdef TESTING
-        unsigned int time;
-#endif
-        TRACE_FUN(ft_t_any);
-
-        out[0] = FDC_SEEK;
-        out[1] = ft_drive_sel;
-        out[2] = track;
-#ifdef TESTING
-        time = ftape_timestamp();
-#endif
-        /*  We really need this command to work !
-         */
-        ft_seek_completed = 0;
-        TRACE_CATCH(fdc_command(out, 3),
-                    fdc_reset();
-                    TRACE(ft_t_noise, "destination was: %d, resetting FDC...",
-                          track));
-        /*    Handle interrupts until ft_seek_completed or timeout.
-         */
-        for (;;) {
-                TRACE_CATCH(fdc_interrupt_wait(2 * FT_SECOND),);
-                if (ft_seek_completed) {
-                        TRACE_CATCH(fdc_sense_interrupt_status(&st0, &pcn),);
-                        if ((st0 & ST0_SEEK_END) == 0) {
-                                TRACE_ABORT(-EIO, ft_t_err,
-                                      "no seek-end after seek completion !??");
-                        }
-                        break;
-                }
-        }
-#ifdef TESTING
-        time = ftape_timediff(time, ftape_timestamp()) / abs(track - ftape_current_cylinder);
-        if ((time < 900 || time > 3100) && abs(track - ftape_current_cylinder) > 5) {
-                TRACE(ft_t_warn, "Wrong FDC STEP interval: %d usecs (%d)",
-                         time, track - ftape_current_cylinder);
-        }
-#endif
-        /*    Verify whether we issued the right tape command.
-         */
-        /* Verify that we seek to the proper track. */
-        if (pcn != track) {
-                TRACE_ABORT(-EIO, ft_t_err, "bad seek..");
-        }
-        ftape_current_cylinder = track;
-        TRACE_EXIT 0;
-}
-
-static int perpend_mode; /* set if fdc is in perpendicular mode */
-
-static int perpend_off(void)
-{
-        __u8 perpend[] = {FDC_PERPEND, 0x00};
-        TRACE_FUN(ft_t_any);
-        
-        if (perpend_mode) {
-                /* Turn off perpendicular mode */
-                perpend[1] = 0x80;
-                TRACE_CATCH(fdc_command(perpend, 2),
-                            TRACE(ft_t_err,"Perpendicular mode exit failed!"));
-                perpend_mode = 0;
-        }
-        TRACE_EXIT 0;
-}
-
-static int handle_perpend(int segment_id)
-{
-        __u8 perpend[] = {FDC_PERPEND, 0x00};
-        TRACE_FUN(ft_t_any);
-
-        /* When writing QIC-3020 tapes, turn on perpendicular mode
-         * if tape is moving in forward direction (even tracks).
-         */
-        if (ft_qic_std == QIC_TAPE_QIC3020 &&
-            ((segment_id / ft_segments_per_track) & 1) == 0) {
-/*  FIXME: some i82077 seem to support perpendicular mode as
- *  well. 
- */
-#if 0
-                if (fdc.type < i82077AA) {}
-#else
-                if (fdc.type < i82077 && ft_data_rate < 1000) {
-#endif
-                        /*  fdc does not support perpendicular mode: complain 
-                         */
-                        TRACE_ABORT(-EIO, ft_t_err,
-                                    "Your FDC does not support QIC-3020.");
-                }
-                perpend[1] = 0x03 /* 0x83 + (0x4 << ft_drive_sel) */ ;
-                TRACE_CATCH(fdc_command(perpend, 2),
-                           TRACE(ft_t_err,"Perpendicular mode entry failed!"));
-                TRACE(ft_t_flow, "Perpendicular mode set");
-                perpend_mode = 1;
-                TRACE_EXIT 0;
-        }
-        TRACE_EXIT perpend_off();
-}
-
-static inline void fdc_setup_dma(char mode,
-                                 volatile void *addr, unsigned int count)
-{
-        /* Program the DMA controller.
-         */
-        disable_dma(fdc.dma);
-        clear_dma_ff(fdc.dma);
-        set_dma_mode(fdc.dma, mode);
-        set_dma_addr(fdc.dma, virt_to_bus((void*)addr));
-        set_dma_count(fdc.dma, count);
-        enable_dma(fdc.dma);
-}
-
-/*  Setup fdc and dma for formatting the next segment
- */
-int fdc_setup_formatting(buffer_struct * buff)
-{
-        unsigned long flags;
-        __u8 out[6] = {
-                FDC_FORMAT, 0x00, 3, 4 * FT_SECTORS_PER_SEGMENT, 0x00, 0x6b
-        };
-        TRACE_FUN(ft_t_any);
-        
-        TRACE_CATCH(handle_perpend(buff->segment_id),);
-        /* Program the DMA controller.
-         */
-        TRACE(ft_t_fdc_dma,
-              "phys. addr. = %lx", virt_to_bus((void*) buff->ptr));
-        spin_lock_irqsave(&fdc_io_lock, flags);
-        fdc_setup_dma(DMA_MODE_WRITE, buff->ptr, FT_SECTORS_PER_SEGMENT * 4);
-        /* Issue FDC command to start reading/writing.
-         */
-        out[1] = ft_drive_sel;
-        out[4] = buff->gap3;
-        TRACE_CATCH(fdc_setup_error = fdc_command(out, sizeof(out)),
-                    restore_flags(flags); fdc_mode = fdc_idle);
-        spin_unlock_irqrestore(&fdc_io_lock, flags);
-        TRACE_EXIT 0;
-}
-
-
-/*      Setup Floppy Disk Controller and DMA to read or write the next cluster
- *      of good sectors from or to the current segment.
- */
-int fdc_setup_read_write(buffer_struct * buff, __u8 operation)
-{
-        unsigned long flags;
-        __u8 out[9];
-        int dma_mode;
-        TRACE_FUN(ft_t_any);
-
-        switch(operation) {
-        case FDC_VERIFY:
-                if (fdc.type < i82077) {
-                        operation = FDC_READ;
-                }
-        case FDC_READ:
-        case FDC_READ_DELETED:
-                dma_mode = DMA_MODE_READ;
-                TRACE(ft_t_fdc_dma, "xfer %d sectors to 0x%p",
-                      buff->sector_count, buff->ptr);
-                TRACE_CATCH(perpend_off(),);
-                break;
-        case FDC_WRITE_DELETED:
-                TRACE(ft_t_noise, "deleting segment %d", buff->segment_id);
-        case FDC_WRITE:
-                dma_mode = DMA_MODE_WRITE;
-                /* When writing QIC-3020 tapes, turn on perpendicular mode
-                 * if tape is moving in forward direction (even tracks).
-                 */
-                TRACE_CATCH(handle_perpend(buff->segment_id),);
-                TRACE(ft_t_fdc_dma, "xfer %d sectors from 0x%p",
-                      buff->sector_count, buff->ptr);
-                break;
-        default:
-                TRACE_ABORT(-EIO,
-                            ft_t_bug, "bug: invalid operation parameter");
-        }
-        TRACE(ft_t_fdc_dma, "phys. addr. = %lx",virt_to_bus((void*)buff->ptr));
-        spin_lock_irqsave(&fdc_io_lock, flags);
-        if (operation != FDC_VERIFY) {
-                fdc_setup_dma(dma_mode, buff->ptr,
-                              FT_SECTOR_SIZE * buff->sector_count);
-        }
-        /* Issue FDC command to start reading/writing.
-         */
-        out[0] = operation;
-        out[1] = ft_drive_sel;
-        out[2] = buff->cyl;
-        out[3] = buff->head;
-        out[4] = buff->sect + buff->sector_offset;
-        out[5] = 3;             /* Sector size of 1K. */
-        out[6] = out[4] + buff->sector_count - 1;       /* last sector */
-        out[7] = 109;           /* Gap length. */
-        out[8] = 0xff;          /* No limit to transfer size. */
-        TRACE(ft_t_fdc_dma, "C: 0x%02x, H: 0x%02x, R: 0x%02x, cnt: 0x%02x",
-                out[2], out[3], out[4], out[6] - out[4] + 1);
-        spin_unlock_irqrestore(&fdc_io_lock, flags);
-        TRACE_CATCH(fdc_setup_error = fdc_command(out, 9),fdc_mode = fdc_idle);
-        TRACE_EXIT 0;
-}
-
-int fdc_fifo_threshold(__u8 threshold,
-                       int *fifo_state, int *lock_state, int *fifo_thr)
-{
-        const __u8 cmd0[] = {FDC_DUMPREGS};
-        __u8 cmd1[] = {FDC_CONFIGURE, 0, (0x0f & (threshold - 1)), 0};
-        const __u8 cmd2[] = {FDC_LOCK};
-        const __u8 cmd3[] = {FDC_UNLOCK};
-        __u8 reg[10];
-        __u8 stat;
-        int i;
-        int result;
-        TRACE_FUN(ft_t_any);
-
-        if (CLK_48MHZ && fdc.type >= i82078) {
-                cmd1[0] |= FDC_CLK48_BIT;
-        }
-        /*  Dump fdc internal registers for examination
-         */
-        TRACE_CATCH(fdc_command(cmd0, NR_ITEMS(cmd0)),
-                    TRACE(ft_t_warn, "dumpreg cmd failed, fifo unchanged"));
-        /*  Now read fdc internal registers from fifo
-         */
-        for (i = 0; i < (int)NR_ITEMS(reg); ++i) {
-                fdc_read(&reg[i]);
-                TRACE(ft_t_fdc_dma, "Register %d = 0x%02x", i, reg[i]);
-        }
-        if (fifo_state && lock_state && fifo_thr) {
-                *fifo_state = (reg[8] & 0x20) == 0;
-                *lock_state = reg[7] & 0x80;
-                *fifo_thr = 1 + (reg[8] & 0x0f);
-        }
-        TRACE(ft_t_noise,
-              "original fifo state: %sabled, threshold %d, %slocked",
-              ((reg[8] & 0x20) == 0) ? "en" : "dis",
-              1 + (reg[8] & 0x0f), (reg[7] & 0x80) ? "" : "not ");
-        /*  If fdc is already locked, unlock it first ! */
-        if (reg[7] & 0x80) {
-                fdc_ready_wait(100);
-                TRACE_CATCH(fdc_issue_command(cmd3, NR_ITEMS(cmd3), &stat, 1),
-                            TRACE(ft_t_bug, "FDC unlock command failed, "
-                                  "configuration unchanged"));
-        }
-        fdc_fifo_locked = 0;
-        /*  Enable fifo and set threshold at xx bytes to allow a
-         *  reasonably large latency and reduce number of dma bursts.
-         */
-        fdc_ready_wait(100);
-        if ((result = fdc_command(cmd1, NR_ITEMS(cmd1))) < 0) {
-                TRACE(ft_t_bug, "configure cmd failed, fifo unchanged");
-        }
-        /*  Now lock configuration so reset will not change it
-         */
-        if(fdc_issue_command(cmd2, NR_ITEMS(cmd2), &stat, 1) < 0 ||
-           stat != 0x10) {
-                TRACE_ABORT(-EIO, ft_t_bug,
-                            "FDC lock command failed, stat = 0x%02x", stat);
-        }
-        fdc_fifo_locked = 1;
-        TRACE_EXIT result;
-}
-
-static int fdc_fifo_enable(void)
-{
-        TRACE_FUN(ft_t_any);
-
-        if (fdc_fifo_locked) {
-                TRACE_ABORT(0, ft_t_warn, "Fifo not enabled because locked");
-        }
-        TRACE_CATCH(fdc_fifo_threshold(ft_fdc_threshold /* bytes */,
-                                       &fdc_fifo_state,
-                                       &fdc_lock_state,
-                                       &fdc_fifo_thr),);
-        TRACE_CATCH(fdc_fifo_threshold(ft_fdc_threshold /* bytes */,
-                                       NULL, NULL, NULL),);
-        TRACE_EXIT 0;
-}
-
-/*   Determine fd controller type 
- */
-static __u8 fdc_save_state[2];
-
-static int fdc_probe(void)
-{
-        __u8 cmd[1];
-        __u8 stat[16]; /* must be able to hold dumpregs & save results */
-        int i;
-        TRACE_FUN(ft_t_any);
-
-        /*  Try to find out what kind of fd controller we have to deal with
-         *  Scheme borrowed from floppy driver:
-         *  first try if FDC_DUMPREGS command works
-         *  (this indicates that we have a 82072 or better)
-         *  then try the FDC_VERSION command (82072 doesn't support this)
-         *  then try the FDC_UNLOCK command (some older 82077's don't support this)
-         *  then try the FDC_PARTID command (82078's support this)
-         */
-        cmd[0] = FDC_DUMPREGS;
-        if (fdc_issue_command(cmd, 1, stat, 1) != 0) {
-                TRACE_ABORT(no_fdc, ft_t_bug, "No FDC found");
-        }
-        if (stat[0] == 0x80) {
-                /* invalid command: must be pre 82072 */
-                TRACE_ABORT(i8272,
-                            ft_t_warn, "Type 8272A/765A compatible FDC found");
-        }
-        fdc_result(&stat[1], 9);
-        fdc_save_state[0] = stat[7];
-        fdc_save_state[1] = stat[8];
-        cmd[0] = FDC_VERSION;
-        if (fdc_issue_command(cmd, 1, stat, 1) < 0 || stat[0] == 0x80) {
-                TRACE_ABORT(i8272, ft_t_warn, "Type 82072 FDC found");
-        }
-        if (*stat != 0x90) {
-                TRACE_ABORT(i8272, ft_t_warn, "Unknown FDC found");
-        }
-        cmd[0] = FDC_UNLOCK;
-        if(fdc_issue_command(cmd, 1, stat, 1) < 0 || stat[0] != 0x00) {
-                TRACE_ABORT(i8272, ft_t_warn,
-                            "Type pre-1991 82077 FDC found, "
-                            "treating it like a 82072");
-        }
-        if (fdc_save_state[0] & 0x80) { /* was locked */
-                cmd[0] = FDC_LOCK; /* restore lock */
-                (void)fdc_issue_command(cmd, 1, stat, 1);
-                TRACE(ft_t_warn, "FDC is already locked");
-        }
-        /* Test for a i82078 FDC */
-        cmd[0] = FDC_PARTID;
-        if (fdc_issue_command(cmd, 1, stat, 1) < 0 || stat[0] == 0x80) {
-                /* invalid command: not a i82078xx type FDC */
-                for (i = 0; i < 4; ++i) {
-                        outb_p(i, fdc.tdr);
-                        if ((inb_p(fdc.tdr) & 0x03) != i) {
-                                TRACE_ABORT(i82077,
-                                            ft_t_warn, "Type 82077 FDC found");
-                        }
-                }
-                TRACE_ABORT(i82077AA, ft_t_warn, "Type 82077AA FDC found");
-        }
-        /* FDC_PARTID cmd succeeded */
-        switch (stat[0] >> 5) {
-        case 0x0:
-                /* i82078SL or i82078-1.  The SL part cannot run at
-                 * 2Mbps (the SL and -1 dies are identical; they are
-                 * speed graded after production, according to Intel).
-                 * Some SL's can be detected by doing a SAVE cmd and
-                 * look at bit 7 of the first byte (the SEL3V# bit).
-                 * If it is 0, the part runs off 3Volts, and hence it
-                 * is a SL.
-                 */
-                cmd[0] = FDC_SAVE;
-                if(fdc_issue_command(cmd, 1, stat, 16) < 0) {
-                        TRACE(ft_t_err, "FDC_SAVE failed. Dunno why");
-                        /* guess we better claim the fdc to be a i82078 */
-                        TRACE_ABORT(i82078,
-                                    ft_t_warn,
-                                    "Type i82078 FDC (i suppose) found");
-                }
-                if ((stat[0] & FDC_SEL3V_BIT)) {
-                        /* fdc running off 5Volts; Pray that it's a i82078-1
-                         */
-                        TRACE_ABORT(i82078_1, ft_t_warn,
-                                  "Type i82078-1 or 5Volt i82078SL FDC found");
-                }
-                TRACE_ABORT(i82078, ft_t_warn,
-                            "Type 3Volt i82078SL FDC (1Mbps) found");
-        case 0x1:
-        case 0x2: /* S82078B  */
-                /* The '78B  isn't '78 compatible.  Detect it as a '77AA */
-                TRACE_ABORT(i82077AA, ft_t_warn, "Type i82077AA FDC found");
-        case 0x3: /* NSC PC8744 core; used in several super-IO chips */
-                TRACE_ABORT(i82077AA,
-                            ft_t_warn, "Type 82077AA compatible FDC found");
-        default:
-                TRACE(ft_t_warn, "A previously undetected FDC found");
-                TRACE_ABORT(i82077AA, ft_t_warn,
-                          "Treating it as a 82077AA. Please report partid= %d",
-                            stat[0]);
-        } /* switch(stat[ 0] >> 5) */
-        TRACE_EXIT no_fdc;
-}
-
-static int fdc_request_regions(void)
-{
-        TRACE_FUN(ft_t_flow);
-
-        if (ft_mach2 || ft_probe_fc10) {
-                if (!request_region(fdc.sra, 8, "fdc (ft)")) {
-#ifndef BROKEN_FLOPPY_DRIVER
-                        TRACE_EXIT -EBUSY;
-#else
-                        TRACE(ft_t_warn,
-"address 0x%03x occupied (by floppy driver?), using it anyway", fdc.sra);
-#endif
-                }
-        } else {
-                if (!request_region(fdc.sra, 6, "fdc (ft)")) {
-#ifndef BROKEN_FLOPPY_DRIVER
-                        TRACE_EXIT -EBUSY;
-#else
-                        TRACE(ft_t_warn,
-"address 0x%03x occupied (by floppy driver?), using it anyway", fdc.sra);
-#endif
-                }
-                if (!request_region(fdc.sra + 7, 1, "fdc (ft)")) {
-#ifndef BROKEN_FLOPPY_DRIVER
-                        release_region(fdc.sra, 6);
-                        TRACE_EXIT -EBUSY;
-#else
-                        TRACE(ft_t_warn,
-"address 0x%03x occupied (by floppy driver?), using it anyway", fdc.sra + 7);
-#endif
-                }
-        }
-        TRACE_EXIT 0;
-}
-
-void fdc_release_regions(void)
-{
-        TRACE_FUN(ft_t_flow);
-
-        if (fdc.sra != 0) {
-                if (fdc.dor2 != 0) {
-                        release_region(fdc.sra, 8);
-                } else {
-                        release_region(fdc.sra, 6);
-                        release_region(fdc.dir, 1);
-                }
-        }
-        TRACE_EXIT;
-}
-
-static int fdc_config_regs(unsigned int fdc_base, 
-                           unsigned int fdc_irq, 
-                           unsigned int fdc_dma)
-{
-        TRACE_FUN(ft_t_flow);
-
-        fdc.irq = fdc_irq;
-        fdc.dma = fdc_dma;
-        fdc.sra = fdc_base;
-        fdc.srb = fdc_base + 1;
-        fdc.dor = fdc_base + 2;
-        fdc.tdr = fdc_base + 3;
-        fdc.msr = fdc.dsr = fdc_base + 4;
-        fdc.fifo = fdc_base + 5;
-        fdc.dir = fdc.ccr = fdc_base + 7;
-        fdc.dor2 = (ft_mach2 || ft_probe_fc10) ? fdc_base + 6 : 0;
-        TRACE_CATCH(fdc_request_regions(), fdc.sra = 0);
-        TRACE_EXIT 0;
-}
-
-static int fdc_config(void)
-{
-        static int already_done;
-        TRACE_FUN(ft_t_any);
-
-        if (already_done) {
-                TRACE_CATCH(fdc_request_regions(),);
-                *(fdc.hook) = fdc_isr;  /* hook our handler in */
-                TRACE_EXIT 0;
-        }
-        if (ft_probe_fc10) {
-                int fc_type;
-                
-                TRACE_CATCH(fdc_config_regs(ft_fdc_base,
-                                            ft_fdc_irq, ft_fdc_dma),);
-                fc_type = fc10_enable();
-                if (fc_type != 0) {
-                        TRACE(ft_t_warn, "FC-%c0 controller found", '0' + fc_type);
-                        fdc.type = fc10;
-                        fdc.hook = &do_ftape;
-                        *(fdc.hook) = fdc_isr;  /* hook our handler in */
-                        already_done = 1;
-                        TRACE_EXIT 0;
-                } else {
-                        TRACE(ft_t_warn, "FC-10/20 controller not found");
-                        fdc_release_regions();
-                        fdc.type = no_fdc;
-                        ft_probe_fc10 = 0;
-                        ft_fdc_base   = 0x3f0;
-                        ft_fdc_irq    = 6;
-                        ft_fdc_dma    = 2;
-                }
-        }
-        TRACE(ft_t_warn, "fdc base: 0x%x, irq: %d, dma: %d", 
-              ft_fdc_base, ft_fdc_irq, ft_fdc_dma);
-        TRACE_CATCH(fdc_config_regs(ft_fdc_base, ft_fdc_irq, ft_fdc_dma),);
-        fdc.hook = &do_ftape;
-        *(fdc.hook) = fdc_isr;  /* hook our handler in */
-        already_done = 1;
-        TRACE_EXIT 0;
-}
-
-static irqreturn_t ftape_interrupt(int irq, void *dev_id, struct pt_regs *regs)
-{
-        void (*handler) (void) = *fdc.hook;
-        int handled = 0;
-        TRACE_FUN(ft_t_any);
-
-        *fdc.hook = NULL;
-        if (handler) {
-                handled = 1;
-                handler();
-        } else {
-                TRACE(ft_t_bug, "Unexpected ftape interrupt");
-        }
-        TRACE_EXIT IRQ_RETVAL(handled);
-}
-
-static int fdc_grab_irq_and_dma(void)
-{
-        TRACE_FUN(ft_t_any);
-
-        if (fdc.hook == &do_ftape) {
-                /*  Get fast interrupt handler.
-                 */
-                if (request_irq(fdc.irq, ftape_interrupt,
-                                IRQF_DISABLED, "ft", ftape_id)) {
-                        TRACE_ABORT(-EIO, ft_t_bug,
-                                    "Unable to grab IRQ%d for ftape driver",
-                                    fdc.irq);
-                }
-                if (request_dma(fdc.dma, ftape_id)) {
-                        free_irq(fdc.irq, ftape_id);
-                        TRACE_ABORT(-EIO, ft_t_bug,
-                              "Unable to grab DMA%d for ftape driver",
-                              fdc.dma);
-                }
-        }
-        if (ft_fdc_base != 0x3f0 && (ft_fdc_dma == 2 || ft_fdc_irq == 6)) {
-                /* Using same dma channel or irq as standard fdc, need
-                 * to disable the dma-gate on the std fdc. This
-                 * couldn't be done in the floppy driver as some
-                 * laptops are using the dma-gate to enter a low power
-                 * or even suspended state :-(
-                 */
-                outb_p(FDC_RESET_NOT, 0x3f2);
-                TRACE(ft_t_noise, "DMA-gate on standard fdc disabled");
-        }
-        TRACE_EXIT 0;
-}
-
-int fdc_release_irq_and_dma(void)
-{
-        TRACE_FUN(ft_t_any);
-
-        if (fdc.hook == &do_ftape) {
-                disable_dma(fdc.dma);   /* just in case... */
-                free_dma(fdc.dma);
-                free_irq(fdc.irq, ftape_id);
-        }
-        if (ft_fdc_base != 0x3f0 && (ft_fdc_dma == 2 || ft_fdc_irq == 6)) {
-                /* Using same dma channel as standard fdc, need to
-                 * disable the dma-gate on the std fdc. This couldn't
-                 * be done in the floppy driver as some laptops are
-                 * using the dma-gate to enter a low power or even
-                 * suspended state :-(
-                 */
-                outb_p(FDC_RESET_NOT | FDC_DMA_MODE, 0x3f2);
-                TRACE(ft_t_noise, "DMA-gate on standard fdc enabled again");
-        }
-        TRACE_EXIT 0;
-}
-
-int fdc_init(void)
-{
-        TRACE_FUN(ft_t_any);
-
-        /* find a FDC to use */
-        TRACE_CATCH(fdc_config(),);
-        TRACE_CATCH(fdc_grab_irq_and_dma(), fdc_release_regions());
-        ftape_motor = 0;
-        fdc_catch_stray_interrupts(0);  /* clear number of awainted
-                                         * stray interrupte 
-                                         */
-        fdc_catch_stray_interrupts(1);  /* one always comes (?) */
-        TRACE(ft_t_flow, "resetting fdc");
-        fdc_set_seek_rate(2);           /* use nominal QIC step rate */
-        fdc_reset();                    /* init fdc & clear track counters */
-        if (fdc.type == no_fdc) {       /* no FC-10 or FC-20 found */
-                fdc.type = fdc_probe();
-                fdc_reset();            /* update with new knowledge */
-        }
-        if (fdc.type == no_fdc) {
-                fdc_release_irq_and_dma();
-                fdc_release_regions();
-                TRACE_EXIT -ENXIO;
-        }
-        if (fdc.type >= i82077) {
-                if (fdc_fifo_enable() < 0) {
-                        TRACE(ft_t_warn, "couldn't enable fdc fifo !");
-                } else {
-                        TRACE(ft_t_flow, "fdc fifo enabled and locked");
-                }
-        }
-        TRACE_EXIT 0;
-}
diff --git a/drivers/char/ftape/lowlevel/fdc-io.h b/drivers/char/ftape/lowlevel/fdc-io.h
deleted file mode 100644
index 7ec3c72178bb..000000000000
--- a/drivers/char/ftape/lowlevel/fdc-io.h
+++ /dev/null
@@ -1,252 +0,0 @@
-#ifndef _FDC_IO_H
-#define _FDC_IO_H
-
-/*
- *    Copyright (C) 1993-1996 Bas Laarhoven,
- *              (C) 1996-1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/fdc-io.h,v $
- * $Revision: 1.3 $
- * $Date: 1997/10/05 19:18:06 $
- *
- *      This file contains the declarations for the low level
- *      functions that communicate with the floppy disk controller,
- *      for the QIC-40/80/3010/3020 floppy-tape driver "ftape" for
- *      Linux.
- */
-
-#include <linux/fdreg.h>
-
-#include "../lowlevel/ftape-bsm.h"
-
-#define FDC_SK_BIT      (0x20)
-#define FDC_MT_BIT      (0x80)
-
-#define FDC_READ        (FD_READ & ~(FDC_SK_BIT | FDC_MT_BIT))
-#define FDC_WRITE       (FD_WRITE & ~FDC_MT_BIT)
-#define FDC_READ_DELETED  (0x4c)
-#define FDC_WRITE_DELETED (0x49)
-#define FDC_VERIFY        (0x56)
-#define FDC_READID      (0x4a)
-#define FDC_SENSED      (0x04)
-#define FDC_SENSEI      (FD_SENSEI)
-#define FDC_FORMAT      (FD_FORMAT)
-#define FDC_RECAL       (FD_RECALIBRATE)
-#define FDC_SEEK        (FD_SEEK)
-#define FDC_SPECIFY     (FD_SPECIFY)
-#define FDC_RECALIBR    (FD_RECALIBRATE)
-#define FDC_VERSION     (FD_VERSION)
-#define FDC_PERPEND     (FD_PERPENDICULAR)
-#define FDC_DUMPREGS    (FD_DUMPREGS)
-#define FDC_LOCK        (FD_LOCK)
-#define FDC_UNLOCK      (FD_UNLOCK)
-#define FDC_CONFIGURE   (FD_CONFIGURE)
-#define FDC_DRIVE_SPEC  (0x8e)  /* i82078 has this (any others?) */
-#define FDC_PARTID      (0x18)  /* i82078 has this */
-#define FDC_SAVE        (0x2e)  /* i82078 has this (any others?) */
-#define FDC_RESTORE     (0x4e)  /* i82078 has this (any others?) */
-
-#define FDC_STATUS_MASK (STATUS_BUSY | STATUS_DMA | STATUS_DIR | STATUS_READY)
-#define FDC_DATA_READY  (STATUS_READY)
-#define FDC_DATA_OUTPUT (STATUS_DIR)
-#define FDC_DATA_READY_MASK (STATUS_READY | STATUS_DIR)
-#define FDC_DATA_OUT_READY  (STATUS_READY | STATUS_DIR)
-#define FDC_DATA_IN_READY   (STATUS_READY)
-#define FDC_BUSY        (STATUS_BUSY)
-#define FDC_CLK48_BIT   (0x80)
-#define FDC_SEL3V_BIT   (0x40)
-
-#define ST0_INT_MASK    (ST0_INTR)
-#define FDC_INT_NORMAL  (ST0_INTR & 0x00)
-#define FDC_INT_ABNORMAL (ST0_INTR & 0x40)
-#define FDC_INT_INVALID (ST0_INTR & 0x80)
-#define FDC_INT_READYCH (ST0_INTR & 0xC0)
-#define ST0_SEEK_END    (ST0_SE)
-#define ST3_TRACK_0     (ST3_TZ)
-
-#define FDC_RESET_NOT   (0x04)
-#define FDC_DMA_MODE    (0x08)
-#define FDC_MOTOR_0     (0x10)
-#define FDC_MOTOR_1     (0x20)
-
-typedef struct {
-        void (**hook) (void);   /* our wedge into the isr */
-        enum {
-                no_fdc, i8272, i82077, i82077AA, fc10,
-                i82078, i82078_1
-        } type;                 /* FDC type */
-        unsigned int irq; /* FDC irq nr */
-        unsigned int dma; /* FDC dma channel nr */
-        __u16 sra;        /* Status register A (PS/2 only) */
-        __u16 srb;        /* Status register B (PS/2 only) */
-        __u16 dor;        /* Digital output register */
-        __u16 tdr;        /* Tape Drive Register (82077SL-1 &
-                             82078 only) */
-        __u16 msr;        /* Main Status Register */
-        __u16 dsr;        /* Datarate Select Register (8207x only) */
-        __u16 fifo;       /* Data register / Fifo on 8207x */
-        __u16 dir;        /* Digital Input Register */
-        __u16 ccr;        /* Configuration Control Register */
-        __u16 dor2;       /* Alternate dor on MACH-2 controller,
-                             also used with FC-10, meaning unknown */
-} fdc_config_info;
-
-typedef enum {
-        fdc_data_rate_250  = 2,
-        fdc_data_rate_300  = 1, /* any fdc in default configuration */
-        fdc_data_rate_500  = 0,
-        fdc_data_rate_1000 = 3,
-        fdc_data_rate_2000 = 1, /* i82078-1: when using Data Rate Table #2 */
-} fdc_data_rate_type;
-
-typedef enum {
-        fdc_idle          = 0,
-        fdc_reading_data  = FDC_READ,
-        fdc_seeking       = FDC_SEEK,
-        fdc_writing_data  = FDC_WRITE,
-        fdc_deleting      = FDC_WRITE_DELETED,
-        fdc_reading_id    = FDC_READID,
-        fdc_recalibrating = FDC_RECAL,
-        fdc_formatting    = FDC_FORMAT,
-        fdc_verifying     = FDC_VERIFY
-} fdc_mode_enum;
-
-typedef enum {
-        waiting = 0,
-        reading,
-        writing,
-        formatting,
-        verifying,
-        deleting,
-        done,
-        error,
-        mmapped,
-} buffer_state_enum;
-
-typedef struct {
-        __u8 *address;
-        volatile buffer_state_enum status;
-        volatile __u8 *ptr;
-        volatile unsigned int bytes;
-        volatile unsigned int segment_id;
-
-        /* bitmap for remainder of segment not yet handled.
-         * one bit set for each bad sector that must be skipped.
-         */
-        volatile SectorMap bad_sector_map;
-
-        /* bitmap with bad data blocks in data buffer.
-         * the errors in this map may be retried.
-         */
-        volatile SectorMap soft_error_map;
-
-        /* bitmap with bad data blocks in data buffer
-         * the errors in this map may not be retried.
-         */
-        volatile SectorMap hard_error_map;
-
-        /* retry counter for soft errors.
-         */
-        volatile int retry;
-
-        /* sectors to skip on retry ???
-         */
-        volatile unsigned int skip;
-
-        /* nr of data blocks in data buffer
-         */
-        volatile unsigned int data_offset;
-
-        /* offset in segment for first sector to be handled.
-         */
-        volatile unsigned int sector_offset;
-
-        /* size of cluster of good sectors to be handled.
-         */
-        volatile unsigned int sector_count;
-
-        /* size of remaining part of segment to be handled.
-         */
-        volatile unsigned int remaining;
-
-        /* points to next segment (contiguous) to be handled,
-         * or is zero if no read-ahead is allowed.
-         */
-        volatile unsigned int next_segment;
-
-        /* flag being set if deleted data was read.
-         */
-        volatile int deleted;
-
-        /* floppy coordinates of first sector in segment */
-        volatile __u8 head;
-        volatile __u8 cyl;
-        volatile __u8 sect;
-
-        /* gap to use when formatting */
-        __u8 gap3;
-        /* flag set when buffer is mmaped */
-        int mmapped;
-} buffer_struct;
-
-/*
- *      fdc-io.c defined public variables
- */
-extern volatile fdc_mode_enum fdc_mode;
-extern int fdc_setup_error;     /* outdated ??? */
-extern wait_queue_head_t ftape_wait_intr;
-extern volatile int ftape_current_cylinder; /* track nr FDC thinks we're on */
-extern volatile __u8 fdc_head;  /* FDC head */
-extern volatile __u8 fdc_cyl;   /* FDC track */
-extern volatile __u8 fdc_sect;  /* FDC sector */
-extern fdc_config_info fdc;     /* FDC hardware configuration */
-
-extern unsigned int ft_fdc_base;
-extern unsigned int ft_fdc_irq;
-extern unsigned int ft_fdc_dma;
-extern unsigned int ft_fdc_threshold;
-extern unsigned int ft_fdc_rate_limit;
-extern int ft_probe_fc10;
-extern int ft_mach2;
-/*
- *      fdc-io.c defined public functions
- */
-extern void fdc_catch_stray_interrupts(int count);
-extern int fdc_ready_wait(unsigned int timeout);
-extern int fdc_command(const __u8 * cmd_data, int cmd_len);
-extern int fdc_result(__u8 * res_data, int res_len);
-extern int fdc_interrupt_wait(unsigned int time);
-extern int fdc_seek(int track);
-extern int fdc_sense_drive_status(int *st3);
-extern void fdc_motor(int motor);
-extern void fdc_reset(void);
-extern void fdc_disable(void);
-extern int fdc_fifo_threshold(__u8 threshold,
-                              int *fifo_state, int *lock_state, int *fifo_thr);
-extern void fdc_wait_calibrate(void);
-extern int fdc_sense_interrupt_status(int *st0, int *current_cylinder);
-extern void fdc_save_drive_specs(void);
-extern void fdc_restore_drive_specs(void);
-extern int fdc_set_data_rate(int rate);
-extern void fdc_set_write_precomp(int precomp);
-extern int fdc_release_irq_and_dma(void);
-extern void fdc_release_regions(void);
-extern int fdc_init(void);
-extern int fdc_setup_read_write(buffer_struct * buff, __u8 operation);
-extern int fdc_setup_formatting(buffer_struct * buff);
-#endif
diff --git a/drivers/char/ftape/lowlevel/fdc-isr.c b/drivers/char/ftape/lowlevel/fdc-isr.c
deleted file mode 100644
index ad2bc733ae1b..000000000000
--- a/drivers/char/ftape/lowlevel/fdc-isr.c
+++ /dev/null
@@ -1,1170 +0,0 @@
-/*
- *      Copyright (C) 1994-1996 Bas Laarhoven,
- *                (C) 1996-1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/fdc-isr.c,v $
- * $Revision: 1.9 $
- * $Date: 1997/10/17 23:01:53 $
- *
- *      This file contains the interrupt service routine and
- *      associated code for the QIC-40/80/3010/3020 floppy-tape driver
- *      "ftape" for Linux.
- */
-
-#include <asm/io.h>
-#include <asm/dma.h>
-
-#define volatile                /* */
-
-#include <linux/ftape.h>
-#include <linux/qic117.h>
-#include "../lowlevel/ftape-tracing.h"
-#include "../lowlevel/fdc-isr.h"
-#include "../lowlevel/fdc-io.h"
-#include "../lowlevel/ftape-ctl.h"
-#include "../lowlevel/ftape-rw.h"
-#include "../lowlevel/ftape-io.h"
-#include "../lowlevel/ftape-calibr.h"
-#include "../lowlevel/ftape-bsm.h"
-
-/*      Global vars.
- */
-volatile int ft_expected_stray_interrupts;
-volatile int ft_interrupt_seen;
-volatile int ft_seek_completed;
-volatile int ft_hide_interrupt;
-/*      Local vars.
- */
-typedef enum {
-        no_error = 0, id_am_error = 0x01, id_crc_error = 0x02,
-        data_am_error = 0x04, data_crc_error = 0x08,
-        no_data_error = 0x10, overrun_error = 0x20,
-} error_cause;
-static int stop_read_ahead;
-
-
-static void print_error_cause(int cause)
-{
-        TRACE_FUN(ft_t_any);
-
-        switch (cause) {
-        case no_data_error:
-                TRACE(ft_t_noise, "no data error");
-                break;
-        case id_am_error:
-                TRACE(ft_t_noise, "id am error");
-                break;
-        case id_crc_error:
-                TRACE(ft_t_noise, "id crc error");
-                break;
-        case data_am_error:
-                TRACE(ft_t_noise, "data am error");
-                break;
-        case data_crc_error:
-                TRACE(ft_t_noise, "data crc error");
-                break;
-        case overrun_error:
-                TRACE(ft_t_noise, "overrun error");
-                break;
-        default:;
-        }
-        TRACE_EXIT;
-}
-
-static char *fdc_mode_txt(fdc_mode_enum mode)
-{
-        switch (mode) {
-        case fdc_idle:
-                return "fdc_idle";
-        case fdc_reading_data:
-                return "fdc_reading_data";
-        case fdc_seeking:
-                return "fdc_seeking";
-        case fdc_writing_data:
-                return "fdc_writing_data";
-        case fdc_reading_id:
-                return "fdc_reading_id";
-        case fdc_recalibrating:
-                return "fdc_recalibrating";
-        case fdc_formatting:
-                return "fdc_formatting";
-        case fdc_verifying:
-                return "fdc_verifying";
-        default:
-                return "unknown";
-        }
-}
-
-static inline error_cause decode_irq_cause(fdc_mode_enum mode, __u8 st[])
-{
-        error_cause cause = no_error;
-        TRACE_FUN(ft_t_any);
-
-        /*  Valid st[], decode cause of interrupt.
-         */
-        switch (st[0] & ST0_INT_MASK) {
-        case FDC_INT_NORMAL:
-                TRACE(ft_t_fdc_dma,"normal completion: %s",fdc_mode_txt(mode));
-                break;
-        case FDC_INT_ABNORMAL:
-                TRACE(ft_t_flow, "abnormal completion %s", fdc_mode_txt(mode));
-                TRACE(ft_t_fdc_dma, "ST0: 0x%02x, ST1: 0x%02x, ST2: 0x%02x",
-                      st[0], st[1], st[2]);
-                TRACE(ft_t_fdc_dma,
-                      "C: 0x%02x, H: 0x%02x, R: 0x%02x, N: 0x%02x",
-                      st[3], st[4], st[5], st[6]);
-                if (st[1] & 0x01) {
-                        if (st[2] & 0x01) {
-                                cause = data_am_error;
-                        } else {
-                                cause = id_am_error;
-                        }
-                } else if (st[1] & 0x20) {
-                        if (st[2] & 0x20) {
-                                cause = data_crc_error;
-                        } else {
-                                cause = id_crc_error;
-                        }
-                } else if (st[1] & 0x04) {
-                        cause = no_data_error;
-                } else if (st[1] & 0x10) {
-                        cause = overrun_error;
-                }
-                print_error_cause(cause);
-                break;
-        case FDC_INT_INVALID:
-                TRACE(ft_t_flow, "invalid completion %s", fdc_mode_txt(mode));
-                break;
-        case FDC_INT_READYCH:
-                if (st[0] & ST0_SEEK_END) {
-                        TRACE(ft_t_flow, "drive poll completed");
-                } else {
-                        TRACE(ft_t_flow, "ready change %s",fdc_mode_txt(mode));
-                }
-                break;
-        default:
-                break;
-        }
-        TRACE_EXIT cause;
-}
-
-static void update_history(error_cause cause)
-{
-        switch (cause) {
-        case id_am_error:
-                ft_history.id_am_errors++;
-                break;
-        case id_crc_error:
-                ft_history.id_crc_errors++;
-                break;
-        case data_am_error:
-                ft_history.data_am_errors++;
-                break;
-        case data_crc_error:
-                ft_history.data_crc_errors++;
-                break;
-        case overrun_error:
-                ft_history.overrun_errors++;
-                break;
-        case no_data_error:
-                ft_history.no_data_errors++;
-                break;
-        default:;
-        }
-}
-
-static void skip_bad_sector(buffer_struct * buff)
-{
-        TRACE_FUN(ft_t_any);
-
-        /*  Mark sector as soft error and skip it
-         */
-        if (buff->remaining > 0) {
-                ++buff->sector_offset;
-                ++buff->data_offset;
-                --buff->remaining;
-                buff->ptr += FT_SECTOR_SIZE;
-                buff->bad_sector_map >>= 1;
-        } else {
-                /*  Hey, what is this????????????? C code: if we shift 
-                 *  more than 31 bits, we get no shift. That's bad!!!!!!
-                 */
-                ++buff->sector_offset;  /* hack for error maps */
-                TRACE(ft_t_warn, "skipping last sector in segment");
-        }
-        TRACE_EXIT;
-}
-
-static void update_error_maps(buffer_struct * buff, unsigned int error_offset)
-{
-        int hard = 0;
-        TRACE_FUN(ft_t_any);
-
-        if (buff->retry < FT_SOFT_RETRIES) {
-                buff->soft_error_map |= (1 << error_offset);
-        } else {
-                buff->hard_error_map |= (1 << error_offset);
-                buff->soft_error_map &= ~buff->hard_error_map;
-                buff->retry = -1;  /* will be set to 0 in setup_segment */
-                hard = 1;
-        }
-        TRACE(ft_t_noise, "sector %d : %s error\n"
-              KERN_INFO "hard map: 0x%08lx\n"
-              KERN_INFO "soft map: 0x%08lx",
-              FT_SECTOR(error_offset), hard ? "hard" : "soft",
-              (long) buff->hard_error_map, (long) buff->soft_error_map);
-        TRACE_EXIT;
-}
-
-static void print_progress(buffer_struct *buff, error_cause cause)
-{
-        TRACE_FUN(ft_t_any);
-
-        switch (cause) {
-        case no_error: 
-                TRACE(ft_t_flow,"%d Sector(s) transferred", buff->sector_count);
-                break;
-        case no_data_error:
-                TRACE(ft_t_flow, "Sector %d not found",
-                      FT_SECTOR(buff->sector_offset));
-                break;
-        case overrun_error:
-                /*  got an overrun error on the first byte, must be a
-                 *  hardware problem
-                 */
-                TRACE(ft_t_bug,
-                      "Unexpected error: failing DMA or FDC controller ?");
-                break;
-        case data_crc_error:
-                TRACE(ft_t_flow, "Error in sector %d",
-                      FT_SECTOR(buff->sector_offset - 1));
-                break;
-        case id_crc_error:
-        case id_am_error:
-        case data_am_error:
-                TRACE(ft_t_flow, "Error in sector %d",
-                      FT_SECTOR(buff->sector_offset));
-                break;
-        default:
-                TRACE(ft_t_flow, "Unexpected error at sector %d",
-                      FT_SECTOR(buff->sector_offset));
-                break;
-        }
-        TRACE_EXIT;
-}
-
-/*
- *  Error cause:   Amount xferred:  Action:
- *
- *  id_am_error         0           mark bad and skip
- *  id_crc_error        0           mark bad and skip
- *  data_am_error       0           mark bad and skip
- *  data_crc_error    % 1024        mark bad and skip
- *  no_data_error       0           retry on write
- *                                  mark bad and skip on read
- *  overrun_error  [ 0..all-1 ]     mark bad and skip
- *  no_error           all          continue
- */
-
-/*  the arg `sector' is returned by the fdc and tells us at which sector we
- *  are positioned at (relative to starting sector of segment)
- */
-static void determine_verify_progress(buffer_struct *buff,
-                                      error_cause cause,
-                                      __u8 sector)
-{
-        TRACE_FUN(ft_t_any);
-
-        if (cause == no_error && sector == 1) {
-                buff->sector_offset = FT_SECTORS_PER_SEGMENT;
-                buff->remaining     = 0;
-                if (TRACE_LEVEL >= ft_t_flow) {
-                        print_progress(buff, cause);
-                }
-        } else {
-                buff->sector_offset = sector - buff->sect;
-                buff->remaining = FT_SECTORS_PER_SEGMENT - buff->sector_offset;
-                TRACE(ft_t_noise, "%ssector offset: 0x%04x", 
-                      (cause == no_error) ? "unexpected " : "",
-                      buff->sector_offset);
-                switch (cause) {
-                case overrun_error:
-                        break;
-#if 0
-                case no_data_error:
-                        buff->retry = FT_SOFT_RETRIES;
-                        if (buff->hard_error_map    &&
-                            buff->sector_offset > 1 &&
-                            (buff->hard_error_map & 
-                             (1 << (buff->sector_offset-2)))) {
-                                buff->retry --;
-                        }
-                        break;
-#endif
-                default:
-                        buff->retry = FT_SOFT_RETRIES;
-                        break;
-                }
-                if (TRACE_LEVEL >= ft_t_flow) {
-                        print_progress(buff, cause);
-                }
-                /*  Sector_offset points to the problem area Now adjust
-                 *  sector_offset so it always points one past he failing
-                 *  sector. I.e. skip the bad sector.
-                 */
-                ++buff->sector_offset;
-                --buff->remaining;
-                update_error_maps(buff, buff->sector_offset - 1);
-        }
-        TRACE_EXIT;
-}
-
-static void determine_progress(buffer_struct *buff,
-                               error_cause cause,
-                               __u8 sector)
-{
-        unsigned int dma_residue;
-        TRACE_FUN(ft_t_any);
-
-        /*  Using less preferred order of disable_dma and
-         *  get_dma_residue because this seems to fail on at least one
-         *  system if reversed!
-         */
-        dma_residue = get_dma_residue(fdc.dma);
-        disable_dma(fdc.dma);
-        if (cause != no_error || dma_residue != 0) {
-                TRACE(ft_t_noise, "%sDMA residue: 0x%04x", 
-                      (cause == no_error) ? "unexpected " : "",
-                      dma_residue);
-                /* adjust to actual value: */
-                if (dma_residue == 0) {
-                        /* this happens sometimes with overrun errors.
-                         * I don't know whether we could ignore the
-                         * overrun error. Play save.
-                         */
-                        buff->sector_count --;
-                } else {
-                        buff->sector_count -= ((dma_residue + 
-                                                (FT_SECTOR_SIZE - 1)) /
-                                               FT_SECTOR_SIZE);
-                }
-        }
-        /*  Update var's influenced by the DMA operation.
-         */
-        if (buff->sector_count > 0) {
-                buff->sector_offset   += buff->sector_count;
-                buff->data_offset     += buff->sector_count;
-                buff->ptr             += (buff->sector_count *
-                                          FT_SECTOR_SIZE);
-                buff->remaining       -= buff->sector_count;
-                buff->bad_sector_map >>= buff->sector_count;
-        }
-        if (TRACE_LEVEL >= ft_t_flow) {
-                print_progress(buff, cause);
-        }
-        if (cause != no_error) {
-                if (buff->remaining == 0) {
-                        TRACE(ft_t_warn, "foo?\n"
-                              KERN_INFO "count : %d\n"
-                              KERN_INFO "offset: %d\n"
-                              KERN_INFO "soft  : %08x\n"
-                              KERN_INFO "hard  : %08x",
-                              buff->sector_count,
-                              buff->sector_offset,
-                              buff->soft_error_map,
-                              buff->hard_error_map);
-                }
-                /*  Sector_offset points to the problem area, except if we got
-                 *  a data_crc_error. In that case it points one past the
-                 *  failing sector.
-                 *
-                 *  Now adjust sector_offset so it always points one past he
-                 *  failing sector. I.e. skip the bad sector.  
-                 */
-                if (cause != data_crc_error) {
-                        skip_bad_sector(buff);
-                }
-                update_error_maps(buff, buff->sector_offset - 1);
-        }
-        TRACE_EXIT;
-}
-
-static int calc_steps(int cmd)
-{
-        if (ftape_current_cylinder > cmd) {
-                return ftape_current_cylinder - cmd;
-        } else {
-                return ftape_current_cylinder + cmd;
-        }
-}
-
-static void pause_tape(int retry, int mode)
-{
-        int result;
-        __u8 out[3] = {FDC_SEEK, ft_drive_sel, 0};
-        TRACE_FUN(ft_t_any);
-
-        /*  We'll use a raw seek command to get the tape to rewind and
-         *  stop for a retry.
-         */
-        ++ft_history.rewinds;
-        if (qic117_cmds[ftape_current_command].non_intr) {
-                TRACE(ft_t_warn, "motion command may be issued too soon");
-        }
-        if (retry && (mode == fdc_reading_data ||
-                      mode == fdc_reading_id   ||
-                      mode == fdc_verifying)) {
-                ftape_current_command = QIC_MICRO_STEP_PAUSE;
-                ftape_might_be_off_track = 1;
-        } else {
-                ftape_current_command = QIC_PAUSE;
-        }
-        out[2] = calc_steps(ftape_current_command);
-        result = fdc_command(out, 3); /* issue QIC_117 command */
-        ftape_current_cylinder = out[ 2];
-        if (result < 0) {
-                TRACE(ft_t_noise, "qic-pause failed, status = %d", result);
-        } else {
-                ft_location.known  = 0;
-                ft_runner_status   = idle;
-                ft_hide_interrupt     = 1;
-                ftape_tape_running = 0;
-        }
-        TRACE_EXIT;
-}
-
-static void continue_xfer(buffer_struct *buff,
-                          fdc_mode_enum mode, 
-                          unsigned int skip)
-{
-        int write = 0;
-        TRACE_FUN(ft_t_any);
-
-        if (mode == fdc_writing_data || mode == fdc_deleting) {
-                write = 1;
-        }
-        /*  This part can be removed if it never happens
-         */
-        if (skip > 0 &&
-            (ft_runner_status != running ||
-             (write && (buff->status != writing)) ||
-             (!write && (buff->status != reading && 
-                         buff->status != verifying)))) {
-                TRACE(ft_t_err, "unexpected runner/buffer state %d/%d",
-                      ft_runner_status, buff->status);
-                buff->status = error;
-                /* finish this buffer: */
-                (void)ftape_next_buffer(ft_queue_head);
-                ft_runner_status = aborting;
-                fdc_mode         = fdc_idle;
-        } else if (buff->remaining > 0 && ftape_calc_next_cluster(buff) > 0) {
-                /*  still sectors left in current segment, continue
-                 *  with this segment
-                 */
-                if (fdc_setup_read_write(buff, mode) < 0) {
-                        /* failed, abort operation
-                         */
-                        buff->bytes = buff->ptr - buff->address;
-                        buff->status = error;
-                        /* finish this buffer: */
-                        (void)ftape_next_buffer(ft_queue_head);
-                        ft_runner_status = aborting;
-                        fdc_mode         = fdc_idle;
-                }
-        } else {
-                /* current segment completed
-                 */
-                unsigned int last_segment = buff->segment_id;
-                int eot = ((last_segment + 1) % ft_segments_per_track) == 0;
-                unsigned int next = buff->next_segment; /* 0 means stop ! */
-
-                buff->bytes = buff->ptr - buff->address;
-                buff->status = done;
-                buff = ftape_next_buffer(ft_queue_head);
-                if (eot) {
-                        /*  finished last segment on current track,
-                         *  can't continue
-                         */
-                        ft_runner_status = logical_eot;
-                        fdc_mode         = fdc_idle;
-                        TRACE_EXIT;
-                }
-                if (next <= 0) {
-                        /*  don't continue with next segment
-                         */
-                        TRACE(ft_t_noise, "no %s allowed, stopping tape",
-                              (write) ? "write next" : "read ahead");
-                        pause_tape(0, mode);
-                        ft_runner_status = idle;  /*  not quite true until
-                                                   *  next irq 
-                                                   */
-                        TRACE_EXIT;
-                }
-                /*  continue with next segment
-                 */
-                if (buff->status != waiting) {
-                        TRACE(ft_t_noise, "all input buffers %s, pausing tape",
-                              (write) ? "empty" : "full");
-                        pause_tape(0, mode);
-                        ft_runner_status = idle;  /*  not quite true until
-                                                   *  next irq 
-                                                   */
-                        TRACE_EXIT;
-                }
-                if (write && next != buff->segment_id) {
-                        TRACE(ft_t_noise, 
-                              "segments out of order, aborting write");
-                        ft_runner_status = do_abort;
-                        fdc_mode         = fdc_idle;
-                        TRACE_EXIT;
-                }
-                ftape_setup_new_segment(buff, next, 0);
-                if (stop_read_ahead) {
-                        buff->next_segment = 0;
-                        stop_read_ahead = 0;
-                }
-                if (ftape_calc_next_cluster(buff) == 0 ||
-                    fdc_setup_read_write(buff, mode) != 0) {
-                        TRACE(ft_t_err, "couldn't start %s-ahead",
-                              write ? "write" : "read");
-                        ft_runner_status = do_abort;
-                        fdc_mode         = fdc_idle;
-                } else {
-                        /* keep on going */
-                        switch (ft_driver_state) {
-                        case   reading: buff->status = reading;   break;
-                        case verifying: buff->status = verifying; break;
-                        case   writing: buff->status = writing;   break;
-                        case  deleting: buff->status = deleting;  break;
-                        default:
-                                TRACE(ft_t_err, 
-                      "BUG: ft_driver_state %d should be one out of "
-                      "{reading, writing, verifying, deleting}",
-                                      ft_driver_state);
-                                buff->status = write ? writing : reading;
-                                break;
-                        }
-                }
-        }
-        TRACE_EXIT;
-}
-
-static void retry_sector(buffer_struct *buff, 
-                         int mode,
-                         unsigned int skip)
-{
-        TRACE_FUN(ft_t_any);
-
-        TRACE(ft_t_noise, "%s error, will retry",
-              (mode == fdc_writing_data || mode == fdc_deleting) ? "write" : "read");
-        pause_tape(1, mode);
-        ft_runner_status = aborting;
-        buff->status     = error;
-        buff->skip       = skip;
-        TRACE_EXIT;
-}
-
-static unsigned int find_resume_point(buffer_struct *buff)
-{
-        int i = 0;
-        SectorMap mask;
-        SectorMap map;
-        TRACE_FUN(ft_t_any);
-
-        /*  This function is to be called after all variables have been
-         *  updated to point past the failing sector.
-         *  If there are any soft errors before the failing sector,
-         *  find the first soft error and return the sector offset.
-         *  Otherwise find the last hard error.
-         *  Note: there should always be at least one hard or soft error !
-         */
-        if (buff->sector_offset < 1 || buff->sector_offset > 32) {
-                TRACE(ft_t_bug, "BUG: sector_offset = %d",
-                      buff->sector_offset);
-                TRACE_EXIT 0;
-        }
-        if (buff->sector_offset >= 32) { /* C-limitation on shift ! */
-                mask = 0xffffffff;
-        } else {
-                mask = (1 << buff->sector_offset) - 1;
-        }
-        map = buff->soft_error_map & mask;
-        if (map) {
-                while ((map & (1 << i)) == 0) {
-                        ++i;
-                }
-                TRACE(ft_t_noise, "at sector %d", FT_SECTOR(i));
-        } else {
-                map = buff->hard_error_map & mask;
-                i = buff->sector_offset - 1;
-                if (map) {
-                        while ((map & (1 << i)) == 0) {
-                                --i;
-                        }
-                        TRACE(ft_t_noise, "after sector %d", FT_SECTOR(i));
-                        ++i; /* first sector after last hard error */
-                } else {
-                        TRACE(ft_t_bug, "BUG: no soft or hard errors");
-                }
-        }
-        TRACE_EXIT i;
-}
-
-/*  check possible dma residue when formatting, update position record in
- *  buffer struct. This is, of course, modelled after determine_progress(), but
- *  we don't need to set up for retries because the format process cannot be
- *  interrupted (except at the end of the tape track).
- */
-static int determine_fmt_progress(buffer_struct *buff, error_cause cause)
-{
-        unsigned int dma_residue;
-        TRACE_FUN(ft_t_any);
-
-        /*  Using less preferred order of disable_dma and
-         *  get_dma_residue because this seems to fail on at least one
-         *  system if reversed!
-         */
-        dma_residue = get_dma_residue(fdc.dma);
-        disable_dma(fdc.dma);
-        if (cause != no_error || dma_residue != 0) {
-                TRACE(ft_t_info, "DMA residue = 0x%04x", dma_residue);
-                fdc_mode = fdc_idle;
-                switch(cause) {
-                case no_error:
-                        ft_runner_status = aborting;
-                        buff->status = idle;
-                        break;
-                case overrun_error:
-                        /*  got an overrun error on the first byte, must be a
-                         *  hardware problem 
-                         */
-                        TRACE(ft_t_bug, 
-                              "Unexpected error: failing DMA controller ?");
-                        ft_runner_status = do_abort;
-                        buff->status = error;
-                        break;
-                default:
-                        TRACE(ft_t_noise, "Unexpected error at segment %d",
-                              buff->segment_id);
-                        ft_runner_status = do_abort;
-                        buff->status = error;
-                        break;
-                }
-                TRACE_EXIT -EIO; /* can only retry entire track in format mode
-                                  */
-        }
-        /*  Update var's influenced by the DMA operation.
-         */
-        buff->ptr             += FT_SECTORS_PER_SEGMENT * 4;
-        buff->bytes           -= FT_SECTORS_PER_SEGMENT * 4;
-        buff->remaining       -= FT_SECTORS_PER_SEGMENT;
-        buff->segment_id ++; /* done with segment */
-        TRACE_EXIT 0;
-}
-
-/*
- *  Continue formatting, switch buffers if there is no data left in
- *  current buffer. This is, of course, modelled after
- *  continue_xfer(), but we don't need to set up for retries because
- *  the format process cannot be interrupted (except at the end of the
- *  tape track).
- */
-static void continue_formatting(buffer_struct *buff)
-{
-        TRACE_FUN(ft_t_any);
-
-        if (buff->remaining <= 0) { /*  no space left in dma buffer */
-                unsigned int next = buff->next_segment; 
-
-                if (next == 0) { /* end of tape track */
-                        buff->status     = done;
-                        ft_runner_status = logical_eot;
-                        fdc_mode         = fdc_idle;
-                        TRACE(ft_t_noise, "Done formatting track %d",
-                              ft_location.track);
-                        TRACE_EXIT;
-                }
-                /*
-                 *  switch to next buffer!
-                 */
-                buff->status   = done;
-                buff = ftape_next_buffer(ft_queue_head);
-
-                if (buff->status != waiting  || next != buff->segment_id) {
-                        goto format_setup_error;
-                }
-        }
-        if (fdc_setup_formatting(buff) < 0) {
-                goto format_setup_error;
-        }
-        buff->status = formatting;
-        TRACE(ft_t_fdc_dma, "Formatting segment %d on track %d",
-              buff->segment_id, ft_location.track);
-        TRACE_EXIT;
- format_setup_error:
-        ft_runner_status = do_abort;
-        fdc_mode         = fdc_idle;
-        buff->status     = error;
-        TRACE(ft_t_err, "Error setting up for segment %d on track %d",
-              buff->segment_id, ft_location.track);
-        TRACE_EXIT;
-
-}
-
-/*  this handles writing, read id, reading and formatting
- */
-static void handle_fdc_busy(buffer_struct *buff)
-{
-        static int no_data_error_count;
-        int retry = 0;
-        error_cause cause;
-        __u8 in[7];
-        int skip;
-        fdc_mode_enum fmode = fdc_mode;
-        TRACE_FUN(ft_t_any);
-
-        if (fdc_result(in, 7) < 0) { /* better get it fast ! */
-                TRACE(ft_t_err, 
-                      "Probably fatal error during FDC Result Phase\n"
-                      KERN_INFO
-                      "drive may hang until (power on) reset :-(");
-                /*  what to do next ????
-                 */
-                TRACE_EXIT;
-        }
-        cause = decode_irq_cause(fdc_mode, in);
-#ifdef TESTING
-        { int i;
-        for (i = 0; i < (int)ft_nr_buffers; ++i)
-                TRACE(ft_t_any, "buffer[%d] status: %d, segment_id: %d",
-                      i, ft_buffer[i]->status, ft_buffer[i]->segment_id);
-        }
-#endif
-        if (fmode == fdc_reading_data && ft_driver_state == verifying) {
-                fmode = fdc_verifying;
-        }
-        switch (fmode) {
-        case fdc_verifying:
-                if (ft_runner_status == aborting ||
-                    ft_runner_status == do_abort) {
-                        TRACE(ft_t_noise,"aborting %s",fdc_mode_txt(fdc_mode));
-                        break;
-                }
-                if (buff->retry > 0) {
-                        TRACE(ft_t_flow, "this is retry nr %d", buff->retry);
-                }
-                switch (cause) {
-                case no_error:
-                        no_data_error_count = 0;
-                        determine_verify_progress(buff, cause, in[5]);
-                        if (in[2] & 0x40) {
-                                /*  This should not happen when verifying
-                                 */
-                                TRACE(ft_t_warn,
-                                      "deleted data in segment %d/%d",
-                                      buff->segment_id,
-                                      FT_SECTOR(buff->sector_offset - 1));
-                                buff->remaining = 0; /* abort transfer */
-                                buff->hard_error_map = EMPTY_SEGMENT;
-                                skip = 1;
-                        } else {
-                                skip = 0;
-                        }
-                        continue_xfer(buff, fdc_mode, skip);
-                        break;
-                case no_data_error:
-                        no_data_error_count ++;
-                case overrun_error:
-                        retry ++;
-                case id_am_error:
-                case id_crc_error:
-                case data_am_error:
-                case data_crc_error:
-                        determine_verify_progress(buff, cause, in[5]); 
-                        if (cause == no_data_error) {
-                                if (no_data_error_count >= 2) {
-                                        TRACE(ft_t_warn,
-                                              "retrying because of successive "
-                                              "no data errors");
-                                        no_data_error_count = 0;
-                                } else {
-                                        retry --;
-                                }
-                        } else {
-                                no_data_error_count = 0;
-                        }
-                        if (retry) {
-                                skip = find_resume_point(buff);
-                        } else {
-                                skip = buff->sector_offset;
-                        }
-                        if (retry && skip < 32) {
-                                retry_sector(buff, fdc_mode, skip);
-                        } else {
-                                continue_xfer(buff, fdc_mode, skip);
-                        }
-                        update_history(cause);
-                        break;
-                default:
-                        /*  Don't know why this could happen 
-                         *  but find out.
-                         */
-                        determine_verify_progress(buff, cause, in[5]);
-                        retry_sector(buff, fdc_mode, 0);
-                        TRACE(ft_t_err, "Error: unexpected error");
-                        break;
-                }
-                break;
-        case fdc_reading_data:
-#ifdef TESTING
-                /* I'm sorry, but: NOBODY ever used this trace
-                 * messages for ages. I guess that Bas was the last person
-                 * that ever really used this (thank you, between the lines)
-                 */
-                if (cause == no_error) {
-                        TRACE(ft_t_flow,"reading segment %d",buff->segment_id);
-                } else {
-                        TRACE(ft_t_noise, "error reading segment %d",
-                              buff->segment_id);
-                        TRACE(ft_t_noise, "\n"
-                              KERN_INFO
-                             "IRQ:C: 0x%02x, H: 0x%02x, R: 0x%02x, N: 0x%02x\n"
-                              KERN_INFO
-                              "BUF:C: 0x%02x, H: 0x%02x, R: 0x%02x",
-                              in[3], in[4], in[5], in[6],
-                              buff->cyl, buff->head, buff->sect);
-                }
-#endif
-                if (ft_runner_status == aborting ||
-                    ft_runner_status == do_abort) {
-                        TRACE(ft_t_noise,"aborting %s",fdc_mode_txt(fdc_mode));
-                        break;
-                }
-                if (buff->bad_sector_map == FAKE_SEGMENT) {
-                        /* This condition occurs when reading a `fake'
-                         * sector that's not accessible. Doesn't
-                         * really matter as we would have ignored it
-                         * anyway !
-                         *
-                         * Chance is that we're past the next segment
-                         * now, so the next operation may fail and
-                         * result in a retry.  
-                         */
-                        buff->remaining = 0;    /* skip failing sector */
-                        /* buff->ptr       = buff->address; */
-                        /* fake success: */
-                        continue_xfer(buff, fdc_mode, 1);
-                        /*  trace calls are expensive: place them AFTER
-                         *  the real stuff has been done.
-                         *  
-                         */
-                        TRACE(ft_t_noise, "skipping empty segment %d (read), size? %d",
-                              buff->segment_id, buff->ptr - buff->address);
-                        TRACE_EXIT;
-                }
-                if (buff->retry > 0) {
-                        TRACE(ft_t_flow, "this is retry nr %d", buff->retry);
-                }
-                switch (cause) {
-                case no_error:
-                        determine_progress(buff, cause, in[5]);
-                        if (in[2] & 0x40) {
-                                /*  Handle deleted data in header segments.
-                                 *  Skip segment and force read-ahead.
-                                 */
-                                TRACE(ft_t_warn,
-                                      "deleted data in segment %d/%d",
-                                      buff->segment_id,
-                                      FT_SECTOR(buff->sector_offset - 1));
-                                buff->deleted = 1;
-                                buff->remaining = 0;/*abort transfer */
-                                buff->soft_error_map |=
-                                                (-1L << buff->sector_offset);
-                                if (buff->segment_id == 0) {
-                                        /* stop on next segment */
-                                        stop_read_ahead = 1;
-                                }
-                                /* force read-ahead: */
-                                buff->next_segment = 
-                                        buff->segment_id + 1;
-                                skip = (FT_SECTORS_PER_SEGMENT - 
-                                        buff->sector_offset);
-                        } else {
-                                skip = 0;
-                        }
-                        continue_xfer(buff, fdc_mode, skip);
-                        break;
-                case no_data_error:
-                        /* Tape started too far ahead of or behind the
-                         * right sector.  This may also happen in the
-                         * middle of a segment !
-                         *
-                         * Handle no-data as soft error. If next
-                         * sector fails too, a retry (with needed
-                         * reposition) will follow.
-                         */
-                        retry ++;
-                case id_am_error:
-                case id_crc_error:
-                case data_am_error:
-                case data_crc_error:
-                case overrun_error:
-                        retry += (buff->soft_error_map != 0 ||
-                                  buff->hard_error_map != 0);
-                        determine_progress(buff, cause, in[5]); 
-#if 1 || defined(TESTING)
-                        if (cause == overrun_error) retry ++;
-#endif
-                        if (retry) {
-                                skip = find_resume_point(buff);
-                        } else {
-                                skip = buff->sector_offset;
-                        }
-                        /*  Try to resume with next sector on single
-                         *  errors (let ecc correct it), but retry on
-                         *  no_data (we'll be past the target when we
-                         *  get here so we cannot retry) or on
-                         *  multiple errors (reduce chance on ecc
-                         *  failure).
-                         */
-                        /*  cH: 23/02/97: if the last sector in the 
-                         *  segment was a hard error, then there is 
-                         *  no sense in a retry. This occasion seldom
-                         *  occurs but ... @:³²¸`@%&§$
-                         */
-                        if (retry && skip < 32) {
-                                retry_sector(buff, fdc_mode, skip);
-                        } else {
-                                continue_xfer(buff, fdc_mode, skip);
-                        }
-                        update_history(cause);
-                        break;
-                default:
-                        /*  Don't know why this could happen 
-                         *  but find out.
-                         */
-                        determine_progress(buff, cause, in[5]);
-                        retry_sector(buff, fdc_mode, 0);
-                        TRACE(ft_t_err, "Error: unexpected error");
-                        break;
-                }
-                break;
-        case fdc_reading_id:
-                if (cause == no_error) {
-                        fdc_cyl = in[3];
-                        fdc_head = in[4];
-                        fdc_sect = in[5];
-                        TRACE(ft_t_fdc_dma,
-                              "id read: C: 0x%02x, H: 0x%02x, R: 0x%02x",
-                              fdc_cyl, fdc_head, fdc_sect);
-                } else {        /* no valid information, use invalid sector */
-                        fdc_cyl = fdc_head = fdc_sect = 0;
-                        TRACE(ft_t_flow, "Didn't find valid sector Id");
-                }
-                fdc_mode = fdc_idle;
-                break;
-        case fdc_deleting:
-        case fdc_writing_data:
-#ifdef TESTING
-                if (cause == no_error) {
-                        TRACE(ft_t_flow, "writing segment %d", buff->segment_id);
-                } else {
-                        TRACE(ft_t_noise, "error writing segment %d",
-                              buff->segment_id);
-                }
-#endif
-                if (ft_runner_status == aborting ||
-                    ft_runner_status == do_abort) {
-                        TRACE(ft_t_flow, "aborting %s",fdc_mode_txt(fdc_mode));
-                        break;
-                }
-                if (buff->retry > 0) {
-                        TRACE(ft_t_flow, "this is retry nr %d", buff->retry);
-                }
-                if (buff->bad_sector_map == FAKE_SEGMENT) {
-                        /* This condition occurs when trying to write to a
-                         * `fake' sector that's not accessible. Doesn't really
-                         * matter as it isn't used anyway ! Might be located
-                         * at wrong segment, then we'll fail on the next
-                         * segment.
-                         */
-                        TRACE(ft_t_noise, "skipping empty segment (write)");
-                        buff->remaining = 0;    /* skip failing sector */
-                        /* fake success: */
-                        continue_xfer(buff, fdc_mode, 1);
-                        break;
-                }
-                switch (cause) {
-                case no_error:
-                        determine_progress(buff, cause, in[5]);
-                        continue_xfer(buff, fdc_mode, 0);
-                        break;
-                case no_data_error:
-                case id_am_error:
-                case id_crc_error:
-                case data_am_error:
-                case overrun_error:
-                        update_history(cause);
-                        determine_progress(buff, cause, in[5]);
-                        skip = find_resume_point(buff);
-                        retry_sector(buff, fdc_mode, skip);
-                        break;
-                default:
-                        if (in[1] & 0x02) {
-                                TRACE(ft_t_err, "media not writable");
-                        } else {
-                                TRACE(ft_t_bug, "unforeseen write error");
-                        }
-                        fdc_mode = fdc_idle;
-                        break;
-                }
-                break; /* fdc_deleting || fdc_writing_data */
-        case fdc_formatting:
-                /*  The interrupt comes after formatting a segment. We then
-                 *  have to set up QUICKLY for the next segment. But
-                 *  afterwards, there is plenty of time.
-                 */
-                switch (cause) {
-                case no_error:
-                        /*  would like to keep most of the formatting stuff
-                         *  outside the isr code, but timing is too critical
-                         */
-                        if (determine_fmt_progress(buff, cause) >= 0) {
-                                continue_formatting(buff);
-                        }
-                        break;
-                case no_data_error:
-                case id_am_error:
-                case id_crc_error:
-                case data_am_error:
-                case overrun_error:
-                default:
-                        determine_fmt_progress(buff, cause);
-                        update_history(cause);
-                        if (in[1] & 0x02) {
-                                TRACE(ft_t_err, "media not writable");
-                        } else {
-                                TRACE(ft_t_bug, "unforeseen write error");
-                        }
-                        break;
-                } /* cause */
-                break;
-        default:
-                TRACE(ft_t_warn, "Warning: unexpected irq during: %s",
-                      fdc_mode_txt(fdc_mode));
-                fdc_mode = fdc_idle;
-                break;
-        }
-        TRACE_EXIT;
-}
-
-/*      FDC interrupt service routine.
- */
-void fdc_isr(void)
-{
-        static int isr_active;
-#ifdef TESTING
-        unsigned int t0 = ftape_timestamp();
-#endif
-        TRACE_FUN(ft_t_any);
-
-        if (isr_active++) {
-                --isr_active;
-                TRACE(ft_t_bug, "BUG: nested interrupt, not good !");
-                *fdc.hook = fdc_isr; /*  hook our handler into the fdc
-                                      *  code again 
-                                      */
-                TRACE_EXIT;
-        }
-        sti();
-        if (inb_p(fdc.msr) & FDC_BUSY) {        /*  Entering Result Phase */
-                ft_hide_interrupt = 0;
-                handle_fdc_busy(ftape_get_buffer(ft_queue_head));
-                if (ft_runner_status == do_abort) {
-                        /*      cease operation, remember tape position
-                         */
-                        TRACE(ft_t_flow, "runner aborting");
-                        ft_runner_status = aborting;
-                        ++ft_expected_stray_interrupts;
-                }
-        } else { /* !FDC_BUSY */
-                /*  clear interrupt, cause should be gotten by issuing
-                 *  a Sense Interrupt Status command.
-                 */
-                if (fdc_mode == fdc_recalibrating || fdc_mode == fdc_seeking) {
-                        if (ft_hide_interrupt) {
-                                int st0;
-                                int pcn;
-
-                                if (fdc_sense_interrupt_status(&st0, &pcn) < 0)
-                                        TRACE(ft_t_err,
-                                              "sense interrupt status failed");
-                                ftape_current_cylinder = pcn;
-                                TRACE(ft_t_flow, "handled hidden interrupt");
-                        }
-                        ft_seek_completed = 1;
-                        fdc_mode = fdc_idle;
-                } else if (!waitqueue_active(&ftape_wait_intr)) {
-                        if (ft_expected_stray_interrupts == 0) {
-                                TRACE(ft_t_warn, "unexpected stray interrupt");
-                        } else {
-                                TRACE(ft_t_flow, "expected stray interrupt");
-                                --ft_expected_stray_interrupts;
-                        }
-                } else {
-                        if (fdc_mode == fdc_reading_data ||
-                            fdc_mode == fdc_verifying    ||
-                            fdc_mode == fdc_writing_data ||
-                            fdc_mode == fdc_deleting     ||
-                            fdc_mode == fdc_formatting   ||
-                            fdc_mode == fdc_reading_id) {
-                                if (inb_p(fdc.msr) & FDC_BUSY) {
-                                        TRACE(ft_t_bug,
-                                        "***** FDC failure, busy too late");
-                                } else {
-                                        TRACE(ft_t_bug,
-                                              "***** FDC failure, no busy");
-                                }
-                        } else {
-                                TRACE(ft_t_fdc_dma, "awaited stray interrupt");
-                        }
-                }
-                ft_hide_interrupt = 0;
-        }
-        /*    Handle sleep code.
-         */
-        if (!ft_hide_interrupt) {
-                ft_interrupt_seen ++;
-                if (waitqueue_active(&ftape_wait_intr)) {
-                        wake_up_interruptible(&ftape_wait_intr);
-                }
-        } else {
-                TRACE(ft_t_flow, "hiding interrupt while %s", 
-                      waitqueue_active(&ftape_wait_intr) ? "waiting":"active");
-        }
-#ifdef TESTING
-        t0 = ftape_timediff(t0, ftape_timestamp());
-        if (t0 >= 1000) {
-                /* only tell us about long calls */
-                TRACE(ft_t_noise, "isr() duration: %5d usec", t0);
-        }
-#endif
-        *fdc.hook = fdc_isr;    /* hook our handler into the fdc code again */
-        --isr_active;
-        TRACE_EXIT;
-}
diff --git a/drivers/char/ftape/lowlevel/fdc-isr.h b/drivers/char/ftape/lowlevel/fdc-isr.h
deleted file mode 100644
index 065aa978942d..000000000000
--- a/drivers/char/ftape/lowlevel/fdc-isr.h
+++ /dev/null
@@ -1,55 +0,0 @@
-#ifndef _FDC_ISR_H
-#define _FDC_ISR_H
-
-/*
- * Copyright (C) 1993-1996 Bas Laarhoven,
- *           (C) 1996-1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/fdc-isr.h,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:18:07 $
- *
- *      This file declares the global variables necessary to
- *      synchronize the interrupt service routine (isr) with the
- *      remainder of the QIC-40/80/3010/3020 floppy-tape driver
- *      "ftape" for Linux.
- */
-
-/*
- *      fdc-isr.c defined public variables
- */
-extern volatile int ft_expected_stray_interrupts; /* masks stray interrupts */
-extern volatile int ft_seek_completed;            /* flag set by isr */
-extern volatile int ft_interrupt_seen;            /* flag set by isr */
-extern volatile int ft_hide_interrupt;            /* flag set by isr */
-
-/*
- *      fdc-io.c defined public functions
- */
-extern void fdc_isr(void);
-
-/*
- *      A kernel hook that steals one interrupt from the floppy
- *      driver (Should be fixed when the new fdc driver gets ready)
- *      See the linux kernel source files:
- *          drivers/block/floppy.c & drivers/block/blk.h
- *      for the details.
- */
-extern void (*do_floppy) (void);
-
-#endif
diff --git a/drivers/char/ftape/lowlevel/ftape-bsm.c b/drivers/char/ftape/lowlevel/ftape-bsm.c
deleted file mode 100644
index d1a301cc344f..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-bsm.c
+++ /dev/null
@@ -1,491 +0,0 @@
-/*
- *      Copyright (C) 1994-1996 Bas Laarhoven,
- *                (C) 1996-1997 Claus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-bsm.c,v $
- * $Revision: 1.3 $
- * $Date: 1997/10/05 19:15:15 $
- *
- *      This file contains the bad-sector map handling code for
- *      the QIC-117 floppy tape driver for Linux.
- *      QIC-40, QIC-80, QIC-3010 and QIC-3020 maps are implemented.
- */
-
-#include <linux/string.h>
-
-#include <linux/ftape.h>
-#include "../lowlevel/ftape-tracing.h"
-#include "../lowlevel/ftape-bsm.h"
-#include "../lowlevel/ftape-ctl.h"
-#include "../lowlevel/ftape-rw.h"
-
-/*      Global vars.
- */
-
-/*      Local vars.
- */
-static __u8 *bad_sector_map;
-static SectorCount *bsm_hash_ptr; 
-
-typedef enum {
-        forward, backward
-} mode_type;
-
-#if 0
-static void ftape_put_bad_sector_entry(int segment_id, SectorMap new_map);
-#endif
-
-#if 0
-/*  fix_tape converts a normal QIC-80 tape into a 'wide' tape.
- *  For testing purposes only !
- */
-void fix_tape(__u8 * buffer, ft_format_type new_code)
-{
-        static __u8 list[BAD_SECTOR_MAP_SIZE];
-        SectorMap *src_ptr = (SectorMap *) list;
-        __u8 *dst_ptr = bad_sector_map;
-        SectorMap map;
-        unsigned int sector = 1;
-        int i;
-
-        if (format_code != fmt_var && format_code != fmt_big) {
-                memcpy(list, bad_sector_map, sizeof(list));
-                memset(bad_sector_map, 0, sizeof(bad_sector_map));
-                while ((__u8 *) src_ptr - list < sizeof(list)) {
-                        map = *src_ptr++;
-                        if (map == EMPTY_SEGMENT) {
-                                *(SectorMap *) dst_ptr = 0x800000 + sector;
-                                dst_ptr += 3;
-                                sector += SECTORS_PER_SEGMENT;
-                        } else {
-                                for (i = 0; i < SECTORS_PER_SEGMENT; ++i) {
-                                        if (map & 1) {
-                                                *(SewctorMap *) dst_ptr = sector;
-                                                dst_ptr += 3;
-                                        }
-                                        map >>= 1;
-                                        ++sector;
-                                }
-                        }
-                }
-        }
-        bad_sector_map_changed = 1;
-        *(buffer + 4) = new_code;       /* put new format code */
-        if (format_code != fmt_var && new_code == fmt_big) {
-                PUT4(buffer, FT_6_HSEG_1,   (__u32)GET2(buffer, 6));
-                PUT4(buffer, FT_6_HSEG_2,   (__u32)GET2(buffer, 8));
-                PUT4(buffer, FT_6_FRST_SEG, (__u32)GET2(buffer, 10));
-                PUT4(buffer, FT_6_LAST_SEG, (__u32)GET2(buffer, 12));
-                memset(buffer+6, '\0', 8);
-        }
-        format_code = new_code;
-}
-
-#endif
-
-/*   given buffer that contains a header segment, find the end of
- *   of the bsm list
- */
-__u8 * ftape_find_end_of_bsm_list(__u8 * address)
-{
-        __u8 *ptr   = address + FT_HEADER_END; /* start of bsm list */
-        __u8 *limit = address + FT_SEGMENT_SIZE;
-        while (ptr + 2 < limit) {
-                if (ptr[0] || ptr[1] || ptr[2]) {
-                        ptr += 3;
-                } else {
-                        return ptr;
-                }
-        }
-        return NULL;
-}
-
-static inline void put_sector(SectorCount *ptr, unsigned int sector)
-{
-        ptr->bytes[0] = sector & 0xff;
-        sector >>= 8;
-        ptr->bytes[1] = sector & 0xff;
-        sector >>= 8;
-        ptr->bytes[2] = sector & 0xff;
-}
-
-static inline unsigned int get_sector(SectorCount *ptr)
-{
-#if 1
-        unsigned int sector;
-
-        sector  = ptr->bytes[0];
-        sector += ptr->bytes[1] <<  8;
-        sector += ptr->bytes[2] << 16;
-
-        return sector;
-#else
-        /*  GET4 gets the next four bytes in Intel little endian order
-         *  and converts them to host byte order and handles unaligned
-         *  access.
-         */
-        return (GET4(ptr, 0) & 0x00ffffff); /* back to host byte order */
-#endif
-}
-
-static void bsm_debug_fake(void)
-{
-        /* for testing of bad sector handling at end of tape
-         */
-#if 0
-        ftape_put_bad_sector_entry(segments_per_track * tracks_per_tape - 3,
-                                   0x000003e0;
-        ftape_put_bad_sector_entry(segments_per_track * tracks_per_tape - 2,
-                                   0xff3fffff;
-        ftape_put_bad_sector_entry(segments_per_track * tracks_per_tape - 1,
-                                   0xffffe000;
-#endif
-        /*  Enable to test bad sector handling
-         */
-#if 0
-        ftape_put_bad_sector_entry(30, 0xfffffffe)
-        ftape_put_bad_sector_entry(32, 0x7fffffff);
-        ftape_put_bad_sector_entry(34, 0xfffeffff);
-        ftape_put_bad_sector_entry(36, 0x55555555);
-        ftape_put_bad_sector_entry(38, 0xffffffff);
-        ftape_put_bad_sector_entry(50, 0xffff0000);
-        ftape_put_bad_sector_entry(51, 0xffffffff);
-        ftape_put_bad_sector_entry(52, 0xffffffff);
-        ftape_put_bad_sector_entry(53, 0x0000ffff);
-#endif
-        /*  Enable when testing multiple volume tar dumps.
-         */
-#if 0
-        {
-                int i;
-
-                for (i = ft_first_data_segment;
-                     i <= ft_last_data_segment - 7; ++i) {
-                        ftape_put_bad_sector_entry(i, EMPTY_SEGMENT);
-                }
-        }
-#endif
-        /*  Enable when testing bit positions in *_error_map
-         */
-#if 0
-        {
-                int i;
-                
-                for (i = first_data_segment; i <= last_data_segment; ++i) {
-                        ftape_put_bad_sector_entry(i,
-                                           ftape_get_bad_sector_entry(i) 
-                                           | 0x00ff00ff);
-                }
-        }
-#endif
-}
-
-static void print_bad_sector_map(void)
-{
-        unsigned int good_sectors;
-        unsigned int total_bad = 0;
-        int i;
-        TRACE_FUN(ft_t_flow);
-
-        if (ft_format_code == fmt_big || 
-            ft_format_code == fmt_var || 
-            ft_format_code == fmt_1100ft) {
-                SectorCount *ptr = (SectorCount *)bad_sector_map;
-                unsigned int sector;
-                __u16 *ptr16;
-
-                while((sector = get_sector(ptr++)) != 0) {
-                        if ((ft_format_code == fmt_big || 
-                             ft_format_code == fmt_var) &&
-                            sector & 0x800000) {
-                                total_bad += FT_SECTORS_PER_SEGMENT - 3;
-                                TRACE(ft_t_noise, "bad segment at sector: %6d",
-                                      sector & 0x7fffff);
-                        } else {
-                                ++total_bad;
-                                TRACE(ft_t_noise, "bad sector: %6d", sector);
-                        }
-                }
-                /*  Display old ftape's end-of-file marks
-                 */
-                ptr16 = (__u16*)ptr;
-                while ((sector = get_unaligned(ptr16++)) != 0) {
-                        TRACE(ft_t_noise, "Old ftape eof mark: %4d/%2d",
-                              sector, get_unaligned(ptr16++));
-                }
-        } else { /* fixed size format */
-                for (i = ft_first_data_segment;
-                     i < (int)(ft_segments_per_track * ft_tracks_per_tape); ++i) {
-                        SectorMap map = ((SectorMap *) bad_sector_map)[i];
-
-                        if (map) {
-                                TRACE(ft_t_noise,
-                                      "bsm for segment %4d: 0x%08x", i, (unsigned int)map);
-                                total_bad += ((map == EMPTY_SEGMENT)
-                                               ? FT_SECTORS_PER_SEGMENT - 3
-                                               : count_ones(map));
-                        }
-                }
-        }
-        good_sectors =
-                ((ft_segments_per_track * ft_tracks_per_tape - ft_first_data_segment)
-                 * (FT_SECTORS_PER_SEGMENT - 3)) - total_bad;
-        TRACE(ft_t_info, "%d Kb usable on this tape", good_sectors);
-        if (total_bad == 0) {
-                TRACE(ft_t_info,
-                      "WARNING: this tape has no bad blocks registered !");
-        } else {
-                TRACE(ft_t_info, "%d bad sectors", total_bad);
-        }
-        TRACE_EXIT;
-}
-
-
-void ftape_extract_bad_sector_map(__u8 * buffer)
-{
-        TRACE_FUN(ft_t_any);
-
-        /*  Fill the bad sector map with the contents of buffer.
-         */
-        if (ft_format_code == fmt_var || ft_format_code == fmt_big) {
-                /* QIC-3010/3020 and wide QIC-80 tapes no longer have a failed
-                 * sector log but use this area to extend the bad sector map.
-                 */
-                bad_sector_map = &buffer[FT_HEADER_END];
-        } else {
-                /* non-wide QIC-80 tapes have a failed sector log area that
-                 * mustn't be included in the bad sector map.
-                 */
-                bad_sector_map = &buffer[FT_FSL + FT_FSL_SIZE];
-        }
-        if (ft_format_code == fmt_1100ft || 
-            ft_format_code == fmt_var    ||
-            ft_format_code == fmt_big) {
-                bsm_hash_ptr = (SectorCount *)bad_sector_map;
-        } else {
-                bsm_hash_ptr = NULL;
-        }
-        bsm_debug_fake();
-        if (TRACE_LEVEL >= ft_t_info) {
-                print_bad_sector_map();
-        }
-        TRACE_EXIT;
-}
-
-static inline SectorMap cvt2map(unsigned int sector)
-{
-        return 1 << (((sector & 0x7fffff) - 1) % FT_SECTORS_PER_SEGMENT);
-}
-
-static inline int cvt2segment(unsigned int sector)
-{
-        return ((sector & 0x7fffff) - 1) / FT_SECTORS_PER_SEGMENT;
-}
-
-static int forward_seek_entry(int segment_id, 
-                              SectorCount **ptr, 
-                              SectorMap *map)
-{
-        unsigned int sector;
-        int segment;
-
-        do {
-                sector = get_sector((*ptr)++);
-                segment = cvt2segment(sector);
-        } while (sector != 0 && segment < segment_id);
-        (*ptr) --; /* point to first sector >= segment_id */
-        /*  Get all sectors in segment_id
-         */
-        if (sector == 0 || segment != segment_id) {
-                *map = 0;
-                return 0;
-        } else if ((sector & 0x800000) &&
-                   (ft_format_code == fmt_var || ft_format_code == fmt_big)) {
-                *map = EMPTY_SEGMENT;
-                return FT_SECTORS_PER_SEGMENT;
-        } else {
-                int count = 1;
-                SectorCount *tmp_ptr = (*ptr) + 1;
-                
-                *map = cvt2map(sector);
-                while ((sector = get_sector(tmp_ptr++)) != 0 &&
-                       (segment = cvt2segment(sector)) == segment_id) {
-                        *map |= cvt2map(sector);
-                        ++count;
-                }
-                return count;
-        }
-}
-
-static int backwards_seek_entry(int segment_id,
-                                SectorCount **ptr,
-                                SectorMap *map)
-{
-        unsigned int sector;
-        int segment; /* max unsigned int */
-
-        if (*ptr <= (SectorCount *)bad_sector_map) {
-                *map = 0;
-                return 0;
-        }
-        do {
-                sector  = get_sector(--(*ptr));
-                segment = cvt2segment(sector);
-        } while (*ptr > (SectorCount *)bad_sector_map && segment > segment_id);
-        if (segment > segment_id) { /*  at start of list, no entry found */
-                *map = 0;
-                return 0;
-        } else if (segment < segment_id) {
-                /*  before smaller entry, adjust for overshoot */
-                (*ptr) ++;
-                *map = 0;
-                return 0;
-        } else if ((sector & 0x800000) &&
-                   (ft_format_code == fmt_big || ft_format_code == fmt_var)) {
-                *map = EMPTY_SEGMENT;
-                return FT_SECTORS_PER_SEGMENT;
-        } else { /*  get all sectors in segment_id */
-                int count = 1;
-
-                *map = cvt2map(sector);
-                while(*ptr > (SectorCount *)bad_sector_map) {
-                        sector = get_sector(--(*ptr));
-                        segment = cvt2segment(sector);
-                        if (segment != segment_id) {
-                                break;
-                        }
-                        *map |= cvt2map(sector);
-                        ++count;
-                }
-                if (segment < segment_id) {
-                        (*ptr) ++;
-                }
-                return count;
-        }
-}
-
-#if 0
-static void ftape_put_bad_sector_entry(int segment_id, SectorMap new_map)
-{
-        SectorCount *ptr = (SectorCount *)bad_sector_map;
-        int count;
-        int new_count;
-        SectorMap map;
-        TRACE_FUN(ft_t_any);
-
-        if (ft_format_code == fmt_1100ft || 
-            ft_format_code == fmt_var || 
-            ft_format_code == fmt_big) {
-                count = forward_seek_entry(segment_id, &ptr, &map);
-                new_count = count_ones(new_map);
-                /* If format code == 4 put empty segment instead of 32
-                 * bad sectors.
-                 */
-                if (ft_format_code == fmt_var || ft_format_code == fmt_big) {
-                        if (new_count == FT_SECTORS_PER_SEGMENT) {
-                                new_count = 1;
-                        }
-                        if (count == FT_SECTORS_PER_SEGMENT) {
-                                count = 1;
-                        }
-                }
-                if (count != new_count) {
-                        /* insert (or delete if < 0) new_count - count
-                         * entries.  Move trailing part of list
-                         * including terminating 0.
-                         */
-                        SectorCount *hi_ptr = ptr;
-
-                        do {
-                        } while (get_sector(hi_ptr++) != 0);
-                        /*  Note: ptr is of type byte *, and each bad sector
-                         *  consumes 3 bytes.
-                         */
-                        memmove(ptr + new_count, ptr + count,
-                                (size_t)(hi_ptr - (ptr + count))*sizeof(SectorCount));
-                }
-                TRACE(ft_t_noise, "putting map 0x%08x at %p, segment %d",
-                      (unsigned int)new_map, ptr, segment_id);
-                if (new_count == 1 && new_map == EMPTY_SEGMENT) {
-                        put_sector(ptr++, (0x800001 + 
-                                          segment_id * 
-                                          FT_SECTORS_PER_SEGMENT));
-                } else {
-                        int i = 0;
-
-                        while (new_map) {
-                                if (new_map & 1) {
-                                        put_sector(ptr++, 
-                                                   1 + segment_id * 
-                                                   FT_SECTORS_PER_SEGMENT + i);
-                                }
-                                ++i;
-                                new_map >>= 1;
-                        }
-                }
-        } else {
-                ((SectorMap *) bad_sector_map)[segment_id] = new_map;
-        }
-        TRACE_EXIT;
-}
-#endif  /*  0  */
-
-SectorMap ftape_get_bad_sector_entry(int segment_id)
-{
-        if (ft_used_header_segment == -1) {
-                /*  When reading header segment we'll need a blank map.
-                 */
-                return 0;
-        } else if (bsm_hash_ptr != NULL) {
-                /*  Invariants:
-                 *    map - mask value returned on last call.
-                 *    bsm_hash_ptr - points to first sector greater or equal to
-                 *          first sector in last_referenced segment.
-                 *    last_referenced - segment id used in the last call,
-                 *                      sector and map belong to this id.
-                 *  This code is designed for sequential access and retries.
-                 *  For true random access it may have to be redesigned.
-                 */
-                static int last_reference = -1;
-                static SectorMap map;
-
-                if (segment_id > last_reference) {
-                        /*  Skip all sectors before segment_id
-                         */
-                        forward_seek_entry(segment_id, &bsm_hash_ptr, &map);
-                } else if (segment_id < last_reference) {
-                        /* Skip backwards until begin of buffer or
-                         * first sector in segment_id 
-                         */
-                        backwards_seek_entry(segment_id, &bsm_hash_ptr, &map);
-                }               /* segment_id == last_reference : keep map */
-                last_reference = segment_id;
-                return map;
-        } else {
-                return ((SectorMap *) bad_sector_map)[segment_id];
-        }
-}
-
-/*  This is simply here to prevent us from overwriting other kernel
- *  data. Writes will result in NULL Pointer dereference.
- */
-void ftape_init_bsm(void)
-{
-        bad_sector_map = NULL;
-        bsm_hash_ptr   = NULL;
-}
diff --git a/drivers/char/ftape/lowlevel/ftape-bsm.h b/drivers/char/ftape/lowlevel/ftape-bsm.h
deleted file mode 100644
index ed45465af4d4..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-bsm.h
+++ /dev/null
@@ -1,66 +0,0 @@
-#ifndef _FTAPE_BSM_H
-#define _FTAPE_BSM_H
-
-/*
- * Copyright (C) 1994-1996 Bas Laarhoven,
- *           (C) 1996-1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-bsm.h,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:18:07 $
- *
- *      This file contains definitions for the bad sector map handling
- *      routines for the QIC-117 floppy-tape driver for Linux.
- */
-
-#include <linux/ftape.h>
-#include <linux/ftape-header-segment.h>
-
-#define EMPTY_SEGMENT           (0xffffffff)
-#define FAKE_SEGMENT            (0xfffffffe)
-
-/*  maximum (format code 4) bad sector map size (bytes).
- */
-#define BAD_SECTOR_MAP_SIZE     (29 * SECTOR_SIZE - 256)
-
-/*  format code 4 bad sector entry, ftape uses this
- *  internally for all format codes
- */
-typedef __u32 SectorMap;
-/*  variable and 1100 ft bad sector map entry. These three bytes represent
- *  a single sector address measured from BOT. 
- */
-typedef struct NewSectorMap {          
-        __u8 bytes[3];
-} SectorCount;
-
-
-/*
- *      ftape-bsm.c defined global vars.
- */
-
-/*
- *      ftape-bsm.c defined global functions.
- */
-extern void update_bad_sector_map(__u8 * buffer);
-extern void ftape_extract_bad_sector_map(__u8 * buffer);
-extern SectorMap ftape_get_bad_sector_entry(int segment_id);
-extern __u8 *ftape_find_end_of_bsm_list(__u8 * address);
-extern void ftape_init_bsm(void);
-
-#endif
diff --git a/drivers/char/ftape/lowlevel/ftape-buffer.c b/drivers/char/ftape/lowlevel/ftape-buffer.c
deleted file mode 100644
index c706ff162771..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-buffer.c
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- *      Copyright (C) 1997 Claus-Justus Heine
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-buffer.c,v $
- * $Revision: 1.3 $
- * $Date: 1997/10/16 23:33:11 $
- *
- *  This file contains the allocator/dealloctor for ftape's dynamic dma
- *  buffer.
- */
-
-#include <linux/slab.h>
-#include <linux/mm.h>
-#include <linux/mman.h>
-#include <asm/dma.h>
-
-#include <linux/ftape.h>
-#include "../lowlevel/ftape-rw.h"
-#include "../lowlevel/ftape-read.h"
-#include "../lowlevel/ftape-tracing.h"
-#include "../lowlevel/ftape-buffer.h"
-
-/*  DMA'able memory allocation stuff.
- */
-
-static inline void *dmaalloc(size_t size)
-{
-        unsigned long addr;
-
-        if (size == 0) {
-                return NULL;
-        }
-        addr = __get_dma_pages(GFP_KERNEL, get_order(size));
-        if (addr) {
-                struct page *page;
-
-                for (page = virt_to_page(addr); page < virt_to_page(addr+size); page++)
-                        SetPageReserved(page);
-        }
-        return (void *)addr;
-}
-
-static inline void dmafree(void *addr, size_t size)
-{
-        if (size > 0) {
-                struct page *page;
-
-                for (page = virt_to_page((unsigned long)addr);
-                     page < virt_to_page((unsigned long)addr+size); page++)
-                        ClearPageReserved(page);
-                free_pages((unsigned long) addr, get_order(size));
-        }
-}
-
-static int add_one_buffer(void)
-{
-        TRACE_FUN(ft_t_flow);
-        
-        if (ft_nr_buffers >= FT_MAX_NR_BUFFERS) {
-                TRACE_EXIT -ENOMEM;
-        }
-        ft_buffer[ft_nr_buffers] = kmalloc(sizeof(buffer_struct), GFP_KERNEL);
-        if (ft_buffer[ft_nr_buffers] == NULL) {
-                TRACE_EXIT -ENOMEM;
-        }
-        memset(ft_buffer[ft_nr_buffers], 0, sizeof(buffer_struct));
-        ft_buffer[ft_nr_buffers]->address = dmaalloc(FT_BUFF_SIZE);
-        if (ft_buffer[ft_nr_buffers]->address == NULL) {
-                kfree(ft_buffer[ft_nr_buffers]);
-                ft_buffer[ft_nr_buffers] = NULL;
-                TRACE_EXIT -ENOMEM;
-        }
-        ft_nr_buffers ++;
-        TRACE(ft_t_info, "buffer nr #%d @ %p, dma area @ %p",
-              ft_nr_buffers,
-              ft_buffer[ft_nr_buffers-1],
-              ft_buffer[ft_nr_buffers-1]->address);
-        TRACE_EXIT 0;
-}
-
-static void del_one_buffer(void)
-{
-        TRACE_FUN(ft_t_flow);
-        if (ft_nr_buffers > 0) {
-                TRACE(ft_t_info, "releasing buffer nr #%d @ %p, dma area @ %p",
-                      ft_nr_buffers,
-                      ft_buffer[ft_nr_buffers-1],
-                      ft_buffer[ft_nr_buffers-1]->address);
-                ft_nr_buffers --;
-                dmafree(ft_buffer[ft_nr_buffers]->address, FT_BUFF_SIZE);
-                kfree(ft_buffer[ft_nr_buffers]);
-                ft_buffer[ft_nr_buffers] = NULL;
-        }
-        TRACE_EXIT;
-}
-
-int ftape_set_nr_buffers(int cnt)
-{
-        int delta = cnt - ft_nr_buffers;
-        TRACE_FUN(ft_t_flow);
-
-        if (delta > 0) {
-                while (delta--) {
-                        if (add_one_buffer() < 0) {
-                                TRACE_EXIT -ENOMEM;
-                        }
-                }
-        } else if (delta < 0) {
-                while (delta++) {
-                        del_one_buffer();
-                }
-        }
-        ftape_zap_read_buffers();
-        TRACE_EXIT 0;
-}
diff --git a/drivers/char/ftape/lowlevel/ftape-buffer.h b/drivers/char/ftape/lowlevel/ftape-buffer.h
deleted file mode 100644
index eec99cee8f82..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-buffer.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#ifndef _FTAPE_BUFFER_H
-#define _FTAPE_BUFFER_H
-
-/*
- *      Copyright (C) 1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-buffer.h,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:18:08 $
- *
- *  This file contains the allocator/dealloctor for ftape's dynamic dma
- *  buffer.
- */
-
-extern int  ftape_set_nr_buffers(int cnt);
-
-#endif
diff --git a/drivers/char/ftape/lowlevel/ftape-calibr.c b/drivers/char/ftape/lowlevel/ftape-calibr.c
deleted file mode 100644
index 8e50bfd35a52..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-calibr.c
+++ /dev/null
@@ -1,275 +0,0 @@
-/*
- *      Copyright (C) 1993-1996 Bas Laarhoven.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-calibr.c,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:18:08 $
- *
- *      GP calibration routine for processor speed dependent
- *      functions.
- */
-
-#include <linux/errno.h>
-#include <linux/jiffies.h>
-#include <asm/system.h>
-#include <asm/io.h>
-#if defined(__alpha__)
-# include <asm/hwrpb.h>
-#elif defined(__x86_64__)
-# include <asm/msr.h>
-# include <asm/timex.h>
-#elif defined(__i386__)
-# include <linux/timex.h>
-#endif
-#include <linux/ftape.h>
-#include "../lowlevel/ftape-tracing.h"
-#include "../lowlevel/ftape-calibr.h"
-#include "../lowlevel/fdc-io.h"
-
-#undef DEBUG
-
-#if !defined(__alpha__) && !defined(__i386__) && !defined(__x86_64__)
-# error Ftape is not implemented for this architecture!
-#endif
-
-#if defined(__alpha__) || defined(__x86_64__)
-static unsigned long ps_per_cycle = 0;
-#endif
-
-static spinlock_t calibr_lock;
-
-/*
- * Note: On Intel PCs, the clock ticks at 100 Hz (HZ==100) which is
- * too slow for certain timeouts (and that clock doesn't even tick
- * when interrupts are disabled).  For that reason, the 8254 timer is
- * used directly to implement fine-grained timeouts.  However, on
- * Alpha PCs, the 8254 is *not* used to implement the clock tick
- * (which is 1024 Hz, normally) and the 8254 timer runs at some
- * "random" frequency (it seems to run at 18Hz, but it's not safe to
- * rely on this value).  Instead, we use the Alpha's "rpcc"
- * instruction to read cycle counts.  As this is a 32 bit counter,
- * it will overflow only once per 30 seconds (on a 200MHz machine),
- * which is plenty.
- */
-
-unsigned int ftape_timestamp(void)
-{
-#if defined(__alpha__)
-        unsigned long r;
-
-        asm volatile ("rpcc %0" : "=r" (r));
-        return r;
-#elif defined(__x86_64__)
-        unsigned long r;
-        rdtscl(r);
-        return r;
-#elif defined(__i386__)
-
-/*
- * Note that there is some time between counter underflowing and jiffies
- * increasing, so the code below won't always give correct output.
- * -Vojtech
- */
-
-        unsigned long flags;
-        __u16 lo;
-        __u16 hi;
-
-        spin_lock_irqsave(&calibr_lock, flags);
-        outb_p(0x00, 0x43);     /* latch the count ASAP */
-        lo = inb_p(0x40);       /* read the latched count */
-        lo |= inb(0x40) << 8;
-        hi = jiffies;
-        spin_unlock_irqrestore(&calibr_lock, flags);
-        return ((hi + 1) * (unsigned int) LATCH) - lo;  /* downcounter ! */
-#endif
-}
-
-static unsigned int short_ftape_timestamp(void)
-{
-#if defined(__alpha__) || defined(__x86_64__)
-        return ftape_timestamp();
-#elif defined(__i386__)
-        unsigned int count;
-        unsigned long flags;
- 
-        spin_lock_irqsave(&calibr_lock, flags);
-        outb_p(0x00, 0x43);     /* latch the count ASAP */
-        count = inb_p(0x40);    /* read the latched count */
-        count |= inb(0x40) << 8;
-        spin_unlock_irqrestore(&calibr_lock, flags);
-        return (LATCH - count); /* normal: downcounter */
-#endif
-}
-
-static unsigned int diff(unsigned int t0, unsigned int t1)
-{
-#if defined(__alpha__) || defined(__x86_64__)
-        return (t1 - t0);
-#elif defined(__i386__)
-        /*
-         * This is tricky: to work for both short and full ftape_timestamps
-         * we'll have to discriminate between these.
-         * If it _looks_ like short stamps with wrapping around we'll
-         * asume it are. This will generate a small error if it really
-         * was a (very large) delta from full ftape_timestamps.
-         */
-        return (t1 <= t0 && t0 <= LATCH) ? t1 + LATCH - t0 : t1 - t0;
-#endif
-}
-
-static unsigned int usecs(unsigned int count)
-{
-#if defined(__alpha__) || defined(__x86_64__)
-        return (ps_per_cycle * count) / 1000000UL;
-#elif defined(__i386__)
-        return (10000 * count) / ((CLOCK_TICK_RATE + 50) / 100);
-#endif
-}
-
-unsigned int ftape_timediff(unsigned int t0, unsigned int t1)
-{
-        /*
-         *  Calculate difference in usec for ftape_timestamp results t0 & t1.
-         *  Note that on the i386 platform with short time-stamps, the
-         *  maximum allowed timespan is 1/HZ or we'll lose ticks!
-         */
-        return usecs(diff(t0, t1));
-}
-
-/*      To get an indication of the I/O performance,
- *      measure the duration of the inb() function.
- */
-static void time_inb(void)
-{
-        int i;
-        int t0, t1;
-        unsigned long flags;
-        int status;
-        TRACE_FUN(ft_t_any);
-
-        spin_lock_irqsave(&calibr_lock, flags);
-        t0 = short_ftape_timestamp();
-        for (i = 0; i < 1000; ++i) {
-                status = inb(fdc.msr);
-        }
-        t1 = short_ftape_timestamp();
-        spin_unlock_irqrestore(&calibr_lock, flags);
-        TRACE(ft_t_info, "inb() duration: %d nsec", ftape_timediff(t0, t1));
-        TRACE_EXIT;
-}
-
-static void init_clock(void)
-{
-        TRACE_FUN(ft_t_any);
-
-#if defined(__x86_64__)
-        ps_per_cycle = 1000000000UL / cpu_khz;
-#elif defined(__alpha__)
-        extern struct hwrpb_struct *hwrpb;
-        ps_per_cycle = (1000*1000*1000*1000UL) / hwrpb->cycle_freq;
-#endif
-        TRACE_EXIT;
-}
-
-/*
- *      Input:  function taking int count as parameter.
- *              pointers to calculated calibration variables.
- */
-void ftape_calibrate(char *name,
-                    void (*fun) (unsigned int), 
-                    unsigned int *calibr_count, 
-                    unsigned int *calibr_time)
-{
-        static int first_time = 1;
-        int i;
-        unsigned int tc = 0;
-        unsigned int count;
-        unsigned int time;
-#if defined(__i386__)
-        unsigned int old_tc = 0;
-        unsigned int old_count = 1;
-        unsigned int old_time = 1;
-#endif
-        TRACE_FUN(ft_t_flow);
-
-        if (first_time) {             /* get idea of I/O performance */
-                init_clock();
-                time_inb();
-                first_time = 0;
-        }
-        /*    value of timeout must be set so that on very slow systems
-         *    it will give a time less than one jiffy, and on
-         *    very fast systems it'll give reasonable precision.
-         */
-
-        count = 40;
-        for (i = 0; i < 15; ++i) {
-                unsigned int t0;
-                unsigned int t1;
-                unsigned int once;
-                unsigned int multiple;
-                unsigned long flags;
-
-                *calibr_count =
-                *calibr_time = count;   /* set TC to 1 */
-                spin_lock_irqsave(&calibr_lock, flags);
-                fun(0);         /* dummy, get code into cache */
-                t0 = short_ftape_timestamp();
-                fun(0);         /* overhead + one test */
-                t1 = short_ftape_timestamp();
-                once = diff(t0, t1);
-                t0 = short_ftape_timestamp();
-                fun(count);             /* overhead + count tests */
-                t1 = short_ftape_timestamp();
-                multiple = diff(t0, t1);
-                spin_unlock_irqrestore(&calibr_lock, flags);
-                time = ftape_timediff(0, multiple - once);
-                tc = (1000 * time) / (count - 1);
-                TRACE(ft_t_any, "once:%3d us,%6d times:%6d us, TC:%5d ns",
-                        usecs(once), count - 1, usecs(multiple), tc);
-#if defined(__alpha__) || defined(__x86_64__)
-                /*
-                 * Increase the calibration count exponentially until the
-                 * calibration time exceeds 100 ms.
-                 */
-                if (time >= 100*1000) {
-                        break;
-                }
-#elif defined(__i386__)
-                /*
-                 * increase the count until the resulting time nears 2/HZ,
-                 * then the tc will drop sharply because we lose LATCH counts.
-                 */
-                if (tc <= old_tc / 2) {
-                        time = old_time;
-                        count = old_count;
-                        break;
-                }
-                old_tc = tc;
-                old_count = count;
-                old_time = time;
-#endif
-                count *= 2;
-        }
-        *calibr_count = count - 1;
-        *calibr_time  = time;
-        TRACE(ft_t_info, "TC for `%s()' = %d nsec (at %d counts)",
-             name, (1000 * *calibr_time) / *calibr_count, *calibr_count);
-        TRACE_EXIT;
-}
diff --git a/drivers/char/ftape/lowlevel/ftape-calibr.h b/drivers/char/ftape/lowlevel/ftape-calibr.h
deleted file mode 100644
index 0c7e75246c7d..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-calibr.h
+++ /dev/null
@@ -1,37 +0,0 @@
-#ifndef _FTAPE_CALIBR_H
-#define _FTAPE_CALIBR_H
-
-/*
- *      Copyright (C) 1993-1996 Bas Laarhoven.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-calibr.h,v $
- * $Revision: 1.1 $
- * $Date: 1997/09/19 09:05:26 $
- *
- *      This file contains a gp calibration routine for
- *      hardware dependent timeout functions.
- */
-
-extern void ftape_calibrate(char *name,
-                            void (*fun) (unsigned int),
-                            unsigned int *calibr_count,
-                            unsigned int *calibr_time);
-extern unsigned int ftape_timestamp(void);
-extern unsigned int ftape_timediff(unsigned int t0, unsigned int t1);
-
-#endif /* _FTAPE_CALIBR_H */
diff --git a/drivers/char/ftape/lowlevel/ftape-ctl.c b/drivers/char/ftape/lowlevel/ftape-ctl.c
deleted file mode 100644
index 5d7c1ce92d59..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-ctl.c
+++ /dev/null
@@ -1,896 +0,0 @@
-/*
- *      Copyright (C) 1993-1996 Bas Laarhoven,
- *                    1996-1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-ctl.c,v $
- * $Revision: 1.4 $
- * $Date: 1997/11/11 14:37:44 $
- *
- *      This file contains the non-read/write ftape functions for the
- *      QIC-40/80/3010/3020 floppy-tape driver "ftape" for Linux.
- */
-
-#include <linux/errno.h>
-#include <linux/mm.h>
-#include <linux/mman.h>
-
-#include <linux/ftape.h>
-#include <linux/qic117.h>
-#include <asm/uaccess.h>
-#include <asm/io.h>
-
-/* ease porting between pre-2.4.x and later kernels */
-#define vma_get_pgoff(v)      ((v)->vm_pgoff)
-
-#include "../lowlevel/ftape-tracing.h"
-#include "../lowlevel/ftape-io.h"
-#include "../lowlevel/ftape-ctl.h"
-#include "../lowlevel/ftape-write.h"
-#include "../lowlevel/ftape-read.h"
-#include "../lowlevel/ftape-rw.h"
-#include "../lowlevel/ftape-bsm.h"
-
-/*      Global vars.
- */
-ftape_info ftape_status = {
-/*  vendor information */
-        { 0, },     /* drive type */
-/*  data rates */
-        500,        /* used data rate */
-        500,        /* drive max rate */
-        500,        /* fdc max rate   */
-/*  drive selection, either FTAPE_SEL_A/B/C/D */
-        -1,     /* drive selection */
-/*  flags set after decode the drive and tape status   */
-        0,          /* formatted */
-        1,          /* no tape */
-        1,          /* write protected */
-        1,          /* new tape */
-/*  values of last queried drive/tape status and error */
-        {{0,}},     /* last error code */
-        {{0,}},     /* drive status, configuration, tape status */
-/*  cartridge geometry */
-        20,         /* tracks_per_tape */
-        102,        /* segments_per_track */
-/*  location of header segments, etc. */
-        -1,     /* used_header_segment */
-        -1,     /* header_segment_1 */
-        -1,     /* header_segment_2 */
-        -1,     /* first_data_segment */
-        -1,     /* last_data_segment */
-/*  the format code as stored in the header segment  */
-        fmt_normal, /* format code */
-/*  the default for the qic std: unknown */
-        -1,
-/*  is tape running? */
-        idle,       /* runner_state */
-/*  is tape reading/writing/verifying/formatting/deleting */
-        idle,       /* driver state */
-/*  flags fatal hardware error */
-        1,          /* failure */
-/*  history record */
-        { 0, }      /* history record */
-};
-        
-int ftape_segments_per_head     = 1020;
-int ftape_segments_per_cylinder = 4;
-int ftape_init_drive_needed = 1; /* need to be global for ftape_reset_drive()
-                                  * in ftape-io.c
-                                  */
-
-/*      Local vars.
- */
-static const vendor_struct vendors[] = QIC117_VENDORS;
-static const wakeup_method methods[] = WAKEUP_METHODS;
-
-const ftape_info *ftape_get_status(void)
-{
-#if defined(STATUS_PARANOYA)
-        static ftape_info get_status;
-
-        get_status = ftape_status;
-        return &get_status;
-#else
-        return &ftape_status; /*  maybe return only a copy of it to assure 
-                               *  read only access
-                               */
-#endif
-}
-
-static int ftape_not_operational(int status)
-{
-        /* return true if status indicates tape can not be used.
-         */
-        return ((status ^ QIC_STATUS_CARTRIDGE_PRESENT) &
-                (QIC_STATUS_ERROR |
-                 QIC_STATUS_CARTRIDGE_PRESENT |
-                 QIC_STATUS_NEW_CARTRIDGE));
-}
-
-int ftape_seek_to_eot(void)
-{
-        int status;
-        TRACE_FUN(ft_t_any);
-
-        TRACE_CATCH(ftape_ready_wait(ftape_timeout.pause, &status),);
-        while ((status & QIC_STATUS_AT_EOT) == 0) {
-                if (ftape_not_operational(status)) {
-                        TRACE_EXIT -EIO;
-                }
-                TRACE_CATCH(ftape_command_wait(QIC_PHYSICAL_FORWARD,
-                                               ftape_timeout.rewind,&status),);
-        }
-        TRACE_EXIT 0;
-}
-
-int ftape_seek_to_bot(void)
-{
-        int status;
-        TRACE_FUN(ft_t_any);
-
-        TRACE_CATCH(ftape_ready_wait(ftape_timeout.pause, &status),);
-        while ((status & QIC_STATUS_AT_BOT) == 0) {
-                if (ftape_not_operational(status)) {
-                        TRACE_EXIT -EIO;
-                }
-                TRACE_CATCH(ftape_command_wait(QIC_PHYSICAL_REVERSE,
-                                               ftape_timeout.rewind,&status),);
-        }
-        TRACE_EXIT 0;
-}
-
-static int ftape_new_cartridge(void)
-{
-        ft_location.track = -1; /* force seek on first access */
-        ftape_zap_read_buffers();
-        ftape_zap_write_buffers();
-        return 0;
-}
-
-int ftape_abort_operation(void)
-{
-        int result = 0;
-        int status;
-        TRACE_FUN(ft_t_flow);
-
-        if (ft_runner_status == running) {
-                TRACE(ft_t_noise, "aborting runner, waiting");
-                
-                ft_runner_status = do_abort;
-                /* set timeout so that the tape will run to logical EOT
-                 * if we missed the last sector and there are no queue pulses.
-                 */
-                result = ftape_dumb_stop();
-        }
-        if (ft_runner_status != idle) {
-                if (ft_runner_status == do_abort) {
-                        TRACE(ft_t_noise, "forcing runner abort");
-                }
-                TRACE(ft_t_noise, "stopping tape");
-                result = ftape_stop_tape(&status);
-                ft_location.known = 0;
-                ft_runner_status  = idle;
-        }
-        ftape_reset_buffer();
-        ftape_zap_read_buffers();
-        ftape_set_state(idle);
-        TRACE_EXIT result;
-}
-
-static int lookup_vendor_id(unsigned int vendor_id)
-{
-        int i = 0;
-
-        while (vendors[i].vendor_id != vendor_id) {
-                if (++i >= NR_ITEMS(vendors)) {
-                        return -1;
-                }
-        }
-        return i;
-}
-
-static void ftape_detach_drive(void)
-{
-        TRACE_FUN(ft_t_any);
-
-        TRACE(ft_t_flow, "disabling tape drive and fdc");
-        ftape_put_drive_to_sleep(ft_drive_type.wake_up);
-        fdc_catch_stray_interrupts(1);  /* one always comes */
-        fdc_disable();
-        fdc_release_irq_and_dma();
-        fdc_release_regions();
-        TRACE_EXIT;
-}
-
-static void clear_history(void)
-{
-        ft_history.used = 0;
-        ft_history.id_am_errors =
-                ft_history.id_crc_errors =
-                ft_history.data_am_errors =
-                ft_history.data_crc_errors =
-                ft_history.overrun_errors =
-                ft_history.no_data_errors =
-                ft_history.retries =
-                ft_history.crc_errors =
-                ft_history.crc_failures =
-                ft_history.ecc_failures =
-                ft_history.corrected =
-                ft_history.defects =
-                ft_history.rewinds = 0;
-}
-
-static int ftape_activate_drive(vendor_struct * drive_type)
-{
-        int result = 0;
-        TRACE_FUN(ft_t_flow);
-
-        /* If we already know the drive type, wake it up.
-         * Else try to find out what kind of drive is attached.
-         */
-        if (drive_type->wake_up != unknown_wake_up) {
-                TRACE(ft_t_flow, "enabling tape drive and fdc");
-                result = ftape_wakeup_drive(drive_type->wake_up);
-                if (result < 0) {
-                        TRACE(ft_t_err, "known wakeup method failed");
-                }
-        } else {
-                wake_up_types method;
-                const ft_trace_t old_tracing = TRACE_LEVEL;
-                if (TRACE_LEVEL < ft_t_flow) {
-                        SET_TRACE_LEVEL(ft_t_bug);
-                }
-
-                /*  Try to awaken the drive using all known methods.
-                 *  Lower tracing for a while.
-                 */
-                for (method=no_wake_up; method < NR_ITEMS(methods); ++method) {
-                        drive_type->wake_up = method;
-#ifdef CONFIG_FT_TWO_DRIVES
-                        /*  Test setup for dual drive configuration.
-                         *  /dev/rft2 uses mountain wakeup
-                         *  /dev/rft3 uses colorado wakeup
-                         *  Other systems will use the normal scheme.
-                         */
-                        if ((ft_drive_sel < 2)                            ||
-                            (ft_drive_sel == 2 && method == FT_WAKE_UP_1) ||
-                            (ft_drive_sel == 3 && method == FT_WAKE_UP_2)) {
-                                result=ftape_wakeup_drive(drive_type->wake_up);
-                        } else {
-                                result = -EIO;
-                        }
-#else
-                        result = ftape_wakeup_drive(drive_type->wake_up);
-#endif
-                        if (result >= 0) {
-                                TRACE(ft_t_warn, "drive wakeup method: %s",
-                                      methods[drive_type->wake_up].name);
-                                break;
-                        }
-                }
-                SET_TRACE_LEVEL(old_tracing);
-
-                if (method >= NR_ITEMS(methods)) {
-                        /* no response at all, cannot open this drive */
-                        drive_type->wake_up = unknown_wake_up;
-                        TRACE(ft_t_err, "no tape drive found !");
-                        result = -ENODEV;
-                }
-        }
-        TRACE_EXIT result;
-}
-
-static int ftape_get_drive_status(void)
-{
-        int result;
-        int status;
-        TRACE_FUN(ft_t_flow);
-
-        ft_no_tape = ft_write_protected = 0;
-        /*    Tape drive is activated now.
-         *    First clear error status if present.
-         */
-        do {
-                result = ftape_ready_wait(ftape_timeout.reset, &status);
-                if (result < 0) {
-                        if (result == -ETIME) {
-                                TRACE(ft_t_err, "ftape_ready_wait timeout");
-                        } else if (result == -EINTR) {
-                                TRACE(ft_t_err, "ftape_ready_wait aborted");
-                        } else {
-                                TRACE(ft_t_err, "ftape_ready_wait failed");
-                        }
-                        TRACE_EXIT -EIO;
-                }
-                /*  Clear error condition (drive is ready !)
-                 */
-                if (status & QIC_STATUS_ERROR) {
-                        unsigned int error;
-                        qic117_cmd_t command;
-
-                        TRACE(ft_t_err, "error status set");
-                        result = ftape_report_error(&error, &command, 1);
-                        if (result < 0) {
-                                TRACE(ft_t_err,
-                                      "report_error_code failed: %d", result);
-                                /* hope it's working next time */
-                                ftape_reset_drive();
-                                TRACE_EXIT -EIO;
-                        } else if (error != 0) {
-                                TRACE(ft_t_noise, "error code   : %d", error);
-                                TRACE(ft_t_noise, "error command: %d", command);
-                        }
-                }
-                if (status & QIC_STATUS_NEW_CARTRIDGE) {
-                        unsigned int error;
-                        qic117_cmd_t command;
-                        const ft_trace_t old_tracing = TRACE_LEVEL;
-                        SET_TRACE_LEVEL(ft_t_bug);
-
-                        /*  Undocumented feature: Must clear (not present!)
-                         *  error here or we'll fail later.
-                         */
-                        ftape_report_error(&error, &command, 1);
-
-                        SET_TRACE_LEVEL(old_tracing);
-                        TRACE(ft_t_info, "status: new cartridge");
-                        ft_new_tape = 1;
-                } else {
-                        ft_new_tape = 0;
-                }
-                FT_SIGNAL_EXIT(_DONT_BLOCK);
-        } while (status & QIC_STATUS_ERROR);
-        
-        ft_no_tape = !(status & QIC_STATUS_CARTRIDGE_PRESENT);
-        ft_write_protected = (status & QIC_STATUS_WRITE_PROTECT) != 0;
-        if (ft_no_tape) {
-                TRACE(ft_t_warn, "no cartridge present");
-        } else {
-                if (ft_write_protected) {
-                        TRACE(ft_t_noise, "Write protected cartridge");
-                }
-        }
-        TRACE_EXIT 0;
-}
-
-static void ftape_log_vendor_id(void)
-{
-        int vendor_index;
-        TRACE_FUN(ft_t_flow);
-
-        ftape_report_vendor_id(&ft_drive_type.vendor_id);
-        vendor_index = lookup_vendor_id(ft_drive_type.vendor_id);
-        if (ft_drive_type.vendor_id == UNKNOWN_VENDOR &&
-            ft_drive_type.wake_up == wake_up_colorado) {
-                vendor_index = 0;
-                /* hack to get rid of all this mail */
-                ft_drive_type.vendor_id = 0;
-        }
-        if (vendor_index < 0) {
-                /* Unknown vendor id, first time opening device.  The
-                 * drive_type remains set to type found at wakeup
-                 * time, this will probably keep the driver operating
-                 * for this new vendor.  
-                 */
-                TRACE(ft_t_warn, "\n"
-                      KERN_INFO "============ unknown vendor id ===========\n"
-                      KERN_INFO "A new, yet unsupported tape drive is found\n"
-                      KERN_INFO "Please report the following values:\n"
-                      KERN_INFO "   Vendor id     : 0x%04x\n"
-                      KERN_INFO "   Wakeup method : %s\n"
-                      KERN_INFO "And a description of your tape drive\n"
-                      KERN_INFO "to "THE_FTAPE_MAINTAINER"\n"
-                      KERN_INFO "==========================================",
-                      ft_drive_type.vendor_id,
-                      methods[ft_drive_type.wake_up].name);
-                ft_drive_type.speed = 0;                /* unknown */
-        } else {
-                ft_drive_type.name  = vendors[vendor_index].name;
-                ft_drive_type.speed = vendors[vendor_index].speed;
-                TRACE(ft_t_info, "tape drive type: %s", ft_drive_type.name);
-                /* scan all methods for this vendor_id in table */
-                while(ft_drive_type.wake_up != vendors[vendor_index].wake_up) {
-                        if (vendor_index < NR_ITEMS(vendors) - 1 &&
-                            vendors[vendor_index + 1].vendor_id 
-                            == 
-                            ft_drive_type.vendor_id) {
-                                ++vendor_index;
-                        } else {
-                                break;
-                        }
-                }
-                if (ft_drive_type.wake_up != vendors[vendor_index].wake_up) {
-                        TRACE(ft_t_warn, "\n"
-                     KERN_INFO "==========================================\n"
-                     KERN_INFO "wakeup type mismatch:\n"
-                     KERN_INFO "found: %s, expected: %s\n"
-                     KERN_INFO "please report this to "THE_FTAPE_MAINTAINER"\n"
-                     KERN_INFO "==========================================",
-                              methods[ft_drive_type.wake_up].name,
-                              methods[vendors[vendor_index].wake_up].name);
-                }
-        }
-        TRACE_EXIT;
-}
-
-void ftape_calc_timeouts(unsigned int qic_std,
-                         unsigned int data_rate,
-                         unsigned int tape_len)
-{
-        int speed;              /* deci-ips ! */
-        int ff_speed;
-        int length;
-        TRACE_FUN(ft_t_any);
-
-        /*                           tape transport speed
-         *  data rate:        QIC-40   QIC-80   QIC-3010 QIC-3020
-         *
-         *    250 Kbps        25 ips     n/a      n/a      n/a
-         *    500 Kbps        50 ips   34 ips   22.6 ips   n/a
-         *      1 Mbps          n/a    68 ips   45.2 ips 22.6 ips
-         *      2 Mbps          n/a      n/a      n/a    45.2 ips
-         *
-         *  fast tape transport speed is at least 68 ips.
-         */
-        switch (qic_std) {
-        case QIC_TAPE_QIC40:
-                speed = (data_rate == 250) ? 250 : 500;
-                break;
-        case QIC_TAPE_QIC80:
-                speed = (data_rate == 500) ? 340 : 680;
-                break;
-        case QIC_TAPE_QIC3010:
-                speed = (data_rate == 500) ? 226 : 452;
-                break;
-        case QIC_TAPE_QIC3020:
-                speed = (data_rate == 1000) ? 226 : 452;
-                break;
-        default:
-                TRACE(ft_t_bug, "Unknown qic_std (bug) ?");
-                speed = 500;
-                break;
-        }
-        if (ft_drive_type.speed == 0) {
-                unsigned long t0;
-                static int dt = 0;     /* keep gcc from complaining */
-                static int first_time = 1;
-
-                /*  Measure the time it takes to wind to EOT and back to BOT.
-                 *  If the tape length is known, calculate the rewind speed.
-                 *  Else keep the time value for calculation of the rewind
-                 *  speed later on, when the length _is_ known.
-                 *  Ask for a report only when length and speed are both known.
-                 */
-                if (first_time) {
-                        ftape_seek_to_bot();
-                        t0 = jiffies;
-                        ftape_seek_to_eot();
-                        ftape_seek_to_bot();
-                        dt = (int) (((jiffies - t0) * FT_USPT) / 1000);
-                        if (dt < 1) {
-                                dt = 1; /* prevent div by zero on failures */
-                        }
-                        first_time = 0;
-                        TRACE(ft_t_info,
-                              "trying to determine seek timeout, got %d msec",
-                              dt);
-                }
-                if (tape_len != 0) {
-                        ft_drive_type.speed = 
-                                (2 * 12 * tape_len * 1000) / dt;
-                        TRACE(ft_t_warn, "\n"
-                     KERN_INFO "==========================================\n"
-                     KERN_INFO "drive type: %s\n"
-                     KERN_INFO "delta time = %d ms, length = %d ft\n"
-                     KERN_INFO "has a maximum tape speed of %d ips\n"
-                     KERN_INFO "please report this to "THE_FTAPE_MAINTAINER"\n"
-                     KERN_INFO "==========================================",
-                              ft_drive_type.name, dt, tape_len, 
-                              ft_drive_type.speed);
-                }
-        }
-        /*  Handle unknown length tapes as very long ones. We'll
-         *  determine the actual length from a header segment later.
-         *  This is normal for all modern (Wide,TR1/2/3) formats.
-         */
-        if (tape_len <= 0) {
-                TRACE(ft_t_noise,
-                      "Unknown tape length, using maximal timeouts");
-                length = QIC_TOP_TAPE_LEN;      /* use worst case values */
-        } else {
-                length = tape_len;              /* use actual values */
-        }
-        if (ft_drive_type.speed == 0) {
-                ff_speed = speed; 
-        } else {
-                ff_speed = ft_drive_type.speed;
-        }
-        /*  time to go from bot to eot at normal speed (data rate):
-         *  time = (1+delta) * length (ft) * 12 (inch/ft) / speed (ips)
-         *  delta = 10 % for seek speed, 20 % for rewind speed.
-         */
-        ftape_timeout.seek = (length * 132 * FT_SECOND) / speed;
-        ftape_timeout.rewind = (length * 144 * FT_SECOND) / (10 * ff_speed);
-        ftape_timeout.reset = 20 * FT_SECOND + ftape_timeout.rewind;
-        TRACE(ft_t_noise, "timeouts for speed = %d, length = %d\n"
-              KERN_INFO "seek timeout  : %d sec\n"
-              KERN_INFO "rewind timeout: %d sec\n"
-              KERN_INFO "reset timeout : %d sec",
-              speed, length,
-              (ftape_timeout.seek + 500) / 1000,
-              (ftape_timeout.rewind + 500) / 1000,
-              (ftape_timeout.reset + 500) / 1000);
-        TRACE_EXIT;
-}
-
-/* This function calibrates the datarate (i.e. determines the maximal
- * usable data rate) and sets the global variable ft_qic_std to qic_std
- *
- */
-int ftape_calibrate_data_rate(unsigned int qic_std)
-{
-        int rate = ft_fdc_rate_limit;
-        int result;
-        TRACE_FUN(ft_t_flow);
-
-        ft_qic_std = qic_std;
-
-        if (ft_qic_std == -1) {
-                TRACE_ABORT(-EIO, ft_t_err,
-                "Unable to determine data rate if QIC standard is unknown");
-        }
-
-        /*  Select highest rate supported by both fdc and drive.
-         *  Start with highest rate supported by the fdc.
-         */
-        while (fdc_set_data_rate(rate) < 0 && rate > 250) {
-                rate /= 2;
-        }
-        TRACE(ft_t_info,
-              "Highest FDC supported data rate: %d Kbps", rate);
-        ft_fdc_max_rate = rate;
-        do {
-                result = ftape_set_data_rate(rate, ft_qic_std);
-        } while (result == -EINVAL && (rate /= 2) > 250);
-        if (result < 0) {
-                TRACE_ABORT(-EIO, ft_t_err, "set datarate failed");
-        }
-        ft_data_rate = rate;
-        TRACE_EXIT 0;
-}
-
-static int ftape_init_drive(void)
-{
-        int status;
-        qic_model model;
-        unsigned int qic_std;
-        unsigned int data_rate;
-        TRACE_FUN(ft_t_flow);
-
-        ftape_init_drive_needed = 0; /* don't retry if this fails ? */
-        TRACE_CATCH(ftape_report_raw_drive_status(&status),);
-        if (status & QIC_STATUS_CARTRIDGE_PRESENT) {
-                if (!(status & QIC_STATUS_AT_BOT)) {
-                        /*  Antique drives will get here after a soft reset,
-                         *  modern ones only if the driver is loaded when the
-                         *  tape wasn't rewound properly.
-                         */
-                        /* Tape should be at bot if new cartridge ! */
-                        ftape_seek_to_bot();
-                }
-                if (!(status & QIC_STATUS_REFERENCED)) {
-                        TRACE(ft_t_flow, "starting seek_load_point");
-                        TRACE_CATCH(ftape_command_wait(QIC_SEEK_LOAD_POINT,
-                                                       ftape_timeout.reset,
-                                                       &status),);
-                }
-        }
-        ft_formatted = (status & QIC_STATUS_REFERENCED) != 0;
-        if (!ft_formatted) {
-                TRACE(ft_t_warn, "Warning: tape is not formatted !");
-        }
-
-        /*  report configuration aborts when ftape_tape_len == -1
-         *  unknown qic_std is okay if not formatted.
-         */
-        TRACE_CATCH(ftape_report_configuration(&model,
-                                               &data_rate,
-                                               &qic_std,
-                                               &ftape_tape_len),);
-
-        /*  Maybe add the following to the /proc entry
-         */
-        TRACE(ft_t_info, "%s drive @ %d Kbps",
-              (model == prehistoric) ? "prehistoric" :
-              ((model == pre_qic117c) ? "pre QIC-117C" :
-               ((model == post_qic117b) ? "post QIC-117B" :
-                "post QIC-117D")), data_rate);
-
-        if (ft_formatted) {
-                /*  initialize ft_used_data_rate to maximum value 
-                 *  and set ft_qic_std
-                 */
-                TRACE_CATCH(ftape_calibrate_data_rate(qic_std),);
-                if (ftape_tape_len == 0) {
-                        TRACE(ft_t_info, "unknown length QIC-%s tape",
-                              (ft_qic_std == QIC_TAPE_QIC40) ? "40" :
-                              ((ft_qic_std == QIC_TAPE_QIC80) ? "80" :
-                               ((ft_qic_std == QIC_TAPE_QIC3010) 
-                                ? "3010" : "3020")));
-                } else {
-                        TRACE(ft_t_info, "%d ft. QIC-%s tape", ftape_tape_len,
-                              (ft_qic_std == QIC_TAPE_QIC40) ? "40" :
-                              ((ft_qic_std == QIC_TAPE_QIC80) ? "80" :
-                               ((ft_qic_std == QIC_TAPE_QIC3010)
-                                ? "3010" : "3020")));
-                }
-                ftape_calc_timeouts(ft_qic_std, ft_data_rate, ftape_tape_len);
-                /* soft write-protect QIC-40/QIC-80 cartridges used with a
-                 * Colorado T3000 drive. Buggy hardware!
-                 */
-                if ((ft_drive_type.vendor_id == 0x011c6) &&
-                    ((ft_qic_std == QIC_TAPE_QIC40 ||
-                      ft_qic_std == QIC_TAPE_QIC80) &&
-                     !ft_write_protected)) {
-                        TRACE(ft_t_warn, "\n"
-        KERN_INFO "The famous Colorado T3000 bug:\n"
-        KERN_INFO "%s drives can't write QIC40 and QIC80\n"
-        KERN_INFO "cartridges but don't set the write-protect flag!",
-                              ft_drive_type.name);
-                        ft_write_protected = 1;
-                }
-        } else {
-                /*  Doesn't make too much sense to set the data rate
-                 *  because we don't know what to use for the write
-                 *  precompensation.
-                 *  Need to do this again when formatting the cartridge.
-                 */
-                ft_data_rate = data_rate;
-                ftape_calc_timeouts(QIC_TAPE_QIC40,
-                                    data_rate,
-                                    ftape_tape_len);
-        }
-        ftape_new_cartridge();
-        TRACE_EXIT 0;
-}
-
-static void ftape_munmap(void)
-{
-        int i;
-        TRACE_FUN(ft_t_flow);
-        
-        for (i = 0; i < ft_nr_buffers; i++) {
-                ft_buffer[i]->mmapped = 0;
-        }
-        TRACE_EXIT;
-}
-
-/*   Map the dma buffers into the virtual address range given by vma.
- *   We only check the caller doesn't map non-existent buffers. We
- *   don't check for multiple mappings.
- */
-int ftape_mmap(struct vm_area_struct *vma)
-{
-        int num_buffers;
-        int i;
-        TRACE_FUN(ft_t_flow);
-        
-        if (ft_failure) {
-                TRACE_EXIT -ENODEV;
-        }
-        if (!(vma->vm_flags & (VM_READ|VM_WRITE))) {
-                TRACE_ABORT(-EINVAL, ft_t_err, "Undefined mmap() access");
-        }
-        if (vma_get_pgoff(vma) != 0) {
-                TRACE_ABORT(-EINVAL, ft_t_err, "page offset must be 0");
-        }
-        if ((vma->vm_end - vma->vm_start) % FT_BUFF_SIZE != 0) {
-                TRACE_ABORT(-EINVAL, ft_t_err,
-                            "size = %ld, should be a multiple of %d",
-                            vma->vm_end - vma->vm_start,
-                            FT_BUFF_SIZE);
-        }
-        num_buffers = (vma->vm_end - vma->vm_start) / FT_BUFF_SIZE;
-        if (num_buffers > ft_nr_buffers) {
-                TRACE_ABORT(-EINVAL,
-                            ft_t_err, "size = %ld, should be less than %d",
-                            vma->vm_end - vma->vm_start,
-                            ft_nr_buffers * FT_BUFF_SIZE);
-        }
-        if (ft_driver_state != idle) {
-                /* this also clears the buffer states 
-                 */
-                ftape_abort_operation();
-        } else {
-                ftape_reset_buffer();
-        }
-        for (i = 0; i < num_buffers; i++) {
-                unsigned long pfn;
-
-                pfn = virt_to_phys(ft_buffer[i]->address) >> PAGE_SHIFT;
-                TRACE_CATCH(remap_pfn_range(vma, vma->vm_start +
-                                             i * FT_BUFF_SIZE,
-                                             pfn,
-                                             FT_BUFF_SIZE,
-                                             vma->vm_page_prot),
-                            _res = -EAGAIN);
-                TRACE(ft_t_noise, "remapped dma buffer @ %p to location @ %p",
-                      ft_buffer[i]->address,
-                      (void *)(vma->vm_start + i * FT_BUFF_SIZE));
-        }
-        for (i = 0; i < num_buffers; i++) {
-                memset(ft_buffer[i]->address, 0xAA, FT_BUFF_SIZE);
-                ft_buffer[i]->mmapped++;
-        }       
-        TRACE_EXIT 0;
-}
-
-static void ftape_init_driver(void); /* forward declaration */
-
-/*      OPEN routine called by kernel-interface code
- */
-int ftape_enable(int drive_selection)
-{
-        TRACE_FUN(ft_t_any);
-
-        if (ft_drive_sel == -1 || ft_drive_sel != drive_selection) {
-                /* Other selection than last time
-                 */
-                ftape_init_driver();
-        }
-        ft_drive_sel = FTAPE_SEL(drive_selection);
-        ft_failure = 0;
-        TRACE_CATCH(fdc_init(),); /* init & detect fdc */
-        TRACE_CATCH(ftape_activate_drive(&ft_drive_type),
-                    fdc_disable();
-                    fdc_release_irq_and_dma();
-                    fdc_release_regions());
-        TRACE_CATCH(ftape_get_drive_status(), ftape_detach_drive());
-        if (ft_drive_type.vendor_id == UNKNOWN_VENDOR) {
-                ftape_log_vendor_id();
-        }
-        if (ft_new_tape) {
-                ftape_init_drive_needed = 1;
-        }
-        if (!ft_no_tape && ftape_init_drive_needed) {
-                TRACE_CATCH(ftape_init_drive(), ftape_detach_drive());
-        }
-        ftape_munmap(); /* clear the mmap flag */
-        clear_history();
-        TRACE_EXIT 0;
-}
-
-/*   release routine called by the high level interface modules
- *   zftape or sftape.
- */
-void ftape_disable(void)
-{
-        int i;
-        TRACE_FUN(ft_t_any);
-
-        for (i = 0; i < ft_nr_buffers; i++) {
-                if (ft_buffer[i]->mmapped) {
-                        TRACE(ft_t_noise, "first byte of buffer %d: 0x%02x",
-                              i, *ft_buffer[i]->address);
-                }
-        }
-        if (sigtestsetmask(&current->pending.signal, _DONT_BLOCK) && 
-            !(sigtestsetmask(&current->pending.signal, _NEVER_BLOCK)) &&
-            ftape_tape_running) {
-                TRACE(ft_t_warn,
-                      "Interrupted by fatal signal and tape still running");
-                ftape_dumb_stop();
-                ftape_abort_operation(); /* it's annoying */
-        } else {
-                ftape_set_state(idle);
-        }
-        ftape_detach_drive();
-        if (ft_history.used) {
-                TRACE(ft_t_info, "== Non-fatal errors this run: ==");
-                TRACE(ft_t_info, "fdc isr statistics:\n"
-                      KERN_INFO " id_am_errors     : %3d\n"
-                      KERN_INFO " id_crc_errors    : %3d\n"
-                      KERN_INFO " data_am_errors   : %3d\n"
-                      KERN_INFO " data_crc_errors  : %3d\n"
-                      KERN_INFO " overrun_errors   : %3d\n"
-                      KERN_INFO " no_data_errors   : %3d\n"
-                      KERN_INFO " retries          : %3d",
-                      ft_history.id_am_errors,   ft_history.id_crc_errors,
-                      ft_history.data_am_errors, ft_history.data_crc_errors,
-                      ft_history.overrun_errors, ft_history.no_data_errors,
-                      ft_history.retries);
-                if (ft_history.used & 1) {
-                        TRACE(ft_t_info, "ecc statistics:\n"
-                              KERN_INFO " crc_errors       : %3d\n"
-                              KERN_INFO " crc_failures     : %3d\n"
-                              KERN_INFO " ecc_failures     : %3d\n"
-                              KERN_INFO " sectors corrected: %3d",
-                              ft_history.crc_errors,   ft_history.crc_failures,
-                              ft_history.ecc_failures, ft_history.corrected);
-                }
-                if (ft_history.defects > 0) {
-                        TRACE(ft_t_warn, "Warning: %d media defects!",
-                              ft_history.defects);
-                }
-                if (ft_history.rewinds > 0) {
-                        TRACE(ft_t_info, "tape motion statistics:\n"
-                              KERN_INFO "repositions       : %3d",
-                              ft_history.rewinds);
-                }
-        }
-        ft_failure = 1;
-        TRACE_EXIT;
-}
-
-static void ftape_init_driver(void)
-{
-        TRACE_FUN(ft_t_flow);
-
-        ft_drive_type.vendor_id = UNKNOWN_VENDOR;
-        ft_drive_type.speed     = 0;
-        ft_drive_type.wake_up   = unknown_wake_up;
-        ft_drive_type.name      = "Unknown";
-
-        ftape_timeout.seek      = 650 * FT_SECOND;
-        ftape_timeout.reset     = 670 * FT_SECOND;
-        ftape_timeout.rewind    = 650 * FT_SECOND;
-        ftape_timeout.head_seek =  15 * FT_SECOND;
-        ftape_timeout.stop      =   5 * FT_SECOND;
-        ftape_timeout.pause     =  16 * FT_SECOND;
-
-        ft_qic_std             = -1;
-        ftape_tape_len         = 0;  /* unknown */
-        ftape_current_command  = 0;
-        ftape_current_cylinder = -1;
-
-        ft_segments_per_track       = 102;
-        ftape_segments_per_head     = 1020;
-        ftape_segments_per_cylinder = 4;
-        ft_tracks_per_tape          = 20;
-
-        ft_failure = 1;
-
-        ft_formatted       = 0;
-        ft_no_tape         = 1;
-        ft_write_protected = 1;
-        ft_new_tape        = 1;
-
-        ft_driver_state = idle;
-
-        ft_data_rate = 
-                ft_fdc_max_rate   = 500;
-        ft_drive_max_rate = 0; /* triggers set_rate_test() */
-
-        ftape_init_drive_needed = 1;
-
-        ft_header_segment_1    = -1;
-        ft_header_segment_2    = -1;
-        ft_used_header_segment = -1;
-        ft_first_data_segment  = -1;
-        ft_last_data_segment   = -1;
-
-        ft_location.track = -1;
-        ft_location.known = 0;
-
-        ftape_tape_running = 0;
-        ftape_might_be_off_track = 1;
-
-        ftape_new_cartridge();  /* init some tape related variables */
-        ftape_init_bsm();
-        TRACE_EXIT;
-}
diff --git a/drivers/char/ftape/lowlevel/ftape-ctl.h b/drivers/char/ftape/lowlevel/ftape-ctl.h
deleted file mode 100644
index 5f5e30bc3615..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-ctl.h
+++ /dev/null
@@ -1,162 +0,0 @@
-#ifndef _FTAPE_CTL_H
-#define _FTAPE_CTL_H
-
-/*
- * Copyright (C) 1993-1996 Bas Laarhoven,
- *           (C) 1996-1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-ctl.h,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:18:09 $
- *
- *      This file contains the non-standard IOCTL related definitions
- *      for the QIC-40/80/3010/3020 floppy-tape driver "ftape" for
- *      Linux.
- */
-
-#include <linux/ioctl.h>
-#include <linux/mtio.h>
-#include <linux/ftape-vendors.h>
-
-#include "../lowlevel/ftape-rw.h"
-#include <linux/ftape-header-segment.h>
-
-typedef struct {
-        int used;               /* any reading or writing done */
-        /* isr statistics */
-        unsigned int id_am_errors;      /* id address mark not found */
-        unsigned int id_crc_errors;     /* crc error in id address mark */
-        unsigned int data_am_errors;    /* data address mark not found */
-        unsigned int data_crc_errors;   /* crc error in data field */
-        unsigned int overrun_errors;    /* fdc access timing problem */
-        unsigned int no_data_errors;    /* sector not found */
-        unsigned int retries;   /* number of tape retries */
-        /* ecc statistics */
-        unsigned int crc_errors;        /* crc error in data */
-        unsigned int crc_failures;      /* bad data without crc error */
-        unsigned int ecc_failures;      /* failed to correct */
-        unsigned int corrected; /* total sectors corrected */
-        /* general statistics */
-        unsigned int rewinds;   /* number of tape rewinds */
-        unsigned int defects;   /* bad sectors due to media defects */
-} history_record;
-
-/* this structure contains * ALL * information that we want
- * our child modules to know about, but don't want them to
- * modify. 
- */
-typedef struct {
-        /*  vendor information */
-        vendor_struct fti_drive_type;
-        /*  data rates */
-        unsigned int fti_used_data_rate;
-        unsigned int fti_drive_max_rate;
-        unsigned int fti_fdc_max_rate;
-        /*  drive selection, either FTAPE_SEL_A/B/C/D */
-        int fti_drive_sel;      
-        /*  flags set after decode the drive and tape status   */
-        unsigned int fti_formatted      :1;
-        unsigned int fti_no_tape        :1;
-        unsigned int fti_write_protected:1;
-        unsigned int fti_new_tape       :1;
-        /*  values of last queried drive/tape status and error */
-        ft_drive_error  fti_last_error;
-        ft_drive_status fti_last_status;
-        /*  cartridge geometry */
-        unsigned int fti_tracks_per_tape;
-        unsigned int fti_segments_per_track;
-        /*  location of header segments, etc. */
-        int fti_used_header_segment;
-        int fti_header_segment_1;
-        int fti_header_segment_2;
-        int fti_first_data_segment;
-        int fti_last_data_segment;
-        /*  the format code as stored in the header segment  */
-        ft_format_type  fti_format_code;
-        /*  the following is the sole reason for the ftape_set_status() call */
-        unsigned int fti_qic_std;
-        /*  is tape running? */
-        volatile enum runner_status_enum fti_runner_status;
-        /*  is tape reading/writing/verifying/formatting/deleting */
-        buffer_state_enum fti_state;
-        /*  flags fatal hardware error */
-        unsigned int fti_failure:1;
-        /*  history record */
-        history_record fti_history;
-} ftape_info;
-
-/* vendor information */
-#define ft_drive_type          ftape_status.fti_drive_type
-/*  data rates */
-#define ft_data_rate           ftape_status.fti_used_data_rate
-#define ft_drive_max_rate      ftape_status.fti_drive_max_rate
-#define ft_fdc_max_rate        ftape_status.fti_fdc_max_rate
-/*  drive selection, either FTAPE_SEL_A/B/C/D */
-#define ft_drive_sel           ftape_status.fti_drive_sel
-/*  flags set after decode the drive and tape status   */
-#define ft_formatted           ftape_status.fti_formatted
-#define ft_no_tape             ftape_status.fti_no_tape
-#define ft_write_protected     ftape_status.fti_write_protected
-#define ft_new_tape            ftape_status.fti_new_tape
-/*  values of last queried drive/tape status and error */
-#define ft_last_error          ftape_status.fti_last_error
-#define ft_last_status         ftape_status.fti_last_status
-/*  cartridge geometry */
-#define ft_tracks_per_tape     ftape_status.fti_tracks_per_tape
-#define ft_segments_per_track  ftape_status.fti_segments_per_track
-/*  the format code as stored in the header segment  */
-#define ft_format_code         ftape_status.fti_format_code
-/*  the qic status as returned by report drive configuration */
-#define ft_qic_std             ftape_status.fti_qic_std
-#define ft_used_header_segment ftape_status.fti_used_header_segment
-#define ft_header_segment_1    ftape_status.fti_header_segment_1
-#define ft_header_segment_2    ftape_status.fti_header_segment_2
-#define ft_first_data_segment  ftape_status.fti_first_data_segment
-#define ft_last_data_segment   ftape_status.fti_last_data_segment
-/*  is tape running? */
-#define ft_runner_status       ftape_status.fti_runner_status
-/*  is tape reading/writing/verifying/formatting/deleting */
-#define ft_driver_state        ftape_status.fti_state
-/*  flags fatal hardware error */
-#define ft_failure             ftape_status.fti_failure
-/*  history record */
-#define ft_history             ftape_status.fti_history
-
-/*
- *      ftape-ctl.c defined global vars.
- */
-extern ftape_info ftape_status;
-extern int ftape_segments_per_head;
-extern int ftape_segments_per_cylinder;
-extern int ftape_init_drive_needed;
-
-/*
- *      ftape-ctl.c defined global functions.
- */
-extern int  ftape_mmap(struct vm_area_struct *vma);
-extern int  ftape_enable(int drive_selection);
-extern void ftape_disable(void);
-extern int  ftape_seek_to_bot(void);
-extern int  ftape_seek_to_eot(void);
-extern int  ftape_abort_operation(void);
-extern void ftape_calc_timeouts(unsigned int qic_std,
-                                 unsigned int data_rate,
-                                 unsigned int tape_len);
-extern int  ftape_calibrate_data_rate(unsigned int qic_std);
-extern const ftape_info *ftape_get_status(void);
-#endif
diff --git a/drivers/char/ftape/lowlevel/ftape-ecc.c b/drivers/char/ftape/lowlevel/ftape-ecc.c
deleted file mode 100644
index e5632f674bc8..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-ecc.c
+++ /dev/null
@@ -1,853 +0,0 @@
-/*
- *
- *      Copyright (c) 1993 Ning and David Mosberger.
- 
- This is based on code originally written by Bas Laarhoven (bas@vimec.nl)
- and David L. Brown, Jr., and incorporates improvements suggested by
- Kai Harrekilde-Petersen.
-
- This program is free software; you can redistribute it and/or
- modify it under the terms of the GNU General Public License as
- published by the Free Software Foundation; either version 2, or (at
- your option) any later version.
- 
- This program is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- General Public License for more details.
- 
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
- USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-ecc.c,v $
- * $Revision: 1.3 $
- * $Date: 1997/10/05 19:18:10 $
- *
- *      This file contains the Reed-Solomon error correction code 
- *      for the QIC-40/80 floppy-tape driver for Linux.
- */
-
-#include <linux/ftape.h>
-
-#include "../lowlevel/ftape-tracing.h"
-#include "../lowlevel/ftape-ecc.h"
-
-/* Machines that are big-endian should define macro BIG_ENDIAN.
- * Unfortunately, there doesn't appear to be a standard include file
- * that works for all OSs.
- */
-
-#if defined(__sparc__) || defined(__hppa)
-#define BIG_ENDIAN
-#endif                          /* __sparc__ || __hppa */
-
-#if defined(__mips__)
-#error Find a smart way to determine the Endianness of the MIPS CPU
-#endif
-
-/* Notice: to minimize the potential for confusion, we use r to
- *         denote the independent variable of the polynomials in the
- *         Galois Field GF(2^8).  We reserve x for polynomials that
- *         that have coefficients in GF(2^8).
- *         
- * The Galois Field in which coefficient arithmetic is performed are
- * the polynomials over Z_2 (i.e., 0 and 1) modulo the irreducible
- * polynomial f(r), where f(r)=r^8 + r^7 + r^2 + r + 1.  A polynomial
- * is represented as a byte with the MSB as the coefficient of r^7 and
- * the LSB as the coefficient of r^0.  For example, the binary
- * representation of f(x) is 0x187 (of course, this doesn't fit into 8
- * bits).  In this field, the polynomial r is a primitive element.
- * That is, r^i with i in 0,...,255 enumerates all elements in the
- * field.
- *
- * The generator polynomial for the QIC-80 ECC is
- *
- *      g(x) = x^3 + r^105*x^2 + r^105*x + 1
- *
- * which can be factored into:
- *
- *      g(x) = (x-r^-1)(x-r^0)(x-r^1)
- *
- * the byte representation of the coefficients are:
- *
- *      r^105 = 0xc0
- *      r^-1  = 0xc3
- *      r^0   = 0x01
- *      r^1   = 0x02
- *
- * Notice that r^-1 = r^254 as exponent arithmetic is performed
- * modulo 2^8-1 = 255.
- *
- * For more information on Galois Fields and Reed-Solomon codes, refer
- * to any good book.  I found _An Introduction to Error Correcting
- * Codes with Applications_ by S. A. Vanstone and P. C. van Oorschot
- * to be a good introduction into the former.  _CODING THEORY: The
- * Essentials_ I found very useful for its concise description of
- * Reed-Solomon encoding/decoding.
- *
- */
-
-typedef __u8 Matrix[3][3];
-
-/*
- * gfpow[] is defined such that gfpow[i] returns r^i if
- * i is in the range [0..255].
- */
-static const __u8 gfpow[] =
-{
-        0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
-        0x87, 0x89, 0x95, 0xad, 0xdd, 0x3d, 0x7a, 0xf4,
-        0x6f, 0xde, 0x3b, 0x76, 0xec, 0x5f, 0xbe, 0xfb,
-        0x71, 0xe2, 0x43, 0x86, 0x8b, 0x91, 0xa5, 0xcd,
-        0x1d, 0x3a, 0x74, 0xe8, 0x57, 0xae, 0xdb, 0x31,
-        0x62, 0xc4, 0x0f, 0x1e, 0x3c, 0x78, 0xf0, 0x67,
-        0xce, 0x1b, 0x36, 0x6c, 0xd8, 0x37, 0x6e, 0xdc,
-        0x3f, 0x7e, 0xfc, 0x7f, 0xfe, 0x7b, 0xf6, 0x6b,
-        0xd6, 0x2b, 0x56, 0xac, 0xdf, 0x39, 0x72, 0xe4,
-        0x4f, 0x9e, 0xbb, 0xf1, 0x65, 0xca, 0x13, 0x26,
-        0x4c, 0x98, 0xb7, 0xe9, 0x55, 0xaa, 0xd3, 0x21,
-        0x42, 0x84, 0x8f, 0x99, 0xb5, 0xed, 0x5d, 0xba,
-        0xf3, 0x61, 0xc2, 0x03, 0x06, 0x0c, 0x18, 0x30,
-        0x60, 0xc0, 0x07, 0x0e, 0x1c, 0x38, 0x70, 0xe0,
-        0x47, 0x8e, 0x9b, 0xb1, 0xe5, 0x4d, 0x9a, 0xb3,
-        0xe1, 0x45, 0x8a, 0x93, 0xa1, 0xc5, 0x0d, 0x1a,
-        0x34, 0x68, 0xd0, 0x27, 0x4e, 0x9c, 0xbf, 0xf9,
-        0x75, 0xea, 0x53, 0xa6, 0xcb, 0x11, 0x22, 0x44,
-        0x88, 0x97, 0xa9, 0xd5, 0x2d, 0x5a, 0xb4, 0xef,
-        0x59, 0xb2, 0xe3, 0x41, 0x82, 0x83, 0x81, 0x85,
-        0x8d, 0x9d, 0xbd, 0xfd, 0x7d, 0xfa, 0x73, 0xe6,
-        0x4b, 0x96, 0xab, 0xd1, 0x25, 0x4a, 0x94, 0xaf,
-        0xd9, 0x35, 0x6a, 0xd4, 0x2f, 0x5e, 0xbc, 0xff,
-        0x79, 0xf2, 0x63, 0xc6, 0x0b, 0x16, 0x2c, 0x58,
-        0xb0, 0xe7, 0x49, 0x92, 0xa3, 0xc1, 0x05, 0x0a,
-        0x14, 0x28, 0x50, 0xa0, 0xc7, 0x09, 0x12, 0x24,
-        0x48, 0x90, 0xa7, 0xc9, 0x15, 0x2a, 0x54, 0xa8,
-        0xd7, 0x29, 0x52, 0xa4, 0xcf, 0x19, 0x32, 0x64,
-        0xc8, 0x17, 0x2e, 0x5c, 0xb8, 0xf7, 0x69, 0xd2,
-        0x23, 0x46, 0x8c, 0x9f, 0xb9, 0xf5, 0x6d, 0xda,
-        0x33, 0x66, 0xcc, 0x1f, 0x3e, 0x7c, 0xf8, 0x77,
-        0xee, 0x5b, 0xb6, 0xeb, 0x51, 0xa2, 0xc3, 0x01
-};
-
-/*
- * This is a log table.  That is, gflog[r^i] returns i (modulo f(r)).
- * gflog[0] is undefined and the first element is therefore not valid.
- */
-static const __u8 gflog[256] =
-{
-        0xff, 0x00, 0x01, 0x63, 0x02, 0xc6, 0x64, 0x6a,
-        0x03, 0xcd, 0xc7, 0xbc, 0x65, 0x7e, 0x6b, 0x2a,
-        0x04, 0x8d, 0xce, 0x4e, 0xc8, 0xd4, 0xbd, 0xe1,
-        0x66, 0xdd, 0x7f, 0x31, 0x6c, 0x20, 0x2b, 0xf3,
-        0x05, 0x57, 0x8e, 0xe8, 0xcf, 0xac, 0x4f, 0x83,
-        0xc9, 0xd9, 0xd5, 0x41, 0xbe, 0x94, 0xe2, 0xb4,
-        0x67, 0x27, 0xde, 0xf0, 0x80, 0xb1, 0x32, 0x35,
-        0x6d, 0x45, 0x21, 0x12, 0x2c, 0x0d, 0xf4, 0x38,
-        0x06, 0x9b, 0x58, 0x1a, 0x8f, 0x79, 0xe9, 0x70,
-        0xd0, 0xc2, 0xad, 0xa8, 0x50, 0x75, 0x84, 0x48,
-        0xca, 0xfc, 0xda, 0x8a, 0xd6, 0x54, 0x42, 0x24,
-        0xbf, 0x98, 0x95, 0xf9, 0xe3, 0x5e, 0xb5, 0x15,
-        0x68, 0x61, 0x28, 0xba, 0xdf, 0x4c, 0xf1, 0x2f,
-        0x81, 0xe6, 0xb2, 0x3f, 0x33, 0xee, 0x36, 0x10,
-        0x6e, 0x18, 0x46, 0xa6, 0x22, 0x88, 0x13, 0xf7,
-        0x2d, 0xb8, 0x0e, 0x3d, 0xf5, 0xa4, 0x39, 0x3b,
-        0x07, 0x9e, 0x9c, 0x9d, 0x59, 0x9f, 0x1b, 0x08,
-        0x90, 0x09, 0x7a, 0x1c, 0xea, 0xa0, 0x71, 0x5a,
-        0xd1, 0x1d, 0xc3, 0x7b, 0xae, 0x0a, 0xa9, 0x91,
-        0x51, 0x5b, 0x76, 0x72, 0x85, 0xa1, 0x49, 0xeb,
-        0xcb, 0x7c, 0xfd, 0xc4, 0xdb, 0x1e, 0x8b, 0xd2,
-        0xd7, 0x92, 0x55, 0xaa, 0x43, 0x0b, 0x25, 0xaf,
-        0xc0, 0x73, 0x99, 0x77, 0x96, 0x5c, 0xfa, 0x52,
-        0xe4, 0xec, 0x5f, 0x4a, 0xb6, 0xa2, 0x16, 0x86,
-        0x69, 0xc5, 0x62, 0xfe, 0x29, 0x7d, 0xbb, 0xcc,
-        0xe0, 0xd3, 0x4d, 0x8c, 0xf2, 0x1f, 0x30, 0xdc,
-        0x82, 0xab, 0xe7, 0x56, 0xb3, 0x93, 0x40, 0xd8,
-        0x34, 0xb0, 0xef, 0x26, 0x37, 0x0c, 0x11, 0x44,
-        0x6f, 0x78, 0x19, 0x9a, 0x47, 0x74, 0xa7, 0xc1,
-        0x23, 0x53, 0x89, 0xfb, 0x14, 0x5d, 0xf8, 0x97,
-        0x2e, 0x4b, 0xb9, 0x60, 0x0f, 0xed, 0x3e, 0xe5,
-        0xf6, 0x87, 0xa5, 0x17, 0x3a, 0xa3, 0x3c, 0xb7
-};
-
-/* This is a multiplication table for the factor 0xc0 (i.e., r^105 (mod f(r)).
- * gfmul_c0[f] returns r^105 * f(r) (modulo f(r)).
- */
-static const __u8 gfmul_c0[256] =
-{
-        0x00, 0xc0, 0x07, 0xc7, 0x0e, 0xce, 0x09, 0xc9,
-        0x1c, 0xdc, 0x1b, 0xdb, 0x12, 0xd2, 0x15, 0xd5,
-        0x38, 0xf8, 0x3f, 0xff, 0x36, 0xf6, 0x31, 0xf1,
-        0x24, 0xe4, 0x23, 0xe3, 0x2a, 0xea, 0x2d, 0xed,
-        0x70, 0xb0, 0x77, 0xb7, 0x7e, 0xbe, 0x79, 0xb9,
-        0x6c, 0xac, 0x6b, 0xab, 0x62, 0xa2, 0x65, 0xa5,
-        0x48, 0x88, 0x4f, 0x8f, 0x46, 0x86, 0x41, 0x81,
-        0x54, 0x94, 0x53, 0x93, 0x5a, 0x9a, 0x5d, 0x9d,
-        0xe0, 0x20, 0xe7, 0x27, 0xee, 0x2e, 0xe9, 0x29,
-        0xfc, 0x3c, 0xfb, 0x3b, 0xf2, 0x32, 0xf5, 0x35,
-        0xd8, 0x18, 0xdf, 0x1f, 0xd6, 0x16, 0xd1, 0x11,
-        0xc4, 0x04, 0xc3, 0x03, 0xca, 0x0a, 0xcd, 0x0d,
-        0x90, 0x50, 0x97, 0x57, 0x9e, 0x5e, 0x99, 0x59,
-        0x8c, 0x4c, 0x8b, 0x4b, 0x82, 0x42, 0x85, 0x45,
-        0xa8, 0x68, 0xaf, 0x6f, 0xa6, 0x66, 0xa1, 0x61,
-        0xb4, 0x74, 0xb3, 0x73, 0xba, 0x7a, 0xbd, 0x7d,
-        0x47, 0x87, 0x40, 0x80, 0x49, 0x89, 0x4e, 0x8e,
-        0x5b, 0x9b, 0x5c, 0x9c, 0x55, 0x95, 0x52, 0x92,
-        0x7f, 0xbf, 0x78, 0xb8, 0x71, 0xb1, 0x76, 0xb6,
-        0x63, 0xa3, 0x64, 0xa4, 0x6d, 0xad, 0x6a, 0xaa,
-        0x37, 0xf7, 0x30, 0xf0, 0x39, 0xf9, 0x3e, 0xfe,
-        0x2b, 0xeb, 0x2c, 0xec, 0x25, 0xe5, 0x22, 0xe2,
-        0x0f, 0xcf, 0x08, 0xc8, 0x01, 0xc1, 0x06, 0xc6,
-        0x13, 0xd3, 0x14, 0xd4, 0x1d, 0xdd, 0x1a, 0xda,
-        0xa7, 0x67, 0xa0, 0x60, 0xa9, 0x69, 0xae, 0x6e,
-        0xbb, 0x7b, 0xbc, 0x7c, 0xb5, 0x75, 0xb2, 0x72,
-        0x9f, 0x5f, 0x98, 0x58, 0x91, 0x51, 0x96, 0x56,
-        0x83, 0x43, 0x84, 0x44, 0x8d, 0x4d, 0x8a, 0x4a,
-        0xd7, 0x17, 0xd0, 0x10, 0xd9, 0x19, 0xde, 0x1e,
-        0xcb, 0x0b, 0xcc, 0x0c, 0xc5, 0x05, 0xc2, 0x02,
-        0xef, 0x2f, 0xe8, 0x28, 0xe1, 0x21, 0xe6, 0x26,
-        0xf3, 0x33, 0xf4, 0x34, 0xfd, 0x3d, 0xfa, 0x3a
-};
-
-
-/* Returns V modulo 255 provided V is in the range -255,-254,...,509.
- */
-static inline __u8 mod255(int v)
-{
-        if (v > 0) {
-                if (v < 255) {
-                        return v;
-                } else {
-                        return v - 255;
-                }
-        } else {
-                return v + 255;
-        }
-}
-
-
-/* Add two numbers in the field.  Addition in this field is equivalent
- * to a bit-wise exclusive OR operation---subtraction is therefore
- * identical to addition.
- */
-static inline __u8 gfadd(__u8 a, __u8 b)
-{
-        return a ^ b;
-}
-
-
-/* Add two vectors of numbers in the field.  Each byte in A and B gets
- * added individually.
- */
-static inline unsigned long gfadd_long(unsigned long a, unsigned long b)
-{
-        return a ^ b;
-}
-
-
-/* Multiply two numbers in the field:
- */
-static inline __u8 gfmul(__u8 a, __u8 b)
-{
-        if (a && b) {
-                return gfpow[mod255(gflog[a] + gflog[b])];
-        } else {
-                return 0;
-        }
-}
-
-
-/* Just like gfmul, except we have already looked up the log of the
- * second number.
- */
-static inline __u8 gfmul_exp(__u8 a, int b)
-{
-        if (a) {
-                return gfpow[mod255(gflog[a] + b)];
-        } else {
-                return 0;
-        }
-}
-
-
-/* Just like gfmul_exp, except that A is a vector of numbers.  That
- * is, each byte in A gets multiplied by gfpow[mod255(B)].
- */
-static inline unsigned long gfmul_exp_long(unsigned long a, int b)
-{
-        __u8 t;
-
-        if (sizeof(long) == 4) {
-                return (
-                ((t = (__u32)a >> 24 & 0xff) ?
-                 (((__u32) gfpow[mod255(gflog[t] + b)]) << 24) : 0) |
-                ((t = (__u32)a >> 16 & 0xff) ?
-                 (((__u32) gfpow[mod255(gflog[t] + b)]) << 16) : 0) |
-                ((t = (__u32)a >> 8 & 0xff) ?
-                 (((__u32) gfpow[mod255(gflog[t] + b)]) << 8) : 0) |
-                ((t = (__u32)a >> 0 & 0xff) ?
-                 (((__u32) gfpow[mod255(gflog[t] + b)]) << 0) : 0));
-        } else if (sizeof(long) == 8) {
-                return (
-                ((t = (__u64)a >> 56 & 0xff) ?
-                 (((__u64) gfpow[mod255(gflog[t] + b)]) << 56) : 0) |
-                ((t = (__u64)a >> 48 & 0xff) ?
-                 (((__u64) gfpow[mod255(gflog[t] + b)]) << 48) : 0) |
-                ((t = (__u64)a >> 40 & 0xff) ?
-                 (((__u64) gfpow[mod255(gflog[t] + b)]) << 40) : 0) |
-                ((t = (__u64)a >> 32 & 0xff) ?
-                 (((__u64) gfpow[mod255(gflog[t] + b)]) << 32) : 0) |
-                ((t = (__u64)a >> 24 & 0xff) ?
-                 (((__u64) gfpow[mod255(gflog[t] + b)]) << 24) : 0) |
-                ((t = (__u64)a >> 16 & 0xff) ?
-                 (((__u64) gfpow[mod255(gflog[t] + b)]) << 16) : 0) |
-                ((t = (__u64)a >> 8 & 0xff) ?
-                 (((__u64) gfpow[mod255(gflog[t] + b)]) << 8) : 0) |
-                ((t = (__u64)a >> 0 & 0xff) ?
-                 (((__u64) gfpow[mod255(gflog[t] + b)]) << 0) : 0));
-        } else {
-                TRACE_FUN(ft_t_any);
-                TRACE_ABORT(-1, ft_t_err, "Error: size of long is %d bytes",
-                            (int)sizeof(long));
-        }
-}
-
-
-/* Divide two numbers in the field.  Returns a/b (modulo f(x)).
- */
-static inline __u8 gfdiv(__u8 a, __u8 b)
-{
-        if (!b) {
-                TRACE_FUN(ft_t_any);
-                TRACE_ABORT(0xff, ft_t_bug, "Error: division by zero");
-        } else if (a == 0) {
-                return 0;
-        } else {
-                return gfpow[mod255(gflog[a] - gflog[b])];
-        }
-}
-
-
-/* The following functions return the inverse of the matrix of the
- * linear system that needs to be solved to determine the error
- * magnitudes.  The first deals with matrices of rank 3, while the
- * second deals with matrices of rank 2.  The error indices are passed
- * in arguments L0,..,L2 (0=first sector, 31=last sector).  The error
- * indices must be sorted in ascending order, i.e., L0<L1<L2.
- *
- * The linear system that needs to be solved for the error magnitudes
- * is A * b = s, where s is the known vector of syndromes, b is the
- * vector of error magnitudes and A in the ORDER=3 case:
- *
- *    A_3 = {{1/r^L[0], 1/r^L[1], 1/r^L[2]},
- *          {        1,        1,        1},
- *          { r^L[0], r^L[1], r^L[2]}} 
- */
-static inline int gfinv3(__u8 l0,
-                         __u8 l1, 
-                         __u8 l2, 
-                         Matrix Ainv)
-{
-        __u8 det;
-        __u8 t20, t10, t21, t12, t01, t02;
-        int log_det;
-
-        /* compute some intermediate results: */
-        t20 = gfpow[l2 - l0];           /* t20 = r^l2/r^l0 */
-        t10 = gfpow[l1 - l0];           /* t10 = r^l1/r^l0 */
-        t21 = gfpow[l2 - l1];           /* t21 = r^l2/r^l1 */
-        t12 = gfpow[l1 - l2 + 255];     /* t12 = r^l1/r^l2 */
-        t01 = gfpow[l0 - l1 + 255];     /* t01 = r^l0/r^l1 */
-        t02 = gfpow[l0 - l2 + 255];     /* t02 = r^l0/r^l2 */
-        /* Calculate the determinant of matrix A_3^-1 (sometimes
-         * called the Vandermonde determinant):
-         */
-        det = gfadd(t20, gfadd(t10, gfadd(t21, gfadd(t12, gfadd(t01, t02)))));
-        if (!det) {
-                TRACE_FUN(ft_t_any);
-                TRACE_ABORT(0, ft_t_err,
-                           "Inversion failed (3 CRC errors, >0 CRC failures)");
-        }
-        log_det = 255 - gflog[det];
-
-        /* Now, calculate all of the coefficients:
-         */
-        Ainv[0][0]= gfmul_exp(gfadd(gfpow[l1], gfpow[l2]), log_det);
-        Ainv[0][1]= gfmul_exp(gfadd(t21, t12), log_det);
-        Ainv[0][2]= gfmul_exp(gfadd(gfpow[255 - l1], gfpow[255 - l2]),log_det);
-
-        Ainv[1][0]= gfmul_exp(gfadd(gfpow[l0], gfpow[l2]), log_det);
-        Ainv[1][1]= gfmul_exp(gfadd(t20, t02), log_det);
-        Ainv[1][2]= gfmul_exp(gfadd(gfpow[255 - l0], gfpow[255 - l2]),log_det);
-
-        Ainv[2][0]= gfmul_exp(gfadd(gfpow[l0], gfpow[l1]), log_det);
-        Ainv[2][1]= gfmul_exp(gfadd(t10, t01), log_det);
-        Ainv[2][2]= gfmul_exp(gfadd(gfpow[255 - l0], gfpow[255 - l1]),log_det);
-
-        return 1;
-}
-
-
-static inline int gfinv2(__u8 l0, __u8 l1, Matrix Ainv)
-{
-        __u8 det;
-        __u8 t1, t2;
-        int log_det;
-
-        t1 = gfpow[255 - l0];
-        t2 = gfpow[255 - l1];
-        det = gfadd(t1, t2);
-        if (!det) {
-                TRACE_FUN(ft_t_any);
-                TRACE_ABORT(0, ft_t_err,
-                           "Inversion failed (2 CRC errors, >0 CRC failures)");
-        }
-        log_det = 255 - gflog[det];
-
-        /* Now, calculate all of the coefficients:
-         */
-        Ainv[0][0] = Ainv[1][0] = gfpow[log_det];
-
-        Ainv[0][1] = gfmul_exp(t2, log_det);
-        Ainv[1][1] = gfmul_exp(t1, log_det);
-
-        return 1;
-}
-
-
-/* Multiply matrix A by vector S and return result in vector B.  M is
- * assumed to be of order NxN, S and B of order Nx1.
- */
-static inline void gfmat_mul(int n, Matrix A, 
-                             __u8 *s, __u8 *b)
-{
-        int i, j;
-        __u8 dot_prod;
-
-        for (i = 0; i < n; ++i) {
-                dot_prod = 0;
-                for (j = 0; j < n; ++j) {
-                        dot_prod = gfadd(dot_prod, gfmul(A[i][j], s[j]));
-                }
-                b[i] = dot_prod;
-        }
-}
-
-
-
-/* The Reed Solomon ECC codes are computed over the N-th byte of each
- * block, where N=SECTOR_SIZE.  There are up to 29 blocks of data, and
- * 3 blocks of ECC.  The blocks are stored contiguously in memory.  A
- * segment, consequently, is assumed to have at least 4 blocks: one or
- * more data blocks plus three ECC blocks.
- *
- * Notice: In QIC-80 speak, a CRC error is a sector with an incorrect
- *         CRC.  A CRC failure is a sector with incorrect data, but
- *         a valid CRC.  In the error control literature, the former
- *         is usually called "erasure", the latter "error."
- */
-/* Compute the parity bytes for C columns of data, where C is the
- * number of bytes that fit into a long integer.  We use a linear
- * feed-back register to do this.  The parity bytes P[0], P[STRIDE],
- * P[2*STRIDE] are computed such that:
- *
- *              x^k * p(x) + m(x) = 0 (modulo g(x))
- *
- * where k = NBLOCKS,
- *       p(x) = P[0] + P[STRIDE]*x + P[2*STRIDE]*x^2, and
- *       m(x) = sum_{i=0}^k m_i*x^i.
- *       m_i = DATA[i*SECTOR_SIZE]
- */
-static inline void set_parity(unsigned long *data,
-                              int nblocks, 
-                              unsigned long *p, 
-                              int stride)
-{
-        unsigned long p0, p1, p2, t1, t2, *end;
-
-        end = data + nblocks * (FT_SECTOR_SIZE / sizeof(long));
-        p0 = p1 = p2 = 0;
-        while (data < end) {
-                /* The new parity bytes p0_i, p1_i, p2_i are computed
-                 * from the old values p0_{i-1}, p1_{i-1}, p2_{i-1}
-                 * recursively as:
-                 *
-                 *        p0_i = p1_{i-1} + r^105 * (m_{i-1} - p0_{i-1})
-                 *        p1_i = p2_{i-1} + r^105 * (m_{i-1} - p0_{i-1})
-                 *        p2_i =                    (m_{i-1} - p0_{i-1})
-                 *
-                 * With the initial condition: p0_0 = p1_0 = p2_0 = 0.
-                 */
-                t1 = gfadd_long(*data, p0);
-                /*
-                 * Multiply each byte in t1 by 0xc0:
-                 */
-                if (sizeof(long) == 4) {
-                        t2= (((__u32) gfmul_c0[(__u32)t1 >> 24 & 0xff]) << 24 |
-                             ((__u32) gfmul_c0[(__u32)t1 >> 16 & 0xff]) << 16 |
-                             ((__u32) gfmul_c0[(__u32)t1 >>  8 & 0xff]) <<  8 |
-                             ((__u32) gfmul_c0[(__u32)t1 >>  0 & 0xff]) <<  0);
-                } else if (sizeof(long) == 8) {
-                        t2= (((__u64) gfmul_c0[(__u64)t1 >> 56 & 0xff]) << 56 |
-                             ((__u64) gfmul_c0[(__u64)t1 >> 48 & 0xff]) << 48 |
-                             ((__u64) gfmul_c0[(__u64)t1 >> 40 & 0xff]) << 40 |
-                             ((__u64) gfmul_c0[(__u64)t1 >> 32 & 0xff]) << 32 |
-                             ((__u64) gfmul_c0[(__u64)t1 >> 24 & 0xff]) << 24 |
-                             ((__u64) gfmul_c0[(__u64)t1 >> 16 & 0xff]) << 16 |
-                             ((__u64) gfmul_c0[(__u64)t1 >>  8 & 0xff]) <<  8 |
-                             ((__u64) gfmul_c0[(__u64)t1 >>  0 & 0xff]) <<  0);
-                } else {
-                        TRACE_FUN(ft_t_any);
-                        TRACE(ft_t_err, "Error: long is of size %d",
-                              (int) sizeof(long));
-                        TRACE_EXIT;
-                }
-                p0 = gfadd_long(t2, p1);
-                p1 = gfadd_long(t2, p2);
-                p2 = t1;
-                data += FT_SECTOR_SIZE / sizeof(long);
-        }
-        *p = p0;
-        p += stride;
-        *p = p1;
-        p += stride;
-        *p = p2;
-        return;
-}
-
-
-/* Compute the 3 syndrome values.  DATA should point to the first byte
- * of the column for which the syndromes are desired.  The syndromes
- * are computed over the first NBLOCKS of rows.  The three bytes will
- * be placed in S[0], S[1], and S[2].
- *
- * S[i] is the value of the "message" polynomial m(x) evaluated at the
- * i-th root of the generator polynomial g(x).
- *
- * As g(x)=(x-r^-1)(x-1)(x-r^1) we evaluate the message polynomial at
- * x=r^-1 to get S[0], at x=r^0=1 to get S[1], and at x=r to get S[2].
- * This could be done directly and efficiently via the Horner scheme.
- * However, it would require multiplication tables for the factors
- * r^-1 (0xc3) and r (0x02).  The following scheme does not require
- * any multiplication tables beyond what's needed for set_parity()
- * anyway and is slightly faster if there are no errors and slightly
- * slower if there are errors.  The latter is hopefully the infrequent
- * case.
- *
- * To understand the alternative algorithm, notice that set_parity(m,
- * k, p) computes parity bytes such that:
- *
- *      x^k * p(x) = m(x) (modulo g(x)).
- *
- * That is, to evaluate m(r^m), where r^m is a root of g(x), we can
- * simply evaluate (r^m)^k*p(r^m).  Also, notice that p is 0 if and
- * only if s is zero.  That is, if all parity bytes are 0, we know
- * there is no error in the data and consequently there is no need to
- * compute s(x) at all!  In all other cases, we compute s(x) from p(x)
- * by evaluating (r^m)^k*p(r^m) for m=-1, m=0, and m=1.  The p(x)
- * polynomial is evaluated via the Horner scheme.
- */
-static int compute_syndromes(unsigned long *data, int nblocks, unsigned long *s)
-{
-        unsigned long p[3];
-
-        set_parity(data, nblocks, p, 1);
-        if (p[0] | p[1] | p[2]) {
-                /* Some of the checked columns do not have a zero
-                 * syndrome.  For simplicity, we compute the syndromes
-                 * for all columns that we have computed the
-                 * remainders for.
-                 */
-                s[0] = gfmul_exp_long(
-                        gfadd_long(p[0], 
-                                   gfmul_exp_long(
-                                           gfadd_long(p[1], 
-                                                      gfmul_exp_long(p[2], -1)),
-                                           -1)), 
-                        -nblocks);
-                s[1] = gfadd_long(gfadd_long(p[2], p[1]), p[0]);
-                s[2] = gfmul_exp_long(
-                        gfadd_long(p[0], 
-                                   gfmul_exp_long(
-                                           gfadd_long(p[1],
-                                                      gfmul_exp_long(p[2], 1)),
-                                           1)),
-                        nblocks);
-                return 0;
-        } else {
-                return 1;
-        }
-}
-
-
-/* Correct the block in the column pointed to by DATA.  There are NBAD
- * CRC errors and their indices are in BAD_LOC[0], up to
- * BAD_LOC[NBAD-1].  If NBAD>1, Ainv holds the inverse of the matrix
- * of the linear system that needs to be solved to determine the error
- * magnitudes.  S[0], S[1], and S[2] are the syndrome values.  If row
- * j gets corrected, then bit j will be set in CORRECTION_MAP.
- */
-static inline int correct_block(__u8 *data, int nblocks,
-                                int nbad, int *bad_loc, Matrix Ainv,
-                                __u8 *s,
-                                SectorMap * correction_map)
-{
-        int ncorrected = 0;
-        int i;
-        __u8 t1, t2;
-        __u8 c0, c1, c2;        /* check bytes */
-        __u8 error_mag[3], log_error_mag;
-        __u8 *dp, l, e;
-        TRACE_FUN(ft_t_any);
-
-        switch (nbad) {
-        case 0:
-                /* might have a CRC failure: */
-                if (s[0] == 0) {
-                        /* more than one error */
-                        TRACE_ABORT(-1, ft_t_err,
-                                 "ECC failed (0 CRC errors, >1 CRC failures)");
-                }
-                t1 = gfdiv(s[1], s[0]);
-                if ((bad_loc[nbad++] = gflog[t1]) >= nblocks) {
-                        TRACE(ft_t_err,
-                              "ECC failed (0 CRC errors, >1 CRC failures)");
-                        TRACE_ABORT(-1, ft_t_err,
-                                  "attempt to correct data at %d", bad_loc[0]);
-                }
-                error_mag[0] = s[1];
-                break;
-        case 1:
-                t1 = gfadd(gfmul_exp(s[1], bad_loc[0]), s[2]);
-                t2 = gfadd(gfmul_exp(s[0], bad_loc[0]), s[1]);
-                if (t1 == 0 && t2 == 0) {
-                        /* one erasure, no error: */
-                        Ainv[0][0] = gfpow[bad_loc[0]];
-                } else if (t1 == 0 || t2 == 0) {
-                        /* one erasure and more than one error: */
-                        TRACE_ABORT(-1, ft_t_err,
-                                    "ECC failed (1 erasure, >1 error)");
-                } else {
-                        /* one erasure, one error: */
-                        if ((bad_loc[nbad++] = gflog[gfdiv(t1, t2)]) 
-                            >= nblocks) {
-                                TRACE(ft_t_err, "ECC failed "
-                                      "(1 CRC errors, >1 CRC failures)");
-                                TRACE_ABORT(-1, ft_t_err,
-                                            "attempt to correct data at %d",
-                                            bad_loc[1]);
-                        }
-                        if (!gfinv2(bad_loc[0], bad_loc[1], Ainv)) {
-                                /* inversion failed---must have more
-                                 *  than one error 
-                                 */
-                                TRACE_EXIT -1;
-                        }
-                }
-                /* FALL THROUGH TO ERROR MAGNITUDE COMPUTATION:
-                 */
-        case 2:
-        case 3:
-                /* compute error magnitudes: */
-                gfmat_mul(nbad, Ainv, s, error_mag);
-                break;
-
-        default:
-                TRACE_ABORT(-1, ft_t_err,
-                            "Internal Error: number of CRC errors > 3");
-        }
-
-        /* Perform correction by adding ERROR_MAG[i] to the byte at
-         * offset BAD_LOC[i].  Also add the value of the computed
-         * error polynomial to the syndrome values.  If the correction
-         * was successful, the resulting check bytes should be zero
-         * (i.e., the corrected data is a valid code word).
-         */
-        c0 = s[0];
-        c1 = s[1];
-        c2 = s[2];
-        for (i = 0; i < nbad; ++i) {
-                e = error_mag[i];
-                if (e) {
-                        /* correct the byte at offset L by magnitude E: */
-                        l = bad_loc[i];
-                        dp = &data[l * FT_SECTOR_SIZE];
-                        *dp = gfadd(*dp, e);
-                        *correction_map |= 1 << l;
-                        ++ncorrected;
-
-                        log_error_mag = gflog[e];
-                        c0 = gfadd(c0, gfpow[mod255(log_error_mag - l)]);
-                        c1 = gfadd(c1, e);
-                        c2 = gfadd(c2, gfpow[mod255(log_error_mag + l)]);
-                }
-        }
-        if (c0 || c1 || c2) {
-                TRACE_ABORT(-1, ft_t_err,
-                            "ECC self-check failed, too many errors");
-        }
-        TRACE_EXIT ncorrected;
-}
-
-
-#if defined(ECC_SANITY_CHECK) || defined(ECC_PARANOID)
-
-/* Perform a sanity check on the computed parity bytes:
- */
-static int sanity_check(unsigned long *data, int nblocks)
-{
-        TRACE_FUN(ft_t_any);
-        unsigned long s[3];
-
-        if (!compute_syndromes(data, nblocks, s)) {
-                TRACE_ABORT(0, ft_bug,
-                            "Internal Error: syndrome self-check failed");
-        }
-        TRACE_EXIT 1;
-}
-
-#endif /* defined(ECC_SANITY_CHECK) || defined(ECC_PARANOID) */
-
-/* Compute the parity for an entire segment of data.
- */
-int ftape_ecc_set_segment_parity(struct memory_segment *mseg)
-{
-        int i;
-        __u8 *parity_bytes;
-
-        parity_bytes = &mseg->data[(mseg->blocks - 3) * FT_SECTOR_SIZE];
-        for (i = 0; i < FT_SECTOR_SIZE; i += sizeof(long)) {
-                set_parity((unsigned long *) &mseg->data[i], mseg->blocks - 3,
-                           (unsigned long *) &parity_bytes[i],
-                           FT_SECTOR_SIZE / sizeof(long));
-#ifdef ECC_PARANOID
-                if (!sanity_check((unsigned long *) &mseg->data[i],
-                                   mseg->blocks)) {
-                        return -1;
-                }
-#endif                          /* ECC_PARANOID */
-        }
-        return 0;
-}
-
-
-/* Checks and corrects (if possible) the segment MSEG.  Returns one of
- * ECC_OK, ECC_CORRECTED, and ECC_FAILED.
- */
-int ftape_ecc_correct_data(struct memory_segment *mseg)
-{
-        int col, i, result;
-        int ncorrected = 0;
-        int nerasures = 0;      /* # of erasures (CRC errors) */
-        int erasure_loc[3];     /* erasure locations */
-        unsigned long ss[3];
-        __u8 s[3];
-        Matrix Ainv;
-        TRACE_FUN(ft_t_flow);
-
-        mseg->corrected = 0;
-
-        /* find first column that has non-zero syndromes: */
-        for (col = 0; col < FT_SECTOR_SIZE; col += sizeof(long)) {
-                if (!compute_syndromes((unsigned long *) &mseg->data[col],
-                                       mseg->blocks, ss)) {
-                        /* something is wrong---have to fix things */
-                        break;
-                }
-        }
-        if (col >= FT_SECTOR_SIZE) {
-                /* all syndromes are ok, therefore nothing to correct */
-                TRACE_EXIT ECC_OK;
-        }
-        /* count the number of CRC errors if there were any: */
-        if (mseg->read_bad) {
-                for (i = 0; i < mseg->blocks; i++) {
-                        if (BAD_CHECK(mseg->read_bad, i)) {
-                                if (nerasures >= 3) {
-                                        /* this is too much for ECC */
-                                        TRACE_ABORT(ECC_FAILED, ft_t_err,
-                                                "ECC failed (>3 CRC errors)");
-                                }       /* if */
-                                erasure_loc[nerasures++] = i;
-                        }
-                }
-        }
-        /*
-         * If there are at least 2 CRC errors, determine inverse of matrix
-         * of linear system to be solved:
-         */
-        switch (nerasures) {
-        case 2:
-                if (!gfinv2(erasure_loc[0], erasure_loc[1], Ainv)) {
-                        TRACE_EXIT ECC_FAILED;
-                }
-                break;
-        case 3:
-                if (!gfinv3(erasure_loc[0], erasure_loc[1],
-                            erasure_loc[2], Ainv)) {
-                        TRACE_EXIT ECC_FAILED;
-                }
-                break;
-        default:
-                /* this is not an error condition... */
-                break;
-        }
-
-        do {
-                for (i = 0; i < sizeof(long); ++i) {
-                        s[0] = ss[0];
-                        s[1] = ss[1];
-                        s[2] = ss[2];
-                        if (s[0] | s[1] | s[2]) {
-#ifdef BIG_ENDIAN
-                                result = correct_block(
-                                        &mseg->data[col + sizeof(long) - 1 - i],
-                                        mseg->blocks,
-                                        nerasures,
-                                        erasure_loc,
-                                        Ainv,
-                                        s,
-                                        &mseg->corrected);
-#else
-                                result = correct_block(&mseg->data[col + i],
-                                                       mseg->blocks,
-                                                       nerasures,
-                                                       erasure_loc,
-                                                       Ainv,
-                                                       s,
-                                                       &mseg->corrected);
-#endif
-                                if (result < 0) {
-                                        TRACE_EXIT ECC_FAILED;
-                                }
-                                ncorrected += result;
-                        }
-                        ss[0] >>= 8;
-                        ss[1] >>= 8;
-                        ss[2] >>= 8;
-                }
-
-#ifdef ECC_SANITY_CHECK
-                if (!sanity_check((unsigned long *) &mseg->data[col],
-                                  mseg->blocks)) {
-                        TRACE_EXIT ECC_FAILED;
-                }
-#endif                          /* ECC_SANITY_CHECK */
-
-                /* find next column with non-zero syndromes: */
-                while ((col += sizeof(long)) < FT_SECTOR_SIZE) {
-                        if (!compute_syndromes((unsigned long *)
-                                    &mseg->data[col], mseg->blocks, ss)) {
-                                /* something is wrong---have to fix things */
-                                break;
-                        }
-                }
-        } while (col < FT_SECTOR_SIZE);
-        if (ncorrected && nerasures == 0) {
-                TRACE(ft_t_warn, "block contained error not caught by CRC");
-        }
-        TRACE((ncorrected > 0) ? ft_t_noise : ft_t_any, "number of corrections: %d", ncorrected);
-        TRACE_EXIT ncorrected ? ECC_CORRECTED : ECC_OK;
-}
diff --git a/drivers/char/ftape/lowlevel/ftape-ecc.h b/drivers/char/ftape/lowlevel/ftape-ecc.h
deleted file mode 100644
index 4829146fe9a0..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-ecc.h
+++ /dev/null
@@ -1,84 +0,0 @@
-#ifndef _FTAPE_ECC_H_
-#define _FTAPE_ECC_H_
-
-/*
- *      Copyright (C) 1993 Ning and David Mosberger.
- *      Original:
- *      Copyright (C) 1993 Bas Laarhoven.
- *      Copyright (C) 1992 David L. Brown, Jr.
- 
- This program is free software; you can redistribute it and/or
- modify it under the terms of the GNU General Public License as
- published by the Free Software Foundation; either version 2, or (at
- your option) any later version.
- 
- This program is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- General Public License for more details.
- 
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
- USA.
- 
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-ecc.h,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:18:11 $
- *
- *      This file contains the definitions for the
- *      Reed-Solomon error correction code 
- *      for the QIC-40/80 tape streamer device driver.
- */
-
-#include "../lowlevel/ftape-bsm.h"
-
-#define BAD_CLEAR(entry) ((entry)=0)
-#define BAD_SET(entry,sector) ((entry)|=(1<<(sector)))
-#define BAD_CHECK(entry,sector) ((entry)&(1<<(sector)))
-
-/*
- * Return values for ecc_correct_data:
- */
-enum {
-        ECC_OK,                 /* Data was correct. */
-        ECC_CORRECTED,          /* Correctable error in data. */
-        ECC_FAILED,             /* Could not correct data. */
-};
-
-/*
- * Representation of an in memory segment.  MARKED_BAD lists the
- * sectors that were marked bad during formatting.  If the N-th sector
- * in a segment is marked bad, bit 1<<N will be set in MARKED_BAD.
- * The sectors should be read in from the disk and packed, as if the
- * bad sectors were not there, and the segment just contained fewer
- * sectors.  READ_SECTORS is a bitmap of errors encountered while
- * reading the data.  These offsets are relative to the packed data.
- * BLOCKS is a count of the sectors not marked bad.  This is just to
- * prevent having to count the zero bits in MARKED_BAD each time this
- * is needed.  DATA is the actual sector packed data from (or to) the
- * tape.
- */
- struct memory_segment {
-        SectorMap marked_bad;
-        SectorMap read_bad;
-        int blocks;
-        __u8 *data;
-        SectorMap corrected;
- };
-
-/*
- * ecc.c defined global variables:
- */
-#ifdef TEST
-extern int ftape_ecc_tracing;
-#endif
-
-/*
- * ecc.c defined global functions:
- */
-extern int ftape_ecc_correct_data(struct memory_segment *data);
-extern int ftape_ecc_set_segment_parity(struct memory_segment *data);
-
-#endif  /* _FTAPE_ECC_H_ */
diff --git a/drivers/char/ftape/lowlevel/ftape-format.c b/drivers/char/ftape/lowlevel/ftape-format.c
deleted file mode 100644
index 5dd4c59a3f34..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-format.c
+++ /dev/null
@@ -1,344 +0,0 @@
-/*
- * Copyright (C) 1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-format.c,v $
- * $Revision: 1.2.4.1 $
- * $Date: 1997/11/14 16:05:39 $
- *
- *      This file contains the code to support formatting of floppy
- *      tape cartridges with the QIC-40/80/3010/3020 floppy-tape
- *      driver "ftape" for Linux.
- */
- 
-#include <linux/string.h>
-#include <linux/errno.h>
-
-#include <linux/ftape.h>
-#include <linux/qic117.h>
-#include "../lowlevel/ftape-tracing.h"
-#include "../lowlevel/ftape-io.h"
-#include "../lowlevel/ftape-ctl.h"
-#include "../lowlevel/ftape-rw.h"
-#include "../lowlevel/ftape-ecc.h"
-#include "../lowlevel/ftape-bsm.h"
-#include "../lowlevel/ftape-format.h"
-
-#if defined(TESTING)
-#define FT_FMT_SEGS_PER_BUF 50
-#else
-#define FT_FMT_SEGS_PER_BUF (FT_BUFF_SIZE/(4*FT_SECTORS_PER_SEGMENT))
-#endif
-
-static spinlock_t ftape_format_lock;
-
-/*
- *  first segment of the new buffer
- */
-static int switch_segment;
-
-/*
- *  at most 256 segments fit into one 32 kb buffer.  Even TR-1 cartridges have
- *  more than this many segments per track, so better be careful.
- *
- *  buffer_struct *buff: buffer to store the formatting coordinates in
- *  int  start: starting segment for this buffer.
- *  int    spt: segments per track
- *
- *  Note: segment ids are relative to the start of the track here.
- */
-static void setup_format_buffer(buffer_struct *buff, int start, int spt,
-                                __u8 gap3)
-{
-        int to_do = spt - start;
-        TRACE_FUN(ft_t_flow);
-
-        if (to_do > FT_FMT_SEGS_PER_BUF) {
-                to_do = FT_FMT_SEGS_PER_BUF;
-        }
-        buff->ptr          = buff->address;
-        buff->remaining    = to_do * FT_SECTORS_PER_SEGMENT; /* # sectors */
-        buff->bytes        = buff->remaining * 4; /* need 4 bytes per sector */
-        buff->gap3         = gap3;
-        buff->segment_id   = start;
-        buff->next_segment = start + to_do;
-        if (buff->next_segment >= spt) {
-                buff->next_segment = 0; /* 0 means: stop runner */
-        }
-        buff->status       = waiting; /* tells the isr that it can use
-                                       * this buffer
-                                       */
-        TRACE_EXIT;
-}
-
-
-/*
- *  start formatting a new track.
- */
-int ftape_format_track(const unsigned int track, const __u8 gap3)
-{
-        unsigned long flags;
-        buffer_struct *tail, *head;
-        int status;
-        TRACE_FUN(ft_t_flow);
-
-        TRACE_CATCH(ftape_ready_wait(ftape_timeout.pause, &status),);
-        if (track & 1) {
-                if (!(status & QIC_STATUS_AT_EOT)) {
-                        TRACE_CATCH(ftape_seek_to_eot(),);
-                }
-        } else {
-                if (!(status & QIC_STATUS_AT_BOT)) {
-                        TRACE_CATCH(ftape_seek_to_bot(),);
-                }
-        }
-        ftape_abort_operation(); /* this sets ft_head = ft_tail = 0 */
-        ftape_set_state(formatting);
-
-        TRACE(ft_t_noise,
-              "Formatting track %d, logical: from segment %d to %d",
-              track, track * ft_segments_per_track, 
-              (track + 1) * ft_segments_per_track - 1);
-        
-        /*
-         *  initialize the buffer switching protocol for this track
-         */
-        head = ftape_get_buffer(ft_queue_head); /* tape isn't running yet */
-        tail = ftape_get_buffer(ft_queue_tail); /* tape isn't running yet */
-        switch_segment = 0;
-        do {
-                FT_SIGNAL_EXIT(_DONT_BLOCK);
-                setup_format_buffer(tail, switch_segment,
-                                    ft_segments_per_track, gap3);
-                switch_segment = tail->next_segment;
-        } while ((switch_segment != 0) &&
-                 ((tail = ftape_next_buffer(ft_queue_tail)) != head));
-        /* go */
-        head->status = formatting;
-        TRACE_CATCH(ftape_seek_head_to_track(track),);
-        TRACE_CATCH(ftape_command(QIC_LOGICAL_FORWARD),);
-        spin_lock_irqsave(&ftape_format_lock, flags);
-        TRACE_CATCH(fdc_setup_formatting(head), restore_flags(flags));
-        spin_unlock_irqrestore(&ftape_format_lock, flags);
-        TRACE_EXIT 0;
-}
-
-/*   return segment id of segment currently being formatted and do the
- *   buffer switching stuff.
- */
-int ftape_format_status(unsigned int *segment_id)
-{
-        buffer_struct *tail = ftape_get_buffer(ft_queue_tail);
-        int result;
-        TRACE_FUN(ft_t_flow);
-
-        while (switch_segment != 0 &&
-               ftape_get_buffer(ft_queue_head) != tail) {
-                FT_SIGNAL_EXIT(_DONT_BLOCK);
-                /*  need more buffers, first wait for empty buffer
-                 */
-                TRACE_CATCH(ftape_wait_segment(formatting),);
-                /*  don't worry for gap3. If we ever hit this piece of code,
-                 *  then all buffer already have the correct gap3 set!
-                 */
-                setup_format_buffer(tail, switch_segment,
-                                    ft_segments_per_track, tail->gap3);
-                switch_segment = tail->next_segment;
-                if (switch_segment != 0) {
-                        tail = ftape_next_buffer(ft_queue_tail);
-                }
-        }
-        /*    should runner stop ?
-         */
-        if (ft_runner_status == aborting || ft_runner_status == do_abort) {
-                buffer_struct *head = ftape_get_buffer(ft_queue_head);
-                TRACE(ft_t_warn, "Error formatting segment %d",
-                      ftape_get_buffer(ft_queue_head)->segment_id);
-                (void)ftape_abort_operation();
-                TRACE_EXIT (head->status != error) ? -EAGAIN : -EIO;
-        }
-        /*
-         *  don't care if the timer expires, this is just kind of a
-         *  "select" operation that lets the calling process sleep
-         *  until something has happened
-         */
-        if (fdc_interrupt_wait(5 * FT_SECOND) < 0) {
-                TRACE(ft_t_noise, "End of track %d at segment %d",
-                      ft_location.track,
-                      ftape_get_buffer(ft_queue_head)->segment_id);
-                result = 1;  /* end of track, unlock module */
-        } else {
-                result = 0;
-        }
-        /*
-         *  the calling process should use the seg id to determine
-         *  which parts of the dma buffers can be safely overwritten
-         *  with new data.
-         */
-        *segment_id = ftape_get_buffer(ft_queue_head)->segment_id;
-        /*
-         *  Internally we start counting segment ids from the start of
-         *  each track when formatting, but externally we keep them
-         *  relative to the start of the tape:
-         */
-        *segment_id += ft_location.track * ft_segments_per_track;
-        TRACE_EXIT result;
-}
-
-/*
- *  The segment id is relative to the start of the tape
- */
-int ftape_verify_segment(const unsigned int segment_id, SectorMap *bsm)
-{
-        int result;
-        int verify_done = 0;
-        TRACE_FUN(ft_t_flow);
-
-        TRACE(ft_t_noise, "Verifying segment %d", segment_id);
-
-        if (ft_driver_state != verifying) {
-                TRACE(ft_t_noise, "calling ftape_abort_operation");
-                if (ftape_abort_operation() < 0) {
-                        TRACE(ft_t_err, "ftape_abort_operation failed");
-                        TRACE_EXIT -EIO;
-                }
-        }
-        *bsm = 0x00000000;
-        ftape_set_state(verifying);
-        for (;;) {
-                buffer_struct *tail;
-                /*
-                 *  Allow escape from this loop on signal
-                 */
-                FT_SIGNAL_EXIT(_DONT_BLOCK);
-                /*
-                 *  Search all full buffers for the first matching the
-                 *  wanted segment.  Clear other buffers on the fly.
-                 */
-                tail = ftape_get_buffer(ft_queue_tail);
-                while (!verify_done && tail->status == done) {
-                        /*
-                         *  Allow escape from this loop on signal !
-                         */
-                        FT_SIGNAL_EXIT(_DONT_BLOCK);
-                        if (tail->segment_id == segment_id) {
-                                /*  If out buffer is already full,
-                                 *  return its contents.  
-                                 */
-                                TRACE(ft_t_flow, "found segment in cache: %d",
-                                      segment_id);
-                                if ((tail->soft_error_map |
-                                     tail->hard_error_map) != 0) {
-                                        TRACE(ft_t_info,"bsm[%d] = 0x%08lx",
-                                              segment_id,
-                                              (unsigned long)
-                                              (tail->soft_error_map |
-                                              tail->hard_error_map));
-                                        *bsm = (tail->soft_error_map |
-                                                tail->hard_error_map);
-                                }
-                                verify_done = 1;
-                        } else {
-                                TRACE(ft_t_flow,"zapping segment in cache: %d",
-                                      tail->segment_id);
-                        }
-                        tail->status = waiting;
-                        tail = ftape_next_buffer(ft_queue_tail);
-                }
-                if (!verify_done && tail->status == verifying) {
-                        if (tail->segment_id == segment_id) {
-                                switch(ftape_wait_segment(verifying)) {
-                                case 0:
-                                        break;
-                                case -EINTR:
-                                        TRACE_ABORT(-EINTR, ft_t_warn,
-                                                    "interrupted by "
-                                                    "non-blockable signal");
-                                        break;
-                                default:
-                                        ftape_abort_operation();
-                                        ftape_set_state(verifying);
-                                        /* be picky */
-                                        TRACE_ABORT(-EIO, ft_t_warn,
-                                                    "wait_segment failed");
-                                }
-                        } else {
-                                /*  We're reading the wrong segment,
-                                 *  stop runner.
-                                 */
-                                TRACE(ft_t_noise, "verifying wrong segment");
-                                ftape_abort_operation();
-                                ftape_set_state(verifying);
-                        }
-                }
-                /*    should runner stop ?
-                 */
-                if (ft_runner_status == aborting) {
-                        buffer_struct *head = ftape_get_buffer(ft_queue_head);
-                        if (head->status == error ||
-                            head->status == verifying) {
-                                /* no data or overrun error */
-                                head->status = waiting;
-                        }
-                        TRACE_CATCH(ftape_dumb_stop(),);
-                } else {
-                        /*  If just passed last segment on tape: wait
-                         *  for BOT or EOT mark. Sets ft_runner_status to
-                         *  idle if at lEOT and successful 
-                         */
-                        TRACE_CATCH(ftape_handle_logical_eot(),);
-                }
-                if (verify_done) {
-                        TRACE_EXIT 0;
-                }
-                /*    Now at least one buffer is idle!
-                 *    Restart runner & tape if needed.
-                 */
-                /*  We could optimize the following a little bit. We know that 
-                 *  the bad sector map is empty.
-                 */
-                tail = ftape_get_buffer(ft_queue_tail);
-                if (tail->status == waiting) {
-                        buffer_struct *head = ftape_get_buffer(ft_queue_head);
-
-                        ftape_setup_new_segment(head, segment_id, -1);
-                        ftape_calc_next_cluster(head);
-                        if (ft_runner_status == idle) {
-                                result = ftape_start_tape(segment_id,
-                                                          head->sector_offset);
-                                switch(result) {
-                                case 0:
-                                        break;
-                                case -ETIME:
-                                case -EINTR:
-                                        TRACE_ABORT(result, ft_t_err, "Error: "
-                                                    "segment %d unreachable",
-                                                    segment_id);
-                                        break;
-                                default:
-                                        *bsm = EMPTY_SEGMENT;
-                                        TRACE_EXIT 0;
-                                        break;
-                                }
-                        }
-                        head->status = verifying;
-                        fdc_setup_read_write(head, FDC_VERIFY);
-                }
-        }
-        /* not reached */
-        TRACE_EXIT -EIO;
-}
diff --git a/drivers/char/ftape/lowlevel/ftape-format.h b/drivers/char/ftape/lowlevel/ftape-format.h
deleted file mode 100644
index f15161566643..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-format.h
+++ /dev/null
@@ -1,37 +0,0 @@
-#ifndef _FTAPE_FORMAT_H
-#define _FTAPE_FORMAT_H
-
-/*
- * Copyright (C) 1996-1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-format.h,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:18:13 $
- *
- *      This file contains the low level definitions for the
- *      formatting support for the QIC-40/80/3010/3020 floppy-tape
- *      driver "ftape" for Linux.
- */
-
-#ifdef __KERNEL__
-extern int ftape_format_track(const unsigned int track, const __u8 gap3);
-extern int ftape_format_status(unsigned int *segment_id);
-extern int ftape_verify_segment(const unsigned int segment_id, SectorMap *bsm);
-#endif /* __KERNEL__ */
-
-#endif
diff --git a/drivers/char/ftape/lowlevel/ftape-init.c b/drivers/char/ftape/lowlevel/ftape-init.c
deleted file mode 100644
index 4998132a81d1..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-init.c
+++ /dev/null
@@ -1,160 +0,0 @@
-/*
- *      Copyright (C) 1993-1996 Bas Laarhoven,
- *                (C) 1996-1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- *      This file contains the code that interfaces the kernel
- *      for the QIC-40/80/3010/3020 floppy-tape driver for Linux.
- */
-
-#include <linux/module.h>
-#include <linux/errno.h>
-#include <linux/fs.h>
-#include <linux/kernel.h>
-#include <linux/signal.h>
-#include <linux/major.h>
-
-#include <linux/ftape.h>
-#include <linux/init.h>
-#include <linux/qic117.h>
-#ifdef CONFIG_ZFTAPE
-#include <linux/zftape.h>
-#endif
-
-#include "../lowlevel/ftape-init.h"
-#include "../lowlevel/ftape-io.h"
-#include "../lowlevel/ftape-read.h"
-#include "../lowlevel/ftape-write.h"
-#include "../lowlevel/ftape-ctl.h"
-#include "../lowlevel/ftape-rw.h"
-#include "../lowlevel/fdc-io.h"
-#include "../lowlevel/ftape-buffer.h"
-#include "../lowlevel/ftape-proc.h"
-#include "../lowlevel/ftape-tracing.h"
-
-
-#if defined(MODULE) && !defined(CONFIG_FT_NO_TRACE_AT_ALL)
-static int ft_tracing = -1;
-#endif
-
-
-/*  Called by modules package when installing the driver
- *  or by kernel during the initialization phase
- */
-static int __init ftape_init(void)
-{
-        TRACE_FUN(ft_t_flow);
-
-#ifdef MODULE
-#ifndef CONFIG_FT_NO_TRACE_AT_ALL
-        if (ft_tracing != -1) {
-                ftape_tracing = ft_tracing;
-        }
-#endif
-        printk(KERN_INFO FTAPE_VERSION "\n");
-        if (TRACE_LEVEL >= ft_t_info) {
-                printk(
-KERN_INFO "(c) 1993-1996 Bas Laarhoven (bas@vimec.nl)\n"
-KERN_INFO "(c) 1995-1996 Kai Harrekilde-Petersen (khp@dolphinics.no)\n"
-KERN_INFO "(c) 1996-1997 Claus-Justus Heine (claus@momo.math.rwth-aachen.de)\n"
-KERN_INFO "QIC-117 driver for QIC-40/80/3010/3020 floppy tape drives\n");
-        }
-#else /* !MODULE */
-        /* print a short no-nonsense boot message */
-        printk(KERN_INFO FTAPE_VERSION "\n");
-#endif /* MODULE */
-        TRACE(ft_t_info, "installing QIC-117 floppy tape hardware drive ... ");
-        TRACE(ft_t_info, "ftape_init @ 0x%p", ftape_init);
-        /*  Allocate the DMA buffers. They are deallocated at cleanup() time.
-         */
-#ifdef TESTING
-#ifdef MODULE
-        while (ftape_set_nr_buffers(CONFIG_FT_NR_BUFFERS) < 0) {
-                ftape_sleep(FT_SECOND/20);
-                if (signal_pending(current)) {
-                        (void)ftape_set_nr_buffers(0);
-                        TRACE(ft_t_bug,
-                              "Killed by signal while allocating buffers.");
-                        TRACE_ABORT(-EINTR, 
-                                    ft_t_bug, "Free up memory and retry");
-                }
-        }
-#else
-        TRACE_CATCH(ftape_set_nr_buffers(CONFIG_FT_NR_BUFFERS),
-                    (void)ftape_set_nr_buffers(0));
-#endif
-#else
-        TRACE_CATCH(ftape_set_nr_buffers(CONFIG_FT_NR_BUFFERS),
-                    (void)ftape_set_nr_buffers(0));
-#endif
-        ft_drive_sel = -1;
-        ft_failure   = 1;         /* inhibit any operation but open */
-        ftape_udelay_calibrate(); /* must be before fdc_wait_calibrate ! */
-        fdc_wait_calibrate();
-#if defined(CONFIG_PROC_FS) && defined(CONFIG_FT_PROC_FS)
-        (void)ftape_proc_init();
-#endif
-#ifdef CONFIG_ZFTAPE
-        (void)zft_init();
-#endif
-        TRACE_EXIT 0;
-}
-
-module_param(ft_fdc_base,       uint, 0);
-MODULE_PARM_DESC(ft_fdc_base,  "Base address of FDC controller.");
-module_param(ft_fdc_irq,        uint, 0);
-MODULE_PARM_DESC(ft_fdc_irq,   "IRQ (interrupt channel) to use.");
-module_param(ft_fdc_dma,        uint, 0);
-MODULE_PARM_DESC(ft_fdc_dma,   "DMA channel to use.");
-module_param(ft_fdc_threshold,  uint, 0);
-MODULE_PARM_DESC(ft_fdc_threshold,  "Threshold of the FDC Fifo.");
-module_param(ft_fdc_rate_limit, uint, 0);
-MODULE_PARM_DESC(ft_fdc_rate_limit, "Maximal data rate for FDC.");
-module_param(ft_probe_fc10,     bool, 0);
-MODULE_PARM_DESC(ft_probe_fc10,
-            "If non-zero, probe for a Colorado FC-10/FC-20 controller.");
-module_param(ft_mach2,          bool, 0);
-MODULE_PARM_DESC(ft_mach2,
-            "If non-zero, probe for a Mountain MACH-2 controller.");
-#if defined(MODULE) && !defined(CONFIG_FT_NO_TRACE_AT_ALL)
-module_param(ft_tracing,        int, 0644);
-MODULE_PARM_DESC(ft_tracing,
-            "Amount of debugging output, 0 <= tracing <= 8, default 3.");
-#endif
-
-MODULE_AUTHOR(
-        "(c) 1993-1996 Bas Laarhoven (bas@vimec.nl), "
-        "(c) 1995-1996 Kai Harrekilde-Petersen (khp@dolphinics.no), "
-        "(c) 1996, 1997 Claus-Justus Heine (claus@momo.math.rwth-aachen.de)");
-MODULE_DESCRIPTION(
-        "QIC-117 driver for QIC-40/80/3010/3020 floppy tape drives.");
-MODULE_LICENSE("GPL");
-
-static void __exit ftape_exit(void)
-{
-        TRACE_FUN(ft_t_flow);
-
-#if defined(CONFIG_PROC_FS) && defined(CONFIG_FT_PROC_FS)
-        ftape_proc_destroy();
-#endif
-        (void)ftape_set_nr_buffers(0);
-        printk(KERN_INFO "ftape: unloaded.\n");
-        TRACE_EXIT;
-}
-
-module_init(ftape_init);
-module_exit(ftape_exit);
diff --git a/drivers/char/ftape/lowlevel/ftape-init.h b/drivers/char/ftape/lowlevel/ftape-init.h
deleted file mode 100644
index 99a7b8ab086f..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-init.h
+++ /dev/null
@@ -1,43 +0,0 @@
-#ifndef _FTAPE_INIT_H
-#define _FTAPE_INIT_H
-
-/*
- * Copyright (C) 1993-1996 Bas Laarhoven,
- *           (C) 1996-1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-init.h,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:18:16 $
- *
- * This file contains the definitions for the interface to 
- * the Linux kernel for floppy tape driver ftape.
- *
- */
-
-#include <linux/linkage.h>
-#include <linux/signal.h>
-
-#define _NEVER_BLOCK    (sigmask(SIGKILL) | sigmask(SIGSTOP))
-#define _DONT_BLOCK     (_NEVER_BLOCK | sigmask(SIGINT))
-#define _DO_BLOCK       (sigmask(SIGPIPE))
-
-#ifndef QIC117_TAPE_MAJOR
-#define QIC117_TAPE_MAJOR 27
-#endif
-
-#endif
diff --git a/drivers/char/ftape/lowlevel/ftape-io.c b/drivers/char/ftape/lowlevel/ftape-io.c
deleted file mode 100644
index 259015aeff55..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-io.c
+++ /dev/null
@@ -1,992 +0,0 @@
-/*
- *      Copyright (C) 1993-1996 Bas Laarhoven,
- *                (C) 1996      Kai Harrekilde-Petersen,
- *                (C) 1997      Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-io.c,v $
- * $Revision: 1.4 $
- * $Date: 1997/11/11 14:02:36 $
- *
- *      This file contains the general control functions for the
- *      QIC-40/80/3010/3020 floppy-tape driver "ftape" for Linux.
- */
-
-#include <linux/errno.h>
-#include <linux/sched.h>
-#include <linux/mm.h>
-#include <asm/system.h>
-#include <linux/ioctl.h>
-#include <linux/mtio.h>
-#include <linux/delay.h>
-
-#include <linux/ftape.h>
-#include <linux/qic117.h>
-#include "../lowlevel/ftape-tracing.h"
-#include "../lowlevel/fdc-io.h"
-#include "../lowlevel/ftape-io.h"
-#include "../lowlevel/ftape-ctl.h"
-#include "../lowlevel/ftape-rw.h"
-#include "../lowlevel/ftape-write.h"
-#include "../lowlevel/ftape-read.h"
-#include "../lowlevel/ftape-init.h"
-#include "../lowlevel/ftape-calibr.h"
-
-/*      Global vars.
- */
-/* NOTE: sectors start numbering at 1, all others at 0 ! */
-ft_timeout_table ftape_timeout;
-unsigned int ftape_tape_len;
-volatile qic117_cmd_t ftape_current_command;
-const struct qic117_command_table qic117_cmds[] = QIC117_COMMANDS;
-int ftape_might_be_off_track;
-
-/*      Local vars.
- */
-static int diagnostic_mode;
-static unsigned int ftape_udelay_count;
-static unsigned int ftape_udelay_time;
-
-void ftape_udelay(unsigned int usecs)
-{
-        volatile int count = (ftape_udelay_count * usecs +
-                              ftape_udelay_count - 1) / ftape_udelay_time;
-        volatile int i;
-
-        while (count-- > 0) {
-                for (i = 0; i < 20; ++i);
-        }
-}
-
-void ftape_udelay_calibrate(void)
-{
-        ftape_calibrate("ftape_udelay",
-                        ftape_udelay, &ftape_udelay_count, &ftape_udelay_time);
-}
-
-/*      Delay (msec) routine.
- */
-void ftape_sleep(unsigned int time)
-{
-        TRACE_FUN(ft_t_any);
-
-        time *= 1000;   /* msecs -> usecs */
-        if (time < FT_USPT) {
-                /*  Time too small for scheduler, do a busy wait ! */
-                ftape_udelay(time);
-        } else {
-                long timeout;
-                unsigned long flags;
-                unsigned int ticks = (time + FT_USPT - 1) / FT_USPT;
-
-                TRACE(ft_t_any, "%d msec, %d ticks", time/1000, ticks);
-                timeout = ticks;
-                save_flags(flags);
-                sti();
-                msleep_interruptible(jiffies_to_msecs(timeout));
-                /*  Mmm. Isn't current->blocked == 0xffffffff ?
-                 */
-                if (signal_pending(current)) {
-                        TRACE(ft_t_err, "awoken by non-blocked signal :-(");
-                }
-                restore_flags(flags);
-        }
-        TRACE_EXIT;
-}
-
-/*  send a command or parameter to the drive
- *  Generates # of step pulses.
- */
-static inline int ft_send_to_drive(int arg)
-{
-        /*  Always wait for a command_timeout period to separate
-         *  individuals commands and/or parameters.
-         */
-        ftape_sleep(3 * FT_MILLISECOND);
-        /*  Keep cylinder nr within range, step towards home if possible.
-         */
-        if (ftape_current_cylinder >= arg) {
-                return fdc_seek(ftape_current_cylinder - arg);
-        } else {
-                return fdc_seek(ftape_current_cylinder + arg);
-        }
-}
-
-/* forward */ int ftape_report_raw_drive_status(int *status);
-
-static int ft_check_cmd_restrictions(qic117_cmd_t command)
-{
-        int status = -1;
-        TRACE_FUN(ft_t_any);
-        
-        TRACE(ft_t_flow, "%s", qic117_cmds[command].name);
-        /* A new motion command during an uninterruptible (motion)
-         *  command requires a ready status before the new command can
-         *  be issued. Otherwise a new motion command needs to be
-         *  checked against required status.
-         */
-        if (qic117_cmds[command].cmd_type == motion &&
-            qic117_cmds[ftape_current_command].non_intr) {
-                ftape_report_raw_drive_status(&status);
-                if ((status & QIC_STATUS_READY) == 0) {
-                        TRACE(ft_t_noise,
-                              "motion cmd (%d) during non-intr cmd (%d)",
-                              command, ftape_current_command);
-                        TRACE(ft_t_noise, "waiting until drive gets ready");
-                        ftape_ready_wait(ftape_timeout.seek,
-                                         &status);
-                }
-        }
-        if (qic117_cmds[command].mask != 0) {
-                __u8 difference;
-                /*  Some commands do require a certain status:
-                 */
-                if (status == -1) {     /* not yet set */
-                        ftape_report_raw_drive_status(&status);
-                }
-                difference = ((status ^ qic117_cmds[command].state) &
-                              qic117_cmds[command].mask);
-                /*  Wait until the drive gets
-                 *  ready. This may last forever if
-                 *  the drive never gets ready... 
-                 */
-                while ((difference & QIC_STATUS_READY) != 0) {
-                        TRACE(ft_t_noise, "command %d issued while not ready",
-                              command);
-                        TRACE(ft_t_noise, "waiting until drive gets ready");
-                        if (ftape_ready_wait(ftape_timeout.seek,
-                                             &status) == -EINTR) {
-                                /*  Bail out on signal !
-                                 */
-                                TRACE_ABORT(-EINTR, ft_t_warn,
-                                      "interrupted by non-blockable signal");
-                        }
-                        difference = ((status ^ qic117_cmds[command].state) &
-                                      qic117_cmds[command].mask);
-                }
-                while ((difference & QIC_STATUS_ERROR) != 0) {
-                        int err;
-                        qic117_cmd_t cmd;
-
-                        TRACE(ft_t_noise,
-                              "command %d issued while error pending",
-                              command);
-                        TRACE(ft_t_noise, "clearing error status");
-                        ftape_report_error(&err, &cmd, 1);
-                        ftape_report_raw_drive_status(&status);
-                        difference = ((status ^ qic117_cmds[command].state) &
-                                      qic117_cmds[command].mask);
-                        if ((difference & QIC_STATUS_ERROR) != 0) {
-                                /*  Bail out on fatal signal !
-                                 */
-                                FT_SIGNAL_EXIT(_NEVER_BLOCK);
-                        }
-                }
-                if (difference) {
-                        /*  Any remaining difference can't be solved
-                         *  here.  
-                         */
-                        if (difference & (QIC_STATUS_CARTRIDGE_PRESENT |
-                                          QIC_STATUS_NEW_CARTRIDGE |
-                                          QIC_STATUS_REFERENCED)) {
-                                TRACE(ft_t_warn,
-                                      "Fatal: tape removed or reinserted !");
-                                ft_failure = 1;
-                        } else {
-                                TRACE(ft_t_err, "wrong state: 0x%02x should be: 0x%02x",
-                                      status & qic117_cmds[command].mask,
-                                      qic117_cmds[command].state);
-                        }
-                        TRACE_EXIT -EIO;
-                }
-                if (~status & QIC_STATUS_READY & qic117_cmds[command].mask) {
-                        TRACE_ABORT(-EBUSY, ft_t_err, "Bad: still busy!");
-                }
-        }
-        TRACE_EXIT 0;
-}
-
-/*      Issue a tape command:
- */
-int ftape_command(qic117_cmd_t command)
-{
-        int result = 0;
-        static int level;
-        TRACE_FUN(ft_t_any);
-
-        if ((unsigned int)command > NR_ITEMS(qic117_cmds)) {
-                /*  This is a bug we'll want to know about too.
-                 */
-                TRACE_ABORT(-EIO, ft_t_bug, "bug - bad command: %d", command);
-        }
-        if (++level > 5) { /*  This is a bug we'll want to know about. */
-                --level;
-                TRACE_ABORT(-EIO, ft_t_bug, "bug - recursion for command: %d",
-                            command);
-        }
-        /*  disable logging and restriction check for some commands,
-         *  check all other commands that have a prescribed starting
-         *  status.
-         */
-        if (diagnostic_mode) {
-                TRACE(ft_t_flow, "diagnostic command %d", command);
-        } else if (command == QIC_REPORT_DRIVE_STATUS ||
-                   command == QIC_REPORT_NEXT_BIT) {
-                TRACE(ft_t_any, "%s", qic117_cmds[command].name);
-        } else {
-                TRACE_CATCH(ft_check_cmd_restrictions(command), --level);
-        }
-        /*  Now all conditions are met or result was < 0.
-         */
-        result = ft_send_to_drive((unsigned int)command);
-        if (qic117_cmds[command].cmd_type == motion &&
-            command != QIC_LOGICAL_FORWARD && command != QIC_STOP_TAPE) {
-                ft_location.known = 0;
-        }
-        ftape_current_command = command;
-        --level;
-        TRACE_EXIT result;
-}
-
-/*      Send a tape command parameter:
- *      Generates command # of step pulses.
- *      Skips tape-status call !
- */
-int ftape_parameter(unsigned int parameter)
-{
-        TRACE_FUN(ft_t_any);
-
-        TRACE(ft_t_flow, "called with parameter = %d", parameter);
-        TRACE_EXIT ft_send_to_drive(parameter + 2);
-}
-
-/*      Wait for the drive to get ready.
- *      timeout time in milli-seconds
- *      Returned status is valid if result != -EIO
- *
- *      Should we allow to be killed by SIGINT?  (^C)
- *      Would be nice at least for large timeouts.
- */
-int ftape_ready_wait(unsigned int timeout, int *status)
-{
-        unsigned long t0;
-        unsigned int poll_delay;
-        int signal_retries;
-        TRACE_FUN(ft_t_any);
-
-        /*  the following ** REALLY ** reduces the system load when
-         *  e.g. one simply rewinds or retensions. The tape is slow 
-         *  anyway. It is really not necessary to detect error 
-         *  conditions with 1/10 seconds granularity
-         *
-         *  On my AMD 133MHZ 486: 100 ms: 23% system load
-         *                        1  sec:  5%
-         *                        5  sec:  0.6%, yeah
-         */
-        if (timeout <= FT_SECOND) {
-                poll_delay = 100 * FT_MILLISECOND;
-                signal_retries = 20; /* two seconds */
-        } else if (timeout < 20 * FT_SECOND) {
-                TRACE(ft_t_flow, "setting poll delay to 1 second");
-                poll_delay = FT_SECOND;
-                signal_retries = 2; /* two seconds */
-        } else {
-                TRACE(ft_t_flow, "setting poll delay to 5 seconds");
-                poll_delay = 5 * FT_SECOND;
-                signal_retries = 1; /* five seconds */
-        }
-        for (;;) {
-                t0 = jiffies;
-                TRACE_CATCH(ftape_report_raw_drive_status(status),);
-                if (*status & QIC_STATUS_READY) {
-                        TRACE_EXIT 0;
-                }
-                if (!signal_retries--) {
-                        FT_SIGNAL_EXIT(_NEVER_BLOCK);
-                }
-                if ((int)timeout >= 0) {
-                        /* this will fail when jiffies wraps around about
-                         * once every year :-)
-                         */
-                        timeout -= ((jiffies - t0) * FT_SECOND) / HZ;
-                        if (timeout <= 0) {
-                                TRACE_ABORT(-ETIME, ft_t_err, "timeout");
-                        }
-                        ftape_sleep(poll_delay);
-                        timeout -= poll_delay;
-                } else {
-                        ftape_sleep(poll_delay);
-                }
-        }
-        TRACE_EXIT -ETIME;
-}
-
-/*      Issue command and wait up to timeout milli seconds for drive ready
- */
-int ftape_command_wait(qic117_cmd_t command, unsigned int timeout, int *status)
-{
-        int result;
-
-        /* Drive should be ready, issue command
-         */
-        result = ftape_command(command);
-        if (result >= 0) {
-                result = ftape_ready_wait(timeout, status);
-        }
-        return result;
-}
-
-static int ftape_parameter_wait(unsigned int parm, unsigned int timeout, int *status)
-{
-        int result;
-
-        /* Drive should be ready, issue command
-         */
-        result = ftape_parameter(parm);
-        if (result >= 0) {
-                result = ftape_ready_wait(timeout, status);
-        }
-        return result;
-}
-
-/*--------------------------------------------------------------------------
- *      Report operations
- */
-
-/* Query the drive about its status.  The command is sent and
-   result_length bits of status are returned (2 extra bits are read
-   for start and stop). */
-
-int ftape_report_operation(int *status,
-                           qic117_cmd_t command,
-                           int result_length)
-{
-        int i, st3;
-        unsigned int t0;
-        unsigned int dt;
-        TRACE_FUN(ft_t_any);
-
-        TRACE_CATCH(ftape_command(command),);
-        t0 = ftape_timestamp();
-        i = 0;
-        do {
-                ++i;
-                ftape_sleep(3 * FT_MILLISECOND);        /* see remark below */
-                TRACE_CATCH(fdc_sense_drive_status(&st3),);
-                dt = ftape_timediff(t0, ftape_timestamp());
-                /*  Ack should be asserted within Ttimout + Tack = 6 msec.
-                 *  Looks like some drives fail to do this so extend this
-                 *  period to 300 msec.
-                 */
-        } while (!(st3 & ST3_TRACK_0) && dt < 300000);
-        if (!(st3 & ST3_TRACK_0)) {
-                TRACE(ft_t_err,
-                      "No acknowledge after %u msec. (%i iter)", dt / 1000, i);
-                TRACE_ABORT(-EIO, ft_t_err, "timeout on Acknowledge");
-        }
-        /*  dt may be larger than expected because of other tasks
-         *  scheduled while we were sleeping.
-         */
-        if (i > 1 && dt > 6000) {
-                TRACE(ft_t_err, "Acknowledge after %u msec. (%i iter)",
-                      dt / 1000, i);
-        }
-        *status = 0;
-        for (i = 0; i < result_length + 1; i++) {
-                TRACE_CATCH(ftape_command(QIC_REPORT_NEXT_BIT),);
-                TRACE_CATCH(fdc_sense_drive_status(&st3),);
-                if (i < result_length) {
-                        *status |= ((st3 & ST3_TRACK_0) ? 1 : 0) << i;
-                } else if ((st3 & ST3_TRACK_0) == 0) {
-                        TRACE_ABORT(-EIO, ft_t_err, "missing status stop bit");
-                }
-        }
-        /* this command will put track zero and index back into normal state */
-        (void)ftape_command(QIC_REPORT_NEXT_BIT);
-        TRACE_EXIT 0;
-}
-
-/* Report the current drive status. */
-
-int ftape_report_raw_drive_status(int *status)
-{
-        int result;
-        int count = 0;
-        TRACE_FUN(ft_t_any);
-
-        do {
-                result = ftape_report_operation(status,
-                                                QIC_REPORT_DRIVE_STATUS, 8);
-        } while (result < 0 && ++count <= 3);
-        if (result < 0) {
-                TRACE_ABORT(-EIO, ft_t_err,
-                            "report_operation failed after %d trials", count);
-        }
-        if ((*status & 0xff) == 0xff) {
-                TRACE_ABORT(-EIO, ft_t_err,
-                            "impossible drive status 0xff");
-        }
-        if (*status & QIC_STATUS_READY) {
-                ftape_current_command = QIC_NO_COMMAND; /* completed */
-        }
-        ft_last_status.status.drive_status = (__u8)(*status & 0xff);
-        TRACE_EXIT 0;
-}
-
-int ftape_report_drive_status(int *status)
-{
-        TRACE_FUN(ft_t_any);
-
-        TRACE_CATCH(ftape_report_raw_drive_status(status),);
-        if (*status & QIC_STATUS_NEW_CARTRIDGE ||
-            !(*status & QIC_STATUS_CARTRIDGE_PRESENT)) {
-                ft_failure = 1; /* will inhibit further operations */
-                TRACE_EXIT -EIO;
-        }
-        if (*status & QIC_STATUS_READY && *status & QIC_STATUS_ERROR) {
-                /*  Let caller handle all errors */
-                TRACE_ABORT(1, ft_t_warn, "warning: error status set!");
-        }
-        TRACE_EXIT 0;
-}
-
-int ftape_report_error(unsigned int *error,
-                       qic117_cmd_t *command, int report)
-{
-        static const ftape_error ftape_errors[] = QIC117_ERRORS;
-        int code;
-        TRACE_FUN(ft_t_any);
-
-        TRACE_CATCH(ftape_report_operation(&code, QIC_REPORT_ERROR_CODE, 16),);
-        *error   = (unsigned int)(code & 0xff);
-        *command = (qic117_cmd_t)((code>>8)&0xff);
-        /*  remember hardware status, maybe useful for status ioctls
-         */
-        ft_last_error.error.command = (__u8)*command;
-        ft_last_error.error.error   = (__u8)*error;
-        if (!report) {
-                TRACE_EXIT 0;
-        }
-        if (*error == 0) {
-                TRACE_ABORT(0, ft_t_info, "No error");
-        }
-        TRACE(ft_t_info, "errorcode: %d", *error);
-        if (*error < NR_ITEMS(ftape_errors)) {
-                TRACE(ft_t_noise, "%sFatal ERROR:",
-                      (ftape_errors[*error].fatal ? "" : "Non-"));
-                TRACE(ft_t_noise, "%s ...", ftape_errors[*error].message);
-        } else {
-                TRACE(ft_t_noise, "Unknown ERROR !");
-        }
-        if ((unsigned int)*command < NR_ITEMS(qic117_cmds) &&
-            qic117_cmds[*command].name != NULL) {
-                TRACE(ft_t_noise, "... caused by command \'%s\'",
-                      qic117_cmds[*command].name);
-        } else {
-                TRACE(ft_t_noise, "... caused by unknown command %d",
-                      *command);
-        }
-        TRACE_EXIT 0;
-}
-
-int ftape_report_configuration(qic_model *model,
-                               unsigned int *rate,
-                               int *qic_std,
-                               int *tape_len)
-{
-        int result;
-        int config;
-        int status;
-        static const unsigned int qic_rates[ 4] = { 250, 2000, 500, 1000 };
-        TRACE_FUN(ft_t_any);
-
-        result = ftape_report_operation(&config,
-                                        QIC_REPORT_DRIVE_CONFIGURATION, 8);
-        if (result < 0) {
-                ft_last_status.status.drive_config = (__u8)0x00;
-                *model = prehistoric;
-                *rate = 500;
-                *qic_std = QIC_TAPE_QIC40;
-                *tape_len = 205;
-                TRACE_EXIT 0;
-        } else {
-                ft_last_status.status.drive_config = (__u8)(config & 0xff);
-        }
-        *rate = qic_rates[(config & QIC_CONFIG_RATE_MASK) >> QIC_CONFIG_RATE_SHIFT];
-        result = ftape_report_operation(&status, QIC_REPORT_TAPE_STATUS, 8);
-        if (result < 0) {
-                ft_last_status.status.tape_status = (__u8)0x00;
-                /* pre- QIC117 rev C spec. drive, QIC_CONFIG_80 bit is valid.
-                 */
-                *qic_std = (config & QIC_CONFIG_80) ?
-                        QIC_TAPE_QIC80 : QIC_TAPE_QIC40;
-                /* ?? how's about 425ft tapes? */
-                *tape_len = (config & QIC_CONFIG_LONG) ? 307 : 0;
-                *model = pre_qic117c;
-                result = 0;
-        } else {
-                ft_last_status.status.tape_status = (__u8)(status & 0xff);
-                *model = post_qic117b;
-                TRACE(ft_t_any, "report tape status result = %02x", status);
-                /* post- QIC117 rev C spec. drive, QIC_CONFIG_80 bit is
-                 * invalid. 
-                 */
-                switch (status & QIC_TAPE_STD_MASK) {
-                case QIC_TAPE_QIC40:
-                case QIC_TAPE_QIC80:
-                case QIC_TAPE_QIC3020:
-                case QIC_TAPE_QIC3010:
-                        *qic_std = status & QIC_TAPE_STD_MASK;
-                        break;
-                default:
-                        *qic_std = -1;
-                        break;
-                }
-                switch (status & QIC_TAPE_LEN_MASK) {
-                case QIC_TAPE_205FT:
-                        /* 205 or 425+ ft 550 Oe tape */
-                        *tape_len = 0;
-                        break;
-                case QIC_TAPE_307FT:
-                        /* 307.5 ft 550 Oe Extended Length (XL) tape */
-                        *tape_len = 307;
-                        break;
-                case QIC_TAPE_VARIABLE:
-                        /* Variable length 550 Oe tape */
-                        *tape_len = 0;
-                        break;
-                case QIC_TAPE_1100FT:
-                        /* 1100 ft 550 Oe tape */
-                        *tape_len = 1100;
-                        break;
-                case QIC_TAPE_FLEX:
-                        /* Variable length 900 Oe tape */
-                        *tape_len = 0;
-                        break;
-                default:
-                        *tape_len = -1;
-                        break;
-                }
-                if (*qic_std == -1 || *tape_len == -1) {
-                        TRACE(ft_t_any,
-                              "post qic-117b spec drive with unknown tape");
-                }
-                result = *tape_len == -1 ? -EIO : 0;
-                if (status & QIC_TAPE_WIDE) {
-                        switch (*qic_std) {
-                        case QIC_TAPE_QIC80:
-                                TRACE(ft_t_info, "TR-1 tape detected");
-                                break;
-                        case QIC_TAPE_QIC3010:
-                                TRACE(ft_t_info, "TR-2 tape detected");
-                                break;
-                        case QIC_TAPE_QIC3020:
-                                TRACE(ft_t_info, "TR-3 tape detected");
-                                break;
-                        default:
-                                TRACE(ft_t_warn,
-                                      "Unknown Travan tape type detected");
-                                break;
-                        }
-                }
-        }
-        TRACE_EXIT (result < 0) ? -EIO : 0;
-}
-
-static int ftape_report_rom_version(int *version)
-{
-
-        if (ftape_report_operation(version, QIC_REPORT_ROM_VERSION, 8) < 0) {
-                return -EIO;
-        } else {
-                return 0;
-        }
-}
-
-void ftape_report_vendor_id(unsigned int *id)
-{
-        int result;
-        TRACE_FUN(ft_t_any);
-
-        /* We'll try to get a vendor id from the drive.  First
-         * according to the QIC-117 spec, a 16-bit id is requested.
-         * If that fails we'll try an 8-bit version, otherwise we'll
-         * try an undocumented query.
-         */
-        result = ftape_report_operation((int *) id, QIC_REPORT_VENDOR_ID, 16);
-        if (result < 0) {
-                result = ftape_report_operation((int *) id,
-                                                QIC_REPORT_VENDOR_ID, 8);
-                if (result < 0) {
-                        /* The following is an undocumented call found
-                         * in the CMS code.
-                         */
-                        result = ftape_report_operation((int *) id, 24, 8);
-                        if (result < 0) {
-                                *id = UNKNOWN_VENDOR;
-                        } else {
-                                TRACE(ft_t_noise, "got old 8 bit id: %04x",
-                                      *id);
-                                *id |= 0x20000;
-                        }
-                } else {
-                        TRACE(ft_t_noise, "got 8 bit id: %04x", *id);
-                        *id |= 0x10000;
-                }
-        } else {
-                TRACE(ft_t_noise, "got 16 bit id: %04x", *id);
-        }
-        if (*id == 0x0047) {
-                int version;
-                int sign;
-
-                if (ftape_report_rom_version(&version) < 0) {
-                        TRACE(ft_t_bug, "report rom version failed");
-                        TRACE_EXIT;
-                }
-                TRACE(ft_t_noise, "CMS rom version: %d", version);
-                ftape_command(QIC_ENTER_DIAGNOSTIC_1);
-                ftape_command(QIC_ENTER_DIAGNOSTIC_1);
-                diagnostic_mode = 1;
-                if (ftape_report_operation(&sign, 9, 8) < 0) {
-                        unsigned int error;
-                        qic117_cmd_t command;
-
-                        ftape_report_error(&error, &command, 1);
-                        ftape_command(QIC_ENTER_PRIMARY_MODE);
-                        diagnostic_mode = 0;
-                        TRACE_EXIT;     /* failure ! */
-                } else {
-                        TRACE(ft_t_noise, "CMS signature: %02x", sign);
-                }
-                if (sign == 0xa5) {
-                        result = ftape_report_operation(&sign, 37, 8);
-                        if (result < 0) {
-                                if (version >= 63) {
-                                        *id = 0x8880;
-                                        TRACE(ft_t_noise,
-                                              "This is an Iomega drive !");
-                                } else {
-                                        *id = 0x0047;
-                                        TRACE(ft_t_noise,
-                                              "This is a real CMS drive !");
-                                }
-                        } else {
-                                *id = 0x0047;
-                                TRACE(ft_t_noise, "CMS status: %d", sign);
-                        }
-                } else {
-                        *id = UNKNOWN_VENDOR;
-                }
-                ftape_command(QIC_ENTER_PRIMARY_MODE);
-                diagnostic_mode = 0;
-        }
-        TRACE_EXIT;
-}
-
-static int qic_rate_code(unsigned int rate)
-{
-        switch (rate) {
-        case 250:
-                return QIC_CONFIG_RATE_250;
-        case 500:
-                return QIC_CONFIG_RATE_500;
-        case 1000:
-                return QIC_CONFIG_RATE_1000;
-        case 2000:
-                return QIC_CONFIG_RATE_2000;
-        default:
-                return QIC_CONFIG_RATE_500;
-        }
-}
-
-static int ftape_set_rate_test(unsigned int *max_rate)
-{
-        unsigned int error;
-        qic117_cmd_t command;
-        int status;
-        int supported = 0;
-        TRACE_FUN(ft_t_any);
-
-        /*  Check if the drive does support the select rate command
-         *  by testing all different settings. If any one is accepted
-         *  we assume the command is supported, else not.
-         */
-        for (*max_rate = 2000; *max_rate >= 250; *max_rate /= 2) {
-                if (ftape_command(QIC_SELECT_RATE) < 0) {
-                        continue;
-                }               
-                if (ftape_parameter_wait(qic_rate_code(*max_rate),
-                                         1 * FT_SECOND, &status) < 0) {
-                        continue;
-                }
-                if (status & QIC_STATUS_ERROR) {
-                        ftape_report_error(&error, &command, 0);
-                        continue;
-                }
-                supported = 1; /* did accept a request */
-                break;
-        }
-        TRACE(ft_t_noise, "Select Rate command is%s supported", 
-              supported ? "" : " not");
-        TRACE_EXIT supported;
-}
-
-int ftape_set_data_rate(unsigned int new_rate /* Kbps */, unsigned int qic_std)
-{
-        int status;
-        int result = 0;
-        unsigned int data_rate = new_rate;
-        static int supported;
-        int rate_changed = 0;
-        qic_model dummy_model;
-        unsigned int dummy_qic_std, dummy_tape_len;
-        TRACE_FUN(ft_t_any);
-
-        if (ft_drive_max_rate == 0) { /* first time */
-                supported = ftape_set_rate_test(&ft_drive_max_rate);
-        }
-        if (supported) {
-                ftape_command(QIC_SELECT_RATE);
-                result = ftape_parameter_wait(qic_rate_code(new_rate),
-                                              1 * FT_SECOND, &status);
-                if (result >= 0 && !(status & QIC_STATUS_ERROR)) {
-                        rate_changed = 1;
-                }
-        }
-        TRACE_CATCH(result = ftape_report_configuration(&dummy_model,
-                                                        &data_rate, 
-                                                        &dummy_qic_std,
-                                                        &dummy_tape_len),);
-        if (data_rate != new_rate) {
-                if (!supported) {
-                        TRACE(ft_t_warn, "Rate change not supported!");
-                } else if (rate_changed) {
-                        TRACE(ft_t_warn, "Requested: %d, got %d",
-                              new_rate, data_rate);
-                } else {
-                        TRACE(ft_t_warn, "Rate change failed!");
-                }
-                result = -EINVAL;
-        }
-        /*
-         *  Set data rate and write precompensation as specified:
-         *
-         *            |  QIC-40/80  | QIC-3010/3020
-         *   rate     |   precomp   |    precomp
-         *  ----------+-------------+--------------
-         *  250 Kbps. |   250 ns.   |     0 ns.
-         *  500 Kbps. |   125 ns.   |     0 ns.
-         *    1 Mbps. |    42 ns.   |     0 ns.
-         *    2 Mbps  |      N/A    |     0 ns.
-         */
-        if ((qic_std == QIC_TAPE_QIC40 && data_rate > 500) || 
-            (qic_std == QIC_TAPE_QIC80 && data_rate > 1000)) {
-                TRACE_ABORT(-EINVAL,
-                            ft_t_warn, "Datarate too high for QIC-mode");
-        }
-        TRACE_CATCH(fdc_set_data_rate(data_rate),_res = -EINVAL);
-        ft_data_rate = data_rate;
-        if (qic_std == QIC_TAPE_QIC40 || qic_std == QIC_TAPE_QIC80) {
-                switch (data_rate) {
-                case 250:
-                        fdc_set_write_precomp(250);
-                        break;
-                default:
-                case 500:
-                        fdc_set_write_precomp(125);
-                        break;
-                case 1000:
-                        fdc_set_write_precomp(42);
-                        break;
-                }
-        } else {
-                fdc_set_write_precomp(0);
-        }
-        TRACE_EXIT result;
-}
-
-/*  The next two functions are used to cope with excessive overrun errors
- */
-int ftape_increase_threshold(void)
-{
-        TRACE_FUN(ft_t_flow);
-
-        if (fdc.type < i82077 || ft_fdc_threshold >= 12) {
-                TRACE_ABORT(-EIO, ft_t_err, "cannot increase fifo threshold");
-        }
-        if (fdc_fifo_threshold(++ft_fdc_threshold, NULL, NULL, NULL) < 0) {
-                TRACE(ft_t_err, "cannot increase fifo threshold");
-                ft_fdc_threshold --;
-                fdc_reset();
-        }
-        TRACE(ft_t_info, "New FIFO threshold: %d", ft_fdc_threshold);
-        TRACE_EXIT 0;
-}
-
-int ftape_half_data_rate(void)
-{
-        if (ft_data_rate < 500) {
-                return -1;
-        }
-        if (ftape_set_data_rate(ft_data_rate / 2, ft_qic_std) < 0) {
-                return -EIO;
-        }
-        ftape_calc_timeouts(ft_qic_std, ft_data_rate, ftape_tape_len);
-        return 0;
-}
-
-/*      Seek the head to the specified track.
- */
-int ftape_seek_head_to_track(unsigned int track)
-{
-        int status;
-        TRACE_FUN(ft_t_any);
-
-        ft_location.track = -1; /* remains set in case of error */
-        if (track >= ft_tracks_per_tape) {
-                TRACE_ABORT(-EINVAL, ft_t_bug, "track out of bounds");
-        }
-        TRACE(ft_t_flow, "seeking track %d", track);
-        TRACE_CATCH(ftape_command(QIC_SEEK_HEAD_TO_TRACK),);
-        TRACE_CATCH(ftape_parameter_wait(track, ftape_timeout.head_seek,
-                                         &status),);
-        ft_location.track = track;
-        ftape_might_be_off_track = 0;
-        TRACE_EXIT 0;
-}
-
-int ftape_wakeup_drive(wake_up_types method)
-{
-        int status;
-        int motor_on = 0;
-        TRACE_FUN(ft_t_any);
-
-        switch (method) {
-        case wake_up_colorado:
-                TRACE_CATCH(ftape_command(QIC_PHANTOM_SELECT),);
-                TRACE_CATCH(ftape_parameter(0 /* ft_drive_sel ?? */),);
-                break;
-        case wake_up_mountain:
-                TRACE_CATCH(ftape_command(QIC_SOFT_SELECT),);
-                ftape_sleep(FT_MILLISECOND);    /* NEEDED */
-                TRACE_CATCH(ftape_parameter(18),);
-                break;
-        case wake_up_insight:
-                ftape_sleep(100 * FT_MILLISECOND);
-                motor_on = 1;
-                fdc_motor(motor_on);    /* enable is done by motor-on */
-        case no_wake_up:
-                break;
-        default:
-                TRACE_EXIT -ENODEV;     /* unknown wakeup method */
-                break;
-        }
-        /*  If wakeup succeeded we shouldn't get an error here..
-         */
-        TRACE_CATCH(ftape_report_raw_drive_status(&status),
-                    if (motor_on) {
-                            fdc_motor(0);
-                    });
-        TRACE_EXIT 0;
-}
-
-int ftape_put_drive_to_sleep(wake_up_types method)
-{
-        TRACE_FUN(ft_t_any);
-
-        switch (method) {
-        case wake_up_colorado:
-                TRACE_CATCH(ftape_command(QIC_PHANTOM_DESELECT),);
-                break;
-        case wake_up_mountain:
-                TRACE_CATCH(ftape_command(QIC_SOFT_DESELECT),);
-                break;
-        case wake_up_insight:
-                fdc_motor(0);   /* enable is done by motor-on */
-        case no_wake_up:        /* no wakeup / no sleep ! */
-                break;
-        default:
-                TRACE_EXIT -ENODEV;     /* unknown wakeup method */
-        }
-        TRACE_EXIT 0;
-}
-
-int ftape_reset_drive(void)
-{
-        int result = 0;
-        int status;
-        unsigned int err_code;
-        qic117_cmd_t err_command;
-        int i;
-        TRACE_FUN(ft_t_any);
-
-        /*  We want to re-establish contact with our drive.  Fire a
-         *  number of reset commands (single step pulses) and pray for
-         *  success.
-         */
-        for (i = 0; i < 2; ++i) {
-                TRACE(ft_t_flow, "Resetting fdc");
-                fdc_reset();
-                ftape_sleep(10 * FT_MILLISECOND);
-                TRACE(ft_t_flow, "Reset command to drive");
-                result = ftape_command(QIC_RESET);
-                if (result == 0) {
-                        ftape_sleep(1 * FT_SECOND); /*  drive not
-                                                     *  accessible
-                                                     *  during 1 second
-                                                     */
-                        TRACE(ft_t_flow, "Re-selecting drive");
-
-                        /* Strange, the QIC-117 specs don't mention
-                         * this but the drive gets deselected after a
-                         * soft reset !  So we need to enable it
-                         * again.
-                         */
-                        if (ftape_wakeup_drive(ft_drive_type.wake_up) < 0) {
-                                TRACE(ft_t_err, "Wakeup failed !");
-                        }
-                        TRACE(ft_t_flow, "Waiting until drive gets ready");
-                        result= ftape_ready_wait(ftape_timeout.reset, &status);
-                        if (result == 0 && (status & QIC_STATUS_ERROR)) {
-                                result = ftape_report_error(&err_code,
-                                                            &err_command, 1);
-                                if (result == 0 && err_code == 27) {
-                                        /*  Okay, drive saw reset
-                                         *  command and responded as it
-                                         *  should
-                                         */
-                                        break;
-                                } else {
-                                        result = -EIO;
-                                }
-                        } else {
-                                result = -EIO;
-                        }
-                }
-                FT_SIGNAL_EXIT(_DONT_BLOCK);
-        }
-        if (result != 0) {
-                TRACE(ft_t_err, "General failure to reset tape drive");
-        } else {
-                /*  Restore correct settings: keep original rate 
-                 */
-                ftape_set_data_rate(ft_data_rate, ft_qic_std);
-        }
-        ftape_init_drive_needed = 1;
-        TRACE_EXIT result;
-}
diff --git a/drivers/char/ftape/lowlevel/ftape-io.h b/drivers/char/ftape/lowlevel/ftape-io.h
deleted file mode 100644
index 26a7baad8717..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-io.h
+++ /dev/null
@@ -1,90 +0,0 @@
-#ifndef _FTAPE_IO_H
-#define _FTAPE_IO_H
-
-/*
- * Copyright (C) 1993-1996 Bas Laarhoven,
- *           (C) 1997      Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-io.h,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:18:18 $
- *
- *      This file contains definitions for the glue part of the
- *      QIC-40/80/3010/3020 floppy-tape driver "ftape" for Linux.
- */
-
-#include <linux/qic117.h>
-#include <linux/ftape-vendors.h>
-
-typedef struct {
-        unsigned int seek;
-        unsigned int reset;
-        unsigned int rewind;
-        unsigned int head_seek;
-        unsigned int stop;
-        unsigned int pause;
-} ft_timeout_table;
-
-typedef enum {
-        prehistoric, pre_qic117c, post_qic117b, post_qic117d 
-} qic_model;
-
-/*
- *      ftape-io.c defined global vars.
- */
-extern ft_timeout_table ftape_timeout;
-extern unsigned int ftape_tape_len;
-extern volatile qic117_cmd_t ftape_current_command;
-extern const struct qic117_command_table qic117_cmds[];
-extern int ftape_might_be_off_track;
-
-/*
- *      ftape-io.c defined global functions.
- */
-extern void ftape_udelay(unsigned int usecs);
-extern void  ftape_udelay_calibrate(void);
-extern void ftape_sleep(unsigned int time);
-extern void ftape_report_vendor_id(unsigned int *id);
-extern int  ftape_command(qic117_cmd_t command);
-extern int  ftape_command_wait(qic117_cmd_t command,
-                               unsigned int timeout,
-                               int *status);
-extern int  ftape_parameter(unsigned int parameter);
-extern int ftape_report_operation(int *status,
-                                  qic117_cmd_t  command,
-                                  int result_length);
-extern int ftape_report_configuration(qic_model *model,
-                                      unsigned int *rate,
-                                      int *qic_std,
-                                      int *tape_len);
-extern int ftape_report_drive_status(int *status);
-extern int ftape_report_raw_drive_status(int *status);
-extern int ftape_report_status(int *status);
-extern int ftape_ready_wait(unsigned int timeout, int *status);
-extern int ftape_seek_head_to_track(unsigned int track);
-extern int ftape_set_data_rate(unsigned int new_rate, unsigned int qic_std);
-extern int ftape_report_error(unsigned int *error,
-                              qic117_cmd_t *command,
-                              int report);
-extern int ftape_reset_drive(void);
-extern int ftape_put_drive_to_sleep(wake_up_types method);
-extern int ftape_wakeup_drive(wake_up_types method);
-extern int ftape_increase_threshold(void);
-extern int ftape_half_data_rate(void);
-
-#endif
diff --git a/drivers/char/ftape/lowlevel/ftape-proc.c b/drivers/char/ftape/lowlevel/ftape-proc.c
deleted file mode 100644
index e805b15e0a12..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-proc.c
+++ /dev/null
@@ -1,214 +0,0 @@
-/*
- *      Copyright (C) 1997 Claus-Justus Heine
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-proc.c,v $
- * $Revision: 1.11 $
- * $Date: 1997/10/24 14:47:37 $
- *
- *      This file contains the procfs interface for the
- *      QIC-40/80/3010/3020 floppy-tape driver "ftape" for Linux.
-
- *      Old code removed, switched to dynamic proc entry.
- */
-
-
-#if defined(CONFIG_PROC_FS) && defined(CONFIG_FT_PROC_FS)
-
-#include <linux/proc_fs.h>
-
-#include <linux/ftape.h>
-#include <linux/init.h>
-#include <linux/qic117.h>
-
-#include "../lowlevel/ftape-io.h"
-#include "../lowlevel/ftape-ctl.h"
-#include "../lowlevel/ftape-proc.h"
-#include "../lowlevel/ftape-tracing.h"
-
-static size_t get_driver_info(char *buf)
-{
-        const char *debug_level[] = { "bugs"  ,
-                                      "errors",
-                                      "warnings",
-                                      "informational",
-                                      "noisy",
-                                      "program flow",
-                                      "fdc and dma",
-                                      "data flow",
-                                      "anything" };
-
-        return sprintf(buf,
-                       "version       : %s\n"
-                       "used data rate: %d kbit/sec\n"
-                       "dma memory    : %d kb\n"
-                       "debug messages: %s\n",
-                       FTAPE_VERSION,
-                       ft_data_rate,
-                       FT_BUFF_SIZE * ft_nr_buffers >> 10,
-                       debug_level[TRACE_LEVEL]);
-}
-
-static size_t get_tapedrive_info(char *buf)
-{ 
-        return sprintf(buf,
-                       "vendor id : 0x%04x\n"
-                       "drive name: %s\n"
-                       "wind speed: %d ips\n"
-                       "wakeup    : %s\n"
-                       "max. rate : %d kbit/sec\n",
-                       ft_drive_type.vendor_id,
-                       ft_drive_type.name,
-                       ft_drive_type.speed,
-                       ((ft_drive_type.wake_up == no_wake_up)
-                        ? "No wakeup needed" :
-                        ((ft_drive_type.wake_up == wake_up_colorado)
-                         ? "Colorado" :
-                         ((ft_drive_type.wake_up == wake_up_mountain)
-                          ? "Mountain" :
-                          ((ft_drive_type.wake_up == wake_up_insight)
-                           ? "Motor on" :
-                           "Unknown")))),
-                       ft_drive_max_rate);
-}
-
-static size_t get_cartridge_info(char *buf)
-{
-        if (ftape_init_drive_needed) {
-                return sprintf(buf, "uninitialized\n");
-        }
-        if (ft_no_tape) {
-                return sprintf(buf, "no cartridge inserted\n");
-        }
-        return sprintf(buf,
-                       "segments  : %5d\n"
-                       "tracks    : %5d\n"
-                       "length    : %5dft\n"
-                       "formatted : %3s\n"
-                       "writable  : %3s\n"
-                       "QIC spec. : QIC-%s\n"
-                       "fmt-code  : %1d\n",
-                       ft_segments_per_track,
-                       ft_tracks_per_tape,
-                       ftape_tape_len,
-                       (ft_formatted == 1) ? "yes" : "no",
-                       (ft_write_protected == 1) ? "no" : "yes",
-                       ((ft_qic_std == QIC_TAPE_QIC40) ? "40" :
-                        ((ft_qic_std == QIC_TAPE_QIC80) ? "80" :
-                         ((ft_qic_std == QIC_TAPE_QIC3010) ? "3010" :
-                          ((ft_qic_std == QIC_TAPE_QIC3020) ? "3020" :
-                           "???")))),
-                       ft_format_code);
-}
-
-static size_t get_controller_info(char *buf)
-{
-        const char  *fdc_name[] = { "no fdc",
-                                    "i8272",
-                                    "i82077",
-                                    "i82077AA",
-                                    "Colorado FC-10 or FC-20",
-                                    "i82078",
-                                    "i82078_1" };
-
-        return sprintf(buf,
-                       "FDC type  : %s\n"
-                       "FDC base  : 0x%03x\n"
-                       "FDC irq   : %d\n"
-                       "FDC dma   : %d\n"
-                       "FDC thr.  : %d\n"
-                       "max. rate : %d kbit/sec\n",
-                       ft_mach2 ? "Mountain MACH-2" : fdc_name[fdc.type],
-                       fdc.sra, fdc.irq, fdc.dma,
-                       ft_fdc_threshold, ft_fdc_max_rate);
-}
-
-static size_t get_history_info(char *buf)
-{
-        size_t len;
-
-        len  = sprintf(buf,
-                       "\nFDC isr statistics\n"
-                       " id_am_errors     : %3d\n"
-                       " id_crc_errors    : %3d\n"
-                       " data_am_errors   : %3d\n"
-                       " data_crc_errors  : %3d\n"
-                       " overrun_errors   : %3d\n"
-                       " no_data_errors   : %3d\n"
-                       " retries          : %3d\n",
-                       ft_history.id_am_errors,   ft_history.id_crc_errors,
-                       ft_history.data_am_errors, ft_history.data_crc_errors,
-                       ft_history.overrun_errors, ft_history.no_data_errors,
-                       ft_history.retries);
-        len += sprintf(buf + len,
-                       "\nECC statistics\n"
-                       " crc_errors       : %3d\n"
-                       " crc_failures     : %3d\n"
-                       " ecc_failures     : %3d\n"
-                       " sectors corrected: %3d\n",
-                       ft_history.crc_errors,   ft_history.crc_failures,
-                       ft_history.ecc_failures, ft_history.corrected);
-        len += sprintf(buf + len,
-                       "\ntape quality statistics\n"
-                       " media defects    : %3d\n",
-                       ft_history.defects);
-        len += sprintf(buf + len,
-                       "\ntape motion statistics\n"
-                       " repositions      : %3d\n",
-                       ft_history.rewinds);
-        return len;
-}
-
-static int ftape_read_proc(char *page, char **start, off_t off,
-                           int count, int *eof, void *data)
-{
-        char *ptr = page;
-        size_t len;
-        
-        ptr += sprintf(ptr, "Kernel Driver\n\n");
-        ptr += get_driver_info(ptr);
-        ptr += sprintf(ptr, "\nTape Drive\n\n");
-        ptr += get_tapedrive_info(ptr);
-        ptr += sprintf(ptr, "\nFDC Controller\n\n");
-        ptr += get_controller_info(ptr);
-        ptr += sprintf(ptr, "\nTape Cartridge\n\n");
-        ptr += get_cartridge_info(ptr);
-        ptr += sprintf(ptr, "\nHistory Record\n\n");
-        ptr += get_history_info(ptr);
-
-        len = strlen(page);
-        *start = NULL;
-        if (off+count >= len) {
-                *eof = 1;
-        } else {
-                *eof = 0;
-        }
-        return len;
-}
-
-int __init ftape_proc_init(void)
-{
-        return create_proc_read_entry("ftape", 0, &proc_root,
-                ftape_read_proc, NULL) != NULL;
-}
-
-void ftape_proc_destroy(void)
-{
-        remove_proc_entry("ftape", &proc_root);
-}
-
-#endif /* defined(CONFIG_PROC_FS) && defined(CONFIG_FT_PROC_FS) */
diff --git a/drivers/char/ftape/lowlevel/ftape-proc.h b/drivers/char/ftape/lowlevel/ftape-proc.h
deleted file mode 100644
index 264dfcc1d22d..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-proc.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#ifndef _FTAPE_PROC_H
-#define _FTAPE_PROC_H
-
-/*
- *      Copyright (C) 1997 Claus-Justus Heine
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-proc.h,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:18:20 $
- *
- *      This file contains definitions for the procfs interface of the
- *      QIC-40/80/3010/3020 floppy-tape driver "ftape" for Linux.
- */
-
-#include <linux/proc_fs.h>
-
-extern int  ftape_proc_init(void);
-extern void ftape_proc_destroy(void);
-
-#endif
diff --git a/drivers/char/ftape/lowlevel/ftape-read.c b/drivers/char/ftape/lowlevel/ftape-read.c
deleted file mode 100644
index d967d8cd86dc..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-read.c
+++ /dev/null
@@ -1,621 +0,0 @@
-/*
- *      Copyright (C) 1993-1996 Bas Laarhoven,
- *                (C) 1996-1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-read.c,v $
- * $Revision: 1.6 $
- * $Date: 1997/10/21 14:39:22 $
- *
- *      This file contains the reading code
- *      for the QIC-117 floppy-tape driver for Linux.
- *
- */
-
-#include <linux/string.h>
-#include <linux/errno.h>
-#include <linux/mm.h>
-
-#include <linux/ftape.h>
-#include <linux/qic117.h>
-#include "../lowlevel/ftape-tracing.h"
-#include "../lowlevel/ftape-read.h"
-#include "../lowlevel/ftape-io.h"
-#include "../lowlevel/ftape-ctl.h"
-#include "../lowlevel/ftape-rw.h"
-#include "../lowlevel/ftape-write.h"
-#include "../lowlevel/ftape-ecc.h"
-#include "../lowlevel/ftape-bsm.h"
-
-/*      Global vars.
- */
-
-/*      Local vars.
- */
-
-void ftape_zap_read_buffers(void)
-{
-        int i;
-
-        for (i = 0; i < ft_nr_buffers; ++i) {
-/*  changed to "fit" with dynamic allocation of tape_buffer. --khp  */
-                ft_buffer[i]->status = waiting;
-                ft_buffer[i]->bytes = 0;
-                ft_buffer[i]->skip = 0;
-                ft_buffer[i]->retry = 0;
-        }
-/*      ftape_reset_buffer(); */
-}
-
-static SectorMap convert_sector_map(buffer_struct * buff)
-{
-        int i = 0;
-        SectorMap bad_map = ftape_get_bad_sector_entry(buff->segment_id);
-        SectorMap src_map = buff->soft_error_map | buff->hard_error_map;
-        SectorMap dst_map = 0;
-        TRACE_FUN(ft_t_any);
-
-        if (bad_map || src_map) {
-                TRACE(ft_t_flow, "bad_map = 0x%08lx", (long) bad_map);
-                TRACE(ft_t_flow, "src_map = 0x%08lx", (long) src_map);
-        }
-        while (bad_map) {
-                while ((bad_map & 1) == 0) {
-                        if (src_map & 1) {
-                                dst_map |= (1 << i);
-                        }
-                        src_map >>= 1;
-                        bad_map >>= 1;
-                        ++i;
-                }
-                /* (bad_map & 1) == 1 */
-                src_map >>= 1;
-                bad_map >>= 1;
-        }
-        if (src_map) {
-                dst_map |= (src_map << i);
-        }
-        if (dst_map) {
-                TRACE(ft_t_flow, "dst_map = 0x%08lx", (long) dst_map);
-        }
-        TRACE_EXIT dst_map;
-}
-
-static int correct_and_copy_fraction(buffer_struct *buff, __u8 * destination,
-                                     int start, int size)
-{
-        struct memory_segment mseg;
-        int result;
-        SectorMap read_bad;
-        TRACE_FUN(ft_t_any);
-
-        mseg.read_bad = convert_sector_map(buff);
-        mseg.marked_bad = 0;    /* not used... */
-        mseg.blocks = buff->bytes / FT_SECTOR_SIZE;
-        mseg.data = buff->address;
-        /*    If there are no data sectors we can skip this segment.
-         */
-        if (mseg.blocks <= 3) {
-                TRACE_ABORT(0, ft_t_noise, "empty segment");
-        }
-        read_bad = mseg.read_bad;
-        ft_history.crc_errors += count_ones(read_bad);
-        result = ftape_ecc_correct_data(&mseg);
-        if (read_bad != 0 || mseg.corrected != 0) {
-                TRACE(ft_t_noise, "crc error map: 0x%08lx", (unsigned long)read_bad);
-                TRACE(ft_t_noise, "corrected map: 0x%08lx", (unsigned long)mseg.corrected);
-                ft_history.corrected += count_ones(mseg.corrected);
-        }
-        if (result == ECC_CORRECTED || result == ECC_OK) {
-                if (result == ECC_CORRECTED) {
-                        TRACE(ft_t_info, "ecc corrected segment: %d", buff->segment_id);
-                }
-                if(start < 0) {
-                        start= 0;
-                }
-                if((start+size) > ((mseg.blocks - 3) * FT_SECTOR_SIZE)) {
-                        size = (mseg.blocks - 3) * FT_SECTOR_SIZE  - start;
-                } 
-                if (size < 0) {
-                        size= 0;
-                }
-                if(size > 0) {
-                        memcpy(destination + start, mseg.data + start, size);
-                }
-                if ((read_bad ^ mseg.corrected) & mseg.corrected) {
-                        /* sectors corrected without crc errors set */
-                        ft_history.crc_failures++;
-                }
-                TRACE_EXIT size; /* (mseg.blocks - 3) * FT_SECTOR_SIZE; */
-        } else {
-                ft_history.ecc_failures++;
-                TRACE_ABORT(-EAGAIN,
-                            ft_t_err, "ecc failure on segment %d",
-                            buff->segment_id);
-        }
-        TRACE_EXIT 0;
-}
-
-/*      Read given segment into buffer at address.
- */
-int ftape_read_segment_fraction(const int segment_id,
-                                void  *address, 
-                                const ft_read_mode_t read_mode,
-                                const int start,
-                                const int size)
-{
-        int result = 0;
-        int retry  = 0;
-        int bytes_read = 0;
-        int read_done  = 0;
-        TRACE_FUN(ft_t_flow);
-
-        ft_history.used |= 1;
-        TRACE(ft_t_data_flow, "segment_id = %d", segment_id);
-        if (ft_driver_state != reading) {
-                TRACE(ft_t_noise, "calling ftape_abort_operation");
-                TRACE_CATCH(ftape_abort_operation(),);
-                ftape_set_state(reading);
-        }
-        for(;;) {
-                buffer_struct *tail;
-                /*  Allow escape from this loop on signal !
-                 */
-                FT_SIGNAL_EXIT(_DONT_BLOCK);
-                /*  Search all full buffers for the first matching the
-                 *  wanted segment.  Clear other buffers on the fly.
-                 */
-                tail = ftape_get_buffer(ft_queue_tail);
-                while (!read_done && tail->status == done) {
-                        /*  Allow escape from this loop on signal !
-                         */
-                        FT_SIGNAL_EXIT(_DONT_BLOCK);
-                        if (tail->segment_id == segment_id) {
-                                /*  If out buffer is already full,
-                                 *  return its contents.  
-                                 */
-                                TRACE(ft_t_flow, "found segment in cache: %d",
-                                      segment_id);
-                                if (tail->deleted) {
-                                        /*  Return a value that
-                                         *  read_header_segment
-                                         *  understands.  As this
-                                         *  should only occur when
-                                         *  searching for the header
-                                         *  segments it shouldn't be
-                                         *  misinterpreted elsewhere.
-                                         */
-                                        TRACE_EXIT 0;
-                                }
-                                result = correct_and_copy_fraction(
-                                        tail,
-                                        address,
-                                        start,
-                                        size);
-                                TRACE(ft_t_flow, "segment contains (bytes): %d",
-                                      result);
-                                if (result < 0) {
-                                        if (result != -EAGAIN) {
-                                                TRACE_EXIT result;
-                                        }
-                                        /* keep read_done == 0, will
-                                         * trigger
-                                         * ftape_abort_operation
-                                         * because reading wrong
-                                         * segment.
-                                         */
-                                        TRACE(ft_t_err, "ecc failed, retry");
-                                        ++retry;
-                                } else {
-                                        read_done = 1;
-                                        bytes_read = result;
-                                }
-                        } else {
-                                TRACE(ft_t_flow,"zapping segment in cache: %d",
-                                      tail->segment_id);
-                        }
-                        tail->status = waiting;
-                        tail = ftape_next_buffer(ft_queue_tail);
-                }
-                if (!read_done && tail->status == reading) {
-                        if (tail->segment_id == segment_id) {
-                                switch(ftape_wait_segment(reading)) {
-                                case 0:
-                                        break;
-                                case -EINTR:
-                                        TRACE_ABORT(-EINTR, ft_t_warn,
-                                                    "interrupted by "
-                                                    "non-blockable signal");
-                                        break;
-                                default:
-                                        TRACE(ft_t_noise,
-                                              "wait_segment failed");
-                                        ftape_abort_operation();
-                                        ftape_set_state(reading);
-                                        break;
-                                }
-                        } else {
-                                /*  We're reading the wrong segment,
-                                 *  stop runner.
-                                 */
-                                TRACE(ft_t_noise, "reading wrong segment");
-                                ftape_abort_operation();
-                                ftape_set_state(reading);
-                        }
-                }
-                /*    should runner stop ?
-                 */
-                if (ft_runner_status == aborting) {
-                        buffer_struct *head = ftape_get_buffer(ft_queue_head);
-                        switch(head->status) {
-                        case error:
-                                ft_history.defects += 
-                                        count_ones(head->hard_error_map);
-                        case reading:
-                                head->status = waiting;
-                                break;
-                        default:
-                                break;
-                        }
-                        TRACE_CATCH(ftape_dumb_stop(),);
-                } else {
-                        /*  If just passed last segment on tape: wait
-                         *  for BOT or EOT mark. Sets ft_runner_status to
-                         *  idle if at lEOT and successful 
-                         */
-                        TRACE_CATCH(ftape_handle_logical_eot(),);
-                }
-                /*    If we got a segment: quit, or else retry up to limit.
-                 *
-                 *    If segment to read is empty, do not start runner for it,
-                 *    but wait for next read call.
-                 */
-                if (read_done ||
-                    ftape_get_bad_sector_entry(segment_id) == EMPTY_SEGMENT ) {
-                        /* bytes_read = 0;  should still be zero */
-                        TRACE_EXIT bytes_read;
-
-                }
-                if (retry > FT_RETRIES_ON_ECC_ERROR) {
-                        ft_history.defects++;
-                        TRACE_ABORT(-ENODATA, ft_t_err,
-                                    "too many retries on ecc failure");
-                }
-                /*    Now at least one buffer is empty !
-                 *    Restart runner & tape if needed.
-                 */
-                TRACE(ft_t_any, "head: %d, tail: %d, ft_runner_status: %d",
-                      ftape_buffer_id(ft_queue_head),
-                      ftape_buffer_id(ft_queue_tail),
-                      ft_runner_status);
-                TRACE(ft_t_any, "buffer[].status, [head]: %d, [tail]: %d",
-                      ftape_get_buffer(ft_queue_head)->status,
-                      ftape_get_buffer(ft_queue_tail)->status);
-                tail = ftape_get_buffer(ft_queue_tail);
-                if (tail->status == waiting) {
-                        buffer_struct *head = ftape_get_buffer(ft_queue_head);
-
-                        ftape_setup_new_segment(head, segment_id, -1);
-                        if (read_mode == FT_RD_SINGLE) {
-                                /* disable read-ahead */
-                                head->next_segment = 0;
-                        }
-                        ftape_calc_next_cluster(head);
-                        if (ft_runner_status == idle) {
-                                result = ftape_start_tape(segment_id,
-                                                          head->sector_offset);
-                                if (result < 0) {
-                                        TRACE_ABORT(result, ft_t_err, "Error: "
-                                                    "segment %d unreachable",
-                                                    segment_id);
-                                }
-                        }
-                        head->status = reading;
-                        fdc_setup_read_write(head, FDC_READ);
-                }
-        }
-        /* not reached */
-        TRACE_EXIT -EIO;
-}
-
-int ftape_read_header_segment(__u8 *address)
-{
-        int result;
-        int header_segment;
-        int first_failed = 0;
-        int status;
-        TRACE_FUN(ft_t_flow);
-
-        ft_used_header_segment = -1;
-        TRACE_CATCH(ftape_report_drive_status(&status),);
-        TRACE(ft_t_flow, "reading...");
-        /*  We're looking for the first header segment.
-         *  A header segment cannot contain bad sectors, therefor at the
-         *  tape start, segments with bad sectors are (according to QIC-40/80)
-         *  written with deleted data marks and must be skipped.
-         */
-        memset(address, '\0', (FT_SECTORS_PER_SEGMENT - 3) * FT_SECTOR_SIZE); 
-        result = 0;
-#define HEADER_SEGMENT_BOUNDARY 68  /* why not 42? */
-        for (header_segment = 0;
-             header_segment < HEADER_SEGMENT_BOUNDARY && result == 0;
-             ++header_segment) {
-                /*  Set no read-ahead, the isr will force read-ahead whenever
-                 *  it encounters deleted data !
-                 */
-                result = ftape_read_segment(header_segment,
-                                            address,
-                                            FT_RD_SINGLE);
-                if (result < 0 && !first_failed) {
-                        TRACE(ft_t_err, "header segment damaged, trying backup");
-                        first_failed = 1;
-                        result = 0;     /* force read of next (backup) segment */
-                }
-        }
-        if (result < 0 || header_segment >= HEADER_SEGMENT_BOUNDARY) {
-                TRACE_ABORT(-EIO, ft_t_err,
-                            "no readable header segment found");
-        }
-        TRACE_CATCH(ftape_abort_operation(),);
-        ft_used_header_segment = header_segment;
-        result = ftape_decode_header_segment(address);
-        TRACE_EXIT result;
-}
-
-int ftape_decode_header_segment(__u8 *address)
-{
-        unsigned int max_floppy_side;
-        unsigned int max_floppy_track;
-        unsigned int max_floppy_sector;
-        unsigned int new_tape_len;
-        TRACE_FUN(ft_t_flow);
-
-        if (GET4(address, FT_SIGNATURE) == FT_D2G_MAGIC) {
-                /* Ditto 2GB header segment. They encrypt the bad sector map.
-                 * We decrypt it and store them in normal format.
-                 * I hope this is correct.
-                 */
-                int i;
-                TRACE(ft_t_warn,
-                      "Found Ditto 2GB tape, "
-                      "trying to decrypt bad sector map");
-                for (i=256; i < 29 * FT_SECTOR_SIZE; i++) {
-                        address[i] = ~(address[i] - (i&0xff));
-                }
-                PUT4(address, 0,FT_HSEG_MAGIC);
-        } else if (GET4(address, FT_SIGNATURE) != FT_HSEG_MAGIC) {
-                TRACE_ABORT(-EIO, ft_t_err,
-                            "wrong signature in header segment");
-        }
-        ft_format_code = (ft_format_type) address[FT_FMT_CODE];
-        if (ft_format_code != fmt_big) {
-                ft_header_segment_1   = GET2(address, FT_HSEG_1);
-                ft_header_segment_2   = GET2(address, FT_HSEG_2);
-                ft_first_data_segment = GET2(address, FT_FRST_SEG);
-                ft_last_data_segment  = GET2(address, FT_LAST_SEG);
-        } else {
-                ft_header_segment_1   = GET4(address, FT_6_HSEG_1);
-                ft_header_segment_2   = GET4(address, FT_6_HSEG_2);
-                ft_first_data_segment = GET4(address, FT_6_FRST_SEG);
-                ft_last_data_segment  = GET4(address, FT_6_LAST_SEG);
-        }
-        TRACE(ft_t_noise, "first data segment: %d", ft_first_data_segment);
-        TRACE(ft_t_noise, "last  data segment: %d", ft_last_data_segment);
-        TRACE(ft_t_noise, "header segments are %d and %d",
-              ft_header_segment_1, ft_header_segment_2);
-
-        /*    Verify tape parameters...
-         *    QIC-40/80 spec:                 tape_parameters:
-         *
-         *    segments-per-track              segments_per_track
-         *    tracks-per-cartridge            tracks_per_tape
-         *    max-floppy-side                 (segments_per_track *
-         *                                    tracks_per_tape - 1) /
-         *                                    ftape_segments_per_head
-         *    max-floppy-track                ftape_segments_per_head /
-         *                                    ftape_segments_per_cylinder - 1
-         *    max-floppy-sector               ftape_segments_per_cylinder *
-         *                                    FT_SECTORS_PER_SEGMENT
-         */
-        ft_segments_per_track = GET2(address, FT_SPT);
-        ft_tracks_per_tape    = address[FT_TPC];
-        max_floppy_side       = address[FT_FHM];
-        max_floppy_track      = address[FT_FTM];
-        max_floppy_sector     = address[FT_FSM];
-        TRACE(ft_t_noise, "(fmt/spt/tpc/fhm/ftm/fsm) = %d/%d/%d/%d/%d/%d",
-              ft_format_code, ft_segments_per_track, ft_tracks_per_tape,
-              max_floppy_side, max_floppy_track, max_floppy_sector);
-        new_tape_len = ftape_tape_len;
-        switch (ft_format_code) {
-        case fmt_425ft:
-                new_tape_len = 425;
-                break;
-        case fmt_normal:
-                if (ftape_tape_len == 0) {      /* otherwise 307 ft */
-                        new_tape_len = 205;
-                }
-                break;
-        case fmt_1100ft:
-                new_tape_len = 1100;
-                break;
-        case fmt_var:{
-                        int segments_per_1000_inch = 1;         /* non-zero default for switch */
-                        switch (ft_qic_std) {
-                        case QIC_TAPE_QIC40:
-                                segments_per_1000_inch = 332;
-                                break;
-                        case QIC_TAPE_QIC80:
-                                segments_per_1000_inch = 488;
-                                break;
-                        case QIC_TAPE_QIC3010:
-                                segments_per_1000_inch = 730;
-                                break;
-                        case QIC_TAPE_QIC3020:
-                                segments_per_1000_inch = 1430;
-                                break;
-                        }
-                        new_tape_len = (1000 * ft_segments_per_track +
-                                        (segments_per_1000_inch - 1)) / segments_per_1000_inch;
-                        break;
-                }
-        case fmt_big:{
-                        int segments_per_1000_inch = 1;         /* non-zero default for switch */
-                        switch (ft_qic_std) {
-                        case QIC_TAPE_QIC40:
-                                segments_per_1000_inch = 332;
-                                break;
-                        case QIC_TAPE_QIC80:
-                                segments_per_1000_inch = 488;
-                                break;
-                        case QIC_TAPE_QIC3010:
-                                segments_per_1000_inch = 730;
-                                break;
-                        case QIC_TAPE_QIC3020:
-                                segments_per_1000_inch = 1430;
-                                break;
-                        default:
-                                TRACE_ABORT(-EIO, ft_t_bug,
-                        "%x QIC-standard with fmt-code %d, please report",
-                                            ft_qic_std, ft_format_code);
-                        }
-                        new_tape_len = ((1000 * ft_segments_per_track +
-                                         (segments_per_1000_inch - 1)) / 
-                                        segments_per_1000_inch);
-                        break;
-                }
-        default:
-                TRACE_ABORT(-EIO, ft_t_err,
-                            "unknown tape format, please report !");
-        }
-        if (new_tape_len != ftape_tape_len) {
-                ftape_tape_len = new_tape_len;
-                TRACE(ft_t_info, "calculated tape length is %d ft",
-                      ftape_tape_len);
-                ftape_calc_timeouts(ft_qic_std, ft_data_rate, ftape_tape_len);
-        }
-        if (ft_segments_per_track == 0 && ft_tracks_per_tape == 0 &&
-            max_floppy_side == 0 && max_floppy_track == 0 &&
-            max_floppy_sector == 0) {
-                /*  QIC-40 Rev E and earlier has no values in the header.
-                 */
-                ft_segments_per_track = 68;
-                ft_tracks_per_tape = 20;
-                max_floppy_side = 1;
-                max_floppy_track = 169;
-                max_floppy_sector = 128;
-        }
-        /*  This test will compensate for the wrong parameter on tapes
-         *  formatted by Conner software.
-         */
-        if (ft_segments_per_track == 150 &&
-            ft_tracks_per_tape == 28 &&
-            max_floppy_side == 7 &&
-            max_floppy_track == 149 &&
-            max_floppy_sector == 128) {
-TRACE(ft_t_info, "the famous CONNER bug: max_floppy_side off by one !");
-                max_floppy_side = 6;
-        }
-        /*  These tests will compensate for the wrong parameter on tapes
-         *  formatted by ComByte Windows software.
-         *
-         *  First, for 205 foot tapes
-         */
-        if (ft_segments_per_track == 100 &&
-            ft_tracks_per_tape == 28 &&
-            max_floppy_side == 9 &&
-            max_floppy_track == 149 &&
-            max_floppy_sector == 128) {
-TRACE(ft_t_info, "the ComByte bug: max_floppy_side incorrect!");
-                max_floppy_side = 4;
-        }
-        /* Next, for 307 foot tapes. */
-        if (ft_segments_per_track == 150 &&
-            ft_tracks_per_tape == 28 &&
-            max_floppy_side == 9 &&
-            max_floppy_track == 149 &&
-            max_floppy_sector == 128) {
-TRACE(ft_t_info, "the ComByte bug: max_floppy_side incorrect!");
-                max_floppy_side = 6;
-        }
-        /*  This test will compensate for the wrong parameter on tapes
-         *  formatted by Colorado Windows software.
-         */
-        if (ft_segments_per_track == 150 &&
-            ft_tracks_per_tape == 28 &&
-            max_floppy_side == 6 &&
-            max_floppy_track == 150 &&
-            max_floppy_sector == 128) {
-TRACE(ft_t_info, "the famous Colorado bug: max_floppy_track off by one !");
-                max_floppy_track = 149;
-        }
-        ftape_segments_per_head = ((max_floppy_sector/FT_SECTORS_PER_SEGMENT) *
-                                   (max_floppy_track + 1));
-        /*  This test will compensate for some bug reported by Dima
-         *  Brodsky.  Seems to be a Colorado bug, either. (freebee
-         *  Imation tape shipped together with Colorado T3000
-         */
-        if ((ft_format_code == fmt_var || ft_format_code == fmt_big) &&
-            ft_tracks_per_tape == 50 &&
-            max_floppy_side == 54 &&
-            max_floppy_track == 255 &&
-            max_floppy_sector == 128) {
-TRACE(ft_t_info, "the famous ??? bug: max_floppy_track off by one !");
-                max_floppy_track = 254;
-        }
-        /*
-         *    Verify drive_configuration with tape parameters
-         */
-        if (ftape_segments_per_head == 0 || ftape_segments_per_cylinder == 0 ||
-          ((ft_segments_per_track * ft_tracks_per_tape - 1) / ftape_segments_per_head
-           != max_floppy_side) ||
-            (ftape_segments_per_head / ftape_segments_per_cylinder - 1 != max_floppy_track) ||
-        (ftape_segments_per_cylinder * FT_SECTORS_PER_SEGMENT != max_floppy_sector)
-#ifdef TESTING
-            || ((ft_format_code == fmt_var || ft_format_code == fmt_big) && 
-                (max_floppy_track != 254 || max_floppy_sector != 128))
-#endif
-           ) {
-                char segperheadz = ftape_segments_per_head ? ' ' : '?';
-                char segpercylz  = ftape_segments_per_cylinder ? ' ' : '?';
-                TRACE(ft_t_err,"Tape parameters inconsistency, please report");
-                TRACE(ft_t_err, "reported = %d/%d/%d/%d/%d/%d",
-                      ft_format_code,
-                      ft_segments_per_track,
-                      ft_tracks_per_tape,
-                      max_floppy_side,
-                      max_floppy_track,
-                      max_floppy_sector);
-                TRACE(ft_t_err, "required = %d/%d/%d/%d%c/%d%c/%d",
-                      ft_format_code,
-                      ft_segments_per_track,
-                      ft_tracks_per_tape,
-                      ftape_segments_per_head ?
-                      ((ft_segments_per_track * ft_tracks_per_tape -1) / 
-                       ftape_segments_per_head ) :
-                        (ft_segments_per_track * ft_tracks_per_tape -1),
-                        segperheadz,
-                      ftape_segments_per_cylinder ?
-                      (ftape_segments_per_head / 
-                       ftape_segments_per_cylinder - 1 ) :
-                        ftape_segments_per_head - 1,
-                        segpercylz,
-                      (ftape_segments_per_cylinder * FT_SECTORS_PER_SEGMENT));
-                TRACE_EXIT -EIO;
-        }
-        ftape_extract_bad_sector_map(address);
-        TRACE_EXIT 0;
-}
diff --git a/drivers/char/ftape/lowlevel/ftape-read.h b/drivers/char/ftape/lowlevel/ftape-read.h
deleted file mode 100644
index 069f99f2a984..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-read.h
+++ /dev/null
@@ -1,51 +0,0 @@
-#ifndef _FTAPE_READ_H
-#define _FTAPE_READ_H
-
-/*
- * Copyright (C) 1994-1996 Bas Laarhoven,
- *           (C) 1996-1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-read.h,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:18:22 $
- *
- *      This file contains the definitions for the read functions
- *      for the QIC-117 floppy-tape driver for Linux.
- *
- */
-
-/*      ftape-read.c defined global functions.
- */
-typedef enum {
-        FT_RD_SINGLE = 0,
-        FT_RD_AHEAD  = 1,
-} ft_read_mode_t;
-
-extern int ftape_read_header_segment(__u8 *address);
-extern int ftape_decode_header_segment(__u8 *address);
-extern int ftape_read_segment_fraction(const int segment,
-                                       void  *address, 
-                                       const ft_read_mode_t read_mode,
-                                       const int start,
-                                       const int size);
-#define ftape_read_segment(segment, address, read_mode)                 \
-        ftape_read_segment_fraction(segment, address, read_mode,        \
-                                    0, FT_SEGMENT_SIZE)
-extern void ftape_zap_read_buffers(void);
-
-#endif                          /* _FTAPE_READ_H */
diff --git a/drivers/char/ftape/lowlevel/ftape-rw.c b/drivers/char/ftape/lowlevel/ftape-rw.c
deleted file mode 100644
index c0d6dc2cbfd3..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-rw.c
+++ /dev/null
@@ -1,1092 +0,0 @@
-/*
- *      Copyright (C) 1993-1996 Bas Laarhoven,
- *                (C) 1996-1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-rw.c,v $
- * $Revision: 1.7 $
- * $Date: 1997/10/28 14:26:49 $
- *
- *      This file contains some common code for the segment read and
- *      segment write routines for the QIC-117 floppy-tape driver for
- *      Linux.
- */
-
-#include <linux/string.h>
-#include <linux/errno.h>
-
-#include <linux/ftape.h>
-#include <linux/qic117.h>
-#include "../lowlevel/ftape-tracing.h"
-#include "../lowlevel/ftape-rw.h"
-#include "../lowlevel/fdc-io.h"
-#include "../lowlevel/ftape-init.h"
-#include "../lowlevel/ftape-io.h"
-#include "../lowlevel/ftape-ctl.h"
-#include "../lowlevel/ftape-read.h"
-#include "../lowlevel/ftape-ecc.h"
-#include "../lowlevel/ftape-bsm.h"
-
-/*      Global vars.
- */
-int ft_nr_buffers;
-buffer_struct *ft_buffer[FT_MAX_NR_BUFFERS];
-static volatile int ft_head;
-static volatile int ft_tail;    /* not volatile but need same type as head */
-int fdc_setup_error;
-location_record ft_location = {-1, 0};
-volatile int ftape_tape_running;
-
-/*      Local vars.
- */
-static int overrun_count_offset;
-static int inhibit_correction;
-
-/*  maxmimal allowed overshoot when fast seeking
- */
-#define OVERSHOOT_LIMIT 10
-
-/*      Increment cyclic buffer nr.
- */
-buffer_struct *ftape_next_buffer(ft_buffer_queue_t pos)
-{
-        switch (pos) {
-        case ft_queue_head:
-                if (++ft_head >= ft_nr_buffers) {
-                        ft_head = 0;
-                }
-                return ft_buffer[ft_head];
-        case ft_queue_tail:
-                if (++ft_tail >= ft_nr_buffers) {
-                        ft_tail = 0;
-                }
-                return ft_buffer[ft_tail];
-        default:
-                return NULL;
-        }
-}
-int ftape_buffer_id(ft_buffer_queue_t pos)
-{
-        switch(pos) {
-        case ft_queue_head: return ft_head;
-        case ft_queue_tail: return ft_tail;
-        default: return -1;
-        }
-}
-buffer_struct *ftape_get_buffer(ft_buffer_queue_t pos)
-{
-        switch(pos) {
-        case ft_queue_head: return ft_buffer[ft_head];
-        case ft_queue_tail: return ft_buffer[ft_tail];
-        default: return NULL;
-        }
-}
-void ftape_reset_buffer(void)
-{
-        ft_head = ft_tail = 0;
-}
-
-buffer_state_enum ftape_set_state(buffer_state_enum new_state)
-{
-        buffer_state_enum old_state = ft_driver_state;
-
-        ft_driver_state = new_state;
-        return old_state;
-}
-/*      Calculate Floppy Disk Controller and DMA parameters for a segment.
- *      head:   selects buffer struct in array.
- *      offset: number of physical sectors to skip (including bad ones).
- *      count:  number of physical sectors to handle (including bad ones).
- */
-static int setup_segment(buffer_struct * buff, 
-                         int segment_id,
-                         unsigned int sector_offset, 
-                         unsigned int sector_count, 
-                         int retry)
-{
-        SectorMap offset_mask;
-        SectorMap mask;
-        TRACE_FUN(ft_t_any);
-
-        buff->segment_id = segment_id;
-        buff->sector_offset = sector_offset;
-        buff->remaining = sector_count;
-        buff->head = segment_id / ftape_segments_per_head;
-        buff->cyl = (segment_id % ftape_segments_per_head) / ftape_segments_per_cylinder;
-        buff->sect = (segment_id % ftape_segments_per_cylinder) * FT_SECTORS_PER_SEGMENT + 1;
-        buff->deleted = 0;
-        offset_mask = (1 << buff->sector_offset) - 1;
-        mask = ftape_get_bad_sector_entry(segment_id) & offset_mask;
-        while (mask) {
-                if (mask & 1) {
-                        offset_mask >>= 1;      /* don't count bad sector */
-                }
-                mask >>= 1;
-        }
-        buff->data_offset = count_ones(offset_mask);    /* good sectors to skip */
-        buff->ptr = buff->address + buff->data_offset * FT_SECTOR_SIZE;
-        TRACE(ft_t_flow, "data offset = %d sectors", buff->data_offset);
-        if (retry) {
-                buff->soft_error_map &= offset_mask;    /* keep skipped part */
-        } else {
-                buff->hard_error_map = buff->soft_error_map = 0;
-        }
-        buff->bad_sector_map = ftape_get_bad_sector_entry(buff->segment_id);
-        if (buff->bad_sector_map != 0) {
-                TRACE(ft_t_noise, "segment: %d, bad sector map: %08lx",
-                        buff->segment_id, (long)buff->bad_sector_map);
-        } else {
-                TRACE(ft_t_flow, "segment: %d", buff->segment_id);
-        }
-        if (buff->sector_offset > 0) {
-                buff->bad_sector_map >>= buff->sector_offset;
-        }
-        if (buff->sector_offset != 0 || buff->remaining != FT_SECTORS_PER_SEGMENT) {
-                TRACE(ft_t_flow, "sector offset = %d, count = %d",
-                        buff->sector_offset, buff->remaining);
-        }
-        /*    Segments with 3 or less sectors are not written with valid
-         *    data because there is no space left for the ecc.  The
-         *    data written is whatever happens to be in the buffer.
-         *    Reading such a segment will return a zero byte-count.
-         *    To allow us to read/write segments with all bad sectors
-         *    we fake one readable sector in the segment. This
-         *    prevents having to handle these segments in a very
-         *    special way.  It is not important if the reading of this
-         *    bad sector fails or not (the data is ignored). It is
-         *    only read to keep the driver running.
-         *
-         *    The QIC-40/80 spec. has no information on how to handle
-         *    this case, so this is my interpretation.  
-         */
-        if (buff->bad_sector_map == EMPTY_SEGMENT) {
-                TRACE(ft_t_flow, "empty segment %d, fake first sector good",
-                      buff->segment_id);
-                if (buff->ptr != buff->address) {
-                        TRACE(ft_t_bug, "This is a bug: %p/%p",
-                              buff->ptr, buff->address);
-                }
-                buff->bad_sector_map = FAKE_SEGMENT;
-        }
-        fdc_setup_error = 0;
-        buff->next_segment = segment_id + 1;
-        TRACE_EXIT 0;
-}
-
-/*      Calculate Floppy Disk Controller and DMA parameters for a new segment.
- */
-int ftape_setup_new_segment(buffer_struct * buff, int segment_id, int skip)
-{
-        int result = 0;
-        static int old_segment_id = -1;
-        static buffer_state_enum old_ft_driver_state = idle;
-        int retry = 0;
-        unsigned offset = 0;
-        int count = FT_SECTORS_PER_SEGMENT;
-        TRACE_FUN(ft_t_flow);
-
-        TRACE(ft_t_flow, "%s segment %d (old = %d)",
-              (ft_driver_state == reading || ft_driver_state == verifying) 
-              ? "reading" : "writing",
-              segment_id, old_segment_id);
-        if (ft_driver_state != old_ft_driver_state) {   /* when verifying */
-                old_segment_id = -1;
-                old_ft_driver_state = ft_driver_state;
-        }
-        if (segment_id == old_segment_id) {
-                ++buff->retry;
-                ++ft_history.retries;
-                TRACE(ft_t_flow, "setting up for retry nr %d", buff->retry);
-                retry = 1;
-                if (skip && buff->skip > 0) {   /* allow skip on retry */
-                        offset = buff->skip;
-                        count -= offset;
-                        TRACE(ft_t_flow, "skipping %d sectors", offset);
-                }
-        } else {
-                buff->retry = 0;
-                buff->skip = 0;
-                old_segment_id = segment_id;
-        }
-        result = setup_segment(buff, segment_id, offset, count, retry);
-        TRACE_EXIT result;
-}
-
-/*      Determine size of next cluster of good sectors.
- */
-int ftape_calc_next_cluster(buffer_struct * buff)
-{
-        /* Skip bad sectors.
-         */
-        while (buff->remaining > 0 && (buff->bad_sector_map & 1) != 0) {
-                buff->bad_sector_map >>= 1;
-                ++buff->sector_offset;
-                --buff->remaining;
-        }
-        /* Find next cluster of good sectors
-         */
-        if (buff->bad_sector_map == 0) {        /* speed up */
-                buff->sector_count = buff->remaining;
-        } else {
-                SectorMap map = buff->bad_sector_map;
-
-                buff->sector_count = 0;
-                while (buff->sector_count < buff->remaining && (map & 1) == 0) {
-                        ++buff->sector_count;
-                        map >>= 1;
-                }
-        }
-        return buff->sector_count;
-}
-
-/*  if just passed the last segment on a track, wait for BOT
- *  or EOT mark.
- */
-int ftape_handle_logical_eot(void)
-{
-        TRACE_FUN(ft_t_flow);
-
-        if (ft_runner_status == logical_eot) {
-                int status;
-
-                TRACE(ft_t_noise, "tape at logical EOT");
-                TRACE_CATCH(ftape_ready_wait(ftape_timeout.seek, &status),);
-                if ((status & (QIC_STATUS_AT_BOT | QIC_STATUS_AT_EOT)) == 0) {
-                        TRACE_ABORT(-EIO, ft_t_err, "eot/bot not reached");
-                }
-                ft_runner_status = end_of_tape;
-        }
-        if (ft_runner_status == end_of_tape) {
-                TRACE(ft_t_noise, "runner stopped because of logical EOT");
-                ft_runner_status = idle;
-        }
-        TRACE_EXIT 0;
-}
-
-static int check_bot_eot(int status)
-{
-        TRACE_FUN(ft_t_flow);
-
-        if (status & (QIC_STATUS_AT_BOT | QIC_STATUS_AT_EOT)) {
-                ft_location.bot = ((ft_location.track & 1) == 0 ?
-                                (status & QIC_STATUS_AT_BOT) != 0:
-                                (status & QIC_STATUS_AT_EOT) != 0);
-                ft_location.eot = !ft_location.bot;
-                ft_location.segment = (ft_location.track +
-                        (ft_location.bot ? 0 : 1)) * ft_segments_per_track - 1;
-                ft_location.sector = -1;
-                ft_location.known  = 1;
-                TRACE(ft_t_flow, "tape at logical %s",
-                      ft_location.bot ? "bot" : "eot");
-                TRACE(ft_t_flow, "segment = %d", ft_location.segment);
-        } else {
-                ft_location.known = 0;
-        }
-        TRACE_EXIT ft_location.known;
-}
-
-/*      Read Id of first sector passing tape head.
- */
-static int ftape_read_id(void)
-{
-        int status;
-        __u8 out[2];
-        TRACE_FUN(ft_t_any);
-
-        /* Assume tape is running on entry, be able to handle
-         * situation where it stopped or is stopping.
-         */
-        ft_location.known = 0;  /* default is location not known */
-        out[0] = FDC_READID;
-        out[1] = ft_drive_sel;
-        TRACE_CATCH(fdc_command(out, 2),);
-        switch (fdc_interrupt_wait(20 * FT_SECOND)) {
-        case 0:
-                if (fdc_sect == 0) {
-                        if (ftape_report_drive_status(&status) >= 0 &&
-                            (status & QIC_STATUS_READY)) {
-                                ftape_tape_running = 0;
-                                TRACE(ft_t_flow, "tape has stopped");
-                                check_bot_eot(status);
-                        }
-                } else {
-                        ft_location.known = 1;
-                        ft_location.segment = (ftape_segments_per_head
-                                               * fdc_head
-                                               + ftape_segments_per_cylinder
-                                               * fdc_cyl
-                                               + (fdc_sect - 1)
-                                               / FT_SECTORS_PER_SEGMENT);
-                        ft_location.sector = ((fdc_sect - 1)
-                                              % FT_SECTORS_PER_SEGMENT);
-                        ft_location.eot = ft_location.bot = 0;
-                }
-                break;
-        case -ETIME:
-                /*  Didn't find id on tape, must be near end: Wait
-                 *  until stopped.
-                 */
-                if (ftape_ready_wait(FT_FOREVER, &status) >= 0) {
-                        ftape_tape_running = 0;
-                        TRACE(ft_t_flow, "tape has stopped");
-                        check_bot_eot(status);
-                }
-                break;
-        default:
-                /*  Interrupted or otherwise failing
-                 *  fdc_interrupt_wait() 
-                 */
-                TRACE(ft_t_err, "fdc_interrupt_wait failed");
-                break;
-        }
-        if (!ft_location.known) {
-                TRACE_ABORT(-EIO, ft_t_flow, "no id found");
-        }
-        if (ft_location.sector == 0) {
-                TRACE(ft_t_flow, "passing segment %d/%d",
-                      ft_location.segment, ft_location.sector);
-        } else {
-                TRACE(ft_t_fdc_dma, "passing segment %d/%d",
-                      ft_location.segment, ft_location.sector);
-        }
-        TRACE_EXIT 0;
-}
-
-static int logical_forward(void)
-{
-        ftape_tape_running = 1;
-        return ftape_command(QIC_LOGICAL_FORWARD);
-}
-
-int ftape_stop_tape(int *pstatus)
-{
-        int retry = 0;
-        int result;
-        TRACE_FUN(ft_t_flow);
-
-        do {
-                result = ftape_command_wait(QIC_STOP_TAPE,
-                                            ftape_timeout.stop, pstatus);
-                if (result == 0) {
-                        if ((*pstatus & QIC_STATUS_READY) == 0) {
-                                result = -EIO;
-                        } else {
-                                ftape_tape_running = 0;
-                        }
-                }
-        } while (result < 0 && ++retry <= 3);
-        if (result < 0) {
-                TRACE(ft_t_err, "failed ! (fatal)");
-        }
-        TRACE_EXIT result;
-}
-
-int ftape_dumb_stop(void)
-{
-        int result;
-        int status;
-        TRACE_FUN(ft_t_flow);
-
-        /*  Abort current fdc operation if it's busy (probably read
-         *  or write operation pending) with a reset.
-         */
-        if (fdc_ready_wait(100 /* usec */) < 0) {
-                TRACE(ft_t_noise, "aborting fdc operation");
-                fdc_reset();
-        }
-        /*  Reading id's after the last segment on a track may fail
-         *  but eventually the drive will become ready (logical eot).
-         */
-        result = ftape_report_drive_status(&status);
-        ft_location.known = 0;
-        do {
-                if (result == 0 && status & QIC_STATUS_READY) {
-                        /* Tape is not running any more.
-                         */
-                        TRACE(ft_t_noise, "tape already halted");
-                        check_bot_eot(status);
-                        ftape_tape_running = 0;
-                } else if (ftape_tape_running) {
-                        /*  Tape is (was) still moving.
-                         */
-#ifdef TESTING
-                        ftape_read_id();
-#endif
-                        result = ftape_stop_tape(&status);
-                } else {
-                        /*  Tape not yet ready but stopped.
-                         */
-                        result = ftape_ready_wait(ftape_timeout.pause,&status);
-                }
-        } while (ftape_tape_running
-                 && !(sigtestsetmask(&current->pending.signal, _NEVER_BLOCK)));
-#ifndef TESTING
-        ft_location.known = 0;
-#endif
-        if (ft_runner_status == aborting || ft_runner_status == do_abort) {
-                ft_runner_status = idle;
-        }
-        TRACE_EXIT result;
-}
-
-/*      Wait until runner has finished tail buffer.
- *
- */
-int ftape_wait_segment(buffer_state_enum state)
-{
-        int status;
-        int result = 0;
-        TRACE_FUN(ft_t_flow);
-
-        while (ft_buffer[ft_tail]->status == state) {
-                TRACE(ft_t_flow, "state: %d", ft_buffer[ft_tail]->status);
-                /*  First buffer still being worked on, wait up to timeout.
-                 *
-                 *  Note: we check two times for being killed. 50
-                 *  seconds are quite long. Note that
-                 *  fdc_interrupt_wait() is not killable by any
-                 *  means. ftape_read_segment() wants us to return
-                 *  -EINTR in case of a signal.  
-                 */
-                FT_SIGNAL_EXIT(_DONT_BLOCK);
-                result = fdc_interrupt_wait(50 * FT_SECOND);
-                FT_SIGNAL_EXIT(_DONT_BLOCK);
-                if (result < 0) {
-                        TRACE_ABORT(result,
-                                    ft_t_err, "fdc_interrupt_wait failed");
-                }
-                if (fdc_setup_error) {
-                        /* recover... FIXME */
-                        TRACE_ABORT(-EIO, ft_t_err, "setup error");
-                }
-        }
-        if (ft_buffer[ft_tail]->status != error) {
-                TRACE_EXIT 0;
-        }
-        TRACE_CATCH(ftape_report_drive_status(&status),);
-        TRACE(ft_t_noise, "ftape_report_drive_status: 0x%02x", status);
-        if ((status & QIC_STATUS_READY) && 
-            (status & QIC_STATUS_ERROR)) {
-                unsigned int error;
-                qic117_cmd_t command;
-                
-                /*  Report and clear error state.
-                 *  In case the drive can't operate at the selected
-                 *  rate, select the next lower data rate.
-                 */
-                ftape_report_error(&error, &command, 1);
-                if (error == 31 && command == QIC_LOGICAL_FORWARD) {
-                        /* drive does not accept this data rate */
-                        if (ft_data_rate > 250) {
-                                TRACE(ft_t_info,
-                                      "Probable data rate conflict");
-                                TRACE(ft_t_info,
-                                      "Lowering data rate to %d Kbps",
-                                      ft_data_rate / 2);
-                                ftape_half_data_rate();
-                                if (ft_buffer[ft_tail]->retry > 0) {
-                                        /* give it a chance */
-                                        --ft_buffer[ft_tail]->retry;
-                                }
-                        } else {
-                                /* no rate is accepted... */
-                                TRACE(ft_t_err, "We're dead :(");
-                        }
-                } else {
-                        TRACE(ft_t_err, "Unknown error");
-                }
-                TRACE_EXIT -EIO;   /* g.p. error */
-        }
-        TRACE_EXIT 0;
-}
-
-/* forward */ static int seek_forward(int segment_id, int fast);
-
-static int fast_seek(int count, int reverse)
-{
-        int result = 0;
-        int status;
-        TRACE_FUN(ft_t_flow);
-
-        if (count > 0) {
-                /*  If positioned at begin or end of tape, fast seeking needs
-                 *  special treatment.
-                 *  Starting from logical bot needs a (slow) seek to the first
-                 *  segment before the high speed seek. Most drives do this
-                 *  automatically but some older don't, so we treat them
-                 *  all the same.
-                 *  Starting from logical eot is even more difficult because
-                 *  we cannot (slow) reverse seek to the last segment.
-                 *  TO BE IMPLEMENTED.
-                 */
-                inhibit_correction = 0;
-                if (ft_location.known &&
-                    ((ft_location.bot && !reverse) ||
-                     (ft_location.eot && reverse))) {
-                        if (!reverse) {
-                                /*  (slow) skip to first segment on a track
-                                 */
-                                seek_forward(ft_location.track * ft_segments_per_track, 0);
-                                --count;
-                        } else {
-                                /*  When seeking backwards from
-                                 *  end-of-tape the number of erased
-                                 *  gaps found seems to be higher than
-                                 *  expected.  Therefor the drive must
-                                 *  skip some more segments than
-                                 *  calculated, but we don't know how
-                                 *  many.  Thus we will prevent the
-                                 *  re-calculation of offset and
-                                 *  overshoot when seeking backwards.
-                                 */
-                                inhibit_correction = 1;
-                                count += 3;     /* best guess */
-                        }
-                }
-        } else {
-                TRACE(ft_t_flow, "warning: zero or negative count: %d", count);
-        }
-        if (count > 0) {
-                int i;
-                int nibbles = count > 255 ? 3 : 2;
-
-                if (count > 4095) {
-                        TRACE(ft_t_noise, "skipping clipped at 4095 segment");
-                        count = 4095;
-                }
-                /* Issue this tape command first. */
-                if (!reverse) {
-                        TRACE(ft_t_noise, "skipping %d segment(s)", count);
-                        result = ftape_command(nibbles == 3 ?
-                           QIC_SKIP_EXTENDED_FORWARD : QIC_SKIP_FORWARD);
-                } else {
-                        TRACE(ft_t_noise, "backing up %d segment(s)", count);
-                        result = ftape_command(nibbles == 3 ?
-                           QIC_SKIP_EXTENDED_REVERSE : QIC_SKIP_REVERSE);
-                }
-                if (result < 0) {
-                        TRACE(ft_t_noise, "Skip command failed");
-                } else {
-                        --count;        /* 0 means one gap etc. */
-                        for (i = 0; i < nibbles; ++i) {
-                                if (result >= 0) {
-                                        result = ftape_parameter(count & 15);
-                                        count /= 16;
-                                }
-                        }
-                        result = ftape_ready_wait(ftape_timeout.rewind, &status);
-                        if (result >= 0) {
-                                ftape_tape_running = 0;
-                        }
-                }
-        }
-        TRACE_EXIT result;
-}
-
-static int validate(int id)
-{
-        /* Check to see if position found is off-track as reported
-         *  once.  Because all tracks in one direction lie next to
-         *  each other, if off-track the error will be approximately
-         *  2 * ft_segments_per_track.
-         */
-        if (ft_location.track == -1) {
-                return 1; /* unforseen situation, don't generate error */
-        } else {
-                /* Use margin of ft_segments_per_track on both sides
-                 * because ftape needs some margin and the error we're
-                 * looking for is much larger !
-                 */
-                int lo = (ft_location.track - 1) * ft_segments_per_track;
-                int hi = (ft_location.track + 2) * ft_segments_per_track;
-
-                return (id >= lo && id < hi);
-        }
-}
-
-static int seek_forward(int segment_id, int fast)
-{
-        int failures = 0;
-        int count;
-        static int margin = 1;  /* fixed: stop this before target */
-        static int overshoot = 1;
-        static int min_count = 8;
-        int expected = -1;
-        int target = segment_id - margin;
-        int fast_seeking;
-        int prev_segment = ft_location.segment;
-        TRACE_FUN(ft_t_flow);
-
-        if (!ft_location.known) {
-                TRACE_ABORT(-EIO, ft_t_err,
-                            "fatal: cannot seek from unknown location");
-        }
-        if (!validate(segment_id)) {
-                ftape_sleep(1 * FT_SECOND);
-                ft_failure = 1;
-                TRACE_ABORT(-EIO, ft_t_err,
-                            "fatal: head off track (bad hardware?)");
-        }
-        TRACE(ft_t_noise, "from %d/%d to %d/0 - %d",
-              ft_location.segment, ft_location.sector,segment_id,margin);
-        count = target - ft_location.segment - overshoot;
-        fast_seeking = (fast &&
-                        count > (min_count + (ft_location.bot ? 1 : 0)));
-        if (fast_seeking) {
-                TRACE(ft_t_noise, "fast skipping %d segments", count);
-                expected = segment_id - margin;
-                fast_seek(count, 0);
-        }
-        if (!ftape_tape_running) {
-                logical_forward();
-        }
-        while (ft_location.segment < segment_id) {
-                /*  This requires at least one sector in a (bad) segment to
-                 *  have a valid and readable sector id !
-                 *  It looks like this is not guaranteed, so we must try
-                 *  to find a way to skip an EMPTY_SEGMENT. !!! FIXME !!!
-                 */
-                if (ftape_read_id() < 0 || !ft_location.known ||
-                    sigtestsetmask(&current->pending.signal, _DONT_BLOCK)) {
-                        ft_location.known = 0;
-                        if (!ftape_tape_running ||
-                            ++failures > FT_SECTORS_PER_SEGMENT) {
-                                TRACE_ABORT(-EIO, ft_t_err,
-                                            "read_id failed completely");
-                        }
-                        FT_SIGNAL_EXIT(_DONT_BLOCK);
-                        TRACE(ft_t_flow, "read_id failed, retry (%d)",
-                              failures);
-                        continue;
-                }
-                if (fast_seeking) {
-                        TRACE(ft_t_noise, "ended at %d/%d (%d,%d)",
-                              ft_location.segment, ft_location.sector,
-                              overshoot, inhibit_correction);
-                        if (!inhibit_correction &&
-                            (ft_location.segment < expected ||
-                             ft_location.segment > expected + margin)) {
-                                int error = ft_location.segment - expected;
-                                TRACE(ft_t_noise,
-                                      "adjusting overshoot from %d to %d",
-                                      overshoot, overshoot + error);
-                                overshoot += error;
-                                /*  All overshoots have the same
-                                 *  direction, so it should never
-                                 *  become negative, but who knows.
-                                 */
-                                if (overshoot < -5 ||
-                                    overshoot > OVERSHOOT_LIMIT) {
-                                        if (overshoot < 0) {
-                                                /* keep sane value */
-                                                overshoot = -5;
-                                        } else {
-                                                /* keep sane value */
-                                                overshoot = OVERSHOOT_LIMIT;
-                                        }
-                                        TRACE(ft_t_noise,
-                                              "clipped overshoot to %d",
-                                              overshoot);
-                                }
-                        }
-                        fast_seeking = 0;
-                }
-                if (ft_location.known) {
-                        if (ft_location.segment > prev_segment + 1) {
-                                TRACE(ft_t_noise,
-                                      "missed segment %d while skipping",
-                                      prev_segment + 1);
-                        }
-                        prev_segment = ft_location.segment;
-                }
-        }
-        if (ft_location.segment > segment_id) {
-                TRACE_ABORT(-EIO,
-                            ft_t_noise, "failed: skip ended at segment %d/%d",
-                            ft_location.segment, ft_location.sector);
-        }
-        TRACE_EXIT 0;
-}
-
-static int skip_reverse(int segment_id, int *pstatus)
-{
-        int failures = 0;
-        static int overshoot = 1;
-        static int min_rewind = 2;      /* 1 + overshoot */
-        static const int margin = 1;    /* stop this before target */
-        int expected = 0;
-        int count = 1;
-        int short_seek;
-        int target = segment_id - margin;
-        TRACE_FUN(ft_t_flow);
-
-        if (ft_location.known && !validate(segment_id)) {
-                ftape_sleep(1 * FT_SECOND);
-                ft_failure = 1;
-                TRACE_ABORT(-EIO, ft_t_err,
-                            "fatal: head off track (bad hardware?)");
-        }
-        do {
-                if (!ft_location.known) {
-                        TRACE(ft_t_warn, "warning: location not known");
-                }
-                TRACE(ft_t_noise, "from %d/%d to %d/0 - %d",
-                      ft_location.segment, ft_location.sector,
-                      segment_id, margin);
-                /*  min_rewind == 1 + overshoot_when_doing_minimum_rewind
-                 *  overshoot  == overshoot_when_doing_larger_rewind
-                 *  Initially min_rewind == 1 + overshoot, optimization
-                 *  of both values will be done separately.
-                 *  overshoot and min_rewind can be negative as both are
-                 *  sums of three components:
-                 *  any_overshoot == rewind_overshoot - 
-                 *                   stop_overshoot   -
-                 *                   start_overshoot
-                 */
-                if (ft_location.segment - target - (min_rewind - 1) < 1) {
-                        short_seek = 1;
-                } else {
-                        count = ft_location.segment - target - overshoot;
-                        short_seek = (count < 1);
-                }
-                if (short_seek) {
-                        count = 1;      /* do shortest rewind */
-                        expected = ft_location.segment - min_rewind;
-                        if (expected/ft_segments_per_track != ft_location.track) {
-                                expected = (ft_location.track * 
-                                            ft_segments_per_track);
-                        }
-                } else {
-                        expected = target;
-                }
-                fast_seek(count, 1);
-                logical_forward();
-                if (ftape_read_id() < 0 || !ft_location.known ||
-                    (sigtestsetmask(&current->pending.signal, _DONT_BLOCK))) {
-                        if ((!ftape_tape_running && !ft_location.known) ||
-                            ++failures > FT_SECTORS_PER_SEGMENT) {
-                                TRACE_ABORT(-EIO, ft_t_err,
-                                            "read_id failed completely");
-                        }
-                        FT_SIGNAL_EXIT(_DONT_BLOCK);
-                        TRACE_CATCH(ftape_report_drive_status(pstatus),);
-                        TRACE(ft_t_noise, "ftape_read_id failed, retry (%d)",
-                              failures);
-                        continue;
-                }
-                TRACE(ft_t_noise, "ended at %d/%d (%d,%d,%d)", 
-                      ft_location.segment, ft_location.sector,
-                      min_rewind, overshoot, inhibit_correction);
-                if (!inhibit_correction &&
-                    (ft_location.segment < expected ||
-                     ft_location.segment > expected + margin)) {
-                        int error = expected - ft_location.segment;
-                        if (short_seek) {
-                                TRACE(ft_t_noise,
-                                      "adjusting min_rewind from %d to %d",
-                                      min_rewind, min_rewind + error);
-                                min_rewind += error;
-                                if (min_rewind < -5) {
-                                        /* is this right ? FIXME ! */
-                                        /* keep sane value */
-                                        min_rewind = -5;
-                                        TRACE(ft_t_noise, 
-                                              "clipped min_rewind to %d",
-                                              min_rewind);
-                                }
-                        } else {
-                                TRACE(ft_t_noise,
-                                      "adjusting overshoot from %d to %d",
-                                      overshoot, overshoot + error);
-                                overshoot += error;
-                                if (overshoot < -5 ||
-                                    overshoot > OVERSHOOT_LIMIT) {
-                                        if (overshoot < 0) {
-                                                /* keep sane value */
-                                                overshoot = -5;
-                                        } else {
-                                                /* keep sane value */
-                                                overshoot = OVERSHOOT_LIMIT;
-                                        }
-                                        TRACE(ft_t_noise,
-                                              "clipped overshoot to %d",
-                                              overshoot);
-                                }
-                        }
-                }
-        } while (ft_location.segment > segment_id);
-        if (ft_location.known) {
-                TRACE(ft_t_noise, "current location: %d/%d",
-                      ft_location.segment, ft_location.sector);
-        }
-        TRACE_EXIT 0;
-}
-
-static int determine_position(void)
-{
-        int retry = 0;
-        int status;
-        int result;
-        TRACE_FUN(ft_t_flow);
-
-        if (!ftape_tape_running) {
-                /*  This should only happen if tape is stopped by isr.
-                 */
-                TRACE(ft_t_flow, "waiting for tape stop");
-                if (ftape_ready_wait(ftape_timeout.pause, &status) < 0) {
-                        TRACE(ft_t_flow, "drive still running (fatal)");
-                        ftape_tape_running = 1; /* ? */
-                }
-        } else {
-                ftape_report_drive_status(&status);
-        }
-        if (status & QIC_STATUS_READY) {
-                /*  Drive must be ready to check error state !
-                 */
-                TRACE(ft_t_flow, "drive is ready");
-                if (status & QIC_STATUS_ERROR) {
-                        unsigned int error;
-                        qic117_cmd_t command;
-
-                        /*  Report and clear error state, try to continue.
-                         */
-                        TRACE(ft_t_flow, "error status set");
-                        ftape_report_error(&error, &command, 1);
-                        ftape_ready_wait(ftape_timeout.reset, &status);
-                        ftape_tape_running = 0; /* ? */
-                }
-                if (check_bot_eot(status)) {
-                        if (ft_location.bot) {
-                                if ((status & QIC_STATUS_READY) == 0) {
-                                        /* tape moving away from
-                                         * bot/eot, let's see if we
-                                         * can catch up with the first
-                                         * segment on this track.
-                                         */
-                                } else {
-                                        TRACE(ft_t_flow,
-                                              "start tape from logical bot");
-                                        logical_forward();      /* start moving */
-                                }
-                        } else {
-                                if ((status & QIC_STATUS_READY) == 0) {
-                                        TRACE(ft_t_noise, "waiting for logical end of track");
-                                        result = ftape_ready_wait(ftape_timeout.reset, &status);
-                                        /* error handling needed ? */
-                                } else {
-                                        TRACE(ft_t_noise,
-                                              "tape at logical end of track");
-                                }
-                        }
-                } else {
-                        TRACE(ft_t_flow, "start tape");
-                        logical_forward();      /* start moving */
-                        ft_location.known = 0;  /* not cleared by logical forward ! */
-                }
-        }
-        /* tape should be moving now, start reading id's
-         */
-        while (!ft_location.known &&
-               retry++ < FT_SECTORS_PER_SEGMENT &&
-               (result = ftape_read_id()) < 0) {
-
-                TRACE(ft_t_flow, "location unknown");
-
-                /* exit on signal
-                 */
-                FT_SIGNAL_EXIT(_DONT_BLOCK);
-
-                /*  read-id somehow failed, tape may
-                 *  have reached end or some other
-                 *  error happened.
-                 */
-                TRACE(ft_t_flow, "read-id failed");
-                TRACE_CATCH(ftape_report_drive_status(&status),);
-                TRACE(ft_t_err, "ftape_report_drive_status: 0x%02x", status);
-                if (status & QIC_STATUS_READY) {
-                        ftape_tape_running = 0;
-                        TRACE(ft_t_noise, "tape stopped for unknown reason! "
-                              "status = 0x%02x", status);
-                        if (status & QIC_STATUS_ERROR ||
-                            !check_bot_eot(status)) {
-                                /* oops, tape stopped but not at end!
-                                 */
-                                TRACE_EXIT -EIO;
-                        }
-                }
-        }
-        TRACE(ft_t_flow,
-              "tape is positioned at segment %d", ft_location.segment);
-        TRACE_EXIT ft_location.known ? 0 : -EIO;
-}
-
-/*      Get the tape running and position it just before the
- *      requested segment.
- *      Seek tape-track and reposition as needed.
- */
-int ftape_start_tape(int segment_id, int sector_offset)
-{
-        int track = segment_id / ft_segments_per_track;
-        int result = -EIO;
-        int status;
-        static int last_segment = -1;
-        static int bad_bus_timing = 0;
-        /* number of segments passing the head between starting the tape
-         * and being able to access the first sector.
-         */
-        static int start_offset = 1;
-        int retry;
-        TRACE_FUN(ft_t_flow);
-
-        /* If sector_offset > 0, seek into wanted segment instead of
-         * into previous.
-         * This allows error recovery if a part of the segment is bad
-         * (erased) causing the tape drive to generate an index pulse
-         * thus causing a no-data error before the requested sector
-         * is reached.
-         */
-        ftape_tape_running = 0;
-        TRACE(ft_t_noise, "target segment: %d/%d%s", segment_id, sector_offset,
-                ft_buffer[ft_head]->retry > 0 ? " retry" : "");
-        if (ft_buffer[ft_head]->retry > 0) {    /* this is a retry */
-                int dist = segment_id - last_segment;
-
-                if ((int)ft_history.overrun_errors < overrun_count_offset) {
-                        overrun_count_offset = ft_history.overrun_errors;
-                } else if (dist < 0 || dist > 50) {
-                        overrun_count_offset = ft_history.overrun_errors;
-                } else if ((ft_history.overrun_errors -
-                            overrun_count_offset) >= 8) {
-                        if (ftape_increase_threshold() >= 0) {
-                                --ft_buffer[ft_head]->retry;
-                                overrun_count_offset =
-                                        ft_history.overrun_errors;
-                                TRACE(ft_t_warn, "increased threshold because "
-                                      "of excessive overrun errors");
-                        } else if (!bad_bus_timing && ft_data_rate >= 1000) {
-                                ftape_half_data_rate();
-                                --ft_buffer[ft_head]->retry;
-                                bad_bus_timing = 1;
-                                overrun_count_offset =
-                                        ft_history.overrun_errors;
-                                TRACE(ft_t_warn, "reduced datarate because "
-                                      "of excessive overrun errors");
-                        }
-                }
-        }
-        last_segment = segment_id;
-        if (ft_location.track != track ||
-            (ftape_might_be_off_track && ft_buffer[ft_head]->retry== 0)) {
-                /* current track unknown or not equal to destination
-                 */
-                ftape_ready_wait(ftape_timeout.seek, &status);
-                ftape_seek_head_to_track(track);
-                /* overrun_count_offset = ft_history.overrun_errors; */
-        }
-        result = -EIO;
-        retry = 0;
-        while (result < 0     &&
-               retry++ <= 5   &&
-               !ft_failure &&
-               !(sigtestsetmask(&current->pending.signal, _DONT_BLOCK))) {
-                
-                if (retry && start_offset < 5) {
-                        start_offset ++;
-                }
-                /*  Check if we are able to catch the requested
-                 *  segment in time.
-                 */
-                if ((ft_location.known || (determine_position() == 0)) &&
-                    ft_location.segment >=
-                    (segment_id -
-                     ((ftape_tape_running || ft_location.bot)
-                      ? 0 : start_offset))) {
-                        /*  Too far ahead (in or past target segment).
-                         */
-                        if (ftape_tape_running) {
-                                if ((result = ftape_stop_tape(&status)) < 0) {
-                                        TRACE(ft_t_err,
-                                              "stop tape failed with code %d",
-                                              result);
-                                        break;
-                                }
-                                TRACE(ft_t_noise, "tape stopped");
-                                ftape_tape_running = 0;
-                        }
-                        TRACE(ft_t_noise, "repositioning");
-                        ++ft_history.rewinds;
-                        if (segment_id % ft_segments_per_track < start_offset){
-                                TRACE(ft_t_noise, "end of track condition\n"
-                                      KERN_INFO "segment_id        : %d\n"
-                                      KERN_INFO "ft_segments_per_track: %d\n"
-                                      KERN_INFO "start_offset      : %d",
-                                      segment_id, ft_segments_per_track, 
-                                      start_offset);
-                                      
-                                /*  If seeking to first segments on
-                                 *  track better do a complete rewind
-                                 *  to logical begin of track to get a
-                                 *  more steady tape motion.  
-                                 */
-                                result = ftape_command_wait(
-                                        (ft_location.track & 1)
-                                        ? QIC_PHYSICAL_FORWARD
-                                        : QIC_PHYSICAL_REVERSE,
-                                        ftape_timeout.rewind, &status);
-                                check_bot_eot(status);  /* update location */
-                        } else {
-                                result= skip_reverse(segment_id - start_offset,
-                                                     &status);
-                        }
-                }
-                if (!ft_location.known) {
-                        TRACE(ft_t_bug, "panic: location not known");
-                        result = -EIO;
-                        continue; /* while() will check for failure */
-                }
-                TRACE(ft_t_noise, "current segment: %d/%d",
-                      ft_location.segment, ft_location.sector);
-                /*  We're on the right track somewhere before the
-                 *  wanted segment.  Start tape movement if needed and
-                 *  skip to just before or inside the requested
-                 *  segment. Keep tape running.  
-                 */
-                result = 0;
-                if (ft_location.segment < 
-                    (segment_id - ((ftape_tape_running || ft_location.bot)
-                                   ? 0 : start_offset))) {
-                        if (sector_offset > 0) {
-                                result = seek_forward(segment_id,
-                                                      retry <= 3);
-                        } else {
-                                result = seek_forward(segment_id - 1,
-                                                      retry <= 3);
-                        }
-                }
-                if (result == 0 &&
-                    ft_location.segment !=
-                    (segment_id - (sector_offset > 0 ? 0 : 1))) {
-                        result = -EIO;
-                }
-        }
-        if (result < 0) {
-                TRACE(ft_t_err, "failed to reposition");
-        } else {
-                ft_runner_status = running;
-        }
-        TRACE_EXIT result;
-}
diff --git a/drivers/char/ftape/lowlevel/ftape-rw.h b/drivers/char/ftape/lowlevel/ftape-rw.h
deleted file mode 100644
index 32f4feeb887c..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-rw.h
+++ /dev/null
@@ -1,111 +0,0 @@
-#ifndef _FTAPE_RW_H
-#define _FTAPE_RW_H
-
-/*
- * Copyright (C) 1993-1996 Bas Laarhoven,
- *           (C) 1996-1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-rw.h,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:18:25 $
- *
- *      This file contains the definitions for the read and write
- *      functions for the QIC-117 floppy-tape driver for Linux.
- *
- * Claus-Justus Heine (1996/09/20): Add definition of format code 6
- * Claus-Justus Heine (1996/10/04): Changed GET/PUT macros to cast to (__u8 *)
- *
- */
-
-#include "../lowlevel/fdc-io.h"
-#include "../lowlevel/ftape-init.h"
-#include "../lowlevel/ftape-bsm.h"
-
-#include <asm/unaligned.h>
-
-#define GET2(address, offset) get_unaligned((__u16*)((__u8 *)address + offset))
-#define GET4(address, offset) get_unaligned((__u32*)((__u8 *)address + offset))
-#define GET8(address, offset) get_unaligned((__u64*)((__u8 *)address + offset))
-#define PUT2(address, offset , value) put_unaligned((value), (__u16*)((__u8 *)address + offset))
-#define PUT4(address, offset , value) put_unaligned((value), (__u32*)((__u8 *)address + offset))
-#define PUT8(address, offset , value) put_unaligned((value), (__u64*)((__u8 *)address + offset))
-
-enum runner_status_enum {
-        idle = 0,
-        running,
-        do_abort,
-        aborting,
-        logical_eot,
-        end_of_tape,
-};
-
-typedef enum ft_buffer_queue {
-        ft_queue_head = 0,
-        ft_queue_tail = 1
-} ft_buffer_queue_t;
-
-
-typedef struct {
-        int track;              /* tape head position */
-        volatile int segment;   /* current segment */
-        volatile int sector;    /* sector offset within current segment */
-        volatile unsigned int bot;      /* logical begin of track */
-        volatile unsigned int eot;      /* logical end of track */
-        volatile unsigned int known;    /* validates bot, segment, sector */
-} location_record;
-
-/*      Count nr of 1's in pattern.
- */
-static inline int count_ones(unsigned long mask)
-{
-        int bits;
-
-        for (bits = 0; mask != 0; mask >>= 1) {
-                if (mask & 1) {
-                        ++bits;
-                }
-        }
-        return bits;
-}
-
-#define FT_MAX_NR_BUFFERS 16 /* arbitrary value */
-/*      ftape-rw.c defined global vars.
- */
-extern buffer_struct *ft_buffer[FT_MAX_NR_BUFFERS];
-extern int ft_nr_buffers;
-extern location_record ft_location;
-extern volatile int ftape_tape_running;
-
-/*      ftape-rw.c defined global functions.
- */
-extern int  ftape_setup_new_segment(buffer_struct * buff,
-                                    int segment_id,
-                                    int offset);
-extern int  ftape_calc_next_cluster(buffer_struct * buff);
-extern buffer_struct *ftape_next_buffer (ft_buffer_queue_t pos);
-extern buffer_struct *ftape_get_buffer  (ft_buffer_queue_t pos);
-extern int            ftape_buffer_id   (ft_buffer_queue_t pos);
-extern void           ftape_reset_buffer(void);
-extern void ftape_tape_parameters(__u8 drive_configuration);
-extern int  ftape_wait_segment(buffer_state_enum state);
-extern int  ftape_dumb_stop(void);
-extern int  ftape_start_tape(int segment_id, int offset);
-extern int  ftape_stop_tape(int *pstatus);
-extern int  ftape_handle_logical_eot(void);
-extern buffer_state_enum ftape_set_state(buffer_state_enum new_state);
-#endif                          /* _FTAPE_RW_H */
diff --git a/drivers/char/ftape/lowlevel/ftape-setup.c b/drivers/char/ftape/lowlevel/ftape-setup.c
deleted file mode 100644
index 678340acd0b7..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-setup.c
+++ /dev/null
@@ -1,104 +0,0 @@
-/* 
- * Copyright (C) 1996, 1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-setup.c,v $
- * $Revision: 1.7 $
- * $Date: 1997/10/10 09:57:06 $
- *
- *      This file contains the code for processing the kernel command
- *      line options for the QIC-40/80/3010/3020 floppy-tape driver
- *      "ftape" for Linux.
- */
-
-#include <linux/string.h>
-#include <linux/errno.h>
-#include <linux/mm.h>
-
-#include <linux/ftape.h>
-#include <linux/init.h>
-#include "../lowlevel/ftape-tracing.h"
-#include "../lowlevel/fdc-io.h"
-
-static struct param_table {
-        const char *name;
-        int *var;
-        int def_param;
-        int min;
-        int max;
-} config_params[] __initdata = {
-#ifndef CONFIG_FT_NO_TRACE_AT_ALL
-        { "tracing",   &ftape_tracing,     3,              ft_t_bug, ft_t_any},
-#endif
-        { "ioport",    &ft_fdc_base,       CONFIG_FT_FDC_BASE,     0x0, 0xfff},
-        { "irq",       &ft_fdc_irq,        CONFIG_FT_FDC_IRQ,        2,    15},
-        { "dma",       &ft_fdc_dma,        CONFIG_FT_FDC_DMA,        0,     3},
-        { "threshold", &ft_fdc_threshold,  CONFIG_FT_FDC_THR,         1,    16},
-        { "datarate",  &ft_fdc_rate_limit, CONFIG_FT_FDC_MAX_RATE, 500,  2000},
-        { "fc10",      &ft_probe_fc10,     CONFIG_FT_PROBE_FC10,     0,     1},
-        { "mach2",     &ft_mach2,          CONFIG_FT_MACH2,          0,     1}
-};
-
-static int __init ftape_setup(char *str)
-{
-        int i;
-        int param;
-        int ints[2];
-
-        TRACE_FUN(ft_t_flow);
-
-        str = get_options(str, ARRAY_SIZE(ints), ints);
-        if (str) {
-                for (i=0; i < NR_ITEMS(config_params); i++) {
-                        if (strcmp(str,config_params[i].name) == 0){
-                                if (ints[0]) {
-                                        param = ints[1];
-                                } else {
-                                        param = config_params[i].def_param;
-                                }
-                                if (param < config_params[i].min ||
-                                    param > config_params[i].max) {
-                                        TRACE(ft_t_err,
-                                        "parameter %s out of range %d ... %d",
-                                              config_params[i].name,
-                                              config_params[i].min,
-                                              config_params[i].max);
-                                        goto out;
-                                }
-                                if(config_params[i].var) {
-                                        TRACE(ft_t_info, "%s=%d", str, param);
-                                        *config_params[i].var = param;
-                                }
-                                goto out;
-                        }
-                }
-        }
-        if (str) {
-                TRACE(ft_t_err, "unknown ftape option [%s]", str);
-                
-                TRACE(ft_t_err, "allowed options are:");
-                for (i=0; i < NR_ITEMS(config_params); i++) {
-                        TRACE(ft_t_err, " %s",config_params[i].name);
-                }
-        } else {
-                TRACE(ft_t_err, "botched ftape option");
-        }
- out:
-        TRACE_EXIT 1;
-}
-
-__setup("ftape=", ftape_setup);
diff --git a/drivers/char/ftape/lowlevel/ftape-tracing.c b/drivers/char/ftape/lowlevel/ftape-tracing.c
deleted file mode 100644
index 7fdc6567440b..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-tracing.c
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- *      Copyright (C) 1993-1996 Bas Laarhoven,
- *                (C) 1996-1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-tracing.c,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:18:27 $
- *
- *      This file contains the reading code
- *      for the QIC-117 floppy-tape driver for Linux.
- */
-
-#include <linux/ftape.h>
-#include "../lowlevel/ftape-tracing.h"
-
-/*      Global vars.
- */
-/*      tracing
- *      set it to:     to log :
- *       0              bugs
- *       1              + errors
- *       2              + warnings
- *       3              + information
- *       4              + more information
- *       5              + program flow
- *       6              + fdc/dma info
- *       7              + data flow
- *       8              + everything else
- */
-ft_trace_t ftape_tracing = ft_t_info; /* Default level: information and up */
-int  ftape_function_nest_level;
-
-/*      Local vars.
- */
-static __u8 trace_id;
-static char spacing[] = "*                              ";
-
-void ftape_trace_call(const char *file, const char *name)
-{
-        char *indent;
-
-        /*    Since printk seems not to work with "%*s" format
-         *    we'll use this work-around.
-         */
-        if (ftape_function_nest_level < 0) {
-                printk(KERN_INFO "function nest level (%d) < 0\n",
-                       ftape_function_nest_level);
-                ftape_function_nest_level = 0;
-        }
-        if (ftape_function_nest_level < sizeof(spacing)) {
-                indent = (spacing +
-                          sizeof(spacing) - 1 -
-                          ftape_function_nest_level);
-        } else {
-                indent = spacing;
-        }
-        printk(KERN_INFO "[%03d]%s+%s (%s)\n",
-               (int) trace_id++, indent, file, name);
-}
-
-void ftape_trace_exit(const char *file, const char *name)
-{
-        char *indent;
-
-        /*    Since printk seems not to work with "%*s" format
-         *    we'll use this work-around.
-         */
-        if (ftape_function_nest_level < 0) {
-                printk(KERN_INFO "function nest level (%d) < 0\n", ftape_function_nest_level);
-                ftape_function_nest_level = 0;
-        }
-        if (ftape_function_nest_level < sizeof(spacing)) {
-                indent = (spacing +
-                          sizeof(spacing) - 1 -
-                          ftape_function_nest_level);
-        } else {
-                indent = spacing;
-        }
-        printk(KERN_INFO "[%03d]%s-%s (%s)\n",
-               (int) trace_id++, indent, file, name);
-}
-
-void ftape_trace_log(const char *file, const char *function)
-{
-        char *indent;
-
-        /*    Since printk seems not to work with "%*s" format
-         *    we'll use this work-around.
-         */
-        if (ftape_function_nest_level < 0) {
-                printk(KERN_INFO "function nest level (%d) < 0\n", ftape_function_nest_level);
-                ftape_function_nest_level = 0;
-        }
-        if (ftape_function_nest_level < sizeof(spacing)) {
-                indent = (spacing + 
-                          sizeof(spacing) - 1 - 
-                          ftape_function_nest_level);
-        } else {
-                indent = spacing;
-        }
-        printk(KERN_INFO "[%03d]%s%s (%s) - ", 
-               (int) trace_id++, indent, file, function);
-}
diff --git a/drivers/char/ftape/lowlevel/ftape-tracing.h b/drivers/char/ftape/lowlevel/ftape-tracing.h
deleted file mode 100644
index 2950810c7085..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-tracing.h
+++ /dev/null
@@ -1,179 +0,0 @@
-#ifndef _FTAPE_TRACING_H
-#define _FTAPE_TRACING_H
-
-/*
- * Copyright (C) 1994-1996 Bas Laarhoven,
- *           (C) 1996-1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-tracing.h,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:18:28 $
- *
- *      This file contains definitions that eases the debugging of the
- *      QIC-40/80/3010/3020 floppy-tape driver "ftape" for Linux.
- */
-
-#include <linux/kernel.h>
-
-/*
- *  Be very careful with TRACE_EXIT and TRACE_ABORT.
- *
- *  if (something) TRACE_EXIT error;
- *
- *  will NOT work. Use
- *
- *  if (something) {
- *    TRACE_EXIT error;
- *  }
- *
- *  instead. Maybe a bit dangerous, but save lots of lines of code.
- */
-
-#define LL_X "%d/%d KB"
-#define LL(x) (unsigned int)((__u64)(x)>>10), (unsigned int)((x)&1023)
-
-typedef enum {
-        ft_t_nil = -1,
-        ft_t_bug,
-        ft_t_err,
-        ft_t_warn,
-        ft_t_info,
-        ft_t_noise,
-        ft_t_flow,
-        ft_t_fdc_dma,
-        ft_t_data_flow,
-        ft_t_any
-} ft_trace_t;
-
-#ifdef  CONFIG_FT_NO_TRACE_AT_ALL
-/*  the compiler will optimize away most TRACE() macros
- */
-#define FT_TRACE_TOP_LEVEL      ft_t_bug
-#define TRACE_FUN(level)        do {} while(0)
-#define TRACE_EXIT              return
-#define TRACE(l, m, i...)                                               \
-{                                                                       \
-        if ((ft_trace_t)(l) == FT_TRACE_TOP_LEVEL) {                    \
-                printk(KERN_INFO"ftape%s(%s):\n"                        \
-                       KERN_INFO m".\n" ,__FILE__, __FUNCTION__ , ##i); \
-        }                                                               \
-}
-#define SET_TRACE_LEVEL(l)      if ((l) == (l)) do {} while(0)
-#define TRACE_LEVEL             FT_TRACE_TOP_LEVEL
-
-#else
-
-#ifdef CONFIG_FT_NO_TRACE
-/*  the compiler will optimize away many TRACE() macros
- *  the ftape_simple_trace_call() function simply increments 
- *  the function nest level.
- */ 
-#define FT_TRACE_TOP_LEVEL      ft_t_warn
-#define TRACE_FUN(level)        ftape_function_nest_level++
-#define TRACE_EXIT              ftape_function_nest_level--; return
-
-#else
-#ifdef CONFIG_FT_FULL_DEBUG
-#define FT_TRACE_TOP_LEVEL ft_t_any
-#else
-#define FT_TRACE_TOP_LEVEL ft_t_flow
-#endif
-#define TRACE_FUN(level)                                        \
-        const ft_trace_t _tracing = level;                      \
-        if (ftape_tracing >= (ft_trace_t)(level) &&             \
-            (ft_trace_t)(level) <= FT_TRACE_TOP_LEVEL)          \
-                ftape_trace_call(__FILE__, __FUNCTION__);       \
-        ftape_function_nest_level ++;
-
-#define TRACE_EXIT                                              \
-        --ftape_function_nest_level;                            \
-        if (ftape_tracing >= (ft_trace_t)(_tracing) &&          \
-            (ft_trace_t)(_tracing) <= FT_TRACE_TOP_LEVEL)       \
-                ftape_trace_exit(__FILE__, __FUNCTION__);       \
-        return
-
-#endif
-
-#define TRACE(l, m, i...)                                       \
-{                                                               \
-        if (ftape_tracing >= (ft_trace_t)(l) &&                 \
-            (ft_trace_t)(l) <= FT_TRACE_TOP_LEVEL) {            \
-                ftape_trace_log(__FILE__, __FUNCTION__);        \
-                printk(m".\n" ,##i);                            \
-        }                                                       \
-}
-
-#define SET_TRACE_LEVEL(l)                              \
-{                                                       \
-        if ((ft_trace_t)(l) <= FT_TRACE_TOP_LEVEL) {    \
-                ftape_tracing = (ft_trace_t)(l);        \
-        } else {                                        \
-                ftape_tracing = FT_TRACE_TOP_LEVEL;     \
-        }                                               \
-}
-#define TRACE_LEVEL                                                          \
-((ftape_tracing <= FT_TRACE_TOP_LEVEL) ? ftape_tracing : FT_TRACE_TOP_LEVEL)
-
-
-/*      Global variables declared in tracing.c
- */
-extern ft_trace_t ftape_tracing;  /* sets default level */
-extern int ftape_function_nest_level;
-
-/*      Global functions declared in tracing.c
- */
-extern void ftape_trace_call(const char *file, const char *name);
-extern void ftape_trace_exit(const char *file, const char *name);
-extern void ftape_trace_log (const char *file, const char *name);
-
-#endif /* !defined(CONFIG_FT_NO_TRACE_AT_ALL) */
-
-/*
- *   Abort with a message.
- */
-#define TRACE_ABORT(res, i...)                  \
-{                                               \
-        TRACE(i);                               \
-        TRACE_EXIT res;                         \
-}
-
-/*   The following transforms the common "if(result < 0) ... " into a
- *   one-liner.
- */
-#define _TRACE_CATCH(level, fun, action)                                \
-{                                                                       \
-        int _res = (fun);                                               \
-        if (_res < 0) {                                                 \
-                do { action /* */ ; } while(0);                         \
-                TRACE_ABORT(_res, level, "%s failed: %d", #fun, _res);  \
-        }                                                               \
-}
-
-#define TRACE_CATCH(fun, fail) _TRACE_CATCH(ft_t_err, fun, fail)
-
-/*  Abort the current function when signalled. This doesn't belong here,
- *  but rather into ftape-rw.h (maybe)
- */
-#define FT_SIGNAL_EXIT(sig_mask)                                        \
-        if (sigtestsetmask(&current->pending.signal, sig_mask)) {       \
-                TRACE_ABORT(-EINTR,                                     \
-                            ft_t_warn,                                  \
-                            "interrupted by non-blockable signal");     \
-        }
-
-#endif /* _FTAPE_TRACING_H */
diff --git a/drivers/char/ftape/lowlevel/ftape-write.c b/drivers/char/ftape/lowlevel/ftape-write.c
deleted file mode 100644
index 45601ec801ee..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-write.c
+++ /dev/null
@@ -1,336 +0,0 @@
-/*
- *      Copyright (C) 1993-1995 Bas Laarhoven,
- *                (C) 1996-1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-write.c,v $
- * $Revision: 1.3.4.1 $
- * $Date: 1997/11/14 18:07:04 $
- *
- *      This file contains the writing code
- *      for the QIC-117 floppy-tape driver for Linux.
- */
-
-#include <linux/string.h>
-#include <linux/errno.h>
-#include <linux/mm.h>
-
-#include <linux/ftape.h>
-#include <linux/qic117.h>
-#include "../lowlevel/ftape-tracing.h"
-#include "../lowlevel/ftape-write.h"
-#include "../lowlevel/ftape-read.h"
-#include "../lowlevel/ftape-io.h"
-#include "../lowlevel/ftape-ctl.h"
-#include "../lowlevel/ftape-rw.h"
-#include "../lowlevel/ftape-ecc.h"
-#include "../lowlevel/ftape-bsm.h"
-#include "../lowlevel/fdc-isr.h"
-
-/*      Global vars.
- */
-
-/*      Local vars.
- */
-static int last_write_failed;
-
-void ftape_zap_write_buffers(void)
-{
-        int i;
-
-        for (i = 0; i < ft_nr_buffers; ++i) {
-                ft_buffer[i]->status = done;
-        }
-        ftape_reset_buffer();
-}
-
-static int copy_and_gen_ecc(void *destination, 
-                            const void *source,
-                            const SectorMap bad_sector_map)
-{
-        int result;
-        struct memory_segment mseg;
-        int bads = count_ones(bad_sector_map);
-        TRACE_FUN(ft_t_any);
-
-        if (bads > 0) {
-                TRACE(ft_t_noise, "bad sectors in map: %d", bads);
-        }
-        if (bads + 3 >= FT_SECTORS_PER_SEGMENT) {
-                TRACE(ft_t_noise, "empty segment");
-                mseg.blocks = 0; /* skip entire segment */
-                result = 0;      /* nothing written */
-        } else {
-                mseg.blocks = FT_SECTORS_PER_SEGMENT - bads;
-                mseg.data = destination;
-                memcpy(mseg.data, source, (mseg.blocks - 3) * FT_SECTOR_SIZE);
-                result = ftape_ecc_set_segment_parity(&mseg);
-                if (result < 0) {
-                        TRACE(ft_t_err, "ecc_set_segment_parity failed");
-                } else {
-                        result = (mseg.blocks - 3) * FT_SECTOR_SIZE;
-                }
-        }
-        TRACE_EXIT result;
-}
-
-
-int ftape_start_writing(const ft_write_mode_t mode)
-{
-        buffer_struct *head = ftape_get_buffer(ft_queue_head);
-        int segment_id = head->segment_id;
-        int result;
-        buffer_state_enum wanted_state = (mode == FT_WR_DELETE
-                                          ? deleting
-                                          : writing);
-        TRACE_FUN(ft_t_flow);
-
-        if ((ft_driver_state != wanted_state) || head->status != waiting) {
-                TRACE_EXIT 0;
-        }
-        ftape_setup_new_segment(head, segment_id, 1);
-        if (mode == FT_WR_SINGLE) {
-                /* stop tape instead of pause */
-                head->next_segment = 0;
-        }
-        ftape_calc_next_cluster(head); /* prepare */
-        head->status = ft_driver_state; /* either writing or deleting */
-        if (ft_runner_status == idle) {
-                TRACE(ft_t_noise,
-                      "starting runner for segment %d", segment_id);
-                TRACE_CATCH(ftape_start_tape(segment_id,head->sector_offset),);
-        } else {
-                TRACE(ft_t_noise, "runner not idle, not starting tape");
-        }
-        /* go */
-        result = fdc_setup_read_write(head, (mode == FT_WR_DELETE
-                                             ? FDC_WRITE_DELETED : FDC_WRITE));
-        ftape_set_state(wanted_state); /* should not be necessary */
-        TRACE_EXIT result;
-}
-
-/*  Wait until all data is actually written to tape.
- *  
- *  There is a problem: when the tape runs into logical EOT, then this
- *  failes. We need to restart the runner in this case.
- */
-int ftape_loop_until_writes_done(void)
-{
-        buffer_struct *head;
-        TRACE_FUN(ft_t_flow);
-
-        while ((ft_driver_state == writing || ft_driver_state == deleting) && 
-               ftape_get_buffer(ft_queue_head)->status != done) {
-                /* set the runner status to idle if at lEOT */
-                TRACE_CATCH(ftape_handle_logical_eot(), last_write_failed = 1);
-                /* restart the tape if necessary */
-                if (ft_runner_status == idle) {
-                        TRACE(ft_t_noise, "runner is idle, restarting");
-                        if (ft_driver_state == deleting) {
-                                TRACE_CATCH(ftape_start_writing(FT_WR_DELETE),
-                                            last_write_failed = 1);
-                        } else {
-                                TRACE_CATCH(ftape_start_writing(FT_WR_MULTI),
-                                            last_write_failed = 1);
-                        }
-                }
-                TRACE(ft_t_noise, "tail: %d, head: %d", 
-                      ftape_buffer_id(ft_queue_tail),
-                      ftape_buffer_id(ft_queue_head));
-                TRACE_CATCH(fdc_interrupt_wait(5 * FT_SECOND),
-                            last_write_failed = 1);
-                head = ftape_get_buffer(ft_queue_head);
-                if (head->status == error) {
-                        /* Allow escape from loop when signaled !
-                         */
-                        FT_SIGNAL_EXIT(_DONT_BLOCK);
-                        if (head->hard_error_map != 0) {
-                                /*  Implement hard write error recovery here
-                                 */
-                        }
-                        /* retry this one */
-                        head->status = waiting;
-                        if (ft_runner_status == aborting) {
-                                ftape_dumb_stop();
-                        }
-                        if (ft_runner_status != idle) {
-                                TRACE_ABORT(-EIO, ft_t_err,
-                                            "unexpected state: "
-                                            "ft_runner_status != idle");
-                        }
-                        ftape_start_writing(ft_driver_state == deleting
-                                            ? FT_WR_MULTI : FT_WR_DELETE);
-                }
-                TRACE(ft_t_noise, "looping until writes done");
-        }
-        ftape_set_state(idle);
-        TRACE_EXIT 0;
-}
-
-/*      Write given segment from buffer at address to tape.
- */
-static int write_segment(const int segment_id,
-                         const void *address, 
-                         const ft_write_mode_t write_mode)
-{
-        int bytes_written = 0;
-        buffer_struct *tail;
-        buffer_state_enum wanted_state = (write_mode == FT_WR_DELETE
-                                          ? deleting : writing);
-        TRACE_FUN(ft_t_flow);
-
-        TRACE(ft_t_noise, "segment_id = %d", segment_id);
-        if (ft_driver_state != wanted_state) {
-                if (ft_driver_state == deleting ||
-                    wanted_state == deleting) {
-                        TRACE_CATCH(ftape_loop_until_writes_done(),);
-                }
-                TRACE(ft_t_noise, "calling ftape_abort_operation");
-                TRACE_CATCH(ftape_abort_operation(),);
-                ftape_zap_write_buffers();
-                ftape_set_state(wanted_state);
-        }
-        /*    if all buffers full we'll have to wait...
-         */
-        ftape_wait_segment(wanted_state);
-        tail = ftape_get_buffer(ft_queue_tail);
-        switch(tail->status) {
-        case done:
-                ft_history.defects += count_ones(tail->hard_error_map);
-                break;
-        case waiting:
-                /* this could happen with multiple EMPTY_SEGMENTs, but
-                 * shouldn't happen any more as we re-start the runner even
-                 * with an empty segment.
-                 */
-                bytes_written = -EAGAIN;
-                break;
-        case error:
-                /*  setup for a retry
-                 */
-                tail->status = waiting;
-                bytes_written = -EAGAIN; /* force retry */
-                if (tail->hard_error_map != 0) {
-                        TRACE(ft_t_warn, 
-                              "warning: %d hard error(s) in written segment",
-                              count_ones(tail->hard_error_map));
-                        TRACE(ft_t_noise, "hard_error_map = 0x%08lx", 
-                              (long)tail->hard_error_map);
-                        /*  Implement hard write error recovery here
-                         */
-                }
-                break;
-        default:
-                TRACE_ABORT(-EIO, ft_t_err,
-                            "wait for empty segment failed, tail status: %d",
-                            tail->status);
-        }
-        /*    should runner stop ?
-         */
-        if (ft_runner_status == aborting) {
-                buffer_struct *head = ftape_get_buffer(ft_queue_head);
-                if (head->status == wanted_state) {
-                        head->status = done; /* ???? */
-                }
-                /*  don't call abort_operation(), we don't want to zap
-                 *  the dma buffers
-                 */
-                TRACE_CATCH(ftape_dumb_stop(),);
-        } else {
-                /*  If just passed last segment on tape: wait for BOT
-                 *  or EOT mark. Sets ft_runner_status to idle if at lEOT
-                 *  and successful 
-                 */
-                TRACE_CATCH(ftape_handle_logical_eot(),);
-        }
-        if (tail->status == done) {
-                /* now at least one buffer is empty, fill it with our
-                 * data.  skip bad sectors and generate ecc.
-                 * copy_and_gen_ecc return nr of bytes written, range
-                 * 0..29 Kb inclusive!  
-                 *
-                 * Empty segments are handled inside coyp_and_gen_ecc()
-                 */
-                if (write_mode != FT_WR_DELETE) {
-                        TRACE_CATCH(bytes_written = copy_and_gen_ecc(
-                                tail->address, address,
-                                ftape_get_bad_sector_entry(segment_id)),);
-                }
-                tail->segment_id = segment_id;
-                tail->status = waiting;
-                tail = ftape_next_buffer(ft_queue_tail);
-        }
-        /*  Start tape only if all buffers full or flush mode.
-         *  This will give higher probability of streaming.
-         */
-        if (ft_runner_status != running && 
-            ((tail->status == waiting &&
-              ftape_get_buffer(ft_queue_head) == tail) ||
-             write_mode != FT_WR_ASYNC)) {
-                TRACE_CATCH(ftape_start_writing(write_mode),);
-        }
-        TRACE_EXIT bytes_written;
-}
-
-/*  Write as much as fits from buffer to the given segment on tape
- *  and handle retries.
- *  Return the number of bytes written (>= 0), or:
- *      -EIO          write failed
- *      -EINTR        interrupted by signal
- *      -ENOSPC       device full
- */
-int ftape_write_segment(const int segment_id,
-                        const void *buffer, 
-                        const ft_write_mode_t flush)
-{
-        int retry = 0;
-        int result;
-        TRACE_FUN(ft_t_flow);
-
-        ft_history.used |= 2;
-        if (segment_id >= ft_tracks_per_tape*ft_segments_per_track) {
-                /* tape full */
-                TRACE_ABORT(-ENOSPC, ft_t_err,
-                            "invalid segment id: %d (max %d)", 
-                            segment_id, 
-                            ft_tracks_per_tape * ft_segments_per_track -1);
-        }
-        for (;;) {
-                if ((result = write_segment(segment_id, buffer, flush)) >= 0) {
-                        if (result == 0) { /* empty segment */
-                                TRACE(ft_t_noise,
-                                      "empty segment, nothing written");
-                        }
-                        TRACE_EXIT result;
-                }
-                if (result == -EAGAIN) {
-                        if (++retry > 100) { /* give up */
-                                TRACE_ABORT(-EIO, ft_t_err,
-                                      "write failed, >100 retries in segment");
-                        }
-                        TRACE(ft_t_warn, "write error, retry %d (%d)",
-                              retry,
-                              ftape_get_buffer(ft_queue_tail)->segment_id);
-                } else {
-                        TRACE_ABORT(result, ft_t_err,
-                                    "write_segment failed, error: %d", result);
-                }
-                /* Allow escape from loop when signaled !
-                 */
-                FT_SIGNAL_EXIT(_DONT_BLOCK);
-        }
-}
diff --git a/drivers/char/ftape/lowlevel/ftape-write.h b/drivers/char/ftape/lowlevel/ftape-write.h
deleted file mode 100644
index 0e7f898b7af9..000000000000
--- a/drivers/char/ftape/lowlevel/ftape-write.h
+++ /dev/null
@@ -1,53 +0,0 @@
-#ifndef _FTAPE_WRITE_H
-#define _FTAPE_WRITE_H
-
-/*
- * Copyright (C) 1994-1995 Bas Laarhoven,
- *           (C) 1996-1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-write.h,v $
- $Author: claus $
- *
- $Revision: 1.2 $
- $Date: 1997/10/05 19:18:30 $
- $State: Exp $
- *
- *      This file contains the definitions for the write functions
- *      for the QIC-117 floppy-tape driver for Linux.
- *
- */
-
-
-/*      ftape-write.c defined global functions.
- */
-typedef enum {
-        FT_WR_ASYNC  = 0, /* start tape only when all buffers are full */
-        FT_WR_MULTI  = 1, /* start tape, but don't necessarily stop */
-        FT_WR_SINGLE = 2, /* write a single segment and stop afterwards */
-        FT_WR_DELETE = 3  /* write deleted data marks */
-} ft_write_mode_t;
-
-extern int  ftape_start_writing(const ft_write_mode_t mode);
-extern int  ftape_write_segment(const int segment,
-                                const void *address, 
-                                const ft_write_mode_t flushing);
-extern void ftape_zap_write_buffers(void);
-extern int  ftape_loop_until_writes_done(void);
-
-#endif                          /* _FTAPE_WRITE_H */
-
diff --git a/drivers/char/ftape/lowlevel/ftape_syms.c b/drivers/char/ftape/lowlevel/ftape_syms.c
deleted file mode 100644
index 8e0dc4a07ca6..000000000000
--- a/drivers/char/ftape/lowlevel/ftape_syms.c
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- *      Copyright (C) 1996-1997 Claus-Justus Heine
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape_syms.c,v $
- * $Revision: 1.4 $
- * $Date: 1997/10/17 00:03:51 $
- *
- *      This file contains the symbols that the ftape low level
- *      part of the QIC-40/80/3010/3020 floppy-tape driver "ftape"
- *      exports to its high level clients
- */
-
-#include <linux/module.h>
-
-#include <linux/ftape.h>
-#include "../lowlevel/ftape-tracing.h"
-#include "../lowlevel/ftape-init.h"
-#include "../lowlevel/fdc-io.h"
-#include "../lowlevel/ftape-read.h"
-#include "../lowlevel/ftape-write.h"
-#include "../lowlevel/ftape-io.h"
-#include "../lowlevel/ftape-ctl.h"
-#include "../lowlevel/ftape-rw.h"
-#include "../lowlevel/ftape-bsm.h"
-#include "../lowlevel/ftape-buffer.h"
-#include "../lowlevel/ftape-format.h"
-
-/* bad sector handling from ftape-bsm.c */
-EXPORT_SYMBOL(ftape_get_bad_sector_entry);
-EXPORT_SYMBOL(ftape_find_end_of_bsm_list);
-/* from ftape-rw.c */
-EXPORT_SYMBOL(ftape_set_state);
-/* from ftape-ctl.c */
-EXPORT_SYMBOL(ftape_seek_to_bot);
-EXPORT_SYMBOL(ftape_seek_to_eot);
-EXPORT_SYMBOL(ftape_abort_operation);
-EXPORT_SYMBOL(ftape_get_status);
-EXPORT_SYMBOL(ftape_enable);
-EXPORT_SYMBOL(ftape_disable);
-EXPORT_SYMBOL(ftape_mmap);
-EXPORT_SYMBOL(ftape_calibrate_data_rate);
-/* from ftape-io.c */
-EXPORT_SYMBOL(ftape_reset_drive);
-EXPORT_SYMBOL(ftape_command);
-EXPORT_SYMBOL(ftape_parameter);
-EXPORT_SYMBOL(ftape_ready_wait);
-EXPORT_SYMBOL(ftape_report_operation);
-EXPORT_SYMBOL(ftape_report_error);
-/* from ftape-read.c */
-EXPORT_SYMBOL(ftape_read_segment_fraction);
-EXPORT_SYMBOL(ftape_zap_read_buffers);
-EXPORT_SYMBOL(ftape_read_header_segment);
-EXPORT_SYMBOL(ftape_decode_header_segment);
-/* from ftape-write.c */
-EXPORT_SYMBOL(ftape_write_segment);
-EXPORT_SYMBOL(ftape_start_writing);
-EXPORT_SYMBOL(ftape_loop_until_writes_done);
-/* from ftape-buffer.h */
-EXPORT_SYMBOL(ftape_set_nr_buffers);
-/* from ftape-format.h */
-EXPORT_SYMBOL(ftape_format_track);
-EXPORT_SYMBOL(ftape_format_status);
-EXPORT_SYMBOL(ftape_verify_segment);
-/* from tracing.c */
-#ifndef CONFIG_FT_NO_TRACE_AT_ALL
-EXPORT_SYMBOL(ftape_tracing);
-EXPORT_SYMBOL(ftape_function_nest_level);
-EXPORT_SYMBOL(ftape_trace_call);
-EXPORT_SYMBOL(ftape_trace_exit);
-EXPORT_SYMBOL(ftape_trace_log);
-#endif
-
diff --git a/drivers/char/ftape/zftape/Makefile b/drivers/char/ftape/zftape/Makefile
deleted file mode 100644
index 6d91c1f77c05..000000000000
--- a/drivers/char/ftape/zftape/Makefile
+++ /dev/null
@@ -1,36 +0,0 @@
-#
-#       Copyright (C) 1996, 1997 Claus-Justus Heine.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2, or (at your option)
-# any later version.
-# 
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-# 
-# You should have received a copy of the GNU General Public License
-# along with this program; see the file COPYING.  If not, write to
-# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-#
-# $Source: /homes/cvs/ftape-stacked/ftape/zftape/Makefile,v $
-# $Revision: 1.4 $
-# $Date: 1997/10/05 19:18:58 $
-#
-#      Makefile for the QIC-40/80/3010/3020 zftape interface VFS to
-#      ftape
-#
-
-
-# ZFT_OBSOLETE - enable the MTIOC_ZFTAPE_GETBLKSZ ioctl. You should
-#                leave this enabled for compatibility with taper.
-
-obj-$(CONFIG_ZFTAPE) += zftape.o
-
-zftape-objs := zftape-rw.o zftape-ctl.o zftape-read.o \
-               zftape-write.o zftape-vtbl.o zftape-eof.o \
-               zftape-init.o zftape-buffers.o zftape_syms.o
-
-EXTRA_CFLAGS := -DZFT_OBSOLETE
diff --git a/drivers/char/ftape/zftape/zftape-buffers.c b/drivers/char/ftape/zftape/zftape-buffers.c
deleted file mode 100644
index da06f138334e..000000000000
--- a/drivers/char/ftape/zftape/zftape-buffers.c
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
- *      Copyright (C) 1995-1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/zftape/zftape-buffers.c,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:18:59 $
- *
- *      This file contains the dynamic buffer allocation routines 
- *      of zftape
- */
-
-#include <linux/errno.h>
-#include <linux/mm.h>
-#include <linux/slab.h>
-#include <linux/delay.h>
-
-#include <linux/zftape.h>
-
-#include <linux/vmalloc.h>
-
-#include "../zftape/zftape-init.h"
-#include "../zftape/zftape-eof.h"
-#include "../zftape/zftape-ctl.h"
-#include "../zftape/zftape-write.h"
-#include "../zftape/zftape-read.h"
-#include "../zftape/zftape-rw.h"
-#include "../zftape/zftape-vtbl.h"
-
-/*  global variables
- */
-
-/*  local varibales
- */
-static unsigned int used_memory;
-static unsigned int peak_memory;
-
-void zft_memory_stats(void)
-{
-        TRACE_FUN(ft_t_flow);
-
-        TRACE(ft_t_noise, "Memory usage (vmalloc allocations):\n"
-              KERN_INFO "total allocated: %d\n"
-              KERN_INFO "peak allocation: %d",
-              used_memory, peak_memory);
-        peak_memory = used_memory;
-        TRACE_EXIT;
-}
-
-int zft_vcalloc_once(void *new, size_t size)
-{
-        TRACE_FUN(ft_t_flow);
-        if (zft_vmalloc_once(new, size) < 0) {
-                TRACE_EXIT -ENOMEM;
-        }
-        memset(*(void **)new, '\0', size);
-        TRACE_EXIT 0;
-}
-int zft_vmalloc_once(void *new, size_t size)
-{
-        TRACE_FUN(ft_t_flow);
-
-        if (*(void **)new != NULL || size == 0) {
-                TRACE_EXIT 0;
-        }
-        if ((*(void **)new = vmalloc(size)) == NULL) {
-                TRACE_EXIT -ENOMEM;
-        }
-        used_memory += size;
-        if (peak_memory < used_memory) {
-                peak_memory = used_memory;
-        }
-        TRACE_ABORT(0, ft_t_noise,
-                    "allocated buffer @ %p, %d bytes", *(void **)new, size);
-}
-int zft_vmalloc_always(void *new, size_t size)
-{
-        TRACE_FUN(ft_t_flow);
-
-        zft_vfree(new, size);
-        TRACE_EXIT zft_vmalloc_once(new, size);
-}
-void zft_vfree(void *old, size_t size)
-{
-        TRACE_FUN(ft_t_flow);
-
-        if (*(void **)old) {
-                vfree(*(void **)old);
-                used_memory -= size;
-                TRACE(ft_t_noise, "released buffer @ %p, %d bytes",
-                      *(void **)old, size);
-                *(void **)old = NULL;
-        }
-        TRACE_EXIT;
-}
-
-void *zft_kmalloc(size_t size)
-{
-        void *new;
-
-        while ((new = kmalloc(size, GFP_KERNEL)) == NULL) {
-                msleep_interruptible(100);
-        }
-        memset(new, 0, size);
-        used_memory += size;
-        if (peak_memory < used_memory) {
-                peak_memory = used_memory;
-        }
-        return new;
-}
-
-void zft_kfree(void *old, size_t size)
-{
-        kfree(old);
-        used_memory -= size;
-}
-
-/* there are some more buffers that are allocated on demand.
- * cleanup_module() calles this function to be sure to have released
- * them 
- */
-void zft_uninit_mem(void)
-{
-        TRACE_FUN(ft_t_flow);
-
-        zft_vfree(&zft_hseg_buf, FT_SEGMENT_SIZE);
-        zft_vfree(&zft_deblock_buf, FT_SEGMENT_SIZE); zft_deblock_segment = -1;
-        zft_free_vtbl();
-        if (zft_cmpr_lock(0 /* don't load */) == 0) {
-                (*zft_cmpr_ops->cleanup)();
-                (*zft_cmpr_ops->reset)(); /* unlock it again */
-        }
-        zft_memory_stats();
-        TRACE_EXIT;
-}
diff --git a/drivers/char/ftape/zftape/zftape-buffers.h b/drivers/char/ftape/zftape/zftape-buffers.h
deleted file mode 100644
index 798e3128c682..000000000000
--- a/drivers/char/ftape/zftape/zftape-buffers.h
+++ /dev/null
@@ -1,55 +0,0 @@
-#ifndef _FTAPE_DYNMEM_H
-#define _FTAPE_DYNMEM_H
-
-/*
- *      Copyright (C) 1995-1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/zftape/zftape-buffers.h,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:18:59 $
- *
- *   memory allocation routines.
- *
- */
-
-/* we do not allocate all of the really large buffer memory before
- * someone tries to open the drive. ftape_open() may fail with
- * -ENOMEM, but that's better having 200k of vmalloced memory which
- * cannot be swapped out.
- */
-
-extern void  zft_memory_stats(void);
-extern int   zft_vmalloc_once(void *new, size_t size);
-extern int   zft_vcalloc_once(void *new, size_t size);
-extern int   zft_vmalloc_always(void *new, size_t size);
-extern void  zft_vfree(void *old, size_t size);
-extern void *zft_kmalloc(size_t size);
-extern void  zft_kfree(void *old, size_t size);
-
-/* called by cleanup_module() 
- */
-extern void zft_uninit_mem(void);
-
-#endif
-
-
-
-
-
-
-
diff --git a/drivers/char/ftape/zftape/zftape-ctl.c b/drivers/char/ftape/zftape/zftape-ctl.c
deleted file mode 100644
index 22ba0f5d00cf..000000000000
--- a/drivers/char/ftape/zftape/zftape-ctl.c
+++ /dev/null
@@ -1,1417 +0,0 @@
-/* 
- *      Copyright (C) 1996, 1997 Claus-Justus Heine
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/zftape/zftape-ctl.c,v $
- * $Revision: 1.2.6.2 $
- * $Date: 1997/11/14 18:07:33 $
- *
- *      This file contains the non-read/write zftape functions
- *      for the QIC-40/80/3010/3020 floppy-tape driver for Linux.
- */
-
-#include <linux/errno.h>
-#include <linux/mm.h>
-#include <linux/module.h>
-#include <linux/fcntl.h>
-
-#include <linux/zftape.h>
-
-#include <asm/uaccess.h>
-
-#include "../zftape/zftape-init.h"
-#include "../zftape/zftape-eof.h"
-#include "../zftape/zftape-ctl.h"
-#include "../zftape/zftape-write.h"
-#include "../zftape/zftape-read.h"
-#include "../zftape/zftape-rw.h"
-#include "../zftape/zftape-vtbl.h"
-
-/*      Global vars.
- */
-int zft_write_protected; /* this is when cartridge rdonly or O_RDONLY */
-int zft_header_read;
-int zft_offline;
-unsigned int zft_unit;
-int zft_resid;
-int zft_mt_compression;
-
-/*      Local vars.
- */
-static int going_offline;
-
-typedef int (mt_fun)(int *argptr);
-typedef int (*mt_funp)(int *argptr);
-typedef struct
-{
-        mt_funp function;
-        unsigned offline         : 1; /* op permitted if offline or no_tape */
-        unsigned write_protected : 1; /* op permitted if write-protected    */
-        unsigned not_formatted   : 1; /* op permitted if tape not formatted */
-        unsigned raw_mode        : 1; /* op permitted if zft_mode == 0    */
-        unsigned need_idle_state : 1; /* need to call def_idle_state        */
-        char     *name;
-} fun_entry;
-
-static mt_fun mt_dummy, mt_reset, mt_fsr, mt_bsr, mt_rew, mt_offl, mt_nop,
-        mt_weof, mt_erase, mt_ras2, mt_setblk, mt_setdensity,
-        mt_seek, mt_tell, mt_reten, mt_eom, mt_fsf, mt_bsf,
-        mt_fsfm, mt_bsfm, mt_setdrvbuffer, mt_compression;
-
-static fun_entry mt_funs[]=
-{ 
-        {mt_reset       , 1, 1, 1, 1, 0, "MT_RESET" }, /*  0 */
-        {mt_fsf         , 0, 1, 0, 0, 1, "MT_FSF"   },
-        {mt_bsf         , 0, 1, 0, 0, 1, "MT_BSF"   },
-        {mt_fsr         , 0, 1, 0, 1, 1, "MT_FSR"   },
-        {mt_bsr         , 0, 1, 0, 1, 1, "MT_BSR"   },
-        {mt_weof        , 0, 0, 0, 0, 0, "MT_WEOF"  }, /*  5 */
-        {mt_rew         , 0, 1, 1, 1, 0, "MT_REW"   },
-        {mt_offl        , 0, 1, 1, 1, 0, "MT_OFFL"  },
-        {mt_nop         , 1, 1, 1, 1, 0, "MT_NOP"   },
-        {mt_reten       , 0, 1, 1, 1, 0, "MT_RETEN" },
-        {mt_bsfm        , 0, 1, 0, 0, 1, "MT_BSFM"  }, /* 10 */
-        {mt_fsfm        , 0, 1, 0, 0, 1, "MT_FSFM"  },
-        {mt_eom         , 0, 1, 0, 0, 1, "MT_EOM"   },
-        {mt_erase       , 0, 0, 0, 1, 0, "MT_ERASE" },
-        {mt_dummy       , 1, 1, 1, 1, 0, "MT_RAS1"  },
-        {mt_ras2        , 0, 0, 0, 1, 0, "MT_RAS2"  },
-        {mt_dummy       , 1, 1, 1, 1, 0, "MT_RAS3"  },
-        {mt_dummy       , 1, 1, 1, 1, 0, "UNKNOWN"  },
-        {mt_dummy       , 1, 1, 1, 1, 0, "UNKNOWN"  },
-        {mt_dummy       , 1, 1, 1, 1, 0, "UNKNOWN"  },
-        {mt_setblk      , 1, 1, 1, 1, 1, "MT_SETBLK"}, /* 20 */
-        {mt_setdensity  , 1, 1, 1, 1, 0, "MT_SETDENSITY"},
-        {mt_seek        , 0, 1, 0, 1, 1, "MT_SEEK"  },
-        {mt_dummy       , 0, 1, 0, 1, 1, "MT_TELL"  }, /* wr-only ?! */
-        {mt_setdrvbuffer, 1, 1, 1, 1, 0, "MT_SETDRVBUFFER" },
-        {mt_dummy       , 1, 1, 1, 1, 0, "MT_FSS"   }, /* 25 */
-        {mt_dummy       , 1, 1, 1, 1, 0, "MT_BSS"   },
-        {mt_dummy       , 1, 1, 1, 1, 0, "MT_WSM"   },
-        {mt_dummy       , 1, 1, 1, 1, 0, "MT_LOCK"  },
-        {mt_dummy       , 1, 1, 1, 1, 0, "MT_UNLOCK"},
-        {mt_dummy       , 1, 1, 1, 1, 0, "MT_LOAD"  }, /* 30 */
-        {mt_dummy       , 1, 1, 1, 1, 0, "MT_UNLOAD"},
-        {mt_compression , 1, 1, 1, 0, 1, "MT_COMPRESSION"},
-        {mt_dummy       , 1, 1, 1, 1, 0, "MT_SETPART"},
-        {mt_dummy       , 1, 1, 1, 1, 0, "MT_MKPART"}
-};  
-
-#define NR_MT_CMDS NR_ITEMS(mt_funs)
-
-void zft_reset_position(zft_position *pos)
-{
-        TRACE_FUN(ft_t_flow);
-
-        pos->seg_byte_pos =
-                pos->volume_pos = 0;
-        if (zft_header_read) {
-                /* need to keep track of the volume table and
-                 * compression map. We therefor simply
-                 * position at the beginning of the first
-                 * volume. This covers old ftape archives as
-                 * well has various flavours of the
-                 * compression map segments. The worst case is
-                 * that the compression map shows up as a
-                 * additional volume in front of all others.
-                 */
-                pos->seg_pos  = zft_find_volume(0)->start_seg;
-                pos->tape_pos = zft_calc_tape_pos(pos->seg_pos);
-        } else {
-                pos->tape_pos =  0;
-                pos->seg_pos  = -1;
-        }
-        zft_just_before_eof =  0;
-        zft_deblock_segment = -1;
-        zft_io_state        = zft_idle;
-        zft_zap_read_buffers();
-        zft_prevent_flush();
-        /*  unlock the compresison module if it is loaded.
-         *  The zero arg means not to try to load the module.
-         */
-        if (zft_cmpr_lock(0) == 0) {
-                (*zft_cmpr_ops->reset)(); /* unlock */
-        }
-        TRACE_EXIT;
-}
-
-static void zft_init_driver(void)
-{
-        TRACE_FUN(ft_t_flow);
-
-        zft_resid =
-                zft_header_read          =
-                zft_old_ftape            =
-                zft_offline              =
-                zft_write_protected      =
-                going_offline            =
-                zft_mt_compression       =
-                zft_header_changed       =
-                zft_volume_table_changed =
-                zft_written_segments     = 0;
-        zft_blk_sz = CONFIG_ZFT_DFLT_BLK_SZ;
-        zft_reset_position(&zft_pos); /* does most of the stuff */
-        ftape_zap_read_buffers();
-        ftape_set_state(idle);
-        TRACE_EXIT;
-}
-
-int zft_def_idle_state(void)
-{ 
-        int result = 0;
-        TRACE_FUN(ft_t_flow);
-        
-        if (!zft_header_read) {
-                result = zft_read_header_segments();
-        } else if ((result = zft_flush_buffers()) >= 0 && zft_qic_mode) {
-                /*  don't move past eof
-                 */
-                (void)zft_close_volume(&zft_pos);
-        }
-        if (ftape_abort_operation() < 0) {
-                TRACE(ft_t_warn, "ftape_abort_operation() failed");
-                result = -EIO;
-        }
-        /* clear remaining read buffers */
-        zft_zap_read_buffers();
-        zft_io_state = zft_idle;
-        TRACE_EXIT result;
-}
-
-/*****************************************************************************
- *                                                                           *
- *  functions for the MTIOCTOP commands                                      *
- *                                                                           *
- *****************************************************************************/
-
-static int mt_dummy(int *dummy)
-{
-        TRACE_FUN(ft_t_flow);
-        
-        TRACE_EXIT -ENOSYS;
-}
-
-static int mt_reset(int *dummy)
-{        
-        TRACE_FUN(ft_t_flow);
-        
-        (void)ftape_seek_to_bot();
-        TRACE_CATCH(ftape_reset_drive(),
-                    zft_init_driver(); zft_uninit_mem(); zft_offline = 1);
-        /*  fake a re-open of the device. This will set all flage and 
-         *  allocate buffers as appropriate. The new tape condition will
-         *  force the open routine to do anything we need.
-         */
-        TRACE_CATCH(_zft_open(-1 /* fake reopen */, 0 /* dummy */),);
-        TRACE_EXIT 0;
-}
-
-static int mt_fsf(int *arg)
-{
-        int result;
-        TRACE_FUN(ft_t_flow);
-
-        result = zft_skip_volumes(*arg, &zft_pos);
-        zft_just_before_eof = 0;
-        TRACE_EXIT result;
-}
-
-static int mt_bsf(int *arg)
-{
-        int result = 0;
-        TRACE_FUN(ft_t_flow);
-        
-        if (*arg != 0) {
-                result = zft_skip_volumes(-*arg + 1, &zft_pos);
-        }
-        TRACE_EXIT result;
-}
-
-static int seek_block(__s64 data_offset,
-                      __s64 block_increment,
-                      zft_position *pos)
-{ 
-        int result      = 0;
-        __s64 new_block_pos;
-        __s64 vol_block_count;
-        const zft_volinfo *volume;
-        int exceed;
-        TRACE_FUN(ft_t_flow);
-        
-        volume = zft_find_volume(pos->seg_pos);
-        if (volume->start_seg == 0 || volume->end_seg == 0) {
-                TRACE_EXIT -EIO;
-        }
-        new_block_pos   = (zft_div_blksz(data_offset, volume->blk_sz)
-                           + block_increment);
-        vol_block_count = zft_div_blksz(volume->size, volume->blk_sz);
-        if (new_block_pos < 0) {
-                TRACE(ft_t_noise,
-                      "new_block_pos " LL_X " < 0", LL(new_block_pos));
-                zft_resid     = (int)new_block_pos;
-                new_block_pos = 0;
-                exceed = 1;
-        } else if (new_block_pos > vol_block_count) {
-                TRACE(ft_t_noise,
-                      "new_block_pos " LL_X " exceeds size of volume " LL_X,
-                      LL(new_block_pos), LL(vol_block_count));
-                zft_resid     = (int)(vol_block_count - new_block_pos);
-                new_block_pos = vol_block_count;
-                exceed = 1;
-        } else {
-                exceed = 0;
-        }
-        if (zft_use_compression && volume->use_compression) {
-                TRACE_CATCH(zft_cmpr_lock(1 /* try to load */),);
-                result = (*zft_cmpr_ops->seek)(new_block_pos, pos, volume,
-                                               zft_deblock_buf);
-                pos->tape_pos  = zft_calc_tape_pos(pos->seg_pos);
-                pos->tape_pos += pos->seg_byte_pos;
-        } else {
-                pos->volume_pos = zft_mul_blksz(new_block_pos, volume->blk_sz);
-                pos->tape_pos   = zft_calc_tape_pos(volume->start_seg);
-                pos->tape_pos  += pos->volume_pos;
-                pos->seg_pos    = zft_calc_seg_byte_coord(&pos->seg_byte_pos,
-                                                          pos->tape_pos);
-        }
-        zft_just_before_eof = volume->size == pos->volume_pos;
-        if (zft_just_before_eof) {
-                /* why this? because zft_file_no checks agains start
-                 * and end segment of a volume. We do not want to
-                 * advance to the next volume with this function.
-                 */
-                TRACE(ft_t_noise, "set zft_just_before_eof");
-                zft_position_before_eof(pos, volume);
-        }
-        TRACE(ft_t_noise, "\n"
-              KERN_INFO "new_seg_pos : %d\n"
-              KERN_INFO "new_tape_pos: " LL_X "\n"
-              KERN_INFO "vol_size    : " LL_X "\n"
-              KERN_INFO "seg_byte_pos: %d\n"
-              KERN_INFO "blk_sz  : %d", 
-              pos->seg_pos, LL(pos->tape_pos),
-              LL(volume->size), pos->seg_byte_pos,
-              volume->blk_sz);
-        if (!exceed) {
-                zft_resid = new_block_pos - zft_div_blksz(pos->volume_pos,
-                                                          volume->blk_sz);
-        }
-        if (zft_resid < 0) {
-                zft_resid = -zft_resid;
-        }
-        TRACE_EXIT ((exceed || zft_resid != 0) && result >= 0) ? -EINVAL : result;
-}     
-
-static int mt_fsr(int *arg)
-{ 
-        int result;
-        TRACE_FUN(ft_t_flow);
-        
-        result = seek_block(zft_pos.volume_pos,  *arg, &zft_pos);
-        TRACE_EXIT result;
-}
-
-static int mt_bsr(int *arg)
-{   
-        int result;
-        TRACE_FUN(ft_t_flow);
-        
-        result = seek_block(zft_pos.volume_pos, -*arg, &zft_pos);
-        TRACE_EXIT result;
-}
-
-static int mt_weof(int *arg)
-{
-        int result;
-        TRACE_FUN(ft_t_flow);
-        
-        TRACE_CATCH(zft_flush_buffers(),);
-        result = zft_weof(*arg, &zft_pos);
-        TRACE_EXIT result;
-}
-
-static int mt_rew(int *dummy)
-{          
-        int result;
-        TRACE_FUN(ft_t_flow);
-        
-        if(zft_header_read) {
-                (void)zft_def_idle_state();
-        }
-        result = ftape_seek_to_bot();
-        zft_reset_position(&zft_pos);
-        TRACE_EXIT result;
-}
-
-static int mt_offl(int *dummy)
-{
-        int result;
-        TRACE_FUN(ft_t_flow);
-        
-        going_offline= 1;
-        result = mt_rew(NULL);
-        TRACE_EXIT result;
-}
-
-static int mt_nop(int *dummy)
-{
-        TRACE_FUN(ft_t_flow);
-        /*  should we set tape status?
-         */
-        if (!zft_offline) { /* offline includes no_tape */
-                (void)zft_def_idle_state();
-        }
-        TRACE_EXIT 0; 
-}
-
-static int mt_reten(int *dummy)
-{  
-        int result;
-        TRACE_FUN(ft_t_flow);
-        
-        if(zft_header_read) {
-                (void)zft_def_idle_state();
-        }
-        result = ftape_seek_to_eot();
-        if (result >= 0) {
-                result = ftape_seek_to_bot();
-        }
-        TRACE_EXIT(result);
-}
-
-static int fsfbsfm(int arg, zft_position *pos)
-{ 
-        const zft_volinfo *vtbl;
-        __s64 block_pos;
-        TRACE_FUN(ft_t_flow);
-        
-        /* What to do? This should seek to the next file-mark and
-         * position BEFORE. That is, a next write would just extend
-         * the current file.  Well. Let's just seek to the end of the
-         * current file, if count == 1.  If count > 1, then do a
-         * "mt_fsf(count - 1)", and then seek to the end of that file.
-         * If count == 0, do nothing
-         */
-        if (arg == 0) {
-                TRACE_EXIT 0;
-        }
-        zft_just_before_eof = 0;
-        TRACE_CATCH(zft_skip_volumes(arg < 0 ? arg : arg-1, pos),
-                    if (arg > 0) {
-                            zft_resid ++; 
-                    });
-        vtbl      = zft_find_volume(pos->seg_pos);
-        block_pos = zft_div_blksz(vtbl->size, vtbl->blk_sz);
-        (void)seek_block(0, block_pos, pos);
-        if (pos->volume_pos != vtbl->size) {
-                zft_just_before_eof = 0;
-                zft_resid = 1;
-                /* we didn't managed to go there */
-                TRACE_ABORT(-EIO, ft_t_err, 
-                            "wanted file position " LL_X ", arrived at " LL_X, 
-                            LL(vtbl->size), LL(pos->volume_pos));
-        }
-        zft_just_before_eof = 1;
-        TRACE_EXIT 0; 
-}
-
-static int mt_bsfm(int *arg)
-{
-        int result;
-        TRACE_FUN(ft_t_flow);
-        
-        result = fsfbsfm(-*arg, &zft_pos);
-        TRACE_EXIT result;
-}
-
-static int mt_fsfm(int *arg)
-{
-        int result;
-        TRACE_FUN(ft_t_flow);
-        
-        result = fsfbsfm(*arg, &zft_pos);
-        TRACE_EXIT result;
-}
-
-static int mt_eom(int *dummy)
-{              
-        TRACE_FUN(ft_t_flow);
-        
-        zft_skip_to_eom(&zft_pos);
-        TRACE_EXIT 0;
-}
-
-static int mt_erase(int *dummy)
-{
-        int result;
-        TRACE_FUN(ft_t_flow);
-        
-        result = zft_erase();
-        TRACE_EXIT result;
-}
-
-static int mt_ras2(int *dummy)
-{
-        int result;
-        TRACE_FUN(ft_t_flow);
-        
-        result = -ENOSYS;
-        TRACE_EXIT result;
-} 
-
-/*  Sets the new blocksize in BYTES
- *
- */
-static int mt_setblk(int *new_size)
-{
-        TRACE_FUN(ft_t_flow);
-        
-        if((unsigned int)(*new_size) > ZFT_MAX_BLK_SZ) {
-                TRACE_ABORT(-EINVAL, ft_t_info,
-                            "desired blk_sz (%d) should be <= %d bytes",
-                            *new_size, ZFT_MAX_BLK_SZ);
-        }
-        if ((*new_size & (FT_SECTOR_SIZE-1)) != 0) {
-                TRACE_ABORT(-EINVAL, ft_t_info,
-                        "desired blk_sz (%d) must be a multiple of %d bytes",
-                            *new_size, FT_SECTOR_SIZE);
-        }
-        if (*new_size == 0) {
-                if (zft_use_compression) {
-                        TRACE_ABORT(-EINVAL, ft_t_info,
-                                    "Variable block size not yet "
-                                    "supported with compression");
-                }
-                *new_size = 1;
-        }
-        zft_blk_sz = *new_size;
-        TRACE_EXIT 0;
-} 
-
-static int mt_setdensity(int *arg)
-{
-        TRACE_FUN(ft_t_flow);
-        
-        SET_TRACE_LEVEL(*arg);
-        TRACE(TRACE_LEVEL, "tracing set to %d", TRACE_LEVEL);
-        if ((int)TRACE_LEVEL != *arg) {
-                TRACE_EXIT -EINVAL;
-        }
-        TRACE_EXIT 0;
-}          
-
-static int mt_seek(int *new_block_pos)
-{ 
-        int result= 0;        
-        TRACE_FUN(ft_t_any);
-        
-        result = seek_block(0, (__s64)*new_block_pos, &zft_pos);
-        TRACE_EXIT result;
-}
-
-/*  OK, this is totally different from SCSI, but the worst thing that can 
- *  happen is that there is not enough defragmentated memory that can be 
- *  allocated. Also, there is a hardwired limit of 16 dma buffers in the 
- *  stock ftape module. This shouldn't bring the system down.
- *
- * NOTE: the argument specifies the total number of dma buffers to use.
- *       The driver needs at least 3 buffers to function at all.
- * 
- */
-static int mt_setdrvbuffer(int *cnt)
-{
-        TRACE_FUN(ft_t_flow);
-
-        if (*cnt < 3) {
-                TRACE_EXIT -EINVAL;
-        }
-        TRACE_CATCH(ftape_set_nr_buffers(*cnt),);
-        TRACE_EXIT 0;
-}
-/* return the block position from start of volume 
- */
-static int mt_tell(int *arg)
-{
-        TRACE_FUN(ft_t_flow);
-        
-        *arg   = zft_div_blksz(zft_pos.volume_pos,
-                               zft_find_volume(zft_pos.seg_pos)->blk_sz);
-        TRACE_EXIT 0;
-}
-
-static int mt_compression(int *arg)
-{
-        TRACE_FUN(ft_t_flow);
-        
-        /*  Ok. We could also check whether compression is available at
-         *  all by trying to load the compression module.  We could
-         *  also check for a block size of 1 byte which is illegal
-         *  with compression.  Instead of doing it here we rely on
-         *  zftape_write() to do the proper checks.
-         */
-        if ((unsigned int)*arg > 1) {
-                TRACE_EXIT -EINVAL;
-        }
-        if (*arg != 0 && zft_blk_sz == 1) { /* variable block size */
-                TRACE_ABORT(-EINVAL, ft_t_info,
-                            "Compression not yet supported "
-                            "with variable block size");
-        }
-        zft_mt_compression  = *arg;
-        if ((zft_unit & ZFT_ZIP_MODE) == 0) {
-                zft_use_compression = zft_mt_compression;
-        }
-        TRACE_EXIT 0;
-}
-
-/*  check whether write access is allowed. Write access is denied when
- *  + zft_write_protected == 1 -- this accounts for either hard write 
- *                                protection of the cartridge or for 
- *                                O_RDONLY access mode of the tape device
- *  + zft_offline == 1         -- this meany that there is either no tape 
- *                                or that the MTOFFLINE ioctl has been 
- *                                previously issued (`soft eject')
- *  + ft_formatted == 0        -- this means that the cartridge is not
- *                                formatted
- *  Then we distinuguish two cases. When zft_qic_mode is TRUE, then we try
- *  to emulate a `traditional' (aka SCSI like) UN*X tape device. Therefore we
- *  deny writes when
- *  + zft_qic_mode ==1 && 
- *       (!zft_tape_at_lbot() &&   -- tape no at logical BOT
- *        !(zft_tape_at_eom() ||   -- tape not at logical EOM (or EOD)
- *          (zft_tape_at_eom() &&
- *           zft_old_ftape())))    -- we can't add new volume to tapes 
- *                                    written by old ftape because ftape
- *                                    don't use the volume table
- *
- *  when the drive is in true raw mode (aka /dev/rawft0) then we don't 
- *  care about LBOT and EOM conditions. This device is intended for a 
- *  user level program that wants to truly implement the QIC-80 compliance
- *  at the logical data layout level of the cartridge, i.e. implement all
- *  that volume table and volume directory stuff etc.<
- */
-int zft_check_write_access(zft_position *pos)
-{
-        TRACE_FUN(ft_t_flow);
-
-        if (zft_offline) { /* offline includes no_tape */
-                TRACE_ABORT(-ENXIO,
-                            ft_t_info, "tape is offline or no cartridge");
-        }
-        if (!ft_formatted) {
-                TRACE_ABORT(-EACCES, ft_t_info, "tape is not formatted");
-        } 
-        if (zft_write_protected) {
-                TRACE_ABORT(-EACCES, ft_t_info, "cartridge write protected");
-        } 
-        if (zft_qic_mode) {
-                /*  check BOT condition */
-                if (!zft_tape_at_lbot(pos)) {
-                        /*  protect cartridges written by old ftape if
-                         *  not at BOT because they use the vtbl
-                         *  segment for storing data
-                         */
-                        if (zft_old_ftape) {
-                                TRACE_ABORT(-EACCES, ft_t_warn, 
-      "Cannot write to cartridges written by old ftape when not at BOT");
-                        }
-                        /*  not at BOT, but allow writes at EOD, of course
-                         */
-                        if (!zft_tape_at_eod(pos)) {
-                                TRACE_ABORT(-EACCES, ft_t_info,
-                                            "tape not at BOT and not at EOD");
-                        }
-                }
-                /*  fine. Now the tape is either at BOT or at EOD. */
-        }
-        /* or in raw mode in which case we don't care about BOT and EOD */
-        TRACE_EXIT 0;
-}
-
-/*      OPEN routine called by kernel-interface code
- *
- *      NOTE: this is also called by mt_reset() with dev_minor == -1
- *            to fake a reopen after a reset.
- */
-int _zft_open(unsigned int dev_minor, unsigned int access_mode)
-{
-        static unsigned int tape_unit;
-        static unsigned int file_access_mode;
-        int result;
-        TRACE_FUN(ft_t_flow);
-
-        if ((int)dev_minor == -1) {
-                /* fake reopen */
-                zft_unit    = tape_unit;
-                access_mode = file_access_mode;
-                zft_init_driver(); /* reset all static data to defaults */
-        } else {
-                tape_unit        = dev_minor;
-                file_access_mode = access_mode;
-                if ((result = ftape_enable(FTAPE_SEL(dev_minor))) < 0) {
-                        TRACE_ABORT(-ENXIO, ft_t_err,
-                                    "ftape_enable failed: %d", result);
-                }
-                if (ft_new_tape || ft_no_tape || !ft_formatted ||
-                    (FTAPE_SEL(zft_unit) != FTAPE_SEL(dev_minor)) ||
-                    (zft_unit & ZFT_RAW_MODE) != (dev_minor & ZFT_RAW_MODE)) {
-                        /* reset all static data to defaults,
-                         */
-                        zft_init_driver(); 
-                }
-                zft_unit = dev_minor;
-        }
-        zft_set_flags(zft_unit); /* decode the minor bits */
-        if (zft_blk_sz == 1 && zft_use_compression) {
-                ftape_disable(); /* resets ft_no_tape */
-                TRACE_ABORT(-ENODEV, ft_t_warn, "Variable block size not yet "
-                            "supported with compression");
-        }
-        /*  no need for most of the buffers when no tape or not
-         *  formatted.  for the read/write operations, it is the
-         *  regardless whether there is no tape, a not-formatted tape
-         *  or the whether the driver is soft offline.  
-         *  Nevertheless we allow some ioctls with non-formatted tapes, 
-         *  like rewind and reset.
-         */
-        if (ft_no_tape || !ft_formatted) {
-                zft_uninit_mem();
-        }
-        if (ft_no_tape) {
-                zft_offline = 1; /* so we need not test two variables */
-        }
-        if ((access_mode == O_WRONLY || access_mode == O_RDWR) &&
-            (ft_write_protected || ft_no_tape)) {
-                ftape_disable(); /* resets ft_no_tape */
-                TRACE_ABORT(ft_no_tape ? -ENXIO : -EROFS,
-                            ft_t_warn, "wrong access mode %s cartridge",
-                            ft_no_tape ? "without a" : "with write protected");
-        }
-        zft_write_protected = (access_mode == O_RDONLY || 
-                               ft_write_protected != 0);
-        if (zft_write_protected) {
-                TRACE(ft_t_noise,
-                      "read only access mode: %d, "
-                      "drive write protected: %d", 
-                      access_mode == O_RDONLY,
-                      ft_write_protected != 0);
-        }
-        if (!zft_offline) {
-                TRACE_CATCH(zft_vmalloc_once(&zft_deblock_buf,FT_SEGMENT_SIZE),
-                            ftape_disable());
-        }
-        /* zft_seg_pos should be greater than the vtbl segpos but not
-         * if in compatibility mode and only after we read in the
-         * header segments
-         *
-         * might also be a problem if the user makes a backup with a
-         * *qft* device and rewinds it with a raw device.
-         */
-        if (zft_qic_mode         &&
-            !zft_old_ftape       &&
-            zft_pos.seg_pos >= 0 &&
-            zft_header_read      && 
-            zft_pos.seg_pos <= ft_first_data_segment) {
-                TRACE(ft_t_noise, "you probably mixed up the zftape devices!");
-                zft_reset_position(&zft_pos); 
-        }
-        TRACE_EXIT 0;
-}
-
-/*      RELEASE routine called by kernel-interface code
- */
-int _zft_close(void)
-{
-        int result = 0;
-        TRACE_FUN(ft_t_flow);
-        
-        if (zft_offline) {
-                /* call the hardware release routine. Puts the drive offline */
-                ftape_disable();
-                TRACE_EXIT 0;
-        }
-        if (!(ft_write_protected || zft_old_ftape)) {
-                result = zft_flush_buffers();
-                TRACE(ft_t_noise, "writing file mark at current position");
-                if (zft_qic_mode && zft_close_volume(&zft_pos) == 0) {
-                        zft_move_past_eof(&zft_pos);
-                }
-                if ((zft_tape_at_lbot(&zft_pos) ||
-                     !(zft_unit & FTAPE_NO_REWIND))) {
-                        if (result >= 0) {
-                                result = zft_update_header_segments();
-                        } else {
-                                TRACE(ft_t_err,
-                                "Error: unable to update header segments");
-                        }
-                }
-        }
-        ftape_abort_operation();
-        if (!(zft_unit & FTAPE_NO_REWIND)) {
-                TRACE(ft_t_noise, "rewinding tape");
-                if (ftape_seek_to_bot() < 0 && result >= 0) {
-                        result = -EIO; /* keep old value */
-                }
-                zft_reset_position(&zft_pos);
-        } 
-        zft_zap_read_buffers();
-        /*  now free up memory as much as possible. We don't destroy
-         *  the deblock buffer if it containes a valid segment.
-         */
-        if (zft_deblock_segment == -1) {
-                zft_vfree(&zft_deblock_buf, FT_SEGMENT_SIZE); 
-        }
-        /* high level driver status, forces creation of a new volume
-         * when calling ftape_write again and not zft_just_before_eof
-         */
-        zft_io_state = zft_idle;  
-        if (going_offline) {
-                zft_init_driver();
-                zft_uninit_mem();
-                going_offline = 0;
-                zft_offline   = 1;
-        } else if (zft_cmpr_lock(0 /* don't load */) == 0) {
-                (*zft_cmpr_ops->reset)(); /* unlock it again */
-        }
-        zft_memory_stats();
-        /* call the hardware release routine. Puts the drive offline */
-        ftape_disable();
-        TRACE_EXIT result;
-}
-
-/*
- *  the wrapper function around the wrapper MTIOCTOP ioctl
- */
-static int mtioctop(struct mtop *mtop, int arg_size)
-{
-        int result = 0;
-        fun_entry *mt_fun_entry;
-        TRACE_FUN(ft_t_flow);
-        
-        if (arg_size != sizeof(struct mtop) || mtop->mt_op >= NR_MT_CMDS) {
-                TRACE_EXIT -EINVAL;
-        }
-        TRACE(ft_t_noise, "calling MTIOCTOP command: %s",
-              mt_funs[mtop->mt_op].name);
-        mt_fun_entry= &mt_funs[mtop->mt_op];
-        zft_resid = mtop->mt_count;
-        if (!mt_fun_entry->offline && zft_offline) {
-                if (ft_no_tape) {
-                        TRACE_ABORT(-ENXIO, ft_t_info, "no tape present");
-                } else {
-                        TRACE_ABORT(-ENXIO, ft_t_info, "drive is offline");
-                }
-        }
-        if (!mt_fun_entry->not_formatted && !ft_formatted) {
-                TRACE_ABORT(-EACCES, ft_t_info, "tape is not formatted");
-        }
-        if (!mt_fun_entry->write_protected) {
-                TRACE_CATCH(zft_check_write_access(&zft_pos),);
-        }
-        if (mt_fun_entry->need_idle_state && !(zft_offline || !ft_formatted)) {
-                TRACE_CATCH(zft_def_idle_state(),);
-        }
-        if (!zft_qic_mode && !mt_fun_entry->raw_mode) {
-                TRACE_ABORT(-EACCES, ft_t_info, 
-"Drive needs to be in QIC-80 compatibility mode for this command");
-        }
-        result = (mt_fun_entry->function)(&mtop->mt_count);
-        if (zft_tape_at_lbot(&zft_pos)) {
-                TRACE_CATCH(zft_update_header_segments(),);
-        }
-        if (result >= 0) {
-                zft_resid = 0;
-        }
-        TRACE_EXIT result;
-}
-
-/*
- *  standard MTIOCGET ioctl
- */
-static int mtiocget(struct mtget *mtget, int arg_size)
-{
-        const zft_volinfo *volume;
-        __s64 max_tape_pos;
-        TRACE_FUN(ft_t_flow);
-        
-        if (arg_size != sizeof(struct mtget)) {
-                TRACE_ABORT(-EINVAL, ft_t_info, "bad argument size: %d",
-                            arg_size);
-        }
-        mtget->mt_type  = ft_drive_type.vendor_id + 0x800000;
-        mtget->mt_dsreg = ft_last_status.space;
-        mtget->mt_erreg = ft_last_error.space; /* error register */
-        mtget->mt_resid = zft_resid; /* residuum of writes, reads and
-                                      * MTIOCTOP commands 
-                                      */
-        if (!zft_offline) { /* neither no_tape nor soft offline */
-                mtget->mt_gstat = GMT_ONLINE(~0UL);
-                /* should rather return the status of the cartridge
-                 * than the access mode of the file, therefor use
-                 * ft_write_protected, not zft_write_protected 
-                 */
-                if (ft_write_protected) {
-                        mtget->mt_gstat |= GMT_WR_PROT(~0UL);
-                }
-                if(zft_header_read) { /* this catches non-formatted */
-                        volume = zft_find_volume(zft_pos.seg_pos);
-                        mtget->mt_fileno = volume->count;
-                        max_tape_pos = zft_capacity - zft_blk_sz;
-                        if (zft_use_compression) {
-                                max_tape_pos -= ZFT_CMPR_OVERHEAD;
-                        }
-                        if (zft_tape_at_eod(&zft_pos)) {
-                                mtget->mt_gstat |= GMT_EOD(~0UL);
-                        }
-                        if (zft_pos.tape_pos > max_tape_pos) {
-                                mtget->mt_gstat |= GMT_EOT(~0UL);
-                        }
-                        mtget->mt_blkno = zft_div_blksz(zft_pos.volume_pos,
-                                                        volume->blk_sz);
-                        if (zft_just_before_eof) {
-                                mtget->mt_gstat |= GMT_EOF(~0UL);
-                        }
-                        if (zft_tape_at_lbot(&zft_pos)) {
-                                mtget->mt_gstat |= GMT_BOT(~0UL);
-                        }
-                } else {
-                        mtget->mt_fileno = mtget->mt_blkno = -1;
-                        if (mtget->mt_dsreg & QIC_STATUS_AT_BOT) {
-                                mtget->mt_gstat |= GMT_BOT(~0UL);
-                        }
-                }
-        } else {
-                if (ft_no_tape) {
-                        mtget->mt_gstat = GMT_DR_OPEN(~0UL);
-                } else {
-                        mtget->mt_gstat = 0UL;
-                }
-                mtget->mt_fileno = mtget->mt_blkno = -1;
-        }
-        TRACE_EXIT 0;
-}
-
-#ifdef MTIOCRDFTSEG
-/*
- *  Read a floppy tape segment. This is useful for manipulating the
- *  volume table, and read the old header segment before re-formatting
- *  the cartridge.
- */
-static int mtiocrdftseg(struct mtftseg * mtftseg, int arg_size)
-{
-        TRACE_FUN(ft_t_flow);
-        
-        TRACE(ft_t_noise, "Mag tape ioctl command: MTIOCRDFTSEG");
-        if (zft_qic_mode) {
-                TRACE_ABORT(-EACCES, ft_t_info,
-                            "driver needs to be in raw mode for this ioctl");
-        } 
-        if (arg_size != sizeof(struct mtftseg)) {
-                TRACE_ABORT(-EINVAL, ft_t_info, "bad argument size: %d",
-                            arg_size);
-        }
-        if (zft_offline) {
-                TRACE_EXIT -ENXIO;
-        }
-        if (mtftseg->mt_mode != FT_RD_SINGLE &&
-            mtftseg->mt_mode != FT_RD_AHEAD) {
-                TRACE_ABORT(-EINVAL, ft_t_info, "invalid read mode");
-        }
-        if (!ft_formatted) {
-                TRACE_EXIT -EACCES; /* -ENXIO ? */
-
-        }
-        if (!zft_header_read) {
-                TRACE_CATCH(zft_def_idle_state(),);
-        }
-        if (mtftseg->mt_segno > ft_last_data_segment) {
-                TRACE_ABORT(-EINVAL, ft_t_info, "segment number is too large");
-        }
-        mtftseg->mt_result = ftape_read_segment(mtftseg->mt_segno,
-                                                zft_deblock_buf,
-                                                mtftseg->mt_mode);
-        if (mtftseg->mt_result < 0) {
-                /*  a negativ result is not an ioctl error. if
-                 *  the user wants to read damaged tapes,
-                 *  it's up to her/him
-                 */
-                TRACE_EXIT 0;
-        }
-        if (copy_to_user(mtftseg->mt_data,
-                         zft_deblock_buf,
-                         mtftseg->mt_result) != 0) {
-                TRACE_EXIT -EFAULT;
-        }
-        TRACE_EXIT 0;
-}
-#endif
-
-#ifdef MTIOCWRFTSEG
-/*
- *  write a floppy tape segment. This version features writing of
- *  deleted address marks, and gracefully ignores the (software)
- *  ft_formatted flag to support writing of header segments after
- *  formatting.
- */
-static int mtiocwrftseg(struct mtftseg * mtftseg, int arg_size)
-{
-        int result;
-        TRACE_FUN(ft_t_flow);
-        
-        TRACE(ft_t_noise, "Mag tape ioctl command: MTIOCWRFTSEG");
-        if (zft_write_protected || zft_qic_mode) {
-                TRACE_EXIT -EACCES;
-        } 
-        if (arg_size != sizeof(struct mtftseg)) {
-                TRACE_ABORT(-EINVAL, ft_t_info, "bad argument size: %d",
-                            arg_size);
-        }
-        if (zft_offline) {
-                TRACE_EXIT -ENXIO;
-        }
-        if (mtftseg->mt_mode != FT_WR_ASYNC   && 
-            mtftseg->mt_mode != FT_WR_MULTI   &&
-            mtftseg->mt_mode != FT_WR_SINGLE  &&
-            mtftseg->mt_mode != FT_WR_DELETE) {
-                TRACE_ABORT(-EINVAL, ft_t_info, "invalid write mode");
-        }
-        /*
-         *  We don't check for ft_formatted, because this gives
-         *  only the software status of the driver.
-         *
-         *  We assume that the user knows what it is
-         *  doing. And rely on the low level stuff to fail
-         *  when the tape isn't formatted. We only make sure
-         *  that The header segment buffer is allocated,
-         *  because it holds the bad sector map.
-         */
-        if (zft_hseg_buf == NULL) {
-                TRACE_EXIT -ENXIO;
-        }
-        if (mtftseg->mt_mode != FT_WR_DELETE) {
-                if (copy_from_user(zft_deblock_buf, 
-                                   mtftseg->mt_data,
-                                   FT_SEGMENT_SIZE) != 0) {
-                        TRACE_EXIT -EFAULT;
-                }
-        }
-        mtftseg->mt_result = ftape_write_segment(mtftseg->mt_segno, 
-                                                 zft_deblock_buf,
-                                                 mtftseg->mt_mode);
-        if (mtftseg->mt_result >= 0 && mtftseg->mt_mode == FT_WR_SINGLE) {
-                /*  
-                 *  a negativ result is not an ioctl error. if
-                 *  the user wants to write damaged tapes,
-                 *  it's up to her/him
-                 */
-                if ((result = ftape_loop_until_writes_done()) < 0) {
-                        mtftseg->mt_result = result;
-                }
-        }
-        TRACE_EXIT 0;
-}
-#endif
-  
-#ifdef MTIOCVOLINFO
-/*
- *  get information about volume positioned at.
- */
-static int mtiocvolinfo(struct mtvolinfo *volinfo, int arg_size)
-{
-        const zft_volinfo *volume;
-        TRACE_FUN(ft_t_flow);
-        
-        TRACE(ft_t_noise, "Mag tape ioctl command: MTIOCVOLINFO");
-        if (arg_size != sizeof(struct mtvolinfo)) {
-                TRACE_ABORT(-EINVAL,
-                            ft_t_info, "bad argument size: %d", arg_size);
-        }
-        if (zft_offline) {
-                TRACE_EXIT -ENXIO;
-        }
-        if (!ft_formatted) {
-                TRACE_EXIT -EACCES;
-        }
-        TRACE_CATCH(zft_def_idle_state(),);
-        volume = zft_find_volume(zft_pos.seg_pos);
-        volinfo->mt_volno   = volume->count;
-        volinfo->mt_blksz   = volume->blk_sz == 1 ? 0 : volume->blk_sz;
-        volinfo->mt_size    = volume->size >> 10;
-        volinfo->mt_rawsize = ((zft_calc_tape_pos(volume->end_seg + 1) >> 10) -
-                               (zft_calc_tape_pos(volume->start_seg) >> 10));
-        volinfo->mt_cmpr    = volume->use_compression;
-        TRACE_EXIT 0;
-}
-#endif
-
-#ifdef ZFT_OBSOLETE  
-static int mtioc_zftape_getblksz(struct mtblksz *blksz, int arg_size)
-{
-        TRACE_FUN(ft_t_flow);
-        
-        TRACE(ft_t_noise, "\n"
-              KERN_INFO "Mag tape ioctl command: MTIOC_ZTAPE_GETBLKSZ\n"
-              KERN_INFO "This ioctl is here merely for compatibility.\n"
-              KERN_INFO "Please use MTIOCVOLINFO instead");
-        if (arg_size != sizeof(struct mtblksz)) {
-                TRACE_ABORT(-EINVAL,
-                            ft_t_info, "bad argument size: %d", arg_size);
-        }
-        if (zft_offline) {
-                TRACE_EXIT -ENXIO;
-        }
-        if (!ft_formatted) {
-                TRACE_EXIT -EACCES;
-        }
-        TRACE_CATCH(zft_def_idle_state(),);
-        blksz->mt_blksz = zft_find_volume(zft_pos.seg_pos)->blk_sz;
-        TRACE_EXIT 0;
-}
-#endif
-
-#ifdef MTIOCGETSIZE
-/*
- *  get the capacity of the tape cartridge.
- */
-static int mtiocgetsize(struct mttapesize *size, int arg_size)
-{
-        TRACE_FUN(ft_t_flow);
-        
-        TRACE(ft_t_noise, "Mag tape ioctl command: MTIOC_ZFTAPE_GETSIZE");
-        if (arg_size != sizeof(struct mttapesize)) {
-                TRACE_ABORT(-EINVAL,
-                            ft_t_info, "bad argument size: %d", arg_size);
-        }
-        if (zft_offline) {
-                TRACE_EXIT -ENXIO;
-        }
-        if (!ft_formatted) {
-                TRACE_EXIT -EACCES;
-        }
-        TRACE_CATCH(zft_def_idle_state(),);
-        size->mt_capacity = (unsigned int)(zft_capacity>>10);
-        size->mt_used     = (unsigned int)(zft_get_eom_pos()>>10);
-        TRACE_EXIT 0;
-}
-#endif
-
-static int mtiocpos(struct mtpos *mtpos, int arg_size)
-{
-        int result;
-        TRACE_FUN(ft_t_flow);
-        
-        TRACE(ft_t_noise, "Mag tape ioctl command: MTIOCPOS");
-        if (arg_size != sizeof(struct mtpos)) {
-                TRACE_ABORT(-EINVAL,
-                            ft_t_info, "bad argument size: %d", arg_size);
-        }
-        result = mt_tell((int *)&mtpos->mt_blkno);
-        TRACE_EXIT result;
-}
-
-#ifdef MTIOCFTFORMAT
-/*
- * formatting of floppy tape cartridges. This is intended to be used
- * together with the MTIOCFTCMD ioctl and the new mmap feature 
- */
-
-/* 
- *  This function uses ftape_decode_header_segment() to inform the low
- *  level ftape module about the new parameters.
- *
- *  It erases the hseg_buf. The calling process must specify all
- *  parameters to assure proper operation.
- *
- *  return values: -EINVAL - wrong argument size
- *                 -EINVAL - if ftape_decode_header_segment() failed.
- */
-static int set_format_parms(struct ftfmtparms *p, __u8 *hseg_buf)
-{
-        ft_trace_t old_level = TRACE_LEVEL;
-        TRACE_FUN(ft_t_flow);
-
-        TRACE(ft_t_noise, "MTIOCFTFORMAT operation FTFMT_SETPARMS");
-        memset(hseg_buf, 0, FT_SEGMENT_SIZE);
-        PUT4(hseg_buf, FT_SIGNATURE, FT_HSEG_MAGIC);
-
-        /*  fill in user specified parameters
-         */
-        hseg_buf[FT_FMT_CODE] = (__u8)p->ft_fmtcode;
-        PUT2(hseg_buf, FT_SPT, p->ft_spt);
-        hseg_buf[FT_TPC]      = (__u8)p->ft_tpc;
-        hseg_buf[FT_FHM]      = (__u8)p->ft_fhm;
-        hseg_buf[FT_FTM]      = (__u8)p->ft_ftm;
-
-        /*  fill in sane defaults to make ftape happy.
-         */ 
-        hseg_buf[FT_FSM] = (__u8)128; /* 128 is hard wired all over ftape */
-        if (p->ft_fmtcode == fmt_big) {
-                PUT4(hseg_buf, FT_6_HSEG_1,   0);
-                PUT4(hseg_buf, FT_6_HSEG_2,   1);
-                PUT4(hseg_buf, FT_6_FRST_SEG, 2);
-                PUT4(hseg_buf, FT_6_LAST_SEG, p->ft_spt * p->ft_tpc - 1);
-        } else {
-                PUT2(hseg_buf, FT_HSEG_1,    0);
-                PUT2(hseg_buf, FT_HSEG_2,    1);
-                PUT2(hseg_buf, FT_FRST_SEG,  2);
-                PUT2(hseg_buf, FT_LAST_SEG, p->ft_spt * p->ft_tpc - 1);
-        }
-
-        /*  Synchronize with the low level module. This is particularly
-         *  needed for unformatted cartridges as the QIC std was previously 
-         *  unknown BUT is needed to set data rate and to calculate timeouts.
-         */
-        TRACE_CATCH(ftape_calibrate_data_rate(p->ft_qicstd&QIC_TAPE_STD_MASK),
-                    _res = -EINVAL);
-
-        /*  The following will also recalcualte the timeouts for the tape
-         *  length and QIC std we want to format to.
-         *  abort with -EINVAL rather than -EIO
-         */
-        SET_TRACE_LEVEL(ft_t_warn);
-        TRACE_CATCH(ftape_decode_header_segment(hseg_buf),
-                    SET_TRACE_LEVEL(old_level); _res = -EINVAL);
-        SET_TRACE_LEVEL(old_level);
-        TRACE_EXIT 0;
-}
-
-/*
- *  Return the internal SOFTWARE status of the kernel driver. This does
- *  NOT query the tape drive about its status.
- */
-static int get_format_parms(struct ftfmtparms *p, __u8 *hseg_buffer)
-{
-        TRACE_FUN(ft_t_flow);
-
-        TRACE(ft_t_noise, "MTIOCFTFORMAT operation FTFMT_GETPARMS");
-        p->ft_qicstd  = ft_qic_std;
-        p->ft_fmtcode = ft_format_code;
-        p->ft_fhm     = hseg_buffer[FT_FHM];
-        p->ft_ftm     = hseg_buffer[FT_FTM];
-        p->ft_spt     = ft_segments_per_track;
-        p->ft_tpc     = ft_tracks_per_tape;
-        TRACE_EXIT 0;
-}
-
-static int mtiocftformat(struct mtftformat *mtftformat, int arg_size)
-{
-        int result;
-        union fmt_arg *arg = &mtftformat->fmt_arg;
-        TRACE_FUN(ft_t_flow);
-
-        TRACE(ft_t_noise, "Mag tape ioctl command: MTIOCFTFORMAT");
-        if (zft_offline) {
-                if (ft_no_tape) {
-                        TRACE_ABORT(-ENXIO, ft_t_info, "no tape present");
-                } else {
-                        TRACE_ABORT(-ENXIO, ft_t_info, "drive is offline");
-                }
-        }
-        if (zft_qic_mode) {
-                TRACE_ABORT(-EACCES, ft_t_info,
-                            "driver needs to be in raw mode for this ioctl");
-        } 
-        if (zft_hseg_buf == NULL) {
-                TRACE_CATCH(zft_vcalloc_once(&zft_hseg_buf, FT_SEGMENT_SIZE),);
-        }
-        zft_header_read = 0;
-        switch(mtftformat->fmt_op) {
-        case FTFMT_SET_PARMS:
-                TRACE_CATCH(set_format_parms(&arg->fmt_parms, zft_hseg_buf),);
-                TRACE_EXIT 0;
-        case FTFMT_GET_PARMS:
-                TRACE_CATCH(get_format_parms(&arg->fmt_parms, zft_hseg_buf),);
-                TRACE_EXIT 0;
-        case FTFMT_FORMAT_TRACK:
-                if ((ft_formatted && zft_check_write_access(&zft_pos) < 0) ||
-                    (!ft_formatted && zft_write_protected)) {
-                        TRACE_ABORT(-EACCES, ft_t_info, "Write access denied");
-                }
-                TRACE_CATCH(ftape_format_track(arg->fmt_track.ft_track,
-                                               arg->fmt_track.ft_gap3),);
-                TRACE_EXIT 0;
-        case FTFMT_STATUS:
-                TRACE_CATCH(ftape_format_status(&arg->fmt_status.ft_segment),);
-                TRACE_EXIT 0;
-        case FTFMT_VERIFY:
-                TRACE_CATCH(ftape_verify_segment(arg->fmt_verify.ft_segment,
-                                (SectorMap *)&arg->fmt_verify.ft_bsm),);
-                TRACE_EXIT 0;
-        default:
-                TRACE_ABORT(-EINVAL, ft_t_err, "Invalid format operation");
-        }
-        TRACE_EXIT result;
-}
-#endif
-
-#ifdef MTIOCFTCMD
-/*
- *  send a QIC-117 command to the drive, with optional timeouts,
- *  parameter and result bits. This is intended to be used together
- *  with the formatting ioctl.
- */
-static int mtiocftcmd(struct mtftcmd *ftcmd, int arg_size)
-{
-        int i;
-        TRACE_FUN(ft_t_flow);
-
-        TRACE(ft_t_noise, "Mag tape ioctl command: MTIOCFTCMD");
-        if (!capable(CAP_SYS_ADMIN)) {
-                TRACE_ABORT(-EPERM, ft_t_info,
-                            "need CAP_SYS_ADMIN capability to send raw qic-117 commands");
-        }
-        if (zft_qic_mode) {
-                TRACE_ABORT(-EACCES, ft_t_info,
-                            "driver needs to be in raw mode for this ioctl");
-        } 
-        if (arg_size != sizeof(struct mtftcmd)) {
-                TRACE_ABORT(-EINVAL,
-                            ft_t_info, "bad argument size: %d", arg_size);
-        }
-        if (ftcmd->ft_wait_before) {
-                TRACE_CATCH(ftape_ready_wait(ftcmd->ft_wait_before,
-                                             &ftcmd->ft_status),);
-        }
-        if (ftcmd->ft_status & QIC_STATUS_ERROR)
-                goto ftmtcmd_error;
-        if (ftcmd->ft_result_bits != 0) {
-                TRACE_CATCH(ftape_report_operation(&ftcmd->ft_result,
-                                                   ftcmd->ft_cmd,
-                                                   ftcmd->ft_result_bits),);
-        } else {
-                TRACE_CATCH(ftape_command(ftcmd->ft_cmd),);
-                if (ftcmd->ft_status & QIC_STATUS_ERROR)
-                        goto ftmtcmd_error;
-                for (i = 0; i < ftcmd->ft_parm_cnt; i++) {
-                        TRACE_CATCH(ftape_parameter(ftcmd->ft_parms[i]&0x0f),);
-                        if (ftcmd->ft_status & QIC_STATUS_ERROR)
-                                goto ftmtcmd_error;
-                }
-        }
-        if (ftcmd->ft_wait_after != 0) {
-                TRACE_CATCH(ftape_ready_wait(ftcmd->ft_wait_after,
-                                             &ftcmd->ft_status),);
-        }
-ftmtcmd_error:         
-        if (ftcmd->ft_status & QIC_STATUS_ERROR) {
-                TRACE(ft_t_noise, "error status set");
-                TRACE_CATCH(ftape_report_error(&ftcmd->ft_error,
-                                               &ftcmd->ft_cmd, 1),);
-        }
-        TRACE_EXIT 0; /* this is not an i/o error */
-}
-#endif
-
-/*  IOCTL routine called by kernel-interface code
- */
-int _zft_ioctl(unsigned int command, void __user * arg)
-{
-        int result;
-        union { struct mtop       mtop;
-                struct mtget      mtget;
-                struct mtpos      mtpos;
-#ifdef MTIOCRDFTSEG
-                struct mtftseg    mtftseg;
-#endif
-#ifdef MTIOCVOLINFO
-                struct mtvolinfo  mtvolinfo;
-#endif
-#ifdef MTIOCGETSIZE
-                struct mttapesize mttapesize;
-#endif
-#ifdef MTIOCFTFORMAT
-                struct mtftformat mtftformat;
-#endif
-#ifdef ZFT_OBSOLETE
-                struct mtblksz mtblksz;
-#endif
-#ifdef MTIOCFTCMD
-                struct mtftcmd mtftcmd;
-#endif
-        } krnl_arg;
-        int arg_size = _IOC_SIZE(command);
-        int dir = _IOC_DIR(command);
-        TRACE_FUN(ft_t_flow);
-
-        /* This check will only catch arguments that are too large !
-         */
-        if (dir & (_IOC_READ | _IOC_WRITE) && arg_size > sizeof(krnl_arg)) {
-                TRACE_ABORT(-EINVAL,
-                            ft_t_info, "bad argument size: %d", arg_size);
-        }
-        if (dir & _IOC_WRITE) {
-                if (copy_from_user(&krnl_arg, arg, arg_size) != 0) {
-                        TRACE_EXIT -EFAULT;
-                }
-        }
-        TRACE(ft_t_flow, "called with ioctl command: 0x%08x", command);
-        switch (command) {
-        case MTIOCTOP:
-                result = mtioctop(&krnl_arg.mtop, arg_size);
-                break;
-        case MTIOCGET:
-                result = mtiocget(&krnl_arg.mtget, arg_size);
-                break;
-        case MTIOCPOS:
-                result = mtiocpos(&krnl_arg.mtpos, arg_size);
-                break;
-#ifdef MTIOCVOLINFO
-        case MTIOCVOLINFO:
-                result = mtiocvolinfo(&krnl_arg.mtvolinfo, arg_size);
-                break;
-#endif
-#ifdef ZFT_OBSOLETE
-        case MTIOC_ZFTAPE_GETBLKSZ:
-                result = mtioc_zftape_getblksz(&krnl_arg.mtblksz, arg_size);
-                break;
-#endif
-#ifdef MTIOCRDFTSEG
-        case MTIOCRDFTSEG: /* read a segment via ioctl */
-                result = mtiocrdftseg(&krnl_arg.mtftseg, arg_size);
-                break;
-#endif
-#ifdef MTIOCWRFTSEG
-        case MTIOCWRFTSEG: /* write a segment via ioctl */
-                result = mtiocwrftseg(&krnl_arg.mtftseg, arg_size);
-                break;
-#endif
-#ifdef MTIOCGETSIZE
-        case MTIOCGETSIZE:
-                result = mtiocgetsize(&krnl_arg.mttapesize, arg_size);
-                break;
-#endif
-#ifdef MTIOCFTFORMAT
-        case MTIOCFTFORMAT:
-                result = mtiocftformat(&krnl_arg.mtftformat, arg_size);
-                break;
-#endif
-#ifdef MTIOCFTCMD
-        case MTIOCFTCMD:
-                result = mtiocftcmd(&krnl_arg.mtftcmd, arg_size);
-                break;
-#endif
-        default:
-                result = -EINVAL;
-                break;
-        }
-        if ((result >= 0) && (dir & _IOC_READ)) {
-                if (copy_to_user(arg, &krnl_arg, arg_size) != 0) {
-                        TRACE_EXIT -EFAULT;
-                }
-        }
-        TRACE_EXIT result;
-}
diff --git a/drivers/char/ftape/zftape/zftape-ctl.h b/drivers/char/ftape/zftape/zftape-ctl.h
deleted file mode 100644
index 8e6f2d7ac74e..000000000000
--- a/drivers/char/ftape/zftape/zftape-ctl.h
+++ /dev/null
@@ -1,58 +0,0 @@
-#ifndef _ZFTAPE_CTL_H
-#define _ZFTAPE_CTL_H
-
-/*
- * Copyright (C) 1996, 1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version. 
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/zftape/zftape-ctl.h,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:19:02 $
- *
- *      This file contains the non-standard IOCTL related definitions
- *      for the QIC-40/80 floppy-tape driver for Linux.
- */
-
-#include <linux/ioctl.h>
-#include <linux/mtio.h>
-
-#include "../zftape/zftape-rw.h"
-
-#ifdef CONFIG_ZFTAPE_MODULE
-#define ftape_status (*zft_status)
-#endif
-
-extern int zft_offline;
-extern int zft_mt_compression;
-extern int zft_write_protected;
-extern int zft_header_read;
-extern unsigned int zft_unit;
-extern int zft_resid;
-
-extern void zft_reset_position(zft_position *pos);
-extern int  zft_check_write_access(zft_position *pos);
-extern int  zft_def_idle_state(void);
-
-/*  hooks for the VFS interface 
- */
-extern int  _zft_open(unsigned int dev_minor, unsigned int access_mode);
-extern int  _zft_close(void);
-extern int  _zft_ioctl(unsigned int command, void __user *arg);
-#endif
-
-
-
diff --git a/drivers/char/ftape/zftape/zftape-eof.c b/drivers/char/ftape/zftape/zftape-eof.c
deleted file mode 100644
index dcadcaee9ac1..000000000000
--- a/drivers/char/ftape/zftape/zftape-eof.c
+++ /dev/null
@@ -1,199 +0,0 @@
-/*
- *   I use these routines just to decide when I have to fake a 
- *   volume-table to preserve compatibility to original ftape.
- */
-/*
- *      Copyright (C) 1994-1995 Bas Laarhoven.
- *      
- *      Modified for zftape 1996, 1997 Claus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- * $Source: /homes/cvs/ftape-stacked/ftape/zftape/zftape-eof.c,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:19:02 $
- *
- *      This file contains the eof mark handling code
- *      for the QIC-40/80 floppy-tape driver for Linux.
- */
-
-#include <linux/string.h>
-#include <linux/errno.h>
-
-#include <linux/zftape.h>
-
-#include "../zftape/zftape-init.h"
-#include "../zftape/zftape-rw.h"
-#include "../zftape/zftape-eof.h"
-
-/*      Global vars.
- */
-
-/* a copy of the failed sector log from the header segment.
- */
-eof_mark_union *zft_eof_map;
-
-/* number of eof marks (entries in bad sector log) on tape.
- */
-int zft_nr_eof_marks = -1;
-
-
-/*      Local vars.
- */
-
-static char linux_tape_label[] = "Linux raw format V";
-enum { 
-        min_fmt_version = 1, max_fmt_version = 2 
-};
-static unsigned ftape_fmt_version = 0;
-
-
-/* Ftape (mis)uses the bad sector log to record end-of-file marks.
- * Initially (when the tape is erased) all entries in the bad sector
- * log are added to the tape's bad sector map. The bad sector log then
- * is cleared.
- *
- * The bad sector log normally contains entries of the form: 
- * even 16-bit word: segment number of bad sector 
- * odd 16-bit word: encoded date
- * There can be a total of 448 entries (1792 bytes).
- *
- * My guess is that no program is using this bad sector log (the *
- * format seems useless as there is no indication of the bad sector
- * itself, only the segment) However, if any program does use the bad
- * sector log, the format used by ftape will let the program think
- * there are some bad sectors and no harm is done.
- *  
- * The eof mark entries that ftape stores in the bad sector log: even
- * 16-bit word: segment number of eof mark odd 16-bit word: sector
- * number of eof mark [1..32]
- *  
- * The zft_eof_map as maintained is a sorted list of eof mark entries.
- *
- *
- * The tape name field in the header segments is used to store a linux
- * tape identification string and a version number.  This way the tape
- * can be recognized as a Linux raw format tape when using tools under
- * other OS's.
- *
- * 'Wide' QIC tapes (format code 4) don't have a failed sector list
- * anymore. That space is used for the (longer) bad sector map that
- * now is a variable length list too.  We now store our end-of-file
- * marker list after the bad-sector-map on tape. The list is delimited
- * by a (__u32) 0 entry.
- */
-
-int zft_ftape_validate_label(char *label)
-{
-        static char tmp_label[45];
-        int result = 0;
-        TRACE_FUN(ft_t_any);
-        
-        memcpy(tmp_label, label, FT_LABEL_SZ);
-        tmp_label[FT_LABEL_SZ] = '\0';
-        TRACE(ft_t_noise, "tape  label = `%s'", tmp_label);
-        ftape_fmt_version = 0;
-        if (memcmp(label, linux_tape_label, strlen(linux_tape_label)) == 0) {
-                int pos = strlen(linux_tape_label);
-                while (label[pos] >= '0' && label[pos] <= '9') {
-                        ftape_fmt_version *= 10;
-                        ftape_fmt_version = label[ pos++] - '0';
-                }
-                result = (ftape_fmt_version >= min_fmt_version &&
-                          ftape_fmt_version <= max_fmt_version);
-        }
-        TRACE(ft_t_noise, "format version = %d", ftape_fmt_version);
-        TRACE_EXIT result;
-}
-
-static __u8 * find_end_of_eof_list(__u8 * ptr, __u8 * limit)
-{
-        while (ptr + 3 < limit) {
-
-                if (get_unaligned((__u32*)ptr)) {
-                        ptr += sizeof(__u32);
-                } else {
-                        return ptr;
-                }
-        }
-        return NULL;
-}
-
-void zft_ftape_extract_file_marks(__u8* address)
-{
-        int i;
-        TRACE_FUN(ft_t_any);
-        
-        zft_eof_map = NULL;
-        if (ft_format_code == fmt_var || ft_format_code == fmt_big) {
-                __u8* end;
-                __u8* start = ftape_find_end_of_bsm_list(address);
-
-                zft_nr_eof_marks = 0;
-                if (start) {
-                        start += 3; /* skip end of list mark */
-                        end = find_end_of_eof_list(start, 
-                                                   address + FT_SEGMENT_SIZE);
-                        if (end && end - start <= FT_FSL_SIZE) {
-                                zft_nr_eof_marks = ((end - start) / 
-                                                    sizeof(eof_mark_union));
-                                zft_eof_map = (eof_mark_union *)start;
-                        } else {
-                                TRACE(ft_t_err,
-                                      "EOF Mark List is too long or damaged!");
-                        }
-                } else {
-                        TRACE(ft_t_err, 
-                              "Bad Sector List is too long or damaged !");
-                }
-        } else {
-                zft_eof_map = (eof_mark_union *)&address[FT_FSL];
-                zft_nr_eof_marks = GET2(address, FT_FSL_CNT);
-        }
-        TRACE(ft_t_noise, "number of file marks: %d", zft_nr_eof_marks);
-        if (ftape_fmt_version == 1) {
-                TRACE(ft_t_info, "swapping version 1 fields");
-                /* version 1 format uses swapped sector and segment
-                 * fields, correct that !  
-                 */
-                for (i = 0; i < zft_nr_eof_marks; ++i) {
-                        __u16 tmp = GET2(&zft_eof_map[i].mark.segment,0);
-                        PUT2(&zft_eof_map[i].mark.segment, 0, 
-                             GET2(&zft_eof_map[i].mark.date,0));
-                        PUT2(&zft_eof_map[i].mark.date, 0, tmp);
-                }
-        }
-        for (i = 0; i < zft_nr_eof_marks; ++i) {
-                TRACE(ft_t_noise, "eof mark: %5d/%2d",
-                        GET2(&zft_eof_map[i].mark.segment, 0), 
-                        GET2(&zft_eof_map[i].mark.date,0));
-        }
-        TRACE_EXIT;
-}
-
-void zft_clear_ftape_file_marks(void)
-{
-        TRACE_FUN(ft_t_flow);
-        /*  Clear failed sector log: remove all tape marks. We
-         *  don't use old ftape-style EOF-marks.
-         */
-        TRACE(ft_t_info, "Clearing old ftape's eof map");
-        memset(zft_eof_map, 0, zft_nr_eof_marks * sizeof(__u32));
-        zft_nr_eof_marks = 0;
-        PUT2(zft_hseg_buf, FT_FSL_CNT, 0); /* nr of eof-marks */
-        zft_header_changed = 1;
-        zft_update_label(zft_hseg_buf);
-        TRACE_EXIT;
-}
diff --git a/drivers/char/ftape/zftape/zftape-eof.h b/drivers/char/ftape/zftape/zftape-eof.h
deleted file mode 100644
index 26568c26c518..000000000000
--- a/drivers/char/ftape/zftape/zftape-eof.h
+++ /dev/null
@@ -1,52 +0,0 @@
-#ifndef _ZFTAPE_EOF_H
-#define _ZFTAPE_EOF_H
-
-/*
- * Copyright (C) 1994-1995 Bas Laarhoven.
- * adaptaed for zftape 1996, 1997 by Claus Heine
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/zftape/zftape-eof.h,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:19:03 $
- *
- *      Definitions and declarations for the end of file markers
- *      for the QIC-40/80 floppy-tape driver for Linux.
- */
-
-#include <linux/ftape-header-segment.h>
-#include "../zftape/zftape-buffers.h"
-/*  failed sector log size (only used if format code != 4).
- */
-
-typedef union {
-        ft_fsl_entry mark;
-        __u32 entry;
-} eof_mark_union;
- 
-/*      ftape-eof.c defined global vars.
- */
-extern int zft_nr_eof_marks;
-extern eof_mark_union *zft_eof_map;
-
-/*      ftape-eof.c defined global functions.
- */
-extern void zft_ftape_extract_file_marks(__u8* address);
-extern int  zft_ftape_validate_label(char* label);
-extern void zft_clear_ftape_file_marks(void);
-
-#endif
diff --git a/drivers/char/ftape/zftape/zftape-init.c b/drivers/char/ftape/zftape/zftape-init.c
deleted file mode 100644
index 164a1aa77a2f..000000000000
--- a/drivers/char/ftape/zftape/zftape-init.c
+++ /dev/null
@@ -1,377 +0,0 @@
-/*
- *      Copyright (C) 1996, 1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- *      This file contains the code that registers the zftape frontend 
- *      to the ftape floppy tape driver for Linux
- */
-
-#include <linux/module.h>
-#include <linux/errno.h>
-#include <linux/fs.h>
-#include <linux/kernel.h>
-#include <linux/signal.h>
-#include <linux/major.h>
-#include <linux/slab.h>
-#ifdef CONFIG_KMOD
-#include <linux/kmod.h>
-#endif
-#include <linux/fcntl.h>
-#include <linux/smp_lock.h>
-
-#include <linux/zftape.h>
-#include <linux/init.h>
-#include <linux/device.h>
-
-#include "../zftape/zftape-init.h"
-#include "../zftape/zftape-read.h"
-#include "../zftape/zftape-write.h"
-#include "../zftape/zftape-ctl.h"
-#include "../zftape/zftape-buffers.h"
-
-MODULE_AUTHOR("(c) 1996, 1997 Claus-Justus Heine "
-              "(claus@momo.math.rwth-aachen.de)");
-MODULE_DESCRIPTION(ZFTAPE_VERSION " - "
-                   "VFS interface for the Linux floppy tape driver. "
-                   "Support for QIC-113 compatible volume table "
-                   "and builtin compression (lzrw3 algorithm)");
-MODULE_SUPPORTED_DEVICE("char-major-27");
-MODULE_LICENSE("GPL");
-
-/*      Global vars.
- */
-struct zft_cmpr_ops *zft_cmpr_ops = NULL;
-const ftape_info *zft_status;
-
-/*      Local vars.
- */
-static unsigned long busy_flag;
-
-static sigset_t orig_sigmask;
-
-/*  the interface to the kernel vfs layer
- */
-
-/* Note about llseek():
- *
- * st.c and tpqic.c update fp->f_pos but don't implment llseek() and
- * initialize the llseek component of the file_ops struct with NULL.
- * This means that the user will get the default seek, but the tape
- * device will not respect the new position, but happily read from the
- * old position. Think a zftape specific llseek() function would be
- * better, returning -ESPIPE. TODO.
- */
-
-static int  zft_open (struct inode *ino, struct file *filep);
-static int zft_close(struct inode *ino, struct file *filep);
-static int  zft_ioctl(struct inode *ino, struct file *filep,
-                      unsigned int command, unsigned long arg);
-static int  zft_mmap(struct file *filep, struct vm_area_struct *vma);
-static ssize_t zft_read (struct file *fp, char __user *buff,
-                         size_t req_len, loff_t *ppos);
-static ssize_t zft_write(struct file *fp, const char __user *buff,
-                         size_t req_len, loff_t *ppos);
-
-static const struct file_operations zft_cdev =
-{
-        .owner          = THIS_MODULE,
-        .read           = zft_read,
-        .write          = zft_write,
-        .ioctl          = zft_ioctl,
-        .mmap           = zft_mmap,
-        .open           = zft_open,
-        .release        = zft_close,
-};
-
-static struct class *zft_class;
-
-/*      Open floppy tape device
- */
-static int zft_open(struct inode *ino, struct file *filep)
-{
-        int result;
-        TRACE_FUN(ft_t_flow);
-
-        nonseekable_open(ino, filep);
-        TRACE(ft_t_flow, "called for minor %d", iminor(ino));
-        if ( test_and_set_bit(0,&busy_flag) ) {
-                TRACE_ABORT(-EBUSY, ft_t_warn, "failed: already busy");
-        }
-        if ((iminor(ino) & ~(ZFT_MINOR_OP_MASK | FTAPE_NO_REWIND))
-             > 
-            FTAPE_SEL_D) {
-                clear_bit(0,&busy_flag);
-                TRACE_ABORT(-ENXIO, ft_t_err, "failed: invalid unit nr");
-        }
-        orig_sigmask = current->blocked;
-        sigfillset(&current->blocked);
-        result = _zft_open(iminor(ino), filep->f_flags & O_ACCMODE);
-        if (result < 0) {
-                current->blocked = orig_sigmask; /* restore mask */
-                clear_bit(0,&busy_flag);
-                TRACE_ABORT(result, ft_t_err, "_ftape_open failed");
-        } else {
-                /* Mask signals that will disturb proper operation of the
-                 * program that is calling.
-                 */
-                current->blocked = orig_sigmask;
-                sigaddsetmask (&current->blocked, _DO_BLOCK);
-                TRACE_EXIT 0;
-        }
-}
-
-/*      Close floppy tape device
- */
-static int zft_close(struct inode *ino, struct file *filep)
-{
-        int result;
-        TRACE_FUN(ft_t_flow);
-
-        if ( !test_bit(0,&busy_flag) || iminor(ino) != zft_unit) {
-                TRACE(ft_t_err, "failed: not busy or wrong unit");
-                TRACE_EXIT 0;
-        }
-        sigfillset(&current->blocked);
-        result = _zft_close();
-        if (result < 0) {
-                TRACE(ft_t_err, "_zft_close failed");
-        }
-        current->blocked = orig_sigmask; /* restore before open state */
-        clear_bit(0,&busy_flag);
-        TRACE_EXIT 0;
-}
-
-/*      Ioctl for floppy tape device
- */
-static int zft_ioctl(struct inode *ino, struct file *filep,
-                     unsigned int command, unsigned long arg)
-{
-        int result = -EIO;
-        sigset_t old_sigmask;
-        TRACE_FUN(ft_t_flow);
-
-        if ( !test_bit(0,&busy_flag) || iminor(ino) != zft_unit || ft_failure) {
-                TRACE_ABORT(-EIO, ft_t_err,
-                            "failed: not busy, failure or wrong unit");
-        }
-        old_sigmask = current->blocked; /* save mask */
-        sigfillset(&current->blocked);
-        /* This will work as long as sizeof(void *) == sizeof(long) */
-        result = _zft_ioctl(command, (void __user *) arg);
-        current->blocked = old_sigmask; /* restore mask */
-        TRACE_EXIT result;
-}
-
-/*      Ioctl for floppy tape device
- */
-static int  zft_mmap(struct file *filep, struct vm_area_struct *vma)
-{
-        int result = -EIO;
-        sigset_t old_sigmask;
-        TRACE_FUN(ft_t_flow);
-
-        if ( !test_bit(0,&busy_flag) || 
-            iminor(filep->f_dentry->d_inode) != zft_unit || 
-            ft_failure)
-        {
-                TRACE_ABORT(-EIO, ft_t_err,
-                            "failed: not busy, failure or wrong unit");
-        }
-        old_sigmask = current->blocked; /* save mask */
-        sigfillset(&current->blocked);
-        if ((result = ftape_mmap(vma)) >= 0) {
-#ifndef MSYNC_BUG_WAS_FIXED
-                static struct vm_operations_struct dummy = { NULL, };
-                vma->vm_ops = &dummy;
-#endif
-        }
-        current->blocked = old_sigmask; /* restore mask */
-        TRACE_EXIT result;
-}
-
-/*      Read from floppy tape device
- */
-static ssize_t zft_read(struct file *fp, char __user *buff,
-                        size_t req_len, loff_t *ppos)
-{
-        int result = -EIO;
-        sigset_t old_sigmask;
-        struct inode *ino = fp->f_dentry->d_inode;
-        TRACE_FUN(ft_t_flow);
-
-        TRACE(ft_t_data_flow, "called with count: %ld", (unsigned long)req_len);
-        if (!test_bit(0,&busy_flag)  || iminor(ino) != zft_unit || ft_failure) {
-                TRACE_ABORT(-EIO, ft_t_err,
-                            "failed: not busy, failure or wrong unit");
-        }
-        old_sigmask = current->blocked; /* save mask */
-        sigfillset(&current->blocked);
-        result = _zft_read(buff, req_len);
-        current->blocked = old_sigmask; /* restore mask */
-        TRACE(ft_t_data_flow, "return with count: %d", result);
-        TRACE_EXIT result;
-}
-
-/*      Write to tape device
- */
-static ssize_t zft_write(struct file *fp, const char __user *buff,
-                         size_t req_len, loff_t *ppos)
-{
-        int result = -EIO;
-        sigset_t old_sigmask;
-        struct inode *ino = fp->f_dentry->d_inode;
-        TRACE_FUN(ft_t_flow);
-
-        TRACE(ft_t_flow, "called with count: %ld", (unsigned long)req_len);
-        if (!test_bit(0,&busy_flag) || iminor(ino) != zft_unit || ft_failure) {
-                TRACE_ABORT(-EIO, ft_t_err,
-                            "failed: not busy, failure or wrong unit");
-        }
-        old_sigmask = current->blocked; /* save mask */
-        sigfillset(&current->blocked);
-        result = _zft_write(buff, req_len);
-        current->blocked = old_sigmask; /* restore mask */
-        TRACE(ft_t_data_flow, "return with count: %d", result);
-        TRACE_EXIT result;
-}
-
-/*                    END OF VFS INTERFACE 
- *          
- *****************************************************************************/
-
-/*  driver/module initialization
- */
-
-/*  the compression module has to call this function to hook into the zftape 
- *  code
- */
-int zft_cmpr_register(struct zft_cmpr_ops *new_ops)
-{
-        TRACE_FUN(ft_t_flow);
-        
-        if (zft_cmpr_ops != NULL) {
-                TRACE_EXIT -EBUSY;
-        } else {
-                zft_cmpr_ops = new_ops;
-                TRACE_EXIT 0;
-        }
-}
-
-/*  lock the zft-compressor() module.
- */
-int zft_cmpr_lock(int try_to_load)
-{
-        if (zft_cmpr_ops == NULL) {
-#ifdef CONFIG_KMOD
-                if (try_to_load) {
-                        request_module("zft-compressor");
-                        if (zft_cmpr_ops == NULL) {
-                                return -ENOSYS;
-                        }
-                } else {
-                        return -ENOSYS;
-                }
-#else
-                return -ENOSYS;
-#endif
-        }
-        (*zft_cmpr_ops->lock)();
-        return 0;
-}
-
-#ifdef CONFIG_ZFT_COMPRESSOR
-extern int zft_compressor_init(void);
-#endif
-
-/*  Called by modules package when installing the driver or by kernel
- *  during the initialization phase
- */
-int __init zft_init(void)
-{
-        int i;
-        TRACE_FUN(ft_t_flow);
-
-#ifdef MODULE
-        printk(KERN_INFO ZFTAPE_VERSION "\n");
-        if (TRACE_LEVEL >= ft_t_info) {
-                printk(
-KERN_INFO
-"(c) 1996, 1997 Claus-Justus Heine (claus@momo.math.rwth-aachen.de)\n"
-KERN_INFO
-"vfs interface for ftape floppy tape driver.\n"
-KERN_INFO
-"Support for QIC-113 compatible volume table, dynamic memory allocation\n"
-KERN_INFO
-"and builtin compression (lzrw3 algorithm).\n");
-        }
-#else /* !MODULE */
-        /* print a short no-nonsense boot message */
-        printk(KERN_INFO ZFTAPE_VERSION "\n");
-#endif /* MODULE */
-        TRACE(ft_t_info, "zft_init @ 0x%p", zft_init);
-        TRACE(ft_t_info,
-              "installing zftape VFS interface for ftape driver ...");
-        TRACE_CATCH(register_chrdev(QIC117_TAPE_MAJOR, "zft", &zft_cdev),);
-
-        zft_class = class_create(THIS_MODULE, "zft");
-        for (i = 0; i < 4; i++) {
-                class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i), NULL, "qft%i", i);
-                class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i + 4), NULL, "nqft%i", i);
-                class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i + 16), NULL, "zqft%i", i);
-                class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i + 20), NULL, "nzqft%i", i);
-                class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i + 32), NULL, "rawqft%i", i);
-                class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i + 36), NULL, "nrawrawqft%i", i);
-        }
-
-#ifdef CONFIG_ZFT_COMPRESSOR
-        (void)zft_compressor_init();
-#endif
-        zft_status = ftape_get_status(); /*  fetch global data of ftape 
-                                          *  hardware driver 
-                                          */
-        TRACE_EXIT 0;
-}
-
-
-/* Called by modules package when removing the driver 
- */
-static void zft_exit(void)
-{
-        int i;
-        TRACE_FUN(ft_t_flow);
-
-        if (unregister_chrdev(QIC117_TAPE_MAJOR, "zft") != 0) {
-                TRACE(ft_t_warn, "failed");
-        } else {
-                TRACE(ft_t_info, "successful");
-        }
-        for (i = 0; i < 4; i++) {
-                class_device_destroy(zft_class, MKDEV(QIC117_TAPE_MAJOR, i));
-                class_device_destroy(zft_class, MKDEV(QIC117_TAPE_MAJOR, i + 4));
-                class_device_destroy(zft_class, MKDEV(QIC117_TAPE_MAJOR, i + 16));
-                class_device_destroy(zft_class, MKDEV(QIC117_TAPE_MAJOR, i + 20));
-                class_device_destroy(zft_class, MKDEV(QIC117_TAPE_MAJOR, i + 32));
-                class_device_destroy(zft_class, MKDEV(QIC117_TAPE_MAJOR, i + 36));
-        }
-        class_destroy(zft_class);
-        zft_uninit_mem(); /* release remaining memory, if any */
-        printk(KERN_INFO "zftape successfully unloaded.\n");
-        TRACE_EXIT;
-}
-
-module_init(zft_init);
-module_exit(zft_exit);
diff --git a/drivers/char/ftape/zftape/zftape-init.h b/drivers/char/ftape/zftape/zftape-init.h
deleted file mode 100644
index 937e5d48c20e..000000000000
--- a/drivers/char/ftape/zftape/zftape-init.h
+++ /dev/null
@@ -1,77 +0,0 @@
-#ifndef _ZFTAPE_INIT_H
-#define _ZFTAPE_INIT_H
-
-/*
- * Copyright (C) 1996, 1997 Claus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/zftape/zftape-init.h,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:19:05 $
- *
- * This file contains definitions and macro for the vfs 
- * interface defined by zftape
- *
- */
-
-#include <linux/ftape-header-segment.h>
-
-#include "../lowlevel/ftape-tracing.h"
-#include "../lowlevel/ftape-ctl.h"
-#include "../lowlevel/ftape-read.h"
-#include "../lowlevel/ftape-write.h"
-#include "../lowlevel/ftape-bsm.h"
-#include "../lowlevel/ftape-io.h"
-#include "../lowlevel/ftape-buffer.h"
-#include "../lowlevel/ftape-format.h"
-
-#include "../zftape/zftape-rw.h"
-
-#ifdef MODULE
-#define ftape_status (*zft_status)
-#endif
-
-extern const  ftape_info *zft_status; /* needed for zftape-vtbl.h */
-
-#include "../zftape/zftape-vtbl.h"
-
-struct zft_cmpr_ops {
-        int (*write)(int *write_cnt,
-                     __u8 *dst_buf, const int seg_sz,
-                     const __u8 __user *src_buf, const int req_len, 
-                     const zft_position *pos, const zft_volinfo *volume);
-        int (*read)(int *read_cnt,
-                    __u8 __user *dst_buf, const int req_len,
-                    const __u8 *src_buf, const int seg_sz,
-                    const zft_position *pos, const zft_volinfo *volume);
-        int (*seek)(unsigned int new_block_pos,
-                    zft_position *pos, const zft_volinfo *volume,
-                    __u8 *buffer);
-        void (*lock)   (void);
-        void (*reset)  (void);
-        void (*cleanup)(void);
-};
-
-extern struct zft_cmpr_ops *zft_cmpr_ops;
-/* zftape-init.c defined global functions.
- */
-extern int                  zft_cmpr_register(struct zft_cmpr_ops *new_ops);
-extern int                  zft_cmpr_lock(int try_to_load);
-
-#endif
-
-
diff --git a/drivers/char/ftape/zftape/zftape-read.c b/drivers/char/ftape/zftape/zftape-read.c
deleted file mode 100644
index 214bf03dce68..000000000000
--- a/drivers/char/ftape/zftape/zftape-read.c
+++ /dev/null
@@ -1,377 +0,0 @@
-/*
- *      Copyright (C) 1996, 1997 Claus-Justus Heine
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/zftape/zftape-read.c,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:19:06 $
- *
- *      This file contains the high level reading code
- *      for the QIC-117 floppy-tape driver for Linux.
- */
-
-#include <linux/errno.h>
-#include <linux/mm.h>
-
-#include <linux/zftape.h>
-
-#include <asm/uaccess.h>
-
-#include "../zftape/zftape-init.h"
-#include "../zftape/zftape-eof.h"
-#include "../zftape/zftape-ctl.h"
-#include "../zftape/zftape-write.h"
-#include "../zftape/zftape-read.h"
-#include "../zftape/zftape-rw.h"
-#include "../zftape/zftape-vtbl.h"
-
-/*      Global vars.
- */
-int zft_just_before_eof;
-
-/*      Local vars.
- */
-static int buf_len_rd;
-
-void zft_zap_read_buffers(void)
-{
-        buf_len_rd = 0;
-}
-
-int zft_read_header_segments(void)      
-{
-        TRACE_FUN(ft_t_flow);
-
-        zft_header_read = 0;
-        TRACE_CATCH(zft_vmalloc_once(&zft_hseg_buf, FT_SEGMENT_SIZE),);
-        TRACE_CATCH(ftape_read_header_segment(zft_hseg_buf),);
-        TRACE(ft_t_info, "Segments written since first format: %d",
-              (int)GET4(zft_hseg_buf, FT_SEG_CNT));
-        zft_qic113 = (ft_format_code != fmt_normal &&
-                      ft_format_code != fmt_1100ft &&
-                      ft_format_code != fmt_425ft);
-        TRACE(ft_t_info, "ft_first_data_segment: %d, ft_last_data_segment: %d", 
-              ft_first_data_segment, ft_last_data_segment);
-        zft_capacity = zft_get_capacity();
-        zft_old_ftape = zft_ftape_validate_label(&zft_hseg_buf[FT_LABEL]);
-        if (zft_old_ftape) {
-                TRACE(ft_t_info, 
-"Found old ftaped tape, emulating eof marks, entering read-only mode");
-                zft_ftape_extract_file_marks(zft_hseg_buf);
-                TRACE_CATCH(zft_fake_volume_headers(zft_eof_map, 
-                                                    zft_nr_eof_marks),);
-        } else {
-                /* the specs say that the volume table must be
-                 * initialized with zeroes during formatting, so it
-                 * MUST be readable, i.e. contain vaid ECC
-                 * information.  
-                 */
-                TRACE_CATCH(ftape_read_segment(ft_first_data_segment, 
-                                               zft_deblock_buf, 
-                                               FT_RD_SINGLE),);
-                TRACE_CATCH(zft_extract_volume_headers(zft_deblock_buf),);
-        }
-        zft_header_read = 1;
-        zft_set_flags(zft_unit);
-        zft_reset_position(&zft_pos);
-        TRACE_EXIT 0;
-}
-
-int zft_fetch_segment_fraction(const unsigned int segment, void *buffer,
-                               const ft_read_mode_t read_mode,
-                               const unsigned int start,
-                               const unsigned int size)
-{
-        int seg_sz;
-        TRACE_FUN(ft_t_flow);
-
-        if (segment == zft_deblock_segment) {
-                TRACE(ft_t_data_flow,
-                      "re-using segment %d already in deblock buffer",
-                      segment);
-                seg_sz = zft_get_seg_sz(segment);
-                if (start > seg_sz) {
-                        TRACE_ABORT(-EINVAL, ft_t_bug,
-                                    "trying to read beyond end of segment:\n"
-                                    KERN_INFO "seg_sz : %d\n"
-                                    KERN_INFO "start  : %d\n"
-                                    KERN_INFO "segment: %d",
-                                    seg_sz, start, segment);
-                }
-                if ((start + size) > seg_sz) {
-                        TRACE_EXIT seg_sz - start;
-                }
-                TRACE_EXIT size;
-        }
-        seg_sz = ftape_read_segment_fraction(segment, buffer, read_mode,
-                                             start, size);
-        TRACE(ft_t_data_flow, "segment %d, result %d", segment, seg_sz);
-        if ((int)seg_sz >= 0 && start == 0 && size == FT_SEGMENT_SIZE) {
-                /*  this implicitly assumes that we are always called with
-                 *  buffer == zft_deblock_buf 
-                 */
-                zft_deblock_segment = segment;
-        } else {
-                zft_deblock_segment = -1;
-        }
-        TRACE_EXIT seg_sz;
-}
-
-/*
- * out:
- *
- * int *read_cnt: the number of bytes we removed from the
- *                zft_deblock_buf (result)
- *
- * int *to_do   : the remaining size of the read-request. Is changed.
- *
- * in:
- *
- * char *buff      : buff is the address of the upper part of the user
- *                   buffer, that hasn't been filled with data yet.
- * int buf_pos_read: copy of buf_pos_rd
- * int buf_len_read: copy of buf_len_rd
- * char *zft_deblock_buf: ftape_zft_deblock_buf
- *
- * returns the amount of data actually copied to the user-buffer
- *
- * to_do MUST NOT SHRINK except to indicate an EOT. In this case to_do
- * has to be set to 0. We cannot return -ENOSPC, because we return the
- * amount of data actually * copied to the user-buffer
- */
-static int zft_simple_read (int *read_cnt, 
-                            __u8  __user *dst_buf, 
-                            const int to_do, 
-                            const __u8 *src_buf, 
-                            const int seg_sz, 
-                            const zft_position *pos,
-                            const zft_volinfo *volume)
-{
-        TRACE_FUN(ft_t_flow);
-
-        if (seg_sz - pos->seg_byte_pos < to_do) {
-                *read_cnt = seg_sz - pos->seg_byte_pos;
-        } else {
-                *read_cnt = to_do;
-        }
-        if (copy_to_user(dst_buf, 
-                         src_buf + pos->seg_byte_pos, *read_cnt) != 0) {
-                TRACE_EXIT -EFAULT;
-        }
-        TRACE(ft_t_noise, "nr bytes just read: %d", *read_cnt);
-        TRACE_EXIT *read_cnt;
-}
-
-/* req_len: gets clipped due to EOT of EOF.
- * req_clipped: is a flag indicating whether req_len was clipped or not
- * volume: contains information on current volume (blk_sz etc.)
- */
-static int check_read_access(int *req_len, 
-                             const zft_volinfo **volume,
-                             int *req_clipped, 
-                             const zft_position *pos)
-{
-        static __s64 remaining;
-        static int eod;
-        TRACE_FUN(ft_t_flow);
-        
-        if (zft_io_state != zft_reading) {
-                if (zft_offline) { /* offline includes no_tape */
-                        TRACE_ABORT(-ENXIO, ft_t_warn,
-                                    "tape is offline or no cartridge");
-                }
-                if (!ft_formatted) {
-                        TRACE_ABORT(-EACCES,
-                                    ft_t_warn, "tape is not formatted");
-                }
-                /*  now enter defined state, read header segment if not
-                 *  already done and flush write buffers
-                 */
-                TRACE_CATCH(zft_def_idle_state(),);
-                zft_io_state = zft_reading;
-                if (zft_tape_at_eod(pos)) {
-                        eod = 1;
-                        TRACE_EXIT 1;
-                }
-                eod = 0;
-                *volume = zft_find_volume(pos->seg_pos);
-                /* get the space left until EOF */
-                remaining = zft_check_for_eof(*volume, pos);
-                buf_len_rd = 0;
-                TRACE(ft_t_noise, "remaining: " LL_X ", vol_no: %d",
-                      LL(remaining), (*volume)->count);
-        } else if (zft_tape_at_eod(pos)) {
-                if (++eod > 2) {
-                        TRACE_EXIT -EIO; /* st.c also returns -EIO */
-                } else {
-                        TRACE_EXIT 1;
-                }
-        }
-        if ((*req_len % (*volume)->blk_sz) != 0) {
-                /*  this message is informational only. The user gets the
-                 *  proper return value
-                 */
-                TRACE_ABORT(-EINVAL, ft_t_info,
-                            "req_len %d not a multiple of block size %d",
-                            *req_len, (*volume)->blk_sz);
-        }
-        /* As GNU tar doesn't accept partial read counts when the
-         * multiple volume flag is set, we make sure to return the
-         * requested amount of data. Except, of course, at the end of
-         * the tape or file mark.  
-         */
-        remaining -= *req_len;
-        if (remaining <= 0) {
-                TRACE(ft_t_noise, 
-                      "clipped request from %d to %d.", 
-                      *req_len, (int)(*req_len + remaining));
-                *req_len += remaining;
-                *req_clipped = 1;
-        } else {
-                *req_clipped = 0;
-        }
-        TRACE_EXIT 0;
-}
-
-/* this_segs_size: the current segment's size.
- * buff: the USER-SPACE buffer provided by the calling function.
- * req_len: how much data should be read at most.
- * volume: contains information on current volume (blk_sz etc.)
- */  
-static int empty_deblock_buf(__u8 __user *usr_buf, const int req_len,
-                             const __u8 *src_buf, const int seg_sz,
-                             zft_position *pos,
-                             const zft_volinfo *volume)
-{
-        int cnt;
-        int result = 0;
-        TRACE_FUN(ft_t_flow);
-
-        TRACE(ft_t_data_flow, "this_segs_size: %d", seg_sz);
-        if (zft_use_compression && volume->use_compression) {
-                TRACE_CATCH(zft_cmpr_lock(1 /* try to load */),);
-                TRACE_CATCH(result= (*zft_cmpr_ops->read)(&cnt,
-                                                          usr_buf, req_len,
-                                                          src_buf, seg_sz,
-                                                          pos, volume),);
-        } else {                                  
-                TRACE_CATCH(result= zft_simple_read (&cnt,
-                                                     usr_buf, req_len,
-                                                     src_buf, seg_sz,
-                                                     pos, volume),);
-        }
-        pos->volume_pos   += result;
-        pos->tape_pos     += cnt;
-        pos->seg_byte_pos += cnt;
-        buf_len_rd        -= cnt; /* remaining bytes in buffer */
-        TRACE(ft_t_data_flow, "buf_len_rd: %d, cnt: %d", buf_len_rd, cnt);
-        if(pos->seg_byte_pos >= seg_sz) {
-                pos->seg_pos++;
-                pos->seg_byte_pos = 0;
-        }
-        TRACE(ft_t_data_flow, "bytes moved out of deblock-buffer: %d", cnt);
-        TRACE_EXIT result;
-}
-
-
-/* note: we store the segment id of the segment that is inside the
- * deblock buffer. This spares a lot of ftape_read_segment()s when we
- * use small block-sizes. The block-size may be 1kb (SECTOR_SIZE). In
- * this case a MTFSR 28 maybe still inside the same segment.
- */
-int _zft_read(char __user *buff, int req_len)
-{
-        int req_clipped;
-        int result     = 0;
-        int bytes_read = 0;
-        static unsigned int seg_sz = 0;
-        static const zft_volinfo *volume = NULL;
-        TRACE_FUN(ft_t_flow);
-        
-        zft_resid = req_len;
-        result = check_read_access(&req_len, &volume,
-                                   &req_clipped, &zft_pos);
-        switch(result) {
-        case 0: 
-                break; /* nothing special */
-        case 1: 
-                TRACE(ft_t_noise, "EOD reached");
-                TRACE_EXIT 0;   /* EOD */
-        default:
-                TRACE_ABORT(result, ft_t_noise,
-                            "check_read_access() failed with result %d",
-                            result);
-                TRACE_EXIT result;
-        }
-        while (req_len > 0) { 
-                /*  Allow escape from this loop on signal !
-                 */
-                FT_SIGNAL_EXIT(_DONT_BLOCK);
-                /* buf_len_rd == 0 means that we need to read a new
-                 * segment.
-                 */
-                if (buf_len_rd == 0) {
-                        while((result = zft_fetch_segment(zft_pos.seg_pos,
-                                                          zft_deblock_buf,
-                                                          FT_RD_AHEAD)) == 0) {
-                                zft_pos.seg_pos ++;
-                                zft_pos.seg_byte_pos = 0;
-                        }
-                        if (result < 0) {
-                                zft_resid -= bytes_read;
-                                TRACE_ABORT(result, ft_t_noise,
-                                            "zft_fetch_segment(): %d",
-                                            result);
-                        }
-                        seg_sz = result;
-                        buf_len_rd = seg_sz - zft_pos.seg_byte_pos;
-                }
-                TRACE_CATCH(result = empty_deblock_buf(buff, 
-                                                       req_len,
-                                                       zft_deblock_buf, 
-                                                       seg_sz, 
-                                                       &zft_pos,
-                                                       volume),
-                            zft_resid -= bytes_read);
-                TRACE(ft_t_data_flow, "bytes just read: %d", result);
-                bytes_read += result; /* what we got so far       */
-                buff       += result; /* index in user-buffer     */
-                req_len    -= result; /* what's left from req_len */
-        } /* while (req_len  > 0) */
-        if (req_clipped) {
-                TRACE(ft_t_data_flow,
-                      "maybe partial count because of eof mark");
-                if (zft_just_before_eof && bytes_read == 0) {
-                        /* req_len was > 0, but user didn't get
-                         * anything the user has read in the eof-mark 
-                         */
-                        zft_move_past_eof(&zft_pos);
-                        ftape_abort_operation();
-                } else {
-                        /* don't skip to the next file before the user
-                         * tried to read a second time past EOF Just
-                         * mark that we are at EOF and maybe decrement
-                         * zft_seg_pos to stay in the same volume;
-                         */
-                        zft_just_before_eof = 1;
-                        zft_position_before_eof(&zft_pos, volume);
-                        TRACE(ft_t_noise, "just before eof");
-                }
-        }
-        zft_resid -= result; /* for MTSTATUS       */
-        TRACE_EXIT bytes_read;
-}
diff --git a/drivers/char/ftape/zftape/zftape-read.h b/drivers/char/ftape/zftape/zftape-read.h
deleted file mode 100644
index 42941de0c23a..000000000000
--- a/drivers/char/ftape/zftape/zftape-read.h
+++ /dev/null
@@ -1,53 +0,0 @@
-#ifndef _ZFTAPE_READ_H
-#define _ZFTAPE_READ_H
-
-/*
- * Copyright (C) 1996, 1997 Claus-Justus Heine
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/zftape/zftape-read.h,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:19:07 $
- *
- *      This file contains the definitions for the read functions
- *      for the zftape driver for Linux.
- *
- */
-
-#include "../lowlevel/ftape-read.h"
-
-/*      ftape-read.c defined global vars.
- */
-extern int zft_just_before_eof;
-        
-/*      ftape-read.c defined global functions.
- */
-extern void zft_zap_read_buffers(void);
-extern int  zft_read_header_segments(void);
-extern int  zft_fetch_segment_fraction(const unsigned int segment,
-                                       void *buffer,
-                                       const ft_read_mode_t read_mode,
-                                       const unsigned int start,
-                                       const unsigned int size);
-#define zft_fetch_segment(segment, address, read_mode)          \
-        zft_fetch_segment_fraction(segment, address, read_mode, \
-                                   0, FT_SEGMENT_SIZE)
-/*   hook for the VFS interface
- */
-extern int  _zft_read(char __user *buff, int req_len);
-
-#endif /* _ZFTAPE_READ_H */
diff --git a/drivers/char/ftape/zftape/zftape-rw.c b/drivers/char/ftape/zftape/zftape-rw.c
deleted file mode 100644
index a61ef50f3dfc..000000000000
--- a/drivers/char/ftape/zftape/zftape-rw.c
+++ /dev/null
@@ -1,376 +0,0 @@
-/*
- *      Copyright (C) 1996, 1997 Claus-Justus Heine
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/zftape/zftape-rw.c,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:19:08 $
- *
- *      This file contains some common code for the r/w code for
- *      zftape.
- */
-
-#include <linux/config.h> /* for CONFIG_ZFT_DFLT_BLK_SZ */
-#include <linux/errno.h>
-#include <linux/mm.h>
-
-#include <linux/zftape.h>
-#include "../zftape/zftape-init.h"
-#include "../zftape/zftape-eof.h"
-#include "../zftape/zftape-ctl.h"
-#include "../zftape/zftape-write.h"
-#include "../zftape/zftape-read.h"
-#include "../zftape/zftape-rw.h"
-#include "../zftape/zftape-vtbl.h"
-
-/*      Global vars.
- */
-
-__u8 *zft_deblock_buf;
-__u8 *zft_hseg_buf;
-int zft_deblock_segment = -1;
-zft_status_enum zft_io_state = zft_idle;
-int zft_header_changed;
-int zft_qic113; /* conform to old specs. and old zftape */
-int zft_use_compression;
-zft_position zft_pos = {
-        -1, /* seg_pos */
-        0,  /* seg_byte_pos */
-        0,  /* tape_pos */
-        0   /* volume_pos */
-};
-unsigned int zft_blk_sz = CONFIG_ZFT_DFLT_BLK_SZ;
-__s64 zft_capacity;
-
-unsigned int zft_written_segments;
-int zft_label_changed;
-
-/*      Local vars.
- */
-
-unsigned int zft_get_seg_sz(unsigned int segment)
-{
-        int size;
-        TRACE_FUN(ft_t_any);
-        
-        size = FT_SEGMENT_SIZE - 
-                count_ones(ftape_get_bad_sector_entry(segment))*FT_SECTOR_SIZE;
-        if (size > 0) {
-                TRACE_EXIT (unsigned)size; 
-        } else {
-                TRACE_EXIT 0;
-        }
-}
-
-/* ftape_set_flags(). Claus-Justus Heine, 1994/1995
- */
-void zft_set_flags(unsigned minor_unit)
-{     
-        TRACE_FUN(ft_t_flow);
-        
-        zft_use_compression = zft_qic_mode = 0;
-        switch (minor_unit & ZFT_MINOR_OP_MASK) {
-        case (ZFT_Q80_MODE | ZFT_ZIP_MODE):
-        case ZFT_ZIP_MODE:
-                zft_use_compression = 1;
-        case 0:
-        case ZFT_Q80_MODE:
-                zft_qic_mode = 1;
-                if (zft_mt_compression) { /* override the default */
-                        zft_use_compression = 1;
-                }
-                break;
-        case ZFT_RAW_MODE:
-                TRACE(ft_t_noise, "switching to raw mode");
-                break;
-        default:
-                TRACE(ft_t_warn, "Warning:\n"
-                      KERN_INFO "Wrong combination of minor device bits.\n"
-                      KERN_INFO "Switching to raw read-only mode.");
-                zft_write_protected = 1;
-                break;
-        }
-        TRACE_EXIT;
-}
-
-/* computes the segment and byte offset inside the segment
- * corresponding to tape_pos.
- *
- * tape_pos gives the offset in bytes from the beginning of the
- * ft_first_data_segment *seg_byte_pos is the offset in the current
- * segment in bytes
- *
- * Of, if this routine was called often one should cache the last data
- * pos it was called with, but actually this is only needed in
- * ftape_seek_block(), that is, almost never.
- */
-int zft_calc_seg_byte_coord(int *seg_byte_pos, __s64 tape_pos)
-{
-        int segment;
-        int seg_sz;
-        TRACE_FUN(ft_t_flow);
-        
-        if (tape_pos == 0) {
-                *seg_byte_pos = 0;
-                segment = ft_first_data_segment;
-        } else {
-                seg_sz = 0;
-                
-                for (segment = ft_first_data_segment; 
-                     ((tape_pos > 0) && (segment <= ft_last_data_segment));
-                     segment++) {
-                        seg_sz = zft_get_seg_sz(segment); 
-                        tape_pos -= seg_sz;
-                }
-                if(tape_pos >= 0) {
-                        /* the case tape_pos > != 0 means that the
-                         * argument tape_pos lies beyond the EOT.
-                         */
-                        *seg_byte_pos= 0;
-                } else { /* tape_pos < 0 */
-                        segment--;
-                        *seg_byte_pos= tape_pos + seg_sz;
-                }
-        }
-        TRACE_EXIT(segment);
-}
-
-/* ftape_calc_tape_pos().
- *
- * computes the offset in bytes from the beginning of the
- * ft_first_data_segment inverse to ftape_calc_seg_byte_coord
- *
- * We should do some caching. But how:
- *
- * Each time the header segments are read in, this routine is called
- * with ft_tracks_per_tape*segments_per_track argumnet. So this should be
- * the time to reset the cache.
- *
- * Also, it might be in the future that the bad sector map gets
- * changed.  -> reset the cache
- */
-static int seg_pos;
-static __s64 tape_pos;
-
-__s64 zft_get_capacity(void)
-{
-        seg_pos  = ft_first_data_segment;
-        tape_pos = 0;
-
-        while (seg_pos <= ft_last_data_segment) {
-                tape_pos += zft_get_seg_sz(seg_pos ++);
-        }
-        return tape_pos;
-}
-
-__s64 zft_calc_tape_pos(int segment)
-{
-        int d1, d2, d3;
-        TRACE_FUN(ft_t_any);
-        
-        if (segment > ft_last_data_segment) {
-                TRACE_EXIT zft_capacity;
-        }
-        if (segment < ft_first_data_segment) {
-                TRACE_EXIT 0;
-        }
-        d2 = segment - seg_pos;
-        if (-d2 > 10) {
-                d1 = segment - ft_first_data_segment;
-                if (-d2 > d1) {
-                        tape_pos = 0;
-                        seg_pos = ft_first_data_segment;
-                        d2 = d1;
-                }
-        }
-        if (d2 > 10) {
-                d3 = ft_last_data_segment - segment;
-                if (d2 > d3) {
-                        tape_pos = zft_capacity;
-                        seg_pos  = ft_last_data_segment + 1;
-                        d2 = -d3;
-                }
-        }               
-        if (d2 > 0) {
-                while (seg_pos < segment) {
-                        tape_pos +=  zft_get_seg_sz(seg_pos++);
-                }
-        } else {
-                while (seg_pos > segment) {
-                        tape_pos -=  zft_get_seg_sz(--seg_pos);
-                }
-        }
-        TRACE(ft_t_noise, "new cached pos: %d", seg_pos);
-
-        TRACE_EXIT tape_pos;
-}
-
-/* copy Z-label string to buffer, keeps track of the correct offset in
- * `buffer' 
- */
-void zft_update_label(__u8 *buffer)
-{ 
-        TRACE_FUN(ft_t_flow);
-        
-        if (strncmp(&buffer[FT_LABEL], ZFTAPE_LABEL, 
-                    sizeof(ZFTAPE_LABEL)-1) != 0) {
-                TRACE(ft_t_info, "updating label from \"%s\" to \"%s\"",
-                      &buffer[FT_LABEL], ZFTAPE_LABEL);
-                strcpy(&buffer[FT_LABEL], ZFTAPE_LABEL);
-                memset(&buffer[FT_LABEL] + sizeof(ZFTAPE_LABEL) - 1, ' ', 
-                       FT_LABEL_SZ - sizeof(ZFTAPE_LABEL + 1));
-                PUT4(buffer, FT_LABEL_DATE, 0);
-                zft_label_changed = zft_header_changed = 1; /* changed */
-        }
-        TRACE_EXIT;
-}
-
-int zft_verify_write_segments(unsigned int segment, 
-                              __u8 *data, size_t size,
-                              __u8 *buffer)
-{
-        int result;
-        __u8 *write_buf;
-        __u8 *src_buf;
-        int single;
-        int seg_pos;
-        int seg_sz;
-        int remaining;
-        ft_write_mode_t write_mode;
-        TRACE_FUN(ft_t_flow);
-
-        seg_pos   = segment;
-        seg_sz    = zft_get_seg_sz(seg_pos);
-        src_buf   = data;
-        single    = size <= seg_sz;
-        remaining = size;
-        do {
-                TRACE(ft_t_noise, "\n"
-                      KERN_INFO "remaining: %d\n"
-                      KERN_INFO "seg_sz   : %d\n"
-                      KERN_INFO "segment  : %d",
-                      remaining, seg_sz, seg_pos);
-                if (remaining == seg_sz) {
-                        write_buf = src_buf;
-                        write_mode = single ? FT_WR_SINGLE : FT_WR_MULTI;
-                        remaining = 0;
-                } else if (remaining > seg_sz) {
-                        write_buf = src_buf;
-                        write_mode = FT_WR_ASYNC; /* don't start tape */
-                        remaining -= seg_sz;
-                } else { /* remaining < seg_sz */
-                        write_buf = buffer;
-                        memcpy(write_buf, src_buf, remaining);
-                        memset(&write_buf[remaining],'\0',seg_sz-remaining);
-                        write_mode = single ? FT_WR_SINGLE : FT_WR_MULTI;
-                        remaining = 0;
-                }
-                if ((result = ftape_write_segment(seg_pos, 
-                                                  write_buf, 
-                                                  write_mode)) != seg_sz) {
-                        TRACE(ft_t_err, "Error: "
-                              "Couldn't write segment %d", seg_pos);
-                        TRACE_EXIT result < 0 ? result : -EIO; /* bail out */
-                }
-                zft_written_segments ++;
-                seg_sz = zft_get_seg_sz(++seg_pos);
-                src_buf += result;
-        } while (remaining > 0);
-        if (ftape_get_status()->fti_state == writing) {
-                TRACE_CATCH(ftape_loop_until_writes_done(),);
-                TRACE_CATCH(ftape_abort_operation(),);
-                zft_prevent_flush();
-        }
-        seg_pos = segment;
-        src_buf = data;
-        remaining = size;
-        do {
-                TRACE_CATCH(result = ftape_read_segment(seg_pos, buffer, 
-                                                        single ? FT_RD_SINGLE
-                                                        : FT_RD_AHEAD),);
-                if (memcmp(src_buf, buffer, 
-                           remaining > result ? result : remaining) != 0) {
-                        TRACE_ABORT(-EIO, ft_t_err,
-                                    "Failed to verify written segment %d",
-                                    seg_pos);
-                }
-                remaining -= result;
-                TRACE(ft_t_noise, "verify successful:\n"
-                      KERN_INFO "segment  : %d\n"
-                      KERN_INFO "segsize  : %d\n"
-                      KERN_INFO "remaining: %d",
-                      seg_pos, result, remaining);
-                src_buf   += seg_sz;
-                seg_pos++;
-        } while (remaining > 0);
-        TRACE_EXIT size;
-}
-
-
-/* zft_erase().  implemented compression-handling
- *
- * calculate the first data-segment when using/not using compression.
- *
- * update header-segment and compression-map-segment.
- */
-int zft_erase(void)
-{
-        int result = 0;
-        TRACE_FUN(ft_t_flow);
-        
-        if (!zft_header_read) {
-                TRACE_CATCH(zft_vmalloc_once((void **)&zft_hseg_buf,
-                                             FT_SEGMENT_SIZE),);
-                /* no need to read the vtbl and compression map */
-                TRACE_CATCH(ftape_read_header_segment(zft_hseg_buf),);
-                if ((zft_old_ftape = 
-                     zft_ftape_validate_label(&zft_hseg_buf[FT_LABEL]))) {
-                        zft_ftape_extract_file_marks(zft_hseg_buf);
-                }
-                TRACE(ft_t_noise,
-                      "ft_first_data_segment: %d, ft_last_data_segment: %d", 
-                      ft_first_data_segment, ft_last_data_segment);
-                zft_qic113 = (ft_format_code != fmt_normal &&
-                              ft_format_code != fmt_1100ft &&
-                              ft_format_code != fmt_425ft);
-        }
-        if (zft_old_ftape) {
-                zft_clear_ftape_file_marks();
-                zft_old_ftape = 0; /* no longer old ftape */
-        }
-        PUT2(zft_hseg_buf, FT_CMAP_START, 0);
-        zft_volume_table_changed = 1;
-        zft_capacity = zft_get_capacity();
-        zft_init_vtbl();
-        /* the rest must be done in ftape_update_header_segments 
-         */
-        zft_header_read = 1;
-        zft_header_changed = 1; /* force update of timestamp */
-        result = zft_update_header_segments();
-
-        ftape_abort_operation();
-
-        zft_reset_position(&zft_pos);
-        zft_set_flags (zft_unit);
-        TRACE_EXIT result;
-}
-
-unsigned int zft_get_time(void) 
-{
-        unsigned int date = FT_TIME_STAMP(2097, 11, 30, 23, 59, 59); /* fun */
-        return date;
-}
diff --git a/drivers/char/ftape/zftape/zftape-rw.h b/drivers/char/ftape/zftape/zftape-rw.h
deleted file mode 100644
index 14c07f086575..000000000000
--- a/drivers/char/ftape/zftape/zftape-rw.h
+++ /dev/null
@@ -1,102 +0,0 @@
-#ifndef _ZFTAPE_RW_H
-#define _ZFTAPE_RW_H
-
-/*
- * Copyright (C) 1996, 1997 Claus-Justus Heine.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/zftape/zftape-rw.h,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:19:09 $
- *
- *      This file contains the definitions for the read and write
- *      functions for the QIC-117 floppy-tape driver for Linux.
- *
- */
-
-#include <linux/config.h> /* for CONFIG_ZFT_DFLT_BLK_SZ */
-#include "../zftape/zftape-buffers.h"
-
-#define SEGMENTS_PER_TAPE  (ft_segments_per_track * ft_tracks_per_tape)
-
-/*  QIC-113 Rev. G says that `a maximum of 63488 raw bytes may be
- *  compressed into a single frame'.
- *  Maybe we should stick to 32kb to make it more `beautiful'
- */
-#define ZFT_MAX_BLK_SZ           (62*1024) /* bytes */
-#if !defined(CONFIG_ZFT_DFLT_BLK_SZ)
-# define CONFIG_ZFT_DFLT_BLK_SZ   (10*1024) /* bytes, default of gnu tar */
-#elif CONFIG_ZFT_DFLT_BLK_SZ == 0
-# undef  CONFIG_ZFT_DFLT_BLK_SZ
-# define CONFIG_ZFT_DFLT_BLK_SZ 1
-#elif (CONFIG_ZFT_DFLT_BLK_SZ % 1024) != 0
-# error CONFIG_ZFT_DFLT_BLK_SZ must be 1 or a multiple of 1024
-#endif
-/* The *optional* compression routines need some overhead per tape
- *  block for their purposes. Instead of asking the actual compression
- *  implementation how much it needs, we restrict this overhead to be
- *  maximal of ZFT_CMPT_OVERHEAD size. We need this for EOT
- *  conditions. The tape is assumed to be logical at EOT when the
- *  distance from the physical EOT is less than 
- *  one tape block + ZFT_CMPR_OVERHEAD 
- */
-#define ZFT_CMPR_OVERHEAD 16        /* bytes */
-
-typedef enum
-{ 
-        zft_idle = 0,
-        zft_reading,
-        zft_writing,
-} zft_status_enum;
-
-typedef struct               /*  all values measured in bytes */
-{
-        int   seg_pos;       /*  segment currently positioned at */
-        int   seg_byte_pos;  /*  offset in current segment */ 
-        __s64 tape_pos;      /*  real offset from BOT */
-        __s64 volume_pos;    /*  pos. in uncompressed data stream in
-                              *  current volume 
-                              */
-} zft_position; 
-
-extern zft_position zft_pos;
-extern __u8 *zft_deblock_buf;
-extern __u8 *zft_hseg_buf;
-extern int zft_deblock_segment;
-extern zft_status_enum zft_io_state;
-extern int zft_header_changed;
-extern int zft_qic113; /* conform to old specs. and old zftape */
-extern int zft_use_compression;
-extern unsigned int zft_blk_sz;
-extern __s64 zft_capacity;
-extern unsigned int zft_written_segments;
-extern int zft_label_changed;
-
-/*  zftape-rw.c exported functions
- */
-extern unsigned int zft_get_seg_sz(unsigned int segment);
-extern void  zft_set_flags(unsigned int minor_unit);
-extern int   zft_calc_seg_byte_coord(int *seg_byte_pos, __s64 tape_pos);
-extern __s64 zft_calc_tape_pos(int segment);
-extern __s64 zft_get_capacity(void);
-extern void  zft_update_label(__u8 *buffer);
-extern int   zft_erase(void);
-extern int   zft_verify_write_segments(unsigned int segment, 
-                                       __u8 *data, size_t size, __u8 *buffer);
-extern unsigned int zft_get_time(void);
-#endif /* _ZFTAPE_RW_H */
-
diff --git a/drivers/char/ftape/zftape/zftape-vtbl.c b/drivers/char/ftape/zftape/zftape-vtbl.c
deleted file mode 100644
index ad7f8be6340b..000000000000
--- a/drivers/char/ftape/zftape/zftape-vtbl.c
+++ /dev/null
@@ -1,757 +0,0 @@
-/*
- *      Copyright (c) 1995-1997 Claus-Justus Heine 
-
- This program is free software; you can redistribute it and/or
- modify it under the terms of the GNU General Public License as
- published by the Free Software Foundation; either version 2, or (at
- your option) any later version.
- 
- This program is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- General Public License for more details.
- 
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
- USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/zftape/zftape-vtbl.c,v $
- * $Revision: 1.7.6.1 $
- * $Date: 1997/11/24 13:48:31 $
- *
- *      This file defines a volume table as defined in various QIC
- *      standards.
- * 
- *      This is a minimal implementation, just allowing ordinary DOS
- *      :( prgrams to identify the cartridge as used.
- */
-
-#include <linux/errno.h>
-#include <linux/mm.h>
-#include <linux/slab.h>
-
-#include <linux/zftape.h>
-#include "../zftape/zftape-init.h"
-#include "../zftape/zftape-eof.h"
-#include "../zftape/zftape-ctl.h"
-#include "../zftape/zftape-write.h"
-#include "../zftape/zftape-read.h"
-#include "../zftape/zftape-rw.h"
-#include "../zftape/zftape-vtbl.h"
-
-#define ZFT_CMAP_HACK /* leave this defined to hide the compression map */
-
-/*
- *  global variables 
- */
-int zft_qic_mode   = 1; /* use the vtbl */
-int zft_old_ftape; /* prevents old ftaped tapes to be overwritten */
-int zft_volume_table_changed; /* for write_header_segments() */
-
-/*
- *  private variables (only exported for inline functions)
- */
-LIST_HEAD(zft_vtbl);
-
-/*  We could also allocate these dynamically when extracting the volume table
- *  sizeof(zft_volinfo) is about 32 or something close to that
- */
-static zft_volinfo  tape_vtbl;
-static zft_volinfo  eot_vtbl;
-static zft_volinfo *cur_vtbl;
-
-static inline void zft_new_vtbl_entry(void)
-{
-        struct list_head *tmp = &zft_last_vtbl->node;
-        zft_volinfo *new = zft_kmalloc(sizeof(zft_volinfo));
-
-        list_add(&new->node, tmp);
-        new->count = zft_eom_vtbl->count ++;
-}
-
-void zft_free_vtbl(void)
-{
-        for (;;) {
-                struct list_head *tmp = zft_vtbl.prev;
-                zft_volinfo *vtbl;
-
-                if (tmp == &zft_vtbl)
-                        break;
-                list_del(tmp);
-                vtbl = list_entry(tmp, zft_volinfo, node);
-                zft_kfree(vtbl, sizeof(zft_volinfo));
-        }
-        INIT_LIST_HEAD(&zft_vtbl);
-        cur_vtbl = NULL;
-}
-
-/*  initialize vtbl, called by ftape_new_cartridge()
- */
-void zft_init_vtbl(void)
-{ 
-        zft_volinfo *new;
-
-        zft_free_vtbl();
-        
-        /*  Create the two dummy vtbl entries
-         */
-        new = zft_kmalloc(sizeof(zft_volinfo));
-        list_add(&new->node, &zft_vtbl);
-        new = zft_kmalloc(sizeof(zft_volinfo));
-        list_add(&new->node, &zft_vtbl);
-        zft_head_vtbl->end_seg   = ft_first_data_segment;
-        zft_head_vtbl->blk_sz    = zft_blk_sz;
-        zft_head_vtbl->count     = -1;
-        zft_eom_vtbl->start_seg  = ft_first_data_segment + 1;
-        zft_eom_vtbl->end_seg    = ft_last_data_segment + 1;
-        zft_eom_vtbl->blk_sz     = zft_blk_sz;
-        zft_eom_vtbl->count      = 0;
-
-        /*  Reset the pointer for zft_find_volume()
-         */
-        cur_vtbl = zft_eom_vtbl;
-
-        /* initialize the dummy vtbl entries for zft_qic_mode == 0
-         */
-        eot_vtbl.start_seg       = ft_last_data_segment + 1;
-        eot_vtbl.end_seg         = ft_last_data_segment + 1;
-        eot_vtbl.blk_sz          = zft_blk_sz;
-        eot_vtbl.count           = -1;
-        tape_vtbl.start_seg = ft_first_data_segment;
-        tape_vtbl.end_seg   = ft_last_data_segment;
-        tape_vtbl.blk_sz    = zft_blk_sz;
-        tape_vtbl.size      = zft_capacity;
-        tape_vtbl.count     = 0;
-}
-
-/* check for a valid VTBL signature. 
- */
-static int vtbl_signature_valid(__u8 signature[4])
-{
-        const char *vtbl_ids[] = VTBL_IDS; /* valid signatures */
-        int j;
-        
-        for (j = 0; 
-             (j < NR_ITEMS(vtbl_ids)) && (memcmp(signature, vtbl_ids[j], 4) != 0);
-             j++);
-        return j < NR_ITEMS(vtbl_ids);
-}
-
-/* We used to store the block-size of the volume in the volume-label,
- * using the keyword "blocksize". The blocksize written to the
- * volume-label is in bytes.
- *
- * We use this now only for compatibility with old zftape version. We
- * store the blocksize directly as binary number in the vendor
- * extension part of the volume entry.
- */
-static int check_volume_label(const char *label, int *blk_sz)
-{ 
-        int valid_format;
-        char *blocksize;
-        TRACE_FUN(ft_t_flow);
-        
-        TRACE(ft_t_noise, "called with \"%s\" / \"%s\"", label, ZFT_VOL_NAME);
-        if (strncmp(label, ZFT_VOL_NAME, strlen(ZFT_VOL_NAME)) != 0) {
-                *blk_sz = 1; /* smallest block size that we allow */
-                valid_format = 0;
-        } else {
-                TRACE(ft_t_noise, "got old style zftape vtbl entry");
-                /* get the default blocksize */
-                /* use the kernel strstr()   */
-                blocksize= strstr(label, " blocksize ");
-                if (blocksize) {
-                        blocksize += strlen(" blocksize ");
-                        for(*blk_sz= 0; 
-                            *blocksize >= '0' && *blocksize <= '9'; 
-                            blocksize++) {
-                                *blk_sz *= 10;
-                                *blk_sz += *blocksize - '0';
-                        }
-                        if (*blk_sz > ZFT_MAX_BLK_SZ) {
-                                *blk_sz= 1;
-                                valid_format= 0;
-                        } else {
-                                valid_format = 1;
-                        }
-                } else {
-                        *blk_sz= 1;
-                        valid_format= 0;
-                }
-        }
-        TRACE_EXIT valid_format;
-}
-
-/*   check for a zftape volume
- */
-static int check_volume(__u8 *entry, zft_volinfo *volume)
-{
-        TRACE_FUN(ft_t_flow);
-        
-        if(strncmp(&entry[VTBL_EXT+EXT_ZFTAPE_SIG], ZFTAPE_SIG,
-                   strlen(ZFTAPE_SIG)) == 0) {
-                TRACE(ft_t_noise, "got new style zftape vtbl entry");
-                volume->blk_sz = GET2(entry, VTBL_EXT+EXT_ZFTAPE_BLKSZ);
-                volume->qic113 = entry[VTBL_EXT+EXT_ZFTAPE_QIC113];
-                TRACE_EXIT 1;
-        } else {
-                TRACE_EXIT check_volume_label(&entry[VTBL_DESC], &volume->blk_sz);
-        }
-}
-
-
-/* create zftape specific vtbl entry, the volume bounds are inserted
- * in the calling function, zft_create_volume_headers()
- */
-static void create_zft_volume(__u8 *entry, zft_volinfo *vtbl)
-{
-        TRACE_FUN(ft_t_flow);
-
-        memset(entry, 0, VTBL_SIZE);
-        memcpy(&entry[VTBL_SIG], VTBL_ID, 4);
-        sprintf(&entry[VTBL_DESC], ZFT_VOL_NAME" %03d", vtbl->count);
-        entry[VTBL_FLAGS] = (VTBL_FL_NOT_VERIFIED | VTBL_FL_SEG_SPANNING);
-        entry[VTBL_M_NO] = 1; /* multi_cartridge_count */
-        strcpy(&entry[VTBL_EXT+EXT_ZFTAPE_SIG], ZFTAPE_SIG);
-        PUT2(entry, VTBL_EXT+EXT_ZFTAPE_BLKSZ, vtbl->blk_sz);
-        if (zft_qic113) {
-                PUT8(entry, VTBL_DATA_SIZE, vtbl->size);
-                entry[VTBL_CMPR] = VTBL_CMPR_UNREG; 
-                if (vtbl->use_compression) { /* use compression: */
-                        entry[VTBL_CMPR] |= VTBL_CMPR_USED;
-                }
-                entry[VTBL_EXT+EXT_ZFTAPE_QIC113] = 1;
-        } else {
-                PUT4(entry, VTBL_DATA_SIZE, vtbl->size);
-                entry[VTBL_K_CMPR] = VTBL_CMPR_UNREG; 
-                if (vtbl->use_compression) { /* use compression: */
-                        entry[VTBL_K_CMPR] |= VTBL_CMPR_USED;
-                }
-        }
-        if (ft_format_code == fmt_big) {
-                /* SCSI like vtbl, store the number of used
-                 * segments as 4 byte value 
-                 */
-                PUT4(entry, VTBL_SCSI_SEGS, vtbl->end_seg-vtbl->start_seg + 1);
-        } else {
-                /* normal, QIC-80MC like vtbl 
-                 */
-                PUT2(entry, VTBL_START, vtbl->start_seg);
-                PUT2(entry, VTBL_END, vtbl->end_seg);
-        }
-        TRACE_EXIT;
-}
-
-/* this one creates the volume headers for each volume. It is assumed
- * that buffer already contains the old volume-table, so that vtbl
- * entries without the zft_volume flag set can savely be ignored.
- */
-static void zft_create_volume_headers(__u8 *buffer)
-{   
-        __u8 *entry;
-        struct list_head *tmp;
-        zft_volinfo *vtbl;
-        TRACE_FUN(ft_t_flow);
-        
-#ifdef ZFT_CMAP_HACK
-        if((strncmp(&buffer[VTBL_EXT+EXT_ZFTAPE_SIG], ZFTAPE_SIG,
-                    strlen(ZFTAPE_SIG)) == 0) && 
-           buffer[VTBL_EXT+EXT_ZFTAPE_CMAP] != 0) {
-                TRACE(ft_t_noise, "deleting cmap volume");
-                memmove(buffer, buffer + VTBL_SIZE,
-                        FT_SEGMENT_SIZE - VTBL_SIZE);
-        }
-#endif
-        entry = buffer;
-        for (tmp = zft_head_vtbl->node.next;
-             tmp != &zft_eom_vtbl->node;
-             tmp = tmp->next) {
-                vtbl = list_entry(tmp, zft_volinfo, node);
-                /* we now fill in the values only for newly created volumes.
-                 */
-                if (vtbl->new_volume) {
-                        create_zft_volume(entry, vtbl);
-                        vtbl->new_volume = 0; /* clear the flag */
-                }
-                
-                DUMP_VOLINFO(ft_t_noise, &entry[VTBL_DESC], vtbl);
-                entry += VTBL_SIZE;
-        }
-        memset(entry, 0, FT_SEGMENT_SIZE - zft_eom_vtbl->count * VTBL_SIZE);
-        TRACE_EXIT;
-}
-
-/*  write volume table to tape. Calls zft_create_volume_headers()
- */
-int zft_update_volume_table(unsigned int segment)
-{
-        int result = 0;
-        __u8 *verify_buf = NULL;
-        TRACE_FUN(ft_t_flow);
-
-        TRACE_CATCH(result = ftape_read_segment(ft_first_data_segment, 
-                                                zft_deblock_buf,
-                                                FT_RD_SINGLE),);
-        zft_create_volume_headers(zft_deblock_buf);
-        TRACE(ft_t_noise, "writing volume table segment %d", segment);
-        if (zft_vmalloc_once(&verify_buf, FT_SEGMENT_SIZE) == 0) {
-                TRACE_CATCH(zft_verify_write_segments(segment, 
-                                                      zft_deblock_buf, result,
-                                                      verify_buf),
-                            zft_vfree(&verify_buf, FT_SEGMENT_SIZE));
-                zft_vfree(&verify_buf, FT_SEGMENT_SIZE);
-        } else {
-                TRACE_CATCH(ftape_write_segment(segment, zft_deblock_buf, 
-                                                FT_WR_SINGLE),);
-        }
-        TRACE_EXIT 0;
-}
-
-/* non zftape volumes are handled in raw mode. Thus we need to
- * calculate the raw amount of data contained in those segments.  
- */
-static void extract_alien_volume(__u8 *entry, zft_volinfo *vtbl)
-{
-        TRACE_FUN(ft_t_flow);
-
-        vtbl->size  = (zft_calc_tape_pos(zft_last_vtbl->end_seg+1) -
-                       zft_calc_tape_pos(zft_last_vtbl->start_seg));
-        vtbl->use_compression = 0;
-        vtbl->qic113 = zft_qic113;
-        if (vtbl->qic113) {
-                TRACE(ft_t_noise, 
-                      "Fake alien volume's size from " LL_X " to " LL_X, 
-                      LL(GET8(entry, VTBL_DATA_SIZE)), LL(vtbl->size));
-        } else {
-                TRACE(ft_t_noise,
-                      "Fake alien volume's size from %d to " LL_X, 
-                      (int)GET4(entry, VTBL_DATA_SIZE), LL(vtbl->size));
-        }
-        TRACE_EXIT;
-}
-
-
-/* extract an zftape specific volume
- */
-static void extract_zft_volume(__u8 *entry, zft_volinfo *vtbl)
-{
-        TRACE_FUN(ft_t_flow);
-
-        if (vtbl->qic113) {
-                vtbl->size = GET8(entry, VTBL_DATA_SIZE);
-                vtbl->use_compression = 
-                        (entry[VTBL_CMPR] & VTBL_CMPR_USED) != 0; 
-        } else {
-                vtbl->size = GET4(entry, VTBL_DATA_SIZE);
-                if (entry[VTBL_K_CMPR] & VTBL_CMPR_UNREG) {
-                        vtbl->use_compression = 
-                                (entry[VTBL_K_CMPR] & VTBL_CMPR_USED) != 0;
-                } else if (entry[VTBL_CMPR] & VTBL_CMPR_UNREG) {
-                        vtbl->use_compression = 
-                                (entry[VTBL_CMPR] & VTBL_CMPR_USED) != 0; 
-                } else {
-                        TRACE(ft_t_warn, "Geeh! There is something wrong:\n"
-                              KERN_INFO "QIC compression (Rev = K): %x\n"
-                              KERN_INFO "QIC compression (Rev > K): %x",
-                              entry[VTBL_K_CMPR], entry[VTBL_CMPR]);
-                }
-        }
-        TRACE_EXIT;
-}
-
-/* extract the volume table from buffer. "buffer" must already contain
- * the vtbl-segment 
- */
-int zft_extract_volume_headers(__u8 *buffer)
-{                            
-        __u8 *entry;
-        TRACE_FUN(ft_t_flow);
-        
-        zft_init_vtbl();
-        entry = buffer;
-#ifdef ZFT_CMAP_HACK
-        if ((strncmp(&entry[VTBL_EXT+EXT_ZFTAPE_SIG], ZFTAPE_SIG,
-                     strlen(ZFTAPE_SIG)) == 0) &&
-            entry[VTBL_EXT+EXT_ZFTAPE_CMAP] != 0) {
-                TRACE(ft_t_noise, "ignoring cmap volume");
-                entry += VTBL_SIZE;
-        } 
-#endif
-        /* the end of the vtbl is indicated by an invalid signature 
-         */
-        while (vtbl_signature_valid(&entry[VTBL_SIG]) &&
-               (entry - buffer) < FT_SEGMENT_SIZE) {
-                zft_new_vtbl_entry();
-                if (ft_format_code == fmt_big) {
-                        /* SCSI like vtbl, stores only the number of
-                         * segments used 
-                         */
-                        unsigned int num_segments= GET4(entry, VTBL_SCSI_SEGS);
-                        zft_last_vtbl->start_seg = zft_eom_vtbl->start_seg;
-                        zft_last_vtbl->end_seg = 
-                                zft_last_vtbl->start_seg + num_segments - 1;
-                } else {
-                        /* `normal', QIC-80 like vtbl 
-                         */
-                        zft_last_vtbl->start_seg = GET2(entry, VTBL_START);
-                        zft_last_vtbl->end_seg   = GET2(entry, VTBL_END);
-                }
-                zft_eom_vtbl->start_seg  = zft_last_vtbl->end_seg + 1;
-                /* check if we created this volume and get the
-                 * blk_sz 
-                 */
-                zft_last_vtbl->zft_volume = check_volume(entry, zft_last_vtbl);
-                if (zft_last_vtbl->zft_volume == 0) {
-                        extract_alien_volume(entry, zft_last_vtbl);
-                } else {
-                        extract_zft_volume(entry, zft_last_vtbl);
-                }
-                DUMP_VOLINFO(ft_t_noise, &entry[VTBL_DESC], zft_last_vtbl);
-                entry +=VTBL_SIZE;
-        }
-#if 0
-/*
- *  undefine to test end of tape handling
- */
-        zft_new_vtbl_entry();
-        zft_last_vtbl->start_seg = zft_eom_vtbl->start_seg;
-        zft_last_vtbl->end_seg   = ft_last_data_segment - 10;
-        zft_last_vtbl->blk_sz          = zft_blk_sz;
-        zft_last_vtbl->zft_volume      = 1;
-        zft_last_vtbl->qic113          = zft_qic113;
-        zft_last_vtbl->size = (zft_calc_tape_pos(zft_last_vtbl->end_seg+1)
-                               - zft_calc_tape_pos(zft_last_vtbl->start_seg));
-#endif
-        TRACE_EXIT 0;
-}
-
-/* this functions translates the failed_sector_log, misused as
- * EOF-marker list, into a virtual volume table. The table mustn't be
- * written to tape, because this would occupy the first data segment,
- * which should be the volume table, but is actually the first segment
- * that is filled with data (when using standard ftape).  We assume,
- * that we get a non-empty failed_sector_log.
- */
-int zft_fake_volume_headers (eof_mark_union *eof_map, int num_failed_sectors)
-{
-        unsigned int segment, sector;
-        int have_eom = 0;
-        int vol_no;
-        TRACE_FUN(ft_t_flow);
-
-        if ((num_failed_sectors >= 2) &&
-            (GET2(&eof_map[num_failed_sectors - 1].mark.segment, 0) 
-             == 
-             GET2(&eof_map[num_failed_sectors - 2].mark.segment, 0) + 1) &&
-            (GET2(&eof_map[num_failed_sectors - 1].mark.date, 0) == 1)) {
-                /* this should be eom. We keep the remainder of the
-                 * tape as another volume.
-                 */
-                have_eom = 1;
-        }
-        zft_init_vtbl();
-        zft_eom_vtbl->start_seg = ft_first_data_segment;
-        for(vol_no = 0; vol_no < num_failed_sectors - have_eom; vol_no ++) {
-                zft_new_vtbl_entry();
-
-                segment = GET2(&eof_map[vol_no].mark.segment, 0);
-                sector  = GET2(&eof_map[vol_no].mark.date, 0);
-
-                zft_last_vtbl->start_seg  = zft_eom_vtbl->start_seg;
-                zft_last_vtbl->end_seg    = segment;
-                zft_eom_vtbl->start_seg  = segment + 1;
-                zft_last_vtbl->blk_sz     = 1;
-                zft_last_vtbl->size       = 
-                        (zft_calc_tape_pos(zft_last_vtbl->end_seg)
-                         - zft_calc_tape_pos(zft_last_vtbl->start_seg)
-                         + (sector-1) * FT_SECTOR_SIZE);
-                TRACE(ft_t_noise, 
-                      "failed sector log: segment: %d, sector: %d", 
-                      segment, sector);
-                DUMP_VOLINFO(ft_t_noise, "Faked volume", zft_last_vtbl);
-        }
-        if (!have_eom) {
-                zft_new_vtbl_entry();
-                zft_last_vtbl->start_seg = zft_eom_vtbl->start_seg;
-                zft_last_vtbl->end_seg   = ft_last_data_segment;
-                zft_eom_vtbl->start_seg  = ft_last_data_segment + 1;
-                zft_last_vtbl->size      = zft_capacity;
-                zft_last_vtbl->size     -= zft_calc_tape_pos(zft_last_vtbl->start_seg);
-                zft_last_vtbl->blk_sz    = 1;
-                DUMP_VOLINFO(ft_t_noise, "Faked volume",zft_last_vtbl);
-        }
-        TRACE_EXIT 0;
-}
-
-/* update the internal volume table
- *
- * if before start of last volume: erase all following volumes if
- * inside a volume: set end of volume to infinity
- *
- * this function is intended to be called every time _ftape_write() is
- * called
- *
- * return: 0 if no new volume was created, 1 if a new volume was
- * created
- *
- * NOTE: we don't need to check for zft_mode as ftape_write() does
- * that already. This function gets never called without accessing
- * zftape via the *qft* devices 
- */
-
-int zft_open_volume(zft_position *pos, int blk_sz, int use_compression)
-{ 
-        TRACE_FUN(ft_t_flow);
-        
-        if (!zft_qic_mode) {
-                TRACE_EXIT 0;
-        }
-        if (zft_tape_at_lbot(pos)) {
-                zft_init_vtbl();
-                if(zft_old_ftape) {
-                        /* clear old ftape's eof marks */
-                        zft_clear_ftape_file_marks();
-                        zft_old_ftape = 0; /* no longer old ftape */
-                }
-                zft_reset_position(pos);
-        }
-        if (pos->seg_pos != zft_last_vtbl->end_seg + 1) {
-                TRACE_ABORT(-EIO, ft_t_bug, 
-                      "BUG: seg_pos: %d, zft_last_vtbl->end_seg: %d", 
-                      pos->seg_pos, zft_last_vtbl->end_seg);
-        }                            
-        TRACE(ft_t_noise, "create new volume");
-        if (zft_eom_vtbl->count >= ZFT_MAX_VOLUMES) {
-                TRACE_ABORT(-ENOSPC, ft_t_err,
-                            "Error: maxmimal number of volumes exhausted "
-                            "(maxmimum is %d)", ZFT_MAX_VOLUMES);
-        }
-        zft_new_vtbl_entry();
-        pos->volume_pos = pos->seg_byte_pos = 0;
-        zft_last_vtbl->start_seg       = pos->seg_pos;
-        zft_last_vtbl->end_seg         = ft_last_data_segment; /* infinity */
-        zft_last_vtbl->blk_sz          = blk_sz;
-        zft_last_vtbl->size            = zft_capacity;
-        zft_last_vtbl->zft_volume      = 1;
-        zft_last_vtbl->use_compression = use_compression;
-        zft_last_vtbl->qic113          = zft_qic113;
-        zft_last_vtbl->new_volume      = 1;
-        zft_last_vtbl->open            = 1;
-        zft_volume_table_changed = 1;
-        zft_eom_vtbl->start_seg  = ft_last_data_segment + 1;
-        TRACE_EXIT 0;
-}
-
-/*  perform mtfsf, mtbsf, not allowed without zft_qic_mode
- */
-int zft_skip_volumes(int count, zft_position *pos)
-{ 
-        const zft_volinfo *vtbl;
-        TRACE_FUN(ft_t_flow);
-        
-        TRACE(ft_t_noise, "count: %d", count);
-        
-        vtbl= zft_find_volume(pos->seg_pos);
-        while (count > 0 && vtbl != zft_eom_vtbl) {
-                vtbl = list_entry(vtbl->node.next, zft_volinfo, node);
-                count --;
-        }
-        while (count < 0 && vtbl != zft_first_vtbl) {
-                vtbl = list_entry(vtbl->node.prev, zft_volinfo, node);
-                count ++;
-        }
-        pos->seg_pos        = vtbl->start_seg;
-        pos->seg_byte_pos   = 0;
-        pos->volume_pos     = 0;
-        pos->tape_pos       = zft_calc_tape_pos(pos->seg_pos);
-        zft_just_before_eof = vtbl->size == 0;
-        if (zft_cmpr_ops) {
-                (*zft_cmpr_ops->reset)();
-        }
-        zft_deblock_segment = -1; /* no need to keep cache */
-        TRACE(ft_t_noise, "repositioning to:\n"
-              KERN_INFO "zft_seg_pos        : %d\n"
-              KERN_INFO "zft_seg_byte_pos   : %d\n"
-              KERN_INFO "zft_tape_pos       : " LL_X "\n"
-              KERN_INFO "zft_volume_pos     : " LL_X "\n"
-              KERN_INFO "file number        : %d",
-              pos->seg_pos, pos->seg_byte_pos, 
-              LL(pos->tape_pos), LL(pos->volume_pos), vtbl->count);
-        zft_resid = count < 0 ? -count : count;
-        TRACE_EXIT zft_resid ? -EINVAL : 0;
-}
-
-/* the following simply returns the raw data position of the EOM
- * marker, MTIOCSIZE ioctl 
- */
-__s64 zft_get_eom_pos(void)
-{
-        if (zft_qic_mode) {
-                return zft_calc_tape_pos(zft_eom_vtbl->start_seg);
-        } else {
-                /* there is only one volume in raw mode */
-                return zft_capacity;
-        }
-}
-
-/* skip to eom, used for MTEOM
- */
-void zft_skip_to_eom(zft_position *pos)
-{
-        TRACE_FUN(ft_t_flow);
-        pos->seg_pos      = zft_eom_vtbl->start_seg;
-        pos->seg_byte_pos = 
-                pos->volume_pos     = 
-                zft_just_before_eof = 0;
-        pos->tape_pos = zft_calc_tape_pos(pos->seg_pos);
-        TRACE(ft_t_noise, "ftape positioned to segment %d, data pos " LL_X, 
-              pos->seg_pos, LL(pos->tape_pos));
-        TRACE_EXIT;
-}
-
-/*  write an EOF-marker by setting zft_last_vtbl->end_seg to seg_pos.
- *  NOTE: this function assumes that zft_last_vtbl points to a valid
- *  vtbl entry
- *
- *  NOTE: this routine always positions before the EOF marker
- */
-int zft_close_volume(zft_position *pos)
-{
-        TRACE_FUN(ft_t_any);
-
-        if (zft_vtbl_empty || !zft_last_vtbl->open) { /* should not happen */
-                TRACE(ft_t_noise, "There are no volumes to finish");
-                TRACE_EXIT -EIO;
-        }
-        if (pos->seg_byte_pos == 0 && 
-            pos->seg_pos != zft_last_vtbl->start_seg) {
-                pos->seg_pos --;
-                pos->seg_byte_pos      = zft_get_seg_sz(pos->seg_pos);
-        }
-        zft_last_vtbl->end_seg   = pos->seg_pos;
-        zft_last_vtbl->size      = pos->volume_pos;
-        zft_volume_table_changed = 1;
-        zft_just_before_eof      = 1;
-        zft_eom_vtbl->start_seg  = zft_last_vtbl->end_seg + 1;
-        zft_last_vtbl->open      = 0; /* closed */
-        TRACE_EXIT 0;
-}
-
-/* write count file-marks at current position. 
- *
- *  The tape is positioned after the eof-marker, that is at byte 0 of
- *  the segment following the eof-marker
- *
- *  this function is only allowed in zft_qic_mode
- *
- *  Only allowed when tape is at BOT or EOD.
- */
-int zft_weof(unsigned int count, zft_position *pos)
-{
-        
-        TRACE_FUN(ft_t_flow);
-
-        if (!count) { /* write zero EOF marks should be a real no-op */
-                TRACE_EXIT 0;
-        }
-        zft_volume_table_changed = 1;
-        if (zft_tape_at_lbot(pos)) {
-                zft_init_vtbl();
-                if(zft_old_ftape) {
-                        /* clear old ftape's eof marks */
-                        zft_clear_ftape_file_marks();
-                        zft_old_ftape = 0;    /* no longer old ftape */
-                }
-        }
-        if (zft_last_vtbl->open) {
-                zft_close_volume(pos);
-                zft_move_past_eof(pos);
-                count --;
-        }
-        /* now it's easy, just append eof-marks, that is empty
-         * volumes, to the end of the already recorded media.
-         */
-        while (count > 0 && 
-               pos->seg_pos <= ft_last_data_segment && 
-               zft_eom_vtbl->count < ZFT_MAX_VOLUMES) {
-                TRACE(ft_t_noise,
-                      "Writing zero sized file at segment %d", pos->seg_pos);
-                zft_new_vtbl_entry();
-                zft_last_vtbl->start_seg       = pos->seg_pos;
-                zft_last_vtbl->end_seg         = pos->seg_pos;
-                zft_last_vtbl->size            = 0;
-                zft_last_vtbl->blk_sz          = zft_blk_sz;
-                zft_last_vtbl->zft_volume      = 1;
-                zft_last_vtbl->use_compression = 0;
-                pos->tape_pos += zft_get_seg_sz(pos->seg_pos);
-                zft_eom_vtbl->start_seg = ++ pos->seg_pos;
-                count --;
-        } 
-        if (count > 0) {
-                /*  there are two possibilities: end of tape, or the
-                 *  maximum number of files is exhausted.
-                 */
-                zft_resid = count;
-                TRACE(ft_t_noise,"Number of marks NOT written: %d", zft_resid);
-                if (zft_eom_vtbl->count == ZFT_MAX_VOLUMES) {
-                        TRACE_ABORT(-EINVAL, ft_t_warn,
-                                    "maximum allowed number of files "
-                                    "exhausted: %d", ZFT_MAX_VOLUMES);
-                } else {
-                        TRACE_ABORT(-ENOSPC,
-                                    ft_t_noise, "reached end of tape");
-                }
-        }
-        TRACE_EXIT 0;
-}
-
-const zft_volinfo *zft_find_volume(unsigned int seg_pos)
-{
-        TRACE_FUN(ft_t_flow);
-        
-        TRACE(ft_t_any, "called with seg_pos %d",seg_pos);
-        if (!zft_qic_mode) {
-                if (seg_pos > ft_last_data_segment) {
-                        TRACE_EXIT &eot_vtbl;
-                }
-                tape_vtbl.blk_sz =  zft_blk_sz;
-                TRACE_EXIT &tape_vtbl;
-        }
-        if (seg_pos < zft_first_vtbl->start_seg) {
-                TRACE_EXIT (cur_vtbl = zft_first_vtbl);
-        }
-        while (seg_pos > cur_vtbl->end_seg) {
-                cur_vtbl = list_entry(cur_vtbl->node.next, zft_volinfo, node);
-                TRACE(ft_t_noise, "%d - %d", cur_vtbl->start_seg, cur_vtbl->end_seg);
-        }
-        while (seg_pos < cur_vtbl->start_seg) {
-                cur_vtbl = list_entry(cur_vtbl->node.prev, zft_volinfo, node);
-                TRACE(ft_t_noise, "%d - %d", cur_vtbl->start_seg, cur_vtbl->end_seg);
-        }
-        if (seg_pos > cur_vtbl->end_seg || seg_pos < cur_vtbl->start_seg) {
-                TRACE(ft_t_bug, "This cannot happen");
-        }
-        DUMP_VOLINFO(ft_t_noise, "", cur_vtbl);
-        TRACE_EXIT cur_vtbl;
-}
-
-/* this function really assumes that we are just before eof
- */
-void zft_move_past_eof(zft_position *pos)
-{ 
-        TRACE_FUN(ft_t_flow);
-
-        TRACE(ft_t_noise, "old seg. pos: %d", pos->seg_pos);
-        pos->tape_pos += zft_get_seg_sz(pos->seg_pos++) - pos->seg_byte_pos;
-        pos->seg_byte_pos = 0;
-        pos->volume_pos   = 0;
-        if (zft_cmpr_ops) {
-                (*zft_cmpr_ops->reset)();
-        }
-        zft_just_before_eof =  0;
-        zft_deblock_segment = -1; /* no need to cache it anymore */
-        TRACE(ft_t_noise, "new seg. pos: %d", pos->seg_pos);
-        TRACE_EXIT;
-}
diff --git a/drivers/char/ftape/zftape/zftape-vtbl.h b/drivers/char/ftape/zftape/zftape-vtbl.h
deleted file mode 100644
index f31d196d1759..000000000000
--- a/drivers/char/ftape/zftape/zftape-vtbl.h
+++ /dev/null
@@ -1,227 +0,0 @@
-#ifndef _ZFTAPE_VTBL_H
-#define _ZFTAPE_VTBL_H
-
-/*
- *      Copyright (c) 1995-1997  Claus-Justus Heine
-
- This program is free software; you can redistribute it and/or
- modify it under the terms of the GNU General Public License as
- published by the Free Software Foundation; either version 2, or (at
- your option) any later version.
- 
- This program is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- General Public License for more details.
- 
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
- USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/zftape/zftape-vtbl.h,v $
- * $Revision: 1.3 $
- * $Date: 1997/10/28 14:30:09 $
- *
- *      This file defines a volume table as defined in the QIC-80
- *      development standards.
- */
-
-#include <linux/list.h>
-
-#include "../lowlevel/ftape-tracing.h"
-
-#include "../zftape/zftape-eof.h"
-#include "../zftape/zftape-ctl.h"
-#include "../zftape/zftape-rw.h"
-
-#define VTBL_SIZE 128 /* bytes */
-
-/* The following are offsets in the vtbl.  */
-#define VTBL_SIG   0
-#define VTBL_START 4
-#define VTBL_END   6
-#define VTBL_DESC  8
-#define VTBL_DATE  52
-#define VTBL_FLAGS 56
-#define VTBL_FL_VENDOR_SPECIFIC (1<<0)
-#define VTBL_FL_MUTLI_CARTRIDGE (1<<1)
-#define VTBL_FL_NOT_VERIFIED    (1<<2)
-#define VTBL_FL_REDIR_INHIBIT   (1<<3)
-#define VTBL_FL_SEG_SPANNING    (1<<4)
-#define VTBL_FL_DIRECTORY_LAST  (1<<5)
-#define VTBL_FL_RESERVED_6      (1<<6)
-#define VTBL_FL_RESERVED_7      (1<<7)
-#define VTBL_M_NO  57
-#define VTBL_EXT   58
-#define EXT_ZFTAPE_SIG     0
-#define EXT_ZFTAPE_BLKSZ  10
-#define EXT_ZFTAPE_CMAP   12
-#define EXT_ZFTAPE_QIC113 13
-#define VTBL_PWD   84
-#define VTBL_DIR_SIZE 92
-#define VTBL_DATA_SIZE 96
-#define VTBL_OS_VERSION 104
-#define VTBL_SRC_DRIVE  106
-#define VTBL_DEV        122
-#define VTBL_RESERVED_1 123
-#define VTBL_CMPR       124
-#define VTBL_CMPR_UNREG 0x3f
-#define VTBL_CMPR_USED  0x80
-#define VTBL_FMT        125
-#define VTBL_RESERVED_2 126
-#define VTBL_RESERVED_3 127
-/* compatibility with pre revision K */
-#define VTBL_K_CMPR     120 
-
-/*  the next is used by QIC-3020 tapes with format code 6 (>2^16
- *  segments) It is specified in QIC-113, Rev. G, Section 5 (SCSI
- *  volume table). The difference is simply, that we only store the
- *  number of segments used, not the starting segment.
- */
-#define VTBL_SCSI_SEGS  4 /* is a 4 byte value */
-
-/*  one vtbl is 128 bytes, that results in a maximum number of
- *  29*1024/128 = 232 volumes.
- */
-#define ZFT_MAX_VOLUMES (FT_SEGMENT_SIZE/VTBL_SIZE)
-#define VTBL_ID  "VTBL"
-#define VTBL_IDS { VTBL_ID, "XTBL", "UTID", "EXVT" } /* other valid ids */
-#define ZFT_VOL_NAME "zftape volume" /* volume label used by me */
-#define ZFTAPE_SIG "LINUX ZFT"
-
-/*  global variables
- */
-typedef struct zft_internal_vtbl
-{
-        struct list_head node;
-        int          count;
-        unsigned int start_seg;         /* 32 bits are enough for now */
-        unsigned int end_seg;           /* 32 bits are enough for now */
-        __s64        size;              /* uncompressed size */
-        unsigned int blk_sz;            /* block size for this volume */
-        unsigned int zft_volume     :1; /* zftape created this volume */
-        unsigned int use_compression:1; /* compressed volume  */
-        unsigned int qic113         :1; /* layout of compressed block
-                                         * info and vtbl conforms to
-                                         * QIC-113, Rev. G 
-                                         */
-        unsigned int new_volume     :1; /* it was created by us, this
-                                         * run.  this allows the
-                                         * fields that aren't really
-                                         * used by zftape to be filled
-                                         * in by some user level
-                                         * program.
-                                         */
-        unsigned int open           :1; /* just in progress of being 
-                                         * written
-                                         */
-} zft_volinfo;
-
-extern struct list_head zft_vtbl;
-#define zft_head_vtbl  list_entry(zft_vtbl.next, zft_volinfo, node)
-#define zft_eom_vtbl   list_entry(zft_vtbl.prev, zft_volinfo, node)
-#define zft_last_vtbl  list_entry(zft_eom_vtbl->node.prev, zft_volinfo, node)
-#define zft_first_vtbl list_entry(zft_head_vtbl->node.next, zft_volinfo, node)
-#define zft_vtbl_empty (zft_eom_vtbl->node.prev == &zft_head_vtbl->node)
-
-#define DUMP_VOLINFO(level, desc, info)                                 \
-{                                                                       \
-        char tmp[21];                                                   \
-        strlcpy(tmp, desc, sizeof(tmp));                                \
-        TRACE(level, "Volume %d:\n"                                     \
-              KERN_INFO "description  : %s\n"                           \
-              KERN_INFO "first segment: %d\n"                           \
-              KERN_INFO "last  segment: %d\n"                           \
-              KERN_INFO "size         : " LL_X "\n"                     \
-              KERN_INFO "block size   : %d\n"                           \
-              KERN_INFO "compression  : %d\n"                           \
-              KERN_INFO "zftape volume: %d\n"                           \
-              KERN_INFO "QIC-113 conf.: %d",                            \
-              (info)->count, tmp, (info)->start_seg, (info)->end_seg,   \
-              LL((info)->size), (info)->blk_sz,                         \
-              (info)->use_compression != 0, (info)->zft_volume != 0,    \
-              (info)->qic113 != 0);                                     \
-}
-
-extern int zft_qic_mode;
-extern int zft_old_ftape;
-extern int zft_volume_table_changed;
-
-/* exported functions */
-extern void  zft_init_vtbl             (void);
-extern void  zft_free_vtbl             (void);
-extern int   zft_extract_volume_headers(__u8 *buffer);
-extern int   zft_update_volume_table   (unsigned int segment);
-extern int   zft_open_volume           (zft_position *pos,
-                                        int blk_sz, int use_compression);
-extern int   zft_close_volume          (zft_position *pos);
-extern const zft_volinfo *zft_find_volume(unsigned int seg_pos);
-extern int   zft_skip_volumes          (int count, zft_position *pos);
-extern __s64 zft_get_eom_pos           (void);
-extern void  zft_skip_to_eom           (zft_position *pos);
-extern int   zft_fake_volume_headers   (eof_mark_union *eof_map, 
-                                        int num_failed_sectors);
-extern int   zft_weof                  (unsigned int count, zft_position *pos);
-extern void  zft_move_past_eof         (zft_position *pos);
-
-static inline int   zft_tape_at_eod         (const zft_position *pos);
-static inline int   zft_tape_at_lbot        (const zft_position *pos);
-static inline void  zft_position_before_eof (zft_position *pos, 
-                                             const zft_volinfo *volume);
-static inline __s64 zft_check_for_eof(const zft_volinfo *vtbl,
-                                      const zft_position *pos);
-
-/* this function decrements the zft_seg_pos counter if we are right
- * at the beginning of a segment. This is to handle fsfm/bsfm -- we
- * need to position before the eof mark.  NOTE: zft_tape_pos is not
- * changed 
- */
-static inline void zft_position_before_eof(zft_position *pos, 
-                                           const zft_volinfo *volume)
-{ 
-        TRACE_FUN(ft_t_flow);
-
-        if (pos->seg_pos == volume->end_seg + 1 &&  pos->seg_byte_pos == 0) {
-                pos->seg_pos --;
-                pos->seg_byte_pos = zft_get_seg_sz(pos->seg_pos);
-        }
-        TRACE_EXIT;
-}
-
-/*  Mmmh. Is the position at the end of the last volume, that is right
- *  before the last EOF mark also logical an EOD condition?
- */
-static inline int zft_tape_at_eod(const zft_position *pos)
-{ 
-        TRACE_FUN(ft_t_any);
-
-        if (zft_qic_mode) {
-                TRACE_EXIT (pos->seg_pos >= zft_eom_vtbl->start_seg ||
-                            zft_last_vtbl->open);
-        } else {
-                TRACE_EXIT pos->seg_pos > ft_last_data_segment;
-        }
-}
-
-static inline int zft_tape_at_lbot(const zft_position *pos)
-{
-        if (zft_qic_mode) {
-                return (pos->seg_pos <= zft_first_vtbl->start_seg &&
-                        pos->volume_pos == 0);
-        } else {
-                return (pos->seg_pos <= ft_first_data_segment && 
-                        pos->volume_pos == 0);
-        }
-}
-
-/* This one checks for EOF.  return remaing space (may be negative) 
- */
-static inline __s64 zft_check_for_eof(const zft_volinfo *vtbl,
-                                      const zft_position *pos)
-{     
-        return (__s64)(vtbl->size - pos->volume_pos);
-}
-
-#endif /* _ZFTAPE_VTBL_H */
diff --git a/drivers/char/ftape/zftape/zftape-write.c b/drivers/char/ftape/zftape/zftape-write.c
deleted file mode 100644
index 94327b8c97b9..000000000000
--- a/drivers/char/ftape/zftape/zftape-write.c
+++ /dev/null
@@ -1,483 +0,0 @@
-/*
- *      Copyright (C) 1996, 1997 Claus Heine
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/zftape/zftape-write.c,v $
- * $Revision: 1.3 $
- * $Date: 1997/11/06 00:50:29 $
- *
- *      This file contains the writing code
- *      for the QIC-117 floppy-tape driver for Linux.
- */
-
-#include <linux/errno.h>
-#include <linux/mm.h>
-
-#include <linux/zftape.h>
-
-#include <asm/uaccess.h>
-
-#include "../zftape/zftape-init.h"
-#include "../zftape/zftape-eof.h"
-#include "../zftape/zftape-ctl.h"
-#include "../zftape/zftape-write.h"
-#include "../zftape/zftape-read.h"
-#include "../zftape/zftape-rw.h"
-#include "../zftape/zftape-vtbl.h"
-
-/*      Global vars.
- */
-
-/*      Local vars.
- */
-static int last_write_failed;
-static int need_flush;
-
-void zft_prevent_flush(void)
-{
-        need_flush = 0;
-}
-
-static int zft_write_header_segments(__u8* buffer)
-{
-        int header_1_ok = 0;
-        int header_2_ok = 0;
-        unsigned int time_stamp;
-        TRACE_FUN(ft_t_noise);
-        
-        TRACE_CATCH(ftape_abort_operation(),);
-        ftape_seek_to_bot();    /* prevents extra rewind */
-        if (GET4(buffer, 0) != FT_HSEG_MAGIC) {
-                TRACE_ABORT(-EIO, ft_t_err,
-                            "wrong header signature found, aborting");
-        } 
-        /*   Be optimistic: */
-        PUT4(buffer, FT_SEG_CNT,
-             zft_written_segments + GET4(buffer, FT_SEG_CNT) + 2);
-        if ((time_stamp = zft_get_time()) != 0) {
-                PUT4(buffer, FT_WR_DATE, time_stamp);
-                if (zft_label_changed) {
-                        PUT4(buffer, FT_LABEL_DATE, time_stamp);
-                }
-        }
-        TRACE(ft_t_noise,
-              "writing first header segment %d", ft_header_segment_1);
-        header_1_ok = zft_verify_write_segments(ft_header_segment_1, 
-                                                buffer, FT_SEGMENT_SIZE,
-                                                zft_deblock_buf) >= 0;
-        TRACE(ft_t_noise,
-              "writing second header segment %d", ft_header_segment_2);
-        header_2_ok = zft_verify_write_segments(ft_header_segment_2, 
-                                                buffer, FT_SEGMENT_SIZE,
-                                                zft_deblock_buf) >= 0;
-        if (!header_1_ok) {
-                TRACE(ft_t_warn, "Warning: "
-                      "update of first header segment failed");
-        }
-        if (!header_2_ok) {
-                TRACE(ft_t_warn, "Warning: "
-                      "update of second header segment failed");
-        }
-        if (!header_1_ok && !header_2_ok) {
-                TRACE_ABORT(-EIO, ft_t_err, "Error: "
-                      "update of both header segments failed.");
-        }
-        TRACE_EXIT 0;
-}
-
-int zft_update_header_segments(void)
-{
-        TRACE_FUN(ft_t_noise);
-        
-        /*  must NOT use zft_write_protected, as it also includes the
-         *  file access mode. But we also want to update when soft
-         *  write protection is enabled (O_RDONLY)
-         */
-        if (ft_write_protected || zft_old_ftape) {
-                TRACE_ABORT(0, ft_t_noise, "Tape set read-only: no update");
-        } 
-        if (!zft_header_read) {
-                TRACE_ABORT(0, ft_t_noise, "Nothing to update");
-        }
-        if (!zft_header_changed) {
-                zft_header_changed = zft_written_segments > 0;
-        }
-        if (!zft_header_changed && !zft_volume_table_changed) {
-                TRACE_ABORT(0, ft_t_noise, "Nothing to update");
-        }
-        TRACE(ft_t_noise, "Updating header segments");
-        if (ftape_get_status()->fti_state == writing) {
-                TRACE_CATCH(ftape_loop_until_writes_done(),);
-        }
-        TRACE_CATCH(ftape_abort_operation(),);
-        
-        zft_deblock_segment = -1; /* invalidate the cache */
-        if (zft_header_changed) {
-                TRACE_CATCH(zft_write_header_segments(zft_hseg_buf),);
-        }
-        if (zft_volume_table_changed) {
-                TRACE_CATCH(zft_update_volume_table(ft_first_data_segment),);
-        }
-        zft_header_changed =
-                zft_volume_table_changed = 
-                zft_label_changed        =
-                zft_written_segments     = 0;
-        TRACE_CATCH(ftape_abort_operation(),);
-        ftape_seek_to_bot();
-        TRACE_EXIT 0;
-}
-
-static int read_merge_buffer(int seg_pos, __u8 *buffer, int offset, int seg_sz)
-{
-        int result = 0;
-        const ft_trace_t old_tracing = TRACE_LEVEL;
-        TRACE_FUN(ft_t_flow);
-        
-        if (zft_qic_mode) {
-                /*  writing in the middle of a volume is NOT allowed
-                 *
-                 */
-                TRACE(ft_t_noise, "No need to read a segment");
-                memset(buffer + offset, 0, seg_sz - offset);
-                TRACE_EXIT 0;
-        }
-        TRACE(ft_t_any, "waiting");
-        ftape_start_writing(FT_WR_MULTI);
-        TRACE_CATCH(ftape_loop_until_writes_done(),);
-        
-        TRACE(ft_t_noise, "trying to read segment %d from offset %d",
-              seg_pos, offset);
-        SET_TRACE_LEVEL(ft_t_bug);
-        result = zft_fetch_segment_fraction(seg_pos, buffer, 
-                                            FT_RD_SINGLE,
-                                            offset, seg_sz - offset);
-        SET_TRACE_LEVEL(old_tracing);
-        if (result != (seg_sz - offset)) {
-                TRACE(ft_t_noise, "Ignore error: read_segment() result: %d",
-                      result);
-                memset(buffer + offset, 0, seg_sz - offset);
-        }
-        TRACE_EXIT 0;
-}
-
-/* flush the write buffer to tape and write an eof-marker at the
- * current position if not in raw mode.  This function always
- * positions the tape before the eof-marker.  _ftape_close() should
- * then advance to the next segment.
- *
- * the parameter "finish_volume" describes whether to position before
- * or after the possibly created file-mark. We always position after
- * the file-mark when called from ftape_close() and a flush was needed
- * (that is ftape_write() was the last tape operation before calling
- * ftape_flush) But we always position before the file-mark when this
- * function get's called from outside ftape_close() 
- */
-int zft_flush_buffers(void)
-{
-        int result;
-        int data_remaining;
-        int this_segs_size;
-        TRACE_FUN(ft_t_flow);
-
-        TRACE(ft_t_data_flow,
-              "entered, ftape_state = %d", ftape_get_status()->fti_state);
-        if (ftape_get_status()->fti_state != writing && !need_flush) {
-                TRACE_ABORT(0, ft_t_noise, "no need for flush");
-        }
-        zft_io_state = zft_idle; /*  triggers some initializations for the
-                                  *  read and write routines 
-                                  */
-        if (last_write_failed) {
-                ftape_abort_operation();
-                TRACE_EXIT -EIO;
-        }
-        TRACE(ft_t_noise, "flushing write buffers");
-        this_segs_size = zft_get_seg_sz(zft_pos.seg_pos);
-        if (this_segs_size == zft_pos.seg_byte_pos) {
-                zft_pos.seg_pos ++;
-                data_remaining = zft_pos.seg_byte_pos = 0;
-        } else {
-                data_remaining = zft_pos.seg_byte_pos;
-        }
-        /* If there is any data not written to tape yet, append zero's
-         * up to the end of the sector (if using compression) or merge
-         * it with the data existing on the tape Then write the
-         * segment(s) to tape.
-         */
-        TRACE(ft_t_noise, "Position:\n"
-              KERN_INFO "seg_pos  : %d\n"
-              KERN_INFO "byte pos : %d\n"
-              KERN_INFO "remaining: %d",
-              zft_pos.seg_pos, zft_pos.seg_byte_pos, data_remaining);
-        if (data_remaining > 0) {
-                do {
-                        this_segs_size = zft_get_seg_sz(zft_pos.seg_pos);
-                        if (this_segs_size > data_remaining) {
-                                TRACE_CATCH(read_merge_buffer(zft_pos.seg_pos,
-                                                              zft_deblock_buf,
-                                                              data_remaining,
-                                                              this_segs_size),
-                                            last_write_failed = 1);
-                        }
-                        result = ftape_write_segment(zft_pos.seg_pos, 
-                                                     zft_deblock_buf,
-                                                     FT_WR_MULTI);
-                        if (result != this_segs_size) {
-                                TRACE(ft_t_err, "flush buffers failed");
-                                zft_pos.tape_pos    -= zft_pos.seg_byte_pos;
-                                zft_pos.seg_byte_pos = 0;
-
-                                last_write_failed = 1;
-                                TRACE_EXIT result;
-                        }
-                        zft_written_segments ++;
-                        TRACE(ft_t_data_flow,
-                              "flush, moved out buffer: %d", result);
-                        /* need next segment for more data (empty segments?)
-                         */
-                        if (result < data_remaining) { 
-                                if (result > 0) {       
-                                        /* move remainder to buffer beginning 
-                                         */
-                                        memmove(zft_deblock_buf, 
-                                                zft_deblock_buf + result,
-                                                FT_SEGMENT_SIZE - result);
-                                }
-                        } 
-                        data_remaining -= result;
-                        zft_pos.seg_pos ++;
-                } while (data_remaining > 0);
-                TRACE(ft_t_any, "result: %d", result);
-                zft_deblock_segment = --zft_pos.seg_pos;
-                if (data_remaining == 0) {  /* first byte next segment */
-                        zft_pos.seg_byte_pos = this_segs_size;
-                } else { /* after data previous segment, data_remaining < 0 */
-                        zft_pos.seg_byte_pos = data_remaining + result;
-                }
-        } else {
-                TRACE(ft_t_noise, "zft_deblock_buf empty");
-                zft_pos.seg_pos --;
-                zft_pos.seg_byte_pos = zft_get_seg_sz (zft_pos.seg_pos);
-                ftape_start_writing(FT_WR_MULTI);
-        }
-        TRACE(ft_t_any, "waiting");
-        if ((result = ftape_loop_until_writes_done()) < 0) {
-                /* that's really bad. What to to with zft_tape_pos? 
-                 */
-                TRACE(ft_t_err, "flush buffers failed");
-        }
-        TRACE(ft_t_any, "zft_seg_pos: %d, zft_seg_byte_pos: %d",
-              zft_pos.seg_pos, zft_pos.seg_byte_pos);
-        last_write_failed  =
-                need_flush = 0;
-        TRACE_EXIT result;
-}
-
-/* return-value: the number of bytes removed from the user-buffer
- *
- * out: 
- *      int *write_cnt: how much actually has been moved to the
- *                      zft_deblock_buf
- *      int req_len  : MUST NOT BE CHANGED, except at EOT, in 
- *                      which case it may be adjusted
- * in : 
- *      char *buff        : the user buffer
- *      int buf_pos_write : copy of buf_len_wr int
- *      this_segs_size    : the size in bytes of the actual segment
- *                          char
- *      *zft_deblock_buf   : zft_deblock_buf
- */
-static int zft_simple_write(int *cnt,
-                            __u8 *dst_buf, const int seg_sz,
-                            const __u8 __user *src_buf, const int req_len, 
-                            const zft_position *pos,const zft_volinfo *volume)
-{
-        int space_left;
-        TRACE_FUN(ft_t_flow);
-
-        /* volume->size holds the tape capacity while volume is open */
-        if (pos->tape_pos + volume->blk_sz > volume->size) {
-                TRACE_EXIT -ENOSPC;
-        }
-        /*  remaining space in this segment, NOT zft_deblock_buf
-         */
-        space_left = seg_sz - pos->seg_byte_pos;
-        *cnt = req_len < space_left ? req_len : space_left;
-        if (copy_from_user(dst_buf + pos->seg_byte_pos, src_buf, *cnt) != 0) {
-                TRACE_EXIT -EFAULT;
-        }
-        TRACE_EXIT *cnt;
-}
-
-static int check_write_access(int req_len,
-                              const zft_volinfo **volume,
-                              zft_position *pos,
-                              const unsigned int blk_sz)
-{
-        int result;
-        TRACE_FUN(ft_t_flow);
-
-        if ((req_len % zft_blk_sz) != 0) {
-                TRACE_ABORT(-EINVAL, ft_t_info,
-                            "write-count %d must be multiple of block-size %d",
-                            req_len, blk_sz);
-        }
-        if (zft_io_state == zft_writing) {
-                /*  all other error conditions have been checked earlier
-                 */
-                TRACE_EXIT 0;
-        }
-        zft_io_state = zft_idle;
-        TRACE_CATCH(zft_check_write_access(pos),);
-        /*  If we haven't read the header segment yet, do it now.
-         *  This will verify the configuration, get the bad sector
-         *  table and read the volume table segment 
-         */
-        if (!zft_header_read) {
-                TRACE_CATCH(zft_read_header_segments(),);
-        }
-        /*  fine. Now the tape is either at BOT or at EOD,
-         *  Write start of volume now
-         */
-        TRACE_CATCH(zft_open_volume(pos, blk_sz, zft_use_compression),);
-        *volume = zft_find_volume(pos->seg_pos);
-        DUMP_VOLINFO(ft_t_noise, "", *volume);
-        zft_just_before_eof = 0;
-        /* now merge with old data if necessary */
-        if (!zft_qic_mode && pos->seg_byte_pos != 0){
-                result = zft_fetch_segment(pos->seg_pos,
-                                           zft_deblock_buf,
-                                           FT_RD_SINGLE);
-                if (result < 0) {
-                        if (result == -EINTR || result == -ENOSPC) {
-                                TRACE_EXIT result;
-                        }
-                        TRACE(ft_t_noise, 
-                              "ftape_read_segment() result: %d. "
-                              "This might be normal when using "
-                              "a newly\nformatted tape", result);
-                        memset(zft_deblock_buf, '\0', pos->seg_byte_pos);
-                }
-        }
-        zft_io_state = zft_writing;
-        TRACE_EXIT 0;
-}
-
-static int fill_deblock_buf(__u8 *dst_buf, const int seg_sz,
-                            zft_position *pos, const zft_volinfo *volume,
-                            const char __user *usr_buf, const int req_len)
-{
-        int cnt = 0;
-        int result = 0;
-        TRACE_FUN(ft_t_flow);
-
-        if (seg_sz == 0) {
-                TRACE_ABORT(0, ft_t_data_flow, "empty segment");
-        }
-        TRACE(ft_t_data_flow, "\n"
-              KERN_INFO "remaining req_len: %d\n"
-              KERN_INFO "          buf_pos: %d", 
-              req_len, pos->seg_byte_pos);
-        /* zft_deblock_buf will not contain a valid segment any longer */
-        zft_deblock_segment = -1;
-        if (zft_use_compression) {
-                TRACE_CATCH(zft_cmpr_lock(1 /* try to load */),);
-                TRACE_CATCH(result= (*zft_cmpr_ops->write)(&cnt,
-                                                           dst_buf, seg_sz,
-                                                           usr_buf, req_len,
-                                                           pos, volume),);
-        } else {
-                TRACE_CATCH(result= zft_simple_write(&cnt,
-                                                     dst_buf, seg_sz,
-                                                     usr_buf, req_len,
-                                                     pos, volume),);
-        }
-        pos->volume_pos   += result;
-        pos->seg_byte_pos += cnt;
-        pos->tape_pos     += cnt;
-        TRACE(ft_t_data_flow, "\n"
-              KERN_INFO "removed from user-buffer : %d bytes.\n"
-              KERN_INFO "copied to zft_deblock_buf: %d bytes.\n"
-              KERN_INFO "zft_tape_pos             : " LL_X " bytes.",
-              result, cnt, LL(pos->tape_pos));
-        TRACE_EXIT result;
-}
-
-
-/*  called by the kernel-interface routine "zft_write()"
- */
-int _zft_write(const char __user *buff, int req_len)
-{
-        int result = 0;
-        int written = 0;
-        int write_cnt;
-        int seg_sz;
-        static const zft_volinfo *volume = NULL;
-        TRACE_FUN(ft_t_flow);
-        
-        zft_resid         = req_len;    
-        last_write_failed = 1; /* reset to 0 when successful */
-        /* check if write is allowed 
-         */
-        TRACE_CATCH(check_write_access(req_len, &volume,&zft_pos,zft_blk_sz),);
-        while (req_len > 0) {
-                /* Allow us to escape from this loop with a signal !
-                 */
-                FT_SIGNAL_EXIT(_DONT_BLOCK);
-                seg_sz = zft_get_seg_sz(zft_pos.seg_pos);
-                if ((write_cnt = fill_deblock_buf(zft_deblock_buf,
-                                                  seg_sz,
-                                                  &zft_pos,
-                                                  volume,
-                                                  buff,
-                                                  req_len)) < 0) {
-                        zft_resid -= written;
-                        if (write_cnt == -ENOSPC) {
-                                /* leave the remainder to flush_buffers()
-                                 */
-                                TRACE(ft_t_info, "No space left on device");
-                                last_write_failed = 0;
-                                if (!need_flush) {
-                                        need_flush = written > 0;
-                                }
-                                TRACE_EXIT written > 0 ? written : -ENOSPC;
-                        } else {
-                                TRACE_EXIT result;
-                        }
-                }
-                if (zft_pos.seg_byte_pos == seg_sz) {
-                        TRACE_CATCH(ftape_write_segment(zft_pos.seg_pos, 
-                                                        zft_deblock_buf,
-                                                        FT_WR_ASYNC),
-                                    zft_resid -= written);
-                        zft_written_segments ++;
-                        zft_pos.seg_byte_pos =  0;
-                        zft_deblock_segment  = zft_pos.seg_pos;
-                        ++zft_pos.seg_pos;
-                }
-                written += write_cnt;
-                buff    += write_cnt;
-                req_len -= write_cnt;
-        } /* while (req_len > 0) */
-        TRACE(ft_t_data_flow, "remaining in blocking buffer: %d",
-               zft_pos.seg_byte_pos);
-        TRACE(ft_t_data_flow, "just written bytes: %d", written);
-        last_write_failed = 0;
-        zft_resid -= written;
-        need_flush = need_flush || written > 0;
-        TRACE_EXIT written;               /* bytes written */
-}
diff --git a/drivers/char/ftape/zftape/zftape-write.h b/drivers/char/ftape/zftape/zftape-write.h
deleted file mode 100644
index ea887015b493..000000000000
--- a/drivers/char/ftape/zftape/zftape-write.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#ifndef _ZFTAPE_WRITE_H
-#define _ZFTAPE_WRITE_H
-
-/*
- * Copyright (C) 1996, 1997 Claus-Justus Heine
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/zftape/zftape-write.h,v $
- * $Revision: 1.2 $
- * $Date: 1997/10/05 19:19:13 $
- *
- *      This file contains the definitions for the write functions
- *      for the zftape driver for Linux.
- *
- */
-
-extern int  zft_flush_buffers(void);
-extern int  zft_update_header_segments(void);
-extern void zft_prevent_flush(void);
-
-/*  hook for the VFS interface 
- */
-extern int _zft_write(const char __user *buff, int req_len);
-#endif /* _ZFTAPE_WRITE_H */
diff --git a/drivers/char/ftape/zftape/zftape_syms.c b/drivers/char/ftape/zftape/zftape_syms.c
deleted file mode 100644
index 2db1401682df..000000000000
--- a/drivers/char/ftape/zftape/zftape_syms.c
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- *      Copyright (C) 1997 Claus-Justus Heine
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; see the file COPYING.  If not, write to
- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- *
- * $Source: /homes/cvs/ftape-stacked/ftape/zftape/zftape_syms.c,v $
- * $Revision: 1.3 $
- * $Date: 1997/10/05 19:19:14 $
- *
- *      This file contains the symbols that the zftape frontend to 
- *      the ftape floppy tape driver exports 
- */              
-
-#include <linux/module.h>
-
-#include <linux/zftape.h>
-
-#include "../zftape/zftape-init.h"
-#include "../zftape/zftape-read.h"
-#include "../zftape/zftape-buffers.h"
-#include "../zftape/zftape-ctl.h"
-
-/* zftape-init.c */
-EXPORT_SYMBOL(zft_cmpr_register);
-/* zftape-read.c */
-EXPORT_SYMBOL(zft_fetch_segment_fraction);
-/* zftape-buffers.c */
-EXPORT_SYMBOL(zft_vmalloc_once);
-EXPORT_SYMBOL(zft_vmalloc_always);
-EXPORT_SYMBOL(zft_vfree);
diff --git a/drivers/char/generic_serial.c b/drivers/char/generic_serial.c
index 5e59c0b42731..e769811e7417 100644
--- a/drivers/char/generic_serial.c
+++ b/drivers/char/generic_serial.c
@@ -33,8 +33,6 @@
 
 #define DEBUG 
 
-static char *                  tmp_buf; 
-
 static int gs_debug;
 
 #ifdef DEBUG
@@ -205,7 +203,7 @@ int gs_write(struct tty_struct * tty,
         if (!tty) return -EIO;
 
         port = tty->driver_data;
-        if (!port || !port->xmit_buf || !tmp_buf)
+        if (!port || !port->xmit_buf)
                 return -EIO;
 
         local_save_flags(flags);
@@ -720,11 +718,11 @@ static unsigned int     gs_baudrates[] = {
 
 
 void gs_set_termios (struct tty_struct * tty, 
-                     struct termios * old_termios)
+                     struct ktermios * old_termios)
 {
         struct gs_port *port;
         int baudrate, tmp, rv;
-        struct termios *tiosp;
+        struct ktermios *tiosp;
 
         func_enter();
 
@@ -746,11 +744,9 @@ void gs_set_termios (struct tty_struct * tty,
                 gs_dprintk (GS_DEBUG_TERMIOS, "termios structure (%p):\n", tiosp);
         }
 
-#if 0
         /* This is an optimization that is only allowed for dumb cards */
         /* Smart cards require knowledge of iflags and oflags too: that 
            might change hardware cooking mode.... */
-#endif
         if (old_termios) {
                 if(   (tiosp->c_iflag == old_termios->c_iflag)
                    && (tiosp->c_oflag == old_termios->c_oflag)
@@ -774,14 +770,7 @@ void gs_set_termios (struct tty_struct * tty,
                 if(!memcmp(tiosp->c_cc, old_termios->c_cc, NCC)) printk("c_cc changed\n");
         }
 
-        baudrate = tiosp->c_cflag & CBAUD;
-        if (baudrate & CBAUDEX) {
-                baudrate &= ~CBAUDEX;
-                if ((baudrate < 1) || (baudrate > 4))
-                        tiosp->c_cflag &= ~CBAUDEX;
-                else
-                        baudrate += 15;
-        }
+        baudrate = tty_get_baud_rate(tty);
 
         baudrate = gs_baudrates[baudrate];
         if ((tiosp->c_cflag & CBAUD) == B38400) {
@@ -846,24 +835,9 @@ void gs_set_termios (struct tty_struct * tty,
 int gs_init_port(struct gs_port *port)
 {
         unsigned long flags;
-        unsigned long page;
 
         func_enter ();
 
-        if (!tmp_buf) {
-                page = get_zeroed_page(GFP_KERNEL);
-                spin_lock_irqsave (&port->driver_lock, flags); /* Don't expect this to make a difference. */
-                if (tmp_buf)
-                        free_page(page);
-                else
-                        tmp_buf = (unsigned char *) page;
-                spin_unlock_irqrestore (&port->driver_lock, flags);
-                if (!tmp_buf) {
-                        func_exit ();
-                        return -ENOMEM;
-                }
-        }
-
         if (port->flags & ASYNC_INITIALIZED) {
                 func_exit ();
                 return 0;
diff --git a/drivers/char/genrtc.c b/drivers/char/genrtc.c
index 817dc409ac20..23b25ada65ea 100644
--- a/drivers/char/genrtc.c
+++ b/drivers/char/genrtc.c
@@ -102,7 +102,7 @@ static void gen_rtc_interrupt(unsigned long arg);
  * Routine to poll RTC seconds field for change as often as possible,
  * after first RTC_UIE use timer to reduce polling
  */
-static void genrtc_troutine(void *data)
+static void genrtc_troutine(struct work_struct *work)
 {
         unsigned int tmp = get_rtc_ss();
         
@@ -255,7 +255,7 @@ static inline int gen_set_rtc_irq_bit(unsigned char bit)
                 irq_active = 1;
                 stop_rtc_timers = 0;
                 lostint = 0;
-                INIT_WORK(&genrtc_task, genrtc_troutine, NULL);
+                INIT_WORK(&genrtc_task, genrtc_troutine);
                 oldsecs = get_rtc_ss();
                 init_timer(&timer_task);
 
diff --git a/drivers/char/hangcheck-timer.c b/drivers/char/hangcheck-timer.c
index d69f2ad9a67d..1aa93a752a9c 100644
--- a/drivers/char/hangcheck-timer.c
+++ b/drivers/char/hangcheck-timer.c
@@ -159,7 +159,7 @@ static void hangcheck_fire(unsigned long data)
                 if (hangcheck_dump_tasks) {
                         printk(KERN_CRIT "Hangcheck: Task state:\n");
 #ifdef CONFIG_MAGIC_SYSRQ
-                        handle_sysrq('t', NULL, NULL);
+                        handle_sysrq('t', NULL);
 #endif  /* CONFIG_MAGIC_SYSRQ */
                 }
                 if (hangcheck_reboot) {
diff --git a/drivers/char/hpet.c b/drivers/char/hpet.c
index 58b0eb581114..20dc3be5ecfc 100644
--- a/drivers/char/hpet.c
+++ b/drivers/char/hpet.c
@@ -21,6 +21,7 @@
 #include <linux/fcntl.h>
 #include <linux/init.h>
 #include <linux/poll.h>
+#include <linux/mm.h>
 #include <linux/proc_fs.h>
 #include <linux/spinlock.h>
 #include <linux/sysctl.h>
@@ -116,7 +117,7 @@ static inline void writeq(unsigned long long v, void __iomem *addr)
 }
 #endif
 
-static irqreturn_t hpet_interrupt(int irq, void *data, struct pt_regs *regs)
+static irqreturn_t hpet_interrupt(int irq, void *data)
 {
         struct hpet_dev *devp;
         unsigned long isr;
diff --git a/drivers/char/hvc_console.c b/drivers/char/hvc_console.c
index a76d2c40dd5e..cc2cd46bedc6 100644
--- a/drivers/char/hvc_console.c
+++ b/drivers/char/hvc_console.c
@@ -38,6 +38,7 @@
 #include <linux/sched.h>
 #include <linux/spinlock.h>
 #include <linux/delay.h>
+#include <linux/freezer.h>
 
 #include <asm/uaccess.h>
 
@@ -294,7 +295,7 @@ static int hvc_poll(struct hvc_struct *hp);
  * NOTE: This API isn't used if the console adapter doesn't support interrupts.
  * In this case the console is poll driven.
  */
-static irqreturn_t hvc_handle_interrupt(int irq, void *dev_instance, struct pt_regs *regs)
+static irqreturn_t hvc_handle_interrupt(int irq, void *dev_instance)
 {
         /* if hvc_poll request a repoll, then kick the hvcd thread */
         if (hvc_poll(dev_instance))
@@ -621,7 +622,7 @@ static int hvc_poll(struct hvc_struct *hp)
                                         sysrq_pressed = 1;
                                         continue;
                                 } else if (sysrq_pressed) {
-                                        handle_sysrq(buf[i], NULL, tty);
+                                        handle_sysrq(buf[i], tty);
                                         sysrq_pressed = 0;
                                         continue;
                                 }
@@ -696,7 +697,7 @@ int khvcd(void *unused)
         return 0;
 }
 
-static struct tty_operations hvc_ops = {
+static const struct tty_operations hvc_ops = {
         .open = hvc_open,
         .close = hvc_close,
         .write = hvc_write,
diff --git a/drivers/char/hvc_iseries.c b/drivers/char/hvc_iseries.c
index 4747729459c7..f144a947bd17 100644
--- a/drivers/char/hvc_iseries.c
+++ b/drivers/char/hvc_iseries.c
@@ -29,6 +29,7 @@
 #include <asm/hvconsole.h>
 #include <asm/vio.h>
 #include <asm/prom.h>
+#include <asm/firmware.h>
 #include <asm/iseries/vio.h>
 #include <asm/iseries/hv_call.h>
 #include <asm/iseries/hv_lp_config.h>
@@ -153,9 +154,7 @@ static int put_chars(uint32_t vtermno, const char *buf, int count)
         spin_lock_irqsave(&consolelock, flags);
 
         if (viochar_is_console(pi) && !viopath_isactive(pi->lp)) {
-                spin_lock_irqsave(&consoleloglock, flags);
                 HvCall_writeLogBuffer(buf, count);
-                spin_unlock_irqrestore(&consoleloglock, flags);
                 sent = count;
                 goto done;
         }
@@ -171,11 +170,8 @@ static int put_chars(uint32_t vtermno, const char *buf, int count)
 
                 len = (count > VIOCHAR_MAX_DATA) ? VIOCHAR_MAX_DATA : count;
 
-                if (viochar_is_console(pi)) {
-                        spin_lock_irqsave(&consoleloglock, flags);
+                if (viochar_is_console(pi))
                         HvCall_writeLogBuffer(buf, len);
-                        spin_unlock_irqrestore(&consoleloglock, flags);
-                }
 
                 init_data_event(viochar, pi->lp);
 
@@ -493,6 +489,9 @@ static int hvc_vio_init(void)
         atomic_t wait_flag;
         int rc;
 
+        if (!firmware_has_feature(FW_FEATURE_ISERIES))
+                return -EIO;
+
         /* +2 for fudge */
         rc = viopath_open(HvLpConfig_getPrimaryLpIndex(),
                         viomajorsubtype_chario, VIOCHAR_WINDOW + 2);
@@ -567,7 +566,7 @@ static int hvc_find_vtys(void)
 
         for (vty = of_find_node_by_name(NULL, "vty"); vty != NULL;
                         vty = of_find_node_by_name(vty, "vty")) {
-                uint32_t *vtermno;
+                const uint32_t *vtermno;
 
                 /* We have statically defined space for only a certain number
                  * of console adapters.
@@ -576,7 +575,7 @@ static int hvc_find_vtys(void)
                                 (num_found >= VTTY_PORTS))
                         break;
 
-                vtermno = (uint32_t *)get_property(vty, "reg", NULL);
+                vtermno = get_property(vty, "reg", NULL);
                 if (!vtermno)
                         continue;
 
diff --git a/drivers/char/hvc_vio.c b/drivers/char/hvc_vio.c
index cc95941148fb..f9c00844d2bf 100644
--- a/drivers/char/hvc_vio.c
+++ b/drivers/char/hvc_vio.c
@@ -35,6 +35,7 @@
 #include <asm/hvconsole.h>
 #include <asm/vio.h>
 #include <asm/prom.h>
+#include <asm/firmware.h>
 
 #include "hvc_console.h"
 
@@ -120,6 +121,9 @@ static int hvc_vio_init(void)
 {
         int rc;
 
+        if (firmware_has_feature(FW_FEATURE_ISERIES))
+                return -EIO;
+
         /* Register as a vio device to receive callbacks */
         rc = vio_register_driver(&hvc_vio_driver);
 
diff --git a/drivers/char/hvcs.c b/drivers/char/hvcs.c
index 4589ff302b07..207f7343ba60 100644
--- a/drivers/char/hvcs.c
+++ b/drivers/char/hvcs.c
@@ -192,11 +192,13 @@ MODULE_VERSION(HVCS_DRIVER_VERSION);
  * that will cause echoing or we'll go into recursive loop echoing chars back
  * and forth with the console drivers.
  */
-static struct termios hvcs_tty_termios = {
+static struct ktermios hvcs_tty_termios = {
         .c_iflag = IGNBRK | IGNPAR,
         .c_oflag = OPOST,
         .c_cflag = B38400 | CS8 | CREAD | HUPCL,
-        .c_cc = INIT_C_CC
+        .c_cc = INIT_C_CC,
+        .c_ispeed = 38400,
+        .c_ospeed = 38400
 };
 
 /*
@@ -313,8 +315,7 @@ static DEFINE_SPINLOCK(hvcs_structs_lock);
 
 static void hvcs_unthrottle(struct tty_struct *tty);
 static void hvcs_throttle(struct tty_struct *tty);
-static irqreturn_t hvcs_handle_interrupt(int irq, void *dev_instance,
-                struct pt_regs *regs);
+static irqreturn_t hvcs_handle_interrupt(int irq, void *dev_instance);
 
 static int hvcs_write(struct tty_struct *tty,
                 const unsigned char *buf, int count);
@@ -338,11 +339,6 @@ static int hvcs_open(struct tty_struct *tty, struct file *filp);
 static void hvcs_close(struct tty_struct *tty, struct file *filp);
 static void hvcs_hangup(struct tty_struct * tty);
 
-static void hvcs_create_device_attrs(struct hvcs_struct *hvcsd);
-static void hvcs_remove_device_attrs(struct vio_dev *vdev);
-static void hvcs_create_driver_attrs(void);
-static void hvcs_remove_driver_attrs(void);
-
 static int __devinit hvcs_probe(struct vio_dev *dev,
                 const struct vio_device_id *id);
 static int __devexit hvcs_remove(struct vio_dev *dev);
@@ -354,6 +350,172 @@ static void __exit hvcs_module_exit(void);
 #define HVCS_TRY_WRITE  0x00000004
 #define HVCS_READ_MASK  (HVCS_SCHED_READ | HVCS_QUICK_READ)
 
+static inline struct hvcs_struct *from_vio_dev(struct vio_dev *viod)
+{
+        return viod->dev.driver_data;
+}
+/* The sysfs interface for the driver and devices */
+
+static ssize_t hvcs_partner_vtys_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct vio_dev *viod = to_vio_dev(dev);
+        struct hvcs_struct *hvcsd = from_vio_dev(viod);
+        unsigned long flags;
+        int retval;
+
+        spin_lock_irqsave(&hvcsd->lock, flags);
+        retval = sprintf(buf, "%X\n", hvcsd->p_unit_address);
+        spin_unlock_irqrestore(&hvcsd->lock, flags);
+        return retval;
+}
+static DEVICE_ATTR(partner_vtys, S_IRUGO, hvcs_partner_vtys_show, NULL);
+
+static ssize_t hvcs_partner_clcs_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct vio_dev *viod = to_vio_dev(dev);
+        struct hvcs_struct *hvcsd = from_vio_dev(viod);
+        unsigned long flags;
+        int retval;
+
+        spin_lock_irqsave(&hvcsd->lock, flags);
+        retval = sprintf(buf, "%s\n", &hvcsd->p_location_code[0]);
+        spin_unlock_irqrestore(&hvcsd->lock, flags);
+        return retval;
+}
+static DEVICE_ATTR(partner_clcs, S_IRUGO, hvcs_partner_clcs_show, NULL);
+
+static ssize_t hvcs_current_vty_store(struct device *dev, struct device_attribute *attr, const char * buf,
+                size_t count)
+{
+        /*
+         * Don't need this feature at the present time because firmware doesn't
+         * yet support multiple partners.
+         */
+        printk(KERN_INFO "HVCS: Denied current_vty change: -EPERM.\n");
+        return -EPERM;
+}
+
+static ssize_t hvcs_current_vty_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct vio_dev *viod = to_vio_dev(dev);
+        struct hvcs_struct *hvcsd = from_vio_dev(viod);
+        unsigned long flags;
+        int retval;
+
+        spin_lock_irqsave(&hvcsd->lock, flags);
+        retval = sprintf(buf, "%s\n", &hvcsd->p_location_code[0]);
+        spin_unlock_irqrestore(&hvcsd->lock, flags);
+        return retval;
+}
+
+static DEVICE_ATTR(current_vty,
+        S_IRUGO | S_IWUSR, hvcs_current_vty_show, hvcs_current_vty_store);
+
+static ssize_t hvcs_vterm_state_store(struct device *dev, struct device_attribute *attr, const char *buf,
+                size_t count)
+{
+        struct vio_dev *viod = to_vio_dev(dev);
+        struct hvcs_struct *hvcsd = from_vio_dev(viod);
+        unsigned long flags;
+
+        /* writing a '0' to this sysfs entry will result in the disconnect. */
+        if (simple_strtol(buf, NULL, 0) != 0)
+                return -EINVAL;
+
+        spin_lock_irqsave(&hvcsd->lock, flags);
+
+        if (hvcsd->open_count > 0) {
+                spin_unlock_irqrestore(&hvcsd->lock, flags);
+                printk(KERN_INFO "HVCS: vterm state unchanged.  "
+                                "The hvcs device node is still in use.\n");
+                return -EPERM;
+        }
+
+        if (hvcsd->connected == 0) {
+                spin_unlock_irqrestore(&hvcsd->lock, flags);
+                printk(KERN_INFO "HVCS: vterm state unchanged. The"
+                                " vty-server is not connected to a vty.\n");
+                return -EPERM;
+        }
+
+        hvcs_partner_free(hvcsd);
+        printk(KERN_INFO "HVCS: Closed vty-server@%X and"
+                        " partner vty@%X:%d connection.\n",
+                        hvcsd->vdev->unit_address,
+                        hvcsd->p_unit_address,
+                        (uint32_t)hvcsd->p_partition_ID);
+
+        spin_unlock_irqrestore(&hvcsd->lock, flags);
+        return count;
+}
+
+static ssize_t hvcs_vterm_state_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct vio_dev *viod = to_vio_dev(dev);
+        struct hvcs_struct *hvcsd = from_vio_dev(viod);
+        unsigned long flags;
+        int retval;
+
+        spin_lock_irqsave(&hvcsd->lock, flags);
+        retval = sprintf(buf, "%d\n", hvcsd->connected);
+        spin_unlock_irqrestore(&hvcsd->lock, flags);
+        return retval;
+}
+static DEVICE_ATTR(vterm_state, S_IRUGO | S_IWUSR,
+                hvcs_vterm_state_show, hvcs_vterm_state_store);
+
+static ssize_t hvcs_index_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct vio_dev *viod = to_vio_dev(dev);
+        struct hvcs_struct *hvcsd = from_vio_dev(viod);
+        unsigned long flags;
+        int retval;
+
+        spin_lock_irqsave(&hvcsd->lock, flags);
+        retval = sprintf(buf, "%d\n", hvcsd->index);
+        spin_unlock_irqrestore(&hvcsd->lock, flags);
+        return retval;
+}
+
+static DEVICE_ATTR(index, S_IRUGO, hvcs_index_show, NULL);
+
+static struct attribute *hvcs_attrs[] = {
+        &dev_attr_partner_vtys.attr,
+        &dev_attr_partner_clcs.attr,
+        &dev_attr_current_vty.attr,
+        &dev_attr_vterm_state.attr,
+        &dev_attr_index.attr,
+        NULL,
+};
+
+static struct attribute_group hvcs_attr_group = {
+        .attrs = hvcs_attrs,
+};
+
+static ssize_t hvcs_rescan_show(struct device_driver *ddp, char *buf)
+{
+        /* A 1 means it is updating, a 0 means it is done updating */
+        return snprintf(buf, PAGE_SIZE, "%d\n", hvcs_rescan_status);
+}
+
+static ssize_t hvcs_rescan_store(struct device_driver *ddp, const char * buf,
+                size_t count)
+{
+        if ((simple_strtol(buf, NULL, 0) != 1)
+                && (hvcs_rescan_status != 0))
+                return -EINVAL;
+
+        hvcs_rescan_status = 1;
+        printk(KERN_INFO "HVCS: rescanning partner info for all"
+                " vty-servers.\n");
+        hvcs_rescan_devices_list();
+        hvcs_rescan_status = 0;
+        return count;
+}
+
+static DRIVER_ATTR(rescan,
+        S_IRUGO | S_IWUSR, hvcs_rescan_show, hvcs_rescan_store);
+
 static void hvcs_kick(void)
 {
         hvcs_kicked = 1;
@@ -387,8 +549,7 @@ static void hvcs_throttle(struct tty_struct *tty)
  * handler taking any further interrupts because they are disabled which means
  * the hvcs_struct will always be valid in this handler.
  */
-static irqreturn_t hvcs_handle_interrupt(int irq, void *dev_instance,
-                struct pt_regs *regs)
+static irqreturn_t hvcs_handle_interrupt(int irq, void *dev_instance)
 {
         struct hvcs_struct *hvcsd = dev_instance;
 
@@ -577,7 +738,7 @@ static void destroy_hvcs_struct(struct kobject *kobj)
         spin_unlock_irqrestore(&hvcsd->lock, flags);
         spin_unlock(&hvcs_structs_lock);
 
-        hvcs_remove_device_attrs(vdev);
+        sysfs_remove_group(&vdev->dev.kobj, &hvcs_attr_group);
 
         kfree(hvcsd);
 }
@@ -610,6 +771,7 @@ static int __devinit hvcs_probe(
 {
         struct hvcs_struct *hvcsd;
         int index;
+        int retval;
 
         if (!dev || !id) {
                 printk(KERN_ERR "HVCS: probed with invalid parameter.\n");
@@ -660,14 +822,16 @@ static int __devinit hvcs_probe(
          * the hvcs_struct has been added to the devices list then the user app
          * will get -ENODEV.
          */
-
         spin_lock(&hvcs_structs_lock);
-
         list_add_tail(&(hvcsd->next), &hvcs_structs);
-
         spin_unlock(&hvcs_structs_lock);
 
-        hvcs_create_device_attrs(hvcsd);
+        retval = sysfs_create_group(&dev->dev.kobj, &hvcs_attr_group);
+        if (retval) {
+                printk(KERN_ERR "HVCS: Can't create sysfs attrs for vty-server@%X\n",
+                       hvcsd->vdev->unit_address);
+                return retval;
+        }
 
         printk(KERN_INFO "HVCS: vty-server@%X added to the vio bus.\n", dev->unit_address);
 
@@ -1306,7 +1470,7 @@ static int hvcs_chars_in_buffer(struct tty_struct *tty)
         return hvcsd->chars_in_buffer;
 }
 
-static struct tty_operations hvcs_ops = {
+static const struct tty_operations hvcs_ops = {
         .open = hvcs_open,
         .close = hvcs_close,
         .hangup = hvcs_hangup,
@@ -1356,8 +1520,10 @@ static int __init hvcs_module_init(void)
         if (!hvcs_tty_driver)
                 return -ENOMEM;
 
-        if (hvcs_alloc_index_list(num_ttys_to_alloc))
-                return -ENOMEM;
+        if (hvcs_alloc_index_list(num_ttys_to_alloc)) {
+                rc = -ENOMEM;
+                goto index_fail;
+        }
 
         hvcs_tty_driver->owner = THIS_MODULE;
 
@@ -1387,41 +1553,57 @@ static int __init hvcs_module_init(void)
          * dynamically assigned major and minor numbers for our devices.
          */
         if (tty_register_driver(hvcs_tty_driver)) {
-                printk(KERN_ERR "HVCS: registration "
-                        " as a tty driver failed.\n");
-                hvcs_free_index_list();
-                put_tty_driver(hvcs_tty_driver);
-                return -EIO;
+                printk(KERN_ERR "HVCS: registration as a tty driver failed.\n");
+                rc = -EIO;
+                goto register_fail;
         }
 
         hvcs_pi_buff = kmalloc(PAGE_SIZE, GFP_KERNEL);
         if (!hvcs_pi_buff) {
-                tty_unregister_driver(hvcs_tty_driver);
-                hvcs_free_index_list();
-                put_tty_driver(hvcs_tty_driver);
-                return -ENOMEM;
+                rc = -ENOMEM;
+                goto buff_alloc_fail;
         }
 
         hvcs_task = kthread_run(khvcsd, NULL, "khvcsd");
         if (IS_ERR(hvcs_task)) {
                 printk(KERN_ERR "HVCS: khvcsd creation failed.  Driver not loaded.\n");
-                kfree(hvcs_pi_buff);
-                tty_unregister_driver(hvcs_tty_driver);
-                hvcs_free_index_list();
-                put_tty_driver(hvcs_tty_driver);
-                return -EIO;
+                rc = -EIO;
+                goto kthread_fail;
         }
 
         rc = vio_register_driver(&hvcs_vio_driver);
+        if (rc) {
+                printk(KERN_ERR "HVCS: can't register vio driver\n");
+                goto vio_fail;
+        }
 
         /*
          * This needs to be done AFTER the vio_register_driver() call or else
          * the kobjects won't be initialized properly.
          */
-        hvcs_create_driver_attrs();
+        rc = driver_create_file(&(hvcs_vio_driver.driver), &driver_attr_rescan);
+        if (rc) {
+                printk(KERN_ERR "HVCS: sysfs attr create failed\n");
+                goto attr_fail;
+        }
 
         printk(KERN_INFO "HVCS: driver module inserted.\n");
 
+        return 0;
+
+attr_fail:
+        vio_unregister_driver(&hvcs_vio_driver);
+vio_fail:
+        kthread_stop(hvcs_task);
+kthread_fail:
+        kfree(hvcs_pi_buff);
+buff_alloc_fail:
+        tty_unregister_driver(hvcs_tty_driver);
+register_fail:
+        hvcs_free_index_list();
+index_fail:
+        put_tty_driver(hvcs_tty_driver);
+        hvcs_tty_driver = NULL;
         return rc;
 }
 
@@ -1443,7 +1625,7 @@ static void __exit hvcs_module_exit(void)
         hvcs_pi_buff = NULL;
         spin_unlock(&hvcs_pi_lock);
 
-        hvcs_remove_driver_attrs();
+        driver_remove_file(&hvcs_vio_driver.driver, &driver_attr_rescan);
 
         vio_unregister_driver(&hvcs_vio_driver);
 
@@ -1458,191 +1640,3 @@ static void __exit hvcs_module_exit(void)
 
 module_init(hvcs_module_init);
 module_exit(hvcs_module_exit);
-
-static inline struct hvcs_struct *from_vio_dev(struct vio_dev *viod)
-{
-        return viod->dev.driver_data;
-}
-/* The sysfs interface for the driver and devices */
-
-static ssize_t hvcs_partner_vtys_show(struct device *dev, struct device_attribute *attr, char *buf)
-{
-        struct vio_dev *viod = to_vio_dev(dev);
-        struct hvcs_struct *hvcsd = from_vio_dev(viod);
-        unsigned long flags;
-        int retval;
-
-        spin_lock_irqsave(&hvcsd->lock, flags);
-        retval = sprintf(buf, "%X\n", hvcsd->p_unit_address);
-        spin_unlock_irqrestore(&hvcsd->lock, flags);
-        return retval;
-}
-static DEVICE_ATTR(partner_vtys, S_IRUGO, hvcs_partner_vtys_show, NULL);
-
-static ssize_t hvcs_partner_clcs_show(struct device *dev, struct device_attribute *attr, char *buf)
-{
-        struct vio_dev *viod = to_vio_dev(dev);
-        struct hvcs_struct *hvcsd = from_vio_dev(viod);
-        unsigned long flags;
-        int retval;
-
-        spin_lock_irqsave(&hvcsd->lock, flags);
-        retval = sprintf(buf, "%s\n", &hvcsd->p_location_code[0]);
-        spin_unlock_irqrestore(&hvcsd->lock, flags);
-        return retval;
-}
-static DEVICE_ATTR(partner_clcs, S_IRUGO, hvcs_partner_clcs_show, NULL);
-
-static ssize_t hvcs_current_vty_store(struct device *dev, struct device_attribute *attr, const char * buf,
-                size_t count)
-{
-        /*
-         * Don't need this feature at the present time because firmware doesn't
-         * yet support multiple partners.
-         */
-        printk(KERN_INFO "HVCS: Denied current_vty change: -EPERM.\n");
-        return -EPERM;
-}
-
-static ssize_t hvcs_current_vty_show(struct device *dev, struct device_attribute *attr, char *buf)
-{
-        struct vio_dev *viod = to_vio_dev(dev);
-        struct hvcs_struct *hvcsd = from_vio_dev(viod);
-        unsigned long flags;
-        int retval;
-
-        spin_lock_irqsave(&hvcsd->lock, flags);
-        retval = sprintf(buf, "%s\n", &hvcsd->p_location_code[0]);
-        spin_unlock_irqrestore(&hvcsd->lock, flags);
-        return retval;
-}
-
-static DEVICE_ATTR(current_vty,
-        S_IRUGO | S_IWUSR, hvcs_current_vty_show, hvcs_current_vty_store);
-
-static ssize_t hvcs_vterm_state_store(struct device *dev, struct device_attribute *attr, const char *buf,
-                size_t count)
-{
-        struct vio_dev *viod = to_vio_dev(dev);
-        struct hvcs_struct *hvcsd = from_vio_dev(viod);
-        unsigned long flags;
-
-        /* writing a '0' to this sysfs entry will result in the disconnect. */
-        if (simple_strtol(buf, NULL, 0) != 0)
-                return -EINVAL;
-
-        spin_lock_irqsave(&hvcsd->lock, flags);
-
-        if (hvcsd->open_count > 0) {
-                spin_unlock_irqrestore(&hvcsd->lock, flags);
-                printk(KERN_INFO "HVCS: vterm state unchanged.  "
-                                "The hvcs device node is still in use.\n");
-                return -EPERM;
-        }
-
-        if (hvcsd->connected == 0) {
-                spin_unlock_irqrestore(&hvcsd->lock, flags);
-                printk(KERN_INFO "HVCS: vterm state unchanged. The"
-                                " vty-server is not connected to a vty.\n");
-                return -EPERM;
-        }
-
-        hvcs_partner_free(hvcsd);
-        printk(KERN_INFO "HVCS: Closed vty-server@%X and"
-                        " partner vty@%X:%d connection.\n",
-                        hvcsd->vdev->unit_address,
-                        hvcsd->p_unit_address,
-                        (uint32_t)hvcsd->p_partition_ID);
-
-        spin_unlock_irqrestore(&hvcsd->lock, flags);
-        return count;
-}
-
-static ssize_t hvcs_vterm_state_show(struct device *dev, struct device_attribute *attr, char *buf)
-{
-        struct vio_dev *viod = to_vio_dev(dev);
-        struct hvcs_struct *hvcsd = from_vio_dev(viod);
-        unsigned long flags;
-        int retval;
-
-        spin_lock_irqsave(&hvcsd->lock, flags);
-        retval = sprintf(buf, "%d\n", hvcsd->connected);
-        spin_unlock_irqrestore(&hvcsd->lock, flags);
-        return retval;
-}
-static DEVICE_ATTR(vterm_state, S_IRUGO | S_IWUSR,
-                hvcs_vterm_state_show, hvcs_vterm_state_store);
-
-static ssize_t hvcs_index_show(struct device *dev, struct device_attribute *attr, char *buf)
-{
-        struct vio_dev *viod = to_vio_dev(dev);
-        struct hvcs_struct *hvcsd = from_vio_dev(viod);
-        unsigned long flags;
-        int retval;
-
-        spin_lock_irqsave(&hvcsd->lock, flags);
-        retval = sprintf(buf, "%d\n", hvcsd->index);
-        spin_unlock_irqrestore(&hvcsd->lock, flags);
-        return retval;
-}
-
-static DEVICE_ATTR(index, S_IRUGO, hvcs_index_show, NULL);
-
-static struct attribute *hvcs_attrs[] = {
-        &dev_attr_partner_vtys.attr,
-        &dev_attr_partner_clcs.attr,
-        &dev_attr_current_vty.attr,
-        &dev_attr_vterm_state.attr,
-        &dev_attr_index.attr,
-        NULL,
-};
-
-static struct attribute_group hvcs_attr_group = {
-        .attrs = hvcs_attrs,
-};
-
-static void hvcs_create_device_attrs(struct hvcs_struct *hvcsd)
-{
-        struct vio_dev *vdev = hvcsd->vdev;
-        sysfs_create_group(&vdev->dev.kobj, &hvcs_attr_group);
-}
-
-static void hvcs_remove_device_attrs(struct vio_dev *vdev)
-{
-        sysfs_remove_group(&vdev->dev.kobj, &hvcs_attr_group);
-}
-
-static ssize_t hvcs_rescan_show(struct device_driver *ddp, char *buf)
-{
-        /* A 1 means it is updating, a 0 means it is done updating */
-        return snprintf(buf, PAGE_SIZE, "%d\n", hvcs_rescan_status);
-}
-
-static ssize_t hvcs_rescan_store(struct device_driver *ddp, const char * buf,
-                size_t count)
-{
-        if ((simple_strtol(buf, NULL, 0) != 1)
-                && (hvcs_rescan_status != 0))
-                return -EINVAL;
-
-        hvcs_rescan_status = 1;
-        printk(KERN_INFO "HVCS: rescanning partner info for all"
-                " vty-servers.\n");
-        hvcs_rescan_devices_list();
-        hvcs_rescan_status = 0;
-        return count;
-}
-static DRIVER_ATTR(rescan,
-        S_IRUGO | S_IWUSR, hvcs_rescan_show, hvcs_rescan_store);
-
-static void hvcs_create_driver_attrs(void)
-{
-        struct device_driver *driverfs = &(hvcs_vio_driver.driver);
-        driver_create_file(driverfs, &driver_attr_rescan);
-}
-
-static void hvcs_remove_driver_attrs(void)
-{
-        struct device_driver *driverfs = &(hvcs_vio_driver.driver);
-        driver_remove_file(driverfs, &driver_attr_rescan);
-}
diff --git a/drivers/char/hvsi.c b/drivers/char/hvsi.c
index a89a95fb5e40..d7806834fc17 100644
--- a/drivers/char/hvsi.c
+++ b/drivers/char/hvsi.c
@@ -69,7 +69,7 @@
 #define __ALIGNED__     __attribute__((__aligned__(sizeof(long))))
 
 struct hvsi_struct {
-        struct work_struct writer;
+        struct delayed_work writer;
         struct work_struct handshaker;
         wait_queue_head_t emptyq; /* woken when outbuf is emptied */
         wait_queue_head_t stateq; /* woken when HVSI state changes */
@@ -406,7 +406,7 @@ static void hvsi_insert_chars(struct hvsi_struct *hp, const char *buf, int len)
                         hp->sysrq = 1;
                         continue;
                 } else if (hp->sysrq) {
-                        handle_sysrq(c, NULL, hp->tty);
+                        handle_sysrq(c, hp->tty);
                         hp->sysrq = 0;
                         continue;
                 }
@@ -555,7 +555,7 @@ static void hvsi_send_overflow(struct hvsi_struct *hp)
  * must get all pending data because we only get an irq on empty->non-empty
  * transition
  */
-static irqreturn_t hvsi_interrupt(int irq, void *arg, struct pt_regs *regs)
+static irqreturn_t hvsi_interrupt(int irq, void *arg)
 {
         struct hvsi_struct *hp = (struct hvsi_struct *)arg;
         struct tty_struct *flip;
@@ -616,7 +616,7 @@ static int __init poll_for_state(struct hvsi_struct *hp, int state)
         unsigned long end_jiffies = jiffies + HVSI_TIMEOUT;
 
         for (;;) {
-                hvsi_interrupt(hp->virq, (void *)hp, NULL); /* get pending data */
+                hvsi_interrupt(hp->virq, (void *)hp); /* get pending data */
 
                 if (hp->state == state)
                         return 0;
@@ -744,9 +744,10 @@ static int hvsi_handshake(struct hvsi_struct *hp)
         return 0;
 }
 
-static void hvsi_handshaker(void *arg)
+static void hvsi_handshaker(struct work_struct *work)
 {
-        struct hvsi_struct *hp = (struct hvsi_struct *)arg;
+        struct hvsi_struct *hp =
+                container_of(work, struct hvsi_struct, handshaker);
 
         if (hvsi_handshake(hp) >= 0)
                 return;
@@ -951,9 +952,10 @@ static void hvsi_push(struct hvsi_struct *hp)
 }
 
 /* hvsi_write_worker will keep rescheduling itself until outbuf is empty */
-static void hvsi_write_worker(void *arg)
+static void hvsi_write_worker(struct work_struct *work)
 {
-        struct hvsi_struct *hp = (struct hvsi_struct *)arg;
+        struct hvsi_struct *hp =
+                container_of(work, struct hvsi_struct, writer.work);
         unsigned long flags;
 #ifdef DEBUG
         static long start_j = 0;
@@ -1130,7 +1132,7 @@ static int hvsi_tiocmset(struct tty_struct *tty, struct file *file,
 }
 
 
-static struct tty_operations hvsi_ops = {
+static const struct tty_operations hvsi_ops = {
         .open = hvsi_open,
         .close = hvsi_close,
         .write = hvsi_write,
@@ -1159,6 +1161,8 @@ static int __init hvsi_init(void)
         hvsi_driver->type = TTY_DRIVER_TYPE_SYSTEM;
         hvsi_driver->init_termios = tty_std_termios;
         hvsi_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL;
+        hvsi_driver->init_termios.c_ispeed = 9600;
+        hvsi_driver->init_termios.c_ospeed = 9600;
         hvsi_driver->flags = TTY_DRIVER_REAL_RAW;
         tty_set_operations(hvsi_driver, &hvsi_ops);
 
@@ -1287,8 +1291,8 @@ static int __init hvsi_console_init(void)
                 }
 
                 hp = &hvsi_ports[hvsi_count];
-                INIT_WORK(&hp->writer, hvsi_write_worker, hp);
-                INIT_WORK(&hp->handshaker, hvsi_handshaker, hp);
+                INIT_DELAYED_WORK(&hp->writer, hvsi_write_worker);
+                INIT_WORK(&hp->handshaker, hvsi_handshaker);
                 init_waitqueue_head(&hp->emptyq);
                 init_waitqueue_head(&hp->stateq);
                 spin_lock_init(&hp->lock);
diff --git a/drivers/char/hw_random/Kconfig b/drivers/char/hw_random/Kconfig
index 9f7635f75178..5f3acd8e64b8 100644
--- a/drivers/char/hw_random/Kconfig
+++ b/drivers/char/hw_random/Kconfig
@@ -3,17 +3,20 @@
 #
 
 config HW_RANDOM
-        bool "Hardware Random Number Generator Core support"
-        default y
+        tristate "Hardware Random Number Generator Core support"
+        default m
         ---help---
           Hardware Random Number Generator Core infrastructure.
 
+          To compile this driver as a module, choose M here: the
+          module will be called rng-core.
+
           If unsure, say Y.
 
 config HW_RANDOM_INTEL
         tristate "Intel HW Random Number Generator support"
         depends on HW_RANDOM && (X86 || IA64) && PCI
-        default y
+        default HW_RANDOM
         ---help---
           This driver provides kernel-side support for the Random Number
           Generator hardware found on Intel i8xx-based motherboards.
@@ -26,7 +29,7 @@ config HW_RANDOM_INTEL
 config HW_RANDOM_AMD
         tristate "AMD HW Random Number Generator support"
         depends on HW_RANDOM && X86 && PCI
-        default y
+        default HW_RANDOM
         ---help---
           This driver provides kernel-side support for the Random Number
           Generator hardware found on AMD 76x-based motherboards.
@@ -39,7 +42,7 @@ config HW_RANDOM_AMD
 config HW_RANDOM_GEODE
         tristate "AMD Geode HW Random Number Generator support"
         depends on HW_RANDOM && X86 && PCI
-        default y
+        default HW_RANDOM
         ---help---
           This driver provides kernel-side support for the Random Number
           Generator hardware found on the AMD Geode LX.
@@ -52,7 +55,7 @@ config HW_RANDOM_GEODE
 config HW_RANDOM_VIA
         tristate "VIA HW Random Number Generator support"
         depends on HW_RANDOM && X86_32
-        default y
+        default HW_RANDOM
         ---help---
           This driver provides kernel-side support for the Random Number
           Generator hardware found on VIA based motherboards.
@@ -65,7 +68,7 @@ config HW_RANDOM_VIA
 config HW_RANDOM_IXP4XX
         tristate "Intel IXP4xx NPU HW Random Number Generator support"
         depends on HW_RANDOM && ARCH_IXP4XX
-        default y
+        default HW_RANDOM
         ---help---
           This driver provides kernel-side support for the Random
           Number Generator hardware found on the Intel IXP4xx NPU.
@@ -78,7 +81,7 @@ config HW_RANDOM_IXP4XX
 config HW_RANDOM_OMAP
         tristate "OMAP Random Number Generator support"
         depends on HW_RANDOM && (ARCH_OMAP16XX || ARCH_OMAP24XX)
-        default y
+        default HW_RANDOM
         ---help---
           This driver provides kernel-side support for the Random Number
           Generator hardware found on OMAP16xx and OMAP24xx multimedia
diff --git a/drivers/char/hw_random/Makefile b/drivers/char/hw_random/Makefile
index e263ae96f940..c41fa19454e3 100644
--- a/drivers/char/hw_random/Makefile
+++ b/drivers/char/hw_random/Makefile
@@ -2,7 +2,8 @@
 # Makefile for HW Random Number Generator (RNG) device drivers.
 #
 
-obj-$(CONFIG_HW_RANDOM) += core.o
+obj-$(CONFIG_HW_RANDOM) += rng-core.o
+rng-core-y := core.o
 obj-$(CONFIG_HW_RANDOM_INTEL) += intel-rng.o
 obj-$(CONFIG_HW_RANDOM_AMD) += amd-rng.o
 obj-$(CONFIG_HW_RANDOM_GEODE) += geode-rng.o
diff --git a/drivers/char/hw_random/core.c b/drivers/char/hw_random/core.c
index 154a81d328c1..26a860adcb38 100644
--- a/drivers/char/hw_random/core.c
+++ b/drivers/char/hw_random/core.c
@@ -36,6 +36,7 @@
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/fs.h>
+#include <linux/sched.h>
 #include <linux/init.h>
 #include <linux/miscdevice.h>
 #include <linux/delay.h>
@@ -162,7 +163,8 @@ static struct miscdevice rng_miscdev = {
 };
 
 
-static ssize_t hwrng_attr_current_store(struct class_device *class,
+static ssize_t hwrng_attr_current_store(struct device *dev,
+                                        struct device_attribute *attr,
                                         const char *buf, size_t len)
 {
         int err;
@@ -192,7 +194,8 @@ static ssize_t hwrng_attr_current_store(struct class_device *class,
         return err ? : len;
 }
 
-static ssize_t hwrng_attr_current_show(struct class_device *class,
+static ssize_t hwrng_attr_current_show(struct device *dev,
+                                       struct device_attribute *attr,
                                        char *buf)
 {
         int err;
@@ -210,7 +213,8 @@ static ssize_t hwrng_attr_current_show(struct class_device *class,
         return ret;
 }
 
-static ssize_t hwrng_attr_available_show(struct class_device *class,
+static ssize_t hwrng_attr_available_show(struct device *dev,
+                                         struct device_attribute *attr,
                                          char *buf)
 {
         int err;
@@ -234,20 +238,18 @@ static ssize_t hwrng_attr_available_show(struct class_device *class,
         return ret;
 }
 
-static CLASS_DEVICE_ATTR(rng_current, S_IRUGO | S_IWUSR,
-                         hwrng_attr_current_show,
-                         hwrng_attr_current_store);
-static CLASS_DEVICE_ATTR(rng_available, S_IRUGO,
-                         hwrng_attr_available_show,
-                         NULL);
+static DEVICE_ATTR(rng_current, S_IRUGO | S_IWUSR,
+                   hwrng_attr_current_show,
+                   hwrng_attr_current_store);
+static DEVICE_ATTR(rng_available, S_IRUGO,
+                   hwrng_attr_available_show,
+                   NULL);
 
 
 static void unregister_miscdev(void)
 {
-        class_device_remove_file(rng_miscdev.class,
-                                 &class_device_attr_rng_available);
-        class_device_remove_file(rng_miscdev.class,
-                                 &class_device_attr_rng_current);
+        device_remove_file(rng_miscdev.this_device, &dev_attr_rng_available);
+        device_remove_file(rng_miscdev.this_device, &dev_attr_rng_current);
         misc_deregister(&rng_miscdev);
 }
 
@@ -258,20 +260,19 @@ static int register_miscdev(void)
         err = misc_register(&rng_miscdev);
         if (err)
                 goto out;
-        err = class_device_create_file(rng_miscdev.class,
-                                       &class_device_attr_rng_current);
+        err = device_create_file(rng_miscdev.this_device,
+                                 &dev_attr_rng_current);
         if (err)
                 goto err_misc_dereg;
-        err = class_device_create_file(rng_miscdev.class,
-                                       &class_device_attr_rng_available);
+        err = device_create_file(rng_miscdev.this_device,
+                                 &dev_attr_rng_available);
         if (err)
                 goto err_remove_current;
 out:
         return err;
 
 err_remove_current:
-        class_device_remove_file(rng_miscdev.class,
-                                 &class_device_attr_rng_current);
+        device_remove_file(rng_miscdev.this_device, &dev_attr_rng_current);
 err_misc_dereg:
         misc_deregister(&rng_miscdev);
         goto out;
diff --git a/drivers/char/hw_random/intel-rng.c b/drivers/char/hw_random/intel-rng.c
index ccd7e7102234..8efbc9c0e545 100644
--- a/drivers/char/hw_random/intel-rng.c
+++ b/drivers/char/hw_random/intel-rng.c
@@ -50,6 +50,43 @@
 #define INTEL_RNG_ADDR_LEN                      3
 
 /*
+ * LPC bridge PCI config space registers
+ */
+#define FWH_DEC_EN1_REG_OLD                     0xe3
+#define FWH_DEC_EN1_REG_NEW                     0xd9 /* high byte of 16-bit register */
+#define FWH_F8_EN_MASK                          0x80
+
+#define BIOS_CNTL_REG_OLD                       0x4e
+#define BIOS_CNTL_REG_NEW                       0xdc
+#define BIOS_CNTL_WRITE_ENABLE_MASK             0x01
+#define BIOS_CNTL_LOCK_ENABLE_MASK              0x02
+
+/*
+ * Magic address at which Intel Firmware Hubs get accessed
+ */
+#define INTEL_FWH_ADDR                          0xffff0000
+#define INTEL_FWH_ADDR_LEN                      2
+
+/*
+ * Intel Firmware Hub command codes (write to any address inside the device)
+ */
+#define INTEL_FWH_RESET_CMD                     0xff /* aka READ_ARRAY */
+#define INTEL_FWH_READ_ID_CMD                   0x90
+
+/*
+ * Intel Firmware Hub Read ID command result addresses
+ */
+#define INTEL_FWH_MANUFACTURER_CODE_ADDRESS     0x000000
+#define INTEL_FWH_DEVICE_CODE_ADDRESS           0x000001
+
+/*
+ * Intel Firmware Hub Read ID command result values
+ */
+#define INTEL_FWH_MANUFACTURER_CODE             0x89
+#define INTEL_FWH_DEVICE_CODE_8M                0xac
+#define INTEL_FWH_DEVICE_CODE_4M                0xad
+
+/*
  * Data for PCI driver interface
  *
  * This data only exists for exporting the supported
@@ -58,12 +95,50 @@
  * want to register another driver on the same PCI id.
  */
 static const struct pci_device_id pci_tbl[] = {
-        { 0x8086, 0x2418, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },
-        { 0x8086, 0x2428, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },
-        { 0x8086, 0x2430, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },
-        { 0x8086, 0x2448, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },
-        { 0x8086, 0x244e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },
-        { 0x8086, 0x245e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },
+/* AA
+        { 0x8086, 0x2418, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, */
+        { 0x8086, 0x2410, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* AA */
+/* AB
+        { 0x8086, 0x2428, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, */
+        { 0x8086, 0x2420, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* AB */
+/* ??
+        { 0x8086, 0x2430, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, */
+/* BAM, CAM, DBM, FBM, GxM
+        { 0x8086, 0x2448, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, */
+        { 0x8086, 0x244c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* BAM */
+        { 0x8086, 0x248c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* CAM */
+        { 0x8086, 0x24cc, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* DBM */
+        { 0x8086, 0x2641, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* FBM */
+        { 0x8086, 0x27b9, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* GxM */
+        { 0x8086, 0x27bd, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* GxM DH */
+/* BA, CA, DB, Ex, 6300, Fx, 631x/632x, Gx
+        { 0x8086, 0x244e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, */
+        { 0x8086, 0x2440, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* BA */
+        { 0x8086, 0x2480, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* CA */
+        { 0x8086, 0x24c0, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* DB */
+        { 0x8086, 0x24d0, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* Ex */
+        { 0x8086, 0x25a1, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* 6300 */
+        { 0x8086, 0x2640, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* Fx */
+        { 0x8086, 0x2670, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* 631x/632x */
+        { 0x8086, 0x2671, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* 631x/632x */
+        { 0x8086, 0x2672, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* 631x/632x */
+        { 0x8086, 0x2673, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* 631x/632x */
+        { 0x8086, 0x2674, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* 631x/632x */
+        { 0x8086, 0x2675, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* 631x/632x */
+        { 0x8086, 0x2676, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* 631x/632x */
+        { 0x8086, 0x2677, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* 631x/632x */
+        { 0x8086, 0x2678, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* 631x/632x */
+        { 0x8086, 0x2679, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* 631x/632x */
+        { 0x8086, 0x267a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* 631x/632x */
+        { 0x8086, 0x267b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* 631x/632x */
+        { 0x8086, 0x267c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* 631x/632x */
+        { 0x8086, 0x267d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* 631x/632x */
+        { 0x8086, 0x267e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* 631x/632x */
+        { 0x8086, 0x267f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* 631x/632x */
+        { 0x8086, 0x27b8, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* Gx */
+/* E
+        { 0x8086, 0x245e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, */
+        { 0x8086, 0x2450, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* E  */
         { 0, }, /* terminate list */
 };
 MODULE_DEVICE_TABLE(pci, pci_tbl);
@@ -138,22 +213,115 @@ static struct hwrng intel_rng = {
 };
 
 
+#ifdef CONFIG_SMP
+static char __initdata waitflag;
+
+static void __init intel_init_wait(void *unused)
+{
+        while (waitflag)
+                cpu_relax();
+}
+#endif
+
 static int __init mod_init(void)
 {
         int err = -ENODEV;
+        unsigned i;
+        struct pci_dev *dev = NULL;
         void __iomem *mem;
-        u8 hw_status;
+        unsigned long flags;
+        u8 bios_cntl_off, fwh_dec_en1_off;
+        u8 bios_cntl_val = 0xff, fwh_dec_en1_val = 0xff;
+        u8 hw_status, mfc, dvc;
 
-        if (!pci_dev_present(pci_tbl))
+        for (i = 0; !dev && pci_tbl[i].vendor; ++i)
+                dev = pci_get_device(pci_tbl[i].vendor, pci_tbl[i].device, NULL);
+
+        if (!dev)
                 goto out; /* Device not found. */
 
+        /* Check for Intel 82802 */
+        if (dev->device < 0x2640) {
+                fwh_dec_en1_off = FWH_DEC_EN1_REG_OLD;
+                bios_cntl_off = BIOS_CNTL_REG_OLD;
+        } else {
+                fwh_dec_en1_off = FWH_DEC_EN1_REG_NEW;
+                bios_cntl_off = BIOS_CNTL_REG_NEW;
+        }
+
+        pci_read_config_byte(dev, fwh_dec_en1_off, &fwh_dec_en1_val);
+        pci_read_config_byte(dev, bios_cntl_off, &bios_cntl_val);
+
+        mem = ioremap_nocache(INTEL_FWH_ADDR, INTEL_FWH_ADDR_LEN);
+        if (mem == NULL) {
+                pci_dev_put(dev);
+                err = -EBUSY;
+                goto out;
+        }
+
+        /*
+         * Since the BIOS code/data is going to disappear from its normal
+         * location with the Read ID command, all activity on the system
+         * must be stopped until the state is back to normal.
+         */
+#ifdef CONFIG_SMP
+        set_mb(waitflag, 1);
+        if (smp_call_function(intel_init_wait, NULL, 1, 0) != 0) {
+                set_mb(waitflag, 0);
+                pci_dev_put(dev);
+                printk(KERN_ERR PFX "cannot run on all processors\n");
+                err = -EAGAIN;
+                goto err_unmap;
+        }
+#endif
+        local_irq_save(flags);
+
+        if (!(fwh_dec_en1_val & FWH_F8_EN_MASK))
+                pci_write_config_byte(dev,
+                                      fwh_dec_en1_off,
+                                      fwh_dec_en1_val | FWH_F8_EN_MASK);
+        if (!(bios_cntl_val &
+              (BIOS_CNTL_LOCK_ENABLE_MASK|BIOS_CNTL_WRITE_ENABLE_MASK)))
+                pci_write_config_byte(dev,
+                                      bios_cntl_off,
+                                      bios_cntl_val | BIOS_CNTL_WRITE_ENABLE_MASK);
+
+        writeb(INTEL_FWH_RESET_CMD, mem);
+        writeb(INTEL_FWH_READ_ID_CMD, mem);
+        mfc = readb(mem + INTEL_FWH_MANUFACTURER_CODE_ADDRESS);
+        dvc = readb(mem + INTEL_FWH_DEVICE_CODE_ADDRESS);
+        writeb(INTEL_FWH_RESET_CMD, mem);
+
+        if (!(bios_cntl_val &
+              (BIOS_CNTL_LOCK_ENABLE_MASK|BIOS_CNTL_WRITE_ENABLE_MASK)))
+                pci_write_config_byte(dev, bios_cntl_off, bios_cntl_val);
+        if (!(fwh_dec_en1_val & FWH_F8_EN_MASK))
+                pci_write_config_byte(dev, fwh_dec_en1_off, fwh_dec_en1_val);
+
+        local_irq_restore(flags);
+#ifdef CONFIG_SMP
+        /* Tell other CPUs to resume. */
+        set_mb(waitflag, 0);
+#endif
+
+        iounmap(mem);
+        pci_dev_put(dev);
+
+        if (mfc != INTEL_FWH_MANUFACTURER_CODE ||
+            (dvc != INTEL_FWH_DEVICE_CODE_8M &&
+             dvc != INTEL_FWH_DEVICE_CODE_4M)) {
+                printk(KERN_ERR PFX "FWH not detected\n");
+                err = -ENODEV;
+                goto out;
+        }
+
         err = -ENOMEM;
         mem = ioremap(INTEL_RNG_ADDR, INTEL_RNG_ADDR_LEN);
         if (!mem)
                 goto out;
         intel_rng.priv = (unsigned long)mem;
 
-        /* Check for Intel 82802 */
+        /* Check for Random Number Generator */
         err = -ENODEV;
         hw_status = hwstatus_get(mem);
         if ((hw_status & INTEL_RNG_PRESENT) == 0)
diff --git a/drivers/char/hw_random/ixp4xx-rng.c b/drivers/char/hw_random/ixp4xx-rng.c
index ef71022423c9..c9caff57db85 100644
--- a/drivers/char/hw_random/ixp4xx-rng.c
+++ b/drivers/char/hw_random/ixp4xx-rng.c
@@ -1,5 +1,5 @@
 /*
- * drivers/char/rng/ixp4xx-rng.c
+ * drivers/char/hw_random/ixp4xx-rng.c
  *
  * RNG driver for Intel IXP4xx family of NPUs
  *
@@ -15,7 +15,6 @@
  */
 
 #include <linux/kernel.h>
-#include <linux/config.h>
 #include <linux/types.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
diff --git a/drivers/char/hw_random/omap-rng.c b/drivers/char/hw_random/omap-rng.c
index a01d796d1eeb..e13dd1892bfd 100644
--- a/drivers/char/hw_random/omap-rng.c
+++ b/drivers/char/hw_random/omap-rng.c
@@ -1,5 +1,5 @@
 /*
- * driver/char/hw_random/omap-rng.c
+ * drivers/char/hw_random/omap-rng.c
  *
  * RNG driver for TI OMAP CPU family
  *
diff --git a/drivers/char/ip2/i2cmd.h b/drivers/char/ip2/i2cmd.h
index baa4e721b758..29277ec6b8ed 100644
--- a/drivers/char/ip2/i2cmd.h
+++ b/drivers/char/ip2/i2cmd.h
@@ -367,11 +367,6 @@ static UCHAR cc02[];
 #define CSE_NULL  3  // Replace with a null
 #define CSE_MARK  4  // Replace with a 3-character sequence (as Unix)
 
-#define  CMD_SET_REPLACEMENT(arg,ch)   \
-                        (((cmdSyntaxPtr)(ct36a))->cmd[1] = (arg), \
-                        (((cmdSyntaxPtr)(ct36a))->cmd[2] = (ch),  \
-                        (cmdSyntaxPtr)(ct36a))
-
 #define CSE_REPLACE  0x8        // Replace the errored character with the
                                                         // replacement character defined here
 
diff --git a/drivers/char/ip2/i2lib.c b/drivers/char/ip2/i2lib.c
index fc944d375be7..78045767ec33 100644
--- a/drivers/char/ip2/i2lib.c
+++ b/drivers/char/ip2/i2lib.c
@@ -84,8 +84,8 @@ static void iiSendPendingMail(i2eBordStrPtr);
 static void serviceOutgoingFifo(i2eBordStrPtr);
 
 // Functions defined in ip2.c as part of interrupt handling
-static void do_input(void *);
-static void do_status(void *);
+static void do_input(struct work_struct *);
+static void do_status(struct work_struct *);
 
 //***************
 //* Debug  Data *
@@ -331,8 +331,8 @@ i2InitChannels ( i2eBordStrPtr pB, int nChannels, i2ChanStrPtr pCh)
                 pCh->ClosingWaitTime  = 30*HZ;
 
                 // Initialize task queue objects
-                INIT_WORK(&pCh->tqueue_input, do_input, pCh);
-                INIT_WORK(&pCh->tqueue_status, do_status, pCh);
+                INIT_WORK(&pCh->tqueue_input, do_input);
+                INIT_WORK(&pCh->tqueue_status, do_status);
 
 #ifdef IP2DEBUG_TRACE
                 pCh->trace = ip2trace;
@@ -1007,7 +1007,7 @@ i2InputAvailable(i2ChanStrPtr pCh)
 // applications that one cannot break out of.
 //******************************************************************************
 static int
-i2Output(i2ChanStrPtr pCh, const char *pSource, int count, int user )
+i2Output(i2ChanStrPtr pCh, const char *pSource, int count)
 {
         i2eBordStrPtr pB;
         unsigned char *pInsert;
@@ -1016,11 +1016,10 @@ i2Output(i2ChanStrPtr pCh, const char *pSource, int count, int user )
         unsigned short channel;
         unsigned short stuffIndex;
         unsigned long flags;
-        int rc = 0;
 
         int bailout = 10;
 
-        ip2trace (CHANN, ITRC_OUTPUT, ITRC_ENTER, 2, count, user );
+        ip2trace (CHANN, ITRC_OUTPUT, ITRC_ENTER, 2, count, 0 );
 
         // Ensure channel structure seems real
         if ( !i2Validate ( pCh ) ) 
@@ -1087,12 +1086,7 @@ i2Output(i2ChanStrPtr pCh, const char *pSource, int count, int user )
                         DATA_COUNT_OF(pInsert)  = amountToMove;
 
                         // Move the data
-                        if ( user ) {
-                                rc = copy_from_user((char*)(DATA_OF(pInsert)), pSource,
-                                                amountToMove );
-                        } else {
-                                memcpy( (char*)(DATA_OF(pInsert)), pSource, amountToMove );
-                        }
+                        memcpy( (char*)(DATA_OF(pInsert)), pSource, amountToMove );
                         // Adjust pointers and indices
                         pSource                                 += amountToMove;
                         pCh->Obuf_char_count    += amountToMove;
@@ -1578,7 +1572,7 @@ i2StripFifo(i2eBordStrPtr pB)
 #ifdef USE_IQ
                         schedule_work(&pCh->tqueue_input);
 #else
-                        do_input(pCh);
+                        do_input(&pCh->tqueue_input);
 #endif
 
                         // Note we do not need to maintain any flow-control credits at this
@@ -1815,7 +1809,7 @@ i2StripFifo(i2eBordStrPtr pB)
 #ifdef USE_IQ
                                                 schedule_work(&pCh->tqueue_status);
 #else
-                                                do_status(pCh);
+                                                do_status(&pCh->tqueue_status);
 #endif
                                         }
                                 }
diff --git a/drivers/char/ip2/i2lib.h b/drivers/char/ip2/i2lib.h
index 952e113ccd8a..e559e9bac06d 100644
--- a/drivers/char/ip2/i2lib.h
+++ b/drivers/char/ip2/i2lib.h
@@ -332,7 +332,7 @@ static int  i2QueueCommands(int, i2ChanStrPtr, int, int, cmdSyntaxPtr,...);
 static int  i2GetStatus(i2ChanStrPtr, int);
 static int  i2Input(i2ChanStrPtr);
 static int  i2InputFlush(i2ChanStrPtr);
-static int  i2Output(i2ChanStrPtr, const char *, int, int);
+static int  i2Output(i2ChanStrPtr, const char *, int);
 static int  i2OutputFree(i2ChanStrPtr);
 static int  i2ServiceBoard(i2eBordStrPtr);
 static void i2DrainOutput(i2ChanStrPtr, int);
diff --git a/drivers/char/ip2/ip2main.c b/drivers/char/ip2/ip2main.c
index 7907ae88c2f4..7c70310a49b5 100644
--- a/drivers/char/ip2/ip2main.c
+++ b/drivers/char/ip2/ip2main.c
@@ -177,7 +177,7 @@ static int  ip2_write_room(PTTY);
 static int  ip2_chars_in_buf(PTTY);
 static void ip2_flush_buffer(PTTY);
 static int  ip2_ioctl(PTTY, struct file *, UINT, ULONG);
-static void ip2_set_termios(PTTY, struct termios *);
+static void ip2_set_termios(PTTY, struct ktermios *);
 static void ip2_set_line_discipline(PTTY);
 static void ip2_throttle(PTTY);
 static void ip2_unthrottle(PTTY);
@@ -189,16 +189,16 @@ static int  ip2_tiocmset(struct tty_struct *tty, struct file *file,
                          unsigned int set, unsigned int clear);
 
 static void set_irq(int, int);
-static void ip2_interrupt_bh(i2eBordStrPtr pB);
-static irqreturn_t ip2_interrupt(int irq, void *dev_id, struct pt_regs * regs);
+static void ip2_interrupt_bh(struct work_struct *work);
+static irqreturn_t ip2_interrupt(int irq, void *dev_id);
 static void ip2_poll(unsigned long arg);
 static inline void service_all_boards(void);
-static void do_input(void *p);
-static void do_status(void *p);
+static void do_input(struct work_struct *);
+static void do_status(struct work_struct *);
 
 static void ip2_wait_until_sent(PTTY,int);
 
-static void set_params (i2ChanStrPtr, struct termios *);
+static void set_params (i2ChanStrPtr, struct ktermios *);
 static int get_serial_info(i2ChanStrPtr, struct serial_struct __user *);
 static int set_serial_info(i2ChanStrPtr, struct serial_struct __user *);
 
@@ -436,6 +436,7 @@ cleanup_module(void)
 #ifdef CONFIG_PCI
                 if (ip2config.type[i] == PCI && ip2config.pci_dev[i]) {
                         pci_disable_device(ip2config.pci_dev[i]);
+                        pci_dev_put(ip2config.pci_dev[i]);
                         ip2config.pci_dev[i] = NULL;
                 }
 #endif
@@ -457,7 +458,7 @@ cleanup_module(void)
 }
 #endif /* MODULE */
 
-static struct tty_operations ip2_ops = {
+static const struct tty_operations ip2_ops = {
         .open            = ip2_open,
         .close           = ip2_close,
         .write           = ip2_write,
@@ -505,6 +506,7 @@ ip2_loadmain(int *iop, int *irqp, unsigned char *firmware, int firmsize)
         static int loaded;
         i2eBordStrPtr pB = NULL;
         int rc = -1;
+        static struct pci_dev *pci_dev_i = NULL;
 
         ip2trace (ITRC_NO_PORT, ITRC_INIT, ITRC_ENTER, 0 );
 
@@ -588,8 +590,7 @@ ip2_loadmain(int *iop, int *irqp, unsigned char *firmware, int firmsize)
                 case PCI:
 #ifdef CONFIG_PCI
                         {
-                                struct pci_dev *pci_dev_i = NULL;
-                                pci_dev_i = pci_find_device(PCI_VENDOR_ID_COMPUTONE,
+                                pci_dev_i = pci_get_device(PCI_VENDOR_ID_COMPUTONE,
                                                           PCI_DEVICE_ID_COMPUTONE_IP2EX, pci_dev_i);
                                 if (pci_dev_i != NULL) {
                                         unsigned int addr;
@@ -600,7 +601,7 @@ ip2_loadmain(int *iop, int *irqp, unsigned char *firmware, int firmsize)
                                                 break;
                                         }
                                         ip2config.type[i] = PCI;
-                                        ip2config.pci_dev[i] = pci_dev_i;
+                                        ip2config.pci_dev[i] = pci_dev_get(pci_dev_i);
                                         status =
                                         pci_read_config_dword(pci_dev_i, PCI_BASE_ADDRESS_1, &addr);
                                         if ( addr & 1 ) {
@@ -641,6 +642,9 @@ ip2_loadmain(int *iop, int *irqp, unsigned char *firmware, int firmsize)
                         break;
                 }       /* switch */
         }       /* for */
+        if (pci_dev_i)
+                pci_dev_put(pci_dev_i);
+
         for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {
                 if ( ip2config.addr[i] ) {
                         pB = kmalloc( sizeof(i2eBordStr), GFP_KERNEL);
@@ -775,8 +779,6 @@ retry:
         ip2trace (ITRC_NO_PORT, ITRC_INIT, ITRC_RETURN, 0 );
         goto out;
 
-out_class:
-        class_destroy(ip2_class);
 out_chrdev:
         unregister_chrdev(IP2_IPL_MAJOR, "ip2");
 out:
@@ -916,7 +918,7 @@ ip2_init_board( int boardnum )
                 pCh++;
         }
 ex_exit:
-        INIT_WORK(&pB->tqueue_interrupt, (void(*)(void*)) ip2_interrupt_bh, pB);
+        INIT_WORK(&pB->tqueue_interrupt, ip2_interrupt_bh);
         return;
 
 err_release_region:
@@ -1123,8 +1125,8 @@ service_all_boards(void)
 
 
 /******************************************************************************/
-/* Function:   ip2_interrupt_bh(pB)                                           */
-/* Parameters: pB - pointer to the board structure                            */
+/* Function:   ip2_interrupt_bh(work)                                         */
+/* Parameters: work - pointer to the board structure                          */
 /* Returns:    Nothing                                                        */
 /*                                                                            */
 /* Description:                                                               */
@@ -1133,8 +1135,9 @@ service_all_boards(void)
 /*                                                                            */
 /******************************************************************************/
 static void
-ip2_interrupt_bh(i2eBordStrPtr pB)
+ip2_interrupt_bh(struct work_struct *work)
 {
+        i2eBordStrPtr pB = container_of(work, i2eBordStr, tqueue_interrupt);
 //      pB better well be set or we have a problem!  We can only get
 //      here from the IMMEDIATE queue.  Here, we process the boards.
 //      Checking pB doesn't cost much and it saves us from the sanity checkers.
@@ -1152,10 +1155,9 @@ ip2_interrupt_bh(i2eBordStrPtr pB)
 
 
 /******************************************************************************/
-/* Function:   ip2_interrupt(int irq, void *dev_id, struct pt_regs * regs)    */
+/* Function:   ip2_interrupt(int irq, void *dev_id)    */
 /* Parameters: irq - interrupt number                                         */
 /*             pointer to optional device ID structure                        */
-/*             pointer to register structure                                  */
 /* Returns:    Nothing                                                        */
 /*                                                                            */
 /* Description:                                                               */
@@ -1171,7 +1173,7 @@ ip2_interrupt_bh(i2eBordStrPtr pB)
 /*                                                                            */
 /******************************************************************************/
 static irqreturn_t
-ip2_interrupt(int irq, void *dev_id, struct pt_regs * regs)
+ip2_interrupt(int irq, void *dev_id)
 {
         int i;
         i2eBordStrPtr  pB;
@@ -1235,7 +1237,7 @@ ip2_poll(unsigned long arg)
         // Just polled boards, IRQ = 0 will hit all non-interrupt boards.
         // It will NOT poll boards handled by hard interrupts.
         // The issue of queued BH interrups is handled in ip2_interrupt().
-        ip2_interrupt(0, NULL, NULL);
+        ip2_interrupt(0, NULL);
 
         PollTimer.expires = POLL_TIMEOUT;
         add_timer( &PollTimer );
@@ -1244,9 +1246,9 @@ ip2_poll(unsigned long arg)
         ip2trace (ITRC_NO_PORT, ITRC_INTR, ITRC_RETURN, 0 );
 }
 
-static void do_input(void *p)
+static void do_input(struct work_struct *work)
 {
-        i2ChanStrPtr pCh = p;
+        i2ChanStrPtr pCh = container_of(work, i2ChanStr, tqueue_input);
         unsigned long flags;
 
         ip2trace(CHANN, ITRC_INPUT, 21, 0 );
@@ -1278,9 +1280,9 @@ static inline void  isig(int sig, struct tty_struct *tty, int flush)
         }
 }
 
-static void do_status(void *p)
+static void do_status(struct work_struct *work)
 {
-        i2ChanStrPtr pCh = p;
+        i2ChanStrPtr pCh = container_of(work, i2ChanStr, tqueue_status);
         int status;
 
         status =  i2GetStatus( pCh, (I2_BRK|I2_PAR|I2_FRA|I2_OVR) );
@@ -1703,7 +1705,7 @@ ip2_write( PTTY tty, const unsigned char *pData, int count)
 
         /* This is the actual move bit. Make sure it does what we need!!!!! */
         WRITE_LOCK_IRQSAVE(&pCh->Pbuf_spinlock,flags);
-        bytesSent = i2Output( pCh, pData, count, 0 );
+        bytesSent = i2Output( pCh, pData, count);
         WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
 
         ip2trace (CHANN, ITRC_WRITE, ITRC_RETURN, 1, bytesSent );
@@ -1763,7 +1765,7 @@ ip2_flush_chars( PTTY tty )
                 //
                 // We may need to restart i2Output if it does not fullfill this request
                 //
-                strip = i2Output( pCh, pCh->Pbuf, pCh->Pbuf_stuff, 0 );
+                strip = i2Output( pCh, pCh->Pbuf, pCh->Pbuf_stuff);
                 if ( strip != pCh->Pbuf_stuff ) {
                         memmove( pCh->Pbuf, &pCh->Pbuf[strip], pCh->Pbuf_stuff - strip );
                 }
@@ -2396,7 +2398,7 @@ set_serial_info( i2ChanStrPtr pCh, struct serial_struct __user *new_info )
 /*                                                                            */
 /******************************************************************************/
 static void
-ip2_set_termios( PTTY tty, struct termios *old_termios )
+ip2_set_termios( PTTY tty, struct ktermios *old_termios )
 {
         i2ChanStrPtr pCh = (i2ChanStrPtr)tty->driver_data;
 
@@ -2438,11 +2440,11 @@ ip2_set_line_discipline ( PTTY tty )
 /* change.                                                                    */
 /******************************************************************************/
 static void
-set_params( i2ChanStrPtr pCh, struct termios *o_tios )
+set_params( i2ChanStrPtr pCh, struct ktermios *o_tios )
 {
         tcflag_t cflag, iflag, lflag;
         char stop_char, start_char;
-        struct termios dummy;
+        struct ktermios dummy;
 
         lflag = pCh->pTTY->termios->c_lflag;
         cflag = pCh->pTTY->termios->c_cflag;
@@ -2698,7 +2700,7 @@ static
 ssize_t
 ip2_ipl_read(struct file *pFile, char __user *pData, size_t count, loff_t *off )
 {
-        unsigned int minor = iminor(pFile->f_dentry->d_inode);
+        unsigned int minor = iminor(pFile->f_path.dentry->d_inode);
         int rc = 0;
 
 #ifdef IP2DEBUG_IPL
diff --git a/drivers/char/ipmi/ipmi_bt_sm.c b/drivers/char/ipmi/ipmi_bt_sm.c
index 0030cd8e2e95..e736119b6497 100644
--- a/drivers/char/ipmi/ipmi_bt_sm.c
+++ b/drivers/char/ipmi/ipmi_bt_sm.c
@@ -33,11 +33,15 @@
 #include <linux/ipmi_msgdefs.h>         /* for completion codes */
 #include "ipmi_si_sm.h"
 
-static int bt_debug = 0x00;     /* Production value 0, see following flags */
+#define BT_DEBUG_OFF    0       /* Used in production */
+#define BT_DEBUG_ENABLE 1       /* Generic messages */
+#define BT_DEBUG_MSG    2       /* Prints all request/response buffers */
+#define BT_DEBUG_STATES 4       /* Verbose look at state changes */
+/* BT_DEBUG_OFF must be zero to correspond to the default uninitialized
+   value */
+
+static int bt_debug; /* 0 == BT_DEBUG_OFF */
 
-#define BT_DEBUG_ENABLE 1
-#define BT_DEBUG_MSG    2
-#define BT_DEBUG_STATES 4
 module_param(bt_debug, int, 0644);
 MODULE_PARM_DESC(bt_debug, "debug bitmask, 1=enable, 2=messages, 4=states");
 
@@ -47,38 +51,54 @@ MODULE_PARM_DESC(bt_debug, "debug bitmask, 1=enable, 2=messages, 4=states");
    Since the Open IPMI architecture is single-message oriented at this
    stage, the queue depth of BT is of no concern. */
 
-#define BT_NORMAL_TIMEOUT       5000000 /* seconds in microseconds */
-#define BT_RETRY_LIMIT          2
-#define BT_RESET_DELAY          6000000 /* 6 seconds after warm reset */
+#define BT_NORMAL_TIMEOUT       5       /* seconds */
+#define BT_NORMAL_RETRY_LIMIT   2
+#define BT_RESET_DELAY          6       /* seconds after warm reset */
+
+/* States are written in chronological order and usually cover
+   multiple rows of the state table discussion in the IPMI spec. */
 
 enum bt_states {
-        BT_STATE_IDLE,
+        BT_STATE_IDLE = 0,      /* Order is critical in this list */
         BT_STATE_XACTION_START,
         BT_STATE_WRITE_BYTES,
-        BT_STATE_WRITE_END,
         BT_STATE_WRITE_CONSUME,
-        BT_STATE_B2H_WAIT,
-        BT_STATE_READ_END,
-        BT_STATE_RESET1,                /* These must come last */
+        BT_STATE_READ_WAIT,
+        BT_STATE_CLEAR_B2H,
+        BT_STATE_READ_BYTES,
+        BT_STATE_RESET1,        /* These must come last */
         BT_STATE_RESET2,
         BT_STATE_RESET3,
         BT_STATE_RESTART,
-        BT_STATE_HOSED
+        BT_STATE_PRINTME,
+        BT_STATE_CAPABILITIES_BEGIN,
+        BT_STATE_CAPABILITIES_END,
+        BT_STATE_LONG_BUSY      /* BT doesn't get hosed :-) */
 };
 
+/* Macros seen at the end of state "case" blocks.  They help with legibility
+   and debugging. */
+
+#define BT_STATE_CHANGE(X,Y) { bt->state = X; return Y; }
+
+#define BT_SI_SM_RETURN(Y)   { last_printed = BT_STATE_PRINTME; return Y; }
+
 struct si_sm_data {
         enum bt_states  state;
-        enum bt_states  last_state;     /* assist printing and resets */
         unsigned char   seq;            /* BT sequence number */
         struct si_sm_io *io;
-        unsigned char   write_data[IPMI_MAX_MSG_LENGTH];
-        int             write_count;
-        unsigned char   read_data[IPMI_MAX_MSG_LENGTH];
-        int             read_count;
-        int             truncated;
-        long            timeout;
-        unsigned int    error_retries;  /* end of "common" fields */
+        unsigned char   write_data[IPMI_MAX_MSG_LENGTH];
+        int             write_count;
+        unsigned char   read_data[IPMI_MAX_MSG_LENGTH];
+        int             read_count;
+        int             truncated;
+        long            timeout;        /* microseconds countdown */
+        int             error_retries;  /* end of "common" fields */
         int             nonzero_status; /* hung BMCs stay all 0 */
+        enum bt_states  complete;       /* to divert the state machine */
+        int             BT_CAP_outreqs;
+        long            BT_CAP_req2rsp;
+        int             BT_CAP_retries; /* Recommended retries */
 };
 
 #define BT_CLR_WR_PTR   0x01    /* See IPMI 1.5 table 11.6.4 */
@@ -111,86 +131,118 @@ struct si_sm_data {
 static char *state2txt(unsigned char state)
 {
         switch (state) {
-                case BT_STATE_IDLE:             return("IDLE");
-                case BT_STATE_XACTION_START:    return("XACTION");
-                case BT_STATE_WRITE_BYTES:      return("WR_BYTES");
-                case BT_STATE_WRITE_END:        return("WR_END");
-                case BT_STATE_WRITE_CONSUME:    return("WR_CONSUME");
-                case BT_STATE_B2H_WAIT:         return("B2H_WAIT");
-                case BT_STATE_READ_END:         return("RD_END");
-                case BT_STATE_RESET1:           return("RESET1");
-                case BT_STATE_RESET2:           return("RESET2");
-                case BT_STATE_RESET3:           return("RESET3");
-                case BT_STATE_RESTART:          return("RESTART");
-                case BT_STATE_HOSED:            return("HOSED");
+        case BT_STATE_IDLE:             return("IDLE");
+        case BT_STATE_XACTION_START:    return("XACTION");
+        case BT_STATE_WRITE_BYTES:      return("WR_BYTES");
+        case BT_STATE_WRITE_CONSUME:    return("WR_CONSUME");
+        case BT_STATE_READ_WAIT:        return("RD_WAIT");
+        case BT_STATE_CLEAR_B2H:        return("CLEAR_B2H");
+        case BT_STATE_READ_BYTES:       return("RD_BYTES");
+        case BT_STATE_RESET1:           return("RESET1");
+        case BT_STATE_RESET2:           return("RESET2");
+        case BT_STATE_RESET3:           return("RESET3");
+        case BT_STATE_RESTART:          return("RESTART");
+        case BT_STATE_LONG_BUSY:        return("LONG_BUSY");
+        case BT_STATE_CAPABILITIES_BEGIN: return("CAP_BEGIN");
+        case BT_STATE_CAPABILITIES_END: return("CAP_END");
         }
         return("BAD STATE");
 }
 #define STATE2TXT state2txt(bt->state)
 
-static char *status2txt(unsigned char status, char *buf)
+static char *status2txt(unsigned char status)
 {
+        /*
+         * This cannot be called by two threads at the same time and
+         * the buffer is always consumed immediately, so the static is
+         * safe to use.
+         */
+        static char buf[40];
+
         strcpy(buf, "[ ");
-        if (status & BT_B_BUSY) strcat(buf, "B_BUSY ");
-        if (status & BT_H_BUSY) strcat(buf, "H_BUSY ");
-        if (status & BT_OEM0) strcat(buf, "OEM0 ");
-        if (status & BT_SMS_ATN) strcat(buf, "SMS ");
-        if (status & BT_B2H_ATN) strcat(buf, "B2H ");
-        if (status & BT_H2B_ATN) strcat(buf, "H2B ");
+        if (status & BT_B_BUSY)
+                strcat(buf, "B_BUSY ");
+        if (status & BT_H_BUSY)
+                strcat(buf, "H_BUSY ");
+        if (status & BT_OEM0)
+                strcat(buf, "OEM0 ");
+        if (status & BT_SMS_ATN)
+                strcat(buf, "SMS ");
+        if (status & BT_B2H_ATN)
+                strcat(buf, "B2H ");
+        if (status & BT_H2B_ATN)
+                strcat(buf, "H2B ");
         strcat(buf, "]");
         return buf;
 }
-#define STATUS2TXT(buf) status2txt(status, buf)
+#define STATUS2TXT status2txt(status)
+
+/* called externally at insmod time, and internally on cleanup */
 
-/* This will be called from within this module on a hosed condition */
-#define FIRST_SEQ       0
 static unsigned int bt_init_data(struct si_sm_data *bt, struct si_sm_io *io)
 {
-        bt->state = BT_STATE_IDLE;
-        bt->last_state = BT_STATE_IDLE;
-        bt->seq = FIRST_SEQ;
-        bt->io = io;
-        bt->write_count = 0;
-        bt->read_count = 0;
-        bt->error_retries = 0;
-        bt->nonzero_status = 0;
-        bt->truncated = 0;
-        bt->timeout = BT_NORMAL_TIMEOUT;
+        memset(bt, 0, sizeof(struct si_sm_data));
+        if (bt->io != io) {             /* external: one-time only things */
+                bt->io = io;
+                bt->seq = 0;
+        }
+        bt->state = BT_STATE_IDLE;      /* start here */
+        bt->complete = BT_STATE_IDLE;   /* end here */
+        bt->BT_CAP_req2rsp = BT_NORMAL_TIMEOUT * 1000000;
+        bt->BT_CAP_retries = BT_NORMAL_RETRY_LIMIT;
+        /* BT_CAP_outreqs == zero is a flag to read BT Capabilities */
         return 3; /* We claim 3 bytes of space; ought to check SPMI table */
 }
 
+/* Jam a completion code (probably an error) into a response */
+
+static void force_result(struct si_sm_data *bt, unsigned char completion_code)
+{
+        bt->read_data[0] = 4;                           /* # following bytes */
+        bt->read_data[1] = bt->write_data[1] | 4;       /* Odd NetFn/LUN */
+        bt->read_data[2] = bt->write_data[2];           /* seq (ignored) */
+        bt->read_data[3] = bt->write_data[3];           /* Command */
+        bt->read_data[4] = completion_code;
+        bt->read_count = 5;
+}
+
+/* The upper state machine starts here */
+
 static int bt_start_transaction(struct si_sm_data *bt,
                                 unsigned char *data,
                                 unsigned int size)
 {
         unsigned int i;
 
-        if ((size < 2) || (size > (IPMI_MAX_MSG_LENGTH - 2)))
-               return -1;
+        if (size < 2)
+                return IPMI_REQ_LEN_INVALID_ERR;
+        if (size > IPMI_MAX_MSG_LENGTH)
+                return IPMI_REQ_LEN_EXCEEDED_ERR;
 
-        if ((bt->state != BT_STATE_IDLE) && (bt->state != BT_STATE_HOSED))
-                return -2;
+        if (bt->state == BT_STATE_LONG_BUSY)
+                return IPMI_NODE_BUSY_ERR;
+
+        if (bt->state != BT_STATE_IDLE)
+                return IPMI_NOT_IN_MY_STATE_ERR;
 
         if (bt_debug & BT_DEBUG_MSG) {
-                printk(KERN_WARNING "+++++++++++++++++++++++++++++++++++++\n");
-                printk(KERN_WARNING "BT: write seq=0x%02X:", bt->seq);
+                printk(KERN_WARNING "BT: +++++++++++++++++ New command\n");
+                printk(KERN_WARNING "BT: NetFn/LUN CMD [%d data]:", size - 2);
                 for (i = 0; i < size; i ++)
-                       printk (" %02x", data[i]);
+                        printk (" %02x", data[i]);
                 printk("\n");
         }
         bt->write_data[0] = size + 1;   /* all data plus seq byte */
         bt->write_data[1] = *data;      /* NetFn/LUN */
-        bt->write_data[2] = bt->seq;
+        bt->write_data[2] = bt->seq++;
         memcpy(bt->write_data + 3, data + 1, size - 1);
         bt->write_count = size + 2;
-
         bt->error_retries = 0;
         bt->nonzero_status = 0;
-        bt->read_count = 0;
         bt->truncated = 0;
         bt->state = BT_STATE_XACTION_START;
-        bt->last_state = BT_STATE_IDLE;
-        bt->timeout = BT_NORMAL_TIMEOUT;
+        bt->timeout = bt->BT_CAP_req2rsp;
+        force_result(bt, IPMI_ERR_UNSPECIFIED);
         return 0;
 }
 
@@ -198,38 +250,30 @@ static int bt_start_transaction(struct si_sm_data *bt,
    it calls this.  Strip out the length and seq bytes. */
 
 static int bt_get_result(struct si_sm_data *bt,
-                           unsigned char *data,
-                           unsigned int length)
+                         unsigned char *data,
+                         unsigned int length)
 {
         int i, msg_len;
 
         msg_len = bt->read_count - 2;           /* account for length & seq */
-        /* Always NetFn, Cmd, cCode */
         if (msg_len < 3 || msg_len > IPMI_MAX_MSG_LENGTH) {
-                printk(KERN_DEBUG "BT results: bad msg_len = %d\n", msg_len);
-                data[0] = bt->write_data[1] | 0x4;      /* Kludge a response */
-                data[1] = bt->write_data[3];
-                data[2] = IPMI_ERR_UNSPECIFIED;
+                force_result(bt, IPMI_ERR_UNSPECIFIED);
                 msg_len = 3;
-        } else {
-                data[0] = bt->read_data[1];
-                data[1] = bt->read_data[3];
-                if (length < msg_len)
-                       bt->truncated = 1;
-                if (bt->truncated) {    /* can be set in read_all_bytes() */
-                        data[2] = IPMI_ERR_MSG_TRUNCATED;
-                        msg_len = 3;
-                } else
-                       memcpy(data + 2, bt->read_data + 4, msg_len - 2);
+        }
+        data[0] = bt->read_data[1];
+        data[1] = bt->read_data[3];
+        if (length < msg_len || bt->truncated) {
+                data[2] = IPMI_ERR_MSG_TRUNCATED;
+                msg_len = 3;
+        } else
+                memcpy(data + 2, bt->read_data + 4, msg_len - 2);
 
-                if (bt_debug & BT_DEBUG_MSG) {
-                        printk (KERN_WARNING "BT: res (raw)");
-                        for (i = 0; i < msg_len; i++)
-                               printk(" %02x", data[i]);
-                        printk ("\n");
-                }
+        if (bt_debug & BT_DEBUG_MSG) {
+                printk (KERN_WARNING "BT: result %d bytes:", msg_len);
+                for (i = 0; i < msg_len; i++)
+                        printk(" %02x", data[i]);
+                printk ("\n");
         }
-        bt->read_count = 0;     /* paranoia */
         return msg_len;
 }
 
@@ -238,22 +282,40 @@ static int bt_get_result(struct si_sm_data *bt,
 
 static void reset_flags(struct si_sm_data *bt)
 {
+        if (bt_debug)
+                printk(KERN_WARNING "IPMI BT: flag reset %s\n",
+                                        status2txt(BT_STATUS));
         if (BT_STATUS & BT_H_BUSY)
-               BT_CONTROL(BT_H_BUSY);
-        if (BT_STATUS & BT_B_BUSY)
-               BT_CONTROL(BT_B_BUSY);
-        BT_CONTROL(BT_CLR_WR_PTR);
-        BT_CONTROL(BT_SMS_ATN);
-
-        if (BT_STATUS & BT_B2H_ATN) {
-                int i;
-                BT_CONTROL(BT_H_BUSY);
-                BT_CONTROL(BT_B2H_ATN);
-                BT_CONTROL(BT_CLR_RD_PTR);
-                for (i = 0; i < IPMI_MAX_MSG_LENGTH + 2; i++)
-                       BMC2HOST;
-                BT_CONTROL(BT_H_BUSY);
-        }
+                BT_CONTROL(BT_H_BUSY);  /* force clear */
+        BT_CONTROL(BT_CLR_WR_PTR);      /* always reset */
+        BT_CONTROL(BT_SMS_ATN);         /* always clear */
+        BT_INTMASK_W(BT_BMC_HWRST);
+}
+
+/* Get rid of an unwanted/stale response.  This should only be needed for
+   BMCs that support multiple outstanding requests. */
+
+static void drain_BMC2HOST(struct si_sm_data *bt)
+{
+        int i, size;
+
+        if (!(BT_STATUS & BT_B2H_ATN))  /* Not signalling a response */
+                return;
+
+        BT_CONTROL(BT_H_BUSY);          /* now set */
+        BT_CONTROL(BT_B2H_ATN);         /* always clear */
+        BT_STATUS;                      /* pause */
+        BT_CONTROL(BT_B2H_ATN);         /* some BMCs are stubborn */
+        BT_CONTROL(BT_CLR_RD_PTR);      /* always reset */
+        if (bt_debug)
+                printk(KERN_WARNING "IPMI BT: stale response %s; ",
+                        status2txt(BT_STATUS));
+        size = BMC2HOST;
+        for (i = 0; i < size ; i++)
+                BMC2HOST;
+        BT_CONTROL(BT_H_BUSY);          /* now clear */
+        if (bt_debug)
+                printk("drained %d bytes\n", size + 1);
 }
 
 static inline void write_all_bytes(struct si_sm_data *bt)
@@ -261,201 +323,256 @@ static inline void write_all_bytes(struct si_sm_data *bt)
         int i;
 
         if (bt_debug & BT_DEBUG_MSG) {
-                printk(KERN_WARNING "BT: write %d bytes seq=0x%02X",
+                printk(KERN_WARNING "BT: write %d bytes seq=0x%02X",
                         bt->write_count, bt->seq);
                 for (i = 0; i < bt->write_count; i++)
                         printk (" %02x", bt->write_data[i]);
                 printk ("\n");
         }
         for (i = 0; i < bt->write_count; i++)
-               HOST2BMC(bt->write_data[i]);
+                HOST2BMC(bt->write_data[i]);
 }
 
 static inline int read_all_bytes(struct si_sm_data *bt)
 {
         unsigned char i;
 
+        /* length is "framing info", minimum = 4: NetFn, Seq, Cmd, cCode.
+           Keep layout of first four bytes aligned with write_data[] */
+
         bt->read_data[0] = BMC2HOST;
         bt->read_count = bt->read_data[0];
-        if (bt_debug & BT_DEBUG_MSG)
-                printk(KERN_WARNING "BT: read %d bytes:", bt->read_count);
 
-        /* minimum: length, NetFn, Seq, Cmd, cCode == 5 total, or 4 more
-           following the length byte. */
         if (bt->read_count < 4 || bt->read_count >= IPMI_MAX_MSG_LENGTH) {
                 if (bt_debug & BT_DEBUG_MSG)
-                        printk("bad length %d\n", bt->read_count);
+                        printk(KERN_WARNING "BT: bad raw rsp len=%d\n",
+                                bt->read_count);
                 bt->truncated = 1;
                 return 1;       /* let next XACTION START clean it up */
         }
         for (i = 1; i <= bt->read_count; i++)
-               bt->read_data[i] = BMC2HOST;
-        bt->read_count++;       /* account for the length byte */
+                bt->read_data[i] = BMC2HOST;
+        bt->read_count++;       /* Account internally for length byte */
 
         if (bt_debug & BT_DEBUG_MSG) {
-                for (i = 0; i < bt->read_count; i++)
+                int max = bt->read_count;
+
+                printk(KERN_WARNING "BT: got %d bytes seq=0x%02X",
+                        max, bt->read_data[2]);
+                if (max > 16)
+                        max = 16;
+                for (i = 0; i < max; i++)
                         printk (" %02x", bt->read_data[i]);
-                printk ("\n");
+                printk ("%s\n", bt->read_count == max ? "" : " ...");
         }
-        if (bt->seq != bt->write_data[2])       /* idiot check */
-                printk(KERN_DEBUG "BT: internal error: sequence mismatch\n");
 
-        /* per the spec, the (NetFn, Seq, Cmd) tuples should match */
-        if ((bt->read_data[3] == bt->write_data[3]) &&          /* Cmd */
-                (bt->read_data[2] == bt->write_data[2]) &&      /* Sequence */
-                ((bt->read_data[1] & 0xF8) == (bt->write_data[1] & 0xF8)))
+        /* per the spec, the (NetFn[1], Seq[2], Cmd[3]) tuples must match */
+        if ((bt->read_data[3] == bt->write_data[3]) &&
+            (bt->read_data[2] == bt->write_data[2]) &&
+            ((bt->read_data[1] & 0xF8) == (bt->write_data[1] & 0xF8)))
                         return 1;
 
         if (bt_debug & BT_DEBUG_MSG)
-               printk(KERN_WARNING "BT: bad packet: "
+                printk(KERN_WARNING "IPMI BT: bad packet: "
                 "want 0x(%02X, %02X, %02X) got (%02X, %02X, %02X)\n",
-                bt->write_data[1], bt->write_data[2], bt->write_data[3],
+                bt->write_data[1] | 0x04, bt->write_data[2], bt->write_data[3],
                 bt->read_data[1],  bt->read_data[2],  bt->read_data[3]);
         return 0;
 }
 
-/* Modifies bt->state appropriately, need to get into the bt_event() switch */
+/* Restart if retries are left, or return an error completion code */
 
-static void error_recovery(struct si_sm_data *bt, char *reason)
+static enum si_sm_result error_recovery(struct si_sm_data *bt,
+                                        unsigned char status,
+                                        unsigned char cCode)
 {
-        unsigned char status;
-        char buf[40]; /* For getting status */
+        char *reason;
 
-        bt->timeout = BT_NORMAL_TIMEOUT; /* various places want to retry */
+        bt->timeout = bt->BT_CAP_req2rsp;
 
-        status = BT_STATUS;
-        printk(KERN_DEBUG "BT: %s in %s %s\n", reason, STATE2TXT,
-               STATUS2TXT(buf));
+        switch (cCode) {
+        case IPMI_TIMEOUT_ERR:
+                reason = "timeout";
+                break;
+        default:
+                reason = "internal error";
+                break;
+        }
+
+        printk(KERN_WARNING "IPMI BT: %s in %s %s ",    /* open-ended line */
+                reason, STATE2TXT, STATUS2TXT);
 
+        /* Per the IPMI spec, retries are based on the sequence number
+           known only to this module, so manage a restart here. */
         (bt->error_retries)++;
-        if (bt->error_retries > BT_RETRY_LIMIT) {
-                printk(KERN_DEBUG "retry limit (%d) exceeded\n", BT_RETRY_LIMIT);
-                bt->state = BT_STATE_HOSED;
-                if (!bt->nonzero_status)
-                        printk(KERN_ERR "IPMI: BT stuck, try power cycle\n");
-                else if (bt->error_retries <= BT_RETRY_LIMIT + 1) {
-                        printk(KERN_DEBUG "IPMI: BT reset (takes 5 secs)\n");
-                        bt->state = BT_STATE_RESET1;
-                }
-        return;
+        if (bt->error_retries < bt->BT_CAP_retries) {
+                printk("%d retries left\n",
+                        bt->BT_CAP_retries - bt->error_retries);
+                bt->state = BT_STATE_RESTART;
+                return SI_SM_CALL_WITHOUT_DELAY;
         }
 
-        /* Sometimes the BMC queues get in an "off-by-one" state...*/
-        if ((bt->state == BT_STATE_B2H_WAIT) && (status & BT_B2H_ATN)) {
-                printk(KERN_DEBUG "retry B2H_WAIT\n");
-                return;
+        printk("failed %d retries, sending error response\n",
+                bt->BT_CAP_retries);
+        if (!bt->nonzero_status)
+                printk(KERN_ERR "IPMI BT: stuck, try power cycle\n");
+
+        /* this is most likely during insmod */
+        else if (bt->seq <= (unsigned char)(bt->BT_CAP_retries & 0xFF)) {
+                printk(KERN_WARNING "IPMI: BT reset (takes 5 secs)\n");
+                bt->state = BT_STATE_RESET1;
+                return SI_SM_CALL_WITHOUT_DELAY;
         }
 
-        printk(KERN_DEBUG "restart command\n");
-        bt->state = BT_STATE_RESTART;
+        /* Concoct a useful error message, set up the next state, and
+           be done with this sequence. */
+
+        bt->state = BT_STATE_IDLE;
+        switch (cCode) {
+        case IPMI_TIMEOUT_ERR:
+                if (status & BT_B_BUSY) {
+                        cCode = IPMI_NODE_BUSY_ERR;
+                        bt->state = BT_STATE_LONG_BUSY;
+                }
+                break;
+        default:
+                break;
+        }
+        force_result(bt, cCode);
+        return SI_SM_TRANSACTION_COMPLETE;
 }
 
-/* Check the status and (possibly) advance the BT state machine.  The
-   default return is SI_SM_CALL_WITH_DELAY. */
+/* Check status and (usually) take action and change this state machine. */
 
 static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
 {
-        unsigned char status;
-        char buf[40]; /* For getting status */
+        unsigned char status, BT_CAP[8];
+        static enum bt_states last_printed = BT_STATE_PRINTME;
         int i;
 
         status = BT_STATUS;
         bt->nonzero_status |= status;
-
-        if ((bt_debug & BT_DEBUG_STATES) && (bt->state != bt->last_state))
+        if ((bt_debug & BT_DEBUG_STATES) && (bt->state != last_printed)) {
                 printk(KERN_WARNING "BT: %s %s TO=%ld - %ld \n",
                         STATE2TXT,
-                        STATUS2TXT(buf),
+                        STATUS2TXT,
                         bt->timeout,
                         time);
-        bt->last_state = bt->state;
+                last_printed = bt->state;
+        }
 
-        if (bt->state == BT_STATE_HOSED)
-               return SI_SM_HOSED;
+        /* Commands that time out may still (eventually) provide a response.
+           This stale response will get in the way of a new response so remove
+           it if possible (hopefully during IDLE).  Even if it comes up later
+           it will be rejected by its (now-forgotten) seq number. */
+
+        if ((bt->state < BT_STATE_WRITE_BYTES) && (status & BT_B2H_ATN)) {
+                drain_BMC2HOST(bt);
+                BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
+        }
 
-        if (bt->state != BT_STATE_IDLE) {       /* do timeout test */
+        if ((bt->state != BT_STATE_IDLE) &&
+            (bt->state <  BT_STATE_PRINTME)) {          /* check timeout */
                 bt->timeout -= time;
-                if ((bt->timeout < 0) && (bt->state < BT_STATE_RESET1)) {
-                        error_recovery(bt, "timed out");
-                        return SI_SM_CALL_WITHOUT_DELAY;
-                }
+                if ((bt->timeout < 0) && (bt->state < BT_STATE_RESET1))
+                        return error_recovery(bt,
+                                              status,
+                                              IPMI_TIMEOUT_ERR);
         }
 
         switch (bt->state) {
 
-        case BT_STATE_IDLE:     /* check for asynchronous messages */
+        /* Idle state first checks for asynchronous messages from another
+           channel, then does some opportunistic housekeeping. */
+
+        case BT_STATE_IDLE:
                 if (status & BT_SMS_ATN) {
                         BT_CONTROL(BT_SMS_ATN); /* clear it */
                         return SI_SM_ATTN;
                 }
-                return SI_SM_IDLE;
 
-        case BT_STATE_XACTION_START:
-                if (status & BT_H_BUSY) {
+                if (status & BT_H_BUSY)         /* clear a leftover H_BUSY */
                         BT_CONTROL(BT_H_BUSY);
-                        break;
-                }
-                if (status & BT_B2H_ATN)
-                       break;
-                bt->state = BT_STATE_WRITE_BYTES;
-                return SI_SM_CALL_WITHOUT_DELAY;        /* for logging */
 
-        case BT_STATE_WRITE_BYTES:
+                /* Read BT capabilities if it hasn't been done yet */
+                if (!bt->BT_CAP_outreqs)
+                        BT_STATE_CHANGE(BT_STATE_CAPABILITIES_BEGIN,
+                                        SI_SM_CALL_WITHOUT_DELAY);
+                bt->timeout = bt->BT_CAP_req2rsp;
+                BT_SI_SM_RETURN(SI_SM_IDLE);
+
+        case BT_STATE_XACTION_START:
                 if (status & (BT_B_BUSY | BT_H2B_ATN))
-                       break;
+                        BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
+                if (BT_STATUS & BT_H_BUSY)
+                        BT_CONTROL(BT_H_BUSY);  /* force clear */
+                BT_STATE_CHANGE(BT_STATE_WRITE_BYTES,
+                                SI_SM_CALL_WITHOUT_DELAY);
+
+        case BT_STATE_WRITE_BYTES:
+                if (status & BT_H_BUSY)
+                        BT_CONTROL(BT_H_BUSY);  /* clear */
                 BT_CONTROL(BT_CLR_WR_PTR);
                 write_all_bytes(bt);
-                BT_CONTROL(BT_H2B_ATN); /* clears too fast to catch? */
-                bt->state = BT_STATE_WRITE_CONSUME;
-                return SI_SM_CALL_WITHOUT_DELAY; /* it MIGHT sail through */
-
-        case BT_STATE_WRITE_CONSUME: /* BMCs usually blow right thru here */
-                if (status & (BT_H2B_ATN | BT_B_BUSY))
-                       break;
-                bt->state = BT_STATE_B2H_WAIT;
-                /* fall through with status */
-
-        /* Stay in BT_STATE_B2H_WAIT until a packet matches.  However, spinning
-           hard here, constantly reading status, seems to hold off the
-           generation of B2H_ATN so ALWAYS return CALL_WITH_DELAY. */
-
-        case BT_STATE_B2H_WAIT:
-                if (!(status & BT_B2H_ATN))
-                       break;
-
-                /* Assume ordered, uncached writes: no need to wait */
-                if (!(status & BT_H_BUSY))
-                       BT_CONTROL(BT_H_BUSY); /* set */
-                BT_CONTROL(BT_B2H_ATN);         /* clear it, ACK to the BMC */
-                BT_CONTROL(BT_CLR_RD_PTR);      /* reset the queue */
-                i = read_all_bytes(bt);
-                BT_CONTROL(BT_H_BUSY);          /* clear */
-                if (!i)                         /* Try this state again */
-                       break;
-                bt->state = BT_STATE_READ_END;
-                return SI_SM_CALL_WITHOUT_DELAY;        /* for logging */
-
-        case BT_STATE_READ_END:
-
-                /* I could wait on BT_H_BUSY to go clear for a truly clean
-                   exit.  However, this is already done in XACTION_START
-                   and the (possible) extra loop/status/possible wait affects
-                   performance.  So, as long as it works, just ignore H_BUSY */
-
-#ifdef MAKE_THIS_TRUE_IF_NECESSARY
+                BT_CONTROL(BT_H2B_ATN); /* can clear too fast to catch */
+                BT_STATE_CHANGE(BT_STATE_WRITE_CONSUME,
+                                SI_SM_CALL_WITHOUT_DELAY);
 
-                if (status & BT_H_BUSY)
-                       break;
-#endif
-                bt->seq++;
-                bt->state = BT_STATE_IDLE;
-                return SI_SM_TRANSACTION_COMPLETE;
+        case BT_STATE_WRITE_CONSUME:
+                if (status & (BT_B_BUSY | BT_H2B_ATN))
+                        BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
+                BT_STATE_CHANGE(BT_STATE_READ_WAIT,
+                                SI_SM_CALL_WITHOUT_DELAY);
+
+        /* Spinning hard can suppress B2H_ATN and force a timeout */
+
+        case BT_STATE_READ_WAIT:
+                if (!(status & BT_B2H_ATN))
+                        BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
+                BT_CONTROL(BT_H_BUSY);          /* set */
+
+                /* Uncached, ordered writes should just proceeed serially but
+                   some BMCs don't clear B2H_ATN with one hit.  Fast-path a
+                   workaround without too much penalty to the general case. */
+
+                BT_CONTROL(BT_B2H_ATN);         /* clear it to ACK the BMC */
+                BT_STATE_CHANGE(BT_STATE_CLEAR_B2H,
+                                SI_SM_CALL_WITHOUT_DELAY);
+
+        case BT_STATE_CLEAR_B2H:
+                if (status & BT_B2H_ATN) {      /* keep hitting it */
+                        BT_CONTROL(BT_B2H_ATN);
+                        BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
+                }
+                BT_STATE_CHANGE(BT_STATE_READ_BYTES,
+                                SI_SM_CALL_WITHOUT_DELAY);
+
+        case BT_STATE_READ_BYTES:
+                if (!(status & BT_H_BUSY))      /* check in case of retry */
+                        BT_CONTROL(BT_H_BUSY);
+                BT_CONTROL(BT_CLR_RD_PTR);      /* start of BMC2HOST buffer */
+                i = read_all_bytes(bt);         /* true == packet seq match */
+                BT_CONTROL(BT_H_BUSY);          /* NOW clear */
+                if (!i)                         /* Not my message */
+                        BT_STATE_CHANGE(BT_STATE_READ_WAIT,
+                                        SI_SM_CALL_WITHOUT_DELAY);
+                bt->state = bt->complete;
+                return bt->state == BT_STATE_IDLE ?     /* where to next? */
+                        SI_SM_TRANSACTION_COMPLETE :    /* normal */
+                        SI_SM_CALL_WITHOUT_DELAY;       /* Startup magic */
+
+        case BT_STATE_LONG_BUSY:        /* For example: after FW update */
+                if (!(status & BT_B_BUSY)) {
+                        reset_flags(bt);        /* next state is now IDLE */
+                        bt_init_data(bt, bt->io);
+                }
+                return SI_SM_CALL_WITH_DELAY;   /* No repeat printing */
 
         case BT_STATE_RESET1:
-                reset_flags(bt);
-                bt->timeout = BT_RESET_DELAY;
-                bt->state = BT_STATE_RESET2;
-                break;
+                reset_flags(bt);
+                drain_BMC2HOST(bt);
+                BT_STATE_CHANGE(BT_STATE_RESET2,
+                                SI_SM_CALL_WITH_DELAY);
 
         case BT_STATE_RESET2:           /* Send a soft reset */
                 BT_CONTROL(BT_CLR_WR_PTR);
@@ -464,29 +581,59 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
                 HOST2BMC(42);           /* Sequence number */
                 HOST2BMC(3);            /* Cmd == Soft reset */
                 BT_CONTROL(BT_H2B_ATN);
-                bt->state = BT_STATE_RESET3;
-                break;
+                bt->timeout = BT_RESET_DELAY * 1000000;
+                BT_STATE_CHANGE(BT_STATE_RESET3,
+                                SI_SM_CALL_WITH_DELAY);
 
-        case BT_STATE_RESET3:
+        case BT_STATE_RESET3:           /* Hold off everything for a bit */
                 if (bt->timeout > 0)
-                       return SI_SM_CALL_WITH_DELAY;
-                bt->state = BT_STATE_RESTART;   /* printk in debug modes */
-                break;
+                        return SI_SM_CALL_WITH_DELAY;
+                drain_BMC2HOST(bt);
+                BT_STATE_CHANGE(BT_STATE_RESTART,
+                                SI_SM_CALL_WITH_DELAY);
 
-        case BT_STATE_RESTART:          /* don't reset retries! */
-                reset_flags(bt);
-                bt->write_data[2] = ++bt->seq;
+        case BT_STATE_RESTART:          /* don't reset retries or seq! */
                 bt->read_count = 0;
                 bt->nonzero_status = 0;
-                bt->timeout = BT_NORMAL_TIMEOUT;
-                bt->state = BT_STATE_XACTION_START;
-                break;
-
-        default:        /* HOSED is supposed to be caught much earlier */
-                error_recovery(bt, "internal logic error");
-                break;
-        }
-        return SI_SM_CALL_WITH_DELAY;
+                bt->timeout = bt->BT_CAP_req2rsp;
+                BT_STATE_CHANGE(BT_STATE_XACTION_START,
+                                SI_SM_CALL_WITH_DELAY);
+
+        /* Get BT Capabilities, using timing of upper level state machine.
+           Set outreqs to prevent infinite loop on timeout. */
+        case BT_STATE_CAPABILITIES_BEGIN:
+                bt->BT_CAP_outreqs = 1;
+                {
+                        unsigned char GetBT_CAP[] = { 0x18, 0x36 };
+                        bt->state = BT_STATE_IDLE;
+                        bt_start_transaction(bt, GetBT_CAP, sizeof(GetBT_CAP));
+                }
+                bt->complete = BT_STATE_CAPABILITIES_END;
+                BT_STATE_CHANGE(BT_STATE_XACTION_START,
+                                SI_SM_CALL_WITH_DELAY);
+
+        case BT_STATE_CAPABILITIES_END:
+                i = bt_get_result(bt, BT_CAP, sizeof(BT_CAP));
+                bt_init_data(bt, bt->io);
+                if ((i == 8) && !BT_CAP[2]) {
+                        bt->BT_CAP_outreqs = BT_CAP[3];
+                        bt->BT_CAP_req2rsp = BT_CAP[6] * 1000000;
+                        bt->BT_CAP_retries = BT_CAP[7];
+                } else
+                        printk(KERN_WARNING "IPMI BT: using default values\n");
+                if (!bt->BT_CAP_outreqs)
+                        bt->BT_CAP_outreqs = 1;
+                printk(KERN_WARNING "IPMI BT: req2rsp=%ld secs retries=%d\n",
+                        bt->BT_CAP_req2rsp / 1000000L, bt->BT_CAP_retries);
+                bt->timeout = bt->BT_CAP_req2rsp;
+                return SI_SM_CALL_WITHOUT_DELAY;
+
+        default:        /* should never occur */
+                return error_recovery(bt,
+                                      status,
+                                      IPMI_ERR_UNSPECIFIED);
+        }
+        return SI_SM_CALL_WITH_DELAY;
 }
 
 static int bt_detect(struct si_sm_data *bt)
@@ -497,7 +644,7 @@ static int bt_detect(struct si_sm_data *bt)
            test that first.  The calling routine uses negative logic. */
 
         if ((BT_STATUS == 0xFF) && (BT_INTMASK_R == 0xFF))
-               return 1;
+                return 1;
         reset_flags(bt);
         return 0;
 }
@@ -513,11 +660,11 @@ static int bt_size(void)
 
 struct si_sm_handlers bt_smi_handlers =
 {
-        .init_data         = bt_init_data,
-        .start_transaction = bt_start_transaction,
-        .get_result        = bt_get_result,
-        .event             = bt_event,
-        .detect            = bt_detect,
-        .cleanup           = bt_cleanup,
-        .size              = bt_size,
+        .init_data              = bt_init_data,
+        .start_transaction      = bt_start_transaction,
+        .get_result             = bt_get_result,
+        .event                  = bt_event,
+        .detect                 = bt_detect,
+        .cleanup                = bt_cleanup,
+        .size                   = bt_size,
 };
diff --git a/drivers/char/ipmi/ipmi_devintf.c b/drivers/char/ipmi/ipmi_devintf.c
index 68d7c61a864e..ff2d052177cb 100644
--- a/drivers/char/ipmi/ipmi_devintf.c
+++ b/drivers/char/ipmi/ipmi_devintf.c
@@ -377,7 +377,8 @@ static int ipmi_ioctl(struct inode  *inode,
                         break;
                 }
 
-                rv = ipmi_register_for_cmd(priv->user, val.netfn, val.cmd);
+                rv = ipmi_register_for_cmd(priv->user, val.netfn, val.cmd,
+                                           IPMI_CHAN_ALL);
                 break;
         }
 
@@ -390,7 +391,36 @@ static int ipmi_ioctl(struct inode  *inode,
                         break;
                 }
 
-                rv = ipmi_unregister_for_cmd(priv->user, val.netfn, val.cmd);
+                rv = ipmi_unregister_for_cmd(priv->user, val.netfn, val.cmd,
+                                             IPMI_CHAN_ALL);
+                break;
+        }
+
+        case IPMICTL_REGISTER_FOR_CMD_CHANS:
+        {
+                struct ipmi_cmdspec_chans val;
+
+                if (copy_from_user(&val, arg, sizeof(val))) {
+                        rv = -EFAULT;
+                        break;
+                }
+
+                rv = ipmi_register_for_cmd(priv->user, val.netfn, val.cmd,
+                                           val.chans);
+                break;
+        }
+
+        case IPMICTL_UNREGISTER_FOR_CMD_CHANS:
+        {
+                struct ipmi_cmdspec_chans val;
+
+                if (copy_from_user(&val, arg, sizeof(val))) {
+                        rv = -EFAULT;
+                        break;
+                }
+
+                rv = ipmi_unregister_for_cmd(priv->user, val.netfn, val.cmd,
+                                             val.chans);
                 break;
         }
 
@@ -566,6 +596,31 @@ static int ipmi_ioctl(struct inode  *inode,
                 rv = 0;
                 break;
         }
+
+        case IPMICTL_GET_MAINTENANCE_MODE_CMD:
+        {
+                int mode;
+
+                mode = ipmi_get_maintenance_mode(priv->user);
+                if (copy_to_user(arg, &mode, sizeof(mode))) {
+                        rv = -EFAULT;
+                        break;
+                }
+                rv = 0;
+                break;
+        }
+
+        case IPMICTL_SET_MAINTENANCE_MODE_CMD:
+        {
+                int mode;
+
+                if (copy_from_user(&mode, arg, sizeof(mode))) {
+                        rv = -EFAULT;
+                        break;
+                }
+                rv = ipmi_set_maintenance_mode(priv->user, mode);
+                break;
+        }
         }
   
         return rv;
@@ -743,7 +798,7 @@ static long compat_ipmi_ioctl(struct file *filep, unsigned int cmd,
                 if (copy_to_user(precv64, &recv64, sizeof(recv64)))
                         return -EFAULT;
 
-                rc = ipmi_ioctl(filep->f_dentry->d_inode, filep,
+                rc = ipmi_ioctl(filep->f_path.dentry->d_inode, filep,
                                 ((cmd == COMPAT_IPMICTL_RECEIVE_MSG)
                                  ? IPMICTL_RECEIVE_MSG
                                  : IPMICTL_RECEIVE_MSG_TRUNC),
@@ -760,7 +815,7 @@ static long compat_ipmi_ioctl(struct file *filep, unsigned int cmd,
                 return rc;
         }
         default:
-                return ipmi_ioctl(filep->f_dentry->d_inode, filep, cmd, arg);
+                return ipmi_ioctl(filep->f_path.dentry->d_inode, filep, cmd, arg);
         }
 }
 #endif
@@ -779,7 +834,7 @@ static const struct file_operations ipmi_fops = {
 
 #define DEVICE_NAME     "ipmidev"
 
-static int ipmi_major = 0;
+static int ipmi_major;
 module_param(ipmi_major, int, 0);
 MODULE_PARM_DESC(ipmi_major, "Sets the major number of the IPMI device.  By"
                  " default, or if you set it to zero, it will choose the next"
diff --git a/drivers/char/ipmi/ipmi_kcs_sm.c b/drivers/char/ipmi/ipmi_kcs_sm.c
index 2062675f9e99..c1b8228cb7b6 100644
--- a/drivers/char/ipmi/ipmi_kcs_sm.c
+++ b/drivers/char/ipmi/ipmi_kcs_sm.c
@@ -93,8 +93,8 @@ enum kcs_states {
                                    state machine. */
 };
 
-#define MAX_KCS_READ_SIZE 80
-#define MAX_KCS_WRITE_SIZE 80
+#define MAX_KCS_READ_SIZE IPMI_MAX_MSG_LENGTH
+#define MAX_KCS_WRITE_SIZE IPMI_MAX_MSG_LENGTH
 
 /* Timeouts in microseconds. */
 #define IBF_RETRY_TIMEOUT 1000000
@@ -261,12 +261,14 @@ static int start_kcs_transaction(struct si_sm_data *kcs, unsigned char *data,
 {
         unsigned int i;
 
-        if ((size < 2) || (size > MAX_KCS_WRITE_SIZE)) {
-                return -1;
-        }
-        if ((kcs->state != KCS_IDLE) && (kcs->state != KCS_HOSED)) {
-                return -2;
-        }
+        if (size < 2)
+                return IPMI_REQ_LEN_INVALID_ERR;
+        if (size > MAX_KCS_WRITE_SIZE)
+                return IPMI_REQ_LEN_EXCEEDED_ERR;
+
+        if ((kcs->state != KCS_IDLE) && (kcs->state != KCS_HOSED))
+                return IPMI_NOT_IN_MY_STATE_ERR;
+
         if (kcs_debug & KCS_DEBUG_MSG) {
                 printk(KERN_DEBUG "start_kcs_transaction -");
                 for (i = 0; i < size; i ++) {
diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
index 843d34c8627c..4e4691a53890 100644
--- a/drivers/char/ipmi/ipmi_msghandler.c
+++ b/drivers/char/ipmi/ipmi_msghandler.c
@@ -48,17 +48,20 @@
 
 #define PFX "IPMI message handler: "
 
-#define IPMI_DRIVER_VERSION "39.0"
+#define IPMI_DRIVER_VERSION "39.1"
 
 static struct ipmi_recv_msg *ipmi_alloc_recv_msg(void);
 static int ipmi_init_msghandler(void);
 
-static int initialized = 0;
+static int initialized;
 
 #ifdef CONFIG_PROC_FS
-static struct proc_dir_entry *proc_ipmi_root = NULL;
+static struct proc_dir_entry *proc_ipmi_root;
 #endif /* CONFIG_PROC_FS */
 
+/* Remain in auto-maintenance mode for this amount of time (in ms). */
+#define IPMI_MAINTENANCE_MODE_TIMEOUT 30000
+
 #define MAX_EVENTS_IN_QUEUE     25
 
 /* Don't let a message sit in a queue forever, always time it with at lest
@@ -96,6 +99,7 @@ struct cmd_rcvr
         ipmi_user_t   user;
         unsigned char netfn;
         unsigned char cmd;
+        unsigned int  chans;
 
         /*
          * This is used to form a linked lised during mass deletion.
@@ -192,17 +196,28 @@ struct ipmi_smi
 
         struct kref refcount;
 
+        /* Used for a list of interfaces. */
+        struct list_head link;
+
         /* The list of upper layers that are using me.  seq_lock
          * protects this. */
         struct list_head users;
 
+        /* Information to supply to users. */
+        unsigned char ipmi_version_major;
+        unsigned char ipmi_version_minor;
+
         /* Used for wake ups at startup. */
         wait_queue_head_t waitq;
 
         struct bmc_device *bmc;
         char *my_dev_name;
+        char *sysfs_name;
 
-        /* This is the lower-layer's sender routine. */
+        /* This is the lower-layer's sender routine.  Note that you
+         * must either be holding the ipmi_interfaces_mutex or be in
+         * an umpreemptible region to use this.  You must fetch the
+         * value into a local variable and make sure it is not NULL. */
         struct ipmi_smi_handlers *handlers;
         void                     *send_info;
 
@@ -241,6 +256,7 @@ struct ipmi_smi
         spinlock_t       events_lock; /* For dealing with event stuff. */
         struct list_head waiting_events;
         unsigned int     waiting_events_count; /* How many events in queue? */
+        int              delivering_events;
 
         /* The event receiver for my BMC, only really used at panic
            shutdown as a place to store this. */
@@ -249,6 +265,12 @@ struct ipmi_smi
         unsigned char local_sel_device;
         unsigned char local_event_generator;
 
+        /* For handling of maintenance mode. */
+        int maintenance_mode;
+        int maintenance_mode_enable;
+        int auto_maintenance_timeout;
+        spinlock_t maintenance_mode_lock; /* Used in a timer... */
+
         /* A cheap hack, if this is non-null and a message to an
            interface comes in with a NULL user, call this routine with
            it.  Note that the message will still be freed by the
@@ -337,13 +359,6 @@ struct ipmi_smi
 };
 #define to_si_intf_from_dev(device) container_of(device, struct ipmi_smi, dev)
 
-/* Used to mark an interface entry that cannot be used but is not a
- * free entry, either, primarily used at creation and deletion time so
- * a slot doesn't get reused too quickly. */
-#define IPMI_INVALID_INTERFACE_ENTRY ((ipmi_smi_t) ((long) 1))
-#define IPMI_INVALID_INTERFACE(i) (((i) == NULL) \
-                                   || (i == IPMI_INVALID_INTERFACE_ENTRY))
-
 /**
  * The driver model view of the IPMI messaging driver.
  */
@@ -353,16 +368,13 @@ static struct device_driver ipmidriver = {
 };
 static DEFINE_MUTEX(ipmidriver_mutex);
 
-#define MAX_IPMI_INTERFACES 4
-static ipmi_smi_t ipmi_interfaces[MAX_IPMI_INTERFACES];
-
-/* Directly protects the ipmi_interfaces data structure. */
-static DEFINE_SPINLOCK(interfaces_lock);
+static struct list_head ipmi_interfaces = LIST_HEAD_INIT(ipmi_interfaces);
+static DEFINE_MUTEX(ipmi_interfaces_mutex);
 
 /* List of watchers that want to know when smi's are added and
    deleted. */
 static struct list_head smi_watchers = LIST_HEAD_INIT(smi_watchers);
-static DECLARE_RWSEM(smi_watchers_sem);
+static DEFINE_MUTEX(smi_watchers_mutex);
 
 
 static void free_recv_msg_list(struct list_head *q)
@@ -375,13 +387,23 @@ static void free_recv_msg_list(struct list_head *q)
         }
 }
 
+static void free_smi_msg_list(struct list_head *q)
+{
+        struct ipmi_smi_msg *msg, *msg2;
+
+        list_for_each_entry_safe(msg, msg2, q, link) {
+                list_del(&msg->link);
+                ipmi_free_smi_msg(msg);
+        }
+}
+
 static void clean_up_interface_data(ipmi_smi_t intf)
 {
         int              i;
         struct cmd_rcvr  *rcvr, *rcvr2;
         struct list_head list;
 
-        free_recv_msg_list(&intf->waiting_msgs);
+        free_smi_msg_list(&intf->waiting_msgs);
         free_recv_msg_list(&intf->waiting_events);
 
         /* Wholesale remove all the entries from the list in the
@@ -412,48 +434,84 @@ static void intf_free(struct kref *ref)
         kfree(intf);
 }
 
+struct watcher_entry {
+        int              intf_num;
+        ipmi_smi_t       intf;
+        struct list_head link;
+};
+
 int ipmi_smi_watcher_register(struct ipmi_smi_watcher *watcher)
 {
-        int           i;
-        unsigned long flags;
+        ipmi_smi_t intf;
+        struct list_head to_deliver = LIST_HEAD_INIT(to_deliver);
+        struct watcher_entry *e, *e2;
 
-        down_write(&smi_watchers_sem);
-        list_add(&(watcher->link), &smi_watchers);
-        up_write(&smi_watchers_sem);
-        spin_lock_irqsave(&interfaces_lock, flags);
-        for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
-                ipmi_smi_t intf = ipmi_interfaces[i];
-                if (IPMI_INVALID_INTERFACE(intf))
+        mutex_lock(&smi_watchers_mutex);
+
+        mutex_lock(&ipmi_interfaces_mutex);
+
+        /* Build a list of things to deliver. */
+        list_for_each_entry_rcu(intf, &ipmi_interfaces, link) {
+                if (intf->intf_num == -1)
                         continue;
-                spin_unlock_irqrestore(&interfaces_lock, flags);
-                watcher->new_smi(i, intf->si_dev);
-                spin_lock_irqsave(&interfaces_lock, flags);
+                e = kmalloc(sizeof(*e), GFP_KERNEL);
+                if (!e)
+                        goto out_err;
+                kref_get(&intf->refcount);
+                e->intf = intf;
+                e->intf_num = intf->intf_num;
+                list_add_tail(&e->link, &to_deliver);
         }
-        spin_unlock_irqrestore(&interfaces_lock, flags);
+
+        /* We will succeed, so add it to the list. */
+        list_add(&watcher->link, &smi_watchers);
+
+        mutex_unlock(&ipmi_interfaces_mutex);
+
+        list_for_each_entry_safe(e, e2, &to_deliver, link) {
+                list_del(&e->link);
+                watcher->new_smi(e->intf_num, e->intf->si_dev);
+                kref_put(&e->intf->refcount, intf_free);
+                kfree(e);
+        }
+
+        mutex_unlock(&smi_watchers_mutex);
+
         return 0;
+
+ out_err:
+        mutex_unlock(&ipmi_interfaces_mutex);
+        mutex_unlock(&smi_watchers_mutex);
+        list_for_each_entry_safe(e, e2, &to_deliver, link) {
+                list_del(&e->link);
+                kref_put(&e->intf->refcount, intf_free);
+                kfree(e);
+        }
+        return -ENOMEM;
 }
 
 int ipmi_smi_watcher_unregister(struct ipmi_smi_watcher *watcher)
 {
-        down_write(&smi_watchers_sem);
+        mutex_lock(&smi_watchers_mutex);
         list_del(&(watcher->link));
-        up_write(&smi_watchers_sem);
+        mutex_unlock(&smi_watchers_mutex);
         return 0;
 }
 
+/*
+ * Must be called with smi_watchers_mutex held.
+ */
 static void
 call_smi_watchers(int i, struct device *dev)
 {
         struct ipmi_smi_watcher *w;
 
-        down_read(&smi_watchers_sem);
         list_for_each_entry(w, &smi_watchers, link) {
                 if (try_module_get(w->owner)) {
                         w->new_smi(i, dev);
                         module_put(w->owner);
                 }
         }
-        up_read(&smi_watchers_sem);
 }
 
 static int
@@ -579,6 +637,17 @@ static void deliver_response(struct ipmi_recv_msg *msg)
         }
 }
 
+static void
+deliver_err_response(struct ipmi_recv_msg *msg, int err)
+{
+        msg->recv_type = IPMI_RESPONSE_RECV_TYPE;
+        msg->msg_data[0] = err;
+        msg->msg.netfn |= 1; /* Convert to a response. */
+        msg->msg.data_len = 1;
+        msg->msg.data = msg->msg_data;
+        deliver_response(msg);
+}
+
 /* Find the next sequence number not being used and add the given
    message with the given timeout to the sequence table.  This must be
    called with the interface's seq_lock held. */
@@ -716,14 +785,8 @@ static int intf_err_seq(ipmi_smi_t   intf,
         }
         spin_unlock_irqrestore(&(intf->seq_lock), flags);
 
-        if (msg) {
-                msg->recv_type = IPMI_RESPONSE_RECV_TYPE;
-                msg->msg_data[0] = err;
-                msg->msg.netfn |= 1; /* Convert to a response. */
-                msg->msg.data_len = 1;
-                msg->msg.data = msg->msg_data;
-                deliver_response(msg);
-        }
+        if (msg)
+                deliver_err_response(msg, err);
 
         return rv;
 }
@@ -765,17 +828,18 @@ int ipmi_create_user(unsigned int          if_num,
         if (!new_user)
                 return -ENOMEM;
 
-        spin_lock_irqsave(&interfaces_lock, flags);
-        intf = ipmi_interfaces[if_num];
-        if ((if_num >= MAX_IPMI_INTERFACES) || IPMI_INVALID_INTERFACE(intf)) {
-                spin_unlock_irqrestore(&interfaces_lock, flags);
-                rv = -EINVAL;
-                goto out_kfree;
+        mutex_lock(&ipmi_interfaces_mutex);
+        list_for_each_entry_rcu(intf, &ipmi_interfaces, link) {
+                if (intf->intf_num == if_num)
+                        goto found;
         }
+        /* Not found, return an error */
+        rv = -EINVAL;
+        goto out_kfree;
 
+ found:
         /* Note that each existing user holds a refcount to the interface. */
         kref_get(&intf->refcount);
-        spin_unlock_irqrestore(&interfaces_lock, flags);
 
         kref_init(&new_user->refcount);
         new_user->handler = handler;
@@ -796,6 +860,10 @@ int ipmi_create_user(unsigned int          if_num,
                 }
         }
 
+        /* Hold the lock so intf->handlers is guaranteed to be good
+         * until now */
+        mutex_unlock(&ipmi_interfaces_mutex);
+
         new_user->valid = 1;
         spin_lock_irqsave(&intf->seq_lock, flags);
         list_add_rcu(&new_user->link, &intf->users);
@@ -806,6 +874,7 @@ int ipmi_create_user(unsigned int          if_num,
 out_kref:
         kref_put(&intf->refcount, intf_free);
 out_kfree:
+        mutex_unlock(&ipmi_interfaces_mutex);
         kfree(new_user);
         return rv;
 }
@@ -835,6 +904,7 @@ int ipmi_destroy_user(ipmi_user_t user)
                     && (intf->seq_table[i].recv_msg->user == user))
                 {
                         intf->seq_table[i].inuse = 0;
+                        ipmi_free_recv_msg(intf->seq_table[i].recv_msg);
                 }
         }
         spin_unlock_irqrestore(&intf->seq_lock, flags);
@@ -861,9 +931,13 @@ int ipmi_destroy_user(ipmi_user_t user)
                 kfree(rcvr);
         }
 
-        module_put(intf->handlers->owner);
-        if (intf->handlers->dec_usecount)
-                intf->handlers->dec_usecount(intf->send_info);
+        mutex_lock(&ipmi_interfaces_mutex);
+        if (intf->handlers) {
+                module_put(intf->handlers->owner);
+                if (intf->handlers->dec_usecount)
+                        intf->handlers->dec_usecount(intf->send_info);
+        }
+        mutex_unlock(&ipmi_interfaces_mutex);
 
         kref_put(&intf->refcount, intf_free);
 
@@ -876,8 +950,8 @@ void ipmi_get_version(ipmi_user_t   user,
                       unsigned char *major,
                       unsigned char *minor)
 {
-        *major = ipmi_version_major(&user->intf->bmc->id);
-        *minor = ipmi_version_minor(&user->intf->bmc->id);
+        *major = user->intf->ipmi_version_major;
+        *minor = user->intf->ipmi_version_minor;
 }
 
 int ipmi_set_my_address(ipmi_user_t   user,
@@ -920,6 +994,65 @@ int ipmi_get_my_LUN(ipmi_user_t   user,
         return 0;
 }
 
+int ipmi_get_maintenance_mode(ipmi_user_t user)
+{
+        int           mode;
+        unsigned long flags;
+
+        spin_lock_irqsave(&user->intf->maintenance_mode_lock, flags);
+        mode = user->intf->maintenance_mode;
+        spin_unlock_irqrestore(&user->intf->maintenance_mode_lock, flags);
+
+        return mode;
+}
+EXPORT_SYMBOL(ipmi_get_maintenance_mode);
+
+static void maintenance_mode_update(ipmi_smi_t intf)
+{
+        if (intf->handlers->set_maintenance_mode)
+                intf->handlers->set_maintenance_mode(
+                        intf->send_info, intf->maintenance_mode_enable);
+}
+
+int ipmi_set_maintenance_mode(ipmi_user_t user, int mode)
+{
+        int           rv = 0;
+        unsigned long flags;
+        ipmi_smi_t    intf = user->intf;
+
+        spin_lock_irqsave(&intf->maintenance_mode_lock, flags);
+        if (intf->maintenance_mode != mode) {
+                switch (mode) {
+                case IPMI_MAINTENANCE_MODE_AUTO:
+                        intf->maintenance_mode = mode;
+                        intf->maintenance_mode_enable
+                                = (intf->auto_maintenance_timeout > 0);
+                        break;
+
+                case IPMI_MAINTENANCE_MODE_OFF:
+                        intf->maintenance_mode = mode;
+                        intf->maintenance_mode_enable = 0;
+                        break;
+
+                case IPMI_MAINTENANCE_MODE_ON:
+                        intf->maintenance_mode = mode;
+                        intf->maintenance_mode_enable = 1;
+                        break;
+
+                default:
+                        rv = -EINVAL;
+                        goto out_unlock;
+                }
+
+                maintenance_mode_update(intf);
+        }
+ out_unlock:
+        spin_unlock_irqrestore(&intf->maintenance_mode_lock, flags);
+
+        return rv;
+}
+EXPORT_SYMBOL(ipmi_set_maintenance_mode);
+
 int ipmi_set_gets_events(ipmi_user_t user, int val)
 {
         unsigned long        flags;
@@ -932,20 +1065,33 @@ int ipmi_set_gets_events(ipmi_user_t user, int val)
         spin_lock_irqsave(&intf->events_lock, flags);
         user->gets_events = val;
 
-        if (val) {
-                /* Deliver any queued events. */
+        if (intf->delivering_events)
+                /*
+                 * Another thread is delivering events for this, so
+                 * let it handle any new events.
+                 */
+                goto out;
+
+        /* Deliver any queued events. */
+        while (user->gets_events && !list_empty(&intf->waiting_events)) {
                 list_for_each_entry_safe(msg, msg2, &intf->waiting_events, link)
                         list_move_tail(&msg->link, &msgs);
                 intf->waiting_events_count = 0;
-        }
 
-        /* Hold the events lock while doing this to preserve order. */
-        list_for_each_entry_safe(msg, msg2, &msgs, link) {
-                msg->user = user;
-                kref_get(&user->refcount);
-                deliver_response(msg);
+                intf->delivering_events = 1;
+                spin_unlock_irqrestore(&intf->events_lock, flags);
+
+                list_for_each_entry_safe(msg, msg2, &msgs, link) {
+                        msg->user = user;
+                        kref_get(&user->refcount);
+                        deliver_response(msg);
+                }
+
+                spin_lock_irqsave(&intf->events_lock, flags);
+                intf->delivering_events = 0;
         }
 
+ out:
         spin_unlock_irqrestore(&intf->events_lock, flags);
 
         return 0;
@@ -953,24 +1099,41 @@ int ipmi_set_gets_events(ipmi_user_t user, int val)
 
 static struct cmd_rcvr *find_cmd_rcvr(ipmi_smi_t    intf,
                                       unsigned char netfn,
-                                      unsigned char cmd)
+                                      unsigned char cmd,
+                                      unsigned char chan)
 {
         struct cmd_rcvr *rcvr;
 
         list_for_each_entry_rcu(rcvr, &intf->cmd_rcvrs, link) {
-                if ((rcvr->netfn == netfn) && (rcvr->cmd == cmd))
+                if ((rcvr->netfn == netfn) && (rcvr->cmd == cmd)
+                                        && (rcvr->chans & (1 << chan)))
                         return rcvr;
         }
         return NULL;
 }
 
+static int is_cmd_rcvr_exclusive(ipmi_smi_t    intf,
+                                 unsigned char netfn,
+                                 unsigned char cmd,
+                                 unsigned int  chans)
+{
+        struct cmd_rcvr *rcvr;
+
+        list_for_each_entry_rcu(rcvr, &intf->cmd_rcvrs, link) {
+                if ((rcvr->netfn == netfn) && (rcvr->cmd == cmd)
+                                        && (rcvr->chans & chans))
+                        return 0;
+        }
+        return 1;
+}
+
 int ipmi_register_for_cmd(ipmi_user_t   user,
                           unsigned char netfn,
-                          unsigned char cmd)
+                          unsigned char cmd,
+                          unsigned int  chans)
 {
         ipmi_smi_t      intf = user->intf;
         struct cmd_rcvr *rcvr;
-        struct cmd_rcvr *entry;
         int             rv = 0;
 
 
@@ -979,12 +1142,12 @@ int ipmi_register_for_cmd(ipmi_user_t   user,
                 return -ENOMEM;
         rcvr->cmd = cmd;
         rcvr->netfn = netfn;
+        rcvr->chans = chans;
         rcvr->user = user;
 
         mutex_lock(&intf->cmd_rcvrs_mutex);
         /* Make sure the command/netfn is not already registered. */
-        entry = find_cmd_rcvr(intf, netfn, cmd);
-        if (entry) {
+        if (!is_cmd_rcvr_exclusive(intf, netfn, cmd, chans)) {
                 rv = -EBUSY;
                 goto out_unlock;
         }
@@ -1001,30 +1164,46 @@ int ipmi_register_for_cmd(ipmi_user_t   user,
 
 int ipmi_unregister_for_cmd(ipmi_user_t   user,
                             unsigned char netfn,
-                            unsigned char cmd)
+                            unsigned char cmd,
+                            unsigned int  chans)
 {
         ipmi_smi_t      intf = user->intf;
         struct cmd_rcvr *rcvr;
+        struct cmd_rcvr *rcvrs = NULL;
+        int i, rv = -ENOENT;
 
         mutex_lock(&intf->cmd_rcvrs_mutex);
-        /* Make sure the command/netfn is not already registered. */
-        rcvr = find_cmd_rcvr(intf, netfn, cmd);
-        if ((rcvr) && (rcvr->user == user)) {
-                list_del_rcu(&rcvr->link);
-                mutex_unlock(&intf->cmd_rcvrs_mutex);
-                synchronize_rcu();
+        for (i = 0; i < IPMI_NUM_CHANNELS; i++) {
+                if (((1 << i) & chans) == 0)
+                        continue;
+                rcvr = find_cmd_rcvr(intf, netfn, cmd, i);
+                if (rcvr == NULL)
+                        continue;
+                if (rcvr->user == user) {
+                        rv = 0;
+                        rcvr->chans &= ~chans;
+                        if (rcvr->chans == 0) {
+                                list_del_rcu(&rcvr->link);
+                                rcvr->next = rcvrs;
+                                rcvrs = rcvr;
+                        }
+                }
+        }
+        mutex_unlock(&intf->cmd_rcvrs_mutex);
+        synchronize_rcu();
+        while (rcvrs) {
+                rcvr = rcvrs;
+                rcvrs = rcvr->next;
                 kfree(rcvr);
-                return 0;
-        } else {
-                mutex_unlock(&intf->cmd_rcvrs_mutex);
-                return -ENOENT;
         }
+        return rv;
 }
 
 void ipmi_user_set_run_to_completion(ipmi_user_t user, int val)
 {
         ipmi_smi_t intf = user->intf;
-        intf->handlers->set_run_to_completion(intf->send_info, val);
+        if (intf->handlers)
+                intf->handlers->set_run_to_completion(intf->send_info, val);
 }
 
 static unsigned char
@@ -1135,10 +1314,11 @@ static int i_ipmi_request(ipmi_user_t          user,
                           int                  retries,
                           unsigned int         retry_time_ms)
 {
-        int                  rv = 0;
-        struct ipmi_smi_msg  *smi_msg;
-        struct ipmi_recv_msg *recv_msg;
-        unsigned long        flags;
+        int                      rv = 0;
+        struct ipmi_smi_msg      *smi_msg;
+        struct ipmi_recv_msg     *recv_msg;
+        unsigned long            flags;
+        struct ipmi_smi_handlers *handlers;
 
 
         if (supplied_recv) {
@@ -1161,6 +1341,13 @@ static int i_ipmi_request(ipmi_user_t          user,
                 }
         }
 
+        rcu_read_lock();
+        handlers = intf->handlers;
+        if (!handlers) {
+                rv = -ENODEV;
+                goto out_err;
+        }
+
         recv_msg->user = user;
         if (user)
                 kref_get(&user->refcount);
@@ -1203,6 +1390,24 @@ static int i_ipmi_request(ipmi_user_t          user,
                         goto out_err;
                 }
 
+                if (((msg->netfn == IPMI_NETFN_APP_REQUEST)
+                      && ((msg->cmd == IPMI_COLD_RESET_CMD)
+                          || (msg->cmd == IPMI_WARM_RESET_CMD)))
+                     || (msg->netfn == IPMI_NETFN_FIRMWARE_REQUEST))
+                {
+                        spin_lock_irqsave(&intf->maintenance_mode_lock, flags);
+                        intf->auto_maintenance_timeout
+                                = IPMI_MAINTENANCE_MODE_TIMEOUT;
+                        if (!intf->maintenance_mode
+                            && !intf->maintenance_mode_enable)
+                        {
+                                intf->maintenance_mode_enable = 1;
+                                maintenance_mode_update(intf);
+                        }
+                        spin_unlock_irqrestore(&intf->maintenance_mode_lock,
+                                               flags);
+                }
+
                 if ((msg->data_len + 2) > IPMI_MAX_MSG_LENGTH) {
                         spin_lock_irqsave(&intf->counter_lock, flags);
                         intf->sent_invalid_commands++;
@@ -1477,11 +1682,14 @@ static int i_ipmi_request(ipmi_user_t          user,
                 printk("\n");
         }
 #endif
-        intf->handlers->sender(intf->send_info, smi_msg, priority);
+
+        handlers->sender(intf->send_info, smi_msg, priority);
+        rcu_read_unlock();
 
         return 0;
 
  out_err:
+        rcu_read_unlock();
         ipmi_free_smi_msg(smi_msg);
         ipmi_free_recv_msg(recv_msg);
         return rv;
@@ -1561,6 +1769,7 @@ int ipmi_request_supply_msgs(ipmi_user_t          user,
                               -1, 0);
 }
 
+#ifdef CONFIG_PROC_FS
 static int ipmb_file_read_proc(char *page, char **start, off_t off,
                                int count, int *eof, void *data)
 {
@@ -1649,6 +1858,7 @@ static int stat_file_read_proc(char *page, char **start, off_t off,
 
         return (out - ((char *) page));
 }
+#endif /* CONFIG_PROC_FS */
 
 int ipmi_smi_add_proc_entry(ipmi_smi_t smi, char *name,
                             read_proc_t *read_proc, write_proc_t *write_proc,
@@ -1774,13 +1984,12 @@ static int __find_bmc_prod_dev_id(struct device *dev, void *data)
         struct bmc_device *bmc = dev_get_drvdata(dev);
 
         return (bmc->id.product_id == id->product_id
-                && bmc->id.product_id == id->product_id
                 && bmc->id.device_id == id->device_id);
 }
 
 static struct bmc_device *ipmi_find_bmc_prod_dev_id(
         struct device_driver *drv,
-        unsigned char product_id, unsigned char device_id)
+        unsigned int product_id, unsigned char device_id)
 {
         struct prod_dev_id id = {
                 .product_id = product_id,
@@ -1811,7 +2020,7 @@ static ssize_t provides_dev_sdrs_show(struct device *dev,
         struct bmc_device *bmc = dev_get_drvdata(dev);
 
         return snprintf(buf, 10, "%u\n",
-                        bmc->id.device_revision && 0x80 >> 7);
+                        (bmc->id.device_revision & 0x80) >> 7);
 }
 
 static ssize_t revision_show(struct device *dev, struct device_attribute *attr,
@@ -1820,7 +2029,7 @@ static ssize_t revision_show(struct device *dev, struct device_attribute *attr,
         struct bmc_device *bmc = dev_get_drvdata(dev);
 
         return snprintf(buf, 20, "%u\n",
-                        bmc->id.device_revision && 0x0F);
+                        bmc->id.device_revision & 0x0F);
 }
 
 static ssize_t firmware_rev_show(struct device *dev,
@@ -1895,12 +2104,10 @@ static ssize_t guid_show(struct device *dev, struct device_attribute *attr,
                         (long long) bmc->guid[8]);
 }
 
-static void
-cleanup_bmc_device(struct kref *ref)
+static void remove_files(struct bmc_device *bmc)
 {
-        struct bmc_device *bmc;
-
-        bmc = container_of(ref, struct bmc_device, refcount);
+        if (!bmc->dev)
+                return;
 
         device_remove_file(&bmc->dev->dev,
                            &bmc->device_id_attr);
@@ -1918,12 +2125,23 @@ cleanup_bmc_device(struct kref *ref)
                            &bmc->manufacturer_id_attr);
         device_remove_file(&bmc->dev->dev,
                            &bmc->product_id_attr);
+
         if (bmc->id.aux_firmware_revision_set)
                 device_remove_file(&bmc->dev->dev,
                                    &bmc->aux_firmware_rev_attr);
         if (bmc->guid_set)
                 device_remove_file(&bmc->dev->dev,
                                    &bmc->guid_attr);
+}
+
+static void
+cleanup_bmc_device(struct kref *ref)
+{
+        struct bmc_device *bmc;
+
+        bmc = container_of(ref, struct bmc_device, refcount);
+
+        remove_files(bmc);
         platform_device_unregister(bmc->dev);
         kfree(bmc);
 }
@@ -1932,7 +2150,11 @@ static void ipmi_bmc_unregister(ipmi_smi_t intf)
 {
         struct bmc_device *bmc = intf->bmc;
 
-        sysfs_remove_link(&intf->si_dev->kobj, "bmc");
+        if (intf->sysfs_name) {
+                sysfs_remove_link(&intf->si_dev->kobj, intf->sysfs_name);
+                kfree(intf->sysfs_name);
+                intf->sysfs_name = NULL;
+        }
         if (intf->my_dev_name) {
                 sysfs_remove_link(&bmc->dev->dev.kobj, intf->my_dev_name);
                 kfree(intf->my_dev_name);
@@ -1941,10 +2163,135 @@ static void ipmi_bmc_unregister(ipmi_smi_t intf)
 
         mutex_lock(&ipmidriver_mutex);
         kref_put(&bmc->refcount, cleanup_bmc_device);
+        intf->bmc = NULL;
         mutex_unlock(&ipmidriver_mutex);
 }
 
-static int ipmi_bmc_register(ipmi_smi_t intf)
+static int create_files(struct bmc_device *bmc)
+{
+        int err;
+
+        bmc->device_id_attr.attr.name = "device_id";
+        bmc->device_id_attr.attr.owner = THIS_MODULE;
+        bmc->device_id_attr.attr.mode = S_IRUGO;
+        bmc->device_id_attr.show = device_id_show;
+
+        bmc->provides_dev_sdrs_attr.attr.name = "provides_device_sdrs";
+        bmc->provides_dev_sdrs_attr.attr.owner = THIS_MODULE;
+        bmc->provides_dev_sdrs_attr.attr.mode = S_IRUGO;
+        bmc->provides_dev_sdrs_attr.show = provides_dev_sdrs_show;
+
+        bmc->revision_attr.attr.name = "revision";
+        bmc->revision_attr.attr.owner = THIS_MODULE;
+        bmc->revision_attr.attr.mode = S_IRUGO;
+        bmc->revision_attr.show = revision_show;
+
+        bmc->firmware_rev_attr.attr.name = "firmware_revision";
+        bmc->firmware_rev_attr.attr.owner = THIS_MODULE;
+        bmc->firmware_rev_attr.attr.mode = S_IRUGO;
+        bmc->firmware_rev_attr.show = firmware_rev_show;
+
+        bmc->version_attr.attr.name = "ipmi_version";
+        bmc->version_attr.attr.owner = THIS_MODULE;
+        bmc->version_attr.attr.mode = S_IRUGO;
+        bmc->version_attr.show = ipmi_version_show;
+
+        bmc->add_dev_support_attr.attr.name = "additional_device_support";
+        bmc->add_dev_support_attr.attr.owner = THIS_MODULE;
+        bmc->add_dev_support_attr.attr.mode = S_IRUGO;
+        bmc->add_dev_support_attr.show = add_dev_support_show;
+
+        bmc->manufacturer_id_attr.attr.name = "manufacturer_id";
+        bmc->manufacturer_id_attr.attr.owner = THIS_MODULE;
+        bmc->manufacturer_id_attr.attr.mode = S_IRUGO;
+        bmc->manufacturer_id_attr.show = manufacturer_id_show;
+
+        bmc->product_id_attr.attr.name = "product_id";
+        bmc->product_id_attr.attr.owner = THIS_MODULE;
+        bmc->product_id_attr.attr.mode = S_IRUGO;
+        bmc->product_id_attr.show = product_id_show;
+
+        bmc->guid_attr.attr.name = "guid";
+        bmc->guid_attr.attr.owner = THIS_MODULE;
+        bmc->guid_attr.attr.mode = S_IRUGO;
+        bmc->guid_attr.show = guid_show;
+
+        bmc->aux_firmware_rev_attr.attr.name = "aux_firmware_revision";
+        bmc->aux_firmware_rev_attr.attr.owner = THIS_MODULE;
+        bmc->aux_firmware_rev_attr.attr.mode = S_IRUGO;
+        bmc->aux_firmware_rev_attr.show = aux_firmware_rev_show;
+
+        err = device_create_file(&bmc->dev->dev,
+                           &bmc->device_id_attr);
+        if (err) goto out;
+        err = device_create_file(&bmc->dev->dev,
+                           &bmc->provides_dev_sdrs_attr);
+        if (err) goto out_devid;
+        err = device_create_file(&bmc->dev->dev,
+                           &bmc->revision_attr);
+        if (err) goto out_sdrs;
+        err = device_create_file(&bmc->dev->dev,
+                           &bmc->firmware_rev_attr);
+        if (err) goto out_rev;
+        err = device_create_file(&bmc->dev->dev,
+                           &bmc->version_attr);
+        if (err) goto out_firm;
+        err = device_create_file(&bmc->dev->dev,
+                           &bmc->add_dev_support_attr);
+        if (err) goto out_version;
+        err = device_create_file(&bmc->dev->dev,
+                           &bmc->manufacturer_id_attr);
+        if (err) goto out_add_dev;
+        err = device_create_file(&bmc->dev->dev,
+                           &bmc->product_id_attr);
+        if (err) goto out_manu;
+        if (bmc->id.aux_firmware_revision_set) {
+                err = device_create_file(&bmc->dev->dev,
+                                   &bmc->aux_firmware_rev_attr);
+                if (err) goto out_prod_id;
+        }
+        if (bmc->guid_set) {
+                err = device_create_file(&bmc->dev->dev,
+                                   &bmc->guid_attr);
+                if (err) goto out_aux_firm;
+        }
+
+        return 0;
+
+out_aux_firm:
+        if (bmc->id.aux_firmware_revision_set)
+                device_remove_file(&bmc->dev->dev,
+                                   &bmc->aux_firmware_rev_attr);
+out_prod_id:
+        device_remove_file(&bmc->dev->dev,
+                           &bmc->product_id_attr);
+out_manu:
+        device_remove_file(&bmc->dev->dev,
+                           &bmc->manufacturer_id_attr);
+out_add_dev:
+        device_remove_file(&bmc->dev->dev,
+                           &bmc->add_dev_support_attr);
+out_version:
+        device_remove_file(&bmc->dev->dev,
+                           &bmc->version_attr);
+out_firm:
+        device_remove_file(&bmc->dev->dev,
+                           &bmc->firmware_rev_attr);
+out_rev:
+        device_remove_file(&bmc->dev->dev,
+                           &bmc->revision_attr);
+out_sdrs:
+        device_remove_file(&bmc->dev->dev,
+                           &bmc->provides_dev_sdrs_attr);
+out_devid:
+        device_remove_file(&bmc->dev->dev,
+                           &bmc->device_id_attr);
+out:
+        return err;
+}
+
+static int ipmi_bmc_register(ipmi_smi_t intf, int ifnum,
+                             const char *sysfs_name)
 {
         int               rv;
         struct bmc_device *bmc = intf->bmc;
@@ -1984,9 +2331,38 @@ static int ipmi_bmc_register(ipmi_smi_t intf)
                        bmc->id.product_id,
                        bmc->id.device_id);
         } else {
-                bmc->dev = platform_device_alloc("ipmi_bmc",
-                                                 bmc->id.device_id);
+                char name[14];
+                unsigned char orig_dev_id = bmc->id.device_id;
+                int warn_printed = 0;
+
+                snprintf(name, sizeof(name),
+                         "ipmi_bmc.%4.4x", bmc->id.product_id);
+
+                while (ipmi_find_bmc_prod_dev_id(&ipmidriver,
+                                                 bmc->id.product_id,
+                                                 bmc->id.device_id)) {
+                        if (!warn_printed) {
+                                printk(KERN_WARNING PFX
+                                       "This machine has two different BMCs"
+                                       " with the same product id and device"
+                                       " id.  This is an error in the"
+                                       " firmware, but incrementing the"
+                                       " device id to work around the problem."
+                                       " Prod ID = 0x%x, Dev ID = 0x%x\n",
+                                       bmc->id.product_id, bmc->id.device_id);
+                                warn_printed = 1;
+                        }
+                        bmc->id.device_id++; /* Wraps at 255 */
+                        if (bmc->id.device_id == orig_dev_id) {
+                                printk(KERN_ERR PFX
+                                       "Out of device ids!\n");
+                                break;
+                        }
+                }
+
+                bmc->dev = platform_device_alloc(name, bmc->id.device_id);
                 if (!bmc->dev) {
+                        mutex_unlock(&ipmidriver_mutex);
                         printk(KERN_ERR
                                "ipmi_msghandler:"
                                " Unable to allocate platform device\n");
@@ -1996,9 +2372,11 @@ static int ipmi_bmc_register(ipmi_smi_t intf)
                 dev_set_drvdata(&bmc->dev->dev, bmc);
                 kref_init(&bmc->refcount);
 
-                rv = platform_device_register(bmc->dev);
+                rv = platform_device_add(bmc->dev);
                 mutex_unlock(&ipmidriver_mutex);
                 if (rv) {
+                        platform_device_put(bmc->dev);
+                        bmc->dev = NULL;
                         printk(KERN_ERR
                                "ipmi_msghandler:"
                                " Unable to register bmc device: %d\n",
@@ -2008,80 +2386,14 @@ static int ipmi_bmc_register(ipmi_smi_t intf)
                         return rv;
                 }
 
-                bmc->device_id_attr.attr.name = "device_id";
-                bmc->device_id_attr.attr.owner = THIS_MODULE;
-                bmc->device_id_attr.attr.mode = S_IRUGO;
-                bmc->device_id_attr.show = device_id_show;
-
-                bmc->provides_dev_sdrs_attr.attr.name = "provides_device_sdrs";
-                bmc->provides_dev_sdrs_attr.attr.owner = THIS_MODULE;
-                bmc->provides_dev_sdrs_attr.attr.mode = S_IRUGO;
-                bmc->provides_dev_sdrs_attr.show = provides_dev_sdrs_show;
-
-
-                bmc->revision_attr.attr.name = "revision";
-                bmc->revision_attr.attr.owner = THIS_MODULE;
-                bmc->revision_attr.attr.mode = S_IRUGO;
-                bmc->revision_attr.show = revision_show;
-
-                bmc->firmware_rev_attr.attr.name = "firmware_revision";
-                bmc->firmware_rev_attr.attr.owner = THIS_MODULE;
-                bmc->firmware_rev_attr.attr.mode = S_IRUGO;
-                bmc->firmware_rev_attr.show = firmware_rev_show;
-
-                bmc->version_attr.attr.name = "ipmi_version";
-                bmc->version_attr.attr.owner = THIS_MODULE;
-                bmc->version_attr.attr.mode = S_IRUGO;
-                bmc->version_attr.show = ipmi_version_show;
-
-                bmc->add_dev_support_attr.attr.name
-                        = "additional_device_support";
-                bmc->add_dev_support_attr.attr.owner = THIS_MODULE;
-                bmc->add_dev_support_attr.attr.mode = S_IRUGO;
-                bmc->add_dev_support_attr.show = add_dev_support_show;
-
-                bmc->manufacturer_id_attr.attr.name = "manufacturer_id";
-                bmc->manufacturer_id_attr.attr.owner = THIS_MODULE;
-                bmc->manufacturer_id_attr.attr.mode = S_IRUGO;
-                bmc->manufacturer_id_attr.show = manufacturer_id_show;
-
-                bmc->product_id_attr.attr.name = "product_id";
-                bmc->product_id_attr.attr.owner = THIS_MODULE;
-                bmc->product_id_attr.attr.mode = S_IRUGO;
-                bmc->product_id_attr.show = product_id_show;
-
-                bmc->guid_attr.attr.name = "guid";
-                bmc->guid_attr.attr.owner = THIS_MODULE;
-                bmc->guid_attr.attr.mode = S_IRUGO;
-                bmc->guid_attr.show = guid_show;
-
-                bmc->aux_firmware_rev_attr.attr.name = "aux_firmware_revision";
-                bmc->aux_firmware_rev_attr.attr.owner = THIS_MODULE;
-                bmc->aux_firmware_rev_attr.attr.mode = S_IRUGO;
-                bmc->aux_firmware_rev_attr.show = aux_firmware_rev_show;
-
-                device_create_file(&bmc->dev->dev,
-                                   &bmc->device_id_attr);
-                device_create_file(&bmc->dev->dev,
-                                   &bmc->provides_dev_sdrs_attr);
-                device_create_file(&bmc->dev->dev,
-                                   &bmc->revision_attr);
-                device_create_file(&bmc->dev->dev,
-                                   &bmc->firmware_rev_attr);
-                device_create_file(&bmc->dev->dev,
-                                   &bmc->version_attr);
-                device_create_file(&bmc->dev->dev,
-                                   &bmc->add_dev_support_attr);
-                device_create_file(&bmc->dev->dev,
-                                   &bmc->manufacturer_id_attr);
-                device_create_file(&bmc->dev->dev,
-                                   &bmc->product_id_attr);
-                if (bmc->id.aux_firmware_revision_set)
-                        device_create_file(&bmc->dev->dev,
-                                           &bmc->aux_firmware_rev_attr);
-                if (bmc->guid_set)
-                        device_create_file(&bmc->dev->dev,
-                                           &bmc->guid_attr);
+                rv = create_files(bmc);
+                if (rv) {
+                        mutex_lock(&ipmidriver_mutex);
+                        platform_device_unregister(bmc->dev);
+                        mutex_unlock(&ipmidriver_mutex);
+
+                        return rv;
+                }
 
                 printk(KERN_INFO
                        "ipmi: Found new BMC (man_id: 0x%6.6x, "
@@ -2095,29 +2407,44 @@ static int ipmi_bmc_register(ipmi_smi_t intf)
          * create symlink from system interface device to bmc device
          * and back.
          */
+        intf->sysfs_name = kstrdup(sysfs_name, GFP_KERNEL);
+        if (!intf->sysfs_name) {
+                rv = -ENOMEM;
+                printk(KERN_ERR
+                       "ipmi_msghandler: allocate link to BMC: %d\n",
+                       rv);
+                goto out_err;
+        }
+
         rv = sysfs_create_link(&intf->si_dev->kobj,
-                               &bmc->dev->dev.kobj, "bmc");
+                               &bmc->dev->dev.kobj, intf->sysfs_name);
         if (rv) {
+                kfree(intf->sysfs_name);
+                intf->sysfs_name = NULL;
                 printk(KERN_ERR
                        "ipmi_msghandler: Unable to create bmc symlink: %d\n",
                        rv);
                 goto out_err;
         }
 
-        size = snprintf(dummy, 0, "ipmi%d", intf->intf_num);
+        size = snprintf(dummy, 0, "ipmi%d", ifnum);
         intf->my_dev_name = kmalloc(size+1, GFP_KERNEL);
         if (!intf->my_dev_name) {
+                kfree(intf->sysfs_name);
+                intf->sysfs_name = NULL;
                 rv = -ENOMEM;
                 printk(KERN_ERR
                        "ipmi_msghandler: allocate link from BMC: %d\n",
                        rv);
                 goto out_err;
         }
-        snprintf(intf->my_dev_name, size+1, "ipmi%d", intf->intf_num);
+        snprintf(intf->my_dev_name, size+1, "ipmi%d", ifnum);
 
         rv = sysfs_create_link(&bmc->dev->dev.kobj, &intf->si_dev->kobj,
                                intf->my_dev_name);
         if (rv) {
+                kfree(intf->sysfs_name);
+                intf->sysfs_name = NULL;
                 kfree(intf->my_dev_name);
                 intf->my_dev_name = NULL;
                 printk(KERN_ERR
@@ -2302,17 +2629,14 @@ int ipmi_register_smi(struct ipmi_smi_handlers *handlers,
                       void                     *send_info,
                       struct ipmi_device_id    *device_id,
                       struct device            *si_dev,
+                      const char               *sysfs_name,
                       unsigned char            slave_addr)
 {
         int              i, j;
         int              rv;
         ipmi_smi_t       intf;
-        unsigned long    flags;
-        int              version_major;
-        int              version_minor;
-
-        version_major = ipmi_version_major(device_id);
-        version_minor = ipmi_version_minor(device_id);
+        ipmi_smi_t       tintf;
+        struct list_head *link;
 
         /* Make sure the driver is actually initialized, this handles
            problems with initialization order. */
@@ -2330,12 +2654,16 @@ int ipmi_register_smi(struct ipmi_smi_handlers *handlers,
         if (!intf)
                 return -ENOMEM;
         memset(intf, 0, sizeof(*intf));
+
+        intf->ipmi_version_major = ipmi_version_major(device_id);
+        intf->ipmi_version_minor = ipmi_version_minor(device_id);
+
         intf->bmc = kzalloc(sizeof(*intf->bmc), GFP_KERNEL);
         if (!intf->bmc) {
                 kfree(intf);
                 return -ENOMEM;
         }
-        intf->intf_num = -1;
+        intf->intf_num = -1; /* Mark it invalid for now. */
         kref_init(&intf->refcount);
         intf->bmc->id = *device_id;
         intf->si_dev = si_dev;
@@ -2363,26 +2691,30 @@ int ipmi_register_smi(struct ipmi_smi_handlers *handlers,
         INIT_LIST_HEAD(&intf->waiting_events);
         intf->waiting_events_count = 0;
         mutex_init(&intf->cmd_rcvrs_mutex);
+        spin_lock_init(&intf->maintenance_mode_lock);
         INIT_LIST_HEAD(&intf->cmd_rcvrs);
         init_waitqueue_head(&intf->waitq);
 
         spin_lock_init(&intf->counter_lock);
         intf->proc_dir = NULL;
 
-        rv = -ENOMEM;
-        spin_lock_irqsave(&interfaces_lock, flags);
-        for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
-                if (ipmi_interfaces[i] == NULL) {
-                        intf->intf_num = i;
-                        /* Reserve the entry till we are done. */
-                        ipmi_interfaces[i] = IPMI_INVALID_INTERFACE_ENTRY;
-                        rv = 0;
+        mutex_lock(&smi_watchers_mutex);
+        mutex_lock(&ipmi_interfaces_mutex);
+        /* Look for a hole in the numbers. */
+        i = 0;
+        link = &ipmi_interfaces;
+        list_for_each_entry_rcu(tintf, &ipmi_interfaces, link) {
+                if (tintf->intf_num != i) {
+                        link = &tintf->link;
                         break;
                 }
+                i++;
         }
-        spin_unlock_irqrestore(&interfaces_lock, flags);
-        if (rv)
-                goto out;
+        /* Add the new interface in numeric order. */
+        if (i == 0)
+                list_add_rcu(&intf->link, &ipmi_interfaces);
+        else
+                list_add_tail_rcu(&intf->link, link);
 
         rv = handlers->start_processing(send_info, intf);
         if (rv)
@@ -2390,8 +2722,9 @@ int ipmi_register_smi(struct ipmi_smi_handlers *handlers,
 
         get_guid(intf);
 
-        if ((version_major > 1)
-            || ((version_major == 1) && (version_minor >= 5)))
+        if ((intf->ipmi_version_major > 1)
+            || ((intf->ipmi_version_major == 1)
+                && (intf->ipmi_version_minor >= 5)))
         {
                 /* Start scanning the channels to see what is
                    available. */
@@ -2414,64 +2747,67 @@ int ipmi_register_smi(struct ipmi_smi_handlers *handlers,
         if (rv == 0)
                 rv = add_proc_entries(intf, i);
 
-        rv = ipmi_bmc_register(intf);
+        rv = ipmi_bmc_register(intf, i, sysfs_name);
 
  out:
         if (rv) {
                 if (intf->proc_dir)
                         remove_proc_entries(intf);
+                intf->handlers = NULL;
+                list_del_rcu(&intf->link);
+                mutex_unlock(&ipmi_interfaces_mutex);
+                mutex_unlock(&smi_watchers_mutex);
+                synchronize_rcu();
                 kref_put(&intf->refcount, intf_free);
-                if (i < MAX_IPMI_INTERFACES) {
-                        spin_lock_irqsave(&interfaces_lock, flags);
-                        ipmi_interfaces[i] = NULL;
-                        spin_unlock_irqrestore(&interfaces_lock, flags);
-                }
         } else {
-                spin_lock_irqsave(&interfaces_lock, flags);
-                ipmi_interfaces[i] = intf;
-                spin_unlock_irqrestore(&interfaces_lock, flags);
+                /* After this point the interface is legal to use. */
+                intf->intf_num = i;
+                mutex_unlock(&ipmi_interfaces_mutex);
                 call_smi_watchers(i, intf->si_dev);
+                mutex_unlock(&smi_watchers_mutex);
         }
 
         return rv;
 }
 
+static void cleanup_smi_msgs(ipmi_smi_t intf)
+{
+        int              i;
+        struct seq_table *ent;
+
+        /* No need for locks, the interface is down. */
+        for (i = 0; i < IPMI_IPMB_NUM_SEQ; i++) {
+                ent = &(intf->seq_table[i]);
+                if (!ent->inuse)
+                        continue;
+                deliver_err_response(ent->recv_msg, IPMI_ERR_UNSPECIFIED);
+        }
+}
+
 int ipmi_unregister_smi(ipmi_smi_t intf)
 {
-        int                     i;
         struct ipmi_smi_watcher *w;
-        unsigned long           flags;
+        int    intf_num = intf->intf_num;
 
         ipmi_bmc_unregister(intf);
 
-        spin_lock_irqsave(&interfaces_lock, flags);
-        for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
-                if (ipmi_interfaces[i] == intf) {
-                        /* Set the interface number reserved until we
-                         * are done. */
-                        ipmi_interfaces[i] = IPMI_INVALID_INTERFACE_ENTRY;
-                        intf->intf_num = -1;
-                        break;
-                }
-        }
-        spin_unlock_irqrestore(&interfaces_lock,flags);
+        mutex_lock(&smi_watchers_mutex);
+        mutex_lock(&ipmi_interfaces_mutex);
+        intf->intf_num = -1;
+        intf->handlers = NULL;
+        list_del_rcu(&intf->link);
+        mutex_unlock(&ipmi_interfaces_mutex);
+        synchronize_rcu();
 
-        if (i == MAX_IPMI_INTERFACES)
-                return -ENODEV;
+        cleanup_smi_msgs(intf);
 
         remove_proc_entries(intf);
 
         /* Call all the watcher interfaces to tell them that
            an interface is gone. */
-        down_read(&smi_watchers_sem);
         list_for_each_entry(w, &smi_watchers, link)
-                w->smi_gone(i);
-        up_read(&smi_watchers_sem);
-
-        /* Allow the entry to be reused now. */
-        spin_lock_irqsave(&interfaces_lock, flags);
-        ipmi_interfaces[i] = NULL;
-        spin_unlock_irqrestore(&interfaces_lock,flags);
+                w->smi_gone(intf_num);
+        mutex_unlock(&smi_watchers_mutex);
 
         kref_put(&intf->refcount, intf_free);
         return 0;
@@ -2548,10 +2884,12 @@ static int handle_ipmb_get_msg_cmd(ipmi_smi_t          intf,
         int                      rv = 0;
         unsigned char            netfn;
         unsigned char            cmd;
+        unsigned char            chan;
         ipmi_user_t              user = NULL;
         struct ipmi_ipmb_addr    *ipmb_addr;
         struct ipmi_recv_msg     *recv_msg;
         unsigned long            flags;
+        struct ipmi_smi_handlers *handlers;
 
         if (msg->rsp_size < 10) {
                 /* Message not big enough, just ignore it. */
@@ -2568,9 +2906,10 @@ static int handle_ipmb_get_msg_cmd(ipmi_smi_t          intf,
 
         netfn = msg->rsp[4] >> 2;
         cmd = msg->rsp[8];
+        chan = msg->rsp[3] & 0xf;
 
         rcu_read_lock();
-        rcvr = find_cmd_rcvr(intf, netfn, cmd);
+        rcvr = find_cmd_rcvr(intf, netfn, cmd, chan);
         if (rcvr) {
                 user = rcvr->user;
                 kref_get(&user->refcount);
@@ -2607,10 +2946,16 @@ static int handle_ipmb_get_msg_cmd(ipmi_smi_t          intf,
                 printk("\n");
         }
 #endif
-                intf->handlers->sender(intf->send_info, msg, 0);
-
-                rv = -1; /* We used the message, so return the value that
-                            causes it to not be freed or queued. */
+                rcu_read_lock();
+                handlers = intf->handlers;
+                if (handlers) {
+                        handlers->sender(intf->send_info, msg, 0);
+                        /* We used the message, so return the value
+                           that causes it to not be freed or
+                           queued. */
+                        rv = -1;
+                }
+                rcu_read_unlock();
         } else {
                 /* Deliver the message to the user. */
                 spin_lock_irqsave(&intf->counter_lock, flags);
@@ -2728,6 +3073,7 @@ static int handle_lan_get_msg_cmd(ipmi_smi_t          intf,
         int                      rv = 0;
         unsigned char            netfn;
         unsigned char            cmd;
+        unsigned char            chan;
         ipmi_user_t              user = NULL;
         struct ipmi_lan_addr     *lan_addr;
         struct ipmi_recv_msg     *recv_msg;
@@ -2748,9 +3094,10 @@ static int handle_lan_get_msg_cmd(ipmi_smi_t          intf,
 
         netfn = msg->rsp[6] >> 2;
         cmd = msg->rsp[10];
+        chan = msg->rsp[3] & 0xf;
 
         rcu_read_lock();
-        rcvr = find_cmd_rcvr(intf, netfn, cmd);
+        rcvr = find_cmd_rcvr(intf, netfn, cmd, chan);
         if (rcvr) {
                 user = rcvr->user;
                 kref_get(&user->refcount);
@@ -3131,7 +3478,9 @@ void ipmi_smi_msg_received(ipmi_smi_t          intf,
                    report the error immediately. */
                 if ((msg->rsp_size >= 3) && (msg->rsp[2] != 0)
                     && (msg->rsp[2] != IPMI_NODE_BUSY_ERR)
-                    && (msg->rsp[2] != IPMI_LOST_ARBITRATION_ERR))
+                    && (msg->rsp[2] != IPMI_LOST_ARBITRATION_ERR)
+                    && (msg->rsp[2] != IPMI_BUS_ERR)
+                    && (msg->rsp[2] != IPMI_NAK_ON_WRITE_ERR))
                 {
                         int chan = msg->rsp[3] & 0xf;
 
@@ -3196,16 +3545,6 @@ void ipmi_smi_watchdog_pretimeout(ipmi_smi_t intf)
         rcu_read_unlock();
 }
 
-static void
-handle_msg_timeout(struct ipmi_recv_msg *msg)
-{
-        msg->recv_type = IPMI_RESPONSE_RECV_TYPE;
-        msg->msg_data[0] = IPMI_TIMEOUT_COMPLETION_CODE;
-        msg->msg.netfn |= 1; /* Convert to a response. */
-        msg->msg.data_len = 1;
-        msg->msg.data = msg->msg_data;
-        deliver_response(msg);
-}
 
 static struct ipmi_smi_msg *
 smi_from_recv_msg(ipmi_smi_t intf, struct ipmi_recv_msg *recv_msg,
@@ -3237,7 +3576,11 @@ static void check_msg_timeout(ipmi_smi_t intf, struct seq_table *ent,
                               struct list_head *timeouts, long timeout_period,
                               int slot, unsigned long *flags)
 {
-        struct ipmi_recv_msg *msg;
+        struct ipmi_recv_msg     *msg;
+        struct ipmi_smi_handlers *handlers;
+
+        if (intf->intf_num == -1)
+                return;
 
         if (!ent->inuse)
                 return;
@@ -3280,13 +3623,19 @@ static void check_msg_timeout(ipmi_smi_t intf, struct seq_table *ent,
                         return;
 
                 spin_unlock_irqrestore(&intf->seq_lock, *flags);
+
                 /* Send the new message.  We send with a zero
                  * priority.  It timed out, I doubt time is
                  * that critical now, and high priority
                  * messages are really only for messages to the
                  * local MC, which don't get resent. */
-                intf->handlers->sender(intf->send_info,
-                                       smi_msg, 0);
+                handlers = intf->handlers;
+                if (handlers)
+                        intf->handlers->sender(intf->send_info,
+                                               smi_msg, 0);
+                else
+                        ipmi_free_smi_msg(smi_msg);
+
                 spin_lock_irqsave(&intf->seq_lock, *flags);
         }
 }
@@ -3298,18 +3647,12 @@ static void ipmi_timeout_handler(long timeout_period)
         struct ipmi_recv_msg *msg, *msg2;
         struct ipmi_smi_msg  *smi_msg, *smi_msg2;
         unsigned long        flags;
-        int                  i, j;
+        int                  i;
 
         INIT_LIST_HEAD(&timeouts);
 
-        spin_lock(&interfaces_lock);
-        for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
-                intf = ipmi_interfaces[i];
-                if (IPMI_INVALID_INTERFACE(intf))
-                        continue;
-                kref_get(&intf->refcount);
-                spin_unlock(&interfaces_lock);
-
+        rcu_read_lock();
+        list_for_each_entry_rcu(intf, &ipmi_interfaces, link) {
                 /* See if any waiting messages need to be processed. */
                 spin_lock_irqsave(&intf->waiting_msgs_lock, flags);
                 list_for_each_entry_safe(smi_msg, smi_msg2,
@@ -3329,35 +3672,60 @@ static void ipmi_timeout_handler(long timeout_period)
                    have timed out, putting them in the timeouts
                    list. */
                 spin_lock_irqsave(&intf->seq_lock, flags);
-                for (j = 0; j < IPMI_IPMB_NUM_SEQ; j++)
-                        check_msg_timeout(intf, &(intf->seq_table[j]),
-                                          &timeouts, timeout_period, j,
+                for (i = 0; i < IPMI_IPMB_NUM_SEQ; i++)
+                        check_msg_timeout(intf, &(intf->seq_table[i]),
+                                          &timeouts, timeout_period, i,
                                           &flags);
                 spin_unlock_irqrestore(&intf->seq_lock, flags);
 
                 list_for_each_entry_safe(msg, msg2, &timeouts, link)
-                        handle_msg_timeout(msg);
-
-                kref_put(&intf->refcount, intf_free);
-                spin_lock(&interfaces_lock);
+                        deliver_err_response(msg, IPMI_TIMEOUT_COMPLETION_CODE);
+
+                /*
+                 * Maintenance mode handling.  Check the timeout
+                 * optimistically before we claim the lock.  It may
+                 * mean a timeout gets missed occasionally, but that
+                 * only means the timeout gets extended by one period
+                 * in that case.  No big deal, and it avoids the lock
+                 * most of the time.
+                 */
+                if (intf->auto_maintenance_timeout > 0) {
+                        spin_lock_irqsave(&intf->maintenance_mode_lock, flags);
+                        if (intf->auto_maintenance_timeout > 0) {
+                                intf->auto_maintenance_timeout
+                                        -= timeout_period;
+                                if (!intf->maintenance_mode
+                                    && (intf->auto_maintenance_timeout <= 0))
+                                {
+                                        intf->maintenance_mode_enable = 0;
+                                        maintenance_mode_update(intf);
+                                }
+                        }
+                        spin_unlock_irqrestore(&intf->maintenance_mode_lock,
+                                               flags);
+                }
         }
-        spin_unlock(&interfaces_lock);
+        rcu_read_unlock();
 }
 
 static void ipmi_request_event(void)
 {
-        ipmi_smi_t intf;
-        int        i;
+        ipmi_smi_t               intf;
+        struct ipmi_smi_handlers *handlers;
 
-        spin_lock(&interfaces_lock);
-        for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
-                intf = ipmi_interfaces[i];
-                if (IPMI_INVALID_INTERFACE(intf))
+        rcu_read_lock();
+        /* Called from the timer, no need to check if handlers is
+         * valid. */
+        list_for_each_entry_rcu(intf, &ipmi_interfaces, link) {
+                /* No event requests when in maintenance mode. */
+                if (intf->maintenance_mode_enable)
                         continue;
 
-                intf->handlers->request_events(intf->send_info);
+                handlers = intf->handlers;
+                if (handlers)
+                        handlers->request_events(intf->send_info);
         }
-        spin_unlock(&interfaces_lock);
+        rcu_read_unlock();
 }
 
 static struct timer_list ipmi_timer;
@@ -3486,7 +3854,6 @@ static void send_panic_events(char *str)
         struct kernel_ipmi_msg            msg;
         ipmi_smi_t                        intf;
         unsigned char                     data[16];
-        int                               i;
         struct ipmi_system_interface_addr *si;
         struct ipmi_addr                  addr;
         struct ipmi_smi_msg               smi_msg;
@@ -3520,9 +3887,9 @@ static void send_panic_events(char *str)
         recv_msg.done = dummy_recv_done_handler;
 
         /* For every registered interface, send the event. */
-        for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
-                intf = ipmi_interfaces[i];
-                if (IPMI_INVALID_INTERFACE(intf))
+        list_for_each_entry_rcu(intf, &ipmi_interfaces, link) {
+                if (!intf->handlers)
+                        /* Interface is not ready. */
                         continue;
 
                 /* Send the event announcing the panic. */
@@ -3547,13 +3914,14 @@ static void send_panic_events(char *str)
         if (!str) 
                 return;
 
-        for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
+        /* For every registered interface, send the event. */
+        list_for_each_entry_rcu(intf, &ipmi_interfaces, link) {
                 char                  *p = str;
                 struct ipmi_ipmb_addr *ipmb;
                 int                   j;
 
-                intf = ipmi_interfaces[i];
-                if (IPMI_INVALID_INTERFACE(intf))
+                if (intf->intf_num == -1)
+                        /* Interface was not ready yet. */
                         continue;
 
                 /* First job here is to figure out where to send the
@@ -3673,13 +4041,12 @@ static void send_panic_events(char *str)
 }
 #endif /* CONFIG_IPMI_PANIC_EVENT */
 
-static int has_panicked = 0;
+static int has_panicked;
 
 static int panic_event(struct notifier_block *this,
                        unsigned long         event,
                        void                  *ptr)
 {
-        int        i;
         ipmi_smi_t intf;
 
         if (has_panicked)
@@ -3687,9 +4054,9 @@ static int panic_event(struct notifier_block *this,
         has_panicked = 1;
 
         /* For every registered interface, set it to run to completion. */
-        for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
-                intf = ipmi_interfaces[i];
-                if (IPMI_INVALID_INTERFACE(intf))
+        list_for_each_entry_rcu(intf, &ipmi_interfaces, link) {
+                if (!intf->handlers)
+                        /* Interface is not ready. */
                         continue;
 
                 intf->handlers->set_run_to_completion(intf->send_info, 1);
@@ -3710,7 +4077,6 @@ static struct notifier_block panic_block = {
 
 static int ipmi_init_msghandler(void)
 {
-        int i;
         int rv;
 
         if (initialized)
@@ -3725,9 +4091,6 @@ static int ipmi_init_msghandler(void)
         printk(KERN_INFO "ipmi message handler version "
                IPMI_DRIVER_VERSION "\n");
 
-        for (i = 0; i < MAX_IPMI_INTERFACES; i++)
-                ipmi_interfaces[i] = NULL;
-
 #ifdef CONFIG_PROC_FS
         proc_ipmi_root = proc_mkdir("ipmi", NULL);
         if (!proc_ipmi_root) {
diff --git a/drivers/char/ipmi/ipmi_poweroff.c b/drivers/char/ipmi/ipmi_poweroff.c
index 8d941db83457..9d23136e598a 100644
--- a/drivers/char/ipmi/ipmi_poweroff.c
+++ b/drivers/char/ipmi/ipmi_poweroff.c
@@ -43,6 +43,9 @@
 
 #define PFX "IPMI poweroff: "
 
+static void ipmi_po_smi_gone(int if_num);
+static void ipmi_po_new_smi(int if_num, struct device *device);
+
 /* Definitions for controlling power off (if the system supports it).  It
  * conveniently matches the IPMI chassis control values. */
 #define IPMI_CHASSIS_POWER_DOWN         0       /* power down, the default. */
@@ -51,6 +54,37 @@
 /* the IPMI data command */
 static int poweroff_powercycle;
 
+/* Which interface to use, -1 means the first we see. */
+static int ifnum_to_use = -1;
+
+/* Our local state. */
+static int ready;
+static ipmi_user_t ipmi_user;
+static int ipmi_ifnum;
+static void (*specific_poweroff_func)(ipmi_user_t user);
+
+/* Holds the old poweroff function so we can restore it on removal. */
+static void (*old_poweroff_func)(void);
+
+static int set_param_ifnum(const char *val, struct kernel_param *kp)
+{
+        int rv = param_set_int(val, kp);
+        if (rv)
+                return rv;
+        if ((ifnum_to_use < 0) || (ifnum_to_use == ipmi_ifnum))
+                return 0;
+
+        ipmi_po_smi_gone(ipmi_ifnum);
+        ipmi_po_new_smi(ifnum_to_use, NULL);
+        return 0;
+}
+
+module_param_call(ifnum_to_use, set_param_ifnum, param_get_int,
+                  &ifnum_to_use, 0644);
+MODULE_PARM_DESC(ifnum_to_use, "The interface number to use for the watchdog "
+                 "timer.  Setting to -1 defaults to the first registered "
+                 "interface");
+
 /* parameter definition to allow user to flag power cycle */
 module_param(poweroff_powercycle, int, 0644);
 MODULE_PARM_DESC(poweroff_powercycle, " Set to non-zero to enable power cycle instead of power down. Power cycle is contingent on hardware support, otherwise it defaults back to power down.");
@@ -142,6 +176,42 @@ static int ipmi_request_in_rc_mode(ipmi_user_t            user,
 #define IPMI_ATCA_GET_ADDR_INFO_CMD     0x01
 #define IPMI_PICMG_ID                   0
 
+#define IPMI_NETFN_OEM                          0x2e
+#define IPMI_ATCA_PPS_GRACEFUL_RESTART          0x11
+#define IPMI_ATCA_PPS_IANA                      "\x00\x40\x0A"
+#define IPMI_MOTOROLA_MANUFACTURER_ID           0x0000A1
+#define IPMI_MOTOROLA_PPS_IPMC_PRODUCT_ID       0x0051
+
+static void (*atca_oem_poweroff_hook)(ipmi_user_t user);
+
+static void pps_poweroff_atca (ipmi_user_t user)
+{
+        struct ipmi_system_interface_addr smi_addr;
+        struct kernel_ipmi_msg            send_msg;
+        int                               rv;
+        /*
+         * Configure IPMI address for local access
+         */
+        smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
+        smi_addr.channel = IPMI_BMC_CHANNEL;
+        smi_addr.lun = 0;
+
+        printk(KERN_INFO PFX "PPS powerdown hook used");
+
+        send_msg.netfn = IPMI_NETFN_OEM;
+        send_msg.cmd = IPMI_ATCA_PPS_GRACEFUL_RESTART;
+        send_msg.data = IPMI_ATCA_PPS_IANA;
+        send_msg.data_len = 3;
+        rv = ipmi_request_in_rc_mode(user,
+                                  (struct ipmi_addr *) &smi_addr,
+                                   &send_msg);
+        if (rv && rv != IPMI_UNKNOWN_ERR_COMPLETION_CODE) {
+                printk(KERN_ERR PFX "Unable to send ATCA ,"
+                       " IPMI error 0x%x\n", rv);
+        }
+        return;
+}
+
 static int ipmi_atca_detect (ipmi_user_t user)
 {
         struct ipmi_system_interface_addr smi_addr;
@@ -167,6 +237,13 @@ static int ipmi_atca_detect (ipmi_user_t user)
         rv = ipmi_request_wait_for_response(user,
                                             (struct ipmi_addr *) &smi_addr,
                                             &send_msg);
+
+        printk(KERN_INFO PFX "ATCA Detect mfg 0x%X prod 0x%X\n", mfg_id, prod_id);
+        if((mfg_id == IPMI_MOTOROLA_MANUFACTURER_ID)
+            && (prod_id == IPMI_MOTOROLA_PPS_IPMC_PRODUCT_ID)) {
+                printk(KERN_INFO PFX "Installing Pigeon Point Systems Poweroff Hook\n");
+                atca_oem_poweroff_hook = pps_poweroff_atca;
+        }
         return !rv;
 }
 
@@ -200,12 +277,19 @@ static void ipmi_poweroff_atca (ipmi_user_t user)
         rv = ipmi_request_in_rc_mode(user,
                                      (struct ipmi_addr *) &smi_addr,
                                      &send_msg);
-        if (rv) {
+        /** At this point, the system may be shutting down, and most
+         ** serial drivers (if used) will have interrupts turned off
+         ** it may be better to ignore IPMI_UNKNOWN_ERR_COMPLETION_CODE
+         ** return code
+         **/
+        if (rv && rv != IPMI_UNKNOWN_ERR_COMPLETION_CODE) {
                 printk(KERN_ERR PFX "Unable to send ATCA powerdown message,"
                        " IPMI error 0x%x\n", rv);
                 goto out;
         }
 
+        if(atca_oem_poweroff_hook)
+                return atca_oem_poweroff_hook(user);
  out:
         return;
 }
@@ -440,15 +524,6 @@ static struct poweroff_function poweroff_functions[] = {
                       / sizeof(struct poweroff_function))
 
 
-/* Our local state. */
-static int ready = 0;
-static ipmi_user_t ipmi_user;
-static void (*specific_poweroff_func)(ipmi_user_t user) = NULL;
-
-/* Holds the old poweroff function so we can restore it on removal. */
-static void (*old_poweroff_func)(void);
-
-
 /* Called on a powerdown request. */
 static void ipmi_poweroff_function (void)
 {
@@ -473,6 +548,9 @@ static void ipmi_po_new_smi(int if_num, struct device *device)
         if (ready)
                 return;
 
+        if ((ifnum_to_use >= 0) && (ifnum_to_use != if_num))
+                return;
+
         rv = ipmi_create_user(if_num, &ipmi_poweroff_handler, NULL,
                               &ipmi_user);
         if (rv) {
@@ -481,6 +559,8 @@ static void ipmi_po_new_smi(int if_num, struct device *device)
                 return;
         }
 
+        ipmi_ifnum = if_num;
+
         /*
          * Do a get device ide and store some results, since this is
          * used by several functions.
@@ -541,9 +621,15 @@ static void ipmi_po_new_smi(int if_num, struct device *device)
 
 static void ipmi_po_smi_gone(int if_num)
 {
-        /* This can never be called, because once poweroff driver is
-           registered, the interface can't go away until the power
-           driver is unregistered. */
+        if (!ready)
+                return;
+
+        if (ipmi_ifnum != if_num)
+                return;
+
+        ready = 0;
+        ipmi_destroy_user(ipmi_user);
+        pm_power_off = old_poweroff_func;
 }
 
 static struct ipmi_smi_watcher smi_watcher =
@@ -616,9 +702,9 @@ static int ipmi_poweroff_init (void)
                 printk(KERN_ERR PFX "Unable to register SMI watcher: %d\n", rv);
                 goto out_err;
         }
-#endif
 
  out_err:
+#endif
         return rv;
 }
 
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index abca98beac14..f1afd26a509f 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -61,6 +61,10 @@
 #include "ipmi_si_sm.h"
 #include <linux/init.h>
 #include <linux/dmi.h>
+#include <linux/string.h>
+#include <linux/ctype.h>
+
+#define PFX "ipmi_si: "
 
 /* Measure times between events in the driver. */
 #undef DEBUG_TIMING
@@ -92,7 +96,7 @@ enum si_intf_state {
 enum si_type {
     SI_KCS, SI_SMIC, SI_BT
 };
-static char *si_to_str[] = { "KCS", "SMIC", "BT" };
+static char *si_to_str[] = { "kcs", "smic", "bt" };
 
 #define DEVICE_NAME "ipmi_si"
 
@@ -217,7 +221,15 @@ struct smi_info
         struct list_head link;
 };
 
+#define SI_MAX_PARMS 4
+
+static int force_kipmid[SI_MAX_PARMS];
+static int num_force_kipmid;
+
+static int unload_when_empty = 1;
+
 static int try_smi_init(struct smi_info *smi);
+static void cleanup_one_si(struct smi_info *to_clean);
 
 static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
 static int register_xaction_notifier(struct notifier_block * nb)
@@ -235,14 +247,18 @@ static void deliver_recv_msg(struct smi_info *smi_info,
         spin_lock(&(smi_info->si_lock));
 }
 
-static void return_hosed_msg(struct smi_info *smi_info)
+static void return_hosed_msg(struct smi_info *smi_info, int cCode)
 {
         struct ipmi_smi_msg *msg = smi_info->curr_msg;
 
+        if (cCode < 0 || cCode > IPMI_ERR_UNSPECIFIED)
+                cCode = IPMI_ERR_UNSPECIFIED;
+        /* else use it as is */
+
         /* Make it a reponse */
         msg->rsp[0] = msg->data[0] | 4;
         msg->rsp[1] = msg->data[1];
-        msg->rsp[2] = 0xFF; /* Unknown error. */
+        msg->rsp[2] = cCode;
         msg->rsp_size = 3;
 
         smi_info->curr_msg = NULL;
@@ -293,7 +309,7 @@ static enum si_sm_result start_next_msg(struct smi_info *smi_info)
                         smi_info->curr_msg->data,
                         smi_info->curr_msg->data_size);
                 if (err) {
-                        return_hosed_msg(smi_info);
+                        return_hosed_msg(smi_info, err);
                 }
 
                 rv = SI_SM_CALL_WITHOUT_DELAY;
@@ -635,7 +651,7 @@ static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
                         /* If we were handling a user message, format
                            a response to send to the upper layer to
                            tell it about the error. */
-                        return_hosed_msg(smi_info);
+                        return_hosed_msg(smi_info, IPMI_ERR_UNSPECIFIED);
                 }
                 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
         }
@@ -679,22 +695,24 @@ static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
         {
                 /* We are idle and the upper layer requested that I fetch
                    events, so do so. */
-                unsigned char msg[2];
+                atomic_set(&smi_info->req_events, 0);
 
-                spin_lock(&smi_info->count_lock);
-                smi_info->flag_fetches++;
-                spin_unlock(&smi_info->count_lock);
+                smi_info->curr_msg = ipmi_alloc_smi_msg();
+                if (!smi_info->curr_msg)
+                        goto out;
 
-                atomic_set(&smi_info->req_events, 0);
-                msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
-                msg[1] = IPMI_GET_MSG_FLAGS_CMD;
+                smi_info->curr_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
+                smi_info->curr_msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
+                smi_info->curr_msg->data_size = 2;
 
                 smi_info->handlers->start_transaction(
-                        smi_info->si_sm, msg, 2);
-                smi_info->si_state = SI_GETTING_FLAGS;
+                        smi_info->si_sm,
+                        smi_info->curr_msg->data,
+                        smi_info->curr_msg->data_size);
+                smi_info->si_state = SI_GETTING_EVENTS;
                 goto restart;
         }
-
+ out:
         return si_sm_result;
 }
 
@@ -709,6 +727,15 @@ static void sender(void                *send_info,
         struct timeval    t;
 #endif
 
+        if (atomic_read(&smi_info->stop_operation)) {
+                msg->rsp[0] = msg->data[0] | 4;
+                msg->rsp[1] = msg->data[1];
+                msg->rsp[2] = IPMI_ERR_UNSPECIFIED;
+                msg->rsp_size = 3;
+                deliver_recv_msg(smi_info, msg);
+                return;
+        }
+
         spin_lock_irqsave(&(smi_info->msg_lock), flags);
 #ifdef DEBUG_TIMING
         do_gettimeofday(&t);
@@ -800,17 +827,25 @@ static void poll(void *send_info)
 {
         struct smi_info *smi_info = send_info;
 
-        smi_event_handler(smi_info, 0);
+        /*
+         * Make sure there is some delay in the poll loop so we can
+         * drive time forward and timeout things.
+         */
+        udelay(10);
+        smi_event_handler(smi_info, 10);
 }
 
 static void request_events(void *send_info)
 {
         struct smi_info *smi_info = send_info;
 
+        if (atomic_read(&smi_info->stop_operation))
+                return;
+
         atomic_set(&smi_info->req_events, 1);
 }
 
-static int initialized = 0;
+static int initialized;
 
 static void smi_timeout(unsigned long data)
 {
@@ -867,7 +902,7 @@ static void smi_timeout(unsigned long data)
         add_timer(&(smi_info->si_timer));
 }
 
-static irqreturn_t si_irq_handler(int irq, void *data, struct pt_regs *regs)
+static irqreturn_t si_irq_handler(int irq, void *data)
 {
         struct smi_info *smi_info = data;
         unsigned long   flags;
@@ -894,20 +929,21 @@ static irqreturn_t si_irq_handler(int irq, void *data, struct pt_regs *regs)
         return IRQ_HANDLED;
 }
 
-static irqreturn_t si_bt_irq_handler(int irq, void *data, struct pt_regs *regs)
+static irqreturn_t si_bt_irq_handler(int irq, void *data)
 {
         struct smi_info *smi_info = data;
         /* We need to clear the IRQ flag for the BT interface. */
         smi_info->io.outputb(&smi_info->io, IPMI_BT_INTMASK_REG,
                              IPMI_BT_INTMASK_CLEAR_IRQ_BIT
                              | IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
-        return si_irq_handler(irq, data, regs);
+        return si_irq_handler(irq, data);
 }
 
 static int smi_start_processing(void       *send_info,
                                 ipmi_smi_t intf)
 {
         struct smi_info *new_smi = send_info;
+        int             enable = 0;
 
         new_smi->intf = intf;
 
@@ -916,7 +952,19 @@ static int smi_start_processing(void       *send_info,
         new_smi->last_timeout_jiffies = jiffies;
         mod_timer(&new_smi->si_timer, jiffies + SI_TIMEOUT_JIFFIES);
 
-        if (new_smi->si_type != SI_BT) {
+        /*
+         * Check if the user forcefully enabled the daemon.
+         */
+        if (new_smi->intf_num < num_force_kipmid)
+                enable = force_kipmid[new_smi->intf_num];
+        /*
+         * The BT interface is efficient enough to not need a thread,
+         * and there is no need for a thread if we have interrupts.
+         */
+        else if ((new_smi->si_type != SI_BT) && (!new_smi->irq))
+                enable = 1;
+
+        if (enable) {
                 new_smi->thread = kthread_run(ipmi_thread, new_smi,
                                               "kipmi%d", new_smi->intf_num);
                 if (IS_ERR(new_smi->thread)) {
@@ -931,12 +979,21 @@ static int smi_start_processing(void       *send_info,
         return 0;
 }
 
+static void set_maintenance_mode(void *send_info, int enable)
+{
+        struct smi_info   *smi_info = send_info;
+
+        if (!enable)
+                atomic_set(&smi_info->req_events, 0);
+}
+
 static struct ipmi_smi_handlers handlers =
 {
         .owner                  = THIS_MODULE,
         .start_processing       = smi_start_processing,
         .sender                 = sender,
         .request_events         = request_events,
+        .set_maintenance_mode   = set_maintenance_mode,
         .set_run_to_completion  = set_run_to_completion,
         .poll                   = poll,
 };
@@ -944,7 +1001,6 @@ static struct ipmi_smi_handlers handlers =
 /* There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
    a default IO port, and 1 ACPI/SPMI address.  That sets SI_MAX_DRIVERS */
 
-#define SI_MAX_PARMS 4
 static LIST_HEAD(smi_infos);
 static DEFINE_MUTEX(smi_infos_lock);
 static int smi_num; /* Used to sequence the SMIs */
@@ -962,14 +1018,24 @@ static int num_ports;
 static int           irqs[SI_MAX_PARMS];
 static int num_irqs;
 static int           regspacings[SI_MAX_PARMS];
-static int num_regspacings = 0;
+static int num_regspacings;
 static int           regsizes[SI_MAX_PARMS];
-static int num_regsizes = 0;
+static int num_regsizes;
 static int           regshifts[SI_MAX_PARMS];
-static int num_regshifts = 0;
+static int num_regshifts;
 static int slave_addrs[SI_MAX_PARMS];
-static int num_slave_addrs = 0;
+static int num_slave_addrs;
+
+#define IPMI_IO_ADDR_SPACE  0
+#define IPMI_MEM_ADDR_SPACE 1
+static char *addr_space_to_str[] = { "i/o", "mem" };
+
+static int hotmod_handler(const char *val, struct kernel_param *kp);
 
+module_param_call(hotmod, hotmod_handler, NULL, NULL, 0200);
+MODULE_PARM_DESC(hotmod, "Add and remove interfaces.  See"
+                 " Documentation/IPMI.txt in the kernel sources for the"
+                 " gory details.");
 
 module_param_named(trydefaults, si_trydefaults, bool, 0);
 MODULE_PARM_DESC(trydefaults, "Setting this to 'false' will disable the"
@@ -1017,12 +1083,16 @@ MODULE_PARM_DESC(slave_addrs, "Set the default IPMB slave address for"
                  " the controller.  Normally this is 0x20, but can be"
                  " overridden by this parm.  This is an array indexed"
                  " by interface number.");
+module_param_array(force_kipmid, int, &num_force_kipmid, 0);
+MODULE_PARM_DESC(force_kipmid, "Force the kipmi daemon to be enabled (1) or"
+                 " disabled(0).  Normally the IPMI driver auto-detects"
+                 " this, but the value may be overridden by this parm.");
+module_param(unload_when_empty, int, 0);
+MODULE_PARM_DESC(unload_when_empty, "Unload the module if no interfaces are"
+                 " specified or found, default is 1.  Setting to 0"
+                 " is useful for hot add of devices using hotmod.");
 
 
-#define IPMI_IO_ADDR_SPACE  0
-#define IPMI_MEM_ADDR_SPACE 1
-static char *addr_space_to_str[] = { "I/O", "memory" };
-
 static void std_irq_cleanup(struct smi_info *info)
 {
         if (info->si_type == SI_BT)
@@ -1190,7 +1260,7 @@ static void intf_mem_outb(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;
+                & 0xff;
 }
 
 static void intf_mem_outw(struct si_sm_io *io, unsigned int offset,
@@ -1202,7 +1272,7 @@ static void intf_mem_outw(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;
+                & 0xff;
 }
 
 static void intf_mem_outl(struct si_sm_io *io, unsigned int offset,
@@ -1215,7 +1285,7 @@ static void intf_mem_outl(struct si_sm_io *io, unsigned int offset,
 static unsigned char mem_inq(struct si_sm_io *io, unsigned int offset)
 {
         return (readq((io->addr)+(offset * io->regspacing)) >> io->regshift)
-                && 0xff;
+                & 0xff;
 }
 
 static void mem_outq(struct si_sm_io *io, unsigned int offset,
@@ -1296,6 +1366,250 @@ static int mem_setup(struct smi_info *info)
         return 0;
 }
 
+/*
+ * Parms come in as <op1>[:op2[:op3...]].  ops are:
+ *   add|remove,kcs|bt|smic,mem|i/o,<address>[,<opt1>[,<opt2>[,...]]]
+ * Options are:
+ *   rsp=<regspacing>
+ *   rsi=<regsize>
+ *   rsh=<regshift>
+ *   irq=<irq>
+ *   ipmb=<ipmb addr>
+ */
+enum hotmod_op { HM_ADD, HM_REMOVE };
+struct hotmod_vals {
+        char *name;
+        int  val;
+};
+static struct hotmod_vals hotmod_ops[] = {
+        { "add",        HM_ADD },
+        { "remove",     HM_REMOVE },
+        { NULL }
+};
+static struct hotmod_vals hotmod_si[] = {
+        { "kcs",        SI_KCS },
+        { "smic",       SI_SMIC },
+        { "bt",         SI_BT },
+        { NULL }
+};
+static struct hotmod_vals hotmod_as[] = {
+        { "mem",        IPMI_MEM_ADDR_SPACE },
+        { "i/o",        IPMI_IO_ADDR_SPACE },
+        { NULL }
+};
+
+static int parse_str(struct hotmod_vals *v, int *val, char *name, char **curr)
+{
+        char *s;
+        int  i;
+
+        s = strchr(*curr, ',');
+        if (!s) {
+                printk(KERN_WARNING PFX "No hotmod %s given.\n", name);
+                return -EINVAL;
+        }
+        *s = '\0';
+        s++;
+        for (i = 0; hotmod_ops[i].name; i++) {
+                if (strcmp(*curr, v[i].name) == 0) {
+                        *val = v[i].val;
+                        *curr = s;
+                        return 0;
+                }
+        }
+
+        printk(KERN_WARNING PFX "Invalid hotmod %s '%s'\n", name, *curr);
+        return -EINVAL;
+}
+
+static int check_hotmod_int_op(const char *curr, const char *option,
+                               const char *name, int *val)
+{
+        char *n;
+
+        if (strcmp(curr, name) == 0) {
+                if (!option) {
+                        printk(KERN_WARNING PFX
+                               "No option given for '%s'\n",
+                               curr);
+                        return -EINVAL;
+                }
+                *val = simple_strtoul(option, &n, 0);
+                if ((*n != '\0') || (*option == '\0')) {
+                        printk(KERN_WARNING PFX
+                               "Bad option given for '%s'\n",
+                               curr);
+                        return -EINVAL;
+                }
+                return 1;
+        }
+        return 0;
+}
+
+static int hotmod_handler(const char *val, struct kernel_param *kp)
+{
+        char *str = kstrdup(val, GFP_KERNEL);
+        int  rv;
+        char *next, *curr, *s, *n, *o;
+        enum hotmod_op op;
+        enum si_type si_type;
+        int  addr_space;
+        unsigned long addr;
+        int regspacing;
+        int regsize;
+        int regshift;
+        int irq;
+        int ipmb;
+        int ival;
+        int len;
+        struct smi_info *info;
+
+        if (!str)
+                return -ENOMEM;
+
+        /* Kill any trailing spaces, as we can get a "\n" from echo. */
+        len = strlen(str);
+        ival = len - 1;
+        while ((ival >= 0) && isspace(str[ival])) {
+                str[ival] = '\0';
+                ival--;
+        }
+
+        for (curr = str; curr; curr = next) {
+                regspacing = 1;
+                regsize = 1;
+                regshift = 0;
+                irq = 0;
+                ipmb = 0x20;
+
+                next = strchr(curr, ':');
+                if (next) {
+                        *next = '\0';
+                        next++;
+                }
+
+                rv = parse_str(hotmod_ops, &ival, "operation", &curr);
+                if (rv)
+                        break;
+                op = ival;
+
+                rv = parse_str(hotmod_si, &ival, "interface type", &curr);
+                if (rv)
+                        break;
+                si_type = ival;
+
+                rv = parse_str(hotmod_as, &addr_space, "address space", &curr);
+                if (rv)
+                        break;
+
+                s = strchr(curr, ',');
+                if (s) {
+                        *s = '\0';
+                        s++;
+                }
+                addr = simple_strtoul(curr, &n, 0);
+                if ((*n != '\0') || (*curr == '\0')) {
+                        printk(KERN_WARNING PFX "Invalid hotmod address"
+                               " '%s'\n", curr);
+                        break;
+                }
+
+                while (s) {
+                        curr = s;
+                        s = strchr(curr, ',');
+                        if (s) {
+                                *s = '\0';
+                                s++;
+                        }
+                        o = strchr(curr, '=');
+                        if (o) {
+                                *o = '\0';
+                                o++;
+                        }
+                        rv = check_hotmod_int_op(curr, o, "rsp", &regspacing);
+                        if (rv < 0)
+                                goto out;
+                        else if (rv)
+                                continue;
+                        rv = check_hotmod_int_op(curr, o, "rsi", &regsize);
+                        if (rv < 0)
+                                goto out;
+                        else if (rv)
+                                continue;
+                        rv = check_hotmod_int_op(curr, o, "rsh", &regshift);
+                        if (rv < 0)
+                                goto out;
+                        else if (rv)
+                                continue;
+                        rv = check_hotmod_int_op(curr, o, "irq", &irq);
+                        if (rv < 0)
+                                goto out;
+                        else if (rv)
+                                continue;
+                        rv = check_hotmod_int_op(curr, o, "ipmb", &ipmb);
+                        if (rv < 0)
+                                goto out;
+                        else if (rv)
+                                continue;
+
+                        rv = -EINVAL;
+                        printk(KERN_WARNING PFX
+                               "Invalid hotmod option '%s'\n",
+                               curr);
+                        goto out;
+                }
+
+                if (op == HM_ADD) {
+                        info = kzalloc(sizeof(*info), GFP_KERNEL);
+                        if (!info) {
+                                rv = -ENOMEM;
+                                goto out;
+                        }
+
+                        info->addr_source = "hotmod";
+                        info->si_type = si_type;
+                        info->io.addr_data = addr;
+                        info->io.addr_type = addr_space;
+                        if (addr_space == IPMI_MEM_ADDR_SPACE)
+                                info->io_setup = mem_setup;
+                        else
+                                info->io_setup = port_setup;
+
+                        info->io.addr = NULL;
+                        info->io.regspacing = regspacing;
+                        if (!info->io.regspacing)
+                                info->io.regspacing = DEFAULT_REGSPACING;
+                        info->io.regsize = regsize;
+                        if (!info->io.regsize)
+                                info->io.regsize = DEFAULT_REGSPACING;
+                        info->io.regshift = regshift;
+                        info->irq = irq;
+                        if (info->irq)
+                                info->irq_setup = std_irq_setup;
+                        info->slave_addr = ipmb;
+
+                        try_smi_init(info);
+                } else {
+                        /* remove */
+                        struct smi_info *e, *tmp_e;
+
+                        mutex_lock(&smi_infos_lock);
+                        list_for_each_entry_safe(e, tmp_e, &smi_infos, link) {
+                                if (e->io.addr_type != addr_space)
+                                        continue;
+                                if (e->si_type != si_type)
+                                        continue;
+                                if (e->io.addr_data == addr)
+                                        cleanup_one_si(e);
+                        }
+                        mutex_unlock(&smi_infos_lock);
+                }
+        }
+        rv = len;
+ out:
+        kfree(str);
+        return rv;
+}
 
 static __devinit void hardcode_find_bmc(void)
 {
@@ -1370,7 +1684,7 @@ static __devinit void hardcode_find_bmc(void)
 /* Once we get an ACPI failure, we don't try any more, because we go
    through the tables sequentially.  Once we don't find a table, there
    are no more. */
-static int acpi_failure = 0;
+static int acpi_failure;
 
 /* For GPE-type interrupts. */
 static u32 ipmi_acpi_gpe(void *context)
@@ -1481,7 +1795,6 @@ struct SPMITable {
 static __devinit int try_init_acpi(struct SPMITable *spmi)
 {
         struct smi_info  *info;
-        char             *io_type;
         u8               addr_space;
 
         if (spmi->IPMIlegacy != 1) {
@@ -1545,11 +1858,9 @@ static __devinit int try_init_acpi(struct SPMITable *spmi)
         info->io.regshift = spmi->addr.register_bit_offset;
 
         if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
-                io_type = "memory";
                 info->io_setup = mem_setup;
                 info->io.addr_type = IPMI_IO_ADDR_SPACE;
         } else if (spmi->addr.address_space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
-                io_type = "I/O";
                 info->io_setup = port_setup;
                 info->io.addr_type = IPMI_MEM_ADDR_SPACE;
         } else {
@@ -1730,6 +2041,7 @@ static void __devinit dmi_find_bmc(void)
         int                  rv;
 
         while ((dev = dmi_find_device(DMI_DEV_TYPE_IPMI, NULL, dev))) {
+                memset(&data, 0, sizeof(data));
                 rv = decode_dmi((struct dmi_header *) dev->device_data, &data);
                 if (!rv)
                         try_init_dmi(&data);
@@ -1767,7 +2079,7 @@ static int __devinit ipmi_pci_probe(struct pci_dev *pdev,
 
         info = kzalloc(sizeof(*info), GFP_KERNEL);
         if (!info)
-                return ENOMEM;
+                return -ENOMEM;
 
         info->addr_source = "PCI";
 
@@ -1788,7 +2100,7 @@ static int __devinit ipmi_pci_probe(struct pci_dev *pdev,
                 kfree(info);
                 printk(KERN_INFO "ipmi_si: %s: Unknown IPMI type: %d\n",
                        pci_name(pdev), class_type);
-                return ENOMEM;
+                return -ENOMEM;
         }
 
         rv = pci_enable_device(pdev);
@@ -1845,7 +2157,7 @@ static int ipmi_pci_resume(struct pci_dev *pdev)
 
 static struct pci_device_id ipmi_pci_devices[] = {
         { PCI_DEVICE(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID) },
-        { PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE) }
+        { PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE_MASK) }
 };
 MODULE_DEVICE_TABLE(pci, ipmi_pci_devices);
 
@@ -1930,19 +2242,9 @@ static int try_get_dev_id(struct smi_info *smi_info)
 static int type_file_read_proc(char *page, char **start, off_t off,
                                int count, int *eof, void *data)
 {
-        char            *out = (char *) page;
         struct smi_info *smi = data;
 
-        switch (smi->si_type) {
-            case SI_KCS:
-                return sprintf(out, "kcs\n");
-            case SI_SMIC:
-                return sprintf(out, "smic\n");
-            case SI_BT:
-                return sprintf(out, "bt\n");
-            default:
-                return 0;
-        }
+        return sprintf(page, "%s\n", si_to_str[smi->si_type]);
 }
 
 static int stat_file_read_proc(char *page, char **start, off_t off,
@@ -1978,7 +2280,24 @@ static int stat_file_read_proc(char *page, char **start, off_t off,
         out += sprintf(out, "incoming_messages:     %ld\n",
                        smi->incoming_messages);
 
-        return (out - ((char *) page));
+        return out - page;
+}
+
+static int param_read_proc(char *page, char **start, off_t off,
+                           int count, int *eof, void *data)
+{
+        struct smi_info *smi = data;
+
+        return sprintf(page,
+                       "%s,%s,0x%lx,rsp=%d,rsi=%d,rsh=%d,irq=%d,ipmb=%d\n",
+                       si_to_str[smi->si_type],
+                       addr_space_to_str[smi->io.addr_type],
+                       smi->io.addr_data,
+                       smi->io.regspacing,
+                       smi->io.regsize,
+                       smi->io.regshift,
+                       smi->irq,
+                       smi->slave_addr);
 }
 
 /*
@@ -2324,7 +2643,7 @@ static int try_smi_init(struct smi_info *new_smi)
                 new_smi->dev = &new_smi->pdev->dev;
                 new_smi->dev->driver = &ipmi_driver;
 
-                rv = platform_device_register(new_smi->pdev);
+                rv = platform_device_add(new_smi->pdev);
                 if (rv) {
                         printk(KERN_ERR
                                "ipmi_si_intf:"
@@ -2340,6 +2659,7 @@ static int try_smi_init(struct smi_info *new_smi)
                                new_smi,
                                &new_smi->device_id,
                                new_smi->dev,
+                               "bmc",
                                new_smi->slave_addr);
         if (rv) {
                 printk(KERN_ERR
@@ -2368,6 +2688,16 @@ static int try_smi_init(struct smi_info *new_smi)
                 goto out_err_stop_timer;
         }
 
+        rv = ipmi_smi_add_proc_entry(new_smi->intf, "params",
+                                     param_read_proc, NULL,
+                                     new_smi, THIS_MODULE);
+        if (rv) {
+                printk(KERN_ERR
+                       "ipmi_si: Unable to create proc entry: %d\n",
+                       rv);
+                goto out_err_stop_timer;
+        }
+
         list_add_tail(&new_smi->link, &smi_infos);
 
         mutex_unlock(&smi_infos_lock);
@@ -2456,12 +2786,16 @@ static __devinit int init_ipmi_si(void)
 #endif
 
 #ifdef CONFIG_ACPI
-        if (si_trydefaults)
-                acpi_find_bmc();
+        acpi_find_bmc();
 #endif
 
 #ifdef CONFIG_PCI
-        pci_module_init(&ipmi_pci_driver);
+        rv = pci_register_driver(&ipmi_pci_driver);
+        if (rv){
+                printk(KERN_ERR
+                       "init_ipmi_si: Unable to register PCI driver: %d\n",
+                       rv);
+        }
 #endif
 
         if (si_trydefaults) {
@@ -2476,7 +2810,7 @@ static __devinit int init_ipmi_si(void)
         }
 
         mutex_lock(&smi_infos_lock);
-        if (list_empty(&smi_infos)) {
+        if (unload_when_empty && list_empty(&smi_infos)) {
                 mutex_unlock(&smi_infos_lock);
 #ifdef CONFIG_PCI
                 pci_unregister_driver(&ipmi_pci_driver);
@@ -2491,7 +2825,7 @@ static __devinit int init_ipmi_si(void)
 }
 module_init(init_ipmi_si);
 
-static void __devexit cleanup_one_si(struct smi_info *to_clean)
+static void cleanup_one_si(struct smi_info *to_clean)
 {
         int           rv;
         unsigned long flags;
diff --git a/drivers/char/ipmi/ipmi_smic_sm.c b/drivers/char/ipmi/ipmi_smic_sm.c
index 39d7e5ef1a2b..e64ea7d25d24 100644
--- a/drivers/char/ipmi/ipmi_smic_sm.c
+++ b/drivers/char/ipmi/ipmi_smic_sm.c
@@ -141,12 +141,14 @@ static int start_smic_transaction(struct si_sm_data *smic,
 {
         unsigned int i;
 
-        if ((size < 2) || (size > MAX_SMIC_WRITE_SIZE)) {
-                return -1;
-        }
-        if ((smic->state != SMIC_IDLE) && (smic->state != SMIC_HOSED)) {
-                return -2;
-        }
+        if (size < 2)
+                return IPMI_REQ_LEN_INVALID_ERR;
+        if (size > MAX_SMIC_WRITE_SIZE)
+                return IPMI_REQ_LEN_EXCEEDED_ERR;
+
+        if ((smic->state != SMIC_IDLE) && (smic->state != SMIC_HOSED))
+                return IPMI_NOT_IN_MY_STATE_ERR;
+
         if (smic_debug & SMIC_DEBUG_MSG) {
                 printk(KERN_INFO "start_smic_transaction -");
                 for (i = 0; i < size; i ++) {
diff --git a/drivers/char/ipmi/ipmi_watchdog.c b/drivers/char/ipmi/ipmi_watchdog.c
index accaaf1a6b69..78280380a905 100644
--- a/drivers/char/ipmi/ipmi_watchdog.c
+++ b/drivers/char/ipmi/ipmi_watchdog.c
@@ -134,13 +134,14 @@
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 
-static ipmi_user_t watchdog_user = NULL;
+static ipmi_user_t watchdog_user;
+static int watchdog_ifnum;
 
 /* Default the timeout to 10 seconds. */
 static int timeout = 10;
 
 /* The pre-timeout is disabled by default. */
-static int pretimeout = 0;
+static int pretimeout;
 
 /* Default action is to reset the board on a timeout. */
 static unsigned char action_val = WDOG_TIMEOUT_RESET;
@@ -155,12 +156,14 @@ static unsigned char preop_val = WDOG_PREOP_NONE;
 
 static char preop[16] = "preop_none";
 static DEFINE_SPINLOCK(ipmi_read_lock);
-static char data_to_read = 0;
+static char data_to_read;
 static DECLARE_WAIT_QUEUE_HEAD(read_q);
-static struct fasync_struct *fasync_q = NULL;
-static char pretimeout_since_last_heartbeat = 0;
+static struct fasync_struct *fasync_q;
+static char pretimeout_since_last_heartbeat;
 static char expect_close;
 
+static int ifnum_to_use = -1;
+
 static DECLARE_RWSEM(register_sem);
 
 /* Parameters to ipmi_set_timeout */
@@ -169,10 +172,12 @@ static DECLARE_RWSEM(register_sem);
 #define IPMI_SET_TIMEOUT_FORCE_HB               2
 
 static int ipmi_set_timeout(int do_heartbeat);
+static void ipmi_register_watchdog(int ipmi_intf);
+static void ipmi_unregister_watchdog(int ipmi_intf);
 
 /* If true, the driver will start running as soon as it is configured
    and ready. */
-static int start_now = 0;
+static int start_now;
 
 static int set_param_int(const char *val, struct kernel_param *kp)
 {
@@ -245,6 +250,26 @@ static int get_param_str(char *buffer, struct kernel_param *kp)
         return strlen(buffer);
 }
 
+
+static int set_param_wdog_ifnum(const char *val, struct kernel_param *kp)
+{
+        int rv = param_set_int(val, kp);
+        if (rv)
+                return rv;
+        if ((ifnum_to_use < 0) || (ifnum_to_use == watchdog_ifnum))
+                return 0;
+
+        ipmi_unregister_watchdog(watchdog_ifnum);
+        ipmi_register_watchdog(ifnum_to_use);
+        return 0;
+}
+
+module_param_call(ifnum_to_use, set_param_wdog_ifnum, get_param_int,
+                  &ifnum_to_use, 0644);
+MODULE_PARM_DESC(ifnum_to_use, "The interface number to use for the watchdog "
+                 "timer.  Setting to -1 defaults to the first registered "
+                 "interface");
+
 module_param_call(timeout, set_param_int, get_param_int, &timeout, 0644);
 MODULE_PARM_DESC(timeout, "Timeout value in seconds.");
 
@@ -263,27 +288,28 @@ module_param_call(preop, set_param_str, get_param_str, preop_op, 0644);
 MODULE_PARM_DESC(preop, "Pretimeout driver operation.  One of: "
                  "preop_none, preop_panic, preop_give_data.");
 
-module_param(start_now, int, 0);
+module_param(start_now, int, 0444);
 MODULE_PARM_DESC(start_now, "Set to 1 to start the watchdog as"
                  "soon as the driver is loaded.");
 
 module_param(nowayout, int, 0644);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started "
+                 "(default=CONFIG_WATCHDOG_NOWAYOUT)");
 
 /* Default state of the timer. */
 static unsigned char ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
 
 /* If shutting down via IPMI, we ignore the heartbeat. */
-static int ipmi_ignore_heartbeat = 0;
+static int ipmi_ignore_heartbeat;
 
 /* Is someone using the watchdog?  Only one user is allowed. */
-static unsigned long ipmi_wdog_open = 0;
+static unsigned long ipmi_wdog_open;
 
 /* If set to 1, the heartbeat command will set the state to reset and
    start the timer.  The timer doesn't normally run when the driver is
    first opened until the heartbeat is set the first time, this
    variable is used to accomplish this. */
-static int ipmi_start_timer_on_heartbeat = 0;
+static int ipmi_start_timer_on_heartbeat;
 
 /* IPMI version of the BMC. */
 static unsigned char ipmi_version_major;
@@ -872,6 +898,11 @@ static void ipmi_register_watchdog(int ipmi_intf)
         if (watchdog_user)
                 goto out;
 
+        if ((ifnum_to_use >= 0) && (ifnum_to_use != ipmi_intf))
+                goto out;
+
+        watchdog_ifnum = ipmi_intf;
+
         rv = ipmi_create_user(ipmi_intf, &ipmi_hndlrs, NULL, &watchdog_user);
         if (rv < 0) {
                 printk(KERN_CRIT PFX "Unable to register with ipmi\n");
@@ -901,9 +932,42 @@ static void ipmi_register_watchdog(int ipmi_intf)
         }
 }
 
+static void ipmi_unregister_watchdog(int ipmi_intf)
+{
+        int rv;
+
+        down_write(&register_sem);
+
+        if (!watchdog_user)
+                goto out;
+
+        if (watchdog_ifnum != ipmi_intf)
+                goto out;
+
+        /* Make sure no one can call us any more. */
+        misc_deregister(&ipmi_wdog_miscdev);
+
+        /* Wait to make sure the message makes it out.  The lower layer has
+           pointers to our buffers, we want to make sure they are done before
+           we release our memory. */
+        while (atomic_read(&set_timeout_tofree))
+                schedule_timeout_uninterruptible(1);
+
+        /* Disconnect from IPMI. */
+        rv = ipmi_destroy_user(watchdog_user);
+        if (rv) {
+                printk(KERN_WARNING PFX "error unlinking from IPMI: %d\n",
+                       rv);
+        }
+        watchdog_user = NULL;
+
+ out:
+        up_write(&register_sem);
+}
+
 #ifdef HAVE_NMI_HANDLER
 static int
-ipmi_nmi(void *dev_id, struct pt_regs *regs, int cpu, int handled)
+ipmi_nmi(void *dev_id, int cpu, int handled)
 {
         /* If we are not expecting a timeout, ignore it. */
         if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE)
@@ -1004,9 +1068,7 @@ static void ipmi_new_smi(int if_num, struct device *device)
 
 static void ipmi_smi_gone(int if_num)
 {
-        /* This can never be called, because once the watchdog is
-           registered, the interface can't go away until the watchdog
-           is unregistered. */
+        ipmi_unregister_watchdog(if_num);
 }
 
 static struct ipmi_smi_watcher smi_watcher =
@@ -1148,30 +1210,32 @@ static int __init ipmi_wdog_init(void)
 
         check_parms();
 
+        register_reboot_notifier(&wdog_reboot_notifier);
+        atomic_notifier_chain_register(&panic_notifier_list,
+                        &wdog_panic_notifier);
+
         rv = ipmi_smi_watcher_register(&smi_watcher);
         if (rv) {
 #ifdef HAVE_NMI_HANDLER
                 if (preaction_val == WDOG_PRETIMEOUT_NMI)
                         release_nmi(&ipmi_nmi_handler);
 #endif
+                atomic_notifier_chain_unregister(&panic_notifier_list,
+                                                 &wdog_panic_notifier);
+                unregister_reboot_notifier(&wdog_reboot_notifier);
                 printk(KERN_WARNING PFX "can't register smi watcher\n");
                 return rv;
         }
 
-        register_reboot_notifier(&wdog_reboot_notifier);
-        atomic_notifier_chain_register(&panic_notifier_list,
-                        &wdog_panic_notifier);
-
         printk(KERN_INFO PFX "driver initialized\n");
 
         return 0;
 }
 
-static __exit void ipmi_unregister_watchdog(void)
+static void __exit ipmi_wdog_exit(void)
 {
-        int rv;
-
-        down_write(&register_sem);
+        ipmi_smi_watcher_unregister(&smi_watcher);
+        ipmi_unregister_watchdog(watchdog_ifnum);
 
 #ifdef HAVE_NMI_HANDLER
         if (nmi_handler_registered)
@@ -1179,37 +1243,8 @@ static __exit void ipmi_unregister_watchdog(void)
 #endif
 
         atomic_notifier_chain_unregister(&panic_notifier_list,
-                        &wdog_panic_notifier);
+                                         &wdog_panic_notifier);
         unregister_reboot_notifier(&wdog_reboot_notifier);
-
-        if (! watchdog_user)
-                goto out;
-
-        /* Make sure no one can call us any more. */
-        misc_deregister(&ipmi_wdog_miscdev);
-
-        /* Wait to make sure the message makes it out.  The lower layer has
-           pointers to our buffers, we want to make sure they are done before
-           we release our memory. */
-        while (atomic_read(&set_timeout_tofree))
-                schedule_timeout_uninterruptible(1);
-
-        /* Disconnect from IPMI. */
-        rv = ipmi_destroy_user(watchdog_user);
-        if (rv) {
-                printk(KERN_WARNING PFX "error unlinking from IPMI: %d\n",
-                       rv);
-        }
-        watchdog_user = NULL;
-
- out:
-        up_write(&register_sem);
-}
-
-static void __exit ipmi_wdog_exit(void)
-{
-        ipmi_smi_watcher_unregister(&smi_watcher);
-        ipmi_unregister_watchdog();
 }
 module_exit(ipmi_wdog_exit);
 module_init(ipmi_wdog_init);
diff --git a/drivers/char/isicom.c b/drivers/char/isicom.c
index 913be23e0a24..5a747e685993 100644
--- a/drivers/char/isicom.c
+++ b/drivers/char/isicom.c
@@ -172,12 +172,14 @@ static struct pci_driver isicom_driver = {
 static int prev_card = 3;       /*      start servicing isi_card[0]     */
 static struct tty_driver *isicom_normal;
 
-static struct timer_list tx;
+static DECLARE_COMPLETION(isi_timerdone);
 static char re_schedule = 1;
 
 static void isicom_tx(unsigned long _data);
 static void isicom_start(struct tty_struct *tty);
 
+static DEFINE_TIMER(tx, isicom_tx, 0, 0);
+
 /*   baud index mappings from linux defns to isi */
 
 static signed char linuxb_to_isib[] = {
@@ -193,9 +195,9 @@ struct	isi_board {
         unsigned short          shift_count;
         struct isi_port         * ports;
         signed char             count;
-        unsigned char           isa;
         spinlock_t              card_lock; /* Card wide lock 11/5/00 -sameer */
         unsigned long           flags;
+        unsigned int            index;
 };
 
 struct  isi_port {
@@ -514,25 +516,19 @@ static void isicom_tx(unsigned long _data)
         /*      schedule another tx for hopefully in about 10ms */
 sched_again:
         if (!re_schedule) {
-                re_schedule = 2;
+                complete(&isi_timerdone);
                 return;
         }
 
-        init_timer(&tx);
-        tx.expires = jiffies + HZ/100;
-        tx.data = 0;
-        tx.function = isicom_tx;
-        add_timer(&tx);
-
-        return;
+        mod_timer(&tx, jiffies + msecs_to_jiffies(10));
 }
 
 /*      Interrupt handlers      */
 
 
-static void isicom_bottomhalf(void *data)
+static void isicom_bottomhalf(struct work_struct *work)
 {
-        struct isi_port *port = (struct isi_port *) data;
+        struct isi_port *port = container_of(work, struct isi_port, bh_tqueue);
         struct tty_struct *tty = port->tty;
 
         if (!tty)
@@ -546,7 +542,7 @@ static void isicom_bottomhalf(void *data)
  *      Main interrupt handler routine
  */
 
-static irqreturn_t isicom_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t isicom_interrupt(int irq, void *dev_id)
 {
         struct isi_board *card = dev_id;
         struct isi_port *port;
@@ -562,14 +558,12 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id, struct pt_regs *regs)
         base = card->base;
         spin_lock(&card->card_lock);
 
-        if (card->isa == NO) {
-                /*
-                 * disable any interrupts from the PCI card and lower the
-                 * interrupt line
-                 */
-                outw(0x8000, base+0x04);
-                ClearInterrupt(base);
-        }
+        /*
+         * disable any interrupts from the PCI card and lower the
+         * interrupt line
+         */
+        outw(0x8000, base+0x04);
+        ClearInterrupt(base);
 
         inw(base);              /* get the dummy word out */
         header = inw(base);
@@ -579,19 +573,13 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id, struct pt_regs *regs)
         if (channel + 1 > card->port_count) {
                 printk(KERN_WARNING "ISICOM: isicom_interrupt(0x%lx): "
                         "%d(channel) > port_count.\n", base, channel+1);
-                if (card->isa)
-                        ClearInterrupt(base);
-                else
-                        outw(0x0000, base+0x04); /* enable interrupts */
+                outw(0x0000, base+0x04); /* enable interrupts */
                 spin_unlock(&card->card_lock);
                 return IRQ_HANDLED;
         }
         port = card->ports + channel;
         if (!(port->flags & ASYNC_INITIALIZED)) {
-                if (card->isa)
-                        ClearInterrupt(base);
-                else
-                        outw(0x0000, base+0x04); /* enable interrupts */
+                outw(0x0000, base+0x04); /* enable interrupts */
                 return IRQ_HANDLED;
         }
 
@@ -604,10 +592,7 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                 }
                 if (byte_count & 0x01)
                         inw(base);
-                if (card->isa == YES)
-                        ClearInterrupt(base);
-                else
-                        outw(0x0000, base+0x04); /* enable interrupts */
+                outw(0x0000, base+0x04); /* enable interrupts */
                 spin_unlock(&card->card_lock);
                 return IRQ_HANDLED;
         }
@@ -708,10 +693,7 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                 }
                 tty_flip_buffer_push(tty);
         }
-        if (card->isa == YES)
-                ClearInterrupt(base);
-        else
-                outw(0x0000, base+0x04); /* enable interrupts */
+        outw(0x0000, base+0x04); /* enable interrupts */
 
         return IRQ_HANDLED;
 }
@@ -964,8 +946,8 @@ static int isicom_open(struct tty_struct *tty, struct file *filp)
 {
         struct isi_port *port;
         struct isi_board *card;
-        unsigned int line, board;
-        int error;
+        unsigned int board;
+        int error, line;
 
         line = tty->index;
         if (line < 0 || line > PORT_COUNT-1)
@@ -1062,11 +1044,12 @@ static void isicom_shutdown_port(struct isi_port *port)
 static void isicom_close(struct tty_struct *tty, struct file *filp)
 {
         struct isi_port *port = tty->driver_data;
-        struct isi_board *card = port->card;
+        struct isi_board *card;
         unsigned long flags;
 
         if (!port)
                 return;
+        card = port->card;
         if (isicom_paranoia_check(port, tty->name, "isicom_close"))
                 return;
 
@@ -1398,7 +1381,7 @@ static int isicom_ioctl(struct tty_struct *tty, struct file *filp,
 
 /* set_termios et all */
 static void isicom_set_termios(struct tty_struct *tty,
-        struct termios *old_termios)
+        struct ktermios *old_termios)
 {
         struct isi_port *port = tty->driver_data;
 
@@ -1473,9 +1456,9 @@ static void isicom_start(struct tty_struct *tty)
 }
 
 /* hangup et all */
-static void do_isicom_hangup(void *data)
+static void do_isicom_hangup(struct work_struct *work)
 {
-        struct isi_port *port = data;
+        struct isi_port *port = container_of(work, struct isi_port, hangup_tq);
         struct tty_struct *tty;
 
         tty = port->tty;
@@ -1519,38 +1502,7 @@ static void isicom_flush_buffer(struct tty_struct *tty)
  * Driver init and deinit functions
  */
 
-static int __devinit isicom_register_ioregion(struct pci_dev *pdev,
-        const unsigned int index)
-{
-        struct isi_board *board = pci_get_drvdata(pdev);
-
-        if (!board->base)
-                return -EINVAL;
-
-        if (!request_region(board->base, 16, ISICOM_NAME)) {
-                dev_dbg(&pdev->dev, "I/O Region 0x%lx-0x%lx is busy. Card%d "
-                        "will be disabled.\n", board->base, board->base + 15,
-                        index + 1);
-                return -EBUSY;
-        }
-
-        return 0;
-}
-
-static void isicom_unregister_ioregion(struct pci_dev *pdev)
-{
-        struct isi_board *board = pci_get_drvdata(pdev);
-
-        if (!board->base)
-                return;
-
-        release_region(board->base, 16);
-        dev_dbg(&pdev->dev, "I/O Region 0x%lx-0x%lx released.\n",
-                board->base, board->base + 15);
-        board->base = 0;
-}
-
-static struct tty_operations isicom_ops = {
+static const struct tty_operations isicom_ops = {
         .open                   = isicom_open,
         .close                  = isicom_close,
         .write                  = isicom_write,
@@ -1570,70 +1522,6 @@ static struct tty_operations isicom_ops = {
         .tiocmset               = isicom_tiocmset,
 };
 
-static int __devinit isicom_register_tty_driver(void)
-{
-        int error = -ENOMEM;
-
-        /* tty driver structure initialization */
-        isicom_normal = alloc_tty_driver(PORT_COUNT);
-        if (!isicom_normal)
-                goto end;
-
-        isicom_normal->owner                    = THIS_MODULE;
-        isicom_normal->name                     = "ttyM";
-        isicom_normal->major                    = ISICOM_NMAJOR;
-        isicom_normal->minor_start              = 0;
-        isicom_normal->type                     = TTY_DRIVER_TYPE_SERIAL;
-        isicom_normal->subtype                  = SERIAL_TYPE_NORMAL;
-        isicom_normal->init_termios             = tty_std_termios;
-        isicom_normal->init_termios.c_cflag     = B9600 | CS8 | CREAD | HUPCL |
-                CLOCAL;
-        isicom_normal->flags                    = TTY_DRIVER_REAL_RAW;
-        tty_set_operations(isicom_normal, &isicom_ops);
-
-        if ((error = tty_register_driver(isicom_normal))) {
-                pr_dbg("Couldn't register the dialin driver, error=%d\n",
-                        error);
-                put_tty_driver(isicom_normal);
-        }
-end:
-        return error;
-}
-
-static void isicom_unregister_tty_driver(void)
-{
-        int error;
-
-        if ((error = tty_unregister_driver(isicom_normal)))
-                pr_dbg("couldn't unregister normal driver, error=%d.\n", error);
-
-        put_tty_driver(isicom_normal);
-}
-
-static int __devinit isicom_register_isr(struct pci_dev *pdev,
-        const unsigned int index)
-{
-        struct isi_board *board = pci_get_drvdata(pdev);
-        unsigned long irqflags = IRQF_DISABLED;
-        int retval = -EINVAL;
-
-        if (!board->base)
-                goto end;
-
-        if (board->isa == NO)
-                irqflags |= IRQF_SHARED;
-
-        retval = request_irq(board->irq, isicom_interrupt, irqflags,
-                ISICOM_NAME, board);
-        if (retval < 0)
-                dev_warn(&pdev->dev, "Could not install handler at Irq %d. "
-                        "Card%d will be disabled.\n", board->irq, index + 1);
-        else
-                retval = 0;
-end:
-        return retval;
-}
-
 static int __devinit reset_card(struct pci_dev *pdev,
         const unsigned int card, unsigned int *signature)
 {
@@ -1655,36 +1543,23 @@ static int __devinit reset_card(struct pci_dev *pdev,
 
         *signature = inw(base + 0x4) & 0xff;
 
-        if (board->isa == YES) {
-                if (!(inw(base + 0xe) & 0x1) || (inw(base + 0x2))) {
-                        dev_dbg(&pdev->dev, "base+0x2=0x%lx, base+0xe=0x%lx\n",
-                                inw(base + 0x2), inw(base + 0xe));
-                        dev_err(&pdev->dev, "ISILoad:ISA Card%d reset failure "
-                                "(Possible bad I/O Port Address 0x%lx).\n",
-                                card + 1, base);
-                        retval = -EIO;
-                        goto end;
-                }
-        } else {
-                portcount = inw(base + 0x2);
-                if (!(inw(base + 0xe) & 0x1) || ((portcount != 0) &&
-                                (portcount != 4) && (portcount != 8))) {
-                        dev_dbg(&pdev->dev, "base+0x2=0x%lx, base+0xe=0x%lx\n",
-                                inw(base + 0x2), inw(base + 0xe));
-                        dev_err(&pdev->dev, "ISILoad:PCI Card%d reset failure "
-                                "(Possible bad I/O Port Address 0x%lx).\n",
-                                card + 1, base);
-                        retval = -EIO;
-                        goto end;
-                }
+        portcount = inw(base + 0x2);
+        if (!(inw(base + 0xe) & 0x1) || ((portcount != 0) &&
+                        (portcount != 4) && (portcount != 8))) {
+                dev_dbg(&pdev->dev, "base+0x2=0x%lx, base+0xe=0x%lx\n",
+                        inw(base + 0x2), inw(base + 0xe));
+                dev_err(&pdev->dev, "ISILoad:PCI Card%d reset failure "
+                        "(Possible bad I/O Port Address 0x%lx).\n",
+                        card + 1, base);
+                retval = -EIO;
+                goto end;
         }
 
         switch (*signature) {
         case 0xa5:
         case 0xbb:
         case 0xdd:
-                board->port_count = (board->isa == NO && portcount == 4) ? 4 :
-                        8;
+                board->port_count = (portcount == 4) ? 4 : 8;
                 board->shift_count = 12;
                 break;
         case 0xcc:
@@ -1756,9 +1631,12 @@ static int __devinit load_firmware(struct pci_dev *pdev,
         if (retval)
                 goto end;
 
+        retval = -EIO;
+
         for (frame = (struct stframe *)fw->data;
                         frame < (struct stframe *)(fw->data + fw->size);
-                        frame++) {
+                        frame = (struct stframe *)((u8 *)(frame + 1) +
+                                frame->count)) {
                 if (WaitTillCardIsFree(base))
                         goto errrelfw;
 
@@ -1797,23 +1675,12 @@ static int __devinit load_firmware(struct pci_dev *pdev,
                 }
         }
 
-        retval = -EIO;
-
-        if (WaitTillCardIsFree(base))
-                goto errrelfw;
-
-        outw(0xf2, base);
-        outw(0x800, base);
-        outw(0x0, base);
-        outw(0x0, base);
-        InterruptTheCard(base);
-        outw(0x0, base + 0x4); /* for ISI4608 cards */
-
 /* XXX: should we test it by reading it back and comparing with original like
  * in load firmware package? */
-        for (frame = (struct stframe*)fw->data;
-                        frame < (struct stframe*)(fw->data + fw->size);
-                        frame++) {
+        for (frame = (struct stframe *)fw->data;
+                        frame < (struct stframe *)(fw->data + fw->size);
+                        frame = (struct stframe *)((u8 *)(frame + 1) +
+                                frame->count)) {
                 if (WaitTillCardIsFree(base))
                         goto errrelfw;
 
@@ -1838,6 +1705,11 @@ static int __devinit load_firmware(struct pci_dev *pdev,
                 }
 
                 data = kmalloc(word_count * 2, GFP_KERNEL);
+                if (data == NULL) {
+                        dev_err(&pdev->dev, "Card%d, firmware upload "
+                                "failed, not enough memory\n", index + 1);
+                        goto errrelfw;
+                }
                 inw(base);
                 insw(base, data, word_count);
                 InterruptTheCard(base);
@@ -1863,6 +1735,17 @@ static int __devinit load_firmware(struct pci_dev *pdev,
                 }
         }
 
+        /* xfer ctrl */
+        if (WaitTillCardIsFree(base))
+                goto errrelfw;
+
+        outw(0xf2, base);
+        outw(0x800, base);
+        outw(0x0, base);
+        outw(0x0, base);
+        InterruptTheCard(base);
+        outw(0x0, base + 0x4); /* for ISI4608 cards */
+
         board->status |= FIRMWARE_LOADED;
         retval = 0;
 
@@ -1875,8 +1758,6 @@ end:
 /*
  *      Insmod can set static symbols so keep these static
  */
-static int io[4];
-static int irq[4];
 static int card;
 
 static int __devinit isicom_probe(struct pci_dev *pdev,
@@ -1902,20 +1783,29 @@ static int __devinit isicom_probe(struct pci_dev *pdev,
                         break;
                 }
 
+        board->index = index;
         board->base = ioaddr;
         board->irq = pciirq;
-        board->isa = NO;
         card++;
 
         pci_set_drvdata(pdev, board);
 
-        retval = isicom_register_ioregion(pdev, index);
-        if (retval < 0)
+        retval = pci_request_region(pdev, 3, ISICOM_NAME);
+        if (retval) {
+                dev_err(&pdev->dev, "I/O Region 0x%lx-0x%lx is busy. Card%d "
+                        "will be disabled.\n", board->base, board->base + 15,
+                        index + 1);
+                retval = -EBUSY;
                 goto err;
+        }
 
-        retval = isicom_register_isr(pdev, index);
-        if (retval < 0)
+        retval = request_irq(board->irq, isicom_interrupt,
+                        IRQF_SHARED | IRQF_DISABLED, ISICOM_NAME, board);
+        if (retval < 0) {
+                dev_err(&pdev->dev, "Could not install handler at Irq %d. "
+                        "Card%d will be disabled.\n", board->irq, index + 1);
                 goto errunrr;
+        }
 
         retval = reset_card(pdev, index, &signature);
         if (retval < 0)
@@ -1925,12 +1815,16 @@ static int __devinit isicom_probe(struct pci_dev *pdev,
         if (retval < 0)
                 goto errunri;
 
+        for (index = 0; index < board->port_count; index++)
+                tty_register_device(isicom_normal, board->index * 16 + index,
+                                &pdev->dev);
+
         return 0;
 
 errunri:
         free_irq(board->irq, board);
 errunrr:
-        isicom_unregister_ioregion(pdev);
+        pci_release_region(pdev, 3);
 err:
         board->base = 0;
         return retval;
@@ -1939,18 +1833,21 @@ err:
 static void __devexit isicom_remove(struct pci_dev *pdev)
 {
         struct isi_board *board = pci_get_drvdata(pdev);
+        unsigned int i;
+
+        for (i = 0; i < board->port_count; i++)
+                tty_unregister_device(isicom_normal, board->index * 16 + i);
 
         free_irq(board->irq, board);
-        isicom_unregister_ioregion(pdev);
+        pci_release_region(pdev, 3);
 }
 
-static int __devinit isicom_setup(void)
+static int __init isicom_init(void)
 {
         int retval, idx, channel;
         struct isi_port *port;
 
         card = 0;
-        memset(isi_ports, 0, sizeof(isi_ports));
 
         for(idx = 0; idx < BOARD_COUNT; idx++) {
                 port = &isi_ports[idx * 16];
@@ -1962,8 +1859,8 @@ static int __devinit isicom_setup(void)
                         port->channel = channel;
                         port->close_delay = 50 * HZ/100;
                         port->closing_wait = 3000 * HZ/100;
-                        INIT_WORK(&port->hangup_tq, do_isicom_hangup, port);
-                        INIT_WORK(&port->bh_tqueue, isicom_bottomhalf, port);
+                        INIT_WORK(&port->hangup_tq, do_isicom_hangup);
+                        INIT_WORK(&port->bh_tqueue, isicom_bottomhalf);
                         port->status = 0;
                         init_waitqueue_head(&port->open_wait);
                         init_waitqueue_head(&port->close_wait);
@@ -1971,66 +1868,65 @@ static int __devinit isicom_setup(void)
                 }
                 isi_card[idx].base = 0;
                 isi_card[idx].irq = 0;
-
-                if (!io[idx])
-                        continue;
-
-                if (irq[idx] == 2 || irq[idx] == 3 || irq[idx] == 4     ||
-                                irq[idx] == 5   || irq[idx] == 7        ||
-                                irq[idx] == 10  || irq[idx] == 11       ||
-                                irq[idx] == 12  || irq[idx] == 15) {
-                        printk(KERN_ERR "ISICOM: ISA not supported yet.\n");
-                        retval = -EINVAL;
-                        goto error;
-                } else
-                        printk(KERN_ERR "ISICOM: Irq %d unsupported. "
-                                "Disabling Card%d...\n", irq[idx], idx + 1);
         }
 
-        retval = isicom_register_tty_driver();
-        if (retval < 0)
+        /* tty driver structure initialization */
+        isicom_normal = alloc_tty_driver(PORT_COUNT);
+        if (!isicom_normal) {
+                retval = -ENOMEM;
                 goto error;
+        }
+
+        isicom_normal->owner                    = THIS_MODULE;
+        isicom_normal->name                     = "ttyM";
+        isicom_normal->major                    = ISICOM_NMAJOR;
+        isicom_normal->minor_start              = 0;
+        isicom_normal->type                     = TTY_DRIVER_TYPE_SERIAL;
+        isicom_normal->subtype                  = SERIAL_TYPE_NORMAL;
+        isicom_normal->init_termios             = tty_std_termios;
+        isicom_normal->init_termios.c_cflag     = B9600 | CS8 | CREAD | HUPCL |
+                CLOCAL;
+        isicom_normal->flags                    = TTY_DRIVER_REAL_RAW |
+                TTY_DRIVER_DYNAMIC_DEV;
+        tty_set_operations(isicom_normal, &isicom_ops);
+
+        retval = tty_register_driver(isicom_normal);
+        if (retval) {
+                pr_dbg("Couldn't register the dialin driver\n");
+                goto err_puttty;
+        }
 
         retval = pci_register_driver(&isicom_driver);
         if (retval < 0) {
                 printk(KERN_ERR "ISICOM: Unable to register pci driver.\n");
-                goto errtty;
+                goto err_unrtty;
         }
 
-        init_timer(&tx);
-        tx.expires = jiffies + 1;
-        tx.data = 0;
-        tx.function = isicom_tx;
-        re_schedule = 1;
-        add_timer(&tx);
+        mod_timer(&tx, jiffies + 1);
 
         return 0;
-errtty:
-        isicom_unregister_tty_driver();
+err_unrtty:
+        tty_unregister_driver(isicom_normal);
+err_puttty:
+        put_tty_driver(isicom_normal);
 error:
         return retval;
 }
 
 static void __exit isicom_exit(void)
 {
-        unsigned int index = 0;
-
         re_schedule = 0;
 
-        while (re_schedule != 2 && index++ < 100)
-                msleep(10);
+        wait_for_completion_timeout(&isi_timerdone, HZ);
 
         pci_unregister_driver(&isicom_driver);
-        isicom_unregister_tty_driver();
+        tty_unregister_driver(isicom_normal);
+        put_tty_driver(isicom_normal);
 }
 
-module_init(isicom_setup);
+module_init(isicom_init);
 module_exit(isicom_exit);
 
 MODULE_AUTHOR("MultiTech");
 MODULE_DESCRIPTION("Driver for the ISI series of cards by MultiTech");
 MODULE_LICENSE("GPL");
-module_param_array(io, int, NULL, 0);
-MODULE_PARM_DESC(io, "I/O ports for the cards");
-module_param_array(irq, int, NULL, 0);
-MODULE_PARM_DESC(irq, "Interrupts for the cards");
diff --git a/drivers/char/istallion.c b/drivers/char/istallion.c
index 8c09997cc3d6..68645d351873 100644
--- a/drivers/char/istallion.c
+++ b/drivers/char/istallion.c
@@ -14,14 +14,6 @@
  *      the Free Software Foundation; either version 2 of the License, or
  *      (at your option) any later version.
  *
- *      This program is distributed in the hope that it will be useful,
- *      but WITHOUT ANY WARRANTY; without even the implied warranty of
- *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *      GNU General Public License for more details.
- *
- *      You should have received a copy of the GNU General Public License
- *      along with this program; if not, write to the Free Software
- *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
 /*****************************************************************************/
@@ -41,6 +33,7 @@
 #include <linux/device.h>
 #include <linux/wait.h>
 #include <linux/eisa.h>
+#include <linux/ctype.h>
 
 #include <asm/io.h>
 #include <asm/uaccess.h>
@@ -61,21 +54,10 @@
 #define BRD_BRUMBY4     2
 #define BRD_ONBOARD2    3
 #define BRD_ONBOARD     4
-#define BRD_BRUMBY8     5
-#define BRD_BRUMBY16    6
 #define BRD_ONBOARDE    7
-#define BRD_ONBOARD32   9
-#define BRD_ONBOARD2_32 10
-#define BRD_ONBOARDRS   11
-#define BRD_EASYIO      20
-#define BRD_ECH         21
-#define BRD_ECHMC       22
 #define BRD_ECP         23
 #define BRD_ECPE        24
 #define BRD_ECPMC       25
-#define BRD_ECHPCI      26
-#define BRD_ECH64PCI    27
-#define BRD_EASYIOPCI   28
 #define BRD_ECPPCI      29
 
 #define BRD_BRUMBY      BRD_BRUMBY4
@@ -119,20 +101,16 @@
  *      interrupt is required.
  */
 
-typedef struct {
+struct stlconf {
         int             brdtype;
         int             ioaddr1;
         int             ioaddr2;
         unsigned long   memaddr;
         int             irq;
         int             irqtype;
-} stlconf_t;
-
-static stlconf_t        stli_brdconf[] = {
-        /*{ BRD_ECP, 0x2a0, 0, 0xcc000, 0, 0 },*/
 };
 
-static int      stli_nrbrds = ARRAY_SIZE(stli_brdconf);
+static unsigned int stli_nrbrds;
 
 /* stli_lock must NOT be taken holding brd_lock */
 static spinlock_t stli_lock;    /* TTY logic lock */
@@ -194,9 +172,11 @@ static struct tty_struct	*stli_txcooktty;
  *      with this termios initially. Basically all it defines is a raw port
  *      at 9600 baud, 8 data bits, no parity, 1 stop bit.
  */
-static struct termios           stli_deftermios = {
+static struct ktermios          stli_deftermios = {
         .c_cflag        = (B9600 | CS8 | CREAD | HUPCL | CLOCAL),
         .c_cc           = INIT_C_CC,
+        .c_ispeed       = 9600,
+        .c_ospeed       = 9600,
 };
 
 /*
@@ -205,13 +185,12 @@ static struct termios		stli_deftermios = {
  */
 static comstats_t       stli_comstats;
 static combrd_t         stli_brdstats;
-static asystats_t       stli_cdkstats;
-static stlibrd_t        stli_dummybrd;
-static stliport_t       stli_dummyport;
+static struct asystats  stli_cdkstats;
 
 /*****************************************************************************/
 
-static stlibrd_t        *stli_brds[STL_MAXBRDS];
+static DEFINE_MUTEX(stli_brdslock);
+static struct stlibrd   *stli_brds[STL_MAXBRDS];
 
 static int              stli_shared;
 
@@ -223,6 +202,7 @@ static int		stli_shared;
  */
 #define BST_FOUND       0x1
 #define BST_STARTED     0x2
+#define BST_PROBED      0x4
 
 /*
  *      Define the set of port state flags. These are marked for internal
@@ -255,18 +235,18 @@ static char	*stli_brdnames[] = {
         "Brumby",
         "Brumby",
         "ONboard-EI",
-        (char *) NULL,
+        NULL,
         "ONboard",
         "ONboard-MC",
         "ONboard-MC",
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
         "EasyIO",
         "EC8/32-AT",
         "EC8/32-MC",
@@ -304,12 +284,10 @@ static char	**stli_brdsp[] = {
  *      parse any module arguments.
  */
 
-typedef struct stlibrdtype {
+static struct stlibrdtype {
         char    *name;
         int     type;
-} stlibrdtype_t;
-
-static stlibrdtype_t    stli_brdstr[] = {
+} stli_brdstr[] = {
         { "stallion", BRD_STALLION },
         { "1", BRD_STALLION },
         { "brumby", BRD_BRUMBY },
@@ -379,6 +357,7 @@ MODULE_PARM_DESC(board2, "Board 2 config -> name[,ioaddr[,memaddr]");
 module_param_array(board3, charp, NULL, 0);
 MODULE_PARM_DESC(board3, "Board 3 config -> name[,ioaddr[,memaddr]");
 
+#if STLI_EISAPROBE != 0
 /*
  *      Set up a default memory address table for EISA board probing.
  *      The default addresses are all bellow 1Mbyte, which has to be the
@@ -396,14 +375,11 @@ static unsigned long	stli_eisamemprobeaddrs[] = {
 };
 
 static int      stli_eisamempsize = ARRAY_SIZE(stli_eisamemprobeaddrs);
+#endif
 
 /*
  *      Define the Stallion PCI vendor and device IDs.
  */
-#ifdef CONFIG_PCI
-#ifndef PCI_VENDOR_ID_STALLION
-#define PCI_VENDOR_ID_STALLION          0x124d
-#endif
 #ifndef PCI_DEVICE_ID_ECRA
 #define PCI_DEVICE_ID_ECRA              0x0004
 #endif
@@ -414,7 +390,7 @@ static struct pci_device_id istallion_pci_tbl[] = {
 };
 MODULE_DEVICE_TABLE(pci, istallion_pci_tbl);
 
-#endif /* CONFIG_PCI */
+static struct pci_driver stli_pcidriver;
 
 /*****************************************************************************/
 
@@ -612,35 +588,13 @@ MODULE_DEVICE_TABLE(pci, istallion_pci_tbl);
 #define MINOR2BRD(min)          (((min) & 0xc0) >> 6)
 #define MINOR2PORT(min)         ((min) & 0x3f)
 
-/*
- *      Define a baud rate table that converts termios baud rate selector
- *      into the actual baud rate value. All baud rate calculations are based
- *      on the actual baud rate required.
- */
-static unsigned int     stli_baudrates[] = {
-        0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
-        9600, 19200, 38400, 57600, 115200, 230400, 460800, 921600
-};
-
-/*****************************************************************************/
-
-/*
- *      Define some handy local macros...
- */
-#undef MIN
-#define MIN(a,b)        (((a) <= (b)) ? (a) : (b))
-
-#undef  TOLOWER
-#define TOLOWER(x)      ((((x) >= 'A') && ((x) <= 'Z')) ? ((x) + 0x20) : (x))
-
 /*****************************************************************************/
 
 /*
  *      Prototype all functions in this driver!
  */
 
-static int      stli_parsebrd(stlconf_t *confp, char **argp);
-static int      stli_init(void);
+static int      stli_parsebrd(struct stlconf *confp, char **argp);
 static int      stli_open(struct tty_struct *tty, struct file *filp);
 static void     stli_close(struct tty_struct *tty, struct file *filp);
 static int      stli_write(struct tty_struct *tty, const unsigned char *buf, int count);
@@ -649,7 +603,7 @@ static void	stli_flushchars(struct tty_struct *tty);
 static int      stli_writeroom(struct tty_struct *tty);
 static int      stli_charsinbuffer(struct tty_struct *tty);
 static int      stli_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg);
-static void     stli_settermios(struct tty_struct *tty, struct termios *old);
+static void     stli_settermios(struct tty_struct *tty, struct ktermios *old);
 static void     stli_throttle(struct tty_struct *tty);
 static void     stli_unthrottle(struct tty_struct *tty);
 static void     stli_stop(struct tty_struct *tty);
@@ -659,86 +613,84 @@ static void	stli_breakctl(struct tty_struct *tty, int state);
 static void     stli_waituntilsent(struct tty_struct *tty, int timeout);
 static void     stli_sendxchar(struct tty_struct *tty, char ch);
 static void     stli_hangup(struct tty_struct *tty);
-static int      stli_portinfo(stlibrd_t *brdp, stliport_t *portp, int portnr, char *pos);
+static int      stli_portinfo(struct stlibrd *brdp, struct stliport *portp, int portnr, char *pos);
 
-static int      stli_brdinit(stlibrd_t *brdp);
-static int      stli_startbrd(stlibrd_t *brdp);
+static int      stli_brdinit(struct stlibrd *brdp);
+static int      stli_startbrd(struct stlibrd *brdp);
 static ssize_t  stli_memread(struct file *fp, char __user *buf, size_t count, loff_t *offp);
 static ssize_t  stli_memwrite(struct file *fp, const char __user *buf, size_t count, loff_t *offp);
 static int      stli_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg);
-static void     stli_brdpoll(stlibrd_t *brdp, cdkhdr_t __iomem *hdrp);
+static void     stli_brdpoll(struct stlibrd *brdp, cdkhdr_t __iomem *hdrp);
 static void     stli_poll(unsigned long arg);
-static int      stli_hostcmd(stlibrd_t *brdp, stliport_t *portp);
-static int      stli_initopen(stlibrd_t *brdp, stliport_t *portp);
-static int      stli_rawopen(stlibrd_t *brdp, stliport_t *portp, unsigned long arg, int wait);
-static int      stli_rawclose(stlibrd_t *brdp, stliport_t *portp, unsigned long arg, int wait);
-static int      stli_waitcarrier(stlibrd_t *brdp, stliport_t *portp, struct file *filp);
-static void     stli_dohangup(void *arg);
-static int      stli_setport(stliport_t *portp);
-static int      stli_cmdwait(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback);
-static void     stli_sendcmd(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback);
-static void     __stli_sendcmd(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback);
-static void     stli_dodelaycmd(stliport_t *portp, cdkctrl_t __iomem *cp);
-static void     stli_mkasyport(stliport_t *portp, asyport_t *pp, struct termios *tiosp);
+static int      stli_hostcmd(struct stlibrd *brdp, struct stliport *portp);
+static int      stli_initopen(struct stlibrd *brdp, struct stliport *portp);
+static int      stli_rawopen(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait);
+static int      stli_rawclose(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait);
+static int      stli_waitcarrier(struct stlibrd *brdp, struct stliport *portp, struct file *filp);
+static void     stli_dohangup(struct work_struct *);
+static int      stli_setport(struct stliport *portp);
+static int      stli_cmdwait(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback);
+static void     stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback);
+static void     __stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback);
+static void     stli_dodelaycmd(struct stliport *portp, cdkctrl_t __iomem *cp);
+static void     stli_mkasyport(struct stliport *portp, asyport_t *pp, struct ktermios *tiosp);
 static void     stli_mkasysigs(asysigs_t *sp, int dtr, int rts);
 static long     stli_mktiocm(unsigned long sigvalue);
-static void     stli_read(stlibrd_t *brdp, stliport_t *portp);
-static int      stli_getserial(stliport_t *portp, struct serial_struct __user *sp);
-static int      stli_setserial(stliport_t *portp, struct serial_struct __user *sp);
+static void     stli_read(struct stlibrd *brdp, struct stliport *portp);
+static int      stli_getserial(struct stliport *portp, struct serial_struct __user *sp);
+static int      stli_setserial(struct stliport *portp, struct serial_struct __user *sp);
 static int      stli_getbrdstats(combrd_t __user *bp);
-static int      stli_getportstats(stliport_t *portp, comstats_t __user *cp);
-static int      stli_portcmdstats(stliport_t *portp);
-static int      stli_clrportstats(stliport_t *portp, comstats_t __user *cp);
-static int      stli_getportstruct(stliport_t __user *arg);
-static int      stli_getbrdstruct(stlibrd_t __user *arg);
-static stlibrd_t *stli_allocbrd(void);
-
-static void     stli_ecpinit(stlibrd_t *brdp);
-static void     stli_ecpenable(stlibrd_t *brdp);
-static void     stli_ecpdisable(stlibrd_t *brdp);
-static char     *stli_ecpgetmemptr(stlibrd_t *brdp, unsigned long offset, int line);
-static void     stli_ecpreset(stlibrd_t *brdp);
-static void     stli_ecpintr(stlibrd_t *brdp);
-static void     stli_ecpeiinit(stlibrd_t *brdp);
-static void     stli_ecpeienable(stlibrd_t *brdp);
-static void     stli_ecpeidisable(stlibrd_t *brdp);
-static char     *stli_ecpeigetmemptr(stlibrd_t *brdp, unsigned long offset, int line);
-static void     stli_ecpeireset(stlibrd_t *brdp);
-static void     stli_ecpmcenable(stlibrd_t *brdp);
-static void     stli_ecpmcdisable(stlibrd_t *brdp);
-static char     *stli_ecpmcgetmemptr(stlibrd_t *brdp, unsigned long offset, int line);
-static void     stli_ecpmcreset(stlibrd_t *brdp);
-static void     stli_ecppciinit(stlibrd_t *brdp);
-static char     *stli_ecppcigetmemptr(stlibrd_t *brdp, unsigned long offset, int line);
-static void     stli_ecppcireset(stlibrd_t *brdp);
-
-static void     stli_onbinit(stlibrd_t *brdp);
-static void     stli_onbenable(stlibrd_t *brdp);
-static void     stli_onbdisable(stlibrd_t *brdp);
-static char     *stli_onbgetmemptr(stlibrd_t *brdp, unsigned long offset, int line);
-static void     stli_onbreset(stlibrd_t *brdp);
-static void     stli_onbeinit(stlibrd_t *brdp);
-static void     stli_onbeenable(stlibrd_t *brdp);
-static void     stli_onbedisable(stlibrd_t *brdp);
-static char     *stli_onbegetmemptr(stlibrd_t *brdp, unsigned long offset, int line);
-static void     stli_onbereset(stlibrd_t *brdp);
-static void     stli_bbyinit(stlibrd_t *brdp);
-static char     *stli_bbygetmemptr(stlibrd_t *brdp, unsigned long offset, int line);
-static void     stli_bbyreset(stlibrd_t *brdp);
-static void     stli_stalinit(stlibrd_t *brdp);
-static char     *stli_stalgetmemptr(stlibrd_t *brdp, unsigned long offset, int line);
-static void     stli_stalreset(stlibrd_t *brdp);
-
-static stliport_t *stli_getport(int brdnr, int panelnr, int portnr);
-
-static int      stli_initecp(stlibrd_t *brdp);
-static int      stli_initonb(stlibrd_t *brdp);
-static int      stli_eisamemprobe(stlibrd_t *brdp);
-static int      stli_initports(stlibrd_t *brdp);
-
-#ifdef  CONFIG_PCI
-static int      stli_initpcibrd(int brdtype, struct pci_dev *devp);
+static int      stli_getportstats(struct stliport *portp, comstats_t __user *cp);
+static int      stli_portcmdstats(struct stliport *portp);
+static int      stli_clrportstats(struct stliport *portp, comstats_t __user *cp);
+static int      stli_getportstruct(struct stliport __user *arg);
+static int      stli_getbrdstruct(struct stlibrd __user *arg);
+static struct stlibrd *stli_allocbrd(void);
+
+static void     stli_ecpinit(struct stlibrd *brdp);
+static void     stli_ecpenable(struct stlibrd *brdp);
+static void     stli_ecpdisable(struct stlibrd *brdp);
+static void __iomem *stli_ecpgetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
+static void     stli_ecpreset(struct stlibrd *brdp);
+static void     stli_ecpintr(struct stlibrd *brdp);
+static void     stli_ecpeiinit(struct stlibrd *brdp);
+static void     stli_ecpeienable(struct stlibrd *brdp);
+static void     stli_ecpeidisable(struct stlibrd *brdp);
+static void __iomem *stli_ecpeigetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
+static void     stli_ecpeireset(struct stlibrd *brdp);
+static void     stli_ecpmcenable(struct stlibrd *brdp);
+static void     stli_ecpmcdisable(struct stlibrd *brdp);
+static void __iomem *stli_ecpmcgetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
+static void     stli_ecpmcreset(struct stlibrd *brdp);
+static void     stli_ecppciinit(struct stlibrd *brdp);
+static void __iomem *stli_ecppcigetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
+static void     stli_ecppcireset(struct stlibrd *brdp);
+
+static void     stli_onbinit(struct stlibrd *brdp);
+static void     stli_onbenable(struct stlibrd *brdp);
+static void     stli_onbdisable(struct stlibrd *brdp);
+static void __iomem *stli_onbgetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
+static void     stli_onbreset(struct stlibrd *brdp);
+static void     stli_onbeinit(struct stlibrd *brdp);
+static void     stli_onbeenable(struct stlibrd *brdp);
+static void     stli_onbedisable(struct stlibrd *brdp);
+static void __iomem *stli_onbegetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
+static void     stli_onbereset(struct stlibrd *brdp);
+static void     stli_bbyinit(struct stlibrd *brdp);
+static void __iomem *stli_bbygetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
+static void     stli_bbyreset(struct stlibrd *brdp);
+static void     stli_stalinit(struct stlibrd *brdp);
+static void __iomem *stli_stalgetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
+static void     stli_stalreset(struct stlibrd *brdp);
+
+static struct stliport *stli_getport(unsigned int brdnr, unsigned int panelnr, unsigned int portnr);
+
+static int      stli_initecp(struct stlibrd *brdp);
+static int      stli_initonb(struct stlibrd *brdp);
+#if STLI_EISAPROBE != 0
+static int      stli_eisamemprobe(struct stlibrd *brdp);
 #endif
+static int      stli_initports(struct stlibrd *brdp);
 
 /*****************************************************************************/
 
@@ -776,154 +728,37 @@ static int	stli_timeron;
 
 static struct class *istallion_class;
 
-/*
- *      Loadable module initialization stuff.
- */
-
-static int __init istallion_module_init(void)
+static void stli_cleanup_ports(struct stlibrd *brdp)
 {
-        stli_init();
-        return 0;
-}
-
-/*****************************************************************************/
-
-static void __exit istallion_module_exit(void)
-{
-        stlibrd_t       *brdp;
-        stliport_t      *portp;
-        int             i, j;
-
-        printk(KERN_INFO "Unloading %s: version %s\n", stli_drvtitle,
-                stli_drvversion);
-
-        /*
-         *      Free up all allocated resources used by the ports. This includes
-         *      memory and interrupts.
-         */
-        if (stli_timeron) {
-                stli_timeron = 0;
-                del_timer_sync(&stli_timerlist);
-        }
-
-        i = tty_unregister_driver(stli_serial);
-        if (i) {
-                printk("STALLION: failed to un-register tty driver, "
-                        "errno=%d\n", -i);
-                return;
-        }
-        put_tty_driver(stli_serial);
-        for (i = 0; i < 4; i++)
-                class_device_destroy(istallion_class, MKDEV(STL_SIOMEMMAJOR, i));
-        class_destroy(istallion_class);
-        if ((i = unregister_chrdev(STL_SIOMEMMAJOR, "staliomem")))
-                printk("STALLION: failed to un-register serial memory device, "
-                        "errno=%d\n", -i);
-
-        kfree(stli_txcookbuf);
-
-        for (i = 0; (i < stli_nrbrds); i++) {
-                if ((brdp = stli_brds[i]) == NULL)
-                        continue;
-                for (j = 0; (j < STL_MAXPORTS); j++) {
-                        portp = brdp->ports[j];
-                        if (portp != NULL) {
-                                if (portp->tty != NULL)
-                                        tty_hangup(portp->tty);
-                                kfree(portp);
-                        }
+        struct stliport *portp;
+        unsigned int j;
+
+        for (j = 0; j < STL_MAXPORTS; j++) {
+                portp = brdp->ports[j];
+                if (portp != NULL) {
+                        if (portp->tty != NULL)
+                                tty_hangup(portp->tty);
+                        kfree(portp);
                 }
-
-                iounmap(brdp->membase);
-                if (brdp->iosize > 0)
-                        release_region(brdp->iobase, brdp->iosize);
-                kfree(brdp);
-                stli_brds[i] = NULL;
         }
 }
 
-module_init(istallion_module_init);
-module_exit(istallion_module_exit);
-
-/*****************************************************************************/
-
-/*
- *      Check for any arguments passed in on the module load command line.
- */
-
-static void stli_argbrds(void)
-{
-        stlconf_t conf;
-        stlibrd_t *brdp;
-        int i;
-
-        for (i = stli_nrbrds; i < ARRAY_SIZE(stli_brdsp); i++) {
-                memset(&conf, 0, sizeof(conf));
-                if (stli_parsebrd(&conf, stli_brdsp[i]) == 0)
-                        continue;
-                if ((brdp = stli_allocbrd()) == NULL)
-                        continue;
-                stli_nrbrds = i + 1;
-                brdp->brdnr = i;
-                brdp->brdtype = conf.brdtype;
-                brdp->iobase = conf.ioaddr1;
-                brdp->memaddr = conf.memaddr;
-                stli_brdinit(brdp);
-        }
-}
-
-/*****************************************************************************/
-
-/*
- *      Convert an ascii string number into an unsigned long.
- */
-
-static unsigned long stli_atol(char *str)
-{
-        unsigned long val;
-        int base, c;
-        char *sp;
-
-        val = 0;
-        sp = str;
-        if ((*sp == '0') && (*(sp+1) == 'x')) {
-                base = 16;
-                sp += 2;
-        } else if (*sp == '0') {
-                base = 8;
-                sp++;
-        } else {
-                base = 10;
-        }
-
-        for (; (*sp != 0); sp++) {
-                c = (*sp > '9') ? (TOLOWER(*sp) - 'a' + 10) : (*sp - '0');
-                if ((c < 0) || (c >= base)) {
-                        printk("STALLION: invalid argument %s\n", str);
-                        val = 0;
-                        break;
-                }
-                val = (val * base) + c;
-        }
-        return(val);
-}
-
 /*****************************************************************************/
 
 /*
  *      Parse the supplied argument string, into the board conf struct.
  */
 
-static int stli_parsebrd(stlconf_t *confp, char **argp)
+static int stli_parsebrd(struct stlconf *confp, char **argp)
 {
+        unsigned int i;
         char *sp;
-        int i;
 
         if (argp[0] == NULL || *argp[0] == 0)
                 return 0;
 
         for (sp = argp[0], i = 0; ((*sp != 0) && (i < 25)); sp++, i++)
-                *sp = TOLOWER(*sp);
+                *sp = tolower(*sp);
 
         for (i = 0; i < ARRAY_SIZE(stli_brdstr); i++) {
                 if (strcmp(stli_brdstr[i].name, argp[0]) == 0)
@@ -936,9 +771,9 @@ static int stli_parsebrd(stlconf_t *confp, char **argp)
 
         confp->brdtype = stli_brdstr[i].type;
         if (argp[1] != NULL && *argp[1] != 0)
-                confp->ioaddr1 = stli_atol(argp[1]);
+                confp->ioaddr1 = simple_strtoul(argp[1], NULL, 0);
         if (argp[2] !=  NULL && *argp[2] != 0)
-                confp->memaddr = stli_atol(argp[2]);
+                confp->memaddr = simple_strtoul(argp[2], NULL, 0);
         return(1);
 }
 
@@ -946,10 +781,10 @@ static int stli_parsebrd(stlconf_t *confp, char **argp)
 
 static int stli_open(struct tty_struct *tty, struct file *filp)
 {
-        stlibrd_t *brdp;
-        stliport_t *portp;
-        unsigned int minordev;
-        int brdnr, portnr, rc;
+        struct stlibrd *brdp;
+        struct stliport *portp;
+        unsigned int minordev, brdnr, portnr;
+        int rc;
 
         minordev = tty->index;
         brdnr = MINOR2BRD(minordev);
@@ -961,7 +796,7 @@ static int stli_open(struct tty_struct *tty, struct file *filp)
         if ((brdp->state & BST_STARTED) == 0)
                 return -ENODEV;
         portnr = MINOR2PORT(minordev);
-        if ((portnr < 0) || (portnr > brdp->nrports))
+        if (portnr > brdp->nrports)
                 return -ENODEV;
 
         portp = brdp->ports[portnr];
@@ -1041,8 +876,8 @@ static int stli_open(struct tty_struct *tty, struct file *filp)
 
 static void stli_close(struct tty_struct *tty, struct file *filp)
 {
-        stlibrd_t *brdp;
-        stliport_t *portp;
+        struct stlibrd *brdp;
+        struct stliport *portp;
         unsigned long flags;
 
         portp = tty->driver_data;
@@ -1119,7 +954,7 @@ static void stli_close(struct tty_struct *tty, struct file *filp)
  *      this still all happens pretty quickly.
  */
 
-static int stli_initopen(stlibrd_t *brdp, stliport_t *portp)
+static int stli_initopen(struct stlibrd *brdp, struct stliport *portp)
 {
         struct tty_struct *tty;
         asynotify_t nt;
@@ -1167,7 +1002,7 @@ static int stli_initopen(stlibrd_t *brdp, stliport_t *portp)
  *      to overlap.
  */
 
-static int stli_rawopen(stlibrd_t *brdp, stliport_t *portp, unsigned long arg, int wait)
+static int stli_rawopen(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait)
 {
         cdkhdr_t __iomem *hdrp;
         cdkctrl_t __iomem *cp;
@@ -1238,7 +1073,7 @@ static int stli_rawopen(stlibrd_t *brdp, stliport_t *portp, unsigned long arg, i
  *      wait is true then must have user context (to sleep).
  */
 
-static int stli_rawclose(stlibrd_t *brdp, stliport_t *portp, unsigned long arg, int wait)
+static int stli_rawclose(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait)
 {
         cdkhdr_t __iomem *hdrp;
         cdkctrl_t __iomem *cp;
@@ -1302,7 +1137,7 @@ static int stli_rawclose(stlibrd_t *brdp, stliport_t *portp, unsigned long arg,
  *      to complete (as opposed to initiating the command then returning).
  */
 
-static int stli_cmdwait(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback)
+static int stli_cmdwait(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback)
 {
         wait_event_interruptible(portp->raw_wait,
                         !test_bit(ST_CMDING, &portp->state));
@@ -1328,16 +1163,16 @@ static int stli_cmdwait(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, v
  *      waiting for the command to complete - so must have user context.
  */
 
-static int stli_setport(stliport_t *portp)
+static int stli_setport(struct stliport *portp)
 {
-        stlibrd_t *brdp;
+        struct stlibrd *brdp;
         asyport_t aport;
 
         if (portp == NULL)
                 return -ENODEV;
         if (portp->tty == NULL)
                 return -ENODEV;
-        if (portp->brdnr < 0 && portp->brdnr >= stli_nrbrds)
+        if (portp->brdnr >= stli_nrbrds)
                 return -ENODEV;
         brdp = stli_brds[portp->brdnr];
         if (brdp == NULL)
@@ -1354,7 +1189,7 @@ static int stli_setport(stliport_t *portp)
  *      maybe because if we are clocal then we don't need to wait...
  */
 
-static int stli_waitcarrier(stlibrd_t *brdp, stliport_t *portp, struct file *filp)
+static int stli_waitcarrier(struct stlibrd *brdp, struct stliport *portp, struct file *filp)
 {
         unsigned long flags;
         int rc, doclocal;
@@ -1419,8 +1254,8 @@ static int stli_write(struct tty_struct *tty, const unsigned char *buf, int coun
         unsigned char __iomem *bits;
         unsigned char __iomem *shbuf;
         unsigned char *chbuf;
-        stliport_t *portp;
-        stlibrd_t *brdp;
+        struct stliport *portp;
+        struct stlibrd *brdp;
         unsigned int len, stlen, head, tail, size;
         unsigned long flags;
 
@@ -1429,7 +1264,7 @@ static int stli_write(struct tty_struct *tty, const unsigned char *buf, int coun
         portp = tty->driver_data;
         if (portp == NULL)
                 return 0;
-        if ((portp->brdnr < 0) || (portp->brdnr >= stli_nrbrds))
+        if (portp->brdnr >= stli_nrbrds)
                 return 0;
         brdp = stli_brds[portp->brdnr];
         if (brdp == NULL)
@@ -1455,12 +1290,12 @@ static int stli_write(struct tty_struct *tty, const unsigned char *buf, int coun
                 stlen = len;
         }
 
-        len = MIN(len, count);
+        len = min(len, (unsigned int)count);
         count = 0;
         shbuf = (char __iomem *) EBRDGETMEMPTR(brdp, portp->txoffset);
 
         while (len > 0) {
-                stlen = MIN(len, stlen);
+                stlen = min(len, stlen);
                 memcpy_toio(shbuf + head, chbuf, stlen);
                 chbuf += stlen;
                 len -= stlen;
@@ -1526,8 +1361,8 @@ static void stli_flushchars(struct tty_struct *tty)
         unsigned char __iomem *bits;
         cdkasy_t __iomem *ap;
         struct tty_struct *cooktty;
-        stliport_t *portp;
-        stlibrd_t *brdp;
+        struct stliport *portp;
+        struct stlibrd *brdp;
         unsigned int len, stlen, head, tail, size, count, cooksize;
         unsigned char *buf;
         unsigned char __iomem *shbuf;
@@ -1551,7 +1386,7 @@ static void stli_flushchars(struct tty_struct *tty)
         portp = tty->driver_data;
         if (portp == NULL)
                 return;
-        if ((portp->brdnr < 0) || (portp->brdnr >= stli_nrbrds))
+        if (portp->brdnr >= stli_nrbrds)
                 return;
         brdp = stli_brds[portp->brdnr];
         if (brdp == NULL)
@@ -1574,13 +1409,13 @@ static void stli_flushchars(struct tty_struct *tty)
                 stlen = len;
         }
 
-        len = MIN(len, cooksize);
+        len = min(len, cooksize);
         count = 0;
-        shbuf = (char *) EBRDGETMEMPTR(brdp, portp->txoffset);
+        shbuf = EBRDGETMEMPTR(brdp, portp->txoffset);
         buf = stli_txcookbuf;
 
         while (len > 0) {
-                stlen = MIN(len, stlen);
+                stlen = min(len, stlen);
                 memcpy_toio(shbuf + head, buf, stlen);
                 buf += stlen;
                 len -= stlen;
@@ -1614,8 +1449,8 @@ static void stli_flushchars(struct tty_struct *tty)
 static int stli_writeroom(struct tty_struct *tty)
 {
         cdkasyrq_t __iomem *rp;
-        stliport_t *portp;
-        stlibrd_t *brdp;
+        struct stliport *portp;
+        struct stlibrd *brdp;
         unsigned int head, tail, len;
         unsigned long flags;
 
@@ -1629,7 +1464,7 @@ static int stli_writeroom(struct tty_struct *tty)
         portp = tty->driver_data;
         if (portp == NULL)
                 return 0;
-        if ((portp->brdnr < 0) || (portp->brdnr >= stli_nrbrds))
+        if (portp->brdnr >= stli_nrbrds)
                 return 0;
         brdp = stli_brds[portp->brdnr];
         if (brdp == NULL)
@@ -1667,8 +1502,8 @@ static int stli_writeroom(struct tty_struct *tty)
 static int stli_charsinbuffer(struct tty_struct *tty)
 {
         cdkasyrq_t __iomem *rp;
-        stliport_t *portp;
-        stlibrd_t *brdp;
+        struct stliport *portp;
+        struct stlibrd *brdp;
         unsigned int head, tail, len;
         unsigned long flags;
 
@@ -1677,7 +1512,7 @@ static int stli_charsinbuffer(struct tty_struct *tty)
         portp = tty->driver_data;
         if (portp == NULL)
                 return 0;
-        if ((portp->brdnr < 0) || (portp->brdnr >= stli_nrbrds))
+        if (portp->brdnr >= stli_nrbrds)
                 return 0;
         brdp = stli_brds[portp->brdnr];
         if (brdp == NULL)
@@ -1705,10 +1540,10 @@ static int stli_charsinbuffer(struct tty_struct *tty)
  *      Generate the serial struct info.
  */
 
-static int stli_getserial(stliport_t *portp, struct serial_struct __user *sp)
+static int stli_getserial(struct stliport *portp, struct serial_struct __user *sp)
 {
         struct serial_struct sio;
-        stlibrd_t *brdp;
+        struct stlibrd *brdp;
 
         memset(&sio, 0, sizeof(struct serial_struct));
         sio.type = PORT_UNKNOWN;
@@ -1738,7 +1573,7 @@ static int stli_getserial(stliport_t *portp, struct serial_struct __user *sp)
  *      just quietly ignore any requests to change irq, etc.
  */
 
-static int stli_setserial(stliport_t *portp, struct serial_struct __user *sp)
+static int stli_setserial(struct stliport *portp, struct serial_struct __user *sp)
 {
         struct serial_struct sio;
         int rc;
@@ -1769,13 +1604,13 @@ static int stli_setserial(stliport_t *portp, struct serial_struct __user *sp)
 
 static int stli_tiocmget(struct tty_struct *tty, struct file *file)
 {
-        stliport_t *portp = tty->driver_data;
-        stlibrd_t *brdp;
+        struct stliport *portp = tty->driver_data;
+        struct stlibrd *brdp;
         int rc;
 
         if (portp == NULL)
                 return -ENODEV;
-        if (portp->brdnr < 0 || portp->brdnr >= stli_nrbrds)
+        if (portp->brdnr >= stli_nrbrds)
                 return 0;
         brdp = stli_brds[portp->brdnr];
         if (brdp == NULL)
@@ -1793,13 +1628,13 @@ static int stli_tiocmget(struct tty_struct *tty, struct file *file)
 static int stli_tiocmset(struct tty_struct *tty, struct file *file,
                          unsigned int set, unsigned int clear)
 {
-        stliport_t *portp = tty->driver_data;
-        stlibrd_t *brdp;
+        struct stliport *portp = tty->driver_data;
+        struct stlibrd *brdp;
         int rts = -1, dtr = -1;
 
         if (portp == NULL)
                 return -ENODEV;
-        if (portp->brdnr < 0 || portp->brdnr >= stli_nrbrds)
+        if (portp->brdnr >= stli_nrbrds)
                 return 0;
         brdp = stli_brds[portp->brdnr];
         if (brdp == NULL)
@@ -1824,8 +1659,8 @@ static int stli_tiocmset(struct tty_struct *tty, struct file *file,
 
 static int stli_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
 {
-        stliport_t *portp;
-        stlibrd_t *brdp;
+        struct stliport *portp;
+        struct stlibrd *brdp;
         unsigned int ival;
         int rc;
         void __user *argp = (void __user *)arg;
@@ -1833,7 +1668,7 @@ static int stli_ioctl(struct tty_struct *tty, struct file *file, unsigned int cm
         portp = tty->driver_data;
         if (portp == NULL)
                 return -ENODEV;
-        if (portp->brdnr < 0 || portp->brdnr >= stli_nrbrds)
+        if (portp->brdnr >= stli_nrbrds)
                 return 0;
         brdp = stli_brds[portp->brdnr];
         if (brdp == NULL)
@@ -1899,11 +1734,11 @@ static int stli_ioctl(struct tty_struct *tty, struct file *file, unsigned int cm
  *      Looks like it is true for the current ttys implementation..!!
  */
 
-static void stli_settermios(struct tty_struct *tty, struct termios *old)
+static void stli_settermios(struct tty_struct *tty, struct ktermios *old)
 {
-        stliport_t *portp;
-        stlibrd_t *brdp;
-        struct termios *tiosp;
+        struct stliport *portp;
+        struct stlibrd *brdp;
+        struct ktermios *tiosp;
         asyport_t aport;
 
         if (tty == NULL)
@@ -1911,7 +1746,7 @@ static void stli_settermios(struct tty_struct *tty, struct termios *old)
         portp = tty->driver_data;
         if (portp == NULL)
                 return;
-        if (portp->brdnr < 0 || portp->brdnr >= stli_nrbrds)
+        if (portp->brdnr >= stli_nrbrds)
                 return;
         brdp = stli_brds[portp->brdnr];
         if (brdp == NULL)
@@ -1947,7 +1782,7 @@ static void stli_settermios(struct tty_struct *tty, struct termios *old)
 
 static void stli_throttle(struct tty_struct *tty)
 {
-        stliport_t      *portp = tty->driver_data;
+        struct stliport *portp = tty->driver_data;
         if (portp == NULL)
                 return;
         set_bit(ST_RXSTOP, &portp->state);
@@ -1963,7 +1798,7 @@ static void stli_throttle(struct tty_struct *tty)
 
 static void stli_unthrottle(struct tty_struct *tty)
 {
-        stliport_t      *portp = tty->driver_data;
+        struct stliport *portp = tty->driver_data;
         if (portp == NULL)
                 return;
         clear_bit(ST_RXSTOP, &portp->state);
@@ -2000,9 +1835,9 @@ static void stli_start(struct tty_struct *tty)
  *      aren't that time critical).
  */
 
-static void stli_dohangup(void *arg)
+static void stli_dohangup(struct work_struct *ugly_api)
 {
-        stliport_t *portp = (stliport_t *) arg;
+        struct stliport *portp = container_of(ugly_api, struct stliport, tqhangup);
         if (portp->tty != NULL) {
                 tty_hangup(portp->tty);
         }
@@ -2019,14 +1854,14 @@ static void stli_dohangup(void *arg)
 
 static void stli_hangup(struct tty_struct *tty)
 {
-        stliport_t *portp;
-        stlibrd_t *brdp;
+        struct stliport *portp;
+        struct stlibrd *brdp;
         unsigned long flags;
 
         portp = tty->driver_data;
         if (portp == NULL)
                 return;
-        if (portp->brdnr < 0 || portp->brdnr >= stli_nrbrds)
+        if (portp->brdnr >= stli_nrbrds)
                 return;
         brdp = stli_brds[portp->brdnr];
         if (brdp == NULL)
@@ -2072,14 +1907,14 @@ static void stli_hangup(struct tty_struct *tty)
 
 static void stli_flushbuffer(struct tty_struct *tty)
 {
-        stliport_t *portp;
-        stlibrd_t *brdp;
+        struct stliport *portp;
+        struct stlibrd *brdp;
         unsigned long ftype, flags;
 
         portp = tty->driver_data;
         if (portp == NULL)
                 return;
-        if (portp->brdnr < 0 || portp->brdnr >= stli_nrbrds)
+        if (portp->brdnr >= stli_nrbrds)
                 return;
         brdp = stli_brds[portp->brdnr];
         if (brdp == NULL)
@@ -2109,14 +1944,14 @@ static void stli_flushbuffer(struct tty_struct *tty)
 
 static void stli_breakctl(struct tty_struct *tty, int state)
 {
-        stlibrd_t       *brdp;
-        stliport_t      *portp;
+        struct stlibrd  *brdp;
+        struct stliport *portp;
         long            arg;
 
         portp = tty->driver_data;
         if (portp == NULL)
                 return;
-        if (portp->brdnr < 0 || portp->brdnr >= stli_nrbrds)
+        if (portp->brdnr >= stli_nrbrds)
                 return;
         brdp = stli_brds[portp->brdnr];
         if (brdp == NULL)
@@ -2130,7 +1965,7 @@ static void stli_breakctl(struct tty_struct *tty, int state)
 
 static void stli_waituntilsent(struct tty_struct *tty, int timeout)
 {
-        stliport_t *portp;
+        struct stliport *portp;
         unsigned long tend;
 
         if (tty == NULL)
@@ -2156,14 +1991,14 @@ static void stli_waituntilsent(struct tty_struct *tty, int timeout)
 
 static void stli_sendxchar(struct tty_struct *tty, char ch)
 {
-        stlibrd_t       *brdp;
-        stliport_t      *portp;
+        struct stlibrd  *brdp;
+        struct stliport *portp;
         asyctrl_t       actrl;
 
         portp = tty->driver_data;
         if (portp == NULL)
                 return;
-        if (portp->brdnr < 0 || portp->brdnr >= stli_nrbrds)
+        if (portp->brdnr >= stli_nrbrds)
                 return;
         brdp = stli_brds[portp->brdnr];
         if (brdp == NULL)
@@ -2191,7 +2026,7 @@ static void stli_sendxchar(struct tty_struct *tty, char ch)
  *      short then padded with spaces).
  */
 
-static int stli_portinfo(stlibrd_t *brdp, stliport_t *portp, int portnr, char *pos)
+static int stli_portinfo(struct stlibrd *brdp, struct stliport *portp, int portnr, char *pos)
 {
         char *sp, *uart;
         int rc, cnt;
@@ -2254,9 +2089,9 @@ static int stli_portinfo(stlibrd_t *brdp, stliport_t *portp, int portnr, char *p
 
 static int stli_readproc(char *page, char **start, off_t off, int count, int *eof, void *data)
 {
-        stlibrd_t *brdp;
-        stliport_t *portp;
-        int brdnr, portnr, totalport;
+        struct stlibrd *brdp;
+        struct stliport *portp;
+        unsigned int brdnr, portnr, totalport;
         int curoff, maxoff;
         char *pos;
 
@@ -2326,7 +2161,7 @@ stli_readdone:
  *      entry point)
  */
 
-static void __stli_sendcmd(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback)
+static void __stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback)
 {
         cdkhdr_t __iomem *hdrp;
         cdkctrl_t __iomem *cp;
@@ -2362,7 +2197,7 @@ static void __stli_sendcmd(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd
         spin_unlock_irqrestore(&brd_lock, flags);
 }
 
-static void stli_sendcmd(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback)
+static void stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback)
 {
         unsigned long           flags;
 
@@ -2381,7 +2216,7 @@ static void stli_sendcmd(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd,
  *      more chars to unload.
  */
 
-static void stli_read(stlibrd_t *brdp, stliport_t *portp)
+static void stli_read(struct stlibrd *brdp, struct stliport *portp)
 {
         cdkasyrq_t __iomem *rp;
         char __iomem *shbuf;
@@ -2416,7 +2251,7 @@ static void stli_read(stlibrd_t *brdp, stliport_t *portp)
         while (len > 0) {
                 unsigned char *cptr;
 
-                stlen = MIN(len, stlen);
+                stlen = min(len, stlen);
                 tty_prepare_flip_string(tty, &cptr, stlen);
                 memcpy_fromio(cptr, shbuf + tail, stlen);
                 len -= stlen;
@@ -2443,7 +2278,7 @@ static void stli_read(stlibrd_t *brdp, stliport_t *portp)
  *      difficult to deal with them here.
  */
 
-static void stli_dodelaycmd(stliport_t *portp, cdkctrl_t __iomem *cp)
+static void stli_dodelaycmd(struct stliport *portp, cdkctrl_t __iomem *cp)
 {
         int cmd;
 
@@ -2491,7 +2326,7 @@ static void stli_dodelaycmd(stliport_t *portp, cdkctrl_t __iomem *cp)
  *      then port is still busy, otherwise no longer busy.
  */
 
-static int stli_hostcmd(stlibrd_t *brdp, stliport_t *portp)
+static int stli_hostcmd(struct stlibrd *brdp, struct stliport *portp)
 {
         cdkasy_t __iomem *ap;
         cdkctrl_t __iomem *cp;
@@ -2638,9 +2473,9 @@ static int stli_hostcmd(stlibrd_t *brdp, stliport_t *portp)
  *      at the cdk header structure.
  */
 
-static void stli_brdpoll(stlibrd_t *brdp, cdkhdr_t __iomem *hdrp)
+static void stli_brdpoll(struct stlibrd *brdp, cdkhdr_t __iomem *hdrp)
 {
-        stliport_t *portp;
+        struct stliport *portp;
         unsigned char hostbits[(STL_MAXCHANS / 8) + 1];
         unsigned char slavebits[(STL_MAXCHANS / 8) + 1];
         unsigned char __iomem *slavep;
@@ -2707,11 +2542,10 @@ static void stli_brdpoll(stlibrd_t *brdp, cdkhdr_t __iomem *hdrp)
 static void stli_poll(unsigned long arg)
 {
         cdkhdr_t __iomem *hdrp;
-        stlibrd_t *brdp;
-        int brdnr;
+        struct stlibrd *brdp;
+        unsigned int brdnr;
 
-        stli_timerlist.expires = STLI_TIMEOUT;
-        add_timer(&stli_timerlist);
+        mod_timer(&stli_timerlist, STLI_TIMEOUT);
 
 /*
  *      Check each board and do any servicing required.
@@ -2740,22 +2574,14 @@ static void stli_poll(unsigned long arg)
  *      the slave.
  */
 
-static void stli_mkasyport(stliport_t *portp, asyport_t *pp, struct termios *tiosp)
+static void stli_mkasyport(struct stliport *portp, asyport_t *pp, struct ktermios *tiosp)
 {
         memset(pp, 0, sizeof(asyport_t));
 
 /*
  *      Start of by setting the baud, char size, parity and stop bit info.
  */
-        pp->baudout = tiosp->c_cflag & CBAUD;
-        if (pp->baudout & CBAUDEX) {
-                pp->baudout &= ~CBAUDEX;
-                if ((pp->baudout < 1) || (pp->baudout > 4))
-                        tiosp->c_cflag &= ~CBAUDEX;
-                else
-                        pp->baudout += 15;
-        }
-        pp->baudout = stli_baudrates[pp->baudout];
+        pp->baudout = tty_get_baud_rate(portp->tty);
         if ((tiosp->c_cflag & CBAUD) == B38400) {
                 if ((portp->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
                         pp->baudout = 57600;
@@ -2897,13 +2723,13 @@ static long stli_mktiocm(unsigned long sigvalue)
  *      we need to do here is set up the appropriate per port data structures.
  */
 
-static int stli_initports(stlibrd_t *brdp)
+static int stli_initports(struct stlibrd *brdp)
 {
-        stliport_t      *portp;
-        int             i, panelnr, panelport;
+        struct stliport *portp;
+        unsigned int i, panelnr, panelport;
 
         for (i = 0, panelnr = 0, panelport = 0; (i < brdp->nrports); i++) {
-                portp = kzalloc(sizeof(stliport_t), GFP_KERNEL);
+                portp = kzalloc(sizeof(struct stliport), GFP_KERNEL);
                 if (!portp) {
                         printk("STALLION: failed to allocate port structure\n");
                         continue;
@@ -2916,7 +2742,7 @@ static int stli_initports(stlibrd_t *brdp)
                 portp->baud_base = STL_BAUDBASE;
                 portp->close_delay = STL_CLOSEDELAY;
                 portp->closing_wait = 30 * HZ;
-                INIT_WORK(&portp->tqhangup, stli_dohangup, portp);
+                INIT_WORK(&portp->tqhangup, stli_dohangup);
                 init_waitqueue_head(&portp->open_wait);
                 init_waitqueue_head(&portp->close_wait);
                 init_waitqueue_head(&portp->raw_wait);
@@ -2937,7 +2763,7 @@ static int stli_initports(stlibrd_t *brdp)
  *      All the following routines are board specific hardware operations.
  */
 
-static void stli_ecpinit(stlibrd_t *brdp)
+static void stli_ecpinit(struct stlibrd *brdp)
 {
         unsigned long   memconf;
 
@@ -2952,23 +2778,23 @@ static void stli_ecpinit(stlibrd_t *brdp)
 
 /*****************************************************************************/
 
-static void stli_ecpenable(stlibrd_t *brdp)
+static void stli_ecpenable(struct stlibrd *brdp)
 {       
         outb(ECP_ATENABLE, (brdp->iobase + ECP_ATCONFR));
 }
 
 /*****************************************************************************/
 
-static void stli_ecpdisable(stlibrd_t *brdp)
+static void stli_ecpdisable(struct stlibrd *brdp)
 {       
         outb(ECP_ATDISABLE, (brdp->iobase + ECP_ATCONFR));
 }
 
 /*****************************************************************************/
 
-static char *stli_ecpgetmemptr(stlibrd_t *brdp, unsigned long offset, int line)
+static void __iomem *stli_ecpgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
 {       
-        void *ptr;
+        void __iomem *ptr;
         unsigned char val;
 
         if (offset > brdp->memsize) {
@@ -2987,7 +2813,7 @@ static char *stli_ecpgetmemptr(stlibrd_t *brdp, unsigned long offset, int line)
 
 /*****************************************************************************/
 
-static void stli_ecpreset(stlibrd_t *brdp)
+static void stli_ecpreset(struct stlibrd *brdp)
 {       
         outb(ECP_ATSTOP, (brdp->iobase + ECP_ATCONFR));
         udelay(10);
@@ -2997,7 +2823,7 @@ static void stli_ecpreset(stlibrd_t *brdp)
 
 /*****************************************************************************/
 
-static void stli_ecpintr(stlibrd_t *brdp)
+static void stli_ecpintr(struct stlibrd *brdp)
 {       
         outb(0x1, brdp->iobase);
 }
@@ -3008,7 +2834,7 @@ static void stli_ecpintr(stlibrd_t *brdp)
  *      The following set of functions act on ECP EISA boards.
  */
 
-static void stli_ecpeiinit(stlibrd_t *brdp)
+static void stli_ecpeiinit(struct stlibrd *brdp)
 {
         unsigned long   memconf;
 
@@ -3026,23 +2852,23 @@ static void stli_ecpeiinit(stlibrd_t *brdp)
 
 /*****************************************************************************/
 
-static void stli_ecpeienable(stlibrd_t *brdp)
+static void stli_ecpeienable(struct stlibrd *brdp)
 {       
         outb(ECP_EIENABLE, (brdp->iobase + ECP_EICONFR));
 }
 
 /*****************************************************************************/
 
-static void stli_ecpeidisable(stlibrd_t *brdp)
+static void stli_ecpeidisable(struct stlibrd *brdp)
 {       
         outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR));
 }
 
 /*****************************************************************************/
 
-static char *stli_ecpeigetmemptr(stlibrd_t *brdp, unsigned long offset, int line)
+static void __iomem *stli_ecpeigetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
 {       
-        void            *ptr;
+        void __iomem *ptr;
         unsigned char   val;
 
         if (offset > brdp->memsize) {
@@ -3064,7 +2890,7 @@ static char *stli_ecpeigetmemptr(stlibrd_t *brdp, unsigned long offset, int line
 
 /*****************************************************************************/
 
-static void stli_ecpeireset(stlibrd_t *brdp)
+static void stli_ecpeireset(struct stlibrd *brdp)
 {       
         outb(ECP_EISTOP, (brdp->iobase + ECP_EICONFR));
         udelay(10);
@@ -3078,23 +2904,23 @@ static void stli_ecpeireset(stlibrd_t *brdp)
  *      The following set of functions act on ECP MCA boards.
  */
 
-static void stli_ecpmcenable(stlibrd_t *brdp)
+static void stli_ecpmcenable(struct stlibrd *brdp)
 {       
         outb(ECP_MCENABLE, (brdp->iobase + ECP_MCCONFR));
 }
 
 /*****************************************************************************/
 
-static void stli_ecpmcdisable(stlibrd_t *brdp)
+static void stli_ecpmcdisable(struct stlibrd *brdp)
 {       
         outb(ECP_MCDISABLE, (brdp->iobase + ECP_MCCONFR));
 }
 
 /*****************************************************************************/
 
-static char *stli_ecpmcgetmemptr(stlibrd_t *brdp, unsigned long offset, int line)
+static void __iomem *stli_ecpmcgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
 {       
-        void *ptr;
+        void __iomem *ptr;
         unsigned char val;
 
         if (offset > brdp->memsize) {
@@ -3113,7 +2939,7 @@ static char *stli_ecpmcgetmemptr(stlibrd_t *brdp, unsigned long offset, int line
 
 /*****************************************************************************/
 
-static void stli_ecpmcreset(stlibrd_t *brdp)
+static void stli_ecpmcreset(struct stlibrd *brdp)
 {       
         outb(ECP_MCSTOP, (brdp->iobase + ECP_MCCONFR));
         udelay(10);
@@ -3127,7 +2953,7 @@ static void stli_ecpmcreset(stlibrd_t *brdp)
  *      The following set of functions act on ECP PCI boards.
  */
 
-static void stli_ecppciinit(stlibrd_t *brdp)
+static void stli_ecppciinit(struct stlibrd *brdp)
 {
         outb(ECP_PCISTOP, (brdp->iobase + ECP_PCICONFR));
         udelay(10);
@@ -3137,9 +2963,9 @@ static void stli_ecppciinit(stlibrd_t *brdp)
 
 /*****************************************************************************/
 
-static char *stli_ecppcigetmemptr(stlibrd_t *brdp, unsigned long offset, int line)
+static void __iomem *stli_ecppcigetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
 {       
-        void            *ptr;
+        void __iomem *ptr;
         unsigned char   val;
 
         if (offset > brdp->memsize) {
@@ -3158,7 +2984,7 @@ static char *stli_ecppcigetmemptr(stlibrd_t *brdp, unsigned long offset, int lin
 
 /*****************************************************************************/
 
-static void stli_ecppcireset(stlibrd_t *brdp)
+static void stli_ecppcireset(struct stlibrd *brdp)
 {       
         outb(ECP_PCISTOP, (brdp->iobase + ECP_PCICONFR));
         udelay(10);
@@ -3172,7 +2998,7 @@ static void stli_ecppcireset(stlibrd_t *brdp)
  *      The following routines act on ONboards.
  */
 
-static void stli_onbinit(stlibrd_t *brdp)
+static void stli_onbinit(struct stlibrd *brdp)
 {
         unsigned long   memconf;
 
@@ -3189,23 +3015,23 @@ static void stli_onbinit(stlibrd_t *brdp)
 
 /*****************************************************************************/
 
-static void stli_onbenable(stlibrd_t *brdp)
+static void stli_onbenable(struct stlibrd *brdp)
 {       
         outb((brdp->enabval | ONB_ATENABLE), (brdp->iobase + ONB_ATCONFR));
 }
 
 /*****************************************************************************/
 
-static void stli_onbdisable(stlibrd_t *brdp)
+static void stli_onbdisable(struct stlibrd *brdp)
 {       
         outb((brdp->enabval | ONB_ATDISABLE), (brdp->iobase + ONB_ATCONFR));
 }
 
 /*****************************************************************************/
 
-static char *stli_onbgetmemptr(stlibrd_t *brdp, unsigned long offset, int line)
+static void __iomem *stli_onbgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
 {       
-        void    *ptr;
+        void __iomem *ptr;
 
         if (offset > brdp->memsize) {
                 printk(KERN_ERR "STALLION: shared memory pointer=%x out of "
@@ -3220,7 +3046,7 @@ static char *stli_onbgetmemptr(stlibrd_t *brdp, unsigned long offset, int line)
 
 /*****************************************************************************/
 
-static void stli_onbreset(stlibrd_t *brdp)
+static void stli_onbreset(struct stlibrd *brdp)
 {       
         outb(ONB_ATSTOP, (brdp->iobase + ONB_ATCONFR));
         udelay(10);
@@ -3234,7 +3060,7 @@ static void stli_onbreset(stlibrd_t *brdp)
  *      The following routines act on ONboard EISA.
  */
 
-static void stli_onbeinit(stlibrd_t *brdp)
+static void stli_onbeinit(struct stlibrd *brdp)
 {
         unsigned long   memconf;
 
@@ -3254,23 +3080,23 @@ static void stli_onbeinit(stlibrd_t *brdp)
 
 /*****************************************************************************/
 
-static void stli_onbeenable(stlibrd_t *brdp)
+static void stli_onbeenable(struct stlibrd *brdp)
 {       
         outb(ONB_EIENABLE, (brdp->iobase + ONB_EICONFR));
 }
 
 /*****************************************************************************/
 
-static void stli_onbedisable(stlibrd_t *brdp)
+static void stli_onbedisable(struct stlibrd *brdp)
 {       
         outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR));
 }
 
 /*****************************************************************************/
 
-static char *stli_onbegetmemptr(stlibrd_t *brdp, unsigned long offset, int line)
+static void __iomem *stli_onbegetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
 {       
-        void *ptr;
+        void __iomem *ptr;
         unsigned char val;
 
         if (offset > brdp->memsize) {
@@ -3292,7 +3118,7 @@ static char *stli_onbegetmemptr(stlibrd_t *brdp, unsigned long offset, int line)
 
 /*****************************************************************************/
 
-static void stli_onbereset(stlibrd_t *brdp)
+static void stli_onbereset(struct stlibrd *brdp)
 {       
         outb(ONB_EISTOP, (brdp->iobase + ONB_EICONFR));
         udelay(10);
@@ -3306,7 +3132,7 @@ static void stli_onbereset(stlibrd_t *brdp)
  *      The following routines act on Brumby boards.
  */
 
-static void stli_bbyinit(stlibrd_t *brdp)
+static void stli_bbyinit(struct stlibrd *brdp)
 {
         outb(BBY_ATSTOP, (brdp->iobase + BBY_ATCONFR));
         udelay(10);
@@ -3318,9 +3144,9 @@ static void stli_bbyinit(stlibrd_t *brdp)
 
 /*****************************************************************************/
 
-static char *stli_bbygetmemptr(stlibrd_t *brdp, unsigned long offset, int line)
+static void __iomem *stli_bbygetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
 {       
-        void *ptr;
+        void __iomem *ptr;
         unsigned char val;
 
         BUG_ON(offset > brdp->memsize);
@@ -3333,7 +3159,7 @@ static char *stli_bbygetmemptr(stlibrd_t *brdp, unsigned long offset, int line)
 
 /*****************************************************************************/
 
-static void stli_bbyreset(stlibrd_t *brdp)
+static void stli_bbyreset(struct stlibrd *brdp)
 {       
         outb(BBY_ATSTOP, (brdp->iobase + BBY_ATCONFR));
         udelay(10);
@@ -3347,7 +3173,7 @@ static void stli_bbyreset(stlibrd_t *brdp)
  *      The following routines act on original old Stallion boards.
  */
 
-static void stli_stalinit(stlibrd_t *brdp)
+static void stli_stalinit(struct stlibrd *brdp)
 {
         outb(0x1, brdp->iobase);
         mdelay(1000);
@@ -3355,7 +3181,7 @@ static void stli_stalinit(stlibrd_t *brdp)
 
 /*****************************************************************************/
 
-static char *stli_stalgetmemptr(stlibrd_t *brdp, unsigned long offset, int line)
+static void __iomem *stli_stalgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
 {       
         BUG_ON(offset > brdp->memsize);
         return brdp->membase + (offset % STAL_PAGESIZE);
@@ -3363,7 +3189,7 @@ static char *stli_stalgetmemptr(stlibrd_t *brdp, unsigned long offset, int line)
 
 /*****************************************************************************/
 
-static void stli_stalreset(stlibrd_t *brdp)
+static void stli_stalreset(struct stlibrd *brdp)
 {       
         u32 __iomem *vecp;
 
@@ -3380,21 +3206,22 @@ static void stli_stalreset(stlibrd_t *brdp)
  *      board types.
  */
 
-static int stli_initecp(stlibrd_t *brdp)
+static int stli_initecp(struct stlibrd *brdp)
 {
         cdkecpsig_t sig;
         cdkecpsig_t __iomem *sigsp;
         unsigned int status, nxtid;
         char *name;
-        int panelnr, nrports;
+        int retval, panelnr, nrports;
 
-        if (!request_region(brdp->iobase, brdp->iosize, "istallion"))
-                return -EIO;
-        
-        if ((brdp->iobase == 0) || (brdp->memaddr == 0))
-        {
-                release_region(brdp->iobase, brdp->iosize);
-                return -ENODEV;
+        if ((brdp->iobase == 0) || (brdp->memaddr == 0)) {
+                retval = -ENODEV;
+                goto err;
+        }
+
+        if (!request_region(brdp->iobase, brdp->iosize, "istallion")) {
+                retval = -EIO;
+                goto err;
         }
 
         brdp->iosize = ECP_IOSIZE;
@@ -3406,7 +3233,6 @@ static int stli_initecp(stlibrd_t *brdp)
  */
         switch (brdp->brdtype) {
         case BRD_ECP:
-                brdp->membase = (void *) brdp->memaddr;
                 brdp->memsize = ECP_MEMSIZE;
                 brdp->pagesize = ECP_ATPAGESIZE;
                 brdp->init = stli_ecpinit;
@@ -3420,7 +3246,6 @@ static int stli_initecp(stlibrd_t *brdp)
                 break;
 
         case BRD_ECPE:
-                brdp->membase = (void *) brdp->memaddr;
                 brdp->memsize = ECP_MEMSIZE;
                 brdp->pagesize = ECP_EIPAGESIZE;
                 brdp->init = stli_ecpeiinit;
@@ -3434,7 +3259,6 @@ static int stli_initecp(stlibrd_t *brdp)
                 break;
 
         case BRD_ECPMC:
-                brdp->membase = (void *) brdp->memaddr;
                 brdp->memsize = ECP_MEMSIZE;
                 brdp->pagesize = ECP_MCPAGESIZE;
                 brdp->init = NULL;
@@ -3448,7 +3272,6 @@ static int stli_initecp(stlibrd_t *brdp)
                 break;
 
         case BRD_ECPPCI:
-                brdp->membase = (void *) brdp->memaddr;
                 brdp->memsize = ECP_PCIMEMSIZE;
                 brdp->pagesize = ECP_PCIPAGESIZE;
                 brdp->init = stli_ecppciinit;
@@ -3462,8 +3285,8 @@ static int stli_initecp(stlibrd_t *brdp)
                 break;
 
         default:
-                release_region(brdp->iobase, brdp->iosize);
-                return -EINVAL;
+                retval = -EINVAL;
+                goto err_reg;
         }
 
 /*
@@ -3475,10 +3298,9 @@ static int stli_initecp(stlibrd_t *brdp)
         EBRDINIT(brdp);
 
         brdp->membase = ioremap(brdp->memaddr, brdp->memsize);
-        if (brdp->membase == NULL)
-        {
-                release_region(brdp->iobase, brdp->iosize);
-                return -ENOMEM;
+        if (brdp->membase == NULL) {
+                retval = -ENOMEM;
+                goto err_reg;
         }
 
 /*
@@ -3491,10 +3313,9 @@ static int stli_initecp(stlibrd_t *brdp)
         memcpy_fromio(&sig, sigsp, sizeof(cdkecpsig_t));
         EBRDDISABLE(brdp);
 
-        if (sig.magic != cpu_to_le32(ECP_MAGIC))
-        {
-                release_region(brdp->iobase, brdp->iosize);
-                return -ENODEV;
+        if (sig.magic != cpu_to_le32(ECP_MAGIC)) {
+                retval = -ENODEV;
+                goto err_unmap;
         }
 
 /*
@@ -3519,6 +3340,13 @@ static int stli_initecp(stlibrd_t *brdp)
 
         brdp->state |= BST_FOUND;
         return 0;
+err_unmap:
+        iounmap(brdp->membase);
+        brdp->membase = NULL;
+err_reg:
+        release_region(brdp->iobase, brdp->iosize);
+err:
+        return retval;
 }
 
 /*****************************************************************************/
@@ -3528,23 +3356,27 @@ static int stli_initecp(stlibrd_t *brdp)
  *      This handles only these board types.
  */
 
-static int stli_initonb(stlibrd_t *brdp)
+static int stli_initonb(struct stlibrd *brdp)
 {
         cdkonbsig_t sig;
         cdkonbsig_t __iomem *sigsp;
         char *name;
-        int i;
+        int i, retval;
 
 /*
  *      Do a basic sanity check on the IO and memory addresses.
  */
-        if (brdp->iobase == 0 || brdp->memaddr == 0)
-                return -ENODEV;
+        if (brdp->iobase == 0 || brdp->memaddr == 0) {
+                retval = -ENODEV;
+                goto err;
+        }
 
         brdp->iosize = ONB_IOSIZE;
         
-        if (!request_region(brdp->iobase, brdp->iosize, "istallion"))
-                return -EIO;
+        if (!request_region(brdp->iobase, brdp->iosize, "istallion")) {
+                retval = -EIO;
+                goto err;
+        }
 
 /*
  *      Based on the specific board type setup the common vars to access
@@ -3553,10 +3385,7 @@ static int stli_initonb(stlibrd_t *brdp)
  */
         switch (brdp->brdtype) {
         case BRD_ONBOARD:
-        case BRD_ONBOARD32:
         case BRD_ONBOARD2:
-        case BRD_ONBOARD2_32:
-        case BRD_ONBOARDRS:
                 brdp->memsize = ONB_MEMSIZE;
                 brdp->pagesize = ONB_ATPAGESIZE;
                 brdp->init = stli_onbinit;
@@ -3587,8 +3416,6 @@ static int stli_initonb(stlibrd_t *brdp)
                 break;
 
         case BRD_BRUMBY4:
-        case BRD_BRUMBY8:
-        case BRD_BRUMBY16:
                 brdp->memsize = BBY_MEMSIZE;
                 brdp->pagesize = BBY_PAGESIZE;
                 brdp->init = stli_bbyinit;
@@ -3615,8 +3442,8 @@ static int stli_initonb(stlibrd_t *brdp)
                 break;
 
         default:
-                release_region(brdp->iobase, brdp->iosize);
-                return -EINVAL;
+                retval = -EINVAL;
+                goto err_reg;
         }
 
 /*
@@ -3628,10 +3455,9 @@ static int stli_initonb(stlibrd_t *brdp)
         EBRDINIT(brdp);
 
         brdp->membase = ioremap(brdp->memaddr, brdp->memsize);
-        if (brdp->membase == NULL)
-        {
-                release_region(brdp->iobase, brdp->iosize);
-                return -ENOMEM;
+        if (brdp->membase == NULL) {
+                retval = -ENOMEM;
+                goto err_reg;
         }
 
 /*
@@ -3647,10 +3473,9 @@ static int stli_initonb(stlibrd_t *brdp)
         if (sig.magic0 != cpu_to_le16(ONB_MAGIC0) ||
             sig.magic1 != cpu_to_le16(ONB_MAGIC1) ||
             sig.magic2 != cpu_to_le16(ONB_MAGIC2) ||
-            sig.magic3 != cpu_to_le16(ONB_MAGIC3))
-        {
-                release_region(brdp->iobase, brdp->iosize);
-                return -ENODEV;
+            sig.magic3 != cpu_to_le16(ONB_MAGIC3)) {
+                retval = -ENODEV;
+                goto err_unmap;
         }
 
 /*
@@ -3672,6 +3497,13 @@ static int stli_initonb(stlibrd_t *brdp)
 
         brdp->state |= BST_FOUND;
         return 0;
+err_unmap:
+        iounmap(brdp->membase);
+        brdp->membase = NULL;
+err_reg:
+        release_region(brdp->iobase, brdp->iosize);
+err:
+        return retval;
 }
 
 /*****************************************************************************/
@@ -3682,14 +3514,15 @@ static int stli_initonb(stlibrd_t *brdp)
  *      read in the memory map, and get the show on the road...
  */
 
-static int stli_startbrd(stlibrd_t *brdp)
+static int stli_startbrd(struct stlibrd *brdp)
 {
         cdkhdr_t __iomem *hdrp;
         cdkmem_t __iomem *memp;
         cdkasy_t __iomem *ap;
         unsigned long flags;
-        stliport_t *portp;
-        int portnr, nrdevs, i, rc = 0;
+        unsigned int portnr, nrdevs, i;
+        struct stliport *portp;
+        int rc = 0;
         u32 memoff;
 
         spin_lock_irqsave(&brd_lock, flags);
@@ -3776,8 +3609,7 @@ stli_donestartup:
 
         if (! stli_timeron) {
                 stli_timeron++;
-                stli_timerlist.expires = STLI_TIMEOUT;
-                add_timer(&stli_timerlist);
+                mod_timer(&stli_timerlist, STLI_TIMEOUT);
         }
 
         return rc;
@@ -3789,49 +3621,32 @@ stli_donestartup:
  *      Probe and initialize the specified board.
  */
 
-static int __init stli_brdinit(stlibrd_t *brdp)
+static int __devinit stli_brdinit(struct stlibrd *brdp)
 {
-        stli_brds[brdp->brdnr] = brdp;
+        int retval;
 
         switch (brdp->brdtype) {
         case BRD_ECP:
         case BRD_ECPE:
         case BRD_ECPMC:
         case BRD_ECPPCI:
-                stli_initecp(brdp);
+                retval = stli_initecp(brdp);
                 break;
         case BRD_ONBOARD:
         case BRD_ONBOARDE:
         case BRD_ONBOARD2:
-        case BRD_ONBOARD32:
-        case BRD_ONBOARD2_32:
-        case BRD_ONBOARDRS:
         case BRD_BRUMBY4:
-        case BRD_BRUMBY8:
-        case BRD_BRUMBY16:
         case BRD_STALLION:
-                stli_initonb(brdp);
+                retval = stli_initonb(brdp);
                 break;
-        case BRD_EASYIO:
-        case BRD_ECH:
-        case BRD_ECHMC:
-        case BRD_ECHPCI:
-                printk(KERN_ERR "STALLION: %s board type not supported in "
-                                "this driver\n", stli_brdnames[brdp->brdtype]);
-                return -ENODEV;
         default:
                 printk(KERN_ERR "STALLION: board=%d is unknown board "
                                 "type=%d\n", brdp->brdnr, brdp->brdtype);
-                return -ENODEV;
+                retval = -ENODEV;
         }
 
-        if ((brdp->state & BST_FOUND) == 0) {
-                printk(KERN_ERR "STALLION: %s board not found, board=%d "
-                                "io=%x mem=%x\n",
-                        stli_brdnames[brdp->brdtype], brdp->brdnr,
-                        brdp->iobase, (int) brdp->memaddr);
-                return -ENODEV;
-        }
+        if (retval)
+                return retval;
 
         stli_initports(brdp);
         printk(KERN_INFO "STALLION: %s found, board=%d io=%x mem=%x "
@@ -3841,6 +3656,7 @@ static int __init stli_brdinit(stlibrd_t *brdp)
         return 0;
 }
 
+#if STLI_EISAPROBE != 0
 /*****************************************************************************/
 
 /*
@@ -3848,7 +3664,7 @@ static int __init stli_brdinit(stlibrd_t *brdp)
  *      might be. This is a bit if hack, but it is the best we can do.
  */
 
-static int stli_eisamemprobe(stlibrd_t *brdp)
+static int stli_eisamemprobe(struct stlibrd *brdp)
 {
         cdkecpsig_t     ecpsig, __iomem *ecpsigp;
         cdkonbsig_t     onbsig, __iomem *onbsigp;
@@ -3894,7 +3710,7 @@ static int stli_eisamemprobe(stlibrd_t *brdp)
                         continue;
 
                 if (brdp->brdtype == BRD_ECPE) {
-                        ecpsigp = (cdkecpsig_t __iomem *) stli_ecpeigetmemptr(brdp,
+                        ecpsigp = stli_ecpeigetmemptr(brdp,
                                 CDK_SIGADDR, __LINE__);
                         memcpy_fromio(&ecpsig, ecpsigp, sizeof(cdkecpsig_t));
                         if (ecpsig.magic == cpu_to_le32(ECP_MAGIC))
@@ -3934,10 +3750,11 @@ static int stli_eisamemprobe(stlibrd_t *brdp)
         }
         return 0;
 }
+#endif
 
 static int stli_getbrdnr(void)
 {
-        int i;
+        unsigned int i;
 
         for (i = 0; i < STL_MAXBRDS; i++) {
                 if (!stli_brds[i]) {
@@ -3949,6 +3766,7 @@ static int stli_getbrdnr(void)
         return -1;
 }
 
+#if STLI_EISAPROBE != 0
 /*****************************************************************************/
 
 /*
@@ -3963,9 +3781,9 @@ static int stli_getbrdnr(void)
 
 static int stli_findeisabrds(void)
 {
-        stlibrd_t *brdp;
-        unsigned int iobase, eid;
-        int i;
+        struct stlibrd *brdp;
+        unsigned int iobase, eid, i;
+        int brdnr, found = 0;
 
 /*
  *      Firstly check if this is an EISA system.  If this is not an EISA system then
@@ -4003,9 +3821,11 @@ static int stli_findeisabrds(void)
  *              Allocate a board structure and initialize it.
  */
                 if ((brdp = stli_allocbrd()) == NULL)
-                        return -ENOMEM;
-                if ((brdp->brdnr = stli_getbrdnr()) < 0)
-                        return -ENOMEM;
+                        return found ? : -ENOMEM;
+                brdnr = stli_getbrdnr();
+                if (brdnr < 0)
+                        return found ? : -ENOMEM;
+                brdp->brdnr = (unsigned int)brdnr;
                 eid = inb(iobase + 0xc82);
                 if (eid == ECP_EISAID)
                         brdp->brdtype = BRD_ECPE;
@@ -4017,11 +3837,24 @@ static int stli_findeisabrds(void)
                 outb(0x1, (iobase + 0xc84));
                 if (stli_eisamemprobe(brdp))
                         outb(0, (iobase + 0xc84));
-                stli_brdinit(brdp);
+                if (stli_brdinit(brdp) < 0) {
+                        kfree(brdp);
+                        continue;
+                }
+
+                stli_brds[brdp->brdnr] = brdp;
+                found++;
+
+                for (i = 0; i < brdp->nrports; i++)
+                        tty_register_device(stli_serial,
+                                        brdp->brdnr * STL_MAXPORTS + i, NULL);
         }
 
-        return 0;
+        return found;
 }
+#else
+static inline int stli_findeisabrds(void) { return 0; }
+#endif
 
 /*****************************************************************************/
 
@@ -4031,72 +3864,104 @@ static int stli_findeisabrds(void)
 
 /*****************************************************************************/
 
-#ifdef  CONFIG_PCI
-
 /*
  *      We have a Stallion board. Allocate a board structure and
  *      initialize it. Read its IO and MEMORY resources from PCI
  *      configuration space.
  */
 
-static int stli_initpcibrd(int brdtype, struct pci_dev *devp)
+static int __devinit stli_pciprobe(struct pci_dev *pdev,
+                const struct pci_device_id *ent)
 {
-        stlibrd_t *brdp;
-
-        if (pci_enable_device(devp))
-                return -EIO;
-        if ((brdp = stli_allocbrd()) == NULL)
-                return -ENOMEM;
-        if ((brdp->brdnr = stli_getbrdnr()) < 0) {
+        struct stlibrd *brdp;
+        unsigned int i;
+        int brdnr, retval = -EIO;
+
+        retval = pci_enable_device(pdev);
+        if (retval)
+                goto err;
+        brdp = stli_allocbrd();
+        if (brdp == NULL) {
+                retval = -ENOMEM;
+                goto err;
+        }
+        mutex_lock(&stli_brdslock);
+        brdnr = stli_getbrdnr();
+        if (brdnr < 0) {
                 printk(KERN_INFO "STALLION: too many boards found, "
                         "maximum supported %d\n", STL_MAXBRDS);
-                return 0;
+                mutex_unlock(&stli_brdslock);
+                retval = -EIO;
+                goto err_fr;
         }
-        brdp->brdtype = brdtype;
+        brdp->brdnr = (unsigned int)brdnr;
+        stli_brds[brdp->brdnr] = brdp;
+        mutex_unlock(&stli_brdslock);
+        brdp->brdtype = BRD_ECPPCI;
 /*
  *      We have all resources from the board, so lets setup the actual
  *      board structure now.
  */
-        brdp->iobase = pci_resource_start(devp, 3);
-        brdp->memaddr = pci_resource_start(devp, 2);
-        stli_brdinit(brdp);
+        brdp->iobase = pci_resource_start(pdev, 3);
+        brdp->memaddr = pci_resource_start(pdev, 2);
+        retval = stli_brdinit(brdp);
+        if (retval)
+                goto err_null;
+
+        brdp->state |= BST_PROBED;
+        pci_set_drvdata(pdev, brdp);
+
+        EBRDENABLE(brdp);
+        brdp->enable = NULL;
+        brdp->disable = NULL;
+
+        for (i = 0; i < brdp->nrports; i++)
+                tty_register_device(stli_serial, brdp->brdnr * STL_MAXPORTS + i,
+                                &pdev->dev);
 
         return 0;
+err_null:
+        stli_brds[brdp->brdnr] = NULL;
+err_fr:
+        kfree(brdp);
+err:
+        return retval;
 }
 
-/*****************************************************************************/
+static void stli_pciremove(struct pci_dev *pdev)
+{
+        struct stlibrd *brdp = pci_get_drvdata(pdev);
 
-/*
- *      Find all Stallion PCI boards that might be installed. Initialize each
- *      one as it is found.
- */
+        stli_cleanup_ports(brdp);
 
-static int stli_findpcibrds(void)
-{
-        struct pci_dev *dev = NULL;
+        iounmap(brdp->membase);
+        if (brdp->iosize > 0)
+                release_region(brdp->iobase, brdp->iosize);
 
-        while ((dev = pci_get_device(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_ECRA, dev))) {
-                stli_initpcibrd(BRD_ECPPCI, dev);
-        }
-        return 0;
+        stli_brds[brdp->brdnr] = NULL;
+        kfree(brdp);
 }
 
-#endif
-
+static struct pci_driver stli_pcidriver = {
+        .name = "istallion",
+        .id_table = istallion_pci_tbl,
+        .probe = stli_pciprobe,
+        .remove = __devexit_p(stli_pciremove)
+};
 /*****************************************************************************/
 
 /*
  *      Allocate a new board structure. Fill out the basic info in it.
  */
 
-static stlibrd_t *stli_allocbrd(void)
+static struct stlibrd *stli_allocbrd(void)
 {
-        stlibrd_t *brdp;
+        struct stlibrd *brdp;
 
-        brdp = kzalloc(sizeof(stlibrd_t), GFP_KERNEL);
+        brdp = kzalloc(sizeof(struct stlibrd), GFP_KERNEL);
         if (!brdp) {
                 printk(KERN_ERR "STALLION: failed to allocate memory "
-                                "(size=%Zd)\n", sizeof(stlibrd_t));
+                                "(size=%Zd)\n", sizeof(struct stlibrd));
                 return NULL;
         }
         brdp->magic = STLI_BOARDMAGIC;
@@ -4112,43 +3977,37 @@ static stlibrd_t *stli_allocbrd(void)
 
 static int stli_initbrds(void)
 {
-        stlibrd_t *brdp, *nxtbrdp;
-        stlconf_t *confp;
-        int i, j;
-
-        if (stli_nrbrds > STL_MAXBRDS) {
-                printk(KERN_INFO "STALLION: too many boards in configuration "
-                        "table, truncating to %d\n", STL_MAXBRDS);
-                stli_nrbrds = STL_MAXBRDS;
-        }
+        struct stlibrd *brdp, *nxtbrdp;
+        struct stlconf conf;
+        unsigned int i, j, found = 0;
+        int retval;
 
-/*
- *      Firstly scan the list of static boards configured. Allocate
- *      resources and initialize the boards as found. If this is a
- *      module then let the module args override static configuration.
- */
-        for (i = 0; (i < stli_nrbrds); i++) {
-                confp = &stli_brdconf[i];
-                stli_parsebrd(confp, stli_brdsp[i]);
+        for (stli_nrbrds = 0; stli_nrbrds < ARRAY_SIZE(stli_brdsp);
+                        stli_nrbrds++) {
+                memset(&conf, 0, sizeof(conf));
+                if (stli_parsebrd(&conf, stli_brdsp[stli_nrbrds]) == 0)
+                        continue;
                 if ((brdp = stli_allocbrd()) == NULL)
-                        return -ENOMEM;
-                brdp->brdnr = i;
-                brdp->brdtype = confp->brdtype;
-                brdp->iobase = confp->ioaddr1;
-                brdp->memaddr = confp->memaddr;
-                stli_brdinit(brdp);
+                        continue;
+                brdp->brdnr = stli_nrbrds;
+                brdp->brdtype = conf.brdtype;
+                brdp->iobase = conf.ioaddr1;
+                brdp->memaddr = conf.memaddr;
+                if (stli_brdinit(brdp) < 0) {
+                        kfree(brdp);
+                        continue;
+                }
+                stli_brds[brdp->brdnr] = brdp;
+                found++;
+
+                for (i = 0; i < brdp->nrports; i++)
+                        tty_register_device(stli_serial,
+                                        brdp->brdnr * STL_MAXPORTS + i, NULL);
         }
 
-/*
- *      Static configuration table done, so now use dynamic methods to
- *      see if any more boards should be configured.
- */
-        stli_argbrds();
-        if (STLI_EISAPROBE)
-                stli_findeisabrds();
-#ifdef CONFIG_PCI
-        stli_findpcibrds();
-#endif
+        retval = stli_findeisabrds();
+        if (retval > 0)
+                found += retval;
 
 /*
  *      All found boards are initialized. Now for a little optimization, if
@@ -4188,7 +4047,16 @@ static int stli_initbrds(void)
                 }
         }
 
+        retval = pci_register_driver(&stli_pcidriver);
+        if (retval && found == 0) {
+                printk(KERN_ERR "Neither isa nor eisa cards found nor pci "
+                                "driver can be registered!\n");
+                goto err;
+        }
+
         return 0;
+err:
+        return retval;
 }
 
 /*****************************************************************************/
@@ -4202,13 +4070,14 @@ static int stli_initbrds(void)
 static ssize_t stli_memread(struct file *fp, char __user *buf, size_t count, loff_t *offp)
 {
         unsigned long flags;
-        void *memptr;
-        stlibrd_t *brdp;
-        int brdnr, size, n;
+        void __iomem *memptr;
+        struct stlibrd *brdp;
+        unsigned int brdnr;
+        int size, n;
         void *p;
         loff_t off = *offp;
 
-        brdnr = iminor(fp->f_dentry->d_inode);
+        brdnr = iminor(fp->f_path.dentry->d_inode);
         if (brdnr >= stli_nrbrds)
                 return -ENODEV;
         brdp = stli_brds[brdnr];
@@ -4219,7 +4088,7 @@ static ssize_t stli_memread(struct file *fp, char __user *buf, size_t count, lof
         if (off >= brdp->memsize || off + count < off)
                 return 0;
 
-        size = MIN(count, (brdp->memsize - off));
+        size = min(count, (size_t)(brdp->memsize - off));
 
         /*
          *      Copy the data a page at a time
@@ -4232,9 +4101,9 @@ static ssize_t stli_memread(struct file *fp, char __user *buf, size_t count, lof
         while (size > 0) {
                 spin_lock_irqsave(&brd_lock, flags);
                 EBRDENABLE(brdp);
-                memptr = (void *) EBRDGETMEMPTR(brdp, off);
-                n = MIN(size, (brdp->pagesize - (((unsigned long) off) % brdp->pagesize)));
-                n = MIN(n, PAGE_SIZE);
+                memptr = EBRDGETMEMPTR(brdp, off);
+                n = min(size, (int)(brdp->pagesize - (((unsigned long) off) % brdp->pagesize)));
+                n = min(n, (int)PAGE_SIZE);
                 memcpy_fromio(p, memptr, n);
                 EBRDDISABLE(brdp);
                 spin_unlock_irqrestore(&brd_lock, flags);
@@ -4265,14 +4134,15 @@ out:
 static ssize_t stli_memwrite(struct file *fp, const char __user *buf, size_t count, loff_t *offp)
 {
         unsigned long flags;
-        void *memptr;
-        stlibrd_t *brdp;
+        void __iomem *memptr;
+        struct stlibrd *brdp;
         char __user *chbuf;
-        int brdnr, size, n;
+        unsigned int brdnr;
+        int size, n;
         void *p;
         loff_t off = *offp;
 
-        brdnr = iminor(fp->f_dentry->d_inode);
+        brdnr = iminor(fp->f_path.dentry->d_inode);
 
         if (brdnr >= stli_nrbrds)
                 return -ENODEV;
@@ -4285,7 +4155,7 @@ static ssize_t stli_memwrite(struct file *fp, const char __user *buf, size_t cou
                 return 0;
 
         chbuf = (char __user *) buf;
-        size = MIN(count, (brdp->memsize - off));
+        size = min(count, (size_t)(brdp->memsize - off));
 
         /*
          *      Copy the data a page at a time
@@ -4296,8 +4166,8 @@ static ssize_t stli_memwrite(struct file *fp, const char __user *buf, size_t cou
                 return -ENOMEM;
 
         while (size > 0) {
-                n = MIN(size, (brdp->pagesize - (((unsigned long) off) % brdp->pagesize)));
-                n = MIN(n, PAGE_SIZE);
+                n = min(size, (int)(brdp->pagesize - (((unsigned long) off) % brdp->pagesize)));
+                n = min(n, (int)PAGE_SIZE);
                 if (copy_from_user(p, chbuf, n)) {
                         if (count == 0)
                                 count = -EFAULT;
@@ -4305,7 +4175,7 @@ static ssize_t stli_memwrite(struct file *fp, const char __user *buf, size_t cou
                 }
                 spin_lock_irqsave(&brd_lock, flags);
                 EBRDENABLE(brdp);
-                memptr = (void *) EBRDGETMEMPTR(brdp, off);
+                memptr = EBRDGETMEMPTR(brdp, off);
                 memcpy_toio(memptr, p, n);
                 EBRDDISABLE(brdp);
                 spin_unlock_irqrestore(&brd_lock, flags);
@@ -4327,8 +4197,8 @@ out:
 
 static int stli_getbrdstats(combrd_t __user *bp)
 {
-        stlibrd_t *brdp;
-        int i;
+        struct stlibrd *brdp;
+        unsigned int i;
 
         if (copy_from_user(&stli_brdstats, bp, sizeof(combrd_t)))
                 return -EFAULT;
@@ -4364,19 +4234,20 @@ static int stli_getbrdstats(combrd_t __user *bp)
  *      Resolve the referenced port number into a port struct pointer.
  */
 
-static stliport_t *stli_getport(int brdnr, int panelnr, int portnr)
+static struct stliport *stli_getport(unsigned int brdnr, unsigned int panelnr,
+                unsigned int portnr)
 {
-        stlibrd_t *brdp;
-        int i;
+        struct stlibrd *brdp;
+        unsigned int i;
 
-        if (brdnr < 0 || brdnr >= STL_MAXBRDS)
+        if (brdnr >= STL_MAXBRDS)
                 return NULL;
         brdp = stli_brds[brdnr];
         if (brdp == NULL)
                 return NULL;
         for (i = 0; (i < panelnr); i++)
                 portnr += brdp->panels[i];
-        if ((portnr < 0) || (portnr >= brdp->nrports))
+        if (portnr >= brdp->nrports)
                 return NULL;
         return brdp->ports[portnr];
 }
@@ -4389,10 +4260,10 @@ static stliport_t *stli_getport(int brdnr, int panelnr, int portnr)
  *      what port to get stats for (used through board control device).
  */
 
-static int stli_portcmdstats(stliport_t *portp)
+static int stli_portcmdstats(struct stliport *portp)
 {
         unsigned long   flags;
-        stlibrd_t       *brdp;
+        struct stlibrd  *brdp;
         int             rc;
 
         memset(&stli_comstats, 0, sizeof(comstats_t));
@@ -4463,9 +4334,9 @@ static int stli_portcmdstats(stliport_t *portp)
  *      what port to get stats for (used through board control device).
  */
 
-static int stli_getportstats(stliport_t *portp, comstats_t __user *cp)
+static int stli_getportstats(struct stliport *portp, comstats_t __user *cp)
 {
-        stlibrd_t *brdp;
+        struct stlibrd *brdp;
         int rc;
 
         if (!portp) {
@@ -4494,9 +4365,9 @@ static int stli_getportstats(stliport_t *portp, comstats_t __user *cp)
  *      Clear the port stats structure. We also return it zeroed out...
  */
 
-static int stli_clrportstats(stliport_t *portp, comstats_t __user *cp)
+static int stli_clrportstats(struct stliport *portp, comstats_t __user *cp)
 {
-        stlibrd_t *brdp;
+        struct stlibrd *brdp;
         int rc;
 
         if (!portp) {
@@ -4533,17 +4404,18 @@ static int stli_clrportstats(stliport_t *portp, comstats_t __user *cp)
  *      Return the entire driver ports structure to a user app.
  */
 
-static int stli_getportstruct(stliport_t __user *arg)
+static int stli_getportstruct(struct stliport __user *arg)
 {
-        stliport_t *portp;
+        struct stliport stli_dummyport;
+        struct stliport *portp;
 
-        if (copy_from_user(&stli_dummyport, arg, sizeof(stliport_t)))
+        if (copy_from_user(&stli_dummyport, arg, sizeof(struct stliport)))
                 return -EFAULT;
         portp = stli_getport(stli_dummyport.brdnr, stli_dummyport.panelnr,
                  stli_dummyport.portnr);
         if (!portp)
                 return -ENODEV;
-        if (copy_to_user(arg, portp, sizeof(stliport_t)))
+        if (copy_to_user(arg, portp, sizeof(struct stliport)))
                 return -EFAULT;
         return 0;
 }
@@ -4554,18 +4426,19 @@ static int stli_getportstruct(stliport_t __user *arg)
  *      Return the entire driver board structure to a user app.
  */
 
-static int stli_getbrdstruct(stlibrd_t __user *arg)
+static int stli_getbrdstruct(struct stlibrd __user *arg)
 {
-        stlibrd_t *brdp;
+        struct stlibrd stli_dummybrd;
+        struct stlibrd *brdp;
 
-        if (copy_from_user(&stli_dummybrd, arg, sizeof(stlibrd_t)))
+        if (copy_from_user(&stli_dummybrd, arg, sizeof(struct stlibrd)))
                 return -EFAULT;
-        if ((stli_dummybrd.brdnr < 0) || (stli_dummybrd.brdnr >= STL_MAXBRDS))
+        if (stli_dummybrd.brdnr >= STL_MAXBRDS)
                 return -ENODEV;
         brdp = stli_brds[stli_dummybrd.brdnr];
         if (!brdp)
                 return -ENODEV;
-        if (copy_to_user(arg, brdp, sizeof(stlibrd_t)))
+        if (copy_to_user(arg, brdp, sizeof(struct stlibrd)))
                 return -EFAULT;
         return 0;
 }
@@ -4580,7 +4453,7 @@ static int stli_getbrdstruct(stlibrd_t __user *arg)
 
 static int stli_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg)
 {
-        stlibrd_t *brdp;
+        struct stlibrd *brdp;
         int brdnr, rc, done;
         void __user *argp = (void __user *)arg;
 
@@ -4654,7 +4527,7 @@ static int stli_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, un
         return rc;
 }
 
-static struct tty_operations stli_ops = {
+static const struct tty_operations stli_ops = {
         .open = stli_open,
         .close = stli_close,
         .write = stli_write,
@@ -4679,46 +4552,53 @@ static struct tty_operations stli_ops = {
 };
 
 /*****************************************************************************/
+/*
+ *      Loadable module initialization stuff.
+ */
+
+static void istallion_cleanup_isa(void)
+{
+        struct stlibrd  *brdp;
+        unsigned int j;
 
-static int __init stli_init(void)
+        for (j = 0; (j < stli_nrbrds); j++) {
+                if ((brdp = stli_brds[j]) == NULL || (brdp->state & BST_PROBED))
+                        continue;
+
+                stli_cleanup_ports(brdp);
+
+                iounmap(brdp->membase);
+                if (brdp->iosize > 0)
+                        release_region(brdp->iobase, brdp->iosize);
+                kfree(brdp);
+                stli_brds[j] = NULL;
+        }
+}
+
+static int __init istallion_module_init(void)
 {
-        int i;
+        unsigned int i;
+        int retval;
+
         printk(KERN_INFO "%s: version %s\n", stli_drvtitle, stli_drvversion);
 
         spin_lock_init(&stli_lock);
         spin_lock_init(&brd_lock);
 
-        stli_initbrds();
-
-        stli_serial = alloc_tty_driver(STL_MAXBRDS * STL_MAXPORTS);
-        if (!stli_serial)
-                return -ENOMEM;
-
-/*
- *      Allocate a temporary write buffer.
- */
         stli_txcookbuf = kmalloc(STLI_TXBUFSIZE, GFP_KERNEL);
-        if (!stli_txcookbuf)
+        if (!stli_txcookbuf) {
                 printk(KERN_ERR "STALLION: failed to allocate memory "
                                 "(size=%d)\n", STLI_TXBUFSIZE);
+                retval = -ENOMEM;
+                goto err;
+        }
 
-/*
- *      Set up a character driver for the shared memory region. We need this
- *      to down load the slave code image. Also it is a useful debugging tool.
- */
-        if (register_chrdev(STL_SIOMEMMAJOR, "staliomem", &stli_fsiomem))
-                printk(KERN_ERR "STALLION: failed to register serial memory "
-                                "device\n");
-
-        istallion_class = class_create(THIS_MODULE, "staliomem");
-        for (i = 0; i < 4; i++)
-                class_device_create(istallion_class, NULL,
-                                MKDEV(STL_SIOMEMMAJOR, i),
-                                NULL, "staliomem%d", i);
+        stli_serial = alloc_tty_driver(STL_MAXBRDS * STL_MAXPORTS);
+        if (!stli_serial) {
+                retval = -ENOMEM;
+                goto err_free;
+        }
 
-/*
- *      Set up the tty driver structure and register us as a driver.
- */
         stli_serial->owner = THIS_MODULE;
         stli_serial->driver_name = stli_drvname;
         stli_serial->name = stli_serialname;
@@ -4727,15 +4607,79 @@ static int __init stli_init(void)
         stli_serial->type = TTY_DRIVER_TYPE_SERIAL;
         stli_serial->subtype = SERIAL_TYPE_NORMAL;
         stli_serial->init_termios = stli_deftermios;
-        stli_serial->flags = TTY_DRIVER_REAL_RAW;
+        stli_serial->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
         tty_set_operations(stli_serial, &stli_ops);
 
-        if (tty_register_driver(stli_serial)) {
-                put_tty_driver(stli_serial);
+        retval = tty_register_driver(stli_serial);
+        if (retval) {
                 printk(KERN_ERR "STALLION: failed to register serial driver\n");
-                return -EBUSY;
+                goto err_ttyput;
         }
+
+        retval = stli_initbrds();
+        if (retval)
+                goto err_ttyunr;
+
+/*
+ *      Set up a character driver for the shared memory region. We need this
+ *      to down load the slave code image. Also it is a useful debugging tool.
+ */
+        retval = register_chrdev(STL_SIOMEMMAJOR, "staliomem", &stli_fsiomem);
+        if (retval) {
+                printk(KERN_ERR "STALLION: failed to register serial memory "
+                                "device\n");
+                goto err_deinit;
+        }
+
+        istallion_class = class_create(THIS_MODULE, "staliomem");
+        for (i = 0; i < 4; i++)
+                class_device_create(istallion_class, NULL,
+                                MKDEV(STL_SIOMEMMAJOR, i),
+                                NULL, "staliomem%d", i);
+
         return 0;
+err_deinit:
+        pci_unregister_driver(&stli_pcidriver);
+        istallion_cleanup_isa();
+err_ttyunr:
+        tty_unregister_driver(stli_serial);
+err_ttyput:
+        put_tty_driver(stli_serial);
+err_free:
+        kfree(stli_txcookbuf);
+err:
+        return retval;
 }
 
 /*****************************************************************************/
+
+static void __exit istallion_module_exit(void)
+{
+        unsigned int j;
+
+        printk(KERN_INFO "Unloading %s: version %s\n", stli_drvtitle,
+                stli_drvversion);
+
+        if (stli_timeron) {
+                stli_timeron = 0;
+                del_timer_sync(&stli_timerlist);
+        }
+
+        unregister_chrdev(STL_SIOMEMMAJOR, "staliomem");
+
+        for (j = 0; j < 4; j++)
+                class_device_destroy(istallion_class, MKDEV(STL_SIOMEMMAJOR,
+                                        j));
+        class_destroy(istallion_class);
+
+        pci_unregister_driver(&stli_pcidriver);
+        istallion_cleanup_isa();
+
+        tty_unregister_driver(stli_serial);
+        put_tty_driver(stli_serial);
+
+        kfree(stli_txcookbuf);
+}
+
+module_init(istallion_module_init);
+module_exit(istallion_module_exit);
diff --git a/drivers/char/ite_gpio.c b/drivers/char/ite_gpio.c
deleted file mode 100644
index cde562d70c4f..000000000000
--- a/drivers/char/ite_gpio.c
+++ /dev/null
@@ -1,419 +0,0 @@
-/*
- * FILE NAME ite_gpio.c
- *
- * BRIEF MODULE DESCRIPTION
- *  API for ITE GPIO device.
- *  Driver for ITE GPIO device.
- *
- *  Author: MontaVista Software, Inc.  <source@mvista.com>
- *          Hai-Pao Fan <haipao@mvista.com>
- *
- * Copyright 2001 MontaVista Software Inc.
- *
- *  This program is free software; you can redistribute  it and/or modify it
- *  under  the terms of  the GNU General  Public License as published by the
- *  Free Software Foundation;  either version 2 of the  License, or (at your
- *  option) any later version.
- *
- *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
- *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
- *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
- *  NO  EVENT  SHALL   THE AUTHOR  BE   LIABLE FOR ANY   DIRECT, INDIRECT,
- *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
- *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
- *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
- *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- *  You should have received a copy of the  GNU General Public License along
- *  with this program; if not, write  to the Free Software Foundation, Inc.,
- *  675 Mass Ave, Cambridge, MA 02139, USA.
- */
-#include <linux/module.h>
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/miscdevice.h>
-#include <linux/init.h>
-#include <linux/ioport.h>
-#include <asm/uaccess.h>
-#include <asm/addrspace.h>
-#include <asm/it8172/it8172_int.h>
-#include <linux/sched.h>
-#include <linux/ite_gpio.h>
-
-#define ite_gpio_base 0x14013800
-
-#define ITE_GPADR       (*(volatile __u8 *)(0x14013800 + KSEG1))
-#define ITE_GPBDR       (*(volatile __u8 *)(0x14013808 + KSEG1))
-#define ITE_GPCDR       (*(volatile __u8 *)(0x14013810 + KSEG1))
-#define ITE_GPACR       (*(volatile __u16 *)(0x14013802 + KSEG1))
-#define ITE_GPBCR       (*(volatile __u16 *)(0x1401380a + KSEG1))
-#define ITE_GPCCR       (*(volatile __u16 *)(0x14013812 + KSEG1))
-#define ITE_GPAICR      (*(volatile __u16 *)(0x14013804 + KSEG1))
-#define ITE_GPBICR      (*(volatile __u16 *)(0x1401380c + KSEG1))
-#define ITE_GPCICR      (*(volatile __u16 *)(0x14013814 + KSEG1))
-#define ITE_GPAISR      (*(volatile __u8 *)(0x14013806 + KSEG1))
-#define ITE_GPBISR      (*(volatile __u8 *)(0x1401380e + KSEG1))
-#define ITE_GPCISR      (*(volatile __u8 *)(0x14013816 + KSEG1))
-#define ITE_GCR         (*(volatile __u8 *)(0x14013818 + KSEG1))
-
-#define MAX_GPIO_LINE           21
-static int ite_gpio_irq=IT8172_GPIO_IRQ;
-
-static long ite_irq_counter[MAX_GPIO_LINE];
-wait_queue_head_t ite_gpio_wait[MAX_GPIO_LINE];
-static int ite_gpio_irq_pending[MAX_GPIO_LINE];
-
-static int ite_gpio_debug=0;
-#define DEB(x)  if (ite_gpio_debug>=1) x
-
-int ite_gpio_in(__u32 device, __u32 mask, volatile __u32 *data)
-{
-        DEB(printk("ite_gpio_in mask=0x%x\n",mask)); 
-
-        switch (device) {
-        case ITE_GPIO_PORTA:
-                ITE_GPACR = (__u16)mask;        /* 0xffff */
-                *data = ITE_GPADR;
-                break;
-        case ITE_GPIO_PORTB:
-                ITE_GPBCR = (__u16)mask;        /* 0xffff */
-                *data = ITE_GPBDR;
-                break;
-        case ITE_GPIO_PORTC:
-                ITE_GPCCR = (__u16)mask;        /* 0x03ff */
-                *data = ITE_GPCDR;
-                break;
-        default:
-                return -EFAULT;
-        }
-
-        return 0;
-}
-
-
-int ite_gpio_out(__u32 device, __u32 mask, __u32 data)
-{
-        switch (device) {
-        case ITE_GPIO_PORTA:
-                ITE_GPACR = (__u16)mask;        /* 0x5555 */
-                ITE_GPADR = (__u8)data;
-                break;
-        case ITE_GPIO_PORTB:
-                ITE_GPBCR = (__u16)mask;        /* 0x5555 */
-                ITE_GPBDR = (__u8)data;
-                break;
-        case ITE_GPIO_PORTC:
-                ITE_GPCCR = (__u16)mask;        /* 0x0155 */
-                ITE_GPCDR = (__u8)data;
-                break;
-        default:
-                return -EFAULT;
-        }
-
-        return 0;
-}
-
-int ite_gpio_int_ctrl(__u32 device, __u32 mask, __u32 data)
-{
-        switch (device) {
-        case ITE_GPIO_PORTA:
-                ITE_GPAICR = (ITE_GPAICR & ~mask) | (data & mask);
-                break;
-        case ITE_GPIO_PORTB:
-                ITE_GPBICR = (ITE_GPBICR & ~mask) | (data & mask);
-                break;
-        case ITE_GPIO_PORTC:
-                ITE_GPCICR = (ITE_GPCICR & ~mask) | (data & mask);
-                break;
-        default:
-                return -EFAULT;
-        }
-
-        return 0;
-}
-
-int ite_gpio_in_status(__u32 device, __u32 mask, volatile __u32 *data)
-{
-        int ret=-1;
-
-        if ((MAX_GPIO_LINE > *data) && (*data >= 0)) 
-                ret=ite_gpio_irq_pending[*data];
- 
-        DEB(printk("ite_gpio_in_status %d ret=%d\n",*data, ret));
-
-        switch (device) {
-        case ITE_GPIO_PORTA:
-                *data = ITE_GPAISR & mask;
-                break;
-        case ITE_GPIO_PORTB:
-                *data = ITE_GPBISR & mask;
-                break;
-        case ITE_GPIO_PORTC:
-                *data = ITE_GPCISR & mask;
-                break;
-        default:
-                return -EFAULT;
-        }
-
-        return ret;
-}
-
-int ite_gpio_out_status(__u32 device, __u32 mask, __u32 data)
-{
-        switch (device) {
-        case ITE_GPIO_PORTA:
-                ITE_GPAISR = (ITE_GPAISR & ~mask) | (data & mask);
-                break;
-        case ITE_GPIO_PORTB:
-                ITE_GPBISR = (ITE_GPBISR & ~mask) | (data & mask);
-                break;
-        case ITE_GPIO_PORTC:
-                ITE_GPCISR = (ITE_GPCISR & ~mask) | (data & mask);
-                break;
-        default:
-                return -EFAULT;
-        }
-
-        return 0;
-}
-
-int ite_gpio_gen_ctrl(__u32 device, __u32 mask, __u32 data)
-{
-        ITE_GCR = (ITE_GCR & ~mask) | (data & mask);
-
-        return 0;
-}
-
-int ite_gpio_int_wait (__u32 device, __u32 mask, __u32 data)
-{
-        int i,line=0, ret=0;
-        unsigned long flags;
-
-        switch (device) {
-        case ITE_GPIO_PORTA:
-                line = data & mask;
-                break;
-        case ITE_GPIO_PORTB:
-                line = (data & mask) <<8;
-                break;
-        case ITE_GPIO_PORTC:
-                line = (data & mask) <<16;
-                break;
-        }
-        for (i=MAX_GPIO_LINE-1; i >= 0; i--) {
-                if ( (line) & (1 << i))
-                        break;
-        }
-
-        DEB(printk("wait device=0x%d mask=0x%x data=0x%x index %d\n", 
-                device, mask, data, i));
-
-        if (line & ~(1<<i))
-                return -EFAULT;
-
-        if (ite_gpio_irq_pending[i]==1)
-                return -EFAULT;
-
-        save_flags (flags);
-        cli();
-        ite_gpio_irq_pending[i] = 1;
-        ret = interruptible_sleep_on_timeout(&ite_gpio_wait[i], 3*HZ);
-        restore_flags (flags);
-        ite_gpio_irq_pending[i] = 0;
-
-        return ret;
-}
-
-EXPORT_SYMBOL(ite_gpio_in);
-EXPORT_SYMBOL(ite_gpio_out);
-EXPORT_SYMBOL(ite_gpio_int_ctrl);
-EXPORT_SYMBOL(ite_gpio_in_status);
-EXPORT_SYMBOL(ite_gpio_out_status);
-EXPORT_SYMBOL(ite_gpio_gen_ctrl);
-EXPORT_SYMBOL(ite_gpio_int_wait);
-
-static int ite_gpio_open(struct inode *inode, struct file *file)
-{
-        return 0;
-}
-
-
-static int ite_gpio_release(struct inode *inode, struct file *file)
-{
-        return 0;
-}
-
-
-static int ite_gpio_ioctl(struct inode *inode, struct file *file,
-        unsigned int cmd, unsigned long arg)
-{
-        static struct ite_gpio_ioctl_data ioctl_data;
-
-        if (copy_from_user(&ioctl_data, (struct ite_gpio_ioctl_data *)arg,
-                        sizeof(ioctl_data)))
-                return -EFAULT;
-        if ((ioctl_data.device < ITE_GPIO_PORTA) ||
-                        (ioctl_data.device > ITE_GPIO_PORTC) )
-                                return -EFAULT;
-
-        switch(cmd) {
-                case ITE_GPIO_IN:
-                        if (ite_gpio_in(ioctl_data.device, ioctl_data.mask,
-                                           &ioctl_data.data))
-                                return -EFAULT;
-
-                        if (copy_to_user((struct ite_gpio_ioctl_data *)arg,
-                                         &ioctl_data, sizeof(ioctl_data)))
-                                return -EFAULT;
-                        break;
-
-                case ITE_GPIO_OUT:
-                        return ite_gpio_out(ioctl_data.device,
-                                        ioctl_data.mask, ioctl_data.data);
-                        break;
-
-                case ITE_GPIO_INT_CTRL:
-                        return ite_gpio_int_ctrl(ioctl_data.device,
-                                        ioctl_data.mask, ioctl_data.data);
-                        break;
-
-                case ITE_GPIO_IN_STATUS:
-                        if (ite_gpio_in_status(ioctl_data.device, ioctl_data.mask,
-                                        &ioctl_data.data))
-                                return -EFAULT;
-                        if (copy_to_user((struct ite_gpio_ioctl_data *)arg,
-                                        &ioctl_data, sizeof(ioctl_data))) 
-                                return -EFAULT;
-                        break;
-
-                case ITE_GPIO_OUT_STATUS:
-                        return ite_gpio_out_status(ioctl_data.device,
-                                        ioctl_data.mask, ioctl_data.data);
-                        break;
-
-                case ITE_GPIO_GEN_CTRL:
-                        return ite_gpio_gen_ctrl(ioctl_data.device,
-                                        ioctl_data.mask, ioctl_data.data);
-                        break;
-
-                case ITE_GPIO_INT_WAIT:
-                        return ite_gpio_int_wait(ioctl_data.device,
-                                        ioctl_data.mask, ioctl_data.data);
-                        break;
-
-                default:
-                        return -ENOIOCTLCMD;
-
-        }
-
-        return 0;
-}
-
-static void ite_gpio_irq_handler(int this_irq, void *dev_id,
-        struct pt_regs *regs)
-{
-        int i,line;
-
-        line = ITE_GPCISR & 0x1f;
-        for (i=4; i >=0; i--) {
-                if ( line & (1 << i)) { 
-                        ++ite_irq_counter[i+16];
-                        ite_gpio_irq_pending[i+16] = 2;
-                        wake_up_interruptible(&ite_gpio_wait[i+16]);
-
-DEB(printk("interrupt 0x%x %d\n", &ite_gpio_wait[i+16], i+16));
-
-                        ITE_GPCISR = ITE_GPCISR & (1<<i);
-                        return;
-                }
-        }
-        line = ITE_GPBISR;
-        for (i=7; i >= 0; i--) {
-                if ( line & (1 << i)) {
-                        ++ite_irq_counter[i+8];
-                        ite_gpio_irq_pending[i+8] = 2;
-                        wake_up_interruptible(&ite_gpio_wait[i+8]);
-
-DEB(printk("interrupt 0x%x %d\n",ITE_GPBISR, i+8));
-
-                        ITE_GPBISR = ITE_GPBISR & (1<<i);
-                        return;
-                }
-        }
-        line = ITE_GPAISR;
-        for (i=7; i >= 0; i--) {
-                if ( line & (1 << i)) {
-                        ++ite_irq_counter[i];
-                        ite_gpio_irq_pending[i] = 2;
-                        wake_up_interruptible(&ite_gpio_wait[i]);
-
-DEB(printk("interrupt 0x%x %d\n",ITE_GPAISR, i));
-
-                        ITE_GPAISR = ITE_GPAISR & (1<<i);
-                        return;
-                }
-        }
-}
-
-static const struct file_operations ite_gpio_fops = {
-        .owner          = THIS_MODULE,
-        .ioctl          = ite_gpio_ioctl,
-        .open           = ite_gpio_open,
-        .release        = ite_gpio_release,
-};
-
-static struct miscdevice ite_gpio_miscdev = {
-        MISC_DYNAMIC_MINOR,
-        "ite_gpio",
-        &ite_gpio_fops
-};
-
-int __init ite_gpio_init(void)
-{
-        int i;
-
-        if (misc_register(&ite_gpio_miscdev))
-                return -ENODEV;
-
-        if (!request_region(ite_gpio_base, 0x1c, "ITE GPIO"))
-        {
-                misc_deregister(&ite_gpio_miscdev);
-                return -EIO;
-        }
-
-        /* initialize registers */
-        ITE_GPACR = 0xffff;
-        ITE_GPBCR = 0xffff;
-        ITE_GPCCR = 0xffff;
-        ITE_GPAICR = 0x00ff;
-        ITE_GPBICR = 0x00ff;
-        ITE_GPCICR = 0x00ff;
-        ITE_GCR = 0;
-        
-        for (i = 0; i < MAX_GPIO_LINE; i++) {
-                ite_gpio_irq_pending[i]=0;      
-                init_waitqueue_head(&ite_gpio_wait[i]);
-        }
-
-        if (request_irq(ite_gpio_irq, ite_gpio_irq_handler, IRQF_SHARED, "gpio", 0) < 0) {
-                misc_deregister(&ite_gpio_miscdev);
-                release_region(ite_gpio_base, 0x1c);
-                return 0;
-        }
-
-        printk("GPIO at 0x%x (irq = %d)\n", ite_gpio_base, ite_gpio_irq);
-
-        return 0;
-}       
-
-static void __exit ite_gpio_exit(void)
-{
-        misc_deregister(&ite_gpio_miscdev);
-}
-
-module_init(ite_gpio_init);
-module_exit(ite_gpio_exit);
-
-MODULE_LICENSE("GPL");
diff --git a/drivers/char/keyboard.c b/drivers/char/keyboard.c
index 3e90aac37510..7a6c1c0b7a95 100644
--- a/drivers/char/keyboard.c
+++ b/drivers/char/keyboard.c
@@ -32,6 +32,7 @@
 #include <linux/string.h>
 #include <linux/init.h>
 #include <linux/slab.h>
+#include <linux/irq.h>
 
 #include <linux/kbd_kern.h>
 #include <linux/kbd_diacr.h>
@@ -77,7 +78,7 @@ void compute_shiftstate(void);
         k_slock,        k_dead2,        k_brl,          k_ignore
 
 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
-                            char up_flag, struct pt_regs *regs);
+                            char up_flag);
 static k_handler_fn K_HANDLERS;
 static k_handler_fn *k_handler[16] = { K_HANDLERS };
 
@@ -88,7 +89,7 @@ static k_handler_fn *k_handler[16] = { K_HANDLERS };
         fn_boot_it,     fn_caps_on,     fn_compose,     fn_SAK,\
         fn_dec_console, fn_inc_console, fn_spawn_con,   fn_bare_num
 
-typedef void (fn_handler_fn)(struct vc_data *vc, struct pt_regs *regs);
+typedef void (fn_handler_fn)(struct vc_data *vc);
 static fn_handler_fn FN_HANDLERS;
 static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
 
@@ -108,7 +109,11 @@ const int NR_TYPES = ARRAY_SIZE(max_vals);
 struct kbd_struct kbd_table[MAX_NR_CONSOLES];
 static struct kbd_struct *kbd = kbd_table;
 
-int spawnpid, spawnsig;
+struct vt_spawn_console vt_spawn_con = {
+        .lock = SPIN_LOCK_UNLOCKED,
+        .pid  = NULL,
+        .sig  = 0,
+};
 
 /*
  * Variables exported for vt.c
@@ -424,7 +429,7 @@ static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
 /*
  * Special function handlers
  */
-static void fn_enter(struct vc_data *vc, struct pt_regs *regs)
+static void fn_enter(struct vc_data *vc)
 {
         if (diacr) {
                 if (kbd->kbdmode == VC_UNICODE)
@@ -438,27 +443,28 @@ static void fn_enter(struct vc_data *vc, struct pt_regs *regs)
                 put_queue(vc, 10);
 }
 
-static void fn_caps_toggle(struct vc_data *vc, struct pt_regs *regs)
+static void fn_caps_toggle(struct vc_data *vc)
 {
         if (rep)
                 return;
         chg_vc_kbd_led(kbd, VC_CAPSLOCK);
 }
 
-static void fn_caps_on(struct vc_data *vc, struct pt_regs *regs)
+static void fn_caps_on(struct vc_data *vc)
 {
         if (rep)
                 return;
         set_vc_kbd_led(kbd, VC_CAPSLOCK);
 }
 
-static void fn_show_ptregs(struct vc_data *vc, struct pt_regs *regs)
+static void fn_show_ptregs(struct vc_data *vc)
 {
+        struct pt_regs *regs = get_irq_regs();
         if (regs)
                 show_regs(regs);
 }
 
-static void fn_hold(struct vc_data *vc, struct pt_regs *regs)
+static void fn_hold(struct vc_data *vc)
 {
         struct tty_struct *tty = vc->vc_tty;
 
@@ -476,12 +482,12 @@ static void fn_hold(struct vc_data *vc, struct pt_regs *regs)
                 stop_tty(tty);
 }
 
-static void fn_num(struct vc_data *vc, struct pt_regs *regs)
+static void fn_num(struct vc_data *vc)
 {
         if (vc_kbd_mode(kbd,VC_APPLIC))
                 applkey(vc, 'P', 1);
         else
-                fn_bare_num(vc, regs);
+                fn_bare_num(vc);
 }
 
 /*
@@ -490,19 +496,19 @@ static void fn_num(struct vc_data *vc, struct pt_regs *regs)
  * Bind this to NumLock if you prefer that the NumLock key always
  * changes the NumLock flag.
  */
-static void fn_bare_num(struct vc_data *vc, struct pt_regs *regs)
+static void fn_bare_num(struct vc_data *vc)
 {
         if (!rep)
                 chg_vc_kbd_led(kbd, VC_NUMLOCK);
 }
 
-static void fn_lastcons(struct vc_data *vc, struct pt_regs *regs)
+static void fn_lastcons(struct vc_data *vc)
 {
         /* switch to the last used console, ChN */
         set_console(last_console);
 }
 
-static void fn_dec_console(struct vc_data *vc, struct pt_regs *regs)
+static void fn_dec_console(struct vc_data *vc)
 {
         int i, cur = fg_console;
 
@@ -519,7 +525,7 @@ static void fn_dec_console(struct vc_data *vc, struct pt_regs *regs)
         set_console(i);
 }
 
-static void fn_inc_console(struct vc_data *vc, struct pt_regs *regs)
+static void fn_inc_console(struct vc_data *vc)
 {
         int i, cur = fg_console;
 
@@ -536,7 +542,7 @@ static void fn_inc_console(struct vc_data *vc, struct pt_regs *regs)
         set_console(i);
 }
 
-static void fn_send_intr(struct vc_data *vc, struct pt_regs *regs)
+static void fn_send_intr(struct vc_data *vc)
 {
         struct tty_struct *tty = vc->vc_tty;
 
@@ -546,44 +552,48 @@ static void fn_send_intr(struct vc_data *vc, struct pt_regs *regs)
         con_schedule_flip(tty);
 }
 
-static void fn_scroll_forw(struct vc_data *vc, struct pt_regs *regs)
+static void fn_scroll_forw(struct vc_data *vc)
 {
         scrollfront(vc, 0);
 }
 
-static void fn_scroll_back(struct vc_data *vc, struct pt_regs *regs)
+static void fn_scroll_back(struct vc_data *vc)
 {
         scrollback(vc, 0);
 }
 
-static void fn_show_mem(struct vc_data *vc, struct pt_regs *regs)
+static void fn_show_mem(struct vc_data *vc)
 {
         show_mem();
 }
 
-static void fn_show_state(struct vc_data *vc, struct pt_regs *regs)
+static void fn_show_state(struct vc_data *vc)
 {
         show_state();
 }
 
-static void fn_boot_it(struct vc_data *vc, struct pt_regs *regs)
+static void fn_boot_it(struct vc_data *vc)
 {
         ctrl_alt_del();
 }
 
-static void fn_compose(struct vc_data *vc, struct pt_regs *regs)
+static void fn_compose(struct vc_data *vc)
 {
         dead_key_next = 1;
 }
 
-static void fn_spawn_con(struct vc_data *vc, struct pt_regs *regs)
+static void fn_spawn_con(struct vc_data *vc)
 {
-        if (spawnpid)
-                if (kill_proc(spawnpid, spawnsig, 1))
-                        spawnpid = 0;
+        spin_lock(&vt_spawn_con.lock);
+        if (vt_spawn_con.pid)
+                if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
+                        put_pid(vt_spawn_con.pid);
+                        vt_spawn_con.pid = NULL;
+                }
+        spin_unlock(&vt_spawn_con.lock);
 }
 
-static void fn_SAK(struct vc_data *vc, struct pt_regs *regs)
+static void fn_SAK(struct vc_data *vc)
 {
         struct tty_struct *tty = vc->vc_tty;
 
@@ -596,7 +606,7 @@ static void fn_SAK(struct vc_data *vc, struct pt_regs *regs)
         reset_vc(vc);
 }
 
-static void fn_null(struct vc_data *vc, struct pt_regs *regs)
+static void fn_null(struct vc_data *vc)
 {
         compute_shiftstate();
 }
@@ -604,11 +614,11 @@ static void fn_null(struct vc_data *vc, struct pt_regs *regs)
 /*
  * Special key handlers
  */
-static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
+static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
 {
 }
 
-static void k_spec(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
+static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
 {
         if (up_flag)
                 return;
@@ -618,15 +628,15 @@ static void k_spec(struct vc_data *vc, unsigned char value, char up_flag, struct
              kbd->kbdmode == VC_MEDIUMRAW) &&
              value != KVAL(K_SAK))
                 return;         /* SAK is allowed even in raw mode */
-        fn_handler[value](vc, regs);
+        fn_handler[value](vc);
 }
 
-static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
+static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
 {
         printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
 }
 
-static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag, struct pt_regs *regs)
+static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
 {
         if (up_flag)
                 return;         /* no action, if this is a key release */
@@ -650,41 +660,41 @@ static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag, stru
  * dead keys modifying the same character. Very useful
  * for Vietnamese.
  */
-static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag, struct pt_regs *regs)
+static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
 {
         if (up_flag)
                 return;
         diacr = (diacr ? handle_diacr(vc, value) : value);
 }
 
-static void k_self(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
+static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
 {
-        k_unicode(vc, value, up_flag, regs);
+        k_unicode(vc, value, up_flag);
 }
 
-static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
+static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
 {
-        k_deadunicode(vc, value, up_flag, regs);
+        k_deadunicode(vc, value, up_flag);
 }
 
 /*
  * Obsolete - for backwards compatibility only
  */
-static void k_dead(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
+static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
 {
         static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
         value = ret_diacr[value];
-        k_deadunicode(vc, value, up_flag, regs);
+        k_deadunicode(vc, value, up_flag);
 }
 
-static void k_cons(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
+static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
 {
         if (up_flag)
                 return;
         set_console(value);
 }
 
-static void k_fn(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
+static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
 {
         unsigned v;
 
@@ -698,16 +708,16 @@ static void k_fn(struct vc_data *vc, unsigned char value, char up_flag, struct p
                 printk(KERN_ERR "k_fn called with value=%d\n", value);
 }
 
-static void k_cur(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
+static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
 {
-        static const char *cur_chars = "BDCA";
+        static const char cur_chars[] = "BDCA";
 
         if (up_flag)
                 return;
         applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
 }
 
-static void k_pad(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
+static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
 {
         static const char pad_chars[] = "0123456789+-*/\015,.?()#";
         static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
@@ -725,34 +735,34 @@ static void k_pad(struct vc_data *vc, unsigned char value, char up_flag, struct
                 switch (value) {
                         case KVAL(K_PCOMMA):
                         case KVAL(K_PDOT):
-                                k_fn(vc, KVAL(K_REMOVE), 0, regs);
+                                k_fn(vc, KVAL(K_REMOVE), 0);
                                 return;
                         case KVAL(K_P0):
-                                k_fn(vc, KVAL(K_INSERT), 0, regs);
+                                k_fn(vc, KVAL(K_INSERT), 0);
                                 return;
                         case KVAL(K_P1):
-                                k_fn(vc, KVAL(K_SELECT), 0, regs);
+                                k_fn(vc, KVAL(K_SELECT), 0);
                                 return;
                         case KVAL(K_P2):
-                                k_cur(vc, KVAL(K_DOWN), 0, regs);
+                                k_cur(vc, KVAL(K_DOWN), 0);
                                 return;
                         case KVAL(K_P3):
-                                k_fn(vc, KVAL(K_PGDN), 0, regs);
+                                k_fn(vc, KVAL(K_PGDN), 0);
                                 return;
                         case KVAL(K_P4):
-                                k_cur(vc, KVAL(K_LEFT), 0, regs);
+                                k_cur(vc, KVAL(K_LEFT), 0);
                                 return;
                         case KVAL(K_P6):
-                                k_cur(vc, KVAL(K_RIGHT), 0, regs);
+                                k_cur(vc, KVAL(K_RIGHT), 0);
                                 return;
                         case KVAL(K_P7):
-                                k_fn(vc, KVAL(K_FIND), 0, regs);
+                                k_fn(vc, KVAL(K_FIND), 0);
                                 return;
                         case KVAL(K_P8):
-                                k_cur(vc, KVAL(K_UP), 0, regs);
+                                k_cur(vc, KVAL(K_UP), 0);
                                 return;
                         case KVAL(K_P9):
-                                k_fn(vc, KVAL(K_PGUP), 0, regs);
+                                k_fn(vc, KVAL(K_PGUP), 0);
                                 return;
                         case KVAL(K_P5):
                                 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
@@ -764,7 +774,7 @@ static void k_pad(struct vc_data *vc, unsigned char value, char up_flag, struct
                 put_queue(vc, 10);
 }
 
-static void k_shift(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
+static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
 {
         int old_state = shift_state;
 
@@ -805,7 +815,7 @@ static void k_shift(struct vc_data *vc, unsigned char value, char up_flag, struc
         }
 }
 
-static void k_meta(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
+static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
 {
         if (up_flag)
                 return;
@@ -817,7 +827,7 @@ static void k_meta(struct vc_data *vc, unsigned char value, char up_flag, struct
                 put_queue(vc, value | 0x80);
 }
 
-static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
+static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
 {
         int base;
 
@@ -839,16 +849,16 @@ static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag, struc
                 npadch = npadch * base + value;
 }
 
-static void k_lock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
+static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
 {
         if (up_flag || rep)
                 return;
         chg_vc_kbd_lock(kbd, value);
 }
 
-static void k_slock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
+static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
 {
-        k_shift(vc, value, up_flag, regs);
+        k_shift(vc, value, up_flag);
         if (up_flag || rep)
                 return;
         chg_vc_kbd_slock(kbd, value);
@@ -868,25 +878,25 @@ static unsigned brl_nbchords = 1;
 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
 module_param(brl_nbchords, uint, 0644);
 
-static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag, struct pt_regs *regs)
+static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
 {
         static unsigned long chords;
         static unsigned committed;
 
         if (!brl_nbchords)
-                k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag, regs);
+                k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
         else {
                 committed |= pattern;
                 chords++;
                 if (chords == brl_nbchords) {
-                        k_unicode(vc, BRL_UC_ROW | committed, up_flag, regs);
+                        k_unicode(vc, BRL_UC_ROW | committed, up_flag);
                         chords = 0;
                         committed = 0;
                 }
         }
 }
 
-static void k_brl(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
+static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
 {
         static unsigned pressed,committing;
         static unsigned long releasestart;
@@ -898,7 +908,7 @@ static void k_brl(struct vc_data *vc, unsigned char value, char up_flag, struct
         }
 
         if (!value) {
-                k_unicode(vc, BRL_UC_ROW, up_flag, regs);
+                k_unicode(vc, BRL_UC_ROW, up_flag);
                 return;
         }
 
@@ -915,13 +925,13 @@ static void k_brl(struct vc_data *vc, unsigned char value, char up_flag, struct
                         pressed &= ~(1 << (value - 1));
                         if (!pressed) {
                                 if (committing) {
-                                        k_brlcommit(vc, committing, 0, regs);
+                                        k_brlcommit(vc, committing, 0);
                                         committing = 0;
                                 }
                         }
                 } else {
                         if (committing) {
-                                k_brlcommit(vc, committing, 0, regs);
+                                k_brlcommit(vc, committing, 0);
                                 committing = 0;
                         }
                         pressed &= ~(1 << (value - 1));
@@ -1125,8 +1135,7 @@ static void kbd_rawcode(unsigned char data)
                 put_queue(vc, data);
 }
 
-static void kbd_keycode(unsigned int keycode, int down,
-                        int hw_raw, struct pt_regs *regs)
+static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
 {
         struct vc_data *vc = vc_cons[fg_console].d;
         unsigned short keysym, *key_map;
@@ -1173,7 +1182,7 @@ static void kbd_keycode(unsigned int keycode, int down,
         if (sysrq_down && !down && keycode == sysrq_alt_use)
                 sysrq_down = 0;
         if (sysrq_down && down && !rep) {
-                handle_sysrq(kbd_sysrq_xlate[keycode], regs, tty);
+                handle_sysrq(kbd_sysrq_xlate[keycode], tty);
                 return;
         }
 #endif
@@ -1259,7 +1268,7 @@ static void kbd_keycode(unsigned int keycode, int down,
                 }
         }
 
-        (*k_handler[type])(vc, keysym & 0xff, !down, regs);
+        (*k_handler[type])(vc, keysym & 0xff, !down);
 
         if (type != KT_SLOCK)
                 kbd->slockstate = 0;
@@ -1271,7 +1280,7 @@ static void kbd_event(struct input_handle *handle, unsigned int event_type,
         if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
                 kbd_rawcode(value);
         if (event_type == EV_KEY)
-                kbd_keycode(event_code, value, HW_RAW(handle->dev), handle->dev->regs);
+                kbd_keycode(event_code, value, HW_RAW(handle->dev));
         tasklet_schedule(&keyboard_tasklet);
         do_poke_blanked_console = 1;
         schedule_console_callback();
@@ -1285,7 +1294,7 @@ static void kbd_event(struct input_handle *handle, unsigned int event_type,
  */
 static struct input_handle *kbd_connect(struct input_handler *handler,
                                         struct input_dev *dev,
-                                        struct input_device_id *id)
+                                        const struct input_device_id *id)
 {
         struct input_handle *handle;
         int i;
@@ -1334,7 +1343,7 @@ static void kbd_start(struct input_handle *handle)
         tasklet_enable(&keyboard_tasklet);
 }
 
-static struct input_device_id kbd_ids[] = {
+static const struct input_device_id kbd_ids[] = {
         {
                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
                 .evbit = { BIT(EV_KEY) },
@@ -1362,6 +1371,7 @@ static struct input_handler kbd_handler = {
 int __init kbd_init(void)
 {
         int i;
+        int error;
 
         for (i = 0; i < MAX_NR_CONSOLES; i++) {
                 kbd_table[i].ledflagstate = KBD_DEFLEDS;
@@ -1373,7 +1383,9 @@ int __init kbd_init(void)
                 kbd_table[i].kbdmode = VC_XLATE;
         }
 
-        input_register_handler(&kbd_handler);
+        error = input_register_handler(&kbd_handler);
+        if (error)
+                return error;
 
         tasklet_enable(&keyboard_tasklet);
         tasklet_schedule(&keyboard_tasklet);
diff --git a/drivers/char/lp.c b/drivers/char/lp.c
index f875fda3b089..b70b5388b5a8 100644
--- a/drivers/char/lp.c
+++ b/drivers/char/lp.c
@@ -296,7 +296,7 @@ static int lp_wait_ready(int minor, int nonblock)
 static ssize_t lp_write(struct file * file, const char __user * buf,
                         size_t count, loff_t *ppos)
 {
-        unsigned int minor = iminor(file->f_dentry->d_inode);
+        unsigned int minor = iminor(file->f_path.dentry->d_inode);
         struct parport *port = lp_table[minor].dev->port;
         char *kbuf = lp_table[minor].lp_buffer;
         ssize_t retv = 0;
@@ -415,7 +415,7 @@ static ssize_t lp_read(struct file * file, char __user * buf,
                        size_t count, loff_t *ppos)
 {
         DEFINE_WAIT(wait);
-        unsigned int minor=iminor(file->f_dentry->d_inode);
+        unsigned int minor=iminor(file->f_path.dentry->d_inode);
         struct parport *port = lp_table[minor].dev->port;
         ssize_t retval = 0;
         char *kbuf = lp_table[minor].lp_buffer;
@@ -906,7 +906,7 @@ static int __init lp_init (void)
         lp_class = class_create(THIS_MODULE, "printer");
         if (IS_ERR(lp_class)) {
                 err = PTR_ERR(lp_class);
-                goto out_devfs;
+                goto out_reg;
         }
 
         if (parport_register_driver (&lp_driver)) {
@@ -927,7 +927,7 @@ static int __init lp_init (void)
 
 out_class:
         class_destroy(lp_class);
-out_devfs:
+out_reg:
         unregister_chrdev(LP_MAJOR, "lp");
         return err;
 }
diff --git a/drivers/char/mbcs.c b/drivers/char/mbcs.c
index 0385650f6077..0afb7ba999cf 100644
--- a/drivers/char/mbcs.c
+++ b/drivers/char/mbcs.c
@@ -22,6 +22,7 @@
 #include <linux/delay.h>
 #include <linux/device.h>
 #include <linux/mm.h>
+#include <linux/fs.h>
 #include <linux/uio.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>
@@ -447,15 +448,15 @@ loff_t mbcs_sram_llseek(struct file * filp, loff_t off, int whence)
         loff_t newpos;
 
         switch (whence) {
-        case 0:         /* SEEK_SET */
+        case SEEK_SET:
                 newpos = off;
                 break;
 
-        case 1:         /* SEEK_CUR */
+        case SEEK_CUR:
                 newpos = filp->f_pos + off;
                 break;
 
-        case 2:         /* SEEK_END */
+        case SEEK_END:
                 newpos = MBCS_SRAM_SIZE + off;
                 break;
 
@@ -515,11 +516,10 @@ int mbcs_gscr_mmap(struct file *fp, struct vm_area_struct *vma)
  * mbcs_completion_intr_handler - Primary completion handler.
  * @irq: irq
  * @arg: soft struct for device
- * @ep: regs
  *
  */
 static irqreturn_t
-mbcs_completion_intr_handler(int irq, void *arg, struct pt_regs *ep)
+mbcs_completion_intr_handler(int irq, void *arg)
 {
         struct mbcs_soft *soft = (struct mbcs_soft *)arg;
         void *mmr_base;
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index 917b20402664..4f1813e04754 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -26,6 +26,7 @@
 #include <linux/backing-dev.h>
 #include <linux/bootmem.h>
 #include <linux/pipe_fs_i.h>
+#include <linux/pfn.h>
 
 #include <asm/uaccess.h>
 #include <asm/io.h>
@@ -238,6 +239,32 @@ static pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn,
 }
 #endif
 
+#ifndef CONFIG_MMU
+static unsigned long get_unmapped_area_mem(struct file *file,
+                                           unsigned long addr,
+                                           unsigned long len,
+                                           unsigned long pgoff,
+                                           unsigned long flags)
+{
+        if (!valid_mmap_phys_addr_range(pgoff, len))
+                return (unsigned long) -EINVAL;
+        return pgoff;
+}
+
+/* can't do an in-place private mapping if there's no MMU */
+static inline int private_mapping_ok(struct vm_area_struct *vma)
+{
+        return vma->vm_flags & VM_MAYSHARE;
+}
+#else
+#define get_unmapped_area_mem   NULL
+
+static inline int private_mapping_ok(struct vm_area_struct *vma)
+{
+        return 1;
+}
+#endif
+
 static int mmap_mem(struct file * file, struct vm_area_struct * vma)
 {
         size_t size = vma->vm_end - vma->vm_start;
@@ -245,6 +272,9 @@ static int mmap_mem(struct file * file, struct vm_area_struct * vma)
         if (!valid_mmap_phys_addr_range(vma->vm_pgoff, size))
                 return -EINVAL;
 
+        if (!private_mapping_ok(vma))
+                return -ENOSYS;
+
         vma->vm_page_prot = phys_mem_access_prot(file, vma->vm_pgoff,
                                                  size,
                                                  vma->vm_page_prot);
@@ -263,8 +293,8 @@ static int mmap_kmem(struct file * file, struct vm_area_struct * vma)
 {
         unsigned long pfn;
 
-        /* Turn a kernel-virtual address into a physical page frame */
-        pfn = __pa((u64)vma->vm_pgoff << PAGE_SHIFT) >> PAGE_SHIFT;
+        /* Turn a pfn offset into an absolute pfn */
+        pfn = PFN_DOWN(virt_to_phys((void *)PAGE_OFFSET)) + vma->vm_pgoff;
 
         /*
          * RED-PEN: on some architectures there is more mapped memory
@@ -522,7 +552,7 @@ static ssize_t write_kmem(struct file * file, const char __user * buf,
         return virtr + wrote;
 }
 
-#if defined(CONFIG_ISA) || !defined(__mc68000__)
+#if (defined(CONFIG_ISA) || defined(CONFIG_PCI)) && !defined(__mc68000__)
 static ssize_t read_port(struct file * file, char __user * buf,
                          size_t count, loff_t *ppos)
 {
@@ -616,7 +646,8 @@ static inline size_t read_zero_pagealigned(char __user * buf, size_t size)
                         count = size;
 
                 zap_page_range(vma, addr, count, NULL);
-                zeromap_page_range(vma, addr, count, PAGE_COPY);
+                if (zeromap_page_range(vma, addr, count, PAGE_COPY))
+                        break;
 
                 size -= count;
                 buf += count;
@@ -683,11 +714,14 @@ out:
 
 static int mmap_zero(struct file * file, struct vm_area_struct * vma)
 {
+        int err;
+
         if (vma->vm_flags & VM_SHARED)
                 return shmem_zero_setup(vma);
-        if (zeromap_page_range(vma, vma->vm_start, vma->vm_end - vma->vm_start, vma->vm_page_prot))
-                return -EAGAIN;
-        return 0;
+        err = zeromap_page_range(vma, vma->vm_start,
+                        vma->vm_end - vma->vm_start, vma->vm_page_prot);
+        BUG_ON(err == -EEXIST);
+        return err;
 }
 #else /* CONFIG_MMU */
 static ssize_t read_zero(struct file * file, char * buf, 
@@ -744,7 +778,7 @@ static loff_t memory_lseek(struct file * file, loff_t offset, int orig)
 {
         loff_t ret;
 
-        mutex_lock(&file->f_dentry->d_inode->i_mutex);
+        mutex_lock(&file->f_path.dentry->d_inode->i_mutex);
         switch (orig) {
                 case 0:
                         file->f_pos = offset;
@@ -759,7 +793,7 @@ static loff_t memory_lseek(struct file * file, loff_t offset, int orig)
                 default:
                         ret = -EINVAL;
         }
-        mutex_unlock(&file->f_dentry->d_inode->i_mutex);
+        mutex_unlock(&file->f_path.dentry->d_inode->i_mutex);
         return ret;
 }
 
@@ -782,6 +816,7 @@ static const struct file_operations mem_fops = {
         .write          = write_mem,
         .mmap           = mmap_mem,
         .open           = open_mem,
+        .get_unmapped_area = get_unmapped_area_mem,
 };
 
 static const struct file_operations kmem_fops = {
@@ -790,6 +825,7 @@ static const struct file_operations kmem_fops = {
         .write          = write_kmem,
         .mmap           = mmap_kmem,
         .open           = open_kmem,
+        .get_unmapped_area = get_unmapped_area_mem,
 };
 
 static const struct file_operations null_fops = {
@@ -799,7 +835,7 @@ static const struct file_operations null_fops = {
         .splice_write   = splice_write_null,
 };
 
-#if defined(CONFIG_ISA) || !defined(__mc68000__)
+#if (defined(CONFIG_ISA) || defined(CONFIG_PCI)) && !defined(__mc68000__)
 static const struct file_operations port_fops = {
         .llseek         = memory_lseek,
         .read           = read_port,
@@ -815,6 +851,10 @@ static const struct file_operations zero_fops = {
         .mmap           = mmap_zero,
 };
 
+/*
+ * capabilities for /dev/zero
+ * - permits private mappings, "copies" are taken of the source of zeros
+ */
 static struct backing_dev_info zero_bdi = {
         .capabilities   = BDI_CAP_MAP_COPY,
 };
@@ -862,14 +902,18 @@ static int memory_open(struct inode * inode, struct file * filp)
         switch (iminor(inode)) {
                 case 1:
                         filp->f_op = &mem_fops;
+                        filp->f_mapping->backing_dev_info =
+                                &directly_mappable_cdev_bdi;
                         break;
                 case 2:
                         filp->f_op = &kmem_fops;
+                        filp->f_mapping->backing_dev_info =
+                                &directly_mappable_cdev_bdi;
                         break;
                 case 3:
                         filp->f_op = &null_fops;
                         break;
-#if defined(CONFIG_ISA) || !defined(__mc68000__)
+#if (defined(CONFIG_ISA) || defined(CONFIG_PCI)) && !defined(__mc68000__)
                 case 4:
                         filp->f_op = &port_fops;
                         break;
@@ -916,7 +960,7 @@ static const struct {
         {1, "mem",     S_IRUSR | S_IWUSR | S_IRGRP, &mem_fops},
         {2, "kmem",    S_IRUSR | S_IWUSR | S_IRGRP, &kmem_fops},
         {3, "null",    S_IRUGO | S_IWUGO,           &null_fops},
-#if defined(CONFIG_ISA) || !defined(__mc68000__)
+#if (defined(CONFIG_ISA) || defined(CONFIG_PCI)) && !defined(__mc68000__)
         {4, "port",    S_IRUSR | S_IWUSR | S_IRGRP, &port_fops},
 #endif
         {5, "zero",    S_IRUGO | S_IWUGO,           &zero_fops},
@@ -940,10 +984,10 @@ static int __init chr_dev_init(void)
 
         mem_class = class_create(THIS_MODULE, "mem");
         for (i = 0; i < ARRAY_SIZE(devlist); i++)
-                class_device_create(mem_class, NULL,
-                                        MKDEV(MEM_MAJOR, devlist[i].minor),
-                                        NULL, devlist[i].name);
-        
+                device_create(mem_class, NULL,
+                              MKDEV(MEM_MAJOR, devlist[i].minor),
+                              devlist[i].name);
+
         return 0;
 }
 
diff --git a/drivers/char/misc.c b/drivers/char/misc.c
index 62ebe09656e3..7e975f606924 100644
--- a/drivers/char/misc.c
+++ b/drivers/char/misc.c
@@ -169,11 +169,6 @@ fail:
         return err;
 }
 
-/* 
- * TODO for 2.7:
- *  - add a struct kref to struct miscdevice and make all usages of
- *    them dynamic.
- */
 static struct class *misc_class;
 
 static const struct file_operations misc_fops = {
@@ -204,6 +199,8 @@ int misc_register(struct miscdevice * misc)
         dev_t dev;
         int err = 0;
 
+        INIT_LIST_HEAD(&misc->list);
+
         down(&misc_sem);
         list_for_each_entry(c, &misc_list, list) {
                 if (c->minor == misc->minor) {
@@ -228,10 +225,10 @@ int misc_register(struct miscdevice * misc)
                 misc_minors[misc->minor >> 3] |= 1 << (misc->minor & 7);
         dev = MKDEV(MISC_MAJOR, misc->minor);
 
-        misc->class = class_device_create(misc_class, NULL, dev, misc->dev,
+        misc->this_device = device_create(misc_class, misc->parent, dev,
                                           "%s", misc->name);
-        if (IS_ERR(misc->class)) {
-                err = PTR_ERR(misc->class);
+        if (IS_ERR(misc->this_device)) {
+                err = PTR_ERR(misc->this_device);
                 goto out;
         }
 
@@ -264,7 +261,7 @@ int misc_deregister(struct miscdevice * misc)
 
         down(&misc_sem);
         list_del(&misc->list);
-        class_device_destroy(misc_class, MKDEV(MISC_MAJOR, misc->minor));
+        device_destroy(misc_class, MKDEV(MISC_MAJOR, misc->minor));
         if (i < DYNAMIC_MINORS && i>0) {
                 misc_minors[i>>3] &= ~(1 << (misc->minor & 7));
         }
diff --git a/drivers/char/mmtimer.c b/drivers/char/mmtimer.c
index 1f0f2b6dae26..c09160383a53 100644
--- a/drivers/char/mmtimer.c
+++ b/drivers/char/mmtimer.c
@@ -422,7 +422,6 @@ static int inline reschedule_periodic_timer(mmtimer_t *x)
  * mmtimer_interrupt - timer interrupt handler
  * @irq: irq received
  * @dev_id: device the irq came from
- * @regs: register state upon receipt of the interrupt
  *
  * Called when one of the comarators matches the counter, This
  * routine will send signals to processes that have requested
@@ -433,7 +432,7 @@ static int inline reschedule_periodic_timer(mmtimer_t *x)
  * registers.
  */
 static irqreturn_t
-mmtimer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+mmtimer_interrupt(int irq, void *dev_id)
 {
         int i;
         unsigned long expires = 0;
@@ -681,7 +680,7 @@ static int __init mmtimer_init(void)
         if (sn_rtc_cycles_per_second < 100000) {
                 printk(KERN_ERR "%s: unable to determine clock frequency\n",
                        MMTIMER_NAME);
-                return -1;
+                goto out1;
         }
 
         mmtimer_femtoperiod = ((unsigned long)1E15 + sn_rtc_cycles_per_second /
@@ -690,13 +689,13 @@ static int __init mmtimer_init(void)
         if (request_irq(SGI_MMTIMER_VECTOR, mmtimer_interrupt, IRQF_PERCPU, MMTIMER_NAME, NULL)) {
                 printk(KERN_WARNING "%s: unable to allocate interrupt.",
                         MMTIMER_NAME);
-                return -1;
+                goto out1;
         }
 
         if (misc_register(&mmtimer_miscdev)) {
                 printk(KERN_ERR "%s: failed to register device\n",
                        MMTIMER_NAME);
-                return -1;
+                goto out2;
         }
 
         /* Get max numbered node, calculate slots needed */
@@ -710,16 +709,18 @@ static int __init mmtimer_init(void)
         if (timers == NULL) {
                 printk(KERN_ERR "%s: failed to allocate memory for device\n",
                                 MMTIMER_NAME);
-                return -1;
+                goto out3;
         }
 
+        memset(timers,0,(sizeof(mmtimer_t *)*maxn));
+
         /* Allocate mmtimer_t's for each online node */
         for_each_online_node(node) {
                 timers[node] = kmalloc_node(sizeof(mmtimer_t)*NUM_COMPARATORS, GFP_KERNEL, node);
                 if (timers[node] == NULL) {
                         printk(KERN_ERR "%s: failed to allocate memory for device\n",
                                 MMTIMER_NAME);
-                        return -1;
+                        goto out4;
                 }
                 for (i=0; i< NUM_COMPARATORS; i++) {
                         mmtimer_t * base = timers[node] + i;
@@ -740,6 +741,17 @@ static int __init mmtimer_init(void)
                sn_rtc_cycles_per_second/(unsigned long)1E6);
 
         return 0;
+
+out4:
+        for_each_online_node(node) {
+                kfree(timers[node]);
+        }
+out3:
+        misc_deregister(&mmtimer_miscdev);
+out2:
+        free_irq(SGI_MMTIMER_VECTOR, NULL);
+out1:
+        return -1;
 }
 
 module_init(mmtimer_init);
diff --git a/drivers/char/moxa.c b/drivers/char/moxa.c
index a369dd6877d8..f391a24a1b44 100644
--- a/drivers/char/moxa.c
+++ b/drivers/char/moxa.c
@@ -130,6 +130,7 @@ static moxa_isa_board_conf moxa_isa_boards[] =
 typedef struct _moxa_pci_devinfo {
         ushort busNum;
         ushort devNum;
+        struct pci_dev *pdev;
 } moxa_pci_devinfo;
 
 typedef struct _moxa_board_conf {
@@ -221,7 +222,7 @@ static struct semaphore moxaBuffSem;
 /*
  * static functions:
  */
-static void do_moxa_softint(void *);
+static void do_moxa_softint(struct work_struct *);
 static int moxa_open(struct tty_struct *, struct file *);
 static void moxa_close(struct tty_struct *, struct file *);
 static int moxa_write(struct tty_struct *, const unsigned char *, int);
@@ -233,7 +234,7 @@ static void moxa_put_char(struct tty_struct *, unsigned char);
 static int moxa_ioctl(struct tty_struct *, struct file *, unsigned int, unsigned long);
 static void moxa_throttle(struct tty_struct *);
 static void moxa_unthrottle(struct tty_struct *);
-static void moxa_set_termios(struct tty_struct *, struct termios *);
+static void moxa_set_termios(struct tty_struct *, struct ktermios *);
 static void moxa_stop(struct tty_struct *);
 static void moxa_start(struct tty_struct *);
 static void moxa_hangup(struct tty_struct *);
@@ -260,7 +261,7 @@ static void MoxaPortEnable(int);
 static void MoxaPortDisable(int);
 static long MoxaPortGetMaxBaud(int);
 static long MoxaPortSetBaud(int, long);
-static int MoxaPortSetTermio(int, struct termios *);
+static int MoxaPortSetTermio(int, struct ktermios *, speed_t);
 static int MoxaPortGetLineOut(int, int *, int *);
 static void MoxaPortLineCtrl(int, int, int);
 static void MoxaPortFlowCtrl(int, int, int, int, int, int);
@@ -281,7 +282,7 @@ static int moxa_get_serial_info(struct moxa_str *, struct serial_struct __user *
 static int moxa_set_serial_info(struct moxa_str *, struct serial_struct __user *);
 static void MoxaSetFifo(int port, int enable);
 
-static struct tty_operations moxa_ops = {
+static const struct tty_operations moxa_ops = {
         .open = moxa_open,
         .close = moxa_close,
         .write = moxa_write,
@@ -324,6 +325,9 @@ static int moxa_get_PCI_conf(struct pci_dev *p, int board_type, moxa_board_conf
         board->busType = MOXA_BUS_TYPE_PCI;
         board->pciInfo.busNum = p->bus->number;
         board->pciInfo.devNum = p->devfn >> 3;
+        board->pciInfo.pdev = p;
+        /* don't lose the reference in the next pci_get_device iteration */
+        pci_dev_get(p);
 
         return (0);
 }
@@ -351,6 +355,8 @@ static int __init moxa_init(void)
         moxaDriver->init_termios.c_oflag = 0;
         moxaDriver->init_termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;
         moxaDriver->init_termios.c_lflag = 0;
+        moxaDriver->init_termios.c_ispeed = 9600;
+        moxaDriver->init_termios.c_ospeed = 9600;
         moxaDriver->flags = TTY_DRIVER_REAL_RAW;
         tty_set_operations(moxaDriver, &moxa_ops);
 
@@ -359,7 +365,7 @@ static int __init moxa_init(void)
         for (i = 0, ch = moxaChannels; i < MAX_PORTS; i++, ch++) {
                 ch->type = PORT_16550A;
                 ch->port = i;
-                INIT_WORK(&ch->tqueue, do_moxa_softint, ch);
+                INIT_WORK(&ch->tqueue, do_moxa_softint);
                 ch->tty = NULL;
                 ch->close_delay = 5 * HZ / 10;
                 ch->closing_wait = 30 * HZ;
@@ -493,6 +499,14 @@ static void __exit moxa_exit(void)
         if (tty_unregister_driver(moxaDriver))
                 printk("Couldn't unregister MOXA Intellio family serial driver\n");
         put_tty_driver(moxaDriver);
+
+        for (i = 0; i < MAX_BOARDS; i++) {
+                if (moxaBaseAddr[i])
+                        iounmap(moxaBaseAddr[i]);
+                if (moxa_boards[i].busType == MOXA_BUS_TYPE_PCI)
+                        pci_dev_put(moxa_boards[i].pciInfo.pdev);
+        }
+
         if (verbose)
                 printk("Done\n");
 }
@@ -500,9 +514,9 @@ static void __exit moxa_exit(void)
 module_init(moxa_init);
 module_exit(moxa_exit);
 
-static void do_moxa_softint(void *private_)
+static void do_moxa_softint(struct work_struct *work)
 {
-        struct moxa_str *ch = (struct moxa_str *) private_;
+        struct moxa_str *ch = container_of(work, struct moxa_str, tqueue);
         struct tty_struct *tty;
 
         if (ch && (tty = ch->tty)) {
@@ -852,7 +866,7 @@ static void moxa_unthrottle(struct tty_struct *tty)
 }
 
 static void moxa_set_termios(struct tty_struct *tty,
-                             struct termios *old_termios)
+                             struct ktermios *old_termios)
 {
         struct moxa_str *ch = (struct moxa_str *) tty->driver_data;
 
@@ -966,7 +980,7 @@ static void moxa_poll(unsigned long ignored)
 
 static void set_tty_param(struct tty_struct *tty)
 {
-        register struct termios *ts;
+        register struct ktermios *ts;
         struct moxa_str *ch;
         int rts, cts, txflow, rxflow, xany;
 
@@ -986,7 +1000,7 @@ static void set_tty_param(struct tty_struct *tty)
         if (ts->c_iflag & IXANY)
                 xany = 1;
         MoxaPortFlowCtrl(ch->port, rts, cts, txflow, rxflow, xany);
-        MoxaPortSetTermio(ch->port, ts);
+        MoxaPortSetTermio(ch->port, ts, tty_get_baud_rate(tty));
 }
 
 static int block_till_ready(struct tty_struct *tty, struct file *filp,
@@ -1137,7 +1151,7 @@ static void shut_down(struct moxa_str *ch)
 static void receive_data(struct moxa_str *ch)
 {
         struct tty_struct *tp;
-        struct termios *ts;
+        struct ktermios *ts;
         unsigned long flags;
 
         ts = NULL;
@@ -1900,9 +1914,10 @@ int MoxaPortsOfCard(int cardno)
  *
  *      Function 12:    Configure the port.
  *      Syntax:
- *      int  MoxaPortSetTermio(int port, struct termios *termio);
+ *      int  MoxaPortSetTermio(int port, struct ktermios *termio, speed_t baud);
  *           int port           : port number (0 - 127)
- *           struct termios * termio : termio structure pointer
+ *           struct ktermios * termio : termio structure pointer
+ *           speed_t baud       : baud rate
  *
  *           return:    -1      : this port is invalid or termio == NULL
  *                      0       : setting O.K.
@@ -2182,11 +2197,10 @@ long MoxaPortSetBaud(int port, long baud)
         return (baud);
 }
 
-int MoxaPortSetTermio(int port, struct termios *termio)
+int MoxaPortSetTermio(int port, struct ktermios *termio, speed_t baud)
 {
         void __iomem *ofsAddr;
         tcflag_t cflag;
-        long baud;
         tcflag_t mode = 0;
 
         if (moxaChkPort[port] == 0 || termio == 0)
@@ -2222,77 +2236,9 @@ int MoxaPortSetTermio(int port, struct termios *termio)
 
         moxafunc(ofsAddr, FC_SetDataMode, (ushort) mode);
 
-        cflag &= (CBAUD | CBAUDEX);
-#ifndef B921600
-#define B921600 (B460800+1)
-#endif
-        switch (cflag) {
-        case B921600:
-                baud = 921600L;
-                break;
-        case B460800:
-                baud = 460800L;
-                break;
-        case B230400:
-                baud = 230400L;
-                break;
-        case B115200:
-                baud = 115200L;
-                break;
-        case B57600:
-                baud = 57600L;
-                break;
-        case B38400:
-                baud = 38400L;
-                break;
-        case B19200:
-                baud = 19200L;
-                break;
-        case B9600:
-                baud = 9600L;
-                break;
-        case B4800:
-                baud = 4800L;
-                break;
-        case B2400:
-                baud = 2400L;
-                break;
-        case B1800:
-                baud = 1800L;
-                break;
-        case B1200:
-                baud = 1200L;
-                break;
-        case B600:
-                baud = 600L;
-                break;
-        case B300:
-                baud = 300L;
-                break;
-        case B200:
-                baud = 200L;
-                break;
-        case B150:
-                baud = 150L;
-                break;
-        case B134:
-                baud = 134L;
-                break;
-        case B110:
-                baud = 110L;
-                break;
-        case B75:
-                baud = 75L;
-                break;
-        case B50:
-                baud = 50L;
-                break;
-        default:
-                baud = 0;
-        }
         if ((moxa_boards[port / MAX_PORTS_PER_BOARD].boardType == MOXA_BOARD_C320_ISA) ||
             (moxa_boards[port / MAX_PORTS_PER_BOARD].boardType == MOXA_BOARD_C320_PCI)) {
-                if (baud == 921600L)
+                if (baud >= 921600L)
                         return (-1);
         }
         MoxaPortSetBaud(port, baud);
diff --git a/drivers/char/mspec.c b/drivers/char/mspec.c
new file mode 100644
index 000000000000..235e89226112
--- /dev/null
+++ b/drivers/char/mspec.c
@@ -0,0 +1,426 @@
+/*
+ * Copyright (C) 2001-2006 Silicon Graphics, Inc.  All rights
+ * reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License
+ * as published by the Free Software Foundation.
+ */
+
+/*
+ * SN Platform Special Memory (mspec) Support
+ *
+ * This driver exports the SN special memory (mspec) facility to user
+ * processes.
+ * There are three types of memory made available thru this driver:
+ * fetchops, uncached and cached.
+ *
+ * Fetchops are atomic memory operations that are implemented in the
+ * memory controller on SGI SN hardware.
+ *
+ * Uncached are used for memory write combining feature of the ia64
+ * cpu.
+ *
+ * Cached are used for areas of memory that are used as cached addresses
+ * on our partition and used as uncached addresses from other partitions.
+ * Due to a design constraint of the SN2 Shub, you can not have processors
+ * on the same FSB perform both a cached and uncached reference to the
+ * same cache line.  These special memory cached regions prevent the
+ * kernel from ever dropping in a TLB entry and therefore prevent the
+ * processor from ever speculating a cache line from this page.
+ */
+
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/errno.h>
+#include <linux/miscdevice.h>
+#include <linux/spinlock.h>
+#include <linux/mm.h>
+#include <linux/vmalloc.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+#include <linux/numa.h>
+#include <asm/page.h>
+#include <asm/system.h>
+#include <asm/pgtable.h>
+#include <asm/atomic.h>
+#include <asm/tlbflush.h>
+#include <asm/uncached.h>
+#include <asm/sn/addrs.h>
+#include <asm/sn/arch.h>
+#include <asm/sn/mspec.h>
+#include <asm/sn/sn_cpuid.h>
+#include <asm/sn/io.h>
+#include <asm/sn/bte.h>
+#include <asm/sn/shubio.h>
+
+
+#define FETCHOP_ID      "SGI Fetchop,"
+#define CACHED_ID       "Cached,"
+#define UNCACHED_ID     "Uncached"
+#define REVISION        "4.0"
+#define MSPEC_BASENAME  "mspec"
+
+/*
+ * Page types allocated by the device.
+ */
+enum {
+        MSPEC_FETCHOP = 1,
+        MSPEC_CACHED,
+        MSPEC_UNCACHED
+};
+
+#ifdef CONFIG_SGI_SN
+static int is_sn2;
+#else
+#define is_sn2          0
+#endif
+
+/*
+ * One of these structures is allocated when an mspec region is mmaped. The
+ * structure is pointed to by the vma->vm_private_data field in the vma struct.
+ * This structure is used to record the addresses of the mspec pages.
+ */
+struct vma_data {
+        atomic_t refcnt;        /* Number of vmas sharing the data. */
+        spinlock_t lock;        /* Serialize access to the vma. */
+        int count;              /* Number of pages allocated. */
+        int type;               /* Type of pages allocated. */
+        unsigned long maddr[0]; /* Array of MSPEC addresses. */
+};
+
+/* used on shub2 to clear FOP cache in the HUB */
+static unsigned long scratch_page[MAX_NUMNODES];
+#define SH2_AMO_CACHE_ENTRIES   4
+
+static inline int
+mspec_zero_block(unsigned long addr, int len)
+{
+        int status;
+
+        if (is_sn2) {
+                if (is_shub2()) {
+                        int nid;
+                        void *p;
+                        int i;
+
+                        nid = nasid_to_cnodeid(get_node_number(__pa(addr)));
+                        p = (void *)TO_AMO(scratch_page[nid]);
+
+                        for (i=0; i < SH2_AMO_CACHE_ENTRIES; i++) {
+                                FETCHOP_LOAD_OP(p, FETCHOP_LOAD);
+                                p += FETCHOP_VAR_SIZE;
+                        }
+                }
+
+                status = bte_copy(0, addr & ~__IA64_UNCACHED_OFFSET, len,
+                                  BTE_WACQUIRE | BTE_ZERO_FILL, NULL);
+        } else {
+                memset((char *) addr, 0, len);
+                status = 0;
+        }
+        return status;
+}
+
+/*
+ * mspec_open
+ *
+ * Called when a device mapping is created by a means other than mmap
+ * (via fork, etc.).  Increments the reference count on the underlying
+ * mspec data so it is not freed prematurely.
+ */
+static void
+mspec_open(struct vm_area_struct *vma)
+{
+        struct vma_data *vdata;
+
+        vdata = vma->vm_private_data;
+        atomic_inc(&vdata->refcnt);
+}
+
+/*
+ * mspec_close
+ *
+ * Called when unmapping a device mapping. Frees all mspec pages
+ * belonging to the vma.
+ */
+static void
+mspec_close(struct vm_area_struct *vma)
+{
+        struct vma_data *vdata;
+        int i, pages, result, vdata_size;
+
+        vdata = vma->vm_private_data;
+        if (!atomic_dec_and_test(&vdata->refcnt))
+                return;
+
+        pages = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
+        vdata_size = sizeof(struct vma_data) + pages * sizeof(long);
+        for (i = 0; i < pages; i++) {
+                if (vdata->maddr[i] == 0)
+                        continue;
+                /*
+                 * Clear the page before sticking it back
+                 * into the pool.
+                 */
+                result = mspec_zero_block(vdata->maddr[i], PAGE_SIZE);
+                if (!result)
+                        uncached_free_page(vdata->maddr[i]);
+                else
+                        printk(KERN_WARNING "mspec_close(): "
+                               "failed to zero page %i\n",
+                               result);
+        }
+
+        if (vdata_size <= PAGE_SIZE)
+                kfree(vdata);
+        else
+                vfree(vdata);
+}
+
+
+/*
+ * mspec_nopfn
+ *
+ * Creates a mspec page and maps it to user space.
+ */
+static unsigned long
+mspec_nopfn(struct vm_area_struct *vma, unsigned long address)
+{
+        unsigned long paddr, maddr;
+        unsigned long pfn;
+        int index;
+        struct vma_data *vdata = vma->vm_private_data;
+
+        index = (address - vma->vm_start) >> PAGE_SHIFT;
+        maddr = (volatile unsigned long) vdata->maddr[index];
+        if (maddr == 0) {
+                maddr = uncached_alloc_page(numa_node_id());
+                if (maddr == 0)
+                        return NOPFN_OOM;
+
+                spin_lock(&vdata->lock);
+                if (vdata->maddr[index] == 0) {
+                        vdata->count++;
+                        vdata->maddr[index] = maddr;
+                } else {
+                        uncached_free_page(maddr);
+                        maddr = vdata->maddr[index];
+                }
+                spin_unlock(&vdata->lock);
+        }
+
+        if (vdata->type == MSPEC_FETCHOP)
+                paddr = TO_AMO(maddr);
+        else
+                paddr = maddr & ~__IA64_UNCACHED_OFFSET;
+
+        pfn = paddr >> PAGE_SHIFT;
+
+        return pfn;
+}
+
+static struct vm_operations_struct mspec_vm_ops = {
+        .open = mspec_open,
+        .close = mspec_close,
+        .nopfn = mspec_nopfn
+};
+
+/*
+ * mspec_mmap
+ *
+ * Called when mmaping the device.  Initializes the vma with a fault handler
+ * and private data structure necessary to allocate, track, and free the
+ * underlying pages.
+ */
+static int
+mspec_mmap(struct file *file, struct vm_area_struct *vma, int type)
+{
+        struct vma_data *vdata;
+        int pages, vdata_size;
+
+        if (vma->vm_pgoff != 0)
+                return -EINVAL;
+
+        if ((vma->vm_flags & VM_SHARED) == 0)
+                return -EINVAL;
+
+        if ((vma->vm_flags & VM_WRITE) == 0)
+                return -EPERM;
+
+        pages = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
+        vdata_size = sizeof(struct vma_data) + pages * sizeof(long);
+        if (vdata_size <= PAGE_SIZE)
+                vdata = kmalloc(vdata_size, GFP_KERNEL);
+        else
+                vdata = vmalloc(vdata_size);
+        if (!vdata)
+                return -ENOMEM;
+        memset(vdata, 0, vdata_size);
+
+        vdata->type = type;
+        spin_lock_init(&vdata->lock);
+        vdata->refcnt = ATOMIC_INIT(1);
+        vma->vm_private_data = vdata;
+
+        vma->vm_flags |= (VM_IO | VM_LOCKED | VM_RESERVED | VM_PFNMAP);
+        if (vdata->type == MSPEC_FETCHOP || vdata->type == MSPEC_UNCACHED)
+                vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
+        vma->vm_ops = &mspec_vm_ops;
+
+        return 0;
+}
+
+static int
+fetchop_mmap(struct file *file, struct vm_area_struct *vma)
+{
+        return mspec_mmap(file, vma, MSPEC_FETCHOP);
+}
+
+static int
+cached_mmap(struct file *file, struct vm_area_struct *vma)
+{
+        return mspec_mmap(file, vma, MSPEC_CACHED);
+}
+
+static int
+uncached_mmap(struct file *file, struct vm_area_struct *vma)
+{
+        return mspec_mmap(file, vma, MSPEC_UNCACHED);
+}
+
+static struct file_operations fetchop_fops = {
+        .owner = THIS_MODULE,
+        .mmap = fetchop_mmap
+};
+
+static struct miscdevice fetchop_miscdev = {
+        .minor = MISC_DYNAMIC_MINOR,
+        .name = "sgi_fetchop",
+        .fops = &fetchop_fops
+};
+
+static struct file_operations cached_fops = {
+        .owner = THIS_MODULE,
+        .mmap = cached_mmap
+};
+
+static struct miscdevice cached_miscdev = {
+        .minor = MISC_DYNAMIC_MINOR,
+        .name = "mspec_cached",
+        .fops = &cached_fops
+};
+
+static struct file_operations uncached_fops = {
+        .owner = THIS_MODULE,
+        .mmap = uncached_mmap
+};
+
+static struct miscdevice uncached_miscdev = {
+        .minor = MISC_DYNAMIC_MINOR,
+        .name = "mspec_uncached",
+        .fops = &uncached_fops
+};
+
+/*
+ * mspec_init
+ *
+ * Called at boot time to initialize the mspec facility.
+ */
+static int __init
+mspec_init(void)
+{
+        int ret;
+        int nid;
+
+        /*
+         * The fetchop device only works on SN2 hardware, uncached and cached
+         * memory drivers should both be valid on all ia64 hardware
+         */
+#ifdef CONFIG_SGI_SN
+        if (ia64_platform_is("sn2")) {
+                is_sn2 = 1;
+                if (is_shub2()) {
+                        ret = -ENOMEM;
+                        for_each_online_node(nid) {
+                                int actual_nid;
+                                int nasid;
+                                unsigned long phys;
+
+                                scratch_page[nid] = uncached_alloc_page(nid);
+                                if (scratch_page[nid] == 0)
+                                        goto free_scratch_pages;
+                                phys = __pa(scratch_page[nid]);
+                                nasid = get_node_number(phys);
+                                actual_nid = nasid_to_cnodeid(nasid);
+                                if (actual_nid != nid)
+                                        goto free_scratch_pages;
+                        }
+                }
+
+                ret = misc_register(&fetchop_miscdev);
+                if (ret) {
+                        printk(KERN_ERR
+                               "%s: failed to register device %i\n",
+                               FETCHOP_ID, ret);
+                        goto free_scratch_pages;
+                }
+        }
+#endif
+        ret = misc_register(&cached_miscdev);
+        if (ret) {
+                printk(KERN_ERR "%s: failed to register device %i\n",
+                       CACHED_ID, ret);
+                if (is_sn2)
+                        misc_deregister(&fetchop_miscdev);
+                goto free_scratch_pages;
+        }
+        ret = misc_register(&uncached_miscdev);
+        if (ret) {
+                printk(KERN_ERR "%s: failed to register device %i\n",
+                       UNCACHED_ID, ret);
+                misc_deregister(&cached_miscdev);
+                if (is_sn2)
+                        misc_deregister(&fetchop_miscdev);
+                goto free_scratch_pages;
+        }
+
+        printk(KERN_INFO "%s %s initialized devices: %s %s %s\n",
+               MSPEC_BASENAME, REVISION, is_sn2 ? FETCHOP_ID : "",
+               CACHED_ID, UNCACHED_ID);
+
+        return 0;
+
+ free_scratch_pages:
+        for_each_node(nid) {
+                if (scratch_page[nid] != 0)
+                        uncached_free_page(scratch_page[nid]);
+        }
+        return ret;
+}
+
+static void __exit
+mspec_exit(void)
+{
+        int nid;
+
+        misc_deregister(&uncached_miscdev);
+        misc_deregister(&cached_miscdev);
+        if (is_sn2) {
+                misc_deregister(&fetchop_miscdev);
+
+                for_each_node(nid) {
+                        if (scratch_page[nid] != 0)
+                                uncached_free_page(scratch_page[nid]);
+                }
+        }
+}
+
+module_init(mspec_init);
+module_exit(mspec_exit);
+
+MODULE_AUTHOR("Silicon Graphics, Inc. <linux-altix@sgi.com>");
+MODULE_DESCRIPTION("Driver for SGI SN special memory operations");
+MODULE_LICENSE("GPL");
diff --git a/drivers/char/mwave/README b/drivers/char/mwave/README
index 70f8d19fb79f..480251fc78e2 100644
--- a/drivers/char/mwave/README
+++ b/drivers/char/mwave/README
@@ -41,10 +41,7 @@ Example to enable the 3780i DSP using ttyS1 resources:
 Accessing the driver
 --------------------
 
-You must also create a node for the driver.  Without devfs:
+You must also create a node for the driver:
   mkdir -p /dev/modems
   mknod --mode=660 /dev/modems/mwave c 10 219
-With devfs:
-  mkdir -p /dev/modems
-  ln -s ../misc/mwave /dev/modems/mwave
 
diff --git a/drivers/char/mwave/mwavedd.c b/drivers/char/mwave/mwavedd.c
index 39a2e661ff55..8d14823b0514 100644
--- a/drivers/char/mwave/mwavedd.c
+++ b/drivers/char/mwave/mwavedd.c
@@ -297,7 +297,7 @@ static int mwave_ioctl(struct inode *inode, struct file *file,
                                 " ipcnum %x, usIntCount %x\n",
                                 ipcnum,
                                 pDrvData->IPCs[ipcnum].usIntCount);
-                        if (ipcnum > ARRAY_SIZE(pDrvData->IPCs)) {
+                        if (ipcnum >= ARRAY_SIZE(pDrvData->IPCs)) {
                                 PRINTK_ERROR(KERN_ERR_MWAVE
                                                 "mwavedd::mwave_ioctl:"
                                                 " IOCTL_MW_GET_IPC: Error:"
@@ -355,7 +355,7 @@ static int mwave_ioctl(struct inode *inode, struct file *file,
                                 "mwavedd::mwave_ioctl IOCTL_MW_UNREGISTER_IPC"
                                 " ipcnum %x\n",
                                 ipcnum);
-                        if (ipcnum > ARRAY_SIZE(pDrvData->IPCs)) {
+                        if (ipcnum >= ARRAY_SIZE(pDrvData->IPCs)) {
                                 PRINTK_ERROR(KERN_ERR_MWAVE
                                                 "mwavedd::mwave_ioctl:"
                                                 " IOCTL_MW_UNREGISTER_IPC:"
diff --git a/drivers/char/mwave/tp3780i.c b/drivers/char/mwave/tp3780i.c
index cc3e54dd7234..f282976daaac 100644
--- a/drivers/char/mwave/tp3780i.c
+++ b/drivers/char/mwave/tp3780i.c
@@ -95,14 +95,14 @@ static void EnableSRAM(THINKPAD_BD_DATA * pBDData)
 }
 
 
-static irqreturn_t UartInterrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t UartInterrupt(int irq, void *dev_id)
 {
         PRINTK_3(TRACE_TP3780I,
                 "tp3780i::UartInterrupt entry irq %x dev_id %p\n", irq, dev_id);
         return IRQ_HANDLED;
 }
 
-static irqreturn_t DspInterrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t DspInterrupt(int irq, void *dev_id)
 {
         pMWAVE_DEVICE_DATA pDrvData = &mwave_s_mdd;
         DSP_3780I_CONFIG_SETTINGS *pSettings = &pDrvData->rBDData.rDspSettings;
diff --git a/drivers/char/mxser.c b/drivers/char/mxser.c
index 556abd3e0d07..c063359baf78 100644
--- a/drivers/char/mxser.c
+++ b/drivers/char/mxser.c
@@ -328,8 +328,8 @@ struct mxser_struct {
         int xmit_tail;
         int xmit_cnt;
         struct work_struct tqueue;
-        struct termios normal_termios;
-        struct termios callout_termios;
+        struct ktermios normal_termios;
+        struct ktermios callout_termios;
         wait_queue_head_t open_wait;
         wait_queue_head_t close_wait;
         wait_queue_head_t delta_msr_wait;
@@ -364,8 +364,8 @@ static int mxserBoardCAP[MXSER_BOARDS] = {
 static struct tty_driver *mxvar_sdriver;
 static struct mxser_struct mxvar_table[MXSER_PORTS];
 static struct tty_struct *mxvar_tty[MXSER_PORTS + 1];
-static struct termios *mxvar_termios[MXSER_PORTS + 1];
-static struct termios *mxvar_termios_locked[MXSER_PORTS + 1];
+static struct ktermios *mxvar_termios[MXSER_PORTS + 1];
+static struct ktermios *mxvar_termios_locked[MXSER_PORTS + 1];
 static struct mxser_log mxvar_log;
 static int mxvar_diagflag;
 static unsigned char mxser_msr[MXSER_PORTS + 1];
@@ -389,7 +389,7 @@ static int mxser_init(void);
 /* static void   mxser_poll(unsigned long); */
 static int mxser_get_ISA_conf(int, struct mxser_hwconf *);
 static int mxser_get_PCI_conf(int, int, int, struct mxser_hwconf *);
-static void mxser_do_softint(void *);
+static void mxser_do_softint(struct work_struct *);
 static int mxser_open(struct tty_struct *, struct file *);
 static void mxser_close(struct tty_struct *, struct file *);
 static int mxser_write(struct tty_struct *, const unsigned char *, int);
@@ -402,19 +402,19 @@ static int mxser_ioctl(struct tty_struct *, struct file *, uint, ulong);
 static int mxser_ioctl_special(unsigned int, void __user *);
 static void mxser_throttle(struct tty_struct *);
 static void mxser_unthrottle(struct tty_struct *);
-static void mxser_set_termios(struct tty_struct *, struct termios *);
+static void mxser_set_termios(struct tty_struct *, struct ktermios *);
 static void mxser_stop(struct tty_struct *);
 static void mxser_start(struct tty_struct *);
 static void mxser_hangup(struct tty_struct *);
 static void mxser_rs_break(struct tty_struct *, int);
-static irqreturn_t mxser_interrupt(int, void *, struct pt_regs *);
+static irqreturn_t mxser_interrupt(int, void *);
 static void mxser_receive_chars(struct mxser_struct *, int *);
 static void mxser_transmit_chars(struct mxser_struct *);
 static void mxser_check_modem_status(struct mxser_struct *, int);
 static int mxser_block_til_ready(struct tty_struct *, struct file *, struct mxser_struct *);
 static int mxser_startup(struct mxser_struct *);
 static void mxser_shutdown(struct mxser_struct *);
-static int mxser_change_speed(struct mxser_struct *, struct termios *old_termios);
+static int mxser_change_speed(struct mxser_struct *, struct ktermios *old_termios);
 static int mxser_get_serial_info(struct mxser_struct *, struct serial_struct __user *);
 static int mxser_set_serial_info(struct mxser_struct *, struct serial_struct __user *);
 static int mxser_get_lsr_info(struct mxser_struct *, unsigned int __user *);
@@ -453,7 +453,7 @@ static int CheckIsMoxaMust(int io)
 
 /* above is modified by Victor Yu. 08-15-2002 */
 
-static struct tty_operations mxser_ops = {
+static const struct tty_operations mxser_ops = {
         .open = mxser_open,
         .close = mxser_close,
         .write = mxser_write,
@@ -515,6 +515,7 @@ static void __exit mxser_module_exit(void)
                         if (pdev != NULL) {     /* PCI */
                                 release_region(pci_resource_start(pdev, 2), pci_resource_len(pdev, 2));
                                 release_region(pci_resource_start(pdev, 3), pci_resource_len(pdev, 3));
+                                pci_dev_put(pdev);
                         } else {
                                 release_region(mxsercfg[i].ioaddr[0], 8 * mxsercfg[i].ports);
                                 release_region(mxsercfg[i].vector, 1);
@@ -556,7 +557,7 @@ static int mxser_initbrd(int board, struct mxser_hwconf *hwconf)
         n = board * MXSER_PORTS_PER_BOARD;
         info = &mxvar_table[n];
         /*if (verbose) */  {
-                printk(KERN_DEBUG "        ttyM%d - ttyM%d ",
+                printk(KERN_DEBUG "        ttyMI%d - ttyMI%d ",
                         n, n + hwconf->ports - 1);
                 printk(" max. baud rate = %d bps.\n",
                         hwconf->MaxCanSetBaudRate[0]);
@@ -590,7 +591,7 @@ static int mxser_initbrd(int board, struct mxser_hwconf *hwconf)
                 info->custom_divisor = hwconf->baud_base[i] * 16;
                 info->close_delay = 5 * HZ / 10;
                 info->closing_wait = 30 * HZ;
-                INIT_WORK(&info->tqueue, mxser_do_softint, info);
+                INIT_WORK(&info->tqueue, mxser_do_softint);
                 info->normal_termios = mxvar_sdriver->init_termios;
                 init_waitqueue_head(&info->open_wait);
                 init_waitqueue_head(&info->close_wait);
@@ -717,7 +718,7 @@ static int mxser_init(void)
         /* Initialize the tty_driver structure */
         memset(mxvar_sdriver, 0, sizeof(struct tty_driver));
         mxvar_sdriver->magic = TTY_DRIVER_MAGIC;
-        mxvar_sdriver->name = "ttyM";
+        mxvar_sdriver->name = "ttyMI";
         mxvar_sdriver->major = ttymajor;
         mxvar_sdriver->minor_start = 0;
         mxvar_sdriver->num = MXSER_PORTS + 1;
@@ -725,6 +726,8 @@ static int mxser_init(void)
         mxvar_sdriver->subtype = SERIAL_TYPE_NORMAL;
         mxvar_sdriver->init_termios = tty_std_termios;
         mxvar_sdriver->init_termios.c_cflag = B9600|CS8|CREAD|HUPCL|CLOCAL;
+        mxvar_sdriver->init_termios.c_ispeed = 9600;
+        mxvar_sdriver->init_termios.c_ospeed = 9600;
         mxvar_sdriver->flags = TTY_DRIVER_REAL_RAW;
         tty_set_operations(mxvar_sdriver, &mxser_ops);
         mxvar_sdriver->ttys = mxvar_tty;
@@ -839,9 +842,9 @@ static int mxser_init(void)
         index = 0;
         b = 0;
         while (b < n) {
-                pdev = pci_find_device(mxser_pcibrds[b].vendor,
+                pdev = pci_get_device(mxser_pcibrds[b].vendor,
                                 mxser_pcibrds[b].device, pdev);
-                        if (pdev == NULL) {
+                if (pdev == NULL) {
                         b++;
                         continue;
                 }
@@ -893,6 +896,9 @@ static int mxser_init(void)
                         if (mxser_initbrd(m, &hwconf) < 0)
                                 continue;
                         m++;
+                        /* Keep an extra reference if we succeeded. It will
+                           be returned at unload time */
+                        pci_dev_get(pdev);
                 }
         }
 #endif
@@ -917,9 +923,10 @@ static int mxser_init(void)
         return 0;
 }
 
-static void mxser_do_softint(void *private_)
+static void mxser_do_softint(struct work_struct *work)
 {
-        struct mxser_struct *info = private_;
+        struct mxser_struct *info =
+                container_of(work, struct mxser_struct, tqueue);
         struct tty_struct *tty;
 
         tty = info->tty;
@@ -993,7 +1000,7 @@ static int mxser_open(struct tty_struct *tty, struct file *filp)
                 mxser_change_speed(info, NULL);
         }
 
-        info->session = current->signal->session;
+        info->session = process_session(current);
         info->pgrp = process_group(current);
 
         /*
@@ -1744,7 +1751,7 @@ static void mxser_unthrottle(struct tty_struct *tty)
         /* MX_UNLOCK(&info->slock); */
 }
 
-static void mxser_set_termios(struct tty_struct *tty, struct termios *old_termios)
+static void mxser_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
 {
         struct mxser_struct *info = tty->driver_data;
         unsigned long flags;
@@ -1916,7 +1923,7 @@ static void mxser_rs_break(struct tty_struct *tty, int break_state)
 /*
  * This is the serial driver's generic interrupt routine
  */
-static irqreturn_t mxser_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t mxser_interrupt(int irq, void *dev_id)
 {
         int status, iir, i;
         struct mxser_struct *info;
@@ -2536,7 +2543,7 @@ static void mxser_shutdown(struct mxser_struct *info)
  * This routine is called to set the UART divisor registers to match
  * the specified baud rate for a serial port.
  */
-static int mxser_change_speed(struct mxser_struct *info, struct termios *old_termios)
+static int mxser_change_speed(struct mxser_struct *info, struct ktermios *old_termios)
 {
         unsigned cflag, cval, fcr;
         int ret = 0;
@@ -2554,71 +2561,7 @@ static int mxser_change_speed(struct mxser_struct *info, struct termios *old_ter
 #define B921600 (B460800 +1)
 #endif
         if (mxser_set_baud_method[info->port] == 0) {
-                switch (cflag & (CBAUD | CBAUDEX)) {
-                case B921600:
-                        baud = 921600;
-                        break;
-                case B460800:
-                        baud = 460800;
-                        break;
-                case B230400:
-                        baud = 230400;
-                        break;
-                case B115200:
-                        baud = 115200;
-                        break;
-                case B57600:
-                        baud = 57600;
-                        break;
-                case B38400:
-                        baud = 38400;
-                        break;
-                case B19200:
-                        baud = 19200;
-                        break;
-                case B9600:
-                        baud = 9600;
-                        break;
-                case B4800:
-                        baud = 4800;
-                        break;
-                case B2400:
-                        baud = 2400;
-                        break;
-                case B1800:
-                        baud = 1800;
-                        break;
-                case B1200:
-                        baud = 1200;
-                        break;
-                case B600:
-                        baud = 600;
-                        break;
-                case B300:
-                        baud = 300;
-                        break;
-                case B200:
-                        baud = 200;
-                        break;
-                case B150:
-                        baud = 150;
-                        break;
-                case B134:
-                        baud = 134;
-                        break;
-                case B110:
-                        baud = 110;
-                        break;
-                case B75:
-                        baud = 75;
-                        break;
-                case B50:
-                        baud = 50;
-                        break;
-                default:
-                        baud = 0;
-                        break;
-                }
+                baud = tty_get_baud_rate(info->tty);
                 mxser_set_baud(info, baud);
         }
 
diff --git a/drivers/char/mxser_new.c b/drivers/char/mxser_new.c
new file mode 100644
index 000000000000..efa8076c33e0
--- /dev/null
+++ b/drivers/char/mxser_new.c
@@ -0,0 +1,2804 @@
+/*
+ *          mxser.c  -- MOXA Smartio/Industio family multiport serial driver.
+ *
+ *      Copyright (C) 1999-2006  Moxa Technologies (support@moxa.com.tw).
+ *      Copyright (C) 2006       Jiri Slaby <jirislaby@gmail.com>
+ *
+ *      This code is loosely based on the 1.8 moxa driver which is based on
+ *      Linux serial driver, written by Linus Torvalds, Theodore T'so and
+ *      others.
+ *
+ *      This program is free software; you can redistribute it and/or modify
+ *      it under the terms of the GNU General Public License as published by
+ *      the Free Software Foundation; either version 2 of the License, or
+ *      (at your option) any later version.
+ *
+ *      Fed through a cleanup, indent and remove of non 2.6 code by Alan Cox
+ *      <alan@redhat.com>. The original 1.8 code is available on www.moxa.com.
+ *      - Fixed x86_64 cleanness
+ *      - Fixed sleep with spinlock held in mxser_send_break
+ */
+
+#include <linux/module.h>
+#include <linux/autoconf.h>
+#include <linux/errno.h>
+#include <linux/signal.h>
+#include <linux/sched.h>
+#include <linux/timer.h>
+#include <linux/interrupt.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+#include <linux/serial.h>
+#include <linux/serial_reg.h>
+#include <linux/major.h>
+#include <linux/string.h>
+#include <linux/fcntl.h>
+#include <linux/ptrace.h>
+#include <linux/gfp.h>
+#include <linux/ioport.h>
+#include <linux/mm.h>
+#include <linux/smp_lock.h>
+#include <linux/delay.h>
+#include <linux/pci.h>
+
+#include <asm/system.h>
+#include <asm/io.h>
+#include <asm/irq.h>
+#include <asm/bitops.h>
+#include <asm/uaccess.h>
+
+#include "mxser_new.h"
+
+#define MXSER_VERSION   "2.0"
+#define MXSERMAJOR       174
+#define MXSERCUMAJOR     175
+
+#define MXSER_EVENT_TXLOW       1
+
+#define MXSER_BOARDS            4       /* Max. boards */
+#define MXSER_PORTS_PER_BOARD   8       /* Max. ports per board */
+#define MXSER_PORTS             (MXSER_BOARDS * MXSER_PORTS_PER_BOARD)
+#define MXSER_ISR_PASS_LIMIT    99999L
+
+#define MXSER_ERR_IOADDR        -1
+#define MXSER_ERR_IRQ           -2
+#define MXSER_ERR_IRQ_CONFLIT   -3
+#define MXSER_ERR_VECTOR        -4
+
+#define WAKEUP_CHARS            256
+
+#define UART_MCR_AFE            0x20
+#define UART_LSR_SPECIAL        0x1E
+
+#define RELEVANT_IFLAG(iflag)   (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK|\
+                                          IXON|IXOFF))
+
+#define C168_ASIC_ID    1
+#define C104_ASIC_ID    2
+#define C102_ASIC_ID    0xB
+#define CI132_ASIC_ID   4
+#define CI134_ASIC_ID   3
+#define CI104J_ASIC_ID  5
+
+#define MXSER_HIGHBAUD  1
+#define MXSER_HAS2      2
+
+/* This is only for PCI */
+static const struct {
+        int type;
+        int tx_fifo;
+        int rx_fifo;
+        int xmit_fifo_size;
+        int rx_high_water;
+        int rx_trigger;
+        int rx_low_water;
+        long max_baud;
+} Gpci_uart_info[] = {
+        {MOXA_OTHER_UART, 16, 16, 16, 14, 14, 1, 921600L},
+        {MOXA_MUST_MU150_HWID, 64, 64, 64, 48, 48, 16, 230400L},
+        {MOXA_MUST_MU860_HWID, 128, 128, 128, 96, 96, 32, 921600L}
+};
+#define UART_INFO_NUM   ARRAY_SIZE(Gpci_uart_info)
+
+struct mxser_cardinfo {
+        unsigned int nports;
+        char *name;
+        unsigned int flags;
+};
+
+static const struct mxser_cardinfo mxser_cards[] = {
+        { 8, "C168 series", },                  /* C168-ISA */
+        { 4, "C104 series", },                  /* C104-ISA */
+        { 4, "CI-104J series", },               /* CI104J */
+        { 8, "C168H/PCI series", },             /* C168-PCI */
+        { 4, "C104H/PCI series", },             /* C104-PCI */
+        { 4, "C102 series", MXSER_HAS2 },       /* C102-ISA */
+        { 4, "CI-132 series", MXSER_HAS2 },     /* CI132 */
+        { 4, "CI-134 series", },                /* CI134 */
+        { 2, "CP-132 series", },                /* CP132 */
+        { 4, "CP-114 series", },                /* CP114 */
+        { 4, "CT-114 series", },                /* CT114 */
+        { 2, "CP-102 series", MXSER_HIGHBAUD }, /* CP102 */
+        { 4, "CP-104U series", },               /* CP104U */
+        { 8, "CP-168U series", },               /* CP168U */
+        { 2, "CP-132U series", },               /* CP132U */
+        { 4, "CP-134U series", },               /* CP134U */
+        { 4, "CP-104JU series", },              /* CP104JU */
+        { 8, "Moxa UC7000 Serial", },           /* RC7000 */
+        { 8, "CP-118U series", },               /* CP118U */
+        { 2, "CP-102UL series", },              /* CP102UL */
+        { 2, "CP-102U series", },               /* CP102U */
+        { 8, "CP-118EL series", },              /* CP118EL */
+        { 8, "CP-168EL series", },              /* CP168EL */
+        { 4, "CP-104EL series", }               /* CP104EL */
+};
+
+/* driver_data correspond to the lines in the structure above
+   see also ISA probe function before you change something */
+static struct pci_device_id mxser_pcibrds[] = {
+        { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_C168),
+                .driver_data = 3 },
+        { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_C104),
+                .driver_data = 4 },
+        { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP132),
+                .driver_data = 8 },
+        { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP114),
+                .driver_data = 9 },
+        { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CT114),
+                .driver_data = 10 },
+        { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP102),
+                .driver_data = 11 },
+        { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP104U),
+                .driver_data = 12 },
+        { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP168U),
+                .driver_data = 13 },
+        { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP132U),
+                .driver_data = 14 },
+        { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP134U),
+                .driver_data = 15 },
+        { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP104JU),
+                .driver_data = 16 },
+        { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_RC7000),
+                .driver_data = 17 },
+        { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP118U),
+                .driver_data = 18 },
+        { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP102UL),
+                .driver_data = 19 },
+        { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP102U),
+                .driver_data = 20 },
+        { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP118EL),
+                .driver_data = 21 },
+        { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP168EL),
+                .driver_data = 22 },
+        { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP104EL),
+                .driver_data = 23 },
+        { }
+};
+MODULE_DEVICE_TABLE(pci, mxser_pcibrds);
+
+static int ioaddr[MXSER_BOARDS] = { 0, 0, 0, 0 };
+static int ttymajor = MXSERMAJOR;
+static int calloutmajor = MXSERCUMAJOR;
+
+/* Variables for insmod */
+
+MODULE_AUTHOR("Casper Yang");
+MODULE_DESCRIPTION("MOXA Smartio/Industio Family Multiport Board Device Driver");
+module_param_array(ioaddr, int, NULL, 0);
+module_param(ttymajor, int, 0);
+MODULE_LICENSE("GPL");
+
+struct mxser_log {
+        int tick;
+        unsigned long rxcnt[MXSER_PORTS];
+        unsigned long txcnt[MXSER_PORTS];
+};
+
+
+struct mxser_mon {
+        unsigned long rxcnt;
+        unsigned long txcnt;
+        unsigned long up_rxcnt;
+        unsigned long up_txcnt;
+        int modem_status;
+        unsigned char hold_reason;
+};
+
+struct mxser_mon_ext {
+        unsigned long rx_cnt[32];
+        unsigned long tx_cnt[32];
+        unsigned long up_rxcnt[32];
+        unsigned long up_txcnt[32];
+        int modem_status[32];
+
+        long baudrate[32];
+        int databits[32];
+        int stopbits[32];
+        int parity[32];
+        int flowctrl[32];
+        int fifo[32];
+        int iftype[32];
+};
+
+struct mxser_board;
+
+struct mxser_port {
+        struct mxser_board *board;
+        struct tty_struct *tty;
+
+        unsigned long ioaddr;
+        unsigned long opmode_ioaddr;
+        int max_baud;
+
+        int rx_high_water;
+        int rx_trigger;         /* Rx fifo trigger level */
+        int rx_low_water;
+        int baud_base;          /* max. speed */
+        long realbaud;
+        int type;               /* UART type */
+        int flags;              /* defined in tty.h */
+        long session;           /* Session of opening process */
+        long pgrp;              /* pgrp of opening process */
+
+        int x_char;             /* xon/xoff character */
+        int IER;                /* Interrupt Enable Register */
+        int MCR;                /* Modem control register */
+
+        unsigned char stop_rx;
+        unsigned char ldisc_stop_rx;
+
+        int custom_divisor;
+        int close_delay;
+        unsigned short closing_wait;
+        unsigned char err_shadow;
+        unsigned long event;
+
+        int count;              /* # of fd on device */
+        int blocked_open;       /* # of blocked opens */
+        struct async_icount icount; /* kernel counters for 4 input interrupts */
+        int timeout;
+
+        int read_status_mask;
+        int ignore_status_mask;
+        int xmit_fifo_size;
+        unsigned char *xmit_buf;
+        int xmit_head;
+        int xmit_tail;
+        int xmit_cnt;
+
+        struct ktermios normal_termios;
+        struct ktermios callout_termios;
+
+        struct mxser_mon mon_data;
+
+        spinlock_t slock;
+        struct work_struct tqueue;
+        wait_queue_head_t open_wait;
+        wait_queue_head_t close_wait;
+        wait_queue_head_t delta_msr_wait;
+};
+
+struct mxser_board {
+        unsigned int idx;
+        int irq;
+        const struct mxser_cardinfo *info;
+        unsigned long vector;
+        unsigned long vector_mask;
+
+        int chip_flag;
+        int uart_type;
+
+        struct mxser_port ports[MXSER_PORTS_PER_BOARD];
+};
+
+struct mxser_mstatus {
+        tcflag_t cflag;
+        int cts;
+        int dsr;
+        int ri;
+        int dcd;
+};
+
+static struct mxser_mstatus GMStatus[MXSER_PORTS];
+
+static int mxserBoardCAP[MXSER_BOARDS] = {
+        0, 0, 0, 0
+        /*  0x180, 0x280, 0x200, 0x320 */
+};
+
+static struct mxser_board mxser_boards[MXSER_BOARDS];
+static struct tty_driver *mxvar_sdriver;
+static struct mxser_log mxvar_log;
+static int mxvar_diagflag;
+static unsigned char mxser_msr[MXSER_PORTS + 1];
+static struct mxser_mon_ext mon_data_ext;
+static int mxser_set_baud_method[MXSER_PORTS + 1];
+static spinlock_t gm_lock;
+
+static int CheckIsMoxaMust(int io)
+{
+        u8 oldmcr, hwid;
+        int i;
+
+        outb(0, io + UART_LCR);
+        DISABLE_MOXA_MUST_ENCHANCE_MODE(io);
+        oldmcr = inb(io + UART_MCR);
+        outb(0, io + UART_MCR);
+        SET_MOXA_MUST_XON1_VALUE(io, 0x11);
+        if ((hwid = inb(io + UART_MCR)) != 0) {
+                outb(oldmcr, io + UART_MCR);
+                return MOXA_OTHER_UART;
+        }
+
+        GET_MOXA_MUST_HARDWARE_ID(io, &hwid);
+        for (i = 1; i < UART_INFO_NUM; i++) { /* 0 = OTHER_UART */
+                if (hwid == Gpci_uart_info[i].type)
+                        return (int)hwid;
+        }
+        return MOXA_OTHER_UART;
+}
+
+static void process_txrx_fifo(struct mxser_port *info)
+{
+        int i;
+
+        if ((info->type == PORT_16450) || (info->type == PORT_8250)) {
+                info->rx_trigger = 1;
+                info->rx_high_water = 1;
+                info->rx_low_water = 1;
+                info->xmit_fifo_size = 1;
+        } else
+                for (i = 0; i < UART_INFO_NUM; i++)
+                        if (info->board->chip_flag == Gpci_uart_info[i].type) {
+                                info->rx_trigger = Gpci_uart_info[i].rx_trigger;
+                                info->rx_low_water = Gpci_uart_info[i].rx_low_water;
+                                info->rx_high_water = Gpci_uart_info[i].rx_high_water;
+                                info->xmit_fifo_size = Gpci_uart_info[i].xmit_fifo_size;
+                                break;
+                        }
+}
+
+static void mxser_do_softint(struct work_struct *work)
+{
+        struct mxser_port *info = container_of(work, struct mxser_port, tqueue);
+        struct tty_struct *tty = info->tty;
+
+        if (test_and_clear_bit(MXSER_EVENT_TXLOW, &info->event))
+                tty_wakeup(tty);
+}
+
+static unsigned char mxser_get_msr(int baseaddr, int mode, int port)
+{
+        unsigned char status = 0;
+
+        status = inb(baseaddr + UART_MSR);
+
+        mxser_msr[port] &= 0x0F;
+        mxser_msr[port] |= status;
+        status = mxser_msr[port];
+        if (mode)
+                mxser_msr[port] = 0;
+
+        return status;
+}
+
+static int mxser_block_til_ready(struct tty_struct *tty, struct file *filp,
+                struct mxser_port *port)
+{
+        DECLARE_WAITQUEUE(wait, current);
+        int retval;
+        int do_clocal = 0;
+        unsigned long flags;
+
+        /*
+         * If non-blocking mode is set, or the port is not enabled,
+         * then make the check up front and then exit.
+         */
+        if ((filp->f_flags & O_NONBLOCK) ||
+                        test_bit(TTY_IO_ERROR, &tty->flags)) {
+                port->flags |= ASYNC_NORMAL_ACTIVE;
+                return 0;
+        }
+
+        if (tty->termios->c_cflag & CLOCAL)
+                do_clocal = 1;
+
+        /*
+         * Block waiting for the carrier detect and the line to become
+         * free (i.e., not in use by the callout).  While we are in
+         * this loop, port->count is dropped by one, so that
+         * mxser_close() knows when to free things.  We restore it upon
+         * exit, either normal or abnormal.
+         */
+        retval = 0;
+        add_wait_queue(&port->open_wait, &wait);
+
+        spin_lock_irqsave(&port->slock, flags);
+        if (!tty_hung_up_p(filp))
+                port->count--;
+        spin_unlock_irqrestore(&port->slock, flags);
+        port->blocked_open++;
+        while (1) {
+                spin_lock_irqsave(&port->slock, flags);
+                outb(inb(port->ioaddr + UART_MCR) |
+                        UART_MCR_DTR | UART_MCR_RTS, port->ioaddr + UART_MCR);
+                spin_unlock_irqrestore(&port->slock, flags);
+                set_current_state(TASK_INTERRUPTIBLE);
+                if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
+                        if (port->flags & ASYNC_HUP_NOTIFY)
+                                retval = -EAGAIN;
+                        else
+                                retval = -ERESTARTSYS;
+                        break;
+                }
+                if (!(port->flags & ASYNC_CLOSING) &&
+                                (do_clocal ||
+                                (inb(port->ioaddr + UART_MSR) & UART_MSR_DCD)))
+                        break;
+                if (signal_pending(current)) {
+                        retval = -ERESTARTSYS;
+                        break;
+                }
+                schedule();
+        }
+        set_current_state(TASK_RUNNING);
+        remove_wait_queue(&port->open_wait, &wait);
+        if (!tty_hung_up_p(filp))
+                port->count++;
+        port->blocked_open--;
+        if (retval)
+                return retval;
+        port->flags |= ASYNC_NORMAL_ACTIVE;
+        return 0;
+}
+
+static int mxser_set_baud(struct mxser_port *info, long newspd)
+{
+        int quot = 0;
+        unsigned char cval;
+        int ret = 0;
+        unsigned long flags;
+
+        if (!info->tty || !info->tty->termios)
+                return ret;
+
+        if (!(info->ioaddr))
+                return ret;
+
+        if (newspd > info->max_baud)
+                return 0;
+
+        info->realbaud = newspd;
+        if (newspd == 134) {
+                quot = (2 * info->baud_base / 269);
+        } else if (newspd) {
+                quot = info->baud_base / newspd;
+                if (quot == 0)
+                        quot = 1;
+        } else {
+                quot = 0;
+        }
+
+        info->timeout = ((info->xmit_fifo_size * HZ * 10 * quot) / info->baud_base);
+        info->timeout += HZ / 50;       /* Add .02 seconds of slop */
+
+        if (quot) {
+                spin_lock_irqsave(&info->slock, flags);
+                info->MCR |= UART_MCR_DTR;
+                outb(info->MCR, info->ioaddr + UART_MCR);
+                spin_unlock_irqrestore(&info->slock, flags);
+        } else {
+                spin_lock_irqsave(&info->slock, flags);
+                info->MCR &= ~UART_MCR_DTR;
+                outb(info->MCR, info->ioaddr + UART_MCR);
+                spin_unlock_irqrestore(&info->slock, flags);
+                return ret;
+        }
+
+        cval = inb(info->ioaddr + UART_LCR);
+
+        outb(cval | UART_LCR_DLAB, info->ioaddr + UART_LCR);    /* set DLAB */
+
+        outb(quot & 0xff, info->ioaddr + UART_DLL);     /* LS of divisor */
+        outb(quot >> 8, info->ioaddr + UART_DLM);       /* MS of divisor */
+        outb(cval, info->ioaddr + UART_LCR);    /* reset DLAB */
+
+
+        return ret;
+}
+
+/*
+ * This routine is called to set the UART divisor registers to match
+ * the specified baud rate for a serial port.
+ */
+static int mxser_change_speed(struct mxser_port *info,
+                struct ktermios *old_termios)
+{
+        unsigned cflag, cval, fcr;
+        int ret = 0;
+        unsigned char status;
+        long baud;
+        unsigned long flags;
+
+        if (!info->tty || !info->tty->termios)
+                return ret;
+        cflag = info->tty->termios->c_cflag;
+        if (!(info->ioaddr))
+                return ret;
+
+        if (mxser_set_baud_method[info->tty->index] == 0) {
+                baud = tty_get_baud_rate(info->tty);
+                mxser_set_baud(info, baud);
+        }
+
+        /* byte size and parity */
+        switch (cflag & CSIZE) {
+        case CS5:
+                cval = 0x00;
+                break;
+        case CS6:
+                cval = 0x01;
+                break;
+        case CS7:
+                cval = 0x02;
+                break;
+        case CS8:
+                cval = 0x03;
+                break;
+        default:
+                cval = 0x00;
+                break;          /* too keep GCC shut... */
+        }
+        if (cflag & CSTOPB)
+                cval |= 0x04;
+        if (cflag & PARENB)
+                cval |= UART_LCR_PARITY;
+        if (!(cflag & PARODD))
+                cval |= UART_LCR_EPAR;
+        if (cflag & CMSPAR)
+                cval |= UART_LCR_SPAR;
+
+        if ((info->type == PORT_8250) || (info->type == PORT_16450)) {
+                if (info->board->chip_flag) {
+                        fcr = UART_FCR_ENABLE_FIFO;
+                        fcr |= MOXA_MUST_FCR_GDA_MODE_ENABLE;
+                        SET_MOXA_MUST_FIFO_VALUE(info);
+                } else
+                        fcr = 0;
+        } else {
+                fcr = UART_FCR_ENABLE_FIFO;
+                if (info->board->chip_flag) {
+                        fcr |= MOXA_MUST_FCR_GDA_MODE_ENABLE;
+                        SET_MOXA_MUST_FIFO_VALUE(info);
+                } else {
+                        switch (info->rx_trigger) {
+                        case 1:
+                                fcr |= UART_FCR_TRIGGER_1;
+                                break;
+                        case 4:
+                                fcr |= UART_FCR_TRIGGER_4;
+                                break;
+                        case 8:
+                                fcr |= UART_FCR_TRIGGER_8;
+                                break;
+                        default:
+                                fcr |= UART_FCR_TRIGGER_14;
+                                break;
+                        }
+                }
+        }
+
+        /* CTS flow control flag and modem status interrupts */
+        info->IER &= ~UART_IER_MSI;
+        info->MCR &= ~UART_MCR_AFE;
+        if (cflag & CRTSCTS) {
+                info->flags |= ASYNC_CTS_FLOW;
+                info->IER |= UART_IER_MSI;
+                if ((info->type == PORT_16550A) || (info->board->chip_flag)) {
+                        info->MCR |= UART_MCR_AFE;
+                } else {
+                        status = inb(info->ioaddr + UART_MSR);
+                        if (info->tty->hw_stopped) {
+                                if (status & UART_MSR_CTS) {
+                                        info->tty->hw_stopped = 0;
+                                        if (info->type != PORT_16550A &&
+                                                        !info->board->chip_flag) {
+                                                outb(info->IER & ~UART_IER_THRI,
+                                                        info->ioaddr +
+                                                        UART_IER);
+                                                info->IER |= UART_IER_THRI;
+                                                outb(info->IER, info->ioaddr +
+                                                                UART_IER);
+                                        }
+                                        set_bit(MXSER_EVENT_TXLOW, &info->event);
+                                        schedule_work(&info->tqueue);                           }
+                        } else {
+                                if (!(status & UART_MSR_CTS)) {
+                                        info->tty->hw_stopped = 1;
+                                        if ((info->type != PORT_16550A) &&
+                                                        (!info->board->chip_flag)) {
+                                                info->IER &= ~UART_IER_THRI;
+                                                outb(info->IER, info->ioaddr +
+                                                                UART_IER);
+                                        }
+                                }
+                        }
+                }
+        } else {
+                info->flags &= ~ASYNC_CTS_FLOW;
+        }
+        outb(info->MCR, info->ioaddr + UART_MCR);
+        if (cflag & CLOCAL) {
+                info->flags &= ~ASYNC_CHECK_CD;
+        } else {
+                info->flags |= ASYNC_CHECK_CD;
+                info->IER |= UART_IER_MSI;
+        }
+        outb(info->IER, info->ioaddr + UART_IER);
+
+        /*
+         * Set up parity check flag
+         */
+        info->read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR;
+        if (I_INPCK(info->tty))
+                info->read_status_mask |= UART_LSR_FE | UART_LSR_PE;
+        if (I_BRKINT(info->tty) || I_PARMRK(info->tty))
+                info->read_status_mask |= UART_LSR_BI;
+
+        info->ignore_status_mask = 0;
+
+        if (I_IGNBRK(info->tty)) {
+                info->ignore_status_mask |= UART_LSR_BI;
+                info->read_status_mask |= UART_LSR_BI;
+                /*
+                 * If we're ignore parity and break indicators, ignore
+                 * overruns too.  (For real raw support).
+                 */
+                if (I_IGNPAR(info->tty)) {
+                        info->ignore_status_mask |=
+                                                UART_LSR_OE |
+                                                UART_LSR_PE |
+                                                UART_LSR_FE;
+                        info->read_status_mask |=
+                                                UART_LSR_OE |
+                                                UART_LSR_PE |
+                                                UART_LSR_FE;
+                }
+        }
+        if (info->board->chip_flag) {
+                spin_lock_irqsave(&info->slock, flags);
+                SET_MOXA_MUST_XON1_VALUE(info->ioaddr, START_CHAR(info->tty));
+                SET_MOXA_MUST_XOFF1_VALUE(info->ioaddr, STOP_CHAR(info->tty));
+                if (I_IXON(info->tty)) {
+                        ENABLE_MOXA_MUST_RX_SOFTWARE_FLOW_CONTROL(info->ioaddr);
+                } else {
+                        DISABLE_MOXA_MUST_RX_SOFTWARE_FLOW_CONTROL(info->ioaddr);
+                }
+                if (I_IXOFF(info->tty)) {
+                        ENABLE_MOXA_MUST_TX_SOFTWARE_FLOW_CONTROL(info->ioaddr);
+                } else {
+                        DISABLE_MOXA_MUST_TX_SOFTWARE_FLOW_CONTROL(info->ioaddr);
+                }
+                spin_unlock_irqrestore(&info->slock, flags);
+        }
+
+
+        outb(fcr, info->ioaddr + UART_FCR);     /* set fcr */
+        outb(cval, info->ioaddr + UART_LCR);
+
+        return ret;
+}
+
+static void mxser_check_modem_status(struct mxser_port *port, int status)
+{
+        /* update input line counters */
+        if (status & UART_MSR_TERI)
+                port->icount.rng++;
+        if (status & UART_MSR_DDSR)
+                port->icount.dsr++;
+        if (status & UART_MSR_DDCD)
+                port->icount.dcd++;
+        if (status & UART_MSR_DCTS)
+                port->icount.cts++;
+        port->mon_data.modem_status = status;
+        wake_up_interruptible(&port->delta_msr_wait);
+
+        if ((port->flags & ASYNC_CHECK_CD) && (status & UART_MSR_DDCD)) {
+                if (status & UART_MSR_DCD)
+                        wake_up_interruptible(&port->open_wait);
+                schedule_work(&port->tqueue);
+        }
+
+        if (port->flags & ASYNC_CTS_FLOW) {
+                if (port->tty->hw_stopped) {
+                        if (status & UART_MSR_CTS) {
+                                port->tty->hw_stopped = 0;
+
+                                if ((port->type != PORT_16550A) &&
+                                                (!port->board->chip_flag)) {
+                                        outb(port->IER & ~UART_IER_THRI,
+                                                port->ioaddr + UART_IER);
+                                        port->IER |= UART_IER_THRI;
+                                        outb(port->IER, port->ioaddr +
+                                                        UART_IER);
+                                }
+                                set_bit(MXSER_EVENT_TXLOW, &port->event);
+                                schedule_work(&port->tqueue);
+                        }
+                } else {
+                        if (!(status & UART_MSR_CTS)) {
+                                port->tty->hw_stopped = 1;
+                                if (port->type != PORT_16550A &&
+                                                !port->board->chip_flag) {
+                                        port->IER &= ~UART_IER_THRI;
+                                        outb(port->IER, port->ioaddr +
+                                                        UART_IER);
+                                }
+                        }
+                }
+        }
+}
+
+static int mxser_startup(struct mxser_port *info)
+{
+        unsigned long page;
+        unsigned long flags;
+
+        page = __get_free_page(GFP_KERNEL);
+        if (!page)
+                return -ENOMEM;
+
+        spin_lock_irqsave(&info->slock, flags);
+
+        if (info->flags & ASYNC_INITIALIZED) {
+                free_page(page);
+                spin_unlock_irqrestore(&info->slock, flags);
+                return 0;
+        }
+
+        if (!info->ioaddr || !info->type) {
+                if (info->tty)
+                        set_bit(TTY_IO_ERROR, &info->tty->flags);
+                free_page(page);
+                spin_unlock_irqrestore(&info->slock, flags);
+                return 0;
+        }
+        if (info->xmit_buf)
+                free_page(page);
+        else
+                info->xmit_buf = (unsigned char *) page;
+
+        /*
+         * Clear the FIFO buffers and disable them
+         * (they will be reenabled in mxser_change_speed())
+         */
+        if (info->board->chip_flag)
+                outb((UART_FCR_CLEAR_RCVR |
+                        UART_FCR_CLEAR_XMIT |
+                        MOXA_MUST_FCR_GDA_MODE_ENABLE), info->ioaddr + UART_FCR);
+        else
+                outb((UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT),
+                        info->ioaddr + UART_FCR);
+
+        /*
+         * At this point there's no way the LSR could still be 0xFF;
+         * if it is, then bail out, because there's likely no UART
+         * here.
+         */
+        if (inb(info->ioaddr + UART_LSR) == 0xff) {
+                spin_unlock_irqrestore(&info->slock, flags);
+                if (capable(CAP_SYS_ADMIN)) {
+                        if (info->tty)
+                                set_bit(TTY_IO_ERROR, &info->tty->flags);
+                        return 0;
+                } else
+                        return -ENODEV;
+        }
+
+        /*
+         * Clear the interrupt registers.
+         */
+        (void) inb(info->ioaddr + UART_LSR);
+        (void) inb(info->ioaddr + UART_RX);
+        (void) inb(info->ioaddr + UART_IIR);
+        (void) inb(info->ioaddr + UART_MSR);
+
+        /*
+         * Now, initialize the UART
+         */
+        outb(UART_LCR_WLEN8, info->ioaddr + UART_LCR);  /* reset DLAB */
+        info->MCR = UART_MCR_DTR | UART_MCR_RTS;
+        outb(info->MCR, info->ioaddr + UART_MCR);
+
+        /*
+         * Finally, enable interrupts
+         */
+        info->IER = UART_IER_MSI | UART_IER_RLSI | UART_IER_RDI;
+
+        if (info->board->chip_flag)
+                info->IER |= MOXA_MUST_IER_EGDAI;
+        outb(info->IER, info->ioaddr + UART_IER);       /* enable interrupts */
+
+        /*
+         * And clear the interrupt registers again for luck.
+         */
+        (void) inb(info->ioaddr + UART_LSR);
+        (void) inb(info->ioaddr + UART_RX);
+        (void) inb(info->ioaddr + UART_IIR);
+        (void) inb(info->ioaddr + UART_MSR);
+
+        if (info->tty)
+                clear_bit(TTY_IO_ERROR, &info->tty->flags);
+        info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
+
+        /*
+         * and set the speed of the serial port
+         */
+        spin_unlock_irqrestore(&info->slock, flags);
+        mxser_change_speed(info, NULL);
+
+        info->flags |= ASYNC_INITIALIZED;
+        return 0;
+}
+
+/*
+ * This routine will shutdown a serial port; interrupts maybe disabled, and
+ * DTR is dropped if the hangup on close termio flag is on.
+ */
+static void mxser_shutdown(struct mxser_port *info)
+{
+        unsigned long flags;
+
+        if (!(info->flags & ASYNC_INITIALIZED))
+                return;
+
+        spin_lock_irqsave(&info->slock, flags);
+
+        /*
+         * clear delta_msr_wait queue to avoid mem leaks: we may free the irq
+         * here so the queue might never be waken up
+         */
+        wake_up_interruptible(&info->delta_msr_wait);
+
+        /*
+         * Free the IRQ, if necessary
+         */
+        if (info->xmit_buf) {
+                free_page((unsigned long) info->xmit_buf);
+                info->xmit_buf = NULL;
+        }
+
+        info->IER = 0;
+        outb(0x00, info->ioaddr + UART_IER);
+
+        if (!info->tty || (info->tty->termios->c_cflag & HUPCL))
+                info->MCR &= ~(UART_MCR_DTR | UART_MCR_RTS);
+        outb(info->MCR, info->ioaddr + UART_MCR);
+
+        /* clear Rx/Tx FIFO's */
+        if (info->board->chip_flag)
+                outb(UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT |
+                                MOXA_MUST_FCR_GDA_MODE_ENABLE,
+                                info->ioaddr + UART_FCR);
+        else
+                outb(UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT,
+                        info->ioaddr + UART_FCR);
+
+        /* read data port to reset things */
+        (void) inb(info->ioaddr + UART_RX);
+
+        if (info->tty)
+                set_bit(TTY_IO_ERROR, &info->tty->flags);
+
+        info->flags &= ~ASYNC_INITIALIZED;
+
+        if (info->board->chip_flag)
+                SET_MOXA_MUST_NO_SOFTWARE_FLOW_CONTROL(info->ioaddr);
+
+        spin_unlock_irqrestore(&info->slock, flags);
+}
+
+/*
+ * This routine is called whenever a serial port is opened.  It
+ * enables interrupts for a serial port, linking in its async structure into
+ * the IRQ chain.   It also performs the serial-specific
+ * initialization for the tty structure.
+ */
+static int mxser_open(struct tty_struct *tty, struct file *filp)
+{
+        struct mxser_port *info;
+        int retval, line;
+
+        /* initialize driver_data in case something fails */
+        tty->driver_data = NULL;
+
+        line = tty->index;
+        if (line == MXSER_PORTS)
+                return 0;
+        if (line < 0 || line > MXSER_PORTS)
+                return -ENODEV;
+        info = &mxser_boards[line / MXSER_PORTS_PER_BOARD].ports[line % MXSER_PORTS_PER_BOARD];
+        if (!info->ioaddr)
+                return -ENODEV;
+
+        tty->driver_data = info;
+        info->tty = tty;
+        /*
+         * Start up serial port
+         */
+        info->count++;
+        retval = mxser_startup(info);
+        if (retval)
+                return retval;
+
+        retval = mxser_block_til_ready(tty, filp, info);
+        if (retval)
+                return retval;
+
+        if ((info->count == 1) && (info->flags & ASYNC_SPLIT_TERMIOS)) {
+                if (tty->driver->subtype == SERIAL_TYPE_NORMAL)
+                        *tty->termios = info->normal_termios;
+                else
+                        *tty->termios = info->callout_termios;
+                mxser_change_speed(info, NULL);
+        }
+
+        info->session = process_session(current);
+        info->pgrp = process_group(current);
+
+        /* unmark here for very high baud rate (ex. 921600 bps) used */
+        tty->low_latency = 1;
+        return 0;
+}
+
+/*
+ * This routine is called when the serial port gets closed.  First, we
+ * wait for the last remaining data to be sent.  Then, we unlink its
+ * async structure from the interrupt chain if necessary, and we free
+ * that IRQ if nothing is left in the chain.
+ */
+static void mxser_close(struct tty_struct *tty, struct file *filp)
+{
+        struct mxser_port *info = tty->driver_data;
+
+        unsigned long timeout;
+        unsigned long flags;
+
+        if (tty->index == MXSER_PORTS)
+                return;
+        if (!info)
+                return;
+
+        spin_lock_irqsave(&info->slock, flags);
+
+        if (tty_hung_up_p(filp)) {
+                spin_unlock_irqrestore(&info->slock, flags);
+                return;
+        }
+        if ((tty->count == 1) && (info->count != 1)) {
+                /*
+                 * Uh, oh.  tty->count is 1, which means that the tty
+                 * structure will be freed.  Info->count should always
+                 * be one in these conditions.  If it's greater than
+                 * one, we've got real problems, since it means the
+                 * serial port won't be shutdown.
+                 */
+                printk(KERN_ERR "mxser_close: bad serial port count; "
+                        "tty->count is 1, info->count is %d\n", info->count);
+                info->count = 1;
+        }
+        if (--info->count < 0) {
+                printk(KERN_ERR "mxser_close: bad serial port count for "
+                        "ttys%d: %d\n", tty->index, info->count);
+                info->count = 0;
+        }
+        if (info->count) {
+                spin_unlock_irqrestore(&info->slock, flags);
+                return;
+        }
+        info->flags |= ASYNC_CLOSING;
+        spin_unlock_irqrestore(&info->slock, flags);
+        /*
+         * Save the termios structure, since this port may have
+         * separate termios for callout and dialin.
+         */
+        if (info->flags & ASYNC_NORMAL_ACTIVE)
+                info->normal_termios = *tty->termios;
+        /*
+         * Now we wait for the transmit buffer to clear; and we notify
+         * the line discipline to only process XON/XOFF characters.
+         */
+        tty->closing = 1;
+        if (info->closing_wait != ASYNC_CLOSING_WAIT_NONE)
+                tty_wait_until_sent(tty, info->closing_wait);
+        /*
+         * At this point we stop accepting input.  To do this, we
+         * disable the receive line status interrupts, and tell the
+         * interrupt driver to stop checking the data ready bit in the
+         * line status register.
+         */
+        info->IER &= ~UART_IER_RLSI;
+        if (info->board->chip_flag)
+                info->IER &= ~MOXA_MUST_RECV_ISR;
+
+        if (info->flags & ASYNC_INITIALIZED) {
+                outb(info->IER, info->ioaddr + UART_IER);
+                /*
+                 * Before we drop DTR, make sure the UART transmitter
+                 * has completely drained; this is especially
+                 * important if there is a transmit FIFO!
+                 */
+                timeout = jiffies + HZ;
+                while (!(inb(info->ioaddr + UART_LSR) & UART_LSR_TEMT)) {
+                        schedule_timeout_interruptible(5);
+                        if (time_after(jiffies, timeout))
+                                break;
+                }
+        }
+        mxser_shutdown(info);
+
+        if (tty->driver->flush_buffer)
+                tty->driver->flush_buffer(tty);
+
+        tty_ldisc_flush(tty);
+
+        tty->closing = 0;
+        info->event = 0;
+        info->tty = NULL;
+        if (info->blocked_open) {
+                if (info->close_delay)
+                        schedule_timeout_interruptible(info->close_delay);
+                wake_up_interruptible(&info->open_wait);
+        }
+
+        info->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
+        wake_up_interruptible(&info->close_wait);
+
+}
+
+static int mxser_write(struct tty_struct *tty, const unsigned char *buf, int count)
+{
+        int c, total = 0;
+        struct mxser_port *info = tty->driver_data;
+        unsigned long flags;
+
+        if (!info->xmit_buf)
+                return 0;
+
+        while (1) {
+                c = min_t(int, count, min(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
+                                          SERIAL_XMIT_SIZE - info->xmit_head));
+                if (c <= 0)
+                        break;
+
+                memcpy(info->xmit_buf + info->xmit_head, buf, c);
+                spin_lock_irqsave(&info->slock, flags);
+                info->xmit_head = (info->xmit_head + c) &
+                                  (SERIAL_XMIT_SIZE - 1);
+                info->xmit_cnt += c;
+                spin_unlock_irqrestore(&info->slock, flags);
+
+                buf += c;
+                count -= c;
+                total += c;
+        }
+
+        if (info->xmit_cnt && !tty->stopped) {
+                if (!tty->hw_stopped ||
+                                (info->type == PORT_16550A) ||
+                                (info->board->chip_flag)) {
+                        spin_lock_irqsave(&info->slock, flags);
+                        outb(info->IER & ~UART_IER_THRI, info->ioaddr +
+                                        UART_IER);
+                        info->IER |= UART_IER_THRI;
+                        outb(info->IER, info->ioaddr + UART_IER);
+                        spin_unlock_irqrestore(&info->slock, flags);
+                }
+        }
+        return total;
+}
+
+static void mxser_put_char(struct tty_struct *tty, unsigned char ch)
+{
+        struct mxser_port *info = tty->driver_data;
+        unsigned long flags;
+
+        if (!info->xmit_buf)
+                return;
+
+        if (info->xmit_cnt >= SERIAL_XMIT_SIZE - 1)
+                return;
+
+        spin_lock_irqsave(&info->slock, flags);
+        info->xmit_buf[info->xmit_head++] = ch;
+        info->xmit_head &= SERIAL_XMIT_SIZE - 1;
+        info->xmit_cnt++;
+        spin_unlock_irqrestore(&info->slock, flags);
+        if (!tty->stopped) {
+                if (!tty->hw_stopped ||
+                                (info->type == PORT_16550A) ||
+                                info->board->chip_flag) {
+                        spin_lock_irqsave(&info->slock, flags);
+                        outb(info->IER & ~UART_IER_THRI, info->ioaddr + UART_IER);
+                        info->IER |= UART_IER_THRI;
+                        outb(info->IER, info->ioaddr + UART_IER);
+                        spin_unlock_irqrestore(&info->slock, flags);
+                }
+        }
+}
+
+
+static void mxser_flush_chars(struct tty_struct *tty)
+{
+        struct mxser_port *info = tty->driver_data;
+        unsigned long flags;
+
+        if (info->xmit_cnt <= 0 ||
+                        tty->stopped ||
+                        !info->xmit_buf ||
+                        (tty->hw_stopped &&
+                         (info->type != PORT_16550A) &&
+                         (!info->board->chip_flag)
+                        ))
+                return;
+
+        spin_lock_irqsave(&info->slock, flags);
+
+        outb(info->IER & ~UART_IER_THRI, info->ioaddr + UART_IER);
+        info->IER |= UART_IER_THRI;
+        outb(info->IER, info->ioaddr + UART_IER);
+
+        spin_unlock_irqrestore(&info->slock, flags);
+}
+
+static int mxser_write_room(struct tty_struct *tty)
+{
+        struct mxser_port *info = tty->driver_data;
+        int ret;
+
+        ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
+        if (ret < 0)
+                ret = 0;
+        return ret;
+}
+
+static int mxser_chars_in_buffer(struct tty_struct *tty)
+{
+        struct mxser_port *info = tty->driver_data;
+        return info->xmit_cnt;
+}
+
+static void mxser_flush_buffer(struct tty_struct *tty)
+{
+        struct mxser_port *info = tty->driver_data;
+        char fcr;
+        unsigned long flags;
+
+
+        spin_lock_irqsave(&info->slock, flags);
+        info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
+
+        fcr = inb(info->ioaddr + UART_FCR);
+        outb((fcr | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT),
+                info->ioaddr + UART_FCR);
+        outb(fcr, info->ioaddr + UART_FCR);
+
+        spin_unlock_irqrestore(&info->slock, flags);
+
+        tty_wakeup(tty);
+}
+
+/*
+ * ------------------------------------------------------------
+ * friends of mxser_ioctl()
+ * ------------------------------------------------------------
+ */
+static int mxser_get_serial_info(struct mxser_port *info,
+                struct serial_struct __user *retinfo)
+{
+        struct serial_struct tmp;
+
+        if (!retinfo)
+                return -EFAULT;
+        memset(&tmp, 0, sizeof(tmp));
+        tmp.type = info->type;
+        tmp.line = info->tty->index;
+        tmp.port = info->ioaddr;
+        tmp.irq = info->board->irq;
+        tmp.flags = info->flags;
+        tmp.baud_base = info->baud_base;
+        tmp.close_delay = info->close_delay;
+        tmp.closing_wait = info->closing_wait;
+        tmp.custom_divisor = info->custom_divisor;
+        tmp.hub6 = 0;
+        if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
+                return -EFAULT;
+        return 0;
+}
+
+static int mxser_set_serial_info(struct mxser_port *info,
+                struct serial_struct __user *new_info)
+{
+        struct serial_struct new_serial;
+        unsigned int flags;
+        int retval = 0;
+
+        if (!new_info || !info->ioaddr)
+                return -EFAULT;
+        if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
+                return -EFAULT;
+
+        if ((new_serial.irq != info->board->irq) ||
+                        (new_serial.port != info->ioaddr) ||
+                        (new_serial.custom_divisor != info->custom_divisor) ||
+                        (new_serial.baud_base != info->baud_base))
+                return -EPERM;
+
+        flags = info->flags & ASYNC_SPD_MASK;
+
+        if (!capable(CAP_SYS_ADMIN)) {
+                if ((new_serial.baud_base != info->baud_base) ||
+                                (new_serial.close_delay != info->close_delay) ||
+                                ((new_serial.flags & ~ASYNC_USR_MASK) != (info->flags & ~ASYNC_USR_MASK)))
+                        return -EPERM;
+                info->flags = ((info->flags & ~ASYNC_USR_MASK) |
+                                (new_serial.flags & ASYNC_USR_MASK));
+        } else {
+                /*
+                 * OK, past this point, all the error checking has been done.
+                 * At this point, we start making changes.....
+                 */
+                info->flags = ((info->flags & ~ASYNC_FLAGS) |
+                                (new_serial.flags & ASYNC_FLAGS));
+                info->close_delay = new_serial.close_delay * HZ / 100;
+                info->closing_wait = new_serial.closing_wait * HZ / 100;
+                info->tty->low_latency =
+                                (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
+                info->tty->low_latency = 0;
+        }
+
+        info->type = new_serial.type;
+
+        process_txrx_fifo(info);
+
+        if (info->flags & ASYNC_INITIALIZED) {
+                if (flags != (info->flags & ASYNC_SPD_MASK))
+                        mxser_change_speed(info, NULL);
+        } else
+                retval = mxser_startup(info);
+
+        return retval;
+}
+
+/*
+ * mxser_get_lsr_info - get line status register info
+ *
+ * Purpose: Let user call ioctl() to get info when the UART physically
+ *          is emptied.  On bus types like RS485, the transmitter must
+ *          release the bus after transmitting. This must be done when
+ *          the transmit shift register is empty, not be done when the
+ *          transmit holding register is empty.  This functionality
+ *          allows an RS485 driver to be written in user space.
+ */
+static int mxser_get_lsr_info(struct mxser_port *info,
+                unsigned int __user *value)
+{
+        unsigned char status;
+        unsigned int result;
+        unsigned long flags;
+
+        spin_lock_irqsave(&info->slock, flags);
+        status = inb(info->ioaddr + UART_LSR);
+        spin_unlock_irqrestore(&info->slock, flags);
+        result = ((status & UART_LSR_TEMT) ? TIOCSER_TEMT : 0);
+        return put_user(result, value);
+}
+
+/*
+ * This routine sends a break character out the serial port.
+ */
+static void mxser_send_break(struct mxser_port *info, int duration)
+{
+        unsigned long flags;
+
+        if (!info->ioaddr)
+                return;
+        set_current_state(TASK_INTERRUPTIBLE);
+        spin_lock_irqsave(&info->slock, flags);
+        outb(inb(info->ioaddr + UART_LCR) | UART_LCR_SBC,
+                info->ioaddr + UART_LCR);
+        spin_unlock_irqrestore(&info->slock, flags);
+        schedule_timeout(duration);
+        spin_lock_irqsave(&info->slock, flags);
+        outb(inb(info->ioaddr + UART_LCR) & ~UART_LCR_SBC,
+                info->ioaddr + UART_LCR);
+        spin_unlock_irqrestore(&info->slock, flags);
+}
+
+static int mxser_tiocmget(struct tty_struct *tty, struct file *file)
+{
+        struct mxser_port *info = tty->driver_data;
+        unsigned char control, status;
+        unsigned long flags;
+
+
+        if (tty->index == MXSER_PORTS)
+                return -ENOIOCTLCMD;
+        if (test_bit(TTY_IO_ERROR, &tty->flags))
+                return -EIO;
+
+        control = info->MCR;
+
+        spin_lock_irqsave(&info->slock, flags);
+        status = inb(info->ioaddr + UART_MSR);
+        if (status & UART_MSR_ANY_DELTA)
+                mxser_check_modem_status(info, status);
+        spin_unlock_irqrestore(&info->slock, flags);
+        return ((control & UART_MCR_RTS) ? TIOCM_RTS : 0) |
+                    ((control & UART_MCR_DTR) ? TIOCM_DTR : 0) |
+                    ((status & UART_MSR_DCD) ? TIOCM_CAR : 0) |
+                    ((status & UART_MSR_RI) ? TIOCM_RNG : 0) |
+                    ((status & UART_MSR_DSR) ? TIOCM_DSR : 0) |
+                    ((status & UART_MSR_CTS) ? TIOCM_CTS : 0);
+}
+
+static int mxser_tiocmset(struct tty_struct *tty, struct file *file,
+                unsigned int set, unsigned int clear)
+{
+        struct mxser_port *info = tty->driver_data;
+        unsigned long flags;
+
+
+        if (tty->index == MXSER_PORTS)
+                return -ENOIOCTLCMD;
+        if (test_bit(TTY_IO_ERROR, &tty->flags))
+                return -EIO;
+
+        spin_lock_irqsave(&info->slock, flags);
+
+        if (set & TIOCM_RTS)
+                info->MCR |= UART_MCR_RTS;
+        if (set & TIOCM_DTR)
+                info->MCR |= UART_MCR_DTR;
+
+        if (clear & TIOCM_RTS)
+                info->MCR &= ~UART_MCR_RTS;
+        if (clear & TIOCM_DTR)
+                info->MCR &= ~UART_MCR_DTR;
+
+        outb(info->MCR, info->ioaddr + UART_MCR);
+        spin_unlock_irqrestore(&info->slock, flags);
+        return 0;
+}
+
+static int mxser_program_mode(int port)
+{
+        int id, i, j, n;
+
+        spin_lock(&gm_lock);
+        outb(0, port);
+        outb(0, port);
+        outb(0, port);
+        (void)inb(port);
+        (void)inb(port);
+        outb(0, port);
+        (void)inb(port);
+        spin_unlock(&gm_lock);
+
+        id = inb(port + 1) & 0x1F;
+        if ((id != C168_ASIC_ID) &&
+                        (id != C104_ASIC_ID) &&
+                        (id != C102_ASIC_ID) &&
+                        (id != CI132_ASIC_ID) &&
+                        (id != CI134_ASIC_ID) &&
+                        (id != CI104J_ASIC_ID))
+                return -1;
+        for (i = 0, j = 0; i < 4; i++) {
+                n = inb(port + 2);
+                if (n == 'M') {
+                        j = 1;
+                } else if ((j == 1) && (n == 1)) {
+                        j = 2;
+                        break;
+                } else
+                        j = 0;
+        }
+        if (j != 2)
+                id = -2;
+        return id;
+}
+
+static void mxser_normal_mode(int port)
+{
+        int i, n;
+
+        outb(0xA5, port + 1);
+        outb(0x80, port + 3);
+        outb(12, port + 0);     /* 9600 bps */
+        outb(0, port + 1);
+        outb(0x03, port + 3);   /* 8 data bits */
+        outb(0x13, port + 4);   /* loop back mode */
+        for (i = 0; i < 16; i++) {
+                n = inb(port + 5);
+                if ((n & 0x61) == 0x60)
+                        break;
+                if ((n & 1) == 1)
+                        (void)inb(port);
+        }
+        outb(0x00, port + 4);
+}
+
+#define CHIP_SK         0x01    /* Serial Data Clock  in Eprom */
+#define CHIP_DO         0x02    /* Serial Data Output in Eprom */
+#define CHIP_CS         0x04    /* Serial Chip Select in Eprom */
+#define CHIP_DI         0x08    /* Serial Data Input  in Eprom */
+#define EN_CCMD         0x000   /* Chip's command register     */
+#define EN0_RSARLO      0x008   /* Remote start address reg 0  */
+#define EN0_RSARHI      0x009   /* Remote start address reg 1  */
+#define EN0_RCNTLO      0x00A   /* Remote byte count reg WR    */
+#define EN0_RCNTHI      0x00B   /* Remote byte count reg WR    */
+#define EN0_DCFG        0x00E   /* Data configuration reg WR   */
+#define EN0_PORT        0x010   /* Rcv missed frame error counter RD */
+#define ENC_PAGE0       0x000   /* Select page 0 of chip registers   */
+#define ENC_PAGE3       0x0C0   /* Select page 3 of chip registers   */
+static int mxser_read_register(int port, unsigned short *regs)
+{
+        int i, k, value, id;
+        unsigned int j;
+
+        id = mxser_program_mode(port);
+        if (id < 0)
+                return id;
+        for (i = 0; i < 14; i++) {
+                k = (i & 0x3F) | 0x180;
+                for (j = 0x100; j > 0; j >>= 1) {
+                        outb(CHIP_CS, port);
+                        if (k & j) {
+                                outb(CHIP_CS | CHIP_DO, port);
+                                outb(CHIP_CS | CHIP_DO | CHIP_SK, port);        /* A? bit of read */
+                        } else {
+                                outb(CHIP_CS, port);
+                                outb(CHIP_CS | CHIP_SK, port);  /* A? bit of read */
+                        }
+                }
+                (void)inb(port);
+                value = 0;
+                for (k = 0, j = 0x8000; k < 16; k++, j >>= 1) {
+                        outb(CHIP_CS, port);
+                        outb(CHIP_CS | CHIP_SK, port);
+                        if (inb(port) & CHIP_DI)
+                                value |= j;
+                }
+                regs[i] = value;
+                outb(0, port);
+        }
+        mxser_normal_mode(port);
+        return id;
+}
+
+static int mxser_ioctl_special(unsigned int cmd, void __user *argp)
+{
+        struct mxser_port *port;
+        int result, status;
+        unsigned int i, j;
+
+        switch (cmd) {
+        case MOXA_GET_CONF:
+/*              if (copy_to_user(argp, mxsercfg,
+                                sizeof(struct mxser_hwconf) * 4))
+                        return -EFAULT;
+                return 0;*/
+                return -ENXIO;
+        case MOXA_GET_MAJOR:
+                if (copy_to_user(argp, &ttymajor, sizeof(int)))
+                        return -EFAULT;
+                return 0;
+
+        case MOXA_GET_CUMAJOR:
+                if (copy_to_user(argp, &calloutmajor, sizeof(int)))
+                        return -EFAULT;
+                return 0;
+
+        case MOXA_CHKPORTENABLE:
+                result = 0;
+
+                for (i = 0; i < MXSER_BOARDS; i++)
+                        for (j = 0; j < MXSER_PORTS_PER_BOARD; j++)
+                                if (mxser_boards[i].ports[j].ioaddr)
+                                        result |= (1 << i);
+
+                return put_user(result, (unsigned long __user *)argp);
+        case MOXA_GETDATACOUNT:
+                if (copy_to_user(argp, &mxvar_log, sizeof(mxvar_log)))
+                        return -EFAULT;
+                return 0;
+        case MOXA_GETMSTATUS:
+                for (i = 0; i < MXSER_BOARDS; i++)
+                        for (j = 0; j < MXSER_PORTS_PER_BOARD; j++) {
+                                port = &mxser_boards[i].ports[j];
+
+                                GMStatus[i].ri = 0;
+                                if (!port->ioaddr) {
+                                        GMStatus[i].dcd = 0;
+                                        GMStatus[i].dsr = 0;
+                                        GMStatus[i].cts = 0;
+                                        continue;
+                                }
+
+                                if (!port->tty || !port->tty->termios)
+                                        GMStatus[i].cflag =
+                                                port->normal_termios.c_cflag;
+                                else
+                                        GMStatus[i].cflag =
+                                                port->tty->termios->c_cflag;
+
+                                status = inb(port->ioaddr + UART_MSR);
+                                if (status & 0x80 /*UART_MSR_DCD */ )
+                                        GMStatus[i].dcd = 1;
+                                else
+                                        GMStatus[i].dcd = 0;
+
+                                if (status & 0x20 /*UART_MSR_DSR */ )
+                                        GMStatus[i].dsr = 1;
+                                else
+                                        GMStatus[i].dsr = 0;
+
+
+                                if (status & 0x10 /*UART_MSR_CTS */ )
+                                        GMStatus[i].cts = 1;
+                                else
+                                        GMStatus[i].cts = 0;
+                        }
+                if (copy_to_user(argp, GMStatus,
+                                sizeof(struct mxser_mstatus) * MXSER_PORTS))
+                        return -EFAULT;
+                return 0;
+        case MOXA_ASPP_MON_EXT: {
+                int status, p, shiftbit;
+                unsigned long opmode;
+                unsigned cflag, iflag;
+
+                for (i = 0; i < MXSER_BOARDS; i++)
+                        for (j = 0; j < MXSER_PORTS_PER_BOARD; j++) {
+                                port = &mxser_boards[i].ports[j];
+                                if (!port->ioaddr)
+                                        continue;
+
+                                status = mxser_get_msr(port->ioaddr, 0, i);
+
+                                if (status & UART_MSR_TERI)
+                                        port->icount.rng++;
+                                if (status & UART_MSR_DDSR)
+                                        port->icount.dsr++;
+                                if (status & UART_MSR_DDCD)
+                                        port->icount.dcd++;
+                                if (status & UART_MSR_DCTS)
+                                        port->icount.cts++;
+
+                                port->mon_data.modem_status = status;
+                                mon_data_ext.rx_cnt[i] = port->mon_data.rxcnt;
+                                mon_data_ext.tx_cnt[i] = port->mon_data.txcnt;
+                                mon_data_ext.up_rxcnt[i] =
+                                        port->mon_data.up_rxcnt;
+                                mon_data_ext.up_txcnt[i] =
+                                        port->mon_data.up_txcnt;
+                                mon_data_ext.modem_status[i] =
+                                        port->mon_data.modem_status;
+                                mon_data_ext.baudrate[i] = port->realbaud;
+
+                                if (!port->tty || !port->tty->termios) {
+                                        cflag = port->normal_termios.c_cflag;
+                                        iflag = port->normal_termios.c_iflag;
+                                } else {
+                                        cflag = port->tty->termios->c_cflag;
+                                        iflag = port->tty->termios->c_iflag;
+                                }
+
+                                mon_data_ext.databits[i] = cflag & CSIZE;
+
+                                mon_data_ext.stopbits[i] = cflag & CSTOPB;
+
+                                mon_data_ext.parity[i] =
+                                        cflag & (PARENB | PARODD | CMSPAR);
+
+                                mon_data_ext.flowctrl[i] = 0x00;
+
+                                if (cflag & CRTSCTS)
+                                        mon_data_ext.flowctrl[i] |= 0x03;
+
+                                if (iflag & (IXON | IXOFF))
+                                        mon_data_ext.flowctrl[i] |= 0x0C;
+
+                                if (port->type == PORT_16550A)
+                                        mon_data_ext.fifo[i] = 1;
+                                else
+                                        mon_data_ext.fifo[i] = 0;
+
+                                p = i % 4;
+                                shiftbit = p * 2;
+                                opmode = inb(port->opmode_ioaddr) >> shiftbit;
+                                opmode &= OP_MODE_MASK;
+
+                                mon_data_ext.iftype[i] = opmode;
+
+                        }
+                        if (copy_to_user(argp, &mon_data_ext,
+                                                sizeof(mon_data_ext)))
+                                return -EFAULT;
+
+                        return 0;
+
+        } default:
+                return -ENOIOCTLCMD;
+        }
+        return 0;
+}
+
+static int mxser_ioctl(struct tty_struct *tty, struct file *file,
+                unsigned int cmd, unsigned long arg)
+{
+        struct mxser_port *info = tty->driver_data;
+        struct async_icount cprev, cnow;        /* kernel counter temps */
+        struct serial_icounter_struct __user *p_cuser;
+        unsigned long templ;
+        unsigned long flags;
+        void __user *argp = (void __user *)arg;
+        int retval;
+
+        if (tty->index == MXSER_PORTS)
+                return mxser_ioctl_special(cmd, argp);
+
+        if (cmd == MOXA_SET_OP_MODE || cmd == MOXA_GET_OP_MODE) {
+                int p;
+                unsigned long opmode;
+                static unsigned char ModeMask[] = { 0xfc, 0xf3, 0xcf, 0x3f };
+                int shiftbit;
+                unsigned char val, mask;
+
+                p = tty->index % 4;
+                if (cmd == MOXA_SET_OP_MODE) {
+                        if (get_user(opmode, (int __user *) argp))
+                                return -EFAULT;
+                        if (opmode != RS232_MODE &&
+                                        opmode != RS485_2WIRE_MODE &&
+                                        opmode != RS422_MODE &&
+                                        opmode != RS485_4WIRE_MODE)
+                                return -EFAULT;
+                        mask = ModeMask[p];
+                        shiftbit = p * 2;
+                        val = inb(info->opmode_ioaddr);
+                        val &= mask;
+                        val |= (opmode << shiftbit);
+                        outb(val, info->opmode_ioaddr);
+                } else {
+                        shiftbit = p * 2;
+                        opmode = inb(info->opmode_ioaddr) >> shiftbit;
+                        opmode &= OP_MODE_MASK;
+                        if (copy_to_user(argp, &opmode, sizeof(int)))
+                                return -EFAULT;
+                }
+                return 0;
+        }
+
+        if (cmd != TIOCGSERIAL && cmd != TIOCMIWAIT && cmd != TIOCGICOUNT &&
+                        test_bit(TTY_IO_ERROR, &tty->flags))
+                return -EIO;
+
+        switch (cmd) {
+        case TCSBRK:            /* SVID version: non-zero arg --> no break */
+                retval = tty_check_change(tty);
+                if (retval)
+                        return retval;
+                tty_wait_until_sent(tty, 0);
+                if (!arg)
+                        mxser_send_break(info, HZ / 4); /* 1/4 second */
+                return 0;
+        case TCSBRKP:           /* support for POSIX tcsendbreak() */
+                retval = tty_check_change(tty);
+                if (retval)
+                        return retval;
+                tty_wait_until_sent(tty, 0);
+                mxser_send_break(info, arg ? arg * (HZ / 10) : HZ / 4);
+                return 0;
+        case TIOCGSOFTCAR:
+                return put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned long __user *)argp);
+        case TIOCSSOFTCAR:
+                if (get_user(templ, (unsigned long __user *) argp))
+                        return -EFAULT;
+                arg = templ;
+                tty->termios->c_cflag = ((tty->termios->c_cflag & ~CLOCAL) | (arg ? CLOCAL : 0));
+                return 0;
+        case TIOCGSERIAL:
+                return mxser_get_serial_info(info, argp);
+        case TIOCSSERIAL:
+                return mxser_set_serial_info(info, argp);
+        case TIOCSERGETLSR:     /* Get line status register */
+                return mxser_get_lsr_info(info, argp);
+                /*
+                 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
+                 * - mask passed in arg for lines of interest
+                 *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
+                 * Caller should use TIOCGICOUNT to see which one it was
+                 */
+        case TIOCMIWAIT: {
+                DECLARE_WAITQUEUE(wait, current);
+                int ret;
+                spin_lock_irqsave(&info->slock, flags);
+                cprev = info->icount;   /* note the counters on entry */
+                spin_unlock_irqrestore(&info->slock, flags);
+
+                add_wait_queue(&info->delta_msr_wait, &wait);
+                while (1) {
+                        spin_lock_irqsave(&info->slock, flags);
+                        cnow = info->icount;    /* atomic copy */
+                        spin_unlock_irqrestore(&info->slock, flags);
+
+                        set_current_state(TASK_INTERRUPTIBLE);
+                        if (((arg & TIOCM_RNG) &&
+                                        (cnow.rng != cprev.rng)) ||
+                                        ((arg & TIOCM_DSR) &&
+                                        (cnow.dsr != cprev.dsr)) ||
+                                        ((arg & TIOCM_CD) &&
+                                        (cnow.dcd != cprev.dcd)) ||
+                                        ((arg & TIOCM_CTS) &&
+                                        (cnow.cts != cprev.cts))) {
+                                ret = 0;
+                                break;
+                        }
+                        /* see if a signal did it */
+                        if (signal_pending(current)) {
+                                ret = -ERESTARTSYS;
+                                break;
+                        }
+                        cprev = cnow;
+                }
+                current->state = TASK_RUNNING;
+                remove_wait_queue(&info->delta_msr_wait, &wait);
+                break;
+        }
+        /* NOTREACHED */
+        /*
+         * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
+         * Return: write counters to the user passed counter struct
+         * NB: both 1->0 and 0->1 transitions are counted except for
+         *     RI where only 0->1 is counted.
+         */
+        case TIOCGICOUNT:
+                spin_lock_irqsave(&info->slock, flags);
+                cnow = info->icount;
+                spin_unlock_irqrestore(&info->slock, flags);
+                p_cuser = argp;
+                if (put_user(cnow.frame, &p_cuser->frame))
+                        return -EFAULT;
+                if (put_user(cnow.brk, &p_cuser->brk))
+                        return -EFAULT;
+                if (put_user(cnow.overrun, &p_cuser->overrun))
+                        return -EFAULT;
+                if (put_user(cnow.buf_overrun, &p_cuser->buf_overrun))
+                        return -EFAULT;
+                if (put_user(cnow.parity, &p_cuser->parity))
+                        return -EFAULT;
+                if (put_user(cnow.rx, &p_cuser->rx))
+                        return -EFAULT;
+                if (put_user(cnow.tx, &p_cuser->tx))
+                        return -EFAULT;
+                put_user(cnow.cts, &p_cuser->cts);
+                put_user(cnow.dsr, &p_cuser->dsr);
+                put_user(cnow.rng, &p_cuser->rng);
+                put_user(cnow.dcd, &p_cuser->dcd);
+                return 0;
+        case MOXA_HighSpeedOn:
+                return put_user(info->baud_base != 115200 ? 1 : 0, (int __user *)argp);
+        case MOXA_SDS_RSTICOUNTER:
+                info->mon_data.rxcnt = 0;
+                info->mon_data.txcnt = 0;
+                return 0;
+        case MOXA_ASPP_SETBAUD:{
+                long baud;
+                if (get_user(baud, (long __user *)argp))
+                        return -EFAULT;
+                mxser_set_baud(info, baud);
+                return 0;
+        }
+        case MOXA_ASPP_GETBAUD:
+                if (copy_to_user(argp, &info->realbaud, sizeof(long)))
+                        return -EFAULT;
+
+                return 0;
+
+        case MOXA_ASPP_OQUEUE:{
+                int len, lsr;
+
+                len = mxser_chars_in_buffer(tty);
+
+                lsr = inb(info->ioaddr + UART_LSR) & UART_LSR_TEMT;
+
+                len += (lsr ? 0 : 1);
+
+                if (copy_to_user(argp, &len, sizeof(int)))
+                        return -EFAULT;
+
+                return 0;
+        }
+        case MOXA_ASPP_MON: {
+                int mcr, status;
+
+                status = mxser_get_msr(info->ioaddr, 1, tty->index);
+                mxser_check_modem_status(info, status);
+
+                mcr = inb(info->ioaddr + UART_MCR);
+                if (mcr & MOXA_MUST_MCR_XON_FLAG)
+                        info->mon_data.hold_reason &= ~NPPI_NOTIFY_XOFFHOLD;
+                else
+                        info->mon_data.hold_reason |= NPPI_NOTIFY_XOFFHOLD;
+
+                if (mcr & MOXA_MUST_MCR_TX_XON)
+                        info->mon_data.hold_reason &= ~NPPI_NOTIFY_XOFFXENT;
+                else
+                        info->mon_data.hold_reason |= NPPI_NOTIFY_XOFFXENT;
+
+                if (info->tty->hw_stopped)
+                        info->mon_data.hold_reason |= NPPI_NOTIFY_CTSHOLD;
+                else
+                        info->mon_data.hold_reason &= ~NPPI_NOTIFY_CTSHOLD;
+
+                if (copy_to_user(argp, &info->mon_data,
+                                sizeof(struct mxser_mon)))
+                        return -EFAULT;
+
+                return 0;
+        }
+        case MOXA_ASPP_LSTATUS: {
+                if (copy_to_user(argp, &info->err_shadow,
+                                sizeof(unsigned char)))
+                        return -EFAULT;
+
+                info->err_shadow = 0;
+                return 0;
+        }
+        case MOXA_SET_BAUD_METHOD: {
+                int method;
+
+                if (get_user(method, (int __user *)argp))
+                        return -EFAULT;
+                mxser_set_baud_method[tty->index] = method;
+                if (copy_to_user(argp, &method, sizeof(int)))
+                        return -EFAULT;
+
+                return 0;
+        }
+        default:
+                return -ENOIOCTLCMD;
+        }
+        return 0;
+}
+
+static void mxser_stoprx(struct tty_struct *tty)
+{
+        struct mxser_port *info = tty->driver_data;
+
+        info->ldisc_stop_rx = 1;
+        if (I_IXOFF(tty)) {
+                if (info->board->chip_flag) {
+                        info->IER &= ~MOXA_MUST_RECV_ISR;
+                        outb(info->IER, info->ioaddr + UART_IER);
+                } else {
+                        info->x_char = STOP_CHAR(tty);
+                        outb(0, info->ioaddr + UART_IER);
+                        info->IER |= UART_IER_THRI;
+                        outb(info->IER, info->ioaddr + UART_IER);
+                }
+        }
+
+        if (info->tty->termios->c_cflag & CRTSCTS) {
+                info->MCR &= ~UART_MCR_RTS;
+                outb(info->MCR, info->ioaddr + UART_MCR);
+        }
+}
+
+/*
+ * This routine is called by the upper-layer tty layer to signal that
+ * incoming characters should be throttled.
+ */
+static void mxser_throttle(struct tty_struct *tty)
+{
+        mxser_stoprx(tty);
+}
+
+static void mxser_unthrottle(struct tty_struct *tty)
+{
+        struct mxser_port *info = tty->driver_data;
+
+        /* startrx */
+        info->ldisc_stop_rx = 0;
+        if (I_IXOFF(tty)) {
+                if (info->x_char)
+                        info->x_char = 0;
+                else {
+                        if (info->board->chip_flag) {
+                                info->IER |= MOXA_MUST_RECV_ISR;
+                                outb(info->IER, info->ioaddr + UART_IER);
+                        } else {
+                                info->x_char = START_CHAR(tty);
+                                outb(0, info->ioaddr + UART_IER);
+                                info->IER |= UART_IER_THRI;
+                                outb(info->IER, info->ioaddr + UART_IER);
+                        }
+                }
+        }
+
+        if (info->tty->termios->c_cflag & CRTSCTS) {
+                info->MCR |= UART_MCR_RTS;
+                outb(info->MCR, info->ioaddr + UART_MCR);
+        }
+}
+
+/*
+ * mxser_stop() and mxser_start()
+ *
+ * This routines are called before setting or resetting tty->stopped.
+ * They enable or disable transmitter interrupts, as necessary.
+ */
+static void mxser_stop(struct tty_struct *tty)
+{
+        struct mxser_port *info = tty->driver_data;
+        unsigned long flags;
+
+        spin_lock_irqsave(&info->slock, flags);
+        if (info->IER & UART_IER_THRI) {
+                info->IER &= ~UART_IER_THRI;
+                outb(info->IER, info->ioaddr + UART_IER);
+        }
+        spin_unlock_irqrestore(&info->slock, flags);
+}
+
+static void mxser_start(struct tty_struct *tty)
+{
+        struct mxser_port *info = tty->driver_data;
+        unsigned long flags;
+
+        spin_lock_irqsave(&info->slock, flags);
+        if (info->xmit_cnt && info->xmit_buf) {
+                outb(info->IER & ~UART_IER_THRI, info->ioaddr + UART_IER);
+                info->IER |= UART_IER_THRI;
+                outb(info->IER, info->ioaddr + UART_IER);
+        }
+        spin_unlock_irqrestore(&info->slock, flags);
+}
+
+static void mxser_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
+{
+        struct mxser_port *info = tty->driver_data;
+        unsigned long flags;
+
+        if ((tty->termios->c_cflag != old_termios->c_cflag) ||
+                        (RELEVANT_IFLAG(tty->termios->c_iflag) != RELEVANT_IFLAG(old_termios->c_iflag))) {
+
+                mxser_change_speed(info, old_termios);
+
+                if ((old_termios->c_cflag & CRTSCTS) &&
+                                !(tty->termios->c_cflag & CRTSCTS)) {
+                        tty->hw_stopped = 0;
+                        mxser_start(tty);
+                }
+        }
+
+        /* Handle sw stopped */
+        if ((old_termios->c_iflag & IXON) &&
+                        !(tty->termios->c_iflag & IXON)) {
+                tty->stopped = 0;
+
+                if (info->board->chip_flag) {
+                        spin_lock_irqsave(&info->slock, flags);
+                        DISABLE_MOXA_MUST_RX_SOFTWARE_FLOW_CONTROL(info->ioaddr);
+                        spin_unlock_irqrestore(&info->slock, flags);
+                }
+
+                mxser_start(tty);
+        }
+}
+
+/*
+ * mxser_wait_until_sent() --- wait until the transmitter is empty
+ */
+static void mxser_wait_until_sent(struct tty_struct *tty, int timeout)
+{
+        struct mxser_port *info = tty->driver_data;
+        unsigned long orig_jiffies, char_time;
+        int lsr;
+
+        if (info->type == PORT_UNKNOWN)
+                return;
+
+        if (info->xmit_fifo_size == 0)
+                return;         /* Just in case.... */
+
+        orig_jiffies = jiffies;
+        /*
+         * Set the check interval to be 1/5 of the estimated time to
+         * send a single character, and make it at least 1.  The check
+         * interval should also be less than the timeout.
+         *
+         * Note: we have to use pretty tight timings here to satisfy
+         * the NIST-PCTS.
+         */
+        char_time = (info->timeout - HZ / 50) / info->xmit_fifo_size;
+        char_time = char_time / 5;
+        if (char_time == 0)
+                char_time = 1;
+        if (timeout && timeout < char_time)
+                char_time = timeout;
+        /*
+         * If the transmitter hasn't cleared in twice the approximate
+         * amount of time to send the entire FIFO, it probably won't
+         * ever clear.  This assumes the UART isn't doing flow
+         * control, which is currently the case.  Hence, if it ever
+         * takes longer than info->timeout, this is probably due to a
+         * UART bug of some kind.  So, we clamp the timeout parameter at
+         * 2*info->timeout.
+         */
+        if (!timeout || timeout > 2 * info->timeout)
+                timeout = 2 * info->timeout;
+#ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
+        printk(KERN_DEBUG "In rs_wait_until_sent(%d) check=%lu...",
+                timeout, char_time);
+        printk("jiff=%lu...", jiffies);
+#endif
+        while (!((lsr = inb(info->ioaddr + UART_LSR)) & UART_LSR_TEMT)) {
+#ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
+                printk("lsr = %d (jiff=%lu)...", lsr, jiffies);
+#endif
+                schedule_timeout_interruptible(char_time);
+                if (signal_pending(current))
+                        break;
+                if (timeout && time_after(jiffies, orig_jiffies + timeout))
+                        break;
+        }
+        set_current_state(TASK_RUNNING);
+
+#ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
+        printk("lsr = %d (jiff=%lu)...done\n", lsr, jiffies);
+#endif
+}
+
+/*
+ * This routine is called by tty_hangup() when a hangup is signaled.
+ */
+void mxser_hangup(struct tty_struct *tty)
+{
+        struct mxser_port *info = tty->driver_data;
+
+        mxser_flush_buffer(tty);
+        mxser_shutdown(info);
+        info->event = 0;
+        info->count = 0;
+        info->flags &= ~ASYNC_NORMAL_ACTIVE;
+        info->tty = NULL;
+        wake_up_interruptible(&info->open_wait);
+}
+
+/*
+ * mxser_rs_break() --- routine which turns the break handling on or off
+ */
+static void mxser_rs_break(struct tty_struct *tty, int break_state)
+{
+        struct mxser_port *info = tty->driver_data;
+        unsigned long flags;
+
+        spin_lock_irqsave(&info->slock, flags);
+        if (break_state == -1)
+                outb(inb(info->ioaddr + UART_LCR) | UART_LCR_SBC,
+                        info->ioaddr + UART_LCR);
+        else
+                outb(inb(info->ioaddr + UART_LCR) & ~UART_LCR_SBC,
+                        info->ioaddr + UART_LCR);
+        spin_unlock_irqrestore(&info->slock, flags);
+}
+
+static void mxser_receive_chars(struct mxser_port *port, int *status)
+{
+        struct tty_struct *tty = port->tty;
+        unsigned char ch, gdl;
+        int ignored = 0;
+        int cnt = 0;
+        int recv_room;
+        int max = 256;
+        unsigned long flags;
+
+        spin_lock_irqsave(&port->slock, flags);
+
+        recv_room = tty->receive_room;
+        if ((recv_room == 0) && (!port->ldisc_stop_rx))
+                mxser_stoprx(tty);
+
+        if (port->board->chip_flag != MOXA_OTHER_UART) {
+
+                if (*status & UART_LSR_SPECIAL)
+                        goto intr_old;
+                if (port->board->chip_flag == MOXA_MUST_MU860_HWID &&
+                                (*status & MOXA_MUST_LSR_RERR))
+                        goto intr_old;
+                if (*status & MOXA_MUST_LSR_RERR)
+                        goto intr_old;
+
+                gdl = inb(port->ioaddr + MOXA_MUST_GDL_REGISTER);
+
+                if (port->board->chip_flag == MOXA_MUST_MU150_HWID)
+                        gdl &= MOXA_MUST_GDL_MASK;
+                if (gdl >= recv_room) {
+                        if (!port->ldisc_stop_rx)
+                                mxser_stoprx(tty);
+                }
+                while (gdl--) {
+                        ch = inb(port->ioaddr + UART_RX);
+                        tty_insert_flip_char(tty, ch, 0);
+                        cnt++;
+                }
+                goto end_intr;
+        }
+intr_old:
+
+        do {
+                if (max-- < 0)
+                        break;
+
+                ch = inb(port->ioaddr + UART_RX);
+                if (port->board->chip_flag && (*status & UART_LSR_OE))
+                        outb(0x23, port->ioaddr + UART_FCR);
+                *status &= port->read_status_mask;
+                if (*status & port->ignore_status_mask) {
+                        if (++ignored > 100)
+                                break;
+                } else {
+                        char flag = 0;
+                        if (*status & UART_LSR_SPECIAL) {
+                                if (*status & UART_LSR_BI) {
+                                        flag = TTY_BREAK;
+                                        port->icount.brk++;
+
+                                        if (port->flags & ASYNC_SAK)
+                                                do_SAK(tty);
+                                } else if (*status & UART_LSR_PE) {
+                                        flag = TTY_PARITY;
+                                        port->icount.parity++;
+                                } else if (*status & UART_LSR_FE) {
+                                        flag = TTY_FRAME;
+                                        port->icount.frame++;
+                                } else if (*status & UART_LSR_OE) {
+                                        flag = TTY_OVERRUN;
+                                        port->icount.overrun++;
+                                }
+                        }
+                        tty_insert_flip_char(tty, ch, flag);
+                        cnt++;
+                        if (cnt >= recv_room) {
+                                if (!port->ldisc_stop_rx)
+                                        mxser_stoprx(tty);
+                                break;
+                        }
+
+                }
+
+                if (port->board->chip_flag)
+                        break;
+
+                *status = inb(port->ioaddr + UART_LSR);
+        } while (*status & UART_LSR_DR);
+
+end_intr:
+        mxvar_log.rxcnt[port->tty->index] += cnt;
+        port->mon_data.rxcnt += cnt;
+        port->mon_data.up_rxcnt += cnt;
+        spin_unlock_irqrestore(&port->slock, flags);
+
+        tty_flip_buffer_push(tty);
+}
+
+static void mxser_transmit_chars(struct mxser_port *port)
+{
+        int count, cnt;
+        unsigned long flags;
+
+        spin_lock_irqsave(&port->slock, flags);
+
+        if (port->x_char) {
+                outb(port->x_char, port->ioaddr + UART_TX);
+                port->x_char = 0;
+                mxvar_log.txcnt[port->tty->index]++;
+                port->mon_data.txcnt++;
+                port->mon_data.up_txcnt++;
+                port->icount.tx++;
+                goto unlock;
+        }
+
+        if (port->xmit_buf == 0)
+                goto unlock;
+
+        if ((port->xmit_cnt <= 0) || port->tty->stopped ||
+                        (port->tty->hw_stopped &&
+                        (port->type != PORT_16550A) &&
+                        (!port->board->chip_flag))) {
+                port->IER &= ~UART_IER_THRI;
+                outb(port->IER, port->ioaddr + UART_IER);
+                goto unlock;
+        }
+
+        cnt = port->xmit_cnt;
+        count = port->xmit_fifo_size;
+        do {
+                outb(port->xmit_buf[port->xmit_tail++],
+                        port->ioaddr + UART_TX);
+                port->xmit_tail = port->xmit_tail & (SERIAL_XMIT_SIZE - 1);
+                if (--port->xmit_cnt <= 0)
+                        break;
+        } while (--count > 0);
+        mxvar_log.txcnt[port->tty->index] += (cnt - port->xmit_cnt);
+
+        port->mon_data.txcnt += (cnt - port->xmit_cnt);
+        port->mon_data.up_txcnt += (cnt - port->xmit_cnt);
+        port->icount.tx += (cnt - port->xmit_cnt);
+
+        if (port->xmit_cnt < WAKEUP_CHARS) {
+                set_bit(MXSER_EVENT_TXLOW, &port->event);
+                schedule_work(&port->tqueue);
+        }
+        if (port->xmit_cnt <= 0) {
+                port->IER &= ~UART_IER_THRI;
+                outb(port->IER, port->ioaddr + UART_IER);
+        }
+unlock:
+        spin_unlock_irqrestore(&port->slock, flags);
+}
+
+/*
+ * This is the serial driver's generic interrupt routine
+ */
+static irqreturn_t mxser_interrupt(int irq, void *dev_id)
+{
+        int status, iir, i;
+        struct mxser_board *brd = NULL;
+        struct mxser_port *port;
+        int max, irqbits, bits, msr;
+        int pass_counter = 0;
+        unsigned int int_cnt;
+        int handled = IRQ_NONE;
+
+        for (i = 0; i < MXSER_BOARDS; i++)
+                if (dev_id == &mxser_boards[i]) {
+                        brd = dev_id;
+                        break;
+                }
+
+        if (i == MXSER_BOARDS)
+                goto irq_stop;
+        if (brd == NULL)
+                goto irq_stop;
+        max = brd->info->nports;
+        while (1) {
+                irqbits = inb(brd->vector) & brd->vector_mask;
+                if (irqbits == brd->vector_mask)
+                        break;
+
+                handled = IRQ_HANDLED;
+                for (i = 0, bits = 1; i < max; i++, irqbits |= bits, bits <<= 1) {
+                        if (irqbits == brd->vector_mask)
+                                break;
+                        if (bits & irqbits)
+                                continue;
+                        port = &brd->ports[i];
+
+                        int_cnt = 0;
+                        do {
+                                iir = inb(port->ioaddr + UART_IIR);
+                                if (iir & UART_IIR_NO_INT)
+                                        break;
+                                iir &= MOXA_MUST_IIR_MASK;
+                                if (!port->tty) {
+                                        status = inb(port->ioaddr + UART_LSR);
+                                        outb(0x27, port->ioaddr + UART_FCR);
+                                        inb(port->ioaddr + UART_MSR);
+                                        break;
+                                }
+
+                                status = inb(port->ioaddr + UART_LSR);
+
+                                if (status & UART_LSR_PE)
+                                        port->err_shadow |= NPPI_NOTIFY_PARITY;
+                                if (status & UART_LSR_FE)
+                                        port->err_shadow |= NPPI_NOTIFY_FRAMING;
+                                if (status & UART_LSR_OE)
+                                        port->err_shadow |=
+                                                NPPI_NOTIFY_HW_OVERRUN;
+                                if (status & UART_LSR_BI)
+                                        port->err_shadow |= NPPI_NOTIFY_BREAK;
+
+                                if (port->board->chip_flag) {
+                                        if (iir == MOXA_MUST_IIR_GDA ||
+                                            iir == MOXA_MUST_IIR_RDA ||
+                                            iir == MOXA_MUST_IIR_RTO ||
+                                            iir == MOXA_MUST_IIR_LSR)
+                                                mxser_receive_chars(port,
+                                                                &status);
+
+                                } else {
+                                        status &= port->read_status_mask;
+                                        if (status & UART_LSR_DR)
+                                                mxser_receive_chars(port,
+                                                                &status);
+                                }
+                                msr = inb(port->ioaddr + UART_MSR);
+                                if (msr & UART_MSR_ANY_DELTA)
+                                        mxser_check_modem_status(port, msr);
+
+                                if (port->board->chip_flag) {
+                                        if (iir == 0x02 && (status &
+                                                                UART_LSR_THRE))
+                                                mxser_transmit_chars(port);
+                                } else {
+                                        if (status & UART_LSR_THRE)
+                                                mxser_transmit_chars(port);
+                                }
+                        } while (int_cnt++ < MXSER_ISR_PASS_LIMIT);
+                }
+                if (pass_counter++ > MXSER_ISR_PASS_LIMIT)
+                        break;  /* Prevent infinite loops */
+        }
+
+irq_stop:
+        return handled;
+}
+
+static const struct tty_operations mxser_ops = {
+        .open = mxser_open,
+        .close = mxser_close,
+        .write = mxser_write,
+        .put_char = mxser_put_char,
+        .flush_chars = mxser_flush_chars,
+        .write_room = mxser_write_room,
+        .chars_in_buffer = mxser_chars_in_buffer,
+        .flush_buffer = mxser_flush_buffer,
+        .ioctl = mxser_ioctl,
+        .throttle = mxser_throttle,
+        .unthrottle = mxser_unthrottle,
+        .set_termios = mxser_set_termios,
+        .stop = mxser_stop,
+        .start = mxser_start,
+        .hangup = mxser_hangup,
+        .break_ctl = mxser_rs_break,
+        .wait_until_sent = mxser_wait_until_sent,
+        .tiocmget = mxser_tiocmget,
+        .tiocmset = mxser_tiocmset,
+};
+
+/*
+ * The MOXA Smartio/Industio serial driver boot-time initialization code!
+ */
+
+static void mxser_release_res(struct mxser_board *brd, struct pci_dev *pdev,
+                unsigned int irq)
+{
+        if (irq)
+                free_irq(brd->irq, brd);
+        if (pdev != NULL) {     /* PCI */
+                pci_release_region(pdev, 2);
+                pci_release_region(pdev, 3);
+                pci_dev_put(pdev);
+        } else {
+                release_region(brd->ports[0].ioaddr, 8 * brd->info->nports);
+                release_region(brd->vector, 1);
+        }
+}
+
+static int __devinit mxser_initbrd(struct mxser_board *brd,
+                struct pci_dev *pdev)
+{
+        struct mxser_port *info;
+        unsigned int i;
+        int retval;
+
+        printk(KERN_INFO "max. baud rate = %d bps.\n", brd->ports[0].max_baud);
+
+        for (i = 0; i < brd->info->nports; i++) {
+                info = &brd->ports[i];
+                info->board = brd;
+                info->stop_rx = 0;
+                info->ldisc_stop_rx = 0;
+
+                /* Enhance mode enabled here */
+                if (brd->chip_flag != MOXA_OTHER_UART)
+                        ENABLE_MOXA_MUST_ENCHANCE_MODE(info->ioaddr);
+
+                info->flags = ASYNC_SHARE_IRQ;
+                info->type = brd->uart_type;
+
+                process_txrx_fifo(info);
+
+                info->custom_divisor = info->baud_base * 16;
+                info->close_delay = 5 * HZ / 10;
+                info->closing_wait = 30 * HZ;
+                INIT_WORK(&info->tqueue, mxser_do_softint);
+                info->normal_termios = mxvar_sdriver->init_termios;
+                init_waitqueue_head(&info->open_wait);
+                init_waitqueue_head(&info->close_wait);
+                init_waitqueue_head(&info->delta_msr_wait);
+                memset(&info->mon_data, 0, sizeof(struct mxser_mon));
+                info->err_shadow = 0;
+                spin_lock_init(&info->slock);
+
+                /* before set INT ISR, disable all int */
+                outb(inb(info->ioaddr + UART_IER) & 0xf0,
+                        info->ioaddr + UART_IER);
+        }
+        /*
+         * Allocate the IRQ if necessary
+         */
+
+        retval = request_irq(brd->irq, mxser_interrupt,
+                        (brd->ports[0].flags & ASYNC_SHARE_IRQ) ? IRQF_SHARED :
+                        IRQF_DISABLED, "mxser", brd);
+        if (retval) {
+                printk(KERN_ERR "Board %s: Request irq failed, IRQ (%d) may "
+                        "conflict with another device.\n",
+                        brd->info->name, brd->irq);
+                /* We hold resources, we need to release them. */
+                mxser_release_res(brd, pdev, 0);
+                return retval;
+        }
+        return 0;
+}
+
+static int __init mxser_get_ISA_conf(int cap, struct mxser_board *brd)
+{
+        int id, i, bits;
+        unsigned short regs[16], irq;
+        unsigned char scratch, scratch2;
+
+        brd->chip_flag = MOXA_OTHER_UART;
+
+        id = mxser_read_register(cap, regs);
+        switch (id) {
+        case C168_ASIC_ID:
+                brd->info = &mxser_cards[0];
+                break;
+        case C104_ASIC_ID:
+                brd->info = &mxser_cards[1];
+                break;
+        case CI104J_ASIC_ID:
+                brd->info = &mxser_cards[2];
+                break;
+        case C102_ASIC_ID:
+                brd->info = &mxser_cards[5];
+                break;
+        case CI132_ASIC_ID:
+                brd->info = &mxser_cards[6];
+                break;
+        case CI134_ASIC_ID:
+                brd->info = &mxser_cards[7];
+                break;
+        default:
+                return 0;
+        }
+
+        irq = 0;
+        /* some ISA cards have 2 ports, but we want to see them as 4-port (why?)
+           Flag-hack checks if configuration should be read as 2-port here. */
+        if (brd->info->nports == 2 || (brd->info->flags & MXSER_HAS2)) {
+                irq = regs[9] & 0xF000;
+                irq = irq | (irq >> 4);
+                if (irq != (regs[9] & 0xFF00))
+                        return MXSER_ERR_IRQ_CONFLIT;
+        } else if (brd->info->nports == 4) {
+                irq = regs[9] & 0xF000;
+                irq = irq | (irq >> 4);
+                irq = irq | (irq >> 8);
+                if (irq != regs[9])
+                        return MXSER_ERR_IRQ_CONFLIT;
+        } else if (brd->info->nports == 8) {
+                irq = regs[9] & 0xF000;
+                irq = irq | (irq >> 4);
+                irq = irq | (irq >> 8);
+                if ((irq != regs[9]) || (irq != regs[10]))
+                        return MXSER_ERR_IRQ_CONFLIT;
+        }
+
+        if (!irq)
+                return MXSER_ERR_IRQ;
+        brd->irq = ((int)(irq & 0xF000) >> 12);
+        for (i = 0; i < 8; i++)
+                brd->ports[i].ioaddr = (int) regs[i + 1] & 0xFFF8;
+        if ((regs[12] & 0x80) == 0)
+                return MXSER_ERR_VECTOR;
+        brd->vector = (int)regs[11];    /* interrupt vector */
+        if (id == 1)
+                brd->vector_mask = 0x00FF;
+        else
+                brd->vector_mask = 0x000F;
+        for (i = 7, bits = 0x0100; i >= 0; i--, bits <<= 1) {
+                if (regs[12] & bits) {
+                        brd->ports[i].baud_base = 921600;
+                        brd->ports[i].max_baud = 921600;
+                } else {
+                        brd->ports[i].baud_base = 115200;
+                        brd->ports[i].max_baud = 115200;
+                }
+        }
+        scratch2 = inb(cap + UART_LCR) & (~UART_LCR_DLAB);
+        outb(scratch2 | UART_LCR_DLAB, cap + UART_LCR);
+        outb(0, cap + UART_EFR);        /* EFR is the same as FCR */
+        outb(scratch2, cap + UART_LCR);
+        outb(UART_FCR_ENABLE_FIFO, cap + UART_FCR);
+        scratch = inb(cap + UART_IIR);
+
+        if (scratch & 0xC0)
+                brd->uart_type = PORT_16550A;
+        else
+                brd->uart_type = PORT_16450;
+        if (!request_region(brd->ports[0].ioaddr, 8 * brd->info->nports,
+                        "mxser(IO)"))
+                return MXSER_ERR_IOADDR;
+        if (!request_region(brd->vector, 1, "mxser(vector)")) {
+                release_region(brd->ports[0].ioaddr, 8 * brd->info->nports);
+                return MXSER_ERR_VECTOR;
+        }
+        return brd->info->nports;
+}
+
+static int __devinit mxser_probe(struct pci_dev *pdev,
+                const struct pci_device_id *ent)
+{
+        struct mxser_board *brd;
+        unsigned int i, j;
+        unsigned long ioaddress;
+        int retval = -EINVAL;
+
+        for (i = 0; i < MXSER_BOARDS; i++)
+                if (mxser_boards[i].info == NULL)
+                        break;
+
+        if (i >= MXSER_BOARDS) {
+                printk(KERN_ERR "Too many Smartio/Industio family boards found "
+                        "(maximum %d), board not configured\n", MXSER_BOARDS);
+                goto err;
+        }
+
+        brd = &mxser_boards[i];
+        brd->idx = i * MXSER_PORTS_PER_BOARD;
+        printk(KERN_INFO "Found MOXA %s board (BusNo=%d, DevNo=%d)\n",
+                mxser_cards[ent->driver_data].name,
+                pdev->bus->number, PCI_SLOT(pdev->devfn));
+
+        retval = pci_enable_device(pdev);
+        if (retval) {
+                printk(KERN_ERR "Moxa SmartI/O PCI enable fail !\n");
+                goto err;
+        }
+
+        /* io address */
+        ioaddress = pci_resource_start(pdev, 2);
+        retval = pci_request_region(pdev, 2, "mxser(IO)");
+        if (retval)
+                goto err;
+
+        brd->info = &mxser_cards[ent->driver_data];
+        for (i = 0; i < brd->info->nports; i++)
+                brd->ports[i].ioaddr = ioaddress + 8 * i;
+
+        /* vector */
+        ioaddress = pci_resource_start(pdev, 3);
+        retval = pci_request_region(pdev, 3, "mxser(vector)");
+        if (retval)
+                goto err_relio;
+        brd->vector = ioaddress;
+
+        /* irq */
+        brd->irq = pdev->irq;
+
+        brd->chip_flag = CheckIsMoxaMust(brd->ports[0].ioaddr);
+        brd->uart_type = PORT_16550A;
+        brd->vector_mask = 0;
+
+        for (i = 0; i < brd->info->nports; i++) {
+                for (j = 0; j < UART_INFO_NUM; j++) {
+                        if (Gpci_uart_info[j].type == brd->chip_flag) {
+                                brd->ports[i].max_baud =
+                                        Gpci_uart_info[j].max_baud;
+
+                                /* exception....CP-102 */
+                                if (brd->info->flags & MXSER_HIGHBAUD)
+                                        brd->ports[i].max_baud = 921600;
+                                break;
+                        }
+                }
+        }
+
+        if (brd->chip_flag == MOXA_MUST_MU860_HWID) {
+                for (i = 0; i < brd->info->nports; i++) {
+                        if (i < 4)
+                                brd->ports[i].opmode_ioaddr = ioaddress + 4;
+                        else
+                                brd->ports[i].opmode_ioaddr = ioaddress + 0x0c;
+                }
+                outb(0, ioaddress + 4); /* default set to RS232 mode */
+                outb(0, ioaddress + 0x0c);      /* default set to RS232 mode */
+        }
+
+        for (i = 0; i < brd->info->nports; i++) {
+                brd->vector_mask |= (1 << i);
+                brd->ports[i].baud_base = 921600;
+        }
+
+        /* mxser_initbrd will hook ISR. */
+        if (mxser_initbrd(brd, pdev) < 0)
+                goto err_relvec;
+
+        for (i = 0; i < brd->info->nports; i++)
+                tty_register_device(mxvar_sdriver, brd->idx + i, &pdev->dev);
+
+        pci_set_drvdata(pdev, brd);
+
+        return 0;
+err_relvec:
+        pci_release_region(pdev, 3);
+err_relio:
+        pci_release_region(pdev, 2);
+        brd->info = NULL;
+err:
+        return retval;
+}
+
+static void __devexit mxser_remove(struct pci_dev *pdev)
+{
+        struct mxser_board *brd = pci_get_drvdata(pdev);
+        unsigned int i;
+
+        for (i = 0; i < brd->info->nports; i++)
+                tty_unregister_device(mxvar_sdriver, brd->idx + i);
+
+        mxser_release_res(brd, pdev, 1);
+}
+
+static struct pci_driver mxser_driver = {
+        .name = "mxser",
+        .id_table = mxser_pcibrds,
+        .probe = mxser_probe,
+        .remove = __devexit_p(mxser_remove)
+};
+
+static int __init mxser_module_init(void)
+{
+        struct mxser_board *brd;
+        unsigned long cap;
+        unsigned int i, m, isaloop;
+        int retval, b;
+
+        pr_debug("Loading module mxser ...\n");
+
+        mxvar_sdriver = alloc_tty_driver(MXSER_PORTS + 1);
+        if (!mxvar_sdriver)
+                return -ENOMEM;
+        spin_lock_init(&gm_lock);
+
+        printk(KERN_INFO "MOXA Smartio/Industio family driver version %s\n",
+                MXSER_VERSION);
+
+        /* Initialize the tty_driver structure */
+        mxvar_sdriver->magic = TTY_DRIVER_MAGIC;
+        mxvar_sdriver->name = "ttyMI";
+        mxvar_sdriver->major = ttymajor;
+        mxvar_sdriver->minor_start = 0;
+        mxvar_sdriver->num = MXSER_PORTS + 1;
+        mxvar_sdriver->type = TTY_DRIVER_TYPE_SERIAL;
+        mxvar_sdriver->subtype = SERIAL_TYPE_NORMAL;
+        mxvar_sdriver->init_termios = tty_std_termios;
+        mxvar_sdriver->init_termios.c_cflag = B9600|CS8|CREAD|HUPCL|CLOCAL;
+        mxvar_sdriver->flags = TTY_DRIVER_REAL_RAW|TTY_DRIVER_DYNAMIC_DEV;
+        tty_set_operations(mxvar_sdriver, &mxser_ops);
+
+        retval = tty_register_driver(mxvar_sdriver);
+        if (retval) {
+                printk(KERN_ERR "Couldn't install MOXA Smartio/Industio family "
+                                "tty driver !\n");
+                goto err_put;
+        }
+
+        mxvar_diagflag = 0;
+
+        m = 0;
+        /* Start finding ISA boards here */
+        for (isaloop = 0; isaloop < 2; isaloop++)
+                for (b = 0; b < MXSER_BOARDS && m < MXSER_BOARDS; b++) {
+                        if (!isaloop)
+                                cap = mxserBoardCAP[b]; /* predefined */
+                        else
+                                cap = ioaddr[b]; /* module param */
+
+                        if (!cap)
+                                continue;
+
+                        brd = &mxser_boards[m];
+                        retval = mxser_get_ISA_conf(cap, brd);
+
+                        if (retval != 0)
+                                printk(KERN_INFO "Found MOXA %s board "
+                                        "(CAP=0x%x)\n",
+                                        brd->info->name, ioaddr[b]);
+
+                        if (retval <= 0) {
+                                if (retval == MXSER_ERR_IRQ)
+                                        printk(KERN_ERR "Invalid interrupt "
+                                                "number, board not "
+                                                "configured\n");
+                                else if (retval == MXSER_ERR_IRQ_CONFLIT)
+                                        printk(KERN_ERR "Invalid interrupt "
+                                                "number, board not "
+                                                "configured\n");
+                                else if (retval == MXSER_ERR_VECTOR)
+                                        printk(KERN_ERR "Invalid interrupt "
+                                                "vector, board not "
+                                                "configured\n");
+                                else if (retval == MXSER_ERR_IOADDR)
+                                        printk(KERN_ERR "Invalid I/O address, "
+                                                "board not configured\n");
+
+                                brd->info = NULL;
+                                continue;
+                        }
+
+                        /* mxser_initbrd will hook ISR. */
+                        if (mxser_initbrd(brd, NULL) < 0) {
+                                brd->info = NULL;
+                                continue;
+                        }
+
+                        brd->idx = m * MXSER_PORTS_PER_BOARD;
+                        for (i = 0; i < brd->info->nports; i++)
+                                tty_register_device(mxvar_sdriver, brd->idx + i,
+                                                NULL);
+
+                        m++;
+                }
+
+        retval = pci_register_driver(&mxser_driver);
+        if (retval) {
+                printk(KERN_ERR "Can't register pci driver\n");
+                if (!m) {
+                        retval = -ENODEV;
+                        goto err_unr;
+                } /* else: we have some ISA cards under control */
+        }
+
+        pr_debug("Done.\n");
+
+        return 0;
+err_unr:
+        tty_unregister_driver(mxvar_sdriver);
+err_put:
+        put_tty_driver(mxvar_sdriver);
+        return retval;
+}
+
+static void __exit mxser_module_exit(void)
+{
+        unsigned int i, j;
+
+        pr_debug("Unloading module mxser ...\n");
+
+        pci_unregister_driver(&mxser_driver);
+
+        for (i = 0; i < MXSER_BOARDS; i++) /* ISA remains */
+                if (mxser_boards[i].info != NULL)
+                        for (j = 0; j < mxser_boards[i].info->nports; j++)
+                                tty_unregister_device(mxvar_sdriver,
+                                                mxser_boards[i].idx + j);
+        tty_unregister_driver(mxvar_sdriver);
+        put_tty_driver(mxvar_sdriver);
+
+        for (i = 0; i < MXSER_BOARDS; i++)
+                if (mxser_boards[i].info != NULL)
+                        mxser_release_res(&mxser_boards[i], NULL, 1);
+
+        pr_debug("Done.\n");
+}
+
+module_init(mxser_module_init);
+module_exit(mxser_module_exit);
diff --git a/drivers/char/mxser_new.h b/drivers/char/mxser_new.h
new file mode 100644
index 000000000000..a08f0ecb09ba
--- /dev/null
+++ b/drivers/char/mxser_new.h
@@ -0,0 +1,450 @@
+#ifndef _MXSER_H
+#define _MXSER_H
+
+/*
+ *      Semi-public control interfaces
+ */
+
+/*
+ *      MOXA ioctls
+ */
+
+#define MOXA                    0x400
+#define MOXA_GETDATACOUNT       (MOXA + 23)
+#define MOXA_GET_CONF           (MOXA + 35)
+#define MOXA_DIAGNOSE           (MOXA + 50)
+#define MOXA_CHKPORTENABLE      (MOXA + 60)
+#define MOXA_HighSpeedOn        (MOXA + 61)
+#define MOXA_GET_MAJOR          (MOXA + 63)
+#define MOXA_GET_CUMAJOR        (MOXA + 64)
+#define MOXA_GETMSTATUS         (MOXA + 65)
+#define MOXA_SET_OP_MODE        (MOXA + 66)
+#define MOXA_GET_OP_MODE        (MOXA + 67)
+
+#define RS232_MODE              0
+#define RS485_2WIRE_MODE        1
+#define RS422_MODE              2
+#define RS485_4WIRE_MODE        3
+#define OP_MODE_MASK            3
+// above add by Victor Yu. 01-05-2004
+
+#define TTY_THRESHOLD_THROTTLE  128
+
+#define LO_WATER                (TTY_FLIPBUF_SIZE)
+#define HI_WATER                (TTY_FLIPBUF_SIZE*2*3/4)
+
+// added by James. 03-11-2004.
+#define MOXA_SDS_GETICOUNTER    (MOXA + 68)
+#define MOXA_SDS_RSTICOUNTER    (MOXA + 69)
+// (above) added by James.
+
+#define MOXA_ASPP_OQUEUE        (MOXA + 70)
+#define MOXA_ASPP_SETBAUD       (MOXA + 71)
+#define MOXA_ASPP_GETBAUD       (MOXA + 72)
+#define MOXA_ASPP_MON           (MOXA + 73)
+#define MOXA_ASPP_LSTATUS       (MOXA + 74)
+#define MOXA_ASPP_MON_EXT       (MOXA + 75)
+#define MOXA_SET_BAUD_METHOD    (MOXA + 76)
+
+
+/* --------------------------------------------------- */
+
+#define NPPI_NOTIFY_PARITY      0x01
+#define NPPI_NOTIFY_FRAMING     0x02
+#define NPPI_NOTIFY_HW_OVERRUN  0x04
+#define NPPI_NOTIFY_SW_OVERRUN  0x08
+#define NPPI_NOTIFY_BREAK       0x10
+
+#define NPPI_NOTIFY_CTSHOLD         0x01        // Tx hold by CTS low
+#define NPPI_NOTIFY_DSRHOLD         0x02        // Tx hold by DSR low
+#define NPPI_NOTIFY_XOFFHOLD        0x08        // Tx hold by Xoff received
+#define NPPI_NOTIFY_XOFFXENT        0x10        // Xoff Sent
+
+//CheckIsMoxaMust return value
+#define MOXA_OTHER_UART                 0x00
+#define MOXA_MUST_MU150_HWID            0x01
+#define MOXA_MUST_MU860_HWID            0x02
+
+// follow just for Moxa Must chip define.
+//
+// when LCR register (offset 0x03) write following value,
+// the Must chip will enter enchance mode. And write value
+// on EFR (offset 0x02) bit 6,7 to change bank.
+#define MOXA_MUST_ENTER_ENCHANCE        0xBF
+
+// when enhance mode enable, access on general bank register
+#define MOXA_MUST_GDL_REGISTER          0x07
+#define MOXA_MUST_GDL_MASK              0x7F
+#define MOXA_MUST_GDL_HAS_BAD_DATA      0x80
+
+#define MOXA_MUST_LSR_RERR              0x80    // error in receive FIFO
+// enchance register bank select and enchance mode setting register
+// when LCR register equal to 0xBF
+#define MOXA_MUST_EFR_REGISTER          0x02
+// enchance mode enable
+#define MOXA_MUST_EFR_EFRB_ENABLE       0x10
+// enchance reister bank set 0, 1, 2
+#define MOXA_MUST_EFR_BANK0             0x00
+#define MOXA_MUST_EFR_BANK1             0x40
+#define MOXA_MUST_EFR_BANK2             0x80
+#define MOXA_MUST_EFR_BANK3             0xC0
+#define MOXA_MUST_EFR_BANK_MASK         0xC0
+
+// set XON1 value register, when LCR=0xBF and change to bank0
+#define MOXA_MUST_XON1_REGISTER         0x04
+
+// set XON2 value register, when LCR=0xBF and change to bank0
+#define MOXA_MUST_XON2_REGISTER         0x05
+
+// set XOFF1 value register, when LCR=0xBF and change to bank0
+#define MOXA_MUST_XOFF1_REGISTER        0x06
+
+// set XOFF2 value register, when LCR=0xBF and change to bank0
+#define MOXA_MUST_XOFF2_REGISTER        0x07
+
+#define MOXA_MUST_RBRTL_REGISTER        0x04
+#define MOXA_MUST_RBRTH_REGISTER        0x05
+#define MOXA_MUST_RBRTI_REGISTER        0x06
+#define MOXA_MUST_THRTL_REGISTER        0x07
+#define MOXA_MUST_ENUM_REGISTER         0x04
+#define MOXA_MUST_HWID_REGISTER         0x05
+#define MOXA_MUST_ECR_REGISTER          0x06
+#define MOXA_MUST_CSR_REGISTER          0x07
+
+// good data mode enable
+#define MOXA_MUST_FCR_GDA_MODE_ENABLE   0x20
+// only good data put into RxFIFO
+#define MOXA_MUST_FCR_GDA_ONLY_ENABLE   0x10
+
+// enable CTS interrupt
+#define MOXA_MUST_IER_ECTSI             0x80
+// enable RTS interrupt
+#define MOXA_MUST_IER_ERTSI             0x40
+// enable Xon/Xoff interrupt
+#define MOXA_MUST_IER_XINT              0x20
+// enable GDA interrupt
+#define MOXA_MUST_IER_EGDAI             0x10
+
+#define MOXA_MUST_RECV_ISR              (UART_IER_RDI | MOXA_MUST_IER_EGDAI)
+
+// GDA interrupt pending
+#define MOXA_MUST_IIR_GDA               0x1C
+#define MOXA_MUST_IIR_RDA               0x04
+#define MOXA_MUST_IIR_RTO               0x0C
+#define MOXA_MUST_IIR_LSR               0x06
+
+// recieved Xon/Xoff or specical interrupt pending
+#define MOXA_MUST_IIR_XSC               0x10
+
+// RTS/CTS change state interrupt pending
+#define MOXA_MUST_IIR_RTSCTS            0x20
+#define MOXA_MUST_IIR_MASK              0x3E
+
+#define MOXA_MUST_MCR_XON_FLAG          0x40
+#define MOXA_MUST_MCR_XON_ANY           0x80
+#define MOXA_MUST_MCR_TX_XON            0x08
+
+
+// software flow control on chip mask value
+#define MOXA_MUST_EFR_SF_MASK           0x0F
+// send Xon1/Xoff1
+#define MOXA_MUST_EFR_SF_TX1            0x08
+// send Xon2/Xoff2
+#define MOXA_MUST_EFR_SF_TX2            0x04
+// send Xon1,Xon2/Xoff1,Xoff2
+#define MOXA_MUST_EFR_SF_TX12           0x0C
+// don't send Xon/Xoff
+#define MOXA_MUST_EFR_SF_TX_NO          0x00
+// Tx software flow control mask
+#define MOXA_MUST_EFR_SF_TX_MASK        0x0C
+// don't receive Xon/Xoff
+#define MOXA_MUST_EFR_SF_RX_NO          0x00
+// receive Xon1/Xoff1
+#define MOXA_MUST_EFR_SF_RX1            0x02
+// receive Xon2/Xoff2
+#define MOXA_MUST_EFR_SF_RX2            0x01
+// receive Xon1,Xon2/Xoff1,Xoff2
+#define MOXA_MUST_EFR_SF_RX12           0x03
+// Rx software flow control mask
+#define MOXA_MUST_EFR_SF_RX_MASK        0x03
+
+//#define MOXA_MUST_MIN_XOFFLIMIT               66
+//#define MOXA_MUST_MIN_XONLIMIT                20
+//#define ID1_RX_TRIG                   120
+
+
+#define CHECK_MOXA_MUST_XOFFLIMIT(info) {       \
+        if ( (info)->IsMoxaMustChipFlag &&      \
+         (info)->HandFlow.XoffLimit < MOXA_MUST_MIN_XOFFLIMIT ) {       \
+                (info)->HandFlow.XoffLimit = MOXA_MUST_MIN_XOFFLIMIT;   \
+                (info)->HandFlow.XonLimit = MOXA_MUST_MIN_XONLIMIT;     \
+        }       \
+}
+
+#define ENABLE_MOXA_MUST_ENCHANCE_MODE(baseio) { \
+        u8      __oldlcr, __efr;        \
+        __oldlcr = inb((baseio)+UART_LCR);      \
+        outb(MOXA_MUST_ENTER_ENCHANCE, (baseio)+UART_LCR);      \
+        __efr = inb((baseio)+MOXA_MUST_EFR_REGISTER);   \
+        __efr |= MOXA_MUST_EFR_EFRB_ENABLE;     \
+        outb(__efr, (baseio)+MOXA_MUST_EFR_REGISTER);   \
+        outb(__oldlcr, (baseio)+UART_LCR);      \
+}
+
+#define DISABLE_MOXA_MUST_ENCHANCE_MODE(baseio) {       \
+        u8      __oldlcr, __efr;        \
+        __oldlcr = inb((baseio)+UART_LCR);      \
+        outb(MOXA_MUST_ENTER_ENCHANCE, (baseio)+UART_LCR);      \
+        __efr = inb((baseio)+MOXA_MUST_EFR_REGISTER);   \
+        __efr &= ~MOXA_MUST_EFR_EFRB_ENABLE;    \
+        outb(__efr, (baseio)+MOXA_MUST_EFR_REGISTER);   \
+        outb(__oldlcr, (baseio)+UART_LCR);      \
+}
+
+#define SET_MOXA_MUST_XON1_VALUE(baseio, Value) {       \
+        u8      __oldlcr, __efr;        \
+        __oldlcr = inb((baseio)+UART_LCR);      \
+        outb(MOXA_MUST_ENTER_ENCHANCE, (baseio)+UART_LCR);      \
+        __efr = inb((baseio)+MOXA_MUST_EFR_REGISTER);   \
+        __efr &= ~MOXA_MUST_EFR_BANK_MASK;      \
+        __efr |= MOXA_MUST_EFR_BANK0;   \
+        outb(__efr, (baseio)+MOXA_MUST_EFR_REGISTER);   \
+        outb((u8)(Value), (baseio)+MOXA_MUST_XON1_REGISTER);    \
+        outb(__oldlcr, (baseio)+UART_LCR);      \
+}
+
+#define SET_MOXA_MUST_XON2_VALUE(baseio, Value) {       \
+        u8      __oldlcr, __efr;        \
+        __oldlcr = inb((baseio)+UART_LCR);      \
+        outb(MOXA_MUST_ENTER_ENCHANCE, (baseio)+UART_LCR);      \
+        __efr = inb((baseio)+MOXA_MUST_EFR_REGISTER);   \
+        __efr &= ~MOXA_MUST_EFR_BANK_MASK;      \
+        __efr |= MOXA_MUST_EFR_BANK0;   \
+        outb(__efr, (baseio)+MOXA_MUST_EFR_REGISTER);   \
+        outb((u8)(Value), (baseio)+MOXA_MUST_XON2_REGISTER);    \
+        outb(__oldlcr, (baseio)+UART_LCR);      \
+}
+
+#define SET_MOXA_MUST_XOFF1_VALUE(baseio, Value) {      \
+        u8      __oldlcr, __efr;        \
+        __oldlcr = inb((baseio)+UART_LCR);      \
+        outb(MOXA_MUST_ENTER_ENCHANCE, (baseio)+UART_LCR);      \
+        __efr = inb((baseio)+MOXA_MUST_EFR_REGISTER);   \
+        __efr &= ~MOXA_MUST_EFR_BANK_MASK;      \
+        __efr |= MOXA_MUST_EFR_BANK0;   \
+        outb(__efr, (baseio)+MOXA_MUST_EFR_REGISTER);   \
+        outb((u8)(Value), (baseio)+MOXA_MUST_XOFF1_REGISTER);   \
+        outb(__oldlcr, (baseio)+UART_LCR);      \
+}
+
+#define SET_MOXA_MUST_XOFF2_VALUE(baseio, Value) {      \
+        u8      __oldlcr, __efr;        \
+        __oldlcr = inb((baseio)+UART_LCR);      \
+        outb(MOXA_MUST_ENTER_ENCHANCE, (baseio)+UART_LCR);      \
+        __efr = inb((baseio)+MOXA_MUST_EFR_REGISTER);   \
+        __efr &= ~MOXA_MUST_EFR_BANK_MASK;      \
+        __efr |= MOXA_MUST_EFR_BANK0;   \
+        outb(__efr, (baseio)+MOXA_MUST_EFR_REGISTER);   \
+        outb((u8)(Value), (baseio)+MOXA_MUST_XOFF2_REGISTER);   \
+        outb(__oldlcr, (baseio)+UART_LCR);      \
+}
+
+#define SET_MOXA_MUST_RBRTL_VALUE(baseio, Value) {      \
+        u8      __oldlcr, __efr;        \
+        __oldlcr = inb((baseio)+UART_LCR);      \
+        outb(MOXA_MUST_ENTER_ENCHANCE, (baseio)+UART_LCR);      \
+        __efr = inb((baseio)+MOXA_MUST_EFR_REGISTER);   \
+        __efr &= ~MOXA_MUST_EFR_BANK_MASK;      \
+        __efr |= MOXA_MUST_EFR_BANK1;   \
+        outb(__efr, (baseio)+MOXA_MUST_EFR_REGISTER);   \
+        outb((u8)(Value), (baseio)+MOXA_MUST_RBRTL_REGISTER);   \
+        outb(__oldlcr, (baseio)+UART_LCR);      \
+}
+
+#define SET_MOXA_MUST_RBRTH_VALUE(baseio, Value) {      \
+        u8      __oldlcr, __efr;        \
+        __oldlcr = inb((baseio)+UART_LCR);      \
+        outb(MOXA_MUST_ENTER_ENCHANCE, (baseio)+UART_LCR);      \
+        __efr = inb((baseio)+MOXA_MUST_EFR_REGISTER);   \
+        __efr &= ~MOXA_MUST_EFR_BANK_MASK;      \
+        __efr |= MOXA_MUST_EFR_BANK1;   \
+        outb(__efr, (baseio)+MOXA_MUST_EFR_REGISTER);   \
+        outb((u8)(Value), (baseio)+MOXA_MUST_RBRTH_REGISTER);   \
+        outb(__oldlcr, (baseio)+UART_LCR);      \
+}
+
+#define SET_MOXA_MUST_RBRTI_VALUE(baseio, Value) {      \
+        u8      __oldlcr, __efr;        \
+        __oldlcr = inb((baseio)+UART_LCR);      \
+        outb(MOXA_MUST_ENTER_ENCHANCE, (baseio)+UART_LCR);      \
+        __efr = inb((baseio)+MOXA_MUST_EFR_REGISTER);   \
+        __efr &= ~MOXA_MUST_EFR_BANK_MASK;      \
+        __efr |= MOXA_MUST_EFR_BANK1;   \
+        outb(__efr, (baseio)+MOXA_MUST_EFR_REGISTER);   \
+        outb((u8)(Value), (baseio)+MOXA_MUST_RBRTI_REGISTER);   \
+        outb(__oldlcr, (baseio)+UART_LCR);      \
+}
+
+#define SET_MOXA_MUST_THRTL_VALUE(baseio, Value) {      \
+        u8      __oldlcr, __efr;        \
+        __oldlcr = inb((baseio)+UART_LCR);      \
+        outb(MOXA_MUST_ENTER_ENCHANCE, (baseio)+UART_LCR);      \
+        __efr = inb((baseio)+MOXA_MUST_EFR_REGISTER);   \
+        __efr &= ~MOXA_MUST_EFR_BANK_MASK;      \
+        __efr |= MOXA_MUST_EFR_BANK1;   \
+        outb(__efr, (baseio)+MOXA_MUST_EFR_REGISTER);   \
+        outb((u8)(Value), (baseio)+MOXA_MUST_THRTL_REGISTER);   \
+        outb(__oldlcr, (baseio)+UART_LCR);      \
+}
+
+//#define MOXA_MUST_RBRL_VALUE  4
+#define SET_MOXA_MUST_FIFO_VALUE(info) {        \
+        u8      __oldlcr, __efr;        \
+        __oldlcr = inb((info)->ioaddr+UART_LCR);        \
+        outb(MOXA_MUST_ENTER_ENCHANCE, (info)->ioaddr+UART_LCR);        \
+        __efr = inb((info)->ioaddr+MOXA_MUST_EFR_REGISTER);     \
+        __efr &= ~MOXA_MUST_EFR_BANK_MASK;      \
+        __efr |= MOXA_MUST_EFR_BANK1;   \
+        outb(__efr, (info)->ioaddr+MOXA_MUST_EFR_REGISTER);     \
+        outb((u8)((info)->rx_high_water), (info)->ioaddr+MOXA_MUST_RBRTH_REGISTER);     \
+        outb((u8)((info)->rx_trigger), (info)->ioaddr+MOXA_MUST_RBRTI_REGISTER);        \
+        outb((u8)((info)->rx_low_water), (info)->ioaddr+MOXA_MUST_RBRTL_REGISTER);      \
+        outb(__oldlcr, (info)->ioaddr+UART_LCR);        \
+}
+
+
+
+#define SET_MOXA_MUST_ENUM_VALUE(baseio, Value) {       \
+        u8      __oldlcr, __efr;        \
+        __oldlcr = inb((baseio)+UART_LCR);      \
+        outb(MOXA_MUST_ENTER_ENCHANCE, (baseio)+UART_LCR);      \
+        __efr = inb((baseio)+MOXA_MUST_EFR_REGISTER);   \
+        __efr &= ~MOXA_MUST_EFR_BANK_MASK;      \
+        __efr |= MOXA_MUST_EFR_BANK2;   \
+        outb(__efr, (baseio)+MOXA_MUST_EFR_REGISTER);   \
+        outb((u8)(Value), (baseio)+MOXA_MUST_ENUM_REGISTER);    \
+        outb(__oldlcr, (baseio)+UART_LCR);      \
+}
+
+#define GET_MOXA_MUST_HARDWARE_ID(baseio, pId) {        \
+        u8      __oldlcr, __efr;        \
+        __oldlcr = inb((baseio)+UART_LCR);      \
+        outb(MOXA_MUST_ENTER_ENCHANCE, (baseio)+UART_LCR);      \
+        __efr = inb((baseio)+MOXA_MUST_EFR_REGISTER);   \
+        __efr &= ~MOXA_MUST_EFR_BANK_MASK;      \
+        __efr |= MOXA_MUST_EFR_BANK2;   \
+        outb(__efr, (baseio)+MOXA_MUST_EFR_REGISTER);   \
+        *pId = inb((baseio)+MOXA_MUST_HWID_REGISTER);   \
+        outb(__oldlcr, (baseio)+UART_LCR);      \
+}
+
+#define SET_MOXA_MUST_NO_SOFTWARE_FLOW_CONTROL(baseio) {        \
+        u8      __oldlcr, __efr;        \
+        __oldlcr = inb((baseio)+UART_LCR);      \
+        outb(MOXA_MUST_ENTER_ENCHANCE, (baseio)+UART_LCR);      \
+        __efr = inb((baseio)+MOXA_MUST_EFR_REGISTER);   \
+        __efr &= ~MOXA_MUST_EFR_SF_MASK;        \
+        outb(__efr, (baseio)+MOXA_MUST_EFR_REGISTER);   \
+        outb(__oldlcr, (baseio)+UART_LCR);      \
+}
+
+#define SET_MOXA_MUST_JUST_TX_SOFTWARE_FLOW_CONTROL(baseio) {   \
+        u8      __oldlcr, __efr;        \
+        __oldlcr = inb((baseio)+UART_LCR);      \
+        outb(MOXA_MUST_ENTER_ENCHANCE, (baseio)+UART_LCR);      \
+        __efr = inb((baseio)+MOXA_MUST_EFR_REGISTER);   \
+        __efr &= ~MOXA_MUST_EFR_SF_MASK;        \
+        __efr |= MOXA_MUST_EFR_SF_TX1;  \
+        outb(__efr, (baseio)+MOXA_MUST_EFR_REGISTER);   \
+        outb(__oldlcr, (baseio)+UART_LCR);      \
+}
+
+#define ENABLE_MOXA_MUST_TX_SOFTWARE_FLOW_CONTROL(baseio) {     \
+        u8      __oldlcr, __efr;        \
+        __oldlcr = inb((baseio)+UART_LCR);      \
+        outb(MOXA_MUST_ENTER_ENCHANCE, (baseio)+UART_LCR);      \
+        __efr = inb((baseio)+MOXA_MUST_EFR_REGISTER);   \
+        __efr &= ~MOXA_MUST_EFR_SF_TX_MASK;     \
+        __efr |= MOXA_MUST_EFR_SF_TX1;  \
+        outb(__efr, (baseio)+MOXA_MUST_EFR_REGISTER);   \
+        outb(__oldlcr, (baseio)+UART_LCR);      \
+}
+
+#define DISABLE_MOXA_MUST_TX_SOFTWARE_FLOW_CONTROL(baseio) {    \
+        u8      __oldlcr, __efr;        \
+        __oldlcr = inb((baseio)+UART_LCR);      \
+        outb(MOXA_MUST_ENTER_ENCHANCE, (baseio)+UART_LCR);      \
+        __efr = inb((baseio)+MOXA_MUST_EFR_REGISTER);   \
+        __efr &= ~MOXA_MUST_EFR_SF_TX_MASK;     \
+        outb(__efr, (baseio)+MOXA_MUST_EFR_REGISTER);   \
+        outb(__oldlcr, (baseio)+UART_LCR);      \
+}
+
+#define SET_MOXA_MUST_JUST_RX_SOFTWARE_FLOW_CONTROL(baseio) {   \
+        u8      __oldlcr, __efr;        \
+        __oldlcr = inb((baseio)+UART_LCR);      \
+        outb(MOXA_MUST_ENTER_ENCHANCE, (baseio)+UART_LCR);      \
+        __efr = inb((baseio)+MOXA_MUST_EFR_REGISTER);   \
+        __efr &= ~MOXA_MUST_EFR_SF_MASK;        \
+        __efr |= MOXA_MUST_EFR_SF_RX1;  \
+        outb(__efr, (baseio)+MOXA_MUST_EFR_REGISTER);   \
+        outb(__oldlcr, (baseio)+UART_LCR);      \
+}
+
+#define ENABLE_MOXA_MUST_RX_SOFTWARE_FLOW_CONTROL(baseio) {     \
+        u8      __oldlcr, __efr;        \
+        __oldlcr = inb((baseio)+UART_LCR);      \
+        outb(MOXA_MUST_ENTER_ENCHANCE, (baseio)+UART_LCR);      \
+        __efr = inb((baseio)+MOXA_MUST_EFR_REGISTER);   \
+        __efr &= ~MOXA_MUST_EFR_SF_RX_MASK;     \
+        __efr |= MOXA_MUST_EFR_SF_RX1;  \
+        outb(__efr, (baseio)+MOXA_MUST_EFR_REGISTER);   \
+        outb(__oldlcr, (baseio)+UART_LCR);      \
+}
+
+#define DISABLE_MOXA_MUST_RX_SOFTWARE_FLOW_CONTROL(baseio) {    \
+        u8      __oldlcr, __efr;        \
+        __oldlcr = inb((baseio)+UART_LCR);      \
+        outb(MOXA_MUST_ENTER_ENCHANCE, (baseio)+UART_LCR);      \
+        __efr = inb((baseio)+MOXA_MUST_EFR_REGISTER);   \
+        __efr &= ~MOXA_MUST_EFR_SF_RX_MASK;     \
+        outb(__efr, (baseio)+MOXA_MUST_EFR_REGISTER);   \
+        outb(__oldlcr, (baseio)+UART_LCR);      \
+}
+
+#define ENABLE_MOXA_MUST_TX_RX_SOFTWARE_FLOW_CONTROL(baseio) {  \
+        u8      __oldlcr, __efr;        \
+        __oldlcr = inb((baseio)+UART_LCR);      \
+        outb(MOXA_MUST_ENTER_ENCHANCE, (baseio)+UART_LCR);      \
+        __efr = inb((baseio)+MOXA_MUST_EFR_REGISTER);   \
+        __efr &= ~MOXA_MUST_EFR_SF_MASK;        \
+        __efr |= (MOXA_MUST_EFR_SF_RX1|MOXA_MUST_EFR_SF_TX1);   \
+        outb(__efr, (baseio)+MOXA_MUST_EFR_REGISTER);   \
+        outb(__oldlcr, (baseio)+UART_LCR);      \
+}
+
+#define ENABLE_MOXA_MUST_XON_ANY_FLOW_CONTROL(baseio) { \
+        u8      __oldmcr;       \
+        __oldmcr = inb((baseio)+UART_MCR);      \
+        __oldmcr |= MOXA_MUST_MCR_XON_ANY;      \
+        outb(__oldmcr, (baseio)+UART_MCR);      \
+}
+
+#define DISABLE_MOXA_MUST_XON_ANY_FLOW_CONTROL(baseio) {        \
+        u8      __oldmcr;       \
+        __oldmcr = inb((baseio)+UART_MCR);      \
+        __oldmcr &= ~MOXA_MUST_MCR_XON_ANY;     \
+        outb(__oldmcr, (baseio)+UART_MCR);      \
+}
+
+#define READ_MOXA_MUST_GDL(baseio)      inb((baseio)+MOXA_MUST_GDL_REGISTER)
+
+
+#ifndef INIT_WORK
+#define INIT_WORK(_work, _func, _data){ \
+        _data->tqueue.routine = _func;\
+        _data->tqueue.data = _data;\
+        }
+#endif
+
+#endif
diff --git a/drivers/char/n_r3964.c b/drivers/char/n_r3964.c
index 203dc2b661d5..103d338f21e2 100644
--- a/drivers/char/n_r3964.c
+++ b/drivers/char/n_r3964.c
@@ -142,7 +142,7 @@ static ssize_t r3964_write(struct tty_struct * tty, struct file * file,
                       const unsigned char * buf, size_t nr);
 static int r3964_ioctl(struct tty_struct * tty, struct file * file,
                        unsigned int cmd, unsigned long arg);
-static void r3964_set_termios(struct tty_struct *tty, struct termios * old);
+static void r3964_set_termios(struct tty_struct *tty, struct ktermios * old);
 static unsigned int r3964_poll(struct tty_struct * tty, struct file * file,
                       struct poll_table_struct  *wait);
 static void r3964_receive_buf(struct tty_struct *tty, const unsigned char *cp,
@@ -1347,7 +1347,7 @@ static int r3964_ioctl(struct tty_struct * tty, struct file * file,
    }
 }
 
-static void r3964_set_termios(struct tty_struct *tty, struct termios * old)
+static void r3964_set_termios(struct tty_struct *tty, struct ktermios * old)
 {
    TRACE_L("set_termios");
 }
diff --git a/drivers/char/n_tty.c b/drivers/char/n_tty.c
index 603b9ade5eb0..e96a00fe1389 100644
--- a/drivers/char/n_tty.c
+++ b/drivers/char/n_tty.c
@@ -994,7 +994,7 @@ int is_ignored(int sig)
  *      when the ldisc is closed.
  */
  
-static void n_tty_set_termios(struct tty_struct *tty, struct termios * old)
+static void n_tty_set_termios(struct tty_struct *tty, struct ktermios * old)
 {
         if (!tty)
                 return;
diff --git a/drivers/char/nsc_gpio.c b/drivers/char/nsc_gpio.c
index 7719bd75810b..808d44e9a32a 100644
--- a/drivers/char/nsc_gpio.c
+++ b/drivers/char/nsc_gpio.c
@@ -7,7 +7,6 @@
    Copyright (c) 2005      Jim Cromie <jim.cromie@gmail.com>
 */
 
-#include <linux/config.h>
 #include <linux/fs.h>
 #include <linux/module.h>
 #include <linux/errno.h>
@@ -42,7 +41,7 @@ void nsc_gpio_dump(struct nsc_gpio_ops *amp, unsigned index)
 ssize_t nsc_gpio_write(struct file *file, const char __user *data,
                        size_t len, loff_t *ppos)
 {
-        unsigned m = iminor(file->f_dentry->d_inode);
+        unsigned m = iminor(file->f_path.dentry->d_inode);
         struct nsc_gpio_ops *amp = file->private_data;
         struct device *dev = amp->dev;
         size_t i;
@@ -105,7 +104,7 @@ ssize_t nsc_gpio_write(struct file *file, const char __user *data,
 ssize_t nsc_gpio_read(struct file *file, char __user * buf,
                       size_t len, loff_t * ppos)
 {
-        unsigned m = iminor(file->f_dentry->d_inode);
+        unsigned m = iminor(file->f_path.dentry->d_inode);
         int value;
         struct nsc_gpio_ops *amp = file->private_data;
 
diff --git a/drivers/char/nwbutton.c b/drivers/char/nwbutton.c
index 7c57ebfa8640..2d264971d839 100644
--- a/drivers/char/nwbutton.c
+++ b/drivers/char/nwbutton.c
@@ -127,9 +127,8 @@ static void button_consume_callbacks (int bpcount)
 static void button_sequence_finished (unsigned long parameters)
 {
 #ifdef CONFIG_NWBUTTON_REBOOT           /* Reboot using button is enabled */
-        if (button_press_count == reboot_count) {
-                kill_proc (1, SIGINT, 1);       /* Ask init to reboot us */
-        }
+        if (button_press_count == reboot_count)
+                kill_cad_pid(SIGINT, 1);        /* Ask init to reboot us */
 #endif /* CONFIG_NWBUTTON_REBOOT */
         button_consume_callbacks (button_press_count);
         bcount = sprintf (button_output_buffer, "%d\n", button_press_count);
@@ -145,7 +144,7 @@ static void button_sequence_finished (unsigned long parameters)
  *  increments the counter.
  */ 
 
-static irqreturn_t button_handler (int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t button_handler (int irq, void *dev_id)
 {
         if (button_press_count) {
                 del_timer (&button_timer);
diff --git a/drivers/char/nwbutton.h b/drivers/char/nwbutton.h
index ddb7b928dcbb..c3ebc16ce8a7 100644
--- a/drivers/char/nwbutton.h
+++ b/drivers/char/nwbutton.h
@@ -25,7 +25,7 @@ struct button_callback {
 /* Function prototypes: */
 
 static void button_sequence_finished (unsigned long parameters);
-static irqreturn_t button_handler (int irq, void *dev_id, struct pt_regs *regs);
+static irqreturn_t button_handler (int irq, void *dev_id);
 int button_init (void);
 int button_add_callback (void (*callback) (void), int count);
 int button_del_callback (void (*callback) (void));
diff --git a/drivers/char/pc8736x_gpio.c b/drivers/char/pc8736x_gpio.c
index 84e5a68635f1..ecfaf180e5bd 100644
--- a/drivers/char/pc8736x_gpio.c
+++ b/drivers/char/pc8736x_gpio.c
@@ -188,16 +188,6 @@ static void pc8736x_gpio_set(unsigned minor, int val)
         pc8736x_gpio_shadow[port] = val;
 }
 
-static void pc8736x_gpio_set_high(unsigned index)
-{
-        pc8736x_gpio_set(index, 1);
-}
-
-static void pc8736x_gpio_set_low(unsigned index)
-{
-        pc8736x_gpio_set(index, 0);
-}
-
 static int pc8736x_gpio_current(unsigned minor)
 {
         int port, bit;
diff --git a/drivers/char/pcmcia/cm4000_cs.c b/drivers/char/pcmcia/cm4000_cs.c
index 50d20aafeb18..211c93fda6fc 100644
--- a/drivers/char/pcmcia/cm4000_cs.c
+++ b/drivers/char/pcmcia/cm4000_cs.c
@@ -1764,29 +1764,11 @@ static int cm4000_config(struct pcmcia_device * link, int devno)
         int rc;
 
         /* read the config-tuples */
-        tuple.DesiredTuple = CISTPL_CONFIG;
         tuple.Attributes = 0;
         tuple.TupleData = buf;
         tuple.TupleDataMax = sizeof(buf);
         tuple.TupleOffset = 0;
 
-        if ((fail_rc = pcmcia_get_first_tuple(link, &tuple)) != CS_SUCCESS) {
-                fail_fn = GetFirstTuple;
-                goto cs_failed;
-        }
-        if ((fail_rc = pcmcia_get_tuple_data(link, &tuple)) != CS_SUCCESS) {
-                fail_fn = GetTupleData;
-                goto cs_failed;
-        }
-        if ((fail_rc =
-             pcmcia_parse_tuple(link, &tuple, &parse)) != CS_SUCCESS) {
-                fail_fn = ParseTuple;
-                goto cs_failed;
-        }
-
-        link->conf.ConfigBase = parse.config.base;
-        link->conf.Present = parse.config.rmask[0];
-
         link->io.BasePort2 = 0;
         link->io.NumPorts2 = 0;
         link->io.Attributes2 = 0;
@@ -1841,8 +1823,6 @@ static int cm4000_config(struct pcmcia_device * link, int devno)
 
         return 0;
 
-cs_failed:
-        cs_error(link, fail_fn, fail_rc);
 cs_release:
         cm4000_release(link);
         return -ENODEV;
@@ -1973,14 +1953,14 @@ static int __init cmm_init(void)
         printk(KERN_INFO "%s\n", version);
 
         cmm_class = class_create(THIS_MODULE, "cardman_4000");
-        if (!cmm_class)
-                return -1;
+        if (IS_ERR(cmm_class))
+                return PTR_ERR(cmm_class);
 
         major = register_chrdev(0, DEVICE_NAME, &cm4000_fops);
         if (major < 0) {
                 printk(KERN_WARNING MODULE_NAME
                         ": could not get major number\n");
-                return -1;
+                return major;
         }
 
         rc = pcmcia_register_driver(&cm4000_driver);
diff --git a/drivers/char/pcmcia/cm4040_cs.c b/drivers/char/pcmcia/cm4040_cs.c
index 55cf4be42976..9b1ff7e8f896 100644
--- a/drivers/char/pcmcia/cm4040_cs.c
+++ b/drivers/char/pcmcia/cm4040_cs.c
@@ -523,29 +523,11 @@ static int reader_config(struct pcmcia_device *link, int devno)
         int fail_fn, fail_rc;
         int rc;
 
-        tuple.DesiredTuple = CISTPL_CONFIG;
         tuple.Attributes = 0;
         tuple.TupleData = buf;
         tuple.TupleDataMax = sizeof(buf);
         tuple.TupleOffset = 0;
 
-        if ((fail_rc = pcmcia_get_first_tuple(link, &tuple)) != CS_SUCCESS) {
-                fail_fn = GetFirstTuple;
-                goto cs_failed;
-        }
-        if ((fail_rc = pcmcia_get_tuple_data(link, &tuple)) != CS_SUCCESS) {
-                fail_fn = GetTupleData;
-                goto cs_failed;
-        }
-        if ((fail_rc = pcmcia_parse_tuple(link, &tuple, &parse))
-                                                        != CS_SUCCESS) {
-                fail_fn = ParseTuple;
-                goto cs_failed;
-        }
-
-        link->conf.ConfigBase = parse.config.base;
-        link->conf.Present = parse.config.rmask[0];
-
         link->io.BasePort2 = 0;
         link->io.NumPorts2 = 0;
         link->io.Attributes2 = 0;
@@ -609,8 +591,6 @@ static int reader_config(struct pcmcia_device *link, int devno)
 
         return 0;
 
-cs_failed:
-        cs_error(link, fail_fn, fail_rc);
 cs_release:
         reader_release(link);
         return -ENODEV;
@@ -721,14 +701,14 @@ static int __init cm4040_init(void)
 
         printk(KERN_INFO "%s\n", version);
         cmx_class = class_create(THIS_MODULE, "cardman_4040");
-        if (!cmx_class)
-                return -1;
+        if (IS_ERR(cmx_class))
+                return PTR_ERR(cmx_class);
 
         major = register_chrdev(0, DEVICE_NAME, &reader_fops);
         if (major < 0) {
                 printk(KERN_WARNING MODULE_NAME
                         ": could not get major number\n");
-                return -1;
+                return major;
         }
 
         rc = pcmcia_register_driver(&reader_driver);
diff --git a/drivers/char/pcmcia/synclink_cs.c b/drivers/char/pcmcia/synclink_cs.c
index 00f574cbb0d4..5152cedd8878 100644
--- a/drivers/char/pcmcia/synclink_cs.c
+++ b/drivers/char/pcmcia/synclink_cs.c
@@ -35,7 +35,6 @@
 
 #define MAX_DEVICE_COUNT 4
 
-#include <linux/config.h>       
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/signal.h>
@@ -57,7 +56,6 @@
 #include <linux/netdevice.h>
 #include <linux/vmalloc.h>
 #include <linux/init.h>
-#include <asm/serial.h>
 #include <linux/delay.h>
 #include <linux/ioctl.h>
 
@@ -77,8 +75,10 @@
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
 
-#ifdef CONFIG_HDLC_MODULE
-#define CONFIG_HDLC 1
+#if defined(CONFIG_HDLC) || (defined(CONFIG_HDLC_MODULE) && defined(CONFIG_SYNCLINK_CS_MODULE))
+#define SYNCLINK_GENERIC_HDLC 1
+#else
+#define SYNCLINK_GENERIC_HDLC 0
 #endif
 
 #define GET_USER(error,value,addr) error = get_user(value,addr)
@@ -237,7 +237,7 @@ typedef struct _mgslpc_info {
         int dosyncppp;
         spinlock_t netlock;
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
         struct net_device *netdev;
 #endif
 
@@ -394,7 +394,7 @@ static void tx_timeout(unsigned long context);
 
 static int ioctl_common(MGSLPC_INFO *info, unsigned int cmd, unsigned long arg);
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
 #define dev_to_port(D) (dev_to_hdlc(D)->priv)
 static void hdlcdev_tx_done(MGSLPC_INFO *info);
 static void hdlcdev_rx(MGSLPC_INFO *info, char *buf, int size);
@@ -418,12 +418,12 @@ static void rx_reset_buffers(MGSLPC_INFO *info);
 static int  rx_alloc_buffers(MGSLPC_INFO *info);
 static void rx_free_buffers(MGSLPC_INFO *info);
 
-static irqreturn_t mgslpc_isr(int irq, void *dev_id, struct pt_regs * regs);
+static irqreturn_t mgslpc_isr(int irq, void *dev_id);
 
 /*
  * Bottom half interrupt handlers
  */
-static void bh_handler(void* Context);
+static void bh_handler(struct work_struct *work);
 static void bh_transmit(MGSLPC_INFO *info);
 static void bh_status(MGSLPC_INFO *info);
 
@@ -549,7 +549,7 @@ static int mgslpc_probe(struct pcmcia_device *link)
 
     memset(info, 0, sizeof(MGSLPC_INFO));
     info->magic = MGSLPC_MAGIC;
-    INIT_WORK(&info->task, bh_handler, info);
+    INIT_WORK(&info->task, bh_handler);
     info->max_frame_size = 4096;
     info->close_delay = 5*HZ/10;
     info->closing_wait = 30*HZ;
@@ -606,17 +606,10 @@ static int mgslpc_config(struct pcmcia_device *link)
     if (debug_level >= DEBUG_LEVEL_INFO)
             printk("mgslpc_config(0x%p)\n", link);
 
-    /* read CONFIG tuple to find its configuration registers */
-    tuple.DesiredTuple = CISTPL_CONFIG;
     tuple.Attributes = 0;
     tuple.TupleData = buf;
     tuple.TupleDataMax = sizeof(buf);
     tuple.TupleOffset = 0;
-    CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
-    CS_CHECK(GetTupleData, pcmcia_get_tuple_data(link, &tuple));
-    CS_CHECK(ParseTuple, pcmcia_parse_tuple(link, &tuple, &parse));
-    link->conf.ConfigBase = parse.config.base;
-    link->conf.Present = parse.config.rmask[0];
 
     /* get CIS configuration entry */
 
@@ -844,9 +837,9 @@ static int bh_action(MGSLPC_INFO *info)
         return rc;
 }
 
-static void bh_handler(void* Context)
+static void bh_handler(struct work_struct *work)
 {
-        MGSLPC_INFO *info = (MGSLPC_INFO*)Context;
+        MGSLPC_INFO *info = container_of(work, MGSLPC_INFO, task);
         int action;
 
         if (!info)
@@ -1062,7 +1055,7 @@ static void tx_done(MGSLPC_INFO *info)
                 info->drop_rts_on_tx_done = 0;
         }
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
         if (info->netcount)
                 hdlcdev_tx_done(info);
         else 
@@ -1173,7 +1166,7 @@ static void dcd_change(MGSLPC_INFO *info)
         }
         else
                 info->input_signal_events.dcd_down++;
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
         if (info->netcount) {
                 if (info->serial_signals & SerialSignal_DCD)
                         netif_carrier_on(info->netdev);
@@ -1236,9 +1229,8 @@ static void ri_change(MGSLPC_INFO *info)
  * 
  * irq     interrupt number that caused interrupt
  * dev_id  device ID supplied during interrupt registration
- * regs    interrupted processor context
  */
-static irqreturn_t mgslpc_isr(int irq, void *dev_id, struct pt_regs * regs)
+static irqreturn_t mgslpc_isr(int irq, void *dev_id)
 {
         MGSLPC_INFO * info = (MGSLPC_INFO *)dev_id;
         unsigned short isr;
@@ -2383,7 +2375,7 @@ static int ioctl_common(MGSLPC_INFO *info, unsigned int cmd, unsigned long arg)
  *      tty             pointer to tty structure
  *      termios         pointer to buffer to hold returned old termios
  */
-static void mgslpc_set_termios(struct tty_struct *tty, struct termios *old_termios)
+static void mgslpc_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
 {
         MGSLPC_INFO *info = (MGSLPC_INFO *)tty->driver_data;
         unsigned long flags;
@@ -2963,7 +2955,7 @@ static void mgslpc_add_device(MGSLPC_INFO *info)
         printk( "SyncLink PC Card %s:IO=%04X IRQ=%d\n",
                 info->device_name, info->io_base, info->irq_level);
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
         hdlcdev_init(info);
 #endif
 }
@@ -2979,7 +2971,7 @@ static void mgslpc_remove_device(MGSLPC_INFO *remove_info)
                                 last->next_device = info->next_device;
                         else
                                 mgslpc_device_list = info->next_device;
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
                         hdlcdev_exit(info);
 #endif
                         release_resources(info);
@@ -3010,7 +3002,7 @@ static struct pcmcia_driver mgslpc_driver = {
         .resume         = mgslpc_resume,
 };
 
-static struct tty_operations mgslpc_ops = {
+static const struct tty_operations mgslpc_ops = {
         .open = mgslpc_open,
         .close = mgslpc_close,
         .write = mgslpc_write,
@@ -3911,7 +3903,7 @@ static int rx_get_frame(MGSLPC_INFO *info)
                                 return_frame = 1;
                 }
                 framesize = 0;
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
                 {
                         struct net_device_stats *stats = hdlc_stats(info->netdev);
                         stats->rx_errors++;
@@ -3945,7 +3937,7 @@ static int rx_get_frame(MGSLPC_INFO *info)
                                 ++framesize;
                         }
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
                         if (info->netcount)
                                 hdlcdev_rx(info, buf->data, framesize);
                         else
@@ -4101,7 +4093,7 @@ static void tx_timeout(unsigned long context)
 
         spin_unlock_irqrestore(&info->lock,flags);
         
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
         if (info->netcount)
                 hdlcdev_tx_done(info);
         else
@@ -4109,7 +4101,7 @@ static void tx_timeout(unsigned long context)
                 bh_transmit(info);
 }
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
 
 /**
  * called by generic HDLC layer when protocol selected (PPP, frame relay, etc.)
diff --git a/drivers/char/ppdev.c b/drivers/char/ppdev.c
index 520d2cf82bc0..4abd1eff61d6 100644
--- a/drivers/char/ppdev.c
+++ b/drivers/char/ppdev.c
@@ -106,7 +106,7 @@ static inline void pp_enable_irq (struct pp_struct *pp)
 static ssize_t pp_read (struct file * file, char __user * buf, size_t count,
                         loff_t * ppos)
 {
-        unsigned int minor = iminor(file->f_dentry->d_inode);
+        unsigned int minor = iminor(file->f_path.dentry->d_inode);
         struct pp_struct *pp = file->private_data;
         char * kbuffer;
         ssize_t bytes_read = 0;
@@ -189,7 +189,7 @@ static ssize_t pp_read (struct file * file, char __user * buf, size_t count,
 static ssize_t pp_write (struct file * file, const char __user * buf,
                          size_t count, loff_t * ppos)
 {
-        unsigned int minor = iminor(file->f_dentry->d_inode);
+        unsigned int minor = iminor(file->f_path.dentry->d_inode);
         struct pp_struct *pp = file->private_data;
         char * kbuffer;
         ssize_t bytes_written = 0;
@@ -269,7 +269,7 @@ static ssize_t pp_write (struct file * file, const char __user * buf,
         return bytes_written;
 }
 
-static void pp_irq (int irq, void * private, struct pt_regs * unused)
+static void pp_irq (int irq, void * private)
 {
         struct pp_struct * pp = (struct pp_struct *) private;
 
@@ -752,13 +752,13 @@ static const struct file_operations pp_fops = {
 
 static void pp_attach(struct parport *port)
 {
-        class_device_create(ppdev_class, NULL, MKDEV(PP_MAJOR, port->number),
-                        NULL, "parport%d", port->number);
+        device_create(ppdev_class, NULL, MKDEV(PP_MAJOR, port->number),
+                        "parport%d", port->number);
 }
 
 static void pp_detach(struct parport *port)
 {
-        class_device_destroy(ppdev_class, MKDEV(PP_MAJOR, port->number));
+        device_destroy(ppdev_class, MKDEV(PP_MAJOR, port->number));
 }
 
 static struct parport_driver pp_driver = {
diff --git a/drivers/char/pty.c b/drivers/char/pty.c
index 34dd4c38110e..c07a1b5cd05d 100644
--- a/drivers/char/pty.c
+++ b/drivers/char/pty.c
@@ -218,13 +218,13 @@ out:
         return retval;
 }
 
-static void pty_set_termios(struct tty_struct *tty, struct termios *old_termios)
+static void pty_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
 {
         tty->termios->c_cflag &= ~(CSIZE | PARENB);
         tty->termios->c_cflag |= (CS8 | CREAD);
 }
 
-static struct tty_operations pty_ops = {
+static const struct tty_operations pty_ops = {
         .open = pty_open,
         .close = pty_close,
         .write = pty_write,
@@ -272,6 +272,8 @@ static void __init legacy_pty_init(void)
         pty_driver->init_termios.c_oflag = 0;
         pty_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
         pty_driver->init_termios.c_lflag = 0;
+        pty_driver->init_termios.c_ispeed = 38400;
+        pty_driver->init_termios.c_ospeed = 38400;
         pty_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW;
         pty_driver->other = pty_slave_driver;
         tty_set_operations(pty_driver, &pty_ops);
@@ -286,6 +288,8 @@ static void __init legacy_pty_init(void)
         pty_slave_driver->subtype = PTY_TYPE_SLAVE;
         pty_slave_driver->init_termios = tty_std_termios;
         pty_slave_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
+        pty_slave_driver->init_termios.c_ispeed = 38400;
+        pty_slave_driver->init_termios.c_ospeed = 38400;
         pty_slave_driver->flags = TTY_DRIVER_RESET_TERMIOS |
                                         TTY_DRIVER_REAL_RAW;
         pty_slave_driver->other = pty_driver;
@@ -366,6 +370,8 @@ static void __init unix98_pty_init(void)
         ptm_driver->init_termios.c_oflag = 0;
         ptm_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
         ptm_driver->init_termios.c_lflag = 0;
+        ptm_driver->init_termios.c_ispeed = 38400;
+        ptm_driver->init_termios.c_ospeed = 38400;
         ptm_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW |
                 TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_DEVPTS_MEM;
         ptm_driver->other = pts_driver;
@@ -381,6 +387,8 @@ static void __init unix98_pty_init(void)
         pts_driver->subtype = PTY_TYPE_SLAVE;
         pts_driver->init_termios = tty_std_termios;
         pts_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
+        pts_driver->init_termios.c_ispeed = 38400;
+        pts_driver->init_termios.c_ospeed = 38400;
         pts_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW |
                 TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_DEVPTS_MEM;
         pts_driver->other = ptm_driver;
diff --git a/drivers/char/qtronix.c b/drivers/char/qtronix.c
deleted file mode 100644
index 9d134e98d2a0..000000000000
--- a/drivers/char/qtronix.c
+++ /dev/null
@@ -1,605 +0,0 @@
-/*
- *
- * BRIEF MODULE DESCRIPTION
- *      Qtronix 990P infrared keyboard driver.
- *
- *
- * Copyright 2001 MontaVista Software Inc.
- * Author: MontaVista Software, Inc.
- *              ppopov@mvista.com or source@mvista.com
- *
- *
- *  The bottom portion of this driver was take from 
- *  pc_keyb.c  Please see that file for copyrights.
- *
- *  This program is free software; you can redistribute  it and/or modify it
- *  under  the terms of  the GNU General  Public License as published by the
- *  Free Software Foundation;  either version 2 of the  License, or (at your
- *  option) any later version.
- *
- *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
- *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
- *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
- *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
- *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
- *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
- *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
- *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- *  You should have received a copy of the  GNU General Public License along
- *  with this program; if not, write  to the Free Software Foundation, Inc.,
- *  675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-
-/* 
- * NOTE:  
- *
- *      This driver has only been tested with the Consumer IR
- *      port of the ITE 8172 system controller.
- *
- *      You do not need this driver if you are using the ps/2 or
- *      USB adapter that the keyboard ships with.  You only need 
- *      this driver if your board has a IR port and the keyboard
- *      data is being sent directly to the IR.  In that case,
- *      you also need some low-level IR support. See it8172_cir.c.
- *      
- */
-
-#ifdef CONFIG_QTRONIX_KEYBOARD
-
-#include <linux/module.h>
-#include <linux/types.h>
-#include <linux/pci.h>
-#include <linux/kernel.h>
-
-#include <asm/it8172/it8172.h>
-#include <asm/it8172/it8172_int.h>
-#include <asm/it8172/it8172_cir.h>
-
-#include <linux/spinlock.h>
-#include <linux/sched.h>
-#include <linux/interrupt.h>
-#include <linux/tty.h>
-#include <linux/mm.h>
-#include <linux/signal.h>
-#include <linux/init.h>
-#include <linux/kbd_ll.h>
-#include <linux/delay.h>
-#include <linux/poll.h>
-#include <linux/miscdevice.h>
-#include <linux/slab.h>
-#include <linux/kbd_kern.h>
-#include <linux/smp_lock.h>
-#include <asm/io.h>
-#include <linux/pc_keyb.h>
-
-#include <asm/keyboard.h>
-#include <linux/bitops.h>
-#include <asm/uaccess.h>
-#include <asm/irq.h>
-#include <asm/system.h>
-
-#define leading1 0
-#define leading2 0xF
-
-#define KBD_CIR_PORT 0
-#define AUX_RECONNECT 170 /* scancode when ps2 device is plugged (back) in */
-
-static int data_index;
-struct cir_port *cir;
-static unsigned char kbdbytes[5];
-static unsigned char cir_data[32]; /* we only need 16 chars */
-
-static void kbd_int_handler(int irq, void *dev_id, struct pt_regs *regs);
-static int handle_data(unsigned char *p_data);
-static inline void handle_mouse_event(unsigned char scancode);
-static inline void handle_keyboard_event(unsigned char scancode, int down);
-static int __init psaux_init(void);
-
-static struct aux_queue *queue; /* Mouse data buffer. */
-static int aux_count = 0;
-
-/*
- * Keys accessed through the 'Fn' key
- * The Fn key does not produce a key-up sequence. So, the first
- * time the user presses it, it will be key-down event. The key
- * stays down until the user presses it again.
- */
-#define NUM_FN_KEYS 56
-static unsigned char fn_keys[NUM_FN_KEYS] = {
-        0,0,0,0,0,0,0,0,        /* 0 7   */
-        8,9,10,93,0,0,0,0,      /* 8 15  */
-        0,0,0,0,0,0,0,5,        /* 16 23 */
-        6,7,91,0,0,0,0,0,       /* 24 31 */
-        0,0,0,0,0,2,3,4,        /* 32 39 */
-        92,0,0,0,0,0,0,0,       /* 40 47 */
-        0,0,0,0,11,0,94,95        /* 48 55 */
-
-};
-
-void __init init_qtronix_990P_kbd(void)
-{
-        int retval;
-
-        cir = (struct cir_port *)kmalloc(sizeof(struct cir_port), GFP_KERNEL);
-        if (!cir) {
-                printk("Unable to initialize Qtronix keyboard\n");
-                return;
-        }
-
-        /* 
-         * revisit
-         * this should be programmable, somehow by the, by the user.
-         */
-        cir->port = KBD_CIR_PORT;
-        cir->baud_rate = 0x1d;
-        cir->rdwos = 0;
-        cir->rxdcr = 0x3;
-        cir->hcfs = 0;
-        cir->fifo_tl = 0;
-        cir->cfq = 0x1d;
-        cir_port_init(cir);
-
-        retval = request_irq(IT8172_CIR0_IRQ, kbd_int_handler, 
-                        (unsigned long )(IRQF_DISABLED|IRQF_SHARED),
-                        (const char *)"Qtronix IR Keyboard", (void *)cir);
-
-        if (retval) {
-                printk("unable to allocate cir %d irq %d\n", 
-                                cir->port, IT8172_CIR0_IRQ);
-        }
-#ifdef CONFIG_PSMOUSE
-        psaux_init();
-#endif
-}
-
-static inline unsigned char BitReverse(unsigned short key)
-{
-        unsigned char rkey = 0;
-        rkey |= (key & 0x1) << 7;
-        rkey |= (key & 0x2) << 5;
-        rkey |= (key & 0x4) << 3;
-        rkey |= (key & 0x8) << 1;
-        rkey |= (key & 0x10) >> 1;
-        rkey |= (key & 0x20) >> 3;
-        rkey |= (key & 0x40) >> 5;
-        rkey |= (key & 0x80) >> 7;
-        return rkey;
-
-}
-
-
-static inline u_int8_t UpperByte(u_int8_t data)
-{
-        return (data >> 4);
-}
-
-
-static inline u_int8_t LowerByte(u_int8_t data)
-{
-        return (data & 0xF);
-}
-
-
-int CheckSumOk(u_int8_t byte1, u_int8_t byte2, 
-                u_int8_t byte3, u_int8_t byte4, u_int8_t byte5)
-{
-        u_int8_t CheckSum;
-
-        CheckSum = (byte1 & 0x0F) + byte2 + byte3 + byte4 + byte5;
-        if ( LowerByte(UpperByte(CheckSum) + LowerByte(CheckSum)) != UpperByte(byte1) )
-                return 0;
-        else
-                return 1;
-}
-
-
-static void kbd_int_handler(int irq, void *dev_id, struct pt_regs *regs)
-{
-        struct cir_port *cir;
-        int j;
-        unsigned char int_status;
-
-        cir = (struct cir_port *)dev_id;
-        int_status = get_int_status(cir);
-        if (int_status & 0x4) {
-                clear_fifo(cir);
-                return;
-        }
-
-        while (cir_get_rx_count(cir)) {
-
-                cir_data[data_index] = cir_read_data(cir);
-
-                if (data_index == 0) {/* expecting first byte */
-                        if (cir_data[data_index] != leading1) {
-                                //printk("!leading byte %x\n", cir_data[data_index]);
-                                set_rx_active(cir);
-                                clear_fifo(cir);
-                                continue;
-                        }
-                }
-                if (data_index == 1) {
-                        if ((cir_data[data_index] & 0xf) != leading2) {
-                                set_rx_active(cir);
-                                data_index = 0; /* start over */
-                                clear_fifo(cir);
-                                continue;
-                        }
-                }
-
-                if ( (cir_data[data_index] == 0xff)) { /* last byte */
-                        //printk("data_index %d\n", data_index);
-                        set_rx_active(cir);
-#if 0
-                        for (j=0; j<=data_index; j++) {
-                                printk("rx_data %d:  %x\n", j, cir_data[j]);
-                        }
-#endif
-                        data_index = 0;
-                        handle_data(cir_data);
-                        return;
-                }
-                else if (data_index>16) {
-                        set_rx_active(cir);
-#if 0
-                        printk("warning: data_index %d\n", data_index);
-                        for (j=0; j<=data_index; j++) {
-                                printk("rx_data %d:  %x\n", j, cir_data[j]);
-                        }
-#endif
-                        data_index = 0;
-                        clear_fifo(cir);
-                        return;
-                }
-                data_index++;
-        }
-}
-
-
-#define NUM_KBD_BYTES 5
-static int handle_data(unsigned char *p_data)
-{
-        u_int32_t bit_bucket;
-        u_int32_t i, j;
-        u_int32_t got_bits, next_byte;
-        int down = 0;
-
-        /* Reorganize the bit stream */
-        for (i=0; i<16; i++)
-                p_data[i] = BitReverse(~p_data[i]);
-
-        /* 
-         * We've already previously checked that p_data[0]
-         * is equal to leading1 and that (p_data[1] & 0xf)
-         * is equal to leading2. These twelve bits are the
-         * leader code.  We can now throw them away (the 12
-         * bits) and continue parsing the stream.
-         */
-        bit_bucket = p_data[1] << 12;
-        got_bits = 4;
-        next_byte = 2;
-
-        /* 
-         * Process four bits at a time
-         */
-        for (i=0; i<NUM_KBD_BYTES; i++) {
-
-                kbdbytes[i]=0;
-
-                for (j=0; j<8; j++) /* 8 bits per byte */
-                {
-                        if (got_bits < 4) {
-                                bit_bucket |= (p_data[next_byte++] << (8 - got_bits));
-                                got_bits += 8;
-                        }
-
-                        if ((bit_bucket & 0xF000) == 0x8000) { 
-                                /* Convert 1000b to 1 */
-                                kbdbytes[i] = 0x80 | (kbdbytes[i] >> 1);
-                                got_bits -= 4;
-                                bit_bucket = bit_bucket << 4;
-                        }
-                        else if ((bit_bucket & 0xC000) == 0x8000) {
-                                /* Convert 10b to 0 */
-                                kbdbytes[i] =  kbdbytes[i] >> 1;
-                                got_bits -= 2;
-                                bit_bucket = bit_bucket << 2;
-                        }
-                        else {
-                                /* bad serial stream */
-                                return 1;
-                        }
-
-                        if (next_byte > 16) {
-                                //printk("error: too many bytes\n");
-                                return 1;
-                        }
-                }
-        }
-
-
-        if (!CheckSumOk(kbdbytes[0], kbdbytes[1], 
-                                kbdbytes[2], kbdbytes[3], kbdbytes[4])) {
-                //printk("checksum failed\n");
-                return 1;
-        }
-
-        if (kbdbytes[1] & 0x08) {
-                //printk("m: %x %x %x\n", kbdbytes[1], kbdbytes[2], kbdbytes[3]);
-                handle_mouse_event(kbdbytes[1]);
-                handle_mouse_event(kbdbytes[2]);
-                handle_mouse_event(kbdbytes[3]);
-        }
-        else {
-                if (kbdbytes[2] == 0) down = 1;
-#if 0
-                if (down)
-                        printk("down %d\n", kbdbytes[3]);
-                else
-                        printk("up %d\n", kbdbytes[3]);
-#endif
-                handle_keyboard_event(kbdbytes[3], down);
-        }
-        return 0;
-}
-
-
-DEFINE_SPINLOCK(kbd_controller_lock);
-static unsigned char handle_kbd_event(void);
-
-
-int kbd_setkeycode(unsigned int scancode, unsigned int keycode)
-{
-        printk("kbd_setkeycode scancode %x keycode %x\n", scancode, keycode);
-        return 0;
-}
-
-int kbd_getkeycode(unsigned int scancode)
-{
-        return scancode;
-}
-
-
-int kbd_translate(unsigned char scancode, unsigned char *keycode,
-                    char raw_mode)
-{
-        static int prev_scancode = 0;
-
-        if (scancode == 0x00 || scancode == 0xff) {
-                prev_scancode = 0;
-                return 0;
-        }
-
-        /* todo */
-        if (!prev_scancode && scancode == 160) { /* Fn key down */
-                //printk("Fn key down\n");
-                prev_scancode = 160;
-                return 0;
-        }
-        else if (prev_scancode && scancode == 160) { /* Fn key up */
-                //printk("Fn key up\n");
-                prev_scancode = 0;
-                return 0;
-        }
-
-        /* todo */
-        if (prev_scancode == 160) {
-                if (scancode <= NUM_FN_KEYS) {
-                        *keycode = fn_keys[scancode];
-                        //printk("fn keycode %d\n", *keycode);
-                }
-                else
-                        return 0;
-        } 
-        else if (scancode <= 127) {
-                *keycode = scancode;
-        }
-        else
-                return 0;
-
-
-        return 1;
-}
-
-char kbd_unexpected_up(unsigned char keycode)
-{
-        //printk("kbd_unexpected_up\n");
-        return 0;
-}
-
-static unsigned char kbd_exists = 1;
-
-static inline void handle_keyboard_event(unsigned char scancode, int down)
-{
-        kbd_exists = 1;
-        handle_scancode(scancode, down);
-        tasklet_schedule(&keyboard_tasklet);
-}       
-
-
-void kbd_leds(unsigned char leds)
-{
-}
-
-/* dummy */
-void kbd_init_hw(void)
-{
-}
-
-
-
-static inline void handle_mouse_event(unsigned char scancode)
-{
-        if(scancode == AUX_RECONNECT){
-                queue->head = queue->tail = 0;  /* Flush input queue */
-        //      __aux_write_ack(AUX_ENABLE_DEV);  /* ping the mouse :) */
-                return;
-        }
-
-        if (aux_count) {
-                int head = queue->head;
-
-                queue->buf[head] = scancode;
-                head = (head + 1) & (AUX_BUF_SIZE-1);
-                if (head != queue->tail) {
-                        queue->head = head;
-                        kill_fasync(&queue->fasync, SIGIO, POLL_IN);
-                        wake_up_interruptible(&queue->proc_list);
-                }
-        }
-}
-
-static unsigned char get_from_queue(void)
-{
-        unsigned char result;
-        unsigned long flags;
-
-        spin_lock_irqsave(&kbd_controller_lock, flags);
-        result = queue->buf[queue->tail];
-        queue->tail = (queue->tail + 1) & (AUX_BUF_SIZE-1);
-        spin_unlock_irqrestore(&kbd_controller_lock, flags);
-        return result;
-}
-
-
-static inline int queue_empty(void)
-{
-        return queue->head == queue->tail;
-}
-
-static int fasync_aux(int fd, struct file *filp, int on)
-{
-        int retval;
-
-        //printk("fasync_aux\n");
-        retval = fasync_helper(fd, filp, on, &queue->fasync);
-        if (retval < 0)
-                return retval;
-        return 0;
-}
-
-
-/*
- * Random magic cookie for the aux device
- */
-#define AUX_DEV ((void *)queue)
-
-static int release_aux(struct inode * inode, struct file * file)
-{
-        fasync_aux(-1, file, 0);
-        aux_count--;
-        return 0;
-}
-
-static int open_aux(struct inode * inode, struct file * file)
-{
-        if (aux_count++) {
-                return 0;
-        }
-        queue->head = queue->tail = 0;          /* Flush input queue */
-        return 0;
-}
-
-/*
- * Put bytes from input queue to buffer.
- */
-
-static ssize_t read_aux(struct file * file, char * buffer,
-                        size_t count, loff_t *ppos)
-{
-        DECLARE_WAITQUEUE(wait, current);
-        ssize_t i = count;
-        unsigned char c;
-
-        if (queue_empty()) {
-                if (file->f_flags & O_NONBLOCK)
-                        return -EAGAIN;
-                add_wait_queue(&queue->proc_list, &wait);
-repeat:
-                set_current_state(TASK_INTERRUPTIBLE);
-                if (queue_empty() && !signal_pending(current)) {
-                        schedule();
-                        goto repeat;
-                }
-                current->state = TASK_RUNNING;
-                remove_wait_queue(&queue->proc_list, &wait);
-        }
-        while (i > 0 && !queue_empty()) {
-                c = get_from_queue();
-                put_user(c, buffer++);
-                i--;
-        }
-        if (count-i) {
-                struct inode *inode = file->f_dentry->d_inode;
-                inode->i_atime = current_fs_time(inode->i_sb);
-                return count-i;
-        }
-        if (signal_pending(current))
-                return -ERESTARTSYS;
-        return 0;
-}
-
-/*
- * Write to the aux device.
- */
-
-static ssize_t write_aux(struct file * file, const char * buffer,
-                         size_t count, loff_t *ppos)
-{
-        /*
-         * The ITE boards this was tested on did not have the
-         * transmit wires connected.
-         */
-        return count;
-}
-
-static unsigned int aux_poll(struct file *file, poll_table * wait)
-{
-        poll_wait(file, &queue->proc_list, wait);
-        if (!queue_empty())
-                return POLLIN | POLLRDNORM;
-        return 0;
-}
-
-struct file_operations psaux_fops = {
-        .read           = read_aux,
-        .write          = write_aux,
-        .poll           = aux_poll,
-        .open           = open_aux,
-        .release        = release_aux,
-        .fasync         = fasync_aux,
-};
-
-/*
- * Initialize driver.
- */
-static struct miscdevice psaux_mouse = {
-        PSMOUSE_MINOR, "psaux", &psaux_fops
-};
-
-static int __init psaux_init(void)
-{
-        int retval;
-
-        retval = misc_register(&psaux_mouse);
-        if(retval < 0)
-                return retval;
-
-        queue = (struct aux_queue *) kmalloc(sizeof(*queue), GFP_KERNEL);
-        if (!queue) {
-                misc_deregister(&psaux_mouse);
-                return -ENOMEM;
-        }
-                
-        memset(queue, 0, sizeof(*queue));
-        queue->head = queue->tail = 0;
-        init_waitqueue_head(&queue->proc_list);
-
-        return 0;
-}
-module_init(init_qtronix_990P_kbd);
-#endif
diff --git a/drivers/char/qtronixmap.c_shipped b/drivers/char/qtronixmap.c_shipped
deleted file mode 100644
index 1e2b92b7d57a..000000000000
--- a/drivers/char/qtronixmap.c_shipped
+++ /dev/null
@@ -1,265 +0,0 @@
-
-/* Do not edit this file! It was automatically generated by   */
-/*    loadkeys --mktable defkeymap.map > defkeymap.c          */
-
-#include <linux/types.h>
-#include <linux/keyboard.h>
-#include <linux/kd.h>
-
-u_short plain_map[NR_KEYS] = {
-        0xf200, 0xf060, 0xf031, 0xf032, 0xf033, 0xf034, 0xf035, 0xf036,
-        0xf037, 0xf038, 0xf039, 0xf030, 0xf02d, 0xf03d, 0xf200, 0xf07f,
-        0xf009, 0xfb71, 0xfb77, 0xfb65, 0xfb72, 0xfb74, 0xfb79, 0xfb75,
-        0xfb69, 0xfb6f, 0xfb70, 0xf05b, 0xf05d, 0xf05c, 0xf207, 0xfb61,
-        0xfb73, 0xfb64, 0xfb66, 0xfb67, 0xfb68, 0xfb6a, 0xfb6b, 0xfb6c,
-        0xf03b, 0xf027, 0xf060, 0xf201, 0xf700, 0xf200, 0xfb7a, 0xfb78,
-        0xfb63, 0xfb76, 0xfb62, 0xfb6e, 0xfb6d, 0xf02c, 0xf02e, 0xf02f,
-        0xf200, 0xf700, 0xf702, 0xf200, 0xf703, 0xf020, 0xf703, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf115, 0xf07f, 0xf200, 0xf200, 0xf601,
-        0xf200, 0xf200, 0xf200, 0xf603, 0xf600, 0xf118, 0xf119, 0xf200,
-        0xf200, 0xf602, 0xf208, 0xf02d, 0xf02b, 0xf30c, 0xf02e, 0xf30d,
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf117, 0xf600, 0xf200, 0xf01b, 0xf200,
-        0xf100, 0xf101, 0xf102, 0xf103, 0xf104, 0xf105, 0xf106, 0xf107,
-        0xf108, 0xf109, 0xf200, 0xf200, 0xf200, 0xf200, 0xf11d, 0xf200,
-};
-
-u_short shift_map[NR_KEYS] = {
-        0xf200, 0xf07e, 0xf021, 0xf040, 0xf023, 0xf024, 0xf025, 0xf05e,
-        0xf026, 0xf02a, 0xf028, 0xf029, 0xf05f, 0xf02b, 0xf200, 0xf07f,
-        0xf009, 0xfb51, 0xfb57, 0xfb45, 0xfb52, 0xfb54, 0xfb59, 0xfb55,
-        0xfb49, 0xfb4f, 0xfb50, 0xf07b, 0xf07d, 0xf07c, 0xf207, 0xfb41,
-        0xfb53, 0xfb44, 0xfb46, 0xfb47, 0xfb48, 0xfb4a, 0xfb4b, 0xfb4c,
-        0xf03a, 0xf022, 0xf07e, 0xf201, 0xf700, 0xf200, 0xfb5a, 0xfb58,
-        0xfb43, 0xfb56, 0xfb42, 0xfb4e, 0xfb4d, 0xf03c, 0xf03e, 0xf03f,
-        0xf200, 0xf700, 0xf702, 0xf200, 0xf703, 0xf020, 0xf703, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf115, 0xf07f, 0xf200, 0xf200, 0xf601,
-        0xf200, 0xf200, 0xf200, 0xf603, 0xf600, 0xf20b, 0xf20a, 0xf200,
-        0xf200, 0xf602, 0xf213, 0xf02d, 0xf02b, 0xf30c, 0xf02e, 0xf30d,
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf117, 0xf600, 0xf200, 0xf01b, 0xf200,
-        0xf10a, 0xf10b, 0xf10c, 0xf10d, 0xf10e, 0xf10f, 0xf110, 0xf111,
-        0xf112, 0xf113, 0xf200, 0xf200, 0xf200, 0xf200, 0xf11d, 0xf200,
-};
-
-u_short altgr_map[NR_KEYS] = {
-        0xf200, 0xf200, 0xf200, 0xf040, 0xf200, 0xf024, 0xf200, 0xf200,
-        0xf07b, 0xf05b, 0xf05d, 0xf07d, 0xf05c, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xfb71, 0xfb77, 0xfb65, 0xfb72, 0xfb74, 0xfb79, 0xfb75,
-        0xfb69, 0xfb6f, 0xfb70, 0xf200, 0xf200, 0xf200, 0xf207, 0xfb61,
-        0xfb73, 0xfb64, 0xfb66, 0xfb67, 0xfb68, 0xfb6a, 0xfb6b, 0xfb6c,
-        0xf200, 0xf200, 0xf200, 0xf201, 0xf700, 0xf200, 0xfb7a, 0xfb78,
-        0xfb63, 0xfb76, 0xfb62, 0xfb6e, 0xfb6d, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xf700, 0xf702, 0xf200, 0xf703, 0xf200, 0xf703, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf115, 0xf07f, 0xf200, 0xf200, 0xf601,
-        0xf200, 0xf200, 0xf200, 0xf603, 0xf600, 0xf118, 0xf119, 0xf200,
-        0xf200, 0xf602, 0xf208, 0xf02d, 0xf02b, 0xf30c, 0xf02e, 0xf30d,
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf117, 0xf600, 0xf200, 0xf200, 0xf200,
-        0xf50c, 0xf50d, 0xf50e, 0xf50f, 0xf510, 0xf511, 0xf512, 0xf513,
-        0xf514, 0xf515, 0xf200, 0xf200, 0xf200, 0xf200, 0xf11d, 0xf200,
-};
-
-u_short ctrl_map[NR_KEYS] = {
-        0xf200, 0xf200, 0xf200, 0xf000, 0xf01b, 0xf01c, 0xf01d, 0xf01e,
-        0xf01f, 0xf07f, 0xf200, 0xf200, 0xf01f, 0xf200, 0xf200, 0xf008,
-        0xf200, 0xf011, 0xf017, 0xf005, 0xf012, 0xf014, 0xf019, 0xf015,
-        0xf009, 0xf00f, 0xf010, 0xf01b, 0xf01d, 0xf01c, 0xf207, 0xf001,
-        0xf013, 0xf004, 0xf006, 0xf007, 0xf008, 0xf00a, 0xf00b, 0xf00c,
-        0xf007, 0xf000, 0xf200, 0xf201, 0xf700, 0xf200, 0xf01a, 0xf018,
-        0xf003, 0xf016, 0xf002, 0xf00e, 0xf20e, 0xf07f, 0xf200, 0xf200,
-        0xf200, 0xf700, 0xf702, 0xf200, 0xf703, 0xf000, 0xf703, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf115, 0xf07f, 0xf200, 0xf200, 0xf601,
-        0xf200, 0xf200, 0xf200, 0xf603, 0xf600, 0xf118, 0xf119, 0xf200,
-        0xf200, 0xf602, 0xf208, 0xf02d, 0xf02b, 0xf30c, 0xf02e, 0xf30d,
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf117, 0xf600, 0xf200, 0xf200, 0xf200,
-        0xf100, 0xf101, 0xf102, 0xf103, 0xf104, 0xf105, 0xf106, 0xf107,
-        0xf108, 0xf109, 0xf200, 0xf200, 0xf200, 0xf200, 0xf11d, 0xf200,
-};
-
-u_short shift_ctrl_map[NR_KEYS] = {
-        0xf200, 0xf200, 0xf200, 0xf000, 0xf200, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf01f, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xf011, 0xf017, 0xf005, 0xf012, 0xf014, 0xf019, 0xf015,
-        0xf009, 0xf00f, 0xf010, 0xf200, 0xf200, 0xf200, 0xf207, 0xf001,
-        0xf013, 0xf004, 0xf006, 0xf007, 0xf008, 0xf00a, 0xf00b, 0xf00c,
-        0xf200, 0xf200, 0xf200, 0xf201, 0xf700, 0xf200, 0xf01a, 0xf018,
-        0xf003, 0xf016, 0xf002, 0xf00e, 0xf00d, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xf700, 0xf702, 0xf200, 0xf703, 0xf200, 0xf703, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf115, 0xf07f, 0xf200, 0xf200, 0xf601,
-        0xf200, 0xf200, 0xf200, 0xf603, 0xf600, 0xf118, 0xf119, 0xf200,
-        0xf200, 0xf602, 0xf208, 0xf02d, 0xf02b, 0xf30c, 0xf02e, 0xf30d,
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf117, 0xf600, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf11d, 0xf200,
-};
-
-u_short alt_map[NR_KEYS] = {
-        0xf200, 0xf81b, 0xf831, 0xf832, 0xf833, 0xf834, 0xf835, 0xf836,
-        0xf837, 0xf838, 0xf839, 0xf830, 0xf82d, 0xf83d, 0xf200, 0xf87f,
-        0xf809, 0xf871, 0xf877, 0xf865, 0xf872, 0xf874, 0xf879, 0xf875,
-        0xf869, 0xf86f, 0xf870, 0xf85b, 0xf85d, 0xf85c, 0xf207, 0xf861,
-        0xf873, 0xf864, 0xf866, 0xf867, 0xf868, 0xf86a, 0xf86b, 0xf83b,
-        0xf827, 0xf860, 0xf200, 0xf80d, 0xf700, 0xf200, 0xf87a, 0xf878,
-        0xf863, 0xf876, 0xf862, 0xf82c, 0xf82e, 0xf82f, 0xf200, 0xf200,
-        0xf200, 0xf700, 0xf702, 0xf200, 0xf703, 0xf820, 0xf703, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf115, 0xf07f, 0xf200, 0xf200, 0xf210,
-        0xf200, 0xf200, 0xf200, 0xf603, 0xf600, 0xf118, 0xf119, 0xf200,
-        0xf200, 0xf211, 0xf208, 0xf02d, 0xf02b, 0xf30c, 0xf02e, 0xf30d,
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf117, 0xf600, 0xf200, 0xf200, 0xf200,
-        0xf500, 0xf501, 0xf502, 0xf503, 0xf504, 0xf505, 0xf506, 0xf507,
-        0xf508, 0xf509, 0xf200, 0xf200, 0xf200, 0xf200, 0xf11d, 0xf200,
-};
-
-u_short ctrl_alt_map[NR_KEYS] = {
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xf811, 0xf817, 0xf805, 0xf812, 0xf814, 0xf819, 0xf815,
-        0xf809, 0xf80f, 0xf810, 0xf200, 0xf200, 0xf200, 0xf207, 0xf801,
-        0xf813, 0xf804, 0xf806, 0xf807, 0xf808, 0xf80a, 0xf80b, 0xf80c,
-        0xf200, 0xf200, 0xf200, 0xf201, 0xf700, 0xf200, 0xf81a, 0xf818,
-        0xf803, 0xf816, 0xf802, 0xf80e, 0xf80d, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xf700, 0xf702, 0xf200, 0xf703, 0xf200, 0xf703, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf115, 0xf07f, 0xf200, 0xf200, 0xf601,
-        0xf200, 0xf200, 0xf200, 0xf603, 0xf600, 0xf118, 0xf119, 0xf200,
-        0xf200, 0xf602, 0xf208, 0xf02d, 0xf02b, 0xf30c, 0xf02e, 0xf30d,
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf117, 0xf600, 0xf200, 0xf200, 0xf200,
-        0xf500, 0xf501, 0xf502, 0xf503, 0xf504, 0xf505, 0xf506, 0xf507,
-        0xf508, 0xf509, 0xf200, 0xf200, 0xf200, 0xf200, 0xf11d, 0xf200,
-};
-
-ushort *key_maps[MAX_NR_KEYMAPS] = {
-        plain_map, shift_map, altgr_map, 0,
-        ctrl_map, shift_ctrl_map, 0, 0,
-        alt_map, 0, 0, 0,
-        ctrl_alt_map,   0
-};
-
-unsigned int keymap_count = 7;
-
-
-/*
- * Philosophy: most people do not define more strings, but they who do
- * often want quite a lot of string space. So, we statically allocate
- * the default and allocate dynamically in chunks of 512 bytes.
- */
-
-char func_buf[] = {
-        '\033', '[', '[', 'A', 0, 
-        '\033', '[', '[', 'B', 0, 
-        '\033', '[', '[', 'C', 0, 
-        '\033', '[', '[', 'D', 0, 
-        '\033', '[', '[', 'E', 0, 
-        '\033', '[', '1', '7', '~', 0, 
-        '\033', '[', '1', '8', '~', 0, 
-        '\033', '[', '1', '9', '~', 0, 
-        '\033', '[', '2', '0', '~', 0, 
-        '\033', '[', '2', '1', '~', 0, 
-        '\033', '[', '2', '3', '~', 0, 
-        '\033', '[', '2', '4', '~', 0, 
-        '\033', '[', '2', '5', '~', 0, 
-        '\033', '[', '2', '6', '~', 0, 
-        '\033', '[', '2', '8', '~', 0, 
-        '\033', '[', '2', '9', '~', 0, 
-        '\033', '[', '3', '1', '~', 0, 
-        '\033', '[', '3', '2', '~', 0, 
-        '\033', '[', '3', '3', '~', 0, 
-        '\033', '[', '3', '4', '~', 0, 
-        '\033', '[', '1', '~', 0, 
-        '\033', '[', '2', '~', 0, 
-        '\033', '[', '3', '~', 0, 
-        '\033', '[', '4', '~', 0, 
-        '\033', '[', '5', '~', 0, 
-        '\033', '[', '6', '~', 0, 
-        '\033', '[', 'M', 0, 
-        '\033', '[', 'P', 0, 
-};
-
-
-char *funcbufptr = func_buf;
-int funcbufsize = sizeof(func_buf);
-int funcbufleft = 0;          /* space left */
-
-char *func_table[MAX_NR_FUNC] = {
-        func_buf + 0,
-        func_buf + 5,
-        func_buf + 10,
-        func_buf + 15,
-        func_buf + 20,
-        func_buf + 25,
-        func_buf + 31,
-        func_buf + 37,
-        func_buf + 43,
-        func_buf + 49,
-        func_buf + 55,
-        func_buf + 61,
-        func_buf + 67,
-        func_buf + 73,
-        func_buf + 79,
-        func_buf + 85,
-        func_buf + 91,
-        func_buf + 97,
-        func_buf + 103,
-        func_buf + 109,
-        func_buf + 115,
-        func_buf + 120,
-        func_buf + 125,
-        func_buf + 130,
-        func_buf + 135,
-        func_buf + 140,
-        func_buf + 145,
-        0,
-        0,
-        func_buf + 149,
-        0,
-};
-
-struct kbdiacr accent_table[MAX_DIACR] = {
-        {'`', 'A', 'À'},        {'`', 'a', 'à'},
-        {'\'', 'A', 'Á'},       {'\'', 'a', 'á'},
-        {'^', 'A', 'Â'},        {'^', 'a', 'â'},
-        {'~', 'A', 'Ã'},        {'~', 'a', 'ã'},
-        {'"', 'A', 'Ä'},        {'"', 'a', 'ä'},
-        {'O', 'A', 'Å'},        {'o', 'a', 'å'},
-        {'0', 'A', 'Å'},        {'0', 'a', 'å'},
-        {'A', 'A', 'Å'},        {'a', 'a', 'å'},
-        {'A', 'E', 'Æ'},        {'a', 'e', 'æ'},
-        {',', 'C', 'Ç'},        {',', 'c', 'ç'},
-        {'`', 'E', 'È'},        {'`', 'e', 'è'},
-        {'\'', 'E', 'É'},       {'\'', 'e', 'é'},
-        {'^', 'E', 'Ê'},        {'^', 'e', 'ê'},
-        {'"', 'E', 'Ë'},        {'"', 'e', 'ë'},
-        {'`', 'I', 'Ì'},        {'`', 'i', 'ì'},
-        {'\'', 'I', 'Í'},       {'\'', 'i', 'í'},
-        {'^', 'I', 'Î'},        {'^', 'i', 'î'},
-        {'"', 'I', 'Ï'},        {'"', 'i', 'ï'},
-        {'-', 'D', 'Ð'},        {'-', 'd', 'ð'},
-        {'~', 'N', 'Ñ'},        {'~', 'n', 'ñ'},
-        {'`', 'O', 'Ò'},        {'`', 'o', 'ò'},
-        {'\'', 'O', 'Ó'},       {'\'', 'o', 'ó'},
-        {'^', 'O', 'Ô'},        {'^', 'o', 'ô'},
-        {'~', 'O', 'Õ'},        {'~', 'o', 'õ'},
-        {'"', 'O', 'Ö'},        {'"', 'o', 'ö'},
-        {'/', 'O', 'Ø'},        {'/', 'o', 'ø'},
-        {'`', 'U', 'Ù'},        {'`', 'u', 'ù'},
-        {'\'', 'U', 'Ú'},       {'\'', 'u', 'ú'},
-        {'^', 'U', 'Û'},        {'^', 'u', 'û'},
-        {'"', 'U', 'Ü'},        {'"', 'u', 'ü'},
-        {'\'', 'Y', 'Ý'},       {'\'', 'y', 'ý'},
-        {'T', 'H', 'Þ'},        {'t', 'h', 'þ'},
-        {'s', 's', 'ß'},        {'"', 'y', 'ÿ'},
-        {'s', 'z', 'ß'},        {'i', 'j', 'ÿ'},
-};
-
-unsigned int accent_table_size = 68;
diff --git a/drivers/char/qtronixmap.map b/drivers/char/qtronixmap.map
deleted file mode 100644
index 8d1ff5c1e281..000000000000
--- a/drivers/char/qtronixmap.map
+++ /dev/null
@@ -1,287 +0,0 @@
-# Default kernel keymap. This uses 7 modifier combinations.
-keymaps 0-2,4-5,8,12
-# Change the above line into
-#       keymaps 0-2,4-6,8,12
-# in case you want the entries
-#       altgr   control keycode  83 = Boot            
-#       altgr   control keycode 111 = Boot            
-# below.
-#
-# In fact AltGr is used very little, and one more keymap can
-# be saved by mapping AltGr to Alt (and adapting a few entries):
-# keycode 100 = Alt
-#
-keycode   1 = grave        asciitilde
-        alt     keycode   1 = Meta_Escape     
-keycode   2 = one              exclam          
-        alt     keycode   2 = Meta_one        
-keycode   3 = two              at               at              
-        control keycode   3 = nul             
-        shift   control keycode   3 = nul             
-        alt     keycode   3 = Meta_two        
-keycode   4 = three            numbersign      
-        control keycode   4 = Escape          
-        alt     keycode   4 = Meta_three      
-keycode   5 = four             dollar           dollar          
-        control keycode   5 = Control_backslash
-        alt     keycode   5 = Meta_four       
-keycode   6 = five             percent         
-        control keycode   6 = Control_bracketright
-        alt     keycode   6 = Meta_five       
-keycode   7 = six              asciicircum     
-        control keycode   7 = Control_asciicircum
-        alt     keycode   7 = Meta_six        
-keycode   8 = seven            ampersand        braceleft       
-        control keycode   8 = Control_underscore
-        alt     keycode   8 = Meta_seven      
-keycode   9 = eight            asterisk         bracketleft     
-        control keycode   9 = Delete          
-        alt     keycode   9 = Meta_eight      
-keycode  10 = nine             parenleft        bracketright    
-        alt     keycode  10 = Meta_nine       
-keycode  11 = zero             parenright       braceright      
-        alt     keycode  11 = Meta_zero       
-keycode  12 = minus            underscore       backslash       
-        control keycode  12 = Control_underscore
-        shift   control keycode  12 = Control_underscore
-        alt     keycode  12 = Meta_minus      
-keycode  13 = equal            plus            
-        alt     keycode  13 = Meta_equal      
-keycode  15 = Delete           Delete          
-        control keycode  15 = BackSpace
-        alt     keycode  15 = Meta_Delete     
-keycode  16 = Tab              Tab             
-        alt     keycode  16 = Meta_Tab        
-keycode  17 = q               
-keycode  18 = w               
-keycode  19 = e
-keycode  20 = r               
-keycode  21 = t               
-keycode  22 = y               
-keycode  23 = u  
-keycode  24 = i               
-keycode  25 = o               
-keycode  26 = p               
-keycode  27 = bracketleft      braceleft       
-        control keycode  27 = Escape          
-        alt     keycode  27 = Meta_bracketleft
-keycode  28 = bracketright     braceright
-        control keycode  28 = Control_bracketright
-        alt     keycode  28 = Meta_bracketright
-keycode  29 = backslash        bar             
-        control keycode  29 = Control_backslash
-        alt     keycode  29 = Meta_backslash  
-keycode  30 = Caps_Lock
-keycode  31 = a               
-keycode  32 = s
-keycode  33 = d
-keycode  34 = f               
-keycode  35 = g               
-keycode  36 = h               
-keycode  37 = j               
-keycode  38 = k               
-keycode  39 = l               
-keycode  40 = semicolon        colon           
-        alt     keycode  39 = Meta_semicolon  
-keycode  41 = apostrophe       quotedbl        
-        control keycode  40 = Control_g       
-        alt     keycode  40 = Meta_apostrophe 
-keycode  42 = grave            asciitilde      
-        control keycode  41 = nul             
-        alt     keycode  41 = Meta_grave      
-keycode  43 = Return          
-        alt     keycode  43 = Meta_Control_m  
-keycode  44 = Shift               
-keycode  46 = z
-keycode  47 = x               
-keycode  48 = c
-keycode  49 = v               
-keycode  50 = b               
-keycode  51 = n
-keycode  52 = m
-keycode  53 = comma            less            
-        alt     keycode  51 = Meta_comma      
-keycode  54 = period           greater         
-        control keycode  52 = Compose         
-        alt     keycode  52 = Meta_period     
-keycode  55 = slash            question        
-        control keycode  53 = Delete          
-        alt     keycode  53 = Meta_slash      
-keycode  57 = Shift
-keycode  58 = Control
-keycode  60 = Alt
-keycode  61 = space            space           
-        control keycode  61 = nul             
-        alt     keycode  61 = Meta_space      
-keycode  62 = Alt
-
-keycode 75 = Insert          
-keycode 76 = Delete          
-
-keycode 83 = Up              
-keycode 84 = Down              
-
-keycode 85 = Prior           
-        shift   keycode 85 = Scroll_Backward 
-keycode 86 = Next            
-        shift   keycode 86 = Scroll_Forward  
-keycode 89 = Right           
-        alt     keycode 89 = Incr_Console
-keycode 79 = Left            
-        alt     keycode 79 = Decr_Console
-
-keycode  90 = Num_Lock
-        shift   keycode  90 = Bare_Num_Lock
-
-keycode 91 = minus
-keycode 92 = plus
-keycode 93 = KP_Multiply
-keycode 94 = period
-keycode 95 = KP_Divide
-
-keycode 107 = Select          
-keycode 108 = Down            
-
-keycode 110 = Escape           Escape          
-        alt     keycode   1 = Meta_Escape     
-
-keycode  112 = F1              F11              Console_13      
-        control keycode  112 = F1              
-        alt     keycode  112 = Console_1       
-        control alt     keycode  112 = Console_1       
-keycode  113 = F2              F12              Console_14      
-        control keycode  113 = F2              
-        alt     keycode  113 = Console_2       
-        control alt     keycode  113 = Console_2       
-keycode  114 = F3              F13              Console_15      
-        control keycode  114 = F3              
-        alt     keycode  114 = Console_3       
-        control alt     keycode  114 = Console_3       
-keycode  115 = F4              F14              Console_16      
-        control keycode  115 = F4              
-        alt     keycode  115 = Console_4       
-        control alt     keycode  115 = Console_4       
-keycode  116 = F5              F15              Console_17      
-        control keycode  116 = F5              
-        alt     keycode  116 = Console_5       
-        control alt     keycode  116 = Console_5       
-keycode  117 = F6              F16              Console_18      
-        control keycode  117 = F6              
-        alt     keycode  117 = Console_6       
-        control alt     keycode  117 = Console_6       
-keycode  118 = F7              F17              Console_19      
-        control keycode  118 = F7              
-        alt     keycode  118 = Console_7       
-        control alt     keycode  118 = Console_7       
-keycode  119 = F8              F18              Console_20      
-        control keycode  119 = F8              
-        alt     keycode  119 = Console_8       
-        control alt     keycode  119 = Console_8       
-keycode  120 = F9              F19              Console_21      
-        control keycode  120 = F9              
-        alt     keycode  120 = Console_9       
-        control alt     keycode  120 = Console_9       
-keycode  121 = F10             F20              Console_22      
-        control keycode  121 = F10             
-        alt     keycode  121 = Console_10      
-        control alt     keycode  121 = Console_10      
-        
-keycode 126 = Pause           
-
-
-string F1 = "\033[[A"
-string F2 = "\033[[B"
-string F3 = "\033[[C"
-string F4 = "\033[[D"
-string F5 = "\033[[E"
-string F6 = "\033[17~"
-string F7 = "\033[18~"
-string F8 = "\033[19~"
-string F9 = "\033[20~"
-string F10 = "\033[21~"
-string F11 = "\033[23~"
-string F12 = "\033[24~"
-string F13 = "\033[25~"
-string F14 = "\033[26~"
-string F15 = "\033[28~"
-string F16 = "\033[29~"
-string F17 = "\033[31~"
-string F18 = "\033[32~"
-string F19 = "\033[33~"
-string F20 = "\033[34~"
-string Find = "\033[1~"
-string Insert = "\033[2~"
-string Remove = "\033[3~"
-string Select = "\033[4~"
-string Prior = "\033[5~"
-string Next = "\033[6~"
-string Macro = "\033[M"
-string Pause = "\033[P"
-compose '`' 'A' to 'À'
-compose '`' 'a' to 'à'
-compose '\'' 'A' to 'Á'
-compose '\'' 'a' to 'á'
-compose '^' 'A' to 'Â'
-compose '^' 'a' to 'â'
-compose '~' 'A' to 'Ã'
-compose '~' 'a' to 'ã'
-compose '"' 'A' to 'Ä'
-compose '"' 'a' to 'ä'
-compose 'O' 'A' to 'Å'
-compose 'o' 'a' to 'å'
-compose '0' 'A' to 'Å'
-compose '0' 'a' to 'å'
-compose 'A' 'A' to 'Å'
-compose 'a' 'a' to 'å'
-compose 'A' 'E' to 'Æ'
-compose 'a' 'e' to 'æ'
-compose ',' 'C' to 'Ç'
-compose ',' 'c' to 'ç'
-compose '`' 'E' to 'È'
-compose '`' 'e' to 'è'
-compose '\'' 'E' to 'É'
-compose '\'' 'e' to 'é'
-compose '^' 'E' to 'Ê'
-compose '^' 'e' to 'ê'
-compose '"' 'E' to 'Ë'
-compose '"' 'e' to 'ë'
-compose '`' 'I' to 'Ì'
-compose '`' 'i' to 'ì'
-compose '\'' 'I' to 'Í'
-compose '\'' 'i' to 'í'
-compose '^' 'I' to 'Î'
-compose '^' 'i' to 'î'
-compose '"' 'I' to 'Ï'
-compose '"' 'i' to 'ï'
-compose '-' 'D' to 'Ð'
-compose '-' 'd' to 'ð'
-compose '~' 'N' to 'Ñ'
-compose '~' 'n' to 'ñ'
-compose '`' 'O' to 'Ò'
-compose '`' 'o' to 'ò'
-compose '\'' 'O' to 'Ó'
-compose '\'' 'o' to 'ó'
-compose '^' 'O' to 'Ô'
-compose '^' 'o' to 'ô'
-compose '~' 'O' to 'Õ'
-compose '~' 'o' to 'õ'
-compose '"' 'O' to 'Ö'
-compose '"' 'o' to 'ö'
-compose '/' 'O' to 'Ø'
-compose '/' 'o' to 'ø'
-compose '`' 'U' to 'Ù'
-compose '`' 'u' to 'ù'
-compose '\'' 'U' to 'Ú'
-compose '\'' 'u' to 'ú'
-compose '^' 'U' to 'Û'
-compose '^' 'u' to 'û'
-compose '"' 'U' to 'Ü'
-compose '"' 'u' to 'ü'
-compose '\'' 'Y' to 'Ý'
-compose '\'' 'y' to 'ý'
-compose 'T' 'H' to 'Þ'
-compose 't' 'h' to 'þ'
-compose 's' 's' to 'ß'
-compose '"' 'y' to 'ÿ'
-compose 's' 'z' to 'ß'
-compose 'i' 'j' to 'ÿ'
diff --git a/drivers/char/random.c b/drivers/char/random.c
index 4c3a5ca9d8f7..13d0b1350a62 100644
--- a/drivers/char/random.c
+++ b/drivers/char/random.c
@@ -645,6 +645,7 @@ void add_input_randomness(unsigned int type, unsigned int code,
         add_timer_randomness(&input_timer_state,
                              (type << 4) ^ code ^ (code >> 4) ^ value);
 }
+EXPORT_SYMBOL_GPL(add_input_randomness);
 
 void add_interrupt_randomness(int irq)
 {
@@ -655,6 +656,7 @@ void add_interrupt_randomness(int irq)
         add_timer_randomness(irq_timer_state[irq], 0x100 + irq);
 }
 
+#ifdef CONFIG_BLOCK
 void add_disk_randomness(struct gendisk *disk)
 {
         if (!disk || !disk->random)
@@ -667,6 +669,7 @@ void add_disk_randomness(struct gendisk *disk)
 }
 
 EXPORT_SYMBOL(add_disk_randomness);
+#endif
 
 #define EXTRACT_SIZE 10
 
@@ -887,8 +890,8 @@ static void init_std_data(struct entropy_store *r)
 
         do_gettimeofday(&tv);
         add_entropy_words(r, (__u32 *)&tv, sizeof(tv)/4);
-        add_entropy_words(r, (__u32 *)&system_utsname,
-                          sizeof(system_utsname)/4);
+        add_entropy_words(r, (__u32 *)utsname(),
+                          sizeof(*(utsname()))/4);
 }
 
 static int __init rand_initialize(void)
@@ -918,6 +921,7 @@ void rand_initialize_irq(int irq)
         }
 }
 
+#ifdef CONFIG_BLOCK
 void rand_initialize_disk(struct gendisk *disk)
 {
         struct timer_rand_state *state;
@@ -932,6 +936,7 @@ void rand_initialize_disk(struct gendisk *disk)
                 disk->random = state;
         }
 }
+#endif
 
 static ssize_t
 random_read(struct file * file, char __user * buf, size_t nbytes, loff_t *ppos)
@@ -1043,7 +1048,7 @@ random_write(struct file * file, const char __user * buffer,
         if (p == buffer) {
                 return (ssize_t)ret;
         } else {
-                struct inode *inode = file->f_dentry->d_inode;
+                struct inode *inode = file->f_path.dentry->d_inode;
                 inode->i_mtime = current_fs_time(inode->i_sb);
                 mark_inode_dirty(inode);
                 return (ssize_t)(p - buffer);
@@ -1198,7 +1203,7 @@ static int proc_do_uuid(ctl_table *table, int write, struct file *filp,
 
 static int uuid_strategy(ctl_table *table, int __user *name, int nlen,
                          void __user *oldval, size_t __user *oldlenp,
-                         void __user *newval, size_t newlen, void **context)
+                         void __user *newval, size_t newlen)
 {
         unsigned char tmp_uuid[16], *uuid;
         unsigned int len;
@@ -1417,9 +1422,9 @@ static struct keydata {
 
 static unsigned int ip_cnt;
 
-static void rekey_seq_generator(void *private_);
+static void rekey_seq_generator(struct work_struct *work);
 
-static DECLARE_WORK(rekey_work, rekey_seq_generator, NULL);
+static DECLARE_DELAYED_WORK(rekey_work, rekey_seq_generator);
 
 /*
  * Lock avoidance:
@@ -1433,7 +1438,7 @@ static DECLARE_WORK(rekey_work, rekey_seq_generator, NULL);
  * happen, and even if that happens only a not perfectly compliant
  * ISN is generated, nothing fatal.
  */
-static void rekey_seq_generator(void *private_)
+static void rekey_seq_generator(struct work_struct *work)
 {
         struct keydata *keyptr = &ip_keydata[1 ^ (ip_cnt & 1)];
 
@@ -1461,8 +1466,8 @@ static __init int seqgen_init(void)
 late_initcall(seqgen_init);
 
 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
-__u32 secure_tcpv6_sequence_number(__u32 *saddr, __u32 *daddr,
-                                   __u16 sport, __u16 dport)
+__u32 secure_tcpv6_sequence_number(__be32 *saddr, __be32 *daddr,
+                                   __be16 sport, __be16 dport)
 {
         struct timeval tv;
         __u32 seq;
@@ -1474,10 +1479,10 @@ __u32 secure_tcpv6_sequence_number(__u32 *saddr, __u32 *daddr,
          */
 
         memcpy(hash, saddr, 16);
-        hash[4]=(sport << 16) + dport;
+        hash[4]=((__force u16)sport << 16) + (__force u16)dport;
         memcpy(&hash[5],keyptr->secret,sizeof(__u32) * 7);
 
-        seq = twothirdsMD4Transform(daddr, hash) & HASH_MASK;
+        seq = twothirdsMD4Transform((const __u32 *)daddr, hash) & HASH_MASK;
         seq += keyptr->count;
 
         do_gettimeofday(&tv);
@@ -1491,7 +1496,7 @@ EXPORT_SYMBOL(secure_tcpv6_sequence_number);
 /*  The code below is shamelessly stolen from secure_tcp_sequence_number().
  *  All blames to Andrey V. Savochkin <saw@msu.ru>.
  */
-__u32 secure_ip_id(__u32 daddr)
+__u32 secure_ip_id(__be32 daddr)
 {
         struct keydata *keyptr;
         __u32 hash[4];
@@ -1503,7 +1508,7 @@ __u32 secure_ip_id(__u32 daddr)
          *  The dest ip address is placed in the starting vector,
          *  which is then hashed with random data.
          */
-        hash[0] = daddr;
+        hash[0] = (__force __u32)daddr;
         hash[1] = keyptr->secret[9];
         hash[2] = keyptr->secret[10];
         hash[3] = keyptr->secret[11];
@@ -1513,8 +1518,8 @@ __u32 secure_ip_id(__u32 daddr)
 
 #ifdef CONFIG_INET
 
-__u32 secure_tcp_sequence_number(__u32 saddr, __u32 daddr,
-                                 __u16 sport, __u16 dport)
+__u32 secure_tcp_sequence_number(__be32 saddr, __be32 daddr,
+                                 __be16 sport, __be16 dport)
 {
         struct timeval tv;
         __u32 seq;
@@ -1527,9 +1532,9 @@ __u32 secure_tcp_sequence_number(__u32 saddr, __u32 daddr,
          *  Note that the words are placed into the starting vector, which is
          *  then mixed with a partial MD4 over random data.
          */
-        hash[0]=saddr;
-        hash[1]=daddr;
-        hash[2]=(sport << 16) + dport;
+        hash[0]=(__force u32)saddr;
+        hash[1]=(__force u32)daddr;
+        hash[2]=((__force u16)sport << 16) + (__force u16)dport;
         hash[3]=keyptr->secret[11];
 
         seq = half_md4_transform(hash, keyptr->secret) & HASH_MASK;
@@ -1554,7 +1559,7 @@ __u32 secure_tcp_sequence_number(__u32 saddr, __u32 daddr,
 EXPORT_SYMBOL(secure_tcp_sequence_number);
 
 /* Generate secure starting point for ephemeral IPV4 transport port search */
-u32 secure_ipv4_port_ephemeral(__u32 saddr, __u32 daddr, __u16 dport)
+u32 secure_ipv4_port_ephemeral(__be32 saddr, __be32 daddr, __be16 dport)
 {
         struct keydata *keyptr = get_keyptr();
         u32 hash[4];
@@ -1563,25 +1568,25 @@ u32 secure_ipv4_port_ephemeral(__u32 saddr, __u32 daddr, __u16 dport)
          *  Pick a unique starting offset for each ephemeral port search
          *  (saddr, daddr, dport) and 48bits of random data.
          */
-        hash[0] = saddr;
-        hash[1] = daddr;
-        hash[2] = dport ^ keyptr->secret[10];
+        hash[0] = (__force u32)saddr;
+        hash[1] = (__force u32)daddr;
+        hash[2] = (__force u32)dport ^ keyptr->secret[10];
         hash[3] = keyptr->secret[11];
 
         return half_md4_transform(hash, keyptr->secret);
 }
 
 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
-u32 secure_ipv6_port_ephemeral(const __u32 *saddr, const __u32 *daddr, __u16 dport)
+u32 secure_ipv6_port_ephemeral(const __be32 *saddr, const __be32 *daddr, __be16 dport)
 {
         struct keydata *keyptr = get_keyptr();
         u32 hash[12];
 
         memcpy(hash, saddr, 16);
-        hash[4] = dport;
+        hash[4] = (__force u32)dport;
         memcpy(&hash[5],keyptr->secret,sizeof(__u32) * 7);
 
-        return twothirdsMD4Transform(daddr, hash);
+        return twothirdsMD4Transform((const __u32 *)daddr, hash);
 }
 #endif
 
@@ -1590,17 +1595,17 @@ u32 secure_ipv6_port_ephemeral(const __u32 *saddr, const __u32 *daddr, __u16 dpo
  * bit's 32-47 increase every key exchange
  *       0-31  hash(source, dest)
  */
-u64 secure_dccp_sequence_number(__u32 saddr, __u32 daddr,
-                                __u16 sport, __u16 dport)
+u64 secure_dccp_sequence_number(__be32 saddr, __be32 daddr,
+                                __be16 sport, __be16 dport)
 {
         struct timeval tv;
         u64 seq;
         __u32 hash[4];
         struct keydata *keyptr = get_keyptr();
 
-        hash[0] = saddr;
-        hash[1] = daddr;
-        hash[2] = (sport << 16) + dport;
+        hash[0] = (__force u32)saddr;
+        hash[1] = (__force u32)daddr;
+        hash[2] = ((__force u16)sport << 16) + (__force u16)dport;
         hash[3] = keyptr->secret[11];
 
         seq = half_md4_transform(hash, keyptr->secret);
@@ -1636,7 +1641,7 @@ unsigned int get_random_int(void)
          * drain on it), and uses halfMD4Transform within the second. We
          * also mix it with jiffies and the PID:
          */
-        return secure_ip_id(current->pid + jiffies);
+        return secure_ip_id((__force __be32)(current->pid + jiffies));
 }
 
 /*
diff --git a/drivers/char/raw.c b/drivers/char/raw.c
index 579868af4a54..645e20a06ece 100644
--- a/drivers/char/raw.c
+++ b/drivers/char/raw.c
@@ -75,7 +75,7 @@ static int raw_open(struct inode *inode, struct file *filp)
         filp->f_flags |= O_DIRECT;
         filp->f_mapping = bdev->bd_inode->i_mapping;
         if (++raw_devices[minor].inuse == 1)
-                filp->f_dentry->d_inode->i_mapping =
+                filp->f_path.dentry->d_inode->i_mapping =
                         bdev->bd_inode->i_mapping;
         filp->private_data = bdev;
         mutex_unlock(&raw_mutex);
@@ -127,9 +127,9 @@ raw_ioctl(struct inode *inode, struct file *filp,
 
 static void bind_device(struct raw_config_request *rq)
 {
-        class_device_destroy(raw_class, MKDEV(RAW_MAJOR, rq->raw_minor));
-        class_device_create(raw_class, NULL, MKDEV(RAW_MAJOR, rq->raw_minor),
-                                      NULL, "raw%d", rq->raw_minor);
+        device_destroy(raw_class, MKDEV(RAW_MAJOR, rq->raw_minor));
+        device_create(raw_class, NULL, MKDEV(RAW_MAJOR, rq->raw_minor),
+                      "raw%d", rq->raw_minor);
 }
 
 /*
@@ -200,7 +200,7 @@ static int raw_ctl_ioctl(struct inode *inode, struct file *filp,
                         if (rq.block_major == 0 && rq.block_minor == 0) {
                                 /* unbind */
                                 rawdev->binding = NULL;
-                                class_device_destroy(raw_class,
+                                device_destroy(raw_class,
                                                 MKDEV(RAW_MAJOR, rq.raw_minor));
                         } else {
                                 rawdev->binding = bdget(dev);
@@ -238,39 +238,14 @@ out:
         return err;
 }
 
-static ssize_t raw_file_write(struct file *file, const char __user *buf,
-                                   size_t count, loff_t *ppos)
-{
-        struct iovec local_iov = {
-                .iov_base = (char __user *)buf,
-                .iov_len = count
-        };
-
-        return generic_file_write_nolock(file, &local_iov, 1, ppos);
-}
-
-static ssize_t raw_file_aio_write(struct kiocb *iocb, const char __user *buf,
-                                        size_t count, loff_t pos)
-{
-        struct iovec local_iov = {
-                .iov_base = (char __user *)buf,
-                .iov_len = count
-        };
-
-        return generic_file_aio_write_nolock(iocb, &local_iov, 1, &iocb->ki_pos);
-}
-
-
 static const struct file_operations raw_fops = {
-        .read   =       generic_file_read,
+        .read   =       do_sync_read,
         .aio_read =     generic_file_aio_read,
-        .write  =       raw_file_write,
-        .aio_write =    raw_file_aio_write,
+        .write  =       do_sync_write,
+        .aio_write =    generic_file_aio_write_nolock,
         .open   =       raw_open,
         .release=       raw_release,
         .ioctl  =       raw_ioctl,
-        .readv  =       generic_file_readv,
-        .writev =       generic_file_writev,
         .owner  =       THIS_MODULE,
 };
 
@@ -288,36 +263,39 @@ static struct cdev raw_cdev = {
 static int __init raw_init(void)
 {
         dev_t dev = MKDEV(RAW_MAJOR, 0);
+        int ret;
 
-        if (register_chrdev_region(dev, MAX_RAW_MINORS, "raw"))
+        ret = register_chrdev_region(dev, MAX_RAW_MINORS, "raw");
+        if (ret)
                 goto error;
 
         cdev_init(&raw_cdev, &raw_fops);
-        if (cdev_add(&raw_cdev, dev, MAX_RAW_MINORS)) {
+        ret = cdev_add(&raw_cdev, dev, MAX_RAW_MINORS);
+        if (ret) {
                 kobject_put(&raw_cdev.kobj);
-                unregister_chrdev_region(dev, MAX_RAW_MINORS);
-                goto error;
+                goto error_region;
         }
 
         raw_class = class_create(THIS_MODULE, "raw");
         if (IS_ERR(raw_class)) {
                 printk(KERN_ERR "Error creating raw class.\n");
                 cdev_del(&raw_cdev);
-                unregister_chrdev_region(dev, MAX_RAW_MINORS);
-                goto error;
+                ret = PTR_ERR(raw_class);
+                goto error_region;
         }
-        class_device_create(raw_class, NULL, MKDEV(RAW_MAJOR, 0), NULL, "rawctl");
+        device_create(raw_class, NULL, MKDEV(RAW_MAJOR, 0), "rawctl");
 
         return 0;
 
+error_region:
+        unregister_chrdev_region(dev, MAX_RAW_MINORS);
 error:
-        printk(KERN_ERR "error register raw device\n");
-        return 1;
+        return ret;
 }
 
 static void __exit raw_exit(void)
 {
-        class_device_destroy(raw_class, MKDEV(RAW_MAJOR, 0));
+        device_destroy(raw_class, MKDEV(RAW_MAJOR, 0));
         class_destroy(raw_class);
         cdev_del(&raw_cdev);
         unregister_chrdev_region(MKDEV(RAW_MAJOR, 0), MAX_RAW_MINORS);
diff --git a/drivers/char/rio/func.h b/drivers/char/rio/func.h
index 6b039186856d..9e7283bd81a0 100644
--- a/drivers/char/rio/func.h
+++ b/drivers/char/rio/func.h
@@ -88,7 +88,7 @@ void RIOHostReset(unsigned int, struct DpRam __iomem *, unsigned int);
 
 /* riointr.c */
 void RIOTxEnable(char *);
-void RIOServiceHost(struct rio_info *, struct Host *, int);
+void RIOServiceHost(struct rio_info *, struct Host *);
 int riotproc(struct rio_info *, struct ttystatics *, int, int);
 
 /* rioparam.c */
diff --git a/drivers/char/rio/host.h b/drivers/char/rio/host.h
index ee2ddea7a63a..23d0681fe491 100644
--- a/drivers/char/rio/host.h
+++ b/drivers/char/rio/host.h
@@ -44,6 +44,7 @@
 **    the host.
 */
 struct Host {
+        struct pci_dev *pdev;
         unsigned char Type;             /* RIO_EISA, RIO_MCA, ... */
         unsigned char Ivec;             /* POLLED or ivec number */
         unsigned char Mode;             /* Control stuff */
diff --git a/drivers/char/rio/rio_linux.c b/drivers/char/rio/rio_linux.c
index 3fa80aaf4527..e79b2ede8510 100644
--- a/drivers/char/rio/rio_linux.c
+++ b/drivers/char/rio/rio_linux.c
@@ -363,12 +363,12 @@ static void rio_reset_interrupt(struct Host *HostP)
 }
 
 
-static irqreturn_t rio_interrupt(int irq, void *ptr, struct pt_regs *regs)
+static irqreturn_t rio_interrupt(int irq, void *ptr)
 {
         struct Host *HostP;
         func_enter();
 
-        HostP = (struct Host *) ptr;    /* &p->RIOHosts[(long)ptr]; */
+        HostP = ptr;                    /* &p->RIOHosts[(long)ptr]; */
         rio_dprintk(RIO_DEBUG_IFLOW, "rio: enter rio_interrupt (%d/%d)\n", irq, HostP->Ivec);
 
         /* AAargh! The order in which to do these things is essential and
@@ -402,7 +402,7 @@ static irqreturn_t rio_interrupt(int irq, void *ptr, struct pt_regs *regs)
                 return IRQ_HANDLED;
         }
 
-        RIOServiceHost(p, HostP, irq);
+        RIOServiceHost(p, HostP);
 
         rio_dprintk(RIO_DEBUG_IFLOW, "riointr() doing host %p type %d\n", ptr, HostP->Type);
 
@@ -417,7 +417,7 @@ static void rio_pollfunc(unsigned long data)
 {
         func_enter();
 
-        rio_interrupt(0, &p->RIOHosts[data], NULL);
+        rio_interrupt(0, &p->RIOHosts[data]);
         p->RIOHosts[data].timer.expires = jiffies + rio_poll;
         add_timer(&p->RIOHosts[data].timer);
 
@@ -727,7 +727,7 @@ static struct vpd_prom *get_VPD_PROM(struct Host *hp)
         return &vpdp;
 }
 
-static struct tty_operations rio_ops = {
+static const struct tty_operations rio_ops = {
         .open = riotopen,
         .close = gs_close,
         .write = gs_write,
@@ -1017,11 +1017,16 @@ static int __init rio_init(void)
                         rio_dprintk(RIO_DEBUG_PROBE, "Hmm Tested ok, uniqid = %x.\n", p->RIOHosts[p->RIONumHosts].UniqueNum);
 
                         fix_rio_pci(pdev);
+
+                        p->RIOHosts[p->RIONumHosts].pdev = pdev;
+                        pci_dev_get(pdev);
+
                         p->RIOLastPCISearch = 0;
                         p->RIONumHosts++;
                         found++;
                 } else {
                         iounmap(p->RIOHosts[p->RIONumHosts].Caddr);
+                        p->RIOHosts[p->RIONumHosts].Caddr = NULL;
                 }
         }
 
@@ -1066,11 +1071,15 @@ static int __init rio_init(void)
                             ((readb(&p->RIOHosts[p->RIONumHosts].Unique[1]) & 0xFF) << 8) | ((readb(&p->RIOHosts[p->RIONumHosts].Unique[2]) & 0xFF) << 16) | ((readb(&p->RIOHosts[p->RIONumHosts].Unique[3]) & 0xFF) << 24);
                         rio_dprintk(RIO_DEBUG_PROBE, "Hmm Tested ok, uniqid = %x.\n", p->RIOHosts[p->RIONumHosts].UniqueNum);
 
+                        p->RIOHosts[p->RIONumHosts].pdev = pdev;
+                        pci_dev_get(pdev);
+
                         p->RIOLastPCISearch = 0;
                         p->RIONumHosts++;
                         found++;
                 } else {
                         iounmap(p->RIOHosts[p->RIONumHosts].Caddr);
+                        p->RIOHosts[p->RIONumHosts].Caddr = NULL;
                 }
 #else
                 printk(KERN_ERR "Found an older RIO PCI card, but the driver is not " "compiled to support it.\n");
@@ -1110,8 +1119,10 @@ static int __init rio_init(void)
                                 }
                         }
 
-                        if (!okboard)
+                        if (!okboard) {
                                 iounmap(hp->Caddr);
+                                hp->Caddr = NULL;
+                        }
                 }
         }
 
@@ -1181,6 +1192,10 @@ static void __exit rio_exit(void)
                 }
                 /* It is safe/allowed to del_timer a non-active timer */
                 del_timer(&hp->timer);
+                if (hp->Caddr)
+                        iounmap(hp->Caddr);
+                if (hp->Type == RIO_PCI)
+                        pci_dev_put(hp->pdev);
         }
 
         if (misc_deregister(&rio_fw_device) < 0) {
diff --git a/drivers/char/rio/riocmd.c b/drivers/char/rio/riocmd.c
index 4df6ab2206a1..167ebc84e8d7 100644
--- a/drivers/char/rio/riocmd.c
+++ b/drivers/char/rio/riocmd.c
@@ -922,7 +922,7 @@ int RIOUnUse(unsigned long iPortP, struct CmdBlk *CmdBlkP)
 ** 
 ** Packet is an actual packet structure to be filled in with the packet
 ** information associated with the command. You need to fill in everything,
-** as the command processore doesn't process the command packet in any way.
+** as the command processor doesn't process the command packet in any way.
 ** 
 ** The PreFuncP is called before the packet is enqueued on the host rup.
 ** PreFuncP is called as (*PreFuncP)(PreArg, CmdBlkP);. PreFuncP must
diff --git a/drivers/char/rio/rioctrl.c b/drivers/char/rio/rioctrl.c
index 052e8120a471..7ce77619707c 100644
--- a/drivers/char/rio/rioctrl.c
+++ b/drivers/char/rio/rioctrl.c
@@ -662,7 +662,7 @@ int riocontrol(struct rio_info *p, dev_t dev, int cmd, unsigned long arg, int su
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
-                if (portStats.port >= RIO_PORTS) {
+                if (portStats.port < 0 || portStats.port >= RIO_PORTS) {
                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
                         return -ENXIO;
                 }
@@ -702,7 +702,7 @@ int riocontrol(struct rio_info *p, dev_t dev, int cmd, unsigned long arg, int su
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
-                if (portStats.port >= RIO_PORTS) {
+                if (portStats.port < 0 || portStats.port >= RIO_PORTS) {
                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
                         return -ENXIO;
                 }
diff --git a/drivers/char/rio/rioinit.c b/drivers/char/rio/rioinit.c
index 99f3df02b61c..0794844369d6 100644
--- a/drivers/char/rio/rioinit.c
+++ b/drivers/char/rio/rioinit.c
@@ -222,7 +222,7 @@ int RIOBoardTest(unsigned long paddr, void __iomem *caddr, unsigned char type, i
 ** which value will be written into memory.
 ** Call with op set to zero means that the RAM will not be read and checked
 ** before it is written.
-** Call with op not zero, and the RAM will be read and compated with val[op-1]
+** Call with op not zero and the RAM will be read and compared with val[op-1]
 ** to check that the data from the previous phase was retained.
 */
 
diff --git a/drivers/char/rio/riointr.c b/drivers/char/rio/riointr.c
index 0bd09040a5c0..eeda40c5e189 100644
--- a/drivers/char/rio/riointr.c
+++ b/drivers/char/rio/riointr.c
@@ -181,7 +181,7 @@ static int RupIntr;
 static int RxIntr;
 static int TxIntr;
 
-void RIOServiceHost(struct rio_info *p, struct Host *HostP, int From)
+void RIOServiceHost(struct rio_info *p, struct Host *HostP)
 {
         rio_spin_lock(&HostP->HostLock);
         if ((HostP->Flags & RUN_STATE) != RC_RUNNING) {
diff --git a/drivers/char/rio/rioparam.c b/drivers/char/rio/rioparam.c
index 1066d9760704..bb498d24adcc 100644
--- a/drivers/char/rio/rioparam.c
+++ b/drivers/char/rio/rioparam.c
@@ -87,8 +87,8 @@ static char *_rioparam_c_sccs_ = "@(#)rioparam.c	1.3";
 ** command bit set onto the port. The command bit is in the len field,
 ** and gets ORed in with the actual byte count.
 **
-** When you send a packet with the command bit set, then the first
-** data byte ( data[0] ) is interpretted as the command to execute.
+** When you send a packet with the command bit set the first
+** data byte (data[0]) is interpreted as the command to execute.
 ** It also governs what data structure overlay should accompany the packet.
 ** Commands are defined in cirrus/cirrus.h
 **
@@ -103,7 +103,7 @@ static char *_rioparam_c_sccs_ = "@(#)rioparam.c	1.3";
 **
 ** Most commands do not use the remaining bytes in the data array. The
 ** exceptions are OPEN MOPEN and CONFIG. (NB. As with the SI CONFIG and
-** OPEN are currently analagous). With these three commands the following
+** OPEN are currently analogous). With these three commands the following
 ** 11 data bytes are all used to pass config information such as baud rate etc.
 ** The fields are also defined in cirrus.h. Some contain straightforward
 ** information such as the transmit XON character. Two contain the transmit and
diff --git a/drivers/char/riscom8.c b/drivers/char/riscom8.c
index f1c94f771af5..e2a94bfb2a43 100644
--- a/drivers/char/riscom8.c
+++ b/drivers/char/riscom8.c
@@ -81,12 +81,6 @@
 
 static struct riscom_board * IRQ_to_board[16];
 static struct tty_driver *riscom_driver;
-static unsigned char * tmp_buf;
-
-static unsigned long baud_table[] =  {
-        0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
-        9600, 19200, 38400, 57600, 76800, 0, 
-};
 
 static struct riscom_board rc_board[RC_NBOARD] =  {
         {
@@ -551,7 +545,7 @@ static inline void rc_check_modem(struct riscom_board const * bp)
 }
 
 /* The main interrupt processing routine */
-static irqreturn_t rc_interrupt(int irq, void * dev_id, struct pt_regs * regs)
+static irqreturn_t rc_interrupt(int irq, void * dev_id)
 {
         unsigned char status;
         unsigned char ack;
@@ -560,11 +554,10 @@ static irqreturn_t rc_interrupt(int irq, void * dev_id, struct pt_regs * regs)
         int handled = 0;
 
         bp = IRQ_to_board[irq];
-        
-        if (!bp || !(bp->flags & RC_BOARD_ACTIVE))  {
+
+        if (!(bp->flags & RC_BOARD_ACTIVE))
                 return IRQ_NONE;
-        }
-        
+
         while ((++loop < 16) && ((status = ~(rc_in(bp, RC_BSR))) &
                                  (RC_BSR_TOUT | RC_BSR_TINT |
                                   RC_BSR_MINT | RC_BSR_RINT))) {
@@ -675,26 +668,12 @@ static void rc_change_speed(struct riscom_board *bp, struct riscom_port *port)
         port->COR2 = 0;
         port->MSVR = MSVR_RTS;
         
-        baud = C_BAUD(tty);
-        
-        if (baud & CBAUDEX) {
-                baud &= ~CBAUDEX;
-                if (baud < 1 || baud > 2) 
-                        port->tty->termios->c_cflag &= ~CBAUDEX;
-                else
-                        baud += 15;
-        }
-        if (baud == 15)  {
-                if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
-                        baud ++;
-                if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
-                        baud += 2;
-        }
+        baud = tty_get_baud_rate(tty);
         
         /* Select port on the board */
         rc_out(bp, CD180_CAR, port_No(port));
         
-        if (!baud_table[baud])  {
+        if (!baud)  {
                 /* Drop DTR & exit */
                 bp->DTR |= (1u << port_No(port));
                 rc_out(bp, RC_DTR, bp->DTR);
@@ -710,7 +689,7 @@ static void rc_change_speed(struct riscom_board *bp, struct riscom_port *port)
          */
         
         /* Set baud rate for port */
-        tmp = (((RC_OSCFREQ + baud_table[baud]/2) / baud_table[baud] +
+        tmp = (((RC_OSCFREQ + baud/2) / baud +
                 CD180_TPC/2) / CD180_TPC);
 
         rc_out(bp, CD180_RBPRH, (tmp >> 8) & 0xff); 
@@ -718,7 +697,7 @@ static void rc_change_speed(struct riscom_board *bp, struct riscom_port *port)
         rc_out(bp, CD180_RBPRL, tmp & 0xff); 
         rc_out(bp, CD180_TBPRL, tmp & 0xff);
         
-        baud = (baud_table[baud] + 5) / 10;   /* Estimated CPS */
+        baud = (baud + 5) / 10;   /* Estimated CPS */
         
         /* Two timer ticks seems enough to wakeup something like SLIP driver */
         tmp = ((baud + HZ/2) / HZ) * 2 - CD180_NFIFO;           
@@ -1138,7 +1117,7 @@ static int rc_write(struct tty_struct * tty,
         
         bp = port_Board(port);
 
-        if (!tty || !port->xmit_buf || !tmp_buf)
+        if (!tty || !port->xmit_buf)
                 return 0;
 
         save_flags(flags);
@@ -1532,9 +1511,9 @@ static void rc_start(struct tty_struct * tty)
  *      do_rc_hangup() -> tty->hangup() -> rc_hangup()
  * 
  */
-static void do_rc_hangup(void *private_)
+static void do_rc_hangup(struct work_struct *ugly_api)
 {
-        struct riscom_port      *port = (struct riscom_port *) private_;
+        struct riscom_port      *port = container_of(ugly_api, struct riscom_port, tqueue_hangup);
         struct tty_struct       *tty;
         
         tty = port->tty;
@@ -1560,7 +1539,7 @@ static void rc_hangup(struct tty_struct * tty)
         wake_up_interruptible(&port->open_wait);
 }
 
-static void rc_set_termios(struct tty_struct * tty, struct termios * old_termios)
+static void rc_set_termios(struct tty_struct * tty, struct ktermios * old_termios)
 {
         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
         unsigned long flags;
@@ -1583,9 +1562,9 @@ static void rc_set_termios(struct tty_struct * tty, struct termios * old_termios
         }
 }
 
-static void do_softint(void *private_)
+static void do_softint(struct work_struct *ugly_api)
 {
-        struct riscom_port      *port = (struct riscom_port *) private_;
+        struct riscom_port      *port = container_of(ugly_api, struct riscom_port, tqueue);
         struct tty_struct       *tty;
         
         if(!(tty = port->tty)) 
@@ -1597,7 +1576,7 @@ static void do_softint(void *private_)
         }
 }
 
-static struct tty_operations riscom_ops = {
+static const struct tty_operations riscom_ops = {
         .open  = rc_open,
         .close = rc_close,
         .write = rc_write,
@@ -1626,11 +1605,6 @@ static inline int rc_init_drivers(void)
         if (!riscom_driver)     
                 return -ENOMEM;
         
-        if (!(tmp_buf = (unsigned char *) get_zeroed_page(GFP_KERNEL))) {
-                printk(KERN_ERR "rc: Couldn't get free page.\n");
-                put_tty_driver(riscom_driver);
-                return 1;
-        }
         memset(IRQ_to_board, 0, sizeof(IRQ_to_board));
         riscom_driver->owner = THIS_MODULE;
         riscom_driver->name = "ttyL";
@@ -1640,10 +1614,11 @@ static inline int rc_init_drivers(void)
         riscom_driver->init_termios = tty_std_termios;
         riscom_driver->init_termios.c_cflag =
                 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+        riscom_driver->init_termios.c_ispeed = 9600;
+        riscom_driver->init_termios.c_ospeed = 9600;
         riscom_driver->flags = TTY_DRIVER_REAL_RAW;
         tty_set_operations(riscom_driver, &riscom_ops);
         if ((error = tty_register_driver(riscom_driver)))  {
-                free_page((unsigned long)tmp_buf);
                 put_tty_driver(riscom_driver);
                 printk(KERN_ERR "rc: Couldn't register RISCom/8 driver, "
                                 "error = %d\n",
@@ -1654,8 +1629,8 @@ static inline int rc_init_drivers(void)
         memset(rc_port, 0, sizeof(rc_port));
         for (i = 0; i < RC_NPORT * RC_NBOARD; i++)  {
                 rc_port[i].magic = RISCOM8_MAGIC;
-                INIT_WORK(&rc_port[i].tqueue, do_softint, &rc_port[i]);
-                INIT_WORK(&rc_port[i].tqueue_hangup, do_rc_hangup, &rc_port[i]);
+                INIT_WORK(&rc_port[i].tqueue, do_softint);
+                INIT_WORK(&rc_port[i].tqueue_hangup, do_rc_hangup);
                 rc_port[i].close_delay = 50 * HZ/100;
                 rc_port[i].closing_wait = 3000 * HZ/100;
                 init_waitqueue_head(&rc_port[i].open_wait);
@@ -1671,7 +1646,6 @@ static void rc_release_drivers(void)
 
         save_flags(flags);
         cli();
-        free_page((unsigned long)tmp_buf);
         tty_unregister_driver(riscom_driver);
         put_tty_driver(riscom_driver);
         restore_flags(flags);
diff --git a/drivers/char/rocket.c b/drivers/char/rocket.c
index 0ac131881322..e94a62e30fc4 100644
--- a/drivers/char/rocket.c
+++ b/drivers/char/rocket.c
@@ -712,7 +712,7 @@ static void init_r_port(int board, int aiop, int chan, struct pci_dev *pci_dev)
  *  user mode into the driver (exception handler).  *info CD manipulation is spinlock protected.
  */
 static void configure_r_port(struct r_port *info,
-                             struct termios *old_termios)
+                             struct ktermios *old_termios)
 {
         unsigned cflag;
         unsigned long flags;
@@ -1017,7 +1017,7 @@ static int rp_open(struct tty_struct *tty, struct file *filp)
         /*
          * Info->count is now 1; so it's safe to sleep now.
          */
-        info->session = current->signal->session;
+        info->session = process_session(current);
         info->pgrp = process_group(current);
 
         if ((info->flags & ROCKET_INITIALIZED) == 0) {
@@ -1194,7 +1194,7 @@ static void rp_close(struct tty_struct *tty, struct file *filp)
 }
 
 static void rp_set_termios(struct tty_struct *tty,
-                           struct termios *old_termios)
+                           struct ktermios *old_termios)
 {
         struct r_port *info = (struct r_port *) tty->driver_data;
         CHANNEL_t *cp;
@@ -2214,7 +2214,7 @@ static int __init init_PCI(int boards_found)
         int count = 0;
 
         /*  Work through the PCI device list, pulling out ours */
-        while ((dev = pci_find_device(PCI_VENDOR_ID_RP, PCI_ANY_ID, dev))) {
+        while ((dev = pci_get_device(PCI_VENDOR_ID_RP, PCI_ANY_ID, dev))) {
                 if (register_PCI(count + boards_found, dev))
                         count++;
         }
@@ -2334,7 +2334,7 @@ static int __init init_ISA(int i)
         return (1);
 }
 
-static struct tty_operations rocket_ops = {
+static const struct tty_operations rocket_ops = {
         .open = rp_open,
         .close = rp_close,
         .write = rp_write,
@@ -2436,6 +2436,8 @@ static int __init rp_init(void)
         rocket_driver->init_termios = tty_std_termios;
         rocket_driver->init_termios.c_cflag =
             B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+        rocket_driver->init_termios.c_ispeed = 9600;
+        rocket_driver->init_termios.c_ospeed = 9600;
 #ifdef ROCKET_SOFT_FLOW
         rocket_driver->flags |= TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
 #endif
diff --git a/drivers/char/rtc.c b/drivers/char/rtc.c
index ab6429b4a84e..66a7385bc34a 100644
--- a/drivers/char/rtc.c
+++ b/drivers/char/rtc.c
@@ -35,13 +35,13 @@
  *      1.09a   Pete Zaitcev: Sun SPARC
  *      1.09b   Jeff Garzik: Modularize, init cleanup
  *      1.09c   Jeff Garzik: SMP cleanup
- *      1.10    Paul Barton-Davis: add support for async I/O
+ *      1.10    Paul Barton-Davis: add support for async I/O
  *      1.10a   Andrea Arcangeli: Alpha updates
  *      1.10b   Andrew Morton: SMP lock fix
  *      1.10c   Cesar Barros: SMP locking fixes and cleanup
  *      1.10d   Paul Gortmaker: delete paranoia check in rtc_exit
  *      1.10e   Maciej W. Rozycki: Handle DECstation's year weirdness.
- *      1.11    Takashi Iwai: Kernel access functions
+ *      1.11    Takashi Iwai: Kernel access functions
  *                            rtc_register/rtc_unregister/rtc_control
  *      1.11a   Daniele Bellucci: Audit create_proc_read_entry in rtc_init
  *      1.12    Venkatesh Pallipadi: Hooks for emulating rtc on HPET base-timer
@@ -113,9 +113,9 @@ static int rtc_has_irq = 1;
 #define hpet_set_rtc_irq_bit(arg)               0
 #define hpet_rtc_timer_init()                   do { } while (0)
 #define hpet_rtc_dropped_irq()                  0
-static inline irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs) {return 0;}
+static inline irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id) {return 0;}
 #else
-extern irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+extern irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id);
 #endif
 
 /*
@@ -229,7 +229,7 @@ static inline unsigned char rtc_is_updating(void)
  *      (See ./arch/XXXX/kernel/time.c for the set_rtc_mmss() function.)
  */
 
-irqreturn_t rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+irqreturn_t rtc_interrupt(int irq, void *dev_id)
 {
         /*
          *      Can be an alarm interrupt, update complete interrupt,
@@ -915,7 +915,7 @@ static const struct file_operations rtc_proc_fops = {
 };
 
 #if defined(RTC_IRQ) && !defined(__sparc__)
-static irqreturn_t (*rtc_int_handler_ptr)(int irq, void *dev_id, struct pt_regs *regs);
+static irq_handler_t rtc_int_handler_ptr;
 #endif
 
 static int __init rtc_init(void)
@@ -1262,10 +1262,8 @@ void rtc_get_rtc_time(struct rtc_time *rtc_tm)
          * Once the read clears, read the RTC time (again via ioctl). Easy.
          */
 
-        while (rtc_is_updating() != 0 && jiffies - uip_watchdog < 2*HZ/100) {
-                barrier();
+        while (rtc_is_updating() != 0 && jiffies - uip_watchdog < 2*HZ/100)
                 cpu_relax();
-        }
 
         /*
          * Only the values that we read from the RTC are set. We leave
diff --git a/drivers/char/s3c2410-rtc.c b/drivers/char/s3c2410-rtc.c
deleted file mode 100644
index 5458ef1634e5..000000000000
--- a/drivers/char/s3c2410-rtc.c
+++ /dev/null
@@ -1,591 +0,0 @@
-/* drivers/char/s3c2410_rtc.c
- *
- * Copyright (c) 2004 Simtec Electronics <linux@simtec.co.uk>
- *                    http://www.simtec.co.uk/products/SWLINUX/
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * S3C2410 Internal RTC Driver
- *
- *  Changelog:
- *      08-Nov-2004     BJD     Initial creation
- *      12-Nov-2004     BJD     Added periodic IRQ and PM code
- *      22-Nov-2004     BJD     Sign-test on alarm code to check for <0
- *      10-Mar-2005     LCVR    Changed S3C2410_VA_RTC to S3C24XX_VA_RTC
-*/
-
-#include <linux/module.h>
-#include <linux/fs.h>
-#include <linux/string.h>
-#include <linux/init.h>
-#include <linux/platform_device.h>
-#include <linux/interrupt.h>
-#include <linux/rtc.h>
-#include <linux/bcd.h>
-#include <linux/clk.h>
-
-#include <asm/hardware.h>
-#include <asm/uaccess.h>
-#include <asm/io.h>
-#include <asm/irq.h>
-#include <asm/rtc.h>
-
-#include <asm/mach/time.h>
-
-#include <asm/arch/regs-rtc.h>
-
-/* need this for the RTC_AF definitions */
-#include <linux/mc146818rtc.h>
-
-#undef S3C24XX_VA_RTC
-#define S3C24XX_VA_RTC s3c2410_rtc_base
-
-static struct resource *s3c2410_rtc_mem;
-
-static void __iomem *s3c2410_rtc_base;
-static int s3c2410_rtc_alarmno = NO_IRQ;
-static int s3c2410_rtc_tickno  = NO_IRQ;
-static int s3c2410_rtc_freq    = 1;
-
-static DEFINE_SPINLOCK(s3c2410_rtc_pie_lock);
-
-/* IRQ Handlers */
-
-static irqreturn_t s3c2410_rtc_alarmirq(int irq, void *id, struct pt_regs *r)
-{
-        rtc_update(1, RTC_AF | RTC_IRQF);
-        return IRQ_HANDLED;
-}
-
-static irqreturn_t s3c2410_rtc_tickirq(int irq, void *id, struct pt_regs *r)
-{
-        rtc_update(1, RTC_PF | RTC_IRQF);
-        return IRQ_HANDLED;
-}
-
-/* Update control registers */
-static void s3c2410_rtc_setaie(int to)
-{
-        unsigned int tmp;
-
-        pr_debug("%s: aie=%d\n", __FUNCTION__, to);
-
-        tmp = readb(S3C2410_RTCALM);
-
-        if (to)
-                tmp |= S3C2410_RTCALM_ALMEN;
-        else
-                tmp &= ~S3C2410_RTCALM_ALMEN;
-
-
-        writeb(tmp, S3C2410_RTCALM);
-}
-
-static void s3c2410_rtc_setpie(int to)
-{
-        unsigned int tmp;
-
-        pr_debug("%s: pie=%d\n", __FUNCTION__, to);
-
-        spin_lock_irq(&s3c2410_rtc_pie_lock);
-        tmp = readb(S3C2410_TICNT) & ~S3C2410_TICNT_ENABLE;
-
-        if (to)
-                tmp |= S3C2410_TICNT_ENABLE;
-
-        writeb(tmp, S3C2410_TICNT);
-        spin_unlock_irq(&s3c2410_rtc_pie_lock);
-}
-
-static void s3c2410_rtc_setfreq(int freq)
-{
-        unsigned int tmp;
-
-        spin_lock_irq(&s3c2410_rtc_pie_lock);
-        tmp = readb(S3C2410_TICNT) & S3C2410_TICNT_ENABLE;
-
-        s3c2410_rtc_freq = freq;
-
-        tmp |= (128 / freq)-1;
-
-        writeb(tmp, S3C2410_TICNT);
-        spin_unlock_irq(&s3c2410_rtc_pie_lock);
-}
-
-/* Time read/write */
-
-static int s3c2410_rtc_gettime(struct rtc_time *rtc_tm)
-{
-        unsigned int have_retried = 0;
-
- retry_get_time:
-        rtc_tm->tm_min  = readb(S3C2410_RTCMIN);
-        rtc_tm->tm_hour = readb(S3C2410_RTCHOUR);
-        rtc_tm->tm_mday = readb(S3C2410_RTCDATE);
-        rtc_tm->tm_mon  = readb(S3C2410_RTCMON);
-        rtc_tm->tm_year = readb(S3C2410_RTCYEAR);
-        rtc_tm->tm_sec  = readb(S3C2410_RTCSEC);
-
-        /* the only way to work out wether the system was mid-update
-         * when we read it is to check the second counter, and if it
-         * is zero, then we re-try the entire read
-         */
-
-        if (rtc_tm->tm_sec == 0 && !have_retried) {
-                have_retried = 1;
-                goto retry_get_time;
-        }
-
-        pr_debug("read time %02x.%02x.%02x %02x/%02x/%02x\n",
-                 rtc_tm->tm_year, rtc_tm->tm_mon, rtc_tm->tm_mday,
-                 rtc_tm->tm_hour, rtc_tm->tm_min, rtc_tm->tm_sec);
-
-        BCD_TO_BIN(rtc_tm->tm_sec);
-        BCD_TO_BIN(rtc_tm->tm_min);
-        BCD_TO_BIN(rtc_tm->tm_hour);
-        BCD_TO_BIN(rtc_tm->tm_mday);
-        BCD_TO_BIN(rtc_tm->tm_mon);
-        BCD_TO_BIN(rtc_tm->tm_year);
-
-        rtc_tm->tm_year += 100;
-        rtc_tm->tm_mon -= 1;
-
-        return 0;
-}
-
-
-static int s3c2410_rtc_settime(struct rtc_time *tm)
-{
-        /* the rtc gets round the y2k problem by just not supporting it */
-
-        if (tm->tm_year < 100)
-                return -EINVAL;
-
-        writeb(BIN2BCD(tm->tm_sec),  S3C2410_RTCSEC);
-        writeb(BIN2BCD(tm->tm_min),  S3C2410_RTCMIN);
-        writeb(BIN2BCD(tm->tm_hour), S3C2410_RTCHOUR);
-        writeb(BIN2BCD(tm->tm_mday), S3C2410_RTCDATE);
-        writeb(BIN2BCD(tm->tm_mon + 1), S3C2410_RTCMON);
-        writeb(BIN2BCD(tm->tm_year - 100), S3C2410_RTCYEAR);
-
-        return 0;
-}
-
-static int s3c2410_rtc_getalarm(struct rtc_wkalrm *alrm)
-{
-        struct rtc_time *alm_tm = &alrm->time;
-        unsigned int alm_en;
-
-        alm_tm->tm_sec  = readb(S3C2410_ALMSEC);
-        alm_tm->tm_min  = readb(S3C2410_ALMMIN);
-        alm_tm->tm_hour = readb(S3C2410_ALMHOUR);
-        alm_tm->tm_mon  = readb(S3C2410_ALMMON);
-        alm_tm->tm_mday = readb(S3C2410_ALMDATE);
-        alm_tm->tm_year = readb(S3C2410_ALMYEAR);
-
-        alm_en = readb(S3C2410_RTCALM);
-
-        pr_debug("read alarm %02x %02x.%02x.%02x %02x/%02x/%02x\n",
-                 alm_en,
-                 alm_tm->tm_year, alm_tm->tm_mon, alm_tm->tm_mday,
-                 alm_tm->tm_hour, alm_tm->tm_min, alm_tm->tm_sec);
-
-
-        /* decode the alarm enable field */
-
-        if (alm_en & S3C2410_RTCALM_SECEN) {
-                BCD_TO_BIN(alm_tm->tm_sec);
-        } else {
-                alm_tm->tm_sec = 0xff;
-        }
-
-        if (alm_en & S3C2410_RTCALM_MINEN) {
-                BCD_TO_BIN(alm_tm->tm_min);
-        } else {
-                alm_tm->tm_min = 0xff;
-        }
-
-        if (alm_en & S3C2410_RTCALM_HOUREN) {
-                BCD_TO_BIN(alm_tm->tm_hour);
-        } else {
-                alm_tm->tm_hour = 0xff;
-        }
-
-        if (alm_en & S3C2410_RTCALM_DAYEN) {
-                BCD_TO_BIN(alm_tm->tm_mday);
-        } else {
-                alm_tm->tm_mday = 0xff;
-        }
-
-        if (alm_en & S3C2410_RTCALM_MONEN) {
-                BCD_TO_BIN(alm_tm->tm_mon);
-                alm_tm->tm_mon -= 1;
-        } else {
-                alm_tm->tm_mon = 0xff;
-        }
-
-        if (alm_en & S3C2410_RTCALM_YEAREN) {
-                BCD_TO_BIN(alm_tm->tm_year);
-        } else {
-                alm_tm->tm_year = 0xffff;
-        }
-
-        /* todo - set alrm->enabled ? */
-
-        return 0;
-}
-
-static int s3c2410_rtc_setalarm(struct rtc_wkalrm *alrm)
-{
-        struct rtc_time *tm = &alrm->time;
-        unsigned int alrm_en;
-
-        pr_debug("s3c2410_rtc_setalarm: %d, %02x/%02x/%02x %02x.%02x.%02x\n",
-                 alrm->enabled,
-                 tm->tm_mday & 0xff, tm->tm_mon & 0xff, tm->tm_year & 0xff,
-                 tm->tm_hour & 0xff, tm->tm_min & 0xff, tm->tm_sec);
-
-        if (alrm->enabled || 1) {
-                alrm_en = readb(S3C2410_RTCALM) & S3C2410_RTCALM_ALMEN;
-                writeb(0x00, S3C2410_RTCALM);
-
-                if (tm->tm_sec < 60 && tm->tm_sec >= 0) {
-                        alrm_en |= S3C2410_RTCALM_SECEN;
-                        writeb(BIN2BCD(tm->tm_sec), S3C2410_ALMSEC);
-                }
-
-                if (tm->tm_min < 60 && tm->tm_min >= 0) {
-                        alrm_en |= S3C2410_RTCALM_MINEN;
-                        writeb(BIN2BCD(tm->tm_min), S3C2410_ALMMIN);
-                }
-
-                if (tm->tm_hour < 24 && tm->tm_hour >= 0) {
-                        alrm_en |= S3C2410_RTCALM_HOUREN;
-                        writeb(BIN2BCD(tm->tm_hour), S3C2410_ALMHOUR);
-                }
-
-                pr_debug("setting S3C2410_RTCALM to %08x\n", alrm_en);
-
-                writeb(alrm_en, S3C2410_RTCALM);
-                enable_irq_wake(s3c2410_rtc_alarmno);
-        } else {
-                alrm_en = readb(S3C2410_RTCALM);
-                alrm_en &= ~S3C2410_RTCALM_ALMEN;
-                writeb(alrm_en, S3C2410_RTCALM);
-                disable_irq_wake(s3c2410_rtc_alarmno);
-        }
-
-        return 0;
-}
-
-static int s3c2410_rtc_ioctl(unsigned int cmd, unsigned long arg)
-{
-        switch (cmd) {
-        case RTC_AIE_OFF:
-        case RTC_AIE_ON:
-                s3c2410_rtc_setaie((cmd == RTC_AIE_ON) ? 1 : 0);
-                return 0;
-
-        case RTC_PIE_OFF:
-        case RTC_PIE_ON:
-                s3c2410_rtc_setpie((cmd == RTC_PIE_ON) ? 1 : 0);
-                return 0;
-
-        case RTC_IRQP_READ:
-                return put_user(s3c2410_rtc_freq, (unsigned long __user *)arg);
-
-        case RTC_IRQP_SET:
-                if (arg < 1 || arg > 64)
-                        return -EINVAL;
-
-                if (!capable(CAP_SYS_RESOURCE))
-                        return -EACCES;
-
-                /* check for power of 2 */
-
-                if ((arg & (arg-1)) != 0)
-                        return -EINVAL;
-
-                pr_debug("s3c2410_rtc: setting frequency %ld\n", arg);
-
-                s3c2410_rtc_setfreq(arg);
-                return 0;
-
-        case RTC_UIE_ON:
-        case RTC_UIE_OFF:
-                return -EINVAL;
-        }
-
-        return -EINVAL;
-}
-
-static int s3c2410_rtc_proc(char *buf)
-{
-        unsigned int rtcalm = readb(S3C2410_RTCALM);
-        unsigned int ticnt = readb (S3C2410_TICNT);
-        char *p = buf;
-
-        p += sprintf(p, "alarm_IRQ\t: %s\n",
-                     (rtcalm & S3C2410_RTCALM_ALMEN) ? "yes" : "no" );
-        p += sprintf(p, "periodic_IRQ\t: %s\n",
-                     (ticnt & S3C2410_TICNT_ENABLE) ? "yes" : "no" );
-        p += sprintf(p, "periodic_freq\t: %d\n", s3c2410_rtc_freq);
-
-        return p - buf;
-}
-
-static int s3c2410_rtc_open(void)
-{
-        int ret;
-
-        ret = request_irq(s3c2410_rtc_alarmno, s3c2410_rtc_alarmirq,
-                          IRQF_DISABLED,  "s3c2410-rtc alarm", NULL);
-
-        if (ret)
-                printk(KERN_ERR "IRQ%d already in use\n", s3c2410_rtc_alarmno);
-
-        ret = request_irq(s3c2410_rtc_tickno, s3c2410_rtc_tickirq,
-                          IRQF_DISABLED,  "s3c2410-rtc tick", NULL);
-
-        if (ret) {
-                printk(KERN_ERR "IRQ%d already in use\n", s3c2410_rtc_tickno);
-                goto tick_err;
-        }
-
-        return ret;
-
- tick_err:
-        free_irq(s3c2410_rtc_alarmno, NULL);
-        return ret;
-}
-
-static void s3c2410_rtc_release(void)
-{
-        /* do not clear AIE here, it may be needed for wake */
-
-        s3c2410_rtc_setpie(0);
-        free_irq(s3c2410_rtc_alarmno, NULL);
-        free_irq(s3c2410_rtc_tickno, NULL);
-}
-
-static struct rtc_ops s3c2410_rtcops = {
-        .owner          = THIS_MODULE,
-        .open           = s3c2410_rtc_open,
-        .release        = s3c2410_rtc_release,
-        .ioctl          = s3c2410_rtc_ioctl,
-        .read_time      = s3c2410_rtc_gettime,
-        .set_time       = s3c2410_rtc_settime,
-        .read_alarm     = s3c2410_rtc_getalarm,
-        .set_alarm      = s3c2410_rtc_setalarm,
-        .proc           = s3c2410_rtc_proc,
-};
-
-static void s3c2410_rtc_enable(struct platform_device *pdev, int en)
-{
-        unsigned int tmp;
-
-        if (s3c2410_rtc_base == NULL)
-                return;
-
-        if (!en) {
-                tmp = readb(S3C2410_RTCCON);
-                writeb(tmp & ~S3C2410_RTCCON_RTCEN, S3C2410_RTCCON);
-
-                tmp = readb(S3C2410_TICNT);
-                writeb(tmp & ~S3C2410_TICNT_ENABLE, S3C2410_TICNT);
-        } else {
-                /* re-enable the device, and check it is ok */
-
-                if ((readb(S3C2410_RTCCON) & S3C2410_RTCCON_RTCEN) == 0){
-                        dev_info(&pdev->dev, "rtc disabled, re-enabling\n");
-
-                        tmp = readb(S3C2410_RTCCON);
-                        writeb(tmp | S3C2410_RTCCON_RTCEN , S3C2410_RTCCON);
-                }
-
-                if ((readb(S3C2410_RTCCON) & S3C2410_RTCCON_CNTSEL)){
-                        dev_info(&pdev->dev, "removing S3C2410_RTCCON_CNTSEL\n");
-
-                        tmp = readb(S3C2410_RTCCON);
-                        writeb(tmp& ~S3C2410_RTCCON_CNTSEL , S3C2410_RTCCON);
-                }
-
-                if ((readb(S3C2410_RTCCON) & S3C2410_RTCCON_CLKRST)){
-                        dev_info(&pdev->dev, "removing S3C2410_RTCCON_CLKRST\n");
-
-                        tmp = readb(S3C2410_RTCCON);
-                        writeb(tmp & ~S3C2410_RTCCON_CLKRST, S3C2410_RTCCON);
-                }
-        }
-}
-
-static int s3c2410_rtc_remove(struct platform_device *dev)
-{
-        unregister_rtc(&s3c2410_rtcops);
-
-        s3c2410_rtc_setpie(0);
-        s3c2410_rtc_setaie(0);
-
-        if (s3c2410_rtc_mem != NULL) {
-                pr_debug("s3c2410_rtc: releasing s3c2410_rtc_mem\n");
-                iounmap(s3c2410_rtc_base);
-                release_resource(s3c2410_rtc_mem);
-                kfree(s3c2410_rtc_mem);
-        }
-
-        return 0;
-}
-
-static int s3c2410_rtc_probe(struct platform_device *pdev)
-{
-        struct resource *res;
-        int ret;
-
-        pr_debug("%s: probe=%p\n", __FUNCTION__, pdev);
-
-        /* find the IRQs */
-
-        s3c2410_rtc_tickno = platform_get_irq(pdev, 1);
-        if (s3c2410_rtc_tickno < 0) {
-                dev_err(&pdev->dev, "no irq for rtc tick\n");
-                return -ENOENT;
-        }
-
-        s3c2410_rtc_alarmno = platform_get_irq(pdev, 0);
-        if (s3c2410_rtc_alarmno < 0) {
-                dev_err(&pdev->dev, "no irq for alarm\n");
-                return -ENOENT;
-        }
-
-        pr_debug("s3c2410_rtc: tick irq %d, alarm irq %d\n",
-                 s3c2410_rtc_tickno, s3c2410_rtc_alarmno);
-
-        /* get the memory region */
-
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (res == NULL) {
-                dev_err(&pdev->dev, "failed to get memory region resource\n");
-                return -ENOENT;
-        }
-
-        s3c2410_rtc_mem = request_mem_region(res->start, res->end-res->start+1,
-                                     pdev->name);
-
-        if (s3c2410_rtc_mem == NULL) {
-                dev_err(&pdev->dev, "failed to reserve memory region\n");
-                ret = -ENOENT;
-                goto exit_err;
-        }
-
-        s3c2410_rtc_base = ioremap(res->start, res->end - res->start + 1);
-        if (s3c2410_rtc_base == NULL) {
-                dev_err(&pdev->dev, "failed ioremap()\n");
-                ret = -EINVAL;
-                goto exit_err;
-        }
-
-        s3c2410_rtc_mem = res;
-        pr_debug("s3c2410_rtc_base=%p\n", s3c2410_rtc_base);
-
-        pr_debug("s3c2410_rtc: RTCCON=%02x\n", readb(S3C2410_RTCCON));
-
-        /* check to see if everything is setup correctly */
-
-        s3c2410_rtc_enable(pdev, 1);
-
-        pr_debug("s3c2410_rtc: RTCCON=%02x\n", readb(S3C2410_RTCCON));
-
-        s3c2410_rtc_setfreq(s3c2410_rtc_freq);
-
-        /* register RTC and exit */
-
-        register_rtc(&s3c2410_rtcops);
-        return 0;
-
- exit_err:
-        dev_err(&pdev->dev, "error %d during initialisation\n", ret);
-
-        return ret;
-}
-
-#ifdef CONFIG_PM
-
-/* S3C2410 RTC Power management control */
-
-static struct timespec s3c2410_rtc_delta;
-
-static int ticnt_save;
-
-static int s3c2410_rtc_suspend(struct platform_device *pdev, pm_message_t state)
-{
-        struct rtc_time tm;
-        struct timespec time;
-
-        time.tv_nsec = 0;
-
-        /* save TICNT for anyone using periodic interrupts */
-
-        ticnt_save = readb(S3C2410_TICNT);
-
-        /* calculate time delta for suspend */
-
-        s3c2410_rtc_gettime(&tm);
-        rtc_tm_to_time(&tm, &time.tv_sec);
-        save_time_delta(&s3c2410_rtc_delta, &time);
-        s3c2410_rtc_enable(pdev, 0);
-
-        return 0;
-}
-
-static int s3c2410_rtc_resume(struct platform_device *pdev)
-{
-        struct rtc_time tm;
-        struct timespec time;
-
-        time.tv_nsec = 0;
-
-        s3c2410_rtc_enable(pdev, 1);
-        s3c2410_rtc_gettime(&tm);
-        rtc_tm_to_time(&tm, &time.tv_sec);
-        restore_time_delta(&s3c2410_rtc_delta, &time);
-
-        writeb(ticnt_save, S3C2410_TICNT);
-        return 0;
-}
-#else
-#define s3c2410_rtc_suspend NULL
-#define s3c2410_rtc_resume  NULL
-#endif
-
-static struct platform_driver s3c2410_rtcdrv = {
-        .probe          = s3c2410_rtc_probe,
-        .remove         = s3c2410_rtc_remove,
-        .suspend        = s3c2410_rtc_suspend,
-        .resume         = s3c2410_rtc_resume,
-        .driver         = {
-                .name   = "s3c2410-rtc",
-                .owner  = THIS_MODULE,
-        },
-};
-
-static char __initdata banner[] = "S3C2410 RTC, (c) 2004 Simtec Electronics\n";
-
-static int __init s3c2410_rtc_init(void)
-{
-        printk(banner);
-        return platform_driver_register(&s3c2410_rtcdrv);
-}
-
-static void __exit s3c2410_rtc_exit(void)
-{
-        platform_driver_unregister(&s3c2410_rtcdrv);
-}
-
-module_init(s3c2410_rtc_init);
-module_exit(s3c2410_rtc_exit);
-
-MODULE_DESCRIPTION("S3C24XX RTC Driver");
-MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
-MODULE_LICENSE("GPL");
diff --git a/drivers/char/scx200_gpio.c b/drivers/char/scx200_gpio.c
index b956c7babd18..99e5272e3c53 100644
--- a/drivers/char/scx200_gpio.c
+++ b/drivers/char/scx200_gpio.c
@@ -44,7 +44,7 @@ struct nsc_gpio_ops scx200_gpio_ops = {
         .gpio_change    = scx200_gpio_change,
         .gpio_current   = scx200_gpio_current
 };
-EXPORT_SYMBOL(scx200_gpio_ops);
+EXPORT_SYMBOL_GPL(scx200_gpio_ops);
 
 static int scx200_gpio_open(struct inode *inode, struct file *file)
 {
@@ -69,7 +69,7 @@ static const struct file_operations scx200_gpio_fileops = {
         .release = scx200_gpio_release,
 };
 
-struct cdev scx200_gpio_cdev;  /* use 1 cdev for all pins */
+static struct cdev scx200_gpio_cdev;  /* use 1 cdev for all pins */
 
 static int __init scx200_gpio_init(void)
 {
diff --git a/drivers/char/selection.c b/drivers/char/selection.c
index 71093a9fc462..74cff839c857 100644
--- a/drivers/char/selection.c
+++ b/drivers/char/selection.c
@@ -33,7 +33,7 @@ extern void poke_blanked_console(void);
 
 /* Variables for selection control. */
 /* Use a dynamic buffer, instead of static (Dec 1994) */
-struct vc_data *sel_cons;               /* must not be disallocated */
+struct vc_data *sel_cons;               /* must not be deallocated */
 static volatile int sel_start = -1;     /* cleared by clear_selection */
 static int sel_end;
 static int sel_buffer_lth;
diff --git a/drivers/char/ser_a2232.c b/drivers/char/ser_a2232.c
index 510bd3e0e88b..75de5f66517a 100644
--- a/drivers/char/ser_a2232.c
+++ b/drivers/char/ser_a2232.c
@@ -111,7 +111,7 @@
 
 /***************************** Prototypes ***************************/
 /* The interrupt service routine */
-static irqreturn_t a2232_vbl_inter(int irq, void *data, struct pt_regs *fp);
+static irqreturn_t a2232_vbl_inter(int irq, void *data);
 /* Initialize the port structures */
 static void a2232_init_portstructs(void);
 /* Initialize and register TTY drivers. */
@@ -504,7 +504,7 @@ static int  a2232_open(struct tty_struct * tty, struct file * filp)
 }
 /*** END OF FUNCTIONS EXPECTED BY TTY DRIVER STRUCTS ***/
 
-static irqreturn_t a2232_vbl_inter(int irq, void *data, struct pt_regs *fp)
+static irqreturn_t a2232_vbl_inter(int irq, void *data)
 {
 #if A2232_IOBUFLEN != 256
 #error "Re-Implement a2232_vbl_inter()!"
@@ -661,7 +661,7 @@ static void a2232_init_portstructs(void)
         }
 }
 
-static struct tty_operations a2232_ops = {
+static const struct tty_operations a2232_ops = {
         .open = a2232_open,
         .close = gs_close,
         .write = gs_write,
@@ -695,6 +695,8 @@ static int a2232_init_drivers(void)
         a2232_driver->init_termios = tty_std_termios;
         a2232_driver->init_termios.c_cflag =
                 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+        a2232_driver->init_termios.c_ispeed = 9600;
+        a2232_driver->init_termios.c_ospeed = 9600;
         a2232_driver->flags = TTY_DRIVER_REAL_RAW;
         tty_set_operations(a2232_driver, &a2232_ops);
         if ((error = tty_register_driver(a2232_driver))) {
diff --git a/drivers/char/serial167.c b/drivers/char/serial167.c
index 21a710cb4bba..af50d32ae2c7 100644
--- a/drivers/char/serial167.c
+++ b/drivers/char/serial167.c
@@ -62,6 +62,7 @@
 #include <linux/console.h>
 #include <linux/module.h>
 #include <linux/bitops.h>
+#include <linux/tty_flip.h>
 
 #include <asm/system.h>
 #include <asm/io.h>
@@ -119,17 +120,6 @@ struct cyclades_port cy_port[] = {
 #define NR_PORTS        ARRAY_SIZE(cy_port)
 
 /*
- * tmp_buf is used as a temporary buffer by serial_write.  We need to
- * lock it in case the copy_from_user 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 = 0;
-
-/*
  * This is used to look up the divisor speeds and the timeouts
  * We're normally limited to 15 distinct baud rates.  The extra
  * are accessed via settings in info->flags.
@@ -381,7 +371,7 @@ cy_sched_event(struct cyclades_port *info, int event)
    received, out buffer empty, modem change, etc.
  */
 static irqreturn_t
-cd2401_rxerr_interrupt(int irq, void *dev_id, struct pt_regs *fp)
+cd2401_rxerr_interrupt(int irq, void *dev_id)
 {
     struct tty_struct *tty;
     struct cyclades_port *info;
@@ -438,8 +428,9 @@ cd2401_rxerr_interrupt(int irq, void *dev_id, struct pt_regs *fp)
                        overflowing, we still loose
                        the next incoming character.
                      */
-                    tty_insert_flip_char(tty, data, TTY_NORMAL);
-                }
+                    if (tty_buffer_request_room(tty, 1) != 0){
+                        tty_insert_flip_char(tty, data, TTY_FRAME);
+                    }
                 /* These two conditions may imply */
                 /* a normal read should be done. */
                 /* else if(data & CyTIMEOUT) */
@@ -448,21 +439,21 @@ cd2401_rxerr_interrupt(int irq, void *dev_id, struct pt_regs *fp)
                     tty_insert_flip_char(tty, 0, TTY_NORMAL);
                 }
             }else{
-                    tty_insert_flip_char(tty, data, TTY_NORMAL);
+                tty_insert_flip_char(tty, data, TTY_NORMAL);
             }
         }else{
             /* there was a software buffer overrun
                and nothing could be done about it!!! */
         }
     }
-    schedule_delayed_work(&tty->flip.work, 1);
+    tty_schedule_flip(tty);
     /* end of service */
     base_addr[CyREOIR] = rfoc ? 0 : CyNOTRANS;
     return IRQ_HANDLED;
 } /* cy_rxerr_interrupt */
 
 static irqreturn_t
-cd2401_modem_interrupt(int irq, void *dev_id, struct pt_regs *fp)
+cd2401_modem_interrupt(int irq, void *dev_id)
 {
     struct cyclades_port *info;
     volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
@@ -517,7 +508,7 @@ cd2401_modem_interrupt(int irq, void *dev_id, struct pt_regs *fp)
 } /* cy_modem_interrupt */
 
 static irqreturn_t
-cd2401_tx_interrupt(int irq, void *dev_id, struct pt_regs *fp)
+cd2401_tx_interrupt(int irq, void *dev_id)
 {
     struct cyclades_port *info;
     volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
@@ -637,7 +628,7 @@ cd2401_tx_interrupt(int irq, void *dev_id, struct pt_regs *fp)
 } /* cy_tx_interrupt */
 
 static irqreturn_t
-cd2401_rx_interrupt(int irq, void *dev_id, struct pt_regs *fp)
+cd2401_rx_interrupt(int irq, void *dev_id)
 {
     struct tty_struct *tty;
     struct cyclades_port *info;
@@ -646,6 +637,7 @@ cd2401_rx_interrupt(int irq, void *dev_id, struct pt_regs *fp)
     char data;
     int char_count;
     int save_cnt;
+    int len;
 
     /* determine the channel and change to that context */
     channel = (u_short ) (base_addr[CyLICR] >> 2);
@@ -678,14 +670,15 @@ cd2401_rx_interrupt(int irq, void *dev_id, struct pt_regs *fp)
             info->mon.char_max = char_count;
         info->mon.char_last = char_count;
 #endif
-        while(char_count--){
+        len = tty_buffer_request_room(tty, char_count);
+        while(len--){
             data = base_addr[CyRDR];
             tty_insert_flip_char(tty, data, TTY_NORMAL);
 #ifdef CYCLOM_16Y_HACK
             udelay(10L);
 #endif
         }
-        schedule_delayed_work(&tty->flip.work, 1);
+        tty_schedule_flip(tty);
     }
     /* end of service */
     base_addr[CyREOIR] = save_cnt ? 0 : CyNOTRANS;
@@ -713,9 +706,9 @@ cd2401_rx_interrupt(int irq, void *dev_id, struct pt_regs *fp)
  * had to poll every port to see if that port needed servicing.
  */
 static void
-do_softint(void *private_)
+do_softint(struct work_struct *ugly_api)
 {
-  struct cyclades_port *info = (struct cyclades_port *) private_;
+  struct cyclades_port *info = container_of(ugly_api, struct cyclades_port, tqueue);
   struct tty_struct    *tty;
 
     tty = info->tty;
@@ -846,7 +839,7 @@ shutdown(struct cyclades_port * info)
     local_irq_save(flags);
         if (info->xmit_buf){
             free_page((unsigned long) info->xmit_buf);
-            info->xmit_buf = 0;
+            info->xmit_buf = NULL;
         }
 
         base_addr[CyCAR] = (u_char)channel;
@@ -1132,7 +1125,7 @@ cy_put_char(struct tty_struct *tty, unsigned char ch)
     if (serial_paranoia_check(info, tty->name, "cy_put_char"))
         return;
 
-    if (!tty || !info->xmit_buf)
+    if (!info->xmit_buf)
         return;
 
     local_irq_save(flags);
@@ -1198,7 +1191,7 @@ cy_write(struct tty_struct * tty,
         return 0;
     }
         
-    if (!tty || !info->xmit_buf || !tmp_buf){
+    if (!info->xmit_buf){
         return 0;
     }
 
@@ -1361,7 +1354,7 @@ cy_unthrottle(struct tty_struct * tty)
 
 static int
 get_serial_info(struct cyclades_port * info,
-                           struct serial_struct * retinfo)
+                           struct serial_struct __user * retinfo)
 {
   struct serial_struct tmp;
 
@@ -1383,7 +1376,7 @@ get_serial_info(struct cyclades_port * info,
 
 static int
 set_serial_info(struct cyclades_port * info,
-                           struct serial_struct * new_info)
+                           struct serial_struct __user * new_info)
 {
   struct serial_struct new_serial;
   struct cyclades_port old_info;
@@ -1433,7 +1426,6 @@ cy_tiocmget(struct tty_struct *tty, struct file *file)
   volatile unsigned char *base_addr = (u_char *)BASE_ADDR;
   unsigned long flags;
   unsigned char status;
-  unsigned int result;
 
     channel = info->line;
 
@@ -1457,7 +1449,6 @@ cy_tiocmset(struct tty_struct *tty, struct file *file,
   int channel;
   volatile unsigned char *base_addr = (u_char *)BASE_ADDR;
   unsigned long flags;
-  unsigned int arg;
           
     channel = info->line;
 
@@ -1512,7 +1503,7 @@ send_break( struct cyclades_port * info, int duration)
 } /* send_break */
 
 static int
-get_mon_info(struct cyclades_port * info, struct cyclades_monitor * mon)
+get_mon_info(struct cyclades_port * info, struct cyclades_monitor __user * mon)
 {
 
    if (copy_to_user(mon, &info->mon, sizeof(struct cyclades_monitor)))
@@ -1525,7 +1516,7 @@ get_mon_info(struct cyclades_port * info, struct cyclades_monitor * mon)
 }
 
 static int
-set_threshold(struct cyclades_port * info, unsigned long *arg)
+set_threshold(struct cyclades_port * info, unsigned long __user *arg)
 {
    volatile unsigned char *base_addr = (u_char *)BASE_ADDR;
    unsigned long value;
@@ -1542,7 +1533,7 @@ set_threshold(struct cyclades_port * info, unsigned long *arg)
 }
 
 static int
-get_threshold(struct cyclades_port * info, unsigned long *value)
+get_threshold(struct cyclades_port * info, unsigned long __user *value)
 {
    volatile unsigned char *base_addr = (u_char *)BASE_ADDR;
    int channel;
@@ -1555,7 +1546,7 @@ get_threshold(struct cyclades_port * info, unsigned long *value)
 }
 
 static int
-set_default_threshold(struct cyclades_port * info, unsigned long *arg)
+set_default_threshold(struct cyclades_port * info, unsigned long __user *arg)
 {
    unsigned long value;
 
@@ -1567,13 +1558,13 @@ set_default_threshold(struct cyclades_port * info, unsigned long *arg)
 }
 
 static int
-get_default_threshold(struct cyclades_port * info, unsigned long *value)
+get_default_threshold(struct cyclades_port * info, unsigned long __user *value)
 {
    return put_user(info->default_threshold,value);
 }
 
 static int
-set_timeout(struct cyclades_port * info, unsigned long *arg)
+set_timeout(struct cyclades_port * info, unsigned long __user *arg)
 {
    volatile unsigned char *base_addr = (u_char *)BASE_ADDR;
    int channel;
@@ -1590,7 +1581,7 @@ set_timeout(struct cyclades_port * info, unsigned long *arg)
 }
 
 static int
-get_timeout(struct cyclades_port * info, unsigned long *value)
+get_timeout(struct cyclades_port * info, unsigned long __user *value)
 {
    volatile unsigned char *base_addr = (u_char *)BASE_ADDR;
    int channel;
@@ -1610,7 +1601,7 @@ set_default_timeout(struct cyclades_port * info, unsigned long value)
 }
 
 static int
-get_default_timeout(struct cyclades_port * info, unsigned long *value)
+get_default_timeout(struct cyclades_port * info, unsigned long __user *value)
 {
    return put_user(info->default_timeout,value);
 }
@@ -1622,6 +1613,7 @@ cy_ioctl(struct tty_struct *tty, struct file * file,
   unsigned long val;
   struct cyclades_port * info = (struct cyclades_port *)tty->driver_data;
   int ret_val = 0;
+  void __user *argp = (void __user *)arg;
 
 #ifdef SERIAL_DEBUG_OTHER
     printk("cy_ioctl %s, cmd = %x arg = %lx\n", tty->name, cmd, arg); /* */
@@ -1629,28 +1621,28 @@ cy_ioctl(struct tty_struct *tty, struct file * file,
 
     switch (cmd) {
         case CYGETMON:
-            ret_val = get_mon_info(info, (struct cyclades_monitor *)arg);
+            ret_val = get_mon_info(info, argp);
             break;
         case CYGETTHRESH:
-            ret_val = get_threshold(info, (unsigned long *)arg);
+            ret_val = get_threshold(info, argp);
             break;
         case CYSETTHRESH:
-            ret_val = set_threshold(info, (unsigned long *)arg);
+            ret_val = set_threshold(info, argp);
             break;
         case CYGETDEFTHRESH:
-            ret_val = get_default_threshold(info, (unsigned long *)arg);
+            ret_val = get_default_threshold(info, argp);
             break;
         case CYSETDEFTHRESH:
-            ret_val = set_default_threshold(info, (unsigned long *)arg);
+            ret_val = set_default_threshold(info, argp);
             break;
         case CYGETTIMEOUT:
-            ret_val = get_timeout(info, (unsigned long *)arg);
+            ret_val = get_timeout(info, argp);
             break;
         case CYSETTIMEOUT:
-            ret_val = set_timeout(info, (unsigned long *)arg);
+            ret_val = set_timeout(info, argp);
             break;
         case CYGETDEFTIMEOUT:
-            ret_val = get_default_timeout(info, (unsigned long *)arg);
+            ret_val = get_default_timeout(info, argp);
             break;
         case CYSETDEFTIMEOUT:
             ret_val = set_default_timeout(info, (unsigned long)arg);
@@ -1673,21 +1665,20 @@ cy_ioctl(struct tty_struct *tty, struct file * file,
 
 /* The following commands are incompletely implemented!!! */
         case TIOCGSOFTCAR:
-            ret_val = put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned long *) arg);
+            ret_val = put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned long __user *) argp);
             break;
         case TIOCSSOFTCAR:
-            ret_val = get_user(val, (unsigned long *) arg);
+            ret_val = get_user(val, (unsigned long __user *) argp);
             if (ret_val)
                     break;
             tty->termios->c_cflag =
                     ((tty->termios->c_cflag & ~CLOCAL) | (val ? CLOCAL : 0));
             break;
         case TIOCGSERIAL:
-            ret_val = get_serial_info(info, (struct serial_struct *) arg);
+            ret_val = get_serial_info(info, argp);
             break;
         case TIOCSSERIAL:
-            ret_val = set_serial_info(info,
-                                   (struct serial_struct *) arg);
+            ret_val = set_serial_info(info, argp);
             break;
         default:
             ret_val = -ENOIOCTLCMD;
@@ -1704,7 +1695,7 @@ cy_ioctl(struct tty_struct *tty, struct file * file,
 
 
 static void
-cy_set_termios(struct tty_struct *tty, struct termios * old_termios)
+cy_set_termios(struct tty_struct *tty, struct ktermios * old_termios)
 {
   struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
 
@@ -1782,7 +1773,7 @@ cy_close(struct tty_struct * tty, struct file * filp)
         tty->driver->flush_buffer(tty);
     tty_ldisc_flush(tty);
     info->event = 0;
-    info->tty = 0;
+    info->tty = NULL;
     if (info->blocked_open) {
         if (info->close_delay) {
             msleep_interruptible(jiffies_to_msecs(info->close_delay));
@@ -1983,13 +1974,6 @@ cy_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;
-        }
-    }
-
     /*
      * Start up serial port
      */
@@ -2158,7 +2142,7 @@ mvme167_serial_console_setup(int cflag)
                                         rcor >> 5, rbpr);
 } /* serial_console_init */
 
-static struct tty_operations cy_ops = {
+static const struct tty_operations cy_ops = {
         .open = cy_open,
         .close = cy_close,
         .write = cy_write,
@@ -2266,7 +2250,7 @@ scrn[1] = '\0';
                 info->card = index;
                 info->line = port_num;
                 info->flags = STD_COM_FLAGS;
-                info->tty = 0;
+                info->tty = NULL;
                 info->xmit_fifo_size = 12;
                 info->cor1 = CyPARITY_NONE|Cy_8_BITS;
                 info->cor2 = CyETC;
@@ -2289,7 +2273,7 @@ scrn[1] = '\0';
                 info->blocked_open = 0;
                 info->default_threshold = 0;
                 info->default_timeout = 0;
-                INIT_WORK(&info->tqueue, do_softint, info);
+                INIT_WORK(&info->tqueue, do_softint);
                 init_waitqueue_head(&info->open_wait);
                 init_waitqueue_head(&info->close_wait);
                 /* info->session */
diff --git a/drivers/char/snsc.c b/drivers/char/snsc.c
index 07e0b75f2338..52753e723eaa 100644
--- a/drivers/char/snsc.c
+++ b/drivers/char/snsc.c
@@ -34,7 +34,7 @@
 #define SCDRV_TIMEOUT   1000
 
 static irqreturn_t
-scdrv_interrupt(int irq, void *subch_data, struct pt_regs *regs)
+scdrv_interrupt(int irq, void *subch_data)
 {
         struct subch_data_s *sd = subch_data;
         unsigned long flags;
diff --git a/drivers/char/snsc_event.c b/drivers/char/snsc_event.c
index d12d4f629cec..2f56e8c54897 100644
--- a/drivers/char/snsc_event.c
+++ b/drivers/char/snsc_event.c
@@ -36,7 +36,7 @@ DECLARE_TASKLET(sn_sysctl_event, scdrv_event, 0);
  * destination.
  */
 static irqreturn_t
-scdrv_event_interrupt(int irq, void *subch_data, struct pt_regs *regs)
+scdrv_event_interrupt(int irq, void *subch_data)
 {
         struct subch_data_s *sd = subch_data;
         unsigned long flags;
@@ -220,7 +220,7 @@ scdrv_dispatch_event(char *event, int len)
                                " Sending SIGPWR to init...\n");
 
                 /* give a SIGPWR signal to init proc */
-                kill_proc(1, SIGPWR, 0);
+                kill_cad_pid(SIGPWR, 0);
         } else {
                 /* print to system log */
                 printk("%s|$(0x%x)%s\n", severity, esp_code, desc);
diff --git a/drivers/char/sonypi.c b/drivers/char/sonypi.c
index d4e434d694b7..17d54e1331b2 100644
--- a/drivers/char/sonypi.c
+++ b/drivers/char/sonypi.c
@@ -765,7 +765,7 @@ static void sonypi_setbluetoothpower(u8 state)
         sonypi_device.bluetooth_power = state;
 }
 
-static void input_keyrelease(void *data)
+static void input_keyrelease(struct work_struct *work)
 {
         struct sonypi_keypress kp;
 
@@ -826,7 +826,7 @@ static void sonypi_report_input_event(u8 event)
 }
 
 /* Interrupt handler: some event is available */
-static irqreturn_t sonypi_irq(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t sonypi_irq(int irq, void *dev_id)
 {
         u8 v1, v2, event = 0;
         int i, j;
@@ -979,7 +979,7 @@ static ssize_t sonypi_misc_read(struct file *file, char __user *buf,
         }
 
         if (ret > 0) {
-                struct inode *inode = file->f_dentry->d_inode;
+                struct inode *inode = file->f_path.dentry->d_inode;
                 inode->i_atime = current_fs_time(inode->i_sb);
         }
 
@@ -1412,7 +1412,7 @@ static int __devinit sonypi_probe(struct platform_device *dev)
                         goto err_inpdev_unregister;
                 }
 
-                INIT_WORK(&sonypi_device.input_work, input_keyrelease, NULL);
+                INIT_WORK(&sonypi_device.input_work, input_keyrelease);
         }
 
         sonypi_enable(0);
diff --git a/drivers/char/specialix.c b/drivers/char/specialix.c
index a1d303f9a33d..20946f5127e0 100644
--- a/drivers/char/specialix.c
+++ b/drivers/char/specialix.c
@@ -182,12 +182,6 @@ static int sx_poll = HZ;
 #define RS_EVENT_WRITE_WAKEUP   0
 
 static struct tty_driver *specialix_driver;
-static unsigned char * tmp_buf;
-
-static unsigned long baud_table[] =  {
-        0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
-        9600, 19200, 38400, 57600, 115200, 0,
-};
 
 static struct specialix_board sx_board[SX_NBOARD] =  {
         { 0, SX_IOBASE1,  9, },
@@ -201,7 +195,7 @@ static struct specialix_port sx_port[SX_NBOARD * SX_NPORT];
 
 #ifdef SPECIALIX_TIMER
 static struct timer_list missed_irq_timer;
-static irqreturn_t sx_interrupt(int irq, void * dev_id, struct pt_regs * regs);
+static irqreturn_t sx_interrupt(int irq, void * dev_id);
 #endif
 
 
@@ -898,7 +892,7 @@ static inline void sx_check_modem(struct specialix_board * bp)
 
 
 /* The main interrupt processing routine */
-static irqreturn_t sx_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t sx_interrupt(int irq, void *dev_id)
 {
         unsigned char status;
         unsigned char ack;
@@ -913,7 +907,7 @@ static irqreturn_t sx_interrupt(int irq, void *dev_id, struct pt_regs *regs)
         spin_lock_irqsave(&bp->lock, flags);
 
         dprintk (SX_DEBUG_FLOW, "enter %s port %d room: %ld\n", __FUNCTION__, port_No(sx_get_port(bp, "INT")), SERIAL_XMIT_SIZE - sx_get_port(bp, "ITN")->xmit_cnt - 1);
-        if (!bp || !(bp->flags & SX_BOARD_ACTIVE)) {
+        if (!(bp->flags & SX_BOARD_ACTIVE)) {
                 dprintk (SX_DEBUG_IRQ, "sx: False interrupt. irq %d.\n", irq);
                 spin_unlock_irqrestore(&bp->lock, flags);
                 func_exit();
@@ -1087,24 +1081,16 @@ static void sx_change_speed(struct specialix_board *bp, struct specialix_port *p
                 port->MSVR =  (sx_in(bp, CD186x_MSVR) & MSVR_RTS);
         spin_unlock_irqrestore(&bp->lock, flags);
         dprintk (SX_DEBUG_TERMIOS, "sx: got MSVR=%02x.\n", port->MSVR);
-        baud = C_BAUD(tty);
+        baud = tty_get_baud_rate(tty);
 
-        if (baud & CBAUDEX) {
-                baud &= ~CBAUDEX;
-                if (baud < 1 || baud > 2)
-                        port->tty->termios->c_cflag &= ~CBAUDEX;
-                else
-                        baud += 15;
-        }
-        if (baud == 15) {
+        if (baud == 38400) {
                 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
-                        baud ++;
+                        baud = 57600;
                 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
-                        baud += 2;
+                        baud = 115200;
         }
 
-
-        if (!baud_table[baud]) {
+        if (!baud) {
                 /* Drop DTR & exit */
                 dprintk (SX_DEBUG_TERMIOS, "Dropping DTR...  Hmm....\n");
                 if (!SX_CRTSCTS (tty)) {
@@ -1134,7 +1120,7 @@ static void sx_change_speed(struct specialix_board *bp, struct specialix_port *p
                                   "This is an untested option, please be carefull.\n",
                                   port_No (port), tmp);
         else
-                tmp = (((SX_OSCFREQ + baud_table[baud]/2) / baud_table[baud] +
+                tmp = (((SX_OSCFREQ + baud/2) / baud +
                          CD186x_TPC/2) / CD186x_TPC);
 
         if ((tmp < 0x10) && time_before(again, jiffies)) {
@@ -1159,11 +1145,9 @@ static void sx_change_speed(struct specialix_board *bp, struct specialix_port *p
         sx_out(bp, CD186x_RBPRL, tmp & 0xff);
         sx_out(bp, CD186x_TBPRL, tmp & 0xff);
         spin_unlock_irqrestore(&bp->lock, flags);
-        if (port->custom_divisor) {
+        if (port->custom_divisor)
                 baud = (SX_OSCFREQ + port->custom_divisor/2) / port->custom_divisor;
-                baud = ( baud + 5 ) / 10;
-        } else
-                baud = (baud_table[baud] + 5) / 10;   /* Estimated CPS */
+        baud = (baud + 5) / 10;         /* Estimated CPS */
 
         /* Two timer ticks seems enough to wakeup something like SLIP driver */
         tmp = ((baud + HZ/2) / HZ) * 2 - CD186x_NFIFO;
@@ -1682,7 +1666,7 @@ static int sx_write(struct tty_struct * tty,
 
         bp = port_Board(port);
 
-        if (!port->xmit_buf || !tmp_buf) {
+        if (!port->xmit_buf) {
                 func_exit();
                 return 0;
         }
@@ -2277,9 +2261,10 @@ static void sx_start(struct tty_struct * tty)
  *      do_sx_hangup() -> tty->hangup() -> sx_hangup()
  *
  */
-static void do_sx_hangup(void *private_)
+static void do_sx_hangup(struct work_struct *work)
 {
-        struct specialix_port   *port = (struct specialix_port *) private_;
+        struct specialix_port   *port =
+                container_of(work, struct specialix_port, tqueue_hangup);
         struct tty_struct       *tty;
 
         func_enter();
@@ -2326,7 +2311,7 @@ static void sx_hangup(struct tty_struct * tty)
 }
 
 
-static void sx_set_termios(struct tty_struct * tty, struct termios * old_termios)
+static void sx_set_termios(struct tty_struct * tty, struct ktermios * old_termios)
 {
         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
         unsigned long flags;
@@ -2352,9 +2337,10 @@ static void sx_set_termios(struct tty_struct * tty, struct termios * old_termios
 }
 
 
-static void do_softint(void *private_)
+static void do_softint(struct work_struct *work)
 {
-        struct specialix_port   *port = (struct specialix_port *) private_;
+        struct specialix_port   *port =
+                container_of(work, struct specialix_port, tqueue);
         struct tty_struct       *tty;
 
         func_enter();
@@ -2372,7 +2358,7 @@ static void do_softint(void *private_)
         func_exit();
 }
 
-static struct tty_operations sx_ops = {
+static const struct tty_operations sx_ops = {
         .open  = sx_open,
         .close = sx_close,
         .write = sx_write,
@@ -2406,12 +2392,6 @@ static int sx_init_drivers(void)
                 return 1;
         }
 
-        if (!(tmp_buf = (unsigned char *) get_zeroed_page(GFP_KERNEL))) {
-                printk(KERN_ERR "sx: Couldn't get free page.\n");
-                put_tty_driver(specialix_driver);
-                func_exit();
-                return 1;
-        }
         specialix_driver->owner = THIS_MODULE;
         specialix_driver->name = "ttyW";
         specialix_driver->major = SPECIALIX_NORMAL_MAJOR;
@@ -2420,12 +2400,13 @@ static int sx_init_drivers(void)
         specialix_driver->init_termios = tty_std_termios;
         specialix_driver->init_termios.c_cflag =
                 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+        specialix_driver->init_termios.c_ispeed = 9600;
+        specialix_driver->init_termios.c_ospeed = 9600;
         specialix_driver->flags = TTY_DRIVER_REAL_RAW;
         tty_set_operations(specialix_driver, &sx_ops);
 
         if ((error = tty_register_driver(specialix_driver))) {
                 put_tty_driver(specialix_driver);
-                free_page((unsigned long)tmp_buf);
                 printk(KERN_ERR "sx: Couldn't register specialix IO8+ driver, error = %d\n",
                        error);
                 func_exit();
@@ -2434,8 +2415,8 @@ static int sx_init_drivers(void)
         memset(sx_port, 0, sizeof(sx_port));
         for (i = 0; i < SX_NPORT * SX_NBOARD; i++) {
                 sx_port[i].magic = SPECIALIX_MAGIC;
-                INIT_WORK(&sx_port[i].tqueue, do_softint, &sx_port[i]);
-                INIT_WORK(&sx_port[i].tqueue_hangup, do_sx_hangup, &sx_port[i]);
+                INIT_WORK(&sx_port[i].tqueue, do_softint);
+                INIT_WORK(&sx_port[i].tqueue_hangup, do_sx_hangup);
                 sx_port[i].close_delay = 50 * HZ/100;
                 sx_port[i].closing_wait = 3000 * HZ/100;
                 init_waitqueue_head(&sx_port[i].open_wait);
@@ -2451,7 +2432,6 @@ static void sx_release_drivers(void)
 {
         func_enter();
 
-        free_page((unsigned long)tmp_buf);
         tty_unregister_driver(specialix_driver);
         put_tty_driver(specialix_driver);
         func_exit();
@@ -2497,7 +2477,7 @@ static int __init specialix_init(void)
                                 i++;
                                 continue;
                         }
-                        pdev = pci_find_device (PCI_VENDOR_ID_SPECIALIX,
+                        pdev = pci_get_device (PCI_VENDOR_ID_SPECIALIX,
                                                 PCI_DEVICE_ID_SPECIALIX_IO8,
                                                 pdev);
                         if (!pdev) break;
@@ -2513,6 +2493,9 @@ static int __init specialix_init(void)
                         if (!sx_probe(&sx_board[i]))
                                 found ++;
                 }
+                /* May exit pci_get sequence early with lots of boards */
+                if (pdev != NULL)
+                        pci_dev_put(pdev);
         }
 #endif
 
diff --git a/drivers/char/stallion.c b/drivers/char/stallion.c
index 3beb2203d24b..e45113a7a472 100644
--- a/drivers/char/stallion.c
+++ b/drivers/char/stallion.c
@@ -41,13 +41,12 @@
 #include <linux/smp_lock.h>
 #include <linux/device.h>
 #include <linux/delay.h>
+#include <linux/ctype.h>
 
 #include <asm/io.h>
 #include <asm/uaccess.h>
 
-#ifdef CONFIG_PCI
 #include <linux/pci.h>
-#endif
 
 /*****************************************************************************/
 
@@ -63,45 +62,16 @@
 #define BRD_ECH64PCI    27
 #define BRD_EASYIOPCI   28
 
-/*
- *      Define a configuration structure to hold the board configuration.
- *      Need to set this up in the code (for now) with the boards that are
- *      to be configured into the system. This is what needs to be modified
- *      when adding/removing/modifying boards. Each line entry in the
- *      stl_brdconf[] array is a board. Each line contains io/irq/memory
- *      ranges for that board (as well as what type of board it is).
- *      Some examples:
- *              { BRD_EASYIO, 0x2a0, 0, 0, 10, 0 },
- *      This line would configure an EasyIO board (4 or 8, no difference),
- *      at io address 2a0 and irq 10.
- *      Another example:
- *              { BRD_ECH, 0x2a8, 0x280, 0, 12, 0 },
- *      This line will configure an EasyConnection 8/32 board at primary io
- *      address 2a8, secondary io address 280 and irq 12.
- *      Enter as many lines into this array as you want (only the first 4
- *      will actually be used!). Any combination of EasyIO and EasyConnection
- *      boards can be specified. EasyConnection 8/32 boards can share their
- *      secondary io addresses between each other.
- *
- *      NOTE: there is no need to put any entries in this table for PCI
- *      boards. They will be found automatically by the driver - provided
- *      PCI BIOS32 support is compiled into the kernel.
- */
-
-typedef struct {
-        int             brdtype;
+struct stlconf {
+        unsigned int    brdtype;
         int             ioaddr1;
         int             ioaddr2;
         unsigned long   memaddr;
         int             irq;
         int             irqtype;
-} stlconf_t;
-
-static stlconf_t        stl_brdconf[] = {
-        /*{ BRD_EASYIO, 0x2a0, 0, 0, 10, 0 },*/
 };
 
-static int      stl_nrbrds = ARRAY_SIZE(stl_brdconf);
+static unsigned int stl_nrbrds;
 
 /*****************************************************************************/
 
@@ -143,34 +113,30 @@ static struct tty_driver	*stl_serial;
  *      with this termios initially. Basically all it defines is a raw port
  *      at 9600, 8 data bits, 1 stop bit.
  */
-static struct termios           stl_deftermios = {
+static struct ktermios          stl_deftermios = {
         .c_cflag        = (B9600 | CS8 | CREAD | HUPCL | CLOCAL),
         .c_cc           = INIT_C_CC,
+        .c_ispeed       = 9600,
+        .c_ospeed       = 9600,
 };
 
 /*
- *      Define global stats structures. Not used often, and can be
- *      re-used for each stats call.
- */
-static comstats_t       stl_comstats;
-static combrd_t         stl_brdstats;
-static stlbrd_t         stl_dummybrd;
-static stlport_t        stl_dummyport;
-
-/*
  *      Define global place to put buffer overflow characters.
  */
 static char             stl_unwanted[SC26198_RXFIFOSIZE];
 
 /*****************************************************************************/
 
-static stlbrd_t         *stl_brds[STL_MAXBRDS];
+static DEFINE_MUTEX(stl_brdslock);
+static struct stlbrd            *stl_brds[STL_MAXBRDS];
 
 /*
  *      Per board state flags. Used with the state field of the board struct.
  *      Not really much here!
  */
 #define BRD_FOUND       0x1
+#define STL_PROBED      0x2
+
 
 /*
  *      Define the port structure istate flags. These set of flags are
@@ -187,32 +153,32 @@ static stlbrd_t		*stl_brds[STL_MAXBRDS];
  *      referencing boards when printing trace and stuff.
  */
 static char     *stl_brdnames[] = {
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
         "EasyIO",
         "EC8/32-AT",
         "EC8/32-MC",
-        (char *) NULL,
-        (char *) NULL,
-        (char *) NULL,
+        NULL,
+        NULL,
+        NULL,
         "EC8/32-PCI",
         "EC8/64-PCI",
         "EasyIO-PCI",
@@ -225,7 +191,7 @@ static char	*stl_brdnames[] = {
  *      load line. These allow for easy board definitions, and easy
  *      modification of the io, memory and irq resoucres.
  */
-static int      stl_nargs = 0;
+static unsigned int stl_nargs;
 static char     *board0[4];
 static char     *board1[4];
 static char     *board2[4];
@@ -243,12 +209,10 @@ static char	**stl_brdsp[] = {
  *      parse any module arguments.
  */
 
-typedef struct stlbrdtype {
+static struct {
         char    *name;
         int     type;
-} stlbrdtype_t;
-
-static stlbrdtype_t     stl_brdstr[] = {
+} stl_brdstr[] = {
         { "easyio", BRD_EASYIO },
         { "eio", BRD_EASYIO },
         { "20", BRD_EASYIO },
@@ -282,9 +246,6 @@ static stlbrdtype_t	stl_brdstr[] = {
 /*
  *      Define the module agruments.
  */
-MODULE_AUTHOR("Greg Ungerer");
-MODULE_DESCRIPTION("Stallion Multiport Serial Driver");
-MODULE_LICENSE("GPL");
 
 module_param_array(board0, charp, &stl_nargs, 0);
 MODULE_PARM_DESC(board0, "Board 0 config -> name[,ioaddr[,ioaddr2][,irq]]");
@@ -386,8 +347,6 @@ static spinlock_t stallion_lock;	/* Guard the tty driver */
 
 /*****************************************************************************/
 
-#ifdef CONFIG_PCI
-
 /*
  *      Define the Stallion PCI vendor and device IDs.
  */
@@ -407,22 +366,19 @@ static spinlock_t stallion_lock;	/* Guard the tty driver */
 /*
  *      Define structure to hold all Stallion PCI boards.
  */
-typedef struct stlpcibrd {
-        unsigned short          vendid;
-        unsigned short          devid;
-        int                     brdtype;
-} stlpcibrd_t;
-
-static stlpcibrd_t      stl_pcibrds[] = {
-        { PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_ECHPCI864, BRD_ECH64PCI },
-        { PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_EIOPCI, BRD_EASYIOPCI },
-        { PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_ECHPCI832, BRD_ECHPCI },
-        { PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_87410, BRD_ECHPCI },
-};
-
-static int      stl_nrpcibrds = ARRAY_SIZE(stl_pcibrds);
 
-#endif
+static struct pci_device_id stl_pcibrds[] = {
+        { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_ECHPCI864),
+                .driver_data = BRD_ECH64PCI },
+        { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_EIOPCI),
+                .driver_data = BRD_EASYIOPCI },
+        { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_ECHPCI832),
+                .driver_data = BRD_ECHPCI },
+        { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_87410),
+                .driver_data = BRD_ECHPCI },
+        { }
+};
+MODULE_DEVICE_TABLE(pci, stl_pcibrds);
 
 /*****************************************************************************/
 
@@ -442,134 +398,74 @@ static unsigned int	stl_baudrates[] = {
         9600, 19200, 38400, 57600, 115200, 230400, 460800, 921600
 };
 
-/*
- *      Define some handy local macros...
- */
-#undef  MIN
-#define MIN(a,b)        (((a) <= (b)) ? (a) : (b))
-
-#undef  TOLOWER
-#define TOLOWER(x)      ((((x) >= 'A') && ((x) <= 'Z')) ? ((x) + 0x20) : (x))
-
 /*****************************************************************************/
 
 /*
  *      Declare all those functions in this driver!
  */
 
-static void     stl_argbrds(void);
-static int      stl_parsebrd(stlconf_t *confp, char **argp);
-
-static unsigned long stl_atol(char *str);
-
-static int      stl_init(void);
-static int      stl_open(struct tty_struct *tty, struct file *filp);
-static void     stl_close(struct tty_struct *tty, struct file *filp);
-static int      stl_write(struct tty_struct *tty, const unsigned char *buf, int count);
-static void     stl_putchar(struct tty_struct *tty, unsigned char ch);
-static void     stl_flushchars(struct tty_struct *tty);
-static int      stl_writeroom(struct tty_struct *tty);
-static int      stl_charsinbuffer(struct tty_struct *tty);
-static int      stl_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg);
-static void     stl_settermios(struct tty_struct *tty, struct termios *old);
-static void     stl_throttle(struct tty_struct *tty);
-static void     stl_unthrottle(struct tty_struct *tty);
-static void     stl_stop(struct tty_struct *tty);
-static void     stl_start(struct tty_struct *tty);
-static void     stl_flushbuffer(struct tty_struct *tty);
-static void     stl_breakctl(struct tty_struct *tty, int state);
-static void     stl_waituntilsent(struct tty_struct *tty, int timeout);
-static void     stl_sendxchar(struct tty_struct *tty, char ch);
-static void     stl_hangup(struct tty_struct *tty);
 static int      stl_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg);
-static int      stl_portinfo(stlport_t *portp, int portnr, char *pos);
-static int      stl_readproc(char *page, char **start, off_t off, int count, int *eof, void *data);
-
-static int      stl_brdinit(stlbrd_t *brdp);
-static int      stl_initports(stlbrd_t *brdp, stlpanel_t *panelp);
-static int      stl_getserial(stlport_t *portp, struct serial_struct __user *sp);
-static int      stl_setserial(stlport_t *portp, struct serial_struct __user *sp);
-static int      stl_getbrdstats(combrd_t __user *bp);
-static int      stl_getportstats(stlport_t *portp, comstats_t __user *cp);
-static int      stl_clrportstats(stlport_t *portp, comstats_t __user *cp);
-static int      stl_getportstruct(stlport_t __user *arg);
-static int      stl_getbrdstruct(stlbrd_t __user *arg);
-static int      stl_waitcarrier(stlport_t *portp, struct file *filp);
-static int      stl_eiointr(stlbrd_t *brdp);
-static int      stl_echatintr(stlbrd_t *brdp);
-static int      stl_echmcaintr(stlbrd_t *brdp);
-static int      stl_echpciintr(stlbrd_t *brdp);
-static int      stl_echpci64intr(stlbrd_t *brdp);
-static void     stl_offintr(void *private);
-static stlbrd_t *stl_allocbrd(void);
-static stlport_t *stl_getport(int brdnr, int panelnr, int portnr);
-
-static inline int       stl_initbrds(void);
-static inline int       stl_initeio(stlbrd_t *brdp);
-static inline int       stl_initech(stlbrd_t *brdp);
-static inline int       stl_getbrdnr(void);
-
-#ifdef  CONFIG_PCI
-static inline int       stl_findpcibrds(void);
-static inline int       stl_initpcibrd(int brdtype, struct pci_dev *devp);
-#endif
+static int      stl_brdinit(struct stlbrd *brdp);
+static int      stl_getportstats(struct stlport *portp, comstats_t __user *cp);
+static int      stl_clrportstats(struct stlport *portp, comstats_t __user *cp);
+static int      stl_waitcarrier(struct stlport *portp, struct file *filp);
 
 /*
  *      CD1400 uart specific handling functions.
  */
-static void     stl_cd1400setreg(stlport_t *portp, int regnr, int value);
-static int      stl_cd1400getreg(stlport_t *portp, int regnr);
-static int      stl_cd1400updatereg(stlport_t *portp, int regnr, int value);
-static int      stl_cd1400panelinit(stlbrd_t *brdp, stlpanel_t *panelp);
-static void     stl_cd1400portinit(stlbrd_t *brdp, stlpanel_t *panelp, stlport_t *portp);
-static void     stl_cd1400setport(stlport_t *portp, struct termios *tiosp);
-static int      stl_cd1400getsignals(stlport_t *portp);
-static void     stl_cd1400setsignals(stlport_t *portp, int dtr, int rts);
-static void     stl_cd1400ccrwait(stlport_t *portp);
-static void     stl_cd1400enablerxtx(stlport_t *portp, int rx, int tx);
-static void     stl_cd1400startrxtx(stlport_t *portp, int rx, int tx);
-static void     stl_cd1400disableintrs(stlport_t *portp);
-static void     stl_cd1400sendbreak(stlport_t *portp, int len);
-static void     stl_cd1400flowctrl(stlport_t *portp, int state);
-static void     stl_cd1400sendflow(stlport_t *portp, int state);
-static void     stl_cd1400flush(stlport_t *portp);
-static int      stl_cd1400datastate(stlport_t *portp);
-static void     stl_cd1400eiointr(stlpanel_t *panelp, unsigned int iobase);
-static void     stl_cd1400echintr(stlpanel_t *panelp, unsigned int iobase);
-static void     stl_cd1400txisr(stlpanel_t *panelp, int ioaddr);
-static void     stl_cd1400rxisr(stlpanel_t *panelp, int ioaddr);
-static void     stl_cd1400mdmisr(stlpanel_t *panelp, int ioaddr);
-
-static inline int       stl_cd1400breakisr(stlport_t *portp, int ioaddr);
+static void     stl_cd1400setreg(struct stlport *portp, int regnr, int value);
+static int      stl_cd1400getreg(struct stlport *portp, int regnr);
+static int      stl_cd1400updatereg(struct stlport *portp, int regnr, int value);
+static int      stl_cd1400panelinit(struct stlbrd *brdp, struct stlpanel *panelp);
+static void     stl_cd1400portinit(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp);
+static void     stl_cd1400setport(struct stlport *portp, struct ktermios *tiosp);
+static int      stl_cd1400getsignals(struct stlport *portp);
+static void     stl_cd1400setsignals(struct stlport *portp, int dtr, int rts);
+static void     stl_cd1400ccrwait(struct stlport *portp);
+static void     stl_cd1400enablerxtx(struct stlport *portp, int rx, int tx);
+static void     stl_cd1400startrxtx(struct stlport *portp, int rx, int tx);
+static void     stl_cd1400disableintrs(struct stlport *portp);
+static void     stl_cd1400sendbreak(struct stlport *portp, int len);
+static void     stl_cd1400flowctrl(struct stlport *portp, int state);
+static void     stl_cd1400sendflow(struct stlport *portp, int state);
+static void     stl_cd1400flush(struct stlport *portp);
+static int      stl_cd1400datastate(struct stlport *portp);
+static void     stl_cd1400eiointr(struct stlpanel *panelp, unsigned int iobase);
+static void     stl_cd1400echintr(struct stlpanel *panelp, unsigned int iobase);
+static void     stl_cd1400txisr(struct stlpanel *panelp, int ioaddr);
+static void     stl_cd1400rxisr(struct stlpanel *panelp, int ioaddr);
+static void     stl_cd1400mdmisr(struct stlpanel *panelp, int ioaddr);
+
+static inline int       stl_cd1400breakisr(struct stlport *portp, int ioaddr);
 
 /*
  *      SC26198 uart specific handling functions.
  */
-static void     stl_sc26198setreg(stlport_t *portp, int regnr, int value);
-static int      stl_sc26198getreg(stlport_t *portp, int regnr);
-static int      stl_sc26198updatereg(stlport_t *portp, int regnr, int value);
-static int      stl_sc26198getglobreg(stlport_t *portp, int regnr);
-static int      stl_sc26198panelinit(stlbrd_t *brdp, stlpanel_t *panelp);
-static void     stl_sc26198portinit(stlbrd_t *brdp, stlpanel_t *panelp, stlport_t *portp);
-static void     stl_sc26198setport(stlport_t *portp, struct termios *tiosp);
-static int      stl_sc26198getsignals(stlport_t *portp);
-static void     stl_sc26198setsignals(stlport_t *portp, int dtr, int rts);
-static void     stl_sc26198enablerxtx(stlport_t *portp, int rx, int tx);
-static void     stl_sc26198startrxtx(stlport_t *portp, int rx, int tx);
-static void     stl_sc26198disableintrs(stlport_t *portp);
-static void     stl_sc26198sendbreak(stlport_t *portp, int len);
-static void     stl_sc26198flowctrl(stlport_t *portp, int state);
-static void     stl_sc26198sendflow(stlport_t *portp, int state);
-static void     stl_sc26198flush(stlport_t *portp);
-static int      stl_sc26198datastate(stlport_t *portp);
-static void     stl_sc26198wait(stlport_t *portp);
-static void     stl_sc26198txunflow(stlport_t *portp, struct tty_struct *tty);
-static void     stl_sc26198intr(stlpanel_t *panelp, unsigned int iobase);
-static void     stl_sc26198txisr(stlport_t *port);
-static void     stl_sc26198rxisr(stlport_t *port, unsigned int iack);
-static void     stl_sc26198rxbadch(stlport_t *portp, unsigned char status, char ch);
-static void     stl_sc26198rxbadchars(stlport_t *portp);
-static void     stl_sc26198otherisr(stlport_t *port, unsigned int iack);
+static void     stl_sc26198setreg(struct stlport *portp, int regnr, int value);
+static int      stl_sc26198getreg(struct stlport *portp, int regnr);
+static int      stl_sc26198updatereg(struct stlport *portp, int regnr, int value);
+static int      stl_sc26198getglobreg(struct stlport *portp, int regnr);
+static int      stl_sc26198panelinit(struct stlbrd *brdp, struct stlpanel *panelp);
+static void     stl_sc26198portinit(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp);
+static void     stl_sc26198setport(struct stlport *portp, struct ktermios *tiosp);
+static int      stl_sc26198getsignals(struct stlport *portp);
+static void     stl_sc26198setsignals(struct stlport *portp, int dtr, int rts);
+static void     stl_sc26198enablerxtx(struct stlport *portp, int rx, int tx);
+static void     stl_sc26198startrxtx(struct stlport *portp, int rx, int tx);
+static void     stl_sc26198disableintrs(struct stlport *portp);
+static void     stl_sc26198sendbreak(struct stlport *portp, int len);
+static void     stl_sc26198flowctrl(struct stlport *portp, int state);
+static void     stl_sc26198sendflow(struct stlport *portp, int state);
+static void     stl_sc26198flush(struct stlport *portp);
+static int      stl_sc26198datastate(struct stlport *portp);
+static void     stl_sc26198wait(struct stlport *portp);
+static void     stl_sc26198txunflow(struct stlport *portp, struct tty_struct *tty);
+static void     stl_sc26198intr(struct stlpanel *panelp, unsigned int iobase);
+static void     stl_sc26198txisr(struct stlport *port);
+static void     stl_sc26198rxisr(struct stlport *port, unsigned int iack);
+static void     stl_sc26198rxbadch(struct stlport *portp, unsigned char status, char ch);
+static void     stl_sc26198rxbadchars(struct stlport *portp);
+static void     stl_sc26198otherisr(struct stlport *port, unsigned int iack);
 
 /*****************************************************************************/
 
@@ -577,20 +473,20 @@ static void	stl_sc26198otherisr(stlport_t *port, unsigned int iack);
  *      Generic UART support structure.
  */
 typedef struct uart {
-        int     (*panelinit)(stlbrd_t *brdp, stlpanel_t *panelp);
-        void    (*portinit)(stlbrd_t *brdp, stlpanel_t *panelp, stlport_t *portp);
-        void    (*setport)(stlport_t *portp, struct termios *tiosp);
-        int     (*getsignals)(stlport_t *portp);
-        void    (*setsignals)(stlport_t *portp, int dtr, int rts);
-        void    (*enablerxtx)(stlport_t *portp, int rx, int tx);
-        void    (*startrxtx)(stlport_t *portp, int rx, int tx);
-        void    (*disableintrs)(stlport_t *portp);
-        void    (*sendbreak)(stlport_t *portp, int len);
-        void    (*flowctrl)(stlport_t *portp, int state);
-        void    (*sendflow)(stlport_t *portp, int state);
-        void    (*flush)(stlport_t *portp);
-        int     (*datastate)(stlport_t *portp);
-        void    (*intr)(stlpanel_t *panelp, unsigned int iobase);
+        int     (*panelinit)(struct stlbrd *brdp, struct stlpanel *panelp);
+        void    (*portinit)(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp);
+        void    (*setport)(struct stlport *portp, struct ktermios *tiosp);
+        int     (*getsignals)(struct stlport *portp);
+        void    (*setsignals)(struct stlport *portp, int dtr, int rts);
+        void    (*enablerxtx)(struct stlport *portp, int rx, int tx);
+        void    (*startrxtx)(struct stlport *portp, int rx, int tx);
+        void    (*disableintrs)(struct stlport *portp);
+        void    (*sendbreak)(struct stlport *portp, int len);
+        void    (*flowctrl)(struct stlport *portp, int state);
+        void    (*sendflow)(struct stlport *portp, int state);
+        void    (*flush)(struct stlport *portp);
+        int     (*datastate)(struct stlport *portp);
+        void    (*intr)(struct stlpanel *panelp, unsigned int iobase);
 } uart_t;
 
 /*
@@ -712,184 +608,35 @@ static const struct file_operations	stl_fsiomem = {
         .ioctl          = stl_memioctl,
 };
 
-/*****************************************************************************/
-
 static struct class *stallion_class;
 
 /*
- *      Loadable module initialization stuff.
- */
-
-static int __init stallion_module_init(void)
-{
-        stl_init();
-        return 0;
-}
-
-/*****************************************************************************/
-
-static void __exit stallion_module_exit(void)
-{
-        stlbrd_t        *brdp;
-        stlpanel_t      *panelp;
-        stlport_t       *portp;
-        int             i, j, k;
-
-#ifdef DEBUG
-        printk("cleanup_module()\n");
-#endif
-
-        printk(KERN_INFO "Unloading %s: version %s\n", stl_drvtitle,
-                stl_drvversion);
-
-/*
- *      Free up all allocated resources used by the ports. This includes
- *      memory and interrupts. As part of this process we will also do
- *      a hangup on every open port - to try to flush out any processes
- *      hanging onto ports.
- */
-        i = tty_unregister_driver(stl_serial);
-        put_tty_driver(stl_serial);
-        if (i) {
-                printk("STALLION: failed to un-register tty driver, "
-                        "errno=%d\n", -i);
-                return;
-        }
-        for (i = 0; i < 4; i++)
-                class_device_destroy(stallion_class, MKDEV(STL_SIOMEMMAJOR, i));
-        if ((i = unregister_chrdev(STL_SIOMEMMAJOR, "staliomem")))
-                printk("STALLION: failed to un-register serial memory device, "
-                        "errno=%d\n", -i);
-        class_destroy(stallion_class);
-
-        for (i = 0; (i < stl_nrbrds); i++) {
-                if ((brdp = stl_brds[i]) == (stlbrd_t *) NULL)
-                        continue;
-
-                free_irq(brdp->irq, brdp);
-
-                for (j = 0; (j < STL_MAXPANELS); j++) {
-                        panelp = brdp->panels[j];
-                        if (panelp == (stlpanel_t *) NULL)
-                                continue;
-                        for (k = 0; (k < STL_PORTSPERPANEL); k++) {
-                                portp = panelp->ports[k];
-                                if (portp == (stlport_t *) NULL)
-                                        continue;
-                                if (portp->tty != (struct tty_struct *) NULL)
-                                        stl_hangup(portp->tty);
-                                kfree(portp->tx.buf);
-                                kfree(portp);
-                        }
-                        kfree(panelp);
-                }
-
-                release_region(brdp->ioaddr1, brdp->iosize1);
-                if (brdp->iosize2 > 0)
-                        release_region(brdp->ioaddr2, brdp->iosize2);
-
-                kfree(brdp);
-                stl_brds[i] = (stlbrd_t *) NULL;
-        }
-}
-
-module_init(stallion_module_init);
-module_exit(stallion_module_exit);
-
-/*****************************************************************************/
-
-/*
  *      Check for any arguments passed in on the module load command line.
  */
 
-static void stl_argbrds(void)
-{
-        stlconf_t       conf;
-        stlbrd_t        *brdp;
-        int             i;
-
-#ifdef DEBUG
-        printk("stl_argbrds()\n");
-#endif
-
-        for (i = stl_nrbrds; (i < stl_nargs); i++) {
-                memset(&conf, 0, sizeof(conf));
-                if (stl_parsebrd(&conf, stl_brdsp[i]) == 0)
-                        continue;
-                if ((brdp = stl_allocbrd()) == (stlbrd_t *) NULL)
-                        continue;
-                stl_nrbrds = i + 1;
-                brdp->brdnr = i;
-                brdp->brdtype = conf.brdtype;
-                brdp->ioaddr1 = conf.ioaddr1;
-                brdp->ioaddr2 = conf.ioaddr2;
-                brdp->irq = conf.irq;
-                brdp->irqtype = conf.irqtype;
-                stl_brdinit(brdp);
-        }
-}
-
-/*****************************************************************************/
-
-/*
- *      Convert an ascii string number into an unsigned long.
- */
-
-static unsigned long stl_atol(char *str)
-{
-        unsigned long   val;
-        int             base, c;
-        char            *sp;
-
-        val = 0;
-        sp = str;
-        if ((*sp == '0') && (*(sp+1) == 'x')) {
-                base = 16;
-                sp += 2;
-        } else if (*sp == '0') {
-                base = 8;
-                sp++;
-        } else {
-                base = 10;
-        }
-
-        for (; (*sp != 0); sp++) {
-                c = (*sp > '9') ? (TOLOWER(*sp) - 'a' + 10) : (*sp - '0');
-                if ((c < 0) || (c >= base)) {
-                        printk("STALLION: invalid argument %s\n", str);
-                        val = 0;
-                        break;
-                }
-                val = (val * base) + c;
-        }
-        return val;
-}
-
 /*****************************************************************************/
 
 /*
  *      Parse the supplied argument string, into the board conf struct.
  */
 
-static int stl_parsebrd(stlconf_t *confp, char **argp)
+static int __init stl_parsebrd(struct stlconf *confp, char **argp)
 {
         char    *sp;
-        int     i;
+        unsigned int i;
 
-#ifdef DEBUG
-        printk("stl_parsebrd(confp=%x,argp=%x)\n", (int) confp, (int) argp);
-#endif
+        pr_debug("stl_parsebrd(confp=%p,argp=%p)\n", confp, argp);
 
-        if ((argp[0] == (char *) NULL) || (*argp[0] == 0))
+        if ((argp[0] == NULL) || (*argp[0] == 0))
                 return 0;
 
-        for (sp = argp[0], i = 0; ((*sp != 0) && (i < 25)); sp++, i++)
-                *sp = TOLOWER(*sp);
+        for (sp = argp[0], i = 0; (*sp != 0) && (i < 25); sp++, i++)
+                *sp = tolower(*sp);
 
-        for (i = 0; i < ARRAY_SIZE(stl_brdstr); i++) {
+        for (i = 0; i < ARRAY_SIZE(stl_brdstr); i++)
                 if (strcmp(stl_brdstr[i].name, argp[0]) == 0)
                         break;
-        }
+
         if (i == ARRAY_SIZE(stl_brdstr)) {
                 printk("STALLION: unknown board name, %s?\n", argp[0]);
                 return 0;
@@ -898,16 +645,16 @@ static int stl_parsebrd(stlconf_t *confp, char **argp)
         confp->brdtype = stl_brdstr[i].type;
 
         i = 1;
-        if ((argp[i] != (char *) NULL) && (*argp[i] != 0))
-                confp->ioaddr1 = stl_atol(argp[i]);
+        if ((argp[i] != NULL) && (*argp[i] != 0))
+                confp->ioaddr1 = simple_strtoul(argp[i], NULL, 0);
         i++;
         if (confp->brdtype == BRD_ECH) {
-                if ((argp[i] != (char *) NULL) && (*argp[i] != 0))
-                        confp->ioaddr2 = stl_atol(argp[i]);
+                if ((argp[i] != NULL) && (*argp[i] != 0))
+                        confp->ioaddr2 = simple_strtoul(argp[i], NULL, 0);
                 i++;
         }
-        if ((argp[i] != (char *) NULL) && (*argp[i] != 0))
-                confp->irq = stl_atol(argp[i]);
+        if ((argp[i] != NULL) && (*argp[i] != 0))
+                confp->irq = simple_strtoul(argp[i], NULL, 0);
         return 1;
 }
 
@@ -917,14 +664,14 @@ static int stl_parsebrd(stlconf_t *confp, char **argp)
  *      Allocate a new board structure. Fill out the basic info in it.
  */
 
-static stlbrd_t *stl_allocbrd(void)
+static struct stlbrd *stl_allocbrd(void)
 {
-        stlbrd_t        *brdp;
+        struct stlbrd   *brdp;
 
-        brdp = kzalloc(sizeof(stlbrd_t), GFP_KERNEL);
+        brdp = kzalloc(sizeof(struct stlbrd), GFP_KERNEL);
         if (!brdp) {
                 printk("STALLION: failed to allocate memory (size=%Zd)\n",
-                        sizeof(stlbrd_t));
+                        sizeof(struct stlbrd));
                 return NULL;
         }
 
@@ -936,26 +683,23 @@ static stlbrd_t *stl_allocbrd(void)
 
 static int stl_open(struct tty_struct *tty, struct file *filp)
 {
-        stlport_t       *portp;
-        stlbrd_t        *brdp;
-        unsigned int    minordev;
-        int             brdnr, panelnr, portnr, rc;
-
-#ifdef DEBUG
-        printk("stl_open(tty=%x,filp=%x): device=%s\n", (int) tty,
-                (int) filp, tty->name);
-#endif
+        struct stlport  *portp;
+        struct stlbrd   *brdp;
+        unsigned int    minordev, brdnr, panelnr;
+        int             portnr, rc;
+
+        pr_debug("stl_open(tty=%p,filp=%p): device=%s\n", tty, filp, tty->name);
 
         minordev = tty->index;
         brdnr = MINOR2BRD(minordev);
         if (brdnr >= stl_nrbrds)
                 return -ENODEV;
         brdp = stl_brds[brdnr];
-        if (brdp == (stlbrd_t *) NULL)
+        if (brdp == NULL)
                 return -ENODEV;
         minordev = MINOR2PORT(minordev);
-        for (portnr = -1, panelnr = 0; (panelnr < STL_MAXPANELS); panelnr++) {
-                if (brdp->panels[panelnr] == (stlpanel_t *) NULL)
+        for (portnr = -1, panelnr = 0; panelnr < STL_MAXPANELS; panelnr++) {
+                if (brdp->panels[panelnr] == NULL)
                         break;
                 if (minordev < brdp->panels[panelnr]->nrports) {
                         portnr = minordev;
@@ -967,7 +711,7 @@ static int stl_open(struct tty_struct *tty, struct file *filp)
                 return -ENODEV;
 
         portp = brdp->panels[panelnr]->ports[portnr];
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return -ENODEV;
 
 /*
@@ -1013,10 +757,10 @@ static int stl_open(struct tty_struct *tty, struct file *filp)
  *      previous opens still in effect. If we are a normal serial device
  *      then also we might have to wait for carrier.
  */
-        if (!(filp->f_flags & O_NONBLOCK)) {
+        if (!(filp->f_flags & O_NONBLOCK))
                 if ((rc = stl_waitcarrier(portp, filp)) != 0)
                         return rc;
-        }
+
         portp->flags |= ASYNC_NORMAL_ACTIVE;
 
         return 0;
@@ -1029,14 +773,12 @@ static int stl_open(struct tty_struct *tty, struct file *filp)
  *      maybe because if we are clocal then we don't need to wait...
  */
 
-static int stl_waitcarrier(stlport_t *portp, struct file *filp)
+static int stl_waitcarrier(struct stlport *portp, struct file *filp)
 {
         unsigned long   flags;
         int             rc, doclocal;
 
-#ifdef DEBUG
-        printk("stl_waitcarrier(portp=%x,filp=%x)\n", (int) portp, (int) filp);
-#endif
+        pr_debug("stl_waitcarrier(portp=%p,filp=%p)\n", portp, filp);
 
         rc = 0;
         doclocal = 0;
@@ -1062,9 +804,8 @@ static int stl_waitcarrier(stlport_t *portp, struct file *filp)
                         break;
                 }
                 if (((portp->flags & ASYNC_CLOSING) == 0) &&
-                    (doclocal || (portp->sigs & TIOCM_CD))) {
+                    (doclocal || (portp->sigs & TIOCM_CD)))
                         break;
-                }
                 if (signal_pending(current)) {
                         rc = -ERESTARTSYS;
                         break;
@@ -1083,17 +824,61 @@ static int stl_waitcarrier(stlport_t *portp, struct file *filp)
 
 /*****************************************************************************/
 
+static void stl_flushbuffer(struct tty_struct *tty)
+{
+        struct stlport  *portp;
+
+        pr_debug("stl_flushbuffer(tty=%p)\n", tty);
+
+        if (tty == NULL)
+                return;
+        portp = tty->driver_data;
+        if (portp == NULL)
+                return;
+
+        stl_flush(portp);
+        tty_wakeup(tty);
+}
+
+/*****************************************************************************/
+
+static void stl_waituntilsent(struct tty_struct *tty, int timeout)
+{
+        struct stlport  *portp;
+        unsigned long   tend;
+
+        pr_debug("stl_waituntilsent(tty=%p,timeout=%d)\n", tty, timeout);
+
+        if (tty == NULL)
+                return;
+        portp = tty->driver_data;
+        if (portp == NULL)
+                return;
+
+        if (timeout == 0)
+                timeout = HZ;
+        tend = jiffies + timeout;
+
+        while (stl_datastate(portp)) {
+                if (signal_pending(current))
+                        break;
+                msleep_interruptible(20);
+                if (time_after_eq(jiffies, tend))
+                        break;
+        }
+}
+
+/*****************************************************************************/
+
 static void stl_close(struct tty_struct *tty, struct file *filp)
 {
-        stlport_t       *portp;
+        struct stlport  *portp;
         unsigned long   flags;
 
-#ifdef DEBUG
-        printk("stl_close(tty=%x,filp=%x)\n", (int) tty, (int) filp);
-#endif
+        pr_debug("stl_close(tty=%p,filp=%p)\n", tty, filp);
 
         portp = tty->driver_data;
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return;
 
         spin_lock_irqsave(&stallion_lock, flags);
@@ -1136,17 +921,17 @@ static void stl_close(struct tty_struct *tty, struct file *filp)
         stl_enablerxtx(portp, 0, 0);
         stl_flushbuffer(tty);
         portp->istate = 0;
-        if (portp->tx.buf != (char *) NULL) {
+        if (portp->tx.buf != NULL) {
                 kfree(portp->tx.buf);
-                portp->tx.buf = (char *) NULL;
-                portp->tx.head = (char *) NULL;
-                portp->tx.tail = (char *) NULL;
+                portp->tx.buf = NULL;
+                portp->tx.head = NULL;
+                portp->tx.tail = NULL;
         }
         set_bit(TTY_IO_ERROR, &tty->flags);
         tty_ldisc_flush(tty);
 
         tty->closing = 0;
-        portp->tty = (struct tty_struct *) NULL;
+        portp->tty = NULL;
 
         if (portp->openwaitcnt) {
                 if (portp->close_delay)
@@ -1167,20 +952,17 @@ static void stl_close(struct tty_struct *tty, struct file *filp)
 
 static int stl_write(struct tty_struct *tty, const unsigned char *buf, int count)
 {
-        stlport_t       *portp;
+        struct stlport  *portp;
         unsigned int    len, stlen;
         unsigned char   *chbuf;
         char            *head, *tail;
 
-#ifdef DEBUG
-        printk("stl_write(tty=%x,buf=%x,count=%d)\n",
-                (int) tty, (int) buf, count);
-#endif
+        pr_debug("stl_write(tty=%p,buf=%p,count=%d)\n", tty, buf, count);
 
         portp = tty->driver_data;
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return 0;
-        if (portp->tx.buf == (char *) NULL)
+        if (portp->tx.buf == NULL)
                 return 0;
 
 /*
@@ -1201,10 +983,10 @@ static int stl_write(struct tty_struct *tty, const unsigned char *buf, int count
                 stlen = len;
         }
 
-        len = MIN(len, count);
+        len = min(len, (unsigned int)count);
         count = 0;
         while (len > 0) {
-                stlen = MIN(len, stlen);
+                stlen = min(len, stlen);
                 memcpy(head, chbuf, stlen);
                 len -= stlen;
                 chbuf += stlen;
@@ -1227,20 +1009,18 @@ static int stl_write(struct tty_struct *tty, const unsigned char *buf, int count
 
 static void stl_putchar(struct tty_struct *tty, unsigned char ch)
 {
-        stlport_t       *portp;
+        struct stlport  *portp;
         unsigned int    len;
         char            *head, *tail;
 
-#ifdef DEBUG
-        printk("stl_putchar(tty=%x,ch=%x)\n", (int) tty, (int) ch);
-#endif
+        pr_debug("stl_putchar(tty=%p,ch=%x)\n", tty, ch);
 
-        if (tty == (struct tty_struct *) NULL)
+        if (tty == NULL)
                 return;
         portp = tty->driver_data;
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return;
-        if (portp->tx.buf == (char *) NULL)
+        if (portp->tx.buf == NULL)
                 return;
 
         head = portp->tx.head;
@@ -1267,18 +1047,16 @@ static void stl_putchar(struct tty_struct *tty, unsigned char ch)
 
 static void stl_flushchars(struct tty_struct *tty)
 {
-        stlport_t       *portp;
+        struct stlport  *portp;
 
-#ifdef DEBUG
-        printk("stl_flushchars(tty=%x)\n", (int) tty);
-#endif
+        pr_debug("stl_flushchars(tty=%p)\n", tty);
 
-        if (tty == (struct tty_struct *) NULL)
+        if (tty == NULL)
                 return;
         portp = tty->driver_data;
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return;
-        if (portp->tx.buf == (char *) NULL)
+        if (portp->tx.buf == NULL)
                 return;
 
         stl_startrxtx(portp, -1, 1);
@@ -1288,24 +1066,22 @@ static void stl_flushchars(struct tty_struct *tty)
 
 static int stl_writeroom(struct tty_struct *tty)
 {
-        stlport_t       *portp;
+        struct stlport  *portp;
         char            *head, *tail;
 
-#ifdef DEBUG
-        printk("stl_writeroom(tty=%x)\n", (int) tty);
-#endif
+        pr_debug("stl_writeroom(tty=%p)\n", tty);
 
-        if (tty == (struct tty_struct *) NULL)
+        if (tty == NULL)
                 return 0;
         portp = tty->driver_data;
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return 0;
-        if (portp->tx.buf == (char *) NULL)
+        if (portp->tx.buf == NULL)
                 return 0;
 
         head = portp->tx.head;
         tail = portp->tx.tail;
-        return ((head >= tail) ? (STL_TXBUFSIZE - (head - tail) - 1) : (tail - head - 1));
+        return (head >= tail) ? (STL_TXBUFSIZE - (head - tail) - 1) : (tail - head - 1);
 }
 
 /*****************************************************************************/
@@ -1321,20 +1097,18 @@ static int stl_writeroom(struct tty_struct *tty)
 
 static int stl_charsinbuffer(struct tty_struct *tty)
 {
-        stlport_t       *portp;
+        struct stlport  *portp;
         unsigned int    size;
         char            *head, *tail;
 
-#ifdef DEBUG
-        printk("stl_charsinbuffer(tty=%x)\n", (int) tty);
-#endif
+        pr_debug("stl_charsinbuffer(tty=%p)\n", tty);
 
-        if (tty == (struct tty_struct *) NULL)
+        if (tty == NULL)
                 return 0;
         portp = tty->driver_data;
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return 0;
-        if (portp->tx.buf == (char *) NULL)
+        if (portp->tx.buf == NULL)
                 return 0;
 
         head = portp->tx.head;
@@ -1351,14 +1125,12 @@ static int stl_charsinbuffer(struct tty_struct *tty)
  *      Generate the serial struct info.
  */
 
-static int stl_getserial(stlport_t *portp, struct serial_struct __user *sp)
+static int stl_getserial(struct stlport *portp, struct serial_struct __user *sp)
 {
         struct serial_struct    sio;
-        stlbrd_t                *brdp;
+        struct stlbrd           *brdp;
 
-#ifdef DEBUG
-        printk("stl_getserial(portp=%x,sp=%x)\n", (int) portp, (int) sp);
-#endif
+        pr_debug("stl_getserial(portp=%p,sp=%p)\n", portp, sp);
 
         memset(&sio, 0, sizeof(struct serial_struct));
         sio.line = portp->portnr;
@@ -1378,7 +1150,7 @@ static int stl_getserial(stlport_t *portp, struct serial_struct __user *sp)
         }
 
         brdp = stl_brds[portp->brdnr];
-        if (brdp != (stlbrd_t *) NULL)
+        if (brdp != NULL)
                 sio.irq = brdp->irq;
 
         return copy_to_user(sp, &sio, sizeof(struct serial_struct)) ? -EFAULT : 0;
@@ -1392,13 +1164,11 @@ static int stl_getserial(stlport_t *portp, struct serial_struct __user *sp)
  *      just quietly ignore any requests to change irq, etc.
  */
 
-static int stl_setserial(stlport_t *portp, struct serial_struct __user *sp)
+static int stl_setserial(struct stlport *portp, struct serial_struct __user *sp)
 {
         struct serial_struct    sio;
 
-#ifdef DEBUG
-        printk("stl_setserial(portp=%x,sp=%x)\n", (int) portp, (int) sp);
-#endif
+        pr_debug("stl_setserial(portp=%p,sp=%p)\n", portp, sp);
 
         if (copy_from_user(&sio, sp, sizeof(struct serial_struct)))
                 return -EFAULT;
@@ -1424,12 +1194,12 @@ static int stl_setserial(stlport_t *portp, struct serial_struct __user *sp)
 
 static int stl_tiocmget(struct tty_struct *tty, struct file *file)
 {
-        stlport_t       *portp;
+        struct stlport  *portp;
 
-        if (tty == (struct tty_struct *) NULL)
+        if (tty == NULL)
                 return -ENODEV;
         portp = tty->driver_data;
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return -ENODEV;
         if (tty->flags & (1 << TTY_IO_ERROR))
                 return -EIO;
@@ -1440,13 +1210,13 @@ static int stl_tiocmget(struct tty_struct *tty, struct file *file)
 static int stl_tiocmset(struct tty_struct *tty, struct file *file,
                         unsigned int set, unsigned int clear)
 {
-        stlport_t       *portp;
+        struct stlport  *portp;
         int rts = -1, dtr = -1;
 
-        if (tty == (struct tty_struct *) NULL)
+        if (tty == NULL)
                 return -ENODEV;
         portp = tty->driver_data;
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return -ENODEV;
         if (tty->flags & (1 << TTY_IO_ERROR))
                 return -EIO;
@@ -1466,27 +1236,24 @@ static int stl_tiocmset(struct tty_struct *tty, struct file *file,
 
 static int stl_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
 {
-        stlport_t       *portp;
+        struct stlport  *portp;
         unsigned int    ival;
         int             rc;
         void __user *argp = (void __user *)arg;
 
-#ifdef DEBUG
-        printk("stl_ioctl(tty=%x,file=%x,cmd=%x,arg=%x)\n",
-                (int) tty, (int) file, cmd, (int) arg);
-#endif
+        pr_debug("stl_ioctl(tty=%p,file=%p,cmd=%x,arg=%lx)\n", tty, file, cmd,
+                        arg);
 
-        if (tty == (struct tty_struct *) NULL)
+        if (tty == NULL)
                 return -ENODEV;
         portp = tty->driver_data;
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return -ENODEV;
 
         if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
-            (cmd != COM_GETPORTSTATS) && (cmd != COM_CLRPORTSTATS)) {
+            (cmd != COM_GETPORTSTATS) && (cmd != COM_CLRPORTSTATS))
                 if (tty->flags & (1 << TTY_IO_ERROR))
                         return -EIO;
-        }
 
         rc = 0;
 
@@ -1531,19 +1298,37 @@ static int stl_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd
 
 /*****************************************************************************/
 
-static void stl_settermios(struct tty_struct *tty, struct termios *old)
+/*
+ *      Start the transmitter again. Just turn TX interrupts back on.
+ */
+
+static void stl_start(struct tty_struct *tty)
 {
-        stlport_t       *portp;
-        struct termios  *tiosp;
+        struct stlport  *portp;
 
-#ifdef DEBUG
-        printk("stl_settermios(tty=%x,old=%x)\n", (int) tty, (int) old);
-#endif
+        pr_debug("stl_start(tty=%p)\n", tty);
 
-        if (tty == (struct tty_struct *) NULL)
+        if (tty == NULL)
                 return;
         portp = tty->driver_data;
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
+                return;
+        stl_startrxtx(portp, -1, 1);
+}
+
+/*****************************************************************************/
+
+static void stl_settermios(struct tty_struct *tty, struct ktermios *old)
+{
+        struct stlport  *portp;
+        struct ktermios *tiosp;
+
+        pr_debug("stl_settermios(tty=%p,old=%p)\n", tty, old);
+
+        if (tty == NULL)
+                return;
+        portp = tty->driver_data;
+        if (portp == NULL)
                 return;
 
         tiosp = tty->termios;
@@ -1571,16 +1356,14 @@ static void stl_settermios(struct tty_struct *tty, struct termios *old)
 
 static void stl_throttle(struct tty_struct *tty)
 {
-        stlport_t       *portp;
+        struct stlport  *portp;
 
-#ifdef DEBUG
-        printk("stl_throttle(tty=%x)\n", (int) tty);
-#endif
+        pr_debug("stl_throttle(tty=%p)\n", tty);
 
-        if (tty == (struct tty_struct *) NULL)
+        if (tty == NULL)
                 return;
         portp = tty->driver_data;
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return;
         stl_flowctrl(portp, 0);
 }
@@ -1593,16 +1376,14 @@ static void stl_throttle(struct tty_struct *tty)
 
 static void stl_unthrottle(struct tty_struct *tty)
 {
-        stlport_t       *portp;
+        struct stlport  *portp;
 
-#ifdef DEBUG
-        printk("stl_unthrottle(tty=%x)\n", (int) tty);
-#endif
+        pr_debug("stl_unthrottle(tty=%p)\n", tty);
 
-        if (tty == (struct tty_struct *) NULL)
+        if (tty == NULL)
                 return;
         portp = tty->driver_data;
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return;
         stl_flowctrl(portp, 1);
 }
@@ -1616,16 +1397,14 @@ static void stl_unthrottle(struct tty_struct *tty)
 
 static void stl_stop(struct tty_struct *tty)
 {
-        stlport_t       *portp;
+        struct stlport  *portp;
 
-#ifdef DEBUG
-        printk("stl_stop(tty=%x)\n", (int) tty);
-#endif
+        pr_debug("stl_stop(tty=%p)\n", tty);
 
-        if (tty == (struct tty_struct *) NULL)
+        if (tty == NULL)
                 return;
         portp = tty->driver_data;
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return;
         stl_startrxtx(portp, -1, 0);
 }
@@ -1633,28 +1412,6 @@ static void stl_stop(struct tty_struct *tty)
 /*****************************************************************************/
 
 /*
- *      Start the transmitter again. Just turn TX interrupts back on.
- */
-
-static void stl_start(struct tty_struct *tty)
-{
-        stlport_t       *portp;
-
-#ifdef DEBUG
-        printk("stl_start(tty=%x)\n", (int) tty);
-#endif
-
-        if (tty == (struct tty_struct *) NULL)
-                return;
-        portp = tty->driver_data;
-        if (portp == (stlport_t *) NULL)
-                return;
-        stl_startrxtx(portp, -1, 1);
-}
-
-/*****************************************************************************/
-
-/*
  *      Hangup this port. This is pretty much like closing the port, only
  *      a little more brutal. No waiting for data to drain. Shutdown the
  *      port and maybe drop signals.
@@ -1662,16 +1419,14 @@ static void stl_start(struct tty_struct *tty)
 
 static void stl_hangup(struct tty_struct *tty)
 {
-        stlport_t       *portp;
+        struct stlport  *portp;
 
-#ifdef DEBUG
-        printk("stl_hangup(tty=%x)\n", (int) tty);
-#endif
+        pr_debug("stl_hangup(tty=%p)\n", tty);
 
-        if (tty == (struct tty_struct *) NULL)
+        if (tty == NULL)
                 return;
         portp = tty->driver_data;
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return;
 
         portp->flags &= ~ASYNC_INITIALIZED;
@@ -1682,13 +1437,13 @@ static void stl_hangup(struct tty_struct *tty)
         stl_flushbuffer(tty);
         portp->istate = 0;
         set_bit(TTY_IO_ERROR, &tty->flags);
-        if (portp->tx.buf != (char *) NULL) {
+        if (portp->tx.buf != NULL) {
                 kfree(portp->tx.buf);
-                portp->tx.buf = (char *) NULL;
-                portp->tx.head = (char *) NULL;
-                portp->tx.tail = (char *) NULL;
+                portp->tx.buf = NULL;
+                portp->tx.head = NULL;
+                portp->tx.tail = NULL;
         }
-        portp->tty = (struct tty_struct *) NULL;
+        portp->tty = NULL;
         portp->flags &= ~ASYNC_NORMAL_ACTIVE;
         portp->refcount = 0;
         wake_up_interruptible(&portp->open_wait);
@@ -1696,38 +1451,16 @@ static void stl_hangup(struct tty_struct *tty)
 
 /*****************************************************************************/
 
-static void stl_flushbuffer(struct tty_struct *tty)
-{
-        stlport_t       *portp;
-
-#ifdef DEBUG
-        printk("stl_flushbuffer(tty=%x)\n", (int) tty);
-#endif
-
-        if (tty == (struct tty_struct *) NULL)
-                return;
-        portp = tty->driver_data;
-        if (portp == (stlport_t *) NULL)
-                return;
-
-        stl_flush(portp);
-        tty_wakeup(tty);
-}
-
-/*****************************************************************************/
-
 static void stl_breakctl(struct tty_struct *tty, int state)
 {
-        stlport_t       *portp;
+        struct stlport  *portp;
 
-#ifdef DEBUG
-        printk("stl_breakctl(tty=%x,state=%d)\n", (int) tty, state);
-#endif
+        pr_debug("stl_breakctl(tty=%p,state=%d)\n", tty, state);
 
-        if (tty == (struct tty_struct *) NULL)
+        if (tty == NULL)
                 return;
         portp = tty->driver_data;
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return;
 
         stl_sendbreak(portp, ((state == -1) ? 1 : 2));
@@ -1735,48 +1468,16 @@ static void stl_breakctl(struct tty_struct *tty, int state)
 
 /*****************************************************************************/
 
-static void stl_waituntilsent(struct tty_struct *tty, int timeout)
-{
-        stlport_t       *portp;
-        unsigned long   tend;
-
-#ifdef DEBUG
-        printk("stl_waituntilsent(tty=%x,timeout=%d)\n", (int) tty, timeout);
-#endif
-
-        if (tty == (struct tty_struct *) NULL)
-                return;
-        portp = tty->driver_data;
-        if (portp == (stlport_t *) NULL)
-                return;
-
-        if (timeout == 0)
-                timeout = HZ;
-        tend = jiffies + timeout;
-
-        while (stl_datastate(portp)) {
-                if (signal_pending(current))
-                        break;
-                msleep_interruptible(20);
-                if (time_after_eq(jiffies, tend))
-                        break;
-        }
-}
-
-/*****************************************************************************/
-
 static void stl_sendxchar(struct tty_struct *tty, char ch)
 {
-        stlport_t       *portp;
+        struct stlport  *portp;
 
-#ifdef DEBUG
-        printk("stl_sendxchar(tty=%x,ch=%x)\n", (int) tty, ch);
-#endif
+        pr_debug("stl_sendxchar(tty=%p,ch=%x)\n", tty, ch);
 
-        if (tty == (struct tty_struct *) NULL)
+        if (tty == NULL)
                 return;
         portp = tty->driver_data;
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return;
 
         if (ch == STOP_CHAR(tty))
@@ -1797,7 +1498,7 @@ static void stl_sendxchar(struct tty_struct *tty, char ch)
  *      short then padded with spaces).
  */
 
-static int stl_portinfo(stlport_t *portp, int portnr, char *pos)
+static int stl_portinfo(struct stlport *portp, int portnr, char *pos)
 {
         char    *sp;
         int     sigs, cnt;
@@ -1826,7 +1527,7 @@ static int stl_portinfo(stlport_t *portp, int portnr, char *pos)
         *sp = ' ';
         sp += cnt;
 
-        for (cnt = (sp - pos); (cnt < (MAXLINE - 1)); cnt++)
+        for (cnt = sp - pos; cnt < (MAXLINE - 1); cnt++)
                 *sp++ = ' ';
         if (cnt >= MAXLINE)
                 pos[(MAXLINE - 2)] = '+';
@@ -1843,18 +1544,15 @@ static int stl_portinfo(stlport_t *portp, int portnr, char *pos)
 
 static int stl_readproc(char *page, char **start, off_t off, int count, int *eof, void *data)
 {
-        stlbrd_t        *brdp;
-        stlpanel_t      *panelp;
-        stlport_t       *portp;
-        int             brdnr, panelnr, portnr, totalport;
-        int             curoff, maxoff;
+        struct stlbrd   *brdp;
+        struct stlpanel *panelp;
+        struct stlport  *portp;
+        unsigned int    brdnr, panelnr, portnr;
+        int             totalport, curoff, maxoff;
         char            *pos;
 
-#ifdef DEBUG
-        printk("stl_readproc(page=%x,start=%x,off=%x,count=%d,eof=%x,"
-                "data=%x\n", (int) page, (int) start, (int) off, count,
-                (int) eof, (int) data);
-#endif
+        pr_debug("stl_readproc(page=%p,start=%p,off=%lx,count=%d,eof=%p,"
+                "data=%p\n", page, start, off, count, eof, data);
 
         pos = page;
         totalport = 0;
@@ -1873,9 +1571,9 @@ static int stl_readproc(char *page, char **start, off_t off, int count, int *eof
  *      We scan through for each board, panel and port. The offset is
  *      calculated on the fly, and irrelevant ports are skipped.
  */
-        for (brdnr = 0; (brdnr < stl_nrbrds); brdnr++) {
+        for (brdnr = 0; brdnr < stl_nrbrds; brdnr++) {
                 brdp = stl_brds[brdnr];
-                if (brdp == (stlbrd_t *) NULL)
+                if (brdp == NULL)
                         continue;
                 if (brdp->state == 0)
                         continue;
@@ -1887,9 +1585,9 @@ static int stl_readproc(char *page, char **start, off_t off, int count, int *eof
                 }
 
                 totalport = brdnr * STL_MAXPORTS;
-                for (panelnr = 0; (panelnr < brdp->nrpanels); panelnr++) {
+                for (panelnr = 0; panelnr < brdp->nrpanels; panelnr++) {
                         panelp = brdp->panels[panelnr];
-                        if (panelp == (stlpanel_t *) NULL)
+                        if (panelp == NULL)
                                 continue;
 
                         maxoff = curoff + (panelp->nrports * MAXLINE);
@@ -1899,10 +1597,10 @@ static int stl_readproc(char *page, char **start, off_t off, int count, int *eof
                                 continue;
                         }
 
-                        for (portnr = 0; (portnr < panelp->nrports); portnr++,
+                        for (portnr = 0; portnr < panelp->nrports; portnr++,
                             totalport++) {
                                 portp = panelp->ports[portnr];
-                                if (portp == (stlport_t *) NULL)
+                                if (portp == NULL)
                                         continue;
                                 if (off >= (curoff += MAXLINE))
                                         continue;
@@ -1917,7 +1615,7 @@ static int stl_readproc(char *page, char **start, off_t off, int count, int *eof
 
 stl_readdone:
         *start = page;
-        return (pos - page);
+        return pos - page;
 }
 
 /*****************************************************************************/
@@ -1927,14 +1625,11 @@ stl_readdone:
  *      calls off to the approrpriate board interrupt handlers.
  */
 
-static irqreturn_t stl_intr(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t stl_intr(int irq, void *dev_id)
 {
-        stlbrd_t        *brdp = (stlbrd_t *) dev_id;
+        struct stlbrd *brdp = dev_id;
 
-#ifdef DEBUG
-        printk("stl_intr(brdp=%x,irq=%d,regs=%x)\n", (int) brdp, irq,
-            (int) regs);
-#endif
+        pr_debug("stl_intr(brdp=%p,irq=%d)\n", brdp, irq);
 
         return IRQ_RETVAL((* brdp->isr)(brdp));
 }
@@ -1945,9 +1640,9 @@ static irqreturn_t stl_intr(int irq, void *dev_id, struct pt_regs *regs)
  *      Interrupt service routine for EasyIO board types.
  */
 
-static int stl_eiointr(stlbrd_t *brdp)
+static int stl_eiointr(struct stlbrd *brdp)
 {
-        stlpanel_t      *panelp;
+        struct stlpanel *panelp;
         unsigned int    iobase;
         int             handled = 0;
 
@@ -1968,18 +1663,17 @@ static int stl_eiointr(stlbrd_t *brdp)
  *      Interrupt service routine for ECH-AT board types.
  */
 
-static int stl_echatintr(stlbrd_t *brdp)
+static int stl_echatintr(struct stlbrd *brdp)
 {
-        stlpanel_t      *panelp;
-        unsigned int    ioaddr;
-        int             bnknr;
+        struct stlpanel *panelp;
+        unsigned int    ioaddr, bnknr;
         int             handled = 0;
 
         outb((brdp->ioctrlval | ECH_BRDENABLE), brdp->ioctrl);
 
         while (inb(brdp->iostatus) & ECH_INTRPEND) {
                 handled = 1;
-                for (bnknr = 0; (bnknr < brdp->nrbnks); bnknr++) {
+                for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) {
                         ioaddr = brdp->bnkstataddr[bnknr];
                         if (inb(ioaddr) & ECH_PNLINTRPEND) {
                                 panelp = brdp->bnk2panel[bnknr];
@@ -1999,16 +1693,15 @@ static int stl_echatintr(stlbrd_t *brdp)
  *      Interrupt service routine for ECH-MCA board types.
  */
 
-static int stl_echmcaintr(stlbrd_t *brdp)
+static int stl_echmcaintr(struct stlbrd *brdp)
 {
-        stlpanel_t      *panelp;
-        unsigned int    ioaddr;
-        int             bnknr;
+        struct stlpanel *panelp;
+        unsigned int    ioaddr, bnknr;
         int             handled = 0;
 
         while (inb(brdp->iostatus) & ECH_INTRPEND) {
                 handled = 1;
-                for (bnknr = 0; (bnknr < brdp->nrbnks); bnknr++) {
+                for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) {
                         ioaddr = brdp->bnkstataddr[bnknr];
                         if (inb(ioaddr) & ECH_PNLINTRPEND) {
                                 panelp = brdp->bnk2panel[bnknr];
@@ -2025,16 +1718,15 @@ static int stl_echmcaintr(stlbrd_t *brdp)
  *      Interrupt service routine for ECH-PCI board types.
  */
 
-static int stl_echpciintr(stlbrd_t *brdp)
+static int stl_echpciintr(struct stlbrd *brdp)
 {
-        stlpanel_t      *panelp;
-        unsigned int    ioaddr;
-        int             bnknr, recheck;
+        struct stlpanel *panelp;
+        unsigned int    ioaddr, bnknr, recheck;
         int             handled = 0;
 
         while (1) {
                 recheck = 0;
-                for (bnknr = 0; (bnknr < brdp->nrbnks); bnknr++) {
+                for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) {
                         outb(brdp->bnkpageaddr[bnknr], brdp->ioctrl);
                         ioaddr = brdp->bnkstataddr[bnknr];
                         if (inb(ioaddr) & ECH_PNLINTRPEND) {
@@ -2056,16 +1748,15 @@ static int stl_echpciintr(stlbrd_t *brdp)
  *      Interrupt service routine for ECH-8/64-PCI board types.
  */
 
-static int stl_echpci64intr(stlbrd_t *brdp)
+static int stl_echpci64intr(struct stlbrd *brdp)
 {
-        stlpanel_t      *panelp;
-        unsigned int    ioaddr;
-        int             bnknr;
+        struct stlpanel *panelp;
+        unsigned int    ioaddr, bnknr;
         int             handled = 0;
 
         while (inb(brdp->ioctrl) & 0x1) {
                 handled = 1;
-                for (bnknr = 0; (bnknr < brdp->nrbnks); bnknr++) {
+                for (bnknr = 0; bnknr < brdp->nrbnks; bnknr++) {
                         ioaddr = brdp->bnkstataddr[bnknr];
                         if (inb(ioaddr) & ECH_PNLINTRPEND) {
                                 panelp = brdp->bnk2panel[bnknr];
@@ -2082,39 +1773,34 @@ static int stl_echpci64intr(stlbrd_t *brdp)
 /*
  *      Service an off-level request for some channel.
  */
-static void stl_offintr(void *private)
+static void stl_offintr(struct work_struct *work)
 {
-        stlport_t               *portp;
+        struct stlport          *portp = container_of(work, struct stlport, tqueue);
         struct tty_struct       *tty;
         unsigned int            oldsigs;
 
-        portp = private;
+        pr_debug("stl_offintr(portp=%p)\n", portp);
 
-#ifdef DEBUG
-        printk("stl_offintr(portp=%x)\n", (int) portp);
-#endif
-
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return;
 
         tty = portp->tty;
-        if (tty == (struct tty_struct *) NULL)
+        if (tty == NULL)
                 return;
 
         lock_kernel();
-        if (test_bit(ASYI_TXLOW, &portp->istate)) {
+        if (test_bit(ASYI_TXLOW, &portp->istate))
                 tty_wakeup(tty);
-        }
+
         if (test_bit(ASYI_DCDCHANGE, &portp->istate)) {
                 clear_bit(ASYI_DCDCHANGE, &portp->istate);
                 oldsigs = portp->sigs;
                 portp->sigs = stl_getsignals(portp);
                 if ((portp->sigs & TIOCM_CD) && ((oldsigs & TIOCM_CD) == 0))
                         wake_up_interruptible(&portp->open_wait);
-                if ((oldsigs & TIOCM_CD) && ((portp->sigs & TIOCM_CD) == 0)) {
+                if ((oldsigs & TIOCM_CD) && ((portp->sigs & TIOCM_CD) == 0))
                         if (portp->flags & ASYNC_CHECK_CD)
                                 tty_hangup(tty);        /* FIXME: module removal race here - AKPM */
-                }
         }
         unlock_kernel();
 }
@@ -2125,14 +1811,13 @@ static void stl_offintr(void *private)
  *      Initialize all the ports on a panel.
  */
 
-static int __init stl_initports(stlbrd_t *brdp, stlpanel_t *panelp)
+static int __devinit stl_initports(struct stlbrd *brdp, struct stlpanel *panelp)
 {
-        stlport_t       *portp;
-        int             chipmask, i;
+        struct stlport *portp;
+        unsigned int i;
+        int chipmask;
 
-#ifdef DEBUG
-        printk("stl_initports(brdp=%x,panelp=%x)\n", (int) brdp, (int) panelp);
-#endif
+        pr_debug("stl_initports(brdp=%p,panelp=%p)\n", brdp, panelp);
 
         chipmask = stl_panelinit(brdp, panelp);
 
@@ -2140,11 +1825,11 @@ static int __init stl_initports(stlbrd_t *brdp, stlpanel_t *panelp)
  *      All UART's are initialized (if found!). Now go through and setup
  *      each ports data structures.
  */
-        for (i = 0; (i < panelp->nrports); i++) {
-                portp = kzalloc(sizeof(stlport_t), GFP_KERNEL);
+        for (i = 0; i < panelp->nrports; i++) {
+                portp = kzalloc(sizeof(struct stlport), GFP_KERNEL);
                 if (!portp) {
                         printk("STALLION: failed to allocate memory "
-                                "(size=%Zd)\n", sizeof(stlport_t));
+                                "(size=%Zd)\n", sizeof(struct stlport));
                         break;
                 }
 
@@ -2157,7 +1842,7 @@ static int __init stl_initports(stlbrd_t *brdp, stlpanel_t *panelp)
                 portp->baud_base = STL_BAUDBASE;
                 portp->close_delay = STL_CLOSEDELAY;
                 portp->closing_wait = 30 * HZ;
-                INIT_WORK(&portp->tqueue, stl_offintr, portp);
+                INIT_WORK(&portp->tqueue, stl_offintr);
                 init_waitqueue_head(&portp->open_wait);
                 init_waitqueue_head(&portp->close_wait);
                 portp->stats.brd = portp->brdnr;
@@ -2167,7 +1852,30 @@ static int __init stl_initports(stlbrd_t *brdp, stlpanel_t *panelp)
                 stl_portinit(brdp, panelp, portp);
         }
 
-        return(0);
+        return 0;
+}
+
+static void stl_cleanup_panels(struct stlbrd *brdp)
+{
+        struct stlpanel *panelp;
+        struct stlport *portp;
+        unsigned int j, k;
+
+        for (j = 0; j < STL_MAXPANELS; j++) {
+                panelp = brdp->panels[j];
+                if (panelp == NULL)
+                        continue;
+                for (k = 0; k < STL_PORTSPERPANEL; k++) {
+                        portp = panelp->ports[k];
+                        if (portp == NULL)
+                                continue;
+                        if (portp->tty != NULL)
+                                stl_hangup(portp->tty);
+                        kfree(portp->tx.buf);
+                        kfree(portp);
+                }
+                kfree(panelp);
+        }
 }
 
 /*****************************************************************************/
@@ -2176,16 +1884,14 @@ static int __init stl_initports(stlbrd_t *brdp, stlpanel_t *panelp)
  *      Try to find and initialize an EasyIO board.
  */
 
-static inline int stl_initeio(stlbrd_t *brdp)
+static int __devinit stl_initeio(struct stlbrd *brdp)
 {
-        stlpanel_t      *panelp;
+        struct stlpanel *panelp;
         unsigned int    status;
         char            *name;
-        int             rc;
+        int             retval;
 
-#ifdef DEBUG
-        printk("stl_initeio(brdp=%x)\n", (int) brdp);
-#endif
+        pr_debug("stl_initeio(brdp=%p)\n", brdp);
 
         brdp->ioctrl = brdp->ioaddr1 + 1;
         brdp->iostatus = brdp->ioaddr1 + 2;
@@ -2210,18 +1916,20 @@ static inline int stl_initeio(stlbrd_t *brdp)
                     (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
                         printk("STALLION: invalid irq=%d for brd=%d\n",
                                 brdp->irq, brdp->brdnr);
-                        return(-EINVAL);
+                        retval = -EINVAL;
+                        goto err;
                 }
                 outb((stl_vecmap[brdp->irq] | EIO_0WS |
                         ((brdp->irqtype) ? EIO_INTLEVEL : EIO_INTEDGE)),
                         brdp->ioctrl);
         }
 
+        retval = -EBUSY;
         if (!request_region(brdp->ioaddr1, brdp->iosize1, name)) {
                 printk(KERN_WARNING "STALLION: Warning, board %d I/O address "
                         "%x conflicts with another device\n", brdp->brdnr, 
                         brdp->ioaddr1);
-                return(-EBUSY);
+                goto err;
         }
         
         if (brdp->iosize2 > 0)
@@ -2232,8 +1940,7 @@ static inline int stl_initeio(stlbrd_t *brdp)
                         printk(KERN_WARNING "STALLION: Warning, also "
                                 "releasing board %d I/O address %x \n", 
                                 brdp->brdnr, brdp->ioaddr1);
-                        release_region(brdp->ioaddr1, brdp->iosize1);
-                        return(-EBUSY);
+                        goto err_rel1;
                 }
 
 /*
@@ -2242,6 +1949,7 @@ static inline int stl_initeio(stlbrd_t *brdp)
         brdp->clk = CD1400_CLK;
         brdp->isr = stl_eiointr;
 
+        retval = -ENODEV;
         switch (status & EIO_IDBITMASK) {
         case EIO_8PORTM:
                 brdp->clk = CD1400_CLK8M;
@@ -2265,11 +1973,11 @@ static inline int stl_initeio(stlbrd_t *brdp)
                         brdp->nrports = 16;
                         break;
                 default:
-                        return(-ENODEV);
+                        goto err_rel2;
                 }
                 break;
         default:
-                return(-ENODEV);
+                goto err_rel2;
         }
 
 /*
@@ -2277,11 +1985,12 @@ static inline int stl_initeio(stlbrd_t *brdp)
  *      can complete the setup.
  */
 
-        panelp = kzalloc(sizeof(stlpanel_t), GFP_KERNEL);
+        panelp = kzalloc(sizeof(struct stlpanel), GFP_KERNEL);
         if (!panelp) {
                 printk(KERN_WARNING "STALLION: failed to allocate memory "
-                        "(size=%Zd)\n", sizeof(stlpanel_t));
-                return -ENOMEM;
+                        "(size=%Zd)\n", sizeof(struct stlpanel));
+                retval = -ENOMEM;
+                goto err_rel2;
         }
 
         panelp->magic = STL_PANELMAGIC;
@@ -2291,10 +2000,10 @@ static inline int stl_initeio(stlbrd_t *brdp)
         panelp->iobase = brdp->ioaddr1;
         panelp->hwid = status;
         if ((status & EIO_IDBITMASK) == EIO_MK3) {
-                panelp->uartp = (void *) &stl_sc26198uart;
+                panelp->uartp = &stl_sc26198uart;
                 panelp->isr = stl_sc26198intr;
         } else {
-                panelp->uartp = (void *) &stl_cd1400uart;
+                panelp->uartp = &stl_cd1400uart;
                 panelp->isr = stl_cd1400eiointr;
         }
 
@@ -2305,11 +2014,20 @@ static inline int stl_initeio(stlbrd_t *brdp)
         if (request_irq(brdp->irq, stl_intr, IRQF_SHARED, name, brdp) != 0) {
                 printk("STALLION: failed to register interrupt "
                     "routine for %s irq=%d\n", name, brdp->irq);
-                rc = -ENODEV;
-        } else {
-                rc = 0;
+                retval = -ENODEV;
+                goto err_fr;
         }
-        return rc;
+
+        return 0;
+err_fr:
+        stl_cleanup_panels(brdp);
+err_rel2:
+        if (brdp->iosize2 > 0)
+                release_region(brdp->ioaddr2, brdp->iosize2);
+err_rel1:
+        release_region(brdp->ioaddr1, brdp->iosize1);
+err:
+        return retval;
 }
 
 /*****************************************************************************/
@@ -2319,16 +2037,14 @@ static inline int stl_initeio(stlbrd_t *brdp)
  *      dealing with all types of ECH board.
  */
 
-static inline int stl_initech(stlbrd_t *brdp)
+static int __devinit stl_initech(struct stlbrd *brdp)
 {
-        stlpanel_t      *panelp;
-        unsigned int    status, nxtid, ioaddr, conflict;
-        int             panelnr, banknr, i;
+        struct stlpanel *panelp;
+        unsigned int    status, nxtid, ioaddr, conflict, panelnr, banknr, i;
+        int             retval;
         char            *name;
 
-#ifdef DEBUG
-        printk("stl_initech(brdp=%x)\n", (int) brdp);
-#endif
+        pr_debug("stl_initech(brdp=%p)\n", brdp);
 
         status = 0;
         conflict = 0;
@@ -2345,20 +2061,23 @@ static inline int stl_initech(stlbrd_t *brdp)
                 brdp->ioctrl = brdp->ioaddr1 + 1;
                 brdp->iostatus = brdp->ioaddr1 + 1;
                 status = inb(brdp->iostatus);
-                if ((status & ECH_IDBITMASK) != ECH_ID)
-                        return(-ENODEV);
+                if ((status & ECH_IDBITMASK) != ECH_ID) {
+                        retval = -ENODEV;
+                        goto err;
+                }
                 if ((brdp->irq < 0) || (brdp->irq > 15) ||
                     (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
                         printk("STALLION: invalid irq=%d for brd=%d\n",
                                 brdp->irq, brdp->brdnr);
-                        return(-EINVAL);
+                        retval = -EINVAL;
+                        goto err;
                 }
                 status = ((brdp->ioaddr2 & ECH_ADDR2MASK) >> 1);
                 status |= (stl_vecmap[brdp->irq] << 1);
                 outb((status | ECH_BRDRESET), brdp->ioaddr1);
                 brdp->ioctrlval = ECH_INTENABLE |
                         ((brdp->irqtype) ? ECH_INTLEVEL : ECH_INTEDGE);
-                for (i = 0; (i < 10); i++)
+                for (i = 0; i < 10; i++)
                         outb((brdp->ioctrlval | ECH_BRDENABLE), brdp->ioctrl);
                 brdp->iosize1 = 2;
                 brdp->iosize2 = 32;
@@ -2371,13 +2090,16 @@ static inline int stl_initech(stlbrd_t *brdp)
                 brdp->ioctrl = brdp->ioaddr1 + 0x20;
                 brdp->iostatus = brdp->ioctrl;
                 status = inb(brdp->iostatus);
-                if ((status & ECH_IDBITMASK) != ECH_ID)
-                        return(-ENODEV);
+                if ((status & ECH_IDBITMASK) != ECH_ID) {
+                        retval = -ENODEV;
+                        goto err;
+                }
                 if ((brdp->irq < 0) || (brdp->irq > 15) ||
                     (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
                         printk("STALLION: invalid irq=%d for brd=%d\n",
                                 brdp->irq, brdp->brdnr);
-                        return(-EINVAL);
+                        retval = -EINVAL;
+                        goto err;
                 }
                 outb(ECHMC_BRDRESET, brdp->ioctrl);
                 outb(ECHMC_INTENABLE, brdp->ioctrl);
@@ -2404,19 +2126,20 @@ static inline int stl_initech(stlbrd_t *brdp)
 
         default:
                 printk("STALLION: unknown board type=%d\n", brdp->brdtype);
-                return(-EINVAL);
-                break;
+                retval = -EINVAL;
+                goto err;
         }
 
 /*
  *      Check boards for possible IO address conflicts and return fail status 
  *      if an IO conflict found.
  */
+        retval = -EBUSY;
         if (!request_region(brdp->ioaddr1, brdp->iosize1, name)) {
                 printk(KERN_WARNING "STALLION: Warning, board %d I/O address "
                         "%x conflicts with another device\n", brdp->brdnr, 
                         brdp->ioaddr1);
-                return(-EBUSY);
+                goto err;
         }
         
         if (brdp->iosize2 > 0)
@@ -2427,8 +2150,7 @@ static inline int stl_initech(stlbrd_t *brdp)
                         printk(KERN_WARNING "STALLION: Warning, also "
                                 "releasing board %d I/O address %x \n", 
                                 brdp->brdnr, brdp->ioaddr1);
-                        release_region(brdp->ioaddr1, brdp->iosize1);
-                        return(-EBUSY);
+                        goto err_rel1;
                 }
 
 /*
@@ -2443,19 +2165,19 @@ static inline int stl_initech(stlbrd_t *brdp)
         panelnr = 0;
         nxtid = 0;
 
-        for (i = 0; (i < STL_MAXPANELS); i++) {
+        for (i = 0; i < STL_MAXPANELS; i++) {
                 if (brdp->brdtype == BRD_ECHPCI) {
                         outb(nxtid, brdp->ioctrl);
                         ioaddr = brdp->ioaddr2;
                 }
                 status = inb(ioaddr + ECH_PNLSTATUS);
                 if ((status & ECH_PNLIDMASK) != nxtid)
-                        break;
-                panelp = kzalloc(sizeof(stlpanel_t), GFP_KERNEL);
+                        goto err_fr;
+                panelp = kzalloc(sizeof(struct stlpanel), GFP_KERNEL);
                 if (!panelp) {
                         printk("STALLION: failed to allocate memory "
-                                "(size=%Zd)\n", sizeof(stlpanel_t));
-                        break;
+                                "(size=%Zd)\n", sizeof(struct stlpanel));
+                        goto err_fr;
                 }
                 panelp->magic = STL_PANELMAGIC;
                 panelp->brdnr = brdp->brdnr;
@@ -2468,7 +2190,7 @@ static inline int stl_initech(stlbrd_t *brdp)
                 brdp->bnkstataddr[banknr++] = ioaddr + ECH_PNLSTATUS;
 
                 if (status & ECH_PNLXPID) {
-                        panelp->uartp = (void *) &stl_sc26198uart;
+                        panelp->uartp = &stl_sc26198uart;
                         panelp->isr = stl_sc26198intr;
                         if (status & ECH_PNL16PORT) {
                                 panelp->nrports = 16;
@@ -2476,11 +2198,10 @@ static inline int stl_initech(stlbrd_t *brdp)
                                 brdp->bnkpageaddr[banknr] = nxtid;
                                 brdp->bnkstataddr[banknr++] = ioaddr + 4 +
                                         ECH_PNLSTATUS;
-                        } else {
+                        } else
                                 panelp->nrports = 8;
-                        }
                 } else {
-                        panelp->uartp = (void *) &stl_cd1400uart;
+                        panelp->uartp = &stl_cd1400uart;
                         panelp->isr = stl_cd1400echintr;
                         if (status & ECH_PNL16PORT) {
                                 panelp->nrports = 16;
@@ -2503,7 +2224,7 @@ static inline int stl_initech(stlbrd_t *brdp)
                 brdp->panels[panelnr++] = panelp;
                 if ((brdp->brdtype != BRD_ECHPCI) &&
                     (ioaddr >= (brdp->ioaddr2 + brdp->iosize2)))
-                        break;
+                        goto err_fr;
         }
 
         brdp->nrpanels = panelnr;
@@ -2515,12 +2236,19 @@ static inline int stl_initech(stlbrd_t *brdp)
         if (request_irq(brdp->irq, stl_intr, IRQF_SHARED, name, brdp) != 0) {
                 printk("STALLION: failed to register interrupt "
                     "routine for %s irq=%d\n", name, brdp->irq);
-                i = -ENODEV;
-        } else {
-                i = 0;
+                retval = -ENODEV;
+                goto err_fr;
         }
 
-        return(i);
+        return 0;
+err_fr:
+        stl_cleanup_panels(brdp);
+        if (brdp->iosize2 > 0)
+                release_region(brdp->ioaddr2, brdp->iosize2);
+err_rel1:
+        release_region(brdp->ioaddr1, brdp->iosize1);
+err:
+        return retval;
 }
 
 /*****************************************************************************/
@@ -2532,48 +2260,61 @@ static inline int stl_initech(stlbrd_t *brdp)
  *      since the initial search and setup is very different.
  */
 
-static int __init stl_brdinit(stlbrd_t *brdp)
+static int __devinit stl_brdinit(struct stlbrd *brdp)
 {
-        int     i;
+        int i, retval;
 
-#ifdef DEBUG
-        printk("stl_brdinit(brdp=%x)\n", (int) brdp);
-#endif
+        pr_debug("stl_brdinit(brdp=%p)\n", brdp);
 
         switch (brdp->brdtype) {
         case BRD_EASYIO:
         case BRD_EASYIOPCI:
-                stl_initeio(brdp);
+                retval = stl_initeio(brdp);
+                if (retval)
+                        goto err;
                 break;
         case BRD_ECH:
         case BRD_ECHMC:
         case BRD_ECHPCI:
         case BRD_ECH64PCI:
-                stl_initech(brdp);
+                retval = stl_initech(brdp);
+                if (retval)
+                        goto err;
                 break;
         default:
                 printk("STALLION: board=%d is unknown board type=%d\n",
                         brdp->brdnr, brdp->brdtype);
-                return(ENODEV);
+                retval = -ENODEV;
+                goto err;
         }
 
-        stl_brds[brdp->brdnr] = brdp;
         if ((brdp->state & BRD_FOUND) == 0) {
                 printk("STALLION: %s board not found, board=%d io=%x irq=%d\n",
                         stl_brdnames[brdp->brdtype], brdp->brdnr,
                         brdp->ioaddr1, brdp->irq);
-                return(ENODEV);
+                goto err_free;
         }
 
-        for (i = 0; (i < STL_MAXPANELS); i++)
-                if (brdp->panels[i] != (stlpanel_t *) NULL)
+        for (i = 0; i < STL_MAXPANELS; i++)
+                if (brdp->panels[i] != NULL)
                         stl_initports(brdp, brdp->panels[i]);
 
         printk("STALLION: %s found, board=%d io=%x irq=%d "
                 "nrpanels=%d nrports=%d\n", stl_brdnames[brdp->brdtype],
                 brdp->brdnr, brdp->ioaddr1, brdp->irq, brdp->nrpanels,
                 brdp->nrports);
-        return(0);
+
+        return 0;
+err_free:
+        free_irq(brdp->irq, brdp);
+
+        stl_cleanup_panels(brdp);
+
+        release_region(brdp->ioaddr1, brdp->iosize1);
+        if (brdp->iosize2 > 0)
+                release_region(brdp->ioaddr2, brdp->iosize2);
+err:
+        return retval;
 }
 
 /*****************************************************************************/
@@ -2582,59 +2323,62 @@ static int __init stl_brdinit(stlbrd_t *brdp)
  *      Find the next available board number that is free.
  */
 
-static inline int stl_getbrdnr(void)
+static int __devinit stl_getbrdnr(void)
 {
-        int     i;
+        unsigned int i;
 
-        for (i = 0; (i < STL_MAXBRDS); i++) {
-                if (stl_brds[i] == (stlbrd_t *) NULL) {
+        for (i = 0; i < STL_MAXBRDS; i++)
+                if (stl_brds[i] == NULL) {
                         if (i >= stl_nrbrds)
                                 stl_nrbrds = i + 1;
-                        return(i);
+                        return i;
                 }
-        }
-        return(-1);
+
+        return -1;
 }
 
 /*****************************************************************************/
-
-#ifdef  CONFIG_PCI
-
 /*
  *      We have a Stallion board. Allocate a board structure and
  *      initialize it. Read its IO and IRQ resources from PCI
  *      configuration space.
  */
 
-static inline int stl_initpcibrd(int brdtype, struct pci_dev *devp)
+static int __devinit stl_pciprobe(struct pci_dev *pdev,
+                const struct pci_device_id *ent)
 {
-        stlbrd_t        *brdp;
-
-#ifdef DEBUG
-        printk("stl_initpcibrd(brdtype=%d,busnr=%x,devnr=%x)\n", brdtype,
-                devp->bus->number, devp->devfn);
-#endif
-
-        if (pci_enable_device(devp))
-                return(-EIO);
-        if ((brdp = stl_allocbrd()) == (stlbrd_t *) NULL)
-                return(-ENOMEM);
-        if ((brdp->brdnr = stl_getbrdnr()) < 0) {
-                printk("STALLION: too many boards found, "
+        struct stlbrd *brdp;
+        unsigned int i, brdtype = ent->driver_data;
+        int brdnr, retval = -ENODEV;
+
+        if ((pdev->class >> 8) == PCI_CLASS_STORAGE_IDE)
+                goto err;
+
+        dev_info(&pdev->dev, "please, report this to LKML: %x/%x/%x\n",
+                        pdev->vendor, pdev->device, pdev->class);
+
+        retval = pci_enable_device(pdev);
+        if (retval)
+                goto err;
+        brdp = stl_allocbrd();
+        if (brdp == NULL) {
+                retval = -ENOMEM;
+                goto err;
+        }
+        mutex_lock(&stl_brdslock);
+        brdnr = stl_getbrdnr();
+        if (brdnr < 0) {
+                dev_err(&pdev->dev, "too many boards found, "
                         "maximum supported %d\n", STL_MAXBRDS);
-                return(0);
+                mutex_unlock(&stl_brdslock);
+                goto err_fr;
         }
-        brdp->brdtype = brdtype;
+        brdp->brdnr = (unsigned int)brdnr;
+        stl_brds[brdp->brdnr] = brdp;
+        mutex_unlock(&stl_brdslock);
 
-/*
- *      Different Stallion boards use the BAR registers in different ways,
- *      so set up io addresses based on board type.
- */
-#ifdef DEBUG
-        printk("%s(%d): BAR[]=%x,%x,%x,%x IRQ=%x\n", __FILE__, __LINE__,
-                pci_resource_start(devp, 0), pci_resource_start(devp, 1),
-                pci_resource_start(devp, 2), pci_resource_start(devp, 3), devp->irq);
-#endif
+        brdp->brdtype = brdtype;
+        brdp->state |= STL_PROBED;
 
 /*
  *      We have all resources from the board, so let's setup the actual
@@ -2642,120 +2386,70 @@ static inline int stl_initpcibrd(int brdtype, struct pci_dev *devp)
  */
         switch (brdtype) {
         case BRD_ECHPCI:
-                brdp->ioaddr2 = pci_resource_start(devp, 0);
-                brdp->ioaddr1 = pci_resource_start(devp, 1);
+                brdp->ioaddr2 = pci_resource_start(pdev, 0);
+                brdp->ioaddr1 = pci_resource_start(pdev, 1);
                 break;
         case BRD_ECH64PCI:
-                brdp->ioaddr2 = pci_resource_start(devp, 2);
-                brdp->ioaddr1 = pci_resource_start(devp, 1);
+                brdp->ioaddr2 = pci_resource_start(pdev, 2);
+                brdp->ioaddr1 = pci_resource_start(pdev, 1);
                 break;
         case BRD_EASYIOPCI:
-                brdp->ioaddr1 = pci_resource_start(devp, 2);
-                brdp->ioaddr2 = pci_resource_start(devp, 1);
+                brdp->ioaddr1 = pci_resource_start(pdev, 2);
+                brdp->ioaddr2 = pci_resource_start(pdev, 1);
                 break;
         default:
-                printk("STALLION: unknown PCI board type=%d\n", brdtype);
+                dev_err(&pdev->dev, "unknown PCI board type=%u\n", brdtype);
                 break;
         }
 
-        brdp->irq = devp->irq;
-        stl_brdinit(brdp);
-
-        return(0);
-}
-
-/*****************************************************************************/
-
-/*
- *      Find all Stallion PCI boards that might be installed. Initialize each
- *      one as it is found.
- */
-
+        brdp->irq = pdev->irq;
+        retval = stl_brdinit(brdp);
+        if (retval)
+                goto err_null;
 
-static inline int stl_findpcibrds(void)
-{
-        struct pci_dev  *dev = NULL;
-        int             i, rc;
+        pci_set_drvdata(pdev, brdp);
 
-#ifdef DEBUG
-        printk("stl_findpcibrds()\n");
-#endif
+        for (i = 0; i < brdp->nrports; i++)
+                tty_register_device(stl_serial,
+                                brdp->brdnr * STL_MAXPORTS + i, &pdev->dev);
 
-        for (i = 0; (i < stl_nrpcibrds); i++)
-                while ((dev = pci_find_device(stl_pcibrds[i].vendid,
-                    stl_pcibrds[i].devid, dev))) {
-
-/*
- *                      Found a device on the PCI bus that has our vendor and
- *                      device ID. Need to check now that it is really us.
- */
-                        if ((dev->class >> 8) == PCI_CLASS_STORAGE_IDE)
-                                continue;
-
-                        rc = stl_initpcibrd(stl_pcibrds[i].brdtype, dev);
-                        if (rc)
-                                return(rc);
-                }
-
-        return(0);
+        return 0;
+err_null:
+        stl_brds[brdp->brdnr] = NULL;
+err_fr:
+        kfree(brdp);
+err:
+        return retval;
 }
 
-#endif
-
-/*****************************************************************************/
-
-/*
- *      Scan through all the boards in the configuration and see what we
- *      can find. Handle EIO and the ECH boards a little differently here
- *      since the initial search and setup is too different.
- */
-
-static inline int stl_initbrds(void)
+static void __devexit stl_pciremove(struct pci_dev *pdev)
 {
-        stlbrd_t        *brdp;
-        stlconf_t       *confp;
-        int             i;
+        struct stlbrd *brdp = pci_get_drvdata(pdev);
+        unsigned int i;
 
-#ifdef DEBUG
-        printk("stl_initbrds()\n");
-#endif
+        free_irq(brdp->irq, brdp);
 
-        if (stl_nrbrds > STL_MAXBRDS) {
-                printk("STALLION: too many boards in configuration table, "
-                        "truncating to %d\n", STL_MAXBRDS);
-                stl_nrbrds = STL_MAXBRDS;
-        }
+        stl_cleanup_panels(brdp);
 
-/*
- *      Firstly scan the list of static boards configured. Allocate
- *      resources and initialize the boards as found.
- */
-        for (i = 0; (i < stl_nrbrds); i++) {
-                confp = &stl_brdconf[i];
-                stl_parsebrd(confp, stl_brdsp[i]);
-                if ((brdp = stl_allocbrd()) == (stlbrd_t *) NULL)
-                        return(-ENOMEM);
-                brdp->brdnr = i;
-                brdp->brdtype = confp->brdtype;
-                brdp->ioaddr1 = confp->ioaddr1;
-                brdp->ioaddr2 = confp->ioaddr2;
-                brdp->irq = confp->irq;
-                brdp->irqtype = confp->irqtype;
-                stl_brdinit(brdp);
-        }
+        release_region(brdp->ioaddr1, brdp->iosize1);
+        if (brdp->iosize2 > 0)
+                release_region(brdp->ioaddr2, brdp->iosize2);
 
-/*
- *      Find any dynamically supported boards. That is via module load
- *      line options or auto-detected on the PCI bus.
- */
-        stl_argbrds();
-#ifdef CONFIG_PCI
-        stl_findpcibrds();
-#endif
+        for (i = 0; i < brdp->nrports; i++)
+                tty_unregister_device(stl_serial,
+                                brdp->brdnr * STL_MAXPORTS + i);
 
-        return(0);
+        stl_brds[brdp->brdnr] = NULL;
+        kfree(brdp);
 }
 
+static struct pci_driver stl_pcidriver = {
+        .name = "stallion",
+        .id_table = stl_pcibrds,
+        .probe = stl_pciprobe,
+        .remove = __devexit_p(stl_pciremove)
+};
+
 /*****************************************************************************/
 
 /*
@@ -2764,17 +2458,18 @@ static inline int stl_initbrds(void)
 
 static int stl_getbrdstats(combrd_t __user *bp)
 {
-        stlbrd_t        *brdp;
-        stlpanel_t      *panelp;
-        int             i;
+        combrd_t        stl_brdstats;
+        struct stlbrd   *brdp;
+        struct stlpanel *panelp;
+        unsigned int i;
 
         if (copy_from_user(&stl_brdstats, bp, sizeof(combrd_t)))
                 return -EFAULT;
         if (stl_brdstats.brd >= STL_MAXBRDS)
-                return(-ENODEV);
+                return -ENODEV;
         brdp = stl_brds[stl_brdstats.brd];
-        if (brdp == (stlbrd_t *) NULL)
-                return(-ENODEV);
+        if (brdp == NULL)
+                return -ENODEV;
 
         memset(&stl_brdstats, 0, sizeof(combrd_t));
         stl_brdstats.brd = brdp->brdnr;
@@ -2786,7 +2481,7 @@ static int stl_getbrdstats(combrd_t __user *bp)
         stl_brdstats.irq = brdp->irq;
         stl_brdstats.nrpanels = brdp->nrpanels;
         stl_brdstats.nrports = brdp->nrports;
-        for (i = 0; (i < brdp->nrpanels); i++) {
+        for (i = 0; i < brdp->nrpanels; i++) {
                 panelp = brdp->panels[i];
                 stl_brdstats.panels[i].panel = i;
                 stl_brdstats.panels[i].hwid = panelp->hwid;
@@ -2802,24 +2497,24 @@ static int stl_getbrdstats(combrd_t __user *bp)
  *      Resolve the referenced port number into a port struct pointer.
  */
 
-static stlport_t *stl_getport(int brdnr, int panelnr, int portnr)
+static struct stlport *stl_getport(int brdnr, int panelnr, int portnr)
 {
-        stlbrd_t        *brdp;
-        stlpanel_t      *panelp;
+        struct stlbrd   *brdp;
+        struct stlpanel *panelp;
 
-        if ((brdnr < 0) || (brdnr >= STL_MAXBRDS))
-                return((stlport_t *) NULL);
+        if (brdnr < 0 || brdnr >= STL_MAXBRDS)
+                return NULL;
         brdp = stl_brds[brdnr];
-        if (brdp == (stlbrd_t *) NULL)
-                return((stlport_t *) NULL);
-        if ((panelnr < 0) || (panelnr >= brdp->nrpanels))
-                return((stlport_t *) NULL);
+        if (brdp == NULL)
+                return NULL;
+        if (panelnr < 0 || (unsigned int)panelnr >= brdp->nrpanels)
+                return NULL;
         panelp = brdp->panels[panelnr];
-        if (panelp == (stlpanel_t *) NULL)
-                return((stlport_t *) NULL);
-        if ((portnr < 0) || (portnr >= panelp->nrports))
-                return((stlport_t *) NULL);
-        return(panelp->ports[portnr]);
+        if (panelp == NULL)
+                return NULL;
+        if (portnr < 0 || (unsigned int)portnr >= panelp->nrports)
+                return NULL;
+        return panelp->ports[portnr];
 }
 
 /*****************************************************************************/
@@ -2830,8 +2525,9 @@ static stlport_t *stl_getport(int brdnr, int panelnr, int portnr)
  *      what port to get stats for (used through board control device).
  */
 
-static int stl_getportstats(stlport_t *portp, comstats_t __user *cp)
+static int stl_getportstats(struct stlport *portp, comstats_t __user *cp)
 {
+        comstats_t      stl_comstats;
         unsigned char   *head, *tail;
         unsigned long   flags;
 
@@ -2840,8 +2536,8 @@ static int stl_getportstats(stlport_t *portp, comstats_t __user *cp)
                         return -EFAULT;
                 portp = stl_getport(stl_comstats.brd, stl_comstats.panel,
                         stl_comstats.port);
-                if (portp == (stlport_t *) NULL)
-                        return(-ENODEV);
+                if (portp == NULL)
+                        return -ENODEV;
         }
 
         portp->stats.state = portp->istate;
@@ -2856,25 +2552,24 @@ static int stl_getportstats(stlport_t *portp, comstats_t __user *cp)
         portp->stats.rxbuffered = 0;
 
         spin_lock_irqsave(&stallion_lock, flags);
-        if (portp->tty != (struct tty_struct *) NULL) {
+        if (portp->tty != NULL)
                 if (portp->tty->driver_data == portp) {
                         portp->stats.ttystate = portp->tty->flags;
                         /* No longer available as a statistic */
                         portp->stats.rxbuffered = 1; /*portp->tty->flip.count; */
-                        if (portp->tty->termios != (struct termios *) NULL) {
+                        if (portp->tty->termios != NULL) {
                                 portp->stats.cflags = portp->tty->termios->c_cflag;
                                 portp->stats.iflags = portp->tty->termios->c_iflag;
                                 portp->stats.oflags = portp->tty->termios->c_oflag;
                                 portp->stats.lflags = portp->tty->termios->c_lflag;
                         }
                 }
-        }
         spin_unlock_irqrestore(&stallion_lock, flags);
 
         head = portp->tx.head;
         tail = portp->tx.tail;
-        portp->stats.txbuffered = ((head >= tail) ? (head - tail) :
-                (STL_TXBUFSIZE - (tail - head)));
+        portp->stats.txbuffered = (head >= tail) ? (head - tail) :
+                (STL_TXBUFSIZE - (tail - head));
 
         portp->stats.signals = (unsigned long) stl_getsignals(portp);
 
@@ -2888,15 +2583,17 @@ static int stl_getportstats(stlport_t *portp, comstats_t __user *cp)
  *      Clear the port stats structure. We also return it zeroed out...
  */
 
-static int stl_clrportstats(stlport_t *portp, comstats_t __user *cp)
+static int stl_clrportstats(struct stlport *portp, comstats_t __user *cp)
 {
+        comstats_t      stl_comstats;
+
         if (!portp) {
                 if (copy_from_user(&stl_comstats, cp, sizeof(comstats_t)))
                         return -EFAULT;
                 portp = stl_getport(stl_comstats.brd, stl_comstats.panel,
                         stl_comstats.port);
-                if (portp == (stlport_t *) NULL)
-                        return(-ENODEV);
+                if (portp == NULL)
+                        return -ENODEV;
         }
 
         memset(&portp->stats, 0, sizeof(comstats_t));
@@ -2913,17 +2610,18 @@ static int stl_clrportstats(stlport_t *portp, comstats_t __user *cp)
  *      Return the entire driver ports structure to a user app.
  */
 
-static int stl_getportstruct(stlport_t __user *arg)
+static int stl_getportstruct(struct stlport __user *arg)
 {
-        stlport_t       *portp;
+        struct stlport  stl_dummyport;
+        struct stlport  *portp;
 
-        if (copy_from_user(&stl_dummyport, arg, sizeof(stlport_t)))
+        if (copy_from_user(&stl_dummyport, arg, sizeof(struct stlport)))
                 return -EFAULT;
         portp = stl_getport(stl_dummyport.brdnr, stl_dummyport.panelnr,
                  stl_dummyport.portnr);
         if (!portp)
                 return -ENODEV;
-        return copy_to_user(arg, portp, sizeof(stlport_t)) ? -EFAULT : 0;
+        return copy_to_user(arg, portp, sizeof(struct stlport)) ? -EFAULT : 0;
 }
 
 /*****************************************************************************/
@@ -2932,18 +2630,19 @@ static int stl_getportstruct(stlport_t __user *arg)
  *      Return the entire driver board structure to a user app.
  */
 
-static int stl_getbrdstruct(stlbrd_t __user *arg)
+static int stl_getbrdstruct(struct stlbrd __user *arg)
 {
-        stlbrd_t        *brdp;
+        struct stlbrd   stl_dummybrd;
+        struct stlbrd   *brdp;
 
-        if (copy_from_user(&stl_dummybrd, arg, sizeof(stlbrd_t)))
+        if (copy_from_user(&stl_dummybrd, arg, sizeof(struct stlbrd)))
                 return -EFAULT;
-        if ((stl_dummybrd.brdnr < 0) || (stl_dummybrd.brdnr >= STL_MAXBRDS))
+        if (stl_dummybrd.brdnr >= STL_MAXBRDS)
                 return -ENODEV;
         brdp = stl_brds[stl_dummybrd.brdnr];
         if (!brdp)
-                return(-ENODEV);
-        return copy_to_user(arg, brdp, sizeof(stlbrd_t)) ? -EFAULT : 0;
+                return -ENODEV;
+        return copy_to_user(arg, brdp, sizeof(struct stlbrd)) ? -EFAULT : 0;
 }
 
 /*****************************************************************************/
@@ -2959,14 +2658,11 @@ static int stl_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, uns
         int     brdnr, rc;
         void __user *argp = (void __user *)arg;
 
-#ifdef DEBUG
-        printk("stl_memioctl(ip=%x,fp=%x,cmd=%x,arg=%x)\n", (int) ip,
-                (int) fp, cmd, (int) arg);
-#endif
+        pr_debug("stl_memioctl(ip=%p,fp=%p,cmd=%x,arg=%lx)\n", ip, fp, cmd,arg);
 
         brdnr = iminor(ip);
         if (brdnr >= STL_MAXBRDS)
-                return(-ENODEV);
+                return -ENODEV;
         rc = 0;
 
         switch (cmd) {
@@ -2990,10 +2686,10 @@ static int stl_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, uns
                 break;
         }
 
-        return(rc);
+        return rc;
 }
 
-static struct tty_operations stl_ops = {
+static const struct tty_operations stl_ops = {
         .open = stl_open,
         .close = stl_close,
         .write = stl_write,
@@ -3018,55 +2714,6 @@ static struct tty_operations stl_ops = {
 };
 
 /*****************************************************************************/
-
-static int __init stl_init(void)
-{
-        int i;
-        printk(KERN_INFO "%s: version %s\n", stl_drvtitle, stl_drvversion);
-
-        spin_lock_init(&stallion_lock);
-        spin_lock_init(&brd_lock);
-
-        stl_initbrds();
-
-        stl_serial = alloc_tty_driver(STL_MAXBRDS * STL_MAXPORTS);
-        if (!stl_serial)
-                return -1;
-
-/*
- *      Set up a character driver for per board stuff. This is mainly used
- *      to do stats ioctls on the ports.
- */
-        if (register_chrdev(STL_SIOMEMMAJOR, "staliomem", &stl_fsiomem))
-                printk("STALLION: failed to register serial board device\n");
-
-        stallion_class = class_create(THIS_MODULE, "staliomem");
-        for (i = 0; i < 4; i++)
-                class_device_create(stallion_class, NULL,
-                                    MKDEV(STL_SIOMEMMAJOR, i), NULL,
-                                    "staliomem%d", i);
-
-        stl_serial->owner = THIS_MODULE;
-        stl_serial->driver_name = stl_drvname;
-        stl_serial->name = "ttyE";
-        stl_serial->major = STL_SERIALMAJOR;
-        stl_serial->minor_start = 0;
-        stl_serial->type = TTY_DRIVER_TYPE_SERIAL;
-        stl_serial->subtype = SERIAL_TYPE_NORMAL;
-        stl_serial->init_termios = stl_deftermios;
-        stl_serial->flags = TTY_DRIVER_REAL_RAW;
-        tty_set_operations(stl_serial, &stl_ops);
-
-        if (tty_register_driver(stl_serial)) {
-                put_tty_driver(stl_serial);
-                printk("STALLION: failed to register serial driver\n");
-                return -1;
-        }
-
-        return 0;
-}
-
-/*****************************************************************************/
 /*                       CD1400 HARDWARE FUNCTIONS                           */
 /*****************************************************************************/
 
@@ -3076,21 +2723,21 @@ static int __init stl_init(void)
  *      (Maybe should make this inline...)
  */
 
-static int stl_cd1400getreg(stlport_t *portp, int regnr)
+static int stl_cd1400getreg(struct stlport *portp, int regnr)
 {
         outb((regnr + portp->uartaddr), portp->ioaddr);
         return inb(portp->ioaddr + EREG_DATA);
 }
 
-static void stl_cd1400setreg(stlport_t *portp, int regnr, int value)
+static void stl_cd1400setreg(struct stlport *portp, int regnr, int value)
 {
-        outb((regnr + portp->uartaddr), portp->ioaddr);
+        outb(regnr + portp->uartaddr, portp->ioaddr);
         outb(value, portp->ioaddr + EREG_DATA);
 }
 
-static int stl_cd1400updatereg(stlport_t *portp, int regnr, int value)
+static int stl_cd1400updatereg(struct stlport *portp, int regnr, int value)
 {
-        outb((regnr + portp->uartaddr), portp->ioaddr);
+        outb(regnr + portp->uartaddr, portp->ioaddr);
         if (inb(portp->ioaddr + EREG_DATA) != value) {
                 outb(value, portp->ioaddr + EREG_DATA);
                 return 1;
@@ -3106,16 +2753,14 @@ static int stl_cd1400updatereg(stlport_t *portp, int regnr, int value)
  *      identical when dealing with ports.
  */
 
-static int stl_cd1400panelinit(stlbrd_t *brdp, stlpanel_t *panelp)
+static int stl_cd1400panelinit(struct stlbrd *brdp, struct stlpanel *panelp)
 {
         unsigned int    gfrcr;
         int             chipmask, i, j;
         int             nrchips, uartaddr, ioaddr;
         unsigned long   flags;
 
-#ifdef DEBUG
-        printk("stl_panelinit(brdp=%x,panelp=%x)\n", (int) brdp, (int) panelp);
-#endif
+        pr_debug("stl_panelinit(brdp=%p,panelp=%p)\n", brdp, panelp);
 
         spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(panelp->brdnr, panelp->pagenr);
@@ -3125,13 +2770,12 @@ static int stl_cd1400panelinit(stlbrd_t *brdp, stlpanel_t *panelp)
  */
         chipmask = 0;
         nrchips = panelp->nrports / CD1400_PORTS;
-        for (i = 0; (i < nrchips); i++) {
+        for (i = 0; i < nrchips; i++) {
                 if (brdp->brdtype == BRD_ECHPCI) {
                         outb((panelp->pagenr + (i >> 1)), brdp->ioctrl);
                         ioaddr = panelp->iobase;
-                } else {
+                } else
                         ioaddr = panelp->iobase + (EREG_BANKSIZE * (i >> 1));
-                }
                 uartaddr = (i & 0x01) ? 0x080 : 0;
                 outb((GFRCR + uartaddr), ioaddr);
                 outb(0, (ioaddr + EREG_DATA));
@@ -3139,10 +2783,10 @@ static int stl_cd1400panelinit(stlbrd_t *brdp, stlpanel_t *panelp)
                 outb(CCR_RESETFULL, (ioaddr + EREG_DATA));
                 outb(CCR_RESETFULL, (ioaddr + EREG_DATA));
                 outb((GFRCR + uartaddr), ioaddr);
-                for (j = 0; (j < CCR_MAXWAIT); j++) {
+                for (j = 0; j < CCR_MAXWAIT; j++)
                         if ((gfrcr = inb(ioaddr + EREG_DATA)) != 0)
                                 break;
-                }
+
                 if ((j >= CCR_MAXWAIT) || (gfrcr < 0x40) || (gfrcr > 0x60)) {
                         printk("STALLION: cd1400 not responding, "
                                 "brd=%d panel=%d chip=%d\n",
@@ -3165,16 +2809,14 @@ static int stl_cd1400panelinit(stlbrd_t *brdp, stlpanel_t *panelp)
  *      Initialize hardware specific port registers.
  */
 
-static void stl_cd1400portinit(stlbrd_t *brdp, stlpanel_t *panelp, stlport_t *portp)
+static void stl_cd1400portinit(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp)
 {
         unsigned long flags;
-#ifdef DEBUG
-        printk("stl_cd1400portinit(brdp=%x,panelp=%x,portp=%x)\n",
-                (int) brdp, (int) panelp, (int) portp);
-#endif
+        pr_debug("stl_cd1400portinit(brdp=%p,panelp=%p,portp=%p)\n", brdp,
+                        panelp, portp);
 
-        if ((brdp == (stlbrd_t *) NULL) || (panelp == (stlpanel_t *) NULL) ||
-            (portp == (stlport_t *) NULL))
+        if ((brdp == NULL) || (panelp == NULL) ||
+            (portp == NULL))
                 return;
 
         spin_lock_irqsave(&brd_lock, flags);
@@ -3198,15 +2840,13 @@ static void stl_cd1400portinit(stlbrd_t *brdp, stlpanel_t *panelp, stlport_t *po
  *      since it won't usually take too long to be ready.
  */
 
-static void stl_cd1400ccrwait(stlport_t *portp)
+static void stl_cd1400ccrwait(struct stlport *portp)
 {
         int     i;
 
-        for (i = 0; (i < CCR_MAXWAIT); i++) {
-                if (stl_cd1400getreg(portp, CCR) == 0) {
+        for (i = 0; i < CCR_MAXWAIT; i++)
+                if (stl_cd1400getreg(portp, CCR) == 0)
                         return;
-                }
-        }
 
         printk("STALLION: cd1400 not responding, port=%d panel=%d brd=%d\n",
                 portp->portnr, portp->panelnr, portp->brdnr);
@@ -3219,9 +2859,9 @@ static void stl_cd1400ccrwait(stlport_t *portp)
  *      settings.
  */
 
-static void stl_cd1400setport(stlport_t *portp, struct termios *tiosp)
+static void stl_cd1400setport(struct stlport *portp, struct ktermios *tiosp)
 {
-        stlbrd_t        *brdp;
+        struct stlbrd   *brdp;
         unsigned long   flags;
         unsigned int    clkdiv, baudrate;
         unsigned char   cor1, cor2, cor3;
@@ -3245,7 +2885,7 @@ static void stl_cd1400setport(stlport_t *portp, struct termios *tiosp)
         sreroff = 0;
 
         brdp = stl_brds[portp->brdnr];
-        if (brdp == (stlbrd_t *) NULL)
+        if (brdp == NULL)
                 return;
 
 /*
@@ -3342,8 +2982,8 @@ static void stl_cd1400setport(stlport_t *portp, struct termios *tiosp)
                 baudrate = STL_CD1400MAXBAUD;
 
         if (baudrate > 0) {
-                for (clk = 0; (clk < CD1400_NUMCLKS); clk++) {
-                        clkdiv = ((portp->clk / stl_cd1400clkdivs[clk]) / baudrate);
+                for (clk = 0; clk < CD1400_NUMCLKS; clk++) {
+                        clkdiv = (portp->clk / stl_cd1400clkdivs[clk]) / baudrate;
                         if (clkdiv < 0x100)
                                 break;
                 }
@@ -3358,9 +2998,8 @@ static void stl_cd1400setport(stlport_t *portp, struct termios *tiosp)
                 mcor2 |= MCOR2_DCD;
                 sreron |= SRER_MODEM;
                 portp->flags |= ASYNC_CHECK_CD;
-        } else {
+        } else
                 portp->flags &= ~ASYNC_CHECK_CD;
-        }
 
 /*
  *      Setup cd1400 enhanced modes if we can. In particular we want to
@@ -3385,18 +3024,16 @@ static void stl_cd1400setport(stlport_t *portp, struct termios *tiosp)
  *      them all up.
  */
 
-#ifdef DEBUG
-        printk("SETPORT: portnr=%d panelnr=%d brdnr=%d\n",
+        pr_debug("SETPORT: portnr=%d panelnr=%d brdnr=%d\n",
                 portp->portnr, portp->panelnr, portp->brdnr);
-        printk("    cor1=%x cor2=%x cor3=%x cor4=%x cor5=%x\n",
+        pr_debug("    cor1=%x cor2=%x cor3=%x cor4=%x cor5=%x\n",
                 cor1, cor2, cor3, cor4, cor5);
-        printk("    mcor1=%x mcor2=%x rtpr=%x sreron=%x sreroff=%x\n",
+        pr_debug("    mcor1=%x mcor2=%x rtpr=%x sreron=%x sreroff=%x\n",
                 mcor1, mcor2, rtpr, sreron, sreroff);
-        printk("    tcor=%x tbpr=%x rcor=%x rbpr=%x\n", clk, div, clk, div);
-        printk("    schr1=%x schr2=%x schr3=%x schr4=%x\n",
+        pr_debug("    tcor=%x tbpr=%x rcor=%x rbpr=%x\n", clk, div, clk, div);
+        pr_debug("    schr1=%x schr2=%x schr3=%x schr4=%x\n",
                 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP],
                 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP]);
-#endif
 
         spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
@@ -3444,15 +3081,13 @@ static void stl_cd1400setport(stlport_t *portp, struct termios *tiosp)
  *      Set the state of the DTR and RTS signals.
  */
 
-static void stl_cd1400setsignals(stlport_t *portp, int dtr, int rts)
+static void stl_cd1400setsignals(struct stlport *portp, int dtr, int rts)
 {
         unsigned char   msvr1, msvr2;
         unsigned long   flags;
 
-#ifdef DEBUG
-        printk("stl_cd1400setsignals(portp=%x,dtr=%d,rts=%d)\n",
-                (int) portp, dtr, rts);
-#endif
+        pr_debug("stl_cd1400setsignals(portp=%p,dtr=%d,rts=%d)\n",
+                        portp, dtr, rts);
 
         msvr1 = 0;
         msvr2 = 0;
@@ -3478,15 +3113,13 @@ static void stl_cd1400setsignals(stlport_t *portp, int dtr, int rts)
  *      Return the state of the signals.
  */
 
-static int stl_cd1400getsignals(stlport_t *portp)
+static int stl_cd1400getsignals(struct stlport *portp)
 {
         unsigned char   msvr1, msvr2;
         unsigned long   flags;
         int             sigs;
 
-#ifdef DEBUG
-        printk("stl_cd1400getsignals(portp=%x)\n", (int) portp);
-#endif
+        pr_debug("stl_cd1400getsignals(portp=%p)\n", portp);
 
         spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
@@ -3516,15 +3149,13 @@ static int stl_cd1400getsignals(stlport_t *portp)
  *      Enable/Disable the Transmitter and/or Receiver.
  */
 
-static void stl_cd1400enablerxtx(stlport_t *portp, int rx, int tx)
+static void stl_cd1400enablerxtx(struct stlport *portp, int rx, int tx)
 {
         unsigned char   ccr;
         unsigned long   flags;
 
-#ifdef DEBUG
-        printk("stl_cd1400enablerxtx(portp=%x,rx=%d,tx=%d)\n",
-                (int) portp, rx, tx);
-#endif
+        pr_debug("stl_cd1400enablerxtx(portp=%p,rx=%d,tx=%d)\n", portp, rx, tx);
+
         ccr = 0;
 
         if (tx == 0)
@@ -3552,15 +3183,12 @@ static void stl_cd1400enablerxtx(stlport_t *portp, int rx, int tx)
  *      Start/stop the Transmitter and/or Receiver.
  */
 
-static void stl_cd1400startrxtx(stlport_t *portp, int rx, int tx)
+static void stl_cd1400startrxtx(struct stlport *portp, int rx, int tx)
 {
         unsigned char   sreron, sreroff;
         unsigned long   flags;
 
-#ifdef DEBUG
-        printk("stl_cd1400startrxtx(portp=%x,rx=%d,tx=%d)\n",
-                (int) portp, rx, tx);
-#endif
+        pr_debug("stl_cd1400startrxtx(portp=%p,rx=%d,tx=%d)\n", portp, rx, tx);
 
         sreron = 0;
         sreroff = 0;
@@ -3592,13 +3220,12 @@ static void stl_cd1400startrxtx(stlport_t *portp, int rx, int tx)
  *      Disable all interrupts from this port.
  */
 
-static void stl_cd1400disableintrs(stlport_t *portp)
+static void stl_cd1400disableintrs(struct stlport *portp)
 {
         unsigned long   flags;
 
-#ifdef DEBUG
-        printk("stl_cd1400disableintrs(portp=%x)\n", (int) portp);
-#endif
+        pr_debug("stl_cd1400disableintrs(portp=%p)\n", portp);
+
         spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
@@ -3609,13 +3236,11 @@ static void stl_cd1400disableintrs(stlport_t *portp)
 
 /*****************************************************************************/
 
-static void stl_cd1400sendbreak(stlport_t *portp, int len)
+static void stl_cd1400sendbreak(struct stlport *portp, int len)
 {
         unsigned long   flags;
 
-#ifdef DEBUG
-        printk("stl_cd1400sendbreak(portp=%x,len=%d)\n", (int) portp, len);
-#endif
+        pr_debug("stl_cd1400sendbreak(portp=%p,len=%d)\n", portp, len);
 
         spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
@@ -3636,19 +3261,17 @@ static void stl_cd1400sendbreak(stlport_t *portp, int len)
  *      Take flow control actions...
  */
 
-static void stl_cd1400flowctrl(stlport_t *portp, int state)
+static void stl_cd1400flowctrl(struct stlport *portp, int state)
 {
         struct tty_struct       *tty;
         unsigned long           flags;
 
-#ifdef DEBUG
-        printk("stl_cd1400flowctrl(portp=%x,state=%x)\n", (int) portp, state);
-#endif
+        pr_debug("stl_cd1400flowctrl(portp=%p,state=%x)\n", portp, state);
 
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return;
         tty = portp->tty;
-        if (tty == (struct tty_struct *) NULL)
+        if (tty == NULL)
                 return;
 
         spin_lock_irqsave(&brd_lock, flags);
@@ -3700,19 +3323,17 @@ static void stl_cd1400flowctrl(stlport_t *portp, int state)
  *      Send a flow control character...
  */
 
-static void stl_cd1400sendflow(stlport_t *portp, int state)
+static void stl_cd1400sendflow(struct stlport *portp, int state)
 {
         struct tty_struct       *tty;
         unsigned long           flags;
 
-#ifdef DEBUG
-        printk("stl_cd1400sendflow(portp=%x,state=%x)\n", (int) portp, state);
-#endif
+        pr_debug("stl_cd1400sendflow(portp=%p,state=%x)\n", portp, state);
 
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return;
         tty = portp->tty;
-        if (tty == (struct tty_struct *) NULL)
+        if (tty == NULL)
                 return;
 
         spin_lock_irqsave(&brd_lock, flags);
@@ -3735,15 +3356,13 @@ static void stl_cd1400sendflow(stlport_t *portp, int state)
 
 /*****************************************************************************/
 
-static void stl_cd1400flush(stlport_t *portp)
+static void stl_cd1400flush(struct stlport *portp)
 {
         unsigned long   flags;
 
-#ifdef DEBUG
-        printk("stl_cd1400flush(portp=%x)\n", (int) portp);
-#endif
+        pr_debug("stl_cd1400flush(portp=%p)\n", portp);
 
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return;
 
         spin_lock_irqsave(&brd_lock, flags);
@@ -3766,13 +3385,11 @@ static void stl_cd1400flush(stlport_t *portp)
  *      maintains the busy port flag.
  */
 
-static int stl_cd1400datastate(stlport_t *portp)
+static int stl_cd1400datastate(struct stlport *portp)
 {
-#ifdef DEBUG
-        printk("stl_cd1400datastate(portp=%x)\n", (int) portp);
-#endif
+        pr_debug("stl_cd1400datastate(portp=%p)\n", portp);
 
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return 0;
 
         return test_bit(ASYI_TXBUSY, &portp->istate) ? 1 : 0;
@@ -3784,14 +3401,11 @@ static int stl_cd1400datastate(stlport_t *portp)
  *      Interrupt service routine for cd1400 EasyIO boards.
  */
 
-static void stl_cd1400eiointr(stlpanel_t *panelp, unsigned int iobase)
+static void stl_cd1400eiointr(struct stlpanel *panelp, unsigned int iobase)
 {
         unsigned char   svrtype;
 
-#ifdef DEBUG
-        printk("stl_cd1400eiointr(panelp=%x,iobase=%x)\n",
-                (int) panelp, iobase);
-#endif
+        pr_debug("stl_cd1400eiointr(panelp=%p,iobase=%x)\n", panelp, iobase);
 
         spin_lock(&brd_lock);
         outb(SVRR, iobase);
@@ -3817,14 +3431,11 @@ static void stl_cd1400eiointr(stlpanel_t *panelp, unsigned int iobase)
  *      Interrupt service routine for cd1400 panels.
  */
 
-static void stl_cd1400echintr(stlpanel_t *panelp, unsigned int iobase)
+static void stl_cd1400echintr(struct stlpanel *panelp, unsigned int iobase)
 {
         unsigned char   svrtype;
 
-#ifdef DEBUG
-        printk("stl_cd1400echintr(panelp=%x,iobase=%x)\n", (int) panelp,
-                iobase);
-#endif
+        pr_debug("stl_cd1400echintr(panelp=%p,iobase=%x)\n", panelp, iobase);
 
         outb(SVRR, iobase);
         svrtype = inb(iobase + EREG_DATA);
@@ -3846,7 +3457,7 @@ static void stl_cd1400echintr(stlpanel_t *panelp, unsigned int iobase)
  *      this is the only way to generate them on the cd1400.
  */
 
-static inline int stl_cd1400breakisr(stlport_t *portp, int ioaddr)
+static int stl_cd1400breakisr(struct stlport *portp, int ioaddr)
 {
         if (portp->brklen == 1) {
                 outb((COR2 + portp->uartaddr), ioaddr);
@@ -3888,16 +3499,14 @@ static inline int stl_cd1400breakisr(stlport_t *portp, int ioaddr)
  *      be NULL if the buffer has been freed.
  */
 
-static void stl_cd1400txisr(stlpanel_t *panelp, int ioaddr)
+static void stl_cd1400txisr(struct stlpanel *panelp, int ioaddr)
 {
-        stlport_t       *portp;
+        struct stlport  *portp;
         int             len, stlen;
         char            *head, *tail;
         unsigned char   ioack, srer;
 
-#ifdef DEBUG
-        printk("stl_cd1400txisr(panelp=%x,ioaddr=%x)\n", (int) panelp, ioaddr);
-#endif
+        pr_debug("stl_cd1400txisr(panelp=%p,ioaddr=%x)\n", panelp, ioaddr);
 
         ioack = inb(ioaddr + EREG_TXACK);
         if (((ioack & panelp->ackmask) != 0) ||
@@ -3936,9 +3545,9 @@ static void stl_cd1400txisr(stlpanel_t *panelp, int ioaddr)
                 }
                 outb(srer, (ioaddr + EREG_DATA));
         } else {
-                len = MIN(len, CD1400_TXFIFOSIZE);
+                len = min(len, CD1400_TXFIFOSIZE);
                 portp->stats.txtotal += len;
-                stlen = MIN(len, ((portp->tx.buf + STL_TXBUFSIZE) - tail));
+                stlen = min(len, ((portp->tx.buf + STL_TXBUFSIZE) - tail));
                 outb((TDR + portp->uartaddr), ioaddr);
                 outsb((ioaddr + EREG_DATA), tail, stlen);
                 len -= stlen;
@@ -3969,17 +3578,15 @@ stl_txalldone:
  *      shutdown a port not in user context. Need to handle this case.
  */
 
-static void stl_cd1400rxisr(stlpanel_t *panelp, int ioaddr)
+static void stl_cd1400rxisr(struct stlpanel *panelp, int ioaddr)
 {
-        stlport_t               *portp;
+        struct stlport          *portp;
         struct tty_struct       *tty;
         unsigned int            ioack, len, buflen;
         unsigned char           status;
         char                    ch;
 
-#ifdef DEBUG
-        printk("stl_cd1400rxisr(panelp=%x,ioaddr=%x)\n", (int) panelp, ioaddr);
-#endif
+        pr_debug("stl_cd1400rxisr(panelp=%p,ioaddr=%x)\n", panelp, ioaddr);
 
         ioack = inb(ioaddr + EREG_RXACK);
         if ((ioack & panelp->ackmask) != 0) {
@@ -3993,13 +3600,13 @@ static void stl_cd1400rxisr(stlpanel_t *panelp, int ioaddr)
                 outb((RDCR + portp->uartaddr), ioaddr);
                 len = inb(ioaddr + EREG_DATA);
                 if (tty == NULL || (buflen = tty_buffer_request_room(tty, len)) == 0) {
-                        len = MIN(len, sizeof(stl_unwanted));
+                        len = min(len, sizeof(stl_unwanted));
                         outb((RDSR + portp->uartaddr), ioaddr);
                         insb((ioaddr + EREG_DATA), &stl_unwanted[0], len);
                         portp->stats.rxlost += len;
                         portp->stats.rxtotal += len;
                 } else {
-                        len = MIN(len, buflen);
+                        len = min(len, buflen);
                         if (len > 0) {
                                 unsigned char *ptr;
                                 outb((RDSR + portp->uartaddr), ioaddr);
@@ -4036,18 +3643,16 @@ static void stl_cd1400rxisr(stlpanel_t *panelp, int ioaddr)
                                                 do_SAK(tty);
                                                 BRDENABLE(portp->brdnr, portp->pagenr);
                                         }
-                                } else if (status & ST_PARITY) {
+                                } else if (status & ST_PARITY)
                                         status = TTY_PARITY;
-                                } else if (status & ST_FRAMING) {
+                                else if (status & ST_FRAMING)
                                         status = TTY_FRAME;
-                                } else if(status & ST_OVERRUN) {
+                                else if(status & ST_OVERRUN)
                                         status = TTY_OVERRUN;
-                                } else {
+                                else
                                         status = 0;
-                                }
-                        } else {
+                        } else
                                 status = 0;
-                        }
                         tty_insert_flip_char(tty, ch, status);
                         tty_schedule_flip(tty);
                 }
@@ -4069,15 +3674,13 @@ stl_rxalldone:
  *      processing routine.
  */
 
-static void stl_cd1400mdmisr(stlpanel_t *panelp, int ioaddr)
+static void stl_cd1400mdmisr(struct stlpanel *panelp, int ioaddr)
 {
-        stlport_t       *portp;
+        struct stlport  *portp;
         unsigned int    ioack;
         unsigned char   misr;
 
-#ifdef DEBUG
-        printk("stl_cd1400mdmisr(panelp=%x)\n", (int) panelp);
-#endif
+        pr_debug("stl_cd1400mdmisr(panelp=%p)\n", panelp);
 
         ioack = inb(ioaddr + EREG_MDACK);
         if (((ioack & panelp->ackmask) != 0) ||
@@ -4109,19 +3712,19 @@ static void stl_cd1400mdmisr(stlpanel_t *panelp, int ioaddr)
  *      (Maybe should make this inline...)
  */
 
-static int stl_sc26198getreg(stlport_t *portp, int regnr)
+static int stl_sc26198getreg(struct stlport *portp, int regnr)
 {
         outb((regnr | portp->uartaddr), (portp->ioaddr + XP_ADDR));
         return inb(portp->ioaddr + XP_DATA);
 }
 
-static void stl_sc26198setreg(stlport_t *portp, int regnr, int value)
+static void stl_sc26198setreg(struct stlport *portp, int regnr, int value)
 {
         outb((regnr | portp->uartaddr), (portp->ioaddr + XP_ADDR));
         outb(value, (portp->ioaddr + XP_DATA));
 }
 
-static int stl_sc26198updatereg(stlport_t *portp, int regnr, int value)
+static int stl_sc26198updatereg(struct stlport *portp, int regnr, int value)
 {
         outb((regnr | portp->uartaddr), (portp->ioaddr + XP_ADDR));
         if (inb(portp->ioaddr + XP_DATA) != value) {
@@ -4137,14 +3740,14 @@ static int stl_sc26198updatereg(stlport_t *portp, int regnr, int value)
  *      Functions to get and set the sc26198 global registers.
  */
 
-static int stl_sc26198getglobreg(stlport_t *portp, int regnr)
+static int stl_sc26198getglobreg(struct stlport *portp, int regnr)
 {
         outb(regnr, (portp->ioaddr + XP_ADDR));
         return inb(portp->ioaddr + XP_DATA);
 }
 
 #if 0
-static void stl_sc26198setglobreg(stlport_t *portp, int regnr, int value)
+static void stl_sc26198setglobreg(struct stlport *portp, int regnr, int value)
 {
         outb(regnr, (portp->ioaddr + XP_ADDR));
         outb(value, (portp->ioaddr + XP_DATA));
@@ -4159,15 +3762,12 @@ static void stl_sc26198setglobreg(stlport_t *portp, int regnr, int value)
  *      identical when dealing with ports.
  */
 
-static int stl_sc26198panelinit(stlbrd_t *brdp, stlpanel_t *panelp)
+static int stl_sc26198panelinit(struct stlbrd *brdp, struct stlpanel *panelp)
 {
         int     chipmask, i;
         int     nrchips, ioaddr;
 
-#ifdef DEBUG
-        printk("stl_sc26198panelinit(brdp=%x,panelp=%x)\n",
-                (int) brdp, (int) panelp);
-#endif
+        pr_debug("stl_sc26198panelinit(brdp=%p,panelp=%p)\n", brdp, panelp);
 
         BRDENABLE(panelp->brdnr, panelp->pagenr);
 
@@ -4179,7 +3779,7 @@ static int stl_sc26198panelinit(stlbrd_t *brdp, stlpanel_t *panelp)
         if (brdp->brdtype == BRD_ECHPCI)
                 outb(panelp->pagenr, brdp->ioctrl);
 
-        for (i = 0; (i < nrchips); i++) {
+        for (i = 0; i < nrchips; i++) {
                 ioaddr = panelp->iobase + (i * 4); 
                 outb(SCCR, (ioaddr + XP_ADDR));
                 outb(CR_RESETALL, (ioaddr + XP_DATA));
@@ -4207,15 +3807,13 @@ static int stl_sc26198panelinit(stlbrd_t *brdp, stlpanel_t *panelp)
  *      Initialize hardware specific port registers.
  */
 
-static void stl_sc26198portinit(stlbrd_t *brdp, stlpanel_t *panelp, stlport_t *portp)
+static void stl_sc26198portinit(struct stlbrd *brdp, struct stlpanel *panelp, struct stlport *portp)
 {
-#ifdef DEBUG
-        printk("stl_sc26198portinit(brdp=%x,panelp=%x,portp=%x)\n",
-                (int) brdp, (int) panelp, (int) portp);
-#endif
+        pr_debug("stl_sc26198portinit(brdp=%p,panelp=%p,portp=%p)\n", brdp,
+                        panelp, portp);
 
-        if ((brdp == (stlbrd_t *) NULL) || (panelp == (stlpanel_t *) NULL) ||
-            (portp == (stlport_t *) NULL))
+        if ((brdp == NULL) || (panelp == NULL) ||
+            (portp == NULL))
                 return;
 
         portp->ioaddr = panelp->iobase + ((portp->portnr < 8) ? 0 : 4);
@@ -4235,9 +3833,9 @@ static void stl_sc26198portinit(stlbrd_t *brdp, stlpanel_t *panelp, stlport_t *p
  *      settings.
  */
 
-static void stl_sc26198setport(stlport_t *portp, struct termios *tiosp)
+static void stl_sc26198setport(struct stlport *portp, struct ktermios *tiosp)
 {
-        stlbrd_t        *brdp;
+        struct stlbrd   *brdp;
         unsigned long   flags;
         unsigned int    baudrate;
         unsigned char   mr0, mr1, mr2, clk;
@@ -4252,7 +3850,7 @@ static void stl_sc26198setport(stlport_t *portp, struct termios *tiosp)
         imroff = 0;
 
         brdp = stl_brds[portp->brdnr];
-        if (brdp == (stlbrd_t *) NULL)
+        if (brdp == NULL)
                 return;
 
 /*
@@ -4301,9 +3899,8 @@ static void stl_sc26198setport(stlport_t *portp, struct termios *tiosp)
                         mr1 |= (MR1_PARENB | MR1_PARODD);
                 else
                         mr1 |= (MR1_PARENB | MR1_PAREVEN);
-        } else {
+        } else
                 mr1 |= MR1_PARNONE;
-        }
 
         mr1 |= MR1_ERRBLOCK;
 
@@ -4343,12 +3940,10 @@ static void stl_sc26198setport(stlport_t *portp, struct termios *tiosp)
         if (baudrate > STL_SC26198MAXBAUD)
                 baudrate = STL_SC26198MAXBAUD;
 
-        if (baudrate > 0) {
-                for (clk = 0; (clk < SC26198_NRBAUDS); clk++) {
+        if (baudrate > 0)
+                for (clk = 0; clk < SC26198_NRBAUDS; clk++)
                         if (baudrate <= sc26198_baudtable[clk])
                                 break;
-                }
-        }
 
 /*
  *      Check what form of modem signaling is required and set it up.
@@ -4370,9 +3965,9 @@ static void stl_sc26198setport(stlport_t *portp, struct termios *tiosp)
         if (tiosp->c_iflag & IXON) {
                 mr0 |= MR0_SWFTX | MR0_SWFT;
                 imron |= IR_XONXOFF;
-        } else {
+        } else
                 imroff |= IR_XONXOFF;
-        }
+
         if (tiosp->c_iflag & IXOFF)
                 mr0 |= MR0_SWFRX;
 
@@ -4386,15 +3981,13 @@ static void stl_sc26198setport(stlport_t *portp, struct termios *tiosp)
  *      them all up.
  */
 
-#ifdef DEBUG
-        printk("SETPORT: portnr=%d panelnr=%d brdnr=%d\n",
+        pr_debug("SETPORT: portnr=%d panelnr=%d brdnr=%d\n",
                 portp->portnr, portp->panelnr, portp->brdnr);
-        printk("    mr0=%x mr1=%x mr2=%x clk=%x\n", mr0, mr1, mr2, clk);
-        printk("    iopr=%x imron=%x imroff=%x\n", iopr, imron, imroff);
-        printk("    schr1=%x schr2=%x schr3=%x schr4=%x\n",
+        pr_debug("    mr0=%x mr1=%x mr2=%x clk=%x\n", mr0, mr1, mr2, clk);
+        pr_debug("    iopr=%x imron=%x imroff=%x\n", iopr, imron, imroff);
+        pr_debug("    schr1=%x schr2=%x schr3=%x schr4=%x\n",
                 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP],
                 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP]);
-#endif
 
         spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
@@ -4432,15 +4025,13 @@ static void stl_sc26198setport(stlport_t *portp, struct termios *tiosp)
  *      Set the state of the DTR and RTS signals.
  */
 
-static void stl_sc26198setsignals(stlport_t *portp, int dtr, int rts)
+static void stl_sc26198setsignals(struct stlport *portp, int dtr, int rts)
 {
         unsigned char   iopioron, iopioroff;
         unsigned long   flags;
 
-#ifdef DEBUG
-        printk("stl_sc26198setsignals(portp=%x,dtr=%d,rts=%d)\n",
-                (int) portp, dtr, rts);
-#endif
+        pr_debug("stl_sc26198setsignals(portp=%p,dtr=%d,rts=%d)\n", portp,
+                        dtr, rts);
 
         iopioron = 0;
         iopioroff = 0;
@@ -4467,15 +4058,13 @@ static void stl_sc26198setsignals(stlport_t *portp, int dtr, int rts)
  *      Return the state of the signals.
  */
 
-static int stl_sc26198getsignals(stlport_t *portp)
+static int stl_sc26198getsignals(struct stlport *portp)
 {
         unsigned char   ipr;
         unsigned long   flags;
         int             sigs;
 
-#ifdef DEBUG
-        printk("stl_sc26198getsignals(portp=%x)\n", (int) portp);
-#endif
+        pr_debug("stl_sc26198getsignals(portp=%p)\n", portp);
 
         spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
@@ -4498,15 +4087,12 @@ static int stl_sc26198getsignals(stlport_t *portp)
  *      Enable/Disable the Transmitter and/or Receiver.
  */
 
-static void stl_sc26198enablerxtx(stlport_t *portp, int rx, int tx)
+static void stl_sc26198enablerxtx(struct stlport *portp, int rx, int tx)
 {
         unsigned char   ccr;
         unsigned long   flags;
 
-#ifdef DEBUG
-        printk("stl_sc26198enablerxtx(portp=%x,rx=%d,tx=%d)\n",
-                (int) portp, rx, tx);
-#endif
+        pr_debug("stl_sc26198enablerxtx(portp=%p,rx=%d,tx=%d)\n", portp, rx,tx);
 
         ccr = portp->crenable;
         if (tx == 0)
@@ -4532,15 +4118,12 @@ static void stl_sc26198enablerxtx(stlport_t *portp, int rx, int tx)
  *      Start/stop the Transmitter and/or Receiver.
  */
 
-static void stl_sc26198startrxtx(stlport_t *portp, int rx, int tx)
+static void stl_sc26198startrxtx(struct stlport *portp, int rx, int tx)
 {
         unsigned char   imr;
         unsigned long   flags;
 
-#ifdef DEBUG
-        printk("stl_sc26198startrxtx(portp=%x,rx=%d,tx=%d)\n",
-                (int) portp, rx, tx);
-#endif
+        pr_debug("stl_sc26198startrxtx(portp=%p,rx=%d,tx=%d)\n", portp, rx, tx);
 
         imr = portp->imr;
         if (tx == 0)
@@ -4568,13 +4151,11 @@ static void stl_sc26198startrxtx(stlport_t *portp, int rx, int tx)
  *      Disable all interrupts from this port.
  */
 
-static void stl_sc26198disableintrs(stlport_t *portp)
+static void stl_sc26198disableintrs(struct stlport *portp)
 {
         unsigned long   flags;
 
-#ifdef DEBUG
-        printk("stl_sc26198disableintrs(portp=%x)\n", (int) portp);
-#endif
+        pr_debug("stl_sc26198disableintrs(portp=%p)\n", portp);
 
         spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
@@ -4586,22 +4167,20 @@ static void stl_sc26198disableintrs(stlport_t *portp)
 
 /*****************************************************************************/
 
-static void stl_sc26198sendbreak(stlport_t *portp, int len)
+static void stl_sc26198sendbreak(struct stlport *portp, int len)
 {
         unsigned long   flags;
 
-#ifdef DEBUG
-        printk("stl_sc26198sendbreak(portp=%x,len=%d)\n", (int) portp, len);
-#endif
+        pr_debug("stl_sc26198sendbreak(portp=%p,len=%d)\n", portp, len);
 
         spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
         if (len == 1) {
                 stl_sc26198setreg(portp, SCCR, CR_TXSTARTBREAK);
                 portp->stats.txbreaks++;
-        } else {
+        } else
                 stl_sc26198setreg(portp, SCCR, CR_TXSTOPBREAK);
-        }
+
         BRDDISABLE(portp->brdnr);
         spin_unlock_irqrestore(&brd_lock, flags);
 }
@@ -4612,20 +4191,18 @@ static void stl_sc26198sendbreak(stlport_t *portp, int len)
  *      Take flow control actions...
  */
 
-static void stl_sc26198flowctrl(stlport_t *portp, int state)
+static void stl_sc26198flowctrl(struct stlport *portp, int state)
 {
         struct tty_struct       *tty;
         unsigned long           flags;
         unsigned char           mr0;
 
-#ifdef DEBUG
-        printk("stl_sc26198flowctrl(portp=%x,state=%x)\n", (int) portp, state);
-#endif
+        pr_debug("stl_sc26198flowctrl(portp=%p,state=%x)\n", portp, state);
 
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return;
         tty = portp->tty;
-        if (tty == (struct tty_struct *) NULL)
+        if (tty == NULL)
                 return;
 
         spin_lock_irqsave(&brd_lock, flags);
@@ -4683,20 +4260,18 @@ static void stl_sc26198flowctrl(stlport_t *portp, int state)
  *      Send a flow control character.
  */
 
-static void stl_sc26198sendflow(stlport_t *portp, int state)
+static void stl_sc26198sendflow(struct stlport *portp, int state)
 {
         struct tty_struct       *tty;
         unsigned long           flags;
         unsigned char           mr0;
 
-#ifdef DEBUG
-        printk("stl_sc26198sendflow(portp=%x,state=%x)\n", (int) portp, state);
-#endif
+        pr_debug("stl_sc26198sendflow(portp=%p,state=%x)\n", portp, state);
 
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return;
         tty = portp->tty;
-        if (tty == (struct tty_struct *) NULL)
+        if (tty == NULL)
                 return;
 
         spin_lock_irqsave(&brd_lock, flags);
@@ -4724,15 +4299,13 @@ static void stl_sc26198sendflow(stlport_t *portp, int state)
 
 /*****************************************************************************/
 
-static void stl_sc26198flush(stlport_t *portp)
+static void stl_sc26198flush(struct stlport *portp)
 {
         unsigned long   flags;
 
-#ifdef DEBUG
-        printk("stl_sc26198flush(portp=%x)\n", (int) portp);
-#endif
+        pr_debug("stl_sc26198flush(portp=%p)\n", portp);
 
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return;
 
         spin_lock_irqsave(&brd_lock, flags);
@@ -4754,16 +4327,14 @@ static void stl_sc26198flush(stlport_t *portp)
  *      check the port statusy register to be sure.
  */
 
-static int stl_sc26198datastate(stlport_t *portp)
+static int stl_sc26198datastate(struct stlport *portp)
 {
         unsigned long   flags;
         unsigned char   sr;
 
-#ifdef DEBUG
-        printk("stl_sc26198datastate(portp=%x)\n", (int) portp);
-#endif
+        pr_debug("stl_sc26198datastate(portp=%p)\n", portp);
 
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return 0;
         if (test_bit(ASYI_TXBUSY, &portp->istate))
                 return 1;
@@ -4784,18 +4355,16 @@ static int stl_sc26198datastate(stlport_t *portp)
  *      to process a command...
  */
 
-static void stl_sc26198wait(stlport_t *portp)
+static void stl_sc26198wait(struct stlport *portp)
 {
         int     i;
 
-#ifdef DEBUG
-        printk("stl_sc26198wait(portp=%x)\n", (int) portp);
-#endif
+        pr_debug("stl_sc26198wait(portp=%p)\n", portp);
 
-        if (portp == (stlport_t *) NULL)
+        if (portp == NULL)
                 return;
 
-        for (i = 0; (i < 20); i++)
+        for (i = 0; i < 20; i++)
                 stl_sc26198getglobreg(portp, TSTR);
 }
 
@@ -4807,7 +4376,7 @@ static void stl_sc26198wait(stlport_t *portp)
  *      automatic flow control modes of the sc26198.
  */
 
-static inline void stl_sc26198txunflow(stlport_t *portp, struct tty_struct *tty)
+static void stl_sc26198txunflow(struct stlport *portp, struct tty_struct *tty)
 {
         unsigned char   mr0;
 
@@ -4825,9 +4394,9 @@ static inline void stl_sc26198txunflow(stlport_t *portp, struct tty_struct *tty)
  *      Interrupt service routine for sc26198 panels.
  */
 
-static void stl_sc26198intr(stlpanel_t *panelp, unsigned int iobase)
+static void stl_sc26198intr(struct stlpanel *panelp, unsigned int iobase)
 {
-        stlport_t       *portp;
+        struct stlport  *portp;
         unsigned int    iack;
 
         spin_lock(&brd_lock);
@@ -4863,16 +4432,14 @@ static void stl_sc26198intr(stlpanel_t *panelp, unsigned int iobase)
  *      be NULL if the buffer has been freed.
  */
 
-static void stl_sc26198txisr(stlport_t *portp)
+static void stl_sc26198txisr(struct stlport *portp)
 {
         unsigned int    ioaddr;
         unsigned char   mr0;
         int             len, stlen;
         char            *head, *tail;
 
-#ifdef DEBUG
-        printk("stl_sc26198txisr(portp=%x)\n", (int) portp);
-#endif
+        pr_debug("stl_sc26198txisr(portp=%p)\n", portp);
 
         ioaddr = portp->ioaddr;
         head = portp->tx.head;
@@ -4897,9 +4464,9 @@ static void stl_sc26198txisr(stlport_t *portp)
                         outb(mr0, (ioaddr + XP_DATA));
                 }
         } else {
-                len = MIN(len, SC26198_TXFIFOSIZE);
+                len = min(len, SC26198_TXFIFOSIZE);
                 portp->stats.txtotal += len;
-                stlen = MIN(len, ((portp->tx.buf + STL_TXBUFSIZE) - tail));
+                stlen = min(len, ((portp->tx.buf + STL_TXBUFSIZE) - tail));
                 outb(GTXFIFO, (ioaddr + XP_ADDR));
                 outsb((ioaddr + XP_DATA), tail, stlen);
                 len -= stlen;
@@ -4926,14 +4493,12 @@ static void stl_sc26198txisr(stlport_t *portp)
  *      shutdown a port not in user context. Need to handle this case.
  */
 
-static void stl_sc26198rxisr(stlport_t *portp, unsigned int iack)
+static void stl_sc26198rxisr(struct stlport *portp, unsigned int iack)
 {
         struct tty_struct       *tty;
         unsigned int            len, buflen, ioaddr;
 
-#ifdef DEBUG
-        printk("stl_sc26198rxisr(portp=%x,iack=%x)\n", (int) portp, iack);
-#endif
+        pr_debug("stl_sc26198rxisr(portp=%p,iack=%x)\n", portp, iack);
 
         tty = portp->tty;
         ioaddr = portp->ioaddr;
@@ -4942,13 +4507,13 @@ static void stl_sc26198rxisr(stlport_t *portp, unsigned int iack)
 
         if ((iack & IVR_TYPEMASK) == IVR_RXDATA) {
                 if (tty == NULL || (buflen = tty_buffer_request_room(tty, len)) == 0) {
-                        len = MIN(len, sizeof(stl_unwanted));
+                        len = min(len, sizeof(stl_unwanted));
                         outb(GRXFIFO, (ioaddr + XP_ADDR));
                         insb((ioaddr + XP_DATA), &stl_unwanted[0], len);
                         portp->stats.rxlost += len;
                         portp->stats.rxtotal += len;
                 } else {
-                        len = MIN(len, buflen);
+                        len = min(len, buflen);
                         if (len > 0) {
                                 unsigned char *ptr;
                                 outb(GRXFIFO, (ioaddr + XP_ADDR));
@@ -4968,8 +4533,8 @@ static void stl_sc26198rxisr(stlport_t *portp, unsigned int iack)
  *      flow control modes of the sc26198.
  */
         if (test_bit(ASYI_TXFLOWED, &portp->istate)) {
-                if ((tty != (struct tty_struct *) NULL) &&
-                    (tty->termios != (struct termios *) NULL) &&
+                if ((tty != NULL) &&
+                    (tty->termios != NULL) &&
                     (tty->termios->c_iflag & IXANY)) {
                         stl_sc26198txunflow(portp, tty);
                 }
@@ -4982,7 +4547,7 @@ static void stl_sc26198rxisr(stlport_t *portp, unsigned int iack)
  *      Process an RX bad character.
  */
 
-static inline void stl_sc26198rxbadch(stlport_t *portp, unsigned char status, char ch)
+static void stl_sc26198rxbadch(struct stlport *portp, unsigned char status, char ch)
 {
         struct tty_struct       *tty;
         unsigned int            ioaddr;
@@ -4999,7 +4564,7 @@ static inline void stl_sc26198rxbadch(stlport_t *portp, unsigned char status, ch
         if (status & SR_RXBREAK)
                 portp->stats.rxbreaks++;
 
-        if ((tty != (struct tty_struct *) NULL) &&
+        if ((tty != NULL) &&
             ((portp->rxignoremsk & status) == 0)) {
                 if (portp->rxmarkmsk & status) {
                         if (status & SR_RXBREAK) {
@@ -5008,18 +4573,16 @@ static inline void stl_sc26198rxbadch(stlport_t *portp, unsigned char status, ch
                                         do_SAK(tty);
                                         BRDENABLE(portp->brdnr, portp->pagenr);
                                 }
-                        } else if (status & SR_RXPARITY) {
+                        } else if (status & SR_RXPARITY)
                                 status = TTY_PARITY;
-                        } else if (status & SR_RXFRAMING) {
+                        else if (status & SR_RXFRAMING)
                                 status = TTY_FRAME;
-                        } else if(status & SR_RXOVERRUN) {
+                        else if(status & SR_RXOVERRUN)
                                 status = TTY_OVERRUN;
-                        } else {
+                        else
                                 status = 0;
-                        }
-                } else {
+                } else
                         status = 0;
-                }
 
                 tty_insert_flip_char(tty, ch, status);
                 tty_schedule_flip(tty);
@@ -5040,7 +4603,7 @@ static inline void stl_sc26198rxbadch(stlport_t *portp, unsigned char status, ch
  *      the FIFO).
  */
 
-static void stl_sc26198rxbadchars(stlport_t *portp)
+static void stl_sc26198rxbadchars(struct stlport *portp)
 {
         unsigned char   status, mr1;
         char            ch;
@@ -5073,13 +4636,11 @@ static void stl_sc26198rxbadchars(stlport_t *portp)
  *      processing time.
  */
 
-static void stl_sc26198otherisr(stlport_t *portp, unsigned int iack)
+static void stl_sc26198otherisr(struct stlport *portp, unsigned int iack)
 {
         unsigned char   cir, ipr, xisr;
 
-#ifdef DEBUG
-        printk("stl_sc26198otherisr(portp=%x,iack=%x)\n", (int) portp, iack);
-#endif
+        pr_debug("stl_sc26198otherisr(portp=%p,iack=%x)\n", portp, iack);
 
         cir = stl_sc26198getglobreg(portp, CIR);
 
@@ -5112,4 +4673,172 @@ static void stl_sc26198otherisr(stlport_t *portp, unsigned int iack)
         }
 }
 
-/*****************************************************************************/
+static void stl_free_isabrds(void)
+{
+        struct stlbrd *brdp;
+        unsigned int i;
+
+        for (i = 0; i < stl_nrbrds; i++) {
+                if ((brdp = stl_brds[i]) == NULL || (brdp->state & STL_PROBED))
+                        continue;
+
+                free_irq(brdp->irq, brdp);
+
+                stl_cleanup_panels(brdp);
+
+                release_region(brdp->ioaddr1, brdp->iosize1);
+                if (brdp->iosize2 > 0)
+                        release_region(brdp->ioaddr2, brdp->iosize2);
+
+                kfree(brdp);
+                stl_brds[i] = NULL;
+        }
+}
+
+/*
+ *      Loadable module initialization stuff.
+ */
+static int __init stallion_module_init(void)
+{
+        struct stlbrd   *brdp;
+        struct stlconf  conf;
+        unsigned int i, j;
+        int retval;
+
+        printk(KERN_INFO "%s: version %s\n", stl_drvtitle, stl_drvversion);
+
+        spin_lock_init(&stallion_lock);
+        spin_lock_init(&brd_lock);
+
+/*
+ *      Find any dynamically supported boards. That is via module load
+ *      line options.
+ */
+        for (i = stl_nrbrds; i < stl_nargs; i++) {
+                memset(&conf, 0, sizeof(conf));
+                if (stl_parsebrd(&conf, stl_brdsp[i]) == 0)
+                        continue;
+                if ((brdp = stl_allocbrd()) == NULL)
+                        continue;
+                brdp->brdnr = i;
+                brdp->brdtype = conf.brdtype;
+                brdp->ioaddr1 = conf.ioaddr1;
+                brdp->ioaddr2 = conf.ioaddr2;
+                brdp->irq = conf.irq;
+                brdp->irqtype = conf.irqtype;
+                if (stl_brdinit(brdp))
+                        kfree(brdp);
+                else {
+                        for (j = 0; j < brdp->nrports; j++)
+                                tty_register_device(stl_serial,
+                                        brdp->brdnr * STL_MAXPORTS + j, NULL);
+                        stl_brds[brdp->brdnr] = brdp;
+                        stl_nrbrds = i + 1;
+                }
+        }
+
+        /* this has to be _after_ isa finding because of locking */
+        retval = pci_register_driver(&stl_pcidriver);
+        if (retval && stl_nrbrds == 0)
+                goto err;
+
+        stl_serial = alloc_tty_driver(STL_MAXBRDS * STL_MAXPORTS);
+        if (!stl_serial) {
+                retval = -ENOMEM;
+                goto err_pcidr;
+        }
+
+/*
+ *      Set up a character driver for per board stuff. This is mainly used
+ *      to do stats ioctls on the ports.
+ */
+        if (register_chrdev(STL_SIOMEMMAJOR, "staliomem", &stl_fsiomem))
+                printk("STALLION: failed to register serial board device\n");
+
+        stallion_class = class_create(THIS_MODULE, "staliomem");
+        if (IS_ERR(stallion_class)) {
+                retval = PTR_ERR(stallion_class);
+                goto err_reg;
+        }
+        for (i = 0; i < 4; i++)
+                class_device_create(stallion_class, NULL,
+                                    MKDEV(STL_SIOMEMMAJOR, i), NULL,
+                                    "staliomem%d", i);
+
+        stl_serial->owner = THIS_MODULE;
+        stl_serial->driver_name = stl_drvname;
+        stl_serial->name = "ttyE";
+        stl_serial->major = STL_SERIALMAJOR;
+        stl_serial->minor_start = 0;
+        stl_serial->type = TTY_DRIVER_TYPE_SERIAL;
+        stl_serial->subtype = SERIAL_TYPE_NORMAL;
+        stl_serial->init_termios = stl_deftermios;
+        stl_serial->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
+        tty_set_operations(stl_serial, &stl_ops);
+
+        retval = tty_register_driver(stl_serial);
+        if (retval) {
+                printk("STALLION: failed to register serial driver\n");
+                goto err_clsdev;
+        }
+
+        return 0;
+err_clsdev:
+        for (i = 0; i < 4; i++)
+                class_device_destroy(stallion_class, MKDEV(STL_SIOMEMMAJOR, i));
+        class_destroy(stallion_class);
+err_reg:
+        unregister_chrdev(STL_SIOMEMMAJOR, "staliomem");
+        put_tty_driver(stl_serial);
+err_pcidr:
+        pci_unregister_driver(&stl_pcidriver);
+        stl_free_isabrds();
+err:
+        return retval;
+}
+
+static void __exit stallion_module_exit(void)
+{
+        struct stlbrd *brdp;
+        unsigned int i, j;
+        int retval;
+
+        pr_debug("cleanup_module()\n");
+
+        printk(KERN_INFO "Unloading %s: version %s\n", stl_drvtitle,
+                stl_drvversion);
+
+/*
+ *      Free up all allocated resources used by the ports. This includes
+ *      memory and interrupts. As part of this process we will also do
+ *      a hangup on every open port - to try to flush out any processes
+ *      hanging onto ports.
+ */
+        for (i = 0; i < stl_nrbrds; i++) {
+                if ((brdp = stl_brds[i]) == NULL || (brdp->state & STL_PROBED))
+                        continue;
+                for (j = 0; j < brdp->nrports; j++)
+                        tty_unregister_device(stl_serial,
+                                brdp->brdnr * STL_MAXPORTS + j);
+        }
+        tty_unregister_driver(stl_serial);
+        put_tty_driver(stl_serial);
+
+        for (i = 0; i < 4; i++)
+                class_device_destroy(stallion_class, MKDEV(STL_SIOMEMMAJOR, i));
+        if ((retval = unregister_chrdev(STL_SIOMEMMAJOR, "staliomem")))
+                printk("STALLION: failed to un-register serial memory device, "
+                        "errno=%d\n", -retval);
+        class_destroy(stallion_class);
+
+        pci_unregister_driver(&stl_pcidriver);
+
+        stl_free_isabrds();
+}
+
+module_init(stallion_module_init);
+module_exit(stallion_module_exit);
+
+MODULE_AUTHOR("Greg Ungerer");
+MODULE_DESCRIPTION("Stallion Multiport Serial Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/char/sx.c b/drivers/char/sx.c
index e1cd2bc4b1e4..a3008ce13015 100644
--- a/drivers/char/sx.c
+++ b/drivers/char/sx.c
@@ -32,7 +32,6 @@
  *      USA.
  *
  * Revision history:
- * $Log: sx.c,v $
  * Revision 1.33  2000/03/09 10:00:00  pvdl,wolff
  * - Fixed module and port counting
  * - Fixed signal handling
@@ -199,13 +198,9 @@
  *
  * */
 
-
-#define RCS_ID "$Id: sx.c,v 1.33 2000/03/08 10:01:02 wolff, pvdl Exp $"
-#define RCS_REV "$Revision: 1.33 $"
-
+#define SX_VERSION      1.33
 
 #include <linux/module.h>
-#include <linux/config.h> 
 #include <linux/kdev_t.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
@@ -219,6 +214,7 @@
 #include <linux/fcntl.h>
 #include <linux/major.h>
 #include <linux/delay.h>
+#include <linux/eisa.h>
 #include <linux/pci.h>
 #include <linux/slab.h>
 #include <linux/init.h>
@@ -242,7 +238,6 @@
 #include <linux/generic_serial.h>
 #include "sx.h"
 
-
 /* I don't think that this driver can handle more than 256 ports on
    one machine. You'll have to increase the number of boards in sx.h
    if you want more than 4 boards.  */
@@ -251,21 +246,12 @@
 #define PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8 0x2000
 #endif
 
-#ifdef CONFIG_PCI
-static struct pci_device_id sx_pci_tbl[] = {
-        { PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8, PCI_ANY_ID, PCI_ANY_ID },
-        { 0 }
-};
-MODULE_DEVICE_TABLE(pci, sx_pci_tbl);
-#endif /* CONFIG_PCI */
-
 /* Configurable options: 
    (Don't be too sure that it'll work if you toggle them) */
 
 /* Am I paranoid or not ? ;-) */
 #undef SX_PARANOIA_CHECK
 
-
 /* 20 -> 2000 per second. The card should rate-limit interrupts at 100
    Hz, but it is user configurable. I don't recommend going above 1000
    Hz. The interrupt ratelimit might trigger if the interrupt is
@@ -279,7 +265,6 @@ MODULE_DEVICE_TABLE(pci, sx_pci_tbl);
    interrupt. Use polling. */
 #undef IRQ_RATE_LIMIT
 
-
 #if 0
 /* Not implemented */
 /* 
@@ -288,35 +273,33 @@ MODULE_DEVICE_TABLE(pci, sx_pci_tbl);
  */
 #define SX_REPORT_FIFO
 #define SX_REPORT_OVERRUN
-#endif 
-
+#endif
 
 /* Function prototypes */
-static void sx_disable_tx_interrupts (void * ptr); 
-static void sx_enable_tx_interrupts (void * ptr); 
-static void sx_disable_rx_interrupts (void * ptr); 
-static void sx_enable_rx_interrupts (void * ptr); 
-static int  sx_get_CD (void * ptr); 
-static void sx_shutdown_port (void * ptr);
-static int  sx_set_real_termios (void  *ptr);
-static void sx_close (void  *ptr);
-static int sx_chars_in_buffer (void * ptr);
-static int sx_init_board (struct sx_board *board);
-static int sx_init_portstructs (int nboards, int nports);
-static int sx_fw_ioctl (struct inode *inode, struct file *filp,
-                        unsigned int cmd, unsigned long arg);
+static void sx_disable_tx_interrupts(void *ptr);
+static void sx_enable_tx_interrupts(void *ptr);
+static void sx_disable_rx_interrupts(void *ptr);
+static void sx_enable_rx_interrupts(void *ptr);
+static int sx_get_CD(void *ptr);
+static void sx_shutdown_port(void *ptr);
+static int sx_set_real_termios(void *ptr);
+static void sx_close(void *ptr);
+static int sx_chars_in_buffer(void *ptr);
+static int sx_init_board(struct sx_board *board);
+static int sx_init_portstructs(int nboards, int nports);
+static int sx_fw_ioctl(struct inode *inode, struct file *filp,
+                unsigned int cmd, unsigned long arg);
 static int sx_init_drivers(void);
 
-
 static struct tty_driver *sx_driver;
 
+static DEFINE_MUTEX(sx_boards_lock);
 static struct sx_board boards[SX_NBOARDS];
 static struct sx_port *sx_ports;
 static int sx_initialized;
 static int sx_nports;
 static int sx_debug;
 
-
 /* You can have the driver poll your card. 
     - Set sx_poll to 1 to poll every timer tick (10ms on Intel). 
       This is used when the card cannot use an interrupt for some reason.
@@ -335,27 +318,36 @@ static int sx_slowpoll;
 
 static int sx_maxints = 100;
 
+#ifdef CONFIG_ISA
+
 /* These are the only open spaces in my computer. Yours may have more
    or less.... -- REW 
    duh: Card at 0xa0000 is possible on HP Netserver?? -- pvdl
 */
-static int sx_probe_addrs[]= {0xc0000, 0xd0000, 0xe0000, 
-                              0xc8000, 0xd8000, 0xe8000};
-static int si_probe_addrs[]= {0xc0000, 0xd0000, 0xe0000, 
-                              0xc8000, 0xd8000, 0xe8000, 0xa0000};
-static int si1_probe_addrs[]= { 0xd0000};
+static int sx_probe_addrs[] = {
+        0xc0000, 0xd0000, 0xe0000,
+        0xc8000, 0xd8000, 0xe8000
+};
+static int si_probe_addrs[] = {
+        0xc0000, 0xd0000, 0xe0000,
+        0xc8000, 0xd8000, 0xe8000, 0xa0000
+};
+static int si1_probe_addrs[] = {
+        0xd0000
+};
 
 #define NR_SX_ADDRS ARRAY_SIZE(sx_probe_addrs)
 #define NR_SI_ADDRS ARRAY_SIZE(si_probe_addrs)
 #define NR_SI1_ADDRS ARRAY_SIZE(si1_probe_addrs)
 
+module_param_array(sx_probe_addrs, int, NULL, 0);
+module_param_array(si_probe_addrs, int, NULL, 0);
+#endif
 
 /* Set the mask to all-ones. This alas, only supports 32 interrupts. 
    Some architectures may need more. */
 static int sx_irqmask = -1;
 
-module_param_array(sx_probe_addrs, int, NULL, 0);
-module_param_array(si_probe_addrs, int, NULL, 0);
 module_param(sx_poll, int, 0);
 module_param(sx_slowpoll, int, 0);
 module_param(sx_maxints, int, 0);
@@ -370,13 +362,12 @@ static struct real_driver sx_real_driver = {
         sx_disable_rx_interrupts,
         sx_enable_rx_interrupts,
         sx_get_CD,
-        sx_shutdown_port, 
-        sx_set_real_termios, 
+        sx_shutdown_port,
+        sx_set_real_termios,
         sx_chars_in_buffer,
         sx_close,
 };
 
-
 /* 
    This driver can spew a whole lot of debugging output at you. If you
    need maximum performance, you should disable the DEBUG define. To
@@ -387,23 +378,17 @@ static struct real_driver sx_real_driver = {
 */
 #define DEBUG
 
-
 #ifdef DEBUG
-#define sx_dprintk(f, str...) if (sx_debug & f) printk (str)
+#define sx_dprintk(f, str...)   if (sx_debug & f) printk (str)
 #else
-#define sx_dprintk(f, str...) /* nothing */
+#define sx_dprintk(f, str...)   /* nothing */
 #endif
 
+#define func_enter()    sx_dprintk(SX_DEBUG_FLOW, "sx: enter %s\n",__FUNCTION__)
+#define func_exit()     sx_dprintk(SX_DEBUG_FLOW, "sx: exit  %s\n",__FUNCTION__)
 
-
-#define func_enter() sx_dprintk (SX_DEBUG_FLOW, "sx: enter %s\n",__FUNCTION__)
-#define func_exit()  sx_dprintk (SX_DEBUG_FLOW, "sx: exit  %s\n", __FUNCTION__)
-
-#define func_enter2() sx_dprintk (SX_DEBUG_FLOW, "sx: enter %s (port %d)\n", \
-                                        __FUNCTION__, port->line)
-
-
-
+#define func_enter2()   sx_dprintk(SX_DEBUG_FLOW, "sx: enter %s (port %d)\n", \
+                                __FUNCTION__, port->line)
 
 /* 
  *  Firmware loader driver specific routines
@@ -411,31 +396,26 @@ static struct real_driver sx_real_driver = {
  */
 
 static const struct file_operations sx_fw_fops = {
-        .owner          = THIS_MODULE,
-        .ioctl          = sx_fw_ioctl,
+        .owner = THIS_MODULE,
+        .ioctl = sx_fw_ioctl,
 };
 
 static struct miscdevice sx_fw_device = {
         SXCTL_MISC_MINOR, "sxctl", &sx_fw_fops
 };
 
-
-
-
-
 #ifdef SX_PARANOIA_CHECK
 
 /* This doesn't work. Who's paranoid around here? Not me! */
 
-static inline int sx_paranoia_check(struct sx_port const * port,
+static inline int sx_paranoia_check(struct sx_port const *port,
                                     char *name, const char *routine)
 {
+        static const char *badmagic = KERN_ERR "sx: Warning: bad sx port magic "
+                        "number for device %s in %s\n";
+        static const char *badinfo = KERN_ERR "sx: Warning: null sx port for "
+                        "device %s in %s\n";
 
-        static const char *badmagic =
-          KERN_ERR "sx: Warning: bad sx port magic number for device %s in %s\n";
-        static const char *badinfo =
-          KERN_ERR "sx: Warning: null sx port for device %s in %s\n";
- 
         if (!port) {
                 printk(badinfo, name, routine);
                 return 1;
@@ -458,23 +438,24 @@ static inline int sx_paranoia_check(struct sx_port const * port,
 #define TIMEOUT_1 30
 #define TIMEOUT_2 1000000
 
-
 #ifdef DEBUG
 static void my_hd_io(void __iomem *p, int len)
 {
         int i, j, ch;
         unsigned char __iomem *addr = p;
 
-        for (i=0;i<len;i+=16) {
-                printk ("%p ", addr+i);
-                for (j=0;j<16;j++) {
-                        printk ("%02x %s", readb(addr+j+i), (j==7)?" ":"");
+        for (i = 0; i < len; i += 16) {
+                printk("%p ", addr + i);
+                for (j = 0; j < 16; j++) {
+                        printk("%02x %s", readb(addr + j + i),
+                                        (j == 7) ? " " : "");
                 }
-                for (j=0;j<16;j++) {
-                        ch = readb(addr+j+i);
-                        printk ("%c", (ch < 0x20)?'.':((ch > 0x7f)?'.':ch));
+                for (j = 0; j < 16; j++) {
+                        ch = readb(addr + j + i);
+                        printk("%c", (ch < 0x20) ? '.' :
+                                        ((ch > 0x7f) ? '.' : ch));
                 }
-                printk ("\n");
+                printk("\n");
         }
 }
 static void my_hd(void *p, int len)
@@ -482,419 +463,468 @@ static void my_hd(void *p, int len)
         int i, j, ch;
         unsigned char *addr = p;
 
-        for (i=0;i<len;i+=16) {
-                printk ("%p ", addr+i);
-                for (j=0;j<16;j++) {
-                        printk ("%02x %s", addr[j+i], (j==7)?" ":"");
+        for (i = 0; i < len; i += 16) {
+                printk("%p ", addr + i);
+                for (j = 0; j < 16; j++) {
+                        printk("%02x %s", addr[j + i], (j == 7) ? " " : "");
                 }
-                for (j=0;j<16;j++) {
-                        ch = addr[j+i];
-                        printk ("%c", (ch < 0x20)?'.':((ch > 0x7f)?'.':ch));
+                for (j = 0; j < 16; j++) {
+                        ch = addr[j + i];
+                        printk("%c", (ch < 0x20) ? '.' :
+                                        ((ch > 0x7f) ? '.' : ch));
                 }
-                printk ("\n");
+                printk("\n");
         }
 }
 #endif
 
-
-
 /* This needs redoing for Alpha -- REW -- Done. */
 
-static inline void write_sx_byte (struct sx_board *board, int offset, u8 byte)
+static inline void write_sx_byte(struct sx_board *board, int offset, u8 byte)
 {
-        writeb (byte, board->base+offset);
+        writeb(byte, board->base + offset);
 }
 
-static inline u8 read_sx_byte (struct sx_board *board, int offset)
+static inline u8 read_sx_byte(struct sx_board *board, int offset)
 {
-        return readb (board->base+offset);
+        return readb(board->base + offset);
 }
 
-
-static inline void write_sx_word (struct sx_board *board, int offset, u16 word)
+static inline void write_sx_word(struct sx_board *board, int offset, u16 word)
 {
-        writew (word, board->base+offset);
+        writew(word, board->base + offset);
 }
 
-static inline u16 read_sx_word (struct sx_board *board, int offset)
+static inline u16 read_sx_word(struct sx_board *board, int offset)
 {
-        return readw (board->base + offset);
+        return readw(board->base + offset);
 }
 
-
-static int sx_busy_wait_eq (struct sx_board *board, 
-                            int offset, int mask, int correctval)
+static int sx_busy_wait_eq(struct sx_board *board,
+                int offset, int mask, int correctval)
 {
         int i;
 
-        func_enter ();
+        func_enter();
 
-        for (i=0; i < TIMEOUT_1 ;i++)
-                if ((read_sx_byte (board, offset) & mask) == correctval) {
-                        func_exit ();
+        for (i = 0; i < TIMEOUT_1; i++)
+                if ((read_sx_byte(board, offset) & mask) == correctval) {
+                        func_exit();
                         return 1;
                 }
 
-        for (i=0; i < TIMEOUT_2 ;i++) {
-                if ((read_sx_byte (board, offset) & mask) == correctval) {
-                        func_exit ();
+        for (i = 0; i < TIMEOUT_2; i++) {
+                if ((read_sx_byte(board, offset) & mask) == correctval) {
+                        func_exit();
                         return 1;
                 }
-                udelay (1);
+                udelay(1);
         }
 
-        func_exit ();
+        func_exit();
         return 0;
 }
 
-
-static int sx_busy_wait_neq (struct sx_board *board, 
-                             int offset, int mask, int badval)
+static int sx_busy_wait_neq(struct sx_board *board,
+                int offset, int mask, int badval)
 {
         int i;
 
-        func_enter ();
+        func_enter();
 
-        for (i=0; i < TIMEOUT_1 ;i++)
-                if ((read_sx_byte (board, offset) & mask) != badval) {
-                        func_exit ();
+        for (i = 0; i < TIMEOUT_1; i++)
+                if ((read_sx_byte(board, offset) & mask) != badval) {
+                        func_exit();
                         return 1;
                 }
 
-        for (i=0; i < TIMEOUT_2 ;i++) {
-                if ((read_sx_byte (board, offset) & mask) != badval) {
-                        func_exit ();
+        for (i = 0; i < TIMEOUT_2; i++) {
+                if ((read_sx_byte(board, offset) & mask) != badval) {
+                        func_exit();
                         return 1;
                 }
-                udelay (1);
+                udelay(1);
         }
 
-        func_exit ();
+        func_exit();
         return 0;
 }
 
-
-
 /* 5.6.4 of 6210028 r2.3 */
-static int sx_reset (struct sx_board *board)
+static int sx_reset(struct sx_board *board)
 {
-        func_enter ();
+        func_enter();
 
-        if (IS_SX_BOARD (board)) {
+        if (IS_SX_BOARD(board)) {
 
-                write_sx_byte (board, SX_CONFIG, 0);
-                write_sx_byte (board, SX_RESET, 1); /* Value doesn't matter */
+                write_sx_byte(board, SX_CONFIG, 0);
+                write_sx_byte(board, SX_RESET, 1); /* Value doesn't matter */
 
-                if (!sx_busy_wait_eq (board, SX_RESET_STATUS, 1, 0)) {
-                        printk (KERN_INFO "sx: Card doesn't respond to reset....\n");
+                if (!sx_busy_wait_eq(board, SX_RESET_STATUS, 1, 0)) {
+                        printk(KERN_INFO "sx: Card doesn't respond to "
+                                        "reset...\n");
                         return 0;
                 }
         } else if (IS_EISA_BOARD(board)) {
-                outb(board->irq<<4, board->eisa_base+0xc02);
+                outb(board->irq << 4, board->eisa_base + 0xc02);
         } else if (IS_SI1_BOARD(board)) {
-                write_sx_byte (board, SI1_ISA_RESET,   0); // value does not matter
+                write_sx_byte(board, SI1_ISA_RESET, 0); /*value doesn't matter*/
         } else {
                 /* Gory details of the SI/ISA board */
-                write_sx_byte (board, SI2_ISA_RESET,    SI2_ISA_RESET_SET);
-                write_sx_byte (board, SI2_ISA_IRQ11,    SI2_ISA_IRQ11_CLEAR);
-                write_sx_byte (board, SI2_ISA_IRQ12,    SI2_ISA_IRQ12_CLEAR);
-                write_sx_byte (board, SI2_ISA_IRQ15,    SI2_ISA_IRQ15_CLEAR);
-                write_sx_byte (board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_CLEAR);
-                write_sx_byte (board, SI2_ISA_IRQSET,   SI2_ISA_IRQSET_CLEAR);
+                write_sx_byte(board, SI2_ISA_RESET, SI2_ISA_RESET_SET);
+                write_sx_byte(board, SI2_ISA_IRQ11, SI2_ISA_IRQ11_CLEAR);
+                write_sx_byte(board, SI2_ISA_IRQ12, SI2_ISA_IRQ12_CLEAR);
+                write_sx_byte(board, SI2_ISA_IRQ15, SI2_ISA_IRQ15_CLEAR);
+                write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_CLEAR);
+                write_sx_byte(board, SI2_ISA_IRQSET, SI2_ISA_IRQSET_CLEAR);
         }
 
-        func_exit ();
+        func_exit();
         return 1;
 }
 
-
 /* This doesn't work on machines where "NULL" isn't 0 */
 /* If you have one of those, someone will need to write 
    the equivalent of this, which will amount to about 3 lines. I don't
    want to complicate this right now. -- REW
    (See, I do write comments every now and then :-) */
-#define OFFSETOF(strct, elem) ((long)&(((struct strct *)NULL)->elem))
-
-
-#define CHAN_OFFSET(port,elem) (port->ch_base + OFFSETOF (_SXCHANNEL, elem))
-#define MODU_OFFSET(board,addr,elem)    (addr + OFFSETOF (_SXMODULE, elem))
-#define  BRD_OFFSET(board,elem)                (OFFSETOF (_SXCARD, elem))
+#define OFFSETOF(strct, elem)   ((long)&(((struct strct *)NULL)->elem))
 
+#define CHAN_OFFSET(port,elem)  (port->ch_base + OFFSETOF (_SXCHANNEL, elem))
+#define MODU_OFFSET(board,addr,elem)    (addr + OFFSETOF (_SXMODULE, elem))
+#define  BRD_OFFSET(board,elem) (OFFSETOF (_SXCARD, elem))
 
 #define sx_write_channel_byte(port, elem, val) \
-   write_sx_byte (port->board, CHAN_OFFSET (port, elem), val)
+        write_sx_byte (port->board, CHAN_OFFSET (port, elem), val)
 
 #define sx_read_channel_byte(port, elem) \
-   read_sx_byte (port->board, CHAN_OFFSET (port, elem))
+        read_sx_byte (port->board, CHAN_OFFSET (port, elem))
 
 #define sx_write_channel_word(port, elem, val) \
-   write_sx_word (port->board, CHAN_OFFSET (port, elem), val)
+        write_sx_word (port->board, CHAN_OFFSET (port, elem), val)
 
 #define sx_read_channel_word(port, elem) \
-   read_sx_word (port->board, CHAN_OFFSET (port, elem))
-
+        read_sx_word (port->board, CHAN_OFFSET (port, elem))
 
 #define sx_write_module_byte(board, addr, elem, val) \
-   write_sx_byte (board, MODU_OFFSET (board, addr, elem), val)
+        write_sx_byte (board, MODU_OFFSET (board, addr, elem), val)
 
 #define sx_read_module_byte(board, addr, elem) \
-   read_sx_byte (board, MODU_OFFSET (board, addr, elem))
+        read_sx_byte (board, MODU_OFFSET (board, addr, elem))
 
 #define sx_write_module_word(board, addr, elem, val) \
-   write_sx_word (board, MODU_OFFSET (board, addr, elem), val)
+        write_sx_word (board, MODU_OFFSET (board, addr, elem), val)
 
 #define sx_read_module_word(board, addr, elem) \
-   read_sx_word (board, MODU_OFFSET (board, addr, elem))
-
+        read_sx_word (board, MODU_OFFSET (board, addr, elem))
 
 #define sx_write_board_byte(board, elem, val) \
-   write_sx_byte (board, BRD_OFFSET (board, elem), val)
+        write_sx_byte (board, BRD_OFFSET (board, elem), val)
 
 #define sx_read_board_byte(board, elem) \
-   read_sx_byte (board, BRD_OFFSET (board, elem))
+        read_sx_byte (board, BRD_OFFSET (board, elem))
 
 #define sx_write_board_word(board, elem, val) \
-   write_sx_word (board, BRD_OFFSET (board, elem), val)
+        write_sx_word (board, BRD_OFFSET (board, elem), val)
 
 #define sx_read_board_word(board, elem) \
-   read_sx_word (board, BRD_OFFSET (board, elem))
-
+        read_sx_word (board, BRD_OFFSET (board, elem))
 
-static int sx_start_board (struct sx_board *board)
+static int sx_start_board(struct sx_board *board)
 {
-        if (IS_SX_BOARD (board)) {
-                write_sx_byte (board, SX_CONFIG, SX_CONF_BUSEN);
+        if (IS_SX_BOARD(board)) {
+                write_sx_byte(board, SX_CONFIG, SX_CONF_BUSEN);
         } else if (IS_EISA_BOARD(board)) {
                 write_sx_byte(board, SI2_EISA_OFF, SI2_EISA_VAL);
-                outb((board->irq<<4)|4, board->eisa_base+0xc02);
+                outb((board->irq << 4) | 4, board->eisa_base + 0xc02);
         } else if (IS_SI1_BOARD(board)) {
-                write_sx_byte (board, SI1_ISA_RESET_CLEAR, 0);
-                write_sx_byte (board, SI1_ISA_INTCL, 0);
+                write_sx_byte(board, SI1_ISA_RESET_CLEAR, 0);
+                write_sx_byte(board, SI1_ISA_INTCL, 0);
         } else {
                 /* Don't bug me about the clear_set. 
                    I haven't the foggiest idea what it's about -- REW */
-                write_sx_byte (board, SI2_ISA_RESET,    SI2_ISA_RESET_CLEAR);
-                write_sx_byte (board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
+                write_sx_byte(board, SI2_ISA_RESET, SI2_ISA_RESET_CLEAR);
+                write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
         }
         return 1;
 }
 
 #define SX_IRQ_REG_VAL(board) \
-        ((board->flags & SX_ISA_BOARD)?(board->irq << 4):0)
+        ((board->flags & SX_ISA_BOARD) ? (board->irq << 4) : 0)
 
 /* Note. The SX register is write-only. Therefore, we have to enable the
    bus too. This is a no-op, if you don't mess with this driver... */
-static int sx_start_interrupts (struct sx_board *board)
+static int sx_start_interrupts(struct sx_board *board)
 {
 
         /* Don't call this with board->irq == 0 */
 
         if (IS_SX_BOARD(board)) {
-                write_sx_byte (board, SX_CONFIG, SX_IRQ_REG_VAL (board) | 
-                                                 SX_CONF_BUSEN | 
-                                                 SX_CONF_HOSTIRQ);
+                write_sx_byte(board, SX_CONFIG, SX_IRQ_REG_VAL(board) |
+                                SX_CONF_BUSEN | SX_CONF_HOSTIRQ);
         } else if (IS_EISA_BOARD(board)) {
-                inb(board->eisa_base+0xc03);  
+                inb(board->eisa_base + 0xc03);
         } else if (IS_SI1_BOARD(board)) {
-               write_sx_byte (board, SI1_ISA_INTCL,0);
-               write_sx_byte (board, SI1_ISA_INTCL_CLEAR,0);
+                write_sx_byte(board, SI1_ISA_INTCL, 0);
+                write_sx_byte(board, SI1_ISA_INTCL_CLEAR, 0);
         } else {
                 switch (board->irq) {
-                case 11:write_sx_byte (board, SI2_ISA_IRQ11, SI2_ISA_IRQ11_SET);break;
-                case 12:write_sx_byte (board, SI2_ISA_IRQ12, SI2_ISA_IRQ12_SET);break;
-                case 15:write_sx_byte (board, SI2_ISA_IRQ15, SI2_ISA_IRQ15_SET);break;
-                default:printk (KERN_INFO "sx: SI/XIO card doesn't support interrupt %d.\n", 
-                                board->irq);
-                return 0;
+                case 11:
+                        write_sx_byte(board, SI2_ISA_IRQ11, SI2_ISA_IRQ11_SET);
+                        break;
+                case 12:
+                        write_sx_byte(board, SI2_ISA_IRQ12, SI2_ISA_IRQ12_SET);
+                        break;
+                case 15:
+                        write_sx_byte(board, SI2_ISA_IRQ15, SI2_ISA_IRQ15_SET);
+                        break;
+                default:
+                        printk(KERN_INFO "sx: SI/XIO card doesn't support "
+                                        "interrupt %d.\n", board->irq);
+                        return 0;
                 }
-                write_sx_byte (board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
+                write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
         }
 
         return 1;
 }
 
-
-static int sx_send_command (struct sx_port *port, 
-                            int command, int mask, int newstat)
+static int sx_send_command(struct sx_port *port,
+                int command, int mask, int newstat)
 {
-        func_enter2 ();
-        write_sx_byte (port->board, CHAN_OFFSET (port, hi_hstat), command);
-        func_exit ();
-        return sx_busy_wait_eq (port->board, CHAN_OFFSET (port, hi_hstat), mask, newstat);
+        func_enter2();
+        write_sx_byte(port->board, CHAN_OFFSET(port, hi_hstat), command);
+        func_exit();
+        return sx_busy_wait_eq(port->board, CHAN_OFFSET(port, hi_hstat), mask,
+                        newstat);
 }
 
-
-static char *mod_type_s (int module_type)
+static char *mod_type_s(int module_type)
 {
         switch (module_type) {
-        case TA4:       return "TA4";
-        case TA8:       return "TA8";
-        case TA4_ASIC:  return "TA4_ASIC";
-        case TA8_ASIC:  return "TA8_ASIC";
-        case MTA_CD1400:return "MTA_CD1400";
-        case SXDC:      return "SXDC";
-        default:return "Unknown/invalid";
+        case TA4:
+                return "TA4";
+        case TA8:
+                return "TA8";
+        case TA4_ASIC:
+                return "TA4_ASIC";
+        case TA8_ASIC:
+                return "TA8_ASIC";
+        case MTA_CD1400:
+                return "MTA_CD1400";
+        case SXDC:
+                return "SXDC";
+        default:
+                return "Unknown/invalid";
         }
 }
 
-
-static char *pan_type_s (int pan_type)
+static char *pan_type_s(int pan_type)
 {
         switch (pan_type) {
-        case MOD_RS232DB25:     return "MOD_RS232DB25";
-        case MOD_RS232RJ45:     return "MOD_RS232RJ45";
-        case MOD_RS422DB25:     return "MOD_RS422DB25";
-        case MOD_PARALLEL:      return "MOD_PARALLEL";
-        case MOD_2_RS232DB25:   return "MOD_2_RS232DB25";
-        case MOD_2_RS232RJ45:   return "MOD_2_RS232RJ45";
-        case MOD_2_RS422DB25:   return "MOD_2_RS422DB25";
-        case MOD_RS232DB25MALE: return "MOD_RS232DB25MALE";
-        case MOD_2_PARALLEL:    return "MOD_2_PARALLEL";
-        case MOD_BLANK:         return "empty";
-        default:return "invalid";
+        case MOD_RS232DB25:
+                return "MOD_RS232DB25";
+        case MOD_RS232RJ45:
+                return "MOD_RS232RJ45";
+        case MOD_RS422DB25:
+                return "MOD_RS422DB25";
+        case MOD_PARALLEL:
+                return "MOD_PARALLEL";
+        case MOD_2_RS232DB25:
+                return "MOD_2_RS232DB25";
+        case MOD_2_RS232RJ45:
+                return "MOD_2_RS232RJ45";
+        case MOD_2_RS422DB25:
+                return "MOD_2_RS422DB25";
+        case MOD_RS232DB25MALE:
+                return "MOD_RS232DB25MALE";
+        case MOD_2_PARALLEL:
+                return "MOD_2_PARALLEL";
+        case MOD_BLANK:
+                return "empty";
+        default:
+                return "invalid";
         }
 }
 
-
-static int mod_compat_type (int module_type)
+static int mod_compat_type(int module_type)
 {
         return module_type >> 4;
 }
 
 static void sx_reconfigure_port(struct sx_port *port)
 {
-        if (sx_read_channel_byte (port, hi_hstat) == HS_IDLE_OPEN) {
-                if (sx_send_command (port, HS_CONFIG, -1, HS_IDLE_OPEN) != 1) {
-                        printk (KERN_WARNING "sx: Sent reconfigure command, but card didn't react.\n");
+        if (sx_read_channel_byte(port, hi_hstat) == HS_IDLE_OPEN) {
+                if (sx_send_command(port, HS_CONFIG, -1, HS_IDLE_OPEN) != 1) {
+                        printk(KERN_WARNING "sx: Sent reconfigure command, but "
+                                        "card didn't react.\n");
                 }
         } else {
-                sx_dprintk (SX_DEBUG_TERMIOS, 
-                            "sx: Not sending reconfigure: port isn't open (%02x).\n", 
-                            sx_read_channel_byte (port, hi_hstat));
-        }       
+                sx_dprintk(SX_DEBUG_TERMIOS, "sx: Not sending reconfigure: "
+                                "port isn't open (%02x).\n",
+                                sx_read_channel_byte(port, hi_hstat));
+        }
 }
 
-static void sx_setsignals (struct sx_port *port, int dtr, int rts)
+static void sx_setsignals(struct sx_port *port, int dtr, int rts)
 {
         int t;
-        func_enter2 ();
+        func_enter2();
 
-        t = sx_read_channel_byte (port, hi_op);
-        if (dtr >= 0) t = dtr? (t | OP_DTR): (t & ~OP_DTR);
-        if (rts >= 0) t = rts? (t | OP_RTS): (t & ~OP_RTS);
-        sx_write_channel_byte (port, hi_op, t);
-        sx_dprintk (SX_DEBUG_MODEMSIGNALS, "setsignals: %d/%d\n", dtr, rts);
+        t = sx_read_channel_byte(port, hi_op);
+        if (dtr >= 0)
+                t = dtr ? (t | OP_DTR) : (t & ~OP_DTR);
+        if (rts >= 0)
+                t = rts ? (t | OP_RTS) : (t & ~OP_RTS);
+        sx_write_channel_byte(port, hi_op, t);
+        sx_dprintk(SX_DEBUG_MODEMSIGNALS, "setsignals: %d/%d\n", dtr, rts);
 
-        func_exit ();
+        func_exit();
 }
 
-
-
-static int sx_getsignals (struct sx_port *port)
+static int sx_getsignals(struct sx_port *port)
 {
-        int i_stat,o_stat;
-
-        o_stat = sx_read_channel_byte (port, hi_op);
-        i_stat = sx_read_channel_byte (port, hi_ip);
-
-        sx_dprintk (SX_DEBUG_MODEMSIGNALS, "getsignals: %d/%d  (%d/%d) %02x/%02x\n",
-                    (o_stat & OP_DTR) != 0, (o_stat & OP_RTS) != 0,
-                    port->c_dcd, sx_get_CD (port),
-                    sx_read_channel_byte (port, hi_ip),
-                    sx_read_channel_byte (port, hi_state));
-
-        return (((o_stat & OP_DTR)?TIOCM_DTR:0) |
-                ((o_stat & OP_RTS)?TIOCM_RTS:0) |
-                ((i_stat & IP_CTS)?TIOCM_CTS:0) |
-                ((i_stat & IP_DCD)?TIOCM_CAR:0) |
-                ((i_stat & IP_DSR)?TIOCM_DSR:0) |
-                ((i_stat & IP_RI)?TIOCM_RNG:0)
-                );
+        int i_stat, o_stat;
+
+        o_stat = sx_read_channel_byte(port, hi_op);
+        i_stat = sx_read_channel_byte(port, hi_ip);
+
+        sx_dprintk(SX_DEBUG_MODEMSIGNALS, "getsignals: %d/%d  (%d/%d) "
+                        "%02x/%02x\n",
+                        (o_stat & OP_DTR) != 0, (o_stat & OP_RTS) != 0,
+                        port->c_dcd, sx_get_CD(port),
+                        sx_read_channel_byte(port, hi_ip),
+                        sx_read_channel_byte(port, hi_state));
+
+        return (((o_stat & OP_DTR) ? TIOCM_DTR : 0) |
+                ((o_stat & OP_RTS) ? TIOCM_RTS : 0) |
+                ((i_stat & IP_CTS) ? TIOCM_CTS : 0) |
+                ((i_stat & IP_DCD) ? TIOCM_CAR : 0) |
+                ((i_stat & IP_DSR) ? TIOCM_DSR : 0) |
+                ((i_stat & IP_RI) ? TIOCM_RNG : 0));
 }
 
-
-static void sx_set_baud (struct sx_port *port)
+static void sx_set_baud(struct sx_port *port)
 {
         int t;
 
         if (port->board->ta_type == MOD_SXDC) {
                 switch (port->gs.baud) {
-                  /* Save some typing work... */
-#define e(x) case x:t= BAUD_ ## x ; break
-                        e(50);e(75);e(110);e(150);e(200);e(300);e(600);
-                        e(1200);e(1800);e(2000);e(2400);e(4800);e(7200);
-                        e(9600);e(14400);e(19200);e(28800);e(38400);
-                        e(56000);e(57600);e(64000);e(76800);e(115200);
-                        e(128000);e(150000);e(230400);e(256000);e(460800);
-                        e(921600);
-                case 134    :t = BAUD_134_5;   break;
-                case 0      :t = -1;
-                                                                 break;
+                        /* Save some typing work... */
+#define e(x) case x: t = BAUD_ ## x; break
+                        e(50);
+                        e(75);
+                        e(110);
+                        e(150);
+                        e(200);
+                        e(300);
+                        e(600);
+                        e(1200);
+                        e(1800);
+                        e(2000);
+                        e(2400);
+                        e(4800);
+                        e(7200);
+                        e(9600);
+                        e(14400);
+                        e(19200);
+                        e(28800);
+                        e(38400);
+                        e(56000);
+                        e(57600);
+                        e(64000);
+                        e(76800);
+                        e(115200);
+                        e(128000);
+                        e(150000);
+                        e(230400);
+                        e(256000);
+                        e(460800);
+                        e(921600);
+                case 134:
+                        t = BAUD_134_5;
+                        break;
+                case 0:
+                        t = -1;
+                        break;
                 default:
                         /* Can I return "invalid"? */
                         t = BAUD_9600;
-                        printk (KERN_INFO "sx: unsupported baud rate: %d.\n", port->gs.baud);
+                        printk(KERN_INFO "sx: unsupported baud rate: %d.\n",
+                                        port->gs.baud);
                         break;
                 }
 #undef e
                 if (t > 0) {
-                        /* The baud rate is not set to 0, so we're enabeling DTR... -- REW */
-                        sx_setsignals (port, 1, -1); 
+/* The baud rate is not set to 0, so we're enabeling DTR... -- REW */
+                        sx_setsignals(port, 1, -1);
                         /* XXX This is not TA & MTA compatible */
-                        sx_write_channel_byte (port, hi_csr, 0xff);
+                        sx_write_channel_byte(port, hi_csr, 0xff);
 
-                        sx_write_channel_byte (port, hi_txbaud, t);
-                        sx_write_channel_byte (port, hi_rxbaud, t);
+                        sx_write_channel_byte(port, hi_txbaud, t);
+                        sx_write_channel_byte(port, hi_rxbaud, t);
                 } else {
-                        sx_setsignals (port, 0, -1);
+                        sx_setsignals(port, 0, -1);
                 }
         } else {
                 switch (port->gs.baud) {
-#define e(x) case x:t= CSR_ ## x ; break
-                        e(75);e(150);e(300);e(600);e(1200);e(2400);e(4800);
-                        e(1800);e(9600);
-                        e(19200);e(57600);e(38400);
-                        /* TA supports 110, but not 115200, MTA supports 115200, but not 110 */
-                case 110: 
+#define e(x) case x: t = CSR_ ## x; break
+                        e(75);
+                        e(150);
+                        e(300);
+                        e(600);
+                        e(1200);
+                        e(2400);
+                        e(4800);
+                        e(1800);
+                        e(9600);
+                        e(19200);
+                        e(57600);
+                        e(38400);
+/* TA supports 110, but not 115200, MTA supports 115200, but not 110 */
+                case 110:
                         if (port->board->ta_type == MOD_TA) {
                                 t = CSR_110;
                                 break;
                         } else {
                                 t = CSR_9600;
-                                printk (KERN_INFO "sx: Unsupported baud rate: %d.\n", port->gs.baud);
+                                printk(KERN_INFO "sx: Unsupported baud rate: "
+                                                "%d.\n", port->gs.baud);
                                 break;
                         }
-                case 115200: 
+                case 115200:
                         if (port->board->ta_type == MOD_TA) {
                                 t = CSR_9600;
-                                printk (KERN_INFO "sx: Unsupported baud rate: %d.\n", port->gs.baud);
+                                printk(KERN_INFO "sx: Unsupported baud rate: "
+                                                "%d.\n", port->gs.baud);
                                 break;
                         } else {
                                 t = CSR_110;
                                 break;
                         }
-                case 0      :t = -1;
-                                                                 break;
+                case 0:
+                        t = -1;
+                        break;
                 default:
                         t = CSR_9600;
-                        printk (KERN_INFO "sx: Unsupported baud rate: %d.\n", port->gs.baud);
+                        printk(KERN_INFO "sx: Unsupported baud rate: %d.\n",
+                                        port->gs.baud);
                         break;
                 }
 #undef e
                 if (t >= 0) {
-                        sx_setsignals (port, 1, -1);
-                        sx_write_channel_byte (port, hi_csr, t * 0x11);
+                        sx_setsignals(port, 1, -1);
+                        sx_write_channel_byte(port, hi_csr, t * 0x11);
                 } else {
-                        sx_setsignals (port, 0, -1);
+                        sx_setsignals(port, 0, -1);
                 }
         }
 }
 
-
 /* Simon Allen's version of this routine was 225 lines long. 85 is a lot
    better. -- REW */
 
-static int sx_set_real_termios (void *ptr)
+static int sx_set_real_termios(void *ptr)
 {
         struct sx_port *port = ptr;
 
@@ -909,80 +939,83 @@ static int sx_set_real_termios (void *ptr)
            belongs (next to the drop dtr if baud == 0) -- REW */
         /* sx_setsignals (port, 1, -1); */
 
-        sx_set_baud (port);
+        sx_set_baud(port);
 
 #define CFLAG port->gs.tty->termios->c_cflag
-        sx_write_channel_byte (port, hi_mr1,
-                               (C_PARENB (port->gs.tty)? MR1_WITH:MR1_NONE) |
-                               (C_PARODD (port->gs.tty)? MR1_ODD:MR1_EVEN) |
-                               (C_CRTSCTS(port->gs.tty)? MR1_RTS_RXFLOW:0) |
-                               (((CFLAG & CSIZE)==CS8) ? MR1_8_BITS:0) |
-                               (((CFLAG & CSIZE)==CS7) ? MR1_7_BITS:0) |
-                               (((CFLAG & CSIZE)==CS6) ? MR1_6_BITS:0) |
-                               (((CFLAG & CSIZE)==CS5) ? MR1_5_BITS:0) );
-
-        sx_write_channel_byte (port, hi_mr2,
-                               (C_CRTSCTS(port->gs.tty)?MR2_CTS_TXFLOW:0) |
-                               (C_CSTOPB (port->gs.tty)?MR2_2_STOP:MR2_1_STOP));
+        sx_write_channel_byte(port, hi_mr1,
+                        (C_PARENB(port->gs.tty) ? MR1_WITH : MR1_NONE) |
+                        (C_PARODD(port->gs.tty) ? MR1_ODD : MR1_EVEN) |
+                        (C_CRTSCTS(port->gs.tty) ? MR1_RTS_RXFLOW : 0) |
+                        (((CFLAG & CSIZE) == CS8) ? MR1_8_BITS : 0) |
+                        (((CFLAG & CSIZE) == CS7) ? MR1_7_BITS : 0) |
+                        (((CFLAG & CSIZE) == CS6) ? MR1_6_BITS : 0) |
+                        (((CFLAG & CSIZE) == CS5) ? MR1_5_BITS : 0));
+
+        sx_write_channel_byte(port, hi_mr2,
+                        (C_CRTSCTS(port->gs.tty) ? MR2_CTS_TXFLOW : 0) |
+                        (C_CSTOPB(port->gs.tty) ? MR2_2_STOP :
+                        MR2_1_STOP));
 
         switch (CFLAG & CSIZE) {
-        case CS8:sx_write_channel_byte (port, hi_mask, 0xff);break;
-        case CS7:sx_write_channel_byte (port, hi_mask, 0x7f);break;
-        case CS6:sx_write_channel_byte (port, hi_mask, 0x3f);break;
-        case CS5:sx_write_channel_byte (port, hi_mask, 0x1f);break;
+        case CS8:
+                sx_write_channel_byte(port, hi_mask, 0xff);
+                break;
+        case CS7:
+                sx_write_channel_byte(port, hi_mask, 0x7f);
+                break;
+        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: %u\n", CFLAG & CSIZE);
+                printk(KERN_INFO "sx: Invalid wordsize: %u\n", CFLAG & CSIZE);
                 break;
         }
 
-        sx_write_channel_byte (port, hi_prtcl, 
-                               (I_IXON   (port->gs.tty)?SP_TXEN:0) |
-                               (I_IXOFF  (port->gs.tty)?SP_RXEN:0) |
-                               (I_IXANY  (port->gs.tty)?SP_TANY:0) |
-                               SP_DCEN);
+        sx_write_channel_byte(port, hi_prtcl,
+                        (I_IXON(port->gs.tty) ? SP_TXEN : 0) |
+                        (I_IXOFF(port->gs.tty) ? SP_RXEN : 0) |
+                        (I_IXANY(port->gs.tty) ? SP_TANY : 0) | SP_DCEN);
 
-        sx_write_channel_byte (port, hi_break, 
-                               (I_IGNBRK(port->gs.tty)?BR_IGN:0 |
-                                I_BRKINT(port->gs.tty)?BR_INT:0));
+        sx_write_channel_byte(port, hi_break,
+                        (I_IGNBRK(port->gs.tty) ? BR_IGN : 0 |
+                        I_BRKINT(port->gs.tty) ? BR_INT : 0));
 
-        sx_write_channel_byte (port, hi_txon,  START_CHAR (port->gs.tty));
-        sx_write_channel_byte (port, hi_rxon,  START_CHAR (port->gs.tty));
-        sx_write_channel_byte (port, hi_txoff, STOP_CHAR  (port->gs.tty));
-        sx_write_channel_byte (port, hi_rxoff, STOP_CHAR  (port->gs.tty));
+        sx_write_channel_byte(port, hi_txon, START_CHAR(port->gs.tty));
+        sx_write_channel_byte(port, hi_rxon, START_CHAR(port->gs.tty));
+        sx_write_channel_byte(port, hi_txoff, STOP_CHAR(port->gs.tty));
+        sx_write_channel_byte(port, hi_rxoff, STOP_CHAR(port->gs.tty));
 
         sx_reconfigure_port(port);
 
         /* Tell line discipline whether we will do input cooking */
-        if(I_OTHER(port->gs.tty)) {
+        if (I_OTHER(port->gs.tty)) {
                 clear_bit(TTY_HW_COOK_IN, &port->gs.tty->flags);
         } else {
                 set_bit(TTY_HW_COOK_IN, &port->gs.tty->flags);
         }
-        sx_dprintk (SX_DEBUG_TERMIOS, "iflags: %x(%d) ",
-                    port->gs.tty->termios->c_iflag, 
-                    I_OTHER(port->gs.tty));
-
+        sx_dprintk(SX_DEBUG_TERMIOS, "iflags: %x(%d) ",
+                        port->gs.tty->termios->c_iflag, I_OTHER(port->gs.tty));
 
 /* Tell line discipline whether we will do output cooking.
  * If OPOST is set and no other output flags are set then we can do output
  * processing.  Even if only *one* other flag in the O_OTHER group is set
  * we do cooking in software.
  */
-        if(O_OPOST(port->gs.tty) && !O_OTHER(port->gs.tty)) {
+        if (O_OPOST(port->gs.tty) && !O_OTHER(port->gs.tty)) {
                 set_bit(TTY_HW_COOK_OUT, &port->gs.tty->flags);
         } else {
                 clear_bit(TTY_HW_COOK_OUT, &port->gs.tty->flags);
         }
-        sx_dprintk (SX_DEBUG_TERMIOS, "oflags: %x(%d)\n",
-                    port->gs.tty->termios->c_oflag, 
-                    O_OTHER(port->gs.tty));
+        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); */
-        func_exit ();
+        func_exit();
         return 0;
 }
 
-
-
 /* ********************************************************************** *
  *                   the interrupt related routines                       *
  * ********************************************************************** */
@@ -998,245 +1031,260 @@ static int sx_set_real_termios (void *ptr)
    know I'm dead against that, but I think it is required in this
    case.  */
 
-
-static void sx_transmit_chars (struct sx_port *port)
+static void sx_transmit_chars(struct sx_port *port)
 {
         int c;
         int tx_ip;
         int txroom;
 
-        func_enter2 ();
-        sx_dprintk (SX_DEBUG_TRANSMIT, "Port %p: transmit %d chars\n", 
-                    port, port->gs.xmit_cnt);
+        func_enter2();
+        sx_dprintk(SX_DEBUG_TRANSMIT, "Port %p: transmit %d chars\n",
+                        port, port->gs.xmit_cnt);
 
-        if (test_and_set_bit (SX_PORT_TRANSMIT_LOCK, &port->locks)) {
+        if (test_and_set_bit(SX_PORT_TRANSMIT_LOCK, &port->locks)) {
                 return;
         }
 
         while (1) {
                 c = port->gs.xmit_cnt;
 
-                sx_dprintk (SX_DEBUG_TRANSMIT, "Copying %d ", c);
-                tx_ip  = sx_read_channel_byte (port, hi_txipos);
+                sx_dprintk(SX_DEBUG_TRANSMIT, "Copying %d ", c);
+                tx_ip = sx_read_channel_byte(port, hi_txipos);
 
                 /* Took me 5 minutes to deduce this formula. 
                    Luckily it is literally in the manual in section 6.5.4.3.5 */
-                txroom = (sx_read_channel_byte (port, hi_txopos) - tx_ip - 1) & 0xff;
+                txroom = (sx_read_channel_byte(port, hi_txopos) - tx_ip - 1) &
+                                0xff;
 
                 /* Don't copy more bytes than there is room for in the buffer */
                 if (c > txroom)
                         c = txroom;
-                sx_dprintk (SX_DEBUG_TRANSMIT, " %d(%d) ", c, txroom );
+                sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%d) ", c, txroom);
 
                 /* Don't copy past the end of the hardware transmit buffer */
-                if (c > 0x100 - tx_ip) 
+                if (c > 0x100 - tx_ip)
                         c = 0x100 - tx_ip;
 
-                sx_dprintk (SX_DEBUG_TRANSMIT, " %d(%d) ", c, 0x100-tx_ip );
+                sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%d) ", c, 0x100 - tx_ip);
 
                 /* Don't copy pas the end of the source buffer */
-                if (c > SERIAL_XMIT_SIZE - port->gs.xmit_tail) 
+                if (c > SERIAL_XMIT_SIZE - port->gs.xmit_tail)
                         c = SERIAL_XMIT_SIZE - port->gs.xmit_tail;
 
-                sx_dprintk (SX_DEBUG_TRANSMIT, " %d(%ld) \n", 
-                            c, SERIAL_XMIT_SIZE- port->gs.xmit_tail);
-
-                /* If for one reason or another, we can't copy more data, we're done! */
-                if (c == 0) break;
+                sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%ld) \n",
+                                c, SERIAL_XMIT_SIZE - port->gs.xmit_tail);
 
+                /* If for one reason or another, we can't copy more data, we're
+                   done! */
+                if (c == 0)
+                        break;
 
-                memcpy_toio (port->board->base + CHAN_OFFSET(port,hi_txbuf) + tx_ip, 
-                             port->gs.xmit_buf + port->gs.xmit_tail, c);
+                memcpy_toio(port->board->base + CHAN_OFFSET(port, hi_txbuf) +
+                        tx_ip, port->gs.xmit_buf + port->gs.xmit_tail, c);
 
                 /* Update the pointer in the card */
-                sx_write_channel_byte (port, hi_txipos, (tx_ip+c) & 0xff);
+                sx_write_channel_byte(port, hi_txipos, (tx_ip + c) & 0xff);
 
                 /* Update the kernel buffer end */
-                port->gs.xmit_tail = (port->gs.xmit_tail + c) & (SERIAL_XMIT_SIZE-1);
+                port->gs.xmit_tail = (port->gs.xmit_tail + c) &
+                                (SERIAL_XMIT_SIZE - 1);
 
                 /* This one last. (this is essential)
-                   It would allow others to start putting more data into the buffer! */
+                   It would allow others to start putting more data into the
+                   buffer! */
                 port->gs.xmit_cnt -= c;
         }
 
         if (port->gs.xmit_cnt == 0) {
-                sx_disable_tx_interrupts (port);
+                sx_disable_tx_interrupts(port);
         }
 
         if ((port->gs.xmit_cnt <= port->gs.wakeup_chars) && port->gs.tty) {
                 tty_wakeup(port->gs.tty);
-                sx_dprintk (SX_DEBUG_TRANSMIT, "Waking up.... ldisc (%d)....\n",
-                            port->gs.wakeup_chars); 
+                sx_dprintk(SX_DEBUG_TRANSMIT, "Waking up.... ldisc (%d)....\n",
+                                port->gs.wakeup_chars);
         }
 
-        clear_bit (SX_PORT_TRANSMIT_LOCK, &port->locks);
-        func_exit ();
+        clear_bit(SX_PORT_TRANSMIT_LOCK, &port->locks);
+        func_exit();
 }
 
-
 /* Note the symmetry between receiving chars and transmitting them!
    Note: The kernel should have implemented both a receive buffer and
    a transmit buffer. */
 
 /* Inlined: Called only once. Remove the inline when you add another call */
-static inline void sx_receive_chars (struct sx_port *port)
+static inline void sx_receive_chars(struct sx_port *port)
 {
         int c;
         int rx_op;
         struct tty_struct *tty;
-        int copied=0;
+        int copied = 0;
         unsigned char *rp;
 
-        func_enter2 ();
+        func_enter2();
         tty = port->gs.tty;
         while (1) {
-                rx_op = sx_read_channel_byte (port, hi_rxopos);
-                c = (sx_read_channel_byte (port, hi_rxipos) - rx_op) & 0xff;
+                rx_op = sx_read_channel_byte(port, hi_rxopos);
+                c = (sx_read_channel_byte(port, hi_rxipos) - rx_op) & 0xff;
 
-                sx_dprintk (SX_DEBUG_RECEIVE, "rxop=%d, c = %d.\n", rx_op, c); 
+                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;
+                if (rx_op + c > 0x100)
+                        c = 0x100 - rx_op;
 
-                sx_dprintk (SX_DEBUG_RECEIVE, "c = %d.\n", c);
+                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); 
+                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;
+                if (c == 0)
+                        break;
 
-                sx_dprintk (SX_DEBUG_RECEIVE , "Copying over %d chars. First is %d at %lx\n", c, 
-                            read_sx_byte (port->board, CHAN_OFFSET(port,hi_rxbuf) + rx_op),
-                            CHAN_OFFSET(port, hi_rxbuf)); 
-                memcpy_fromio (rp,
-                               port->board->base + CHAN_OFFSET(port,hi_rxbuf) + rx_op, c);
+                sx_dprintk(SX_DEBUG_RECEIVE, "Copying over %d chars. First is "
+                                "%d at %lx\n", c, read_sx_byte(port->board,
+                                        CHAN_OFFSET(port, hi_rxbuf) + rx_op),
+                                CHAN_OFFSET(port, hi_rxbuf));
+                memcpy_fromio(rp, port->board->base +
+                                CHAN_OFFSET(port, hi_rxbuf) + rx_op, c);
 
                 /* This one last. ( Not essential.)
-                   It allows the card to start putting more data into the buffer! 
+                   It allows the card to start putting more data into the
+                   buffer!
                    Update the pointer in the card */
-                sx_write_channel_byte (port, hi_rxopos, (rx_op + c) & 0xff);
+                sx_write_channel_byte(port, hi_rxopos, (rx_op + c) & 0xff);
 
                 copied += c;
         }
         if (copied) {
                 struct timeval tv;
 
-                do_gettimeofday (&tv);
-                sx_dprintk (SX_DEBUG_RECEIVE, 
-                            "pushing flipq port %d (%3d chars): %d.%06d  (%d/%d)\n", 
-                            port->line, copied, 
-                            (int) (tv.tv_sec % 60), (int)tv.tv_usec, tty->raw, tty->real_raw);
+                do_gettimeofday(&tv);
+                sx_dprintk(SX_DEBUG_RECEIVE, "pushing flipq port %d (%3d "
+                                "chars): %d.%06d  (%d/%d)\n", port->line,
+                                copied, (int)(tv.tv_sec % 60), (int)tv.tv_usec,
+                                tty->raw, tty->real_raw);
 
-                /* Tell the rest of the system the news. Great news. New characters! */
-                tty_flip_buffer_push (tty);
+                /* Tell the rest of the system the news. Great news. New
+                   characters! */
+                tty_flip_buffer_push(tty);
                 /*    tty_schedule_flip (tty); */
         }
 
-        func_exit ();
+        func_exit();
 }
 
 /* Inlined: it is called only once. Remove the inline if you add another 
    call */
-static inline void sx_check_modem_signals (struct sx_port *port)
+static inline void sx_check_modem_signals(struct sx_port *port)
 {
         int hi_state;
         int c_dcd;
 
-        hi_state = sx_read_channel_byte (port, hi_state);
-        sx_dprintk (SX_DEBUG_MODEMSIGNALS, "Checking modem signals (%d/%d)\n",
-                    port->c_dcd, sx_get_CD (port));
+        hi_state = sx_read_channel_byte(port, hi_state);
+        sx_dprintk(SX_DEBUG_MODEMSIGNALS, "Checking modem signals (%d/%d)\n",
+                        port->c_dcd, sx_get_CD(port));
 
         if (hi_state & ST_BREAK) {
                 hi_state &= ~ST_BREAK;
-                sx_dprintk (SX_DEBUG_MODEMSIGNALS, "got a break.\n");
-                sx_write_channel_byte (port, hi_state, hi_state);
-                gs_got_break (&port->gs);
+                sx_dprintk(SX_DEBUG_MODEMSIGNALS, "got a break.\n");
+                sx_write_channel_byte(port, hi_state, hi_state);
+                gs_got_break(&port->gs);
         }
         if (hi_state & ST_DCD) {
                 hi_state &= ~ST_DCD;
-                sx_dprintk (SX_DEBUG_MODEMSIGNALS, "got a DCD change.\n");
-                sx_write_channel_byte (port, hi_state, hi_state);
-                c_dcd = sx_get_CD (port);
-                sx_dprintk (SX_DEBUG_MODEMSIGNALS, "DCD is now %d\n", c_dcd);
+                sx_dprintk(SX_DEBUG_MODEMSIGNALS, "got a DCD change.\n");
+                sx_write_channel_byte(port, hi_state, hi_state);
+                c_dcd = sx_get_CD(port);
+                sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD is now %d\n", c_dcd);
                 if (c_dcd != port->c_dcd) {
                         port->c_dcd = c_dcd;
-                        if (sx_get_CD (port)) {
+                        if (sx_get_CD(port)) {
                                 /* DCD went UP */
-                                if ((sx_read_channel_byte(port, hi_hstat) != HS_IDLE_CLOSED) &&
-                                                !(port->gs.tty->termios->c_cflag & CLOCAL) ) {
-                                        /* Are we blocking in open?*/
-                                        sx_dprintk (SX_DEBUG_MODEMSIGNALS, "DCD active, unblocking open\n");
-                                        wake_up_interruptible(&port->gs.open_wait);
+                                if ((sx_read_channel_byte(port, hi_hstat) !=
+                                                HS_IDLE_CLOSED) &&
+                                                !(port->gs.tty->termios->
+                                                        c_cflag & CLOCAL)) {
+                                        /* Are we blocking in open? */
+                                        sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
+                                                "active, unblocking open\n");
+                                        wake_up_interruptible(&port->gs.
+                                                        open_wait);
                                 } else {
-                                        sx_dprintk (SX_DEBUG_MODEMSIGNALS, "DCD raised. Ignoring.\n");
+                                        sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
+                                                "raised. Ignoring.\n");
                                 }
                         } else {
                                 /* DCD went down! */
-                                if (!(port->gs.tty->termios->c_cflag & CLOCAL) ) {
-                                        sx_dprintk (SX_DEBUG_MODEMSIGNALS, "DCD dropped. hanging up....\n");
-                                        tty_hangup (port->gs.tty);
+                                if (!(port->gs.tty->termios->c_cflag & CLOCAL)){
+                                        sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
+                                                "dropped. hanging up....\n");
+                                        tty_hangup(port->gs.tty);
                                 } else {
-                                        sx_dprintk (SX_DEBUG_MODEMSIGNALS, "DCD dropped. ignoring.\n");
+                                        sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
+                                                "dropped. ignoring.\n");
                                 }
                         }
                 } else {
-                        sx_dprintk (SX_DEBUG_MODEMSIGNALS, "Hmmm. card told us DCD changed, but it didn't.\n");
+                        sx_dprintk(SX_DEBUG_MODEMSIGNALS, "Hmmm. card told us "
+                                "DCD changed, but it didn't.\n");
                 }
         }
 }
 
-
 /* This is what an interrupt routine should look like. 
  * Small, elegant, clear.
  */
 
-static irqreturn_t sx_interrupt (int irq, void *ptr, struct pt_regs *regs)
+static irqreturn_t sx_interrupt(int irq, void *ptr)
 {
         struct sx_board *board = ptr;
         struct sx_port *port;
         int i;
 
-        func_enter ();
-        sx_dprintk (SX_DEBUG_FLOW, "sx: enter sx_interrupt (%d/%d)\n", irq, board->irq); 
+        func_enter();
+        sx_dprintk(SX_DEBUG_FLOW, "sx: enter sx_interrupt (%d/%d)\n", irq,
+                        board->irq);
 
         /* AAargh! The order in which to do these things is essential and
            not trivial. 
 
            - Rate limit goes before "recursive". Otherwise a series of
-             recursive calls will hang the machine in the interrupt routine. 
+           recursive calls will hang the machine in the interrupt routine.
 
            - hardware twiddling goes before "recursive". Otherwise when we
-             poll the card, and a recursive interrupt happens, we won't
-             ack the card, so it might keep on interrupting us. (especially
-             level sensitive interrupt systems like PCI).
+           poll the card, and a recursive interrupt happens, we won't
+           ack the card, so it might keep on interrupting us. (especially
+           level sensitive interrupt systems like PCI).
 
            - Rate limit goes before hardware twiddling. Otherwise we won't
-             catch a card that has gone bonkers.
+           catch a card that has gone bonkers.
 
            - The "initialized" test goes after the hardware twiddling. Otherwise
-             the card will stick us in the interrupt routine again.
+           the card will stick us in the interrupt routine again.
 
            - The initialized test goes before recursive. 
-        */
-
-
+         */
 
 #ifdef IRQ_RATE_LIMIT
         /* Aaargh! I'm ashamed. This costs more lines-of-code than the
-           actual interrupt routine!. (Well, used to when I wrote that comment) */
+           actual interrupt routine!. (Well, used to when I wrote that
+           comment) */
         {
                 static int lastjif;
-                static int nintr=0;
+                static int nintr = 0;
 
                 if (lastjif == jiffies) {
                         if (++nintr > IRQ_RATE_LIMIT) {
-                                free_irq (board->irq, board);
-                                printk (KERN_ERR "sx: Too many interrupts. Turning off interrupt %d.\n", 
-                                              board->irq);
+                                free_irq(board->irq, board);
+                                printk(KERN_ERR "sx: Too many interrupts. "
+                                                "Turning off interrupt %d.\n",
+                                                board->irq);
                         }
                 } else {
                         lastjif = jiffies;
@@ -1245,19 +1293,20 @@ static irqreturn_t sx_interrupt (int irq, void *ptr, struct pt_regs *regs)
         }
 #endif
 
-
         if (board->irq == irq) {
                 /* Tell the card we've noticed the interrupt. */
 
-                sx_write_board_word (board, cc_int_pending, 0);
-                if (IS_SX_BOARD (board)) {
-                        write_sx_byte (board, SX_RESET_IRQ, 1);
+                sx_write_board_word(board, cc_int_pending, 0);
+                if (IS_SX_BOARD(board)) {
+                        write_sx_byte(board, SX_RESET_IRQ, 1);
                 } else if (IS_EISA_BOARD(board)) {
-                        inb(board->eisa_base+0xc03);
-                        write_sx_word(board, 8, 0); 
+                        inb(board->eisa_base + 0xc03);
+                        write_sx_word(board, 8, 0);
                 } else {
-                        write_sx_byte (board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_CLEAR);
-                        write_sx_byte (board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
+                        write_sx_byte(board, SI2_ISA_INTCLEAR,
+                                        SI2_ISA_INTCLEAR_CLEAR);
+                        write_sx_byte(board, SI2_ISA_INTCLEAR,
+                                        SI2_ISA_INTCLEAR_SET);
                 }
         }
 
@@ -1266,53 +1315,48 @@ static irqreturn_t sx_interrupt (int irq, void *ptr, struct pt_regs *regs)
         if (!(board->flags & SX_BOARD_INITIALIZED))
                 return IRQ_HANDLED;
 
-        if (test_and_set_bit (SX_BOARD_INTR_LOCK, &board->locks)) {
-                printk (KERN_ERR "Recursive interrupt! (%d)\n", board->irq);
+        if (test_and_set_bit(SX_BOARD_INTR_LOCK, &board->locks)) {
+                printk(KERN_ERR "Recursive interrupt! (%d)\n", board->irq);
                 return IRQ_HANDLED;
         }
 
-         for (i=0;i<board->nports;i++) {
+        for (i = 0; i < board->nports; i++) {
                 port = &board->ports[i];
                 if (port->gs.flags & GS_ACTIVE) {
-                        if (sx_read_channel_byte (port, hi_state)) {
-                                sx_dprintk (SX_DEBUG_INTERRUPTS, 
-                                            "Port %d: modem signal change?... \n", i);
-                                sx_check_modem_signals (port); 
+                        if (sx_read_channel_byte(port, hi_state)) {
+                                sx_dprintk(SX_DEBUG_INTERRUPTS, "Port %d: "
+                                                "modem signal change?... \n",i);
+                                sx_check_modem_signals(port);
                         }
                         if (port->gs.xmit_cnt) {
-                                sx_transmit_chars (port);
+                                sx_transmit_chars(port);
                         }
                         if (!(port->gs.flags & SX_RX_THROTTLE)) {
-                                sx_receive_chars (port);
+                                sx_receive_chars(port);
                         }
                 }
         }
 
-        clear_bit (SX_BOARD_INTR_LOCK, &board->locks);
+        clear_bit(SX_BOARD_INTR_LOCK, &board->locks);
 
-        sx_dprintk (SX_DEBUG_FLOW, "sx: exit sx_interrupt (%d/%d)\n", irq, board->irq); 
-        func_exit ();
+        sx_dprintk(SX_DEBUG_FLOW, "sx: exit sx_interrupt (%d/%d)\n", irq,
+                        board->irq);
+        func_exit();
         return IRQ_HANDLED;
 }
 
-
-static void sx_pollfunc (unsigned long data)
+static void sx_pollfunc(unsigned long data)
 {
-        struct sx_board *board = (struct sx_board *) data;
-
-        func_enter ();
+        struct sx_board *board = (struct sx_board *)data;
 
-        sx_interrupt (0, board, NULL);
+        func_enter();
 
-        init_timer(&board->timer);
+        sx_interrupt(0, board);
 
-        board->timer.expires = jiffies + sx_poll;
-        add_timer (&board->timer);
-        func_exit ();
+        mod_timer(&board->timer, jiffies + sx_poll);
+        func_exit();
 }
 
-
-
 /* ********************************************************************** *
  *                Here are the routines that actually                     *
  *              interface with the generic_serial driver                  *
@@ -1321,9 +1365,9 @@ static void sx_pollfunc (unsigned long data)
 /* Ehhm. I don't know how to fiddle with interrupts on the SX card. --REW */
 /* Hmm. Ok I figured it out. You don't.  */
 
-static void sx_disable_tx_interrupts (void * ptr) 
+static void sx_disable_tx_interrupts(void *ptr)
 {
-        struct sx_port *port = ptr; 
+        struct sx_port *port = ptr;
         func_enter2();
 
         port->gs.flags &= ~GS_TX_INTEN;
@@ -1331,30 +1375,28 @@ static void sx_disable_tx_interrupts (void * ptr)
         func_exit();
 }
 
-
-static void sx_enable_tx_interrupts (void * ptr) 
+static void sx_enable_tx_interrupts(void *ptr)
 {
-        struct sx_port *port = ptr; 
+        struct sx_port *port = ptr;
         int data_in_buffer;
         func_enter2();
 
         /* First transmit the characters that we're supposed to */
-        sx_transmit_chars (port);
+        sx_transmit_chars(port);
 
         /* The sx card will never interrupt us if we don't fill the buffer
            past 25%. So we keep considering interrupts off if that's the case. */
-        data_in_buffer = (sx_read_channel_byte (port, hi_txipos) - 
-                          sx_read_channel_byte (port, hi_txopos)) & 0xff;
+        data_in_buffer = (sx_read_channel_byte(port, hi_txipos) -
+                          sx_read_channel_byte(port, hi_txopos)) & 0xff;
 
         /* XXX Must be "HIGH_WATER" for SI card according to doc. */
-        if (data_in_buffer < LOW_WATER) 
+        if (data_in_buffer < LOW_WATER)
                 port->gs.flags &= ~GS_TX_INTEN;
 
         func_exit();
 }
 
-
-static void sx_disable_rx_interrupts (void * ptr) 
+static void sx_disable_rx_interrupts(void *ptr)
 {
         /*  struct sx_port *port = ptr; */
         func_enter();
@@ -1362,7 +1404,7 @@ static void sx_disable_rx_interrupts (void * ptr)
         func_exit();
 }
 
-static void sx_enable_rx_interrupts (void * ptr) 
+static void sx_enable_rx_interrupts(void *ptr)
 {
         /*  struct sx_port *port = ptr; */
         func_enter();
@@ -1370,55 +1412,48 @@ static void sx_enable_rx_interrupts (void * ptr)
         func_exit();
 }
 
-
 /* Jeez. Isn't this simple? */
-static int sx_get_CD (void * ptr) 
+static int sx_get_CD(void *ptr)
 {
         struct sx_port *port = ptr;
         func_enter2();
 
         func_exit();
-        return ((sx_read_channel_byte (port, hi_ip) & IP_DCD) != 0);
+        return ((sx_read_channel_byte(port, hi_ip) & IP_DCD) != 0);
 }
 
-
 /* Jeez. Isn't this simple? */
-static int sx_chars_in_buffer (void * ptr) 
+static int sx_chars_in_buffer(void *ptr)
 {
         struct sx_port *port = ptr;
         func_enter2();
 
         func_exit();
-        return ((sx_read_channel_byte (port, hi_txipos) - 
-                 sx_read_channel_byte (port, hi_txopos)) & 0xff);
+        return ((sx_read_channel_byte(port, hi_txipos) -
+                 sx_read_channel_byte(port, hi_txopos)) & 0xff);
 }
 
-
-static void sx_shutdown_port (void * ptr) 
+static void sx_shutdown_port(void *ptr)
 {
-        struct sx_port *port = ptr; 
+        struct sx_port *port = ptr;
 
         func_enter();
 
-        port->gs.flags &= ~ GS_ACTIVE;
+        port->gs.flags &= ~GS_ACTIVE;
         if (port->gs.tty && (port->gs.tty->termios->c_cflag & HUPCL)) {
-                sx_setsignals (port, 0, 0);
+                sx_setsignals(port, 0, 0);
                 sx_reconfigure_port(port);
         }
 
         func_exit();
 }
 
-
-
-
-
 /* ********************************************************************** *
  *                Here are the routines that actually                     *
  *               interface with the rest of the system                    *
  * ********************************************************************** */
 
-static int sx_open  (struct tty_struct * tty, struct file * filp)
+static int sx_open(struct tty_struct *tty, struct file *filp)
 {
         struct sx_port *port;
         int retval, line;
@@ -1431,18 +1466,18 @@ static int sx_open  (struct tty_struct * tty, struct file * filp)
         }
 
         line = tty->index;
-        sx_dprintk (SX_DEBUG_OPEN, "%d: opening line %d. tty=%p ctty=%p, np=%d)\n", 
-                    current->pid, line, tty, current->signal->tty, sx_nports);
+        sx_dprintk(SX_DEBUG_OPEN, "%d: opening line %d. tty=%p ctty=%p, "
+                        "np=%d)\n", current->pid, line, tty,
+                        current->signal->tty, sx_nports);
 
         if ((line < 0) || (line >= SX_NPORTS) || (line >= sx_nports))
                 return -ENODEV;
 
-        port = & sx_ports[line];
+        port = &sx_ports[line];
         port->c_dcd = 0; /* Make sure that the first interrupt doesn't detect a
-                            1 -> 0 transition. */
+                            1 -> 0 transition. */
 
-
-        sx_dprintk (SX_DEBUG_OPEN, "port = %p c_dcd = %d\n", port, port->c_dcd);
+        sx_dprintk(SX_DEBUG_OPEN, "port = %p c_dcd = %d\n", port, port->c_dcd);
 
         spin_lock_irqsave(&port->gs.driver_lock, flags);
 
@@ -1451,13 +1486,13 @@ static int sx_open  (struct tty_struct * tty, struct file * filp)
         port->gs.count++;
         spin_unlock_irqrestore(&port->gs.driver_lock, flags);
 
-        sx_dprintk (SX_DEBUG_OPEN, "starting port\n");
+        sx_dprintk(SX_DEBUG_OPEN, "starting port\n");
 
         /*
          * Start up serial port
          */
         retval = gs_init_port(&port->gs);
-        sx_dprintk (SX_DEBUG_OPEN, "done gs_init\n");
+        sx_dprintk(SX_DEBUG_OPEN, "done gs_init\n");
         if (retval) {
                 port->gs.count--;
                 return retval;
@@ -1465,19 +1500,20 @@ static int sx_open  (struct tty_struct * tty, struct file * filp)
 
         port->gs.flags |= GS_ACTIVE;
         if (port->gs.count <= 1)
-                sx_setsignals (port, 1,1);
+                sx_setsignals(port, 1, 1);
 
 #if 0
         if (sx_debug & SX_DEBUG_OPEN)
-                my_hd (port, sizeof (*port));
+                my_hd(port, sizeof(*port));
 #else
         if (sx_debug & SX_DEBUG_OPEN)
-                my_hd_io (port->board->base + port->ch_base, sizeof (*port));
+                my_hd_io(port->board->base + port->ch_base, sizeof(*port));
 #endif
 
         if (port->gs.count <= 1) {
-                if (sx_send_command (port, HS_LOPEN, -1, HS_IDLE_OPEN) != 1) {
-                        printk (KERN_ERR "sx: Card didn't respond to LOPEN command.\n");
+                if (sx_send_command(port, HS_LOPEN, -1, HS_IDLE_OPEN) != 1) {
+                        printk(KERN_ERR "sx: Card didn't respond to LOPEN "
+                                        "command.\n");
                         spin_lock_irqsave(&port->gs.driver_lock, flags);
                         port->gs.count--;
                         spin_unlock_irqrestore(&port->gs.driver_lock, flags);
@@ -1486,75 +1522,76 @@ static int sx_open  (struct tty_struct * tty, struct file * filp)
         }
 
         retval = gs_block_til_ready(port, filp);
-        sx_dprintk (SX_DEBUG_OPEN, "Block til ready returned %d. Count=%d\n", 
-                    retval, port->gs.count);
+        sx_dprintk(SX_DEBUG_OPEN, "Block til ready returned %d. Count=%d\n",
+                        retval, port->gs.count);
 
         if (retval) {
-                /* 
-                 * Don't lower gs.count here because sx_close() will be called later
-                 */ 
+/*
+ * Don't lower gs.count here because sx_close() will be called later
+ */
 
                 return retval;
         }
         /* tty->low_latency = 1; */
 
-        port->c_dcd = sx_get_CD (port);
-        sx_dprintk (SX_DEBUG_OPEN, "at open: cd=%d\n", port->c_dcd);
+        port->c_dcd = sx_get_CD(port);
+        sx_dprintk(SX_DEBUG_OPEN, "at open: cd=%d\n", port->c_dcd);
 
         func_exit();
         return 0;
 
 }
 
-
-static void sx_close (void *ptr)
+static void sx_close(void *ptr)
 {
-        struct sx_port *port = ptr; 
+        struct sx_port *port = ptr;
         /* Give the port 5 seconds to close down. */
-        int to = 5 * HZ; 
+        int to = 5 * HZ;
 
-        func_enter ();
+        func_enter();
 
-        sx_setsignals (port, 0, 0);
-        sx_reconfigure_port(port);      
-        sx_send_command (port, HS_CLOSE, 0, 0);
+        sx_setsignals(port, 0, 0);
+        sx_reconfigure_port(port);
+        sx_send_command(port, HS_CLOSE, 0, 0);
 
-        while (to-- && (sx_read_channel_byte (port, hi_hstat) != HS_IDLE_CLOSED))
+        while (to-- && (sx_read_channel_byte(port, hi_hstat) != HS_IDLE_CLOSED))
                 if (msleep_interruptible(10))
                         break;
-        if (sx_read_channel_byte (port, hi_hstat) != HS_IDLE_CLOSED) {
-                if (sx_send_command (port, HS_FORCE_CLOSED, -1, HS_IDLE_CLOSED) != 1) {
-                        printk (KERN_ERR 
-                                "sx: sent the force_close command, but card didn't react\n");
+        if (sx_read_channel_byte(port, hi_hstat) != HS_IDLE_CLOSED) {
+                if (sx_send_command(port, HS_FORCE_CLOSED, -1, HS_IDLE_CLOSED)
+                                != 1) {
+                        printk(KERN_ERR "sx: sent the force_close command, but "
+                                        "card didn't react\n");
                 } else
-                        sx_dprintk (SX_DEBUG_CLOSE, "sent the force_close command.\n");
+                        sx_dprintk(SX_DEBUG_CLOSE, "sent the force_close "
+                                        "command.\n");
         }
 
-        sx_dprintk (SX_DEBUG_CLOSE, "waited %d jiffies for close. count=%d\n", 
-                    5 * HZ - to - 1, port->gs.count);
+        sx_dprintk(SX_DEBUG_CLOSE, "waited %d jiffies for close. count=%d\n",
+                        5 * HZ - to - 1, port->gs.count);
 
-        if(port->gs.count) {
-                sx_dprintk(SX_DEBUG_CLOSE, "WARNING port count:%d\n", port->gs.count);
-                //printk ("%s SETTING port count to zero: %p count: %d\n", __FUNCTION__, port, port->gs.count);
-                //port->gs.count = 0;
+        if (port->gs.count) {
+                sx_dprintk(SX_DEBUG_CLOSE, "WARNING port count:%d\n",
+                                port->gs.count);
+                /*printk("%s SETTING port count to zero: %p count: %d\n",
+                                __FUNCTION__, port, port->gs.count);
+                port->gs.count = 0;*/
         }
 
-        func_exit ();
+        func_exit();
 }
 
-
-
 /* This is relatively thorough. But then again it is only 20 lines. */
-#define MARCHUP    for (i=min;i<max;i++) 
-#define MARCHDOWN  for (i=max-1;i>=min;i--)
-#define W0         write_sx_byte (board, i, 0x55)
-#define W1         write_sx_byte (board, i, 0xaa)
-#define R0         if (read_sx_byte (board, i) != 0x55) return 1
-#define R1         if (read_sx_byte (board, i) != 0xaa) return 1
+#define MARCHUP         for (i = min; i < max; i++)
+#define MARCHDOWN       for (i = max - 1; i >= min; i--)
+#define W0              write_sx_byte(board, i, 0x55)
+#define W1              write_sx_byte(board, i, 0xaa)
+#define R0              if (read_sx_byte(board, i) != 0x55) return 1
+#define R1              if (read_sx_byte(board, i) != 0xaa) return 1
 
 /* This memtest takes a human-noticable time. You normally only do it
    once a boot, so I guess that it is worth it. */
-static int do_memtest (struct sx_board *board, int min, int max)
+static int do_memtest(struct sx_board *board, int min, int max)
 {
         int i;
 
@@ -1563,16 +1600,37 @@ static int do_memtest (struct sx_board *board, int min, int max)
            intermittent errors. -- REW
            (For the theory behind memory testing see: 
            Testing Semiconductor Memories by A.J. van de Goor.) */
-        MARCHUP  {W0;}
-        MARCHUP   {R0;W1;R1;W0;R0;W1;}
-        MARCHUP   {R1;W0;W1;}
-        MARCHDOWN {R1;W0;W1;W0;}
-        MARCHDOWN {R0;W1;W0;}
+        MARCHUP {
+                W0;
+        }
+        MARCHUP {
+                R0;
+                W1;
+                R1;
+                W0;
+                R0;
+                W1;
+        }
+        MARCHUP {
+                R1;
+                W0;
+                W1;
+        }
+        MARCHDOWN {
+                R1;
+                W0;
+                W1;
+                W0;
+        }
+        MARCHDOWN {
+                R0;
+                W1;
+                W0;
+        }
 
         return 0;
 }
 
-
 #undef MARCHUP
 #undef MARCHDOWN
 #undef W0
@@ -1580,33 +1638,54 @@ static int do_memtest (struct sx_board *board, int min, int max)
 #undef R0
 #undef R1
 
-#define MARCHUP    for (i=min;i<max;i+=2) 
-#define MARCHDOWN  for (i=max-1;i>=min;i-=2)
-#define W0         write_sx_word (board, i, 0x55aa)
-#define W1         write_sx_word (board, i, 0xaa55)
-#define R0         if (read_sx_word (board, i) != 0x55aa) return 1
-#define R1         if (read_sx_word (board, i) != 0xaa55) return 1
+#define MARCHUP         for (i = min; i < max; i += 2)
+#define MARCHDOWN       for (i = max - 1; i >= min; i -= 2)
+#define W0              write_sx_word(board, i, 0x55aa)
+#define W1              write_sx_word(board, i, 0xaa55)
+#define R0              if (read_sx_word(board, i) != 0x55aa) return 1
+#define R1              if (read_sx_word(board, i) != 0xaa55) return 1
 
 #if 0
 /* This memtest takes a human-noticable time. You normally only do it
    once a boot, so I guess that it is worth it. */
-static int do_memtest_w (struct sx_board *board, int min, int max)
+static int do_memtest_w(struct sx_board *board, int min, int max)
 {
         int i;
 
-        MARCHUP   {W0;}
-        MARCHUP   {R0;W1;R1;W0;R0;W1;}
-        MARCHUP   {R1;W0;W1;}
-        MARCHDOWN {R1;W0;W1;W0;}
-        MARCHDOWN {R0;W1;W0;}
+        MARCHUP {
+                W0;
+        }
+        MARCHUP {
+                R0;
+                W1;
+                R1;
+                W0;
+                R0;
+                W1;
+        }
+        MARCHUP {
+                R1;
+                W0;
+                W1;
+        }
+        MARCHDOWN {
+                R1;
+                W0;
+                W1;
+                W0;
+        }
+        MARCHDOWN {
+                R0;
+                W1;
+                W0;
+        }
 
         return 0;
 }
 #endif
 
-
-static int sx_fw_ioctl (struct inode *inode, struct file *filp,
-                        unsigned int cmd, unsigned long arg)
+static int sx_fw_ioctl(struct inode *inode, struct file *filp,
+                unsigned int cmd, unsigned long arg)
 {
         int rc = 0;
         int __user *descr = (int __user *)arg;
@@ -1618,7 +1697,7 @@ static int sx_fw_ioctl (struct inode *inode, struct file *filp,
 
         func_enter();
 
-#if 0 
+#if 0
         /* Removed superuser check: Sysops can use the permissions on the device
            file to restrict access. Recommendation: Root only. (root.root 600) */
         if (!capable(CAP_SYS_ADMIN)) {
@@ -1626,103 +1705,115 @@ static int sx_fw_ioctl (struct inode *inode, struct file *filp,
         }
 #endif
 
-        sx_dprintk (SX_DEBUG_FIRMWARE, "IOCTL %x: %lx\n", cmd, arg);
+        sx_dprintk(SX_DEBUG_FIRMWARE, "IOCTL %x: %lx\n", cmd, arg);
 
-        if (!board) board = &boards[0];
+        if (!board)
+                board = &boards[0];
         if (board->flags & SX_BOARD_PRESENT) {
-                sx_dprintk (SX_DEBUG_FIRMWARE, "Board present! (%x)\n", 
-                            board->flags);
+                sx_dprintk(SX_DEBUG_FIRMWARE, "Board present! (%x)\n",
+                                board->flags);
         } else {
-                sx_dprintk (SX_DEBUG_FIRMWARE, "Board not present! (%x) all:", 
-                            board->flags);
-                for (i=0;i< SX_NBOARDS;i++)
-                        sx_dprintk (SX_DEBUG_FIRMWARE, "<%x> ", boards[i].flags);
-                sx_dprintk (SX_DEBUG_FIRMWARE, "\n");
+                sx_dprintk(SX_DEBUG_FIRMWARE, "Board not present! (%x) all:",
+                                board->flags);
+                for (i = 0; i < SX_NBOARDS; i++)
+                        sx_dprintk(SX_DEBUG_FIRMWARE, "<%x> ", boards[i].flags);
+                sx_dprintk(SX_DEBUG_FIRMWARE, "\n");
                 return -EIO;
         }
 
         switch (cmd) {
         case SXIO_SET_BOARD:
-                sx_dprintk (SX_DEBUG_FIRMWARE, "set board to %ld\n", arg);
-                if (arg >= SX_NBOARDS) return -EIO;
-                sx_dprintk (SX_DEBUG_FIRMWARE, "not out of range\n");
-                if (!(boards[arg].flags & SX_BOARD_PRESENT)) return -EIO;
-                sx_dprintk (SX_DEBUG_FIRMWARE, ".. and present!\n");
+                sx_dprintk(SX_DEBUG_FIRMWARE, "set board to %ld\n", arg);
+                if (arg >= SX_NBOARDS)
+                        return -EIO;
+                sx_dprintk(SX_DEBUG_FIRMWARE, "not out of range\n");
+                if (!(boards[arg].flags & SX_BOARD_PRESENT))
+                        return -EIO;
+                sx_dprintk(SX_DEBUG_FIRMWARE, ".. and present!\n");
                 board = &boards[arg];
                 break;
         case SXIO_GET_TYPE:
-                rc = -ENOENT; /* If we manage to miss one, return error. */
-                if (IS_SX_BOARD (board)) rc = SX_TYPE_SX;
-                if (IS_CF_BOARD (board)) rc = SX_TYPE_CF;
-                if (IS_SI_BOARD (board)) rc = SX_TYPE_SI;
-                if (IS_SI1_BOARD (board)) rc = SX_TYPE_SI;
-                if (IS_EISA_BOARD (board)) rc = SX_TYPE_SI;
-                sx_dprintk (SX_DEBUG_FIRMWARE, "returning type= %d\n", rc);
+                rc = -ENOENT;   /* If we manage to miss one, return error. */
+                if (IS_SX_BOARD(board))
+                        rc = SX_TYPE_SX;
+                if (IS_CF_BOARD(board))
+                        rc = SX_TYPE_CF;
+                if (IS_SI_BOARD(board))
+                        rc = SX_TYPE_SI;
+                if (IS_SI1_BOARD(board))
+                        rc = SX_TYPE_SI;
+                if (IS_EISA_BOARD(board))
+                        rc = SX_TYPE_SI;
+                sx_dprintk(SX_DEBUG_FIRMWARE, "returning type= %d\n", rc);
                 break;
         case SXIO_DO_RAMTEST:
-                if (sx_initialized) /* Already initialized: better not ramtest the board.  */
+                if (sx_initialized)     /* Already initialized: better not ramtest the board.  */
                         return -EPERM;
-                if (IS_SX_BOARD (board)) {
-                        rc          = do_memtest   (board, 0, 0x7000);
-                        if (!rc) rc = do_memtest   (board, 0, 0x7000);
-                        /*if (!rc) rc = do_memtest_w (board, 0, 0x7000);*/
+                if (IS_SX_BOARD(board)) {
+                        rc = do_memtest(board, 0, 0x7000);
+                        if (!rc)
+                                rc = do_memtest(board, 0, 0x7000);
+                        /*if (!rc) rc = do_memtest_w (board, 0, 0x7000); */
                 } else {
-                        rc             = do_memtest   (board, 0, 0x7ff8);
+                        rc = do_memtest(board, 0, 0x7ff8);
                         /* if (!rc) rc = do_memtest_w (board, 0, 0x7ff8); */
                 }
-                sx_dprintk (SX_DEBUG_FIRMWARE, "returning memtest result= %d\n", rc);
+                sx_dprintk(SX_DEBUG_FIRMWARE, "returning memtest result= %d\n",
+                           rc);
                 break;
         case SXIO_DOWNLOAD:
-                if (sx_initialized) /* Already initialized */
+                if (sx_initialized)     /* Already initialized */
                         return -EEXIST;
-                if (!sx_reset (board)) 
+                if (!sx_reset(board))
                         return -EIO;
-                sx_dprintk (SX_DEBUG_INIT, "reset the board...\n");
-
-                tmp = kmalloc (SX_CHUNK_SIZE, GFP_USER);
-                if (!tmp) return -ENOMEM;
-                get_user (nbytes, descr++);
-                get_user (offset, descr++); 
-                get_user (data,  descr++);
+                sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
+
+                tmp = kmalloc(SX_CHUNK_SIZE, GFP_USER);
+                if (!tmp)
+                        return -ENOMEM;
+                get_user(nbytes, descr++);
+                get_user(offset, descr++);
+                get_user(data, descr++);
                 while (nbytes && data) {
-                        for (i=0;i<nbytes;i += SX_CHUNK_SIZE) {
-                                if (copy_from_user(tmp, (char __user *)data+i, 
-                                                   (i + SX_CHUNK_SIZE >
-                                                    nbytes) ? nbytes - i :
-                                                              SX_CHUNK_SIZE)) {
-                                        kfree (tmp);
+                        for (i = 0; i < nbytes; i += SX_CHUNK_SIZE) {
+                                if (copy_from_user(tmp, (char __user *)data + i,
+                                                (i + SX_CHUNK_SIZE > nbytes) ?
+                                                nbytes - i : SX_CHUNK_SIZE)) {
+                                        kfree(tmp);
                                         return -EFAULT;
                                 }
-                                memcpy_toio(board->base2 + offset + i, tmp, 
-                                                (i+SX_CHUNK_SIZE>nbytes)?nbytes-i:SX_CHUNK_SIZE);
+                                memcpy_toio(board->base2 + offset + i, tmp,
+                                                (i + SX_CHUNK_SIZE > nbytes) ?
+                                                nbytes - i : SX_CHUNK_SIZE);
                         }
 
-                        get_user (nbytes, descr++);
-                        get_user (offset, descr++); 
-                        get_user (data,   descr++);
+                        get_user(nbytes, descr++);
+                        get_user(offset, descr++);
+                        get_user(data, descr++);
                 }
-                kfree (tmp);
-                sx_nports += sx_init_board (board);
+                kfree(tmp);
+                sx_nports += sx_init_board(board);
                 rc = sx_nports;
                 break;
         case SXIO_INIT:
-                if (sx_initialized) /* Already initialized */
+                if (sx_initialized)     /* Already initialized */
                         return -EEXIST;
                 /* This is not allowed until all boards are initialized... */
-                for (i=0;i<SX_NBOARDS;i++) {
-                        if ( (boards[i].flags & SX_BOARD_PRESENT) &&
-                             !(boards[i].flags & SX_BOARD_INITIALIZED))
+                for (i = 0; i < SX_NBOARDS; i++) {
+                        if ((boards[i].flags & SX_BOARD_PRESENT) &&
+                                !(boards[i].flags & SX_BOARD_INITIALIZED))
                                 return -EIO;
                 }
-                for (i=0;i<SX_NBOARDS;i++)
-                        if (!(boards[i].flags & SX_BOARD_PRESENT)) break;
-
-                sx_dprintk (SX_DEBUG_FIRMWARE, "initing portstructs, %d boards, "
-                            "%d channels, first board: %d ports\n", 
-                            i, sx_nports, boards[0].nports);
-                rc = sx_init_portstructs (i, sx_nports);
-                sx_init_drivers ();
-                if (rc >= 0) 
+                for (i = 0; i < SX_NBOARDS; i++)
+                        if (!(boards[i].flags & SX_BOARD_PRESENT))
+                                break;
+
+                sx_dprintk(SX_DEBUG_FIRMWARE, "initing portstructs, %d boards, "
+                                "%d channels, first board: %d ports\n",
+                                i, sx_nports, boards[0].nports);
+                rc = sx_init_portstructs(i, sx_nports);
+                sx_init_drivers();
+                if (rc >= 0)
                         sx_initialized++;
                 break;
         case SXIO_SETDEBUG:
@@ -1739,32 +1830,32 @@ static int sx_fw_ioctl (struct inode *inode, struct file *filp,
                 rc = sx_nports;
                 break;
         default:
-                printk (KERN_WARNING "Unknown ioctl on firmware device (%x).\n", cmd);
+                printk(KERN_WARNING "Unknown ioctl on firmware device (%x).\n",
+                                cmd);
                 break;
         }
-        func_exit ();
+        func_exit();
         return rc;
 }
 
-
-static void sx_break (struct tty_struct * tty, int flag)
+static void sx_break(struct tty_struct *tty, int flag)
 {
         struct sx_port *port = tty->driver_data;
         int rv;
 
-        func_enter ();
+        func_enter();
 
-        if (flag) 
-                rv = sx_send_command (port, HS_START, -1, HS_IDLE_BREAK);
-        else 
-                rv = sx_send_command (port, HS_STOP, -1, HS_IDLE_OPEN);
-        if (rv != 1) printk (KERN_ERR "sx: couldn't send break (%x).\n",
-                        read_sx_byte (port->board, CHAN_OFFSET (port, hi_hstat)));
+        if (flag)
+                rv = sx_send_command(port, HS_START, -1, HS_IDLE_BREAK);
+        else
+                rv = sx_send_command(port, HS_STOP, -1, HS_IDLE_OPEN);
+        if (rv != 1)
+                printk(KERN_ERR "sx: couldn't send break (%x).\n",
+                        read_sx_byte(port->board, CHAN_OFFSET(port, hi_hstat)));
 
-        func_exit ();
+        func_exit();
 }
 
-
 static int sx_tiocmget(struct tty_struct *tty, struct file *file)
 {
         struct sx_port *port = tty->driver_data;
@@ -1772,7 +1863,7 @@ static int sx_tiocmget(struct tty_struct *tty, struct file *file)
 }
 
 static int sx_tiocmset(struct tty_struct *tty, struct file *file,
-                       unsigned int set, unsigned int clear)
+                unsigned int set, unsigned int clear)
 {
         struct sx_port *port = tty->driver_data;
         int rts = -1, dtr = -1;
@@ -1791,8 +1882,8 @@ static int sx_tiocmset(struct tty_struct *tty, struct file *file,
         return 0;
 }
 
-static int sx_ioctl (struct tty_struct * tty, struct file * filp, 
-                     unsigned int cmd, unsigned long arg)
+static int sx_ioctl(struct tty_struct *tty, struct file *filp,
+                unsigned int cmd, unsigned long arg)
 {
         int rc;
         struct sx_port *port = tty->driver_data;
@@ -1805,10 +1896,10 @@ static int sx_ioctl (struct tty_struct * tty, struct file * filp,
         switch (cmd) {
         case TIOCGSOFTCAR:
                 rc = put_user(((tty->termios->c_cflag & CLOCAL) ? 1 : 0),
-                              (unsigned __user *) argp);
+                                (unsigned __user *)argp);
                 break;
         case TIOCSSOFTCAR:
-                if ((rc = get_user(ival, (unsigned __user *) argp)) == 0) {
+                if ((rc = get_user(ival, (unsigned __user *)argp)) == 0) {
                         tty->termios->c_cflag =
                                 (tty->termios->c_cflag & ~CLOCAL) |
                                 (ival ? CLOCAL : 0);
@@ -1829,7 +1920,6 @@ static int sx_ioctl (struct tty_struct * tty, struct file * filp,
         return rc;
 }
 
-
 /* The throttle/unthrottle scheme for the Specialix card is different
  * from other drivers and deserves some explanation. 
  * The Specialix hardware takes care of XON/XOFF
@@ -1846,7 +1936,7 @@ static int sx_ioctl (struct tty_struct * tty, struct file * filp,
  * flow control scheme is in use for that port. -- Simon Allen
  */
 
-static void sx_throttle (struct tty_struct * tty)
+static void sx_throttle(struct tty_struct *tty)
 {
         struct sx_port *port = (struct sx_port *)tty->driver_data;
 
@@ -1854,14 +1944,13 @@ static void sx_throttle (struct tty_struct * tty)
         /* If the port is using any type of input flow
          * control then throttle the port.
          */
-        if((tty->termios->c_cflag & CRTSCTS) || (I_IXOFF(tty)) ) {
+        if ((tty->termios->c_cflag & CRTSCTS) || (I_IXOFF(tty))) {
                 port->gs.flags |= SX_RX_THROTTLE;
         }
         func_exit();
 }
 
-
-static void sx_unthrottle (struct tty_struct * tty)
+static void sx_unthrottle(struct tty_struct *tty)
 {
         struct sx_port *port = (struct sx_port *)tty->driver_data;
 
@@ -1875,15 +1964,11 @@ static void sx_unthrottle (struct tty_struct * tty)
         return;
 }
 
-
 /* ********************************************************************** *
  *                    Here are the initialization routines.               *
  * ********************************************************************** */
 
-
-
-
-static int sx_init_board (struct sx_board *board)
+static int sx_init_board(struct sx_board *board)
 {
         int addr;
         int chans;
@@ -1895,36 +1980,38 @@ static int sx_init_board (struct sx_board *board)
 
         board->flags |= SX_BOARD_INITIALIZED;
 
-        if (read_sx_byte (board, 0))
+        if (read_sx_byte(board, 0))
                 /* CF boards may need this. */
-                write_sx_byte(board,0, 0);
+                write_sx_byte(board, 0, 0);
 
         /* This resets the processor again, to make sure it didn't do any
            foolish things while we were downloading the image */
-        if (!sx_reset (board))
+        if (!sx_reset(board))
                 return 0;
 
-        sx_start_board (board);
-        udelay (10);
-        if (!sx_busy_wait_neq (board, 0, 0xff, 0)) {
-                printk (KERN_ERR "sx: Ooops. Board won't initialize.\n");
+        sx_start_board(board);
+        udelay(10);
+        if (!sx_busy_wait_neq(board, 0, 0xff, 0)) {
+                printk(KERN_ERR "sx: Ooops. Board won't initialize.\n");
                 return 0;
         }
 
         /* Ok. So now the processor on the card is running. It gathered
            some info for us... */
-        sx_dprintk (SX_DEBUG_INIT, "The sxcard structure:\n");
-        if (sx_debug & SX_DEBUG_INIT) my_hd_io (board->base, 0x10);
-        sx_dprintk (SX_DEBUG_INIT, "the first sx_module structure:\n");
-        if (sx_debug & SX_DEBUG_INIT) my_hd_io (board->base + 0x80, 0x30);
-
-        sx_dprintk (SX_DEBUG_INIT, 
-                    "init_status: %x, %dk memory, firmware V%x.%02x,\n", 
-                    read_sx_byte (board, 0), read_sx_byte(board, 1), 
-                    read_sx_byte (board, 5), read_sx_byte(board, 4));
-
-        if (read_sx_byte (board, 0) == 0xff) {
-                printk (KERN_INFO "sx: No modules found. Sorry.\n");
+        sx_dprintk(SX_DEBUG_INIT, "The sxcard structure:\n");
+        if (sx_debug & SX_DEBUG_INIT)
+                my_hd_io(board->base, 0x10);
+        sx_dprintk(SX_DEBUG_INIT, "the first sx_module structure:\n");
+        if (sx_debug & SX_DEBUG_INIT)
+                my_hd_io(board->base + 0x80, 0x30);
+
+        sx_dprintk(SX_DEBUG_INIT, "init_status: %x, %dk memory, firmware "
+                        "V%x.%02x,\n",
+                        read_sx_byte(board, 0), read_sx_byte(board, 1),
+                        read_sx_byte(board, 5), read_sx_byte(board, 4));
+
+        if (read_sx_byte(board, 0) == 0xff) {
+                printk(KERN_INFO "sx: No modules found. Sorry.\n");
                 board->nports = 0;
                 return 0;
         }
@@ -1932,82 +2019,97 @@ static int sx_init_board (struct sx_board *board)
         chans = 0;
 
         if (IS_SX_BOARD(board)) {
-                sx_write_board_word (board, cc_int_count, sx_maxints);
+                sx_write_board_word(board, cc_int_count, sx_maxints);
         } else {
                 if (sx_maxints)
-                        sx_write_board_word (board, cc_int_count, SI_PROCESSOR_CLOCK/8/sx_maxints);
+                        sx_write_board_word(board, cc_int_count,
+                                        SI_PROCESSOR_CLOCK / 8 / sx_maxints);
         }
 
         /* grab the first module type... */
-        /*  board->ta_type = mod_compat_type (read_sx_byte (board, 0x80 + 0x08)); */
-        board->ta_type = mod_compat_type (sx_read_module_byte (board, 0x80, mc_chip));
+        /* board->ta_type = mod_compat_type (read_sx_byte (board, 0x80 + 0x08)); */
+        board->ta_type = mod_compat_type(sx_read_module_byte(board, 0x80,
+                                mc_chip));
 
         /* XXX byteorder */
-        for (addr = 0x80;addr != 0;addr = read_sx_word (board, addr) & 0x7fff) {
-                type = sx_read_module_byte (board, addr, mc_chip);
-                sx_dprintk (SX_DEBUG_INIT, "Module at %x: %d channels\n", 
-                            addr, read_sx_byte (board, addr + 2));
-
-                chans += sx_read_module_byte (board, addr, mc_type);
-
-                sx_dprintk (SX_DEBUG_INIT, "module is an %s, which has %s/%s panels\n", 
-                            mod_type_s (type),
-                            pan_type_s (sx_read_module_byte (board, addr, mc_mods) & 0xf),
-                            pan_type_s (sx_read_module_byte (board, addr, mc_mods) >> 4));
-
-                sx_dprintk (SX_DEBUG_INIT, "CD1400 versions: %x/%x, ASIC version: %x\n", 
-                            sx_read_module_byte (board, addr, mc_rev1),
-                            sx_read_module_byte (board, addr, mc_rev2),
-                            sx_read_module_byte (board, addr, mc_mtaasic_rev));
+        for (addr = 0x80; addr != 0; addr = read_sx_word(board, addr) & 0x7fff){
+                type = sx_read_module_byte(board, addr, mc_chip);
+                sx_dprintk(SX_DEBUG_INIT, "Module at %x: %d channels\n",
+                                addr, read_sx_byte(board, addr + 2));
+
+                chans += sx_read_module_byte(board, addr, mc_type);
+
+                sx_dprintk(SX_DEBUG_INIT, "module is an %s, which has %s/%s "
+                                "panels\n",
+                                mod_type_s(type),
+                                pan_type_s(sx_read_module_byte(board, addr,
+                                                mc_mods) & 0xf),
+                                pan_type_s(sx_read_module_byte(board, addr,
+                                                mc_mods) >> 4));
+
+                sx_dprintk(SX_DEBUG_INIT, "CD1400 versions: %x/%x, ASIC "
+                        "version: %x\n",
+                        sx_read_module_byte(board, addr, mc_rev1),
+                        sx_read_module_byte(board, addr, mc_rev2),
+                        sx_read_module_byte(board, addr, mc_mtaasic_rev));
 
                 /* The following combinations are illegal: It should theoretically
                    work, but timing problems make the bus HANG. */
 
-                if (mod_compat_type (type) != board->ta_type) {
-                        printk (KERN_ERR "sx: This is an invalid configuration.\n"
-                                "Don't mix TA/MTA/SXDC on the same hostadapter.\n");
-                        chans=0;
+                if (mod_compat_type(type) != board->ta_type) {
+                        printk(KERN_ERR "sx: This is an invalid "
+                                "configuration.\nDon't mix TA/MTA/SXDC on the "
+                                "same hostadapter.\n");
+                        chans = 0;
                         break;
                 }
-                if ((IS_EISA_BOARD(board) || 
-                     IS_SI_BOARD(board)) && (mod_compat_type(type) == 4)) {
-                        printk (KERN_ERR "sx: This is an invalid configuration.\n"
-                                "Don't use SXDCs on an SI/XIO adapter.\n");
-                        chans=0;
+                if ((IS_EISA_BOARD(board) ||
+                                IS_SI_BOARD(board)) &&
+                                (mod_compat_type(type) == 4)) {
+                        printk(KERN_ERR "sx: This is an invalid "
+                                "configuration.\nDon't use SXDCs on an SI/XIO "
+                                "adapter.\n");
+                        chans = 0;
                         break;
                 }
-#if 0 /* Problem fixed: firmware 3.05 */
+#if 0                           /* Problem fixed: firmware 3.05 */
                 if (IS_SX_BOARD(board) && (type == TA8)) {
                         /* There are some issues with the firmware and the DCD/RTS
                            lines. It might work if you tie them together or something.
-                           It might also work if you get a newer sx_firmware.   Therefore
+                           It might also work if you get a newer sx_firmware.   Therefore
                            this is just a warning. */
-                        printk (KERN_WARNING "sx: The SX host doesn't work too well "
-                                "with the TA8 adapters.\nSpecialix is working on it.\n");
+                        printk(KERN_WARNING
+                               "sx: The SX host doesn't work too well "
+                               "with the TA8 adapters.\nSpecialix is working on it.\n");
                 }
 #endif
         }
 
         if (chans) {
-                /* board->flags |= SX_BOARD_PRESENT; */
-                if(board->irq > 0) {
+                if (board->irq > 0) {
                         /* fixed irq, probably PCI */
-                        if(sx_irqmask & (1 << board->irq)) { /* may we use this irq? */
-                                if(request_irq(board->irq, sx_interrupt, IRQF_SHARED | IRQF_DISABLED, "sx", board)) {
-                                        printk(KERN_ERR "sx: Cannot allocate irq %d.\n", board->irq);
+                        if (sx_irqmask & (1 << board->irq)) {   /* may we use this irq? */
+                                if (request_irq(board->irq, sx_interrupt,
+                                                IRQF_SHARED | IRQF_DISABLED,
+                                                "sx", board)) {
+                                        printk(KERN_ERR "sx: Cannot allocate "
+                                                "irq %d.\n", board->irq);
                                         board->irq = 0;
                                 }
                         } else
                                 board->irq = 0;
-                } else if(board->irq < 0 && sx_irqmask) {
+                } else if (board->irq < 0 && sx_irqmask) {
                         /* auto-allocate irq */
                         int irqnr;
-                        int irqmask = sx_irqmask & (IS_SX_BOARD(board) ? SX_ISA_IRQ_MASK : SI2_ISA_IRQ_MASK);
-                        for(irqnr = 15; irqnr > 0; irqnr--)
-                                if(irqmask & (1 << irqnr))
-                                        if(! request_irq(irqnr, sx_interrupt, IRQF_SHARED | IRQF_DISABLED, "sx", board))
+                        int irqmask = sx_irqmask & (IS_SX_BOARD(board) ?
+                                        SX_ISA_IRQ_MASK : SI2_ISA_IRQ_MASK);
+                        for (irqnr = 15; irqnr > 0; irqnr--)
+                                if (irqmask & (1 << irqnr))
+                                        if (!request_irq(irqnr, sx_interrupt,
+                                                IRQF_SHARED | IRQF_DISABLED,
+                                                "sx", board))
                                                 break;
-                        if(! irqnr)
+                        if (!irqnr)
                                 printk(KERN_ERR "sx: Cannot allocate IRQ.\n");
                         board->irq = irqnr;
                 } else
@@ -2015,52 +2117,48 @@ static int sx_init_board (struct sx_board *board)
 
                 if (board->irq) {
                         /* Found a valid interrupt, start up interrupts! */
-                        sx_dprintk (SX_DEBUG_INIT, "Using irq %d.\n", board->irq);
-                        sx_start_interrupts (board);
+                        sx_dprintk(SX_DEBUG_INIT, "Using irq %d.\n",
+                                        board->irq);
+                        sx_start_interrupts(board);
                         board->poll = sx_slowpoll;
                         board->flags |= SX_IRQ_ALLOCATED;
                 } else {
                         /* no irq: setup board for polled operation */
                         board->poll = sx_poll;
-                        sx_dprintk (SX_DEBUG_INIT, "Using poll-interval %d.\n", board->poll);
+                        sx_dprintk(SX_DEBUG_INIT, "Using poll-interval %d.\n",
+                                        board->poll);
                 }
 
-                /* The timer should be initialized anyway: That way we can safely
-                         del_timer it when the module is unloaded. */
-                init_timer (&board->timer);
+                /* The timer should be initialized anyway: That way we can
+                   safely del_timer it when the module is unloaded. */
+                setup_timer(&board->timer, sx_pollfunc, (unsigned long)board);
 
-                if (board->poll) {
-                        board->timer.data = (unsigned long) board;
-                        board->timer.function = sx_pollfunc;
-                        board->timer.expires = jiffies + board->poll;
-                        add_timer (&board->timer);
-                }
+                if (board->poll)
+                        mod_timer(&board->timer, jiffies + board->poll);
         } else {
                 board->irq = 0;
         }
 
         board->nports = chans;
-        sx_dprintk (SX_DEBUG_INIT, "returning %d ports.", board->nports);
+        sx_dprintk(SX_DEBUG_INIT, "returning %d ports.", board->nports);
 
         func_exit();
         return chans;
 }
 
-
-static void printheader(void)
+static void __devinit printheader(void)
 {
         static int header_printed;
 
         if (!header_printed) {
-                printk (KERN_INFO "Specialix SX driver "
-                        "(C) 1998/1999 R.E.Wolff@BitWizard.nl \n");
-                printk (KERN_INFO "sx: version %s\n", RCS_ID);
+                printk(KERN_INFO "Specialix SX driver "
+                        "(C) 1998/1999 R.E.Wolff@BitWizard.nl\n");
+                printk(KERN_INFO "sx: version " __stringify(SX_VERSION) "\n");
                 header_printed = 1;
         }
 }
 
-
-static int probe_sx (struct sx_board *board)
+static int __devinit probe_sx(struct sx_board *board)
 {
         struct vpd_prom vpdp;
         char *p;
@@ -2068,51 +2166,57 @@ static int probe_sx (struct sx_board *board)
 
         func_enter();
 
-        if (!IS_CF_BOARD (board)) {    
-                sx_dprintk (SX_DEBUG_PROBE, "Going to verify vpd prom at %p.\n", 
-                            board->base + SX_VPD_ROM);
+        if (!IS_CF_BOARD(board)) {
+                sx_dprintk(SX_DEBUG_PROBE, "Going to verify vpd prom at %p.\n",
+                                board->base + SX_VPD_ROM);
 
                 if (sx_debug & SX_DEBUG_PROBE)
                         my_hd_io(board->base + SX_VPD_ROM, 0x40);
 
-                p = (char *) &vpdp;
-                for (i=0;i< sizeof (struct vpd_prom);i++)
-                        *p++ = read_sx_byte (board, SX_VPD_ROM + i*2);
+                p = (char *)&vpdp;
+                for (i = 0; i < sizeof(struct vpd_prom); i++)
+                        *p++ = read_sx_byte(board, SX_VPD_ROM + i * 2);
 
                 if (sx_debug & SX_DEBUG_PROBE)
-                        my_hd (&vpdp, 0x20);
+                        my_hd(&vpdp, 0x20);
 
-                sx_dprintk (SX_DEBUG_PROBE, "checking identifier...\n");
+                sx_dprintk(SX_DEBUG_PROBE, "checking identifier...\n");
 
-                if (strncmp (vpdp.identifier, SX_VPD_IDENT_STRING, 16) != 0) {
-                        sx_dprintk (SX_DEBUG_PROBE, "Got non-SX identifier: '%s'\n", 
-                                    vpdp.identifier); 
+                if (strncmp(vpdp.identifier, SX_VPD_IDENT_STRING, 16) != 0) {
+                        sx_dprintk(SX_DEBUG_PROBE, "Got non-SX identifier: "
+                                        "'%s'\n", vpdp.identifier);
                         return 0;
                 }
         }
 
-        printheader ();
-
-        if (!IS_CF_BOARD (board)) {
-                printk (KERN_DEBUG "sx: Found an SX board at %lx\n", board->hw_base);
-                printk (KERN_DEBUG "sx: hw_rev: %d, assembly level: %d, uniq ID:%08x, ", 
-                        vpdp.hwrev, vpdp.hwass, vpdp.uniqid);
-                printk (           "Manufactured: %d/%d\n", 
-                        1970 + vpdp.myear, vpdp.mweek);
+        printheader();
 
+        if (!IS_CF_BOARD(board)) {
+                printk(KERN_DEBUG "sx: Found an SX board at %lx\n",
+                        board->hw_base);
+                printk(KERN_DEBUG "sx: hw_rev: %d, assembly level: %d, "
+                                "uniq ID:%08x, ",
+                                vpdp.hwrev, vpdp.hwass, vpdp.uniqid);
+                printk("Manufactured: %d/%d\n", 1970 + vpdp.myear, vpdp.mweek);
 
-                if ((((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) != SX_PCI_UNIQUEID1) &&
-                    (((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) != SX_ISA_UNIQUEID1)) {
-                        /* This might be a bit harsh. This was the primary reason the
-                           SX/ISA card didn't work at first... */
-                        printk (KERN_ERR "sx: Hmm. Not an SX/PCI or SX/ISA card. Sorry: giving up.\n");
+                if ((((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) !=
+                                SX_PCI_UNIQUEID1) && (((vpdp.uniqid >> 24) &
+                                SX_UNIQUEID_MASK) != SX_ISA_UNIQUEID1)) {
+                        /* This might be a bit harsh. This was the primary
+                           reason the SX/ISA card didn't work at first... */
+                        printk(KERN_ERR "sx: Hmm. Not an SX/PCI or SX/ISA "
+                                        "card. Sorry: giving up.\n");
                         return (0);
                 }
 
-                if (((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) == SX_ISA_UNIQUEID1) {
+                if (((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) ==
+                                SX_ISA_UNIQUEID1) {
                         if (((unsigned long)board->hw_base) & 0x8000) {
-                                printk (KERN_WARNING "sx: Warning: There may be hardware problems with the card at %lx.\n", board->hw_base);
-                                printk (KERN_WARNING "sx: Read sx.txt for more info.\n");
+                                printk(KERN_WARNING "sx: Warning: There may be "
+                                        "hardware problems with the card at "
+                                        "%lx.\n", board->hw_base);
+                                printk(KERN_WARNING "sx: Read sx.txt for more "
+                                                "info.\n");
                         }
                 }
         }
@@ -2120,17 +2224,15 @@ static int probe_sx (struct sx_board *board)
         board->nports = -1;
 
         /* This resets the processor, and keeps it off the bus. */
-        if (!sx_reset (board)) 
+        if (!sx_reset(board))
                 return 0;
-        sx_dprintk (SX_DEBUG_INIT, "reset the board...\n");
-
-        board->flags |= SX_BOARD_PRESENT;
+        sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
 
         func_exit();
         return 1;
 }
 
-
+#if defined(CONFIG_ISA) || defined(CONFIG_EISA)
 
 /* Specialix probes for this card at 32k increments from 640k to 16M.
    I consider machines with less than 16M unlikely nowadays, so I'm
@@ -2138,28 +2240,27 @@ static int probe_sx (struct sx_board *board)
    card. 0xe0000 and 0xf0000 are taken by the BIOS. That only leaves 
    0xc0000, 0xc8000, 0xd0000 and 0xd8000 . */
 
-static int probe_si (struct sx_board *board)
+static int __devinit probe_si(struct sx_board *board)
 {
         int i;
 
         func_enter();
-        sx_dprintk (SX_DEBUG_PROBE, "Going to verify SI signature hw %lx at %p.\n", board->hw_base,
-                    board->base + SI2_ISA_ID_BASE);
+        sx_dprintk(SX_DEBUG_PROBE, "Going to verify SI signature hw %lx at "
+                "%p.\n", board->hw_base, board->base + SI2_ISA_ID_BASE);
 
         if (sx_debug & SX_DEBUG_PROBE)
                 my_hd_io(board->base + SI2_ISA_ID_BASE, 0x8);
 
         if (!IS_EISA_BOARD(board)) {
-          if( IS_SI1_BOARD(board) ) 
-            {
-                for (i=0;i<8;i++) {
-                  write_sx_byte (board, SI2_ISA_ID_BASE+7-i,i); 
-
+                if (IS_SI1_BOARD(board)) {
+                        for (i = 0; i < 8; i++) {
+                                write_sx_byte(board, SI2_ISA_ID_BASE + 7 - i,i);
+                        }
                 }
-            }
-                for (i=0;i<8;i++) {
-                        if ((read_sx_byte (board, SI2_ISA_ID_BASE+7-i) & 7) != i) {
-                                func_exit ();
+                for (i = 0; i < 8; i++) {
+                        if ((read_sx_byte(board, SI2_ISA_ID_BASE + 7 - i) & 7)
+                                        != i) {
+                                func_exit();
                                 return 0;
                         }
                 }
@@ -2169,20 +2270,20 @@ static int probe_si (struct sx_board *board)
            but to prevent trouble, we'd better double check that we don't
            have an SI1 board when we're probing for an SI2 board.... */
 
-        write_sx_byte (board, SI2_ISA_ID_BASE,0x10); 
-        if ( IS_SI1_BOARD(board)) {
+        write_sx_byte(board, SI2_ISA_ID_BASE, 0x10);
+        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) {
-                        func_exit ();
-                        return 0; 
+                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) {
-                        func_exit ();
-                        return 0; 
+                if (read_sx_byte(board, SI2_ISA_ID_BASE) == 0x10) {
+                        func_exit();
+                        return 0;
                 }
         }
 
@@ -2190,45 +2291,44 @@ static int probe_si (struct sx_board *board)
            but to prevent trouble, we'd better double check that we don't
            have an SI1 board when we're probing for an SI2 board.... */
 
-        write_sx_byte (board, SI2_ISA_ID_BASE,0x10); 
-        if ( IS_SI1_BOARD(board)) {
+        write_sx_byte(board, SI2_ISA_ID_BASE, 0x10);
+        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; 
+                        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) {
-                        func_exit ();
-                        return 0; 
+                if (read_sx_byte(board, SI2_ISA_ID_BASE) == 0x10) {
+                        func_exit();
+                        return 0;
                 }
         }
 
-        printheader ();
+        printheader();
 
-        printk (KERN_DEBUG "sx: Found an SI board at %lx\n", board->hw_base);
+        printk(KERN_DEBUG "sx: Found an SI board at %lx\n", board->hw_base);
         /* Compared to the SX boards, it is a complete guess as to what
-                 this card is up to... */
+           this card is up to... */
 
         board->nports = -1;
 
         /* This resets the processor, and keeps it off the bus. */
-        if (!sx_reset (board)) 
+        if (!sx_reset(board))
                 return 0;
-        sx_dprintk (SX_DEBUG_INIT, "reset the board...\n");
-
-        board->flags |= SX_BOARD_PRESENT;
+        sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
 
         func_exit();
         return 1;
 }
+#endif
 
-static struct tty_operations sx_ops = {
+static const struct tty_operations sx_ops = {
         .break_ctl = sx_break,
-        .open   = sx_open,
+        .open = sx_open,
         .close = gs_close,
         .write = gs_write,
         .put_char = gs_put_char,
@@ -2263,34 +2363,23 @@ static int sx_init_drivers(void)
         sx_driver->type = TTY_DRIVER_TYPE_SERIAL;
         sx_driver->subtype = SERIAL_TYPE_NORMAL;
         sx_driver->init_termios = tty_std_termios;
-        sx_driver->init_termios.c_cflag =
-          B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+        sx_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+        sx_driver->init_termios.c_ispeed = 9600;
+        sx_driver->init_termios.c_ospeed = 9600;
         sx_driver->flags = TTY_DRIVER_REAL_RAW;
         tty_set_operations(sx_driver, &sx_ops);
 
         if ((error = tty_register_driver(sx_driver))) {
                 put_tty_driver(sx_driver);
                 printk(KERN_ERR "sx: Couldn't register sx driver, error = %d\n",
-                       error);
+                        error);
                 return 1;
         }
         func_exit();
         return 0;
 }
 
-
-static void * ckmalloc (int size)
-{
-        void *p;
-
-        p = kmalloc(size, GFP_KERNEL);
-        if (p) 
-                memset(p, 0, size);
-        return p;
-}
-
-
-static int sx_init_portstructs (int nboards, int nports)
+static int sx_init_portstructs(int nboards, int nports)
 {
         struct sx_board *board;
         struct sx_port *port;
@@ -2301,8 +2390,9 @@ static int sx_init_portstructs (int nboards, int nports)
         func_enter();
 
         /* Many drivers statically allocate the maximum number of ports
-           There is no reason not to allocate them dynamically. Is there? -- REW */
-        sx_ports          = ckmalloc(nports * sizeof (struct sx_port));
+           There is no reason not to allocate them dynamically.
+           Is there? -- REW */
+        sx_ports = kcalloc(nports, sizeof(struct sx_port), GFP_KERNEL);
         if (!sx_ports)
                 return -ENOMEM;
 
@@ -2310,10 +2400,10 @@ static int sx_init_portstructs (int nboards, int nports)
         for (i = 0; i < nboards; i++) {
                 board = &boards[i];
                 board->ports = port;
-                for (j=0; j < boards[i].nports;j++) {
-                        sx_dprintk (SX_DEBUG_INIT, "initing port %d\n", j);
+                for (j = 0; j < boards[i].nports; j++) {
+                        sx_dprintk(SX_DEBUG_INIT, "initing port %d\n", j);
                         port->gs.magic = SX_MAGIC;
-                        port->gs.close_delay = HZ/2;
+                        port->gs.close_delay = HZ / 2;
                         port->gs.closing_wait = 30 * HZ;
                         port->board = board;
                         port->gs.rd = &sx_real_driver;
@@ -2325,8 +2415,8 @@ static int sx_init_portstructs (int nboards, int nports)
                          * Initializing wait queue
                          */
                         init_waitqueue_head(&port->gs.open_wait);
-                        init_waitqueue_head(&port->gs.close_wait);              
-                        
+                        init_waitqueue_head(&port->gs.close_wait);
+
                         port++;
                 }
         }
@@ -2337,28 +2427,36 @@ static int sx_init_portstructs (int nboards, int nports)
                 board = &boards[i];
                 board->port_base = portno;
                 /* Possibly the configuration was rejected. */
-                sx_dprintk (SX_DEBUG_PROBE, "Board has %d channels\n", board->nports);
-                if (board->nports <= 0) continue;
+                sx_dprintk(SX_DEBUG_PROBE, "Board has %d channels\n",
+                                board->nports);
+                if (board->nports <= 0)
+                        continue;
                 /* XXX byteorder ?? */
-                for (addr = 0x80;addr != 0;addr = read_sx_word (board, addr) & 0x7fff) {
-                        chans = sx_read_module_byte (board, addr, mc_type); 
-                        sx_dprintk (SX_DEBUG_PROBE, "Module at %x: %d channels\n", addr, chans);
-                        sx_dprintk (SX_DEBUG_PROBE, "Port at");
-                        for (j=0;j<chans;j++) {
-                                /* The "sx-way" is the way it SHOULD be done. That way in the 
-                                   future, the firmware may for example pack the structures a bit
-                                   more efficient. Neil tells me it isn't going to happen anytime
-                                   soon though. */
+                for (addr = 0x80; addr != 0;
+                                addr = read_sx_word(board, addr) & 0x7fff) {
+                        chans = sx_read_module_byte(board, addr, mc_type);
+                        sx_dprintk(SX_DEBUG_PROBE, "Module at %x: %d "
+                                        "channels\n", addr, chans);
+                        sx_dprintk(SX_DEBUG_PROBE, "Port at");
+                        for (j = 0; j < chans; j++) {
+                                /* The "sx-way" is the way it SHOULD be done.
+                                   That way in the future, the firmware may for
+                                   example pack the structures a bit more
+                                   efficient. Neil tells me it isn't going to
+                                   happen anytime soon though. */
                                 if (IS_SX_BOARD(board))
-                                        port->ch_base = sx_read_module_word (board, addr+j*2, mc_chan_pointer);
+                                        port->ch_base = sx_read_module_word(
+                                                        board, addr + j * 2,
+                                                        mc_chan_pointer);
                                 else
-                                        port->ch_base = addr + 0x100 + 0x300*j;
+                                        port->ch_base = addr + 0x100 + 0x300 *j;
 
-                                sx_dprintk (SX_DEBUG_PROBE, " %x", port->ch_base);
+                                sx_dprintk(SX_DEBUG_PROBE, " %x",
+                                                port->ch_base);
                                 port->line = portno++;
                                 port++;
                         }
-                        sx_dprintk (SX_DEBUG_PROBE, "\n");
+                        sx_dprintk(SX_DEBUG_PROBE, "\n");
                 }
                 /* This has to be done earlier. */
                 /* board->flags |= SX_BOARD_INITIALIZED; */
@@ -2368,6 +2466,17 @@ static int sx_init_portstructs (int nboards, int nports)
         return 0;
 }
 
+static unsigned int sx_find_free_board(void)
+{
+        unsigned int i;
+
+        for (i = 0; i < SX_NBOARDS; i++)
+                if (!(boards[i].flags & SX_BOARD_PRESENT))
+                        break;
+
+        return i;
+}
+
 static void __exit sx_release_drivers(void)
 {
         func_enter();
@@ -2376,7 +2485,122 @@ static void __exit sx_release_drivers(void)
         func_exit();
 }
 
-#ifdef CONFIG_PCI
+static void __devexit sx_remove_card(struct sx_board *board,
+                struct pci_dev *pdev)
+{
+        if (board->flags & SX_BOARD_INITIALIZED) {
+                /* The board should stop messing with us. (actually I mean the
+                   interrupt) */
+                sx_reset(board);
+                if ((board->irq) && (board->flags & SX_IRQ_ALLOCATED))
+                        free_irq(board->irq, board);
+
+                /* It is safe/allowed to del_timer a non-active timer */
+                del_timer(&board->timer);
+                if (pdev) {
+                        pci_iounmap(pdev, board->base);
+                        pci_release_region(pdev, IS_CF_BOARD(board) ? 3 : 2);
+                } else {
+                        iounmap(board->base);
+                        release_region(board->hw_base, board->hw_len);
+                }
+
+                board->flags &= ~(SX_BOARD_INITIALIZED | SX_BOARD_PRESENT);
+        }
+}
+
+#ifdef CONFIG_EISA
+
+static int __devinit sx_eisa_probe(struct device *dev)
+{
+        struct eisa_device *edev = to_eisa_device(dev);
+        struct sx_board *board;
+        unsigned long eisa_slot = edev->base_addr;
+        unsigned int i;
+        int retval = -EIO;
+
+        mutex_lock(&sx_boards_lock);
+        i = sx_find_free_board();
+        if (i == SX_NBOARDS) {
+                mutex_unlock(&sx_boards_lock);
+                goto err;
+        }
+        board = &boards[i];
+        board->flags |= SX_BOARD_PRESENT;
+        mutex_unlock(&sx_boards_lock);
+
+        dev_info(dev, "XIO : Signature found in EISA slot %lu, "
+                 "Product %d Rev %d (REPORT THIS TO LKLM)\n",
+                 eisa_slot >> 12,
+                 inb(eisa_slot + EISA_VENDOR_ID_OFFSET + 2),
+                 inb(eisa_slot + EISA_VENDOR_ID_OFFSET + 3));
+
+        board->eisa_base = eisa_slot;
+        board->flags &= ~SX_BOARD_TYPE;
+        board->flags |= SI_EISA_BOARD;
+
+        board->hw_base = ((inb(eisa_slot + 0xc01) << 8) +
+                          inb(eisa_slot + 0xc00)) << 16;
+        board->hw_len = SI2_EISA_WINDOW_LEN;
+        if (!request_region(board->hw_base, board->hw_len, "sx")) {
+                dev_err(dev, "can't request region\n");
+                goto err_flag;
+        }
+        board->base2 =
+        board->base = ioremap(board->hw_base, SI2_EISA_WINDOW_LEN);
+        if (!board->base) {
+                dev_err(dev, "can't remap memory\n");
+                goto err_reg;
+        }
+
+        sx_dprintk(SX_DEBUG_PROBE, "IO hw_base address: %lx\n", board->hw_base);
+        sx_dprintk(SX_DEBUG_PROBE, "base: %p\n", board->base);
+        board->irq = inb(eisa_slot + 0xc02) >> 4;
+        sx_dprintk(SX_DEBUG_PROBE, "IRQ: %d\n", board->irq);
+
+        if (!probe_si(board))
+                goto err_unmap;
+
+        dev_set_drvdata(dev, board);
+
+        return 0;
+err_unmap:
+        iounmap(board->base);
+err_reg:
+        release_region(board->hw_base, board->hw_len);
+err_flag:
+        board->flags &= ~SX_BOARD_PRESENT;
+err:
+        return retval;
+}
+
+static int __devexit sx_eisa_remove(struct device *dev)
+{
+        struct sx_board *board = dev_get_drvdata(dev);
+
+        sx_remove_card(board, NULL);
+
+        return 0;
+}
+
+static struct eisa_device_id sx_eisa_tbl[] = {
+        { "SLX" },
+        { "" }
+};
+
+MODULE_DEVICE_TABLE(eisa, sx_eisa_tbl);
+
+static struct eisa_driver sx_eisadriver = {
+        .id_table = sx_eisa_tbl,
+        .driver = {
+                .name = "sx",
+                .probe = sx_eisa_probe,
+                .remove = __devexit_p(sx_eisa_remove),
+        }
+};
+
+#endif
+
  /******************************************************** 
  * Setting bit 17 in the CNTRL register of the PLX 9050  * 
  * chip forces a retry on writes while a read is pending.*
@@ -2388,233 +2612,265 @@ static void __exit sx_release_drivers(void)
    EEprom.  As the bit is read/write for the CPU, we can fix it here,
    if we detect that it isn't set correctly. -- REW */
 
-static void fix_sx_pci (struct pci_dev *pdev, struct sx_board *board)
+static void __devinit fix_sx_pci(struct pci_dev *pdev, struct sx_board *board)
 {
         unsigned int hwbase;
         void __iomem *rebase;
         unsigned int t;
 
-#define CNTRL_REG_OFFSET        0x50
-#define CNTRL_REG_GOODVALUE     0x18260000
+#define CNTRL_REG_OFFSET        0x50
+#define CNTRL_REG_GOODVALUE     0x18260000
 
         pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &hwbase);
         hwbase &= PCI_BASE_ADDRESS_MEM_MASK;
         rebase = ioremap(hwbase, 0x80);
-        t = readl (rebase + CNTRL_REG_OFFSET);
+        t = readl(rebase + CNTRL_REG_OFFSET);
         if (t != CNTRL_REG_GOODVALUE) {
-                printk (KERN_DEBUG "sx: performing cntrl reg fix: %08x -> %08x\n", t, CNTRL_REG_GOODVALUE); 
-                writel (CNTRL_REG_GOODVALUE, rebase + CNTRL_REG_OFFSET);
+                printk(KERN_DEBUG "sx: performing cntrl reg fix: %08x -> "
+                        "%08x\n", t, CNTRL_REG_GOODVALUE);
+                writel(CNTRL_REG_GOODVALUE, rebase + CNTRL_REG_OFFSET);
         }
         iounmap(rebase);
 }
-#endif
-
 
-static int __init sx_init(void) 
+static int __devinit sx_pci_probe(struct pci_dev *pdev,
+                                  const struct pci_device_id *ent)
 {
-        int i;
-        int found = 0;
-        int eisa_slot;
         struct sx_board *board;
+        unsigned int i, reg;
+        int retval = -EIO;
 
-#ifdef CONFIG_PCI
-        struct pci_dev *pdev = NULL;
-        unsigned int tint;
-        unsigned short tshort;
-#endif
+        mutex_lock(&sx_boards_lock);
+        i = sx_find_free_board();
+        if (i == SX_NBOARDS) {
+                mutex_unlock(&sx_boards_lock);
+                goto err;
+        }
+        board = &boards[i];
+        board->flags |= SX_BOARD_PRESENT;
+        mutex_unlock(&sx_boards_lock);
 
-        func_enter();
-        sx_dprintk (SX_DEBUG_INIT, "Initing sx module... (sx_debug=%d)\n", sx_debug);
-        if (abs ((long) (&sx_debug) - sx_debug) < 0x10000) {
-                printk (KERN_WARNING "sx: sx_debug is an address, instead of a value. "
-                        "Assuming -1.\n");
-                printk ("(%p)\n", &sx_debug);
-                sx_debug=-1;
+        retval = pci_enable_device(pdev);
+        if (retval)
+                goto err_flag;
+
+        board->flags &= ~SX_BOARD_TYPE;
+        board->flags |= (pdev->subsystem_vendor == 0x200) ? SX_PCI_BOARD :
+                SX_CFPCI_BOARD;
+
+        /* CF boards use base address 3.... */
+        reg = IS_CF_BOARD(board) ? 3 : 2;
+        retval = pci_request_region(pdev, reg, "sx");
+        if (retval) {
+                dev_err(&pdev->dev, "can't request region\n");
+                goto err_flag;
+        }
+        board->hw_base = pci_resource_start(pdev, reg);
+        board->base2 =
+        board->base = pci_iomap(pdev, reg, WINDOW_LEN(board));
+        if (!board->base) {
+                dev_err(&pdev->dev, "ioremap failed\n");
+                goto err_reg;
         }
 
-        if (misc_register(&sx_fw_device) < 0) {
-                printk(KERN_ERR "SX: Unable to register firmware loader driver.\n");
-                return -EIO;
+        /* Most of the stuff on the CF board is offset by 0x18000 ....  */
+        if (IS_CF_BOARD(board))
+                board->base += 0x18000;
+
+        board->irq = pdev->irq;
+
+        dev_info(&pdev->dev, "Got a specialix card: %p(%d) %x.\n", board->base,
+                 board->irq, board->flags);
+
+        if (!probe_sx(board)) {
+                retval = -EIO;
+                goto err_unmap;
         }
 
-#ifdef CONFIG_PCI
-        while ((pdev = pci_find_device (PCI_VENDOR_ID_SPECIALIX, 
-                                        PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8, 
-                                              pdev))) {
-                if (pci_enable_device(pdev))
-                        continue;
+        fix_sx_pci(pdev, board);
 
-                /* Specialix has a whole bunch of cards with
-                   0x2000 as the device ID. They say its because
-                   the standard requires it. Stupid standard. */
-                /* It seems that reading a word doesn't work reliably on 2.0.
-                   Also, reading a non-aligned dword doesn't work. So we read the
-                   whole dword at 0x2c and extract the word at 0x2e (SUBSYSTEM_ID)
-                   ourselves */
-                /* I don't know why the define doesn't work, constant 0x2c does --REW */ 
-                pci_read_config_dword (pdev, 0x2c, &tint);
-                tshort = (tint >> 16) & 0xffff;
-                sx_dprintk (SX_DEBUG_PROBE, "Got a specialix card: %x.\n", tint);
-                /* sx_dprintk (SX_DEBUG_PROBE, "pdev = %d/%d    (%x)\n", pdev, tint); */ 
-                if ((tshort != 0x0200) && (tshort != 0x0300)) {
-                        sx_dprintk (SX_DEBUG_PROBE, "But it's not an SX card (%d)...\n", 
-                                    tshort);
-                        continue;
-                }
-                board = &boards[found];
+        pci_set_drvdata(pdev, board);
 
-                board->flags &= ~SX_BOARD_TYPE;
-                board->flags |= (tshort == 0x200)?SX_PCI_BOARD:
-                                                  SX_CFPCI_BOARD;
-
-                /* CF boards use base address 3.... */
-                if (IS_CF_BOARD (board))
-                        board->hw_base = pci_resource_start (pdev, 3);
-                else
-                        board->hw_base = pci_resource_start (pdev, 2);
-                board->base2 = 
-                board->base = ioremap(board->hw_base, WINDOW_LEN (board));
-                if (!board->base) {
-                        printk(KERN_ERR "ioremap failed\n");
-                        /* XXX handle error */
-                }
+        return 0;
+err_unmap:
+        pci_iounmap(pdev, board->base);
+err_reg:
+        pci_release_region(pdev, reg);
+err_flag:
+        board->flags &= ~SX_BOARD_PRESENT;
+err:
+        return retval;
+}
 
-                /* Most of the stuff on the CF board is offset by
-                   0x18000 ....  */
-                if (IS_CF_BOARD (board)) board->base += 0x18000;
+static void __devexit sx_pci_remove(struct pci_dev *pdev)
+{
+        struct sx_board *board = pci_get_drvdata(pdev);
 
-                board->irq = pdev->irq;
+        sx_remove_card(board, pdev);
+}
 
-                sx_dprintk (SX_DEBUG_PROBE, "Got a specialix card: %x/%p(%d) %x.\n", 
-                            tint, boards[found].base, board->irq, board->flags);
+/* Specialix has a whole bunch of cards with 0x2000 as the device ID. They say
+   its because the standard requires it. So check for SUBVENDOR_ID. */
+static struct pci_device_id sx_pci_tbl[] = {
+        { PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
+                .subvendor = 0x0200,.subdevice = PCI_ANY_ID },
+        { PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
+                .subvendor = 0x0300,.subdevice = PCI_ANY_ID },
+        { 0 }
+};
 
-                if (probe_sx (board)) {
-                        found++;
-                        fix_sx_pci (pdev, board);
-                } else 
-                        iounmap(board->base2);
-        }
+MODULE_DEVICE_TABLE(pci, sx_pci_tbl);
+
+static struct pci_driver sx_pcidriver = {
+        .name = "sx",
+        .id_table = sx_pci_tbl,
+        .probe = sx_pci_probe,
+        .remove = __devexit_p(sx_pci_remove)
+};
+
+static int __init sx_init(void)
+{
+#ifdef CONFIG_EISA
+        int retval1;
 #endif
+#ifdef CONFIG_ISA
+        struct sx_board *board;
+        unsigned int i;
+#endif
+        unsigned int found = 0;
+        int retval;
+
+        func_enter();
+        sx_dprintk(SX_DEBUG_INIT, "Initing sx module... (sx_debug=%d)\n",
+                        sx_debug);
+        if (abs((long)(&sx_debug) - sx_debug) < 0x10000) {
+                printk(KERN_WARNING "sx: sx_debug is an address, instead of a "
+                                "value. Assuming -1.\n(%p)\n", &sx_debug);
+                sx_debug = -1;
+        }
 
-        for (i=0;i<NR_SX_ADDRS;i++) {
+        if (misc_register(&sx_fw_device) < 0) {
+                printk(KERN_ERR "SX: Unable to register firmware loader "
+                                "driver.\n");
+                return -EIO;
+        }
+#ifdef CONFIG_ISA
+        for (i = 0; i < NR_SX_ADDRS; i++) {
                 board = &boards[found];
                 board->hw_base = sx_probe_addrs[i];
+                board->hw_len = SX_WINDOW_LEN;
+                if (!request_region(board->hw_base, board->hw_len, "sx"))
+                        continue;
                 board->base2 =
-                board->base = ioremap(board->hw_base, SX_WINDOW_LEN);
+                board->base = ioremap(board->hw_base, board->hw_len);
+                if (!board->base)
+                        goto err_sx_reg;
                 board->flags &= ~SX_BOARD_TYPE;
-                board->flags |= SX_ISA_BOARD;
-                board->irq = sx_irqmask?-1:0;
+                board->flags |= SX_ISA_BOARD;
+                board->irq = sx_irqmask ? -1 : 0;
 
-                if (probe_sx (board)) {
+                if (probe_sx(board)) {
+                        board->flags |= SX_BOARD_PRESENT;
                         found++;
                 } else {
                         iounmap(board->base);
+err_sx_reg:
+                        release_region(board->hw_base, board->hw_len);
                 }
         }
 
-        for (i=0;i<NR_SI_ADDRS;i++) {
+        for (i = 0; i < NR_SI_ADDRS; i++) {
                 board = &boards[found];
                 board->hw_base = si_probe_addrs[i];
+                board->hw_len = SI2_ISA_WINDOW_LEN;
+                if (!request_region(board->hw_base, board->hw_len, "sx"))
+                        continue;
                 board->base2 =
-                board->base = ioremap(board->hw_base, SI2_ISA_WINDOW_LEN);
+                board->base = ioremap(board->hw_base, board->hw_len);
+                if (!board->base)
+                        goto err_si_reg;
                 board->flags &= ~SX_BOARD_TYPE;
-                board->flags |=  SI_ISA_BOARD;
-                board->irq = sx_irqmask ?-1:0;
+                board->flags |= SI_ISA_BOARD;
+                board->irq = sx_irqmask ? -1 : 0;
 
-                if (probe_si (board)) {
+                if (probe_si(board)) {
+                        board->flags |= SX_BOARD_PRESENT;
                         found++;
                 } else {
-                        iounmap (board->base);
+                        iounmap(board->base);
+err_si_reg:
+                        release_region(board->hw_base, board->hw_len);
                 }
         }
-        for (i=0;i<NR_SI1_ADDRS;i++) {
+        for (i = 0; i < NR_SI1_ADDRS; i++) {
                 board = &boards[found];
                 board->hw_base = si1_probe_addrs[i];
+                board->hw_len = SI1_ISA_WINDOW_LEN;
+                if (!request_region(board->hw_base, board->hw_len, "sx"))
+                        continue;
                 board->base2 =
-                board->base = ioremap(board->hw_base, SI1_ISA_WINDOW_LEN);
+                board->base = ioremap(board->hw_base, board->hw_len);
+                if (!board->base)
+                        goto err_si1_reg;
                 board->flags &= ~SX_BOARD_TYPE;
-                board->flags |=  SI1_ISA_BOARD;
-                board->irq = sx_irqmask ?-1:0;
+                board->flags |= SI1_ISA_BOARD;
+                board->irq = sx_irqmask ? -1 : 0;
 
-                if (probe_si (board)) {
+                if (probe_si(board)) {
+                        board->flags |= SX_BOARD_PRESENT;
                         found++;
                 } else {
-                        iounmap (board->base);
+                        iounmap(board->base);
+err_si1_reg:
+                        release_region(board->hw_base, board->hw_len);
                 }
         }
+#endif
+#ifdef CONFIG_EISA
+        retval1 = eisa_driver_register(&sx_eisadriver);
+#endif
+        retval = pci_register_driver(&sx_pcidriver);
 
-        sx_dprintk(SX_DEBUG_PROBE, "Probing for EISA cards\n");
-        for(eisa_slot=0x1000; eisa_slot<0x10000; eisa_slot+=0x1000)
-        {
-                if((inb(eisa_slot+0xc80)==0x4d) &&
-                   (inb(eisa_slot+0xc81)==0x98))
-                {
-                        sx_dprintk(SX_DEBUG_PROBE, "%s : Signature found in EISA slot %d, Product %d Rev %d\n",
-                                                "XIO", (eisa_slot>>12), inb(eisa_slot+0xc82), inb(eisa_slot+0xc83));
-
-                        board = &boards[found];
-                        board->eisa_base = eisa_slot;
-                        board->flags &= ~SX_BOARD_TYPE;
-                        board->flags |= SI_EISA_BOARD;
-
-                        board->hw_base = (((inb(0xc01+eisa_slot) << 8) + inb(0xc00+eisa_slot)) << 16);
-                        board->base2 =
-                        board->base = ioremap(board->hw_base, SI2_EISA_WINDOW_LEN);
-
-                        sx_dprintk(SX_DEBUG_PROBE, "IO hw_base address: %lx\n", board->hw_base);
-                        sx_dprintk(SX_DEBUG_PROBE, "base: %p\n", board->base);
-                        board->irq = inb(board->eisa_base+0xc02)>>4; 
-                        sx_dprintk(SX_DEBUG_PROBE, "IRQ: %d\n", board->irq);
-                        
-                        probe_si(board);
-
-                        found++;
-                }
-        }
         if (found) {
-                printk (KERN_INFO "sx: total of %d boards detected.\n", found);
-        } else {
-                misc_deregister(&sx_fw_device);
+                printk(KERN_INFO "sx: total of %d boards detected.\n", found);
+                retval = 0;
+        } else if (retval) {
+#ifdef CONFIG_EISA
+                retval = retval1;
+                if (retval1)
+#endif
+                        misc_deregister(&sx_fw_device);
         }
 
         func_exit();
-        return found?0:-EIO;
+        return retval;
 }
 
-
-static void __exit sx_exit (void)
+static void __exit sx_exit(void)
 {
-        int i; 
-        struct sx_board *board;
+        int i;
 
         func_enter();
-        for (i = 0; i < SX_NBOARDS; i++) {
-                board = &boards[i];
-                if (board->flags & SX_BOARD_INITIALIZED) {
-                        sx_dprintk (SX_DEBUG_CLEANUP, "Cleaning up board at %p\n", board->base);
-                        /* The board should stop messing with us.
-                           (actually I mean the interrupt) */
-                        sx_reset (board);
-                        if ((board->irq) && (board->flags & SX_IRQ_ALLOCATED))
-                                free_irq (board->irq, board);
-
-                        /* It is safe/allowed to del_timer a non-active timer */
-                        del_timer (& board->timer);
-                        iounmap(board->base);
-                }
-        }
+#ifdef CONFIG_EISA
+        eisa_driver_unregister(&sx_eisadriver);
+#endif
+        pci_unregister_driver(&sx_pcidriver);
+
+        for (i = 0; i < SX_NBOARDS; i++)
+                sx_remove_card(&boards[i], NULL);
+
         if (misc_deregister(&sx_fw_device) < 0) {
-                printk (KERN_INFO "sx: couldn't deregister firmware loader devic\n");
+                printk(KERN_INFO "sx: couldn't deregister firmware loader "
+                                "device\n");
         }
-        sx_dprintk (SX_DEBUG_CLEANUP, "Cleaning up drivers (%d)\n", sx_initialized);
+        sx_dprintk(SX_DEBUG_CLEANUP, "Cleaning up drivers (%d)\n",
+                        sx_initialized);
         if (sx_initialized)
-                sx_release_drivers ();
+                sx_release_drivers();
 
-        kfree (sx_ports);
+        kfree(sx_ports);
         func_exit();
 }
 
 module_init(sx_init);
 module_exit(sx_exit);
-
-
diff --git a/drivers/char/sx.h b/drivers/char/sx.h
index e01f83cbe299..432aad0a2ddd 100644
--- a/drivers/char/sx.h
+++ b/drivers/char/sx.h
@@ -35,6 +35,7 @@ struct sx_board {
   void __iomem *base;
   void __iomem *base2;
   unsigned long hw_base;
+  resource_size_t hw_len;
   int eisa_base;
   int port_base; /* Number of the first port */
   struct sx_port *ports;
diff --git a/drivers/char/synclink.c b/drivers/char/synclink.c
index 78b1b1a2732b..acc6fab601cc 100644
--- a/drivers/char/synclink.c
+++ b/drivers/char/synclink.c
@@ -63,7 +63,6 @@
 #define MAX_PCI_DEVICES 10
 #define MAX_TOTAL_DEVICES 20
 
-#include <linux/config.h>       
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/signal.h>
@@ -87,7 +86,6 @@
 
 #include <linux/vmalloc.h>
 #include <linux/init.h>
-#include <asm/serial.h>
 
 #include <linux/delay.h>
 #include <linux/ioctl.h>
@@ -103,8 +101,10 @@
 #include <linux/hdlc.h>
 #include <linux/dma-mapping.h>
 
-#ifdef CONFIG_HDLC_MODULE
-#define CONFIG_HDLC 1
+#if defined(CONFIG_HDLC) || (defined(CONFIG_HDLC_MODULE) && defined(CONFIG_SYNCLINK_MODULE))
+#define SYNCLINK_GENERIC_HDLC 1
+#else
+#define SYNCLINK_GENERIC_HDLC 0
 #endif
 
 #define GET_USER(error,value,addr) error = get_user(value,addr)
@@ -135,8 +135,8 @@ static MGSL_PARAMS default_params = {
 };
 
 #define SHARED_MEM_ADDRESS_SIZE 0x40000
-#define BUFFERLISTSIZE (PAGE_SIZE)
-#define DMABUFFERSIZE (PAGE_SIZE)
+#define BUFFERLISTSIZE 4096
+#define DMABUFFERSIZE 4096
 #define MAXRXFRAMES 7
 
 typedef struct _DMABUFFERENTRY
@@ -322,7 +322,7 @@ struct mgsl_struct {
         int dosyncppp;
         spinlock_t netlock;
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
         struct net_device *netdev;
 #endif
 };
@@ -730,7 +730,7 @@ static void usc_loopmode_send_done( struct mgsl_struct * info );
 
 static int mgsl_ioctl_common(struct mgsl_struct *info, unsigned int cmd, unsigned long arg);
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
 #define dev_to_port(D) (dev_to_hdlc(D)->priv)
 static void hdlcdev_tx_done(struct mgsl_struct *info);
 static void hdlcdev_rx(struct mgsl_struct *info, char *buf, int size);
@@ -804,7 +804,7 @@ static int save_tx_buffer_request(struct mgsl_struct *info,const char *Buffer, u
 /*
  * Bottom half interrupt handlers
  */
-static void mgsl_bh_handler(void* Context);
+static void mgsl_bh_handler(struct work_struct *work);
 static void mgsl_bh_receive(struct mgsl_struct *info);
 static void mgsl_bh_transmit(struct mgsl_struct *info);
 static void mgsl_bh_status(struct mgsl_struct *info);
@@ -1073,9 +1073,10 @@ static int mgsl_bh_action(struct mgsl_struct *info)
 /*
  *      Perform bottom half processing of work items queued by ISR.
  */
-static void mgsl_bh_handler(void* Context)
+static void mgsl_bh_handler(struct work_struct *work)
 {
-        struct mgsl_struct *info = (struct mgsl_struct*)Context;
+        struct mgsl_struct *info =
+                container_of(work, struct mgsl_struct, task);
         int action;
 
         if (!info)
@@ -1278,7 +1279,7 @@ static void mgsl_isr_transmit_status( struct mgsl_struct *info )
                 info->drop_rts_on_tx_done = 0;
         }
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
         if (info->netcount)
                 hdlcdev_tx_done(info);
         else 
@@ -1343,7 +1344,7 @@ static void mgsl_isr_io_pin( struct mgsl_struct *info )
                                 info->input_signal_events.dcd_up++;
                         } else
                                 info->input_signal_events.dcd_down++;
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
                         if (info->netcount) {
                                 if (status & MISCSTATUS_DCD)
                                         netif_carrier_on(info->netdev);
@@ -1700,11 +1701,10 @@ static void mgsl_isr_transmit_dma( struct mgsl_struct *info )
  * 
  *      irq             interrupt number that caused interrupt
  *      dev_id          device ID supplied during interrupt registration
- *      regs            interrupted processor context
  *      
  * Return Value: None
  */
-static irqreturn_t mgsl_interrupt(int irq, void *dev_id, struct pt_regs * regs)
+static irqreturn_t mgsl_interrupt(int irq, void *dev_id)
 {
         struct mgsl_struct * info;
         u16 UscVector;
@@ -3060,7 +3060,7 @@ static int mgsl_ioctl_common(struct mgsl_struct *info, unsigned int cmd, unsigne
  *      
  * Return Value:                None
  */
-static void mgsl_set_termios(struct tty_struct *tty, struct termios *old_termios)
+static void mgsl_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
 {
         struct mgsl_struct *info = (struct mgsl_struct *)tty->driver_data;
         unsigned long flags;
@@ -4315,7 +4315,7 @@ static void mgsl_add_device( struct mgsl_struct *info )
                         info->max_frame_size );
         }
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
         hdlcdev_init(info);
 #endif
 
@@ -4340,7 +4340,7 @@ static struct mgsl_struct* mgsl_allocate_device(void)
         } else {
                 memset(info, 0, sizeof(struct mgsl_struct));
                 info->magic = MGSL_MAGIC;
-                INIT_WORK(&info->task, mgsl_bh_handler, info);
+                INIT_WORK(&info->task, mgsl_bh_handler);
                 info->max_frame_size = 4096;
                 info->close_delay = 5*HZ/10;
                 info->closing_wait = 30*HZ;
@@ -4360,7 +4360,7 @@ static struct mgsl_struct* mgsl_allocate_device(void)
 
 }       /* end of mgsl_allocate_device()*/
 
-static struct tty_operations mgsl_ops = {
+static const struct tty_operations mgsl_ops = {
         .open = mgsl_open,
         .close = mgsl_close,
         .write = mgsl_write,
@@ -4405,6 +4405,8 @@ static int mgsl_init_tty(void)
         serial_driver->init_termios = tty_std_termios;
         serial_driver->init_termios.c_cflag =
                 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+        serial_driver->init_termios.c_ispeed = 9600;
+        serial_driver->init_termios.c_ospeed = 9600;
         serial_driver->flags = TTY_DRIVER_REAL_RAW;
         tty_set_operations(serial_driver, &mgsl_ops);
         if ((rc = tty_register_driver(serial_driver)) < 0) {
@@ -4473,7 +4475,7 @@ static void synclink_cleanup(void)
 
         info = mgsl_device_list;
         while(info) {
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
                 hdlcdev_exit(info);
 #endif
                 mgsl_release_resources(info);
@@ -6647,7 +6649,7 @@ static int mgsl_get_rx_frame(struct mgsl_struct *info)
                                 return_frame = 1;
                 }
                 framesize = 0;
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
                 {
                         struct net_device_stats *stats = hdlc_stats(info->netdev);
                         stats->rx_errors++;
@@ -6723,7 +6725,7 @@ static int mgsl_get_rx_frame(struct mgsl_struct *info)
                                                 *ptmp);
                         }
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
                         if (info->netcount)
                                 hdlcdev_rx(info,info->intermediate_rxbuffer,framesize);
                         else
@@ -7627,7 +7629,7 @@ static void mgsl_tx_timeout(unsigned long context)
 
         spin_unlock_irqrestore(&info->irq_spinlock,flags);
         
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
         if (info->netcount)
                 hdlcdev_tx_done(info);
         else
@@ -7703,7 +7705,7 @@ static int usc_loopmode_active( struct mgsl_struct * info)
         return usc_InReg( info, CCSR ) & BIT7 ? 1 : 0 ;
 }
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
 
 /**
  * called by generic HDLC layer when protocol selected (PPP, frame relay, etc.)
diff --git a/drivers/char/synclink_gt.c b/drivers/char/synclink_gt.c
index 2f07b085536b..792c79c315e0 100644
--- a/drivers/char/synclink_gt.c
+++ b/drivers/char/synclink_gt.c
@@ -1,5 +1,5 @@
 /*
- * $Id: synclink_gt.c,v 4.25 2006/02/06 21:20:33 paulkf Exp $
+ * $Id: synclink_gt.c,v 4.36 2006/08/28 20:47:14 paulkf Exp $
  *
  * Device driver for Microgate SyncLink GT serial adapters.
  *
@@ -83,20 +83,22 @@
 
 #include "linux/synclink.h"
 
-#ifdef CONFIG_HDLC_MODULE
-#define CONFIG_HDLC 1
+#if defined(CONFIG_HDLC) || (defined(CONFIG_HDLC_MODULE) && defined(CONFIG_SYNCLINK_GT_MODULE))
+#define SYNCLINK_GENERIC_HDLC 1
+#else
+#define SYNCLINK_GENERIC_HDLC 0
 #endif
 
 /*
  * module identification
  */
 static char *driver_name     = "SyncLink GT";
-static char *driver_version  = "$Revision: 4.25 $";
+static char *driver_version  = "$Revision: 4.36 $";
 static char *tty_driver_name = "synclink_gt";
 static char *tty_dev_prefix  = "ttySLG";
 MODULE_LICENSE("GPL");
 #define MGSL_MAGIC 0x5401
-#define MAX_DEVICES 12
+#define MAX_DEVICES 32
 
 static struct pci_device_id pci_table[] = {
         {PCI_VENDOR_ID_MICROGATE, SYNCLINK_GT_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
@@ -149,7 +151,7 @@ static struct tty_driver *serial_driver;
 static int  open(struct tty_struct *tty, struct file * filp);
 static void close(struct tty_struct *tty, struct file * filp);
 static void hangup(struct tty_struct *tty);
-static void set_termios(struct tty_struct *tty, struct termios *old_termios);
+static void set_termios(struct tty_struct *tty, struct ktermios *old_termios);
 
 static int  write(struct tty_struct *tty, const unsigned char *buf, int count);
 static void put_char(struct tty_struct *tty, unsigned char ch);
@@ -171,7 +173,7 @@ static void set_break(struct tty_struct *tty, int break_state);
 /*
  * generic HDLC support and callbacks
  */
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
 #define dev_to_port(D) (dev_to_hdlc(D)->priv)
 static void hdlcdev_tx_done(struct slgt_info *info);
 static void hdlcdev_rx(struct slgt_info *info, char *buf, int size);
@@ -359,7 +361,7 @@ struct slgt_info {
         int netcount;
         int dosyncppp;
         spinlock_t netlock;
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
         struct net_device *netdev;
 #endif
 
@@ -461,7 +463,7 @@ static int  adapter_test(struct slgt_info *info);
 static void reset_adapter(struct slgt_info *info);
 static void reset_port(struct slgt_info *info);
 static void async_mode(struct slgt_info *info);
-static void hdlc_mode(struct slgt_info *info);
+static void sync_mode(struct slgt_info *info);
 
 static void rx_stop(struct slgt_info *info);
 static void rx_start(struct slgt_info *info);
@@ -485,13 +487,13 @@ static void enable_loopback(struct slgt_info *info);
 static void set_rate(struct slgt_info *info, u32 data_rate);
 
 static int  bh_action(struct slgt_info *info);
-static void bh_handler(void* context);
+static void bh_handler(struct work_struct *work);
 static void bh_transmit(struct slgt_info *info);
 static void isr_serial(struct slgt_info *info);
 static void isr_rdma(struct slgt_info *info);
 static void isr_txeom(struct slgt_info *info, unsigned short status);
 static void isr_tdma(struct slgt_info *info);
-static irqreturn_t slgt_interrupt(int irq, void *dev_id, struct pt_regs * regs);
+static irqreturn_t slgt_interrupt(int irq, void *dev_id);
 
 static int  alloc_dma_bufs(struct slgt_info *info);
 static void free_dma_bufs(struct slgt_info *info);
@@ -814,7 +816,7 @@ static void hangup(struct tty_struct *tty)
         wake_up_interruptible(&info->open_wait);
 }
 
-static void set_termios(struct tty_struct *tty, struct termios *old_termios)
+static void set_termios(struct tty_struct *tty, struct ktermios *old_termios)
 {
         struct slgt_info *info = tty->driver_data;
         unsigned long flags;
@@ -881,7 +883,9 @@ static int write(struct tty_struct *tty,
         if (!count)
                 goto cleanup;
 
-        if (info->params.mode == MGSL_MODE_RAW) {
+        if (info->params.mode == MGSL_MODE_RAW ||
+            info->params.mode == MGSL_MODE_MONOSYNC ||
+            info->params.mode == MGSL_MODE_BISYNC) {
                 unsigned int bufs_needed = (count/DMABUFSIZE);
                 unsigned int bufs_free = free_tbuf_count(info);
                 if (count % DMABUFSIZE)
@@ -1352,7 +1356,7 @@ static void set_break(struct tty_struct *tty, int break_state)
         spin_unlock_irqrestore(&info->lock,flags);
 }
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
 
 /**
  * called by generic HDLC layer when protocol selected (PPP, frame relay, etc.)
@@ -1876,9 +1880,9 @@ static int bh_action(struct slgt_info *info)
 /*
  * perform bottom half processing
  */
-static void bh_handler(void* context)
+static void bh_handler(struct work_struct *work)
 {
-        struct slgt_info *info = context;
+        struct slgt_info *info = container_of(work, struct slgt_info, task);
         int action;
 
         if (!info)
@@ -1897,6 +1901,8 @@ static void bh_handler(void* context)
                                 while(rx_get_frame(info));
                                 break;
                         case MGSL_MODE_RAW:
+                        case MGSL_MODE_MONOSYNC:
+                        case MGSL_MODE_BISYNC:
                                 while(rx_get_buf(info));
                                 break;
                         }
@@ -1998,7 +2004,7 @@ static void dcd_change(struct slgt_info *info)
         } else {
                 info->input_signal_events.dcd_down++;
         }
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
         if (info->netcount) {
                 if (info->signals & SerialSignal_DCD)
                         netif_carrier_on(info->netdev);
@@ -2176,7 +2182,7 @@ static void isr_txeom(struct slgt_info *info, unsigned short status)
                         set_signals(info);
                 }
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
                 if (info->netcount)
                         hdlcdev_tx_done(info);
                 else
@@ -2213,9 +2219,8 @@ static void isr_gpio(struct slgt_info *info, unsigned int changed, unsigned int
  *
  *      irq     interrupt number
  *      dev_id  device ID supplied during interrupt registration
- *      regs    interrupted processor context
  */
-static irqreturn_t slgt_interrupt(int irq, void *dev_id, struct pt_regs * regs)
+static irqreturn_t slgt_interrupt(int irq, void *dev_id)
 {
         struct slgt_info *info;
         unsigned int gsr;
@@ -2362,10 +2367,9 @@ static void program_hw(struct slgt_info *info)
         rx_stop(info);
         tx_stop(info);
 
-        if (info->params.mode == MGSL_MODE_HDLC ||
-            info->params.mode == MGSL_MODE_RAW ||
+        if (info->params.mode != MGSL_MODE_ASYNC ||
             info->netcount)
-                hdlc_mode(info);
+                sync_mode(info);
         else
                 async_mode(info);
 
@@ -2564,6 +2568,10 @@ static int rx_enable(struct slgt_info *info, int enable)
         if (enable) {
                 if (!info->rx_enabled)
                         rx_start(info);
+                else if (enable == 2) {
+                        /* force hunt mode (write 1 to RCR[3]) */
+                        wr_reg16(info, RCR, rd_reg16(info, RCR) | BIT3);
+                }
         } else {
                 if (info->rx_enabled)
                         rx_stop(info);
@@ -3300,7 +3308,7 @@ static void add_device(struct slgt_info *info)
                 devstr, info->device_name, info->phys_reg_addr,
                 info->irq_level, info->max_frame_size);
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
         hdlcdev_init(info);
 #endif
 }
@@ -3320,7 +3328,7 @@ static struct slgt_info *alloc_dev(int adapter_num, int port_num, struct pci_dev
         } else {
                 memset(info, 0, sizeof(struct slgt_info));
                 info->magic = MGSL_MAGIC;
-                INIT_WORK(&info->task, bh_handler, info);
+                INIT_WORK(&info->task, bh_handler);
                 info->max_frame_size = 4096;
                 info->raw_rx_size = DMABUFSIZE;
                 info->close_delay = 5*HZ/10;
@@ -3434,7 +3442,7 @@ static void __devexit remove_one(struct pci_dev *dev)
 {
 }
 
-static struct tty_operations ops = {
+static const struct tty_operations ops = {
         .open = open,
         .close = close,
         .write = write,
@@ -3482,7 +3490,7 @@ static void slgt_cleanup(void)
         /* release devices */
         info = slgt_device_list;
         while(info) {
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
                 hdlcdev_exit(info);
 #endif
                 free_dma_bufs(info);
@@ -3516,6 +3524,7 @@ static int __init slgt_init(void)
 
         if (!slgt_device_list) {
                 printk("%s no devices found\n",driver_name);
+                pci_unregister_driver(&pci_driver);
                 return -ENODEV;
         }
 
@@ -3537,6 +3546,8 @@ static int __init slgt_init(void)
         serial_driver->init_termios = tty_std_termios;
         serial_driver->init_termios.c_cflag =
                 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+        serial_driver->init_termios.c_ispeed = 9600;
+        serial_driver->init_termios.c_ospeed = 9600;
         serial_driver->flags = TTY_DRIVER_REAL_RAW;
         tty_set_operations(serial_driver, &ops);
         if ((rc = tty_register_driver(serial_driver)) < 0) {
@@ -3748,7 +3759,7 @@ static void tx_start(struct slgt_info *info)
 {
         if (!info->tx_enabled) {
                 wr_reg16(info, TCR,
-                        (unsigned short)(rd_reg16(info, TCR) | BIT1));
+                         (unsigned short)((rd_reg16(info, TCR) | BIT1) & ~BIT2));
                 info->tx_enabled = TRUE;
         }
 
@@ -3775,13 +3786,18 @@ static void tx_start(struct slgt_info *info)
                                 tdma_reset(info);
                                 /* set 1st descriptor address */
                                 wr_reg32(info, TDDAR, info->tbufs[info->tbuf_start].pdesc);
-                                if (info->params.mode == MGSL_MODE_RAW)
+                                switch(info->params.mode) {
+                                case MGSL_MODE_RAW:
+                                case MGSL_MODE_MONOSYNC:
+                                case MGSL_MODE_BISYNC:
                                         wr_reg32(info, TDCSR, BIT2 + BIT0); /* IRQ + DMA enable */
-                                else
+                                        break;
+                                default:
                                         wr_reg32(info, TDCSR, BIT0); /* DMA enable */
+                                }
                         }
 
-                        if (info->params.mode != MGSL_MODE_RAW) {
+                        if (info->params.mode == MGSL_MODE_HDLC) {
                                 info->tx_timer.expires = jiffies + msecs_to_jiffies(5000);
                                 add_timer(&info->tx_timer);
                         }
@@ -3814,7 +3830,6 @@ static void tx_stop(struct slgt_info *info)
         /* reset and disable transmitter */
         val = rd_reg16(info, TCR) & ~BIT1;          /* clear enable bit */
         wr_reg16(info, TCR, (unsigned short)(val | BIT2)); /* set reset bit */
-        wr_reg16(info, TCR, val);                  /* clear reset */
 
         slgt_irq_off(info, IRQ_TXDATA + IRQ_TXIDLE + IRQ_TXUNDER);
 
@@ -3982,7 +3997,7 @@ static void async_mode(struct slgt_info *info)
                 enable_loopback(info);
 }
 
-static void hdlc_mode(struct slgt_info *info)
+static void sync_mode(struct slgt_info *info)
 {
         unsigned short val;
 
@@ -3992,7 +4007,7 @@ static void hdlc_mode(struct slgt_info *info)
 
         /* TCR (tx control)
          *
-         * 15..13  mode, 000=HDLC 001=raw sync
+         * 15..13  mode, 000=HDLC 001=raw 010=async 011=monosync 100=bisync
          * 12..10  encoding
          * 09      CRC enable
          * 08      CRC32
@@ -4006,8 +4021,11 @@ static void hdlc_mode(struct slgt_info *info)
          */
         val = 0;
 
-        if (info->params.mode == MGSL_MODE_RAW)
-                val |= BIT13;
+        switch(info->params.mode) {
+        case MGSL_MODE_MONOSYNC: val |= BIT14 + BIT13; break;
+        case MGSL_MODE_BISYNC:   val |= BIT15; break;
+        case MGSL_MODE_RAW:      val |= BIT13; break;
+        }
         if (info->if_mode & MGSL_INTERFACE_RTS_EN)
                 val |= BIT7;
 
@@ -4058,7 +4076,7 @@ static void hdlc_mode(struct slgt_info *info)
 
         /* RCR (rx control)
          *
-         * 15..13  mode, 000=HDLC 001=raw sync
+         * 15..13  mode, 000=HDLC 001=raw 010=async 011=monosync 100=bisync
          * 12..10  encoding
          * 09      CRC enable
          * 08      CRC32
@@ -4069,8 +4087,11 @@ static void hdlc_mode(struct slgt_info *info)
          */
         val = 0;
 
-        if (info->params.mode == MGSL_MODE_RAW)
-                val |= BIT13;
+        switch(info->params.mode) {
+        case MGSL_MODE_MONOSYNC: val |= BIT14 + BIT13; break;
+        case MGSL_MODE_BISYNC:   val |= BIT15; break;
+        case MGSL_MODE_RAW:      val |= BIT13; break;
+        }
 
         switch(info->params.encoding)
         {
@@ -4309,10 +4330,15 @@ static void free_rbufs(struct slgt_info *info, unsigned int i, unsigned int last
         while(!done) {
                 /* reset current buffer for reuse */
                 info->rbufs[i].status = 0;
-                if (info->params.mode == MGSL_MODE_RAW)
+                switch(info->params.mode) {
+                case MGSL_MODE_RAW:
+                case MGSL_MODE_MONOSYNC:
+                case MGSL_MODE_BISYNC:
                         set_desc_count(info->rbufs[i], info->raw_rx_size);
-                else
+                        break;
+                default:
                         set_desc_count(info->rbufs[i], DMABUFSIZE);
+                }
 
                 if (i == last)
                         done = 1;
@@ -4412,7 +4438,7 @@ check_again:
                         framesize = 0;
         }
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
         if (framesize == 0) {
                 struct net_device_stats *stats = hdlc_stats(info->netdev);
                 stats->rx_errors++;
@@ -4455,7 +4481,7 @@ check_again:
                                 framesize++;
                         }
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
                         if (info->netcount)
                                 hdlcdev_rx(info,info->tmp_rbuf, framesize);
                         else
@@ -4477,13 +4503,24 @@ cleanup:
 static int rx_get_buf(struct slgt_info *info)
 {
         unsigned int i = info->rbuf_current;
+        unsigned int count;
 
         if (!desc_complete(info->rbufs[i]))
                 return 0;
-        DBGDATA(info, info->rbufs[i].buf, desc_count(info->rbufs[i]), "rx");
-        DBGINFO(("rx_get_buf size=%d\n", desc_count(info->rbufs[i])));
-        ldisc_receive_buf(info->tty, info->rbufs[i].buf,
-                          info->flag_buf, desc_count(info->rbufs[i]));
+        count = desc_count(info->rbufs[i]);
+        switch(info->params.mode) {
+        case MGSL_MODE_MONOSYNC:
+        case MGSL_MODE_BISYNC:
+                /* ignore residue in byte synchronous modes */
+                if (desc_residue(info->rbufs[i]))
+                        count--;
+                break;
+        }
+        DBGDATA(info, info->rbufs[i].buf, count, "rx");
+        DBGINFO(("rx_get_buf size=%d\n", count));
+        if (count)
+                ldisc_receive_buf(info->tty, info->rbufs[i].buf,
+                                  info->flag_buf, count);
         free_rbufs(info, i, i);
         return 1;
 }
@@ -4549,8 +4586,13 @@ static void tx_load(struct slgt_info *info, const char *buf, unsigned int size)
                 size -= count;
                 buf  += count;
 
-                if (!size && info->params.mode != MGSL_MODE_RAW)
-                        set_desc_eof(*d, 1); /* HDLC: set EOF of last desc */
+                /*
+                 * set EOF bit for last buffer of HDLC frame or
+                 * for every buffer in raw mode
+                 */
+                if ((!size && info->params.mode == MGSL_MODE_HDLC) ||
+                    info->params.mode == MGSL_MODE_RAW)
+                        set_desc_eof(*d, 1);
                 else
                         set_desc_eof(*d, 0);
 
@@ -4742,7 +4784,7 @@ static void tx_timeout(unsigned long context)
         info->tx_count = 0;
         spin_unlock_irqrestore(&info->lock,flags);
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
         if (info->netcount)
                 hdlcdev_tx_done(info);
         else
@@ -4762,6 +4804,6 @@ static void rx_timeout(unsigned long context)
         spin_lock_irqsave(&info->lock, flags);
         info->pending_bh |= BH_RECEIVE;
         spin_unlock_irqrestore(&info->lock, flags);
-        bh_handler(info);
+        bh_handler(&info->task);
 }
 
diff --git a/drivers/char/synclinkmp.c b/drivers/char/synclinkmp.c
index 66f3754fbbdf..53e8ccf94fe3 100644
--- a/drivers/char/synclinkmp.c
+++ b/drivers/char/synclinkmp.c
@@ -67,8 +67,10 @@
 #include <linux/workqueue.h>
 #include <linux/hdlc.h>
 
-#ifdef CONFIG_HDLC_MODULE
-#define CONFIG_HDLC 1
+#if defined(CONFIG_HDLC) || (defined(CONFIG_HDLC_MODULE) && defined(CONFIG_SYNCLINKMP_MODULE))
+#define SYNCLINK_GENERIC_HDLC 1
+#else
+#define SYNCLINK_GENERIC_HDLC 0
 #endif
 
 #define GET_USER(error,value,addr) error = get_user(value,addr)
@@ -280,7 +282,7 @@ typedef struct _synclinkmp_info {
         int dosyncppp;
         spinlock_t netlock;
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
         struct net_device *netdev;
 #endif
 
@@ -517,7 +519,7 @@ static struct tty_driver *serial_driver;
 static int  open(struct tty_struct *tty, struct file * filp);
 static void close(struct tty_struct *tty, struct file * filp);
 static void hangup(struct tty_struct *tty);
-static void set_termios(struct tty_struct *tty, struct termios *old_termios);
+static void set_termios(struct tty_struct *tty, struct ktermios *old_termios);
 
 static int  write(struct tty_struct *tty, const unsigned char *buf, int count);
 static void put_char(struct tty_struct *tty, unsigned char ch);
@@ -536,7 +538,7 @@ static void throttle(struct tty_struct * tty);
 static void unthrottle(struct tty_struct * tty);
 static void set_break(struct tty_struct *tty, int break_state);
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
 #define dev_to_port(D) (dev_to_hdlc(D)->priv)
 static void hdlcdev_tx_done(SLMP_INFO *info);
 static void hdlcdev_rx(SLMP_INFO *info, char *buf, int size);
@@ -602,7 +604,7 @@ static void enable_loopback(SLMP_INFO *info, int enable);
 static void set_rate(SLMP_INFO *info, u32 data_rate);
 
 static int  bh_action(SLMP_INFO *info);
-static void bh_handler(void* Context);
+static void bh_handler(struct work_struct *work);
 static void bh_receive(SLMP_INFO *info);
 static void bh_transmit(SLMP_INFO *info);
 static void bh_status(SLMP_INFO *info);
@@ -916,7 +918,7 @@ static void hangup(struct tty_struct *tty)
 
 /* Set new termios settings
  */
-static void set_termios(struct tty_struct *tty, struct termios *old_termios)
+static void set_termios(struct tty_struct *tty, struct ktermios *old_termios)
 {
         SLMP_INFO *info = (SLMP_INFO *)tty->driver_data;
         unsigned long flags;
@@ -1607,7 +1609,7 @@ static void set_break(struct tty_struct *tty, int break_state)
         spin_unlock_irqrestore(&info->lock,flags);
 }
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
 
 /**
  * called by generic HDLC layer when protocol selected (PPP, frame relay, etc.)
@@ -2063,9 +2065,9 @@ int bh_action(SLMP_INFO *info)
 
 /* Perform bottom half processing of work items queued by ISR.
  */
-void bh_handler(void* Context)
+void bh_handler(struct work_struct *work)
 {
-        SLMP_INFO *info = (SLMP_INFO*)Context;
+        SLMP_INFO *info = container_of(work, SLMP_INFO, task);
         int action;
 
         if (!info)
@@ -2339,7 +2341,7 @@ static void isr_txeom(SLMP_INFO * info, unsigned char status)
                         set_signals(info);
                 }
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
                 if (info->netcount)
                         hdlcdev_tx_done(info);
                 else
@@ -2523,7 +2525,7 @@ void isr_io_pin( SLMP_INFO *info, u16 status )
                                 info->input_signal_events.dcd_up++;
                         } else
                                 info->input_signal_events.dcd_down++;
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
                         if (info->netcount) {
                                 if (status & SerialSignal_DCD)
                                         netif_carrier_on(info->netdev);
@@ -2596,8 +2598,7 @@ void isr_io_pin( SLMP_INFO *info, u16 status )
  *      dev_id          device ID supplied during interrupt registration
  *      regs            interrupted processor context
  */
-static irqreturn_t synclinkmp_interrupt(int irq, void *dev_id,
-                                        struct pt_regs *regs)
+static irqreturn_t synclinkmp_interrupt(int irq, void *dev_id)
 {
         SLMP_INFO * info;
         unsigned char status, status0, status1=0;
@@ -3784,7 +3785,7 @@ void add_device(SLMP_INFO *info)
                 info->irq_level,
                 info->max_frame_size );
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
         hdlcdev_init(info);
 #endif
 }
@@ -3806,7 +3807,7 @@ static SLMP_INFO *alloc_dev(int adapter_num, int port_num, struct pci_dev *pdev)
         } else {
                 memset(info, 0, sizeof(SLMP_INFO));
                 info->magic = MGSL_MAGIC;
-                INIT_WORK(&info->task, bh_handler, info);
+                INIT_WORK(&info->task, bh_handler);
                 info->max_frame_size = 4096;
                 info->close_delay = 5*HZ/10;
                 info->closing_wait = 30*HZ;
@@ -3929,7 +3930,7 @@ void device_init(int adapter_num, struct pci_dev *pdev)
         }
 }
 
-static struct tty_operations ops = {
+static const struct tty_operations ops = {
         .open = open,
         .close = close,
         .write = write,
@@ -3978,7 +3979,7 @@ static void synclinkmp_cleanup(void)
         /* release devices */
         info = synclinkmp_device_list;
         while(info) {
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
                 hdlcdev_exit(info);
 #endif
                 free_dma_bufs(info);
@@ -4033,6 +4034,8 @@ static int __init synclinkmp_init(void)
         serial_driver->init_termios = tty_std_termios;
         serial_driver->init_termios.c_cflag =
                 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+        serial_driver->init_termios.c_ispeed = 9600;
+        serial_driver->init_termios.c_ospeed = 9600;
         serial_driver->flags = TTY_DRIVER_REAL_RAW;
         tty_set_operations(serial_driver, &ops);
         if ((rc = tty_register_driver(serial_driver)) < 0) {
@@ -4980,7 +4983,7 @@ CheckAgain:
                         info->icount.rxcrc++;
 
                 framesize = 0;
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
                 {
                         struct net_device_stats *stats = hdlc_stats(info->netdev);
                         stats->rx_errors++;
@@ -5021,7 +5024,7 @@ CheckAgain:
                                         index = 0;
                         }
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
                         if (info->netcount)
                                 hdlcdev_rx(info,info->tmp_rx_buf,framesize);
                         else
@@ -5532,7 +5535,7 @@ void tx_timeout(unsigned long context)
 
         spin_unlock_irqrestore(&info->lock,flags);
 
-#ifdef CONFIG_HDLC
+#if SYNCLINK_GENERIC_HDLC
         if (info->netcount)
                 hdlcdev_tx_done(info);
         else
diff --git a/drivers/char/sysrq.c b/drivers/char/sysrq.c
index ee3ca8f1768e..05810c8d20bc 100644
--- a/drivers/char/sysrq.c
+++ b/drivers/char/sysrq.c
@@ -35,14 +35,15 @@
 #include <linux/vt_kern.h>
 #include <linux/workqueue.h>
 #include <linux/kexec.h>
+#include <linux/irq.h>
 
 #include <asm/ptrace.h>
+#include <asm/irq_regs.h>
 
 /* Whether we react on sysrq keys or just ignore them */
 int sysrq_enabled = 1;
 
-static void sysrq_handle_loglevel(int key, struct pt_regs *pt_regs,
-                                  struct tty_struct *tty)
+static void sysrq_handle_loglevel(int key, struct tty_struct *tty)
 {
         int i;
         i = key - '0';
@@ -58,8 +59,7 @@ static struct sysrq_key_op sysrq_loglevel_op = {
 };
 
 #ifdef CONFIG_VT
-static void sysrq_handle_SAK(int key, struct pt_regs *pt_regs,
-                             struct tty_struct *tty)
+static void sysrq_handle_SAK(int key, struct tty_struct *tty)
 {
         if (tty)
                 do_SAK(tty);
@@ -76,8 +76,7 @@ static struct sysrq_key_op sysrq_SAK_op = {
 #endif
 
 #ifdef CONFIG_VT
-static void sysrq_handle_unraw(int key, struct pt_regs *pt_regs,
-                               struct tty_struct *tty)
+static void sysrq_handle_unraw(int key, struct tty_struct *tty)
 {
         struct kbd_struct *kbd = &kbd_table[fg_console];
 
@@ -95,10 +94,9 @@ static struct sysrq_key_op sysrq_unraw_op = {
 #endif /* CONFIG_VT */
 
 #ifdef CONFIG_KEXEC
-static void sysrq_handle_crashdump(int key, struct pt_regs *pt_regs,
-                                struct tty_struct *tty)
+static void sysrq_handle_crashdump(int key, struct tty_struct *tty)
 {
-        crash_kexec(pt_regs);
+        crash_kexec(get_irq_regs());
 }
 static struct sysrq_key_op sysrq_crashdump_op = {
         .handler        = sysrq_handle_crashdump,
@@ -110,9 +108,9 @@ static struct sysrq_key_op sysrq_crashdump_op = {
 #define sysrq_crashdump_op (*(struct sysrq_key_op *)0)
 #endif
 
-static void sysrq_handle_reboot(int key, struct pt_regs *pt_regs,
-                                struct tty_struct *tty)
+static void sysrq_handle_reboot(int key, struct tty_struct *tty)
 {
+        lockdep_off();
         local_irq_enable();
         emergency_restart();
 }
@@ -123,8 +121,7 @@ static struct sysrq_key_op sysrq_reboot_op = {
         .enable_mask    = SYSRQ_ENABLE_BOOT,
 };
 
-static void sysrq_handle_sync(int key, struct pt_regs *pt_regs,
-                              struct tty_struct *tty)
+static void sysrq_handle_sync(int key, struct tty_struct *tty)
 {
         emergency_sync();
 }
@@ -135,8 +132,7 @@ static struct sysrq_key_op sysrq_sync_op = {
         .enable_mask    = SYSRQ_ENABLE_SYNC,
 };
 
-static void sysrq_handle_mountro(int key, struct pt_regs *pt_regs,
-                                 struct tty_struct *tty)
+static void sysrq_handle_mountro(int key, struct tty_struct *tty)
 {
         emergency_remount();
 }
@@ -148,8 +144,7 @@ static struct sysrq_key_op sysrq_mountro_op = {
 };
 
 #ifdef CONFIG_LOCKDEP
-static void sysrq_handle_showlocks(int key, struct pt_regs *pt_regs,
-                                struct tty_struct *tty)
+static void sysrq_handle_showlocks(int key, struct tty_struct *tty)
 {
         debug_show_all_locks();
 }
@@ -163,11 +158,11 @@ static struct sysrq_key_op sysrq_showlocks_op = {
 #define sysrq_showlocks_op (*(struct sysrq_key_op *)0)
 #endif
 
-static void sysrq_handle_showregs(int key, struct pt_regs *pt_regs,
-                                  struct tty_struct *tty)
+static void sysrq_handle_showregs(int key, struct tty_struct *tty)
 {
-        if (pt_regs)
-                show_regs(pt_regs);
+        struct pt_regs *regs = get_irq_regs();
+        if (regs)
+                show_regs(regs);
 }
 static struct sysrq_key_op sysrq_showregs_op = {
         .handler        = sysrq_handle_showregs,
@@ -176,8 +171,7 @@ static struct sysrq_key_op sysrq_showregs_op = {
         .enable_mask    = SYSRQ_ENABLE_DUMP,
 };
 
-static void sysrq_handle_showstate(int key, struct pt_regs *pt_regs,
-                                   struct tty_struct *tty)
+static void sysrq_handle_showstate(int key, struct tty_struct *tty)
 {
         show_state();
 }
@@ -188,8 +182,19 @@ static struct sysrq_key_op sysrq_showstate_op = {
         .enable_mask    = SYSRQ_ENABLE_DUMP,
 };
 
-static void sysrq_handle_showmem(int key, struct pt_regs *pt_regs,
-                                 struct tty_struct *tty)
+static void sysrq_handle_showstate_blocked(int key, struct tty_struct *tty)
+{
+        show_state_filter(TASK_UNINTERRUPTIBLE);
+}
+static struct sysrq_key_op sysrq_showstate_blocked_op = {
+        .handler        = sysrq_handle_showstate_blocked,
+        .help_msg       = "showBlockedTasks",
+        .action_msg     = "Show Blocked State",
+        .enable_mask    = SYSRQ_ENABLE_DUMP,
+};
+
+
+static void sysrq_handle_showmem(int key, struct tty_struct *tty)
 {
         show_mem();
 }
@@ -208,14 +213,13 @@ static void send_sig_all(int sig)
         struct task_struct *p;
 
         for_each_process(p) {
-                if (p->mm && p->pid != 1)
+                if (p->mm && !is_init(p))
                         /* Not swapper, init nor kernel thread */
                         force_sig(sig, p);
         }
 }
 
-static void sysrq_handle_term(int key, struct pt_regs *pt_regs,
-                              struct tty_struct *tty)
+static void sysrq_handle_term(int key, struct tty_struct *tty)
 {
         send_sig_all(SIGTERM);
         console_loglevel = 8;
@@ -227,16 +231,15 @@ static struct sysrq_key_op sysrq_term_op = {
         .enable_mask    = SYSRQ_ENABLE_SIGNAL,
 };
 
-static void moom_callback(void *ignored)
+static void moom_callback(struct work_struct *ignored)
 {
         out_of_memory(&NODE_DATA(0)->node_zonelists[ZONE_NORMAL],
                         GFP_KERNEL, 0);
 }
 
-static DECLARE_WORK(moom_work, moom_callback, NULL);
+static DECLARE_WORK(moom_work, moom_callback);
 
-static void sysrq_handle_moom(int key, struct pt_regs *pt_regs,
-                              struct tty_struct *tty)
+static void sysrq_handle_moom(int key, struct tty_struct *tty)
 {
         schedule_work(&moom_work);
 }
@@ -246,8 +249,7 @@ static struct sysrq_key_op sysrq_moom_op = {
         .action_msg     = "Manual OOM execution",
 };
 
-static void sysrq_handle_kill(int key, struct pt_regs *pt_regs,
-                              struct tty_struct *tty)
+static void sysrq_handle_kill(int key, struct tty_struct *tty)
 {
         send_sig_all(SIGKILL);
         console_loglevel = 8;
@@ -259,8 +261,7 @@ static struct sysrq_key_op sysrq_kill_op = {
         .enable_mask    = SYSRQ_ENABLE_SIGNAL,
 };
 
-static void sysrq_handle_unrt(int key, struct pt_regs *pt_regs,
-                                struct tty_struct *tty)
+static void sysrq_handle_unrt(int key, struct tty_struct *tty)
 {
         normalize_rt_tasks();
 }
@@ -315,7 +316,7 @@ static struct sysrq_key_op *sysrq_key_table[36] = {
         /* May be assigned at init time by SMP VOYAGER */
         NULL,                           /* v */
         NULL,                           /* w */
-        NULL,                           /* x */
+        &sysrq_showstate_blocked_op,    /* x */
         NULL,                           /* y */
         NULL                            /* z */
 };
@@ -360,8 +361,7 @@ static void __sysrq_put_key_op(int key, struct sysrq_key_op *op_p)
  * This is the non-locking version of handle_sysrq.  It must/can only be called
  * by sysrq key handlers, as they are inside of the lock
  */
-void __handle_sysrq(int key, struct pt_regs *pt_regs, struct tty_struct *tty,
-                        int check_mask)
+void __handle_sysrq(int key, struct tty_struct *tty, int check_mask)
 {
         struct sysrq_key_op *op_p;
         int orig_log_level;
@@ -383,7 +383,7 @@ void __handle_sysrq(int key, struct pt_regs *pt_regs, struct tty_struct *tty,
                     (sysrq_enabled & op_p->enable_mask)) {
                         printk("%s\n", op_p->action_msg);
                         console_loglevel = orig_log_level;
-                        op_p->handler(key, pt_regs, tty);
+                        op_p->handler(key, tty);
                 } else {
                         printk("This sysrq operation is disabled.\n");
                 }
@@ -412,11 +412,11 @@ void __handle_sysrq(int key, struct pt_regs *pt_regs, struct tty_struct *tty,
  * This function is called by the keyboard handler when SysRq is pressed
  * and any other keycode arrives.
  */
-void handle_sysrq(int key, struct pt_regs *pt_regs, struct tty_struct *tty)
+void handle_sysrq(int key, struct tty_struct *tty)
 {
         if (!sysrq_enabled)
                 return;
-        __handle_sysrq(key, pt_regs, tty, 1);
+        __handle_sysrq(key, tty, 1);
 }
 EXPORT_SYMBOL(handle_sysrq);
 
diff --git a/drivers/char/tb0219.c b/drivers/char/tb0219.c
index bb1bad4c18f9..4c431cb7cf1b 100644
--- a/drivers/char/tb0219.c
+++ b/drivers/char/tb0219.c
@@ -164,7 +164,7 @@ static ssize_t tanbac_tb0219_read(struct file *file, char __user *buf, size_t le
         unsigned int minor;
         char value;
 
-        minor = iminor(file->f_dentry->d_inode);
+        minor = iminor(file->f_path.dentry->d_inode);
         switch (minor) {
         case 0:
                 value = get_led();
@@ -200,7 +200,7 @@ static ssize_t tanbac_tb0219_write(struct file *file, const char __user *data,
         int retval = 0;
         char c;
 
-        minor = iminor(file->f_dentry->d_inode);
+        minor = iminor(file->f_path.dentry->d_inode);
         switch (minor) {
         case 0:
                 type = TYPE_LED;
diff --git a/drivers/char/tipar.c b/drivers/char/tipar.c
index d30dc09dbbc9..47fb20f69695 100644
--- a/drivers/char/tipar.c
+++ b/drivers/char/tipar.c
@@ -224,14 +224,16 @@ probe_ti_parallel(int minor)
 {
         int i;
         int seq[] = { 0x00, 0x20, 0x10, 0x30 };
+        int data;
 
         for (i = 3; i >= 0; i--) {
                 outbyte(3, minor);
                 outbyte(i, minor);
                 udelay(delay);
+                data = inbyte(minor) & 0x30;
                 pr_debug("tipar: Probing -> %i: 0x%02x 0x%02x\n", i,
-                        data & 0x30, seq[i]);
-                if ((inbyte(minor) & 0x30) != seq[i]) {
+                        data, seq[i]);
+                if (data != seq[i]) {
                         outbyte(3, minor);
                         return -1;
                 }
@@ -283,7 +285,7 @@ static ssize_t
 tipar_write (struct file *file, const char __user *buf, size_t count,
                 loff_t * ppos)
 {
-        unsigned int minor = iminor(file->f_dentry->d_inode) - TIPAR_MINOR;
+        unsigned int minor = iminor(file->f_path.dentry->d_inode) - TIPAR_MINOR;
         ssize_t n;
 
         parport_claim_or_block(table[minor].dev);
@@ -311,7 +313,7 @@ static ssize_t
 tipar_read(struct file *file, char __user *buf, size_t count, loff_t * ppos)
 {
         int b = 0;
-        unsigned int minor = iminor(file->f_dentry->d_inode) - TIPAR_MINOR;
+        unsigned int minor = iminor(file->f_path.dentry->d_inode) - TIPAR_MINOR;
         ssize_t retval = 0;
         ssize_t n = 0;
 
diff --git a/drivers/char/tlclk.c b/drivers/char/tlclk.c
index d2c5ba4e83b8..244d30a03fef 100644
--- a/drivers/char/tlclk.c
+++ b/drivers/char/tlclk.c
@@ -193,7 +193,7 @@ static DEFINE_SPINLOCK(event_lock);
 
 static int tlclk_major = TLCLK_MAJOR;
 
-static irqreturn_t tlclk_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+static irqreturn_t tlclk_interrupt(int irq, void *dev_id);
 
 static DECLARE_WAIT_QUEUE_HEAD(wq);
 
@@ -792,15 +792,14 @@ static int __init tlclk_init(void)
         ret = misc_register(&tlclk_miscdev);
         if (ret < 0) {
                 printk(KERN_ERR "tlclk: misc_register returns %d.\n", ret);
-                ret = -EBUSY;
                 goto out3;
         }
 
         tlclk_device = platform_device_register_simple("telco_clock",
                                 -1, NULL, 0);
-        if (!tlclk_device) {
+        if (IS_ERR(tlclk_device)) {
                 printk(KERN_ERR "tlclk: platform_device_register failed.\n");
-                ret = -EBUSY;
+                ret = PTR_ERR(tlclk_device);
                 goto out4;
         }
 
@@ -856,7 +855,7 @@ static void switchover_timeout(unsigned long data)
         wake_up(&wq);
 }
 
-static irqreturn_t tlclk_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t tlclk_interrupt(int irq, void *dev_id)
 {
         unsigned long flags;
 
diff --git a/drivers/char/toshiba.c b/drivers/char/toshiba.c
index dd36fd04a842..07067c31c4ec 100644
--- a/drivers/char/toshiba.c
+++ b/drivers/char/toshiba.c
@@ -249,6 +249,7 @@ int tosh_smm(SMMRegisters *regs)
 
         return eax;
 }
+EXPORT_SYMBOL(tosh_smm);
 
 
 static int tosh_ioctl(struct inode *ip, struct file *fp, unsigned int cmd,
diff --git a/drivers/char/tpm/tpm.c b/drivers/char/tpm/tpm.c
index a082a2e34252..33e1f66e39cb 100644
--- a/drivers/char/tpm/tpm.c
+++ b/drivers/char/tpm/tpm.c
@@ -325,9 +325,9 @@ static void user_reader_timeout(unsigned long ptr)
         schedule_work(&chip->work);
 }
 
-static void timeout_work(void *ptr)
+static void timeout_work(struct work_struct *work)
 {
-        struct tpm_chip *chip = ptr;
+        struct tpm_chip *chip = container_of(work, struct tpm_chip, work);
 
         down(&chip->buffer_mutex);
         atomic_set(&chip->data_pending, 0);
@@ -1105,7 +1105,7 @@ struct tpm_chip *tpm_register_hardware(struct device *dev, const struct tpm_vend
         init_MUTEX(&chip->tpm_mutex);
         INIT_LIST_HEAD(&chip->list);
 
-        INIT_WORK(&chip->work, timeout_work, chip);
+        INIT_WORK(&chip->work, timeout_work);
 
         init_timer(&chip->user_read_timer);
         chip->user_read_timer.function = user_reader_timeout;
@@ -1130,7 +1130,7 @@ struct tpm_chip *tpm_register_hardware(struct device *dev, const struct tpm_vend
         scnprintf(devname, DEVNAME_SIZE, "%s%d", "tpm", chip->dev_num);
         chip->vendor.miscdev.name = devname;
 
-        chip->vendor.miscdev.dev = dev;
+        chip->vendor.miscdev.parent = dev;
         chip->dev = get_device(dev);
 
         if (misc_register(&chip->vendor.miscdev)) {
@@ -1153,7 +1153,15 @@ struct tpm_chip *tpm_register_hardware(struct device *dev, const struct tpm_vend
 
         spin_unlock(&driver_lock);
 
-        sysfs_create_group(&dev->kobj, chip->vendor.attr_group);
+        if (sysfs_create_group(&dev->kobj, chip->vendor.attr_group)) {
+                list_del(&chip->list);
+                misc_deregister(&chip->vendor.miscdev);
+                put_device(dev);
+                clear_bit(chip->dev_num, dev_mask);
+                kfree(chip);
+                kfree(devname);
+                return NULL;
+        }
 
         chip->bios_dir = tpm_bios_log_setup(devname);
 
diff --git a/drivers/char/tpm/tpm.h b/drivers/char/tpm/tpm.h
index 050ced247f68..bb9a43c6cf3d 100644
--- a/drivers/char/tpm/tpm.h
+++ b/drivers/char/tpm/tpm.h
@@ -22,6 +22,7 @@
 #include <linux/pci.h>
 #include <linux/delay.h>
 #include <linux/fs.h>
+#include <linux/sched.h>
 #include <linux/miscdevice.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
diff --git a/drivers/char/tpm/tpm_atmel.c b/drivers/char/tpm/tpm_atmel.c
index ad8ffe49256f..1ab0896070be 100644
--- a/drivers/char/tpm/tpm_atmel.c
+++ b/drivers/char/tpm/tpm_atmel.c
@@ -184,7 +184,9 @@ static int __init init_atmel(void)
         unsigned long base;
         struct  tpm_chip *chip;
 
-        driver_register(&atml_drv);
+        rc = driver_register(&atml_drv);
+        if (rc)
+                return rc;
 
         if ((iobase = atmel_get_base_addr(&base, &region_size)) == NULL) {
                 rc = -ENODEV;
@@ -195,10 +197,8 @@ static int __init init_atmel(void)
             (atmel_request_region
              (tpm_atmel.base, region_size, "tpm_atmel0") == NULL) ? 0 : 1;
 
-
-        if (IS_ERR
-            (pdev =
-             platform_device_register_simple("tpm_atmel", -1, NULL, 0))) {
+        pdev = platform_device_register_simple("tpm_atmel", -1, NULL, 0);
+        if (IS_ERR(pdev)) {
                 rc = PTR_ERR(pdev);
                 goto err_rel_reg;
         }
diff --git a/drivers/char/tpm/tpm_nsc.c b/drivers/char/tpm/tpm_nsc.c
index 26287aace87d..608f73071bef 100644
--- a/drivers/char/tpm/tpm_nsc.c
+++ b/drivers/char/tpm/tpm_nsc.c
@@ -284,7 +284,7 @@ static struct device_driver nsc_drv = {
 static int __init init_nsc(void)
 {
         int rc = 0;
-        int lo, hi;
+        int lo, hi, err;
         int nscAddrBase = TPM_ADDR;
         struct tpm_chip *chip;
         unsigned long base;
@@ -297,7 +297,9 @@ static int __init init_nsc(void)
                         return -ENODEV;
         }
 
-        driver_register(&nsc_drv);
+        err = driver_register(&nsc_drv);
+        if (err)
+                return err;
 
         hi = tpm_read_index(nscAddrBase, TPM_NSC_BASE0_HI);
         lo = tpm_read_index(nscAddrBase, TPM_NSC_BASE0_LO);
diff --git a/drivers/char/tpm/tpm_tis.c b/drivers/char/tpm/tpm_tis.c
index ee7ac6f43c65..483f3f60013c 100644
--- a/drivers/char/tpm/tpm_tis.c
+++ b/drivers/char/tpm/tpm_tis.c
@@ -377,7 +377,7 @@ static struct tpm_vendor_specific tpm_tis = {
                     .fops = &tis_ops,},
 };
 
-static irqreturn_t tis_int_probe(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t tis_int_probe(int irq, void *dev_id)
 {
         struct tpm_chip *chip = (struct tpm_chip *) dev_id;
         u32 interrupt;
@@ -397,7 +397,7 @@ static irqreturn_t tis_int_probe(int irq, void *dev_id, struct pt_regs *regs)
         return IRQ_HANDLED;
 }
 
-static irqreturn_t tis_int_handler(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t tis_int_handler(int irq, void *dev_id)
 {
         struct tpm_chip *chip = (struct tpm_chip *) dev_id;
         u32 interrupt;
diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index bb0d9199e994..4044c864fdd4 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -109,13 +109,15 @@
 #define TTY_PARANOIA_CHECK 1
 #define CHECK_TTY_COUNT 1
 
-struct termios tty_std_termios = {      /* for the benefit of tty drivers  */
+struct ktermios tty_std_termios = {     /* for the benefit of tty drivers  */
         .c_iflag = ICRNL | IXON,
         .c_oflag = OPOST | ONLCR,
         .c_cflag = B38400 | CS8 | CREAD | HUPCL,
         .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
                    ECHOCTL | ECHOKE | IEXTEN,
-        .c_cc = INIT_C_CC
+        .c_cc = INIT_C_CC,
+        .c_ispeed = 38400,
+        .c_ospeed = 38400
 };
 
 EXPORT_SYMBOL(tty_std_termios);
@@ -126,9 +128,10 @@ EXPORT_SYMBOL(tty_std_termios);
    
 LIST_HEAD(tty_drivers);                 /* linked list of tty drivers */
 
-/* Semaphore to protect creating and releasing a tty. This is shared with
+/* Mutex to protect creating and releasing a tty. This is shared with
    vt.c for deeply disgusting hack reasons */
 DEFINE_MUTEX(tty_mutex);
+EXPORT_SYMBOL(tty_mutex);
 
 #ifdef CONFIG_UNIX98_PTYS
 extern struct tty_driver *ptm_driver;   /* Unix98 pty masters; for /dev/ptmx */
@@ -160,17 +163,11 @@ static void release_mem(struct tty_struct *tty, int idx);
  *      been initialized in any way but has been zeroed
  *
  *      Locking: none
- *      FIXME: use kzalloc
  */
 
 static struct tty_struct *alloc_tty_struct(void)
 {
-        struct tty_struct *tty;
-
-        tty = kmalloc(sizeof(struct tty_struct), GFP_KERNEL);
-        if (tty)
-                memset(tty, 0, sizeof(struct tty_struct));
-        return tty;
+        return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
 }
 
 static void tty_buffer_free_all(struct tty_struct *);
@@ -255,7 +252,7 @@ static int check_tty_count(struct tty_struct *tty, const char *routine)
                                     "!= #fd's(%d) in %s\n",
                        tty->name, tty->count, count, routine);
                 return count;
-       }        
+        }
 #endif
         return 0;
 }
@@ -264,18 +261,6 @@ static int check_tty_count(struct tty_struct *tty, const char *routine)
  * Tty buffer allocation management
  */
 
-
-/**
- *      tty_buffer_free_all             -       free buffers used by a tty
- *      @tty: tty to free from
- *
- *      Remove all the buffers pending on a tty whether queued with data
- *      or in the free ring. Must be called when the tty is no longer in use
- *
- *      Locking: none
- */
-
-
 /**
  *      tty_buffer_free_all             -       free buffers used by a tty
  *      @tty: tty to free from
@@ -483,10 +468,9 @@ int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars,
                 tb->used += space;
                 copied += space;
                 chars += space;
-        }
-        /* There is a small chance that we need to split the data over
-           several buffers. If this is the case we must loop */
-        while (unlikely(size > copied));
+                /* There is a small chance that we need to split the data over
+                   several buffers. If this is the case we must loop */
+        } while (unlikely(size > copied));
         return copied;
 }
 EXPORT_SYMBOL(tty_insert_flip_string);
@@ -521,10 +505,9 @@ int tty_insert_flip_string_flags(struct tty_struct *tty,
                 copied += space;
                 chars += space;
                 flags += space;
-        }
-        /* There is a small chance that we need to split the data over
-           several buffers. If this is the case we must loop */
-        while (unlikely(size > copied));
+                /* There is a small chance that we need to split the data over
+                   several buffers. If this is the case we must loop */
+        } while (unlikely(size > copied));
         return copied;
 }
 EXPORT_SYMBOL(tty_insert_flip_string_flags);
@@ -621,14 +604,14 @@ EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
  *      they are not on hot paths so a little discipline won't do 
  *      any harm.
  *
- *      Locking: takes termios_sem
+ *      Locking: takes termios_mutex
  */
  
 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
 {
-        down(&tty->termios_sem);
+        mutex_lock(&tty->termios_mutex);
         tty->termios->c_line = num;
-        up(&tty->termios_sem);
+        mutex_unlock(&tty->termios_mutex);
 }
 
 /*
@@ -922,7 +905,7 @@ static void tty_ldisc_enable(struct tty_struct *tty)
  *      context.
  *
  *      Locking: takes tty_ldisc_lock.
- *              called functions take termios_sem
+ *               called functions take termios_mutex
  */
  
 static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
@@ -1258,10 +1241,26 @@ void tty_ldisc_flush(struct tty_struct *tty)
 }
 
 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
+
+/**
+ *      tty_reset_termios       -       reset terminal state
+ *      @tty: tty to reset
+ *
+ *      Restore a terminal to the driver default state
+ */
+
+static void tty_reset_termios(struct tty_struct *tty)
+{
+        mutex_lock(&tty->termios_mutex);
+        *tty->termios = tty->driver->init_termios;
+        tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
+        tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
+        mutex_unlock(&tty->termios_mutex);
+}
         
 /**
  *      do_tty_hangup           -       actual handler for hangup events
- *      @data: tty device
+ *      @work: tty device
  *
  *      This can be called by the "eventd" kernel thread.  That is process
  *      synchronous but doesn't hold any locks, so we need to make sure we
@@ -1274,16 +1273,17 @@ EXPORT_SYMBOL_GPL(tty_ldisc_flush);
  *
  *      Locking:
  *              BKL
- *              redirect lock for undoing redirection
- *              file list lock for manipulating list of ttys
- *              tty_ldisc_lock from called functions
- *              termios_sem resetting termios data
- *              tasklist_lock to walk task list for hangup event
- *
+ *                redirect lock for undoing redirection
+ *                file list lock for manipulating list of ttys
+ *                tty_ldisc_lock from called functions
+ *                termios_mutex resetting termios data
+ *                tasklist_lock to walk task list for hangup event
+ *                  ->siglock to protect ->signal/->sighand
  */
-static void do_tty_hangup(void *data)
+static void do_tty_hangup(struct work_struct *work)
 {
-        struct tty_struct *tty = (struct tty_struct *) data;
+        struct tty_struct *tty =
+                container_of(work, struct tty_struct, hangup_work);
         struct file * cons_filp = NULL;
         struct file *filp, *f = NULL;
         struct task_struct *p;
@@ -1345,11 +1345,7 @@ static void do_tty_hangup(void *data)
          * N_TTY.
          */
         if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
-        {
-                down(&tty->termios_sem);
-                *tty->termios = tty->driver->init_termios;
-                up(&tty->termios_sem);
-        }
+                tty_reset_termios(tty);
         
         /* Defer ldisc switch */
         /* tty_deferred_ldisc_switch(N_TTY);
@@ -1360,14 +1356,18 @@ static void do_tty_hangup(void *data)
         read_lock(&tasklist_lock);
         if (tty->session > 0) {
                 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
+                        spin_lock_irq(&p->sighand->siglock);
                         if (p->signal->tty == tty)
                                 p->signal->tty = NULL;
-                        if (!p->signal->leader)
+                        if (!p->signal->leader) {
+                                spin_unlock_irq(&p->sighand->siglock);
                                 continue;
-                        group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
-                        group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
+                        }
+                        __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
+                        __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
                         if (tty->pgrp > 0)
                                 p->signal->tty_old_pgrp = tty->pgrp;
+                        spin_unlock_irq(&p->sighand->siglock);
                 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
         }
         read_unlock(&tasklist_lock);
@@ -1440,7 +1440,7 @@ void tty_vhangup(struct tty_struct * tty)
 
         printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
 #endif
-        do_tty_hangup((void *) tty);
+        do_tty_hangup(&tty->hangup_work);
 }
 EXPORT_SYMBOL(tty_vhangup);
 
@@ -1459,6 +1459,14 @@ int tty_hung_up_p(struct file * filp)
 
 EXPORT_SYMBOL(tty_hung_up_p);
 
+static void session_clear_tty(pid_t session)
+{
+        struct task_struct *p;
+        do_each_task_pid(session, PIDTYPE_SID, p) {
+                proc_clear_tty(p);
+        } while_each_task_pid(session, PIDTYPE_SID, p);
+}
+
 /**
  *      disassociate_ctty       -       disconnect controlling tty
  *      @on_exit: true if exiting so need to "hang up" the session
@@ -1475,31 +1483,35 @@ EXPORT_SYMBOL(tty_hung_up_p);
  *      The argument on_exit is set to 1 if called when a process is
  *      exiting; it is 0 if called by the ioctl TIOCNOTTY.
  *
- *      Locking: tty_mutex is taken to protect current->signal->tty
+ *      Locking:
  *              BKL is taken for hysterical raisins
- *              Tasklist lock is taken (under tty_mutex) to walk process
- *              lists for the session.
+ *                tty_mutex is taken to protect tty
+ *                ->siglock is taken to protect ->signal/->sighand
+ *                tasklist_lock is taken to walk process list for sessions
+ *                  ->siglock is taken to protect ->signal/->sighand
  */
 
 void disassociate_ctty(int on_exit)
 {
         struct tty_struct *tty;
-        struct task_struct *p;
         int tty_pgrp = -1;
+        int session;
 
         lock_kernel();
 
         mutex_lock(&tty_mutex);
-        tty = current->signal->tty;
+        tty = get_current_tty();
         if (tty) {
                 tty_pgrp = tty->pgrp;
                 mutex_unlock(&tty_mutex);
+                /* XXX: here we race, there is nothing protecting tty */
                 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
                         tty_vhangup(tty);
         } else {
-                if (current->signal->tty_old_pgrp) {
-                        kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
-                        kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
+                pid_t old_pgrp = current->signal->tty_old_pgrp;
+                if (old_pgrp) {
+                        kill_pg(old_pgrp, SIGHUP, on_exit);
+                        kill_pg(old_pgrp, SIGCONT, on_exit);
                 }
                 mutex_unlock(&tty_mutex);
                 unlock_kernel();        
@@ -1511,19 +1523,29 @@ void disassociate_ctty(int on_exit)
                         kill_pg(tty_pgrp, SIGCONT, on_exit);
         }
 
-        /* Must lock changes to tty_old_pgrp */
-        mutex_lock(&tty_mutex);
+        spin_lock_irq(&current->sighand->siglock);
         current->signal->tty_old_pgrp = 0;
-        tty->session = 0;
-        tty->pgrp = -1;
+        session = process_session(current);
+        spin_unlock_irq(&current->sighand->siglock);
+
+        mutex_lock(&tty_mutex);
+        /* It is possible that do_tty_hangup has free'd this tty */
+        tty = get_current_tty();
+        if (tty) {
+                tty->session = 0;
+                tty->pgrp = 0;
+        } else {
+#ifdef TTY_DEBUG_HANGUP
+                printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
+                       " = NULL", tty);
+#endif
+        }
+        mutex_unlock(&tty_mutex);
 
         /* Now clear signal->tty under the lock */
         read_lock(&tasklist_lock);
-        do_each_task_pid(current->signal->session, PIDTYPE_SID, p) {
-                p->signal->tty = NULL;
-        } while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
+        session_clear_tty(session);
         read_unlock(&tasklist_lock);
-        mutex_unlock(&tty_mutex);
         unlock_kernel();
 }
 
@@ -1621,7 +1643,7 @@ static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
         struct tty_ldisc *ld;
 
         tty = (struct tty_struct *)file->private_data;
-        inode = file->f_dentry->d_inode;
+        inode = file->f_path.dentry->d_inode;
         if (tty_paranoia_check(tty, inode, "tty_read"))
                 return -EIO;
         if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
@@ -1724,7 +1746,7 @@ static inline ssize_t do_tty_write(
                 cond_resched();
         }
         if (written) {
-                struct inode *inode = file->f_dentry->d_inode;
+                struct inode *inode = file->f_path.dentry->d_inode;
                 inode->i_mtime = current_fs_time(inode->i_sb);
                 ret = written;
         }
@@ -1755,7 +1777,7 @@ static ssize_t tty_write(struct file * file, const char __user * buf, size_t cou
                          loff_t *ppos)
 {
         struct tty_struct * tty;
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         ssize_t ret;
         struct tty_ldisc *ld;
         
@@ -1862,8 +1884,8 @@ static int init_dev(struct tty_driver *driver, int idx,
         struct tty_struct **ret_tty)
 {
         struct tty_struct *tty, *o_tty;
-        struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
-        struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
+        struct ktermios *tp, **tp_loc, *o_tp, **o_tp_loc;
+        struct ktermios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
         int retval = 0;
 
         /* check whether we're reopening an existing tty */
@@ -1910,7 +1932,7 @@ static int init_dev(struct tty_driver *driver, int idx,
         }
 
         if (!*tp_loc) {
-                tp = (struct termios *) kmalloc(sizeof(struct termios),
+                tp = (struct ktermios *) kmalloc(sizeof(struct ktermios),
                                                 GFP_KERNEL);
                 if (!tp)
                         goto free_mem_out;
@@ -1918,11 +1940,11 @@ static int init_dev(struct tty_driver *driver, int idx,
         }
 
         if (!*ltp_loc) {
-                ltp = (struct termios *) kmalloc(sizeof(struct termios),
+                ltp = (struct ktermios *) kmalloc(sizeof(struct ktermios),
                                                  GFP_KERNEL);
                 if (!ltp)
                         goto free_mem_out;
-                memset(ltp, 0, sizeof(struct termios));
+                memset(ltp, 0, sizeof(struct ktermios));
         }
 
         if (driver->type == TTY_DRIVER_TYPE_PTY) {
@@ -1943,19 +1965,19 @@ static int init_dev(struct tty_driver *driver, int idx,
                 }
 
                 if (!*o_tp_loc) {
-                        o_tp = (struct termios *)
-                                kmalloc(sizeof(struct termios), GFP_KERNEL);
+                        o_tp = (struct ktermios *)
+                                kmalloc(sizeof(struct ktermios), GFP_KERNEL);
                         if (!o_tp)
                                 goto free_mem_out;
                         *o_tp = driver->other->init_termios;
                 }
 
                 if (!*o_ltp_loc) {
-                        o_ltp = (struct termios *)
-                                kmalloc(sizeof(struct termios), GFP_KERNEL);
+                        o_ltp = (struct ktermios *)
+                                kmalloc(sizeof(struct ktermios), GFP_KERNEL);
                         if (!o_ltp)
                                 goto free_mem_out;
-                        memset(o_ltp, 0, sizeof(struct termios));
+                        memset(o_ltp, 0, sizeof(struct ktermios));
                 }
 
                 /*
@@ -1994,6 +2016,9 @@ static int init_dev(struct tty_driver *driver, int idx,
                 *ltp_loc = ltp;
         tty->termios = *tp_loc;
         tty->termios_locked = *ltp_loc;
+        /* Compatibility until drivers always set this */
+        tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
+        tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
         driver->refcount++;
         tty->count++;
 
@@ -2072,8 +2097,9 @@ fail_no_mem:
 
         /* call the tty release_mem routine to clean out this slot */
 release_mem_out:
-        printk(KERN_INFO "init_dev: ldisc open failed, "
-                         "clearing slot %d\n", idx);
+        if (printk_ratelimit())
+                printk(KERN_INFO "init_dev: ldisc open failed, "
+                                 "clearing slot %d\n", idx);
         release_mem(tty, idx);
         goto end_init;
 }
@@ -2095,7 +2121,7 @@ release_mem_out:
 static void release_mem(struct tty_struct *tty, int idx)
 {
         struct tty_struct *o_tty;
-        struct termios *tp;
+        struct ktermios *tp;
         int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
 
         if ((o_tty = tty->link) != NULL) {
@@ -2161,7 +2187,7 @@ static void release_dev(struct file * filp)
         unsigned long flags;
         
         tty = (struct tty_struct *)filp->private_data;
-        if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
+        if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "release_dev"))
                 return;
 
         check_tty_count(tty, "release_dev");
@@ -2342,16 +2368,10 @@ static void release_dev(struct file * filp)
          * tty.
          */
         if (tty_closing || o_tty_closing) {
-                struct task_struct *p;
-
                 read_lock(&tasklist_lock);
-                do_each_task_pid(tty->session, PIDTYPE_SID, p) {
-                        p->signal->tty = NULL;
-                } while_each_task_pid(tty->session, PIDTYPE_SID, p);
+                session_clear_tty(tty->session);
                 if (o_tty)
-                        do_each_task_pid(o_tty->session, PIDTYPE_SID, p) {
-                                p->signal->tty = NULL;
-                        } while_each_task_pid(o_tty->session, PIDTYPE_SID, p);
+                        session_clear_tty(o_tty->session);
                 read_unlock(&tasklist_lock);
         }
 
@@ -2448,9 +2468,9 @@ static void release_dev(struct file * filp)
  *      The termios state of a pty is reset on first open so that
  *      settings don't persist across reuse.
  *
- *      Locking: tty_mutex protects current->signal->tty, get_tty_driver and
- *              init_dev work. tty->count should protect the rest.
- *              task_lock is held to update task details for sessions
+ *      Locking: tty_mutex protects tty, get_tty_driver and init_dev work.
+ *               tty->count should protect the rest.
+ *               ->siglock protects ->signal/->sighand
  */
 
 static int tty_open(struct inode * inode, struct file * filp)
@@ -2472,12 +2492,13 @@ retry_open:
         mutex_lock(&tty_mutex);
 
         if (device == MKDEV(TTYAUX_MAJOR,0)) {
-                if (!current->signal->tty) {
+                tty = get_current_tty();
+                if (!tty) {
                         mutex_unlock(&tty_mutex);
                         return -ENXIO;
                 }
-                driver = current->signal->tty->driver;
-                index = current->signal->tty->index;
+                driver = tty->driver;
+                index = tty->index;
                 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
                 /* noctty = 1; */
                 goto got_driver;
@@ -2552,17 +2573,16 @@ got_driver:
                         filp->f_op = &tty_fops;
                 goto retry_open;
         }
+
+        mutex_lock(&tty_mutex);
+        spin_lock_irq(&current->sighand->siglock);
         if (!noctty &&
             current->signal->leader &&
             !current->signal->tty &&
-            tty->session == 0) {
-                task_lock(current);
-                current->signal->tty = tty;
-                task_unlock(current);
-                current->signal->tty_old_pgrp = 0;
-                tty->session = current->signal->session;
-                tty->pgrp = process_group(current);
-        }
+            tty->session == 0)
+                __proc_set_tty(current, tty);
+        spin_unlock_irq(&current->sighand->siglock);
+        mutex_unlock(&tty_mutex);
         return 0;
 }
 
@@ -2677,7 +2697,7 @@ static unsigned int tty_poll(struct file * filp, poll_table * wait)
         int ret = 0;
 
         tty = (struct tty_struct *)filp->private_data;
-        if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
+        if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_poll"))
                 return 0;
                 
         ld = tty_ldisc_ref_wait(tty);
@@ -2693,7 +2713,7 @@ static int tty_fasync(int fd, struct file * filp, int on)
         int retval;
 
         tty = (struct tty_struct *)filp->private_data;
-        if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
+        if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_fasync"))
                 return 0;
         
         retval = fasync_helper(fd, filp, on, &tty->fasync);
@@ -2726,6 +2746,8 @@ static int tty_fasync(int fd, struct file * filp, int on)
  *      Locking:
  *              Called functions take tty_ldisc_lock
  *              current->signal->tty check is safe without locks
+ *
+ *      FIXME: may race normal receive processing
  */
 
 static int tiocsti(struct tty_struct *tty, char __user *p)
@@ -2748,18 +2770,21 @@ static int tiocsti(struct tty_struct *tty, char __user *p)
  *      @tty; tty
  *      @arg: user buffer for result
  *
- *      Copies the kernel idea of the window size into the user buffer. No
- *      locking is done.
+ *      Copies the kernel idea of the window size into the user buffer.
  *
- *      FIXME: Returning random values racing a window size set is wrong
- *      should lock here against that
+ *      Locking: tty->termios_mutex is taken to ensure the winsize data
+ *              is consistent.
  */
 
 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
 {
-        if (copy_to_user(arg, &tty->winsize, sizeof(*arg)))
-                return -EFAULT;
-        return 0;
+        int err;
+
+        mutex_lock(&tty->termios_mutex);
+        err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
+        mutex_unlock(&tty->termios_mutex);
+
+        return err ? -EFAULT: 0;
 }
 
 /**
@@ -2772,12 +2797,11 @@ static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
  *      actually has driver level meaning and triggers a VC resize.
  *
  *      Locking:
- *              The console_sem is used to ensure we do not try and resize
- *      the console twice at once.
- *      FIXME: Two racing size sets may leave the console and kernel
- *              parameters disagreeing. Is this exploitable ?
- *      FIXME: Random values racing a window size get is wrong
- *      should lock here against that
+ *              Called function use the console_sem is used to ensure we do
+ *      not try and resize the console twice at once.
+ *              The tty->termios_mutex is used to ensure we don't double
+ *      resize and get confused. Lock order - tty->termios_mutex before
+ *      console sem
  */
 
 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
@@ -2787,17 +2811,18 @@ static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
 
         if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
                 return -EFAULT;
+
+        mutex_lock(&tty->termios_mutex);
         if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
-                return 0;
+                goto done;
+
 #ifdef CONFIG_VT
         if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
-                int rc;
-
-                acquire_console_sem();
-                rc = vc_resize(tty->driver_data, tmp_ws.ws_col, tmp_ws.ws_row);
-                release_console_sem();
-                if (rc)
-                        return -ENXIO;
+                if (vc_lock_resize(tty->driver_data, tmp_ws.ws_col,
+                                        tmp_ws.ws_row)) {
+                        mutex_unlock(&tty->termios_mutex);
+                        return -ENXIO;
+                }
         }
 #endif
         if (tty->pgrp > 0)
@@ -2806,6 +2831,8 @@ static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
                 kill_pg(real_tty->pgrp, SIGWINCH, 1);
         tty->winsize = tmp_ws;
         real_tty->winsize = tmp_ws;
+done:
+        mutex_unlock(&tty->termios_mutex);
         return 0;
 }
 
@@ -2878,27 +2905,28 @@ static int fionbio(struct file *file, int __user *p)
  *      leader to set this tty as the controlling tty for the session.
  *
  *      Locking:
- *              Takes tasklist lock internally to walk sessions
- *              Takes task_lock() when updating signal->tty
- *
- *      FIXME: tty_mutex is needed to protect signal->tty references.
- *      FIXME: why task_lock on the signal->tty reference ??
- *
+ *              Takes tty_mutex() to protect tty instance
+ *              Takes tasklist_lock internally to walk sessions
+ *              Takes ->siglock() when updating signal->tty
  */
 
 static int tiocsctty(struct tty_struct *tty, int arg)
 {
-        struct task_struct *p;
-
+        int ret = 0;
         if (current->signal->leader &&
-            (current->signal->session == tty->session))
-                return 0;
+                        (process_session(current) == tty->session))
+                return ret;
+
+        mutex_lock(&tty_mutex);
         /*
          * The process must be a session leader and
          * not have a controlling tty already.
          */
-        if (!current->signal->leader || current->signal->tty)
-                return -EPERM;
+        if (!current->signal->leader || current->signal->tty) {
+                ret = -EPERM;
+                goto unlock;
+        }
+
         if (tty->session > 0) {
                 /*
                  * This tty is already the controlling
@@ -2908,22 +2936,18 @@ static int tiocsctty(struct tty_struct *tty, int arg)
                         /*
                          * Steal it away
                          */
-
                         read_lock(&tasklist_lock);
-                        do_each_task_pid(tty->session, PIDTYPE_SID, p) {
-                                p->signal->tty = NULL;
-                        } while_each_task_pid(tty->session, PIDTYPE_SID, p);
+                        session_clear_tty(tty->session);
                         read_unlock(&tasklist_lock);
-                } else
-                        return -EPERM;
+                } else {
+                        ret = -EPERM;
+                        goto unlock;
+                }
         }
-        task_lock(current);
-        current->signal->tty = tty;
-        task_unlock(current);
-        current->signal->tty_old_pgrp = 0;
-        tty->session = current->signal->session;
-        tty->pgrp = process_group(current);
-        return 0;
+        proc_set_tty(current, tty);
+unlock:
+        mutex_unlock(&tty_mutex);
+        return ret;
 }
 
 /**
@@ -2935,7 +2959,7 @@ static int tiocsctty(struct tty_struct *tty, int arg)
  *      Obtain the process group of the tty. If there is no process group
  *      return an error.
  *
- *      Locking: none. Reference to ->signal->tty is safe.
+ *      Locking: none. Reference to current->signal->tty is safe.
  */
 
 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
@@ -2959,8 +2983,6 @@ static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t
  *      permitted where the tty session is our session.
  *
  *      Locking: None
- *
- *      FIXME: current->signal->tty referencing is unsafe.
  */
 
 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
@@ -2974,13 +2996,13 @@ static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t
                 return retval;
         if (!current->signal->tty ||
             (current->signal->tty != real_tty) ||
-            (real_tty->session != current->signal->session))
+            (real_tty->session != process_session(current)))
                 return -ENOTTY;
         if (get_user(pgrp, p))
                 return -EFAULT;
         if (pgrp < 0)
                 return -EINVAL;
-        if (session_of_pgrp(pgrp) != current->signal->session)
+        if (session_of_pgrp(pgrp) != process_session(current))
                 return -EPERM;
         real_tty->pgrp = pgrp;
         return 0;
@@ -2995,7 +3017,7 @@ static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t
  *      Obtain the session id of the tty. If there is no session
  *      return an error.
  *
- *      Locking: none. Reference to ->signal->tty is safe.
+ *      Locking: none. Reference to current->signal->tty is safe.
  */
 
 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
@@ -3039,19 +3061,20 @@ static int tiocsetd(struct tty_struct *tty, int __user *p)
  *      timed break functionality.
  *
  *      Locking:
- *              None
+ *              atomic_write_lock serializes
  *
- *      FIXME:
- *              What if two overlap
  */
 
 static int send_break(struct tty_struct *tty, unsigned int duration)
 {
+        if (mutex_lock_interruptible(&tty->atomic_write_lock))
+                return -EINTR;
         tty->driver->break_ctl(tty, -1);
         if (!signal_pending(current)) {
                 msleep_interruptible(duration);
         }
         tty->driver->break_ctl(tty, 0);
+        mutex_unlock(&tty->atomic_write_lock);
         if (signal_pending(current))
                 return -EINTR;
         return 0;
@@ -3144,6 +3167,8 @@ int tty_ioctl(struct inode * inode, struct file * file,
         if (tty_paranoia_check(tty, inode, "tty_ioctl"))
                 return -EINVAL;
 
+        /* CHECKME: is this safe as one end closes ? */
+
         real_tty = tty;
         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
             tty->driver->subtype == PTY_TYPE_MASTER)
@@ -3211,14 +3236,11 @@ int tty_ioctl(struct inode * inode, struct file * file,
                         clear_bit(TTY_EXCLUSIVE, &tty->flags);
                         return 0;
                 case TIOCNOTTY:
-                        /* FIXME: taks lock or tty_mutex ? */
                         if (current->signal->tty != tty)
                                 return -ENOTTY;
                         if (current->signal->leader)
                                 disassociate_ctty(0);
-                        task_lock(current);
-                        current->signal->tty = NULL;
-                        task_unlock(current);
+                        proc_clear_tty(current);
                         return 0;
                 case TIOCSCTTY:
                         return tiocsctty(tty, arg);
@@ -3302,12 +3324,13 @@ int tty_ioctl(struct inode * inode, struct file * file,
  * Nasty bug: do_SAK is being called in interrupt context.  This can
  * deadlock.  We punt it up to process context.  AKPM - 16Mar2001
  */
-static void __do_SAK(void *arg)
+static void __do_SAK(struct work_struct *work)
 {
+        struct tty_struct *tty =
+                container_of(work, struct tty_struct, SAK_work);
 #ifdef TTY_SOFT_SAK
         tty_hangup(tty);
 #else
-        struct tty_struct *tty = arg;
         struct task_struct *g, *p;
         int session;
         int             i;
@@ -3317,7 +3340,7 @@ static void __do_SAK(void *arg)
         
         if (!tty)
                 return;
-        session  = tty->session;
+        session = tty->session;
         
         /* We don't want an ldisc switch during this */
         disc = tty_ldisc_ref(tty);
@@ -3332,7 +3355,7 @@ static void __do_SAK(void *arg)
         /* Kill the entire session */
         do_each_task_pid(session, PIDTYPE_SID, p) {
                 printk(KERN_NOTICE "SAK: killed process %d"
-                        " (%s): p->signal->session==tty->session\n",
+                        " (%s): process_session(p)==tty->session\n",
                         p->pid, p->comm);
                 send_sig(SIGKILL, p, 1);
         } while_each_task_pid(session, PIDTYPE_SID, p);
@@ -3342,7 +3365,7 @@ static void __do_SAK(void *arg)
         do_each_thread(g, p) {
                 if (p->signal->tty == tty) {
                         printk(KERN_NOTICE "SAK: killed process %d"
-                            " (%s): p->signal->session==tty->session\n",
+                            " (%s): process_session(p)==tty->session\n",
                             p->pid, p->comm);
                         send_sig(SIGKILL, p, 1);
                         continue;
@@ -3386,7 +3409,7 @@ void do_SAK(struct tty_struct *tty)
 {
         if (!tty)
                 return;
-        PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
+        PREPARE_WORK(&tty->SAK_work, __do_SAK);
         schedule_work(&tty->SAK_work);
 }
 
@@ -3394,7 +3417,7 @@ EXPORT_SYMBOL(do_SAK);
 
 /**
  *      flush_to_ldisc
- *      @private_: tty structure passed from work queue.
+ *      @work: tty structure passed from work queue.
  *
  *      This routine is called out of the software interrupt to flush data
  *      from the buffer chain to the line discipline.
@@ -3404,9 +3427,10 @@ EXPORT_SYMBOL(do_SAK);
  *      receive_buf method is single threaded for each tty instance.
  */
  
-static void flush_to_ldisc(void *private_)
+static void flush_to_ldisc(struct work_struct *work)
 {
-        struct tty_struct *tty = (struct tty_struct *) private_;
+        struct tty_struct *tty =
+                container_of(work, struct tty_struct, buf.work.work);
         unsigned long   flags;
         struct tty_ldisc *disc;
         struct tty_buffer *tbuf, *head;
@@ -3451,84 +3475,6 @@ static void flush_to_ldisc(void *private_)
         tty_ldisc_deref(disc);
 }
 
-/*
- * Routine which returns the baud rate of the tty
- *
- * Note that the baud_table needs to be kept in sync with the
- * include/asm/termbits.h file.
- */
-static int baud_table[] = {
-        0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
-        9600, 19200, 38400, 57600, 115200, 230400, 460800,
-#ifdef __sparc__
-        76800, 153600, 307200, 614400, 921600
-#else
-        500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
-        2500000, 3000000, 3500000, 4000000
-#endif
-};
-
-static int n_baud_table = ARRAY_SIZE(baud_table);
-
-/**
- *      tty_termios_baud_rate
- *      @termios: termios structure
- *
- *      Convert termios baud rate data into a speed. This should be called
- *      with the termios lock held if this termios is a terminal termios
- *      structure. May change the termios data.
- *
- *      Locking: none
- */
- 
-int tty_termios_baud_rate(struct termios *termios)
-{
-        unsigned int cbaud;
-        
-        cbaud = termios->c_cflag & CBAUD;
-
-        if (cbaud & CBAUDEX) {
-                cbaud &= ~CBAUDEX;
-
-                if (cbaud < 1 || cbaud + 15 > n_baud_table)
-                        termios->c_cflag &= ~CBAUDEX;
-                else
-                        cbaud += 15;
-        }
-        return baud_table[cbaud];
-}
-
-EXPORT_SYMBOL(tty_termios_baud_rate);
-
-/**
- *      tty_get_baud_rate       -       get tty bit rates
- *      @tty: tty to query
- *
- *      Returns the baud rate as an integer for this terminal. The
- *      termios lock must be held by the caller and the terminal bit
- *      flags may be updated.
- *
- *      Locking: none
- */
- 
-int tty_get_baud_rate(struct tty_struct *tty)
-{
-        int baud = tty_termios_baud_rate(tty->termios);
-
-        if (baud == 38400 && tty->alt_speed) {
-                if (!tty->warned) {
-                        printk(KERN_WARNING "Use of setserial/setrocket to "
-                                            "set SPD_* flags is deprecated\n");
-                        tty->warned = 1;
-                }
-                baud = tty->alt_speed;
-        }
-        
-        return baud;
-}
-
-EXPORT_SYMBOL(tty_get_baud_rate);
-
 /**
  *      tty_flip_buffer_push    -       terminal
  *      @tty: tty to push
@@ -3551,7 +3497,7 @@ void tty_flip_buffer_push(struct tty_struct *tty)
         spin_unlock_irqrestore(&tty->buf.lock, flags);
 
         if (tty->low_latency)
-                flush_to_ldisc((void *) tty);
+                flush_to_ldisc(&tty->buf.work.work);
         else
                 schedule_delayed_work(&tty->buf.work, 1);
 }
@@ -3578,17 +3524,17 @@ static void initialize_tty_struct(struct tty_struct *tty)
         tty->overrun_time = jiffies;
         tty->buf.head = tty->buf.tail = NULL;
         tty_buffer_init(tty);
-        INIT_WORK(&tty->buf.work, flush_to_ldisc, tty);
+        INIT_DELAYED_WORK(&tty->buf.work, flush_to_ldisc);
         init_MUTEX(&tty->buf.pty_sem);
-        init_MUTEX(&tty->termios_sem);
+        mutex_init(&tty->termios_mutex);
         init_waitqueue_head(&tty->write_wait);
         init_waitqueue_head(&tty->read_wait);
-        INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
+        INIT_WORK(&tty->hangup_work, do_tty_hangup);
         mutex_init(&tty->atomic_read_lock);
         mutex_init(&tty->atomic_write_lock);
         spin_lock_init(&tty->read_lock);
         INIT_LIST_HEAD(&tty->tty_files);
-        INIT_WORK(&tty->SAK_work, NULL, NULL);
+        INIT_WORK(&tty->SAK_work, NULL);
 }
 
 /*
@@ -3610,7 +3556,8 @@ static struct class *tty_class;
  *              This field is optional, if there is no known struct device
  *              for this tty device it can be set to NULL safely.
  *
- *      Returns a pointer to the class device (or ERR_PTR(-EFOO) on error).
+ *      Returns a pointer to the struct device for this tty device
+ *      (or ERR_PTR(-EFOO) on error).
  *
  *      This call is required to be made to register an individual tty device
  *      if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set.  If
@@ -3620,8 +3567,8 @@ static struct class *tty_class;
  *      Locking: ??
  */
 
-struct class_device *tty_register_device(struct tty_driver *driver,
-                                         unsigned index, struct device *device)
+struct device *tty_register_device(struct tty_driver *driver, unsigned index,
+                                   struct device *device)
 {
         char name[64];
         dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
@@ -3637,7 +3584,7 @@ struct class_device *tty_register_device(struct tty_driver *driver,
         else
                 tty_line_name(driver, index, name);
 
-        return class_device_create(tty_class, NULL, dev, device, "%s", name);
+        return device_create(tty_class, device, dev, name);
 }
 
 /**
@@ -3653,7 +3600,7 @@ struct class_device *tty_register_device(struct tty_driver *driver,
 
 void tty_unregister_device(struct tty_driver *driver, unsigned index)
 {
-        class_device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
+        device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
 }
 
 EXPORT_SYMBOL(tty_register_device);
@@ -3678,7 +3625,8 @@ void put_tty_driver(struct tty_driver *driver)
         kfree(driver);
 }
 
-void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
+void tty_set_operations(struct tty_driver *driver,
+                        const struct tty_operations *op)
 {
         driver->open = op->open;
         driver->close = op->close;
@@ -3749,8 +3697,8 @@ int tty_register_driver(struct tty_driver *driver)
 
         if (p) {
                 driver->ttys = (struct tty_struct **)p;
-                driver->termios = (struct termios **)(p + driver->num);
-                driver->termios_locked = (struct termios **)(p + driver->num * 2);
+                driver->termios = (struct ktermios **)(p + driver->num);
+                driver->termios_locked = (struct ktermios **)(p + driver->num * 2);
         } else {
                 driver->ttys = NULL;
                 driver->termios = NULL;
@@ -3789,7 +3737,7 @@ EXPORT_SYMBOL(tty_register_driver);
 int tty_unregister_driver(struct tty_driver *driver)
 {
         int i;
-        struct termios *tp;
+        struct ktermios *tp;
         void *p;
 
         if (driver->refcount)
@@ -3827,9 +3775,52 @@ int tty_unregister_driver(struct tty_driver *driver)
         cdev_del(&driver->cdev);
         return 0;
 }
-
 EXPORT_SYMBOL(tty_unregister_driver);
 
+dev_t tty_devnum(struct tty_struct *tty)
+{
+        return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
+}
+EXPORT_SYMBOL(tty_devnum);
+
+void proc_clear_tty(struct task_struct *p)
+{
+        spin_lock_irq(&p->sighand->siglock);
+        p->signal->tty = NULL;
+        spin_unlock_irq(&p->sighand->siglock);
+}
+EXPORT_SYMBOL(proc_clear_tty);
+
+void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
+{
+        if (tty) {
+                tty->session = process_session(tsk);
+                tty->pgrp = process_group(tsk);
+        }
+        tsk->signal->tty = tty;
+        tsk->signal->tty_old_pgrp = 0;
+}
+
+void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
+{
+        spin_lock_irq(&tsk->sighand->siglock);
+        __proc_set_tty(tsk, tty);
+        spin_unlock_irq(&tsk->sighand->siglock);
+}
+
+struct tty_struct *get_current_tty(void)
+{
+        struct tty_struct *tty;
+        WARN_ON_ONCE(!mutex_is_locked(&tty_mutex));
+        tty = current->signal->tty;
+        /*
+         * session->tty can be changed/cleared from under us, make sure we
+         * issue the load. The obtained pointer, when not NULL, is valid as
+         * long as we hold tty_mutex.
+         */
+        barrier();
+        return tty;
+}
 
 /*
  * Initialize the console device. This is called *early*, so
@@ -3892,20 +3883,20 @@ static int __init tty_init(void)
         if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
                 panic("Couldn't register /dev/tty driver\n");
-        class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
+        device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), "tty");
 
         cdev_init(&console_cdev, &console_fops);
         if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
                 panic("Couldn't register /dev/console driver\n");
-        class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
+        device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), "console");
 
 #ifdef CONFIG_UNIX98_PTYS
         cdev_init(&ptmx_cdev, &ptmx_fops);
         if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
                 panic("Couldn't register /dev/ptmx driver\n");
-        class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
+        device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), "ptmx");
 #endif
 
 #ifdef CONFIG_VT
@@ -3913,7 +3904,7 @@ static int __init tty_init(void)
         if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
             register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
                 panic("Couldn't register /dev/tty0 driver\n");
-        class_device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
+        device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), "tty0");
 
         vty_init();
 #endif
diff --git a/drivers/char/tty_ioctl.c b/drivers/char/tty_ioctl.c
index 4ad47d321bd4..dee47f40c6a3 100644
--- a/drivers/char/tty_ioctl.c
+++ b/drivers/char/tty_ioctl.c
@@ -20,6 +20,7 @@
 #include <linux/mm.h>
 #include <linux/module.h>
 #include <linux/bitops.h>
+#include <linux/mutex.h>
 
 #include <asm/io.h>
 #include <asm/uaccess.h>
@@ -35,6 +36,7 @@
 #define TERMIOS_FLUSH   1
 #define TERMIOS_WAIT    2
 #define TERMIOS_TERMIO  4
+#define TERMIOS_OLD     8
 
 
 /**
@@ -83,9 +85,9 @@ stop_waiting:
 
 EXPORT_SYMBOL(tty_wait_until_sent);
 
-static void unset_locked_termios(struct termios *termios,
-                                 struct termios *old,
-                                 struct termios *locked)
+static void unset_locked_termios(struct ktermios *termios,
+                                 struct ktermios *old,
+                                 struct ktermios *locked)
 {
         int     i;
         
@@ -104,8 +106,204 @@ static void unset_locked_termios(struct termios *termios,
         for (i=0; i < NCCS; i++)
                 termios->c_cc[i] = locked->c_cc[i] ?
                         old->c_cc[i] : termios->c_cc[i];
+        /* FIXME: What should we do for i/ospeed */
 }
 
+/*
+ * Routine which returns the baud rate of the tty
+ *
+ * Note that the baud_table needs to be kept in sync with the
+ * include/asm/termbits.h file.
+ */
+static const speed_t baud_table[] = {
+        0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
+        9600, 19200, 38400, 57600, 115200, 230400, 460800,
+#ifdef __sparc__
+        76800, 153600, 307200, 614400, 921600
+#else
+        500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
+        2500000, 3000000, 3500000, 4000000
+#endif
+};
+
+#ifndef __sparc__
+static const tcflag_t baud_bits[] = {
+        B0, B50, B75, B110, B134, B150, B200, B300, B600,
+        B1200, B1800, B2400, B4800, B9600, B19200, B38400,
+        B57600, B115200, B230400, B460800, B500000, B576000,
+        B921600, B1000000, B1152000, B1500000, B2000000, B2500000,
+        B3000000, B3500000, B4000000
+};
+#else
+static const tcflag_t baud_bits[] = {
+        B0, B50, B75, B110, B134, B150, B200, B300, B600,
+        B1200, B1800, B2400, B4800, B9600, B19200, B38400,
+        B57600, B115200, B230400, B460800, B76800, B153600,
+        B307200, B614400, B921600
+};
+#endif
+
+static int n_baud_table = ARRAY_SIZE(baud_table);
+
+/**
+ *      tty_termios_baud_rate
+ *      @termios: termios structure
+ *
+ *      Convert termios baud rate data into a speed. This should be called
+ *      with the termios lock held if this termios is a terminal termios
+ *      structure. May change the termios data. Device drivers can call this
+ *      function but should use ->c_[io]speed directly as they are updated.
+ *
+ *      Locking: none
+ */
+
+speed_t tty_termios_baud_rate(struct ktermios *termios)
+{
+        unsigned int cbaud;
+
+        cbaud = termios->c_cflag & CBAUD;
+
+#ifdef BOTHER
+        /* Magic token for arbitary speed via c_ispeed/c_ospeed */
+        if (cbaud == BOTHER)
+                return termios->c_ospeed;
+#endif
+        if (cbaud & CBAUDEX) {
+                cbaud &= ~CBAUDEX;
+
+                if (cbaud < 1 || cbaud + 15 > n_baud_table)
+                        termios->c_cflag &= ~CBAUDEX;
+                else
+                        cbaud += 15;
+        }
+        return baud_table[cbaud];
+}
+
+EXPORT_SYMBOL(tty_termios_baud_rate);
+
+/**
+ *      tty_termios_input_baud_rate
+ *      @termios: termios structure
+ *
+ *      Convert termios baud rate data into a speed. This should be called
+ *      with the termios lock held if this termios is a terminal termios
+ *      structure. May change the termios data. Device drivers can call this
+ *      function but should use ->c_[io]speed directly as they are updated.
+ *
+ *      Locking: none
+ */
+
+speed_t tty_termios_input_baud_rate(struct ktermios *termios)
+{
+#ifdef IBSHIFT
+        unsigned int cbaud = (termios->c_cflag >> IBSHIFT) & CBAUD;
+
+        if (cbaud == B0)
+                return tty_termios_baud_rate(termios);
+
+        /* Magic token for arbitary speed via c_ispeed*/
+        if (cbaud == BOTHER)
+                return termios->c_ispeed;
+
+        if (cbaud & CBAUDEX) {
+                cbaud &= ~CBAUDEX;
+
+                if (cbaud < 1 || cbaud + 15 > n_baud_table)
+                        termios->c_cflag &= ~(CBAUDEX << IBSHIFT);
+                else
+                        cbaud += 15;
+        }
+        return baud_table[cbaud];
+#else
+        return tty_termios_baud_rate(termios);
+#endif
+}
+
+EXPORT_SYMBOL(tty_termios_input_baud_rate);
+
+#ifdef BOTHER
+
+/**
+ *      tty_termios_encode_baud_rate
+ *      @termios: termios structure
+ *      @ispeed: input speed
+ *      @ospeed: output speed
+ *
+ *      Encode the speeds set into the passed termios structure. This is
+ *      used as a library helper for drivers os that they can report back
+ *      the actual speed selected when it differs from the speed requested
+ *
+ *      For now input and output speed must agree.
+ *
+ *      Locking: Caller should hold termios lock. This is already held
+ *      when calling this function from the driver termios handler.
+ */
+
+void tty_termios_encode_baud_rate(struct ktermios *termios, speed_t ibaud, speed_t obaud)
+{
+        int i = 0;
+        int ifound = 0, ofound = 0;
+
+        termios->c_ispeed = ibaud;
+        termios->c_ospeed = obaud;
+
+        termios->c_cflag &= ~CBAUD;
+        /* Identical speed means no input encoding (ie B0 << IBSHIFT)*/
+        if (termios->c_ispeed == termios->c_ospeed)
+                ifound = 1;
+
+        do {
+                if (obaud == baud_table[i]) {
+                        termios->c_cflag |= baud_bits[i];
+                        ofound = 1;
+                        /* So that if ibaud == obaud we don't set it */
+                        continue;
+                }
+                if (ibaud == baud_table[i]) {
+                        termios->c_cflag |= (baud_bits[i] << IBSHIFT);
+                        ifound = 1;
+                }
+        }
+        while(++i < n_baud_table);
+        if (!ofound)
+                termios->c_cflag |= BOTHER;
+        if (!ifound)
+                termios->c_cflag |= (BOTHER << IBSHIFT);
+}
+
+EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate);
+
+#endif
+
+/**
+ *      tty_get_baud_rate       -       get tty bit rates
+ *      @tty: tty to query
+ *
+ *      Returns the baud rate as an integer for this terminal. The
+ *      termios lock must be held by the caller and the terminal bit
+ *      flags may be updated.
+ *
+ *      Locking: none
+ */
+
+speed_t tty_get_baud_rate(struct tty_struct *tty)
+{
+        speed_t baud = tty_termios_baud_rate(tty->termios);
+
+        if (baud == 38400 && tty->alt_speed) {
+                if (!tty->warned) {
+                        printk(KERN_WARNING "Use of setserial/setrocket to "
+                                            "set SPD_* flags is deprecated\n");
+                        tty->warned = 1;
+                }
+                baud = tty->alt_speed;
+        }
+
+        return baud;
+}
+
+EXPORT_SYMBOL(tty_get_baud_rate);
+
 /**
  *      change_termios          -       update termios values
  *      @tty: tty to update
@@ -118,10 +316,10 @@ static void unset_locked_termios(struct termios *termios,
  *      Locking: termios_sem
  */
 
-static void change_termios(struct tty_struct * tty, struct termios * new_termios)
+static void change_termios(struct tty_struct * tty, struct ktermios * new_termios)
 {
         int canon_change;
-        struct termios old_termios = *tty->termios;
+        struct ktermios old_termios = *tty->termios;
         struct tty_ldisc *ld;
         
         /*
@@ -131,7 +329,7 @@ static void change_termios(struct tty_struct * tty, struct termios * new_termios
 
         /* FIXME: we need to decide on some locking/ordering semantics
            for the set_termios notification eventually */
-        down(&tty->termios_sem);
+        mutex_lock(&tty->termios_mutex);
 
         *tty->termios = *new_termios;
         unset_locked_termios(tty->termios, &old_termios, tty->termios_locked);
@@ -176,7 +374,7 @@ static void change_termios(struct tty_struct * tty, struct termios * new_termios
                         (ld->set_termios)(tty, &old_termios);
                 tty_ldisc_deref(ld);
         }
-        up(&tty->termios_sem);
+        mutex_unlock(&tty->termios_mutex);
 }
 
 /**
@@ -194,23 +392,39 @@ static void change_termios(struct tty_struct * tty, struct termios * new_termios
 
 static int set_termios(struct tty_struct * tty, void __user *arg, int opt)
 {
-        struct termios tmp_termios;
+        struct ktermios tmp_termios;
         struct tty_ldisc *ld;
         int retval = tty_check_change(tty);
 
         if (retval)
                 return retval;
 
+        memcpy(&tmp_termios, tty->termios, sizeof(struct ktermios));
+
         if (opt & TERMIOS_TERMIO) {
-                memcpy(&tmp_termios, tty->termios, sizeof(struct termios));
                 if (user_termio_to_kernel_termios(&tmp_termios,
                                                 (struct termio __user *)arg))
                         return -EFAULT;
+#ifdef TCGETS2
+        } else if (opt & TERMIOS_OLD) {
+                if (user_termios_to_kernel_termios_1(&tmp_termios,
+                                                (struct termios __user *)arg))
+                        return -EFAULT;
         } else {
                 if (user_termios_to_kernel_termios(&tmp_termios,
-                                                (struct termios __user *)arg))
+                                                (struct termios2 __user *)arg))
                         return -EFAULT;
         }
+#else
+        } else if (user_termios_to_kernel_termios(&tmp_termios,
+                                        (struct termios __user *)arg))
+                return -EFAULT;
+#endif
+
+        /* If old style Bfoo values are used then load c_ispeed/c_ospeed with the real speed
+           so its unconditionally usable */
+        tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
+        tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
 
         ld = tty_ldisc_ref(tty);
         
@@ -284,18 +498,18 @@ static int get_sgttyb(struct tty_struct * tty, struct sgttyb __user * sgttyb)
 {
         struct sgttyb tmp;
 
-        down(&tty->termios_sem);
-        tmp.sg_ispeed = 0;
-        tmp.sg_ospeed = 0;
+        mutex_lock(&tty->termios_mutex);
+        tmp.sg_ispeed = tty->termios->c_ispeed;
+        tmp.sg_ospeed = tty->termios->c_ospeed;
         tmp.sg_erase = tty->termios->c_cc[VERASE];
         tmp.sg_kill = tty->termios->c_cc[VKILL];
         tmp.sg_flags = get_sgflags(tty);
-        up(&tty->termios_sem);
+        mutex_unlock(&tty->termios_mutex);
         
         return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 }
 
-static void set_sgflags(struct termios * termios, int flags)
+static void set_sgflags(struct ktermios * termios, int flags)
 {
         termios->c_iflag = ICRNL | IXON;
         termios->c_oflag = 0;
@@ -336,7 +550,7 @@ static int set_sgttyb(struct tty_struct * tty, struct sgttyb __user * sgttyb)
 {
         int retval;
         struct sgttyb tmp;
-        struct termios termios;
+        struct ktermios termios;
 
         retval = tty_check_change(tty);
         if (retval)
@@ -345,12 +559,16 @@ static int set_sgttyb(struct tty_struct * tty, struct sgttyb __user * sgttyb)
         if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
                 return -EFAULT;
 
-        down(&tty->termios_sem);                
+        mutex_lock(&tty->termios_mutex);
         termios =  *tty->termios;
         termios.c_cc[VERASE] = tmp.sg_erase;
         termios.c_cc[VKILL] = tmp.sg_kill;
         set_sgflags(&termios, tmp.sg_flags);
-        up(&tty->termios_sem);
+        /* Try and encode into Bfoo format */
+#ifdef BOTHER
+        tty_termios_encode_baud_rate(&termios, termios.c_ispeed, termios.c_ospeed);
+#endif
+        mutex_unlock(&tty->termios_mutex);
         change_termios(tty, &termios);
         return 0;
 }
@@ -422,24 +640,28 @@ static int set_ltchars(struct tty_struct * tty, struct ltchars __user * ltchars)
  *
  *      Send a high priority character to the tty even if stopped
  *
- *      Locking: none
- *
- *      FIXME: overlapping calls with start/stop tty lose state of tty
+ *      Locking: none for xchar method, write ordering for write method.
  */
 
-static void send_prio_char(struct tty_struct *tty, char ch)
+static int send_prio_char(struct tty_struct *tty, char ch)
 {
         int     was_stopped = tty->stopped;
 
         if (tty->driver->send_xchar) {
                 tty->driver->send_xchar(tty, ch);
-                return;
+                return 0;
         }
+
+        if (mutex_lock_interruptible(&tty->atomic_write_lock))
+                return -ERESTARTSYS;
+
         if (was_stopped)
                 start_tty(tty);
         tty->driver->write(tty, &ch, 1);
         if (was_stopped)
                 stop_tty(tty);
+        mutex_unlock(&tty->atomic_write_lock);
+        return 0;
 }
 
 int n_tty_ioctl(struct tty_struct * tty, struct file * file,
@@ -476,16 +698,33 @@ int n_tty_ioctl(struct tty_struct * tty, struct file * file,
                 case TIOCSLTC:
                         return set_ltchars(real_tty, p);
 #endif
+                case TCSETSF:
+                        return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
+                case TCSETSW:
+                        return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
+                case TCSETS:
+                        return set_termios(real_tty, p, TERMIOS_OLD);
+#ifndef TCGETS2
                 case TCGETS:
                         if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios))
                                 return -EFAULT;
                         return 0;
-                case TCSETSF:
+#else
+                case TCGETS:
+                        if (kernel_termios_to_user_termios_1((struct termios __user *)arg, real_tty->termios))
+                                return -EFAULT;
+                        return 0;
+                case TCGETS2:
+                        if (kernel_termios_to_user_termios((struct termios2 __user *)arg, real_tty->termios))
+                                return -EFAULT;
+                        return 0;
+                case TCSETSF2:
                         return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT);
-                case TCSETSW:
+                case TCSETSW2:
                         return set_termios(real_tty, p, TERMIOS_WAIT);
-                case TCSETS:
+                case TCSETS2:
                         return set_termios(real_tty, p, 0);
+#endif
                 case TCGETA:
                         return get_termio(real_tty, p);
                 case TCSETAF:
@@ -513,11 +752,11 @@ int n_tty_ioctl(struct tty_struct * tty, struct file * file,
                                 break;
                         case TCIOFF:
                                 if (STOP_CHAR(tty) != __DISABLED_CHAR)
-                                        send_prio_char(tty, STOP_CHAR(tty));
+                                        return send_prio_char(tty, STOP_CHAR(tty));
                                 break;
                         case TCION:
                                 if (START_CHAR(tty) != __DISABLED_CHAR)
-                                        send_prio_char(tty, START_CHAR(tty));
+                                        return send_prio_char(tty, START_CHAR(tty));
                                 break;
                         default:
                                 return -EINVAL;
@@ -592,11 +831,11 @@ int n_tty_ioctl(struct tty_struct * tty, struct file * file,
                 case TIOCSSOFTCAR:
                         if (get_user(arg, (unsigned int __user *) arg))
                                 return -EFAULT;
-                        down(&tty->termios_sem);
+                        mutex_lock(&tty->termios_mutex);
                         tty->termios->c_cflag =
                                 ((tty->termios->c_cflag & ~CLOCAL) |
                                  (arg ? CLOCAL : 0));
-                        up(&tty->termios_sem);
+                        mutex_unlock(&tty->termios_mutex);
                         return 0;
                 default:
                         return -ENOIOCTLCMD;
diff --git a/drivers/char/vc_screen.c b/drivers/char/vc_screen.c
index a9247b5213d5..26776517f04c 100644
--- a/drivers/char/vc_screen.c
+++ b/drivers/char/vc_screen.c
@@ -72,7 +72,7 @@ static loff_t vcs_lseek(struct file *file, loff_t offset, int orig)
         int size;
 
         down(&con_buf_sem);
-        size = vcs_size(file->f_dentry->d_inode);
+        size = vcs_size(file->f_path.dentry->d_inode);
         switch (orig) {
                 default:
                         up(&con_buf_sem);
@@ -98,7 +98,7 @@ static loff_t vcs_lseek(struct file *file, loff_t offset, int orig)
 static ssize_t
 vcs_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         unsigned int currcons = iminor(inode);
         struct vc_data *vc;
         long pos;
@@ -271,7 +271,7 @@ unlock_out:
 static ssize_t
 vcs_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
         unsigned int currcons = iminor(inode);
         struct vc_data *vc;
         long pos;
@@ -474,17 +474,18 @@ static const struct file_operations vcs_fops = {
 
 static struct class *vc_class;
 
-void vcs_make_devfs(struct tty_struct *tty)
+void vcs_make_sysfs(struct tty_struct *tty)
 {
-        class_device_create(vc_class, NULL, MKDEV(VCS_MAJOR, tty->index + 1),
-                        NULL, "vcs%u", tty->index + 1);
-        class_device_create(vc_class, NULL, MKDEV(VCS_MAJOR, tty->index + 129),
-                        NULL, "vcsa%u", tty->index + 1);
+        device_create(vc_class, NULL, MKDEV(VCS_MAJOR, tty->index + 1),
+                        "vcs%u", tty->index + 1);
+        device_create(vc_class, NULL, MKDEV(VCS_MAJOR, tty->index + 129),
+                        "vcsa%u", tty->index + 1);
 }
-void vcs_remove_devfs(struct tty_struct *tty)
+
+void vcs_remove_sysfs(struct tty_struct *tty)
 {
-        class_device_destroy(vc_class, MKDEV(VCS_MAJOR, tty->index + 1));
-        class_device_destroy(vc_class, MKDEV(VCS_MAJOR, tty->index + 129));
+        device_destroy(vc_class, MKDEV(VCS_MAJOR, tty->index + 1));
+        device_destroy(vc_class, MKDEV(VCS_MAJOR, tty->index + 129));
 }
 
 int __init vcs_init(void)
@@ -493,7 +494,7 @@ int __init vcs_init(void)
                 panic("unable to get major %d for vcs device", VCS_MAJOR);
         vc_class = class_create(THIS_MODULE, "vc");
 
-        class_device_create(vc_class, NULL, MKDEV(VCS_MAJOR, 0), NULL, "vcs");
-        class_device_create(vc_class, NULL, MKDEV(VCS_MAJOR, 128), NULL, "vcsa");
+        device_create(vc_class, NULL, MKDEV(VCS_MAJOR, 0), "vcs");
+        device_create(vc_class, NULL, MKDEV(VCS_MAJOR, 128), "vcsa");
         return 0;
 }
diff --git a/drivers/char/viocons.c b/drivers/char/viocons.c
index f3efeaf2826e..6d2e314860df 100644
--- a/drivers/char/viocons.c
+++ b/drivers/char/viocons.c
@@ -947,7 +947,7 @@ static void vioHandleData(struct HvLpEvent *event)
                                  */
                                 continue;
                         } else if (vio_sysrq_pressed) {
-                                handle_sysrq(cevent->data[index], NULL, tty);
+                                handle_sysrq(cevent->data[index], tty);
                                 vio_sysrq_pressed = 0;
                                 /*
                                  * continue because we don't want to add
@@ -1047,7 +1047,7 @@ static int send_open(HvLpIndex remoteLp, void *sem)
                         0, 0, 0, 0);
 }
 
-static struct tty_operations serial_ops = {
+static const struct tty_operations serial_ops = {
         .open = viotty_open,
         .close = viotty_close,
         .write = viotty_write,
diff --git a/drivers/char/viotape.c b/drivers/char/viotape.c
index 73c78bf75d7f..94d79cb8ce8d 100644
--- a/drivers/char/viotape.c
+++ b/drivers/char/viotape.c
@@ -442,7 +442,7 @@ static ssize_t viotap_write(struct file *file, const char *buf,
         if (op == NULL)
                 return -ENOMEM;
 
-        get_dev_info(file->f_dentry->d_inode, &devi);
+        get_dev_info(file->f_path.dentry->d_inode, &devi);
 
         /*
          * We need to make sure we can send a request.  We use
@@ -532,7 +532,7 @@ static ssize_t viotap_read(struct file *file, char *buf, size_t count,
         if (op == NULL)
                 return -ENOMEM;
 
-        get_dev_info(file->f_dentry->d_inode, &devi);
+        get_dev_info(file->f_path.dentry->d_inode, &devi);
 
         /*
          * We need to make sure we can send a request.  We use
@@ -612,7 +612,7 @@ static int viotap_ioctl(struct inode *inode, struct file *file,
         if (op == NULL)
                 return -ENOMEM;
 
-        get_dev_info(file->f_dentry->d_inode, &devi);
+        get_dev_info(file->f_path.dentry->d_inode, &devi);
 
         down(&reqSem);
 
@@ -777,7 +777,7 @@ static int viotap_open(struct inode *inode, struct file *file)
         if (op == NULL)
                 return -ENOMEM;
 
-        get_dev_info(file->f_dentry->d_inode, &devi);
+        get_dev_info(file->f_path.dentry->d_inode, &devi);
 
         /* Note: We currently only support one mode! */
         if ((devi.devno >= viotape_numdev) || (devi.mode)) {
@@ -822,7 +822,7 @@ static int viotap_release(struct inode *inode, struct file *file)
                 return -ENOMEM;
         init_completion(&op->com);
 
-        get_dev_info(file->f_dentry->d_inode, &devi);
+        get_dev_info(file->f_path.dentry->d_inode, &devi);
 
         if (devi.devno >= viotape_numdev) {
                 ret = -ENODEV;
diff --git a/drivers/char/vme_scc.c b/drivers/char/vme_scc.c
index bfe5ea948f6a..e01317cb1a0e 100644
--- a/drivers/char/vme_scc.c
+++ b/drivers/char/vme_scc.c
@@ -81,10 +81,10 @@ static int scc_ioctl(struct tty_struct * tty, struct file * filp,
                      unsigned int cmd, unsigned long arg);
 static void scc_throttle(struct tty_struct *tty);
 static void scc_unthrottle(struct tty_struct *tty);
-static irqreturn_t scc_tx_int(int irq, void *data, struct pt_regs *fp);
-static irqreturn_t scc_rx_int(int irq, void *data, struct pt_regs *fp);
-static irqreturn_t scc_stat_int(int irq, void *data, struct pt_regs *fp);
-static irqreturn_t scc_spcond_int(int irq, void *data, struct pt_regs *fp);
+static irqreturn_t scc_tx_int(int irq, void *data);
+static irqreturn_t scc_rx_int(int irq, void *data);
+static irqreturn_t scc_stat_int(int irq, void *data);
+static irqreturn_t scc_spcond_int(int irq, void *data);
 static void scc_setsignals(struct scc_port *port, int dtr, int rts);
 static void scc_break_ctl(struct tty_struct *tty, int break_state);
 
@@ -113,7 +113,7 @@ static struct real_driver scc_real_driver = {
 };
 
 
-static struct tty_operations scc_ops = {
+static const struct tty_operations scc_ops = {
         .open   = scc_open,
         .close = gs_close,
         .write = gs_write,
@@ -153,6 +153,8 @@ static int scc_init_drivers(void)
         scc_driver->init_termios = tty_std_termios;
         scc_driver->init_termios.c_cflag =
           B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+        scc_driver->init_termios.c_ispeed = 9600;
+        scc_driver->init_termios.c_ospeed = 9600;
         scc_driver->flags = TTY_DRIVER_REAL_RAW;
         tty_set_operations(scc_driver, &scc_ops);
 
@@ -419,7 +421,7 @@ module_init(vme_scc_init);
  * Interrupt handlers
  *--------------------------------------------------------------------------*/
 
-static irqreturn_t scc_rx_int(int irq, void *data, struct pt_regs *fp)
+static irqreturn_t scc_rx_int(int irq, void *data)
 {
         unsigned char   ch;
         struct scc_port *port = data;
@@ -440,7 +442,7 @@ static irqreturn_t scc_rx_int(int irq, void *data, struct pt_regs *fp)
          */
         if (SCCread(INT_PENDING_REG) &
             (port->channel == CHANNEL_A ? IPR_A_RX : IPR_B_RX)) {
-                scc_spcond_int (irq, data, fp);
+                scc_spcond_int (irq, data);
                 return IRQ_HANDLED;
         }
 
@@ -451,7 +453,7 @@ static irqreturn_t scc_rx_int(int irq, void *data, struct pt_regs *fp)
 }
 
 
-static irqreturn_t scc_spcond_int(int irq, void *data, struct pt_regs *fp)
+static irqreturn_t scc_spcond_int(int irq, void *data)
 {
         struct scc_port *port = data;
         struct tty_struct *tty = port->gs.tty;
@@ -496,7 +498,7 @@ static irqreturn_t scc_spcond_int(int irq, void *data, struct pt_regs *fp)
 }
 
 
-static irqreturn_t scc_tx_int(int irq, void *data, struct pt_regs *fp)
+static irqreturn_t scc_tx_int(int irq, void *data)
 {
         struct scc_port *port = data;
         SCC_ACCESS_INIT(port);
@@ -538,7 +540,7 @@ static irqreturn_t scc_tx_int(int irq, void *data, struct pt_regs *fp)
 }
 
 
-static irqreturn_t scc_stat_int(int irq, void *data, struct pt_regs *fp)
+static irqreturn_t scc_stat_int(int irq, void *data)
 {
         struct scc_port *port = data;
         unsigned channel = port->channel;
@@ -593,7 +595,7 @@ static void scc_enable_tx_interrupts(void *ptr)
         local_irq_save(flags);
         SCCmod(INT_AND_DMA_REG, 0xff, IDR_TX_INT_ENAB);
         /* restart the transmitter */
-        scc_tx_int (0, port, 0);
+        scc_tx_int (0, port);
         local_irq_restore(flags);
 }
 
diff --git a/drivers/char/vr41xx_giu.c b/drivers/char/vr41xx_giu.c
index 8116a47b80f4..a744dad9cf45 100644
--- a/drivers/char/vr41xx_giu.c
+++ b/drivers/char/vr41xx_giu.c
@@ -221,7 +221,7 @@ static struct hw_interrupt_type giuint_high_irq_type = {
         .end            = end_giuint_high_irq,
 };
 
-static int giu_get_irq(unsigned int irq, struct pt_regs *regs)
+static int giu_get_irq(unsigned int irq)
 {
         uint16_t pendl, pendh, maskl, maskh;
         int i;
@@ -506,7 +506,7 @@ static ssize_t gpio_read(struct file *file, char __user *buf, size_t len,
         unsigned int pin;
         char value = '0';
 
-        pin = iminor(file->f_dentry->d_inode);
+        pin = iminor(file->f_path.dentry->d_inode);
         if (pin >= giu_nr_pins)
                 return -EBADF;
 
@@ -530,7 +530,7 @@ static ssize_t gpio_write(struct file *file, const char __user *data,
         char c;
         int retval = 0;
 
-        pin = iminor(file->f_dentry->d_inode);
+        pin = iminor(file->f_path.dentry->d_inode);
         if (pin >= giu_nr_pins)
                 return -EBADF;
 
diff --git a/drivers/char/vt.c b/drivers/char/vt.c
index da7e66a2a38b..a8239dac994f 100644
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
@@ -63,6 +63,13 @@
  *
  * Removed console_lock, enabled interrupts across all console operations
  * 13 March 2001, Andrew Morton
+ *
+ * Fixed UTF-8 mode so alternate charset modes always work according
+ * to control sequences interpreted in do_con_trol function
+ * preserving backward VT100 semigraphics compatibility,
+ * malformed UTF sequences represented as sequences of replacement glyphs,
+ * original codes or '?' as a last resort if replacement glyph is undefined
+ * by Adam Tla/lka <atlka@pg.gda.pl>, Aug 2006
  */
 
 #include <linux/module.h>
@@ -99,12 +106,13 @@
 #define MAX_NR_CON_DRIVER 16
 
 #define CON_DRIVER_FLAG_MODULE 1
-#define CON_DRIVER_FLAG_INIT 2
+#define CON_DRIVER_FLAG_INIT   2
+#define CON_DRIVER_FLAG_ATTR   4
 
 struct con_driver {
         const struct consw *con;
         const char *desc;
-        struct class_device *class_dev;
+        struct device *dev;
         int node;
         int first;
         int last;
@@ -128,16 +136,8 @@ const struct consw *conswitchp;
 #define DEFAULT_BELL_PITCH      750
 #define DEFAULT_BELL_DURATION   (HZ/8)
 
-extern void vcs_make_devfs(struct tty_struct *tty);
-extern void vcs_remove_devfs(struct tty_struct *tty);
-
-extern void console_map_init(void);
-#ifdef CONFIG_PROM_CONSOLE
-extern void prom_con_init(void);
-#endif
-#ifdef CONFIG_MDA_CONSOLE
-extern int mda_console_init(void);
-#endif
+extern void vcs_make_sysfs(struct tty_struct *tty);
+extern void vcs_remove_sysfs(struct tty_struct *tty);
 
 struct vc vc_cons [MAX_NR_CONSOLES];
 
@@ -152,10 +152,10 @@ static void gotoxy(struct vc_data *vc, int new_x, int new_y);
 static void save_cur(struct vc_data *vc);
 static void reset_terminal(struct vc_data *vc, int do_clear);
 static void con_flush_chars(struct tty_struct *tty);
-static void set_vesa_blanking(char __user *p);
+static int set_vesa_blanking(char __user *p);
 static void set_cursor(struct vc_data *vc);
 static void hide_cursor(struct vc_data *vc);
-static void console_callback(void *ignored);
+static void console_callback(struct work_struct *ignored);
 static void blank_screen_t(unsigned long dummy);
 static void set_palette(struct vc_data *vc);
 
@@ -174,7 +174,7 @@ static int vesa_blank_mode; /* 0:none 1:suspendV 2:suspendH 3:powerdown */
 static int blankinterval = 10*60*HZ;
 static int vesa_off_interval;
 
-static DECLARE_WORK(console_work, console_callback, NULL);
+static DECLARE_WORK(console_work, console_callback);
 
 /*
  * fg_console is the current virtual console,
@@ -730,7 +730,8 @@ int vc_allocate(unsigned int currcons)	/* return 0 on success */
             visual_init(vc, currcons, 1);
             if (!*vc->vc_uni_pagedir_loc)
                 con_set_default_unimap(vc);
-            vc->vc_screenbuf = kmalloc(vc->vc_screenbuf_size, GFP_KERNEL);
+            if (!vc->vc_kmalloced)
+                vc->vc_screenbuf = kmalloc(vc->vc_screenbuf_size, GFP_KERNEL);
             if (!vc->vc_screenbuf) {
                 kfree(vc);
                 vc_cons[currcons].d = NULL;
@@ -878,14 +879,24 @@ int vc_resize(struct vc_data *vc, unsigned int cols, unsigned int lines)
         return err;
 }
 
+int vc_lock_resize(struct vc_data *vc, unsigned int cols, unsigned int lines)
+{
+        int rc;
+
+        acquire_console_sem();
+        rc = vc_resize(vc, cols, lines);
+        release_console_sem();
+        return rc;
+}
 
-void vc_disallocate(unsigned int currcons)
+void vc_deallocate(unsigned int currcons)
 {
         WARN_CONSOLE_UNLOCKED();
 
         if (vc_cons_allocated(currcons)) {
                 struct vc_data *vc = vc_cons[currcons].d;
                 vc->vc_sw->con_deinit(vc);
+                put_pid(vc->vt_pid);
                 module_put(vc->vc_sw->owner);
                 if (vc->vc_kmalloced)
                         kfree(vc->vc_screenbuf);
@@ -2005,17 +2016,23 @@ static int do_con_write(struct tty_struct *tty, const unsigned char *buf, int co
                 /* Do no translation at all in control states */
                 if (vc->vc_state != ESnormal) {
                         tc = c;
-                } else if (vc->vc_utf) {
+                } else if (vc->vc_utf && !vc->vc_disp_ctrl) {
                     /* Combine UTF-8 into Unicode */
-                    /* Incomplete characters silently ignored */
+                    /* Malformed sequences as sequences of replacement glyphs */
+rescan_last_byte:
                     if(c > 0x7f) {
-                        if (vc->vc_utf_count > 0 && (c & 0xc0) == 0x80) {
-                                vc->vc_utf_char = (vc->vc_utf_char << 6) | (c & 0x3f);
-                                vc->vc_utf_count--;
-                                if (vc->vc_utf_count == 0)
-                                    tc = c = vc->vc_utf_char;
-                                else continue;
+                        if (vc->vc_utf_count) {
+                               if ((c & 0xc0) == 0x80) {
+                                       vc->vc_utf_char = (vc->vc_utf_char << 6) | (c & 0x3f);
+                                       if (--vc->vc_utf_count) {
+                                               vc->vc_npar++;
+                                               continue;
+                                       }
+                                       tc = c = vc->vc_utf_char;
+                               } else
+                                       goto replacement_glyph;
                         } else {
+                                vc->vc_npar = 0;
                                 if ((c & 0xe0) == 0xc0) {
                                     vc->vc_utf_count = 1;
                                     vc->vc_utf_char = (c & 0x1f);
@@ -2032,14 +2049,15 @@ static int do_con_write(struct tty_struct *tty, const unsigned char *buf, int co
                                     vc->vc_utf_count = 5;
                                     vc->vc_utf_char = (c & 0x01);
                                 } else
-                                    vc->vc_utf_count = 0;
+                                    goto replacement_glyph;
                                 continue;
                               }
                     } else {
+                      if (vc->vc_utf_count)
+                              goto replacement_glyph;
                       tc = c;
-                      vc->vc_utf_count = 0;
                     }
-                } else {        /* no utf */
+                } else {        /* no utf or alternate charset mode */
                   tc = vc->vc_translate[vc->vc_toggle_meta ? (c | 0x80) : c];
                 }
 
@@ -2054,31 +2072,33 @@ static int do_con_write(struct tty_struct *tty, const unsigned char *buf, int co
                  * direct-to-font zone in UTF-8 mode.
                  */
                 ok = tc && (c >= 32 ||
-                            (!vc->vc_utf && !(((vc->vc_disp_ctrl ? CTRL_ALWAYS
-                                                : CTRL_ACTION) >> c) & 1)))
+                            !(vc->vc_disp_ctrl ? (CTRL_ALWAYS >> c) & 1 :
+                                  vc->vc_utf || ((CTRL_ACTION >> c) & 1)))
                         && (c != 127 || vc->vc_disp_ctrl)
                         && (c != 128+27);
 
                 if (vc->vc_state == ESnormal && ok) {
                         /* Now try to find out how to display it */
                         tc = conv_uni_to_pc(vc, tc);
-                        if ( tc == -4 ) {
+                        if (tc & ~charmask) {
+                                if ( tc == -4 ) {
                                 /* If we got -4 (not found) then see if we have
                                    defined a replacement character (U+FFFD) */
-                                tc = conv_uni_to_pc(vc, 0xfffd);
-
-                                /* One reason for the -4 can be that we just
-                                   did a clear_unimap();
-                                   try at least to show something. */
-                                if (tc == -4)
-                                     tc = c;
-                        } else if ( tc == -3 ) {
-                                /* Bad hash table -- hope for the best */
-                                tc = c;
-                        }
-                        if (tc & ~charmask)
-                                continue; /* Conversion failed */
+replacement_glyph:
+                                        tc = conv_uni_to_pc(vc, 0xfffd);
+                                        if (!(tc & ~charmask))
+                                                goto display_glyph;
+                                } else if ( tc != -3 )
+                                        continue; /* nothing to display */
+                                /* no hash table or no replacement --
+                                 * hope for the best */
+                                if ( c & ~charmask )
+                                        tc = '?';
+                                else
+                                        tc = c;
+                        }
 
+display_glyph:
                         if (vc->vc_need_wrap || vc->vc_decim)
                                 FLUSH
                         if (vc->vc_need_wrap) {
@@ -2102,6 +2122,15 @@ static int do_con_write(struct tty_struct *tty, const unsigned char *buf, int co
                                 vc->vc_x++;
                                 draw_to = (vc->vc_pos += 2);
                         }
+                        if (vc->vc_utf_count) {
+                                if (vc->vc_npar) {
+                                        vc->vc_npar--;
+                                        goto display_glyph;
+                                }
+                                vc->vc_utf_count = 0;
+                                c = orig;
+                                goto rescan_last_byte;
+                        }
                         continue;
                 }
                 FLUSH
@@ -2125,7 +2154,7 @@ out:
  * with other console code and prevention of re-entrancy is
  * ensured with console_sem.
  */
-static void console_callback(void *ignored)
+static void console_callback(struct work_struct *ignored)
 {
         acquire_console_sem();
 
@@ -2340,7 +2369,7 @@ int tioclinux(struct tty_struct *tty, unsigned long arg)
                         ret = __put_user(data, p);
                         break;
                 case TIOCL_SETVESABLANK:
-                        set_vesa_blanking(p);
+                        ret = set_vesa_blanking(p);
                         break;
                 case TIOCL_GETKMSGREDIRECT:
                         data = kmsg_redirect;
@@ -2498,7 +2527,7 @@ static int con_open(struct tty_struct *tty, struct file *filp)
                                 tty->winsize.ws_col = vc_cons[currcons].d->vc_cols;
                         }
                         release_console_sem();
-                        vcs_make_devfs(tty);
+                        vcs_make_sysfs(tty);
                         return ret;
                 }
         }
@@ -2511,7 +2540,7 @@ static int con_open(struct tty_struct *tty, struct file *filp)
  * and taking a ref against the tty while we're in the process of forgetting
  * about it and cleaning things up.
  *
- * This is because vcs_remove_devfs() can sleep and will drop the BKL.
+ * This is because vcs_remove_sysfs() can sleep and will drop the BKL.
  */
 static void con_close(struct tty_struct *tty, struct file *filp)
 {
@@ -2524,7 +2553,7 @@ static void con_close(struct tty_struct *tty, struct file *filp)
                         vc->vc_tty = NULL;
                 tty->driver_data = NULL;
                 release_console_sem();
-                vcs_remove_devfs(tty);
+                vcs_remove_sysfs(tty);
                 mutex_unlock(&tty_mutex);
                 /*
                  * tty_mutex is released, but we still hold BKL, so there is
@@ -2639,7 +2668,7 @@ static int __init con_init(void)
 }
 console_initcall(con_init);
 
-static struct tty_operations con_ops = {
+static const struct tty_operations con_ops = {
         .open = con_open,
         .close = con_close,
         .write = con_write,
@@ -2994,10 +3023,10 @@ static inline int vt_unbind(struct con_driver *con)
 }
 #endif /* CONFIG_VT_HW_CONSOLE_BINDING */
 
-static ssize_t store_bind(struct class_device *class_device,
+static ssize_t store_bind(struct device *dev, struct device_attribute *attr,
                           const char *buf, size_t count)
 {
-        struct con_driver *con = class_get_devdata(class_device);
+        struct con_driver *con = dev_get_drvdata(dev);
         int bind = simple_strtoul(buf, NULL, 0);
 
         if (bind)
@@ -3008,17 +3037,19 @@ static ssize_t store_bind(struct class_device *class_device,
         return count;
 }
 
-static ssize_t show_bind(struct class_device *class_device, char *buf)
+static ssize_t show_bind(struct device *dev, struct device_attribute *attr,
+                         char *buf)
 {
-        struct con_driver *con = class_get_devdata(class_device);
+        struct con_driver *con = dev_get_drvdata(dev);
         int bind = con_is_bound(con->con);
 
         return snprintf(buf, PAGE_SIZE, "%i\n", bind);
 }
 
-static ssize_t show_name(struct class_device *class_device, char *buf)
+static ssize_t show_name(struct device *dev, struct device_attribute *attr,
+                         char *buf)
 {
-        struct con_driver *con = class_get_devdata(class_device);
+        struct con_driver *con = dev_get_drvdata(dev);
 
         return snprintf(buf, PAGE_SIZE, "%s %s\n",
                         (con->flag & CON_DRIVER_FLAG_MODULE) ? "(M)" : "(S)",
@@ -3026,30 +3057,42 @@ static ssize_t show_name(struct class_device *class_device, char *buf)
 
 }
 
-static struct class_device_attribute class_device_attrs[] = {
+static struct device_attribute device_attrs[] = {
         __ATTR(bind, S_IRUGO|S_IWUSR, show_bind, store_bind),
         __ATTR(name, S_IRUGO, show_name, NULL),
 };
 
-static int vtconsole_init_class_device(struct con_driver *con)
+static int vtconsole_init_device(struct con_driver *con)
 {
         int i;
+        int error = 0;
 
-        class_set_devdata(con->class_dev, con);
-        for (i = 0; i < ARRAY_SIZE(class_device_attrs); i++)
-                class_device_create_file(con->class_dev,
-                                         &class_device_attrs[i]);
+        con->flag |= CON_DRIVER_FLAG_ATTR;
+        dev_set_drvdata(con->dev, con);
+        for (i = 0; i < ARRAY_SIZE(device_attrs); i++) {
+                error = device_create_file(con->dev, &device_attrs[i]);
+                if (error)
+                        break;
+        }
 
-        return 0;
+        if (error) {
+                while (--i >= 0)
+                        device_remove_file(con->dev, &device_attrs[i]);
+                con->flag &= ~CON_DRIVER_FLAG_ATTR;
+        }
+
+        return error;
 }
 
-static void vtconsole_deinit_class_device(struct con_driver *con)
+static void vtconsole_deinit_device(struct con_driver *con)
 {
         int i;
 
-        for (i = 0; i < ARRAY_SIZE(class_device_attrs); i++)
-                class_device_remove_file(con->class_dev,
-                                         &class_device_attrs[i]);
+        if (con->flag & CON_DRIVER_FLAG_ATTR) {
+                for (i = 0; i < ARRAY_SIZE(device_attrs); i++)
+                        device_remove_file(con->dev, &device_attrs[i]);
+                con->flag &= ~CON_DRIVER_FLAG_ATTR;
+        }
 }
 
 /**
@@ -3135,19 +3178,19 @@ int register_con_driver(const struct consw *csw, int first, int last)
         if (retval)
                 goto err;
 
-        con_driver->class_dev = class_device_create(vtconsole_class, NULL,
-                                                    MKDEV(0, con_driver->node),
-                                                    NULL, "vtcon%i",
-                                                    con_driver->node);
+        con_driver->dev = device_create(vtconsole_class, NULL,
+                                        MKDEV(0, con_driver->node),
+                                        "vtcon%i", con_driver->node);
 
-        if (IS_ERR(con_driver->class_dev)) {
-                printk(KERN_WARNING "Unable to create class_device for %s; "
+        if (IS_ERR(con_driver->dev)) {
+                printk(KERN_WARNING "Unable to create device for %s; "
                        "errno = %ld\n", con_driver->desc,
-                       PTR_ERR(con_driver->class_dev));
-                con_driver->class_dev = NULL;
+                       PTR_ERR(con_driver->dev));
+                con_driver->dev = NULL;
         } else {
-                vtconsole_init_class_device(con_driver);
+                vtconsole_init_device(con_driver);
         }
+
 err:
         release_console_sem();
         module_put(owner);
@@ -3181,12 +3224,12 @@ int unregister_con_driver(const struct consw *csw)
 
                 if (con_driver->con == csw &&
                     con_driver->flag & CON_DRIVER_FLAG_MODULE) {
-                        vtconsole_deinit_class_device(con_driver);
-                        class_device_destroy(vtconsole_class,
-                                             MKDEV(0, con_driver->node));
+                        vtconsole_deinit_device(con_driver);
+                        device_destroy(vtconsole_class,
+                                       MKDEV(0, con_driver->node));
                         con_driver->con = NULL;
                         con_driver->desc = NULL;
-                        con_driver->class_dev = NULL;
+                        con_driver->dev = NULL;
                         con_driver->node = 0;
                         con_driver->flag = 0;
                         con_driver->first = 0;
@@ -3244,19 +3287,18 @@ static int __init vtconsole_class_init(void)
         for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
                 struct con_driver *con = &registered_con_driver[i];
 
-                if (con->con && !con->class_dev) {
-                        con->class_dev =
-                                class_device_create(vtconsole_class, NULL,
-                                                    MKDEV(0, con->node), NULL,
-                                                    "vtcon%i", con->node);
+                if (con->con && !con->dev) {
+                        con->dev = device_create(vtconsole_class, NULL,
+                                                 MKDEV(0, con->node),
+                                                 "vtcon%i", con->node);
 
-                        if (IS_ERR(con->class_dev)) {
+                        if (IS_ERR(con->dev)) {
                                 printk(KERN_WARNING "Unable to create "
-                                       "class_device for %s; errno = %ld\n",
-                                       con->desc, PTR_ERR(con->class_dev));
-                                con->class_dev = NULL;
+                                       "device for %s; errno = %ld\n",
+                                       con->desc, PTR_ERR(con->dev));
+                                con->dev = NULL;
                         } else {
-                                vtconsole_init_class_device(con);
+                                vtconsole_init_device(con);
                         }
                 }
         }
@@ -3271,11 +3313,15 @@ postcore_initcall(vtconsole_class_init);
  *      Screen blanking
  */
 
-static void set_vesa_blanking(char __user *p)
+static int set_vesa_blanking(char __user *p)
 {
-    unsigned int mode;
-    get_user(mode, p + 1);
-    vesa_blank_mode = (mode < 4) ? mode : 0;
+        unsigned int mode;
+
+        if (get_user(mode, p + 1))
+                return -EFAULT;
+
+        vesa_blank_mode = (mode < 4) ? mode : 0;
+        return 0;
 }
 
 void do_blank_screen(int entering_gfx)
@@ -3765,6 +3811,7 @@ EXPORT_SYMBOL(default_blu);
 EXPORT_SYMBOL(update_region);
 EXPORT_SYMBOL(redraw_screen);
 EXPORT_SYMBOL(vc_resize);
+EXPORT_SYMBOL(vc_lock_resize);
 EXPORT_SYMBOL(fg_console);
 EXPORT_SYMBOL(console_blank_hook);
 EXPORT_SYMBOL(console_blanked);
diff --git a/drivers/char/vt_ioctl.c b/drivers/char/vt_ioctl.c
index a5628a8b6620..ac5d60edbafa 100644
--- a/drivers/char/vt_ioctl.c
+++ b/drivers/char/vt_ioctl.c
@@ -96,7 +96,7 @@ do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm, struct kbd_str
                 if (!perm)
                         return -EPERM;
                 if (!i && v == K_NOSUCHMAP) {
-                        /* disallocate map */
+                        /* deallocate map */
                         key_map = key_maps[s];
                         if (s && key_map) {
                             key_maps[s] = NULL;
@@ -645,13 +645,16 @@ int vt_ioctl(struct tty_struct *tty, struct file * file,
          */
         case KDSIGACCEPT:
         {
-                extern int spawnpid, spawnsig;
                 if (!perm || !capable(CAP_KILL))
                   return -EPERM;
                 if (!valid_signal(arg) || arg < 1 || arg == SIGKILL)
                   return -EINVAL;
-                spawnpid = current->pid;
-                spawnsig = arg;
+
+                spin_lock_irq(&vt_spawn_con.lock);
+                put_pid(vt_spawn_con.pid);
+                vt_spawn_con.pid = get_pid(task_pid(current));
+                vt_spawn_con.sig = arg;
+                spin_unlock_irq(&vt_spawn_con.lock);
                 return 0;
         }
 
@@ -669,7 +672,7 @@ int vt_ioctl(struct tty_struct *tty, struct file * file,
                 vc->vt_mode = tmp;
                 /* the frsig is ignored, so we set it to 0 */
                 vc->vt_mode.frsig = 0;
-                vc->vt_pid = current->pid;
+                put_pid(xchg(&vc->vt_pid, get_pid(task_pid(current))));
                 /* no switch is required -- saw@shade.msu.ru */
                 vc->vt_newvt = -1;
                 release_console_sem();
@@ -819,20 +822,20 @@ int vt_ioctl(struct tty_struct *tty, struct file * file,
                 if (arg > MAX_NR_CONSOLES)
                         return -ENXIO;
                 if (arg == 0) {
-                    /* disallocate all unused consoles, but leave 0 */
+                    /* deallocate all unused consoles, but leave 0 */
                         acquire_console_sem();
                         for (i=1; i<MAX_NR_CONSOLES; i++)
                                 if (! VT_BUSY(i))
-                                        vc_disallocate(i);
+                                        vc_deallocate(i);
                         release_console_sem();
                 } else {
-                        /* disallocate a single console, if possible */
+                        /* deallocate a single console, if possible */
                         arg--;
                         if (VT_BUSY(arg))
                                 return -EBUSY;
                         if (arg) {                            /* leave 0 */
                                 acquire_console_sem();
-                                vc_disallocate(arg);
+                                vc_deallocate(arg);
                                 release_console_sem();
                         }
                 }
@@ -847,11 +850,8 @@ int vt_ioctl(struct tty_struct *tty, struct file * file,
                 if (get_user(ll, &vtsizes->v_rows) ||
                     get_user(cc, &vtsizes->v_cols))
                         return -EFAULT;
-                for (i = 0; i < MAX_NR_CONSOLES; i++) {
-                        acquire_console_sem();
-                        vc_resize(vc_cons[i].d, cc, ll);
-                        release_console_sem();
-                }
+                for (i = 0; i < MAX_NR_CONSOLES; i++)
+                        vc_lock_resize(vc_cons[i].d, cc, ll);
                 return 0;
         }
 
@@ -1063,7 +1063,7 @@ void reset_vc(struct vc_data *vc)
         vc->vt_mode.relsig = 0;
         vc->vt_mode.acqsig = 0;
         vc->vt_mode.frsig = 0;
-        vc->vt_pid = -1;
+        put_pid(xchg(&vc->vt_pid, NULL));
         vc->vt_newvt = -1;
         if (!in_interrupt())    /* Via keyboard.c:SAK() - akpm */
                 reset_palette(vc);
@@ -1114,7 +1114,7 @@ static void complete_change_console(struct vc_data *vc)
                  * tell us if the process has gone or something else
                  * is awry
                  */
-                if (kill_proc(vc->vt_pid, vc->vt_mode.acqsig, 1) != 0) {
+                if (kill_pid(vc->vt_pid, vc->vt_mode.acqsig, 1) != 0) {
                 /*
                  * The controlling process has died, so we revert back to
                  * normal operation. In this case, we'll also change back
@@ -1174,7 +1174,7 @@ void change_console(struct vc_data *new_vc)
                  * tell us if the process has gone or something else
                  * is awry
                  */
-                if (kill_proc(vc->vt_pid, vc->vt_mode.relsig, 1) == 0) {
+                if (kill_pid(vc->vt_pid, vc->vt_mode.relsig, 1) == 0) {
                         /*
                          * It worked. Mark the vt to switch to and
                          * return. The process needs to send us a
diff --git a/drivers/char/watchdog/Kconfig b/drivers/char/watchdog/Kconfig
index fff89c2d88fd..ea09d0c974ea 100644
--- a/drivers/char/watchdog/Kconfig
+++ b/drivers/char/watchdog/Kconfig
@@ -13,7 +13,7 @@ config WATCHDOG
           subsequently opening the file and then failing to write to it for
           longer than 1 minute will result in rebooting the machine. This
           could be useful for a networked machine that needs to come back
-          online as fast as possible after a lock-up. There's both a watchdog
+          on-line as fast as possible after a lock-up. There's both a watchdog
           implementation entirely in software (which can sometimes fail to
           reboot the machine) and a driver for hardware watchdog boards, which
           are more robust and can also keep track of the temperature inside
@@ -60,7 +60,7 @@ config SOFT_WATCHDOG
 
 # ARM Architecture
 
-config AT91_WATCHDOG
+config AT91RM9200_WATCHDOG
         tristate "AT91RM9200 watchdog"
         depends on WATCHDOG && ARCH_AT91RM9200
         help
@@ -71,7 +71,7 @@ config 21285_WATCHDOG
         tristate "DC21285 watchdog"
         depends on WATCHDOG && FOOTBRIDGE
         help
-          The Intel Footbridge chip contains a builtin watchdog circuit. Say Y
+          The Intel Footbridge chip contains a built-in watchdog circuit. Say Y
           here if you wish to use this. Alternatively say M to compile the
           driver as a module, which will be called wdt285.
 
@@ -165,6 +165,24 @@ config EP93XX_WATCHDOG
           To compile this driver as a module, choose M here: the
           module will be called ep93xx_wdt.
 
+config OMAP_WATCHDOG
+        tristate "OMAP Watchdog"
+        depends on WATCHDOG && (ARCH_OMAP16XX || ARCH_OMAP24XX)
+        help
+          Support for TI OMAP1610/OMAP1710/OMAP2420 watchdog.  Say 'Y' here to
+          enable the OMAP1610/OMAP1710 watchdog timer.
+
+config PNX4008_WATCHDOG
+        tristate "PNX4008 Watchdog"
+        depends on WATCHDOG && ARCH_PNX4008
+        help
+          Say Y here if to include support for the watchdog timer
+          in the PNX4008 processor.
+          This driver can be built as a module by choosing M. The module
+          will be called pnx4008_wdt.
+
+          Say N if you are unsure.
+
 # X86 (i386 + ia64 + x86_64) Architecture
 
 config ACQUIRE_WDT
@@ -251,11 +269,11 @@ config IB700_WDT
           Most people will say N.
 
 config IBMASR
-        tristate "IBM Automatic Server Restart"
-        depends on WATCHDOG && X86
-        help
+        tristate "IBM Automatic Server Restart"
+        depends on WATCHDOG && X86
+        help
           This is the driver for the IBM Automatic Server Restart watchdog
-          timer builtin into some eServer xSeries machines.
+          timer built-in into some eServer xSeries machines.
 
           To compile this driver as a module, choose M here: the
           module will be called ibmasr.
@@ -298,6 +316,38 @@ config I8XX_TCO
           To compile this driver as a module, choose M here: the
           module will be called i8xx_tco.
 
+          Note: This driver will be removed in the near future. Please
+          use the Intel TCO Timer/Watchdog driver.
+
+config ITCO_WDT
+        tristate "Intel TCO Timer/Watchdog"
+        depends on WATCHDOG && (X86 || IA64) && PCI
+        ---help---
+          Hardware driver for the intel TCO timer based watchdog devices.
+          These drivers are included in the Intel 82801 I/O Controller
+          Hub family (from ICH0 up to ICH8) and in the Intel 6300ESB
+          controller hub.
+
+          The TCO (Total Cost of Ownership) timer is a watchdog timer
+          that will reboot the machine after its second expiration. The
+          expiration time can be configured with the "heartbeat" parameter.
+
+          On some motherboards the driver may fail to reset the chipset's
+          NO_REBOOT flag which prevents the watchdog from rebooting the
+          machine. If this is the case you will get a kernel message like
+          "failed to reset NO_REBOOT flag, reboot disabled by hardware".
+
+          To compile this driver as a module, choose M here: the
+          module will be called iTCO_wdt.
+
+config ITCO_VENDOR_SUPPORT
+        bool "Intel TCO Timer/Watchdog Specific Vendor Support"
+        depends on ITCO_WDT
+        ---help---
+          Add vendor specific support to the intel TCO timer based watchdog
+          devices. At this moment we only have additional support for some
+          SuperMicro Inc. motherboards.
+
 config SC1200_WDT
         tristate "National Semiconductor PC87307/PC97307 (ala SC1200) Watchdog"
         depends on WATCHDOG && X86
@@ -321,6 +371,20 @@ config SCx200_WDT
 
           If compiled as a module, it will be called scx200_wdt.
 
+config PC87413_WDT
+        tristate "NS PC87413 watchdog"
+        depends on WATCHDOG && X86
+        ---help---
+          This is the driver for the hardware watchdog on the PC87413 chipset
+          This watchdog simply watches your kernel to make sure it doesn't
+          freeze, and if it does, it reboots your computer after a certain
+          amount of time.
+
+          To compile this driver as a module, choose M here: the
+          module will be called pc87413_wdt.
+
+          Most people will say N.
+ 
 config 60XX_WDT
         tristate "SBC-60XX Watchdog Timer"
         depends on WATCHDOG && X86
@@ -356,6 +420,26 @@ config CPU5_WDT
           To compile this driver as a module, choose M here: the
           module will be called cpu5wdt.
 
+config SMSC37B787_WDT
+        tristate "Winbond SMsC37B787 Watchdog Timer"
+        depends on WATCHDOG && X86
+        ---help---
+          This is the driver for the hardware watchdog component on the
+          Winbond SMsC37B787 chipset as used on the NetRunner Mainboard
+          from Vision Systems and maybe others.
+
+          This watchdog simply watches your kernel to make sure it doesn't
+          freeze, and if it does, it reboots your computer after a certain
+          amount of time.
+
+          Usually a userspace daemon will notify the kernel WDT driver that
+          userspace is still alive, at regular intervals.
+
+          To compile this driver as a module, choose M here: the
+          module will be called smsc37b787_wdt.
+
+          Most people will say N.
+
 config W83627HF_WDT
         tristate "W83627HF Watchdog Timer"
         depends on WATCHDOG && X86
@@ -371,6 +455,21 @@ config W83627HF_WDT
 
           Most people will say N.
 
+config W83697HF_WDT
+        tristate "W83697HF/W83697HG Watchdog Timer"
+        depends on WATCHDOG && X86
+        ---help---
+          This is the driver for the hardware watchdog on the W83697HF/HG
+          chipset as used in Dedibox/VIA motherboards (and likely others).
+          This watchdog simply watches your kernel to make sure it doesn't
+          freeze, and if it does, it reboots your computer after a certain
+          amount of time.
+
+          To compile this driver as a module, choose M here: the
+          module will be called w83697hf_wdt.
+
+          Most people will say N.
+
 config W83877F_WDT
         tristate "W83877F (EMACS) Watchdog Timer"
         depends on WATCHDOG && X86
@@ -404,7 +503,7 @@ config MACHZ_WDT
         depends on WATCHDOG && X86
         ---help---
           If you are using a ZF Micro MachZ processor, say Y here, otherwise
-          N.  This is the driver for the watchdog timer builtin on that
+          N.  This is the driver for the watchdog timer built-in on that
           processor using ZF-Logic interface.  This watchdog simply watches
           your kernel to make sure it doesn't freeze, and if it does, it
           reboots your computer after a certain amount of time.
@@ -433,7 +532,6 @@ config SBC_EPX_C3_WATCHDOG
           To compile this driver as a module, choose M here: the
           module will be called sbc_epx_c3.
 
-
 # PowerPC Architecture
 
 config 8xx_WDT
@@ -463,7 +561,7 @@ config WATCHDOG_RTAS
         help
           This driver adds watchdog support for the RTAS watchdog.
 
-          To compile this driver as a module, choose M here. The module
+          To compile this driver as a module, choose M here. The module
           will be called wdrtas.
 
 # MIPS Architecture
@@ -477,6 +575,16 @@ config INDYDOG
           timer expired and no process has written to /dev/watchdog during
           that time.
 
+config WDT_RM9K_GPI
+        tristate "RM9000/GPI hardware watchdog"
+        depends on WATCHDOG && CPU_RM9000
+        help
+          Watchdog implementation using the GPI hardware found on
+          PMC-Sierra RM9xxx CPUs.
+
+          To compile this driver as a module, choose M here: the
+          module will be called rm9k_wdt.
+
 # S390 Architecture
 
 config ZVM_WATCHDOG
@@ -510,6 +618,14 @@ config SH_WDT
           To compile this driver as a module, choose M here: the
           module will be called shwdt.
 
+config SH_WDT_MMAP
+        bool "Allow mmap of SH WDT"
+        default n
+        depends on SH_WDT
+        help
+          If you say Y here, user applications will be able to mmap the
+          WDT/CPG registers.
+
 # SPARC64 Architecture
 
 config WATCHDOG_CP1XXX
diff --git a/drivers/char/watchdog/Makefile b/drivers/char/watchdog/Makefile
index 6ab77b61a643..2cd8ff8d10ac 100644
--- a/drivers/char/watchdog/Makefile
+++ b/drivers/char/watchdog/Makefile
@@ -23,7 +23,8 @@ obj-$(CONFIG_WDTPCI) += wdt_pci.o
 obj-$(CONFIG_USBPCWATCHDOG) += pcwd_usb.o
 
 # ARM Architecture
-obj-$(CONFIG_AT91_WATCHDOG) += at91_wdt.o
+obj-$(CONFIG_AT91RM9200_WATCHDOG) += at91rm9200_wdt.o
+obj-$(CONFIG_OMAP_WATCHDOG) += omap_wdt.o
 obj-$(CONFIG_21285_WATCHDOG) += wdt285.o
 obj-$(CONFIG_977_WATCHDOG) += wdt977.o
 obj-$(CONFIG_IXP2000_WATCHDOG) += ixp2000_wdt.o
@@ -32,6 +33,7 @@ obj-$(CONFIG_S3C2410_WATCHDOG) += s3c2410_wdt.o
 obj-$(CONFIG_SA1100_WATCHDOG) += sa1100_wdt.o
 obj-$(CONFIG_MPCORE_WATCHDOG) += mpcore_wdt.o
 obj-$(CONFIG_EP93XX_WATCHDOG) += ep93xx_wdt.o
+obj-$(CONFIG_PNX4008_WATCHDOG) += pnx4008_wdt.o
 
 # X86 (i386 + ia64 + x86_64) Architecture
 obj-$(CONFIG_ACQUIRE_WDT) += acquirewdt.o
@@ -45,12 +47,16 @@ obj-$(CONFIG_IBMASR) += ibmasr.o
 obj-$(CONFIG_WAFER_WDT) += wafer5823wdt.o
 obj-$(CONFIG_I6300ESB_WDT) += i6300esb.o
 obj-$(CONFIG_I8XX_TCO) += i8xx_tco.o
+obj-$(CONFIG_ITCO_WDT) += iTCO_wdt.o iTCO_vendor_support.o
 obj-$(CONFIG_SC1200_WDT) += sc1200wdt.o
 obj-$(CONFIG_SCx200_WDT) += scx200_wdt.o
+obj-$(CONFIG_PC87413_WDT) += pc87413_wdt.o
 obj-$(CONFIG_60XX_WDT) += sbc60xxwdt.o
 obj-$(CONFIG_SBC8360_WDT) += sbc8360.o
 obj-$(CONFIG_CPU5_WDT) += cpu5wdt.o
+obj-$(CONFIG_SMSC37B787_WDT) += smsc37b787_wdt.o
 obj-$(CONFIG_W83627HF_WDT) += w83627hf_wdt.o
+obj-$(CONFIG_W83697HF_WDT) += w83697hf_wdt.o
 obj-$(CONFIG_W83877F_WDT) += w83877f_wdt.o
 obj-$(CONFIG_W83977F_WDT) += w83977f_wdt.o
 obj-$(CONFIG_MACHZ_WDT) += machzwd.o
@@ -67,6 +73,7 @@ obj-$(CONFIG_WATCHDOG_RTAS) += wdrtas.o
 
 # MIPS Architecture
 obj-$(CONFIG_INDYDOG) += indydog.o
+obj-$(CONFIG_WDT_RM9K_GPI) += rm9k_wdt.o
 
 # S390 Architecture
 
diff --git a/drivers/char/watchdog/acquirewdt.c b/drivers/char/watchdog/acquirewdt.c
index c77fe3cf2852..154d67e591e5 100644
--- a/drivers/char/watchdog/acquirewdt.c
+++ b/drivers/char/watchdog/acquirewdt.c
@@ -183,7 +183,7 @@ static int acq_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
         }
 
         default:
-          return -ENOIOCTLCMD;
+          return -ENOTTY;
         }
 }
 
diff --git a/drivers/char/watchdog/advantechwdt.c b/drivers/char/watchdog/advantechwdt.c
index 8069be445edc..9d732769ba01 100644
--- a/drivers/char/watchdog/advantechwdt.c
+++ b/drivers/char/watchdog/advantechwdt.c
@@ -176,7 +176,7 @@ advwdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
         }
 
         default:
-          return -ENOIOCTLCMD;
+          return -ENOTTY;
         }
         return 0;
 }
diff --git a/drivers/char/watchdog/alim1535_wdt.c b/drivers/char/watchdog/alim1535_wdt.c
index c5c94e4c9495..01b0d132ee41 100644
--- a/drivers/char/watchdog/alim1535_wdt.c
+++ b/drivers/char/watchdog/alim1535_wdt.c
@@ -236,7 +236,7 @@ static int ali_ioctl(struct inode *inode, struct file *file,
                         return put_user(timeout, p);
 
                 default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
         }
 }
 
@@ -330,17 +330,20 @@ static int __init ali_find_watchdog(void)
         u32 wdog;
 
         /* Check for a 1535 series bridge */
-        pdev = pci_find_device(PCI_VENDOR_ID_AL, 0x1535, NULL);
+        pdev = pci_get_device(PCI_VENDOR_ID_AL, 0x1535, NULL);
         if(pdev == NULL)
                 return -ENODEV;
+        pci_dev_put(pdev);
 
         /* Check for the a 7101 PMU */
-        pdev = pci_find_device(PCI_VENDOR_ID_AL, 0x7101, NULL);
+        pdev = pci_get_device(PCI_VENDOR_ID_AL, 0x7101, NULL);
         if(pdev == NULL)
                 return -ENODEV;
 
-        if(pci_enable_device(pdev))
+        if(pci_enable_device(pdev)) {
+                pci_dev_put(pdev);
                 return -EIO;
+        }
 
         ali_pci = pdev;
 
@@ -447,6 +450,7 @@ static void __exit watchdog_exit(void)
         /* Deregister */
         unregister_reboot_notifier(&ali_notifier);
         misc_deregister(&ali_miscdev);
+        pci_dev_put(ali_pci);
 }
 
 module_init(watchdog_init);
diff --git a/drivers/char/watchdog/alim7101_wdt.c b/drivers/char/watchdog/alim7101_wdt.c
index ffd7684f999b..bf25d0a55a99 100644
--- a/drivers/char/watchdog/alim7101_wdt.c
+++ b/drivers/char/watchdog/alim7101_wdt.c
@@ -77,7 +77,8 @@ static struct pci_dev *alim7101_pmu;
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
+                 __stringify(CONFIG_WATCHDOG_NOWAYOUT) ")");
 
 /*
  *      Whack the dog
@@ -277,7 +278,7 @@ static int fop_ioctl(struct inode *inode, struct file *file, unsigned int cmd, u
                 case WDIOC_GETTIMEOUT:
                         return put_user(timeout, p);
                 default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
         }
 }
 
@@ -333,6 +334,7 @@ static void __exit alim7101_wdt_unload(void)
         /* Deregister */
         misc_deregister(&wdt_miscdev);
         unregister_reboot_notifier(&wdt_notifier);
+        pci_dev_put(alim7101_pmu);
 }
 
 static int __init alim7101_wdt_init(void)
@@ -342,7 +344,8 @@ static int __init alim7101_wdt_init(void)
         char tmp;
 
         printk(KERN_INFO PFX "Steve Hill <steve@navaho.co.uk>.\n");
-        alim7101_pmu = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101,NULL);
+        alim7101_pmu = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101,
+                NULL);
         if (!alim7101_pmu) {
                 printk(KERN_INFO PFX "ALi M7101 PMU not present - WDT not set\n");
                 return -EBUSY;
@@ -351,21 +354,23 @@ static int __init alim7101_wdt_init(void)
         /* Set the WDT in the PMU to 1 second */
         pci_write_config_byte(alim7101_pmu, ALI_7101_WDT, 0x02);
 
-        ali1543_south = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533, NULL);
+        ali1543_south = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
+                NULL);
         if (!ali1543_south) {
                 printk(KERN_INFO PFX "ALi 1543 South-Bridge not present - WDT not set\n");
-                return -EBUSY;
+                goto err_out;
         }
         pci_read_config_byte(ali1543_south, 0x5e, &tmp);
+        pci_dev_put(ali1543_south);
         if ((tmp & 0x1e) == 0x00) {
                 if (!use_gpio) {
                         printk(KERN_INFO PFX "Detected old alim7101 revision 'a1d'.  If this is a cobalt board, set the 'use_gpio' module parameter.\n");
-                        return -EBUSY;
+                        goto err_out;
                 } 
                 nowayout = 1;
         } else if ((tmp & 0x1e) != 0x12 && (tmp & 0x1e) != 0x00) {
                 printk(KERN_INFO PFX "ALi 1543 South-Bridge does not have the correct revision number (???1001?) - WDT not set\n");
-                return -EBUSY;
+                goto err_out;
         }
 
         if(timeout < 1 || timeout > 3600) /* arbitrary upper limit */
@@ -404,12 +409,23 @@ static int __init alim7101_wdt_init(void)
 err_out_miscdev:
         misc_deregister(&wdt_miscdev);
 err_out:
+        pci_dev_put(alim7101_pmu);
         return rc;
 }
 
 module_init(alim7101_wdt_init);
 module_exit(alim7101_wdt_unload);
 
+static struct pci_device_id alim7101_pci_tbl[] __devinitdata = {
+        { PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
+          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+        { PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101,
+          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+        { }
+};
+
+MODULE_DEVICE_TABLE(pci, alim7101_pci_tbl);
+
 MODULE_AUTHOR("Steve Hill");
 MODULE_DESCRIPTION("ALi M7101 PMU Computer Watchdog Timer driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/char/watchdog/at91_wdt.c b/drivers/char/watchdog/at91rm9200_wdt.c
index cc266715ea32..cb86967e2c5f 100644
--- a/drivers/char/watchdog/at91_wdt.c
+++ b/drivers/char/watchdog/at91rm9200_wdt.c
@@ -21,6 +21,7 @@
 #include <linux/watchdog.h>
 #include <asm/bitops.h>
 #include <asm/uaccess.h>
+#include <asm/arch/at91_st.h>
 
 
 #define WDT_DEFAULT_TIME        5       /* seconds */
@@ -168,7 +169,7 @@ static int at91_wdt_ioctl(struct inode *inode, struct file *file,
                         return 0;
 
                 default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
         }
 }
 
diff --git a/drivers/char/watchdog/booke_wdt.c b/drivers/char/watchdog/booke_wdt.c
index e3cefc538b40..488902231cc2 100644
--- a/drivers/char/watchdog/booke_wdt.c
+++ b/drivers/char/watchdog/booke_wdt.c
@@ -125,7 +125,7 @@ static int booke_wdt_ioctl (struct inode *inode, struct file *file,
                         return -EINVAL;
                 return 0;
         default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
         }
 
         return 0;
diff --git a/drivers/char/watchdog/cpu5wdt.c b/drivers/char/watchdog/cpu5wdt.c
index 04c7e49918db..00bdabb90f27 100644
--- a/drivers/char/watchdog/cpu5wdt.c
+++ b/drivers/char/watchdog/cpu5wdt.c
@@ -183,7 +183,7 @@ static int cpu5wdt_ioctl(struct inode *inode, struct file *file, unsigned int cm
                         }
                         break;
                 default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
         }
         return 0;
 }
diff --git a/drivers/char/watchdog/ep93xx_wdt.c b/drivers/char/watchdog/ep93xx_wdt.c
index 77c8a955ae9e..01cf123b1616 100644
--- a/drivers/char/watchdog/ep93xx_wdt.c
+++ b/drivers/char/watchdog/ep93xx_wdt.c
@@ -144,7 +144,7 @@ static int
 ep93xx_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                  unsigned long arg)
 {
-        int ret = -ENOIOCTLCMD;
+        int ret = -ENOTTY;
 
         switch (cmd) {
         case WDIOC_GETSUPPORT:
diff --git a/drivers/char/watchdog/eurotechwdt.c b/drivers/char/watchdog/eurotechwdt.c
index 62dbccb2f6df..e228d6e173ce 100644
--- a/drivers/char/watchdog/eurotechwdt.c
+++ b/drivers/char/watchdog/eurotechwdt.c
@@ -153,7 +153,7 @@ static void eurwdt_activate_timer(void)
  * Kernel methods.
  */
 
-static irqreturn_t eurwdt_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t eurwdt_interrupt(int irq, void *dev_id)
 {
         printk(KERN_CRIT "timeout WDT timeout\n");
 
@@ -240,7 +240,7 @@ static int eurwdt_ioctl(struct inode *inode, struct file *file,
 
         switch(cmd) {
         default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
 
         case WDIOC_GETSUPPORT:
                 return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
diff --git a/drivers/char/watchdog/i6300esb.c b/drivers/char/watchdog/i6300esb.c
index 870539eabbf3..fb64df4d7c87 100644
--- a/drivers/char/watchdog/i6300esb.c
+++ b/drivers/char/watchdog/i6300esb.c
@@ -315,7 +315,7 @@ static int esb_ioctl (struct inode *inode, struct file *file,
                         return put_user(heartbeat, p);
 
                 default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
         }
 }
 
diff --git a/drivers/char/watchdog/i8xx_tco.c b/drivers/char/watchdog/i8xx_tco.c
index 8385dd36eefe..e0627d79707b 100644
--- a/drivers/char/watchdog/i8xx_tco.c
+++ b/drivers/char/watchdog/i8xx_tco.c
@@ -356,7 +356,7 @@ static int i8xx_tco_ioctl (struct inode *inode, struct file *file,
                 }
 
                 default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
         }
 }
 
@@ -406,18 +406,18 @@ static struct notifier_block i8xx_tco_notifier = {
  * want to register another driver on the same PCI id.
  */
 static struct pci_device_id i8xx_tco_pci_tbl[] = {
-        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AA_0,   PCI_ANY_ID, PCI_ANY_ID, },
-        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AB_0,   PCI_ANY_ID, PCI_ANY_ID, },
-        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_0,   PCI_ANY_ID, PCI_ANY_ID, },
-        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_10,  PCI_ANY_ID, PCI_ANY_ID, },
-        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_0,   PCI_ANY_ID, PCI_ANY_ID, },
-        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_12,  PCI_ANY_ID, PCI_ANY_ID, },
-        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_0,   PCI_ANY_ID, PCI_ANY_ID, },
-        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_12,  PCI_ANY_ID, PCI_ANY_ID, },
-        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801E_0,    PCI_ANY_ID, PCI_ANY_ID, },
-        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_0,   PCI_ANY_ID, PCI_ANY_ID, },
-        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB_1,       PCI_ANY_ID, PCI_ANY_ID, },
-        { 0, },                 /* End of list */
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AA_0) },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AB_0) },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_0) },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_10) },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_0) },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_12) },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_0) },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_12) },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801E_0) },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_0) },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB_1) },
+        { },                    /* End of list */
 };
 MODULE_DEVICE_TABLE (pci, i8xx_tco_pci_tbl);
 
@@ -434,12 +434,11 @@ static unsigned char __init i8xx_tco_getdevice (void)
          *      Find the PCI device
          */
 
-        while ((dev = pci_find_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
+        for_each_pci_dev(dev)
                 if (pci_match_id(i8xx_tco_pci_tbl, dev)) {
                         i8xx_tco_pci = dev;
                         break;
                 }
-        }
 
         if (i8xx_tco_pci) {
                 /*
@@ -454,6 +453,7 @@ static unsigned char __init i8xx_tco_getdevice (void)
                 /* Something's wrong here, ACPIBASE has to be set */
                 if (badr == 0x0001 || badr == 0x0000) {
                         printk (KERN_ERR PFX "failed to get TCOBASE address\n");
+                        pci_dev_put(i8xx_tco_pci);
                         return 0;
                 }
 
@@ -465,6 +465,7 @@ static unsigned char __init i8xx_tco_getdevice (void)
                         pci_read_config_byte (i8xx_tco_pci, 0xd4, &val1);
                         if (val1 & 0x02) {
                                 printk (KERN_ERR PFX "failed to reset NO_REBOOT flag, reboot disabled by hardware\n");
+                                pci_dev_put(i8xx_tco_pci);
                                 return 0;       /* Cannot reset NO_REBOOT bit */
                         }
                 }
@@ -476,6 +477,7 @@ static unsigned char __init i8xx_tco_getdevice (void)
                 if (!request_region (SMI_EN + 1, 1, "i8xx TCO")) {
                         printk (KERN_ERR PFX "I/O address 0x%04x already in use\n",
                                 SMI_EN + 1);
+                        pci_dev_put(i8xx_tco_pci);
                         return 0;
                 }
                 val1 = inb (SMI_EN + 1);
@@ -542,6 +544,7 @@ unreg_notifier:
 unreg_region:
         release_region (TCOBASE, 0x10);
 out:
+        pci_dev_put(i8xx_tco_pci);
         return ret;
 }
 
@@ -555,6 +558,8 @@ static void __exit watchdog_cleanup (void)
         misc_deregister (&i8xx_tco_miscdev);
         unregister_reboot_notifier(&i8xx_tco_notifier);
         release_region (TCOBASE, 0x10);
+
+        pci_dev_put(i8xx_tco_pci);
 }
 
 module_init(watchdog_init);
diff --git a/drivers/char/watchdog/iTCO_vendor_support.c b/drivers/char/watchdog/iTCO_vendor_support.c
new file mode 100644
index 000000000000..415083990097
--- /dev/null
+++ b/drivers/char/watchdog/iTCO_vendor_support.c
@@ -0,0 +1,307 @@
+/*
+ *      intel TCO vendor specific watchdog driver support
+ *
+ *      (c) Copyright 2006 Wim Van Sebroeck <wim@iguana.be>.
+ *
+ *      This program is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU General Public License
+ *      as published by the Free Software Foundation; either version
+ *      2 of the License, or (at your option) any later version.
+ *
+ *      Neither Wim Van Sebroeck nor Iguana vzw. admit liability nor
+ *      provide warranty for any of this software. This material is
+ *      provided "AS-IS" and at no charge.
+ */
+
+/*
+ *      Includes, defines, variables, module parameters, ...
+ */
+
+/* Module and version information */
+#define DRV_NAME        "iTCO_vendor_support"
+#define DRV_VERSION     "1.01"
+#define DRV_RELDATE     "11-Nov-2006"
+#define PFX             DRV_NAME ": "
+
+/* Includes */
+#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/init.h>                 /* For __init/__exit/... */
+#include <linux/ioport.h>               /* For io-port access */
+
+#include <asm/io.h>                     /* For inb/outb/... */
+
+/* iTCO defines */
+#define SMI_EN          acpibase + 0x30 /* SMI Control and Enable Register */
+#define TCOBASE         acpibase + 0x60 /* TCO base address             */
+#define TCO1_STS        TCOBASE + 0x04  /* TCO1 Status Register         */
+
+/* List of vendor support modes */
+#define SUPERMICRO_OLD_BOARD    1       /* SuperMicro Pentium 3 Era 370SSE+-OEM1/P3TSSE */
+#define SUPERMICRO_NEW_BOARD    2       /* SuperMicro Pentium 4 / Xeon 4 / EMT64T Era Systems */
+
+static int vendorsupport = 0;
+module_param(vendorsupport, int, 0);
+MODULE_PARM_DESC(vendorsupport, "iTCO vendor specific support mode, default=0 (none), 1=SuperMicro Pent3, 2=SuperMicro Pent4+");
+
+/*
+ *      Vendor Specific Support
+ */
+
+/*
+ *      Vendor Support: 1
+ *      Board: Super Micro Computer Inc. 370SSE+-OEM1/P3TSSE
+ *      iTCO chipset: ICH2
+ *
+ *      Code contributed by: R. Seretny <lkpatches@paypc.com>
+ *      Documentation obtained by R. Seretny from SuperMicro Technical Support
+ *
+ *      To enable Watchdog function:
+ *          BIOS setup -> Power -> TCO Logic SMI Enable -> Within5Minutes
+ *          This setting enables SMI to clear the watchdog expired flag.
+ *          If BIOS or CPU fail which may cause SMI hang, then system will
+ *          reboot. When application starts to use watchdog function,
+ *          application has to take over the control from SMI.
+ *
+ *          For P3TSSE, J36 jumper needs to be removed to enable the Watchdog
+ *          function.
+ *
+ *          Note: The system will reboot when Expire Flag is set TWICE.
+ *          So, if the watchdog timer is 20 seconds, then the maximum hang
+ *          time is about 40 seconds, and the minimum hang time is about
+ *          20.6 seconds.
+ */
+
+static void supermicro_old_pre_start(unsigned long acpibase)
+{
+        unsigned long val32;
+
+        val32 = inl(SMI_EN);
+        val32 &= 0xffffdfff;    /* Turn off SMI clearing watchdog */
+        outl(val32, SMI_EN);    /* Needed to activate watchdog */
+}
+
+static void supermicro_old_pre_stop(unsigned long acpibase)
+{
+        unsigned long val32;
+
+        val32 = inl(SMI_EN);
+        val32 &= 0x00002000;    /* Turn on SMI clearing watchdog */
+        outl(val32, SMI_EN);    /* Needed to deactivate watchdog */
+}
+
+static void supermicro_old_pre_keepalive(unsigned long acpibase)
+{
+        /* Reload TCO Timer (done in iTCO_wdt_keepalive) + */
+        /* Clear "Expire Flag" (Bit 3 of TC01_STS register) */
+        outb(0x08, TCO1_STS);
+}
+
+/*
+ *      Vendor Support: 2
+ *      Board: Super Micro Computer Inc. P4SBx, P4DPx
+ *      iTCO chipset: ICH4
+ *
+ *      Code contributed by: R. Seretny <lkpatches@paypc.com>
+ *      Documentation obtained by R. Seretny from SuperMicro Technical Support
+ *
+ *      To enable Watchdog function:
+ *       1. BIOS
+ *        For P4SBx:
+ *        BIOS setup -> Advanced -> Integrated Peripherals -> Watch Dog Feature
+ *        For P4DPx:
+ *        BIOS setup -> Advanced -> I/O Device Configuration -> Watch Dog
+ *       This setting enables or disables Watchdog function. When enabled, the
+ *       default watchdog timer is set to be 5 minutes (about 4’35�). It is
+ *       enough to load and run the OS. The application (service or driver) has
+ *       to take over the control once OS is running up and before watchdog
+ *       expires.
+ *
+ *       2. JUMPER
+ *        For P4SBx: JP39
+ *        For P4DPx: JP37
+ *        This jumper is used for safety.  Closed is enabled. This jumper
+ *        prevents user enables watchdog in BIOS by accident.
+ *
+ *       To enable Watch Dog function, both BIOS and JUMPER must be enabled.
+ *
+ *      The documentation lists motherboards P4SBx and P4DPx series as of
+ *      20-March-2002. However, this code works flawlessly with much newer
+ *      motherboards, such as my X6DHR-8G2 (SuperServer 6014H-82).
+ *
+ *      The original iTCO driver as written does not actually reset the
+ *      watchdog timer on these machines, as a result they reboot after five
+ *      minutes.
+ *
+ *      NOTE: You may leave the Watchdog function disabled in the SuperMicro
+ *      BIOS to avoid a "boot-race"... This driver will enable watchdog
+ *      functionality even if it's disabled in the BIOS once the /dev/watchdog
+ *      file is opened.
+ */
+
+/* I/O Port's */
+#define SM_REGINDEX     0x2e            /* SuperMicro ICH4+ Register Index */
+#define SM_DATAIO       0x2f            /* SuperMicro ICH4+ Register Data I/O */
+
+/* Control Register's */
+#define SM_CTLPAGESW    0x07            /* SuperMicro ICH4+ Control Page Switch */
+#define SM_CTLPAGE              0x08    /* SuperMicro ICH4+ Control Page Num */
+
+#define SM_WATCHENABLE  0x30            /* Watchdog enable: Bit 0: 0=off, 1=on */
+
+#define SM_WATCHPAGE    0x87            /* Watchdog unlock control page */
+
+#define SM_ENDWATCH     0xAA            /* Watchdog lock control page */
+
+#define SM_COUNTMODE    0xf5            /* Watchdog count mode select */
+                                        /* (Bit 3: 0 = seconds, 1 = minutes */
+
+#define SM_WATCHTIMER   0xf6            /* 8-bits, Watchdog timer counter (RW) */
+
+#define SM_RESETCONTROL 0xf7            /* Watchdog reset control */
+                                        /* Bit 6: timer is reset by kbd interrupt */
+                                        /* Bit 7: timer is reset by mouse interrupt */
+
+static void supermicro_new_unlock_watchdog(void)
+{
+        outb(SM_WATCHPAGE, SM_REGINDEX);        /* Write 0x87 to port 0x2e twice */
+        outb(SM_WATCHPAGE, SM_REGINDEX);
+
+        outb(SM_CTLPAGESW, SM_REGINDEX);        /* Switch to watchdog control page */
+        outb(SM_CTLPAGE, SM_DATAIO);
+}
+
+static void supermicro_new_lock_watchdog(void)
+{
+        outb(SM_ENDWATCH, SM_REGINDEX);
+}
+
+static void supermicro_new_pre_start(unsigned int heartbeat)
+{
+        unsigned int val;
+
+        supermicro_new_unlock_watchdog();
+
+        /* Watchdog timer setting needs to be in seconds*/
+        outb(SM_COUNTMODE, SM_REGINDEX);
+        val = inb(SM_DATAIO);
+        val &= 0xF7;
+        outb(val, SM_DATAIO);
+
+        /* Write heartbeat interval to WDOG */
+        outb (SM_WATCHTIMER, SM_REGINDEX);
+        outb((heartbeat & 255), SM_DATAIO);
+
+        /* Make sure keyboard/mouse interrupts don't interfere */
+        outb(SM_RESETCONTROL, SM_REGINDEX);
+        val = inb(SM_DATAIO);
+        val &= 0x3f;
+        outb(val, SM_DATAIO);
+
+        /* enable watchdog by setting bit 0 of Watchdog Enable to 1 */
+        outb(SM_WATCHENABLE, SM_REGINDEX);
+        val = inb(SM_DATAIO);
+        val |= 0x01;
+        outb(val, SM_DATAIO);
+
+        supermicro_new_lock_watchdog();
+}
+
+static void supermicro_new_pre_stop(void)
+{
+        unsigned int val;
+
+        supermicro_new_unlock_watchdog();
+
+        /* disable watchdog by setting bit 0 of Watchdog Enable to 0 */
+        outb(SM_WATCHENABLE, SM_REGINDEX);
+        val = inb(SM_DATAIO);
+        val &= 0xFE;
+        outb(val, SM_DATAIO);
+
+        supermicro_new_lock_watchdog();
+}
+
+static void supermicro_new_pre_set_heartbeat(unsigned int heartbeat)
+{
+        supermicro_new_unlock_watchdog();
+
+        /* reset watchdog timeout to heartveat value */
+        outb(SM_WATCHTIMER, SM_REGINDEX);
+        outb((heartbeat & 255), SM_DATAIO);
+
+        supermicro_new_lock_watchdog();
+}
+
+/*
+ *      Generic Support Functions
+ */
+
+void iTCO_vendor_pre_start(unsigned long acpibase,
+                           unsigned int heartbeat)
+{
+        if (vendorsupport == SUPERMICRO_OLD_BOARD)
+                supermicro_old_pre_start(acpibase);
+        else if (vendorsupport == SUPERMICRO_NEW_BOARD)
+                supermicro_new_pre_start(heartbeat);
+}
+EXPORT_SYMBOL(iTCO_vendor_pre_start);
+
+void iTCO_vendor_pre_stop(unsigned long acpibase)
+{
+        if (vendorsupport == SUPERMICRO_OLD_BOARD)
+                supermicro_old_pre_stop(acpibase);
+        else if (vendorsupport == SUPERMICRO_NEW_BOARD)
+                supermicro_new_pre_stop();
+}
+EXPORT_SYMBOL(iTCO_vendor_pre_stop);
+
+void iTCO_vendor_pre_keepalive(unsigned long acpibase, unsigned int heartbeat)
+{
+        if (vendorsupport == SUPERMICRO_OLD_BOARD)
+                supermicro_old_pre_keepalive(acpibase);
+        else if (vendorsupport == SUPERMICRO_NEW_BOARD)
+                supermicro_new_pre_set_heartbeat(heartbeat);
+}
+EXPORT_SYMBOL(iTCO_vendor_pre_keepalive);
+
+void iTCO_vendor_pre_set_heartbeat(unsigned int heartbeat)
+{
+        if (vendorsupport == SUPERMICRO_NEW_BOARD)
+                supermicro_new_pre_set_heartbeat(heartbeat);
+}
+EXPORT_SYMBOL(iTCO_vendor_pre_set_heartbeat);
+
+int iTCO_vendor_check_noreboot_on(void)
+{
+        switch(vendorsupport) {
+        case SUPERMICRO_OLD_BOARD:
+                return 0;
+        default:
+                return 1;
+        }
+}
+EXPORT_SYMBOL(iTCO_vendor_check_noreboot_on);
+
+static int __init iTCO_vendor_init_module(void)
+{
+        printk (KERN_INFO PFX "vendor-support=%d\n", vendorsupport);
+        return 0;
+}
+
+static void __exit iTCO_vendor_exit_module(void)
+{
+        printk (KERN_INFO PFX "Module Unloaded\n");
+}
+
+module_init(iTCO_vendor_init_module);
+module_exit(iTCO_vendor_exit_module);
+
+MODULE_AUTHOR("Wim Van Sebroeck <wim@iguana.be>, R. Seretny <lkpatches@paypc.com>");
+MODULE_DESCRIPTION("Intel TCO Vendor Specific WatchDog Timer Driver Support");
+MODULE_VERSION(DRV_VERSION);
+MODULE_LICENSE("GPL");
+
diff --git a/drivers/char/watchdog/iTCO_wdt.c b/drivers/char/watchdog/iTCO_wdt.c
new file mode 100644
index 000000000000..7eac922df867
--- /dev/null
+++ b/drivers/char/watchdog/iTCO_wdt.c
@@ -0,0 +1,772 @@
+/*
+ *      intel TCO Watchdog Driver (Used in i82801 and i6300ESB chipsets)
+ *
+ *      (c) Copyright 2006 Wim Van Sebroeck <wim@iguana.be>.
+ *
+ *      This program is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU General Public License
+ *      as published by the Free Software Foundation; either version
+ *      2 of the License, or (at your option) any later version.
+ *
+ *      Neither Wim Van Sebroeck nor Iguana vzw. admit liability nor
+ *      provide warranty for any of this software. This material is
+ *      provided "AS-IS" and at no charge.
+ *
+ *      The TCO watchdog is implemented in the following I/O controller hubs:
+ *      (See the intel documentation on http://developer.intel.com.)
+ *      82801AA  (ICH)       : document number 290655-003, 290677-014,
+ *      82801AB  (ICHO)      : document number 290655-003, 290677-014,
+ *      82801BA  (ICH2)      : document number 290687-002, 298242-027,
+ *      82801BAM (ICH2-M)    : document number 290687-002, 298242-027,
+ *      82801CA  (ICH3-S)    : document number 290733-003, 290739-013,
+ *      82801CAM (ICH3-M)    : document number 290716-001, 290718-007,
+ *      82801DB  (ICH4)      : document number 290744-001, 290745-020,
+ *      82801DBM (ICH4-M)    : document number 252337-001, 252663-005,
+ *      82801E   (C-ICH)     : document number 273599-001, 273645-002,
+ *      82801EB  (ICH5)      : document number 252516-001, 252517-003,
+ *      82801ER  (ICH5R)     : document number 252516-001, 252517-003,
+ *      82801FB  (ICH6)      : document number 301473-002, 301474-007,
+ *      82801FR  (ICH6R)     : document number 301473-002, 301474-007,
+ *      82801FBM (ICH6-M)    : document number 301473-002, 301474-007,
+ *      82801FW  (ICH6W)     : document number 301473-001, 301474-007,
+ *      82801FRW (ICH6RW)    : document number 301473-001, 301474-007,
+ *      82801GB  (ICH7)      : document number 307013-002, 307014-009,
+ *      82801GR  (ICH7R)     : document number 307013-002, 307014-009,
+ *      82801GDH (ICH7DH)    : document number 307013-002, 307014-009,
+ *      82801GBM (ICH7-M)    : document number 307013-002, 307014-009,
+ *      82801GHM (ICH7-M DH) : document number 307013-002, 307014-009,
+ *      82801HB  (ICH8)      : document number 313056-002, 313057-004,
+ *      82801HR  (ICH8R)     : document number 313056-002, 313057-004,
+ *      82801HH  (ICH8DH)    : document number 313056-002, 313057-004,
+ *      82801HO  (ICH8DO)    : document number 313056-002, 313057-004,
+ *      6300ESB  (6300ESB)   : document number 300641-003
+ */
+
+/*
+ *      Includes, defines, variables, module parameters, ...
+ */
+
+/* Module and version information */
+#define DRV_NAME        "iTCO_wdt"
+#define DRV_VERSION     "1.01"
+#define DRV_RELDATE     "11-Nov-2006"
+#define PFX             DRV_NAME ": "
+
+/* Includes */
+#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/miscdevice.h>           /* For MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR) */
+#include <linux/watchdog.h>             /* For the watchdog specific items */
+#include <linux/init.h>                 /* For __init/__exit/... */
+#include <linux/fs.h>                   /* For file operations */
+#include <linux/platform_device.h>      /* For platform_driver framework */
+#include <linux/pci.h>                  /* For pci functions */
+#include <linux/ioport.h>               /* For io-port access */
+#include <linux/spinlock.h>             /* For spin_lock/spin_unlock/... */
+
+#include <asm/uaccess.h>                /* For copy_to_user/put_user/... */
+#include <asm/io.h>                     /* For inb/outb/... */
+
+/* TCO related info */
+enum iTCO_chipsets {
+        TCO_ICH = 0,    /* ICH */
+        TCO_ICH0,       /* ICH0 */
+        TCO_ICH2,       /* ICH2 */
+        TCO_ICH2M,      /* ICH2-M */
+        TCO_ICH3,       /* ICH3-S */
+        TCO_ICH3M,      /* ICH3-M */
+        TCO_ICH4,       /* ICH4 */
+        TCO_ICH4M,      /* ICH4-M */
+        TCO_CICH,       /* C-ICH */
+        TCO_ICH5,       /* ICH5 & ICH5R */
+        TCO_6300ESB,    /* 6300ESB */
+        TCO_ICH6,       /* ICH6 & ICH6R */
+        TCO_ICH6M,      /* ICH6-M */
+        TCO_ICH6W,      /* ICH6W & ICH6RW */
+        TCO_ICH7,       /* ICH7 & ICH7R */
+        TCO_ICH7M,      /* ICH7-M */
+        TCO_ICH7MDH,    /* ICH7-M DH */
+        TCO_ICH8,       /* ICH8 & ICH8R */
+        TCO_ICH8DH,     /* ICH8DH */
+        TCO_ICH8DO,     /* ICH8DO */
+};
+
+static struct {
+        char *name;
+        unsigned int iTCO_version;
+} iTCO_chipset_info[] __devinitdata = {
+        {"ICH", 1},
+        {"ICH0", 1},
+        {"ICH2", 1},
+        {"ICH2-M", 1},
+        {"ICH3-S", 1},
+        {"ICH3-M", 1},
+        {"ICH4", 1},
+        {"ICH4-M", 1},
+        {"C-ICH", 1},
+        {"ICH5 or ICH5R", 1},
+        {"6300ESB", 1},
+        {"ICH6 or ICH6R", 2},
+        {"ICH6-M", 2},
+        {"ICH6W or ICH6RW", 2},
+        {"ICH7 or ICH7R", 2},
+        {"ICH7-M", 2},
+        {"ICH7-M DH", 2},
+        {"ICH8 or ICH8R", 2},
+        {"ICH8DH", 2},
+        {"ICH8DO", 2},
+        {NULL,0}
+};
+
+/*
+ * This data only exists for exporting the supported PCI ids
+ * via MODULE_DEVICE_TABLE.  We do not actually register a
+ * pci_driver, because the I/O Controller Hub has also other
+ * functions that probably will be registered by other drivers.
+ */
+static struct pci_device_id iTCO_wdt_pci_tbl[] = {
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AA_0,   PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH     },
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AB_0,   PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH0    },
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_0,   PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH2    },
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_10,  PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH2M   },
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_0,   PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH3    },
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_12,  PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH3M   },
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_0,   PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH4    },
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_12,  PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH4M   },
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801E_0,    PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_CICH    },
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_0,   PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH5    },
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB_1,       PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_6300ESB },
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_0,      PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH6    },
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_1,      PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH6M   },
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_2,      PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH6W   },
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_0,      PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH7    },
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_1,      PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH7M   },
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_31,     PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH7MDH },
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH8_0,      PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH8    },
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH8_2,      PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH8DH  },
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH8_3,      PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH8DO  },
+        { 0, },                 /* End of list */
+};
+MODULE_DEVICE_TABLE (pci, iTCO_wdt_pci_tbl);
+
+/* Address definitions for the TCO */
+#define TCOBASE         iTCO_wdt_private.ACPIBASE + 0x60        /* TCO base address                */
+#define SMI_EN          iTCO_wdt_private.ACPIBASE + 0x30        /* SMI Control and Enable Register */
+
+#define TCO_RLD         TCOBASE + 0x00  /* TCO Timer Reload and Current Value */
+#define TCOv1_TMR       TCOBASE + 0x01  /* TCOv1 Timer Initial Value    */
+#define TCO_DAT_IN      TCOBASE + 0x02  /* TCO Data In Register         */
+#define TCO_DAT_OUT     TCOBASE + 0x03  /* TCO Data Out Register        */
+#define TCO1_STS        TCOBASE + 0x04  /* TCO1 Status Register         */
+#define TCO2_STS        TCOBASE + 0x06  /* TCO2 Status Register         */
+#define TCO1_CNT        TCOBASE + 0x08  /* TCO1 Control Register        */
+#define TCO2_CNT        TCOBASE + 0x0a  /* TCO2 Control Register        */
+#define TCOv2_TMR       TCOBASE + 0x12  /* TCOv2 Timer Initial Value    */
+
+/* internal variables */
+static unsigned long is_active;
+static char expect_release;
+static struct {                         /* this is private data for the iTCO_wdt device */
+        unsigned int iTCO_version;      /* TCO version/generation */
+        unsigned long ACPIBASE;         /* The cards ACPIBASE address (TCOBASE = ACPIBASE+0x60) */
+        unsigned long __iomem *gcs;     /* NO_REBOOT flag is Memory-Mapped GCS register bit 5 (TCO version 2) */
+        spinlock_t io_lock;             /* the lock for io operations */
+        struct pci_dev *pdev;           /* the PCI-device */
+} iTCO_wdt_private;
+
+static struct platform_device *iTCO_wdt_platform_device;        /* the watchdog platform device */
+
+/* module parameters */
+#define WATCHDOG_HEARTBEAT 30   /* 30 sec default heartbeat */
+static int heartbeat = WATCHDOG_HEARTBEAT;  /* in seconds */
+module_param(heartbeat, int, 0);
+MODULE_PARM_DESC(heartbeat, "Watchdog heartbeat in seconds. (2<heartbeat<39 (TCO v1) or 613 (TCO v2), default=" __MODULE_STRING(WATCHDOG_HEARTBEAT) ")");
+
+static int nowayout = WATCHDOG_NOWAYOUT;
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
+
+/* iTCO Vendor Specific Support hooks */
+#ifdef CONFIG_ITCO_VENDOR_SUPPORT
+extern void iTCO_vendor_pre_start(unsigned long, unsigned int);
+extern void iTCO_vendor_pre_stop(unsigned long);
+extern void iTCO_vendor_pre_keepalive(unsigned long, unsigned int);
+extern void iTCO_vendor_pre_set_heartbeat(unsigned int);
+extern int iTCO_vendor_check_noreboot_on(void);
+#else
+#define iTCO_vendor_pre_start(acpibase, heartbeat)      {}
+#define iTCO_vendor_pre_stop(acpibase)                  {}
+#define iTCO_vendor_pre_keepalive(acpibase,heartbeat)   {}
+#define iTCO_vendor_pre_set_heartbeat(heartbeat)        {}
+#define iTCO_vendor_check_noreboot_on()                 1       /* 1=check noreboot; 0=don't check */
+#endif
+
+/*
+ * Some TCO specific functions
+ */
+
+static inline unsigned int seconds_to_ticks(int seconds)
+{
+        /* the internal timer is stored as ticks which decrement
+         * every 0.6 seconds */
+        return (seconds * 10) / 6;
+}
+
+static void iTCO_wdt_set_NO_REBOOT_bit(void)
+{
+        u32 val32;
+
+        /* Set the NO_REBOOT bit: this disables reboots */
+        if (iTCO_wdt_private.iTCO_version == 2) {
+                val32 = readl(iTCO_wdt_private.gcs);
+                val32 |= 0x00000020;
+                writel(val32, iTCO_wdt_private.gcs);
+        } else if (iTCO_wdt_private.iTCO_version == 1) {
+                pci_read_config_dword(iTCO_wdt_private.pdev, 0xd4, &val32);
+                val32 |= 0x00000002;
+                pci_write_config_dword(iTCO_wdt_private.pdev, 0xd4, val32);
+        }
+}
+
+static int iTCO_wdt_unset_NO_REBOOT_bit(void)
+{
+        int ret = 0;
+        u32 val32;
+
+        /* Unset the NO_REBOOT bit: this enables reboots */
+        if (iTCO_wdt_private.iTCO_version == 2) {
+                val32 = readl(iTCO_wdt_private.gcs);
+                val32 &= 0xffffffdf;
+                writel(val32, iTCO_wdt_private.gcs);
+
+                val32 = readl(iTCO_wdt_private.gcs);
+                if (val32 & 0x00000020)
+                        ret = -EIO;
+        } else if (iTCO_wdt_private.iTCO_version == 1) {
+                pci_read_config_dword(iTCO_wdt_private.pdev, 0xd4, &val32);
+                val32 &= 0xfffffffd;
+                pci_write_config_dword(iTCO_wdt_private.pdev, 0xd4, val32);
+
+                pci_read_config_dword(iTCO_wdt_private.pdev, 0xd4, &val32);
+                if (val32 & 0x00000002)
+                        ret = -EIO;
+        }
+
+        return ret; /* returns: 0 = OK, -EIO = Error */
+}
+
+static int iTCO_wdt_start(void)
+{
+        unsigned int val;
+
+        spin_lock(&iTCO_wdt_private.io_lock);
+
+        iTCO_vendor_pre_start(iTCO_wdt_private.ACPIBASE, heartbeat);
+
+        /* disable chipset's NO_REBOOT bit */
+        if (iTCO_wdt_unset_NO_REBOOT_bit()) {
+                printk(KERN_ERR PFX "failed to reset NO_REBOOT flag, reboot disabled by hardware\n");
+                return -EIO;
+        }
+
+        /* Bit 11: TCO Timer Halt -> 0 = The TCO timer is enabled to count */
+        val = inw(TCO1_CNT);
+        val &= 0xf7ff;
+        outw(val, TCO1_CNT);
+        val = inw(TCO1_CNT);
+        spin_unlock(&iTCO_wdt_private.io_lock);
+
+        if (val & 0x0800)
+                return -1;
+        return 0;
+}
+
+static int iTCO_wdt_stop(void)
+{
+        unsigned int val;
+
+        spin_lock(&iTCO_wdt_private.io_lock);
+
+        iTCO_vendor_pre_stop(iTCO_wdt_private.ACPIBASE);
+
+        /* Bit 11: TCO Timer Halt -> 1 = The TCO timer is disabled */
+        val = inw(TCO1_CNT);
+        val |= 0x0800;
+        outw(val, TCO1_CNT);
+        val = inw(TCO1_CNT);
+
+        /* Set the NO_REBOOT bit to prevent later reboots, just for sure */
+        iTCO_wdt_set_NO_REBOOT_bit();
+
+        spin_unlock(&iTCO_wdt_private.io_lock);
+
+        if ((val & 0x0800) == 0)
+                return -1;
+        return 0;
+}
+
+static int iTCO_wdt_keepalive(void)
+{
+        spin_lock(&iTCO_wdt_private.io_lock);
+
+        iTCO_vendor_pre_keepalive(iTCO_wdt_private.ACPIBASE, heartbeat);
+
+        /* Reload the timer by writing to the TCO Timer Counter register */
+        if (iTCO_wdt_private.iTCO_version == 2) {
+                outw(0x01, TCO_RLD);
+        } else if (iTCO_wdt_private.iTCO_version == 1) {
+                outb(0x01, TCO_RLD);
+        }
+
+        spin_unlock(&iTCO_wdt_private.io_lock);
+        return 0;
+}
+
+static int iTCO_wdt_set_heartbeat(int t)
+{
+        unsigned int val16;
+        unsigned char val8;
+        unsigned int tmrval;
+
+        tmrval = seconds_to_ticks(t);
+        /* from the specs: */
+        /* "Values of 0h-3h are ignored and should not be attempted" */
+        if (tmrval < 0x04)
+                return -EINVAL;
+        if (((iTCO_wdt_private.iTCO_version == 2) && (tmrval > 0x3ff)) ||
+            ((iTCO_wdt_private.iTCO_version == 1) && (tmrval > 0x03f)))
+                return -EINVAL;
+
+        iTCO_vendor_pre_set_heartbeat(tmrval);
+
+        /* Write new heartbeat to watchdog */
+        if (iTCO_wdt_private.iTCO_version == 2) {
+                spin_lock(&iTCO_wdt_private.io_lock);
+                val16 = inw(TCOv2_TMR);
+                val16 &= 0xfc00;
+                val16 |= tmrval;
+                outw(val16, TCOv2_TMR);
+                val16 = inw(TCOv2_TMR);
+                spin_unlock(&iTCO_wdt_private.io_lock);
+
+                if ((val16 & 0x3ff) != tmrval)
+                        return -EINVAL;
+        } else if (iTCO_wdt_private.iTCO_version == 1) {
+                spin_lock(&iTCO_wdt_private.io_lock);
+                val8 = inb(TCOv1_TMR);
+                val8 &= 0xc0;
+                val8 |= (tmrval & 0xff);
+                outb(val8, TCOv1_TMR);
+                val8 = inb(TCOv1_TMR);
+                spin_unlock(&iTCO_wdt_private.io_lock);
+
+                if ((val8 & 0x3f) != tmrval)
+                        return -EINVAL;
+        }
+
+        heartbeat = t;
+        return 0;
+}
+
+static int iTCO_wdt_get_timeleft (int *time_left)
+{
+        unsigned int val16;
+        unsigned char val8;
+
+        /* read the TCO Timer */
+        if (iTCO_wdt_private.iTCO_version == 2) {
+                spin_lock(&iTCO_wdt_private.io_lock);
+                val16 = inw(TCO_RLD);
+                val16 &= 0x3ff;
+                spin_unlock(&iTCO_wdt_private.io_lock);
+
+                *time_left = (val16 * 6) / 10;
+        } else if (iTCO_wdt_private.iTCO_version == 1) {
+                spin_lock(&iTCO_wdt_private.io_lock);
+                val8 = inb(TCO_RLD);
+                val8 &= 0x3f;
+                spin_unlock(&iTCO_wdt_private.io_lock);
+
+                *time_left = (val8 * 6) / 10;
+        } else
+                return -EINVAL;
+        return 0;
+}
+
+/*
+ *      /dev/watchdog handling
+ */
+
+static int iTCO_wdt_open (struct inode *inode, struct file *file)
+{
+        /* /dev/watchdog can only be opened once */
+        if (test_and_set_bit(0, &is_active))
+                return -EBUSY;
+
+        /*
+         *      Reload and activate timer
+         */
+        iTCO_wdt_keepalive();
+        iTCO_wdt_start();
+        return nonseekable_open(inode, file);
+}
+
+static int iTCO_wdt_release (struct inode *inode, struct file *file)
+{
+        /*
+         *      Shut off the timer.
+         */
+        if (expect_release == 42) {
+                iTCO_wdt_stop();
+        } else {
+                printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");
+                iTCO_wdt_keepalive();
+        }
+        clear_bit(0, &is_active);
+        expect_release = 0;
+        return 0;
+}
+
+static ssize_t iTCO_wdt_write (struct file *file, const char __user *data,
+                              size_t len, loff_t * ppos)
+{
+        /* See if we got the magic character 'V' and reload the timer */
+        if (len) {
+                if (!nowayout) {
+                        size_t i;
+
+                        /* note: just in case someone wrote the magic character
+                         * five months ago... */
+                        expect_release = 0;
+
+                        /* scan to see whether or not we got the magic character */
+                        for (i = 0; i != len; i++) {
+                                char c;
+                                if (get_user(c, data+i))
+                                        return -EFAULT;
+                                if (c == 'V')
+                                        expect_release = 42;
+                        }
+                }
+
+                /* someone wrote to us, we should reload the timer */
+                iTCO_wdt_keepalive();
+        }
+        return len;
+}
+
+static int iTCO_wdt_ioctl (struct inode *inode, struct file *file,
+                          unsigned int cmd, unsigned long arg)
+{
+        int new_options, retval = -EINVAL;
+        int new_heartbeat;
+        void __user *argp = (void __user *)arg;
+        int __user *p = argp;
+        static struct watchdog_info ident = {
+                .options =              WDIOF_SETTIMEOUT |
+                                        WDIOF_KEEPALIVEPING |
+                                        WDIOF_MAGICCLOSE,
+                .firmware_version =     0,
+                .identity =             DRV_NAME,
+        };
+
+        switch (cmd) {
+                case WDIOC_GETSUPPORT:
+                        return copy_to_user(argp, &ident,
+                                sizeof (ident)) ? -EFAULT : 0;
+
+                case WDIOC_GETSTATUS:
+                case WDIOC_GETBOOTSTATUS:
+                        return put_user(0, p);
+
+                case WDIOC_KEEPALIVE:
+                        iTCO_wdt_keepalive();
+                        return 0;
+
+                case WDIOC_SETOPTIONS:
+                {
+                        if (get_user(new_options, p))
+                                return -EFAULT;
+
+                        if (new_options & WDIOS_DISABLECARD) {
+                                iTCO_wdt_stop();
+                                retval = 0;
+                        }
+
+                        if (new_options & WDIOS_ENABLECARD) {
+                                iTCO_wdt_keepalive();
+                                iTCO_wdt_start();
+                                retval = 0;
+                        }
+
+                        return retval;
+                }
+
+                case WDIOC_SETTIMEOUT:
+                {
+                        if (get_user(new_heartbeat, p))
+                                return -EFAULT;
+
+                        if (iTCO_wdt_set_heartbeat(new_heartbeat))
+                                return -EINVAL;
+
+                        iTCO_wdt_keepalive();
+                        /* Fall */
+                }
+
+                case WDIOC_GETTIMEOUT:
+                        return put_user(heartbeat, p);
+
+                case WDIOC_GETTIMELEFT:
+                {
+                        int time_left;
+
+                        if (iTCO_wdt_get_timeleft(&time_left))
+                                return -EINVAL;
+
+                        return put_user(time_left, p);
+                }
+
+                default:
+                        return -ENOTTY;
+        }
+}
+
+/*
+ *      Kernel Interfaces
+ */
+
+static struct file_operations iTCO_wdt_fops = {
+        .owner =        THIS_MODULE,
+        .llseek =       no_llseek,
+        .write =        iTCO_wdt_write,
+        .ioctl =        iTCO_wdt_ioctl,
+        .open =         iTCO_wdt_open,
+        .release =      iTCO_wdt_release,
+};
+
+static struct miscdevice iTCO_wdt_miscdev = {
+        .minor =        WATCHDOG_MINOR,
+        .name =         "watchdog",
+        .fops =         &iTCO_wdt_fops,
+};
+
+/*
+ *      Init & exit routines
+ */
+
+static int iTCO_wdt_init(struct pci_dev *pdev, const struct pci_device_id *ent, struct platform_device *dev)
+{
+        int ret;
+        u32 base_address;
+        unsigned long RCBA;
+        unsigned long val32;
+
+        /*
+         *      Find the ACPI/PM base I/O address which is the base
+         *      for the TCO registers (TCOBASE=ACPIBASE + 0x60)
+         *      ACPIBASE is bits [15:7] from 0x40-0x43
+         */
+        pci_read_config_dword(pdev, 0x40, &base_address);
+        base_address &= 0x00007f80;
+        if (base_address == 0x00000000) {
+                /* Something's wrong here, ACPIBASE has to be set */
+                printk(KERN_ERR PFX "failed to get TCOBASE address\n");
+                pci_dev_put(pdev);
+                return -ENODEV;
+        }
+        iTCO_wdt_private.iTCO_version = iTCO_chipset_info[ent->driver_data].iTCO_version;
+        iTCO_wdt_private.ACPIBASE = base_address;
+        iTCO_wdt_private.pdev = pdev;
+
+        /* Get the Memory-Mapped GCS register, we need it for the NO_REBOOT flag (TCO v2) */
+        /* To get access to it you have to read RCBA from PCI Config space 0xf0
+           and use it as base. GCS = RCBA + ICH6_GCS(0x3410). */
+        if (iTCO_wdt_private.iTCO_version == 2) {
+                pci_read_config_dword(pdev, 0xf0, &base_address);
+                RCBA = base_address & 0xffffc000;
+                iTCO_wdt_private.gcs = ioremap((RCBA + 0x3410),4);
+        }
+
+        /* Check chipset's NO_REBOOT bit */
+        if (iTCO_wdt_unset_NO_REBOOT_bit() && iTCO_vendor_check_noreboot_on()) {
+                printk(KERN_ERR PFX "failed to reset NO_REBOOT flag, reboot disabled by hardware\n");
+                ret = -ENODEV;  /* Cannot reset NO_REBOOT bit */
+                goto out;
+        }
+
+        /* Set the NO_REBOOT bit to prevent later reboots, just for sure */
+        iTCO_wdt_set_NO_REBOOT_bit();
+
+        /* Set the TCO_EN bit in SMI_EN register */
+        if (!request_region(SMI_EN, 4, "iTCO_wdt")) {
+                printk(KERN_ERR PFX "I/O address 0x%04lx already in use\n",
+                        SMI_EN );
+                ret = -EIO;
+                goto out;
+        }
+        val32 = inl(SMI_EN);
+        val32 &= 0xffffdfff;    /* Turn off SMI clearing watchdog */
+        outl(val32, SMI_EN);
+        release_region(SMI_EN, 4);
+
+        /* The TCO I/O registers reside in a 32-byte range pointed to by the TCOBASE value */
+        if (!request_region (TCOBASE, 0x20, "iTCO_wdt")) {
+                printk (KERN_ERR PFX "I/O address 0x%04lx already in use\n",
+                        TCOBASE);
+                ret = -EIO;
+                goto out;
+        }
+
+        printk(KERN_INFO PFX "Found a %s TCO device (Version=%d, TCOBASE=0x%04lx)\n",
+                iTCO_chipset_info[ent->driver_data].name,
+                iTCO_chipset_info[ent->driver_data].iTCO_version,
+                TCOBASE);
+
+        /* Clear out the (probably old) status */
+        outb(0, TCO1_STS);
+        outb(3, TCO2_STS);
+
+        /* Make sure the watchdog is not running */
+        iTCO_wdt_stop();
+
+        /* Check that the heartbeat value is within it's range ; if not reset to the default */
+        if (iTCO_wdt_set_heartbeat(heartbeat)) {
+                iTCO_wdt_set_heartbeat(WATCHDOG_HEARTBEAT);
+                printk(KERN_INFO PFX "heartbeat value must be 2<heartbeat<39 (TCO v1) or 613 (TCO v2), using %d\n",
+                        heartbeat);
+        }
+
+        ret = misc_register(&iTCO_wdt_miscdev);
+        if (ret != 0) {
+                printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
+                        WATCHDOG_MINOR, ret);
+                goto unreg_region;
+        }
+
+        printk (KERN_INFO PFX "initialized. heartbeat=%d sec (nowayout=%d)\n",
+                heartbeat, nowayout);
+
+        return 0;
+
+unreg_region:
+        release_region (TCOBASE, 0x20);
+out:
+        if (iTCO_wdt_private.iTCO_version == 2)
+                iounmap(iTCO_wdt_private.gcs);
+        pci_dev_put(iTCO_wdt_private.pdev);
+        iTCO_wdt_private.ACPIBASE = 0;
+        return ret;
+}
+
+static void iTCO_wdt_cleanup(void)
+{
+        /* Stop the timer before we leave */
+        if (!nowayout)
+                iTCO_wdt_stop();
+
+        /* Deregister */
+        misc_deregister(&iTCO_wdt_miscdev);
+        release_region(TCOBASE, 0x20);
+        if (iTCO_wdt_private.iTCO_version == 2)
+                iounmap(iTCO_wdt_private.gcs);
+        pci_dev_put(iTCO_wdt_private.pdev);
+        iTCO_wdt_private.ACPIBASE = 0;
+}
+
+static int iTCO_wdt_probe(struct platform_device *dev)
+{
+        int found = 0;
+        struct pci_dev *pdev = NULL;
+        const struct pci_device_id *ent;
+
+        spin_lock_init(&iTCO_wdt_private.io_lock);
+
+        for_each_pci_dev(pdev) {
+                ent = pci_match_id(iTCO_wdt_pci_tbl, pdev);
+                if (ent) {
+                        if (!(iTCO_wdt_init(pdev, ent, dev))) {
+                                found++;
+                                break;
+                        }
+                }
+        }
+
+        if (!found) {
+                printk(KERN_INFO PFX "No card detected\n");
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static int iTCO_wdt_remove(struct platform_device *dev)
+{
+        if (iTCO_wdt_private.ACPIBASE)
+                iTCO_wdt_cleanup();
+
+        return 0;
+}
+
+static void iTCO_wdt_shutdown(struct platform_device *dev)
+{
+        iTCO_wdt_stop();
+}
+
+#define iTCO_wdt_suspend NULL
+#define iTCO_wdt_resume  NULL
+
+static struct platform_driver iTCO_wdt_driver = {
+        .probe          = iTCO_wdt_probe,
+        .remove         = iTCO_wdt_remove,
+        .shutdown       = iTCO_wdt_shutdown,
+        .suspend        = iTCO_wdt_suspend,
+        .resume         = iTCO_wdt_resume,
+        .driver         = {
+                .owner  = THIS_MODULE,
+                .name   = DRV_NAME,
+        },
+};
+
+static int __init iTCO_wdt_init_module(void)
+{
+        int err;
+
+        printk(KERN_INFO PFX "Intel TCO WatchDog Timer Driver v%s (%s)\n",
+                DRV_VERSION, DRV_RELDATE);
+
+        err = platform_driver_register(&iTCO_wdt_driver);
+        if (err)
+                return err;
+
+        iTCO_wdt_platform_device = platform_device_register_simple(DRV_NAME, -1, NULL, 0);
+        if (IS_ERR(iTCO_wdt_platform_device)) {
+                err = PTR_ERR(iTCO_wdt_platform_device);
+                goto unreg_platform_driver;
+        }
+
+        return 0;
+
+unreg_platform_driver:
+        platform_driver_unregister(&iTCO_wdt_driver);
+        return err;
+}
+
+static void __exit iTCO_wdt_cleanup_module(void)
+{
+        platform_device_unregister(iTCO_wdt_platform_device);
+        platform_driver_unregister(&iTCO_wdt_driver);
+        printk(KERN_INFO PFX "Watchdog Module Unloaded.\n");
+}
+
+module_init(iTCO_wdt_init_module);
+module_exit(iTCO_wdt_cleanup_module);
+
+MODULE_AUTHOR("Wim Van Sebroeck <wim@iguana.be>");
+MODULE_DESCRIPTION("Intel TCO WatchDog Timer Driver");
+MODULE_VERSION(DRV_VERSION);
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/char/watchdog/ib700wdt.c b/drivers/char/watchdog/ib700wdt.c
index fd95f7327798..c1ed209a138c 100644
--- a/drivers/char/watchdog/ib700wdt.c
+++ b/drivers/char/watchdog/ib700wdt.c
@@ -199,7 +199,7 @@ ibwdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
           break;
 
         default:
-          return -ENOIOCTLCMD;
+          return -ENOTTY;
         }
         return 0;
 }
diff --git a/drivers/char/watchdog/ibmasr.c b/drivers/char/watchdog/ibmasr.c
index 26ceee7a4df0..dd6760f1a23b 100644
--- a/drivers/char/watchdog/ibmasr.c
+++ b/drivers/char/watchdog/ibmasr.c
@@ -295,7 +295,7 @@ static int asr_ioctl(struct inode *inode, struct file *file,
                 }
         }
 
-        return -ENOIOCTLCMD;
+        return -ENOTTY;
 }
 
 static int asr_open(struct inode *inode, struct file *file)
diff --git a/drivers/char/watchdog/indydog.c b/drivers/char/watchdog/indydog.c
index dacc1c20a310..0bc239308989 100644
--- a/drivers/char/watchdog/indydog.c
+++ b/drivers/char/watchdog/indydog.c
@@ -112,7 +112,7 @@ static int indydog_ioctl(struct inode *inode, struct file *file,
 
         switch (cmd) {
                 default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
                 case WDIOC_GETSUPPORT:
                         if (copy_to_user((struct watchdog_info *)arg,
                                          &ident, sizeof(ident)))
diff --git a/drivers/char/watchdog/ixp2000_wdt.c b/drivers/char/watchdog/ixp2000_wdt.c
index 692908819e26..fd955dbd588c 100644
--- a/drivers/char/watchdog/ixp2000_wdt.c
+++ b/drivers/char/watchdog/ixp2000_wdt.c
@@ -1,5 +1,5 @@
 /*
- * drivers/watchdog/ixp2000_wdt.c
+ * drivers/char/watchdog/ixp2000_wdt.c
  *
  * Watchdog driver for Intel IXP2000 network processors
  *
@@ -107,7 +107,7 @@ static int
 ixp2000_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                         unsigned long arg)
 {
-        int ret = -ENOIOCTLCMD;
+        int ret = -ENOTTY;
         int time;
 
         switch (cmd) {
diff --git a/drivers/char/watchdog/ixp4xx_wdt.c b/drivers/char/watchdog/ixp4xx_wdt.c
index 9db5cf2c38c3..5864bb865cfe 100644
--- a/drivers/char/watchdog/ixp4xx_wdt.c
+++ b/drivers/char/watchdog/ixp4xx_wdt.c
@@ -1,5 +1,5 @@
 /*
- * drivers/watchdog/ixp4xx_wdt.c
+ * drivers/char/watchdog/ixp4xx_wdt.c
  *
  * Watchdog driver for Intel IXP4xx network processors
  *
@@ -102,7 +102,7 @@ static int
 ixp4xx_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                         unsigned long arg)
 {
-        int ret = -ENOIOCTLCMD;
+        int ret = -ENOTTY;
         int time;
 
         switch (cmd) {
diff --git a/drivers/char/watchdog/machzwd.c b/drivers/char/watchdog/machzwd.c
index 23734e07fb22..276577d08fba 100644
--- a/drivers/char/watchdog/machzwd.c
+++ b/drivers/char/watchdog/machzwd.c
@@ -329,7 +329,7 @@ static int zf_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                         break;
 
                 default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
         }
 
         return 0;
@@ -426,8 +426,7 @@ static int __init zf_init(void)
         printk(KERN_INFO PFX ": MachZ ZF-Logic Watchdog driver initializing.\n");
 
         ret = zf_get_ZFL_version();
-        printk("%#x\n", ret);
-        if((!ret) || (ret != 0xffff)){
+        if ((!ret) || (ret == 0xffff)) {
                 printk(KERN_WARNING PFX ": no ZF-Logic found\n");
                 return -ENODEV;
         }
diff --git a/drivers/char/watchdog/mixcomwd.c b/drivers/char/watchdog/mixcomwd.c
index ae943324d251..c2dac0aa1d62 100644
--- a/drivers/char/watchdog/mixcomwd.c
+++ b/drivers/char/watchdog/mixcomwd.c
@@ -185,7 +185,7 @@ static int mixcomwd_ioctl(struct inode *inode, struct file *file,
                         mixcomwd_ping();
                         break;
                 default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
         }
         return 0;
 }
diff --git a/drivers/char/watchdog/mpc83xx_wdt.c b/drivers/char/watchdog/mpc83xx_wdt.c
index a480903ee1a5..18ca752e2f90 100644
--- a/drivers/char/watchdog/mpc83xx_wdt.c
+++ b/drivers/char/watchdog/mpc83xx_wdt.c
@@ -125,7 +125,7 @@ static int mpc83xx_wdt_ioctl(struct inode *inode, struct file *file,
         case WDIOC_GETTIMEOUT:
                 return put_user(timeout_sec, p);
         default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
         }
 }
 
diff --git a/drivers/char/watchdog/mpc8xx_wdt.c b/drivers/char/watchdog/mpc8xx_wdt.c
index 35dd9e6e1140..8aaed10dd499 100644
--- a/drivers/char/watchdog/mpc8xx_wdt.c
+++ b/drivers/char/watchdog/mpc8xx_wdt.c
@@ -126,7 +126,7 @@ static int mpc8xx_wdt_ioctl(struct inode *inode, struct file *file,
                 break;
 
         default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
         }
 
         return 0;
diff --git a/drivers/char/watchdog/mpcore_wdt.c b/drivers/char/watchdog/mpcore_wdt.c
index 54b3c56ead0d..3404a9c67f08 100644
--- a/drivers/char/watchdog/mpcore_wdt.c
+++ b/drivers/char/watchdog/mpcore_wdt.c
@@ -64,7 +64,7 @@ MODULE_PARM_DESC(mpcore_noboot, "MPcore watchdog action, set to 1 to ignore rebo
  *      This is the interrupt handler.  Note that we only use this
  *      in testing mode, so don't actually do a reboot here.
  */
-static irqreturn_t mpcore_wdt_fire(int irq, void *arg, struct pt_regs *regs)
+static irqreturn_t mpcore_wdt_fire(int irq, void *arg)
 {
         struct mpcore_wdt *wdt = arg;
 
@@ -221,7 +221,7 @@ static int mpcore_wdt_ioctl(struct inode *inode, struct file *file,
         } uarg;
 
         if (_IOC_DIR(cmd) && _IOC_SIZE(cmd) > sizeof(uarg))
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
 
         if (_IOC_DIR(cmd) & _IOC_WRITE) {
                 ret = copy_from_user(&uarg, (void __user *)arg, _IOC_SIZE(cmd));
@@ -271,7 +271,7 @@ static int mpcore_wdt_ioctl(struct inode *inode, struct file *file,
                 break;
 
         default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
         }
 
         if (ret == 0 && _IOC_DIR(cmd) & _IOC_READ) {
diff --git a/drivers/char/watchdog/mv64x60_wdt.c b/drivers/char/watchdog/mv64x60_wdt.c
index 5c8fab345b40..b887cdb01334 100644
--- a/drivers/char/watchdog/mv64x60_wdt.c
+++ b/drivers/char/watchdog/mv64x60_wdt.c
@@ -160,7 +160,7 @@ static int mv64x60_wdt_ioctl(struct inode *inode, struct file *file,
                 break;
 
         default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
         }
 
         return 0;
diff --git a/drivers/char/watchdog/omap_wdt.c b/drivers/char/watchdog/omap_wdt.c
new file mode 100644
index 000000000000..5dbd7dc2936f
--- /dev/null
+++ b/drivers/char/watchdog/omap_wdt.c
@@ -0,0 +1,390 @@
+/*
+ * linux/drivers/char/watchdog/omap_wdt.c
+ *
+ * Watchdog driver for the TI OMAP 16xx & 24xx 32KHz (non-secure) watchdog
+ *
+ * Author: MontaVista Software, Inc.
+ *       <gdavis@mvista.com> or <source@mvista.com>
+ *
+ * 2003 (c) MontaVista Software, Inc. This file is licensed under the
+ * terms of the GNU General Public License version 2. This program is
+ * licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ *
+ * History:
+ *
+ * 20030527: George G. Davis <gdavis@mvista.com>
+ *      Initially based on linux-2.4.19-rmk7-pxa1/drivers/char/sa1100_wdt.c
+ *      (c) Copyright 2000 Oleg Drokin <green@crimea.edu>
+ *      Based on SoftDog driver by Alan Cox <alan@redhat.com>
+ *
+ * Copyright (c) 2004 Texas Instruments.
+ *      1. Modified to support OMAP1610 32-KHz watchdog timer
+ *      2. Ported to 2.6 kernel
+ *
+ * Copyright (c) 2005 David Brownell
+ *      Use the driver model and standard identifiers; handle bigger timeouts.
+ */
+
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include <linux/miscdevice.h>
+#include <linux/watchdog.h>
+#include <linux/reboot.h>
+#include <linux/smp_lock.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/moduleparam.h>
+#include <linux/clk.h>
+
+#include <asm/io.h>
+#include <asm/uaccess.h>
+#include <asm/hardware.h>
+#include <asm/bitops.h>
+
+#include <asm/arch/prcm.h>
+
+#include "omap_wdt.h"
+
+static unsigned timer_margin;
+module_param(timer_margin, uint, 0);
+MODULE_PARM_DESC(timer_margin, "initial watchdog timeout (in seconds)");
+
+static int omap_wdt_users;
+static struct clk *armwdt_ck = NULL;
+static struct clk *mpu_wdt_ick = NULL;
+static struct clk *mpu_wdt_fck = NULL;
+
+static unsigned int wdt_trgr_pattern = 0x1234;
+
+static void omap_wdt_ping(void)
+{
+        /* wait for posted write to complete */
+        while ((omap_readl(OMAP_WATCHDOG_WPS)) & 0x08)
+                cpu_relax();
+        wdt_trgr_pattern = ~wdt_trgr_pattern;
+        omap_writel(wdt_trgr_pattern, (OMAP_WATCHDOG_TGR));
+        /* wait for posted write to complete */
+        while ((omap_readl(OMAP_WATCHDOG_WPS)) & 0x08)
+                cpu_relax();
+        /* reloaded WCRR from WLDR */
+}
+
+static void omap_wdt_enable(void)
+{
+        /* Sequence to enable the watchdog */
+        omap_writel(0xBBBB, OMAP_WATCHDOG_SPR);
+        while ((omap_readl(OMAP_WATCHDOG_WPS)) & 0x10)
+                cpu_relax();
+        omap_writel(0x4444, OMAP_WATCHDOG_SPR);
+        while ((omap_readl(OMAP_WATCHDOG_WPS)) & 0x10)
+                cpu_relax();
+}
+
+static void omap_wdt_disable(void)
+{
+        /* sequence required to disable watchdog */
+        omap_writel(0xAAAA, OMAP_WATCHDOG_SPR); /* TIMER_MODE */
+        while (omap_readl(OMAP_WATCHDOG_WPS) & 0x10)
+                cpu_relax();
+        omap_writel(0x5555, OMAP_WATCHDOG_SPR); /* TIMER_MODE */
+        while (omap_readl(OMAP_WATCHDOG_WPS) & 0x10)
+                cpu_relax();
+}
+
+static void omap_wdt_adjust_timeout(unsigned new_timeout)
+{
+        if (new_timeout < TIMER_MARGIN_MIN)
+                new_timeout = TIMER_MARGIN_DEFAULT;
+        if (new_timeout > TIMER_MARGIN_MAX)
+                new_timeout = TIMER_MARGIN_MAX;
+        timer_margin = new_timeout;
+}
+
+static void omap_wdt_set_timeout(void)
+{
+        u32 pre_margin = GET_WLDR_VAL(timer_margin);
+
+        /* just count up at 32 KHz */
+        while (omap_readl(OMAP_WATCHDOG_WPS) & 0x04)
+                cpu_relax();
+        omap_writel(pre_margin, OMAP_WATCHDOG_LDR);
+        while (omap_readl(OMAP_WATCHDOG_WPS) & 0x04)
+                cpu_relax();
+}
+
+/*
+ *      Allow only one task to hold it open
+ */
+
+static int omap_wdt_open(struct inode *inode, struct file *file)
+{
+        if (test_and_set_bit(1, (unsigned long *)&omap_wdt_users))
+                return -EBUSY;
+
+        if (cpu_is_omap16xx())
+                clk_enable(armwdt_ck);  /* Enable the clock */
+
+        if (cpu_is_omap24xx()) {
+                clk_enable(mpu_wdt_ick);    /* Enable the interface clock */
+                clk_enable(mpu_wdt_fck);    /* Enable the functional clock */
+        }
+
+        /* initialize prescaler */
+        while (omap_readl(OMAP_WATCHDOG_WPS) & 0x01)
+                cpu_relax();
+        omap_writel((1 << 5) | (PTV << 2), OMAP_WATCHDOG_CNTRL);
+        while (omap_readl(OMAP_WATCHDOG_WPS) & 0x01)
+                cpu_relax();
+
+        omap_wdt_set_timeout();
+        omap_wdt_enable();
+        return 0;
+}
+
+static int omap_wdt_release(struct inode *inode, struct file *file)
+{
+        /*
+         *      Shut off the timer unless NOWAYOUT is defined.
+         */
+#ifndef CONFIG_WATCHDOG_NOWAYOUT
+        omap_wdt_disable();
+
+        if (cpu_is_omap16xx()) {
+                clk_disable(armwdt_ck); /* Disable the clock */
+                clk_put(armwdt_ck);
+                armwdt_ck = NULL;
+        }
+
+        if (cpu_is_omap24xx()) {
+                clk_disable(mpu_wdt_ick);       /* Disable the clock */
+                clk_disable(mpu_wdt_fck);       /* Disable the clock */
+                clk_put(mpu_wdt_ick);
+                clk_put(mpu_wdt_fck);
+                mpu_wdt_ick = NULL;
+                mpu_wdt_fck = NULL;
+        }
+#else
+        printk(KERN_CRIT "omap_wdt: Unexpected close, not stopping!\n");
+#endif
+        omap_wdt_users = 0;
+        return 0;
+}
+
+static ssize_t
+omap_wdt_write(struct file *file, const char __user *data,
+                size_t len, loff_t *ppos)
+{
+        /* Refresh LOAD_TIME. */
+        if (len)
+                omap_wdt_ping();
+        return len;
+}
+
+static int
+omap_wdt_ioctl(struct inode *inode, struct file *file,
+        unsigned int cmd, unsigned long arg)
+{
+        int new_margin;
+        static struct watchdog_info ident = {
+                .identity = "OMAP Watchdog",
+                .options = WDIOF_SETTIMEOUT,
+                .firmware_version = 0,
+        };
+
+        switch (cmd) {
+        default:
+                return -ENOIOCTLCMD;
+        case WDIOC_GETSUPPORT:
+                return copy_to_user((struct watchdog_info __user *)arg, &ident,
+                                sizeof(ident));
+        case WDIOC_GETSTATUS:
+                return put_user(0, (int __user *)arg);
+        case WDIOC_GETBOOTSTATUS:
+                if (cpu_is_omap16xx())
+                        return put_user(omap_readw(ARM_SYSST),
+                                        (int __user *)arg);
+                if (cpu_is_omap24xx())
+                        return put_user(omap_prcm_get_reset_sources(),
+                                        (int __user *)arg);
+        case WDIOC_KEEPALIVE:
+                omap_wdt_ping();
+                return 0;
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_margin, (int __user *)arg))
+                        return -EFAULT;
+                omap_wdt_adjust_timeout(new_margin);
+
+                omap_wdt_disable();
+                omap_wdt_set_timeout();
+                omap_wdt_enable();
+
+                omap_wdt_ping();
+                /* Fall */
+        case WDIOC_GETTIMEOUT:
+                return put_user(timer_margin, (int __user *)arg);
+        }
+}
+
+static struct file_operations omap_wdt_fops = {
+        .owner = THIS_MODULE,
+        .write = omap_wdt_write,
+        .ioctl = omap_wdt_ioctl,
+        .open = omap_wdt_open,
+        .release = omap_wdt_release,
+};
+
+static struct miscdevice omap_wdt_miscdev = {
+        .minor = WATCHDOG_MINOR,
+        .name = "watchdog",
+        .fops = &omap_wdt_fops
+};
+
+static int __init omap_wdt_probe(struct platform_device *pdev)
+{
+        struct resource *res, *mem;
+        int ret;
+
+        /* reserve static register mappings */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENOENT;
+
+        mem = request_mem_region(res->start, res->end - res->start + 1,
+                                 pdev->name);
+        if (mem == NULL)
+                return -EBUSY;
+
+        platform_set_drvdata(pdev, mem);
+
+        omap_wdt_users = 0;
+
+        if (cpu_is_omap16xx()) {
+                armwdt_ck = clk_get(&pdev->dev, "armwdt_ck");
+                if (IS_ERR(armwdt_ck)) {
+                        ret = PTR_ERR(armwdt_ck);
+                        armwdt_ck = NULL;
+                        goto fail;
+                }
+        }
+
+        if (cpu_is_omap24xx()) {
+                mpu_wdt_ick = clk_get(&pdev->dev, "mpu_wdt_ick");
+                if (IS_ERR(mpu_wdt_ick)) {
+                        ret = PTR_ERR(mpu_wdt_ick);
+                        mpu_wdt_ick = NULL;
+                        goto fail;
+                }
+                mpu_wdt_fck = clk_get(&pdev->dev, "mpu_wdt_fck");
+                if (IS_ERR(mpu_wdt_fck)) {
+                        ret = PTR_ERR(mpu_wdt_fck);
+                        mpu_wdt_fck = NULL;
+                        goto fail;
+                }
+        }
+
+        omap_wdt_disable();
+        omap_wdt_adjust_timeout(timer_margin);
+
+        omap_wdt_miscdev.dev = &pdev->dev;
+        ret = misc_register(&omap_wdt_miscdev);
+        if (ret)
+                goto fail;
+
+        pr_info("OMAP Watchdog Timer: initial timeout %d sec\n", timer_margin);
+
+        /* autogate OCP interface clock */
+        omap_writel(0x01, OMAP_WATCHDOG_SYS_CONFIG);
+        return 0;
+
+fail:
+        if (armwdt_ck)
+                clk_put(armwdt_ck);
+        if (mpu_wdt_ick)
+                clk_put(mpu_wdt_ick);
+        if (mpu_wdt_fck)
+                clk_put(mpu_wdt_fck);
+        release_resource(mem);
+        return ret;
+}
+
+static void omap_wdt_shutdown(struct platform_device *pdev)
+{
+        omap_wdt_disable();
+}
+
+static int omap_wdt_remove(struct platform_device *pdev)
+{
+        struct resource *mem = platform_get_drvdata(pdev);
+        misc_deregister(&omap_wdt_miscdev);
+        release_resource(mem);
+        if (armwdt_ck)
+                clk_put(armwdt_ck);
+        if (mpu_wdt_ick)
+                clk_put(mpu_wdt_ick);
+        if (mpu_wdt_fck)
+                clk_put(mpu_wdt_fck);
+        return 0;
+}
+
+#ifdef  CONFIG_PM
+
+/* REVISIT ... not clear this is the best way to handle system suspend; and
+ * it's very inappropriate for selective device suspend (e.g. suspending this
+ * through sysfs rather than by stopping the watchdog daemon).  Also, this
+ * may not play well enough with NOWAYOUT...
+ */
+
+static int omap_wdt_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        if (omap_wdt_users)
+                omap_wdt_disable();
+        return 0;
+}
+
+static int omap_wdt_resume(struct platform_device *pdev)
+{
+        if (omap_wdt_users) {
+                omap_wdt_enable();
+                omap_wdt_ping();
+        }
+        return 0;
+}
+
+#else
+#define omap_wdt_suspend        NULL
+#define omap_wdt_resume         NULL
+#endif
+
+static struct platform_driver omap_wdt_driver = {
+        .probe          = omap_wdt_probe,
+        .remove         = omap_wdt_remove,
+        .shutdown       = omap_wdt_shutdown,
+        .suspend        = omap_wdt_suspend,
+        .resume         = omap_wdt_resume,
+        .driver         = {
+                .owner  = THIS_MODULE,
+                .name   = "omap_wdt",
+        },
+};
+
+static int __init omap_wdt_init(void)
+{
+        return platform_driver_register(&omap_wdt_driver);
+}
+
+static void __exit omap_wdt_exit(void)
+{
+        platform_driver_unregister(&omap_wdt_driver);
+}
+
+module_init(omap_wdt_init);
+module_exit(omap_wdt_exit);
+
+MODULE_AUTHOR("George G. Davis");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/char/watchdog/omap_wdt.h b/drivers/char/watchdog/omap_wdt.h
new file mode 100644
index 000000000000..52a532a5114a
--- /dev/null
+++ b/drivers/char/watchdog/omap_wdt.h
@@ -0,0 +1,64 @@
+/*
+ *  linux/drivers/char/watchdog/omap_wdt.h
+ *
+ *  BRIEF MODULE DESCRIPTION
+ *      OMAP Watchdog timer register definitions
+ *
+ *  Copyright (C) 2004 Texas Instruments.
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
+ *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
+ *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
+ *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  You should have received a copy of the  GNU General Public License along
+ *  with this program; if not, write  to the Free Software Foundation, Inc.,
+ *  675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _OMAP_WATCHDOG_H
+#define _OMAP_WATCHDOG_H
+
+#define OMAP1610_WATCHDOG_BASE          0xfffeb000
+#define OMAP2420_WATCHDOG_BASE          0x48022000      /*WDT Timer 2 */
+
+#ifdef CONFIG_ARCH_OMAP24XX
+#define OMAP_WATCHDOG_BASE              OMAP2420_WATCHDOG_BASE
+#else
+#define OMAP_WATCHDOG_BASE              OMAP1610_WATCHDOG_BASE
+#define RM_RSTST_WKUP                   0
+#endif
+
+#define OMAP_WATCHDOG_REV               (OMAP_WATCHDOG_BASE + 0x00)
+#define OMAP_WATCHDOG_SYS_CONFIG        (OMAP_WATCHDOG_BASE + 0x10)
+#define OMAP_WATCHDOG_STATUS            (OMAP_WATCHDOG_BASE + 0x14)
+#define OMAP_WATCHDOG_CNTRL             (OMAP_WATCHDOG_BASE + 0x24)
+#define OMAP_WATCHDOG_CRR               (OMAP_WATCHDOG_BASE + 0x28)
+#define OMAP_WATCHDOG_LDR               (OMAP_WATCHDOG_BASE + 0x2c)
+#define OMAP_WATCHDOG_TGR               (OMAP_WATCHDOG_BASE + 0x30)
+#define OMAP_WATCHDOG_WPS               (OMAP_WATCHDOG_BASE + 0x34)
+#define OMAP_WATCHDOG_SPR               (OMAP_WATCHDOG_BASE + 0x48)
+
+/* Using the prescaler, the OMAP watchdog could go for many
+ * months before firing.  These limits work without scaling,
+ * with the 60 second default assumed by most tools and docs.
+ */
+#define TIMER_MARGIN_MAX        (24 * 60 * 60)  /* 1 day */
+#define TIMER_MARGIN_DEFAULT    60      /* 60 secs */
+#define TIMER_MARGIN_MIN        1
+
+#define PTV                     0       /* prescale */
+#define GET_WLDR_VAL(secs)      (0xffffffff - ((secs) * (32768/(1<<PTV))) + 1)
+
+#endif                          /* _OMAP_WATCHDOG_H */
diff --git a/drivers/char/watchdog/pc87413_wdt.c b/drivers/char/watchdog/pc87413_wdt.c
new file mode 100644
index 000000000000..1d447e32af41
--- /dev/null
+++ b/drivers/char/watchdog/pc87413_wdt.c
@@ -0,0 +1,635 @@
+/*
+ *      NS pc87413-wdt Watchdog Timer driver for Linux 2.6.x.x
+ *
+ *      This code is based on wdt.c with original copyright.
+ *
+ *      (C) Copyright 2006 Sven Anders, <anders@anduras.de>
+ *                     and Marcus Junker, <junker@anduras.de>
+ *
+ *      This program is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU General Public License
+ *      as published by the Free Software Foundation; either version
+ *      2 of the License, or (at your option) any later version.
+ *
+ *      Neither Sven Anders, Marcus Junker nor ANDURAS AG
+ *      admit liability nor provide warranty for any of this software.
+ *      This material is provided "AS-IS" and at no charge.
+ *
+ *      Release 1.1
+ */
+
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/miscdevice.h>
+#include <linux/watchdog.h>
+#include <linux/ioport.h>
+#include <linux/delay.h>
+#include <linux/notifier.h>
+#include <linux/fs.h>
+#include <linux/reboot.h>
+#include <linux/init.h>
+#include <linux/spinlock.h>
+#include <linux/moduleparam.h>
+#include <linux/version.h>
+
+#include <asm/io.h>
+#include <asm/uaccess.h>
+#include <asm/system.h>
+
+/* #define DEBUG 1 */
+
+#define DEFAULT_TIMEOUT     1            /* 1 minute */
+#define MAX_TIMEOUT         255
+
+#define VERSION             "1.1"
+#define MODNAME             "pc87413 WDT"
+#define PFX                 MODNAME ": "
+#define DPFX                MODNAME " - DEBUG: "
+
+#define WDT_INDEX_IO_PORT   (io+0)       /* I/O port base (index register) */
+#define WDT_DATA_IO_PORT    (WDT_INDEX_IO_PORT+1)
+#define SWC_LDN             0x04
+#define SIOCFG2             0x22         /* Serial IO register */
+#define WDCTL               0x10         /* Watchdog-Timer-Controll-Register */
+#define WDTO                0x11         /* Watchdog timeout register */
+#define WDCFG               0x12         /* Watchdog config register */
+
+static int io = 0x2E;                    /* Address used on Portwell Boards */
+
+static int timeout = DEFAULT_TIMEOUT;    /* timeout value */
+static unsigned long timer_enabled = 0;  /* is the timer enabled? */
+
+static char expect_close;                /* is the close expected? */
+
+static spinlock_t io_lock;               /* to guard the watchdog from io races */
+
+static int nowayout = WATCHDOG_NOWAYOUT;
+
+/* -- Low level function ----------------------------------------*/
+
+/* Select pins for Watchdog output */
+
+static inline void pc87413_select_wdt_out (void)
+{
+        unsigned int cr_data = 0;
+
+        /* Step 1: Select multiple pin,pin55,as WDT output */
+
+        outb_p(SIOCFG2, WDT_INDEX_IO_PORT);
+
+        cr_data = inb (WDT_DATA_IO_PORT);
+
+        cr_data |= 0x80; /* Set Bit7 to 1*/
+        outb_p(SIOCFG2, WDT_INDEX_IO_PORT);
+
+        outb_p(cr_data, WDT_DATA_IO_PORT);
+
+#ifdef DEBUG
+        printk(KERN_INFO DPFX "Select multiple pin,pin55,as WDT output:"
+                              " Bit7 to 1: %d\n", cr_data);
+#endif
+}
+
+/* Enable SWC functions */
+
+static inline void pc87413_enable_swc(void)
+{
+        unsigned int cr_data=0;
+
+        /* Step 2: Enable SWC functions */
+
+        outb_p(0x07, WDT_INDEX_IO_PORT);        /* Point SWC_LDN (LDN=4) */
+        outb_p(SWC_LDN, WDT_DATA_IO_PORT);
+
+        outb_p(0x30, WDT_INDEX_IO_PORT);        /* Read Index 0x30 First */
+        cr_data = inb(WDT_DATA_IO_PORT);
+        cr_data |= 0x01;                        /* Set Bit0 to 1 */
+        outb_p(0x30, WDT_INDEX_IO_PORT);
+        outb_p(cr_data, WDT_DATA_IO_PORT);      /* Index0x30_bit0P1 */
+
+#ifdef DEBUG
+        printk(KERN_INFO DPFX "pc87413 - Enable SWC functions\n");
+#endif
+}
+
+/* Read SWC I/O base address */
+
+static inline unsigned int pc87413_get_swc_base(void)
+{
+        unsigned int  swc_base_addr = 0;
+        unsigned char addr_l, addr_h = 0;
+
+        /* Step 3: Read SWC I/O Base Address */
+
+        outb_p(0x60, WDT_INDEX_IO_PORT);        /* Read Index 0x60 */
+        addr_h = inb(WDT_DATA_IO_PORT);
+
+        outb_p(0x61, WDT_INDEX_IO_PORT);        /* Read Index 0x61 */
+
+        addr_l = inb(WDT_DATA_IO_PORT);
+
+        swc_base_addr = (addr_h << 8) + addr_l;
+
+#ifdef DEBUG
+        printk(KERN_INFO DPFX "Read SWC I/O Base Address: low %d, high %d,"
+                              " res %d\n", addr_l, addr_h, swc_base_addr);
+#endif
+
+        return swc_base_addr;
+}
+
+/* Select Bank 3 of SWC */
+
+static inline void pc87413_swc_bank3(unsigned int swc_base_addr)
+{
+        /* Step 4: Select Bank3 of SWC */
+
+        outb_p(inb(swc_base_addr + 0x0f) | 0x03, swc_base_addr + 0x0f);
+
+#ifdef DEBUG
+        printk(KERN_INFO DPFX "Select Bank3 of SWC\n");
+#endif
+}
+
+/* Set watchdog timeout to x minutes */
+
+static inline void pc87413_programm_wdto(unsigned int swc_base_addr,
+                                         char pc87413_time)
+{
+        /* Step 5: Programm WDTO, Twd. */
+
+        outb_p(pc87413_time, swc_base_addr + WDTO);
+
+#ifdef DEBUG
+        printk(KERN_INFO DPFX "Set WDTO to %d minutes\n", pc87413_time);
+#endif
+}
+
+/* Enable WDEN */
+
+static inline void pc87413_enable_wden(unsigned int swc_base_addr)
+{
+        /* Step 6: Enable WDEN */
+
+        outb_p(inb (swc_base_addr + WDCTL) | 0x01, swc_base_addr + WDCTL);
+
+#ifdef DEBUG
+        printk(KERN_INFO DPFX "Enable WDEN\n");
+#endif
+}
+
+/* Enable SW_WD_TREN */
+static inline void pc87413_enable_sw_wd_tren(unsigned int swc_base_addr)
+{
+        /* Enable SW_WD_TREN */
+
+        outb_p(inb (swc_base_addr + WDCFG) | 0x80, swc_base_addr + WDCFG);
+
+#ifdef DEBUG
+        printk(KERN_INFO DPFX "Enable SW_WD_TREN\n");
+#endif
+}
+
+/* Disable SW_WD_TREN */
+
+static inline void pc87413_disable_sw_wd_tren(unsigned int swc_base_addr)
+{
+        /* Disable SW_WD_TREN */
+
+        outb_p(inb (swc_base_addr + WDCFG) & 0x7f, swc_base_addr + WDCFG);
+
+#ifdef DEBUG
+        printk(KERN_INFO DPFX "pc87413 - Disable SW_WD_TREN\n");
+#endif
+}
+
+/* Enable SW_WD_TRG */
+
+static inline void pc87413_enable_sw_wd_trg(unsigned int swc_base_addr)
+{
+        /* Enable SW_WD_TRG */
+
+        outb_p(inb (swc_base_addr + WDCTL) | 0x80, swc_base_addr + WDCTL);
+
+#ifdef DEBUG
+        printk(KERN_INFO DPFX "pc87413 - Enable SW_WD_TRG\n");
+#endif
+}
+
+/* Disable SW_WD_TRG */
+
+static inline void pc87413_disable_sw_wd_trg(unsigned int swc_base_addr)
+{
+        /* Disable SW_WD_TRG */
+
+        outb_p(inb (swc_base_addr + WDCTL) & 0x7f, swc_base_addr + WDCTL);
+
+#ifdef DEBUG
+        printk(KERN_INFO DPFX "Disable SW_WD_TRG\n");
+#endif
+}
+
+/* -- Higher level functions ------------------------------------*/
+
+/* Enable the watchdog */
+
+static void pc87413_enable(void)
+{
+        unsigned int swc_base_addr;
+
+        spin_lock(&io_lock);
+
+        pc87413_select_wdt_out();
+        pc87413_enable_swc();
+        swc_base_addr = pc87413_get_swc_base();
+        pc87413_swc_bank3(swc_base_addr);
+        pc87413_programm_wdto(swc_base_addr, timeout);
+        pc87413_enable_wden(swc_base_addr);
+        pc87413_enable_sw_wd_tren(swc_base_addr);
+        pc87413_enable_sw_wd_trg(swc_base_addr);
+
+        spin_unlock(&io_lock);
+}
+
+/* Disable the watchdog */
+
+static void pc87413_disable(void)
+{
+        unsigned int swc_base_addr;
+
+        spin_lock(&io_lock);
+
+        pc87413_select_wdt_out();
+        pc87413_enable_swc();
+        swc_base_addr = pc87413_get_swc_base();
+        pc87413_swc_bank3(swc_base_addr);
+        pc87413_disable_sw_wd_tren(swc_base_addr);
+        pc87413_disable_sw_wd_trg(swc_base_addr);
+        pc87413_programm_wdto(swc_base_addr, 0);
+
+        spin_unlock(&io_lock);
+}
+
+/* Refresh the watchdog */
+
+static void pc87413_refresh(void)
+{
+        unsigned int swc_base_addr;
+
+        spin_lock(&io_lock);
+
+        pc87413_select_wdt_out();
+        pc87413_enable_swc();
+        swc_base_addr = pc87413_get_swc_base();
+        pc87413_swc_bank3(swc_base_addr);
+        pc87413_disable_sw_wd_tren(swc_base_addr);
+        pc87413_disable_sw_wd_trg(swc_base_addr);
+        pc87413_programm_wdto(swc_base_addr, timeout);
+        pc87413_enable_wden(swc_base_addr);
+        pc87413_enable_sw_wd_tren(swc_base_addr);
+        pc87413_enable_sw_wd_trg(swc_base_addr);
+
+        spin_unlock(&io_lock);
+}
+
+/* -- File operations -------------------------------------------*/
+
+/**
+ *      pc87413_open:
+ *      @inode: inode of device
+ *      @file: file handle to device
+ *
+ */
+
+static int pc87413_open(struct inode *inode, struct file *file)
+{
+        /* /dev/watchdog can only be opened once */
+
+        if (test_and_set_bit(0, &timer_enabled))
+                return -EBUSY;
+
+        if (nowayout)
+                __module_get(THIS_MODULE);
+
+        /* Reload and activate timer */
+        pc87413_refresh();
+
+        printk(KERN_INFO MODNAME "Watchdog enabled. Timeout set to"
+                                 " %d minute(s).\n", timeout);
+
+        return nonseekable_open(inode, file);
+}
+
+/**
+ *      pc87413_release:
+ *      @inode: inode to board
+ *      @file: file handle to board
+ *
+ *      The watchdog has a configurable API. There is a religious dispute
+ *      between people who want their watchdog to be able to shut down and
+ *      those who want to be sure if the watchdog manager dies the machine
+ *      reboots. In the former case we disable the counters, in the latter
+ *      case you have to open it again very soon.
+ */
+
+static int pc87413_release(struct inode *inode, struct file *file)
+{
+        /* Shut off the timer. */
+
+        if (expect_close == 42) {
+                pc87413_disable();
+                printk(KERN_INFO MODNAME "Watchdog disabled,"
+                                         " sleeping again...\n");
+        } else {
+                printk(KERN_CRIT MODNAME "Unexpected close, not stopping"
+                                         " watchdog!\n");
+                pc87413_refresh();
+        }
+
+        clear_bit(0, &timer_enabled);
+        expect_close = 0;
+
+        return 0;
+}
+
+/**
+ *      pc87413_status:
+ *
+ *      return, if the watchdog is enabled (timeout is set...)
+ */
+
+
+static int pc87413_status(void)
+{
+          return 0; /* currently not supported */
+}
+
+/**
+ *      pc87413_write:
+ *      @file: file handle to the watchdog
+ *      @data: data buffer to write
+ *      @len: length in bytes
+ *      @ppos: pointer to the position to write. No seeks allowed
+ *
+ *      A write to a watchdog device is defined as a keepalive signal. Any
+ *      write of data will do, as we we don't define content meaning.
+ */
+
+static ssize_t pc87413_write(struct file *file, const char __user *data,
+                             size_t len, loff_t *ppos)
+{
+        /* See if we got the magic character 'V' and reload the timer */
+        if (len) {
+                if (!nowayout) {
+                        size_t i;
+
+                        /* reset expect flag */
+                        expect_close = 0;
+
+                        /* scan to see whether or not we got the magic character */
+                        for (i = 0; i != len; i++) {
+                                char c;
+                                if (get_user(c, data+i))
+                                        return -EFAULT;
+                                if (c == 'V')
+                                        expect_close = 42;
+                        }
+                }
+
+                /* someone wrote to us, we should reload the timer */
+                pc87413_refresh();
+        }
+        return len;
+}
+
+/**
+ *      pc87413_ioctl:
+ *      @inode: inode of the device
+ *      @file: file handle to the device
+ *      @cmd: watchdog command
+ *      @arg: argument pointer
+ *
+ *      The watchdog API defines a common set of functions for all watchdogs
+ *      according to their available features. We only actually usefully support
+ *      querying capabilities and current status.
+ */
+
+static int pc87413_ioctl(struct inode *inode, struct file *file,
+                         unsigned int cmd, unsigned long arg)
+{
+        int new_timeout;
+
+        union {
+                struct watchdog_info __user *ident;
+                int __user *i;
+        } uarg;
+
+        static struct watchdog_info ident = {
+                .options          = WDIOF_KEEPALIVEPING |
+                                    WDIOF_SETTIMEOUT |
+                                    WDIOF_MAGICCLOSE,
+                .firmware_version = 1,
+                .identity         = "PC87413(HF/F) watchdog"
+        };
+
+        uarg.i = (int __user *)arg;
+
+        switch(cmd) {
+                default:
+                        return -ENOTTY;
+
+                case WDIOC_GETSUPPORT:
+                        return copy_to_user(uarg.ident, &ident,
+                                sizeof(ident)) ? -EFAULT : 0;
+
+                case WDIOC_GETSTATUS:
+                        return put_user(pc87413_status(), uarg.i);
+
+                case WDIOC_GETBOOTSTATUS:
+                        return put_user(0, uarg.i);
+
+                case WDIOC_KEEPALIVE:
+                        pc87413_refresh();
+#ifdef DEBUG
+                        printk(KERN_INFO DPFX "keepalive\n");
+#endif
+                        return 0;
+
+                case WDIOC_SETTIMEOUT:
+                        if (get_user(new_timeout, uarg.i))
+                                return -EFAULT;
+
+                        // the API states this is given in secs
+                        new_timeout /= 60;
+
+                        if (new_timeout < 0 || new_timeout > MAX_TIMEOUT)
+                                return -EINVAL;
+
+                        timeout = new_timeout;
+                        pc87413_refresh();
+
+                        // fall through and return the new timeout...
+
+                case WDIOC_GETTIMEOUT:
+
+                        new_timeout = timeout * 60;
+
+                        return put_user(new_timeout, uarg.i);
+
+                case WDIOC_SETOPTIONS:
+                {
+                        int options, retval = -EINVAL;
+
+                        if (get_user(options, uarg.i))
+                                return -EFAULT;
+
+                        if (options & WDIOS_DISABLECARD) {
+                                pc87413_disable();
+                                retval = 0;
+                        }
+
+                        if (options & WDIOS_ENABLECARD) {
+                                pc87413_enable();
+                                retval = 0;
+                        }
+
+                        return retval;
+                }
+        }
+}
+
+/* -- Notifier funtions -----------------------------------------*/
+
+/**
+ *      notify_sys:
+ *      @this: our notifier block
+ *      @code: the event being reported
+ *      @unused: unused
+ *
+ *      Our notifier is called on system shutdowns. We want to turn the card
+ *      off at reboot otherwise the machine will reboot again during memory
+ *      test or worse yet during the following fsck. This would suck, in fact
+ *      trust me - if it happens it does suck.
+ */
+
+static int pc87413_notify_sys(struct notifier_block *this,
+                              unsigned long code,
+                              void *unused)
+{
+        if (code == SYS_DOWN || code == SYS_HALT)
+        {
+                /* Turn the card off */
+                pc87413_disable();
+        }
+        return NOTIFY_DONE;
+}
+
+/* -- Module's structures ---------------------------------------*/
+
+static struct file_operations pc87413_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .write          = pc87413_write,
+        .ioctl          = pc87413_ioctl,
+        .open           = pc87413_open,
+        .release        = pc87413_release,
+};
+
+static struct notifier_block pc87413_notifier =
+{
+        .notifier_call  = pc87413_notify_sys,
+};
+
+static struct miscdevice pc87413_miscdev=
+{
+        .minor          = WATCHDOG_MINOR,
+        .name           = "watchdog",
+        .fops           = &pc87413_fops
+};
+
+/* -- Module init functions -------------------------------------*/
+
+/**
+ *      pc87413_init: module's "constructor"
+ *
+ *      Set up the WDT watchdog board. All we have to do is grab the
+ *      resources we require and bitch if anyone beat us to them.
+ *      The open() function will actually kick the board off.
+ */
+
+static int __init pc87413_init(void)
+{
+        int ret;
+
+        spin_lock_init(&io_lock);
+
+        printk(KERN_INFO PFX "Version " VERSION " at io 0x%X\n", WDT_INDEX_IO_PORT);
+
+        /* request_region(io, 2, "pc87413"); */
+
+        ret = register_reboot_notifier(&pc87413_notifier);
+        if (ret != 0) {
+                printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
+                        ret);
+        }
+
+        ret = misc_register(&pc87413_miscdev);
+
+        if (ret != 0) {
+                printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
+                        WATCHDOG_MINOR, ret);
+                unregister_reboot_notifier(&pc87413_notifier);
+                return ret;
+        }
+
+        printk(KERN_INFO PFX "initialized. timeout=%d min \n", timeout);
+
+        pc87413_enable();
+
+        return 0;
+}
+
+/**
+ *      pc87413_exit: module's "destructor"
+ *
+ *      Unload the watchdog. You cannot do this with any file handles open.
+ *      If your watchdog is set to continue ticking on close and you unload
+ *      it, well it keeps ticking. We won't get the interrupt but the board
+ *      will not touch PC memory so all is fine. You just have to load a new
+ *      module in 60 seconds or reboot.
+ */
+
+static void __exit pc87413_exit(void)
+{
+        /* Stop the timer before we leave */
+        if (!nowayout)
+        {
+                pc87413_disable();
+                printk(KERN_INFO MODNAME "Watchdog disabled.\n");
+        }
+
+        misc_deregister(&pc87413_miscdev);
+        unregister_reboot_notifier(&pc87413_notifier);
+        /* release_region(io,2); */
+
+        printk(MODNAME " watchdog component driver removed.\n");
+}
+
+module_init(pc87413_init);
+module_exit(pc87413_exit);
+
+MODULE_AUTHOR("Sven Anders <anders@anduras.de>, Marcus Junker <junker@anduras.de>,");
+MODULE_DESCRIPTION("PC87413 WDT driver");
+MODULE_LICENSE("GPL");
+
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
+
+module_param(io, int, 0);
+MODULE_PARM_DESC(io, MODNAME " I/O port (default: " __MODULE_STRING(io) ").");
+
+module_param(timeout, int, 0);
+MODULE_PARM_DESC(timeout, "Watchdog timeout in minutes (default=" __MODULE_STRING(timeout) ").");
+
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
+
diff --git a/drivers/char/watchdog/pcwd.c b/drivers/char/watchdog/pcwd.c
index cd7d1b6a5d9f..8e1e6e48e0a7 100644
--- a/drivers/char/watchdog/pcwd.c
+++ b/drivers/char/watchdog/pcwd.c
@@ -49,7 +49,6 @@
  *      More info available at http://www.berkprod.com/ or http://www.pcwatchdog.com/
  */
 
-#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) */
@@ -572,7 +571,7 @@ static int pcwd_ioctl(struct inode *inode, struct file *file,
 
         switch(cmd) {
         default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
 
         case WDIOC_GETSUPPORT:
                 if(copy_to_user(argp, &ident, sizeof(ident)))
diff --git a/drivers/char/watchdog/pcwd_pci.c b/drivers/char/watchdog/pcwd_pci.c
index c7cfd6dbfe1b..f4872c871063 100644
--- a/drivers/char/watchdog/pcwd_pci.c
+++ b/drivers/char/watchdog/pcwd_pci.c
@@ -31,7 +31,6 @@
  *      Includes, defines, variables, module parameters, ...
  */
 
-#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) */
@@ -541,7 +540,7 @@ static int pcipcwd_ioctl(struct inode *inode, struct file *file,
                 }
 
                 default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
         }
 }
 
diff --git a/drivers/char/watchdog/pcwd_usb.c b/drivers/char/watchdog/pcwd_usb.c
index b7ae73dcdd08..61138726b501 100644
--- a/drivers/char/watchdog/pcwd_usb.c
+++ b/drivers/char/watchdog/pcwd_usb.c
@@ -158,7 +158,7 @@ static struct usb_driver usb_pcwd_driver = {
 };
 
 
-static void usb_pcwd_intr_done(struct urb *urb, struct pt_regs *regs)
+static void usb_pcwd_intr_done(struct urb *urb)
 {
         struct usb_pcwd_private *usb_pcwd = (struct usb_pcwd_private *)urb->context;
         unsigned char *data = usb_pcwd->intr_buffer;
@@ -445,7 +445,7 @@ static int usb_pcwd_ioctl(struct inode *inode, struct file *file,
                 }
 
                 default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
         }
 }
 
@@ -561,8 +561,7 @@ static struct notifier_block usb_pcwd_notifier = {
  */
 static inline void usb_pcwd_delete (struct usb_pcwd_private *usb_pcwd)
 {
-        if (usb_pcwd->intr_urb != NULL)
-                usb_free_urb (usb_pcwd->intr_urb);
+        usb_free_urb(usb_pcwd->intr_urb);
         if (usb_pcwd->intr_buffer != NULL)
                 usb_buffer_free(usb_pcwd->udev, usb_pcwd->intr_size,
                                 usb_pcwd->intr_buffer, usb_pcwd->intr_dma);
@@ -635,7 +634,7 @@ static int usb_pcwd_probe(struct usb_interface *interface, const struct usb_devi
         usb_pcwd->intr_size = (le16_to_cpu(endpoint->wMaxPacketSize) > 8 ? le16_to_cpu(endpoint->wMaxPacketSize) : 8);
 
         /* set up the memory buffer's */
-        if (!(usb_pcwd->intr_buffer = usb_buffer_alloc(udev, usb_pcwd->intr_size, SLAB_ATOMIC, &usb_pcwd->intr_dma))) {
+        if (!(usb_pcwd->intr_buffer = usb_buffer_alloc(udev, usb_pcwd->intr_size, GFP_ATOMIC, &usb_pcwd->intr_dma))) {
                 printk(KERN_ERR PFX "Out of memory\n");
                 goto error;
         }
diff --git a/drivers/char/watchdog/pnx4008_wdt.c b/drivers/char/watchdog/pnx4008_wdt.c
new file mode 100644
index 000000000000..3a55fc6abcd8
--- /dev/null
+++ b/drivers/char/watchdog/pnx4008_wdt.c
@@ -0,0 +1,361 @@
+/*
+ * drivers/char/watchdog/pnx4008_wdt.c
+ *
+ * Watchdog driver for PNX4008 board
+ *
+ * Authors: Dmitry Chigirev <source@mvista.com>,
+ *          Vitaly Wool <vitalywool@gmail.com>
+ * Based on sa1100 driver,
+ * Copyright (C) 2000 Oleg Drokin <green@crimea.edu>
+ *
+ * 2005-2006 (c) MontaVista Software, Inc. This file is licensed under
+ * the terms of the GNU General Public License version 2. This program
+ * is licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/miscdevice.h>
+#include <linux/watchdog.h>
+#include <linux/init.h>
+#include <linux/bitops.h>
+#include <linux/ioport.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/spinlock.h>
+
+#include <asm/hardware.h>
+#include <asm/uaccess.h>
+#include <asm/io.h>
+
+#define MODULE_NAME "PNX4008-WDT: "
+
+/* WatchDog Timer - Chapter 23 Page 207 */
+
+#define DEFAULT_HEARTBEAT 19
+#define MAX_HEARTBEAT     60
+
+/* Watchdog timer register set definition */
+#define WDTIM_INT(p)     ((p) + 0x0)
+#define WDTIM_CTRL(p)    ((p) + 0x4)
+#define WDTIM_COUNTER(p) ((p) + 0x8)
+#define WDTIM_MCTRL(p)   ((p) + 0xC)
+#define WDTIM_MATCH0(p)  ((p) + 0x10)
+#define WDTIM_EMR(p)     ((p) + 0x14)
+#define WDTIM_PULSE(p)   ((p) + 0x18)
+#define WDTIM_RES(p)     ((p) + 0x1C)
+
+/* WDTIM_INT bit definitions */
+#define MATCH_INT      1
+
+/* WDTIM_CTRL bit definitions */
+#define COUNT_ENAB     1
+#define RESET_COUNT    (1<<1)
+#define DEBUG_EN       (1<<2)
+
+/* WDTIM_MCTRL bit definitions */
+#define MR0_INT        1
+#undef  RESET_COUNT0
+#define RESET_COUNT0   (1<<2)
+#define STOP_COUNT0    (1<<2)
+#define M_RES1         (1<<3)
+#define M_RES2         (1<<4)
+#define RESFRC1        (1<<5)
+#define RESFRC2        (1<<6)
+
+/* WDTIM_EMR bit definitions */
+#define EXT_MATCH0      1
+#define MATCH_OUTPUT_HIGH (2<<4)        /*a MATCH_CTRL setting */
+
+/* WDTIM_RES bit definitions */
+#define WDOG_RESET      1       /* read only */
+
+#define WDOG_COUNTER_RATE 13000000      /*the counter clock is 13 MHz fixed */
+
+static int nowayout = WATCHDOG_NOWAYOUT;
+static int heartbeat = DEFAULT_HEARTBEAT;
+
+static spinlock_t io_lock;
+static unsigned long wdt_status;
+#define WDT_IN_USE        0
+#define WDT_OK_TO_CLOSE   1
+#define WDT_REGION_INITED 2
+#define WDT_DEVICE_INITED 3
+
+static unsigned long boot_status;
+
+static struct resource  *wdt_mem;
+static void __iomem     *wdt_base;
+struct clk              *wdt_clk;
+
+static void wdt_enable(void)
+{
+        spin_lock(&io_lock);
+
+        if (wdt_clk)
+                clk_set_rate(wdt_clk, 1);
+
+        /* stop counter, initiate counter reset */
+        __raw_writel(RESET_COUNT, WDTIM_CTRL(wdt_base));
+        /*wait for reset to complete. 100% guarantee event */
+        while (__raw_readl(WDTIM_COUNTER(wdt_base)))
+                cpu_relax();
+        /* internal and external reset, stop after that */
+        __raw_writel(M_RES2 | STOP_COUNT0 | RESET_COUNT0,
+                WDTIM_MCTRL(wdt_base));
+        /* configure match output */
+        __raw_writel(MATCH_OUTPUT_HIGH, WDTIM_EMR(wdt_base));
+        /* clear interrupt, just in case */
+        __raw_writel(MATCH_INT, WDTIM_INT(wdt_base));
+        /* the longest pulse period 65541/(13*10^6) seconds ~ 5 ms. */
+        __raw_writel(0xFFFF, WDTIM_PULSE(wdt_base));
+        __raw_writel(heartbeat * WDOG_COUNTER_RATE, WDTIM_MATCH0(wdt_base));
+        /*enable counter, stop when debugger active */
+        __raw_writel(COUNT_ENAB | DEBUG_EN, WDTIM_CTRL(wdt_base));
+
+        spin_unlock(&io_lock);
+}
+
+static void wdt_disable(void)
+{
+        spin_lock(&io_lock);
+
+        __raw_writel(0, WDTIM_CTRL(wdt_base));  /*stop counter */
+        if (wdt_clk)
+                clk_set_rate(wdt_clk, 0);
+
+        spin_unlock(&io_lock);
+}
+
+static int pnx4008_wdt_open(struct inode *inode, struct file *file)
+{
+        if (test_and_set_bit(WDT_IN_USE, &wdt_status))
+                return -EBUSY;
+
+        clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
+
+        wdt_enable();
+
+        return nonseekable_open(inode, file);
+}
+
+static ssize_t
+pnx4008_wdt_write(struct file *file, const char *data, size_t len,
+                  loff_t * ppos)
+{
+        /*  Can't seek (pwrite) on this device  */
+        if (ppos != &file->f_pos)
+                return -ESPIPE;
+
+        if (len) {
+                if (!nowayout) {
+                        size_t i;
+
+                        clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
+
+                        for (i = 0; i != len; i++) {
+                                char c;
+
+                                if (get_user(c, data + i))
+                                        return -EFAULT;
+                                if (c == 'V')
+                                        set_bit(WDT_OK_TO_CLOSE, &wdt_status);
+                        }
+                }
+                wdt_enable();
+        }
+
+        return len;
+}
+
+static struct watchdog_info ident = {
+        .options = WDIOF_CARDRESET | WDIOF_MAGICCLOSE |
+            WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
+        .identity = "PNX4008 Watchdog",
+};
+
+static int
+pnx4008_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
+                  unsigned long arg)
+{
+        int ret = -ENOTTY;
+        int time;
+
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                ret = copy_to_user((struct watchdog_info *)arg, &ident,
+                                   sizeof(ident)) ? -EFAULT : 0;
+                break;
+
+        case WDIOC_GETSTATUS:
+                ret = put_user(0, (int *)arg);
+                break;
+
+        case WDIOC_GETBOOTSTATUS:
+                ret = put_user(boot_status, (int *)arg);
+                break;
+
+        case WDIOC_SETTIMEOUT:
+                ret = get_user(time, (int *)arg);
+                if (ret)
+                        break;
+
+                if (time <= 0 || time > MAX_HEARTBEAT) {
+                        ret = -EINVAL;
+                        break;
+                }
+
+                heartbeat = time;
+                wdt_enable();
+                /* Fall through */
+
+        case WDIOC_GETTIMEOUT:
+                ret = put_user(heartbeat, (int *)arg);
+                break;
+
+        case WDIOC_KEEPALIVE:
+                wdt_enable();
+                ret = 0;
+                break;
+        }
+        return ret;
+}
+
+static int pnx4008_wdt_release(struct inode *inode, struct file *file)
+{
+        if (!test_bit(WDT_OK_TO_CLOSE, &wdt_status))
+                printk(KERN_WARNING "WATCHDOG: Device closed unexpectdly\n");
+
+        wdt_disable();
+        clear_bit(WDT_IN_USE, &wdt_status);
+        clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
+
+        return 0;
+}
+
+static struct file_operations pnx4008_wdt_fops = {
+        .owner = THIS_MODULE,
+        .llseek = no_llseek,
+        .write = pnx4008_wdt_write,
+        .ioctl = pnx4008_wdt_ioctl,
+        .open = pnx4008_wdt_open,
+        .release = pnx4008_wdt_release,
+};
+
+static struct miscdevice pnx4008_wdt_miscdev = {
+        .minor = WATCHDOG_MINOR,
+        .name = "watchdog",
+        .fops = &pnx4008_wdt_fops,
+};
+
+static int pnx4008_wdt_probe(struct platform_device *pdev)
+{
+        int ret = 0, size;
+        struct resource *res;
+
+        spin_lock_init(&io_lock);
+
+        if (heartbeat < 1 || heartbeat > MAX_HEARTBEAT)
+                heartbeat = DEFAULT_HEARTBEAT;
+
+        printk(KERN_INFO MODULE_NAME
+                "PNX4008 Watchdog Timer: heartbeat %d sec\n", heartbeat);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res == NULL) {
+                printk(KERN_INFO MODULE_NAME
+                        "failed to get memory region resouce\n");
+                return -ENOENT;
+        }
+
+        size = res->end - res->start + 1;
+        wdt_mem = request_mem_region(res->start, size, pdev->name);
+
+        if (wdt_mem == NULL) {
+                printk(KERN_INFO MODULE_NAME "failed to get memory region\n");
+                return -ENOENT;
+        }
+        wdt_base = (void __iomem *)IO_ADDRESS(res->start);
+
+        wdt_clk = clk_get(&pdev->dev, "wdt_ck");
+        if (!wdt_clk) {
+                release_resource(wdt_mem);
+                kfree(wdt_mem);
+                goto out;
+        } else
+                clk_set_rate(wdt_clk, 1);
+
+        ret = misc_register(&pnx4008_wdt_miscdev);
+        if (ret < 0) {
+                printk(KERN_ERR MODULE_NAME "cannot register misc device\n");
+                release_resource(wdt_mem);
+                kfree(wdt_mem);
+                clk_set_rate(wdt_clk, 0);
+        } else {
+                boot_status = (__raw_readl(WDTIM_RES(wdt_base)) & WDOG_RESET) ?
+                    WDIOF_CARDRESET : 0;
+                wdt_disable();          /*disable for now */
+                set_bit(WDT_DEVICE_INITED, &wdt_status);
+        }
+
+out:
+        return ret;
+}
+
+static int pnx4008_wdt_remove(struct platform_device *pdev)
+{
+        misc_deregister(&pnx4008_wdt_miscdev);
+        if (wdt_clk) {
+                clk_set_rate(wdt_clk, 0);
+                clk_put(wdt_clk);
+                wdt_clk = NULL;
+        }
+        if (wdt_mem) {
+                release_resource(wdt_mem);
+                kfree(wdt_mem);
+                wdt_mem = NULL;
+        }
+        return 0;
+}
+
+static struct platform_driver platform_wdt_driver = {
+        .driver = {
+                .name = "watchdog",
+        },
+        .probe = pnx4008_wdt_probe,
+        .remove = pnx4008_wdt_remove,
+};
+
+static int __init pnx4008_wdt_init(void)
+{
+        return platform_driver_register(&platform_wdt_driver);
+}
+
+static void __exit pnx4008_wdt_exit(void)
+{
+        return platform_driver_unregister(&platform_wdt_driver);
+}
+
+module_init(pnx4008_wdt_init);
+module_exit(pnx4008_wdt_exit);
+
+MODULE_AUTHOR("MontaVista Software, Inc. <source@mvista.com>");
+MODULE_DESCRIPTION("PNX4008 Watchdog Driver");
+
+module_param(heartbeat, int, 0);
+MODULE_PARM_DESC(heartbeat,
+                 "Watchdog heartbeat period in seconds from 1 to "
+                 __MODULE_STRING(MAX_HEARTBEAT) ", default "
+                 __MODULE_STRING(DEFAULT_HEARTBEAT));
+
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout,
+                 "Set to 1 to keep watchdog running after device release");
+
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/char/watchdog/rm9k_wdt.c b/drivers/char/watchdog/rm9k_wdt.c
new file mode 100644
index 000000000000..ec3909371c21
--- /dev/null
+++ b/drivers/char/watchdog/rm9k_wdt.c
@@ -0,0 +1,420 @@
+/*
+ *  Watchdog implementation for GPI h/w found on PMC-Sierra RM9xxx
+ *  chips.
+ *
+ *  Copyright (C) 2004 by Basler Vision Technologies AG
+ *  Author: Thomas Koeller <thomas.koeller@baslerweb.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/platform_device.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/interrupt.h>
+#include <linux/fs.h>
+#include <linux/reboot.h>
+#include <linux/notifier.h>
+#include <linux/miscdevice.h>
+#include <linux/watchdog.h>
+#include <asm/io.h>
+#include <asm/atomic.h>
+#include <asm/processor.h>
+#include <asm/uaccess.h>
+#include <asm/system.h>
+#include <asm/rm9k-ocd.h>
+
+#include <rm9k_wdt.h>
+
+
+#define CLOCK                  125000000
+#define MAX_TIMEOUT_SECONDS    32
+#define CPCCR                  0x0080
+#define CPGIG1SR               0x0044
+#define CPGIG1ER               0x0054
+
+
+/* Function prototypes */
+static irqreturn_t wdt_gpi_irqhdl(int, void *, struct pt_regs *);
+static void wdt_gpi_start(void);
+static void wdt_gpi_stop(void);
+static void wdt_gpi_set_timeout(unsigned int);
+static int wdt_gpi_open(struct inode *, struct file *);
+static int wdt_gpi_release(struct inode *, struct file *);
+static ssize_t wdt_gpi_write(struct file *, const char __user *, size_t, loff_t *);
+static long wdt_gpi_ioctl(struct file *, unsigned int, unsigned long);
+static int wdt_gpi_notify(struct notifier_block *, unsigned long, void *);
+static const struct resource *wdt_gpi_get_resource(struct platform_device *, const char *, unsigned int);
+static int __init wdt_gpi_probe(struct device *);
+static int __exit wdt_gpi_remove(struct device *);
+
+
+static const char wdt_gpi_name[] = "wdt_gpi";
+static atomic_t opencnt;
+static int expect_close;
+static int locked;
+
+
+/* These are set from device resources */
+static void __iomem * wd_regs;
+static unsigned int wd_irq, wd_ctr;
+
+
+/* Module arguments */
+static int timeout = MAX_TIMEOUT_SECONDS;
+module_param(timeout, int, 0444);
+MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds");
+
+static unsigned long resetaddr = 0xbffdc200;
+module_param(resetaddr, ulong, 0444);
+MODULE_PARM_DESC(resetaddr, "Address to write to to force a reset");
+
+static unsigned long flagaddr = 0xbffdc104;
+module_param(flagaddr, ulong, 0444);
+MODULE_PARM_DESC(flagaddr, "Address to write to boot flags to");
+
+static int powercycle;
+module_param(powercycle, bool, 0444);
+MODULE_PARM_DESC(powercycle, "Cycle power if watchdog expires");
+
+static int nowayout = WATCHDOG_NOWAYOUT;
+module_param(nowayout, bool, 0444);
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be disabled once started");
+
+
+/* Interrupt handler */
+static irqreturn_t wdt_gpi_irqhdl(int irq, void *ctxt, struct pt_regs *regs)
+{
+        if (!unlikely(__raw_readl(wd_regs + 0x0008) & 0x1))
+                return IRQ_NONE;
+        __raw_writel(0x1, wd_regs + 0x0008);
+
+
+        printk(KERN_CRIT "%s: watchdog expired - resetting system\n",
+                wdt_gpi_name);
+
+        *(volatile char *) flagaddr |= 0x01;
+        *(volatile char *) resetaddr = powercycle ? 0x01 : 0x2;
+        iob();
+        while (1)
+                cpu_relax();
+}
+
+
+/* Watchdog functions */
+static void wdt_gpi_start(void)
+{
+        u32 reg;
+
+        lock_titan_regs();
+        reg = titan_readl(CPGIG1ER);
+        titan_writel(reg | (0x100 << wd_ctr), CPGIG1ER);
+        iob();
+        unlock_titan_regs();
+}
+
+static void wdt_gpi_stop(void)
+{
+        u32 reg;
+
+        lock_titan_regs();
+        reg = titan_readl(CPCCR) & ~(0xf << (wd_ctr * 4));
+        titan_writel(reg, CPCCR);
+        reg = titan_readl(CPGIG1ER);
+        titan_writel(reg & ~(0x100 << wd_ctr), CPGIG1ER);
+        iob();
+        unlock_titan_regs();
+}
+
+static void wdt_gpi_set_timeout(unsigned int to)
+{
+        u32 reg;
+        const u32 wdval = (to * CLOCK) & ~0x0000000f;
+
+        lock_titan_regs();
+        reg = titan_readl(CPCCR) & ~(0xf << (wd_ctr * 4));
+        titan_writel(reg, CPCCR);
+        wmb();
+        __raw_writel(wdval, wd_regs + 0x0000);
+        wmb();
+        titan_writel(reg | (0x2 << (wd_ctr * 4)), CPCCR);
+        wmb();
+        titan_writel(reg | (0x5 << (wd_ctr * 4)), CPCCR);
+        iob();
+        unlock_titan_regs();
+}
+
+
+/* /dev/watchdog operations */
+static int wdt_gpi_open(struct inode *inode, struct file *file)
+{
+        int res;
+
+        if (unlikely(atomic_dec_if_positive(&opencnt) < 0))
+                return -EBUSY;
+
+        expect_close = 0;
+        if (locked) {
+                module_put(THIS_MODULE);
+                free_irq(wd_irq, &miscdev);
+                locked = 0;
+        }
+
+        res = request_irq(wd_irq, wdt_gpi_irqhdl, SA_SHIRQ | SA_INTERRUPT,
+                          wdt_gpi_name, &miscdev);
+        if (unlikely(res))
+                return res;
+
+        wdt_gpi_set_timeout(timeout);
+        wdt_gpi_start();
+
+        printk(KERN_INFO "%s: watchdog started, timeout = %u seconds\n",
+                wdt_gpi_name, timeout);
+        return nonseekable_open(inode, file);
+}
+
+static int wdt_gpi_release(struct inode *inode, struct file *file)
+{
+        if (nowayout) {
+                printk(KERN_INFO "%s: no way out - watchdog left running\n",
+                        wdt_gpi_name);
+                __module_get(THIS_MODULE);
+                locked = 1;
+        } else {
+                if (expect_close) {
+                        wdt_gpi_stop();
+                        free_irq(wd_irq, &miscdev);
+                        printk(KERN_INFO "%s: watchdog stopped\n", wdt_gpi_name);
+                } else {
+                        printk(KERN_CRIT "%s: unexpected close() -"
+                                " watchdog left running\n",
+                                wdt_gpi_name);
+                        wdt_gpi_set_timeout(timeout);
+                        __module_get(THIS_MODULE);
+                        locked = 1;
+                }
+        }
+
+        atomic_inc(&opencnt);
+        return 0;
+}
+
+static ssize_t
+wdt_gpi_write(struct file *f, const char __user *d, size_t s, loff_t *o)
+{
+        char val;
+
+        wdt_gpi_set_timeout(timeout);
+        expect_close = (s > 0) && !get_user(val, d) && (val == 'V');
+        return s ? 1 : 0;
+}
+
+static long
+wdt_gpi_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
+{
+        long res = -ENOTTY;
+        const long size = _IOC_SIZE(cmd);
+        int stat;
+        void __user *argp = (void __user *)arg;
+        static struct watchdog_info wdinfo = {
+                .identity               = "RM9xxx/GPI watchdog",
+                .firmware_version       = 0,
+                .options                = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING
+        };
+
+        if (unlikely(_IOC_TYPE(cmd) != WATCHDOG_IOCTL_BASE))
+                return -ENOTTY;
+
+        if ((_IOC_DIR(cmd) & _IOC_READ)
+            && !access_ok(VERIFY_WRITE, arg, size))
+                return -EFAULT;
+
+        if ((_IOC_DIR(cmd) & _IOC_WRITE)
+            && !access_ok(VERIFY_READ, arg, size))
+                return -EFAULT;
+
+        expect_close = 0;
+
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                wdinfo.options = nowayout ?
+                        WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING :
+                        WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE;
+                res = __copy_to_user(argp, &wdinfo, size) ?  -EFAULT : size;
+                break;
+
+        case WDIOC_GETSTATUS:
+                break;
+
+        case WDIOC_GETBOOTSTATUS:
+                stat = (*(volatile char *) flagaddr & 0x01)
+                        ? WDIOF_CARDRESET : 0;
+                res = __copy_to_user(argp, &stat, size) ?
+                        -EFAULT : size;
+                break;
+
+        case WDIOC_SETOPTIONS:
+                break;
+
+        case WDIOC_KEEPALIVE:
+                wdt_gpi_set_timeout(timeout);
+                res = size;
+                break;
+
+        case WDIOC_SETTIMEOUT:
+                {
+                        int val;
+                        if (unlikely(__copy_from_user(&val, argp, size))) {
+                                res = -EFAULT;
+                                break;
+                        }
+
+                        if (val > MAX_TIMEOUT_SECONDS)
+                                val = MAX_TIMEOUT_SECONDS;
+                        timeout = val;
+                        wdt_gpi_set_timeout(val);
+                        res = size;
+                        printk(KERN_INFO "%s: timeout set to %u seconds\n",
+                                wdt_gpi_name, timeout);
+                }
+                break;
+
+        case WDIOC_GETTIMEOUT:
+                res = __copy_to_user(argp, &timeout, size) ?
+                        -EFAULT : size;
+                break;
+        }
+
+        return res;
+}
+
+
+/* Shutdown notifier */
+static int
+wdt_gpi_notify(struct notifier_block *this, unsigned long code, void *unused)
+{
+        if (code == SYS_DOWN || code == SYS_HALT)
+                wdt_gpi_stop();
+
+        return NOTIFY_DONE;
+}
+
+
+/* Kernel interfaces */
+static struct file_operations fops = {
+        .owner          = THIS_MODULE,
+        .open           = wdt_gpi_open,
+        .release        = wdt_gpi_release,
+        .write          = wdt_gpi_write,
+        .unlocked_ioctl = wdt_gpi_ioctl,
+};
+
+static struct miscdevice miscdev = {
+        .minor          = WATCHDOG_MINOR,
+        .name           = wdt_gpi_name,
+        .fops           = &fops,
+};
+
+static struct notifier_block wdt_gpi_shutdown = {
+        .notifier_call  = wdt_gpi_notify,
+};
+
+
+/* Init & exit procedures */
+static const struct resource *
+wdt_gpi_get_resource(struct platform_device *pdv, const char *name,
+                      unsigned int type)
+{
+        char buf[80];
+        if (snprintf(buf, sizeof buf, "%s_0", name) >= sizeof buf)
+                return NULL;
+        return platform_get_resource_byname(pdv, type, buf);
+}
+
+/* No hotplugging on the platform bus - use __init */
+static int __init wdt_gpi_probe(struct device *dev)
+{
+        int res;
+        struct platform_device * const pdv = to_platform_device(dev);
+        const struct resource
+                * const rr = wdt_gpi_get_resource(pdv, WDT_RESOURCE_REGS,
+                                                  IORESOURCE_MEM),
+                * const ri = wdt_gpi_get_resource(pdv, WDT_RESOURCE_IRQ,
+                                                  IORESOURCE_IRQ),
+                * const rc = wdt_gpi_get_resource(pdv, WDT_RESOURCE_COUNTER,
+                                                  0);
+
+        if (unlikely(!rr || !ri || !rc))
+                return -ENXIO;
+
+        wd_regs = ioremap_nocache(rr->start, rr->end + 1 - rr->start);
+        if (unlikely(!wd_regs))
+                return -ENOMEM;
+        wd_irq = ri->start;
+        wd_ctr = rc->start;
+        res = misc_register(&miscdev);
+        if (res)
+                iounmap(wd_regs);
+        else
+                register_reboot_notifier(&wdt_gpi_shutdown);
+        return res;
+}
+
+static int __exit wdt_gpi_remove(struct device *dev)
+{
+        int res;
+
+        unregister_reboot_notifier(&wdt_gpi_shutdown);
+        res = misc_deregister(&miscdev);
+        iounmap(wd_regs);
+        wd_regs = NULL;
+        return res;
+}
+
+
+/* Device driver init & exit */
+static struct device_driver wdt_gpi_driver = {
+        .name           = (char *) wdt_gpi_name,
+        .bus            = &platform_bus_type,
+        .owner          = THIS_MODULE,
+        .probe          = wdt_gpi_probe,
+        .remove         = __exit_p(wdt_gpi_remove),
+        .shutdown       = NULL,
+        .suspend        = NULL,
+        .resume         = NULL,
+};
+
+static int __init wdt_gpi_init_module(void)
+{
+        atomic_set(&opencnt, 1);
+        if (timeout > MAX_TIMEOUT_SECONDS)
+                timeout = MAX_TIMEOUT_SECONDS;
+        return driver_register(&wdt_gpi_driver);
+}
+
+static void __exit wdt_gpi_cleanup_module(void)
+{
+        driver_unregister(&wdt_gpi_driver);
+}
+
+module_init(wdt_gpi_init_module);
+module_exit(wdt_gpi_cleanup_module);
+
+MODULE_AUTHOR("Thomas Koeller <thomas.koeller@baslerweb.com>");
+MODULE_DESCRIPTION("Basler eXcite watchdog driver for gpi devices");
+MODULE_VERSION("0.1");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
+
diff --git a/drivers/char/watchdog/s3c2410_wdt.c b/drivers/char/watchdog/s3c2410_wdt.c
index be978e8ed754..18cb050c3862 100644
--- a/drivers/char/watchdog/s3c2410_wdt.c
+++ b/drivers/char/watchdog/s3c2410_wdt.c
@@ -62,7 +62,7 @@
 #define CONFIG_S3C2410_WATCHDOG_ATBOOT          (0)
 #define CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME    (15)
 
-static int nowayout = WATCHDOG_NOWAYOUT;
+static int nowayout     = WATCHDOG_NOWAYOUT;
 static int tmr_margin   = CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME;
 static int tmr_atboot   = CONFIG_S3C2410_WATCHDOG_ATBOOT;
 static int soft_noboot  = 0;
@@ -213,11 +213,10 @@ static int s3c2410wdt_open(struct inode *inode, struct file *file)
         if(down_trylock(&open_lock))
                 return -EBUSY;
 
-        if (nowayout) {
+        if (nowayout)
                 __module_get(THIS_MODULE);
-        } else {
-                allow_close = CLOSE_STATE_ALLOW;
-        }
+
+        allow_close = CLOSE_STATE_NOT;
 
         /* start the timer */
         s3c2410wdt_start();
@@ -230,6 +229,7 @@ static int s3c2410wdt_release(struct inode *inode, struct file *file)
          *      Shut off the timer.
          *      Lock it in if it's a module and we set nowayout
          */
+
         if (allow_close == CLOSE_STATE_ALLOW) {
                 s3c2410wdt_stop();
         } else {
@@ -288,7 +288,7 @@ static int s3c2410wdt_ioctl(struct inode *inode, struct file *file,
 
         switch (cmd) {
                 default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
 
                 case WDIOC_GETSUPPORT:
                         return copy_to_user(argp, &s3c2410_wdt_ident,
@@ -336,8 +336,7 @@ static struct miscdevice s3c2410wdt_miscdev = {
 
 /* interrupt handler code */
 
-static irqreturn_t s3c2410wdt_irq(int irqno, void *param,
-                                  struct pt_regs *regs)
+static irqreturn_t s3c2410wdt_irq(int irqno, void *param)
 {
         printk(KERN_INFO PFX "Watchdog timer expired!\n");
 
@@ -381,18 +380,21 @@ static int s3c2410wdt_probe(struct platform_device *pdev)
         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
         if (res == NULL) {
                 printk(KERN_INFO PFX "failed to get irq resource\n");
+                iounmap(wdt_base);
                 return -ENOENT;
         }
 
         ret = request_irq(res->start, s3c2410wdt_irq, 0, pdev->name, pdev);
         if (ret != 0) {
                 printk(KERN_INFO PFX "failed to install irq (%d)\n", ret);
+                iounmap(wdt_base);
                 return ret;
         }
 
         wdt_clock = clk_get(&pdev->dev, "watchdog");
         if (wdt_clock == NULL) {
                 printk(KERN_INFO PFX "failed to find watchdog clock source\n");
+                iounmap(wdt_base);
                 return -ENOENT;
         }
 
@@ -416,6 +418,7 @@ static int s3c2410wdt_probe(struct platform_device *pdev)
         if (ret) {
                 printk (KERN_ERR PFX "cannot register miscdev on minor=%d (%d)\n",
                         WATCHDOG_MINOR, ret);
+                iounmap(wdt_base);
                 return ret;
         }
 
@@ -452,6 +455,7 @@ static int s3c2410wdt_remove(struct platform_device *dev)
                 wdt_clock = NULL;
         }
 
+        iounmap(wdt_base);
         misc_deregister(&s3c2410wdt_miscdev);
         return 0;
 }
diff --git a/drivers/char/watchdog/sa1100_wdt.c b/drivers/char/watchdog/sa1100_wdt.c
index 1fc16d995788..33c1137f17d6 100644
--- a/drivers/char/watchdog/sa1100_wdt.c
+++ b/drivers/char/watchdog/sa1100_wdt.c
@@ -90,7 +90,7 @@ static struct watchdog_info ident = {
 static int sa1100dog_ioctl(struct inode *inode, struct file *file,
         unsigned int cmd, unsigned long arg)
 {
-        int ret = -ENOIOCTLCMD;
+        int ret = -ENOTTY;
         int time;
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
diff --git a/drivers/char/watchdog/sbc60xxwdt.c b/drivers/char/watchdog/sbc60xxwdt.c
index 4663c2fd53cd..c7b2045bc76b 100644
--- a/drivers/char/watchdog/sbc60xxwdt.c
+++ b/drivers/char/watchdog/sbc60xxwdt.c
@@ -235,7 +235,7 @@ static int fop_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
         switch(cmd)
         {
                 default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
                 case WDIOC_GETSUPPORT:
                         return copy_to_user(argp, &ident, sizeof(ident))?-EFAULT:0;
                 case WDIOC_GETSTATUS:
diff --git a/drivers/char/watchdog/sbc_epx_c3.c b/drivers/char/watchdog/sbc_epx_c3.c
index bfc475dabe6d..8882b427d24f 100644
--- a/drivers/char/watchdog/sbc_epx_c3.c
+++ b/drivers/char/watchdog/sbc_epx_c3.c
@@ -141,7 +141,7 @@ static int epx_c3_ioctl(struct inode *inode, struct file *file,
 
                 return retval;
         default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
         }
 }
 
diff --git a/drivers/char/watchdog/sc1200wdt.c b/drivers/char/watchdog/sc1200wdt.c
index 7c3cf293a5af..e3239833e4b0 100644
--- a/drivers/char/watchdog/sc1200wdt.c
+++ b/drivers/char/watchdog/sc1200wdt.c
@@ -180,7 +180,7 @@ static int sc1200wdt_ioctl(struct inode *inode, struct file *file, unsigned int
 
         switch (cmd) {
                 default:
-                        return -ENOIOCTLCMD;    /* Keep Pavel Machek amused ;) */
+                        return -ENOTTY;
 
                 case WDIOC_GETSUPPORT:
                         if (copy_to_user(argp, &ident, sizeof ident))
@@ -392,7 +392,7 @@ static int __init sc1200wdt_init(void)
         if (io == -1) {
                 printk(KERN_ERR PFX "io parameter must be specified\n");
                 ret = -EINVAL;
-                goto out_clean;
+                goto out_pnp;
         }
 
 #if defined CONFIG_PNP
@@ -405,7 +405,7 @@ static int __init sc1200wdt_init(void)
         if (!request_region(io, io_len, SC1200_MODULE_NAME)) {
                 printk(KERN_ERR PFX "Unable to register IO port %#x\n", io);
                 ret = -EBUSY;
-                goto out_clean;
+                goto out_pnp;
         }
 
         ret = sc1200wdt_probe();
@@ -435,6 +435,11 @@ out_rbt:
 out_io:
         release_region(io, io_len);
 
+out_pnp:
+#if defined CONFIG_PNP
+        if (isapnp)
+                pnp_unregister_driver(&scl200wdt_pnp_driver);
+#endif
         goto out_clean;
 }
 
diff --git a/drivers/char/watchdog/sc520_wdt.c b/drivers/char/watchdog/sc520_wdt.c
index 2c7c9db71be8..caec37ba750a 100644
--- a/drivers/char/watchdog/sc520_wdt.c
+++ b/drivers/char/watchdog/sc520_wdt.c
@@ -290,7 +290,7 @@ static int fop_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
         switch(cmd)
         {
                 default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
                 case WDIOC_GETSUPPORT:
                         return copy_to_user(argp, &ident, sizeof(ident))?-EFAULT:0;
                 case WDIOC_GETSTATUS:
diff --git a/drivers/char/watchdog/scx200_wdt.c b/drivers/char/watchdog/scx200_wdt.c
index c561299a5537..fc0e0347f9d2 100644
--- a/drivers/char/watchdog/scx200_wdt.c
+++ b/drivers/char/watchdog/scx200_wdt.c
@@ -166,7 +166,7 @@ static int scx200_wdt_ioctl(struct inode *inode, struct file *file,
 
         switch (cmd) {
         default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
         case WDIOC_GETSUPPORT:
                 if(copy_to_user(argp, &ident, sizeof(ident)))
                         return -EFAULT;
diff --git a/drivers/char/watchdog/shwdt.c b/drivers/char/watchdog/shwdt.c
index 1355038f1044..dc403629aeb3 100644
--- a/drivers/char/watchdog/shwdt.c
+++ b/drivers/char/watchdog/shwdt.c
@@ -27,7 +27,7 @@
 #include <linux/notifier.h>
 #include <linux/ioport.h>
 #include <linux/fs.h>
-
+#include <linux/mm.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>
 #include <asm/watchdog.h>
@@ -125,7 +125,6 @@ static void sh_wdt_start(void)
 
 /**
  *      sh_wdt_stop - Stop the Watchdog
- *
  *      Stops the watchdog.
  */
 static void sh_wdt_stop(void)
@@ -141,22 +140,20 @@ static void sh_wdt_stop(void)
 
 /**
  *      sh_wdt_keepalive - Keep the Userspace Watchdog Alive
- *
  *      The Userspace watchdog got a KeepAlive: schedule the next heartbeat.
  */
-static void sh_wdt_keepalive(void)
+static inline void sh_wdt_keepalive(void)
 {
         next_heartbeat = jiffies + (heartbeat * HZ);
 }
 
 /**
  *      sh_wdt_set_heartbeat - Set the Userspace Watchdog heartbeat
- *
  *      Set the Userspace Watchdog heartbeat
  */
 static int sh_wdt_set_heartbeat(int t)
 {
-        if ((t < 1) || (t > 3600)) /* arbitrary upper limit */
+        if (unlikely((t < 1) || (t > 3600))) /* arbitrary upper limit */
                 return -EINVAL;
 
         heartbeat = t;
@@ -165,7 +162,6 @@ static int sh_wdt_set_heartbeat(int t)
 
 /**
  *      sh_wdt_ping - Ping the Watchdog
- *
  *      @data: Unused
  *
  *      Clears overflow bit, resets timer counter.
@@ -182,14 +178,13 @@ static void sh_wdt_ping(unsigned long data)
                 sh_wdt_write_cnt(0);
 
                 mod_timer(&timer, next_ping_period(clock_division_ratio));
-        } else {
-                printk(KERN_WARNING PFX "Heartbeat lost! Will not ping the watchdog\n");
-        }
+        } else
+                printk(KERN_WARNING PFX "Heartbeat lost! Will not ping "
+                       "the watchdog\n");
 }
 
 /**
  *      sh_wdt_open - Open the Device
- *
  *      @inode: inode of device
  *      @file: file handle of device
  *
@@ -209,7 +204,6 @@ static int sh_wdt_open(struct inode *inode, struct file *file)
 
 /**
  *      sh_wdt_close - Close the Device
- *
  *      @inode: inode of device
  *      @file: file handle of device
  *
@@ -220,7 +214,8 @@ static int sh_wdt_close(struct inode *inode, struct file *file)
         if (shwdt_expect_close == 42) {
                 sh_wdt_stop();
         } else {
-                printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");
+                printk(KERN_CRIT PFX "Unexpected close, not "
+                       "stopping watchdog!\n");
                 sh_wdt_keepalive();
         }
 
@@ -232,7 +227,6 @@ static int sh_wdt_close(struct inode *inode, struct file *file)
 
 /**
  *      sh_wdt_write - Write to Device
- *
  *      @file: file handle of device
  *      @buf: buffer to write
  *      @count: length of buffer
@@ -264,8 +258,56 @@ static ssize_t sh_wdt_write(struct file *file, const char *buf,
 }
 
 /**
- *      sh_wdt_ioctl - Query Device
+ *      sh_wdt_mmap - map WDT/CPG registers into userspace
+ *      @file: file structure for the device
+ *      @vma: VMA to map the registers into
+ *
+ *      A simple mmap() implementation for the corner cases where the counter
+ *      needs to be mapped in userspace directly. Due to the relatively small
+ *      size of the area, neighbouring registers not necessarily tied to the
+ *      CPG will also be accessible through the register page, so this remains
+ *      configurable for users that really know what they're doing.
  *
+ *      Additionaly, the register page maps in the CPG register base relative
+ *      to the nearest page-aligned boundary, which requires that userspace do
+ *      the appropriate CPU subtype math for calculating the page offset for
+ *      the counter value.
+ */
+static int sh_wdt_mmap(struct file *file, struct vm_area_struct *vma)
+{
+        int ret = -ENOSYS;
+
+#ifdef CONFIG_SH_WDT_MMAP
+        unsigned long addr;
+
+        /* Only support the simple cases where we map in a register page. */
+        if (((vma->vm_end - vma->vm_start) != PAGE_SIZE) || vma->vm_pgoff)
+                return -EINVAL;
+
+        /*
+         * Pick WTCNT as the start, it's usually the first register after the
+         * FRQCR, and neither one are generally page-aligned out of the box.
+         */
+        addr = WTCNT & ~(PAGE_SIZE - 1);
+
+        vma->vm_flags |= VM_IO;
+        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
+
+        if (io_remap_pfn_range(vma, vma->vm_start, addr >> PAGE_SHIFT,
+                               PAGE_SIZE, vma->vm_page_prot)) {
+                printk(KERN_ERR PFX "%s: io_remap_pfn_range failed\n",
+                       __FUNCTION__);
+                return -EAGAIN;
+        }
+
+        ret = 0;
+#endif
+
+        return ret;
+}
+
+/**
+ *      sh_wdt_ioctl - Query Device
  *      @inode: inode of device
  *      @file: file handle of device
  *      @cmd: watchdog command
@@ -318,7 +360,7 @@ static int sh_wdt_ioctl(struct inode *inode, struct file *file,
 
                         return retval;
                 default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
         }
 
         return 0;
@@ -326,7 +368,6 @@ static int sh_wdt_ioctl(struct inode *inode, struct file *file,
 
 /**
  *      sh_wdt_notify_sys - Notifier Handler
- *
  *      @this: notifier block
  *      @code: notifier event
  *      @unused: unused
@@ -337,9 +378,8 @@ static int sh_wdt_ioctl(struct inode *inode, struct file *file,
 static int sh_wdt_notify_sys(struct notifier_block *this,
                              unsigned long code, void *unused)
 {
-        if (code == SYS_DOWN || code == SYS_HALT) {
+        if (code == SYS_DOWN || code == SYS_HALT)
                 sh_wdt_stop();
-        }
 
         return NOTIFY_DONE;
 }
@@ -351,10 +391,12 @@ static const struct file_operations sh_wdt_fops = {
         .ioctl          = sh_wdt_ioctl,
         .open           = sh_wdt_open,
         .release        = sh_wdt_close,
+        .mmap           = sh_wdt_mmap,
 };
 
 static struct watchdog_info sh_wdt_info = {
-        .options                = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,
+        .options                = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT |
+                                  WDIOF_MAGICCLOSE,
         .firmware_version       = 1,
         .identity               = "SH WDT",
 };
@@ -371,7 +413,6 @@ static struct miscdevice sh_wdt_miscdev = {
 
 /**
  *      sh_wdt_init - Initialize module
- *
  *      Registers the device and notifier handler. Actual device
  *      initialization is handled by sh_wdt_open().
  */
@@ -381,15 +422,15 @@ static int __init sh_wdt_init(void)
 
         if ((clock_division_ratio < 0x5) || (clock_division_ratio > 0x7)) {
                 clock_division_ratio = WTCSR_CKS_4096;
-                printk(KERN_INFO PFX "clock_division_ratio value must be 0x5<=x<=0x7, using %d\n",
-                        clock_division_ratio);
+                printk(KERN_INFO PFX "clock_division_ratio value must "
+                       "be 0x5<=x<=0x7, using %d\n", clock_division_ratio);
         }
 
-        if (sh_wdt_set_heartbeat(heartbeat))
-        {
+        rc = sh_wdt_set_heartbeat(heartbeat);
+        if (unlikely(rc)) {
                 heartbeat = WATCHDOG_HEARTBEAT;
-                printk(KERN_INFO PFX "heartbeat value must be 1<=x<=3600, using %d\n",
-                        heartbeat);
+                printk(KERN_INFO PFX "heartbeat value must "
+                       "be 1<=x<=3600, using %d\n", heartbeat);
         }
 
         init_timer(&timer);
@@ -397,15 +438,16 @@ static int __init sh_wdt_init(void)
         timer.data = 0;
 
         rc = register_reboot_notifier(&sh_wdt_notifier);
-        if (rc) {
-                printk(KERN_ERR PFX "Can't register reboot notifier (err=%d)\n", rc);
+        if (unlikely(rc)) {
+                printk(KERN_ERR PFX "Can't register reboot notifier (err=%d)\n",
+                       rc);
                 return rc;
         }
 
         rc = misc_register(&sh_wdt_miscdev);
-        if (rc) {
-                printk(KERN_ERR PFX "Can't register miscdev on minor=%d (err=%d)\n",
-                        sh_wdt_miscdev.minor, rc);
+        if (unlikely(rc)) {
+                printk(KERN_ERR PFX "Can't register miscdev on "
+                       "minor=%d (err=%d)\n", sh_wdt_miscdev.minor, rc);
                 unregister_reboot_notifier(&sh_wdt_notifier);
                 return rc;
         }
@@ -418,7 +460,6 @@ static int __init sh_wdt_init(void)
 
 /**
  *      sh_wdt_exit - Deinitialize module
- *
  *      Unregisters the device and notifier handler. Actual device
  *      deinitialization is handled by sh_wdt_close().
  */
@@ -434,14 +475,13 @@ MODULE_LICENSE("GPL");
 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 
 module_param(clock_division_ratio, int, 0);
-MODULE_PARM_DESC(clock_division_ratio, "Clock division ratio. Valid ranges are from 0x5 (1.31ms) to 0x7 (5.25ms). Defaults to 0x7.");
+MODULE_PARM_DESC(clock_division_ratio, "Clock division ratio. Valid ranges are from 0x5 (1.31ms) to 0x7 (5.25ms). (default=" __MODULE_STRING(clock_division_ratio) ")");
 
 module_param(heartbeat, int, 0);
 MODULE_PARM_DESC(heartbeat, "Watchdog heartbeat in seconds. (1<=heartbeat<=3600, default=" __MODULE_STRING(WATCHDOG_HEARTBEAT) ")");
 
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 module_init(sh_wdt_init);
 module_exit(sh_wdt_exit);
-
diff --git a/drivers/char/watchdog/smsc37b787_wdt.c b/drivers/char/watchdog/smsc37b787_wdt.c
new file mode 100644
index 000000000000..9f56913b484f
--- /dev/null
+++ b/drivers/char/watchdog/smsc37b787_wdt.c
@@ -0,0 +1,627 @@
+/*
+ *      SMsC 37B787 Watchdog Timer driver for Linux 2.6.x.x
+ *
+ *      Based on acquirewdt.c by Alan Cox <alan@redhat.com>
+ *       and some other existing drivers
+ *
+ *      This program is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU General Public License
+ *      as published by the Free Software Foundation; either version
+ *      2 of the License, or (at your option) any later version.
+ *
+ *      The authors do NOT admit liability nor provide warranty for
+ *      any of this software. This material is provided "AS-IS" in
+ *      the hope that it may be useful for others.
+ *
+ *      (C) Copyright 2003-2006  Sven Anders <anders@anduras.de>
+ *
+ *  History:
+ *      2003 - Created version 1.0 for Linux 2.4.x.
+ *      2006 - Ported to Linux 2.6, added nowayout and MAGICCLOSE
+ *             features. Released version 1.1
+ *
+ *  Theory of operation:
+ *
+ *      A Watchdog Timer (WDT) is a hardware circuit that can
+ *      reset the computer system in case of a software fault.
+ *      You probably knew that already.
+ *
+ *      Usually a userspace daemon will notify the kernel WDT driver
+ *      via the /dev/watchdog special device file that userspace is
+ *      still alive, at regular intervals.  When such a notification
+ *      occurs, the driver will usually tell the hardware watchdog
+ *      that everything is in order, and that the watchdog should wait
+ *      for yet another little while to reset the system.
+ *      If userspace fails (RAM error, kernel bug, whatever), the
+ *      notifications cease to occur, and the hardware watchdog will
+ *      reset the system (causing a reboot) after the timeout occurs.
+ *
+ * Create device with:
+ *  mknod /dev/watchdog c 10 130
+ *
+ * For an example userspace keep-alive daemon, see:
+ *   Documentation/watchdog/watchdog.txt
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/types.h>
+#include <linux/miscdevice.h>
+#include <linux/watchdog.h>
+#include <linux/delay.h>
+#include <linux/fs.h>
+#include <linux/ioport.h>
+#include <linux/notifier.h>
+#include <linux/reboot.h>
+#include <linux/init.h>
+#include <linux/spinlock.h>
+
+#include <asm/io.h>
+#include <asm/uaccess.h>
+#include <asm/system.h>
+
+/* enable support for minutes as units? */
+/* (does not always work correctly, so disabled by default!) */
+#define SMSC_SUPPORT_MINUTES
+#undef SMSC_SUPPORT_MINUTES
+
+#define MAX_TIMEOUT     255
+
+#define UNIT_SECOND     0
+#define UNIT_MINUTE     1
+
+#define MODNAME         "smsc37b787_wdt: "
+#define VERSION         "1.1"
+
+#define IOPORT          0x3F0
+#define IOPORT_SIZE     2
+#define IODEV_NO        8
+
+static int unit = UNIT_SECOND;  /* timer's unit */
+static int timeout = 60;        /* timeout value: default is 60 "units" */
+static unsigned long timer_enabled = 0;   /* is the timer enabled? */
+
+static char expect_close;       /* is the close expected? */
+
+static spinlock_t io_lock;      /* to guard the watchdog from io races */
+
+static int nowayout = WATCHDOG_NOWAYOUT;
+
+/* -- Low level function ----------------------------------------*/
+
+/* unlock the IO chip */
+
+static inline void open_io_config(void)
+{
+        outb(0x55, IOPORT);
+        mdelay(1);
+        outb(0x55, IOPORT);
+}
+
+/* lock the IO chip */
+static inline void close_io_config(void)
+{
+        outb(0xAA, IOPORT);
+}
+
+/* select the IO device */
+static inline void select_io_device(unsigned char devno)
+{
+        outb(0x07, IOPORT);
+        outb(devno, IOPORT+1);
+}
+
+/* write to the control register */
+static inline void write_io_cr(unsigned char reg, unsigned char data)
+{
+        outb(reg, IOPORT);
+        outb(data, IOPORT+1);
+}
+
+/* read from the control register */
+static inline char read_io_cr(unsigned char reg)
+{
+        outb(reg, IOPORT);
+        return inb(IOPORT+1);
+}
+
+/* -- Medium level functions ------------------------------------*/
+
+static inline void gpio_bit12(unsigned char reg)
+{
+        // -- General Purpose I/O Bit 1.2 --
+        // Bit 0,   In/Out: 0 = Output, 1 = Input
+        // Bit 1,   Polarity: 0 = No Invert, 1 = Invert
+        // Bit 2,   Group Enable Intr.: 0 = Disable, 1 = Enable
+        // Bit 3/4, Function select: 00 = GPI/O, 01 = WDT, 10 = P17,
+        //                           11 = Either Edge Triggered Intr. 2
+        // Bit 5/6  (Reserved)
+        // Bit 7,   Output Type: 0 = Push Pull Bit, 1 = Open Drain
+        write_io_cr(0xE2, reg);
+}
+
+static inline void gpio_bit13(unsigned char reg)
+{
+        // -- General Purpose I/O Bit 1.3 --
+        // Bit 0,  In/Out: 0 = Output, 1 = Input
+        // Bit 1,  Polarity: 0 = No Invert, 1 = Invert
+        // Bit 2,  Group Enable Intr.: 0 = Disable, 1 = Enable
+        // Bit 3,  Function select: 0 = GPI/O, 1 = LED
+        // Bit 4-6 (Reserved)
+        // Bit 7,  Output Type: 0 = Push Pull Bit, 1 = Open Drain
+        write_io_cr(0xE3, reg);
+}
+
+static inline void wdt_timer_units(unsigned char new_units)
+{
+        // -- Watchdog timer units --
+        // Bit 0-6 (Reserved)
+        // Bit 7,  WDT Time-out Value Units Select
+        //         (0 = Minutes, 1 = Seconds)
+        write_io_cr(0xF1, new_units);
+}
+
+static inline void wdt_timeout_value(unsigned char new_timeout)
+{
+        // -- Watchdog Timer Time-out Value --
+        // Bit 0-7 Binary coded units (0=Disabled, 1..255)
+        write_io_cr(0xF2, new_timeout);
+}
+
+static inline void wdt_timer_conf(unsigned char conf)
+{
+        // -- Watchdog timer configuration --
+        // Bit 0   Joystick enable: 0* = No Reset, 1 = Reset WDT upon Gameport I/O
+        // Bit 1   Keyboard enable: 0* = No Reset, 1 = Reset WDT upon KBD Intr.
+        // Bit 2   Mouse enable: 0* = No Reset, 1 = Reset WDT upon Mouse Intr.
+        // Bit 3   Reset the timer
+        //         (Wrong in SMsC documentation? Given as: PowerLED Timout Enabled)
+        // Bit 4-7 WDT Interrupt Mapping: (0000* = Disabled,
+        //            0001=IRQ1, 0010=(Invalid), 0011=IRQ3 to 1111=IRQ15)
+        write_io_cr(0xF3, conf);
+}
+
+static inline void wdt_timer_ctrl(unsigned char reg)
+{
+        // -- Watchdog timer control --
+        // Bit 0   Status Bit: 0 = Timer counting, 1 = Timeout occured
+        // Bit 1   Power LED Toggle: 0 = Disable Toggle, 1 = Toggle at 1 Hz
+        // Bit 2   Force Timeout: 1 = Forces WD timeout event (self-cleaning)
+        // Bit 3   P20 Force Timeout enabled:
+        //          0 = P20 activity does not generate the WD timeout event
+        //          1 = P20 Allows rising edge of P20, from the keyboard
+        //              controller, to force the WD timeout event.
+        // Bit 4   (Reserved)
+        // -- Soft power management --
+        // Bit 5   Stop Counter: 1 = Stop software power down counter
+        //            set via register 0xB8, (self-cleaning)
+        //            (Upon read: 0 = Counter running, 1 = Counter stopped)
+        // Bit 6   Restart Counter: 1 = Restart software power down counter
+        //            set via register 0xB8, (self-cleaning)
+        // Bit 7   SPOFF: 1 = Force software power down (self-cleaning)
+
+        write_io_cr(0xF4, reg);
+}
+
+/* -- Higher level functions ------------------------------------*/
+
+/* initialize watchdog */
+
+static void wb_smsc_wdt_initialize(void)
+{
+        unsigned char old;
+
+        spin_lock(&io_lock);
+        open_io_config();
+        select_io_device(IODEV_NO);
+
+        // enable the watchdog
+        gpio_bit13(0x08);  // Select pin 80 = LED not GPIO
+        gpio_bit12(0x0A);  // Set pin 79 = WDT not GPIO/Output/Polarity=Invert
+
+        // disable the timeout
+        wdt_timeout_value(0);
+
+        // reset control register
+        wdt_timer_ctrl(0x00);
+
+        // reset configuration register
+        wdt_timer_conf(0x00);
+
+        // read old (timer units) register
+        old = read_io_cr(0xF1) & 0x7F;
+        if (unit == UNIT_SECOND) old |= 0x80; // set to seconds
+
+        // set the watchdog timer units
+        wdt_timer_units(old);
+
+        close_io_config();
+        spin_unlock(&io_lock);
+}
+
+/* shutdown the watchdog */
+
+static void wb_smsc_wdt_shutdown(void)
+{
+        spin_lock(&io_lock);
+        open_io_config();
+        select_io_device(IODEV_NO);
+
+        // disable the watchdog
+        gpio_bit13(0x09);
+        gpio_bit12(0x09);
+
+        // reset watchdog config register
+        wdt_timer_conf(0x00);
+
+        // reset watchdog control register
+        wdt_timer_ctrl(0x00);
+
+        // disable timeout
+        wdt_timeout_value(0x00);
+
+        close_io_config();
+        spin_unlock(&io_lock);
+}
+
+/* set timeout => enable watchdog */
+
+static void wb_smsc_wdt_set_timeout(unsigned char new_timeout)
+{
+        spin_lock(&io_lock);
+        open_io_config();
+        select_io_device(IODEV_NO);
+
+        // set Power LED to blink, if we enable the timeout
+        wdt_timer_ctrl((new_timeout == 0) ? 0x00 : 0x02);
+
+        // set timeout value
+        wdt_timeout_value(new_timeout);
+
+        close_io_config();
+        spin_unlock(&io_lock);
+}
+
+/* get timeout */
+
+static unsigned char wb_smsc_wdt_get_timeout(void)
+{
+        unsigned char set_timeout;
+
+        spin_lock(&io_lock);
+        open_io_config();
+        select_io_device(IODEV_NO);
+        set_timeout = read_io_cr(0xF2);
+        close_io_config();
+        spin_unlock(&io_lock);
+
+        return set_timeout;
+}
+
+/* disable watchdog */
+
+static void wb_smsc_wdt_disable(void)
+{
+        // set the timeout to 0 to disable the watchdog
+        wb_smsc_wdt_set_timeout(0);
+}
+
+/* enable watchdog by setting the current timeout */
+
+static void wb_smsc_wdt_enable(void)
+{
+        // set the current timeout...
+        wb_smsc_wdt_set_timeout(timeout);
+}
+
+/* reset the timer */
+
+static void wb_smsc_wdt_reset_timer(void)
+{
+        spin_lock(&io_lock);
+        open_io_config();
+        select_io_device(IODEV_NO);
+
+        // reset the timer
+        wdt_timeout_value(timeout);
+        wdt_timer_conf(0x08);
+
+        close_io_config();
+        spin_unlock(&io_lock);
+}
+
+/* return, if the watchdog is enabled (timeout is set...) */
+
+static int wb_smsc_wdt_status(void)
+{
+        return (wb_smsc_wdt_get_timeout() == 0) ? 0 : WDIOF_KEEPALIVEPING;
+}
+
+
+/* -- File operations -------------------------------------------*/
+
+/* open => enable watchdog and set initial timeout */
+
+static int wb_smsc_wdt_open(struct inode *inode, struct file *file)
+{
+        /* /dev/watchdog can only be opened once */
+
+        if (test_and_set_bit(0, &timer_enabled))
+                return -EBUSY;
+
+        if (nowayout)
+                __module_get(THIS_MODULE);
+
+        /* Reload and activate timer */
+        wb_smsc_wdt_enable();
+
+        printk(KERN_INFO MODNAME "Watchdog enabled. Timeout set to %d %s.\n", timeout, (unit == UNIT_SECOND) ? "second(s)" : "minute(s)");
+
+        return nonseekable_open(inode, file);
+}
+
+/* close => shut off the timer */
+
+static int wb_smsc_wdt_release(struct inode *inode, struct file *file)
+{
+        /* Shut off the timer. */
+
+        if (expect_close == 42) {
+                wb_smsc_wdt_disable();
+                printk(KERN_INFO MODNAME "Watchdog disabled, sleeping again...\n");
+        } else {
+                printk(KERN_CRIT MODNAME "Unexpected close, not stopping watchdog!\n");
+                wb_smsc_wdt_reset_timer();
+        }
+
+        clear_bit(0, &timer_enabled);
+        expect_close = 0;
+        return 0;
+}
+
+/* write => update the timer to keep the machine alive */
+
+static ssize_t wb_smsc_wdt_write(struct file *file, const char __user *data,
+                                 size_t len, loff_t *ppos)
+{
+        /* See if we got the magic character 'V' and reload the timer */
+        if (len) {
+                if (!nowayout) {
+                        size_t i;
+
+                        /* reset expect flag */
+                        expect_close = 0;
+
+                        /* scan to see whether or not we got the magic character */
+                        for (i = 0; i != len; i++) {
+                                char c;
+                                if (get_user(c, data+i))
+                                        return -EFAULT;
+                                if (c == 'V')
+                                        expect_close = 42;
+                        }
+                }
+
+                /* someone wrote to us, we should reload the timer */
+                wb_smsc_wdt_reset_timer();
+        }
+        return len;
+}
+
+/* ioctl => control interface */
+
+static int wb_smsc_wdt_ioctl(struct inode *inode, struct file *file,
+                             unsigned int cmd, unsigned long arg)
+{
+        int new_timeout;
+
+        union {
+                struct watchdog_info __user *ident;
+                int __user *i;
+        } uarg;
+
+        static struct watchdog_info ident = {
+                .options =              WDIOF_KEEPALIVEPING |
+                                        WDIOF_SETTIMEOUT |
+                                        WDIOF_MAGICCLOSE,
+                .firmware_version =     0,
+                .identity =             "SMsC 37B787 Watchdog"
+        };
+
+        uarg.i = (int __user *)arg;
+
+        switch (cmd) {
+                default:
+                        return -ENOTTY;
+
+                case WDIOC_GETSUPPORT:
+                        return copy_to_user(uarg.ident, &ident,
+                                sizeof(ident)) ? -EFAULT : 0;
+
+                case WDIOC_GETSTATUS:
+                        return put_user(wb_smsc_wdt_status(), uarg.i);
+
+                case WDIOC_GETBOOTSTATUS:
+                        return put_user(0, uarg.i);
+
+                case WDIOC_KEEPALIVE:
+                        wb_smsc_wdt_reset_timer();
+                        return 0;
+
+                case WDIOC_SETTIMEOUT:
+                        if (get_user(new_timeout, uarg.i))
+                                return -EFAULT;
+
+                        // the API states this is given in secs
+                        if (unit == UNIT_MINUTE)
+                          new_timeout /= 60;
+
+                        if (new_timeout < 0 || new_timeout > MAX_TIMEOUT)
+                                return -EINVAL;
+
+                        timeout = new_timeout;
+                        wb_smsc_wdt_set_timeout(timeout);
+
+                        // fall through and return the new timeout...
+
+                case WDIOC_GETTIMEOUT:
+
+                        new_timeout = timeout;
+
+                        if (unit == UNIT_MINUTE)
+                          new_timeout *= 60;
+
+                        return put_user(new_timeout, uarg.i);
+
+                case WDIOC_SETOPTIONS:
+                {
+                        int options, retval = -EINVAL;
+
+                        if (get_user(options, uarg.i))
+                                return -EFAULT;
+
+                        if (options & WDIOS_DISABLECARD) {
+                                wb_smsc_wdt_disable();
+                                retval = 0;
+                        }
+
+                        if (options & WDIOS_ENABLECARD) {
+                                wb_smsc_wdt_enable();
+                                retval = 0;
+                        }
+
+                        return retval;
+                }
+        }
+}
+
+/* -- Notifier funtions -----------------------------------------*/
+
+static int wb_smsc_wdt_notify_sys(struct notifier_block *this, unsigned long code, void *unused)
+{
+        if (code == SYS_DOWN || code == SYS_HALT)
+        {
+                // set timeout to 0, to avoid possible race-condition
+                timeout = 0;
+                wb_smsc_wdt_disable();
+        }
+        return NOTIFY_DONE;
+}
+
+/* -- Module's structures ---------------------------------------*/
+
+static struct file_operations wb_smsc_wdt_fops =
+{
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .write          = wb_smsc_wdt_write,
+        .ioctl          = wb_smsc_wdt_ioctl,
+        .open           = wb_smsc_wdt_open,
+        .release        = wb_smsc_wdt_release,
+};
+
+static struct notifier_block wb_smsc_wdt_notifier =
+{
+        .notifier_call  = wb_smsc_wdt_notify_sys,
+};
+
+static struct miscdevice wb_smsc_wdt_miscdev =
+{
+        .minor          = WATCHDOG_MINOR,
+        .name           = "watchdog",
+        .fops           = &wb_smsc_wdt_fops,
+};
+
+/* -- Module init functions -------------------------------------*/
+
+/* module's "constructor" */
+
+static int __init wb_smsc_wdt_init(void)
+{
+        int ret;
+
+        spin_lock_init(&io_lock);
+
+        printk("SMsC 37B787 watchdog component driver " VERSION " initialising...\n");
+
+        if (!request_region(IOPORT, IOPORT_SIZE, "SMsC 37B787 watchdog")) {
+                printk(KERN_ERR MODNAME "Unable to register IO port %#x\n", IOPORT);
+                ret = -EBUSY;
+                goto out_pnp;
+        }
+
+        // set new maximum, if it's too big
+        if (timeout > MAX_TIMEOUT)
+               timeout = MAX_TIMEOUT;
+
+        // init the watchdog timer
+        wb_smsc_wdt_initialize();
+
+        ret = register_reboot_notifier(&wb_smsc_wdt_notifier);
+        if (ret) {
+                printk(KERN_ERR MODNAME "Unable to register reboot notifier err = %d\n", ret);
+                goto out_io;
+        }
+
+        ret = misc_register(&wb_smsc_wdt_miscdev);
+        if (ret) {
+                printk(KERN_ERR MODNAME "Unable to register miscdev on minor %d\n", WATCHDOG_MINOR);
+                goto out_rbt;
+        }
+
+        // output info
+        printk(KERN_INFO MODNAME "Timeout set to %d %s.\n", timeout, (unit == UNIT_SECOND) ? "second(s)" : "minute(s)");
+        printk(KERN_INFO MODNAME "Watchdog initialized and sleeping (nowayout=%d)...\n", nowayout);
+
+        // ret = 0
+
+out_clean:
+        return ret;
+
+out_rbt:
+        unregister_reboot_notifier(&wb_smsc_wdt_notifier);
+
+out_io:
+        release_region(IOPORT, IOPORT_SIZE);
+
+out_pnp:
+        goto out_clean;
+}
+
+/* module's "destructor" */
+
+static void __exit wb_smsc_wdt_exit(void)
+{
+        /* Stop the timer before we leave */
+        if (!nowayout)
+        {
+                wb_smsc_wdt_shutdown();
+                printk(KERN_INFO MODNAME "Watchdog disabled.\n");
+        }
+
+        misc_deregister(&wb_smsc_wdt_miscdev);
+        unregister_reboot_notifier(&wb_smsc_wdt_notifier);
+        release_region(IOPORT, IOPORT_SIZE);
+
+        printk("SMsC 37B787 watchdog component driver removed.\n");
+}
+
+module_init(wb_smsc_wdt_init);
+module_exit(wb_smsc_wdt_exit);
+
+MODULE_AUTHOR("Sven Anders <anders@anduras.de>");
+MODULE_DESCRIPTION("Driver for SMsC 37B787 watchdog component (Version " VERSION ")");
+MODULE_LICENSE("GPL");
+
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
+
+#ifdef SMSC_SUPPORT_MINUTES
+module_param(unit, int, 0);
+MODULE_PARM_DESC(unit, "set unit to use, 0=seconds or 1=minutes, default is 0");
+#endif
+
+module_param(timeout, int, 0);
+MODULE_PARM_DESC(timeout, "range is 1-255 units, default is 60");
+
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
diff --git a/drivers/char/watchdog/softdog.c b/drivers/char/watchdog/softdog.c
index ef8da517545a..4067e1f8a368 100644
--- a/drivers/char/watchdog/softdog.c
+++ b/drivers/char/watchdog/softdog.c
@@ -203,7 +203,7 @@ static int softdog_ioctl(struct inode *inode, struct file *file,
         };
         switch (cmd) {
                 default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
                 case WDIOC_GETSUPPORT:
                         return copy_to_user(argp, &ident,
                                 sizeof(ident)) ? -EFAULT : 0;
diff --git a/drivers/char/watchdog/w83627hf_wdt.c b/drivers/char/watchdog/w83627hf_wdt.c
index 13f16d41c2fd..07d4bff27226 100644
--- a/drivers/char/watchdog/w83627hf_wdt.c
+++ b/drivers/char/watchdog/w83627hf_wdt.c
@@ -33,6 +33,7 @@
 #include <linux/notifier.h>
 #include <linux/reboot.h>
 #include <linux/init.h>
+#include <linux/spinlock.h>
 
 #include <asm/io.h>
 #include <asm/uaccess.h>
@@ -44,6 +45,7 @@
 
 static unsigned long wdt_is_open;
 static char expect_close;
+static spinlock_t io_lock;
 
 /* You must set this - there is no sane way to probe for this board. */
 static int wdt_io = 0x2E;
@@ -110,12 +112,16 @@ w83627hf_init(void)
 static void
 wdt_ctrl(int timeout)
 {
+        spin_lock(&io_lock);
+        
         w83627hf_select_wd_register();
 
         outb_p(0xF6, WDT_EFER);    /* Select CRF6 */
         outb_p(timeout, WDT_EFDR); /* Write Timeout counter to CRF6 */
 
         w83627hf_unselect_wd_register();
+
+        spin_unlock(&io_lock);
 }
 
 static int
@@ -223,7 +229,7 @@ wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
         }
 
         default:
-          return -ENOIOCTLCMD;
+          return -ENOTTY;
         }
         return 0;
 }
@@ -303,6 +309,8 @@ wdt_init(void)
 {
         int ret;
 
+        spin_lock_init(&io_lock);
+
         printk(KERN_INFO "WDT driver for the Winbond(TM) W83627HF Super I/O chip initialising.\n");
 
         if (wdt_set_heartbeat(timeout)) {
diff --git a/drivers/char/watchdog/w83697hf_wdt.c b/drivers/char/watchdog/w83697hf_wdt.c
new file mode 100644
index 000000000000..7768b55487c8
--- /dev/null
+++ b/drivers/char/watchdog/w83697hf_wdt.c
@@ -0,0 +1,450 @@
+/*
+ *      w83697hf/hg WDT driver
+ *
+ *      (c) Copyright 2006 Samuel Tardieu <sam@rfc1149.net>
+ *      (c) Copyright 2006 Marcus Junker <junker@anduras.de>
+ *
+ *      Based on w83627hf_wdt.c which is based on advantechwdt.c
+ *      which is based on wdt.c.
+ *      Original copyright messages:
+ *
+ *      (c) Copyright 2003 Pádraig Brady <P@draigBrady.com>
+ *
+ *      (c) Copyright 2000-2001 Marek Michalkiewicz <marekm@linux.org.pl>
+ *
+ *      (c) Copyright 1996 Alan Cox <alan@redhat.com>, All Rights Reserved.
+ *                              http://www.redhat.com
+ *
+ *      This program is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU General Public License
+ *      as published by the Free Software Foundation; either version
+ *      2 of the License, or (at your option) any later version.
+ *
+ *      Neither Marcus Junker nor ANDURAS AG admit liability nor provide
+ *      warranty for any of this software. This material is provided
+ *      "AS-IS" and at no charge.
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/types.h>
+#include <linux/miscdevice.h>
+#include <linux/watchdog.h>
+#include <linux/fs.h>
+#include <linux/ioport.h>
+#include <linux/notifier.h>
+#include <linux/reboot.h>
+#include <linux/init.h>
+#include <linux/spinlock.h>
+
+#include <asm/io.h>
+#include <asm/uaccess.h>
+#include <asm/system.h>
+
+#define WATCHDOG_NAME "w83697hf/hg WDT"
+#define PFX WATCHDOG_NAME ": "
+#define WATCHDOG_TIMEOUT 60             /* 60 sec default timeout */
+
+static unsigned long wdt_is_open;
+static char expect_close;
+static spinlock_t io_lock;
+
+/* You must set this - there is no sane way to probe for this board. */
+static int wdt_io = 0x2e;
+module_param(wdt_io, int, 0);
+MODULE_PARM_DESC(wdt_io, "w83697hf/hg WDT io port (default 0x2e, 0 = autodetect)");
+
+static int timeout = WATCHDOG_TIMEOUT;  /* in seconds */
+module_param(timeout, int, 0);
+MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. 1<= timeout <=255, default=" __MODULE_STRING(WATCHDOG_TIMEOUT) ".");
+
+static int nowayout = WATCHDOG_NOWAYOUT;
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
+
+/*
+ *      Kernel methods.
+ */
+
+#define W83697HF_EFER (wdt_io+0)        /* Extended Function Enable Register */
+#define W83697HF_EFIR (wdt_io+0)        /* Extended Function Index Register (same as EFER) */
+#define W83697HF_EFDR (wdt_io+1)        /* Extended Function Data Register */
+
+static inline void
+w83697hf_unlock(void)
+{
+        outb_p(0x87, W83697HF_EFER);    /* Enter extended function mode */
+        outb_p(0x87, W83697HF_EFER);    /* Again according to manual */
+}
+
+static inline void
+w83697hf_lock(void)
+{
+        outb_p(0xAA, W83697HF_EFER);    /* Leave extended function mode */
+}
+
+/*
+ *      The three functions w83697hf_get_reg(), w83697hf_set_reg() and
+ *      w83697hf_write_timeout() must be called with the device unlocked.
+ */
+
+static unsigned char
+w83697hf_get_reg(unsigned char reg)
+{
+        outb_p(reg, W83697HF_EFIR);
+        return inb_p(W83697HF_EFDR);
+}
+
+static void
+w83697hf_set_reg(unsigned char reg, unsigned char data)
+{
+        outb_p(reg, W83697HF_EFIR);
+        outb_p(data, W83697HF_EFDR);
+}
+
+static void
+w83697hf_write_timeout(int timeout)
+{
+        w83697hf_set_reg(0xF4, timeout);        /* Write Timeout counter to CRF4 */
+}
+
+static void
+w83697hf_select_wdt(void)
+{
+        w83697hf_unlock();
+        w83697hf_set_reg(0x07, 0x08);   /* Switch to logic device 8 (GPIO2) */
+}
+
+static inline void
+w83697hf_deselect_wdt(void)
+{
+        w83697hf_lock();
+}
+
+static void
+w83697hf_init(void)
+{
+        unsigned char bbuf;
+
+        w83697hf_select_wdt();
+
+        bbuf = w83697hf_get_reg(0x29);
+        bbuf &= ~0x60;
+        bbuf |= 0x20;
+        w83697hf_set_reg(0x29, bbuf);   /* Set pin 119 to WDTO# mode (= CR29, WDT0) */
+
+        bbuf = w83697hf_get_reg(0xF3);
+        bbuf &= ~0x04;
+        w83697hf_set_reg(0xF3, bbuf);   /* Count mode is seconds */
+
+        w83697hf_deselect_wdt();
+}
+
+static int
+wdt_ping(void)
+{
+        spin_lock(&io_lock);
+        w83697hf_select_wdt();
+
+        w83697hf_write_timeout(timeout);
+
+        w83697hf_deselect_wdt();
+        spin_unlock(&io_lock);
+        return 0;
+}
+
+static int
+wdt_enable(void)
+{
+        spin_lock(&io_lock);
+        w83697hf_select_wdt();
+
+        w83697hf_write_timeout(timeout);
+        w83697hf_set_reg(0x30, 1);      /* Enable timer */
+
+        w83697hf_deselect_wdt();
+        spin_unlock(&io_lock);
+        return 0;
+}
+
+static int
+wdt_disable(void)
+{
+        spin_lock(&io_lock);
+        w83697hf_select_wdt();
+
+        w83697hf_set_reg(0x30, 0);      /* Disable timer */
+        w83697hf_write_timeout(0);
+
+        w83697hf_deselect_wdt();
+        spin_unlock(&io_lock);
+        return 0;
+}
+
+static int
+wdt_set_heartbeat(int t)
+{
+        if ((t < 1) || (t > 255))
+                return -EINVAL;
+
+        timeout = t;
+        return 0;
+}
+
+static ssize_t
+wdt_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
+{
+        if (count) {
+                if (!nowayout) {
+                        size_t i;
+
+                        expect_close = 0;
+
+                        for (i = 0; i != count; i++) {
+                                char c;
+                                if (get_user(c, buf+i))
+                                        return -EFAULT;
+                                if (c == 'V')
+                                        expect_close = 42;
+                        }
+                }
+                wdt_ping();
+        }
+        return count;
+}
+
+static int
+wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
+          unsigned long arg)
+{
+        void __user *argp = (void __user *)arg;
+        int __user *p = argp;
+        int new_timeout;
+        static struct watchdog_info ident = {
+                .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,
+                .firmware_version = 1,
+                .identity = "W83697HF WDT",
+        };
+
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                if (copy_to_user(argp, &ident, sizeof(ident)))
+                        return -EFAULT;
+                break;
+
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, p);
+
+        case WDIOC_KEEPALIVE:
+                wdt_ping();
+                break;
+
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_timeout, p))
+                        return -EFAULT;
+                if (wdt_set_heartbeat(new_timeout))
+                        return -EINVAL;
+                wdt_ping();
+                /* Fall */
+
+        case WDIOC_GETTIMEOUT:
+                return put_user(timeout, p);
+
+        case WDIOC_SETOPTIONS:
+        {
+                int options, retval = -EINVAL;
+
+                if (get_user(options, p))
+                        return -EFAULT;
+
+                if (options & WDIOS_DISABLECARD) {
+                        wdt_disable();
+                        retval = 0;
+                }
+
+                if (options & WDIOS_ENABLECARD) {
+                        wdt_enable();
+                        retval = 0;
+                }
+
+                return retval;
+        }
+
+        default:
+                return -ENOTTY;
+        }
+        return 0;
+}
+
+static int
+wdt_open(struct inode *inode, struct file *file)
+{
+        if (test_and_set_bit(0, &wdt_is_open))
+                return -EBUSY;
+        /*
+         *      Activate
+         */
+
+        wdt_enable();
+        return nonseekable_open(inode, file);
+}
+
+static int
+wdt_close(struct inode *inode, struct file *file)
+{
+        if (expect_close == 42) {
+                wdt_disable();
+        } else {
+                printk (KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");
+                wdt_ping();
+        }
+        expect_close = 0;
+        clear_bit(0, &wdt_is_open);
+        return 0;
+}
+
+/*
+ *      Notifier for system down
+ */
+
+static int
+wdt_notify_sys(struct notifier_block *this, unsigned long code,
+        void *unused)
+{
+        if (code == SYS_DOWN || code == SYS_HALT) {
+                /* Turn the WDT off */
+                wdt_disable();
+        }
+        return NOTIFY_DONE;
+}
+
+/*
+ *      Kernel Interfaces
+ */
+
+static struct file_operations wdt_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .write          = wdt_write,
+        .ioctl          = wdt_ioctl,
+        .open           = wdt_open,
+        .release        = wdt_close,
+};
+
+static struct miscdevice wdt_miscdev = {
+        .minor = WATCHDOG_MINOR,
+        .name = "watchdog",
+        .fops = &wdt_fops,
+};
+
+/*
+ *      The WDT needs to learn about soft shutdowns in order to
+ *      turn the timebomb registers off.
+ */
+
+static struct notifier_block wdt_notifier = {
+        .notifier_call = wdt_notify_sys,
+};
+
+static int
+w83697hf_check_wdt(void)
+{
+        if (!request_region(wdt_io, 2, WATCHDOG_NAME)) {
+                printk (KERN_ERR PFX "I/O address 0x%x already in use\n", wdt_io);
+                return -EIO;
+        }
+
+        printk (KERN_DEBUG PFX "Looking for watchdog at address 0x%x\n", wdt_io);
+        w83697hf_unlock();
+        if (w83697hf_get_reg(0x20) == 0x60) {
+                printk (KERN_INFO PFX "watchdog found at address 0x%x\n", wdt_io);
+                w83697hf_lock();
+                return 0;
+        }
+        w83697hf_lock();        /* Reprotect in case it was a compatible device */
+
+        printk (KERN_INFO PFX "watchdog not found at address 0x%x\n", wdt_io);
+        release_region(wdt_io, 2);
+        return -EIO;
+}
+
+static int w83697hf_ioports[] = { 0x2e, 0x4e, 0x00 };
+
+static int __init
+wdt_init(void)
+{
+        int ret, i, found = 0;
+
+        spin_lock_init(&io_lock);
+
+        printk (KERN_INFO PFX "WDT driver for W83697HF/HG initializing\n");
+
+        if (wdt_io == 0) {
+                /* we will autodetect the W83697HF/HG watchdog */
+                for (i = 0; ((!found) && (w83697hf_ioports[i] != 0)); i++) {
+                        wdt_io = w83697hf_ioports[i];
+                        if (!w83697hf_check_wdt())
+                                found++;
+                }
+        } else {
+                if (!w83697hf_check_wdt())
+                        found++;
+        }
+
+        if (!found) {
+                printk (KERN_ERR PFX "No W83697HF/HG could be found\n");
+                ret = -EIO;
+                goto out;
+        }
+
+        w83697hf_init();
+        wdt_disable();  /* Disable watchdog until first use */
+
+        if (wdt_set_heartbeat(timeout)) {
+                wdt_set_heartbeat(WATCHDOG_TIMEOUT);
+                printk (KERN_INFO PFX "timeout value must be 1<=timeout<=255, using %d\n",
+                        WATCHDOG_TIMEOUT);
+        }
+
+        ret = register_reboot_notifier(&wdt_notifier);
+        if (ret != 0) {
+                printk (KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
+                        ret);
+                goto unreg_regions;
+        }
+
+        ret = misc_register(&wdt_miscdev);
+        if (ret != 0) {
+                printk (KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
+                        WATCHDOG_MINOR, ret);
+                goto unreg_reboot;
+        }
+
+        printk (KERN_INFO PFX "initialized. timeout=%d sec (nowayout=%d)\n",
+                timeout, nowayout);
+
+out:
+        return ret;
+unreg_reboot:
+        unregister_reboot_notifier(&wdt_notifier);
+unreg_regions:
+        release_region(wdt_io, 2);
+        goto out;
+}
+
+static void __exit
+wdt_exit(void)
+{
+        misc_deregister(&wdt_miscdev);
+        unregister_reboot_notifier(&wdt_notifier);
+        release_region(wdt_io, 2);
+}
+
+module_init(wdt_init);
+module_exit(wdt_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Marcus Junker <junker@anduras.de>, Samuel Tardieu <sam@rfc1149.net>");
+MODULE_DESCRIPTION("w83697hf/hg WDT driver");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/char/watchdog/w83877f_wdt.c b/drivers/char/watchdog/w83877f_wdt.c
index ccf6c0915945..b0e5f84d6baf 100644
--- a/drivers/char/watchdog/w83877f_wdt.c
+++ b/drivers/char/watchdog/w83877f_wdt.c
@@ -252,7 +252,7 @@ static int fop_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
         switch(cmd)
         {
                 default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
                 case WDIOC_GETSUPPORT:
                         return copy_to_user(argp, &ident, sizeof(ident))?-EFAULT:0;
                 case WDIOC_GETSTATUS:
diff --git a/drivers/char/watchdog/w83977f_wdt.c b/drivers/char/watchdog/w83977f_wdt.c
index 98f4e17db70a..2c8d5d8bd4e8 100644
--- a/drivers/char/watchdog/w83977f_wdt.c
+++ b/drivers/char/watchdog/w83977f_wdt.c
@@ -393,7 +393,7 @@ static int wdt_ioctl(struct inode *inode, struct file *file,
         switch(cmd)
         {
         default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
 
         case WDIOC_GETSUPPORT:
                 return copy_to_user(uarg.ident, &ident, sizeof(ident)) ? -EFAULT : 0;
diff --git a/drivers/char/watchdog/wafer5823wdt.c b/drivers/char/watchdog/wafer5823wdt.c
index 2bb6a9d6ad28..163e028ef9ed 100644
--- a/drivers/char/watchdog/wafer5823wdt.c
+++ b/drivers/char/watchdog/wafer5823wdt.c
@@ -174,7 +174,7 @@ static int wafwdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd
         }
 
         default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
         }
         return 0;
 }
diff --git a/drivers/char/watchdog/wdrtas.c b/drivers/char/watchdog/wdrtas.c
index 5c38cdf41731..1d64e277567d 100644
--- a/drivers/char/watchdog/wdrtas.c
+++ b/drivers/char/watchdog/wdrtas.c
@@ -385,7 +385,7 @@ wdrtas_ioctl(struct inode *inode, struct file *file,
                 return put_user(wdrtas_interval, argp);
 
         default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
         }
 }
 
diff --git a/drivers/char/watchdog/wdt.c b/drivers/char/watchdog/wdt.c
index 70be81e39a61..517fbd8643f8 100644
--- a/drivers/char/watchdog/wdt.c
+++ b/drivers/char/watchdog/wdt.c
@@ -225,14 +225,13 @@ static int wdt_get_temperature(int *temperature)
  *      wdt_interrupt:
  *      @irq:           Interrupt number
  *      @dev_id:        Unused as we don't allow multiple devices.
- *      @regs:          Unused.
  *
  *      Handle an interrupt from the board. These are raised when the status
  *      map changes in what the board considers an interesting way. That means
  *      a failure condition occurring.
  */
 
-static irqreturn_t wdt_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t wdt_interrupt(int irq, void *dev_id)
 {
         /*
          *      Read the status register see what is up and
@@ -341,7 +340,7 @@ static int wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
         switch(cmd)
         {
                 default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
                 case WDIOC_GETSUPPORT:
                         return copy_to_user(argp, &ident, sizeof(ident))?-EFAULT:0;
 
diff --git a/drivers/char/watchdog/wdt285.c b/drivers/char/watchdog/wdt285.c
index 6555fb844f23..e4cf661dc890 100644
--- a/drivers/char/watchdog/wdt285.c
+++ b/drivers/char/watchdog/wdt285.c
@@ -46,7 +46,7 @@ static unsigned long timer_alive;
 /*
  *      If the timer expires..
  */
-static void watchdog_fire(int irq, void *dev_id, struct pt_regs *regs)
+static void watchdog_fire(int irq, void *dev_id)
 {
         printk(KERN_CRIT "Watchdog: Would Reboot.\n");
         *CSR_TIMER4_CNTL = 0;
@@ -137,7 +137,7 @@ watchdog_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                unsigned long arg)
 {
         unsigned int new_margin;
-        int ret = -ENOIOCTLCMD;
+        int ret = -ENOTTY;
 
         switch(cmd) {
         case WDIOC_GETSUPPORT:
diff --git a/drivers/char/watchdog/wdt977.c b/drivers/char/watchdog/wdt977.c
index a0935bc775f8..6253041b235b 100644
--- a/drivers/char/watchdog/wdt977.c
+++ b/drivers/char/watchdog/wdt977.c
@@ -361,7 +361,7 @@ static int wdt977_ioctl(struct inode *inode, struct file *file,
         switch(cmd)
         {
         default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
 
         case WDIOC_GETSUPPORT:
                 return copy_to_user(uarg.ident, &ident,
diff --git a/drivers/char/watchdog/wdt_pci.c b/drivers/char/watchdog/wdt_pci.c
index 5918ca2c9c35..ce1261c5cbce 100644
--- a/drivers/char/watchdog/wdt_pci.c
+++ b/drivers/char/watchdog/wdt_pci.c
@@ -270,14 +270,13 @@ static int wdtpci_get_temperature(int *temperature)
  *      wdtpci_interrupt:
  *      @irq:           Interrupt number
  *      @dev_id:        Unused as we don't allow multiple devices.
- *      @regs:          Unused.
  *
  *      Handle an interrupt from the board. These are raised when the status
  *      map changes in what the board considers an interesting way. That means
  *      a failure condition occurring.
  */
 
-static irqreturn_t wdtpci_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t wdtpci_interrupt(int irq, void *dev_id)
 {
         /*
          *      Read the status register see what is up and
@@ -386,7 +385,7 @@ static int wdtpci_ioctl(struct inode *inode, struct file *file, unsigned int cmd
         switch(cmd)
         {
                 default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
                 case WDIOC_GETSUPPORT:
                         return copy_to_user(argp, &ident, sizeof(ident))?-EFAULT:0;