202 files changed, 3980 insertions, 4141 deletions

diff --git a/drivers/base/core.c b/drivers/base/core.c
index fd8059920dbf..6b355bd7816d 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -161,8 +161,8 @@ static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,
         return count;
 }
 
-/**
- *      device_subsys - structure to be registered with kobject core.
+/*
+ *      devices_subsys - structure to be registered with kobject core.
  */
 
 decl_subsys(devices, &ktype_device, &device_uevent_ops);
diff --git a/drivers/base/cpu.c b/drivers/base/cpu.c
index 281d26784d25..07a7f97e1de9 100644
--- a/drivers/base/cpu.c
+++ b/drivers/base/cpu.c
@@ -83,6 +83,31 @@ static inline void register_cpu_control(struct cpu *cpu)
 }
 #endif /* CONFIG_HOTPLUG_CPU */
 
+#ifdef CONFIG_KEXEC
+#include <linux/kexec.h>
+
+static ssize_t show_crash_notes(struct sys_device *dev, char *buf)
+{
+        struct cpu *cpu = container_of(dev, struct cpu, sysdev);
+        ssize_t rc;
+        unsigned long long addr;
+        int cpunum;
+
+        cpunum = cpu->sysdev.id;
+
+        /*
+         * Might be reading other cpu's data based on which cpu read thread
+         * has been scheduled. But cpu data (memory) is allocated once during
+         * boot up and this data does not change there after. Hence this
+         * operation should be safe. No locking required.
+         */
+        addr = __pa(per_cpu_ptr(crash_notes, cpunum));
+        rc = sprintf(buf, "%Lx\n", addr);
+        return rc;
+}
+static SYSDEV_ATTR(crash_notes, 0400, show_crash_notes, NULL);
+#endif
+
 /*
  * register_cpu - Setup a driverfs device for a CPU.
  * @cpu - Callers can set the cpu->no_control field to 1, to indicate not to
@@ -108,6 +133,11 @@ int __devinit register_cpu(struct cpu *cpu, int num, struct node *root)
                 register_cpu_control(cpu);
         if (!error)
                 cpu_sys_devices[num] = &cpu->sysdev;
+
+#ifdef CONFIG_KEXEC
+        if (!error)
+                error = sysdev_create_file(&cpu->sysdev, &attr_crash_notes);
+#endif
         return error;
 }
 
diff --git a/drivers/bluetooth/hci_ldisc.c b/drivers/bluetooth/hci_ldisc.c
index 573ff6c1be5f..613673b12fa6 100644
--- a/drivers/bluetooth/hci_ldisc.c
+++ b/drivers/bluetooth/hci_ldisc.c
@@ -279,6 +279,7 @@ static int hci_uart_tty_open(struct tty_struct *tty)
 
         tty->disc_data = hu;
         hu->tty = tty;
+        tty->receive_room = 65536;
 
         spin_lock_init(&hu->rx_lock);
 
@@ -348,20 +349,6 @@ static void hci_uart_tty_wakeup(struct tty_struct *tty)
                 hci_uart_tx_wakeup(hu);
 }
 
-/* hci_uart_tty_room()
- * 
- *    Callback function from tty driver. Return the amount of 
- *    space left in the receiver's buffer to decide if remote
- *    transmitter is to be throttled.
- *
- * Arguments:        tty    pointer to associated tty instance data
- * Return Value:    number of bytes left in receive buffer
- */
-static int hci_uart_tty_room (struct tty_struct *tty)
-{
-        return 65536;
-}
-
 /* hci_uart_tty_receive()
  * 
  *     Called by tty low level driver when receive data is
@@ -544,7 +531,6 @@ static int __init hci_uart_init(void)
         hci_uart_ldisc.write            = hci_uart_tty_write;
         hci_uart_ldisc.ioctl            = hci_uart_tty_ioctl;
         hci_uart_ldisc.poll             = hci_uart_tty_poll;
-        hci_uart_ldisc.receive_room     = hci_uart_tty_room;
         hci_uart_ldisc.receive_buf      = hci_uart_tty_receive;
         hci_uart_ldisc.write_wakeup     = hci_uart_tty_wakeup;
         hci_uart_ldisc.owner            = THIS_MODULE;
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index dd7e6901c575..d6fcd0a36f9f 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -80,7 +80,7 @@ config SERIAL_NONSTANDARD
 
 config COMPUTONE
         tristate "Computone IntelliPort Plus serial support"
-        depends on SERIAL_NONSTANDARD && BROKEN_ON_SMP
+        depends on SERIAL_NONSTANDARD
         ---help---
           This driver supports the entire family of Intelliport II/Plus
           controllers with the exception of the MicroChannel controllers and
@@ -153,7 +153,7 @@ config DIGIEPCA
 
 config ESPSERIAL
         tristate "Hayes ESP serial port support"
-        depends on SERIAL_NONSTANDARD && ISA && BROKEN_ON_SMP && ISA_DMA_API
+        depends on SERIAL_NONSTANDARD && ISA && ISA_DMA_API
         help
           This is a driver which supports Hayes ESP serial ports.  Both single
           port cards and multiport cards are supported.  Make sure to read
@@ -166,7 +166,7 @@ config ESPSERIAL
 
 config MOXA_INTELLIO
         tristate "Moxa Intellio support"
-        depends on SERIAL_NONSTANDARD && BROKEN_ON_SMP
+        depends on SERIAL_NONSTANDARD
         help
           Say Y here if you have a Moxa Intellio multiport serial card.
 
@@ -290,7 +290,7 @@ config SX
 
 config RIO
         tristate "Specialix RIO system support"
-        depends on SERIAL_NONSTANDARD && BROKEN_ON_SMP
+        depends on SERIAL_NONSTANDARD && BROKEN_ON_SMP && !64BIT
         help
           This is a driver for the Specialix RIO, a smart serial card which
           drives an outboard box that can support up to 128 ports.  Product
@@ -936,6 +936,15 @@ config SCx200_GPIO
 
           If compiled as a module, it will be called scx200_gpio.
 
+config CS5535_GPIO
+        tristate "AMD CS5535/CS5536 GPIO (Geode Companion Device)"
+        depends on X86_32
+        help
+          Give userspace access to the GPIO pins on the AMD CS5535 and
+          CS5536 Geode companion devices.
+
+          If compiled as a module, it will be called cs5535_gpio.
+
 config GPIO_VR41XX
         tristate "NEC VR4100 series General-purpose I/O Unit support"
         depends on CPU_VR41XX
diff --git a/drivers/char/Makefile b/drivers/char/Makefile
index d973d14d8f7f..503dd901d406 100644
--- a/drivers/char/Makefile
+++ b/drivers/char/Makefile
@@ -81,6 +81,7 @@ obj-$(CONFIG_PPDEV) += ppdev.o
 obj-$(CONFIG_NWBUTTON) += nwbutton.o
 obj-$(CONFIG_NWFLASH) += nwflash.o
 obj-$(CONFIG_SCx200_GPIO) += scx200_gpio.o
+obj-$(CONFIG_CS5535_GPIO) += cs5535_gpio.o
 obj-$(CONFIG_GPIO_VR41XX) += vr41xx_giu.o
 obj-$(CONFIG_TANBAC_TB0219) += tb0219.o
 obj-$(CONFIG_TELCLOCK) += tlclk.o
diff --git a/drivers/char/amiserial.c b/drivers/char/amiserial.c
index a124f8c5d062..869518e4035f 100644
--- a/drivers/char/amiserial.c
+++ b/drivers/char/amiserial.c
@@ -116,7 +116,7 @@ static void rs_wait_until_sent(struct tty_struct *tty, int timeout);
 
 static struct serial_state rs_table[1];
 
-#define NR_PORTS        (sizeof(rs_table)/sizeof(struct serial_state))
+#define NR_PORTS ARRAY_SIZE(rs_table)
 
 /*
  * tmp_buf is used as a temporary buffer by serial_write.  We need to
@@ -265,8 +265,9 @@ static _INLINE_ void receive_chars(struct async_struct *info)
         int status;
         int serdatr;
         struct tty_struct *tty = info->tty;
-        unsigned char ch;
+        unsigned char ch, flag;
         struct  async_icount *icount;
+        int oe = 0;
 
         icount = &info->state->icount;
 
@@ -282,15 +283,12 @@ static _INLINE_ void receive_chars(struct async_struct *info)
             status |= UART_LSR_OE;
 
         ch = serdatr & 0xff;
-        if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-          goto ignore_char;
-        *tty->flip.char_buf_ptr = ch;
         icount->rx++;
 
 #ifdef SERIAL_DEBUG_INTR
         printk("DR%02x:%02x...", ch, status);
 #endif
-        *tty->flip.flag_buf_ptr = 0;
+        flag = TTY_NORMAL;
 
         /*
          * We don't handle parity or frame errors - but I have left
@@ -319,7 +317,7 @@ static _INLINE_ void receive_chars(struct async_struct *info)
            * should be ignored.
            */
           if (status & info->ignore_status_mask)
-            goto ignore_char;
+            goto out;
 
           status &= info->read_status_mask;
 
@@ -327,33 +325,28 @@ static _INLINE_ void receive_chars(struct async_struct *info)
 #ifdef SERIAL_DEBUG_INTR
             printk("handling break....");
 #endif
-            *tty->flip.flag_buf_ptr = TTY_BREAK;
+            flag = TTY_BREAK;
             if (info->flags & ASYNC_SAK)
               do_SAK(tty);
           } else if (status & UART_LSR_PE)
-            *tty->flip.flag_buf_ptr = TTY_PARITY;
+            flag = TTY_PARITY;
           else if (status & UART_LSR_FE)
-            *tty->flip.flag_buf_ptr = TTY_FRAME;
+            flag = TTY_FRAME;
           if (status & UART_LSR_OE) {
             /*
              * Overrun is special, since it's
              * reported immediately, and doesn't
              * affect the current character
              */
-            if (tty->flip.count < TTY_FLIPBUF_SIZE) {
-              tty->flip.count++;
-              tty->flip.flag_buf_ptr++;
-              tty->flip.char_buf_ptr++;
-              *tty->flip.flag_buf_ptr = TTY_OVERRUN;
-            }
+             oe = 1;
           }
         }
-        tty->flip.flag_buf_ptr++;
-        tty->flip.char_buf_ptr++;
-        tty->flip.count++;
- ignore_char:
-
+        tty_insert_flip_char(tty, ch, flag);
+        if (oe == 1)
+                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
         tty_flip_buffer_push(tty);
+out:
+        return;
 }
 
 static _INLINE_ void transmit_chars(struct async_struct *info)
diff --git a/drivers/char/cs5535_gpio.c b/drivers/char/cs5535_gpio.c
new file mode 100644
index 000000000000..5d72f50de1ac
--- /dev/null
+++ b/drivers/char/cs5535_gpio.c
@@ -0,0 +1,250 @@
+/*
+ * AMD CS5535/CS5536 GPIO driver.
+ * Allows a user space process to play with the GPIO pins.
+ *
+ * Copyright (c) 2005 Ben Gardner <bgardner@wabtec.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the smems of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ */
+
+#include <linux/fs.h>
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/cdev.h>
+#include <linux/ioport.h>
+#include <linux/pci.h>
+#include <asm/uaccess.h>
+#include <asm/io.h>
+
+
+#define NAME                    "cs5535_gpio"
+
+MODULE_AUTHOR("Ben Gardner <bgardner@wabtec.com>");
+MODULE_DESCRIPTION("AMD CS5535/CS5536 GPIO Pin Driver");
+MODULE_LICENSE("GPL");
+
+static int major;
+module_param(major, int, 0);
+MODULE_PARM_DESC(major, "Major device number");
+
+static ulong mask;
+module_param(mask, ulong, 0);
+MODULE_PARM_DESC(mask, "GPIO channel mask");
+
+#define MSR_LBAR_GPIO           0x5140000C
+
+static u32 gpio_base;
+
+static struct pci_device_id divil_pci[] = {
+        { PCI_DEVICE(PCI_VENDOR_ID_NS,  PCI_DEVICE_ID_NS_CS5535_ISA) },
+        { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_ISA) },
+        { } /* NULL entry */
+};
+
+static struct cdev cs5535_gpio_cdev;
+
+/* reserve 32 entries even though some aren't usable */
+#define CS5535_GPIO_COUNT       32
+
+/* IO block size */
+#define CS5535_GPIO_SIZE        256
+
+struct gpio_regmap {
+        u32     rd_offset;
+        u32     wr_offset;
+        char    on;
+        char    off;
+};
+static struct gpio_regmap rm[] =
+{
+        { 0x30, 0x00, '1', '0' },       /* GPIOx_READ_BACK / GPIOx_OUT_VAL */
+        { 0x20, 0x20, 'I', 'i' },       /* GPIOx_IN_EN */
+        { 0x04, 0x04, 'O', 'o' },       /* GPIOx_OUT_EN */
+        { 0x08, 0x08, 't', 'T' },       /* GPIOx_OUT_OD_EN */
+        { 0x18, 0x18, 'P', 'p' },       /* GPIOx_OUT_PU_EN */
+        { 0x1c, 0x1c, 'D', 'd' },       /* GPIOx_OUT_PD_EN */
+};
+
+
+/**
+ * Gets the register offset for the GPIO bank.
+ * Low (0-15) starts at 0x00, high (16-31) starts at 0x80
+ */
+static inline u32 cs5535_lowhigh_base(int reg)
+{
+        return (reg & 0x10) << 3;
+}
+
+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);
+        int     i, j;
+        u32     base = gpio_base + cs5535_lowhigh_base(m);
+        u32     m0, m1;
+        char    c;
+
+        /**
+         * Creates the mask for atomic bit programming.
+         * The high 16 bits and the low 16 bits are used to set the mask.
+         * For example, GPIO 15 maps to 31,15: 0,1 => On; 1,0=> Off
+         */
+        m1 = 1 << (m & 0x0F);
+        m0 = m1 << 16;
+
+        for (i = 0; i < len; ++i) {
+                if (get_user(c, data+i))
+                        return -EFAULT;
+
+                for (j = 0; j < ARRAY_SIZE(rm); j++) {
+                        if (c == rm[j].on) {
+                                outl(m1, base + rm[j].wr_offset);
+                                break;
+                        } else if (c == rm[j].off) {
+                                outl(m0, base + rm[j].wr_offset);
+                                break;
+                        }
+                }
+        }
+        *ppos = 0;
+        return len;
+}
+
+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     base = gpio_base + cs5535_lowhigh_base(m);
+        int     rd_bit = 1 << (m & 0x0f);
+        int     i;
+        char    ch;
+        ssize_t count = 0;
+
+        if (*ppos >= ARRAY_SIZE(rm))
+                return 0;
+
+        for (i = *ppos; (i < (*ppos + len)) && (i < ARRAY_SIZE(rm)); i++) {
+                ch = (inl(base + rm[i].rd_offset) & rd_bit) ?
+                     rm[i].on : rm[i].off;
+
+                if (put_user(ch, buf+count))
+                        return -EFAULT;
+
+                count++;
+        }
+
+        /* add a line-feed if there is room */
+        if ((i == ARRAY_SIZE(rm)) && (count < len)) {
+                put_user('\n', buf + count);
+                count++;
+        }
+
+        *ppos += count;
+        return count;
+}
+
+static int cs5535_gpio_open(struct inode *inode, struct file *file)
+{
+        u32 m = iminor(inode);
+
+        /* the mask says which pins are usable by this driver */
+        if ((mask & (1 << m)) == 0)
+                return -EINVAL;
+
+        return nonseekable_open(inode, file);
+}
+
+static struct file_operations cs5535_gpio_fops = {
+        .owner  = THIS_MODULE,
+        .write  = cs5535_gpio_write,
+        .read   = cs5535_gpio_read,
+        .open   = cs5535_gpio_open
+};
+
+static int __init cs5535_gpio_init(void)
+{
+        dev_t   dev_id;
+        u32     low, hi;
+        int     retval;
+
+        if (pci_dev_present(divil_pci) == 0) {
+                printk(KERN_WARNING NAME ": DIVIL not found\n");
+                return -ENODEV;
+        }
+
+        /* Grab the GPIO I/O range */
+        rdmsr(MSR_LBAR_GPIO, low, hi);
+
+        /* Check the mask and whether GPIO is enabled (sanity check) */
+        if (hi != 0x0000f001) {
+                printk(KERN_WARNING NAME ": GPIO not enabled\n");
+                return -ENODEV;
+        }
+
+        /* Mask off the IO base address */
+        gpio_base = low & 0x0000ff00;
+
+        /**
+         * Some GPIO pins
+         *  31-29,23 : reserved (always mask out)
+         *  28       : Power Button
+         *  26       : PME#
+         *  22-16    : LPC
+         *  14,15    : SMBus
+         *  9,8      : UART1
+         *  7        : PCI INTB
+         *  3,4      : UART2/DDC
+         *  2        : IDE_IRQ0
+         *  0        : PCI INTA
+         *
+         * If a mask was not specified, be conservative and only allow:
+         *  1,2,5,6,10-13,24,25,27
+         */
+        if (mask != 0)
+                mask &= 0x1f7fffff;
+        else
+                mask = 0x0b003c66;
+
+        if (request_region(gpio_base, CS5535_GPIO_SIZE, NAME) == 0) {
+                printk(KERN_ERR NAME ": can't allocate I/O for GPIO\n");
+                return -ENODEV;
+        }
+
+        if (major) {
+                dev_id = MKDEV(major, 0);
+                retval = register_chrdev_region(dev_id, CS5535_GPIO_COUNT,
+                                                NAME);
+        } else {
+                retval = alloc_chrdev_region(&dev_id, 0, CS5535_GPIO_COUNT,
+                                             NAME);
+                major = MAJOR(dev_id);
+        }
+
+        if (retval) {
+                release_region(gpio_base, CS5535_GPIO_SIZE);
+                return -1;
+        }
+
+        printk(KERN_DEBUG NAME ": base=%#x mask=%#lx major=%d\n",
+               gpio_base, mask, major);
+
+        cdev_init(&cs5535_gpio_cdev, &cs5535_gpio_fops);
+        cdev_add(&cs5535_gpio_cdev, dev_id, CS5535_GPIO_COUNT);
+
+        return 0;
+}
+
+static void __exit cs5535_gpio_cleanup(void)
+{
+        dev_t dev_id = MKDEV(major, 0);
+        unregister_chrdev_region(dev_id, CS5535_GPIO_COUNT);
+        if (gpio_base != 0)
+                release_region(gpio_base, CS5535_GPIO_SIZE);
+}
+
+module_init(cs5535_gpio_init);
+module_exit(cs5535_gpio_cleanup);
diff --git a/drivers/char/cyclades.c b/drivers/char/cyclades.c
index c7f818cd7b02..39c61a71176e 100644
--- a/drivers/char/cyclades.c
+++ b/drivers/char/cyclades.c
@@ -641,6 +641,7 @@ static char rcsid[] =
 #include <linux/timer.h>
 #include <linux/interrupt.h>
 #include <linux/tty.h>
+#include <linux/tty_flip.h>
 #include <linux/serial.h>
 #include <linux/major.h>
 #include <linux/string.h>
@@ -723,7 +724,7 @@ static unsigned int cy_isa_addresses[] = {
         0xDE000,
         0,0,0,0,0,0,0,0
 };
-#define NR_ISA_ADDRS (sizeof(cy_isa_addresses)/sizeof(unsigned char*))
+#define NR_ISA_ADDRS ARRAY_SIZE(cy_isa_addresses)
 
 #ifdef MODULE
 static long maddr[NR_CARDS] = { 0, };
@@ -1086,7 +1087,7 @@ cyy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
   int had_work;
   int mdm_change;
   int mdm_status;
-
+  int len;
     if((cinfo = (struct cyclades_card *)dev_id) == 0){
 #ifdef CY_DEBUG_INTERRUPTS
         printk("cyy_interrupt: spurious interrupt %d\n\r", irq);
@@ -1163,63 +1164,43 @@ cyy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                                 info->icount.rx++;
                                 continue;
                             }
-                            if (tty->flip.count < TTY_FLIPBUF_SIZE){
-                                tty->flip.count++;
+                            if (tty_buffer_request_room(tty, 1)) {
                                 if (data & info->read_status_mask){
                                     if(data & CyBREAK){
-                                        *tty->flip.flag_buf_ptr++ =
-                                                            TTY_BREAK;
-                                        *tty->flip.char_buf_ptr++ =
-                                          cy_readb(base_addr+(CyRDSR<<index));
+                                        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->flip.flag_buf_ptr++ =
-                                                            TTY_FRAME;
-                                        *tty->flip.char_buf_ptr++ =
-                                          cy_readb(base_addr+(CyRDSR<<index));
+                                        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){
-                                        *tty->flip.flag_buf_ptr++ =
-                                                            TTY_PARITY;
-                                        *tty->flip.char_buf_ptr++ =
-                                          cy_readb(base_addr+(CyRDSR<<index));
+                                        /* 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->flip.flag_buf_ptr++ =
-                                                            TTY_OVERRUN;
-                                        *tty->flip.char_buf_ptr++ = 0;
+                                        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.
                                          */
-                                        if(tty->flip.count
-                                                   < TTY_FLIPBUF_SIZE){
-                                            tty->flip.count++;
-                                            *tty->flip.flag_buf_ptr++ =
-                                                             TTY_NORMAL;
-                                           *tty->flip.char_buf_ptr++ =
-                                            cy_readb(base_addr+(CyRDSR<<index));
-                                            info->icount.rx++;
-                                        }
+                                        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->flip.flag_buf_ptr++ = 0;
-                                        *tty->flip.char_buf_ptr++ = 0;
-                                        info->icount.rx++;
+                                    }else {
+                                        tty_insert_flip_char(tty, 0, TTY_NORMAL);
+                                        info->icount.rx++;
                                     }
                                 }else{
-                                    *tty->flip.flag_buf_ptr++ = 0;
-                                    *tty->flip.char_buf_ptr++ = 0;
+                                    tty_insert_flip_char(tty, 0, TTY_NORMAL);
                                     info->icount.rx++;
                                 }
                             }else{
@@ -1240,14 +1221,10 @@ cyy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                                info->mon.char_max = char_count;
                             info->mon.char_last = char_count;
 #endif
-                            while(char_count--){
-                                if (tty->flip.count >= TTY_FLIPBUF_SIZE){
-                                        break;
-                                }
-                                tty->flip.count++;
+                            len = tty_buffer_request_room(tty, char_count);
+                            while(len--){
                                 data = cy_readb(base_addr+(CyRDSR<<index));
-                                *tty->flip.flag_buf_ptr++ = TTY_NORMAL;
-                                *tty->flip.char_buf_ptr++ = data;
+                                tty_insert_flip_char(tty, data, TTY_NORMAL);
                                 info->idle_stats.recv_bytes++;
                                 info->icount.rx++;
 #ifdef CY_16Y_HACK
@@ -1256,7 +1233,7 @@ cyy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                             }
                              info->idle_stats.recv_idle = jiffies;
                         }
-                        schedule_delayed_work(&tty->flip.work, 1);
+                        schedule_delayed_work(&tty->buf.work, 1);
                     }
                     /* end of service */
                     cy_writeb(base_addr+(CyRIR<<index), (save_xir & 0x3f));
@@ -1551,6 +1528,7 @@ cyz_handle_rx(struct cyclades_port *info,
   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;
 #else
@@ -1606,18 +1584,11 @@ cyz_handle_rx(struct cyclades_port *info,
                 tty->flip.count += small_count;
             }
 #else
-            while(char_count--){
-                if (tty->flip.count >= N_TTY_BUF_SIZE - tty->read_cnt)
-                    break;
-
-                if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                    break;
-
+            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->flip.count++;
-                *tty->flip.flag_buf_ptr++ = TTY_NORMAL;
-                *tty->flip.char_buf_ptr++ = data;
+                tty_insert_flip_char(tty, data, TTY_NORMAL);
                 info->idle_stats.recv_bytes++;
                 info->icount.rx++;
             }
@@ -1635,7 +1606,7 @@ cyz_handle_rx(struct cyclades_port *info,
             }
 #endif
             info->idle_stats.recv_idle = jiffies;
-            schedule_delayed_work(&tty->flip.work, 1);
+            schedule_delayed_work(&tty->buf.work, 1);
         }
         /* Update rx_get */
         cy_writel(&buf_ctrl->rx_get, new_rx_get);
@@ -1763,23 +1734,17 @@ cyz_handle_cmd(struct cyclades_card *cinfo)
 
         switch(cmd) {
             case C_CM_PR_ERROR:
-                tty->flip.count++;
-                *tty->flip.flag_buf_ptr++ = TTY_PARITY;
-                *tty->flip.char_buf_ptr++ = 0;
+                tty_insert_flip_char(tty, 0, TTY_PARITY);
                 info->icount.rx++;
                 special_count++;
                 break;
             case C_CM_FR_ERROR:
-                tty->flip.count++;
-                *tty->flip.flag_buf_ptr++ = TTY_FRAME;
-                *tty->flip.char_buf_ptr++ = 0;
+                tty_insert_flip_char(tty, 0, TTY_FRAME);
                 info->icount.rx++;
                 special_count++;
                 break;
             case C_CM_RXBRK:
-                tty->flip.count++;
-                *tty->flip.flag_buf_ptr++ = TTY_BREAK;
-                *tty->flip.char_buf_ptr++ = 0;
+                tty_insert_flip_char(tty, 0, TTY_BREAK);
                 info->icount.rx++;
                 special_count++;
                 break;
@@ -1844,7 +1809,7 @@ cyz_handle_cmd(struct cyclades_card *cinfo)
         if(delta_count)
             cy_sched_event(info, Cy_EVENT_DELTA_WAKEUP);
         if(special_count)
-            schedule_delayed_work(&tty->flip.work, 1);
+            schedule_delayed_work(&tty->buf.work, 1);
     }
 }
 
diff --git a/drivers/char/drm/drm_ioc32.c b/drivers/char/drm/drm_ioc32.c
index dd91ff6b474c..e9e2db18952d 100644
--- a/drivers/char/drm/drm_ioc32.c
+++ b/drivers/char/drm/drm_ioc32.c
@@ -28,7 +28,6 @@
  * IN THE SOFTWARE.
  */
 #include <linux/compat.h>
-#include <linux/ioctl32.h>
 
 #include "drmP.h"
 #include "drm_core.h"
diff --git a/drivers/char/drm/i915_ioc32.c b/drivers/char/drm/i915_ioc32.c
index 2218a946ec87..296248cdc767 100644
--- a/drivers/char/drm/i915_ioc32.c
+++ b/drivers/char/drm/i915_ioc32.c
@@ -30,7 +30,6 @@
  * IN THE SOFTWARE.
  */
 #include <linux/compat.h>
-#include <linux/ioctl32.h>
 
 #include "drmP.h"
 #include "drm.h"
diff --git a/drivers/char/drm/mga_ioc32.c b/drivers/char/drm/mga_ioc32.c
index 24a9d4e86af0..54a18eb2fc04 100644
--- a/drivers/char/drm/mga_ioc32.c
+++ b/drivers/char/drm/mga_ioc32.c
@@ -31,7 +31,6 @@
  * IN THE SOFTWARE.
  */
 #include <linux/compat.h>
-#include <linux/ioctl32.h>
 
 #include "drmP.h"
 #include "drm.h"
diff --git a/drivers/char/drm/r128_ioc32.c b/drivers/char/drm/r128_ioc32.c
index 1e2e367b8b82..9dd6d4116e47 100644
--- a/drivers/char/drm/r128_ioc32.c
+++ b/drivers/char/drm/r128_ioc32.c
@@ -30,7 +30,6 @@
  * IN THE SOFTWARE.
  */
 #include <linux/compat.h>
-#include <linux/ioctl32.h>
 
 #include "drmP.h"
 #include "drm.h"
diff --git a/drivers/char/drm/radeon_ioc32.c b/drivers/char/drm/radeon_ioc32.c
index fef4a2b84c1e..0ccfd3618ff1 100644
--- a/drivers/char/drm/radeon_ioc32.c
+++ b/drivers/char/drm/radeon_ioc32.c
@@ -28,7 +28,6 @@
  * IN THE SOFTWARE.
  */
 #include <linux/compat.h>
-#include <linux/ioctl32.h>
 
 #include "drmP.h"
 #include "drm.h"
diff --git a/drivers/char/epca.c b/drivers/char/epca.c
index 407708a001e4..765c5c108bf4 100644
--- a/drivers/char/epca.c
+++ b/drivers/char/epca.c
@@ -1786,9 +1786,7 @@ static void doevent(int crd)
                 if (tty)  { /* Begin if valid tty */
                         if (event & BREAK_IND)  { /* Begin if BREAK_IND */
                                 /* A break has been indicated */
-                                tty->flip.count++;
-                                *tty->flip.flag_buf_ptr++ = TTY_BREAK;
-                                *tty->flip.char_buf_ptr++ = 0;
+                                tty_insert_flip_char(tty, 0, TTY_BREAK);
                                 tty_schedule_flip(tty); 
                         } else if (event & LOWTX_IND)  { /* Begin LOWTX_IND */
                                 if (ch->statusflags & LOWWAIT) 
@@ -2124,7 +2122,6 @@ static void receive_data(struct channel *ch)
         int dataToRead, wrapgap, bytesAvailable;
         unsigned int tail, head;
         unsigned int wrapmask;
-        int rc;
 
         /* ---------------------------------------------------------------
                 This routine is called by doint when a receive data event 
@@ -2162,16 +2159,15 @@ static void receive_data(struct channel *ch)
                 return;
         }
 
-        if (tty->flip.count == TTY_FLIPBUF_SIZE) 
+        if (tty_buffer_request_room(tty, bytesAvailable + 1) == 0)
                 return;
 
         if (readb(&bc->orun)) {
                 writeb(0, &bc->orun);
                 printk(KERN_WARNING "epca; overrun! DigiBoard device %s\n",tty->name);
+                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
         }
         rxwinon(ch);
-        rptr = tty->flip.char_buf_ptr;
-        rc = tty->flip.count;
         while (bytesAvailable > 0)  { /* Begin while there is data on the card */
                 wrapgap = (head >= tail) ? head - tail : ch->rxbufsize - tail;
                 /* ---------------------------------------------------------------
@@ -2183,8 +2179,7 @@ static void receive_data(struct channel *ch)
                 /* --------------------------------------------------------------
                    Make sure we don't overflow the buffer
                 ----------------------------------------------------------------- */
-                if ((rc + dataToRead) > TTY_FLIPBUF_SIZE)
-                        dataToRead = TTY_FLIPBUF_SIZE - rc;
+                dataToRead = tty_prepare_flip_string(tty, &rptr, dataToRead);
                 if (dataToRead == 0)
                         break;
                 /* ---------------------------------------------------------------
@@ -2192,13 +2187,9 @@ static void receive_data(struct channel *ch)
                         for translation if necessary.
                 ------------------------------------------------------------------ */
                 memcpy_fromio(rptr, ch->rxptr + tail, dataToRead);
-                rc   += dataToRead;
-                rptr += dataToRead;
                 tail = (tail + dataToRead) & wrapmask;
                 bytesAvailable -= dataToRead;
         } /* End while there is data on the card */
-        tty->flip.count = rc;
-        tty->flip.char_buf_ptr = rptr;
         globalwinon(ch);
         writew(tail, &bc->rout);
         /* Must be called with global data */
diff --git a/drivers/char/esp.c b/drivers/char/esp.c
index 9f53d2fcc360..e469f641c728 100644
--- a/drivers/char/esp.c
+++ b/drivers/char/esp.c
@@ -345,26 +345,22 @@ static inline void receive_chars_pio(struct esp_struct *info, int num_bytes)
 
         for (i = 0; i < num_bytes; i++) {
                 if (!(err_buf->data[i] & status_mask)) {
-                        *(tty->flip.char_buf_ptr++) = pio_buf->data[i];
+                        int flag = 0;
 
                         if (err_buf->data[i] & 0x04) {
-                                *(tty->flip.flag_buf_ptr++) = TTY_BREAK;
-
+                                flag = TTY_BREAK;
                                 if (info->flags & ASYNC_SAK)
                                         do_SAK(tty);
                         }
                         else if (err_buf->data[i] & 0x02)
-                                *(tty->flip.flag_buf_ptr++) = TTY_FRAME;
+                                flag = TTY_FRAME;
                         else if (err_buf->data[i] & 0x01)
-                                *(tty->flip.flag_buf_ptr++) = TTY_PARITY;
-                        else
-                                *(tty->flip.flag_buf_ptr++) = 0;
-                
-                        tty->flip.count++;
+                                flag = TTY_PARITY;
+                        tty_insert_flip_char(tty, pio_buf->data[i], flag);
                 }
         }
 
-        schedule_delayed_work(&tty->flip.work, 1);
+        schedule_delayed_work(&tty->buf.work, 1);
 
         info->stat_flags &= ~ESP_STAT_RX_TIMEOUT;
         release_pio_buffer(pio_buf);
@@ -397,7 +393,6 @@ static inline void receive_chars_dma_done(struct esp_struct *info,
         int num_bytes;
         unsigned long flags;
         
-        
         flags=claim_dma_lock();
         disable_dma(dma);
         clear_dma_ff(dma);
@@ -408,38 +403,31 @@ static inline void receive_chars_dma_done(struct esp_struct *info,
         
         info->icount.rx += num_bytes;
 
-        memcpy(tty->flip.char_buf_ptr, dma_buffer, num_bytes);
-        tty->flip.char_buf_ptr += num_bytes;
-        tty->flip.count += num_bytes;
-        memset(tty->flip.flag_buf_ptr, 0, num_bytes);
-        tty->flip.flag_buf_ptr += num_bytes;
-
         if (num_bytes > 0) {
-                tty->flip.flag_buf_ptr--;
+                tty_insert_flip_string(tty, dma_buffer, num_bytes - 1);
 
                 status &= (0x1c & info->read_status_mask);
+                
+                /* Is the status significant or do we throw the last byte ? */
+                if (!(status & info->ignore_status_mask)) {
+                        int statflag = 0;
 
-                if (status & info->ignore_status_mask) {
-                        tty->flip.count--;
-                        tty->flip.char_buf_ptr--;
-                        tty->flip.flag_buf_ptr--;
-                } else if (status & 0x10) {
-                        *tty->flip.flag_buf_ptr = TTY_BREAK;
-                        (info->icount.brk)++;
-                        if (info->flags & ASYNC_SAK)
-                                do_SAK(tty);
-                } else if (status & 0x08) {
-                        *tty->flip.flag_buf_ptr = TTY_FRAME;
-                        (info->icount.frame)++;
-                }
-                else if (status & 0x04) {
-                        *tty->flip.flag_buf_ptr = TTY_PARITY;
-                        (info->icount.parity)++;
+                        if (status & 0x10) {
+                                statflag = TTY_BREAK;
+                                (info->icount.brk)++;
+                                if (info->flags & ASYNC_SAK)
+                                        do_SAK(tty);
+                        } else if (status & 0x08) {
+                                statflag = TTY_FRAME;
+                                (info->icount.frame)++;
+                        }
+                        else if (status & 0x04) {
+                                statflag = TTY_PARITY;
+                                (info->icount.parity)++;
+                        }
+                        tty_insert_flip_char(tty, dma_buffer[num_bytes - 1], statflag);
                 }
-
-                tty->flip.flag_buf_ptr++;
-                
-                schedule_delayed_work(&tty->flip.work, 1);
+                schedule_delayed_work(&tty->buf.work, 1);
         }
 
         if (dma_bytes != num_bytes) {
@@ -693,8 +681,7 @@ static irqreturn_t rs_interrupt_single(int irq, void *dev_id,
                 num_bytes = serial_in(info, UART_ESI_STAT1) << 8;
                 num_bytes |= serial_in(info, UART_ESI_STAT2);
 
-                if (num_bytes > (TTY_FLIPBUF_SIZE - info->tty->flip.count))
-                  num_bytes = TTY_FLIPBUF_SIZE - info->tty->flip.count;
+                num_bytes = tty_buffer_request_room(info->tty, num_bytes);
 
                 if (num_bytes) {
                         if (dma_bytes ||
diff --git a/drivers/char/hvc_console.c b/drivers/char/hvc_console.c
index f92177634677..1994a92d4733 100644
--- a/drivers/char/hvc_console.c
+++ b/drivers/char/hvc_console.c
@@ -597,9 +597,7 @@ static int hvc_poll(struct hvc_struct *hp)
 
         /* Read data if any */
         for (;;) {
-                int count = N_INBUF;
-                if (count > (TTY_FLIPBUF_SIZE - tty->flip.count))
-                        count = TTY_FLIPBUF_SIZE - tty->flip.count;
+                int count = tty_buffer_request_room(tty, N_INBUF);
 
                 /* If flip is full, just reschedule a later read */
                 if (count == 0) {
@@ -635,7 +633,7 @@ static int hvc_poll(struct hvc_struct *hp)
                         tty_insert_flip_char(tty, buf[i], 0);
                 }
 
-                if (tty->flip.count)
+                if (count)
                         tty_schedule_flip(tty);
 
                 /*
diff --git a/drivers/char/hvcs.c b/drivers/char/hvcs.c
index 53dc77c760fc..831eb4e8d9d3 100644
--- a/drivers/char/hvcs.c
+++ b/drivers/char/hvcs.c
@@ -456,12 +456,11 @@ static int hvcs_io(struct hvcs_struct *hvcsd)
         /* remove the read masks */
         hvcsd->todo_mask &= ~(HVCS_READ_MASK);
 
-        if ((tty->flip.count + HVCS_BUFF_LEN) < TTY_FLIPBUF_SIZE) {
+        if (tty_buffer_request_room(tty, HVCS_BUFF_LEN) >= HVCS_BUFF_LEN) {
                 got = hvc_get_chars(unit_address,
                                 &buf[0],
                                 HVCS_BUFF_LEN);
-                for (i=0;got && i<got;i++)
-                        tty_insert_flip_char(tty, buf[i], TTY_NORMAL);
+                tty_insert_flip_string(tty, buf, got);
         }
 
         /* Give the TTY time to process the data we just sent. */
@@ -469,10 +468,9 @@ static int hvcs_io(struct hvcs_struct *hvcsd)
                 hvcsd->todo_mask |= HVCS_QUICK_READ;
 
         spin_unlock_irqrestore(&hvcsd->lock, flags);
-        if (tty->flip.count) {
-                /* This is synch because tty->low_latency == 1 */
+        /* This is synch because tty->low_latency == 1 */
+        if(got)
                 tty_flip_buffer_push(tty);
-        }
 
         if (!got) {
                 /* Do this _after_ the flip_buffer_push */
diff --git a/drivers/char/hvsi.c b/drivers/char/hvsi.c
index a22aa940e01e..a9522189fc9e 100644
--- a/drivers/char/hvsi.c
+++ b/drivers/char/hvsi.c
@@ -197,7 +197,7 @@ static inline void print_state(struct hvsi_struct *hp)
         };
         const char *name = state_names[hp->state];
 
-        if (hp->state > (sizeof(state_names)/sizeof(char*)))
+        if (hp->state > ARRAY_SIZE(state_names))
                 name = "UNKNOWN";
 
         pr_debug("hvsi%i: state = %s\n", hp->index, name);
diff --git a/drivers/char/ip2/i2lib.c b/drivers/char/ip2/i2lib.c
index ba85eb1b6ec7..fc944d375be7 100644
--- a/drivers/char/ip2/i2lib.c
+++ b/drivers/char/ip2/i2lib.c
@@ -854,7 +854,7 @@ i2Input(i2ChanStrPtr pCh)
                 count += IBUF_SIZE;
         }
         // Don't give more than can be taken by the line discipline
-        amountToMove = pCh->pTTY->ldisc.receive_room( pCh->pTTY );
+        amountToMove = pCh->pTTY->receive_room;
         if (count > amountToMove) {
                 count = amountToMove;
         }
diff --git a/drivers/char/ip2main.c b/drivers/char/ip2main.c
index d815d197dc3e..56e93a5a1e24 100644
--- a/drivers/char/ip2main.c
+++ b/drivers/char/ip2main.c
@@ -172,7 +172,7 @@ static int Fip_firmware_size;
 /* Private (static) functions */
 static int  ip2_open(PTTY, struct file *);
 static void ip2_close(PTTY, struct file *);
-static int  ip2_write(PTTY, int, const unsigned char *, int);
+static int  ip2_write(PTTY, const unsigned char *, int);
 static void ip2_putchar(PTTY, unsigned char);
 static void ip2_flush_chars(PTTY);
 static int  ip2_write_room(PTTY);
@@ -1713,7 +1713,7 @@ ip2_hangup ( PTTY tty )
 /*                                                                            */
 /******************************************************************************/
 static int
-ip2_write( PTTY tty, int user, const unsigned char *pData, int count)
+ip2_write( PTTY tty, const unsigned char *pData, int count)
 {
         i2ChanStrPtr  pCh = tty->driver_data;
         int bytesSent = 0;
@@ -1726,7 +1726,7 @@ ip2_write( PTTY tty, int user, 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, user );
+        bytesSent = i2Output( pCh, pData, count, 0 );
         WRITE_UNLOCK_IRQRESTORE(&pCh->Pbuf_spinlock,flags);
 
         ip2trace (CHANN, ITRC_WRITE, ITRC_RETURN, 1, bytesSent );
@@ -2001,7 +2001,9 @@ ip2_stop ( PTTY tty )
 static int ip2_tiocmget(struct tty_struct *tty, struct file *file)
 {
         i2ChanStrPtr pCh = DevTable[tty->index];
+#ifdef  ENABLE_DSSNOW
         wait_queue_t wait;
+#endif
 
         if (pCh == NULL)
                 return -ENODEV;
@@ -2089,15 +2091,17 @@ ip2_ioctl ( PTTY tty, struct file *pFile, UINT cmd, ULONG arg )
 {
         wait_queue_t wait;
         i2ChanStrPtr pCh = DevTable[tty->index];
+        i2eBordStrPtr pB;
         struct async_icount cprev, cnow;        /* kernel counter temps */
         struct serial_icounter_struct __user *p_cuser;
         int rc = 0;
         unsigned long flags;
         void __user *argp = (void __user *)arg;
 
-        if ( pCh == NULL ) {
+        if ( pCh == NULL )
                 return -ENODEV;
-        }
+
+        pB = pCh->pMyBord;
 
         ip2trace (CHANN, ITRC_IOCTL, ITRC_ENTER, 2, cmd, arg );
 
@@ -2206,9 +2210,9 @@ ip2_ioctl ( PTTY tty, struct file *pFile, UINT cmd, ULONG arg )
          * for masking). Caller should use TIOCGICOUNT to see which one it was
          */
         case TIOCMIWAIT:
-                save_flags(flags);cli();
+                WRITE_LOCK_IRQSAVE(&pB->read_fifo_spinlock, flags);
                 cprev = pCh->icount;     /* note the counters on entry */
-                restore_flags(flags);
+                WRITE_UNLOCK_IRQRESTORE(&pB->read_fifo_spinlock, flags);
                 i2QueueCommands(PTYPE_BYPASS, pCh, 100, 4, 
                                                 CMD_DCD_REP, CMD_CTS_REP, CMD_DSR_REP, CMD_RI_REP);
                 init_waitqueue_entry(&wait, current);
@@ -2228,9 +2232,9 @@ ip2_ioctl ( PTTY tty, struct file *pFile, UINT cmd, ULONG arg )
                                 rc = -ERESTARTSYS;
                                 break;
                         }
-                        save_flags(flags);cli();
+                        WRITE_LOCK_IRQSAVE(&pB->read_fifo_spinlock, flags);
                         cnow = pCh->icount; /* atomic copy */
-                        restore_flags(flags);
+                        WRITE_UNLOCK_IRQRESTORE(&pB->read_fifo_spinlock, flags);
                         if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
                                 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) {
                                 rc =  -EIO; /* no change => rc */
@@ -2268,9 +2272,9 @@ ip2_ioctl ( PTTY tty, struct file *pFile, UINT cmd, ULONG arg )
         case TIOCGICOUNT:
                 ip2trace (CHANN, ITRC_IOCTL, 11, 1, rc );
 
-                save_flags(flags);cli();
+                WRITE_LOCK_IRQSAVE(&pB->read_fifo_spinlock, flags);
                 cnow = pCh->icount;
-                restore_flags(flags);
+                WRITE_UNLOCK_IRQRESTORE(&pB->read_fifo_spinlock, flags);
                 p_cuser = argp;
                 rc = put_user(cnow.cts, &p_cuser->cts);
                 rc = put_user(cnow.dsr, &p_cuser->dsr);
diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
index 561430ed94af..0097f06fa67b 100644
--- a/drivers/char/ipmi/ipmi_msghandler.c
+++ b/drivers/char/ipmi/ipmi_msghandler.c
@@ -57,6 +57,7 @@ static int initialized = 0;
 
 #ifdef CONFIG_PROC_FS
 struct proc_dir_entry *proc_ipmi_root = NULL;
+EXPORT_SYMBOL(proc_ipmi_root);
 #endif /* CONFIG_PROC_FS */
 
 #define MAX_EVENTS_IN_QUEUE     25
@@ -3295,6 +3296,5 @@ EXPORT_SYMBOL(ipmi_get_my_address);
 EXPORT_SYMBOL(ipmi_set_my_LUN);
 EXPORT_SYMBOL(ipmi_get_my_LUN);
 EXPORT_SYMBOL(ipmi_smi_add_proc_entry);
-EXPORT_SYMBOL(proc_ipmi_root);
 EXPORT_SYMBOL(ipmi_user_set_run_to_completion);
 EXPORT_SYMBOL(ipmi_free_recv_msg);
diff --git a/drivers/char/ipmi/ipmi_poweroff.c b/drivers/char/ipmi/ipmi_poweroff.c
index e053eade0366..49c09ae004bf 100644
--- a/drivers/char/ipmi/ipmi_poweroff.c
+++ b/drivers/char/ipmi/ipmi_poweroff.c
@@ -612,11 +612,14 @@ static int ipmi_poweroff_init (void)
 #endif
 
         rv = ipmi_smi_watcher_register(&smi_watcher);
+
+#ifdef CONFIG_PROC_FS
         if (rv) {
                 unregister_sysctl_table(ipmi_table_header);
                 printk(KERN_ERR PFX "Unable to register SMI watcher: %d\n", rv);
                 goto out_err;
         }
+#endif
 
  out_err:
         return rv;
diff --git a/drivers/char/isicom.c b/drivers/char/isicom.c
index 1bbf507adda5..e9ebabaf8cb0 100644
--- a/drivers/char/isicom.c
+++ b/drivers/char/isicom.c
@@ -20,7 +20,7 @@
  *      3/9/99  sameer                  Added support for ISI4616 cards.
  *
  *      16/9/99 sameer                  We do not force RTS low anymore.
- *                                      This is to prevent the firmware 
+ *                                      This is to prevent the firmware
  *                                      from getting confused.
  *
  *      26/10/99 sameer                 Cosmetic changes:The driver now
@@ -31,28 +31,28 @@
  *
  *      10/5/00  sameer                 Fixed isicom_shutdown_board()
  *                                      to not lower DTR on all the ports
- *                                      when the last port on the card is 
+ *                                      when the last port on the card is
  *                                      closed.
  *
  *      10/5/00  sameer                 Signal mask setup command added
- *                                      to  isicom_setup_port and 
+ *                                      to  isicom_setup_port and
  *                                      isicom_shutdown_port.
  *
  *      24/5/00  sameer                 The driver is now SMP aware.
- *                                      
- *      
+ *
+ *
  *      27/11/00 Vinayak P Risbud       Fixed the Driver Crash Problem
- *      
- *      
+ *
+ *
  *      03/01/01  anil .s               Added support for resetting the
  *                                      internal modems on ISI cards.
  *
  *      08/02/01  anil .s               Upgraded the driver for kernel
  *                                      2.4.x
  *
- *      11/04/01  Kevin                 Fixed firmware load problem with
+ *      11/04/01  Kevin                 Fixed firmware load problem with
  *                                      ISIHP-4X card
- *      
+ *
  *      30/04/01  anil .s               Fixed the remote login through
  *                                      ISI port problem. Now the link
  *                                      does not go down before password
@@ -62,9 +62,9 @@
  *                                      among ISI-PCI cards.
  *
  *      03/05/01  anil .s               Added support to display the version
- *                                      info during insmod as well as module 
+ *                                      info during insmod as well as module
  *                                      listing by lsmod.
- *      
+ *
  *      10/05/01  anil .s               Done the modifications to the source
  *                                      file and Install script so that the
  *                                      same installation can be used for
@@ -73,19 +73,19 @@
  *      06/06/01  anil .s               Now we drop both dtr and rts during
  *                                      shutdown_port as well as raise them
  *                                      during isicom_config_port.
- *      
+ *
  *      09/06/01 acme@conectiva.com.br  use capable, not suser, do
  *                                      restore_flags on failure in
  *                                      isicom_send_break, verify put_user
  *                                      result
  *
- *      11/02/03  ranjeeth              Added support for 230 Kbps and 460 Kbps
- *                                      Baud index extended to 21
- *      
- *      20/03/03  ranjeeth              Made to work for Linux Advanced server.
- *                                      Taken care of license warning.  
- *      
- *      10/12/03  Ravindra              Made to work for Fedora Core 1 of 
+ *      11/02/03  ranjeeth              Added support for 230 Kbps and 460 Kbps
+ *                                      Baud index extended to 21
+ *
+ *      20/03/03  ranjeeth              Made to work for Linux Advanced server.
+ *                                      Taken care of license warning.
+ *
+ *      10/12/03  Ravindra              Made to work for Fedora Core 1 of
  *                                      Red Hat Distribution
  *
  *      06/01/05  Alan Cox              Merged the ISI and base kernel strands
@@ -93,10 +93,10 @@
  *
  *      ***********************************************************
  *
- *      To use this driver you also need the support package. You 
+ *      To use this driver you also need the support package. You
  *      can find this in RPM format on
  *              ftp://ftp.linux.org.uk/pub/linux/alan
- *      
+ *
  *      You can find the original tools for this direct from Multitech
  *              ftp://ftp.multitech.com/ISI-Cards/
  *
@@ -107,20 +107,20 @@
  *      Omit those entries for boards you don't have installed.
  *
  *      TODO
- *              Hotplug
  *              Merge testing
  *              64-bit verification
  */
 
 #include <linux/module.h>
+#include <linux/firmware.h>
 #include <linux/kernel.h>
 #include <linux/tty.h>
+#include <linux/tty_flip.h>
 #include <linux/termios.h>
 #include <linux/fs.h>
 #include <linux/sched.h>
 #include <linux/serial.h>
 #include <linux/mm.h>
-#include <linux/miscdevice.h>
 #include <linux/interrupt.h>
 #include <linux/timer.h>
 #include <linux/delay.h>
@@ -134,50 +134,62 @@
 
 #include <linux/isicom.h>
 
+#define InterruptTheCard(base) outw(0, (base) + 0xc)
+#define ClearInterrupt(base) inw((base) + 0x0a)
+
+#ifdef DEBUG
+#define pr_dbg(str...) printk(KERN_DEBUG "ISICOM: " str)
+#define isicom_paranoia_check(a, b, c) __isicom_paranoia_check((a), (b), (c))
+#else
+#define pr_dbg(str...) do { } while (0)
+#define isicom_paranoia_check(a, b, c) 0
+#endif
+
+static int isicom_probe(struct pci_dev *, const struct pci_device_id *);
+static void __devexit isicom_remove(struct pci_dev *);
+
 static struct pci_device_id isicom_pci_tbl[] = {
-        { VENDOR_ID, 0x2028, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
-        { VENDOR_ID, 0x2051, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
-        { VENDOR_ID, 0x2052, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
-        { VENDOR_ID, 0x2053, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
-        { VENDOR_ID, 0x2054, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
-        { VENDOR_ID, 0x2055, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
-        { VENDOR_ID, 0x2056, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
-        { VENDOR_ID, 0x2057, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
-        { VENDOR_ID, 0x2058, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
+        { PCI_DEVICE(VENDOR_ID, 0x2028) },
+        { PCI_DEVICE(VENDOR_ID, 0x2051) },
+        { PCI_DEVICE(VENDOR_ID, 0x2052) },
+        { PCI_DEVICE(VENDOR_ID, 0x2053) },
+        { PCI_DEVICE(VENDOR_ID, 0x2054) },
+        { PCI_DEVICE(VENDOR_ID, 0x2055) },
+        { PCI_DEVICE(VENDOR_ID, 0x2056) },
+        { PCI_DEVICE(VENDOR_ID, 0x2057) },
+        { PCI_DEVICE(VENDOR_ID, 0x2058) },
         { 0 }
 };
 MODULE_DEVICE_TABLE(pci, isicom_pci_tbl);
 
+static struct pci_driver isicom_driver = {
+        .name           = "isicom",
+        .id_table       = isicom_pci_tbl,
+        .probe          = isicom_probe,
+        .remove         = __devexit_p(isicom_remove)
+};
+
 static int prev_card = 3;       /*      start servicing isi_card[0]     */
 static struct tty_driver *isicom_normal;
 
 static struct timer_list tx;
 static char re_schedule = 1;
-#ifdef ISICOM_DEBUG
-static unsigned long tx_count = 0;
-#endif
-
-static int ISILoad_ioctl(struct inode *inode, struct file *filp, unsigned  int cmd, unsigned long arg);
 
 static void isicom_tx(unsigned long _data);
-static void isicom_start(struct tty_struct * tty);
-
-static unsigned char * tmp_buf;
-static DECLARE_MUTEX(tmp_buf_sem);
+static void isicom_start(struct tty_struct *tty);
 
 /*   baud index mappings from linux defns to isi */
 
 static signed char linuxb_to_isib[] = {
-        -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 13, 15, 16, 17,     
-        18, 19
+        -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 13, 15, 16, 17, 18, 19
 };
 
 struct  isi_board {
-        unsigned short          base;
+        unsigned long           base;
         unsigned char           irq;
         unsigned char           port_count;
         unsigned short          status;
-        unsigned short          port_status; /* each bit represents a single port */
+        unsigned short          port_status; /* each bit for each port */
         unsigned short          shift_count;
         struct isi_port         * ports;
         signed char             count;
@@ -192,9 +204,9 @@ struct	isi_port {
         int                     count;
         int                     blocked_open;
         int                     close_delay;
-        unsigned short          channel;
-        unsigned short          status;
-        unsigned short          closing_wait;
+        u16                     channel;
+        u16                     status;
+        u16                     closing_wait;
         struct isi_board        * card;
         struct tty_struct       * tty;
         wait_queue_head_t       close_wait;
@@ -215,35 +227,37 @@ static struct isi_port  isi_ports[PORT_COUNT];
  *      the kernel lock for the card and have the card in a position that
  *      it wants to talk.
  */
- 
+
 static int lock_card(struct isi_board *card)
 {
         char            retries;
-        unsigned short base = card->base;
+        unsigned long base = card->base;
 
         for (retries = 0; retries < 100; retries++) {
                 spin_lock_irqsave(&card->card_lock, card->flags);
                 if (inw(base + 0xe) & 0x1) {
-                        return 1; 
+                        return 1;
                 } else {
                         spin_unlock_irqrestore(&card->card_lock, card->flags);
                         udelay(1000);   /* 1ms */
                 }
         }
-        printk(KERN_WARNING "ISICOM: Failed to lock Card (0x%x)\n", card->base);
+        printk(KERN_WARNING "ISICOM: Failed to lock Card (0x%lx)\n",
+                card->base);
+
         return 0;       /* Failed to aquire the card! */
 }
 
 static int lock_card_at_interrupt(struct isi_board *card)
 {
         unsigned char           retries;
-        unsigned short          base = card->base;
+        unsigned long base = card->base;
 
         for (retries = 0; retries < 200; retries++) {
                 spin_lock_irqsave(&card->card_lock, card->flags);
 
                 if (inw(base + 0xe) & 0x1)
-                        return 1; 
+                        return 1;
                 else
                         spin_unlock_irqrestore(&card->card_lock, card->flags);
         }
@@ -259,373 +273,141 @@ static void unlock_card(struct isi_board *card)
 /*
  *  ISI Card specific ops ...
  */
- 
-static void raise_dtr(struct isi_port * port)
+
+static void raise_dtr(struct isi_port *port)
 {
-        struct isi_board * card = port->card;
-        unsigned short base = card->base;
-        unsigned char channel = port->channel;
+        struct isi_board *card = port->card;
+        unsigned long base = card->base;
+        u16 channel = port->channel;
 
         if (!lock_card(card))
                 return;
 
-        outw(0x8000 | (channel << card->shift_count) | 0x02 , base);
+        outw(0x8000 | (channel << card->shift_count) | 0x02, base);
         outw(0x0504, base);
         InterruptTheCard(base);
         port->status |= ISI_DTR;
         unlock_card(card);
 }
 
-static inline void drop_dtr(struct isi_port * port)
-{       
-        struct isi_board * card = port->card;
-        unsigned short base = card->base;
-        unsigned char channel = port->channel;
+static inline void drop_dtr(struct isi_port *port)
+{
+        struct isi_board *card = port->card;
+        unsigned long base = card->base;
+        u16 channel = port->channel;
 
         if (!lock_card(card))
                 return;
 
-        outw(0x8000 | (channel << card->shift_count) | 0x02 , base);
+        outw(0x8000 | (channel << card->shift_count) | 0x02, base);
         outw(0x0404, base);
-        InterruptTheCard(base); 
+        InterruptTheCard(base);
         port->status &= ~ISI_DTR;
         unlock_card(card);
 }
 
-static inline void raise_rts(struct isi_port * port)
+static inline void raise_rts(struct isi_port *port)
 {
-        struct isi_board * card = port->card;
-        unsigned short base = card->base;
-        unsigned char channel = port->channel;
+        struct isi_board *card = port->card;
+        unsigned long base = card->base;
+        u16 channel = port->channel;
 
         if (!lock_card(card))
                 return;
 
-        outw(0x8000 | (channel << card->shift_count) | 0x02 , base);
+        outw(0x8000 | (channel << card->shift_count) | 0x02, base);
         outw(0x0a04, base);
-        InterruptTheCard(base); 
+        InterruptTheCard(base);
         port->status |= ISI_RTS;
         unlock_card(card);
 }
-static inline void drop_rts(struct isi_port * port)
+static inline void drop_rts(struct isi_port *port)
 {
-        struct isi_board * card = port->card;
-        unsigned short base = card->base;
-        unsigned char channel = port->channel;
+        struct isi_board *card = port->card;
+        unsigned long base = card->base;
+        u16 channel = port->channel;
 
         if (!lock_card(card))
                 return;
 
-        outw(0x8000 | (channel << card->shift_count) | 0x02 , base);
+        outw(0x8000 | (channel << card->shift_count) | 0x02, base);
         outw(0x0804, base);
-        InterruptTheCard(base); 
+        InterruptTheCard(base);
         port->status &= ~ISI_RTS;
         unlock_card(card);
 }
 
-static inline void raise_dtr_rts(struct isi_port * port)
+static inline void raise_dtr_rts(struct isi_port *port)
 {
-        struct isi_board * card = port->card;
-        unsigned short base = card->base;
-        unsigned char channel = port->channel;
+        struct isi_board *card = port->card;
+        unsigned long base = card->base;
+        u16 channel = port->channel;
 
         if (!lock_card(card))
                 return;
 
-        outw(0x8000 | (channel << card->shift_count) | 0x02 , base);
+        outw(0x8000 | (channel << card->shift_count) | 0x02, base);
         outw(0x0f04, base);
         InterruptTheCard(base);
         port->status |= (ISI_DTR | ISI_RTS);
         unlock_card(card);
 }
 
-static void drop_dtr_rts(struct isi_port * port)
+static void drop_dtr_rts(struct isi_port *port)
 {
-        struct isi_board * card = port->card;
-        unsigned short base = card->base;
-        unsigned char channel = port->channel;
+        struct isi_board *card = port->card;
+        unsigned long base = card->base;
+        u16 channel = port->channel;
 
         if (!lock_card(card))
                 return;
 
-        outw(0x8000 | (channel << card->shift_count) | 0x02 , base);
+        outw(0x8000 | (channel << card->shift_count) | 0x02, base);
         outw(0x0c04, base);
-        InterruptTheCard(base); 
+        InterruptTheCard(base);
         port->status &= ~(ISI_RTS | ISI_DTR);
         unlock_card(card);
 }
 
-static inline void kill_queue(struct isi_port * port, short queue)
+static inline void kill_queue(struct isi_port *port, short queue)
 {
-        struct isi_board * card = port->card;
-        unsigned short base = card->base;
-        unsigned char channel = port->channel;
+        struct isi_board *card = port->card;
+        unsigned long base = card->base;
+        u16 channel = port->channel;
 
         if (!lock_card(card))
                 return;
 
-        outw(0x8000 | (channel << card->shift_count) | 0x02 , base);
+        outw(0x8000 | (channel << card->shift_count) | 0x02, base);
         outw((queue << 8) | 0x06, base);
-        InterruptTheCard(base); 
+        InterruptTheCard(base);
         unlock_card(card);
 }
 
-
-/* 
- *  Firmware loader driver specific routines. This needs to mostly die
- *  and be replaced with request_firmware.
- */
-
-static struct file_operations ISILoad_fops = {
-        .owner          = THIS_MODULE,
-        .ioctl          = ISILoad_ioctl,
-};
-
-static struct miscdevice isiloader_device = {
-        ISILOAD_MISC_MINOR, "isictl", &ISILoad_fops
-};
-
- 
-static inline int WaitTillCardIsFree(unsigned short base)
-{
-        unsigned long count=0;
-        while( (!(inw(base+0xe) & 0x1)) && (count++ < 6000000));
-        if (inw(base+0xe)&0x1)  
-                return 0;
-        else
-                return 1;
-}
-
-static int ISILoad_ioctl(struct inode *inode, struct file *filp,
-                         unsigned int cmd, unsigned long arg)
-{
-        unsigned int card, i, j, signature, status, portcount = 0;
-        unsigned long t;
-        unsigned short word_count, base;
-        bin_frame frame;
-        void __user *argp = (void __user *)arg;
-        /* exec_record exec_rec; */
-        
-        if(get_user(card, (int __user *)argp))
-                return -EFAULT;
-                
-        if(card < 0 || card >= BOARD_COUNT)
-                return -ENXIO;
-                
-        base=isi_card[card].base;
-        
-        if(base==0)
-                return -ENXIO;  /* disabled or not used */
-        
-        switch(cmd) {
-                case MIOCTL_RESET_CARD:
-                        if (!capable(CAP_SYS_ADMIN))
-                                return -EPERM;
-                        printk(KERN_DEBUG "ISILoad:Resetting Card%d at 0x%x ",card+1,base);
-                                                                
-                        inw(base+0x8);
-                        
-                        for(t=jiffies+HZ/100;time_before(jiffies, t););
-                                
-                        outw(0,base+0x8); /* Reset */
-                        
-                        for(j=1;j<=3;j++) {
-                                for(t=jiffies+HZ;time_before(jiffies, t););
-                                printk(".");
-                        }       
-                        signature=(inw(base+0x4)) & 0xff;       
-                        if (isi_card[card].isa) {
-                                        
-                                if (!(inw(base+0xe) & 0x1) || (inw(base+0x2))) {
-#ifdef ISICOM_DEBUG                             
-                                        printk("\nbase+0x2=0x%x , base+0xe=0x%x",inw(base+0x2),inw(base+0xe));
-#endif                          
-                                        printk("\nISILoad:ISA Card%d reset failure (Possible bad I/O Port Address 0x%x).\n",card+1,base);
-                                        return -EIO;                                    
-                                }
-                        }       
-                        else {
-                                portcount = inw(base+0x2);
-                                if (!(inw(base+0xe) & 0x1) || ((portcount!=0) && (portcount!=4) && (portcount!=8))) {   
-#ifdef ISICOM_DEBUG
-                                        printk("\nbase+0x2=0x%x , base+0xe=0x%x",inw(base+0x2),inw(base+0xe));
-#endif
-                                        printk("\nISILoad:PCI Card%d reset failure (Possible bad I/O Port Address 0x%x).\n",card+1,base);
-                                        return -EIO;
-                                }
-                        }       
-                        switch(signature) {
-                        case    0xa5:
-                        case    0xbb:
-                        case    0xdd:   
-                                        if (isi_card[card].isa) 
-                                                isi_card[card].port_count = 8;
-                                        else {
-                                                if (portcount == 4)
-                                                        isi_card[card].port_count = 4;
-                                                else
-                                                        isi_card[card].port_count = 8;
-                                        }       
-                                        isi_card[card].shift_count = 12;
-                                        break;
-                                        
-                        case    0xcc:   isi_card[card].port_count = 16;
-                                        isi_card[card].shift_count = 11;
-                                        break;                          
-                                        
-                        default: printk("ISILoad:Card%d reset failure (Possible bad I/O Port Address 0x%x).\n",card+1,base);
-#ifdef ISICOM_DEBUG                     
-                                 printk("Sig=0x%x\n",signature);
-#endif                           
-                                 return -EIO;
-                        }
-                        printk("-Done\n");
-                        return put_user(signature,(unsigned __user *)argp);
-                                                
-        case    MIOCTL_LOAD_FIRMWARE:
-                        if (!capable(CAP_SYS_ADMIN))
-                                return -EPERM;
-                                
-                        if(copy_from_user(&frame, argp, sizeof(bin_frame)))
-                                return -EFAULT;
-                        
-                        if (WaitTillCardIsFree(base))
-                                return -EIO;
-                        
-                        outw(0xf0,base);        /* start upload sequence */ 
-                        outw(0x00,base);
-                        outw((frame.addr), base);/*      lsb of adderess    */
-                        
-                        word_count=(frame.count >> 1) + frame.count % 2;
-                        outw(word_count, base);
-                        InterruptTheCard(base);
-                        
-                        for(i=0;i<=0x2f;i++);   /* a wee bit of delay */
-                        
-                        if (WaitTillCardIsFree(base)) 
-                                return -EIO;
-                                
-                        if ((status=inw(base+0x4))!=0) {
-                                printk(KERN_WARNING "ISILoad:Card%d rejected load header:\nAddress:0x%x \nCount:0x%x \nStatus:0x%x \n", 
-                                card+1, frame.addr, frame.count, status);
-                                return -EIO;
-                        }
-                        outsw(base, (void *) frame.bin_data, word_count);
-                        
-                        InterruptTheCard(base);
-                        
-                        for(i=0;i<=0x0f;i++);   /* another wee bit of delay */ 
-                        
-                        if (WaitTillCardIsFree(base)) 
-                                return -EIO;
-                                
-                        if ((status=inw(base+0x4))!=0) {
-                                printk(KERN_ERR "ISILoad:Card%d got out of sync.Card Status:0x%x\n",card+1, status);
-                                return -EIO;
-                        }       
-                        return 0;
-                                                
-        case    MIOCTL_READ_FIRMWARE:
-                        if (!capable(CAP_SYS_ADMIN))
-                                return -EPERM;
-                                
-                        if(copy_from_user(&frame, argp, sizeof(bin_header)))
-                                return -EFAULT;
-                        
-                        if (WaitTillCardIsFree(base))
-                                return -EIO;
-                        
-                        outw(0xf1,base);        /* start download sequence */ 
-                        outw(0x00,base);
-                        outw((frame.addr), base);/*      lsb of adderess    */
-                        
-                        word_count=(frame.count >> 1) + frame.count % 2;
-                        outw(word_count+1, base);
-                        InterruptTheCard(base);
-                        
-                        for(i=0;i<=0xf;i++);    /* a wee bit of delay */
-                        
-                        if (WaitTillCardIsFree(base)) 
-                                return -EIO;
-                                
-                        if ((status=inw(base+0x4))!=0) {
-                                printk(KERN_WARNING "ISILoad:Card%d rejected verify header:\nAddress:0x%x \nCount:0x%x \nStatus:0x%x \n", 
-                                card+1, frame.addr, frame.count, status);
-                                return -EIO;
-                        }
-                        
-                        inw(base);
-                        insw(base, frame.bin_data, word_count);
-                        InterruptTheCard(base);
-                        
-                        for(i=0;i<=0x0f;i++);   /* another wee bit of delay */ 
-                        
-                        if (WaitTillCardIsFree(base)) 
-                                return -EIO;
-                                
-                        if ((status=inw(base+0x4))!=0) {
-                                printk(KERN_ERR "ISILoad:Card%d verify got out of sync.Card Status:0x%x\n",card+1, status);
-                                return -EIO;
-                        }       
-                        
-                        if(copy_to_user(argp, &frame, sizeof(bin_frame)))
-                                return -EFAULT;
-                        return 0;
-        
-        case    MIOCTL_XFER_CTRL:
-                        if (!capable(CAP_SYS_ADMIN))
-                                return -EPERM;
-                        if (WaitTillCardIsFree(base)) 
-                                return -EIO;
-                                        
-                        outw(0xf2, base);
-                        outw(0x800, base);
-                        outw(0x0, base);
-                        outw(0x0, base);
-                        InterruptTheCard(base);
-                        outw(0x0, base+0x4);    /* for ISI4608 cards */
-                                                        
-                        isi_card[card].status |= FIRMWARE_LOADED;
-                        return 0;       
-                        
-        default:
-#ifdef ISICOM_DEBUG     
-                printk(KERN_DEBUG "ISILoad: Received Ioctl cmd 0x%x.\n", cmd); 
-#endif
-                return -ENOIOCTLCMD;
-        
-        }
-        
-}
-                                
-
 /*
  *      ISICOM Driver specific routines ...
  *
  */
- 
-static inline int isicom_paranoia_check(struct isi_port const * port, char *name, 
-                                        const char * routine)
+
+static inline int __isicom_paranoia_check(struct isi_port const *port,
+        char *name, const char *routine)
 {
-#ifdef ISICOM_DEBUG 
-        static const char * badmagic = 
-                        KERN_WARNING "ISICOM: Warning: bad isicom magic for dev %s in %s.\n";
-        static const char * badport = 
-                        KERN_WARNING "ISICOM: Warning: NULL isicom port for dev %s in %s.\n";           
         if (!port) {
-                printk(badport, name, routine);
+                printk(KERN_WARNING "ISICOM: Warning: bad isicom magic for "
+                        "dev %s in %s.\n", name, routine);
                 return 1;
         }
         if (port->magic != ISICOM_MAGIC) {
-                printk(badmagic, name, routine);
+                printk(KERN_WARNING "ISICOM: Warning: NULL isicom port for "
+                        "dev %s in %s.\n", name, routine);
                 return 1;
-        }       
-#endif  
+        }
+
         return 0;
 }
-                        
+
 /*
- *      Transmitter. 
+ *      Transmitter.
  *
  *      We shovel data into the card buffers on a regular basis. The card
  *      will do the rest of the work for us.
@@ -635,25 +417,21 @@ static void isicom_tx(unsigned long _data)
 {
         short count = (BOARD_COUNT-1), card, base;
         short txcount, wrd, residue, word_count, cnt;
-        struct isi_port * port;
-        struct tty_struct * tty;
-        
-#ifdef ISICOM_DEBUG
-        ++tx_count;
-#endif  
-        
+        struct isi_port *port;
+        struct tty_struct *tty;
+
         /*      find next active board  */
         card = (prev_card + 1) & 0x0003;
         while(count-- > 0) {
-                if (isi_card[card].status & BOARD_ACTIVE) 
+                if (isi_card[card].status & BOARD_ACTIVE)
                         break;
-                card = (card + 1) & 0x0003;     
+                card = (card + 1) & 0x0003;
         }
         if (!(isi_card[card].status & BOARD_ACTIVE))
                 goto sched_again;
-                
+
         prev_card = card;
-        
+
         count = isi_card[card].port_count;
         port = isi_card[card].ports;
         base = isi_card[card].base;
@@ -662,18 +440,18 @@ static void isicom_tx(unsigned long _data)
                         continue;
                 /* port not active or tx disabled to force flow control */
                 if (!(port->flags & ASYNC_INITIALIZED) ||
-                        !(port->status & ISI_TXOK))
+                                !(port->status & ISI_TXOK))
                         unlock_card(&isi_card[card]);
                         continue;
-                
+
                 tty = port->tty;
-                
-                
-                if(tty == NULL) {
+
+
+                if (tty == NULL) {
                         unlock_card(&isi_card[card]);
                         continue;
                 }
-                
+
                 txcount = min_t(short, TX_SIZE, port->xmit_cnt);
                 if (txcount <= 0 || tty->stopped || tty->hw_stopped) {
                         unlock_card(&isi_card[card]);
@@ -681,44 +459,45 @@ static void isicom_tx(unsigned long _data)
                 }
                 if (!(inw(base + 0x02) & (1 << port->channel))) {
                         unlock_card(&isi_card[card]);
-                        continue;               
+                        continue;
                 }
-#ifdef ISICOM_DEBUG
-                printk(KERN_DEBUG "ISICOM: txing %d bytes, port%d.\n", 
-                                txcount, port->channel+1); 
-#endif  
-                outw((port->channel << isi_card[card].shift_count) | txcount
-                                        , base);
+                pr_dbg("txing %d bytes, port%d.\n", txcount,
+                        port->channel + 1);
+                outw((port->channel << isi_card[card].shift_count) | txcount,
+                        base);
                 residue = NO;
-                wrd = 0;                        
+                wrd = 0;
                 while (1) {
-                        cnt = min_t(int, txcount, (SERIAL_XMIT_SIZE - port->xmit_tail));
+                        cnt = min_t(int, txcount, (SERIAL_XMIT_SIZE
+                                        - port->xmit_tail));
                         if (residue == YES) {
                                 residue = NO;
                                 if (cnt > 0) {
-                                        wrd |= (port->xmit_buf[port->xmit_tail] << 8);
-                                        port->xmit_tail = (port->xmit_tail + 1) & (SERIAL_XMIT_SIZE - 1);
+                                        wrd |= (port->xmit_buf[port->xmit_tail]
+                                                                        << 8);
+                                        port->xmit_tail = (port->xmit_tail + 1)
+                                                & (SERIAL_XMIT_SIZE - 1);
                                         port->xmit_cnt--;
                                         txcount--;
                                         cnt--;
-                                        outw(wrd, base);                        
-                                }
-                                else {
+                                        outw(wrd, base);
+                                } else {
                                         outw(wrd, base);
                                         break;
                                 }
-                        }               
+                        }
                         if (cnt <= 0) break;
                         word_count = cnt >> 1;
-                        outsw(base, port->xmit_buf+port->xmit_tail, word_count);
-                        port->xmit_tail = (port->xmit_tail + (word_count << 1)) &
-                                                (SERIAL_XMIT_SIZE - 1);
+                        outsw(base, port->xmit_buf+port->xmit_tail,word_count);
+                        port->xmit_tail = (port->xmit_tail
+                                + (word_count << 1)) & (SERIAL_XMIT_SIZE - 1);
                         txcount -= (word_count << 1);
                         port->xmit_cnt -= (word_count << 1);
                         if (cnt & 0x0001) {
                                 residue = YES;
                                 wrd = port->xmit_buf[port->xmit_tail];
-                                port->xmit_tail = (port->xmit_tail + 1) & (SERIAL_XMIT_SIZE - 1);
+                                port->xmit_tail = (port->xmit_tail + 1)
+                                        & (SERIAL_XMIT_SIZE - 1);
                                 port->xmit_cnt--;
                                 txcount--;
                         }
@@ -730,81 +509,82 @@ static void isicom_tx(unsigned long _data)
                 if (port->xmit_cnt <= WAKEUP_CHARS)
                         schedule_work(&port->bh_tqueue);
                 unlock_card(&isi_card[card]);
-        }       
+        }
+
+        /*      schedule another tx for hopefully in about 10ms */
+sched_again:
+        if (!re_schedule) {
+                re_schedule = 2;
+                return;
+        }
 
-        /*      schedule another tx for hopefully in about 10ms */      
-sched_again:    
-        if (!re_schedule)       
-                return;
         init_timer(&tx);
         tx.expires = jiffies + HZ/100;
         tx.data = 0;
         tx.function = isicom_tx;
         add_timer(&tx);
-        
-        return; 
-}               
- 
+
+        return;
+}
+
 /*      Interrupt handlers      */
 
- 
-static void isicom_bottomhalf(void * data)
+
+static void isicom_bottomhalf(void *data)
 {
-        struct isi_port * port = (struct isi_port *) data;
-        struct tty_struct * tty = port->tty;
-        
+        struct isi_port *port = (struct isi_port *) data;
+        struct tty_struct *tty = port->tty;
+
         if (!tty)
                 return;
 
-        tty_wakeup(tty);        
+        tty_wakeup(tty);
         wake_up_interruptible(&tty->write_wait);
-}               
-                
+}
+
 /*
- *      Main interrupt handler routine 
+ *      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 pt_regs *regs)
 {
-        struct isi_board * card;
-        struct isi_port * port;
-        struct tty_struct * tty;
-        unsigned short base, header, word_count, count;
-        unsigned char channel;
+        struct isi_board *card = dev_id;
+        struct isi_port *port;
+        struct tty_struct *tty;
+        unsigned long base;
+        u16 header, word_count, count, channel;
         short byte_count;
-        
-        card = (struct isi_board *) dev_id;
+        unsigned char *rp;
 
         if (!card || !(card->status & FIRMWARE_LOADED))
                 return IRQ_NONE;
-        
+
         base = card->base;
         spin_lock(&card->card_lock);
-        
+
         if (card->isa == NO) {
                 /*
-                 *      disable any interrupts from the PCI card and lower the
-                 *      interrupt line
+                 * 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);
         channel = (header & 0x7800) >> card->shift_count;
         byte_count = header & 0xff;
 
         if (channel + 1 > card->port_count) {
-                printk(KERN_WARNING "ISICOM: isicom_interrupt(0x%x): %d(channel) > port_count.\n",
-                                base, channel+1);
+                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;                     
+                return IRQ_HANDLED;
         }
         port = card->ports + channel;
         if (!(port->flags & ASYNC_INITIALIZED)) {
@@ -813,8 +593,8 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id,
                 else
                         outw(0x0000, base+0x04); /* enable interrupts */
                 return IRQ_HANDLED;
-        }       
-                
+        }
+
         tty = port->tty;
         if (tty == NULL) {
                 word_count = byte_count >> 1;
@@ -831,224 +611,204 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id,
                 spin_unlock(&card->card_lock);
                 return IRQ_HANDLED;
         }
-        
+
         if (header & 0x8000) {          /* Status Packet */
                 header = inw(base);
                 switch(header & 0xff) {
-                        case 0: /* Change in EIA signals */
-                                
-                                if (port->flags & ASYNC_CHECK_CD) {
-                                        if (port->status & ISI_DCD) {
-                                                if (!(header & ISI_DCD)) {
-                                                /* Carrier has been lost  */
-#ifdef ISICOM_DEBUG                                             
-                                                        printk(KERN_DEBUG "ISICOM: interrupt: DCD->low.\n");
-#endif                                                  
-                                                        port->status &= ~ISI_DCD;
-                                                        schedule_work(&port->hangup_tq);
-                                                }
-                                        }
-                                        else {
-                                                if (header & ISI_DCD) {
-                                                /* Carrier has been detected */
-#ifdef ISICOM_DEBUG
-                                                        printk(KERN_DEBUG "ISICOM: interrupt: DCD->high.\n");
-#endif                                                  
-                                                        port->status |= ISI_DCD;
-                                                        wake_up_interruptible(&port->open_wait);
-                                                }
-                                        }
-                                }
-                                else {
-                                        if (header & ISI_DCD) 
-                                                port->status |= ISI_DCD;
-                                        else
+                case 0: /* Change in EIA signals */
+                        if (port->flags & ASYNC_CHECK_CD) {
+                                if (port->status & ISI_DCD) {
+                                        if (!(header & ISI_DCD)) {
+                                        /* Carrier has been lost  */
+                                                pr_dbg("interrupt: DCD->low.\n"
+                                                        );
                                                 port->status &= ~ISI_DCD;
-                                }       
-                                
-                                if (port->flags & ASYNC_CTS_FLOW) {
-                                        if (port->tty->hw_stopped) {
-                                                if (header & ISI_CTS) {
-                                                        port->tty->hw_stopped = 0;
-                                                        /* start tx ing */
-                                                        port->status |= (ISI_TXOK | ISI_CTS);
-                                                        schedule_work(&port->bh_tqueue);
-                                                }
-                                        }
-                                        else {
-                                                if (!(header & ISI_CTS)) {
-                                                        port->tty->hw_stopped = 1;
-                                                        /* stop tx ing */
-                                                        port->status &= ~(ISI_TXOK | ISI_CTS);
-                                                }
+                                                schedule_work(&port->hangup_tq);
                                         }
+                                } else if (header & ISI_DCD) {
+                                /* Carrier has been detected */
+                                        pr_dbg("interrupt: DCD->high.\n");
+                                        port->status |= ISI_DCD;
+                                        wake_up_interruptible(&port->open_wait);
                                 }
-                                else {
-                                        if (header & ISI_CTS) 
-                                                port->status |= ISI_CTS;
-                                        else
-                                                port->status &= ~ISI_CTS;
-                                }
-                                
-                                if (header & ISI_DSR) 
-                                        port->status |= ISI_DSR;
+                        } else {
+                                if (header & ISI_DCD)
+                                        port->status |= ISI_DCD;
                                 else
-                                        port->status &= ~ISI_DSR;
-                                
-                                if (header & ISI_RI) 
-                                        port->status |= ISI_RI;
+                                        port->status &= ~ISI_DCD;
+                        }
+
+                        if (port->flags & ASYNC_CTS_FLOW) {
+                                if (port->tty->hw_stopped) {
+                                        if (header & ISI_CTS) {
+                                                port->tty->hw_stopped = 0;
+                                                /* start tx ing */
+                                                port->status |= (ISI_TXOK
+                                                        | ISI_CTS);
+                                                schedule_work(&port->bh_tqueue);
+                                        }
+                                } else if (!(header & ISI_CTS)) {
+                                        port->tty->hw_stopped = 1;
+                                        /* stop tx ing */
+                                        port->status &= ~(ISI_TXOK | ISI_CTS);
+                                }
+                        } else {
+                                if (header & ISI_CTS)
+                                        port->status |= ISI_CTS;
                                 else
-                                        port->status &= ~ISI_RI;                                                
-                                
-                                break;
-                                
-                        case 1: /* Received Break !!!    */
-                                if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                                        break;
-                                *tty->flip.flag_buf_ptr++ = TTY_BREAK;
-                                *tty->flip.char_buf_ptr++ = 0;
-                                tty->flip.count++;
-                                if (port->flags & ASYNC_SAK)
-                                        do_SAK(tty);
-                                schedule_delayed_work(&tty->flip.work, 1);
-                                break;
-                                
-                        case 2: /* Statistics            */
-                                printk(KERN_DEBUG "ISICOM: isicom_interrupt: stats!!!.\n");                     
-                                break;
-                                
-                        default:
-                                printk(KERN_WARNING "ISICOM: Intr: Unknown code in status packet.\n");
-                                break;
-                }        
-        }
-        else {                          /* Data   Packet */
-                count = min_t(unsigned short, byte_count, (TTY_FLIPBUF_SIZE - tty->flip.count));
-#ifdef ISICOM_DEBUG
-                printk(KERN_DEBUG "ISICOM: Intr: Can rx %d of %d bytes.\n", 
-                                        count, byte_count);
-#endif                  
+                                        port->status &= ~ISI_CTS;
+                        }
+
+                        if (header & ISI_DSR)
+                                port->status |= ISI_DSR;
+                        else
+                                port->status &= ~ISI_DSR;
+
+                        if (header & ISI_RI)
+                                port->status |= ISI_RI;
+                        else
+                                port->status &= ~ISI_RI;
+
+                        break;
+
+                case 1: /* Received Break !!! */
+                        tty_insert_flip_char(tty, 0, TTY_BREAK);
+                        if (port->flags & ASYNC_SAK)
+                                do_SAK(tty);
+                        tty_flip_buffer_push(tty);
+                        break;
+
+                case 2: /* Statistics            */
+                        pr_dbg("isicom_interrupt: stats!!!.\n");
+                        break;
+
+                default:
+                        pr_dbg("Intr: Unknown code in status packet.\n");
+                        break;
+                }
+        } else {                                /* Data   Packet */
+
+                count = tty_prepare_flip_string(tty, &rp, byte_count & ~1);
+                pr_dbg("Intr: Can rx %d of %d bytes.\n", count, byte_count);
                 word_count = count >> 1;
-                insw(base, tty->flip.char_buf_ptr, word_count);
-                tty->flip.char_buf_ptr += (word_count << 1);            
+                insw(base, rp, word_count);
                 byte_count -= (word_count << 1);
                 if (count & 0x0001) {
-                        *tty->flip.char_buf_ptr++ = (char)(inw(base) & 0xff);
+                        tty_insert_flip_char(tty,  inw(base) & 0xff,
+                                TTY_NORMAL);
                         byte_count -= 2;
-                }       
-                memset(tty->flip.flag_buf_ptr, 0, count);
-                tty->flip.flag_buf_ptr += count;
-                tty->flip.count += count;
-                
+                }
                 if (byte_count > 0) {
-                        printk(KERN_DEBUG "ISICOM: Intr(0x%x:%d): Flip buffer overflow! dropping bytes...\n",
-                                        base, channel+1);
+                        pr_dbg("Intr(0x%lx:%d): Flip buffer overflow! dropping "
+                                "bytes...\n", base, channel + 1);
                         while(byte_count > 0) { /* drain out unread xtra data */
                                 inw(base);
                                 byte_count -= 2;
                         }
                 }
-                schedule_delayed_work(&tty->flip.work, 1);
+                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;
-} 
+}
 
-static void isicom_config_port(struct isi_port * port)
+static void isicom_config_port(struct isi_port *port)
 {
-        struct isi_board * card = port->card;
-        struct tty_struct * tty;
+        struct isi_board *card = port->card;
+        struct tty_struct *tty;
         unsigned long baud;
-        unsigned short channel_setup, base = card->base;
-        unsigned short channel = port->channel, shift_count = card->shift_count;
+        unsigned long base = card->base;
+        u16 channel_setup, channel = port->channel,
+                shift_count = card->shift_count;
         unsigned char flow_ctrl;
-        
+
         if (!(tty = port->tty) || !tty->termios)
                 return;
         baud = C_BAUD(tty);
         if (baud & CBAUDEX) {
                 baud &= ~CBAUDEX;
-                
+
                 /*  if CBAUDEX bit is on and the baud is set to either 50 or 75
                  *  then the card is programmed for 57.6Kbps or 115Kbps
                  *  respectively.
-                 */   
-                 
+                 */
+
                 if (baud < 1 || baud > 2)
                         port->tty->termios->c_cflag &= ~CBAUDEX;
                 else
                         baud += 15;
-        }       
+        }
         if (baud == 15) {
-        
-                /*  the ASYNC_SPD_HI and ASYNC_SPD_VHI options are set 
+
+                /*  the ASYNC_SPD_HI and ASYNC_SPD_VHI options are set
                  *  by the set_serial_info ioctl ... this is done by
                  *  the 'setserial' utility.
-                 */  
-                        
+                 */
+
                 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
-                        baud++;     /*  57.6 Kbps */
+                        baud++; /*  57.6 Kbps */
                 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
-                        baud +=2;   /*  115  Kbps */     
+                        baud +=2; /*  115  Kbps */
         }
         if (linuxb_to_isib[baud] == -1) {
                 /* hang up */
-                drop_dtr(port);
-                return;
-        }       
-        else  
+                drop_dtr(port);
+                return;
+        }
+        else
                 raise_dtr(port);
-                
+
         if (lock_card(card)) {
                 outw(0x8000 | (channel << shift_count) |0x03, base);
                 outw(linuxb_to_isib[baud] << 8 | 0x03, base);
                 channel_setup = 0;
                 switch(C_CSIZE(tty)) {
-                        case CS5:
-                                channel_setup |= ISICOM_CS5;
-                                break;
-                        case CS6:
-                                channel_setup |= ISICOM_CS6;
-                                break;
-                        case CS7:
-                                channel_setup |= ISICOM_CS7;
-                                break;
-                        case CS8:
-                                channel_setup |= ISICOM_CS8;
-                                break;
+                case CS5:
+                        channel_setup |= ISICOM_CS5;
+                        break;
+                case CS6:
+                        channel_setup |= ISICOM_CS6;
+                        break;
+                case CS7:
+                        channel_setup |= ISICOM_CS7;
+                        break;
+                case CS8:
+                        channel_setup |= ISICOM_CS8;
+                        break;
                 }
-                        
+
                 if (C_CSTOPB(tty))
                         channel_setup |= ISICOM_2SB;
                 if (C_PARENB(tty)) {
                         channel_setup |= ISICOM_EVPAR;
                         if (C_PARODD(tty))
-                                channel_setup |= ISICOM_ODPAR;  
+                                channel_setup |= ISICOM_ODPAR;
                 }
-                outw(channel_setup, base);      
+                outw(channel_setup, base);
                 InterruptTheCard(base);
-                unlock_card(card);      
-        }       
+                unlock_card(card);
+        }
         if (C_CLOCAL(tty))
                 port->flags &= ~ASYNC_CHECK_CD;
         else
-                port->flags |= ASYNC_CHECK_CD;  
-        
+                port->flags |= ASYNC_CHECK_CD;
+
         /* flow control settings ...*/
         flow_ctrl = 0;
         port->flags &= ~ASYNC_CTS_FLOW;
         if (C_CRTSCTS(tty)) {
                 port->flags |= ASYNC_CTS_FLOW;
                 flow_ctrl |= ISICOM_CTSRTS;
-        }       
-        if (I_IXON(tty))        
+        }
+        if (I_IXON(tty))
                 flow_ctrl |= ISICOM_RESPOND_XONXOFF;
         if (I_IXOFF(tty))
-                flow_ctrl |= ISICOM_INITIATE_XONXOFF;   
-                
+                flow_ctrl |= ISICOM_INITIATE_XONXOFF;
+
         if (lock_card(card)) {
                 outw(0x8000 | (channel << shift_count) |0x04, base);
                 outw(flow_ctrl << 8 | 0x05, base);
@@ -1056,22 +816,22 @@ static void isicom_config_port(struct isi_port * port)
                 InterruptTheCard(base);
                 unlock_card(card);
         }
-        
+
         /*      rx enabled -> enable port for rx on the card    */
         if (C_CREAD(tty)) {
                 card->port_status |= (1 << channel);
                 outw(card->port_status, base + 0x02);
         }
 }
- 
-/* open et all */ 
 
-static inline void isicom_setup_board(struct isi_board * bp)
+/* open et all */
+
+static inline void isicom_setup_board(struct isi_board *bp)
 {
         int channel;
-        struct isi_port * port;
+        struct isi_port *port;
         unsigned long flags;
-        
+
         spin_lock_irqsave(&bp->card_lock, flags);
         if (bp->status & BOARD_ACTIVE) {
                 spin_unlock_irqrestore(&bp->card_lock, flags);
@@ -1080,53 +840,54 @@ static inline void isicom_setup_board(struct isi_board * bp)
         port = bp->ports;
         bp->status |= BOARD_ACTIVE;
         spin_unlock_irqrestore(&bp->card_lock, flags);
-        for(channel = 0; channel < bp->port_count; channel++, port++)
+        for (channel = 0; channel < bp->port_count; channel++, port++)
                 drop_dtr_rts(port);
         return;
 }
- 
-static int isicom_setup_port(struct isi_port * port)
+
+static int isicom_setup_port(struct isi_port *port)
 {
-        struct isi_board * card = port->card;
+        struct isi_board *card = port->card;
         unsigned long flags;
-        
+
         if (port->flags & ASYNC_INITIALIZED) {
                 return 0;
         }
         if (!port->xmit_buf) {
                 unsigned long page;
-                
+
                 if (!(page = get_zeroed_page(GFP_KERNEL)))
                         return -ENOMEM;
-                
+
                 if (port->xmit_buf) {
                         free_page(page);
                         return -ERESTARTSYS;
                 }
-                port->xmit_buf = (unsigned char *) page;        
-        }       
+                port->xmit_buf = (unsigned char *) page;
+        }
 
         spin_lock_irqsave(&card->card_lock, flags);
         if (port->tty)
                 clear_bit(TTY_IO_ERROR, &port->tty->flags);
         if (port->count == 1)
                 card->count++;
-                
+
         port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
-        
+
         /*      discard any residual data       */
         kill_queue(port, ISICOM_KILLTX | ISICOM_KILLRX);
-        
+
         isicom_config_port(port);
         port->flags |= ASYNC_INITIALIZED;
         spin_unlock_irqrestore(&card->card_lock, flags);
-        
-        return 0;               
-} 
- 
-static int block_til_ready(struct tty_struct * tty, struct file * filp, struct isi_port * port) 
+
+        return 0;
+}
+
+static int block_til_ready(struct tty_struct *tty, struct file *filp,
+        struct isi_port *port)
 {
-        struct isi_board * card = port->card;
+        struct isi_board *card = port->card;
         int do_clocal = 0, retval;
         unsigned long flags;
         DECLARE_WAITQUEUE(wait, current);
@@ -1134,30 +895,27 @@ static int block_til_ready(struct tty_struct * tty, struct file * filp, struct i
         /* block if port is in the process of being closed */
 
         if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
-#ifdef ISICOM_DEBUG     
-                printk(KERN_DEBUG "ISICOM: block_til_ready: close in progress.\n");
-#endif          
+                pr_dbg("block_til_ready: close in progress.\n");
                 interruptible_sleep_on(&port->close_wait);
                 if (port->flags & ASYNC_HUP_NOTIFY)
                         return -EAGAIN;
                 else
                         return -ERESTARTSYS;
         }
-        
+
         /* if non-blocking mode is set ... */
-        
-        if ((filp->f_flags & O_NONBLOCK) || (tty->flags & (1 << TTY_IO_ERROR))) {
-#ifdef ISICOM_DEBUG     
-                printk(KERN_DEBUG "ISICOM: block_til_ready: non-block mode.\n");
-#endif          
+
+        if ((filp->f_flags & O_NONBLOCK) ||
+                        (tty->flags & (1 << TTY_IO_ERROR))) {
+                pr_dbg("block_til_ready: non-block mode.\n");
                 port->flags |= ASYNC_NORMAL_ACTIVE;
-                return 0;       
-        }       
-        
+                return 0;
+        }
+
         if (C_CLOCAL(tty))
                 do_clocal = 1;
-        
-        /* block waiting for DCD to be asserted, and while 
+
+        /* block waiting for DCD to be asserted, and while
                                                 callout dev is busy */
         retval = 0;
         add_wait_queue(&port->open_wait, &wait);
@@ -1167,27 +925,27 @@ static int block_til_ready(struct tty_struct * tty, struct file * filp, struct i
                 port->count--;
         port->blocked_open++;
         spin_unlock_irqrestore(&card->card_lock, flags);
-        
+
         while (1) {
                 raise_dtr_rts(port);
 
                 set_current_state(TASK_INTERRUPTIBLE);
-                if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {        
+                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 || (port->status & ISI_DCD))) {
+                                (do_clocal || (port->status & ISI_DCD))) {
                         break;
-                }       
+                }
                 if (signal_pending(current)) {
                         retval = -ERESTARTSYS;
                         break;
                 }
-                schedule();             
+                schedule();
         }
         set_current_state(TASK_RUNNING);
         remove_wait_queue(&port->open_wait, &wait);
@@ -1201,11 +959,11 @@ static int block_til_ready(struct tty_struct * tty, struct file * filp, struct i
         port->flags |= ASYNC_NORMAL_ACTIVE;
         return 0;
 }
- 
-static int isicom_open(struct tty_struct * tty, struct file * filp)
+
+static int isicom_open(struct tty_struct *tty, struct file *filp)
 {
-        struct isi_port * port;
-        struct isi_board * card;
+        struct isi_port *port;
+        struct isi_board *card;
         unsigned int line, board;
         int error;
 
@@ -1214,20 +972,20 @@ static int isicom_open(struct tty_struct * tty, struct file * filp)
                 return -ENODEV;
         board = BOARD(line);
         card = &isi_card[board];
-        
+
         if (!(card->status & FIRMWARE_LOADED))
                 return -ENODEV;
-        
+
         /*  open on a port greater than the port count for the card !!! */
         if (line > ((board * 16) + card->port_count - 1))
                 return -ENODEV;
 
-        port = &isi_ports[line];        
+        port = &isi_ports[line];
         if (isicom_paranoia_check(port, tty->name, "isicom_open"))
                 return -ENODEV;
-                
-        isicom_setup_board(card);               
-        
+
+        isicom_setup_board(card);
+
         port->count++;
         tty->driver_data = port;
         port->tty = tty;
@@ -1236,12 +994,12 @@ static int isicom_open(struct tty_struct * tty, struct file * filp)
         if ((error = block_til_ready(tty, filp, port))!=0)
                 return error;
 
-        return 0;               
+        return 0;
 }
- 
+
 /* close et all */
 
-static inline void isicom_shutdown_board(struct isi_board * bp)
+static inline void isicom_shutdown_board(struct isi_board *bp)
 {
         unsigned long flags;
 
@@ -1252,15 +1010,15 @@ static inline void isicom_shutdown_board(struct isi_board * bp)
         spin_unlock_irqrestore(&bp->card_lock, flags);
 }
 
-static void isicom_shutdown_port(struct isi_port * port)
+static void isicom_shutdown_port(struct isi_port *port)
 {
-        struct isi_board * card = port->card;
-        struct tty_struct * tty;        
+        struct isi_board *card = port->card;
+        struct tty_struct *tty;
         unsigned long flags;
-        
+
         tty = port->tty;
 
-        spin_lock_irqsave(&card->card_lock, flags);     
+        spin_lock_irqsave(&card->card_lock, flags);
         if (!(port->flags & ASYNC_INITIALIZED)) {
                 spin_unlock_irqrestore(&card->card_lock, flags);
                 return;
@@ -1268,93 +1026,91 @@ static void isicom_shutdown_port(struct isi_port * port)
         if (port->xmit_buf) {
                 free_page((unsigned long) port->xmit_buf);
                 port->xmit_buf = NULL;
-        }       
+        }
         port->flags &= ~ASYNC_INITIALIZED;
         /* 3rd October 2000 : Vinayak P Risbud */
         port->tty = NULL;
         spin_unlock_irqrestore(&card->card_lock, flags);
-        
+
         /*Fix done by Anil .S on 30-04-2001
         remote login through isi port has dtr toggle problem
         due to which the carrier drops before the password prompt
-        appears on the remote end. Now we drop the dtr only if the 
+        appears on the remote end. Now we drop the dtr only if the
         HUPCL(Hangup on close) flag is set for the tty*/
-        
-        if (C_HUPCL(tty)) 
+
+        if (C_HUPCL(tty))
                 /* drop dtr on this port */
                 drop_dtr(port);
-                
-        /* any other port uninits  */ 
+
+        /* any other port uninits  */
         if (tty)
                 set_bit(TTY_IO_ERROR, &tty->flags);
-        
+
         if (--card->count < 0) {
-                printk(KERN_DEBUG "ISICOM: isicom_shutdown_port: bad board(0x%x) count %d.\n",
+                pr_dbg("isicom_shutdown_port: bad board(0x%lx) count %d.\n",
                         card->base, card->count);
-                card->count = 0;        
+                card->count = 0;
         }
-        
-        /* last port was closed , shutdown that boad too */
-        if(C_HUPCL(tty)) {
+
+        /* last port was closed, shutdown that boad too */
+        if (C_HUPCL(tty)) {
                 if (!card->count)
                         isicom_shutdown_board(card);
         }
 }
 
-static void isicom_close(struct tty_struct * tty, struct file * filp)
+static void isicom_close(struct tty_struct *tty, struct file *filp)
 {
-        struct isi_port * port = (struct isi_port *) tty->driver_data;
-        struct isi_board * card = port->card;
+        struct isi_port *port = tty->driver_data;
+        struct isi_board *card = port->card;
         unsigned long flags;
-        
+
         if (!port)
                 return;
         if (isicom_paranoia_check(port, tty->name, "isicom_close"))
                 return;
-        
-#ifdef ISICOM_DEBUG             
-        printk(KERN_DEBUG "ISICOM: Close start!!!.\n");
-#endif  
-        
+
+        pr_dbg("Close start!!!.\n");
+
         spin_lock_irqsave(&card->card_lock, flags);
         if (tty_hung_up_p(filp)) {
                 spin_unlock_irqrestore(&card->card_lock, flags);
                 return;
         }
-        
+
         if (tty->count == 1 && port->count != 1) {
-                printk(KERN_WARNING "ISICOM:(0x%x) isicom_close: bad port count"
-                        "tty->count = 1 port count = %d.\n",
+                printk(KERN_WARNING "ISICOM:(0x%lx) isicom_close: bad port "
+                        "count tty->count = 1 port count = %d.\n",
                         card->base, port->count);
                 port->count = 1;
         }
         if (--port->count < 0) {
-                printk(KERN_WARNING "ISICOM:(0x%x) isicom_close: bad port count for"
-                        "channel%d = %d", card->base, port->channel, 
+                printk(KERN_WARNING "ISICOM:(0x%lx) isicom_close: bad port "
+                        "count for channel%d = %d", card->base, port->channel,
                         port->count);
-                port->count = 0;        
+                port->count = 0;
         }
-        
+
         if (port->count) {
                 spin_unlock_irqrestore(&card->card_lock, flags);
                 return;
-        }       
+        }
         port->flags |= ASYNC_CLOSING;
         tty->closing = 1;
         spin_unlock_irqrestore(&card->card_lock, flags);
-        
+
         if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
                 tty_wait_until_sent(tty, port->closing_wait);
-        /* indicate to the card that no more data can be received 
+        /* indicate to the card that no more data can be received
            on this port */
         spin_lock_irqsave(&card->card_lock, flags);
-        if (port->flags & ASYNC_INITIALIZED) {   
+        if (port->flags & ASYNC_INITIALIZED) {
                 card->port_status &= ~(1 << port->channel);
                 outw(card->port_status, card->base + 0x02);
-        }       
+        }
         isicom_shutdown_port(port);
         spin_unlock_irqrestore(&card->card_lock, flags);
-        
+
         if (tty->driver->flush_buffer)
                 tty->driver->flush_buffer(tty);
         tty_ldisc_flush(tty);
@@ -1365,65 +1121,65 @@ static void isicom_close(struct tty_struct * tty, struct file * filp)
         if (port->blocked_open) {
                 spin_unlock_irqrestore(&card->card_lock, flags);
                 if (port->close_delay) {
-#ifdef ISICOM_DEBUG                     
-                        printk(KERN_DEBUG "ISICOM: scheduling until time out.\n");
-#endif                  
-                        msleep_interruptible(jiffies_to_msecs(port->close_delay));
+                        pr_dbg("scheduling until time out.\n");
+                        msleep_interruptible(
+                                jiffies_to_msecs(port->close_delay));
                 }
                 spin_lock_irqsave(&card->card_lock, flags);
                 wake_up_interruptible(&port->open_wait);
-        }       
+        }
         port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
         wake_up_interruptible(&port->close_wait);
         spin_unlock_irqrestore(&card->card_lock, flags);
 }
 
 /* write et all */
-static int isicom_write(struct tty_struct * tty,
-                        const unsigned char * buf, int count)
+static int isicom_write(struct tty_struct *tty, const unsigned char *buf,
+        int count)
 {
-        struct isi_port * port = (struct isi_port *) tty->driver_data;
-        struct isi_board * card = port->card;
+        struct isi_port *port = tty->driver_data;
+        struct isi_board *card = port->card;
         unsigned long flags;
         int cnt, total = 0;
 
         if (isicom_paranoia_check(port, tty->name, "isicom_write"))
                 return 0;
-        
-        if (!tty || !port->xmit_buf || !tmp_buf)
+
+        if (!tty || !port->xmit_buf)
                 return 0;
-                
+
         spin_lock_irqsave(&card->card_lock, flags);
-        
-        while(1) {      
-                cnt = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
-                                            SERIAL_XMIT_SIZE - port->xmit_head));
-                if (cnt <= 0) 
+
+        while(1) {
+                cnt = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt
+                                - 1, SERIAL_XMIT_SIZE - port->xmit_head));
+                if (cnt <= 0)
                         break;
-                
+
                 memcpy(port->xmit_buf + port->xmit_head, buf, cnt);
-                port->xmit_head = (port->xmit_head + cnt) & (SERIAL_XMIT_SIZE - 1);
+                port->xmit_head = (port->xmit_head + cnt) & (SERIAL_XMIT_SIZE
+                        - 1);
                 port->xmit_cnt += cnt;
                 buf += cnt;
                 count -= cnt;
                 total += cnt;
-        }               
+        }
         if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped)
                 port->status |= ISI_TXOK;
         spin_unlock_irqrestore(&card->card_lock, flags);
-        return total;   
+        return total;
 }
 
 /* put_char et all */
-static void isicom_put_char(struct tty_struct * tty, unsigned char ch)
+static void isicom_put_char(struct tty_struct *tty, unsigned char ch)
 {
-        struct isi_port * port = (struct isi_port *) tty->driver_data;
-        struct isi_board * card = port->card;
+        struct isi_port *port = tty->driver_data;
+        struct isi_board *card = port->card;
         unsigned long flags;
-        
+
         if (isicom_paranoia_check(port, tty->name, "isicom_put_char"))
                 return;
-        
+
         if (!tty || !port->xmit_buf)
                 return;
 
@@ -1432,7 +1188,7 @@ static void isicom_put_char(struct tty_struct * tty, unsigned char ch)
                 spin_unlock_irqrestore(&card->card_lock, flags);
                 return;
         }
-        
+
         port->xmit_buf[port->xmit_head++] = ch;
         port->xmit_head &= (SERIAL_XMIT_SIZE - 1);
         port->xmit_cnt++;
@@ -1440,30 +1196,31 @@ static void isicom_put_char(struct tty_struct * tty, unsigned char ch)
 }
 
 /* flush_chars et all */
-static void isicom_flush_chars(struct tty_struct * tty)
+static void isicom_flush_chars(struct tty_struct *tty)
 {
-        struct isi_port * port = (struct isi_port *) tty->driver_data;
-        
+        struct isi_port *port = tty->driver_data;
+
         if (isicom_paranoia_check(port, tty->name, "isicom_flush_chars"))
                 return;
-        
-        if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped || !port->xmit_buf)
+
+        if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
+                        !port->xmit_buf)
                 return;
-                
+
         /* this tells the transmitter to consider this port for
            data output to the card ... that's the best we can do. */
-        port->status |= ISI_TXOK;       
+        port->status |= ISI_TXOK;
 }
 
 /* write_room et all */
-static int isicom_write_room(struct tty_struct * tty)
+static int isicom_write_room(struct tty_struct *tty)
 {
-        struct isi_port * port = (struct isi_port *) tty->driver_data;
+        struct isi_port *port = tty->driver_data;
         int free;
 
         if (isicom_paranoia_check(port, tty->name, "isicom_write_room"))
                 return 0;
-        
+
         free = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
         if (free < 0)
                 free = 0;
@@ -1471,23 +1228,24 @@ static int isicom_write_room(struct tty_struct * tty)
 }
 
 /* chars_in_buffer et all */
-static int isicom_chars_in_buffer(struct tty_struct * tty)
+static int isicom_chars_in_buffer(struct tty_struct *tty)
 {
-        struct isi_port * port = (struct isi_port *) tty->driver_data;
+        struct isi_port *port = tty->driver_data;
         if (isicom_paranoia_check(port, tty->name, "isicom_chars_in_buffer"))
                 return 0;
         return port->xmit_cnt;
 }
 
 /* ioctl et all */
-static inline void isicom_send_break(struct isi_port * port, unsigned long length)
+static inline void isicom_send_break(struct isi_port *port,
+        unsigned long length)
 {
-        struct isi_board * card = port->card;
-        unsigned short base = card->base;       
-        
-        if(!lock_card(card))
+        struct isi_board *card = port->card;
+        unsigned long base = card->base;
+
+        if (!lock_card(card))
                 return;
-                
+
         outw(0x8000 | ((port->channel) << (card->shift_count)) | 0x3, base);
         outw((length & 0xff) << 8 | 0x00, base);
         outw((length & 0xff00), base);
@@ -1498,13 +1256,13 @@ static inline void isicom_send_break(struct isi_port * port, unsigned long lengt
 
 static int isicom_tiocmget(struct tty_struct *tty, struct file *file)
 {
-        struct isi_port * port = (struct isi_port *) tty->driver_data;
+        struct isi_port *port = tty->driver_data;
         /* just send the port status */
-        unsigned short status = port->status;
+        u16 status = port->status;
 
         if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
                 return -ENODEV;
-        
+
         return  ((status & ISI_RTS) ? TIOCM_RTS : 0) |
                 ((status & ISI_DTR) ? TIOCM_DTR : 0) |
                 ((status & ISI_DCD) ? TIOCM_CAR : 0) |
@@ -1514,13 +1272,13 @@ static int isicom_tiocmget(struct tty_struct *tty, struct file *file)
 }
 
 static int isicom_tiocmset(struct tty_struct *tty, struct file *file,
-                           unsigned int set, unsigned int clear)
+        unsigned int set, unsigned int clear)
 {
-        struct isi_port * port = (struct isi_port *) tty->driver_data;
-        
+        struct isi_port *port = tty->driver_data;
+
         if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
                 return -ENODEV;
-        
+
         if (set & TIOCM_RTS)
                 raise_rts(port);
         if (set & TIOCM_DTR)
@@ -1532,46 +1290,46 @@ static int isicom_tiocmset(struct tty_struct *tty, struct file *file,
                 drop_dtr(port);
 
         return 0;
-}                       
+}
 
-static int isicom_set_serial_info(struct isi_port * port,
-                                        struct serial_struct __user *info)
+static int isicom_set_serial_info(struct isi_port *port,
+        struct serial_struct __user *info)
 {
         struct serial_struct newinfo;
         int reconfig_port;
 
-        if(copy_from_user(&newinfo, info, sizeof(newinfo)))
+        if (copy_from_user(&newinfo, info, sizeof(newinfo)))
                 return -EFAULT;
-                
-        reconfig_port = ((port->flags & ASYNC_SPD_MASK) != 
-                         (newinfo.flags & ASYNC_SPD_MASK));
-        
+
+        reconfig_port = ((port->flags & ASYNC_SPD_MASK) !=
+                (newinfo.flags & ASYNC_SPD_MASK));
+
         if (!capable(CAP_SYS_ADMIN)) {
                 if ((newinfo.close_delay != port->close_delay) ||
-                    (newinfo.closing_wait != port->closing_wait) ||
-                    ((newinfo.flags & ~ASYNC_USR_MASK) != 
-                     (port->flags & ~ASYNC_USR_MASK)))
+                                (newinfo.closing_wait != port->closing_wait) ||
+                                ((newinfo.flags & ~ASYNC_USR_MASK) !=
+                                (port->flags & ~ASYNC_USR_MASK)))
                         return -EPERM;
                 port->flags = ((port->flags & ~ ASYNC_USR_MASK) |
                                 (newinfo.flags & ASYNC_USR_MASK));
-        }       
+        }
         else {
                 port->close_delay = newinfo.close_delay;
-                port->closing_wait = newinfo.closing_wait; 
-                port->flags = ((port->flags & ~ASYNC_FLAGS) | 
+                port->closing_wait = newinfo.closing_wait;
+                port->flags = ((port->flags & ~ASYNC_FLAGS) |
                                 (newinfo.flags & ASYNC_FLAGS));
         }
         if (reconfig_port) {
                 isicom_config_port(port);
         }
-        return 0;                
-}               
+        return 0;
+}
 
-static int isicom_get_serial_info(struct isi_port * port, 
-                                        struct serial_struct __user *info)
+static int isicom_get_serial_info(struct isi_port *port,
+        struct serial_struct __user *info)
 {
         struct serial_struct out_info;
-        
+
         memset(&out_info, 0, sizeof(out_info));
 /*      out_info.type = ? */
         out_info.line = port - isi_ports;
@@ -1581,15 +1339,15 @@ static int isicom_get_serial_info(struct isi_port * port,
 /*      out_info.baud_base = ? */
         out_info.close_delay = port->close_delay;
         out_info.closing_wait = port->closing_wait;
-        if(copy_to_user(info, &out_info, sizeof(out_info)))
+        if (copy_to_user(info, &out_info, sizeof(out_info)))
                 return -EFAULT;
         return 0;
-}                                       
+}
 
-static int isicom_ioctl(struct tty_struct * tty, struct file * filp,
-                        unsigned int cmd, unsigned long arg) 
+static int isicom_ioctl(struct tty_struct *tty, struct file *filp,
+        unsigned int cmd, unsigned long arg)
 {
-        struct isi_port * port = (struct isi_port *) tty->driver_data;
+        struct isi_port *port = tty->driver_data;
         void __user *argp = (void __user *)arg;
         int retval;
 
@@ -1597,139 +1355,141 @@ static int isicom_ioctl(struct tty_struct * tty, struct file * filp,
                 return -ENODEV;
 
         switch(cmd) {
-                case TCSBRK:
-                        retval = tty_check_change(tty);
-                        if (retval)
-                                return retval;
-                        tty_wait_until_sent(tty, 0);
-                        if (!arg)
-                                isicom_send_break(port, HZ/4);
-                        return 0;
-                        
-                case TCSBRKP:   
-                        retval = tty_check_change(tty);
-                        if (retval)
-                                return retval;
-                        tty_wait_until_sent(tty, 0);
-                        isicom_send_break(port, 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(arg, (unsigned long __user *) argp))
-                                return -EFAULT;
-                        tty->termios->c_cflag =
-                                ((tty->termios->c_cflag & ~CLOCAL) |
-                                (arg ? CLOCAL : 0));
-                        return 0;       
-                        
-                case TIOCGSERIAL:
-                        return isicom_get_serial_info(port, argp);
-                
-                case TIOCSSERIAL:
-                        return isicom_set_serial_info(port, argp);
-                                        
-                default:
-                        return -ENOIOCTLCMD;                                            
+        case TCSBRK:
+                retval = tty_check_change(tty);
+                if (retval)
+                        return retval;
+                tty_wait_until_sent(tty, 0);
+                if (!arg)
+                        isicom_send_break(port, HZ/4);
+                return 0;
+
+        case TCSBRKP:
+                retval = tty_check_change(tty);
+                if (retval)
+                        return retval;
+                tty_wait_until_sent(tty, 0);
+                isicom_send_break(port, 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(arg, (unsigned long __user *) argp))
+                        return -EFAULT;
+                tty->termios->c_cflag =
+                        ((tty->termios->c_cflag & ~CLOCAL) |
+                        (arg ? CLOCAL : 0));
+                return 0;
+
+        case TIOCGSERIAL:
+                return isicom_get_serial_info(port, argp);
+
+        case TIOCSSERIAL:
+                return isicom_set_serial_info(port, argp);
+
+        default:
+                return -ENOIOCTLCMD;
         }
         return 0;
 }
 
 /* set_termios et all */
-static void isicom_set_termios(struct tty_struct * tty, struct termios * old_termios)
+static void isicom_set_termios(struct tty_struct *tty,
+        struct termios *old_termios)
 {
-        struct isi_port * port = (struct isi_port *) tty->driver_data;
-        
+        struct isi_port *port = tty->driver_data;
+
         if (isicom_paranoia_check(port, tty->name, "isicom_set_termios"))
                 return;
-        
+
         if (tty->termios->c_cflag == old_termios->c_cflag &&
-            tty->termios->c_iflag == old_termios->c_iflag)
+                        tty->termios->c_iflag == old_termios->c_iflag)
                 return;
-                
+
         isicom_config_port(port);
-        
+
         if ((old_termios->c_cflag & CRTSCTS) &&
-            !(tty->termios->c_cflag & CRTSCTS)) {       
+                        !(tty->termios->c_cflag & CRTSCTS)) {
                 tty->hw_stopped = 0;
-                isicom_start(tty);   
-        }    
+                isicom_start(tty);
+        }
 }
 
 /* throttle et all */
-static void isicom_throttle(struct tty_struct * tty)
+static void isicom_throttle(struct tty_struct *tty)
 {
-        struct isi_port * port = (struct isi_port *) tty->driver_data;
-        struct isi_board * card = port->card;
-        
+        struct isi_port *port = tty->driver_data;
+        struct isi_board *card = port->card;
+
         if (isicom_paranoia_check(port, tty->name, "isicom_throttle"))
                 return;
-        
+
         /* tell the card that this port cannot handle any more data for now */
         card->port_status &= ~(1 << port->channel);
         outw(card->port_status, card->base + 0x02);
 }
 
 /* unthrottle et all */
-static void isicom_unthrottle(struct tty_struct * tty)
+static void isicom_unthrottle(struct tty_struct *tty)
 {
-        struct isi_port * port = (struct isi_port *) tty->driver_data;
-        struct isi_board * card = port->card;
-        
+        struct isi_port *port = tty->driver_data;
+        struct isi_board *card = port->card;
+
         if (isicom_paranoia_check(port, tty->name, "isicom_unthrottle"))
                 return;
-        
+
         /* tell the card that this port is ready to accept more data */
         card->port_status |= (1 << port->channel);
         outw(card->port_status, card->base + 0x02);
 }
 
 /* stop et all */
-static void isicom_stop(struct tty_struct * tty)
+static void isicom_stop(struct tty_struct *tty)
 {
-        struct isi_port * port = (struct isi_port *) tty->driver_data;
+        struct isi_port *port = tty->driver_data;
 
         if (isicom_paranoia_check(port, tty->name, "isicom_stop"))
                 return;
-        
+
         /* this tells the transmitter not to consider this port for
            data output to the card. */
         port->status &= ~ISI_TXOK;
 }
 
 /* start et all */
-static void isicom_start(struct tty_struct * tty)
+static void isicom_start(struct tty_struct *tty)
 {
-        struct isi_port * port = (struct isi_port *) tty->driver_data;
-        
+        struct isi_port *port = tty->driver_data;
+
         if (isicom_paranoia_check(port, tty->name, "isicom_start"))
                 return;
-        
+
         /* this tells the transmitter to consider this port for
            data output to the card. */
         port->status |= ISI_TXOK;
 }
 
 /* hangup et all */
-static void do_isicom_hangup(void * data)
+static void do_isicom_hangup(void *data)
 {
-        struct isi_port * port = (struct isi_port *) data;
-        struct tty_struct * tty;
-        
+        struct isi_port *port = data;
+        struct tty_struct *tty;
+
         tty = port->tty;
         if (tty)
                 tty_hangup(tty);
 }
 
-static void isicom_hangup(struct tty_struct * tty)
+static void isicom_hangup(struct tty_struct *tty)
 {
-        struct isi_port * port = (struct isi_port *) tty->driver_data;
-        
+        struct isi_port *port = tty->driver_data;
+
         if (isicom_paranoia_check(port, tty->name, "isicom_hangup"))
                 return;
-        
+
         isicom_shutdown_port(port);
         port->count = 0;
         port->flags &= ~ASYNC_NORMAL_ACTIVE;
@@ -1738,342 +1498,540 @@ static void isicom_hangup(struct tty_struct * tty)
 }
 
 /* flush_buffer et all */
-static void isicom_flush_buffer(struct tty_struct * tty)
+static void isicom_flush_buffer(struct tty_struct *tty)
 {
-        struct isi_port * port = (struct isi_port *) tty->driver_data;
-        struct isi_board * card = port->card;
+        struct isi_port *port = tty->driver_data;
+        struct isi_board *card = port->card;
         unsigned long flags;
-        
+
         if (isicom_paranoia_check(port, tty->name, "isicom_flush_buffer"))
                 return;
-        
+
         spin_lock_irqsave(&card->card_lock, flags);
         port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
         spin_unlock_irqrestore(&card->card_lock, flags);
-        
+
         wake_up_interruptible(&tty->write_wait);
         tty_wakeup(tty);
 }
 
+/*
+ * Driver init and deinit functions
+ */
 
-static int __devinit register_ioregion(void)
+static int __devinit isicom_register_ioregion(struct pci_dev *pdev,
+        const unsigned int index)
 {
-        int count, done=0;
-        for (count=0; count < BOARD_COUNT; count++ ) {
-                if (isi_card[count].base)
-                        if (!request_region(isi_card[count].base,16,ISICOM_NAME)) {
-                                printk(KERN_DEBUG "ISICOM: I/O Region 0x%x-0x%x is busy. Card%d will be disabled.\n",
-                                        isi_card[count].base,isi_card[count].base+15,count+1);
-                                isi_card[count].base=0;
-                                done++;
-                        }
-        }
-        return done;
+        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 unregister_ioregion(void)
+static void isicom_unregister_ioregion(struct pci_dev *pdev)
 {
-        int count;
-        for (count=0; count < BOARD_COUNT; count++ ) 
-                if (isi_card[count].base) {
-                        release_region(isi_card[count].base,16);
-#ifdef ISICOM_DEBUG                     
-                        printk(KERN_DEBUG "ISICOM: I/O Region 0x%x-0x%x released for Card%d.\n",isi_card[count].base,isi_card[count].base+15,count+1);
-#endif                  
-                }
+        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 = {
-        .open   = isicom_open,
-        .close  = isicom_close,
-        .write  = isicom_write,
-        .put_char       = isicom_put_char,
-        .flush_chars    = isicom_flush_chars,
-        .write_room     = isicom_write_room,
+        .open                   = isicom_open,
+        .close                  = isicom_close,
+        .write                  = isicom_write,
+        .put_char               = isicom_put_char,
+        .flush_chars            = isicom_flush_chars,
+        .write_room             = isicom_write_room,
         .chars_in_buffer        = isicom_chars_in_buffer,
-        .ioctl  = isicom_ioctl,
-        .set_termios    = isicom_set_termios,
-        .throttle       = isicom_throttle,
-        .unthrottle     = isicom_unthrottle,
-        .stop   = isicom_stop,
-        .start  = isicom_start,
-        .hangup = isicom_hangup,
-        .flush_buffer   = isicom_flush_buffer,
-        .tiocmget       = isicom_tiocmget,
-        .tiocmset       = isicom_tiocmset,
+        .ioctl                  = isicom_ioctl,
+        .set_termios            = isicom_set_termios,
+        .throttle               = isicom_throttle,
+        .unthrottle             = isicom_unthrottle,
+        .stop                   = isicom_stop,
+        .start                  = isicom_start,
+        .hangup                 = isicom_hangup,
+        .flush_buffer           = isicom_flush_buffer,
+        .tiocmget               = isicom_tiocmget,
+        .tiocmset               = isicom_tiocmset,
 };
 
-static int __devinit register_drivers(void)
+static int __devinit isicom_register_tty_driver(void)
 {
-        int error;
+        int error = -ENOMEM;
 
         /* tty driver structure initialization */
         isicom_normal = alloc_tty_driver(PORT_COUNT);
         if (!isicom_normal)
-                return -ENOMEM;
-
-        isicom_normal->owner    = THIS_MODULE;
-        isicom_normal->name     = "ttyM";
-        isicom_normal->devfs_name = "isicom/";
-        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;
+                goto end;
+
+        isicom_normal->owner                    = THIS_MODULE;
+        isicom_normal->name                     = "ttyM";
+        isicom_normal->devfs_name               = "isicom/";
+        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))!=0) {
-                printk(KERN_DEBUG "ISICOM: Couldn't register the dialin driver, error=%d\n",
+
+        if ((error = tty_register_driver(isicom_normal))) {
+                pr_dbg("Couldn't register the dialin driver, error=%d\n",
                         error);
                 put_tty_driver(isicom_normal);
-                return error;
         }
-        return 0;
+end:
+        return error;
 }
 
-static void unregister_drivers(void)
+static void isicom_unregister_tty_driver(void)
 {
-        int error = tty_unregister_driver(isicom_normal);
-        if (error)
-                printk(KERN_DEBUG "ISICOM: couldn't unregister normal driver error=%d.\n",error);
+        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 register_isr(void)
+static int __devinit isicom_register_isr(struct pci_dev *pdev,
+        const unsigned int index)
 {
-        int count, done=0;
-        unsigned long irqflags;
-
-        for (count=0; count < BOARD_COUNT; count++ ) {
-                if (isi_card[count].base) {
-                        irqflags = (isi_card[count].isa == YES) ? 
-                                        SA_INTERRUPT : 
-                                        (SA_INTERRUPT | SA_SHIRQ);
-
-                        if (request_irq(isi_card[count].irq, 
-                                        isicom_interrupt, 
-                                        irqflags, 
-                                        ISICOM_NAME, &isi_card[count])) {
-
-                                printk(KERN_WARNING "ISICOM: Could not"
-                                        " install handler at Irq %d."
-                                        " Card%d will be disabled.\n",
-                                        isi_card[count].irq, count+1);
-
-                                release_region(isi_card[count].base,16);
-                                isi_card[count].base=0;
-                        }
-                        else
-                                done++;
-                }       
-        }
-        return done;
+        struct isi_board *board = pci_get_drvdata(pdev);
+        unsigned long irqflags = SA_INTERRUPT;
+        int retval = -EINVAL;
+
+        if (!board->base)
+                goto end;
+
+        if (board->isa == NO)
+                irqflags |= SA_SHIRQ;
+
+        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 void __exit unregister_isr(void)
+static int __devinit reset_card(struct pci_dev *pdev,
+        const unsigned int card, unsigned int *signature)
 {
-        int count;
+        struct isi_board *board = pci_get_drvdata(pdev);
+        unsigned long base = board->base;
+        unsigned int portcount = 0;
+        int retval = 0;
+
+        dev_dbg(&pdev->dev, "ISILoad:Resetting Card%d at 0x%lx\n", card + 1,
+                base);
 
-        for (count=0; count < BOARD_COUNT; count++ ) {
-                if (isi_card[count].base)
-                        free_irq(isi_card[count].irq, &isi_card[count]);
+        inw(base + 0x8);
+
+        mdelay(10);
+
+        outw(0, base + 0x8); /* Reset */
+
+        msleep(3000);
+
+        *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;
+                }
         }
+
+        switch (*signature) {
+        case 0xa5:
+        case 0xbb:
+        case 0xdd:
+                board->port_count = (board->isa == NO && portcount == 4) ? 4 :
+                        8;
+                board->shift_count = 12;
+                break;
+        case 0xcc:
+                board->port_count = 16;
+                board->shift_count = 11;
+                break;
+        default:
+                dev_warn(&pdev->dev, "ISILoad:Card%d reset failure (Possible "
+                        "bad I/O Port Address 0x%lx).\n", card + 1, base);
+                dev_dbg(&pdev->dev, "Sig=0x%lx\n", signature);
+                retval = -EIO;
+        }
+        dev_info(&pdev->dev, "-Done\n");
+
+end:
+        return retval;
 }
 
-static int __devinit isicom_init(void)
+static inline int WaitTillCardIsFree(u16 base)
 {
-        int card, channel, base;
-        struct isi_port * port;
-        unsigned long page;
-        
-        if (!tmp_buf) { 
-                page = get_zeroed_page(GFP_KERNEL);
-                if (!page) {
-#ifdef ISICOM_DEBUG             
-                        printk(KERN_DEBUG "ISICOM: Couldn't allocate page for tmp_buf.\n");
-#else
-                        printk(KERN_ERR "ISICOM: Not enough memory...\n");
-#endif        
-                        return 0;
-                }       
-                tmp_buf = (unsigned char *) page;
-        }
-        
-        if (!register_ioregion()) 
-        {
-                printk(KERN_ERR "ISICOM: All required I/O space found busy.\n");
-                free_page((unsigned long)tmp_buf);
-                return 0;
-        }
-        if (register_drivers()) 
-        {
-                unregister_ioregion();
-                free_page((unsigned long)tmp_buf);
-                return 0;
-        }
-        if (!register_isr()) 
-        {
-                unregister_drivers();
-                /*  ioports already uregistered in register_isr */
-                free_page((unsigned long)tmp_buf);
-                return 0;               
+        unsigned long count = 0;
+
+        while (!(inw(base + 0xe) & 0x1) && count++ < 100)
+                msleep(5);
+
+        return !(inw(base + 0xe) & 0x1);
+}
+
+static int __devinit load_firmware(struct pci_dev *pdev,
+        const unsigned int index, const unsigned int signature)
+{
+        struct isi_board *board = pci_get_drvdata(pdev);
+        const struct firmware *fw;
+        unsigned long base = board->base;
+        unsigned int a;
+        u16 word_count, status;
+        int retval = -EIO;
+        char *name;
+        u8 *data;
+
+        struct stframe {
+                u16     addr;
+                u16     count;
+                u8      data[0];
+        } *frame;
+
+        switch (signature) {
+        case 0xa5:
+                name = "isi608.bin";
+                break;
+        case 0xbb:
+                name = "isi608em.bin";
+                break;
+        case 0xcc:
+                name = "isi616em.bin";
+                break;
+        case 0xdd:
+                name = "isi4608.bin";
+                break;
+        case 0xee:
+                name = "isi4616.bin";
+                break;
+        default:
+                dev_err(&pdev->dev, "Unknown signature.\n");
+                goto end;
+        }
+
+        retval = request_firmware(&fw, name, &pdev->dev);
+        if (retval)
+                goto end;
+
+        for (frame = (struct stframe *)fw->data;
+                        frame < (struct stframe *)(fw->data + fw->size);
+                        frame++) {
+                if (WaitTillCardIsFree(base))
+                        goto errrelfw;
+
+                outw(0xf0, base);       /* start upload sequence */
+                outw(0x00, base);
+                outw(frame->addr, base); /* lsb of address */
+
+                word_count = frame->count / 2 + frame->count % 2;
+                outw(word_count, base);
+                InterruptTheCard(base);
+
+                udelay(100); /* 0x2f */
+
+                if (WaitTillCardIsFree(base))
+                        goto errrelfw;
+
+                if ((status = inw(base + 0x4)) != 0) {
+                        dev_warn(&pdev->dev, "Card%d rejected load header:\n"
+                                "Address:0x%x\nCount:0x%x\nStatus:0x%x\n",
+                                index + 1, frame->addr, frame->count, status);
+                        goto errrelfw;
+                }
+                outsw(base, frame->data, word_count);
+
+                InterruptTheCard(base);
+
+                udelay(50); /* 0x0f */
+
+                if (WaitTillCardIsFree(base))
+                        goto errrelfw;
+
+                if ((status = inw(base + 0x4)) != 0) {
+                        dev_err(&pdev->dev, "Card%d got out of sync.Card "
+                                "Status:0x%x\n", index + 1, status);
+                        goto errrelfw;
+                }
+        }
+
+        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++) {
+                if (WaitTillCardIsFree(base))
+                        goto errrelfw;
+
+                outw(0xf1, base); /* start download sequence */
+                outw(0x00, base);
+                outw(frame->addr, base); /* lsb of address */
+
+                word_count = (frame->count >> 1) + frame->count % 2;
+                outw(word_count + 1, base);
+                InterruptTheCard(base);
+
+                udelay(50); /* 0xf */
+
+                if (WaitTillCardIsFree(base))
+                        goto errrelfw;
+
+                if ((status = inw(base + 0x4)) != 0) {
+                        dev_warn(&pdev->dev, "Card%d rejected verify header:\n"
+                                "Address:0x%x\nCount:0x%x\nStatus: 0x%x\n",
+                                index + 1, frame->addr, frame->count, status);
+                        goto errrelfw;
+                }
+
+                data = kmalloc(word_count * 2, GFP_KERNEL);
+                inw(base);
+                insw(base, data, word_count);
+                InterruptTheCard(base);
+
+                for (a = 0; a < frame->count; a++)
+                        if (data[a] != frame->data[a]) {
+                                kfree(data);
+                                dev_err(&pdev->dev, "Card%d, firmware upload "
+                                        "failed\n", index + 1);
+                                goto errrelfw;
+                        }
+                kfree(data);
+
+                udelay(50); /* 0xf */
+
+                if (WaitTillCardIsFree(base))
+                        goto errrelfw;
+
+                if ((status = inw(base + 0x4)) != 0) {
+                        dev_err(&pdev->dev, "Card%d verify got out of sync. "
+                                "Card Status:0x%x\n", index + 1, status);
+                        goto errrelfw;
+                }
         }
-        
-        memset(isi_ports, 0, sizeof(isi_ports));
-        for (card = 0; card < BOARD_COUNT; card++) {
-                port = &isi_ports[card * 16];
-                isi_card[card].ports = port;
-                spin_lock_init(&isi_card[card].card_lock);
-                base = isi_card[card].base;
-                for (channel = 0; channel < 16; channel++, port++) {
-                        port->magic = ISICOM_MAGIC;
-                        port->card = &isi_card[card];
-                        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);
-                        port->status = 0;
-                        init_waitqueue_head(&port->open_wait);                                  
-                        init_waitqueue_head(&port->close_wait);
-                        /*  . . .  */
-                }
-        } 
-        
-        return 1;       
+
+        board->status |= FIRMWARE_LOADED;
+        retval = 0;
+
+errrelfw:
+        release_firmware(fw);
+end:
+        return retval;
 }
 
 /*
  *      Insmod can set static symbols so keep these static
  */
- 
 static int io[4];
 static int irq[4];
+static int card;
 
-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");
+static int __devinit isicom_probe(struct pci_dev *pdev,
+        const struct pci_device_id *ent)
+{
+        unsigned int ioaddr, signature, index;
+        int retval = -EPERM;
+        u8 pciirq;
+        struct isi_board *board = NULL;
+
+        if (card >= BOARD_COUNT)
+                goto err;
+
+        ioaddr = pci_resource_start(pdev, 3);
+        /* i.e at offset 0x1c in the PCI configuration register space. */
+        pciirq = pdev->irq;
+        dev_info(&pdev->dev, "ISI PCI Card(Device ID 0x%x)\n", ent->device);
+
+        /* allot the first empty slot in the array */
+        for (index = 0; index < BOARD_COUNT; index++)
+                if (isi_card[index].base == 0) {
+                        board = &isi_card[index];
+                        break;
+                }
+
+        board->base = ioaddr;
+        board->irq = pciirq;
+        board->isa = NO;
+        card++;
+
+        pci_set_drvdata(pdev, board);
+
+        retval = isicom_register_ioregion(pdev, index);
+        if (retval < 0)
+                goto err;
+
+        retval = isicom_register_isr(pdev, index);
+        if (retval < 0)
+                goto errunrr;
+
+        retval = reset_card(pdev, index, &signature);
+        if (retval < 0)
+                goto errunri;
+
+        retval = load_firmware(pdev, index, signature);
+        if (retval < 0)
+                goto errunri;
+
+        return 0;
+
+errunri:
+        free_irq(board->irq, board);
+errunrr:
+        isicom_unregister_ioregion(pdev);
+err:
+        board->base = 0;
+        return retval;
+}
+
+static void __devexit isicom_remove(struct pci_dev *pdev)
+{
+        struct isi_board *board = pci_get_drvdata(pdev);
+
+        free_irq(board->irq, board);
+        isicom_unregister_ioregion(pdev);
+}
 
 static int __devinit isicom_setup(void)
 {
-        struct pci_dev *dev = NULL;
-        int retval, card, idx, count;
-        unsigned char pciirq;
-        unsigned int ioaddr;
-                        
+        int retval, idx, channel;
+        struct isi_port *port;
+
         card = 0;
-        for(idx=0; idx < BOARD_COUNT; idx++) {  
-                if (io[idx]) {
-                        isi_card[idx].base=io[idx];
-                        isi_card[idx].irq=irq[idx];
-                        isi_card[idx].isa=YES;
-                        card++;
-                }
-                else {
-                        isi_card[idx].base = 0;
-                        isi_card[idx].irq = 0;
-                }
-        }
-        
-        for (idx=0 ;idx < card; idx++) {
-                if (!((isi_card[idx].irq==2)||(isi_card[idx].irq==3)||
-                    (isi_card[idx].irq==4)||(isi_card[idx].irq==5)||
-                    (isi_card[idx].irq==7)||(isi_card[idx].irq==10)||
-                    (isi_card[idx].irq==11)||(isi_card[idx].irq==12)||
-                    (isi_card[idx].irq==15))) {
-                        
-                        if (isi_card[idx].base) {
-                                printk(KERN_ERR "ISICOM: Irq %d unsupported. Disabling Card%d...\n",
-                                        isi_card[idx].irq, idx+1);
-                                isi_card[idx].base=0;
-                                card--;
-                        }       
-                }
-        }       
-        
-        if (card < BOARD_COUNT) {
-                for (idx=0; idx < DEVID_COUNT; idx++) {
-                        dev = NULL;
-                        for (;;){
-                                if (!(dev = pci_find_device(VENDOR_ID, isicom_pci_tbl[idx].device, dev)))
-                                        break;
-                                if (card >= BOARD_COUNT)
-                                        break;
-                                        
-                                if (pci_enable_device(dev))
-                                        break;
+        memset(isi_ports, 0, sizeof(isi_ports));
 
-                                /* found a PCI ISI card! */
-                                ioaddr = pci_resource_start (dev, 3); /* i.e at offset 0x1c in the
-                                                                       * PCI configuration register
-                                                                       * space.
-                                                                       */
-                                pciirq = dev->irq;
-                                printk(KERN_INFO "ISI PCI Card(Device ID 0x%x)\n", isicom_pci_tbl[idx].device);
-                                /*
-                                 * allot the first empty slot in the array
-                                 */                             
-                                for (count=0; count < BOARD_COUNT; count++) {                           
-                                        if (isi_card[count].base == 0) {
-                                                isi_card[count].base = ioaddr;
-                                                isi_card[count].irq = pciirq;
-                                                isi_card[count].isa = NO;
-                                                card++;
-                                                break;
-                                        }
-                                }
-                        }                               
-                        if (card >= BOARD_COUNT) break;
-                }
+        for(idx = 0; idx < BOARD_COUNT; idx++) {
+                port = &isi_ports[idx * 16];
+                isi_card[idx].ports = port;
+                spin_lock_init(&isi_card[idx].card_lock);
+                for (channel = 0; channel < 16; channel++, port++) {
+                        port->magic = ISICOM_MAGIC;
+                        port->card = &isi_card[idx];
+                        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);
+                        port->status = 0;
+                        init_waitqueue_head(&port->open_wait);
+                        init_waitqueue_head(&port->close_wait);
+                        /*  . . .  */
+                }
+                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);
         }
-        
-        if (!(isi_card[0].base || isi_card[1].base || isi_card[2].base || isi_card[3].base)) {
-                printk(KERN_ERR "ISICOM: No valid card configuration. Driver cannot be initialized...\n"); 
-                return -EIO;
-        }       
 
-        retval = misc_register(&isiloader_device);
+        retval = isicom_register_tty_driver();
+        if (retval < 0)
+                goto error;
+
+        retval = pci_register_driver(&isicom_driver);
         if (retval < 0) {
-                printk(KERN_ERR "ISICOM: Unable to register firmware loader driver.\n");
-                return retval;
-        }
-        
-        if (!isicom_init()) {
-                if (misc_deregister(&isiloader_device)) 
-                        printk(KERN_ERR "ISICOM: Unable to unregister Firmware Loader driver\n");
-                return -EIO;
+                printk(KERN_ERR "ISICOM: Unable to register pci driver.\n");
+                goto errtty;
         }
-        
+
         init_timer(&tx);
         tx.expires = jiffies + 1;
         tx.data = 0;
         tx.function = isicom_tx;
         re_schedule = 1;
         add_timer(&tx);
-        
+
         return 0;
+errtty:
+        isicom_unregister_tty_driver();
+error:
+        return retval;
 }
 
 static void __exit isicom_exit(void)
 {
+        unsigned int index = 0;
+
         re_schedule = 0;
-        /* FIXME */
-        msleep(1000);
-        unregister_isr();
-        unregister_drivers();
-        unregister_ioregion();  
-        if(tmp_buf)
-                free_page((unsigned long)tmp_buf);
-        if (misc_deregister(&isiloader_device))
-                printk(KERN_ERR "ISICOM: Unable to unregister Firmware Loader driver\n");
+
+        while (re_schedule != 2 && index++ < 100)
+                msleep(10);
+
+        pci_unregister_driver(&isicom_driver);
+        isicom_unregister_tty_driver();
 }
 
 module_init(isicom_setup);
 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 ce3bc0d45f1f..28c5a3193b81 100644
--- a/drivers/char/istallion.c
+++ b/drivers/char/istallion.c
@@ -135,7 +135,7 @@ static stlconf_t	stli_brdconf[] = {
         /*{ BRD_ECP, 0x2a0, 0, 0xcc000, 0, 0 },*/
 };
 
-static int      stli_nrbrds = sizeof(stli_brdconf) / sizeof(stlconf_t);
+static int      stli_nrbrds = ARRAY_SIZE(stli_brdconf);
 
 /*
  *      There is some experimental EISA board detection code in this driver.
@@ -406,7 +406,7 @@ static unsigned long	stli_eisamemprobeaddrs[] = {
         0xff000000, 0xff010000, 0xff020000, 0xff030000,
 };
 
-static int      stli_eisamempsize = sizeof(stli_eisamemprobeaddrs) / sizeof(unsigned long);
+static int      stli_eisamempsize = ARRAY_SIZE(stli_eisamemprobeaddrs);
 
 /*
  *      Define the Stallion PCI vendor and device IDs.
@@ -899,15 +899,13 @@ static void stli_argbrds(void)
 {
         stlconf_t       conf;
         stlibrd_t       *brdp;
-        int             nrargs, i;
+        int             i;
 
 #ifdef DEBUG
         printk("stli_argbrds()\n");
 #endif
 
-        nrargs = sizeof(stli_brdsp) / sizeof(char **);
-
-        for (i = stli_nrbrds; (i < nrargs); 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;
@@ -967,7 +965,7 @@ static unsigned long stli_atol(char *str)
 static int stli_parsebrd(stlconf_t *confp, char **argp)
 {
         char    *sp;
-        int     nrbrdnames, i;
+        int     i;
 
 #ifdef DEBUG
         printk("stli_parsebrd(confp=%x,argp=%x)\n", (int) confp, (int) argp);
@@ -979,14 +977,13 @@ static int stli_parsebrd(stlconf_t *confp, char **argp)
         for (sp = argp[0], i = 0; ((*sp != 0) && (i < 25)); sp++, i++)
                 *sp = TOLOWER(*sp);
 
-        nrbrdnames = sizeof(stli_brdstr) / sizeof(stlibrdtype_t);
-        for (i = 0; (i < nrbrdnames); i++) {
+        for (i = 0; i < ARRAY_SIZE(stli_brdstr); i++) {
                 if (strcmp(stli_brdstr[i].name, argp[0]) == 0)
                         break;
         }
-        if (i >= nrbrdnames) {
+        if (i == ARRAY_SIZE(stli_brdstr)) {
                 printk("STALLION: unknown board name, %s?\n", argp[0]);
-                return(0);
+                return 0;
         }
 
         confp->brdtype = stli_brdstr[i].type;
@@ -2714,17 +2711,13 @@ static void stli_read(stlibrd_t *brdp, stliport_t *portp)
                 stlen = size - tail;
         }
 
-        len = MIN(len, (TTY_FLIPBUF_SIZE - tty->flip.count));
+        len = tty_buffer_request_room(tty, len);
+        /* FIXME : iomap ? */
         shbuf = (volatile char *) EBRDGETMEMPTR(brdp, portp->rxoffset);
 
         while (len > 0) {
                 stlen = MIN(len, stlen);
-                memcpy(tty->flip.char_buf_ptr, (char *) (shbuf + tail), stlen);
-                memset(tty->flip.flag_buf_ptr, 0, stlen);
-                tty->flip.char_buf_ptr += stlen;
-                tty->flip.flag_buf_ptr += stlen;
-                tty->flip.count += stlen;
-
+                tty_insert_flip_string(tty, (char *)(shbuf + tail), stlen);
                 len -= stlen;
                 tail += stlen;
                 if (tail >= size) {
@@ -2909,16 +2902,12 @@ static int stli_hostcmd(stlibrd_t *brdp, stliport_t *portp)
 
                 if ((nt.data & DT_RXBREAK) && (portp->rxmarkmsk & BRKINT)) {
                         if (tty != (struct tty_struct *) NULL) {
-                                if (tty->flip.count < TTY_FLIPBUF_SIZE) {
-                                        tty->flip.count++;
-                                        *tty->flip.flag_buf_ptr++ = TTY_BREAK;
-                                        *tty->flip.char_buf_ptr++ = 0;
-                                        if (portp->flags & ASYNC_SAK) {
-                                                do_SAK(tty);
-                                                EBRDENABLE(brdp);
-                                        }
-                                        tty_schedule_flip(tty);
+                                tty_insert_flip_char(tty, 0, TTY_BREAK);
+                                if (portp->flags & ASYNC_SAK) {
+                                        do_SAK(tty);
+                                        EBRDENABLE(brdp);
                                 }
+                                tty_schedule_flip(tty);
                         }
                 }
 
@@ -4943,7 +4932,7 @@ static int stli_portcmdstats(stliport_t *portp)
         if (portp->tty != (struct tty_struct *) NULL) {
                 if (portp->tty->driver_data == portp) {
                         stli_comstats.ttystate = portp->tty->flags;
-                        stli_comstats.rxbuffered = portp->tty->flip.count;
+                        stli_comstats.rxbuffered = -1 /*portp->tty->flip.count*/;
                         if (portp->tty->termios != (struct termios *) NULL) {
                                 stli_comstats.cflags = portp->tty->termios->c_cflag;
                                 stli_comstats.iflags = portp->tty->termios->c_iflag;
diff --git a/drivers/char/moxa.c b/drivers/char/moxa.c
index 79e490ef2cf2..5e3ef5522194 100644
--- a/drivers/char/moxa.c
+++ b/drivers/char/moxa.c
@@ -269,7 +269,7 @@ static int MoxaPortDCDChange(int);
 static int MoxaPortDCDON(int);
 static void MoxaPortFlushData(int, int);
 static int MoxaPortWriteData(int, unsigned char *, int);
-static int MoxaPortReadData(int, unsigned char *, int);
+static int MoxaPortReadData(int, struct tty_struct *tty);
 static int MoxaPortTxQueue(int);
 static int MoxaPortRxQueue(int);
 static int MoxaPortTxFree(int);
@@ -301,6 +301,8 @@ static struct tty_operations moxa_ops = {
         .tiocmset = moxa_tiocmset,
 };
 
+static spinlock_t moxa_lock = SPIN_LOCK_UNLOCKED;
+
 #ifdef CONFIG_PCI
 static int moxa_get_PCI_conf(struct pci_dev *p, int board_type, moxa_board_conf * board)
 {
@@ -448,7 +450,7 @@ static int __init moxa_init(void)
 #ifdef CONFIG_PCI
         {
                 struct pci_dev *p = NULL;
-                int n = (sizeof(moxa_pcibrds) / sizeof(moxa_pcibrds[0])) - 1;
+                int n = ARRAY_SIZE(moxa_pcibrds) - 1;
                 i = 0;
                 while (i < n) {
                         while ((p = pci_get_device(moxa_pcibrds[i].vendor, moxa_pcibrds[i].device, p))!=NULL)
@@ -645,10 +647,10 @@ static int moxa_write(struct tty_struct *tty,
         if (ch == NULL)
                 return (0);
         port = ch->port;
-        save_flags(flags);
-        cli();
+
+        spin_lock_irqsave(&moxa_lock, flags);
         len = MoxaPortWriteData(port, (unsigned char *) buf, count);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&moxa_lock, flags);
 
         /*********************************************
         if ( !(ch->statusflags & LOWWAIT) &&
@@ -723,11 +725,10 @@ static void moxa_put_char(struct tty_struct *tty, unsigned char c)
         if (ch == NULL)
                 return;
         port = ch->port;
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&moxa_lock, flags);
         moxaXmitBuff[0] = c;
         MoxaPortWriteData(port, moxaXmitBuff, 1);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&moxa_lock, flags);
         /************************************************
         if ( !(ch->statusflags & LOWWAIT) && (MoxaPortTxFree(port) <= 100) )
         *************************************************/
@@ -1030,12 +1031,12 @@ static int block_till_ready(struct tty_struct *tty, struct file *filp,
         printk("block_til_ready before block: ttys%d, count = %d\n",
                ch->line, ch->count);
 #endif
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&moxa_lock, flags);
         if (!tty_hung_up_p(filp))
                 ch->count--;
-        restore_flags(flags);
         ch->blocked_open++;
+        spin_unlock_irqrestore(&moxa_lock, flags);
+
         while (1) {
                 set_current_state(TASK_INTERRUPTIBLE);
                 if (tty_hung_up_p(filp) ||
@@ -1062,17 +1063,21 @@ static int block_till_ready(struct tty_struct *tty, struct file *filp,
         }
         set_current_state(TASK_RUNNING);
         remove_wait_queue(&ch->open_wait, &wait);
+
+        spin_lock_irqsave(&moxa_lock, flags);
         if (!tty_hung_up_p(filp))
                 ch->count++;
         ch->blocked_open--;
+        spin_unlock_irqrestore(&moxa_lock, flags);
 #ifdef SERIAL_DEBUG_OPEN
         printk("block_til_ready after blocking: ttys%d, count = %d\n",
                ch->line, ch->count);
 #endif
         if (retval)
                 return (retval);
+        /* FIXME: review to see if we need to use set_bit on these */
         ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
-        return (0);
+        return 0;
 }
 
 static void setup_empty_event(struct tty_struct *tty)
@@ -1080,15 +1085,14 @@ static void setup_empty_event(struct tty_struct *tty)
         struct moxa_str *ch = tty->driver_data;
         unsigned long flags;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&moxa_lock, flags);
         ch->statusflags |= EMPTYWAIT;
         moxaEmptyTimer_on[ch->port] = 0;
         del_timer(&moxaEmptyTimer[ch->port]);
         moxaEmptyTimer[ch->port].expires = jiffies + HZ;
         moxaEmptyTimer_on[ch->port] = 1;
         add_timer(&moxaEmptyTimer[ch->port]);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&moxa_lock, flags);
 }
 
 static void check_xmit_empty(unsigned long data)
@@ -1135,8 +1139,6 @@ static void receive_data(struct moxa_str *ch)
 {
         struct tty_struct *tp;
         struct termios *ts;
-        int i, count, rc, space;
-        unsigned char *charptr, *flagptr;
         unsigned long flags;
 
         ts = NULL;
@@ -1150,24 +1152,10 @@ static void receive_data(struct moxa_str *ch)
                 MoxaPortFlushData(ch->port, 0);
                 return;
         }
-        space = TTY_FLIPBUF_SIZE - tp->flip.count;
-        if (space <= 0)
-                return;
-        charptr = tp->flip.char_buf_ptr;
-        flagptr = tp->flip.flag_buf_ptr;
-        rc = tp->flip.count;
-        save_flags(flags);
-        cli();
-        count = MoxaPortReadData(ch->port, charptr, space);
-        restore_flags(flags);
-        for (i = 0; i < count; i++)
-                *flagptr++ = 0;
-        charptr += count;
-        rc += count;
-        tp->flip.count = rc;
-        tp->flip.char_buf_ptr = charptr;
-        tp->flip.flag_buf_ptr = flagptr;
-        tty_schedule_flip(ch->tty);
+        spin_lock_irqsave(&moxa_lock, flags);
+        MoxaPortReadData(ch->port, tp);
+        spin_unlock_irqrestore(&moxa_lock, flags);
+        tty_schedule_flip(tp);
 }
 
 #define Magic_code      0x404
@@ -1774,7 +1762,7 @@ int MoxaPortsOfCard(int cardno)
  *      14. MoxaPortDCDON(int port);                                         *
  *      15. MoxaPortFlushData(int port, int mode);                           *
  *      16. MoxaPortWriteData(int port, unsigned char * buffer, int length); *
- *      17. MoxaPortReadData(int port, unsigned char * buffer, int length);  *
+ *      17. MoxaPortReadData(int port, struct tty_struct *tty);              *
  *      18. MoxaPortTxBufSize(int port);                                     *
  *      19. MoxaPortRxBufSize(int port);                                     *
  *      20. MoxaPortTxQueue(int port);                                       *
@@ -2003,10 +1991,9 @@ int MoxaPortsOfCard(int cardno)
  *
  *      Function 21:    Read data.
  *      Syntax:
- *      int  MoxaPortReadData(int port, unsigned char * buffer, int length);
+ *      int  MoxaPortReadData(int port, struct tty_struct *tty);
  *           int port           : port number (0 - 127)
- *           unsigned char * buffer     : pointer to read data buffer.
- *           int length         : read data buffer length
+ *           struct tty_struct *tty : tty for data
  *
  *           return:    0 - length      : real read data length
  *
@@ -2504,7 +2491,7 @@ int MoxaPortWriteData(int port, unsigned char * buffer, int len)
         return (total);
 }
 
-int MoxaPortReadData(int port, unsigned char * buffer, int space)
+int MoxaPortReadData(int port, struct tty_struct *tty)
 {
         register ushort head, pageofs;
         int i, count, cnt, len, total, remain;
@@ -2522,9 +2509,9 @@ int MoxaPortReadData(int port, unsigned char * buffer, int space)
         count = (tail >= head) ? (tail - head)
             : (tail - head + rx_mask + 1);
         if (count == 0)
-                return (0);
+                return 0;
 
-        total = (space > count) ? count : space;
+        total = count;
         remain = count - total;
         moxaLog.rxcnt[port] += total;
         count = total;
@@ -2539,7 +2526,7 @@ int MoxaPortReadData(int port, unsigned char * buffer, int space)
                         len = (count > len) ? len : count;
                         ofs = baseAddr + DynPage_addr + bufhead + head;
                         for (i = 0; i < len; i++)
-                                *buffer++ = readb(ofs + i);
+                                tty_insert_flip_char(tty, readb(ofs + i), TTY_NORMAL);
                         head = (head + len) & rx_mask;
                         count -= len;
                 }
@@ -2556,7 +2543,7 @@ int MoxaPortReadData(int port, unsigned char * buffer, int space)
                         writew(pageno, baseAddr + Control_reg);
                         ofs = baseAddr + DynPage_addr + pageofs;
                         for (i = 0; i < cnt; i++)
-                                *buffer++ = readb(ofs + i);
+                                tty_insert_flip_char(tty, readb(ofs + i), TTY_NORMAL);
                         if (count == 0) {
                                 writew((head + len) & rx_mask, ofsAddr + RXrptr);
                                 break;
diff --git a/drivers/char/mxser.c b/drivers/char/mxser.c
index 26448f176803..ea725a9964e2 100644
--- a/drivers/char/mxser.c
+++ b/drivers/char/mxser.c
@@ -813,7 +813,7 @@ static int mxser_init(void)
 
         /* start finding PCI board here */
 #ifdef CONFIG_PCI
-        n = (sizeof(mxser_pcibrds) / sizeof(mxser_pcibrds[0])) - 1;
+        n = ARRAY_SIZE(mxser_pcibrds) - 1;
         index = 0;
         b = 0;
         while (b < n) {
@@ -1982,7 +1982,7 @@ static void mxser_receive_chars(struct mxser_struct *info, int *status)
 
         spin_lock_irqsave(&info->slock, flags);
 
-        recv_room = tty->ldisc.receive_room(tty);
+        recv_room = tty->receive_room;
         if ((recv_room == 0) && (!info->ldisc_stop_rx)) {
                 //mxser_throttle(tty);
                 mxser_stoprx(tty);
diff --git a/drivers/char/n_hdlc.c b/drivers/char/n_hdlc.c
index a133a62f3d55..9f54733f1623 100644
--- a/drivers/char/n_hdlc.c
+++ b/drivers/char/n_hdlc.c
@@ -191,7 +191,6 @@ static unsigned int n_hdlc_tty_poll(struct tty_struct *tty, struct file *filp,
                                     poll_table *wait);
 static int n_hdlc_tty_open(struct tty_struct *tty);
 static void n_hdlc_tty_close(struct tty_struct *tty);
-static int n_hdlc_tty_room(struct tty_struct *tty);
 static void n_hdlc_tty_receive(struct tty_struct *tty, const __u8 *cp,
                                char *fp, int count);
 static void n_hdlc_tty_wakeup(struct tty_struct *tty);
@@ -212,7 +211,6 @@ static struct tty_ldisc n_hdlc_ldisc = {
         .ioctl          = n_hdlc_tty_ioctl,
         .poll           = n_hdlc_tty_poll,
         .receive_buf    = n_hdlc_tty_receive,
-        .receive_room   = n_hdlc_tty_room,
         .write_wakeup   = n_hdlc_tty_wakeup,
 };
 
@@ -337,6 +335,7 @@ static int n_hdlc_tty_open (struct tty_struct *tty)
                 
         tty->disc_data = n_hdlc;
         n_hdlc->tty    = tty;
+        tty->receive_room = 65536;
         
 #if defined(TTY_NO_WRITE_SPLIT)
         /* change tty_io write() to not split large writes into 8K chunks */
@@ -478,22 +477,6 @@ static void n_hdlc_tty_wakeup(struct tty_struct *tty)
 }       /* end of n_hdlc_tty_wakeup() */
 
 /**
- * n_hdlc_tty_room - Return the amount of space left in the receiver's buffer
- * @tty - pointer to associated tty instance data
- *
- * Callback function from tty driver. Return the amount of space left in the
- * receiver's buffer to decide if remote transmitter is to be throttled.
- */
-static int n_hdlc_tty_room(struct tty_struct *tty)
-{
-        if (debuglevel >= DEBUG_LEVEL_INFO)     
-                printk("%s(%d)n_hdlc_tty_room() called\n",__FILE__,__LINE__);
-        /* always return a larger number to prevent */
-        /* throttling of remote transmitter. */
-        return 65536;
-}       /* end of n_hdlc_tty_root() */
-
-/**
  * n_hdlc_tty_receive - Called by tty driver when receive data is available
  * @tty - pointer to tty instance data
  * @data - pointer to received data
diff --git a/drivers/char/n_r3964.c b/drivers/char/n_r3964.c
index 853c98cee64f..c48de09d68f0 100644
--- a/drivers/char/n_r3964.c
+++ b/drivers/char/n_r3964.c
@@ -147,7 +147,6 @@ 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,
                               char *fp, int count);
-static int  r3964_receive_room(struct tty_struct *tty);
 
 static struct tty_ldisc tty_ldisc_N_R3964 = {
         .owner   = THIS_MODULE,
@@ -161,7 +160,6 @@ static struct tty_ldisc tty_ldisc_N_R3964 = {
         .set_termios = r3964_set_termios,
         .poll   = r3964_poll,            
         .receive_buf = r3964_receive_buf,
-        .receive_room = r3964_receive_room,
 };
 
 
@@ -1119,6 +1117,7 @@ static int r3964_open(struct tty_struct *tty)
    pInfo->nRetry = 0;
    
    tty->disc_data = pInfo;
+   tty->receive_room = 65536;
 
    init_timer(&pInfo->tmr);
    pInfo->tmr.data = (unsigned long)pInfo;
@@ -1405,12 +1404,5 @@ static void r3964_receive_buf(struct tty_struct *tty, const unsigned char *cp,
     }
 }
 
-static int r3964_receive_room(struct tty_struct *tty)
-{
-   TRACE_L("receive_room");
-   return -1;
-}
-
-
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_LDISC(N_R3964);
diff --git a/drivers/char/n_tty.c b/drivers/char/n_tty.c
index c556f4d3ccd7..ccad7ae94541 100644
--- a/drivers/char/n_tty.c
+++ b/drivers/char/n_tty.c
@@ -78,7 +78,32 @@ static inline void free_buf(unsigned char *buf)
                 free_page((unsigned long) buf);
 }
 
-static inline void put_tty_queue_nolock(unsigned char c, struct tty_struct *tty)
+/**
+ *      n_tty_set__room -       receive space
+ *      @tty: terminal
+ *
+ *      Called by the driver to find out how much data it is
+ *      permitted to feed to the line discipline without any being lost
+ *      and thus to manage flow control. Not serialized. Answers for the
+ *      "instant".
+ */
+
+static void n_tty_set_room(struct tty_struct *tty)
+{
+        int     left = N_TTY_BUF_SIZE - tty->read_cnt - 1;
+
+        /*
+         * If we are doing input canonicalization, and there are no
+         * pending newlines, let characters through without limit, so
+         * that erase characters will be handled.  Other excess
+         * characters will be beeped.
+         */
+        if (left <= 0)
+                left = tty->icanon && !tty->canon_data;
+        tty->receive_room = left;
+}
+
+static void put_tty_queue_nolock(unsigned char c, struct tty_struct *tty)
 {
         if (tty->read_cnt < N_TTY_BUF_SIZE) {
                 tty->read_buf[tty->read_head] = c;
@@ -87,7 +112,7 @@ static inline void put_tty_queue_nolock(unsigned char c, struct tty_struct *tty)
         }
 }
 
-static inline void put_tty_queue(unsigned char c, struct tty_struct *tty)
+static void put_tty_queue(unsigned char c, struct tty_struct *tty)
 {
         unsigned long flags;
         /*
@@ -136,6 +161,7 @@ static void reset_buffer_flags(struct tty_struct *tty)
         spin_unlock_irqrestore(&tty->read_lock, flags);
         tty->canon_head = tty->canon_data = tty->erasing = 0;
         memset(&tty->read_flags, 0, sizeof tty->read_flags);
+        n_tty_set_room(tty);
         check_unthrottle(tty);
 }
 
@@ -838,30 +864,6 @@ send_signal:
         put_tty_queue(c, tty);
 }       
 
-/**
- *      n_tty_receive_room      -       receive space
- *      @tty: terminal
- *
- *      Called by the driver to find out how much data it is
- *      permitted to feed to the line discipline without any being lost
- *      and thus to manage flow control. Not serialized. Answers for the
- *      "instant".
- */
- 
-static int n_tty_receive_room(struct tty_struct *tty)
-{
-        int     left = N_TTY_BUF_SIZE - tty->read_cnt - 1;
-
-        /*
-         * If we are doing input canonicalization, and there are no
-         * pending newlines, let characters through without limit, so
-         * that erase characters will be handled.  Other excess
-         * characters will be beeped.
-         */
-        if (left <= 0)
-                left = tty->icanon && !tty->canon_data;
-        return left;
-}
 
 /**
  *      n_tty_write_wakeup      -       asynchronous I/O notifier
@@ -953,6 +955,8 @@ static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
                         tty->driver->flush_chars(tty);
         }
 
+        n_tty_set_room(tty);
+
         if (!tty->icanon && (tty->read_cnt >= tty->minimum_to_wake)) {
                 kill_fasync(&tty->fasync, SIGIO, POLL_IN);
                 if (waitqueue_active(&tty->read_wait))
@@ -964,7 +968,7 @@ static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
          * mode.  We don't want to throttle the driver if we're in
          * canonical mode and don't have a newline yet!
          */
-        if (n_tty_receive_room(tty) < TTY_THRESHOLD_THROTTLE) {
+        if (tty->receive_room < TTY_THRESHOLD_THROTTLE) {
                 /* check TTY_THROTTLED first so it indicates our state */
                 if (!test_and_set_bit(TTY_THROTTLED, &tty->flags) &&
                     tty->driver->throttle)
@@ -999,6 +1003,7 @@ static void n_tty_set_termios(struct tty_struct *tty, struct termios * old)
         if (test_bit(TTY_HW_COOK_IN, &tty->flags)) {
                 tty->raw = 1;
                 tty->real_raw = 1;
+                n_tty_set_room(tty);
                 return;
         }
         if (I_ISTRIP(tty) || I_IUCLC(tty) || I_IGNCR(tty) ||
@@ -1051,6 +1056,7 @@ static void n_tty_set_termios(struct tty_struct *tty, struct termios * old)
                 else
                         tty->real_raw = 0;
         }
+        n_tty_set_room(tty);
 }
 
 /**
@@ -1130,7 +1136,7 @@ static inline int input_available_p(struct tty_struct *tty, int amt)
  *
  */
  
-static inline int copy_from_read_buf(struct tty_struct *tty,
+static int copy_from_read_buf(struct tty_struct *tty,
                                       unsigned char __user **b,
                                       size_t *nr)
 
@@ -1308,6 +1314,7 @@ do_it_again:
                                 retval = -ERESTARTSYS;
                                 break;
                         }
+                        n_tty_set_room(tty);
                         clear_bit(TTY_DONT_FLIP, &tty->flags);
                         timeout = schedule_timeout(timeout);
                         set_bit(TTY_DONT_FLIP, &tty->flags);
@@ -1401,6 +1408,8 @@ do_it_again:
         } else if (test_and_clear_bit(TTY_PUSH, &tty->flags))
                  goto do_it_again;
 
+        n_tty_set_room(tty);
+
         return retval;
 }
 
@@ -1553,7 +1562,6 @@ struct tty_ldisc tty_ldisc_N_TTY = {
         normal_poll,            /* poll */
         NULL,                   /* hangup */
         n_tty_receive_buf,      /* receive_buf */
-        n_tty_receive_room,     /* receive_room */
         n_tty_write_wakeup      /* write_wakeup */
 };
 
diff --git a/drivers/char/nvram.c b/drivers/char/nvram.c
index 1af733d07321..3556ccd77570 100644
--- a/drivers/char/nvram.c
+++ b/drivers/char/nvram.c
@@ -557,13 +557,13 @@ pc_proc_infos(unsigned char *nvram, char *buffer, int *len,
             (nvram[6] & 1) ? (nvram[6] >> 6) + 1 : 0);
         PRINT_PROC("Floppy 0 type  : ");
         type = nvram[2] >> 4;
-        if (type < sizeof (floppy_types) / sizeof (*floppy_types))
+        if (type < ARRAY_SIZE(floppy_types))
                 PRINT_PROC("%s\n", floppy_types[type]);
         else
                 PRINT_PROC("%d (unknown)\n", type);
         PRINT_PROC("Floppy 1 type  : ");
         type = nvram[2] & 0x0f;
-        if (type < sizeof (floppy_types) / sizeof (*floppy_types))
+        if (type < ARRAY_SIZE(floppy_types))
                 PRINT_PROC("%s\n", floppy_types[type]);
         else
                 PRINT_PROC("%d (unknown)\n", type);
@@ -843,8 +843,6 @@ static char *colors[] = {
         "2", "4", "16", "256", "65536", "??", "??", "??"
 };
 
-#define fieldsize(a)    (sizeof(a)/sizeof(*a))
-
 static int
 atari_proc_infos(unsigned char *nvram, char *buffer, int *len,
     off_t *begin, off_t offset, int size)
@@ -856,7 +854,7 @@ atari_proc_infos(unsigned char *nvram, char *buffer, int *len,
         PRINT_PROC("Checksum status  : %svalid\n", checksum ? "" : "not ");
 
         PRINT_PROC("Boot preference  : ");
-        for (i = fieldsize(boot_prefs) - 1; i >= 0; --i) {
+        for (i = ARRAY_SIZE(boot_prefs) - 1; i >= 0; --i) {
                 if (nvram[1] == boot_prefs[i].val) {
                         PRINT_PROC("%s\n", boot_prefs[i].name);
                         break;
@@ -878,12 +876,12 @@ atari_proc_infos(unsigned char *nvram, char *buffer, int *len,
                 return 1;
 
         PRINT_PROC("OS language      : ");
-        if (nvram[6] < fieldsize(languages))
+        if (nvram[6] < ARRAY_SIZE(languages))
                 PRINT_PROC("%s\n", languages[nvram[6]]);
         else
                 PRINT_PROC("%u (undefined)\n", nvram[6]);
         PRINT_PROC("Keyboard language: ");
-        if (nvram[7] < fieldsize(languages))
+        if (nvram[7] < ARRAY_SIZE(languages))
                 PRINT_PROC("%s\n", languages[nvram[7]]);
         else
                 PRINT_PROC("%u (undefined)\n", nvram[7]);
diff --git a/drivers/char/pcmcia/synclink_cs.c b/drivers/char/pcmcia/synclink_cs.c
index cf45b100eff1..8a8ca32822ba 100644
--- a/drivers/char/pcmcia/synclink_cs.c
+++ b/drivers/char/pcmcia/synclink_cs.c
@@ -1007,8 +1007,9 @@ static void rx_ready_hdlc(MGSLPC_INFO *info, int eom)
 
 static void rx_ready_async(MGSLPC_INFO *info, int tcd)
 {
-        unsigned char data, status;
+        unsigned char data, status, flag;
         int fifo_count;
+        int work = 0;
         struct tty_struct *tty = info->tty;
         struct mgsl_icount *icount = &info->icount;
 
@@ -1023,20 +1024,16 @@ static void rx_ready_async(MGSLPC_INFO *info, int tcd)
                         fifo_count = 32;
         } else
                 fifo_count = 32;
-        
+
+        tty_buffer_request_room(tty, fifo_count);
         /* Flush received async data to receive data buffer. */ 
         while (fifo_count) {
                 data   = read_reg(info, CHA + RXFIFO);
                 status = read_reg(info, CHA + RXFIFO);
                 fifo_count -= 2;
 
-                if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                        break;
-                        
-                *tty->flip.char_buf_ptr = data;
                 icount->rx++;
-                
-                *tty->flip.flag_buf_ptr = 0;
+                flag = TTY_NORMAL;
 
                 // if no frameing/crc error then save data
                 // BIT7:parity error
@@ -1055,26 +1052,23 @@ static void rx_ready_async(MGSLPC_INFO *info, int tcd)
                         status &= info->read_status_mask;
 
                         if (status & BIT7)
-                                *tty->flip.flag_buf_ptr = TTY_PARITY;
+                                flag = TTY_PARITY;
                         else if (status & BIT6)
-                                *tty->flip.flag_buf_ptr = TTY_FRAME;
+                                flag = TTY_FRAME;
                 }
-                
-                tty->flip.flag_buf_ptr++;
-                tty->flip.char_buf_ptr++;
-                tty->flip.count++;
+                work += tty_insert_flip_char(tty, data, flag);
         }
         issue_command(info, CHA, CMD_RXFIFO);
 
         if (debug_level >= DEBUG_LEVEL_ISR) {
-                printk("%s(%d):rx_ready_async count=%d\n",
-                        __FILE__,__LINE__,tty->flip.count);
+                printk("%s(%d):rx_ready_async",
+                        __FILE__,__LINE__);
                 printk("%s(%d):rx=%d brk=%d parity=%d frame=%d overrun=%d\n",
                         __FILE__,__LINE__,icount->rx,icount->brk,
                         icount->parity,icount->frame,icount->overrun);
         }
                         
-        if (tty->flip.count)
+        if (work)
                 tty_flip_buffer_push(tty);
 }
 
@@ -4005,7 +3999,7 @@ BOOLEAN register_test(MGSLPC_INFO *info)
 {
         static unsigned char patterns[] = 
             { 0x00, 0xff, 0xaa, 0x55, 0x69, 0x96, 0x0f };
-        static unsigned int count = sizeof(patterns) / sizeof(patterns[0]);
+        static unsigned int count = ARRAY_SIZE(patterns);
         unsigned int i;
         BOOLEAN rc = TRUE;
         unsigned long flags;
@@ -4016,7 +4010,7 @@ BOOLEAN register_test(MGSLPC_INFO *info)
         for (i = 0; i < count; i++) {
                 write_reg(info, XAD1, patterns[i]);
                 write_reg(info, XAD2, patterns[(i + 1) % count]);
-                if ((read_reg(info, XAD1) != patterns[i]) || 
+                if ((read_reg(info, XAD1) != patterns[i]) ||
                     (read_reg(info, XAD2) != patterns[(i + 1) % count])) {
                         rc = FALSE;
                         break;
diff --git a/drivers/char/pty.c b/drivers/char/pty.c
index 49f3997fd251..9b5a2c0e7008 100644
--- a/drivers/char/pty.c
+++ b/drivers/char/pty.c
@@ -111,7 +111,7 @@ static int pty_write(struct tty_struct * tty, const unsigned char *buf, int coun
         if (!to || tty->stopped)
                 return 0;
 
-        c = to->ldisc.receive_room(to);
+        c = to->receive_room;
         if (c > count)
                 c = count;
         to->ldisc.receive_buf(to, buf, NULL, c);
@@ -126,7 +126,7 @@ static int pty_write_room(struct tty_struct *tty)
         if (!to || tty->stopped)
                 return 0;
 
-        return to->ldisc.receive_room(to);
+        return to->receive_room;
 }
 
 /*
diff --git a/drivers/char/rio/rio_linux.c b/drivers/char/rio/rio_linux.c
index d7d484024e2b..7085a38532b3 100644
--- a/drivers/char/rio/rio_linux.c
+++ b/drivers/char/rio/rio_linux.c
@@ -56,10 +56,6 @@
 #include <linux/generic_serial.h>
 #include <asm/uaccess.h>
 
-#if BITS_PER_LONG != 32
-#  error FIXME: this driver only works on 32-bit platforms
-#endif
-
 #include "linux_compat.h"
 #include "typdef.h"
 #include "pkt.h"
@@ -215,7 +211,7 @@ static int rio_poll = 1;
    or less.... */
 static int rio_probe_addrs[]= {0xc0000, 0xd0000, 0xe0000};
 
-#define NR_RIO_ADDRS (sizeof(rio_probe_addrs)/sizeof (int))
+#define NR_RIO_ADDRS ARRAY_SIZE(rio_probe_addrs)
 
 
 /* Set the mask to all-ones. This alas, only supports 32 interrupts. 
diff --git a/drivers/char/rio/riointr.c b/drivers/char/rio/riointr.c
index e42e7b50bf6b..ddda9c14e059 100644
--- a/drivers/char/rio/riointr.c
+++ b/drivers/char/rio/riointr.c
@@ -38,6 +38,7 @@ static char *_riointr_c_sccs_ = "@(#)riointr.c	1.2";
 #include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/tty.h>
+#include <linux/tty_flip.h>
 #include <asm/io.h>
 #include <asm/system.h>
 #include <asm/string.h>
@@ -560,6 +561,7 @@ struct Port *		PortP;
   struct PKT *PacketP;
   register uint DataCnt;
   uchar *       ptr;
+  unsigned char *buf;
   int copied =0;
 
   static int intCount, RxIntCnt;
@@ -657,8 +659,7 @@ struct Port *		PortP;
           ** and available space.
           */
                         
-          transCount = min_t(unsigned int, PacketP->len & PKT_LEN_MASK,
-                           TTY_FLIPBUF_SIZE - TtyP->flip.count);
+          transCount = tty_buffer_request_room(TtyP, PacketP->len & PKT_LEN_MASK);
           rio_dprintk (RIO_DEBUG_REC,  "port %d: Copy %d bytes\n", 
                                       PortP->PortNum, transCount);
           /*
@@ -678,9 +679,8 @@ struct Port *		PortP;
 #endif
           ptr = (uchar *) PacketP->data + PortP->RxDataStart;
 
-          rio_memcpy_fromio (TtyP->flip.char_buf_ptr, ptr, transCount);
-          memset(TtyP->flip.flag_buf_ptr, TTY_NORMAL, transCount);
-
+          tty_prepare_flip_string(TtyP, &buf, transCount);
+          rio_memcpy_fromio (buf, ptr, transCount);
 #ifdef STATS
           /*
           ** keep a count for statistical purposes
@@ -690,9 +690,6 @@ struct Port *		PortP;
           PortP->RxDataStart    += transCount;
           PacketP->len          -= transCount;
           copied += transCount;
-          TtyP->flip.count += transCount;
-          TtyP->flip.char_buf_ptr += transCount;
-          TtyP->flip.flag_buf_ptr += transCount;
 
 
 #ifdef ___DEBUG_IT___
diff --git a/drivers/char/riscom8.c b/drivers/char/riscom8.c
index 55a3a0188eda..050e70ee5920 100644
--- a/drivers/char/riscom8.c
+++ b/drivers/char/riscom8.c
@@ -46,6 +46,7 @@
 #include <linux/major.h>
 #include <linux/init.h>
 #include <linux/delay.h>
+#include <linux/tty_flip.h>
 
 #include <asm/uaccess.h>
 
@@ -107,15 +108,15 @@ static struct riscom_port rc_port[RC_NBOARD * RC_NPORT];
 
 /* RISCom/8 I/O ports addresses (without address translation) */
 static unsigned short rc_ioport[] =  {
-#if 1   
+#if 1
         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0c,
-#else   
+#else
         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0c, 0x10,
         0x11, 0x12, 0x18, 0x28, 0x31, 0x32, 0x39, 0x3a, 0x40, 0x41, 0x61, 0x62,
         0x63, 0x64, 0x6b, 0x70, 0x71, 0x78, 0x7a, 0x7b, 0x7f, 0x100, 0x101
-#endif  
+#endif
 };
-#define RC_NIOPORT      (sizeof(rc_ioport) / sizeof(rc_ioport[0]))
+#define RC_NIOPORT      ARRAY_SIZE(rc_ioport)
 
 
 static inline int rc_paranoia_check(struct riscom_port const * port,
@@ -354,28 +355,17 @@ static inline void rc_receive_exc(struct riscom_board const * bp)
         struct riscom_port *port;
         struct tty_struct *tty;
         unsigned char status;
-        unsigned char ch;
+        unsigned char ch, flag;
         
         if (!(port = rc_get_port(bp, "Receive")))
                 return;
 
         tty = port->tty;
-        if (tty->flip.count >= TTY_FLIPBUF_SIZE)  {
-                printk(KERN_WARNING "rc%d: port %d: Working around flip "
-                                    "buffer overflow.\n",
-                       board_No(bp), port_No(port));
-                return;
-        }
         
 #ifdef RC_REPORT_OVERRUN        
         status = rc_in(bp, CD180_RCSR);
-        if (status & RCSR_OE)  {
+        if (status & RCSR_OE)
                 port->overrun++;
-#if 0           
-                printk(KERN_ERR "rc%d: port %d: Overrun. Total %ld overruns\n", 
-                       board_No(bp), port_No(port), port->overrun);
-#endif          
-        }
         status &= port->mark_mask;
 #else   
         status = rc_in(bp, CD180_RCSR) & port->mark_mask;
@@ -393,25 +383,24 @@ static inline void rc_receive_exc(struct riscom_board const * bp)
         } else if (status & RCSR_BREAK)  {
                 printk(KERN_INFO "rc%d: port %d: Handling break...\n",
                        board_No(bp), port_No(port));
-                *tty->flip.flag_buf_ptr++ = TTY_BREAK;
+                flag = TTY_BREAK;
                 if (port->flags & ASYNC_SAK)
                         do_SAK(tty);
                 
         } else if (status & RCSR_PE) 
-                *tty->flip.flag_buf_ptr++ = TTY_PARITY;
+                flag = TTY_PARITY;
         
         else if (status & RCSR_FE) 
-                *tty->flip.flag_buf_ptr++ = TTY_FRAME;
+                flag = TTY_FRAME;
         
         else if (status & RCSR_OE)
-                *tty->flip.flag_buf_ptr++ = TTY_OVERRUN;
+                flag = TTY_OVERRUN;
         
         else
-                *tty->flip.flag_buf_ptr++ = 0;
+                flag = TTY_NORMAL;
         
-        *tty->flip.char_buf_ptr++ = ch;
-        tty->flip.count++;
-        schedule_delayed_work(&tty->flip.work, 1);
+        tty_insert_flip_char(tty, ch, flag);
+        tty_flip_buffer_push(tty);
 }
 
 static inline void rc_receive(struct riscom_board const * bp)
@@ -432,17 +421,15 @@ static inline void rc_receive(struct riscom_board const * bp)
 #endif  
         
         while (count--)  {
-                if (tty->flip.count >= TTY_FLIPBUF_SIZE)  {
+                if (tty_buffer_request_room(tty, 1) == 0)  {
                         printk(KERN_WARNING "rc%d: port %d: Working around "
                                             "flip buffer overflow.\n",
                                board_No(bp), port_No(port));
                         break;
                 }
-                *tty->flip.char_buf_ptr++ = rc_in(bp, CD180_RDR);
-                *tty->flip.flag_buf_ptr++ = 0;
-                tty->flip.count++;
+                tty_insert_flip_char(tty, rc_in(bp, CD180_RDR), TTY_NORMAL);
         }
-        schedule_delayed_work(&tty->flip.work, 1);
+        tty_flip_buffer_push(tty);
 }
 
 static inline void rc_transmit(struct riscom_board const * bp)
diff --git a/drivers/char/rocket.c b/drivers/char/rocket.c
index d3bc731fbb27..0949dcef0697 100644
--- a/drivers/char/rocket.c
+++ b/drivers/char/rocket.c
@@ -325,19 +325,16 @@ static void rp_do_receive(struct r_port *info,
 {
         unsigned int CharNStat;
         int ToRecv, wRecv, space = 0, count;
-        unsigned char *cbuf;
-        char *fbuf;
+        unsigned char *cbuf, *chead;
+        char *fbuf, *fhead;
         struct tty_ldisc *ld;
 
         ld = tty_ldisc_ref(tty);
 
         ToRecv = sGetRxCnt(cp);
-        if (ld)
-                space = ld->receive_room(tty);
+        space = tty->receive_room;
         if (space > 2 * TTY_FLIPBUF_SIZE)
                 space = 2 * TTY_FLIPBUF_SIZE;
-        cbuf = tty->flip.char_buf;
-        fbuf = tty->flip.flag_buf;
         count = 0;
 #ifdef ROCKET_DEBUG_INTR
         printk(KERN_INFO "rp_do_receive(%d, %d)...", ToRecv, space);
@@ -350,9 +347,13 @@ static void rp_do_receive(struct r_port *info,
         if (ToRecv > space)
                 ToRecv = space;
 
+        ToRecv = tty_prepare_flip_string_flags(tty, &chead, &fhead, ToRecv);
         if (ToRecv <= 0)
                 goto done;
 
+        cbuf = chead;
+        fbuf = fhead;
+
         /*
          * if status indicates there are errored characters in the
          * FIFO, then enter status mode (a word in FIFO holds
@@ -399,7 +400,7 @@ static void rp_do_receive(struct r_port *info,
                         else if (CharNStat & STMRCVROVRH)
                                 *fbuf++ = TTY_OVERRUN;
                         else
-                                *fbuf++ = 0;
+                                *fbuf++ = TTY_NORMAL;
                         *cbuf++ = CharNStat & 0xff;
                         count++;
                         ToRecv--;
@@ -426,13 +427,13 @@ static void rp_do_receive(struct r_port *info,
                         sInStrW(sGetTxRxDataIO(cp), (unsigned short *) cbuf, wRecv);
                 if (ToRecv & 1)
                         cbuf[ToRecv - 1] = sInB(sGetTxRxDataIO(cp));
-                memset(fbuf, 0, ToRecv);
+                memset(fbuf, TTY_NORMAL, ToRecv);
                 cbuf += ToRecv;
                 fbuf += ToRecv;
                 count += ToRecv;
         }
         /*  Push the data up to the tty layer */
-        ld->receive_buf(tty, tty->flip.char_buf, tty->flip.flag_buf, count);
+        ld->receive_buf(tty, cbuf, fbuf, count);
 done:
         tty_ldisc_deref(ld);
 }
diff --git a/drivers/char/selection.c b/drivers/char/selection.c
index 5b187c895c18..71093a9fc462 100644
--- a/drivers/char/selection.c
+++ b/drivers/char/selection.c
@@ -275,7 +275,8 @@ int set_selection(const struct tiocl_selection __user *sel, struct tty_struct *t
 int paste_selection(struct tty_struct *tty)
 {
         struct vc_data *vc = (struct vc_data *)tty->driver_data;
-        int     pasted = 0, count;
+        int     pasted = 0;
+        unsigned int count;
         struct  tty_ldisc *ld;
         DECLARE_WAITQUEUE(wait, current);
 
@@ -293,7 +294,7 @@ int paste_selection(struct tty_struct *tty)
                         continue;
                 }
                 count = sel_buffer_lth - pasted;
-                count = min(count, tty->ldisc.receive_room(tty));
+                count = min(count, tty->receive_room);
                 tty->ldisc.receive_buf(tty, sel_buffer + pasted, NULL, count);
                 pasted += count;
         }
diff --git a/drivers/char/ser_a2232.c b/drivers/char/ser_a2232.c
index dda30e42ec79..80a5b840e22f 100644
--- a/drivers/char/ser_a2232.c
+++ b/drivers/char/ser_a2232.c
@@ -194,11 +194,6 @@ static inline void a2232_receive_char(struct a2232_port *port, int ch, int err)
 */
         struct tty_struct *tty = port->gs.tty;
 
-        if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                return;
-
-        tty->flip.count++;
-
 #if 0
         switch(err) {
         case TTY_BREAK:
@@ -212,8 +207,7 @@ static inline void a2232_receive_char(struct a2232_port *port, int ch, int err)
         }
 #endif
 
-        *tty->flip.flag_buf_ptr++ = err;
-        *tty->flip.char_buf_ptr++ = ch;
+        tty_insert_flip_char(tty, ch, err);
         tty_flip_buffer_push(tty);
 }
 
diff --git a/drivers/char/serial167.c b/drivers/char/serial167.c
index c2deac968bdd..f36342ae8e7e 100644
--- a/drivers/char/serial167.c
+++ b/drivers/char/serial167.c
@@ -117,7 +117,7 @@ struct cyclades_port cy_port[] = {
         {-1 },      /* ttyS2 */
         {-1 },      /* ttyS3 */
 };
-#define NR_PORTS        (sizeof(cy_port)/sizeof(struct cyclades_port))
+#define NR_PORTS        ARRAY_SIZE(cy_port)
 
 /*
  * tmp_buf is used as a temporary buffer by serial_write.  We need to
@@ -422,45 +422,35 @@ cd2401_rxerr_interrupt(int irq, void *dev_id, struct pt_regs *fp)
             base_addr[CyREOIR] = rfoc ? 0 : CyNOTRANS;
             return IRQ_HANDLED;
         }
-        if (tty->flip.count < TTY_FLIPBUF_SIZE){
-            tty->flip.count++;
+        if (tty_buffer_request_room(tty, 1) != 0){
             if (err & info->read_status_mask){
                 if(err & CyBREAK){
-                    *tty->flip.flag_buf_ptr++ = TTY_BREAK;
-                    *tty->flip.char_buf_ptr++ = data;
+                    tty_insert_flip_char(tty, data, TTY_BREAK);
                     if (info->flags & ASYNC_SAK){
                         do_SAK(tty);
                     }
                 }else if(err & CyFRAME){
-                    *tty->flip.flag_buf_ptr++ = TTY_FRAME;
-                    *tty->flip.char_buf_ptr++ = data;
+                    tty_insert_flip_char(tty, data, TTY_FRAME);
                 }else if(err & CyPARITY){
-                    *tty->flip.flag_buf_ptr++ = TTY_PARITY;
-                    *tty->flip.char_buf_ptr++ = data;
+                    tty_insert_flip_char(tty, data, TTY_PARITY);
                 }else if(err & CyOVERRUN){
-                    *tty->flip.flag_buf_ptr++ = TTY_OVERRUN;
-                    *tty->flip.char_buf_ptr++ = 0;
+                    tty_insert_flip_char(tty, 0, TTY_OVERRUN);
                     /*
                        If the flip buffer itself is
                        overflowing, we still loose
                        the next incoming character.
                      */
-                    if(tty->flip.count < TTY_FLIPBUF_SIZE){
-                        tty->flip.count++;
-                        *tty->flip.flag_buf_ptr++ = TTY_NORMAL;
-                        *tty->flip.char_buf_ptr++ = data;
-                    }
+                    tty_insert_flip_char(tty, data, TTY_NORMAL);
+                }
                 /* These two conditions may imply */
                 /* a normal read should be done. */
                 /* else if(data & CyTIMEOUT) */
                 /* else if(data & CySPECHAR) */
                 }else{
-                    *tty->flip.flag_buf_ptr++ = 0;
-                    *tty->flip.char_buf_ptr++ = 0;
+                    tty_insert_flip_char(tty, 0, TTY_NORMAL);
                 }
             }else{
-                *tty->flip.flag_buf_ptr++ = 0;
-                *tty->flip.char_buf_ptr++ = 0;
+                    tty_insert_flip_char(tty, data, TTY_NORMAL);
             }
         }else{
             /* there was a software buffer overrun
@@ -692,12 +682,7 @@ cd2401_rx_interrupt(int irq, void *dev_id, struct pt_regs *fp)
 #endif
         while(char_count--){
             data = base_addr[CyRDR];
-            if (tty->flip.count >= TTY_FLIPBUF_SIZE){
-                continue;
-            }
-            tty->flip.count++;
-            *tty->flip.flag_buf_ptr++ = TTY_NORMAL;
-            *tty->flip.char_buf_ptr++ = data;
+            tty_insert_flip_char(tty, data, TTY_NORMAL);
 #ifdef CYCLOM_16Y_HACK
             udelay(10L);
 #endif
diff --git a/drivers/char/specialix.c b/drivers/char/specialix.c
index 0bbfce43031c..0a574bdbce36 100644
--- a/drivers/char/specialix.c
+++ b/drivers/char/specialix.c
@@ -85,6 +85,7 @@
 #include <linux/interrupt.h>
 #include <linux/errno.h>
 #include <linux/tty.h>
+#include <linux/tty_flip.h>
 #include <linux/mm.h>
 #include <linux/serial.h>
 #include <linux/fcntl.h>
@@ -665,7 +666,7 @@ static inline void sx_receive_exc(struct specialix_board * bp)
         struct specialix_port *port;
         struct tty_struct *tty;
         unsigned char status;
-        unsigned char ch;
+        unsigned char ch, flag;
 
         func_enter();
 
@@ -676,8 +677,6 @@ static inline void sx_receive_exc(struct specialix_board * bp)
                 return;
         }
         tty = port->tty;
-        dprintk (SX_DEBUG_RX, "port: %p count: %d BUFF_SIZE: %d\n",
-                 port,  tty->flip.count, TTY_FLIPBUF_SIZE);
 
         status = sx_in(bp, CD186x_RCSR);
 
@@ -691,7 +690,7 @@ static inline void sx_receive_exc(struct specialix_board * bp)
 
         /* This flip buffer check needs to be below the reading of the
            status register to reset the chip's IRQ.... */
-        if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
+        if (tty_buffer_request_room(tty, 1) == 0) {
                 dprintk(SX_DEBUG_FIFO, "sx%d: port %d: Working around flip buffer overflow.\n",
                        board_No(bp), port_No(port));
                 func_exit();
@@ -712,26 +711,24 @@ static inline void sx_receive_exc(struct specialix_board * bp)
         } else if (status & RCSR_BREAK) {
                 dprintk(SX_DEBUG_RX, "sx%d: port %d: Handling break...\n",
                        board_No(bp), port_No(port));
-                *tty->flip.flag_buf_ptr++ = TTY_BREAK;
+                flag = TTY_BREAK;
                 if (port->flags & ASYNC_SAK)
                         do_SAK(tty);
 
         } else if (status & RCSR_PE)
-                *tty->flip.flag_buf_ptr++ = TTY_PARITY;
+                flag = TTY_PARITY;
 
         else if (status & RCSR_FE)
-                *tty->flip.flag_buf_ptr++ = TTY_FRAME;
+                flag = TTY_FRAME;
 
         else if (status & RCSR_OE)
-                *tty->flip.flag_buf_ptr++ = TTY_OVERRUN;
+                flag = TTY_OVERRUN;
 
         else
-                *tty->flip.flag_buf_ptr++ = 0;
-
-        *tty->flip.char_buf_ptr++ = ch;
-        tty->flip.count++;
-        schedule_delayed_work(&tty->flip.work, 1);
+                flag = TTY_NORMAL;
 
+        if(tty_insert_flip_char(tty, ch, flag))
+                tty_flip_buffer_push(tty);
         func_exit();
 }
 
@@ -755,18 +752,11 @@ static inline void sx_receive(struct specialix_board * bp)
         dprintk (SX_DEBUG_RX, "port: %p: count: %d\n", port, count);
         port->hits[count > 8 ? 9 : count]++;
 
-        while (count--) {
-                if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                        printk(KERN_INFO "sx%d: port %d: Working around flip buffer overflow.\n",
-                               board_No(bp), port_No(port));
-                        break;
-                }
-                *tty->flip.char_buf_ptr++ = sx_in(bp, CD186x_RDR);
-                *tty->flip.flag_buf_ptr++ = 0;
-                tty->flip.count++;
-        }
-        schedule_delayed_work(&tty->flip.work, 1);
+        tty_buffer_request_room(tty, count);
 
+        while (count--)
+                tty_insert_flip_char(tty, sx_in(bp, CD186x_RDR), TTY_NORMAL);
+        tty_flip_buffer_push(tty);
         func_exit();
 }
 
diff --git a/drivers/char/stallion.c b/drivers/char/stallion.c
index 95af2a941595..0e20780d4a29 100644
--- a/drivers/char/stallion.c
+++ b/drivers/char/stallion.c
@@ -103,7 +103,7 @@ static stlconf_t	stl_brdconf[] = {
         /*{ BRD_EASYIO, 0x2a0, 0, 0, 10, 0 },*/
 };
 
-static int      stl_nrbrds = sizeof(stl_brdconf) / sizeof(stlconf_t);
+static int      stl_nrbrds = ARRAY_SIZE(stl_brdconf);
 
 /*****************************************************************************/
 
@@ -424,7 +424,7 @@ static stlpcibrd_t	stl_pcibrds[] = {
         { PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_87410, BRD_ECHPCI },
 };
 
-static int      stl_nrpcibrds = sizeof(stl_pcibrds) / sizeof(stlpcibrd_t);
+static int      stl_nrpcibrds = ARRAY_SIZE(stl_pcibrds);
 
 #endif
 
@@ -704,7 +704,7 @@ static unsigned int	sc26198_baudtable[] = {
         230400, 460800, 921600
 };
 
-#define SC26198_NRBAUDS         (sizeof(sc26198_baudtable) / sizeof(unsigned int))
+#define SC26198_NRBAUDS         ARRAY_SIZE(sc26198_baudtable)
 
 /*****************************************************************************/
 
@@ -901,7 +901,7 @@ static unsigned long stl_atol(char *str)
 static int stl_parsebrd(stlconf_t *confp, char **argp)
 {
         char    *sp;
-        int     nrbrdnames, i;
+        int     i;
 
 #ifdef DEBUG
         printk("stl_parsebrd(confp=%x,argp=%x)\n", (int) confp, (int) argp);
@@ -913,14 +913,13 @@ static int stl_parsebrd(stlconf_t *confp, char **argp)
         for (sp = argp[0], i = 0; ((*sp != 0) && (i < 25)); sp++, i++)
                 *sp = TOLOWER(*sp);
 
-        nrbrdnames = sizeof(stl_brdstr) / sizeof(stlbrdtype_t);
-        for (i = 0; (i < nrbrdnames); i++) {
+        for (i = 0; i < ARRAY_SIZE(stl_brdstr); i++) {
                 if (strcmp(stl_brdstr[i].name, argp[0]) == 0)
                         break;
         }
-        if (i >= nrbrdnames) {
+        if (i == ARRAY_SIZE(stl_brdstr)) {
                 printk("STALLION: unknown board name, %s?\n", argp[0]);
-                return(0);
+                return 0;
         }
 
         confp->brdtype = stl_brdstr[i].type;
@@ -2902,7 +2901,8 @@ static int stl_getportstats(stlport_t *portp, comstats_t __user *cp)
         if (portp->tty != (struct tty_struct *) NULL) {
                 if (portp->tty->driver_data == portp) {
                         portp->stats.ttystate = portp->tty->flags;
-                        portp->stats.rxbuffered = portp->tty->flip.count;
+                        /* No longer available as a statistic */
+                        portp->stats.rxbuffered = 1; /*portp->tty->flip.count; */
                         if (portp->tty->termios != (struct termios *) NULL) {
                                 portp->stats.cflags = portp->tty->termios->c_cflag;
                                 portp->stats.iflags = portp->tty->termios->c_iflag;
@@ -4046,9 +4046,7 @@ static void stl_cd1400rxisr(stlpanel_t *panelp, int ioaddr)
         if ((ioack & ACK_TYPMASK) == ACK_TYPRXGOOD) {
                 outb((RDCR + portp->uartaddr), ioaddr);
                 len = inb(ioaddr + EREG_DATA);
-                if ((tty == (struct tty_struct *) NULL) ||
-                    (tty->flip.char_buf_ptr == (char *) NULL) ||
-                    ((buflen = TTY_FLIPBUF_SIZE - tty->flip.count) == 0)) {
+                if (tty == NULL || (buflen = tty_buffer_request_room(tty, len)) == 0) {
                         len = MIN(len, sizeof(stl_unwanted));
                         outb((RDSR + portp->uartaddr), ioaddr);
                         insb((ioaddr + EREG_DATA), &stl_unwanted[0], len);
@@ -4057,12 +4055,10 @@ static void stl_cd1400rxisr(stlpanel_t *panelp, int ioaddr)
                 } else {
                         len = MIN(len, buflen);
                         if (len > 0) {
+                                unsigned char *ptr;
                                 outb((RDSR + portp->uartaddr), ioaddr);
-                                insb((ioaddr + EREG_DATA), tty->flip.char_buf_ptr, len);
-                                memset(tty->flip.flag_buf_ptr, 0, len);
-                                tty->flip.flag_buf_ptr += len;
-                                tty->flip.char_buf_ptr += len;
-                                tty->flip.count += len;
+                                tty_prepare_flip_string(tty, &ptr, len);
+                                insb((ioaddr + EREG_DATA), ptr, len);
                                 tty_schedule_flip(tty);
                                 portp->stats.rxtotal += len;
                         }
@@ -4086,8 +4082,7 @@ static void stl_cd1400rxisr(stlpanel_t *panelp, int ioaddr)
                                 portp->stats.txxoff++;
                         goto stl_rxalldone;
                 }
-                if ((tty != (struct tty_struct *) NULL) &&
-                    ((portp->rxignoremsk & status) == 0)) {
+                if (tty != NULL && (portp->rxignoremsk & status) == 0) {
                         if (portp->rxmarkmsk & status) {
                                 if (status & ST_BREAK) {
                                         status = TTY_BREAK;
@@ -4107,14 +4102,8 @@ static void stl_cd1400rxisr(stlpanel_t *panelp, int ioaddr)
                         } else {
                                 status = 0;
                         }
-                        if (tty->flip.char_buf_ptr != (char *) NULL) {
-                                if (tty->flip.count < TTY_FLIPBUF_SIZE) {
-                                        *tty->flip.flag_buf_ptr++ = status;
-                                        *tty->flip.char_buf_ptr++ = ch;
-                                        tty->flip.count++;
-                                }
-                                tty_schedule_flip(tty);
-                        }
+                        tty_insert_flip_char(tty, ch, status);
+                        tty_schedule_flip(tty);
                 }
         } else {
                 printk("STALLION: bad RX interrupt ack value=%x\n", ioack);
@@ -5013,9 +5002,7 @@ static void stl_sc26198rxisr(stlport_t *portp, unsigned int iack)
         len = inb(ioaddr + XP_DATA) + 1;
 
         if ((iack & IVR_TYPEMASK) == IVR_RXDATA) {
-                if ((tty == (struct tty_struct *) NULL) ||
-                    (tty->flip.char_buf_ptr == (char *) NULL) ||
-                    ((buflen = TTY_FLIPBUF_SIZE - tty->flip.count) == 0)) {
+                if (tty == NULL || (buflen = tty_buffer_request_room(tty, len)) == 0) {
                         len = MIN(len, sizeof(stl_unwanted));
                         outb(GRXFIFO, (ioaddr + XP_ADDR));
                         insb((ioaddr + XP_DATA), &stl_unwanted[0], len);
@@ -5024,12 +5011,10 @@ static void stl_sc26198rxisr(stlport_t *portp, unsigned int iack)
                 } else {
                         len = MIN(len, buflen);
                         if (len > 0) {
+                                unsigned char *ptr;
                                 outb(GRXFIFO, (ioaddr + XP_ADDR));
-                                insb((ioaddr + XP_DATA), tty->flip.char_buf_ptr, len);
-                                memset(tty->flip.flag_buf_ptr, 0, len);
-                                tty->flip.flag_buf_ptr += len;
-                                tty->flip.char_buf_ptr += len;
-                                tty->flip.count += len;
+                                tty_prepare_flip_string(tty, &ptr, len);
+                                insb((ioaddr + XP_DATA), ptr, len);
                                 tty_schedule_flip(tty);
                                 portp->stats.rxtotal += len;
                         }
@@ -5097,14 +5082,8 @@ static inline void stl_sc26198rxbadch(stlport_t *portp, unsigned char status, ch
                         status = 0;
                 }
 
-                if (tty->flip.char_buf_ptr != (char *) NULL) {
-                        if (tty->flip.count < TTY_FLIPBUF_SIZE) {
-                                *tty->flip.flag_buf_ptr++ = status;
-                                *tty->flip.char_buf_ptr++ = ch;
-                                tty->flip.count++;
-                        }
-                        tty_schedule_flip(tty);
-                }
+                tty_insert_flip_char(tty, ch, status);
+                tty_schedule_flip(tty);
 
                 if (status == 0)
                         portp->stats.rxtotal++;
diff --git a/drivers/char/sx.c b/drivers/char/sx.c
index 3ad758a9a1dc..64bf89cb574f 100644
--- a/drivers/char/sx.c
+++ b/drivers/char/sx.c
@@ -345,9 +345,9 @@ static int si_probe_addrs[]= {0xc0000, 0xd0000, 0xe0000,
                               0xc8000, 0xd8000, 0xe8000, 0xa0000};
 static int si1_probe_addrs[]= { 0xd0000};
 
-#define NR_SX_ADDRS (sizeof(sx_probe_addrs)/sizeof (int))
-#define NR_SI_ADDRS (sizeof(si_probe_addrs)/sizeof (int))
-#define NR_SI1_ADDRS (sizeof(si1_probe_addrs)/sizeof (int))
+#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)
 
 
 /* Set the mask to all-ones. This alas, only supports 32 interrupts. 
@@ -1085,6 +1085,7 @@ static inline void sx_receive_chars (struct sx_port *port)
         int rx_op;
         struct tty_struct *tty;
         int copied=0;
+        unsigned char *rp;
 
         func_enter2 ();
         tty = port->gs.tty;
@@ -1095,8 +1096,8 @@ static inline void sx_receive_chars (struct sx_port *port)
                 sx_dprintk (SX_DEBUG_RECEIVE, "rxop=%d, c = %d.\n", rx_op, c); 
 
                 /* Don't copy more bytes than there is room for in the buffer */
-                if (tty->flip.count + c > TTY_FLIPBUF_SIZE) 
-                        c = TTY_FLIPBUF_SIZE - tty->flip.count;
+
+                c = tty_prepare_flip_string(tty, &rp, c);
 
                 sx_dprintk (SX_DEBUG_RECEIVE, "c = %d.\n", c); 
 
@@ -1111,14 +1112,8 @@ static inline void sx_receive_chars (struct sx_port *port)
                 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 (tty->flip.char_buf_ptr, 
+                memcpy_fromio (rp,
                                port->board->base + CHAN_OFFSET(port,hi_rxbuf) + rx_op, c);
-                memset(tty->flip.flag_buf_ptr, TTY_NORMAL, c);
-
-                /* Update the kernel buffer end */
-                tty->flip.count += c;
-                tty->flip.char_buf_ptr += c;
-                tty->flip.flag_buf_ptr += c;
 
                 /* This one last. ( Not essential.)
                    It allows the card to start putting more data into the buffer! 
diff --git a/drivers/char/synclink.c b/drivers/char/synclink.c
index 62aa0e534a6d..9f1b466c4f84 100644
--- a/drivers/char/synclink.c
+++ b/drivers/char/synclink.c
@@ -1467,6 +1467,7 @@ static void mgsl_isr_receive_data( struct mgsl_struct *info )
 {
         int Fifocount;
         u16 status;
+        int work = 0;
         unsigned char DataByte;
         struct tty_struct *tty = info->tty;
         struct  mgsl_icount *icount = &info->icount;
@@ -1487,6 +1488,8 @@ static void mgsl_isr_receive_data( struct mgsl_struct *info )
         /* flush the receive FIFO */
 
         while( (Fifocount = (usc_InReg(info,RICR) >> 8)) ) {
+                int flag;
+
                 /* read one byte from RxFIFO */
                 outw( (inw(info->io_base + CCAR) & 0x0780) | (RDR+LSBONLY),
                       info->io_base + CCAR );
@@ -1498,13 +1501,9 @@ static void mgsl_isr_receive_data( struct mgsl_struct *info )
                                 RXSTATUS_OVERRUN + RXSTATUS_BREAK_RECEIVED) )
                         usc_UnlatchRxstatusBits(info,RXSTATUS_ALL);
                 
-                if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                        continue;
-                        
-                *tty->flip.char_buf_ptr = DataByte;
                 icount->rx++;
                 
-                *tty->flip.flag_buf_ptr = 0;
+                flag = 0;
                 if ( status & (RXSTATUS_FRAMING_ERROR + RXSTATUS_PARITY_ERROR +
                                 RXSTATUS_OVERRUN + RXSTATUS_BREAK_RECEIVED) ) {
                         printk("rxerr=%04X\n",status);                                  
@@ -1530,41 +1529,31 @@ static void mgsl_isr_receive_data( struct mgsl_struct *info )
                         status &= info->read_status_mask;
                 
                         if (status & RXSTATUS_BREAK_RECEIVED) {
-                                *tty->flip.flag_buf_ptr = TTY_BREAK;
+                                flag = TTY_BREAK;
                                 if (info->flags & ASYNC_SAK)
                                         do_SAK(tty);
                         } else if (status & RXSTATUS_PARITY_ERROR)
-                                *tty->flip.flag_buf_ptr = TTY_PARITY;
+                                flag = TTY_PARITY;
                         else if (status & RXSTATUS_FRAMING_ERROR)
-                                *tty->flip.flag_buf_ptr = TTY_FRAME;
-                        if (status & RXSTATUS_OVERRUN) {
-                                /* Overrun is special, since it's
-                                 * reported immediately, and doesn't
-                                 * affect the current character
-                                 */
-                                if (tty->flip.count < TTY_FLIPBUF_SIZE) {
-                                        tty->flip.count++;
-                                        tty->flip.flag_buf_ptr++;
-                                        tty->flip.char_buf_ptr++;
-                                        *tty->flip.flag_buf_ptr = TTY_OVERRUN;
-                                }
-                        }
+                                flag = TTY_FRAME;
                 }       /* end of if (error) */
-                
-                tty->flip.flag_buf_ptr++;
-                tty->flip.char_buf_ptr++;
-                tty->flip.count++;
+                tty_insert_flip_char(tty, DataByte, flag);
+                if (status & RXSTATUS_OVERRUN) {
+                        /* Overrun is special, since it's
+                         * reported immediately, and doesn't
+                         * affect the current character
+                         */
+                        work += tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                }
         }
 
         if ( debug_level >= DEBUG_LEVEL_ISR ) {
-                printk("%s(%d):mgsl_isr_receive_data flip count=%d\n",
-                        __FILE__,__LINE__,tty->flip.count);
                 printk("%s(%d):rx=%d brk=%d parity=%d frame=%d overrun=%d\n",
                         __FILE__,__LINE__,icount->rx,icount->brk,
                         icount->parity,icount->frame,icount->overrun);
         }
                         
-        if ( tty->flip.count )
+        if(work)
                 tty_flip_buffer_push(tty);
 }
 
@@ -7058,7 +7047,7 @@ static BOOLEAN mgsl_register_test( struct mgsl_struct *info )
 {
         static unsigned short BitPatterns[] =
                 { 0x0000, 0xffff, 0xaaaa, 0x5555, 0x1234, 0x6969, 0x9696, 0x0f0f };
-        static unsigned int Patterncount = sizeof(BitPatterns)/sizeof(unsigned short);
+        static unsigned int Patterncount = ARRAY_SIZE(BitPatterns);
         unsigned int i;
         BOOLEAN rc = TRUE;
         unsigned long flags;
@@ -7501,9 +7490,9 @@ static int mgsl_adapter_test( struct mgsl_struct *info )
  */
 static BOOLEAN mgsl_memory_test( struct mgsl_struct *info )
 {
-        static unsigned long BitPatterns[] = { 0x0, 0x55555555, 0xaaaaaaaa,
-                                                                                        0x66666666, 0x99999999, 0xffffffff, 0x12345678 };
-        unsigned long Patterncount = sizeof(BitPatterns)/sizeof(unsigned long);
+        static unsigned long BitPatterns[] =
+                { 0x0, 0x55555555, 0xaaaaaaaa, 0x66666666, 0x99999999, 0xffffffff, 0x12345678 };
+        unsigned long Patterncount = ARRAY_SIZE(BitPatterns);
         unsigned long i;
         unsigned long TestLimit = SHARED_MEM_ADDRESS_SIZE/sizeof(unsigned long);
         unsigned long * TestAddr;
diff --git a/drivers/char/synclink_gt.c b/drivers/char/synclink_gt.c
index 2b9cde94e2f7..79c81def4104 100644
--- a/drivers/char/synclink_gt.c
+++ b/drivers/char/synclink_gt.c
@@ -75,7 +75,6 @@
 #include <linux/workqueue.h>
 #include <linux/hdlc.h>
 
-#include <asm/serial.h>
 #include <asm/system.h>
 #include <asm/io.h>
 #include <asm/irq.h>
@@ -1750,6 +1749,9 @@ static void rx_async(struct slgt_info *info)
         unsigned char status;
         struct slgt_desc *bufs = info->rbufs;
         int i, count;
+        int chars = 0;
+        int stat;
+        unsigned char ch;
 
         start = end = info->rbuf_current;
 
@@ -1761,16 +1763,15 @@ static void rx_async(struct slgt_info *info)
                 DBGDATA(info, p, count, "rx");
 
                 for(i=0 ; i < count; i+=2, p+=2) {
-                        if (tty) {
-                                if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                                        tty_flip_buffer_push(tty);
-                                if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                                        break;
-                                *tty->flip.char_buf_ptr = *p;
-                                *tty->flip.flag_buf_ptr = 0;
+                        if (tty && chars) {
+                                tty_flip_buffer_push(tty);
+                                chars = 0;
                         }
+                        ch = *p;
                         icount->rx++;
 
+                        stat = 0;
+
                         if ((status = *(p+1) & (BIT9 + BIT8))) {
                                 if (status & BIT9)
                                         icount->parity++;
@@ -1779,17 +1780,14 @@ static void rx_async(struct slgt_info *info)
                                 /* discard char if tty control flags say so */
                                 if (status & info->ignore_status_mask)
                                         continue;
-                                if (tty) {
-                                        if (status & BIT9)
-                                                *tty->flip.flag_buf_ptr = TTY_PARITY;
-                                        else if (status & BIT8)
-                                                *tty->flip.flag_buf_ptr = TTY_FRAME;
-                                }
+                                if (status & BIT9)
+                                        stat = TTY_PARITY;
+                                else if (status & BIT8)
+                                        stat = TTY_FRAME;
                         }
                         if (tty) {
-                                tty->flip.flag_buf_ptr++;
-                                tty->flip.char_buf_ptr++;
-                                tty->flip.count++;
+                                tty_insert_flip_char(tty, ch, stat);
+                                chars++;
                         }
                 }
 
@@ -1812,7 +1810,7 @@ static void rx_async(struct slgt_info *info)
                         break;
         }
 
-        if (tty && tty->flip.count)
+        if (tty && chars)
                 tty_flip_buffer_push(tty);
 }
 
@@ -2030,7 +2028,7 @@ static void isr_serial(struct slgt_info *info)
                         if (info->tty) {
                                 if (!(status & info->ignore_status_mask)) {
                                         if (info->read_status_mask & MASK_BREAK) {
-                                                *info->tty->flip.flag_buf_ptr = TTY_BREAK;
+                                                tty_insert_flip_char(info->tty, 0, TTY_BREAK);
                                                 if (info->flags & ASYNC_SAK)
                                                         do_SAK(info->tty);
                                         }
diff --git a/drivers/char/synclinkmp.c b/drivers/char/synclinkmp.c
index ee5a40be9f99..960adb256fbb 100644
--- a/drivers/char/synclinkmp.c
+++ b/drivers/char/synclinkmp.c
@@ -2196,7 +2196,7 @@ void isr_rxint(SLMP_INFO * info)
                         if ( tty ) {
                                 if (!(status & info->ignore_status_mask1)) {
                                         if (info->read_status_mask1 & BRKD) {
-                                                *tty->flip.flag_buf_ptr = TTY_BREAK;
+                                                tty_insert_flip_char(tty, 0, TTY_BREAK);
                                                 if (info->flags & ASYNC_SAK)
                                                         do_SAK(tty);
                                         }
@@ -2240,16 +2240,10 @@ void isr_rxrdy(SLMP_INFO * info)
 
         while((status = read_reg(info,CST0)) & BIT0)
         {
+                int flag = 0;
+                int over = 0;
                 DataByte = read_reg(info,TRB);
 
-                if ( tty ) {
-                        if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                                continue;
-
-                        *tty->flip.char_buf_ptr = DataByte;
-                        *tty->flip.flag_buf_ptr = 0;
-                }
-
                 icount->rx++;
 
                 if ( status & (PE + FRME + OVRN) ) {
@@ -2272,42 +2266,34 @@ void isr_rxrdy(SLMP_INFO * info)
 
                         if ( tty ) {
                                 if (status & PE)
-                                        *tty->flip.flag_buf_ptr = TTY_PARITY;
+                                        flag = TTY_PARITY;
                                 else if (status & FRME)
-                                        *tty->flip.flag_buf_ptr = TTY_FRAME;
+                                        flag = TTY_FRAME;
                                 if (status & OVRN) {
                                         /* Overrun is special, since it's
                                          * reported immediately, and doesn't
                                          * affect the current character
                                          */
-                                        if (tty->flip.count < TTY_FLIPBUF_SIZE) {
-                                                tty->flip.count++;
-                                                tty->flip.flag_buf_ptr++;
-                                                tty->flip.char_buf_ptr++;
-                                                *tty->flip.flag_buf_ptr = TTY_OVERRUN;
-                                        }
+                                        over = 1;
                                 }
                         }
                 }       /* end of if (error) */
 
                 if ( tty ) {
-                        tty->flip.flag_buf_ptr++;
-                        tty->flip.char_buf_ptr++;
-                        tty->flip.count++;
+                        tty_insert_flip_char(tty, DataByte, flag);
+                        if (over)
+                                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
                 }
         }
 
         if ( debug_level >= DEBUG_LEVEL_ISR ) {
-                printk("%s(%d):%s isr_rxrdy() flip count=%d\n",
-                        __FILE__,__LINE__,info->device_name,
-                        tty ? tty->flip.count : 0);
                 printk("%s(%d):%s rx=%d brk=%d parity=%d frame=%d overrun=%d\n",
                         __FILE__,__LINE__,info->device_name,
                         icount->rx,icount->brk,icount->parity,
                         icount->frame,icount->overrun);
         }
 
-        if ( tty && tty->flip.count )
+        if ( tty )
                 tty_flip_buffer_push(tty);
 }
 
@@ -5104,7 +5090,7 @@ void tx_load_dma_buffer(SLMP_INFO *info, const char *buf, unsigned int count)
 int register_test(SLMP_INFO *info)
 {
         static unsigned char testval[] = {0x00, 0xff, 0xaa, 0x55, 0x69, 0x96};
-        static unsigned int count = sizeof(testval)/sizeof(unsigned char);
+        static unsigned int count = ARRAY_SIZE(testval);
         unsigned int i;
         int rc = TRUE;
         unsigned long flags;
@@ -5422,7 +5408,7 @@ int memory_test(SLMP_INFO *info)
 {
         static unsigned long testval[] = { 0x0, 0x55555555, 0xaaaaaaaa,
                 0x66666666, 0x99999999, 0xffffffff, 0x12345678 };
-        unsigned long count = sizeof(testval)/sizeof(unsigned long);
+        unsigned long count = ARRAY_SIZE(testval);
         unsigned long i;
         unsigned long limit = SCA_MEM_SIZE/sizeof(unsigned long);
         unsigned long * addr = (unsigned long *)info->memory_base;
diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index 4b1eef51ec59..1eda82b31a61 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -166,9 +166,12 @@ static struct tty_struct *alloc_tty_struct(void)
         return tty;
 }
 
+static void tty_buffer_free_all(struct tty_struct *);
+
 static inline void free_tty_struct(struct tty_struct *tty)
 {
         kfree(tty->write_buf);
+        tty_buffer_free_all(tty);
         kfree(tty);
 }
 
@@ -231,6 +234,201 @@ static int check_tty_count(struct tty_struct *tty, const char *routine)
 }
 
 /*
+ * Tty buffer allocation management
+ */
+
+static void tty_buffer_free_all(struct tty_struct *tty)
+{
+        struct tty_buffer *thead;
+        while((thead = tty->buf.head) != NULL) {
+                tty->buf.head = thead->next;
+                kfree(thead);
+        }
+        while((thead = tty->buf.free) != NULL) {
+                tty->buf.free = thead->next;
+                kfree(thead);
+        }
+        tty->buf.tail = NULL;
+}
+
+static void tty_buffer_init(struct tty_struct *tty)
+{
+        tty->buf.head = NULL;
+        tty->buf.tail = NULL;
+        tty->buf.free = NULL;
+}
+
+static struct tty_buffer *tty_buffer_alloc(size_t size)
+{
+        struct tty_buffer *p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
+        if(p == NULL)
+                return NULL;
+        p->used = 0;
+        p->size = size;
+        p->next = NULL;
+        p->char_buf_ptr = (char *)(p->data);
+        p->flag_buf_ptr = (unsigned char *)p->char_buf_ptr + size;
+/*      printk("Flip create %p\n", p); */
+        return p;
+}
+
+/* Must be called with the tty_read lock held. This needs to acquire strategy
+   code to decide if we should kfree or relink a given expired buffer */
+
+static void tty_buffer_free(struct tty_struct *tty, struct tty_buffer *b)
+{
+        /* Dumb strategy for now - should keep some stats */
+/*      printk("Flip dispose %p\n", b); */
+        if(b->size >= 512)
+                kfree(b);
+        else {
+                b->next = tty->buf.free;
+                tty->buf.free = b;
+        }
+}
+
+static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
+{
+        struct tty_buffer **tbh = &tty->buf.free;
+        while((*tbh) != NULL) {
+                struct tty_buffer *t = *tbh;
+                if(t->size >= size) {
+                        *tbh = t->next;
+                        t->next = NULL;
+                        t->used = 0;
+                        /* DEBUG ONLY */
+                        memset(t->data, '*', size);
+/*                      printk("Flip recycle %p\n", t); */
+                        return t;
+                }
+                tbh = &((*tbh)->next);
+        }
+        /* Round the buffer size out */
+        size = (size + 0xFF) & ~ 0xFF;
+        return tty_buffer_alloc(size);
+        /* Should possibly check if this fails for the largest buffer we
+           have queued and recycle that ? */
+}
+
+int tty_buffer_request_room(struct tty_struct *tty, size_t size)
+{
+        struct tty_buffer *b = tty->buf.head, *n;
+        int left = 0;
+
+        /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
+           remove this conditional if its worth it. This would be invisible
+           to the callers */
+        if(b != NULL)
+                left = b->size - b->used;
+        if(left >= size)
+                return size;
+        /* This is the slow path - looking for new buffers to use */
+        n = tty_buffer_find(tty, size);
+        if(n == NULL)
+                return left;
+        n->next = b;
+        if(b != NULL)
+                b->next = n;
+        else
+                tty->buf.head = n;
+        tty->buf.tail = n;
+        return size;
+}
+
+EXPORT_SYMBOL_GPL(tty_buffer_request_room);
+
+int tty_insert_flip_string(struct tty_struct *tty, unsigned char *chars, size_t size)
+{
+        int copied = 0;
+        do {
+                int space = tty_buffer_request_room(tty, size - copied);
+                struct tty_buffer *tb = tty->buf.tail;
+                /* If there is no space then tb may be NULL */
+                if(unlikely(space == 0))
+                        break;
+                memcpy(tb->char_buf_ptr + tb->used, chars, space);
+                memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
+                tb->used += space;
+                copied += space;
+                chars += space;
+/*              printk("Flip insert %d.\n", 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));
+        return copied;
+}
+
+EXPORT_SYMBOL_GPL(tty_insert_flip_string);
+
+int tty_insert_flip_string_flags(struct tty_struct *tty, unsigned char *chars, char *flags, size_t size)
+{
+        int copied = 0;
+        do {
+                int space = tty_buffer_request_room(tty, size - copied);
+                struct tty_buffer *tb = tty->buf.tail;
+                /* If there is no space then tb may be NULL */
+                if(unlikely(space == 0))
+                        break;
+                memcpy(tb->char_buf_ptr + tb->used, chars, space);
+                memcpy(tb->flag_buf_ptr + tb->used, flags, space);
+                tb->used += space;
+                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));
+        return copied;
+}
+
+EXPORT_SYMBOL_GPL(tty_insert_flip_string_flags);
+
+
+/*
+ *      Prepare a block of space in the buffer for data. Returns the length
+ *      available and buffer pointer to the space which is now allocated and
+ *      accounted for as ready for normal characters. This is used for drivers
+ *      that need their own block copy routines into the buffer. There is no
+ *      guarantee the buffer is a DMA target!
+ */
+
+int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size)
+{
+        int space = tty_buffer_request_room(tty, size);
+        struct tty_buffer *tb = tty->buf.tail;
+        *chars = tb->char_buf_ptr + tb->used;
+        memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
+        tb->used += space;
+        return space;
+}
+
+EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
+
+/*
+ *      Prepare a block of space in the buffer for data. Returns the length
+ *      available and buffer pointer to the space which is now allocated and
+ *      accounted for as ready for characters. This is used for drivers
+ *      that need their own block copy routines into the buffer. There is no
+ *      guarantee the buffer is a DMA target!
+ */
+
+int tty_prepare_flip_string_flags(struct tty_struct *tty, unsigned char **chars, char **flags, size_t size)
+{
+        int space = tty_buffer_request_room(tty, size);
+        struct tty_buffer *tb = tty->buf.tail;
+        *chars = tb->char_buf_ptr + tb->used;
+        *flags = tb->flag_buf_ptr + tb->used;
+        tb->used += space;
+        return space;
+}
+
+EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
+
+
+
+/*
  *      This is probably overkill for real world processors but
  *      they are not on hot paths so a little discipline won't do 
  *      any harm.
@@ -492,6 +690,17 @@ restart:
         if (ld == NULL)
                 return -EINVAL;
 
+        /*
+         *      No more input please, we are switching. The new ldisc
+         *      will update this value in the ldisc open function
+         */
+
+        tty->receive_room = 0;
+
+        /*
+         *      Problem: What do we do if this blocks ?
+         */
+
         tty_wait_until_sent(tty, 0);
 
         if (tty->ldisc.num == ldisc) {
@@ -560,9 +769,9 @@ restart:
          *      we say so later on.
          */
 
-        work = cancel_delayed_work(&tty->flip.work);
+        work = cancel_delayed_work(&tty->buf.work);
         /*
-         * Wait for ->hangup_work and ->flip.work handlers to terminate
+         * Wait for ->hangup_work and ->buf.work handlers to terminate
          */
          
         flush_scheduled_work();
@@ -616,7 +825,7 @@ restart:
         /* Restart it in case no characters kick it off. Safe if
            already running */
         if (work)
-                schedule_delayed_work(&tty->flip.work, 1);
+                schedule_delayed_work(&tty->buf.work, 1);
         return retval;
 }
 
@@ -1721,10 +1930,10 @@ static void release_dev(struct file * filp)
          */
         clear_bit(TTY_LDISC, &tty->flags);
         clear_bit(TTY_DONT_FLIP, &tty->flags);
-        cancel_delayed_work(&tty->flip.work);
+        cancel_delayed_work(&tty->buf.work);
 
         /*
-         * Wait for ->hangup_work and ->flip.work handlers to terminate
+         * Wait for ->hangup_work and ->buf.work handlers to terminate
          */
          
         flush_scheduled_work();
@@ -2518,17 +2727,15 @@ EXPORT_SYMBOL(do_SAK);
 
 /*
  * This routine is called out of the software interrupt to flush data
- * from the flip buffer to the line discipline. 
+ * from the buffer chain to the line discipline.
  */
  
 static void flush_to_ldisc(void *private_)
 {
         struct tty_struct *tty = (struct tty_struct *) private_;
-        unsigned char   *cp;
-        char            *fp;
-        int             count;
         unsigned long   flags;
         struct tty_ldisc *disc;
+        struct tty_buffer *tbuf;
 
         disc = tty_ldisc_ref(tty);
         if (disc == NULL)       /*  !TTY_LDISC */
@@ -2538,28 +2745,22 @@ static void flush_to_ldisc(void *private_)
                 /*
                  * Do it after the next timer tick:
                  */
-                schedule_delayed_work(&tty->flip.work, 1);
+                schedule_delayed_work(&tty->buf.work, 1);
                 goto out;
         }
         spin_lock_irqsave(&tty->read_lock, flags);
-        if (tty->flip.buf_num) {
-                cp = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
-                fp = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
-                tty->flip.buf_num = 0;
-                tty->flip.char_buf_ptr = tty->flip.char_buf;
-                tty->flip.flag_buf_ptr = tty->flip.flag_buf;
-        } else {
-                cp = tty->flip.char_buf;
-                fp = tty->flip.flag_buf;
-                tty->flip.buf_num = 1;
-                tty->flip.char_buf_ptr = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
-                tty->flip.flag_buf_ptr = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
-        }
-        count = tty->flip.count;
-        tty->flip.count = 0;
+        while((tbuf = tty->buf.head) != NULL) {
+                tty->buf.head = tbuf->next;
+                spin_unlock_irqrestore(&tty->read_lock, flags);
+                /* printk("Process buffer %p for %d\n", tbuf, tbuf->used); */
+                disc->receive_buf(tty, tbuf->char_buf_ptr,
+                                       tbuf->flag_buf_ptr,
+                                       tbuf->used);
+                spin_lock_irqsave(&tty->read_lock, flags);
+                tty_buffer_free(tty, tbuf);
+        }
+        tty->buf.tail = NULL;
         spin_unlock_irqrestore(&tty->read_lock, flags);
-
-        disc->receive_buf(tty, cp, fp, count);
 out:
         tty_ldisc_deref(disc);
 }
@@ -2654,11 +2855,12 @@ void tty_flip_buffer_push(struct tty_struct *tty)
         if (tty->low_latency)
                 flush_to_ldisc((void *) tty);
         else
-                schedule_delayed_work(&tty->flip.work, 1);
+                schedule_delayed_work(&tty->buf.work, 1);
 }
 
 EXPORT_SYMBOL(tty_flip_buffer_push);
 
+
 /*
  * This subroutine initializes a tty structure.
  */
@@ -2669,10 +2871,10 @@ static void initialize_tty_struct(struct tty_struct *tty)
         tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
         tty->pgrp = -1;
         tty->overrun_time = jiffies;
-        tty->flip.char_buf_ptr = tty->flip.char_buf;
-        tty->flip.flag_buf_ptr = tty->flip.flag_buf;
-        INIT_WORK(&tty->flip.work, flush_to_ldisc, tty);
-        init_MUTEX(&tty->flip.pty_sem);
+        tty->buf.head = tty->buf.tail = NULL;
+        tty_buffer_init(tty);
+        INIT_WORK(&tty->buf.work, flush_to_ldisc, tty);
+        init_MUTEX(&tty->buf.pty_sem);
         init_MUTEX(&tty->termios_sem);
         init_waitqueue_head(&tty->write_wait);
         init_waitqueue_head(&tty->read_wait);
diff --git a/drivers/char/viocons.c b/drivers/char/viocons.c
index 4d75c261f98a..cb82ebf4cb07 100644
--- a/drivers/char/viocons.c
+++ b/drivers/char/viocons.c
@@ -993,11 +993,10 @@ static void vioHandleData(struct HvLpEvent *event)
                  * Don't attempt to copy more data into the buffer than we
                  * have room for because it would fail without indication.
                  */
-                if ((tty->flip.count + 1) > TTY_FLIPBUF_SIZE) {
+                if(tty_insert_flip_char(tty, cevent->data[index], TTY_NORMAL) == 0) {
                         printk(VIOCONS_KERN_WARN "input buffer overflow!\n");
                         break;
                 }
-                tty_insert_flip_char(tty, cevent->data[index], TTY_NORMAL);
         }
 
         /* if cevent->len == 0 then no data was added to the buffer and flip.count == 0 */
diff --git a/drivers/char/vme_scc.c b/drivers/char/vme_scc.c
index 19ba83635dd7..d9325281e482 100644
--- a/drivers/char/vme_scc.c
+++ b/drivers/char/vme_scc.c
@@ -434,13 +434,7 @@ static irqreturn_t scc_rx_int(int irq, void *data, struct pt_regs *fp)
                 SCCwrite_NB(COMMAND_REG, CR_HIGHEST_IUS_RESET);
                 return IRQ_HANDLED;
         }
-        if (tty->flip.count < TTY_FLIPBUF_SIZE) {
-                *tty->flip.char_buf_ptr = ch;
-                *tty->flip.flag_buf_ptr = 0;
-                tty->flip.flag_buf_ptr++;
-                tty->flip.char_buf_ptr++;
-                tty->flip.count++;
-        }
+        tty_insert_flip_char(tty, ch, 0);
 
         /* Check if another character is already ready; in that case, the
          * spcond_int() function must be used, because this character may have an
@@ -487,13 +481,7 @@ static irqreturn_t scc_spcond_int(int irq, void *data, struct pt_regs *fp)
                 else
                         err = 0;
 
-                if (tty->flip.count < TTY_FLIPBUF_SIZE) {
-                        *tty->flip.char_buf_ptr = ch;
-                        *tty->flip.flag_buf_ptr = err;
-                        tty->flip.flag_buf_ptr++;
-                        tty->flip.char_buf_ptr++;
-                        tty->flip.count++;
-                }
+                tty_insert_flip_char(tty, ch, err);
 
                 /* ++TeSche: *All* errors have to be cleared manually,
                  * else the condition persists for the next chars
@@ -875,13 +863,13 @@ static int scc_open (struct tty_struct * tty, struct file * filp)
                 local_irq_save(flags);
 #if defined(CONFIG_MVME147_SCC) || defined(CONFIG_MVME162_SCC)
                 if (MACH_IS_MVME147 || MACH_IS_MVME16x) {
-                        for (i=0; i<sizeof(mvme_init_tab)/sizeof(*mvme_init_tab); ++i)
+                        for (i = 0; i < ARRAY_SIZE(mvme_init_tab); ++i)
                                 SCCwrite(mvme_init_tab[i].reg, mvme_init_tab[i].val);
                 }
 #endif
 #if defined(CONFIG_BVME6000_SCC)
                 if (MACH_IS_BVME6000) {
-                        for (i=0; i<sizeof(bvme_init_tab)/sizeof(*bvme_init_tab); ++i)
+                        for (i = 0; i < ARRAY_SIZE(bvme_init_tab); ++i)
                                 SCCwrite(bvme_init_tab[i].reg, bvme_init_tab[i].val);
                 }
 #endif
diff --git a/drivers/char/vr41xx_rtc.c b/drivers/char/vr41xx_rtc.c
index 435b30748e23..159acd8b7788 100644
--- a/drivers/char/vr41xx_rtc.c
+++ b/drivers/char/vr41xx_rtc.c
@@ -127,8 +127,6 @@ struct resource rtc_resource[2] = {
                 .flags  = IORESOURCE_MEM,       },
 };
 
-#define RTC_NUM_RESOURCES       sizeof(rtc_resource) / sizeof(struct resource)
-
 static inline unsigned long read_elapsed_second(void)
 {
         unsigned long first_low, first_mid, first_high;
@@ -686,7 +684,8 @@ static int __devinit vr41xx_rtc_init(void)
                 break;
         }
 
-        rtc_platform_device = platform_device_register_simple("RTC", -1, rtc_resource, RTC_NUM_RESOURCES);
+        rtc_platform_device = platform_device_register_simple("RTC", -1,
+                              rtc_resource, ARRAY_SIZE(rtc_resource));
         if (IS_ERR(rtc_platform_device))
                 return PTR_ERR(rtc_platform_device);
 
diff --git a/drivers/char/vt.c b/drivers/char/vt.c
index e91268e86833..f1d9cb7feae6 100644
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
@@ -2758,29 +2758,6 @@ static void set_vesa_blanking(char __user *p)
     vesa_blank_mode = (mode < 4) ? mode : 0;
 }
 
-/*
- * This is called by a timer handler
- */
-static void vesa_powerdown(void)
-{
-    struct vc_data *c = vc_cons[fg_console].d;
-    /*
-     *  Power down if currently suspended (1 or 2),
-     *  suspend if currently blanked (0),
-     *  else do nothing (i.e. already powered down (3)).
-     *  Called only if powerdown features are allowed.
-     */
-    switch (vesa_blank_mode) {
-    case VESA_NO_BLANKING:
-            c->vc_sw->con_blank(c, VESA_VSYNC_SUSPEND+1, 0);
-            break;
-    case VESA_VSYNC_SUSPEND:
-    case VESA_HSYNC_SUSPEND:
-            c->vc_sw->con_blank(c, VESA_POWERDOWN+1, 0);
-            break;
-    }
-}
-
 void do_blank_screen(int entering_gfx)
 {
         struct vc_data *vc = vc_cons[fg_console].d;
@@ -2791,8 +2768,7 @@ void do_blank_screen(int entering_gfx)
         if (console_blanked) {
                 if (blank_state == blank_vesa_wait) {
                         blank_state = blank_off;
-                        vesa_powerdown();
-
+                        vc->vc_sw->con_blank(vc, vesa_blank_mode + 1, 0);
                 }
                 return;
         }
@@ -2822,7 +2798,7 @@ void do_blank_screen(int entering_gfx)
 
         save_screen(vc);
         /* In case we need to reset origin, blanking hook returns 1 */
-        i = vc->vc_sw->con_blank(vc, 1, 0);
+        i = vc->vc_sw->con_blank(vc, vesa_off_interval ? 1 : (vesa_blank_mode + 1), 0);
         console_blanked = fg_console + 1;
         if (i)
                 set_origin(vc);
@@ -2830,13 +2806,10 @@ void do_blank_screen(int entering_gfx)
         if (console_blank_hook && console_blank_hook(1))
                 return;
 
-        if (vesa_off_interval) {
+        if (vesa_off_interval && vesa_blank_mode) {
                 blank_state = blank_vesa_wait;
                 mod_timer(&console_timer, jiffies + vesa_off_interval);
         }
-
-        if (vesa_blank_mode)
-                vc->vc_sw->con_blank(vc, vesa_blank_mode + 1, 0);
 }
 EXPORT_SYMBOL(do_blank_screen);
 
diff --git a/drivers/connector/cn_proc.c b/drivers/connector/cn_proc.c
index 385e52930c02..4b4d7db1ff7b 100644
--- a/drivers/connector/cn_proc.c
+++ b/drivers/connector/cn_proc.c
@@ -24,6 +24,7 @@
 
 #include <linux/module.h>
 #include <linux/kernel.h>
+#include <linux/ktime.h>
 #include <linux/init.h>
 #include <asm/atomic.h>
 
@@ -56,7 +57,7 @@ void proc_fork_connector(struct task_struct *task)
         msg = (struct cn_msg*)buffer;
         ev = (struct proc_event*)msg->data;
         get_seq(&msg->seq, &ev->cpu);
-        getnstimestamp(&ev->timestamp);
+        ktime_get_ts(&ev->timestamp); /* get high res monotonic timestamp */
         ev->what = PROC_EVENT_FORK;
         ev->event_data.fork.parent_pid = task->real_parent->pid;
         ev->event_data.fork.parent_tgid = task->real_parent->tgid;
@@ -82,7 +83,7 @@ void proc_exec_connector(struct task_struct *task)
         msg = (struct cn_msg*)buffer;
         ev = (struct proc_event*)msg->data;
         get_seq(&msg->seq, &ev->cpu);
-        getnstimestamp(&ev->timestamp);
+        ktime_get_ts(&ev->timestamp);
         ev->what = PROC_EVENT_EXEC;
         ev->event_data.exec.process_pid = task->pid;
         ev->event_data.exec.process_tgid = task->tgid;
@@ -116,7 +117,7 @@ void proc_id_connector(struct task_struct *task, int which_id)
         } else
                 return;
         get_seq(&msg->seq, &ev->cpu);
-        getnstimestamp(&ev->timestamp);
+        ktime_get_ts(&ev->timestamp);
 
         memcpy(&msg->id, &cn_proc_event_id, sizeof(msg->id));
         msg->ack = 0; /* not used */
@@ -136,7 +137,7 @@ void proc_exit_connector(struct task_struct *task)
         msg = (struct cn_msg*)buffer;
         ev = (struct proc_event*)msg->data;
         get_seq(&msg->seq, &ev->cpu);
-        getnstimestamp(&ev->timestamp);
+        ktime_get_ts(&ev->timestamp);
         ev->what = PROC_EVENT_EXIT;
         ev->event_data.exit.process_pid = task->pid;
         ev->event_data.exit.process_tgid = task->tgid;
@@ -169,7 +170,7 @@ static void cn_proc_ack(int err, int rcvd_seq, int rcvd_ack)
         msg = (struct cn_msg*)buffer;
         ev = (struct proc_event*)msg->data;
         msg->seq = rcvd_seq;
-        getnstimestamp(&ev->timestamp);
+        ktime_get_ts(&ev->timestamp);
         ev->cpu = -1;
         ev->what = PROC_EVENT_NONE;
         ev->event_data.ack.err = err;
diff --git a/drivers/ide/pci/pdc202xx_new.c b/drivers/ide/pci/pdc202xx_new.c
index 211641a54398..fe06ebb0e5bf 100644
--- a/drivers/ide/pci/pdc202xx_new.c
+++ b/drivers/ide/pci/pdc202xx_new.c
@@ -39,7 +39,7 @@
 
 #define PDC202_DEBUG_CABLE      0
 
-const static char *pdc_quirk_drives[] = {
+static const char *pdc_quirk_drives[] = {
         "QUANTUM FIREBALLlct08 08",
         "QUANTUM FIREBALLP KA6.4",
         "QUANTUM FIREBALLP KA9.1",
diff --git a/drivers/ieee1394/amdtp.c b/drivers/ieee1394/amdtp.c
index 75897509c401..17390d762cf7 100644
--- a/drivers/ieee1394/amdtp.c
+++ b/drivers/ieee1394/amdtp.c
@@ -80,7 +80,6 @@
 #include <linux/pci.h>
 #include <linux/interrupt.h>
 #include <linux/poll.h>
-#include <linux/ioctl32.h>
 #include <linux/compat.h>
 #include <linux/cdev.h>
 #include <asm/uaccess.h>
diff --git a/drivers/ieee1394/dv1394.c b/drivers/ieee1394/dv1394.c
index 196db7439272..efeaa944bd0a 100644
--- a/drivers/ieee1394/dv1394.c
+++ b/drivers/ieee1394/dv1394.c
@@ -108,7 +108,6 @@
 #include <linux/types.h>
 #include <linux/vmalloc.h>
 #include <linux/string.h>
-#include <linux/ioctl32.h>
 #include <linux/compat.h>
 #include <linux/cdev.h>
 
diff --git a/drivers/ieee1394/video1394.c b/drivers/ieee1394/video1394.c
index 608479b2df14..39fb88309e8e 100644
--- a/drivers/ieee1394/video1394.c
+++ b/drivers/ieee1394/video1394.c
@@ -48,7 +48,6 @@
 #include <linux/vmalloc.h>
 #include <linux/timex.h>
 #include <linux/mm.h>
-#include <linux/ioctl32.h>
 #include <linux/compat.h>
 #include <linux/cdev.h>
 
diff --git a/drivers/input/serio/serport.c b/drivers/input/serio/serport.c
index 1bd88fca0542..54a680cc704d 100644
--- a/drivers/input/serio/serport.c
+++ b/drivers/input/serio/serport.c
@@ -96,6 +96,7 @@ static int serport_ldisc_open(struct tty_struct *tty)
         init_waitqueue_head(&serport->wait);
 
         tty->disc_data = serport;
+        tty->receive_room = 256;
         set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 
         return 0;
@@ -140,17 +141,6 @@ out:
 }
 
 /*
- * serport_ldisc_room() reports how much room we do have for receiving data.
- * Although we in fact have infinite room, we need to specify some value
- * here, and 256 seems to be reasonable.
- */
-
-static int serport_ldisc_room(struct tty_struct *tty)
-{
-        return 256;
-}
-
-/*
  * serport_ldisc_read() just waits indefinitely if everything goes well.
  * However, when the serio driver closes the serio port, it finishes,
  * returning 0 characters.
@@ -237,7 +227,6 @@ static struct tty_ldisc serport_ldisc = {
         .read =         serport_ldisc_read,
         .ioctl =        serport_ldisc_ioctl,
         .receive_buf =  serport_ldisc_receive,
-        .receive_room = serport_ldisc_room,
         .write_wakeup = serport_ldisc_write_wakeup
 };
 
diff --git a/drivers/isdn/capi/capi.c b/drivers/isdn/capi/capi.c
index 11ae0fddea04..623adbb0d13a 100644
--- a/drivers/isdn/capi/capi.c
+++ b/drivers/isdn/capi/capi.c
@@ -463,8 +463,7 @@ static int handle_recv_skb(struct capiminor *mp, struct sk_buff *skb)
 #endif
                 goto bad;
         }
-        if (ld->receive_room &&
-            ld->receive_room(mp->tty) < datalen) {
+        if (mp->tty->receive_room < datalen) {
 #if defined(_DEBUG_DATAFLOW) || defined(_DEBUG_TTYFUNCS)
                 printk(KERN_DEBUG "capi: no room in tty\n");
 #endif
diff --git a/drivers/isdn/i4l/isdn_common.c b/drivers/isdn/i4l/isdn_common.c
index 4643df097bfe..22759c01746a 100644
--- a/drivers/isdn/i4l/isdn_common.c
+++ b/drivers/isdn/i4l/isdn_common.c
@@ -857,6 +857,118 @@ isdn_readbchan(int di, int channel, u_char * buf, u_char * fp, int len, wait_que
         return count;
 }
 
+/*
+ * isdn_readbchan_tty() tries to get data from the read-queue.
+ * It MUST be called with interrupts off.
+ *
+ * Be aware that this is not an atomic operation when sleep != 0, even though
+ * interrupts are turned off! Well, like that we are currently only called
+ * on behalf of a read system call on raw device files (which are documented
+ * to be dangerous and for for debugging purpose only). The inode semaphore
+ * takes care that this is not called for the same minor device number while
+ * we are sleeping, but access is not serialized against simultaneous read()
+ * from the corresponding ttyI device. Can other ugly events, like changes
+ * of the mapping (di,ch)<->minor, happen during the sleep? --he
+ */
+int
+isdn_readbchan_tty(int di, int channel, struct tty_struct *tty, int cisco_hack)
+{
+        int count;
+        int count_pull;
+        int count_put;
+        int dflag;
+        struct sk_buff *skb;
+        char last = 0;
+        int len;
+
+        if (!dev->drv[di])
+                return 0;
+        if (skb_queue_empty(&dev->drv[di]->rpqueue[channel]))
+                        return 0;
+
+        len = tty_buffer_request_room(tty, dev->drv[di]->rcvcount[channel]);
+        if(len == 0)
+                return len;
+
+        count = 0;
+        while (len) {
+                if (!(skb = skb_peek(&dev->drv[di]->rpqueue[channel])))
+                        break;
+#ifdef CONFIG_ISDN_AUDIO
+                if (ISDN_AUDIO_SKB_LOCK(skb))
+                        break;
+                ISDN_AUDIO_SKB_LOCK(skb) = 1;
+                if ((ISDN_AUDIO_SKB_DLECOUNT(skb)) || (dev->drv[di]->DLEflag & (1 << channel))) {
+                        char *p = skb->data;
+                        unsigned long DLEmask = (1 << channel);
+
+                        dflag = 0;
+                        count_pull = count_put = 0;
+                        while ((count_pull < skb->len) && (len > 0)) {
+                                len--;
+                                if (dev->drv[di]->DLEflag & DLEmask) {
+                                        last = DLE;
+                                        dev->drv[di]->DLEflag &= ~DLEmask;
+                                } else {
+                                        last = *p;
+                                        if (last == DLE) {
+                                                dev->drv[di]->DLEflag |= DLEmask;
+                                                (ISDN_AUDIO_SKB_DLECOUNT(skb))--;
+                                        }
+                                        p++;
+                                        count_pull++;
+                                }
+                                count_put++;
+                        }
+                        if (count_pull >= skb->len)
+                                dflag = 1;
+                } else {
+#endif
+                        /* No DLE's in buff, so simply copy it */
+                        dflag = 1;
+                        if ((count_pull = skb->len) > len) {
+                                count_pull = len;
+                                dflag = 0;
+                        }
+                        count_put = count_pull;
+                        if(count_put > 1)
+                                tty_insert_flip_string(tty, skb->data, count_put - 1);
+                        last = skb->data[count_put] - 1;
+                        len -= count_put;
+#ifdef CONFIG_ISDN_AUDIO
+                }
+#endif
+                count += count_put;
+                if (dflag) {
+                        /* We got all the data in this buff.
+                         * Now we can dequeue it.
+                         */
+                        if(cisco_hack)
+                                tty_insert_flip_char(tty, last, 0xFF);
+                        else
+                                tty_insert_flip_char(tty, last, TTY_NORMAL);
+#ifdef CONFIG_ISDN_AUDIO
+                        ISDN_AUDIO_SKB_LOCK(skb) = 0;
+#endif
+                        skb = skb_dequeue(&dev->drv[di]->rpqueue[channel]);
+                        dev_kfree_skb(skb);
+                } else {
+                        tty_insert_flip_char(tty, last, TTY_NORMAL);
+                        /* Not yet emptied this buff, so it
+                         * must stay in the queue, for further calls
+                         * but we pull off the data we got until now.
+                         */
+                        skb_pull(skb, count_pull);
+#ifdef CONFIG_ISDN_AUDIO
+                        ISDN_AUDIO_SKB_LOCK(skb) = 0;
+#endif
+                }
+                dev->drv[di]->rcvcount[channel] -= count_put;
+        }
+        return count;
+}
+
+
 static __inline int
 isdn_minor2drv(int minor)
 {
diff --git a/drivers/isdn/i4l/isdn_common.h b/drivers/isdn/i4l/isdn_common.h
index e27e9c3a81ed..082735dbb412 100644
--- a/drivers/isdn/i4l/isdn_common.h
+++ b/drivers/isdn/i4l/isdn_common.h
@@ -37,6 +37,7 @@ extern void isdn_timer_ctrl(int tf, int onoff);
 extern void isdn_unexclusive_channel(int di, int ch);
 extern int  isdn_getnum(char **);
 extern int  isdn_readbchan(int, int, u_char *, u_char *, int, wait_queue_head_t *);
+extern int  isdn_readbchan_tty(int, int, struct tty_struct *, int);
 extern int  isdn_get_free_channel(int, int, int, int, int, char *);
 extern int  isdn_writebuf_skb_stub(int, int, int, struct sk_buff *);
 extern int  register_isdn(isdn_if * i);
diff --git a/drivers/isdn/i4l/isdn_tty.c b/drivers/isdn/i4l/isdn_tty.c
index 8c404b4e2482..f190a99604f0 100644
--- a/drivers/isdn/i4l/isdn_tty.c
+++ b/drivers/isdn/i4l/isdn_tty.c
@@ -64,37 +64,42 @@ isdn_tty_try_read(modem_info * info, struct sk_buff *skb)
         int c;
         int len;
         struct tty_struct *tty;
+        char last;
 
         if (info->online) {
                 if ((tty = info->tty)) {
                         if (info->mcr & UART_MCR_RTS) {
-                                c = TTY_FLIPBUF_SIZE - tty->flip.count;
                                 len = skb->len
 #ifdef CONFIG_ISDN_AUDIO
                                         + ISDN_AUDIO_SKB_DLECOUNT(skb)
 #endif
                                         ;
+
+                                c = tty_buffer_request_room(tty, len);
                                 if (c >= len) {
 #ifdef CONFIG_ISDN_AUDIO
-                                        if (ISDN_AUDIO_SKB_DLECOUNT(skb))
-                                                while (skb->len--) {
+                                        if (ISDN_AUDIO_SKB_DLECOUNT(skb)) {
+                                                int l = skb->len;
+                                                unsigned char *dp = skb->data;
+                                                while (--l) {
                                                         if (*skb->data == DLE)
                                                                 tty_insert_flip_char(tty, DLE, 0);
-                                                        tty_insert_flip_char(tty, *skb->data++, 0);
+                                                        tty_insert_flip_char(tty, *dp++, 0);
+                                                }
+                                                last = *dp;
                                         } else {
 #endif
-                                                memcpy(tty->flip.char_buf_ptr,
-                                                       skb->data, len);
-                                                tty->flip.count += len;
-                                                tty->flip.char_buf_ptr += len;
-                                                memset(tty->flip.flag_buf_ptr, 0, len);
-                                                tty->flip.flag_buf_ptr += len;
+                                                if(len > 1)
+                                                        tty_insert_flip_string(tty, skb->data, len - 1);
+                                                last = skb->data[len - 1];
 #ifdef CONFIG_ISDN_AUDIO
                                         }
 #endif
                                         if (info->emu.mdmreg[REG_CPPP] & BIT_CPPP)
-                                                tty->flip.flag_buf_ptr[len - 1] = 0xff;
-                                        schedule_delayed_work(&tty->flip.work, 1);
+                                                tty_insert_flip_char(tty, last, 0xFF);
+                                        else
+                                                tty_insert_flip_char(tty, last, TTY_NORMAL);
+                                        tty_flip_buffer_push(tty);
                                         kfree_skb(skb);
                                         return 1;
                                 }
@@ -114,7 +119,6 @@ isdn_tty_readmodem(void)
         int resched = 0;
         int midx;
         int i;
-        int c;
         int r;
         struct tty_struct *tty;
         modem_info *info;
@@ -131,20 +135,13 @@ isdn_tty_readmodem(void)
 #endif
                                 if ((tty = info->tty)) {
                                         if (info->mcr & UART_MCR_RTS) {
-                                                c = TTY_FLIPBUF_SIZE - tty->flip.count;
-                                                if (c > 0) {
-                                                        r = isdn_readbchan(info->isdn_driver, info->isdn_channel,
-                                                                           tty->flip.char_buf_ptr,
-                                                                           tty->flip.flag_buf_ptr, c, NULL);
-                                                        /* CISCO AsyncPPP Hack */
-                                                        if (!(info->emu.mdmreg[REG_CPPP] & BIT_CPPP))
-                                                                memset(tty->flip.flag_buf_ptr, 0, r);
-                                                        tty->flip.count += r;
-                                                        tty->flip.flag_buf_ptr += r;
-                                                        tty->flip.char_buf_ptr += r;
-                                                        if (r)
-                                                                schedule_delayed_work(&tty->flip.work, 1);
-                                                }
+                                                /* CISCO AsyncPPP Hack */
+                                                if (!(info->emu.mdmreg[REG_CPPP] & BIT_CPPP))
+                                                        r = isdn_readbchan_tty(info->isdn_driver, info->isdn_channel, tty, 0);
+                                                else
+                                                        r = isdn_readbchan_tty(info->isdn_driver, info->isdn_channel, tty, 1);
+                                                if (r)
+                                                        tty_flip_buffer_push(tty);
                                         } else
                                                 r = 1;
                                 } else
@@ -249,7 +246,7 @@ isdn_tty_rcv_skb(int i, int di, int channel, struct sk_buff *skb)
         }
 #endif
 #endif
-        /* Try to deliver directly via tty-flip-buf if queue is empty */
+        /* Try to deliver directly via tty-buf if queue is empty */
         spin_lock_irqsave(&info->readlock, flags);
         if (skb_queue_empty(&dev->drv[di]->rpqueue[channel]))
                 if (isdn_tty_try_read(info, skb)) {
@@ -534,7 +531,7 @@ isdn_tty_senddown(modem_info * info)
 /* The next routine is called once from within timer-interrupt
  * triggered within isdn_tty_modem_ncarrier(). It calls
  * isdn_tty_modem_result() to stuff a "NO CARRIER" Message
- * into the tty's flip-buffer.
+ * into the tty's buffer.
  */
 static void
 isdn_tty_modem_do_ncarrier(unsigned long data)
@@ -2347,6 +2344,7 @@ isdn_tty_at_cout(char *msg, modem_info * info)
         u_long flags;
         struct sk_buff *skb = NULL;
         char *sp = NULL;
+        int l = strlen(msg);
 
         if (!msg) {
                 printk(KERN_WARNING "isdn_tty: Null-Message in isdn_tty_at_cout\n");
@@ -2359,16 +2357,16 @@ isdn_tty_at_cout(char *msg, modem_info * info)
                 return;
         }
 
-        /* use queue instead of direct flip, if online and */
-        /* data is in queue or flip buffer is full */
-        if ((info->online) && (((tty->flip.count + strlen(msg)) >= TTY_FLIPBUF_SIZE) ||
-            (!skb_queue_empty(&dev->drv[info->isdn_driver]->rpqueue[info->isdn_channel])))) {
-                skb = alloc_skb(strlen(msg), GFP_ATOMIC);
+        /* use queue instead of direct, if online and */
+        /* data is in queue or buffer is full */
+        if ((info->online && tty_buffer_request_room(tty, l) < l) ||
+            (!skb_queue_empty(&dev->drv[info->isdn_driver]->rpqueue[info->isdn_channel]))) {
+                skb = alloc_skb(l, GFP_ATOMIC);
                 if (!skb) {
                         spin_unlock_irqrestore(&info->readlock, flags);
                         return;
                 }
-                sp = skb_put(skb, strlen(msg));
+                sp = skb_put(skb, l);
 #ifdef CONFIG_ISDN_AUDIO
                 ISDN_AUDIO_SKB_DLECOUNT(skb) = 0;
                 ISDN_AUDIO_SKB_LOCK(skb) = 0;
@@ -2392,9 +2390,8 @@ isdn_tty_at_cout(char *msg, modem_info * info)
                 if (skb) {
                         *sp++ = c;
                 } else {
-                        if (tty->flip.count >= TTY_FLIPBUF_SIZE)
+                        if(tty_insert_flip_char(tty, c, TTY_NORMAL) == 0)
                                 break;
-                        tty_insert_flip_char(tty, c, 0);
                 }
         }
         if (skb) {
@@ -2402,12 +2399,12 @@ isdn_tty_at_cout(char *msg, modem_info * info)
                 dev->drv[info->isdn_driver]->rcvcount[info->isdn_channel] += skb->len;
                 spin_unlock_irqrestore(&info->readlock, flags);
                 /* Schedule dequeuing */
-                if ((dev->modempoll) && (info->rcvsched))
+                if (dev->modempoll && info->rcvsched)
                         isdn_timer_ctrl(ISDN_TIMER_MODEMREAD, 1);
 
         } else {
                 spin_unlock_irqrestore(&info->readlock, flags);
-                schedule_delayed_work(&tty->flip.work, 1);
+                tty_flip_buffer_push(tty);
         }
 }
 
diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c
index e6aa309a66d7..96f7af4ae400 100644
--- a/drivers/md/multipath.c
+++ b/drivers/md/multipath.c
@@ -303,6 +303,7 @@ static void print_multipath_conf (multipath_conf_t *conf)
 static int multipath_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
 {
         multipath_conf_t *conf = mddev->private;
+        struct request_queue *q;
         int found = 0;
         int path;
         struct multipath_info *p;
@@ -311,8 +312,8 @@ static int multipath_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
 
         for (path=0; path<mddev->raid_disks; path++) 
                 if ((p=conf->multipaths+path)->rdev == NULL) {
-                        blk_queue_stack_limits(mddev->queue,
-                                               rdev->bdev->bd_disk->queue);
+                        q = rdev->bdev->bd_disk->queue;
+                        blk_queue_stack_limits(mddev->queue, q);
 
                 /* as we don't honour merge_bvec_fn, we must never risk
                  * violating it, so limit ->max_sector to one PAGE, as
@@ -320,7 +321,7 @@ static int multipath_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
                  * (Note: it is very unlikely that a device with
                  * merge_bvec_fn will be involved in multipath.)
                  */
-                        if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
+                        if (q->merge_bvec_fn &&
                             mddev->queue->max_sectors > (PAGE_SIZE>>9))
                                 blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
 
diff --git a/drivers/media/radio/radio-maestro.c b/drivers/media/radio/radio-maestro.c
index c30effdf711f..36c9f5bf8cdd 100644
--- a/drivers/media/radio/radio-maestro.c
+++ b/drivers/media/radio/radio-maestro.c
@@ -27,34 +27,30 @@
 #include <linux/pci.h>
 #include <linux/videodev.h>
 
-#define DRIVER_VERSION  "0.04"
+#define DRIVER_VERSION  "0.05"
 
-#define PCI_VENDOR_ESS                  0x125D
-#define PCI_DEVICE_ID_ESS_ESS1968       0x1968          /* Maestro 2    */
-#define PCI_DEVICE_ID_ESS_ESS1978       0x1978          /* Maestro 2E   */
-
-#define GPIO_DATA       0x60   /* port offset from ESS_IO_BASE */
+#define GPIO_DATA       0x60   /* port offset from ESS_IO_BASE */
 
 #define IO_MASK         4      /* mask      register offset from GPIO_DATA
                                 bits 1=unmask write to given bit */
 #define IO_DIR          8      /* direction register offset from GPIO_DATA
                                 bits 0/1=read/write direction */
 
-#define GPIO6           0x0040 /* mask bits for GPIO lines */
-#define GPIO7           0x0080
-#define GPIO8           0x0100
-#define GPIO9           0x0200
+#define GPIO6           0x0040 /* mask bits for GPIO lines */
+#define GPIO7           0x0080
+#define GPIO8           0x0100
+#define GPIO9           0x0200
 
-#define STR_DATA        GPIO6  /* radio TEA5757 pins and GPIO bits */
-#define STR_CLK         GPIO7
-#define STR_WREN        GPIO8
-#define STR_MOST        GPIO9
+#define STR_DATA        GPIO6  /* radio TEA5757 pins and GPIO bits */
+#define STR_CLK         GPIO7
+#define STR_WREN        GPIO8
+#define STR_MOST        GPIO9
 
 #define FREQ_LO          50*16000
 #define FREQ_HI         150*16000
 
-#define FREQ_IF         171200 /* 10.7*16000   */
-#define FREQ_STEP       200    /* 12.5*16      */
+#define FREQ_IF         171200 /* 10.7*16000   */
+#define FREQ_STEP       200    /* 12.5*16      */
 
 #define FREQ2BITS(x)    ((((unsigned int)(x)+FREQ_IF+(FREQ_STEP<<1))\
                         /(FREQ_STEP<<2))<<2) /* (x==fmhz*16*1000) -> bits */
@@ -65,7 +61,27 @@ static int radio_nr = -1;
 module_param(radio_nr, int, 0);
 
 static int radio_ioctl(struct inode *inode, struct file *file,
-                       unsigned int cmd, unsigned long arg);
+        unsigned int cmd, unsigned long arg);
+static int maestro_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
+static void maestro_remove(struct pci_dev *pdev);
+
+static struct pci_device_id maestro_r_pci_tbl[] = {
+        { PCI_DEVICE(PCI_VENDOR_ID_ESS, PCI_DEVICE_ID_ESS_ESS1968),
+                .class = PCI_CLASS_MULTIMEDIA_AUDIO << 8,
+                .class_mask = 0xffff00 },
+        { PCI_DEVICE(PCI_VENDOR_ID_ESS, PCI_DEVICE_ID_ESS_ESS1978),
+                .class = PCI_CLASS_MULTIMEDIA_AUDIO << 8,
+                .class_mask = 0xffff00 },
+        { 0 }
+};
+MODULE_DEVICE_TABLE(pci, maestro_r_pci_tbl);
+
+static struct pci_driver maestro_r_driver = {
+        .name           = "maestro_radio",
+        .id_table       = maestro_r_pci_tbl,
+        .probe          = maestro_probe,
+        .remove         = __devexit_p(maestro_remove),
+};
 
 static struct file_operations maestro_fops = {
         .owner          = THIS_MODULE,
@@ -76,29 +92,27 @@ static struct file_operations maestro_fops = {
         .llseek         = no_llseek,
 };
 
-static struct video_device maestro_radio=
-{
-        .owner          = THIS_MODULE,
+static struct video_device maestro_radio = {
         .name           = "Maestro radio",
         .type           = VID_TYPE_TUNER,
         .hardware       = VID_HARDWARE_SF16MI,
-        .fops           = &maestro_fops,
+        .fops           = &maestro_fops,
 };
 
-static struct radio_device
-{
-        __u16   io,     /* base of Maestro card radio io (GPIO_DATA)*/
+struct radio_device {
+        u16     io,     /* base of Maestro card radio io (GPIO_DATA)*/
                 muted,  /* VIDEO_AUDIO_MUTE */
                 stereo, /* VIDEO_TUNER_STEREO_ON */     
                 tuned;  /* signal strength (0 or 0xffff) */
-        struct  semaphore lock;
-} radio_unit = {0, 0, 0, 0, };
+        struct  semaphore lock;
+};
 
-static __u32 radio_bits_get(struct radio_device *dev)
+static u32 radio_bits_get(struct radio_device *dev)
 {
-        register __u16 io=dev->io, l, rdata;
-        register __u32 data=0;
-        __u16 omask;
+        register u16 io=dev->io, l, rdata;
+        register u32 data=0;
+        u16 omask;
+
         omask = inw(io + IO_MASK);
         outw(~(STR_CLK | STR_WREN), io + IO_MASK);
         outw(0, io);
@@ -121,17 +135,21 @@ static __u32 radio_bits_get(struct radio_device *dev)
                                 data++;
                 udelay(2);
         }
+
         if(dev->muted)
                 outw(STR_WREN, io);
+
         udelay(4);
         outw(omask, io + IO_MASK);
+
         return data & 0x3ffe;
 }
 
-static void radio_bits_set(struct radio_device *dev, __u32 data)
+static void radio_bits_set(struct radio_device *dev, u32 data)
 {
-        register __u16 io=dev->io, l, bits;
-        __u16 omask, odir;
+        register u16 io=dev->io, l, bits;
+        u16 omask, odir;
+
         omask = inw(io + IO_MASK);
         odir  = (inw(io + IO_DIR) & ~STR_DATA) | (STR_CLK | STR_WREN);
         outw(odir | STR_DATA, io + IO_DIR);
@@ -147,8 +165,10 @@ static void radio_bits_set(struct radio_device *dev, __u32 data)
                 outw(bits, io);                 /* LO level */
                 udelay(4);
         }
+
         if(!dev->muted)
                 outw(0, io);
+
         udelay(4);
         outw(omask, io + IO_MASK);
         outw(odir, io + IO_DIR);
@@ -156,141 +176,103 @@ static void radio_bits_set(struct radio_device *dev, __u32 data)
 }
 
 static inline int radio_function(struct inode *inode, struct file *file,
-                                 unsigned int cmd, void *arg)
+        unsigned int cmd, void *arg)
 {
         struct video_device *dev = video_devdata(file);
-        struct radio_device *card=dev->priv;
-        
-        switch(cmd) {
-                case VIDIOCGCAP: {
-                        struct video_capability *v = arg;
-                        memset(v,0,sizeof(*v));
-                        strcpy(v->name, "Maestro radio");
-                        v->type=VID_TYPE_TUNER;
-                        v->channels=v->audios=1;
-                        return 0;
-                }
-                case VIDIOCGTUNER: {
-                        struct video_tuner *v = arg;
-                        if(v->tuner)
-                                return -EINVAL;
-                        (void)radio_bits_get(card);
-                        v->flags = VIDEO_TUNER_LOW | card->stereo;
-                        v->signal = card->tuned;
-                        strcpy(v->name, "FM");
-                        v->rangelow = FREQ_LO;
-                        v->rangehigh = FREQ_HI;
-                        v->mode = VIDEO_MODE_AUTO;
-                        return 0;
-                }
-                case VIDIOCSTUNER: {
-                        struct video_tuner *v = arg;
-                        if(v->tuner!=0)
-                                return -EINVAL;
-                        return 0;
-                }
-                case VIDIOCGFREQ: {
-                        unsigned long *freq = arg;
-                        *freq = BITS2FREQ(radio_bits_get(card));
-                        return 0;
-                }
-                case VIDIOCSFREQ: {
-                        unsigned long *freq = arg;
-                        if (*freq<FREQ_LO || *freq>FREQ_HI )
-                                return -EINVAL;
-                        radio_bits_set(card, FREQ2BITS(*freq));
+        struct radio_device *card = video_get_drvdata(dev);
+
+        switch (cmd) {
+        case VIDIOCGCAP: {
+                struct video_capability *v = arg;
+                memset(v, 0, sizeof(*v));
+                strcpy(v->name, "Maestro radio");
+                v->type = VID_TYPE_TUNER;
+                v->channels = v->audios = 1;
+                return 0;
+        } case VIDIOCGTUNER: {
+                struct video_tuner *v = arg;
+                if (v->tuner)
+                        return -EINVAL;
+                (void)radio_bits_get(card);
+                v->flags = VIDEO_TUNER_LOW | card->stereo;
+                v->signal = card->tuned;
+                strcpy(v->name, "FM");
+                v->rangelow = FREQ_LO;
+                v->rangehigh = FREQ_HI;
+                v->mode = VIDEO_MODE_AUTO;
+                return 0;
+        } case VIDIOCSTUNER: {
+                struct video_tuner *v = arg;
+                if (v->tuner != 0)
+                        return -EINVAL;
+                return 0;
+        } case VIDIOCGFREQ: {
+                unsigned long *freq = arg;
+                *freq = BITS2FREQ(radio_bits_get(card));
+                return 0;
+        } case VIDIOCSFREQ: {
+                unsigned long *freq = arg;
+                if (*freq < FREQ_LO || *freq > FREQ_HI)
+                        return -EINVAL;
+                radio_bits_set(card, FREQ2BITS(*freq));
+                return 0;
+        } case VIDIOCGAUDIO: {
+                struct video_audio *v = arg;
+                memset(v, 0, sizeof(*v));
+                strcpy(v->name, "Radio");
+                v->flags = VIDEO_AUDIO_MUTABLE | card->muted;
+                v->mode = VIDEO_SOUND_STEREO;
+                return 0;
+        } case VIDIOCSAUDIO: {
+                struct video_audio *v = arg;
+                if (v->audio)
+                        return -EINVAL;
+                {
+                        register u16 io = card->io;
+                        register u16 omask = inw(io + IO_MASK);
+                        outw(~STR_WREN, io + IO_MASK);
+                        outw((card->muted = v->flags & VIDEO_AUDIO_MUTE) ?
+                                STR_WREN : 0, io);
+                        udelay(4);
+                        outw(omask, io + IO_MASK);
+                        msleep(125);
                         return 0;
                 }
-                case VIDIOCGAUDIO: {    
-                        struct video_audio *v = arg;
-                        memset(v,0,sizeof(*v));
-                        strcpy(v->name, "Radio");
-                        v->flags=VIDEO_AUDIO_MUTABLE | card->muted;
-                        v->mode=VIDEO_SOUND_STEREO;
-                        return 0;               
-                }
-                case VIDIOCSAUDIO: {
-                        struct video_audio *v = arg;
-                        if(v->audio)
-                                return -EINVAL;
-                        {
-                                register __u16 io=card->io;
-                                register __u16 omask = inw(io + IO_MASK);
-                                outw(~STR_WREN, io + IO_MASK);
-                                outw((card->muted = v->flags & VIDEO_AUDIO_MUTE)
-                                     ? STR_WREN : 0, io);
-                                udelay(4);
-                                outw(omask, io + IO_MASK);
-                                msleep(125);
-                                return 0;
-                        }
-                }
-                case VIDIOCGUNIT: {
-                        struct video_unit *v = arg;
-                        v->video=VIDEO_NO_UNIT;
-                        v->vbi=VIDEO_NO_UNIT;
-                        v->radio=dev->minor;
-                        v->audio=0;
-                        v->teletext=VIDEO_NO_UNIT;
-                        return 0;               
-                }
-                default: return -ENOIOCTLCMD;
+        } case VIDIOCGUNIT: {
+                struct video_unit *v = arg;
+                v->video = VIDEO_NO_UNIT;
+                v->vbi = VIDEO_NO_UNIT;
+                v->radio = dev->minor;
+                v->audio = 0;
+                v->teletext = VIDEO_NO_UNIT;
+                return 0;
+        } default:
+                return -ENOIOCTLCMD;
         }
 }
 
 static int radio_ioctl(struct inode *inode, struct file *file,
-                       unsigned int cmd, unsigned long arg)
+        unsigned int cmd, unsigned long arg)
 {
         struct video_device *dev = video_devdata(file);
-        struct radio_device *card=dev->priv;
+        struct radio_device *card = video_get_drvdata(dev);
         int ret;
 
         down(&card->lock);
         ret = video_usercopy(inode, file, cmd, arg, radio_function);
         up(&card->lock);
-        return ret;
-}
 
-static __u16 radio_install(struct pci_dev *pcidev);
-
-MODULE_AUTHOR("Adam Tlalka, atlka@pg.gda.pl");
-MODULE_DESCRIPTION("Radio driver for the Maestro PCI sound card radio.");
-MODULE_LICENSE("GPL");
-
-static void __exit maestro_radio_exit(void)
-{
-        video_unregister_device(&maestro_radio);
+        return ret;
 }
 
-static int __init maestro_radio_init(void)
+static u16 __devinit radio_power_on(struct radio_device *dev)
 {
-        register __u16 found=0;
-        struct pci_dev *pcidev = NULL;
-        while(!found && (pcidev = pci_find_device(PCI_VENDOR_ESS, 
-                                                  PCI_DEVICE_ID_ESS_ESS1968,
-                                                  pcidev)))
-                found |= radio_install(pcidev);
-        while(!found && (pcidev = pci_find_device(PCI_VENDOR_ESS,
-                                                  PCI_DEVICE_ID_ESS_ESS1978, 
-                                                  pcidev)))
-                found |= radio_install(pcidev);
-        if(!found) {
-                printk(KERN_INFO "radio-maestro: no devices found.\n");
-                return -ENODEV;
-        }
-        return 0;
-}
+        register u16 io = dev->io;
+        register u32 ofreq;
+        u16 omask, odir;
 
-module_init(maestro_radio_init);
-module_exit(maestro_radio_exit);
-
-static inline __u16 radio_power_on(struct radio_device *dev)
-{
-        register __u16 io=dev->io;
-        register __u32 ofreq;
-        __u16 omask, odir;
         omask = inw(io + IO_MASK);
-        odir  = (inw(io + IO_DIR) & ~STR_DATA) | (STR_CLK | STR_WREN);
+        odir = (inw(io + IO_DIR) & ~STR_DATA) | (STR_CLK | STR_WREN);
         outw(odir & ~STR_WREN, io + IO_DIR);
         dev->muted = inw(io) & STR_WREN ? 0 : VIDEO_AUDIO_MUTE;
         outw(odir, io + IO_DIR);
@@ -299,35 +281,101 @@ static inline __u16 radio_power_on(struct radio_device *dev)
         udelay(16);
         outw(omask, io + IO_MASK);
         ofreq = radio_bits_get(dev);
-        if((ofreq<FREQ2BITS(FREQ_LO)) || (ofreq>FREQ2BITS(FREQ_HI)))
+
+        if ((ofreq < FREQ2BITS(FREQ_LO)) || (ofreq > FREQ2BITS(FREQ_HI)))
                 ofreq = FREQ2BITS(FREQ_LO);
         radio_bits_set(dev, ofreq);
+
         return (ofreq == radio_bits_get(dev));
 }
 
-static __u16 radio_install(struct pci_dev *pcidev)
+static int __devinit maestro_probe(struct pci_dev *pdev,
+        const struct pci_device_id *ent)
 {
-        if(((pcidev->class >> 8) & 0xffff) != PCI_CLASS_MULTIMEDIA_AUDIO)
-                return 0;
-        
-        radio_unit.io = pcidev->resource[0].start + GPIO_DATA;
-        maestro_radio.priv = &radio_unit;
-        init_MUTEX(&radio_unit.lock);
-        
-        if(radio_power_on(&radio_unit)) {
-                if(video_register_device(&maestro_radio, VFL_TYPE_RADIO, radio_nr)==-1) {
-                        printk("radio-maestro: can't register device!");
-                        return 0;
-                }
-                printk(KERN_INFO "radio-maestro: version "
-                       DRIVER_VERSION 
-                       " time " 
-                       __TIME__ "  "
-                       __DATE__
-                       "\n");
-                printk(KERN_INFO "radio-maestro: radio chip initialized\n");
-                return 1;
-        } else
-                return 0;   
+        struct radio_device *radio_unit;
+        struct video_device *maestro_radio_inst;
+        int retval;
+
+        retval = pci_enable_device(pdev);
+        if (retval) {
+                dev_err(&pdev->dev, "enabling pci device failed!\n");
+                goto err;
+        }
+
+        retval = -ENOMEM;
+
+        radio_unit = kzalloc(sizeof(*radio_unit), GFP_KERNEL);
+        if (radio_unit == NULL) {
+                dev_err(&pdev->dev, "not enough memory\n");
+                goto err;
+        }
+
+        radio_unit->io = pci_resource_start(pdev, 0) + GPIO_DATA;
+        init_MUTEX(&radio_unit->lock);
+
+        maestro_radio_inst = video_device_alloc();
+        if (maestro_radio_inst == NULL) {
+                dev_err(&pdev->dev, "not enough memory\n");
+                goto errfr;
+        }
+
+        memcpy(maestro_radio_inst, &maestro_radio, sizeof(maestro_radio));
+        video_set_drvdata(maestro_radio_inst, radio_unit);
+        pci_set_drvdata(pdev, maestro_radio_inst);
+
+        retval = video_register_device(maestro_radio_inst, VFL_TYPE_RADIO,
+                radio_nr);
+        if (retval) {
+                printk(KERN_ERR "can't register video device!\n");
+                goto errfr1;
+        }
+
+        if (!radio_power_on(radio_unit)) {
+                retval = -EIO;
+                goto errunr;
+        }
+
+        dev_info(&pdev->dev, "version " DRIVER_VERSION " time " __TIME__ "  "
+                 __DATE__ "\n");
+        dev_info(&pdev->dev, "radio chip initialized\n");
+
+        return 0;
+errunr:
+        video_unregister_device(maestro_radio_inst);
+errfr1:
+        kfree(maestro_radio_inst);
+errfr:
+        kfree(radio_unit);
+err:
+        return retval;
+
+}
+
+static void __devexit maestro_remove(struct pci_dev *pdev)
+{
+        struct video_device *vdev = pci_get_drvdata(pdev);
+
+        video_unregister_device(vdev);
 }
 
+static int __init maestro_radio_init(void)
+{
+        int retval = pci_register_driver(&maestro_r_driver);
+
+        if (retval)
+                printk(KERN_ERR "error during registration pci driver\n");
+
+        return retval;
+}
+
+static void __exit maestro_radio_exit(void)
+{
+        pci_unregister_driver(&maestro_r_driver);
+}
+
+module_init(maestro_radio_init);
+module_exit(maestro_radio_exit);
+
+MODULE_AUTHOR("Adam Tlalka, atlka@pg.gda.pl");
+MODULE_DESCRIPTION("Radio driver for the Maestro PCI sound card radio.");
+MODULE_LICENSE("GPL");
diff --git a/drivers/message/fusion/mptctl.c b/drivers/message/fusion/mptctl.c
index 959d2c5951b8..7c340240a50e 100644
--- a/drivers/message/fusion/mptctl.c
+++ b/drivers/message/fusion/mptctl.c
@@ -2585,8 +2585,6 @@ static struct miscdevice mptctl_miscdev = {
 
 #ifdef CONFIG_COMPAT
 
-#include <linux/ioctl32.h>
-
 static int
 compat_mptfwxfer_ioctl(struct file *filp, unsigned int cmd,
                         unsigned long arg)
diff --git a/drivers/mtd/nand/au1550nd.c b/drivers/mtd/nand/au1550nd.c
index 9c5945d6df88..201e1362da14 100644
--- a/drivers/mtd/nand/au1550nd.c
+++ b/drivers/mtd/nand/au1550nd.c
@@ -43,7 +43,7 @@ static int nand_width = 1; /* default x8*/
 /*
  * Define partitions for flash device
  */
-const static struct mtd_partition partition_info[] = {
+static const struct mtd_partition partition_info[] = {
         {
                 .name   = "NAND FS 0",
                 .offset = 0,
diff --git a/drivers/mtd/nand/rtc_from4.c b/drivers/mtd/nand/rtc_from4.c
index 3a5841c9d950..4129c03dfd90 100644
--- a/drivers/mtd/nand/rtc_from4.c
+++ b/drivers/mtd/nand/rtc_from4.c
@@ -96,7 +96,7 @@ static struct mtd_info *rtc_from4_mtd = NULL;
  */
 static void __iomem *rtc_from4_fio_base = (void *)P2SEGADDR(RTC_FROM4_FIO_BASE);
 
-const static struct mtd_partition partition_info[] = {
+static const struct mtd_partition partition_info[] = {
         {
                 .name   = "Renesas flash partition 1",
                 .offset = 0,
diff --git a/drivers/mtd/nand/spia.c b/drivers/mtd/nand/spia.c
index 32541cbb0103..9cf1ce718ec1 100644
--- a/drivers/mtd/nand/spia.c
+++ b/drivers/mtd/nand/spia.c
@@ -67,7 +67,7 @@ module_param(spia_peddr, int, 0);
 /*
  * Define partitions for flash device
  */
-const static struct mtd_partition partition_info[] = {
+static const struct mtd_partition partition_info[] = {
         {
                 .name   = "SPIA flash partition 1",
                 .offset = 0,
diff --git a/drivers/net/8139too.c b/drivers/net/8139too.c
index d2102a27d307..adfba44dac5a 100644
--- a/drivers/net/8139too.c
+++ b/drivers/net/8139too.c
@@ -505,7 +505,7 @@ enum chip_flags {
 #define HW_REVID_MASK   HW_REVID(1, 1, 1, 1, 1, 1, 1)
 
 /* directly indexed by chip_t, above */
-const static struct {
+static const struct {
         const char *name;
         u32 version; /* from RTL8139C/RTL8139D docs */
         u32 flags;
diff --git a/drivers/net/hamradio/6pack.c b/drivers/net/hamradio/6pack.c
index 90999867a32c..102c1f0b90da 100644
--- a/drivers/net/hamradio/6pack.c
+++ b/drivers/net/hamradio/6pack.c
@@ -456,11 +456,6 @@ out:
 
 /* ----------------------------------------------------------------------- */
 
-static int sixpack_receive_room(struct tty_struct *tty)
-{
-        return 65536;  /* We can handle an infinite amount of data. :-) */
-}
-
 /*
  * Handle the 'receiver data ready' interrupt.
  * This function is called by the 'tty_io' module in the kernel when
@@ -671,6 +666,7 @@ static int sixpack_open(struct tty_struct *tty)
 
         /* Done.  We have linked the TTY line to a channel. */
         tty->disc_data = sp;
+        tty->receive_room = 65536;
 
         /* Now we're ready to register. */
         if (register_netdev(dev))
@@ -802,7 +798,6 @@ static struct tty_ldisc sp_ldisc = {
         .close          = sixpack_close,
         .ioctl          = sixpack_ioctl,
         .receive_buf    = sixpack_receive_buf,
-        .receive_room   = sixpack_receive_room,
         .write_wakeup   = sixpack_write_wakeup,
 };
 
diff --git a/drivers/net/hamradio/mkiss.c b/drivers/net/hamradio/mkiss.c
index f4424cf886c5..dc5e9d59deed 100644
--- a/drivers/net/hamradio/mkiss.c
+++ b/drivers/net/hamradio/mkiss.c
@@ -753,6 +753,7 @@ static int mkiss_open(struct tty_struct *tty)
 
         ax->tty = tty;
         tty->disc_data = ax;
+        tty->receive_room = 65535;
 
         if (tty->driver->flush_buffer)
                 tty->driver->flush_buffer(tty);
@@ -940,11 +941,6 @@ static void mkiss_receive_buf(struct tty_struct *tty, const unsigned char *cp,
                 tty->driver->unthrottle(tty);
 }
 
-static int mkiss_receive_room(struct tty_struct *tty)
-{
-        return 65536;  /* We can handle an infinite amount of data. :-) */
-}
-
 /*
  * Called by the driver when there's room for more data.  If we have
  * more packets to send, we send them here.
@@ -983,7 +979,6 @@ static struct tty_ldisc ax_ldisc = {
         .close          = mkiss_close,
         .ioctl          = mkiss_ioctl,
         .receive_buf    = mkiss_receive_buf,
-        .receive_room   = mkiss_receive_room,
         .write_wakeup   = mkiss_write_wakeup
 };
 
diff --git a/drivers/net/irda/irport.c b/drivers/net/irda/irport.c
index 3d016a498e1d..6070195b87bd 100644
--- a/drivers/net/irda/irport.c
+++ b/drivers/net/irda/irport.c
@@ -285,19 +285,6 @@ static void irport_start(struct irport_cb *self)
 }
 
 /*
- * Function irport_probe (void)
- *
- *    Start IO port 
- *
- */
-int irport_probe(int iobase)
-{
-        IRDA_DEBUG(4, "%s(), iobase=%#x\n", __FUNCTION__, iobase);
-
-        return 0;
-}
-
-/*
  * Function irport_get_fcr (speed)
  *
  *    Compute value of fcr
@@ -382,7 +369,7 @@ static void irport_change_speed(void *priv, __u32 speed)
  *    we cannot use schedule_timeout() when we are in interrupt context
  *
  */
-int __irport_change_speed(struct irda_task *task)
+static int __irport_change_speed(struct irda_task *task)
 {
         struct irport_cb *self;
         __u32 speed = (__u32) task->param;
diff --git a/drivers/net/irda/irtty-sir.c b/drivers/net/irda/irtty-sir.c
index b8d112348ba4..101750bf210f 100644
--- a/drivers/net/irda/irtty-sir.c
+++ b/drivers/net/irda/irtty-sir.c
@@ -289,22 +289,6 @@ static void irtty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
 }
 
 /*
- * Function irtty_receive_room (tty)
- *
- *    Used by the TTY to find out how much data we can receive at a time
- * 
-*/
-static int irtty_receive_room(struct tty_struct *tty) 
-{
-        struct sirtty_cb *priv = tty->disc_data;
-
-        IRDA_ASSERT(priv != NULL, return 0;);
-        IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return 0;);
-
-        return 65536;  /* We can handle an infinite amount of data. :-) */
-}
-
-/*
  * Function irtty_write_wakeup (tty)
  *
  *    Called by the driver when there's room for more data.  If we have
@@ -534,6 +518,7 @@ static int irtty_open(struct tty_struct *tty)
 
         dev->priv = priv;
         tty->disc_data = priv;
+        tty->receive_room = 65536;
 
         up(&irtty_sem);
 
@@ -605,7 +590,6 @@ static struct tty_ldisc irda_ldisc = {
         .ioctl          = irtty_ioctl,
         .poll           = NULL,
         .receive_buf    = irtty_receive_buf,
-        .receive_room   = irtty_receive_room,
         .write_wakeup   = irtty_write_wakeup,
         .owner          = THIS_MODULE,
 };
diff --git a/drivers/net/pci-skeleton.c b/drivers/net/pci-skeleton.c
index a1ac4bd1696e..a7bb54df75a8 100644
--- a/drivers/net/pci-skeleton.c
+++ b/drivers/net/pci-skeleton.c
@@ -415,7 +415,7 @@ typedef enum {
 
 
 /* directly indexed by chip_t, above */
-const static struct {
+static const struct {
         const char *name;
         u8 version; /* from RTL8139C docs */
         u32 RxConfigMask; /* should clear the bits supported by this chip */
diff --git a/drivers/net/ppp_async.c b/drivers/net/ppp_async.c
index 400f652282d7..aa6540b39466 100644
--- a/drivers/net/ppp_async.c
+++ b/drivers/net/ppp_async.c
@@ -189,7 +189,7 @@ ppp_asynctty_open(struct tty_struct *tty)
                 goto out_free;
 
         tty->disc_data = ap;
-
+        tty->receive_room = 65536;
         return 0;
 
  out_free:
@@ -343,12 +343,6 @@ ppp_asynctty_poll(struct tty_struct *tty, struct file *file, poll_table *wait)
         return 0;
 }
 
-static int
-ppp_asynctty_room(struct tty_struct *tty)
-{
-        return 65535;
-}
-
 /*
  * This can now be called from hard interrupt level as well
  * as soft interrupt level or mainline.
@@ -398,7 +392,6 @@ static struct tty_ldisc ppp_ldisc = {
         .write  = ppp_asynctty_write,
         .ioctl  = ppp_asynctty_ioctl,
         .poll   = ppp_asynctty_poll,
-        .receive_room = ppp_asynctty_room,
         .receive_buf = ppp_asynctty_receive,
         .write_wakeup = ppp_asynctty_wakeup,
 };
diff --git a/drivers/net/ppp_synctty.c b/drivers/net/ppp_synctty.c
index 4d51c0c8023d..33cb8254e79d 100644
--- a/drivers/net/ppp_synctty.c
+++ b/drivers/net/ppp_synctty.c
@@ -237,7 +237,7 @@ ppp_sync_open(struct tty_struct *tty)
                 goto out_free;
 
         tty->disc_data = ap;
-
+        tty->receive_room = 65536;
         return 0;
 
  out_free:
@@ -384,12 +384,6 @@ ppp_sync_poll(struct tty_struct *tty, struct file *file, poll_table *wait)
         return 0;
 }
 
-static int
-ppp_sync_room(struct tty_struct *tty)
-{
-        return 65535;
-}
-
 /*
  * This can now be called from hard interrupt level as well
  * as soft interrupt level or mainline.
@@ -439,7 +433,6 @@ static struct tty_ldisc ppp_sync_ldisc = {
         .write  = ppp_sync_write,
         .ioctl  = ppp_synctty_ioctl,
         .poll   = ppp_sync_poll,
-        .receive_room = ppp_sync_room,
         .receive_buf = ppp_sync_receive,
         .write_wakeup = ppp_sync_wakeup,
 };
diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
index 14a76f7cf900..2e1bed153c39 100644
--- a/drivers/net/r8169.c
+++ b/drivers/net/r8169.c
@@ -170,7 +170,7 @@ enum phy_version {
 #define _R(NAME,MAC,MASK) \
         { .name = NAME, .mac_version = MAC, .RxConfigMask = MASK }
 
-const static struct {
+static const struct {
         const char *name;
         u8 mac_version;
         u32 RxConfigMask;       /* Clears the bits supported by this chip */
diff --git a/drivers/net/sis190.c b/drivers/net/sis190.c
index 478791e09bf7..b420182eec4b 100644
--- a/drivers/net/sis190.c
+++ b/drivers/net/sis190.c
@@ -329,7 +329,7 @@ static struct mii_chip_info {
         { NULL, }
 };
 
-const static struct {
+static const struct {
         const char *name;
 } sis_chip_info[] = {
         { "SiS 190 PCI Fast Ethernet adapter" },
diff --git a/drivers/net/slip.c b/drivers/net/slip.c
index 404ea4297e32..b2e18d28850d 100644
--- a/drivers/net/slip.c
+++ b/drivers/net/slip.c
@@ -651,11 +651,6 @@ static void sl_setup(struct net_device *dev)
  ******************************************/
 
 
-static int slip_receive_room(struct tty_struct *tty)
-{
-        return 65536;  /* We can handle an infinite amount of data. :-) */
-}
-
 /*
  * Handle the 'receiver data ready' interrupt.
  * This function is called by the 'tty_io' module in the kernel when
@@ -869,10 +864,6 @@ static int slip_open(struct tty_struct *tty)
         sl->line = tty_devnum(tty);
         sl->pid = current->pid;
         
-        /* FIXME: already done before we were called - seems this can go */
-        if (tty->driver->flush_buffer)
-                tty->driver->flush_buffer(tty);
-                
         if (!test_bit(SLF_INUSE, &sl->flags)) {
                 /* Perform the low-level SLIP initialization. */
                 if ((err = sl_alloc_bufs(sl, SL_MTU)) != 0)
@@ -897,6 +888,7 @@ static int slip_open(struct tty_struct *tty)
 
         /* Done.  We have linked the TTY line to a channel. */
         rtnl_unlock();
+        tty->receive_room = 65536;      /* We don't flow control */
         return sl->dev->base_addr;
 
 err_free_bufs:
@@ -1329,7 +1321,6 @@ static struct tty_ldisc	sl_ldisc = {
         .close          = slip_close,
         .ioctl          = slip_ioctl,
         .receive_buf    = slip_receive_buf,
-        .receive_room   = slip_receive_room,
         .write_wakeup   = slip_write_wakeup,
 };
 
diff --git a/drivers/net/wan/pc300_tty.c b/drivers/net/wan/pc300_tty.c
index 52f26b9c69d2..931cbdf6d791 100644
--- a/drivers/net/wan/pc300_tty.c
+++ b/drivers/net/wan/pc300_tty.c
@@ -689,7 +689,7 @@ static void cpc_tty_rx_work(void * data)
                                         }
                                 }       
                                 cpc_tty->buf_rx.first = cpc_tty->buf_rx.first->next;
-                                kfree(buf);
+                                kfree((void *)buf);
                                 buf = cpc_tty->buf_rx.first;
                                 flg_rx = 1;
                         }
diff --git a/drivers/net/wan/x25_asy.c b/drivers/net/wan/x25_asy.c
index bdf672c48182..9c3ccc669143 100644
--- a/drivers/net/wan/x25_asy.c
+++ b/drivers/net/wan/x25_asy.c
@@ -515,11 +515,6 @@ static int x25_asy_close(struct net_device *dev)
         return 0;
 }
 
-static int x25_asy_receive_room(struct tty_struct *tty)
-{
-        return 65536;  /* We can handle an infinite amount of data. :-) */
-}
-
 /*
  * Handle the 'receiver data ready' interrupt.
  * This function is called by the 'tty_io' module in the kernel when
@@ -573,6 +568,7 @@ static int x25_asy_open_tty(struct tty_struct *tty)
 
         sl->tty = tty;
         tty->disc_data = sl;
+        tty->receive_room = 65536;
         if (tty->driver->flush_buffer)  {
                 tty->driver->flush_buffer(tty);
         }
@@ -779,7 +775,6 @@ static struct tty_ldisc x25_ldisc = {
         .close          = x25_asy_close_tty,
         .ioctl          = x25_asy_ioctl,
         .receive_buf    = x25_asy_receive_buf,
-        .receive_room   = x25_asy_receive_room,
         .write_wakeup   = x25_asy_write_wakeup,
 };
 
diff --git a/drivers/net/wireless/strip.c b/drivers/net/wireless/strip.c
index d25264ba0c0e..18baacfc5a2c 100644
--- a/drivers/net/wireless/strip.c
+++ b/drivers/net/wireless/strip.c
@@ -1675,11 +1675,6 @@ static int strip_rebuild_header(struct sk_buff *skb)
 /************************************************************************/
 /* Receiving routines                                                   */
 
-static int strip_receive_room(struct tty_struct *tty)
-{
-        return 0x10000;         /* We can handle an infinite amount of data. :-) */
-}
-
 /*
  * This function parses the response to the ATS300? command,
  * extracting the radio version and serial number.
@@ -2424,7 +2419,7 @@ static struct net_device_stats *strip_get_stats(struct net_device *dev)
 /*
  * Here's the order things happen:
  * When the user runs "slattach -p strip ..."
- *  1. The TTY module calls strip_open
+ *  1. The TTY module calls strip_open;;
  *  2. strip_open calls strip_alloc
  *  3.                  strip_alloc calls register_netdev
  *  4.                  register_netdev calls strip_dev_init
@@ -2652,6 +2647,8 @@ static int strip_open(struct tty_struct *tty)
 
         strip_info->tty = tty;
         tty->disc_data = strip_info;
+        tty->receive_room = 65536;
+
         if (tty->driver->flush_buffer)
                 tty->driver->flush_buffer(tty);
 
@@ -2762,7 +2759,6 @@ static struct tty_ldisc strip_ldisc = {
         .close = strip_close,
         .ioctl = strip_ioctl,
         .receive_buf = strip_receive_buf,
-        .receive_room = strip_receive_room,
         .write_wakeup = strip_write_some_more,
 };
 
diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index 2472fa1a1be1..9c25654b1e75 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -1751,6 +1751,7 @@ dasd_device_operations = {
         .open           = dasd_open,
         .release        = dasd_release,
         .ioctl          = dasd_ioctl,
+        .compat_ioctl   = dasd_compat_ioctl,
         .getgeo         = dasd_getgeo,
 };
 
diff --git a/drivers/s390/block/dasd_int.h b/drivers/s390/block/dasd_int.h
index 2fb05c4a528c..e4b401500b01 100644
--- a/drivers/s390/block/dasd_int.h
+++ b/drivers/s390/block/dasd_int.h
@@ -527,6 +527,7 @@ void dasd_ioctl_exit(void);
 int  dasd_ioctl_no_register(struct module *, int, dasd_ioctl_fn_t);
 int  dasd_ioctl_no_unregister(struct module *, int, dasd_ioctl_fn_t);
 int  dasd_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
+long dasd_compat_ioctl(struct file *, unsigned int, unsigned long);
 
 /* externals in dasd_proc.c */
 int dasd_proc_init(void);
diff --git a/drivers/s390/block/dasd_ioctl.c b/drivers/s390/block/dasd_ioctl.c
index 8e4dcd58599e..9396fcacb8f8 100644
--- a/drivers/s390/block/dasd_ioctl.c
+++ b/drivers/s390/block/dasd_ioctl.c
@@ -118,6 +118,18 @@ dasd_ioctl(struct inode *inp, struct file *filp,
         return -EINVAL;
 }
 
+long
+dasd_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
+{
+        int rval;
+
+        lock_kernel();
+        rval = dasd_ioctl(filp->f_dentry->d_inode, filp, cmd, arg);
+        unlock_kernel();
+
+        return (rval == -EINVAL) ? -ENOIOCTLCMD : rval;
+}
+
 static int
 dasd_ioctl_api_version(struct block_device *bdev, int no, long args)
 {
diff --git a/drivers/s390/char/con3215.c b/drivers/s390/char/con3215.c
index 75419cf9d353..1f060914cfa4 100644
--- a/drivers/s390/char/con3215.c
+++ b/drivers/s390/char/con3215.c
@@ -16,6 +16,7 @@
 #include <linux/types.h>
 #include <linux/kdev_t.h>
 #include <linux/tty.h>
+#include <linux/tty_flip.h>
 #include <linux/vt_kern.h>
 #include <linux/init.h>
 #include <linux/console.h>
@@ -432,8 +433,6 @@ raw3215_irq(struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
                                 if (count > slen)
                                         count = slen;
                         } else
-                        if (count >= TTY_FLIPBUF_SIZE - tty->flip.count)
-                                count = TTY_FLIPBUF_SIZE - tty->flip.count - 1;
                         EBCASC(raw->inbuf, count);
                         cchar = ctrlchar_handle(raw->inbuf, count, tty);
                         switch (cchar & CTRLCHAR_MASK) {
@@ -441,28 +440,20 @@ raw3215_irq(struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
                                 break;
 
                         case CTRLCHAR_CTRL:
-                                tty->flip.count++;
-                                *tty->flip.flag_buf_ptr++ = TTY_NORMAL;
-                                *tty->flip.char_buf_ptr++ = cchar;
+                                tty_insert_flip_char(tty, cchar, TTY_NORMAL);
                                 tty_flip_buffer_push(raw->tty);
                                 break;
 
                         case CTRLCHAR_NONE:
-                                memcpy(tty->flip.char_buf_ptr,
-                                       raw->inbuf, count);
                                 if (count < 2 ||
-                                    (strncmp(raw->inbuf+count-2, "^n", 2) &&
-                                    strncmp(raw->inbuf+count-2, "\252n", 2)) ) {
-                                        /* don't add the auto \n */
-                                        tty->flip.char_buf_ptr[count] = '\n';
-                                        memset(tty->flip.flag_buf_ptr,
-                                               TTY_NORMAL, count + 1);
+                                    (strncmp(raw->inbuf+count-2, "\252n", 2) &&
+                                     strncmp(raw->inbuf+count-2, "^n", 2)) ) {
+                                        /* add the auto \n */
+                                        raw->inbuf[count] = '\n';
                                         count++;
                                 } else
-                                        count-=2;
-                                tty->flip.char_buf_ptr += count;
-                                tty->flip.flag_buf_ptr += count;
-                                tty->flip.count += count;
+                                        count -= 2;
+                                tty_insert_flip_string(tty, raw->inbuf, count);
                                 tty_flip_buffer_push(raw->tty);
                                 break;
                         }
diff --git a/drivers/s390/char/fs3270.c b/drivers/s390/char/fs3270.c
index 735a7fcdeff5..5f6fa4c67843 100644
--- a/drivers/s390/char/fs3270.c
+++ b/drivers/s390/char/fs3270.c
@@ -319,9 +319,8 @@ fs3270_write(struct file *filp, const char *data, size_t count, loff_t *off)
 /*
  * process ioctl commands for the tube driver
  */
-static int
-fs3270_ioctl(struct inode *inode, struct file *filp,
-             unsigned int cmd, unsigned long arg)
+static long
+fs3270_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
         struct fs3270 *fp;
         struct raw3270_iocb iocb;
@@ -331,6 +330,7 @@ fs3270_ioctl(struct inode *inode, struct file *filp,
         if (!fp)
                 return -ENODEV;
         rc = 0;
+        lock_kernel();
         switch (cmd) {
         case TUBICMD:
                 fp->read_command = arg;
@@ -356,6 +356,7 @@ fs3270_ioctl(struct inode *inode, struct file *filp,
                         rc = -EFAULT;
                 break;
         }
+        unlock_kernel();
         return rc;
 }
 
@@ -491,12 +492,13 @@ fs3270_close(struct inode *inode, struct file *filp)
 }
 
 static struct file_operations fs3270_fops = {
-        .owner   = THIS_MODULE,         /* owner */
-        .read    = fs3270_read,         /* read */
-        .write   = fs3270_write,        /* write */
-        .ioctl   = fs3270_ioctl,        /* ioctl */
-        .open    = fs3270_open,         /* open */
-        .release = fs3270_close,        /* release */
+        .owner           = THIS_MODULE,         /* owner */
+        .read            = fs3270_read,         /* read */
+        .write           = fs3270_write,        /* write */
+        .unlocked_ioctl  = fs3270_ioctl,        /* ioctl */
+        .compat_ioctl    = fs3270_ioctl,        /* ioctl */
+        .open           = fs3270_open,          /* open */
+        .release        = fs3270_close,         /* release */
 };
 
 /*
diff --git a/drivers/s390/char/sclp_tty.c b/drivers/s390/char/sclp_tty.c
index a20d7c89341d..6cbf067f1a8f 100644
--- a/drivers/s390/char/sclp_tty.c
+++ b/drivers/s390/char/sclp_tty.c
@@ -13,6 +13,7 @@
 #include <linux/kmod.h>
 #include <linux/tty.h>
 #include <linux/tty_driver.h>
+#include <linux/tty_flip.h>
 #include <linux/sched.h>
 #include <linux/wait.h>
 #include <linux/slab.h>
@@ -496,25 +497,19 @@ sclp_tty_input(unsigned char* buf, unsigned int count)
         case CTRLCHAR_SYSRQ:
                 break;
         case CTRLCHAR_CTRL:
-                sclp_tty->flip.count++;
-                *sclp_tty->flip.flag_buf_ptr++ = TTY_NORMAL;
-                *sclp_tty->flip.char_buf_ptr++ = cchar;
+                tty_insert_flip_char(sclp_tty, cchar, TTY_NORMAL);
                 tty_flip_buffer_push(sclp_tty);
                 break;
         case CTRLCHAR_NONE:
                 /* send (normal) input to line discipline */
-                memcpy(sclp_tty->flip.char_buf_ptr, buf, count);
                 if (count < 2 ||
-                    (strncmp ((const char *) buf + count - 2, "^n", 2) &&
-                     strncmp ((const char *) buf + count - 2, "\0252n", 2))) {
-                        sclp_tty->flip.char_buf_ptr[count] = '\n';
-                        count++;
+                    (strncmp((const char *) buf + count - 2, "^n", 2) &&
+                     strncmp((const char *) buf + count - 2, "\252n", 2))) {
+                        /* add the auto \n */
+                        tty_insert_flip_string(sclp_tty, buf, count);
+                        tty_insert_flip_char(sclp_tty, '\n', TTY_NORMAL);
                 } else
-                        count -= 2;
-                memset(sclp_tty->flip.flag_buf_ptr, TTY_NORMAL, count);
-                sclp_tty->flip.char_buf_ptr += count;
-                sclp_tty->flip.flag_buf_ptr += count;
-                sclp_tty->flip.count += count;
+                        tty_insert_flip_string(sclp_tty, buf, count - 2);
                 tty_flip_buffer_push(sclp_tty);
                 break;
         }
diff --git a/drivers/s390/char/sclp_vt220.c b/drivers/s390/char/sclp_vt220.c
index 06bd85824d7b..9e02625c82cf 100644
--- a/drivers/s390/char/sclp_vt220.c
+++ b/drivers/s390/char/sclp_vt220.c
@@ -16,6 +16,7 @@
 #include <linux/kernel.h>
 #include <linux/tty.h>
 #include <linux/tty_driver.h>
+#include <linux/tty_flip.h>
 #include <linux/sched.h>
 #include <linux/errno.h>
 #include <linux/mm.h>
@@ -482,16 +483,7 @@ sclp_vt220_receiver_fn(struct evbuf_header *evbuf)
                 /* Send input to line discipline */
                 buffer++;
                 count--;
-                /* Prevent buffer overrun by discarding input. Note that
-                 * because buffer_push works asynchronously, we cannot wait
-                 * for the buffer to be emptied. */
-                if (count + sclp_vt220_tty->flip.count > TTY_FLIPBUF_SIZE)
-                        count = TTY_FLIPBUF_SIZE - sclp_vt220_tty->flip.count;
-                memcpy(sclp_vt220_tty->flip.char_buf_ptr, buffer, count);
-                memset(sclp_vt220_tty->flip.flag_buf_ptr, TTY_NORMAL, count);
-                sclp_vt220_tty->flip.char_buf_ptr += count;
-                sclp_vt220_tty->flip.flag_buf_ptr += count;
-                sclp_vt220_tty->flip.count += count;
+                tty_insert_flip_string(sclp_vt220_tty, buffer, count);
                 tty_flip_buffer_push(sclp_vt220_tty);
                 break;
         }
diff --git a/drivers/s390/char/tape_char.c b/drivers/s390/char/tape_char.c
index 86262a13f7c6..5ce7ca38ace0 100644
--- a/drivers/s390/char/tape_char.c
+++ b/drivers/s390/char/tape_char.c
@@ -37,6 +37,8 @@ static int tapechar_open(struct inode *,struct file *);
 static int tapechar_release(struct inode *,struct file *);
 static int tapechar_ioctl(struct inode *, struct file *, unsigned int,
                           unsigned long);
+static long tapechar_compat_ioctl(struct file *, unsigned int,
+                          unsigned long);
 
 static struct file_operations tape_fops =
 {
@@ -44,6 +46,7 @@ static struct file_operations tape_fops =
         .read = tapechar_read,
         .write = tapechar_write,
         .ioctl = tapechar_ioctl,
+        .compat_ioctl = tapechar_compat_ioctl,
         .open = tapechar_open,
         .release = tapechar_release,
 };
@@ -463,6 +466,23 @@ tapechar_ioctl(struct inode *inp, struct file *filp,
         return device->discipline->ioctl_fn(device, no, data);
 }
 
+static long
+tapechar_compat_ioctl(struct file *filp, unsigned int no, unsigned long data)
+{
+        struct tape_device *device = filp->private_data;
+        int rval = -ENOIOCTLCMD;
+
+        if (device->discipline->ioctl_fn) {
+                lock_kernel();
+                rval = device->discipline->ioctl_fn(device, no, data);
+                unlock_kernel();
+                if (rval == -EINVAL)
+                        rval = -ENOIOCTLCMD;
+        }
+
+        return rval;
+}
+
 /*
  * Initialize character device frontend.
  */
diff --git a/drivers/s390/crypto/z90main.c b/drivers/s390/crypto/z90main.c
index 135ae04e6e75..2f54d033d7cf 100644
--- a/drivers/s390/crypto/z90main.c
+++ b/drivers/s390/crypto/z90main.c
@@ -30,7 +30,6 @@
 #include <linux/delay.h>       // mdelay
 #include <linux/init.h>
 #include <linux/interrupt.h>   // for tasklets
-#include <linux/ioctl32.h>
 #include <linux/miscdevice.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
diff --git a/drivers/s390/net/ctctty.c b/drivers/s390/net/ctctty.c
index 968f2c113efe..93d1725eb79b 100644
--- a/drivers/s390/net/ctctty.c
+++ b/drivers/s390/net/ctctty.c
@@ -25,6 +25,7 @@
 #include <linux/config.h>
 #include <linux/module.h>
 #include <linux/tty.h>
+#include <linux/tty_flip.h>
 #include <linux/serial_reg.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
@@ -101,25 +102,17 @@ static spinlock_t ctc_tty_lock;
 static int
 ctc_tty_try_read(ctc_tty_info * info, struct sk_buff *skb)
 {
-        int c;
         int len;
         struct tty_struct *tty;
 
         DBF_TEXT(trace, 5, __FUNCTION__);
         if ((tty = info->tty)) {
                 if (info->mcr & UART_MCR_RTS) {
-                        c = TTY_FLIPBUF_SIZE - tty->flip.count;
                         len = skb->len;
-                        if (c >= len) {
-                                memcpy(tty->flip.char_buf_ptr, skb->data, len);
-                                memset(tty->flip.flag_buf_ptr, 0, len);
-                                tty->flip.count += len;
-                                tty->flip.char_buf_ptr += len;
-                                tty->flip.flag_buf_ptr += len;
-                                tty_flip_buffer_push(tty);
-                                kfree_skb(skb);
-                                return 1;
-                        }
+                        tty_insert_flip_string(tty, skb->data, len);
+                        tty_flip_buffer_push(tty);
+                        kfree_skb(skb);
+                        return 1;
                 }
         }
         return 0;
@@ -138,19 +131,12 @@ ctc_tty_readmodem(ctc_tty_info *info)
         DBF_TEXT(trace, 5, __FUNCTION__);
         if ((tty = info->tty)) {
                 if (info->mcr & UART_MCR_RTS) {
-                        int c = TTY_FLIPBUF_SIZE - tty->flip.count;
                         struct sk_buff *skb;
                         
-                        if ((c > 0) && (skb = skb_dequeue(&info->rx_queue))) {
+                        if ((skb = skb_dequeue(&info->rx_queue))) {
                                 int len = skb->len;
-                                if (len > c)
-                                        len = c;
-                                memcpy(tty->flip.char_buf_ptr, skb->data, len);
+                                tty_insert_flip_string(tty, skb->data, len);
                                 skb_pull(skb, len);
-                                memset(tty->flip.flag_buf_ptr, 0, len);
-                                tty->flip.count += len;
-                                tty->flip.char_buf_ptr += len;
-                                tty->flip.flag_buf_ptr += len;
                                 tty_flip_buffer_push(tty);
                                 if (skb->len > 0)
                                         skb_queue_head(&info->rx_queue, skb);
diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c
index 3cb68af90456..9b9062f02462 100644
--- a/drivers/scsi/aacraid/linit.c
+++ b/drivers/scsi/aacraid/linit.c
@@ -46,7 +46,6 @@
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/syscalls.h>
-#include <linux/ioctl32.h>
 #include <linux/delay.h>
 #include <linux/smp_lock.h>
 #include <asm/semaphore.h>
diff --git a/drivers/scsi/ch.c b/drivers/scsi/ch.c
index 0920220f3313..4299fabca554 100644
--- a/drivers/scsi/ch.c
+++ b/drivers/scsi/ch.c
@@ -20,7 +20,6 @@
 #include <linux/interrupt.h>
 #include <linux/blkdev.h>
 #include <linux/completion.h>
-#include <linux/ioctl32.h>
 #include <linux/compat.h>
 #include <linux/chio.h>                 /* here are all the ioctls */
 
diff --git a/drivers/scsi/megaraid/megaraid_mm.h b/drivers/scsi/megaraid/megaraid_mm.h
index eb8c390a0fa3..3d9e67d6849d 100644
--- a/drivers/scsi/megaraid/megaraid_mm.h
+++ b/drivers/scsi/megaraid/megaraid_mm.h
@@ -22,7 +22,6 @@
 #include <linux/moduleparam.h>
 #include <linux/pci.h>
 #include <linux/list.h>
-#include <linux/ioctl32.h>
 
 #include "mbox_defs.h"
 #include "megaraid_ioctl.h"
diff --git a/drivers/serial/21285.c b/drivers/serial/21285.c
index b5cf39468d18..221999bcf8fe 100644
--- a/drivers/serial/21285.c
+++ b/drivers/serial/21285.c
@@ -94,15 +94,6 @@ static irqreturn_t serial21285_rx_chars(int irq, void *dev_id, struct pt_regs *r
 
         status = *CSR_UARTFLG;
         while (!(status & 0x10) && max_count--) {
-                if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                        if (tty->low_latency)
-                                tty_flip_buffer_push(tty);
-                        /*
-                         * If this failed then we will throw away the
-                         * bytes but must do so to clear interrupts
-                         */
-                }
-
                 ch = *CSR_UARTDR;
                 flag = TTY_NORMAL;
                 port->icount.rx++;
diff --git a/drivers/serial/68328serial.c b/drivers/serial/68328serial.c
index 67e9afa000c1..4dd5c3f98167 100644
--- a/drivers/serial/68328serial.c
+++ b/drivers/serial/68328serial.c
@@ -294,7 +294,7 @@ static _INLINE_ void receive_chars(struct m68k_serial *info, struct pt_regs *reg
 {
         struct tty_struct *tty = info->tty;
         m68328_uart *uart = &uart_addr[info->line];
-        unsigned char ch;
+        unsigned char ch, flag;
 
         /*
          * This do { } while() loop will get ALL chars out of Rx FIFO 
@@ -332,26 +332,24 @@ static _INLINE_ void receive_chars(struct m68k_serial *info, struct pt_regs *reg
                 /*
                  * Make sure that we do not overflow the buffer
                  */
-                if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
+                if (tty_request_buffer_room(tty, 1) == 0) {
                         schedule_work(&tty->flip.work);
                         return;
                 }
 
+                flag = TTY_NORMAL;
+
                 if(rx & URX_PARITY_ERROR) {
-                        *tty->flip.flag_buf_ptr++ = TTY_PARITY;
+                        flag = TTY_PARITY;
                         status_handle(info, rx);
                 } else if(rx & URX_OVRUN) {
-                        *tty->flip.flag_buf_ptr++ = TTY_OVERRUN;
+                        flag = TTY_OVERRUN;
                         status_handle(info, rx);
                 } else if(rx & URX_FRAME_ERROR) {
-                        *tty->flip.flag_buf_ptr++ = TTY_FRAME;
+                        flag = TTY_FRAME;
                         status_handle(info, rx);
-                } else {
-                        *tty->flip.flag_buf_ptr++ = 0; /* XXX */
                 }
-                *tty->flip.char_buf_ptr++ = ch;
-                tty->flip.count++;
-
+                tty_insert_flip_char(tty, ch, flag);
 #ifndef CONFIG_XCOPILOT_BUGS
         } while((rx = uart->urx.w) & URX_DATA_READY);
 #endif
diff --git a/drivers/serial/68360serial.c b/drivers/serial/68360serial.c
index 170c9d2a749c..60f5a5dc17f1 100644
--- a/drivers/serial/68360serial.c
+++ b/drivers/serial/68360serial.c
@@ -394,7 +394,7 @@ static void rs_360_start(struct tty_struct *tty)
 static _INLINE_ void receive_chars(ser_info_t *info)
 {
         struct tty_struct *tty = info->tty;
-        unsigned char ch, *cp;
+        unsigned char ch, flag, *cp;
         /*int   ignored = 0;*/
         int     i;
         ushort  status;
@@ -438,24 +438,15 @@ static _INLINE_ void receive_chars(ser_info_t *info)
                 cp = (char *)bdp->buf;
                 status = bdp->status;
 
-                /* Check to see if there is room in the tty buffer for
-                 * the characters in our BD buffer.  If not, we exit
-                 * now, leaving the BD with the characters.  We'll pick
-                 * them up again on the next receive interrupt (which could
-                 * be a timeout).
-                 */
-                if ((tty->flip.count + i) >= TTY_FLIPBUF_SIZE)
-                        break;
-
                 while (i-- > 0) {
                         ch = *cp++;
-                        *tty->flip.char_buf_ptr = ch;
                         icount->rx++;
 
 #ifdef SERIAL_DEBUG_INTR
                         printk("DR%02x:%02x...", ch, status);
 #endif
-                        *tty->flip.flag_buf_ptr = 0;
+                        flag = TTY_NORMAL;
+
                         if (status & (BD_SC_BR | BD_SC_FR |
                                        BD_SC_PR | BD_SC_OV)) {
                                 /*
@@ -490,30 +481,18 @@ static _INLINE_ void receive_chars(ser_info_t *info)
                                         if (info->flags & ASYNC_SAK)
                                                 do_SAK(tty);
                                 } else if (status & BD_SC_PR)
-                                        *tty->flip.flag_buf_ptr = TTY_PARITY;
+                                        flag = TTY_PARITY;
                                 else if (status & BD_SC_FR)
-                                        *tty->flip.flag_buf_ptr = TTY_FRAME;
-                                if (status & BD_SC_OV) {
-                                        /*
-                                         * Overrun is special, since it's
-                                         * reported immediately, and doesn't
-                                         * affect the current character
-                                         */
-                                        if (tty->flip.count < TTY_FLIPBUF_SIZE) {
-                                                tty->flip.count++;
-                                                tty->flip.flag_buf_ptr++;
-                                                tty->flip.char_buf_ptr++;
-                                                *tty->flip.flag_buf_ptr =
-                                                                TTY_OVERRUN;
-                                        }
-                                }
+                                        flag = TTY_FRAME;
                         }
-                        if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                                break;
-
-                        tty->flip.flag_buf_ptr++;
-                        tty->flip.char_buf_ptr++;
-                        tty->flip.count++;
+                        tty_insert_flip_char(tty, ch, flag);
+                        if (status & BD_SC_OV)
+                                /*
+                                 * Overrun is special, since it's
+                                 * reported immediately, and doesn't
+                                 * affect the current character
+                                 */
+                                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
                 }
 
                 /* This BD is ready to be used again.  Clear status.
@@ -541,12 +520,7 @@ static _INLINE_ void receive_break(ser_info_t *info)
         /* Check to see if there is room in the tty buffer for
          * the break.  If not, we exit now, losing the break.  FIXME
          */
-        if ((tty->flip.count + 1) >= TTY_FLIPBUF_SIZE)
-                return;
-        *(tty->flip.flag_buf_ptr++) = TTY_BREAK;
-        *(tty->flip.char_buf_ptr++) = 0;
-        tty->flip.count++;
-
+        tty_insert_flip_char(tty, 0, TTY_BREAK);
         schedule_work(&tty->flip.work);
 }
 
diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
index e8454611cb65..54e5cc0dd5f8 100644
--- a/drivers/serial/8250.c
+++ b/drivers/serial/8250.c
@@ -1142,19 +1142,6 @@ receive_chars(struct uart_8250_port *up, int *status, struct pt_regs *regs)
         char flag;
 
         do {
-                /* The following is not allowed by the tty layer and
-                   unsafe. It should be fixed ASAP */
-                if (unlikely(tty->flip.count >= TTY_FLIPBUF_SIZE)) {
-                        if (tty->low_latency) {
-                                spin_unlock(&up->port.lock);
-                                tty_flip_buffer_push(tty);
-                                spin_lock(&up->port.lock);
-                        }
-                        /*
-                         * If this failed then we will throw away the
-                         * bytes but must do so to clear interrupts
-                         */
-                }
                 ch = serial_inp(up, UART_RX);
                 flag = TTY_NORMAL;
                 up->port.icount.rx++;
diff --git a/drivers/serial/Kconfig b/drivers/serial/Kconfig
index 1bae26a8a503..698cb76819d9 100644
--- a/drivers/serial/Kconfig
+++ b/drivers/serial/Kconfig
@@ -860,7 +860,7 @@ config SERIAL_VR41XX_CONSOLE
 
 config SERIAL_JSM
         tristate "Digi International NEO PCI Support"
-        depends on PCI
+        depends on PCI && BROKEN
         select SERIAL_CORE
         help
           This is a driver for Digi International's Neo series
diff --git a/drivers/serial/amba-pl010.c b/drivers/serial/amba-pl010.c
index 48f6e872314b..3490022e9fdc 100644
--- a/drivers/serial/amba-pl010.c
+++ b/drivers/serial/amba-pl010.c
@@ -154,15 +154,6 @@ pl010_rx_chars(struct uart_port *port)
 
         status = UART_GET_FR(port);
         while (UART_RX_DATA(status) && max_count--) {
-                if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                        if (tty->low_latency)
-                                tty_flip_buffer_push(tty);
-                        /*
-                         * If this failed then we will throw away the
-                         * bytes but must do so to clear interrupts.
-                         */
-                }
-
                 ch = UART_GET_CHAR(port);
                 flag = TTY_NORMAL;
 
diff --git a/drivers/serial/amba-pl011.c b/drivers/serial/amba-pl011.c
index 129670556162..034a029e356e 100644
--- a/drivers/serial/amba-pl011.c
+++ b/drivers/serial/amba-pl011.c
@@ -120,15 +120,6 @@ pl011_rx_chars(struct uart_amba_port *uap)
 
         status = readw(uap->port.membase + UART01x_FR);
         while ((status & UART01x_FR_RXFE) == 0 && max_count--) {
-                if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                        if (tty->low_latency)
-                                tty_flip_buffer_push(tty);
-                        /*
-                         * If this failed then we will throw away the
-                         * bytes but must do so to clear interrupts
-                         */
-                }
-
                 ch = readw(uap->port.membase + UART01x_DR) | UART_DUMMY_DR_RX;
                 flag = TTY_NORMAL;
                 uap->port.icount.rx++;
diff --git a/drivers/serial/au1x00_uart.c b/drivers/serial/au1x00_uart.c
index a274ebf256a1..ceb5d7f37bbd 100644
--- a/drivers/serial/au1x00_uart.c
+++ b/drivers/serial/au1x00_uart.c
@@ -241,18 +241,12 @@ static _INLINE_ void
 receive_chars(struct uart_8250_port *up, int *status, struct pt_regs *regs)
 {
         struct tty_struct *tty = up->port.info->tty;
-        unsigned char ch;
+        unsigned char ch, flag;
         int max_count = 256;
 
         do {
-                if (unlikely(tty->flip.count >= TTY_FLIPBUF_SIZE)) {
-                        tty->flip.work.func((void *)tty);
-                        if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                                return; // if TTY_DONT_FLIP is set
-                }
                 ch = serial_inp(up, UART_RX);
-                *tty->flip.char_buf_ptr = ch;
-                *tty->flip.flag_buf_ptr = TTY_NORMAL;
+                flag = TTY_NORMAL;
                 up->port.icount.rx++;
 
                 if (unlikely(*status & (UART_LSR_BI | UART_LSR_PE |
@@ -292,30 +286,23 @@ receive_chars(struct uart_8250_port *up, int *status, struct pt_regs *regs)
 #endif
                         if (*status & UART_LSR_BI) {
                                 DEBUG_INTR("handling break....");
-                                *tty->flip.flag_buf_ptr = TTY_BREAK;
+                                flag = TTY_BREAK;
                         } else if (*status & UART_LSR_PE)
-                                *tty->flip.flag_buf_ptr = TTY_PARITY;
+                                flag = TTY_PARITY;
                         else if (*status & UART_LSR_FE)
-                                *tty->flip.flag_buf_ptr = TTY_FRAME;
+                                flag = TTY_FRAME;
                 }
                 if (uart_handle_sysrq_char(&up->port, ch, regs))
                         goto ignore_char;
-                if ((*status & up->port.ignore_status_mask) == 0) {
-                        tty->flip.flag_buf_ptr++;
-                        tty->flip.char_buf_ptr++;
-                        tty->flip.count++;
-                }
-                if ((*status & UART_LSR_OE) &&
-                    tty->flip.count < TTY_FLIPBUF_SIZE) {
+                if ((*status & up->port.ignore_status_mask) == 0)
+                        tty_insert_flip_char(tty, ch, flag);
+                if (*status & UART_LSR_OE)
                         /*
                          * Overrun is special, since it's reported
                          * immediately, and doesn't affect the current
                          * character.
                          */
-                        *tty->flip.flag_buf_ptr = TTY_OVERRUN;
-                        tty->flip.flag_buf_ptr++;
-                        tty->flip.char_buf_ptr++;
-                        tty->flip.count++;
+                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
                 }
         ignore_char:
                 *status = serial_inp(up, UART_LSR);
diff --git a/drivers/serial/clps711x.c b/drivers/serial/clps711x.c
index 87ef368384fb..8ef999481f93 100644
--- a/drivers/serial/clps711x.c
+++ b/drivers/serial/clps711x.c
@@ -104,8 +104,6 @@ static irqreturn_t clps711xuart_int_rx(int irq, void *dev_id, struct pt_regs *re
         while (!(status & SYSFLG_URXFE)) {
                 ch = clps_readl(UARTDR(port));
 
-                if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                        goto ignore_char;
                 port->icount.rx++;
 
                 flg = TTY_NORMAL;
diff --git a/drivers/serial/dz.c b/drivers/serial/dz.c
index 4d8516d1bb71..a64ba26a94e8 100644
--- a/drivers/serial/dz.c
+++ b/drivers/serial/dz.c
@@ -216,8 +216,6 @@ static inline void dz_receive_chars(struct dz_port *dport)
 
                 if (!tty)
                         break;
-                if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                        break;
 
                 icount->rx++;
 
diff --git a/drivers/serial/icom.c b/drivers/serial/icom.c
index eb31125c6a30..144a7a352b28 100644
--- a/drivers/serial/icom.c
+++ b/drivers/serial/icom.c
@@ -729,19 +729,20 @@ static void recv_interrupt(u16 port_int_reg, struct icom_port *icom_port)
         unsigned short int status;
         struct uart_icount *icount;
         unsigned long offset;
+        unsigned char flag;
 
         trace(icom_port, "RCV_COMPLETE", 0);
         rcv_buff = icom_port->next_rcv;
 
         status = cpu_to_le16(icom_port->statStg->rcv[rcv_buff].flags);
         while (status & SA_FL_RCV_DONE) {
+                int first = -1;
 
                 trace(icom_port, "FID_STATUS", status);
                 count = cpu_to_le16(icom_port->statStg->rcv[rcv_buff].leLength);
 
+                count = tty_buffer_request_room(tty, count);
                 trace(icom_port, "RCV_COUNT", count);
-                if (count > (TTY_FLIPBUF_SIZE - tty->flip.count))
-                        count = TTY_FLIPBUF_SIZE - tty->flip.count;
 
                 trace(icom_port, "REAL_COUNT", count);
 
@@ -749,15 +750,10 @@ static void recv_interrupt(u16 port_int_reg, struct icom_port *icom_port)
                         cpu_to_le32(icom_port->statStg->rcv[rcv_buff].leBuffer) -
                         icom_port->recv_buf_pci;
 
-                memcpy(tty->flip.char_buf_ptr,(unsigned char *)
-                       ((unsigned long)icom_port->recv_buf + offset), count);
-
+                /* Block copy all but the last byte as this may have status */
                 if (count > 0) {
-                        tty->flip.count += count - 1;
-                        tty->flip.char_buf_ptr += count - 1;
-
-                        memset(tty->flip.flag_buf_ptr, 0, count);
-                        tty->flip.flag_buf_ptr += count - 1;
+                        first = icom_port->recv_buf[offset];
+                        tty_insert_flip_string(tty, icom_port->recv_buf + offset, count - 1);
                 }
 
                 icount = &icom_port->uart_port.icount;
@@ -765,12 +761,14 @@ static void recv_interrupt(u16 port_int_reg, struct icom_port *icom_port)
 
                 /* Break detect logic */
                 if ((status & SA_FLAGS_FRAME_ERROR)
-                    && (tty->flip.char_buf_ptr[0] == 0x00)) {
+                    && first == 0) {
                         status &= ~SA_FLAGS_FRAME_ERROR;
                         status |= SA_FLAGS_BREAK_DET;
                         trace(icom_port, "BREAK_DET", 0);
                 }
 
+                flag = TTY_NORMAL;
+
                 if (status &
                     (SA_FLAGS_BREAK_DET | SA_FLAGS_PARITY_ERROR |
                      SA_FLAGS_FRAME_ERROR | SA_FLAGS_OVERRUN)) {
@@ -797,33 +795,26 @@ static void recv_interrupt(u16 port_int_reg, struct icom_port *icom_port)
                         status &= icom_port->read_status_mask;
 
                         if (status & SA_FLAGS_BREAK_DET) {
-                                *tty->flip.flag_buf_ptr = TTY_BREAK;
+                                flag = TTY_BREAK;
                         } else if (status & SA_FLAGS_PARITY_ERROR) {
                                 trace(icom_port, "PARITY_ERROR", 0);
-                                *tty->flip.flag_buf_ptr = TTY_PARITY;
+                                flag = TTY_PARITY;
                         } else if (status & SA_FLAGS_FRAME_ERROR)
-                                *tty->flip.flag_buf_ptr = TTY_FRAME;
-
-                        if (status & SA_FLAGS_OVERRUN) {
-                                /*
-                                 * Overrun is special, since it's
-                                 * reported immediately, and doesn't
-                                 * affect the current character
-                                 */
-                                if (tty->flip.count < TTY_FLIPBUF_SIZE) {
-                                        tty->flip.count++;
-                                        tty->flip.flag_buf_ptr++;
-                                        tty->flip.char_buf_ptr++;
-                                        *tty->flip.flag_buf_ptr = TTY_OVERRUN;
-                                }
-                        }
+                                flag = TTY_FRAME;
+
                 }
 
-                tty->flip.flag_buf_ptr++;
-                tty->flip.char_buf_ptr++;
-                tty->flip.count++;
-                ignore_char:
-                        icom_port->statStg->rcv[rcv_buff].flags = 0;
+                tty_insert_flip_char(tty, *(icom_port->recv_buf + offset + count - 1), flag);
+
+                if (status & SA_FLAGS_OVERRUN)
+                        /*
+                         * Overrun is special, since it's
+                         * reported immediately, and doesn't
+                         * affect the current character
+                         */
+                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+ignore_char:
+                icom_port->statStg->rcv[rcv_buff].flags = 0;
                 icom_port->statStg->rcv[rcv_buff].leLength = 0;
                 icom_port->statStg->rcv[rcv_buff].WorkingLength =
                         (unsigned short int) cpu_to_le16(RCV_BUFF_SZ);
diff --git a/drivers/serial/imx.c b/drivers/serial/imx.c
index 83c4c1216587..5c098be9346b 100644
--- a/drivers/serial/imx.c
+++ b/drivers/serial/imx.c
@@ -256,9 +256,6 @@ static irqreturn_t imx_rxint(int irq, void *dev_id, struct pt_regs *regs)
         error_return:
                 tty_insert_flip_char(tty, rx, flg);
 
-                if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                        goto out;
-
         ignore_char:
                 rx = URXD0((u32)sport->port.membase);
         } while(rx & URXD_CHARRDY);
diff --git a/drivers/serial/ioc4_serial.c b/drivers/serial/ioc4_serial.c
index 771676abee60..1d85533d46d2 100644
--- a/drivers/serial/ioc4_serial.c
+++ b/drivers/serial/ioc4_serial.c
@@ -2327,19 +2327,13 @@ static void receive_chars(struct uart_port *the_port)
         spin_lock_irqsave(&the_port->lock, pflags);
         tty = info->tty;
 
-        if (request_count > TTY_FLIPBUF_SIZE - tty->flip.count)
-                request_count = TTY_FLIPBUF_SIZE - tty->flip.count;
+        request_count = tty_buffer_request_room(tty, IOC4_MAX_CHARS - 2);
 
         if (request_count > 0) {
                 icount = &the_port->icount;
                 read_count = do_read(the_port, ch, request_count);
                 if (read_count > 0) {
-                        flip = 1;
-                        memcpy(tty->flip.char_buf_ptr, ch, read_count);
-                        memset(tty->flip.flag_buf_ptr, TTY_NORMAL, read_count);
-                        tty->flip.char_buf_ptr += read_count;
-                        tty->flip.flag_buf_ptr += read_count;
-                        tty->flip.count += read_count;
+                        tty_insert_flip_string(tty, ch, read_count);
                         icount->rx += read_count;
                 }
         }
diff --git a/drivers/serial/ip22zilog.c b/drivers/serial/ip22zilog.c
index ef132349f310..66f117d15065 100644
--- a/drivers/serial/ip22zilog.c
+++ b/drivers/serial/ip22zilog.c
@@ -259,13 +259,7 @@ static void ip22zilog_receive_chars(struct uart_ip22zilog_port *up,
         struct tty_struct *tty = up->port.info->tty;    /* XXX info==NULL? */
 
         while (1) {
-                unsigned char ch, r1;
-
-                if (unlikely(tty->flip.count >= TTY_FLIPBUF_SIZE)) {
-                        tty->flip.work.func((void *)tty);
-                        if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                                return;         /* XXX Ignores SysRq when we need it most. Fix. */
-                }
+                unsigned char ch, r1, flag;
 
                 r1 = read_zsreg(channel, R1);
                 if (r1 & (PAR_ERR | Rx_OVR | CRC_ERR)) {
@@ -303,8 +297,7 @@ static void ip22zilog_receive_chars(struct uart_ip22zilog_port *up,
                 }
 
                 /* A real serial line, record the character and status.  */
-                *tty->flip.char_buf_ptr = ch;
-                *tty->flip.flag_buf_ptr = TTY_NORMAL;
+                flag = TTY_NORMAL;
                 up->port.icount.rx++;
                 if (r1 & (BRK_ABRT | PAR_ERR | Rx_OVR | CRC_ERR)) {
                         if (r1 & BRK_ABRT) {
@@ -321,28 +314,21 @@ static void ip22zilog_receive_chars(struct uart_ip22zilog_port *up,
                                 up->port.icount.overrun++;
                         r1 &= up->port.read_status_mask;
                         if (r1 & BRK_ABRT)
-                                *tty->flip.flag_buf_ptr = TTY_BREAK;
+                                flag = TTY_BREAK;
                         else if (r1 & PAR_ERR)
-                                *tty->flip.flag_buf_ptr = TTY_PARITY;
+                                flag = TTY_PARITY;
                         else if (r1 & CRC_ERR)
-                                *tty->flip.flag_buf_ptr = TTY_FRAME;
+                                flag = TTY_FRAME;
                 }
                 if (uart_handle_sysrq_char(&up->port, ch, regs))
                         goto next_char;
 
                 if (up->port.ignore_status_mask == 0xff ||
-                    (r1 & up->port.ignore_status_mask) == 0) {
-                        tty->flip.flag_buf_ptr++;
-                        tty->flip.char_buf_ptr++;
-                        tty->flip.count++;
-                }
-                if ((r1 & Rx_OVR) &&
-                    tty->flip.count < TTY_FLIPBUF_SIZE) {
-                        *tty->flip.flag_buf_ptr = TTY_OVERRUN;
-                        tty->flip.flag_buf_ptr++;
-                        tty->flip.char_buf_ptr++;
-                        tty->flip.count++;
-                }
+                    (r1 & up->port.ignore_status_mask) == 0)
+                        tty_insert_flip_char(tty, ch, flag);
+
+                if (r1 & Rx_OVR)
+                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
         next_char:
                 ch = readb(&channel->control);
                 ZSDELAY();
diff --git a/drivers/serial/m32r_sio.c b/drivers/serial/m32r_sio.c
index b0ecc7537ce5..b48066a64a7d 100644
--- a/drivers/serial/m32r_sio.c
+++ b/drivers/serial/m32r_sio.c
@@ -331,17 +331,12 @@ static _INLINE_ void receive_chars(struct uart_sio_port *up, int *status,
 {
         struct tty_struct *tty = up->port.info->tty;
         unsigned char ch;
+        unsigned char flag;
         int max_count = 256;
 
         do {
-                if (unlikely(tty->flip.count >= TTY_FLIPBUF_SIZE)) {
-                        tty->flip.work.func((void *)tty);
-                        if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                                return; // if TTY_DONT_FLIP is set
-                }
                 ch = sio_in(up, SIORXB);
-                *tty->flip.char_buf_ptr = ch;
-                *tty->flip.flag_buf_ptr = TTY_NORMAL;
+                flag = TTY_NORMAL;
                 up->port.icount.rx++;
 
                 if (unlikely(*status & (UART_LSR_BI | UART_LSR_PE |
@@ -380,30 +375,24 @@ static _INLINE_ void receive_chars(struct uart_sio_port *up, int *status,
 
                         if (*status & UART_LSR_BI) {
                                 DEBUG_INTR("handling break....");
-                                *tty->flip.flag_buf_ptr = TTY_BREAK;
+                                flag = TTY_BREAK;
                         } else if (*status & UART_LSR_PE)
-                                *tty->flip.flag_buf_ptr = TTY_PARITY;
+                                flag = TTY_PARITY;
                         else if (*status & UART_LSR_FE)
-                                *tty->flip.flag_buf_ptr = TTY_FRAME;
+                                flag = TTY_FRAME;
                 }
                 if (uart_handle_sysrq_char(&up->port, ch, regs))
                         goto ignore_char;
-                if ((*status & up->port.ignore_status_mask) == 0) {
-                        tty->flip.flag_buf_ptr++;
-                        tty->flip.char_buf_ptr++;
-                        tty->flip.count++;
-                }
-                if ((*status & UART_LSR_OE) &&
-                    tty->flip.count < TTY_FLIPBUF_SIZE) {
+                if ((*status & up->port.ignore_status_mask) == 0)
+                        tty_insert_flip_char(tty, ch, flag);
+
+                if (*status & UART_LSR_OE) {
                         /*
                          * Overrun is special, since it's reported
                          * immediately, and doesn't affect the current
                          * character.
                          */
-                        *tty->flip.flag_buf_ptr = TTY_OVERRUN;
-                        tty->flip.flag_buf_ptr++;
-                        tty->flip.char_buf_ptr++;
-                        tty->flip.count++;
+                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
                 }
         ignore_char:
                 *status = serial_in(up, UART_LSR);
diff --git a/drivers/serial/mcfserial.c b/drivers/serial/mcfserial.c
index 47f7404cb045..f2a51e61eec7 100644
--- a/drivers/serial/mcfserial.c
+++ b/drivers/serial/mcfserial.c
@@ -313,7 +313,7 @@ static inline void receive_chars(struct mcf_serial *info)
 {
         volatile unsigned char  *uartp;
         struct tty_struct       *tty = info->tty;
-        unsigned char           status, ch;
+        unsigned char           status, ch, flag;
 
         if (!tty)
                 return;
@@ -321,10 +321,6 @@ static inline void receive_chars(struct mcf_serial *info)
         uartp = info->addr;
 
         while ((status = uartp[MCFUART_USR]) & MCFUART_USR_RXREADY) {
-
-                if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                        break;
-
                 ch = uartp[MCFUART_URB];
                 info->stats.rx++;
 
@@ -335,29 +331,24 @@ static inline void receive_chars(struct mcf_serial *info)
                 }
 #endif
 
-                tty->flip.count++;
+                flag = TTY_NORMAL;
                 if (status & MCFUART_USR_RXERR) {
                         uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETERR;
                         if (status & MCFUART_USR_RXBREAK) {
                                 info->stats.rxbreak++;
-                                *tty->flip.flag_buf_ptr++ = TTY_BREAK;
+                                flag = TTY_BREAK;
                         } else if (status & MCFUART_USR_RXPARITY) {
                                 info->stats.rxparity++;
-                                *tty->flip.flag_buf_ptr++ = TTY_PARITY;
+                                flag = TTY_PARITY;
                         } else if (status & MCFUART_USR_RXOVERRUN) {
                                 info->stats.rxoverrun++;
-                                *tty->flip.flag_buf_ptr++ = TTY_OVERRUN;
+                                flag = TTY_OVERRUN;
                         } else if (status & MCFUART_USR_RXFRAMING) {
                                 info->stats.rxframing++;
-                                *tty->flip.flag_buf_ptr++ = TTY_FRAME;
-                        } else {
-                                /* This should never happen... */
-                                *tty->flip.flag_buf_ptr++ = 0;
+                                flag = TTY_FRAME;
                         }
-                } else {
-                        *tty->flip.flag_buf_ptr++ = 0;
                 }
-                *tty->flip.char_buf_ptr++ = ch;
+                tty_insert_flip_char(tty, ch, flag);
         }
 
         schedule_work(&tty->flip.work);
diff --git a/drivers/serial/mpc52xx_uart.c b/drivers/serial/mpc52xx_uart.c
index 1288d6203e94..61dd17d7bace 100644
--- a/drivers/serial/mpc52xx_uart.c
+++ b/drivers/serial/mpc52xx_uart.c
@@ -405,17 +405,13 @@ static inline int
 mpc52xx_uart_int_rx_chars(struct uart_port *port, struct pt_regs *regs)
 {
         struct tty_struct *tty = port->info->tty;
-        unsigned char ch;
+        unsigned char ch, flag;
         unsigned short status;
 
         /* While we can read, do so ! */
         while ( (status = in_be16(&PSC(port)->mpc52xx_psc_status)) &
                 MPC52xx_PSC_SR_RXRDY) {
 
-                /* If we are full, just stop reading */
-                if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                        break;
-                
                 /* Get the char */
                 ch = in_8(&PSC(port)->mpc52xx_psc_buffer_8);
 
@@ -428,45 +424,35 @@ mpc52xx_uart_int_rx_chars(struct uart_port *port, struct pt_regs *regs)
 #endif
 
                 /* Store it */
-                *tty->flip.char_buf_ptr = ch;
-                *tty->flip.flag_buf_ptr = 0;
+
+                flag = TTY_NORMAL;
                 port->icount.rx++;
         
                 if ( status & (MPC52xx_PSC_SR_PE |
                                MPC52xx_PSC_SR_FE |
-                               MPC52xx_PSC_SR_RB |
-                               MPC52xx_PSC_SR_OE) ) {
+                               MPC52xx_PSC_SR_RB) ) {
                         
                         if (status & MPC52xx_PSC_SR_RB) {
-                                *tty->flip.flag_buf_ptr = TTY_BREAK;
+                                flag = TTY_BREAK;
                                 uart_handle_break(port);
                         } else if (status & MPC52xx_PSC_SR_PE)
-                                *tty->flip.flag_buf_ptr = TTY_PARITY;
+                                flag = TTY_PARITY;
                         else if (status & MPC52xx_PSC_SR_FE)
-                                *tty->flip.flag_buf_ptr = TTY_FRAME;
-                        if (status & MPC52xx_PSC_SR_OE) {
-                                /*
-                                 * Overrun is special, since it's
-                                 * reported immediately, and doesn't
-                                 * affect the current character
-                                 */
-                                if (tty->flip.count < (TTY_FLIPBUF_SIZE-1)) {
-                                        tty->flip.flag_buf_ptr++;
-                                        tty->flip.char_buf_ptr++;
-                                        tty->flip.count++;
-                                }
-                                *tty->flip.flag_buf_ptr = TTY_OVERRUN;
-                        }
+                                flag = TTY_FRAME;
 
                         /* Clear error condition */
                         out_8(&PSC(port)->command,MPC52xx_PSC_RST_ERR_STAT);
 
                 }
-
-                tty->flip.char_buf_ptr++;
-                tty->flip.flag_buf_ptr++;
-                tty->flip.count++;
-
+                tty_insert_flip_char(tty, ch, flag);
+                if (status & MPC52xx_PSC_SR_OE) {
+                        /*
+                         * Overrun is special, since it's
+                         * reported immediately, and doesn't
+                         * affect the current character
+                         */
+                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                }
         }
 
         tty_flip_buffer_push(tty);
diff --git a/drivers/serial/mpsc.c b/drivers/serial/mpsc.c
index 8f83e4007ecd..0ca83ac31d07 100644
--- a/drivers/serial/mpsc.c
+++ b/drivers/serial/mpsc.c
@@ -769,12 +769,12 @@ mpsc_rx_intr(struct mpsc_port_info *pi, struct pt_regs *regs)
                 bytes_in = be16_to_cpu(rxre->bytecnt);
 
                 /* Following use of tty struct directly is deprecated */
-                if (unlikely((tty->flip.count + bytes_in) >= TTY_FLIPBUF_SIZE)){
+                if (unlikely(tty_buffer_request_room(tty, bytes_in) < bytes_in)) {
                         if (tty->low_latency)
                                 tty_flip_buffer_push(tty);
                         /*
-                         * If this failed then we will throw awa the bytes
-                         * but mst do so to clear interrupts.
+                         * If this failed then we will throw away the bytes
+                         * but must do so to clear interrupts.
                          */
                 }
 
diff --git a/drivers/serial/mux.c b/drivers/serial/mux.c
index 7633132a10aa..4e49168c3176 100644
--- a/drivers/serial/mux.c
+++ b/drivers/serial/mux.c
@@ -223,11 +223,6 @@ static void mux_read(struct uart_port *port)
                 if (MUX_EOFIFO(data))
                         break;
 
-                if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                        continue;
-
-                *tty->flip.char_buf_ptr = data & 0xffu;
-                *tty->flip.flag_buf_ptr = TTY_NORMAL;
                 port->icount.rx++;
 
                 if (MUX_BREAK(data)) {
@@ -239,9 +234,7 @@ static void mux_read(struct uart_port *port)
                 if (uart_handle_sysrq_char(port, data & 0xffu, NULL))
                         continue;
 
-                tty->flip.flag_buf_ptr++;
-                tty->flip.char_buf_ptr++;
-                tty->flip.count++;
+                tty_insert_flip_char(tty, data & 0xFF, TTY_NORMAL);
         }
         
         if (start_count != port->icount.rx) {
diff --git a/drivers/serial/pmac_zilog.c b/drivers/serial/pmac_zilog.c
index ea24129eb6b9..f330d6c0e0df 100644
--- a/drivers/serial/pmac_zilog.c
+++ b/drivers/serial/pmac_zilog.c
@@ -210,10 +210,9 @@ static struct tty_struct *pmz_receive_chars(struct uart_pmac_port *uap,
                                             struct pt_regs *regs)
 {
         struct tty_struct *tty = NULL;
-        unsigned char ch, r1, drop, error;
+        unsigned char ch, r1, drop, error, flag;
         int loops = 0;
 
- retry:
         /* The interrupt can be enabled when the port isn't open, typically
          * that happens when using one port is open and the other closed (stale
          * interrupt) or when one port is used as a console.
@@ -246,20 +245,6 @@ static struct tty_struct *pmz_receive_chars(struct uart_pmac_port *uap,
                 error = 0;
                 drop = 0;
 
-                if (unlikely(tty->flip.count >= TTY_FLIPBUF_SIZE)) {
-                        /* Have to drop the lock here */
-                        pmz_debug("pmz: flip overflow\n");
-                        spin_unlock(&uap->port.lock);
-                        tty->flip.work.func((void *)tty);
-                        spin_lock(&uap->port.lock);
-                        if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                                drop = 1;
-                        if (ZS_IS_ASLEEP(uap))
-                                return NULL;
-                        if (!ZS_IS_OPEN(uap))
-                                goto retry;
-                }
-
                 r1 = read_zsreg(uap, R1);
                 ch = read_zsdata(uap);
 
@@ -295,8 +280,7 @@ static struct tty_struct *pmz_receive_chars(struct uart_pmac_port *uap,
                 if (drop)
                         goto next_char;
 
-                *tty->flip.char_buf_ptr = ch;
-                *tty->flip.flag_buf_ptr = TTY_NORMAL;
+                flag = TTY_NORMAL;
                 uap->port.icount.rx++;
 
                 if (r1 & (PAR_ERR | Rx_OVR | CRC_ERR | BRK_ABRT)) {
@@ -316,26 +300,19 @@ static struct tty_struct *pmz_receive_chars(struct uart_pmac_port *uap,
                                 uap->port.icount.overrun++;
                         r1 &= uap->port.read_status_mask;
                         if (r1 & BRK_ABRT)
-                                *tty->flip.flag_buf_ptr = TTY_BREAK;
+                                flag = TTY_BREAK;
                         else if (r1 & PAR_ERR)
-                                *tty->flip.flag_buf_ptr = TTY_PARITY;
+                                flag = TTY_PARITY;
                         else if (r1 & CRC_ERR)
-                                *tty->flip.flag_buf_ptr = TTY_FRAME;
+                                flag = TTY_FRAME;
                 }
 
                 if (uap->port.ignore_status_mask == 0xff ||
                     (r1 & uap->port.ignore_status_mask) == 0) {
-                        tty->flip.flag_buf_ptr++;
-                        tty->flip.char_buf_ptr++;
-                        tty->flip.count++;
-                }
-                if ((r1 & Rx_OVR) &&
-                    tty->flip.count < TTY_FLIPBUF_SIZE) {
-                        *tty->flip.flag_buf_ptr = TTY_OVERRUN;
-                        tty->flip.flag_buf_ptr++;
-                        tty->flip.char_buf_ptr++;
-                        tty->flip.count++;
+                        tty_insert_flip_char(tty, ch, flag);
                 }
+                if (r1 & Rx_OVR)
+                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
         next_char:
                 /* We can get stuck in an infinite loop getting char 0 when the
                  * line is in a wrong HW state, we break that here.
diff --git a/drivers/serial/pxa.c b/drivers/serial/pxa.c
index cc998b99a19f..10535f00301f 100644
--- a/drivers/serial/pxa.c
+++ b/drivers/serial/pxa.c
@@ -107,14 +107,6 @@ receive_chars(struct uart_pxa_port *up, int *status, struct pt_regs *regs)
         int max_count = 256;
 
         do {
-                if (unlikely(tty->flip.count >= TTY_FLIPBUF_SIZE)) {
-                        if (tty->low_latency)
-                                tty_flip_buffer_push(tty);
-                        /*
-                         * If this failed then we will throw away the
-                         * bytes but must do so to clear interrupts
-                         */
-                }
                 ch = serial_in(up, UART_RX);
                 flag = TTY_NORMAL;
                 up->port.icount.rx++;
diff --git a/drivers/serial/s3c2410.c b/drivers/serial/s3c2410.c
index fe83ce6fef52..eb4883efb7c6 100644
--- a/drivers/serial/s3c2410.c
+++ b/drivers/serial/s3c2410.c
@@ -323,16 +323,6 @@ s3c24xx_serial_rx_chars(int irq, void *dev_id, struct pt_regs *regs)
                 if (s3c24xx_serial_rx_fifocnt(ourport, ufstat) == 0)
                         break;
 
-                if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                        if (tty->low_latency)
-                                tty_flip_buffer_push(tty);
-
-                        /*
-                         * If this failed then we will throw away the
-                         * bytes but must do so to clear interrupts
-                         */
-                }
-
                 uerstat = rd_regl(port, S3C2410_UERSTAT);
                 ch = rd_regb(port, S3C2410_URXH);
 
diff --git a/drivers/serial/sa1100.c b/drivers/serial/sa1100.c
index 25a086458ab9..1bd93168f504 100644
--- a/drivers/serial/sa1100.c
+++ b/drivers/serial/sa1100.c
@@ -201,8 +201,6 @@ sa1100_rx_chars(struct sa1100_port *sport, struct pt_regs *regs)
         while (status & UTSR1_TO_SM(UTSR1_RNE)) {
                 ch = UART_GET_CHAR(sport);
 
-                if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                        goto ignore_char;
                 sport->port.icount.rx++;
 
                 flg = TTY_NORMAL;
diff --git a/drivers/serial/serial_lh7a40x.c b/drivers/serial/serial_lh7a40x.c
index d01dbe5da3b9..d4a1f0e798c1 100644
--- a/drivers/serial/serial_lh7a40x.c
+++ b/drivers/serial/serial_lh7a40x.c
@@ -148,15 +148,6 @@ lh7a40xuart_rx_chars (struct uart_port* port)
         unsigned int data, flag;/* Received data and status */
 
         while (!(UR (port, UART_R_STATUS) & nRxRdy) && --cbRxMax) {
-                if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                        if (tty->low_latency)
-                                tty_flip_buffer_push(tty);
-                        /*
-                         * If this failed then we will throw away the
-                         * bytes but must do so to clear interrupts
-                         */
-                }
-
                 data = UR (port, UART_R_DATA);
                 flag = TTY_NORMAL;
                 ++port->icount.rx;
diff --git a/drivers/serial/serial_txx9.c b/drivers/serial/serial_txx9.c
index 995d9dd9ddd5..fdd1f1915a42 100644
--- a/drivers/serial/serial_txx9.c
+++ b/drivers/serial/serial_txx9.c
@@ -303,17 +303,6 @@ receive_chars(struct uart_txx9_port *up, unsigned int *status, struct pt_regs *r
         char flag;
 
         do {
-                /* The following is not allowed by the tty layer and
-                   unsafe. It should be fixed ASAP */
-                if (unlikely(tty->flip.count >= TTY_FLIPBUF_SIZE)) {
-                        if (tty->low_latency) {
-                                spin_unlock(&up->port.lock);
-                                tty_flip_buffer_push(tty);
-                                spin_lock(&up->port.lock);
-                        }
-                        /* If this failed then we will throw away the
-                           bytes but must do so to clear interrupts */
-                }
                 ch = sio_in(up, TXX9_SIRFIFO);
                 flag = TTY_NORMAL;
                 up->port.icount.rx++;
diff --git a/drivers/serial/sh-sci.c b/drivers/serial/sh-sci.c
index 430754ebac8a..a9e070759628 100644
--- a/drivers/serial/sh-sci.c
+++ b/drivers/serial/sh-sci.c
@@ -482,6 +482,7 @@ static inline void sci_receive_chars(struct uart_port *port,
         struct tty_struct *tty = port->info->tty;
         int i, count, copied = 0;
         unsigned short status;
+        unsigned char flag;
 
         status = sci_in(port, SCxSR);
         if (!(status & SCxSR_RDxF(port)))
@@ -499,8 +500,7 @@ static inline void sci_receive_chars(struct uart_port *port,
 #endif
 
                 /* Don't copy more bytes than there is room for in the buffer */
-                if (tty->flip.count + count > TTY_FLIPBUF_SIZE)
-                        count = TTY_FLIPBUF_SIZE - tty->flip.count;
+                count = tty_buffer_request_room(tty, count);
 
                 /* If for any reason we can't copy more data, we're done! */
                 if (count == 0)
@@ -512,8 +512,7 @@ static inline void sci_receive_chars(struct uart_port *port,
                             || uart_handle_sysrq_char(port, c, regs)) {
                                 count = 0;
                         } else {
-                            tty->flip.char_buf_ptr[0] = c;
-                            tty->flip.flag_buf_ptr[0] = TTY_NORMAL;
+                            tty_insert_flip_char(tty, c, TTY_NORMAL);
                         }
                 } else {
                         for (i=0; i<count; i++) {
@@ -542,26 +541,21 @@ static inline void sci_receive_chars(struct uart_port *port,
                                 }
 
                                 /* Store data and status */
-                                tty->flip.char_buf_ptr[i] = c;
                                 if (status&SCxSR_FER(port)) {
-                                        tty->flip.flag_buf_ptr[i] = TTY_FRAME;
+                                        flag = TTY_FRAME;
                                         pr_debug("sci: frame error\n");
                                 } else if (status&SCxSR_PER(port)) {
-                                        tty->flip.flag_buf_ptr[i] = TTY_PARITY;
+                                        flag = TTY_PARITY;
                                         pr_debug("sci: parity error\n");
-                                } else {
-                                        tty->flip.flag_buf_ptr[i] = TTY_NORMAL;
-                                }
+                                } else
+                                        flag = TTY_NORMAL;
+                                tty_insert_flip_char(tty, c, flag);
                         }
                 }
 
                 sci_in(port, SCxSR); /* dummy read */
                 sci_out(port, SCxSR, SCxSR_RDxF_CLEAR(port));
 
-                /* Update the kernel buffer end */
-                tty->flip.count += count;
-                tty->flip.char_buf_ptr += count;
-                tty->flip.flag_buf_ptr += count;
                 copied += count;
                 port->icount.rx += count;
         }
@@ -608,48 +602,45 @@ static inline int sci_handle_errors(struct uart_port *port)
         unsigned short status = sci_in(port, SCxSR);
         struct tty_struct *tty = port->info->tty;
 
-        if (status&SCxSR_ORER(port) && tty->flip.count<TTY_FLIPBUF_SIZE) {
+        if (status&SCxSR_ORER(port)) {
                 /* overrun error */
-                copied++;
-                *tty->flip.flag_buf_ptr++ = TTY_OVERRUN;
+                if(tty_insert_flip_char(tty, 0, TTY_OVERRUN))
+                        copied++;
                 pr_debug("sci: overrun error\n");
         }
 
-        if (status&SCxSR_FER(port) && tty->flip.count<TTY_FLIPBUF_SIZE) {
+        if (status&SCxSR_FER(port)) {
                 if (sci_rxd_in(port) == 0) {
                         /* Notify of BREAK */
                         struct sci_port * sci_port = (struct sci_port *)port;
-                       if(!sci_port->break_flag) {
-                                sci_port->break_flag = 1;
-                               sci_schedule_break_timer((struct sci_port *)port);
+                        if(!sci_port->break_flag) {
+                                sci_port->break_flag = 1;
+                                sci_schedule_break_timer((struct sci_port *)port);
                                 /* Do sysrq handling. */
-                                if(uart_handle_break(port)) {
+                                if(uart_handle_break(port))
                                         return 0;
-                                }
                                 pr_debug("sci: BREAK detected\n");
-                                copied++;
-                                *tty->flip.flag_buf_ptr++ = TTY_BREAK;
+                                if(tty_insert_flip_char(tty, 0, TTY_BREAK))
+                                        copied++;
                        }
                 }
                 else {
                         /* frame error */
-                        copied++;
-                        *tty->flip.flag_buf_ptr++ = TTY_FRAME;
+                        if(tty_insert_flip_char(tty, 0, TTY_FRAME))
+                                copied++;
                         pr_debug("sci: frame error\n");
                 }
         }
 
-        if (status&SCxSR_PER(port) && tty->flip.count<TTY_FLIPBUF_SIZE) {
+        if (status&SCxSR_PER(port)) {
+                if(tty_insert_flip_char(tty, 0, TTY_PARITY))
+                        copied++;
                 /* parity error */
-                copied++;
-                *tty->flip.flag_buf_ptr++ = TTY_PARITY;
                 pr_debug("sci: parity error\n");
         }
 
-        if (copied) {
-                tty->flip.count += copied;
+        if (copied)
                 tty_flip_buffer_push(tty);
-        }
 
         return copied;
 }
@@ -661,15 +652,14 @@ static inline int sci_handle_breaks(struct uart_port *port)
         struct tty_struct *tty = port->info->tty;
         struct sci_port *s = &sci_ports[port->line];
 
-        if (!s->break_flag && status & SCxSR_BRK(port) &&
-            tty->flip.count < TTY_FLIPBUF_SIZE) {
+        if (!s->break_flag && status & SCxSR_BRK(port))
 #if defined(CONFIG_CPU_SH3)
                 /* Debounce break */
                 s->break_flag = 1;
 #endif
                 /* Notify of BREAK */
-                copied++;
-                *tty->flip.flag_buf_ptr++ = TTY_BREAK;
+                if(tty_insert_flip_char(tty, 0, TTY_BREAK))
+                        copied++;
                 pr_debug("sci: BREAK detected\n");
         }
 
@@ -677,19 +667,15 @@ static inline int sci_handle_breaks(struct uart_port *port)
         /* XXX: Handle SCIF overrun error */
         if (port->type == PORT_SCIF && (sci_in(port, SCLSR) & SCIF_ORER) != 0) {
                 sci_out(port, SCLSR, 0);
-                if(tty->flip.count<TTY_FLIPBUF_SIZE) {
+                if(tty_insert_flip_char(tty, 0, TTY_OVERRUN)) {
                         copied++;
-                        *tty->flip.flag_buf_ptr++ = TTY_OVERRUN;
                         pr_debug("sci: overrun error\n");
                 }
         }
 #endif
 
-        if (copied) {
-                tty->flip.count += copied;
+        if (copied)
                 tty_flip_buffer_push(tty);
-        }
-
         return copied;
 }
 
@@ -732,12 +718,9 @@ static irqreturn_t sci_er_interrupt(int irq, void *ptr, struct pt_regs *regs)
                         struct tty_struct *tty = port->info->tty;
 
                         sci_out(port, SCLSR, 0);
-                        if(tty->flip.count<TTY_FLIPBUF_SIZE) {
-                                *tty->flip.flag_buf_ptr++ = TTY_OVERRUN;
-                                tty->flip.count++;
-                                tty_flip_buffer_push(tty);
-                                pr_debug("scif: overrun error\n");
-                        }
+                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                        tty_flip_buffer_push(tty);
+                        pr_debug("scif: overrun error\n");
                 }
 #endif
                 sci_rx_interrupt(irq, ptr, regs);
diff --git a/drivers/serial/sn_console.c b/drivers/serial/sn_console.c
index 313f9df24a2d..5468e5a767e2 100644
--- a/drivers/serial/sn_console.c
+++ b/drivers/serial/sn_console.c
@@ -519,11 +519,7 @@ sn_receive_chars(struct sn_cons_port *port, struct pt_regs *regs,
 
                 /* record the character to pass up to the tty layer */
                 if (tty) {
-                        *tty->flip.char_buf_ptr = ch;
-                        *tty->flip.flag_buf_ptr = TTY_NORMAL;
-                        tty->flip.char_buf_ptr++;
-                        tty->flip.count++;
-                        if (tty->flip.count == TTY_FLIPBUF_SIZE)
+                        if(tty_insert_flip_char(tty, ch, TTY_NORMAL) == 0)
                                 break;
                 }
                 port->sc_port.icount.rx++;
diff --git a/drivers/serial/sunsab.c b/drivers/serial/sunsab.c
index ba9381fd3f2d..7e773ff76c61 100644
--- a/drivers/serial/sunsab.c
+++ b/drivers/serial/sunsab.c
@@ -159,21 +159,14 @@ receive_chars(struct uart_sunsab_port *up,
                 saw_console_brk = 1;
 
         for (i = 0; i < count; i++) {
-                unsigned char ch = buf[i];
+                unsigned char ch = buf[i], flag;
 
                 if (tty == NULL) {
                         uart_handle_sysrq_char(&up->port, ch, regs);
                         continue;
                 }
 
-                if (unlikely(tty->flip.count >= TTY_FLIPBUF_SIZE)) {
-                        tty->flip.work.func((void *)tty);
-                        if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                                return tty; // if TTY_DONT_FLIP is set
-                }
-
-                *tty->flip.char_buf_ptr = ch;
-                *tty->flip.flag_buf_ptr = TTY_NORMAL;
+                flag = TTY_NORMAL;
                 up->port.icount.rx++;
 
                 if (unlikely(stat->sreg.isr0 & (SAB82532_ISR0_PERR |
@@ -209,34 +202,21 @@ receive_chars(struct uart_sunsab_port *up,
                         stat->sreg.isr1 &= ((up->port.read_status_mask >> 8) & 0xff);
 
                         if (stat->sreg.isr1 & SAB82532_ISR1_BRK) {
-                                *tty->flip.flag_buf_ptr = TTY_BREAK;
+                                flag = TTY_BREAK;
                         } else if (stat->sreg.isr0 & SAB82532_ISR0_PERR)
-                                *tty->flip.flag_buf_ptr = TTY_PARITY;
+                                flag = TTY_PARITY;
                         else if (stat->sreg.isr0 & SAB82532_ISR0_FERR)
-                                *tty->flip.flag_buf_ptr = TTY_FRAME;
+                                flag = TTY_FRAME;
                 }
 
                 if (uart_handle_sysrq_char(&up->port, ch, regs))
                         continue;
 
                 if ((stat->sreg.isr0 & (up->port.ignore_status_mask & 0xff)) == 0 &&
-                    (stat->sreg.isr1 & ((up->port.ignore_status_mask >> 8) & 0xff)) == 0){
-                        tty->flip.flag_buf_ptr++;
-                        tty->flip.char_buf_ptr++;
-                        tty->flip.count++;
-                }
-                if ((stat->sreg.isr0 & SAB82532_ISR0_RFO) &&
-                    tty->flip.count < TTY_FLIPBUF_SIZE) {
-                        /*
-                         * Overrun is special, since it's reported
-                         * immediately, and doesn't affect the current
-                         * character.
-                         */
-                        *tty->flip.flag_buf_ptr = TTY_OVERRUN;
-                        tty->flip.flag_buf_ptr++;
-                        tty->flip.char_buf_ptr++;
-                        tty->flip.count++;
-                }
+                    (stat->sreg.isr1 & ((up->port.ignore_status_mask >> 8) & 0xff)) == 0)
+                        tty_insert_flip_char(tty, ch, flag);
+                if (stat->sreg.isr0 & SAB82532_ISR0_RFO)
+                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
         }
 
         if (saw_console_brk)
diff --git a/drivers/serial/sunsu.c b/drivers/serial/sunsu.c
index f0738533f39a..9a3665b34d97 100644
--- a/drivers/serial/sunsu.c
+++ b/drivers/serial/sunsu.c
@@ -323,19 +323,13 @@ static _INLINE_ struct tty_struct *
 receive_chars(struct uart_sunsu_port *up, unsigned char *status, struct pt_regs *regs)
 {
         struct tty_struct *tty = up->port.info->tty;
-        unsigned char ch;
+        unsigned char ch, flag;
         int max_count = 256;
         int saw_console_brk = 0;
 
         do {
-                if (unlikely(tty->flip.count >= TTY_FLIPBUF_SIZE)) {
-                        tty->flip.work.func((void *)tty);
-                        if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                                return tty; // if TTY_DONT_FLIP is set
-                }
                 ch = serial_inp(up, UART_RX);
-                *tty->flip.char_buf_ptr = ch;
-                *tty->flip.flag_buf_ptr = TTY_NORMAL;
+                flag = TTY_NORMAL;
                 up->port.icount.rx++;
 
                 if (unlikely(*status & (UART_LSR_BI | UART_LSR_PE |
@@ -377,31 +371,23 @@ receive_chars(struct uart_sunsu_port *up, unsigned char *status, struct pt_regs
                         }
 
                         if (*status & UART_LSR_BI) {
-                                *tty->flip.flag_buf_ptr = TTY_BREAK;
+                                flag = TTY_BREAK;
                         } else if (*status & UART_LSR_PE)
-                                *tty->flip.flag_buf_ptr = TTY_PARITY;
+                                flag = TTY_PARITY;
                         else if (*status & UART_LSR_FE)
-                                *tty->flip.flag_buf_ptr = TTY_FRAME;
+                                flag = TTY_FRAME;
                 }
                 if (uart_handle_sysrq_char(&up->port, ch, regs))
                         goto ignore_char;
-                if ((*status & up->port.ignore_status_mask) == 0) {
-                        tty->flip.flag_buf_ptr++;
-                        tty->flip.char_buf_ptr++;
-                        tty->flip.count++;
-                }
-                if ((*status & UART_LSR_OE) &&
-                    tty->flip.count < TTY_FLIPBUF_SIZE) {
+                if ((*status & up->port.ignore_status_mask) == 0)
+                        tty_insert_flip_char(tty, ch, flag);
+                if (*status & UART_LSR_OE)
                         /*
                          * Overrun is special, since it's reported
                          * immediately, and doesn't affect the current
                          * character.
                          */
-                        *tty->flip.flag_buf_ptr = TTY_OVERRUN;
-                        tty->flip.flag_buf_ptr++;
-                        tty->flip.char_buf_ptr++;
-                        tty->flip.count++;
-                }
+                         tty_insert_flip_char(tty, 0, TTY_OVERRUN);
         ignore_char:
                 *status = serial_inp(up, UART_LSR);
         } while ((*status & UART_LSR_DR) && (max_count-- > 0));
diff --git a/drivers/serial/sunzilog.c b/drivers/serial/sunzilog.c
index 7653d6cf05af..3c72484adea7 100644
--- a/drivers/serial/sunzilog.c
+++ b/drivers/serial/sunzilog.c
@@ -319,7 +319,7 @@ sunzilog_receive_chars(struct uart_sunzilog_port *up,
                        struct pt_regs *regs)
 {
         struct tty_struct *tty;
-        unsigned char ch, r1;
+        unsigned char ch, r1, flag;
 
         tty = NULL;
         if (up->port.info != NULL &&            /* Unopened serial console */
@@ -362,19 +362,8 @@ sunzilog_receive_chars(struct uart_sunzilog_port *up,
                         continue;
                 }
 
-                if (unlikely(tty->flip.count >= TTY_FLIPBUF_SIZE)) {
-                        tty->flip.work.func((void *)tty);
-                        /*
-                         * The 8250 bails out of the loop here,
-                         * but we need to read everything, or die.
-                         */
-                        if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                                continue;
-                }
-
                 /* A real serial line, record the character and status.  */
-                *tty->flip.char_buf_ptr = ch;
-                *tty->flip.flag_buf_ptr = TTY_NORMAL;
+                flag = TTY_NORMAL;
                 up->port.icount.rx++;
                 if (r1 & (BRK_ABRT | PAR_ERR | Rx_OVR | CRC_ERR)) {
                         if (r1 & BRK_ABRT) {
@@ -391,28 +380,21 @@ sunzilog_receive_chars(struct uart_sunzilog_port *up,
                                 up->port.icount.overrun++;
                         r1 &= up->port.read_status_mask;
                         if (r1 & BRK_ABRT)
-                                *tty->flip.flag_buf_ptr = TTY_BREAK;
+                                flag = TTY_BREAK;
                         else if (r1 & PAR_ERR)
-                                *tty->flip.flag_buf_ptr = TTY_PARITY;
+                                flag = TTY_PARITY;
                         else if (r1 & CRC_ERR)
-                                *tty->flip.flag_buf_ptr = TTY_FRAME;
+                                flag = TTY_FRAME;
                 }
                 if (uart_handle_sysrq_char(&up->port, ch, regs))
                         continue;
 
                 if (up->port.ignore_status_mask == 0xff ||
                     (r1 & up->port.ignore_status_mask) == 0) {
-                        tty->flip.flag_buf_ptr++;
-                        tty->flip.char_buf_ptr++;
-                        tty->flip.count++;
-                }
-                if ((r1 & Rx_OVR) &&
-                    tty->flip.count < TTY_FLIPBUF_SIZE) {
-                        *tty->flip.flag_buf_ptr = TTY_OVERRUN;
-                        tty->flip.flag_buf_ptr++;
-                        tty->flip.char_buf_ptr++;
-                        tty->flip.count++;
+                        tty_insert_flip_char(tty, ch, flag);
                 }
+                if (r1 & Rx_OVR)
+                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
         }
 
         return tty;
diff --git a/drivers/serial/vr41xx_siu.c b/drivers/serial/vr41xx_siu.c
index 865d4dea65df..0a28deeb098d 100644
--- a/drivers/serial/vr41xx_siu.c
+++ b/drivers/serial/vr41xx_siu.c
@@ -371,11 +371,6 @@ static inline void receive_chars(struct uart_port *port, uint8_t *status,
         lsr = *status;
 
         do {
-                if (unlikely(tty->flip.count >= TTY_FLIPBUF_SIZE)) {
-                        if (tty->low_latency)
-                                tty_flip_buffer_push(tty);
-                }
-
                 ch = siu_read(port, UART_RX);
                 port->icount.rx++;
                 flag = TTY_NORMAL;
diff --git a/drivers/usb/atm/speedtch.c b/drivers/usb/atm/speedtch.c
index b28336148658..c1b47d74e206 100644
--- a/drivers/usb/atm/speedtch.c
+++ b/drivers/usb/atm/speedtch.c
@@ -532,9 +532,9 @@ static void speedtch_handle_int(struct urb *int_urb, struct pt_regs *regs)
         int ret = int_urb->status;
 
         /* The magic interrupt for "up state" */
-        const static unsigned char up_int[6]   = { 0xa1, 0x00, 0x01, 0x00, 0x00, 0x00 };
+        static const unsigned char up_int[6]   = { 0xa1, 0x00, 0x01, 0x00, 0x00, 0x00 };
         /* The magic interrupt for "down state" */
-        const static unsigned char down_int[6] = { 0xa1, 0x00, 0x00, 0x00, 0x00, 0x00 };
+        static const unsigned char down_int[6] = { 0xa1, 0x00, 0x00, 0x00, 0x00, 0x00 };
 
         atm_dbg(usbatm, "%s entered\n", __func__);
 
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index 248279e44c99..b9fd39fd1b5b 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -335,14 +335,9 @@ next_buffer:
 
         dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d\n", buf, buf->size);
 
-        for (i = 0; i < buf->size && !acm->throttle; i++) {
-                /* if we insert more than TTY_FLIPBUF_SIZE characters,
-                   we drop them. */
-                if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                        tty_flip_buffer_push(tty);
-                }
-                tty_insert_flip_char(tty, buf->base[i], 0);
-        }
+        tty_buffer_request_room(tty, buf->size);
+        if (!acm->throttle)
+                tty_insert_flip_string(tty, buf->base, buf->size);
         tty_flip_buffer_push(tty);
 
         spin_lock(&acm->throttle_lock);
diff --git a/drivers/usb/gadget/serial.c b/drivers/usb/gadget/serial.c
index 65e084a2c87e..2e6926b33455 100644
--- a/drivers/usb/gadget/serial.c
+++ b/drivers/usb/gadget/serial.c
@@ -1271,6 +1271,7 @@ static int gs_recv_packet(struct gs_dev *dev, char *packet, unsigned int size)
         unsigned int len;
         struct gs_port *port;
         int ret;
+        struct tty_struct *tty;
 
         /* TEMPORARY -- only port 0 is supported right now */
         port = dev->dev_port[0];
@@ -1290,7 +1291,10 @@ static int gs_recv_packet(struct gs_dev *dev, char *packet, unsigned int size)
                 goto exit;
         }
 
-        if (port->port_tty == NULL) {
+
+        tty = port->port_tty;
+
+        if (tty == NULL) {
                 printk(KERN_ERR "gs_recv_packet: port=%d, NULL tty pointer\n",
                         port->port_num);
                 ret = -EIO;
@@ -1304,20 +1308,13 @@ static int gs_recv_packet(struct gs_dev *dev, char *packet, unsigned int size)
                 goto exit;
         }
 
-        len = (unsigned int)(TTY_FLIPBUF_SIZE - port->port_tty->flip.count);
-        if (len < size)
-                size = len;
-
-        if (size > 0) {
-                memcpy(port->port_tty->flip.char_buf_ptr, packet, size);
-                port->port_tty->flip.char_buf_ptr += size;
-                port->port_tty->flip.count += size;
+        len = tty_buffer_request_room(tty, size);
+        if (len > 0) {
+                tty_insert_flip_string(tty, packet, len);
                 tty_flip_buffer_push(port->port_tty);
                 wake_up_interruptible(&port->port_tty->read_wait);
         }
-
         ret = 0;
-
 exit:
         spin_unlock(&port->port_lock);
         return ret;
diff --git a/drivers/usb/image/microtek.c b/drivers/usb/image/microtek.c
index 458f2acdeb0a..28538db9eaf3 100644
--- a/drivers/usb/image/microtek.c
+++ b/drivers/usb/image/microtek.c
@@ -674,7 +674,7 @@ struct vendor_product
 
 
 /* These are taken from the msmUSB.inf file on the Windows driver CD */
-const static struct vendor_product mts_supported_products[] =
+static const struct vendor_product mts_supported_products[] =
 {
         { "Phantom 336CX",      mts_sup_unknown},
         { "Phantom 336CX",      mts_sup_unknown},
diff --git a/drivers/usb/serial/Kconfig b/drivers/usb/serial/Kconfig
index 14f55fd26a64..be5dc80836c3 100644
--- a/drivers/usb/serial/Kconfig
+++ b/drivers/usb/serial/Kconfig
@@ -84,7 +84,7 @@ config USB_SERIAL_BELKIN
 
 config USB_SERIAL_WHITEHEAT
         tristate "USB ConnectTech WhiteHEAT Serial Driver"
-        depends on USB_SERIAL && BROKEN_ON_SMP
+        depends on USB_SERIAL
         help
           Say Y here if you want to use a ConnectTech WhiteHEAT 4 port
           USB to serial converter device.
diff --git a/drivers/usb/serial/cyberjack.c b/drivers/usb/serial/cyberjack.c
index 6d18d4eaba35..2357b1d102d7 100644
--- a/drivers/usb/serial/cyberjack.c
+++ b/drivers/usb/serial/cyberjack.c
@@ -364,7 +364,6 @@ static void cyberjack_read_bulk_callback (struct urb *urb, struct pt_regs *regs)
         struct tty_struct *tty;
         unsigned char *data = urb->transfer_buffer;
         short todo;
-        int i;
         int result;
 
         dbg("%s - port %d", __FUNCTION__, port->number);
@@ -381,14 +380,8 @@ static void cyberjack_read_bulk_callback (struct urb *urb, struct pt_regs *regs)
                 return;
         }
         if (urb->actual_length) {
-                for (i = 0; i < urb->actual_length ; ++i) {
-                        /* if we insert more than TTY_FLIPBUF_SIZE characters, we drop them. */
-                        if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                                tty_flip_buffer_push(tty);
-                        }
-                        /* this doesn't actually push the data through unless tty->low_latency is set */
-                        tty_insert_flip_char(tty, data[i], 0);
-                }
+                tty_buffer_request_room(tty, urb->actual_length);
+                tty_insert_flip_string(tty, data, urb->actual_length);
                 tty_flip_buffer_push(tty);
         }
 
diff --git a/drivers/usb/serial/cypress_m8.c b/drivers/usb/serial/cypress_m8.c
index 4e9637eb6137..68067fe117a4 100644
--- a/drivers/usb/serial/cypress_m8.c
+++ b/drivers/usb/serial/cypress_m8.c
@@ -1263,12 +1263,10 @@ static void cypress_read_int_callback(struct urb *urb, struct pt_regs *regs)
 
         /* process read if there is data other than line status */
         if (tty && (bytes > i)) {
+                bytes = tty_buffer_request_room(tty, bytes);
                 for (; i < bytes ; ++i) {
                         dbg("pushing byte number %d - %d - %c", i, data[i],
                                         data[i]);
-                        if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                                tty_flip_buffer_push(tty);
-                        }
                         tty_insert_flip_char(tty, data[i], tty_flag);
                 }
                 tty_flip_buffer_push(port->tty);
diff --git a/drivers/usb/serial/digi_acceleport.c b/drivers/usb/serial/digi_acceleport.c
index 8fc414bd5b24..b3f776a90c93 100644
--- a/drivers/usb/serial/digi_acceleport.c
+++ b/drivers/usb/serial/digi_acceleport.c
@@ -946,13 +946,10 @@ dbg( "digi_rx_unthrottle: TOP: port=%d", priv->dp_port_num );
         spin_lock_irqsave( &priv->dp_port_lock, flags );
 
         /* send any buffered chars from throttle time on to tty subsystem */
-        len = min(priv->dp_in_buf_len, TTY_FLIPBUF_SIZE - tty->flip.count );
+
+        len = tty_buffer_request_room(tty, priv->dp_in_buf_len);
         if( len > 0 ) {
-                memcpy( tty->flip.char_buf_ptr, priv->dp_in_buf, len );
-                memcpy( tty->flip.flag_buf_ptr, priv->dp_in_flag_buf, len );
-                tty->flip.char_buf_ptr += len;
-                tty->flip.flag_buf_ptr += len;
-                tty->flip.count += len;
+                tty_insert_flip_string_flags(tty, priv->dp_in_buf, priv->dp_in_flag_buf, len);
                 tty_flip_buffer_push( tty );
         }
 
@@ -1827,6 +1824,7 @@ static int digi_read_inb_callback( struct urb *urb )
         int status = ((unsigned char *)urb->transfer_buffer)[2];
         unsigned char *data = ((unsigned char *)urb->transfer_buffer)+3;
         int flag,throttled;
+        int i;
 
         /* do not process callbacks on closed ports */
         /* but do continue the read chain */
@@ -1885,20 +1883,18 @@ static int digi_read_inb_callback( struct urb *urb )
                         }
 
                 } else {
-
-                        len = min( len, TTY_FLIPBUF_SIZE - tty->flip.count );
-
+                        len = tty_buffer_request_room(tty, len);
                         if( len > 0 ) {
-                                memcpy( tty->flip.char_buf_ptr, data, len );
-                                memset( tty->flip.flag_buf_ptr, flag, len );
-                                tty->flip.char_buf_ptr += len;
-                                tty->flip.flag_buf_ptr += len;
-                                tty->flip.count += len;
+                                /* Hot path */
+                                if(flag == TTY_NORMAL)
+                                        tty_insert_flip_string(tty, data, len);
+                                else {
+                                        for(i = 0; i < len; i++)
+                                                tty_insert_flip_char(tty, data[i], flag);
+                                }
                                 tty_flip_buffer_push( tty );
                         }
-
                 }
-
         }
 
         spin_unlock( &priv->dp_port_lock );
diff --git a/drivers/usb/serial/empeg.c b/drivers/usb/serial/empeg.c
index 79a766e9ca23..63f7c78a1152 100644
--- a/drivers/usb/serial/empeg.c
+++ b/drivers/usb/serial/empeg.c
@@ -344,7 +344,6 @@ static void empeg_read_bulk_callback (struct urb *urb, struct pt_regs *regs)
         struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
         struct tty_struct *tty;
         unsigned char *data = urb->transfer_buffer;
-        int i;
         int result;
 
         dbg("%s - port %d", __FUNCTION__, port->number);
@@ -359,19 +358,8 @@ static void empeg_read_bulk_callback (struct urb *urb, struct pt_regs *regs)
         tty = port->tty;
 
         if (urb->actual_length) {
-                for (i = 0; i < urb->actual_length ; ++i) {
-                        /* gb - 2000/11/13
-                         * If we insert too many characters we'll overflow the buffer.
-                         * This means we'll lose bytes - Decidedly bad.
-                         */
-                        if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                                tty_flip_buffer_push(tty);
-                                }
-                        tty_insert_flip_char(tty, data[i], 0);
-                }
-                /* gb - 2000/11/13
-                 * Goes straight through instead of scheduling - if tty->low_latency is set.
-                 */
+                tty_buffer_request_room(tty, urb->actual_length);
+                tty_insert_flip_string(tty, data, urb->actual_length);
                 tty_flip_buffer_push(tty);
                 bytes_in += urb->actual_length;
         }
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index eb863b3f2d79..10bc1bf23b35 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -1610,24 +1610,11 @@ static void ftdi_process_read (void *param)
                         length = 0;
                 }
 
-                /* have to make sure we don't overflow the buffer
-                   with tty_insert_flip_char's */
-                if (tty->flip.count+length > TTY_FLIPBUF_SIZE) {
-                        tty_flip_buffer_push(tty);
-                        need_flip = 0;
-
-                        if (tty->flip.count != 0) {
-                                /* flip didn't work, this happens when ftdi_process_read() is
-                                 * called from ftdi_unthrottle, because TTY_DONT_FLIP is set */
-                                dbg("%s - flip buffer push failed", __FUNCTION__);
-                                break;
-                        }
-                }
                 if (priv->rx_flags & THROTTLED) {
                         dbg("%s - throttled", __FUNCTION__);
                         break;
                 }
-                if (tty->ldisc.receive_room(tty)-tty->flip.count < length) {
+                if (tty_buffer_request_room(tty, length) < length) {
                         /* break out & wait for throttling/unthrottling to happen */
                         dbg("%s - receive room low", __FUNCTION__);
                         break;
diff --git a/drivers/usb/serial/garmin_gps.c b/drivers/usb/serial/garmin_gps.c
index 452efce72714..d6f55e9dccae 100644
--- a/drivers/usb/serial/garmin_gps.c
+++ b/drivers/usb/serial/garmin_gps.c
@@ -275,23 +275,14 @@ static void send_to_tty(struct usb_serial_port *port,
                         char *data, unsigned int actual_length)
 {
         struct tty_struct *tty = port->tty;
-        int i;
 
         if (tty && actual_length) {
 
                 usb_serial_debug_data(debug, &port->dev, 
                                         __FUNCTION__, actual_length, data);
 
-                for (i = 0; i < actual_length ; ++i) {
-                        /* if we insert more than TTY_FLIPBUF_SIZE characters,
-                           we drop them. */
-                        if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                                tty_flip_buffer_push(tty);
-                        }
-                        /* this doesn't actually push the data through unless
-                           tty->low_latency is set */
-                        tty_insert_flip_char(tty, data[i], 0);
-                }
+                tty_buffer_request_room(tty, actual_length);
+                tty_insert_flip_string(tty, data, actual_length);
                 tty_flip_buffer_push(tty);
         }
 }
diff --git a/drivers/usb/serial/generic.c b/drivers/usb/serial/generic.c
index 4ddac620fc0c..476cda107f4f 100644
--- a/drivers/usb/serial/generic.c
+++ b/drivers/usb/serial/generic.c
@@ -254,7 +254,6 @@ void usb_serial_generic_read_bulk_callback (struct urb *urb, struct pt_regs *reg
         struct usb_serial *serial = port->serial;
         struct tty_struct *tty;
         unsigned char *data = urb->transfer_buffer;
-        int i;
         int result;
 
         dbg("%s - port %d", __FUNCTION__, port->number);
@@ -268,14 +267,8 @@ void usb_serial_generic_read_bulk_callback (struct urb *urb, struct pt_regs *reg
 
         tty = port->tty;
         if (tty && urb->actual_length) {
-                for (i = 0; i < urb->actual_length ; ++i) {
-                        /* if we insert more than TTY_FLIPBUF_SIZE characters, we drop them. */
-                        if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                                tty_flip_buffer_push(tty);
-                        }
-                        /* this doesn't actually push the data through unless tty->low_latency is set */
-                        tty_insert_flip_char(tty, data[i], 0);
-                }
+                tty_buffer_request_room(tty, urb->actual_length);
+                tty_insert_flip_string(tty, data, urb->actual_length);
                 tty_flip_buffer_push(tty);
         }
 
diff --git a/drivers/usb/serial/io_edgeport.c b/drivers/usb/serial/io_edgeport.c
index faedbeb6ba49..3f29e6b0fd19 100644
--- a/drivers/usb/serial/io_edgeport.c
+++ b/drivers/usb/serial/io_edgeport.c
@@ -1965,20 +1965,14 @@ static void edge_tty_recv(struct device *dev, struct tty_struct *tty, unsigned c
         int cnt;
 
         do {
-                if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                        tty_flip_buffer_push(tty);
-                        if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                                dev_err(dev, "%s - dropping data, %d bytes lost\n",
-                                        __FUNCTION__, length);
-                                return;
-                        }
+                cnt = tty_buffer_request_room(tty, length);
+                if (cnt < length) {
+                        dev_err(dev, "%s - dropping data, %d bytes lost\n",
+                                        __FUNCTION__, length - cnt);
+                        if(cnt == 0)
+                                break;
                 }
-                cnt = min(length, TTY_FLIPBUF_SIZE - tty->flip.count);
-                memcpy(tty->flip.char_buf_ptr, data, cnt);
-                memset(tty->flip.flag_buf_ptr, 0, cnt);
-                tty->flip.char_buf_ptr += cnt;
-                tty->flip.flag_buf_ptr += cnt;
-                tty->flip.count += cnt;
+                tty_insert_flip_string(tty, data, cnt);
                 data += cnt;
                 length -= cnt;
         } while (length > 0);
diff --git a/drivers/usb/serial/io_ti.c b/drivers/usb/serial/io_ti.c
index 2edf9cabad20..afc0f34b3a46 100644
--- a/drivers/usb/serial/io_ti.c
+++ b/drivers/usb/serial/io_ti.c
@@ -1865,20 +1865,14 @@ static void edge_tty_recv(struct device *dev, struct tty_struct *tty, unsigned c
         int cnt;
 
         do {
-                if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                        tty_flip_buffer_push(tty);
-                        if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                                dev_err(dev, "%s - dropping data, %d bytes lost\n",
-                                        __FUNCTION__, length);
-                                return;
-                        }
+                cnt = tty_buffer_request_room(tty, length);
+                if (cnt < length) {
+                        dev_err(dev, "%s - dropping data, %d bytes lost\n",
+                                __FUNCTION__, length - cnt);
+                        if(cnt == 0)
+                                break;
                 }
-                cnt = min(length, TTY_FLIPBUF_SIZE - tty->flip.count);
-                memcpy(tty->flip.char_buf_ptr, data, cnt);
-                memset(tty->flip.flag_buf_ptr, 0, cnt);
-                tty->flip.char_buf_ptr += cnt;
-                tty->flip.flag_buf_ptr += cnt;
-                tty->flip.count += cnt;
+                tty_insert_flip_string(tty, data, cnt);
                 data += cnt;
                 length -= cnt;
         } while (length > 0);
diff --git a/drivers/usb/serial/ipaq.c b/drivers/usb/serial/ipaq.c
index 06d07cea0b70..9a5c97989562 100644
--- a/drivers/usb/serial/ipaq.c
+++ b/drivers/usb/serial/ipaq.c
@@ -711,7 +711,7 @@ static void ipaq_read_bulk_callback(struct urb *urb, struct pt_regs *regs)
         struct usb_serial_port  *port = (struct usb_serial_port *)urb->context;
         struct tty_struct       *tty;
         unsigned char           *data = urb->transfer_buffer;
-        int                     i, result;
+        int                     result;
 
         dbg("%s - port %d", __FUNCTION__, port->number);
 
@@ -724,14 +724,8 @@ static void ipaq_read_bulk_callback(struct urb *urb, struct pt_regs *regs)
 
         tty = port->tty;
         if (tty && urb->actual_length) {
-                for (i = 0; i < urb->actual_length ; ++i) {
-                        /* if we insert more than TTY_FLIPBUF_SIZE characters, we drop them. */
-                        if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                                tty_flip_buffer_push(tty);
-                        }
-                        /* this doesn't actually push the data through unless tty->low_latency is set */
-                        tty_insert_flip_char(tty, data[i], 0);
-                }
+                tty_buffer_request_room(tty, urb->actual_length);
+                tty_insert_flip_string(tty, data, urb->actual_length);
                 tty_flip_buffer_push(tty);
                 bytes_in += urb->actual_length;
         }
diff --git a/drivers/usb/serial/ipw.c b/drivers/usb/serial/ipw.c
index 2dd191f5fe76..e760a70242c1 100644
--- a/drivers/usb/serial/ipw.c
+++ b/drivers/usb/serial/ipw.c
@@ -166,7 +166,6 @@ static void ipw_read_bulk_callback(struct urb *urb, struct pt_regs *regs)
         struct usb_serial_port *port = urb->context;
         unsigned char *data = urb->transfer_buffer;
         struct tty_struct *tty;
-        int i;
         int result;
 
         dbg("%s - port %d", __FUNCTION__, port->number);
@@ -180,14 +179,8 @@ static void ipw_read_bulk_callback(struct urb *urb, struct pt_regs *regs)
 
         tty = port->tty;
         if (tty && urb->actual_length) {
-                for (i = 0; i < urb->actual_length ; ++i) {
-                        /* if we insert more than TTY_FLIPBUF_SIZE characters, we drop them. */
-                        if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                                tty_flip_buffer_push(tty);
-                        }
-                        /* this doesn't actually push the data through unless tty->low_latency is set */
-                        tty_insert_flip_char(tty, data[i], 0);
-                }
+                tty_buffer_request_room(tty, urb->actual_length);
+                tty_insert_flip_string(tty, data, urb->actual_length);
                 tty_flip_buffer_push(tty);
         }
 
diff --git a/drivers/usb/serial/kl5kusb105.c b/drivers/usb/serial/kl5kusb105.c
index 4e2f7dfb58b2..78335a5f7743 100644
--- a/drivers/usb/serial/kl5kusb105.c
+++ b/drivers/usb/serial/kl5kusb105.c
@@ -648,7 +648,6 @@ static void klsi_105_read_bulk_callback (struct urb *urb, struct pt_regs *regs)
                 usb_serial_debug_data(debug, &port->dev, __FUNCTION__,
                                       urb->actual_length, data);
         } else {
-                int i;
                 int bytes_sent = ((__u8 *) data)[0] +
                                  ((unsigned int) ((__u8 *) data)[1] << 8);
                 tty = port->tty;
@@ -669,16 +668,8 @@ static void klsi_105_read_bulk_callback (struct urb *urb, struct pt_regs *regs)
                         bytes_sent = urb->actual_length - 2;
                 }
 
-                for (i = 2; i < 2+bytes_sent; i++) {
-                        /* if we insert more than TTY_FLIPBUF_SIZE characters,
-                         * we drop them. */
-                        if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                                tty_flip_buffer_push(tty);
-                        }
-                        /* this doesn't actually push the data through unless 
-                         * tty->low_latency is set */
-                        tty_insert_flip_char(tty, ((__u8*) data)[i], 0);
-                }
+                tty_buffer_request_room(tty, bytes_sent);
+                tty_insert_flip_string(tty, data + 2, bytes_sent);
                 tty_flip_buffer_push(tty);
 
                 /* again lockless, but debug info only */
diff --git a/drivers/usb/serial/kobil_sct.c b/drivers/usb/serial/kobil_sct.c
index d9c21e275130..b8b213185d0f 100644
--- a/drivers/usb/serial/kobil_sct.c
+++ b/drivers/usb/serial/kobil_sct.c
@@ -365,7 +365,6 @@ static void kobil_close (struct usb_serial_port *port, struct file *filp)
 
 static void kobil_read_int_callback( struct urb *purb, struct pt_regs *regs)
 {
-        int i;
         int result;
         struct usb_serial_port *port = (struct usb_serial_port *) purb->context;
         struct tty_struct *tty;
@@ -397,14 +396,8 @@ static void kobil_read_int_callback( struct urb *purb, struct pt_regs *regs)
                 */
                 // END DEBUG
 
-                for (i = 0; i < purb->actual_length; ++i) {
-                        // if we insert more than TTY_FLIPBUF_SIZE characters, we drop them.
-                        if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                                tty_flip_buffer_push(tty);
-                        }
-                        // this doesn't actually push the data through unless tty->low_latency is set
-                        tty_insert_flip_char(tty, data[i], 0);
-                }
+                tty_buffer_request_room(tty, purb->actual_length);
+                tty_insert_flip_string(tty, data, purb->actual_length);
                 tty_flip_buffer_push(tty);
         }
 
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index 3fd2405304fd..52bdf6fe46f2 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -321,7 +321,7 @@ static int option_write(struct usb_serial_port *port,
 
 static void option_indat_callback(struct urb *urb, struct pt_regs *regs)
 {
-        int i, err;
+        int err;
         int endpoint;
         struct usb_serial_port *port;
         struct tty_struct *tty;
@@ -338,11 +338,8 @@ static void option_indat_callback(struct urb *urb, struct pt_regs *regs)
         } else {
                 tty = port->tty;
                 if (urb->actual_length) {
-                        for (i = 0; i < urb->actual_length ; ++i) {
-                                if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-                                        tty_flip_buffer_push(tty);
-                                tty_insert_flip_char(tty, data[i], 0);
-                        }
+                        tty_buffer_request_room(tty, urb->actual_length);
+                        tty_insert_flip_string(tty, data, urb->actual_length);
                         tty_flip_buffer_push(tty);
                 } else {
                         dbg("%s: empty read urb received", __FUNCTION__);
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index f03721056190..9ffff1938239 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -924,16 +924,12 @@ static void pl2303_read_bulk_callback (struct urb *urb, struct pt_regs *regs)
 
         tty = port->tty;
         if (tty && urb->actual_length) {
+                tty_buffer_request_room(tty, urb->actual_length + 1);
                 /* overrun is special, not associated with a char */
                 if (status & UART_OVERRUN_ERROR)
                         tty_insert_flip_char(tty, 0, TTY_OVERRUN);
-
-                for (i = 0; i < urb->actual_length; ++i) {
-                        if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                                tty_flip_buffer_push(tty);
-                        }
+                for (i = 0; i < urb->actual_length; ++i)
                         tty_insert_flip_char (tty, data[i], tty_flag);
-                }
                 tty_flip_buffer_push (tty);
         }
 
diff --git a/drivers/usb/serial/ti_usb_3410_5052.c b/drivers/usb/serial/ti_usb_3410_5052.c
index abb830cb77bd..c18db3257073 100644
--- a/drivers/usb/serial/ti_usb_3410_5052.c
+++ b/drivers/usb/serial/ti_usb_3410_5052.c
@@ -1280,24 +1280,18 @@ static void ti_recv(struct device *dev, struct tty_struct *tty,
         int cnt;
 
         do {
-                if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                        tty_flip_buffer_push(tty);
-                        if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                                dev_err(dev, "%s - dropping data, %d bytes lost\n", __FUNCTION__, length);
-                                return;
-                        }
+                cnt = tty_buffer_request_room(tty, length);
+                if (cnt < length) {
+                        dev_err(dev, "%s - dropping data, %d bytes lost\n", __FUNCTION__, length - cnt);
+                        if(cnt == 0)
+                                break;
                 }
-                cnt = min(length, TTY_FLIPBUF_SIZE - tty->flip.count);
-                memcpy(tty->flip.char_buf_ptr, data, cnt);
-                memset(tty->flip.flag_buf_ptr, 0, cnt);
-                tty->flip.char_buf_ptr += cnt;
-                tty->flip.flag_buf_ptr += cnt;
-                tty->flip.count += cnt;
+                tty_insert_flip_string(tty, data, cnt);
+                tty_flip_buffer_push(tty);
                 data += cnt;
                 length -= cnt;
         } while (length > 0);
 
-        tty_flip_buffer_push(tty);
 }
 
 
diff --git a/drivers/usb/serial/visor.c b/drivers/usb/serial/visor.c
index 49b1fbe61f25..bce3d55affd8 100644
--- a/drivers/usb/serial/visor.c
+++ b/drivers/usb/serial/visor.c
@@ -488,7 +488,6 @@ static void visor_read_bulk_callback (struct urb *urb, struct pt_regs *regs)
         unsigned char *data = urb->transfer_buffer;
         struct tty_struct *tty;
         unsigned long flags;
-        int i;
         int throttled;
         int result;
 
@@ -503,14 +502,8 @@ static void visor_read_bulk_callback (struct urb *urb, struct pt_regs *regs)
 
         tty = port->tty;
         if (tty && urb->actual_length) {
-                for (i = 0; i < urb->actual_length ; ++i) {
-                        /* if we insert more than TTY_FLIPBUF_SIZE characters, we drop them. */
-                        if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                                tty_flip_buffer_push(tty);
-                        }
-                        /* this doesn't actually push the data through unless tty->low_latency is set */
-                        tty_insert_flip_char(tty, data[i], 0);
-                }
+                tty_buffer_request_room(tty, urb->actual_length);
+                tty_insert_flip_string(tty, data, urb->actual_length);
                 tty_flip_buffer_push(tty);
         }
         spin_lock_irqsave(&priv->lock, flags);
diff --git a/drivers/usb/serial/whiteheat.c b/drivers/usb/serial/whiteheat.c
index a7c3c4734d83..557411c6e7c7 100644
--- a/drivers/usb/serial/whiteheat.c
+++ b/drivers/usb/serial/whiteheat.c
@@ -1434,7 +1434,9 @@ static void rx_data_softint(void *private)
                 urb = wrap->urb;
 
                 if (tty && urb->actual_length) {
-                        if (urb->actual_length > TTY_FLIPBUF_SIZE - tty->flip.count) {
+                        int len = tty_buffer_request_room(tty, urb->actual_length);
+                        /* This stuff can go away now I suspect */
+                        if (unlikely(len < urb->actual_length)) {
                                 spin_lock_irqsave(&info->lock, flags);
                                 list_add(tmp, &info->rx_urb_q);
                                 spin_unlock_irqrestore(&info->lock, flags);
@@ -1442,11 +1444,8 @@ static void rx_data_softint(void *private)
                                 schedule_work(&info->rx_work);
                                 return;
                         }
-
-                        memcpy(tty->flip.char_buf_ptr, urb->transfer_buffer, urb->actual_length);
-                        tty->flip.char_buf_ptr += urb->actual_length;
-                        tty->flip.count += urb->actual_length;
-                        sent += urb->actual_length;
+                        tty_insert_flip_string(tty, urb->transfer_buffer, len);
+                        sent += len;
                 }
 
                 urb->dev = port->serial->dev;
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index 3f04427c9026..3e153d313bb0 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -993,12 +993,6 @@ config FB_ATY_GENERIC_LCD
           Say Y if you have a laptop with an ATI Rage LT PRO, Rage Mobility,
           Rage XC, or Rage XL chipset.
 
-config FB_ATY_XL_INIT
-        bool "Rage XL No-BIOS Init support"
-        depends on FB_ATY_CT
-        help
-          Say Y here to support booting a Rage XL without BIOS support.
-
 config FB_ATY_GX
         bool "Mach64 GX support" if PCI
         depends on FB_ATY
@@ -1376,7 +1370,7 @@ config FB_PXA
 
           This driver is also available as a module ( = code which can be
           inserted and removed from the running kernel whenever you want). The
-          module will be called vfb. If you want to compile it as a module,
+          module will be called pxafb. If you want to compile it as a module,
           say M here and read <file:Documentation/modules.txt>.
 
           If unsure, say N.
@@ -1409,7 +1403,7 @@ config FB_W100
 
           This driver is also available as a module ( = code which can be
           inserted and removed from the running kernel whenever you want). The
-          module will be called vfb. If you want to compile it as a module,
+          module will be called w100fb. If you want to compile it as a module,
           say M here and read <file:Documentation/modules.txt>.
 
           If unsure, say N.
diff --git a/drivers/video/arcfb.c b/drivers/video/arcfb.c
index 2784f0a9d693..89060b2db8e5 100644
--- a/drivers/video/arcfb.c
+++ b/drivers/video/arcfb.c
@@ -366,7 +366,8 @@ static void arcfb_lcd_update(struct arcfb_par *par, unsigned int dx,
         }
 }
 
-void arcfb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
+static void arcfb_fillrect(struct fb_info *info,
+                           const struct fb_fillrect *rect)
 {
         struct arcfb_par *par = info->par;
 
@@ -376,7 +377,8 @@ void arcfb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
         arcfb_lcd_update(par, rect->dx, rect->dy, rect->width, rect->height);
 }
 
-void arcfb_copyarea(struct fb_info *info, const struct fb_copyarea *area)
+static void arcfb_copyarea(struct fb_info *info,
+                           const struct fb_copyarea *area)
 {
         struct arcfb_par *par = info->par;
 
@@ -386,7 +388,7 @@ void arcfb_copyarea(struct fb_info *info, const struct fb_copyarea *area)
         arcfb_lcd_update(par, area->dx, area->dy, area->width, area->height);
 }
 
-void arcfb_imageblit(struct fb_info *info, const struct fb_image *image)
+static void arcfb_imageblit(struct fb_info *info, const struct fb_image *image)
 {
         struct arcfb_par *par = info->par;
 
diff --git a/drivers/video/asiliantfb.c b/drivers/video/asiliantfb.c
index c64de59398f4..69f75547865d 100644
--- a/drivers/video/asiliantfb.c
+++ b/drivers/video/asiliantfb.c
@@ -549,7 +549,7 @@ asiliantfb_pci_init(struct pci_dev *dp, const struct pci_device_id *ent)
         if (!request_mem_region(addr, size, "asiliantfb"))
                 return -EBUSY;
 
-        p = framebuffer_alloc(sizeof(u32) * 256, &dp->dev);
+        p = framebuffer_alloc(sizeof(u32) * 16, &dp->dev);
         if (!p) {
                 release_mem_region(addr, size);
                 return -ENOMEM;
diff --git a/drivers/video/aty/Makefile b/drivers/video/aty/Makefile
index 9dec96249ffb..18521397a6e3 100644
--- a/drivers/video/aty/Makefile
+++ b/drivers/video/aty/Makefile
@@ -5,7 +5,6 @@ obj-$(CONFIG_FB_RADEON) += radeonfb.o
 atyfb-y                         := atyfb_base.o mach64_accel.o mach64_cursor.o
 atyfb-$(CONFIG_FB_ATY_GX)       += mach64_gx.o
 atyfb-$(CONFIG_FB_ATY_CT)       += mach64_ct.o
-atyfb-$(CONFIG_FB_ATY_XL_INIT)  += xlinit.o
 
 atyfb-objs                      := $(atyfb-y)
 
diff --git a/drivers/video/aty/atyfb.h b/drivers/video/aty/atyfb.h
index 09de173c1164..e9b7a64c1ac4 100644
--- a/drivers/video/aty/atyfb.h
+++ b/drivers/video/aty/atyfb.h
@@ -50,6 +50,7 @@ struct pll_info {
         int sclk, mclk, mclk_pm, xclk;
         int ref_div;
         int ref_clk;
+        int ecp_max;
 };
 
 typedef struct {
@@ -354,6 +355,5 @@ static inline void wait_for_idle(struct atyfb_par *par)
 
 extern void aty_reset_engine(const struct atyfb_par *par);
 extern void aty_init_engine(struct atyfb_par *par, struct fb_info *info);
-extern int  atyfb_xl_init(struct fb_info *info);
 extern void aty_st_pll_ct(int offset, u8 val, const struct atyfb_par *par);
 extern u8   aty_ld_pll_ct(int offset, const struct atyfb_par *par);
diff --git a/drivers/video/aty/atyfb_base.c b/drivers/video/aty/atyfb_base.c
index 3fefdb0cbf07..e370125e4fbc 100644
--- a/drivers/video/aty/atyfb_base.c
+++ b/drivers/video/aty/atyfb_base.c
@@ -109,9 +109,18 @@
 #define GUI_RESERVE     (1 * PAGE_SIZE)
 
 /* FIXME: remove the FAIL definition */
-#define FAIL(msg) do { printk(KERN_CRIT "atyfb: " msg "\n"); return -EINVAL; } while (0)
-#define FAIL_MAX(msg, x, _max_) do { if(x > _max_) { printk(KERN_CRIT "atyfb: " msg " %x(%x)\n", x, _max_); return -EINVAL; } } while (0)
-
+#define FAIL(msg) do { \
+        if (!(var->activate & FB_ACTIVATE_TEST)) \
+                printk(KERN_CRIT "atyfb: " msg "\n"); \
+        return -EINVAL; \
+} while (0)
+#define FAIL_MAX(msg, x, _max_) do { \
+        if (x > _max_) { \
+                if (!(var->activate & FB_ACTIVATE_TEST)) \
+                        printk(KERN_CRIT "atyfb: " msg " %x(%x)\n", x, _max_); \
+                return -EINVAL; \
+        } \
+} while (0)
 #ifdef DEBUG
 #define DPRINTK(fmt, args...)   printk(KERN_DEBUG "atyfb: " fmt, ## args)
 #else
@@ -340,6 +349,7 @@ static unsigned long phys_guiregbase[FB_MAX] __initdata = { 0, };
 #define ATI_CHIP_264VT3    (M64F_VT | M64F_INTEGRATED | M64F_VT_BUS | M64F_GTB_DSP | M64F_SDRAM_MAGIC_PLL)
 #define ATI_CHIP_264VT4    (M64F_VT | M64F_INTEGRATED               | M64F_GTB_DSP)
 
+/* FIXME what is this chip? */
 #define ATI_CHIP_264LT     (M64F_GT | M64F_INTEGRATED               | M64F_GTB_DSP)
 
 /* make sets shorter */
@@ -359,58 +369,60 @@ static unsigned long phys_guiregbase[FB_MAX] __initdata = { 0, };
 static struct {
         u16 pci_id;
         const char *name;
-        int pll, mclk, xclk;
+        int pll, mclk, xclk, ecp_max;
         u32 features;
 } aty_chips[] __devinitdata = {
 #ifdef CONFIG_FB_ATY_GX
         /* Mach64 GX */
-        { PCI_CHIP_MACH64GX, "ATI888GX00 (Mach64 GX)", 135, 50, 50, ATI_CHIP_88800GX },
-        { PCI_CHIP_MACH64CX, "ATI888CX00 (Mach64 CX)", 135, 50, 50, ATI_CHIP_88800CX },
+        { PCI_CHIP_MACH64GX, "ATI888GX00 (Mach64 GX)", 135, 50, 50, 0, ATI_CHIP_88800GX },
+        { PCI_CHIP_MACH64CX, "ATI888CX00 (Mach64 CX)", 135, 50, 50, 0, ATI_CHIP_88800CX },
 #endif /* CONFIG_FB_ATY_GX */
 
 #ifdef CONFIG_FB_ATY_CT
-        { PCI_CHIP_MACH64CT, "ATI264CT (Mach64 CT)", 135, 60, 60, ATI_CHIP_264CT },
-        { PCI_CHIP_MACH64ET, "ATI264ET (Mach64 ET)", 135, 60, 60, ATI_CHIP_264ET },
-        { PCI_CHIP_MACH64VT, "ATI264VT? (Mach64 VT)", 170, 67, 67, ATI_CHIP_264VT },
-        { PCI_CHIP_MACH64GT, "3D RAGE (Mach64 GT)", 135, 63, 63, ATI_CHIP_264GT },
-        /* FIXME { ...ATI_264GU, maybe ATI_CHIP_264GTDVD }, */
-        { PCI_CHIP_MACH64GU, "3D RAGE II+ (Mach64 GTB)", 200, 67, 67, ATI_CHIP_264GTB  },
-        { PCI_CHIP_MACH64VU, "ATI264VTB (Mach64 VU)", 200, 67, 67, ATI_CHIP_264VT3 },
-
-        { PCI_CHIP_MACH64LT, "3D RAGE LT (Mach64 LT)", 135, 63, 63, ATI_CHIP_264LT },
-         /* FIXME chipset maybe ATI_CHIP_264LTPRO ? */
-        { PCI_CHIP_MACH64LG, "3D RAGE LT-G (Mach64 LG)", 230, 63, 63, ATI_CHIP_264LTG | M64F_LT_LCD_REGS | M64F_G3_PB_1024x768 },
-
-        { PCI_CHIP_MACH64VV, "ATI264VT4 (Mach64 VV)", 230, 83, 83, ATI_CHIP_264VT4 },
-
-        { PCI_CHIP_MACH64GV, "3D RAGE IIC (Mach64 GV, PCI)", 230, 83, 83, ATI_CHIP_264GT2C },
-        { PCI_CHIP_MACH64GW, "3D RAGE IIC (Mach64 GW, AGP)", 230, 83, 83, ATI_CHIP_264GT2C },
-        { PCI_CHIP_MACH64GY, "3D RAGE IIC (Mach64 GY, PCI)", 230, 83, 83, ATI_CHIP_264GT2C },
-        { PCI_CHIP_MACH64GZ, "3D RAGE IIC (Mach64 GZ, AGP)", 230, 83, 83, ATI_CHIP_264GT2C },
-
-        { PCI_CHIP_MACH64GB, "3D RAGE PRO (Mach64 GB, BGA, AGP)", 230, 100, 100, ATI_CHIP_264GTPRO },
-        { PCI_CHIP_MACH64GD, "3D RAGE PRO (Mach64 GD, BGA, AGP 1x)", 230, 100, 100, ATI_CHIP_264GTPRO },
-        { PCI_CHIP_MACH64GI, "3D RAGE PRO (Mach64 GI, BGA, PCI)", 230, 100, 100, ATI_CHIP_264GTPRO | M64F_MAGIC_VRAM_SIZE },
-        { PCI_CHIP_MACH64GP, "3D RAGE PRO (Mach64 GP, PQFP, PCI)", 230, 100, 100, ATI_CHIP_264GTPRO },
-        { PCI_CHIP_MACH64GQ, "3D RAGE PRO (Mach64 GQ, PQFP, PCI, limited 3D)", 230, 100, 100, ATI_CHIP_264GTPRO },
-
-        { PCI_CHIP_MACH64LB, "3D RAGE LT PRO (Mach64 LB, AGP)", 236, 75, 100, ATI_CHIP_264LTPRO },
-        { PCI_CHIP_MACH64LD, "3D RAGE LT PRO (Mach64 LD, AGP)", 230, 100, 100, ATI_CHIP_264LTPRO },
-        { PCI_CHIP_MACH64LI, "3D RAGE LT PRO (Mach64 LI, PCI)", 230, 100, 100, ATI_CHIP_264LTPRO | M64F_G3_PB_1_1 | M64F_G3_PB_1024x768 },
-        { PCI_CHIP_MACH64LP, "3D RAGE LT PRO (Mach64 LP, PCI)", 230, 100, 100, ATI_CHIP_264LTPRO },
-        { PCI_CHIP_MACH64LQ, "3D RAGE LT PRO (Mach64 LQ, PCI)", 230, 100, 100, ATI_CHIP_264LTPRO },
-
-        { PCI_CHIP_MACH64GM, "3D RAGE XL (Mach64 GM, AGP)", 230, 83, 63, ATI_CHIP_264XL },
-        { PCI_CHIP_MACH64GN, "3D RAGE XL (Mach64 GN, AGP)", 230, 83, 63, ATI_CHIP_264XL },
-        { PCI_CHIP_MACH64GO, "3D RAGE XL (Mach64 GO, PCI-66/BGA)", 230, 83, 63, ATI_CHIP_264XL },
-        { PCI_CHIP_MACH64GR, "3D RAGE XL (Mach64 GR, PCI-33MHz)", 235, 83, 63, ATI_CHIP_264XL | M64F_SDRAM_MAGIC_PLL },
-        { PCI_CHIP_MACH64GL, "3D RAGE XL (Mach64 GL, PCI)", 230, 83, 63, ATI_CHIP_264XL },
-        { PCI_CHIP_MACH64GS, "3D RAGE XL (Mach64 GS, PCI)", 230, 83, 63, ATI_CHIP_264XL },
-
-        { PCI_CHIP_MACH64LM, "3D RAGE Mobility P/M (Mach64 LM, AGP 2x)", 230, 83, 125, ATI_CHIP_MOBILITY },
-        { PCI_CHIP_MACH64LN, "3D RAGE Mobility L (Mach64 LN, AGP 2x)", 230, 83, 125, ATI_CHIP_MOBILITY },
-        { PCI_CHIP_MACH64LR, "3D RAGE Mobility P/M (Mach64 LR, PCI)", 230, 83, 125, ATI_CHIP_MOBILITY },
-        { PCI_CHIP_MACH64LS, "3D RAGE Mobility L (Mach64 LS, PCI)", 230, 83, 125, ATI_CHIP_MOBILITY },
+        { PCI_CHIP_MACH64CT, "ATI264CT (Mach64 CT)", 135, 60, 60, 0, ATI_CHIP_264CT },
+        { PCI_CHIP_MACH64ET, "ATI264ET (Mach64 ET)", 135, 60, 60, 0, ATI_CHIP_264ET },
+
+        /* FIXME what is this chip? */
+        { PCI_CHIP_MACH64LT, "ATI264LT (Mach64 LT)", 135, 63, 63, 0, ATI_CHIP_264LT },
+
+        { PCI_CHIP_MACH64VT, "ATI264VT (Mach64 VT)", 170, 67, 67, 80, ATI_CHIP_264VT },
+        { PCI_CHIP_MACH64GT, "3D RAGE (Mach64 GT)", 135, 63, 63, 80, ATI_CHIP_264GT },
+
+        { PCI_CHIP_MACH64VU, "ATI264VT3 (Mach64 VU)", 200, 67, 67, 80, ATI_CHIP_264VT3 },
+        { PCI_CHIP_MACH64GU, "3D RAGE II+ (Mach64 GU)", 200, 67, 67, 100, ATI_CHIP_264GTB },
+
+        { PCI_CHIP_MACH64LG, "3D RAGE LT (Mach64 LG)", 230, 63, 63, 100, ATI_CHIP_264LTG | M64F_LT_LCD_REGS | M64F_G3_PB_1024x768 },
+
+        { PCI_CHIP_MACH64VV, "ATI264VT4 (Mach64 VV)", 230, 83, 83, 100, ATI_CHIP_264VT4 },
+
+        { PCI_CHIP_MACH64GV, "3D RAGE IIC (Mach64 GV, PCI)", 230, 83, 83, 100, ATI_CHIP_264GT2C },
+        { PCI_CHIP_MACH64GW, "3D RAGE IIC (Mach64 GW, AGP)", 230, 83, 83, 100, ATI_CHIP_264GT2C },
+        { PCI_CHIP_MACH64GY, "3D RAGE IIC (Mach64 GY, PCI)", 230, 83, 83, 100, ATI_CHIP_264GT2C },
+        { PCI_CHIP_MACH64GZ, "3D RAGE IIC (Mach64 GZ, AGP)", 230, 83, 83, 100, ATI_CHIP_264GT2C },
+
+        { PCI_CHIP_MACH64GB, "3D RAGE PRO (Mach64 GB, BGA, AGP)", 230, 100, 100, 125, ATI_CHIP_264GTPRO },
+        { PCI_CHIP_MACH64GD, "3D RAGE PRO (Mach64 GD, BGA, AGP 1x)", 230, 100, 100, 125, ATI_CHIP_264GTPRO },
+        { PCI_CHIP_MACH64GI, "3D RAGE PRO (Mach64 GI, BGA, PCI)", 230, 100, 100, 125, ATI_CHIP_264GTPRO | M64F_MAGIC_VRAM_SIZE },
+        { PCI_CHIP_MACH64GP, "3D RAGE PRO (Mach64 GP, PQFP, PCI)", 230, 100, 100, 125, ATI_CHIP_264GTPRO },
+        { PCI_CHIP_MACH64GQ, "3D RAGE PRO (Mach64 GQ, PQFP, PCI, limited 3D)", 230, 100, 100, 125, ATI_CHIP_264GTPRO },
+
+        { PCI_CHIP_MACH64LB, "3D RAGE LT PRO (Mach64 LB, AGP)", 236, 75, 100, 135, ATI_CHIP_264LTPRO },
+        { PCI_CHIP_MACH64LD, "3D RAGE LT PRO (Mach64 LD, AGP)", 230, 100, 100, 135, ATI_CHIP_264LTPRO },
+        { PCI_CHIP_MACH64LI, "3D RAGE LT PRO (Mach64 LI, PCI)", 230, 100, 100, 135, ATI_CHIP_264LTPRO | M64F_G3_PB_1_1 | M64F_G3_PB_1024x768 },
+        { PCI_CHIP_MACH64LP, "3D RAGE LT PRO (Mach64 LP, PCI)", 230, 100, 100, 135, ATI_CHIP_264LTPRO },
+        { PCI_CHIP_MACH64LQ, "3D RAGE LT PRO (Mach64 LQ, PCI)", 230, 100, 100, 135, ATI_CHIP_264LTPRO },
+
+        { PCI_CHIP_MACH64GM, "3D RAGE XL (Mach64 GM, AGP 2x)", 230, 83, 63, 135, ATI_CHIP_264XL },
+        { PCI_CHIP_MACH64GN, "3D RAGE XC (Mach64 GN, AGP 2x)", 230, 83, 63, 135, ATI_CHIP_264XL },
+        { PCI_CHIP_MACH64GO, "3D RAGE XL (Mach64 GO, PCI-66)", 230, 83, 63, 135, ATI_CHIP_264XL },
+        { PCI_CHIP_MACH64GL, "3D RAGE XC (Mach64 GL, PCI-66)", 230, 83, 63, 135, ATI_CHIP_264XL },
+        { PCI_CHIP_MACH64GR, "3D RAGE XL (Mach64 GR, PCI-33)", 230, 83, 63, 135, ATI_CHIP_264XL | M64F_SDRAM_MAGIC_PLL },
+        { PCI_CHIP_MACH64GS, "3D RAGE XC (Mach64 GS, PCI-33)", 230, 83, 63, 135, ATI_CHIP_264XL },
+
+        { PCI_CHIP_MACH64LM, "3D RAGE Mobility P/M (Mach64 LM, AGP 2x)", 230, 83, 125, 135, ATI_CHIP_MOBILITY },
+        { PCI_CHIP_MACH64LN, "3D RAGE Mobility L (Mach64 LN, AGP 2x)", 230, 83, 125, 135, ATI_CHIP_MOBILITY },
+        { PCI_CHIP_MACH64LR, "3D RAGE Mobility P/M (Mach64 LR, PCI)", 230, 83, 125, 135, ATI_CHIP_MOBILITY },
+        { PCI_CHIP_MACH64LS, "3D RAGE Mobility L (Mach64 LS, PCI)", 230, 83, 125, 135, ATI_CHIP_MOBILITY },
 #endif /* CONFIG_FB_ATY_CT */
 };
 
@@ -431,6 +443,7 @@ static int __devinit correct_chipset(struct atyfb_par *par)
         par->pll_limits.pll_max = aty_chips[i].pll;
         par->pll_limits.mclk = aty_chips[i].mclk;
         par->pll_limits.xclk = aty_chips[i].xclk;
+        par->pll_limits.ecp_max = aty_chips[i].ecp_max;
         par->features = aty_chips[i].features;
 
         chip_id = aty_ld_le32(CONFIG_CHIP_ID, par);
@@ -450,39 +463,63 @@ static int __devinit correct_chipset(struct atyfb_par *par)
 #endif
 #ifdef CONFIG_FB_ATY_CT
         case PCI_CHIP_MACH64VT:
-                rev &= 0xc7;
-                if(rev == 0x00) {
-                        name = "ATI264VTA3 (Mach64 VT)";
-                        par->pll_limits.pll_max = 170;
-                        par->pll_limits.mclk = 67;
-                        par->pll_limits.xclk = 67;
-                        par->features = ATI_CHIP_264VT;
-                } else if(rev == 0x40) {
-                        name = "ATI264VTA4 (Mach64 VT)";
+                switch (rev & 0x07) {
+                case 0x00:
+                        switch (rev & 0xc0) {
+                        case 0x00:
+                                name = "ATI264VT (A3) (Mach64 VT)";
+                                par->pll_limits.pll_max = 170;
+                                par->pll_limits.mclk = 67;
+                                par->pll_limits.xclk = 67;
+                                par->pll_limits.ecp_max = 80;
+                                par->features = ATI_CHIP_264VT;
+                                break;
+                        case 0x40:
+                                name = "ATI264VT2 (A4) (Mach64 VT)";
+                                par->pll_limits.pll_max = 200;
+                                par->pll_limits.mclk = 67;
+                                par->pll_limits.xclk = 67;
+                                par->pll_limits.ecp_max = 80;
+                                par->features = ATI_CHIP_264VT | M64F_MAGIC_POSTDIV;
+                                break;
+                        }
+                        break;
+                case 0x01:
+                        name = "ATI264VT3 (B1) (Mach64 VT)";
                         par->pll_limits.pll_max = 200;
                         par->pll_limits.mclk = 67;
                         par->pll_limits.xclk = 67;
-                        par->features = ATI_CHIP_264VT | M64F_MAGIC_POSTDIV;
-                } else {
-                        name = "ATI264VTB (Mach64 VT)";
+                        par->pll_limits.ecp_max = 80;
+                        par->features = ATI_CHIP_264VTB;
+                        break;
+                case 0x02:
+                        name = "ATI264VT3 (B2) (Mach64 VT)";
                         par->pll_limits.pll_max = 200;
                         par->pll_limits.mclk = 67;
                         par->pll_limits.xclk = 67;
-                        par->features = ATI_CHIP_264VTB;
+                        par->pll_limits.ecp_max = 80;
+                        par->features = ATI_CHIP_264VT3;
+                        break;
                 }
                 break;
         case PCI_CHIP_MACH64GT:
-                rev &= 0x07;
-                if(rev == 0x01) {
+                switch (rev & 0x07) {
+                case 0x01:
+                        name = "3D RAGE II (Mach64 GT)";
                         par->pll_limits.pll_max = 170;
                         par->pll_limits.mclk = 67;
                         par->pll_limits.xclk = 67;
+                        par->pll_limits.ecp_max = 80;
                         par->features = ATI_CHIP_264GTB;
-                } else if(rev == 0x02) {
+                        break;
+                case 0x02:
+                        name = "3D RAGE II+ (Mach64 GT)";
                         par->pll_limits.pll_max = 200;
                         par->pll_limits.mclk = 67;
                         par->pll_limits.xclk = 67;
+                        par->pll_limits.ecp_max = 100;
                         par->features = ATI_CHIP_264GTB;
+                        break;
                 }
                 break;
 #endif
@@ -692,7 +729,7 @@ static void aty_set_crtc(const struct atyfb_par *par, const struct crtc *crtc)
                 aty_st_lcd(LCD_GEN_CNTL, (crtc->lcd_gen_cntl & ~CRTC_RW_SELECT) |
                         (SHADOW_EN | SHADOW_RW_EN), par);
 
-                DPRINTK("set secondary CRT to %ix%i %c%c\n",
+                DPRINTK("set shadow CRT to %ix%i %c%c\n",
                     ((((crtc->shadow_h_tot_disp>>16) & 0xff) + 1)<<3), (((crtc->shadow_v_tot_disp>>16) & 0x7ff) + 1),
                     (crtc->shadow_h_sync_strt_wid & 0x200000)?'N':'P', (crtc->shadow_v_sync_strt_wid & 0x200000)?'N':'P');
 
@@ -840,11 +877,14 @@ static int aty_var_to_crtc(const struct fb_info *info,
                            know if one is connected. So it's better to fail then.
                          */
                         if (crtc->lcd_gen_cntl & CRT_ON) {
-                                PRINTKI("Disable lcd panel, because video mode does not fit.\n");
+                                if (!(var->activate & FB_ACTIVATE_TEST))
+                                        PRINTKI("Disable LCD panel, because video mode does not fit.\n");
                                 crtc->lcd_gen_cntl &= ~LCD_ON;
                                 /*aty_st_lcd(LCD_GEN_CNTL, crtc->lcd_gen_cntl, par);*/
                         } else {
-                                FAIL("Video mode exceeds size of lcd panel.\nConnect this computer to a conventional monitor if you really need this mode.");
+                                if (!(var->activate & FB_ACTIVATE_TEST))
+                                        PRINTKE("Video mode exceeds size of LCD panel.\nConnect this computer to a conventional monitor if you really need this mode.\n");
+                                return -EINVAL;
                         }
                 }
         }
@@ -858,9 +898,9 @@ static int aty_var_to_crtc(const struct fb_info *info,
                 vmode &= ~(FB_VMODE_DOUBLE | FB_VMODE_INTERLACED);
 
                 /* This is horror! When we simulate, say 640x480 on an 800x600
-                   lcd monitor, the CRTC should be programmed 800x600 values for
+                   LCD monitor, the CRTC should be programmed 800x600 values for
                    the non visible part, but 640x480 for the visible part.
-                   This code has been tested on a laptop with it's 1400x1050 lcd
+                   This code has been tested on a laptop with it's 1400x1050 LCD
                    monitor and a conventional monitor both switched on.
                    Tested modes: 1280x1024, 1152x864, 1024x768, 800x600,
                     works with little glitches also with DOUBLESCAN modes
@@ -955,16 +995,6 @@ static int aty_var_to_crtc(const struct fb_info *info,
                 vdisplay = yres;
                 if(vmode & FB_VMODE_DOUBLE)
                         vdisplay <<= 1;
-                if(vmode & FB_VMODE_INTERLACED) {
-                        vdisplay >>= 1;
-
-                        /* The prefered mode for the lcd is not interlaced, so disable it if
-                           it was enabled. For doublescan there is no problem, because we can
-                           compensate for it in the hardware stretching (we stretch half as much)
-                         */
-                        vmode &= ~FB_VMODE_INTERLACED;
-                        /*crtc->gen_cntl &= ~CRTC_INTERLACE_EN;*/
-                }
                 crtc->gen_cntl &= ~(CRTC2_EN | CRTC2_PIX_WIDTH);
                 crtc->lcd_gen_cntl &= ~(HORZ_DIVBY2_EN | DIS_HOR_CRT_DIVBY2 |
                         /*TVCLK_PM_EN | VCLK_DAC_PM_EN |*/
@@ -980,7 +1010,7 @@ static int aty_var_to_crtc(const struct fb_info *info,
                 crtc->horz_stretching &=
                         ~(HORZ_STRETCH_RATIO | HORZ_STRETCH_LOOP | AUTO_HORZ_RATIO |
                         HORZ_STRETCH_MODE | HORZ_STRETCH_EN);
-                if (xres < par->lcd_width) {
+                if (xres < par->lcd_width && crtc->lcd_gen_cntl & LCD_ON) {
                         do {
                                 /*
                                 * The horizontal blender misbehaves when HDisplay is less than a
@@ -1042,7 +1072,7 @@ static int aty_var_to_crtc(const struct fb_info *info,
                         } while (0);
                 }
 
-                if (vdisplay < par->lcd_height) {
+                if (vdisplay < par->lcd_height && crtc->lcd_gen_cntl & LCD_ON) {
                         crtc->vert_stretching = (VERT_STRETCH_USE0 | VERT_STRETCH_EN |
                                 (((vdisplay * (VERT_STRETCH_RATIO0 + 1)) / par->lcd_height) & VERT_STRETCH_RATIO0));
 
@@ -1065,9 +1095,8 @@ static int aty_var_to_crtc(const struct fb_info *info,
 #endif /* CONFIG_FB_ATY_GENERIC_LCD */
 
         if (M64_HAS(MAGIC_FIFO)) {
-                /* Not VTB/GTB */
-                /* FIXME: magic FIFO values */
-                crtc->gen_cntl |= (aty_ld_le32(CRTC_GEN_CNTL, par) & CRTC2_PIX_WIDTH);
+                /* FIXME: display FIFO low watermark values */
+                crtc->gen_cntl |= (aty_ld_le32(CRTC_GEN_CNTL, par) & CRTC_FIFO_LWM);
         }
         crtc->dp_pix_width = dp_pix_width;
         crtc->dp_chain_mask = dp_chain_mask;
@@ -1184,7 +1213,8 @@ static int aty_crtc_to_var(const struct crtc *crtc, struct fb_var_screeninfo *va
                 var->transp.length = 8;
                 break;
         default:
-                FAIL("Invalid pixel width");
+                PRINTKE("Invalid pixel width\n");
+                return -EINVAL;
         }
 
         /* output */
@@ -1241,7 +1271,8 @@ static int atyfb_set_par(struct fb_info *info)
         pixclock = atyfb_get_pixclock(var, par);
 
         if (pixclock == 0) {
-                FAIL("Invalid pixclock");
+                PRINTKE("Invalid pixclock\n");
+                return -EINVAL;
         } else {
                 if((err = par->pll_ops->var_to_pll(info, pixclock, var->bits_per_pixel, &par->pll)))
                         return err;
@@ -1446,7 +1477,9 @@ static int atyfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
         pixclock = atyfb_get_pixclock(var, par);
 
         if (pixclock == 0) {
-                FAIL("Invalid pixclock");
+                if (!(var->activate & FB_ACTIVATE_TEST))
+                        PRINTKE("Invalid pixclock\n");
+                return -EINVAL;
         } else {
                 if((err = par->pll_ops->var_to_pll(info, pixclock, var->bits_per_pixel, &pll)))
                         return err;
@@ -2291,10 +2324,6 @@ static int __init aty_init(struct fb_info *info, const char *name)
                 par->dac_ops = &aty_dac_ct;
                 par->pll_ops = &aty_pll_ct;
                 par->bus_type = PCI;
-#ifdef CONFIG_FB_ATY_XL_INIT
-                if (IS_XL(par->pci_id))
-                        atyfb_xl_init(info);
-#endif
                 par->ram_type = (aty_ld_le32(CONFIG_STAT0, par) & 0x07);
                 ramname = aty_ct_ram[par->ram_type];
                 /* for many chips, the mclk is 67 MHz for SDRAM, 63 MHz otherwise */
@@ -2638,16 +2667,16 @@ static int __init store_video_par(char *video_str, unsigned char m64_num)
 static int atyfb_blank(int blank, struct fb_info *info)
 {
         struct atyfb_par *par = (struct atyfb_par *) info->par;
-        u8 gen_cntl;
+        u32 gen_cntl;
 
         if (par->lock_blank || par->asleep)
                 return 0;
 
 #ifdef CONFIG_PMAC_BACKLIGHT
-        if ((_machine == _MACH_Pmac) && blank)
+        if ((_machine == _MACH_Pmac) && blank > FB_BLANK_NORMAL)
                 set_backlight_enable(0);
 #elif defined(CONFIG_FB_ATY_GENERIC_LCD)
-        if (par->lcd_table && blank &&
+        if (par->lcd_table && blank > FB_BLANK_NORMAL &&
             (aty_ld_lcd(LCD_GEN_CNTL, par) & LCD_ON)) {
                 u32 pm = aty_ld_lcd(POWER_MANAGEMENT, par);
                 pm &= ~PWR_BLON;
@@ -2655,31 +2684,31 @@ static int atyfb_blank(int blank, struct fb_info *info)
         }
 #endif
 
-        gen_cntl = aty_ld_8(CRTC_GEN_CNTL, par);
+        gen_cntl = aty_ld_le32(CRTC_GEN_CNTL, par);
         switch (blank) {
                 case FB_BLANK_UNBLANK:
-                        gen_cntl &= ~(0x4c);
+                        gen_cntl &= ~0x400004c;
                         break;
                 case FB_BLANK_NORMAL:
-                        gen_cntl |= 0x40;
+                        gen_cntl |= 0x4000040;
                         break;
                 case FB_BLANK_VSYNC_SUSPEND:
-                        gen_cntl |= 0x8;
+                        gen_cntl |= 0x4000048;
                         break;
                 case FB_BLANK_HSYNC_SUSPEND:
-                        gen_cntl |= 0x4;
+                        gen_cntl |= 0x4000044;
                         break;
                 case FB_BLANK_POWERDOWN:
-                        gen_cntl |= 0x4c;
+                        gen_cntl |= 0x400004c;
                         break;
         }
-        aty_st_8(CRTC_GEN_CNTL, gen_cntl, par);
+        aty_st_le32(CRTC_GEN_CNTL, gen_cntl, par);
 
 #ifdef CONFIG_PMAC_BACKLIGHT
-        if ((_machine == _MACH_Pmac) && !blank)
+        if ((_machine == _MACH_Pmac) && blank <= FB_BLANK_NORMAL)
                 set_backlight_enable(1);
 #elif defined(CONFIG_FB_ATY_GENERIC_LCD)
-        if (par->lcd_table && !blank &&
+        if (par->lcd_table && blank <= FB_BLANK_NORMAL &&
             (aty_ld_lcd(LCD_GEN_CNTL, par) & LCD_ON)) {
                 u32 pm = aty_ld_lcd(POWER_MANAGEMENT, par);
                 pm |= PWR_BLON;
@@ -3157,15 +3186,15 @@ static void aty_init_lcd(struct atyfb_par *par, u32 bios_base)
                         refresh_rates_buf, lcd_refresh_rates[default_refresh_rate]);
                 par->lcd_refreshrate = lcd_refresh_rates[default_refresh_rate];
                 /* We now need to determine the crtc parameters for the
-                 * lcd monitor. This is tricky, because they are not stored
+                 * LCD monitor. This is tricky, because they are not stored
                  * individually in the BIOS. Instead, the BIOS contains a
                  * table of display modes that work for this monitor.
                  *
                  * The idea is that we search for a mode of the same dimensions
-                 * as the dimensions of the lcd monitor. Say our lcd monitor
+                 * as the dimensions of the LCD monitor. Say our LCD monitor
                  * is 800x600 pixels, we search for a 800x600 monitor.
                  * The CRTC parameters we find here are the ones that we need
-                 * to use to simulate other resolutions on the lcd screen.
+                 * to use to simulate other resolutions on the LCD screen.
                  */
                 lcdmodeptr = (u16 *)(par->lcd_table + 64);
                 while (*lcdmodeptr != 0) {
@@ -3692,9 +3721,7 @@ static int __init atyfb_init(void)
     atyfb_setup(option);
 #endif
 
-#ifdef CONFIG_PCI
     pci_register_driver(&atyfb_driver);
-#endif
 #ifdef CONFIG_ATARI
     atyfb_atari_probe();
 #endif
@@ -3703,9 +3730,7 @@ static int __init atyfb_init(void)
 
 static void __exit atyfb_exit(void)
 {
-#ifdef CONFIG_PCI
         pci_unregister_driver(&atyfb_driver);
-#endif
 }
 
 module_init(atyfb_init);
diff --git a/drivers/video/aty/mach64_ct.c b/drivers/video/aty/mach64_ct.c
index 9bdb2aab01aa..e7056934c6a8 100644
--- a/drivers/video/aty/mach64_ct.c
+++ b/drivers/video/aty/mach64_ct.c
@@ -206,9 +206,7 @@ static int aty_valid_pll_ct(const struct fb_info *info, u32 vclk_per, struct pll
 {
         u32 q;
         struct atyfb_par *par = (struct atyfb_par *) info->par;
-#ifdef DEBUG
         int pllvclk;
-#endif
 
         /* FIXME: use the VTB/GTB /{3,6,12} post dividers if they're better suited */
         q = par->ref_clk_per * pll->pll_ref_div * 4 / vclk_per;
@@ -223,13 +221,26 @@ static int aty_valid_pll_ct(const struct fb_info *info, u32 vclk_per, struct pll
         pll->vclk_post_div_real = postdividers[pll->vclk_post_div];
         //    pll->vclk_post_div <<= 6;
         pll->vclk_fb_div = q * pll->vclk_post_div_real / 8;
-#ifdef DEBUG
         pllvclk = (1000000 * 2 * pll->vclk_fb_div) /
                 (par->ref_clk_per * pll->pll_ref_div);
+#ifdef DEBUG
         printk("atyfb(%s): pllvclk=%d MHz, vclk=%d MHz\n",
                 __FUNCTION__, pllvclk, pllvclk / pll->vclk_post_div_real);
 #endif
         pll->pll_vclk_cntl = 0x03; /* VCLK = PLL_VCLK/VCLKx_POST */
+
+        /* Set ECP (scaler/overlay clock) divider */
+        if (par->pll_limits.ecp_max) {
+                int ecp = pllvclk / pll->vclk_post_div_real;
+                int ecp_div = 0;
+
+                while (ecp > par->pll_limits.ecp_max && ecp_div < 2) {
+                        ecp >>= 1;
+                        ecp_div++;
+                }
+                pll->pll_vclk_cntl |= ecp_div << 4;
+        }
+
         return 0;
 }
 
diff --git a/drivers/video/aty/xlinit.c b/drivers/video/aty/xlinit.c
deleted file mode 100644
index a085cbf74ecb..000000000000
--- a/drivers/video/aty/xlinit.c
+++ /dev/null
@@ -1,359 +0,0 @@
-/*
- *  ATI Rage XL Initialization. Support for Xpert98 and Victoria
- *  PCI cards.
- *
- *  Copyright (C) 2002 MontaVista Software Inc.
- *  Author: MontaVista Software, Inc.
- *              stevel@mvista.com or source@mvista.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  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/config.h>
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/errno.h>
-#include <linux/string.h>
-#include <linux/mm.h> 
-#include <linux/slab.h>
-#include <linux/vmalloc.h>
-#include <linux/delay.h>
-#include <linux/fb.h>
-#include <linux/init.h>
-#include <linux/pci.h>
-#include <asm/io.h>
-#include <video/mach64.h>
-#include "atyfb.h"
-
-#define MPLL_GAIN       0xad
-#define VPLL_GAIN       0xd5
-
-enum {
-        VICTORIA = 0,
-        XPERT98,
-        NUM_XL_CARDS
-};
-
-extern const struct aty_pll_ops aty_pll_ct;
-
-#define DEFAULT_CARD XPERT98
-static int xl_card = DEFAULT_CARD;
-
-static const struct xl_card_cfg_t {
-        int ref_crystal; // 10^4 Hz
-        int mem_type;
-        int mem_size;
-        u32 mem_cntl;
-        u32 ext_mem_cntl;
-        u32 mem_addr_config;
-        u32 bus_cntl;
-        u32 dac_cntl;
-        u32 hw_debug;
-        u32 custom_macro_cntl;
-        u8  dll2_cntl;
-        u8  pll_yclk_cntl;
-} card_cfg[NUM_XL_CARDS] = {
-        // VICTORIA
-        {       2700, SDRAM, 0x800000,
-                0x10757A3B, 0x64000C81, 0x00110202, 0x7b33A040,
-                0x82010102, 0x48803800, 0x005E0179,
-                0x50, 0x25
-        },
-        // XPERT98
-        {       1432,  WRAM, 0x800000,
-                0x00165A2B, 0xE0000CF1, 0x00200213, 0x7333A001,
-                0x8000000A, 0x48833800, 0x007F0779,
-                0x10, 0x19
-        }
-};
-          
-typedef struct {
-        u8 lcd_reg;
-        u32 val;
-} lcd_tbl_t;
-
-static const lcd_tbl_t lcd_tbl[] = {
-        { 0x01, 0x000520C0 },
-        { 0x08, 0x02000408 },
-        { 0x03, 0x00000F00 },
-        { 0x00, 0x00000000 },
-        { 0x02, 0x00000000 },
-        { 0x04, 0x00000000 },
-        { 0x05, 0x00000000 },
-        { 0x06, 0x00000000 },
-        { 0x33, 0x00000000 },
-        { 0x34, 0x00000000 },
-        { 0x35, 0x00000000 },
-        { 0x36, 0x00000000 },
-        { 0x37, 0x00000000 }
-};
-
-static void reset_gui(struct atyfb_par *par)
-{
-        aty_st_8(GEN_TEST_CNTL+1, 0x01, par);
-        aty_st_8(GEN_TEST_CNTL+1, 0x00, par);
-        aty_st_8(GEN_TEST_CNTL+1, 0x02, par);
-        mdelay(5);
-}
-
-static void reset_sdram(struct atyfb_par *par)
-{
-        u8 temp;
-
-        temp = aty_ld_8(EXT_MEM_CNTL, par);
-        temp |= 0x02;
-        aty_st_8(EXT_MEM_CNTL, temp, par); // MEM_SDRAM_RESET = 1b
-        temp |= 0x08;
-        aty_st_8(EXT_MEM_CNTL, temp, par); // MEM_CYC_TEST    = 10b
-        temp |= 0x0c;
-        aty_st_8(EXT_MEM_CNTL, temp, par); // MEM_CYC_TEST    = 11b
-        mdelay(5);
-        temp &= 0xf3;
-        aty_st_8(EXT_MEM_CNTL, temp, par); // MEM_CYC_TEST    = 00b
-        temp &= 0xfd;
-        aty_st_8(EXT_MEM_CNTL, temp, par); // MEM_SDRAM_REST  = 0b
-        mdelay(5);
-}
-
-static void init_dll(struct atyfb_par *par)
-{
-        // enable DLL
-        aty_st_pll_ct(PLL_GEN_CNTL,
-                   aty_ld_pll_ct(PLL_GEN_CNTL, par) & 0x7f,
-                   par);
-
-        // reset DLL
-        aty_st_pll_ct(DLL_CNTL, 0x82, par);
-        aty_st_pll_ct(DLL_CNTL, 0xE2, par);
-        mdelay(5);
-        aty_st_pll_ct(DLL_CNTL, 0x82, par);
-        mdelay(6);
-}
-
-static void reset_clocks(struct atyfb_par *par, struct pll_ct *pll,
-                         int hsync_enb)
-{
-        reset_gui(par);
-        aty_st_pll_ct(MCLK_FB_DIV, pll->mclk_fb_div, par);
-        aty_st_pll_ct(SCLK_FB_DIV, pll->sclk_fb_div, par);
-
-        mdelay(15);
-        init_dll(par);
-        aty_st_8(GEN_TEST_CNTL+1, 0x00, par);
-        mdelay(5);
-        aty_st_8(CRTC_GEN_CNTL+3, 0x04, par);
-        mdelay(6);
-        reset_sdram(par);
-        aty_st_8(CRTC_GEN_CNTL+3,
-                 hsync_enb ? 0x00 : 0x04, par);
-
-        aty_st_pll_ct(SPLL_CNTL2, pll->spll_cntl2, par);
-        aty_st_pll_ct(PLL_GEN_CNTL, pll->pll_gen_cntl, par);
-        aty_st_pll_ct(PLL_VCLK_CNTL, pll->pll_vclk_cntl, par);
-}
-
-int atyfb_xl_init(struct fb_info *info)
-{
-        const struct xl_card_cfg_t * card = &card_cfg[xl_card];
-        struct atyfb_par *par = (struct atyfb_par *) info->par;
-        union aty_pll pll;
-        int err;
-        u32 temp;
-        
-        aty_st_8(CONFIG_STAT0, 0x85, par);
-        mdelay(10);
-
-        /*
-         * The following needs to be set before the call
-         * to var_to_pll() below. They'll be re-set again
-         * to the same values in aty_init().
-         */
-        par->ref_clk_per = 100000000UL/card->ref_crystal;
-        par->ram_type = card->mem_type;
-        info->fix.smem_len = card->mem_size;
-        if (xl_card == VICTORIA) {
-                // the MCLK, XCLK are 120MHz on victoria card
-                par->mclk_per = 1000000/120;
-                par->xclk_per = 1000000/120;
-                par->features &= ~M64F_MFB_FORCE_4;
-        }
-        
-        /*
-         * Calculate mclk and xclk dividers, etc. The passed
-         * pixclock and bpp values don't matter yet, the vclk
-         * isn't programmed until later.
-         */
-        if ((err = aty_pll_ct.var_to_pll(info, 39726, 8, &pll)))
-                return err;
-
-        aty_st_pll_ct(LVDS_CNTL0, 0x00, par);
-        aty_st_pll_ct(DLL2_CNTL, card->dll2_cntl, par);
-        aty_st_pll_ct(V2PLL_CNTL, 0x10, par);
-        aty_st_pll_ct(MPLL_CNTL, MPLL_GAIN, par);
-        aty_st_pll_ct(VPLL_CNTL, VPLL_GAIN, par);
-        aty_st_pll_ct(PLL_VCLK_CNTL, 0x00, par);
-        aty_st_pll_ct(VFC_CNTL, 0x1B, par);
-        aty_st_pll_ct(PLL_REF_DIV, pll.ct.pll_ref_div, par);
-        aty_st_pll_ct(PLL_EXT_CNTL, pll.ct.pll_ext_cntl, par);
-        aty_st_pll_ct(SPLL_CNTL2, 0x03, par);
-        aty_st_pll_ct(PLL_GEN_CNTL, 0x44, par);
-
-        reset_clocks(par, &pll.ct, 0);
-        mdelay(10);
-
-        aty_st_pll_ct(VCLK_POST_DIV, 0x03, par);
-        aty_st_pll_ct(VCLK0_FB_DIV, 0xDA, par);
-        aty_st_pll_ct(VCLK_POST_DIV, 0x0F, par);
-        aty_st_pll_ct(VCLK1_FB_DIV, 0xF5, par);
-        aty_st_pll_ct(VCLK_POST_DIV, 0x3F, par);
-        aty_st_pll_ct(PLL_EXT_CNTL, 0x40 | pll.ct.pll_ext_cntl, par);
-        aty_st_pll_ct(VCLK2_FB_DIV, 0x00, par);
-        aty_st_pll_ct(VCLK_POST_DIV, 0xFF, par);
-        aty_st_pll_ct(PLL_EXT_CNTL, 0xC0 | pll.ct.pll_ext_cntl, par);
-        aty_st_pll_ct(VCLK3_FB_DIV, 0x00, par);
-
-        aty_st_8(BUS_CNTL, 0x01, par);
-        aty_st_le32(BUS_CNTL, card->bus_cntl | 0x08000000, par);
-
-        aty_st_le32(CRTC_GEN_CNTL, 0x04000200, par);
-        aty_st_le16(CONFIG_STAT0, 0x0020, par);
-        aty_st_le32(MEM_CNTL, 0x10151A33, par);
-        aty_st_le32(EXT_MEM_CNTL, 0xE0000C01, par);
-        aty_st_le16(CRTC_GEN_CNTL+2, 0x0000, par);
-        aty_st_le32(DAC_CNTL, card->dac_cntl, par);
-        aty_st_le16(GEN_TEST_CNTL, 0x0100, par);
-        aty_st_le32(CUSTOM_MACRO_CNTL, 0x003C0171, par);
-        aty_st_le32(MEM_BUF_CNTL, 0x00382848, par);
-
-        aty_st_le32(HW_DEBUG, card->hw_debug, par);
-        aty_st_le16(MEM_ADDR_CONFIG, 0x0000, par);
-        aty_st_le16(GP_IO+2, 0x0000, par);
-        aty_st_le16(GEN_TEST_CNTL, 0x0000, par);
-        aty_st_le16(EXT_DAC_REGS+2, 0x0000, par);
-        aty_st_le32(CRTC_INT_CNTL, 0x00000000, par);
-        aty_st_le32(TIMER_CONFIG, 0x00000000, par);
-        aty_st_le32(0xEC, 0x00000000, par);
-        aty_st_le32(0xFC, 0x00000000, par);
-
-#if defined (CONFIG_FB_ATY_GENERIC_LCD)
-        {
-                int i;
-
-                for (i = 0; i < ARRAY_SIZE(lcd_tbl); i++)
-                        aty_st_lcd(lcd_tbl[i].lcd_reg, lcd_tbl[i].val, par);
-        }
-#endif
-
-        aty_st_le16(CONFIG_STAT0, 0x00A4, par);
-        mdelay(10);
-
-        aty_st_8(BUS_CNTL+1, 0xA0, par);
-        mdelay(10);
-        
-        reset_clocks(par, &pll.ct, 1);
-        mdelay(10);
-
-        // something about power management
-        aty_st_8(LCD_INDEX, 0x08, par);
-        aty_st_8(LCD_DATA, 0x0A, par);
-        aty_st_8(LCD_INDEX, 0x08, par);
-        aty_st_8(LCD_DATA+3, 0x02, par);
-        aty_st_8(LCD_INDEX, 0x08, par);
-        aty_st_8(LCD_DATA, 0x0B, par);
-        mdelay(2);
-        
-        // enable display requests, enable CRTC
-        aty_st_8(CRTC_GEN_CNTL+3, 0x02, par);
-        // disable display
-        aty_st_8(CRTC_GEN_CNTL, 0x40, par);
-        // disable display requests, disable CRTC
-        aty_st_8(CRTC_GEN_CNTL+3, 0x04, par);
-        mdelay(10);
-
-        aty_st_pll_ct(PLL_YCLK_CNTL, 0x25, par);
-
-        aty_st_le16(CUSTOM_MACRO_CNTL, 0x0179, par);
-        aty_st_le16(CUSTOM_MACRO_CNTL+2, 0x005E, par);
-        aty_st_le16(CUSTOM_MACRO_CNTL+2, card->custom_macro_cntl>>16, par);
-        aty_st_8(CUSTOM_MACRO_CNTL+1,
-                 (card->custom_macro_cntl>>8) & 0xff, par);
-
-        aty_st_le32(MEM_ADDR_CONFIG, card->mem_addr_config, par);
-        aty_st_le32(MEM_CNTL, card->mem_cntl, par);
-        aty_st_le32(EXT_MEM_CNTL, card->ext_mem_cntl, par);
-
-        aty_st_8(CONFIG_STAT0, 0xA0 | card->mem_type, par);
-
-        aty_st_pll_ct(PLL_YCLK_CNTL, 0x01, par);
-        mdelay(15);
-        aty_st_pll_ct(PLL_YCLK_CNTL, card->pll_yclk_cntl, par);
-        mdelay(1);
-        
-        reset_clocks(par, &pll.ct, 0);
-        mdelay(50);
-        reset_clocks(par, &pll.ct, 0);
-        mdelay(50);
-
-        // enable extended register block
-        aty_st_8(BUS_CNTL+3, 0x7B, par);
-        mdelay(1);
-        // disable extended register block
-        aty_st_8(BUS_CNTL+3, 0x73, par);
-
-        aty_st_8(CONFIG_STAT0, 0x80 | card->mem_type, par);
-
-        // disable display requests, disable CRTC
-        aty_st_8(CRTC_GEN_CNTL+3, 0x04, par);
-        // disable mapping registers in VGA aperture
-        aty_st_8(CONFIG_CNTL, aty_ld_8(CONFIG_CNTL, par) & ~0x04, par);
-        mdelay(50);
-        // enable display requests, enable CRTC
-        aty_st_8(CRTC_GEN_CNTL+3, 0x02, par);
-
-        // make GPIO's 14,15,16 all inputs
-        aty_st_8(LCD_INDEX, 0x07, par);
-        aty_st_8(LCD_DATA+3, 0x00, par);
-
-        // enable the display
-        aty_st_8(CRTC_GEN_CNTL, 0x00, par);
-        mdelay(17);
-        // reset the memory controller
-        aty_st_8(GEN_TEST_CNTL+1, 0x02, par);
-        mdelay(15);
-        aty_st_8(GEN_TEST_CNTL+1, 0x00, par);
-        mdelay(30);
-
-        // enable extended register block
-        aty_st_8(BUS_CNTL+3,
-                 (u8)(aty_ld_8(BUS_CNTL+3, par) | 0x08),
-                 par);
-        // set FIFO size to 512 (PIO)
-        aty_st_le32(GUI_CNTL,
-                    aty_ld_le32(GUI_CNTL, par) & ~0x3,
-                    par);
-
-        // enable CRT and disable lcd
-        aty_st_8(LCD_INDEX, 0x01, par);
-        temp = aty_ld_le32(LCD_DATA, par);
-        temp = (temp | 0x01) & ~0x02;
-        aty_st_le32(LCD_DATA, temp, par);
-        return 0;
-}
-
diff --git a/drivers/video/console/bitblit.c b/drivers/video/console/bitblit.c
index e65fc3ef7630..eea422eb1ab5 100644
--- a/drivers/video/console/bitblit.c
+++ b/drivers/video/console/bitblit.c
@@ -234,14 +234,14 @@ static void bit_clear_margins(struct vc_data *vc, struct fb_info *info,
         }
 }
 
-static void bit_cursor(struct vc_data *vc, struct fb_info *info,
-                       struct display *p, int mode, int softback_lines, int fg, int bg)
+static void bit_cursor(struct vc_data *vc, struct fb_info *info, int mode,
+                       int softback_lines, int fg, int bg)
 {
         struct fb_cursor cursor;
-        struct fbcon_ops *ops = (struct fbcon_ops *) info->fbcon_par;
+        struct fbcon_ops *ops = info->fbcon_par;
         unsigned short charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff;
         int w = (vc->vc_font.width + 7) >> 3, c;
-        int y = real_y(p, vc->vc_y);
+        int y = real_y(ops->p, vc->vc_y);
         int attribute, use_sw = (vc->vc_cursor_type & 0x10);
         int err = 1;
         char *src;
@@ -310,7 +310,7 @@ static void bit_cursor(struct vc_data *vc, struct fb_info *info,
         }
 
         if (cursor.set & FB_CUR_SETSIZE ||
-            vc->vc_cursor_type != p->cursor_shape ||
+            vc->vc_cursor_type != ops->p->cursor_shape ||
             ops->cursor_state.mask == NULL ||
             ops->cursor_reset) {
                 char *mask = kmalloc(w*vc->vc_font.height, GFP_ATOMIC);
@@ -323,10 +323,10 @@ static void bit_cursor(struct vc_data *vc, struct fb_info *info,
                 kfree(ops->cursor_state.mask);
                 ops->cursor_state.mask = mask;
 
-                p->cursor_shape = vc->vc_cursor_type;
+                ops->p->cursor_shape = vc->vc_cursor_type;
                 cursor.set |= FB_CUR_SETSHAPE;
 
-                switch (p->cursor_shape & CUR_HWMASK) {
+                switch (ops->p->cursor_shape & CUR_HWMASK) {
                 case CUR_NONE:
                         cur_height = 0;
                         break;
diff --git a/drivers/video/console/fbcon.c b/drivers/video/console/fbcon.c
index 50e4c4eb491f..041d06987861 100644
--- a/drivers/video/console/fbcon.c
+++ b/drivers/video/console/fbcon.c
@@ -209,13 +209,13 @@ static irqreturn_t fb_vbl_detect(int irq, void *dummy, struct pt_regs *fp)
 #endif
 
 #ifdef CONFIG_FRAMEBUFFER_CONSOLE_ROTATION
-static inline void fbcon_set_rotation(struct fb_info *info, struct display *p)
+static inline void fbcon_set_rotation(struct fb_info *info)
 {
         struct fbcon_ops *ops = info->fbcon_par;
 
         if (!(info->flags & FBINFO_MISC_TILEBLITTING) &&
-            p->con_rotate < 4)
-                ops->rotate = p->con_rotate;
+            ops->p->con_rotate < 4)
+                ops->rotate = ops->p->con_rotate;
         else
                 ops->rotate = 0;
 }
@@ -265,7 +265,7 @@ static void fbcon_rotate_all(struct fb_info *info, u32 rotate)
         fbcon_set_all_vcs(info);
 }
 #else
-static inline void fbcon_set_rotation(struct fb_info *info, struct display *p)
+static inline void fbcon_set_rotation(struct fb_info *info)
 {
         struct fbcon_ops *ops = info->fbcon_par;
 
@@ -402,7 +402,7 @@ static void fb_flashcursor(void *private)
         c = scr_readw((u16 *) vc->vc_pos);
         mode = (!ops->cursor_flash || ops->cursor_state.enable) ?
                 CM_ERASE : CM_DRAW;
-        ops->cursor(vc, info, p, mode, softback_lines, get_color(vc, info, c, 1),
+        ops->cursor(vc, info, mode, softback_lines, get_color(vc, info, c, 1),
                     get_color(vc, info, c, 0));
         release_console_sem();
 }
@@ -647,29 +647,27 @@ static void fbcon_prepare_logo(struct vc_data *vc, struct fb_info *info,
 }
 
 #ifdef CONFIG_FB_TILEBLITTING
-static void set_blitting_type(struct vc_data *vc, struct fb_info *info,
-                              struct display *p)
+static void set_blitting_type(struct vc_data *vc, struct fb_info *info)
 {
         struct fbcon_ops *ops = info->fbcon_par;
 
-        ops->p = (p) ? p : &fb_display[vc->vc_num];
+        ops->p = &fb_display[vc->vc_num];
 
         if ((info->flags & FBINFO_MISC_TILEBLITTING))
-                fbcon_set_tileops(vc, info, p, ops);
+                fbcon_set_tileops(vc, info);
         else {
-                fbcon_set_rotation(info, ops->p);
+                fbcon_set_rotation(info);
                 fbcon_set_bitops(ops);
         }
 }
 #else
-static void set_blitting_type(struct vc_data *vc, struct fb_info *info,
-                              struct display *p)
+static void set_blitting_type(struct vc_data *vc, struct fb_info *info)
 {
         struct fbcon_ops *ops = info->fbcon_par;
 
         info->flags &= ~FBINFO_MISC_TILEBLITTING;
-        ops->p = (p) ? p : &fb_display[vc->vc_num];
-        fbcon_set_rotation(info, ops->p);
+        ops->p = &fb_display[vc->vc_num];
+        fbcon_set_rotation(info);
         fbcon_set_bitops(ops);
 }
 #endif /* CONFIG_MISC_TILEBLITTING */
@@ -689,15 +687,14 @@ static int con2fb_acquire_newinfo(struct vc_data *vc, struct fb_info *info,
                 err = -ENODEV;
 
         if (!err) {
-                ops = kmalloc(sizeof(struct fbcon_ops), GFP_KERNEL);
+                ops = kzalloc(sizeof(struct fbcon_ops), GFP_KERNEL);
                 if (!ops)
                         err = -ENOMEM;
         }
 
         if (!err) {
-                memset(ops, 0, sizeof(struct fbcon_ops));
                 info->fbcon_par = ops;
-                set_blitting_type(vc, info, NULL);
+                set_blitting_type(vc, info);
         }
 
         if (err) {
@@ -921,19 +918,18 @@ static const char *fbcon_startup(void)
                 return NULL;
         }
 
-        ops = kmalloc(sizeof(struct fbcon_ops), GFP_KERNEL);
+        ops = kzalloc(sizeof(struct fbcon_ops), GFP_KERNEL);
         if (!ops) {
                 module_put(owner);
                 return NULL;
         }
 
-        memset(ops, 0, sizeof(struct fbcon_ops));
         ops->currcon = -1;
         ops->graphics = 1;
         ops->cur_rotate = -1;
         info->fbcon_par = ops;
         p->con_rotate = rotate;
-        set_blitting_type(vc, info, NULL);
+        set_blitting_type(vc, info);
 
         if (info->fix.type != FB_TYPE_TEXT) {
                 if (fbcon_softback_size) {
@@ -1093,7 +1089,7 @@ static void fbcon_init(struct vc_data *vc, int init)
 
         ops = info->fbcon_par;
         p->con_rotate = rotate;
-        set_blitting_type(vc, info, NULL);
+        set_blitting_type(vc, info);
 
         cols = vc->vc_cols;
         rows = vc->vc_rows;
@@ -1141,9 +1137,9 @@ static void fbcon_init(struct vc_data *vc, int init)
         if (vc == svc && softback_buf)
                 fbcon_update_softback(vc);
 
-        if (ops->rotate_font && ops->rotate_font(info, vc, p)) {
+        if (ops->rotate_font && ops->rotate_font(info, vc)) {
                 ops->rotate = FB_ROTATE_UR;
-                set_blitting_type(vc, info, p);
+                set_blitting_type(vc, info);
         }
 
 }
@@ -1243,7 +1239,6 @@ static void fbcon_cursor(struct vc_data *vc, int mode)
 {
         struct fb_info *info = registered_fb[con2fb_map[vc->vc_num]];
         struct fbcon_ops *ops = info->fbcon_par;
-        struct display *p = &fb_display[vc->vc_num];
         int y;
         int c = scr_readw((u16 *) vc->vc_pos);
 
@@ -1260,7 +1255,7 @@ static void fbcon_cursor(struct vc_data *vc, int mode)
                 y = 0;
         }
 
-        ops->cursor(vc, info, p, mode, y, get_color(vc, info, c, 1),
+        ops->cursor(vc, info, mode, y, get_color(vc, info, c, 1),
                     get_color(vc, info, c, 0));
         vbl_cursor_cnt = CURSOR_DRAW_DELAY;
 }
@@ -1411,16 +1406,13 @@ static __inline__ void ypan_up_redraw(struct vc_data *vc, int t, int count)
         struct fb_info *info = registered_fb[con2fb_map[vc->vc_num]];
         struct fbcon_ops *ops = info->fbcon_par;
         struct display *p = &fb_display[vc->vc_num];
-        int redraw = 0;
 
         p->yscroll += count;
+
         if (p->yscroll > p->vrows - vc->vc_rows) {
                 p->yscroll -= p->vrows - vc->vc_rows;
-                redraw = 1;
-        }
-
-        if (redraw)
                 fbcon_redraw_move(vc, p, t + count, vc->vc_rows - count, t);
+        }
 
         ops->var.xoffset = 0;
         ops->var.yoffset = p->yscroll * vc->vc_font.height;
@@ -1462,16 +1454,13 @@ static __inline__ void ypan_down_redraw(struct vc_data *vc, int t, int count)
         struct fb_info *info = registered_fb[con2fb_map[vc->vc_num]];
         struct fbcon_ops *ops = info->fbcon_par;
         struct display *p = &fb_display[vc->vc_num];
-        int redraw = 0;
 
         p->yscroll -= count;
+
         if (p->yscroll < 0) {
                 p->yscroll += p->vrows - vc->vc_rows;
-                redraw = 1;
-        }
-
-        if (redraw)
                 fbcon_redraw_move(vc, p, t, vc->vc_rows - count, t + count);
+        }
 
         ops->var.xoffset = 0;
         ops->var.yoffset = p->yscroll * vc->vc_font.height;
@@ -1968,7 +1957,8 @@ static __inline__ void updatescrollmode(struct display *p,
                 divides(ypan, vc->vc_font.height) && vyres > yres;
         int good_wrap = (cap & FBINFO_HWACCEL_YWRAP) &&
                 divides(ywrap, vc->vc_font.height) &&
-                divides(vc->vc_font.height, vyres);
+                divides(vc->vc_font.height, vyres) &&
+                divides(vc->vc_font.height, yres);
         int reading_fast = cap & FBINFO_READS_FAST;
         int fast_copyarea = (cap & FBINFO_HWACCEL_COPYAREA) &&
                 !(cap & FBINFO_HWACCEL_DISABLED);
@@ -2107,16 +2097,19 @@ static int fbcon_switch(struct vc_data *vc)
                                  info->flags & FBINFO_MISC_ALWAYS_SETPAR)) {
                 if (info->fbops->fb_set_par)
                         info->fbops->fb_set_par(info);
-                fbcon_del_cursor_timer(old_info);
-                fbcon_add_cursor_timer(info);
+
+                if (old_info != info) {
+                        fbcon_del_cursor_timer(old_info);
+                        fbcon_add_cursor_timer(info);
+                }
         }
 
-        set_blitting_type(vc, info, p);
+        set_blitting_type(vc, info);
         ops->cursor_reset = 1;
 
-        if (ops->rotate_font && ops->rotate_font(info, vc, p)) {
+        if (ops->rotate_font && ops->rotate_font(info, vc)) {
                 ops->rotate = FB_ROTATE_UR;
-                set_blitting_type(vc, info, p);
+                set_blitting_type(vc, info);
         }
 
         vc->vc_can_do_color = (fb_get_color_depth(&info->var, &info->fix)!=1);
@@ -2739,7 +2732,7 @@ static void fbcon_modechanged(struct fb_info *info)
                 return;
 
         p = &fb_display[vc->vc_num];
-        set_blitting_type(vc, info, p);
+        set_blitting_type(vc, info);
 
         if (CON_IS_VISIBLE(vc)) {
                 var_to_display(p, &info->var, info);
@@ -2781,7 +2774,7 @@ static void fbcon_set_all_vcs(struct fb_info *info)
                         continue;
 
                 p = &fb_display[vc->vc_num];
-                set_blitting_type(vc, info, p);
+                set_blitting_type(vc, info);
                 var_to_display(p, &info->var, info);
                 cols = FBCON_SWAP(ops->rotate, info->var.xres, info->var.yres);
                 rows = FBCON_SWAP(ops->rotate, info->var.yres, info->var.xres);
@@ -2806,6 +2799,8 @@ static void fbcon_set_all_vcs(struct fb_info *info)
                                 fbcon_update_softback(vc);
                 }
         }
+
+        ops->p = &fb_display[ops->currcon];
 }
 
 static int fbcon_mode_deleted(struct fb_info *info,
diff --git a/drivers/video/console/fbcon.h b/drivers/video/console/fbcon.h
index 6892e7ff34de..c38c3d8e7a74 100644
--- a/drivers/video/console/fbcon.h
+++ b/drivers/video/console/fbcon.h
@@ -62,12 +62,10 @@ struct fbcon_ops {
                       int fg, int bg);
         void (*clear_margins)(struct vc_data *vc, struct fb_info *info,
                               int bottom_only);
-        void (*cursor)(struct vc_data *vc, struct fb_info *info,
-                       struct display *p, int mode, int softback_lines,
-                       int fg, int bg);
+        void (*cursor)(struct vc_data *vc, struct fb_info *info, int mode,
+                       int softback_lines, int fg, int bg);
         int  (*update_start)(struct fb_info *info);
-        int  (*rotate_font)(struct fb_info *info, struct vc_data *vc,
-                            struct display *p);
+        int  (*rotate_font)(struct fb_info *info, struct vc_data *vc);
         struct fb_var_screeninfo var;  /* copy of the current fb_var_screeninfo */
         struct timer_list cursor_timer; /* Cursor timer */
         struct fb_cursor cursor_state;
@@ -173,8 +171,7 @@ struct fbcon_ops {
 #define SCROLL_PAN_REDRAW  0x005
 
 #ifdef CONFIG_FB_TILEBLITTING
-extern void fbcon_set_tileops(struct vc_data *vc, struct fb_info *info,
-                              struct display *p, struct fbcon_ops *ops);
+extern void fbcon_set_tileops(struct vc_data *vc, struct fb_info *info);
 #endif
 extern void fbcon_set_bitops(struct fbcon_ops *ops);
 extern int  soft_cursor(struct fb_info *info, struct fb_cursor *cursor);
diff --git a/drivers/video/console/fbcon_ccw.c b/drivers/video/console/fbcon_ccw.c
index 4952b66ae206..990289a69b78 100644
--- a/drivers/video/console/fbcon_ccw.c
+++ b/drivers/video/console/fbcon_ccw.c
@@ -219,19 +219,18 @@ static void ccw_clear_margins(struct vc_data *vc, struct fb_info *info,
         }
 }
 
-static void ccw_cursor(struct vc_data *vc, struct fb_info *info,
-                      struct display *p, int mode, int softback_lines,
-                      int fg, int bg)
+static void ccw_cursor(struct vc_data *vc, struct fb_info *info, int mode,
+                       int softback_lines, int fg, int bg)
 {
         struct fb_cursor cursor;
-        struct fbcon_ops *ops = (struct fbcon_ops *) info->fbcon_par;
+        struct fbcon_ops *ops = info->fbcon_par;
         unsigned short charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff;
         int w = (vc->vc_font.height + 7) >> 3, c;
-        int y = real_y(p, vc->vc_y);
+        int y = real_y(ops->p, vc->vc_y);
         int attribute, use_sw = (vc->vc_cursor_type & 0x10);
         int err = 1, dx, dy;
         char *src;
-        u32 vyres = GETVYRES(p->scrollmode, info);
+        u32 vyres = GETVYRES(ops->p->scrollmode, info);
 
         if (!ops->fontbuffer)
                 return;
@@ -303,7 +302,7 @@ static void ccw_cursor(struct vc_data *vc, struct fb_info *info,
         }
 
         if (cursor.set & FB_CUR_SETSIZE ||
-            vc->vc_cursor_type != p->cursor_shape ||
+            vc->vc_cursor_type != ops->p->cursor_shape ||
             ops->cursor_state.mask == NULL ||
             ops->cursor_reset) {
                 char *tmp, *mask = kmalloc(w*vc->vc_font.width, GFP_ATOMIC);
@@ -323,10 +322,10 @@ static void ccw_cursor(struct vc_data *vc, struct fb_info *info,
                 kfree(ops->cursor_state.mask);
                 ops->cursor_state.mask = mask;
 
-                p->cursor_shape = vc->vc_cursor_type;
+                ops->p->cursor_shape = vc->vc_cursor_type;
                 cursor.set |= FB_CUR_SETSHAPE;
 
-                switch (p->cursor_shape & CUR_HWMASK) {
+                switch (ops->p->cursor_shape & CUR_HWMASK) {
                 case CUR_NONE:
                         cur_height = 0;
                         break;
diff --git a/drivers/video/console/fbcon_cw.c b/drivers/video/console/fbcon_cw.c
index 6d92b8456206..d44c5fa515fb 100644
--- a/drivers/video/console/fbcon_cw.c
+++ b/drivers/video/console/fbcon_cw.c
@@ -203,19 +203,18 @@ static void cw_clear_margins(struct vc_data *vc, struct fb_info *info,
         }
 }
 
-static void cw_cursor(struct vc_data *vc, struct fb_info *info,
-                      struct display *p, int mode, int softback_lines,
-                      int fg, int bg)
+static void cw_cursor(struct vc_data *vc, struct fb_info *info, int mode,
+                      int softback_lines, int fg, int bg)
 {
         struct fb_cursor cursor;
-        struct fbcon_ops *ops = (struct fbcon_ops *) info->fbcon_par;
+        struct fbcon_ops *ops = info->fbcon_par;
         unsigned short charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff;
         int w = (vc->vc_font.height + 7) >> 3, c;
-        int y = real_y(p, vc->vc_y);
+        int y = real_y(ops->p, vc->vc_y);
         int attribute, use_sw = (vc->vc_cursor_type & 0x10);
         int err = 1, dx, dy;
         char *src;
-        u32 vxres = GETVXRES(p->scrollmode, info);
+        u32 vxres = GETVXRES(ops->p->scrollmode, info);
 
         if (!ops->fontbuffer)
                 return;
@@ -287,7 +286,7 @@ static void cw_cursor(struct vc_data *vc, struct fb_info *info,
         }
 
         if (cursor.set & FB_CUR_SETSIZE ||
-            vc->vc_cursor_type != p->cursor_shape ||
+            vc->vc_cursor_type != ops->p->cursor_shape ||
             ops->cursor_state.mask == NULL ||
             ops->cursor_reset) {
                 char *tmp, *mask = kmalloc(w*vc->vc_font.width, GFP_ATOMIC);
@@ -307,10 +306,10 @@ static void cw_cursor(struct vc_data *vc, struct fb_info *info,
                 kfree(ops->cursor_state.mask);
                 ops->cursor_state.mask = mask;
 
-                p->cursor_shape = vc->vc_cursor_type;
+                ops->p->cursor_shape = vc->vc_cursor_type;
                 cursor.set |= FB_CUR_SETSHAPE;
 
-                switch (p->cursor_shape & CUR_HWMASK) {
+                switch (ops->p->cursor_shape & CUR_HWMASK) {
                 case CUR_NONE:
                         cur_height = 0;
                         break;
diff --git a/drivers/video/console/fbcon_rotate.c b/drivers/video/console/fbcon_rotate.c
index ec0dd8fe241c..2dc091fbd5c9 100644
--- a/drivers/video/console/fbcon_rotate.c
+++ b/drivers/video/console/fbcon_rotate.c
@@ -18,8 +18,7 @@
 #include "fbcon.h"
 #include "fbcon_rotate.h"
 
-static int fbcon_rotate_font(struct fb_info *info, struct vc_data *vc,
-                             struct display *p)
+static int fbcon_rotate_font(struct fb_info *info, struct vc_data *vc)
 {
         struct fbcon_ops *ops = info->fbcon_par;
         int len, err = 0;
@@ -28,12 +27,12 @@ static int fbcon_rotate_font(struct fb_info *info, struct vc_data *vc,
         u8 *dst;
 
         if (vc->vc_font.data == ops->fontdata &&
-            p->con_rotate == ops->cur_rotate)
+            ops->p->con_rotate == ops->cur_rotate)
                 goto finished;
 
         src = ops->fontdata = vc->vc_font.data;
-        ops->cur_rotate = p->con_rotate;
-        len = (!p->userfont) ? 256 : FNTCHARCNT(src);
+        ops->cur_rotate = ops->p->con_rotate;
+        len = (!ops->p->userfont) ? 256 : FNTCHARCNT(src);
         s_cellsize = ((vc->vc_font.width + 7)/8) *
                 vc->vc_font.height;
         d_cellsize = s_cellsize;
diff --git a/drivers/video/console/fbcon_rotate.h b/drivers/video/console/fbcon_rotate.h
index 1b8f92fdc6a8..75be5ce53dc5 100644
--- a/drivers/video/console/fbcon_rotate.h
+++ b/drivers/video/console/fbcon_rotate.h
@@ -11,8 +11,6 @@
 #ifndef _FBCON_ROTATE_H
 #define _FBCON_ROTATE_H
 
-#define FNTCHARCNT(fd)  (((int *)(fd))[-3])
-
 #define GETVYRES(s,i) ({                           \
         (s == SCROLL_REDRAW || s == SCROLL_MOVE) ? \
         (i)->var.yres : (i)->var.yres_virtual; })
diff --git a/drivers/video/console/fbcon_ud.c b/drivers/video/console/fbcon_ud.c
index 9dd059e8b645..f56ed068a5bc 100644
--- a/drivers/video/console/fbcon_ud.c
+++ b/drivers/video/console/fbcon_ud.c
@@ -249,20 +249,19 @@ static void ud_clear_margins(struct vc_data *vc, struct fb_info *info,
         }
 }
 
-static void ud_cursor(struct vc_data *vc, struct fb_info *info,
-                      struct display *p, int mode, int softback_lines,
-                      int fg, int bg)
+static void ud_cursor(struct vc_data *vc, struct fb_info *info, int mode,
+                      int softback_lines, int fg, int bg)
 {
         struct fb_cursor cursor;
-        struct fbcon_ops *ops = (struct fbcon_ops *) info->fbcon_par;
+        struct fbcon_ops *ops = info->fbcon_par;
         unsigned short charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff;
         int w = (vc->vc_font.width + 7) >> 3, c;
-        int y = real_y(p, vc->vc_y);
+        int y = real_y(ops->p, vc->vc_y);
         int attribute, use_sw = (vc->vc_cursor_type & 0x10);
         int err = 1, dx, dy;
         char *src;
-        u32 vyres = GETVYRES(p->scrollmode, info);
-        u32 vxres = GETVXRES(p->scrollmode, info);
+        u32 vyres = GETVYRES(ops->p->scrollmode, info);
+        u32 vxres = GETVXRES(ops->p->scrollmode, info);
 
         if (!ops->fontbuffer)
                 return;
@@ -334,7 +333,7 @@ static void ud_cursor(struct vc_data *vc, struct fb_info *info,
         }
 
         if (cursor.set & FB_CUR_SETSIZE ||
-            vc->vc_cursor_type != p->cursor_shape ||
+            vc->vc_cursor_type != ops->p->cursor_shape ||
             ops->cursor_state.mask == NULL ||
             ops->cursor_reset) {
                 char *mask = kmalloc(w*vc->vc_font.height, GFP_ATOMIC);
@@ -347,10 +346,10 @@ static void ud_cursor(struct vc_data *vc, struct fb_info *info,
                 kfree(ops->cursor_state.mask);
                 ops->cursor_state.mask = mask;
 
-                p->cursor_shape = vc->vc_cursor_type;
+                ops->p->cursor_shape = vc->vc_cursor_type;
                 cursor.set |= FB_CUR_SETSHAPE;
 
-                switch (p->cursor_shape & CUR_HWMASK) {
+                switch (ops->p->cursor_shape & CUR_HWMASK) {
                 case CUR_NONE:
                         cur_height = 0;
                         break;
diff --git a/drivers/video/console/softcursor.c b/drivers/video/console/softcursor.c
index 8529bf08db28..3957fc7523e2 100644
--- a/drivers/video/console/softcursor.c
+++ b/drivers/video/console/softcursor.c
@@ -17,6 +17,8 @@
 #include <asm/uaccess.h>
 #include <asm/io.h>
 
+#include "fbcon.h"
+
 int soft_cursor(struct fb_info *info, struct fb_cursor *cursor)
 {
         unsigned int scan_align = info->pixmap.scan_align - 1;
diff --git a/drivers/video/console/tileblit.c b/drivers/video/console/tileblit.c
index cb25324a5635..153352ca9461 100644
--- a/drivers/video/console/tileblit.c
+++ b/drivers/video/console/tileblit.c
@@ -80,9 +80,8 @@ static void tile_clear_margins(struct vc_data *vc, struct fb_info *info,
         return;
 }
 
-static void tile_cursor(struct vc_data *vc, struct fb_info *info,
-                        struct display *p, int mode, int softback_lines,
-                        int fg, int bg)
+static void tile_cursor(struct vc_data *vc, struct fb_info *info, int mode,
+                        int softback_lines, int fg, int bg)
 {
         struct fb_tilecursor cursor;
         int use_sw = (vc->vc_cursor_type & 0x01);
@@ -130,10 +129,10 @@ static int tile_update_start(struct fb_info *info)
         return err;
 }
 
-void fbcon_set_tileops(struct vc_data *vc, struct fb_info *info,
-                       struct display *p, struct fbcon_ops *ops)
+void fbcon_set_tileops(struct vc_data *vc, struct fb_info *info)
 {
         struct fb_tilemap map;
+        struct fbcon_ops *ops = info->fbcon_par;
 
         ops->bmove = tile_bmove;
         ops->clear = tile_clear;
@@ -142,13 +141,13 @@ void fbcon_set_tileops(struct vc_data *vc, struct fb_info *info,
         ops->cursor = tile_cursor;
         ops->update_start = tile_update_start;
 
-        if (p) {
+        if (ops->p) {
                 map.width = vc->vc_font.width;
                 map.height = vc->vc_font.height;
                 map.depth = 1;
-                map.length = (p->userfont) ?
-                        FNTCHARCNT(p->fontdata) : 256;
-                map.data = p->fontdata;
+                map.length = (ops->p->userfont) ?
+                        FNTCHARCNT(ops->p->fontdata) : 256;
+                map.data = ops->p->fontdata;
                 info->tileops->fb_settile(info, &map);
         }
 }
diff --git a/drivers/video/fbcvt.c b/drivers/video/fbcvt.c
index 0b6af00d197e..ac90883dc3aa 100644
--- a/drivers/video/fbcvt.c
+++ b/drivers/video/fbcvt.c
@@ -214,12 +214,11 @@ static void fb_cvt_print_name(struct fb_cvt_data *cvt)
 {
         u32 pixcount, pixcount_mod;
         int cnt = 255, offset = 0, read = 0;
-        u8 *buf = kmalloc(256, GFP_KERNEL);
+        u8 *buf = kzalloc(256, GFP_KERNEL);
 
         if (!buf)
                 return;
 
-        memset(buf, 0, 256);
         pixcount = (cvt->xres * (cvt->yres/cvt->interlace))/1000000;
         pixcount_mod = (cvt->xres * (cvt->yres/cvt->interlace)) % 1000000;
         pixcount_mod /= 1000;
diff --git a/drivers/video/fbmem.c b/drivers/video/fbmem.c
index 10dfdf035264..32a9b69becc5 100644
--- a/drivers/video/fbmem.c
+++ b/drivers/video/fbmem.c
@@ -589,17 +589,19 @@ fb_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
                 return info->fbops->fb_read(file, buf, count, ppos);
         
         total_size = info->screen_size;
+
         if (total_size == 0)
                 total_size = info->fix.smem_len;
 
         if (p >= total_size)
-            return 0;
+                return 0;
+
         if (count >= total_size)
-            count = total_size;
+                count = total_size;
+
         if (count + p > total_size)
                 count = total_size - p;
 
-        cnt = 0;
         buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count,
                          GFP_KERNEL);
         if (!buffer)
@@ -636,6 +638,7 @@ fb_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
         }
 
         kfree(buffer);
+
         return (err) ? err : cnt;
 }
 
@@ -648,7 +651,7 @@ fb_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
         struct fb_info *info = registered_fb[fbidx];
         u32 *buffer, *src;
         u32 __iomem *dst;
-        int c, i, cnt = 0, err;
+        int c, i, cnt = 0, err = 0;
         unsigned long total_size;
 
         if (!info || !info->screen_base)
@@ -661,19 +664,19 @@ fb_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
                 return info->fbops->fb_write(file, buf, count, ppos);
         
         total_size = info->screen_size;
+
         if (total_size == 0)
                 total_size = info->fix.smem_len;
 
         if (p > total_size)
-            return -ENOSPC;
+                return 0;
+
         if (count >= total_size)
-            count = total_size;
-        err = 0;
-        if (count + p > total_size) {
-            count = total_size - p;
-            err = -ENOSPC;
-        }
-        cnt = 0;
+                count = total_size;
+
+        if (count + p > total_size)
+                count = total_size - p;
+
         buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count,
                          GFP_KERNEL);
         if (!buffer)
@@ -687,12 +690,15 @@ fb_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
         while (count) {
                 c = (count > PAGE_SIZE) ? PAGE_SIZE : count;
                 src = buffer;
+
                 if (copy_from_user(src, buf, c)) {
                         err = -EFAULT;
                         break;
                 }
+
                 for (i = c >> 2; i--; )
                         fb_writel(*src++, dst++);
+
                 if (c & 3) {
                         u8 *src8 = (u8 *) src;
                         u8 __iomem *dst8 = (u8 __iomem *) dst;
@@ -702,11 +708,13 @@ fb_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
 
                         dst = (u32 __iomem *) dst8;
                 }
+
                 *ppos += c;
                 buf += c;
                 cnt += c;
                 count -= c;
         }
+
         kfree(buffer);
 
         return (err) ? err : cnt;
@@ -1226,6 +1234,7 @@ fb_open(struct inode *inode, struct file *file)
                 return -ENODEV;
         if (!try_module_get(info->fbops->owner))
                 return -ENODEV;
+        file->private_data = info;
         if (info->fbops->fb_open) {
                 res = info->fbops->fb_open(info,1);
                 if (res)
@@ -1237,11 +1246,9 @@ fb_open(struct inode *inode, struct file *file)
 static int 
 fb_release(struct inode *inode, struct file *file)
 {
-        int fbidx = iminor(inode);
-        struct fb_info *info;
+        struct fb_info * const info = file->private_data;
 
         lock_kernel();
-        info = registered_fb[fbidx];
         if (info->fbops->fb_release)
                 info->fbops->fb_release(info,1);
         module_put(info->fbops->owner);
diff --git a/drivers/video/fbmon.c b/drivers/video/fbmon.c
index fc7965b66775..7c74e7325d95 100644
--- a/drivers/video/fbmon.c
+++ b/drivers/video/fbmon.c
@@ -317,26 +317,29 @@ static int edid_is_monitor_block(unsigned char *block)
 static void calc_mode_timings(int xres, int yres, int refresh,
                               struct fb_videomode *mode)
 {
-        struct fb_var_screeninfo var;
-        struct fb_info info;
+        struct fb_var_screeninfo *var;
         
-        memset(&var, 0, sizeof(struct fb_var_screeninfo));
-        var.xres = xres;
-        var.yres = yres;
-        fb_get_mode(FB_VSYNCTIMINGS | FB_IGNOREMON, 
-                    refresh, &var, &info);
-        mode->xres = xres;
-        mode->yres = yres;
-        mode->pixclock = var.pixclock;
-        mode->refresh = refresh;
-        mode->left_margin = var.left_margin;
-        mode->right_margin = var.right_margin;
-        mode->upper_margin = var.upper_margin;
-        mode->lower_margin = var.lower_margin;
-        mode->hsync_len = var.hsync_len;
-        mode->vsync_len = var.vsync_len;
-        mode->vmode = 0;
-        mode->sync = 0;
+        var = kzalloc(sizeof(struct fb_var_screeninfo), GFP_KERNEL);
+
+        if (var) {
+                var->xres = xres;
+                var->yres = yres;
+                fb_get_mode(FB_VSYNCTIMINGS | FB_IGNOREMON,
+                            refresh, var, NULL);
+                mode->xres = xres;
+                mode->yres = yres;
+                mode->pixclock = var->pixclock;
+                mode->refresh = refresh;
+                mode->left_margin = var->left_margin;
+                mode->right_margin = var->right_margin;
+                mode->upper_margin = var->upper_margin;
+                mode->lower_margin = var->lower_margin;
+                mode->hsync_len = var->hsync_len;
+                mode->vsync_len = var->vsync_len;
+                mode->vmode = 0;
+                mode->sync = 0;
+                kfree(var);
+        }
 }
 
 static int get_est_timing(unsigned char *block, struct fb_videomode *mode)
@@ -525,10 +528,9 @@ static struct fb_videomode *fb_create_modedb(unsigned char *edid, int *dbsize)
         unsigned char *block;
         int num = 0, i;
 
-        mode = kmalloc(50 * sizeof(struct fb_videomode), GFP_KERNEL);
+        mode = kzalloc(50 * sizeof(struct fb_videomode), GFP_KERNEL);
         if (mode == NULL)
                 return NULL;
-        memset(mode, 0, 50 * sizeof(struct fb_videomode));
 
         if (edid == NULL || !edid_checksum(edid) || 
             !edid_check_header(edid)) {
@@ -1105,15 +1107,21 @@ static void fb_timings_dclk(struct __fb_timings *timings)
  */ 
 int fb_get_mode(int flags, u32 val, struct fb_var_screeninfo *var, struct fb_info *info)
 {
-        struct __fb_timings timings;
+        struct __fb_timings *timings;
         u32 interlace = 1, dscan = 1;
-        u32 hfmin, hfmax, vfmin, vfmax, dclkmin, dclkmax;
+        u32 hfmin, hfmax, vfmin, vfmax, dclkmin, dclkmax, err = 0;
+
+
+        timings = kzalloc(sizeof(struct __fb_timings), GFP_KERNEL);
+
+        if (!timings)
+                return -ENOMEM;
 
         /* 
          * If monspecs are invalid, use values that are enough
          * for 640x480@60
          */
-        if (!info->monspecs.hfmax || !info->monspecs.vfmax ||
+        if (!info || !info->monspecs.hfmax || !info->monspecs.vfmax ||
             !info->monspecs.dclkmax ||
             info->monspecs.hfmax < info->monspecs.hfmin ||
             info->monspecs.vfmax < info->monspecs.vfmin ||
@@ -1130,65 +1138,66 @@ int fb_get_mode(int flags, u32 val, struct fb_var_screeninfo *var, struct fb_inf
                 dclkmax = info->monspecs.dclkmax;
         }
 
-        memset(&timings, 0, sizeof(struct __fb_timings));
-        timings.hactive = var->xres;
-        timings.vactive = var->yres;
+        timings->hactive = var->xres;
+        timings->vactive = var->yres;
         if (var->vmode & FB_VMODE_INTERLACED) { 
-                timings.vactive /= 2;
+                timings->vactive /= 2;
                 interlace = 2;
         }
         if (var->vmode & FB_VMODE_DOUBLE) {
-                timings.vactive *= 2;
+                timings->vactive *= 2;
                 dscan = 2;
         }
 
         switch (flags & ~FB_IGNOREMON) {
         case FB_MAXTIMINGS: /* maximize refresh rate */
-                timings.hfreq = hfmax;
-                fb_timings_hfreq(&timings);
-                if (timings.vfreq > vfmax) {
-                        timings.vfreq = vfmax;
-                        fb_timings_vfreq(&timings);
+                timings->hfreq = hfmax;
+                fb_timings_hfreq(timings);
+                if (timings->vfreq > vfmax) {
+                        timings->vfreq = vfmax;
+                        fb_timings_vfreq(timings);
                 }
-                if (timings.dclk > dclkmax) {
-                        timings.dclk = dclkmax;
-                        fb_timings_dclk(&timings);
+                if (timings->dclk > dclkmax) {
+                        timings->dclk = dclkmax;
+                        fb_timings_dclk(timings);
                 }
                 break;
         case FB_VSYNCTIMINGS: /* vrefresh driven */
-                timings.vfreq = val;
-                fb_timings_vfreq(&timings);
+                timings->vfreq = val;
+                fb_timings_vfreq(timings);
                 break;
         case FB_HSYNCTIMINGS: /* hsync driven */
-                timings.hfreq = val;
-                fb_timings_hfreq(&timings);
+                timings->hfreq = val;
+                fb_timings_hfreq(timings);
                 break;
         case FB_DCLKTIMINGS: /* pixelclock driven */
-                timings.dclk = PICOS2KHZ(val) * 1000;
-                fb_timings_dclk(&timings);
+                timings->dclk = PICOS2KHZ(val) * 1000;
+                fb_timings_dclk(timings);
                 break;
         default:
-                return -EINVAL;
+                err = -EINVAL;
                 
         } 
         
-        if (!(flags & FB_IGNOREMON) && 
-            (timings.vfreq < vfmin || timings.vfreq > vfmax || 
-             timings.hfreq < hfmin || timings.hfreq > hfmax ||
-             timings.dclk < dclkmin || timings.dclk > dclkmax))
-                return -EINVAL;
-
-        var->pixclock = KHZ2PICOS(timings.dclk/1000);
-        var->hsync_len = (timings.htotal * 8)/100;
-        var->right_margin = (timings.hblank/2) - var->hsync_len;
-        var->left_margin = timings.hblank - var->right_margin - var->hsync_len;
-        
-        var->vsync_len = (3 * interlace)/dscan;
-        var->lower_margin = (1 * interlace)/dscan;
-        var->upper_margin = (timings.vblank * interlace)/dscan - 
-                (var->vsync_len + var->lower_margin);
+        if (err || (!(flags & FB_IGNOREMON) &&
+            (timings->vfreq < vfmin || timings->vfreq > vfmax ||
+             timings->hfreq < hfmin || timings->hfreq > hfmax ||
+             timings->dclk < dclkmin || timings->dclk > dclkmax))) {
+                err = -EINVAL;
+        } else {
+                var->pixclock = KHZ2PICOS(timings->dclk/1000);
+                var->hsync_len = (timings->htotal * 8)/100;
+                var->right_margin = (timings->hblank/2) - var->hsync_len;
+                var->left_margin = timings->hblank - var->right_margin -
+                        var->hsync_len;
+                var->vsync_len = (3 * interlace)/dscan;
+                var->lower_margin = (1 * interlace)/dscan;
+                var->upper_margin = (timings->vblank * interlace)/dscan -
+                        (var->vsync_len + var->lower_margin);
+        }
         
-        return 0;
+        kfree(timings);
+        return err;
 }
 #else
 int fb_parse_edid(unsigned char *edid, struct fb_var_screeninfo *var)
diff --git a/drivers/video/fbsysfs.c b/drivers/video/fbsysfs.c
index 08dac9580d15..6d26057337e2 100644
--- a/drivers/video/fbsysfs.c
+++ b/drivers/video/fbsysfs.c
@@ -43,10 +43,11 @@ struct fb_info *framebuffer_alloc(size_t size, struct device *dev)
         if (size)
                 fb_info_size += PADDING;
 
-        p = kmalloc(fb_info_size + size, GFP_KERNEL);
+        p = kzalloc(fb_info_size + size, GFP_KERNEL);
+
         if (!p)
                 return NULL;
-        memset(p, 0, fb_info_size + size);
+
         info = (struct fb_info *) p;
 
         if (size)
@@ -106,8 +107,7 @@ static int mode_string(char *buf, unsigned int offset,
 static ssize_t store_mode(struct class_device *class_device, const char * buf,
                           size_t count)
 {
-        struct fb_info *fb_info =
-                (struct fb_info *)class_get_devdata(class_device);
+        struct fb_info *fb_info = class_get_devdata(class_device);
         char mstr[100];
         struct fb_var_screeninfo var;
         struct fb_modelist *modelist;
@@ -137,8 +137,7 @@ static ssize_t store_mode(struct class_device *class_device, const char * buf,
 
 static ssize_t show_mode(struct class_device *class_device, char *buf)
 {
-        struct fb_info *fb_info =
-                (struct fb_info *)class_get_devdata(class_device);
+        struct fb_info *fb_info = class_get_devdata(class_device);
 
         if (!fb_info->mode)
                 return 0;
@@ -149,8 +148,7 @@ static ssize_t show_mode(struct class_device *class_device, char *buf)
 static ssize_t store_modes(struct class_device *class_device, const char * buf,
                            size_t count)
 {
-        struct fb_info *fb_info =
-                (struct fb_info *)class_get_devdata(class_device);
+        struct fb_info *fb_info = class_get_devdata(class_device);
         LIST_HEAD(old_list);
         int i = count / sizeof(struct fb_videomode);
 
@@ -174,8 +172,7 @@ static ssize_t store_modes(struct class_device *class_device, const char * buf,
 
 static ssize_t show_modes(struct class_device *class_device, char *buf)
 {
-        struct fb_info *fb_info =
-                (struct fb_info *)class_get_devdata(class_device);
+        struct fb_info *fb_info = class_get_devdata(class_device);
         unsigned int i;
         struct list_head *pos;
         struct fb_modelist *modelist;
@@ -193,8 +190,7 @@ static ssize_t show_modes(struct class_device *class_device, char *buf)
 static ssize_t store_bpp(struct class_device *class_device, const char * buf,
                          size_t count)
 {
-        struct fb_info *fb_info =
-                (struct fb_info *)class_get_devdata(class_device);
+        struct fb_info *fb_info = class_get_devdata(class_device);
         struct fb_var_screeninfo var;
         char ** last = NULL;
         int err;
@@ -208,8 +204,7 @@ static ssize_t store_bpp(struct class_device *class_device, const char * buf,
 
 static ssize_t show_bpp(struct class_device *class_device, char *buf)
 {
-        struct fb_info *fb_info =
-                (struct fb_info *)class_get_devdata(class_device);
+        struct fb_info *fb_info = class_get_devdata(class_device);
         return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->var.bits_per_pixel);
 }
 
@@ -280,8 +275,7 @@ static ssize_t show_con_rotate(struct class_device *class_device, char *buf)
 static ssize_t store_virtual(struct class_device *class_device,
                              const char * buf, size_t count)
 {
-        struct fb_info *fb_info =
-                (struct fb_info *)class_get_devdata(class_device);
+        struct fb_info *fb_info = class_get_devdata(class_device);
         struct fb_var_screeninfo var;
         char *last = NULL;
         int err;
@@ -300,16 +294,14 @@ static ssize_t store_virtual(struct class_device *class_device,
 
 static ssize_t show_virtual(struct class_device *class_device, char *buf)
 {
-        struct fb_info *fb_info =
-                (struct fb_info *)class_get_devdata(class_device);
+        struct fb_info *fb_info = class_get_devdata(class_device);
         return snprintf(buf, PAGE_SIZE, "%d,%d\n", fb_info->var.xres_virtual,
                         fb_info->var.yres_virtual);
 }
 
 static ssize_t show_stride(struct class_device *class_device, char *buf)
 {
-        struct fb_info *fb_info =
-                (struct fb_info *)class_get_devdata(class_device);
+        struct fb_info *fb_info = class_get_devdata(class_device);
         return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->fix.line_length);
 }
 
@@ -320,7 +312,7 @@ static ssize_t show_stride(struct class_device *class_device, char *buf)
 static ssize_t store_cmap(struct class_device *class_device, const char *buf,
                           size_t count)
 {
-        struct fb_info *fb_info = (struct fb_info *)class_get_devdata(class_device);
+        struct fb_info *fb_info = class_get_devdata(class_device);
         int rc, i, start, length, transp = 0;
 
         if ((count > PAGE_SIZE) || ((count % 16) != 0))
@@ -380,8 +372,7 @@ static ssize_t store_cmap(struct class_device *class_device, const char *buf,
 
 static ssize_t show_cmap(struct class_device *class_device, char *buf)
 {
-        struct fb_info *fb_info =
-                (struct fb_info *)class_get_devdata(class_device);
+        struct fb_info *fb_info = class_get_devdata(class_device);
         unsigned int i;
 
         if (!fb_info->cmap.red || !fb_info->cmap.blue ||
@@ -405,8 +396,7 @@ static ssize_t show_cmap(struct class_device *class_device, char *buf)
 static ssize_t store_blank(struct class_device *class_device, const char * buf,
                            size_t count)
 {
-        struct fb_info *fb_info =
-                (struct fb_info *)class_get_devdata(class_device);
+        struct fb_info *fb_info = class_get_devdata(class_device);
         char *last = NULL;
         int err;
 
@@ -422,41 +412,40 @@ static ssize_t store_blank(struct class_device *class_device, const char * buf,
 
 static ssize_t show_blank(struct class_device *class_device, char *buf)
 {
-//      struct fb_info *fb_info = (struct fb_info *)class_get_devdata(class_device);
+//      struct fb_info *fb_info = class_get_devdata(class_device);
         return 0;
 }
 
 static ssize_t store_console(struct class_device *class_device,
                              const char * buf, size_t count)
 {
-//      struct fb_info *fb_info = (struct fb_info *)class_get_devdata(class_device);
+//      struct fb_info *fb_info = class_get_devdata(class_device);
         return 0;
 }
 
 static ssize_t show_console(struct class_device *class_device, char *buf)
 {
-//      struct fb_info *fb_info = (struct fb_info *)class_get_devdata(class_device);
+//      struct fb_info *fb_info = class_get_devdata(class_device);
         return 0;
 }
 
 static ssize_t store_cursor(struct class_device *class_device,
                             const char * buf, size_t count)
 {
-//      struct fb_info *fb_info = (struct fb_info *)class_get_devdata(class_device);
+//      struct fb_info *fb_info = class_get_devdata(class_device);
         return 0;
 }
 
 static ssize_t show_cursor(struct class_device *class_device, char *buf)
 {
-//      struct fb_info *fb_info = (struct fb_info *)class_get_devdata(class_device);
+//      struct fb_info *fb_info = class_get_devdata(class_device);
         return 0;
 }
 
 static ssize_t store_pan(struct class_device *class_device, const char * buf,
                          size_t count)
 {
-        struct fb_info *fb_info =
-                (struct fb_info *)class_get_devdata(class_device);
+        struct fb_info *fb_info = class_get_devdata(class_device);
         struct fb_var_screeninfo var;
         char *last = NULL;
         int err;
@@ -479,19 +468,40 @@ static ssize_t store_pan(struct class_device *class_device, const char * buf,
 
 static ssize_t show_pan(struct class_device *class_device, char *buf)
 {
-        struct fb_info *fb_info =
-                (struct fb_info *)class_get_devdata(class_device);
+        struct fb_info *fb_info = class_get_devdata(class_device);
         return snprintf(buf, PAGE_SIZE, "%d,%d\n", fb_info->var.xoffset,
                         fb_info->var.xoffset);
 }
 
 static ssize_t show_name(struct class_device *class_device, char *buf)
 {
-        struct fb_info *fb_info = (struct fb_info *)class_get_devdata(class_device);
+        struct fb_info *fb_info = class_get_devdata(class_device);
 
         return snprintf(buf, PAGE_SIZE, "%s\n", fb_info->fix.id);
 }
 
+static ssize_t store_fbstate(struct class_device *class_device,
+                        const char *buf, size_t count)
+{
+        struct fb_info *fb_info = class_get_devdata(class_device);
+        u32 state;
+        char *last = NULL;
+
+        state = simple_strtoul(buf, &last, 0);
+
+        acquire_console_sem();
+        fb_set_suspend(fb_info, (int)state);
+        release_console_sem();
+
+        return count;
+}
+
+static ssize_t show_fbstate(struct class_device *class_device, char *buf)
+{
+        struct fb_info *fb_info = class_get_devdata(class_device);
+        return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->state);
+}
+
 static struct class_device_attribute class_device_attrs[] = {
         __ATTR(bits_per_pixel, S_IRUGO|S_IWUSR, show_bpp, store_bpp),
         __ATTR(blank, S_IRUGO|S_IWUSR, show_blank, store_blank),
@@ -507,6 +517,7 @@ static struct class_device_attribute class_device_attrs[] = {
         __ATTR(rotate, S_IRUGO|S_IWUSR, show_rotate, store_rotate),
         __ATTR(con_rotate, S_IRUGO|S_IWUSR, show_con_rotate, store_con_rotate),
         __ATTR(con_rotate_all, S_IWUSR, NULL, store_con_rotate_all),
+        __ATTR(state, S_IRUGO|S_IWUSR, show_fbstate, store_fbstate),
 };
 
 int fb_init_class_device(struct fb_info *fb_info)
diff --git a/drivers/video/hgafb.c b/drivers/video/hgafb.c
index b37cea7d1094..4e39035cf335 100644
--- a/drivers/video/hgafb.c
+++ b/drivers/video/hgafb.c
@@ -42,6 +42,7 @@
 #include <linux/fb.h>
 #include <linux/init.h>
 #include <linux/ioport.h>
+#include <linux/platform_device.h>
 #include <asm/io.h>
 #include <asm/vga.h>
 
@@ -107,7 +108,7 @@ static DEFINE_SPINLOCK(hga_reg_lock);
 
 /* Framebuffer driver structures */
 
-static struct fb_var_screeninfo hga_default_var = {
+static struct fb_var_screeninfo __initdata hga_default_var = {
         .xres           = 720,
         .yres           = 348,
         .xres_virtual   = 720,
@@ -121,7 +122,7 @@ static struct fb_var_screeninfo hga_default_var = {
         .width          = -1,
 };
 
-static struct fb_fix_screeninfo hga_fix = {
+static struct fb_fix_screeninfo __initdata hga_fix = {
         .id             = "HGA",
         .type           = FB_TYPE_PACKED_PIXELS,        /* (not sure) */
         .visual         = FB_VISUAL_MONO10,
@@ -131,8 +132,6 @@ static struct fb_fix_screeninfo hga_fix = {
         .accel          = FB_ACCEL_NONE
 };
 
-static struct fb_info fb_info;
-
 /* Don't assume that tty1 will be the initial current console. */
 static int release_io_port = 0;
 static int release_io_ports = 0;
@@ -549,10 +548,9 @@ static struct fb_ops hgafb_ops = {
          *  Initialization
          */
 
-static int __init hgafb_init(void)
+static int __init hgafb_probe(struct device *device)
 {
-        if (fb_get_options("hgafb", NULL))
-                return -ENODEV;
+        struct fb_info *info;
 
         if (! hga_card_detect()) {
                 printk(KERN_INFO "hgafb: HGA card not detected.\n");
@@ -564,41 +562,95 @@ static int __init hgafb_init(void)
         printk(KERN_INFO "hgafb: %s with %ldK of memory detected.\n",
                 hga_type_name, hga_vram_len/1024);
 
+        info = framebuffer_alloc(0, NULL);
+        if (!info) {
+                iounmap(hga_vram);
+                return -ENOMEM;
+        }
+
         hga_fix.smem_start = (unsigned long)hga_vram;
         hga_fix.smem_len = hga_vram_len;
 
-        fb_info.flags = FBINFO_DEFAULT | FBINFO_HWACCEL_YPAN;
-        fb_info.var = hga_default_var;
-        fb_info.fix = hga_fix;
-        fb_info.monspecs.hfmin = 0;
-        fb_info.monspecs.hfmax = 0;
-        fb_info.monspecs.vfmin = 10000;
-        fb_info.monspecs.vfmax = 10000;
-        fb_info.monspecs.dpms = 0;
-        fb_info.fbops = &hgafb_ops;
-        fb_info.screen_base = hga_vram;
-
-        if (register_framebuffer(&fb_info) < 0) {
+        info->flags = FBINFO_DEFAULT | FBINFO_HWACCEL_YPAN;
+        info->var = hga_default_var;
+        info->fix = hga_fix;
+        info->monspecs.hfmin = 0;
+        info->monspecs.hfmax = 0;
+        info->monspecs.vfmin = 10000;
+        info->monspecs.vfmax = 10000;
+        info->monspecs.dpms = 0;
+        info->fbops = &hgafb_ops;
+        info->screen_base = hga_vram;
+
+        if (register_framebuffer(info) < 0) {
+                framebuffer_release(info);
                 iounmap(hga_vram);
                 return -EINVAL;
         }
 
         printk(KERN_INFO "fb%d: %s frame buffer device\n",
-               fb_info.node, fb_info.fix.id);
+               info->node, info->fix.id);
+        dev_set_drvdata(device, info);
         return 0;
 }
 
-#ifdef MODULE
-static void __exit hgafb_exit(void)
+static int hgafb_remove(struct device *device)
 {
+        struct fb_info *info = dev_get_drvdata(device);
+
         hga_txt_mode();
         hga_clear_screen();
-        unregister_framebuffer(&fb_info);
+
+        if (info) {
+                unregister_framebuffer(info);
+                framebuffer_release(info);
+        }
+
         iounmap(hga_vram);
-        if (release_io_ports) release_region(0x3b0, 12);
-        if (release_io_port) release_region(0x3bf, 1);
+
+        if (release_io_ports)
+                release_region(0x3b0, 12);
+
+        if (release_io_port)
+                release_region(0x3bf, 1);
+
+        return 0;
+}
+
+static struct device_driver hgafb_driver = {
+        .name = "hgafb",
+        .bus  = &platform_bus_type,
+        .probe = hgafb_probe,
+        .remove = hgafb_remove,
+};
+
+static struct platform_device hgafb_device = {
+        .name = "hgafb",
+};
+
+static int __init hgafb_init(void)
+{
+        int ret;
+
+        if (fb_get_options("hgafb", NULL))
+                return -ENODEV;
+
+        ret = driver_register(&hgafb_driver);
+
+        if (!ret) {
+                ret = platform_device_register(&hgafb_device);
+                if (ret)
+                        driver_unregister(&hgafb_driver);
+        }
+
+        return ret;
+}
+
+static void __exit hgafb_exit(void)
+{
+        platform_device_unregister(&hgafb_device);
+        driver_unregister(&hgafb_driver);
 }
-#endif
 
 /* -------------------------------------------------------------------------
  *
@@ -613,7 +665,4 @@ MODULE_LICENSE("GPL");
 module_param(nologo, bool, 0);
 MODULE_PARM_DESC(nologo, "Disables startup logo if != 0 (default=0)");
 module_init(hgafb_init);
-
-#ifdef MODULE
 module_exit(hgafb_exit);
-#endif
diff --git a/drivers/video/i810/i810-i2c.c b/drivers/video/i810/i810-i2c.c
index c61bad0da20f..bd410e06db73 100644
--- a/drivers/video/i810/i810-i2c.c
+++ b/drivers/video/i810/i810-i2c.c
@@ -17,6 +17,7 @@
 #include <linux/fb.h>
 #include "i810.h"
 #include "i810_regs.h"
+#include "i810_main.h"
 #include "../edid.h"
 
 #define I810_DDC 0x50
@@ -42,7 +43,7 @@
 
 static void i810i2c_setscl(void *data, int state)
 {
-        struct i810fb_i2c_chan    *chan = (struct i810fb_i2c_chan *)data;
+        struct i810fb_i2c_chan    *chan = data;
         struct i810fb_par         *par = chan->par;
         u8                        __iomem *mmio = par->mmio_start_virtual;
 
diff --git a/drivers/video/i810/i810_accel.c b/drivers/video/i810/i810_accel.c
index 64cd1c827cf0..76764ea3486a 100644
--- a/drivers/video/i810/i810_accel.c
+++ b/drivers/video/i810/i810_accel.c
@@ -14,6 +14,7 @@
 
 #include "i810_regs.h"
 #include "i810.h"
+#include "i810_main.h"
 
 static u32 i810fb_rop[] = {
         COLOR_COPY_ROP, /* ROP_COPY */
@@ -57,7 +58,7 @@ static inline void i810_report_error(u8 __iomem *mmio)
  */     
 static inline int wait_for_space(struct fb_info *info, u32 space)
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
         u32 head, count = WAIT_COUNT, tail;
         u8 __iomem *mmio = par->mmio_start_virtual;
 
@@ -88,7 +89,7 @@ static inline int wait_for_space(struct fb_info *info, u32 space)
  */
 static inline int wait_for_engine_idle(struct fb_info *info)
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
         u8 __iomem *mmio = par->mmio_start_virtual;
         int count = WAIT_COUNT;
 
@@ -116,7 +117,7 @@ static inline int wait_for_engine_idle(struct fb_info *info)
  */ 
 static inline u32 begin_iring(struct fb_info *info, u32 space)
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
 
         if (par->dev_flags & ALWAYS_SYNC) 
                 wait_for_engine_idle(info);
@@ -161,7 +162,7 @@ static inline void source_copy_blit(int dwidth, int dheight, int dpitch,
                                     int xdir, int src, int dest, int rop, 
                                     int blit_bpp, struct fb_info *info)
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
 
         if (begin_iring(info, 24 + IRING_PAD)) return;
 
@@ -195,7 +196,7 @@ static inline void color_blit(int width, int height, int pitch,  int dest,
                               int rop, int what, int blit_bpp, 
                               struct fb_info *info)
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
 
         if (begin_iring(info, 24 + IRING_PAD)) return;
 
@@ -236,7 +237,7 @@ static inline void mono_src_copy_imm_blit(int dwidth, int dheight, int dpitch,
                                           int dest, const u32 *src, int bg,
                                           int fg, struct fb_info *info)
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
 
         if (begin_iring(info, 24 + (dsize << 2) + IRING_PAD)) return;
 
@@ -254,7 +255,7 @@ static inline void mono_src_copy_imm_blit(int dwidth, int dheight, int dpitch,
 
 static inline void load_front(int offset, struct fb_info *info)
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
 
         if (begin_iring(info, 8 + IRING_PAD)) return;
 
@@ -296,7 +297,7 @@ static inline void i810fb_iring_enable(struct i810fb_par *par, u32 mode)
 
 void i810fb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
         u32 dx, dy, width, height, dest, rop = 0, color = 0;
 
         if (!info->var.accel_flags || par->dev_flags & LOCKUP ||
@@ -322,7 +323,7 @@ void i810fb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
         
 void i810fb_copyarea(struct fb_info *info, const struct fb_copyarea *region) 
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
         u32 sx, sy, dx, dy, pitch, width, height, src, dest, xdir;
 
         if (!info->var.accel_flags || par->dev_flags & LOCKUP ||
@@ -361,7 +362,7 @@ void i810fb_copyarea(struct fb_info *info, const struct fb_copyarea *region)
 
 void i810fb_imageblit(struct fb_info *info, const struct fb_image *image)
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
         u32 fg = 0, bg = 0, size, dst;
         
         if (!info->var.accel_flags || par->dev_flags & LOCKUP ||
@@ -397,7 +398,7 @@ void i810fb_imageblit(struct fb_info *info, const struct fb_image *image)
 
 int i810fb_sync(struct fb_info *info)
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
         
         if (!info->var.accel_flags || par->dev_flags & LOCKUP)
                 return 0;
@@ -407,7 +408,7 @@ int i810fb_sync(struct fb_info *info)
 
 void i810fb_load_front(u32 offset, struct fb_info *info)
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
         u8 __iomem *mmio = par->mmio_start_virtual;
 
         if (!info->var.accel_flags || par->dev_flags & LOCKUP)
@@ -427,7 +428,7 @@ void i810fb_load_front(u32 offset, struct fb_info *info)
  */
 void i810fb_init_ringbuffer(struct fb_info *info)
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
         u32 tmp1, tmp2;
         u8 __iomem *mmio = par->mmio_start_virtual;
         
diff --git a/drivers/video/i810/i810_gtf.c b/drivers/video/i810/i810_gtf.c
index 64f087a4466b..9743d51e7f8c 100644
--- a/drivers/video/i810/i810_gtf.c
+++ b/drivers/video/i810/i810_gtf.c
@@ -14,6 +14,7 @@
 
 #include "i810_regs.h"
 #include "i810.h"
+#include "i810_main.h"
 
 /*
  * FIFO and Watermark tables - based almost wholly on i810_wmark.c in 
diff --git a/drivers/video/i810/i810_main.c b/drivers/video/i810/i810_main.c
index c0c974b1afaa..266d0ab92663 100644
--- a/drivers/video/i810/i810_main.c
+++ b/drivers/video/i810/i810_main.c
@@ -42,20 +42,62 @@
 #include <linux/pci_ids.h>
 #include <linux/resource.h>
 #include <linux/unistd.h>
+#include <linux/console.h>
 
 #include <asm/io.h>
 #include <asm/div64.h>
-
-#ifdef CONFIG_MTRR
-#include <asm/mtrr.h>
-#endif 
-
 #include <asm/page.h>
 
 #include "i810_regs.h"
 #include "i810.h"
 #include "i810_main.h"
 
+/*
+ * voffset - framebuffer offset in MiB from aperture start address.  In order for
+ * the driver to work with X, we must try to use memory holes left untouched by X. The
+ * following table lists where X's different surfaces start at.
+ *
+ * ---------------------------------------------
+ * :                :  64 MiB     : 32 MiB      :
+ * ----------------------------------------------
+ * : FrontBuffer    :   0         :  0          :
+ * : DepthBuffer    :   48        :  16         :
+ * : BackBuffer     :   56        :  24         :
+ * ----------------------------------------------
+ *
+ * So for chipsets with 64 MiB Aperture sizes, 32 MiB for v_offset is okay, allowing up to
+ * 15 + 1 MiB of Framebuffer memory.  For 32 MiB Aperture sizes, a v_offset of 8 MiB should
+ * work, allowing 7 + 1 MiB of Framebuffer memory.
+ * Note, the size of the hole may change depending on how much memory you allocate to X,
+ * and how the memory is split up between these surfaces.
+ *
+ * Note: Anytime the DepthBuffer or FrontBuffer is overlapped, X would still run but with
+ * DRI disabled.  But if the Frontbuffer is overlapped, X will fail to load.
+ *
+ * Experiment with v_offset to find out which works best for you.
+ */
+static u32 v_offset_default __initdata; /* For 32 MiB Aper size, 8 should be the default */
+static u32 voffset          __initdata = 0;
+
+static int i810fb_cursor(struct fb_info *info, struct fb_cursor *cursor);
+static int  __devinit i810fb_init_pci (struct pci_dev *dev,
+                                       const struct pci_device_id *entry);
+static void __exit i810fb_remove_pci(struct pci_dev *dev);
+static int i810fb_resume(struct pci_dev *dev);
+static int i810fb_suspend(struct pci_dev *dev, pm_message_t state);
+
+/* Chipset Specific Functions */
+static int i810fb_set_par    (struct fb_info *info);
+static int i810fb_getcolreg  (u8 regno, u8 *red, u8 *green, u8 *blue,
+                              u8 *transp, struct fb_info *info);
+static int i810fb_setcolreg  (unsigned regno, unsigned red, unsigned green, unsigned blue,
+                              unsigned transp, struct fb_info *info);
+static int i810fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info);
+static int i810fb_blank      (int blank_mode, struct fb_info *info);
+
+/* Initialization */
+static void i810fb_release_resource       (struct fb_info *info, struct i810fb_par *par);
+
 /* PCI */
 static const char *i810_pci_list[] __devinitdata = {
         "Intel(R) 810 Framebuffer Device"                                 ,
@@ -776,7 +818,7 @@ static void i810_load_cursor_image(int width, int height, u8 *data,
 
 static void i810_load_cursor_colors(int fg, int bg, struct fb_info *info)
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
         u8 __iomem *mmio = par->mmio_start_virtual;
         u8 red, green, blue, trans, temp;
 
@@ -949,7 +991,7 @@ static void set_color_bitfields(struct fb_var_screeninfo *var)
 static int i810_check_params(struct fb_var_screeninfo *var, 
                              struct fb_info *info)
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
         int line_length, vidmem, mode_valid = 0, retval = 0;
         u32 vyres = var->yres_virtual, vxres = var->xres_virtual;
         /*
@@ -1043,7 +1085,7 @@ static int i810_check_params(struct fb_var_screeninfo *var,
  */
 static int encode_fix(struct fb_fix_screeninfo *fix, struct fb_info *info)
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
 
         memset(fix, 0, sizeof(struct fb_fix_screeninfo));
 
@@ -1154,7 +1196,7 @@ static void decode_var(const struct fb_var_screeninfo *var,
 static int i810fb_getcolreg(u8 regno, u8 *red, u8 *green, u8 *blue, 
                             u8 *transp, struct fb_info *info)
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
         u8 __iomem *mmio = par->mmio_start_virtual;
         u8 temp;
 
@@ -1193,7 +1235,7 @@ static int i810fb_getcolreg(u8 regno, u8 *red, u8 *green, u8 *blue,
 
 static int i810fb_open(struct fb_info *info, int user)
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
         u32 count = atomic_read(&par->use_count);
         
         if (count == 0) {
@@ -1212,7 +1254,7 @@ static int i810fb_open(struct fb_info *info, int user)
 
 static int i810fb_release(struct fb_info *info, int user)
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
         u32 count;
         
         count = atomic_read(&par->use_count);
@@ -1234,7 +1276,7 @@ static int i810fb_setcolreg(unsigned regno, unsigned red, unsigned green,
                             unsigned blue, unsigned transp, 
                             struct fb_info *info)
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
         u8 __iomem *mmio = par->mmio_start_virtual;
         u8 temp;
         int i;
@@ -1328,7 +1370,7 @@ static int i810fb_setcolreg(unsigned regno, unsigned red, unsigned green,
 static int i810fb_pan_display(struct fb_var_screeninfo *var, 
                               struct fb_info *info)
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
         u32 total;
         
         total = var->xoffset * par->depth + 
@@ -1340,7 +1382,7 @@ static int i810fb_pan_display(struct fb_var_screeninfo *var,
 
 static int i810fb_blank (int blank_mode, struct fb_info *info)
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
         u8 __iomem *mmio = par->mmio_start_virtual;
         int mode = 0, pwr, scr_off = 0;
         
@@ -1385,7 +1427,7 @@ static int i810fb_blank (int blank_mode, struct fb_info *info)
 
 static int i810fb_set_par(struct fb_info *info)
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
 
         decode_var(&info->var, par);
         i810_load_regs(par);
@@ -1429,7 +1471,7 @@ static int i810fb_check_var(struct fb_var_screeninfo *var,
 
 static int i810fb_cursor(struct fb_info *info, struct fb_cursor *cursor)
 {
-        struct i810fb_par *par = (struct i810fb_par *)info->par;
+        struct i810fb_par *par = info->par;
         u8 __iomem *mmio = par->mmio_start_virtual;
 
         if (!par->dev_flags & LOCKUP)
@@ -1516,36 +1558,29 @@ static struct fb_ops i810fb_ops __devinitdata = {
 static int i810fb_suspend(struct pci_dev *dev, pm_message_t state)
 {
         struct fb_info *info = pci_get_drvdata(dev);
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
-        int blank = 0, prev_state = par->cur_state;
-
-        if (state.event == prev_state)
-                return 0;
+        struct i810fb_par *par = info->par;
 
         par->cur_state = state.event;
 
-        switch (state.event) {
-        case 1:
-                blank = VESA_VSYNC_SUSPEND;
-                break;
-        case 2:
-                blank = VESA_HSYNC_SUSPEND;
-                break;
-        case 3:
-                blank = VESA_POWERDOWN;
-                break;
-        default:
-                return -EINVAL;
+        if (state.event == PM_EVENT_FREEZE) {
+                dev->dev.power.power_state = state;
+                return 0;
         }
-        info->fbops->fb_blank(blank, info);
 
-        if (!prev_state) { 
-                agp_unbind_memory(par->i810_gtt.i810_fb_memory);
-                agp_unbind_memory(par->i810_gtt.i810_cursor_memory);
-                pci_disable_device(dev);
-        }
+        acquire_console_sem();
+        fb_set_suspend(info, 1);
+
+        if (info->fbops->fb_sync)
+                info->fbops->fb_sync(info);
+
+        i810fb_blank(FB_BLANK_POWERDOWN, info);
+        agp_unbind_memory(par->i810_gtt.i810_fb_memory);
+        agp_unbind_memory(par->i810_gtt.i810_cursor_memory);
+
         pci_save_state(dev);
+        pci_disable_device(dev);
         pci_set_power_state(dev, pci_choose_state(dev, state));
+        release_console_sem();
 
         return 0;
 }
@@ -1553,23 +1588,29 @@ static int i810fb_suspend(struct pci_dev *dev, pm_message_t state)
 static int i810fb_resume(struct pci_dev *dev) 
 {
         struct fb_info *info = pci_get_drvdata(dev);
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
+        int cur_state = par->cur_state;
+
+        par->cur_state = PM_EVENT_ON;
 
-        if (par->cur_state == 0)
+        if (cur_state == PM_EVENT_FREEZE) {
+                pci_set_power_state(dev, PCI_D0);
                 return 0;
+        }
 
-        pci_restore_state(dev);
+        acquire_console_sem();
         pci_set_power_state(dev, PCI_D0);
+        pci_restore_state(dev);
         pci_enable_device(dev);
+        pci_set_master(dev);
         agp_bind_memory(par->i810_gtt.i810_fb_memory,
                         par->fb.offset);
         agp_bind_memory(par->i810_gtt.i810_cursor_memory,
                         par->cursor_heap.offset);
-
+        i810fb_set_par(info);
+        fb_set_suspend (info, 0);
         info->fbops->fb_blank(VESA_NO_BLANKING, info);
-
-        par->cur_state = 0;
-
+        release_console_sem();
         return 0;
 }
 /***********************************************************************
@@ -1610,7 +1651,7 @@ static void __devinit i810_fix_offsets(struct i810fb_par *par)
 
 static int __devinit i810_alloc_agp_mem(struct fb_info *info)
 {
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
         int size;
         struct agp_bridge_data *bridge;
         
@@ -2074,7 +2115,7 @@ static void i810fb_release_resource(struct fb_info *info,
 static void __exit i810fb_remove_pci(struct pci_dev *dev)
 {
         struct fb_info *info = pci_get_drvdata(dev);
-        struct i810fb_par *par = (struct i810fb_par *) info->par;
+        struct i810fb_par *par = info->par;
 
         unregister_framebuffer(info);  
         i810fb_release_resource(info, par);
diff --git a/drivers/video/i810/i810_main.h b/drivers/video/i810/i810_main.h
index 06072a6466f2..51d4f3d4116d 100644
--- a/drivers/video/i810/i810_main.h
+++ b/drivers/video/i810/i810_main.h
@@ -14,55 +14,6 @@
 #ifndef __I810_MAIN_H__
 #define __I810_MAIN_H__
 
-static int  __devinit i810fb_init_pci (struct pci_dev *dev, 
-                                       const struct pci_device_id *entry);
-static void __exit i810fb_remove_pci(struct pci_dev *dev);
-static int i810fb_resume(struct pci_dev *dev);
-static int i810fb_suspend(struct pci_dev *dev, pm_message_t state);
-
-/*
- * voffset - framebuffer offset in MiB from aperture start address.  In order for
- * the driver to work with X, we must try to use memory holes left untouched by X. The 
- * following table lists where X's different surfaces start at.  
- * 
- * ---------------------------------------------
- * :                :  64 MiB     : 32 MiB      :
- * ----------------------------------------------
- * : FrontBuffer    :   0         :  0          :
- * : DepthBuffer    :   48        :  16         :
- * : BackBuffer     :   56        :  24         :
- * ----------------------------------------------
- *
- * So for chipsets with 64 MiB Aperture sizes, 32 MiB for v_offset is okay, allowing up to
- * 15 + 1 MiB of Framebuffer memory.  For 32 MiB Aperture sizes, a v_offset of 8 MiB should
- * work, allowing 7 + 1 MiB of Framebuffer memory.
- * Note, the size of the hole may change depending on how much memory you allocate to X,
- * and how the memory is split up between these surfaces.  
- *
- * Note: Anytime the DepthBuffer or FrontBuffer is overlapped, X would still run but with
- * DRI disabled.  But if the Frontbuffer is overlapped, X will fail to load.
- * 
- * Experiment with v_offset to find out which works best for you.
- */
-static u32 v_offset_default __initdata; /* For 32 MiB Aper size, 8 should be the default */
-static u32 voffset          __initdata = 0;
-
-static int i810fb_cursor(struct fb_info *info, struct fb_cursor *cursor);
-
-/* Chipset Specific Functions */
-static int i810fb_set_par    (struct fb_info *info);
-static int i810fb_getcolreg  (u8 regno, u8 *red, u8 *green, u8 *blue,
-                              u8 *transp, struct fb_info *info);
-static int i810fb_setcolreg  (unsigned regno, unsigned red, unsigned green, unsigned blue,
-                              unsigned transp, struct fb_info *info);
-static int i810fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info);
-static int i810fb_blank      (int blank_mode, struct fb_info *info);
-
-/* Initialization */
-static void i810fb_release_resource       (struct fb_info *info, struct i810fb_par *par);
-extern int __init agp_intel_init(void);
-
-
 /* Video Timings */
 extern void round_off_xres         (u32 *xres);
 extern void round_off_yres         (u32 *xres, u32 *yres);
@@ -101,7 +52,7 @@ static inline void i810_delete_i2c_busses(struct i810fb_par *par) { }
 
 /* Conditionals */
 #ifdef CONFIG_X86
-inline void flush_cache(void)
+static inline void flush_cache(void)
 {
         asm volatile ("wbinvd":::"memory");
 }
@@ -110,7 +61,9 @@ inline void flush_cache(void)
 #endif 
 
 #ifdef CONFIG_MTRR
-#define KERNEL_HAS_MTRR 1
+
+#include <asm/mtrr.h>
+
 static inline void __devinit set_mtrr(struct i810fb_par *par)
 {
         par->mtrr_reg = mtrr_add((u32) par->aperture.physical, 
@@ -128,7 +81,6 @@ static inline void unset_mtrr(struct i810fb_par *par)
                          par->aperture.size); 
 }
 #else
-#define KERNEL_HAS_MTRR 0
 #define set_mtrr(x) printk("set_mtrr: MTRR is disabled in the kernel\n")
 
 #define unset_mtrr(x) do { } while (0)
diff --git a/drivers/video/imsttfb.c b/drivers/video/imsttfb.c
index 7fbe24206b19..a5d813050db5 100644
--- a/drivers/video/imsttfb.c
+++ b/drivers/video/imsttfb.c
@@ -323,6 +323,7 @@ struct imstt_par {
         unsigned long cmap_regs_phys;
         __u8 *cmap_regs;
         __u32 ramdac;
+        __u32 palette[16];
 };
  
 enum {
@@ -657,7 +658,7 @@ set_imstt_regvals_tvp (struct imstt_par *par, u_int bpp)
 static void
 set_imstt_regvals (struct fb_info *info, u_int bpp)
 {
-        struct imstt_par *par = (struct imstt_par *) info->par;
+        struct imstt_par *par = info->par;
         struct imstt_regvals *init = &par->init;
         __u32 ctl, pitch, byteswap, scr;
 
@@ -749,7 +750,7 @@ set_imstt_regvals (struct fb_info *info, u_int bpp)
 static inline void
 set_offset (struct fb_var_screeninfo *var, struct fb_info *info)
 {
-        struct imstt_par *par = (struct imstt_par *) info->par;
+        struct imstt_par *par = info->par;
         __u32 off = var->yoffset * (info->fix.line_length >> 3)
                     + ((var->xoffset * (var->bits_per_pixel >> 3)) >> 3);
         write_reg_le32(par->dc_regs, SSR, off);
@@ -863,7 +864,7 @@ imsttfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 static int
 imsttfb_set_par(struct fb_info *info) 
 {
-        struct imstt_par *par = (struct imstt_par *) info->par;
+        struct imstt_par *par = info->par;
                 
         if (!compute_imstt_regvals(par, info->var.xres, info->var.yres))
                 return -EINVAL;
@@ -881,7 +882,7 @@ static int
 imsttfb_setcolreg (u_int regno, u_int red, u_int green, u_int blue,
                    u_int transp, struct fb_info *info)
 {
-        struct imstt_par *par = (struct imstt_par *) info->par;
+        struct imstt_par *par = info->par;
         u_int bpp = info->var.bits_per_pixel;
 
         if (regno > 255)
@@ -905,14 +906,17 @@ imsttfb_setcolreg (u_int regno, u_int red, u_int green, u_int blue,
         if (regno < 16)
                 switch (bpp) {
                         case 16:
-                                ((u16 *)info->pseudo_palette)[regno] = (regno << (info->var.green.length == 5 ? 10 : 11)) | (regno << 5) | regno;
+                                par->palette[regno] =
+                                        (regno << (info->var.green.length ==
+                                        5 ? 10 : 11)) | (regno << 5) | regno;
                                 break;
                         case 24:
-                                ((u32 *)info->pseudo_palette)[regno] = (regno << 16) | (regno << 8) | regno;
+                                par->palette[regno] =
+                                        (regno << 16) | (regno << 8) | regno;
                                 break;
                         case 32: {
                                 int i = (regno << 8) | regno;
-                                ((u32 *)info->pseudo_palette)[regno] = (i << 16) | i;
+                                par->palette[regno] = (i << 16) |i;
                                 break;
                         }
                 }
@@ -935,7 +939,7 @@ imsttfb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
 static int 
 imsttfb_blank(int blank, struct fb_info *info)
 {
-        struct imstt_par *par = (struct imstt_par *) info->par;
+        struct imstt_par *par = info->par;
         __u32 ctrl;
 
         ctrl = read_reg_le32(par->dc_regs, STGCTL);
@@ -989,7 +993,7 @@ imsttfb_blank(int blank, struct fb_info *info)
 static void
 imsttfb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
 { 
-        struct imstt_par *par = (struct imstt_par *) info->par;
+        struct imstt_par *par = info->par;
         __u32 Bpp, line_pitch, bgc, dx, dy, width, height;
 
         bgc = rect->color;
@@ -1033,7 +1037,7 @@ imsttfb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
 static void
 imsttfb_copyarea(struct fb_info *info, const struct fb_copyarea *area)
 {
-        struct imstt_par *par = (struct imstt_par *) info->par;
+        struct imstt_par *par = info->par;
         __u32 Bpp, line_pitch, fb_offset_old, fb_offset_new, sp, dp_octl;
         __u32 cnt, bltctl, sx, sy, dx, dy, height, width;
 
@@ -1195,7 +1199,7 @@ imstt_set_cursor(struct imstt_par *par, struct fb_image *d, int on)
 static int 
 imsttfb_cursor(struct fb_info *info, struct fb_cursor *cursor)
 {
-        struct imstt_par *par = (struct imstt_par *) info->par;
+        struct imstt_par *par = info->par;
         u32 flags = cursor->set, fg, bg, xx, yy;
 
         if (cursor->dest == NULL && cursor->rop == ROP_XOR)
@@ -1266,7 +1270,7 @@ static int
 imsttfb_ioctl(struct inode *inode, struct file *file, u_int cmd,
               u_long arg, struct fb_info *info)
 {
-        struct imstt_par *par = (struct imstt_par *) info->par;
+        struct imstt_par *par = info->par;
         void __user *argp = (void __user *)arg;
         __u32 reg[2];
         __u8 idx[2];
@@ -1350,7 +1354,7 @@ static struct fb_ops imsttfb_ops = {
 static void __devinit
 init_imstt(struct fb_info *info)
 {
-        struct imstt_par *par = (struct imstt_par *) info->par;
+        struct imstt_par *par = info->par;
         __u32 i, tmp, *ip, *end;
 
         tmp = read_reg_le32(par->dc_regs, PRC);
@@ -1413,7 +1417,7 @@ init_imstt(struct fb_info *info)
         if ((info->var.xres * info->var.yres) * (info->var.bits_per_pixel >> 3) > info->fix.smem_len
             || !(compute_imstt_regvals(par, info->var.xres, info->var.yres))) {
                 printk("imsttfb: %ux%ux%u not supported\n", info->var.xres, info->var.yres, info->var.bits_per_pixel);
-                kfree(info);
+                framebuffer_release(info);
                 return;
         }
 
@@ -1449,7 +1453,7 @@ init_imstt(struct fb_info *info)
         fb_alloc_cmap(&info->cmap, 0, 0);
 
         if (register_framebuffer(info) < 0) {
-                kfree(info);
+                framebuffer_release(info);
                 return;
         }
 
@@ -1474,26 +1478,21 @@ imsttfb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 printk(KERN_ERR "imsttfb: no OF node for pci device\n");
 #endif /* CONFIG_PPC_OF */
 
-        size = sizeof(struct fb_info) + sizeof(struct imstt_par) +
-                sizeof(u32) * 16;
-
-        info = kmalloc(size, GFP_KERNEL);
+        info = framebuffer_alloc(sizeof(struct imstt_par), &pdev->dev);
 
         if (!info) {
                 printk(KERN_ERR "imsttfb: Can't allocate memory\n");
                 return -ENOMEM;
         }
 
-        memset(info, 0, size);
-
-        par = (struct imstt_par *) (info + 1);
+        par = info->par;
 
         addr = pci_resource_start (pdev, 0);
         size = pci_resource_len (pdev, 0);
 
         if (!request_mem_region(addr, size, "imsttfb")) {
                 printk(KERN_ERR "imsttfb: Can't reserve memory region\n");
-                kfree(info);
+                framebuffer_release(info);
                 return -ENODEV;
         }
 
@@ -1516,14 +1515,13 @@ imsttfb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         }
 
         info->fix.smem_start = addr;
-        info->screen_base = (__u8 *)ioremap(addr, par->ramdac == IBM ? 0x400000 : 0x800000);
+        info->screen_base = (__u8 *)ioremap(addr, par->ramdac == IBM ?
+                                            0x400000 : 0x800000);
         info->fix.mmio_start = addr + 0x800000;
         par->dc_regs = ioremap(addr + 0x800000, 0x1000);
         par->cmap_regs_phys = addr + 0x840000;
         par->cmap_regs = (__u8 *)ioremap(addr + 0x840000, 0x1000);
-        info->par = par;
-        info->pseudo_palette = (void *) (par + 1);
-        info->device = &pdev->dev;
+        info->pseudo_palette = par->palette;
         init_imstt(info);
 
         pci_set_drvdata(pdev, info);
@@ -1534,7 +1532,7 @@ static void __devexit
 imsttfb_remove(struct pci_dev *pdev)
 {
         struct fb_info *info = pci_get_drvdata(pdev);
-        struct imstt_par *par = (struct imstt_par *) info->par;
+        struct imstt_par *par = info->par;
         int size = pci_resource_len(pdev, 0);
 
         unregister_framebuffer(info);
@@ -1542,7 +1540,7 @@ imsttfb_remove(struct pci_dev *pdev)
         iounmap(par->dc_regs);
         iounmap(info->screen_base);
         release_mem_region(info->fix.smem_start, size);
-        kfree(info);
+        framebuffer_release(info);
 }
 
 #ifndef MODULE
diff --git a/drivers/video/kyro/STG4000InitDevice.c b/drivers/video/kyro/STG4000InitDevice.c
index 7e33cd307d47..ab5285a7f1d6 100644
--- a/drivers/video/kyro/STG4000InitDevice.c
+++ b/drivers/video/kyro/STG4000InitDevice.c
@@ -15,6 +15,7 @@
 #include <linux/pci.h>
 
 #include "STG4000Reg.h"
+#include "STG4000Interface.h"
 
 /* SDRAM fixed settings */
 #define SDRAM_CFG_0   0x49A1
diff --git a/drivers/video/kyro/STG4000Interface.h b/drivers/video/kyro/STG4000Interface.h
index e75b3b4a4aa1..b7c83d5dfb13 100644
--- a/drivers/video/kyro/STG4000Interface.h
+++ b/drivers/video/kyro/STG4000Interface.h
@@ -11,7 +11,8 @@
 #ifndef _STG4000INTERFACE_H
 #define _STG4000INTERFACE_H
 
-struct pci_dev;
+#include <linux/pci.h>
+#include <video/kyro.h>
 
 /*
  * Ramdac Setup
diff --git a/drivers/video/kyro/STG4000OverlayDevice.c b/drivers/video/kyro/STG4000OverlayDevice.c
index 2ae9bafacdd0..a8c9713413e6 100644
--- a/drivers/video/kyro/STG4000OverlayDevice.c
+++ b/drivers/video/kyro/STG4000OverlayDevice.c
@@ -14,6 +14,7 @@
 #include <linux/types.h>
 
 #include "STG4000Reg.h"
+#include "STG4000Interface.h"
 
 /* HW Defines */
 
diff --git a/drivers/video/kyro/fbdev.c b/drivers/video/kyro/fbdev.c
index 5eb4d5c177bd..bcd359b6d4ff 100644
--- a/drivers/video/kyro/fbdev.c
+++ b/drivers/video/kyro/fbdev.c
@@ -73,8 +73,6 @@ static struct fb_var_screeninfo kyro_var __devinitdata = {
         .vmode          = FB_VMODE_NONINTERLACED,
 };
 
-static struct kyrofb_info *currentpar;
-
 typedef struct {
         STG4000REG __iomem *pSTGReg;    /* Virtual address of PCI register region */
         u32 ulNextFreeVidMem;   /* Offset from start of vid mem to next free region */
@@ -309,7 +307,7 @@ enum {
 /* Accessors */
 static int kyro_dev_video_mode_set(struct fb_info *info)
 {
-        struct kyrofb_info *par = (struct kyrofb_info *)info->par;
+        struct kyrofb_info *par = info->par;
 
         /* Turn off display */
         StopVTG(deviceInfo.pSTGReg);
@@ -402,7 +400,7 @@ static inline unsigned long get_line_length(int x, int bpp)
 
 static int kyrofb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 {
-        struct kyrofb_info *par = (struct kyrofb_info *)info->par;
+        struct kyrofb_info *par = info->par;
 
         if (var->bits_per_pixel != 16 && var->bits_per_pixel != 32) {
                 printk(KERN_WARNING "kyrofb: depth not supported: %u\n", var->bits_per_pixel);
@@ -478,7 +476,7 @@ static int kyrofb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 
 static int kyrofb_set_par(struct fb_info *info)
 {
-        struct kyrofb_info *par = (struct kyrofb_info *)info->par;
+        struct kyrofb_info *par = info->par;
         unsigned long lineclock;
         unsigned long frameclock;
 
@@ -536,20 +534,22 @@ static int kyrofb_set_par(struct fb_info *info)
 static int kyrofb_setcolreg(u_int regno, u_int red, u_int green,
                             u_int blue, u_int transp, struct fb_info *info)
 {
+        struct kyrofb_info *par = info->par;
+
         if (regno > 255)
                 return 1;       /* Invalid register */
 
         if (regno < 16) {
                 switch (info->var.bits_per_pixel) {
                 case 16:
-                        ((u16*)(info->pseudo_palette))[regno] =
+                        par->palette[regno] =
                              (red   & 0xf800) |
                             ((green & 0xfc00) >> 5) |
                             ((blue  & 0xf800) >> 11);
                         break;
                 case 32:
                         red >>= 8; green >>= 8; blue >>= 8; transp >>= 8;
-                        ((u32*)(info->pseudo_palette))[regno] =
+                        par->palette[regno] =
                             (transp << 24) | (red << 16) | (green << 8) | blue;
                         break;
                 }
@@ -675,6 +675,7 @@ static int __devinit kyrofb_probe(struct pci_dev *pdev,
                                   const struct pci_device_id *ent)
 {
         struct fb_info *info;
+        struct kyrofb_info *currentpar;
         unsigned long size;
         int err;
 
@@ -683,14 +684,11 @@ static int __devinit kyrofb_probe(struct pci_dev *pdev,
                 return err;
         }
 
-        size = sizeof(struct fb_info) + sizeof(struct kyrofb_info) + 16 * sizeof(u32);
-        info = kmalloc(size, GFP_KERNEL);
+        info = framebuffer_alloc(sizeof(struct kyrofb_info), &pdev->dev);
         if (!info)
                 return -ENOMEM;
 
-        memset(info, 0, size);
-
-        currentpar = (struct kyrofb_info *)(info + 1);
+        currentpar = info->par;
 
         kyro_fix.smem_start = pci_resource_start(pdev, 0);
         kyro_fix.smem_len   = pci_resource_len(pdev, 0);
@@ -716,8 +714,7 @@ static int __devinit kyrofb_probe(struct pci_dev *pdev,
 
         info->fbops             = &kyrofb_ops;
         info->fix               = kyro_fix;
-        info->par               = currentpar;
-        info->pseudo_palette    = (void *)(currentpar + 1);
+        info->pseudo_palette    = currentpar->palette;
         info->flags             = FBINFO_DEFAULT;
 
         SetCoreClockPLL(deviceInfo.pSTGReg, pdev);
@@ -741,7 +738,6 @@ static int __devinit kyrofb_probe(struct pci_dev *pdev,
 
         fb_memset(info->screen_base, 0, size);
 
-        info->device = &pdev->dev;
         if (register_framebuffer(info) < 0)
                 goto out_unmap;
 
@@ -757,7 +753,7 @@ static int __devinit kyrofb_probe(struct pci_dev *pdev,
 out_unmap:
         iounmap(currentpar->regbase);
         iounmap(info->screen_base);
-        kfree(info);
+        framebuffer_release(info);
 
         return -EINVAL;
 }
@@ -765,7 +761,7 @@ out_unmap:
 static void __devexit kyrofb_remove(struct pci_dev *pdev)
 {
         struct fb_info *info = pci_get_drvdata(pdev);
-        struct kyrofb_info *par = (struct kyrofb_info *)info->par;
+        struct kyrofb_info *par = info->par;
 
         /* Reset the board */
         StopVTG(deviceInfo.pSTGReg);
@@ -789,7 +785,7 @@ static void __devexit kyrofb_remove(struct pci_dev *pdev)
 
         unregister_framebuffer(info);
         pci_set_drvdata(pdev, NULL);
-        kfree(info);
+        framebuffer_release(info);
 }
 
 static int __init kyrofb_init(void)
diff --git a/drivers/video/matrox/matroxfb_base.h b/drivers/video/matrox/matroxfb_base.h
index a8c47ad2cdb6..3a3e1804c56a 100644
--- a/drivers/video/matrox/matroxfb_base.h
+++ b/drivers/video/matrox/matroxfb_base.h
@@ -50,8 +50,6 @@
 #include <asm/mtrr.h>
 #endif
 
-#include "../console/fbcon.h"
-
 #if defined(CONFIG_PPC_PMAC)
 #include <asm/prom.h>
 #include <asm/pci-bridge.h>
@@ -351,8 +349,6 @@ struct matrox_bios {
                       } output;
 };
 
-extern struct display fb_display[];
-
 struct matrox_switch;
 struct matroxfb_driver;
 struct matroxfb_dh_fb_info;
diff --git a/drivers/video/matrox/matroxfb_g450.c b/drivers/video/matrox/matroxfb_g450.c
index 35008af7db75..c122d8743dd2 100644
--- a/drivers/video/matrox/matroxfb_g450.c
+++ b/drivers/video/matrox/matroxfb_g450.c
@@ -20,6 +20,8 @@
 #include <asm/uaccess.h>
 #include <asm/div64.h>
 
+#include "matroxfb_g450.h"
+
 /* Definition of the various controls */
 struct mctl {
         struct v4l2_queryctrl desc;
diff --git a/drivers/video/matrox/matroxfb_misc.c b/drivers/video/matrox/matroxfb_misc.c
index d9d3e9f6c08e..455a46ce840c 100644
--- a/drivers/video/matrox/matroxfb_misc.c
+++ b/drivers/video/matrox/matroxfb_misc.c
@@ -192,11 +192,8 @@ int matroxfb_vgaHWinit(WPMINFO struct my_timming* m) {
         unsigned int wd;
         unsigned int divider;
         int i;
-        int fwidth;
         struct matrox_hw_state * const hw = &ACCESS_FBINFO(hw);
 
-        fwidth = 8;
-
         DBG(__FUNCTION__)
 
         hw->SEQ[0] = 0x00;
@@ -235,10 +232,7 @@ int matroxfb_vgaHWinit(WPMINFO struct my_timming* m) {
         hw->ATTR[16] = 0x41;
         hw->ATTR[17] = 0xFF;
         hw->ATTR[18] = 0x0F;
-        if (fwidth == 9)
-                hw->ATTR[19] = 0x08;
-        else
-                hw->ATTR[19] = 0x00;
+        hw->ATTR[19] = 0x00;
         hw->ATTR[20] = 0x00;
 
         hd = m->HDisplay >> 3;
diff --git a/drivers/video/neofb.c b/drivers/video/neofb.c
index 8486e77872dc..e18c9f98a401 100644
--- a/drivers/video/neofb.c
+++ b/drivers/video/neofb.c
@@ -485,7 +485,7 @@ static void vgaHWRestore(const struct fb_info *info,
  */
 static inline int neo2200_sync(struct fb_info *info)
 {
-        struct neofb_par *par = (struct neofb_par *) info->par;
+        struct neofb_par *par = info->par;
         int waitcycles;
 
         while (readl(&par->neo2200->bltStat) & 1)
@@ -525,7 +525,7 @@ static inline void neo2200_wait_fifo(struct fb_info *info,
 static inline void neo2200_accel_init(struct fb_info *info,
                                       struct fb_var_screeninfo *var)
 {
-        struct neofb_par *par = (struct neofb_par *) info->par;
+        struct neofb_par *par = info->par;
         Neo2200 __iomem *neo2200 = par->neo2200;
         u32 bltMod, pitch;
 
@@ -560,7 +560,7 @@ static inline void neo2200_accel_init(struct fb_info *info,
 static int
 neofb_open(struct fb_info *info, int user)
 {
-        struct neofb_par *par = (struct neofb_par *) info->par;
+        struct neofb_par *par = info->par;
         int cnt = atomic_read(&par->ref_count);
 
         if (!cnt) {
@@ -575,7 +575,7 @@ neofb_open(struct fb_info *info, int user)
 static int
 neofb_release(struct fb_info *info, int user)
 {
-        struct neofb_par *par = (struct neofb_par *) info->par;
+        struct neofb_par *par = info->par;
         int cnt = atomic_read(&par->ref_count);
 
         if (!cnt)
@@ -590,7 +590,7 @@ neofb_release(struct fb_info *info, int user)
 static int
 neofb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 {
-        struct neofb_par *par = (struct neofb_par *) info->par;
+        struct neofb_par *par = info->par;
         unsigned int pixclock = var->pixclock;
         struct xtimings timings;
         int memlen, vramlen;
@@ -757,7 +757,7 @@ neofb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 
 static int neofb_set_par(struct fb_info *info)
 {
-        struct neofb_par *par = (struct neofb_par *) info->par;
+        struct neofb_par *par = info->par;
         struct xtimings timings;
         unsigned char temp;
         int i, clock_hi = 0;
@@ -1216,7 +1216,7 @@ static int neofb_set_par(struct fb_info *info)
 static void neofb_update_start(struct fb_info *info,
                                struct fb_var_screeninfo *var)
 {
-        struct neofb_par *par = (struct neofb_par *) info->par;
+        struct neofb_par *par = info->par;
         struct vgastate *state = &par->state;
         int oldExtCRTDispAddr;
         int Base;
@@ -1331,7 +1331,7 @@ static int neofb_blank(int blank_mode, struct fb_info *info)
          *  wms...Enable VESA DPMS compatible powerdown mode
          *  run "setterm -powersave powerdown" to take advantage
          */
-        struct neofb_par *par = (struct neofb_par *)info->par;
+        struct neofb_par *par = info->par;
         int seqflags, lcdflags, dpmsflags, reg;
 
         switch (blank_mode) {
@@ -1404,7 +1404,7 @@ static int neofb_blank(int blank_mode, struct fb_info *info)
 static void
 neo2200_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
 {
-        struct neofb_par *par = (struct neofb_par *) info->par;
+        struct neofb_par *par = info->par;
         u_long dst, rop;
 
         dst = rect->dx + rect->dy * info->var.xres_virtual;
@@ -1440,7 +1440,7 @@ static void
 neo2200_copyarea(struct fb_info *info, const struct fb_copyarea *area)
 {
         u32 sx = area->sx, sy = area->sy, dx = area->dx, dy = area->dy;
-        struct neofb_par *par = (struct neofb_par *) info->par;
+        struct neofb_par *par = info->par;
         u_long src, dst, bltCntl;
 
         bltCntl = NEO_BC3_FIFO_EN | NEO_BC3_SKIP_MAPPING | 0x0C0000;
@@ -1472,7 +1472,7 @@ neo2200_copyarea(struct fb_info *info, const struct fb_copyarea *area)
 static void
 neo2200_imageblit(struct fb_info *info, const struct fb_image *image)
 {
-        struct neofb_par *par = (struct neofb_par *) info->par;
+        struct neofb_par *par = info->par;
         int s_pitch = (image->width * image->depth + 7) >> 3;
         int scan_align = info->pixmap.scan_align - 1;
         int buf_align = info->pixmap.buf_align - 1;
@@ -1686,7 +1686,7 @@ static struct fb_videomode __devinitdata mode800x480 = {
 static int __devinit neo_map_mmio(struct fb_info *info,
                                   struct pci_dev *dev)
 {
-        struct neofb_par *par = (struct neofb_par *) info->par;
+        struct neofb_par *par = info->par;
 
         DBG("neo_map_mmio");
 
@@ -1733,7 +1733,7 @@ static int __devinit neo_map_mmio(struct fb_info *info,
 
 static void neo_unmap_mmio(struct fb_info *info)
 {
-        struct neofb_par *par = (struct neofb_par *) info->par;
+        struct neofb_par *par = info->par;
 
         DBG("neo_unmap_mmio");
 
@@ -1796,7 +1796,7 @@ static void neo_unmap_video(struct fb_info *info)
 
 #ifdef CONFIG_MTRR
         {
-                struct neofb_par *par = (struct neofb_par *) info->par;
+                struct neofb_par *par = info->par;
 
                 mtrr_del(par->mtrr, info->fix.smem_start,
                          info->fix.smem_len);
@@ -1811,7 +1811,7 @@ static void neo_unmap_video(struct fb_info *info)
 
 static int __devinit neo_scan_monitor(struct fb_info *info)
 {
-        struct neofb_par *par = (struct neofb_par *) info->par;
+        struct neofb_par *par = info->par;
         unsigned char type, display;
         int w;
 
@@ -1890,7 +1890,7 @@ static int __devinit neo_scan_monitor(struct fb_info *info)
 
 static int __devinit neo_init_hw(struct fb_info *info)
 {
-        struct neofb_par *par = (struct neofb_par *) info->par;
+        struct neofb_par *par = info->par;
         int videoRam = 896;
         int maxClock = 65000;
         int CursorMem = 1024;
@@ -2014,7 +2014,7 @@ static struct fb_info *__devinit neo_alloc_fb_info(struct pci_dev *dev, const st
         struct fb_info *info;
         struct neofb_par *par;
 
-        info = framebuffer_alloc(sizeof(struct neofb_par) + sizeof(u32) * 256, &dev->dev);
+        info = framebuffer_alloc(sizeof(struct neofb_par), &dev->dev);
 
         if (!info)
                 return NULL;
@@ -2081,7 +2081,7 @@ static struct fb_info *__devinit neo_alloc_fb_info(struct pci_dev *dev, const st
         info->fix.accel = id->driver_data;
 
         info->fbops = &neofb_ops;
-        info->pseudo_palette = (void *) (par + 1);
+        info->pseudo_palette = par->palette;
         return info;
 }
 
diff --git a/drivers/video/nvidia/nv_hw.c b/drivers/video/nvidia/nv_hw.c
index b989358437b3..99c3a8e6a237 100644
--- a/drivers/video/nvidia/nv_hw.c
+++ b/drivers/video/nvidia/nv_hw.c
@@ -52,6 +52,7 @@
 #include <linux/pci.h>
 #include "nv_type.h"
 #include "nv_local.h"
+#include "nv_proto.h"
 
 void NVLockUnlock(struct nvidia_par *par, int Lock)
 {
@@ -848,7 +849,7 @@ void NVCalcStateExt(struct nvidia_par *par,
                     int width,
                     int hDisplaySize, int height, int dotClock, int flags)
 {
-        int pixelDepth, VClk;
+        int pixelDepth, VClk = 0;
         /*
          * Save mode parameters.
          */
@@ -938,15 +939,24 @@ void NVLoadStateExt(struct nvidia_par *par, RIVA_HW_STATE * state)
 
         if (par->Architecture == NV_ARCH_04) {
                 NV_WR32(par->PFB, 0x0200, state->config);
-        } else if ((par->Chipset & 0xfff0) == 0x0090) {
-                for (i = 0; i < 15; i++) {
-                        NV_WR32(par->PFB, 0x0600 + (i * 0x10), 0);
-                        NV_WR32(par->PFB, 0x0604 + (i * 0x10), par->FbMapSize - 1);
-                }
-        } else {
+        } else if ((par->Architecture < NV_ARCH_40) ||
+                   (par->Chipset & 0xfff0) == 0x0040) {
                 for (i = 0; i < 8; i++) {
                         NV_WR32(par->PFB, 0x0240 + (i * 0x10), 0);
-                        NV_WR32(par->PFB, 0x0244 + (i * 0x10), par->FbMapSize - 1);
+                        NV_WR32(par->PFB, 0x0244 + (i * 0x10),
+                                par->FbMapSize - 1);
+                }
+        } else {
+                int regions = 12;
+
+                if (((par->Chipset & 0xfff0) == 0x0090) ||
+                    ((par->Chipset & 0xfff0) == 0x01D0) ||
+                    ((par->Chipset & 0xfff0) == 0x0290))
+                        regions = 15;
+                for(i = 0; i < regions; i++) {
+                        NV_WR32(par->PFB, 0x0600 + (i * 0x10), 0);
+                        NV_WR32(par->PFB, 0x0604 + (i * 0x10),
+                                par->FbMapSize - 1);
                 }
         }
 
@@ -1182,11 +1192,17 @@ void NVLoadStateExt(struct nvidia_par *par, RIVA_HW_STATE * state)
                         NV_WR32(par->PGRAPH, 0x0608, 0xFFFFFFFF);
                 } else {
                         if (par->Architecture >= NV_ARCH_40) {
+                                u32 tmp;
+
                                 NV_WR32(par->PGRAPH, 0x0084, 0x401287c0);
                                 NV_WR32(par->PGRAPH, 0x008C, 0x60de8051);
                                 NV_WR32(par->PGRAPH, 0x0090, 0x00008000);
                                 NV_WR32(par->PGRAPH, 0x0610, 0x00be3c5f);
 
+                                tmp = NV_RD32(par->REGS, 0x1540) & 0xff;
+                                for(i = 0; tmp && !(tmp & 1); tmp >>= 1, i++);
+                                NV_WR32(par->PGRAPH, 0x5000, i);
+
                                 if ((par->Chipset & 0xfff0) == 0x0040) {
                                         NV_WR32(par->PGRAPH, 0x09b0,
                                                 0x83280fff);
@@ -1211,6 +1227,7 @@ void NVLoadStateExt(struct nvidia_par *par, RIVA_HW_STATE * state)
                                                 0xffff7fff);
                                         break;
                                 case 0x00C0:
+                                case 0x0120:
                                         NV_WR32(par->PGRAPH, 0x0828,
                                                 0x007596ff);
                                         NV_WR32(par->PGRAPH, 0x082C,
@@ -1245,6 +1262,7 @@ void NVLoadStateExt(struct nvidia_par *par, RIVA_HW_STATE * state)
                                                 0x00100000);
                                         break;
                                 case 0x0090:
+                                case 0x0290:
                                         NV_WR32(par->PRAMDAC, 0x0608,
                                                 NV_RD32(par->PRAMDAC, 0x0608) |
                                                 0x00100000);
@@ -1310,14 +1328,44 @@ void NVLoadStateExt(struct nvidia_par *par, RIVA_HW_STATE * state)
                                 }
                         }
 
-                        if ((par->Chipset & 0xfff0) == 0x0090) {
-                                for (i = 0; i < 60; i++)
-                                        NV_WR32(par->PGRAPH, 0x0D00 + i,
-                                                NV_RD32(par->PFB, 0x0600 + i));
+                        if ((par->Architecture < NV_ARCH_40) ||
+                            ((par->Chipset & 0xfff0) == 0x0040)) {
+                                for (i = 0; i < 32; i++) {
+                                        NV_WR32(par->PGRAPH, 0x0900 + i*4,
+                                                NV_RD32(par->PFB, 0x0240 +i*4));
+                                        NV_WR32(par->PGRAPH, 0x6900 + i*4,
+                                                NV_RD32(par->PFB, 0x0240 +i*4));
+                                }
                         } else {
-                                for (i = 0; i < 32; i++)
-                                        NV_WR32(par->PGRAPH, 0x0900 + i,
-                                                NV_RD32(par->PFB, 0x0240 + i));
+                                if (((par->Chipset & 0xfff0) == 0x0090) ||
+                                    ((par->Chipset & 0xfff0) == 0x01D0) ||
+                                    ((par->Chipset & 0xfff0) == 0x0290)) {
+                                        for (i = 0; i < 60; i++) {
+                                                NV_WR32(par->PGRAPH,
+                                                        0x0D00 + i*4,
+                                                        NV_RD32(par->PFB,
+                                                                0x0600 + i*4));
+                                                NV_WR32(par->PGRAPH,
+                                                        0x6900 + i*4,
+                                                        NV_RD32(par->PFB,
+                                                                0x0600 + i*4));
+                                        }
+                                } else {
+                                        for (i = 0; i < 48; i++) {
+                                                NV_WR32(par->PGRAPH,
+                                                        0x0900 + i*4,
+                                                        NV_RD32(par->PFB,
+                                                                0x0600 + i*4));
+                                                if(((par->Chipset & 0xfff0)
+                                                    != 0x0160) &&
+                                                   ((par->Chipset & 0xfff0)
+                                                    != 0x0220))
+                                                        NV_WR32(par->PGRAPH,
+                                                                0x6900 + i*4,
+                                                                NV_RD32(par->PFB,
+                                                                        0x0600 + i*4));
+                                        }
+                                }
                         }
 
                         if (par->Architecture >= NV_ARCH_40) {
@@ -1338,7 +1386,9 @@ void NVLoadStateExt(struct nvidia_par *par, RIVA_HW_STATE * state)
                                         NV_WR32(par->PGRAPH, 0x0868,
                                                 par->FbMapSize - 1);
                                 } else {
-                                        if((par->Chipset & 0xfff0) == 0x0090) {
+                                        if ((par->Chipset & 0xfff0) == 0x0090 ||
+                                            (par->Chipset & 0xfff0) == 0x01D0 ||
+                                            (par->Chipset & 0xfff0) == 0x0290) {
                                                 NV_WR32(par->PGRAPH, 0x0DF0,
                                                         NV_RD32(par->PFB, 0x0200));
                                                 NV_WR32(par->PGRAPH, 0x0DF4,
diff --git a/drivers/video/nvidia/nv_i2c.c b/drivers/video/nvidia/nv_i2c.c
index 12f2884d3f0b..bd9eca05e146 100644
--- a/drivers/video/nvidia/nv_i2c.c
+++ b/drivers/video/nvidia/nv_i2c.c
@@ -46,7 +46,7 @@ static void nvidia_gpio_setscl(void *data, int state)
 
 static void nvidia_gpio_setsda(void *data, int state)
 {
-        struct nvidia_i2c_chan *chan = (struct nvidia_i2c_chan *)data;
+        struct nvidia_i2c_chan *chan = data;
         struct nvidia_par *par = chan->par;
         u32 val;
 
@@ -64,7 +64,7 @@ static void nvidia_gpio_setsda(void *data, int state)
 
 static int nvidia_gpio_getscl(void *data)
 {
-        struct nvidia_i2c_chan *chan = (struct nvidia_i2c_chan *)data;
+        struct nvidia_i2c_chan *chan = data;
         struct nvidia_par *par = chan->par;
         u32 val = 0;
 
@@ -79,7 +79,7 @@ static int nvidia_gpio_getscl(void *data)
 
 static int nvidia_gpio_getsda(void *data)
 {
-        struct nvidia_i2c_chan *chan = (struct nvidia_i2c_chan *)data;
+        struct nvidia_i2c_chan *chan = data;
         struct nvidia_par *par = chan->par;
         u32 val = 0;
 
@@ -136,13 +136,13 @@ void nvidia_create_i2c_busses(struct nvidia_par *par)
         par->chan[2].par = par;
 
         par->chan[0].ddc_base = 0x3e;
-        nvidia_setup_i2c_bus(&par->chan[0], "BUS1");
+        nvidia_setup_i2c_bus(&par->chan[0], "nvidia #0");
 
         par->chan[1].ddc_base = 0x36;
-        nvidia_setup_i2c_bus(&par->chan[1], "BUS2");
+        nvidia_setup_i2c_bus(&par->chan[1], "nvidia #1");
 
         par->chan[2].ddc_base = 0x50;
-        nvidia_setup_i2c_bus(&par->chan[2], "BUS3");
+        nvidia_setup_i2c_bus(&par->chan[2], "nvidia #2");
 }
 
 void nvidia_delete_i2c_busses(struct nvidia_par *par)
diff --git a/drivers/video/nvidia/nv_proto.h b/drivers/video/nvidia/nv_proto.h
index 3353103e8b0b..b149a690ee0f 100644
--- a/drivers/video/nvidia/nv_proto.h
+++ b/drivers/video/nvidia/nv_proto.h
@@ -4,7 +4,7 @@
 #define __NV_PROTO_H__
 
 /* in nv_setup.c */
-void NVCommonSetup(struct fb_info *info);
+int NVCommonSetup(struct fb_info *info);
 void NVWriteCrtc(struct nvidia_par *par, u8 index, u8 value);
 u8 NVReadCrtc(struct nvidia_par *par, u8 index);
 void NVWriteGr(struct nvidia_par *par, u8 index, u8 value);
diff --git a/drivers/video/nvidia/nv_setup.c b/drivers/video/nvidia/nv_setup.c
index 1f06a9f1bd0f..a18a9aebf05f 100644
--- a/drivers/video/nvidia/nv_setup.c
+++ b/drivers/video/nvidia/nv_setup.c
@@ -285,28 +285,34 @@ static void nv10GetConfig(struct nvidia_par *par)
                         par->CrystalFreqKHz = 27000;
         }
 
-        par->CursorStart = (par->RamAmountKBytes - 96) * 1024;
         par->CURSOR = NULL;     /* can't set this here */
         par->MinVClockFreqKHz = 12000;
         par->MaxVClockFreqKHz = par->twoStagePLL ? 400000 : 350000;
 }
 
-void NVCommonSetup(struct fb_info *info)
+int NVCommonSetup(struct fb_info *info)
 {
         struct nvidia_par *par = info->par;
-        struct fb_var_screeninfo var;
+        struct fb_var_screeninfo *var;
         u16 implementation = par->Chipset & 0x0ff0;
         u8 *edidA = NULL, *edidB = NULL;
-        struct fb_monspecs monitorA, monitorB;
+        struct fb_monspecs *monitorA, *monitorB;
         struct fb_monspecs *monA = NULL, *monB = NULL;
         int mobile = 0;
         int tvA = 0;
         int tvB = 0;
         int FlatPanel = -1;     /* really means the CRTC is slaved */
         int Television = 0;
+        int err = 0;
 
-        memset(&monitorA, 0, sizeof(struct fb_monspecs));
-        memset(&monitorB, 0, sizeof(struct fb_monspecs));
+        var = kzalloc(sizeof(struct fb_var_screeninfo), GFP_KERNEL);
+        monitorA = kzalloc(sizeof(struct fb_monspecs), GFP_KERNEL);
+        monitorB = kzalloc(sizeof(struct fb_monspecs), GFP_KERNEL);
+
+        if (!var || !monitorA || !monitorB) {
+                err = -ENOMEM;
+                goto done;
+        }
 
         par->PRAMIN = par->REGS + (0x00710000 / 4);
         par->PCRTC0 = par->REGS + (0x00600000 / 4);
@@ -382,6 +388,8 @@ void NVCommonSetup(struct fb_info *info)
         case 0x0146:
         case 0x0147:
         case 0x0148:
+        case 0x0098:
+        case 0x0099:
                 mobile = 1;
                 break;
         default:
@@ -406,9 +414,9 @@ void NVCommonSetup(struct fb_info *info)
                 par->CRTCnumber = 0;
                 if (nvidia_probe_i2c_connector(info, 1, &edidA))
                         nvidia_probe_of_connector(info, 1, &edidA);
-                if (edidA && !fb_parse_edid(edidA, &var)) {
+                if (edidA && !fb_parse_edid(edidA, var)) {
                         printk("nvidiafb: EDID found from BUS1\n");
-                        monA = &monitorA;
+                        monA = monitorA;
                         fb_edid_to_monspecs(edidA, monA);
                         FlatPanel = (monA->input & FB_DISP_DDI) ? 1 : 0;
 
@@ -494,17 +502,17 @@ void NVCommonSetup(struct fb_info *info)
 
                 if (nvidia_probe_i2c_connector(info, 1, &edidA))
                         nvidia_probe_of_connector(info, 1, &edidA);
-                if (edidA && !fb_parse_edid(edidA, &var)) {
+                if (edidA && !fb_parse_edid(edidA, var)) {
                         printk("nvidiafb: EDID found from BUS1\n");
-                        monA = &monitorA;
+                        monA = monitorA;
                         fb_edid_to_monspecs(edidA, monA);
                 }
 
                 if (nvidia_probe_i2c_connector(info, 2, &edidB))
                         nvidia_probe_of_connector(info, 2, &edidB);
-                if (edidB && !fb_parse_edid(edidB, &var)) {
+                if (edidB && !fb_parse_edid(edidB, var)) {
                         printk("nvidiafb: EDID found from BUS2\n");
-                        monB = &monitorB;
+                        monB = monitorB;
                         fb_edid_to_monspecs(edidB, monB);
                 }
 
@@ -639,4 +647,9 @@ void NVCommonSetup(struct fb_info *info)
 
         kfree(edidA);
         kfree(edidB);
+done:
+        kfree(var);
+        kfree(monitorA);
+        kfree(monitorB);
+        return err;
 }
diff --git a/drivers/video/nvidia/nvidia.c b/drivers/video/nvidia/nvidia.c
index bee09c6e48f6..dbcb8962e57d 100644
--- a/drivers/video/nvidia/nvidia.c
+++ b/drivers/video/nvidia/nvidia.c
@@ -284,6 +284,16 @@ static struct pci_device_id nvidiafb_pci_tbl[] = {
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         {PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE_6200,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+        {PCI_VENDOR_ID_NVIDIA, PCIE_DEVICE_ID_NVIDIA_GEFORCE_6800_ALT1,
+         PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+        {PCI_VENDOR_ID_NVIDIA, PCIE_DEVICE_ID_NVIDIA_GEFORCE_6600_ALT1,
+         PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+        {PCI_VENDOR_ID_NVIDIA, PCIE_DEVICE_ID_NVIDIA_GEFORCE_6600_ALT2,
+         PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+        {PCI_VENDOR_ID_NVIDIA, PCIE_DEVICE_ID_NVIDIA_GEFORCE_6200_ALT1,
+         PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+        {PCI_VENDOR_ID_NVIDIA, PCIE_DEVICE_ID_NVIDIA_GEFORCE_6800_GT,
+         PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         {PCI_VENDOR_ID_NVIDIA, 0x0252,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         {PCI_VENDOR_ID_NVIDIA, 0x0313,
@@ -418,6 +428,7 @@ static int noaccel __devinitdata = 0;
 static int noscale __devinitdata = 0;
 static int paneltweak __devinitdata = 0;
 static int vram __devinitdata = 0;
+static int bpp __devinitdata = 8;
 #ifdef CONFIG_MTRR
 static int nomtrr __devinitdata = 0;
 #endif
@@ -485,7 +496,7 @@ static int nvidia_backlight_levels[] = {
 
 static int nvidia_set_backlight_enable(int on, int level, void *data)
 {
-        struct nvidia_par *par = (struct nvidia_par *)data;
+        struct nvidia_par *par = data;
         u32 tmp_pcrt, tmp_pmc, fpcontrol;
 
         tmp_pmc = NV_RD32(par->PMC, 0x10F0) & 0x0000FFFF;
@@ -1382,24 +1393,36 @@ static int __devinit nvidia_set_fbinfo(struct fb_info *info)
                                  info->monspecs.modedb_len, &info->modelist);
         fb_var_to_videomode(&modedb, &nvidiafb_default_var);
 
+        switch (bpp) {
+        case 0 ... 8:
+                bpp = 8;
+                break;
+        case 9 ... 16:
+                bpp = 16;
+                break;
+        default:
+                bpp = 32;
+                break;
+        }
+
         if (specs->modedb != NULL) {
                 struct fb_videomode *modedb;
 
                 modedb = fb_find_best_display(specs, &info->modelist);
                 fb_videomode_to_var(&nvidiafb_default_var, modedb);
-                nvidiafb_default_var.bits_per_pixel = 8;
+                nvidiafb_default_var.bits_per_pixel = bpp;
         } else if (par->fpWidth && par->fpHeight) {
                 char buf[16];
 
                 memset(buf, 0, 16);
                 snprintf(buf, 15, "%dx%dMR", par->fpWidth, par->fpHeight);
                 fb_find_mode(&nvidiafb_default_var, info, buf, specs->modedb,
-                             specs->modedb_len, &modedb, 8);
+                             specs->modedb_len, &modedb, bpp);
         }
 
         if (mode_option)
                 fb_find_mode(&nvidiafb_default_var, info, mode_option,
-                             specs->modedb, specs->modedb_len, &modedb, 8);
+                             specs->modedb, specs->modedb_len, &modedb, bpp);
 
         info->var = nvidiafb_default_var;
         info->fix.visual = (info->var.bits_per_pixel == 8) ?
@@ -1448,11 +1471,34 @@ static int __devinit nvidia_set_fbinfo(struct fb_info *info)
         return nvidiafb_check_var(&info->var, info);
 }
 
-static u32 __devinit nvidia_get_arch(struct pci_dev *pd)
+static u32 __devinit nvidia_get_chipset(struct fb_info *info)
 {
+        struct nvidia_par *par = info->par;
+        u32 id = (par->pci_dev->vendor << 16) | par->pci_dev->device;
+
+        printk("nvidiafb: PCI id - %x\n", id);
+        if ((id & 0xfff0) == 0x00f0) {
+                /* pci-e */
+                printk("nvidiafb: PCI-E card\n");
+                id = NV_RD32(par->REGS, 0x1800);
+
+                if ((id & 0x0000ffff) == 0x000010DE)
+                        id = 0x10DE0000 | (id >> 16);
+                else if ((id & 0xffff0000) == 0xDE100000) /* wrong endian */
+                        id = 0x10DE0000 | ((id << 8) & 0x0000ff00) |
+                            ((id >> 8) & 0x000000ff);
+        }
+
+        printk("nvidiafb: Actual id - %x\n", id);
+        return id;
+}
+
+static u32 __devinit nvidia_get_arch(struct fb_info *info)
+{
+        struct nvidia_par *par = info->par;
         u32 arch = 0;
 
-        switch (pd->device & 0x0ff0) {
+        switch (par->Chipset & 0x0ff0) {
         case 0x0100:            /* GeForce 256 */
         case 0x0110:            /* GeForce2 MX */
         case 0x0150:            /* GeForce2 */
@@ -1485,6 +1531,8 @@ static u32 __devinit nvidia_get_arch(struct pci_dev *pd)
         case 0x0210:
         case 0x0220:
         case 0x0230:
+        case 0x0290:
+        case 0x0390:
                 arch = NV_ARCH_40;
                 break;
         case 0x0020:            /* TNT, TNT2 */
@@ -1513,7 +1561,7 @@ static int __devinit nvidiafb_probe(struct pci_dev *pd,
         if (!info)
                 goto err_out;
 
-        par = (struct nvidia_par *)info->par;
+        par = info->par;
         par->pci_dev = pd;
 
         info->pixmap.addr = kmalloc(8 * 1024, GFP_KERNEL);
@@ -1533,18 +1581,6 @@ static int __devinit nvidiafb_probe(struct pci_dev *pd,
                 goto err_out_request;
         }
 
-        par->Architecture = nvidia_get_arch(pd);
-
-        par->Chipset = (pd->vendor << 16) | pd->device;
-        printk(KERN_INFO PFX "nVidia device/chipset %X\n", par->Chipset);
-
-        if (par->Architecture == 0) {
-                printk(KERN_ERR PFX "unknown NV_ARCH\n");
-                goto err_out_free_base0;
-        }
-
-        sprintf(nvidiafb_fix.id, "NV%x", (pd->device & 0x0ff0) >> 4);
-
         par->FlatPanel = flatpanel;
         if (flatpanel == 1)
                 printk(KERN_INFO PFX "flatpanel support enabled\n");
@@ -1570,7 +1606,19 @@ static int __devinit nvidiafb_probe(struct pci_dev *pd,
                 goto err_out_free_base0;
         }
 
-        NVCommonSetup(info);
+        par->Chipset = nvidia_get_chipset(info);
+        printk(KERN_INFO PFX "nVidia device/chipset %X\n", par->Chipset);
+        par->Architecture = nvidia_get_arch(info);
+
+        if (par->Architecture == 0) {
+                printk(KERN_ERR PFX "unknown NV_ARCH\n");
+                goto err_out_arch;
+        }
+
+        sprintf(nvidiafb_fix.id, "NV%x", (pd->device & 0x0ff0) >> 4);
+
+        if (NVCommonSetup(info))
+                goto err_out_arch;
 
         par->FbAddress = nvidiafb_fix.smem_start;
         par->FbMapSize = par->RamAmountKBytes * 1024;
@@ -1581,10 +1629,15 @@ static int __devinit nvidiafb_probe(struct pci_dev *pd,
         if (par->FbMapSize > 64 * 1024 * 1024)
                 par->FbMapSize = 64 * 1024 * 1024;
 
-        par->FbUsableSize = par->FbMapSize - (128 * 1024);
+        if(par->Architecture >= NV_ARCH_40)
+                par->FbUsableSize = par->FbMapSize - (560 * 1024);
+        else
+                par->FbUsableSize = par->FbMapSize - (128 * 1024);
         par->ScratchBufferSize = (par->Architecture < NV_ARCH_10) ? 8 * 1024 :
             16 * 1024;
         par->ScratchBufferStart = par->FbUsableSize - par->ScratchBufferSize;
+        par->CursorStart = par->FbUsableSize + (32 * 1024);
+
         info->screen_base = ioremap(nvidiafb_fix.smem_start, par->FbMapSize);
         info->screen_size = par->FbUsableSize;
         nvidiafb_fix.smem_len = par->RamAmountKBytes * 1024;
@@ -1640,21 +1693,22 @@ static int __devinit nvidiafb_probe(struct pci_dev *pd,
         NVTRACE_LEAVE();
         return 0;
 
-      err_out_iounmap_fb:
+err_out_iounmap_fb:
         iounmap(info->screen_base);
-      err_out_free_base1:
+err_out_free_base1:
         fb_destroy_modedb(info->monspecs.modedb);
         nvidia_delete_i2c_busses(par);
+err_out_arch:
         iounmap(par->REGS);
-      err_out_free_base0:
+err_out_free_base0:
         pci_release_regions(pd);
-      err_out_request:
+err_out_request:
         pci_disable_device(pd);
-      err_out_enable:
+err_out_enable:
         kfree(info->pixmap.addr);
-      err_out_kfree:
+err_out_kfree:
         framebuffer_release(info);
-      err_out:
+err_out:
         return -ENODEV;
 }
 
@@ -1729,6 +1783,8 @@ static int __devinit nvidiafb_setup(char *options)
 #endif
                 } else if (!strncmp(this_opt, "fpdither:", 9)) {
                         fpdither = simple_strtol(this_opt+9, NULL, 0);
+                } else if (!strncmp(this_opt, "bpp:", 4)) {
+                        bpp = simple_strtoul(this_opt+4, NULL, 0);
                 } else
                         mode_option = this_opt;
         }
@@ -1804,6 +1860,11 @@ module_param(vram, int, 0);
 MODULE_PARM_DESC(vram,
                  "amount of framebuffer memory to remap in MiB"
                  "(default=0 - remap entire memory)");
+module_param(mode_option, charp, 0);
+MODULE_PARM_DESC(mode_option, "Specify initial video mode");
+module_param(bpp, int, 0);
+MODULE_PARM_DESC(bpp, "pixel width in bits"
+                 "(default=8)");
 #ifdef CONFIG_MTRR
 module_param(nomtrr, bool, 0);
 MODULE_PARM_DESC(nomtrr, "Disables MTRR support (0 or 1=disabled) "
diff --git a/drivers/video/pm2fb.c b/drivers/video/pm2fb.c
index 0277ce031e5e..5fe197943deb 100644
--- a/drivers/video/pm2fb.c
+++ b/drivers/video/pm2fb.c
@@ -91,6 +91,7 @@ struct pm2fb_par
         u32             mem_config;     /* MemConfig reg at probe */
         u32             mem_control;    /* MemControl reg at probe */
         u32             boot_address;   /* BootAddress reg at probe */
+        u32             palette[16];
 };
 
 /*
@@ -674,7 +675,7 @@ static int pm2fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
  */
 static int pm2fb_set_par(struct fb_info *info)
 {
-        struct pm2fb_par *par = (struct pm2fb_par *) info->par;
+        struct pm2fb_par *par = info->par;
         u32 pixclock;
         u32 width, height, depth;
         u32 hsstart, hsend, hbend, htotal;
@@ -854,7 +855,7 @@ static int pm2fb_setcolreg(unsigned regno, unsigned red, unsigned green,
                            unsigned blue, unsigned transp,
                            struct fb_info *info)
 {
-        struct pm2fb_par *par = (struct pm2fb_par *) info->par;
+        struct pm2fb_par *par = info->par;
 
         if (regno >= info->cmap.len)  /* no. of hw registers */
                 return 1;
@@ -929,7 +930,7 @@ static int pm2fb_setcolreg(unsigned regno, unsigned red, unsigned green,
                 case 16:
                 case 24:
                 case 32:        
-                        ((u32*)(info->pseudo_palette))[regno] = v;
+                        par->palette[regno] = v;
                         break;
                 }
                 return 0;
@@ -955,7 +956,7 @@ static int pm2fb_setcolreg(unsigned regno, unsigned red, unsigned green,
 static int pm2fb_pan_display(struct fb_var_screeninfo *var,
                              struct fb_info *info)
 {
-        struct pm2fb_par *p = (struct pm2fb_par *) info->par;
+        struct pm2fb_par *p = info->par;
         u32 base;
         u32 depth;
         u32 xres;
@@ -987,7 +988,7 @@ static int pm2fb_pan_display(struct fb_var_screeninfo *var,
  */
 static int pm2fb_blank(int blank_mode, struct fb_info *info)
 {
-        struct pm2fb_par *par = (struct pm2fb_par *) info->par;
+        struct pm2fb_par *par = info->par;
         u32 video = par->video;
 
         DPRINTK("blank_mode %d\n", blank_mode);
@@ -1054,8 +1055,7 @@ static int __devinit pm2fb_probe(struct pci_dev *pdev,
 {
         struct pm2fb_par *default_par;
         struct fb_info *info;
-        int size, err;
-        int err_retval = -ENXIO;
+        int err, err_retval = -ENXIO;
 
         err = pci_enable_device(pdev);
         if ( err ) {
@@ -1063,11 +1063,10 @@ static int __devinit pm2fb_probe(struct pci_dev *pdev,
                 return err;
         }
 
-        size = sizeof(struct pm2fb_par) + 256 * sizeof(u32);
-        info = framebuffer_alloc(size, &pdev->dev);
+        info = framebuffer_alloc(sizeof(struct pm2fb_par), &pdev->dev);
         if ( !info )
                 return -ENOMEM;
-        default_par = (struct pm2fb_par *) info->par;
+        default_par = info->par;
 
         switch (pdev->device) {
         case  PCI_DEVICE_ID_TI_TVP4020:
@@ -1171,7 +1170,7 @@ static int __devinit pm2fb_probe(struct pci_dev *pdev,
 
         info->fbops             = &pm2fb_ops;
         info->fix               = pm2fb_fix;    
-        info->pseudo_palette    = (void *)(default_par + 1); 
+        info->pseudo_palette    = default_par->palette;
         info->flags             = FBINFO_DEFAULT |
                                   FBINFO_HWACCEL_YPAN;
 
diff --git a/drivers/video/riva/fbdev.c b/drivers/video/riva/fbdev.c
index 3e9f96e9237d..6c19ab6afb01 100644
--- a/drivers/video/riva/fbdev.c
+++ b/drivers/video/riva/fbdev.c
@@ -630,7 +630,7 @@ static void riva_load_video_mode(struct fb_info *info)
         int bpp, width, hDisplaySize, hDisplay, hStart,
             hEnd, hTotal, height, vDisplay, vStart, vEnd, vTotal, dotClock;
         int hBlankStart, hBlankEnd, vBlankStart, vBlankEnd;
-        struct riva_par *par = (struct riva_par *) info->par;
+        struct riva_par *par = info->par;
         struct riva_regs newmode;
         
         NVTRACE_ENTER();
@@ -925,7 +925,7 @@ riva_set_rop_solid(struct riva_par *par, int rop)
 
 static void riva_setup_accel(struct fb_info *info)
 {
-        struct riva_par *par = (struct riva_par *) info->par;
+        struct riva_par *par = info->par;
 
         RIVA_FIFO_FREE(par->riva, Clip, 2);
         NV_WR32(&par->riva.Clip->TopLeft, 0, 0x0);
@@ -979,7 +979,7 @@ static int riva_get_cmap_len(const struct fb_var_screeninfo *var)
 #ifdef CONFIG_PMAC_BACKLIGHT
 static int riva_set_backlight_enable(int on, int level, void *data)
 {
-        struct riva_par *par = (struct riva_par *)data;
+        struct riva_par *par = data;
         U032 tmp_pcrt, tmp_pmc;
 
         tmp_pmc = par->riva.PMC[0x10F0/4] & 0x0000FFFF;
@@ -1008,7 +1008,7 @@ static int riva_set_backlight_level(int level, void *data)
 
 static int rivafb_open(struct fb_info *info, int user)
 {
-        struct riva_par *par = (struct riva_par *) info->par;
+        struct riva_par *par = info->par;
         int cnt = atomic_read(&par->ref_count);
 
         NVTRACE_ENTER();
@@ -1034,7 +1034,7 @@ static int rivafb_open(struct fb_info *info, int user)
 
 static int rivafb_release(struct fb_info *info, int user)
 {
-        struct riva_par *par = (struct riva_par *) info->par;
+        struct riva_par *par = info->par;
         int cnt = atomic_read(&par->ref_count);
 
         NVTRACE_ENTER();
@@ -1057,7 +1057,7 @@ static int rivafb_release(struct fb_info *info, int user)
 static int rivafb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 {
         struct fb_videomode *mode;
-        struct riva_par *par = (struct riva_par *) info->par;
+        struct riva_par *par = info->par;
         int nom, den;           /* translating from pixels->bytes */
         int mode_valid = 0;
         
@@ -1166,7 +1166,7 @@ static int rivafb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 
 static int rivafb_set_par(struct fb_info *info)
 {
-        struct riva_par *par = (struct riva_par *) info->par;
+        struct riva_par *par = info->par;
 
         NVTRACE_ENTER();
         /* vgaHWunlock() + riva unlock (0x7F) */
@@ -1205,43 +1205,19 @@ static int rivafb_set_par(struct fb_info *info)
 static int rivafb_pan_display(struct fb_var_screeninfo *var,
                               struct fb_info *info)
 {
-        struct riva_par *par = (struct riva_par *)info->par;
+        struct riva_par *par = info->par;
         unsigned int base;
 
         NVTRACE_ENTER();
-        if (var->xoffset > (var->xres_virtual - var->xres))
-                return -EINVAL;
-        if (var->yoffset > (var->yres_virtual - var->yres))
-                return -EINVAL;
-
-        if (var->vmode & FB_VMODE_YWRAP) {
-                if (var->yoffset < 0
-                    || var->yoffset >= info->var.yres_virtual
-                    || var->xoffset) return -EINVAL;
-        } else {
-                if (var->xoffset + info->var.xres > info->var.xres_virtual ||
-                    var->yoffset + info->var.yres > info->var.yres_virtual)
-                        return -EINVAL;
-        }
-
         base = var->yoffset * info->fix.line_length + var->xoffset;
-
         par->riva.SetStartAddress(&par->riva, base);
-
-        info->var.xoffset = var->xoffset;
-        info->var.yoffset = var->yoffset;
-
-        if (var->vmode & FB_VMODE_YWRAP)
-                info->var.vmode |= FB_VMODE_YWRAP;
-        else
-                info->var.vmode &= ~FB_VMODE_YWRAP;
         NVTRACE_LEAVE();
         return 0;
 }
 
 static int rivafb_blank(int blank, struct fb_info *info)
 {
-        struct riva_par *par= (struct riva_par *)info->par;
+        struct riva_par *par= info->par;
         unsigned char tmp, vesa;
 
         tmp = SEQin(par, 0x01) & ~0x20; /* screen on/off */
@@ -1304,7 +1280,7 @@ static int rivafb_setcolreg(unsigned regno, unsigned red, unsigned green,
                           unsigned blue, unsigned transp,
                           struct fb_info *info)
 {
-        struct riva_par *par = (struct riva_par *)info->par;
+        struct riva_par *par = info->par;
         RIVA_HW_INST *chip = &par->riva;
         int i;
 
@@ -1393,7 +1369,7 @@ static int rivafb_setcolreg(unsigned regno, unsigned red, unsigned green,
  */
 static void rivafb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
 {
-        struct riva_par *par = (struct riva_par *) info->par;
+        struct riva_par *par = info->par;
         u_int color, rop = 0;
 
         if ((info->flags & FBINFO_HWACCEL_DISABLED)) {
@@ -1449,7 +1425,7 @@ static void rivafb_fillrect(struct fb_info *info, const struct fb_fillrect *rect
  */
 static void rivafb_copyarea(struct fb_info *info, const struct fb_copyarea *region)
 {
-        struct riva_par *par = (struct riva_par *) info->par;
+        struct riva_par *par = info->par;
 
         if ((info->flags & FBINFO_HWACCEL_DISABLED)) {
                 cfb_copyarea(info, region);
@@ -1495,7 +1471,7 @@ static inline void convert_bgcolor_16(u32 *col)
 static void rivafb_imageblit(struct fb_info *info, 
                              const struct fb_image *image)
 {
-        struct riva_par *par = (struct riva_par *) info->par;
+        struct riva_par *par = info->par;
         u32 fgx = 0, bgx = 0, width, tmp;
         u8 *cdat = (u8 *) image->data;
         volatile u32 __iomem *d;
@@ -1580,7 +1556,7 @@ static void rivafb_imageblit(struct fb_info *info,
  */
 static int rivafb_cursor(struct fb_info *info, struct fb_cursor *cursor)
 {
-        struct riva_par *par = (struct riva_par *) info->par;
+        struct riva_par *par = info->par;
         u8 data[MAX_CURS * MAX_CURS/8];
         int i, set = cursor->set;
         u16 fg, bg;
@@ -1664,7 +1640,7 @@ static int rivafb_cursor(struct fb_info *info, struct fb_cursor *cursor)
 
 static int rivafb_sync(struct fb_info *info)
 {
-        struct riva_par *par = (struct riva_par *)info->par;
+        struct riva_par *par = info->par;
 
         wait_for_idle(par);
         return 0;
@@ -1696,7 +1672,7 @@ static struct fb_ops riva_fb_ops = {
 static int __devinit riva_set_fbinfo(struct fb_info *info)
 {
         unsigned int cmap_len;
-        struct riva_par *par = (struct riva_par *) info->par;
+        struct riva_par *par = info->par;
 
         NVTRACE_ENTER();
         info->flags = FBINFO_DEFAULT
@@ -1733,7 +1709,7 @@ static int __devinit riva_set_fbinfo(struct fb_info *info)
 #ifdef CONFIG_PPC_OF
 static int __devinit riva_get_EDID_OF(struct fb_info *info, struct pci_dev *pd)
 {
-        struct riva_par *par = (struct riva_par *) info->par;
+        struct riva_par *par = info->par;
         struct device_node *dp;
         unsigned char *pedid = NULL;
         unsigned char *disptype = NULL;
@@ -1767,7 +1743,7 @@ static int __devinit riva_get_EDID_OF(struct fb_info *info, struct pci_dev *pd)
 #if defined(CONFIG_FB_RIVA_I2C) && !defined(CONFIG_PPC_OF)
 static int __devinit riva_get_EDID_i2c(struct fb_info *info)
 {
-        struct riva_par *par = (struct riva_par *) info->par;
+        struct riva_par *par = info->par;
         struct fb_var_screeninfo var;
         int i;
 
@@ -1837,7 +1813,7 @@ static void __devinit riva_get_EDID(struct fb_info *info, struct pci_dev *pdev)
 static void __devinit riva_get_edidinfo(struct fb_info *info)
 {
         struct fb_var_screeninfo *var = &rivafb_default_var;
-        struct riva_par *par = (struct riva_par *) info->par;
+        struct riva_par *par = info->par;
 
         fb_edid_to_monspecs(par->EDID, &info->monspecs);
         fb_videomode_to_modelist(info->monspecs.modedb, info->monspecs.modedb_len,
@@ -1909,7 +1885,7 @@ static int __devinit rivafb_probe(struct pci_dev *pd,
                 ret = -ENOMEM;
                 goto err_ret;
         }
-        default_par = (struct riva_par *) info->par;
+        default_par = info->par;
         default_par->pdev = pd;
 
         info->pixmap.addr = kmalloc(8 * 1024, GFP_KERNEL);
@@ -2070,7 +2046,7 @@ static int __devinit rivafb_probe(struct pci_dev *pd,
 
 err_iounmap_screen_base:
 #ifdef CONFIG_FB_RIVA_I2C
-        riva_delete_i2c_busses((struct riva_par *) info->par);
+        riva_delete_i2c_busses(info->par);
 #endif
         iounmap(info->screen_base);
 err_iounmap_pramin:
@@ -2093,7 +2069,7 @@ err_ret:
 static void __exit rivafb_remove(struct pci_dev *pd)
 {
         struct fb_info *info = pci_get_drvdata(pd);
-        struct riva_par *par = (struct riva_par *) info->par;
+        struct riva_par *par = info->par;
         
         NVTRACE_ENTER();
         if (!info)
diff --git a/drivers/video/riva/rivafb-i2c.c b/drivers/video/riva/rivafb-i2c.c
index 77151d8e0766..8b1967fc116a 100644
--- a/drivers/video/riva/rivafb-i2c.c
+++ b/drivers/video/riva/rivafb-i2c.c
@@ -30,7 +30,7 @@
 
 static void riva_gpio_setscl(void* data, int state)
 {
-        struct riva_i2c_chan    *chan = (struct riva_i2c_chan *)data;
+        struct riva_i2c_chan    *chan = data;
         struct riva_par         *par = chan->par;
         u32                     val;
 
@@ -48,7 +48,7 @@ static void riva_gpio_setscl(void* data, int state)
 
 static void riva_gpio_setsda(void* data, int state)
 {
-        struct riva_i2c_chan    *chan = (struct riva_i2c_chan *)data;
+        struct riva_i2c_chan    *chan = data;
         struct riva_par         *par = chan->par;
         u32                     val;
 
@@ -66,7 +66,7 @@ static void riva_gpio_setsda(void* data, int state)
 
 static int riva_gpio_getscl(void* data)
 {
-        struct riva_i2c_chan    *chan = (struct riva_i2c_chan *)data;
+        struct riva_i2c_chan    *chan = data;
         struct riva_par         *par = chan->par;
         u32                     val = 0;
 
@@ -81,7 +81,7 @@ static int riva_gpio_getscl(void* data)
 
 static int riva_gpio_getsda(void* data)
 {
-        struct riva_i2c_chan    *chan = (struct riva_i2c_chan *)data;
+        struct riva_i2c_chan    *chan = data;
         struct riva_par         *par = chan->par;
         u32                     val = 0;
 
diff --git a/drivers/video/s3c2410fb.c b/drivers/video/s3c2410fb.c
index fe99d17a21d7..d574dd3c9c8a 100644
--- a/drivers/video/s3c2410fb.c
+++ b/drivers/video/s3c2410fb.c
@@ -552,7 +552,7 @@ static inline void modify_gpio(void __iomem *reg,
  * s3c2410fb_init_registers - Initialise all LCD-related registers
  */
 
-int s3c2410fb_init_registers(struct s3c2410fb_info *fbi)
+static int s3c2410fb_init_registers(struct s3c2410fb_info *fbi)
 {
         unsigned long flags;
 
@@ -634,7 +634,7 @@ static irqreturn_t s3c2410fb_irq(int irq, void *dev_id, struct pt_regs *r)
 
 static char driver_name[]="s3c2410fb";
 
-int __init s3c2410fb_probe(struct platform_device *pdev)
+static int __init s3c2410fb_probe(struct platform_device *pdev)
 {
         struct s3c2410fb_info *info;
         struct fb_info     *fbinfo;
@@ -667,8 +667,6 @@ int __init s3c2410fb_probe(struct platform_device *pdev)
         info->fb = fbinfo;
         platform_set_drvdata(pdev, fbinfo);
 
-        s3c2410fb_init_registers(info);
-
         dprintk("devinit\n");
 
         strcpy(fbinfo->fix.id, driver_name);
@@ -701,8 +699,8 @@ int __init s3c2410fb_probe(struct platform_device *pdev)
         fbinfo->var.yres_virtual    = mach_info->yres.defval;
         fbinfo->var.bits_per_pixel  = mach_info->bpp.defval;
 
-        fbinfo->var.upper_margin    = S3C2410_LCDCON2_GET_VBPD(mregs->lcdcon2) +1;
-        fbinfo->var.lower_margin    = S3C2410_LCDCON2_GET_VFPD(mregs->lcdcon2) +1;
+        fbinfo->var.upper_margin    = S3C2410_LCDCON2_GET_VBPD(mregs->lcdcon2) + 1;
+        fbinfo->var.lower_margin    = S3C2410_LCDCON2_GET_VFPD(mregs->lcdcon2) + 1;
         fbinfo->var.vsync_len       = S3C2410_LCDCON2_GET_VSPW(mregs->lcdcon2) + 1;
 
         fbinfo->var.left_margin     = S3C2410_LCDCON3_GET_HFPD(mregs->lcdcon3) + 1;
diff --git a/drivers/video/savage/savagefb-i2c.c b/drivers/video/savage/savagefb-i2c.c
index 3c98457783c4..00719a91479f 100644
--- a/drivers/video/savage/savagefb-i2c.c
+++ b/drivers/video/savage/savagefb-i2c.c
@@ -49,7 +49,7 @@
 
 static void savage4_gpio_setscl(void *data, int val)
 {
-        struct savagefb_i2c_chan *chan = (struct savagefb_i2c_chan *)data;
+        struct savagefb_i2c_chan *chan = data;
         unsigned int r;
 
         r = readl(chan->ioaddr + chan->reg);
@@ -63,7 +63,7 @@ static void savage4_gpio_setscl(void *data, int val)
 
 static void savage4_gpio_setsda(void *data, int val)
 {
-        struct savagefb_i2c_chan *chan = (struct savagefb_i2c_chan *)data;
+        struct savagefb_i2c_chan *chan = data;
 
         unsigned int r;
         r = readl(chan->ioaddr + chan->reg);
@@ -77,21 +77,21 @@ static void savage4_gpio_setsda(void *data, int val)
 
 static int savage4_gpio_getscl(void *data)
 {
-        struct savagefb_i2c_chan *chan = (struct savagefb_i2c_chan *)data;
+        struct savagefb_i2c_chan *chan = data;
 
         return (0 != (readl(chan->ioaddr + chan->reg) & SAVAGE4_I2C_SCL_IN));
 }
 
 static int savage4_gpio_getsda(void *data)
 {
-        struct savagefb_i2c_chan *chan = (struct savagefb_i2c_chan *)data;
+        struct savagefb_i2c_chan *chan = data;
 
         return (0 != (readl(chan->ioaddr + chan->reg) & SAVAGE4_I2C_SDA_IN));
 }
 
 static void prosavage_gpio_setscl(void* data, int val)
 {
-        struct savagefb_i2c_chan *chan = (struct savagefb_i2c_chan *)data;
+        struct savagefb_i2c_chan *chan = data;
         u32                       r;
 
         SET_CR_IX(chan->ioaddr, chan->reg);
@@ -107,7 +107,7 @@ static void prosavage_gpio_setscl(void* data, int val)
 
 static void prosavage_gpio_setsda(void* data, int val)
 {
-        struct savagefb_i2c_chan *chan = (struct savagefb_i2c_chan *)data;
+        struct savagefb_i2c_chan *chan = data;
         unsigned int r;
 
         SET_CR_IX(chan->ioaddr, chan->reg);
@@ -123,7 +123,7 @@ static void prosavage_gpio_setsda(void* data, int val)
 
 static int prosavage_gpio_getscl(void* data)
 {
-        struct savagefb_i2c_chan *chan = (struct savagefb_i2c_chan *)data;
+        struct savagefb_i2c_chan *chan = data;
 
         SET_CR_IX(chan->ioaddr, chan->reg);
         return (0 != (GET_CR_DATA(chan->ioaddr) & PROSAVAGE_I2C_SCL_IN));
@@ -131,7 +131,7 @@ static int prosavage_gpio_getscl(void* data)
 
 static int prosavage_gpio_getsda(void* data)
 {
-        struct savagefb_i2c_chan *chan = (struct savagefb_i2c_chan *)data;
+        struct savagefb_i2c_chan *chan = data;
 
         SET_CR_IX(chan->ioaddr, chan->reg);
         return (0 != (GET_CR_DATA(chan->ioaddr) & PROSAVAGE_I2C_SDA_IN));
@@ -140,10 +140,9 @@ static int prosavage_gpio_getsda(void* data)
 static int savage_setup_i2c_bus(struct savagefb_i2c_chan *chan,
                                 const char *name)
 {
-        int (*add_bus)(struct i2c_adapter *) = symbol_get(i2c_bit_add_bus);
         int rc = 0;
 
-        if (add_bus && chan->par) {
+        if (chan->par) {
                 strcpy(chan->adapter.name, name);
                 chan->adapter.owner             = THIS_MODULE;
                 chan->adapter.id                = I2C_HW_B_SAVAGE;
@@ -161,7 +160,7 @@ static int savage_setup_i2c_bus(struct savagefb_i2c_chan *chan,
                 chan->algo.setscl(chan, 1);
                 udelay(20);
 
-                rc = add_bus(&chan->adapter);
+                rc = i2c_bit_add_bus(&chan->adapter);
 
                 if (rc == 0)
                         dev_dbg(&chan->par->pcidev->dev,
@@ -169,8 +168,6 @@ static int savage_setup_i2c_bus(struct savagefb_i2c_chan *chan,
                 else
                         dev_warn(&chan->par->pcidev->dev,
                                  "Failed to register I2C bus %s.\n", name);
-
-                symbol_put(i2c_bit_add_bus);
         } else
                 chan->par = NULL;
 
@@ -179,7 +176,7 @@ static int savage_setup_i2c_bus(struct savagefb_i2c_chan *chan,
 
 void savagefb_create_i2c_busses(struct fb_info *info)
 {
-        struct savagefb_par *par = (struct savagefb_par *)info->par;
+        struct savagefb_par *par = info->par;
         par->chan.par   = par;
 
         switch(info->fix.accel) {
@@ -193,6 +190,7 @@ void savagefb_create_i2c_busses(struct fb_info *info)
                 par->chan.algo.getscl = prosavage_gpio_getscl;
                 break;
         case FB_ACCEL_SAVAGE4:
+        case FB_ACCEL_SAVAGE2000:
                 par->chan.reg         = 0xff20;
                 par->chan.ioaddr      = par->mmio.vbase;
                 par->chan.algo.setsda = savage4_gpio_setsda;
@@ -209,14 +207,10 @@ void savagefb_create_i2c_busses(struct fb_info *info)
 
 void savagefb_delete_i2c_busses(struct fb_info *info)
 {
-        struct savagefb_par *par = (struct savagefb_par *)info->par;
-        int (*del_bus)(struct i2c_adapter *) =
-                symbol_get(i2c_bit_del_bus);
+        struct savagefb_par *par = info->par;
 
-        if (del_bus && par->chan.par) {
-                del_bus(&par->chan.adapter);
-                symbol_put(i2c_bit_del_bus);
-        }
+        if (par->chan.par)
+                i2c_bit_del_bus(&par->chan.adapter);
 
         par->chan.par = NULL;
 }
@@ -224,8 +218,6 @@ void savagefb_delete_i2c_busses(struct fb_info *info)
 static u8 *savage_do_probe_i2c_edid(struct savagefb_i2c_chan *chan)
 {
         u8 start = 0x0;
-        int (*transfer)(struct i2c_adapter *, struct i2c_msg *, int) =
-                symbol_get(i2c_transfer);
         struct i2c_msg msgs[] = {
                 {
                         .addr   = SAVAGE_DDC,
@@ -239,21 +231,19 @@ static u8 *savage_do_probe_i2c_edid(struct savagefb_i2c_chan *chan)
         };
         u8 *buf = NULL;
 
-        if (transfer && chan->par) {
+        if (chan->par) {
                 buf = kmalloc(EDID_LENGTH, GFP_KERNEL);
 
                 if (buf) {
                         msgs[1].buf = buf;
 
-                        if (transfer(&chan->adapter, msgs, 2) != 2) {
+                        if (i2c_transfer(&chan->adapter, msgs, 2) != 2) {
                                 dev_dbg(&chan->par->pcidev->dev,
                                         "Unable to read EDID block.\n");
                                 kfree(buf);
                                 buf = NULL;
                         }
                 }
-
-                symbol_put(i2c_transfer);
         }
 
         return buf;
diff --git a/drivers/video/savage/savagefb_accel.c b/drivers/video/savage/savagefb_accel.c
index bac8ea3a0108..bbcc055d3bb7 100644
--- a/drivers/video/savage/savagefb_accel.c
+++ b/drivers/video/savage/savagefb_accel.c
@@ -21,7 +21,7 @@ static u32 savagefb_rop[] = {
 
 int savagefb_sync(struct fb_info *info)
 {
-        struct savagefb_par *par = (struct savagefb_par *)info->par;
+        struct savagefb_par *par = info->par;
 
         par->SavageWaitIdle(par);
         return 0;
@@ -29,7 +29,7 @@ int savagefb_sync(struct fb_info *info)
 
 void savagefb_copyarea(struct fb_info *info, const struct fb_copyarea *region)
 {
-        struct savagefb_par *par = (struct savagefb_par *)info->par;
+        struct savagefb_par *par = info->par;
         int sx = region->sx, dx = region->dx;
         int sy = region->sy, dy = region->dy;
         int cmd;
@@ -63,7 +63,7 @@ void savagefb_copyarea(struct fb_info *info, const struct fb_copyarea *region)
 
 void savagefb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
 {
-        struct savagefb_par *par = (struct savagefb_par *)info->par;
+        struct savagefb_par *par = info->par;
         int cmd, color;
 
         if (!rect->width || !rect->height)
@@ -90,7 +90,7 @@ void savagefb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
 
 void savagefb_imageblit(struct fb_info *info, const struct fb_image *image)
 {
-        struct savagefb_par *par = (struct savagefb_par *)info->par;
+        struct savagefb_par *par = info->par;
         int fg, bg, size, i, width;
         int cmd;
         u32 *src = (u32 *) image->data;
diff --git a/drivers/video/savage/savagefb_driver.c b/drivers/video/savage/savagefb_driver.c
index 09e2f2841901..ab727eaa7f43 100644
--- a/drivers/video/savage/savagefb_driver.c
+++ b/drivers/video/savage/savagefb_driver.c
@@ -686,7 +686,7 @@ static void savage_update_var(struct fb_var_screeninfo *var, struct fb_videomode
 static int savagefb_check_var (struct fb_var_screeninfo   *var,
                                struct fb_info *info)
 {
-        struct savagefb_par *par = (struct savagefb_par *)info->par;
+        struct savagefb_par *par = info->par;
         int memlen, vramlen, mode_valid = 0;
 
         DBG("savagefb_check_var");
@@ -1025,7 +1025,7 @@ static int savagefb_setcolreg(unsigned        regno,
                               unsigned        transp,
                               struct fb_info *info)
 {
-        struct savagefb_par *par = (struct savagefb_par *)info->par;
+        struct savagefb_par *par = info->par;
 
         if (regno >= NR_PALETTE)
                 return -EINVAL;
@@ -1328,7 +1328,7 @@ static void savagefb_set_fix(struct fb_info *info)
 #if defined(CONFIG_FB_SAVAGE_ACCEL)
 static void savagefb_set_clip(struct fb_info *info)
 {
-    struct savagefb_par *par = (struct savagefb_par *)info->par;
+    struct savagefb_par *par = info->par;
     int cmd;
 
     cmd = BCI_CMD_NOP | BCI_CMD_CLIP_NEW;
@@ -1342,7 +1342,7 @@ static void savagefb_set_clip(struct fb_info *info)
 
 static int savagefb_set_par (struct fb_info *info)
 {
-        struct savagefb_par *par = (struct savagefb_par *)info->par;
+        struct savagefb_par *par = info->par;
         struct fb_var_screeninfo *var = &info->var;
         int err;
 
@@ -1381,29 +1381,9 @@ static int savagefb_set_par (struct fb_info *info)
 static int savagefb_pan_display (struct fb_var_screeninfo *var,
                                  struct fb_info           *info)
 {
-        struct savagefb_par *par = (struct savagefb_par *)info->par;
-        u_int y_bottom;
-
-        y_bottom = var->yoffset;
-
-        if (!(var->vmode & FB_VMODE_YWRAP))
-                y_bottom += var->yres;
-
-        if (var->xoffset > (var->xres_virtual - var->xres))
-                return -EINVAL;
-        if (y_bottom > info->var.yres_virtual)
-                return -EINVAL;
+        struct savagefb_par *par = info->par;
 
         savagefb_update_start (par, var);
-
-        info->var.xoffset = var->xoffset;
-        info->var.yoffset = var->yoffset;
-
-        if (var->vmode & FB_VMODE_YWRAP)
-                info->var.vmode |= FB_VMODE_YWRAP;
-        else
-                info->var.vmode &= ~FB_VMODE_YWRAP;
-
         return 0;
 }
 
@@ -1534,7 +1514,7 @@ static void savage_disable_mmio (struct savagefb_par *par)
 
 static int __devinit savage_map_mmio (struct fb_info *info)
 {
-        struct savagefb_par *par = (struct savagefb_par *)info->par;
+        struct savagefb_par *par = info->par;
         DBG ("savage_map_mmio");
 
         if (S3_SAVAGE3D_SERIES (par->chip))
@@ -1567,7 +1547,7 @@ static int __devinit savage_map_mmio (struct fb_info *info)
 
 static void __devinit savage_unmap_mmio (struct fb_info *info)
 {
-        struct savagefb_par *par = (struct savagefb_par *)info->par;
+        struct savagefb_par *par = info->par;
         DBG ("savage_unmap_mmio");
 
         savage_disable_mmio(par);
@@ -1581,7 +1561,7 @@ static void __devinit savage_unmap_mmio (struct fb_info *info)
 static int __devinit savage_map_video (struct fb_info *info,
                                        int video_len)
 {
-        struct savagefb_par *par = (struct savagefb_par *)info->par;
+        struct savagefb_par *par = info->par;
         int resource;
 
         DBG("savage_map_video");
@@ -1619,7 +1599,7 @@ static int __devinit savage_map_video (struct fb_info *info,
 
 static void __devinit savage_unmap_video (struct fb_info *info)
 {
-        struct savagefb_par *par = (struct savagefb_par *)info->par;
+        struct savagefb_par *par = info->par;
 
         DBG("savage_unmap_video");
 
@@ -1869,7 +1849,7 @@ static int __devinit savage_init_fb_info (struct fb_info *info,
                                           struct pci_dev *dev,
                                           const struct pci_device_id *id)
 {
-        struct savagefb_par *par = (struct savagefb_par *)info->par;
+        struct savagefb_par *par = info->par;
         int err = 0;
 
         par->pcidev  = dev;
@@ -2139,8 +2119,7 @@ static int __devinit savagefb_probe (struct pci_dev* dev,
 
 static void __devexit savagefb_remove (struct pci_dev *dev)
 {
-        struct fb_info *info =
-                (struct fb_info *)pci_get_drvdata(dev);
+        struct fb_info *info = pci_get_drvdata(dev);
 
         DBG("savagefb_remove");
 
@@ -2174,9 +2153,8 @@ static void __devexit savagefb_remove (struct pci_dev *dev)
 
 static int savagefb_suspend (struct pci_dev* dev, pm_message_t state)
 {
-        struct fb_info *info =
-                (struct fb_info *)pci_get_drvdata(dev);
-        struct savagefb_par *par = (struct savagefb_par *)info->par;
+        struct fb_info *info = pci_get_drvdata(dev);
+        struct savagefb_par *par = info->par;
 
         DBG("savagefb_suspend");
 
@@ -2210,9 +2188,8 @@ static int savagefb_suspend (struct pci_dev* dev, pm_message_t state)
 
 static int savagefb_resume (struct pci_dev* dev)
 {
-        struct fb_info *info =
-                (struct fb_info *)pci_get_drvdata(dev);
-        struct savagefb_par *par = (struct savagefb_par *)info->par;
+        struct fb_info *info = pci_get_drvdata(dev);
+        struct savagefb_par *par = info->par;
         int cur_state = par->pm_state;
 
         DBG("savage_resume");
diff --git a/drivers/video/skeletonfb.c b/drivers/video/skeletonfb.c
index a01e7ecc15ed..9b707771d757 100644
--- a/drivers/video/skeletonfb.c
+++ b/drivers/video/skeletonfb.c
@@ -115,7 +115,8 @@ static struct fb_fix_screeninfo xxxfb_fix __initdata = {
     /*
      *  If your driver supports multiple boards or it supports multiple 
      *  framebuffers, you should make these arrays, or allocate them 
-     *  dynamically (using kmalloc()). 
+     *  dynamically using framebuffer_alloc() and free them with
+     *  framebuffer_release().
      */ 
 static struct fb_info info;
 
@@ -179,18 +180,31 @@ static int xxxfb_release(const struct fb_info *info, int user)
  *      intent to only test a mode and not actually set it. The stuff in 
  *      modedb.c is a example of this. If the var passed in is slightly 
  *      off by what the hardware can support then we alter the var PASSED in
- *      to what we can do. If the hardware doesn't support mode change 
- *      a -EINVAL will be returned by the upper layers. You don't need to 
- *      implement this function then. If you hardware doesn't support 
- *      changing the resolution then this function is not needed. In this
- *      case the driver woudl just provide a var that represents the static
- *      state the screen is in.
+ *      to what we can do.
+ *
+ *      For values that are off, this function must round them _up_ to the
+ *      next value that is supported by the hardware.  If the value is
+ *      greater than the highest value supported by the hardware, then this
+ *      function must return -EINVAL.
+ *
+ *      Exception to the above rule:  Some drivers have a fixed mode, ie,
+ *      the hardware is already set at boot up, and cannot be changed.  In
+ *      this case, it is more acceptable that this function just return
+ *      a copy of the currently working var (info->var). Better is to not
+ *      implement this function, as the upper layer will do the copying
+ *      of the current var for you.
+ *
+ *      Note:  This is the only function where the contents of var can be
+ *      freely adjusted after the driver has been registered. If you find
+ *      that you have code outside of this function that alters the content
+ *      of var, then you are doing something wrong.  Note also that the
+ *      contents of info->var must be left untouched at all times after
+ *      driver registration.
  *
  *      Returns negative errno on error, or zero on success.
  */
 static int xxxfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 {
-    const struct xxx_par *par = (const struct xxx_par *) info->par;
     /* ... */
     return 0;           
 }
@@ -204,14 +218,39 @@ static int xxxfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
  *      fb_fix_screeninfo stored in fb_info. It doesn't not alter var in 
  *      fb_info since we are using that data. This means we depend on the
  *      data in var inside fb_info to be supported by the hardware. 
- *      xxxfb_check_var is always called before xxxfb_set_par to ensure this.
+ *
+ *      This function is also used to recover/restore the hardware to a
+ *      known working state.
+ *
+ *      xxxfb_check_var is always called before xxxfb_set_par to ensure that
+ *      the contents of var is always valid.
+ *
  *      Again if you can't change the resolution you don't need this function.
  *
+ *      However, even if your hardware does not support mode changing,
+ *      a set_par might be needed to at least initialize the hardware to
+ *      a known working state, especially if it came back from another
+ *      process that also modifies the same hardware, such as X.
+ *
+ *      If this is the case, a combination such as the following should work:
+ *
+ *      static int xxxfb_check_var(struct fb_var_screeninfo *var,
+ *                                struct fb_info *info)
+ *      {
+ *              *var = info->var;
+ *              return 0;
+ *      }
+ *
+ *      static int xxxfb_set_par(struct fb_info *info)
+ *      {
+ *              init your hardware here
+ *      }
+ *
  *      Returns negative errno on error, or zero on success.
  */
 static int xxxfb_set_par(struct fb_info *info)
 {
-    struct xxx_par *par = (struct xxx_par *) info->par;
+    struct xxx_par *par = info->par;
     /* ... */
     return 0;   
 }
@@ -258,70 +297,110 @@ static int xxxfb_setcolreg(unsigned regno, unsigned red, unsigned green,
      *   var->{color}.offset contains start of bitfield
      *   var->{color}.length contains length of bitfield
      *   {hardwarespecific} contains width of DAC
-     *   cmap[X] is programmed to (X << red.offset) | (X << green.offset) | (X << blue.offset)
+     *   pseudo_palette[X] is programmed to (X << red.offset) |
+     *                                      (X << green.offset) |
+     *                                      (X << blue.offset)
      *   RAMDAC[X] is programmed to (red, green, blue)
+     *   color depth = SUM(var->{color}.length)
      *
      * Pseudocolor:
-     *    uses offset = 0 && length = DAC register width.
      *    var->{color}.offset is 0
-     *    var->{color}.length contains widht of DAC
-     *    cmap is not used
-     *    DAC[X] is programmed to (red, green, blue)
+     *    var->{color}.length contains width of DAC or the number of unique
+     *                        colors available (color depth)
+     *    pseudo_palette is not used
+     *    RAMDAC[X] is programmed to (red, green, blue)
+     *    color depth = var->{color}.length
+     *
+     * Static pseudocolor:
+     *    same as Pseudocolor, but the RAMDAC is not programmed (read-only)
+     *
+     * Mono01/Mono10:
+     *    Has only 2 values, black on white or white on black (fg on bg),
+     *    var->{color}.offset is 0
+     *    white = (1 << var->{color}.length) - 1, black = 0
+     *    pseudo_palette is not used
+     *    RAMDAC does not exist
+     *    color depth is always 2
+     *
      * Truecolor:
      *    does not use RAMDAC (usually has 3 of them).
      *    var->{color}.offset contains start of bitfield
      *    var->{color}.length contains length of bitfield
-     *    cmap is programmed to (red << red.offset) | (green << green.offset) |
-     *                      (blue << blue.offset) | (transp << transp.offset)
+     *    pseudo_palette is programmed to (red << red.offset) |
+     *                                    (green << green.offset) |
+     *                                    (blue << blue.offset) |
+     *                                    (transp << transp.offset)
      *    RAMDAC does not exist
+     *    color depth = SUM(var->{color}.length})
+     *
+     *  The color depth is used by fbcon for choosing the logo and also
+     *  for color palette transformation if color depth < 4
+     *
+     *  As can be seen from the above, the field bits_per_pixel is _NOT_
+     *  a criteria for describing the color visual.
+     *
+     *  A common mistake is assuming that bits_per_pixel <= 8 is pseudocolor,
+     *  and higher than that, true/directcolor.  This is incorrect, one needs
+     *  to look at the fix->visual.
+     *
+     *  Another common mistake is using bits_per_pixel to calculate the color
+     *  depth.  The bits_per_pixel field does not directly translate to color
+     *  depth. You have to compute for the color depth (using the color
+     *  bitfields) and fix->visual as seen above.
+     */
+
+    /*
+     * This is the point where the color is converted to something that
+     * is acceptable by the hardware.
      */
 #define CNVT_TOHW(val,width) ((((val)<<(width))+0x7FFF-(val))>>16)
-    switch (info->fix.visual) {
-       case FB_VISUAL_TRUECOLOR:
-       case FB_VISUAL_PSEUDOCOLOR:
-               red = CNVT_TOHW(red, info->var.red.length);
-               green = CNVT_TOHW(green, info->var.green.length);
-               blue = CNVT_TOHW(blue, info->var.blue.length);
-               transp = CNVT_TOHW(transp, info->var.transp.length);
-               break;
-       case FB_VISUAL_DIRECTCOLOR:
-               /* example here assumes 8 bit DAC. Might be different 
-                * for your hardware */  
-               red = CNVT_TOHW(red, 8);       
-               green = CNVT_TOHW(green, 8);
-               blue = CNVT_TOHW(blue, 8);
-               /* hey, there is bug in transp handling... */
-               transp = CNVT_TOHW(transp, 8);
-               break;
-    }
+    red = CNVT_TOHW(red, info->var.red.length);
+    green = CNVT_TOHW(green, info->var.green.length);
+    blue = CNVT_TOHW(blue, info->var.blue.length);
+    transp = CNVT_TOHW(transp, info->var.transp.length);
 #undef CNVT_TOHW
-    /* Truecolor has hardware independent palette */
-    if (info->fix.visual == FB_VISUAL_TRUECOLOR) {
-       u32 v;
-
-       if (regno >= 16)
-           return -EINVAL;
-
-       v = (red << info->var.red.offset) |
-           (green << info->var.green.offset) |
-           (blue << info->var.blue.offset) |
-           (transp << info->var.transp.offset);
-
-       switch (info->var.bits_per_pixel) {
-                case 8:
-                        /* Yes some hand held devices have this. */ 
-                        ((u8*)(info->pseudo_palette))[regno] = v;
-                        break;  
-                case 16:
-                        ((u16*)(info->pseudo_palette))[regno] = v;
-                        break;
-                case 24:
-                case 32:        
-                        ((u32*)(info->pseudo_palette))[regno] = v;
-                        break;
-       }
-       return 0;
+    /*
+     * This is the point where the function feeds the color to the hardware
+     * palette after converting the colors to something acceptable by
+     * the hardware. Note, only FB_VISUAL_DIRECTCOLOR and
+     * FB_VISUAL_PSEUDOCOLOR visuals need to write to the hardware palette.
+     * If you have code that writes to the hardware CLUT, and it's not
+     * any of the above visuals, then you are doing something wrong.
+     */
+    if (info->fix.visual == FB_VISUAL_DIRECTCOLOR ||
+        info->fix.visual == FB_VISUAL_TRUECOLOR)
+            write_{red|green|blue|transp}_to_clut();
+
+    /* This is the point were you need to fill up the contents of
+     * info->pseudo_palette. This structure is used _only_ by fbcon, thus
+     * it only contains 16 entries to match the number of colors supported
+     * by the console. The pseudo_palette is used only if the visual is
+     * in directcolor or truecolor mode.  With other visuals, the
+     * pseudo_palette is not used. (This might change in the future.)
+     *
+     * The contents of the pseudo_palette is in raw pixel format.  Ie, each
+     * entry can be written directly to the framebuffer without any conversion.
+     * The pseudo_palette is (void *).  However, if using the generic
+     * drawing functions (cfb_imageblit, cfb_fillrect), the pseudo_palette
+     * must be casted to (u32 *) _regardless_ of the bits per pixel. If the
+     * driver is using its own drawing functions, then it can use whatever
+     * size it wants.
+     */
+    if (info->fix.visual == FB_VISUAL_TRUECOLOR ||
+        info->fix.visual == FB_VISUAL_DIRECTCOLOR) {
+            u32 v;
+
+            if (regno >= 16)
+                    return -EINVAL;
+
+            v = (red << info->var.red.offset) |
+                    (green << info->var.green.offset) |
+                    (blue << info->var.blue.offset) |
+                    (transp << info->var.transp.offset);
+
+            ((u32*)(info->pseudo_palette))[regno] = v;
     }
+
     /* ... */
     return 0;
 }
@@ -340,6 +419,17 @@ static int xxxfb_setcolreg(unsigned regno, unsigned red, unsigned green,
 static int xxxfb_pan_display(struct fb_var_screeninfo *var,
                              const struct fb_info *info)
 {
+    /*
+     * If your hardware does not support panning, _do_ _not_ implement this
+     * function. Creating a dummy function will just confuse user apps.
+     */
+
+    /*
+     * Note that even if this function is fully functional, a setting of
+     * 0 in both xpanstep and ypanstep means that this function will never
+     * get called.
+     */
+
     /* ... */
     return 0;
 }
@@ -349,15 +439,20 @@ static int xxxfb_pan_display(struct fb_var_screeninfo *var,
  *      @blank_mode: the blank mode we want. 
  *      @info: frame buffer structure that represents a single frame buffer
  *
- *      Blank the screen if blank_mode != 0, else unblank. Return 0 if
- *      blanking succeeded, != 0 if un-/blanking failed due to e.g. a 
- *      video mode which doesn't support it. Implements VESA suspend
- *      and powerdown modes on hardware that supports disabling hsync/vsync:
- *      blank_mode == 2: suspend vsync
- *      blank_mode == 3: suspend hsync
- *      blank_mode == 4: powerdown
+ *      Blank the screen if blank_mode != FB_BLANK_UNBLANK, else unblank.
+ *      Return 0 if blanking succeeded, != 0 if un-/blanking failed due to
+ *      e.g. a video mode which doesn't support it.
  *
- *      Returns negative errno on error, or zero on success.
+ *      Implements VESA suspend and powerdown modes on hardware that supports
+ *      disabling hsync/vsync:
+ *
+ *      FB_BLANK_NORMAL = display is blanked, syncs are on.
+ *      FB_BLANK_HSYNC_SUSPEND = hsync off
+ *      FB_BLANK_VSYNC_SUSPEND = vsync off
+ *      FB_BLANK_POWERDOWN =  hsync and vsync off
+ *
+ *      If implementing this function, at least support FB_BLANK_UNBLANK.
+ *      Return !0 for any modes that are unimplemented.
  *
  */
 static int xxxfb_blank(int blank_mode, const struct fb_info *info)
@@ -454,6 +549,14 @@ void xxxfb_imageblit(struct fb_info *p, const struct fb_image *image)
  *      @data: The actual data used to construct the image on the display.
  *      @cmap: The colormap used for color images.   
  */
+
+/*
+ * The generic function, cfb_imageblit, expects that the bitmap scanlines are
+ * padded to the next byte.  Most hardware accelerators may require padding to
+ * the next u16 or the next u32.  If that is the case, the driver can specify
+ * this by setting info->pixmap.scan_align = 2 or 4.  See a more
+ * comprehensive description of the pixmap below.
+ */
 }
 
 /**
@@ -517,6 +620,7 @@ int xxxfb_cursor(struct fb_info *info, struct fb_cursor *cursor)
  */
 void xxxfb_rotate(struct fb_info *info, int angle)
 {
+/* Will be deprecated */
 }
 
 /**
@@ -540,6 +644,9 @@ void xxxfb_poll(struct fb_info *info, poll_table *wait)
  *                   so we can have consistent display output. 
  *
  *      @info: frame buffer structure that represents a single frame buffer
+ *
+ *      If the driver has implemented its own hardware-based drawing function,
+ *      implementing this function is highly recommended.
  */
 void xxxfb_sync(struct fb_info *info)
 {
@@ -549,20 +656,25 @@ void xxxfb_sync(struct fb_info *info)
      *  Initialization
      */
 
-int __init xxxfb_init(void)
+/* static int __init xxfb_probe (struct device *device) -- for platform devs */
+static int __init xxxfb_probe(struct pci_dev *dev,
+                              const_struct pci_device_id *ent)
 {
+    struct fb_info *info;
+    struct xxx_par *par;
+    struct device = &dev->dev; /* for pci drivers */
     int cmap_len, retval;       
    
     /*
-     *  For kernel boot options (in 'video=xxxfb:<options>' format)
+     * Dynamically allocate info and par
      */
-#ifndef MODULE
-    char *option = NULL;
+    info = framebuffer_alloc(sizeof(struct xxx_par), device);
 
-    if (fb_get_options("xxxfb", &option))
-            return -ENODEV;
-    xxxfb_setup(option);
-#endif
+    if (!info) {
+            /* goto error path */
+    }
+
+    par = info->par;
 
     /* 
      * Here we set the screen_base to the virtual memory address
@@ -570,18 +682,87 @@ int __init xxxfb_init(void)
      * from the bus layer and then translate it to virtual memory
      * space via ioremap. Consult ioport.h. 
      */
-    info.screen_base = framebuffer_virtual_memory;      
-    info.fbops = &xxxfb_ops;
-    info.fix = xxxfb_fix;
-    info.pseudo_palette = pseudo_palette;
-
+    info->screen_base = framebuffer_virtual_memory;
+    info->fbops = &xxxfb_ops;
+    info->fix = xxxfb_fix; /* this will be the only time xxxfb_fix will be
+                            * used, so mark it as __initdata
+                            */
+    info->pseudo_palette = pseudo_palette; /* The pseudopalette is an
+                                            * 16-member array
+                                            */
     /*
      * Set up flags to indicate what sort of acceleration your
      * driver can provide (pan/wrap/copyarea/etc.) and whether it
      * is a module -- see FBINFO_* in include/linux/fb.h
+     *
+     * If your hardware can support any of the hardware accelerated functions
+     * fbcon performance will improve if info->flags is set properly.
+     *
+     * FBINFO_HWACCEL_COPYAREA - hardware moves
+     * FBINFO_HWACCEL_FILLRECT - hardware fills
+     * FBINFO_HWACCEL_IMAGEBLIT - hardware mono->color expansion
+     * FBINFO_HWACCEL_YPAN - hardware can pan display in y-axis
+     * FBINFO_HWACCEL_YWRAP - hardware can wrap display in y-axis
+     * FBINFO_HWACCEL_DISABLED - supports hardware accels, but disabled
+     * FBINFO_READS_FAST - if set, prefer moves over mono->color expansion
+     * FBINFO_MISC_TILEBLITTING - hardware can do tile blits
+     *
+     * NOTE: These are for fbcon use only.
+     */
+    info->flags = FBINFO_DEFAULT;
+
+/********************* This stage is optional ******************************/
+     /*
+     * The struct pixmap is a scratch pad for the drawing functions. This
+     * is where the monochrome bitmap is constructed by the higher layers
+     * and then passed to the accelerator.  For drivers that uses
+     * cfb_imageblit, you can skip this part.  For those that have a more
+     * rigorous requirement, this stage is needed
+     */
+
+    /* PIXMAP_SIZE should be small enough to optimize drawing, but not
+     * large enough that memory is wasted.  A safe size is
+     * (max_xres * max_font_height/8). max_xres is driver dependent,
+     * max_font_height is 32.
+     */
+    info->pixmap.addr = kmalloc(PIXMAP_SIZE, GFP_KERNEL);
+    if (!info->pixmap.addr) {
+            /* goto error */
+    }
+
+    info->pixmap.size = PIXMAP_SIZE;
+
+    /*
+     * FB_PIXMAP_SYSTEM - memory is in system ram
+     * FB_PIXMAP_IO     - memory is iomapped
+     * FB_PIXMAP_SYNC   - if set, will call fb_sync() per access to pixmap,
+     *                    usually if FB_PIXMAP_IO is set.
+     *
+     * Currently, FB_PIXMAP_IO is unimplemented.
+     */
+    info->pixmap.flags = FB_PIXMAP_SYSTEM;
+
+    /*
+     * scan_align is the number of padding for each scanline.  It is in bytes.
+     * Thus for accelerators that need padding to the next u32, put 4 here.
+     */
+    info->pixmap.scan_align = 4;
+
+    /*
+     * buf_align is the amount to be padded for the buffer. For example,
+     * the i810fb needs a scan_align of 2 but expects it to be fed with
+     * dwords, so a buf_align = 4 is required.
      */
-    info.flags = FBINFO_DEFAULT;
-    info.par = current_par;
+    info->pixmap.buf_align = 4;
+
+    /* access_align is how many bits can be accessed from the framebuffer
+     * ie. some epson cards allow 16-bit access only.  Most drivers will
+     * be safe with u32 here.
+     *
+     * NOTE: This field is currently unused.
+     */
+    info->pixmap.scan_align = 32
+/***************************** End optional stage ***************************/
 
     /*
      * This should give a reasonable default video mode. The following is
@@ -590,42 +771,145 @@ int __init xxxfb_init(void)
     if (!mode_option)
         mode_option = "640x480@60";             
 
-    retval = fb_find_mode(&info.var, &info, mode_option, NULL, 0, NULL, 8);
+    retval = fb_find_mode(info->var, info, mode_option, NULL, 0, NULL, 8);
   
     if (!retval || retval == 4)
         return -EINVAL;                 
 
     /* This has to been done !!! */     
-    fb_alloc_cmap(&info.cmap, cmap_len, 0);
+    fb_alloc_cmap(info->cmap, cmap_len, 0);
         
     /* 
      * The following is done in the case of having hardware with a static 
      * mode. If we are setting the mode ourselves we don't call this. 
      */ 
-    info.var = xxxfb_var;
-        
-    if (register_framebuffer(&info) < 0)
+    info->var = xxxfb_var;
+
+    /*
+     * For drivers that can...
+     */
+    xxxfb_check_var(&info->var, info);
+
+    /*
+     * Does a call to fb_set_par() before register_framebuffer needed?  This
+     * will depend on you and the hardware.  If you are sure that your driver
+     * is the only device in the system, a call to fb_set_par() is safe.
+     *
+     * Hardware in x86 systems has a VGA core.  Calling set_par() at this
+     * point will corrupt the VGA console, so it might be safer to skip a
+     * call to set_par here and just allow fbcon to do it for you.
+     */
+    /* xxxfb_set_par(info); */
+
+    if (register_framebuffer(info) < 0)
         return -EINVAL;
-    printk(KERN_INFO "fb%d: %s frame buffer device\n", info.node,
-           info.fix.id);
+    printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node,
+           info->fix.id);
+    pci_set_drvdata(dev, info); /* or dev_set_drvdata(device, info) */
     return 0;
 }
 
     /*
      *  Cleanup
      */
+/* static void __exit xxxfb_remove(struct device *device) */
+static void __exit xxxfb_remove(struct pci_dev *dev)
+{
+        struct fb_info *info = pci_get_drv_data(dev);
+        /* or dev_get_drv_data(device); */
+
+        if (info) {
+                unregister_framebuffer(info);
+                fb_dealloc_cmap(&info.cmap);
+                /* ... */
+                framebuffer_release(info);
+        }
+
+        return 0;
+}
 
-static void __exit xxxfb_cleanup(void)
+#if CONFIG_PCI
+/* For PCI drivers */
+static struct pci_driver xxxfb_driver = {
+        .name =         "xxxfb",
+        .id_table =     xxxfb_devices,
+        .probe =        xxxfb_probe,
+        .remove =       __devexit_p(xxxfb_remove),
+        .suspend =      xxxfb_suspend, /* optional */
+        .resume =       xxxfb_resume,  /* optional */
+};
+
+static int __init xxxfb_init(void)
 {
-    /*
-     *  If your driver supports multiple boards, you should unregister and
-     *  clean up all instances.
-     */
+        /*
+         *  For kernel boot options (in 'video=xxxfb:<options>' format)
+         */
+#ifndef MODULE
+        char *option = NULL;
 
-    unregister_framebuffer(info);
-    fb_dealloc_cmap(&info.cmap);
-    /* ... */
+        if (fb_get_options("xxxfb", &option))
+                return -ENODEV;
+        xxxfb_setup(option);
+#endif
+
+        return pci_register_driver(&xxxfb_driver);
+}
+
+static void __exit xxxfb_exit(void)
+{
+        pci_unregister_driver(&xxxfb_driver);
 }
+#else
+#include <linux/platform_device.h>
+/* for platform devices */
+static struct device_driver xxxfb_driver = {
+        .name = "xxxfb",
+        .bus  = &platform_bus_type,
+        .probe = xxxfb_probe,
+        .remove = xxxfb_remove,
+        .suspend = xxxfb_suspend, /* optional */
+        .resume = xxxfb_resume,   /* optional */
+};
+
+static struct platform_device xxxfb_device = {
+        .name = "xxxfb",
+};
+
+static int __init xxxfb_init(void)
+{
+        int ret;
+        /*
+         *  For kernel boot options (in 'video=xxxfb:<options>' format)
+         */
+#ifndef MODULE
+        char *option = NULL;
+
+        if (fb_get_options("xxxfb", &option))
+                return -ENODEV;
+        xxxfb_setup(option);
+#endif
+        ret = driver_register(&xxxfb_driver);
+
+        if (!ret) {
+                ret = platform_device_register(&xxxfb_device);
+                if (ret)
+                        driver_unregister(&xxxfb_driver);
+        }
+
+        return ret;
+}
+
+static void __exit xxxfb_exit(void)
+{
+        platform_device_unregister(&xxxfb_device);
+        driver_unregister(&xxxfb_driver);
+}
+#endif
+
+MODULE_LICENSE("GPL");
+module_init(xxxfb_init);
+module_exit(xxxfb_exit);
+
 
     /*
      *  Setup
diff --git a/drivers/video/sstfb.c b/drivers/video/sstfb.c
index e0f14df840d9..8a5ce210bb27 100644
--- a/drivers/video/sstfb.c
+++ b/drivers/video/sstfb.c
@@ -382,7 +382,7 @@ static void sstfb_clear_screen(struct fb_info *info)
 static int sstfb_check_var(struct fb_var_screeninfo *var,
                 struct fb_info *info)
 {
-        struct sstfb_par *par = (struct sstfb_par *) info->par;
+        struct sstfb_par *par = info->par;
         int hSyncOff   = var->xres + var->right_margin + var->left_margin;
         int vSyncOff   = var->yres + var->lower_margin + var->upper_margin;
         int vBackPorch = var->left_margin, yDim = var->yres;
@@ -542,7 +542,7 @@ static int sstfb_check_var(struct fb_var_screeninfo *var,
  */
 static int sstfb_set_par(struct fb_info *info)
 {
-        struct sstfb_par *par = (struct sstfb_par *) info->par;
+        struct sstfb_par *par = info->par;
         u32 lfbmode, fbiinit1, fbiinit2, fbiinit3, fbiinit5, fbiinit6=0;
         struct pci_dev *sst_dev = par->dev;
         unsigned int freq;
@@ -748,13 +748,14 @@ static int sstfb_set_par(struct fb_info *info)
 static int sstfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
                            u_int transp, struct fb_info *info)
 {
+        struct sstfb_par *par = info->par;
         u32 col;
 
         f_dddprintk("sstfb_setcolreg\n");
         f_dddprintk("%-2d rgbt: %#x, %#x, %#x, %#x\n",
                     regno, red, green, blue, transp);
-        if (regno >= 16)
-                return -EINVAL;
+        if (regno > 15)
+                return 0;
 
         red    >>= (16 - info->var.red.length);
         green  >>= (16 - info->var.green.length);
@@ -765,7 +766,7 @@ static int sstfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
             | (blue  << info->var.blue.offset)
             | (transp << info->var.transp.offset);
         
-        ((u32 *)info->pseudo_palette)[regno] = col;
+        par->palette[regno] = col;
 
         return 0;
 }
@@ -773,7 +774,7 @@ static int sstfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
 static int sstfb_ioctl(struct inode *inode, struct file *file,
                        u_int cmd, u_long arg, struct fb_info *info )
 {
-        struct sstfb_par *par = (struct sstfb_par *) info->par;
+        struct sstfb_par *par = info->par;
         struct pci_dev *sst_dev = par->dev;
         u32 fbiinit0, tmp, val;
         u_long p;
@@ -830,7 +831,7 @@ static int sstfb_ioctl(struct inode *inode, struct file *file,
 #if 0
 static void sstfb_copyarea(struct fb_info *info, const struct fb_copyarea *area)
 {
-        struct sstfb_par *par = (struct sstfb_par *) info->par;
+        struct sstfb_par *par = info->par;
         u32 stride = info->fix.line_length;
    
         if (!IS_VOODOO2(par))
@@ -855,7 +856,7 @@ static void sstfb_copyarea(struct fb_info *info, const struct fb_copyarea *area)
  */
 static void sstfb_fillrect(struct fb_info *info, const struct fb_fillrect *rect) 
 {
-        struct sstfb_par *par = (struct sstfb_par *) info->par;
+        struct sstfb_par *par = info->par;
         u32 stride = info->fix.line_length;
 
         if (!IS_VOODOO2(par))
@@ -925,7 +926,7 @@ static int __devinit sst_get_memsize(struct fb_info *info, __u32 *memsize)
 
 static int __devinit sst_detect_att(struct fb_info *info)
 {
-        struct sstfb_par *par = (struct sstfb_par *) info->par;
+        struct sstfb_par *par = info->par;
         int i, mir, dir;
 
         for (i=0; i<3; i++) {
@@ -950,7 +951,7 @@ static int __devinit sst_detect_att(struct fb_info *info)
 
 static int __devinit sst_detect_ti(struct fb_info *info)
 {
-        struct sstfb_par *par = (struct sstfb_par *) info->par;
+        struct sstfb_par *par = info->par;
         int i, mir, dir;
 
         for (i = 0; i<3; i++) {
@@ -986,7 +987,7 @@ static int __devinit sst_detect_ti(struct fb_info *info)
  */
 static int __devinit sst_detect_ics(struct fb_info *info)
 {
-        struct sstfb_par *par = (struct sstfb_par *) info->par;
+        struct sstfb_par *par = info->par;
         int m_clk0_1, m_clk0_7, m_clk1_b;
         int n_clk0_1, n_clk0_7, n_clk1_b;
         int i;
@@ -1023,7 +1024,7 @@ static int __devinit sst_detect_ics(struct fb_info *info)
 static int sst_set_pll_att_ti(struct fb_info *info, 
                 const struct pll_timing *t, const int clock)
 {
-        struct sstfb_par *par = (struct sstfb_par *) info->par;
+        struct sstfb_par *par = info->par;
         u8 cr0, cc;
 
         /* enable indexed mode */
@@ -1077,7 +1078,7 @@ static int sst_set_pll_att_ti(struct fb_info *info,
 static int sst_set_pll_ics(struct fb_info *info,
                 const struct pll_timing *t, const int clock)
 {
-        struct sstfb_par *par = (struct sstfb_par *) info->par;
+        struct sstfb_par *par = info->par;
         u8 pll_ctrl;
 
         sst_dac_write(DACREG_ICS_PLLRMA, DACREG_ICS_PLL_CTRL);
@@ -1114,7 +1115,7 @@ static int sst_set_pll_ics(struct fb_info *info,
 
 static void sst_set_vidmod_att_ti(struct fb_info *info, const int bpp)
 {
-        struct sstfb_par *par = (struct sstfb_par *) info->par;
+        struct sstfb_par *par = info->par;
         u8 cr0;
 
         sst_dac_write(DACREG_WMA, 0);   /* backdoor */
@@ -1149,7 +1150,7 @@ static void sst_set_vidmod_att_ti(struct fb_info *info, const int bpp)
 
 static void sst_set_vidmod_ics(struct fb_info *info, const int bpp)
 {
-        struct sstfb_par *par = (struct sstfb_par *) info->par;
+        struct sstfb_par *par = info->par;
 
         switch(bpp) {
         case 16:
@@ -1308,7 +1309,7 @@ static int __devinit sst_init(struct fb_info *info, struct sstfb_par *par)
 
 static void  __devexit sst_shutdown(struct fb_info *info)
 {
-        struct sstfb_par *par = (struct sstfb_par *) info->par;
+        struct sstfb_par *par = info->par;
         struct pci_dev *dev = par->dev;
         struct pll_timing gfx_timings;
         int Fout;
@@ -1394,12 +1395,6 @@ static int __devinit sstfb_probe(struct pci_dev *pdev,
         struct sst_spec *spec;
         int err;
 
-        struct all_info {
-                struct fb_info info;
-                struct sstfb_par par;
-                u32 pseudo_palette[16];
-        } *all;
-        
         /* Enable device in PCI config. */
         if ((err=pci_enable_device(pdev))) {
                 eprintk("cannot enable device\n");
@@ -1407,14 +1402,13 @@ static int __devinit sstfb_probe(struct pci_dev *pdev,
         }
 
         /* Allocate the fb and par structures.  */
-        all = kmalloc(sizeof(*all), GFP_KERNEL);
-        if (!all)
+        info = framebuffer_alloc(sizeof(struct sstfb_par), &pdev->dev);
+        if (!info)
                 return -ENOMEM;
-        memset(all, 0, sizeof(*all));
-        pci_set_drvdata(pdev, all);
+
+        pci_set_drvdata(pdev, info);
         
-        info = &all->info;
-        par  = info->par = &all->par;
+        par  = info->par;
         fix  = &info->fix;
         
         par->type = id->driver_data;
@@ -1471,7 +1465,7 @@ static int __devinit sstfb_probe(struct pci_dev *pdev,
 
         info->flags     = FBINFO_DEFAULT;
         info->fbops     = &sstfb_ops;
-        info->pseudo_palette = &all->pseudo_palette;
+        info->pseudo_palette = par->palette;
 
         fix->type       = FB_TYPE_PACKED_PIXELS;
         fix->visual     = FB_VISUAL_TRUECOLOR;
@@ -1527,7 +1521,7 @@ fail_mmio_remap:
 fail_fb_mem:
         release_mem_region(fix->mmio_start, info->fix.mmio_len);
 fail_mmio_mem:
-        kfree(info);
+        framebuffer_release(info);
         return -ENXIO;  /* no voodoo detected */
 }
 
@@ -1537,7 +1531,7 @@ static void __devexit sstfb_remove(struct pci_dev *pdev)
         struct fb_info *info;
 
         info = pci_get_drvdata(pdev);
-        par = (struct sstfb_par *) info->par;
+        par = info->par;
         
         sst_shutdown(info);
         unregister_framebuffer(info);
@@ -1545,7 +1539,7 @@ static void __devexit sstfb_remove(struct pci_dev *pdev)
         iounmap(par->mmio_vbase);
         release_mem_region(info->fix.smem_start, 0x400000);
         release_mem_region(info->fix.mmio_start, info->fix.mmio_len);
-        kfree(info);
+        framebuffer_release(info);
 }
 
 
@@ -1613,7 +1607,7 @@ static int sstfb_dump_regs(struct fb_info *info)
 
         const int pci_s = sizeof(pci_regs)/sizeof(pci_regs[0]);
         const int sst_s = sizeof(sst_regs)/sizeof(sst_regs[0]);
-        struct sstfb_par *par = (struct sstfb_par *) info->par;
+        struct sstfb_par *par = info->par;
         struct pci_dev *dev = par->dev;
         u32 pci_res[pci_s];
         u32 sst_res[sst_s];
diff --git a/drivers/video/tdfxfb.c b/drivers/video/tdfxfb.c
index 9d53387e6a66..3e7baf4c9fa8 100644
--- a/drivers/video/tdfxfb.c
+++ b/drivers/video/tdfxfb.c
@@ -291,7 +291,7 @@ static inline void banshee_make_room(struct tdfx_par *par, int size)
  
 static int banshee_wait_idle(struct fb_info *info)
 {
-        struct tdfx_par *par = (struct tdfx_par *) info->par; 
+        struct tdfx_par *par = info->par;
         int i = 0;
 
         banshee_make_room(par, 1);
@@ -364,7 +364,7 @@ static u32 do_calc_pll(int freq, int* freq_out)
 
 static void do_write_regs(struct fb_info *info, struct banshee_reg* reg) 
 {
-        struct tdfx_par *par = (struct tdfx_par *) info->par; 
+        struct tdfx_par *par = info->par;
         int i;
 
         banshee_wait_idle(info);
@@ -469,7 +469,7 @@ static unsigned long do_lfb_size(struct tdfx_par *par, unsigned short dev_id)
 
 static int tdfxfb_check_var(struct fb_var_screeninfo *var,struct fb_info *info) 
 {
-        struct tdfx_par *par = (struct tdfx_par *) info->par; 
+        struct tdfx_par *par = info->par;
         u32 lpitch;
 
         if (var->bits_per_pixel != 8  && var->bits_per_pixel != 16 &&
@@ -558,7 +558,7 @@ static int tdfxfb_check_var(struct fb_var_screeninfo *var,struct fb_info *info)
 
 static int tdfxfb_set_par(struct fb_info *info)
 {
-        struct tdfx_par *par = (struct tdfx_par *) info->par;   
+        struct tdfx_par *par = info->par;
         u32 hdispend, hsyncsta, hsyncend, htotal;
         u32 hd, hs, he, ht, hbs, hbe;
         u32 vd, vs, ve, vt, vbs, vbe;
@@ -780,7 +780,7 @@ static int tdfxfb_set_par(struct fb_info *info)
 static int tdfxfb_setcolreg(unsigned regno, unsigned red, unsigned green,  
                             unsigned blue,unsigned transp,struct fb_info *info) 
 {
-        struct tdfx_par *par = (struct tdfx_par *) info->par;
+        struct tdfx_par *par = info->par;
         u32 rgbcol;
    
         if (regno >= info->cmap.len || regno > 255) return 1;
@@ -794,11 +794,15 @@ static int tdfxfb_setcolreg(unsigned regno, unsigned red, unsigned green,
                         break;
                 /* Truecolor has no hardware color palettes. */
                 case FB_VISUAL_TRUECOLOR:
-                        rgbcol = (CNVT_TOHW( red, info->var.red.length) << info->var.red.offset) |
-                                 (CNVT_TOHW( green, info->var.green.length) << info->var.green.offset) |
-                                 (CNVT_TOHW( blue, info->var.blue.length) << info->var.blue.offset) |
-                                 (CNVT_TOHW( transp, info->var.transp.length) << info->var.transp.offset);
-                                ((u32*)(info->pseudo_palette))[regno] = rgbcol;
+                        rgbcol = (CNVT_TOHW( red, info->var.red.length) <<
+                                  info->var.red.offset) |
+                                 (CNVT_TOHW( green, info->var.green.length) <<
+                                  info->var.green.offset) |
+                                 (CNVT_TOHW( blue, info->var.blue.length) <<
+                                  info->var.blue.offset) |
+                                 (CNVT_TOHW( transp, info->var.transp.length) <<
+                                  info->var.transp.offset);
+                                par->palette[regno] = rgbcol;
                         break;
                 default:
                         DPRINTK("bad depth %u\n", info->var.bits_per_pixel);
@@ -810,7 +814,7 @@ static int tdfxfb_setcolreg(unsigned regno, unsigned red, unsigned green,
 /* 0 unblank, 1 blank, 2 no vsync, 3 no hsync, 4 off */
 static int tdfxfb_blank(int blank, struct fb_info *info)
 { 
-        struct tdfx_par *par = (struct tdfx_par *) info->par;
+        struct tdfx_par *par = info->par;
         u32 dacmode, state = 0, vgablank = 0;
 
         dacmode = tdfx_inl(par, DACMODE);
@@ -855,7 +859,7 @@ static int tdfxfb_blank(int blank, struct fb_info *info)
 static int tdfxfb_pan_display(struct fb_var_screeninfo *var,
                               struct fb_info *info) 
 {
-        struct tdfx_par *par = (struct tdfx_par *) info->par;
+        struct tdfx_par *par = info->par;
         u32 addr;       
 
         if (nopan || var->xoffset || (var->yoffset > var->yres_virtual))
@@ -878,7 +882,7 @@ static int tdfxfb_pan_display(struct fb_var_screeninfo *var,
  */
 static void tdfxfb_fillrect(struct fb_info *info, const struct fb_fillrect *rect) 
 {
-        struct tdfx_par *par = (struct tdfx_par *) info->par;
+        struct tdfx_par *par = info->par;
         u32 bpp = info->var.bits_per_pixel;
         u32 stride = info->fix.line_length;
         u32 fmt= stride | ((bpp+((bpp==8) ? 0 : 8)) << 13); 
@@ -894,7 +898,7 @@ static void tdfxfb_fillrect(struct fb_info *info, const struct fb_fillrect *rect
         if (info->fix.visual == FB_VISUAL_PSEUDOCOLOR) {
                 tdfx_outl(par,  COLORFORE, rect->color);
         } else { /* FB_VISUAL_TRUECOLOR */
-                tdfx_outl(par, COLORFORE, ((u32*)(info->pseudo_palette))[rect->color]);
+                tdfx_outl(par, COLORFORE, par->palette[rect->color]);
         }
         tdfx_outl(par,  COMMAND_2D, COMMAND_2D_FILLRECT | (tdfx_rop << 24));
         tdfx_outl(par,  DSTSIZE,    rect->width | (rect->height << 16));
@@ -906,7 +910,7 @@ static void tdfxfb_fillrect(struct fb_info *info, const struct fb_fillrect *rect
  */
 static void tdfxfb_copyarea(struct fb_info *info, const struct fb_copyarea *area)  
 {
-        struct tdfx_par *par = (struct tdfx_par *) info->par;
+        struct tdfx_par *par = info->par;
         u32 sx = area->sx, sy = area->sy, dx = area->dx, dy = area->dy;
         u32 bpp = info->var.bits_per_pixel;
         u32 stride = info->fix.line_length;
@@ -938,7 +942,7 @@ static void tdfxfb_copyarea(struct fb_info *info, const struct fb_copyarea *area
 
 static void tdfxfb_imageblit(struct fb_info *info, const struct fb_image *image) 
 {
-        struct tdfx_par *par = (struct tdfx_par *) info->par;
+        struct tdfx_par *par = info->par;
         int size = image->height * ((image->width * image->depth + 7)>>3);
         int fifo_free;
         int i, stride = info->fix.line_length;
@@ -961,8 +965,10 @@ static void tdfxfb_imageblit(struct fb_info *info, const struct fb_image *image)
                                 break;
                         case FB_VISUAL_TRUECOLOR:
                         default:
-                                tdfx_outl(par, COLORFORE, ((u32*)(info->pseudo_palette))[image->fg_color]);
-                                tdfx_outl(par, COLORBACK, ((u32*)(info->pseudo_palette))[image->bg_color]);
+                                tdfx_outl(par, COLORFORE,
+                                          par->palette[image->fg_color]);
+                                tdfx_outl(par, COLORBACK,
+                                          par->palette[image->bg_color]);
                 }
 #ifdef __BIG_ENDIAN
                 srcfmt = 0x400000 | BIT(20);
@@ -1007,7 +1013,7 @@ static void tdfxfb_imageblit(struct fb_info *info, const struct fb_image *image)
 #ifdef TDFX_HARDWARE_CURSOR
 static int tdfxfb_cursor(struct fb_info *info, struct fb_cursor *cursor)
 {
-        struct tdfx_par *par = (struct tdfx_par *) info->par;
+        struct tdfx_par *par = info->par;
         unsigned long flags;
 
         /*
@@ -1157,18 +1163,17 @@ static int __devinit tdfxfb_probe(struct pci_dev *pdev,
 {
         struct tdfx_par *default_par;
         struct fb_info *info;
-        int size, err, lpitch;
+        int err, lpitch;
 
         if ((err = pci_enable_device(pdev))) {
                 printk(KERN_WARNING "tdfxfb: Can't enable pdev: %d\n", err);
                 return err;
         }
 
-        size = sizeof(struct tdfx_par)+256*sizeof(u32);
+        info = framebuffer_alloc(sizeof(struct tdfx_par), &pdev->dev);
 
-        info = framebuffer_alloc(size, &pdev->dev);
-
-        if (!info)      return -ENOMEM;
+        if (!info)
+                return -ENOMEM;
                 
         default_par = info->par;
  
@@ -1248,7 +1253,7 @@ static int __devinit tdfxfb_probe(struct pci_dev *pdev,
    
         info->fbops             = &tdfxfb_ops;
         info->fix               = tdfx_fix;     
-        info->pseudo_palette    = (void *)(default_par + 1); 
+        info->pseudo_palette    = default_par->palette;
         info->flags             = FBINFO_DEFAULT | FBINFO_HWACCEL_YPAN;
 #ifdef CONFIG_FB_3DFX_ACCEL
         info->flags             |= FBINFO_HWACCEL_FILLRECT |
@@ -1307,7 +1312,7 @@ out_err:
 }
 
 #ifndef MODULE
-void tdfxfb_setup(char *options)
+static void tdfxfb_setup(char *options)
 {
         char* this_opt;
 
@@ -1340,7 +1345,7 @@ void tdfxfb_setup(char *options)
 static void __devexit tdfxfb_remove(struct pci_dev *pdev)
 {
         struct fb_info *info = pci_get_drvdata(pdev);
-        struct tdfx_par *par = (struct tdfx_par *) info->par;
+        struct tdfx_par *par = info->par;
 
         unregister_framebuffer(info);
         iounmap(par->regbase_virt);
diff --git a/drivers/video/vesafb.c b/drivers/video/vesafb.c
index 3e58ddc2bc38..8982e540214c 100644
--- a/drivers/video/vesafb.c
+++ b/drivers/video/vesafb.c
@@ -57,7 +57,6 @@ static unsigned short  *pmi_base  = NULL;
 static void            (*pmi_start)(void);
 static void            (*pmi_pal)(void);
 static int             depth;
-static int             vga_compat;
 
 /* --------------------------------------------------------------------- */
 
@@ -67,15 +66,6 @@ static int vesafb_pan_display(struct fb_var_screeninfo *var,
 #ifdef __i386__
         int offset;
 
-        if (!ypan)
-                return -EINVAL;
-        if (var->xoffset)
-                return -EINVAL;
-        if (var->yoffset > var->yres_virtual)
-                return -EINVAL;
-        if ((ypan==1) && var->yoffset+var->yres > var->yres_virtual)
-                return -EINVAL;
-
         offset = (var->yoffset * info->fix.line_length + var->xoffset) / 4;
 
         __asm__ __volatile__(
@@ -90,37 +80,6 @@ static int vesafb_pan_display(struct fb_var_screeninfo *var,
         return 0;
 }
 
-static int vesafb_blank(int blank, struct fb_info *info)
-{
-        int err = 1;
-
-        if (vga_compat) {
-                int loop = 10000;
-                u8 seq = 0, crtc17 = 0;
-
-                if (blank == FB_BLANK_POWERDOWN) {
-                        seq = 0x20;
-                        crtc17 = 0x00;
-                        err = 0;
-                } else {
-                        seq = 0x00;
-                        crtc17 = 0x80;
-                        err = (blank == FB_BLANK_UNBLANK) ? 0 : -EINVAL;
-                }
-
-                vga_wseq(NULL, 0x00, 0x01);
-                seq |= vga_rseq(NULL, 0x01) & ~0x20;
-                vga_wseq(NULL, 0x00, seq);
-
-                crtc17 |= vga_rcrt(NULL, 0x17) & ~0x80;
-                while (loop--);
-                vga_wcrt(NULL, 0x17, crtc17);
-                vga_wseq(NULL, 0x00, 0x03);
-        }
-
-        return err;
-}
-
 static void vesa_setpalette(int regno, unsigned red, unsigned green,
                             unsigned blue)
 {
@@ -205,7 +164,6 @@ static struct fb_ops vesafb_ops = {
         .owner          = THIS_MODULE,
         .fb_setcolreg   = vesafb_setcolreg,
         .fb_pan_display = vesafb_pan_display,
-        .fb_blank       = vesafb_blank,
         .fb_fillrect    = cfb_fillrect,
         .fb_copyarea    = cfb_copyarea,
         .fb_imageblit   = cfb_imageblit,
@@ -459,9 +417,8 @@ static int __init vesafb_probe(struct platform_device *dev)
         info->flags = FBINFO_FLAG_DEFAULT |
                 (ypan) ? FBINFO_HWACCEL_YPAN : 0;
 
-        vga_compat = (screen_info.capabilities & 2) ? 0 : 1;
-        printk("vesafb: Mode is %sVGA compatible\n",
-               (vga_compat) ? "" : "not ");
+        if (!ypan)
+                info->fbops->fb_pan_display = NULL;
 
         if (fb_alloc_cmap(&info->cmap, 256, 0) < 0) {
                 err = -ENOMEM;
diff --git a/drivers/video/vga16fb.c b/drivers/video/vga16fb.c
index 226ae8a88482..f3f16fd9f231 100644
--- a/drivers/video/vga16fb.c
+++ b/drivers/video/vga16fb.c
@@ -705,15 +705,7 @@ static int vga16fb_setcolreg(unsigned regno, unsigned red, unsigned green,
 static int vga16fb_pan_display(struct fb_var_screeninfo *var,
                                struct fb_info *info) 
 {
-        if (var->xoffset + info->var.xres > info->var.xres_virtual ||
-            var->yoffset + info->var.yres > info->var.yres_virtual)
-                return -EINVAL;
-
         vga16fb_pan_var(info, var);
-
-        info->var.xoffset = var->xoffset;
-        info->var.yoffset = var->yoffset;
-        info->var.vmode &= ~FB_VMODE_YWRAP;
         return 0;
 }
 
diff --git a/drivers/video/vgastate.c b/drivers/video/vgastate.c
index d9e01daee630..15179ec62339 100644
--- a/drivers/video/vgastate.c
+++ b/drivers/video/vgastate.c
@@ -356,10 +356,11 @@ int save_vga(struct vgastate *state)
 {
         struct regstate *saved;
 
-        saved = kmalloc(sizeof(struct regstate), GFP_KERNEL);
+        saved = kzalloc(sizeof(struct regstate), GFP_KERNEL);
+
         if (saved == NULL)
                 return 1;
-        memset (saved, 0, sizeof(struct regstate));
+
         state->vidstate = (void *)saved;
                 
         if (state->flags & VGA_SAVE_CMAP) {