Merge commit 'v2.6.28-rc2' into x86/pci-ioapic-boot-irq-quirks

author: Ingo Molnar <mingo@elte.hu> 2008-10-28 11:26:12 -0400
committer: Ingo Molnar <mingo@elte.hu> 2008-10-28 11:26:12 -0400
commit: 7a9787e1eba95a166265e6a260cf30af04ef0a99 (patch)
tree: e730a4565e0318140d2fbd2f0415d18a339d7336 /drivers/serial
parent: 41b9eb264c8407655db57b60b4457fe1b2ec9977 (diff)
parent: 0173a3265b228da319ceb9c1ec6a5682fd1b2d92 (diff)
66 files changed, 1549 insertions, 3550 deletions
diff --git a/drivers/serial/21285.c b/drivers/serial/21285.c
index 0276471cb25e..f31c6698419c 100644
--- a/drivers/serial/21285.c
+++ b/drivers/serial/21285.c
@@ -4,8 +4,6 @@
 * Driver for the serial port on the 21285 StrongArm-110 core logic chip.
 *
 * Based on drivers/char/serial.c
- *
- *  $Id: 21285.c,v 1.37 2002/07/28 10:03:27 rmk Exp $
 */
 #include <linux/module.h>
 #include <linux/tty.h>
@@ -21,7 +19,7 @@
 #include <asm/irq.h>
 #include <asm/mach-types.h>
 #include <asm/hardware/dec21285.h>
-#include <asm/hardware.h>
+#include <mach/hardware.h>
 #define BAUD_BASE               (mem_fclk_21285/64)
@@ -88,7 +86,7 @@ static void serial21285_enable_ms(struct uart_port *port)
 static irqreturn_t serial21285_rx_chars(int irq, void *dev_id)
 {
        struct uart_port *port = dev_id;
-        struct tty_struct *tty = port->info->tty;
+        struct tty_struct *tty = port->info->port.tty;
        unsigned int status, ch, flag, rxs, max_count = 256;
        status = *CSR_UARTFLG;
@@ -237,8 +235,8 @@ serial21285_set_termios(struct uart_port *port, struct ktermios *termios,
        baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16); 
        quot = uart_get_divisor(port, baud);
-        if (port->info && port->info->tty) {
+        if (port->info && port->info->port.tty) {
-                struct tty_struct *tty = port->info->tty;
+                struct tty_struct *tty = port->info->port.tty;
                unsigned int b = port->uartclk / (16 * quot);
                tty_encode_baud_rate(tty, b, b);
        }
@@ -494,7 +492,7 @@ static int __init serial21285_init(void)
 {
        int ret;
-        printk(KERN_INFO "Serial: 21285 driver $Revision: 1.37 $\n");
+        printk(KERN_INFO "Serial: 21285 driver\n");
        serial21285_setup_ports();
@@ -515,5 +513,5 @@ module_init(serial21285_init);
 module_exit(serial21285_exit);
 MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("Intel Footbridge (21285) serial driver $Revision: 1.37 $");
+MODULE_DESCRIPTION("Intel Footbridge (21285) serial driver");
 MODULE_ALIAS_CHARDEV(SERIAL_21285_MAJOR, SERIAL_21285_MINOR);
diff --git a/drivers/serial/68328serial.c b/drivers/serial/68328serial.c
index bbf5bc5892c7..d935b2d04f93 100644
--- a/drivers/serial/68328serial.c
+++ b/drivers/serial/68328serial.c
@@ -66,7 +66,6 @@
 #endif
 static struct m68k_serial m68k_soft[NR_PORTS];
-struct m68k_serial *IRQ_ports[NR_IRQS];
 static unsigned int uart_irqs[NR_PORTS] = UART_IRQ_DEFNS;
@@ -249,7 +248,7 @@ static void status_handle(struct m68k_serial *info, unsigned short status)
 {
 #if 0
        if(status & DCD) {
-                if((info->tty->termios->c_cflag & CRTSCTS) &&
+                if((info->port.tty->termios->c_cflag & CRTSCTS) &&
                   ((info->curregs[3] & AUTO_ENAB)==0)) {
                        info->curregs[3] |= AUTO_ENAB;
                        info->pendregs[3] |= AUTO_ENAB;
@@ -274,7 +273,7 @@ static void status_handle(struct m68k_serial *info, unsigned short status)
 static void receive_chars(struct m68k_serial *info, unsigned short rx)
 {
-        struct tty_struct *tty = info->tty;
+        struct tty_struct *tty = info->port.tty;
        m68328_uart *uart = &uart_addr[info->line];
        unsigned char ch, flag;
@@ -345,7 +344,7 @@ static void transmit_chars(struct m68k_serial *info)
                goto clear_and_return;
        }
-        if((info->xmit_cnt <= 0) || info->tty->stopped) {
+        if((info->xmit_cnt <= 0) || info->port.tty->stopped) {
                /* That's peculiar... TX ints off */
                uart->ustcnt &= ~USTCNT_TX_INTR_MASK;
                goto clear_and_return;
@@ -375,15 +374,11 @@ clear_and_return:
 */
 irqreturn_t rs_interrupt(int irq, void *dev_id)
 {
-        struct m68k_serial * info;
+        struct m68k_serial *info = dev_id;
        m68328_uart *uart;
        unsigned short rx;
        unsigned short tx;
-        info = IRQ_ports[irq];
-        if(!info)
-            return IRQ_NONE;
        uart = &uart_addr[info->line];
        rx = uart->urx.w;
@@ -403,7 +398,7 @@ static void do_softint(struct work_struct *work)
        struct m68k_serial      *info = container_of(work, struct m68k_serial, tqueue);
        struct tty_struct       *tty;
        
-        tty = info->tty;
+        tty = info->port.tty;
        if (!tty)
                return;
 #if 0
@@ -427,7 +422,7 @@ static void do_serial_hangup(struct work_struct *work)
        struct m68k_serial      *info = container_of(work, struct m68k_serial, tqueue_hangup);
        struct tty_struct       *tty;
        
-        tty = info->tty;
+        tty = info->port.tty;
        if (!tty)
                return;
@@ -471,8 +466,8 @@ static int startup(struct m68k_serial * info)
        uart->ustcnt = USTCNT_UEN | USTCNT_RXEN | USTCNT_RX_INTR_MASK;
 #endif
-        if (info->tty)
+        if (info->port.tty)
-                clear_bit(TTY_IO_ERROR, &info->tty->flags);
+                clear_bit(TTY_IO_ERROR, &info->port.tty->flags);
        info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
        /*
@@ -506,8 +501,8 @@ static void shutdown(struct m68k_serial * info)
                info->xmit_buf = 0;
        }
-        if (info->tty)
+        if (info->port.tty)
-                set_bit(TTY_IO_ERROR, &info->tty->flags);
+                set_bit(TTY_IO_ERROR, &info->port.tty->flags);
        
        info->flags &= ~S_INITIALIZED;
        local_irq_restore(flags);
@@ -573,9 +568,9 @@ static void change_speed(struct m68k_serial *info)
        unsigned cflag;
        int     i;
-        if (!info->tty || !info->tty->termios)
+        if (!info->port.tty || !info->port.tty->termios)
                return;
-        cflag = info->tty->termios->c_cflag;
+        cflag = info->port.tty->termios->c_cflag;
        if (!(port = info->port))
                return;
@@ -1131,7 +1126,7 @@ static void rs_close(struct tty_struct *tty, struct file * filp)
        tty_ldisc_flush(tty);
        tty->closing = 0;
        info->event = 0;
-        info->tty = 0;
+        info->port.tty = NULL;
 #warning "This is not and has never been valid so fix it"       
 #if 0
        if (tty->ldisc.num != ldiscs[N_TTY].num) {
@@ -1169,7 +1164,7 @@ void rs_hangup(struct tty_struct *tty)
        info->event = 0;
        info->count = 0;
        info->flags &= ~S_NORMAL_ACTIVE;
-        info->tty = 0;
+        info->port.tty = NULL;
        wake_up_interruptible(&info->open_wait);
 }
@@ -1286,7 +1281,7 @@ int rs_open(struct tty_struct *tty, struct file * filp)
        info->count++;
        tty->driver_data = info;
-        info->tty = tty;
+        info->port.tty = tty;
        /*
         * Start up serial port
@@ -1363,7 +1358,7 @@ rs68328_init(void)
            info = &m68k_soft[i];
            info->magic = SERIAL_MAGIC;
            info->port = (int) &uart_addr[i];
-            info->tty = 0;
+            info->port.tty = NULL;
            info->irq = uart_irqs[i];
            info->custom_divisor = 16;
            info->close_delay = 50;
@@ -1383,8 +1378,6 @@ rs68328_init(void)
                   info->port, info->irq);
            printk(" is a builtin MC68328 UART\n");
            
-            IRQ_ports[info->irq] = info;        /* waste of space */
 #ifdef CONFIG_M68VZ328
                if (i > 0 )
                        PJSEL &= 0xCF;  /* PSW enable second port output */
@@ -1393,7 +1386,7 @@ rs68328_init(void)
            if (request_irq(uart_irqs[i],
                            rs_interrupt,
                            IRQF_DISABLED,
-                            "M68328_UART", NULL))
+                            "M68328_UART", info))
                panic("Unable to attach 68328 serial interrupt\n");
        }
        local_irq_restore(flags);
diff --git a/drivers/serial/68360serial.c b/drivers/serial/68360serial.c
index d9d4e9552a4d..24661cd5e4fb 100644
--- a/drivers/serial/68360serial.c
+++ b/drivers/serial/68360serial.c
@@ -393,7 +393,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;
+        struct tty_struct *tty = info->port.tty;
        unsigned char ch, flag, *cp;
        /*int   ignored = 0;*/
        int     i;
@@ -514,7 +514,7 @@ static _INLINE_ void receive_chars(ser_info_t *info)
 static _INLINE_ void receive_break(ser_info_t *info)
 {
-        struct tty_struct *tty = info->tty;
+        struct tty_struct *tty = info->port.tty;
        info->state->icount.brk++;
        /* Check to see if there is room in the tty buffer for
@@ -528,7 +528,7 @@ static _INLINE_ void transmit_chars(ser_info_t *info)
 {
        if ((info->flags & TX_WAKEUP) ||
-            (info->tty->flags & (1 << TTY_DO_WRITE_WAKEUP))) {
+            (info->port.tty->flags & (1 << TTY_DO_WRITE_WAKEUP))) {
                schedule_work(&info->tqueue);
        }
@@ -584,12 +584,12 @@ static _INLINE_ void check_modem_status(struct async_struct *info)
                }
        }
        if (info->flags & ASYNC_CTS_FLOW) {
-                if (info->tty->hw_stopped) {
+                if (info->port.tty->hw_stopped) {
                        if (status & UART_MSR_CTS) {
 #if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
                                printk("CTS tx start...");
 #endif
-                                info->tty->hw_stopped = 0;
+                                info->port.tty->hw_stopped = 0;
                                info->IER |= UART_IER_THRI;
                                serial_out(info, UART_IER, info->IER);
                                rs_sched_event(info, RS_EVENT_WRITE_WAKEUP);
@@ -600,7 +600,7 @@ static _INLINE_ void check_modem_status(struct async_struct *info)
 #if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
                                printk("CTS tx stop...");
 #endif
-                                info->tty->hw_stopped = 1;
+                                info->port.tty->hw_stopped = 1;
                                info->IER &= ~UART_IER_THRI;
                                serial_out(info, UART_IER, info->IER);
                        }
@@ -670,7 +670,7 @@ static void do_softint(void *private_)
        ser_info_t      *info = (ser_info_t *) private_;
        struct tty_struct       *tty;
        
-        tty = info->tty;
+        tty = info->port.tty;
        if (!tty)
                return;
@@ -693,7 +693,7 @@ static void do_serial_hangup(void *private_)
        struct async_struct     *info = (struct async_struct *) private_;
        struct tty_struct       *tty;
        
-        tty = info->tty;
+        tty = info->port.tty;
        if (!tty)
                return;
@@ -721,8 +721,8 @@ static int startup(ser_info_t *info)
 #ifdef maybe
        if (!state->port || !state->type) {
-                if (info->tty)
+                if (info->port.tty)
-                        set_bit(TTY_IO_ERROR, &info->tty->flags);
+                        set_bit(TTY_IO_ERROR, &info->port.tty->flags);
                goto errout;
        }
 #endif
@@ -734,12 +734,12 @@ static int startup(ser_info_t *info)
 #ifdef modem_control
        info->MCR = 0;
-        if (info->tty->termios->c_cflag & CBAUD)
+        if (info->port.tty->termios->c_cflag & CBAUD)
                info->MCR = UART_MCR_DTR | UART_MCR_RTS;
 #endif
        
-        if (info->tty)
+        if (info->port.tty)
-                clear_bit(TTY_IO_ERROR, &info->tty->flags);
+                clear_bit(TTY_IO_ERROR, &info->port.tty->flags);
        /*
         * and set the speed of the serial port
@@ -842,8 +842,8 @@ static void shutdown(ser_info_t *info)
                        smcp->smc_smcmr &= ~(SMCMR_REN | SMCMR_TEN);
        }
        
-        if (info->tty)
+        if (info->port.tty)
-                set_bit(TTY_IO_ERROR, &info->tty->flags);
+                set_bit(TTY_IO_ERROR, &info->port.tty->flags);
        info->flags &= ~ASYNC_INITIALIZED;
        local_irq_restore(flags);
@@ -863,9 +863,9 @@ static void change_speed(ser_info_t *info)
        volatile struct smc_regs        *smcp;
        volatile struct scc_regs        *sccp;
-        if (!info->tty || !info->tty->termios)
+        if (!info->port.tty || !info->port.tty->termios)
                return;
-        cflag = info->tty->termios->c_cflag;
+        cflag = info->port.tty->termios->c_cflag;
        state = info->state;
@@ -936,24 +936,24 @@ static void change_speed(ser_info_t *info)
         * Set up parity check flag
         */
        info->read_status_mask = (BD_SC_EMPTY | BD_SC_OV);
-        if (I_INPCK(info->tty))
+        if (I_INPCK(info->port.tty))
                info->read_status_mask |= BD_SC_FR | BD_SC_PR;
-        if (I_BRKINT(info->tty) || I_PARMRK(info->tty))
+        if (I_BRKINT(info->port.tty) || I_PARMRK(info->port.tty))
                info->read_status_mask |= BD_SC_BR;
        
        /*
         * Characters to ignore
         */
        info->ignore_status_mask = 0;
-        if (I_IGNPAR(info->tty))
+        if (I_IGNPAR(info->port.tty))
                info->ignore_status_mask |= BD_SC_PR | BD_SC_FR;
-        if (I_IGNBRK(info->tty)) {
+        if (I_IGNBRK(info->port.tty)) {
                info->ignore_status_mask |= BD_SC_BR;
                /*
                 * If we're ignore parity and break indicators, ignore 
                 * overruns too.  (For real raw support).
                 */
-                if (I_IGNPAR(info->tty))
+                if (I_IGNPAR(info->port.tty))
                        info->ignore_status_mask |= BD_SC_OV;
        }
        /*
@@ -1658,7 +1658,7 @@ static void rs_360_close(struct tty_struct *tty, struct file * filp)
        tty_ldisc_flush(tty);           
        tty->closing = 0;
        info->event = 0;
-        info->tty = 0;
+        info->port.tty = NULL;
        if (info->blocked_open) {
                if (info->close_delay) {
                        msleep_interruptible(jiffies_to_msecs(info->close_delay));
@@ -1758,7 +1758,7 @@ static void rs_360_hangup(struct tty_struct *tty)
        info->event = 0;
        state->count = 0;
        info->flags &= ~ASYNC_NORMAL_ACTIVE;
-        info->tty = 0;
+        info->port.tty = NULL;
        wake_up_interruptible(&info->open_wait);
 }
@@ -1919,7 +1919,7 @@ static int rs_360_open(struct tty_struct *tty, struct file * filp)
        printk("rs_open %s, count = %d\n", tty->name, info->state->count);
 #endif
        tty->driver_data = info;
-        info->tty = tty;
+        info->port.tty = tty;
        /*
         * Start up serial port
@@ -1976,7 +1976,7 @@ static inline int line_info(char *buf, struct serial_state *state)
                info->port = state->port;
                info->flags = state->flags;
                info->quot = 0;
-                info->tty = 0;
+                info->port.tty = NULL;
        }
        local_irq_disable();
        status = serial_in(info, UART_MSR);
diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
index be95e55b228b..303272af386e 100644
--- a/drivers/serial/8250.c
+++ b/drivers/serial/8250.c
@@ -12,8 +12,6 @@
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
- *  $Id: 8250.c,v 1.90 2002/07/28 10:03:27 rmk Exp $
- *
 * A note about mapbase / membase
 *
 *  mapbase is the physical address of the IO port.
@@ -46,6 +44,10 @@
 #include "8250.h"
+#ifdef CONFIG_SPARC
+#include "suncore.h"
+#endif
 /*
 * Configuration:
 *   share_irqs - whether we pass IRQF_SHARED to request_irq().  This option
@@ -55,6 +57,13 @@ static unsigned int share_irqs = SERIAL8250_SHARE_IRQS;
 static unsigned int nr_uarts = CONFIG_SERIAL_8250_RUNTIME_UARTS;
+static struct uart_driver serial8250_reg;
+static int serial_index(struct uart_port *port)
+{
+        return (serial8250_reg.minor - 64) + port->line;
+}
 /*
 * Debugging.
 */
@@ -147,11 +156,15 @@ struct uart_8250_port {
 };
 struct irq_info {
-        spinlock_t              lock;
+        struct                  hlist_node node;
+        int                     irq;
+        spinlock_t              lock;   /* Protects list not the hash */
        struct list_head        *head;
 };
-static struct irq_info irq_lists[NR_IRQS];
+#define NR_IRQ_HASH             32      /* Can be adjusted later */
+static struct hlist_head irq_lists[NR_IRQ_HASH];
+static DEFINE_MUTEX(hash_mutex);        /* Used to walk the hash */
 /*
 * Here we define the default xmit fifo size used for each type of UART.
@@ -538,7 +551,7 @@ static unsigned int serial_icr_read(struct uart_8250_port *up, int offset)
 /*
 * FIFO support.
 */
-static inline void serial8250_clear_fifos(struct uart_8250_port *p)
+static void serial8250_clear_fifos(struct uart_8250_port *p)
 {
        if (p->capabilities & UART_CAP_FIFO) {
                serial_outp(p, UART_FCR, UART_FCR_ENABLE_FIFO);
@@ -553,7 +566,7 @@ static inline void serial8250_clear_fifos(struct uart_8250_port *p)
 * capability" bit enabled.  Note that on XR16C850s, we need to
 * reset LCR to write to IER.
 */
-static inline void serial8250_set_sleep(struct uart_8250_port *p, int sleep)
+static void serial8250_set_sleep(struct uart_8250_port *p, int sleep)
 {
        if (p->capabilities & UART_CAP_SLEEP) {
                if (p->capabilities & UART_CAP_EFR) {
@@ -995,7 +1008,7 @@ static void autoconfig(struct uart_8250_port *up, unsigned int probeflags)
                return;
        DEBUG_AUTOCONF("ttyS%d: autoconf (0x%04x, 0x%p): ",
-                        up->port.line, up->port.iobase, up->port.membase);
+                       serial_index(&up->port), up->port.iobase, up->port.membase);
        /*
         * We really do need global IRQs disabled here - we're going to
@@ -1130,8 +1143,8 @@ static void autoconfig(struct uart_8250_port *up, unsigned int probeflags)
        if (up->capabilities != uart_config[up->port.type].flags) {
                printk(KERN_WARNING
                       "ttyS%d: detected caps %08x should be %08x\n",
-                        up->port.line, up->capabilities,
+                       serial_index(&up->port), up->capabilities,
-                        uart_config[up->port.type].flags);
+                       uart_config[up->port.type].flags);
        }
        up->port.fifosize = uart_config[up->port.type].fifo_size;
@@ -1289,13 +1302,24 @@ static void serial8250_enable_ms(struct uart_port *port)
 static void
 receive_chars(struct uart_8250_port *up, unsigned int *status)
 {
-        struct tty_struct *tty = up->port.info->tty;
+        struct tty_struct *tty = up->port.info->port.tty;
        unsigned char ch, lsr = *status;
        int max_count = 256;
        char flag;
        do {
-                ch = serial_inp(up, UART_RX);
+                if (likely(lsr & UART_LSR_DR))
+                        ch = serial_inp(up, UART_RX);
+                else
+                        /*
+                         * Intel 82571 has a Serial Over Lan device that will
+                         * set UART_LSR_BI without setting UART_LSR_DR when
+                         * it receives a break. To avoid reading from the
+                         * receive buffer without UART_LSR_DR bit set, we
+                         * just force the read character to be 0
+                         */
+                        ch = 0;
                flag = TTY_NORMAL;
                up->port.icount.rx++;
@@ -1344,7 +1368,7 @@ receive_chars(struct uart_8250_port *up, unsigned int *status)
 ignore_char:
                lsr = serial_inp(up, UART_LSR);
-        } while ((lsr & UART_LSR_DR) && (max_count-- > 0));
+        } while ((lsr & (UART_LSR_DR | UART_LSR_BI)) && (max_count-- > 0));
        spin_unlock(&up->port.lock);
        tty_flip_buffer_push(tty);
        spin_lock(&up->port.lock);
@@ -1415,8 +1439,7 @@ static unsigned int check_modem_status(struct uart_8250_port *up)
 /*
 * This handles the interrupt from one port.
 */
-static inline void
+static void serial8250_handle_port(struct uart_8250_port *up)
-serial8250_handle_port(struct uart_8250_port *up)
 {
        unsigned int status;
        unsigned long flags;
@@ -1427,7 +1450,7 @@ serial8250_handle_port(struct uart_8250_port *up)
        DEBUG_INTR("status = %x...", status);
-        if (status & UART_LSR_DR)
+        if (status & (UART_LSR_DR | UART_LSR_BI))
                receive_chars(up, &status);
        check_modem_status(up);
        if (status & UART_LSR_THRE)
@@ -1526,15 +1549,43 @@ static void serial_do_unlink(struct irq_info *i, struct uart_8250_port *up)
                BUG_ON(i->head != &up->list);
                i->head = NULL;
        }
        spin_unlock_irq(&i->lock);
+        /* List empty so throw away the hash node */
+        if (i->head == NULL) {
+                hlist_del(&i->node);
+                kfree(i);
+        }
 }
 static int serial_link_irq_chain(struct uart_8250_port *up)
 {
-        struct irq_info *i = irq_lists + up->port.irq;
+        struct hlist_head *h;
+        struct hlist_node *n;
+        struct irq_info *i;
        int ret, irq_flags = up->port.flags & UPF_SHARE_IRQ ? IRQF_SHARED : 0;
+        mutex_lock(&hash_mutex);
+        h = &irq_lists[up->port.irq % NR_IRQ_HASH];
+        hlist_for_each(n, h) {
+                i = hlist_entry(n, struct irq_info, node);
+                if (i->irq == up->port.irq)
+                        break;
+        }
+        if (n == NULL) {
+                i = kzalloc(sizeof(struct irq_info), GFP_KERNEL);
+                if (i == NULL) {
+                        mutex_unlock(&hash_mutex);
+                        return -ENOMEM;
+                }
+                spin_lock_init(&i->lock);
+                i->irq = up->port.irq;
+                hlist_add_head(&i->node, h);
+        }
+        mutex_unlock(&hash_mutex);
        spin_lock_irq(&i->lock);
        if (i->head) {
@@ -1558,14 +1609,28 @@ static int serial_link_irq_chain(struct uart_8250_port *up)
 static void serial_unlink_irq_chain(struct uart_8250_port *up)
 {
-        struct irq_info *i = irq_lists + up->port.irq;
+        struct irq_info *i;
+        struct hlist_node *n;
+        struct hlist_head *h;
+        mutex_lock(&hash_mutex);
+        h = &irq_lists[up->port.irq % NR_IRQ_HASH];
+        hlist_for_each(n, h) {
+                i = hlist_entry(n, struct irq_info, node);
+                if (i->irq == up->port.irq)
+                        break;
+        }
+        BUG_ON(n == NULL);
        BUG_ON(i->head == NULL);
        if (list_empty(i->head))
                free_irq(up->port.irq, i);
        serial_do_unlink(i, up);
+        mutex_unlock(&hash_mutex);
 }
 /* Base timer interval for polling */
@@ -1710,7 +1775,7 @@ static void serial8250_break_ctl(struct uart_port *port, int break_state)
 /*
 *      Wait for transmitter & holding register to empty
 */
-static inline void wait_for_xmitr(struct uart_8250_port *up, int bits)
+static void wait_for_xmitr(struct uart_8250_port *up, int bits)
 {
        unsigned int status, tmout = 10000;
@@ -1845,7 +1910,8 @@ static int serial8250_startup(struct uart_port *port)
         */
        if (!(up->port.flags & UPF_BUGGY_UART) &&
            (serial_inp(up, UART_LSR) == 0xff)) {
-                printk("ttyS%d: LSR safety check engaged!\n", up->port.line);
+                printk(KERN_INFO "ttyS%d: LSR safety check engaged!\n",
+                       serial_index(&up->port));
                return -ENODEV;
        }
@@ -1877,6 +1943,8 @@ static int serial8250_startup(struct uart_port *port)
                 * allow register changes to become visible.
                 */
                spin_lock_irqsave(&up->port.lock, flags);
+                if (up->port.flags & UPF_SHARE_IRQ)
+                        disable_irq_nosync(up->port.irq);
                wait_for_xmitr(up, UART_LSR_THRE);
                serial_out_sync(up, UART_IER, UART_IER_THRI);
@@ -1888,6 +1956,8 @@ static int serial8250_startup(struct uart_port *port)
                iir = serial_in(up, UART_IIR);
                serial_out(up, UART_IER, 0);
+                if (up->port.flags & UPF_SHARE_IRQ)
+                        enable_irq(up->port.irq);
                spin_unlock_irqrestore(&up->port.lock, flags);
                /*
@@ -1895,15 +1965,24 @@ static int serial8250_startup(struct uart_port *port)
                 * kick the UART on a regular basis.
                 */
                if (!(iir1 & UART_IIR_NO_INT) && (iir & UART_IIR_NO_INT)) {
-                        pr_debug("ttyS%d - using backup timer\n", port->line);
+                        up->bugs |= UART_BUG_THRE;
-                        up->timer.function = serial8250_backup_timeout;
+                        pr_debug("ttyS%d - using backup timer\n",
-                        up->timer.data = (unsigned long)up;
+                                 serial_index(port));
-                        mod_timer(&up->timer, jiffies +
-                                poll_timeout(up->port.timeout) + HZ / 5);
                }
        }
        /*
+         * The above check will only give an accurate result the first time
+         * the port is opened so this value needs to be preserved.
+         */
+        if (up->bugs & UART_BUG_THRE) {
+                up->timer.function = serial8250_backup_timeout;
+                up->timer.data = (unsigned long)up;
+                mod_timer(&up->timer, jiffies +
+                          poll_timeout(up->port.timeout) + HZ / 5);
+        }
+        /*
         * If the "interrupt" for this port doesn't correspond with any
         * hardware interrupt, we use a timer-based system.  The original
         * driver used to do this with IRQ0.
@@ -1948,7 +2027,7 @@ static int serial8250_startup(struct uart_port *port)
                if (!(up->bugs & UART_BUG_TXEN)) {
                        up->bugs |= UART_BUG_TXEN;
                        pr_debug("ttyS%d - enabling bad tx status workarounds\n",
-                                 port->line);
+                                 serial_index(port));
                }
        } else {
                up->bugs &= ~UART_BUG_TXEN;
@@ -2190,9 +2269,9 @@ serial8250_set_termios(struct uart_port *port, struct ktermios *termios,
                serial_outp(up, UART_EFR, efr);
        }
-#ifdef CONFIG_ARCH_OMAP15XX
+#ifdef CONFIG_ARCH_OMAP
        /* Workaround to enable 115200 baud on OMAP1510 internal ports */
-        if (cpu_is_omap1510() && is_omap_port((unsigned int)up->port.membase)) {
+        if (cpu_is_omap1510() && is_omap_port(up)) {
                if (baud == 115200) {
                        quot = 1;
                        serial_out(up, UART_OMAP_OSC_12M_SEL, 1);
@@ -2245,18 +2324,27 @@ serial8250_pm(struct uart_port *port, unsigned int state,
                p->pm(port, state, oldstate);
 }
+static unsigned int serial8250_port_size(struct uart_8250_port *pt)
+{
+        if (pt->port.iotype == UPIO_AU)
+                return 0x100000;
+#ifdef CONFIG_ARCH_OMAP
+        if (is_omap_port(pt))
+                return 0x16 << pt->port.regshift;
+#endif
+        return 8 << pt->port.regshift;
+}
 /*
 * Resource handling.
 */
 static int serial8250_request_std_resource(struct uart_8250_port *up)
 {
-        unsigned int size = 8 << up->port.regshift;
+        unsigned int size = serial8250_port_size(up);
        int ret = 0;
        switch (up->port.iotype) {
        case UPIO_AU:
-                size = 0x100000;
-                /* fall thru */
        case UPIO_TSI:
        case UPIO_MEM32:
        case UPIO_MEM:
@@ -2290,12 +2378,10 @@ static int serial8250_request_std_resource(struct uart_8250_port *up)
 static void serial8250_release_std_resource(struct uart_8250_port *up)
 {
-        unsigned int size = 8 << up->port.regshift;
+        unsigned int size = serial8250_port_size(up);
        switch (up->port.iotype) {
        case UPIO_AU:
-                size = 0x100000;
-                /* fall thru */
        case UPIO_TSI:
        case UPIO_MEM32:
        case UPIO_MEM:
@@ -2407,7 +2493,7 @@ static void serial8250_config_port(struct uart_port *port, int flags)
 static int
 serial8250_verify_port(struct uart_port *port, struct serial_struct *ser)
 {
-        if (ser->irq >= NR_IRQS || ser->irq < 0 ||
+        if (ser->irq >= nr_irqs || ser->irq < 0 ||
            ser->baud_base < 9600 || ser->type < PORT_UNKNOWN ||
            ser->type >= ARRAY_SIZE(uart_config) || ser->type == PORT_CIRRUS ||
            ser->type == PORT_STARTECH)
@@ -2609,7 +2695,6 @@ static int serial8250_console_early_setup(void)
        return serial8250_find_port_for_earlycon();
 }
-static struct uart_driver serial8250_reg;
 static struct console serial8250_console = {
        .name           = "ttyS",
        .write          = serial8250_console_write,
@@ -2656,7 +2741,6 @@ static struct uart_driver serial8250_reg = {
        .dev_name               = "ttyS",
        .major                  = TTY_MAJOR,
        .minor                  = 64,
-        .nr                     = UART_NR,
        .cons                   = SERIAL8250_CONSOLE,
 };
@@ -2929,19 +3013,21 @@ EXPORT_SYMBOL(serial8250_unregister_port);
 static int __init serial8250_init(void)
 {
-        int ret, i;
+        int ret;
        if (nr_uarts > UART_NR)
                nr_uarts = UART_NR;
-        printk(KERN_INFO "Serial: 8250/16550 driver $Revision: 1.90 $ "
+        printk(KERN_INFO "Serial: 8250/16550 driver"
                "%d ports, IRQ sharing %sabled\n", nr_uarts,
                share_irqs ? "en" : "dis");
-        for (i = 0; i < NR_IRQS; i++)
+#ifdef CONFIG_SPARC
-                spin_lock_init(&irq_lists[i].lock);
+        ret = sunserial_register_minors(&serial8250_reg, UART_NR);
+#else
+        serial8250_reg.nr = UART_NR;
        ret = uart_register_driver(&serial8250_reg);
+#endif
        if (ret)
                goto out;
@@ -2963,11 +3049,15 @@ static int __init serial8250_init(void)
                goto out;
        platform_device_del(serial8250_isa_devs);
- put_dev:
+put_dev:
        platform_device_put(serial8250_isa_devs);
- unreg_uart_drv:
+unreg_uart_drv:
+#ifdef CONFIG_SPARC
+        sunserial_unregister_minors(&serial8250_reg, UART_NR);
+#else
        uart_unregister_driver(&serial8250_reg);
- out:
+#endif
+out:
        return ret;
 }
@@ -2985,7 +3075,11 @@ static void __exit serial8250_exit(void)
        platform_driver_unregister(&serial8250_isa_driver);
        platform_device_unregister(isa_dev);
+#ifdef CONFIG_SPARC
+        sunserial_unregister_minors(&serial8250_reg, UART_NR);
+#else
        uart_unregister_driver(&serial8250_reg);
+#endif
 }
 module_init(serial8250_init);
@@ -2995,7 +3089,7 @@ EXPORT_SYMBOL(serial8250_suspend_port);
 EXPORT_SYMBOL(serial8250_resume_port);
 MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("Generic 8250/16x50 serial driver $Revision: 1.90 $");
+MODULE_DESCRIPTION("Generic 8250/16x50 serial driver");
 module_param(share_irqs, uint, 0644);
 MODULE_PARM_DESC(share_irqs, "Share IRQs with other non-8250/16x50 devices"
diff --git a/drivers/serial/8250.h b/drivers/serial/8250.h
index 91bd28f2bb47..520260326f3d 100644
--- a/drivers/serial/8250.h
+++ b/drivers/serial/8250.h
@@ -11,8 +11,6 @@
 * 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.
- *
- *  $Id: 8250.h,v 1.8 2002/07/21 21:32:30 rmk Exp $
 */
 #include <linux/serial_8250.h>
@@ -49,6 +47,7 @@ struct serial8250_config {
 #define UART_BUG_QUOT   (1 << 0)        /* UART has buggy quot LSB */
 #define UART_BUG_TXEN   (1 << 1)        /* UART has buggy TX IIR status */
 #define UART_BUG_NOMSR  (1 << 2)        /* UART has buggy MSR status bits (Au1x00) */
+#define UART_BUG_THRE   (1 << 3)        /* UART has buggy THRE reassertion */
 #define PROBE_RSA       (1 << 0)
 #define PROBE_ANY       (~0)
diff --git a/drivers/serial/8250_gsc.c b/drivers/serial/8250_gsc.c
index 4eb7437a404a..418b4fe9a0a1 100644
--- a/drivers/serial/8250_gsc.c
+++ b/drivers/serial/8250_gsc.c
@@ -111,7 +111,7 @@ static struct parisc_driver serial_driver = {
        .probe          = serial_init_chip,
 };
-int __init probe_serial_gsc(void)
+static int __init probe_serial_gsc(void)
 {
        register_parisc_driver(&lasi_driver);
        register_parisc_driver(&serial_driver);
@@ -119,3 +119,5 @@ int __init probe_serial_gsc(void)
 }
 module_init(probe_serial_gsc);
+MODULE_LICENSE("GPL");
diff --git a/drivers/serial/8250_pci.c b/drivers/serial/8250_pci.c
index 788c3559522d..5450a0e5ecdb 100644
--- a/drivers/serial/8250_pci.c
+++ b/drivers/serial/8250_pci.c
@@ -10,8 +10,6 @@
 * 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.
- *
- *  $Id: 8250_pci.c,v 1.28 2002/11/02 11:14:18 rmk Exp $
 */
 #include <linux/module.h>
 #include <linux/init.h>
@@ -769,6 +767,9 @@ pci_default_setup(struct serial_private *priv, struct pciserial_board *board,
 #define PCI_SUBDEVICE_ID_POCTAL232      0x0308
 #define PCI_SUBDEVICE_ID_POCTAL422      0x0408
+/* Unknown vendors/cards - this should not be in linux/pci_ids.h */
+#define PCI_SUBDEVICE_ID_UNKNOWN_0x1584 0x1584
 /*
 * Master list of serial port init/setup/exit quirks.
 * This does not describe the general nature of the port.
@@ -884,6 +885,15 @@ static struct pci_serial_quirk pci_serial_quirks[] __refdata = {
        },
        {
                .vendor         = PCI_VENDOR_ID_PLX,
+                .device         = PCI_DEVICE_ID_PLX_9050,
+                .subvendor      = PCI_VENDOR_ID_PLX,
+                .subdevice      = PCI_SUBDEVICE_ID_UNKNOWN_0x1584,
+                .init           = pci_plx9050_init,
+                .setup          = pci_default_setup,
+                .exit           = __devexit_p(pci_plx9050_exit),
+        },
+        {
+                .vendor         = PCI_VENDOR_ID_PLX,
                .device         = PCI_DEVICE_ID_PLX_ROMULUS,
                .subvendor      = PCI_VENDOR_ID_PLX,
                .subdevice      = PCI_DEVICE_ID_PLX_ROMULUS,
@@ -1090,6 +1100,8 @@ enum pci_board_num_t {
        pbn_b0_4_1843200_200,
        pbn_b0_8_1843200_200,
+        pbn_b0_1_4000000,
        pbn_b0_bt_1_115200,
        pbn_b0_bt_2_115200,
        pbn_b0_bt_8_115200,
@@ -1157,6 +1169,10 @@ enum pci_board_num_t {
        pbn_exsys_4055,
        pbn_plx_romulus,
        pbn_oxsemi,
+        pbn_oxsemi_1_4000000,
+        pbn_oxsemi_2_4000000,
+        pbn_oxsemi_4_4000000,
+        pbn_oxsemi_8_4000000,
        pbn_intel_i960,
        pbn_sgi_ioc3,
        pbn_computone_4,
@@ -1280,6 +1296,12 @@ static struct pciserial_board pci_boards[] __devinitdata = {
                .base_baud      = 1843200,
                .uart_offset    = 0x200,
        },
+        [pbn_b0_1_4000000] = {
+                .flags          = FL_BASE0,
+                .num_ports      = 1,
+                .base_baud      = 4000000,
+                .uart_offset    = 8,
+        },
        [pbn_b0_bt_1_115200] = {
                .flags          = FL_BASE0|FL_BASE_BARS,
@@ -1615,6 +1637,35 @@ static struct pciserial_board pci_boards[] __devinitdata = {
                .base_baud      = 115200,
                .uart_offset    = 8,
        },
+        [pbn_oxsemi_1_4000000] = {
+                .flags          = FL_BASE0,
+                .num_ports      = 1,
+                .base_baud      = 4000000,
+                .uart_offset    = 0x200,
+                .first_offset   = 0x1000,
+        },
+        [pbn_oxsemi_2_4000000] = {
+                .flags          = FL_BASE0,
+                .num_ports      = 2,
+                .base_baud      = 4000000,
+                .uart_offset    = 0x200,
+                .first_offset   = 0x1000,
+        },
+        [pbn_oxsemi_4_4000000] = {
+                .flags          = FL_BASE0,
+                .num_ports      = 4,
+                .base_baud      = 4000000,
+                .uart_offset    = 0x200,
+                .first_offset   = 0x1000,
+        },
+        [pbn_oxsemi_8_4000000] = {
+                .flags          = FL_BASE0,
+                .num_ports      = 8,
+                .base_baud      = 4000000,
+                .uart_offset    = 0x200,
+                .first_offset   = 0x1000,
+        },
        /*
         * EKF addition for i960 Boards form EKF with serial port.
@@ -1803,6 +1854,39 @@ serial_pci_matches(struct pciserial_board *board,
            board->first_offset == guessed->first_offset;
 }
+/*
+ * Oxford Semiconductor Inc.
+ * Check that device is part of the Tornado range of devices, then determine
+ * the number of ports available on the device.
+ */
+static int pci_oxsemi_tornado_init(struct pci_dev *dev, struct pciserial_board *board)
+{
+        u8 __iomem *p;
+        unsigned long deviceID;
+        unsigned int  number_uarts;
+        /* OxSemi Tornado devices are all 0xCxxx */
+        if (dev->vendor == PCI_VENDOR_ID_OXSEMI &&
+            (dev->device & 0xF000) != 0xC000)
+                return 0;
+        p = pci_iomap(dev, 0, 5);
+        if (p == NULL)
+                return -ENOMEM;
+        deviceID = ioread32(p);
+        /* Tornado device */
+        if (deviceID == 0x07000200) {
+                number_uarts = ioread8(p + 4);
+                board->num_ports = number_uarts;
+                printk(KERN_DEBUG
+                        "%d ports detected on Oxford PCI Express device\n",
+                                                                number_uarts);
+        }
+        pci_iounmap(dev, p);
+        return 0;
+}
 struct serial_private *
 pciserial_init_ports(struct pci_dev *dev, struct pciserial_board *board)
 {
@@ -1811,6 +1895,13 @@ pciserial_init_ports(struct pci_dev *dev, struct pciserial_board *board)
        struct pci_serial_quirk *quirk;
        int rc, nr_ports, i;
+        /*
+         * Find number of ports on board
+         */
+        if (dev->vendor == PCI_VENDOR_ID_OXSEMI ||
+            dev->vendor == PCI_VENDOR_ID_MAINPINE)
+                pci_oxsemi_tornado_init(dev, board);
        nr_ports = board->num_ports;
        /*
@@ -2031,9 +2122,9 @@ static int pciserial_resume_one(struct pci_dev *dev)
                 * The device may have been disabled.  Re-enable it.
                 */
                err = pci_enable_device(dev);
+                /* FIXME: We cannot simply error out here */
                if (err)
-                        return err;
+                        printk(KERN_ERR "pciserial: Unable to re-enable ports, trying to continue.\n");
                pciserial_resume_ports(priv);
        }
        return 0;
@@ -2199,6 +2290,11 @@ static struct pci_device_id serial_pci_tbl[] = {
        {       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_1077,
                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
                pbn_b2_4_921600 },
+        /* Unknown card - subdevice 0x1584 */
+        {       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
+                PCI_VENDOR_ID_PLX,
+                PCI_SUBDEVICE_ID_UNKNOWN_0x1584, 0, 0,
+                pbn_b0_4_115200 },
        {       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
                PCI_SUBVENDOR_ID_KEYSPAN,
                PCI_SUBDEVICE_ID_KEYSPAN_SX2, 0, 0,
@@ -2286,6 +2382,156 @@ static struct pci_device_id serial_pci_tbl[] = {
                pbn_b0_bt_2_921600 },
        /*
+         * Oxford Semiconductor Inc. Tornado PCI express device range.
+         */
+        {       PCI_VENDOR_ID_OXSEMI, 0xc101,    /* OXPCIe952 1 Legacy UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b0_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc105,    /* OXPCIe952 1 Legacy UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b0_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc11b,    /* OXPCIe952 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc11f,    /* OXPCIe952 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc120,    /* OXPCIe952 1 Legacy UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b0_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc124,    /* OXPCIe952 1 Legacy UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b0_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc138,    /* OXPCIe952 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc13d,    /* OXPCIe952 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc140,    /* OXPCIe952 1 Legacy UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b0_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc141,    /* OXPCIe952 1 Legacy UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b0_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc144,    /* OXPCIe952 1 Legacy UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b0_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc145,    /* OXPCIe952 1 Legacy UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b0_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc158,    /* OXPCIe952 2 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_2_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc15d,    /* OXPCIe952 2 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_2_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc208,    /* OXPCIe954 4 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_4_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc20d,    /* OXPCIe954 4 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_4_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc308,    /* OXPCIe958 8 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_8_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc30d,    /* OXPCIe958 8 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_8_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc40b,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc40f,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc41b,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc41f,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc42b,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc42f,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc43b,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc43f,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc44b,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc44f,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc45b,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc45f,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc46b,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc46f,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc47b,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc47f,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc48b,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc48f,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc49b,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc49f,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc4ab,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc4af,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc4bb,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc4bf,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc4cb,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_OXSEMI, 0xc4cf,    /* OXPCIe200 1 Native UART */
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        /*
+         * Mainpine Inc. IQ Express "Rev3" utilizing OxSemi Tornado
+         */
+        {       PCI_VENDOR_ID_MAINPINE, 0x4000, /* IQ Express 1 Port V.34 Super-G3 Fax */
+                PCI_VENDOR_ID_MAINPINE, 0x4001, 0, 0,
+                pbn_oxsemi_1_4000000 },
+        {       PCI_VENDOR_ID_MAINPINE, 0x4000, /* IQ Express 2 Port V.34 Super-G3 Fax */
+                PCI_VENDOR_ID_MAINPINE, 0x4002, 0, 0,
+                pbn_oxsemi_2_4000000 },
+        {       PCI_VENDOR_ID_MAINPINE, 0x4000, /* IQ Express 4 Port V.34 Super-G3 Fax */
+                PCI_VENDOR_ID_MAINPINE, 0x4004, 0, 0,
+                pbn_oxsemi_4_4000000 },
+        {       PCI_VENDOR_ID_MAINPINE, 0x4000, /* IQ Express 8 Port V.34 Super-G3 Fax */
+                PCI_VENDOR_ID_MAINPINE, 0x4008, 0, 0,
+                pbn_oxsemi_8_4000000 },
+        /*
         * SBS Technologies, Inc. P-Octal and PMC-OCTPRO cards,
         * from skokodyn@yahoo.com
         */
diff --git a/drivers/serial/8250_pnp.c b/drivers/serial/8250_pnp.c
index 638b68649e79..fde7f9ccf57e 100644
--- a/drivers/serial/8250_pnp.c
+++ b/drivers/serial/8250_pnp.c
@@ -12,8 +12,6 @@
 * 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.
- *
- *  $Id: 8250_pnp.c,v 1.10 2002/07/21 21:32:30 rmk Exp $
 */
 #include <linux/module.h>
 #include <linux/init.h>
diff --git a/drivers/serial/Kconfig b/drivers/serial/Kconfig
index 18ca9075e131..c94d3c4b7521 100644
--- a/drivers/serial/Kconfig
+++ b/drivers/serial/Kconfig
@@ -1,8 +1,6 @@
 #
 # Serial device configuration
 #
-# $Id: Kconfig,v 1.11 2004/03/11 18:08:04 lethal Exp $
-#
 menu "Serial drivers"
        depends on HAS_IOMEM
@@ -11,7 +9,6 @@ menu "Serial drivers"
 # The new 8250/16550 serial drivers
 config SERIAL_8250
        tristate "8250/16550 and compatible serial support"
-        depends on (BROKEN || !SPARC)
        select SERIAL_CORE
        ---help---
          This selects whether you want to include the driver for the standard
@@ -451,6 +448,7 @@ config SERIAL_CLPS711X_CONSOLE
 config SERIAL_SAMSUNG
        tristate "Samsung SoC serial support"
        depends on ARM && PLAT_S3C24XX
+        select SERIAL_CORE
        help
          Support for the on-chip UARTs on the Samsung S3C24XX series CPUs,
          providing /dev/ttySAC0, 1 and 2 (note, some machines may not
@@ -459,7 +457,7 @@ config SERIAL_SAMSUNG
 config SERIAL_SAMSUNG_DEBUG
        bool "Samsung SoC serial debug"
-        depends on SERIAL_SAMSUNG
+        depends on SERIAL_SAMSUNG && DEBUG_LL
        help
          Add support for debugging the serial driver. Since this is
          generally being used as a console, we use our own output
@@ -944,22 +942,6 @@ config SERIAL_IP22_ZILOG_CONSOLE
        depends on SERIAL_IP22_ZILOG=y
        select SERIAL_CORE_CONSOLE
-config V850E_UART
-        bool "NEC V850E on-chip UART support"
-        depends on V850E_MA1 || V850E_ME2 || V850E_TEG || V850E2_ANNA || V850E_AS85EP1
-        select SERIAL_CORE
-        default y
-config V850E_UARTB
-        bool
-        depends on V850E_UART && V850E_ME2
-        default y
-config V850E_UART_CONSOLE
-        bool "Use NEC V850E on-chip UART for console"
-        depends on V850E_UART
-        select SERIAL_CORE_CONSOLE
 config SERIAL_SH_SCI
        tristate "SuperH SCI(F) serial port support"
        depends on SUPERH || H8300
@@ -1011,24 +993,12 @@ config SERIAL_68328_RTS_CTS
        bool "Support RTS/CTS on 68328 serial port"
        depends on SERIAL_68328
-config SERIAL_COLDFIRE
-        bool "ColdFire serial support (DEPRECATED)"
-        depends on COLDFIRE
-        help
-          This driver supports the built-in serial ports of the Motorola ColdFire
-          family of CPUs.
-          This driver is deprecated because it supports only the old interface
-          for serial drivers and features like magic keys are not working.
-          Please switch to the new style driver because this driver will be
-          removed soon.
 config SERIAL_MCF
-        bool "Coldfire serial support (new style driver)"
+        bool "Coldfire serial support"
        depends on COLDFIRE
        select SERIAL_CORE
        help
-          This new serial driver supports the Freescale Coldfire serial ports
+          This serial driver supports the Freescale Coldfire serial ports.
-          using the new serial driver subsystem.
 config SERIAL_MCF_BAUDRATE
        int "Default baudrate for Coldfire serial ports"
@@ -1153,42 +1123,6 @@ config SERIAL_CPM_CONSOLE
          your boot loader (lilo or loadlin) about how to pass options to the
          kernel at boot time.)
-config SERIAL_CPM_SCC1
-        bool "Support for SCC1 serial port"
-        depends on SERIAL_CPM=y
-        help
-          Select this option to use SCC1 as a serial port
-config SERIAL_CPM_SCC2
-        bool "Support for SCC2 serial port"
-        depends on SERIAL_CPM=y
-        help
-          Select this option to use SCC2 as a serial port
-config SERIAL_CPM_SCC3
-        bool "Support for SCC3 serial port"
-        depends on SERIAL_CPM=y
-        help
-          Select this option to use SCC3 as a serial port
-config SERIAL_CPM_SCC4
-        bool "Support for SCC4 serial port"
-        depends on SERIAL_CPM=y
-        help
-          Select this option to use SCC4 as a serial port
-config SERIAL_CPM_SMC1
-        bool "Support for SMC1 serial port"
-        depends on SERIAL_CPM=y
-        help
-          Select this option to use SMC1 as a serial port
-config SERIAL_CPM_SMC2
-        bool "Support for SMC2 serial port"
-        depends on SERIAL_CPM=y
-        help
-          Select this option to use SMC2 as a serial port
 config SERIAL_SGI_L1_CONSOLE
        bool "SGI Altix L1 serial console support"
        depends on IA64_GENERIC || IA64_SGI_SN2
diff --git a/drivers/serial/Makefile b/drivers/serial/Makefile
index 7d85c1fbe7e0..0c17c8ddb19d 100644
--- a/drivers/serial/Makefile
+++ b/drivers/serial/Makefile
@@ -1,11 +1,19 @@
 #
 # Makefile for the kernel serial device drivers.
 #
-#  $Id: Makefile,v 1.8 2002/07/21 21:32:30 rmk Exp $
-#
 obj-$(CONFIG_SERIAL_CORE) += serial_core.o
 obj-$(CONFIG_SERIAL_21285) += 21285.o
+# These Sparc drivers have to appear before others such as 8250
+# which share ttySx minor node space.  Otherwise console device
+# names change and other unplesantries.
+obj-$(CONFIG_SERIAL_SUNCORE) += suncore.o
+obj-$(CONFIG_SERIAL_SUNHV) += sunhv.o
+obj-$(CONFIG_SERIAL_SUNZILOG) += sunzilog.o
+obj-$(CONFIG_SERIAL_SUNSU) += sunsu.o
+obj-$(CONFIG_SERIAL_SUNSAB) += sunsab.o
 obj-$(CONFIG_SERIAL_8250) += 8250.o
 obj-$(CONFIG_SERIAL_8250_PNP) += 8250_pnp.o
 obj-$(CONFIG_SERIAL_8250_GSC) += 8250_gsc.o
@@ -33,18 +41,11 @@ obj-$(CONFIG_SERIAL_S3C2400) += s3c2400.o
 obj-$(CONFIG_SERIAL_S3C2410) += s3c2410.o
 obj-$(CONFIG_SERIAL_S3C2412) += s3c2412.o
 obj-$(CONFIG_SERIAL_S3C2440) += s3c2440.o
-obj-$(CONFIG_SERIAL_SUNCORE) += suncore.o
-obj-$(CONFIG_SERIAL_SUNHV) += sunhv.o
-obj-$(CONFIG_SERIAL_SUNZILOG) += sunzilog.o
 obj-$(CONFIG_SERIAL_IP22_ZILOG) += ip22zilog.o
-obj-$(CONFIG_SERIAL_SUNSU) += sunsu.o
-obj-$(CONFIG_SERIAL_SUNSAB) += sunsab.o
 obj-$(CONFIG_SERIAL_MUX) += mux.o
 obj-$(CONFIG_SERIAL_68328) += 68328serial.o
 obj-$(CONFIG_SERIAL_68360) += 68360serial.o
-obj-$(CONFIG_SERIAL_COLDFIRE) += mcfserial.o
 obj-$(CONFIG_SERIAL_MCF) += mcf.o
-obj-$(CONFIG_V850E_UART) += v850e_uart.o
 obj-$(CONFIG_SERIAL_PMACZILOG) += pmac_zilog.o
 obj-$(CONFIG_SERIAL_LH7A40X) += serial_lh7a40x.o
 obj-$(CONFIG_SERIAL_DZ) += dz.o
diff --git a/drivers/serial/amba-pl010.c b/drivers/serial/amba-pl010.c
index e88da72f8304..71562689116f 100644
--- a/drivers/serial/amba-pl010.c
+++ b/drivers/serial/amba-pl010.c
@@ -22,8 +22,6 @@
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
- *  $Id: amba.c,v 1.41 2002/07/28 10:03:27 rmk Exp $
- *
 * This is a generic driver for ARM AMBA-type serial ports.  They
 * have a lot of 16550-like features, but are not register compatible.
 * Note that although they do have CTS, DCD and DSR inputs, they do
@@ -119,7 +117,7 @@ static void pl010_enable_ms(struct uart_port *port)
 static void pl010_rx_chars(struct uart_amba_port *uap)
 {
-        struct tty_struct *tty = uap->port.info->tty;
+        struct tty_struct *tty = uap->port.info->port.tty;
        unsigned int status, ch, flag, rsr, max_count = 256;
        status = readb(uap->port.membase + UART01x_FR);
@@ -514,7 +512,7 @@ static int pl010_verify_port(struct uart_port *port, struct serial_struct *ser)
        int ret = 0;
        if (ser->type != PORT_UNKNOWN && ser->type != PORT_AMBA)
                ret = -EINVAL;
-        if (ser->irq < 0 || ser->irq >= NR_IRQS)
+        if (ser->irq < 0 || ser->irq >= nr_irqs)
                ret = -EINVAL;
        if (ser->baud_base < 9600)
                ret = -EINVAL;
@@ -791,7 +789,7 @@ static int __init pl010_init(void)
 {
        int ret;
-        printk(KERN_INFO "Serial: AMBA driver $Revision: 1.41 $\n");
+        printk(KERN_INFO "Serial: AMBA driver\n");
        ret = uart_register_driver(&amba_reg);
        if (ret == 0) {
@@ -812,5 +810,5 @@ module_init(pl010_init);
 module_exit(pl010_exit);
 MODULE_AUTHOR("ARM Ltd/Deep Blue Solutions Ltd");
-MODULE_DESCRIPTION("ARM AMBA serial port driver $Revision: 1.41 $");
+MODULE_DESCRIPTION("ARM AMBA serial port driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/serial/amba-pl011.c b/drivers/serial/amba-pl011.c
index 08adc1de4a79..b7180046f8db 100644
--- a/drivers/serial/amba-pl011.c
+++ b/drivers/serial/amba-pl011.c
@@ -22,8 +22,6 @@
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
- *  $Id: amba.c,v 1.41 2002/07/28 10:03:27 rmk Exp $
- *
 * This is a generic driver for ARM AMBA-type serial ports.  They
 * have a lot of 16550-like features, but are not register compatible.
 * Note that although they do have CTS, DCD and DSR inputs, they do
@@ -109,7 +107,7 @@ static void pl011_enable_ms(struct uart_port *port)
 static void pl011_rx_chars(struct uart_amba_port *uap)
 {
-        struct tty_struct *tty = uap->port.info->tty;
+        struct tty_struct *tty = uap->port.info->port.tty;
        unsigned int status, ch, flag, max_count = 256;
        status = readw(uap->port.membase + UART01x_FR);
@@ -574,7 +572,7 @@ static int pl010_verify_port(struct uart_port *port, struct serial_struct *ser)
        int ret = 0;
        if (ser->type != PORT_UNKNOWN && ser->type != PORT_AMBA)
                ret = -EINVAL;
-        if (ser->irq < 0 || ser->irq >= NR_IRQS)
+        if (ser->irq < 0 || ser->irq >= nr_irqs)
                ret = -EINVAL;
        if (ser->baud_base < 9600)
                ret = -EINVAL;
diff --git a/drivers/serial/atmel_serial.c b/drivers/serial/atmel_serial.c
index 6aeef22bd203..61fb8b6d19af 100644
--- a/drivers/serial/atmel_serial.c
+++ b/drivers/serial/atmel_serial.c
@@ -42,11 +42,11 @@
 #include <asm/io.h>
 #include <asm/mach/serial_at91.h>
-#include <asm/arch/board.h>
+#include <mach/board.h>
 #ifdef CONFIG_ARM
-#include <asm/arch/cpu.h>
+#include <mach/cpu.h>
-#include <asm/arch/gpio.h>
+#include <mach/gpio.h>
 #endif
 #define PDC_BUFFER_SIZE         512
@@ -131,7 +131,8 @@ struct atmel_uart_char {
 struct atmel_uart_port {
        struct uart_port        uart;           /* uart */
        struct clk              *clk;           /* uart clock */
-        unsigned short          suspended;      /* is port suspended? */
+        int                     may_wakeup;     /* cached value of device_may_wakeup for times we need to disable it */
+        u32                     backup_imr;     /* IMR saved during suspend */
        int                     break_active;   /* break being received */
        short                   use_dma_rx;     /* enable PDC receiver */
@@ -662,14 +663,14 @@ static void atmel_rx_from_ring(struct uart_port *port)
         * uart_start(), which takes the lock.
         */
        spin_unlock(&port->lock);
-        tty_flip_buffer_push(port->info->tty);
+        tty_flip_buffer_push(port->info->port.tty);
        spin_lock(&port->lock);
 }
 static void atmel_rx_from_dma(struct uart_port *port)
 {
        struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
-        struct tty_struct *tty = port->info->tty;
+        struct tty_struct *tty = port->info->port.tty;
        struct atmel_dma_buffer *pdc;
        int rx_idx = atmel_port->pdc_rx_idx;
        unsigned int head;
@@ -794,7 +795,7 @@ static void atmel_tasklet_func(unsigned long data)
 static int atmel_startup(struct uart_port *port)
 {
        struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
-        struct tty_struct *tty = port->info->tty;
+        struct tty_struct *tty = port->info->port.tty;
        int retval;
        /*
@@ -956,6 +957,20 @@ static void atmel_shutdown(struct uart_port *port)
 }
 /*
+ * Flush any TX data submitted for DMA. Called when the TX circular
+ * buffer is reset.
+ */
+static void atmel_flush_buffer(struct uart_port *port)
+{
+        struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
+        if (atmel_use_dma_tx(port)) {
+                UART_PUT_TCR(port, 0);
+                atmel_port->pdc_tx.ofs = 0;
+        }
+}
+/*
 * Power / Clock management.
 */
 static void atmel_serial_pm(struct uart_port *port, unsigned int state,
@@ -970,8 +985,15 @@ static void atmel_serial_pm(struct uart_port *port, unsigned int state,
                 * This is called on uart_open() or a resume event.
                 */
                clk_enable(atmel_port->clk);
+                /* re-enable interrupts if we disabled some on suspend */
+                UART_PUT_IER(port, atmel_port->backup_imr);
                break;
        case 3:
+                /* Back up the interrupt mask and disable all interrupts */
+                atmel_port->backup_imr = UART_GET_IMR(port);
+                UART_PUT_IDR(port, -1);
                /*
                 * Disable the peripheral clock for this serial port.
                 * This is called on uart_close() or a suspend event.
@@ -1189,6 +1211,7 @@ static struct uart_ops atmel_pops = {
        .break_ctl      = atmel_break_ctl,
        .startup        = atmel_startup,
        .shutdown       = atmel_shutdown,
+        .flush_buffer   = atmel_flush_buffer,
        .set_termios    = atmel_set_termios,
        .type           = atmel_type,
        .release_port   = atmel_release_port,
@@ -1460,13 +1483,12 @@ static int atmel_serial_suspend(struct platform_device *pdev,
                        cpu_relax();
        }
-        if (device_may_wakeup(&pdev->dev)
+        /* we can not wake up if we're running on slow clock */
-            && !atmel_serial_clk_will_stop())
+        atmel_port->may_wakeup = device_may_wakeup(&pdev->dev);
-                enable_irq_wake(port->irq);
+        if (atmel_serial_clk_will_stop())
-        else {
+                device_set_wakeup_enable(&pdev->dev, 0);
-                uart_suspend_port(&atmel_uart, port);
-                atmel_port->suspended = 1;
+        uart_suspend_port(&atmel_uart, port);
-        }
        return 0;
 }
@@ -1476,11 +1498,8 @@ static int atmel_serial_resume(struct platform_device *pdev)
        struct uart_port *port = platform_get_drvdata(pdev);
        struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
-        if (atmel_port->suspended) {
+        uart_resume_port(&atmel_uart, port);
-                uart_resume_port(&atmel_uart, port);
+        device_set_wakeup_enable(&pdev->dev, atmel_port->may_wakeup);
-                atmel_port->suspended = 0;
-        } else
-                disable_irq_wake(port->irq);
        return 0;
 }
@@ -1498,6 +1517,8 @@ static int __devinit atmel_serial_probe(struct platform_device *pdev)
        BUILD_BUG_ON(!is_power_of_2(ATMEL_SERIAL_RINGSIZE));
        port = &atmel_ports[pdev->id];
+        port->backup_imr = 0;
        atmel_init_port(port, pdev);
        if (!atmel_use_dma_rx(&port->uart)) {
diff --git a/drivers/serial/bfin_5xx.c b/drivers/serial/bfin_5xx.c
index fd9bb777df28..569f0e2476c6 100644
--- a/drivers/serial/bfin_5xx.c
+++ b/drivers/serial/bfin_5xx.c
@@ -1,7 +1,7 @@
 /*
 * Blackfin On-Chip Serial Driver
 *
- * Copyright 2006-2007 Analog Devices Inc.
+ * Copyright 2006-2008 Analog Devices Inc.
 *
 * Enter bugs at http://blackfin.uclinux.org/
 *
@@ -28,7 +28,7 @@
 #endif
 #include <asm/gpio.h>
-#include <asm/mach/bfin_serial_5xx.h>
+#include <mach/bfin_serial_5xx.h>
 #ifdef CONFIG_SERIAL_BFIN_DMA
 #include <linux/dma-mapping.h>
@@ -42,6 +42,9 @@
 #define BFIN_SERIAL_MAJOR       204
 #define BFIN_SERIAL_MINOR       64
+static struct bfin_serial_port bfin_serial_ports[BFIN_UART_NR_PORTS];
+static int nr_active_ports = ARRAY_SIZE(bfin_serial_resource);
 /*
 * Setup for console. Argument comes from the menuconfig
 */
@@ -126,13 +129,13 @@ static int kgdb_entry_state;
 void kgdb_put_debug_char(int chr)
 {
        struct bfin_serial_port *uart;
-        
        if (CONFIG_KGDB_UART_PORT < 0
                || CONFIG_KGDB_UART_PORT >= BFIN_UART_NR_PORTS)
                uart = &bfin_serial_ports[0];
        else
                uart = &bfin_serial_ports[CONFIG_KGDB_UART_PORT];
-        
        while (!(UART_GET_LSR(uart) & THRE)) {
                SSYNC();
        }
@@ -152,7 +155,7 @@ int kgdb_get_debug_char(void)
                uart = &bfin_serial_ports[0];
        else
                uart = &bfin_serial_ports[CONFIG_KGDB_UART_PORT];
-        
        while(!(UART_GET_LSR(uart) & DR)) {
                SSYNC();
        }
@@ -175,7 +178,7 @@ int kgdb_get_debug_char(void)
 #ifdef CONFIG_SERIAL_BFIN_PIO
 static void bfin_serial_rx_chars(struct bfin_serial_port *uart)
 {
-        struct tty_struct *tty = uart->port.info->tty;
+        struct tty_struct *tty = uart->port.info->port.tty;
        unsigned int status, ch, flg;
        static struct timeval anomaly_start = { .tv_sec = 0 };
@@ -298,7 +301,11 @@ static void bfin_serial_tx_chars(struct bfin_serial_port *uart)
        bfin_serial_mctrl_check(uart);
        if (uart_circ_empty(xmit) || uart_tx_stopped(&uart->port)) {
-                bfin_serial_stop_tx(&uart->port);
+#ifdef CONFIG_BF54x
+                /* Clear TFI bit */
+                UART_PUT_LSR(uart, TFI);
+#endif
+                UART_CLEAR_IER(uart, ETBEI);
                return;
        }
@@ -317,9 +324,6 @@ static void bfin_serial_tx_chars(struct bfin_serial_port *uart)
        if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
                uart_write_wakeup(&uart->port);
-        if (uart_circ_empty(xmit))
-                bfin_serial_stop_tx(&uart->port);
 }
 static irqreturn_t bfin_serial_rx_int(int irq, void *dev_id)
@@ -393,7 +397,7 @@ static void bfin_serial_dma_tx_chars(struct bfin_serial_port *uart)
 static void bfin_serial_dma_rx_chars(struct bfin_serial_port *uart)
 {
-        struct tty_struct *tty = uart->port.info->tty;
+        struct tty_struct *tty = uart->port.info->port.tty;
        int i, flg, status;
        status = UART_GET_LSR(uart);
@@ -552,7 +556,7 @@ static void bfin_serial_mctrl_check(struct bfin_serial_port *uart)
 #ifdef CONFIG_SERIAL_BFIN_CTSRTS
        unsigned int status;
        struct uart_info *info = uart->port.info;
-        struct tty_struct *tty = info->tty;
+        struct tty_struct *tty = info->port.tty;
        status = bfin_serial_get_mctrl(&uart->port);
        uart_handle_cts_change(&uart->port, status & TIOCM_CTS);
@@ -645,6 +649,42 @@ static int bfin_serial_startup(struct uart_port *port)
                free_irq(uart->port.irq, uart);
                return -EBUSY;
        }
+# ifdef CONFIG_BF54x
+        {
+                unsigned uart_dma_ch_rx, uart_dma_ch_tx;
+                switch (uart->port.irq) {
+                case IRQ_UART3_RX:
+                        uart_dma_ch_rx = CH_UART3_RX;
+                        uart_dma_ch_tx = CH_UART3_TX;
+                        break;
+                case IRQ_UART2_RX:
+                        uart_dma_ch_rx = CH_UART2_RX;
+                        uart_dma_ch_tx = CH_UART2_TX;
+                        break;
+                default:
+                        uart_dma_ch_rx = uart_dma_ch_tx = 0;
+                        break;
+                };
+                if (uart_dma_ch_rx &&
+                        request_dma(uart_dma_ch_rx, "BFIN_UART_RX") < 0) {
+                        printk(KERN_NOTICE"Fail to attach UART interrupt\n");
+                        free_irq(uart->port.irq, uart);
+                        free_irq(uart->port.irq + 1, uart);
+                        return -EBUSY;
+                }
+                if (uart_dma_ch_tx &&
+                        request_dma(uart_dma_ch_tx, "BFIN_UART_TX") < 0) {
+                        printk(KERN_NOTICE "Fail to attach UART interrupt\n");
+                        free_dma(uart_dma_ch_rx);
+                        free_irq(uart->port.irq, uart);
+                        free_irq(uart->port.irq + 1, uart);
+                        return -EBUSY;
+                }
+        }
+# endif
 #endif
        UART_SET_IER(uart, ERBFI);
        return 0;
@@ -662,6 +702,20 @@ static void bfin_serial_shutdown(struct uart_port *port)
        del_timer(&(uart->rx_dma_timer));
        dma_free_coherent(NULL, PAGE_SIZE, uart->rx_dma_buf.buf, 0);
 #else
+#ifdef CONFIG_BF54x
+        switch (uart->port.irq) {
+        case IRQ_UART3_RX:
+                free_dma(CH_UART3_RX);
+                free_dma(CH_UART3_TX);
+                break;
+        case IRQ_UART2_RX:
+                free_dma(CH_UART2_RX);
+                free_dma(CH_UART2_TX);
+                break;
+        default:
+                break;
+        };
+#endif
 #ifdef  CONFIG_KGDB_UART
        if (uart->port.line != CONFIG_KGDB_UART_PORT)
 #endif
@@ -757,6 +811,9 @@ bfin_serial_set_termios(struct uart_port *port, struct ktermios *termios,
        val |= UCEN;
        UART_PUT_GCTL(uart, val);
+        /* Port speed changed, update the per-port timeout. */
+        uart_update_timeout(port, termios->c_cflag, baud);
        spin_unlock_irqrestore(&uart->port.lock, flags);
 }
@@ -814,10 +871,10 @@ static void bfin_serial_set_ldisc(struct uart_port *port)
        int line = port->line;
        unsigned short val;
-        if (line >= port->info->tty->driver->num)
+        if (line >= port->info->port.tty->driver->num)
                return;
-        switch (port->info->tty->ldisc.num) {
+        switch (port->info->port.tty->termios->c_line) {
        case N_IRDA:
                val = UART_GET_GCTL(&bfin_serial_ports[line]);
                val |= (IREN | RPOLC);
@@ -859,8 +916,9 @@ static void __init bfin_serial_init_ports(void)
                return;
        first = 0;
-        for (i = 0; i < nr_ports; i++) {
+        for (i = 0; i < nr_active_ports; i++) {
                bfin_serial_ports[i].port.uartclk   = get_sclk();
+                bfin_serial_ports[i].port.fifosize  = BFIN_UART_TX_FIFO_SIZE;
                bfin_serial_ports[i].port.ops       = &bfin_serial_pops;
                bfin_serial_ports[i].port.line      = i;
                bfin_serial_ports[i].port.iotype    = UPIO_MEM;
@@ -961,7 +1019,7 @@ bfin_serial_console_setup(struct console *co, char *options)
         * if so, search for the first available port that does have
         * console support.
         */
-        if (co->index == -1 || co->index >= nr_ports)
+        if (co->index == -1 || co->index >= nr_active_ports)
                co->index = 0;
        uart = &bfin_serial_ports[co->index];
@@ -1056,7 +1114,7 @@ static __init void early_serial_write(struct console *con, const char *s,
        }
 }
-static struct __init console bfin_early_serial_console = {
+static struct __initdata console bfin_early_serial_console = {
        .name = "early_BFuart",
        .write = early_serial_write,
        .device = uart_console_device,
@@ -1072,7 +1130,7 @@ struct console __init *bfin_earlyserial_init(unsigned int port,
        struct bfin_serial_port *uart;
        struct ktermios t;
-        if (port == -1 || port >= nr_ports)
+        if (port == -1 || port >= nr_active_ports)
                port = 0;
        bfin_serial_init_ports();
        bfin_early_serial_console.index = port;
@@ -1100,20 +1158,26 @@ static struct uart_driver bfin_serial_reg = {
 static int bfin_serial_suspend(struct platform_device *dev, pm_message_t state)
 {
-        struct bfin_serial_port *uart = platform_get_drvdata(dev);
+        int i;
-        if (uart)
+        for (i = 0; i < nr_active_ports; i++) {
-                uart_suspend_port(&bfin_serial_reg, &uart->port);
+                if (bfin_serial_ports[i].port.dev != &dev->dev)
+                        continue;
+                uart_suspend_port(&bfin_serial_reg, &bfin_serial_ports[i].port);
+        }
        return 0;
 }
 static int bfin_serial_resume(struct platform_device *dev)
 {
-        struct bfin_serial_port *uart = platform_get_drvdata(dev);
+        int i;
-        if (uart)
+        for (i = 0; i < nr_active_ports; i++) {
-                uart_resume_port(&bfin_serial_reg, &uart->port);
+                if (bfin_serial_ports[i].port.dev != &dev->dev)
+                        continue;
+                uart_resume_port(&bfin_serial_reg, &bfin_serial_ports[i].port);
+        }
        return 0;
 }
@@ -1128,32 +1192,31 @@ static int bfin_serial_probe(struct platform_device *dev)
                        break;
        if (i < dev->num_resources) {
-                for (i = 0; i < nr_ports; i++, res++) {
+                for (i = 0; i < nr_active_ports; i++, res++) {
                        if (bfin_serial_ports[i].port.mapbase != res->start)
                                continue;
                        bfin_serial_ports[i].port.dev = &dev->dev;
                        uart_add_one_port(&bfin_serial_reg, &bfin_serial_ports[i].port);
-                        platform_set_drvdata(dev, &bfin_serial_ports[i]);
                }
        }
        return 0;
 }
-static int bfin_serial_remove(struct platform_device *pdev)
+static int bfin_serial_remove(struct platform_device *dev)
 {
-        struct bfin_serial_port *uart = platform_get_drvdata(pdev);
+        int i;
+        for (i = 0; i < nr_active_ports; i++) {
+                if (bfin_serial_ports[i].port.dev != &dev->dev)
+                        continue;
+                uart_remove_one_port(&bfin_serial_reg, &bfin_serial_ports[i].port);
+                bfin_serial_ports[i].port.dev = NULL;
 #ifdef CONFIG_SERIAL_BFIN_CTSRTS
-        gpio_free(uart->cts_pin);
+                gpio_free(bfin_serial_ports[i].cts_pin);
-        gpio_free(uart->rts_pin);
+                gpio_free(bfin_serial_ports[i].rts_pin);
 #endif
+        }
-        platform_set_drvdata(pdev, NULL);
-        if (uart)
-                uart_remove_one_port(&bfin_serial_reg, &uart->port);
        return 0;
 }
diff --git a/drivers/serial/bfin_sport_uart.c b/drivers/serial/bfin_sport_uart.c
index aca1240ad808..dd8564d25051 100644
--- a/drivers/serial/bfin_sport_uart.c
+++ b/drivers/serial/bfin_sport_uart.c
@@ -174,7 +174,7 @@ static int sport_uart_setup(struct sport_uart_port *up, int sclk, int baud_rate)
 static irqreturn_t sport_uart_rx_irq(int irq, void *dev_id)
 {
        struct sport_uart_port *up = dev_id;
-        struct tty_struct *tty = up->port.info->tty;
+        struct tty_struct *tty = up->port.info->port.tty;
        unsigned int ch;
        do {
@@ -201,7 +201,7 @@ static irqreturn_t sport_uart_tx_irq(int irq, void *dev_id)
 static irqreturn_t sport_uart_err_irq(int irq, void *dev_id)
 {
        struct sport_uart_port *up = dev_id;
-        struct tty_struct *tty = up->port.info->tty;
+        struct tty_struct *tty = up->port.info->port.tty;
        unsigned int stat = SPORT_GET_STAT(up);
        /* Overflow in RX FIFO */
diff --git a/drivers/serial/clps711x.c b/drivers/serial/clps711x.c
index 23827189ec0e..459f3420a429 100644
--- a/drivers/serial/clps711x.c
+++ b/drivers/serial/clps711x.c
@@ -21,9 +21,6 @@
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- *  $Id: clps711x.c,v 1.42 2002/07/28 10:03:28 rmk Exp $
- *
 */
 #if defined(CONFIG_SERIAL_CLPS711X_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
@@ -42,7 +39,7 @@
 #include <linux/serial_core.h>
 #include <linux/serial.h>
-#include <asm/hardware.h>
+#include <mach/hardware.h>
 #include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/hardware/clps7111.h>
@@ -96,7 +93,7 @@ static void clps711xuart_enable_ms(struct uart_port *port)
 static irqreturn_t clps711xuart_int_rx(int irq, void *dev_id)
 {
        struct uart_port *port = dev_id;
-        struct tty_struct *tty = port->info->tty;
+        struct tty_struct *tty = port->info->port.tty;
        unsigned int status, ch, flg;
        status = clps_readl(SYSFLG(port));
@@ -551,7 +548,7 @@ static int __init clps711xuart_init(void)
 {
        int ret, i;
-        printk(KERN_INFO "Serial: CLPS711x driver $Revision: 1.42 $\n");
+        printk(KERN_INFO "Serial: CLPS711x driver\n");
        ret = uart_register_driver(&clps711x_reg);
        if (ret)
@@ -577,6 +574,6 @@ module_init(clps711xuart_init);
 module_exit(clps711xuart_exit);
 MODULE_AUTHOR("Deep Blue Solutions Ltd");
-MODULE_DESCRIPTION("CLPS-711x generic serial driver $Revision: 1.42 $");
+MODULE_DESCRIPTION("CLPS-711x generic serial driver");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_CHARDEV(SERIAL_CLPS711X_MAJOR, SERIAL_CLPS711X_MINOR);
diff --git a/drivers/serial/cpm_uart/cpm_uart.h b/drivers/serial/cpm_uart/cpm_uart.h
index 5c76e0ae0582..7274b527a3c1 100644
--- a/drivers/serial/cpm_uart/cpm_uart.h
+++ b/drivers/serial/cpm_uart/cpm_uart.h
@@ -50,6 +50,15 @@
 #define SCC_WAIT_CLOSING 100
+#define GPIO_CTS        0
+#define GPIO_RTS        1
+#define GPIO_DCD        2
+#define GPIO_DSR        3
+#define GPIO_DTR        4
+#define GPIO_RI         5
+#define NUM_GPIOS       (GPIO_RI+1)
 struct uart_cpm_port {
        struct uart_port        port;
        u16                     rx_nrfifos;
@@ -68,6 +77,7 @@ struct uart_cpm_port {
        unsigned char           *rx_buf;
        u32                     flags;
        void                    (*set_lineif)(struct uart_cpm_port *);
+        struct clk              *clk;
        u8                      brg;
        uint                     dp_addr;
        void                    *mem_addr;
@@ -82,6 +92,7 @@ struct uart_cpm_port {
        int                     wait_closing;
        /* value to combine with opcode to form cpm command */
        u32                     command;
+        int                     gpios[NUM_GPIOS];
 };
 extern int cpm_uart_nr;
diff --git a/drivers/serial/cpm_uart/cpm_uart_core.c b/drivers/serial/cpm_uart/cpm_uart_core.c
index abe129cc927a..bde4b4b0b80f 100644
--- a/drivers/serial/cpm_uart/cpm_uart_core.c
+++ b/drivers/serial/cpm_uart/cpm_uart_core.c
@@ -43,6 +43,9 @@
 #include <linux/dma-mapping.h>
 #include <linux/fs_uart_pd.h>
 #include <linux/of_platform.h>
+#include <linux/gpio.h>
+#include <linux/of_gpio.h>
+#include <linux/clk.h>
 #include <asm/io.h>
 #include <asm/irq.h>
@@ -96,13 +99,41 @@ static unsigned int cpm_uart_tx_empty(struct uart_port *port)
 static void cpm_uart_set_mctrl(struct uart_port *port, unsigned int mctrl)
 {
-        /* Whee. Do nothing. */
+        struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
+        if (pinfo->gpios[GPIO_RTS] >= 0)
+                gpio_set_value(pinfo->gpios[GPIO_RTS], !(mctrl & TIOCM_RTS));
+        if (pinfo->gpios[GPIO_DTR] >= 0)
+                gpio_set_value(pinfo->gpios[GPIO_DTR], !(mctrl & TIOCM_DTR));
 }
 static unsigned int cpm_uart_get_mctrl(struct uart_port *port)
 {
-        /* Whee. Do nothing. */
+        struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
-        return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;
+        unsigned int mctrl = TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
+        if (pinfo->gpios[GPIO_CTS] >= 0) {
+                if (gpio_get_value(pinfo->gpios[GPIO_CTS]))
+                        mctrl &= ~TIOCM_CTS;
+        }
+        if (pinfo->gpios[GPIO_DSR] >= 0) {
+                if (gpio_get_value(pinfo->gpios[GPIO_DSR]))
+                        mctrl &= ~TIOCM_DSR;
+        }
+        if (pinfo->gpios[GPIO_DCD] >= 0) {
+                if (gpio_get_value(pinfo->gpios[GPIO_DCD]))
+                        mctrl &= ~TIOCM_CAR;
+        }
+        if (pinfo->gpios[GPIO_RI] >= 0) {
+                if (!gpio_get_value(pinfo->gpios[GPIO_RI]))
+                        mctrl |= TIOCM_RNG;
+        }
+        return mctrl;
 }
 /*
@@ -201,6 +232,10 @@ static void cpm_uart_int_tx(struct uart_port *port)
        cpm_uart_tx_pump(port);
 }
+#ifdef CONFIG_CONSOLE_POLL
+static int serial_polled;
+#endif
 /*
 * Receive characters
 */
@@ -209,7 +244,7 @@ static void cpm_uart_int_rx(struct uart_port *port)
        int i;
        unsigned char ch;
        u8 *cp;
-        struct tty_struct *tty = port->info->tty;
+        struct tty_struct *tty = port->info->port.tty;
        struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
        cbd_t __iomem *bdp;
        u16 status;
@@ -222,6 +257,12 @@ static void cpm_uart_int_rx(struct uart_port *port)
         */
        bdp = pinfo->rx_cur;
        for (;;) {
+#ifdef CONFIG_CONSOLE_POLL
+                if (unlikely(serial_polled)) {
+                        serial_polled = 0;
+                        return;
+                }
+#endif
                /* get status */
                status = in_be16(&bdp->cbd_sc);
                /* If this one is empty, return happy */
@@ -253,7 +294,12 @@ static void cpm_uart_int_rx(struct uart_port *port)
                                goto handle_error;
                        if (uart_handle_sysrq_char(port, ch))
                                continue;
+#ifdef CONFIG_CONSOLE_POLL
+                        if (unlikely(serial_polled)) {
+                                serial_polled = 0;
+                                return;
+                        }
+#endif
                      error_return:
                        tty_insert_flip_char(tty, ch, flg);
@@ -420,10 +466,13 @@ static void cpm_uart_shutdown(struct uart_port *port)
                }
                /* Shut them really down and reinit buffer descriptors */
-                if (IS_SMC(pinfo))
+                if (IS_SMC(pinfo)) {
+                        out_be16(&pinfo->smcup->smc_brkcr, 0);
                        cpm_line_cr_cmd(pinfo, CPM_CR_STOP_TX);
-                else
+                } else {
+                        out_be16(&pinfo->sccup->scc_brkcr, 0);
                        cpm_line_cr_cmd(pinfo, CPM_CR_GRA_STOP_TX);
+                }
                cpm_uart_initbd(pinfo);
        }
@@ -539,14 +588,19 @@ static void cpm_uart_set_termios(struct uart_port *port,
                 * enables, because we want to put them back if they were
                 * present.
                 */
-                prev_mode = in_be16(&smcp->smc_smcmr);
+                prev_mode = in_be16(&smcp->smc_smcmr) & (SMCMR_REN | SMCMR_TEN);
-                out_be16(&smcp->smc_smcmr, smcr_mk_clen(bits) | cval | SMCMR_SM_UART);
+                /* Output in *one* operation, so we don't interrupt RX/TX if they
-                setbits16(&smcp->smc_smcmr, (prev_mode & (SMCMR_REN | SMCMR_TEN)));
+                 * were already enabled. */
+                out_be16(&smcp->smc_smcmr, smcr_mk_clen(bits) | cval |
+                    SMCMR_SM_UART | prev_mode);
        } else {
                out_be16(&sccp->scc_psmr, (sbits << 12) | scval);
        }
-        cpm_set_brg(pinfo->brg - 1, baud);
+        if (pinfo->clk)
+                clk_set_rate(pinfo->clk, baud);
+        else
+                cpm_set_brg(pinfo->brg - 1, baud);
        spin_unlock_irqrestore(&port->lock, flags);
 }
@@ -569,7 +623,7 @@ static int cpm_uart_verify_port(struct uart_port *port,
        if (ser->type != PORT_UNKNOWN && ser->type != PORT_CPM)
                ret = -EINVAL;
-        if (ser->irq < 0 || ser->irq >= NR_IRQS)
+        if (ser->irq < 0 || ser->irq >= nr_irqs)
                ret = -EINVAL;
        if (ser->baud_base < 9600)
                ret = -EINVAL;
@@ -865,6 +919,80 @@ static void cpm_uart_config_port(struct uart_port *port, int flags)
                cpm_uart_request_port(port);
        }
 }
+#ifdef CONFIG_CONSOLE_POLL
+/* Serial polling routines for writing and reading from the uart while
+ * in an interrupt or debug context.
+ */
+#define GDB_BUF_SIZE    512     /* power of 2, please */
+static char poll_buf[GDB_BUF_SIZE];
+static char *pollp;
+static int poll_chars;
+static int poll_wait_key(char *obuf, struct uart_cpm_port *pinfo)
+{
+        u_char          c, *cp;
+        volatile cbd_t  *bdp;
+        int             i;
+        /* Get the address of the host memory buffer.
+         */
+        bdp = pinfo->rx_cur;
+        while (bdp->cbd_sc & BD_SC_EMPTY)
+                ;
+        /* If the buffer address is in the CPM DPRAM, don't
+         * convert it.
+         */
+        cp = cpm2cpu_addr(bdp->cbd_bufaddr, pinfo);
+        if (obuf) {
+                i = c = bdp->cbd_datlen;
+                while (i-- > 0)
+                        *obuf++ = *cp++;
+        } else
+                c = *cp;
+        bdp->cbd_sc &= ~(BD_SC_BR | BD_SC_FR | BD_SC_PR | BD_SC_OV | BD_SC_ID);
+        bdp->cbd_sc |= BD_SC_EMPTY;
+        if (bdp->cbd_sc & BD_SC_WRAP)
+                bdp = pinfo->rx_bd_base;
+        else
+                bdp++;
+        pinfo->rx_cur = (cbd_t *)bdp;
+        return (int)c;
+}
+static int cpm_get_poll_char(struct uart_port *port)
+{
+        struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
+        if (!serial_polled) {
+                serial_polled = 1;
+                poll_chars = 0;
+        }
+        if (poll_chars <= 0) {
+                poll_chars = poll_wait_key(poll_buf, pinfo);
+                pollp = poll_buf;
+        }
+        poll_chars--;
+        return *pollp++;
+}
+static void cpm_put_poll_char(struct uart_port *port,
+                         unsigned char c)
+{
+        struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
+        static char ch[2];
+        ch[0] = (char)c;
+        cpm_uart_early_write(pinfo->port.line, ch, 1);
+}
+#endif /* CONFIG_CONSOLE_POLL */
 static struct uart_ops cpm_uart_pops = {
        .tx_empty       = cpm_uart_tx_empty,
        .set_mctrl      = cpm_uart_set_mctrl,
@@ -882,6 +1010,10 @@ static struct uart_ops cpm_uart_pops = {
        .request_port   = cpm_uart_request_port,
        .config_port    = cpm_uart_config_port,
        .verify_port    = cpm_uart_verify_port,
+#ifdef CONFIG_CONSOLE_POLL
+        .poll_get_char = cpm_get_poll_char,
+        .poll_put_char = cpm_put_poll_char,
+#endif
 };
 struct uart_cpm_port cpm_uart_ports[UART_NR];
@@ -893,14 +1025,23 @@ static int cpm_uart_init_port(struct device_node *np,
        void __iomem *mem, *pram;
        int len;
        int ret;
+        int i;
-        data = of_get_property(np, "fsl,cpm-brg", &len);
+        data = of_get_property(np, "clock", NULL);
-        if (!data || len != 4) {
+        if (data) {
-                printk(KERN_ERR "CPM UART %s has no/invalid "
+                struct clk *clk = clk_get(NULL, (const char*)data);
-                                "fsl,cpm-brg property.\n", np->name);
+                if (!IS_ERR(clk))
-                return -EINVAL;
+                        pinfo->clk = clk;
+        }
+        if (!pinfo->clk) {
+                data = of_get_property(np, "fsl,cpm-brg", &len);
+                if (!data || len != 4) {
+                        printk(KERN_ERR "CPM UART %s has no/invalid "
+                                        "fsl,cpm-brg property.\n", np->name);
+                        return -EINVAL;
+                }
+                pinfo->brg = *data;
        }
-        pinfo->brg = *data;
        data = of_get_property(np, "fsl,cpm-command", &len);
        if (!data || len != 4) {
@@ -952,6 +1093,9 @@ static int cpm_uart_init_port(struct device_node *np,
                goto out_pram;
        }
+        for (i = 0; i < NUM_GPIOS; i++)
+                pinfo->gpios[i] = of_get_gpio(np, i);
        return cpm_uart_request_port(&pinfo->port);
 out_pram:
@@ -1105,12 +1249,14 @@ static int __init cpm_uart_console_setup(struct console *co, char *options)
        udbg_putc = NULL;
 #endif
-        cpm_line_cr_cmd(pinfo, CPM_CR_STOP_TX);
        if (IS_SMC(pinfo)) {
+                out_be16(&pinfo->smcup->smc_brkcr, 0);
+                cpm_line_cr_cmd(pinfo, CPM_CR_STOP_TX);
                clrbits8(&pinfo->smcp->smc_smcm, SMCM_RX | SMCM_TX);
                clrbits16(&pinfo->smcp->smc_smcmr, SMCMR_REN | SMCMR_TEN);
        } else {
+                out_be16(&pinfo->sccup->scc_brkcr, 0);
+                cpm_line_cr_cmd(pinfo, CPM_CR_GRA_STOP_TX);
                clrbits16(&pinfo->sccp->scc_sccm, UART_SCCM_TX | UART_SCCM_RX);
                clrbits32(&pinfo->sccp->scc_gsmrl, SCC_GSMRL_ENR | SCC_GSMRL_ENT);
        }
@@ -1187,6 +1333,9 @@ static int __devinit cpm_uart_probe(struct of_device *ofdev,
        if (ret)
                return ret;
+        /* initialize the device pointer for the port */
+        pinfo->port.dev = &ofdev->dev;
        return uart_add_one_port(&cpm_reg, &pinfo->port);
 }
diff --git a/drivers/serial/cpm_uart/cpm_uart_cpm1.c b/drivers/serial/cpm_uart/cpm_uart_cpm1.c
index 0f0aff06c596..1b94c56ec239 100644
--- a/drivers/serial/cpm_uart/cpm_uart_cpm1.c
+++ b/drivers/serial/cpm_uart/cpm_uart_cpm1.c
@@ -100,7 +100,7 @@ int cpm_uart_allocbuf(struct uart_cpm_port *pinfo, unsigned int is_con)
                mem_addr = (u8 *) cpm_dpram_addr(cpm_dpalloc(memsz, 8));
                dma_addr = (u32)cpm_dpram_phys(mem_addr);
        } else
-                mem_addr = dma_alloc_coherent(NULL, memsz, &dma_addr,
+                mem_addr = dma_alloc_coherent(pinfo->port.dev, memsz, &dma_addr,
                                              GFP_KERNEL);
        if (mem_addr == NULL) {
@@ -127,8 +127,8 @@ int cpm_uart_allocbuf(struct uart_cpm_port *pinfo, unsigned int is_con)
 void cpm_uart_freebuf(struct uart_cpm_port *pinfo)
 {
-        dma_free_coherent(NULL, L1_CACHE_ALIGN(pinfo->rx_nrfifos *
+        dma_free_coherent(pinfo->port.dev, L1_CACHE_ALIGN(pinfo->rx_nrfifos *
-                                               pinfo->rx_fifosize) +
+                                                          pinfo->rx_fifosize) +
                          L1_CACHE_ALIGN(pinfo->tx_nrfifos *
                                         pinfo->tx_fifosize), pinfo->mem_addr,
                          pinfo->dma_addr);
diff --git a/drivers/serial/cpm_uart/cpm_uart_cpm2.c b/drivers/serial/cpm_uart/cpm_uart_cpm2.c
index b8db4d3eed36..141c0a3333ad 100644
--- a/drivers/serial/cpm_uart/cpm_uart_cpm2.c
+++ b/drivers/serial/cpm_uart/cpm_uart_cpm2.c
@@ -136,7 +136,7 @@ int cpm_uart_allocbuf(struct uart_cpm_port *pinfo, unsigned int is_con)
                dma_addr = virt_to_bus(mem_addr);
        }
        else
-                mem_addr = dma_alloc_coherent(NULL, memsz, &dma_addr,
+                mem_addr = dma_alloc_coherent(pinfo->port.dev, memsz, &dma_addr,
                                              GFP_KERNEL);
        if (mem_addr == NULL) {
@@ -163,8 +163,8 @@ int cpm_uart_allocbuf(struct uart_cpm_port *pinfo, unsigned int is_con)
 void cpm_uart_freebuf(struct uart_cpm_port *pinfo)
 {
-        dma_free_coherent(NULL, L1_CACHE_ALIGN(pinfo->rx_nrfifos *
+        dma_free_coherent(pinfo->port.dev, L1_CACHE_ALIGN(pinfo->rx_nrfifos *
-                                               pinfo->rx_fifosize) +
+                                                          pinfo->rx_fifosize) +
                          L1_CACHE_ALIGN(pinfo->tx_nrfifos *
                                         pinfo->tx_fifosize), (void __force *)pinfo->mem_addr,
                          pinfo->dma_addr);
diff --git a/drivers/serial/crisv10.c b/drivers/serial/crisv10.c
index 3e0366eab412..211c21797ce0 100644
--- a/drivers/serial/crisv10.c
+++ b/drivers/serial/crisv10.c
@@ -234,7 +234,7 @@ unsigned long r_alt_ser_baudrate_shadow = 0;
 static struct e100_serial rs_table[] = {
        { .baud        = DEF_BAUD,
-          .port        = (unsigned char *)R_SERIAL0_CTRL,
+          .ioport        = (unsigned char *)R_SERIAL0_CTRL,
          .irq         = 1U << 12, /* uses DMA 6 and 7 */
          .oclrintradr = R_DMA_CH6_CLR_INTR,
          .ofirstadr   = R_DMA_CH6_FIRST,
@@ -288,7 +288,7 @@ static struct e100_serial rs_table[] = {
 },  /* ttyS0 */
 #ifndef CONFIG_SVINTO_SIM
        { .baud        = DEF_BAUD,
-          .port        = (unsigned char *)R_SERIAL1_CTRL,
+          .ioport        = (unsigned char *)R_SERIAL1_CTRL,
          .irq         = 1U << 16, /* uses DMA 8 and 9 */
          .oclrintradr = R_DMA_CH8_CLR_INTR,
          .ofirstadr   = R_DMA_CH8_FIRST,
@@ -344,7 +344,7 @@ static struct e100_serial rs_table[] = {
 },  /* ttyS1 */
        { .baud        = DEF_BAUD,
-          .port        = (unsigned char *)R_SERIAL2_CTRL,
+          .ioport        = (unsigned char *)R_SERIAL2_CTRL,
          .irq         = 1U << 4,  /* uses DMA 2 and 3 */
          .oclrintradr = R_DMA_CH2_CLR_INTR,
          .ofirstadr   = R_DMA_CH2_FIRST,
@@ -398,7 +398,7 @@ static struct e100_serial rs_table[] = {
 },  /* ttyS2 */
        { .baud        = DEF_BAUD,
-          .port        = (unsigned char *)R_SERIAL3_CTRL,
+          .ioport        = (unsigned char *)R_SERIAL3_CTRL,
          .irq         = 1U << 8,  /* uses DMA 4 and 5 */
          .oclrintradr = R_DMA_CH4_CLR_INTR,
          .ofirstadr   = R_DMA_CH4_FIRST,
@@ -457,7 +457,6 @@ static struct e100_serial rs_table[] = {
 #define NR_PORTS (sizeof(rs_table)/sizeof(struct e100_serial))
 static struct ktermios *serial_termios[NR_PORTS];
-static struct ktermios *serial_termios_locked[NR_PORTS];
 #ifdef CONFIG_ETRAX_SERIAL_FAST_TIMER
 static struct fast_timer fast_timers[NR_PORTS];
 #endif
@@ -939,7 +938,7 @@ static const struct control_pins e100_modem_pins[NR_PORTS] =
 /* Output */
 #define E100_RTS_GET(info) ((info)->rx_ctrl & E100_RTS_MASK)
 /* Input */
-#define E100_CTS_GET(info) ((info)->port[REG_STATUS] & E100_CTS_MASK)
+#define E100_CTS_GET(info) ((info)->ioport[REG_STATUS] & E100_CTS_MASK)
 /* These are typically PA or PB and 0 means 0V, 1 means 3.3V */
 /* Is an output */
@@ -968,7 +967,7 @@ static DEFINE_MUTEX(tmp_buf_mutex);
 /* Calculate the chartime depending on baudrate, numbor of bits etc. */
 static void update_char_time(struct e100_serial * info)
 {
-        tcflag_t cflags = info->tty->termios->c_cflag;
+        tcflag_t cflags = info->port.tty->termios->c_cflag;
        int bits;
        /* calc. number of bits / data byte */
@@ -1092,7 +1091,7 @@ e100_rts(struct e100_serial *info, int set)
        local_irq_save(flags);
        info->rx_ctrl &= ~E100_RTS_MASK;
        info->rx_ctrl |= (set ? 0 : E100_RTS_MASK);  /* RTS is active low */
-        info->port[REG_REC_CTRL] = info->rx_ctrl;
+        info->ioport[REG_REC_CTRL] = info->rx_ctrl;
        local_irq_restore(flags);
 #ifdef SERIAL_DEBUG_IO
        printk("ser%i rts %i\n", info->line, set);
@@ -1142,7 +1141,7 @@ e100_disable_rx(struct e100_serial *info)
 {
 #ifndef CONFIG_SVINTO_SIM
        /* disable the receiver */
-        info->port[REG_REC_CTRL] =
+        info->ioport[REG_REC_CTRL] =
                (info->rx_ctrl &= ~IO_MASK(R_SERIAL0_REC_CTRL, rec_enable));
 #endif
 }
@@ -1152,7 +1151,7 @@ e100_enable_rx(struct e100_serial *info)
 {
 #ifndef CONFIG_SVINTO_SIM
        /* enable the receiver */
-        info->port[REG_REC_CTRL] =
+        info->ioport[REG_REC_CTRL] =
                (info->rx_ctrl |= IO_MASK(R_SERIAL0_REC_CTRL, rec_enable));
 #endif
 }
@@ -1483,13 +1482,14 @@ rs_stop(struct tty_struct *tty)
                                CIRC_CNT(info->xmit.head,
                                         info->xmit.tail,SERIAL_XMIT_SIZE)));
-                xoff = IO_FIELD(R_SERIAL0_XOFF, xoff_char, STOP_CHAR(info->tty));
+                xoff = IO_FIELD(R_SERIAL0_XOFF, xoff_char,
+                                STOP_CHAR(info->port.tty));
                xoff |= IO_STATE(R_SERIAL0_XOFF, tx_stop, stop);
                if (tty->termios->c_iflag & IXON ) {
                        xoff |= IO_STATE(R_SERIAL0_XOFF, auto_xoff, enable);
                }
-                *((unsigned long *)&info->port[REG_XOFF]) = xoff;
+                *((unsigned long *)&info->ioport[REG_XOFF]) = xoff;
                local_irq_restore(flags);
        }
 }
@@ -1512,7 +1512,7 @@ rs_start(struct tty_struct *tty)
                        xoff |= IO_STATE(R_SERIAL0_XOFF, auto_xoff, enable);
                }
-                *((unsigned long *)&info->port[REG_XOFF]) = xoff;
+                *((unsigned long *)&info->ioport[REG_XOFF]) = xoff;
                if (!info->uses_dma_out &&
                    info->xmit.head != info->xmit.tail && info->xmit.buf)
                        e100_enable_serial_tx_ready_irq(info);
@@ -1772,7 +1772,7 @@ add_char_and_flag(struct e100_serial *info, unsigned char data, unsigned char fl
                info->icount.rx++;
        } else {
-                struct tty_struct *tty = info->tty;
+                struct tty_struct *tty = info->port.tty;
                tty_insert_flip_char(tty, data, flag);
                info->icount.rx++;
        }
@@ -1838,7 +1838,7 @@ static unsigned int handle_all_descr_data(struct e100_serial *info)
                descr->status = 0;
                DFLOW(  DEBUG_LOG(info->line, "RX %lu\n", recvl);
-                        if (info->tty->stopped) {
+                        if (info->port.tty->stopped) {
                                unsigned char *buf = phys_to_virt(descr->buf);
                                DEBUG_LOG(info->line, "rx 0x%02X\n", buf[0]);
                                DEBUG_LOG(info->line, "rx 0x%02X\n", buf[1]);
@@ -1872,7 +1872,7 @@ static void receive_chars_dma(struct e100_serial *info)
                IO_STATE(R_DMA_CH6_CLR_INTR, clr_descr, do) |
                IO_STATE(R_DMA_CH6_CLR_INTR, clr_eop, do);
-        tty = info->tty;
+        tty = info->port.tty;
        if (!tty) /* Something wrong... */
                return;
@@ -1887,7 +1887,7 @@ static void receive_chars_dma(struct e100_serial *info)
        handle_all_descr_data(info);
        /* Read the status register to detect errors */
-        rstat = info->port[REG_STATUS];
+        rstat = info->ioport[REG_STATUS];
        if (rstat & IO_MASK(R_SERIAL0_STATUS, xoff_detect) ) {
                DFLOW(DEBUG_LOG(info->line, "XOFF detect stat %x\n", rstat));
        }
@@ -1896,7 +1896,7 @@ static void receive_chars_dma(struct e100_serial *info)
                /* If we got an error, we must reset it by reading the
                 * data_in field
                 */
-                unsigned char data = info->port[REG_DATA];
+                unsigned char data = info->ioport[REG_DATA];
                PROCSTAT(ser_stat[info->line].errors_cnt++);
                DEBUG_LOG(info->line, "#dERR: s d 0x%04X\n",
@@ -2076,7 +2076,7 @@ static int force_eop_if_needed(struct e100_serial *info)
        /* We check data_avail bit to determine if data has
         * arrived since last time
         */
-        unsigned char rstat = info->port[REG_STATUS];
+        unsigned char rstat = info->ioport[REG_STATUS];
        /* error or datavail? */
        if (rstat & SER_ERROR_MASK) {
@@ -2095,7 +2095,7 @@ static int force_eop_if_needed(struct e100_serial *info)
                TIMERD(DEBUG_LOG(info->line, "timeout: rstat 0x%03X\n",
                          rstat | (info->line << 8)));
                /* Read data to clear status flags */
-                (void)info->port[REG_DATA];
+                (void)info->ioport[REG_DATA];
                info->forced_eop = 0;
                START_FLUSH_FAST_TIMER(info, "magic");
@@ -2122,7 +2122,7 @@ static void flush_to_flip_buffer(struct e100_serial *info)
        unsigned long flags;
        local_irq_save(flags);
-        tty = info->tty;
+        tty = info->port.tty;
        if (!tty) {
                local_irq_restore(flags);
@@ -2287,7 +2287,7 @@ static
 struct e100_serial * handle_ser_rx_interrupt_no_dma(struct e100_serial *info)
 {
        unsigned long data_read;
-        struct tty_struct *tty = info->tty;
+        struct tty_struct *tty = info->port.tty;
        if (!tty) {
                printk("!NO TTY!\n");
@@ -2295,7 +2295,7 @@ struct e100_serial * handle_ser_rx_interrupt_no_dma(struct e100_serial *info)
        }
        /* Read data and status at the same time */
-        data_read = *((unsigned long *)&info->port[REG_DATA_STATUS32]);
+        data_read = *((unsigned long *)&info->ioport[REG_DATA_STATUS32]);
 more_data:
        if (data_read & IO_MASK(R_SERIAL0_READ, xoff_detect) ) {
                DFLOW(DEBUG_LOG(info->line, "XOFF detect\n", 0));
@@ -2350,7 +2350,7 @@ more_data:
                                        data_in, data_read);
                                char flag = TTY_NORMAL;
                                if (info->errorcode == ERRCODE_INSERT_BREAK) {
-                                        struct tty_struct *tty = info->tty;
+                                        struct tty_struct *tty = info->port.tty;
                                        tty_insert_flip_char(tty, 0, flag);
                                        info->icount.rx++;
                                }
@@ -2390,13 +2390,13 @@ more_data:
        info->icount.rx++;
-        data_read = *((unsigned long *)&info->port[REG_DATA_STATUS32]);
+        data_read = *((unsigned long *)&info->ioport[REG_DATA_STATUS32]);
        if (data_read & IO_MASK(R_SERIAL0_READ, data_avail)) {
                DEBUG_LOG(info->line, "ser_rx   %c in loop\n", IO_EXTRACT(R_SERIAL0_READ, data_in, data_read));
                goto more_data;
        }
-        tty_flip_buffer_push(info->tty);
+        tty_flip_buffer_push(info->port.tty);
        return info;
 }
@@ -2412,7 +2412,7 @@ static struct e100_serial* handle_ser_rx_interrupt(struct e100_serial *info)
                return handle_ser_rx_interrupt_no_dma(info);
        }
        /* DMA is used */
-        rstat = info->port[REG_STATUS];
+        rstat = info->ioport[REG_STATUS];
        if (rstat & IO_MASK(R_SERIAL0_STATUS, xoff_detect) ) {
                DFLOW(DEBUG_LOG(info->line, "XOFF detect\n", 0));
        }
@@ -2425,7 +2425,7 @@ static struct e100_serial* handle_ser_rx_interrupt(struct e100_serial *info)
                /* If we got an error, we must reset it by reading the
                 * data_in field
                 */
-                data = info->port[REG_DATA];
+                data = info->ioport[REG_DATA];
                DINTR1(DEBUG_LOG(info->line, "ser_rx!  %c\n", data));
                DINTR1(DEBUG_LOG(info->line, "ser_rx err stat %02X\n", rstat));
                if (!data && (rstat & SER_FRAMING_ERR_MASK)) {
@@ -2527,10 +2527,10 @@ static void handle_ser_tx_interrupt(struct e100_serial *info)
                unsigned char rstat;
                DFLOW(DEBUG_LOG(info->line, "tx_int: xchar 0x%02X\n", info->x_char));
                local_irq_save(flags);
-                rstat = info->port[REG_STATUS];
+                rstat = info->ioport[REG_STATUS];
                DFLOW(DEBUG_LOG(info->line, "stat %x\n", rstat));
-                info->port[REG_TR_DATA] = info->x_char;
+                info->ioport[REG_TR_DATA] = info->x_char;
                info->icount.tx++;
                info->x_char = 0;
                /* We must enable since it is disabled in ser_interrupt */
@@ -2544,11 +2544,11 @@ static void handle_ser_tx_interrupt(struct e100_serial *info)
                /* We only use normal tx interrupt when sending x_char */
                DFLOW(DEBUG_LOG(info->line, "tx_int: xchar sent\n", 0));
                local_irq_save(flags);
-                rstat = info->port[REG_STATUS];
+                rstat = info->ioport[REG_STATUS];
                DFLOW(DEBUG_LOG(info->line, "stat %x\n", rstat));
                e100_disable_serial_tx_ready_irq(info);
-                if (info->tty->stopped)
+                if (info->port.tty->stopped)
-                        rs_stop(info->tty);
+                        rs_stop(info->port.tty);
                /* Enable the DMA channel and tell it to continue */
                e100_enable_txdma_channel(info);
                /* Wait 12 cycles before doing the DMA command */
@@ -2561,9 +2561,10 @@ static void handle_ser_tx_interrupt(struct e100_serial *info)
        }
        /* Normal char-by-char interrupt */
        if (info->xmit.head == info->xmit.tail
-            || info->tty->stopped
+            || info->port.tty->stopped
-            || info->tty->hw_stopped) {
+            || info->port.tty->hw_stopped) {
-                DFLOW(DEBUG_LOG(info->line, "tx_int: stopped %i\n", info->tty->stopped));
+                DFLOW(DEBUG_LOG(info->line, "tx_int: stopped %i\n",
+                                info->port.tty->stopped));
                e100_disable_serial_tx_ready_irq(info);
                info->tr_running = 0;
                return;
@@ -2571,7 +2572,7 @@ static void handle_ser_tx_interrupt(struct e100_serial *info)
        DINTR2(DEBUG_LOG(info->line, "tx_int %c\n", info->xmit.buf[info->xmit.tail]));
        /* Send a byte, rs485 timing is critical so turn of ints */
        local_irq_save(flags);
-        info->port[REG_TR_DATA] = info->xmit.buf[info->xmit.tail];
+        info->ioport[REG_TR_DATA] = info->xmit.buf[info->xmit.tail];
        info->xmit.tail = (info->xmit.tail + 1) & (SERIAL_XMIT_SIZE-1);
        info->icount.tx++;
        if (info->xmit.head == info->xmit.tail) {
@@ -2725,7 +2726,7 @@ do_softint(struct work_struct *work)
        info = container_of(work, struct e100_serial, work);
-        tty = info->tty;
+        tty = info->port.tty;
        if (!tty)
                return;
@@ -2767,8 +2768,8 @@ startup(struct e100_serial * info)
        /* Bits and pieces collected from below.  Better to have them
           in one ifdef:ed clause than to mix in a lot of ifdefs,
           right? */
-        if (info->tty)
+        if (info->port.tty)
-                clear_bit(TTY_IO_ERROR, &info->tty->flags);
+                clear_bit(TTY_IO_ERROR, &info->port.tty->flags);
        info->xmit.head = info->xmit.tail = 0;
        info->first_recv_buffer = info->last_recv_buffer = NULL;
@@ -2825,8 +2826,8 @@ startup(struct e100_serial * info)
                e100_disable_txdma_channel(info);
        }
-        if (info->tty)
+        if (info->port.tty)
-                clear_bit(TTY_IO_ERROR, &info->tty->flags);
+                clear_bit(TTY_IO_ERROR, &info->port.tty->flags);
        info->xmit.head = info->xmit.tail = 0;
        info->first_recv_buffer = info->last_recv_buffer = NULL;
@@ -2846,7 +2847,7 @@ startup(struct e100_serial * info)
        /* dummy read to reset any serial errors */
-        (void)info->port[REG_DATA];
+        (void)info->ioport[REG_DATA];
        /* enable the interrupts */
        if (info->uses_dma_out)
@@ -2895,7 +2896,7 @@ shutdown(struct e100_serial * info)
        /* shut down the transmitter and receiver */
        DFLOW(DEBUG_LOG(info->line, "shutdown %i\n", info->line));
        e100_disable_rx(info);
-        info->port[REG_TR_CTRL] = (info->tx_ctrl &= ~0x40);
+        info->ioport[REG_TR_CTRL] = (info->tx_ctrl &= ~0x40);
        /* disable interrupts, reset dma channels */
        if (info->uses_dma_in) {
@@ -2940,14 +2941,14 @@ shutdown(struct e100_serial * info)
                        descr[i].buf = 0;
                }
-        if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
+        if (!info->port.tty || (info->port.tty->termios->c_cflag & HUPCL)) {
                /* hang up DTR and RTS if HUPCL is enabled */
                e100_dtr(info, 0);
                e100_rts(info, 0); /* could check CRTSCTS before doing this */
        }
-        if (info->tty)
+        if (info->port.tty)
-                set_bit(TTY_IO_ERROR, &info->tty->flags);
+                set_bit(TTY_IO_ERROR, &info->port.tty->flags);
        info->flags &= ~ASYNC_INITIALIZED;
        local_irq_restore(flags);
@@ -2964,12 +2965,12 @@ change_speed(struct e100_serial *info)
        unsigned long flags;
        /* first some safety checks */
-        if (!info->tty || !info->tty->termios)
+        if (!info->port.tty || !info->port.tty->termios)
                return;
-        if (!info->port)
+        if (!info->ioport)
                return;
-        cflag = info->tty->termios->c_cflag;
+        cflag = info->port.tty->termios->c_cflag;
        /* possibly, the tx/rx should be disabled first to do this safely */
@@ -3035,7 +3036,7 @@ change_speed(struct e100_serial *info)
                info->baud = cflag_to_baud(cflag);
 #ifndef CONFIG_SVINTO_SIM
-                info->port[REG_BAUD] = cflag_to_etrax_baud(cflag);
+                info->ioport[REG_BAUD] = cflag_to_etrax_baud(cflag);
 #endif /* CONFIG_SVINTO_SIM */
        }
@@ -3095,16 +3096,17 @@ change_speed(struct e100_serial *info)
        /* actually write the control regs to the hardware */
-        info->port[REG_TR_CTRL] = info->tx_ctrl;
+        info->ioport[REG_TR_CTRL] = info->tx_ctrl;
-        info->port[REG_REC_CTRL] = info->rx_ctrl;
+        info->ioport[REG_REC_CTRL] = info->rx_ctrl;
-        xoff = IO_FIELD(R_SERIAL0_XOFF, xoff_char, STOP_CHAR(info->tty));
+        xoff = IO_FIELD(R_SERIAL0_XOFF, xoff_char, STOP_CHAR(info->port.tty));
        xoff |= IO_STATE(R_SERIAL0_XOFF, tx_stop, enable);
-        if (info->tty->termios->c_iflag & IXON ) {
+        if (info->port.tty->termios->c_iflag & IXON ) {
-                DFLOW(DEBUG_LOG(info->line, "FLOW XOFF enabled 0x%02X\n", STOP_CHAR(info->tty)));
+                DFLOW(DEBUG_LOG(info->line, "FLOW XOFF enabled 0x%02X\n",
+                                STOP_CHAR(info->port.tty)));
                xoff |= IO_STATE(R_SERIAL0_XOFF, auto_xoff, enable);
        }
-        *((unsigned long *)&info->port[REG_XOFF]) = xoff;
+        *((unsigned long *)&info->ioport[REG_XOFF]) = xoff;
        local_irq_restore(flags);
 #endif /* !CONFIG_SVINTO_SIM */
@@ -3153,7 +3155,7 @@ static int rs_raw_write(struct tty_struct *tty,
 #ifdef SERIAL_DEBUG_DATA
        if (info->line == SERIAL_DEBUG_LINE)
                printk("rs_raw_write (%d), status %d\n",
-                       count, info->port[REG_STATUS]);
+                       count, info->ioport[REG_STATUS]);
 #endif
 #ifdef CONFIG_SVINTO_SIM
@@ -3424,7 +3426,7 @@ get_serial_info(struct e100_serial * info,
        memset(&tmp, 0, sizeof(tmp));
        tmp.type = info->type;
        tmp.line = info->line;
-        tmp.port = (int)info->port;
+        tmp.port = (int)info->ioport;
        tmp.irq = info->irq;
        tmp.flags = info->flags;
        tmp.baud_base = info->baud_base;
@@ -3475,7 +3477,7 @@ set_serial_info(struct e100_serial *info,
        info->type = new_serial.type;
        info->close_delay = new_serial.close_delay;
        info->closing_wait = new_serial.closing_wait;
-        info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
+        info->port.tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
 check_and_exit:
        if (info->flags & ASYNC_INITIALIZED) {
@@ -3554,14 +3556,14 @@ char *get_control_state_str(int MLines, char *s)
 }
 #endif
-static void
+static int
 rs_break(struct tty_struct *tty, int break_state)
 {
        struct e100_serial *info = (struct e100_serial *)tty->driver_data;
        unsigned long flags;
-        if (!info->port)
+        if (!info->ioport)
-                return;
+                return -EIO;
        local_irq_save(flags);
        if (break_state == -1) {
@@ -3572,8 +3574,9 @@ rs_break(struct tty_struct *tty, int break_state)
                /* Set bit 7 (txd) and 6 (tr_enable) */
                info->tx_ctrl |= (0x80 | 0x40);
        }
-        info->port[REG_TR_CTRL] = info->tx_ctrl;
+        info->ioport[REG_TR_CTRL] = info->tx_ctrl;
        local_irq_restore(flags);
+        return 0;
 }
 static int
@@ -3811,7 +3814,7 @@ rs_close(struct tty_struct *tty, struct file * filp)
        tty_ldisc_flush(tty);
        tty->closing = 0;
        info->event = 0;
-        info->tty = 0;
+        info->port.tty = NULL;
        if (info->blocked_open) {
                if (info->close_delay)
                        schedule_timeout_interruptible(info->close_delay);
@@ -3915,7 +3918,7 @@ rs_hangup(struct tty_struct *tty)
        info->event = 0;
        info->count = 0;
        info->flags &= ~ASYNC_NORMAL_ACTIVE;
-        info->tty = 0;
+        info->port.tty = NULL;
        wake_up_interruptible(&info->open_wait);
 }
@@ -4077,9 +4080,9 @@ rs_open(struct tty_struct *tty, struct file * filp)
        info->count++;
        tty->driver_data = info;
-        info->tty = tty;
+        info->port.tty = tty;
-        info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
+        info->port.tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
        if (!tmp_buf) {
                page = get_zeroed_page(GFP_KERNEL);
@@ -4228,9 +4231,9 @@ static int line_info(char *buf, struct e100_serial *info)
        unsigned long tmp;
        ret = sprintf(buf, "%d: uart:E100 port:%lX irq:%d",
-                      info->line, (unsigned long)info->port, info->irq);
+                      info->line, (unsigned long)info->ioport, info->irq);
-        if (!info->port || (info->type == PORT_UNKNOWN)) {
+        if (!info->ioport || (info->type == PORT_UNKNOWN)) {
                ret += sprintf(buf+ret, "\n");
                return ret;
        }
@@ -4267,18 +4270,18 @@ static int line_info(char *buf, struct e100_serial *info)
                       (unsigned long)info->max_recv_cnt);
 #if 1
-        if (info->tty) {
+        if (info->port.tty) {
-                if (info->tty->stopped)
+                if (info->port.tty->stopped)
                        ret += sprintf(buf+ret, " stopped:%i",
-                                       (int)info->tty->stopped);
+                                       (int)info->port.tty->stopped);
-                if (info->tty->hw_stopped)
+                if (info->port.tty->hw_stopped)
                        ret += sprintf(buf+ret, " hw_stopped:%i",
-                                       (int)info->tty->hw_stopped);
+                                       (int)info->port.tty->hw_stopped);
        }
        {
-                unsigned char rstat = info->port[REG_STATUS];
+                unsigned char rstat = info->ioport[REG_STATUS];
                if (rstat & IO_MASK(R_SERIAL0_STATUS, xoff_detect) )
                        ret += sprintf(buf+ret, " xoff_detect:1");
        }
@@ -4415,6 +4418,7 @@ rs_init(void)
                        rs485_pa_bit)) {
                printk(KERN_CRIT "ETRAX100LX serial: Could not allocate "
                        "RS485 pin\n");
+                put_tty_driver(driver);
                return -EBUSY;
        }
 #endif
@@ -4423,6 +4427,7 @@ rs_init(void)
                        rs485_port_g_bit)) {
                printk(KERN_CRIT "ETRAX100LX serial: Could not allocate "
                        "RS485 pin\n");
+                put_tty_driver(driver);
                return -EBUSY;
        }
 #endif
@@ -4442,8 +4447,6 @@ rs_init(void)
        driver->init_termios.c_ispeed = 115200;
        driver->init_termios.c_ospeed = 115200;
        driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
-        driver->termios = serial_termios;
-        driver->termios_locked = serial_termios_locked;
        tty_set_operations(driver, &rs_ops);
        serial_driver = driver;
@@ -4465,7 +4468,7 @@ rs_init(void)
                info->uses_dma_in = 0;
                info->uses_dma_out = 0;
                info->line = i;
-                info->tty = 0;
+                info->port.tty = NULL;
                info->type = PORT_ETRAX;
                info->tr_running = 0;
                info->forced_eop = 0;
@@ -4499,7 +4502,7 @@ rs_init(void)
                if (info->enabled) {
                        printk(KERN_INFO "%s%d at 0x%x is a builtin UART with DMA\n",
-                               serial_driver->name, info->line, (unsigned int)info->port);
+                               serial_driver->name, info->line, (unsigned int)info->ioport);
                }
        }
 #ifdef CONFIG_ETRAX_FAST_TIMER
diff --git a/drivers/serial/crisv10.h b/drivers/serial/crisv10.h
index ccd0f32b7372..e3c5c8c3c09b 100644
--- a/drivers/serial/crisv10.h
+++ b/drivers/serial/crisv10.h
@@ -36,8 +36,9 @@ struct etrax_recv_buffer {
 };
 struct e100_serial {
+        struct tty_port port;
        int baud;
-        volatile u8     *port;  /* R_SERIALx_CTRL */
+        volatile u8     *ioport;        /* R_SERIALx_CTRL */
        u32             irq;    /* bitnr in R_IRQ_MASK2 for dmaX_descr */
        /* Output registers */
diff --git a/drivers/serial/dz.c b/drivers/serial/dz.c
index 0dddd68b20d2..6042b87797a1 100644
--- a/drivers/serial/dz.c
+++ b/drivers/serial/dz.c
@@ -197,7 +197,7 @@ static inline void dz_receive_chars(struct dz_mux *mux)
        while ((status = dz_in(dport, DZ_RBUF)) & DZ_DVAL) {
                dport = &mux->dport[LINE(status)];
                uport = &dport->port;
-                tty = uport->info->tty;         /* point to the proper dev */
+                tty = uport->info->port.tty;    /* point to the proper dev */
                ch = UCHAR(status);             /* grab the char */
                flag = TTY_NORMAL;
@@ -249,7 +249,7 @@ static inline void dz_receive_chars(struct dz_mux *mux)
        }
        for (i = 0; i < DZ_NB_PORT; i++)
                if (lines_rx[i])
-                        tty_flip_buffer_push(mux->dport[i].port.info->tty);
+                        tty_flip_buffer_push(mux->dport[i].port.info->port.tty);
 }
 /*
@@ -642,6 +642,26 @@ static void dz_set_termios(struct uart_port *uport, struct ktermios *termios,
        spin_unlock_irqrestore(&dport->port.lock, flags);
 }
+/*
+ * Hack alert!
+ * Required solely so that the initial PROM-based console
+ * works undisturbed in parallel with this one.
+ */
+static void dz_pm(struct uart_port *uport, unsigned int state,
+                  unsigned int oldstate)
+{
+        struct dz_port *dport = to_dport(uport);
+        unsigned long flags;
+        spin_lock_irqsave(&dport->port.lock, flags);
+        if (state < 3)
+                dz_start_tx(&dport->port);
+        else
+                dz_stop_tx(&dport->port);
+        spin_unlock_irqrestore(&dport->port.lock, flags);
+}
 static const char *dz_type(struct uart_port *uport)
 {
        return "DZ";
@@ -738,6 +758,7 @@ static struct uart_ops dz_ops = {
        .startup        = dz_startup,
        .shutdown       = dz_shutdown,
        .set_termios    = dz_set_termios,
+        .pm             = dz_pm,
        .type           = dz_type,
        .release_port   = dz_release_port,
        .request_port   = dz_request_port,
@@ -861,7 +882,10 @@ static int __init dz_console_setup(struct console *co, char *options)
        if (ret)
                return ret;
+        spin_lock_init(&dport->port.lock);      /* For dz_pm().  */
        dz_reset(dport);
+        dz_pm(uport, 0, -1);
        if (options)
                uart_parse_options(options, &baud, &parity, &bits, &flow);
diff --git a/drivers/serial/icom.c b/drivers/serial/icom.c
index 9c2df5c857cf..2b7531d9f6ab 100644
--- a/drivers/serial/icom.c
+++ b/drivers/serial/icom.c
@@ -730,7 +730,7 @@ static void xmit_interrupt(u16 port_int_reg, struct icom_port *icom_port)
 static void recv_interrupt(u16 port_int_reg, struct icom_port *icom_port)
 {
        short int count, rcv_buff;
-        struct tty_struct *tty = icom_port->uart_port.info->tty;
+        struct tty_struct *tty = icom_port->uart_port.info->port.tty;
        unsigned short int status;
        struct uart_icount *icount;
        unsigned long offset;
diff --git a/drivers/serial/imx.c b/drivers/serial/imx.c
index 64acb39a51ba..3f90f1bbbbcd 100644
--- a/drivers/serial/imx.c
+++ b/drivers/serial/imx.c
@@ -44,8 +44,8 @@
 #include <asm/io.h>
 #include <asm/irq.h>
-#include <asm/hardware.h>
+#include <mach/hardware.h>
-#include <asm/arch/imx-uart.h>
+#include <mach/imx-uart.h>
 /* Register definitions */
 #define URXD0 0x0  /* Receiver Register */
@@ -127,8 +127,13 @@
 #define  UCR3_RXDSEN     (1<<6)  /* Receive status interrupt enable */
 #define  UCR3_AIRINTEN   (1<<5)  /* Async IR wake interrupt enable */
 #define  UCR3_AWAKEN     (1<<4)  /* Async wake interrupt enable */
-#define  UCR3_REF25      (1<<3)  /* Ref freq 25 MHz */
+#ifdef CONFIG_ARCH_IMX
-#define  UCR3_REF30      (1<<2)  /* Ref Freq 30 MHz */
+#define  UCR3_REF25      (1<<3)  /* Ref freq 25 MHz, only on mx1 */
+#define  UCR3_REF30      (1<<2)  /* Ref Freq 30 MHz, only on mx1 */
+#endif
+#if defined CONFIG_ARCH_MX2 || defined CONFIG_ARCH_MX3
+#define  UCR3_RXDMUXSEL  (1<<2)  /* RXD Muxed Input Select, on mx2/mx3 */
+#endif
 #define  UCR3_INVT       (1<<1)  /* Inverted Infrared transmission */
 #define  UCR3_BPEN       (1<<0)  /* Preset registers enable */
 #define  UCR4_CTSTL_32   (32<<10) /* CTS trigger level (32 chars) */
@@ -372,7 +377,7 @@ static irqreturn_t imx_rxint(int irq, void *dev_id)
 {
        struct imx_port *sport = dev_id;
        unsigned int rx,flg,ignored = 0;
-        struct tty_struct *tty = sport->port.info->tty;
+        struct tty_struct *tty = sport->port.info->port.tty;
        unsigned long flags, temp;
        spin_lock_irqsave(&sport->port.lock,flags);
@@ -445,7 +450,7 @@ static irqreturn_t imx_int(int irq, void *dev_id)
                        readl(sport->port.membase + UCR1) & UCR1_TXMPTYEN)
                imx_txint(irq, dev_id);
-        if (sts & USR1_RTSS)
+        if (sts & USR1_RTSD)
                imx_rtsint(irq, dev_id);
        return IRQ_HANDLED;
@@ -598,6 +603,12 @@ static int imx_startup(struct uart_port *port)
        temp |= (UCR2_RXEN | UCR2_TXEN);
        writel(temp, sport->port.membase + UCR2);
+#if defined CONFIG_ARCH_MX2 || defined CONFIG_ARCH_MX3
+        temp = readl(sport->port.membase + UCR3);
+        temp |= UCR3_RXDMUXSEL;
+        writel(temp, sport->port.membase + UCR3);
+#endif
        /*
         * Enable modem status interrupts
         */
@@ -1133,13 +1144,19 @@ static int serial_imx_probe(struct platform_device *pdev)
        if(pdata && (pdata->flags & IMXUART_HAVE_RTSCTS))
                sport->have_rtscts = 1;
-        if (pdata->init)
+        if (pdata->init) {
-                pdata->init(pdev);
+                ret = pdata->init(pdev);
+                if (ret)
+                        goto clkput;
+        }
        uart_add_one_port(&imx_reg, &sport->port);
        platform_set_drvdata(pdev, &sport->port);
        return 0;
+clkput:
+        clk_put(sport->clk);
+        clk_disable(sport->clk);
 unmap:
        iounmap(sport->port.membase);
 free:
diff --git a/drivers/serial/ioc3_serial.c b/drivers/serial/ioc3_serial.c
index 4f1af71e9a1b..6dd98f9fb89c 100644
--- a/drivers/serial/ioc3_serial.c
+++ b/drivers/serial/ioc3_serial.c
@@ -905,7 +905,7 @@ static void transmit_chars(struct uart_port *the_port)
                return;
        info = the_port->info;
-        tty = info->tty;
+        tty = info->port.tty;
        if (uart_circ_empty(&info->xmit) || uart_tx_stopped(the_port)) {
                /* Nothing to do or hw stopped */
@@ -997,14 +997,14 @@ ioc3_change_speed(struct uart_port *the_port,
        the_port->ignore_status_mask = N_ALL_INPUT;
-        info->tty->low_latency = 1;
+        info->port.tty->low_latency = 1;
-        if (I_IGNPAR(info->tty))
+        if (I_IGNPAR(info->port.tty))
                the_port->ignore_status_mask &= ~(N_PARITY_ERROR
                                                  | N_FRAMING_ERROR);
-        if (I_IGNBRK(info->tty)) {
+        if (I_IGNBRK(info->port.tty)) {
                the_port->ignore_status_mask &= ~N_BREAK;
-                if (I_IGNPAR(info->tty))
+                if (I_IGNPAR(info->port.tty))
                        the_port->ignore_status_mask &= ~N_OVERRUN_ERROR;
        }
        if (!(cflag & CREAD)) {
@@ -1399,14 +1399,14 @@ static int receive_chars(struct uart_port *the_port)
        /* Make sure all the pointers are "good" ones */
        if (!info)
                return 0;
-        if (!info->tty)
+        if (!info->port.tty)
                return 0;
        if (!(port->ip_flags & INPUT_ENABLE))
                return 0;
        spin_lock_irqsave(&the_port->lock, pflags);
-        tty = info->tty;
+        tty = info->port.tty;
        read_count = do_read(the_port, ch, MAX_CHARS);
        if (read_count > 0) {
diff --git a/drivers/serial/ioc4_serial.c b/drivers/serial/ioc4_serial.c
index 49b8a82b7b9f..6bab63cd5b29 100644
--- a/drivers/serial/ioc4_serial.c
+++ b/drivers/serial/ioc4_serial.c
@@ -1635,7 +1635,7 @@ static void transmit_chars(struct uart_port *the_port)
                return;
        info = the_port->info;
-        tty = info->tty;
+        tty = info->port.tty;
        if (uart_circ_empty(&info->xmit) || uart_tx_stopped(the_port)) {
                /* Nothing to do or hw stopped */
@@ -1738,14 +1738,14 @@ ioc4_change_speed(struct uart_port *the_port,
        the_port->ignore_status_mask = N_ALL_INPUT;
-        info->tty->low_latency = 1;
+        info->port.tty->low_latency = 1;
-        if (I_IGNPAR(info->tty))
+        if (I_IGNPAR(info->port.tty))
                the_port->ignore_status_mask &= ~(N_PARITY_ERROR
                                                | N_FRAMING_ERROR);
-        if (I_IGNBRK(info->tty)) {
+        if (I_IGNBRK(info->port.tty)) {
                the_port->ignore_status_mask &= ~N_BREAK;
-                if (I_IGNPAR(info->tty))
+                if (I_IGNPAR(info->port.tty))
                        the_port->ignore_status_mask &= ~N_OVERRUN_ERROR;
        }
        if (!(cflag & CREAD)) {
@@ -1801,7 +1801,8 @@ static inline int ic4_startup_local(struct uart_port *the_port)
        ioc4_set_proto(port, the_port->mapbase);
        /* set the speed of the serial port */
-        ioc4_change_speed(the_port, info->tty->termios, (struct ktermios *)0);
+        ioc4_change_speed(the_port, info->port.tty->termios,
+                          (struct ktermios *)0);
        return 0;
 }
@@ -2346,11 +2347,11 @@ static void receive_chars(struct uart_port *the_port)
        /* Make sure all the pointers are "good" ones */
        if (!info)
                return;
-        if (!info->tty)
+        if (!info->port.tty)
                return;
        spin_lock_irqsave(&the_port->lock, pflags);
-        tty = info->tty;
+        tty = info->port.tty;
        request_count = tty_buffer_request_room(tty, IOC4_MAX_CHARS);
@@ -2440,8 +2441,8 @@ static void ic4_shutdown(struct uart_port *the_port)
        wake_up_interruptible(&info->delta_msr_wait);
-        if (info->tty)
+        if (info->port.tty)
-                set_bit(TTY_IO_ERROR, &info->tty->flags);
+                set_bit(TTY_IO_ERROR, &info->port.tty->flags);
        spin_lock_irqsave(&the_port->lock, port_flags);
        set_notification(port, N_ALL, 0);
diff --git a/drivers/serial/ip22zilog.c b/drivers/serial/ip22zilog.c
index 9c95bc0398ad..0d9acbd0bb70 100644
--- a/drivers/serial/ip22zilog.c
+++ b/drivers/serial/ip22zilog.c
@@ -257,8 +257,8 @@ static struct tty_struct *ip22zilog_receive_chars(struct uart_ip22zilog_port *up
        tty = NULL;
        if (up->port.info != NULL &&
-            up->port.info->tty != NULL)
+            up->port.info->port.tty != NULL)
-                tty = up->port.info->tty;
+                tty = up->port.info->port.tty;
        for (;;) {
                ch = readb(&channel->control);
diff --git a/drivers/serial/jsm/jsm_neo.c b/drivers/serial/jsm/jsm_neo.c
index b2d6f5b1a7c2..b7584ca55ade 100644
--- a/drivers/serial/jsm/jsm_neo.c
+++ b/drivers/serial/jsm/jsm_neo.c
@@ -998,7 +998,7 @@ static void neo_param(struct jsm_channel *ch)
                        {     50, B50     },
                };
-                cflag = C_BAUD(ch->uart_port.info->tty);
+                cflag = C_BAUD(ch->uart_port.info->port.tty);
                baud = 9600;
                for (i = 0; i < ARRAY_SIZE(baud_rates); i++) {
                        if (baud_rates[i].cflag == cflag) {
diff --git a/drivers/serial/jsm/jsm_tty.c b/drivers/serial/jsm/jsm_tty.c
index 94ec66372508..a697914ae3d0 100644
--- a/drivers/serial/jsm/jsm_tty.c
+++ b/drivers/serial/jsm/jsm_tty.c
@@ -145,7 +145,7 @@ static void jsm_tty_send_xchar(struct uart_port *port, char ch)
        struct ktermios *termios;
        spin_lock_irqsave(&port->lock, lock_flags);
-        termios = port->info->tty->termios;
+        termios = port->info->port.tty->termios;
        if (ch == termios->c_cc[VSTART])
                channel->ch_bd->bd_ops->send_start_character(channel);
@@ -239,7 +239,7 @@ static int jsm_tty_open(struct uart_port *port)
        channel->ch_cached_lsr = 0;
        channel->ch_stops_sent = 0;
-        termios = port->info->tty->termios;
+        termios = port->info->port.tty->termios;
        channel->ch_c_cflag     = termios->c_cflag;
        channel->ch_c_iflag     = termios->c_iflag;
        channel->ch_c_oflag     = termios->c_oflag;
@@ -272,7 +272,7 @@ static void jsm_tty_close(struct uart_port *port)
        jsm_printk(CLOSE, INFO, &channel->ch_bd->pci_dev, "start\n");
        bd = channel->ch_bd;
-        ts = channel->uart_port.info->tty->termios;
+        ts = channel->uart_port.info->port.tty->termios;
        channel->ch_flags &= ~(CH_STOPI);
@@ -515,7 +515,7 @@ void jsm_input(struct jsm_channel *ch)
        if (!ch)
                return;
-        tp = ch->uart_port.info->tty;
+        tp = ch->uart_port.info->port.tty;
        bd = ch->ch_bd;
        if(!bd)
diff --git a/drivers/serial/m32r_sio.c b/drivers/serial/m32r_sio.c
index c2bb11c02bde..611c97a15654 100644
--- a/drivers/serial/m32r_sio.c
+++ b/drivers/serial/m32r_sio.c
@@ -325,7 +325,7 @@ static void m32r_sio_enable_ms(struct uart_port *port)
 static void receive_chars(struct uart_sio_port *up, int *status)
 {
-        struct tty_struct *tty = up->port.info->tty;
+        struct tty_struct *tty = up->port.info->port.tty;
        unsigned char ch;
        unsigned char flag;
        int max_count = 256;
@@ -922,7 +922,7 @@ static void m32r_sio_config_port(struct uart_port *port, int flags)
 static int
 m32r_sio_verify_port(struct uart_port *port, struct serial_struct *ser)
 {
-        if (ser->irq >= NR_IRQS || ser->irq < 0 ||
+        if (ser->irq >= nr_irqs || ser->irq < 0 ||
            ser->baud_base < 9600 || ser->type < PORT_UNKNOWN ||
            ser->type >= ARRAY_SIZE(uart_config))
                return -EINVAL;
@@ -1160,9 +1160,9 @@ static int __init m32r_sio_init(void)
 {
        int ret, i;
-        printk(KERN_INFO "Serial: M32R SIO driver $Revision: 1.11 $ ");
+        printk(KERN_INFO "Serial: M32R SIO driver\n");
-        for (i = 0; i < NR_IRQS; i++)
+        for (i = 0; i < nr_irqs; i++)
                spin_lock_init(&irq_lists[i].lock);
        ret = uart_register_driver(&m32r_sio_reg);
@@ -1189,4 +1189,4 @@ EXPORT_SYMBOL(m32r_sio_suspend_port);
 EXPORT_SYMBOL(m32r_sio_resume_port);
 MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("Generic M32R SIO serial driver $Revision: 1.11 $");
+MODULE_DESCRIPTION("Generic M32R SIO serial driver");
diff --git a/drivers/serial/mcf.c b/drivers/serial/mcf.c
index 7e164e0cd211..b2001c5b145c 100644
--- a/drivers/serial/mcf.c
+++ b/drivers/serial/mcf.c
@@ -312,7 +312,7 @@ static void mcf_rx_chars(struct mcf_uart *pp)
                uart_insert_char(port, status, MCFUART_USR_RXOVERRUN, ch, flag);
        }
-        tty_flip_buffer_push(port->info->tty);
+        tty_flip_buffer_push(port->info->port.tty);
 }
 /****************************************************************************/
diff --git a/drivers/serial/mcfserial.c b/drivers/serial/mcfserial.c
deleted file mode 100644
index 56007cc8a9b3..000000000000
--- a/drivers/serial/mcfserial.c
+++ /dev/null
@@ -1,1965 +0,0 @@
-#warning This driver is deprecated. Check Kconfig for details.
-/*
- * mcfserial.c -- serial driver for ColdFire internal UARTS.
- *
- * Copyright (C) 1999-2003 Greg Ungerer <gerg@snapgear.com>
- * Copyright (c) 2000-2001 Lineo, Inc. <www.lineo.com> 
- * Copyright (C) 2001-2002 SnapGear Inc. <www.snapgear.com> 
- *
- * Based on code from 68332serial.c which was:
- *
- * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
- * Copyright (C) 1998 TSHG
- * Copyright (c) 1999 Rt-Control Inc. <jeff@uclinux.org>
- *
- * Changes:
- * 08/07/2003    Daniele Bellucci <bellucda@tiscali.it>
- *               some cleanups in mcfrs_write.
- *
- */
- 
-#include <linux/module.h>
-#include <linux/errno.h>
-#include <linux/signal.h>
-#include <linux/sched.h>
-#include <linux/timer.h>
-#include <linux/wait.h>
-#include <linux/interrupt.h>
-#include <linux/tty.h>
-#include <linux/tty_flip.h>
-#include <linux/string.h>
-#include <linux/fcntl.h>
-#include <linux/mm.h>
-#include <linux/kernel.h>
-#include <linux/serial.h>
-#include <linux/serialP.h>
-#include <linux/console.h>
-#include <linux/init.h>
-#include <linux/bitops.h>
-#include <linux/delay.h>
-#include <asm/io.h>
-#include <asm/irq.h>
-#include <asm/system.h>
-#include <asm/delay.h>
-#include <asm/coldfire.h>
-#include <asm/mcfsim.h>
-#include <asm/mcfuart.h>
-#include <asm/nettel.h>
-#include <asm/uaccess.h>
-#include "mcfserial.h"
-struct timer_list mcfrs_timer_struct;
-/*
- *      Default console baud rate,  we use this as the default
- *      for all ports so init can just open /dev/console and
- *      keep going.  Perhaps one day the cflag settings for the
- *      console can be used instead.
- */
-#if defined(CONFIG_HW_FEITH)
-#define CONSOLE_BAUD_RATE       38400
-#define DEFAULT_CBAUD           B38400
-#elif defined(CONFIG_MOD5272) || defined(CONFIG_M5208EVB) || \
-      defined(CONFIG_M5329EVB) || defined(CONFIG_GILBARCO)
-#define CONSOLE_BAUD_RATE       115200
-#define DEFAULT_CBAUD           B115200
-#elif defined(CONFIG_ARNEWSH) || defined(CONFIG_FREESCALE) || \
-      defined(CONFIG_senTec) || defined(CONFIG_SNEHA) || defined(CONFIG_AVNET)
-#define CONSOLE_BAUD_RATE       19200
-#define DEFAULT_CBAUD           B19200
-#endif
-#ifndef CONSOLE_BAUD_RATE
-#define CONSOLE_BAUD_RATE       9600
-#define DEFAULT_CBAUD           B9600
-#endif
-int mcfrs_console_inited = 0;
-int mcfrs_console_port = -1;
-int mcfrs_console_baud = CONSOLE_BAUD_RATE;
-int mcfrs_console_cbaud = DEFAULT_CBAUD;
-/*
- *      Driver data structures.
- */
-static struct tty_driver *mcfrs_serial_driver;
-/* number of characters left in xmit buffer before we ask for more */
-#define WAKEUP_CHARS 256
-/* Debugging...
- */
-#undef SERIAL_DEBUG_OPEN
-#undef SERIAL_DEBUG_FLOW
-#if defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x) || \
-    defined(CONFIG_M520x) || defined(CONFIG_M532x)
-#define IRQBASE (MCFINT_VECBASE+MCFINT_UART0)
-#else
-#define IRQBASE 73
-#endif
-/*
- *      Configuration table, UARTs to look for at startup.
- */
-static struct mcf_serial mcfrs_table[] = {
-        {  /* ttyS0 */
-                .magic = 0,
-                .addr = (volatile unsigned char *) (MCF_MBAR+MCFUART_BASE1),
-                .irq = IRQBASE,
-                .flags = ASYNC_BOOT_AUTOCONF,
-        },
-#ifdef MCFUART_BASE2
-        {  /* ttyS1 */
-                .magic = 0,
-                .addr = (volatile unsigned char *) (MCF_MBAR+MCFUART_BASE2),
-                .irq = IRQBASE+1,
-                .flags = ASYNC_BOOT_AUTOCONF,
-        },
-#endif
-#ifdef MCFUART_BASE3
-        {  /* ttyS2 */
-                .magic = 0,
-                .addr = (volatile unsigned char *) (MCF_MBAR+MCFUART_BASE3),
-                .irq = IRQBASE+2,
-                .flags = ASYNC_BOOT_AUTOCONF,
-        },
-#endif
-#ifdef MCFUART_BASE4
-        {  /* ttyS3 */
-                .magic = 0,
-                .addr = (volatile unsigned char *) (MCF_MBAR+MCFUART_BASE4),
-                .irq = IRQBASE+3,
-                .flags = ASYNC_BOOT_AUTOCONF,
-        },
-#endif
-};
-#define NR_PORTS        (sizeof(mcfrs_table) / sizeof(struct mcf_serial))
-/*
- * This is used to figure out the divisor speeds and the timeouts.
- */
-static int mcfrs_baud_table[] = {
-        0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
-        9600, 19200, 38400, 57600, 115200, 230400, 460800, 0
-};
-#define MCFRS_BAUD_TABLE_SIZE \
-                        (sizeof(mcfrs_baud_table)/sizeof(mcfrs_baud_table[0]))
-#ifdef CONFIG_MAGIC_SYSRQ
-/*
- *      Magic system request keys. Used for debugging...
- */
-extern int      magic_sysrq_key(int ch);
-#endif
-/*
- *      Forware declarations...
- */
-static void     mcfrs_change_speed(struct mcf_serial *info);
-static void     mcfrs_wait_until_sent(struct tty_struct *tty, int timeout);
-static inline int serial_paranoia_check(struct mcf_serial *info,
-                                        char *name, const char *routine)
-{
-#ifdef SERIAL_PARANOIA_CHECK
-        static const char badmagic[] =
-                "MCFRS(warning): bad magic number for serial struct %s in %s\n";
-        static const char badinfo[] =
-                "MCFRS(warning): null mcf_serial for %s in %s\n";
-        if (!info) {
-                printk(badinfo, name, routine);
-                return 1;
-        }
-        if (info->magic != SERIAL_MAGIC) {
-                printk(badmagic, name, routine);
-                return 1;
-        }
-#endif
-        return 0;
-}
-/*
- *      Sets or clears DTR and RTS on the requested line.
- */
-static void mcfrs_setsignals(struct mcf_serial *info, int dtr, int rts)
-{
-        volatile unsigned char  *uartp;
-        unsigned long           flags;
-        
-#if 0
-        printk("%s(%d): mcfrs_setsignals(info=%x,dtr=%d,rts=%d)\n",
-                __FILE__, __LINE__, info, dtr, rts);
-#endif
-        local_irq_save(flags);
-        if (dtr >= 0) {
-#ifdef MCFPP_DTR0
-                if (info->line)
-                        mcf_setppdata(MCFPP_DTR1, (dtr ? 0 : MCFPP_DTR1));
-                else
-                        mcf_setppdata(MCFPP_DTR0, (dtr ? 0 : MCFPP_DTR0));
-#endif
-        }
-        if (rts >= 0) {
-                uartp = info->addr;
-                if (rts) {
-                        info->sigs |= TIOCM_RTS;
-                        uartp[MCFUART_UOP1] = MCFUART_UOP_RTS;
-                } else {
-                        info->sigs &= ~TIOCM_RTS;
-                        uartp[MCFUART_UOP0] = MCFUART_UOP_RTS;
-                }
-        }
-        local_irq_restore(flags);
-        return;
-}
-/*
- *      Gets values of serial signals.
- */
-static int mcfrs_getsignals(struct mcf_serial *info)
-{
-        volatile unsigned char  *uartp;
-        unsigned long           flags;
-        int                     sigs;
-#if defined(CONFIG_NETtel) && defined(CONFIG_M5307)
-        unsigned short          ppdata;
-#endif
-#if 0
-        printk("%s(%d): mcfrs_getsignals(info=%x)\n", __FILE__, __LINE__);
-#endif
-        local_irq_save(flags);
-        uartp = info->addr;
-        sigs = (uartp[MCFUART_UIPR] & MCFUART_UIPR_CTS) ? 0 : TIOCM_CTS;
-        sigs |= (info->sigs & TIOCM_RTS);
-#ifdef MCFPP_DCD0
-{
-        unsigned int ppdata;
-        ppdata = mcf_getppdata();
-        if (info->line == 0) {
-                sigs |= (ppdata & MCFPP_DCD0) ? 0 : TIOCM_CD;
-                sigs |= (ppdata & MCFPP_DTR0) ? 0 : TIOCM_DTR;
-        } else if (info->line == 1) {
-                sigs |= (ppdata & MCFPP_DCD1) ? 0 : TIOCM_CD;
-                sigs |= (ppdata & MCFPP_DTR1) ? 0 : TIOCM_DTR;
-        }
-}
-#endif
-        local_irq_restore(flags);
-        return(sigs);
-}
-/*
- * ------------------------------------------------------------
- * mcfrs_stop() and mcfrs_start()
- *
- * This routines are called before setting or resetting tty->stopped.
- * They enable or disable transmitter interrupts, as necessary.
- * ------------------------------------------------------------
- */
-static void mcfrs_stop(struct tty_struct *tty)
-{
-        volatile unsigned char  *uartp;
-        struct mcf_serial       *info = (struct mcf_serial *)tty->driver_data;
-        unsigned long           flags;
-        if (serial_paranoia_check(info, tty->name, "mcfrs_stop"))
-                return;
-        
-        local_irq_save(flags);
-        uartp = info->addr;
-        info->imr &= ~MCFUART_UIR_TXREADY;
-        uartp[MCFUART_UIMR] = info->imr;
-        local_irq_restore(flags);
-}
-static void mcfrs_start(struct tty_struct *tty)
-{
-        volatile unsigned char  *uartp;
-        struct mcf_serial       *info = (struct mcf_serial *)tty->driver_data;
-        unsigned long           flags;
-        
-        if (serial_paranoia_check(info, tty->name, "mcfrs_start"))
-                return;
-        local_irq_save(flags);
-        if (info->xmit_cnt && info->xmit_buf) {
-                uartp = info->addr;
-                info->imr |= MCFUART_UIR_TXREADY;
-                uartp[MCFUART_UIMR] = info->imr;
-        }
-        local_irq_restore(flags);
-}
-/*
- * ----------------------------------------------------------------------
- *
- * Here starts the interrupt handling routines.  All of the following
- * subroutines are declared as inline and are folded into
- * mcfrs_interrupt().  They were separated out for readability's sake.
- *
- * Note: mcfrs_interrupt() is a "fast" interrupt, which means that it
- * runs with interrupts turned off.  People who may want to modify
- * mcfrs_interrupt() should try to keep the interrupt handler as fast as
- * possible.  After you are done making modifications, it is not a bad
- * idea to do:
- * 
- * gcc -S -DKERNEL -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer serial.c
- *
- * and look at the resulting assemble code in serial.s.
- *
- *                              - Ted Ts'o (tytso@mit.edu), 7-Mar-93
- * -----------------------------------------------------------------------
- */
-static inline void receive_chars(struct mcf_serial *info)
-{
-        volatile unsigned char  *uartp;
-        struct tty_struct       *tty = info->tty;
-        unsigned char           status, ch, flag;
-        if (!tty)
-                return;
-        uartp = info->addr;
-        while ((status = uartp[MCFUART_USR]) & MCFUART_USR_RXREADY) {
-                ch = uartp[MCFUART_URB];
-                info->stats.rx++;
-#ifdef CONFIG_MAGIC_SYSRQ
-                if (mcfrs_console_inited && (info->line == mcfrs_console_port)) {
-                        if (magic_sysrq_key(ch))
-                                continue;
-                }
-#endif
-                flag = TTY_NORMAL;
-                if (status & MCFUART_USR_RXERR) {
-                        uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETERR;
-                        if (status & MCFUART_USR_RXBREAK) {
-                                info->stats.rxbreak++;
-                                flag = TTY_BREAK;
-                        } else if (status & MCFUART_USR_RXPARITY) {
-                                info->stats.rxparity++;
-                                flag = TTY_PARITY;
-                        } else if (status & MCFUART_USR_RXOVERRUN) {
-                                info->stats.rxoverrun++;
-                                flag = TTY_OVERRUN;
-                        } else if (status & MCFUART_USR_RXFRAMING) {
-                                info->stats.rxframing++;
-                                flag = TTY_FRAME;
-                        }
-                }
-                tty_insert_flip_char(tty, ch, flag);
-        }
-        tty_schedule_flip(tty);
-        return;
-}
-static inline void transmit_chars(struct mcf_serial *info)
-{
-        volatile unsigned char  *uartp;
-        uartp = info->addr;
-        if (info->x_char) {
-                /* Send special char - probably flow control */
-                uartp[MCFUART_UTB] = info->x_char;
-                info->x_char = 0;
-                info->stats.tx++;
-        }
-        if ((info->xmit_cnt <= 0) || info->tty->stopped) {
-                info->imr &= ~MCFUART_UIR_TXREADY;
-                uartp[MCFUART_UIMR] = info->imr;
-                return;
-        }
-        while (uartp[MCFUART_USR] & MCFUART_USR_TXREADY) {
-                uartp[MCFUART_UTB] = info->xmit_buf[info->xmit_tail++];
-                info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1);
-                info->stats.tx++;
-                if (--info->xmit_cnt <= 0)
-                        break;
-        }
-        if (info->xmit_cnt < WAKEUP_CHARS)
-                schedule_work(&info->tqueue);
-        return;
-}
-/*
- * This is the serial driver's generic interrupt routine
- */
-irqreturn_t mcfrs_interrupt(int irq, void *dev_id)
-{
-        struct mcf_serial       *info;
-        unsigned char           isr;
-        info = &mcfrs_table[(irq - IRQBASE)];
-        isr = info->addr[MCFUART_UISR] & info->imr;
-        if (isr & MCFUART_UIR_RXREADY)
-                receive_chars(info);
-        if (isr & MCFUART_UIR_TXREADY)
-                transmit_chars(info);
-        return IRQ_HANDLED;
-}
-/*
- * -------------------------------------------------------------------
- * Here ends the serial interrupt routines.
- * -------------------------------------------------------------------
- */
-static void mcfrs_offintr(struct work_struct *work)
-{
-        struct mcf_serial *info = container_of(work, struct mcf_serial, tqueue);
-        struct tty_struct *tty = info->tty;
-        
-        if (tty)
-                tty_wakeup(tty);
-}
-/*
- *      Change of state on a DCD line.
- */
-void mcfrs_modem_change(struct mcf_serial *info, int dcd)
-{
-        if (info->count == 0)
-                return;
-        if (info->flags & ASYNC_CHECK_CD) {
-                if (dcd)
-                        wake_up_interruptible(&info->open_wait);
-                else 
-                        schedule_work(&info->tqueue_hangup);
-        }
-}
-#ifdef MCFPP_DCD0
-unsigned short  mcfrs_ppstatus;
-/*
- * This subroutine is called when the RS_TIMER goes off. It is used
- * to monitor the state of the DCD lines - since they have no edge
- * sensors and interrupt generators.
- */
-static void mcfrs_timer(void)
-{
-        unsigned int    ppstatus, dcdval, i;
-        ppstatus = mcf_getppdata() & (MCFPP_DCD0 | MCFPP_DCD1);
-        if (ppstatus != mcfrs_ppstatus) {
-                for (i = 0; (i < 2); i++) {
-                        dcdval = (i ? MCFPP_DCD1 : MCFPP_DCD0);
-                        if ((ppstatus & dcdval) != (mcfrs_ppstatus & dcdval)) {
-                                mcfrs_modem_change(&mcfrs_table[i],
-                                        ((ppstatus & dcdval) ? 0 : 1));
-                        }
-                }
-        }
-        mcfrs_ppstatus = ppstatus;
-        /* Re-arm timer */
-        mcfrs_timer_struct.expires = jiffies + HZ/25;
-        add_timer(&mcfrs_timer_struct);
-}
-#endif  /* MCFPP_DCD0 */
-/*
- * This routine is called from the scheduler tqueue when the interrupt
- * routine has signalled that a hangup has occurred. The path of
- * hangup processing is:
- *
- *      serial interrupt routine -> (scheduler tqueue) ->
- *      do_serial_hangup() -> tty->hangup() -> mcfrs_hangup()
- * 
- */
-static void do_serial_hangup(struct work_struct *work)
-{
-        struct mcf_serial *info = container_of(work, struct mcf_serial, tqueue_hangup);
-        struct tty_struct *tty = info->tty;
-        
-        if (tty)
-                tty_hangup(tty);
-}
-static int startup(struct mcf_serial * info)
-{
-        volatile unsigned char  *uartp;
-        unsigned long           flags;
-        
-        if (info->flags & ASYNC_INITIALIZED)
-                return 0;
-        if (!info->xmit_buf) {
-                info->xmit_buf = (unsigned char *) __get_free_page(GFP_KERNEL);
-                if (!info->xmit_buf)
-                        return -ENOMEM;
-        }
-        local_irq_save(flags);
-#ifdef SERIAL_DEBUG_OPEN
-        printk("starting up ttyS%d (irq %d)...\n", info->line, info->irq);
-#endif
-        /*
-         *      Reset UART, get it into known state...
-         */
-        uartp = info->addr;
-        uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETRX;  /* reset RX */
-        uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETTX;  /* reset TX */
-        mcfrs_setsignals(info, 1, 1);
-        if (info->tty)
-                clear_bit(TTY_IO_ERROR, &info->tty->flags);
-        info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
-        /*
-         * and set the speed of the serial port
-         */
-        mcfrs_change_speed(info);
-        /*
-         * Lastly enable the UART transmitter and receiver, and
-         * interrupt enables.
-         */
-        info->imr = MCFUART_UIR_RXREADY;
-        uartp[MCFUART_UCR] = MCFUART_UCR_RXENABLE | MCFUART_UCR_TXENABLE;
-        uartp[MCFUART_UIMR] = info->imr;
-        info->flags |= ASYNC_INITIALIZED;
-        local_irq_restore(flags);
-        return 0;
-}
-/*
- * This routine will shutdown a serial port; interrupts are disabled, and
- * DTR is dropped if the hangup on close termio flag is on.
- */
-static void shutdown(struct mcf_serial * info)
-{
-        volatile unsigned char  *uartp;
-        unsigned long           flags;
-        if (!(info->flags & ASYNC_INITIALIZED))
-                return;
-#ifdef SERIAL_DEBUG_OPEN
-        printk("Shutting down serial port %d (irq %d)....\n", info->line,
-               info->irq);
-#endif
-        
-        local_irq_save(flags);
-        uartp = info->addr;
-        uartp[MCFUART_UIMR] = 0;  /* mask all interrupts */
-        uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETRX;  /* reset RX */
-        uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETTX;  /* reset TX */
-        if (!info->tty || (info->tty->termios->c_cflag & HUPCL))
-                mcfrs_setsignals(info, 0, 0);
-        if (info->xmit_buf) {
-                free_page((unsigned long) info->xmit_buf);
-                info->xmit_buf = 0;
-        }
-        if (info->tty)
-                set_bit(TTY_IO_ERROR, &info->tty->flags);
-        
-        info->flags &= ~ASYNC_INITIALIZED;
-        local_irq_restore(flags);
-}
-/*
- * This routine is called to set the UART divisor registers to match
- * the specified baud rate for a serial port.
- */
-static void mcfrs_change_speed(struct mcf_serial *info)
-{
-        volatile unsigned char  *uartp;
-        unsigned int            baudclk, cflag;
-        unsigned long           flags;
-        unsigned char           mr1, mr2;
-        int                     i;
-#ifdef  CONFIG_M5272
-        unsigned int            fraction;
-#endif
-        if (!info->tty || !info->tty->termios)
-                return;
-        cflag = info->tty->termios->c_cflag;
-        if (info->addr == 0)
-                return;
-#if 0
-        printk("%s(%d): mcfrs_change_speed()\n", __FILE__, __LINE__);
-#endif
-        i = cflag & CBAUD;
-        if (i & CBAUDEX) {
-                i &= ~CBAUDEX;
-                if (i < 1 || i > 4)
-                        info->tty->termios->c_cflag &= ~CBAUDEX;
-                else
-                        i += 15;
-        }
-        if (i == 0) {
-                mcfrs_setsignals(info, 0, -1);
-                return;
-        }
-        /* compute the baudrate clock */
-#ifdef  CONFIG_M5272
-        /*
-         * For the MCF5272, also compute the baudrate fraction.
-         */
-        baudclk = (MCF_BUSCLK / mcfrs_baud_table[i]) / 32;
-        fraction = MCF_BUSCLK - (baudclk * 32 * mcfrs_baud_table[i]);
-        fraction *= 16;
-        fraction /= (32 * mcfrs_baud_table[i]);
-#else
-        baudclk = ((MCF_BUSCLK / mcfrs_baud_table[i]) + 16) / 32;
-#endif
-        info->baud = mcfrs_baud_table[i];
-        mr1 = MCFUART_MR1_RXIRQRDY | MCFUART_MR1_RXERRCHAR;
-        mr2 = 0;
-        switch (cflag & CSIZE) {
-        case CS5:       mr1 |= MCFUART_MR1_CS5; break;
-        case CS6:       mr1 |= MCFUART_MR1_CS6; break;
-        case CS7:       mr1 |= MCFUART_MR1_CS7; break;
-        case CS8:
-        default:        mr1 |= MCFUART_MR1_CS8; break;
-        }
-        if (cflag & PARENB) {
-                if (cflag & CMSPAR) {
-                        if (cflag & PARODD)
-                                mr1 |= MCFUART_MR1_PARITYMARK;
-                        else
-                                mr1 |= MCFUART_MR1_PARITYSPACE;
-                } else {
-                        if (cflag & PARODD)
-                                mr1 |= MCFUART_MR1_PARITYODD;
-                        else
-                                mr1 |= MCFUART_MR1_PARITYEVEN;
-                }
-        } else {
-                mr1 |= MCFUART_MR1_PARITYNONE;
-        }
-        if (cflag & CSTOPB)
-                mr2 |= MCFUART_MR2_STOP2;
-        else
-                mr2 |= MCFUART_MR2_STOP1;
-        if (cflag & CRTSCTS) {
-                mr1 |= MCFUART_MR1_RXRTS;
-                mr2 |= MCFUART_MR2_TXCTS;
-        }
-        if (cflag & CLOCAL)
-                info->flags &= ~ASYNC_CHECK_CD;
-        else
-                info->flags |= ASYNC_CHECK_CD;
-        uartp = info->addr;
-        local_irq_save(flags);
-#if 0
-        printk("%s(%d): mr1=%x mr2=%x baudclk=%x\n", __FILE__, __LINE__,
-                mr1, mr2, baudclk);
-#endif
-        /*
-          Note: pg 12-16 of MCF5206e User's Manual states that a
-          software reset should be performed prior to changing
-          UMR1,2, UCSR, UACR, bit 7
-        */
-        uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETRX;    /* reset RX */
-        uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETTX;    /* reset TX */
-        uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETMRPTR; /* reset MR pointer */
-        uartp[MCFUART_UMR] = mr1;
-        uartp[MCFUART_UMR] = mr2;
-        uartp[MCFUART_UBG1] = (baudclk & 0xff00) >> 8;  /* set msb byte */
-        uartp[MCFUART_UBG2] = (baudclk & 0xff);         /* set lsb byte */
-#ifdef  CONFIG_M5272
-        uartp[MCFUART_UFPD] = (fraction & 0xf);         /* set fraction */
-#endif
-        uartp[MCFUART_UCSR] = MCFUART_UCSR_RXCLKTIMER | MCFUART_UCSR_TXCLKTIMER;
-        uartp[MCFUART_UCR] = MCFUART_UCR_RXENABLE | MCFUART_UCR_TXENABLE;
-        mcfrs_setsignals(info, 1, -1);
-        local_irq_restore(flags);
-        return;
-}
-static void mcfrs_flush_chars(struct tty_struct *tty)
-{
-        volatile unsigned char  *uartp;
-        struct mcf_serial       *info = (struct mcf_serial *)tty->driver_data;
-        unsigned long           flags;
-        if (serial_paranoia_check(info, tty->name, "mcfrs_flush_chars"))
-                return;
-        uartp = (volatile unsigned char *) info->addr;
-        /*
-         * re-enable receiver interrupt
-         */
-        local_irq_save(flags);
-        if ((!(info->imr & MCFUART_UIR_RXREADY)) &&
-            (info->flags & ASYNC_INITIALIZED) ) {
-                info->imr |= MCFUART_UIR_RXREADY;
-                uartp[MCFUART_UIMR] = info->imr;
-        }
-        local_irq_restore(flags);
-        if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
-            !info->xmit_buf)
-                return;
-        /* Enable transmitter */
-        local_irq_save(flags);
-        info->imr |= MCFUART_UIR_TXREADY;
-        uartp[MCFUART_UIMR] = info->imr;
-        local_irq_restore(flags);
-}
-static int mcfrs_write(struct tty_struct * tty,
-                    const unsigned char *buf, int count)
-{
-        volatile unsigned char  *uartp;
-        struct mcf_serial       *info = (struct mcf_serial *)tty->driver_data;
-        unsigned long           flags;
-        int                     c, total = 0;
-#if 0
-        printk("%s(%d): mcfrs_write(tty=%x,buf=%x,count=%d)\n",
-                __FILE__, __LINE__, (int)tty, (int)buf, count);
-#endif
-        if (serial_paranoia_check(info, tty->name, "mcfrs_write"))
-                return 0;
-        if (!tty || !info->xmit_buf)
-                return 0;
-        
-        local_save_flags(flags);
-        while (1) {
-                local_irq_disable();            
-                c = min(count, (int) min(((int)SERIAL_XMIT_SIZE) - info->xmit_cnt - 1,
-                        ((int)SERIAL_XMIT_SIZE) - info->xmit_head));
-                local_irq_restore(flags);
-                if (c <= 0)
-                        break;
-                memcpy(info->xmit_buf + info->xmit_head, buf, c);
-                local_irq_disable();
-                info->xmit_head = (info->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
-                info->xmit_cnt += c;
-                local_irq_restore(flags);
-                buf += c;
-                count -= c;
-                total += c;
-        }
-        local_irq_disable();
-        uartp = info->addr;
-        info->imr |= MCFUART_UIR_TXREADY;
-        uartp[MCFUART_UIMR] = info->imr;
-        local_irq_restore(flags);
-        return total;
-}
-static int mcfrs_write_room(struct tty_struct *tty)
-{
-        struct mcf_serial *info = (struct mcf_serial *)tty->driver_data;
-        int     ret;
-        if (serial_paranoia_check(info, tty->name, "mcfrs_write_room"))
-                return 0;
-        ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
-        if (ret < 0)
-                ret = 0;
-        return ret;
-}
-static int mcfrs_chars_in_buffer(struct tty_struct *tty)
-{
-        struct mcf_serial *info = (struct mcf_serial *)tty->driver_data;
-        if (serial_paranoia_check(info, tty->name, "mcfrs_chars_in_buffer"))
-                return 0;
-        return info->xmit_cnt;
-}
-static void mcfrs_flush_buffer(struct tty_struct *tty)
-{
-        struct mcf_serial       *info = (struct mcf_serial *)tty->driver_data;
-        unsigned long           flags;
-        if (serial_paranoia_check(info, tty->name, "mcfrs_flush_buffer"))
-                return;
-        local_irq_save(flags);
-        info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
-        local_irq_restore(flags);
-        tty_wakeup(tty);
-}
-/*
- * ------------------------------------------------------------
- * mcfrs_throttle()
- * 
- * This routine is called by the upper-layer tty layer to signal that
- * incoming characters should be throttled.
- * ------------------------------------------------------------
- */
-static void mcfrs_throttle(struct tty_struct * tty)
-{
-        struct mcf_serial *info = (struct mcf_serial *)tty->driver_data;
-#ifdef SERIAL_DEBUG_THROTTLE
-        char    buf[64];
-        
-        printk("throttle %s: %d....\n", tty_name(tty, buf),
-               tty->ldisc.chars_in_buffer(tty));
-#endif
-        if (serial_paranoia_check(info, tty->name, "mcfrs_throttle"))
-                return;
-        
-        if (I_IXOFF(tty))
-                info->x_char = STOP_CHAR(tty);
-        /* Turn off RTS line (do this atomic) */
-}
-static void mcfrs_unthrottle(struct tty_struct * tty)
-{
-        struct mcf_serial *info = (struct mcf_serial *)tty->driver_data;
-#ifdef SERIAL_DEBUG_THROTTLE
-        char    buf[64];
-        
-        printk("unthrottle %s: %d....\n", tty_name(tty, buf),
-               tty->ldisc.chars_in_buffer(tty));
-#endif
-        if (serial_paranoia_check(info, tty->name, "mcfrs_unthrottle"))
-                return;
-        
-        if (I_IXOFF(tty)) {
-                if (info->x_char)
-                        info->x_char = 0;
-                else
-                        info->x_char = START_CHAR(tty);
-        }
-        /* Assert RTS line (do this atomic) */
-}
-/*
- * ------------------------------------------------------------
- * mcfrs_ioctl() and friends
- * ------------------------------------------------------------
- */
-static int get_serial_info(struct mcf_serial * info,
-                           struct serial_struct * retinfo)
-{
-        struct serial_struct tmp;
-  
-        if (!retinfo)
-                return -EFAULT;
-        memset(&tmp, 0, sizeof(tmp));
-        tmp.type = info->type;
-        tmp.line = info->line;
-        tmp.port = (unsigned int) info->addr;
-        tmp.irq = info->irq;
-        tmp.flags = info->flags;
-        tmp.baud_base = info->baud_base;
-        tmp.close_delay = info->close_delay;
-        tmp.closing_wait = info->closing_wait;
-        tmp.custom_divisor = info->custom_divisor;
-        return copy_to_user(retinfo,&tmp,sizeof(*retinfo)) ? -EFAULT : 0;
-}
-static int set_serial_info(struct mcf_serial * info,
-                           struct serial_struct * new_info)
-{
-        struct serial_struct new_serial;
-        struct mcf_serial old_info;
-        int     retval = 0;
-        if (!new_info)
-                return -EFAULT;
-        if (copy_from_user(&new_serial,new_info,sizeof(new_serial)))
-                return -EFAULT;
-        old_info = *info;
-        if (!capable(CAP_SYS_ADMIN)) {
-                if ((new_serial.baud_base != info->baud_base) ||
-                    (new_serial.type != info->type) ||
-                    (new_serial.close_delay != info->close_delay) ||
-                    ((new_serial.flags & ~ASYNC_USR_MASK) !=
-                     (info->flags & ~ASYNC_USR_MASK)))
-                        return -EPERM;
-                info->flags = ((info->flags & ~ASYNC_USR_MASK) |
-                               (new_serial.flags & ASYNC_USR_MASK));
-                info->custom_divisor = new_serial.custom_divisor;
-                goto check_and_exit;
-        }
-        if (info->count > 1)
-                return -EBUSY;
-        /*
-         * OK, past this point, all the error checking has been done.
-         * At this point, we start making changes.....
-         */
-        info->baud_base = new_serial.baud_base;
-        info->flags = ((info->flags & ~ASYNC_FLAGS) |
-                        (new_serial.flags & ASYNC_FLAGS));
-        info->type = new_serial.type;
-        info->close_delay = new_serial.close_delay;
-        info->closing_wait = new_serial.closing_wait;
-check_and_exit:
-        retval = startup(info);
-        return retval;
-}
-/*
- * get_lsr_info - get line status register info
- *
- * Purpose: Let user call ioctl() to get info when the UART physically
- *          is emptied.  On bus types like RS485, the transmitter must
- *          release the bus after transmitting. This must be done when
- *          the transmit shift register is empty, not be done when the
- *          transmit holding register is empty.  This functionality
- *          allows an RS485 driver to be written in user space. 
- */
-static int get_lsr_info(struct mcf_serial * info, unsigned int *value)
-{
-        volatile unsigned char  *uartp;
-        unsigned long           flags;
-        unsigned char           status;
-        local_irq_save(flags);
-        uartp = info->addr;
-        status = (uartp[MCFUART_USR] & MCFUART_USR_TXEMPTY) ? TIOCSER_TEMT : 0;
-        local_irq_restore(flags);
-        return put_user(status,value);
-}
-/*
- * This routine sends a break character out the serial port.
- */
-static void send_break( struct mcf_serial * info, int duration)
-{
-        volatile unsigned char  *uartp;
-        unsigned long           flags;
-        if (!info->addr)
-                return;
-        set_current_state(TASK_INTERRUPTIBLE);
-        uartp = info->addr;
-        local_irq_save(flags);
-        uartp[MCFUART_UCR] = MCFUART_UCR_CMDBREAKSTART;
-        schedule_timeout(duration);
-        uartp[MCFUART_UCR] = MCFUART_UCR_CMDBREAKSTOP;
-        local_irq_restore(flags);
-}
-static int mcfrs_tiocmget(struct tty_struct *tty, struct file *file)
-{
-        struct mcf_serial * info = (struct mcf_serial *)tty->driver_data;
-        if (serial_paranoia_check(info, tty->name, "mcfrs_ioctl"))
-                return -ENODEV;
-        if (tty->flags & (1 << TTY_IO_ERROR))
-                return -EIO;
-        return mcfrs_getsignals(info);
-}
-static int mcfrs_tiocmset(struct tty_struct *tty, struct file *file,
-                          unsigned int set, unsigned int clear)
-{
-        struct mcf_serial * info = (struct mcf_serial *)tty->driver_data;
-        int rts = -1, dtr = -1;
-        if (serial_paranoia_check(info, tty->name, "mcfrs_ioctl"))
-                return -ENODEV;
-        if (tty->flags & (1 << TTY_IO_ERROR))
-                return -EIO;
-        if (set & TIOCM_RTS)
-                rts = 1;
-        if (set & TIOCM_DTR)
-                dtr = 1;
-        if (clear & TIOCM_RTS)
-                rts = 0;
-        if (clear & TIOCM_DTR)
-                dtr = 0;
-        mcfrs_setsignals(info, dtr, rts);
-        return 0;
-}
-static int mcfrs_ioctl(struct tty_struct *tty, struct file * file,
-                    unsigned int cmd, unsigned long arg)
-{
-        struct mcf_serial * info = (struct mcf_serial *)tty->driver_data;
-        int retval, error;
-        if (serial_paranoia_check(info, tty->name, "mcfrs_ioctl"))
-                return -ENODEV;
-        if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
-            (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGWILD)  &&
-            (cmd != TIOCSERSWILD) && (cmd != TIOCSERGSTRUCT)) {
-                if (tty->flags & (1 << TTY_IO_ERROR))
-                    return -EIO;
-        }
-        
-        switch (cmd) {
-                case TCSBRK:    /* SVID version: non-zero arg --> no break */
-                        retval = tty_check_change(tty);
-                        if (retval)
-                                return retval;
-                        tty_wait_until_sent(tty, 0);
-                        if (!arg)
-                                send_break(info, HZ/4); /* 1/4 second */
-                        return 0;
-                case TCSBRKP:   /* support for POSIX tcsendbreak() */
-                        retval = tty_check_change(tty);
-                        if (retval)
-                                return retval;
-                        tty_wait_until_sent(tty, 0);
-                        send_break(info, arg ? arg*(HZ/10) : HZ/4);
-                        return 0;
-                case TIOCGSERIAL:
-                        if (access_ok(VERIFY_WRITE, (void *) arg,
-                                                sizeof(struct serial_struct)))
-                                return get_serial_info(info,
-                                               (struct serial_struct *) arg);
-                        return -EFAULT;
-                case TIOCSSERIAL:
-                        return set_serial_info(info,
-                                               (struct serial_struct *) arg);
-                case TIOCSERGETLSR: /* Get line status register */
-                        if (access_ok(VERIFY_WRITE, (void *) arg,
-                                                sizeof(unsigned int)))
-                                return get_lsr_info(info, (unsigned int *) arg);
-                        return -EFAULT;
-                case TIOCSERGSTRUCT:
-                        error = copy_to_user((struct mcf_serial *) arg,
-                                    info, sizeof(struct mcf_serial));
-                        if (error)
-                                return -EFAULT;
-                        return 0;
-                        
-#ifdef TIOCSET422
-                case TIOCSET422: {
-                        unsigned int val;
-                        get_user(val, (unsigned int *) arg);
-                        mcf_setpa(MCFPP_PA11, (val ? 0 : MCFPP_PA11));
-                        break;
-                }
-                case TIOCGET422: {
-                        unsigned int val;
-                        val = (mcf_getpa() & MCFPP_PA11) ? 0 : 1;
-                        put_user(val, (unsigned int *) arg);
-                        break;
-                }
-#endif
-                default:
-                        return -ENOIOCTLCMD;
-                }
-        return 0;
-}
-static void mcfrs_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
-{
-        struct mcf_serial *info = (struct mcf_serial *)tty->driver_data;
-        if (tty->termios->c_cflag == old_termios->c_cflag)
-                return;
-        mcfrs_change_speed(info);
-        if ((old_termios->c_cflag & CRTSCTS) &&
-            !(tty->termios->c_cflag & CRTSCTS)) {
-                tty->hw_stopped = 0;
-                mcfrs_setsignals(info, -1, 1);
-#if 0
-                mcfrs_start(tty);
-#endif
-        }
-}
-/*
- * ------------------------------------------------------------
- * mcfrs_close()
- * 
- * This routine is called when the serial port gets closed.  First, we
- * wait for the last remaining data to be sent.  Then, we unlink its
- * S structure from the interrupt chain if necessary, and we free
- * that IRQ if nothing is left in the chain.
- * ------------------------------------------------------------
- */
-static void mcfrs_close(struct tty_struct *tty, struct file * filp)
-{
-        volatile unsigned char  *uartp;
-        struct mcf_serial       *info = (struct mcf_serial *)tty->driver_data;
-        unsigned long           flags;
-        if (!info || serial_paranoia_check(info, tty->name, "mcfrs_close"))
-                return;
-        
-        local_irq_save(flags);
-        
-        if (tty_hung_up_p(filp)) {
-                local_irq_restore(flags);
-                return;
-        }
-        
-#ifdef SERIAL_DEBUG_OPEN
-        printk("mcfrs_close ttyS%d, count = %d\n", info->line, info->count);
-#endif
-        if ((tty->count == 1) && (info->count != 1)) {
-                /*
-                 * Uh, oh.  tty->count is 1, which means that the tty
-                 * structure will be freed.  Info->count should always
-                 * be one in these conditions.  If it's greater than
-                 * one, we've got real problems, since it means the
-                 * serial port won't be shutdown.
-                 */
-                printk("MCFRS: bad serial port count; tty->count is 1, "
-                       "info->count is %d\n", info->count);
-                info->count = 1;
-        }
-        if (--info->count < 0) {
-                printk("MCFRS: bad serial port count for ttyS%d: %d\n",
-                       info->line, info->count);
-                info->count = 0;
-        }
-        if (info->count) {
-                local_irq_restore(flags);
-                return;
-        }
-        info->flags |= ASYNC_CLOSING;
-        /*
-         * Now we wait for the transmit buffer to clear; and we notify 
-         * the line discipline to only process XON/XOFF characters.
-         */
-        tty->closing = 1;
-        if (info->closing_wait != ASYNC_CLOSING_WAIT_NONE)
-                tty_wait_until_sent(tty, info->closing_wait);
-        /*
-         * At this point we stop accepting input.  To do this, we
-         * disable the receive line status interrupts, and tell the
-         * interrupt driver to stop checking the data ready bit in the
-         * line status register.
-         */
-        info->imr &= ~MCFUART_UIR_RXREADY;
-        uartp = info->addr;
-        uartp[MCFUART_UIMR] = info->imr;
-#if 0
-        /* FIXME: do we need to keep this enabled for console?? */
-        if (mcfrs_console_inited && (mcfrs_console_port == info->line)) {
-                /* Do not disable the UART */ ;
-        } else
-#endif
-        shutdown(info);
-        mcfrs_flush_buffer(tty);
-        tty_ldisc_flush(tty);
-        
-        tty->closing = 0;
-        info->event = 0;
-        info->tty = 0;
-#if 0   
-        if (tty->ldisc.num != ldiscs[N_TTY].num) {
-                if (tty->ldisc.close)
-                        (tty->ldisc.close)(tty);
-                tty->ldisc = ldiscs[N_TTY];
-                tty->termios->c_line = N_TTY;
-                if (tty->ldisc.open)
-                        (tty->ldisc.open)(tty);
-        }
-#endif  
-        if (info->blocked_open) {
-                if (info->close_delay) {
-                        msleep_interruptible(jiffies_to_msecs(info->close_delay));
-                }
-                wake_up_interruptible(&info->open_wait);
-        }
-        info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
-        wake_up_interruptible(&info->close_wait);
-        local_irq_restore(flags);
-}
-/*
- * mcfrs_wait_until_sent() --- wait until the transmitter is empty
- */
-static void
-mcfrs_wait_until_sent(struct tty_struct *tty, int timeout)
-{
-#ifdef  CONFIG_M5272
-#define MCF5272_FIFO_SIZE       25              /* fifo size + shift reg */
-        struct mcf_serial * info = (struct mcf_serial *)tty->driver_data;
-        volatile unsigned char *uartp;
-        unsigned long orig_jiffies, fifo_time, char_time, fifo_cnt;
-        if (serial_paranoia_check(info, tty->name, "mcfrs_wait_until_sent"))
-                return;
-        orig_jiffies = jiffies;
-        /*
-         * Set the check interval to be 1/5 of the approximate time
-         * to send the entire fifo, and make it at least 1.  The check
-         * interval should also be less than the timeout.
-         *
-         * Note: we have to use pretty tight timings here to satisfy
-         * the NIST-PCTS.
-         */
-        lock_kernel();
-        fifo_time = (MCF5272_FIFO_SIZE * HZ * 10) / info->baud;
-        char_time = fifo_time / 5;
-        if (char_time == 0)
-                char_time = 1;
-        if (timeout && timeout < char_time)
-                char_time = timeout;
-        /*
-         * Clamp the timeout period at 2 * the time to empty the
-         * fifo.  Just to be safe, set the minimum at .5 seconds.
-         */
-        fifo_time *= 2;
-        if (fifo_time < (HZ/2))
-                fifo_time = HZ/2;
-        if (!timeout || timeout > fifo_time)
-                timeout = fifo_time;
-        /*
-         * Account for the number of bytes in the UART
-         * transmitter FIFO plus any byte being shifted out.
-         */
-        uartp = (volatile unsigned char *) info->addr;
-        for (;;) {
-                fifo_cnt = (uartp[MCFUART_UTF] & MCFUART_UTF_TXB);
-                if ((uartp[MCFUART_USR] & (MCFUART_USR_TXREADY|
-                                MCFUART_USR_TXEMPTY)) ==
-                        MCFUART_USR_TXREADY)
-                        fifo_cnt++;
-                if (fifo_cnt == 0)
-                        break;
-                msleep_interruptible(jiffies_to_msecs(char_time));
-                if (signal_pending(current))
-                        break;
-                if (timeout && time_after(jiffies, orig_jiffies + timeout))
-                        break;
-        }
-        unlock_kernel();
-#else
-        /*
-         * For the other coldfire models, assume all data has been sent
-         */
-#endif
-}
-/*
- * mcfrs_hangup() --- called by tty_hangup() when a hangup is signaled.
- */
-void mcfrs_hangup(struct tty_struct *tty)
-{
-        struct mcf_serial * info = (struct mcf_serial *)tty->driver_data;
-        
-        if (serial_paranoia_check(info, tty->name, "mcfrs_hangup"))
-                return;
-        
-        mcfrs_flush_buffer(tty);
-        shutdown(info);
-        info->event = 0;
-        info->count = 0;
-        info->flags &= ~ASYNC_NORMAL_ACTIVE;
-        info->tty = 0;
-        wake_up_interruptible(&info->open_wait);
-}
-/*
- * ------------------------------------------------------------
- * mcfrs_open() and friends
- * ------------------------------------------------------------
- */
-static int block_til_ready(struct tty_struct *tty, struct file * filp,
-                           struct mcf_serial *info)
-{
-        DECLARE_WAITQUEUE(wait, current);
-        int     retval;
-        int     do_clocal = 0;
-        /*
-         * If the device is in the middle of being closed, then block
-         * until it's done, and then try again.
-         */
-        if (info->flags & ASYNC_CLOSING) {
-                interruptible_sleep_on(&info->close_wait);
-#ifdef SERIAL_DO_RESTART
-                if (info->flags & ASYNC_HUP_NOTIFY)
-                        return -EAGAIN;
-                else
-                        return -ERESTARTSYS;
-#else
-                return -EAGAIN;
-#endif
-        }
-        
-        /*
-         * If non-blocking mode is set, or the port is not enabled,
-         * then make the check up front and then exit.
-         */
-        if ((filp->f_flags & O_NONBLOCK) ||
-            (tty->flags & (1 << TTY_IO_ERROR))) {
-                info->flags |= ASYNC_NORMAL_ACTIVE;
-                return 0;
-        }
-        if (tty->termios->c_cflag & CLOCAL)
-                do_clocal = 1;
-        /*
-         * Block waiting for the carrier detect and the line to become
-         * free (i.e., not in use by the callout).  While we are in
-         * this loop, info->count is dropped by one, so that
-         * mcfrs_close() knows when to free things.  We restore it upon
-         * exit, either normal or abnormal.
-         */
-        retval = 0;
-        add_wait_queue(&info->open_wait, &wait);
-#ifdef SERIAL_DEBUG_OPEN
-        printk("block_til_ready before block: ttyS%d, count = %d\n",
-               info->line, info->count);
-#endif
-        info->count--;
-        info->blocked_open++;
-        while (1) {
-                local_irq_disable();
-                mcfrs_setsignals(info, 1, 1);
-                local_irq_enable();
-                current->state = TASK_INTERRUPTIBLE;
-                if (tty_hung_up_p(filp) ||
-                    !(info->flags & ASYNC_INITIALIZED)) {
-#ifdef SERIAL_DO_RESTART
-                        if (info->flags & ASYNC_HUP_NOTIFY)
-                                retval = -EAGAIN;
-                        else
-                                retval = -ERESTARTSYS;  
-#else
-                        retval = -EAGAIN;
-#endif
-                        break;
-                }
-                if (!(info->flags & ASYNC_CLOSING) &&
-                    (do_clocal || (mcfrs_getsignals(info) & TIOCM_CD)))
-                        break;
-                if (signal_pending(current)) {
-                        retval = -ERESTARTSYS;
-                        break;
-                }
-#ifdef SERIAL_DEBUG_OPEN
-                printk("block_til_ready blocking: ttyS%d, count = %d\n",
-                       info->line, info->count);
-#endif
-                schedule();
-        }
-        current->state = TASK_RUNNING;
-        remove_wait_queue(&info->open_wait, &wait);
-        if (!tty_hung_up_p(filp))
-                info->count++;
-        info->blocked_open--;
-#ifdef SERIAL_DEBUG_OPEN
-        printk("block_til_ready after blocking: ttyS%d, count = %d\n",
-               info->line, info->count);
-#endif
-        if (retval)
-                return retval;
-        info->flags |= ASYNC_NORMAL_ACTIVE;
-        return 0;
-}       
-/*
- * This routine is called whenever a serial port is opened. It
- * enables interrupts for a serial port, linking in its structure into
- * the IRQ chain.   It also performs the serial-specific
- * initialization for the tty structure.
- */
-int mcfrs_open(struct tty_struct *tty, struct file * filp)
-{
-        struct mcf_serial       *info;
-        int                     retval, line;
-        line = tty->index;
-        if ((line < 0) || (line >= NR_PORTS))
-                return -ENODEV;
-        info = mcfrs_table + line;
-        if (serial_paranoia_check(info, tty->name, "mcfrs_open"))
-                return -ENODEV;
-#ifdef SERIAL_DEBUG_OPEN
-        printk("mcfrs_open %s, count = %d\n", tty->name, info->count);
-#endif
-        info->count++;
-        tty->driver_data = info;
-        info->tty = tty;
-        /*
-         * Start up serial port
-         */
-        retval = startup(info);
-        if (retval)
-                return retval;
-        retval = block_til_ready(tty, filp, info);
-        if (retval) {
-#ifdef SERIAL_DEBUG_OPEN
-                printk("mcfrs_open returning after block_til_ready with %d\n",
-                       retval);
-#endif
-                return retval;
-        }
-#ifdef SERIAL_DEBUG_OPEN
-        printk("mcfrs_open %s successful...\n", tty->name);
-#endif
-        return 0;
-}
-/*
- *      Based on the line number set up the internal interrupt stuff.
- */
-static void mcfrs_irqinit(struct mcf_serial *info)
-{
-#if defined(CONFIG_M5272)
-        volatile unsigned long  *icrp;
-        volatile unsigned long  *portp;
-        volatile unsigned char  *uartp;
-        uartp = info->addr;
-        icrp = (volatile unsigned long *) (MCF_MBAR + MCFSIM_ICR2);
-        switch (info->line) {
-        case 0:
-                *icrp = 0xe0000000;
-                break;
-        case 1:
-                *icrp = 0x0e000000;
-                break;
-        default:
-                printk("MCFRS: don't know how to handle UART %d interrupt?\n",
-                        info->line);
-                return;
-        }
-        /* Enable the output lines for the serial ports */
-        portp = (volatile unsigned long *) (MCF_MBAR + MCFSIM_PBCNT);
-        *portp = (*portp & ~0x000000ff) | 0x00000055;
-        portp = (volatile unsigned long *) (MCF_MBAR + MCFSIM_PDCNT);
-        *portp = (*portp & ~0x000003fc) | 0x000002a8;
-#elif defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x)
-        volatile unsigned char *icrp, *uartp;
-        volatile unsigned long *imrp;
-        uartp = info->addr;
-        icrp = (volatile unsigned char *) (MCF_MBAR + MCFICM_INTC0 +
-                MCFINTC_ICR0 + MCFINT_UART0 + info->line);
-        *icrp = 0x30 + info->line; /* level 6, line based priority */
-        imrp = (volatile unsigned long *) (MCF_MBAR + MCFICM_INTC0 +
-                MCFINTC_IMRL);
-        *imrp &= ~((1 << (info->irq - MCFINT_VECBASE)) | 1);
-#if defined(CONFIG_M527x)
-        {
-                /*
-                 * External Pin Mask Setting & Enable External Pin for Interface
-                 * mrcbis@aliceposta.it
-                 */
-                u16 *serpin_enable_mask;
-                serpin_enable_mask = (u16 *) (MCF_IPSBAR + MCF_GPIO_PAR_UART);
-                if (info->line == 0)
-                        *serpin_enable_mask |= UART0_ENABLE_MASK;
-                else if (info->line == 1)
-                        *serpin_enable_mask |= UART1_ENABLE_MASK;
-                else if (info->line == 2)
-                        *serpin_enable_mask |= UART2_ENABLE_MASK;
-        }
-#endif
-#if defined(CONFIG_M528x)
-        /* make sure PUAPAR is set for UART0 and UART1 */
-        if (info->line < 2) {
-                volatile unsigned char *portp = (volatile unsigned char *) (MCF_MBAR + MCF5282_GPIO_PUAPAR);
-                *portp |= (0x03 << (info->line * 2));
-        }
-#endif
-#elif defined(CONFIG_M520x)
-        volatile unsigned char *icrp, *uartp;
-        volatile unsigned long *imrp;
-        uartp = info->addr;
-        icrp = (volatile unsigned char *) (MCF_MBAR + MCFICM_INTC0 +
-                MCFINTC_ICR0 + MCFINT_UART0 + info->line);
-        *icrp = 0x03;
-        imrp = (volatile unsigned long *) (MCF_MBAR + MCFICM_INTC0 +
-                MCFINTC_IMRL);
-        *imrp &= ~((1 << (info->irq - MCFINT_VECBASE)) | 1);
-        if (info->line < 2) {
-                unsigned short *uart_par;
-                uart_par = (unsigned short *)(MCF_IPSBAR + MCF_GPIO_PAR_UART);
-                if (info->line == 0)
-                        *uart_par |=  MCF_GPIO_PAR_UART_PAR_UTXD0
-                                  | MCF_GPIO_PAR_UART_PAR_URXD0;
-                else if (info->line == 1)
-                        *uart_par |=  MCF_GPIO_PAR_UART_PAR_UTXD1
-                                  | MCF_GPIO_PAR_UART_PAR_URXD1;
-                } else if (info->line == 2) {
-                        unsigned char *feci2c_par;
-                        feci2c_par = (unsigned char *)(MCF_IPSBAR +  MCF_GPIO_PAR_FECI2C);
-                        *feci2c_par &= ~0x0F;
-                        *feci2c_par |=  MCF_GPIO_PAR_FECI2C_PAR_SCL_UTXD2
-                                    | MCF_GPIO_PAR_FECI2C_PAR_SDA_URXD2;
-                }
-#elif defined(CONFIG_M532x)
-        volatile unsigned char *uartp;
-        uartp = info->addr;
-        switch (info->line) {
-        case 0:
-                MCF_INTC0_ICR26 = 0x3;
-                MCF_INTC0_CIMR = 26;
-                /* GPIO initialization */
-                MCF_GPIO_PAR_UART |= 0x000F;
-                break;
-        case 1:
-                MCF_INTC0_ICR27 = 0x3;
-                MCF_INTC0_CIMR = 27;
-                /* GPIO initialization */
-                MCF_GPIO_PAR_UART |= 0x0FF0;
-                break;
-        case 2:
-                MCF_INTC0_ICR28 = 0x3;
-                MCF_INTC0_CIMR = 28;
-                /* GPIOs also must be initalized, depends on board */
-                break;
-        }
-#else
-        volatile unsigned char  *icrp, *uartp;
-        switch (info->line) {
-        case 0:
-                icrp = (volatile unsigned char *) (MCF_MBAR + MCFSIM_UART1ICR);
-                *icrp = /*MCFSIM_ICR_AUTOVEC |*/ MCFSIM_ICR_LEVEL6 |
-                        MCFSIM_ICR_PRI1;
-                mcf_setimr(mcf_getimr() & ~MCFSIM_IMR_UART1);
-                break;
-        case 1:
-                icrp = (volatile unsigned char *) (MCF_MBAR + MCFSIM_UART2ICR);
-                *icrp = /*MCFSIM_ICR_AUTOVEC |*/ MCFSIM_ICR_LEVEL6 |
-                        MCFSIM_ICR_PRI2;
-                mcf_setimr(mcf_getimr() & ~MCFSIM_IMR_UART2);
-                break;
-        default:
-                printk("MCFRS: don't know how to handle UART %d interrupt?\n",
-                        info->line);
-                return;
-        }
-        uartp = info->addr;
-        uartp[MCFUART_UIVR] = info->irq;
-#endif
-        /* Clear mask, so no surprise interrupts. */
-        uartp[MCFUART_UIMR] = 0;
-        if (request_irq(info->irq, mcfrs_interrupt, IRQF_DISABLED,
-            "ColdFire UART", NULL)) {
-                printk("MCFRS: Unable to attach ColdFire UART %d interrupt "
-                        "vector=%d\n", info->line, info->irq);
-        }
-        return;
-}
-char *mcfrs_drivername = "ColdFire internal UART serial driver version 1.00\n";
-/*
- * Serial stats reporting...
- */
-int mcfrs_readproc(char *page, char **start, off_t off, int count,
-                         int *eof, void *data)
-{
-        struct mcf_serial       *info;
-        char                    str[20];
-        int                     len, sigs, i;
-        len = sprintf(page, mcfrs_drivername);
-        for (i = 0; (i < NR_PORTS); i++) {
-                info = &mcfrs_table[i];
-                len += sprintf((page + len), "%d: port:%x irq=%d baud:%d ",
-                        i, (unsigned int) info->addr, info->irq, info->baud);
-                if (info->stats.rx || info->stats.tx)
-                        len += sprintf((page + len), "tx:%d rx:%d ",
-                        info->stats.tx, info->stats.rx);
-                if (info->stats.rxframing)
-                        len += sprintf((page + len), "fe:%d ",
-                        info->stats.rxframing);
-                if (info->stats.rxparity)
-                        len += sprintf((page + len), "pe:%d ",
-                        info->stats.rxparity);
-                if (info->stats.rxbreak)
-                        len += sprintf((page + len), "brk:%d ",
-                        info->stats.rxbreak);
-                if (info->stats.rxoverrun)
-                        len += sprintf((page + len), "oe:%d ",
-                        info->stats.rxoverrun);
-                str[0] = str[1] = 0;
-                if ((sigs = mcfrs_getsignals(info))) {
-                        if (sigs & TIOCM_RTS)
-                                strcat(str, "|RTS");
-                        if (sigs & TIOCM_CTS)
-                                strcat(str, "|CTS");
-                        if (sigs & TIOCM_DTR)
-                                strcat(str, "|DTR");
-                        if (sigs & TIOCM_CD)
-                                strcat(str, "|CD");
-                }
-                len += sprintf((page + len), "%s\n", &str[1]);
-        }
-        return(len);
-}
-/* Finally, routines used to initialize the serial driver. */
-static void show_serial_version(void)
-{
-        printk(mcfrs_drivername);
-}
-static const struct tty_operations mcfrs_ops = {
-        .open = mcfrs_open,
-        .close = mcfrs_close,
-        .write = mcfrs_write,
-        .flush_chars = mcfrs_flush_chars,
-        .write_room = mcfrs_write_room,
-        .chars_in_buffer = mcfrs_chars_in_buffer,
-        .flush_buffer = mcfrs_flush_buffer,
-        .ioctl = mcfrs_ioctl,
-        .throttle = mcfrs_throttle,
-        .unthrottle = mcfrs_unthrottle,
-        .set_termios = mcfrs_set_termios,
-        .stop = mcfrs_stop,
-        .start = mcfrs_start,
-        .hangup = mcfrs_hangup,
-        .read_proc = mcfrs_readproc,
-        .wait_until_sent = mcfrs_wait_until_sent,
-        .tiocmget = mcfrs_tiocmget,
-        .tiocmset = mcfrs_tiocmset,
-};
-/* mcfrs_init inits the driver */
-static int __init
-mcfrs_init(void)
-{
-        struct mcf_serial       *info;
-        unsigned long           flags;
-        int                     i;
-        /* Setup base handler, and timer table. */
-#ifdef MCFPP_DCD0
-        init_timer(&mcfrs_timer_struct);
-        mcfrs_timer_struct.function = mcfrs_timer;
-        mcfrs_timer_struct.data = 0;
-        mcfrs_timer_struct.expires = jiffies + HZ/25;
-        add_timer(&mcfrs_timer_struct);
-        mcfrs_ppstatus = mcf_getppdata() & (MCFPP_DCD0 | MCFPP_DCD1);
-#endif
-        mcfrs_serial_driver = alloc_tty_driver(NR_PORTS);
-        if (!mcfrs_serial_driver)
-                return -ENOMEM;
-        show_serial_version();
-        /* Initialize the tty_driver structure */
-        mcfrs_serial_driver->owner = THIS_MODULE;
-        mcfrs_serial_driver->name = "ttyS";
-        mcfrs_serial_driver->driver_name = "mcfserial";
-        mcfrs_serial_driver->major = TTY_MAJOR;
-        mcfrs_serial_driver->minor_start = 64;
-        mcfrs_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
-        mcfrs_serial_driver->subtype = SERIAL_TYPE_NORMAL;
-        mcfrs_serial_driver->init_termios = tty_std_termios;
-        mcfrs_serial_driver->init_termios.c_cflag =
-                mcfrs_console_cbaud | CS8 | CREAD | HUPCL | CLOCAL;
-        mcfrs_serial_driver->flags = TTY_DRIVER_REAL_RAW;
-        tty_set_operations(mcfrs_serial_driver, &mcfrs_ops);
-        if (tty_register_driver(mcfrs_serial_driver)) {
-                printk("MCFRS: Couldn't register serial driver\n");
-                put_tty_driver(mcfrs_serial_driver);
-                return(-EBUSY);
-        }
-        local_irq_save(flags);
-        /*
-         *      Configure all the attached serial ports.
-         */
-        for (i = 0, info = mcfrs_table; (i < NR_PORTS); i++, info++) {
-                info->magic = SERIAL_MAGIC;
-                info->line = i;
-                info->tty = 0;
-                info->custom_divisor = 16;
-                info->close_delay = 50;
-                info->closing_wait = 3000;
-                info->x_char = 0;
-                info->event = 0;
-                info->count = 0;
-                info->blocked_open = 0;
-                INIT_WORK(&info->tqueue, mcfrs_offintr);
-                INIT_WORK(&info->tqueue_hangup, do_serial_hangup);
-                init_waitqueue_head(&info->open_wait);
-                init_waitqueue_head(&info->close_wait);
-                info->imr = 0;
-                mcfrs_setsignals(info, 0, 0);
-                mcfrs_irqinit(info);
-                printk("ttyS%d at 0x%04x (irq = %d)", info->line,
-                        (unsigned int) info->addr, info->irq);
-                printk(" is a builtin ColdFire UART\n");
-        }
-        local_irq_restore(flags);
-        return 0;
-}
-module_init(mcfrs_init);
-/****************************************************************************/
-/*                          Serial Console                                  */
-/****************************************************************************/
-/*
- *      Quick and dirty UART initialization, for console output.
- */
-void mcfrs_init_console(void)
-{
-        volatile unsigned char  *uartp;
-        unsigned int            clk;
-        /*
-         *      Reset UART, get it into known state...
-         */
-        uartp = (volatile unsigned char *) (MCF_MBAR +
-                (mcfrs_console_port ? MCFUART_BASE2 : MCFUART_BASE1));
-        uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETRX;  /* reset RX */
-        uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETTX;  /* reset TX */
-        uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETMRPTR;  /* reset MR pointer */
-        /*
-         * Set port for defined baud , 8 data bits, 1 stop bit, no parity.
-         */
-        uartp[MCFUART_UMR] = MCFUART_MR1_PARITYNONE | MCFUART_MR1_CS8;
-        uartp[MCFUART_UMR] = MCFUART_MR2_STOP1;
-#ifdef  CONFIG_M5272
-{
-        /*
-         * For the MCF5272, also compute the baudrate fraction.
-         */
-        int fraction = MCF_BUSCLK - (clk * 32 * mcfrs_console_baud);
-        fraction *= 16;
-        fraction /= (32 * mcfrs_console_baud);
-        uartp[MCFUART_UFPD] = (fraction & 0xf);         /* set fraction */
-        clk = (MCF_BUSCLK / mcfrs_console_baud) / 32;
-}
-#else
-        clk = ((MCF_BUSCLK / mcfrs_console_baud) + 16) / 32; /* set baud */
-#endif
-        uartp[MCFUART_UBG1] = (clk & 0xff00) >> 8;  /* set msb baud */
-        uartp[MCFUART_UBG2] = (clk & 0xff);  /* set lsb baud */
-        uartp[MCFUART_UCSR] = MCFUART_UCSR_RXCLKTIMER | MCFUART_UCSR_TXCLKTIMER;
-        uartp[MCFUART_UCR] = MCFUART_UCR_RXENABLE | MCFUART_UCR_TXENABLE;
-        mcfrs_console_inited++;
-        return;
-}
-/*
- *      Setup for console. Argument comes from the boot command line.
- */
-int mcfrs_console_setup(struct console *cp, char *arg)
-{
-        int             i, n = CONSOLE_BAUD_RATE;
-        if (!cp)
-                return(-1);
-        if (!strncmp(cp->name, "ttyS", 4))
-                mcfrs_console_port = cp->index;
-        else if (!strncmp(cp->name, "cua", 3))
-                mcfrs_console_port = cp->index;
-        else
-                return(-1);
-        if (arg)
-                n = simple_strtoul(arg,NULL,0);
-        for (i = 0; i < MCFRS_BAUD_TABLE_SIZE; i++)
-                if (mcfrs_baud_table[i] == n)
-                        break;
-        if (i < MCFRS_BAUD_TABLE_SIZE) {
-                mcfrs_console_baud = n;
-                mcfrs_console_cbaud = 0;
-                if (i > 15) {
-                        mcfrs_console_cbaud |= CBAUDEX;
-                        i -= 15;
-                }
-                mcfrs_console_cbaud |= i;
-        }
-        mcfrs_init_console(); /* make sure baud rate changes */
-        return(0);
-}
-static struct tty_driver *mcfrs_console_device(struct console *c, int *index)
-{
-        *index = c->index;
-        return mcfrs_serial_driver;
-}
-/*
- *      Output a single character, using UART polled mode.
- *      This is used for console output.
- */
-int mcfrs_put_char(char ch)
-{
-        volatile unsigned char  *uartp;
-        unsigned long           flags;
-        int                     i;
-        uartp = (volatile unsigned char *) (MCF_MBAR +
-                (mcfrs_console_port ? MCFUART_BASE2 : MCFUART_BASE1));
-        local_irq_save(flags);
-        for (i = 0; (i < 0x10000); i++) {
-                if (uartp[MCFUART_USR] & MCFUART_USR_TXREADY)
-                        break;
-        }
-        if (i < 0x10000) {
-                uartp[MCFUART_UTB] = ch;
-                for (i = 0; (i < 0x10000); i++)
-                        if (uartp[MCFUART_USR] & MCFUART_USR_TXEMPTY)
-                                break;
-        }
-        if (i >= 0x10000)
-                mcfrs_init_console(); /* try and get it back */
-        local_irq_restore(flags);
-        return 1;
-}
-/*
- * rs_console_write is registered for printk output.
- */
-void mcfrs_console_write(struct console *cp, const char *p, unsigned len)
-{
-        if (!mcfrs_console_inited)
-                mcfrs_init_console();
-        while (len-- > 0) {
-                if (*p == '\n')
-                        mcfrs_put_char('\r');
-                mcfrs_put_char(*p++);
-        }
-}
-/*
- * declare our consoles
- */
-struct console mcfrs_console = {
-        .name           = "ttyS",
-        .write          = mcfrs_console_write,
-        .device         = mcfrs_console_device,
-        .setup          = mcfrs_console_setup,
-        .flags          = CON_PRINTBUFFER,
-        .index          = -1,
-};
-static int __init mcfrs_console_init(void)
-{
-        register_console(&mcfrs_console);
-        return 0;
-}
-console_initcall(mcfrs_console_init);
-/****************************************************************************/
diff --git a/drivers/serial/mcfserial.h b/drivers/serial/mcfserial.h
deleted file mode 100644
index 56420e2cb110..000000000000
--- a/drivers/serial/mcfserial.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * mcfserial.c -- serial driver for ColdFire internal UARTS.
- *
- * Copyright (c) 1999 Greg Ungerer <gerg@snapgear.com>
- * Copyright (c) 2000-2001 Lineo, Inc. <www.lineo.com>
- * Copyright (c) 2002 SnapGear Inc., <www.snapgear.com>
- *
- * Based on code from 68332serial.c which was:
- *
- * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
- * Copyright (C) 1998 TSHG
- * Copyright (c) 1999 Rt-Control Inc. <jeff@uclinux.org>
- */ 
-#ifndef _MCF_SERIAL_H
-#define _MCF_SERIAL_H
-#include <linux/serial.h>
-#ifdef __KERNEL__
-/*
- *      Define a local serial stats structure.
- */
-struct mcf_stats {
-        unsigned int    rx;
-        unsigned int    tx;
-        unsigned int    rxbreak;
-        unsigned int    rxframing;
-        unsigned int    rxparity;
-        unsigned int    rxoverrun;
-};
-/*
- * This is our internal structure for each serial port's state.
- * Each serial port has one of these structures associated with it.
- */
-struct mcf_serial {
-        int                     magic;
-        volatile unsigned char  *addr;          /* UART memory address */
-        int                     irq;
-        int                     flags;          /* defined in tty.h */
-        int                     type;           /* UART type */
-        struct tty_struct       *tty;
-        unsigned char           imr;            /* Software imr register */
-        unsigned int            baud;
-        int                     sigs;
-        int                     custom_divisor;
-        int                     x_char; /* xon/xoff character */
-        int                     baud_base;
-        int                     close_delay;
-        unsigned short          closing_wait;
-        unsigned short          closing_wait2;
-        unsigned long           event;
-        int                     line;
-        int                     count;      /* # of fd on device */
-        int                     blocked_open; /* # of blocked opens */
-        unsigned char           *xmit_buf;
-        int                     xmit_head;
-        int                     xmit_tail;
-        int                     xmit_cnt;
-        struct mcf_stats        stats;
-        struct work_struct      tqueue;
-        struct work_struct      tqueue_hangup;
-        wait_queue_head_t       open_wait;
-        wait_queue_head_t       close_wait;
-};
-#endif /* __KERNEL__ */
-#endif /* _MCF_SERIAL_H */
diff --git a/drivers/serial/mpc52xx_uart.c b/drivers/serial/mpc52xx_uart.c
index efc971d9647b..6117d3db0b66 100644
--- a/drivers/serial/mpc52xx_uart.c
+++ b/drivers/serial/mpc52xx_uart.c
@@ -72,13 +72,8 @@
 #include <linux/console.h>
 #include <linux/delay.h>
 #include <linux/io.h>
-#if defined(CONFIG_PPC_MERGE)
 #include <linux/of.h>
 #include <linux/of_platform.h>
-#else
-#include <linux/platform_device.h>
-#endif
 #include <asm/mpc52xx.h>
 #include <asm/mpc512x.h>
@@ -107,12 +102,11 @@ static struct uart_port mpc52xx_uart_ports[MPC52xx_PSC_MAXNUM];
         *        it's cleared, then a memset(...,0,...) should be added to
         *        the console_init
         */
-#if defined(CONFIG_PPC_MERGE)
 /* lookup table for matching device nodes to index numbers */
 static struct device_node *mpc52xx_uart_nodes[MPC52xx_PSC_MAXNUM];
 static void mpc52xx_uart_of_enumerate(void);
-#endif
 #define PSC(port) ((struct mpc52xx_psc __iomem *)((port)->membase))
@@ -255,17 +249,12 @@ static void mpc52xx_psc_cw_restore_ints(struct uart_port *port)
 /* Search for bus-frequency property in this node or a parent */
 static unsigned long mpc52xx_getuartclk(void *p)
 {
-#if defined(CONFIG_PPC_MERGE)
        /*
         * 5200 UARTs have a / 32 prescaler
         * but the generic serial code assumes 16
         * so return ipb freq / 2
         */
        return mpc52xx_find_ipb_freq(p) / 2;
-#else
-        pr_debug("unexpected call to mpc52xx_getuartclk with arch/ppc\n");
-        return NULL;
-#endif
 }
 static struct psc_ops mpc52xx_psc_ops = {
@@ -732,7 +721,7 @@ static struct uart_ops mpc52xx_uart_ops = {
 static inline int
 mpc52xx_uart_int_rx_chars(struct uart_port *port)
 {
-        struct tty_struct *tty = port->info->tty;
+        struct tty_struct *tty = port->info->port.tty;
        unsigned char ch, flag;
        unsigned short status;
@@ -886,10 +875,6 @@ mpc52xx_console_get_options(struct uart_port *port,
        /* CT{U,L}R are write-only ! */
        *baud = CONFIG_SERIAL_MPC52xx_CONSOLE_BAUD;
-#if !defined(CONFIG_PPC_MERGE)
-        if (__res.bi_baudrate)
-                *baud = __res.bi_baudrate;
-#endif
        /* Parse them */
        switch (mr1 & MPC52xx_PSC_MODE_BITS_MASK) {
@@ -946,42 +931,6 @@ mpc52xx_console_write(struct console *co, const char *s, unsigned int count)
        psc_ops->cw_restore_ints(port);
 }
-#if !defined(CONFIG_PPC_MERGE)
-static int __init
-mpc52xx_console_setup(struct console *co, char *options)
-{
-        struct uart_port *port = &mpc52xx_uart_ports[co->index];
-        int baud = CONFIG_SERIAL_MPC52xx_CONSOLE_BAUD;
-        int bits = 8;
-        int parity = 'n';
-        int flow = 'n';
-        if (co->index < 0 || co->index >= MPC52xx_PSC_MAXNUM)
-                return -EINVAL;
-        /* Basic port init. Needed since we use some uart_??? func before
-         * real init for early access */
-        spin_lock_init(&port->lock);
-        port->uartclk   = __res.bi_ipbfreq / 2; /* Look at CTLR doc */
-        port->ops       = &mpc52xx_uart_ops;
-        port->mapbase   = MPC52xx_PA(MPC52xx_PSCx_OFFSET(co->index+1));
-        /* We ioremap ourself */
-        port->membase = ioremap(port->mapbase, MPC52xx_PSC_SIZE);
-        if (port->membase == NULL)
-                return -EINVAL;
-        /* Setup the port parameters accoding to options */
-        if (options)
-                uart_parse_options(options, &baud, &parity, &bits, &flow);
-        else
-                mpc52xx_console_get_options(port, &baud, &parity, &bits, &flow);
-        return uart_set_options(port, co, baud, parity, bits, flow);
-}
-#else
 static int __init
 mpc52xx_console_setup(struct console *co, char *options)
@@ -1053,7 +1002,6 @@ mpc52xx_console_setup(struct console *co, char *options)
        return uart_set_options(port, co, baud, parity, bits, flow);
 }
-#endif /* defined(CONFIG_PPC_MERGE) */
 static struct uart_driver mpc52xx_uart_driver;
@@ -1072,9 +1020,7 @@ static struct console mpc52xx_console = {
 static int __init
 mpc52xx_console_init(void)
 {
-#if defined(CONFIG_PPC_MERGE)
        mpc52xx_uart_of_enumerate();
-#endif
        register_console(&mpc52xx_console);
        return 0;
 }
@@ -1100,115 +1046,6 @@ static struct uart_driver mpc52xx_uart_driver = {
        .cons           = MPC52xx_PSC_CONSOLE,
 };
-#if !defined(CONFIG_PPC_MERGE)
-/* ======================================================================== */
-/* Platform Driver                                                          */
-/* ======================================================================== */
-static int __devinit
-mpc52xx_uart_probe(struct platform_device *dev)
-{
-        struct resource *res = dev->resource;
-        struct uart_port *port = NULL;
-        int i, idx, ret;
-        /* Check validity & presence */
-        idx = dev->id;
-        if (idx < 0 || idx >= MPC52xx_PSC_MAXNUM)
-                return -EINVAL;
-        if (!mpc52xx_match_psc_function(idx, "uart"))
-                return -ENODEV;
-        /* Init the port structure */
-        port = &mpc52xx_uart_ports[idx];
-        spin_lock_init(&port->lock);
-        port->uartclk   = __res.bi_ipbfreq / 2; /* Look at CTLR doc */
-        port->fifosize  = 512;
-        port->iotype    = UPIO_MEM;
-        port->flags     = UPF_BOOT_AUTOCONF |
-                          (uart_console(port) ? 0 : UPF_IOREMAP);
-        port->line      = idx;
-        port->ops       = &mpc52xx_uart_ops;
-        port->dev       = &dev->dev;
-        /* Search for IRQ and mapbase */
-        for (i = 0 ; i < dev->num_resources ; i++, res++) {
-                if (res->flags & IORESOURCE_MEM)
-                        port->mapbase = res->start;
-                else if (res->flags & IORESOURCE_IRQ)
-                        port->irq = res->start;
-        }
-        if (!port->irq || !port->mapbase)
-                return -EINVAL;
-        /* Add the port to the uart sub-system */
-        ret = uart_add_one_port(&mpc52xx_uart_driver, port);
-        if (!ret)
-                platform_set_drvdata(dev, (void *)port);
-        return ret;
-}
-static int
-mpc52xx_uart_remove(struct platform_device *dev)
-{
-        struct uart_port *port = (struct uart_port *) platform_get_drvdata(dev);
-        platform_set_drvdata(dev, NULL);
-        if (port)
-                uart_remove_one_port(&mpc52xx_uart_driver, port);
-        return 0;
-}
-#ifdef CONFIG_PM
-static int
-mpc52xx_uart_suspend(struct platform_device *dev, pm_message_t state)
-{
-        struct uart_port *port = (struct uart_port *) platform_get_drvdata(dev);
-        if (port)
-                uart_suspend_port(&mpc52xx_uart_driver, port);
-        return 0;
-}
-static int
-mpc52xx_uart_resume(struct platform_device *dev)
-{
-        struct uart_port *port = (struct uart_port *) platform_get_drvdata(dev);
-        if (port)
-                uart_resume_port(&mpc52xx_uart_driver, port);
-        return 0;
-}
-#endif
-/* work with hotplug and coldplug */
-MODULE_ALIAS("platform:mpc52xx-psc");
-static struct platform_driver mpc52xx_uart_platform_driver = {
-        .probe          = mpc52xx_uart_probe,
-        .remove         = mpc52xx_uart_remove,
-#ifdef CONFIG_PM
-        .suspend        = mpc52xx_uart_suspend,
-        .resume         = mpc52xx_uart_resume,
-#endif
-        .driver         = {
-                .owner  = THIS_MODULE,
-                .name   = "mpc52xx-psc",
-        },
-};
-#endif /* !defined(CONFIG_PPC_MERGE) */
-#if defined(CONFIG_PPC_MERGE)
 /* ======================================================================== */
 /* OF Platform Driver                                                       */
 /* ======================================================================== */
@@ -1402,7 +1239,6 @@ static struct of_platform_driver mpc52xx_uart_of_driver = {
                .name   = "mpc52xx-psc-uart",
        },
 };
-#endif /* defined(CONFIG_PPC_MERGE) */
 /* ======================================================================== */
@@ -1423,7 +1259,6 @@ mpc52xx_uart_init(void)
                return ret;
        }
-#if defined(CONFIG_PPC_MERGE)
        mpc52xx_uart_of_enumerate();
        ret = of_register_platform_driver(&mpc52xx_uart_of_driver);
@@ -1433,16 +1268,6 @@ mpc52xx_uart_init(void)
                uart_unregister_driver(&mpc52xx_uart_driver);
                return ret;
        }
-#else
-        psc_ops = &mpc52xx_psc_ops;
-        ret = platform_driver_register(&mpc52xx_uart_platform_driver);
-        if (ret) {
-                printk(KERN_ERR "%s: platform_driver_register failed (%i)\n",
-                       __FILE__, ret);
-                uart_unregister_driver(&mpc52xx_uart_driver);
-                return ret;
-        }
-#endif
        return 0;
 }
@@ -1450,11 +1275,7 @@ mpc52xx_uart_init(void)
 static void __exit
 mpc52xx_uart_exit(void)
 {
-#if defined(CONFIG_PPC_MERGE)
        of_unregister_platform_driver(&mpc52xx_uart_of_driver);
-#else
-        platform_driver_unregister(&mpc52xx_uart_platform_driver);
-#endif
        uart_unregister_driver(&mpc52xx_uart_driver);
 }
diff --git a/drivers/serial/mpsc.c b/drivers/serial/mpsc.c
index e8819c43f57d..61d3ade5286c 100644
--- a/drivers/serial/mpsc.c
+++ b/drivers/serial/mpsc.c
@@ -921,6 +921,10 @@ static int mpsc_make_ready(struct mpsc_port_info *pi)
        return 0;
 }
+#ifdef CONFIG_CONSOLE_POLL
+static int serial_polled;
+#endif
 /*
 ******************************************************************************
 *
@@ -932,7 +936,7 @@ static int mpsc_make_ready(struct mpsc_port_info *pi)
 static int mpsc_rx_intr(struct mpsc_port_info *pi)
 {
        struct mpsc_rx_desc *rxre;
-        struct tty_struct *tty = pi->port.info->tty;
+        struct tty_struct *tty = pi->port.info->port.tty;
        u32     cmdstat, bytes_in, i;
        int     rc = 0;
        u8      *bp;
@@ -956,7 +960,12 @@ static int mpsc_rx_intr(struct mpsc_port_info *pi)
        while (!((cmdstat = be32_to_cpu(rxre->cmdstat))
                                & SDMA_DESC_CMDSTAT_O)) {
                bytes_in = be16_to_cpu(rxre->bytecnt);
+#ifdef CONFIG_CONSOLE_POLL
+                if (unlikely(serial_polled)) {
+                        serial_polled = 0;
+                        return 0;
+                }
+#endif
                /* Following use of tty struct directly is deprecated */
                if (unlikely(tty_buffer_request_room(tty, bytes_in)
                                        < bytes_in)) {
@@ -1017,6 +1026,12 @@ static int mpsc_rx_intr(struct mpsc_port_info *pi)
                if (uart_handle_sysrq_char(&pi->port, *bp)) {
                        bp++;
                        bytes_in--;
+#ifdef CONFIG_CONSOLE_POLL
+                        if (unlikely(serial_polled)) {
+                                serial_polled = 0;
+                                return 0;
+                        }
+#endif
                        goto next_frame;
                }
@@ -1519,6 +1534,133 @@ static int mpsc_verify_port(struct uart_port *port, struct serial_struct *ser)
        return rc;
 }
+#ifdef CONFIG_CONSOLE_POLL
+/* Serial polling routines for writing and reading from the uart while
+ * in an interrupt or debug context.
+ */
+static char poll_buf[2048];
+static int poll_ptr;
+static int poll_cnt;
+static void mpsc_put_poll_char(struct uart_port *port,
+                                                           unsigned char c);
+static int mpsc_get_poll_char(struct uart_port *port)
+{
+        struct mpsc_port_info *pi = (struct mpsc_port_info *)port;
+        struct mpsc_rx_desc *rxre;
+        u32     cmdstat, bytes_in, i;
+        u8      *bp;
+        if (!serial_polled)
+                serial_polled = 1;
+        pr_debug("mpsc_rx_intr[%d]: Handling Rx intr\n", pi->port.line);
+        if (poll_cnt) {
+                poll_cnt--;
+                return poll_buf[poll_ptr++];
+        }
+        poll_ptr = 0;
+        poll_cnt = 0;
+        while (poll_cnt == 0) {
+                rxre = (struct mpsc_rx_desc *)(pi->rxr +
+                       (pi->rxr_posn*MPSC_RXRE_SIZE));
+                dma_cache_sync(pi->port.dev, (void *)rxre,
+                               MPSC_RXRE_SIZE, DMA_FROM_DEVICE);
+#if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
+                if (pi->cache_mgmt) /* GT642[46]0 Res #COMM-2 */
+                        invalidate_dcache_range((ulong)rxre,
+                        (ulong)rxre + MPSC_RXRE_SIZE);
+#endif
+                /*
+                 * Loop through Rx descriptors handling ones that have
+                 * been completed.
+                 */
+                while (poll_cnt == 0 &&
+                       !((cmdstat = be32_to_cpu(rxre->cmdstat)) &
+                         SDMA_DESC_CMDSTAT_O)){
+                        bytes_in = be16_to_cpu(rxre->bytecnt);
+                        bp = pi->rxb + (pi->rxr_posn * MPSC_RXBE_SIZE);
+                        dma_cache_sync(pi->port.dev, (void *) bp,
+                                       MPSC_RXBE_SIZE, DMA_FROM_DEVICE);
+#if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
+                        if (pi->cache_mgmt) /* GT642[46]0 Res #COMM-2 */
+                                invalidate_dcache_range((ulong)bp,
+                                        (ulong)bp + MPSC_RXBE_SIZE);
+#endif
+                        if ((unlikely(cmdstat & (SDMA_DESC_CMDSTAT_BR |
+                         SDMA_DESC_CMDSTAT_FR | SDMA_DESC_CMDSTAT_OR))) &&
+                                !(cmdstat & pi->port.ignore_status_mask)) {
+                                poll_buf[poll_cnt] = *bp;
+                                poll_cnt++;
+                        } else {
+                                for (i = 0; i < bytes_in; i++) {
+                                        poll_buf[poll_cnt] = *bp++;
+                                        poll_cnt++;
+                                }
+                                pi->port.icount.rx += bytes_in;
+                        }
+                        rxre->bytecnt = cpu_to_be16(0);
+                        wmb();
+                        rxre->cmdstat = cpu_to_be32(SDMA_DESC_CMDSTAT_O |
+                                                    SDMA_DESC_CMDSTAT_EI |
+                                                    SDMA_DESC_CMDSTAT_F |
+                                                    SDMA_DESC_CMDSTAT_L);
+                        wmb();
+                        dma_cache_sync(pi->port.dev, (void *)rxre,
+                                       MPSC_RXRE_SIZE, DMA_BIDIRECTIONAL);
+#if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
+                        if (pi->cache_mgmt) /* GT642[46]0 Res #COMM-2 */
+                                flush_dcache_range((ulong)rxre,
+                                           (ulong)rxre + MPSC_RXRE_SIZE);
+#endif
+                        /* Advance to next descriptor */
+                        pi->rxr_posn = (pi->rxr_posn + 1) &
+                                (MPSC_RXR_ENTRIES - 1);
+                        rxre = (struct mpsc_rx_desc *)(pi->rxr +
+                                       (pi->rxr_posn * MPSC_RXRE_SIZE));
+                        dma_cache_sync(pi->port.dev, (void *)rxre,
+                                       MPSC_RXRE_SIZE, DMA_FROM_DEVICE);
+#if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
+                        if (pi->cache_mgmt) /* GT642[46]0 Res #COMM-2 */
+                                invalidate_dcache_range((ulong)rxre,
+                                                (ulong)rxre + MPSC_RXRE_SIZE);
+#endif
+                }
+                /* Restart rx engine, if its stopped */
+                if ((readl(pi->sdma_base + SDMA_SDCM) & SDMA_SDCM_ERD) == 0)
+                        mpsc_start_rx(pi);
+        }
+        if (poll_cnt) {
+                poll_cnt--;
+                return poll_buf[poll_ptr++];
+        }
+        return 0;
+}
+static void mpsc_put_poll_char(struct uart_port *port,
+                         unsigned char c)
+{
+        struct mpsc_port_info *pi = (struct mpsc_port_info *)port;
+        u32 data;
+        data = readl(pi->mpsc_base + MPSC_MPCR);
+        writeb(c, pi->mpsc_base + MPSC_CHR_1);
+        mb();
+        data = readl(pi->mpsc_base + MPSC_CHR_2);
+        data |= MPSC_CHR_2_TTCS;
+        writel(data, pi->mpsc_base + MPSC_CHR_2);
+        mb();
+        while (readl(pi->mpsc_base + MPSC_CHR_2) & MPSC_CHR_2_TTCS);
+}
+#endif
 static struct uart_ops mpsc_pops = {
        .tx_empty       = mpsc_tx_empty,
@@ -1537,6 +1679,10 @@ static struct uart_ops mpsc_pops = {
        .request_port   = mpsc_request_port,
        .config_port    = mpsc_config_port,
        .verify_port    = mpsc_verify_port,
+#ifdef CONFIG_CONSOLE_POLL
+        .poll_get_char = mpsc_get_poll_char,
+        .poll_put_char = mpsc_put_poll_char,
+#endif
 };
 /*
@@ -1972,7 +2118,7 @@ static int __init mpsc_drv_init(void)
 {
        int     rc;
-        printk(KERN_INFO "Serial: MPSC driver $Revision: 1.00 $\n");
+        printk(KERN_INFO "Serial: MPSC driver\n");
        memset(mpsc_ports, 0, sizeof(mpsc_ports));
        memset(&mpsc_shared_regs, 0, sizeof(mpsc_shared_regs));
@@ -2004,7 +2150,7 @@ module_init(mpsc_drv_init);
 module_exit(mpsc_drv_exit);
 MODULE_AUTHOR("Mark A. Greer <mgreer@mvista.com>");
-MODULE_DESCRIPTION("Generic Marvell MPSC serial/UART driver $Revision: 1.00 $");
+MODULE_DESCRIPTION("Generic Marvell MPSC serial/UART driver");
 MODULE_VERSION(MPSC_VERSION);
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_CHARDEV_MAJOR(MPSC_MAJOR);
diff --git a/drivers/serial/mux.c b/drivers/serial/mux.c
index e94031731a47..953a5ffa9b44 100644
--- a/drivers/serial/mux.c
+++ b/drivers/serial/mux.c
@@ -243,7 +243,7 @@ static void mux_write(struct uart_port *port)
 static void mux_read(struct uart_port *port)
 {
        int data;
-        struct tty_struct *tty = port->info->tty;
+        struct tty_struct *tty = port->info->port.tty;
        __u32 start_count = port->icount.rx;
        while(1) {
diff --git a/drivers/serial/netx-serial.c b/drivers/serial/netx-serial.c
index 81ac9bb4f39b..3f489329e8d3 100644
--- a/drivers/serial/netx-serial.c
+++ b/drivers/serial/netx-serial.c
@@ -35,8 +35,8 @@
 #include <asm/io.h>
 #include <asm/irq.h>
-#include <asm/hardware.h>
+#include <mach/hardware.h>
-#include <asm/arch/netx-regs.h>
+#include <mach/netx-regs.h>
 /* We've been assigned a range on the "Low-density serial ports" major */
 #define SERIAL_NX_MAJOR 204
@@ -203,7 +203,7 @@ static void netx_txint(struct uart_port *port)
 static void netx_rxint(struct uart_port *port)
 {
        unsigned char rx, flg, status;
-        struct tty_struct *tty = port->info->tty;
+        struct tty_struct *tty = port->info->port.tty;
        while (!(readl(port->membase + UART_FR) & FR_RXFE)) {
                rx = readl(port->membase + UART_DR);
diff --git a/drivers/serial/pmac_zilog.c b/drivers/serial/pmac_zilog.c
index 794bd0f50d73..317b061f7641 100644
--- a/drivers/serial/pmac_zilog.c
+++ b/drivers/serial/pmac_zilog.c
@@ -242,12 +242,12 @@ static struct tty_struct *pmz_receive_chars(struct uart_pmac_port *uap)
        }
        /* Sanity check, make sure the old bug is no longer happening */
-        if (uap->port.info == NULL || uap->port.info->tty == NULL) {
+        if (uap->port.info == NULL || uap->port.info->port.tty == NULL) {
                WARN_ON(1);
                (void)read_zsdata(uap);
                return NULL;
        }
-        tty = uap->port.info->tty;
+        tty = uap->port.info->port.tty;
        while (1) {
                error = 0;
diff --git a/drivers/serial/pnx8xxx_uart.c b/drivers/serial/pnx8xxx_uart.c
index d0e5a79ea635..22e30d21225e 100644
--- a/drivers/serial/pnx8xxx_uart.c
+++ b/drivers/serial/pnx8xxx_uart.c
@@ -181,7 +181,7 @@ static void pnx8xxx_enable_ms(struct uart_port *port)
 static void pnx8xxx_rx_chars(struct pnx8xxx_port *sport)
 {
-        struct tty_struct *tty = sport->port.info->tty;
+        struct tty_struct *tty = sport->port.info->port.tty;
        unsigned int status, ch, flg;
        status = FIFO_TO_SM(serial_in(sport, PNX8XXX_FIFO)) |
@@ -824,7 +824,7 @@ static int __init pnx8xxx_serial_init(void)
 {
        int ret;
-        printk(KERN_INFO "Serial: PNX8XXX driver $Revision: 1.2 $\n");
+        printk(KERN_INFO "Serial: PNX8XXX driver\n");
        pnx8xxx_init_ports();
diff --git a/drivers/serial/pxa.c b/drivers/serial/pxa.c
index b4f7ffb7688d..abc00be55433 100644
--- a/drivers/serial/pxa.c
+++ b/drivers/serial/pxa.c
@@ -45,9 +45,9 @@
 #include <linux/clk.h>
 #include <asm/io.h>
-#include <asm/hardware.h>
+#include <mach/hardware.h>
 #include <asm/irq.h>
-#include <asm/arch/pxa-regs.h>
+#include <mach/pxa-regs.h>
 struct uart_pxa_port {
@@ -101,7 +101,7 @@ static void serial_pxa_stop_rx(struct uart_port *port)
 static inline void receive_chars(struct uart_pxa_port *up, int *status)
 {
-        struct tty_struct *tty = up->port.info->tty;
+        struct tty_struct *tty = up->port.info->port.tty;
        unsigned int ch, flag;
        int max_count = 256;
@@ -534,6 +534,11 @@ serial_pxa_set_termios(struct uart_port *port, struct ktermios *termios,
        serial_out(up, UART_IER, up->ier);
+        if (termios->c_cflag & CRTSCTS)
+                up->mcr |= UART_MCR_AFE;
+        else
+                up->mcr &= ~UART_MCR_AFE;
        serial_out(up, UART_LCR, cval | UART_LCR_DLAB);/* set DLAB */
        serial_out(up, UART_DLL, quot & 0xff);          /* LS of divisor */
        serial_out(up, UART_DLM, quot >> 8);            /* MS of divisor */
diff --git a/drivers/serial/s3c2400.c b/drivers/serial/s3c2400.c
index a1102053e553..4873f2978bd2 100644
--- a/drivers/serial/s3c2400.c
+++ b/drivers/serial/s3c2400.c
@@ -17,10 +17,10 @@
 #include <asm/irq.h>
-#include <asm/hardware.h>
+#include <mach/hardware.h>
-#include <asm/plat-s3c/regs-serial.h>
+#include <plat/regs-serial.h>
-#include <asm/arch/regs-gpio.h>
+#include <mach/regs-gpio.h>
 #include "samsung.h"
diff --git a/drivers/serial/s3c2410.c b/drivers/serial/s3c2410.c
index c5f03f41686f..87c182ef71b8 100644
--- a/drivers/serial/s3c2410.c
+++ b/drivers/serial/s3c2410.c
@@ -19,10 +19,10 @@
 #include <linux/serial.h>
 #include <asm/irq.h>
-#include <asm/hardware.h>
+#include <mach/hardware.h>
-#include <asm/plat-s3c/regs-serial.h>
+#include <plat/regs-serial.h>
-#include <asm/arch/regs-gpio.h>
+#include <mach/regs-gpio.h>
 #include "samsung.h"
diff --git a/drivers/serial/s3c2412.c b/drivers/serial/s3c2412.c
index ce0c220e3e92..fd017b375568 100644
--- a/drivers/serial/s3c2412.c
+++ b/drivers/serial/s3c2412.c
@@ -19,10 +19,10 @@
 #include <linux/serial.h>
 #include <asm/irq.h>
-#include <asm/hardware.h>
+#include <mach/hardware.h>
-#include <asm/plat-s3c/regs-serial.h>
+#include <plat/regs-serial.h>
-#include <asm/arch/regs-gpio.h>
+#include <mach/regs-gpio.h>
 #include "samsung.h"
diff --git a/drivers/serial/s3c2440.c b/drivers/serial/s3c2440.c
index 38f954bd39c6..317d239ab740 100644
--- a/drivers/serial/s3c2440.c
+++ b/drivers/serial/s3c2440.c
@@ -19,10 +19,10 @@
 #include <linux/serial.h>
 #include <asm/irq.h>
-#include <asm/hardware.h>
+#include <mach/hardware.h>
-#include <asm/plat-s3c/regs-serial.h>
+#include <plat/regs-serial.h>
-#include <asm/arch/regs-gpio.h>
+#include <mach/regs-gpio.h>
 #include "samsung.h"
diff --git a/drivers/serial/sa1100.c b/drivers/serial/sa1100.c
index 62b38582f5e9..b24a25ea6bc5 100644
--- a/drivers/serial/sa1100.c
+++ b/drivers/serial/sa1100.c
@@ -20,9 +20,6 @@
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- *  $Id: sa1100.c,v 1.50 2002/07/29 14:41:04 rmk Exp $
- *
 */
 #if defined(CONFIG_SERIAL_SA1100_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
@@ -42,7 +39,7 @@
 #include <asm/io.h>
 #include <asm/irq.h>
-#include <asm/hardware.h>
+#include <mach/hardware.h>
 #include <asm/mach/serial_sa1100.h>
 /* We've been assigned a range on the "Low-density serial ports" major */
@@ -192,7 +189,7 @@ static void sa1100_enable_ms(struct uart_port *port)
 static void
 sa1100_rx_chars(struct sa1100_port *sport)
 {
-        struct tty_struct *tty = sport->port.info->tty;
+        struct tty_struct *tty = sport->port.info->port.tty;
        unsigned int status, ch, flg;
        status = UTSR1_TO_SM(UART_GET_UTSR1(sport)) |
@@ -892,7 +889,7 @@ static int __init sa1100_serial_init(void)
 {
        int ret;
-        printk(KERN_INFO "Serial: SA11x0 driver $Revision: 1.50 $\n");
+        printk(KERN_INFO "Serial: SA11x0 driver\n");
        sa1100_init_ports();
@@ -915,7 +912,7 @@ module_init(sa1100_serial_init);
 module_exit(sa1100_serial_exit);
 MODULE_AUTHOR("Deep Blue Solutions Ltd");
-MODULE_DESCRIPTION("SA1100 generic serial port driver $Revision: 1.50 $");
+MODULE_DESCRIPTION("SA1100 generic serial port driver");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_CHARDEV_MAJOR(SERIAL_SA1100_MAJOR);
 MODULE_ALIAS("platform:sa11x0-uart");
diff --git a/drivers/serial/samsung.c b/drivers/serial/samsung.c
index 4a3ecaa629e6..1e219d3d0352 100644
--- a/drivers/serial/samsung.c
+++ b/drivers/serial/samsung.c
@@ -45,10 +45,10 @@
 #include <asm/irq.h>
-#include <asm/hardware.h>
+#include <mach/hardware.h>
-#include <asm/plat-s3c/regs-serial.h>
+#include <plat/regs-serial.h>
-#include <asm/arch/regs-gpio.h>
+#include <mach/regs-gpio.h>
 #include "samsung.h"
@@ -202,7 +202,7 @@ s3c24xx_serial_rx_chars(int irq, void *dev_id)
 {
        struct s3c24xx_uart_port *ourport = dev_id;
        struct uart_port *port = &ourport->port;
-        struct tty_struct *tty = port->info->tty;
+        struct tty_struct *tty = port->info->port.tty;
        unsigned int ufcon, ch, flag, ufstat, uerstat;
        int max_count = 64;
diff --git a/drivers/serial/sb1250-duart.c b/drivers/serial/sb1250-duart.c
index f8e1447a022a..a4fb343a08da 100644
--- a/drivers/serial/sb1250-duart.c
+++ b/drivers/serial/sb1250-duart.c
@@ -384,7 +384,7 @@ static void sbd_receive_chars(struct sbd_port *sport)
                uart_insert_char(uport, status, M_DUART_OVRUN_ERR, ch, flag);
        }
-        tty_flip_buffer_push(uport->info->tty);
+        tty_flip_buffer_push(uport->info->port.tty);
 }
 static void sbd_transmit_chars(struct sbd_port *sport)
diff --git a/drivers/serial/sc26xx.c b/drivers/serial/sc26xx.c
index ae2a9e2df777..e0be11ceaa25 100644
--- a/drivers/serial/sc26xx.c
+++ b/drivers/serial/sc26xx.c
@@ -141,7 +141,7 @@ static struct tty_struct *receive_chars(struct uart_port *port)
        u8 status;
        if (port->info != NULL)         /* Unopened serial console */
-                tty = port->info->tty;
+                tty = port->info->port.tty;
        while (limit-- > 0) {
                status = READ_SC_PORT(port, SR);
diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c
index 42d2e108b679..874786a11fe9 100644
--- a/drivers/serial/serial_core.c
+++ b/drivers/serial/serial_core.c
@@ -50,7 +50,7 @@ static struct lock_class_key port_lock_key;
 #define HIGH_BITS_OFFSET        ((sizeof(long)-sizeof(int))*8)
-#define uart_users(state)       ((state)->count + ((state)->info ? (state)->info->blocked_open : 0))
+#define uart_users(state)       ((state)->count + ((state)->info ? (state)->info->port.blocked_open : 0))
 #ifdef CONFIG_SERIAL_CORE_CONSOLE
 #define uart_console(port)      ((port)->cons && (port)->cons->index == (port)->line)
@@ -113,7 +113,7 @@ static void uart_start(struct tty_struct *tty)
 static void uart_tasklet_action(unsigned long data)
 {
        struct uart_state *state = (struct uart_state *)data;
-        tty_wakeup(state->info->tty);
+        tty_wakeup(state->info->port.tty);
 }
 static inline void
@@ -135,7 +135,7 @@ uart_update_mctrl(struct uart_port *port, unsigned int set, unsigned int clear)
 /*
 * Startup the port.  This will be called once per open.  All calls
- * will be serialised by the per-port semaphore.
+ * will be serialised by the per-port mutex.
 */
 static int uart_startup(struct uart_state *state, int init_hw)
 {
@@ -152,7 +152,7 @@ static int uart_startup(struct uart_state *state, int init_hw)
         * once we have successfully opened the port.  Also set
         * up the tty->alt_speed kludge
         */
-        set_bit(TTY_IO_ERROR, &info->tty->flags);
+        set_bit(TTY_IO_ERROR, &info->port.tty->flags);
        if (port->type == PORT_UNKNOWN)
                return 0;
@@ -162,6 +162,7 @@ static int uart_startup(struct uart_state *state, int init_hw)
         * buffer.
         */
        if (!info->xmit.buf) {
+                /* This is protected by the per port mutex */
                page = get_zeroed_page(GFP_KERNEL);
                if (!page)
                        return -ENOMEM;
@@ -182,20 +183,20 @@ static int uart_startup(struct uart_state *state, int init_hw)
                         * Setup the RTS and DTR signals once the
                         * port is open and ready to respond.
                         */
-                        if (info->tty->termios->c_cflag & CBAUD)
+                        if (info->port.tty->termios->c_cflag & CBAUD)
                                uart_set_mctrl(port, TIOCM_RTS | TIOCM_DTR);
                }
                if (info->flags & UIF_CTS_FLOW) {
                        spin_lock_irq(&port->lock);
                        if (!(port->ops->get_mctrl(port) & TIOCM_CTS))
-                                info->tty->hw_stopped = 1;
+                                info->port.tty->hw_stopped = 1;
                        spin_unlock_irq(&port->lock);
                }
                info->flags |= UIF_INITIALIZED;
-                clear_bit(TTY_IO_ERROR, &info->tty->flags);
+                clear_bit(TTY_IO_ERROR, &info->port.tty->flags);
        }
        if (retval && capable(CAP_SYS_ADMIN))
@@ -217,8 +218,8 @@ static void uart_shutdown(struct uart_state *state)
        /*
         * Set the TTY IO error marker
         */
-        if (info->tty)
+        if (info->port.tty)
-                set_bit(TTY_IO_ERROR, &info->tty->flags);
+                set_bit(TTY_IO_ERROR, &info->port.tty->flags);
        if (info->flags & UIF_INITIALIZED) {
                info->flags &= ~UIF_INITIALIZED;
@@ -226,7 +227,7 @@ static void uart_shutdown(struct uart_state *state)
                /*
                 * Turn off DTR and RTS early.
                 */
-                if (!info->tty || (info->tty->termios->c_cflag & HUPCL))
+                if (!info->port.tty || (info->port.tty->termios->c_cflag & HUPCL))
                        uart_clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
                /*
@@ -426,7 +427,7 @@ EXPORT_SYMBOL(uart_get_divisor);
 static void
 uart_change_speed(struct uart_state *state, struct ktermios *old_termios)
 {
-        struct tty_struct *tty = state->info->tty;
+        struct tty_struct *tty = state->info->port.tty;
        struct uart_port *port = state->port;
        struct ktermios *termios;
@@ -573,6 +574,8 @@ static void uart_flush_buffer(struct tty_struct *tty)
        spin_lock_irqsave(&port->lock, flags);
        uart_circ_clear(&state->info->xmit);
+        if (port->ops->flush_buffer)
+                port->ops->flush_buffer(port);
        spin_unlock_irqrestore(&port->lock, flags);
        tty_wakeup(tty);
 }
@@ -738,7 +741,7 @@ static int uart_set_info(struct uart_state *state,
        if (port->ops->verify_port)
                retval = port->ops->verify_port(port, &new_serial);
-        if ((new_serial.irq >= NR_IRQS) || (new_serial.irq < 0) ||
+        if ((new_serial.irq >= nr_irqs) || (new_serial.irq < 0) ||
            (new_serial.baud_base < 9600))
                retval = -EINVAL;
@@ -834,8 +837,8 @@ static int uart_set_info(struct uart_state *state,
        state->closing_wait    = closing_wait;
        if (new_serial.xmit_fifo_size)
                port->fifosize = new_serial.xmit_fifo_size;
-        if (state->info->tty)
+        if (state->info->port.tty)
-                state->info->tty->low_latency =
+                state->info->port.tty->low_latency =
                        (port->flags & UPF_LOW_LATENCY) ? 1 : 0;
 check_and_exit:
@@ -855,7 +858,7 @@ static int uart_set_info(struct uart_state *state,
                                printk(KERN_NOTICE
                                       "%s sets custom speed on %s. This "
                                       "is deprecated.\n", current->comm,
-                                       tty_name(state->info->tty, buf));
+                                       tty_name(state->info->port.tty, buf));
                        }
                        uart_change_speed(state, NULL);
                }
@@ -887,7 +890,7 @@ static int uart_get_lsr_info(struct uart_state *state,
         */
        if (port->x_char ||
            ((uart_circ_chars_pending(&state->info->xmit) > 0) &&
-             !state->info->tty->stopped && !state->info->tty->hw_stopped))
+             !state->info->port.tty->stopped && !state->info->port.tty->hw_stopped))
                result &= ~TIOCSER_TEMT;
        return put_user(result, value);
@@ -931,7 +934,7 @@ uart_tiocmset(struct tty_struct *tty, struct file *file,
        return ret;
 }
-static void uart_break_ctl(struct tty_struct *tty, int break_state)
+static int uart_break_ctl(struct tty_struct *tty, int break_state)
 {
        struct uart_state *state = tty->driver_data;
        struct uart_port *port = state->port;
@@ -942,6 +945,7 @@ static void uart_break_ctl(struct tty_struct *tty, int break_state)
                port->ops->break_ctl(port, break_state);
        mutex_unlock(&state->mutex);
+        return 0;
 }
 static int uart_do_autoconfig(struct uart_state *state)
@@ -1237,7 +1241,7 @@ static void uart_set_termios(struct tty_struct *tty,
         */
        if (!(old_termios->c_cflag & CLOCAL) &&
            (tty->termios->c_cflag & CLOCAL))
-                wake_up_interruptible(&state->info->open_wait);
+                wake_up_interruptible(&state->info->port.open_wait);
 #endif
 }
@@ -1318,9 +1322,9 @@ static void uart_close(struct tty_struct *tty, struct file *filp)
        tty_ldisc_flush(tty);
        tty->closing = 0;
-        state->info->tty = NULL;
+        state->info->port.tty = NULL;
-        if (state->info->blocked_open) {
+        if (state->info->port.blocked_open) {
                if (state->close_delay)
                        msleep_interruptible(state->close_delay);
        } else if (!uart_console(port)) {
@@ -1331,7 +1335,7 @@ static void uart_close(struct tty_struct *tty, struct file *filp)
         * Wake up anyone trying to open this port.
         */
        state->info->flags &= ~UIF_NORMAL_ACTIVE;
-        wake_up_interruptible(&state->info->open_wait);
+        wake_up_interruptible(&state->info->port.open_wait);
 done:
        mutex_unlock(&state->mutex);
@@ -1415,8 +1419,8 @@ static void uart_hangup(struct tty_struct *tty)
                uart_shutdown(state);
                state->count = 0;
                state->info->flags &= ~UIF_NORMAL_ACTIVE;
-                state->info->tty = NULL;
+                state->info->port.tty = NULL;
-                wake_up_interruptible(&state->info->open_wait);
+                wake_up_interruptible(&state->info->port.open_wait);
                wake_up_interruptible(&state->info->delta_msr_wait);
        }
        mutex_unlock(&state->mutex);
@@ -1430,7 +1434,7 @@ static void uart_hangup(struct tty_struct *tty)
 */
 static void uart_update_termios(struct uart_state *state)
 {
-        struct tty_struct *tty = state->info->tty;
+        struct tty_struct *tty = state->info->port.tty;
        struct uart_port *port = state->port;
        if (uart_console(port) && port->cons->cflag) {
@@ -1469,17 +1473,17 @@ uart_block_til_ready(struct file *filp, struct uart_state *state)
        struct uart_port *port = state->port;
        unsigned int mctrl;
-        info->blocked_open++;
+        info->port.blocked_open++;
        state->count--;
-        add_wait_queue(&info->open_wait, &wait);
+        add_wait_queue(&info->port.open_wait, &wait);
        while (1) {
                set_current_state(TASK_INTERRUPTIBLE);
                /*
                 * If we have been hung up, tell userspace/restart open.
                 */
-                if (tty_hung_up_p(filp) || info->tty == NULL)
+                if (tty_hung_up_p(filp) || info->port.tty == NULL)
                        break;
                /*
@@ -1498,8 +1502,8 @@ uart_block_til_ready(struct file *filp, struct uart_state *state)
                 * have set TTY_IO_ERROR for a non-existant port.
                 */
                if ((filp->f_flags & O_NONBLOCK) ||
-                    (info->tty->termios->c_cflag & CLOCAL) ||
+                    (info->port.tty->termios->c_cflag & CLOCAL) ||
-                    (info->tty->flags & (1 << TTY_IO_ERROR)))
+                    (info->port.tty->flags & (1 << TTY_IO_ERROR)))
                        break;
                /*
@@ -1507,7 +1511,7 @@ uart_block_til_ready(struct file *filp, struct uart_state *state)
                 * not set RTS here - we want to make sure we catch
                 * the data from the modem.
                 */
-                if (info->tty->termios->c_cflag & CBAUD)
+                if (info->port.tty->termios->c_cflag & CBAUD)
                        uart_set_mctrl(port, TIOCM_DTR);
                /*
@@ -1529,15 +1533,15 @@ uart_block_til_ready(struct file *filp, struct uart_state *state)
                        break;
        }
        set_current_state(TASK_RUNNING);
-        remove_wait_queue(&info->open_wait, &wait);
+        remove_wait_queue(&info->port.open_wait, &wait);
        state->count++;
-        info->blocked_open--;
+        info->port.blocked_open--;
        if (signal_pending(current))
                return -ERESTARTSYS;
-        if (!info->tty || tty_hung_up_p(filp))
+        if (!info->port.tty || tty_hung_up_p(filp))
                return -EAGAIN;
        return 0;
@@ -1560,10 +1564,13 @@ static struct uart_state *uart_get(struct uart_driver *drv, int line)
                goto err_unlock;
        }
+        /* BKL: RACE HERE - LEAK */
+        /* We should move this into the uart_state structure and kill off
+           this whole complexity */
        if (!state->info) {
                state->info = kzalloc(sizeof(struct uart_info), GFP_KERNEL);
                if (state->info) {
-                        init_waitqueue_head(&state->info->open_wait);
+                        init_waitqueue_head(&state->info->port.open_wait);
                        init_waitqueue_head(&state->info->delta_msr_wait);
                        /*
@@ -1620,7 +1627,7 @@ static int uart_open(struct tty_struct *tty, struct file *filp)
         * be re-entered while allocating the info structure, or while we
         * request any IRQs that the driver may need.  This also has the nice
         * side-effect that it delays the action of uart_hangup, so we can
-         * guarantee that info->tty will always contain something reasonable.
+         * guarantee that info->port.tty will always contain something reasonable.
         */
        state = uart_get(drv, line);
        if (IS_ERR(state)) {
@@ -1636,7 +1643,7 @@ static int uart_open(struct tty_struct *tty, struct file *filp)
        tty->driver_data = state;
        tty->low_latency = (state->port->flags & UPF_LOW_LATENCY) ? 1 : 0;
        tty->alt_speed = 0;
-        state->info->tty = tty;
+        state->info->port.tty = tty;
        /*
         * If the port is in the middle of closing, bail out now.
@@ -2044,7 +2051,8 @@ int uart_suspend_port(struct uart_driver *drv, struct uart_port *port)
                                        "transmitter\n",
                               port->dev ? port->dev->bus_id : "",
                               port->dev ? ": " : "",
-                               drv->dev_name, port->line);
+                               drv->dev_name,
+                               drv->tty_driver->name_base + port->line);
                ops->shutdown(port);
        }
@@ -2099,8 +2107,8 @@ int uart_resume_port(struct uart_driver *drv, struct uart_port *port)
                /*
                 * If that's unset, use the tty termios setting.
                 */
-                if (state->info && state->info->tty && termios.c_cflag == 0)
+                if (state->info && state->info->port.tty && termios.c_cflag == 0)
-                        termios = *state->info->tty->termios;
+                        termios = *state->info->port.tty->termios;
                uart_change_pm(state, 0);
                port->ops->set_termios(port, &termios, NULL);
@@ -2147,12 +2155,11 @@ uart_report_port(struct uart_driver *drv, struct uart_port *port)
        switch (port->iotype) {
        case UPIO_PORT:
-                snprintf(address, sizeof(address),
+                snprintf(address, sizeof(address), "I/O 0x%lx", port->iobase);
-                         "I/O 0x%x", port->iobase);
                break;
        case UPIO_HUB6:
                snprintf(address, sizeof(address),
-                         "I/O 0x%x offset 0x%x", port->iobase, port->hub6);
+                         "I/O 0x%lx offset 0x%x", port->iobase, port->hub6);
                break;
        case UPIO_MEM:
        case UPIO_MEM32:
@@ -2170,7 +2177,9 @@ uart_report_port(struct uart_driver *drv, struct uart_port *port)
        printk(KERN_INFO "%s%s%s%d at %s (irq = %d) is a %s\n",
               port->dev ? port->dev->bus_id : "",
               port->dev ? ": " : "",
-               drv->dev_name, port->line, address, port->irq, uart_type(port));
+               drv->dev_name,
+               drv->tty_driver->name_base + port->line,
+               address, port->irq, uart_type(port));
 }
 static void
@@ -2519,8 +2528,8 @@ int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port)
        tty_unregister_device(drv->tty_driver, port->line);
        info = state->info;
-        if (info && info->tty)
+        if (info && info->port.tty)
-                tty_vhangup(info->tty);
+                tty_vhangup(info->port.tty);
        /*
         * All users of this port should now be disconnected from
diff --git a/drivers/serial/serial_cs.c b/drivers/serial/serial_cs.c
index 164d2a42eb59..7546aa887fa7 100644
--- a/drivers/serial/serial_cs.c
+++ b/drivers/serial/serial_cs.c
@@ -431,131 +431,103 @@ first_tuple(struct pcmcia_device *handle, tuple_t * tuple, cisparse_t * parse)
 {
        int i;
        i = pcmcia_get_first_tuple(handle, tuple);
-        if (i != CS_SUCCESS)
+        if (i != 0)
-                return CS_NO_MORE_ITEMS;
-        i = pcmcia_get_tuple_data(handle, tuple);
-        if (i != CS_SUCCESS)
                return i;
-        return pcmcia_parse_tuple(handle, tuple, parse);
-}
-static int
-next_tuple(struct pcmcia_device *handle, tuple_t * tuple, cisparse_t * parse)
-{
-        int i;
-        i = pcmcia_get_next_tuple(handle, tuple);
-        if (i != CS_SUCCESS)
-                return CS_NO_MORE_ITEMS;
        i = pcmcia_get_tuple_data(handle, tuple);
-        if (i != CS_SUCCESS)
+        if (i != 0)
                return i;
-        return pcmcia_parse_tuple(handle, tuple, parse);
+        return pcmcia_parse_tuple(tuple, parse);
 }
 /*====================================================================*/
-static int simple_config(struct pcmcia_device *link)
+static int simple_config_check(struct pcmcia_device *p_dev,
+                               cistpl_cftable_entry_t *cf,
+                               cistpl_cftable_entry_t *dflt,
+                               unsigned int vcc,
+                               void *priv_data)
 {
-        static const unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
        static const int size_table[2] = { 8, 16 };
-        struct serial_info *info = link->priv;
+        int *try = priv_data;
-        struct serial_cfg_mem *cfg_mem;
-        tuple_t *tuple;
+        if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
-        u_char *buf;
+                p_dev->conf.Vpp =
-        cisparse_t *parse;
+                        cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
-        cistpl_cftable_entry_t *cf;
-        config_info_t config;
+        if ((cf->io.nwin > 0) && (cf->io.win[0].len == size_table[(*try >> 1)])
-        int i, j, try;
+            && (cf->io.win[0].base != 0)) {
-        int s;
+                p_dev->io.BasePort1 = cf->io.win[0].base;
+                p_dev->io.IOAddrLines = ((*try & 0x1) == 0) ?
+                        16 : cf->io.flags & CISTPL_IO_LINES_MASK;
+                if (!pcmcia_request_io(p_dev, &p_dev->io))
+                        return 0;
+        }
+        return -EINVAL;
+}
-        cfg_mem = kmalloc(sizeof(struct serial_cfg_mem), GFP_KERNEL);
+static int simple_config_check_notpicky(struct pcmcia_device *p_dev,
-        if (!cfg_mem)
+                                        cistpl_cftable_entry_t *cf,
-                return -1;
+                                        cistpl_cftable_entry_t *dflt,
+                                        unsigned int vcc,
+                                        void *priv_data)
+{
+        static const unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
+        int j;
+        if ((cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
+                for (j = 0; j < 5; j++) {
+                        p_dev->io.BasePort1 = base[j];
+                        p_dev->io.IOAddrLines = base[j] ? 16 : 3;
+                        if (!pcmcia_request_io(p_dev, &p_dev->io))
+                                return 0;
+                }
+        }
+        return -ENODEV;
+}
-        tuple = &cfg_mem->tuple;
+static int simple_config(struct pcmcia_device *link)
-        parse = &cfg_mem->parse;
+{
-        cf = &parse->cftable_entry;
+        struct serial_info *info = link->priv;
-        buf = cfg_mem->buf;
+        int i = -ENODEV, try;
        /* If the card is already configured, look up the port and irq */
-        i = pcmcia_get_configuration_info(link, &config);
+        if (link->function_config) {
-        if ((i == CS_SUCCESS) && (config.Attributes & CONF_VALID_CLIENT)) {
                unsigned int port = 0;
-                if ((config.BasePort2 != 0) && (config.NumPorts2 == 8)) {
+                if ((link->io.BasePort2 != 0) &&
-                        port = config.BasePort2;
+                    (link->io.NumPorts2 == 8)) {
+                        port = link->io.BasePort2;
                        info->slave = 1;
                } else if ((info->manfid == MANFID_OSITECH) &&
-                           (config.NumPorts1 == 0x40)) {
+                           (link->io.NumPorts1 == 0x40)) {
-                        port = config.BasePort1 + 0x28;
+                        port = link->io.BasePort1 + 0x28;
                        info->slave = 1;
                }
                if (info->slave) {
-                        kfree(cfg_mem);
+                        return setup_serial(link, info, port,
-                        return setup_serial(link, info, port, config.AssignedIRQ);
+                                            link->irq.AssignedIRQ);
                }
        }
-        /* First pass: look for a config entry that looks normal. */
+        /* First pass: look for a config entry that looks normal.
-        tuple->TupleData = (cisdata_t *) buf;
+         * Two tries: without IO aliases, then with aliases */
-        tuple->TupleOffset = 0;
+        for (try = 0; try < 4; try++)
-        tuple->TupleDataMax = 255;
+                if (!pcmcia_loop_config(link, simple_config_check, &try))
-        tuple->Attributes = 0;
+                        goto found_port;
-        tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
-        /* Two tries: without IO aliases, then with aliases */
-        for (s = 0; s < 2; s++) {
-                for (try = 0; try < 2; try++) {
-                        i = first_tuple(link, tuple, parse);
-                        while (i != CS_NO_MORE_ITEMS) {
-                                if (i != CS_SUCCESS)
-                                        goto next_entry;
-                                if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
-                                        link->conf.Vpp =
-                                            cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
-                                if ((cf->io.nwin > 0) && (cf->io.win[0].len == size_table[s]) &&
-                                            (cf->io.win[0].base != 0)) {
-                                        link->conf.ConfigIndex = cf->index;
-                                        link->io.BasePort1 = cf->io.win[0].base;
-                                        link->io.IOAddrLines = (try == 0) ?
-                                            16 : cf->io.flags & CISTPL_IO_LINES_MASK;
-                                        i = pcmcia_request_io(link, &link->io);
-                                        if (i == CS_SUCCESS)
-                                                goto found_port;
-                                }
-next_entry:
-                                i = next_tuple(link, tuple, parse);
-                        }
-                }
-        }
        /* Second pass: try to find an entry that isn't picky about
           its base address, then try to grab any standard serial port
           address, and finally try to get any free port. */
-        i = first_tuple(link, tuple, parse);
+        if (!pcmcia_loop_config(link, simple_config_check_notpicky, NULL))
-        while (i != CS_NO_MORE_ITEMS) {
+                goto found_port;
-                if ((i == CS_SUCCESS) && (cf->io.nwin > 0) &&
-                    ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
-                        link->conf.ConfigIndex = cf->index;
-                        for (j = 0; j < 5; j++) {
-                                link->io.BasePort1 = base[j];
-                                link->io.IOAddrLines = base[j] ? 16 : 3;
-                                i = pcmcia_request_io(link, &link->io);
-                                if (i == CS_SUCCESS)
-                                        goto found_port;
-                        }
-                }
-                i = next_tuple(link, tuple, parse);
-        }
-      found_port:
+        printk(KERN_NOTICE
-        if (i != CS_SUCCESS) {
+               "serial_cs: no usable port range found, giving up\n");
-                printk(KERN_NOTICE
+        cs_error(link, RequestIO, i);
-                       "serial_cs: no usable port range found, giving up\n");
+        return -1;
-                cs_error(link, RequestIO, i);
-                kfree(cfg_mem);
-                return -1;
-        }
+found_port:
        i = pcmcia_request_irq(link, &link->irq);
-        if (i != CS_SUCCESS) {
+        if (i != 0) {
                cs_error(link, RequestIRQ, i);
                link->irq.AssignedIRQ = 0;
        }
@@ -569,88 +541,76 @@ next_entry:
                info->quirk->config(link);
        i = pcmcia_request_configuration(link, &link->conf);
-        if (i != CS_SUCCESS) {
+        if (i != 0) {
                cs_error(link, RequestConfiguration, i);
-                kfree(cfg_mem);
                return -1;
        }
-        kfree(cfg_mem);
        return setup_serial(link, info, link->io.BasePort1, link->irq.AssignedIRQ);
 }
-static int multi_config(struct pcmcia_device * link)
+static int multi_config_check(struct pcmcia_device *p_dev,
+                              cistpl_cftable_entry_t *cf,
+                              cistpl_cftable_entry_t *dflt,
+                              unsigned int vcc,
+                              void *priv_data)
 {
-        struct serial_info *info = link->priv;
+        int *base2 = priv_data;
-        struct serial_cfg_mem *cfg_mem;
-        tuple_t *tuple;
+        /* The quad port cards have bad CIS's, so just look for a
-        u_char *buf;
+           window larger than 8 ports and assume it will be right */
-        cisparse_t *parse;
+        if ((cf->io.nwin == 1) && (cf->io.win[0].len > 8)) {
-        cistpl_cftable_entry_t *cf;
+                p_dev->io.BasePort1 = cf->io.win[0].base;
-        int i, rc, base2 = 0;
+                p_dev->io.IOAddrLines = cf->io.flags & CISTPL_IO_LINES_MASK;
+                if (!pcmcia_request_io(p_dev, &p_dev->io)) {
+                        *base2 = p_dev->io.BasePort1 + 8;
+                        return 0;
+                }
+        }
+        return -ENODEV;
+}
-        cfg_mem = kmalloc(sizeof(struct serial_cfg_mem), GFP_KERNEL);
+static int multi_config_check_notpicky(struct pcmcia_device *p_dev,
-        if (!cfg_mem)
+                                       cistpl_cftable_entry_t *cf,
-                return -1;
+                                       cistpl_cftable_entry_t *dflt,
-        tuple = &cfg_mem->tuple;
+                                       unsigned int vcc,
-        parse = &cfg_mem->parse;
+                                       void *priv_data)
-        cf = &parse->cftable_entry;
+{
-        buf = cfg_mem->buf;
+        int *base2 = priv_data;
+        if (cf->io.nwin == 2) {
+                p_dev->io.BasePort1 = cf->io.win[0].base;
+                p_dev->io.BasePort2 = cf->io.win[1].base;
+                p_dev->io.IOAddrLines = cf->io.flags & CISTPL_IO_LINES_MASK;
+                if (!pcmcia_request_io(p_dev, &p_dev->io)) {
+                        *base2 = p_dev->io.BasePort2;
+                        return 0;
+                }
+        }
+        return -ENODEV;
+}
-        tuple->TupleData = (cisdata_t *) buf;
+static int multi_config(struct pcmcia_device *link)
-        tuple->TupleOffset = 0;
+{
-        tuple->TupleDataMax = 255;
+        struct serial_info *info = link->priv;
-        tuple->Attributes = 0;
+        int i, base2 = 0;
-        tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
        /* First, look for a generic full-sized window */
        link->io.NumPorts1 = info->multi * 8;
-        i = first_tuple(link, tuple, parse);
+        if (pcmcia_loop_config(link, multi_config_check, &base2)) {
-        while (i != CS_NO_MORE_ITEMS) {
+                /* If that didn't work, look for two windows */
-                /* The quad port cards have bad CIS's, so just look for a
-                   window larger than 8 ports and assume it will be right */
-                if ((i == CS_SUCCESS) && (cf->io.nwin == 1) &&
-                    (cf->io.win[0].len > 8)) {
-                        link->conf.ConfigIndex = cf->index;
-                        link->io.BasePort1 = cf->io.win[0].base;
-                        link->io.IOAddrLines =
-                            cf->io.flags & CISTPL_IO_LINES_MASK;
-                        i = pcmcia_request_io(link, &link->io);
-                        base2 = link->io.BasePort1 + 8;
-                        if (i == CS_SUCCESS)
-                                break;
-                }
-                i = next_tuple(link, tuple, parse);
-        }
-        /* If that didn't work, look for two windows */
-        if (i != CS_SUCCESS) {
                link->io.NumPorts1 = link->io.NumPorts2 = 8;
                info->multi = 2;
-                i = first_tuple(link, tuple, parse);
+                if (pcmcia_loop_config(link, multi_config_check_notpicky,
-                while (i != CS_NO_MORE_ITEMS) {
+                                       &base2)) {
-                        if ((i == CS_SUCCESS) && (cf->io.nwin == 2)) {
+                        printk(KERN_NOTICE "serial_cs: no usable port range"
-                                link->conf.ConfigIndex = cf->index;
+                               "found, giving up\n");
-                                link->io.BasePort1 = cf->io.win[0].base;
+                        return -ENODEV;
-                                link->io.BasePort2 = cf->io.win[1].base;
-                                link->io.IOAddrLines =
-                                    cf->io.flags & CISTPL_IO_LINES_MASK;
-                                i = pcmcia_request_io(link, &link->io);
-                                base2 = link->io.BasePort2;
-                                if (i == CS_SUCCESS)
-                                        break;
-                        }
-                        i = next_tuple(link, tuple, parse);
                }
        }
-        if (i != CS_SUCCESS) {
-                cs_error(link, RequestIO, i);
-                rc = -1;
-                goto free_cfg_mem;
-        }
        i = pcmcia_request_irq(link, &link->irq);
-        if (i != CS_SUCCESS) {
+        if (i != 0) {
+                /* FIXME: comment does not fit, error handling does not fit */
                printk(KERN_NOTICE
                       "serial_cs: no usable port range found, giving up\n");
                cs_error(link, RequestIRQ, i);
@@ -664,10 +624,9 @@ static int multi_config(struct pcmcia_device * link)
                info->quirk->config(link);
        i = pcmcia_request_configuration(link, &link->conf);
-        if (i != CS_SUCCESS) {
+        if (i != 0) {
                cs_error(link, RequestConfiguration, i);
-                rc = -1;
+                return -ENODEV;
-                goto free_cfg_mem;
        }
        /* The Oxford Semiconductor OXCF950 cards are in fact single-port:
@@ -678,7 +637,8 @@ static int multi_config(struct pcmcia_device * link)
                                info->prodid == PRODID_POSSIO_GCC)) {
                int err;
-                if (cf->index == 1 || cf->index == 3) {
+                if (link->conf.ConfigIndex == 1 ||
+                    link->conf.ConfigIndex == 3) {
                        err = setup_serial(link, info, base2,
                                        link->irq.AssignedIRQ);
                        base2 = link->io.BasePort1;
@@ -695,18 +655,14 @@ static int multi_config(struct pcmcia_device * link)
                if (info->quirk && info->quirk->wakeup)
                        info->quirk->wakeup(link);
-                rc = 0;
+                return 0;
-                goto free_cfg_mem;
        }
        setup_serial(link, info, link->io.BasePort1, link->irq.AssignedIRQ);
        for (i = 0; i < info->multi - 1; i++)
                setup_serial(link, info, base2 + (8 * i),
                                link->irq.AssignedIRQ);
-        rc = 0;
+        return 0;
-free_cfg_mem:
-        kfree(cfg_mem);
-        return rc;
 }
 /*======================================================================
@@ -746,7 +702,7 @@ static int serial_config(struct pcmcia_device * link)
        /* Is this a compliant multifunction card? */
        tuple->DesiredTuple = CISTPL_LONGLINK_MFC;
        tuple->Attributes = TUPLE_RETURN_COMMON | TUPLE_RETURN_LINK;
-        info->multi = (first_tuple(link, tuple, parse) == CS_SUCCESS);
+        info->multi = (first_tuple(link, tuple, parse) == 0);
        /* Is this a multiport card? */
        tuple->DesiredTuple = CISTPL_MANFID;
@@ -770,7 +726,7 @@ static int serial_config(struct pcmcia_device * link)
            ((link->func_id == CISTPL_FUNCID_MULTI) ||
             (link->func_id == CISTPL_FUNCID_SERIAL))) {
                tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
-                if (first_tuple(link, tuple, parse) == CS_SUCCESS) {
+                if (first_tuple(link, tuple, parse) == 0) {
                        if ((cf->io.nwin == 1) && (cf->io.win[0].len % 8 == 0))
                                info->multi = cf->io.win[0].len >> 3;
                        if ((cf->io.nwin == 2) && (cf->io.win[0].len == 8) &&
diff --git a/drivers/serial/serial_ks8695.c b/drivers/serial/serial_ks8695.c
index 8721afe1ae4f..998e89dc5aaf 100644
--- a/drivers/serial/serial_ks8695.c
+++ b/drivers/serial/serial_ks8695.c
@@ -26,8 +26,8 @@
 #include <asm/irq.h>
 #include <asm/mach/irq.h>
-#include <asm/arch/regs-uart.h>
+#include <mach/regs-uart.h>
-#include <asm/arch/regs-irq.h>
+#include <mach/regs-irq.h>
 #if defined(CONFIG_SERIAL_KS8695_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
 #define SUPPORT_SYSRQ
@@ -63,8 +63,44 @@
 #define UART_DUMMY_LSR_RX       0x100
 #define UART_PORT_SIZE          (KS8695_USR - KS8695_URRB + 4)
-#define tx_enabled(port) ((port)->unused[0])
+static inline int tx_enabled(struct uart_port *port)
-#define rx_enabled(port) ((port)->unused[1])
+{
+        return port->unused[0] & 1;
+}
+static inline int rx_enabled(struct uart_port *port)
+{
+        return port->unused[0] & 2;
+}
+static inline int ms_enabled(struct uart_port *port)
+{
+        return port->unused[0] & 4;
+}
+static inline void ms_enable(struct uart_port *port, int enabled)
+{
+        if(enabled)
+                port->unused[0] |= 4;
+        else
+                port->unused[0] &= ~4;
+}
+static inline void rx_enable(struct uart_port *port, int enabled)
+{
+        if(enabled)
+                port->unused[0] |= 2;
+        else
+                port->unused[0] &= ~2;
+}
+static inline void tx_enable(struct uart_port *port, int enabled)
+{
+        if(enabled)
+                port->unused[0] |= 1;
+        else
+                port->unused[0] &= ~1;
+}
 #ifdef SUPPORT_SYSRQ
@@ -75,7 +111,7 @@ static void ks8695uart_stop_tx(struct uart_port *port)
 {
        if (tx_enabled(port)) {
                disable_irq(KS8695_IRQ_UART_TX);
-                tx_enabled(port) = 0;
+                tx_enable(port, 0);
        }
 }
@@ -83,7 +119,7 @@ static void ks8695uart_start_tx(struct uart_port *port)
 {
        if (!tx_enabled(port)) {
                enable_irq(KS8695_IRQ_UART_TX);
-                tx_enabled(port) = 1;
+                tx_enable(port, 1);
        }
 }
@@ -91,24 +127,30 @@ static void ks8695uart_stop_rx(struct uart_port *port)
 {
        if (rx_enabled(port)) {
                disable_irq(KS8695_IRQ_UART_RX);
-                rx_enabled(port) = 0;
+                rx_enable(port, 0);
        }
 }
 static void ks8695uart_enable_ms(struct uart_port *port)
 {
-        enable_irq(KS8695_IRQ_UART_MODEM_STATUS);
+        if (!ms_enabled(port)) {
+                enable_irq(KS8695_IRQ_UART_MODEM_STATUS);
+                ms_enable(port,1);
+        }
 }
 static void ks8695uart_disable_ms(struct uart_port *port)
 {
-        disable_irq(KS8695_IRQ_UART_MODEM_STATUS);
+        if (ms_enabled(port)) {
+                disable_irq(KS8695_IRQ_UART_MODEM_STATUS);
+                ms_enable(port,0);
+        }
 }
 static irqreturn_t ks8695uart_rx_chars(int irq, void *dev_id)
 {
        struct uart_port *port = dev_id;
-        struct tty_struct *tty = port->info->tty;
+        struct tty_struct *tty = port->info->port.tty;
        unsigned int status, ch, lsr, flg, max_count = 256;
        status = UART_GET_LSR(port);            /* clears pending LSR interrupts */
@@ -285,8 +327,9 @@ static int ks8695uart_startup(struct uart_port *port)
        int retval;
        set_irq_flags(KS8695_IRQ_UART_TX, IRQF_VALID | IRQF_NOAUTOEN);
-        tx_enabled(port) = 0;
+        tx_enable(port, 0);
-        rx_enabled(port) = 1;
+        rx_enable(port, 1);
+        ms_enable(port, 1);
        /*
         * Allocate the IRQ
diff --git a/drivers/serial/serial_lh7a40x.c b/drivers/serial/serial_lh7a40x.c
index eb18d429752d..61dc8b3daa26 100644
--- a/drivers/serial/serial_lh7a40x.c
+++ b/drivers/serial/serial_lh7a40x.c
@@ -137,7 +137,7 @@ static void lh7a40xuart_enable_ms (struct uart_port* port)
 static void lh7a40xuart_rx_chars (struct uart_port* port)
 {
-        struct tty_struct* tty = port->info->tty;
+        struct tty_struct* tty = port->info->port.tty;
        int cbRxMax = 256;      /* (Gross) limit on receive */
        unsigned int data;      /* Received data and status */
        unsigned int flag;
@@ -460,7 +460,7 @@ static int lh7a40xuart_verify_port (struct uart_port* port,
        if (ser->type != PORT_UNKNOWN && ser->type != PORT_LH7A40X)
                ret = -EINVAL;
-        if (ser->irq < 0 || ser->irq >= NR_IRQS)
+        if (ser->irq < 0 || ser->irq >= nr_irqs)
                ret = -EINVAL;
        if (ser->baud_base < 9600) /* *** FIXME: is this true? */
                ret = -EINVAL;
diff --git a/drivers/serial/serial_txx9.c b/drivers/serial/serial_txx9.c
index 7ad21925869a..7313c2edcb83 100644
--- a/drivers/serial/serial_txx9.c
+++ b/drivers/serial/serial_txx9.c
@@ -272,7 +272,7 @@ static void serial_txx9_initialize(struct uart_port *port)
 static inline void
 receive_chars(struct uart_txx9_port *up, unsigned int *status)
 {
-        struct tty_struct *tty = up->port.info->tty;
+        struct tty_struct *tty = up->port.info->port.tty;
        unsigned char ch;
        unsigned int disr = *status;
        int max_count = 256;
@@ -1039,7 +1039,7 @@ static int __devinit serial_txx9_probe(struct platform_device *dev)
                ret = serial_txx9_register_port(&port);
                if (ret < 0) {
                        dev_err(&dev->dev, "unable to register port at index %d "
-                                "(IO%x MEM%llx IRQ%d): %d\n", i,
+                                "(IO%lx MEM%llx IRQ%d): %d\n", i,
                                p->iobase, (unsigned long long)p->mapbase,
                                p->irq, ret);
                }
diff --git a/drivers/serial/sh-sci.c b/drivers/serial/sh-sci.c
index ce6ee92b3a1b..f0658d2c45b2 100644
--- a/drivers/serial/sh-sci.c
+++ b/drivers/serial/sh-sci.c
@@ -3,7 +3,7 @@
 *
 * SuperH on-chip serial module support.  (SCI with no FIFO / with FIFO)
 *
- *  Copyright (C) 2002 - 2006  Paul Mundt
+ *  Copyright (C) 2002 - 2008  Paul Mundt
 *  Modified to support SH7720 SCIF. Markus Brunner, Mark Jonas (Jul 2007).
 *
 * based off of the old drivers/char/sh-sci.c by:
@@ -46,6 +46,7 @@
 #include <linux/cpufreq.h>
 #include <linux/clk.h>
 #include <linux/ctype.h>
+#include <linux/err.h>
 #ifdef CONFIG_SUPERH
 #include <asm/clock.h>
@@ -78,7 +79,7 @@ struct sci_port {
        struct timer_list       break_timer;
        int                     break_flag;
-#ifdef CONFIG_SUPERH
+#ifdef CONFIG_HAVE_CLK
        /* Port clock */
        struct clk              *clk;
 #endif
@@ -410,7 +411,6 @@ static void sci_init_pins_scif(struct uart_port *port, unsigned int cflag)
 #endif
 #if defined(CONFIG_CPU_SUBTYPE_SH7760) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7763) || \
    defined(CONFIG_CPU_SUBTYPE_SH7780) || \
    defined(CONFIG_CPU_SUBTYPE_SH7785)
 static inline int scif_txroom(struct uart_port *port)
@@ -422,6 +422,22 @@ static inline int scif_rxroom(struct uart_port *port)
 {
        return sci_in(port, SCRFDR) & 0xff;
 }
+#elif defined(CONFIG_CPU_SUBTYPE_SH7763)
+static inline int scif_txroom(struct uart_port *port)
+{
+        if((port->mapbase == 0xffe00000) || (port->mapbase == 0xffe08000)) /* SCIF0/1*/
+                return SCIF_TXROOM_MAX - (sci_in(port, SCTFDR) & 0xff);
+        else /* SCIF2 */
+                return SCIF2_TXROOM_MAX - (sci_in(port, SCFDR) >> 8);
+}
+static inline int scif_rxroom(struct uart_port *port)
+{
+        if((port->mapbase == 0xffe00000) || (port->mapbase == 0xffe08000)) /* SCIF0/1*/
+                return sci_in(port, SCRFDR) & 0xff;
+        else /* SCIF2 */
+                return sci_in(port, SCFDR) & SCIF2_RFDC_MASK;
+}
 #else
 static inline int scif_txroom(struct uart_port *port)
 {
@@ -521,7 +537,7 @@ static void sci_transmit_chars(struct uart_port *port)
 static inline void sci_receive_chars(struct uart_port *port)
 {
        struct sci_port *sci_port = (struct sci_port *)port;
-        struct tty_struct *tty = port->info->tty;
+        struct tty_struct *tty = port->info->port.tty;
        int i, count, copied = 0;
        unsigned short status;
        unsigned char flag;
@@ -642,7 +658,7 @@ static inline int sci_handle_errors(struct uart_port *port)
 {
        int copied = 0;
        unsigned short status = sci_in(port, SCxSR);
-        struct tty_struct *tty = port->info->tty;
+        struct tty_struct *tty = port->info->port.tty;
        if (status & SCxSR_ORER(port)) {
                /* overrun error */
@@ -692,7 +708,7 @@ static inline int sci_handle_breaks(struct uart_port *port)
 {
        int copied = 0;
        unsigned short status = sci_in(port, SCxSR);
-        struct tty_struct *tty = port->info->tty;
+        struct tty_struct *tty = port->info->port.tty;
        struct sci_port *s = &sci_ports[port->line];
        if (uart_handle_break(port))
@@ -762,7 +778,7 @@ static irqreturn_t sci_er_interrupt(int irq, void *ptr)
        } else {
 #if defined(SCIF_ORER)
                if((sci_in(port, SCLSR) & SCIF_ORER) != 0) {
-                        struct tty_struct *tty = port->info->tty;
+                        struct tty_struct *tty = port->info->port.tty;
                        sci_out(port, SCLSR, 0);
                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
@@ -816,7 +832,7 @@ static irqreturn_t sci_mpxed_interrupt(int irq, void *ptr)
        return IRQ_HANDLED;
 }
-#ifdef CONFIG_CPU_FREQ
+#if defined(CONFIG_CPU_FREQ) && defined(CONFIG_HAVE_CLK)
 /*
 * Here we define a transistion notifier so that we can update all of our
 * ports' baud rate when the peripheral clock changes.
@@ -845,7 +861,7 @@ static int sci_notifier(struct notifier_block *self,
                         * Clean this up later..
                         */
                        clk = clk_get(NULL, "module_clk");
-                        port->uartclk = clk_get_rate(clk) * 16;
+                        port->uartclk = clk_get_rate(clk);
                        clk_put(clk);
                }
@@ -858,7 +874,7 @@ static int sci_notifier(struct notifier_block *self,
 }
 static struct notifier_block sci_nb = { &sci_notifier, NULL, 0 };
-#endif /* CONFIG_CPU_FREQ */
+#endif /* CONFIG_CPU_FREQ && CONFIG_HAVE_CLK */
 static int sci_request_irq(struct sci_port *port)
 {
@@ -993,7 +1009,7 @@ static int sci_startup(struct uart_port *port)
        if (s->enable)
                s->enable(port);
-#if defined(CONFIG_SUPERH) && !defined(CONFIG_SUPERH64)
+#ifdef CONFIG_HAVE_CLK
        s->clk = clk_get(NULL, "module_clk");
 #endif
@@ -1015,7 +1031,7 @@ static void sci_shutdown(struct uart_port *port)
        if (s->disable)
                s->disable(port);
-#if defined(CONFIG_SUPERH) && !defined(CONFIG_SUPERH64)
+#ifdef CONFIG_HAVE_CLK
        clk_put(s->clk);
        s->clk = NULL;
 #endif
@@ -1026,24 +1042,11 @@ static void sci_set_termios(struct uart_port *port, struct ktermios *termios,
 {
        struct sci_port *s = &sci_ports[port->line];
        unsigned int status, baud, smr_val;
-        int t;
+        int t = -1;
        baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
+        if (likely(baud))
-        switch (baud) {
+                t = SCBRR_VALUE(baud, port->uartclk);
-                case 0:
-                        t = -1;
-                        break;
-                default:
-                {
-#if defined(CONFIG_SUPERH) && !defined(CONFIG_SUPERH64)
-                        t = SCBRR_VALUE(baud, clk_get_rate(s->clk));
-#else
-                        t = SCBRR_VALUE(baud);
-#endif
-                        break;
-                }
-        }
        do {
                status = sci_in(port, SCxSR);
@@ -1098,7 +1101,7 @@ static const char *sci_type(struct uart_port *port)
                case PORT_IRDA: return "irda";
        }
-        return 0;
+        return NULL;
 }
 static void sci_release_port(struct uart_port *port)
@@ -1130,19 +1133,23 @@ static void sci_config_port(struct uart_port *port, int flags)
                break;
        }
-#if defined(CONFIG_CPU_SUBTYPE_SH5_101) || defined(CONFIG_CPU_SUBTYPE_SH5_103)
+        if (port->flags & UPF_IOREMAP && !port->membase) {
-        if (port->mapbase == 0)
+#if defined(CONFIG_SUPERH64)
                port->mapbase = onchip_remap(SCIF_ADDR_SH5, 1024, "SCIF");
+                port->membase = (void __iomem *)port->mapbase;
-        port->membase = (void __iomem *)port->mapbase;
+#else
+                port->membase = ioremap_nocache(port->mapbase, 0x40);
 #endif
+                printk(KERN_ERR "sci: can't remap port#%d\n", port->line);
+        }
 }
 static int sci_verify_port(struct uart_port *port, struct serial_struct *ser)
 {
        struct sci_port *s = &sci_ports[port->line];
-        if (ser->irq != s->irqs[SCIx_TXI_IRQ] || ser->irq > NR_IRQS)
+        if (ser->irq != s->irqs[SCIx_TXI_IRQ] || ser->irq > nr_irqs)
                return -EINVAL;
        if (ser->baud_base < 2400)
                /* No paper tape reader for Mitch.. */
@@ -1192,17 +1199,17 @@ static void __init sci_init_ports(void)
                sci_ports[i].disable    = h8300_sci_disable;
 #endif
                sci_ports[i].port.uartclk = CONFIG_CPU_CLOCK;
-#elif defined(CONFIG_SUPERH64)
+#elif defined(CONFIG_HAVE_CLK)
-                sci_ports[i].port.uartclk = current_cpu_data.module_clock * 16;
-#else
                /*
                 * XXX: We should use a proper SCI/SCIF clock
                 */
                {
                        struct clk *clk = clk_get(NULL, "module_clk");
-                        sci_ports[i].port.uartclk = clk_get_rate(clk) * 16;
+                        sci_ports[i].port.uartclk = clk_get_rate(clk);
                        clk_put(clk);
                }
+#else
+#error "Need a valid uartclk"
 #endif
                sci_ports[i].break_timer.data = (unsigned long)&sci_ports[i];
@@ -1270,7 +1277,7 @@ static int __init serial_console_setup(struct console *co, char *options)
        port->type = serial_console_port->type;
-#if defined(CONFIG_SUPERH) && !defined(CONFIG_SUPERH64)
+#ifdef CONFIG_HAVE_CLK
        if (!serial_console_port->clk)
                serial_console_port->clk = clk_get(NULL, "module_clk");
 #endif
@@ -1421,7 +1428,7 @@ static struct uart_driver sci_uart_driver = {
 static int __devinit sci_probe(struct platform_device *dev)
 {
        struct plat_sci_port *p = dev->dev.platform_data;
-        int i;
+        int i, ret = -EINVAL;
        for (i = 0; p && p->flags != 0; p++, i++) {
                struct sci_port *sciport = &sci_ports[i];
@@ -1438,12 +1445,22 @@ static int __devinit sci_probe(struct platform_device *dev)
                sciport->port.mapbase   = p->mapbase;
-                /*
+                if (p->mapbase && !p->membase) {
-                 * For the simple (and majority of) cases where we don't need
+                        if (p->flags & UPF_IOREMAP) {
-                 * to do any remapping, just cast the cookie directly.
+                                p->membase = ioremap_nocache(p->mapbase, 0x40);
-                 */
+                                if (IS_ERR(p->membase)) {
-                if (p->mapbase && !p->membase && !(p->flags & UPF_IOREMAP))
+                                        ret = PTR_ERR(p->membase);
-                        p->membase = (void __iomem *)p->mapbase;
+                                        goto err_unreg;
+                                }
+                        } else {
+                                /*
+                                 * For the simple (and majority of) cases
+                                 * where we don't need to do any remapping,
+                                 * just cast the cookie directly.
+                                 */
+                                p->membase = (void __iomem *)p->mapbase;
+                        }
+                }
                sciport->port.membase   = p->membase;
@@ -1464,7 +1481,7 @@ static int __devinit sci_probe(struct platform_device *dev)
        kgdb_putchar    = kgdb_sci_putchar;
 #endif
-#ifdef CONFIG_CPU_FREQ
+#if defined(CONFIG_CPU_FREQ) && defined(CONFIG_HAVE_CLK)
        cpufreq_register_notifier(&sci_nb, CPUFREQ_TRANSITION_NOTIFIER);
        dev_info(&dev->dev, "CPU frequency notifier registered\n");
 #endif
@@ -1474,6 +1491,12 @@ static int __devinit sci_probe(struct platform_device *dev)
 #endif
        return 0;
+err_unreg:
+        for (i = i - 1; i >= 0; i--)
+                uart_remove_one_port(&sci_uart_driver, &sci_ports[i].port);
+        return ret;
 }
 static int __devexit sci_remove(struct platform_device *dev)
diff --git a/drivers/serial/sh-sci.h b/drivers/serial/sh-sci.h
index eb84833233fd..7cd28b226800 100644
--- a/drivers/serial/sh-sci.h
+++ b/drivers/serial/sh-sci.h
@@ -123,8 +123,9 @@
 #elif defined(CONFIG_CPU_SUBTYPE_SH7763)
 # define SCSPTR0 0xffe00024 /* 16 bit SCIF */
 # define SCSPTR1 0xffe08024 /* 16 bit SCIF */
+# define SCSPTR2 0xffe10020 /* 16 bit SCIF/IRDA */
 # define SCIF_ORER 0x0001  /* overrun error bit */
-# define SCSCR_INIT(port)       0x3a    /* TIE=0,RIE=0,TE=1,RE=1,REIE=1 */
+# define SCSCR_INIT(port)       0x38    /* TIE=0,RIE=0,TE=1,RE=1,REIE=1 */
 # define SCIF_ONLY
 #elif defined(CONFIG_CPU_SUBTYPE_SH7770)
 # define SCSPTR0 0xff923020 /* 16 bit SCIF */
@@ -188,6 +189,7 @@
    defined(CONFIG_CPU_SUBTYPE_SH7750S) || \
    defined(CONFIG_CPU_SUBTYPE_SH7751)  || \
    defined(CONFIG_CPU_SUBTYPE_SH7751R) || \
+    defined(CONFIG_CPU_SUBTYPE_SH7763)  || \
    defined(CONFIG_CPU_SUBTYPE_SH7780)  || \
    defined(CONFIG_CPU_SUBTYPE_SH7785)  || \
    defined(CONFIG_CPU_SUBTYPE_SHX3)
@@ -225,14 +227,21 @@
 #if defined(CONFIG_CPU_SUBTYPE_SH7705) || \
    defined(CONFIG_CPU_SUBTYPE_SH7720) || \
    defined(CONFIG_CPU_SUBTYPE_SH7721)
-#define SCIF_ORER    0x0200
+# define SCIF_ORER    0x0200
-#define SCIF_ERRORS ( SCIF_PER | SCIF_FER | SCIF_ER | SCIF_BRK | SCIF_ORER)
+# define SCIF_ERRORS ( SCIF_PER | SCIF_FER | SCIF_ER | SCIF_BRK | SCIF_ORER)
-#define SCIF_RFDC_MASK 0x007f
+# define SCIF_RFDC_MASK 0x007f
-#define SCIF_TXROOM_MAX 64
+# define SCIF_TXROOM_MAX 64
+#elif defined(CONFIG_CPU_SUBTYPE_SH7763)
+# define SCIF_ERRORS ( SCIF_PER | SCIF_FER | SCIF_ER | SCIF_BRK )
+# define SCIF_RFDC_MASK 0x007f
+# define SCIF_TXROOM_MAX 64
+/* SH7763 SCIF2 support */
+# define SCIF2_RFDC_MASK 0x001f
+# define SCIF2_TXROOM_MAX 16
 #else
-#define SCIF_ERRORS ( SCIF_PER | SCIF_FER | SCIF_ER | SCIF_BRK)
+# define SCIF_ERRORS ( SCIF_PER | SCIF_FER | SCIF_ER | SCIF_BRK)
-#define SCIF_RFDC_MASK 0x001f
+# define SCIF_RFDC_MASK 0x001f
-#define SCIF_TXROOM_MAX 16
+# define SCIF_TXROOM_MAX 16
 #endif
 #if defined(SCI_ONLY)
@@ -311,18 +320,16 @@
 #define SCI_EVENT_WRITE_WAKEUP  0
 #define SCI_IN(size, offset)                                    \
-  unsigned int addr = port->mapbase + (offset);                 \
  if ((size) == 8) {                                            \
-    return ctrl_inb(addr);                                      \
+    return ioread8(port->membase + (offset));                   \
  } else {                                                      \
-    return ctrl_inw(addr);                                      \
+    return ioread16(port->membase + (offset));                  \
  }
 #define SCI_OUT(size, offset, value)                            \
-  unsigned int addr = port->mapbase + (offset);                 \
  if ((size) == 8) {                                            \
-    ctrl_outb(value, addr);                                     \
+    iowrite8(value, port->membase + (offset));                  \
  } else if ((size) == 16) {                                    \
-    ctrl_outw(value, addr);                                     \
+    iowrite16(value, port->membase + (offset));                 \
  }
 #define CPU_SCIx_FNS(name, sci_offset, sci_size, scif_offset, scif_size)\
@@ -442,7 +449,6 @@ SCIx_FNS(SCxSR,  0x08,  8, 0x10,  8, 0x08, 16, 0x10, 16, 0x04,  8)
 SCIx_FNS(SCxRDR, 0x0a,  8, 0x14,  8, 0x0A,  8, 0x14,  8, 0x05,  8)
 SCIF_FNS(SCFCR,                      0x0c,  8, 0x18, 16)
 #if defined(CONFIG_CPU_SUBTYPE_SH7760) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7763) || \
    defined(CONFIG_CPU_SUBTYPE_SH7780) || \
    defined(CONFIG_CPU_SUBTYPE_SH7785)
 SCIF_FNS(SCFDR,                      0x0e, 16, 0x1C, 16)
@@ -450,6 +456,14 @@ SCIF_FNS(SCTFDR,		     0x0e, 16, 0x1C, 16)
 SCIF_FNS(SCRFDR,                     0x0e, 16, 0x20, 16)
 SCIF_FNS(SCSPTR,                        0,  0, 0x24, 16)
 SCIF_FNS(SCLSR,                         0,  0, 0x28, 16)
+#elif defined(CONFIG_CPU_SUBTYPE_SH7763)
+SCIF_FNS(SCFDR,                         0,  0, 0x1C, 16)
+SCIF_FNS(SCSPTR2,                       0,  0, 0x20, 16)
+SCIF_FNS(SCLSR2,                        0,  0, 0x24, 16)
+SCIF_FNS(SCTFDR,                     0x0e, 16, 0x1C, 16)
+SCIF_FNS(SCRFDR,                     0x0e, 16, 0x20, 16)
+SCIF_FNS(SCSPTR,                        0,  0, 0x24, 16)
+SCIF_FNS(SCLSR,                         0,  0, 0x28, 16)
 #else
 SCIF_FNS(SCFDR,                      0x0e, 16, 0x1C, 16)
 #if defined(CONFIG_CPU_SUBTYPE_SH7722)
@@ -652,6 +666,9 @@ static inline int sci_rxd_in(struct uart_port *port)
                return ctrl_inw(SCSPTR0) & 0x0001 ? 1 : 0; /* SCIF */
        if (port->mapbase == 0xffe08000)
                return ctrl_inw(SCSPTR1) & 0x0001 ? 1 : 0; /* SCIF */
+        if (port->mapbase == 0xffe10000)
+                return ctrl_inw(SCSPTR2) & 0x0001 ? 1 : 0; /* SCIF/IRDA */
        return 1;
 }
 #elif defined(CONFIG_CPU_SUBTYPE_SH7770)
@@ -764,8 +781,7 @@ static inline int sci_rxd_in(struct uart_port *port)
 * -- Mitch Davis - 15 Jul 2000
 */
-#if defined(CONFIG_CPU_SUBTYPE_SH7763) || \
+#if defined(CONFIG_CPU_SUBTYPE_SH7780) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7780) || \
    defined(CONFIG_CPU_SUBTYPE_SH7785)
 #define SCBRR_VALUE(bps, clk) ((clk+16*bps)/(16*bps)-1)
 #elif defined(CONFIG_CPU_SUBTYPE_SH7705) || \
@@ -773,11 +789,16 @@ static inline int sci_rxd_in(struct uart_port *port)
      defined(CONFIG_CPU_SUBTYPE_SH7721)
 #define SCBRR_VALUE(bps, clk) (((clk*2)+16*bps)/(32*bps)-1)
 #elif defined(CONFIG_CPU_SUBTYPE_SH7723)
-#define SCBRR_VALUE(bps, clk) (((clk*2)+16*bps)/(16*bps)-1)
+static inline int scbrr_calc(struct uart_port *port, int bps, int clk)
+{
+        if (port->type == PORT_SCIF)
+                return (clk+16*bps)/(32*bps)-1;
+        else
+                return ((clk*2)+16*bps)/(16*bps)-1;
+}
+#define SCBRR_VALUE(bps, clk) scbrr_calc(port, bps, clk)
 #elif defined(__H8300H__) || defined(__H8300S__)
-#define SCBRR_VALUE(bps) (((CONFIG_CPU_CLOCK*1000/32)/bps)-1)
+#define SCBRR_VALUE(bps, clk) (((clk*1000/32)/bps)-1)
-#elif defined(CONFIG_SUPERH64)
-#define SCBRR_VALUE(bps) ((current_cpu_data.module_clock+16*bps)/(32*bps)-1)
 #else /* Generic SH */
 #define SCBRR_VALUE(bps, clk) ((clk+16*bps)/(32*bps)-1)
 #endif
diff --git a/drivers/serial/sn_console.c b/drivers/serial/sn_console.c
index 019da2e05f0b..d5276c012f78 100644
--- a/drivers/serial/sn_console.c
+++ b/drivers/serial/sn_console.c
@@ -61,7 +61,7 @@
 #define SN_SAL_BUFFER_SIZE (64 * (1 << 10))
 #define SN_SAL_UART_FIFO_DEPTH 16
-#define SN_SAL_UART_FIFO_SPEED_CPS 9600/10
+#define SN_SAL_UART_FIFO_SPEED_CPS (9600/10)
 /* sn_transmit_chars() calling args */
 #define TRANSMIT_BUFFERED       0
@@ -471,7 +471,7 @@ sn_receive_chars(struct sn_cons_port *port, unsigned long flags)
        if (port->sc_port.info) {
                /* The serial_core stuffs are initilized, use them */
-                tty = port->sc_port.info->tty;
+                tty = port->sc_port.info->port.tty;
        }
        else {
                /* Not registered yet - can't pass to tty layer.  */
diff --git a/drivers/serial/sunhv.c b/drivers/serial/sunhv.c
index 2847336742d7..a94a2ab4b571 100644
--- a/drivers/serial/sunhv.c
+++ b/drivers/serial/sunhv.c
@@ -17,11 +17,11 @@
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/init.h>
+#include <linux/of_device.h>
 #include <asm/hypervisor.h>
 #include <asm/spitfire.h>
 #include <asm/prom.h>
-#include <asm/of_device.h>
 #include <asm/irq.h>
 #if defined(CONFIG_MAGIC_SYSRQ)
@@ -185,7 +185,7 @@ static struct tty_struct *receive_chars(struct uart_port *port)
        struct tty_struct *tty = NULL;
        if (port->info != NULL)         /* Unopened serial console */
-                tty = port->info->tty;
+                tty = port->info->port.tty;
        if (sunhv_ops->receive_chars(port, tty))
                sun_do_break();
@@ -616,7 +616,7 @@ static int __devexit hv_remove(struct of_device *dev)
        return 0;
 }
-static struct of_device_id hv_match[] = {
+static const struct of_device_id hv_match[] = {
        {
                .name = "console",
                .compatible = "qcn",
diff --git a/drivers/serial/sunsab.c b/drivers/serial/sunsab.c
index 9ff5b38f3bee..0355efe115d9 100644
--- a/drivers/serial/sunsab.c
+++ b/drivers/serial/sunsab.c
@@ -32,11 +32,11 @@
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/init.h>
+#include <linux/of_device.h>
 #include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/prom.h>
-#include <asm/of_device.h>
 #if defined(CONFIG_SERIAL_SUNSAB_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
 #define SUPPORT_SYSRQ
@@ -118,7 +118,7 @@ receive_chars(struct uart_sunsab_port *up,
        int i;
        if (up->port.info != NULL)              /* Unopened serial console */
-                tty = up->port.info->tty;
+                tty = up->port.info->port.tty;
        /* Read number of BYTES (Character + Status) available. */
        if (stat->sreg.isr0 & SAB82532_ISR0_RPF) {
@@ -1078,7 +1078,7 @@ static int __devexit sab_remove(struct of_device *op)
        return 0;
 }
-static struct of_device_id sab_match[] = {
+static const struct of_device_id sab_match[] = {
        {
                .name = "se",
        },
diff --git a/drivers/serial/sunsu.c b/drivers/serial/sunsu.c
index 03806a935209..a4dc79b1d7ab 100644
--- a/drivers/serial/sunsu.c
+++ b/drivers/serial/sunsu.c
@@ -1,4 +1,4 @@
-/* $Id: su.c,v 1.55 2002/01/08 16:00:16 davem Exp $
+/*
 * su.c: Small serial driver for keyboard/mouse interface on sparc32/PCI
 *
 * Copyright (C) 1997  Eddie C. Dost  (ecd@skynet.be)
@@ -35,11 +35,11 @@
 #include <linux/serial_reg.h>
 #include <linux/init.h>
 #include <linux/delay.h>
+#include <linux/of_device.h>
 #include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/prom.h>
-#include <asm/of_device.h>
 #if defined(CONFIG_SERIAL_SUNSU_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
 #define SUPPORT_SYSRQ
@@ -311,7 +311,7 @@ static void sunsu_enable_ms(struct uart_port *port)
 static struct tty_struct *
 receive_chars(struct uart_sunsu_port *up, unsigned char *status)
 {
-        struct tty_struct *tty = up->port.info->tty;
+        struct tty_struct *tty = up->port.info->port.tty;
        unsigned char ch, flag;
        int max_count = 256;
        int saw_console_brk = 0;
@@ -1506,7 +1506,7 @@ static int __devexit su_remove(struct of_device *op)
        return 0;
 }
-static struct of_device_id su_match[] = {
+static const struct of_device_id su_match[] = {
        {
                .name = "su",
        },
diff --git a/drivers/serial/sunzilog.c b/drivers/serial/sunzilog.c
index 7e9fa5ef0eb7..45a299f35617 100644
--- a/drivers/serial/sunzilog.c
+++ b/drivers/serial/sunzilog.c
@@ -32,11 +32,11 @@
 #include <linux/serio.h>
 #endif
 #include <linux/init.h>
+#include <linux/of_device.h>
 #include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/prom.h>
-#include <asm/of_device.h>
 #if defined(CONFIG_SERIAL_SUNZILOG_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
 #define SUPPORT_SYSRQ
@@ -329,8 +329,8 @@ sunzilog_receive_chars(struct uart_sunzilog_port *up,
        tty = NULL;
        if (up->port.info != NULL &&            /* Unopened serial console */
-            up->port.info->tty != NULL)         /* Keyboard || mouse */
+            up->port.info->port.tty != NULL)    /* Keyboard || mouse */
-                tty = up->port.info->tty;
+                tty = up->port.info->port.tty;
        for (;;) {
@@ -1480,7 +1480,7 @@ static int __devexit zs_remove(struct of_device *op)
        return 0;
 }
-static struct of_device_id zs_match[] = {
+static const struct of_device_id zs_match[] = {
        {
                .name = "zs",
        },
diff --git a/drivers/serial/uartlite.c b/drivers/serial/uartlite.c
index b51c24245be4..6a3f8fb0c9dd 100644
--- a/drivers/serial/uartlite.c
+++ b/drivers/serial/uartlite.c
@@ -75,7 +75,7 @@ static struct uart_port ulite_ports[ULITE_NR_UARTS];
 static int ulite_receive(struct uart_port *port, int stat)
 {
-        struct tty_struct *tty = port->info->tty;
+        struct tty_struct *tty = port->info->port.tty;
        unsigned char ch = 0;
        char flag = TTY_NORMAL;
@@ -162,7 +162,7 @@ static irqreturn_t ulite_isr(int irq, void *dev_id)
                busy |= ulite_transmit(port, stat);
        } while (busy);
-        tty_flip_buffer_push(port->info->tty);
+        tty_flip_buffer_push(port->info->port.tty);
        return IRQ_HANDLED;
 }
diff --git a/drivers/serial/ucc_uart.c b/drivers/serial/ucc_uart.c
index 566a8b42e05a..315a9333ca3c 100644
--- a/drivers/serial/ucc_uart.c
+++ b/drivers/serial/ucc_uart.c
@@ -466,7 +466,7 @@ static void qe_uart_int_rx(struct uart_qe_port *qe_port)
        int i;
        unsigned char ch, *cp;
        struct uart_port *port = &qe_port->port;
-        struct tty_struct *tty = port->info->tty;
+        struct tty_struct *tty = port->info->port.tty;
        struct qe_bd *bdp;
        u16 status;
        unsigned int flg;
@@ -1009,7 +1009,7 @@ static int qe_uart_request_port(struct uart_port *port)
        rx_size = L1_CACHE_ALIGN(qe_port->rx_nrfifos * qe_port->rx_fifosize);
        tx_size = L1_CACHE_ALIGN(qe_port->tx_nrfifos * qe_port->tx_fifosize);
-        bd_virt = dma_alloc_coherent(NULL, rx_size + tx_size, &bd_dma_addr,
+        bd_virt = dma_alloc_coherent(port->dev, rx_size + tx_size, &bd_dma_addr,
                GFP_KERNEL);
        if (!bd_virt) {
                dev_err(port->dev, "could not allocate buffer descriptors\n");
@@ -1051,7 +1051,7 @@ static void qe_uart_release_port(struct uart_port *port)
                container_of(port, struct uart_qe_port, port);
        struct ucc_slow_private *uccs = qe_port->us_private;
-        dma_free_coherent(NULL, qe_port->bd_size, qe_port->bd_virt,
+        dma_free_coherent(port->dev, qe_port->bd_size, qe_port->bd_virt,
                          qe_port->bd_dma_addr);
        ucc_slow_free(uccs);
@@ -1066,7 +1066,7 @@ static int qe_uart_verify_port(struct uart_port *port,
        if (ser->type != PORT_UNKNOWN && ser->type != PORT_CPM)
                return -EINVAL;
-        if (ser->irq < 0 || ser->irq >= NR_IRQS)
+        if (ser->irq < 0 || ser->irq >= nr_irqs)
                return -EINVAL;
        if (ser->baud_base < 9600)
diff --git a/drivers/serial/v850e_uart.c b/drivers/serial/v850e_uart.c
deleted file mode 100644
index dd98aca6ed08..000000000000
--- a/drivers/serial/v850e_uart.c
+++ /dev/null
@@ -1,548 +0,0 @@
-/*
- * drivers/serial/v850e_uart.c -- Serial I/O using V850E on-chip UART or UARTB
- *
- *  Copyright (C) 2001,02,03  NEC Electronics Corporation
- *  Copyright (C) 2001,02,03  Miles Bader <miles@gnu.org>
- *
- * This file is subject to the terms and conditions of the GNU General
- * Public License.  See the file COPYING in the main directory of this
- * archive for more details.
- *
- * Written by Miles Bader <miles@gnu.org>
- */
-/* This driver supports both the original V850E UART interface (called
-   merely `UART' in the docs) and the newer `UARTB' interface, which is
-   roughly a superset of the first one.  The selection is made at
-   configure time -- if CONFIG_V850E_UARTB is defined, then UARTB is
-   presumed, otherwise the old UART -- as these are on-CPU UARTS, a system
-   can never have both.
-   The UARTB interface also has a 16-entry FIFO mode, which is not
-   yet supported by this driver.  */
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/console.h>
-#include <linux/tty.h>
-#include <linux/tty_flip.h>
-#include <linux/serial.h>
-#include <linux/serial_core.h>
-#include <asm/v850e_uart.h>
-/* Initial UART state.  This may be overridden by machine-dependent headers. */
-#ifndef V850E_UART_INIT_BAUD
-#define V850E_UART_INIT_BAUD    115200
-#endif
-#ifndef V850E_UART_INIT_CFLAGS
-#define V850E_UART_INIT_CFLAGS  (B115200 | CS8 | CREAD)
-#endif
-/* A string used for prefixing printed descriptions; since the same UART
-   macro is actually used on other chips than the V850E.  This must be a
-   constant string.  */
-#ifndef V850E_UART_CHIP_NAME
-#define V850E_UART_CHIP_NAME    "V850E"
-#endif
-#define V850E_UART_MINOR_BASE   64         /* First tty minor number */
-/* Low-level UART functions.  */
-/* Configure and turn on uart channel CHAN, using the termios `control
-   modes' bits in CFLAGS, and a baud-rate of BAUD.  */
-void v850e_uart_configure (unsigned chan, unsigned cflags, unsigned baud)
-{
-        int flags;
-        v850e_uart_speed_t old_speed;
-        v850e_uart_config_t old_config;
-        v850e_uart_speed_t new_speed = v850e_uart_calc_speed (baud);
-        v850e_uart_config_t new_config = v850e_uart_calc_config (cflags);
-        /* Disable interrupts while we're twiddling the hardware.  */
-        local_irq_save (flags);
-#ifdef V850E_UART_PRE_CONFIGURE
-        V850E_UART_PRE_CONFIGURE (chan, cflags, baud);
-#endif
-        old_config = V850E_UART_CONFIG (chan);
-        old_speed = v850e_uart_speed (chan);
-        if (! v850e_uart_speed_eq (old_speed, new_speed)) {
-                /* The baud rate has changed.  First, disable the UART.  */
-                V850E_UART_CONFIG (chan) = V850E_UART_CONFIG_FINI;
-                old_config = 0; /* Force the uart to be re-initialized. */
-                /* Reprogram the baud-rate generator.  */
-                v850e_uart_set_speed (chan, new_speed);
-        }
-        if (! (old_config & V850E_UART_CONFIG_ENABLED)) {
-                /* If we are using the uart for the first time, start by
-                   enabling it, which must be done before turning on any
-                   other bits.  */
-                V850E_UART_CONFIG (chan) = V850E_UART_CONFIG_INIT;
-                /* See the initial state.  */
-                old_config = V850E_UART_CONFIG (chan);
-        }
-        if (new_config != old_config) {
-                /* Which of the TXE/RXE bits we'll temporarily turn off
-                   before changing other control bits.  */
-                unsigned temp_disable = 0;
-                /* Which of the TXE/RXE bits will be enabled.  */
-                unsigned enable = 0;
-                unsigned changed_bits = new_config ^ old_config;
-                /* Which of RX/TX will be enabled in the new configuration.  */
-                if (new_config & V850E_UART_CONFIG_RX_BITS)
-                        enable |= (new_config & V850E_UART_CONFIG_RX_ENABLE);
-                if (new_config & V850E_UART_CONFIG_TX_BITS)
-                        enable |= (new_config & V850E_UART_CONFIG_TX_ENABLE);
-                /* Figure out which of RX/TX needs to be disabled; note
-                   that this will only happen if they're not already
-                   disabled.  */
-                if (changed_bits & V850E_UART_CONFIG_RX_BITS)
-                        temp_disable
-                                |= (old_config & V850E_UART_CONFIG_RX_ENABLE);
-                if (changed_bits & V850E_UART_CONFIG_TX_BITS)
-                        temp_disable
-                                |= (old_config & V850E_UART_CONFIG_TX_ENABLE);
-                /* We have to turn off RX and/or TX mode before changing
-                   any associated control bits.  */
-                if (temp_disable)
-                        V850E_UART_CONFIG (chan) = old_config & ~temp_disable;
-                /* Write the new control bits, while RX/TX are disabled. */ 
-                if (changed_bits & ~enable)
-                        V850E_UART_CONFIG (chan) = new_config & ~enable;
-                v850e_uart_config_delay (new_config, new_speed);
-                /* Write the final version, with enable bits turned on.  */
-                V850E_UART_CONFIG (chan) = new_config;
-        }
-        local_irq_restore (flags);
-}
-/*  Low-level console. */
-#ifdef CONFIG_V850E_UART_CONSOLE
-static void v850e_uart_cons_write (struct console *co,
-                                   const char *s, unsigned count)
-{
-        if (count > 0) {
-                unsigned chan = co->index;
-                unsigned irq = V850E_UART_TX_IRQ (chan);
-                int irq_was_enabled, irq_was_pending, flags;
-                /* We don't want to get `transmission completed'
-                   interrupts, since we're busy-waiting, so we disable them
-                   while sending (we don't disable interrupts entirely
-                   because sending over a serial line is really slow).  We
-                   save the status of the tx interrupt and restore it when
-                   we're done so that using printk doesn't interfere with
-                   normal serial transmission (other than interleaving the
-                   output, of course!).  This should work correctly even if
-                   this function is interrupted and the interrupt printks
-                   something.  */
-                /* Disable interrupts while fiddling with tx interrupt.  */
-                local_irq_save (flags);
-                /* Get current tx interrupt status.  */
-                irq_was_enabled = v850e_intc_irq_enabled (irq);
-                irq_was_pending = v850e_intc_irq_pending (irq);
-                /* Disable tx interrupt if necessary.  */
-                if (irq_was_enabled)
-                        v850e_intc_disable_irq (irq);
-                /* Turn interrupts back on.  */
-                local_irq_restore (flags);
-                /* Send characters.  */
-                while (count > 0) {
-                        int ch = *s++;
-                        if (ch == '\n') {
-                                /* We don't have the benefit of a tty
-                                   driver, so translate NL into CR LF.  */
-                                v850e_uart_wait_for_xmit_ok (chan);
-                                v850e_uart_putc (chan, '\r');
-                        }
-                        v850e_uart_wait_for_xmit_ok (chan);
-                        v850e_uart_putc (chan, ch);
-                        count--;
-                }
-                /* Restore saved tx interrupt status.  */
-                if (irq_was_enabled) {
-                        /* Wait for the last character we sent to be
-                           completely transmitted (as we'll get an
-                           interrupt interrupt at that point).  */
-                        v850e_uart_wait_for_xmit_done (chan);
-                        /* Clear pending interrupts received due
-                           to our transmission, unless there was already
-                           one pending, in which case we want the
-                           handler to be called.  */
-                        if (! irq_was_pending)
-                                v850e_intc_clear_pending_irq (irq);
-                        /* ... and then turn back on handling.  */
-                        v850e_intc_enable_irq (irq);
-                }
-        }
-}
-extern struct uart_driver v850e_uart_driver;
-static struct console v850e_uart_cons =
-{
-    .name       = "ttyS",
-    .write      = v850e_uart_cons_write,
-    .device     = uart_console_device,
-    .flags      = CON_PRINTBUFFER,
-    .cflag      = V850E_UART_INIT_CFLAGS,
-    .index      = -1,
-    .data       = &v850e_uart_driver,
-};
-void v850e_uart_cons_init (unsigned chan)
-{
-        v850e_uart_configure (chan, V850E_UART_INIT_CFLAGS,
-                              V850E_UART_INIT_BAUD);
-        v850e_uart_cons.index = chan;
-        register_console (&v850e_uart_cons);
-        printk ("Console: %s on-chip UART channel %d\n",
-                V850E_UART_CHIP_NAME, chan);
-}
-/* This is what the init code actually calls.  */
-static int v850e_uart_console_init (void)
-{
-        v850e_uart_cons_init (V850E_UART_CONSOLE_CHANNEL);
-        return 0;
-}
-console_initcall(v850e_uart_console_init);
-#define V850E_UART_CONSOLE &v850e_uart_cons
-#else /* !CONFIG_V850E_UART_CONSOLE */
-#define V850E_UART_CONSOLE 0
-#endif /* CONFIG_V850E_UART_CONSOLE */
-/* TX/RX interrupt handlers.  */
-static void v850e_uart_stop_tx (struct uart_port *port);
-void v850e_uart_tx (struct uart_port *port)
-{
-        struct circ_buf *xmit = &port->info->xmit;
-        int stopped = uart_tx_stopped (port);
-        if (v850e_uart_xmit_ok (port->line)) {
-                int tx_ch;
-                if (port->x_char) {
-                        tx_ch = port->x_char;
-                        port->x_char = 0;
-                } else if (!uart_circ_empty (xmit) && !stopped) {
-                        tx_ch = xmit->buf[xmit->tail];
-                        xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
-                } else
-                        goto no_xmit;
-                v850e_uart_putc (port->line, tx_ch);
-                port->icount.tx++;
-                if (uart_circ_chars_pending (xmit) < WAKEUP_CHARS)
-                        uart_write_wakeup (port);
-        }
- no_xmit:
-        if (uart_circ_empty (xmit) || stopped)
-                v850e_uart_stop_tx (port, stopped);
-}
-static irqreturn_t v850e_uart_tx_irq(int irq, void *data)
-{
-        struct uart_port *port = data;
-        v850e_uart_tx (port);
-        return IRQ_HANDLED;
-}
-static irqreturn_t v850e_uart_rx_irq(int irq, void *data)
-{
-        struct uart_port *port = data;
-        unsigned ch_stat = TTY_NORMAL;
-        unsigned ch = v850e_uart_getc (port->line);
-        unsigned err = v850e_uart_err (port->line);
-        if (err) {
-                if (err & V850E_UART_ERR_OVERRUN) {
-                        ch_stat = TTY_OVERRUN;
-                        port->icount.overrun++;
-                } else if (err & V850E_UART_ERR_FRAME) {
-                        ch_stat = TTY_FRAME;
-                        port->icount.frame++;
-                } else if (err & V850E_UART_ERR_PARITY) {
-                        ch_stat = TTY_PARITY;
-                        port->icount.parity++;
-                }
-        }
-        port->icount.rx++;
-        tty_insert_flip_char (port->info->tty, ch, ch_stat);
-        tty_schedule_flip (port->info->tty);
-        return IRQ_HANDLED;
-}
-/* Control functions for the serial framework.  */
-static void v850e_uart_nop (struct uart_port *port) { }
-static int v850e_uart_success (struct uart_port *port) { return 0; }
-static unsigned v850e_uart_tx_empty (struct uart_port *port)
-{
-        return TIOCSER_TEMT;    /* Can't detect.  */
-}
-static void v850e_uart_set_mctrl (struct uart_port *port, unsigned mctrl)
-{
-#ifdef V850E_UART_SET_RTS
-        V850E_UART_SET_RTS (port->line, (mctrl & TIOCM_RTS));
-#endif
-}
-static unsigned v850e_uart_get_mctrl (struct uart_port *port)
-{
-        /* We don't support DCD or DSR, so consider them permanently active. */
-        int mctrl = TIOCM_CAR | TIOCM_DSR;
-        /* We may support CTS.  */
-#ifdef V850E_UART_CTS
-        mctrl |= V850E_UART_CTS(port->line) ? TIOCM_CTS : 0;
-#else
-        mctrl |= TIOCM_CTS;
-#endif
-        return mctrl;
-}
-static void v850e_uart_start_tx (struct uart_port *port)
-{
-        v850e_intc_disable_irq (V850E_UART_TX_IRQ (port->line));
-        v850e_uart_tx (port);
-        v850e_intc_enable_irq (V850E_UART_TX_IRQ (port->line));
-}
-static void v850e_uart_stop_tx (struct uart_port *port)
-{
-        v850e_intc_disable_irq (V850E_UART_TX_IRQ (port->line));
-}
-static void v850e_uart_start_rx (struct uart_port *port)
-{
-        v850e_intc_enable_irq (V850E_UART_RX_IRQ (port->line));
-}
-static void v850e_uart_stop_rx (struct uart_port *port)
-{
-        v850e_intc_disable_irq (V850E_UART_RX_IRQ (port->line));
-}
-static void v850e_uart_break_ctl (struct uart_port *port, int break_ctl)
-{
-        /* Umm, do this later.  */
-}
-static int v850e_uart_startup (struct uart_port *port)
-{
-        int err;
-        /* Alloc RX irq.  */
-        err = request_irq (V850E_UART_RX_IRQ (port->line), v850e_uart_rx_irq,
-                           IRQF_DISABLED, "v850e_uart", port);
-        if (err)
-                return err;
-        /* Alloc TX irq.  */
-        err = request_irq (V850E_UART_TX_IRQ (port->line), v850e_uart_tx_irq,
-                           IRQF_DISABLED, "v850e_uart", port);
-        if (err) {
-                free_irq (V850E_UART_RX_IRQ (port->line), port);
-                return err;
-        }
-        v850e_uart_start_rx (port);
-        return 0;
-}
-static void v850e_uart_shutdown (struct uart_port *port)
-{
-        /* Disable port interrupts.  */
-        free_irq (V850E_UART_TX_IRQ (port->line), port);
-        free_irq (V850E_UART_RX_IRQ (port->line), port);
-        /* Turn off xmit/recv enable bits.  */
-        V850E_UART_CONFIG (port->line)
-                &= ~(V850E_UART_CONFIG_TX_ENABLE
-                     | V850E_UART_CONFIG_RX_ENABLE);
-        /* Then reset the channel.  */
-        V850E_UART_CONFIG (port->line) = 0;
-}
-static void
-v850e_uart_set_termios (struct uart_port *port, struct ktermios *termios,
-                        struct ktermios *old)
-{
-        unsigned cflags = termios->c_cflag;
-        /* Restrict flags to legal values.  */
-        if ((cflags & CSIZE) != CS7 && (cflags & CSIZE) != CS8)
-                /* The new value of CSIZE is invalid, use the old value.  */
-                cflags = (cflags & ~CSIZE)
-                        | (old ? (old->c_cflag & CSIZE) : CS8);
-        termios->c_cflag = cflags;
-        v850e_uart_configure (port->line, cflags,
-                              uart_get_baud_rate (port, termios, old,
-                                                  v850e_uart_min_baud(),
-                                                  v850e_uart_max_baud()));
-}
-static const char *v850e_uart_type (struct uart_port *port)
-{
-        return port->type == PORT_V850E_UART ? "v850e_uart" : 0;
-}
-static void v850e_uart_config_port (struct uart_port *port, int flags)
-{
-        if (flags & UART_CONFIG_TYPE)
-                port->type = PORT_V850E_UART;
-}
-static int
-v850e_uart_verify_port (struct uart_port *port, struct serial_struct *ser)
-{
-        if (ser->type != PORT_UNKNOWN && ser->type != PORT_V850E_UART)
-                return -EINVAL;
-        if (ser->irq != V850E_UART_TX_IRQ (port->line))
-                return -EINVAL;
-        return 0;
-}
-static struct uart_ops v850e_uart_ops = {
-        .tx_empty       = v850e_uart_tx_empty,
-        .get_mctrl      = v850e_uart_get_mctrl,
-        .set_mctrl      = v850e_uart_set_mctrl,
-        .start_tx       = v850e_uart_start_tx,
-        .stop_tx        = v850e_uart_stop_tx,
-        .stop_rx        = v850e_uart_stop_rx,
-        .enable_ms      = v850e_uart_nop,
-        .break_ctl      = v850e_uart_break_ctl,
-        .startup        = v850e_uart_startup,
-        .shutdown       = v850e_uart_shutdown,
-        .set_termios    = v850e_uart_set_termios,
-        .type           = v850e_uart_type,
-        .release_port   = v850e_uart_nop,
-        .request_port   = v850e_uart_success,
-        .config_port    = v850e_uart_config_port,
-        .verify_port    = v850e_uart_verify_port,
-};
-/* Initialization and cleanup.  */
-static struct uart_driver v850e_uart_driver = {
-        .owner                  = THIS_MODULE,
-        .driver_name            = "v850e_uart",
-        .dev_name               = "ttyS",
-        .major                  = TTY_MAJOR,
-        .minor                  = V850E_UART_MINOR_BASE,
-        .nr                     = V850E_UART_NUM_CHANNELS,
-        .cons                   = V850E_UART_CONSOLE,
-};
-static struct uart_port v850e_uart_ports[V850E_UART_NUM_CHANNELS];
-static int __init v850e_uart_init (void)
-{
-        int rval;
-        printk (KERN_INFO "%s on-chip UART\n", V850E_UART_CHIP_NAME);
-        rval = uart_register_driver (&v850e_uart_driver);
-        if (rval == 0) {
-                unsigned chan;
-                for (chan = 0; chan < V850E_UART_NUM_CHANNELS; chan++) {
-                        struct uart_port *port = &v850e_uart_ports[chan];
-                        
-                        memset (port, 0, sizeof *port);
-                        port->ops = &v850e_uart_ops;
-                        port->line = chan;
-                        port->iotype = UPIO_MEM;
-                        port->flags = UPF_BOOT_AUTOCONF;
-                        /* We actually use multiple IRQs, but the serial
-                           framework seems to mainly use this for
-                           informational purposes anyway.  Here we use the TX
-                           irq.  */
-                        port->irq = V850E_UART_TX_IRQ (chan);
-                        /* The serial framework doesn't really use these
-                           membase/mapbase fields for anything useful, but
-                           it requires that they be something non-zero to
-                           consider the port `valid', and also uses them
-                           for informational purposes.  */
-                        port->membase = (void *)V850E_UART_BASE_ADDR (chan);
-                        port->mapbase = V850E_UART_BASE_ADDR (chan);
-                        /* The framework insists on knowing the uart's master
-                           clock freq, though it doesn't seem to do anything
-                           useful for us with it.  We must make it at least
-                           higher than (the maximum baud rate * 16), otherwise
-                           the framework will puke during its internal
-                           calculations, and force the baud rate to be 9600.
-                           To be accurate though, just repeat the calculation
-                           we use when actually setting the speed.  */
-                        port->uartclk = v850e_uart_max_clock() * 16;
-                        uart_add_one_port (&v850e_uart_driver, port);
-                }
-        }
-        return rval;
-}
-static void __exit v850e_uart_exit (void)
-{
-        unsigned chan;
-        for (chan = 0; chan < V850E_UART_NUM_CHANNELS; chan++)
-                uart_remove_one_port (&v850e_uart_driver,
-                                      &v850e_uart_ports[chan]);
-        uart_unregister_driver (&v850e_uart_driver);
-}
-module_init (v850e_uart_init);
-module_exit (v850e_uart_exit);
-MODULE_AUTHOR ("Miles Bader");
-MODULE_DESCRIPTION ("NEC " V850E_UART_CHIP_NAME " on-chip UART");
-MODULE_LICENSE ("GPL");
diff --git a/drivers/serial/vr41xx_siu.c b/drivers/serial/vr41xx_siu.c
index bb6ce6bba32f..0573f3b5175e 100644
--- a/drivers/serial/vr41xx_siu.c
+++ b/drivers/serial/vr41xx_siu.c
@@ -318,7 +318,7 @@ static inline void receive_chars(struct uart_port *port, uint8_t *status)
        char flag;
        int max_count = RX_MAX_COUNT;
-        tty = port->info->tty;
+        tty = port->info->port.tty;
        lsr = *status;
        do {
diff --git a/drivers/serial/zs.c b/drivers/serial/zs.c
index 65f1294fd27b..9e6a873f8203 100644
--- a/drivers/serial/zs.c
+++ b/drivers/serial/zs.c
@@ -602,7 +602,7 @@ static void zs_receive_chars(struct zs_port *zport)
                uart_insert_char(uport, status, Rx_OVR, ch, flag);
        }
-        tty_flip_buffer_push(uport->info->tty);
+        tty_flip_buffer_push(uport->info->port.tty);
 }
 static void zs_raw_transmit_chars(struct zs_port *zport)
@@ -787,7 +787,6 @@ static int zs_startup(struct uart_port *uport)
        zport->regs[1] &= ~RxINT_MASK;
        zport->regs[1] |= RxINT_ALL | TxINT_ENAB | EXT_INT_ENAB;
        zport->regs[3] |= RxENABLE;
-        zport->regs[5] |= TxENAB;
        zport->regs[15] |= BRKIE;
        write_zsreg(zport, R1, zport->regs[1]);
        write_zsreg(zport, R3, zport->regs[3]);
@@ -814,7 +813,6 @@ static void zs_shutdown(struct uart_port *uport)
        spin_lock_irqsave(&scc->zlock, flags);
-        zport->regs[5] &= ~TxENAB;
        zport->regs[3] &= ~RxENABLE;
        write_zsreg(zport, R5, zport->regs[5]);
        write_zsreg(zport, R3, zport->regs[3]);
@@ -959,6 +957,23 @@ static void zs_set_termios(struct uart_port *uport, struct ktermios *termios,
        spin_unlock_irqrestore(&scc->zlock, flags);
 }
+/*
+ * Hack alert!
+ * Required solely so that the initial PROM-based console
+ * works undisturbed in parallel with this one.
+ */
+static void zs_pm(struct uart_port *uport, unsigned int state,
+                  unsigned int oldstate)
+{
+        struct zs_port *zport = to_zport(uport);
+        if (state < 3)
+                zport->regs[5] |= TxENAB;
+        else
+                zport->regs[5] &= ~TxENAB;
+        write_zsreg(zport, R5, zport->regs[5]);
+}
 static const char *zs_type(struct uart_port *uport)
 {
@@ -1041,6 +1056,7 @@ static struct uart_ops zs_ops = {
        .startup        = zs_startup,
        .shutdown       = zs_shutdown,
        .set_termios    = zs_set_termios,
+        .pm             = zs_pm,
        .type           = zs_type,
        .release_port   = zs_release_port,
        .request_port   = zs_request_port,
@@ -1190,6 +1206,7 @@ static int __init zs_console_setup(struct console *co, char *options)
                return ret;
        zs_reset(zport);
+        zs_pm(uport, 0, -1);
        if (options)
                uart_parse_options(options, &baud, &parity, &bits, &flow);
author	Ingo Molnar <mingo@elte.hu>	2008-10-28 11:26:12 -0400
committer	Ingo Molnar <mingo@elte.hu>	2008-10-28 11:26:12 -0400
commit	7a9787e1eba95a166265e6a260cf30af04ef0a99 (patch)
tree	e730a4565e0318140d2fbd2f0415d18a339d7336 /drivers/serial
parent	41b9eb264c8407655db57b60b4457fe1b2ec9977 (diff)
parent	0173a3265b228da319ceb9c1ec6a5682fd1b2d92 (diff)