Merge tag 'tty-3.9-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/tty

Pull tty/serial patches from Greg Kroah-Hartman:
 "Here's the big tty/serial driver patches for 3.9-rc1.

  More tty port rework and fixes from Jiri here, as well as lots of
  individual serial driver updates and fixes.

  All of these have been in the linux-next tree for a while."

* tag 'tty-3.9-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/tty: (140 commits)
  tty: mxser: improve error handling in mxser_probe() and mxser_module_init()
  serial: imx: fix uninitialized variable warning
  serial: tegra: assume CONFIG_OF
  TTY: do not update atime/mtime on read/write
  lguest: select CONFIG_TTY to build properly.
  ARM defconfigs: add missing inclusions of linux/platform_device.h
  fb/exynos: include platform_device.h
  ARM: sa1100/assabet: include platform_device.h directly
  serial: imx: Fix recursive locking bug
  pps: Fix build breakage from decoupling pps from tty
  tty: Remove ancient hardpps()
  pps: Additional cleanups in uart_handle_dcd_change
  pps: Move timestamp read into PPS code proper
  pps: Don't crash the machine when exiting will do
  pps: Fix a use-after free bug when unregistering a source.
  pps: Use pps_lookup_dev to reduce ldisc coupling
  pps: Add pps_lookup_dev() function
  tty: serial: uartlite: Support uartlite on big and little endian systems
  tty: serial: uartlite: Fix sparse and checkpatch warnings
  serial/arc-uart: Miscll DT related updates (Grant's review comments)
  ...

Fix up trivial conflicts, mostly just due to the TTY config option
clashing with the EXPERIMENTAL removal.

214 files changed, 6442 insertions, 2354 deletions

diff --git a/drivers/bluetooth/Kconfig b/drivers/bluetooth/Kconfig
index e9f203eadb1f..fdfd61a2d523 100644
--- a/drivers/bluetooth/Kconfig
+++ b/drivers/bluetooth/Kconfig
@@ -26,6 +26,7 @@ config BT_HCIBTSDIO
 
 config BT_HCIUART
         tristate "HCI UART driver"
+        depends on TTY
         help
           Bluetooth HCI UART driver.
           This driver is required if you want to use Bluetooth devices with
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 72bedad6bf8c..3bb6fa3930be 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -53,7 +53,7 @@ source "drivers/tty/serial/Kconfig"
 
 config TTY_PRINTK
         bool "TTY driver to output user messages via printk"
-        depends on EXPERT
+        depends on EXPERT && TTY
         default n
         ---help---
           If you say Y here, the support for writing user messages (i.e.
@@ -159,7 +159,7 @@ source "drivers/tty/hvc/Kconfig"
 
 config VIRTIO_CONSOLE
         tristate "Virtio console"
-        depends on VIRTIO
+        depends on VIRTIO && TTY
         select HVC_DRIVER
         help
           Virtio console for use with lguest and other hypervisors.
@@ -392,6 +392,7 @@ config XILINX_HWICAP
 
 config R3964
         tristate "Siemens R3964 line discipline"
+        depends on TTY
         ---help---
           This driver allows synchronous communication with devices using the
           Siemens R3964 packet protocol. Unless you are dealing with special
@@ -439,7 +440,7 @@ source "drivers/char/pcmcia/Kconfig"
 
 config MWAVE
         tristate "ACP Modem (Mwave) support"
-        depends on X86
+        depends on X86 && TTY
         select SERIAL_8250
         ---help---
           The ACP modem (Mwave) for Linux is a WinModem. It is composed of a
diff --git a/drivers/char/pcmcia/Kconfig b/drivers/char/pcmcia/Kconfig
index 6614416a8623..2a166d56738a 100644
--- a/drivers/char/pcmcia/Kconfig
+++ b/drivers/char/pcmcia/Kconfig
@@ -7,7 +7,7 @@ menu "PCMCIA character devices"
 
 config SYNCLINK_CS
         tristate "SyncLink PC Card support"
-        depends on PCMCIA
+        depends on PCMCIA && TTY
         help
           Enable support for the SyncLink PC Card serial adapter, running
           asynchronous and HDLC communications up to 512Kbps. The port is
@@ -45,7 +45,7 @@ config CARDMAN_4040
 
 config IPWIRELESS
         tristate "IPWireless 3G UMTS PCMCIA card support"
-        depends on PCMCIA && NETDEVICES
+        depends on PCMCIA && NETDEVICES && TTY
         select PPP
         help
           This is a driver for 3G UMTS PCMCIA card from IPWireless company. In
diff --git a/drivers/char/pcmcia/synclink_cs.c b/drivers/char/pcmcia/synclink_cs.c
index b66eaa04f8cb..d0c9852ab875 100644
--- a/drivers/char/pcmcia/synclink_cs.c
+++ b/drivers/char/pcmcia/synclink_cs.c
@@ -210,7 +210,7 @@ typedef struct _mgslpc_info {
         char testing_irq;
         unsigned int init_error;        /* startup error (DIAGS)        */
 
-        char flag_buf[MAX_ASYNC_BUFFER_SIZE];
+        char *flag_buf;
         bool drop_rts_on_tx_done;
 
         struct  _input_signal_events    input_signal_events;
@@ -765,9 +765,6 @@ static void bh_handler(struct work_struct *work)
         struct tty_struct *tty;
         int action;
 
-        if (!info)
-                return;
-
         if (debug_level >= DEBUG_LEVEL_BH)
                 printk( "%s(%d):bh_handler(%s) entry\n",
                         __FILE__,__LINE__,info->device_name);
@@ -886,21 +883,14 @@ static void rx_ready_hdlc(MGSLPC_INFO *info, int eom)
         issue_command(info, CHA, CMD_RXFIFO);
 }
 
-static void rx_ready_async(MGSLPC_INFO *info, int tcd, struct tty_struct *tty)
+static void rx_ready_async(MGSLPC_INFO *info, int tcd)
 {
+        struct tty_port *port = &info->port;
         unsigned char data, status, flag;
         int fifo_count;
         int work = 0;
         struct mgsl_icount *icount = &info->icount;
 
-        if (!tty) {
-                /* tty is not available anymore */
-                issue_command(info, CHA, CMD_RXRESET);
-                if (debug_level >= DEBUG_LEVEL_ISR)
-                        printk("%s(%d):rx_ready_async(tty=NULL)\n",__FILE__,__LINE__);
-                return;
-        }
-
         if (tcd) {
                 /* early termination, get FIFO count from RBCL register */
                 fifo_count = (unsigned char)(read_reg(info, CHA+RBCL) & 0x1f);
@@ -913,7 +903,7 @@ static void rx_ready_async(MGSLPC_INFO *info, int tcd, struct tty_struct *tty)
         } else
                 fifo_count = 32;
 
-        tty_buffer_request_room(tty, fifo_count);
+        tty_buffer_request_room(port, fifo_count);
         /* Flush received async data to receive data buffer. */
         while (fifo_count) {
                 data   = read_reg(info, CHA + RXFIFO);
@@ -944,7 +934,7 @@ static void rx_ready_async(MGSLPC_INFO *info, int tcd, struct tty_struct *tty)
                         else if (status & BIT6)
                                 flag = TTY_FRAME;
                 }
-                work += tty_insert_flip_char(tty, data, flag);
+                work += tty_insert_flip_char(port, data, flag);
         }
         issue_command(info, CHA, CMD_RXFIFO);
 
@@ -957,7 +947,7 @@ static void rx_ready_async(MGSLPC_INFO *info, int tcd, struct tty_struct *tty)
         }
 
         if (work)
-                tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(port);
 }
 
 
@@ -1217,7 +1207,7 @@ static irqreturn_t mgslpc_isr(int dummy, void *dev_id)
                                 if (info->params.mode == MGSL_MODE_HDLC)
                                         rx_ready_hdlc(info, isr & IRQ_RXEOM);
                                 else
-                                        rx_ready_async(info, isr & IRQ_RXEOM, tty);
+                                        rx_ready_async(info, isr & IRQ_RXEOM);
                         }
 
                         /* transmit IRQs */
@@ -1353,7 +1343,7 @@ static void shutdown(MGSLPC_INFO * info, struct tty_struct *tty)
         reset_device(info);
 
         if (!tty || tty->termios.c_cflag & HUPCL) {
-                info->serial_signals &= ~(SerialSignal_DTR + SerialSignal_RTS);
+                info->serial_signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
                 set_signals(info);
         }
 
@@ -1415,12 +1405,12 @@ static void mgslpc_change_params(MGSLPC_INFO *info, struct tty_struct *tty)
 
         cflag = tty->termios.c_cflag;
 
-        /* if B0 rate (hangup) specified then negate DTR and RTS */
-        /* otherwise assert DTR and RTS */
+        /* if B0 rate (hangup) specified then negate RTS and DTR */
+        /* otherwise assert RTS and DTR */
         if (cflag & CBAUD)
-                info->serial_signals |= SerialSignal_RTS + SerialSignal_DTR;
+                info->serial_signals |= SerialSignal_RTS | SerialSignal_DTR;
         else
-                info->serial_signals &= ~(SerialSignal_RTS + SerialSignal_DTR);
+                info->serial_signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
 
         /* byte size and parity */
 
@@ -2311,7 +2301,7 @@ static void mgslpc_set_termios(struct tty_struct *tty, struct ktermios *old_term
         /* Handle transition to B0 status */
         if (old_termios->c_cflag & CBAUD &&
             !(tty->termios.c_cflag & CBAUD)) {
-                info->serial_signals &= ~(SerialSignal_RTS + SerialSignal_DTR);
+                info->serial_signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
                 spin_lock_irqsave(&info->lock,flags);
                 set_signals(info);
                 spin_unlock_irqrestore(&info->lock,flags);
@@ -2474,9 +2464,9 @@ static void dtr_rts(struct tty_port *port, int onoff)
 
         spin_lock_irqsave(&info->lock,flags);
         if (onoff)
-                info->serial_signals |= SerialSignal_RTS + SerialSignal_DTR;
+                info->serial_signals |= SerialSignal_RTS | SerialSignal_DTR;
         else
-                info->serial_signals &= ~SerialSignal_RTS + SerialSignal_DTR;
+                info->serial_signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
         set_signals(info);
         spin_unlock_irqrestore(&info->lock,flags);
 }
@@ -2521,7 +2511,7 @@ static int mgslpc_open(struct tty_struct *tty, struct file * filp)
                 goto cleanup;
         }
 
-        tty->low_latency = (port->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
+        port->low_latency = (port->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
 
         spin_lock_irqsave(&info->netlock, flags);
         if (info->netcount) {
@@ -2674,6 +2664,14 @@ static int rx_alloc_buffers(MGSLPC_INFO *info)
         if (info->rx_buf == NULL)
                 return -ENOMEM;
 
+        /* unused flag buffer to satisfy receive_buf calling interface */
+        info->flag_buf = kzalloc(info->max_frame_size, GFP_KERNEL);
+        if (!info->flag_buf) {
+                kfree(info->rx_buf);
+                info->rx_buf = NULL;
+                return -ENOMEM;
+        }
+        
         rx_reset_buffers(info);
         return 0;
 }
@@ -2682,6 +2680,8 @@ static void rx_free_buffers(MGSLPC_INFO *info)
 {
         kfree(info->rx_buf);
         info->rx_buf = NULL;
+        kfree(info->flag_buf);
+        info->flag_buf = NULL;
 }
 
 static int claim_resources(MGSLPC_INFO *info)
@@ -3575,8 +3575,8 @@ static void get_signals(MGSLPC_INFO *info)
 {
         unsigned char status = 0;
 
-        /* preserve DTR and RTS */
-        info->serial_signals &= SerialSignal_DTR + SerialSignal_RTS;
+        /* preserve RTS and DTR */
+        info->serial_signals &= SerialSignal_RTS | SerialSignal_DTR;
 
         if (read_reg(info, CHB + VSTR) & BIT7)
                 info->serial_signals |= SerialSignal_DCD;
@@ -3590,7 +3590,7 @@ static void get_signals(MGSLPC_INFO *info)
                 info->serial_signals |= SerialSignal_DSR;
 }
 
-/* Set the state of DTR and RTS based on contents of
+/* Set the state of RTS and DTR based on contents of
  * serial_signals member of device extension.
  */
 static void set_signals(MGSLPC_INFO *info)
@@ -4009,8 +4009,8 @@ static int hdlcdev_open(struct net_device *dev)
                 spin_unlock_irqrestore(&info->netlock, flags);
                 return rc;
         }
-        /* assert DTR and RTS, apply hardware settings */
-        info->serial_signals |= SerialSignal_RTS + SerialSignal_DTR;
+        /* assert RTS and DTR, apply hardware settings */
+        info->serial_signals |= SerialSignal_RTS | SerialSignal_DTR;
         mgslpc_program_hw(info, tty);
         tty_kref_put(tty);
 
diff --git a/drivers/gpu/drm/gma500/cdv_intel_dp.c b/drivers/gpu/drm/gma500/cdv_intel_dp.c
index 51044cc55cf2..88d9ef6b5b4a 100644
--- a/drivers/gpu/drm/gma500/cdv_intel_dp.c
+++ b/drivers/gpu/drm/gma500/cdv_intel_dp.c
@@ -27,6 +27,7 @@
 
 #include <linux/i2c.h>
 #include <linux/slab.h>
+#include <linux/module.h>
 #include <drm/drmP.h>
 #include <drm/drm_crtc.h>
 #include <drm/drm_crtc_helper.h>
diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig
index 9b94a78ca776..8bb810e1900b 100644
--- a/drivers/i2c/busses/Kconfig
+++ b/drivers/i2c/busses/Kconfig
@@ -802,6 +802,7 @@ config I2C_PARPORT_LIGHT
 
 config I2C_TAOS_EVM
         tristate "TAOS evaluation module"
+        depends on TTY
         select SERIO
         select SERIO_SERPORT
         default n
diff --git a/drivers/input/serio/Kconfig b/drivers/input/serio/Kconfig
index 560c243bfcaf..6e9cc765e0dc 100644
--- a/drivers/input/serio/Kconfig
+++ b/drivers/input/serio/Kconfig
@@ -36,6 +36,7 @@ config SERIO_I8042
 config SERIO_SERPORT
         tristate "Serial port line discipline"
         default y
+        depends on TTY
         help
           Say Y here if you plan to use an input device (mouse, joystick,
           tablet, 6dof) that communicates over the RS232 serial (COM) port.
diff --git a/drivers/ipack/devices/Kconfig b/drivers/ipack/devices/Kconfig
index 0b82fdc198c0..907a8cb48f2a 100644
--- a/drivers/ipack/devices/Kconfig
+++ b/drivers/ipack/devices/Kconfig
@@ -1,6 +1,6 @@
 config SERIAL_IPOCTAL
         tristate "IndustryPack IP-OCTAL uart support"
-        depends on IPACK_BUS
+        depends on IPACK_BUS && TTY
         help
           This driver supports the IPOCTAL serial port device for the IndustryPack bus.
         default n
diff --git a/drivers/ipack/devices/ipoctal.c b/drivers/ipack/devices/ipoctal.c
index 576d53d92677..ab20a0851dd2 100644
--- a/drivers/ipack/devices/ipoctal.c
+++ b/drivers/ipack/devices/ipoctal.c
@@ -133,9 +133,9 @@ static int ipoctal_get_icount(struct tty_struct *tty,
         return 0;
 }
 
-static void ipoctal_irq_rx(struct ipoctal_channel *channel,
-                           struct tty_struct *tty, u8 sr)
+static void ipoctal_irq_rx(struct ipoctal_channel *channel, u8 sr)
 {
+        struct tty_port *port = &channel->tty_port;
         unsigned char value;
         unsigned char flag = TTY_NORMAL;
         u8 isr;
@@ -149,7 +149,7 @@ static void ipoctal_irq_rx(struct ipoctal_channel *channel,
                         if (sr & SR_OVERRUN_ERROR) {
                                 channel->stats.overrun_err++;
                                 /* Overrun doesn't affect the current character*/
-                                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                                tty_insert_flip_char(port, 0, TTY_OVERRUN);
                         }
                         if (sr & SR_PARITY_ERROR) {
                                 channel->stats.parity_err++;
@@ -165,7 +165,7 @@ static void ipoctal_irq_rx(struct ipoctal_channel *channel,
                                 flag = TTY_BREAK;
                         }
                 }
-                tty_insert_flip_char(tty, value, flag);
+                tty_insert_flip_char(port, value, flag);
 
                 /* Check if there are more characters in RX FIFO
                  * If there are more, the isr register for this channel
@@ -175,7 +175,7 @@ static void ipoctal_irq_rx(struct ipoctal_channel *channel,
                 sr = ioread8(&channel->regs->r.sr);
         } while (isr & channel->isr_rx_rdy_mask);
 
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(port);
 }
 
 static void ipoctal_irq_tx(struct ipoctal_channel *channel)
@@ -208,15 +208,11 @@ static void ipoctal_irq_tx(struct ipoctal_channel *channel)
 static void ipoctal_irq_channel(struct ipoctal_channel *channel)
 {
         u8 isr, sr;
-        struct tty_struct *tty;
 
         /* If there is no client, skip the check */
         if (!atomic_read(&channel->open))
                 return;
 
-        tty = tty_port_tty_get(&channel->tty_port);
-        if (!tty)
-                return;
         /* The HW is organized in pair of channels.  See which register we need
          * to read from */
         isr = ioread8(&channel->block_regs->r.isr);
@@ -235,14 +231,13 @@ static void ipoctal_irq_channel(struct ipoctal_channel *channel)
 
         /* RX data */
         if ((isr & channel->isr_rx_rdy_mask) && (sr & SR_RX_READY))
-                ipoctal_irq_rx(channel, tty, sr);
+                ipoctal_irq_rx(channel, sr);
 
         /* TX of each character */
         if ((isr & channel->isr_tx_rdy_mask) && (sr & SR_TX_READY))
                 ipoctal_irq_tx(channel);
 
-        tty_flip_buffer_push(tty);
-        tty_kref_put(tty);
+        tty_flip_buffer_push(&channel->tty_port);
 }
 
 static irqreturn_t ipoctal_irq_handler(void *arg)
diff --git a/drivers/isdn/Kconfig b/drivers/isdn/Kconfig
index 86cd75a0e84d..ef661acdda17 100644
--- a/drivers/isdn/Kconfig
+++ b/drivers/isdn/Kconfig
@@ -22,6 +22,7 @@ if ISDN
 
 menuconfig ISDN_I4L
         tristate "Old ISDN4Linux (deprecated)"
+        depends on TTY
         ---help---
           This driver allows you to use an ISDN adapter for networking
           connections and as dialin/out device.  The isdn-tty's have a built
diff --git a/drivers/isdn/capi/Kconfig b/drivers/isdn/capi/Kconfig
index 15c3ffd9d860..f04686580040 100644
--- a/drivers/isdn/capi/Kconfig
+++ b/drivers/isdn/capi/Kconfig
@@ -18,6 +18,7 @@ config CAPI_TRACE
 
 config ISDN_CAPI_MIDDLEWARE
         bool "CAPI2.0 Middleware support"
+        depends on TTY
         help
           This option will enhance the capabilities of the /dev/capi20
           interface.  It will provide a means of moving a data connection,
diff --git a/drivers/isdn/gigaset/Kconfig b/drivers/isdn/gigaset/Kconfig
index b18a92c32184..dde5e09e6267 100644
--- a/drivers/isdn/gigaset/Kconfig
+++ b/drivers/isdn/gigaset/Kconfig
@@ -1,5 +1,6 @@
 menuconfig ISDN_DRV_GIGASET
         tristate "Siemens Gigaset support"
+        depends on TTY
         select CRC_CCITT
         select BITREVERSE
         help
diff --git a/drivers/isdn/gigaset/interface.c b/drivers/isdn/gigaset/interface.c
index 20b7e7a1190f..e2b539675b66 100644
--- a/drivers/isdn/gigaset/interface.c
+++ b/drivers/isdn/gigaset/interface.c
@@ -134,7 +134,7 @@ static int if_open(struct tty_struct *tty, struct file *filp)
 
         if (cs->port.count == 1) {
                 tty_port_tty_set(&cs->port, tty);
-                tty->low_latency = 1;
+                cs->port.low_latency = 1;
         }
 
         mutex_unlock(&cs->mutex);
@@ -546,16 +546,8 @@ void gigaset_if_free(struct cardstate *cs)
 void gigaset_if_receive(struct cardstate *cs,
                         unsigned char *buffer, size_t len)
 {
-        struct tty_struct *tty = tty_port_tty_get(&cs->port);
-
-        if (tty == NULL) {
-                gig_dbg(DEBUG_IF, "receive on closed device");
-                return;
-        }
-
-        tty_insert_flip_string(tty, buffer, len);
-        tty_flip_buffer_push(tty);
-        tty_kref_put(tty);
+        tty_insert_flip_string(&cs->port, buffer, len);
+        tty_flip_buffer_push(&cs->port);
 }
 EXPORT_SYMBOL_GPL(gigaset_if_receive);
 
diff --git a/drivers/isdn/hardware/mISDN/Kconfig b/drivers/isdn/hardware/mISDN/Kconfig
index eadc1cd34a20..b8611e3e5e74 100644
--- a/drivers/isdn/hardware/mISDN/Kconfig
+++ b/drivers/isdn/hardware/mISDN/Kconfig
@@ -76,6 +76,7 @@ config MISDN_NETJET
         tristate "Support for NETJet cards"
         depends on MISDN
         depends on PCI
+        depends on TTY
         select MISDN_IPAC
         select ISDN_HDLC
         select ISDN_I4L
diff --git a/drivers/isdn/i4l/isdn_common.c b/drivers/isdn/i4l/isdn_common.c
index e2a945ee9f05..b87d9e577be2 100644
--- a/drivers/isdn/i4l/isdn_common.c
+++ b/drivers/isdn/i4l/isdn_common.c
@@ -876,7 +876,7 @@ isdn_readbchan(int di, int channel, u_char *buf, u_char *fp, int len, wait_queue
  * of the mapping (di,ch)<->minor, happen during the sleep? --he
  */
 int
-isdn_readbchan_tty(int di, int channel, struct tty_struct *tty, int cisco_hack)
+isdn_readbchan_tty(int di, int channel, struct tty_port *port, int cisco_hack)
 {
         int count;
         int count_pull;
@@ -891,7 +891,7 @@ isdn_readbchan_tty(int di, int channel, struct tty_struct *tty, int cisco_hack)
         if (skb_queue_empty(&dev->drv[di]->rpqueue[channel]))
                 return 0;
 
-        len = tty_buffer_request_room(tty, dev->drv[di]->rcvcount[channel]);
+        len = tty_buffer_request_room(port, dev->drv[di]->rcvcount[channel]);
         if (len == 0)
                 return len;
 
@@ -912,7 +912,7 @@ isdn_readbchan_tty(int di, int channel, struct tty_struct *tty, int cisco_hack)
                         while ((count_pull < skb->len) && (len > 0)) {
                                 /* push every character but the last to the tty buffer directly */
                                 if (count_put)
-                                        tty_insert_flip_char(tty, last, TTY_NORMAL);
+                                        tty_insert_flip_char(port, last, TTY_NORMAL);
                                 len--;
                                 if (dev->drv[di]->DLEflag & DLEmask) {
                                         last = DLE;
@@ -940,7 +940,7 @@ isdn_readbchan_tty(int di, int channel, struct tty_struct *tty, int cisco_hack)
                         }
                         count_put = count_pull;
                         if (count_put > 1)
-                                tty_insert_flip_string(tty, skb->data, count_put - 1);
+                                tty_insert_flip_string(port, skb->data, count_put - 1);
                         last = skb->data[count_put - 1];
                         len -= count_put;
 #ifdef CONFIG_ISDN_AUDIO
@@ -952,16 +952,16 @@ isdn_readbchan_tty(int di, int channel, struct tty_struct *tty, int cisco_hack)
                          * Now we can dequeue it.
                          */
                         if (cisco_hack)
-                                tty_insert_flip_char(tty, last, 0xFF);
+                                tty_insert_flip_char(port, last, 0xFF);
                         else
-                                tty_insert_flip_char(tty, last, TTY_NORMAL);
+                                tty_insert_flip_char(port, last, TTY_NORMAL);
 #ifdef CONFIG_ISDN_AUDIO
                         ISDN_AUDIO_SKB_LOCK(skb) = 0;
 #endif
                         skb = skb_dequeue(&dev->drv[di]->rpqueue[channel]);
                         dev_kfree_skb(skb);
                 } else {
-                        tty_insert_flip_char(tty, last, TTY_NORMAL);
+                        tty_insert_flip_char(port, last, TTY_NORMAL);
                         /* Not yet emptied this buff, so it
                          * must stay in the queue, for further calls
                          * but we pull off the data we got until now.
diff --git a/drivers/isdn/i4l/isdn_common.h b/drivers/isdn/i4l/isdn_common.h
index 9a471f62e1d4..2260ef07ab9c 100644
--- a/drivers/isdn/i4l/isdn_common.h
+++ b/drivers/isdn/i4l/isdn_common.h
@@ -37,7 +37,7 @@ extern void isdn_timer_ctrl(int tf, int onoff);
 extern void isdn_unexclusive_channel(int di, int ch);
 extern int isdn_getnum(char **);
 extern int isdn_readbchan(int, int, u_char *, u_char *, int, wait_queue_head_t *);
-extern int isdn_readbchan_tty(int, int, struct tty_struct *, int);
+extern int isdn_readbchan_tty(int, int, struct tty_port *, int);
 extern int isdn_get_free_channel(int, int, int, int, int, char *);
 extern int isdn_writebuf_skb_stub(int, int, int, struct sk_buff *);
 extern int register_isdn(isdn_if *i);
diff --git a/drivers/isdn/i4l/isdn_tty.c b/drivers/isdn/i4l/isdn_tty.c
index e09dc8a5e743..d8a7d8323414 100644
--- a/drivers/isdn/i4l/isdn_tty.c
+++ b/drivers/isdn/i4l/isdn_tty.c
@@ -60,18 +60,14 @@ static int si2bit[8] =
 static int
 isdn_tty_try_read(modem_info *info, struct sk_buff *skb)
 {
+        struct tty_port *port = &info->port;
         int c;
         int len;
-        struct tty_struct *tty;
         char last;
 
         if (!info->online)
                 return 0;
 
-        tty = info->port.tty;
-        if (!tty)
-                return 0;
-
         if (!(info->mcr & UART_MCR_RTS))
                 return 0;
 
@@ -81,7 +77,7 @@ isdn_tty_try_read(modem_info *info, struct sk_buff *skb)
 #endif
                 ;
 
-        c = tty_buffer_request_room(tty, len);
+        c = tty_buffer_request_room(port, len);
         if (c < len)
                 return 0;
 
@@ -91,25 +87,25 @@ isdn_tty_try_read(modem_info *info, struct sk_buff *skb)
                 unsigned char *dp = skb->data;
                 while (--l) {
                         if (*dp == DLE)
-                                tty_insert_flip_char(tty, DLE, 0);
-                        tty_insert_flip_char(tty, *dp++, 0);
+                                tty_insert_flip_char(port, DLE, 0);
+                        tty_insert_flip_char(port, *dp++, 0);
                 }
                 if (*dp == DLE)
-                        tty_insert_flip_char(tty, DLE, 0);
+                        tty_insert_flip_char(port, DLE, 0);
                 last = *dp;
         } else {
 #endif
                 if (len > 1)
-                        tty_insert_flip_string(tty, skb->data, len - 1);
+                        tty_insert_flip_string(port, skb->data, len - 1);
                 last = skb->data[len - 1];
 #ifdef CONFIG_ISDN_AUDIO
         }
 #endif
         if (info->emu.mdmreg[REG_CPPP] & BIT_CPPP)
-                tty_insert_flip_char(tty, last, 0xFF);
+                tty_insert_flip_char(port, last, 0xFF);
         else
-                tty_insert_flip_char(tty, last, TTY_NORMAL);
-        tty_flip_buffer_push(tty);
+                tty_insert_flip_char(port, last, TTY_NORMAL);
+        tty_flip_buffer_push(port);
         kfree_skb(skb);
 
         return 1;
@@ -126,7 +122,6 @@ isdn_tty_readmodem(void)
         int midx;
         int i;
         int r;
-        struct tty_struct *tty;
         modem_info *info;
 
         for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
@@ -144,20 +139,21 @@ isdn_tty_readmodem(void)
                 if ((info->vonline & 1) && (info->emu.vpar[1]))
                         isdn_audio_eval_silence(info);
 #endif
-                tty = info->port.tty;
-                if (tty) {
-                        if (info->mcr & UART_MCR_RTS) {
-                                /* CISCO AsyncPPP Hack */
-                                if (!(info->emu.mdmreg[REG_CPPP] & BIT_CPPP))
-                                        r = isdn_readbchan_tty(info->isdn_driver, info->isdn_channel, tty, 0);
-                                else
-                                        r = isdn_readbchan_tty(info->isdn_driver, info->isdn_channel, tty, 1);
-                                if (r)
-                                        tty_flip_buffer_push(tty);
-                        } else
-                                r = 1;
+                if (info->mcr & UART_MCR_RTS) {
+                        /* CISCO AsyncPPP Hack */
+                        if (!(info->emu.mdmreg[REG_CPPP] & BIT_CPPP))
+                                r = isdn_readbchan_tty(info->isdn_driver,
+                                                info->isdn_channel,
+                                                &info->port, 0);
+                        else
+                                r = isdn_readbchan_tty(info->isdn_driver,
+                                                info->isdn_channel,
+                                                &info->port, 1);
+                        if (r)
+                                tty_flip_buffer_push(&info->port);
                 } else
                         r = 1;
+
                 if (r) {
                         info->rcvsched = 0;
                         resched = 1;
@@ -2229,7 +2225,7 @@ isdn_tty_stat_callback(int i, isdn_ctrl *c)
 void
 isdn_tty_at_cout(char *msg, modem_info *info)
 {
-        struct tty_struct *tty;
+        struct tty_port *port = &info->port;
         atemu *m = &info->emu;
         char *p;
         char c;
@@ -2246,15 +2242,14 @@ isdn_tty_at_cout(char *msg, modem_info *info)
         l = strlen(msg);
 
         spin_lock_irqsave(&info->readlock, flags);
-        tty = info->port.tty;
-        if ((info->port.flags & ASYNC_CLOSING) || (!tty)) {
+        if (port->flags & ASYNC_CLOSING) {
                 spin_unlock_irqrestore(&info->readlock, flags);
                 return;
         }
 
         /* use queue instead of direct, if online and */
         /* data is in queue or buffer is full */
-        if (info->online && ((tty_buffer_request_room(tty, l) < l) ||
+        if (info->online && ((tty_buffer_request_room(port, l) < l) ||
                              !skb_queue_empty(&dev->drv[info->isdn_driver]->rpqueue[info->isdn_channel]))) {
                 skb = alloc_skb(l, GFP_ATOMIC);
                 if (!skb) {
@@ -2285,7 +2280,7 @@ isdn_tty_at_cout(char *msg, modem_info *info)
                 if (skb) {
                         *sp++ = c;
                 } else {
-                        if (tty_insert_flip_char(tty, c, TTY_NORMAL) == 0)
+                        if (tty_insert_flip_char(port, c, TTY_NORMAL) == 0)
                                 break;
                 }
         }
@@ -2299,7 +2294,7 @@ isdn_tty_at_cout(char *msg, modem_info *info)
 
         } else {
                 spin_unlock_irqrestore(&info->readlock, flags);
-                tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(port);
         }
 }
 
diff --git a/drivers/lguest/Kconfig b/drivers/lguest/Kconfig
index 6cdcdb0d3d58..89875ea19ade 100644
--- a/drivers/lguest/Kconfig
+++ b/drivers/lguest/Kconfig
@@ -1,6 +1,6 @@
 config LGUEST
         tristate "Linux hypervisor example code"
-        depends on X86_32 && EVENTFD
+        depends on X86_32 && EVENTFD && TTY
         select HVC_DRIVER
         ---help---
           This is a very simple module which allows you to run
diff --git a/drivers/media/radio/wl128x/Kconfig b/drivers/media/radio/wl128x/Kconfig
index ea1e6545df36..f359be7e9dd9 100644
--- a/drivers/media/radio/wl128x/Kconfig
+++ b/drivers/media/radio/wl128x/Kconfig
@@ -4,7 +4,7 @@
 menu "Texas Instruments WL128x FM driver (ST based)"
 config RADIO_WL128X
         tristate "Texas Instruments WL128x FM Radio"
-        depends on VIDEO_V4L2 && RFKILL && GPIOLIB
+        depends on VIDEO_V4L2 && RFKILL && GPIOLIB && TTY
         select TI_ST if NET
         help
         Choose Y here if you have this FM radio chip.
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index 8f59d88897e7..668a5822ab4e 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -127,7 +127,7 @@ config PHANTOM
 
 config INTEL_MID_PTI
         tristate "Parallel Trace Interface for MIPI P1149.7 cJTAG standard"
-        depends on PCI
+        depends on PCI && TTY
         default n
         help
           The PTI (Parallel Trace Interface) driver directs
diff --git a/drivers/misc/ti-st/Kconfig b/drivers/misc/ti-st/Kconfig
index abb5de1afce3..f34dcc514730 100644
--- a/drivers/misc/ti-st/Kconfig
+++ b/drivers/misc/ti-st/Kconfig
@@ -5,7 +5,7 @@
 menu "Texas Instruments shared transport line discipline"
 config TI_ST
         tristate "Shared transport core driver"
-        depends on NET && GPIOLIB
+        depends on NET && GPIOLIB && TTY
         select FW_LOADER
         help
           This enables the shared transport core driver for TI
diff --git a/drivers/mmc/card/Kconfig b/drivers/mmc/card/Kconfig
index 3b1f783bf924..5562308699bc 100644
--- a/drivers/mmc/card/Kconfig
+++ b/drivers/mmc/card/Kconfig
@@ -52,6 +52,7 @@ config MMC_BLOCK_BOUNCE
 
 config SDIO_UART
         tristate "SDIO UART/GPS class support"
+        depends on TTY
         help
           SDIO function driver for SDIO cards that implements the UART
           class, as well as the GPS class which appears like a UART.
diff --git a/drivers/mmc/card/sdio_uart.c b/drivers/mmc/card/sdio_uart.c
index bd57a11acc79..c931dfe6a59c 100644
--- a/drivers/mmc/card/sdio_uart.c
+++ b/drivers/mmc/card/sdio_uart.c
@@ -381,7 +381,6 @@ static void sdio_uart_stop_rx(struct sdio_uart_port *port)
 static void sdio_uart_receive_chars(struct sdio_uart_port *port,
                                     unsigned int *status)
 {
-        struct tty_struct *tty = tty_port_tty_get(&port->port);
         unsigned int ch, flag;
         int max_count = 256;
 
@@ -418,23 +417,19 @@ static void sdio_uart_receive_chars(struct sdio_uart_port *port,
                 }
 
                 if ((*status & port->ignore_status_mask & ~UART_LSR_OE) == 0)
-                        if (tty)
-                                tty_insert_flip_char(tty, ch, flag);
+                        tty_insert_flip_char(&port->port, ch, flag);
 
                 /*
                  * Overrun is special.  Since it's reported immediately,
                  * it doesn't affect the current character.
                  */
                 if (*status & ~port->ignore_status_mask & UART_LSR_OE)
-                        if (tty)
-                                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                        tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
 
                 *status = sdio_in(port, UART_LSR);
         } while ((*status & UART_LSR_DR) && (max_count-- > 0));
-        if (tty) {
-                tty_flip_buffer_push(tty);
-                tty_kref_put(tty);
-        }
+
+        tty_flip_buffer_push(&port->port);
 }
 
 static void sdio_uart_transmit_chars(struct sdio_uart_port *port)
diff --git a/drivers/net/caif/Kconfig b/drivers/net/caif/Kconfig
index abf4d7a9dcce..60c2142373c9 100644
--- a/drivers/net/caif/Kconfig
+++ b/drivers/net/caif/Kconfig
@@ -6,7 +6,7 @@ comment "CAIF transport drivers"
 
 config CAIF_TTY
         tristate "CAIF TTY transport driver"
-        depends on CAIF
+        depends on CAIF && TTY
         default n
         ---help---
         The CAIF TTY transport driver is a Line Discipline (ldisc)
diff --git a/drivers/net/caif/caif_serial.c b/drivers/net/caif/caif_serial.c
index 5de74e762021..666891a9a248 100644
--- a/drivers/net/caif/caif_serial.c
+++ b/drivers/net/caif/caif_serial.c
@@ -91,7 +91,7 @@ static inline void update_tty_status(struct ser_device *ser)
                 ser->tty->hw_stopped << 4 |
                 ser->tty->flow_stopped << 3 |
                 ser->tty->packet << 2 |
-                ser->tty->low_latency << 1 |
+                ser->tty->port->low_latency << 1 |
                 ser->tty->warned;
 }
 static inline void debugfs_init(struct ser_device *ser, struct tty_struct *tty)
diff --git a/drivers/net/can/Kconfig b/drivers/net/can/Kconfig
index 1cca19f1c490..9862b2e07644 100644
--- a/drivers/net/can/Kconfig
+++ b/drivers/net/can/Kconfig
@@ -11,6 +11,7 @@ config CAN_VCAN
 
 config CAN_SLCAN
         tristate "Serial / USB serial CAN Adaptors (slcan)"
+        depends on TTY
         ---help---
           CAN driver for several 'low cost' CAN interfaces that are attached
           via serial lines or via USB-to-serial adapters using the LAWICEL
diff --git a/drivers/net/hamradio/Kconfig b/drivers/net/hamradio/Kconfig
index 95dbcfdf131d..bf5e59687680 100644
--- a/drivers/net/hamradio/Kconfig
+++ b/drivers/net/hamradio/Kconfig
@@ -1,6 +1,6 @@
 config MKISS
         tristate "Serial port KISS driver"
-        depends on AX25
+        depends on AX25 && TTY
         select CRC16
         ---help---
           KISS is a protocol used for the exchange of data between a computer
@@ -18,7 +18,7 @@ config MKISS
 
 config 6PACK
         tristate "Serial port 6PACK driver"
-        depends on AX25
+        depends on AX25 && TTY
         ---help---
           6pack is a transmission protocol for the data exchange between your
           PC and your TNC (the Terminal Node Controller acts as a kind of
diff --git a/drivers/net/irda/Kconfig b/drivers/net/irda/Kconfig
index 59e9d9e1fd0f..2a30193d0d50 100644
--- a/drivers/net/irda/Kconfig
+++ b/drivers/net/irda/Kconfig
@@ -5,7 +5,7 @@ comment "SIR device drivers"
 
 config IRTTY_SIR
         tristate "IrTTY (uses Linux serial driver)"
-        depends on IRDA
+        depends on IRDA && TTY
         help
           Say Y here if you want to build support for the IrTTY line
           discipline.  To compile it as a module, choose M here: the module
diff --git a/drivers/net/irda/irtty-sir.c b/drivers/net/irda/irtty-sir.c
index 6e4d4b62c9a8..a41267197839 100644
--- a/drivers/net/irda/irtty-sir.c
+++ b/drivers/net/irda/irtty-sir.c
@@ -210,7 +210,7 @@ static int irtty_do_write(struct sir_dev *dev, const unsigned char *ptr, size_t
  *    been received, which can now be decapsulated and delivered for
  *    further processing 
  *
- * calling context depends on underlying driver and tty->low_latency!
+ * calling context depends on underlying driver and tty->port->low_latency!
  * for example (low_latency: 1 / 0):
  * serial.c:    uart-interrupt / softint
  * usbserial:   urb-complete-interrupt / softint
diff --git a/drivers/net/ppp/Kconfig b/drivers/net/ppp/Kconfig
index 278dea0c4c98..1373c6d7278d 100644
--- a/drivers/net/ppp/Kconfig
+++ b/drivers/net/ppp/Kconfig
@@ -147,6 +147,7 @@ config PPPOL2TP
           Support for PPP-over-L2TP socket family. L2TP is a protocol
           used by ISPs and enterprises to tunnel PPP traffic over UDP
           tunnels. L2TP is replacing PPTP for VPN uses.
+if TTY
 
 config PPP_ASYNC
         tristate "PPP support for async serial ports"
@@ -172,4 +173,6 @@ config PPP_SYNC_TTY
 
           To compile this driver as a module, choose M here.
 
+endif # TTY
+
 endif # PPP
diff --git a/drivers/net/slip/Kconfig b/drivers/net/slip/Kconfig
index 211b160e4e9c..48e68714eef3 100644
--- a/drivers/net/slip/Kconfig
+++ b/drivers/net/slip/Kconfig
@@ -4,6 +4,7 @@
 
 config SLIP
         tristate "SLIP (serial line) support"
+        depends on TTY
         ---help---
           Say Y if you intend to use SLIP or CSLIP (compressed SLIP) to
           connect to your Internet service provider or to connect to some
diff --git a/drivers/net/usb/Kconfig b/drivers/net/usb/Kconfig
index 3a44a5d7bf9e..da92ed3797aa 100644
--- a/drivers/net/usb/Kconfig
+++ b/drivers/net/usb/Kconfig
@@ -443,7 +443,7 @@ config USB_NET_QMI_WWAN
 
 config USB_HSO
         tristate "Option USB High Speed Mobile Devices"
-        depends on USB && RFKILL
+        depends on USB && RFKILL && TTY
         default n
         help
           Choose this option if you have an Option HSDPA/HSUPA card.
@@ -491,7 +491,7 @@ config USB_SIERRA_NET
 
 config USB_VL600
         tristate "LG VL600 modem dongle"
-        depends on USB_NET_CDCETHER
+        depends on USB_NET_CDCETHER && TTY
         select USB_ACM
         help
           Select this if you want to use an LG Electronics 4G/LTE usb modem
diff --git a/drivers/net/usb/hso.c b/drivers/net/usb/hso.c
index 41e5dfb5ee64..e2dd3249b6bd 100644
--- a/drivers/net/usb/hso.c
+++ b/drivers/net/usb/hso.c
@@ -2035,25 +2035,23 @@ static int put_rxbuf_data(struct urb *urb, struct hso_serial *serial)
         tty = tty_port_tty_get(&serial->port);
 
         /* Push data to tty */
-        if (tty) {
-                write_length_remaining = urb->actual_length -
-                        serial->curr_rx_urb_offset;
-                D1("data to push to tty");
-                while (write_length_remaining) {
-                        if (test_bit(TTY_THROTTLED, &tty->flags)) {
-                                tty_kref_put(tty);
-                                return -1;
-                        }
-                        curr_write_len =  tty_insert_flip_string
-                                (tty, urb->transfer_buffer +
-                                 serial->curr_rx_urb_offset,
-                                 write_length_remaining);
-                        serial->curr_rx_urb_offset += curr_write_len;
-                        write_length_remaining -= curr_write_len;
-                        tty_flip_buffer_push(tty);
+        write_length_remaining = urb->actual_length -
+                serial->curr_rx_urb_offset;
+        D1("data to push to tty");
+        while (write_length_remaining) {
+                if (tty && test_bit(TTY_THROTTLED, &tty->flags)) {
+                        tty_kref_put(tty);
+                        return -1;
                 }
-                tty_kref_put(tty);
+                curr_write_len = tty_insert_flip_string(&serial->port,
+                        urb->transfer_buffer + serial->curr_rx_urb_offset,
+                        write_length_remaining);
+                serial->curr_rx_urb_offset += curr_write_len;
+                write_length_remaining -= curr_write_len;
+                tty_flip_buffer_push(&serial->port);
         }
+        tty_kref_put(tty);
+
         if (write_length_remaining == 0) {
                 serial->curr_rx_urb_offset = 0;
                 serial->rx_urb_filled[hso_urb_to_index(serial, urb)] = 0;
diff --git a/drivers/net/wan/Kconfig b/drivers/net/wan/Kconfig
index 13daec88d918..94e234975c61 100644
--- a/drivers/net/wan/Kconfig
+++ b/drivers/net/wan/Kconfig
@@ -375,7 +375,7 @@ config LAPBETHER
 
 config X25_ASY
         tristate "X.25 async driver"
-        depends on LAPB && X25
+        depends on LAPB && X25 && TTY
         ---help---
           Send and receive X.25 frames over regular asynchronous serial
           lines such as telephone lines equipped with ordinary modems.
diff --git a/drivers/parport/parport_serial.c b/drivers/parport/parport_serial.c
index ef6169adb845..1b8bdb7e9bf4 100644
--- a/drivers/parport/parport_serial.c
+++ b/drivers/parport/parport_serial.c
@@ -63,6 +63,7 @@ enum parport_pc_pci_cards {
         timedia_9079b,
         timedia_9079c,
         wch_ch353_2s1p,
+        sunix_2s1p,
 };
 
 /* each element directly indexed from enum list, above */
@@ -148,8 +149,12 @@ static struct parport_pc_pci cards[] = {
         /* timedia_9079b */             { 1, { { 2, 3 }, } },
         /* timedia_9079c */             { 1, { { 2, 3 }, } },
         /* wch_ch353_2s1p*/             { 1, { { 2, -1}, } },
+        /* sunix_2s1p */                { 1, { { 3, -1 }, } },
 };
 
+#define PCI_VENDOR_ID_SUNIX             0x1fd4
+#define PCI_DEVICE_ID_SUNIX_1999        0x1999
+
 static struct pci_device_id parport_serial_pci_tbl[] = {
         /* PCI cards */
         { PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_110L,
@@ -246,8 +251,18 @@ static struct pci_device_id parport_serial_pci_tbl[] = {
         { 0x1409, 0x7168, 0x1409, 0xb079, 0, 0, timedia_9079a },
         { 0x1409, 0x7168, 0x1409, 0xc079, 0, 0, timedia_9079b },
         { 0x1409, 0x7168, 0x1409, 0xd079, 0, 0, timedia_9079c },
+
         /* WCH CARDS */
         { 0x4348, 0x7053, 0x4348, 0x3253, 0, 0, wch_ch353_2s1p},
+
+        /*
+         * More SUNIX variations. At least one of these has part number
+         * '5079A but subdevice 0x102. That board reports 0x0708 as
+         * its PCI Class.
+         */
+        { PCI_VENDOR_ID_SUNIX, PCI_DEVICE_ID_SUNIX_1999, PCI_VENDOR_ID_SUNIX,
+          0x0102, 0, 0, sunix_2s1p },
+
         { 0, } /* terminate list */
 };
 MODULE_DEVICE_TABLE(pci,parport_serial_pci_tbl);
@@ -470,6 +485,12 @@ static struct pciserial_board pci_parport_serial_boards[] = {
                 .base_baud      = 115200,
                 .uart_offset    = 8,
         },
+        [sunix_2s1p] = {
+                .flags          = FL_BASE0|FL_BASE_BARS,
+                .num_ports      = 2,
+                .base_baud      = 921600,
+                .uart_offset    = 8,
+        },
 };
 
 struct parport_serial_private {
diff --git a/drivers/pps/clients/Kconfig b/drivers/pps/clients/Kconfig
index 445197d4a8c4..6efd9b60d8ff 100644
--- a/drivers/pps/clients/Kconfig
+++ b/drivers/pps/clients/Kconfig
@@ -17,7 +17,7 @@ config PPS_CLIENT_KTIMER
 
 config PPS_CLIENT_LDISC
         tristate "PPS line discipline"
-        depends on PPS
+        depends on PPS && TTY
         help
           If you say yes here you get support for a PPS source connected
           with the CD (Carrier Detect) pin of your serial port.
diff --git a/drivers/pps/clients/pps-ldisc.c b/drivers/pps/clients/pps-ldisc.c
index 79451f2dea6a..73bd3bb4d93b 100644
--- a/drivers/pps/clients/pps-ldisc.c
+++ b/drivers/pps/clients/pps-ldisc.c
@@ -25,18 +25,27 @@
 #include <linux/serial_core.h>
 #include <linux/tty.h>
 #include <linux/pps_kernel.h>
+#include <linux/bug.h>
 
 #define PPS_TTY_MAGIC           0x0001
 
-static void pps_tty_dcd_change(struct tty_struct *tty, unsigned int status,
-                                struct pps_event_time *ts)
+static void pps_tty_dcd_change(struct tty_struct *tty, unsigned int status)
 {
-        struct pps_device *pps = (struct pps_device *)tty->disc_data;
+        struct pps_device *pps;
+        struct pps_event_time ts;
+
+        pps_get_ts(&ts);
 
-        BUG_ON(pps == NULL);
+        pps = pps_lookup_dev(tty);
+        /*
+         * This should never fail, but the ldisc locking is very
+         * convoluted, so don't crash just in case.
+         */
+        if (WARN_ON_ONCE(pps == NULL))
+                return;
 
         /* Now do the PPS event report */
-        pps_event(pps, ts, status ? PPS_CAPTUREASSERT :
+        pps_event(pps, &ts, status ? PPS_CAPTUREASSERT :
                         PPS_CAPTURECLEAR, NULL);
 
         dev_dbg(pps->dev, "PPS %s at %lu\n",
@@ -67,9 +76,9 @@ static int pps_tty_open(struct tty_struct *tty)
                 pr_err("cannot register PPS source \"%s\"\n", info.path);
                 return -ENOMEM;
         }
-        tty->disc_data = pps;
+        pps->lookup_cookie = tty;
 
-        /* Should open N_TTY ldisc too */
+        /* Now open the base class N_TTY ldisc */
         ret = alias_n_tty_open(tty);
         if (ret < 0) {
                 pr_err("cannot open tty ldisc \"%s\"\n", info.path);
@@ -81,7 +90,6 @@ static int pps_tty_open(struct tty_struct *tty)
         return 0;
 
 err_unregister:
-        tty->disc_data = NULL;
         pps_unregister_source(pps);
         return ret;
 }
@@ -90,11 +98,13 @@ static void (*alias_n_tty_close)(struct tty_struct *tty);
 
 static void pps_tty_close(struct tty_struct *tty)
 {
-        struct pps_device *pps = (struct pps_device *)tty->disc_data;
+        struct pps_device *pps = pps_lookup_dev(tty);
 
         alias_n_tty_close(tty);
 
-        tty->disc_data = NULL;
+        if (WARN_ON(!pps))
+                return;
+
         dev_info(pps->dev, "removed\n");
         pps_unregister_source(pps);
 }
diff --git a/drivers/pps/pps.c b/drivers/pps/pps.c
index 2420d5af0583..6437703eb10f 100644
--- a/drivers/pps/pps.c
+++ b/drivers/pps/pps.c
@@ -247,12 +247,15 @@ static int pps_cdev_open(struct inode *inode, struct file *file)
         struct pps_device *pps = container_of(inode->i_cdev,
                                                 struct pps_device, cdev);
         file->private_data = pps;
-
+        kobject_get(&pps->dev->kobj);
         return 0;
 }
 
 static int pps_cdev_release(struct inode *inode, struct file *file)
 {
+        struct pps_device *pps = container_of(inode->i_cdev,
+                                                struct pps_device, cdev);
+        kobject_put(&pps->dev->kobj);
         return 0;
 }
 
@@ -274,8 +277,10 @@ static void pps_device_destruct(struct device *dev)
 {
         struct pps_device *pps = dev_get_drvdata(dev);
 
-        /* release id here to protect others from using it while it's
-         * still in use */
+        cdev_del(&pps->cdev);
+
+        /* Now we can release the ID for re-use */
+        pr_debug("deallocating pps%d\n", pps->id);
         mutex_lock(&pps_idr_lock);
         idr_remove(&pps_idr, pps->id);
         mutex_unlock(&pps_idr_lock);
@@ -332,6 +337,7 @@ int pps_register_cdev(struct pps_device *pps)
                 goto del_cdev;
         }
 
+        /* Override the release function with our own */
         pps->dev->release = pps_device_destruct;
 
         pr_debug("source %s got cdev (%d:%d)\n", pps->info.name,
@@ -352,11 +358,44 @@ free_idr:
 
 void pps_unregister_cdev(struct pps_device *pps)
 {
+        pr_debug("unregistering pps%d\n", pps->id);
+        pps->lookup_cookie = NULL;
         device_destroy(pps_class, pps->dev->devt);
-        cdev_del(&pps->cdev);
 }
 
 /*
+ * Look up a pps device by magic cookie.
+ * The cookie is usually a pointer to some enclosing device, but this
+ * code doesn't care; you should never be dereferencing it.
+ *
+ * This is a bit of a kludge that is currently used only by the PPS
+ * serial line discipline.  It may need to be tweaked when a second user
+ * is found.
+ *
+ * There is no function interface for setting the lookup_cookie field.
+ * It's initialized to NULL when the pps device is created, and if a
+ * client wants to use it, just fill it in afterward.
+ *
+ * The cookie is automatically set to NULL in pps_unregister_source()
+ * so that it will not be used again, even if the pps device cannot
+ * be removed from the idr due to pending references holding the minor
+ * number in use.
+ */
+struct pps_device *pps_lookup_dev(void const *cookie)
+{
+        struct pps_device *pps;
+        unsigned id;
+
+        rcu_read_lock();
+        idr_for_each_entry(&pps_idr, pps, id)
+                if (cookie == pps->lookup_cookie)
+                        break;
+        rcu_read_unlock();
+        return pps;
+}
+EXPORT_SYMBOL(pps_lookup_dev);
+
+/*
  * Module stuff
  */
 
diff --git a/drivers/s390/char/Kconfig b/drivers/s390/char/Kconfig
index 2c9a776bd63c..71bf959732fe 100644
--- a/drivers/s390/char/Kconfig
+++ b/drivers/s390/char/Kconfig
@@ -11,7 +11,7 @@ config TN3270
 config TN3270_TTY
         def_tristate y
         prompt "Support for tty input/output on 3270 terminals"
-        depends on TN3270
+        depends on TN3270 && TTY
         help
           Include support for using an IBM 3270 terminal as a Linux tty.
 
@@ -33,7 +33,7 @@ config TN3270_CONSOLE
 config TN3215
         def_bool y
         prompt "Support for 3215 line mode terminal"
-        depends on CCW
+        depends on CCW && TTY
         help
           Include support for IBM 3215 line-mode terminals.
 
@@ -51,7 +51,7 @@ config CCW_CONSOLE
 config SCLP_TTY
         def_bool y
         prompt "Support for SCLP line mode terminal"
-        depends on S390
+        depends on S390 && TTY
         help
           Include support for IBM SCLP line-mode terminals.
 
@@ -66,7 +66,7 @@ config SCLP_CONSOLE
 config SCLP_VT220_TTY
         def_bool y
         prompt "Support for SCLP VT220-compatible terminal"
-        depends on S390
+        depends on S390 && TTY
         help
           Include support for an IBM SCLP VT220-compatible terminal.
 
diff --git a/drivers/s390/char/con3215.c b/drivers/s390/char/con3215.c
index 33b7141a182f..7b00fa634d40 100644
--- a/drivers/s390/char/con3215.c
+++ b/drivers/s390/char/con3215.c
@@ -412,8 +412,9 @@ static void raw3215_irq(struct ccw_device *cdev, unsigned long intparm,
                                 break;
 
                         case CTRLCHAR_CTRL:
-                                tty_insert_flip_char(tty, cchar, TTY_NORMAL);
-                                tty_flip_buffer_push(tty);
+                                tty_insert_flip_char(&raw->port, cchar,
+                                                TTY_NORMAL);
+                                tty_flip_buffer_push(&raw->port);
                                 break;
 
                         case CTRLCHAR_NONE:
@@ -425,8 +426,9 @@ static void raw3215_irq(struct ccw_device *cdev, unsigned long intparm,
                                         count++;
                                 } else
                                         count -= 2;
-                                tty_insert_flip_string(tty, raw->inbuf, count);
-                                tty_flip_buffer_push(tty);
+                                tty_insert_flip_string(&raw->port, raw->inbuf,
+                                                count);
+                                tty_flip_buffer_push(&raw->port);
                                 break;
                         }
                 } else if (req->type == RAW3215_WRITE) {
@@ -970,7 +972,7 @@ static int tty3215_open(struct tty_struct *tty, struct file * filp)
 
         tty_port_tty_set(&raw->port, tty);
 
-        tty->low_latency = 0;  /* don't use bottom half for pushing chars */
+        raw->port.low_latency = 0; /* don't use bottom half for pushing chars */
         /*
          * Start up 3215 device
          */
diff --git a/drivers/s390/char/keyboard.h b/drivers/s390/char/keyboard.h
index d0ae2be58191..a31f339211d5 100644
--- a/drivers/s390/char/keyboard.h
+++ b/drivers/s390/char/keyboard.h
@@ -43,22 +43,14 @@ int kbd_ioctl(struct kbd_data *, unsigned int, unsigned long);
 static inline void
 kbd_put_queue(struct tty_port *port, int ch)
 {
-        struct tty_struct *tty = tty_port_tty_get(port);
-        if (!tty)
-                return;
-        tty_insert_flip_char(tty, ch, 0);
-        tty_schedule_flip(tty);
-        tty_kref_put(tty);
+        tty_insert_flip_char(port, ch, 0);
+        tty_schedule_flip(port);
 }
 
 static inline void
 kbd_puts_queue(struct tty_port *port, char *cp)
 {
-        struct tty_struct *tty = tty_port_tty_get(port);
-        if (!tty)
-                return;
         while (*cp)
-                tty_insert_flip_char(tty, *cp++, 0);
-        tty_schedule_flip(tty);
-        tty_kref_put(tty);
+                tty_insert_flip_char(port, *cp++, 0);
+        tty_schedule_flip(port);
 }
diff --git a/drivers/s390/char/sclp_tty.c b/drivers/s390/char/sclp_tty.c
index 877fbc37c1e7..14b4cb8abcc8 100644
--- a/drivers/s390/char/sclp_tty.c
+++ b/drivers/s390/char/sclp_tty.c
@@ -65,7 +65,7 @@ sclp_tty_open(struct tty_struct *tty, struct file *filp)
 {
         tty_port_tty_set(&sclp_port, tty);
         tty->driver_data = NULL;
-        tty->low_latency = 0;
+        sclp_port.low_latency = 0;
         return 0;
 }
 
@@ -342,8 +342,8 @@ sclp_tty_input(unsigned char* buf, unsigned int count)
         case CTRLCHAR_SYSRQ:
                 break;
         case CTRLCHAR_CTRL:
-                tty_insert_flip_char(tty, cchar, TTY_NORMAL);
-                tty_flip_buffer_push(tty);
+                tty_insert_flip_char(&sclp_port, cchar, TTY_NORMAL);
+                tty_flip_buffer_push(&sclp_port);
                 break;
         case CTRLCHAR_NONE:
                 /* send (normal) input to line discipline */
@@ -351,11 +351,11 @@ sclp_tty_input(unsigned char* buf, unsigned int count)
                     (strncmp((const char *) buf + count - 2, "^n", 2) &&
                      strncmp((const char *) buf + count - 2, "\252n", 2))) {
                         /* add the auto \n */
-                        tty_insert_flip_string(tty, buf, count);
-                        tty_insert_flip_char(tty, '\n', TTY_NORMAL);
+                        tty_insert_flip_string(&sclp_port, buf, count);
+                        tty_insert_flip_char(&sclp_port, '\n', TTY_NORMAL);
                 } else
-                        tty_insert_flip_string(tty, buf, count - 2);
-                tty_flip_buffer_push(tty);
+                        tty_insert_flip_string(&sclp_port, buf, count - 2);
+                tty_flip_buffer_push(&sclp_port);
                 break;
         }
         tty_kref_put(tty);
diff --git a/drivers/s390/char/sclp_vt220.c b/drivers/s390/char/sclp_vt220.c
index effcc8756e0a..6c92f62623be 100644
--- a/drivers/s390/char/sclp_vt220.c
+++ b/drivers/s390/char/sclp_vt220.c
@@ -461,14 +461,9 @@ sclp_vt220_write(struct tty_struct *tty, const unsigned char *buf, int count)
 static void
 sclp_vt220_receiver_fn(struct evbuf_header *evbuf)
 {
-        struct tty_struct *tty = tty_port_tty_get(&sclp_vt220_port);
         char *buffer;
         unsigned int count;
 
-        /* Ignore input if device is not open */
-        if (tty == NULL)
-                return;
-
         buffer = (char *) ((addr_t) evbuf + sizeof(struct evbuf_header));
         count = evbuf->length - sizeof(struct evbuf_header);
 
@@ -480,11 +475,10 @@ sclp_vt220_receiver_fn(struct evbuf_header *evbuf)
                 /* Send input to line discipline */
                 buffer++;
                 count--;
-                tty_insert_flip_string(tty, buffer, count);
-                tty_flip_buffer_push(tty);
+                tty_insert_flip_string(&sclp_vt220_port, buffer, count);
+                tty_flip_buffer_push(&sclp_vt220_port);
                 break;
         }
-        tty_kref_put(tty);
 }
 
 /*
@@ -495,7 +489,7 @@ sclp_vt220_open(struct tty_struct *tty, struct file *filp)
 {
         if (tty->count == 1) {
                 tty_port_tty_set(&sclp_vt220_port, tty);
-                tty->low_latency = 0;
+                sclp_vt220_port.low_latency = 0;
                 if (!tty->winsize.ws_row && !tty->winsize.ws_col) {
                         tty->winsize.ws_row = 24;
                         tty->winsize.ws_col = 80;
diff --git a/drivers/s390/char/tty3270.c b/drivers/s390/char/tty3270.c
index 43ea0593bdb0..3860e796b65f 100644
--- a/drivers/s390/char/tty3270.c
+++ b/drivers/s390/char/tty3270.c
@@ -860,7 +860,7 @@ static int tty3270_install(struct tty_driver *driver, struct tty_struct *tty)
                 tty->driver_data = tp;
                 tty->winsize.ws_row = tp->view.rows - 2;
                 tty->winsize.ws_col = tp->view.cols;
-                tty->low_latency = 0;
+                tp->port.low_latency = 0;
                 /* why to reassign? */
                 tty_port_tty_set(&tp->port, tty);
                 tp->inattr = TF_INPUT;
@@ -893,7 +893,7 @@ static int tty3270_install(struct tty_driver *driver, struct tty_struct *tty)
         }
 
         tty_port_tty_set(&tp->port, tty);
-        tty->low_latency = 0;
+        tp->port.low_latency = 0;
         tty->winsize.ws_row = tp->view.rows - 2;
         tty->winsize.ws_col = tp->view.cols;
 
diff --git a/drivers/staging/ccg/Kconfig b/drivers/staging/ccg/Kconfig
index 8997a8c757aa..7ed5bc6caadb 100644
--- a/drivers/staging/ccg/Kconfig
+++ b/drivers/staging/ccg/Kconfig
@@ -2,7 +2,7 @@ if USB_GADGET
 
 config USB_G_CCG
         tristate "Configurable Composite Gadget (STAGING)"
-        depends on STAGING && BLOCK && NET && !USB_ZERO && !USB_ZERO_HNPTEST && !USB_AUDIO && !GADGET_UAC1 && !USB_ETH && !USB_ETH_RNDIS && !USB_ETH_EEM && !USB_G_NCM && !USB_GADGETFS && !USB_FUNCTIONFS && !USB_FUNCTIONFS_ETH && !USB_FUNCTIONFS_RNDIS && !USB_FUNCTIONFS_GENERIC && !USB_FILE_STORAGE && !USB_FILE_STORAGE_TEST && !USB_MASS_STORAGE && !USB_G_SERIAL && !USB_MIDI_GADGET && !USB_G_PRINTER && !USB_CDC_COMPOSITE && !USB_G_NOKIA && !USB_G_ACM_MS && !USB_G_MULTI && !USB_G_MULTI_RNDIS && !USB_G_MULTI_CDC && !USB_G_HID && !USB_G_DBGP && !USB_G_WEBCAM
+        depends on STAGING && BLOCK && NET && !USB_ZERO && !USB_ZERO_HNPTEST && !USB_AUDIO && !GADGET_UAC1 && !USB_ETH && !USB_ETH_RNDIS && !USB_ETH_EEM && !USB_G_NCM && !USB_GADGETFS && !USB_FUNCTIONFS && !USB_FUNCTIONFS_ETH && !USB_FUNCTIONFS_RNDIS && !USB_FUNCTIONFS_GENERIC && !USB_FILE_STORAGE && !USB_FILE_STORAGE_TEST && !USB_MASS_STORAGE && !USB_G_SERIAL && !USB_MIDI_GADGET && !USB_G_PRINTER && !USB_CDC_COMPOSITE && !USB_G_NOKIA && !USB_G_ACM_MS && !USB_G_MULTI && !USB_G_MULTI_RNDIS && !USB_G_MULTI_CDC && !USB_G_HID && !USB_G_DBGP && !USB_G_WEBCAM && TTY
         help
           The Configurable Composite Gadget supports multiple USB
           functions: acm, mass storage, rndis and FunctionFS.
diff --git a/drivers/staging/ccg/u_serial.c b/drivers/staging/ccg/u_serial.c
index 373c40656b52..b10947ae0ac5 100644
--- a/drivers/staging/ccg/u_serial.c
+++ b/drivers/staging/ccg/u_serial.c
@@ -491,12 +491,8 @@ static void gs_rx_push(unsigned long _port)
 
                 req = list_first_entry(queue, struct usb_request, list);
 
-                /* discard data if tty was closed */
-                if (!tty)
-                        goto recycle;
-
                 /* leave data queued if tty was rx throttled */
-                if (test_bit(TTY_THROTTLED, &tty->flags))
+                if (tty && test_bit(TTY_THROTTLED, &tty->flags))
                         break;
 
                 switch (req->status) {
@@ -529,7 +525,7 @@ static void gs_rx_push(unsigned long _port)
                                 size -= n;
                         }
 
-                        count = tty_insert_flip_string(tty, packet, size);
+                        count = tty_insert_flip_string(&port->port, packet, size);
                         if (count)
                                 do_push = true;
                         if (count != size) {
@@ -542,7 +538,6 @@ static void gs_rx_push(unsigned long _port)
                         }
                         port->n_read = 0;
                 }
-recycle:
                 list_move(&req->list, &port->read_pool);
                 port->read_started--;
         }
@@ -550,8 +545,8 @@ recycle:
         /* Push from tty to ldisc; without low_latency set this is handled by
          * a workqueue, so we won't get callbacks and can hold port_lock
          */
-        if (tty && do_push)
-                tty_flip_buffer_push(tty);
+        if (do_push)
+                tty_flip_buffer_push(&port->port);
 
 
         /* We want our data queue to become empty ASAP, keeping data
diff --git a/drivers/staging/dgrp/Kconfig b/drivers/staging/dgrp/Kconfig
index 39f4bb65ec83..e4c41552923a 100644
--- a/drivers/staging/dgrp/Kconfig
+++ b/drivers/staging/dgrp/Kconfig
@@ -1,7 +1,7 @@
 config DGRP
        tristate "Digi Realport driver"
        default n
-       depends on SYSFS
+       depends on SYSFS && TTY
        ---help---
        Support for Digi Realport devices.  These devices allow you to
        access remote serial ports as if they are local tty devices.  This
diff --git a/drivers/staging/dgrp/dgrp_net_ops.c b/drivers/staging/dgrp/dgrp_net_ops.c
index 2d1bbfd5b67c..e6018823b9de 100644
--- a/drivers/staging/dgrp/dgrp_net_ops.c
+++ b/drivers/staging/dgrp/dgrp_net_ops.c
@@ -37,6 +37,7 @@
 #include <linux/proc_fs.h>
 #include <linux/types.h>
 #include <linux/string.h>
+#include <linux/device.h>
 #include <linux/tty.h>
 #include <linux/tty_flip.h>
 #include <linux/spinlock.h>
@@ -211,7 +212,7 @@ static void dgrp_input(struct ch_struct *ch)
         data_len = (ch->ch_rin - ch->ch_rout) & RBUF_MASK;
 
         /* len is the amount of data we are going to transfer here */
-        len = tty_buffer_request_room(tty, data_len);
+        len = tty_buffer_request_room(&ch->port, data_len);
 
         /* Check DPA flow control */
         if ((nd->nd_dpa_debug) &&
@@ -232,9 +233,9 @@ static void dgrp_input(struct ch_struct *ch)
                     (nd->nd_dpa_port == PORT_NUM(MINOR(tty_devnum(tty)))))
                         dgrp_dpa_data(nd, 1, myflipbuf, len);
 
-                tty_insert_flip_string_flags(tty, myflipbuf,
+                tty_insert_flip_string_flags(&ch->port, myflipbuf,
                                              myflipflagbuf, len);
-                tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(&ch->port);
 
                 ch->ch_rxcount += len;
         }
@@ -2956,9 +2957,9 @@ check_query:
                             I_BRKINT(ch->ch_tun.un_tty) &&
                             !(I_IGNBRK(ch->ch_tun.un_tty))) {
 
-                                tty_buffer_request_room(ch->ch_tun.un_tty, 1);
-                                tty_insert_flip_char(ch->ch_tun.un_tty, 0, TTY_BREAK);
-                                tty_flip_buffer_push(ch->ch_tun.un_tty);
+                                tty_buffer_request_room(&ch->port, 1);
+                                tty_insert_flip_char(&ch->port, 0, TTY_BREAK);
+                                tty_flip_buffer_push(&ch->port);
 
                         }
 
diff --git a/drivers/staging/dgrp/dgrp_tty.c b/drivers/staging/dgrp/dgrp_tty.c
index 51d3ed3dca27..654f6010b473 100644
--- a/drivers/staging/dgrp/dgrp_tty.c
+++ b/drivers/staging/dgrp/dgrp_tty.c
@@ -39,6 +39,7 @@
 #include <linux/slab.h>
 #include <linux/tty.h>
 #include <linux/tty_flip.h>
+#include <linux/device.h>
 #include <linux/sched.h>
 #include <linux/uaccess.h>
 
diff --git a/drivers/staging/fwserial/Kconfig b/drivers/staging/fwserial/Kconfig
index b2f8331e4acf..a0812d99136f 100644
--- a/drivers/staging/fwserial/Kconfig
+++ b/drivers/staging/fwserial/Kconfig
@@ -1,6 +1,6 @@
 config FIREWIRE_SERIAL
        tristate "TTY over Firewire"
-       depends on FIREWIRE
+       depends on FIREWIRE && TTY
        help
           This enables TTY over IEEE 1394, providing high-speed serial
           connectivity to cabled peers. This driver implements a
diff --git a/drivers/staging/fwserial/fwserial.c b/drivers/staging/fwserial/fwserial.c
index 8859c75f16fa..5a6fb44f38a8 100644
--- a/drivers/staging/fwserial/fwserial.c
+++ b/drivers/staging/fwserial/fwserial.c
@@ -500,16 +500,11 @@ static void fwtty_do_hangup(struct work_struct *work)
 static void fwtty_emit_breaks(struct work_struct *work)
 {
         struct fwtty_port *port = to_port(to_delayed_work(work), emit_breaks);
-        struct tty_struct *tty;
         static const char buf[16];
         unsigned long now = jiffies;
         unsigned long elapsed = now - port->break_last;
         int n, t, c, brk = 0;
 
-        tty = tty_port_tty_get(&port->port);
-        if (!tty)
-                return;
-
         /* generate breaks at the line rate (but at least 1) */
         n = (elapsed * port->cps) / HZ + 1;
         port->break_last = now;
@@ -518,15 +513,14 @@ static void fwtty_emit_breaks(struct work_struct *work)
 
         while (n) {
                 t = min(n, 16);
-                c = tty_insert_flip_string_fixed_flag(tty, buf, TTY_BREAK, t);
+                c = tty_insert_flip_string_fixed_flag(&port->port, buf,
+                                TTY_BREAK, t);
                 n -= c;
                 brk += c;
                 if (c < t)
                         break;
         }
-        tty_flip_buffer_push(tty);
-
-        tty_kref_put(tty);
+        tty_flip_buffer_push(&port->port);
 
         if (port->mstatus & (UART_LSR_BI << 24))
                 schedule_delayed_work(&port->emit_breaks, FREQ_BREAKS);
@@ -540,13 +534,9 @@ static void fwtty_pushrx(struct work_struct *work)
         struct buffered_rx *buf, *next;
         int n, c = 0;
 
-        tty = tty_port_tty_get(&port->port);
-        if (!tty)
-                return;
-
         spin_lock_bh(&port->lock);
         list_for_each_entry_safe(buf, next, &port->buf_list, list) {
-                n = tty_insert_flip_string_fixed_flag(tty, buf->data,
+                n = tty_insert_flip_string_fixed_flag(&port->port, buf->data,
                                                       TTY_NORMAL, buf->n);
                 c += n;
                 port->buffered -= n;
@@ -555,7 +545,11 @@ static void fwtty_pushrx(struct work_struct *work)
                                 memmove(buf->data, buf->data + n, buf->n - n);
                                 buf->n -= n;
                         }
-                        __fwtty_throttle(port, tty);
+                        tty = tty_port_tty_get(&port->port);
+                        if (tty) {
+                                __fwtty_throttle(port, tty);
+                                tty_kref_put(tty);
+                        }
                         break;
                 } else {
                         list_del(&buf->list);
@@ -563,13 +557,11 @@ static void fwtty_pushrx(struct work_struct *work)
                 }
         }
         if (c > 0)
-                tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(&port->port);
 
         if (list_empty(&port->buf_list))
                 clear_bit(BUFFERING_RX, &port->flags);
         spin_unlock_bh(&port->lock);
-
-        tty_kref_put(tty);
 }
 
 static int fwtty_buffer_rx(struct fwtty_port *port, unsigned char *d, size_t n)
@@ -607,10 +599,6 @@ static int fwtty_rx(struct fwtty_port *port, unsigned char *data, size_t len)
         unsigned lsr;
         int err = 0;
 
-        tty = tty_port_tty_get(&port->port);
-        if (!tty)
-                return -ENOENT;
-
         fwtty_dbg(port, "%d", n);
         profile_size_distrib(port->stats.reads, n);
 
@@ -630,7 +618,7 @@ static int fwtty_rx(struct fwtty_port *port, unsigned char *data, size_t len)
 
         lsr &= port->status_mask;
         if (lsr & ~port->ignore_mask & UART_LSR_OE) {
-                if (!tty_insert_flip_char(tty, 0, TTY_OVERRUN)) {
+                if (!tty_insert_flip_char(&port->port, 0, TTY_OVERRUN)) {
                         err = -EIO;
                         goto out;
                 }
@@ -644,18 +632,23 @@ static int fwtty_rx(struct fwtty_port *port, unsigned char *data, size_t len)
         }
 
         if (!test_bit(BUFFERING_RX, &port->flags)) {
-                c = tty_insert_flip_string_fixed_flag(tty, data, TTY_NORMAL, n);
+                c = tty_insert_flip_string_fixed_flag(&port->port, data,
+                                TTY_NORMAL, n);
                 if (c > 0)
-                        tty_flip_buffer_push(tty);
+                        tty_flip_buffer_push(&port->port);
                 n -= c;
 
                 if (n) {
                         /* start buffering and throttling */
                         n -= fwtty_buffer_rx(port, &data[c], n);
 
-                        spin_lock_bh(&port->lock);
-                        __fwtty_throttle(port, tty);
-                        spin_unlock_bh(&port->lock);
+                        tty = tty_port_tty_get(&port->port);
+                        if (tty) {
+                                spin_lock_bh(&port->lock);
+                                __fwtty_throttle(port, tty);
+                                spin_unlock_bh(&port->lock);
+                                tty_kref_put(tty);
+                        }
                 }
         } else
                 n -= fwtty_buffer_rx(port, data, n);
@@ -666,8 +659,6 @@ static int fwtty_rx(struct fwtty_port *port, unsigned char *data, size_t len)
         }
 
 out:
-        tty_kref_put(tty);
-
         port->icount.rx += len;
         port->stats.lost += n;
         return err;
diff --git a/drivers/staging/sb105x/Kconfig b/drivers/staging/sb105x/Kconfig
index 1facad625554..245e7847a354 100644
--- a/drivers/staging/sb105x/Kconfig
+++ b/drivers/staging/sb105x/Kconfig
@@ -1,8 +1,7 @@
 config SB105X
         tristate "SystemBase PCI Multiport UART"
         select SERIAL_CORE
-        depends on PCI
-        depends on X86
+        depends on PCI && X86 && TTY && BROKEN
         help
           A driver for the SystemBase Multi-2/PCI serial card
 
diff --git a/drivers/staging/serqt_usb2/serqt_usb2.c b/drivers/staging/serqt_usb2/serqt_usb2.c
index 1b3e995d3a27..b1bb1a6abe81 100644
--- a/drivers/staging/serqt_usb2/serqt_usb2.c
+++ b/drivers/staging/serqt_usb2/serqt_usb2.c
@@ -255,12 +255,11 @@ static void ProcessModemStatus(struct quatech_port *qt_port,
         wake_up_interruptible(&qt_port->wait);
 }
 
-static void ProcessRxChar(struct tty_struct *tty, struct usb_serial_port *port,
-                                                unsigned char data)
+static void ProcessRxChar(struct usb_serial_port *port, unsigned char data)
 {
         struct urb *urb = port->read_urb;
         if (urb->actual_length)
-                tty_insert_flip_char(tty, data, TTY_NORMAL);
+                tty_insert_flip_char(&port->port, data, TTY_NORMAL);
 }
 
 static void qt_write_bulk_callback(struct urb *urb)
@@ -291,8 +290,7 @@ static void qt_interrupt_callback(struct urb *urb)
         /* FIXME */
 }
 
-static void qt_status_change_check(struct tty_struct *tty,
-                                   struct urb *urb,
+static void qt_status_change_check(struct urb *urb,
                                    struct quatech_port *qt_port,
                                    struct usb_serial_port *port)
 {
@@ -335,8 +333,8 @@ static void qt_status_change_check(struct tty_struct *tty,
                         case 0xff:
                                 dev_dbg(&port->dev, "No status sequence.\n");
 
-                                ProcessRxChar(tty, port, data[i]);
-                                ProcessRxChar(tty, port, data[i + 1]);
+                                ProcessRxChar(port, data[i]);
+                                ProcessRxChar(port, data[i + 1]);
 
                                 i += 2;
                                 break;
@@ -345,11 +343,11 @@ static void qt_status_change_check(struct tty_struct *tty,
                                 continue;
                 }
 
-                if (tty && urb->actual_length)
-                        tty_insert_flip_char(tty, data[i], TTY_NORMAL);
+                if (urb->actual_length)
+                        tty_insert_flip_char(&port->port, data[i], TTY_NORMAL);
 
         }
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&port->port);
 }
 
 static void qt_read_bulk_callback(struct urb *urb)
@@ -358,7 +356,6 @@ static void qt_read_bulk_callback(struct urb *urb)
         struct usb_serial_port *port = urb->context;
         struct usb_serial *serial = get_usb_serial(port, __func__);
         struct quatech_port *qt_port = qt_get_port_private(port);
-        struct tty_struct *tty;
         int result;
 
         if (urb->status) {
@@ -369,27 +366,23 @@ static void qt_read_bulk_callback(struct urb *urb)
                 return;
         }
 
-        tty = tty_port_tty_get(&port->port);
-        if (!tty)
-                return;
-
         dev_dbg(&port->dev,
                 "%s - port->RxHolding = %d\n", __func__, qt_port->RxHolding);
 
         if (port_paranoia_check(port, __func__) != 0) {
                 qt_port->ReadBulkStopped = 1;
-                goto exit;
+                return;
         }
 
         if (!serial)
-                goto exit;
+                return;
 
         if (qt_port->closePending == 1) {
                 /* Were closing , stop reading */
                 dev_dbg(&port->dev,
                         "%s - (qt_port->closepending == 1\n", __func__);
                 qt_port->ReadBulkStopped = 1;
-                goto exit;
+                return;
         }
 
         /*
@@ -399,7 +392,7 @@ static void qt_read_bulk_callback(struct urb *urb)
          */
         if (qt_port->RxHolding == 1) {
                 qt_port->ReadBulkStopped = 1;
-                goto exit;
+                return;
         }
 
         if (urb->status) {
@@ -408,11 +401,11 @@ static void qt_read_bulk_callback(struct urb *urb)
                 dev_dbg(&port->dev,
                         "%s - nonzero read bulk status received: %d\n",
                         __func__, urb->status);
-                goto exit;
+                return;
         }
 
         if (urb->actual_length)
-                qt_status_change_check(tty, urb, qt_port, port);
+                qt_status_change_check(urb, qt_port, port);
 
         /* Continue trying to always read  */
         usb_fill_bulk_urb(port->read_urb, serial->dev,
@@ -428,14 +421,12 @@ static void qt_read_bulk_callback(struct urb *urb)
                         __func__, result);
         else {
                 if (urb->actual_length) {
-                        tty_flip_buffer_push(tty);
-                        tty_schedule_flip(tty);
+                        tty_flip_buffer_push(&port->port);
+                        tty_schedule_flip(&port->port);
                 }
         }
 
         schedule_work(&port->work);
-exit:
-        tty_kref_put(tty);
 }
 
 /*
diff --git a/drivers/staging/speakup/selection.c b/drivers/staging/speakup/selection.c
index 822ac3d24788..775af26b9914 100644
--- a/drivers/staging/speakup/selection.c
+++ b/drivers/staging/speakup/selection.c
@@ -2,6 +2,7 @@
 #include <linux/consolemap.h>
 #include <linux/interrupt.h>
 #include <linux/sched.h>
+#include <linux/device.h> /* for dev_warn */
 #include <linux/selection.h>
 
 #include "speakup.h"
diff --git a/drivers/tty/Kconfig b/drivers/tty/Kconfig
index 0ecf22b6a38e..978db344bda0 100644
--- a/drivers/tty/Kconfig
+++ b/drivers/tty/Kconfig
@@ -1,3 +1,14 @@
+config TTY
+        bool "Enable TTY" if EXPERT
+        default y
+        ---help---
+          Allows you to remove TTY support which can save space, and
+          blocks features that require TTY from inclusion in the kernel.
+          TTY is required for any text terminals or serial port
+          communication. Most users should leave this enabled.
+
+if TTY
+
 config VT
         bool "Virtual terminal" if EXPERT
         depends on !S390 && !UML
@@ -388,3 +399,24 @@ config PPC_EARLY_DEBUG_EHV_BC_HANDLE
           If the number you specify is not a valid byte channel handle, then
           there simply will be no early console output.  This is true also
           if you don't boot under a hypervisor at all.
+
+config GOLDFISH_TTY
+        tristate "Goldfish TTY Driver"
+        depends on GOLDFISH
+        help
+          Console and system TTY driver for the Goldfish virtual platform.
+
+config DA_TTY
+        bool "DA TTY"
+        depends on METAG_DA
+        select SERIAL_NONSTANDARD
+        help
+          This enables a TTY on a Dash channel.
+
+config DA_CONSOLE
+        bool "DA Console"
+        depends on DA_TTY
+        help
+          This enables a console on a Dash channel.
+
+endif # TTY
diff --git a/drivers/tty/Makefile b/drivers/tty/Makefile
index 2953059530e4..6b78399bc7c9 100644
--- a/drivers/tty/Makefile
+++ b/drivers/tty/Makefile
@@ -1,4 +1,4 @@
-obj-y                           += tty_io.o n_tty.o tty_ioctl.o tty_ldisc.o \
+obj-$(CONFIG_TTY)               += tty_io.o n_tty.o tty_ioctl.o tty_ldisc.o \
                                    tty_buffer.o tty_port.o tty_mutex.o
 obj-$(CONFIG_LEGACY_PTYS)       += pty.o
 obj-$(CONFIG_UNIX98_PTYS)       += pty.o
@@ -27,5 +27,7 @@ obj-$(CONFIG_SYNCLINK_GT)	+= synclink_gt.o
 obj-$(CONFIG_SYNCLINKMP)        += synclinkmp.o
 obj-$(CONFIG_SYNCLINK)          += synclink.o
 obj-$(CONFIG_PPC_EPAPR_HV_BYTECHAN) += ehv_bytechan.o
+obj-$(CONFIG_GOLDFISH_TTY)      += goldfish.o
+obj-$(CONFIG_DA_TTY)            += metag_da.o
 
 obj-y += ipwireless/
diff --git a/drivers/tty/amiserial.c b/drivers/tty/amiserial.c
index 9d7d00cdfecb..fc700342d43f 100644
--- a/drivers/tty/amiserial.c
+++ b/drivers/tty/amiserial.c
@@ -251,7 +251,6 @@ static void receive_chars(struct serial_state *info)
 {
         int status;
         int serdatr;
-        struct tty_struct *tty = info->tport.tty;
         unsigned char ch, flag;
         struct  async_icount *icount;
         int oe = 0;
@@ -314,7 +313,7 @@ static void receive_chars(struct serial_state *info)
 #endif
             flag = TTY_BREAK;
             if (info->tport.flags & ASYNC_SAK)
-              do_SAK(tty);
+              do_SAK(info->tport.tty);
           } else if (status & UART_LSR_PE)
             flag = TTY_PARITY;
           else if (status & UART_LSR_FE)
@@ -328,10 +327,10 @@ static void receive_chars(struct serial_state *info)
              oe = 1;
           }
         }
-        tty_insert_flip_char(tty, ch, flag);
+        tty_insert_flip_char(&info->tport, ch, flag);
         if (oe == 1)
-                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
-        tty_flip_buffer_push(tty);
+                tty_insert_flip_char(&info->tport, 0, TTY_OVERRUN);
+        tty_flip_buffer_push(&info->tport);
 out:
         return;
 }
@@ -394,11 +393,6 @@ static void check_modem_status(struct serial_state *info)
                         icount->dsr++;
                 if (dstatus & SER_DCD) {
                         icount->dcd++;
-#ifdef CONFIG_HARD_PPS
-                        if ((port->flags & ASYNC_HARDPPS_CD) &&
-                            !(status & SER_DCD))
-                                hardpps();
-#endif
                 }
                 if (dstatus & SER_CTS)
                         icount->cts++;
@@ -1099,7 +1093,7 @@ static int set_serial_info(struct tty_struct *tty, struct serial_state *state,
         state->custom_divisor = new_serial.custom_divisor;
         port->close_delay = new_serial.close_delay * HZ/100;
         port->closing_wait = new_serial.closing_wait * HZ/100;
-        tty->low_latency = (port->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
+        port->low_latency = (port->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
 
 check_and_exit:
         if (port->flags & ASYNC_INITIALIZED) {
@@ -1528,7 +1522,7 @@ static int rs_open(struct tty_struct *tty, struct file * filp)
         if (serial_paranoia_check(info, tty->name, "rs_open"))
                 return -ENODEV;
 
-        tty->low_latency = (port->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
+        port->low_latency = (port->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
 
         retval = startup(tty, info);
         if (retval) {
diff --git a/drivers/tty/bfin_jtag_comm.c b/drivers/tty/bfin_jtag_comm.c
index 1cfcdbf1d0cc..a93a424873fa 100644
--- a/drivers/tty/bfin_jtag_comm.c
+++ b/drivers/tty/bfin_jtag_comm.c
@@ -95,18 +95,16 @@ bfin_jc_emudat_manager(void *arg)
 
                 /* if incoming data is ready, eat it */
                 if (bfin_read_DBGSTAT() & EMUDIF) {
-                        if (tty != NULL) {
-                                uint32_t emudat = bfin_read_emudat();
-                                if (inbound_len == 0) {
-                                        pr_debug("incoming length: 0x%08x\n", emudat);
-                                        inbound_len = emudat;
-                                } else {
-                                        size_t num_chars = (4 <= inbound_len ? 4 : inbound_len);
-                                        pr_debug("  incoming data: 0x%08x (pushing %zu)\n", emudat, num_chars);
-                                        inbound_len -= num_chars;
-                                        tty_insert_flip_string(tty, (unsigned char *)&emudat, num_chars);
-                                        tty_flip_buffer_push(tty);
-                                }
+                        uint32_t emudat = bfin_read_emudat();
+                        if (inbound_len == 0) {
+                                pr_debug("incoming length: 0x%08x\n", emudat);
+                                inbound_len = emudat;
+                        } else {
+                                size_t num_chars = (4 <= inbound_len ? 4 : inbound_len);
+                                pr_debug("  incoming data: 0x%08x (pushing %zu)\n", emudat, num_chars);
+                                inbound_len -= num_chars;
+                                tty_insert_flip_string(&port, (unsigned char *)&emudat, num_chars);
+                                tty_flip_buffer_push(&port);
                         }
                 }
 
diff --git a/drivers/tty/cyclades.c b/drivers/tty/cyclades.c
index b09c8d1f9a66..345bd0e0884e 100644
--- a/drivers/tty/cyclades.c
+++ b/drivers/tty/cyclades.c
@@ -441,7 +441,7 @@ static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
                 void __iomem *base_addr)
 {
         struct cyclades_port *info;
-        struct tty_struct *tty;
+        struct tty_port *port;
         int len, index = cinfo->bus_index;
         u8 ivr, save_xir, channel, save_car, data, char_count;
 
@@ -452,22 +452,11 @@ static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
         save_xir = readb(base_addr + (CyRIR << index));
         channel = save_xir & CyIRChannel;
         info = &cinfo->ports[channel + chip * 4];
+        port = &info->port;
         save_car = cyy_readb(info, CyCAR);
         cyy_writeb(info, CyCAR, save_xir);
         ivr = cyy_readb(info, CyRIVR) & CyIVRMask;
 
-        tty = tty_port_tty_get(&info->port);
-        /* if there is nowhere to put the data, discard it */
-        if (tty == NULL) {
-                if (ivr == CyIVRRxEx) { /* exception */
-                        data = cyy_readb(info, CyRDSR);
-                } else {        /* normal character reception */
-                        char_count = cyy_readb(info, CyRDCR);
-                        while (char_count--)
-                                data = cyy_readb(info, CyRDSR);
-                }
-                goto end;
-        }
         /* there is an open port for this data */
         if (ivr == CyIVRRxEx) { /* exception */
                 data = cyy_readb(info, CyRDSR);
@@ -484,40 +473,45 @@ static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
 
                 if (data & info->ignore_status_mask) {
                         info->icount.rx++;
-                        tty_kref_put(tty);
                         return;
                 }
-                if (tty_buffer_request_room(tty, 1)) {
+                if (tty_buffer_request_room(port, 1)) {
                         if (data & info->read_status_mask) {
                                 if (data & CyBREAK) {
-                                        tty_insert_flip_char(tty,
+                                        tty_insert_flip_char(port,
                                                 cyy_readb(info, CyRDSR),
                                                 TTY_BREAK);
                                         info->icount.rx++;
-                                        if (info->port.flags & ASYNC_SAK)
-                                                do_SAK(tty);
+                                        if (port->flags & ASYNC_SAK) {
+                                                struct tty_struct *tty =
+                                                        tty_port_tty_get(port);
+                                                if (tty) {
+                                                        do_SAK(tty);
+                                                        tty_kref_put(tty);
+                                                }
+                                        }
                                 } else if (data & CyFRAME) {
-                                        tty_insert_flip_char(tty,
+                                        tty_insert_flip_char(port,
                                                 cyy_readb(info, CyRDSR),
                                                 TTY_FRAME);
                                         info->icount.rx++;
                                         info->idle_stats.frame_errs++;
                                 } else if (data & CyPARITY) {
                                         /* Pieces of seven... */
-                                        tty_insert_flip_char(tty,
+                                        tty_insert_flip_char(port,
                                                 cyy_readb(info, CyRDSR),
                                                 TTY_PARITY);
                                         info->icount.rx++;
                                         info->idle_stats.parity_errs++;
                                 } else if (data & CyOVERRUN) {
-                                        tty_insert_flip_char(tty, 0,
+                                        tty_insert_flip_char(port, 0,
                                                         TTY_OVERRUN);
                                         info->icount.rx++;
                                         /* If the flip buffer itself is
                                            overflowing, we still lose
                                            the next incoming character.
                                          */
-                                        tty_insert_flip_char(tty,
+                                        tty_insert_flip_char(port,
                                                 cyy_readb(info, CyRDSR),
                                                 TTY_FRAME);
                                         info->icount.rx++;
@@ -527,12 +521,12 @@ static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
                                 /* } else if(data & CyTIMEOUT) { */
                                 /* } else if(data & CySPECHAR) { */
                                 } else {
-                                        tty_insert_flip_char(tty, 0,
+                                        tty_insert_flip_char(port, 0,
                                                         TTY_NORMAL);
                                         info->icount.rx++;
                                 }
                         } else {
-                                tty_insert_flip_char(tty, 0, TTY_NORMAL);
+                                tty_insert_flip_char(port, 0, TTY_NORMAL);
                                 info->icount.rx++;
                         }
                 } else {
@@ -552,10 +546,10 @@ static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
                         info->mon.char_max = char_count;
                 info->mon.char_last = char_count;
 #endif
-                len = tty_buffer_request_room(tty, char_count);
+                len = tty_buffer_request_room(port, char_count);
                 while (len--) {
                         data = cyy_readb(info, CyRDSR);
-                        tty_insert_flip_char(tty, data, TTY_NORMAL);
+                        tty_insert_flip_char(port, data, TTY_NORMAL);
                         info->idle_stats.recv_bytes++;
                         info->icount.rx++;
 #ifdef CY_16Y_HACK
@@ -564,9 +558,8 @@ static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
                 }
                 info->idle_stats.recv_idle = jiffies;
         }
-        tty_schedule_flip(tty);
-        tty_kref_put(tty);
-end:
+        tty_schedule_flip(port);
+
         /* end of service */
         cyy_writeb(info, CyRIR, save_xir & 0x3f);
         cyy_writeb(info, CyCAR, save_car);
@@ -924,10 +917,11 @@ cyz_issue_cmd(struct cyclades_card *cinfo,
         return 0;
 }                               /* cyz_issue_cmd */
 
-static void cyz_handle_rx(struct cyclades_port *info, struct tty_struct *tty)
+static void cyz_handle_rx(struct cyclades_port *info)
 {
         struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
         struct cyclades_card *cinfo = info->card;
+        struct tty_port *port = &info->port;
         unsigned int char_count;
         int len;
 #ifdef BLOCKMOVE
@@ -946,80 +940,77 @@ static void cyz_handle_rx(struct cyclades_port *info, struct tty_struct *tty)
         else
                 char_count = rx_put - rx_get + rx_bufsize;
 
-        if (char_count) {
+        if (!char_count)
+                return;
+
 #ifdef CY_ENABLE_MONITORING
-                info->mon.int_count++;
-                info->mon.char_count += char_count;
-                if (char_count > info->mon.char_max)
-                        info->mon.char_max = char_count;
-                info->mon.char_last = char_count;
+        info->mon.int_count++;
+        info->mon.char_count += char_count;
+        if (char_count > info->mon.char_max)
+                info->mon.char_max = char_count;
+        info->mon.char_last = char_count;
 #endif
-                if (tty == NULL) {
-                        /* flush received characters */
-                        new_rx_get = (new_rx_get + char_count) &
-                                        (rx_bufsize - 1);
-                        info->rflush_count++;
-                } else {
+
 #ifdef BLOCKMOVE
-                /* we'd like to use memcpy(t, f, n) and memset(s, c, count)
-                   for performance, but because of buffer boundaries, there
-                   may be several steps to the operation */
-                        while (1) {
-                                len = tty_prepare_flip_string(tty, &buf,
-                                                char_count);
-                                if (!len)
-                                        break;
+        /* we'd like to use memcpy(t, f, n) and memset(s, c, count)
+           for performance, but because of buffer boundaries, there
+           may be several steps to the operation */
+        while (1) {
+                len = tty_prepare_flip_string(port, &buf,
+                                char_count);
+                if (!len)
+                        break;
 
-                                len = min_t(unsigned int, min(len, char_count),
-                                                rx_bufsize - new_rx_get);
+                len = min_t(unsigned int, min(len, char_count),
+                                rx_bufsize - new_rx_get);
 
-                                memcpy_fromio(buf, cinfo->base_addr +
-                                                rx_bufaddr + new_rx_get, len);
+                memcpy_fromio(buf, cinfo->base_addr +
+                                rx_bufaddr + new_rx_get, len);
 
-                                new_rx_get = (new_rx_get + len) &
-                                                (rx_bufsize - 1);
-                                char_count -= len;
-                                info->icount.rx += len;
-                                info->idle_stats.recv_bytes += len;
-                        }
+                new_rx_get = (new_rx_get + len) &
+                                (rx_bufsize - 1);
+                char_count -= len;
+                info->icount.rx += len;
+                info->idle_stats.recv_bytes += len;
+        }
 #else
-                        len = tty_buffer_request_room(tty, char_count);
-                        while (len--) {
-                                data = readb(cinfo->base_addr + rx_bufaddr +
-                                                new_rx_get);
-                                new_rx_get = (new_rx_get + 1) &
-                                                        (rx_bufsize - 1);
-                                tty_insert_flip_char(tty, data, TTY_NORMAL);
-                                info->idle_stats.recv_bytes++;
-                                info->icount.rx++;
-                        }
+        len = tty_buffer_request_room(port, char_count);
+        while (len--) {
+                data = readb(cinfo->base_addr + rx_bufaddr +
+                                new_rx_get);
+                new_rx_get = (new_rx_get + 1) &
+                                        (rx_bufsize - 1);
+                tty_insert_flip_char(port, data, TTY_NORMAL);
+                info->idle_stats.recv_bytes++;
+                info->icount.rx++;
+        }
 #endif
 #ifdef CONFIG_CYZ_INTR
-                /* Recalculate the number of chars in the RX buffer and issue
-                   a cmd in case it's higher than the RX high water mark */
-                        rx_put = readl(&buf_ctrl->rx_put);
-                        if (rx_put >= rx_get)
-                                char_count = rx_put - rx_get;
-                        else
-                                char_count = rx_put - rx_get + rx_bufsize;
-                        if (char_count >= readl(&buf_ctrl->rx_threshold) &&
-                                        !timer_pending(&cyz_rx_full_timer[
-                                                        info->line]))
-                                mod_timer(&cyz_rx_full_timer[info->line],
-                                                jiffies + 1);
+        /* Recalculate the number of chars in the RX buffer and issue
+           a cmd in case it's higher than the RX high water mark */
+        rx_put = readl(&buf_ctrl->rx_put);
+        if (rx_put >= rx_get)
+                char_count = rx_put - rx_get;
+        else
+                char_count = rx_put - rx_get + rx_bufsize;
+        if (char_count >= readl(&buf_ctrl->rx_threshold) &&
+                        !timer_pending(&cyz_rx_full_timer[
+                                        info->line]))
+                mod_timer(&cyz_rx_full_timer[info->line],
+                                jiffies + 1);
 #endif
-                        info->idle_stats.recv_idle = jiffies;
-                        tty_schedule_flip(tty);
-                }
-                /* Update rx_get */
-                cy_writel(&buf_ctrl->rx_get, new_rx_get);
-        }
+        info->idle_stats.recv_idle = jiffies;
+        tty_schedule_flip(&info->port);
+
+        /* Update rx_get */
+        cy_writel(&buf_ctrl->rx_get, new_rx_get);
 }
 
-static void cyz_handle_tx(struct cyclades_port *info, struct tty_struct *tty)
+static void cyz_handle_tx(struct cyclades_port *info)
 {
         struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
         struct cyclades_card *cinfo = info->card;
+        struct tty_struct *tty;
         u8 data;
         unsigned int char_count;
 #ifdef BLOCKMOVE
@@ -1039,63 +1030,63 @@ static void cyz_handle_tx(struct cyclades_port *info, struct tty_struct *tty)
         else
                 char_count = tx_get - tx_put - 1;
 
-        if (char_count) {
-
-                if (tty == NULL)
-                        goto ztxdone;
+        if (!char_count)
+                return;
+                
+        tty = tty_port_tty_get(&info->port);
+        if (tty == NULL)
+                goto ztxdone;
 
-                if (info->x_char) {     /* send special char */
-                        data = info->x_char;
+        if (info->x_char) {     /* send special char */
+                data = info->x_char;
 
-                        cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
-                        tx_put = (tx_put + 1) & (tx_bufsize - 1);
-                        info->x_char = 0;
-                        char_count--;
-                        info->icount.tx++;
-                }
+                cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
+                tx_put = (tx_put + 1) & (tx_bufsize - 1);
+                info->x_char = 0;
+                char_count--;
+                info->icount.tx++;
+        }
 #ifdef BLOCKMOVE
-                while (0 < (small_count = min_t(unsigned int,
-                                tx_bufsize - tx_put, min_t(unsigned int,
-                                        (SERIAL_XMIT_SIZE - info->xmit_tail),
-                                        min_t(unsigned int, info->xmit_cnt,
-                                                char_count))))) {
-
-                        memcpy_toio((char *)(cinfo->base_addr + tx_bufaddr +
-                                        tx_put),
-                                        &info->port.xmit_buf[info->xmit_tail],
-                                        small_count);
-
-                        tx_put = (tx_put + small_count) & (tx_bufsize - 1);
-                        char_count -= small_count;
-                        info->icount.tx += small_count;
-                        info->xmit_cnt -= small_count;
-                        info->xmit_tail = (info->xmit_tail + small_count) &
-                                        (SERIAL_XMIT_SIZE - 1);
-                }
+        while (0 < (small_count = min_t(unsigned int,
+                        tx_bufsize - tx_put, min_t(unsigned int,
+                                (SERIAL_XMIT_SIZE - info->xmit_tail),
+                                min_t(unsigned int, info->xmit_cnt,
+                                        char_count))))) {
+
+                memcpy_toio((char *)(cinfo->base_addr + tx_bufaddr + tx_put),
+                                &info->port.xmit_buf[info->xmit_tail],
+                                small_count);
+
+                tx_put = (tx_put + small_count) & (tx_bufsize - 1);
+                char_count -= small_count;
+                info->icount.tx += small_count;
+                info->xmit_cnt -= small_count;
+                info->xmit_tail = (info->xmit_tail + small_count) &
+                                (SERIAL_XMIT_SIZE - 1);
+        }
 #else
-                while (info->xmit_cnt && char_count) {
-                        data = info->port.xmit_buf[info->xmit_tail];
-                        info->xmit_cnt--;
-                        info->xmit_tail = (info->xmit_tail + 1) &
-                                        (SERIAL_XMIT_SIZE - 1);
-
-                        cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
-                        tx_put = (tx_put + 1) & (tx_bufsize - 1);
-                        char_count--;
-                        info->icount.tx++;
-                }
+        while (info->xmit_cnt && char_count) {
+                data = info->port.xmit_buf[info->xmit_tail];
+                info->xmit_cnt--;
+                info->xmit_tail = (info->xmit_tail + 1) &
+                                (SERIAL_XMIT_SIZE - 1);
+
+                cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
+                tx_put = (tx_put + 1) & (tx_bufsize - 1);
+                char_count--;
+                info->icount.tx++;
+        }
 #endif
-                tty_wakeup(tty);
+        tty_wakeup(tty);
+        tty_kref_put(tty);
 ztxdone:
-                /* Update tx_put */
-                cy_writel(&buf_ctrl->tx_put, tx_put);
-        }
+        /* Update tx_put */
+        cy_writel(&buf_ctrl->tx_put, tx_put);
 }
 
 static void cyz_handle_cmd(struct cyclades_card *cinfo)
 {
         struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
-        struct tty_struct *tty;
         struct cyclades_port *info;
         __u32 channel, param, fw_ver;
         __u8 cmd;
@@ -1108,23 +1099,20 @@ static void cyz_handle_cmd(struct cyclades_card *cinfo)
                 special_count = 0;
                 delta_count = 0;
                 info = &cinfo->ports[channel];
-                tty = tty_port_tty_get(&info->port);
-                if (tty == NULL)
-                        continue;
 
                 switch (cmd) {
                 case C_CM_PR_ERROR:
-                        tty_insert_flip_char(tty, 0, TTY_PARITY);
+                        tty_insert_flip_char(&info->port, 0, TTY_PARITY);
                         info->icount.rx++;
                         special_count++;
                         break;
                 case C_CM_FR_ERROR:
-                        tty_insert_flip_char(tty, 0, TTY_FRAME);
+                        tty_insert_flip_char(&info->port, 0, TTY_FRAME);
                         info->icount.rx++;
                         special_count++;
                         break;
                 case C_CM_RXBRK:
-                        tty_insert_flip_char(tty, 0, TTY_BREAK);
+                        tty_insert_flip_char(&info->port, 0, TTY_BREAK);
                         info->icount.rx++;
                         special_count++;
                         break;
@@ -1136,8 +1124,14 @@ static void cyz_handle_cmd(struct cyclades_card *cinfo)
                                         readl(&info->u.cyz.ch_ctrl->rs_status);
                                 if (dcd & C_RS_DCD)
                                         wake_up_interruptible(&info->port.open_wait);
-                                else
-                                        tty_hangup(tty);
+                                else {
+                                        struct tty_struct *tty;
+                                        tty = tty_port_tty_get(&info->port);
+                                        if (tty) {
+                                                tty_hangup(tty);
+                                                tty_kref_put(tty);
+                                        }
+                                }
                         }
                         break;
                 case C_CM_MCTS:
@@ -1166,7 +1160,7 @@ static void cyz_handle_cmd(struct cyclades_card *cinfo)
                         printk(KERN_DEBUG "cyz_interrupt: rcvd intr, card %d, "
                                         "port %ld\n", info->card, channel);
 #endif
-                        cyz_handle_rx(info, tty);
+                        cyz_handle_rx(info);
                         break;
                 case C_CM_TXBEMPTY:
                 case C_CM_TXLOWWM:
@@ -1176,7 +1170,7 @@ static void cyz_handle_cmd(struct cyclades_card *cinfo)
                         printk(KERN_DEBUG "cyz_interrupt: xmit intr, card %d, "
                                         "port %ld\n", info->card, channel);
 #endif
-                        cyz_handle_tx(info, tty);
+                        cyz_handle_tx(info);
                         break;
 #endif                          /* CONFIG_CYZ_INTR */
                 case C_CM_FATAL:
@@ -1188,8 +1182,7 @@ static void cyz_handle_cmd(struct cyclades_card *cinfo)
                 if (delta_count)
                         wake_up_interruptible(&info->port.delta_msr_wait);
                 if (special_count)
-                        tty_schedule_flip(tty);
-                tty_kref_put(tty);
+                        tty_schedule_flip(&info->port);
         }
 }
 
@@ -1255,17 +1248,11 @@ static void cyz_poll(unsigned long arg)
                 cyz_handle_cmd(cinfo);
 
                 for (port = 0; port < cinfo->nports; port++) {
-                        struct tty_struct *tty;
-
                         info = &cinfo->ports[port];
-                        tty = tty_port_tty_get(&info->port);
-                        /* OK to pass NULL to the handle functions below.
-                           They need to drop the data in that case. */
 
                         if (!info->throttle)
-                                cyz_handle_rx(info, tty);
-                        cyz_handle_tx(info, tty);
-                        tty_kref_put(tty);
+                                cyz_handle_rx(info);
+                        cyz_handle_tx(info);
                 }
                 /* poll every 'cyz_polling_cycle' period */
                 expires = jiffies + cyz_polling_cycle;
diff --git a/drivers/tty/ehv_bytechan.c b/drivers/tty/ehv_bytechan.c
index c117d775a22f..ed92622b8949 100644
--- a/drivers/tty/ehv_bytechan.c
+++ b/drivers/tty/ehv_bytechan.c
@@ -371,22 +371,17 @@ console_initcall(ehv_bc_console_init);
 static irqreturn_t ehv_bc_tty_rx_isr(int irq, void *data)
 {
         struct ehv_bc_data *bc = data;
-        struct tty_struct *ttys = tty_port_tty_get(&bc->port);
         unsigned int rx_count, tx_count, len;
         int count;
         char buffer[EV_BYTE_CHANNEL_MAX_BYTES];
         int ret;
 
-        /* ttys could be NULL during a hangup */
-        if (!ttys)
-                return IRQ_HANDLED;
-
         /* Find out how much data needs to be read, and then ask the TTY layer
          * if it can handle that much.  We want to ensure that every byte we
          * read from the byte channel will be accepted by the TTY layer.
          */
         ev_byte_channel_poll(bc->handle, &rx_count, &tx_count);
-        count = tty_buffer_request_room(ttys, rx_count);
+        count = tty_buffer_request_room(&bc->port, rx_count);
 
         /* 'count' is the maximum amount of data the TTY layer can accept at
          * this time.  However, during testing, I was never able to get 'count'
@@ -407,7 +402,7 @@ static irqreturn_t ehv_bc_tty_rx_isr(int irq, void *data)
                  */
 
                 /* Pass the received data to the tty layer. */
-                ret = tty_insert_flip_string(ttys, buffer, len);
+                ret = tty_insert_flip_string(&bc->port, buffer, len);
 
                 /* 'ret' is the number of bytes that the TTY layer accepted.
                  * If it's not equal to 'len', then it means the buffer is
@@ -422,9 +417,7 @@ static irqreturn_t ehv_bc_tty_rx_isr(int irq, void *data)
         }
 
         /* Tell the tty layer that we're done. */
-        tty_flip_buffer_push(ttys);
-
-        tty_kref_put(ttys);
+        tty_flip_buffer_push(&bc->port);
 
         return IRQ_HANDLED;
 }
diff --git a/drivers/tty/goldfish.c b/drivers/tty/goldfish.c
new file mode 100644
index 000000000000..f17d2e4ee2ca
--- /dev/null
+++ b/drivers/tty/goldfish.c
@@ -0,0 +1,328 @@
+/*
+ * Copyright (C) 2007 Google, Inc.
+ * Copyright (C) 2012 Intel, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/console.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+#include <linux/slab.h>
+#include <linux/io.h>
+#include <linux/module.h>
+
+enum {
+        GOLDFISH_TTY_PUT_CHAR       = 0x00,
+        GOLDFISH_TTY_BYTES_READY    = 0x04,
+        GOLDFISH_TTY_CMD            = 0x08,
+
+        GOLDFISH_TTY_DATA_PTR       = 0x10,
+        GOLDFISH_TTY_DATA_LEN       = 0x14,
+
+        GOLDFISH_TTY_CMD_INT_DISABLE    = 0,
+        GOLDFISH_TTY_CMD_INT_ENABLE     = 1,
+        GOLDFISH_TTY_CMD_WRITE_BUFFER   = 2,
+        GOLDFISH_TTY_CMD_READ_BUFFER    = 3,
+};
+
+struct goldfish_tty {
+        struct tty_port port;
+        spinlock_t lock;
+        void __iomem *base;
+        u32 irq;
+        int opencount;
+        struct console console;
+};
+
+static DEFINE_MUTEX(goldfish_tty_lock);
+static struct tty_driver *goldfish_tty_driver;
+static u32 goldfish_tty_line_count = 8;
+static u32 goldfish_tty_current_line_count;
+static struct goldfish_tty *goldfish_ttys;
+
+static void goldfish_tty_do_write(int line, const char *buf, unsigned count)
+{
+        unsigned long irq_flags;
+        struct goldfish_tty *qtty = &goldfish_ttys[line];
+        void __iomem *base = qtty->base;
+        spin_lock_irqsave(&qtty->lock, irq_flags);
+        writel((u32)buf, base + GOLDFISH_TTY_DATA_PTR);
+        writel(count, base + GOLDFISH_TTY_DATA_LEN);
+        writel(GOLDFISH_TTY_CMD_WRITE_BUFFER, base + GOLDFISH_TTY_CMD);
+        spin_unlock_irqrestore(&qtty->lock, irq_flags);
+}
+
+static irqreturn_t goldfish_tty_interrupt(int irq, void *dev_id)
+{
+        struct platform_device *pdev = dev_id;
+        struct goldfish_tty *qtty = &goldfish_ttys[pdev->id];
+        void __iomem *base = qtty->base;
+        unsigned long irq_flags;
+        unsigned char *buf;
+        u32 count;
+
+        count = readl(base + GOLDFISH_TTY_BYTES_READY);
+        if(count == 0)
+                return IRQ_NONE;
+
+        count = tty_prepare_flip_string(&qtty->port, &buf, count);
+        spin_lock_irqsave(&qtty->lock, irq_flags);
+        writel((u32)buf, base + GOLDFISH_TTY_DATA_PTR);
+        writel(count, base + GOLDFISH_TTY_DATA_LEN);
+        writel(GOLDFISH_TTY_CMD_READ_BUFFER, base + GOLDFISH_TTY_CMD);
+        spin_unlock_irqrestore(&qtty->lock, irq_flags);
+        tty_schedule_flip(&qtty->port);
+        return IRQ_HANDLED;
+}
+
+static int goldfish_tty_activate(struct tty_port *port, struct tty_struct *tty)
+{
+        struct goldfish_tty *qtty = container_of(port, struct goldfish_tty, port);
+        writel(GOLDFISH_TTY_CMD_INT_ENABLE, qtty->base + GOLDFISH_TTY_CMD);
+        return 0;
+}
+
+static void goldfish_tty_shutdown(struct tty_port *port)
+{
+        struct goldfish_tty *qtty = container_of(port, struct goldfish_tty, port);
+        writel(GOLDFISH_TTY_CMD_INT_DISABLE, qtty->base + GOLDFISH_TTY_CMD);
+}
+
+static int goldfish_tty_open(struct tty_struct * tty, struct file * filp)
+{
+        struct goldfish_tty *qtty = &goldfish_ttys[tty->index];
+        return tty_port_open(&qtty->port, tty, filp);
+}
+
+static void goldfish_tty_close(struct tty_struct * tty, struct file * filp)
+{
+        tty_port_close(tty->port, tty, filp);
+}
+
+static void goldfish_tty_hangup(struct tty_struct *tty)
+{
+        tty_port_hangup(tty->port);
+}
+
+static int goldfish_tty_write(struct tty_struct * tty, const unsigned char *buf, int count)
+{
+        goldfish_tty_do_write(tty->index, buf, count);
+        return count;
+}
+
+static int goldfish_tty_write_room(struct tty_struct *tty)
+{
+        return 0x10000;
+}
+
+static int goldfish_tty_chars_in_buffer(struct tty_struct *tty)
+{
+        struct goldfish_tty *qtty = &goldfish_ttys[tty->index];
+        void __iomem *base = qtty->base;
+        return readl(base + GOLDFISH_TTY_BYTES_READY);
+}
+
+static void goldfish_tty_console_write(struct console *co, const char *b, unsigned count)
+{
+        goldfish_tty_do_write(co->index, b, count);
+}
+
+static struct tty_driver *goldfish_tty_console_device(struct console *c, int *index)
+{
+        *index = c->index;
+        return goldfish_tty_driver;
+}
+
+static int goldfish_tty_console_setup(struct console *co, char *options)
+{
+        if((unsigned)co->index > goldfish_tty_line_count)
+                return -ENODEV;
+        if(goldfish_ttys[co->index].base == 0)
+                return -ENODEV;
+        return 0;
+}
+
+static struct tty_port_operations goldfish_port_ops = {
+        .activate = goldfish_tty_activate,
+        .shutdown = goldfish_tty_shutdown
+};
+
+static struct tty_operations goldfish_tty_ops = {
+        .open = goldfish_tty_open,
+        .close = goldfish_tty_close,
+        .hangup = goldfish_tty_hangup,
+        .write = goldfish_tty_write,
+        .write_room = goldfish_tty_write_room,
+        .chars_in_buffer = goldfish_tty_chars_in_buffer,
+};
+
+static int goldfish_tty_create_driver(void)
+{
+        int ret;
+        struct tty_driver *tty;
+
+        goldfish_ttys = kzalloc(sizeof(*goldfish_ttys) * goldfish_tty_line_count, GFP_KERNEL);
+        if(goldfish_ttys == NULL) {
+                ret = -ENOMEM;
+                goto err_alloc_goldfish_ttys_failed;
+        }
+        tty = alloc_tty_driver(goldfish_tty_line_count);
+        if(tty == NULL) {
+                ret = -ENOMEM;
+                goto err_alloc_tty_driver_failed;
+        }
+        tty->driver_name = "goldfish";
+        tty->name = "ttyGF";
+        tty->type = TTY_DRIVER_TYPE_SERIAL;
+        tty->subtype = SERIAL_TYPE_NORMAL;
+        tty->init_termios = tty_std_termios;
+        tty->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
+        tty_set_operations(tty, &goldfish_tty_ops);
+        ret = tty_register_driver(tty);
+        if(ret)
+                goto err_tty_register_driver_failed;
+
+        goldfish_tty_driver = tty;
+        return 0;
+
+err_tty_register_driver_failed:
+        put_tty_driver(tty);
+err_alloc_tty_driver_failed:
+        kfree(goldfish_ttys);
+        goldfish_ttys = NULL;
+err_alloc_goldfish_ttys_failed:
+        return ret;
+}
+
+static void goldfish_tty_delete_driver(void)
+{
+        tty_unregister_driver(goldfish_tty_driver);
+        put_tty_driver(goldfish_tty_driver);
+        goldfish_tty_driver = NULL;
+        kfree(goldfish_ttys);
+        goldfish_ttys = NULL;
+}
+
+static int goldfish_tty_probe(struct platform_device *pdev)
+{
+        struct goldfish_tty *qtty;
+        int ret = -EINVAL;
+        int i;
+        struct resource *r;
+        struct device *ttydev;
+        void __iomem *base;
+        u32 irq;
+
+        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if(r == NULL)
+                return -EINVAL;
+
+        base = ioremap(r->start, 0x1000);
+        if (base == NULL)
+                pr_err("goldfish_tty: unable to remap base\n");
+
+        r = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if(r == NULL)
+                goto err_unmap;
+
+        irq = r->start;
+
+        if(pdev->id >= goldfish_tty_line_count)
+                goto err_unmap;
+
+        mutex_lock(&goldfish_tty_lock);
+        if(goldfish_tty_current_line_count == 0) {
+                ret = goldfish_tty_create_driver();
+                if(ret)
+                        goto err_create_driver_failed;
+        }
+        goldfish_tty_current_line_count++;
+
+        qtty = &goldfish_ttys[pdev->id];
+        spin_lock_init(&qtty->lock);
+        tty_port_init(&qtty->port);
+        qtty->port.ops = &goldfish_port_ops;
+        qtty->base = base;
+        qtty->irq = irq;
+
+        writel(GOLDFISH_TTY_CMD_INT_DISABLE, base + GOLDFISH_TTY_CMD);
+
+        ret = request_irq(irq, goldfish_tty_interrupt, IRQF_SHARED, "goldfish_tty", pdev);
+        if(ret)
+                goto err_request_irq_failed;
+
+
+        ttydev = tty_port_register_device(&qtty->port, goldfish_tty_driver,
+                                                        pdev->id, &pdev->dev);
+        if(IS_ERR(ttydev)) {
+                ret = PTR_ERR(ttydev);
+                goto err_tty_register_device_failed;
+        }
+
+        strcpy(qtty->console.name, "ttyGF");
+        qtty->console.write = goldfish_tty_console_write;
+        qtty->console.device = goldfish_tty_console_device;
+        qtty->console.setup = goldfish_tty_console_setup;
+        qtty->console.flags = CON_PRINTBUFFER;
+        qtty->console.index = pdev->id;
+        register_console(&qtty->console);
+
+        mutex_unlock(&goldfish_tty_lock);
+        return 0;
+
+        tty_unregister_device(goldfish_tty_driver, i);
+err_tty_register_device_failed:
+        free_irq(irq, pdev);
+err_request_irq_failed:
+        goldfish_tty_current_line_count--;
+        if(goldfish_tty_current_line_count == 0)
+                goldfish_tty_delete_driver();
+err_create_driver_failed:
+        mutex_unlock(&goldfish_tty_lock);
+err_unmap:
+        iounmap(base);
+        return ret;
+}
+
+static int goldfish_tty_remove(struct platform_device *pdev)
+{
+        struct goldfish_tty *qtty;
+
+        mutex_lock(&goldfish_tty_lock);
+
+        qtty = &goldfish_ttys[pdev->id];
+        unregister_console(&qtty->console);
+        tty_unregister_device(goldfish_tty_driver, pdev->id);
+        iounmap(qtty->base);
+        qtty->base = 0;
+        free_irq(qtty->irq, pdev);
+        goldfish_tty_current_line_count--;
+        if(goldfish_tty_current_line_count == 0)
+                goldfish_tty_delete_driver();
+        mutex_unlock(&goldfish_tty_lock);
+        return 0;
+}
+
+static struct platform_driver goldfish_tty_platform_driver = {
+        .probe = goldfish_tty_probe,
+        .remove = goldfish_tty_remove,
+        .driver = {
+                .name = "goldfish_tty"
+        }
+};
+
+module_platform_driver(goldfish_tty_platform_driver);
+
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/tty/hvc/Kconfig b/drivers/tty/hvc/Kconfig
index f47b734c6a7a..8902f9b4df71 100644
--- a/drivers/tty/hvc/Kconfig
+++ b/drivers/tty/hvc/Kconfig
@@ -1,3 +1,5 @@
+if TTY
+
 config HVC_DRIVER
         bool
         help
@@ -119,3 +121,4 @@ config HVCS
           which will also be compiled when this driver is built as a
           module.
 
+endif # TTY
diff --git a/drivers/tty/hvc/hvc_console.c b/drivers/tty/hvc/hvc_console.c
index 13ee53bd0bf6..eb255e807c06 100644
--- a/drivers/tty/hvc/hvc_console.c
+++ b/drivers/tty/hvc/hvc_console.c
@@ -629,7 +629,7 @@ int hvc_poll(struct hvc_struct *hp)
 
         /* Read data if any */
         for (;;) {
-                int count = tty_buffer_request_room(tty, N_INBUF);
+                int count = tty_buffer_request_room(&hp->port, N_INBUF);
 
                 /* If flip is full, just reschedule a later read */
                 if (count == 0) {
@@ -672,7 +672,7 @@ int hvc_poll(struct hvc_struct *hp)
                                 }
                         }
 #endif /* CONFIG_MAGIC_SYSRQ */
-                        tty_insert_flip_char(tty, buf[i], 0);
+                        tty_insert_flip_char(&hp->port, buf[i], 0);
                 }
 
                 read_total += n;
@@ -691,7 +691,7 @@ int hvc_poll(struct hvc_struct *hp)
                    a minimum for performance. */
                 timeout = MIN_TIMEOUT;
 
-                tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(&hp->port);
         }
         tty_kref_put(tty);
 
diff --git a/drivers/tty/hvc/hvcs.c b/drivers/tty/hvc/hvcs.c
index 877635733952..1956593ee89d 100644
--- a/drivers/tty/hvc/hvcs.c
+++ b/drivers/tty/hvc/hvcs.c
@@ -609,11 +609,11 @@ static int hvcs_io(struct hvcs_struct *hvcsd)
         /* remove the read masks */
         hvcsd->todo_mask &= ~(HVCS_READ_MASK);
 
-        if (tty_buffer_request_room(tty, HVCS_BUFF_LEN) >= HVCS_BUFF_LEN) {
+        if (tty_buffer_request_room(&hvcsd->port, HVCS_BUFF_LEN) >= HVCS_BUFF_LEN) {
                 got = hvc_get_chars(unit_address,
                                 &buf[0],
                                 HVCS_BUFF_LEN);
-                tty_insert_flip_string(tty, buf, got);
+                tty_insert_flip_string(&hvcsd->port, buf, got);
         }
 
         /* Give the TTY time to process the data we just sent. */
@@ -623,7 +623,7 @@ static int hvcs_io(struct hvcs_struct *hvcsd)
         spin_unlock_irqrestore(&hvcsd->lock, flags);
         /* This is synch because tty->low_latency == 1 */
         if(got)
-                tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(&hvcsd->port);
 
         if (!got) {
                 /* Do this _after_ the flip_buffer_push */
diff --git a/drivers/tty/hvc/hvsi.c b/drivers/tty/hvc/hvsi.c
index 68357a6e4de9..ef95a154854a 100644
--- a/drivers/tty/hvc/hvsi.c
+++ b/drivers/tty/hvc/hvsi.c
@@ -329,8 +329,7 @@ static void hvsi_recv_query(struct hvsi_struct *hp, uint8_t *packet)
         }
 }
 
-static void hvsi_insert_chars(struct hvsi_struct *hp, struct tty_struct *tty,
-                const char *buf, int len)
+static void hvsi_insert_chars(struct hvsi_struct *hp, const char *buf, int len)
 {
         int i;
 
@@ -346,7 +345,7 @@ static void hvsi_insert_chars(struct hvsi_struct *hp, struct tty_struct *tty,
                         continue;
                 }
 #endif /* CONFIG_MAGIC_SYSRQ */
-                tty_insert_flip_char(tty, c, 0);
+                tty_insert_flip_char(&hp->port, c, 0);
         }
 }
 
@@ -359,8 +358,7 @@ static void hvsi_insert_chars(struct hvsi_struct *hp, struct tty_struct *tty,
  * revisited.
  */
 #define TTY_THRESHOLD_THROTTLE 128
-static bool hvsi_recv_data(struct hvsi_struct *hp, struct tty_struct *tty,
-                const uint8_t *packet)
+static bool hvsi_recv_data(struct hvsi_struct *hp, const uint8_t *packet)
 {
         const struct hvsi_header *header = (const struct hvsi_header *)packet;
         const uint8_t *data = packet + sizeof(struct hvsi_header);
@@ -377,7 +375,7 @@ static bool hvsi_recv_data(struct hvsi_struct *hp, struct tty_struct *tty,
                 datalen = TTY_THRESHOLD_THROTTLE;
         }
 
-        hvsi_insert_chars(hp, tty, data, datalen);
+        hvsi_insert_chars(hp, data, datalen);
 
         if (overflow > 0) {
                 /*
@@ -438,9 +436,7 @@ static int hvsi_load_chunk(struct hvsi_struct *hp, struct tty_struct *tty,
                         case VS_DATA_PACKET_HEADER:
                                 if (!is_open(hp))
                                         break;
-                                if (tty == NULL)
-                                        break; /* no tty buffer to put data in */
-                                flip = hvsi_recv_data(hp, tty, packet);
+                                flip = hvsi_recv_data(hp, packet);
                                 break;
                         case VS_CONTROL_PACKET_HEADER:
                                 hvsi_recv_control(hp, packet, tty, handshake);
@@ -469,17 +465,17 @@ static int hvsi_load_chunk(struct hvsi_struct *hp, struct tty_struct *tty,
         compact_inbuf(hp, packet);
 
         if (flip)
-                tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(&hp->port);
 
         return 1;
 }
 
-static void hvsi_send_overflow(struct hvsi_struct *hp, struct tty_struct *tty)
+static void hvsi_send_overflow(struct hvsi_struct *hp)
 {
         pr_debug("%s: delivering %i bytes overflow\n", __func__,
                         hp->n_throttle);
 
-        hvsi_insert_chars(hp, tty, hp->throttle_buf, hp->n_throttle);
+        hvsi_insert_chars(hp, hp->throttle_buf, hp->n_throttle);
         hp->n_throttle = 0;
 }
 
@@ -514,8 +510,8 @@ static irqreturn_t hvsi_interrupt(int irq, void *arg)
         if (tty && hp->n_throttle && !test_bit(TTY_THROTTLED, &tty->flags)) {
                 /* we weren't hung up and we weren't throttled, so we can
                  * deliver the rest now */
-                hvsi_send_overflow(hp, tty);
-                tty_flip_buffer_push(tty);
+                hvsi_send_overflow(hp);
+                tty_flip_buffer_push(&hp->port);
         }
         spin_unlock_irqrestore(&hp->lock, flags);
 
@@ -1001,8 +997,8 @@ static void hvsi_unthrottle(struct tty_struct *tty)
 
         spin_lock_irqsave(&hp->lock, flags);
         if (hp->n_throttle) {
-                hvsi_send_overflow(hp, tty);
-                tty_flip_buffer_push(tty);
+                hvsi_send_overflow(hp);
+                tty_flip_buffer_push(&hp->port);
         }
         spin_unlock_irqrestore(&hp->lock, flags);
 
@@ -1187,9 +1183,7 @@ static int __init hvsi_console_init(void)
         hvsi_wait = poll_for_state; /* no irqs yet; must poll */
 
         /* search device tree for vty nodes */
-        for (vty = of_find_compatible_node(NULL, "serial", "hvterm-protocol");
-                        vty != NULL;
-                        vty = of_find_compatible_node(vty, "serial", "hvterm-protocol")) {
+        for_each_compatible_node(vty, "serial", "hvterm-protocol") {
                 struct hvsi_struct *hp;
                 const uint32_t *vtermno, *irq;
 
diff --git a/drivers/tty/ipwireless/tty.c b/drivers/tty/ipwireless/tty.c
index 2cde13ddf9fc..8fd72ff9436e 100644
--- a/drivers/tty/ipwireless/tty.c
+++ b/drivers/tty/ipwireless/tty.c
@@ -106,7 +106,7 @@ static int ipw_open(struct tty_struct *linux_tty, struct file *filp)
 
         tty->port.tty = linux_tty;
         linux_tty->driver_data = tty;
-        linux_tty->low_latency = 1;
+        tty->port.low_latency = 1;
 
         if (tty->tty_type == TTYTYPE_MODEM)
                 ipwireless_ppp_open(tty->network);
@@ -160,15 +160,9 @@ static void ipw_close(struct tty_struct *linux_tty, struct file *filp)
 void ipwireless_tty_received(struct ipw_tty *tty, unsigned char *data,
                         unsigned int length)
 {
-        struct tty_struct *linux_tty;
         int work = 0;
 
         mutex_lock(&tty->ipw_tty_mutex);
-        linux_tty = tty->port.tty;
-        if (linux_tty == NULL) {
-                mutex_unlock(&tty->ipw_tty_mutex);
-                return;
-        }
 
         if (!tty->port.count) {
                 mutex_unlock(&tty->ipw_tty_mutex);
@@ -176,7 +170,7 @@ void ipwireless_tty_received(struct ipw_tty *tty, unsigned char *data,
         }
         mutex_unlock(&tty->ipw_tty_mutex);
 
-        work = tty_insert_flip_string(linux_tty, data, length);
+        work = tty_insert_flip_string(&tty->port, data, length);
 
         if (work != length)
                 printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME
@@ -187,7 +181,7 @@ void ipwireless_tty_received(struct ipw_tty *tty, unsigned char *data,
          * This may sleep if ->low_latency is set
          */
         if (work)
-                tty_flip_buffer_push(linux_tty);
+                tty_flip_buffer_push(&tty->port);
 }
 
 static void ipw_write_packet_sent_callback(void *callback_data,
diff --git a/drivers/tty/isicom.c b/drivers/tty/isicom.c
index 3205b2e9090b..858291ca889c 100644
--- a/drivers/tty/isicom.c
+++ b/drivers/tty/isicom.c
@@ -634,10 +634,10 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id)
                         break;
 
                 case 1: /* Received Break !!! */
-                        tty_insert_flip_char(tty, 0, TTY_BREAK);
+                        tty_insert_flip_char(&port->port, 0, TTY_BREAK);
                         if (port->port.flags & ASYNC_SAK)
                                 do_SAK(tty);
-                        tty_flip_buffer_push(tty);
+                        tty_flip_buffer_push(&port->port);
                         break;
 
                 case 2: /* Statistics            */
@@ -650,15 +650,15 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id)
                         break;
                 }
         } else {                                /* Data   Packet */
-
-                count = tty_prepare_flip_string(tty, &rp, byte_count & ~1);
+                count = tty_prepare_flip_string(&port->port, &rp,
+                                byte_count & ~1);
                 pr_debug("%s: Can rx %d of %d bytes.\n",
                          __func__, count, byte_count);
                 word_count = count >> 1;
                 insw(base, rp, word_count);
                 byte_count -= (word_count << 1);
                 if (count & 0x0001) {
-                        tty_insert_flip_char(tty,  inw(base) & 0xff,
+                        tty_insert_flip_char(&port->port, inw(base) & 0xff,
                                 TTY_NORMAL);
                         byte_count -= 2;
                 }
@@ -671,7 +671,7 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id)
                                 byte_count -= 2;
                         }
                 }
-                tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(&port->port);
         }
         outw(0x0000, base+0x04); /* enable interrupts */
         spin_unlock(&card->card_lock);
diff --git a/drivers/tty/metag_da.c b/drivers/tty/metag_da.c
new file mode 100644
index 000000000000..0e888621f484
--- /dev/null
+++ b/drivers/tty/metag_da.c
@@ -0,0 +1,677 @@
+/*
+ *  dashtty.c - tty driver for Dash channels interface.
+ *
+ *  Copyright (C) 2007,2008,2012 Imagination Technologies
+ *
+ * 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.
+ *
+ */
+
+#include <linux/atomic.h>
+#include <linux/completion.h>
+#include <linux/console.h>
+#include <linux/delay.h>
+#include <linux/export.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/kthread.h>
+#include <linux/mutex.h>
+#include <linux/sched.h>
+#include <linux/serial.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/string.h>
+#include <linux/timer.h>
+#include <linux/tty.h>
+#include <linux/tty_driver.h>
+#include <linux/tty_flip.h>
+#include <linux/uaccess.h>
+
+#include <asm/da.h>
+
+/* Channel error codes */
+#define CONAOK  0
+#define CONERR  1
+#define CONBAD  2
+#define CONPRM  3
+#define CONADR  4
+#define CONCNT  5
+#define CONCBF  6
+#define CONCBE  7
+#define CONBSY  8
+
+/* Default channel for the console */
+#define CONSOLE_CHANNEL      1
+
+#define NUM_TTY_CHANNELS     6
+
+/* Auto allocate */
+#define DA_TTY_MAJOR        0
+
+/* A speedy poll rate helps the userland debug process connection response.
+ * But, if you set it too high then no other userland processes get much
+ * of a look in.
+ */
+#define DA_TTY_POLL (HZ / 50)
+
+/*
+ * A short put delay improves latency but has a high throughput overhead
+ */
+#define DA_TTY_PUT_DELAY (HZ / 100)
+
+static atomic_t num_channels_need_poll = ATOMIC_INIT(0);
+
+static struct timer_list poll_timer;
+
+static struct tty_driver *channel_driver;
+
+static struct timer_list put_timer;
+static struct task_struct *dashtty_thread;
+
+#define RX_BUF_SIZE 1024
+
+enum {
+        INCHR = 1,
+        OUTCHR,
+        RDBUF,
+        WRBUF,
+        RDSTAT
+};
+
+/**
+ * struct dashtty_port - Wrapper struct for dashtty tty_port.
+ * @port:               TTY port data
+ * @rx_lock:            Lock for rx_buf.
+ *                      This protects between the poll timer and user context.
+ *                      It's also held during read SWITCH operations.
+ * @rx_buf:             Read buffer
+ * @xmit_lock:          Lock for xmit_*, and port.xmit_buf.
+ *                      This protects between user context and kernel thread.
+ *                      It's also held during write SWITCH operations.
+ * @xmit_cnt:           Size of xmit buffer contents
+ * @xmit_head:          Head of xmit buffer where data is written
+ * @xmit_tail:          Tail of xmit buffer where data is read
+ * @xmit_empty:         Completion for xmit buffer being empty
+ */
+struct dashtty_port {
+        struct tty_port          port;
+        spinlock_t               rx_lock;
+        void                    *rx_buf;
+        struct mutex             xmit_lock;
+        unsigned int             xmit_cnt;
+        unsigned int             xmit_head;
+        unsigned int             xmit_tail;
+        struct completion        xmit_empty;
+};
+
+static struct dashtty_port dashtty_ports[NUM_TTY_CHANNELS];
+
+static atomic_t dashtty_xmit_cnt = ATOMIC_INIT(0);
+static wait_queue_head_t dashtty_waitqueue;
+
+/*
+ * Low-level DA channel access routines
+ */
+static int chancall(int in_bios_function, int in_channel,
+                    int in_arg2, void *in_arg3,
+                    void *in_arg4)
+{
+        register int   bios_function asm("D1Ar1") = in_bios_function;
+        register int   channel       asm("D0Ar2") = in_channel;
+        register int   arg2          asm("D1Ar3") = in_arg2;
+        register void *arg3          asm("D0Ar4") = in_arg3;
+        register void *arg4          asm("D1Ar5") = in_arg4;
+        register int   bios_call     asm("D0Ar6") = 3;
+        register int   result        asm("D0Re0");
+
+        asm volatile (
+                "MSETL  [A0StP++], %6,%4,%2\n\t"
+                "ADD    A0StP, A0StP, #8\n\t"
+                "SWITCH #0x0C30208\n\t"
+                "GETD   %0, [A0StP+#-8]\n\t"
+                "SUB    A0StP, A0StP, #(4*6)+8\n\t"
+                : "=d" (result)   /* outs */
+                : "d" (bios_function),
+                  "d" (channel),
+                  "d" (arg2),
+                  "d" (arg3),
+                  "d" (arg4),
+                  "d" (bios_call) /* ins */
+                : "memory");
+
+        return result;
+}
+
+/*
+ * Attempts to fetch count bytes from channel and returns actual count.
+ */
+static int fetch_data(unsigned int channel)
+{
+        struct dashtty_port *dport = &dashtty_ports[channel];
+        int received = 0;
+
+        spin_lock_bh(&dport->rx_lock);
+        /* check the port isn't being shut down */
+        if (!dport->rx_buf)
+                goto unlock;
+        if (chancall(RDBUF, channel, RX_BUF_SIZE,
+                     (void *)dport->rx_buf, &received) == CONAOK) {
+                if (received) {
+                        int space;
+                        unsigned char *cbuf;
+
+                        space = tty_prepare_flip_string(&dport->port, &cbuf,
+                                                        received);
+
+                        if (space <= 0)
+                                goto unlock;
+
+                        memcpy(cbuf, dport->rx_buf, space);
+                        tty_flip_buffer_push(&dport->port);
+                }
+        }
+unlock:
+        spin_unlock_bh(&dport->rx_lock);
+
+        return received;
+}
+
+/**
+ * find_channel_to_poll() - Returns number of the next channel to poll.
+ * Returns:     The number of the next channel to poll, or -1 if none need
+ *              polling.
+ */
+static int find_channel_to_poll(void)
+{
+        static int last_polled_channel;
+        int last = last_polled_channel;
+        int chan;
+        struct dashtty_port *dport;
+
+        for (chan = last + 1; ; ++chan) {
+                if (chan >= NUM_TTY_CHANNELS)
+                        chan = 0;
+
+                dport = &dashtty_ports[chan];
+                if (dport->rx_buf) {
+                        last_polled_channel = chan;
+                        return chan;
+                }
+
+                if (chan == last)
+                        break;
+        }
+        return -1;
+}
+
+/**
+ * put_channel_data() - Write out a block of channel data.
+ * @chan:       DA channel number.
+ *
+ * Write a single block of data out to the debug adapter. If the circular buffer
+ * is wrapped then only the first block is written.
+ *
+ * Returns:     1 if the remote buffer was too full to accept data.
+ *              0 otherwise.
+ */
+static int put_channel_data(unsigned int chan)
+{
+        struct dashtty_port *dport;
+        struct tty_struct *tty;
+        int number_written;
+        unsigned int count = 0;
+
+        dport = &dashtty_ports[chan];
+        mutex_lock(&dport->xmit_lock);
+        if (dport->xmit_cnt) {
+                count = min((unsigned int)(SERIAL_XMIT_SIZE - dport->xmit_tail),
+                            dport->xmit_cnt);
+                chancall(WRBUF, chan, count,
+                         dport->port.xmit_buf + dport->xmit_tail,
+                         &number_written);
+                dport->xmit_cnt -= number_written;
+                if (!dport->xmit_cnt) {
+                        /* reset pointers to avoid wraps */
+                        dport->xmit_head = 0;
+                        dport->xmit_tail = 0;
+                        complete(&dport->xmit_empty);
+                } else {
+                        dport->xmit_tail += number_written;
+                        if (dport->xmit_tail >= SERIAL_XMIT_SIZE)
+                                dport->xmit_tail -= SERIAL_XMIT_SIZE;
+                }
+                atomic_sub(number_written, &dashtty_xmit_cnt);
+        }
+        mutex_unlock(&dport->xmit_lock);
+
+        /* if we've made more data available, wake up tty */
+        if (count && number_written) {
+                tty = tty_port_tty_get(&dport->port);
+                if (tty) {
+                        tty_wakeup(tty);
+                        tty_kref_put(tty);
+                }
+        }
+
+        /* did the write fail? */
+        return count && !number_written;
+}
+
+/**
+ * put_data() - Kernel thread to write out blocks of channel data to DA.
+ * @arg:        Unused.
+ *
+ * This kernel thread runs while @dashtty_xmit_cnt != 0, and loops over the
+ * channels to write out any buffered data. If any of the channels stall due to
+ * the remote buffer being full, a hold off happens to allow the debugger to
+ * drain the buffer.
+ */
+static int put_data(void *arg)
+{
+        unsigned int chan, stall;
+
+        __set_current_state(TASK_RUNNING);
+        while (!kthread_should_stop()) {
+                /*
+                 * For each channel see if there's anything to transmit in the
+                 * port's xmit_buf.
+                 */
+                stall = 0;
+                for (chan = 0; chan < NUM_TTY_CHANNELS; ++chan)
+                        stall += put_channel_data(chan);
+
+                /*
+                 * If some of the buffers are full, hold off for a short while
+                 * to allow them to empty.
+                 */
+                if (stall)
+                        msleep(25);
+
+                wait_event_interruptible(dashtty_waitqueue,
+                                         atomic_read(&dashtty_xmit_cnt));
+        }
+
+        return 0;
+}
+
+/*
+ *      This gets called every DA_TTY_POLL and polls the channels for data
+ */
+static void dashtty_timer(unsigned long ignored)
+{
+        int channel;
+
+        /* If there are no ports open do nothing and don't poll again. */
+        if (!atomic_read(&num_channels_need_poll))
+                return;
+
+        channel = find_channel_to_poll();
+
+        /* Did we find a channel to poll? */
+        if (channel >= 0)
+                fetch_data(channel);
+
+        mod_timer_pinned(&poll_timer, jiffies + DA_TTY_POLL);
+}
+
+static void add_poll_timer(struct timer_list *poll_timer)
+{
+        setup_timer(poll_timer, dashtty_timer, 0);
+        poll_timer->expires = jiffies + DA_TTY_POLL;
+
+        /*
+         * Always attach the timer to the boot CPU. The DA channels are per-CPU
+         * so all polling should be from a single CPU.
+         */
+        add_timer_on(poll_timer, 0);
+}
+
+static int dashtty_port_activate(struct tty_port *port, struct tty_struct *tty)
+{
+        struct dashtty_port *dport = container_of(port, struct dashtty_port,
+                                                  port);
+        void *rx_buf;
+
+        /* Allocate the buffer we use for writing data */
+        if (tty_port_alloc_xmit_buf(port) < 0)
+                goto err;
+
+        /* Allocate the buffer we use for reading data */
+        rx_buf = kzalloc(RX_BUF_SIZE, GFP_KERNEL);
+        if (!rx_buf)
+                goto err_free_xmit;
+
+        spin_lock_bh(&dport->rx_lock);
+        dport->rx_buf = rx_buf;
+        spin_unlock_bh(&dport->rx_lock);
+
+        /*
+         * Don't add the poll timer if we're opening a console. This
+         * avoids the overhead of polling the Dash but means it is not
+         * possible to have a login on /dev/console.
+         *
+         */
+        if (dport != &dashtty_ports[CONSOLE_CHANNEL])
+                if (atomic_inc_return(&num_channels_need_poll) == 1)
+                        add_poll_timer(&poll_timer);
+
+        return 0;
+err_free_xmit:
+        tty_port_free_xmit_buf(port);
+err:
+        return -ENOMEM;
+}
+
+static void dashtty_port_shutdown(struct tty_port *port)
+{
+        struct dashtty_port *dport = container_of(port, struct dashtty_port,
+                                                  port);
+        void *rx_buf;
+        unsigned int count;
+
+        /* stop reading */
+        if (dport != &dashtty_ports[CONSOLE_CHANNEL])
+                if (atomic_dec_and_test(&num_channels_need_poll))
+                        del_timer_sync(&poll_timer);
+
+        mutex_lock(&dport->xmit_lock);
+        count = dport->xmit_cnt;
+        mutex_unlock(&dport->xmit_lock);
+        if (count) {
+                /*
+                 * There's still data to write out, so wake and wait for the
+                 * writer thread to drain the buffer.
+                 */
+                del_timer(&put_timer);
+                wake_up_interruptible(&dashtty_waitqueue);
+                wait_for_completion(&dport->xmit_empty);
+        }
+
+        /* Null the read buffer (timer could still be running!) */
+        spin_lock_bh(&dport->rx_lock);
+        rx_buf = dport->rx_buf;
+        dport->rx_buf = NULL;
+        spin_unlock_bh(&dport->rx_lock);
+        /* Free the read buffer */
+        kfree(rx_buf);
+
+        /* Free the write buffer */
+        tty_port_free_xmit_buf(port);
+}
+
+static const struct tty_port_operations dashtty_port_ops = {
+        .activate       = dashtty_port_activate,
+        .shutdown       = dashtty_port_shutdown,
+};
+
+static int dashtty_install(struct tty_driver *driver, struct tty_struct *tty)
+{
+        return tty_port_install(&dashtty_ports[tty->index].port, driver, tty);
+}
+
+static int dashtty_open(struct tty_struct *tty, struct file *filp)
+{
+        return tty_port_open(tty->port, tty, filp);
+}
+
+static void dashtty_close(struct tty_struct *tty, struct file *filp)
+{
+        return tty_port_close(tty->port, tty, filp);
+}
+
+static void dashtty_hangup(struct tty_struct *tty)
+{
+        int channel;
+        struct dashtty_port *dport;
+
+        channel = tty->index;
+        dport = &dashtty_ports[channel];
+
+        /* drop any data in the xmit buffer */
+        mutex_lock(&dport->xmit_lock);
+        if (dport->xmit_cnt) {
+                atomic_sub(dport->xmit_cnt, &dashtty_xmit_cnt);
+                dport->xmit_cnt = 0;
+                dport->xmit_head = 0;
+                dport->xmit_tail = 0;
+                complete(&dport->xmit_empty);
+        }
+        mutex_unlock(&dport->xmit_lock);
+
+        tty_port_hangup(tty->port);
+}
+
+/**
+ * dashtty_put_timer() - Delayed wake up of kernel thread.
+ * @ignored:    unused
+ *
+ * This timer function wakes up the kernel thread if any data exists in the
+ * buffers. It is used to delay the expensive writeout until the writer has
+ * stopped writing.
+ */
+static void dashtty_put_timer(unsigned long ignored)
+{
+        if (atomic_read(&dashtty_xmit_cnt))
+                wake_up_interruptible(&dashtty_waitqueue);
+}
+
+static int dashtty_write(struct tty_struct *tty, const unsigned char *buf,
+                         int total)
+{
+        int channel, count, block;
+        struct dashtty_port *dport;
+
+        /* Determine the channel */
+        channel = tty->index;
+        dport = &dashtty_ports[channel];
+
+        /*
+         * Write to output buffer.
+         *
+         * The reason that we asynchronously write the buffer is because if we
+         * were to write the buffer synchronously then because DA channels are
+         * per-CPU the buffer would be written to the channel of whatever CPU
+         * we're running on.
+         *
+         * What we actually want to happen is have all input and output done on
+         * one CPU.
+         */
+        mutex_lock(&dport->xmit_lock);
+        /* work out how many bytes we can write to the xmit buffer */
+        total = min(total, (int)(SERIAL_XMIT_SIZE - dport->xmit_cnt));
+        atomic_add(total, &dashtty_xmit_cnt);
+        dport->xmit_cnt += total;
+        /* write the actual bytes (may need splitting if it wraps) */
+        for (count = total; count; count -= block) {
+                block = min(count, (int)(SERIAL_XMIT_SIZE - dport->xmit_head));
+                memcpy(dport->port.xmit_buf + dport->xmit_head, buf, block);
+                dport->xmit_head += block;
+                if (dport->xmit_head >= SERIAL_XMIT_SIZE)
+                        dport->xmit_head -= SERIAL_XMIT_SIZE;
+                buf += block;
+        }
+        count = dport->xmit_cnt;
+        /* xmit buffer no longer empty? */
+        if (count)
+                INIT_COMPLETION(dport->xmit_empty);
+        mutex_unlock(&dport->xmit_lock);
+
+        if (total) {
+                /*
+                 * If the buffer is full, wake up the kthread, otherwise allow
+                 * some more time for the buffer to fill up a bit before waking
+                 * it.
+                 */
+                if (count == SERIAL_XMIT_SIZE) {
+                        del_timer(&put_timer);
+                        wake_up_interruptible(&dashtty_waitqueue);
+                } else {
+                        mod_timer(&put_timer, jiffies + DA_TTY_PUT_DELAY);
+                }
+        }
+        return total;
+}
+
+static int dashtty_write_room(struct tty_struct *tty)
+{
+        struct dashtty_port *dport;
+        int channel;
+        int room;
+
+        channel = tty->index;
+        dport = &dashtty_ports[channel];
+
+        /* report the space in the xmit buffer */
+        mutex_lock(&dport->xmit_lock);
+        room = SERIAL_XMIT_SIZE - dport->xmit_cnt;
+        mutex_unlock(&dport->xmit_lock);
+
+        return room;
+}
+
+static int dashtty_chars_in_buffer(struct tty_struct *tty)
+{
+        struct dashtty_port *dport;
+        int channel;
+        int chars;
+
+        channel = tty->index;
+        dport = &dashtty_ports[channel];
+
+        /* report the number of bytes in the xmit buffer */
+        mutex_lock(&dport->xmit_lock);
+        chars = dport->xmit_cnt;
+        mutex_unlock(&dport->xmit_lock);
+
+        return chars;
+}
+
+static const struct tty_operations dashtty_ops = {
+        .install                = dashtty_install,
+        .open                   = dashtty_open,
+        .close                  = dashtty_close,
+        .hangup                 = dashtty_hangup,
+        .write                  = dashtty_write,
+        .write_room             = dashtty_write_room,
+        .chars_in_buffer        = dashtty_chars_in_buffer,
+};
+
+static int __init dashtty_init(void)
+{
+        int ret;
+        int nport;
+        struct dashtty_port *dport;
+
+        if (!metag_da_enabled())
+                return -ENODEV;
+
+        channel_driver = tty_alloc_driver(NUM_TTY_CHANNELS,
+                                          TTY_DRIVER_REAL_RAW);
+        if (IS_ERR(channel_driver))
+                return PTR_ERR(channel_driver);
+
+        channel_driver->driver_name = "metag_da";
+        channel_driver->name = "ttyDA";
+        channel_driver->major = DA_TTY_MAJOR;
+        channel_driver->minor_start = 0;
+        channel_driver->type = TTY_DRIVER_TYPE_SERIAL;
+        channel_driver->subtype = SERIAL_TYPE_NORMAL;
+        channel_driver->init_termios = tty_std_termios;
+        channel_driver->init_termios.c_cflag |= CLOCAL;
+
+        tty_set_operations(channel_driver, &dashtty_ops);
+        for (nport = 0; nport < NUM_TTY_CHANNELS; nport++) {
+                dport = &dashtty_ports[nport];
+                tty_port_init(&dport->port);
+                dport->port.ops = &dashtty_port_ops;
+                spin_lock_init(&dport->rx_lock);
+                mutex_init(&dport->xmit_lock);
+                /* the xmit buffer starts empty, i.e. completely written */
+                init_completion(&dport->xmit_empty);
+                complete(&dport->xmit_empty);
+        }
+
+        setup_timer(&put_timer, dashtty_put_timer, 0);
+
+        init_waitqueue_head(&dashtty_waitqueue);
+        dashtty_thread = kthread_create(put_data, NULL, "ttyDA");
+        if (IS_ERR(dashtty_thread)) {
+                pr_err("Couldn't create dashtty thread\n");
+                ret = PTR_ERR(dashtty_thread);
+                goto err_destroy_ports;
+        }
+        /*
+         * Bind the writer thread to the boot CPU so it can't migrate.
+         * DA channels are per-CPU and we want all channel I/O to be on a single
+         * predictable CPU.
+         */
+        kthread_bind(dashtty_thread, 0);
+        wake_up_process(dashtty_thread);
+
+        ret = tty_register_driver(channel_driver);
+
+        if (ret < 0) {
+                pr_err("Couldn't install dashtty driver: err %d\n",
+                       ret);
+                goto err_stop_kthread;
+        }
+
+        return 0;
+
+err_stop_kthread:
+        kthread_stop(dashtty_thread);
+err_destroy_ports:
+        for (nport = 0; nport < NUM_TTY_CHANNELS; nport++) {
+                dport = &dashtty_ports[nport];
+                tty_port_destroy(&dport->port);
+        }
+        put_tty_driver(channel_driver);
+        return ret;
+}
+
+static void dashtty_exit(void)
+{
+        int nport;
+        struct dashtty_port *dport;
+
+        del_timer_sync(&put_timer);
+        kthread_stop(dashtty_thread);
+        del_timer_sync(&poll_timer);
+        tty_unregister_driver(channel_driver);
+        for (nport = 0; nport < NUM_TTY_CHANNELS; nport++) {
+                dport = &dashtty_ports[nport];
+                tty_port_destroy(&dport->port);
+        }
+        put_tty_driver(channel_driver);
+}
+
+module_init(dashtty_init);
+module_exit(dashtty_exit);
+
+#ifdef CONFIG_DA_CONSOLE
+
+static void dash_console_write(struct console *co, const char *s,
+                               unsigned int count)
+{
+        int actually_written;
+
+        chancall(WRBUF, CONSOLE_CHANNEL, count, (void *)s, &actually_written);
+}
+
+static struct tty_driver *dash_console_device(struct console *c, int *index)
+{
+        *index = c->index;
+        return channel_driver;
+}
+
+struct console dash_console = {
+        .name = "ttyDA",
+        .write = dash_console_write,
+        .device = dash_console_device,
+        .flags = CON_PRINTBUFFER,
+        .index = 1,
+};
+
+#endif
diff --git a/drivers/tty/moxa.c b/drivers/tty/moxa.c
index f9d28503bdec..adeac255e526 100644
--- a/drivers/tty/moxa.c
+++ b/drivers/tty/moxa.c
@@ -1405,7 +1405,7 @@ static int moxa_poll_port(struct moxa_port *p, unsigned int handle,
                 if (inited && !test_bit(TTY_THROTTLED, &tty->flags) &&
                                 MoxaPortRxQueue(p) > 0) { /* RX */
                         MoxaPortReadData(p);
-                        tty_schedule_flip(tty);
+                        tty_schedule_flip(&p->port);
                 }
         } else {
                 clear_bit(EMPTYWAIT, &p->statusflags);
@@ -1429,8 +1429,8 @@ static int moxa_poll_port(struct moxa_port *p, unsigned int handle,
                 goto put;
 
         if (tty && (intr & IntrBreak) && !I_IGNBRK(tty)) { /* BREAK */
-                tty_insert_flip_char(tty, 0, TTY_BREAK);
-                tty_schedule_flip(tty);
+                tty_insert_flip_char(&p->port, 0, TTY_BREAK);
+                tty_schedule_flip(&p->port);
         }
 
         if (intr & IntrLine)
@@ -1966,7 +1966,7 @@ static int MoxaPortReadData(struct moxa_port *port)
                         ofs = baseAddr + DynPage_addr + bufhead + head;
                         len = (tail >= head) ? (tail - head) :
                                         (rx_mask + 1 - head);
-                        len = tty_prepare_flip_string(tty, &dst,
+                        len = tty_prepare_flip_string(&port->port, &dst,
                                         min(len, count));
                         memcpy_fromio(dst, ofs, len);
                         head = (head + len) & rx_mask;
@@ -1978,7 +1978,7 @@ static int MoxaPortReadData(struct moxa_port *port)
                 while (count > 0) {
                         writew(pageno, baseAddr + Control_reg);
                         ofs = baseAddr + DynPage_addr + pageofs;
-                        len = tty_prepare_flip_string(tty, &dst,
+                        len = tty_prepare_flip_string(&port->port, &dst,
                                         min(Page_size - pageofs, count));
                         memcpy_fromio(dst, ofs, len);
 
diff --git a/drivers/tty/mxser.c b/drivers/tty/mxser.c
index 40113868bec2..484b6a3c9b03 100644
--- a/drivers/tty/mxser.c
+++ b/drivers/tty/mxser.c
@@ -1264,7 +1264,7 @@ static int mxser_set_serial_info(struct tty_struct *tty,
                                 (new_serial.flags & ASYNC_FLAGS));
                 port->close_delay = new_serial.close_delay * HZ / 100;
                 port->closing_wait = new_serial.closing_wait * HZ / 100;
-                tty->low_latency = (port->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
+                port->low_latency = (port->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
                 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST &&
                                 (new_serial.baud_base != info->baud_base ||
                                 new_serial.custom_divisor !=
@@ -2079,7 +2079,7 @@ static void mxser_receive_chars(struct tty_struct *tty,
                 }
                 while (gdl--) {
                         ch = inb(port->ioaddr + UART_RX);
-                        tty_insert_flip_char(tty, ch, 0);
+                        tty_insert_flip_char(&port->port, ch, 0);
                         cnt++;
                 }
                 goto end_intr;
@@ -2118,7 +2118,7 @@ intr_old:
                                 } else
                                         flag = TTY_BREAK;
                         }
-                        tty_insert_flip_char(tty, ch, flag);
+                        tty_insert_flip_char(&port->port, ch, flag);
                         cnt++;
                         if (cnt >= recv_room) {
                                 if (!port->ldisc_stop_rx)
@@ -2145,7 +2145,7 @@ end_intr:
          * recursive locking.
          */
         spin_unlock(&port->slock);
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&port->port);
         spin_lock(&port->slock);
 }
 
@@ -2364,7 +2364,6 @@ static void mxser_release_vector(struct mxser_board *brd)
 
 static void mxser_release_ISA_res(struct mxser_board *brd)
 {
-        free_irq(brd->irq, brd);
         release_region(brd->ports[0].ioaddr, 8 * brd->info->nports);
         mxser_release_vector(brd);
 }
@@ -2430,6 +2429,7 @@ static void mxser_board_remove(struct mxser_board *brd)
                 tty_unregister_device(mxvar_sdriver, brd->idx + i);
                 tty_port_destroy(&brd->ports[i].port);
         }
+        free_irq(brd->irq, brd);
 }
 
 static int __init mxser_get_ISA_conf(int cap, struct mxser_board *brd)
@@ -2554,6 +2554,7 @@ static int mxser_probe(struct pci_dev *pdev,
         struct mxser_board *brd;
         unsigned int i, j;
         unsigned long ioaddress;
+        struct device *tty_dev;
         int retval = -EINVAL;
 
         for (i = 0; i < MXSER_BOARDS; i++)
@@ -2637,13 +2638,25 @@ static int mxser_probe(struct pci_dev *pdev,
         if (retval)
                 goto err_rel3;
 
-        for (i = 0; i < brd->info->nports; i++)
-                tty_port_register_device(&brd->ports[i].port, mxvar_sdriver,
-                                brd->idx + i, &pdev->dev);
+        for (i = 0; i < brd->info->nports; i++) {
+                tty_dev = tty_port_register_device(&brd->ports[i].port,
+                                mxvar_sdriver, brd->idx + i, &pdev->dev);
+                if (IS_ERR(tty_dev)) {
+                        retval = PTR_ERR(tty_dev);
+                        for (i--; i >= 0; i--)
+                                tty_unregister_device(mxvar_sdriver,
+                                        brd->idx + i);
+                        goto err_relbrd;
+                }
+        }
 
         pci_set_drvdata(pdev, brd);
 
         return 0;
+err_relbrd:
+        for (i = 0; i < brd->info->nports; i++)
+                tty_port_destroy(&brd->ports[i].port);
+        free_irq(brd->irq, brd);
 err_rel3:
         pci_release_region(pdev, 3);
 err_zero:
@@ -2665,7 +2678,6 @@ static void mxser_remove(struct pci_dev *pdev)
 
         mxser_board_remove(brd);
 
-        free_irq(pdev->irq, brd);
         pci_release_region(pdev, 2);
         pci_release_region(pdev, 3);
         pci_disable_device(pdev);
@@ -2683,6 +2695,7 @@ static struct pci_driver mxser_driver = {
 static int __init mxser_module_init(void)
 {
         struct mxser_board *brd;
+        struct device *tty_dev;
         unsigned int b, i, m;
         int retval;
 
@@ -2728,14 +2741,29 @@ static int __init mxser_module_init(void)
 
                 /* mxser_initbrd will hook ISR. */
                 if (mxser_initbrd(brd, NULL) < 0) {
+                        mxser_release_ISA_res(brd);
                         brd->info = NULL;
                         continue;
                 }
 
                 brd->idx = m * MXSER_PORTS_PER_BOARD;
-                for (i = 0; i < brd->info->nports; i++)
-                        tty_port_register_device(&brd->ports[i].port,
+                for (i = 0; i < brd->info->nports; i++) {
+                        tty_dev = tty_port_register_device(&brd->ports[i].port,
                                         mxvar_sdriver, brd->idx + i, NULL);
+                        if (IS_ERR(tty_dev)) {
+                                for (i--; i >= 0; i--)
+                                        tty_unregister_device(mxvar_sdriver,
+                                                brd->idx + i);
+                                for (i = 0; i < brd->info->nports; i++)
+                                        tty_port_destroy(&brd->ports[i].port);
+                                free_irq(brd->irq, brd);
+                                mxser_release_ISA_res(brd);
+                                brd->info = NULL;
+                                break;
+                        }
+                }
+                if (brd->info == NULL)
+                        continue;
 
                 m++;
         }
diff --git a/drivers/tty/n_gsm.c b/drivers/tty/n_gsm.c
index dcc0430a49c8..4a43ef5d7962 100644
--- a/drivers/tty/n_gsm.c
+++ b/drivers/tty/n_gsm.c
@@ -1067,9 +1067,9 @@ static void gsm_process_modem(struct tty_struct *tty, struct gsm_dlci *dlci,
                 if ((mlines & TIOCM_CD) == 0 && (dlci->modem_rx & TIOCM_CD))
                         if (!(tty->termios.c_cflag & CLOCAL))
                                 tty_hangup(tty);
-                if (brk & 0x01)
-                        tty_insert_flip_char(tty, 0, TTY_BREAK);
         }
+        if (brk & 0x01)
+                tty_insert_flip_char(&dlci->port, 0, TTY_BREAK);
         dlci->modem_rx = mlines;
 }
 
@@ -1137,7 +1137,7 @@ static void gsm_control_modem(struct gsm_mux *gsm, u8 *data, int clen)
 
 static void gsm_control_rls(struct gsm_mux *gsm, u8 *data, int clen)
 {
-        struct tty_struct *tty;
+        struct tty_port *port;
         unsigned int addr = 0 ;
         u8 bits;
         int len = clen;
@@ -1160,19 +1160,18 @@ static void gsm_control_rls(struct gsm_mux *gsm, u8 *data, int clen)
         bits = *dp;
         if ((bits & 1) == 0)
                 return;
-        /* See if we have an uplink tty */
-        tty = tty_port_tty_get(&gsm->dlci[addr]->port);
 
-        if (tty) {
-                if (bits & 2)
-                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
-                if (bits & 4)
-                        tty_insert_flip_char(tty, 0, TTY_PARITY);
-                if (bits & 8)
-                        tty_insert_flip_char(tty, 0, TTY_FRAME);
-                tty_flip_buffer_push(tty);
-                tty_kref_put(tty);
-        }
+        port = &gsm->dlci[addr]->port;
+
+        if (bits & 2)
+                tty_insert_flip_char(port, 0, TTY_OVERRUN);
+        if (bits & 4)
+                tty_insert_flip_char(port, 0, TTY_PARITY);
+        if (bits & 8)
+                tty_insert_flip_char(port, 0, TTY_FRAME);
+
+        tty_flip_buffer_push(port);
+
         gsm_control_reply(gsm, CMD_RLS, data, clen);
 }
 
@@ -1545,36 +1544,37 @@ static void gsm_dlci_data(struct gsm_dlci *dlci, u8 *data, int clen)
 {
         /* krefs .. */
         struct tty_port *port = &dlci->port;
-        struct tty_struct *tty = tty_port_tty_get(port);
+        struct tty_struct *tty;
         unsigned int modem = 0;
         int len = clen;
 
         if (debug & 16)
-                pr_debug("%d bytes for tty %p\n", len, tty);
-        if (tty) {
-                switch (dlci->adaption)  {
-                /* Unsupported types */
-                /* Packetised interruptible data */
-                case 4:
-                        break;
-                /* Packetised uininterruptible voice/data */
-                case 3:
-                        break;
-                /* Asynchronous serial with line state in each frame */
-                case 2:
-                        while (gsm_read_ea(&modem, *data++) == 0) {
-                                len--;
-                                if (len == 0)
-                                        return;
-                        }
+                pr_debug("%d bytes for tty\n", len);
+        switch (dlci->adaption)  {
+        /* Unsupported types */
+        /* Packetised interruptible data */
+        case 4:
+                break;
+        /* Packetised uininterruptible voice/data */
+        case 3:
+                break;
+        /* Asynchronous serial with line state in each frame */
+        case 2:
+                while (gsm_read_ea(&modem, *data++) == 0) {
+                        len--;
+                        if (len == 0)
+                                return;
+                }
+                tty = tty_port_tty_get(port);
+                if (tty) {
                         gsm_process_modem(tty, dlci, modem, clen);
-                /* Line state will go via DLCI 0 controls only */
-                case 1:
-                default:
-                        tty_insert_flip_string(tty, data, len);
-                        tty_flip_buffer_push(tty);
+                        tty_kref_put(tty);
                 }
-                tty_kref_put(tty);
+        /* Line state will go via DLCI 0 controls only */
+        case 1:
+        default:
+                tty_insert_flip_string(port, data, len);
+                tty_flip_buffer_push(port);
         }
 }
 
@@ -1689,6 +1689,8 @@ static inline void dlci_put(struct gsm_dlci *dlci)
         tty_port_put(&dlci->port);
 }
 
+static void gsm_destroy_network(struct gsm_dlci *dlci);
+
 /**
  *      gsm_dlci_release                -       release DLCI
  *      @dlci: DLCI to destroy
@@ -1702,9 +1704,19 @@ static void gsm_dlci_release(struct gsm_dlci *dlci)
 {
         struct tty_struct *tty = tty_port_tty_get(&dlci->port);
         if (tty) {
+                mutex_lock(&dlci->mutex);
+                gsm_destroy_network(dlci);
+                mutex_unlock(&dlci->mutex);
+
+                /* tty_vhangup needs the tty_lock, so unlock and
+                   relock after doing the hangup. */
+                tty_unlock(tty);
                 tty_vhangup(tty);
+                tty_lock(tty);
+                tty_port_tty_set(&dlci->port, NULL);
                 tty_kref_put(tty);
         }
+        dlci->state = DLCI_CLOSED;
         dlci_put(dlci);
 }
 
@@ -2947,6 +2959,8 @@ static void gsmtty_close(struct tty_struct *tty, struct file *filp)
 
         if (dlci == NULL)
                 return;
+        if (dlci->state == DLCI_CLOSED)
+                return;
         mutex_lock(&dlci->mutex);
         gsm_destroy_network(dlci);
         mutex_unlock(&dlci->mutex);
@@ -2965,6 +2979,8 @@ out:
 static void gsmtty_hangup(struct tty_struct *tty)
 {
         struct gsm_dlci *dlci = tty->driver_data;
+        if (dlci->state == DLCI_CLOSED)
+                return;
         tty_port_hangup(&dlci->port);
         gsm_dlci_begin_close(dlci);
 }
@@ -2972,9 +2988,12 @@ static void gsmtty_hangup(struct tty_struct *tty)
 static int gsmtty_write(struct tty_struct *tty, const unsigned char *buf,
                                                                     int len)
 {
+        int sent;
         struct gsm_dlci *dlci = tty->driver_data;
+        if (dlci->state == DLCI_CLOSED)
+                return -EINVAL;
         /* Stuff the bytes into the fifo queue */
-        int sent = kfifo_in_locked(dlci->fifo, buf, len, &dlci->lock);
+        sent = kfifo_in_locked(dlci->fifo, buf, len, &dlci->lock);
         /* Need to kick the channel */
         gsm_dlci_data_kick(dlci);
         return sent;
@@ -2983,18 +3002,24 @@ static int gsmtty_write(struct tty_struct *tty, const unsigned char *buf,
 static int gsmtty_write_room(struct tty_struct *tty)
 {
         struct gsm_dlci *dlci = tty->driver_data;
+        if (dlci->state == DLCI_CLOSED)
+                return -EINVAL;
         return TX_SIZE - kfifo_len(dlci->fifo);
 }
 
 static int gsmtty_chars_in_buffer(struct tty_struct *tty)
 {
         struct gsm_dlci *dlci = tty->driver_data;
+        if (dlci->state == DLCI_CLOSED)
+                return -EINVAL;
         return kfifo_len(dlci->fifo);
 }
 
 static void gsmtty_flush_buffer(struct tty_struct *tty)
 {
         struct gsm_dlci *dlci = tty->driver_data;
+        if (dlci->state == DLCI_CLOSED)
+                return;
         /* Caution needed: If we implement reliable transport classes
            then the data being transmitted can't simply be junked once
            it has first hit the stack. Until then we can just blow it
@@ -3013,6 +3038,8 @@ static void gsmtty_wait_until_sent(struct tty_struct *tty, int timeout)
 static int gsmtty_tiocmget(struct tty_struct *tty)
 {
         struct gsm_dlci *dlci = tty->driver_data;
+        if (dlci->state == DLCI_CLOSED)
+                return -EINVAL;
         return dlci->modem_rx;
 }
 
@@ -3022,6 +3049,8 @@ static int gsmtty_tiocmset(struct tty_struct *tty,
         struct gsm_dlci *dlci = tty->driver_data;
         unsigned int modem_tx = dlci->modem_tx;
 
+        if (dlci->state == DLCI_CLOSED)
+                return -EINVAL;
         modem_tx &= ~clear;
         modem_tx |= set;
 
@@ -3040,6 +3069,8 @@ static int gsmtty_ioctl(struct tty_struct *tty,
         struct gsm_netconfig nc;
         int index;
 
+        if (dlci->state == DLCI_CLOSED)
+                return -EINVAL;
         switch (cmd) {
         case GSMIOC_ENABLE_NET:
                 if (copy_from_user(&nc, (void __user *)arg, sizeof(nc)))
@@ -3066,6 +3097,9 @@ static int gsmtty_ioctl(struct tty_struct *tty,
 
 static void gsmtty_set_termios(struct tty_struct *tty, struct ktermios *old)
 {
+        struct gsm_dlci *dlci = tty->driver_data;
+        if (dlci->state == DLCI_CLOSED)
+                return;
         /* For the moment its fixed. In actual fact the speed information
            for the virtual channel can be propogated in both directions by
            the RPN control message. This however rapidly gets nasty as we
@@ -3077,6 +3111,8 @@ static void gsmtty_set_termios(struct tty_struct *tty, struct ktermios *old)
 static void gsmtty_throttle(struct tty_struct *tty)
 {
         struct gsm_dlci *dlci = tty->driver_data;
+        if (dlci->state == DLCI_CLOSED)
+                return;
         if (tty->termios.c_cflag & CRTSCTS)
                 dlci->modem_tx &= ~TIOCM_DTR;
         dlci->throttled = 1;
@@ -3087,6 +3123,8 @@ static void gsmtty_throttle(struct tty_struct *tty)
 static void gsmtty_unthrottle(struct tty_struct *tty)
 {
         struct gsm_dlci *dlci = tty->driver_data;
+        if (dlci->state == DLCI_CLOSED)
+                return;
         if (tty->termios.c_cflag & CRTSCTS)
                 dlci->modem_tx |= TIOCM_DTR;
         dlci->throttled = 0;
@@ -3098,6 +3136,8 @@ static int gsmtty_break_ctl(struct tty_struct *tty, int state)
 {
         struct gsm_dlci *dlci = tty->driver_data;
         int encode = 0; /* Off */
+        if (dlci->state == DLCI_CLOSED)
+                return -EINVAL;
 
         if (state == -1)        /* "On indefinitely" - we can't encode this
                                     properly */
diff --git a/drivers/tty/n_tty.c b/drivers/tty/n_tty.c
index 19083efa2314..05e72bea9b07 100644
--- a/drivers/tty/n_tty.c
+++ b/drivers/tty/n_tty.c
@@ -49,6 +49,7 @@
 #include <linux/file.h>
 #include <linux/uaccess.h>
 #include <linux/module.h>
+#include <linux/ratelimit.h>
 
 
 /* number of characters left in xmit buffer before select has we have room */
@@ -100,7 +101,7 @@ struct n_tty_data {
         struct mutex atomic_read_lock;
         struct mutex output_lock;
         struct mutex echo_lock;
-        spinlock_t read_lock;
+        raw_spinlock_t read_lock;
 };
 
 static inline int tty_put_user(struct tty_struct *tty, unsigned char x,
@@ -182,9 +183,9 @@ static void put_tty_queue(unsigned char c, struct n_tty_data *ldata)
          *      The problem of stomping on the buffers ends here.
          *      Why didn't anyone see this one coming? --AJK
         */
-        spin_lock_irqsave(&ldata->read_lock, flags);
+        raw_spin_lock_irqsave(&ldata->read_lock, flags);
         put_tty_queue_nolock(c, ldata);
-        spin_unlock_irqrestore(&ldata->read_lock, flags);
+        raw_spin_unlock_irqrestore(&ldata->read_lock, flags);
 }
 
 /**
@@ -218,9 +219,9 @@ static void reset_buffer_flags(struct tty_struct *tty)
         struct n_tty_data *ldata = tty->disc_data;
         unsigned long flags;
 
-        spin_lock_irqsave(&ldata->read_lock, flags);
+        raw_spin_lock_irqsave(&ldata->read_lock, flags);
         ldata->read_head = ldata->read_tail = ldata->read_cnt = 0;
-        spin_unlock_irqrestore(&ldata->read_lock, flags);
+        raw_spin_unlock_irqrestore(&ldata->read_lock, flags);
 
         mutex_lock(&ldata->echo_lock);
         ldata->echo_pos = ldata->echo_cnt = ldata->echo_overrun = 0;
@@ -276,7 +277,7 @@ static ssize_t n_tty_chars_in_buffer(struct tty_struct *tty)
         unsigned long flags;
         ssize_t n = 0;
 
-        spin_lock_irqsave(&ldata->read_lock, flags);
+        raw_spin_lock_irqsave(&ldata->read_lock, flags);
         if (!ldata->icanon) {
                 n = ldata->read_cnt;
         } else if (ldata->canon_data) {
@@ -284,7 +285,7 @@ static ssize_t n_tty_chars_in_buffer(struct tty_struct *tty)
                         ldata->canon_head - ldata->read_tail :
                         ldata->canon_head + (N_TTY_BUF_SIZE - ldata->read_tail);
         }
-        spin_unlock_irqrestore(&ldata->read_lock, flags);
+        raw_spin_unlock_irqrestore(&ldata->read_lock, flags);
         return n;
 }
 
@@ -915,19 +916,19 @@ static void eraser(unsigned char c, struct tty_struct *tty)
                 kill_type = WERASE;
         else {
                 if (!L_ECHO(tty)) {
-                        spin_lock_irqsave(&ldata->read_lock, flags);
+                        raw_spin_lock_irqsave(&ldata->read_lock, flags);
                         ldata->read_cnt -= ((ldata->read_head - ldata->canon_head) &
                                           (N_TTY_BUF_SIZE - 1));
                         ldata->read_head = ldata->canon_head;
-                        spin_unlock_irqrestore(&ldata->read_lock, flags);
+                        raw_spin_unlock_irqrestore(&ldata->read_lock, flags);
                         return;
                 }
                 if (!L_ECHOK(tty) || !L_ECHOKE(tty) || !L_ECHOE(tty)) {
-                        spin_lock_irqsave(&ldata->read_lock, flags);
+                        raw_spin_lock_irqsave(&ldata->read_lock, flags);
                         ldata->read_cnt -= ((ldata->read_head - ldata->canon_head) &
                                           (N_TTY_BUF_SIZE - 1));
                         ldata->read_head = ldata->canon_head;
-                        spin_unlock_irqrestore(&ldata->read_lock, flags);
+                        raw_spin_unlock_irqrestore(&ldata->read_lock, flags);
                         finish_erasing(ldata);
                         echo_char(KILL_CHAR(tty), tty);
                         /* Add a newline if ECHOK is on and ECHOKE is off. */
@@ -961,10 +962,10 @@ static void eraser(unsigned char c, struct tty_struct *tty)
                                 break;
                 }
                 cnt = (ldata->read_head - head) & (N_TTY_BUF_SIZE-1);
-                spin_lock_irqsave(&ldata->read_lock, flags);
+                raw_spin_lock_irqsave(&ldata->read_lock, flags);
                 ldata->read_head = head;
                 ldata->read_cnt -= cnt;
-                spin_unlock_irqrestore(&ldata->read_lock, flags);
+                raw_spin_unlock_irqrestore(&ldata->read_lock, flags);
                 if (L_ECHO(tty)) {
                         if (L_ECHOPRT(tty)) {
                                 if (!ldata->erasing) {
@@ -1344,12 +1345,12 @@ send_signal:
                                 put_tty_queue(c, ldata);
 
 handle_newline:
-                        spin_lock_irqsave(&ldata->read_lock, flags);
+                        raw_spin_lock_irqsave(&ldata->read_lock, flags);
                         set_bit(ldata->read_head, ldata->read_flags);
                         put_tty_queue_nolock(c, ldata);
                         ldata->canon_head = ldata->read_head;
                         ldata->canon_data++;
-                        spin_unlock_irqrestore(&ldata->read_lock, flags);
+                        raw_spin_unlock_irqrestore(&ldata->read_lock, flags);
                         kill_fasync(&tty->fasync, SIGIO, POLL_IN);
                         if (waitqueue_active(&tty->read_wait))
                                 wake_up_interruptible(&tty->read_wait);
@@ -1423,7 +1424,7 @@ static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
         unsigned long cpuflags;
 
         if (ldata->real_raw) {
-                spin_lock_irqsave(&ldata->read_lock, cpuflags);
+                raw_spin_lock_irqsave(&ldata->read_lock, cpuflags);
                 i = min(N_TTY_BUF_SIZE - ldata->read_cnt,
                         N_TTY_BUF_SIZE - ldata->read_head);
                 i = min(count, i);
@@ -1439,7 +1440,7 @@ static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
                 memcpy(ldata->read_buf + ldata->read_head, cp, i);
                 ldata->read_head = (ldata->read_head + i) & (N_TTY_BUF_SIZE-1);
                 ldata->read_cnt += i;
-                spin_unlock_irqrestore(&ldata->read_lock, cpuflags);
+                raw_spin_unlock_irqrestore(&ldata->read_lock, cpuflags);
         } else {
                 for (i = count, p = cp, f = fp; i; i--, p++) {
                         if (f)
@@ -1635,7 +1636,7 @@ static int n_tty_open(struct tty_struct *tty)
         mutex_init(&ldata->atomic_read_lock);
         mutex_init(&ldata->output_lock);
         mutex_init(&ldata->echo_lock);
-        spin_lock_init(&ldata->read_lock);
+        raw_spin_lock_init(&ldata->read_lock);
 
         /* These are ugly. Currently a malloc failure here can panic */
         ldata->read_buf = kzalloc(N_TTY_BUF_SIZE, GFP_KERNEL);
@@ -1703,10 +1704,10 @@ static int copy_from_read_buf(struct tty_struct *tty,
         bool is_eof;
 
         retval = 0;
-        spin_lock_irqsave(&ldata->read_lock, flags);
+        raw_spin_lock_irqsave(&ldata->read_lock, flags);
         n = min(ldata->read_cnt, N_TTY_BUF_SIZE - ldata->read_tail);
         n = min(*nr, n);
-        spin_unlock_irqrestore(&ldata->read_lock, flags);
+        raw_spin_unlock_irqrestore(&ldata->read_lock, flags);
         if (n) {
                 retval = copy_to_user(*b, &ldata->read_buf[ldata->read_tail], n);
                 n -= retval;
@@ -1714,13 +1715,13 @@ static int copy_from_read_buf(struct tty_struct *tty,
                         ldata->read_buf[ldata->read_tail] == EOF_CHAR(tty);
                 tty_audit_add_data(tty, &ldata->read_buf[ldata->read_tail], n,
                                 ldata->icanon);
-                spin_lock_irqsave(&ldata->read_lock, flags);
+                raw_spin_lock_irqsave(&ldata->read_lock, flags);
                 ldata->read_tail = (ldata->read_tail + n) & (N_TTY_BUF_SIZE-1);
                 ldata->read_cnt -= n;
                 /* Turn single EOF into zero-length read */
                 if (L_EXTPROC(tty) && ldata->icanon && is_eof && !ldata->read_cnt)
                         n = 0;
-                spin_unlock_irqrestore(&ldata->read_lock, flags);
+                raw_spin_unlock_irqrestore(&ldata->read_lock, flags);
                 *b += n;
                 *nr -= n;
         }
@@ -1900,7 +1901,7 @@ do_it_again:
 
                 if (ldata->icanon && !L_EXTPROC(tty)) {
                         /* N.B. avoid overrun if nr == 0 */
-                        spin_lock_irqsave(&ldata->read_lock, flags);
+                        raw_spin_lock_irqsave(&ldata->read_lock, flags);
                         while (nr && ldata->read_cnt) {
                                 int eol;
 
@@ -1918,25 +1919,25 @@ do_it_again:
                                         if (--ldata->canon_data < 0)
                                                 ldata->canon_data = 0;
                                 }
-                                spin_unlock_irqrestore(&ldata->read_lock, flags);
+                                raw_spin_unlock_irqrestore(&ldata->read_lock, flags);
 
                                 if (!eol || (c != __DISABLED_CHAR)) {
                                         if (tty_put_user(tty, c, b++)) {
                                                 retval = -EFAULT;
                                                 b--;
-                                                spin_lock_irqsave(&ldata->read_lock, flags);
+                                                raw_spin_lock_irqsave(&ldata->read_lock, flags);
                                                 break;
                                         }
                                         nr--;
                                 }
                                 if (eol) {
                                         tty_audit_push(tty);
-                                        spin_lock_irqsave(&ldata->read_lock, flags);
+                                        raw_spin_lock_irqsave(&ldata->read_lock, flags);
                                         break;
                                 }
-                                spin_lock_irqsave(&ldata->read_lock, flags);
+                                raw_spin_lock_irqsave(&ldata->read_lock, flags);
                         }
-                        spin_unlock_irqrestore(&ldata->read_lock, flags);
+                        raw_spin_unlock_irqrestore(&ldata->read_lock, flags);
                         if (retval)
                                 break;
                 } else {
@@ -2188,7 +2189,7 @@ struct tty_ldisc_ops tty_ldisc_N_TTY = {
  *      n_tty_inherit_ops       -       inherit N_TTY methods
  *      @ops: struct tty_ldisc_ops where to save N_TTY methods
  *
- *      Used by a generic struct tty_ldisc_ops to easily inherit N_TTY
+ *      Enables a 'subclass' line discipline to 'inherit' N_TTY
  *      methods.
  */
 
diff --git a/drivers/tty/nozomi.c b/drivers/tty/nozomi.c
index a0c69ab04399..2dff19796157 100644
--- a/drivers/tty/nozomi.c
+++ b/drivers/tty/nozomi.c
@@ -827,15 +827,10 @@ static int receive_data(enum port_type index, struct nozomi *dc)
         struct tty_struct *tty = tty_port_tty_get(&port->port);
         int i, ret;
 
-        if (unlikely(!tty)) {
-                DBG1("tty not open for port: %d?", index);
-                return 1;
-        }
-
         read_mem32((u32 *) &size, addr, 4);
         /*  DBG1( "%d bytes port: %d", size, index); */
 
-        if (test_bit(TTY_THROTTLED, &tty->flags)) {
+        if (tty && test_bit(TTY_THROTTLED, &tty->flags)) {
                 DBG1("No room in tty, don't read data, don't ack interrupt, "
                         "disable interrupt");
 
@@ -855,13 +850,14 @@ static int receive_data(enum port_type index, struct nozomi *dc)
                 read_mem32((u32 *) buf, addr + offset, RECEIVE_BUF_MAX);
 
                 if (size == 1) {
-                        tty_insert_flip_char(tty, buf[0], TTY_NORMAL);
+                        tty_insert_flip_char(&port->port, buf[0], TTY_NORMAL);
                         size = 0;
                 } else if (size < RECEIVE_BUF_MAX) {
-                        size -= tty_insert_flip_string(tty, (char *) buf, size);
+                        size -= tty_insert_flip_string(&port->port,
+                                        (char *)buf, size);
                 } else {
-                        i = tty_insert_flip_string(tty, \
-                                                (char *) buf, RECEIVE_BUF_MAX);
+                        i = tty_insert_flip_string(&port->port,
+                                        (char *)buf, RECEIVE_BUF_MAX);
                         size -= i;
                         offset += i;
                 }
@@ -1276,15 +1272,11 @@ static irqreturn_t interrupt_handler(int irq, void *dev_id)
 
 exit_handler:
         spin_unlock(&dc->spin_mutex);
-        for (a = 0; a < NOZOMI_MAX_PORTS; a++) {
-                struct tty_struct *tty;
-                if (test_and_clear_bit(a, &dc->flip)) {
-                        tty = tty_port_tty_get(&dc->port[a].port);
-                        if (tty)
-                                tty_flip_buffer_push(tty);
-                        tty_kref_put(tty);
-                }
-        }
+
+        for (a = 0; a < NOZOMI_MAX_PORTS; a++)
+                if (test_and_clear_bit(a, &dc->flip))
+                        tty_flip_buffer_push(&dc->port[a].port);
+
         return IRQ_HANDLED;
 none:
         spin_unlock(&dc->spin_mutex);
@@ -1687,12 +1679,6 @@ static int ntty_write(struct tty_struct *tty, const unsigned char *buffer,
 
         rval = kfifo_in(&port->fifo_ul, (unsigned char *)buffer, count);
 
-        /* notify card */
-        if (unlikely(dc == NULL)) {
-                DBG1("No device context?");
-                goto exit;
-        }
-
         spin_lock_irqsave(&dc->spin_mutex, flags);
         /* CTS is only valid on the modem channel */
         if (port == &(dc->port[PORT_MDM])) {
@@ -1708,7 +1694,6 @@ static int ntty_write(struct tty_struct *tty, const unsigned char *buffer,
         }
         spin_unlock_irqrestore(&dc->spin_mutex, flags);
 
-exit:
         return rval;
 }
 
diff --git a/drivers/tty/pty.c b/drivers/tty/pty.c
index 79ff3a5e925d..c24b4db243b9 100644
--- a/drivers/tty/pty.c
+++ b/drivers/tty/pty.c
@@ -38,16 +38,18 @@ static void pty_close(struct tty_struct *tty, struct file *filp)
         if (tty->driver->subtype == PTY_TYPE_MASTER)
                 WARN_ON(tty->count > 1);
         else {
+                if (test_bit(TTY_IO_ERROR, &tty->flags))
+                        return;
                 if (tty->count > 2)
                         return;
         }
+        set_bit(TTY_IO_ERROR, &tty->flags);
         wake_up_interruptible(&tty->read_wait);
         wake_up_interruptible(&tty->write_wait);
         tty->packet = 0;
         /* Review - krefs on tty_link ?? */
         if (!tty->link)
                 return;
-        tty->link->packet = 0;
         set_bit(TTY_OTHER_CLOSED, &tty->link->flags);
         wake_up_interruptible(&tty->link->read_wait);
         wake_up_interruptible(&tty->link->write_wait);
@@ -55,9 +57,10 @@ static void pty_close(struct tty_struct *tty, struct file *filp)
                 set_bit(TTY_OTHER_CLOSED, &tty->flags);
 #ifdef CONFIG_UNIX98_PTYS
                 if (tty->driver == ptm_driver) {
-                        mutex_lock(&devpts_mutex);
-                        devpts_pty_kill(tty->link->driver_data);
-                        mutex_unlock(&devpts_mutex);
+                        mutex_lock(&devpts_mutex);
+                        if (tty->link->driver_data)
+                                devpts_pty_kill(tty->link->driver_data);
+                        mutex_unlock(&devpts_mutex);
                 }
 #endif
                 tty_unlock(tty);
@@ -120,10 +123,10 @@ static int pty_write(struct tty_struct *tty, const unsigned char *buf, int c)
 
         if (c > 0) {
                 /* Stuff the data into the input queue of the other end */
-                c = tty_insert_flip_string(to, buf, c);
+                c = tty_insert_flip_string(to->port, buf, c);
                 /* And shovel */
                 if (c) {
-                        tty_flip_buffer_push(to);
+                        tty_flip_buffer_push(to->port);
                         tty_wakeup(tty);
                 }
         }
@@ -246,14 +249,17 @@ static int pty_open(struct tty_struct *tty, struct file *filp)
         if (!tty || !tty->link)
                 goto out;
 
+        set_bit(TTY_IO_ERROR, &tty->flags);
+
         retval = -EIO;
         if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
                 goto out;
         if (test_bit(TTY_PTY_LOCK, &tty->link->flags))
                 goto out;
-        if (tty->link->count != 1)
+        if (tty->driver->subtype == PTY_TYPE_SLAVE && tty->link->count != 1)
                 goto out;
 
+        clear_bit(TTY_IO_ERROR, &tty->flags);
         clear_bit(TTY_OTHER_CLOSED, &tty->link->flags);
         set_bit(TTY_THROTTLED, &tty->flags);
         retval = 0;
@@ -663,7 +669,7 @@ static const struct tty_operations pty_unix98_ops = {
  *      Allocate a unix98 pty master device from the ptmx driver.
  *
  *      Locking: tty_mutex protects the init_dev work. tty->count should
- *              protect the rest.
+ *              protect the rest.
  *              allocated_ptys_lock handles the list of free pty numbers
  */
 
@@ -704,6 +710,7 @@ static int ptmx_open(struct inode *inode, struct file *filp)
         mutex_unlock(&tty_mutex);
 
         set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
+        tty->driver_data = inode;
 
         tty_add_file(tty, filp);
 
@@ -714,14 +721,13 @@ static int ptmx_open(struct inode *inode, struct file *filp)
                 retval = PTR_ERR(slave_inode);
                 goto err_release;
         }
+        tty->link->driver_data = slave_inode;
 
         retval = ptm_driver->ops->open(tty, filp);
         if (retval)
                 goto err_release;
 
         tty_unlock(tty);
-        tty->driver_data = inode;
-        tty->link->driver_data = slave_inode;
         return 0;
 err_release:
         tty_unlock(tty);
@@ -797,7 +803,7 @@ static void __init unix98_pty_init(void)
         cdev_init(&ptmx_cdev, &ptmx_fops);
         if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
-                panic("Couldn't register /dev/ptmx driver\n");
+                panic("Couldn't register /dev/ptmx driver");
         device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
 }
 
diff --git a/drivers/tty/rocket.c b/drivers/tty/rocket.c
index e42009a00529..1d270034bfc3 100644
--- a/drivers/tty/rocket.c
+++ b/drivers/tty/rocket.c
@@ -55,7 +55,7 @@
 #undef REV_PCI_ORDER
 #undef ROCKET_DEBUG_IO
 
-#define POLL_PERIOD HZ/100      /*  Polling period .01 seconds (10ms) */
+#define POLL_PERIOD (HZ/100)    /*  Polling period .01 seconds (10ms) */
 
 /****** Kernel includes ******/
 
@@ -315,9 +315,8 @@ static inline int rocket_paranoia_check(struct r_port *info,
  *  that receive data is present on a serial port.  Pulls data from FIFO, moves it into the 
  *  tty layer.  
  */
-static void rp_do_receive(struct r_port *info,
-                          struct tty_struct *tty,
-                          CHANNEL_t * cp, unsigned int ChanStatus)
+static void rp_do_receive(struct r_port *info, CHANNEL_t *cp,
+                unsigned int ChanStatus)
 {
         unsigned int CharNStat;
         int ToRecv, wRecv, space;
@@ -379,7 +378,8 @@ static void rp_do_receive(struct r_port *info,
                                 flag = TTY_OVERRUN;
                         else
                                 flag = TTY_NORMAL;
-                        tty_insert_flip_char(tty, CharNStat & 0xff, flag);
+                        tty_insert_flip_char(&info->port, CharNStat & 0xff,
+                                        flag);
                         ToRecv--;
                 }
 
@@ -399,7 +399,7 @@ static void rp_do_receive(struct r_port *info,
                  * characters at time by doing repeated word IO
                  * transfer.
                  */
-                space = tty_prepare_flip_string(tty, &cbuf, ToRecv);
+                space = tty_prepare_flip_string(&info->port, &cbuf, ToRecv);
                 if (space < ToRecv) {
 #ifdef ROCKET_DEBUG_RECEIVE
                         printk(KERN_INFO "rp_do_receive:insufficient space ToRecv=%d space=%d\n", ToRecv, space);
@@ -415,7 +415,7 @@ static void rp_do_receive(struct r_port *info,
                         cbuf[ToRecv - 1] = sInB(sGetTxRxDataIO(cp));
         }
         /*  Push the data up to the tty layer */
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&info->port);
 }
 
 /*
@@ -494,7 +494,6 @@ static void rp_do_transmit(struct r_port *info)
 static void rp_handle_port(struct r_port *info)
 {
         CHANNEL_t *cp;
-        struct tty_struct *tty;
         unsigned int IntMask, ChanStatus;
 
         if (!info)
@@ -505,12 +504,7 @@ static void rp_handle_port(struct r_port *info)
                                 "info->flags & NOT_INIT\n");
                 return;
         }
-        tty = tty_port_tty_get(&info->port);
-        if (!tty) {
-                printk(KERN_WARNING "rp: WARNING: rp_handle_port called with "
-                                "tty==NULL\n");
-                return;
-        }
+
         cp = &info->channel;
 
         IntMask = sGetChanIntID(cp) & info->intmask;
@@ -519,7 +513,7 @@ static void rp_handle_port(struct r_port *info)
 #endif
         ChanStatus = sGetChanStatus(cp);
         if (IntMask & RXF_TRIG) {       /* Rx FIFO trigger level */
-                rp_do_receive(info, tty, cp, ChanStatus);
+                rp_do_receive(info, cp, ChanStatus);
         }
         if (IntMask & DELTA_CD) {       /* CD change  */
 #if (defined(ROCKET_DEBUG_OPEN) || defined(ROCKET_DEBUG_INTR) || defined(ROCKET_DEBUG_HANGUP))
@@ -527,10 +521,15 @@ static void rp_handle_port(struct r_port *info)
                        (ChanStatus & CD_ACT) ? "on" : "off");
 #endif
                 if (!(ChanStatus & CD_ACT) && info->cd_status) {
+                        struct tty_struct *tty;
 #ifdef ROCKET_DEBUG_HANGUP
                         printk(KERN_INFO "CD drop, calling hangup.\n");
 #endif
-                        tty_hangup(tty);
+                        tty = tty_port_tty_get(&info->port);
+                        if (tty) {
+                                tty_hangup(tty);
+                                tty_kref_put(tty);
+                        }
                 }
                 info->cd_status = (ChanStatus & CD_ACT) ? 1 : 0;
                 wake_up_interruptible(&info->port.open_wait);
@@ -543,7 +542,6 @@ static void rp_handle_port(struct r_port *info)
                 printk(KERN_INFO "DSR change...\n");
         }
 #endif
-        tty_kref_put(tty);
 }
 
 /*
@@ -1758,8 +1756,29 @@ static void rp_flush_buffer(struct tty_struct *tty)
 
 #ifdef CONFIG_PCI
 
-static struct pci_device_id __used rocket_pci_ids[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_ANY_ID) },
+static DEFINE_PCI_DEVICE_TABLE(rocket_pci_ids) = {
+        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP4QUAD) },
+        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP8OCTA) },
+        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_DEVICE_ID_URP8OCTA) },
+        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP8INTF) },
+        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_DEVICE_ID_URP8INTF) },
+        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP8J) },
+        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP4J) },
+        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP8SNI) },
+        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP16SNI) },
+        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP16INTF) },
+        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_DEVICE_ID_URP16INTF) },
+        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_DEVICE_ID_CRP16INTF) },
+        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP32INTF) },
+        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_DEVICE_ID_URP32INTF) },
+        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RPP4) },
+        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RPP8) },
+        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP2_232) },
+        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP2_422) },
+        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP6M) },
+        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_DEVICE_ID_RP4M) },
+        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_DEVICE_ID_UPCI_RM3_8PORT) },
+        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_DEVICE_ID_UPCI_RM3_4PORT) },
         { }
 };
 MODULE_DEVICE_TABLE(pci, rocket_pci_ids);
@@ -1781,7 +1800,8 @@ static __init int register_PCI(int i, struct pci_dev *dev)
         WordIO_t ConfigIO = 0;
         ByteIO_t UPCIRingInd = 0;
 
-        if (!dev || pci_enable_device(dev))
+        if (!dev || !pci_match_id(rocket_pci_ids, dev) ||
+            pci_enable_device(dev))
                 return 0;
 
         rcktpt_io_addr[i] = pci_resource_start(dev, 0);
diff --git a/drivers/tty/serial/21285.c b/drivers/tty/serial/21285.c
index a44345a2dbb4..c7e8b60b6177 100644
--- a/drivers/tty/serial/21285.c
+++ b/drivers/tty/serial/21285.c
@@ -85,7 +85,6 @@ 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->state->port.tty;
         unsigned int status, ch, flag, rxs, max_count = 256;
 
         status = *CSR_UARTFLG;
@@ -115,7 +114,7 @@ static irqreturn_t serial21285_rx_chars(int irq, void *dev_id)
 
                 status = *CSR_UARTFLG;
         }
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&port->state->port);
 
         return IRQ_HANDLED;
 }
diff --git a/drivers/tty/serial/68328serial.c b/drivers/tty/serial/68328serial.c
index f99a84526f82..49399470794d 100644
--- a/drivers/tty/serial/68328serial.c
+++ b/drivers/tty/serial/68328serial.c
@@ -262,8 +262,7 @@ static void rs_start(struct tty_struct *tty)
         local_irq_restore(flags);
 }
 
-static void receive_chars(struct m68k_serial *info, struct tty_struct *tty,
-                unsigned short rx)
+static void receive_chars(struct m68k_serial *info, unsigned short rx)
 {
         m68328_uart *uart = &uart_addr[info->line];
         unsigned char ch, flag;
@@ -293,9 +292,6 @@ static void receive_chars(struct m68k_serial *info, struct tty_struct *tty,
                         }
                 }
 
-                if(!tty)
-                        goto clear_and_exit;
-                
                 flag = TTY_NORMAL;
 
                 if (rx & URX_PARITY_ERROR)
@@ -305,15 +301,12 @@ static void receive_chars(struct m68k_serial *info, struct tty_struct *tty,
                 else if (rx & URX_FRAME_ERROR)
                         flag = TTY_FRAME;
 
-                tty_insert_flip_char(tty, ch, flag);
+                tty_insert_flip_char(&info->tport, ch, flag);
 #ifndef CONFIG_XCOPILOT_BUGS
         } while((rx = uart->urx.w) & URX_DATA_READY);
 #endif
 
-        tty_schedule_flip(tty);
-
-clear_and_exit:
-        return;
+        tty_schedule_flip(&info->tport);
 }
 
 static void transmit_chars(struct m68k_serial *info, struct tty_struct *tty)
@@ -367,11 +360,11 @@ irqreturn_t rs_interrupt(int irq, void *dev_id)
         tx = uart->utx.w;
 
         if (rx & URX_DATA_READY)
-                receive_chars(info, tty, rx);
+                receive_chars(info, rx);
         if (tx & UTX_TX_AVAIL)
                 transmit_chars(info, tty);
 #else
-        receive_chars(info, tty, rx);
+        receive_chars(info, rx);
 #endif
         tty_kref_put(tty);
 
@@ -1009,7 +1002,7 @@ static void rs_close(struct tty_struct *tty, struct file * filp)
         m68328_uart *uart = &uart_addr[info->line];
         unsigned long flags;
 
-        if (!info || serial_paranoia_check(info, tty->name, "rs_close"))
+        if (serial_paranoia_check(info, tty->name, "rs_close"))
                 return;
         
         local_irq_save(flags);
diff --git a/drivers/tty/serial/8250/8250.c b/drivers/tty/serial/8250/8250.c
index f9320437a649..0efc815a4968 100644
--- a/drivers/tty/serial/8250/8250.c
+++ b/drivers/tty/serial/8250/8250.c
@@ -239,13 +239,6 @@ static const struct serial8250_config uart_config[] = {
                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
                 .flags          = UART_CAP_FIFO | UART_CAP_UUE | UART_CAP_RTOIE,
         },
-        [PORT_RM9000] = {
-                .name           = "RM9000",
-                .fifo_size      = 16,
-                .tx_loadsz      = 16,
-                .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
-                .flags          = UART_CAP_FIFO,
-        },
         [PORT_OCTEON] = {
                 .name           = "OCTEON",
                 .fifo_size      = 64,
@@ -324,9 +317,9 @@ static void default_serial_dl_write(struct uart_8250_port *up, int value)
         serial_out(up, UART_DLM, value >> 8 & 0xff);
 }
 
-#ifdef CONFIG_MIPS_ALCHEMY
+#if defined(CONFIG_MIPS_ALCHEMY) || defined(CONFIG_SERIAL_8250_RT288X)
 
-/* Au1x00 UART hardware has a weird register layout */
+/* Au1x00/RT288x UART hardware has a weird register layout */
 static const u8 au_io_in_map[] = {
         [UART_RX]  = 0,
         [UART_IER] = 2,
@@ -370,56 +363,6 @@ static void au_serial_dl_write(struct uart_8250_port *up, int value)
 
 #endif
 
-#ifdef CONFIG_SERIAL_8250_RM9K
-
-static const u8
-        regmap_in[8] = {
-                [UART_RX]       = 0x00,
-                [UART_IER]      = 0x0c,
-                [UART_IIR]      = 0x14,
-                [UART_LCR]      = 0x1c,
-                [UART_MCR]      = 0x20,
-                [UART_LSR]      = 0x24,
-                [UART_MSR]      = 0x28,
-                [UART_SCR]      = 0x2c
-        },
-        regmap_out[8] = {
-                [UART_TX]       = 0x04,
-                [UART_IER]      = 0x0c,
-                [UART_FCR]      = 0x18,
-                [UART_LCR]      = 0x1c,
-                [UART_MCR]      = 0x20,
-                [UART_LSR]      = 0x24,
-                [UART_MSR]      = 0x28,
-                [UART_SCR]      = 0x2c
-        };
-
-static unsigned int rm9k_serial_in(struct uart_port *p, int offset)
-{
-        offset = regmap_in[offset] << p->regshift;
-        return readl(p->membase + offset);
-}
-
-static void rm9k_serial_out(struct uart_port *p, int offset, int value)
-{
-        offset = regmap_out[offset] << p->regshift;
-        writel(value, p->membase + offset);
-}
-
-static int rm9k_serial_dl_read(struct uart_8250_port *up)
-{
-        return ((__raw_readl(up->port.membase + 0x10) << 8) |
-                (__raw_readl(up->port.membase + 0x08) & 0xff)) & 0xffff;
-}
-
-static void rm9k_serial_dl_write(struct uart_8250_port *up, int value)
-{
-        __raw_writel(value, up->port.membase + 0x08);
-        __raw_writel(value >> 8, up->port.membase + 0x10);
-}
-
-#endif
-
 static unsigned int hub6_serial_in(struct uart_port *p, int offset)
 {
         offset = offset << p->regshift;
@@ -497,16 +440,7 @@ static void set_io_from_upio(struct uart_port *p)
                 p->serial_out = mem32_serial_out;
                 break;
 
-#ifdef CONFIG_SERIAL_8250_RM9K
-        case UPIO_RM9000:
-                p->serial_in = rm9k_serial_in;
-                p->serial_out = rm9k_serial_out;
-                up->dl_read = rm9k_serial_dl_read;
-                up->dl_write = rm9k_serial_dl_write;
-                break;
-#endif
-
-#ifdef CONFIG_MIPS_ALCHEMY
+#if defined(CONFIG_MIPS_ALCHEMY) || defined(CONFIG_SERIAL_8250_RT288X)
         case UPIO_AU:
                 p->serial_in = au_serial_in;
                 p->serial_out = au_serial_out;
@@ -1341,7 +1275,9 @@ static void serial8250_start_tx(struct uart_port *port)
         struct uart_8250_port *up =
                 container_of(port, struct uart_8250_port, port);
 
-        if (!(up->ier & UART_IER_THRI)) {
+        if (up->dma && !serial8250_tx_dma(up)) {
+                return;
+        } else if (!(up->ier & UART_IER_THRI)) {
                 up->ier |= UART_IER_THRI;
                 serial_port_out(port, UART_IER, up->ier);
 
@@ -1349,9 +1285,7 @@ static void serial8250_start_tx(struct uart_port *port)
                         unsigned char lsr;
                         lsr = serial_in(up, UART_LSR);
                         up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
-                        if ((port->type == PORT_RM9000) ?
-                                (lsr & UART_LSR_THRE) :
-                                (lsr & UART_LSR_TEMT))
+                        if (lsr & UART_LSR_TEMT)
                                 serial8250_tx_chars(up);
                 }
         }
@@ -1397,7 +1331,6 @@ unsigned char
 serial8250_rx_chars(struct uart_8250_port *up, unsigned char lsr)
 {
         struct uart_port *port = &up->port;
-        struct tty_struct *tty = port->state->port.tty;
         unsigned char ch;
         int max_count = 256;
         char flag;
@@ -1462,7 +1395,7 @@ ignore_char:
                 lsr = serial_in(up, UART_LSR);
         } while ((lsr & (UART_LSR_DR | UART_LSR_BI)) && (max_count-- > 0));
         spin_unlock(&port->lock);
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&port->state->port);
         spin_lock(&port->lock);
         return lsr;
 }
@@ -1547,6 +1480,7 @@ int serial8250_handle_irq(struct uart_port *port, unsigned int iir)
         unsigned long flags;
         struct uart_8250_port *up =
                 container_of(port, struct uart_8250_port, port);
+        int dma_err = 0;
 
         if (iir & UART_IIR_NO_INT)
                 return 0;
@@ -1557,8 +1491,13 @@ int serial8250_handle_irq(struct uart_port *port, unsigned int iir)
 
         DEBUG_INTR("status = %x...", status);
 
-        if (status & (UART_LSR_DR | UART_LSR_BI))
-                status = serial8250_rx_chars(up, status);
+        if (status & (UART_LSR_DR | UART_LSR_BI)) {
+                if (up->dma)
+                        dma_err = serial8250_rx_dma(up, iir);
+
+                if (!up->dma || dma_err)
+                        status = serial8250_rx_chars(up, status);
+        }
         serial8250_modem_status(up);
         if (status & UART_LSR_THRE)
                 serial8250_tx_chars(up);
@@ -1991,9 +1930,12 @@ static int serial8250_startup(struct uart_port *port)
         if (port->type == PORT_8250_CIR)
                 return -ENODEV;
 
-        port->fifosize = uart_config[up->port.type].fifo_size;
-        up->tx_loadsz = uart_config[up->port.type].tx_loadsz;
-        up->capabilities = uart_config[up->port.type].flags;
+        if (!port->fifosize)
+                port->fifosize = uart_config[port->type].fifo_size;
+        if (!up->tx_loadsz)
+                up->tx_loadsz = uart_config[port->type].tx_loadsz;
+        if (!up->capabilities)
+                up->capabilities = uart_config[port->type].flags;
         up->mcr = 0;
 
         if (port->iotype != up->cur_iotype)
@@ -2198,6 +2140,18 @@ dont_test_tx_en:
         up->msr_saved_flags = 0;
 
         /*
+         * Request DMA channels for both RX and TX.
+         */
+        if (up->dma) {
+                retval = serial8250_request_dma(up);
+                if (retval) {
+                        pr_warn_ratelimited("ttyS%d - failed to request DMA\n",
+                                            serial_index(port));
+                        up->dma = NULL;
+                }
+        }
+
+        /*
          * Finally, enable interrupts.  Note: Modem status interrupts
          * are set via set_termios(), which will be occurring imminently
          * anyway, so we don't enable them here.
@@ -2230,6 +2184,9 @@ static void serial8250_shutdown(struct uart_port *port)
         up->ier = 0;
         serial_port_out(port, UART_IER, 0);
 
+        if (up->dma)
+                serial8250_release_dma(up);
+
         spin_lock_irqsave(&port->lock, flags);
         if (port->flags & UPF_FOURPORT) {
                 /* reset interrupts on the AST Fourport board */
@@ -2826,9 +2783,12 @@ static void
 serial8250_init_fixed_type_port(struct uart_8250_port *up, unsigned int type)
 {
         up->port.type = type;
-        up->port.fifosize = uart_config[type].fifo_size;
-        up->capabilities = uart_config[type].flags;
-        up->tx_loadsz = uart_config[type].tx_loadsz;
+        if (!up->port.fifosize)
+                up->port.fifosize = uart_config[type].fifo_size;
+        if (!up->tx_loadsz)
+                up->tx_loadsz = uart_config[type].tx_loadsz;
+        if (!up->capabilities)
+                up->capabilities = uart_config[type].flags;
 }
 
 static void __init
@@ -3262,6 +3222,10 @@ int serial8250_register_8250_port(struct uart_8250_port *up)
                 uart->bugs              = up->bugs;
                 uart->port.mapbase      = up->port.mapbase;
                 uart->port.private_data = up->port.private_data;
+                uart->port.fifosize     = up->port.fifosize;
+                uart->tx_loadsz         = up->tx_loadsz;
+                uart->capabilities      = up->capabilities;
+
                 if (up->port.dev)
                         uart->port.dev = up->port.dev;
 
@@ -3287,6 +3251,8 @@ int serial8250_register_8250_port(struct uart_8250_port *up)
                         uart->dl_read = up->dl_read;
                 if (up->dl_write)
                         uart->dl_write = up->dl_write;
+                if (up->dma)
+                        uart->dma = up->dma;
 
                 if (serial8250_isa_config != NULL)
                         serial8250_isa_config(0, &uart->port,
diff --git a/drivers/tty/serial/8250/8250.h b/drivers/tty/serial/8250/8250.h
index 12caa1292b75..34eb676916fe 100644
--- a/drivers/tty/serial/8250/8250.h
+++ b/drivers/tty/serial/8250/8250.h
@@ -12,6 +12,35 @@
  */
 
 #include <linux/serial_8250.h>
+#include <linux/dmaengine.h>
+
+struct uart_8250_dma {
+        dma_filter_fn           fn;
+        void                    *rx_param;
+        void                    *tx_param;
+
+        int                     rx_chan_id;
+        int                     tx_chan_id;
+
+        struct dma_slave_config rxconf;
+        struct dma_slave_config txconf;
+
+        struct dma_chan         *rxchan;
+        struct dma_chan         *txchan;
+
+        dma_addr_t              rx_addr;
+        dma_addr_t              tx_addr;
+
+        dma_cookie_t            rx_cookie;
+        dma_cookie_t            tx_cookie;
+
+        void                    *rx_buf;
+
+        size_t                  rx_size;
+        size_t                  tx_size;
+
+        unsigned char           tx_running:1;
+};
 
 struct old_serial_port {
         unsigned int uart;
@@ -143,3 +172,24 @@ static inline int is_omap1510_8250(struct uart_8250_port *pt)
         return 0;
 }
 #endif
+
+#ifdef CONFIG_SERIAL_8250_DMA
+extern int serial8250_tx_dma(struct uart_8250_port *);
+extern int serial8250_rx_dma(struct uart_8250_port *, unsigned int iir);
+extern int serial8250_request_dma(struct uart_8250_port *);
+extern void serial8250_release_dma(struct uart_8250_port *);
+#else
+static inline int serial8250_tx_dma(struct uart_8250_port *p)
+{
+        return -1;
+}
+static inline int serial8250_rx_dma(struct uart_8250_port *p, unsigned int iir)
+{
+        return -1;
+}
+static inline int serial8250_request_dma(struct uart_8250_port *p)
+{
+        return -1;
+}
+static inline void serial8250_release_dma(struct uart_8250_port *p) { }
+#endif
diff --git a/drivers/tty/serial/8250/8250_dma.c b/drivers/tty/serial/8250/8250_dma.c
new file mode 100644
index 000000000000..b9f7fd28112e
--- /dev/null
+++ b/drivers/tty/serial/8250/8250_dma.c
@@ -0,0 +1,216 @@
+/*
+ * 8250_dma.c - DMA Engine API support for 8250.c
+ *
+ * Copyright (C) 2013 Intel Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+#include <linux/serial_reg.h>
+#include <linux/dma-mapping.h>
+
+#include "8250.h"
+
+static void __dma_tx_complete(void *param)
+{
+        struct uart_8250_port   *p = param;
+        struct uart_8250_dma    *dma = p->dma;
+        struct circ_buf         *xmit = &p->port.state->xmit;
+
+        dma->tx_running = 0;
+
+        dma_sync_single_for_cpu(dma->txchan->device->dev, dma->tx_addr,
+                                UART_XMIT_SIZE, DMA_TO_DEVICE);
+
+        xmit->tail += dma->tx_size;
+        xmit->tail &= UART_XMIT_SIZE - 1;
+        p->port.icount.tx += dma->tx_size;
+
+        if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
+                uart_write_wakeup(&p->port);
+
+        if (!uart_circ_empty(xmit) && !uart_tx_stopped(&p->port)) {
+                serial8250_tx_dma(p);
+                uart_write_wakeup(&p->port);
+        }
+}
+
+static void __dma_rx_complete(void *param)
+{
+        struct uart_8250_port   *p = param;
+        struct uart_8250_dma    *dma = p->dma;
+        struct tty_port         *tty_port = &p->port.state->port;
+        struct dma_tx_state     state;
+        int                     count;
+
+        dma_sync_single_for_cpu(dma->rxchan->device->dev, dma->rx_addr,
+                                dma->rx_size, DMA_FROM_DEVICE);
+
+        dmaengine_tx_status(dma->rxchan, dma->rx_cookie, &state);
+        dmaengine_terminate_all(dma->rxchan);
+
+        count = dma->rx_size - state.residue;
+
+        tty_insert_flip_string(tty_port, dma->rx_buf, count);
+        p->port.icount.rx += count;
+
+        tty_flip_buffer_push(tty_port);
+}
+
+int serial8250_tx_dma(struct uart_8250_port *p)
+{
+        struct uart_8250_dma            *dma = p->dma;
+        struct circ_buf                 *xmit = &p->port.state->xmit;
+        struct dma_async_tx_descriptor  *desc;
+
+        if (dma->tx_running)
+                return -EBUSY;
+
+        dma->tx_size = CIRC_CNT_TO_END(xmit->head, xmit->tail, UART_XMIT_SIZE);
+        if (!dma->tx_size)
+                return -EINVAL;
+
+        desc = dmaengine_prep_slave_single(dma->txchan,
+                                           dma->tx_addr + xmit->tail,
+                                           dma->tx_size, DMA_MEM_TO_DEV,
+                                           DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+        if (!desc)
+                return -EBUSY;
+
+        dma->tx_running = 1;
+
+        desc->callback = __dma_tx_complete;
+        desc->callback_param = p;
+
+        dma->tx_cookie = dmaengine_submit(desc);
+
+        dma_sync_single_for_device(dma->txchan->device->dev, dma->tx_addr,
+                                   UART_XMIT_SIZE, DMA_TO_DEVICE);
+
+        dma_async_issue_pending(dma->txchan);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(serial8250_tx_dma);
+
+int serial8250_rx_dma(struct uart_8250_port *p, unsigned int iir)
+{
+        struct uart_8250_dma            *dma = p->dma;
+        struct dma_async_tx_descriptor  *desc;
+        struct dma_tx_state             state;
+        int                             dma_status;
+
+        /*
+         * If RCVR FIFO trigger level was not reached, complete the transfer and
+         * let 8250.c copy the remaining data.
+         */
+        if ((iir & 0x3f) == UART_IIR_RX_TIMEOUT) {
+                dma_status = dmaengine_tx_status(dma->rxchan, dma->rx_cookie,
+                                                &state);
+                if (dma_status == DMA_IN_PROGRESS) {
+                        dmaengine_pause(dma->rxchan);
+                        __dma_rx_complete(p);
+                }
+                return -ETIMEDOUT;
+        }
+
+        desc = dmaengine_prep_slave_single(dma->rxchan, dma->rx_addr,
+                                           dma->rx_size, DMA_DEV_TO_MEM,
+                                           DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+        if (!desc)
+                return -EBUSY;
+
+        desc->callback = __dma_rx_complete;
+        desc->callback_param = p;
+
+        dma->rx_cookie = dmaengine_submit(desc);
+
+        dma_sync_single_for_device(dma->rxchan->device->dev, dma->rx_addr,
+                                   dma->rx_size, DMA_FROM_DEVICE);
+
+        dma_async_issue_pending(dma->rxchan);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(serial8250_rx_dma);
+
+int serial8250_request_dma(struct uart_8250_port *p)
+{
+        struct uart_8250_dma    *dma = p->dma;
+        dma_cap_mask_t          mask;
+
+        dma->rxconf.src_addr = p->port.mapbase + UART_RX;
+        dma->txconf.dst_addr = p->port.mapbase + UART_TX;
+
+        dma_cap_zero(mask);
+        dma_cap_set(DMA_SLAVE, mask);
+
+        /* Get a channel for RX */
+        dma->rxchan = dma_request_channel(mask, dma->fn, dma->rx_param);
+        if (!dma->rxchan)
+                return -ENODEV;
+
+        dmaengine_slave_config(dma->rxchan, &dma->rxconf);
+
+        /* Get a channel for TX */
+        dma->txchan = dma_request_channel(mask, dma->fn, dma->tx_param);
+        if (!dma->txchan) {
+                dma_release_channel(dma->rxchan);
+                return -ENODEV;
+        }
+
+        dmaengine_slave_config(dma->txchan, &dma->txconf);
+
+        /* RX buffer */
+        if (!dma->rx_size)
+                dma->rx_size = PAGE_SIZE;
+
+        dma->rx_buf = dma_alloc_coherent(dma->rxchan->device->dev, dma->rx_size,
+                                        &dma->rx_addr, GFP_KERNEL);
+        if (!dma->rx_buf) {
+                dma_release_channel(dma->rxchan);
+                dma_release_channel(dma->txchan);
+                return -ENOMEM;
+        }
+
+        /* TX buffer */
+        dma->tx_addr = dma_map_single(dma->txchan->device->dev,
+                                        p->port.state->xmit.buf,
+                                        UART_XMIT_SIZE,
+                                        DMA_TO_DEVICE);
+
+        dev_dbg_ratelimited(p->port.dev, "got both dma channels\n");
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(serial8250_request_dma);
+
+void serial8250_release_dma(struct uart_8250_port *p)
+{
+        struct uart_8250_dma *dma = p->dma;
+
+        if (!dma)
+                return;
+
+        /* Release RX resources */
+        dmaengine_terminate_all(dma->rxchan);
+        dma_free_coherent(dma->rxchan->device->dev, dma->rx_size, dma->rx_buf,
+                          dma->rx_addr);
+        dma_release_channel(dma->rxchan);
+        dma->rxchan = NULL;
+
+        /* Release TX resources */
+        dmaengine_terminate_all(dma->txchan);
+        dma_unmap_single(dma->txchan->device->dev, dma->tx_addr,
+                         UART_XMIT_SIZE, DMA_TO_DEVICE);
+        dma_release_channel(dma->txchan);
+        dma->txchan = NULL;
+        dma->tx_running = 0;
+
+        dev_dbg_ratelimited(p->port.dev, "dma channels released\n");
+}
+EXPORT_SYMBOL_GPL(serial8250_release_dma);
diff --git a/drivers/tty/serial/8250/8250_dw.c b/drivers/tty/serial/8250/8250_dw.c
index 096d2ef48b32..db0e66f6dd0e 100644
--- a/drivers/tty/serial/8250/8250_dw.c
+++ b/drivers/tty/serial/8250/8250_dw.c
@@ -2,6 +2,7 @@
  * Synopsys DesignWare 8250 driver.
  *
  * Copyright 2011 Picochip, Jamie Iles.
+ * Copyright 2013 Intel Corporation
  *
  * 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
@@ -24,6 +25,34 @@
 #include <linux/of_platform.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
+#include <linux/acpi.h>
+
+#include "8250.h"
+
+/* Offsets for the DesignWare specific registers */
+#define DW_UART_USR     0x1f /* UART Status Register */
+#define DW_UART_CPR     0xf4 /* Component Parameter Register */
+#define DW_UART_UCV     0xf8 /* UART Component Version */
+
+/* Intel Low Power Subsystem specific */
+#define LPSS_PRV_CLOCK_PARAMS 0x800
+
+/* Component Parameter Register bits */
+#define DW_UART_CPR_ABP_DATA_WIDTH      (3 << 0)
+#define DW_UART_CPR_AFCE_MODE           (1 << 4)
+#define DW_UART_CPR_THRE_MODE           (1 << 5)
+#define DW_UART_CPR_SIR_MODE            (1 << 6)
+#define DW_UART_CPR_SIR_LP_MODE         (1 << 7)
+#define DW_UART_CPR_ADDITIONAL_FEATURES (1 << 8)
+#define DW_UART_CPR_FIFO_ACCESS         (1 << 9)
+#define DW_UART_CPR_FIFO_STAT           (1 << 10)
+#define DW_UART_CPR_SHADOW              (1 << 11)
+#define DW_UART_CPR_ENCODED_PARMS       (1 << 12)
+#define DW_UART_CPR_DMA_EXTRA           (1 << 13)
+#define DW_UART_CPR_FIFO_MODE           (0xff << 16)
+/* Helper for fifo size calculation */
+#define DW_UART_CPR_FIFO_SIZE(a)        (((a >> 16) & 0xff) * 16)
+
 
 struct dw8250_data {
         int     last_lcr;
@@ -66,9 +95,6 @@ static unsigned int dw8250_serial_in32(struct uart_port *p, int offset)
         return readl(p->membase + offset);
 }
 
-/* Offset for the DesignWare's UART Status Register. */
-#define UART_USR        0x1f
-
 static int dw8250_handle_irq(struct uart_port *p)
 {
         struct dw8250_data *d = p->private_data;
@@ -78,7 +104,7 @@ static int dw8250_handle_irq(struct uart_port *p)
                 return 1;
         } else if ((iir & UART_IIR_BUSY) == UART_IIR_BUSY) {
                 /* Clear the USR and write the LCR again. */
-                (void)p->serial_in(p, UART_USR);
+                (void)p->serial_in(p, DW_UART_USR);
                 p->serial_out(p, UART_LCR, d->last_lcr);
 
                 return 1;
@@ -87,61 +113,210 @@ static int dw8250_handle_irq(struct uart_port *p)
         return 0;
 }
 
+static int dw8250_probe_of(struct uart_port *p)
+{
+        struct device_node      *np = p->dev->of_node;
+        u32                     val;
+
+        if (!of_property_read_u32(np, "reg-io-width", &val)) {
+                switch (val) {
+                case 1:
+                        break;
+                case 4:
+                        p->iotype = UPIO_MEM32;
+                        p->serial_in = dw8250_serial_in32;
+                        p->serial_out = dw8250_serial_out32;
+                        break;
+                default:
+                        dev_err(p->dev, "unsupported reg-io-width (%u)\n", val);
+                        return -EINVAL;
+                }
+        }
+
+        if (!of_property_read_u32(np, "reg-shift", &val))
+                p->regshift = val;
+
+        if (of_property_read_u32(np, "clock-frequency", &val)) {
+                dev_err(p->dev, "no clock-frequency property set\n");
+                return -EINVAL;
+        }
+        p->uartclk = val;
+
+        return 0;
+}
+
+#ifdef CONFIG_ACPI
+static bool dw8250_acpi_dma_filter(struct dma_chan *chan, void *parm)
+{
+        return chan->chan_id == *(int *)parm;
+}
+
+static acpi_status
+dw8250_acpi_walk_resource(struct acpi_resource *res, void *data)
+{
+        struct uart_port                *p = data;
+        struct uart_8250_port           *port;
+        struct uart_8250_dma            *dma;
+        struct acpi_resource_fixed_dma  *fixed_dma;
+        struct dma_slave_config         *slave;
+
+        port = container_of(p, struct uart_8250_port, port);
+
+        switch (res->type) {
+        case ACPI_RESOURCE_TYPE_FIXED_DMA:
+                fixed_dma = &res->data.fixed_dma;
+
+                /* TX comes first */
+                if (!port->dma) {
+                        dma = devm_kzalloc(p->dev, sizeof(*dma), GFP_KERNEL);
+                        if (!dma)
+                                return AE_NO_MEMORY;
+
+                        port->dma = dma;
+                        slave = &dma->txconf;
+
+                        slave->direction        = DMA_MEM_TO_DEV;
+                        slave->dst_addr_width   = DMA_SLAVE_BUSWIDTH_1_BYTE;
+                        slave->slave_id         = fixed_dma->request_lines;
+                        slave->dst_maxburst     = port->tx_loadsz / 4;
+
+                        dma->tx_chan_id         = fixed_dma->channels;
+                        dma->tx_param           = &dma->tx_chan_id;
+                        dma->fn                 = dw8250_acpi_dma_filter;
+                } else {
+                        dma = port->dma;
+                        slave = &dma->rxconf;
+
+                        slave->direction        = DMA_DEV_TO_MEM;
+                        slave->src_addr_width   = DMA_SLAVE_BUSWIDTH_1_BYTE;
+                        slave->slave_id         = fixed_dma->request_lines;
+                        slave->src_maxburst     = p->fifosize / 4;
+
+                        dma->rx_chan_id         = fixed_dma->channels;
+                        dma->rx_param           = &dma->rx_chan_id;
+                }
+
+                break;
+        }
+
+        return AE_OK;
+}
+
+static int dw8250_probe_acpi(struct uart_port *p)
+{
+        const struct acpi_device_id *id;
+        acpi_status status;
+        u32 reg;
+
+        id = acpi_match_device(p->dev->driver->acpi_match_table, p->dev);
+        if (!id)
+                return -ENODEV;
+
+        p->iotype = UPIO_MEM32;
+        p->serial_in = dw8250_serial_in32;
+        p->serial_out = dw8250_serial_out32;
+        p->regshift = 2;
+        p->uartclk = (unsigned int)id->driver_data;
+
+        status = acpi_walk_resources(ACPI_HANDLE(p->dev), METHOD_NAME__CRS,
+                                     dw8250_acpi_walk_resource, p);
+        if (ACPI_FAILURE(status)) {
+                dev_err_ratelimited(p->dev, "%s failed \"%s\"\n", __func__,
+                                    acpi_format_exception(status));
+                return -ENODEV;
+        }
+
+        /* Fix Haswell issue where the clocks do not get enabled */
+        if (!strcmp(id->id, "INT33C4") || !strcmp(id->id, "INT33C5")) {
+                reg = readl(p->membase + LPSS_PRV_CLOCK_PARAMS);
+                writel(reg | 1, p->membase + LPSS_PRV_CLOCK_PARAMS);
+        }
+
+        return 0;
+}
+#else
+static inline int dw8250_probe_acpi(struct uart_port *p)
+{
+        return -ENODEV;
+}
+#endif /* CONFIG_ACPI */
+
+static void dw8250_setup_port(struct uart_8250_port *up)
+{
+        struct uart_port        *p = &up->port;
+        u32                     reg = readl(p->membase + DW_UART_UCV);
+
+        /*
+         * If the Component Version Register returns zero, we know that
+         * ADDITIONAL_FEATURES are not enabled. No need to go any further.
+         */
+        if (!reg)
+                return;
+
+        dev_dbg_ratelimited(p->dev, "Designware UART version %c.%c%c\n",
+                (reg >> 24) & 0xff, (reg >> 16) & 0xff, (reg >> 8) & 0xff);
+
+        reg = readl(p->membase + DW_UART_CPR);
+        if (!reg)
+                return;
+
+        /* Select the type based on fifo */
+        if (reg & DW_UART_CPR_FIFO_MODE) {
+                p->type = PORT_16550A;
+                p->flags |= UPF_FIXED_TYPE;
+                p->fifosize = DW_UART_CPR_FIFO_SIZE(reg);
+                up->tx_loadsz = p->fifosize;
+        }
+}
+
 static int dw8250_probe(struct platform_device *pdev)
 {
         struct uart_8250_port uart = {};
         struct resource *regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         struct resource *irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
-        struct device_node *np = pdev->dev.of_node;
-        u32 val;
         struct dw8250_data *data;
+        int err;
 
         if (!regs || !irq) {
                 dev_err(&pdev->dev, "no registers/irq defined\n");
                 return -EINVAL;
         }
 
-        data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
-        if (!data)
-                return -ENOMEM;
-        uart.port.private_data = data;
-
         spin_lock_init(&uart.port.lock);
         uart.port.mapbase = regs->start;
         uart.port.irq = irq->start;
         uart.port.handle_irq = dw8250_handle_irq;
         uart.port.type = PORT_8250;
-        uart.port.flags = UPF_SHARE_IRQ | UPF_BOOT_AUTOCONF | UPF_IOREMAP |
-                UPF_FIXED_PORT | UPF_FIXED_TYPE;
+        uart.port.flags = UPF_SHARE_IRQ | UPF_BOOT_AUTOCONF | UPF_FIXED_PORT;
         uart.port.dev = &pdev->dev;
 
+        uart.port.membase = ioremap(regs->start, resource_size(regs));
+        if (!uart.port.membase)
+                return -ENOMEM;
+
         uart.port.iotype = UPIO_MEM;
         uart.port.serial_in = dw8250_serial_in;
         uart.port.serial_out = dw8250_serial_out;
-        if (!of_property_read_u32(np, "reg-io-width", &val)) {
-                switch (val) {
-                case 1:
-                        break;
-                case 4:
-                        uart.port.iotype = UPIO_MEM32;
-                        uart.port.serial_in = dw8250_serial_in32;
-                        uart.port.serial_out = dw8250_serial_out32;
-                        break;
-                default:
-                        dev_err(&pdev->dev, "unsupported reg-io-width (%u)\n",
-                                val);
-                        return -EINVAL;
-                }
+
+        dw8250_setup_port(&uart);
+
+        if (pdev->dev.of_node) {
+                err = dw8250_probe_of(&uart.port);
+                if (err)
+                        return err;
+        } else if (ACPI_HANDLE(&pdev->dev)) {
+                err = dw8250_probe_acpi(&uart.port);
+                if (err)
+                        return err;
+        } else {
+                return -ENODEV;
         }
 
-        if (!of_property_read_u32(np, "reg-shift", &val))
-                uart.port.regshift = val;
+        data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
 
-        if (of_property_read_u32(np, "clock-frequency", &val)) {
-                dev_err(&pdev->dev, "no clock-frequency property set\n");
-                return -EINVAL;
-        }
-        uart.port.uartclk = val;
+        uart.port.private_data = data;
 
         data->line = serial8250_register_8250_port(&uart);
         if (data->line < 0)
@@ -184,17 +359,25 @@ static int dw8250_resume(struct platform_device *pdev)
 #define dw8250_resume NULL
 #endif /* CONFIG_PM */
 
-static const struct of_device_id dw8250_match[] = {
+static const struct of_device_id dw8250_of_match[] = {
         { .compatible = "snps,dw-apb-uart" },
         { /* Sentinel */ }
 };
-MODULE_DEVICE_TABLE(of, dw8250_match);
+MODULE_DEVICE_TABLE(of, dw8250_of_match);
+
+static const struct acpi_device_id dw8250_acpi_match[] = {
+        { "INT33C4", 100000000 },
+        { "INT33C5", 100000000 },
+        { },
+};
+MODULE_DEVICE_TABLE(acpi, dw8250_acpi_match);
 
 static struct platform_driver dw8250_platform_driver = {
         .driver = {
                 .name           = "dw-apb-uart",
                 .owner          = THIS_MODULE,
-                .of_match_table = dw8250_match,
+                .of_match_table = dw8250_of_match,
+                .acpi_match_table = ACPI_PTR(dw8250_acpi_match),
         },
         .probe                  = dw8250_probe,
         .remove                 = dw8250_remove,
diff --git a/drivers/tty/serial/8250/8250_early.c b/drivers/tty/serial/8250/8250_early.c
index f53a7db4350d..721904f8efa9 100644
--- a/drivers/tty/serial/8250/8250_early.c
+++ b/drivers/tty/serial/8250/8250_early.c
@@ -194,7 +194,7 @@ static int __init parse_options(struct early_serial8250_device *device,
                 options++;
                 device->baud = simple_strtoul(options, NULL, 0);
                 length = min(strcspn(options, " "), sizeof(device->options));
-                strncpy(device->options, options, length);
+                strlcpy(device->options, options, length);
         } else {
                 device->baud = probe_baud(port);
                 snprintf(device->options, sizeof(device->options), "%u",
diff --git a/drivers/tty/serial/8250/8250_pci.c b/drivers/tty/serial/8250/8250_pci.c
index a27a98e1b066..791c5a77ec61 100644
--- a/drivers/tty/serial/8250/8250_pci.c
+++ b/drivers/tty/serial/8250/8250_pci.c
@@ -1040,6 +1040,253 @@ static int pci_asix_setup(struct serial_private *priv,
         return pci_default_setup(priv, board, port, idx);
 }
 
+/* Quatech devices have their own extra interface features */
+
+struct quatech_feature {
+        u16 devid;
+        bool amcc;
+};
+
+#define QPCR_TEST_FOR1          0x3F
+#define QPCR_TEST_GET1          0x00
+#define QPCR_TEST_FOR2          0x40
+#define QPCR_TEST_GET2          0x40
+#define QPCR_TEST_FOR3          0x80
+#define QPCR_TEST_GET3          0x40
+#define QPCR_TEST_FOR4          0xC0
+#define QPCR_TEST_GET4          0x80
+
+#define QOPR_CLOCK_X1           0x0000
+#define QOPR_CLOCK_X2           0x0001
+#define QOPR_CLOCK_X4           0x0002
+#define QOPR_CLOCK_X8           0x0003
+#define QOPR_CLOCK_RATE_MASK    0x0003
+
+
+static struct quatech_feature quatech_cards[] = {
+        { PCI_DEVICE_ID_QUATECH_QSC100,   1 },
+        { PCI_DEVICE_ID_QUATECH_DSC100,   1 },
+        { PCI_DEVICE_ID_QUATECH_DSC100E,  0 },
+        { PCI_DEVICE_ID_QUATECH_DSC200,   1 },
+        { PCI_DEVICE_ID_QUATECH_DSC200E,  0 },
+        { PCI_DEVICE_ID_QUATECH_ESC100D,  1 },
+        { PCI_DEVICE_ID_QUATECH_ESC100M,  1 },
+        { PCI_DEVICE_ID_QUATECH_QSCP100,  1 },
+        { PCI_DEVICE_ID_QUATECH_DSCP100,  1 },
+        { PCI_DEVICE_ID_QUATECH_QSCP200,  1 },
+        { PCI_DEVICE_ID_QUATECH_DSCP200,  1 },
+        { PCI_DEVICE_ID_QUATECH_ESCLP100, 0 },
+        { PCI_DEVICE_ID_QUATECH_QSCLP100, 0 },
+        { PCI_DEVICE_ID_QUATECH_DSCLP100, 0 },
+        { PCI_DEVICE_ID_QUATECH_SSCLP100, 0 },
+        { PCI_DEVICE_ID_QUATECH_QSCLP200, 0 },
+        { PCI_DEVICE_ID_QUATECH_DSCLP200, 0 },
+        { PCI_DEVICE_ID_QUATECH_SSCLP200, 0 },
+        { PCI_DEVICE_ID_QUATECH_SPPXP_100, 0 },
+        { 0, }
+};
+
+static int pci_quatech_amcc(u16 devid)
+{
+        struct quatech_feature *qf = &quatech_cards[0];
+        while (qf->devid) {
+                if (qf->devid == devid)
+                        return qf->amcc;
+                qf++;
+        }
+        pr_err("quatech: unknown port type '0x%04X'.\n", devid);
+        return 0;
+};
+
+static int pci_quatech_rqopr(struct uart_8250_port *port)
+{
+        unsigned long base = port->port.iobase;
+        u8 LCR, val;
+
+        LCR = inb(base + UART_LCR);
+        outb(0xBF, base + UART_LCR);
+        val = inb(base + UART_SCR);
+        outb(LCR, base + UART_LCR);
+        return val;
+}
+
+static void pci_quatech_wqopr(struct uart_8250_port *port, u8 qopr)
+{
+        unsigned long base = port->port.iobase;
+        u8 LCR, val;
+
+        LCR = inb(base + UART_LCR);
+        outb(0xBF, base + UART_LCR);
+        val = inb(base + UART_SCR);
+        outb(qopr, base + UART_SCR);
+        outb(LCR, base + UART_LCR);
+}
+
+static int pci_quatech_rqmcr(struct uart_8250_port *port)
+{
+        unsigned long base = port->port.iobase;
+        u8 LCR, val, qmcr;
+
+        LCR = inb(base + UART_LCR);
+        outb(0xBF, base + UART_LCR);
+        val = inb(base + UART_SCR);
+        outb(val | 0x10, base + UART_SCR);
+        qmcr = inb(base + UART_MCR);
+        outb(val, base + UART_SCR);
+        outb(LCR, base + UART_LCR);
+
+        return qmcr;
+}
+
+static void pci_quatech_wqmcr(struct uart_8250_port *port, u8 qmcr)
+{
+        unsigned long base = port->port.iobase;
+        u8 LCR, val;
+
+        LCR = inb(base + UART_LCR);
+        outb(0xBF, base + UART_LCR);
+        val = inb(base + UART_SCR);
+        outb(val | 0x10, base + UART_SCR);
+        outb(qmcr, base + UART_MCR);
+        outb(val, base + UART_SCR);
+        outb(LCR, base + UART_LCR);
+}
+
+static int pci_quatech_has_qmcr(struct uart_8250_port *port)
+{
+        unsigned long base = port->port.iobase;
+        u8 LCR, val;
+
+        LCR = inb(base + UART_LCR);
+        outb(0xBF, base + UART_LCR);
+        val = inb(base + UART_SCR);
+        if (val & 0x20) {
+                outb(0x80, UART_LCR);
+                if (!(inb(UART_SCR) & 0x20)) {
+                        outb(LCR, base + UART_LCR);
+                        return 1;
+                }
+        }
+        return 0;
+}
+
+static int pci_quatech_test(struct uart_8250_port *port)
+{
+        u8 reg;
+        u8 qopr = pci_quatech_rqopr(port);
+        pci_quatech_wqopr(port, qopr & QPCR_TEST_FOR1);
+        reg = pci_quatech_rqopr(port) & 0xC0;
+        if (reg != QPCR_TEST_GET1)
+                return -EINVAL;
+        pci_quatech_wqopr(port, (qopr & QPCR_TEST_FOR1)|QPCR_TEST_FOR2);
+        reg = pci_quatech_rqopr(port) & 0xC0;
+        if (reg != QPCR_TEST_GET2)
+                return -EINVAL;
+        pci_quatech_wqopr(port, (qopr & QPCR_TEST_FOR1)|QPCR_TEST_FOR3);
+        reg = pci_quatech_rqopr(port) & 0xC0;
+        if (reg != QPCR_TEST_GET3)
+                return -EINVAL;
+        pci_quatech_wqopr(port, (qopr & QPCR_TEST_FOR1)|QPCR_TEST_FOR4);
+        reg = pci_quatech_rqopr(port) & 0xC0;
+        if (reg != QPCR_TEST_GET4)
+                return -EINVAL;
+
+        pci_quatech_wqopr(port, qopr);
+        return 0;
+}
+
+static int pci_quatech_clock(struct uart_8250_port *port)
+{
+        u8 qopr, reg, set;
+        unsigned long clock;
+
+        if (pci_quatech_test(port) < 0)
+                return 1843200;
+
+        qopr = pci_quatech_rqopr(port);
+
+        pci_quatech_wqopr(port, qopr & ~QOPR_CLOCK_X8);
+        reg = pci_quatech_rqopr(port);
+        if (reg & QOPR_CLOCK_X8) {
+                clock = 1843200;
+                goto out;
+        }
+        pci_quatech_wqopr(port, qopr | QOPR_CLOCK_X8);
+        reg = pci_quatech_rqopr(port);
+        if (!(reg & QOPR_CLOCK_X8)) {
+                clock = 1843200;
+                goto out;
+        }
+        reg &= QOPR_CLOCK_X8;
+        if (reg == QOPR_CLOCK_X2) {
+                clock =  3685400;
+                set = QOPR_CLOCK_X2;
+        } else if (reg == QOPR_CLOCK_X4) {
+                clock = 7372800;
+                set = QOPR_CLOCK_X4;
+        } else if (reg == QOPR_CLOCK_X8) {
+                clock = 14745600;
+                set = QOPR_CLOCK_X8;
+        } else {
+                clock = 1843200;
+                set = QOPR_CLOCK_X1;
+        }
+        qopr &= ~QOPR_CLOCK_RATE_MASK;
+        qopr |= set;
+
+out:
+        pci_quatech_wqopr(port, qopr);
+        return clock;
+}
+
+static int pci_quatech_rs422(struct uart_8250_port *port)
+{
+        u8 qmcr;
+        int rs422 = 0;
+
+        if (!pci_quatech_has_qmcr(port))
+                return 0;
+        qmcr = pci_quatech_rqmcr(port);
+        pci_quatech_wqmcr(port, 0xFF);
+        if (pci_quatech_rqmcr(port))
+                rs422 = 1;
+        pci_quatech_wqmcr(port, qmcr);
+        return rs422;
+}
+
+static int pci_quatech_init(struct pci_dev *dev)
+{
+        if (pci_quatech_amcc(dev->device)) {
+                unsigned long base = pci_resource_start(dev, 0);
+                if (base) {
+                        u32 tmp;
+                        outl(inl(base + 0x38), base + 0x38);
+                        tmp = inl(base + 0x3c);
+                        outl(tmp | 0x01000000, base + 0x3c);
+                        outl(tmp, base + 0x3c);
+                }
+        }
+        return 0;
+}
+
+static int pci_quatech_setup(struct serial_private *priv,
+                  const struct pciserial_board *board,
+                  struct uart_8250_port *port, int idx)
+{
+        /* Needed by pci_quatech calls below */
+        port->port.iobase = pci_resource_start(priv->dev, FL_GET_BASE(board->flags));
+        /* Set up the clocking */
+        port->port.uartclk = pci_quatech_clock(port);
+        /* For now just warn about RS422 */
+        if (pci_quatech_rs422(port))
+                pr_warn("quatech: software control of RS422 features not currently supported.\n");
+        return pci_default_setup(priv, board, port, idx);
+}
+
+static void pci_quatech_exit(struct pci_dev *dev)
+{
+}
+
 static int pci_default_setup(struct serial_private *priv,
                   const struct pciserial_board *board,
                   struct uart_8250_port *port, int idx)
@@ -1318,6 +1565,9 @@ pci_wch_ch353_setup(struct serial_private *priv,
 #define PCI_DEVICE_ID_COMMTECH_4222PCIE 0x0022
 #define PCI_DEVICE_ID_BROADCOM_TRUMANAGE 0x160a
 
+#define PCI_VENDOR_ID_SUNIX             0x1fd4
+#define PCI_DEVICE_ID_SUNIX_1999        0x1999
+
 
 /* Unknown vendors/cards - this should not be in linux/pci_ids.h */
 #define PCI_SUBDEVICE_ID_UNKNOWN_0x1584 0x1584
@@ -1541,6 +1791,16 @@ static struct pci_serial_quirk pci_serial_quirks[] __refdata = {
                 .setup          = pci_ni8430_setup,
                 .exit           = pci_ni8430_exit,
         },
+        /* Quatech */
+        {
+                .vendor         = PCI_VENDOR_ID_QUATECH,
+                .device         = PCI_ANY_ID,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
+                .init           = pci_quatech_init,
+                .setup          = pci_quatech_setup,
+                .exit           = pci_quatech_exit,
+        },
         /*
          * Panacom
          */
@@ -1704,6 +1964,23 @@ static struct pci_serial_quirk pci_serial_quirks[] __refdata = {
                 .setup          = pci_timedia_setup,
         },
         /*
+         * SUNIX (Timedia) cards
+         * Do not "probe" for these cards as there is at least one combination
+         * card that should be handled by parport_pc that doesn't match the
+         * rule in pci_timedia_probe.
+         * It is part number is MIO5079A but its subdevice ID is 0x0102.
+         * There are some boards with part number SER5037AL that report
+         * subdevice ID 0x0002.
+         */
+        {
+                .vendor         = PCI_VENDOR_ID_SUNIX,
+                .device         = PCI_DEVICE_ID_SUNIX_1999,
+                .subvendor      = PCI_VENDOR_ID_SUNIX,
+                .subdevice      = PCI_ANY_ID,
+                .init           = pci_timedia_init,
+                .setup          = pci_timedia_setup,
+        },
+        /*
          * Exar cards
          */
         {
@@ -3506,18 +3783,70 @@ static struct pci_device_id serial_pci_tbl[] = {
         {       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_ROMULUS,
                 0x10b5, 0x106a, 0, 0,
                 pbn_plx_romulus },
+        /*
+         * Quatech cards. These actually have configurable clocks but for
+         * now we just use the default.
+         *
+         * 100 series are RS232, 200 series RS422,
+         */
         {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_QSC100,
                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
                 pbn_b1_4_115200 },
         {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSC100,
                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
                 pbn_b1_2_115200 },
+        {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSC100E,
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b2_2_115200 },
+        {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSC200,
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b1_2_115200 },
+        {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSC200E,
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b2_2_115200 },
+        {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_QSC200,
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b1_4_115200 },
         {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_ESC100D,
                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
                 pbn_b1_8_115200 },
         {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_ESC100M,
                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
                 pbn_b1_8_115200 },
+        {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_QSCP100,
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b1_4_115200 },
+        {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSCP100,
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b1_2_115200 },
+        {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_QSCP200,
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b1_4_115200 },
+        {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSCP200,
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b1_2_115200 },
+        {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_QSCLP100,
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b2_4_115200 },
+        {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSCLP100,
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b2_2_115200 },
+        {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_SSCLP100,
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b2_1_115200 },
+        {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_QSCLP200,
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b2_4_115200 },
+        {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSCLP200,
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b2_2_115200 },
+        {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_SSCLP200,
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b2_1_115200 },
+        {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_ESCLP100,
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b0_8_115200 },
+
         {       PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_OXSEMI_16PCI954,
                 PCI_VENDOR_ID_SPECIALIX, PCI_SUBDEVICE_ID_SPECIALIX_SPEED4,
                 0, 0,
@@ -3902,6 +4231,19 @@ static struct pci_device_id serial_pci_tbl[] = {
                 pbn_b0_bt_1_921600 },
 
         /*
+         * SUNIX (TIMEDIA)
+         */
+        {       PCI_VENDOR_ID_SUNIX, PCI_DEVICE_ID_SUNIX_1999,
+                PCI_VENDOR_ID_SUNIX, PCI_ANY_ID,
+                PCI_CLASS_COMMUNICATION_SERIAL << 8, 0xffff00,
+                pbn_b0_bt_1_921600 },
+
+        {       PCI_VENDOR_ID_SUNIX, PCI_DEVICE_ID_SUNIX_1999,
+                PCI_VENDOR_ID_SUNIX, PCI_ANY_ID,
+                PCI_CLASS_COMMUNICATION_MULTISERIAL << 8, 0xffff00,
+                pbn_b0_bt_1_921600 },
+
+        /*
          * AFAVLAB serial card, from Harald Welte <laforge@gnumonks.org>
          */
         {       PCI_VENDOR_ID_AFAVLAB, PCI_DEVICE_ID_AFAVLAB_P028,
diff --git a/drivers/tty/serial/8250/Kconfig b/drivers/tty/serial/8250/Kconfig
index c31133a6ea8e..2ef9537bcb2c 100644
--- a/drivers/tty/serial/8250/Kconfig
+++ b/drivers/tty/serial/8250/Kconfig
@@ -84,6 +84,14 @@ config SERIAL_8250_GSC
         depends on SERIAL_8250 && GSC
         default SERIAL_8250
 
+config SERIAL_8250_DMA
+        bool "DMA support for 16550 compatible UART controllers" if EXPERT
+        depends on SERIAL_8250 && DMADEVICES=y
+        default SERIAL_8250
+        help
+          This builds DMA support that can be used with 8250/16650
+          compatible UART controllers that support DMA signaling.
+
 config SERIAL_8250_PCI
         tristate "8250/16550 PCI device support" if EXPERT
         depends on SERIAL_8250 && PCI
@@ -249,15 +257,6 @@ config SERIAL_8250_ACORN
           system, say Y to this option.  The driver can handle 1, 2, or 3 port
           cards.  If unsure, say N.
 
-config SERIAL_8250_RM9K
-        bool "Support for MIPS RM9xxx integrated serial port"
-        depends on SERIAL_8250 != n && SERIAL_RM9000
-        select SERIAL_8250_SHARE_IRQ
-        help
-          Selecting this option will add support for the integrated serial
-          port hardware found on MIPS RM9122 and similar processors.
-          If unsure, say N.
-
 config SERIAL_8250_FSL
         bool
         depends on SERIAL_8250_CONSOLE && PPC_UDBG_16550
@@ -265,7 +264,7 @@ config SERIAL_8250_FSL
 
 config SERIAL_8250_DW
         tristate "Support for Synopsys DesignWare 8250 quirks"
-        depends on SERIAL_8250 && OF
+        depends on SERIAL_8250
         help
           Selecting this option will enable handling of the extra features
           present in the Synopsys DesignWare APB UART.
@@ -277,3 +276,11 @@ config SERIAL_8250_EM
           Selecting this option will add support for the integrated serial
           port hardware found on the Emma Mobile line of processors.
           If unsure, say N.
+
+config SERIAL_8250_RT288X
+        bool "Ralink RT288x/RT305x/RT3662/RT3883 serial port support"
+        depends on SERIAL_8250 && (SOC_RT288X || SOC_RT305X || SOC_RT3883)
+        help
+          If you have a Ralink RT288x/RT305x SoC based board and want to use the
+          serial port, say Y to this option. The driver can handle up to 2 serial
+          ports. If unsure, say N.
diff --git a/drivers/tty/serial/8250/Makefile b/drivers/tty/serial/8250/Makefile
index 108fe7fe13e2..a23838a4d535 100644
--- a/drivers/tty/serial/8250/Makefile
+++ b/drivers/tty/serial/8250/Makefile
@@ -5,6 +5,7 @@
 obj-$(CONFIG_SERIAL_8250)               += 8250_core.o
 8250_core-y                             := 8250.o
 8250_core-$(CONFIG_SERIAL_8250_PNP)     += 8250_pnp.o
+8250_core-$(CONFIG_SERIAL_8250_DMA)     += 8250_dma.o
 obj-$(CONFIG_SERIAL_8250_GSC)           += 8250_gsc.o
 obj-$(CONFIG_SERIAL_8250_PCI)           += 8250_pci.o
 obj-$(CONFIG_SERIAL_8250_HP300)         += 8250_hp300.o
diff --git a/drivers/tty/serial/Kconfig b/drivers/tty/serial/Kconfig
index 59c23d038106..a0162cbf0557 100644
--- a/drivers/tty/serial/Kconfig
+++ b/drivers/tty/serial/Kconfig
@@ -2,8 +2,10 @@
 # Serial device configuration
 #
 
+if TTY
+
 menu "Serial drivers"
-        depends on HAS_IOMEM
+        depends on HAS_IOMEM && GENERIC_HARDIRQS
 
 source "drivers/tty/serial/8250/Kconfig"
 
@@ -269,6 +271,17 @@ config SERIAL_SIRFSOC_CONSOLE
           your boot loader about how to pass options to the kernel at
           boot time.)
 
+config SERIAL_TEGRA
+        tristate "NVIDIA Tegra20/30 SoC serial controller"
+        depends on ARCH_TEGRA && TEGRA20_APB_DMA
+        select SERIAL_CORE
+        help
+          Support for the on-chip UARTs on the NVIDIA Tegra series SOCs
+          providing /dev/ttyHS0, 1, 2, 3 and 4 (note, some machines may not
+          provide all of these ports, depending on how the serial port
+          are enabled). This driver uses the APB DMA to achieve higher baudrate
+          and better performance.
+
 config SERIAL_MAX3100
         tristate "MAX3100 support"
         depends on SPI
@@ -1447,4 +1460,30 @@ config SERIAL_ARC_NR_PORTS
           Set this to the number of serial ports you want the driver
           to support.
 
+config SERIAL_RP2
+        tristate "Comtrol RocketPort EXPRESS/INFINITY support"
+        depends on PCI
+        select SERIAL_CORE
+        help
+          This driver supports the Comtrol RocketPort EXPRESS and
+          RocketPort INFINITY families of PCI/PCIe multiport serial adapters.
+          These adapters use a "RocketPort 2" ASIC that is not compatible
+          with the original RocketPort driver (CONFIG_ROCKETPORT).
+
+          To compile this driver as a module, choose M here: the
+          module will be called rp2.
+
+          If you want to compile this driver into the kernel, say Y here.  If
+          you don't have a suitable RocketPort card installed, say N.
+
+config SERIAL_RP2_NR_UARTS
+        int "Maximum number of RocketPort EXPRESS/INFINITY ports"
+        depends on SERIAL_RP2
+        default "32"
+        help
+          If multiple cards are present, the default limit of 32 ports may
+          need to be increased.
+
 endmenu
+
+endif # TTY
diff --git a/drivers/tty/serial/Makefile b/drivers/tty/serial/Makefile
index df1b998c436b..eedfec40e3dd 100644
--- a/drivers/tty/serial/Makefile
+++ b/drivers/tty/serial/Makefile
@@ -80,6 +80,8 @@ obj-$(CONFIG_SERIAL_MXS_AUART) += mxs-auart.o
 obj-$(CONFIG_SERIAL_LANTIQ)     += lantiq.o
 obj-$(CONFIG_SERIAL_XILINX_PS_UART) += xilinx_uartps.o
 obj-$(CONFIG_SERIAL_SIRFSOC) += sirfsoc_uart.o
+obj-$(CONFIG_SERIAL_TEGRA) += serial-tegra.o
 obj-$(CONFIG_SERIAL_AR933X)   += ar933x_uart.o
 obj-$(CONFIG_SERIAL_EFM32_UART) += efm32-uart.o
 obj-$(CONFIG_SERIAL_ARC)        += arc_uart.o
+obj-$(CONFIG_SERIAL_RP2)        += rp2.o
diff --git a/drivers/tty/serial/altera_jtaguart.c b/drivers/tty/serial/altera_jtaguart.c
index 872f14ae43d2..c6bdb943726b 100644
--- a/drivers/tty/serial/altera_jtaguart.c
+++ b/drivers/tty/serial/altera_jtaguart.c
@@ -139,7 +139,7 @@ static void altera_jtaguart_rx_chars(struct altera_jtaguart *pp)
                 uart_insert_char(port, 0, 0, ch, flag);
         }
 
-        tty_flip_buffer_push(port->state->port.tty);
+        tty_flip_buffer_push(&port->state->port);
 }
 
 static void altera_jtaguart_tx_chars(struct altera_jtaguart *pp)
@@ -493,11 +493,9 @@ static int __init altera_jtaguart_init(void)
         if (rc)
                 return rc;
         rc = platform_driver_register(&altera_jtaguart_platform_driver);
-        if (rc) {
+        if (rc)
                 uart_unregister_driver(&altera_jtaguart_driver);
-                return rc;
-        }
-        return 0;
+        return rc;
 }
 
 static void __exit altera_jtaguart_exit(void)
diff --git a/drivers/tty/serial/altera_uart.c b/drivers/tty/serial/altera_uart.c
index 684a0808e1c7..13471dd95793 100644
--- a/drivers/tty/serial/altera_uart.c
+++ b/drivers/tty/serial/altera_uart.c
@@ -231,7 +231,7 @@ static void altera_uart_rx_chars(struct altera_uart *pp)
                                  flag);
         }
 
-        tty_flip_buffer_push(port->state->port.tty);
+        tty_flip_buffer_push(&port->state->port);
 }
 
 static void altera_uart_tx_chars(struct altera_uart *pp)
@@ -637,11 +637,9 @@ static int __init altera_uart_init(void)
         if (rc)
                 return rc;
         rc = platform_driver_register(&altera_uart_platform_driver);
-        if (rc) {
+        if (rc)
                 uart_unregister_driver(&altera_uart_driver);
-                return rc;
-        }
-        return 0;
+        return rc;
 }
 
 static void __exit altera_uart_exit(void)
diff --git a/drivers/tty/serial/amba-pl010.c b/drivers/tty/serial/amba-pl010.c
index 22317dd16474..c36840519527 100644
--- a/drivers/tty/serial/amba-pl010.c
+++ b/drivers/tty/serial/amba-pl010.c
@@ -116,7 +116,6 @@ 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.state->port.tty;
         unsigned int status, ch, flag, rsr, max_count = 256;
 
         status = readb(uap->port.membase + UART01x_FR);
@@ -165,7 +164,7 @@ static void pl010_rx_chars(struct uart_amba_port *uap)
                 status = readb(uap->port.membase + UART01x_FR);
         }
         spin_unlock(&uap->port.lock);
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&uap->port.state->port);
         spin_lock(&uap->port.lock);
 }
 
diff --git a/drivers/tty/serial/amba-pl011.c b/drivers/tty/serial/amba-pl011.c
index 7fca4022a8b2..3ea5408fcbeb 100644
--- a/drivers/tty/serial/amba-pl011.c
+++ b/drivers/tty/serial/amba-pl011.c
@@ -698,7 +698,7 @@ static void pl011_dma_rx_chars(struct uart_amba_port *uap,
                                u32 pending, bool use_buf_b,
                                bool readfifo)
 {
-        struct tty_struct *tty = uap->port.state->port.tty;
+        struct tty_port *port = &uap->port.state->port;
         struct pl011_sgbuf *sgbuf = use_buf_b ?
                 &uap->dmarx.sgbuf_b : &uap->dmarx.sgbuf_a;
         struct device *dev = uap->dmarx.chan->device->dev;
@@ -715,8 +715,7 @@ static void pl011_dma_rx_chars(struct uart_amba_port *uap,
                  * Note that tty_insert_flip_buf() tries to take as many chars
                  * as it can.
                  */
-                dma_count = tty_insert_flip_string(uap->port.state->port.tty,
-                                                   sgbuf->buf, pending);
+                dma_count = tty_insert_flip_string(port, sgbuf->buf, pending);
 
                 /* Return buffer to device */
                 dma_sync_sg_for_device(dev, &sgbuf->sg, 1, DMA_FROM_DEVICE);
@@ -754,7 +753,7 @@ static void pl011_dma_rx_chars(struct uart_amba_port *uap,
         dev_vdbg(uap->port.dev,
                  "Took %d chars from DMA buffer and %d chars from the FIFO\n",
                  dma_count, fifotaken);
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(port);
         spin_lock(&uap->port.lock);
 }
 
@@ -1076,12 +1075,10 @@ 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.state->port.tty;
-
         pl011_fifo_to_tty(uap);
 
         spin_unlock(&uap->port.lock);
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&uap->port.state->port);
         /*
          * If we were temporarily out of DMA mode for a while,
          * attempt to switch back to DMA mode again.
diff --git a/drivers/tty/serial/apbuart.c b/drivers/tty/serial/apbuart.c
index 59ae2b53e765..6331464d9101 100644
--- a/drivers/tty/serial/apbuart.c
+++ b/drivers/tty/serial/apbuart.c
@@ -78,7 +78,6 @@ static void apbuart_enable_ms(struct uart_port *port)
 
 static void apbuart_rx_chars(struct uart_port *port)
 {
-        struct tty_struct *tty = port->state->port.tty;
         unsigned int status, ch, rsr, flag;
         unsigned int max_chars = port->fifosize;
 
@@ -126,7 +125,7 @@ static void apbuart_rx_chars(struct uart_port *port)
                 status = UART_GET_STATUS(port);
         }
 
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&port->state->port);
 }
 
 static void apbuart_tx_chars(struct uart_port *port)
diff --git a/drivers/tty/serial/ar933x_uart.c b/drivers/tty/serial/ar933x_uart.c
index 505c490c0b44..27f20c57abed 100644
--- a/drivers/tty/serial/ar933x_uart.c
+++ b/drivers/tty/serial/ar933x_uart.c
@@ -297,10 +297,9 @@ static void ar933x_uart_set_termios(struct uart_port *port,
 
 static void ar933x_uart_rx_chars(struct ar933x_uart_port *up)
 {
-        struct tty_struct *tty;
+        struct tty_port *port = &up->port.state->port;
         int max_count = 256;
 
-        tty = tty_port_tty_get(&up->port.state->port);
         do {
                 unsigned int rdata;
                 unsigned char ch;
@@ -313,11 +312,6 @@ static void ar933x_uart_rx_chars(struct ar933x_uart_port *up)
                 ar933x_uart_write(up, AR933X_UART_DATA_REG,
                                   AR933X_UART_DATA_RX_CSR);
 
-                if (!tty) {
-                        /* discard the data if no tty available */
-                        continue;
-                }
-
                 up->port.icount.rx++;
                 ch = rdata & AR933X_UART_DATA_TX_RX_MASK;
 
@@ -325,13 +319,10 @@ static void ar933x_uart_rx_chars(struct ar933x_uart_port *up)
                         continue;
 
                 if ((up->port.ignore_status_mask & AR933X_DUMMY_STATUS_RD) == 0)
-                        tty_insert_flip_char(tty, ch, TTY_NORMAL);
+                        tty_insert_flip_char(port, ch, TTY_NORMAL);
         } while (max_count-- > 0);
 
-        if (tty) {
-                tty_flip_buffer_push(tty);
-                tty_kref_put(tty);
-        }
+        tty_flip_buffer_push(port);
 }
 
 static void ar933x_uart_tx_chars(struct ar933x_uart_port *up)
diff --git a/drivers/tty/serial/arc_uart.c b/drivers/tty/serial/arc_uart.c
index 3e0b3fac6a0e..d97e194b6bc5 100644
--- a/drivers/tty/serial/arc_uart.c
+++ b/drivers/tty/serial/arc_uart.c
@@ -37,6 +37,8 @@
 #include <linux/tty_flip.h>
 #include <linux/serial_core.h>
 #include <linux/io.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
 
 /*************************************
  * ARC UART Hardware Specs
@@ -209,12 +211,8 @@ static void arc_serial_start_tx(struct uart_port *port)
 
 static void arc_serial_rx_chars(struct arc_uart_port *uart)
 {
-        struct tty_struct *tty = tty_port_tty_get(&uart->port.state->port);
         unsigned int status, ch, flg = 0;
 
-        if (!tty)
-                return;
-
         /*
          * UART has 4 deep RX-FIFO. Driver's recongnition of this fact
          * is very subtle. Here's how ...
@@ -250,10 +248,8 @@ static void arc_serial_rx_chars(struct arc_uart_port *uart)
                 uart_insert_char(&uart->port, status, RXOERR, ch, flg);
 
 done:
-                tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(&uart->port.state->port);
         }
-
-        tty_kref_put(tty);
 }
 
 /*
@@ -526,18 +522,37 @@ static struct uart_ops arc_serial_pops = {
 };
 
 static int
-arc_uart_init_one(struct platform_device *pdev, struct arc_uart_port *uart)
+arc_uart_init_one(struct platform_device *pdev, int dev_id)
 {
         struct resource *res, *res2;
         unsigned long *plat_data;
-
-        if (pdev->id < 0 || pdev->id >= CONFIG_SERIAL_ARC_NR_PORTS) {
-                dev_err(&pdev->dev, "Wrong uart platform device id.\n");
-                return -ENOENT;
-        }
+        struct arc_uart_port *uart = &arc_uart_ports[dev_id];
 
         plat_data = ((unsigned long *)(pdev->dev.platform_data));
-        uart->baud = plat_data[0];
+        if (!plat_data)
+                return -ENODEV;
+
+        uart->is_emulated = !!plat_data[0];     /* workaround ISS bug */
+
+        if (is_early_platform_device(pdev)) {
+                uart->port.uartclk = plat_data[1];
+                uart->baud = plat_data[2];
+        } else {
+                struct device_node *np = pdev->dev.of_node;
+                u32 val;
+
+                if (of_property_read_u32(np, "clock-frequency", &val)) {
+                        dev_err(&pdev->dev, "clock-frequency property NOTset\n");
+                        return -EINVAL;
+                }
+                uart->port.uartclk = val;
+
+                if (of_property_read_u32(np, "current-speed", &val)) {
+                        dev_err(&pdev->dev, "current-speed property NOT set\n");
+                        return -EINVAL;
+                }
+                uart->baud = val;
+        }
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res)
@@ -557,10 +572,9 @@ arc_uart_init_one(struct platform_device *pdev, struct arc_uart_port *uart)
         uart->port.dev = &pdev->dev;
         uart->port.iotype = UPIO_MEM;
         uart->port.flags = UPF_BOOT_AUTOCONF;
-        uart->port.line = pdev->id;
+        uart->port.line = dev_id;
         uart->port.ops = &arc_serial_pops;
 
-        uart->port.uartclk = plat_data[1];
         uart->port.fifosize = ARC_UART_TX_FIFO_SIZE;
 
         /*
@@ -569,9 +583,6 @@ arc_uart_init_one(struct platform_device *pdev, struct arc_uart_port *uart)
          */
         uart->port.ignore_status_mask = 0;
 
-        /* Real Hardware vs. emulated to work around a bug */
-        uart->is_emulated = !!plat_data[2];
-
         return 0;
 }
 
@@ -648,45 +659,50 @@ static __init void early_serial_write(struct console *con, const char *s,
         }
 }
 
-static struct __initdata console arc_early_serial_console = {
+static struct console arc_early_serial_console __initdata = {
         .name = "early_ARCuart",
         .write = early_serial_write,
         .flags = CON_PRINTBUFFER | CON_BOOT,
         .index = -1
 };
 
-static int arc_serial_probe_earlyprintk(struct platform_device *pdev)
+static int __init arc_serial_probe_earlyprintk(struct platform_device *pdev)
 {
-        arc_early_serial_console.index = pdev->id;
+        int dev_id = pdev->id < 0 ? 0 : pdev->id;
+        int rc;
+
+        arc_early_serial_console.index = dev_id;
 
-        arc_uart_init_one(pdev, &arc_uart_ports[pdev->id]);
+        rc = arc_uart_init_one(pdev, dev_id);
+        if (rc)
+                panic("early console init failed\n");
 
         arc_serial_console_setup(&arc_early_serial_console, NULL);
 
         register_console(&arc_early_serial_console);
         return 0;
 }
-#else
-static int arc_serial_probe_earlyprintk(struct platform_device *pdev)
-{
-        return -ENODEV;
-}
 #endif  /* CONFIG_SERIAL_ARC_CONSOLE */
 
 static int arc_serial_probe(struct platform_device *pdev)
 {
-        struct arc_uart_port *uart;
-        int rc;
+        int rc, dev_id;
+        struct device_node *np = pdev->dev.of_node;
+
+        /* no device tree device */
+        if (!np)
+                return -ENODEV;
 
-        if (is_early_platform_device(pdev))
-                return arc_serial_probe_earlyprintk(pdev);
+        dev_id = of_alias_get_id(np, "serial");
+        if (dev_id < 0)
+                dev_id = 0;
 
-        uart = &arc_uart_ports[pdev->id];
-        rc = arc_uart_init_one(pdev, uart);
+        rc = arc_uart_init_one(pdev, dev_id);
         if (rc)
                 return rc;
 
-        return uart_add_one_port(&arc_uart_driver, &uart->port);
+        rc = uart_add_one_port(&arc_uart_driver, &arc_uart_ports[dev_id].port);
+        return rc;
 }
 
 static int arc_serial_remove(struct platform_device *pdev)
@@ -695,16 +711,32 @@ static int arc_serial_remove(struct platform_device *pdev)
         return 0;
 }
 
+static const struct of_device_id arc_uart_dt_ids[] = {
+        { .compatible = "snps,arc-uart" },
+        { /* Sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, arc_uart_dt_ids);
+
 static struct platform_driver arc_platform_driver = {
         .probe = arc_serial_probe,
         .remove = arc_serial_remove,
         .driver = {
                 .name = DRIVER_NAME,
                 .owner = THIS_MODULE,
+                .of_match_table  = arc_uart_dt_ids,
          },
 };
 
 #ifdef CONFIG_SERIAL_ARC_CONSOLE
+
+static struct platform_driver early_arc_platform_driver __initdata = {
+        .probe = arc_serial_probe_earlyprintk,
+        .remove = arc_serial_remove,
+        .driver = {
+                .name = DRIVER_NAME,
+                .owner = THIS_MODULE,
+         },
+};
 /*
  * Register an early platform driver of "earlyprintk" class.
  * ARCH platform code installs the driver and probes the early devices
@@ -712,7 +744,7 @@ static struct platform_driver arc_platform_driver = {
  * or it could be done independently, for all "earlyprintk" class drivers.
  * [see arch/arc/plat-arcfpga/platform.c]
  */
-early_platform_init("earlyprintk", &arc_platform_driver);
+early_platform_init("earlyprintk", &early_arc_platform_driver);
 
 #endif  /* CONFIG_SERIAL_ARC_CONSOLE */
 
diff --git a/drivers/tty/serial/atmel_serial.c b/drivers/tty/serial/atmel_serial.c
index 922e85aeb63a..d4a7c241b751 100644
--- a/drivers/tty/serial/atmel_serial.c
+++ b/drivers/tty/serial/atmel_serial.c
@@ -774,14 +774,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->state->port.tty);
+        tty_flip_buffer_push(&port->state->port);
         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->state->port.tty;
+        struct tty_port *tport = &port->state->port;
         struct atmel_dma_buffer *pdc;
         int rx_idx = atmel_port->pdc_rx_idx;
         unsigned int head;
@@ -820,7 +820,8 @@ static void atmel_rx_from_dma(struct uart_port *port)
                          */
                         count = head - tail;
 
-                        tty_insert_flip_string(tty, pdc->buf + pdc->ofs, count);
+                        tty_insert_flip_string(tport, pdc->buf + pdc->ofs,
+                                                count);
 
                         dma_sync_single_for_device(port->dev, pdc->dma_addr,
                                         pdc->dma_size, DMA_FROM_DEVICE);
@@ -848,7 +849,7 @@ static void atmel_rx_from_dma(struct uart_port *port)
          * uart_start(), which takes the lock.
          */
         spin_unlock(&port->lock);
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(tport);
         spin_lock(&port->lock);
 
         UART_PUT_IER(port, ATMEL_US_ENDRX | ATMEL_US_TIMEOUT);
diff --git a/drivers/tty/serial/bcm63xx_uart.c b/drivers/tty/serial/bcm63xx_uart.c
index c76a226080f2..719594e5fc21 100644
--- a/drivers/tty/serial/bcm63xx_uart.c
+++ b/drivers/tty/serial/bcm63xx_uart.c
@@ -235,14 +235,13 @@ static const char *bcm_uart_type(struct uart_port *port)
  */
 static void bcm_uart_do_rx(struct uart_port *port)
 {
-        struct tty_struct *tty;
+        struct tty_port *port = &port->state->port;
         unsigned int max_count;
 
         /* limit number of char read in interrupt, should not be
          * higher than fifo size anyway since we're much faster than
          * serial port */
         max_count = 32;
-        tty = port->state->port.tty;
         do {
                 unsigned int iestat, c, cstat;
                 char flag;
@@ -261,7 +260,7 @@ static void bcm_uart_do_rx(struct uart_port *port)
                         bcm_uart_writel(port, val, UART_CTL_REG);
 
                         port->icount.overrun++;
-                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                        tty_insert_flip_char(port, 0, TTY_OVERRUN);
                 }
 
                 if (!(iestat & UART_IR_STAT(UART_IR_RXNOTEMPTY)))
@@ -300,11 +299,11 @@ static void bcm_uart_do_rx(struct uart_port *port)
 
 
                 if ((cstat & port->ignore_status_mask) == 0)
-                        tty_insert_flip_char(tty, c, flag);
+                        tty_insert_flip_char(port, c, flag);
 
         } while (--max_count);
 
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(port);
 }
 
 /*
diff --git a/drivers/tty/serial/bfin_sport_uart.c b/drivers/tty/serial/bfin_sport_uart.c
index f5d117379b60..487c173b0f72 100644
--- a/drivers/tty/serial/bfin_sport_uart.c
+++ b/drivers/tty/serial/bfin_sport_uart.c
@@ -149,7 +149,7 @@ static int sport_uart_setup(struct sport_uart_port *up, int size, 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.state->port.tty;
+        struct tty_port *port = &up->port.state->port;
         unsigned int ch;
 
         spin_lock(&up->port.lock);
@@ -159,9 +159,10 @@ static irqreturn_t sport_uart_rx_irq(int irq, void *dev_id)
                 up->port.icount.rx++;
 
                 if (!uart_handle_sysrq_char(&up->port, ch))
-                        tty_insert_flip_char(tty, ch, TTY_NORMAL);
+                        tty_insert_flip_char(port, ch, TTY_NORMAL);
         }
-        tty_flip_buffer_push(tty);
+        /* XXX this won't deadlock with lowlat? */
+        tty_flip_buffer_push(port);
 
         spin_unlock(&up->port.lock);
 
@@ -182,7 +183,6 @@ 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.state->port.tty;
         unsigned int stat = SPORT_GET_STAT(up);
 
         spin_lock(&up->port.lock);
@@ -190,7 +190,7 @@ static irqreturn_t sport_uart_err_irq(int irq, void *dev_id)
         /* Overflow in RX FIFO */
         if (stat & ROVF) {
                 up->port.icount.overrun++;
-                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                tty_insert_flip_char(&up->port.state->port, 0, TTY_OVERRUN);
                 SPORT_PUT_STAT(up, ROVF); /* Clear ROVF bit */
         }
         /* These should not happen */
@@ -205,6 +205,8 @@ static irqreturn_t sport_uart_err_irq(int irq, void *dev_id)
         SSYNC();
 
         spin_unlock(&up->port.lock);
+        /* XXX we don't push the overrun bit to TTY? */
+
         return IRQ_HANDLED;
 }
 
diff --git a/drivers/tty/serial/bfin_uart.c b/drivers/tty/serial/bfin_uart.c
index 2e2b2c1cb722..12dceda9db33 100644
--- a/drivers/tty/serial/bfin_uart.c
+++ b/drivers/tty/serial/bfin_uart.c
@@ -223,7 +223,6 @@ static void bfin_serial_enable_ms(struct uart_port *port)
 #ifdef CONFIG_SERIAL_BFIN_PIO
 static void bfin_serial_rx_chars(struct bfin_serial_port *uart)
 {
-        struct tty_struct *tty = NULL;
         unsigned int status, ch, flg;
         static struct timeval anomaly_start = { .tv_sec = 0 };
 
@@ -242,11 +241,9 @@ static void bfin_serial_rx_chars(struct bfin_serial_port *uart)
                         return;
                 }
 
-        if (!uart->port.state || !uart->port.state->port.tty)
+        if (!uart->port.state)
                 return;
 #endif
-        tty = uart->port.state->port.tty;
-
         if (ANOMALY_05000363) {
                 /* The BF533 (and BF561) family of processors have a nice anomaly
                  * where they continuously generate characters for a "single" break.
@@ -325,7 +322,7 @@ static void bfin_serial_rx_chars(struct bfin_serial_port *uart)
         uart_insert_char(&uart->port, status, OE, ch, flg);
 
  ignore_char:
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&uart->port.state->port);
 }
 
 static void bfin_serial_tx_chars(struct bfin_serial_port *uart)
@@ -426,7 +423,6 @@ 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.state->port.tty;
         int i, flg, status;
 
         status = UART_GET_LSR(uart);
@@ -471,7 +467,7 @@ static void bfin_serial_dma_rx_chars(struct bfin_serial_port *uart)
         }
 
  dma_ignore_char:
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&uart->port.state->port);
 }
 
 void bfin_serial_rx_dma_timeout(struct bfin_serial_port *uart)
diff --git a/drivers/tty/serial/clps711x.c b/drivers/tty/serial/clps711x.c
index 3fd2526d121e..bfb17968c8db 100644
--- a/drivers/tty/serial/clps711x.c
+++ b/drivers/tty/serial/clps711x.c
@@ -85,12 +85,8 @@ static void uart_clps711x_enable_ms(struct uart_port *port)
 static irqreturn_t uart_clps711x_int_rx(int irq, void *dev_id)
 {
         struct uart_port *port = dev_id;
-        struct tty_struct *tty = tty_port_tty_get(&port->state->port);
         unsigned int status, ch, flg;
 
-        if (!tty)
-                return IRQ_HANDLED;
-
         for (;;) {
                 status = clps_readl(SYSFLG(port));
                 if (status & SYSFLG_URXFE)
@@ -130,9 +126,7 @@ static irqreturn_t uart_clps711x_int_rx(int irq, void *dev_id)
                 uart_insert_char(port, status, UARTDR_OVERR, ch, flg);
         }
 
-        tty_flip_buffer_push(tty);
-
-        tty_kref_put(tty);
+        tty_flip_buffer_push(&port->state->port);
 
         return IRQ_HANDLED;
 }
diff --git a/drivers/tty/serial/cpm_uart/cpm_uart_core.c b/drivers/tty/serial/cpm_uart/cpm_uart_core.c
index ad0caf176808..97f4e1858649 100644
--- a/drivers/tty/serial/cpm_uart/cpm_uart_core.c
+++ b/drivers/tty/serial/cpm_uart/cpm_uart_core.c
@@ -245,7 +245,7 @@ static void cpm_uart_int_rx(struct uart_port *port)
         int i;
         unsigned char ch;
         u8 *cp;
-        struct tty_struct *tty = port->state->port.tty;
+        struct tty_port *tport = &port->state->port;
         struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
         cbd_t __iomem *bdp;
         u16 status;
@@ -276,7 +276,7 @@ static void cpm_uart_int_rx(struct uart_port *port)
                 /* If we have not enough room in tty flip buffer, then we try
                  * later, which will be the next rx-interrupt or a timeout
                  */
-                if(tty_buffer_request_room(tty, i) < i) {
+                if (tty_buffer_request_room(tport, i) < i) {
                         printk(KERN_WARNING "No room in flip buffer\n");
                         return;
                 }
@@ -302,7 +302,7 @@ static void cpm_uart_int_rx(struct uart_port *port)
                         }
 #endif
                       error_return:
-                        tty_insert_flip_char(tty, ch, flg);
+                        tty_insert_flip_char(tport, ch, flg);
 
                 }               /* End while (i--) */
 
@@ -322,7 +322,7 @@ static void cpm_uart_int_rx(struct uart_port *port)
         pinfo->rx_cur = bdp;
 
         /* activate BH processing */
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(tport);
 
         return;
 
@@ -507,7 +507,7 @@ static void cpm_uart_set_termios(struct uart_port *port,
 
         baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk / 16);
         if (baud < HW_BUF_SPD_THRESHOLD ||
-            (pinfo->port.state && pinfo->port.state->port.tty->low_latency))
+            (pinfo->port.state && pinfo->port.state->port.low_latency))
                 pinfo->rx_fifosize = 1;
         else
                 pinfo->rx_fifosize = RX_BUF_SIZE;
diff --git a/drivers/tty/serial/crisv10.c b/drivers/tty/serial/crisv10.c
index 35ee6a2c6877..5f37c31e32bc 100644
--- a/drivers/tty/serial/crisv10.c
+++ b/drivers/tty/serial/crisv10.c
@@ -1760,8 +1760,7 @@ add_char_and_flag(struct e100_serial *info, unsigned char data, unsigned char fl
 
                 info->icount.rx++;
         } else {
-                struct tty_struct *tty = info->port.tty;
-                tty_insert_flip_char(tty, data, flag);
+                tty_insert_flip_char(&info->port, data, flag);
                 info->icount.rx++;
         }
 
@@ -2105,22 +2104,15 @@ static int force_eop_if_needed(struct e100_serial *info)
 
 static void flush_to_flip_buffer(struct e100_serial *info)
 {
-        struct tty_struct *tty;
         struct etrax_recv_buffer *buffer;
         unsigned long flags;
 
         local_irq_save(flags);
-        tty = info->port.tty;
-
-        if (!tty) {
-                local_irq_restore(flags);
-                return;
-        }
 
         while ((buffer = info->first_recv_buffer) != NULL) {
                 unsigned int count = buffer->length;
 
-                tty_insert_flip_string(tty, buffer->buffer, count);
+                tty_insert_flip_string(&info->port, buffer->buffer, count);
                 info->recv_cnt -= count;
 
                 if (count == buffer->length) {
@@ -2139,7 +2131,7 @@ static void flush_to_flip_buffer(struct e100_serial *info)
         local_irq_restore(flags);
 
         /* This includes a check for low-latency */
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&info->port);
 }
 
 static void check_flush_timeout(struct e100_serial *info)
@@ -2275,12 +2267,6 @@ static
 struct e100_serial * handle_ser_rx_interrupt_no_dma(struct e100_serial *info)
 {
         unsigned long data_read;
-        struct tty_struct *tty = info->port.tty;
-
-        if (!tty) {
-                printk("!NO TTY!\n");
-                return info;
-        }
 
         /* Read data and status at the same time */
         data_read = *((unsigned long *)&info->ioport[REG_DATA_STATUS32]);
@@ -2338,8 +2324,7 @@ more_data:
                                         data_in, data_read);
                                 char flag = TTY_NORMAL;
                                 if (info->errorcode == ERRCODE_INSERT_BREAK) {
-                                        struct tty_struct *tty = info->port.tty;
-                                        tty_insert_flip_char(tty, 0, flag);
+                                        tty_insert_flip_char(&info->port, 0, flag);
                                         info->icount.rx++;
                                 }
 
@@ -2353,7 +2338,7 @@ more_data:
                                         info->icount.frame++;
                                         flag = TTY_FRAME;
                                 }
-                                tty_insert_flip_char(tty, data, flag);
+                                tty_insert_flip_char(&info->port, data, flag);
                                 info->errorcode = 0;
                         }
                         info->break_detected_cnt = 0;
@@ -2369,7 +2354,7 @@ more_data:
                         log_int(rdpc(), 0, 0);
                 }
                 );
-                tty_insert_flip_char(tty,
+                tty_insert_flip_char(&info->port,
                         IO_EXTRACT(R_SERIAL0_READ, data_in, data_read),
                         TTY_NORMAL);
         } else {
@@ -2384,7 +2369,7 @@ more_data:
                 goto more_data;
         }
 
-        tty_flip_buffer_push(info->port.tty);
+        tty_flip_buffer_push(&info->port);
         return info;
 }
 
@@ -3137,7 +3122,7 @@ static int rs_raw_write(struct tty_struct *tty,
 
         /* first some sanity checks */
 
-        if (!tty || !info->xmit.buf)
+        if (!info->xmit.buf)
                 return 0;
 
 #ifdef SERIAL_DEBUG_DATA
@@ -3464,7 +3449,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->port.tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
+        info->port.low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
 
  check_and_exit:
         if (info->flags & ASYNC_INITIALIZED) {
@@ -4108,7 +4093,7 @@ rs_open(struct tty_struct *tty, struct file * filp)
         tty->driver_data = info;
         info->port.tty = tty;
 
-        tty->low_latency = !!(info->flags & ASYNC_LOW_LATENCY);
+        info->port.low_latency = !!(info->flags & ASYNC_LOW_LATENCY);
 
         /*
          * If the port is in the middle of closing, bail out now
diff --git a/drivers/tty/serial/dz.c b/drivers/tty/serial/dz.c
index 6491b8644a7f..2f2b2e538a54 100644
--- a/drivers/tty/serial/dz.c
+++ b/drivers/tty/serial/dz.c
@@ -187,7 +187,6 @@ static inline void dz_receive_chars(struct dz_mux *mux)
 {
         struct uart_port *uport;
         struct dz_port *dport = &mux->dport[0];
-        struct tty_struct *tty = NULL;
         struct uart_icount *icount;
         int lines_rx[DZ_NB_PORT] = { [0 ... DZ_NB_PORT - 1] = 0 };
         unsigned char ch, flag;
@@ -197,7 +196,6 @@ 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->state->port.tty;   /* point to the proper dev */
 
                 ch = UCHAR(status);             /* grab the char */
                 flag = TTY_NORMAL;
@@ -249,7 +247,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.state->port.tty);
+                        tty_flip_buffer_push(&mux->dport[i].port.state->port);
 }
 
 /*
diff --git a/drivers/tty/serial/efm32-uart.c b/drivers/tty/serial/efm32-uart.c
index a8cbb2670521..7d199c8e1a75 100644
--- a/drivers/tty/serial/efm32-uart.c
+++ b/drivers/tty/serial/efm32-uart.c
@@ -81,6 +81,7 @@ struct efm32_uart_port {
         struct uart_port port;
         unsigned int txirq;
         struct clk *clk;
+        struct efm32_uart_pdata pdata;
 };
 #define to_efm_port(_port) container_of(_port, struct efm32_uart_port, port)
 #define efm_debug(efm_port, format, arg...)                     \
@@ -194,8 +195,7 @@ static void efm32_uart_break_ctl(struct uart_port *port, int ctl)
         /* not possible without fiddling with gpios */
 }
 
-static void efm32_uart_rx_chars(struct efm32_uart_port *efm_port,
-                struct tty_struct *tty)
+static void efm32_uart_rx_chars(struct efm32_uart_port *efm_port)
 {
         struct uart_port *port = &efm_port->port;
 
@@ -237,8 +237,8 @@ static void efm32_uart_rx_chars(struct efm32_uart_port *efm_port,
                                         rxdata & UARTn_RXDATAX_RXDATA__MASK))
                         continue;
 
-                if (tty && (rxdata & port->ignore_status_mask) == 0)
-                        tty_insert_flip_char(tty,
+                if ((rxdata & port->ignore_status_mask) == 0)
+                        tty_insert_flip_char(&port->state->port,
                                         rxdata & UARTn_RXDATAX_RXDATA__MASK, flag);
         }
 }
@@ -249,15 +249,13 @@ static irqreturn_t efm32_uart_rxirq(int irq, void *data)
         u32 irqflag = efm32_uart_read32(efm_port, UARTn_IF);
         int handled = IRQ_NONE;
         struct uart_port *port = &efm_port->port;
-        struct tty_struct *tty;
+        struct tty_port *tport = &port->state->port;
 
         spin_lock(&port->lock);
 
-        tty = tty_kref_get(port->state->port.tty);
-
         if (irqflag & UARTn_IF_RXDATAV) {
                 efm32_uart_write32(efm_port, UARTn_IF_RXDATAV, UARTn_IFC);
-                efm32_uart_rx_chars(efm_port, tty);
+                efm32_uart_rx_chars(efm_port);
 
                 handled = IRQ_HANDLED;
         }
@@ -265,16 +263,12 @@ static irqreturn_t efm32_uart_rxirq(int irq, void *data)
         if (irqflag & UARTn_IF_RXOF) {
                 efm32_uart_write32(efm_port, UARTn_IF_RXOF, UARTn_IFC);
                 port->icount.overrun++;
-                if (tty)
-                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                tty_insert_flip_char(tport, 0, TTY_OVERRUN);
 
                 handled = IRQ_HANDLED;
         }
 
-        if (tty) {
-                tty_flip_buffer_push(tty);
-                tty_kref_put(tty);
-        }
+        tty_flip_buffer_push(tport);
 
         spin_unlock(&port->lock);
 
@@ -300,13 +294,8 @@ static irqreturn_t efm32_uart_txirq(int irq, void *data)
 static int efm32_uart_startup(struct uart_port *port)
 {
         struct efm32_uart_port *efm_port = to_efm_port(port);
-        u32 location = 0;
-        struct efm32_uart_pdata *pdata = dev_get_platdata(port->dev);
         int ret;
 
-        if (pdata)
-                location = UARTn_ROUTE_LOCATION(pdata->location);
-
         ret = clk_enable(efm_port->clk);
         if (ret) {
                 efm_debug(efm_port, "failed to enable clk\n");
@@ -315,7 +304,9 @@ static int efm32_uart_startup(struct uart_port *port)
         port->uartclk = clk_get_rate(efm_port->clk);
 
         /* Enable pins at configured location */
-        efm32_uart_write32(efm_port, location | UARTn_ROUTE_RXPEN | UARTn_ROUTE_TXPEN,
+        efm32_uart_write32(efm_port,
+                        UARTn_ROUTE_LOCATION(efm_port->pdata.location) |
+                        UARTn_ROUTE_RXPEN | UARTn_ROUTE_TXPEN,
                         UARTn_ROUTE);
 
         ret = request_irq(port->irq, efm32_uart_rxirq, 0,
@@ -674,11 +665,24 @@ static int efm32_uart_probe_dt(struct platform_device *pdev,
                 struct efm32_uart_port *efm_port)
 {
         struct device_node *np = pdev->dev.of_node;
+        u32 location;
         int ret;
 
         if (!np)
                 return 1;
 
+        ret = of_property_read_u32(np, "location", &location);
+        if (!ret) {
+                if (location > 5) {
+                        dev_err(&pdev->dev, "invalid location\n");
+                        return -EINVAL;
+                }
+                efm_debug(efm_port, "using location %u\n", location);
+                efm_port->pdata.location = location;
+        } else {
+                efm_debug(efm_port, "fall back to location 0\n");
+        }
+
         ret = of_alias_get_id(np, "serial");
         if (ret < 0) {
                 dev_err(&pdev->dev, "failed to get alias id: %d\n", ret);
@@ -738,10 +742,16 @@ static int efm32_uart_probe(struct platform_device *pdev)
         efm_port->port.flags = UPF_BOOT_AUTOCONF;
 
         ret = efm32_uart_probe_dt(pdev, efm_port);
-        if (ret > 0)
+        if (ret > 0) {
                 /* not created by device tree */
+                const struct efm32_uart_pdata *pdata = dev_get_platdata(&pdev->dev);
+
                 efm_port->port.line = pdev->id;
 
+                if (pdata)
+                        efm_port->pdata = *pdata;
+        }
+
         if (efm_port->port.line >= 0 &&
                         efm_port->port.line < ARRAY_SIZE(efm32_uart_ports))
                 efm32_uart_ports[efm_port->port.line] = efm_port;
diff --git a/drivers/tty/serial/icom.c b/drivers/tty/serial/icom.c
index 72b6334bcf1a..bc9e6b017b05 100644
--- a/drivers/tty/serial/icom.c
+++ b/drivers/tty/serial/icom.c
@@ -734,7 +734,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.state->port.tty;
+        struct tty_port *port = &icom_port->uart_port.state->port;
         unsigned short int status;
         struct uart_icount *icount;
         unsigned long offset;
@@ -761,7 +761,7 @@ static void recv_interrupt(u16 port_int_reg, struct icom_port *icom_port)
                 /* Block copy all but the last byte as this may have status */
                 if (count > 0) {
                         first = icom_port->recv_buf[offset];
-                        tty_insert_flip_string(tty, icom_port->recv_buf + offset, count - 1);
+                        tty_insert_flip_string(port, icom_port->recv_buf + offset, count - 1);
                 }
 
                 icount = &icom_port->uart_port.icount;
@@ -812,7 +812,7 @@ static void recv_interrupt(u16 port_int_reg, struct icom_port *icom_port)
 
                 }
 
-                tty_insert_flip_char(tty, *(icom_port->recv_buf + offset + count - 1), flag);
+                tty_insert_flip_char(port, *(icom_port->recv_buf + offset + count - 1), flag);
 
                 if (status & SA_FLAGS_OVERRUN)
                         /*
@@ -820,7 +820,7 @@ static void recv_interrupt(u16 port_int_reg, struct icom_port *icom_port)
                          * reported immediately, and doesn't
                          * affect the current character
                          */
-                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                        tty_insert_flip_char(port, 0, TTY_OVERRUN);
 ignore_char:
                 icom_port->statStg->rcv[rcv_buff].flags = 0;
                 icom_port->statStg->rcv[rcv_buff].leLength = 0;
@@ -834,7 +834,7 @@ ignore_char:
                 status = cpu_to_le16(icom_port->statStg->rcv[rcv_buff].flags);
         }
         icom_port->next_rcv = rcv_buff;
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(port);
 }
 
 static void process_interrupt(u16 port_int_reg,
diff --git a/drivers/tty/serial/ifx6x60.c b/drivers/tty/serial/ifx6x60.c
index 8cb6d8d66a13..68d7ce997ede 100644
--- a/drivers/tty/serial/ifx6x60.c
+++ b/drivers/tty/serial/ifx6x60.c
@@ -481,7 +481,6 @@ static int ifx_spi_prepare_tx_buffer(struct ifx_spi_device *ifx_dev)
         unsigned char *tx_buffer;
 
         tx_buffer = ifx_dev->tx_buffer;
-        memset(tx_buffer, 0, IFX_SPI_TRANSFER_SIZE);
 
         /* make room for required SPI header */
         tx_buffer += IFX_SPI_HEADER_OVERHEAD;
@@ -615,7 +614,7 @@ static int ifx_port_activate(struct tty_port *port, struct tty_struct *tty)
         tty->driver_data = ifx_dev;
 
         /* allows flip string push from int context */
-        tty->low_latency = 1;
+        port->low_latency = 1;
 
         /* set flag to allows data transfer */
         set_bit(IFX_SPI_STATE_IO_AVAILABLE, &ifx_dev->flags);
@@ -670,12 +669,8 @@ static const struct tty_operations ifx_spi_serial_ops = {
 static void ifx_spi_insert_flip_string(struct ifx_spi_device *ifx_dev,
                                     unsigned char *chars, size_t size)
 {
-        struct tty_struct *tty = tty_port_tty_get(&ifx_dev->tty_port);
-        if (!tty)
-                return;
-        tty_insert_flip_string(tty, chars, size);
-        tty_flip_buffer_push(tty);
-        tty_kref_put(tty);
+        tty_insert_flip_string(&ifx_dev->tty_port, chars, size);
+        tty_flip_buffer_push(&ifx_dev->tty_port);
 }
 
 /**
diff --git a/drivers/tty/serial/imx.c b/drivers/tty/serial/imx.c
index 59819121fe9b..147c9e193595 100644
--- a/drivers/tty/serial/imx.c
+++ b/drivers/tty/serial/imx.c
@@ -48,8 +48,8 @@
 #include <linux/of.h>
 #include <linux/of_device.h>
 #include <linux/pinctrl/consumer.h>
+#include <linux/io.h>
 
-#include <asm/io.h>
 #include <asm/irq.h>
 #include <linux/platform_data/serial-imx.h>
 
@@ -73,102 +73,102 @@
 #define IMX21_UTS 0xb4 /* UART Test Register on all other i.mx*/
 
 /* UART Control Register Bit Fields.*/
-#define  URXD_CHARRDY    (1<<15)
-#define  URXD_ERR        (1<<14)
-#define  URXD_OVRRUN     (1<<13)
-#define  URXD_FRMERR     (1<<12)
-#define  URXD_BRK        (1<<11)
-#define  URXD_PRERR      (1<<10)
-#define  UCR1_ADEN       (1<<15) /* Auto detect interrupt */
-#define  UCR1_ADBR       (1<<14) /* Auto detect baud rate */
-#define  UCR1_TRDYEN     (1<<13) /* Transmitter ready interrupt enable */
-#define  UCR1_IDEN       (1<<12) /* Idle condition interrupt */
-#define  UCR1_RRDYEN     (1<<9)  /* Recv ready interrupt enable */
-#define  UCR1_RDMAEN     (1<<8)  /* Recv ready DMA enable */
-#define  UCR1_IREN       (1<<7)  /* Infrared interface enable */
-#define  UCR1_TXMPTYEN   (1<<6)  /* Transimitter empty interrupt enable */
-#define  UCR1_RTSDEN     (1<<5)  /* RTS delta interrupt enable */
-#define  UCR1_SNDBRK     (1<<4)  /* Send break */
-#define  UCR1_TDMAEN     (1<<3)  /* Transmitter ready DMA enable */
-#define  IMX1_UCR1_UARTCLKEN  (1<<2)  /* UART clock enabled, i.mx1 only */
-#define  UCR1_DOZE       (1<<1)  /* Doze */
-#define  UCR1_UARTEN     (1<<0)  /* UART enabled */
-#define  UCR2_ESCI       (1<<15) /* Escape seq interrupt enable */
-#define  UCR2_IRTS       (1<<14) /* Ignore RTS pin */
-#define  UCR2_CTSC       (1<<13) /* CTS pin control */
-#define  UCR2_CTS        (1<<12) /* Clear to send */
-#define  UCR2_ESCEN      (1<<11) /* Escape enable */
-#define  UCR2_PREN       (1<<8)  /* Parity enable */
-#define  UCR2_PROE       (1<<7)  /* Parity odd/even */
-#define  UCR2_STPB       (1<<6)  /* Stop */
-#define  UCR2_WS         (1<<5)  /* Word size */
-#define  UCR2_RTSEN      (1<<4)  /* Request to send interrupt enable */
-#define  UCR2_ATEN       (1<<3)  /* Aging Timer Enable */
-#define  UCR2_TXEN       (1<<2)  /* Transmitter enabled */
-#define  UCR2_RXEN       (1<<1)  /* Receiver enabled */
-#define  UCR2_SRST       (1<<0)  /* SW reset */
-#define  UCR3_DTREN      (1<<13) /* DTR interrupt enable */
-#define  UCR3_PARERREN   (1<<12) /* Parity enable */
-#define  UCR3_FRAERREN   (1<<11) /* Frame error interrupt enable */
-#define  UCR3_DSR        (1<<10) /* Data set ready */
-#define  UCR3_DCD        (1<<9)  /* Data carrier detect */
-#define  UCR3_RI         (1<<8)  /* Ring indicator */
-#define  UCR3_TIMEOUTEN  (1<<7)  /* Timeout interrupt enable */
-#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  IMX21_UCR3_RXDMUXSEL    (1<<2)  /* RXD Muxed Input Select */
-#define  UCR3_INVT       (1<<1)  /* Inverted Infrared transmission */
-#define  UCR3_BPEN       (1<<0)  /* Preset registers enable */
-#define  UCR4_CTSTL_SHF  10      /* CTS trigger level shift */
-#define  UCR4_CTSTL_MASK 0x3F    /* CTS trigger is 6 bits wide */
-#define  UCR4_INVR       (1<<9)  /* Inverted infrared reception */
-#define  UCR4_ENIRI      (1<<8)  /* Serial infrared interrupt enable */
-#define  UCR4_WKEN       (1<<7)  /* Wake interrupt enable */
-#define  UCR4_REF16      (1<<6)  /* Ref freq 16 MHz */
-#define  UCR4_IRSC       (1<<5)  /* IR special case */
-#define  UCR4_TCEN       (1<<3)  /* Transmit complete interrupt enable */
-#define  UCR4_BKEN       (1<<2)  /* Break condition interrupt enable */
-#define  UCR4_OREN       (1<<1)  /* Receiver overrun interrupt enable */
-#define  UCR4_DREN       (1<<0)  /* Recv data ready interrupt enable */
-#define  UFCR_RXTL_SHF   0       /* Receiver trigger level shift */
-#define  UFCR_DCEDTE     (1<<6)  /* DCE/DTE mode select */
-#define  UFCR_RFDIV      (7<<7)  /* Reference freq divider mask */
-#define  UFCR_RFDIV_REG(x)      (((x) < 7 ? 6 - (x) : 6) << 7)
-#define  UFCR_TXTL_SHF   10      /* Transmitter trigger level shift */
-#define  USR1_PARITYERR  (1<<15) /* Parity error interrupt flag */
-#define  USR1_RTSS       (1<<14) /* RTS pin status */
-#define  USR1_TRDY       (1<<13) /* Transmitter ready interrupt/dma flag */
-#define  USR1_RTSD       (1<<12) /* RTS delta */
-#define  USR1_ESCF       (1<<11) /* Escape seq interrupt flag */
-#define  USR1_FRAMERR    (1<<10) /* Frame error interrupt flag */
-#define  USR1_RRDY       (1<<9)  /* Receiver ready interrupt/dma flag */
-#define  USR1_TIMEOUT    (1<<7)  /* Receive timeout interrupt status */
-#define  USR1_RXDS       (1<<6)  /* Receiver idle interrupt flag */
-#define  USR1_AIRINT     (1<<5)  /* Async IR wake interrupt flag */
-#define  USR1_AWAKE      (1<<4)  /* Aysnc wake interrupt flag */
-#define  USR2_ADET       (1<<15) /* Auto baud rate detect complete */
-#define  USR2_TXFE       (1<<14) /* Transmit buffer FIFO empty */
-#define  USR2_DTRF       (1<<13) /* DTR edge interrupt flag */
-#define  USR2_IDLE       (1<<12) /* Idle condition */
-#define  USR2_IRINT      (1<<8)  /* Serial infrared interrupt flag */
-#define  USR2_WAKE       (1<<7)  /* Wake */
-#define  USR2_RTSF       (1<<4)  /* RTS edge interrupt flag */
-#define  USR2_TXDC       (1<<3)  /* Transmitter complete */
-#define  USR2_BRCD       (1<<2)  /* Break condition */
-#define  USR2_ORE        (1<<1)  /* Overrun error */
-#define  USR2_RDR        (1<<0)  /* Recv data ready */
-#define  UTS_FRCPERR     (1<<13) /* Force parity error */
-#define  UTS_LOOP        (1<<12) /* Loop tx and rx */
-#define  UTS_TXEMPTY     (1<<6)  /* TxFIFO empty */
-#define  UTS_RXEMPTY     (1<<5)  /* RxFIFO empty */
-#define  UTS_TXFULL      (1<<4)  /* TxFIFO full */
-#define  UTS_RXFULL      (1<<3)  /* RxFIFO full */
-#define  UTS_SOFTRST     (1<<0)  /* Software reset */
+#define URXD_CHARRDY    (1<<15)
+#define URXD_ERR        (1<<14)
+#define URXD_OVRRUN     (1<<13)
+#define URXD_FRMERR     (1<<12)
+#define URXD_BRK        (1<<11)
+#define URXD_PRERR      (1<<10)
+#define UCR1_ADEN       (1<<15) /* Auto detect interrupt */
+#define UCR1_ADBR       (1<<14) /* Auto detect baud rate */
+#define UCR1_TRDYEN     (1<<13) /* Transmitter ready interrupt enable */
+#define UCR1_IDEN       (1<<12) /* Idle condition interrupt */
+#define UCR1_RRDYEN     (1<<9)  /* Recv ready interrupt enable */
+#define UCR1_RDMAEN     (1<<8)  /* Recv ready DMA enable */
+#define UCR1_IREN       (1<<7)  /* Infrared interface enable */
+#define UCR1_TXMPTYEN   (1<<6)  /* Transimitter empty interrupt enable */
+#define UCR1_RTSDEN     (1<<5)  /* RTS delta interrupt enable */
+#define UCR1_SNDBRK     (1<<4)  /* Send break */
+#define UCR1_TDMAEN     (1<<3)  /* Transmitter ready DMA enable */
+#define IMX1_UCR1_UARTCLKEN (1<<2) /* UART clock enabled, i.mx1 only */
+#define UCR1_DOZE       (1<<1)  /* Doze */
+#define UCR1_UARTEN     (1<<0)  /* UART enabled */
+#define UCR2_ESCI       (1<<15) /* Escape seq interrupt enable */
+#define UCR2_IRTS       (1<<14) /* Ignore RTS pin */
+#define UCR2_CTSC       (1<<13) /* CTS pin control */
+#define UCR2_CTS        (1<<12) /* Clear to send */
+#define UCR2_ESCEN      (1<<11) /* Escape enable */
+#define UCR2_PREN       (1<<8)  /* Parity enable */
+#define UCR2_PROE       (1<<7)  /* Parity odd/even */
+#define UCR2_STPB       (1<<6)  /* Stop */
+#define UCR2_WS         (1<<5)  /* Word size */
+#define UCR2_RTSEN      (1<<4)  /* Request to send interrupt enable */
+#define UCR2_ATEN       (1<<3)  /* Aging Timer Enable */
+#define UCR2_TXEN       (1<<2)  /* Transmitter enabled */
+#define UCR2_RXEN       (1<<1)  /* Receiver enabled */
+#define UCR2_SRST       (1<<0)  /* SW reset */
+#define UCR3_DTREN      (1<<13) /* DTR interrupt enable */
+#define UCR3_PARERREN   (1<<12) /* Parity enable */
+#define UCR3_FRAERREN   (1<<11) /* Frame error interrupt enable */
+#define UCR3_DSR        (1<<10) /* Data set ready */
+#define UCR3_DCD        (1<<9)  /* Data carrier detect */
+#define UCR3_RI         (1<<8)  /* Ring indicator */
+#define UCR3_TIMEOUTEN  (1<<7)  /* Timeout interrupt enable */
+#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 IMX21_UCR3_RXDMUXSEL    (1<<2)  /* RXD Muxed Input Select */
+#define UCR3_INVT       (1<<1)  /* Inverted Infrared transmission */
+#define UCR3_BPEN       (1<<0)  /* Preset registers enable */
+#define UCR4_CTSTL_SHF  10      /* CTS trigger level shift */
+#define UCR4_CTSTL_MASK 0x3F    /* CTS trigger is 6 bits wide */
+#define UCR4_INVR       (1<<9)  /* Inverted infrared reception */
+#define UCR4_ENIRI      (1<<8)  /* Serial infrared interrupt enable */
+#define UCR4_WKEN       (1<<7)  /* Wake interrupt enable */
+#define UCR4_REF16      (1<<6)  /* Ref freq 16 MHz */
+#define UCR4_IRSC       (1<<5)  /* IR special case */
+#define UCR4_TCEN       (1<<3)  /* Transmit complete interrupt enable */
+#define UCR4_BKEN       (1<<2)  /* Break condition interrupt enable */
+#define UCR4_OREN       (1<<1)  /* Receiver overrun interrupt enable */
+#define UCR4_DREN       (1<<0)  /* Recv data ready interrupt enable */
+#define UFCR_RXTL_SHF   0       /* Receiver trigger level shift */
+#define UFCR_DCEDTE     (1<<6)  /* DCE/DTE mode select */
+#define UFCR_RFDIV      (7<<7)  /* Reference freq divider mask */
+#define UFCR_RFDIV_REG(x)       (((x) < 7 ? 6 - (x) : 6) << 7)
+#define UFCR_TXTL_SHF   10      /* Transmitter trigger level shift */
+#define USR1_PARITYERR  (1<<15) /* Parity error interrupt flag */
+#define USR1_RTSS       (1<<14) /* RTS pin status */
+#define USR1_TRDY       (1<<13) /* Transmitter ready interrupt/dma flag */
+#define USR1_RTSD       (1<<12) /* RTS delta */
+#define USR1_ESCF       (1<<11) /* Escape seq interrupt flag */
+#define USR1_FRAMERR    (1<<10) /* Frame error interrupt flag */
+#define USR1_RRDY       (1<<9)   /* Receiver ready interrupt/dma flag */
+#define USR1_TIMEOUT    (1<<7)   /* Receive timeout interrupt status */
+#define USR1_RXDS        (1<<6)  /* Receiver idle interrupt flag */
+#define USR1_AIRINT      (1<<5)  /* Async IR wake interrupt flag */
+#define USR1_AWAKE       (1<<4)  /* Aysnc wake interrupt flag */
+#define USR2_ADET        (1<<15) /* Auto baud rate detect complete */
+#define USR2_TXFE        (1<<14) /* Transmit buffer FIFO empty */
+#define USR2_DTRF        (1<<13) /* DTR edge interrupt flag */
+#define USR2_IDLE        (1<<12) /* Idle condition */
+#define USR2_IRINT       (1<<8)  /* Serial infrared interrupt flag */
+#define USR2_WAKE        (1<<7)  /* Wake */
+#define USR2_RTSF        (1<<4)  /* RTS edge interrupt flag */
+#define USR2_TXDC        (1<<3)  /* Transmitter complete */
+#define USR2_BRCD        (1<<2)  /* Break condition */
+#define USR2_ORE        (1<<1)   /* Overrun error */
+#define USR2_RDR        (1<<0)   /* Recv data ready */
+#define UTS_FRCPERR     (1<<13) /* Force parity error */
+#define UTS_LOOP        (1<<12)  /* Loop tx and rx */
+#define UTS_TXEMPTY      (1<<6)  /* TxFIFO empty */
+#define UTS_RXEMPTY      (1<<5)  /* RxFIFO empty */
+#define UTS_TXFULL       (1<<4)  /* TxFIFO full */
+#define UTS_RXFULL       (1<<3)  /* RxFIFO full */
+#define UTS_SOFTRST      (1<<0)  /* Software reset */
 
 /* We've been assigned a range on the "Low-density serial ports" major */
-#define SERIAL_IMX_MAJOR        207
-#define MINOR_START             16
+#define SERIAL_IMX_MAJOR        207
+#define MINOR_START             16
 #define DEV_NAME                "ttymxc"
 
 /*
@@ -199,7 +199,7 @@ struct imx_port {
         struct uart_port        port;
         struct timer_list       timer;
         unsigned int            old_status;
-        int                     txirq,rxirq,rtsirq;
+        int                     txirq, rxirq, rtsirq;
         unsigned int            have_rtscts:1;
         unsigned int            use_irda:1;
         unsigned int            irda_inv_rx:1;
@@ -397,7 +397,7 @@ static void imx_stop_rx(struct uart_port *port)
         unsigned long temp;
 
         temp = readl(sport->port.membase + UCR2);
-        writel(temp &~ UCR2_RXEN, sport->port.membase + UCR2);
+        writel(temp & ~UCR2_RXEN, sport->port.membase + UCR2);
 }
 
 /*
@@ -490,9 +490,8 @@ static irqreturn_t imx_txint(int irq, void *dev_id)
         struct circ_buf *xmit = &sport->port.state->xmit;
         unsigned long flags;
 
-        spin_lock_irqsave(&sport->port.lock,flags);
-        if (sport->port.x_char)
-        {
+        spin_lock_irqsave(&sport->port.lock, flags);
+        if (sport->port.x_char) {
                 /* Send next char */
                 writel(sport->port.x_char, sport->port.membase + URTX0);
                 goto out;
@@ -509,18 +508,18 @@ static irqreturn_t imx_txint(int irq, void *dev_id)
                 uart_write_wakeup(&sport->port);
 
 out:
-        spin_unlock_irqrestore(&sport->port.lock,flags);
+        spin_unlock_irqrestore(&sport->port.lock, flags);
         return IRQ_HANDLED;
 }
 
 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.state->port.tty;
+        unsigned int rx, flg, ignored = 0;
+        struct tty_port *port = &sport->port.state->port;
         unsigned long flags, temp;
 
-        spin_lock_irqsave(&sport->port.lock,flags);
+        spin_lock_irqsave(&sport->port.lock, flags);
 
         while (readl(sport->port.membase + USR2) & USR2_RDR) {
                 flg = TTY_NORMAL;
@@ -570,12 +569,12 @@ static irqreturn_t imx_rxint(int irq, void *dev_id)
 #endif
                 }
 
-                tty_insert_flip_char(tty, rx, flg);
+                tty_insert_flip_char(port, rx, flg);
         }
 
 out:
-        spin_unlock_irqrestore(&sport->port.lock,flags);
-        tty_flip_buffer_push(tty);
+        spin_unlock_irqrestore(&sport->port.lock, flags);
+        tty_flip_buffer_push(port);
         return IRQ_HANDLED;
 }
 
@@ -654,7 +653,7 @@ static void imx_break_ctl(struct uart_port *port, int break_state)
 
         temp = readl(sport->port.membase + UCR1) & ~UCR1_SNDBRK;
 
-        if ( break_state != 0 )
+        if (break_state != 0)
                 temp |= UCR1_SNDBRK;
 
         writel(temp, sport->port.membase + UCR1);
@@ -696,8 +695,8 @@ static int imx_startup(struct uart_port *port)
                 temp |= UCR4_IRSC;
 
         /* set the trigger level for CTS */
-        temp &= ~(UCR4_CTSTL_MASK<<  UCR4_CTSTL_SHF);
-        temp |= CTSTL<<  UCR4_CTSTL_SHF;
+        temp &= ~(UCR4_CTSTL_MASK << UCR4_CTSTL_SHF);
+        temp |= CTSTL << UCR4_CTSTL_SHF;
 
         writel(temp & ~UCR4_DREN, sport->port.membase + UCR4);
 
@@ -799,7 +798,7 @@ static int imx_startup(struct uart_port *port)
          * Enable modem status interrupts
          */
         imx_enable_ms(&sport->port);
-        spin_unlock_irqrestore(&sport->port.lock,flags);
+        spin_unlock_irqrestore(&sport->port.lock, flags);
 
         if (USE_IRDA(sport)) {
                 struct imxuart_platform_data *pdata;
@@ -909,7 +908,7 @@ imx_set_termios(struct uart_port *port, struct ktermios *termios,
                 ucr2 = UCR2_SRST | UCR2_IRTS;
 
         if (termios->c_cflag & CRTSCTS) {
-                if( sport->have_rtscts ) {
+                if (sport->have_rtscts) {
                         ucr2 &= ~UCR2_IRTS;
                         ucr2 |= UCR2_CTSC;
                 } else {
@@ -969,12 +968,12 @@ imx_set_termios(struct uart_port *port, struct ktermios *termios,
         writel(old_ucr1 & ~(UCR1_TXMPTYEN | UCR1_RRDYEN | UCR1_RTSDEN),
                         sport->port.membase + UCR1);
 
-        while ( !(readl(sport->port.membase + USR2) & USR2_TXDC))
+        while (!(readl(sport->port.membase + USR2) & USR2_TXDC))
                 barrier();
 
         /* then, disable everything */
         old_txrxen = readl(sport->port.membase + UCR2);
-        writel(old_txrxen & ~( UCR2_TXEN | UCR2_RXEN),
+        writel(old_txrxen & ~(UCR2_TXEN | UCR2_RXEN),
                         sport->port.membase + UCR2);
         old_txrxen &= (UCR2_TXEN | UCR2_RXEN);
 
@@ -1212,9 +1211,15 @@ imx_console_write(struct console *co, const char *s, unsigned int count)
         struct imx_port *sport = imx_ports[co->index];
         struct imx_port_ucrs old_ucr;
         unsigned int ucr1;
-        unsigned long flags;
+        unsigned long flags = 0;
+        int locked = 1;
 
-        spin_lock_irqsave(&sport->port.lock, flags);
+        if (sport->port.sysrq)
+                locked = 0;
+        else if (oops_in_progress)
+                locked = spin_trylock_irqsave(&sport->port.lock, flags);
+        else
+                spin_lock_irqsave(&sport->port.lock, flags);
 
         /*
          *      First, save UCR1/2/3 and then disable interrupts
@@ -1241,7 +1246,8 @@ imx_console_write(struct console *co, const char *s, unsigned int count)
 
         imx_port_ucrs_restore(&sport->port, &old_ucr);
 
-        spin_unlock_irqrestore(&sport->port.lock, flags);
+        if (locked)
+                spin_unlock_irqrestore(&sport->port.lock, flags);
 }
 
 /*
@@ -1255,7 +1261,7 @@ imx_console_get_options(struct imx_port *sport, int *baud,
 
         if (readl(sport->port.membase + UCR1) & UCR1_UARTEN) {
                 /* ok, the port was enabled */
-                unsigned int ucr2, ubir,ubmr, uartclk;
+                unsigned int ucr2, ubir, ubmr, uartclk;
                 unsigned int baud_raw;
                 unsigned int ucfr_rfdiv;
 
@@ -1301,8 +1307,8 @@ imx_console_get_options(struct imx_port *sport, int *baud,
                         *baud = (baud_raw + 50) / 100 * 100;
                 }
 
-                if(*baud != baud_raw)
-                        printk(KERN_INFO "Serial: Console IMX rounded baud rate from %d to %d\n",
+                if (*baud != baud_raw)
+                        pr_info("Console IMX rounded baud rate from %d to %d\n",
                                 baud_raw, *baud);
         }
 }
@@ -1324,7 +1330,7 @@ imx_console_setup(struct console *co, char *options)
         if (co->index == -1 || co->index >= ARRAY_SIZE(imx_ports))
                 co->index = 0;
         sport = imx_ports[co->index];
-        if(sport == NULL)
+        if (sport == NULL)
                 return -ENODEV;
 
         if (options)
@@ -1462,7 +1468,7 @@ static int serial_imx_probe(struct platform_device *pdev)
         struct resource *res;
         struct pinctrl *pinctrl;
 
-        sport = kzalloc(sizeof(*sport), GFP_KERNEL);
+        sport = devm_kzalloc(&pdev->dev, sizeof(*sport), GFP_KERNEL);
         if (!sport)
                 return -ENOMEM;
 
@@ -1470,19 +1476,15 @@ static int serial_imx_probe(struct platform_device *pdev)
         if (ret > 0)
                 serial_imx_probe_pdata(sport, pdev);
         else if (ret < 0)
-                goto free;
+                return ret;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res) {
-                ret = -ENODEV;
-                goto free;
-        }
+        if (!res)
+                return -ENODEV;
 
-        base = ioremap(res->start, PAGE_SIZE);
-        if (!base) {
-                ret = -ENOMEM;
-                goto free;
-        }
+        base = devm_ioremap(&pdev->dev, res->start, PAGE_SIZE);
+        if (!base)
+                return -ENOMEM;
 
         sport->port.dev = &pdev->dev;
         sport->port.mapbase = res->start;
@@ -1504,21 +1506,21 @@ static int serial_imx_probe(struct platform_device *pdev)
         if (IS_ERR(pinctrl)) {
                 ret = PTR_ERR(pinctrl);
                 dev_err(&pdev->dev, "failed to get default pinctrl: %d\n", ret);
-                goto unmap;
+                return ret;
         }
 
         sport->clk_ipg = devm_clk_get(&pdev->dev, "ipg");
         if (IS_ERR(sport->clk_ipg)) {
                 ret = PTR_ERR(sport->clk_ipg);
                 dev_err(&pdev->dev, "failed to get ipg clk: %d\n", ret);
-                goto unmap;
+                return ret;
         }
 
         sport->clk_per = devm_clk_get(&pdev->dev, "per");
         if (IS_ERR(sport->clk_per)) {
                 ret = PTR_ERR(sport->clk_per);
                 dev_err(&pdev->dev, "failed to get per clk: %d\n", ret);
-                goto unmap;
+                return ret;
         }
 
         clk_prepare_enable(sport->clk_per);
@@ -1547,11 +1549,6 @@ deinit:
 clkput:
         clk_disable_unprepare(sport->clk_per);
         clk_disable_unprepare(sport->clk_ipg);
-unmap:
-        iounmap(sport->port.membase);
-free:
-        kfree(sport);
-
         return ret;
 }
 
@@ -1572,9 +1569,6 @@ static int serial_imx_remove(struct platform_device *pdev)
         if (pdata && pdata->exit)
                 pdata->exit(pdev);
 
-        iounmap(sport->port.membase);
-        kfree(sport);
-
         return 0;
 }
 
@@ -1596,7 +1590,7 @@ static int __init imx_serial_init(void)
 {
         int ret;
 
-        printk(KERN_INFO "Serial: IMX driver\n");
+        pr_info("Serial: IMX driver\n");
 
         ret = uart_register_driver(&imx_reg);
         if (ret)
diff --git a/drivers/tty/serial/ioc3_serial.c b/drivers/tty/serial/ioc3_serial.c
index d8f1d1d54471..6e4c715c5d26 100644
--- a/drivers/tty/serial/ioc3_serial.c
+++ b/drivers/tty/serial/ioc3_serial.c
@@ -1000,7 +1000,7 @@ ioc3_change_speed(struct uart_port *the_port,
 
         the_port->ignore_status_mask = N_ALL_INPUT;
 
-        state->port.tty->low_latency = 1;
+        state->port.low_latency = 1;
 
         if (iflag & IGNPAR)
                 the_port->ignore_status_mask &= ~(N_PARITY_ERROR
@@ -1393,7 +1393,6 @@ static inline int do_read(struct uart_port *the_port, char *buf, int len)
  */
 static int receive_chars(struct uart_port *the_port)
 {
-        struct tty_struct *tty;
         unsigned char ch[MAX_CHARS];
         int read_count = 0, read_room, flip = 0;
         struct uart_state *state = the_port->state;
@@ -1403,25 +1402,23 @@ static int receive_chars(struct uart_port *the_port)
         /* Make sure all the pointers are "good" ones */
         if (!state)
                 return 0;
-        if (!state->port.tty)
-                return 0;
 
         if (!(port->ip_flags & INPUT_ENABLE))
                 return 0;
 
         spin_lock_irqsave(&the_port->lock, pflags);
-        tty = state->port.tty;
 
         read_count = do_read(the_port, ch, MAX_CHARS);
         if (read_count > 0) {
                 flip = 1;
-                read_room = tty_insert_flip_string(tty, ch, read_count);
+                read_room = tty_insert_flip_string(&state->port, ch,
+                                read_count);
                 the_port->icount.rx += read_count;
         }
         spin_unlock_irqrestore(&the_port->lock, pflags);
 
         if (flip)
-                tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(&state->port);
 
         return read_count;
 }
diff --git a/drivers/tty/serial/ioc4_serial.c b/drivers/tty/serial/ioc4_serial.c
index 3e7da10cebba..e2520abcb1c4 100644
--- a/drivers/tty/serial/ioc4_serial.c
+++ b/drivers/tty/serial/ioc4_serial.c
@@ -1740,7 +1740,7 @@ ioc4_change_speed(struct uart_port *the_port,
 
         the_port->ignore_status_mask = N_ALL_INPUT;
 
-        state->port.tty->low_latency = 1;
+        state->port.low_latency = 1;
 
         if (iflag & IGNPAR)
                 the_port->ignore_status_mask &= ~(N_PARITY_ERROR
@@ -2340,7 +2340,6 @@ static inline int do_read(struct uart_port *the_port, unsigned char *buf,
  */
 static void receive_chars(struct uart_port *the_port)
 {
-        struct tty_struct *tty;
         unsigned char ch[IOC4_MAX_CHARS];
         int read_count, request_count = IOC4_MAX_CHARS;
         struct uart_icount *icount;
@@ -2350,26 +2349,23 @@ static void receive_chars(struct uart_port *the_port)
         /* Make sure all the pointers are "good" ones */
         if (!state)
                 return;
-        if (!state->port.tty)
-                return;
 
         spin_lock_irqsave(&the_port->lock, pflags);
-        tty = state->port.tty;
 
-        request_count = tty_buffer_request_room(tty, IOC4_MAX_CHARS);
+        request_count = tty_buffer_request_room(&state->port, IOC4_MAX_CHARS);
 
         if (request_count > 0) {
                 icount = &the_port->icount;
                 read_count = do_read(the_port, ch, request_count);
                 if (read_count > 0) {
-                        tty_insert_flip_string(tty, ch, read_count);
+                        tty_insert_flip_string(&state->port, ch, read_count);
                         icount->rx += read_count;
                 }
         }
 
         spin_unlock_irqrestore(&the_port->lock, pflags);
 
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&state->port);
 }
 
 /**
@@ -2883,6 +2879,7 @@ ioc4_serial_attach_one(struct ioc4_driver_data *idd)
         /* error exits that give back resources */
 out5:
         ioc4_serial_remove_one(idd);
+        return ret;
 out4:
         kfree(soft);
 out3:
diff --git a/drivers/tty/serial/ip22zilog.c b/drivers/tty/serial/ip22zilog.c
index 7b1cda59ebb5..cb3c81eb0996 100644
--- a/drivers/tty/serial/ip22zilog.c
+++ b/drivers/tty/serial/ip22zilog.c
@@ -248,17 +248,12 @@ static void ip22zilog_maybe_update_regs(struct uart_ip22zilog_port *up,
 #define Rx_BRK 0x0100                   /* BREAK event software flag.  */
 #define Rx_SYS 0x0200                   /* SysRq event software flag.  */
 
-static struct tty_struct *ip22zilog_receive_chars(struct uart_ip22zilog_port *up,
+static bool ip22zilog_receive_chars(struct uart_ip22zilog_port *up,
                                                   struct zilog_channel *channel)
 {
-        struct tty_struct *tty;
         unsigned char ch, flag;
         unsigned int r1;
-
-        tty = NULL;
-        if (up->port.state != NULL &&
-            up->port.state->port.tty != NULL)
-                tty = up->port.state->port.tty;
+        bool push = up->port.state != NULL;
 
         for (;;) {
                 ch = readb(&channel->control);
@@ -312,10 +307,10 @@ static struct tty_struct *ip22zilog_receive_chars(struct uart_ip22zilog_port *up
                 if (uart_handle_sysrq_char(&up->port, ch))
                         continue;
 
-                if (tty)
+                if (push)
                         uart_insert_char(&up->port, r1, Rx_OVR, ch, flag);
         }
-        return tty;
+        return push;
 }
 
 static void ip22zilog_status_handle(struct uart_ip22zilog_port *up,
@@ -438,21 +433,20 @@ static irqreturn_t ip22zilog_interrupt(int irq, void *dev_id)
         while (up) {
                 struct zilog_channel *channel
                         = ZILOG_CHANNEL_FROM_PORT(&up->port);
-                struct tty_struct *tty;
                 unsigned char r3;
+                bool push = false;
 
                 spin_lock(&up->port.lock);
                 r3 = read_zsreg(channel, R3);
 
                 /* Channel A */
-                tty = NULL;
                 if (r3 & (CHAEXT | CHATxIP | CHARxIP)) {
                         writeb(RES_H_IUS, &channel->control);
                         ZSDELAY();
                         ZS_WSYNC(channel);
 
                         if (r3 & CHARxIP)
-                                tty = ip22zilog_receive_chars(up, channel);
+                                push = ip22zilog_receive_chars(up, channel);
                         if (r3 & CHAEXT)
                                 ip22zilog_status_handle(up, channel);
                         if (r3 & CHATxIP)
@@ -460,22 +454,22 @@ static irqreturn_t ip22zilog_interrupt(int irq, void *dev_id)
                 }
                 spin_unlock(&up->port.lock);
 
-                if (tty)
-                        tty_flip_buffer_push(tty);
+                if (push)
+                        tty_flip_buffer_push(&up->port.state->port);
 
                 /* Channel B */
                 up = up->next;
                 channel = ZILOG_CHANNEL_FROM_PORT(&up->port);
+                push = false;
 
                 spin_lock(&up->port.lock);
-                tty = NULL;
                 if (r3 & (CHBEXT | CHBTxIP | CHBRxIP)) {
                         writeb(RES_H_IUS, &channel->control);
                         ZSDELAY();
                         ZS_WSYNC(channel);
 
                         if (r3 & CHBRxIP)
-                                tty = ip22zilog_receive_chars(up, channel);
+                                push = ip22zilog_receive_chars(up, channel);
                         if (r3 & CHBEXT)
                                 ip22zilog_status_handle(up, channel);
                         if (r3 & CHBTxIP)
@@ -483,8 +477,8 @@ static irqreturn_t ip22zilog_interrupt(int irq, void *dev_id)
                 }
                 spin_unlock(&up->port.lock);
 
-                if (tty)
-                        tty_flip_buffer_push(tty);
+                if (push)
+                        tty_flip_buffer_push(&up->port.state->port);
 
                 up = up->next;
         }
diff --git a/drivers/tty/serial/jsm/jsm_tty.c b/drivers/tty/serial/jsm/jsm_tty.c
index 4c00c5550b1a..00f250ae14c5 100644
--- a/drivers/tty/serial/jsm/jsm_tty.c
+++ b/drivers/tty/serial/jsm/jsm_tty.c
@@ -521,6 +521,7 @@ void jsm_input(struct jsm_channel *ch)
 {
         struct jsm_board *bd;
         struct tty_struct *tp;
+        struct tty_port *port;
         u32 rmask;
         u16 head;
         u16 tail;
@@ -536,7 +537,8 @@ void jsm_input(struct jsm_channel *ch)
         if (!ch)
                 return;
 
-        tp = ch->uart_port.state->port.tty;
+        port = &ch->uart_port.state->port;
+        tp = port->tty;
 
         bd = ch->ch_bd;
         if(!bd)
@@ -600,7 +602,7 @@ void jsm_input(struct jsm_channel *ch)
                 return;
         }
 
-        len = tty_buffer_request_room(tp, data_len);
+        len = tty_buffer_request_room(port, data_len);
         n = len;
 
         /*
@@ -629,16 +631,16 @@ void jsm_input(struct jsm_channel *ch)
                                  * format it likes.
                                  */
                                 if (*(ch->ch_equeue +tail +i) & UART_LSR_BI)
-                                        tty_insert_flip_char(tp, *(ch->ch_rqueue +tail +i),  TTY_BREAK);
+                                        tty_insert_flip_char(port, *(ch->ch_rqueue +tail +i),  TTY_BREAK);
                                 else if (*(ch->ch_equeue +tail +i) & UART_LSR_PE)
-                                        tty_insert_flip_char(tp, *(ch->ch_rqueue +tail +i), TTY_PARITY);
+                                        tty_insert_flip_char(port, *(ch->ch_rqueue +tail +i), TTY_PARITY);
                                 else if (*(ch->ch_equeue +tail +i) & UART_LSR_FE)
-                                        tty_insert_flip_char(tp, *(ch->ch_rqueue +tail +i), TTY_FRAME);
+                                        tty_insert_flip_char(port, *(ch->ch_rqueue +tail +i), TTY_FRAME);
                                 else
-                                        tty_insert_flip_char(tp, *(ch->ch_rqueue +tail +i), TTY_NORMAL);
+                                        tty_insert_flip_char(port, *(ch->ch_rqueue +tail +i), TTY_NORMAL);
                         }
                 } else {
-                        tty_insert_flip_string(tp, ch->ch_rqueue + tail, s) ;
+                        tty_insert_flip_string(port, ch->ch_rqueue + tail, s);
                 }
                 tail += s;
                 n -= s;
@@ -652,7 +654,7 @@ void jsm_input(struct jsm_channel *ch)
         spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
 
         /* Tell the tty layer its okay to "eat" the data now */
-        tty_flip_buffer_push(tp);
+        tty_flip_buffer_push(port);
 
         jsm_dbg(IOCTL, &ch->ch_bd->pci_dev, "finish\n");
 }
diff --git a/drivers/tty/serial/kgdb_nmi.c b/drivers/tty/serial/kgdb_nmi.c
index 6ac2b797a764..5dafcf1c227b 100644
--- a/drivers/tty/serial/kgdb_nmi.c
+++ b/drivers/tty/serial/kgdb_nmi.c
@@ -23,6 +23,7 @@
 #include <linux/tty.h>
 #include <linux/tty_driver.h>
 #include <linux/tty_flip.h>
+#include <linux/serial_core.h>
 #include <linux/interrupt.h>
 #include <linux/hrtimer.h>
 #include <linux/tick.h>
@@ -202,7 +203,6 @@ bool kgdb_nmi_poll_knock(void)
 static void kgdb_nmi_tty_receiver(unsigned long data)
 {
         struct kgdb_nmi_tty_priv *priv = (void *)data;
-        struct tty_struct *tty;
         char ch;
 
         tasklet_schedule(&priv->tlet);
@@ -210,16 +210,9 @@ static void kgdb_nmi_tty_receiver(unsigned long data)
         if (likely(!kgdb_nmi_tty_enabled || !kfifo_len(&priv->fifo)))
                 return;
 
-        /* Port is there, but tty might be hung up, check. */
-        tty = tty_port_tty_get(kgdb_nmi_port);
-        if (!tty)
-                return;
-
         while (kfifo_out(&priv->fifo, &ch, 1))
-                tty_insert_flip_char(priv->port.tty, ch, TTY_NORMAL);
-        tty_flip_buffer_push(priv->port.tty);
-
-        tty_kref_put(tty);
+                tty_insert_flip_char(&priv->port, ch, TTY_NORMAL);
+        tty_flip_buffer_push(&priv->port);
 }
 
 static int kgdb_nmi_tty_activate(struct tty_port *port, struct tty_struct *tty)
diff --git a/drivers/tty/serial/lantiq.c b/drivers/tty/serial/lantiq.c
index 02da071fe1e7..15733da757c6 100644
--- a/drivers/tty/serial/lantiq.c
+++ b/drivers/tty/serial/lantiq.c
@@ -162,21 +162,16 @@ lqasc_enable_ms(struct uart_port *port)
 static int
 lqasc_rx_chars(struct uart_port *port)
 {
-        struct tty_struct *tty = tty_port_tty_get(&port->state->port);
+        struct tty_port *tport = &port->state->port;
         unsigned int ch = 0, rsr = 0, fifocnt;
 
-        if (!tty) {
-                dev_dbg(port->dev, "%s:tty is busy now", __func__);
-                return -EBUSY;
-        }
-        fifocnt =
-                ltq_r32(port->membase + LTQ_ASC_FSTAT) & ASCFSTAT_RXFFLMASK;
+        fifocnt = ltq_r32(port->membase + LTQ_ASC_FSTAT) & ASCFSTAT_RXFFLMASK;
         while (fifocnt--) {
                 u8 flag = TTY_NORMAL;
                 ch = ltq_r8(port->membase + LTQ_ASC_RBUF);
                 rsr = (ltq_r32(port->membase + LTQ_ASC_STATE)
                         & ASCSTATE_ANY) | UART_DUMMY_UER_RX;
-                tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(tport);
                 port->icount.rx++;
 
                 /*
@@ -208,7 +203,7 @@ lqasc_rx_chars(struct uart_port *port)
                 }
 
                 if ((rsr & port->ignore_status_mask) == 0)
-                        tty_insert_flip_char(tty, ch, flag);
+                        tty_insert_flip_char(tport, ch, flag);
 
                 if (rsr & ASCSTATE_ROE)
                         /*
@@ -216,11 +211,12 @@ lqasc_rx_chars(struct uart_port *port)
                          * immediately, and doesn't affect the current
                          * character
                          */
-                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                        tty_insert_flip_char(tport, 0, TTY_OVERRUN);
         }
+
         if (ch != 0)
-                tty_flip_buffer_push(tty);
-        tty_kref_put(tty);
+                tty_flip_buffer_push(tport);
+
         return 0;
 }
 
diff --git a/drivers/tty/serial/lpc32xx_hs.c b/drivers/tty/serial/lpc32xx_hs.c
index 0e86bff3fe2a..dffea6b2cd7d 100644
--- a/drivers/tty/serial/lpc32xx_hs.c
+++ b/drivers/tty/serial/lpc32xx_hs.c
@@ -257,17 +257,8 @@ static void __serial_uart_flush(struct uart_port *port)
 
 static void __serial_lpc32xx_rx(struct uart_port *port)
 {
+        struct tty_port *tport = &port->state->port;
         unsigned int tmp, flag;
-        struct tty_struct *tty = tty_port_tty_get(&port->state->port);
-
-        if (!tty) {
-                /* Discard data: no tty available */
-                while (!(readl(LPC32XX_HSUART_FIFO(port->membase)) &
-                         LPC32XX_HSU_RX_EMPTY))
-                        ;
-
-                return;
-        }
 
         /* Read data from FIFO and push into terminal */
         tmp = readl(LPC32XX_HSUART_FIFO(port->membase));
@@ -281,15 +272,14 @@ static void __serial_lpc32xx_rx(struct uart_port *port)
                                LPC32XX_HSUART_IIR(port->membase));
                         port->icount.frame++;
                         flag = TTY_FRAME;
-                        tty_insert_flip_char(tty, 0, TTY_FRAME);
+                        tty_insert_flip_char(tport, 0, TTY_FRAME);
                 }
 
-                tty_insert_flip_char(tty, (tmp & 0xFF), flag);
+                tty_insert_flip_char(tport, (tmp & 0xFF), flag);
 
                 tmp = readl(LPC32XX_HSUART_FIFO(port->membase));
         }
-        tty_flip_buffer_push(tty);
-        tty_kref_put(tty);
+        tty_flip_buffer_push(tport);
 }
 
 static void __serial_lpc32xx_tx(struct uart_port *port)
@@ -332,7 +322,7 @@ exit_tx:
 static irqreturn_t serial_lpc32xx_interrupt(int irq, void *dev_id)
 {
         struct uart_port *port = dev_id;
-        struct tty_struct *tty = tty_port_tty_get(&port->state->port);
+        struct tty_port *tport = &port->state->port;
         u32 status;
 
         spin_lock(&port->lock);
@@ -356,17 +346,14 @@ static irqreturn_t serial_lpc32xx_interrupt(int irq, void *dev_id)
                 writel(LPC32XX_HSU_RX_OE_INT,
                        LPC32XX_HSUART_IIR(port->membase));
                 port->icount.overrun++;
-                if (tty) {
-                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
-                        tty_schedule_flip(tty);
-                }
+                tty_insert_flip_char(tport, 0, TTY_OVERRUN);
+                tty_schedule_flip(tport);
         }
 
         /* Data received? */
         if (status & (LPC32XX_HSU_RX_TIMEOUT_INT | LPC32XX_HSU_RX_TRIG_INT)) {
                 __serial_lpc32xx_rx(port);
-                if (tty)
-                        tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(tport);
         }
 
         /* Transmit data request? */
@@ -376,7 +363,6 @@ static irqreturn_t serial_lpc32xx_interrupt(int irq, void *dev_id)
         }
 
         spin_unlock(&port->lock);
-        tty_kref_put(tty);
 
         return IRQ_HANDLED;
 }
diff --git a/drivers/tty/serial/m32r_sio.c b/drivers/tty/serial/m32r_sio.c
index b13949ad3408..bb1afa0922e1 100644
--- a/drivers/tty/serial/m32r_sio.c
+++ b/drivers/tty/serial/m32r_sio.c
@@ -300,7 +300,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.state->port.tty;
+        struct tty_port *port = &up->port.state->port;
         unsigned char ch;
         unsigned char flag;
         int max_count = 256;
@@ -355,7 +355,7 @@ static void receive_chars(struct uart_sio_port *up, int *status)
                 if (uart_handle_sysrq_char(&up->port, ch))
                         goto ignore_char;
                 if ((*status & up->port.ignore_status_mask) == 0)
-                        tty_insert_flip_char(tty, ch, flag);
+                        tty_insert_flip_char(port, ch, flag);
 
                 if (*status & UART_LSR_OE) {
                         /*
@@ -363,12 +363,12 @@ static void receive_chars(struct uart_sio_port *up, int *status)
                          * immediately, and doesn't affect the current
                          * character.
                          */
-                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                        tty_insert_flip_char(port, 0, TTY_OVERRUN);
                 }
         ignore_char:
                 *status = serial_in(up, UART_LSR);
         } while ((*status & UART_LSR_DR) && (max_count-- > 0));
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(port);
 }
 
 static void transmit_chars(struct uart_sio_port *up)
diff --git a/drivers/tty/serial/max3100.c b/drivers/tty/serial/max3100.c
index dd6277eb5a38..32517d4bceab 100644
--- a/drivers/tty/serial/max3100.c
+++ b/drivers/tty/serial/max3100.c
@@ -310,8 +310,8 @@ static void max3100_work(struct work_struct *w)
                         }
                 }
 
-                if (rxchars > 16 && s->port.state->port.tty != NULL) {
-                        tty_flip_buffer_push(s->port.state->port.tty);
+                if (rxchars > 16) {
+                        tty_flip_buffer_push(&s->port.state->port);
                         rxchars = 0;
                 }
                 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
@@ -323,8 +323,8 @@ static void max3100_work(struct work_struct *w)
                   (!uart_circ_empty(xmit) &&
                    !uart_tx_stopped(&s->port))));
 
-        if (rxchars > 0 && s->port.state->port.tty != NULL)
-                tty_flip_buffer_push(s->port.state->port.tty);
+        if (rxchars > 0)
+                tty_flip_buffer_push(&s->port.state->port);
 }
 
 static irqreturn_t max3100_irq(int irqno, void *dev_id)
@@ -529,7 +529,7 @@ max3100_set_termios(struct uart_port *port, struct ktermios *termios,
                         MAX3100_STATUS_OE;
 
         /* we are sending char from a workqueue so enable */
-        s->port.state->port.tty->low_latency = 1;
+        s->port.state->port.low_latency = 1;
 
         if (s->poll_time > 0)
                 del_timer_sync(&s->timer);
diff --git a/drivers/tty/serial/max310x.c b/drivers/tty/serial/max310x.c
index a801f6872cad..0c2422cb04ea 100644
--- a/drivers/tty/serial/max310x.c
+++ b/drivers/tty/serial/max310x.c
@@ -460,10 +460,6 @@ static int max310x_set_ref_clk(struct max310x_port *s)
 static void max310x_handle_rx(struct max310x_port *s, unsigned int rxlen)
 {
         unsigned int sts = 0, ch = 0, flag;
-        struct tty_struct *tty = tty_port_tty_get(&s->port.state->port);
-
-        if (!tty)
-                return;
 
         if (unlikely(rxlen >= MAX310X_FIFO_SIZE)) {
                 dev_warn(s->port.dev, "Possible RX FIFO overrun %d\n", rxlen);
@@ -516,9 +512,7 @@ static void max310x_handle_rx(struct max310x_port *s, unsigned int rxlen)
                                  ch, flag);
         }
 
-        tty_flip_buffer_push(tty);
-
-        tty_kref_put(tty);
+        tty_flip_buffer_push(&s->port.state->port);
 }
 
 static void max310x_handle_tx(struct max310x_port *s)
diff --git a/drivers/tty/serial/mcf.c b/drivers/tty/serial/mcf.c
index fcd56ab6053f..e956377a38fe 100644
--- a/drivers/tty/serial/mcf.c
+++ b/drivers/tty/serial/mcf.c
@@ -23,6 +23,7 @@
 #include <linux/serial.h>
 #include <linux/serial_core.h>
 #include <linux/io.h>
+#include <linux/uaccess.h>
 #include <asm/coldfire.h>
 #include <asm/mcfsim.h>
 #include <asm/mcfuart.h>
@@ -55,6 +56,7 @@ struct mcf_uart {
         struct uart_port        port;
         unsigned int            sigs;           /* Local copy of line sigs */
         unsigned char           imr;            /* Local IMR mirror */
+        struct serial_rs485     rs485;          /* RS485 settings */
 };
 
 /****************************************************************************/
@@ -101,6 +103,12 @@ static void mcf_start_tx(struct uart_port *port)
 {
         struct mcf_uart *pp = container_of(port, struct mcf_uart, port);
 
+        if (pp->rs485.flags & SER_RS485_ENABLED) {
+                /* Enable Transmitter */
+                writeb(MCFUART_UCR_TXENABLE, port->membase + MCFUART_UCR);
+                /* Manually assert RTS */
+                writeb(MCFUART_UOP_RTS, port->membase + MCFUART_UOP1);
+        }
         pp->imr |= MCFUART_UIR_TXREADY;
         writeb(pp->imr, port->membase + MCFUART_UIMR);
 }
@@ -196,6 +204,7 @@ static void mcf_shutdown(struct uart_port *port)
 static void mcf_set_termios(struct uart_port *port, struct ktermios *termios,
         struct ktermios *old)
 {
+        struct mcf_uart *pp = container_of(port, struct mcf_uart, port);
         unsigned long flags;
         unsigned int baud, baudclk;
 #if defined(CONFIG_M5272)
@@ -248,6 +257,11 @@ static void mcf_set_termios(struct uart_port *port, struct ktermios *termios,
                 mr2 |= MCFUART_MR2_TXCTS;
         }
 
+        if (pp->rs485.flags & SER_RS485_ENABLED) {
+                dev_dbg(port->dev, "Setting UART to RS485\n");
+                mr2 |= MCFUART_MR2_TXRTS;
+        }
+
         spin_lock_irqsave(&port->lock, flags);
         uart_update_timeout(port, termios->c_cflag, baud);
         writeb(MCFUART_UCR_CMDRESETRX, port->membase + MCFUART_UCR);
@@ -310,7 +324,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->state->port.tty);
+        tty_flip_buffer_push(&port->state->port);
 }
 
 /****************************************************************************/
@@ -342,6 +356,10 @@ static void mcf_tx_chars(struct mcf_uart *pp)
         if (xmit->head == xmit->tail) {
                 pp->imr &= ~MCFUART_UIR_TXREADY;
                 writeb(pp->imr, port->membase + MCFUART_UIMR);
+                /* Disable TX to negate RTS automatically */
+                if (pp->rs485.flags & SER_RS485_ENABLED)
+                        writeb(MCFUART_UCR_TXDISABLE,
+                                port->membase + MCFUART_UCR);
         }
 }
 
@@ -418,6 +436,58 @@ static int mcf_verify_port(struct uart_port *port, struct serial_struct *ser)
 
 /****************************************************************************/
 
+/* Enable or disable the RS485 support */
+static void mcf_config_rs485(struct uart_port *port, struct serial_rs485 *rs485)
+{
+        struct mcf_uart *pp = container_of(port, struct mcf_uart, port);
+        unsigned long flags;
+        unsigned char mr1, mr2;
+
+        spin_lock_irqsave(&port->lock, flags);
+        /* Get mode registers */
+        mr1 = readb(port->membase + MCFUART_UMR);
+        mr2 = readb(port->membase + MCFUART_UMR);
+        if (rs485->flags & SER_RS485_ENABLED) {
+                dev_dbg(port->dev, "Setting UART to RS485\n");
+                /* Automatically negate RTS after TX completes */
+                mr2 |= MCFUART_MR2_TXRTS;
+        } else {
+                dev_dbg(port->dev, "Setting UART to RS232\n");
+                mr2 &= ~MCFUART_MR2_TXRTS;
+        }
+        writeb(mr1, port->membase + MCFUART_UMR);
+        writeb(mr2, port->membase + MCFUART_UMR);
+        pp->rs485 = *rs485;
+        spin_unlock_irqrestore(&port->lock, flags);
+}
+
+static int mcf_ioctl(struct uart_port *port, unsigned int cmd,
+                unsigned long arg)
+{
+        switch (cmd) {
+        case TIOCSRS485: {
+                struct serial_rs485 rs485;
+                if (copy_from_user(&rs485, (struct serial_rs485 *)arg,
+                                sizeof(struct serial_rs485)))
+                        return -EFAULT;
+                mcf_config_rs485(port, &rs485);
+                break;
+        }
+        case TIOCGRS485: {
+                struct mcf_uart *pp = container_of(port, struct mcf_uart, port);
+                if (copy_to_user((struct serial_rs485 *)arg, &pp->rs485,
+                                sizeof(struct serial_rs485)))
+                        return -EFAULT;
+                break;
+        }
+        default:
+                return -ENOIOCTLCMD;
+        }
+        return 0;
+}
+
+/****************************************************************************/
+
 /*
  *      Define the basic serial functions we support.
  */
@@ -438,6 +508,7 @@ static const struct uart_ops mcf_uart_ops = {
         .release_port   = mcf_release_port,
         .config_port    = mcf_config_port,
         .verify_port    = mcf_verify_port,
+        .ioctl          = mcf_ioctl,
 };
 
 static struct mcf_uart mcf_ports[4];
diff --git a/drivers/tty/serial/mfd.c b/drivers/tty/serial/mfd.c
index 2c01344dc332..5f4765a7a5c5 100644
--- a/drivers/tty/serial/mfd.c
+++ b/drivers/tty/serial/mfd.c
@@ -387,12 +387,9 @@ void hsu_dma_rx(struct uart_hsu_port *up, u32 int_sts)
         struct hsu_dma_buffer *dbuf = &up->rxbuf;
         struct hsu_dma_chan *chan = up->rxc;
         struct uart_port *port = &up->port;
-        struct tty_struct *tty = port->state->port.tty;
+        struct tty_port *tport = &port->state->port;
         int count;
 
-        if (!tty)
-                return;
-
         /*
          * First need to know how many is already transferred,
          * then check if its a timeout DMA irq, and return
@@ -423,7 +420,7 @@ void hsu_dma_rx(struct uart_hsu_port *up, u32 int_sts)
          * explicitly set tail to 0. So head will
          * always be greater than tail.
          */
-        tty_insert_flip_string(tty, dbuf->buf, count);
+        tty_insert_flip_string(tport, dbuf->buf, count);
         port->icount.rx += count;
 
         dma_sync_single_for_device(up->port.dev, dbuf->dma_addr,
@@ -437,7 +434,7 @@ void hsu_dma_rx(struct uart_hsu_port *up, u32 int_sts)
                                          | (0x1 << 16)
                                          | (0x1 << 24)  /* timeout bit, see HSU Errata 1 */
                                          );
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(tport);
 
         chan_writel(chan, HSU_CH_CR, 0x3);
 
@@ -460,13 +457,9 @@ static void serial_hsu_stop_rx(struct uart_port *port)
 
 static inline void receive_chars(struct uart_hsu_port *up, int *status)
 {
-        struct tty_struct *tty = up->port.state->port.tty;
         unsigned int ch, flag;
         unsigned int max_count = 256;
 
-        if (!tty)
-                return;
-
         do {
                 ch = serial_in(up, UART_RX);
                 flag = TTY_NORMAL;
@@ -522,7 +515,7 @@ static inline void receive_chars(struct uart_hsu_port *up, int *status)
         ignore_char:
                 *status = serial_in(up, UART_LSR);
         } while ((*status & UART_LSR_DR) && max_count--);
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&up->port.state->port);
 }
 
 static void transmit_chars(struct uart_hsu_port *up)
diff --git a/drivers/tty/serial/mpc52xx_uart.c b/drivers/tty/serial/mpc52xx_uart.c
index 7c23c4f4c58d..c0e1fad51be7 100644
--- a/drivers/tty/serial/mpc52xx_uart.c
+++ b/drivers/tty/serial/mpc52xx_uart.c
@@ -941,7 +941,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->state->port.tty;
+        struct tty_port *tport = &port->state->port;
         unsigned char ch, flag;
         unsigned short status;
 
@@ -986,20 +986,20 @@ mpc52xx_uart_int_rx_chars(struct uart_port *port)
                         out_8(&PSC(port)->command, MPC52xx_PSC_RST_ERR_STAT);
 
                 }
-                tty_insert_flip_char(tty, ch, flag);
+                tty_insert_flip_char(tport, ch, flag);
                 if (status & MPC52xx_PSC_SR_OE) {
                         /*
                          * Overrun is special, since it's
                          * reported immediately, and doesn't
                          * affect the current character
                          */
-                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                        tty_insert_flip_char(tport, 0, TTY_OVERRUN);
                         port->icount.overrun++;
                 }
         }
 
         spin_unlock(&port->lock);
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(tport);
         spin_lock(&port->lock);
 
         return psc_ops->raw_rx_rdy(port);
diff --git a/drivers/tty/serial/mpsc.c b/drivers/tty/serial/mpsc.c
index 6a9c6605666a..bc24f4931670 100644
--- a/drivers/tty/serial/mpsc.c
+++ b/drivers/tty/serial/mpsc.c
@@ -937,7 +937,7 @@ static int serial_polled;
 static int mpsc_rx_intr(struct mpsc_port_info *pi)
 {
         struct mpsc_rx_desc *rxre;
-        struct tty_struct *tty = pi->port.state->port.tty;
+        struct tty_port *port = &pi->port.state->port;
         u32     cmdstat, bytes_in, i;
         int     rc = 0;
         u8      *bp;
@@ -968,10 +968,9 @@ static int mpsc_rx_intr(struct mpsc_port_info *pi)
                 }
 #endif
                 /* Following use of tty struct directly is deprecated */
-                if (unlikely(tty_buffer_request_room(tty, bytes_in)
-                                        < bytes_in)) {
-                        if (tty->low_latency)
-                                tty_flip_buffer_push(tty);
+                if (tty_buffer_request_room(port, bytes_in) < bytes_in) {
+                        if (port->low_latency)
+                                tty_flip_buffer_push(port);
                         /*
                          * If this failed then we will throw away the bytes
                          * but must do so to clear interrupts.
@@ -1040,10 +1039,10 @@ static int mpsc_rx_intr(struct mpsc_port_info *pi)
                                                 | SDMA_DESC_CMDSTAT_FR
                                                 | SDMA_DESC_CMDSTAT_OR)))
                                 && !(cmdstat & pi->port.ignore_status_mask)) {
-                        tty_insert_flip_char(tty, *bp, flag);
+                        tty_insert_flip_char(port, *bp, flag);
                 } else {
                         for (i=0; i<bytes_in; i++)
-                                tty_insert_flip_char(tty, *bp++, TTY_NORMAL);
+                                tty_insert_flip_char(port, *bp++, TTY_NORMAL);
 
                         pi->port.icount.rx += bytes_in;
                 }
@@ -1081,7 +1080,7 @@ next_frame:
         if ((readl(pi->sdma_base + SDMA_SDCM) & SDMA_SDCM_ERD) == 0)
                 mpsc_start_rx(pi);
 
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(port);
         return rc;
 }
 
diff --git a/drivers/tty/serial/mrst_max3110.c b/drivers/tty/serial/mrst_max3110.c
index 58734d7e746d..f641c232beca 100644
--- a/drivers/tty/serial/mrst_max3110.c
+++ b/drivers/tty/serial/mrst_max3110.c
@@ -339,7 +339,7 @@ static int
 receive_chars(struct uart_max3110 *max, unsigned short *str, int len)
 {
         struct uart_port *port = &max->port;
-        struct tty_struct *tty;
+        struct tty_port *tport;
         char buf[M3110_RX_FIFO_DEPTH];
         int r, w, usable;
 
@@ -347,9 +347,7 @@ receive_chars(struct uart_max3110 *max, unsigned short *str, int len)
         if (!port->state)
                 return 0;
 
-        tty = tty_port_tty_get(&port->state->port);
-        if (!tty)
-                return 0;
+        tport = &port->state->port;
 
         for (r = 0, w = 0; r < len; r++) {
                 if (str[r] & MAX3110_BREAK &&
@@ -364,20 +362,17 @@ receive_chars(struct uart_max3110 *max, unsigned short *str, int len)
                 }
         }
 
-        if (!w) {
-                tty_kref_put(tty);
+        if (!w)
                 return 0;
-        }
 
         for (r = 0; w; r += usable, w -= usable) {
-                usable = tty_buffer_request_room(tty, w);
+                usable = tty_buffer_request_room(tport, w);
                 if (usable) {
-                        tty_insert_flip_string(tty, buf + r, usable);
+                        tty_insert_flip_string(tport, buf + r, usable);
                         port->icount.rx += usable;
                 }
         }
-        tty_flip_buffer_push(tty);
-        tty_kref_put(tty);
+        tty_flip_buffer_push(tport);
 
         return r;
 }
@@ -493,7 +488,7 @@ static int serial_m3110_startup(struct uart_port *port)
                         | WC_BAUD_DR2;
 
         /* as we use thread to handle tx/rx, need set low latency */
-        port->state->port.tty->low_latency = 1;
+        port->state->port.low_latency = 1;
 
         if (max->irq) {
                 max->read_thread = NULL;
diff --git a/drivers/tty/serial/msm_serial.c b/drivers/tty/serial/msm_serial.c
index 95fd39be2934..b11e99797fd8 100644
--- a/drivers/tty/serial/msm_serial.c
+++ b/drivers/tty/serial/msm_serial.c
@@ -91,14 +91,14 @@ static void msm_enable_ms(struct uart_port *port)
 
 static void handle_rx_dm(struct uart_port *port, unsigned int misr)
 {
-        struct tty_struct *tty = port->state->port.tty;
+        struct tty_port *tport = &port->state->port;
         unsigned int sr;
         int count = 0;
         struct msm_port *msm_port = UART_TO_MSM(port);
 
         if ((msm_read(port, UART_SR) & UART_SR_OVERRUN)) {
                 port->icount.overrun++;
-                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                tty_insert_flip_char(tport, 0, TTY_OVERRUN);
                 msm_write(port, UART_CR_CMD_RESET_ERR, UART_CR);
         }
 
@@ -132,12 +132,12 @@ static void handle_rx_dm(struct uart_port *port, unsigned int misr)
                         port->icount.frame++;
 
                 /* TODO: handle sysrq */
-                tty_insert_flip_string(tty, (char *) &c,
+                tty_insert_flip_string(tport, (char *)&c,
                                        (count > 4) ? 4 : count);
                 count -= 4;
         }
 
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(tport);
         if (misr & (UART_IMR_RXSTALE))
                 msm_write(port, UART_CR_CMD_RESET_STALE_INT, UART_CR);
         msm_write(port, 0xFFFFFF, UARTDM_DMRX);
@@ -146,7 +146,7 @@ static void handle_rx_dm(struct uart_port *port, unsigned int misr)
 
 static void handle_rx(struct uart_port *port)
 {
-        struct tty_struct *tty = port->state->port.tty;
+        struct tty_port *tport = &port->state->port;
         unsigned int sr;
 
         /*
@@ -155,7 +155,7 @@ static void handle_rx(struct uart_port *port)
          */
         if ((msm_read(port, UART_SR) & UART_SR_OVERRUN)) {
                 port->icount.overrun++;
-                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                tty_insert_flip_char(tport, 0, TTY_OVERRUN);
                 msm_write(port, UART_CR_CMD_RESET_ERR, UART_CR);
         }
 
@@ -186,10 +186,10 @@ static void handle_rx(struct uart_port *port)
                 }
 
                 if (!uart_handle_sysrq_char(port, c))
-                        tty_insert_flip_char(tty, c, flag);
+                        tty_insert_flip_char(tport, c, flag);
         }
 
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(tport);
 }
 
 static void reset_dm_count(struct uart_port *port)
diff --git a/drivers/tty/serial/msm_serial_hs.c b/drivers/tty/serial/msm_serial_hs.c
index 1fa92284ade0..4a942c78347e 100644
--- a/drivers/tty/serial/msm_serial_hs.c
+++ b/drivers/tty/serial/msm_serial_hs.c
@@ -908,6 +908,7 @@ static void msm_hs_dmov_rx_callback(struct msm_dmov_cmd *cmd_ptr,
         unsigned long flags;
         unsigned int flush;
         struct tty_struct *tty;
+        struct tty_port *port;
         struct uart_port *uport;
         struct msm_hs_port *msm_uport;
 
@@ -917,7 +918,8 @@ static void msm_hs_dmov_rx_callback(struct msm_dmov_cmd *cmd_ptr,
         spin_lock_irqsave(&uport->lock, flags);
         clk_enable(msm_uport->clk);
 
-        tty = uport->state->port.tty;
+        port = &uport->state->port;
+        tty = port->tty;
 
         msm_hs_write(uport, UARTDM_CR_ADDR, STALE_EVENT_DISABLE);
 
@@ -926,7 +928,7 @@ static void msm_hs_dmov_rx_callback(struct msm_dmov_cmd *cmd_ptr,
         /* overflow is not connect to data in a FIFO */
         if (unlikely((status & UARTDM_SR_OVERRUN_BMSK) &&
                      (uport->read_status_mask & CREAD))) {
-                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                tty_insert_flip_char(port, 0, TTY_OVERRUN);
                 uport->icount.buf_overrun++;
                 error_f = 1;
         }
@@ -939,7 +941,7 @@ static void msm_hs_dmov_rx_callback(struct msm_dmov_cmd *cmd_ptr,
                 uport->icount.parity++;
                 error_f = 1;
                 if (uport->ignore_status_mask & IGNPAR)
-                        tty_insert_flip_char(tty, 0, TTY_PARITY);
+                        tty_insert_flip_char(port, 0, TTY_PARITY);
         }
 
         if (error_f)
@@ -959,7 +961,7 @@ static void msm_hs_dmov_rx_callback(struct msm_dmov_cmd *cmd_ptr,
         rx_count = msm_hs_read(uport, UARTDM_RX_TOTAL_SNAP_ADDR);
 
         if (0 != (uport->read_status_mask & CREAD)) {
-                retval = tty_insert_flip_string(tty, msm_uport->rx.buffer,
+                retval = tty_insert_flip_string(port, msm_uport->rx.buffer,
                                                 rx_count);
                 BUG_ON(retval != rx_count);
         }
@@ -979,9 +981,8 @@ static void msm_hs_tty_flip_buffer_work(struct work_struct *work)
 {
         struct msm_hs_port *msm_uport =
                         container_of(work, struct msm_hs_port, rx.tty_work);
-        struct tty_struct *tty = msm_uport->uport.state->port.tty;
 
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&msm_uport->uport.state->port);
 }
 
 /*
@@ -1344,7 +1345,6 @@ static irqreturn_t msm_hs_rx_wakeup_isr(int irq, void *dev)
         unsigned long flags;
         struct msm_hs_port *msm_uport = dev;
         struct uart_port *uport = &msm_uport->uport;
-        struct tty_struct *tty = NULL;
 
         spin_lock_irqsave(&uport->lock, flags);
         if (msm_uport->clk_state == MSM_HS_CLK_OFF) {
@@ -1361,8 +1361,7 @@ static irqreturn_t msm_hs_rx_wakeup_isr(int irq, void *dev)
                  * optionally inject char into tty rx */
                 msm_hs_request_clock_on_locked(uport);
                 if (msm_uport->rx_wakeup.inject_rx) {
-                        tty = uport->state->port.tty;
-                        tty_insert_flip_char(tty,
+                        tty_insert_flip_char(&uport->state->port,
                                              msm_uport->rx_wakeup.rx_to_inject,
                                              TTY_NORMAL);
                         queue_work(msm_hs_workqueue, &msm_uport->rx.tty_work);
@@ -1400,7 +1399,7 @@ static int msm_hs_startup(struct uart_port *uport)
 
         /* do not let tty layer execute RX in global workqueue, use a
          * dedicated workqueue managed by this driver */
-        uport->state->port.tty->low_latency = 1;
+        uport->state->port.low_latency = 1;
 
         /* turn on uart clk */
         ret = msm_hs_init_clk_locked(uport);
diff --git a/drivers/tty/serial/msm_smd_tty.c b/drivers/tty/serial/msm_smd_tty.c
index 925d1fa153db..e722ff163d91 100644
--- a/drivers/tty/serial/msm_smd_tty.c
+++ b/drivers/tty/serial/msm_smd_tty.c
@@ -70,7 +70,7 @@ static void smd_tty_notify(void *priv, unsigned event)
                 if (avail == 0)
                         break;
 
-                avail = tty_prepare_flip_string(tty, &ptr, avail);
+                avail = tty_prepare_flip_string(&info->port, &ptr, avail);
 
                 if (smd_read(info->ch, ptr, avail) != avail) {
                         /* shouldn't be possible since we're in interrupt
@@ -80,7 +80,7 @@ static void smd_tty_notify(void *priv, unsigned event)
                         pr_err("OOPS - smd_tty_buffer mismatch?!");
                 }
 
-                tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(&info->port);
         }
 
         /* XXX only when writable and necessary */
diff --git a/drivers/tty/serial/mux.c b/drivers/tty/serial/mux.c
index e2775b6df5a5..7fd6aaaacd8e 100644
--- a/drivers/tty/serial/mux.c
+++ b/drivers/tty/serial/mux.c
@@ -242,8 +242,8 @@ static void mux_write(struct uart_port *port)
  */
 static void mux_read(struct uart_port *port)
 {
+        struct tty_port *tport = &port->state->port;
         int data;
-        struct tty_struct *tty = port->state->port.tty;
         __u32 start_count = port->icount.rx;
 
         while(1) {
@@ -266,12 +266,11 @@ static void mux_read(struct uart_port *port)
                 if (uart_handle_sysrq_char(port, data & 0xffu))
                         continue;
 
-                tty_insert_flip_char(tty, data & 0xFF, TTY_NORMAL);
+                tty_insert_flip_char(tport, data & 0xFF, TTY_NORMAL);
         }
         
-        if (start_count != port->icount.rx) {
-                tty_flip_buffer_push(tty);
-        }
+        if (start_count != port->icount.rx)
+                tty_flip_buffer_push(tport);
 }
 
 /**
diff --git a/drivers/tty/serial/mxs-auart.c b/drivers/tty/serial/mxs-auart.c
index e55615eb34ad..d549fe1fa42a 100644
--- a/drivers/tty/serial/mxs-auart.c
+++ b/drivers/tty/serial/mxs-auart.c
@@ -364,7 +364,6 @@ out:
 
 static void mxs_auart_rx_chars(struct mxs_auart_port *s)
 {
-        struct tty_struct *tty = s->port.state->port.tty;
         u32 stat = 0;
 
         for (;;) {
@@ -375,7 +374,7 @@ static void mxs_auart_rx_chars(struct mxs_auart_port *s)
         }
 
         writel(stat, s->port.membase + AUART_STAT);
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&s->port.state->port);
 }
 
 static int mxs_auart_request_port(struct uart_port *u)
@@ -459,7 +458,7 @@ static int mxs_auart_dma_prep_rx(struct mxs_auart_port *s);
 static void dma_rx_callback(void *arg)
 {
         struct mxs_auart_port *s = (struct mxs_auart_port *) arg;
-        struct tty_struct *tty = s->port.state->port.tty;
+        struct tty_port *port = &s->port.state->port;
         int count;
         u32 stat;
 
@@ -470,10 +469,10 @@ static void dma_rx_callback(void *arg)
                         AUART_STAT_PERR | AUART_STAT_FERR);
 
         count = stat & AUART_STAT_RXCOUNT_MASK;
-        tty_insert_flip_string(tty, s->rx_dma_buf, count);
+        tty_insert_flip_string(port, s->rx_dma_buf, count);
 
         writel(stat, s->port.membase + AUART_STAT);
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(port);
 
         /* start the next DMA for RX. */
         mxs_auart_dma_prep_rx(s);
@@ -552,7 +551,7 @@ static int mxs_auart_dma_init(struct mxs_auart_port *s)
                 return 0;
 
         /* We do not get the right DMA channels. */
-        if (s->dma_channel_rx == -1 || s->dma_channel_rx == -1)
+        if (s->dma_channel_rx == -1 || s->dma_channel_tx == -1)
                 return -EINVAL;
 
         /* init for RX */
diff --git a/drivers/tty/serial/netx-serial.c b/drivers/tty/serial/netx-serial.c
index d40da78e7c85..b9a40ed70be2 100644
--- a/drivers/tty/serial/netx-serial.c
+++ b/drivers/tty/serial/netx-serial.c
@@ -199,7 +199,6 @@ 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->state->port.tty;
 
         while (!(readl(port->membase + UART_FR) & FR_RXFE)) {
                 rx = readl(port->membase + UART_DR);
@@ -237,8 +236,7 @@ static void netx_rxint(struct uart_port *port)
                 uart_insert_char(port, status, SR_OE, rx, flg);
         }
 
-        tty_flip_buffer_push(tty);
-        return;
+        tty_flip_buffer_push(&port->state->port);
 }
 
 static irqreturn_t netx_int(int irq, void *dev_id)
diff --git a/drivers/tty/serial/nwpserial.c b/drivers/tty/serial/nwpserial.c
index dd4c31d1aee5..77287c54f331 100644
--- a/drivers/tty/serial/nwpserial.c
+++ b/drivers/tty/serial/nwpserial.c
@@ -128,7 +128,7 @@ static void nwpserial_config_port(struct uart_port *port, int flags)
 static irqreturn_t nwpserial_interrupt(int irq, void *dev_id)
 {
         struct nwpserial_port *up = dev_id;
-        struct tty_struct *tty = up->port.state->port.tty;
+        struct tty_port *port = &up->port.state->port;
         irqreturn_t ret;
         unsigned int iir;
         unsigned char ch;
@@ -146,10 +146,10 @@ static irqreturn_t nwpserial_interrupt(int irq, void *dev_id)
                 up->port.icount.rx++;
                 ch = dcr_read(up->dcr_host, UART_RX);
                 if (up->port.ignore_status_mask != NWPSERIAL_STATUS_RXVALID)
-                        tty_insert_flip_char(tty, ch, TTY_NORMAL);
+                        tty_insert_flip_char(port, ch, TTY_NORMAL);
         } while (dcr_read(up->dcr_host, UART_LSR) & UART_LSR_DR);
 
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(port);
         ret = IRQ_HANDLED;
 
         /* clear interrupt */
diff --git a/drivers/tty/serial/of_serial.c b/drivers/tty/serial/of_serial.c
index e7cae1c2d7d2..d5874605682b 100644
--- a/drivers/tty/serial/of_serial.c
+++ b/drivers/tty/serial/of_serial.c
@@ -18,7 +18,6 @@
 #include <linux/serial_reg.h>
 #include <linux/of_address.h>
 #include <linux/of_irq.h>
-#include <linux/of_serial.h>
 #include <linux/of_platform.h>
 #include <linux/nwpserial.h>
 #include <linux/clk.h>
@@ -45,8 +44,10 @@ void tegra_serial_handle_break(struct uart_port *p)
                 udelay(1);
         } while (1);
 }
-/* FIXME remove this export when tegra finishes conversion to open firmware */
-EXPORT_SYMBOL_GPL(tegra_serial_handle_break);
+#else
+static inline void tegra_serial_handle_break(struct uart_port *port)
+{
+}
 #endif
 
 /*
diff --git a/drivers/tty/serial/omap-serial.c b/drivers/tty/serial/omap-serial.c
index 57d6b29c039c..4dc41408ecb7 100644
--- a/drivers/tty/serial/omap-serial.c
+++ b/drivers/tty/serial/omap-serial.c
@@ -59,6 +59,7 @@
 
 /* SCR register bitmasks */
 #define OMAP_UART_SCR_RX_TRIG_GRANU1_MASK               (1 << 7)
+#define OMAP_UART_SCR_TX_TRIG_GRANU1_MASK               (1 << 6)
 #define OMAP_UART_SCR_TX_EMPTY                  (1 << 3)
 
 /* FCR register bitmasks */
@@ -232,24 +233,42 @@ static void serial_omap_enable_wakeup(struct uart_omap_port *up, bool enable)
 }
 
 /*
+ * serial_omap_baud_is_mode16 - check if baud rate is MODE16X
+ * @port: uart port info
+ * @baud: baudrate for which mode needs to be determined
+ *
+ * Returns true if baud rate is MODE16X and false if MODE13X
+ * Original table in OMAP TRM named "UART Mode Baud Rates, Divisor Values,
+ * and Error Rates" determines modes not for all common baud rates.
+ * E.g. for 1000000 baud rate mode must be 16x, but according to that
+ * table it's determined as 13x.
+ */
+static bool
+serial_omap_baud_is_mode16(struct uart_port *port, unsigned int baud)
+{
+        unsigned int n13 = port->uartclk / (13 * baud);
+        unsigned int n16 = port->uartclk / (16 * baud);
+        int baudAbsDiff13 = baud - (port->uartclk / (13 * n13));
+        int baudAbsDiff16 = baud - (port->uartclk / (16 * n16));
+        if(baudAbsDiff13 < 0)
+                baudAbsDiff13 = -baudAbsDiff13;
+        if(baudAbsDiff16 < 0)
+                baudAbsDiff16 = -baudAbsDiff16;
+
+        return (baudAbsDiff13 > baudAbsDiff16);
+}
+
+/*
  * serial_omap_get_divisor - calculate divisor value
  * @port: uart port info
  * @baud: baudrate for which divisor needs to be calculated.
- *
- * We have written our own function to get the divisor so as to support
- * 13x mode. 3Mbps Baudrate as an different divisor.
- * Reference OMAP TRM Chapter 17:
- * Table 17-1. UART Mode Baud Rates, Divisor Values, and Error Rates
- * referring to oversampling - divisor value
- * baudrate 460,800 to 3,686,400 all have divisor 13
- * except 3,000,000 which has divisor value 16
  */
 static unsigned int
 serial_omap_get_divisor(struct uart_port *port, unsigned int baud)
 {
         unsigned int divisor;
 
-        if (baud > OMAP_MODE13X_SPEED && baud != 3000000)
+        if (!serial_omap_baud_is_mode16(port, baud))
                 divisor = 13;
         else
                 divisor = 16;
@@ -302,9 +321,6 @@ static void transmit_chars(struct uart_omap_port *up, unsigned int lsr)
         struct circ_buf *xmit = &up->port.state->xmit;
         int count;
 
-        if (!(lsr & UART_LSR_THRE))
-                return;
-
         if (up->port.x_char) {
                 serial_out(up, UART_TX, up->port.x_char);
                 up->port.icount.tx++;
@@ -483,7 +499,6 @@ static void serial_omap_rdi(struct uart_omap_port *up, unsigned int lsr)
 static irqreturn_t serial_omap_irq(int irq, void *dev_id)
 {
         struct uart_omap_port *up = dev_id;
-        struct tty_struct *tty = up->port.state->port.tty;
         unsigned int iir, lsr;
         unsigned int type;
         irqreturn_t ret = IRQ_NONE;
@@ -530,7 +545,7 @@ static irqreturn_t serial_omap_irq(int irq, void *dev_id)
 
         spin_unlock(&up->port.lock);
 
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&up->port.state->port);
 
         pm_runtime_mark_last_busy(up->dev);
         pm_runtime_put_autosuspend(up->dev);
@@ -776,6 +791,8 @@ serial_omap_set_termios(struct uart_port *port, struct ktermios *termios,
                 cval |= UART_LCR_PARITY;
         if (!(termios->c_cflag & PARODD))
                 cval |= UART_LCR_EPAR;
+        if (termios->c_cflag & CMSPAR)
+                cval |= UART_LCR_SPAR;
 
         /*
          * Ask the core to calculate the divisor for us.
@@ -845,7 +862,7 @@ serial_omap_set_termios(struct uart_port *port, struct ktermios *termios,
         serial_out(up, UART_IER, up->ier);
         serial_out(up, UART_LCR, cval);         /* reset DLAB */
         up->lcr = cval;
-        up->scr = OMAP_UART_SCR_TX_EMPTY;
+        up->scr = 0;
 
         /* FIFOs and DMA Settings */
 
@@ -869,8 +886,6 @@ serial_omap_set_termios(struct uart_port *port, struct ktermios *termios,
         serial_out(up, UART_MCR, up->mcr | UART_MCR_TCRTLR);
         /* FIFO ENABLE, DMA MODE */
 
-        up->scr |= OMAP_UART_SCR_RX_TRIG_GRANU1_MASK;
-
         /* Set receive FIFO threshold to 16 characters and
          * transmit FIFO threshold to 16 spaces
          */
@@ -915,7 +930,7 @@ serial_omap_set_termios(struct uart_port *port, struct ktermios *termios,
         serial_out(up, UART_EFR, up->efr);
         serial_out(up, UART_LCR, cval);
 
-        if (baud > 230400 && baud != 3000000)
+        if (!serial_omap_baud_is_mode16(port, baud))
                 up->mdr1 = UART_OMAP_MDR1_13X_MODE;
         else
                 up->mdr1 = UART_OMAP_MDR1_16X_MODE;
diff --git a/drivers/tty/serial/pch_uart.c b/drivers/tty/serial/pch_uart.c
index 8318925fbf6b..7a6c989924b3 100644
--- a/drivers/tty/serial/pch_uart.c
+++ b/drivers/tty/serial/pch_uart.c
@@ -14,18 +14,21 @@
  *along with this program; if not, write to the Free Software
  *Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
  */
+#if defined(CONFIG_SERIAL_PCH_UART_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
+#define SUPPORT_SYSRQ
+#endif
 #include <linux/kernel.h>
 #include <linux/serial_reg.h>
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/pci.h>
+#include <linux/console.h>
 #include <linux/serial_core.h>
 #include <linux/tty.h>
 #include <linux/tty_flip.h>
 #include <linux/interrupt.h>
 #include <linux/io.h>
 #include <linux/dmi.h>
-#include <linux/console.h>
 #include <linux/nmi.h>
 #include <linux/delay.h>
 
@@ -553,12 +556,26 @@ static int pch_uart_hal_read(struct eg20t_port *priv, unsigned char *buf,
 {
         int i;
         u8 rbr, lsr;
+        struct uart_port *port = &priv->port;
 
         lsr = ioread8(priv->membase + UART_LSR);
         for (i = 0, lsr = ioread8(priv->membase + UART_LSR);
-             i < rx_size && lsr & UART_LSR_DR;
+             i < rx_size && lsr & (UART_LSR_DR | UART_LSR_BI);
              lsr = ioread8(priv->membase + UART_LSR)) {
                 rbr = ioread8(priv->membase + PCH_UART_RBR);
+
+                if (lsr & UART_LSR_BI) {
+                        port->icount.brk++;
+                        if (uart_handle_break(port))
+                                continue;
+                }
+#ifdef SUPPORT_SYSRQ
+                if (port->sysrq) {
+                        if (uart_handle_sysrq_char(port, rbr))
+                                continue;
+                }
+#endif
+
                 buf[i++] = rbr;
         }
         return i;
@@ -591,19 +608,11 @@ static void pch_uart_hal_set_break(struct eg20t_port *priv, int on)
 static int push_rx(struct eg20t_port *priv, const unsigned char *buf,
                    int size)
 {
-        struct uart_port *port;
-        struct tty_struct *tty;
-
-        port = &priv->port;
-        tty = tty_port_tty_get(&port->state->port);
-        if (!tty) {
-                dev_dbg(priv->port.dev, "%s:tty is busy now", __func__);
-                return -EBUSY;
-        }
+        struct uart_port *port = &priv->port;
+        struct tty_port *tport = &port->state->port;
 
-        tty_insert_flip_string(tty, buf, size);
-        tty_flip_buffer_push(tty);
-        tty_kref_put(tty);
+        tty_insert_flip_string(tport, buf, size);
+        tty_flip_buffer_push(tport);
 
         return 0;
 }
@@ -629,15 +638,16 @@ static int dma_push_rx(struct eg20t_port *priv, int size)
         struct tty_struct *tty;
         int room;
         struct uart_port *port = &priv->port;
+        struct tty_port *tport = &port->state->port;
 
         port = &priv->port;
-        tty = tty_port_tty_get(&port->state->port);
+        tty = tty_port_tty_get(tport);
         if (!tty) {
                 dev_dbg(priv->port.dev, "%s:tty is busy now", __func__);
                 return 0;
         }
 
-        room = tty_buffer_request_room(tty, size);
+        room = tty_buffer_request_room(tport, size);
 
         if (room < size)
                 dev_warn(port->dev, "Rx overrun: dropping %u bytes\n",
@@ -645,7 +655,7 @@ static int dma_push_rx(struct eg20t_port *priv, int size)
         if (!room)
                 return room;
 
-        tty_insert_flip_string(tty, sg_virt(&priv->sg_rx), size);
+        tty_insert_flip_string(tport, sg_virt(&priv->sg_rx), size);
 
         port->icount.rx += room;
         tty_kref_put(tty);
@@ -743,19 +753,12 @@ static void pch_dma_rx_complete(void *arg)
 {
         struct eg20t_port *priv = arg;
         struct uart_port *port = &priv->port;
-        struct tty_struct *tty = tty_port_tty_get(&port->state->port);
         int count;
 
-        if (!tty) {
-                dev_dbg(priv->port.dev, "%s:tty is busy now", __func__);
-                return;
-        }
-
         dma_sync_sg_for_cpu(port->dev, &priv->sg_rx, 1, DMA_FROM_DEVICE);
         count = dma_push_rx(priv, priv->trigger_level);
         if (count)
-                tty_flip_buffer_push(tty);
-        tty_kref_put(tty);
+                tty_flip_buffer_push(&port->state->port);
         async_tx_ack(priv->desc_rx);
         pch_uart_hal_enable_interrupt(priv, PCH_UART_HAL_RX_INT |
                                             PCH_UART_HAL_RX_ERR_INT);
@@ -1037,23 +1040,33 @@ static unsigned int dma_handle_tx(struct eg20t_port *priv)
 
 static void pch_uart_err_ir(struct eg20t_port *priv, unsigned int lsr)
 {
-        u8 fcr = ioread8(priv->membase + UART_FCR);
-
-        /* Reset FIFO */
-        fcr |= UART_FCR_CLEAR_RCVR;
-        iowrite8(fcr, priv->membase + UART_FCR);
+        struct uart_port *port = &priv->port;
+        struct tty_struct *tty = tty_port_tty_get(&port->state->port);
+        char   *error_msg[5] = {};
+        int    i = 0;
 
         if (lsr & PCH_UART_LSR_ERR)
-                dev_err(&priv->pdev->dev, "Error data in FIFO\n");
+                error_msg[i++] = "Error data in FIFO\n";
 
-        if (lsr & UART_LSR_FE)
-                dev_err(&priv->pdev->dev, "Framing Error\n");
+        if (lsr & UART_LSR_FE) {
+                port->icount.frame++;
+                error_msg[i++] = "  Framing Error\n";
+        }
 
-        if (lsr & UART_LSR_PE)
-                dev_err(&priv->pdev->dev, "Parity Error\n");
+        if (lsr & UART_LSR_PE) {
+                port->icount.parity++;
+                error_msg[i++] = "  Parity Error\n";
+        }
 
-        if (lsr & UART_LSR_OE)
-                dev_err(&priv->pdev->dev, "Overrun Error\n");
+        if (lsr & UART_LSR_OE) {
+                port->icount.overrun++;
+                error_msg[i++] = "  Overrun Error\n";
+        }
+
+        if (tty == NULL) {
+                for (i = 0; error_msg[i] != NULL; i++)
+                        dev_err(&priv->pdev->dev, error_msg[i]);
+        }
 }
 
 static irqreturn_t pch_uart_interrupt(int irq, void *dev_id)
@@ -1564,7 +1577,8 @@ pch_console_write(struct console *co, const char *s, unsigned int count)
 
         local_irq_save(flags);
         if (priv->port.sysrq) {
-                spin_lock(&priv->lock);
+                /* call to uart_handle_sysrq_char already took the priv lock */
+                priv_locked = 0;
                 /* serial8250_handle_port() already took the port lock */
                 port_locked = 0;
         } else if (oops_in_progress) {
diff --git a/drivers/tty/serial/pmac_zilog.c b/drivers/tty/serial/pmac_zilog.c
index 333c8d012b0e..b1785f58b6e3 100644
--- a/drivers/tty/serial/pmac_zilog.c
+++ b/drivers/tty/serial/pmac_zilog.c
@@ -227,19 +227,19 @@ static void pmz_interrupt_control(struct uart_pmac_port *uap, int enable)
         write_zsreg(uap, R1, uap->curregs[1]);
 }
 
-static struct tty_struct *pmz_receive_chars(struct uart_pmac_port *uap)
+static bool pmz_receive_chars(struct uart_pmac_port *uap)
 {
-        struct tty_struct *tty = NULL;
+        struct tty_port *port;
         unsigned char ch, r1, drop, error, flag;
         int loops = 0;
 
         /* Sanity check, make sure the old bug is no longer happening */
-        if (uap->port.state == NULL || uap->port.state->port.tty == NULL) {
+        if (uap->port.state == NULL) {
                 WARN_ON(1);
                 (void)read_zsdata(uap);
-                return NULL;
+                return false;
         }
-        tty = uap->port.state->port.tty;
+        port = &uap->port.state->port;
 
         while (1) {
                 error = 0;
@@ -309,10 +309,10 @@ static struct tty_struct *pmz_receive_chars(struct uart_pmac_port *uap)
 
                 if (uap->port.ignore_status_mask == 0xff ||
                     (r1 & uap->port.ignore_status_mask) == 0) {
-                        tty_insert_flip_char(tty, ch, flag);
+                        tty_insert_flip_char(port, ch, flag);
                 }
                 if (r1 & Rx_OVR)
-                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                        tty_insert_flip_char(port, 0, TTY_OVERRUN);
         next_char:
                 /* We can get stuck in an infinite loop getting char 0 when the
                  * line is in a wrong HW state, we break that here.
@@ -328,11 +328,11 @@ static struct tty_struct *pmz_receive_chars(struct uart_pmac_port *uap)
                         break;
         }
 
-        return tty;
+        return true;
  flood:
         pmz_interrupt_control(uap, 0);
         pmz_error("pmz: rx irq flood !\n");
-        return tty;
+        return true;
 }
 
 static void pmz_status_handle(struct uart_pmac_port *uap)
@@ -453,7 +453,7 @@ static irqreturn_t pmz_interrupt(int irq, void *dev_id)
         struct uart_pmac_port *uap_a;
         struct uart_pmac_port *uap_b;
         int rc = IRQ_NONE;
-        struct tty_struct *tty;
+        bool push;
         u8 r3;
 
         uap_a = pmz_get_port_A(uap);
@@ -466,7 +466,7 @@ static irqreturn_t pmz_interrupt(int irq, void *dev_id)
         pmz_debug("irq, r3: %x\n", r3);
 #endif
         /* Channel A */
-        tty = NULL;
+        push = false;
         if (r3 & (CHAEXT | CHATxIP | CHARxIP)) {
                 if (!ZS_IS_OPEN(uap_a)) {
                         pmz_debug("ChanA interrupt while not open !\n");
@@ -477,21 +477,21 @@ static irqreturn_t pmz_interrupt(int irq, void *dev_id)
                 if (r3 & CHAEXT)
                         pmz_status_handle(uap_a);
                 if (r3 & CHARxIP)
-                        tty = pmz_receive_chars(uap_a);
+                        push = pmz_receive_chars(uap_a);
                 if (r3 & CHATxIP)
                         pmz_transmit_chars(uap_a);
                 rc = IRQ_HANDLED;
         }
  skip_a:
         spin_unlock(&uap_a->port.lock);
-        if (tty != NULL)
-                tty_flip_buffer_push(tty);
+        if (push)
+                tty_flip_buffer_push(&uap->port.state->port);
 
         if (!uap_b)
                 goto out;
 
         spin_lock(&uap_b->port.lock);
-        tty = NULL;
+        push = false;
         if (r3 & (CHBEXT | CHBTxIP | CHBRxIP)) {
                 if (!ZS_IS_OPEN(uap_b)) {
                         pmz_debug("ChanB interrupt while not open !\n");
@@ -502,15 +502,15 @@ static irqreturn_t pmz_interrupt(int irq, void *dev_id)
                 if (r3 & CHBEXT)
                         pmz_status_handle(uap_b);
                 if (r3 & CHBRxIP)
-                        tty = pmz_receive_chars(uap_b);
+                        push = pmz_receive_chars(uap_b);
                 if (r3 & CHBTxIP)
                         pmz_transmit_chars(uap_b);
                 rc = IRQ_HANDLED;
         }
  skip_b:
         spin_unlock(&uap_b->port.lock);
-        if (tty != NULL)
-                tty_flip_buffer_push(tty);
+        if (push)
+                tty_flip_buffer_push(&uap->port.state->port);
 
  out:
         return rc;
diff --git a/drivers/tty/serial/pnx8xxx_uart.c b/drivers/tty/serial/pnx8xxx_uart.c
index 0aa75a97531c..7e277a5384a7 100644
--- a/drivers/tty/serial/pnx8xxx_uart.c
+++ b/drivers/tty/serial/pnx8xxx_uart.c
@@ -181,7 +181,6 @@ static void pnx8xxx_enable_ms(struct uart_port *port)
 
 static void pnx8xxx_rx_chars(struct pnx8xxx_port *sport)
 {
-        struct tty_struct *tty = sport->port.state->port.tty;
         unsigned int status, ch, flg;
 
         status = FIFO_TO_SM(serial_in(sport, PNX8XXX_FIFO)) |
@@ -238,7 +237,7 @@ static void pnx8xxx_rx_chars(struct pnx8xxx_port *sport)
                 status = FIFO_TO_SM(serial_in(sport, PNX8XXX_FIFO)) |
                          ISTAT_TO_SM(serial_in(sport, PNX8XXX_ISTAT));
         }
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&sport->port.state->port);
 }
 
 static void pnx8xxx_tx_chars(struct pnx8xxx_port *sport)
diff --git a/drivers/tty/serial/pxa.c b/drivers/tty/serial/pxa.c
index 2764828251f5..05f504e0c271 100644
--- a/drivers/tty/serial/pxa.c
+++ b/drivers/tty/serial/pxa.c
@@ -98,7 +98,6 @@ 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.state->port.tty;
         unsigned int ch, flag;
         int max_count = 256;
 
@@ -168,7 +167,7 @@ static inline void receive_chars(struct uart_pxa_port *up, int *status)
         ignore_char:
                 *status = serial_in(up, UART_LSR);
         } while ((*status & UART_LSR_DR) && (max_count-- > 0));
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&up->port.state->port);
 
         /* work around Errata #20 according to
          * Intel(R) PXA27x Processor Family
@@ -673,8 +672,7 @@ serial_pxa_console_write(struct console *co, const char *s, unsigned int count)
         unsigned long flags;
         int locked = 1;
 
-        clk_prepare_enable(up->clk);
-
+        clk_enable(up->clk);
         local_irq_save(flags);
         if (up->port.sysrq)
                 locked = 0;
@@ -701,8 +699,8 @@ serial_pxa_console_write(struct console *co, const char *s, unsigned int count)
         if (locked)
                 spin_unlock(&up->port.lock);
         local_irq_restore(flags);
+        clk_disable(up->clk);
 
-        clk_disable_unprepare(up->clk);
 }
 
 #ifdef CONFIG_CONSOLE_POLL
@@ -899,6 +897,12 @@ static int serial_pxa_probe(struct platform_device *dev)
                 goto err_free;
         }
 
+        ret = clk_prepare(sport->clk);
+        if (ret) {
+                clk_put(sport->clk);
+                goto err_free;
+        }
+
         sport->port.type = PORT_PXA;
         sport->port.iotype = UPIO_MEM;
         sport->port.mapbase = mmres->start;
@@ -930,6 +934,7 @@ static int serial_pxa_probe(struct platform_device *dev)
         return 0;
 
  err_clk:
+        clk_unprepare(sport->clk);
         clk_put(sport->clk);
  err_free:
         kfree(sport);
@@ -943,6 +948,8 @@ static int serial_pxa_remove(struct platform_device *dev)
         platform_set_drvdata(dev, NULL);
 
         uart_remove_one_port(&serial_pxa_reg, &sport->port);
+
+        clk_unprepare(sport->clk);
         clk_put(sport->clk);
         kfree(sport);
 
diff --git a/drivers/tty/serial/rp2.c b/drivers/tty/serial/rp2.c
new file mode 100644
index 000000000000..a314a943f124
--- /dev/null
+++ b/drivers/tty/serial/rp2.c
@@ -0,0 +1,885 @@
+/*
+ * Driver for Comtrol RocketPort EXPRESS/INFINITY cards
+ *
+ * Copyright (C) 2012 Kevin Cernekee <cernekee@gmail.com>
+ *
+ * Inspired by, and loosely based on:
+ *
+ *   ar933x_uart.c
+ *     Copyright (C) 2011 Gabor Juhos <juhosg@openwrt.org>
+ *
+ *   rocketport_infinity_express-linux-1.20.tar.gz
+ *     Copyright (C) 2004-2011 Comtrol, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published
+ * by the Free Software Foundation.
+ */
+
+#include <linux/bitops.h>
+#include <linux/compiler.h>
+#include <linux/completion.h>
+#include <linux/console.h>
+#include <linux/delay.h>
+#include <linux/firmware.h>
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/ioport.h>
+#include <linux/irq.h>
+#include <linux/kernel.h>
+#include <linux/log2.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/serial.h>
+#include <linux/serial_core.h>
+#include <linux/slab.h>
+#include <linux/sysrq.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+#include <linux/types.h>
+
+#define DRV_NAME                        "rp2"
+
+#define RP2_FW_NAME                     "rp2.fw"
+#define RP2_UCODE_BYTES                 0x3f
+
+#define PORTS_PER_ASIC                  16
+#define ALL_PORTS_MASK                  (BIT(PORTS_PER_ASIC) - 1)
+
+#define UART_CLOCK                      44236800
+#define DEFAULT_BAUD_DIV                (UART_CLOCK / (9600 * 16))
+#define FIFO_SIZE                       512
+
+/* BAR0 registers */
+#define RP2_FPGA_CTL0                   0x110
+#define RP2_FPGA_CTL1                   0x11c
+#define RP2_IRQ_MASK                    0x1ec
+#define RP2_IRQ_MASK_EN_m               BIT(0)
+#define RP2_IRQ_STATUS                  0x1f0
+
+/* BAR1 registers */
+#define RP2_ASIC_SPACING                0x1000
+#define RP2_ASIC_OFFSET(i)              ((i) << ilog2(RP2_ASIC_SPACING))
+
+#define RP2_PORT_BASE                   0x000
+#define RP2_PORT_SPACING                0x040
+
+#define RP2_UCODE_BASE                  0x400
+#define RP2_UCODE_SPACING               0x80
+
+#define RP2_CLK_PRESCALER               0xc00
+#define RP2_CH_IRQ_STAT                 0xc04
+#define RP2_CH_IRQ_MASK                 0xc08
+#define RP2_ASIC_IRQ                    0xd00
+#define RP2_ASIC_IRQ_EN_m               BIT(20)
+#define RP2_GLOBAL_CMD                  0xd0c
+#define RP2_ASIC_CFG                    0xd04
+
+/* port registers */
+#define RP2_DATA_DWORD                  0x000
+
+#define RP2_DATA_BYTE                   0x008
+#define RP2_DATA_BYTE_ERR_PARITY_m      BIT(8)
+#define RP2_DATA_BYTE_ERR_OVERRUN_m     BIT(9)
+#define RP2_DATA_BYTE_ERR_FRAMING_m     BIT(10)
+#define RP2_DATA_BYTE_BREAK_m           BIT(11)
+
+/* This lets uart_insert_char() drop bytes received on a !CREAD port */
+#define RP2_DUMMY_READ                  BIT(16)
+
+#define RP2_DATA_BYTE_EXCEPTION_MASK    (RP2_DATA_BYTE_ERR_PARITY_m | \
+                                         RP2_DATA_BYTE_ERR_OVERRUN_m | \
+                                         RP2_DATA_BYTE_ERR_FRAMING_m | \
+                                         RP2_DATA_BYTE_BREAK_m)
+
+#define RP2_RX_FIFO_COUNT               0x00c
+#define RP2_TX_FIFO_COUNT               0x00e
+
+#define RP2_CHAN_STAT                   0x010
+#define RP2_CHAN_STAT_RXDATA_m          BIT(0)
+#define RP2_CHAN_STAT_DCD_m             BIT(3)
+#define RP2_CHAN_STAT_DSR_m             BIT(4)
+#define RP2_CHAN_STAT_CTS_m             BIT(5)
+#define RP2_CHAN_STAT_RI_m              BIT(6)
+#define RP2_CHAN_STAT_OVERRUN_m         BIT(13)
+#define RP2_CHAN_STAT_DSR_CHANGED_m     BIT(16)
+#define RP2_CHAN_STAT_CTS_CHANGED_m     BIT(17)
+#define RP2_CHAN_STAT_CD_CHANGED_m      BIT(18)
+#define RP2_CHAN_STAT_RI_CHANGED_m      BIT(22)
+#define RP2_CHAN_STAT_TXEMPTY_m         BIT(25)
+
+#define RP2_CHAN_STAT_MS_CHANGED_MASK   (RP2_CHAN_STAT_DSR_CHANGED_m | \
+                                         RP2_CHAN_STAT_CTS_CHANGED_m | \
+                                         RP2_CHAN_STAT_CD_CHANGED_m | \
+                                         RP2_CHAN_STAT_RI_CHANGED_m)
+
+#define RP2_TXRX_CTL                    0x014
+#define RP2_TXRX_CTL_MSRIRQ_m           BIT(0)
+#define RP2_TXRX_CTL_RXIRQ_m            BIT(2)
+#define RP2_TXRX_CTL_RX_TRIG_s          3
+#define RP2_TXRX_CTL_RX_TRIG_m          (0x3 << RP2_TXRX_CTL_RX_TRIG_s)
+#define RP2_TXRX_CTL_RX_TRIG_1          (0x1 << RP2_TXRX_CTL_RX_TRIG_s)
+#define RP2_TXRX_CTL_RX_TRIG_256        (0x2 << RP2_TXRX_CTL_RX_TRIG_s)
+#define RP2_TXRX_CTL_RX_TRIG_448        (0x3 << RP2_TXRX_CTL_RX_TRIG_s)
+#define RP2_TXRX_CTL_RX_EN_m            BIT(5)
+#define RP2_TXRX_CTL_RTSFLOW_m          BIT(6)
+#define RP2_TXRX_CTL_DTRFLOW_m          BIT(7)
+#define RP2_TXRX_CTL_TX_TRIG_s          16
+#define RP2_TXRX_CTL_TX_TRIG_m          (0x3 << RP2_TXRX_CTL_RX_TRIG_s)
+#define RP2_TXRX_CTL_DSRFLOW_m          BIT(18)
+#define RP2_TXRX_CTL_TXIRQ_m            BIT(19)
+#define RP2_TXRX_CTL_CTSFLOW_m          BIT(23)
+#define RP2_TXRX_CTL_TX_EN_m            BIT(24)
+#define RP2_TXRX_CTL_RTS_m              BIT(25)
+#define RP2_TXRX_CTL_DTR_m              BIT(26)
+#define RP2_TXRX_CTL_LOOP_m             BIT(27)
+#define RP2_TXRX_CTL_BREAK_m            BIT(28)
+#define RP2_TXRX_CTL_CMSPAR_m           BIT(29)
+#define RP2_TXRX_CTL_nPARODD_m          BIT(30)
+#define RP2_TXRX_CTL_PARENB_m           BIT(31)
+
+#define RP2_UART_CTL                    0x018
+#define RP2_UART_CTL_MODE_s             0
+#define RP2_UART_CTL_MODE_m             (0x7 << RP2_UART_CTL_MODE_s)
+#define RP2_UART_CTL_MODE_rs232         (0x1 << RP2_UART_CTL_MODE_s)
+#define RP2_UART_CTL_FLUSH_RX_m         BIT(3)
+#define RP2_UART_CTL_FLUSH_TX_m         BIT(4)
+#define RP2_UART_CTL_RESET_CH_m         BIT(5)
+#define RP2_UART_CTL_XMIT_EN_m          BIT(6)
+#define RP2_UART_CTL_DATABITS_s         8
+#define RP2_UART_CTL_DATABITS_m         (0x3 << RP2_UART_CTL_DATABITS_s)
+#define RP2_UART_CTL_DATABITS_8         (0x3 << RP2_UART_CTL_DATABITS_s)
+#define RP2_UART_CTL_DATABITS_7         (0x2 << RP2_UART_CTL_DATABITS_s)
+#define RP2_UART_CTL_DATABITS_6         (0x1 << RP2_UART_CTL_DATABITS_s)
+#define RP2_UART_CTL_DATABITS_5         (0x0 << RP2_UART_CTL_DATABITS_s)
+#define RP2_UART_CTL_STOPBITS_m         BIT(10)
+
+#define RP2_BAUD                        0x01c
+
+/* ucode registers */
+#define RP2_TX_SWFLOW                   0x02
+#define RP2_TX_SWFLOW_ena               0x81
+#define RP2_TX_SWFLOW_dis               0x9d
+
+#define RP2_RX_SWFLOW                   0x0c
+#define RP2_RX_SWFLOW_ena               0x81
+#define RP2_RX_SWFLOW_dis               0x8d
+
+#define RP2_RX_FIFO                     0x37
+#define RP2_RX_FIFO_ena                 0x08
+#define RP2_RX_FIFO_dis                 0x81
+
+static struct uart_driver rp2_uart_driver = {
+        .owner                          = THIS_MODULE,
+        .driver_name                    = DRV_NAME,
+        .dev_name                       = "ttyRP",
+        .nr                             = CONFIG_SERIAL_RP2_NR_UARTS,
+};
+
+struct rp2_card;
+
+struct rp2_uart_port {
+        struct uart_port                port;
+        int                             idx;
+        int                             ignore_rx;
+        struct rp2_card                 *card;
+        void __iomem                    *asic_base;
+        void __iomem                    *base;
+        void __iomem                    *ucode;
+};
+
+struct rp2_card {
+        struct pci_dev                  *pdev;
+        struct rp2_uart_port            *ports;
+        int                             n_ports;
+        int                             initialized_ports;
+        int                             minor_start;
+        int                             smpte;
+        void __iomem                    *bar0;
+        void __iomem                    *bar1;
+        spinlock_t                      card_lock;
+        struct completion               fw_loaded;
+};
+
+#define RP_ID(prod) PCI_VDEVICE(RP, (prod))
+#define RP_CAP(ports, smpte) (((ports) << 8) | ((smpte) << 0))
+
+static inline void rp2_decode_cap(const struct pci_device_id *id,
+                                  int *ports, int *smpte)
+{
+        *ports = id->driver_data >> 8;
+        *smpte = id->driver_data & 0xff;
+}
+
+static DEFINE_SPINLOCK(rp2_minor_lock);
+static int rp2_minor_next;
+
+static int rp2_alloc_ports(int n_ports)
+{
+        int ret = -ENOSPC;
+
+        spin_lock(&rp2_minor_lock);
+        if (rp2_minor_next + n_ports <= CONFIG_SERIAL_RP2_NR_UARTS) {
+                /* sorry, no support for hot unplugging individual cards */
+                ret = rp2_minor_next;
+                rp2_minor_next += n_ports;
+        }
+        spin_unlock(&rp2_minor_lock);
+
+        return ret;
+}
+
+static inline struct rp2_uart_port *port_to_up(struct uart_port *port)
+{
+        return container_of(port, struct rp2_uart_port, port);
+}
+
+static void rp2_rmw(struct rp2_uart_port *up, int reg,
+                    u32 clr_bits, u32 set_bits)
+{
+        u32 tmp = readl(up->base + reg);
+        tmp &= ~clr_bits;
+        tmp |= set_bits;
+        writel(tmp, up->base + reg);
+}
+
+static void rp2_rmw_clr(struct rp2_uart_port *up, int reg, u32 val)
+{
+        rp2_rmw(up, reg, val, 0);
+}
+
+static void rp2_rmw_set(struct rp2_uart_port *up, int reg, u32 val)
+{
+        rp2_rmw(up, reg, 0, val);
+}
+
+static void rp2_mask_ch_irq(struct rp2_uart_port *up, int ch_num,
+                            int is_enabled)
+{
+        unsigned long flags, irq_mask;
+
+        spin_lock_irqsave(&up->card->card_lock, flags);
+
+        irq_mask = readl(up->asic_base + RP2_CH_IRQ_MASK);
+        if (is_enabled)
+                irq_mask &= ~BIT(ch_num);
+        else
+                irq_mask |= BIT(ch_num);
+        writel(irq_mask, up->asic_base + RP2_CH_IRQ_MASK);
+
+        spin_unlock_irqrestore(&up->card->card_lock, flags);
+}
+
+static unsigned int rp2_uart_tx_empty(struct uart_port *port)
+{
+        struct rp2_uart_port *up = port_to_up(port);
+        unsigned long tx_fifo_bytes, flags;
+
+        /*
+         * This should probably check the transmitter, not the FIFO.
+         * But the TXEMPTY bit doesn't seem to work unless the TX IRQ is
+         * enabled.
+         */
+        spin_lock_irqsave(&up->port.lock, flags);
+        tx_fifo_bytes = readw(up->base + RP2_TX_FIFO_COUNT);
+        spin_unlock_irqrestore(&up->port.lock, flags);
+
+        return tx_fifo_bytes ? 0 : TIOCSER_TEMT;
+}
+
+static unsigned int rp2_uart_get_mctrl(struct uart_port *port)
+{
+        struct rp2_uart_port *up = port_to_up(port);
+        u32 status;
+
+        status = readl(up->base + RP2_CHAN_STAT);
+        return ((status & RP2_CHAN_STAT_DCD_m) ? TIOCM_CAR : 0) |
+               ((status & RP2_CHAN_STAT_DSR_m) ? TIOCM_DSR : 0) |
+               ((status & RP2_CHAN_STAT_CTS_m) ? TIOCM_CTS : 0) |
+               ((status & RP2_CHAN_STAT_RI_m) ? TIOCM_RI : 0);
+}
+
+static void rp2_uart_set_mctrl(struct uart_port *port, unsigned int mctrl)
+{
+        rp2_rmw(port_to_up(port), RP2_TXRX_CTL,
+                RP2_TXRX_CTL_DTR_m | RP2_TXRX_CTL_RTS_m | RP2_TXRX_CTL_LOOP_m,
+                ((mctrl & TIOCM_DTR) ? RP2_TXRX_CTL_DTR_m : 0) |
+                ((mctrl & TIOCM_RTS) ? RP2_TXRX_CTL_RTS_m : 0) |
+                ((mctrl & TIOCM_LOOP) ? RP2_TXRX_CTL_LOOP_m : 0));
+}
+
+static void rp2_uart_start_tx(struct uart_port *port)
+{
+        rp2_rmw_set(port_to_up(port), RP2_TXRX_CTL, RP2_TXRX_CTL_TXIRQ_m);
+}
+
+static void rp2_uart_stop_tx(struct uart_port *port)
+{
+        rp2_rmw_clr(port_to_up(port), RP2_TXRX_CTL, RP2_TXRX_CTL_TXIRQ_m);
+}
+
+static void rp2_uart_stop_rx(struct uart_port *port)
+{
+        rp2_rmw_clr(port_to_up(port), RP2_TXRX_CTL, RP2_TXRX_CTL_RXIRQ_m);
+}
+
+static void rp2_uart_break_ctl(struct uart_port *port, int break_state)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&port->lock, flags);
+        rp2_rmw(port_to_up(port), RP2_TXRX_CTL, RP2_TXRX_CTL_BREAK_m,
+                break_state ? RP2_TXRX_CTL_BREAK_m : 0);
+        spin_unlock_irqrestore(&port->lock, flags);
+}
+
+static void rp2_uart_enable_ms(struct uart_port *port)
+{
+        rp2_rmw_set(port_to_up(port), RP2_TXRX_CTL, RP2_TXRX_CTL_MSRIRQ_m);
+}
+
+static void __rp2_uart_set_termios(struct rp2_uart_port *up,
+                                   unsigned long cfl,
+                                   unsigned long ifl,
+                                   unsigned int baud_div)
+{
+        /* baud rate divisor (calculated elsewhere).  0 = divide-by-1 */
+        writew(baud_div - 1, up->base + RP2_BAUD);
+
+        /* data bits and stop bits */
+        rp2_rmw(up, RP2_UART_CTL,
+                RP2_UART_CTL_STOPBITS_m | RP2_UART_CTL_DATABITS_m,
+                ((cfl & CSTOPB) ? RP2_UART_CTL_STOPBITS_m : 0) |
+                (((cfl & CSIZE) == CS8) ? RP2_UART_CTL_DATABITS_8 : 0) |
+                (((cfl & CSIZE) == CS7) ? RP2_UART_CTL_DATABITS_7 : 0) |
+                (((cfl & CSIZE) == CS6) ? RP2_UART_CTL_DATABITS_6 : 0) |
+                (((cfl & CSIZE) == CS5) ? RP2_UART_CTL_DATABITS_5 : 0));
+
+        /* parity and hardware flow control */
+        rp2_rmw(up, RP2_TXRX_CTL,
+                RP2_TXRX_CTL_PARENB_m | RP2_TXRX_CTL_nPARODD_m |
+                RP2_TXRX_CTL_CMSPAR_m | RP2_TXRX_CTL_DTRFLOW_m |
+                RP2_TXRX_CTL_DSRFLOW_m | RP2_TXRX_CTL_RTSFLOW_m |
+                RP2_TXRX_CTL_CTSFLOW_m,
+                ((cfl & PARENB) ? RP2_TXRX_CTL_PARENB_m : 0) |
+                ((cfl & PARODD) ? 0 : RP2_TXRX_CTL_nPARODD_m) |
+                ((cfl & CMSPAR) ? RP2_TXRX_CTL_CMSPAR_m : 0) |
+                ((cfl & CRTSCTS) ? (RP2_TXRX_CTL_RTSFLOW_m |
+                                    RP2_TXRX_CTL_CTSFLOW_m) : 0));
+
+        /* XON/XOFF software flow control */
+        writeb((ifl & IXON) ? RP2_TX_SWFLOW_ena : RP2_TX_SWFLOW_dis,
+               up->ucode + RP2_TX_SWFLOW);
+        writeb((ifl & IXOFF) ? RP2_RX_SWFLOW_ena : RP2_RX_SWFLOW_dis,
+               up->ucode + RP2_RX_SWFLOW);
+}
+
+static void rp2_uart_set_termios(struct uart_port *port,
+                                 struct ktermios *new,
+                                 struct ktermios *old)
+{
+        struct rp2_uart_port *up = port_to_up(port);
+        unsigned long flags;
+        unsigned int baud, baud_div;
+
+        baud = uart_get_baud_rate(port, new, old, 0, port->uartclk / 16);
+        baud_div = uart_get_divisor(port, baud);
+
+        if (tty_termios_baud_rate(new))
+                tty_termios_encode_baud_rate(new, baud, baud);
+
+        spin_lock_irqsave(&port->lock, flags);
+
+        /* ignore all characters if CREAD is not set */
+        port->ignore_status_mask = (new->c_cflag & CREAD) ? 0 : RP2_DUMMY_READ;
+
+        __rp2_uart_set_termios(up, new->c_cflag, new->c_iflag, baud_div);
+        uart_update_timeout(port, new->c_cflag, baud);
+
+        spin_unlock_irqrestore(&port->lock, flags);
+}
+
+static void rp2_rx_chars(struct rp2_uart_port *up)
+{
+        u16 bytes = readw(up->base + RP2_RX_FIFO_COUNT);
+        struct tty_port *port = &up->port.state->port;
+
+        for (; bytes != 0; bytes--) {
+                u32 byte = readw(up->base + RP2_DATA_BYTE) | RP2_DUMMY_READ;
+                char ch = byte & 0xff;
+
+                if (likely(!(byte & RP2_DATA_BYTE_EXCEPTION_MASK))) {
+                        if (!uart_handle_sysrq_char(&up->port, ch))
+                                uart_insert_char(&up->port, byte, 0, ch,
+                                                 TTY_NORMAL);
+                } else {
+                        char flag = TTY_NORMAL;
+
+                        if (byte & RP2_DATA_BYTE_BREAK_m)
+                                flag = TTY_BREAK;
+                        else if (byte & RP2_DATA_BYTE_ERR_FRAMING_m)
+                                flag = TTY_FRAME;
+                        else if (byte & RP2_DATA_BYTE_ERR_PARITY_m)
+                                flag = TTY_PARITY;
+                        uart_insert_char(&up->port, byte,
+                                         RP2_DATA_BYTE_ERR_OVERRUN_m, ch, flag);
+                }
+                up->port.icount.rx++;
+        }
+
+        tty_flip_buffer_push(port);
+}
+
+static void rp2_tx_chars(struct rp2_uart_port *up)
+{
+        u16 max_tx = FIFO_SIZE - readw(up->base + RP2_TX_FIFO_COUNT);
+        struct circ_buf *xmit = &up->port.state->xmit;
+
+        if (uart_tx_stopped(&up->port)) {
+                rp2_uart_stop_tx(&up->port);
+                return;
+        }
+
+        for (; max_tx != 0; max_tx--) {
+                if (up->port.x_char) {
+                        writeb(up->port.x_char, up->base + RP2_DATA_BYTE);
+                        up->port.x_char = 0;
+                        up->port.icount.tx++;
+                        continue;
+                }
+                if (uart_circ_empty(xmit)) {
+                        rp2_uart_stop_tx(&up->port);
+                        break;
+                }
+                writeb(xmit->buf[xmit->tail], up->base + RP2_DATA_BYTE);
+                xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
+                up->port.icount.tx++;
+        }
+
+        if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
+                uart_write_wakeup(&up->port);
+}
+
+static void rp2_ch_interrupt(struct rp2_uart_port *up)
+{
+        u32 status;
+
+        spin_lock(&up->port.lock);
+
+        /*
+         * The IRQ status bits are clear-on-write.  Other status bits in
+         * this register aren't, so it's harmless to write to them.
+         */
+        status = readl(up->base + RP2_CHAN_STAT);
+        writel(status, up->base + RP2_CHAN_STAT);
+
+        if (status & RP2_CHAN_STAT_RXDATA_m)
+                rp2_rx_chars(up);
+        if (status & RP2_CHAN_STAT_TXEMPTY_m)
+                rp2_tx_chars(up);
+        if (status & RP2_CHAN_STAT_MS_CHANGED_MASK)
+                wake_up_interruptible(&up->port.state->port.delta_msr_wait);
+
+        spin_unlock(&up->port.lock);
+}
+
+static int rp2_asic_interrupt(struct rp2_card *card, unsigned int asic_id)
+{
+        void __iomem *base = card->bar1 + RP2_ASIC_OFFSET(asic_id);
+        int ch, handled = 0;
+        unsigned long status = readl(base + RP2_CH_IRQ_STAT) &
+                               ~readl(base + RP2_CH_IRQ_MASK);
+
+        for_each_set_bit(ch, &status, PORTS_PER_ASIC) {
+                rp2_ch_interrupt(&card->ports[ch]);
+                handled++;
+        }
+        return handled;
+}
+
+static irqreturn_t rp2_uart_interrupt(int irq, void *dev_id)
+{
+        struct rp2_card *card = dev_id;
+        int handled;
+
+        handled = rp2_asic_interrupt(card, 0);
+        if (card->n_ports >= PORTS_PER_ASIC)
+                handled += rp2_asic_interrupt(card, 1);
+
+        return handled ? IRQ_HANDLED : IRQ_NONE;
+}
+
+static inline void rp2_flush_fifos(struct rp2_uart_port *up)
+{
+        rp2_rmw_set(up, RP2_UART_CTL,
+                    RP2_UART_CTL_FLUSH_RX_m | RP2_UART_CTL_FLUSH_TX_m);
+        readl(up->base + RP2_UART_CTL);
+        udelay(10);
+        rp2_rmw_clr(up, RP2_UART_CTL,
+                    RP2_UART_CTL_FLUSH_RX_m | RP2_UART_CTL_FLUSH_TX_m);
+}
+
+static int rp2_uart_startup(struct uart_port *port)
+{
+        struct rp2_uart_port *up = port_to_up(port);
+
+        rp2_flush_fifos(up);
+        rp2_rmw(up, RP2_TXRX_CTL, RP2_TXRX_CTL_MSRIRQ_m, RP2_TXRX_CTL_RXIRQ_m);
+        rp2_rmw(up, RP2_TXRX_CTL, RP2_TXRX_CTL_RX_TRIG_m,
+                RP2_TXRX_CTL_RX_TRIG_1);
+        rp2_rmw(up, RP2_CHAN_STAT, 0, 0);
+        rp2_mask_ch_irq(up, up->idx, 1);
+
+        return 0;
+}
+
+static void rp2_uart_shutdown(struct uart_port *port)
+{
+        struct rp2_uart_port *up = port_to_up(port);
+        unsigned long flags;
+
+        rp2_uart_break_ctl(port, 0);
+
+        spin_lock_irqsave(&port->lock, flags);
+        rp2_mask_ch_irq(up, up->idx, 0);
+        rp2_rmw(up, RP2_CHAN_STAT, 0, 0);
+        spin_unlock_irqrestore(&port->lock, flags);
+}
+
+static const char *rp2_uart_type(struct uart_port *port)
+{
+        return (port->type == PORT_RP2) ? "RocketPort 2 UART" : NULL;
+}
+
+static void rp2_uart_release_port(struct uart_port *port)
+{
+        /* Nothing to release ... */
+}
+
+static int rp2_uart_request_port(struct uart_port *port)
+{
+        /* UARTs always present */
+        return 0;
+}
+
+static void rp2_uart_config_port(struct uart_port *port, int flags)
+{
+        if (flags & UART_CONFIG_TYPE)
+                port->type = PORT_RP2;
+}
+
+static int rp2_uart_verify_port(struct uart_port *port,
+                                   struct serial_struct *ser)
+{
+        if (ser->type != PORT_UNKNOWN && ser->type != PORT_RP2)
+                return -EINVAL;
+
+        return 0;
+}
+
+static const struct uart_ops rp2_uart_ops = {
+        .tx_empty       = rp2_uart_tx_empty,
+        .set_mctrl      = rp2_uart_set_mctrl,
+        .get_mctrl      = rp2_uart_get_mctrl,
+        .stop_tx        = rp2_uart_stop_tx,
+        .start_tx       = rp2_uart_start_tx,
+        .stop_rx        = rp2_uart_stop_rx,
+        .enable_ms      = rp2_uart_enable_ms,
+        .break_ctl      = rp2_uart_break_ctl,
+        .startup        = rp2_uart_startup,
+        .shutdown       = rp2_uart_shutdown,
+        .set_termios    = rp2_uart_set_termios,
+        .type           = rp2_uart_type,
+        .release_port   = rp2_uart_release_port,
+        .request_port   = rp2_uart_request_port,
+        .config_port    = rp2_uart_config_port,
+        .verify_port    = rp2_uart_verify_port,
+};
+
+static void rp2_reset_asic(struct rp2_card *card, unsigned int asic_id)
+{
+        void __iomem *base = card->bar1 + RP2_ASIC_OFFSET(asic_id);
+        u32 clk_cfg;
+
+        writew(1, base + RP2_GLOBAL_CMD);
+        readw(base + RP2_GLOBAL_CMD);
+        msleep(100);
+        writel(0, base + RP2_CLK_PRESCALER);
+
+        /* TDM clock configuration */
+        clk_cfg = readw(base + RP2_ASIC_CFG);
+        clk_cfg = (clk_cfg & ~BIT(8)) | BIT(9);
+        writew(clk_cfg, base + RP2_ASIC_CFG);
+
+        /* IRQ routing */
+        writel(ALL_PORTS_MASK, base + RP2_CH_IRQ_MASK);
+        writel(RP2_ASIC_IRQ_EN_m, base + RP2_ASIC_IRQ);
+}
+
+static void rp2_init_card(struct rp2_card *card)
+{
+        writel(4, card->bar0 + RP2_FPGA_CTL0);
+        writel(0, card->bar0 + RP2_FPGA_CTL1);
+
+        rp2_reset_asic(card, 0);
+        if (card->n_ports >= PORTS_PER_ASIC)
+                rp2_reset_asic(card, 1);
+
+        writel(RP2_IRQ_MASK_EN_m, card->bar0 + RP2_IRQ_MASK);
+}
+
+static void rp2_init_port(struct rp2_uart_port *up, const struct firmware *fw)
+{
+        int i;
+
+        writel(RP2_UART_CTL_RESET_CH_m, up->base + RP2_UART_CTL);
+        readl(up->base + RP2_UART_CTL);
+        udelay(1);
+
+        writel(0, up->base + RP2_TXRX_CTL);
+        writel(0, up->base + RP2_UART_CTL);
+        readl(up->base + RP2_UART_CTL);
+        udelay(1);
+
+        rp2_flush_fifos(up);
+
+        for (i = 0; i < min_t(int, fw->size, RP2_UCODE_BYTES); i++)
+                writeb(fw->data[i], up->ucode + i);
+
+        __rp2_uart_set_termios(up, CS8 | CREAD | CLOCAL, 0, DEFAULT_BAUD_DIV);
+        rp2_uart_set_mctrl(&up->port, 0);
+
+        writeb(RP2_RX_FIFO_ena, up->ucode + RP2_RX_FIFO);
+        rp2_rmw(up, RP2_UART_CTL, RP2_UART_CTL_MODE_m,
+                RP2_UART_CTL_XMIT_EN_m | RP2_UART_CTL_MODE_rs232);
+        rp2_rmw_set(up, RP2_TXRX_CTL,
+                    RP2_TXRX_CTL_TX_EN_m | RP2_TXRX_CTL_RX_EN_m);
+}
+
+static void rp2_remove_ports(struct rp2_card *card)
+{
+        int i;
+
+        for (i = 0; i < card->initialized_ports; i++)
+                uart_remove_one_port(&rp2_uart_driver, &card->ports[i].port);
+        card->initialized_ports = 0;
+}
+
+static void rp2_fw_cb(const struct firmware *fw, void *context)
+{
+        struct rp2_card *card = context;
+        resource_size_t phys_base;
+        int i, rc = -ENOENT;
+
+        if (!fw) {
+                dev_err(&card->pdev->dev, "cannot find '%s' firmware image\n",
+                        RP2_FW_NAME);
+                goto no_fw;
+        }
+
+        phys_base = pci_resource_start(card->pdev, 1);
+
+        for (i = 0; i < card->n_ports; i++) {
+                struct rp2_uart_port *rp = &card->ports[i];
+                struct uart_port *p;
+                int j = (unsigned)i % PORTS_PER_ASIC;
+
+                rp->asic_base = card->bar1;
+                rp->base = card->bar1 + RP2_PORT_BASE + j*RP2_PORT_SPACING;
+                rp->ucode = card->bar1 + RP2_UCODE_BASE + j*RP2_UCODE_SPACING;
+                rp->card = card;
+                rp->idx = j;
+
+                p = &rp->port;
+                p->line = card->minor_start + i;
+                p->dev = &card->pdev->dev;
+                p->type = PORT_RP2;
+                p->iotype = UPIO_MEM32;
+                p->uartclk = UART_CLOCK;
+                p->regshift = 2;
+                p->fifosize = FIFO_SIZE;
+                p->ops = &rp2_uart_ops;
+                p->irq = card->pdev->irq;
+                p->membase = rp->base;
+                p->mapbase = phys_base + RP2_PORT_BASE + j*RP2_PORT_SPACING;
+
+                if (i >= PORTS_PER_ASIC) {
+                        rp->asic_base += RP2_ASIC_SPACING;
+                        rp->base += RP2_ASIC_SPACING;
+                        rp->ucode += RP2_ASIC_SPACING;
+                        p->mapbase += RP2_ASIC_SPACING;
+                }
+
+                rp2_init_port(rp, fw);
+                rc = uart_add_one_port(&rp2_uart_driver, p);
+                if (rc) {
+                        dev_err(&card->pdev->dev,
+                                "error registering port %d: %d\n", i, rc);
+                        rp2_remove_ports(card);
+                        break;
+                }
+                card->initialized_ports++;
+        }
+
+        release_firmware(fw);
+no_fw:
+        /*
+         * rp2_fw_cb() is called from a workqueue long after rp2_probe()
+         * has already returned success.  So if something failed here,
+         * we'll just leave the now-dormant device in place until somebody
+         * unbinds it.
+         */
+        if (rc)
+                dev_warn(&card->pdev->dev, "driver initialization failed\n");
+
+        complete(&card->fw_loaded);
+}
+
+static int rp2_probe(struct pci_dev *pdev,
+                                   const struct pci_device_id *id)
+{
+        struct rp2_card *card;
+        struct rp2_uart_port *ports;
+        void __iomem * const *bars;
+        int rc;
+
+        card = devm_kzalloc(&pdev->dev, sizeof(*card), GFP_KERNEL);
+        if (!card)
+                return -ENOMEM;
+        pci_set_drvdata(pdev, card);
+        spin_lock_init(&card->card_lock);
+        init_completion(&card->fw_loaded);
+
+        rc = pcim_enable_device(pdev);
+        if (rc)
+                return rc;
+
+        rc = pcim_iomap_regions_request_all(pdev, 0x03, DRV_NAME);
+        if (rc)
+                return rc;
+
+        bars = pcim_iomap_table(pdev);
+        card->bar0 = bars[0];
+        card->bar1 = bars[1];
+        card->pdev = pdev;
+
+        rp2_decode_cap(id, &card->n_ports, &card->smpte);
+        dev_info(&pdev->dev, "found new card with %d ports\n", card->n_ports);
+
+        card->minor_start = rp2_alloc_ports(card->n_ports);
+        if (card->minor_start < 0) {
+                dev_err(&pdev->dev,
+                        "too many ports (try increasing CONFIG_SERIAL_RP2_NR_UARTS)\n");
+                return -EINVAL;
+        }
+
+        rp2_init_card(card);
+
+        ports = devm_kzalloc(&pdev->dev, sizeof(*ports) * card->n_ports,
+                             GFP_KERNEL);
+        if (!ports)
+                return -ENOMEM;
+        card->ports = ports;
+
+        rc = devm_request_irq(&pdev->dev, pdev->irq, rp2_uart_interrupt,
+                              IRQF_SHARED, DRV_NAME, card);
+        if (rc)
+                return rc;
+
+        /*
+         * Only catastrophic errors (e.g. ENOMEM) are reported here.
+         * If the FW image is missing, we'll find out in rp2_fw_cb()
+         * and print an error message.
+         */
+        rc = request_firmware_nowait(THIS_MODULE, 1, RP2_FW_NAME, &pdev->dev,
+                                     GFP_KERNEL, card, rp2_fw_cb);
+        if (rc)
+                return rc;
+        dev_dbg(&pdev->dev, "waiting for firmware blob...\n");
+
+        return 0;
+}
+
+static void rp2_remove(struct pci_dev *pdev)
+{
+        struct rp2_card *card = pci_get_drvdata(pdev);
+
+        wait_for_completion(&card->fw_loaded);
+        rp2_remove_ports(card);
+}
+
+static DEFINE_PCI_DEVICE_TABLE(rp2_pci_tbl) = {
+
+        /* RocketPort INFINITY cards */
+
+        { RP_ID(0x0040), RP_CAP(8,  0) }, /* INF Octa, RJ45, selectable */
+        { RP_ID(0x0041), RP_CAP(32, 0) }, /* INF 32, ext interface */
+        { RP_ID(0x0042), RP_CAP(8,  0) }, /* INF Octa, ext interface */
+        { RP_ID(0x0043), RP_CAP(16, 0) }, /* INF 16, ext interface */
+        { RP_ID(0x0044), RP_CAP(4,  0) }, /* INF Quad, DB, selectable */
+        { RP_ID(0x0045), RP_CAP(8,  0) }, /* INF Octa, DB, selectable */
+        { RP_ID(0x0046), RP_CAP(4,  0) }, /* INF Quad, ext interface */
+        { RP_ID(0x0047), RP_CAP(4,  0) }, /* INF Quad, RJ45 */
+        { RP_ID(0x004a), RP_CAP(4,  0) }, /* INF Plus, Quad */
+        { RP_ID(0x004b), RP_CAP(8,  0) }, /* INF Plus, Octa */
+        { RP_ID(0x004c), RP_CAP(8,  0) }, /* INF III, Octa */
+        { RP_ID(0x004d), RP_CAP(4,  0) }, /* INF III, Quad */
+        { RP_ID(0x004e), RP_CAP(2,  0) }, /* INF Plus, 2, RS232 */
+        { RP_ID(0x004f), RP_CAP(2,  1) }, /* INF Plus, 2, SMPTE */
+        { RP_ID(0x0050), RP_CAP(4,  0) }, /* INF Plus, Quad, RJ45 */
+        { RP_ID(0x0051), RP_CAP(8,  0) }, /* INF Plus, Octa, RJ45 */
+        { RP_ID(0x0052), RP_CAP(8,  1) }, /* INF Octa, SMPTE */
+
+        /* RocketPort EXPRESS cards */
+
+        { RP_ID(0x0060), RP_CAP(8,  0) }, /* EXP Octa, RJ45, selectable */
+        { RP_ID(0x0061), RP_CAP(32, 0) }, /* EXP 32, ext interface */
+        { RP_ID(0x0062), RP_CAP(8,  0) }, /* EXP Octa, ext interface */
+        { RP_ID(0x0063), RP_CAP(16, 0) }, /* EXP 16, ext interface */
+        { RP_ID(0x0064), RP_CAP(4,  0) }, /* EXP Quad, DB, selectable */
+        { RP_ID(0x0065), RP_CAP(8,  0) }, /* EXP Octa, DB, selectable */
+        { RP_ID(0x0066), RP_CAP(4,  0) }, /* EXP Quad, ext interface */
+        { RP_ID(0x0067), RP_CAP(4,  0) }, /* EXP Quad, RJ45 */
+        { RP_ID(0x0068), RP_CAP(8,  0) }, /* EXP Octa, RJ11 */
+        { RP_ID(0x0072), RP_CAP(8,  1) }, /* EXP Octa, SMPTE */
+        { }
+};
+MODULE_DEVICE_TABLE(pci, rp2_pci_tbl);
+
+static struct pci_driver rp2_pci_driver = {
+        .name           = DRV_NAME,
+        .id_table       = rp2_pci_tbl,
+        .probe          = rp2_probe,
+        .remove         = rp2_remove,
+};
+
+static int __init rp2_uart_init(void)
+{
+        int rc;
+
+        rc = uart_register_driver(&rp2_uart_driver);
+        if (rc)
+                return rc;
+
+        rc = pci_register_driver(&rp2_pci_driver);
+        if (rc) {
+                uart_unregister_driver(&rp2_uart_driver);
+                return rc;
+        }
+
+        return 0;
+}
+
+static void __exit rp2_uart_exit(void)
+{
+        pci_unregister_driver(&rp2_pci_driver);
+        uart_unregister_driver(&rp2_uart_driver);
+}
+
+module_init(rp2_uart_init);
+module_exit(rp2_uart_exit);
+
+MODULE_DESCRIPTION("Comtrol RocketPort EXPRESS/INFINITY driver");
+MODULE_AUTHOR("Kevin Cernekee <cernekee@gmail.com>");
+MODULE_LICENSE("GPL v2");
+MODULE_FIRMWARE(RP2_FW_NAME);
diff --git a/drivers/tty/serial/sa1100.c b/drivers/tty/serial/sa1100.c
index 5d4b9b449b4a..af6b3e3ad24d 100644
--- a/drivers/tty/serial/sa1100.c
+++ b/drivers/tty/serial/sa1100.c
@@ -188,7 +188,6 @@ static void sa1100_enable_ms(struct uart_port *port)
 static void
 sa1100_rx_chars(struct sa1100_port *sport)
 {
-        struct tty_struct *tty = sport->port.state->port.tty;
         unsigned int status, ch, flg;
 
         status = UTSR1_TO_SM(UART_GET_UTSR1(sport)) |
@@ -233,7 +232,7 @@ sa1100_rx_chars(struct sa1100_port *sport)
                 status = UTSR1_TO_SM(UART_GET_UTSR1(sport)) |
                          UTSR0_TO_SM(UART_GET_UTSR0(sport));
         }
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&sport->port.state->port);
 }
 
 static void sa1100_tx_chars(struct sa1100_port *sport)
diff --git a/drivers/tty/serial/samsung.c b/drivers/tty/serial/samsung.c
index e514b3a4dc57..2769a38d15b6 100644
--- a/drivers/tty/serial/samsung.c
+++ b/drivers/tty/serial/samsung.c
@@ -47,7 +47,6 @@
 #include <asm/irq.h>
 
 #include <mach/hardware.h>
-#include <mach/map.h>
 
 #include <plat/regs-serial.h>
 #include <plat/clock.h>
@@ -221,7 +220,6 @@ 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->state->port.tty;
         unsigned int ufcon, ch, flag, ufstat, uerstat;
         unsigned long flags;
         int max_count = 64;
@@ -299,7 +297,7 @@ s3c24xx_serial_rx_chars(int irq, void *dev_id)
  ignore_char:
                 continue;
         }
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&port->state->port);
 
  out:
         spin_unlock_irqrestore(&port->lock, flags);
@@ -1143,8 +1141,13 @@ static int s3c24xx_serial_init_port(struct s3c24xx_uart_port *ourport,
 
         dbg("resource %p (%lx..%lx)\n", res, res->start, res->end);
 
+        port->membase = devm_ioremap(port->dev, res->start, resource_size(res));
+        if (!port->membase) {
+                dev_err(port->dev, "failed to remap controller address\n");
+                return -EBUSY;
+        }
+
         port->mapbase = res->start;
-        port->membase = S3C_VA_UART + (res->start & 0xfffff);
         ret = platform_get_irq(platdev, 0);
         if (ret < 0)
                 port->irq = 0;
@@ -1724,8 +1727,6 @@ static const struct of_device_id s3c24xx_uart_dt_match[] = {
         {},
 };
 MODULE_DEVICE_TABLE(of, s3c24xx_uart_dt_match);
-#else
-#define s3c24xx_uart_dt_match NULL
 #endif
 
 static struct platform_driver samsung_serial_driver = {
@@ -1736,7 +1737,7 @@ static struct platform_driver samsung_serial_driver = {
                 .name   = "samsung-uart",
                 .owner  = THIS_MODULE,
                 .pm     = SERIAL_SAMSUNG_PM_OPS,
-                .of_match_table = s3c24xx_uart_dt_match,
+                .of_match_table = of_match_ptr(s3c24xx_uart_dt_match),
         },
 };
 
diff --git a/drivers/tty/serial/sb1250-duart.c b/drivers/tty/serial/sb1250-duart.c
index f76b1688c5c8..a7cdec2962dd 100644
--- a/drivers/tty/serial/sb1250-duart.c
+++ b/drivers/tty/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->state->port.tty);
+        tty_flip_buffer_push(&uport->state->port);
 }
 
 static void sbd_transmit_chars(struct sbd_port *sport)
diff --git a/drivers/tty/serial/sc26xx.c b/drivers/tty/serial/sc26xx.c
index aced1dd923d8..c9735680762d 100644
--- a/drivers/tty/serial/sc26xx.c
+++ b/drivers/tty/serial/sc26xx.c
@@ -136,16 +136,17 @@ static void sc26xx_disable_irq(struct uart_port *port, int mask)
         WRITE_SC(port, IMR, up->imr);
 }
 
-static struct tty_struct *receive_chars(struct uart_port *port)
+static bool receive_chars(struct uart_port *port)
 {
-        struct tty_struct *tty = NULL;
+        struct tty_port *tport = NULL;
         int limit = 10000;
         unsigned char ch;
         char flag;
         u8 status;
 
+        /* FIXME what is this trying to achieve? */
         if (port->state != NULL)                /* Unopened serial console */
-                tty = port->state->port.tty;
+                tport = &port->state->port;
 
         while (limit-- > 0) {
                 status = READ_SC_PORT(port, SR);
@@ -185,9 +186,9 @@ static struct tty_struct *receive_chars(struct uart_port *port)
                 if (status & port->ignore_status_mask)
                         continue;
 
-                tty_insert_flip_char(tty, ch, flag);
+                tty_insert_flip_char(tport, ch, flag);
         }
-        return tty;
+        return !!tport;
 }
 
 static void transmit_chars(struct uart_port *port)
@@ -217,36 +218,36 @@ static void transmit_chars(struct uart_port *port)
 static irqreturn_t sc26xx_interrupt(int irq, void *dev_id)
 {
         struct uart_sc26xx_port *up = dev_id;
-        struct tty_struct *tty;
         unsigned long flags;
+        bool push;
         u8 isr;
 
         spin_lock_irqsave(&up->port[0].lock, flags);
 
-        tty = NULL;
+        push = false;
         isr = READ_SC(&up->port[0], ISR);
         if (isr & ISR_TXRDYA)
             transmit_chars(&up->port[0]);
         if (isr & ISR_RXRDYA)
-            tty = receive_chars(&up->port[0]);
+            push = receive_chars(&up->port[0]);
 
         spin_unlock(&up->port[0].lock);
 
-        if (tty)
-                tty_flip_buffer_push(tty);
+        if (push)
+                tty_flip_buffer_push(&up->port[0].state->port);
 
         spin_lock(&up->port[1].lock);
 
-        tty = NULL;
+        push = false;
         if (isr & ISR_TXRDYB)
             transmit_chars(&up->port[1]);
         if (isr & ISR_RXRDYB)
-            tty = receive_chars(&up->port[1]);
+            push = receive_chars(&up->port[1]);
 
         spin_unlock_irqrestore(&up->port[1].lock, flags);
 
-        if (tty)
-                tty_flip_buffer_push(tty);
+        if (push)
+                tty_flip_buffer_push(&up->port[1].state->port);
 
         return IRQ_HANDLED;
 }
diff --git a/drivers/tty/serial/sccnxp.c b/drivers/tty/serial/sccnxp.c
index e869eab180be..08dbfb88d42c 100644
--- a/drivers/tty/serial/sccnxp.c
+++ b/drivers/tty/serial/sccnxp.c
@@ -24,8 +24,9 @@
 #include <linux/io.h>
 #include <linux/tty.h>
 #include <linux/tty_flip.h>
+#include <linux/spinlock.h>
 #include <linux/platform_device.h>
-#include <linux/platform_data/sccnxp.h>
+#include <linux/platform_data/serial-sccnxp.h>
 
 #define SCCNXP_NAME                     "uart-sccnxp"
 #define SCCNXP_MAJOR                    204
@@ -107,6 +108,7 @@ enum {
 struct sccnxp_port {
         struct uart_driver      uart;
         struct uart_port        port[SCCNXP_MAX_UARTS];
+        bool                    opened[SCCNXP_MAX_UARTS];
 
         const char              *name;
         int                     irq;
@@ -123,7 +125,10 @@ struct sccnxp_port {
         struct console          console;
 #endif
 
-        struct mutex            sccnxp_mutex;
+        spinlock_t              lock;
+
+        bool                    poll;
+        struct timer_list       timer;
 
         struct sccnxp_pdata     pdata;
 };
@@ -175,14 +180,12 @@ static int sccnxp_update_best_err(int a, int b, int *besterr)
         return 1;
 }
 
-struct baud_table {
+static const struct {
         u8      csr;
         u8      acr;
         u8      mr0;
         int     baud;
-};
-
-const struct baud_table baud_std[] = {
+} baud_std[] = {
         { 0,    ACR_BAUD0,      MR0_BAUD_NORMAL,        50, },
         { 0,    ACR_BAUD1,      MR0_BAUD_NORMAL,        75, },
         { 1,    ACR_BAUD0,      MR0_BAUD_NORMAL,        110, },
@@ -286,10 +289,6 @@ static void sccnxp_handle_rx(struct uart_port *port)
 {
         u8 sr;
         unsigned int ch, flag;
-        struct tty_struct *tty = tty_port_tty_get(&port->state->port);
-
-        if (!tty)
-                return;
 
         for (;;) {
                 sr = sccnxp_port_read(port, SCCNXP_SR_REG);
@@ -305,14 +304,19 @@ static void sccnxp_handle_rx(struct uart_port *port)
                 if (unlikely(sr)) {
                         if (sr & SR_BRK) {
                                 port->icount.brk++;
+                                sccnxp_port_write(port, SCCNXP_CR_REG,
+                                                  CR_CMD_BREAK_RESET);
                                 if (uart_handle_break(port))
                                         continue;
                         } else if (sr & SR_PE)
                                 port->icount.parity++;
                         else if (sr & SR_FE)
                                 port->icount.frame++;
-                        else if (sr & SR_OVR)
+                        else if (sr & SR_OVR) {
                                 port->icount.overrun++;
+                                sccnxp_port_write(port, SCCNXP_CR_REG,
+                                                  CR_CMD_STATUS_RESET);
+                        }
 
                         sr &= port->read_status_mask;
                         if (sr & SR_BRK)
@@ -334,9 +338,7 @@ static void sccnxp_handle_rx(struct uart_port *port)
                 uart_insert_char(port, sr, SR_OVR, ch, flag);
         }
 
-        tty_flip_buffer_push(tty);
-
-        tty_kref_put(tty);
+        tty_flip_buffer_push(&port->state->port);
 }
 
 static void sccnxp_handle_tx(struct uart_port *port)
@@ -378,31 +380,48 @@ static void sccnxp_handle_tx(struct uart_port *port)
                 uart_write_wakeup(port);
 }
 
-static irqreturn_t sccnxp_ist(int irq, void *dev_id)
+static void sccnxp_handle_events(struct sccnxp_port *s)
 {
         int i;
         u8 isr;
-        struct sccnxp_port *s = (struct sccnxp_port *)dev_id;
-
-        mutex_lock(&s->sccnxp_mutex);
 
-        for (;;) {
+        do {
                 isr = sccnxp_read(&s->port[0], SCCNXP_ISR_REG);
                 isr &= s->imr;
                 if (!isr)
                         break;
 
-                dev_dbg(s->port[0].dev, "IRQ status: 0x%02x\n", isr);
-
                 for (i = 0; i < s->uart.nr; i++) {
-                        if (isr & ISR_RXRDY(i))
+                        if (s->opened[i] && (isr & ISR_RXRDY(i)))
                                 sccnxp_handle_rx(&s->port[i]);
-                        if (isr & ISR_TXRDY(i))
+                        if (s->opened[i] && (isr & ISR_TXRDY(i)))
                                 sccnxp_handle_tx(&s->port[i]);
                 }
-        }
+        } while (1);
+}
+
+static void sccnxp_timer(unsigned long data)
+{
+        struct sccnxp_port *s = (struct sccnxp_port *)data;
+        unsigned long flags;
 
-        mutex_unlock(&s->sccnxp_mutex);
+        spin_lock_irqsave(&s->lock, flags);
+        sccnxp_handle_events(s);
+        spin_unlock_irqrestore(&s->lock, flags);
+
+        if (!timer_pending(&s->timer))
+                mod_timer(&s->timer, jiffies +
+                          usecs_to_jiffies(s->pdata.poll_time_us));
+}
+
+static irqreturn_t sccnxp_ist(int irq, void *dev_id)
+{
+        struct sccnxp_port *s = (struct sccnxp_port *)dev_id;
+        unsigned long flags;
+
+        spin_lock_irqsave(&s->lock, flags);
+        sccnxp_handle_events(s);
+        spin_unlock_irqrestore(&s->lock, flags);
 
         return IRQ_HANDLED;
 }
@@ -410,8 +429,9 @@ static irqreturn_t sccnxp_ist(int irq, void *dev_id)
 static void sccnxp_start_tx(struct uart_port *port)
 {
         struct sccnxp_port *s = dev_get_drvdata(port->dev);
+        unsigned long flags;
 
-        mutex_lock(&s->sccnxp_mutex);
+        spin_lock_irqsave(&s->lock, flags);
 
         /* Set direction to output */
         if (s->flags & SCCNXP_HAVE_IO)
@@ -419,7 +439,7 @@ static void sccnxp_start_tx(struct uart_port *port)
 
         sccnxp_enable_irq(port, IMR_TXRDY);
 
-        mutex_unlock(&s->sccnxp_mutex);
+        spin_unlock_irqrestore(&s->lock, flags);
 }
 
 static void sccnxp_stop_tx(struct uart_port *port)
@@ -430,20 +450,22 @@ static void sccnxp_stop_tx(struct uart_port *port)
 static void sccnxp_stop_rx(struct uart_port *port)
 {
         struct sccnxp_port *s = dev_get_drvdata(port->dev);
+        unsigned long flags;
 
-        mutex_lock(&s->sccnxp_mutex);
+        spin_lock_irqsave(&s->lock, flags);
         sccnxp_port_write(port, SCCNXP_CR_REG, CR_RX_DISABLE);
-        mutex_unlock(&s->sccnxp_mutex);
+        spin_unlock_irqrestore(&s->lock, flags);
 }
 
 static unsigned int sccnxp_tx_empty(struct uart_port *port)
 {
         u8 val;
+        unsigned long flags;
         struct sccnxp_port *s = dev_get_drvdata(port->dev);
 
-        mutex_lock(&s->sccnxp_mutex);
+        spin_lock_irqsave(&s->lock, flags);
         val = sccnxp_port_read(port, SCCNXP_SR_REG);
-        mutex_unlock(&s->sccnxp_mutex);
+        spin_unlock_irqrestore(&s->lock, flags);
 
         return (val & SR_TXEMT) ? TIOCSER_TEMT : 0;
 }
@@ -456,28 +478,30 @@ static void sccnxp_enable_ms(struct uart_port *port)
 static void sccnxp_set_mctrl(struct uart_port *port, unsigned int mctrl)
 {
         struct sccnxp_port *s = dev_get_drvdata(port->dev);
+        unsigned long flags;
 
         if (!(s->flags & SCCNXP_HAVE_IO))
                 return;
 
-        mutex_lock(&s->sccnxp_mutex);
+        spin_lock_irqsave(&s->lock, flags);
 
         sccnxp_set_bit(port, DTR_OP, mctrl & TIOCM_DTR);
         sccnxp_set_bit(port, RTS_OP, mctrl & TIOCM_RTS);
 
-        mutex_unlock(&s->sccnxp_mutex);
+        spin_unlock_irqrestore(&s->lock, flags);
 }
 
 static unsigned int sccnxp_get_mctrl(struct uart_port *port)
 {
         u8 bitmask, ipr;
+        unsigned long flags;
         struct sccnxp_port *s = dev_get_drvdata(port->dev);
         unsigned int mctrl = TIOCM_DSR | TIOCM_CTS | TIOCM_CAR;
 
         if (!(s->flags & SCCNXP_HAVE_IO))
                 return mctrl;
 
-        mutex_lock(&s->sccnxp_mutex);
+        spin_lock_irqsave(&s->lock, flags);
 
         ipr = ~sccnxp_read(port, SCCNXP_IPCR_REG);
 
@@ -506,7 +530,7 @@ static unsigned int sccnxp_get_mctrl(struct uart_port *port)
                 mctrl |= (ipr & bitmask) ? TIOCM_RNG : 0;
         }
 
-        mutex_unlock(&s->sccnxp_mutex);
+        spin_unlock_irqrestore(&s->lock, flags);
 
         return mctrl;
 }
@@ -514,21 +538,23 @@ static unsigned int sccnxp_get_mctrl(struct uart_port *port)
 static void sccnxp_break_ctl(struct uart_port *port, int break_state)
 {
         struct sccnxp_port *s = dev_get_drvdata(port->dev);
+        unsigned long flags;
 
-        mutex_lock(&s->sccnxp_mutex);
+        spin_lock_irqsave(&s->lock, flags);
         sccnxp_port_write(port, SCCNXP_CR_REG, break_state ?
                           CR_CMD_START_BREAK : CR_CMD_STOP_BREAK);
-        mutex_unlock(&s->sccnxp_mutex);
+        spin_unlock_irqrestore(&s->lock, flags);
 }
 
 static void sccnxp_set_termios(struct uart_port *port,
                                struct ktermios *termios, struct ktermios *old)
 {
         struct sccnxp_port *s = dev_get_drvdata(port->dev);
+        unsigned long flags;
         u8 mr1, mr2;
         int baud;
 
-        mutex_lock(&s->sccnxp_mutex);
+        spin_lock_irqsave(&s->lock, flags);
 
         /* Mask termios capabilities we don't support */
         termios->c_cflag &= ~CMSPAR;
@@ -595,20 +621,22 @@ static void sccnxp_set_termios(struct uart_port *port,
         /* Update timeout according to new baud rate */
         uart_update_timeout(port, termios->c_cflag, baud);
 
+        /* Report actual baudrate back to core */
         if (tty_termios_baud_rate(termios))
                 tty_termios_encode_baud_rate(termios, baud, baud);
 
         /* Enable RX & TX */
         sccnxp_port_write(port, SCCNXP_CR_REG, CR_RX_ENABLE | CR_TX_ENABLE);
 
-        mutex_unlock(&s->sccnxp_mutex);
+        spin_unlock_irqrestore(&s->lock, flags);
 }
 
 static int sccnxp_startup(struct uart_port *port)
 {
         struct sccnxp_port *s = dev_get_drvdata(port->dev);
+        unsigned long flags;
 
-        mutex_lock(&s->sccnxp_mutex);
+        spin_lock_irqsave(&s->lock, flags);
 
         if (s->flags & SCCNXP_HAVE_IO) {
                 /* Outputs are controlled manually */
@@ -627,7 +655,9 @@ static int sccnxp_startup(struct uart_port *port)
         /* Enable RX interrupt */
         sccnxp_enable_irq(port, IMR_RXRDY);
 
-        mutex_unlock(&s->sccnxp_mutex);
+        s->opened[port->line] = 1;
+
+        spin_unlock_irqrestore(&s->lock, flags);
 
         return 0;
 }
@@ -635,8 +665,11 @@ static int sccnxp_startup(struct uart_port *port)
 static void sccnxp_shutdown(struct uart_port *port)
 {
         struct sccnxp_port *s = dev_get_drvdata(port->dev);
+        unsigned long flags;
 
-        mutex_lock(&s->sccnxp_mutex);
+        spin_lock_irqsave(&s->lock, flags);
+
+        s->opened[port->line] = 0;
 
         /* Disable interrupts */
         sccnxp_disable_irq(port, IMR_TXRDY | IMR_RXRDY);
@@ -648,7 +681,7 @@ static void sccnxp_shutdown(struct uart_port *port)
         if (s->flags & SCCNXP_HAVE_IO)
                 sccnxp_set_bit(port, DIR_OP, 0);
 
-        mutex_unlock(&s->sccnxp_mutex);
+        spin_unlock_irqrestore(&s->lock, flags);
 }
 
 static const char *sccnxp_type(struct uart_port *port)
@@ -722,10 +755,11 @@ static void sccnxp_console_write(struct console *co, const char *c, unsigned n)
 {
         struct sccnxp_port *s = (struct sccnxp_port *)co->data;
         struct uart_port *port = &s->port[co->index];
+        unsigned long flags;
 
-        mutex_lock(&s->sccnxp_mutex);
+        spin_lock_irqsave(&s->lock, flags);
         uart_console_write(port, c, n, sccnxp_console_putchar);
-        mutex_unlock(&s->sccnxp_mutex);
+        spin_unlock_irqrestore(&s->lock, flags);
 }
 
 static int sccnxp_console_setup(struct console *co, char *options)
@@ -764,7 +798,7 @@ static int sccnxp_probe(struct platform_device *pdev)
         }
         platform_set_drvdata(pdev, s);
 
-        mutex_init(&s->sccnxp_mutex);
+        spin_lock_init(&s->lock);
 
         /* Individual chip settings */
         switch (chiptype) {
@@ -861,11 +895,19 @@ static int sccnxp_probe(struct platform_device *pdev)
         } else
                 memcpy(&s->pdata, pdata, sizeof(struct sccnxp_pdata));
 
-        s->irq = platform_get_irq(pdev, 0);
-        if (s->irq <= 0) {
-                dev_err(&pdev->dev, "Missing irq resource data\n");
-                ret = -ENXIO;
-                goto err_out;
+        if (s->pdata.poll_time_us) {
+                dev_info(&pdev->dev, "Using poll mode, resolution %u usecs\n",
+                         s->pdata.poll_time_us);
+                s->poll = 1;
+        }
+
+        if (!s->poll) {
+                s->irq = platform_get_irq(pdev, 0);
+                if (s->irq < 0) {
+                        dev_err(&pdev->dev, "Missing irq resource data\n");
+                        ret = -ENXIO;
+                        goto err_out;
+                }
         }
 
         /* Check input frequency */
@@ -929,13 +971,23 @@ static int sccnxp_probe(struct platform_device *pdev)
         if (s->pdata.init)
                 s->pdata.init();
 
-        ret = devm_request_threaded_irq(&pdev->dev, s->irq, NULL, sccnxp_ist,
-                                        IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
-                                        dev_name(&pdev->dev), s);
-        if (!ret)
+        if (!s->poll) {
+                ret = devm_request_threaded_irq(&pdev->dev, s->irq, NULL,
+                                                sccnxp_ist,
+                                                IRQF_TRIGGER_FALLING |
+                                                IRQF_ONESHOT,
+                                                dev_name(&pdev->dev), s);
+                if (!ret)
+                        return 0;
+
+                dev_err(&pdev->dev, "Unable to reguest IRQ %i\n", s->irq);
+        } else {
+                init_timer(&s->timer);
+                setup_timer(&s->timer, sccnxp_timer, (unsigned long)s);
+                mod_timer(&s->timer, jiffies +
+                          usecs_to_jiffies(s->pdata.poll_time_us));
                 return 0;
-
-        dev_err(&pdev->dev, "Unable to reguest IRQ %i\n", s->irq);
+        }
 
 err_out:
         platform_set_drvdata(pdev, NULL);
@@ -948,7 +1000,10 @@ static int sccnxp_remove(struct platform_device *pdev)
         int i;
         struct sccnxp_port *s = platform_get_drvdata(pdev);
 
-        devm_free_irq(&pdev->dev, s->irq, s);
+        if (!s->poll)
+                devm_free_irq(&pdev->dev, s->irq, s);
+        else
+                del_timer_sync(&s->timer);
 
         for (i = 0; i < s->uart.nr; i++)
                 uart_remove_one_port(&s->uart, &s->port[i]);
diff --git a/drivers/tty/serial/serial-tegra.c b/drivers/tty/serial/serial-tegra.c
new file mode 100644
index 000000000000..372de8ade76a
--- /dev/null
+++ b/drivers/tty/serial/serial-tegra.c
@@ -0,0 +1,1401 @@
+/*
+ * serial_tegra.c
+ *
+ * High-speed serial driver for NVIDIA Tegra SoCs
+ *
+ * Copyright (c) 2012-2013, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Author: Laxman Dewangan <ldewangan@nvidia.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/clk.h>
+#include <linux/debugfs.h>
+#include <linux/delay.h>
+#include <linux/dmaengine.h>
+#include <linux/dma-mapping.h>
+#include <linux/dmapool.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/pagemap.h>
+#include <linux/platform_device.h>
+#include <linux/serial.h>
+#include <linux/serial_8250.h>
+#include <linux/serial_core.h>
+#include <linux/serial_reg.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/termios.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+
+#include <linux/clk/tegra.h>
+
+#define TEGRA_UART_TYPE                         "TEGRA_UART"
+#define TX_EMPTY_STATUS                         (UART_LSR_TEMT | UART_LSR_THRE)
+#define BYTES_TO_ALIGN(x)                       ((unsigned long)(x) & 0x3)
+
+#define TEGRA_UART_RX_DMA_BUFFER_SIZE           4096
+#define TEGRA_UART_LSR_TXFIFO_FULL              0x100
+#define TEGRA_UART_IER_EORD                     0x20
+#define TEGRA_UART_MCR_RTS_EN                   0x40
+#define TEGRA_UART_MCR_CTS_EN                   0x20
+#define TEGRA_UART_LSR_ANY                      (UART_LSR_OE | UART_LSR_BI | \
+                                                UART_LSR_PE | UART_LSR_FE)
+#define TEGRA_UART_IRDA_CSR                     0x08
+#define TEGRA_UART_SIR_ENABLED                  0x80
+
+#define TEGRA_UART_TX_PIO                       1
+#define TEGRA_UART_TX_DMA                       2
+#define TEGRA_UART_MIN_DMA                      16
+#define TEGRA_UART_FIFO_SIZE                    32
+
+/*
+ * Tx fifo trigger level setting in tegra uart is in
+ * reverse way then conventional uart.
+ */
+#define TEGRA_UART_TX_TRIG_16B                  0x00
+#define TEGRA_UART_TX_TRIG_8B                   0x10
+#define TEGRA_UART_TX_TRIG_4B                   0x20
+#define TEGRA_UART_TX_TRIG_1B                   0x30
+
+#define TEGRA_UART_MAXIMUM                      5
+
+/* Default UART setting when started: 115200 no parity, stop, 8 data bits */
+#define TEGRA_UART_DEFAULT_BAUD                 115200
+#define TEGRA_UART_DEFAULT_LSR                  UART_LCR_WLEN8
+
+/* Tx transfer mode */
+#define TEGRA_TX_PIO                            1
+#define TEGRA_TX_DMA                            2
+
+/**
+ * tegra_uart_chip_data: SOC specific data.
+ *
+ * @tx_fifo_full_status: Status flag available for checking tx fifo full.
+ * @allow_txfifo_reset_fifo_mode: allow_tx fifo reset with fifo mode or not.
+ *                      Tegra30 does not allow this.
+ * @support_clk_src_div: Clock source support the clock divider.
+ */
+struct tegra_uart_chip_data {
+        bool    tx_fifo_full_status;
+        bool    allow_txfifo_reset_fifo_mode;
+        bool    support_clk_src_div;
+};
+
+struct tegra_uart_port {
+        struct uart_port                        uport;
+        const struct tegra_uart_chip_data       *cdata;
+
+        struct clk                              *uart_clk;
+        unsigned int                            current_baud;
+
+        /* Register shadow */
+        unsigned long                           fcr_shadow;
+        unsigned long                           mcr_shadow;
+        unsigned long                           lcr_shadow;
+        unsigned long                           ier_shadow;
+        bool                                    rts_active;
+
+        int                                     tx_in_progress;
+        unsigned int                            tx_bytes;
+
+        bool                                    enable_modem_interrupt;
+
+        bool                                    rx_timeout;
+        int                                     rx_in_progress;
+        int                                     symb_bit;
+        int                                     dma_req_sel;
+
+        struct dma_chan                         *rx_dma_chan;
+        struct dma_chan                         *tx_dma_chan;
+        dma_addr_t                              rx_dma_buf_phys;
+        dma_addr_t                              tx_dma_buf_phys;
+        unsigned char                           *rx_dma_buf_virt;
+        unsigned char                           *tx_dma_buf_virt;
+        struct dma_async_tx_descriptor          *tx_dma_desc;
+        struct dma_async_tx_descriptor          *rx_dma_desc;
+        dma_cookie_t                            tx_cookie;
+        dma_cookie_t                            rx_cookie;
+        int                                     tx_bytes_requested;
+        int                                     rx_bytes_requested;
+};
+
+static void tegra_uart_start_next_tx(struct tegra_uart_port *tup);
+static int tegra_uart_start_rx_dma(struct tegra_uart_port *tup);
+
+static inline unsigned long tegra_uart_read(struct tegra_uart_port *tup,
+                unsigned long reg)
+{
+        return readl(tup->uport.membase + (reg << tup->uport.regshift));
+}
+
+static inline void tegra_uart_write(struct tegra_uart_port *tup, unsigned val,
+        unsigned long reg)
+{
+        writel(val, tup->uport.membase + (reg << tup->uport.regshift));
+}
+
+static inline struct tegra_uart_port *to_tegra_uport(struct uart_port *u)
+{
+        return container_of(u, struct tegra_uart_port, uport);
+}
+
+static unsigned int tegra_uart_get_mctrl(struct uart_port *u)
+{
+        struct tegra_uart_port *tup = to_tegra_uport(u);
+
+        /*
+         * RI - Ring detector is active
+         * CD/DCD/CAR - Carrier detect is always active. For some reason
+         *      linux has different names for carrier detect.
+         * DSR - Data Set ready is active as the hardware doesn't support it.
+         *      Don't know if the linux support this yet?
+         * CTS - Clear to send. Always set to active, as the hardware handles
+         *      CTS automatically.
+         */
+        if (tup->enable_modem_interrupt)
+                return TIOCM_RI | TIOCM_CD | TIOCM_DSR | TIOCM_CTS;
+        return TIOCM_CTS;
+}
+
+static void set_rts(struct tegra_uart_port *tup, bool active)
+{
+        unsigned long mcr;
+
+        mcr = tup->mcr_shadow;
+        if (active)
+                mcr |= TEGRA_UART_MCR_RTS_EN;
+        else
+                mcr &= ~TEGRA_UART_MCR_RTS_EN;
+        if (mcr != tup->mcr_shadow) {
+                tegra_uart_write(tup, mcr, UART_MCR);
+                tup->mcr_shadow = mcr;
+        }
+        return;
+}
+
+static void set_dtr(struct tegra_uart_port *tup, bool active)
+{
+        unsigned long mcr;
+
+        mcr = tup->mcr_shadow;
+        if (active)
+                mcr |= UART_MCR_DTR;
+        else
+                mcr &= ~UART_MCR_DTR;
+        if (mcr != tup->mcr_shadow) {
+                tegra_uart_write(tup, mcr, UART_MCR);
+                tup->mcr_shadow = mcr;
+        }
+        return;
+}
+
+static void tegra_uart_set_mctrl(struct uart_port *u, unsigned int mctrl)
+{
+        struct tegra_uart_port *tup = to_tegra_uport(u);
+        unsigned long mcr;
+        int dtr_enable;
+
+        mcr = tup->mcr_shadow;
+        tup->rts_active = !!(mctrl & TIOCM_RTS);
+        set_rts(tup, tup->rts_active);
+
+        dtr_enable = !!(mctrl & TIOCM_DTR);
+        set_dtr(tup, dtr_enable);
+        return;
+}
+
+static void tegra_uart_break_ctl(struct uart_port *u, int break_ctl)
+{
+        struct tegra_uart_port *tup = to_tegra_uport(u);
+        unsigned long lcr;
+
+        lcr = tup->lcr_shadow;
+        if (break_ctl)
+                lcr |= UART_LCR_SBC;
+        else
+                lcr &= ~UART_LCR_SBC;
+        tegra_uart_write(tup, lcr, UART_LCR);
+        tup->lcr_shadow = lcr;
+}
+
+/* Wait for a symbol-time. */
+static void tegra_uart_wait_sym_time(struct tegra_uart_port *tup,
+                unsigned int syms)
+{
+        if (tup->current_baud)
+                udelay(DIV_ROUND_UP(syms * tup->symb_bit * 1000000,
+                        tup->current_baud));
+}
+
+static void tegra_uart_fifo_reset(struct tegra_uart_port *tup, u8 fcr_bits)
+{
+        unsigned long fcr = tup->fcr_shadow;
+
+        if (tup->cdata->allow_txfifo_reset_fifo_mode) {
+                fcr |= fcr_bits & (UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
+                tegra_uart_write(tup, fcr, UART_FCR);
+        } else {
+                fcr &= ~UART_FCR_ENABLE_FIFO;
+                tegra_uart_write(tup, fcr, UART_FCR);
+                udelay(60);
+                fcr |= fcr_bits & (UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
+                tegra_uart_write(tup, fcr, UART_FCR);
+                fcr |= UART_FCR_ENABLE_FIFO;
+                tegra_uart_write(tup, fcr, UART_FCR);
+        }
+
+        /* Dummy read to ensure the write is posted */
+        tegra_uart_read(tup, UART_SCR);
+
+        /* Wait for the flush to propagate. */
+        tegra_uart_wait_sym_time(tup, 1);
+}
+
+static int tegra_set_baudrate(struct tegra_uart_port *tup, unsigned int baud)
+{
+        unsigned long rate;
+        unsigned int divisor;
+        unsigned long lcr;
+        int ret;
+
+        if (tup->current_baud == baud)
+                return 0;
+
+        if (tup->cdata->support_clk_src_div) {
+                rate = baud * 16;
+                ret = clk_set_rate(tup->uart_clk, rate);
+                if (ret < 0) {
+                        dev_err(tup->uport.dev,
+                                "clk_set_rate() failed for rate %lu\n", rate);
+                        return ret;
+                }
+                divisor = 1;
+        } else {
+                rate = clk_get_rate(tup->uart_clk);
+                divisor = DIV_ROUND_CLOSEST(rate, baud * 16);
+        }
+
+        lcr = tup->lcr_shadow;
+        lcr |= UART_LCR_DLAB;
+        tegra_uart_write(tup, lcr, UART_LCR);
+
+        tegra_uart_write(tup, divisor & 0xFF, UART_TX);
+        tegra_uart_write(tup, ((divisor >> 8) & 0xFF), UART_IER);
+
+        lcr &= ~UART_LCR_DLAB;
+        tegra_uart_write(tup, lcr, UART_LCR);
+
+        /* Dummy read to ensure the write is posted */
+        tegra_uart_read(tup, UART_SCR);
+
+        tup->current_baud = baud;
+
+        /* wait two character intervals at new rate */
+        tegra_uart_wait_sym_time(tup, 2);
+        return 0;
+}
+
+static char tegra_uart_decode_rx_error(struct tegra_uart_port *tup,
+                        unsigned long lsr)
+{
+        char flag = TTY_NORMAL;
+
+        if (unlikely(lsr & TEGRA_UART_LSR_ANY)) {
+                if (lsr & UART_LSR_OE) {
+                        /* Overrrun error */
+                        flag |= TTY_OVERRUN;
+                        tup->uport.icount.overrun++;
+                        dev_err(tup->uport.dev, "Got overrun errors\n");
+                } else if (lsr & UART_LSR_PE) {
+                        /* Parity error */
+                        flag |= TTY_PARITY;
+                        tup->uport.icount.parity++;
+                        dev_err(tup->uport.dev, "Got Parity errors\n");
+                } else if (lsr & UART_LSR_FE) {
+                        flag |= TTY_FRAME;
+                        tup->uport.icount.frame++;
+                        dev_err(tup->uport.dev, "Got frame errors\n");
+                } else if (lsr & UART_LSR_BI) {
+                        dev_err(tup->uport.dev, "Got Break\n");
+                        tup->uport.icount.brk++;
+                        /* If FIFO read error without any data, reset Rx FIFO */
+                        if (!(lsr & UART_LSR_DR) && (lsr & UART_LSR_FIFOE))
+                                tegra_uart_fifo_reset(tup, UART_FCR_CLEAR_RCVR);
+                }
+        }
+        return flag;
+}
+
+static int tegra_uart_request_port(struct uart_port *u)
+{
+        return 0;
+}
+
+static void tegra_uart_release_port(struct uart_port *u)
+{
+        /* Nothing to do here */
+}
+
+static void tegra_uart_fill_tx_fifo(struct tegra_uart_port *tup, int max_bytes)
+{
+        struct circ_buf *xmit = &tup->uport.state->xmit;
+        int i;
+
+        for (i = 0; i < max_bytes; i++) {
+                BUG_ON(uart_circ_empty(xmit));
+                if (tup->cdata->tx_fifo_full_status) {
+                        unsigned long lsr = tegra_uart_read(tup, UART_LSR);
+                        if ((lsr & TEGRA_UART_LSR_TXFIFO_FULL))
+                                break;
+                }
+                tegra_uart_write(tup, xmit->buf[xmit->tail], UART_TX);
+                xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
+                tup->uport.icount.tx++;
+        }
+}
+
+static void tegra_uart_start_pio_tx(struct tegra_uart_port *tup,
+                unsigned int bytes)
+{
+        if (bytes > TEGRA_UART_MIN_DMA)
+                bytes = TEGRA_UART_MIN_DMA;
+
+        tup->tx_in_progress = TEGRA_UART_TX_PIO;
+        tup->tx_bytes = bytes;
+        tup->ier_shadow |= UART_IER_THRI;
+        tegra_uart_write(tup, tup->ier_shadow, UART_IER);
+}
+
+static void tegra_uart_tx_dma_complete(void *args)
+{
+        struct tegra_uart_port *tup = args;
+        struct circ_buf *xmit = &tup->uport.state->xmit;
+        struct dma_tx_state state;
+        unsigned long flags;
+        int count;
+
+        dmaengine_tx_status(tup->tx_dma_chan, tup->rx_cookie, &state);
+        count = tup->tx_bytes_requested - state.residue;
+        async_tx_ack(tup->tx_dma_desc);
+        spin_lock_irqsave(&tup->uport.lock, flags);
+        xmit->tail = (xmit->tail + count) & (UART_XMIT_SIZE - 1);
+        tup->tx_in_progress = 0;
+        if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
+                uart_write_wakeup(&tup->uport);
+        tegra_uart_start_next_tx(tup);
+        spin_unlock_irqrestore(&tup->uport.lock, flags);
+}
+
+static int tegra_uart_start_tx_dma(struct tegra_uart_port *tup,
+                unsigned long count)
+{
+        struct circ_buf *xmit = &tup->uport.state->xmit;
+        dma_addr_t tx_phys_addr;
+
+        dma_sync_single_for_device(tup->uport.dev, tup->tx_dma_buf_phys,
+                                UART_XMIT_SIZE, DMA_TO_DEVICE);
+
+        tup->tx_bytes = count & ~(0xF);
+        tx_phys_addr = tup->tx_dma_buf_phys + xmit->tail;
+        tup->tx_dma_desc = dmaengine_prep_slave_single(tup->tx_dma_chan,
+                                tx_phys_addr, tup->tx_bytes, DMA_MEM_TO_DEV,
+                                DMA_PREP_INTERRUPT);
+        if (!tup->tx_dma_desc) {
+                dev_err(tup->uport.dev, "Not able to get desc for Tx\n");
+                return -EIO;
+        }
+
+        tup->tx_dma_desc->callback = tegra_uart_tx_dma_complete;
+        tup->tx_dma_desc->callback_param = tup;
+        tup->tx_in_progress = TEGRA_UART_TX_DMA;
+        tup->tx_bytes_requested = tup->tx_bytes;
+        tup->tx_cookie = dmaengine_submit(tup->tx_dma_desc);
+        dma_async_issue_pending(tup->tx_dma_chan);
+        return 0;
+}
+
+static void tegra_uart_start_next_tx(struct tegra_uart_port *tup)
+{
+        unsigned long tail;
+        unsigned long count;
+        struct circ_buf *xmit = &tup->uport.state->xmit;
+
+        tail = (unsigned long)&xmit->buf[xmit->tail];
+        count = CIRC_CNT_TO_END(xmit->head, xmit->tail, UART_XMIT_SIZE);
+        if (!count)
+                return;
+
+        if (count < TEGRA_UART_MIN_DMA)
+                tegra_uart_start_pio_tx(tup, count);
+        else if (BYTES_TO_ALIGN(tail) > 0)
+                tegra_uart_start_pio_tx(tup, BYTES_TO_ALIGN(tail));
+        else
+                tegra_uart_start_tx_dma(tup, count);
+}
+
+/* Called by serial core driver with u->lock taken. */
+static void tegra_uart_start_tx(struct uart_port *u)
+{
+        struct tegra_uart_port *tup = to_tegra_uport(u);
+        struct circ_buf *xmit = &u->state->xmit;
+
+        if (!uart_circ_empty(xmit) && !tup->tx_in_progress)
+                tegra_uart_start_next_tx(tup);
+}
+
+static unsigned int tegra_uart_tx_empty(struct uart_port *u)
+{
+        struct tegra_uart_port *tup = to_tegra_uport(u);
+        unsigned int ret = 0;
+        unsigned long flags;
+
+        spin_lock_irqsave(&u->lock, flags);
+        if (!tup->tx_in_progress) {
+                unsigned long lsr = tegra_uart_read(tup, UART_LSR);
+                if ((lsr & TX_EMPTY_STATUS) == TX_EMPTY_STATUS)
+                        ret = TIOCSER_TEMT;
+        }
+        spin_unlock_irqrestore(&u->lock, flags);
+        return ret;
+}
+
+static void tegra_uart_stop_tx(struct uart_port *u)
+{
+        struct tegra_uart_port *tup = to_tegra_uport(u);
+        struct circ_buf *xmit = &tup->uport.state->xmit;
+        struct dma_tx_state state;
+        int count;
+
+        dmaengine_terminate_all(tup->tx_dma_chan);
+        dmaengine_tx_status(tup->tx_dma_chan, tup->tx_cookie, &state);
+        count = tup->tx_bytes_requested - state.residue;
+        async_tx_ack(tup->tx_dma_desc);
+        xmit->tail = (xmit->tail + count) & (UART_XMIT_SIZE - 1);
+        tup->tx_in_progress = 0;
+        return;
+}
+
+static void tegra_uart_handle_tx_pio(struct tegra_uart_port *tup)
+{
+        struct circ_buf *xmit = &tup->uport.state->xmit;
+
+        tegra_uart_fill_tx_fifo(tup, tup->tx_bytes);
+        tup->tx_in_progress = 0;
+        if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
+                uart_write_wakeup(&tup->uport);
+        tegra_uart_start_next_tx(tup);
+        return;
+}
+
+static void tegra_uart_handle_rx_pio(struct tegra_uart_port *tup,
+                struct tty_port *tty)
+{
+        do {
+                char flag = TTY_NORMAL;
+                unsigned long lsr = 0;
+                unsigned char ch;
+
+                lsr = tegra_uart_read(tup, UART_LSR);
+                if (!(lsr & UART_LSR_DR))
+                        break;
+
+                flag = tegra_uart_decode_rx_error(tup, lsr);
+                ch = (unsigned char) tegra_uart_read(tup, UART_RX);
+                tup->uport.icount.rx++;
+
+                if (!uart_handle_sysrq_char(&tup->uport, ch) && tty)
+                        tty_insert_flip_char(tty, ch, flag);
+        } while (1);
+
+        return;
+}
+
+static void tegra_uart_copy_rx_to_tty(struct tegra_uart_port *tup,
+                struct tty_port *tty, int count)
+{
+        int copied;
+
+        tup->uport.icount.rx += count;
+        if (!tty) {
+                dev_err(tup->uport.dev, "No tty port\n");
+                return;
+        }
+        dma_sync_single_for_cpu(tup->uport.dev, tup->rx_dma_buf_phys,
+                                TEGRA_UART_RX_DMA_BUFFER_SIZE, DMA_FROM_DEVICE);
+        copied = tty_insert_flip_string(tty,
+                        ((unsigned char *)(tup->rx_dma_buf_virt)), count);
+        if (copied != count) {
+                WARN_ON(1);
+                dev_err(tup->uport.dev, "RxData copy to tty layer failed\n");
+        }
+        dma_sync_single_for_device(tup->uport.dev, tup->rx_dma_buf_phys,
+                                TEGRA_UART_RX_DMA_BUFFER_SIZE, DMA_TO_DEVICE);
+}
+
+static void tegra_uart_rx_dma_complete(void *args)
+{
+        struct tegra_uart_port *tup = args;
+        struct uart_port *u = &tup->uport;
+        int count = tup->rx_bytes_requested;
+        struct tty_struct *tty = tty_port_tty_get(&tup->uport.state->port);
+        struct tty_port *port = &u->state->port;
+        unsigned long flags;
+
+        async_tx_ack(tup->rx_dma_desc);
+        spin_lock_irqsave(&u->lock, flags);
+
+        /* Deactivate flow control to stop sender */
+        if (tup->rts_active)
+                set_rts(tup, false);
+
+        /* If we are here, DMA is stopped */
+        if (count)
+                tegra_uart_copy_rx_to_tty(tup, port, count);
+
+        tegra_uart_handle_rx_pio(tup, port);
+        if (tty) {
+                tty_flip_buffer_push(port);
+                tty_kref_put(tty);
+        }
+        tegra_uart_start_rx_dma(tup);
+
+        /* Activate flow control to start transfer */
+        if (tup->rts_active)
+                set_rts(tup, true);
+
+        spin_unlock_irqrestore(&u->lock, flags);
+}
+
+static void tegra_uart_handle_rx_dma(struct tegra_uart_port *tup)
+{
+        struct dma_tx_state state;
+        struct tty_struct *tty = tty_port_tty_get(&tup->uport.state->port);
+        struct tty_port *port = &tup->uport.state->port;
+        int count;
+
+        /* Deactivate flow control to stop sender */
+        if (tup->rts_active)
+                set_rts(tup, false);
+
+        dmaengine_terminate_all(tup->rx_dma_chan);
+        dmaengine_tx_status(tup->rx_dma_chan,  tup->rx_cookie, &state);
+        count = tup->rx_bytes_requested - state.residue;
+
+        /* If we are here, DMA is stopped */
+        if (count)
+                tegra_uart_copy_rx_to_tty(tup, port, count);
+
+        tegra_uart_handle_rx_pio(tup, port);
+        if (tty) {
+                tty_flip_buffer_push(port);
+                tty_kref_put(tty);
+        }
+        tegra_uart_start_rx_dma(tup);
+
+        if (tup->rts_active)
+                set_rts(tup, true);
+}
+
+static int tegra_uart_start_rx_dma(struct tegra_uart_port *tup)
+{
+        unsigned int count = TEGRA_UART_RX_DMA_BUFFER_SIZE;
+
+        tup->rx_dma_desc = dmaengine_prep_slave_single(tup->rx_dma_chan,
+                                tup->rx_dma_buf_phys, count, DMA_DEV_TO_MEM,
+                                DMA_PREP_INTERRUPT);
+        if (!tup->rx_dma_desc) {
+                dev_err(tup->uport.dev, "Not able to get desc for Rx\n");
+                return -EIO;
+        }
+
+        tup->rx_dma_desc->callback = tegra_uart_rx_dma_complete;
+        tup->rx_dma_desc->callback_param = tup;
+        dma_sync_single_for_device(tup->uport.dev, tup->rx_dma_buf_phys,
+                                count, DMA_TO_DEVICE);
+        tup->rx_bytes_requested = count;
+        tup->rx_cookie = dmaengine_submit(tup->rx_dma_desc);
+        dma_async_issue_pending(tup->rx_dma_chan);
+        return 0;
+}
+
+static void tegra_uart_handle_modem_signal_change(struct uart_port *u)
+{
+        struct tegra_uart_port *tup = to_tegra_uport(u);
+        unsigned long msr;
+
+        msr = tegra_uart_read(tup, UART_MSR);
+        if (!(msr & UART_MSR_ANY_DELTA))
+                return;
+
+        if (msr & UART_MSR_TERI)
+                tup->uport.icount.rng++;
+        if (msr & UART_MSR_DDSR)
+                tup->uport.icount.dsr++;
+        /* We may only get DDCD when HW init and reset */
+        if (msr & UART_MSR_DDCD)
+                uart_handle_dcd_change(&tup->uport, msr & UART_MSR_DCD);
+        /* Will start/stop_tx accordingly */
+        if (msr & UART_MSR_DCTS)
+                uart_handle_cts_change(&tup->uport, msr & UART_MSR_CTS);
+        return;
+}
+
+static irqreturn_t tegra_uart_isr(int irq, void *data)
+{
+        struct tegra_uart_port *tup = data;
+        struct uart_port *u = &tup->uport;
+        unsigned long iir;
+        unsigned long ier;
+        bool is_rx_int = false;
+        unsigned long flags;
+
+        spin_lock_irqsave(&u->lock, flags);
+        while (1) {
+                iir = tegra_uart_read(tup, UART_IIR);
+                if (iir & UART_IIR_NO_INT) {
+                        if (is_rx_int) {
+                                tegra_uart_handle_rx_dma(tup);
+                                if (tup->rx_in_progress) {
+                                        ier = tup->ier_shadow;
+                                        ier |= (UART_IER_RLSI | UART_IER_RTOIE |
+                                                TEGRA_UART_IER_EORD);
+                                        tup->ier_shadow = ier;
+                                        tegra_uart_write(tup, ier, UART_IER);
+                                }
+                        }
+                        spin_unlock_irqrestore(&u->lock, flags);
+                        return IRQ_HANDLED;
+                }
+
+                switch ((iir >> 1) & 0x7) {
+                case 0: /* Modem signal change interrupt */
+                        tegra_uart_handle_modem_signal_change(u);
+                        break;
+
+                case 1: /* Transmit interrupt only triggered when using PIO */
+                        tup->ier_shadow &= ~UART_IER_THRI;
+                        tegra_uart_write(tup, tup->ier_shadow, UART_IER);
+                        tegra_uart_handle_tx_pio(tup);
+                        break;
+
+                case 4: /* End of data */
+                case 6: /* Rx timeout */
+                case 2: /* Receive */
+                        if (!is_rx_int) {
+                                is_rx_int = true;
+                                /* Disable Rx interrupts */
+                                ier = tup->ier_shadow;
+                                ier |= UART_IER_RDI;
+                                tegra_uart_write(tup, ier, UART_IER);
+                                ier &= ~(UART_IER_RDI | UART_IER_RLSI |
+                                        UART_IER_RTOIE | TEGRA_UART_IER_EORD);
+                                tup->ier_shadow = ier;
+                                tegra_uart_write(tup, ier, UART_IER);
+                        }
+                        break;
+
+                case 3: /* Receive error */
+                        tegra_uart_decode_rx_error(tup,
+                                        tegra_uart_read(tup, UART_LSR));
+                        break;
+
+                case 5: /* break nothing to handle */
+                case 7: /* break nothing to handle */
+                        break;
+                }
+        }
+}
+
+static void tegra_uart_stop_rx(struct uart_port *u)
+{
+        struct tegra_uart_port *tup = to_tegra_uport(u);
+        struct tty_struct *tty = tty_port_tty_get(&tup->uport.state->port);
+        struct tty_port *port = &u->state->port;
+        struct dma_tx_state state;
+        unsigned long ier;
+        int count;
+
+        if (tup->rts_active)
+                set_rts(tup, false);
+
+        if (!tup->rx_in_progress)
+                return;
+
+        tegra_uart_wait_sym_time(tup, 1); /* wait a character interval */
+
+        ier = tup->ier_shadow;
+        ier &= ~(UART_IER_RDI | UART_IER_RLSI | UART_IER_RTOIE |
+                                        TEGRA_UART_IER_EORD);
+        tup->ier_shadow = ier;
+        tegra_uart_write(tup, ier, UART_IER);
+        tup->rx_in_progress = 0;
+        if (tup->rx_dma_chan) {
+                dmaengine_terminate_all(tup->rx_dma_chan);
+                dmaengine_tx_status(tup->rx_dma_chan, tup->rx_cookie, &state);
+                async_tx_ack(tup->rx_dma_desc);
+                count = tup->rx_bytes_requested - state.residue;
+                tegra_uart_copy_rx_to_tty(tup, port, count);
+                tegra_uart_handle_rx_pio(tup, port);
+        } else {
+                tegra_uart_handle_rx_pio(tup, port);
+        }
+        if (tty) {
+                tty_flip_buffer_push(port);
+                tty_kref_put(tty);
+        }
+        return;
+}
+
+static void tegra_uart_hw_deinit(struct tegra_uart_port *tup)
+{
+        unsigned long flags;
+        unsigned long char_time = DIV_ROUND_UP(10000000, tup->current_baud);
+        unsigned long fifo_empty_time = tup->uport.fifosize * char_time;
+        unsigned long wait_time;
+        unsigned long lsr;
+        unsigned long msr;
+        unsigned long mcr;
+
+        /* Disable interrupts */
+        tegra_uart_write(tup, 0, UART_IER);
+
+        lsr = tegra_uart_read(tup, UART_LSR);
+        if ((lsr & UART_LSR_TEMT) != UART_LSR_TEMT) {
+                msr = tegra_uart_read(tup, UART_MSR);
+                mcr = tegra_uart_read(tup, UART_MCR);
+                if ((mcr & TEGRA_UART_MCR_CTS_EN) && (msr & UART_MSR_CTS))
+                        dev_err(tup->uport.dev,
+                                "Tx Fifo not empty, CTS disabled, waiting\n");
+
+                /* Wait for Tx fifo to be empty */
+                while ((lsr & UART_LSR_TEMT) != UART_LSR_TEMT) {
+                        wait_time = min(fifo_empty_time, 100lu);
+                        udelay(wait_time);
+                        fifo_empty_time -= wait_time;
+                        if (!fifo_empty_time) {
+                                msr = tegra_uart_read(tup, UART_MSR);
+                                mcr = tegra_uart_read(tup, UART_MCR);
+                                if ((mcr & TEGRA_UART_MCR_CTS_EN) &&
+                                        (msr & UART_MSR_CTS))
+                                        dev_err(tup->uport.dev,
+                                                "Slave not ready\n");
+                                break;
+                        }
+                        lsr = tegra_uart_read(tup, UART_LSR);
+                }
+        }
+
+        spin_lock_irqsave(&tup->uport.lock, flags);
+        /* Reset the Rx and Tx FIFOs */
+        tegra_uart_fifo_reset(tup, UART_FCR_CLEAR_XMIT | UART_FCR_CLEAR_RCVR);
+        tup->current_baud = 0;
+        spin_unlock_irqrestore(&tup->uport.lock, flags);
+
+        clk_disable_unprepare(tup->uart_clk);
+}
+
+static int tegra_uart_hw_init(struct tegra_uart_port *tup)
+{
+        int ret;
+
+        tup->fcr_shadow = 0;
+        tup->mcr_shadow = 0;
+        tup->lcr_shadow = 0;
+        tup->ier_shadow = 0;
+        tup->current_baud = 0;
+
+        clk_prepare_enable(tup->uart_clk);
+
+        /* Reset the UART controller to clear all previous status.*/
+        tegra_periph_reset_assert(tup->uart_clk);
+        udelay(10);
+        tegra_periph_reset_deassert(tup->uart_clk);
+
+        tup->rx_in_progress = 0;
+        tup->tx_in_progress = 0;
+
+        /*
+         * Set the trigger level
+         *
+         * For PIO mode:
+         *
+         * For receive, this will interrupt the CPU after that many number of
+         * bytes are received, for the remaining bytes the receive timeout
+         * interrupt is received. Rx high watermark is set to 4.
+         *
+         * For transmit, if the trasnmit interrupt is enabled, this will
+         * interrupt the CPU when the number of entries in the FIFO reaches the
+         * low watermark. Tx low watermark is set to 16 bytes.
+         *
+         * For DMA mode:
+         *
+         * Set the Tx trigger to 16. This should match the DMA burst size that
+         * programmed in the DMA registers.
+         */
+        tup->fcr_shadow = UART_FCR_ENABLE_FIFO;
+        tup->fcr_shadow |= UART_FCR_R_TRIG_01;
+        tup->fcr_shadow |= TEGRA_UART_TX_TRIG_16B;
+        tegra_uart_write(tup, tup->fcr_shadow, UART_FCR);
+
+        /*
+         * Initialize the UART with default configuration
+         * (115200, N, 8, 1) so that the receive DMA buffer may be
+         * enqueued
+         */
+        tup->lcr_shadow = TEGRA_UART_DEFAULT_LSR;
+        tegra_set_baudrate(tup, TEGRA_UART_DEFAULT_BAUD);
+        tup->fcr_shadow |= UART_FCR_DMA_SELECT;
+        tegra_uart_write(tup, tup->fcr_shadow, UART_FCR);
+
+        ret = tegra_uart_start_rx_dma(tup);
+        if (ret < 0) {
+                dev_err(tup->uport.dev, "Not able to start Rx DMA\n");
+                return ret;
+        }
+        tup->rx_in_progress = 1;
+
+        /*
+         * Enable IE_RXS for the receive status interrupts like line errros.
+         * Enable IE_RX_TIMEOUT to get the bytes which cannot be DMA'd.
+         *
+         * If using DMA mode, enable EORD instead of receive interrupt which
+         * will interrupt after the UART is done with the receive instead of
+         * the interrupt when the FIFO "threshold" is reached.
+         *
+         * EORD is different interrupt than RX_TIMEOUT - RX_TIMEOUT occurs when
+         * the DATA is sitting in the FIFO and couldn't be transferred to the
+         * DMA as the DMA size alignment(4 bytes) is not met. EORD will be
+         * triggered when there is a pause of the incomming data stream for 4
+         * characters long.
+         *
+         * For pauses in the data which is not aligned to 4 bytes, we get
+         * both the EORD as well as RX_TIMEOUT - SW sees RX_TIMEOUT first
+         * then the EORD.
+         */
+        tup->ier_shadow = UART_IER_RLSI | UART_IER_RTOIE | TEGRA_UART_IER_EORD;
+        tegra_uart_write(tup, tup->ier_shadow, UART_IER);
+        return 0;
+}
+
+static int tegra_uart_dma_channel_allocate(struct tegra_uart_port *tup,
+                        bool dma_to_memory)
+{
+        struct dma_chan *dma_chan;
+        unsigned char *dma_buf;
+        dma_addr_t dma_phys;
+        int ret;
+        struct dma_slave_config dma_sconfig;
+        dma_cap_mask_t mask;
+
+        dma_cap_zero(mask);
+        dma_cap_set(DMA_SLAVE, mask);
+        dma_chan = dma_request_channel(mask, NULL, NULL);
+        if (!dma_chan) {
+                dev_err(tup->uport.dev,
+                        "Dma channel is not available, will try later\n");
+                return -EPROBE_DEFER;
+        }
+
+        if (dma_to_memory) {
+                dma_buf = dma_alloc_coherent(tup->uport.dev,
+                                TEGRA_UART_RX_DMA_BUFFER_SIZE,
+                                 &dma_phys, GFP_KERNEL);
+                if (!dma_buf) {
+                        dev_err(tup->uport.dev,
+                                "Not able to allocate the dma buffer\n");
+                        dma_release_channel(dma_chan);
+                        return -ENOMEM;
+                }
+        } else {
+                dma_phys = dma_map_single(tup->uport.dev,
+                        tup->uport.state->xmit.buf, UART_XMIT_SIZE,
+                        DMA_TO_DEVICE);
+                dma_buf = tup->uport.state->xmit.buf;
+        }
+
+        dma_sconfig.slave_id = tup->dma_req_sel;
+        if (dma_to_memory) {
+                dma_sconfig.src_addr = tup->uport.mapbase;
+                dma_sconfig.src_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;
+                dma_sconfig.src_maxburst = 4;
+        } else {
+                dma_sconfig.dst_addr = tup->uport.mapbase;
+                dma_sconfig.dst_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;
+                dma_sconfig.dst_maxburst = 16;
+        }
+
+        ret = dmaengine_slave_config(dma_chan, &dma_sconfig);
+        if (ret < 0) {
+                dev_err(tup->uport.dev,
+                        "Dma slave config failed, err = %d\n", ret);
+                goto scrub;
+        }
+
+        if (dma_to_memory) {
+                tup->rx_dma_chan = dma_chan;
+                tup->rx_dma_buf_virt = dma_buf;
+                tup->rx_dma_buf_phys = dma_phys;
+        } else {
+                tup->tx_dma_chan = dma_chan;
+                tup->tx_dma_buf_virt = dma_buf;
+                tup->tx_dma_buf_phys = dma_phys;
+        }
+        return 0;
+
+scrub:
+        dma_release_channel(dma_chan);
+        return ret;
+}
+
+static void tegra_uart_dma_channel_free(struct tegra_uart_port *tup,
+                bool dma_to_memory)
+{
+        struct dma_chan *dma_chan;
+
+        if (dma_to_memory) {
+                dma_free_coherent(tup->uport.dev, TEGRA_UART_RX_DMA_BUFFER_SIZE,
+                                tup->rx_dma_buf_virt, tup->rx_dma_buf_phys);
+                dma_chan = tup->rx_dma_chan;
+                tup->rx_dma_chan = NULL;
+                tup->rx_dma_buf_phys = 0;
+                tup->rx_dma_buf_virt = NULL;
+        } else {
+                dma_unmap_single(tup->uport.dev, tup->tx_dma_buf_phys,
+                        UART_XMIT_SIZE, DMA_TO_DEVICE);
+                dma_chan = tup->tx_dma_chan;
+                tup->tx_dma_chan = NULL;
+                tup->tx_dma_buf_phys = 0;
+                tup->tx_dma_buf_virt = NULL;
+        }
+        dma_release_channel(dma_chan);
+}
+
+static int tegra_uart_startup(struct uart_port *u)
+{
+        struct tegra_uart_port *tup = to_tegra_uport(u);
+        int ret;
+
+        ret = tegra_uart_dma_channel_allocate(tup, false);
+        if (ret < 0) {
+                dev_err(u->dev, "Tx Dma allocation failed, err = %d\n", ret);
+                return ret;
+        }
+
+        ret = tegra_uart_dma_channel_allocate(tup, true);
+        if (ret < 0) {
+                dev_err(u->dev, "Rx Dma allocation failed, err = %d\n", ret);
+                goto fail_rx_dma;
+        }
+
+        ret = tegra_uart_hw_init(tup);
+        if (ret < 0) {
+                dev_err(u->dev, "Uart HW init failed, err = %d\n", ret);
+                goto fail_hw_init;
+        }
+
+        ret = request_irq(u->irq, tegra_uart_isr, IRQF_DISABLED,
+                                dev_name(u->dev), tup);
+        if (ret < 0) {
+                dev_err(u->dev, "Failed to register ISR for IRQ %d\n", u->irq);
+                goto fail_hw_init;
+        }
+        return 0;
+
+fail_hw_init:
+        tegra_uart_dma_channel_free(tup, true);
+fail_rx_dma:
+        tegra_uart_dma_channel_free(tup, false);
+        return ret;
+}
+
+static void tegra_uart_shutdown(struct uart_port *u)
+{
+        struct tegra_uart_port *tup = to_tegra_uport(u);
+
+        tegra_uart_hw_deinit(tup);
+
+        tup->rx_in_progress = 0;
+        tup->tx_in_progress = 0;
+
+        tegra_uart_dma_channel_free(tup, true);
+        tegra_uart_dma_channel_free(tup, false);
+        free_irq(u->irq, tup);
+}
+
+static void tegra_uart_enable_ms(struct uart_port *u)
+{
+        struct tegra_uart_port *tup = to_tegra_uport(u);
+
+        if (tup->enable_modem_interrupt) {
+                tup->ier_shadow |= UART_IER_MSI;
+                tegra_uart_write(tup, tup->ier_shadow, UART_IER);
+        }
+}
+
+static void tegra_uart_set_termios(struct uart_port *u,
+                struct ktermios *termios, struct ktermios *oldtermios)
+{
+        struct tegra_uart_port *tup = to_tegra_uport(u);
+        unsigned int baud;
+        unsigned long flags;
+        unsigned int lcr;
+        int symb_bit = 1;
+        struct clk *parent_clk = clk_get_parent(tup->uart_clk);
+        unsigned long parent_clk_rate = clk_get_rate(parent_clk);
+        int max_divider = (tup->cdata->support_clk_src_div) ? 0x7FFF : 0xFFFF;
+
+        max_divider *= 16;
+        spin_lock_irqsave(&u->lock, flags);
+
+        /* Changing configuration, it is safe to stop any rx now */
+        if (tup->rts_active)
+                set_rts(tup, false);
+
+        /* Clear all interrupts as configuration is going to be change */
+        tegra_uart_write(tup, tup->ier_shadow | UART_IER_RDI, UART_IER);
+        tegra_uart_read(tup, UART_IER);
+        tegra_uart_write(tup, 0, UART_IER);
+        tegra_uart_read(tup, UART_IER);
+
+        /* Parity */
+        lcr = tup->lcr_shadow;
+        lcr &= ~UART_LCR_PARITY;
+
+        /* CMSPAR isn't supported by this driver */
+        termios->c_cflag &= ~CMSPAR;
+
+        if ((termios->c_cflag & PARENB) == PARENB) {
+                symb_bit++;
+                if (termios->c_cflag & PARODD) {
+                        lcr |= UART_LCR_PARITY;
+                        lcr &= ~UART_LCR_EPAR;
+                        lcr &= ~UART_LCR_SPAR;
+                } else {
+                        lcr |= UART_LCR_PARITY;
+                        lcr |= UART_LCR_EPAR;
+                        lcr &= ~UART_LCR_SPAR;
+                }
+        }
+
+        lcr &= ~UART_LCR_WLEN8;
+        switch (termios->c_cflag & CSIZE) {
+        case CS5:
+                lcr |= UART_LCR_WLEN5;
+                symb_bit += 5;
+                break;
+        case CS6:
+                lcr |= UART_LCR_WLEN6;
+                symb_bit += 6;
+                break;
+        case CS7:
+                lcr |= UART_LCR_WLEN7;
+                symb_bit += 7;
+                break;
+        default:
+                lcr |= UART_LCR_WLEN8;
+                symb_bit += 8;
+                break;
+        }
+
+        /* Stop bits */
+        if (termios->c_cflag & CSTOPB) {
+                lcr |= UART_LCR_STOP;
+                symb_bit += 2;
+        } else {
+                lcr &= ~UART_LCR_STOP;
+                symb_bit++;
+        }
+
+        tegra_uart_write(tup, lcr, UART_LCR);
+        tup->lcr_shadow = lcr;
+        tup->symb_bit = symb_bit;
+
+        /* Baud rate. */
+        baud = uart_get_baud_rate(u, termios, oldtermios,
+                        parent_clk_rate/max_divider,
+                        parent_clk_rate/16);
+        spin_unlock_irqrestore(&u->lock, flags);
+        tegra_set_baudrate(tup, baud);
+        if (tty_termios_baud_rate(termios))
+                tty_termios_encode_baud_rate(termios, baud, baud);
+        spin_lock_irqsave(&u->lock, flags);
+
+        /* Flow control */
+        if (termios->c_cflag & CRTSCTS) {
+                tup->mcr_shadow |= TEGRA_UART_MCR_CTS_EN;
+                tup->mcr_shadow &= ~TEGRA_UART_MCR_RTS_EN;
+                tegra_uart_write(tup, tup->mcr_shadow, UART_MCR);
+                /* if top layer has asked to set rts active then do so here */
+                if (tup->rts_active)
+                        set_rts(tup, true);
+        } else {
+                tup->mcr_shadow &= ~TEGRA_UART_MCR_CTS_EN;
+                tup->mcr_shadow &= ~TEGRA_UART_MCR_RTS_EN;
+                tegra_uart_write(tup, tup->mcr_shadow, UART_MCR);
+        }
+
+        /* update the port timeout based on new settings */
+        uart_update_timeout(u, termios->c_cflag, baud);
+
+        /* Make sure all write has completed */
+        tegra_uart_read(tup, UART_IER);
+
+        /* Reenable interrupt */
+        tegra_uart_write(tup, tup->ier_shadow, UART_IER);
+        tegra_uart_read(tup, UART_IER);
+
+        spin_unlock_irqrestore(&u->lock, flags);
+        return;
+}
+
+/*
+ * Flush any TX data submitted for DMA and PIO. Called when the
+ * TX circular buffer is reset.
+ */
+static void tegra_uart_flush_buffer(struct uart_port *u)
+{
+        struct tegra_uart_port *tup = to_tegra_uport(u);
+
+        tup->tx_bytes = 0;
+        if (tup->tx_dma_chan)
+                dmaengine_terminate_all(tup->tx_dma_chan);
+        return;
+}
+
+static const char *tegra_uart_type(struct uart_port *u)
+{
+        return TEGRA_UART_TYPE;
+}
+
+static struct uart_ops tegra_uart_ops = {
+        .tx_empty       = tegra_uart_tx_empty,
+        .set_mctrl      = tegra_uart_set_mctrl,
+        .get_mctrl      = tegra_uart_get_mctrl,
+        .stop_tx        = tegra_uart_stop_tx,
+        .start_tx       = tegra_uart_start_tx,
+        .stop_rx        = tegra_uart_stop_rx,
+        .flush_buffer   = tegra_uart_flush_buffer,
+        .enable_ms      = tegra_uart_enable_ms,
+        .break_ctl      = tegra_uart_break_ctl,
+        .startup        = tegra_uart_startup,
+        .shutdown       = tegra_uart_shutdown,
+        .set_termios    = tegra_uart_set_termios,
+        .type           = tegra_uart_type,
+        .request_port   = tegra_uart_request_port,
+        .release_port   = tegra_uart_release_port,
+};
+
+static struct uart_driver tegra_uart_driver = {
+        .owner          = THIS_MODULE,
+        .driver_name    = "tegra_hsuart",
+        .dev_name       = "ttyTHS",
+        .cons           = 0,
+        .nr             = TEGRA_UART_MAXIMUM,
+};
+
+static int tegra_uart_parse_dt(struct platform_device *pdev,
+        struct tegra_uart_port *tup)
+{
+        struct device_node *np = pdev->dev.of_node;
+        u32 of_dma[2];
+        int port;
+
+        if (of_property_read_u32_array(np, "nvidia,dma-request-selector",
+                                of_dma, 2) >= 0) {
+                tup->dma_req_sel = of_dma[1];
+        } else {
+                dev_err(&pdev->dev, "missing dma requestor in device tree\n");
+                return -EINVAL;
+        }
+
+        port = of_alias_get_id(np, "serial");
+        if (port < 0) {
+                dev_err(&pdev->dev, "failed to get alias id, errno %d\n", port);
+                return port;
+        }
+        tup->uport.line = port;
+
+        tup->enable_modem_interrupt = of_property_read_bool(np,
+                                        "nvidia,enable-modem-interrupt");
+        return 0;
+}
+
+struct tegra_uart_chip_data tegra20_uart_chip_data = {
+        .tx_fifo_full_status            = false,
+        .allow_txfifo_reset_fifo_mode   = true,
+        .support_clk_src_div            = false,
+};
+
+struct tegra_uart_chip_data tegra30_uart_chip_data = {
+        .tx_fifo_full_status            = true,
+        .allow_txfifo_reset_fifo_mode   = false,
+        .support_clk_src_div            = true,
+};
+
+static struct of_device_id tegra_uart_of_match[] = {
+        {
+                .compatible     = "nvidia,tegra30-hsuart",
+                .data           = &tegra30_uart_chip_data,
+        }, {
+                .compatible     = "nvidia,tegra20-hsuart",
+                .data           = &tegra20_uart_chip_data,
+        }, {
+        },
+};
+MODULE_DEVICE_TABLE(of, tegra_uart_of_match);
+
+static int tegra_uart_probe(struct platform_device *pdev)
+{
+        struct tegra_uart_port *tup;
+        struct uart_port *u;
+        struct resource *resource;
+        int ret;
+        const struct tegra_uart_chip_data *cdata;
+        const struct of_device_id *match;
+
+        match = of_match_device(tegra_uart_of_match, &pdev->dev);
+        if (!match) {
+                dev_err(&pdev->dev, "Error: No device match found\n");
+                return -ENODEV;
+        }
+        cdata = match->data;
+
+        tup = devm_kzalloc(&pdev->dev, sizeof(*tup), GFP_KERNEL);
+        if (!tup) {
+                dev_err(&pdev->dev, "Failed to allocate memory for tup\n");
+                return -ENOMEM;
+        }
+
+        ret = tegra_uart_parse_dt(pdev, tup);
+        if (ret < 0)
+                return ret;
+
+        u = &tup->uport;
+        u->dev = &pdev->dev;
+        u->ops = &tegra_uart_ops;
+        u->type = PORT_TEGRA;
+        u->fifosize = 32;
+        tup->cdata = cdata;
+
+        platform_set_drvdata(pdev, tup);
+        resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!resource) {
+                dev_err(&pdev->dev, "No IO memory resource\n");
+                return -ENODEV;
+        }
+
+        u->mapbase = resource->start;
+        u->membase = devm_request_and_ioremap(&pdev->dev, resource);
+        if (!u->membase) {
+                dev_err(&pdev->dev, "memregion/iomap address req failed\n");
+                return -EADDRNOTAVAIL;
+        }
+
+        tup->uart_clk = devm_clk_get(&pdev->dev, NULL);
+        if (IS_ERR(tup->uart_clk)) {
+                dev_err(&pdev->dev, "Couldn't get the clock\n");
+                return PTR_ERR(tup->uart_clk);
+        }
+
+        u->iotype = UPIO_MEM32;
+        u->irq = platform_get_irq(pdev, 0);
+        u->regshift = 2;
+        ret = uart_add_one_port(&tegra_uart_driver, u);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Failed to add uart port, err %d\n", ret);
+                return ret;
+        }
+        return ret;
+}
+
+static int tegra_uart_remove(struct platform_device *pdev)
+{
+        struct tegra_uart_port *tup = platform_get_drvdata(pdev);
+        struct uart_port *u = &tup->uport;
+
+        uart_remove_one_port(&tegra_uart_driver, u);
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int tegra_uart_suspend(struct device *dev)
+{
+        struct tegra_uart_port *tup = dev_get_drvdata(dev);
+        struct uart_port *u = &tup->uport;
+
+        return uart_suspend_port(&tegra_uart_driver, u);
+}
+
+static int tegra_uart_resume(struct device *dev)
+{
+        struct tegra_uart_port *tup = dev_get_drvdata(dev);
+        struct uart_port *u = &tup->uport;
+
+        return uart_resume_port(&tegra_uart_driver, u);
+}
+#endif
+
+static const struct dev_pm_ops tegra_uart_pm_ops = {
+        SET_SYSTEM_SLEEP_PM_OPS(tegra_uart_suspend, tegra_uart_resume)
+};
+
+static struct platform_driver tegra_uart_platform_driver = {
+        .probe          = tegra_uart_probe,
+        .remove         = tegra_uart_remove,
+        .driver         = {
+                .name   = "serial-tegra",
+                .of_match_table = tegra_uart_of_match,
+                .pm     = &tegra_uart_pm_ops,
+        },
+};
+
+static int __init tegra_uart_init(void)
+{
+        int ret;
+
+        ret = uart_register_driver(&tegra_uart_driver);
+        if (ret < 0) {
+                pr_err("Could not register %s driver\n",
+                        tegra_uart_driver.driver_name);
+                return ret;
+        }
+
+        ret = platform_driver_register(&tegra_uart_platform_driver);
+        if (ret < 0) {
+                pr_err("Uart platfrom driver register failed, e = %d\n", ret);
+                uart_unregister_driver(&tegra_uart_driver);
+                return ret;
+        }
+        return 0;
+}
+
+static void __exit tegra_uart_exit(void)
+{
+        pr_info("Unloading tegra uart driver\n");
+        platform_driver_unregister(&tegra_uart_platform_driver);
+        uart_unregister_driver(&tegra_uart_driver);
+}
+
+module_init(tegra_uart_init);
+module_exit(tegra_uart_exit);
+
+MODULE_ALIAS("platform:serial-tegra");
+MODULE_DESCRIPTION("High speed UART driver for tegra chipset");
+MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/tty/serial/serial_core.c b/drivers/tty/serial/serial_core.c
index 2c7230aaefd4..a400002dfa84 100644
--- a/drivers/tty/serial/serial_core.c
+++ b/drivers/tty/serial/serial_core.c
@@ -59,7 +59,8 @@ static struct lock_class_key port_lock_key;
 static void uart_change_speed(struct tty_struct *tty, struct uart_state *state,
                                         struct ktermios *old_termios);
 static void uart_wait_until_sent(struct tty_struct *tty, int timeout);
-static void uart_change_pm(struct uart_state *state, int pm_state);
+static void uart_change_pm(struct uart_state *state,
+                           enum uart_pm_state pm_state);
 
 static void uart_port_shutdown(struct tty_port *port);
 
@@ -866,9 +867,7 @@ static int uart_set_info(struct tty_struct *tty, struct tty_port *port,
         port->closing_wait    = closing_wait;
         if (new_info->xmit_fifo_size)
                 uport->fifosize = new_info->xmit_fifo_size;
-        if (port->tty)
-                port->tty->low_latency =
-                        (uport->flags & UPF_LOW_LATENCY) ? 1 : 0;
+        port->low_latency = (uport->flags & UPF_LOW_LATENCY) ? 1 : 0;
 
  check_and_exit:
         retval = 0;
@@ -1308,9 +1307,10 @@ static void uart_set_termios(struct tty_struct *tty,
 }
 
 /*
- * In 2.4.5, calls to this will be serialized via the BKL in
- *  linux/drivers/char/tty_io.c:tty_release()
- *  linux/drivers/char/tty_io.c:do_tty_handup()
+ * Calls to uart_close() are serialised via the tty_lock in
+ *   drivers/tty/tty_io.c:tty_release()
+ *   drivers/tty/tty_io.c:do_tty_hangup()
+ * This runs from a workqueue and can sleep for a _short_ time only.
  */
 static void uart_close(struct tty_struct *tty, struct file *filp)
 {
@@ -1365,7 +1365,7 @@ static void uart_close(struct tty_struct *tty, struct file *filp)
                 spin_lock_irqsave(&port->lock, flags);
         } else if (!uart_console(uport)) {
                 spin_unlock_irqrestore(&port->lock, flags);
-                uart_change_pm(state, 3);
+                uart_change_pm(state, UART_PM_STATE_OFF);
                 spin_lock_irqsave(&port->lock, flags);
         }
 
@@ -1437,10 +1437,9 @@ static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
 }
 
 /*
- * This is called with the BKL held in
- *  linux/drivers/char/tty_io.c:do_tty_hangup()
- * We're called from the eventd thread, so we can sleep for
- * a _short_ time only.
+ * Calls to uart_hangup() are serialised by the tty_lock in
+ *   drivers/tty/tty_io.c:do_tty_hangup()
+ * This runs from a workqueue and can sleep for a _short_ time only.
  */
 static void uart_hangup(struct tty_struct *tty)
 {
@@ -1521,8 +1520,8 @@ static void uart_dtr_rts(struct tty_port *port, int onoff)
 }
 
 /*
- * calls to uart_open are serialised by the BKL in
- *   fs/char_dev.c:chrdev_open()
+ * Calls to uart_open are serialised by the tty_lock in
+ *   drivers/tty/tty_io.c:tty_open()
  * Note that if this fails, then uart_close() _will_ be called.
  *
  * In time, we want to scrap the "opening nonpresent ports"
@@ -1564,7 +1563,8 @@ static int uart_open(struct tty_struct *tty, struct file *filp)
          */
         tty->driver_data = state;
         state->uart_port->state = state;
-        tty->low_latency = (state->uart_port->flags & UPF_LOW_LATENCY) ? 1 : 0;
+        state->port.low_latency =
+                (state->uart_port->flags & UPF_LOW_LATENCY) ? 1 : 0;
         tty_port_tty_set(port, tty);
 
         /*
@@ -1579,7 +1579,7 @@ static int uart_open(struct tty_struct *tty, struct file *filp)
          * Make sure the device is in D0 state.
          */
         if (port->count == 1)
-                uart_change_pm(state, 0);
+                uart_change_pm(state, UART_PM_STATE_ON);
 
         /*
          * Start up the serial port.
@@ -1620,7 +1620,7 @@ static void uart_line_info(struct seq_file *m, struct uart_driver *drv, int i)
 {
         struct uart_state *state = drv->state + i;
         struct tty_port *port = &state->port;
-        int pm_state;
+        enum uart_pm_state pm_state;
         struct uart_port *uport = state->uart_port;
         char stat_buf[32];
         unsigned int status;
@@ -1645,12 +1645,12 @@ static void uart_line_info(struct seq_file *m, struct uart_driver *drv, int i)
         if (capable(CAP_SYS_ADMIN)) {
                 mutex_lock(&port->mutex);
                 pm_state = state->pm_state;
-                if (pm_state)
-                        uart_change_pm(state, 0);
+                if (pm_state != UART_PM_STATE_ON)
+                        uart_change_pm(state, UART_PM_STATE_ON);
                 spin_lock_irq(&uport->lock);
                 status = uport->ops->get_mctrl(uport);
                 spin_unlock_irq(&uport->lock);
-                if (pm_state)
+                if (pm_state != UART_PM_STATE_ON)
                         uart_change_pm(state, pm_state);
                 mutex_unlock(&port->mutex);
 
@@ -1897,7 +1897,8 @@ EXPORT_SYMBOL_GPL(uart_set_options);
  *
  * Locking: port->mutex has to be held
  */
-static void uart_change_pm(struct uart_state *state, int pm_state)
+static void uart_change_pm(struct uart_state *state,
+                           enum uart_pm_state pm_state)
 {
         struct uart_port *port = state->uart_port;
 
@@ -1982,7 +1983,7 @@ int uart_suspend_port(struct uart_driver *drv, struct uart_port *uport)
                 console_stop(uport->cons);
 
         if (console_suspend_enabled || !uart_console(uport))
-                uart_change_pm(state, 3);
+                uart_change_pm(state, UART_PM_STATE_OFF);
 
         mutex_unlock(&port->mutex);
 
@@ -2027,7 +2028,7 @@ int uart_resume_port(struct uart_driver *drv, struct uart_port *uport)
                         termios = port->tty->termios;
 
                 if (console_suspend_enabled)
-                        uart_change_pm(state, 0);
+                        uart_change_pm(state, UART_PM_STATE_ON);
                 uport->ops->set_termios(uport, &termios, NULL);
                 if (console_suspend_enabled)
                         console_start(uport->cons);
@@ -2037,7 +2038,7 @@ int uart_resume_port(struct uart_driver *drv, struct uart_port *uport)
                 const struct uart_ops *ops = uport->ops;
                 int ret;
 
-                uart_change_pm(state, 0);
+                uart_change_pm(state, UART_PM_STATE_ON);
                 spin_lock_irq(&uport->lock);
                 ops->set_mctrl(uport, 0);
                 spin_unlock_irq(&uport->lock);
@@ -2137,7 +2138,7 @@ uart_configure_port(struct uart_driver *drv, struct uart_state *state,
                 uart_report_port(drv, port);
 
                 /* Power up port for set_mctrl() */
-                uart_change_pm(state, 0);
+                uart_change_pm(state, UART_PM_STATE_ON);
 
                 /*
                  * Ensure that the modem control lines are de-activated.
@@ -2161,7 +2162,7 @@ uart_configure_port(struct uart_driver *drv, struct uart_state *state,
                  * console if we have one.
                  */
                 if (!uart_console(port))
-                        uart_change_pm(state, 3);
+                        uart_change_pm(state, UART_PM_STATE_OFF);
         }
 }
 
@@ -2588,7 +2589,7 @@ int uart_add_one_port(struct uart_driver *drv, struct uart_port *uport)
         }
 
         state->uart_port = uport;
-        state->pm_state = -1;
+        state->pm_state = UART_PM_STATE_UNDEFINED;
 
         uport->cons = drv->cons;
         uport->state = state;
@@ -2642,6 +2643,7 @@ int uart_remove_one_port(struct uart_driver *drv, struct uart_port *uport)
 {
         struct uart_state *state = drv->state + uport->line;
         struct tty_port *port = &state->port;
+        int ret = 0;
 
         BUG_ON(in_interrupt());
 
@@ -2656,6 +2658,11 @@ int uart_remove_one_port(struct uart_driver *drv, struct uart_port *uport)
          * succeeding while we shut down the port.
          */
         mutex_lock(&port->mutex);
+        if (!state->uart_port) {
+                mutex_unlock(&port->mutex);
+                ret = -EINVAL;
+                goto out;
+        }
         uport->flags |= UPF_DEAD;
         mutex_unlock(&port->mutex);
 
@@ -2679,9 +2686,10 @@ int uart_remove_one_port(struct uart_driver *drv, struct uart_port *uport)
         uport->type = PORT_UNKNOWN;
 
         state->uart_port = NULL;
+out:
         mutex_unlock(&port_mutex);
 
-        return 0;
+        return ret;
 }
 
 /*
@@ -2715,22 +2723,17 @@ EXPORT_SYMBOL(uart_match_port);
  */
 void uart_handle_dcd_change(struct uart_port *uport, unsigned int status)
 {
-        struct uart_state *state = uport->state;
-        struct tty_port *port = &state->port;
-        struct tty_ldisc *ld = NULL;
-        struct pps_event_time ts;
+        struct tty_port *port = &uport->state->port;
         struct tty_struct *tty = port->tty;
+        struct tty_ldisc *ld = tty ? tty_ldisc_ref(tty) : NULL;
 
-        if (tty)
-                ld = tty_ldisc_ref(tty);
-        if (ld && ld->ops->dcd_change)
-                pps_get_ts(&ts);
+        if (ld) {
+                if (ld->ops->dcd_change)
+                        ld->ops->dcd_change(tty, status);
+                tty_ldisc_deref(ld);
+        }
 
         uport->icount.dcd++;
-#ifdef CONFIG_HARD_PPS
-        if ((uport->flags & UPF_HARDPPS_CD) && status)
-                hardpps();
-#endif
 
         if (port->flags & ASYNC_CHECK_CD) {
                 if (status)
@@ -2738,11 +2741,6 @@ void uart_handle_dcd_change(struct uart_port *uport, unsigned int status)
                 else if (tty)
                         tty_hangup(tty);
         }
-
-        if (ld && ld->ops->dcd_change)
-                ld->ops->dcd_change(tty, status, &ts);
-        if (ld)
-                tty_ldisc_deref(ld);
 }
 EXPORT_SYMBOL_GPL(uart_handle_dcd_change);
 
@@ -2790,10 +2788,10 @@ EXPORT_SYMBOL_GPL(uart_handle_cts_change);
 void uart_insert_char(struct uart_port *port, unsigned int status,
                  unsigned int overrun, unsigned int ch, unsigned int flag)
 {
-        struct tty_struct *tty = port->state->port.tty;
+        struct tty_port *tport = &port->state->port;
 
         if ((status & port->ignore_status_mask & ~overrun) == 0)
-                if (tty_insert_flip_char(tty, ch, flag) == 0)
+                if (tty_insert_flip_char(tport, ch, flag) == 0)
                         ++port->icount.buf_overrun;
 
         /*
@@ -2801,7 +2799,7 @@ void uart_insert_char(struct uart_port *port, unsigned int status,
          * it doesn't affect the current character.
          */
         if (status & ~port->ignore_status_mask & overrun)
-                if (tty_insert_flip_char(tty, 0, TTY_OVERRUN) == 0)
+                if (tty_insert_flip_char(tport, 0, TTY_OVERRUN) == 0)
                         ++port->icount.buf_overrun;
 }
 EXPORT_SYMBOL_GPL(uart_insert_char);
diff --git a/drivers/tty/serial/serial_ks8695.c b/drivers/tty/serial/serial_ks8695.c
index 9bd004f9da89..e1caa99e3d3b 100644
--- a/drivers/tty/serial/serial_ks8695.c
+++ b/drivers/tty/serial/serial_ks8695.c
@@ -153,7 +153,6 @@ static void ks8695uart_disable_ms(struct uart_port *port)
 static irqreturn_t ks8695uart_rx_chars(int irq, void *dev_id)
 {
         struct uart_port *port = dev_id;
-        struct tty_struct *tty = port->state->port.tty;
         unsigned int status, ch, lsr, flg, max_count = 256;
 
         status = UART_GET_LSR(port);            /* clears pending LSR interrupts */
@@ -200,7 +199,7 @@ static irqreturn_t ks8695uart_rx_chars(int irq, void *dev_id)
 ignore_char:
                 status = UART_GET_LSR(port);
         }
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&port->state->port);
 
         return IRQ_HANDLED;
 }
diff --git a/drivers/tty/serial/serial_txx9.c b/drivers/tty/serial/serial_txx9.c
index b52b21aeb250..fe48a0c2b4ca 100644
--- a/drivers/tty/serial/serial_txx9.c
+++ b/drivers/tty/serial/serial_txx9.c
@@ -277,7 +277,6 @@ 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.state->port.tty;
         unsigned char ch;
         unsigned int disr = *status;
         int max_count = 256;
@@ -346,7 +345,7 @@ receive_chars(struct uart_txx9_port *up, unsigned int *status)
                 disr = sio_in(up, TXX9_SIDISR);
         } while (!(disr & TXX9_SIDISR_UVALID) && (max_count-- > 0));
         spin_unlock(&up->port.lock);
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&up->port.state->port);
         spin_lock(&up->port.lock);
         *status = disr;
 }
diff --git a/drivers/tty/serial/sh-sci.c b/drivers/tty/serial/sh-sci.c
index 61477567423f..156418619949 100644
--- a/drivers/tty/serial/sh-sci.c
+++ b/drivers/tty/serial/sh-sci.c
@@ -596,7 +596,7 @@ static void sci_transmit_chars(struct uart_port *port)
 static void sci_receive_chars(struct uart_port *port)
 {
         struct sci_port *sci_port = to_sci_port(port);
-        struct tty_struct *tty = port->state->port.tty;
+        struct tty_port *tport = &port->state->port;
         int i, count, copied = 0;
         unsigned short status;
         unsigned char flag;
@@ -607,7 +607,7 @@ static void sci_receive_chars(struct uart_port *port)
 
         while (1) {
                 /* Don't copy more bytes than there is room for in the buffer */
-                count = tty_buffer_request_room(tty, sci_rxfill(port));
+                count = tty_buffer_request_room(tport, sci_rxfill(port));
 
                 /* If for any reason we can't copy more data, we're done! */
                 if (count == 0)
@@ -619,7 +619,7 @@ static void sci_receive_chars(struct uart_port *port)
                             sci_port->break_flag)
                                 count = 0;
                         else
-                                tty_insert_flip_char(tty, c, TTY_NORMAL);
+                                tty_insert_flip_char(tport, c, TTY_NORMAL);
                 } else {
                         for (i = 0; i < count; i++) {
                                 char c = serial_port_in(port, SCxRDR);
@@ -661,7 +661,7 @@ static void sci_receive_chars(struct uart_port *port)
                                 } else
                                         flag = TTY_NORMAL;
 
-                                tty_insert_flip_char(tty, c, flag);
+                                tty_insert_flip_char(tport, c, flag);
                         }
                 }
 
@@ -674,7 +674,7 @@ static void sci_receive_chars(struct uart_port *port)
 
         if (copied) {
                 /* Tell the rest of the system the news. New characters! */
-                tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(tport);
         } else {
                 serial_port_in(port, SCxSR); /* dummy read */
                 serial_port_out(port, SCxSR, SCxSR_RDxF_CLEAR(port));
@@ -720,7 +720,7 @@ static int sci_handle_errors(struct uart_port *port)
 {
         int copied = 0;
         unsigned short status = serial_port_in(port, SCxSR);
-        struct tty_struct *tty = port->state->port.tty;
+        struct tty_port *tport = &port->state->port;
         struct sci_port *s = to_sci_port(port);
 
         /*
@@ -731,7 +731,7 @@ static int sci_handle_errors(struct uart_port *port)
                         port->icount.overrun++;
 
                         /* overrun error */
-                        if (tty_insert_flip_char(tty, 0, TTY_OVERRUN))
+                        if (tty_insert_flip_char(tport, 0, TTY_OVERRUN))
                                 copied++;
 
                         dev_notice(port->dev, "overrun error");
@@ -755,7 +755,7 @@ static int sci_handle_errors(struct uart_port *port)
 
                                 dev_dbg(port->dev, "BREAK detected\n");
 
-                                if (tty_insert_flip_char(tty, 0, TTY_BREAK))
+                                if (tty_insert_flip_char(tport, 0, TTY_BREAK))
                                         copied++;
                         }
 
@@ -763,7 +763,7 @@ static int sci_handle_errors(struct uart_port *port)
                         /* frame error */
                         port->icount.frame++;
 
-                        if (tty_insert_flip_char(tty, 0, TTY_FRAME))
+                        if (tty_insert_flip_char(tport, 0, TTY_FRAME))
                                 copied++;
 
                         dev_notice(port->dev, "frame error\n");
@@ -774,21 +774,21 @@ static int sci_handle_errors(struct uart_port *port)
                 /* parity error */
                 port->icount.parity++;
 
-                if (tty_insert_flip_char(tty, 0, TTY_PARITY))
+                if (tty_insert_flip_char(tport, 0, TTY_PARITY))
                         copied++;
 
                 dev_notice(port->dev, "parity error");
         }
 
         if (copied)
-                tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(tport);
 
         return copied;
 }
 
 static int sci_handle_fifo_overrun(struct uart_port *port)
 {
-        struct tty_struct *tty = port->state->port.tty;
+        struct tty_port *tport = &port->state->port;
         struct sci_port *s = to_sci_port(port);
         struct plat_sci_reg *reg;
         int copied = 0;
@@ -802,8 +802,8 @@ static int sci_handle_fifo_overrun(struct uart_port *port)
 
                 port->icount.overrun++;
 
-                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
-                tty_flip_buffer_push(tty);
+                tty_insert_flip_char(tport, 0, TTY_OVERRUN);
+                tty_flip_buffer_push(tport);
 
                 dev_notice(port->dev, "overrun error\n");
                 copied++;
@@ -816,7 +816,7 @@ static int sci_handle_breaks(struct uart_port *port)
 {
         int copied = 0;
         unsigned short status = serial_port_in(port, SCxSR);
-        struct tty_struct *tty = port->state->port.tty;
+        struct tty_port *tport = &port->state->port;
         struct sci_port *s = to_sci_port(port);
 
         if (uart_handle_break(port))
@@ -831,14 +831,14 @@ static int sci_handle_breaks(struct uart_port *port)
                 port->icount.brk++;
 
                 /* Notify of BREAK */
-                if (tty_insert_flip_char(tty, 0, TTY_BREAK))
+                if (tty_insert_flip_char(tport, 0, TTY_BREAK))
                         copied++;
 
                 dev_dbg(port->dev, "BREAK detected\n");
         }
 
         if (copied)
-                tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(tport);
 
         copied += sci_handle_fifo_overrun(port);
 
@@ -1259,13 +1259,13 @@ static void sci_dma_tx_complete(void *arg)
 }
 
 /* Locking: called with port lock held */
-static int sci_dma_rx_push(struct sci_port *s, struct tty_struct *tty,
-                           size_t count)
+static int sci_dma_rx_push(struct sci_port *s, size_t count)
 {
         struct uart_port *port = &s->port;
+        struct tty_port *tport = &port->state->port;
         int i, active, room;
 
-        room = tty_buffer_request_room(tty, count);
+        room = tty_buffer_request_room(tport, count);
 
         if (s->active_rx == s->cookie_rx[0]) {
                 active = 0;
@@ -1283,7 +1283,7 @@ static int sci_dma_rx_push(struct sci_port *s, struct tty_struct *tty,
                 return room;
 
         for (i = 0; i < room; i++)
-                tty_insert_flip_char(tty, ((u8 *)sg_virt(&s->sg_rx[active]))[i],
+                tty_insert_flip_char(tport, ((u8 *)sg_virt(&s->sg_rx[active]))[i],
                                      TTY_NORMAL);
 
         port->icount.rx += room;
@@ -1295,7 +1295,6 @@ static void sci_dma_rx_complete(void *arg)
 {
         struct sci_port *s = arg;
         struct uart_port *port = &s->port;
-        struct tty_struct *tty = port->state->port.tty;
         unsigned long flags;
         int count;
 
@@ -1303,14 +1302,14 @@ static void sci_dma_rx_complete(void *arg)
 
         spin_lock_irqsave(&port->lock, flags);
 
-        count = sci_dma_rx_push(s, tty, s->buf_len_rx);
+        count = sci_dma_rx_push(s, s->buf_len_rx);
 
         mod_timer(&s->rx_timer, jiffies + s->rx_timeout);
 
         spin_unlock_irqrestore(&port->lock, flags);
 
         if (count)
-                tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(&port->state->port);
 
         schedule_work(&s->work_rx);
 }
@@ -1404,7 +1403,6 @@ static void work_fn_rx(struct work_struct *work)
         if (dma_async_is_tx_complete(s->chan_rx, s->active_rx, NULL, NULL) !=
             DMA_SUCCESS) {
                 /* Handle incomplete DMA receive */
-                struct tty_struct *tty = port->state->port.tty;
                 struct dma_chan *chan = s->chan_rx;
                 struct shdma_desc *sh_desc = container_of(desc,
                                         struct shdma_desc, async_tx);
@@ -1416,11 +1414,11 @@ static void work_fn_rx(struct work_struct *work)
                         sh_desc->partial, sh_desc->cookie);
 
                 spin_lock_irqsave(&port->lock, flags);
-                count = sci_dma_rx_push(s, tty, sh_desc->partial);
+                count = sci_dma_rx_push(s, sh_desc->partial);
                 spin_unlock_irqrestore(&port->lock, flags);
 
                 if (count)
-                        tty_flip_buffer_push(tty);
+                        tty_flip_buffer_push(&port->state->port);
 
                 sci_submit_rx(s);
 
diff --git a/drivers/tty/serial/sirfsoc_uart.c b/drivers/tty/serial/sirfsoc_uart.c
index 5da5cb962769..6bbfe9934a4d 100644
--- a/drivers/tty/serial/sirfsoc_uart.c
+++ b/drivers/tty/serial/sirfsoc_uart.c
@@ -75,6 +75,20 @@ static struct sirfsoc_uart_port sirfsoc_uart_ports[SIRFSOC_UART_NR] = {
                         .line           = 2,
                 },
         },
+        [3] = {
+                .port = {
+                        .iotype         = UPIO_MEM,
+                        .flags          = UPF_BOOT_AUTOCONF,
+                        .line           = 3,
+                },
+        },
+        [4] = {
+                .port = {
+                        .iotype         = UPIO_MEM,
+                        .flags          = UPF_BOOT_AUTOCONF,
+                        .line           = 4,
+                },
+        },
 };
 
 static inline struct sirfsoc_uart_port *to_sirfport(struct uart_port *port)
@@ -192,11 +206,6 @@ static unsigned int
 sirfsoc_uart_pio_rx_chars(struct uart_port *port, unsigned int max_rx_count)
 {
         unsigned int ch, rx_count = 0;
-        struct tty_struct *tty;
-
-        tty = tty_port_tty_get(&port->state->port);
-        if (!tty)
-                return -ENODEV;
 
         while (!(rd_regl(port, SIRFUART_RX_FIFO_STATUS) &
                                         SIRFUART_FIFOEMPTY_MASK(port))) {
@@ -210,8 +219,7 @@ sirfsoc_uart_pio_rx_chars(struct uart_port *port, unsigned int max_rx_count)
         }
 
         port->icount.rx += rx_count;
-        tty_flip_buffer_push(tty);
-        tty_kref_put(tty);
+        tty_flip_buffer_push(&port->state->port);
 
         return rx_count;
 }
@@ -245,6 +253,7 @@ static irqreturn_t sirfsoc_uart_isr(int irq, void *dev_id)
         struct uart_port *port = &sirfport->port;
         struct uart_state *state = port->state;
         struct circ_buf *xmit = &port->state->xmit;
+        spin_lock(&port->lock);
         intr_status = rd_regl(port, SIRFUART_INT_STATUS);
         wr_regl(port, SIRFUART_INT_STATUS, intr_status);
         intr_status &= rd_regl(port, SIRFUART_INT_EN);
@@ -254,6 +263,7 @@ static irqreturn_t sirfsoc_uart_isr(int irq, void *dev_id)
                                 goto recv_char;
                         uart_insert_char(port, intr_status,
                                         SIRFUART_RX_OFLOW, 0, TTY_BREAK);
+                        spin_unlock(&port->lock);
                         return IRQ_HANDLED;
                 }
                 if (intr_status & SIRFUART_RX_OFLOW)
@@ -286,6 +296,7 @@ recv_char:
                 sirfsoc_uart_pio_rx_chars(port, SIRFSOC_UART_IO_RX_MAX_CNT);
         if (intr_status & SIRFUART_TX_INT_EN) {
                 if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
+                        spin_unlock(&port->lock);
                         return IRQ_HANDLED;
                 } else {
                         sirfsoc_uart_pio_tx_chars(sirfport,
@@ -296,6 +307,7 @@ recv_char:
                                 sirfsoc_uart_stop_tx(port);
                 }
         }
+        spin_unlock(&port->lock);
         return IRQ_HANDLED;
 }
 
@@ -345,7 +357,6 @@ static void sirfsoc_uart_set_termios(struct uart_port *port,
                                        struct ktermios *old)
 {
         struct sirfsoc_uart_port *sirfport = to_sirfport(port);
-        unsigned long   ioclk_rate;
         unsigned long   config_reg = 0;
         unsigned long   baud_rate;
         unsigned long   setted_baud;
@@ -357,7 +368,6 @@ static void sirfsoc_uart_set_termios(struct uart_port *port,
         int             threshold_div;
         int             temp;
 
-        ioclk_rate = 150000000;
         switch (termios->c_cflag & CSIZE) {
         default:
         case CS8:
@@ -413,14 +423,17 @@ static void sirfsoc_uart_set_termios(struct uart_port *port,
                         sirfsoc_uart_disable_ms(port);
         }
 
-        /* common rate: fast calculation */
-        for (ic = 0; ic < SIRF_BAUD_RATE_SUPPORT_NR; ic++)
-                if (baud_rate == baudrate_to_regv[ic].baud_rate)
-                        clk_div_reg = baudrate_to_regv[ic].reg_val;
+        if (port->uartclk == 150000000) {
+                /* common rate: fast calculation */
+                for (ic = 0; ic < SIRF_BAUD_RATE_SUPPORT_NR; ic++)
+                        if (baud_rate == baudrate_to_regv[ic].baud_rate)
+                                clk_div_reg = baudrate_to_regv[ic].reg_val;
+        }
+
         setted_baud = baud_rate;
         /* arbitary rate setting */
         if (unlikely(clk_div_reg == 0))
-                clk_div_reg = sirfsoc_calc_sample_div(baud_rate, ioclk_rate,
+                clk_div_reg = sirfsoc_calc_sample_div(baud_rate, port->uartclk,
                                                                 &setted_baud);
         wr_regl(port, SIRFUART_DIVISOR, clk_div_reg);
 
@@ -679,6 +692,14 @@ int sirfsoc_uart_probe(struct platform_device *pdev)
                         goto err;
         }
 
+        sirfport->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(sirfport->clk)) {
+                ret = PTR_ERR(sirfport->clk);
+                goto clk_err;
+        }
+        clk_prepare_enable(sirfport->clk);
+        port->uartclk = clk_get_rate(sirfport->clk);
+
         port->ops = &sirfsoc_uart_ops;
         spin_lock_init(&port->lock);
 
@@ -692,6 +713,9 @@ int sirfsoc_uart_probe(struct platform_device *pdev)
         return 0;
 
 port_err:
+        clk_disable_unprepare(sirfport->clk);
+        clk_put(sirfport->clk);
+clk_err:
         platform_set_drvdata(pdev, NULL);
         if (sirfport->hw_flow_ctrl)
                 pinctrl_put(sirfport->p);
@@ -706,6 +730,8 @@ static int sirfsoc_uart_remove(struct platform_device *pdev)
         platform_set_drvdata(pdev, NULL);
         if (sirfport->hw_flow_ctrl)
                 pinctrl_put(sirfport->p);
+        clk_disable_unprepare(sirfport->clk);
+        clk_put(sirfport->clk);
         uart_remove_one_port(&sirfsoc_uart_drv, port);
         return 0;
 }
@@ -729,6 +755,7 @@ static int sirfsoc_uart_resume(struct platform_device *pdev)
 
 static struct of_device_id sirfsoc_uart_ids[] = {
         { .compatible = "sirf,prima2-uart", },
+        { .compatible = "sirf,marco-uart", },
         {}
 };
 MODULE_DEVICE_TABLE(of, sirfsoc_serial_of_match);
diff --git a/drivers/tty/serial/sirfsoc_uart.h b/drivers/tty/serial/sirfsoc_uart.h
index 6e207fdc2fed..85328ba0c4e3 100644
--- a/drivers/tty/serial/sirfsoc_uart.h
+++ b/drivers/tty/serial/sirfsoc_uart.h
@@ -139,7 +139,7 @@
 #define SIRFSOC_UART_MINOR                      0
 #define SIRFUART_PORT_NAME                      "sirfsoc-uart"
 #define SIRFUART_MAP_SIZE                       0x200
-#define SIRFSOC_UART_NR                         3
+#define SIRFSOC_UART_NR                         5
 #define SIRFSOC_PORT_TYPE                       0xa5
 
 /* Baud Rate Calculation */
@@ -163,6 +163,7 @@ struct sirfsoc_uart_port {
 
         struct uart_port                port;
         struct pinctrl                  *p;
+        struct clk                      *clk;
 };
 
 /* Hardware Flow Control */
diff --git a/drivers/tty/serial/sn_console.c b/drivers/tty/serial/sn_console.c
index 1c6de9f58699..f51ffdc696fd 100644
--- a/drivers/tty/serial/sn_console.c
+++ b/drivers/tty/serial/sn_console.c
@@ -457,8 +457,8 @@ static int sn_debug_printf(const char *fmt, ...)
 static void
 sn_receive_chars(struct sn_cons_port *port, unsigned long flags)
 {
+        struct tty_port *tport = NULL;
         int ch;
-        struct tty_struct *tty;
 
         if (!port) {
                 printk(KERN_ERR "sn_receive_chars - port NULL so can't receive\n");
@@ -472,11 +472,7 @@ sn_receive_chars(struct sn_cons_port *port, unsigned long flags)
 
         if (port->sc_port.state) {
                 /* The serial_core stuffs are initialized, use them */
-                tty = port->sc_port.state->port.tty;
-        }
-        else {
-                /* Not registered yet - can't pass to tty layer.  */
-                tty = NULL;
+                tport = &port->sc_port.state->port;
         }
 
         while (port->sc_ops->sal_input_pending()) {
@@ -516,15 +512,15 @@ sn_receive_chars(struct sn_cons_port *port, unsigned long flags)
 #endif /* CONFIG_MAGIC_SYSRQ */
 
                 /* record the character to pass up to the tty layer */
-                if (tty) {
-                        if(tty_insert_flip_char(tty, ch, TTY_NORMAL) == 0)
+                if (tport) {
+                        if (tty_insert_flip_char(tport, ch, TTY_NORMAL) == 0)
                                 break;
                 }
                 port->sc_port.icount.rx++;
         }
 
-        if (tty)
-                tty_flip_buffer_push(tty);
+        if (tport)
+                tty_flip_buffer_push(tport);
 }
 
 /**
diff --git a/drivers/tty/serial/sunhv.c b/drivers/tty/serial/sunhv.c
index b9bf9c53f7fd..ba60708053e0 100644
--- a/drivers/tty/serial/sunhv.c
+++ b/drivers/tty/serial/sunhv.c
@@ -72,7 +72,7 @@ static void transmit_chars_write(struct uart_port *port, struct circ_buf *xmit)
         }
 }
 
-static int receive_chars_getchar(struct uart_port *port, struct tty_struct *tty)
+static int receive_chars_getchar(struct uart_port *port)
 {
         int saw_console_brk = 0;
         int limit = 10000;
@@ -99,7 +99,7 @@ static int receive_chars_getchar(struct uart_port *port, struct tty_struct *tty)
                         uart_handle_dcd_change(port, 1);
                 }
 
-                if (tty == NULL) {
+                if (port->state == NULL) {
                         uart_handle_sysrq_char(port, c);
                         continue;
                 }
@@ -109,13 +109,13 @@ static int receive_chars_getchar(struct uart_port *port, struct tty_struct *tty)
                 if (uart_handle_sysrq_char(port, c))
                         continue;
 
-                tty_insert_flip_char(tty, c, TTY_NORMAL);
+                tty_insert_flip_char(&port->state->port, c, TTY_NORMAL);
         }
 
         return saw_console_brk;
 }
 
-static int receive_chars_read(struct uart_port *port, struct tty_struct *tty)
+static int receive_chars_read(struct uart_port *port)
 {
         int saw_console_brk = 0;
         int limit = 10000;
@@ -152,12 +152,13 @@ static int receive_chars_read(struct uart_port *port, struct tty_struct *tty)
                 for (i = 0; i < bytes_read; i++)
                         uart_handle_sysrq_char(port, con_read_page[i]);
 
-                if (tty == NULL)
+                if (port->state == NULL)
                         continue;
 
                 port->icount.rx += bytes_read;
 
-                tty_insert_flip_string(tty, con_read_page, bytes_read);
+                tty_insert_flip_string(&port->state->port, con_read_page,
+                                bytes_read);
         }
 
         return saw_console_brk;
@@ -165,7 +166,7 @@ static int receive_chars_read(struct uart_port *port, struct tty_struct *tty)
 
 struct sunhv_ops {
         void (*transmit_chars)(struct uart_port *port, struct circ_buf *xmit);
-        int (*receive_chars)(struct uart_port *port, struct tty_struct *tty);
+        int (*receive_chars)(struct uart_port *port);
 };
 
 static struct sunhv_ops bychar_ops = {
@@ -180,17 +181,17 @@ static struct sunhv_ops bywrite_ops = {
 
 static struct sunhv_ops *sunhv_ops = &bychar_ops;
 
-static struct tty_struct *receive_chars(struct uart_port *port)
+static struct tty_port *receive_chars(struct uart_port *port)
 {
-        struct tty_struct *tty = NULL;
+        struct tty_port *tport = NULL;
 
         if (port->state != NULL)                /* Unopened serial console */
-                tty = port->state->port.tty;
+                tport = &port->state->port;
 
-        if (sunhv_ops->receive_chars(port, tty))
+        if (sunhv_ops->receive_chars(port))
                 sun_do_break();
 
-        return tty;
+        return tport;
 }
 
 static void transmit_chars(struct uart_port *port)
@@ -213,16 +214,16 @@ static void transmit_chars(struct uart_port *port)
 static irqreturn_t sunhv_interrupt(int irq, void *dev_id)
 {
         struct uart_port *port = dev_id;
-        struct tty_struct *tty;
+        struct tty_port *tport;
         unsigned long flags;
 
         spin_lock_irqsave(&port->lock, flags);
-        tty = receive_chars(port);
+        tport = receive_chars(port);
         transmit_chars(port);
         spin_unlock_irqrestore(&port->lock, flags);
 
-        if (tty)
-                tty_flip_buffer_push(tty);
+        if (tport)
+                tty_flip_buffer_push(tport);
 
         return IRQ_HANDLED;
 }
diff --git a/drivers/tty/serial/sunsab.c b/drivers/tty/serial/sunsab.c
index bd8b3b634103..8de2213664e0 100644
--- a/drivers/tty/serial/sunsab.c
+++ b/drivers/tty/serial/sunsab.c
@@ -107,11 +107,11 @@ static __inline__ void sunsab_cec_wait(struct uart_sunsab_port *up)
                 udelay(1);
 }
 
-static struct tty_struct *
+static struct tty_port *
 receive_chars(struct uart_sunsab_port *up,
               union sab82532_irq_status *stat)
 {
-        struct tty_struct *tty = NULL;
+        struct tty_port *port = NULL;
         unsigned char buf[32];
         int saw_console_brk = 0;
         int free_fifo = 0;
@@ -119,7 +119,7 @@ receive_chars(struct uart_sunsab_port *up,
         int i;
 
         if (up->port.state != NULL)             /* Unopened serial console */
-                tty = up->port.state->port.tty;
+                port = &up->port.state->port;
 
         /* Read number of BYTES (Character + Status) available. */
         if (stat->sreg.isr0 & SAB82532_ISR0_RPF) {
@@ -136,7 +136,7 @@ receive_chars(struct uart_sunsab_port *up,
         if (stat->sreg.isr0 & SAB82532_ISR0_TIME) {
                 sunsab_cec_wait(up);
                 writeb(SAB82532_CMDR_RFRD, &up->regs->w.cmdr);
-                return tty;
+                return port;
         }
 
         if (stat->sreg.isr0 & SAB82532_ISR0_RFO)
@@ -160,11 +160,6 @@ receive_chars(struct uart_sunsab_port *up,
         for (i = 0; i < count; i++) {
                 unsigned char ch = buf[i], flag;
 
-                if (tty == NULL) {
-                        uart_handle_sysrq_char(&up->port, ch);
-                        continue;
-                }
-
                 flag = TTY_NORMAL;
                 up->port.icount.rx++;
 
@@ -213,15 +208,15 @@ receive_chars(struct uart_sunsab_port *up,
 
                 if ((stat->sreg.isr0 & (up->port.ignore_status_mask & 0xff)) == 0 &&
                     (stat->sreg.isr1 & ((up->port.ignore_status_mask >> 8) & 0xff)) == 0)
-                        tty_insert_flip_char(tty, ch, flag);
+                        tty_insert_flip_char(port, ch, flag);
                 if (stat->sreg.isr0 & SAB82532_ISR0_RFO)
-                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                        tty_insert_flip_char(port, 0, TTY_OVERRUN);
         }
 
         if (saw_console_brk)
                 sun_do_break();
 
-        return tty;
+        return port;
 }
 
 static void sunsab_stop_tx(struct uart_port *);
@@ -304,7 +299,7 @@ static void check_status(struct uart_sunsab_port *up,
 static irqreturn_t sunsab_interrupt(int irq, void *dev_id)
 {
         struct uart_sunsab_port *up = dev_id;
-        struct tty_struct *tty;
+        struct tty_port *port = NULL;
         union sab82532_irq_status status;
         unsigned long flags;
         unsigned char gis;
@@ -318,12 +313,11 @@ static irqreturn_t sunsab_interrupt(int irq, void *dev_id)
         if (gis & 2)
                 status.sreg.isr1 = readb(&up->regs->r.isr1);
 
-        tty = NULL;
         if (status.stat) {
                 if ((status.sreg.isr0 & (SAB82532_ISR0_TCD | SAB82532_ISR0_TIME |
                                          SAB82532_ISR0_RFO | SAB82532_ISR0_RPF)) ||
                     (status.sreg.isr1 & SAB82532_ISR1_BRK))
-                        tty = receive_chars(up, &status);
+                        port = receive_chars(up, &status);
                 if ((status.sreg.isr0 & SAB82532_ISR0_CDSC) ||
                     (status.sreg.isr1 & SAB82532_ISR1_CSC))
                         check_status(up, &status);
@@ -333,8 +327,8 @@ static irqreturn_t sunsab_interrupt(int irq, void *dev_id)
 
         spin_unlock_irqrestore(&up->port.lock, flags);
 
-        if (tty)
-                tty_flip_buffer_push(tty);
+        if (port)
+                tty_flip_buffer_push(port);
 
         return IRQ_HANDLED;
 }
diff --git a/drivers/tty/serial/sunsu.c b/drivers/tty/serial/sunsu.c
index 220da3f9724f..e343d6670854 100644
--- a/drivers/tty/serial/sunsu.c
+++ b/drivers/tty/serial/sunsu.c
@@ -315,10 +315,10 @@ static void sunsu_enable_ms(struct uart_port *port)
         spin_unlock_irqrestore(&up->port.lock, flags);
 }
 
-static struct tty_struct *
+static void
 receive_chars(struct uart_sunsu_port *up, unsigned char *status)
 {
-        struct tty_struct *tty = up->port.state->port.tty;
+        struct tty_port *port = &up->port.state->port;
         unsigned char ch, flag;
         int max_count = 256;
         int saw_console_brk = 0;
@@ -376,22 +376,20 @@ receive_chars(struct uart_sunsu_port *up, unsigned char *status)
                 if (uart_handle_sysrq_char(&up->port, ch))
                         goto ignore_char;
                 if ((*status & up->port.ignore_status_mask) == 0)
-                        tty_insert_flip_char(tty, ch, flag);
+                        tty_insert_flip_char(port, ch, flag);
                 if (*status & UART_LSR_OE)
                         /*
                          * Overrun is special, since it's reported
                          * immediately, and doesn't affect the current
                          * character.
                          */
-                         tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                         tty_insert_flip_char(port, 0, TTY_OVERRUN);
         ignore_char:
                 *status = serial_inp(up, UART_LSR);
         } while ((*status & UART_LSR_DR) && (max_count-- > 0));
 
         if (saw_console_brk)
                 sun_do_break();
-
-        return tty;
 }
 
 static void transmit_chars(struct uart_sunsu_port *up)
@@ -460,20 +458,16 @@ static irqreturn_t sunsu_serial_interrupt(int irq, void *dev_id)
         spin_lock_irqsave(&up->port.lock, flags);
 
         do {
-                struct tty_struct *tty;
-
                 status = serial_inp(up, UART_LSR);
-                tty = NULL;
                 if (status & UART_LSR_DR)
-                        tty = receive_chars(up, &status);
+                        receive_chars(up, &status);
                 check_modem_status(up);
                 if (status & UART_LSR_THRE)
                         transmit_chars(up);
 
                 spin_unlock_irqrestore(&up->port.lock, flags);
 
-                if (tty)
-                        tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(&up->port.state->port);
 
                 spin_lock_irqsave(&up->port.lock, flags);
 
diff --git a/drivers/tty/serial/sunzilog.c b/drivers/tty/serial/sunzilog.c
index aef4fab957c3..27669ff3d446 100644
--- a/drivers/tty/serial/sunzilog.c
+++ b/drivers/tty/serial/sunzilog.c
@@ -323,17 +323,15 @@ static void sunzilog_kbdms_receive_chars(struct uart_sunzilog_port *up,
         }
 }
 
-static struct tty_struct *
+static struct tty_port *
 sunzilog_receive_chars(struct uart_sunzilog_port *up,
                        struct zilog_channel __iomem *channel)
 {
-        struct tty_struct *tty;
+        struct tty_port *port = NULL;
         unsigned char ch, r1, flag;
 
-        tty = NULL;
-        if (up->port.state != NULL &&           /* Unopened serial console */
-            up->port.state->port.tty != NULL)   /* Keyboard || mouse */
-                tty = up->port.state->port.tty;
+        if (up->port.state != NULL)             /* Unopened serial console */
+                port = &up->port.state->port;
 
         for (;;) {
 
@@ -366,11 +364,6 @@ sunzilog_receive_chars(struct uart_sunzilog_port *up,
                         continue;
                 }
 
-                if (tty == NULL) {
-                        uart_handle_sysrq_char(&up->port, ch);
-                        continue;
-                }
-
                 /* A real serial line, record the character and status.  */
                 flag = TTY_NORMAL;
                 up->port.icount.rx++;
@@ -400,13 +393,13 @@ sunzilog_receive_chars(struct uart_sunzilog_port *up,
 
                 if (up->port.ignore_status_mask == 0xff ||
                     (r1 & up->port.ignore_status_mask) == 0) {
-                        tty_insert_flip_char(tty, ch, flag);
+                        tty_insert_flip_char(port, ch, flag);
                 }
                 if (r1 & Rx_OVR)
-                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                        tty_insert_flip_char(port, 0, TTY_OVERRUN);
         }
 
-        return tty;
+        return port;
 }
 
 static void sunzilog_status_handle(struct uart_sunzilog_port *up,
@@ -539,21 +532,21 @@ static irqreturn_t sunzilog_interrupt(int irq, void *dev_id)
         while (up) {
                 struct zilog_channel __iomem *channel
                         = ZILOG_CHANNEL_FROM_PORT(&up->port);
-                struct tty_struct *tty;
+                struct tty_port *port;
                 unsigned char r3;
 
                 spin_lock(&up->port.lock);
                 r3 = read_zsreg(channel, R3);
 
                 /* Channel A */
-                tty = NULL;
+                port = NULL;
                 if (r3 & (CHAEXT | CHATxIP | CHARxIP)) {
                         writeb(RES_H_IUS, &channel->control);
                         ZSDELAY();
                         ZS_WSYNC(channel);
 
                         if (r3 & CHARxIP)
-                                tty = sunzilog_receive_chars(up, channel);
+                                port = sunzilog_receive_chars(up, channel);
                         if (r3 & CHAEXT)
                                 sunzilog_status_handle(up, channel);
                         if (r3 & CHATxIP)
@@ -561,22 +554,22 @@ static irqreturn_t sunzilog_interrupt(int irq, void *dev_id)
                 }
                 spin_unlock(&up->port.lock);
 
-                if (tty)
-                        tty_flip_buffer_push(tty);
+                if (port)
+                        tty_flip_buffer_push(port);
 
                 /* Channel B */
                 up = up->next;
                 channel = ZILOG_CHANNEL_FROM_PORT(&up->port);
 
                 spin_lock(&up->port.lock);
-                tty = NULL;
+                port = NULL;
                 if (r3 & (CHBEXT | CHBTxIP | CHBRxIP)) {
                         writeb(RES_H_IUS, &channel->control);
                         ZSDELAY();
                         ZS_WSYNC(channel);
 
                         if (r3 & CHBRxIP)
-                                tty = sunzilog_receive_chars(up, channel);
+                                port = sunzilog_receive_chars(up, channel);
                         if (r3 & CHBEXT)
                                 sunzilog_status_handle(up, channel);
                         if (r3 & CHBTxIP)
@@ -584,8 +577,8 @@ static irqreturn_t sunzilog_interrupt(int irq, void *dev_id)
                 }
                 spin_unlock(&up->port.lock);
 
-                if (tty)
-                        tty_flip_buffer_push(tty);
+                if (port)
+                        tty_flip_buffer_push(port);
 
                 up = up->next;
         }
diff --git a/drivers/tty/serial/timbuart.c b/drivers/tty/serial/timbuart.c
index 5be0d68feceb..6818410a2bea 100644
--- a/drivers/tty/serial/timbuart.c
+++ b/drivers/tty/serial/timbuart.c
@@ -91,16 +91,16 @@ static void timbuart_flush_buffer(struct uart_port *port)
 
 static void timbuart_rx_chars(struct uart_port *port)
 {
-        struct tty_struct *tty = port->state->port.tty;
+        struct tty_port *tport = &port->state->port;
 
         while (ioread32(port->membase + TIMBUART_ISR) & RXDP) {
                 u8 ch = ioread8(port->membase + TIMBUART_RXFIFO);
                 port->icount.rx++;
-                tty_insert_flip_char(tty, ch, TTY_NORMAL);
+                tty_insert_flip_char(tport, ch, TTY_NORMAL);
         }
 
         spin_unlock(&port->lock);
-        tty_flip_buffer_push(port->state->port.tty);
+        tty_flip_buffer_push(tport);
         spin_lock(&port->lock);
 
         dev_dbg(port->dev, "%s - total read %d bytes\n",
diff --git a/drivers/tty/serial/uartlite.c b/drivers/tty/serial/uartlite.c
index 89eee43c4e2d..5f90ef24d475 100644
--- a/drivers/tty/serial/uartlite.c
+++ b/drivers/tty/serial/uartlite.c
@@ -19,7 +19,7 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/of.h>
 #include <linux/of_address.h>
 #include <linux/of_device.h>
@@ -34,7 +34,7 @@
  * Register definitions
  *
  * For register details see datasheet:
- * http://www.xilinx.com/support/documentation/ip_documentation/opb_uartlite.pdf 
+ * http://www.xilinx.com/support/documentation/ip_documentation/opb_uartlite.pdf
  */
 
 #define ULITE_RX                0x00
@@ -57,6 +57,54 @@
 #define ULITE_CONTROL_RST_RX    0x02
 #define ULITE_CONTROL_IE        0x10
 
+struct uartlite_reg_ops {
+        u32 (*in)(void __iomem *addr);
+        void (*out)(u32 val, void __iomem *addr);
+};
+
+static u32 uartlite_inbe32(void __iomem *addr)
+{
+        return ioread32be(addr);
+}
+
+static void uartlite_outbe32(u32 val, void __iomem *addr)
+{
+        iowrite32be(val, addr);
+}
+
+static struct uartlite_reg_ops uartlite_be = {
+        .in = uartlite_inbe32,
+        .out = uartlite_outbe32,
+};
+
+static u32 uartlite_inle32(void __iomem *addr)
+{
+        return ioread32(addr);
+}
+
+static void uartlite_outle32(u32 val, void __iomem *addr)
+{
+        iowrite32(val, addr);
+}
+
+static struct uartlite_reg_ops uartlite_le = {
+        .in = uartlite_inle32,
+        .out = uartlite_outle32,
+};
+
+static inline u32 uart_in32(u32 offset, struct uart_port *port)
+{
+        struct uartlite_reg_ops *reg_ops = port->private_data;
+
+        return reg_ops->in(port->membase + offset);
+}
+
+static inline void uart_out32(u32 val, u32 offset, struct uart_port *port)
+{
+        struct uartlite_reg_ops *reg_ops = port->private_data;
+
+        reg_ops->out(val, port->membase + offset);
+}
 
 static struct uart_port ulite_ports[ULITE_NR_UARTS];
 
@@ -66,7 +114,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->state->port.tty;
+        struct tty_port *tport = &port->state->port;
         unsigned char ch = 0;
         char flag = TTY_NORMAL;
 
@@ -77,7 +125,7 @@ static int ulite_receive(struct uart_port *port, int stat)
         /* stats */
         if (stat & ULITE_STATUS_RXVALID) {
                 port->icount.rx++;
-                ch = ioread32be(port->membase + ULITE_RX);
+                ch = uart_in32(ULITE_RX, port);
 
                 if (stat & ULITE_STATUS_PARITY)
                         port->icount.parity++;
@@ -103,13 +151,13 @@ static int ulite_receive(struct uart_port *port, int stat)
         stat &= ~port->ignore_status_mask;
 
         if (stat & ULITE_STATUS_RXVALID)
-                tty_insert_flip_char(tty, ch, flag);
+                tty_insert_flip_char(tport, ch, flag);
 
         if (stat & ULITE_STATUS_FRAME)
-                tty_insert_flip_char(tty, 0, TTY_FRAME);
+                tty_insert_flip_char(tport, 0, TTY_FRAME);
 
         if (stat & ULITE_STATUS_OVERRUN)
-                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                tty_insert_flip_char(tport, 0, TTY_OVERRUN);
 
         return 1;
 }
@@ -122,7 +170,7 @@ static int ulite_transmit(struct uart_port *port, int stat)
                 return 0;
 
         if (port->x_char) {
-                iowrite32be(port->x_char, port->membase + ULITE_TX);
+                uart_out32(port->x_char, ULITE_TX, port);
                 port->x_char = 0;
                 port->icount.tx++;
                 return 1;
@@ -131,7 +179,7 @@ static int ulite_transmit(struct uart_port *port, int stat)
         if (uart_circ_empty(xmit) || uart_tx_stopped(port))
                 return 0;
 
-        iowrite32be(xmit->buf[xmit->tail], port->membase + ULITE_TX);
+        uart_out32(xmit->buf[xmit->tail], ULITE_TX, port);
         xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE-1);
         port->icount.tx++;
 
@@ -148,7 +196,7 @@ static irqreturn_t ulite_isr(int irq, void *dev_id)
         int busy, n = 0;
 
         do {
-                int stat = ioread32be(port->membase + ULITE_STATUS);
+                int stat = uart_in32(ULITE_STATUS, port);
                 busy  = ulite_receive(port, stat);
                 busy |= ulite_transmit(port, stat);
                 n++;
@@ -156,7 +204,7 @@ static irqreturn_t ulite_isr(int irq, void *dev_id)
 
         /* work done? */
         if (n > 1) {
-                tty_flip_buffer_push(port->state->port.tty);
+                tty_flip_buffer_push(&port->state->port);
                 return IRQ_HANDLED;
         } else {
                 return IRQ_NONE;
@@ -169,7 +217,7 @@ static unsigned int ulite_tx_empty(struct uart_port *port)
         unsigned int ret;
 
         spin_lock_irqsave(&port->lock, flags);
-        ret = ioread32be(port->membase + ULITE_STATUS);
+        ret = uart_in32(ULITE_STATUS, port);
         spin_unlock_irqrestore(&port->lock, flags);
 
         return ret & ULITE_STATUS_TXEMPTY ? TIOCSER_TEMT : 0;
@@ -192,7 +240,7 @@ static void ulite_stop_tx(struct uart_port *port)
 
 static void ulite_start_tx(struct uart_port *port)
 {
-        ulite_transmit(port, ioread32be(port->membase + ULITE_STATUS));
+        ulite_transmit(port, uart_in32(ULITE_STATUS, port));
 }
 
 static void ulite_stop_rx(struct uart_port *port)
@@ -220,17 +268,17 @@ static int ulite_startup(struct uart_port *port)
         if (ret)
                 return ret;
 
-        iowrite32be(ULITE_CONTROL_RST_RX | ULITE_CONTROL_RST_TX,
-               port->membase + ULITE_CONTROL);
-        iowrite32be(ULITE_CONTROL_IE, port->membase + ULITE_CONTROL);
+        uart_out32(ULITE_CONTROL_RST_RX | ULITE_CONTROL_RST_TX,
+                ULITE_CONTROL, port);
+        uart_out32(ULITE_CONTROL_IE, ULITE_CONTROL, port);
 
         return 0;
 }
 
 static void ulite_shutdown(struct uart_port *port)
 {
-        iowrite32be(0, port->membase + ULITE_CONTROL);
-        ioread32be(port->membase + ULITE_CONTROL); /* dummy */
+        uart_out32(0, ULITE_CONTROL, port);
+        uart_in32(ULITE_CONTROL, port); /* dummy */
         free_irq(port->irq, port);
 }
 
@@ -281,6 +329,8 @@ static void ulite_release_port(struct uart_port *port)
 
 static int ulite_request_port(struct uart_port *port)
 {
+        int ret;
+
         pr_debug("ulite console: port=%p; port->mapbase=%llx\n",
                  port, (unsigned long long) port->mapbase);
 
@@ -296,6 +346,14 @@ static int ulite_request_port(struct uart_port *port)
                 return -EBUSY;
         }
 
+        port->private_data = &uartlite_be;
+        ret = uart_in32(ULITE_CONTROL, port);
+        uart_out32(ULITE_CONTROL_RST_TX, ULITE_CONTROL, port);
+        ret = uart_in32(ULITE_STATUS, port);
+        /* Endianess detection */
+        if ((ret & ULITE_STATUS_TXEMPTY) != ULITE_STATUS_TXEMPTY)
+                port->private_data = &uartlite_le;
+
         return 0;
 }
 
@@ -314,20 +372,19 @@ static int ulite_verify_port(struct uart_port *port, struct serial_struct *ser)
 #ifdef CONFIG_CONSOLE_POLL
 static int ulite_get_poll_char(struct uart_port *port)
 {
-        if (!(ioread32be(port->membase + ULITE_STATUS)
-                                                & ULITE_STATUS_RXVALID))
+        if (!(uart_in32(ULITE_STATUS, port) & ULITE_STATUS_RXVALID))
                 return NO_POLL_CHAR;
 
-        return ioread32be(port->membase + ULITE_RX);
+        return uart_in32(ULITE_RX, port);
 }
 
 static void ulite_put_poll_char(struct uart_port *port, unsigned char ch)
 {
-        while (ioread32be(port->membase + ULITE_STATUS) & ULITE_STATUS_TXFULL)
+        while (uart_in32(ULITE_STATUS, port) & ULITE_STATUS_TXFULL)
                 cpu_relax();
 
         /* write char to device */
-        iowrite32be(ch, port->membase + ULITE_TX);
+        uart_out32(ch, ULITE_TX, port);
 }
 #endif
 
@@ -366,7 +423,7 @@ static void ulite_console_wait_tx(struct uart_port *port)
 
         /* Spin waiting for TX fifo to have space available */
         for (i = 0; i < 100000; i++) {
-                val = ioread32be(port->membase + ULITE_STATUS);
+                val = uart_in32(ULITE_STATUS, port);
                 if ((val & ULITE_STATUS_TXFULL) == 0)
                         break;
                 cpu_relax();
@@ -376,7 +433,7 @@ static void ulite_console_wait_tx(struct uart_port *port)
 static void ulite_console_putchar(struct uart_port *port, int ch)
 {
         ulite_console_wait_tx(port);
-        iowrite32be(ch, port->membase + ULITE_TX);
+        uart_out32(ch, ULITE_TX, port);
 }
 
 static void ulite_console_write(struct console *co, const char *s,
@@ -393,8 +450,8 @@ static void ulite_console_write(struct console *co, const char *s,
                 spin_lock_irqsave(&port->lock, flags);
 
         /* save and disable interrupt */
-        ier = ioread32be(port->membase + ULITE_STATUS) & ULITE_STATUS_IE;
-        iowrite32be(0, port->membase + ULITE_CONTROL);
+        ier = uart_in32(ULITE_STATUS, port) & ULITE_STATUS_IE;
+        uart_out32(0, ULITE_CONTROL, port);
 
         uart_console_write(port, s, count, ulite_console_putchar);
 
@@ -402,7 +459,7 @@ static void ulite_console_write(struct console *co, const char *s,
 
         /* restore interrupt state */
         if (ier)
-                iowrite32be(ULITE_CONTROL_IE, port->membase + ULITE_CONTROL);
+                uart_out32(ULITE_CONTROL_IE, ULITE_CONTROL, port);
 
         if (locked)
                 spin_unlock_irqrestore(&port->lock, flags);
@@ -615,7 +672,7 @@ static struct platform_driver ulite_platform_driver = {
  * Module setup/teardown
  */
 
-int __init ulite_init(void)
+static int __init ulite_init(void)
 {
         int ret;
 
@@ -634,11 +691,11 @@ int __init ulite_init(void)
 err_plat:
         uart_unregister_driver(&ulite_uart_driver);
 err_uart:
-        printk(KERN_ERR "registering uartlite driver failed: err=%i", ret);
+        pr_err("registering uartlite driver failed: err=%i", ret);
         return ret;
 }
 
-void __exit ulite_exit(void)
+static void __exit ulite_exit(void)
 {
         platform_driver_unregister(&ulite_platform_driver);
         uart_unregister_driver(&ulite_uart_driver);
diff --git a/drivers/tty/serial/ucc_uart.c b/drivers/tty/serial/ucc_uart.c
index f99b0c965f85..7355303dad99 100644
--- a/drivers/tty/serial/ucc_uart.c
+++ b/drivers/tty/serial/ucc_uart.c
@@ -469,7 +469,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->state->port.tty;
+        struct tty_port *tport = &port->state->port;
         struct qe_bd *bdp;
         u16 status;
         unsigned int flg;
@@ -491,7 +491,7 @@ static void qe_uart_int_rx(struct uart_qe_port *qe_port)
                 /* If we don't have enough room in RX buffer for the entire BD,
                  * then we try later, which will be the next RX interrupt.
                  */
-                if (tty_buffer_request_room(tty, i) < i) {
+                if (tty_buffer_request_room(tport, i) < i) {
                         dev_dbg(port->dev, "ucc-uart: no room in RX buffer\n");
                         return;
                 }
@@ -512,7 +512,7 @@ static void qe_uart_int_rx(struct uart_qe_port *qe_port)
                                 continue;
 
 error_return:
-                        tty_insert_flip_char(tty, ch, flg);
+                        tty_insert_flip_char(tport, ch, flg);
 
                 }
 
@@ -530,7 +530,7 @@ error_return:
         qe_port->rx_cur = bdp;
 
         /* Activate BH processing */
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(tport);
 
         return;
 
@@ -560,7 +560,7 @@ handle_error:
 
         /* Overrun does not affect the current character ! */
         if (status & BD_SC_OV)
-                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                tty_insert_flip_char(tport, 0, TTY_OVERRUN);
 #ifdef SUPPORT_SYSRQ
         port->sysrq = 0;
 #endif
diff --git a/drivers/tty/serial/vr41xx_siu.c b/drivers/tty/serial/vr41xx_siu.c
index 62ee0166bc65..f655997f44af 100644
--- a/drivers/tty/serial/vr41xx_siu.c
+++ b/drivers/tty/serial/vr41xx_siu.c
@@ -313,12 +313,10 @@ static void siu_break_ctl(struct uart_port *port, int ctl)
 
 static inline void receive_chars(struct uart_port *port, uint8_t *status)
 {
-        struct tty_struct *tty;
         uint8_t lsr, ch;
         char flag;
         int max_count = RX_MAX_COUNT;
 
-        tty = port->state->port.tty;
         lsr = *status;
 
         do {
@@ -365,7 +363,7 @@ static inline void receive_chars(struct uart_port *port, uint8_t *status)
                 lsr = siu_read(port, UART_LSR);
         } while ((lsr & UART_LSR_DR) && (max_count-- > 0));
 
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&port->state->port);
 
         *status = lsr;
 }
diff --git a/drivers/tty/serial/vt8500_serial.c b/drivers/tty/serial/vt8500_serial.c
index d5ed9f613005..a3f9dd5c9dff 100644
--- a/drivers/tty/serial/vt8500_serial.c
+++ b/drivers/tty/serial/vt8500_serial.c
@@ -136,22 +136,14 @@ static void vt8500_enable_ms(struct uart_port *port)
 
 static void handle_rx(struct uart_port *port)
 {
-        struct tty_struct *tty = tty_port_tty_get(&port->state->port);
-        if (!tty) {
-                /* Discard data: no tty available */
-                int count = (vt8500_read(port, VT8500_URFIDX) & 0x1f00) >> 8;
-                u16 ch;
-                while (count--)
-                        ch = readw(port->membase + VT8500_RXFIFO);
-                return;
-        }
+        struct tty_port *tport = &port->state->port;
 
         /*
          * Handle overrun
          */
         if ((vt8500_read(port, VT8500_URISR) & RXOVER)) {
                 port->icount.overrun++;
-                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                tty_insert_flip_char(tport, 0, TTY_OVERRUN);
         }
 
         /* and now the main RX loop */
@@ -174,11 +166,10 @@ static void handle_rx(struct uart_port *port)
                 port->icount.rx++;
 
                 if (!uart_handle_sysrq_char(port, c))
-                        tty_insert_flip_char(tty, c, flag);
+                        tty_insert_flip_char(tport, c, flag);
         }
 
-        tty_flip_buffer_push(tty);
-        tty_kref_put(tty);
+        tty_flip_buffer_push(tport);
 }
 
 static void handle_tx(struct uart_port *port)
@@ -569,7 +560,7 @@ static int vt8500_serial_probe(struct platform_device *pdev)
 
         if (np)
                 port = of_alias_get_id(np, "serial");
-                if (port > VT8500_MAX_PORTS)
+                if (port >= VT8500_MAX_PORTS)
                         port = -1;
         else
                 port = -1;
@@ -580,7 +571,7 @@ static int vt8500_serial_probe(struct platform_device *pdev)
                                         sizeof(vt8500_ports_in_use));
         }
 
-        if (port > VT8500_MAX_PORTS)
+        if (port >= VT8500_MAX_PORTS)
                 return -ENODEV;
 
         /* reserve the port id */
@@ -589,10 +580,27 @@ static int vt8500_serial_probe(struct platform_device *pdev)
                 return -EBUSY;
         }
 
-        vt8500_port = kzalloc(sizeof(struct vt8500_port), GFP_KERNEL);
+        vt8500_port = devm_kzalloc(&pdev->dev, sizeof(struct vt8500_port),
+                                   GFP_KERNEL);
         if (!vt8500_port)
                 return -ENOMEM;
 
+        vt8500_port->uart.membase = devm_request_and_ioremap(&pdev->dev, mmres);
+        if (!vt8500_port->uart.membase)
+                return -EADDRNOTAVAIL;
+
+        vt8500_port->clk = of_clk_get(pdev->dev.of_node, 0);
+        if (IS_ERR(vt8500_port->clk)) {
+                dev_err(&pdev->dev, "failed to get clock\n");
+                return  -EINVAL;
+        }
+
+        ret = clk_prepare_enable(vt8500_port->clk);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to enable clock\n");
+                return ret;
+        }
+
         vt8500_port->uart.type = PORT_VT8500;
         vt8500_port->uart.iotype = UPIO_MEM;
         vt8500_port->uart.mapbase = mmres->start;
@@ -615,12 +623,6 @@ static int vt8500_serial_probe(struct platform_device *pdev)
         snprintf(vt8500_port->name, sizeof(vt8500_port->name),
                  "VT8500 UART%d", pdev->id);
 
-        vt8500_port->uart.membase = ioremap(mmres->start, resource_size(mmres));
-        if (!vt8500_port->uart.membase) {
-                ret = -ENOMEM;
-                goto err;
-        }
-
         vt8500_uart_ports[port] = vt8500_port;
 
         uart_add_one_port(&vt8500_uart_driver, &vt8500_port->uart);
@@ -628,10 +630,6 @@ static int vt8500_serial_probe(struct platform_device *pdev)
         platform_set_drvdata(pdev, vt8500_port);
 
         return 0;
-
-err:
-        kfree(vt8500_port);
-        return ret;
 }
 
 static int vt8500_serial_remove(struct platform_device *pdev)
@@ -639,8 +637,8 @@ static int vt8500_serial_remove(struct platform_device *pdev)
         struct vt8500_port *vt8500_port = platform_get_drvdata(pdev);
 
         platform_set_drvdata(pdev, NULL);
+        clk_disable_unprepare(vt8500_port->clk);
         uart_remove_one_port(&vt8500_uart_driver, &vt8500_port->uart);
-        kfree(vt8500_port);
 
         return 0;
 }
diff --git a/drivers/tty/serial/xilinx_uartps.c b/drivers/tty/serial/xilinx_uartps.c
index 9ab910370c56..ba451c7209fc 100644
--- a/drivers/tty/serial/xilinx_uartps.c
+++ b/drivers/tty/serial/xilinx_uartps.c
@@ -17,6 +17,7 @@
 #include <linux/tty.h>
 #include <linux/tty_flip.h>
 #include <linux/console.h>
+#include <linux/clk.h>
 #include <linux/irq.h>
 #include <linux/io.h>
 #include <linux/of.h>
@@ -147,15 +148,11 @@
 static irqreturn_t xuartps_isr(int irq, void *dev_id)
 {
         struct uart_port *port = (struct uart_port *)dev_id;
-        struct tty_struct *tty;
         unsigned long flags;
         unsigned int isrstatus, numbytes;
         unsigned int data;
         char status = TTY_NORMAL;
 
-        /* Get the tty which could be NULL so don't assume it's valid */
-        tty = tty_port_tty_get(&port->state->port);
-
         spin_lock_irqsave(&port->lock, flags);
 
         /* Read the interrupt status register to determine which
@@ -187,14 +184,11 @@ static irqreturn_t xuartps_isr(int irq, void *dev_id)
                         } else if (isrstatus & XUARTPS_IXR_OVERRUN)
                                 port->icount.overrun++;
 
-                        if (tty)
-                                uart_insert_char(port, isrstatus,
-                                                XUARTPS_IXR_OVERRUN, data,
-                                                status);
+                        uart_insert_char(port, isrstatus, XUARTPS_IXR_OVERRUN,
+                                        data, status);
                 }
                 spin_unlock(&port->lock);
-                if (tty)
-                        tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(&port->state->port);
                 spin_lock(&port->lock);
         }
 
@@ -237,7 +231,6 @@ static irqreturn_t xuartps_isr(int irq, void *dev_id)
 
         /* be sure to release the lock and tty before leaving */
         spin_unlock_irqrestore(&port->lock, flags);
-        tty_kref_put(tty);
 
         return IRQ_HANDLED;
 }
@@ -944,16 +937,18 @@ static int xuartps_probe(struct platform_device *pdev)
         int rc;
         struct uart_port *port;
         struct resource *res, *res2;
-        int clk = 0;
-
-        const unsigned int *prop;
+        struct clk *clk;
 
-        prop = of_get_property(pdev->dev.of_node, "clock", NULL);
-        if (prop)
-                clk = be32_to_cpup(prop);
-        if (!clk) {
+        clk = of_clk_get(pdev->dev.of_node, 0);
+        if (IS_ERR(clk)) {
                 dev_err(&pdev->dev, "no clock specified\n");
-                return -ENODEV;
+                return PTR_ERR(clk);
+        }
+
+        rc = clk_prepare_enable(clk);
+        if (rc) {
+                dev_err(&pdev->dev, "could not enable clock\n");
+                return -EBUSY;
         }
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -978,7 +973,8 @@ static int xuartps_probe(struct platform_device *pdev)
                 port->mapbase = res->start;
                 port->irq = res2->start;
                 port->dev = &pdev->dev;
-                port->uartclk = clk;
+                port->uartclk = clk_get_rate(clk);
+                port->private_data = clk;
                 dev_set_drvdata(&pdev->dev, port);
                 rc = uart_add_one_port(&xuartps_uart_driver, port);
                 if (rc) {
@@ -1000,14 +996,14 @@ static int xuartps_probe(struct platform_device *pdev)
 static int xuartps_remove(struct platform_device *pdev)
 {
         struct uart_port *port = dev_get_drvdata(&pdev->dev);
-        int rc = 0;
+        struct clk *clk = port->private_data;
+        int rc;
 
         /* Remove the xuartps port from the serial core */
-        if (port) {
-                rc = uart_remove_one_port(&xuartps_uart_driver, port);
-                dev_set_drvdata(&pdev->dev, NULL);
-                port->mapbase = 0;
-        }
+        rc = uart_remove_one_port(&xuartps_uart_driver, port);
+        dev_set_drvdata(&pdev->dev, NULL);
+        port->mapbase = 0;
+        clk_disable_unprepare(clk);
         return rc;
 }
 
@@ -1048,7 +1044,7 @@ MODULE_DEVICE_TABLE(of, xuartps_of_match);
 
 static struct platform_driver xuartps_platform_driver = {
         .probe   = xuartps_probe,               /* Probe method */
-        .remove  = __exit_p(xuartps_remove),    /* Detach method */
+        .remove  = xuartps_remove,              /* Detach method */
         .suspend = xuartps_suspend,             /* Suspend */
         .resume  = xuartps_resume,              /* Resume after a suspend */
         .driver  = {
diff --git a/drivers/tty/serial/zs.c b/drivers/tty/serial/zs.c
index 92c00b24d0df..6a169877109b 100644
--- a/drivers/tty/serial/zs.c
+++ b/drivers/tty/serial/zs.c
@@ -603,7 +603,7 @@ static void zs_receive_chars(struct zs_port *zport)
                 uart_insert_char(uport, status, Rx_OVR, ch, flag);
         }
 
-        tty_flip_buffer_push(uport->state->port.tty);
+        tty_flip_buffer_push(&uport->state->port);
 }
 
 static void zs_raw_transmit_chars(struct zs_port *zport)
diff --git a/drivers/tty/synclink.c b/drivers/tty/synclink.c
index 9e071f6985f6..8983276aa35e 100644
--- a/drivers/tty/synclink.c
+++ b/drivers/tty/synclink.c
@@ -291,8 +291,7 @@ struct mgsl_struct {
         bool lcr_mem_requested;
 
         u32 misc_ctrl_value;
-        char flag_buf[MAX_ASYNC_BUFFER_SIZE];
-        char char_buf[MAX_ASYNC_BUFFER_SIZE];   
+        char *flag_buf;
         bool drop_rts_on_tx_done;
 
         bool loopmode_insert_requested;
@@ -1440,7 +1439,6 @@ static void mgsl_isr_receive_data( struct mgsl_struct *info )
         u16 status;
         int work = 0;
         unsigned char DataByte;
-        struct tty_struct *tty = info->port.tty;
         struct  mgsl_icount *icount = &info->icount;
         
         if ( debug_level >= DEBUG_LEVEL_ISR )   
@@ -1502,19 +1500,19 @@ static void mgsl_isr_receive_data( struct mgsl_struct *info )
                         if (status & RXSTATUS_BREAK_RECEIVED) {
                                 flag = TTY_BREAK;
                                 if (info->port.flags & ASYNC_SAK)
-                                        do_SAK(tty);
+                                        do_SAK(info->port.tty);
                         } else if (status & RXSTATUS_PARITY_ERROR)
                                 flag = TTY_PARITY;
                         else if (status & RXSTATUS_FRAMING_ERROR)
                                 flag = TTY_FRAME;
                 }       /* end of if (error) */
-                tty_insert_flip_char(tty, DataByte, flag);
+                tty_insert_flip_char(&info->port, DataByte, flag);
                 if (status & RXSTATUS_OVERRUN) {
                         /* Overrun is special, since it's
                          * reported immediately, and doesn't
                          * affect the current character
                          */
-                        work += tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                        work += tty_insert_flip_char(&info->port, 0, TTY_OVERRUN);
                 }
         }
 
@@ -1525,7 +1523,7 @@ static void mgsl_isr_receive_data( struct mgsl_struct *info )
         }
                         
         if(work)
-                tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(&info->port);
 }
 
 /* mgsl_isr_misc()
@@ -1852,7 +1850,7 @@ static void shutdown(struct mgsl_struct * info)
         usc_OutReg(info, PCR, (u16)((usc_InReg(info, PCR) | BIT13) | BIT12));
 
         if (!info->port.tty || info->port.tty->termios.c_cflag & HUPCL) {
-                info->serial_signals &= ~(SerialSignal_DTR + SerialSignal_RTS);
+                info->serial_signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
                 usc_set_serial_signals(info);
         }
 
@@ -1917,12 +1915,12 @@ static void mgsl_change_params(struct mgsl_struct *info)
                          
         cflag = info->port.tty->termios.c_cflag;
 
-        /* if B0 rate (hangup) specified then negate DTR and RTS */
-        /* otherwise assert DTR and RTS */
+        /* if B0 rate (hangup) specified then negate RTS and DTR */
+        /* otherwise assert RTS and DTR */
         if (cflag & CBAUD)
-                info->serial_signals |= SerialSignal_RTS + SerialSignal_DTR;
+                info->serial_signals |= SerialSignal_RTS | SerialSignal_DTR;
         else
-                info->serial_signals &= ~(SerialSignal_RTS + SerialSignal_DTR);
+                info->serial_signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
         
         /* byte size and parity */
         
@@ -3046,7 +3044,7 @@ static void mgsl_set_termios(struct tty_struct *tty, struct ktermios *old_termio
         /* Handle transition to B0 status */
         if (old_termios->c_cflag & CBAUD &&
             !(tty->termios.c_cflag & CBAUD)) {
-                info->serial_signals &= ~(SerialSignal_RTS + SerialSignal_DTR);
+                info->serial_signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
                 spin_lock_irqsave(&info->irq_spinlock,flags);
                 usc_set_serial_signals(info);
                 spin_unlock_irqrestore(&info->irq_spinlock,flags);
@@ -3245,9 +3243,9 @@ static void dtr_rts(struct tty_port *port, int on)
 
         spin_lock_irqsave(&info->irq_spinlock,flags);
         if (on)
-                info->serial_signals |= SerialSignal_RTS + SerialSignal_DTR;
+                info->serial_signals |= SerialSignal_RTS | SerialSignal_DTR;
         else
-                info->serial_signals &= ~(SerialSignal_RTS + SerialSignal_DTR);
+                info->serial_signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
         usc_set_serial_signals(info);
         spin_unlock_irqrestore(&info->irq_spinlock,flags);
 }
@@ -3416,7 +3414,7 @@ static int mgsl_open(struct tty_struct *tty, struct file * filp)
                 goto cleanup;
         }
         
-        info->port.tty->low_latency = (info->port.flags & ASYNC_LOW_LATENCY) ? 1 : 0;
+        info->port.low_latency = (info->port.flags & ASYNC_LOW_LATENCY) ? 1 : 0;
 
         spin_lock_irqsave(&info->netlock, flags);
         if (info->netcount) {
@@ -3898,7 +3896,13 @@ static int mgsl_alloc_intermediate_rxbuffer_memory(struct mgsl_struct *info)
         info->intermediate_rxbuffer = kmalloc(info->max_frame_size, GFP_KERNEL | GFP_DMA);
         if ( info->intermediate_rxbuffer == NULL )
                 return -ENOMEM;
-
+        /* unused flag buffer to satisfy receive_buf calling interface */
+        info->flag_buf = kzalloc(info->max_frame_size, GFP_KERNEL);
+        if (!info->flag_buf) {
+                kfree(info->intermediate_rxbuffer);
+                info->intermediate_rxbuffer = NULL;
+                return -ENOMEM;
+        }
         return 0;
 
 }       /* end of mgsl_alloc_intermediate_rxbuffer_memory() */
@@ -3917,6 +3921,8 @@ static void mgsl_free_intermediate_rxbuffer_memory(struct mgsl_struct *info)
 {
         kfree(info->intermediate_rxbuffer);
         info->intermediate_rxbuffer = NULL;
+        kfree(info->flag_buf);
+        info->flag_buf = NULL;
 
 }       /* end of mgsl_free_intermediate_rxbuffer_memory() */
 
@@ -6233,8 +6239,8 @@ static void usc_get_serial_signals( struct mgsl_struct *info )
 {
         u16 status;
 
-        /* clear all serial signals except DTR and RTS */
-        info->serial_signals &= SerialSignal_DTR + SerialSignal_RTS;
+        /* clear all serial signals except RTS and DTR */
+        info->serial_signals &= SerialSignal_RTS | SerialSignal_DTR;
 
         /* Read the Misc Interrupt status Register (MISR) to get */
         /* the V24 status signals. */
@@ -6259,7 +6265,7 @@ static void usc_get_serial_signals( struct mgsl_struct *info )
 
 /* usc_set_serial_signals()
  *
- *      Set the state of DTR and RTS based on contents of
+ *      Set the state of RTS and DTR based on contents of
  *      serial_signals member of device extension.
  *      
  * Arguments:           info    pointer to device instance data
@@ -7773,8 +7779,8 @@ static int hdlcdev_open(struct net_device *dev)
                 return rc;
         }
 
-        /* assert DTR and RTS, apply hardware settings */
-        info->serial_signals |= SerialSignal_RTS + SerialSignal_DTR;
+        /* assert RTS and DTR, apply hardware settings */
+        info->serial_signals |= SerialSignal_RTS | SerialSignal_DTR;
         mgsl_program_hw(info);
 
         /* enable network layer transmit */
diff --git a/drivers/tty/synclink_gt.c b/drivers/tty/synclink_gt.c
index aba1e59f4a88..aa9eece35c3b 100644
--- a/drivers/tty/synclink_gt.c
+++ b/drivers/tty/synclink_gt.c
@@ -317,8 +317,7 @@ struct slgt_info {
         unsigned char *tx_buf;
         int tx_count;
 
-        char flag_buf[MAX_ASYNC_BUFFER_SIZE];
-        char char_buf[MAX_ASYNC_BUFFER_SIZE];
+        char *flag_buf;
         bool drop_rts_on_tx_done;
         struct  _input_signal_events    input_signal_events;
 
@@ -683,7 +682,7 @@ static int open(struct tty_struct *tty, struct file *filp)
         }
 
         mutex_lock(&info->port.mutex);
-        info->port.tty->low_latency = (info->port.flags & ASYNC_LOW_LATENCY) ? 1 : 0;
+        info->port.low_latency = (info->port.flags & ASYNC_LOW_LATENCY) ? 1 : 0;
 
         spin_lock_irqsave(&info->netlock, flags);
         if (info->netcount) {
@@ -786,7 +785,7 @@ static void set_termios(struct tty_struct *tty, struct ktermios *old_termios)
         /* Handle transition to B0 status */
         if (old_termios->c_cflag & CBAUD &&
             !(tty->termios.c_cflag & CBAUD)) {
-                info->signals &= ~(SerialSignal_RTS + SerialSignal_DTR);
+                info->signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
                 spin_lock_irqsave(&info->lock,flags);
                 set_signals(info);
                 spin_unlock_irqrestore(&info->lock,flags);
@@ -1561,8 +1560,8 @@ static int hdlcdev_open(struct net_device *dev)
                 return rc;
         }
 
-        /* assert DTR and RTS, apply hardware settings */
-        info->signals |= SerialSignal_RTS + SerialSignal_DTR;
+        /* assert RTS and DTR, apply hardware settings */
+        info->signals |= SerialSignal_RTS | SerialSignal_DTR;
         program_hw(info);
 
         /* enable network layer transmit */
@@ -1855,7 +1854,6 @@ static void hdlcdev_exit(struct slgt_info *info)
  */
 static void rx_async(struct slgt_info *info)
 {
-        struct tty_struct *tty = info->port.tty;
         struct mgsl_icount *icount = &info->icount;
         unsigned int start, end;
         unsigned char *p;
@@ -1894,10 +1892,8 @@ static void rx_async(struct slgt_info *info)
                                 else if (status & BIT0)
                                         stat = TTY_FRAME;
                         }
-                        if (tty) {
-                                tty_insert_flip_char(tty, ch, stat);
-                                chars++;
-                        }
+                        tty_insert_flip_char(&info->port, ch, stat);
+                        chars++;
                 }
 
                 if (i < count) {
@@ -1918,8 +1914,8 @@ static void rx_async(struct slgt_info *info)
                         break;
         }
 
-        if (tty && chars)
-                tty_flip_buffer_push(tty);
+        if (chars)
+                tty_flip_buffer_push(&info->port);
 }
 
 /*
@@ -1961,8 +1957,6 @@ static void bh_handler(struct work_struct *work)
         struct slgt_info *info = container_of(work, struct slgt_info, task);
         int action;
 
-        if (!info)
-                return;
         info->bh_running = true;
 
         while((action = bh_action(info))) {
@@ -2183,7 +2177,7 @@ static void isr_serial(struct slgt_info *info)
                         if (info->port.tty) {
                                 if (!(status & info->ignore_status_mask)) {
                                         if (info->read_status_mask & MASK_BREAK) {
-                                                tty_insert_flip_char(info->port.tty, 0, TTY_BREAK);
+                                                tty_insert_flip_char(&info->port, 0, TTY_BREAK);
                                                 if (info->port.flags & ASYNC_SAK)
                                                         do_SAK(info->port.tty);
                                         }
@@ -2494,7 +2488,7 @@ static void shutdown(struct slgt_info *info)
         slgt_irq_off(info, IRQ_ALL | IRQ_MASTER);
 
         if (!info->port.tty || info->port.tty->termios.c_cflag & HUPCL) {
-                info->signals &= ~(SerialSignal_DTR + SerialSignal_RTS);
+                info->signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
                 set_signals(info);
         }
 
@@ -2554,12 +2548,12 @@ static void change_params(struct slgt_info *info)
 
         cflag = info->port.tty->termios.c_cflag;
 
-        /* if B0 rate (hangup) specified then negate DTR and RTS */
-        /* otherwise assert DTR and RTS */
+        /* if B0 rate (hangup) specified then negate RTS and DTR */
+        /* otherwise assert RTS and DTR */
         if (cflag & CBAUD)
-                info->signals |= SerialSignal_RTS + SerialSignal_DTR;
+                info->signals |= SerialSignal_RTS | SerialSignal_DTR;
         else
-                info->signals &= ~(SerialSignal_RTS + SerialSignal_DTR);
+                info->signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
 
         /* byte size and parity */
 
@@ -3262,9 +3256,9 @@ static void dtr_rts(struct tty_port *port, int on)
 
         spin_lock_irqsave(&info->lock,flags);
         if (on)
-                info->signals |= SerialSignal_RTS + SerialSignal_DTR;
+                info->signals |= SerialSignal_RTS | SerialSignal_DTR;
         else
-                info->signals &= ~(SerialSignal_RTS + SerialSignal_DTR);
+                info->signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
         set_signals(info);
         spin_unlock_irqrestore(&info->lock,flags);
 }
@@ -3355,11 +3349,24 @@ static int block_til_ready(struct tty_struct *tty, struct file *filp,
         return retval;
 }
 
+/*
+ * allocate buffers used for calling line discipline receive_buf
+ * directly in synchronous mode
+ * note: add 5 bytes to max frame size to allow appending
+ * 32-bit CRC and status byte when configured to do so
+ */
 static int alloc_tmp_rbuf(struct slgt_info *info)
 {
         info->tmp_rbuf = kmalloc(info->max_frame_size + 5, GFP_KERNEL);
         if (info->tmp_rbuf == NULL)
                 return -ENOMEM;
+        /* unused flag buffer to satisfy receive_buf calling interface */
+        info->flag_buf = kzalloc(info->max_frame_size + 5, GFP_KERNEL);
+        if (!info->flag_buf) {
+                kfree(info->tmp_rbuf);
+                info->tmp_rbuf = NULL;
+                return -ENOMEM;
+        }
         return 0;
 }
 
@@ -3367,6 +3374,8 @@ static void free_tmp_rbuf(struct slgt_info *info)
 {
         kfree(info->tmp_rbuf);
         info->tmp_rbuf = NULL;
+        kfree(info->flag_buf);
+        info->flag_buf = NULL;
 }
 
 /*
@@ -4110,7 +4119,7 @@ static void reset_port(struct slgt_info *info)
         tx_stop(info);
         rx_stop(info);
 
-        info->signals &= ~(SerialSignal_DTR + SerialSignal_RTS);
+        info->signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
         set_signals(info);
 
         slgt_irq_off(info, IRQ_ALL | IRQ_MASTER);
@@ -4537,8 +4546,8 @@ static void get_signals(struct slgt_info *info)
 {
         unsigned short status = rd_reg16(info, SSR);
 
-        /* clear all serial signals except DTR and RTS */
-        info->signals &= SerialSignal_DTR + SerialSignal_RTS;
+        /* clear all serial signals except RTS and DTR */
+        info->signals &= SerialSignal_RTS | SerialSignal_DTR;
 
         if (status & BIT3)
                 info->signals |= SerialSignal_DSR;
diff --git a/drivers/tty/synclinkmp.c b/drivers/tty/synclinkmp.c
index fd43fb6f7cee..6d5780cf1d57 100644
--- a/drivers/tty/synclinkmp.c
+++ b/drivers/tty/synclinkmp.c
@@ -262,8 +262,7 @@ typedef struct _synclinkmp_info {
         bool sca_statctrl_requested;
 
         u32 misc_ctrl_value;
-        char flag_buf[MAX_ASYNC_BUFFER_SIZE];
-        char char_buf[MAX_ASYNC_BUFFER_SIZE];
+        char *flag_buf;
         bool drop_rts_on_tx_done;
 
         struct  _input_signal_events    input_signal_events;
@@ -762,7 +761,7 @@ static int open(struct tty_struct *tty, struct file *filp)
                 goto cleanup;
         }
 
-        info->port.tty->low_latency = (info->port.flags & ASYNC_LOW_LATENCY) ? 1 : 0;
+        info->port.low_latency = (info->port.flags & ASYNC_LOW_LATENCY) ? 1 : 0;
 
         spin_lock_irqsave(&info->netlock, flags);
         if (info->netcount) {
@@ -883,7 +882,7 @@ static void set_termios(struct tty_struct *tty, struct ktermios *old_termios)
         /* Handle transition to B0 status */
         if (old_termios->c_cflag & CBAUD &&
             !(tty->termios.c_cflag & CBAUD)) {
-                info->serial_signals &= ~(SerialSignal_RTS + SerialSignal_DTR);
+                info->serial_signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
                 spin_lock_irqsave(&info->lock,flags);
                 set_signals(info);
                 spin_unlock_irqrestore(&info->lock,flags);
@@ -1677,8 +1676,8 @@ static int hdlcdev_open(struct net_device *dev)
                 return rc;
         }
 
-        /* assert DTR and RTS, apply hardware settings */
-        info->serial_signals |= SerialSignal_RTS + SerialSignal_DTR;
+        /* assert RTS and DTR, apply hardware settings */
+        info->serial_signals |= SerialSignal_RTS | SerialSignal_DTR;
         program_hw(info);
 
         /* enable network layer transmit */
@@ -2008,9 +2007,6 @@ static void bh_handler(struct work_struct *work)
         SLMP_INFO *info = container_of(work, SLMP_INFO, task);
         int action;
 
-        if (!info)
-                return;
-
         if ( debug_level >= DEBUG_LEVEL_BH )
                 printk( "%s(%d):%s bh_handler() entry\n",
                         __FILE__,__LINE__,info->device_name);
@@ -2132,13 +2128,11 @@ static void isr_rxint(SLMP_INFO * info)
                         /* process break detection if tty control
                          * is not set to ignore it
                          */
-                        if ( tty ) {
-                                if (!(status & info->ignore_status_mask1)) {
-                                        if (info->read_status_mask1 & BRKD) {
-                                                tty_insert_flip_char(tty, 0, TTY_BREAK);
-                                                if (info->port.flags & ASYNC_SAK)
-                                                        do_SAK(tty);
-                                        }
+                        if (!(status & info->ignore_status_mask1)) {
+                                if (info->read_status_mask1 & BRKD) {
+                                        tty_insert_flip_char(&info->port, 0, TTY_BREAK);
+                                        if (tty && (info->port.flags & ASYNC_SAK))
+                                                do_SAK(tty);
                                 }
                         }
                 }
@@ -2170,7 +2164,6 @@ static void isr_rxrdy(SLMP_INFO * info)
 {
         u16 status;
         unsigned char DataByte;
-        struct tty_struct *tty = info->port.tty;
         struct  mgsl_icount *icount = &info->icount;
 
         if ( debug_level >= DEBUG_LEVEL_ISR )
@@ -2203,26 +2196,22 @@ static void isr_rxrdy(SLMP_INFO * info)
 
                         status &= info->read_status_mask2;
 
-                        if ( tty ) {
-                                if (status & PE)
-                                        flag = TTY_PARITY;
-                                else if (status & FRME)
-                                        flag = TTY_FRAME;
-                                if (status & OVRN) {
-                                        /* Overrun is special, since it's
-                                         * reported immediately, and doesn't
-                                         * affect the current character
-                                         */
-                                        over = true;
-                                }
+                        if (status & PE)
+                                flag = TTY_PARITY;
+                        else if (status & FRME)
+                                flag = TTY_FRAME;
+                        if (status & OVRN) {
+                                /* Overrun is special, since it's
+                                 * reported immediately, and doesn't
+                                 * affect the current character
+                                 */
+                                over = true;
                         }
                 }       /* end of if (error) */
 
-                if ( tty ) {
-                        tty_insert_flip_char(tty, DataByte, flag);
-                        if (over)
-                                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
-                }
+                tty_insert_flip_char(&info->port, DataByte, flag);
+                if (over)
+                        tty_insert_flip_char(&info->port, 0, TTY_OVERRUN);
         }
 
         if ( debug_level >= DEBUG_LEVEL_ISR ) {
@@ -2232,8 +2221,7 @@ static void isr_rxrdy(SLMP_INFO * info)
                         icount->frame,icount->overrun);
         }
 
-        if ( tty )
-                tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&info->port);
 }
 
 static void isr_txeom(SLMP_INFO * info, unsigned char status)
@@ -2718,7 +2706,7 @@ static void shutdown(SLMP_INFO * info)
         reset_port(info);
 
         if (!info->port.tty || info->port.tty->termios.c_cflag & HUPCL) {
-                info->serial_signals &= ~(SerialSignal_DTR + SerialSignal_RTS);
+                info->serial_signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
                 set_signals(info);
         }
 
@@ -2780,12 +2768,12 @@ static void change_params(SLMP_INFO *info)
 
         cflag = info->port.tty->termios.c_cflag;
 
-        /* if B0 rate (hangup) specified then negate DTR and RTS */
-        /* otherwise assert DTR and RTS */
+        /* if B0 rate (hangup) specified then negate RTS and DTR */
+        /* otherwise assert RTS and DTR */
         if (cflag & CBAUD)
-                info->serial_signals |= SerialSignal_RTS + SerialSignal_DTR;
+                info->serial_signals |= SerialSignal_RTS | SerialSignal_DTR;
         else
-                info->serial_signals &= ~(SerialSignal_RTS + SerialSignal_DTR);
+                info->serial_signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
 
         /* byte size and parity */
 
@@ -3224,12 +3212,12 @@ static int tiocmget(struct tty_struct *tty)
         get_signals(info);
         spin_unlock_irqrestore(&info->lock,flags);
 
-        result = ((info->serial_signals & SerialSignal_RTS) ? TIOCM_RTS:0) +
-                ((info->serial_signals & SerialSignal_DTR) ? TIOCM_DTR:0) +
-                ((info->serial_signals & SerialSignal_DCD) ? TIOCM_CAR:0) +
-                ((info->serial_signals & SerialSignal_RI)  ? TIOCM_RNG:0) +
-                ((info->serial_signals & SerialSignal_DSR) ? TIOCM_DSR:0) +
-                ((info->serial_signals & SerialSignal_CTS) ? TIOCM_CTS:0);
+        result = ((info->serial_signals & SerialSignal_RTS) ? TIOCM_RTS : 0) |
+                 ((info->serial_signals & SerialSignal_DTR) ? TIOCM_DTR : 0) |
+                 ((info->serial_signals & SerialSignal_DCD) ? TIOCM_CAR : 0) |
+                 ((info->serial_signals & SerialSignal_RI)  ? TIOCM_RNG : 0) |
+                 ((info->serial_signals & SerialSignal_DSR) ? TIOCM_DSR : 0) |
+                 ((info->serial_signals & SerialSignal_CTS) ? TIOCM_CTS : 0);
 
         if (debug_level >= DEBUG_LEVEL_INFO)
                 printk("%s(%d):%s tiocmget() value=%08X\n",
@@ -3284,9 +3272,9 @@ static void dtr_rts(struct tty_port *port, int on)
 
         spin_lock_irqsave(&info->lock,flags);
         if (on)
-                info->serial_signals |= SerialSignal_RTS + SerialSignal_DTR;
+                info->serial_signals |= SerialSignal_RTS | SerialSignal_DTR;
         else
-                info->serial_signals &= ~(SerialSignal_RTS + SerialSignal_DTR);
+                info->serial_signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
         set_signals(info);
         spin_unlock_irqrestore(&info->lock,flags);
 }
@@ -3553,6 +3541,13 @@ static int alloc_tmp_rx_buf(SLMP_INFO *info)
         info->tmp_rx_buf = kmalloc(info->max_frame_size, GFP_KERNEL);
         if (info->tmp_rx_buf == NULL)
                 return -ENOMEM;
+        /* unused flag buffer to satisfy receive_buf calling interface */
+        info->flag_buf = kzalloc(info->max_frame_size, GFP_KERNEL);
+        if (!info->flag_buf) {
+                kfree(info->tmp_rx_buf);
+                info->tmp_rx_buf = NULL;
+                return -ENOMEM;
+        }
         return 0;
 }
 
@@ -3560,6 +3555,8 @@ static void free_tmp_rx_buf(SLMP_INFO *info)
 {
         kfree(info->tmp_rx_buf);
         info->tmp_rx_buf = NULL;
+        kfree(info->flag_buf);
+        info->flag_buf = NULL;
 }
 
 static int claim_resources(SLMP_INFO *info)
@@ -4357,7 +4354,7 @@ static void reset_port(SLMP_INFO *info)
                 tx_stop(info);
                 rx_stop(info);
 
-                info->serial_signals &= ~(SerialSignal_DTR + SerialSignal_RTS);
+                info->serial_signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
                 set_signals(info);
 
                 /* disable all port interrupts */
@@ -4753,8 +4750,8 @@ static void get_signals(SLMP_INFO *info)
         u16 gpstatus = read_status_reg(info);
         u16 testbit;
 
-        /* clear all serial signals except DTR and RTS */
-        info->serial_signals &= SerialSignal_DTR + SerialSignal_RTS;
+        /* clear all serial signals except RTS and DTR */
+        info->serial_signals &= SerialSignal_RTS | SerialSignal_DTR;
 
         /* set serial signal bits to reflect MISR */
 
@@ -4773,7 +4770,7 @@ static void get_signals(SLMP_INFO *info)
                 info->serial_signals |= SerialSignal_DSR;
 }
 
-/* Set the state of DTR and RTS based on contents of
+/* Set the state of RTS and DTR based on contents of
  * serial_signals member of device context.
  */
 static void set_signals(SLMP_INFO *info)
diff --git a/drivers/tty/tty_buffer.c b/drivers/tty/tty_buffer.c
index 45d916198f78..bb119934e76c 100644
--- a/drivers/tty/tty_buffer.c
+++ b/drivers/tty/tty_buffer.c
@@ -16,6 +16,7 @@
 #include <linux/bitops.h>
 #include <linux/delay.h>
 #include <linux/module.h>
+#include <linux/ratelimit.h>
 
 /**
  *      tty_buffer_free_all             -       free buffers used by a tty
@@ -119,11 +120,14 @@ static void __tty_buffer_flush(struct tty_port *port)
         struct tty_bufhead *buf = &port->buf;
         struct tty_buffer *thead;
 
-        while ((thead = buf->head) != NULL) {
-                buf->head = thead->next;
-                tty_buffer_free(port, thead);
+        if (unlikely(buf->head == NULL))
+                return;
+        while ((thead = buf->head->next) != NULL) {
+                tty_buffer_free(port, buf->head);
+                buf->head = thead;
         }
-        buf->tail = NULL;
+        WARN_ON(buf->head != buf->tail);
+        buf->head->read = buf->head->commit;
 }
 
 /**
@@ -194,19 +198,22 @@ static struct tty_buffer *tty_buffer_find(struct tty_port *port, size_t size)
            have queued and recycle that ? */
 }
 /**
- *      __tty_buffer_request_room               -       grow tty buffer if needed
+ *      tty_buffer_request_room         -       grow tty buffer if needed
  *      @tty: tty structure
  *      @size: size desired
  *
  *      Make at least size bytes of linear space available for the tty
  *      buffer. If we fail return the size we managed to find.
- *      Locking: Caller must hold port->buf.lock
+ *
+ *      Locking: Takes port->buf.lock
  */
-static int __tty_buffer_request_room(struct tty_port *port, size_t size)
+int tty_buffer_request_room(struct tty_port *port, size_t size)
 {
         struct tty_bufhead *buf = &port->buf;
         struct tty_buffer *b, *n;
         int left;
+        unsigned long flags;
+        spin_lock_irqsave(&buf->lock, flags);
         /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
            remove this conditional if its worth it. This would be invisible
            to the callers */
@@ -228,37 +235,14 @@ static int __tty_buffer_request_room(struct tty_port *port, size_t size)
                 } else
                         size = left;
         }
-
+        spin_unlock_irqrestore(&buf->lock, flags);
         return size;
 }
-
-
-/**
- *      tty_buffer_request_room         -       grow tty buffer if needed
- *      @tty: tty structure
- *      @size: size desired
- *
- *      Make at least size bytes of linear space available for the tty
- *      buffer. If we fail return the size we managed to find.
- *
- *      Locking: Takes port->buf.lock
- */
-int tty_buffer_request_room(struct tty_struct *tty, size_t size)
-{
-        struct tty_port *port = tty->port;
-        unsigned long flags;
-        int length;
-
-        spin_lock_irqsave(&port->buf.lock, flags);
-        length = __tty_buffer_request_room(port, size);
-        spin_unlock_irqrestore(&port->buf.lock, flags);
-        return length;
-}
 EXPORT_SYMBOL_GPL(tty_buffer_request_room);
 
 /**
  *      tty_insert_flip_string_fixed_flag - Add characters to the tty buffer
- *      @tty: tty structure
+ *      @port: tty port
  *      @chars: characters
  *      @flag: flag value for each character
  *      @size: size
@@ -269,29 +253,21 @@ EXPORT_SYMBOL_GPL(tty_buffer_request_room);
  *      Locking: Called functions may take port->buf.lock
  */
 
-int tty_insert_flip_string_fixed_flag(struct tty_struct *tty,
+int tty_insert_flip_string_fixed_flag(struct tty_port *port,
                 const unsigned char *chars, char flag, size_t size)
 {
-        struct tty_bufhead *buf = &tty->port->buf;
         int copied = 0;
         do {
                 int goal = min_t(size_t, size - copied, TTY_BUFFER_PAGE);
-                int space;
-                unsigned long flags;
-                struct tty_buffer *tb;
-
-                spin_lock_irqsave(&buf->lock, flags);
-                space = __tty_buffer_request_room(tty->port, goal);
-                tb = buf->tail;
+                int space = tty_buffer_request_room(port, goal);
+                struct tty_buffer *tb = port->buf.tail;
                 /* If there is no space then tb may be NULL */
                 if (unlikely(space == 0)) {
-                        spin_unlock_irqrestore(&buf->lock, flags);
                         break;
                 }
                 memcpy(tb->char_buf_ptr + tb->used, chars, space);
                 memset(tb->flag_buf_ptr + tb->used, flag, space);
                 tb->used += space;
-                spin_unlock_irqrestore(&buf->lock, flags);
                 copied += space;
                 chars += space;
                 /* There is a small chance that we need to split the data over
@@ -303,7 +279,7 @@ EXPORT_SYMBOL(tty_insert_flip_string_fixed_flag);
 
 /**
  *      tty_insert_flip_string_flags    -       Add characters to the tty buffer
- *      @tty: tty structure
+ *      @port: tty port
  *      @chars: characters
  *      @flags: flag bytes
  *      @size: size
@@ -315,29 +291,21 @@ EXPORT_SYMBOL(tty_insert_flip_string_fixed_flag);
  *      Locking: Called functions may take port->buf.lock
  */
 
-int tty_insert_flip_string_flags(struct tty_struct *tty,
+int tty_insert_flip_string_flags(struct tty_port *port,
                 const unsigned char *chars, const char *flags, size_t size)
 {
-        struct tty_bufhead *buf = &tty->port->buf;
         int copied = 0;
         do {
                 int goal = min_t(size_t, size - copied, TTY_BUFFER_PAGE);
-                int space;
-                unsigned long __flags;
-                struct tty_buffer *tb;
-
-                spin_lock_irqsave(&buf->lock, __flags);
-                space = __tty_buffer_request_room(tty->port, goal);
-                tb = buf->tail;
+                int space = tty_buffer_request_room(port, goal);
+                struct tty_buffer *tb = port->buf.tail;
                 /* If there is no space then tb may be NULL */
                 if (unlikely(space == 0)) {
-                        spin_unlock_irqrestore(&buf->lock, __flags);
                         break;
                 }
                 memcpy(tb->char_buf_ptr + tb->used, chars, space);
                 memcpy(tb->flag_buf_ptr + tb->used, flags, space);
                 tb->used += space;
-                spin_unlock_irqrestore(&buf->lock, __flags);
                 copied += space;
                 chars += space;
                 flags += space;
@@ -350,7 +318,7 @@ EXPORT_SYMBOL(tty_insert_flip_string_flags);
 
 /**
  *      tty_schedule_flip       -       push characters to ldisc
- *      @tty: tty to push from
+ *      @port: tty port to push from
  *
  *      Takes any pending buffers and transfers their ownership to the
  *      ldisc side of the queue. It then schedules those characters for
@@ -361,11 +329,11 @@ EXPORT_SYMBOL(tty_insert_flip_string_flags);
  *      Locking: Takes port->buf.lock
  */
 
-void tty_schedule_flip(struct tty_struct *tty)
+void tty_schedule_flip(struct tty_port *port)
 {
-        struct tty_bufhead *buf = &tty->port->buf;
+        struct tty_bufhead *buf = &port->buf;
         unsigned long flags;
-        WARN_ON(tty->low_latency);
+        WARN_ON(port->low_latency);
 
         spin_lock_irqsave(&buf->lock, flags);
         if (buf->tail != NULL)
@@ -377,7 +345,7 @@ EXPORT_SYMBOL(tty_schedule_flip);
 
 /**
  *      tty_prepare_flip_string         -       make room for characters
- *      @tty: tty
+ *      @port: tty port
  *      @chars: return pointer for character write area
  *      @size: desired size
  *
@@ -390,31 +358,23 @@ EXPORT_SYMBOL(tty_schedule_flip);
  *      Locking: May call functions taking port->buf.lock
  */
 
-int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars,
+int tty_prepare_flip_string(struct tty_port *port, unsigned char **chars,
                 size_t size)
 {
-        struct tty_bufhead *buf = &tty->port->buf;
-        int space;
-        unsigned long flags;
-        struct tty_buffer *tb;
-
-        spin_lock_irqsave(&buf->lock, flags);
-        space = __tty_buffer_request_room(tty->port, size);
-
-        tb = buf->tail;
+        int space = tty_buffer_request_room(port, size);
         if (likely(space)) {
+                struct tty_buffer *tb = port->buf.tail;
                 *chars = tb->char_buf_ptr + tb->used;
                 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
                 tb->used += space;
         }
-        spin_unlock_irqrestore(&buf->lock, flags);
         return space;
 }
 EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
 
 /**
  *      tty_prepare_flip_string_flags   -       make room for characters
- *      @tty: tty
+ *      @port: tty port
  *      @chars: return pointer for character write area
  *      @flags: return pointer for status flag write area
  *      @size: desired size
@@ -428,24 +388,16 @@ EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
  *      Locking: May call functions taking port->buf.lock
  */
 
-int tty_prepare_flip_string_flags(struct tty_struct *tty,
+int tty_prepare_flip_string_flags(struct tty_port *port,
                         unsigned char **chars, char **flags, size_t size)
 {
-        struct tty_bufhead *buf = &tty->port->buf;
-        int space;
-        unsigned long __flags;
-        struct tty_buffer *tb;
-
-        spin_lock_irqsave(&buf->lock, __flags);
-        space = __tty_buffer_request_room(tty->port, size);
-
-        tb = buf->tail;
+        int space = tty_buffer_request_room(port, size);
         if (likely(space)) {
+                struct tty_buffer *tb = port->buf.tail;
                 *chars = tb->char_buf_ptr + tb->used;
                 *flags = tb->flag_buf_ptr + tb->used;
                 tb->used += space;
         }
-        spin_unlock_irqrestore(&buf->lock, __flags);
         return space;
 }
 EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
@@ -539,16 +491,17 @@ static void flush_to_ldisc(struct work_struct *work)
  */
 void tty_flush_to_ldisc(struct tty_struct *tty)
 {
-        if (!tty->low_latency)
+        if (!tty->port->low_latency)
                 flush_work(&tty->port->buf.work);
 }
 
 /**
  *      tty_flip_buffer_push    -       terminal
- *      @tty: tty to push
+ *      @port: tty port to push
  *
  *      Queue a push of the terminal flip buffers to the line discipline. This
- *      function must not be called from IRQ context if tty->low_latency is set.
+ *      function must not be called from IRQ context if port->low_latency is
+ *      set.
  *
  *      In the event of the queue being busy for flipping the work will be
  *      held off and retried later.
@@ -556,9 +509,9 @@ void tty_flush_to_ldisc(struct tty_struct *tty)
  *      Locking: tty buffer lock. Driver locks in low latency mode.
  */
 
-void tty_flip_buffer_push(struct tty_struct *tty)
+void tty_flip_buffer_push(struct tty_port *port)
 {
-        struct tty_bufhead *buf = &tty->port->buf;
+        struct tty_bufhead *buf = &port->buf;
         unsigned long flags;
 
         spin_lock_irqsave(&buf->lock, flags);
@@ -566,7 +519,7 @@ void tty_flip_buffer_push(struct tty_struct *tty)
                 buf->tail->commit = buf->tail->used;
         spin_unlock_irqrestore(&buf->lock, flags);
 
-        if (tty->low_latency)
+        if (port->low_latency)
                 flush_to_ldisc(&buf->work);
         else
                 schedule_work(&buf->work);
diff --git a/drivers/tty/tty_io.c b/drivers/tty/tty_io.c
index 6b20fd66d4ad..60e48a11b66c 100644
--- a/drivers/tty/tty_io.c
+++ b/drivers/tty/tty_io.c
@@ -536,7 +536,7 @@ EXPORT_SYMBOL_GPL(tty_wakeup);
  *      __tty_hangup            -       actual handler for hangup events
  *      @work: tty device
  *
- *      This can be called by the "eventd" kernel thread.  That is process
+ *      This can be called by a "kworker" kernel thread.  That is process
  *      synchronous but doesn't hold any locks, so we need to make sure we
  *      have the appropriate locks for what we're doing.
  *
@@ -977,8 +977,7 @@ static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
         else
                 i = -EIO;
         tty_ldisc_deref(ld);
-        if (i > 0)
-                inode->i_atime = current_fs_time(inode->i_sb);
+
         return i;
 }
 
@@ -1079,11 +1078,8 @@ static inline ssize_t do_tty_write(
                         break;
                 cond_resched();
         }
-        if (written) {
-                struct inode *inode = file->f_path.dentry->d_inode;
-                inode->i_mtime = current_fs_time(inode->i_sb);
+        if (written)
                 ret = written;
-        }
 out:
         tty_write_unlock(tty);
         return ret;
diff --git a/drivers/tty/tty_ioctl.c b/drivers/tty/tty_ioctl.c
index 8481b29d5b3a..d58b92cc187c 100644
--- a/drivers/tty/tty_ioctl.c
+++ b/drivers/tty/tty_ioctl.c
@@ -617,7 +617,7 @@ static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
         if (opt & TERMIOS_WAIT) {
                 tty_wait_until_sent(tty, 0);
                 if (signal_pending(current))
-                        return -EINTR;
+                        return -ERESTARTSYS;
         }
 
         tty_set_termios(tty, &tmp_termios);
@@ -684,7 +684,7 @@ static int set_termiox(struct tty_struct *tty, void __user *arg, int opt)
         if (opt & TERMIOS_WAIT) {
                 tty_wait_until_sent(tty, 0);
                 if (signal_pending(current))
-                        return -EINTR;
+                        return -ERESTARTSYS;
         }
 
         mutex_lock(&tty->termios_mutex);
@@ -1096,12 +1096,16 @@ int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
         ld = tty_ldisc_ref_wait(tty);
         switch (arg) {
         case TCIFLUSH:
-                if (ld && ld->ops->flush_buffer)
+                if (ld && ld->ops->flush_buffer) {
                         ld->ops->flush_buffer(tty);
+                        tty_unthrottle(tty);
+                }
                 break;
         case TCIOFLUSH:
-                if (ld && ld->ops->flush_buffer)
+                if (ld && ld->ops->flush_buffer) {
                         ld->ops->flush_buffer(tty);
+                        tty_unthrottle(tty);
+                }
                 /* fall through */
         case TCOFLUSH:
                 tty_driver_flush_buffer(tty);
diff --git a/drivers/tty/tty_ldisc.c b/drivers/tty/tty_ldisc.c
index c5782294e532..d794087c327e 100644
--- a/drivers/tty/tty_ldisc.c
+++ b/drivers/tty/tty_ldisc.c
@@ -64,7 +64,9 @@ static void put_ldisc(struct tty_ldisc *ld)
                 return;
         }
         raw_spin_unlock_irqrestore(&tty_ldisc_lock, flags);
-        wake_up(&ld->wq_idle);
+
+        if (waitqueue_active(&ld->wq_idle))
+                wake_up(&ld->wq_idle);
 }
 
 /**
@@ -934,17 +936,17 @@ void tty_ldisc_release(struct tty_struct *tty, struct tty_struct *o_tty)
          * race with the set_ldisc code path.
          */
 
-        tty_lock_pair(tty, o_tty);
         tty_ldisc_halt(tty);
-        tty_ldisc_flush_works(tty);
-        if (o_tty) {
+        if (o_tty)
                 tty_ldisc_halt(o_tty);
+
+        tty_ldisc_flush_works(tty);
+        if (o_tty)
                 tty_ldisc_flush_works(o_tty);
-        }
 
+        tty_lock_pair(tty, o_tty);
         /* This will need doing differently if we need to lock */
         tty_ldisc_kill(tty);
-
         if (o_tty)
                 tty_ldisc_kill(o_tty);
 
diff --git a/drivers/tty/vt/Makefile b/drivers/tty/vt/Makefile
index 14a51c9960df..17ae94cb29f8 100644
--- a/drivers/tty/vt/Makefile
+++ b/drivers/tty/vt/Makefile
@@ -27,8 +27,6 @@ $(obj)/defkeymap.o:  $(obj)/defkeymap.c
 ifdef GENERATE_KEYMAP
 
 $(obj)/defkeymap.c: $(obj)/%.c: $(src)/%.map
-        loadkeys --mktable $< > $@.tmp
-        sed -e 's/^static *//' $@.tmp > $@
-        rm $@.tmp
+        loadkeys --mktable $< > $@
 
 endif
diff --git a/drivers/tty/vt/keyboard.c b/drivers/tty/vt/keyboard.c
index 681765baef69..a9af1b9ae160 100644
--- a/drivers/tty/vt/keyboard.c
+++ b/drivers/tty/vt/keyboard.c
@@ -307,26 +307,17 @@ int kbd_rate(struct kbd_repeat *rep)
  */
 static void put_queue(struct vc_data *vc, int ch)
 {
-        struct tty_struct *tty = vc->port.tty;
-
-        if (tty) {
-                tty_insert_flip_char(tty, ch, 0);
-                tty_schedule_flip(tty);
-        }
+        tty_insert_flip_char(&vc->port, ch, 0);
+        tty_schedule_flip(&vc->port);
 }
 
 static void puts_queue(struct vc_data *vc, char *cp)
 {
-        struct tty_struct *tty = vc->port.tty;
-
-        if (!tty)
-                return;
-
         while (*cp) {
-                tty_insert_flip_char(tty, *cp, 0);
+                tty_insert_flip_char(&vc->port, *cp, 0);
                 cp++;
         }
-        tty_schedule_flip(tty);
+        tty_schedule_flip(&vc->port);
 }
 
 static void applkey(struct vc_data *vc, int key, char mode)
@@ -582,12 +573,8 @@ static void fn_inc_console(struct vc_data *vc)
 
 static void fn_send_intr(struct vc_data *vc)
 {
-        struct tty_struct *tty = vc->port.tty;
-
-        if (!tty)
-                return;
-        tty_insert_flip_char(tty, 0, TTY_BREAK);
-        tty_schedule_flip(tty);
+        tty_insert_flip_char(&vc->port, 0, TTY_BREAK);
+        tty_schedule_flip(&vc->port);
 }
 
 static void fn_scroll_forw(struct vc_data *vc)
diff --git a/drivers/tty/vt/vt.c b/drivers/tty/vt/vt.c
index 8fd89687d068..1a2728034599 100644
--- a/drivers/tty/vt/vt.c
+++ b/drivers/tty/vt/vt.c
@@ -1333,13 +1333,13 @@ static void csi_m(struct vc_data *vc)
         update_attr(vc);
 }
 
-static void respond_string(const char *p, struct tty_struct *tty)
+static void respond_string(const char *p, struct tty_port *port)
 {
         while (*p) {
-                tty_insert_flip_char(tty, *p, 0);
+                tty_insert_flip_char(port, *p, 0);
                 p++;
         }
-        tty_schedule_flip(tty);
+        tty_schedule_flip(port);
 }
 
 static void cursor_report(struct vc_data *vc, struct tty_struct *tty)
@@ -1347,17 +1347,17 @@ static void cursor_report(struct vc_data *vc, struct tty_struct *tty)
         char buf[40];
 
         sprintf(buf, "\033[%d;%dR", vc->vc_y + (vc->vc_decom ? vc->vc_top + 1 : 1), vc->vc_x + 1);
-        respond_string(buf, tty);
+        respond_string(buf, tty->port);
 }
 
 static inline void status_report(struct tty_struct *tty)
 {
-        respond_string("\033[0n", tty); /* Terminal ok */
+        respond_string("\033[0n", tty->port);   /* Terminal ok */
 }
 
-static inline void respond_ID(struct tty_struct * tty)
+static inline void respond_ID(struct tty_struct *tty)
 {
-        respond_string(VT102ID, tty);
+        respond_string(VT102ID, tty->port);
 }
 
 void mouse_report(struct tty_struct *tty, int butt, int mrx, int mry)
@@ -1366,7 +1366,7 @@ void mouse_report(struct tty_struct *tty, int butt, int mrx, int mry)
 
         sprintf(buf, "\033[M%c%c%c", (char)(' ' + butt), (char)('!' + mrx),
                 (char)('!' + mry));
-        respond_string(buf, tty);
+        respond_string(buf, tty->port);
 }
 
 /* invoked via ioctl(TIOCLINUX) and through set_selection */
diff --git a/drivers/usb/class/Kconfig b/drivers/usb/class/Kconfig
index 2519e320098f..316aac8e4ca1 100644
--- a/drivers/usb/class/Kconfig
+++ b/drivers/usb/class/Kconfig
@@ -6,7 +6,7 @@ comment "USB Device Class drivers"
 
 config USB_ACM
         tristate "USB Modem (CDC ACM) support"
-        depends on USB
+        depends on USB && TTY
         ---help---
           This driver supports USB modems and ISDN adapters which support the
           Communication Device Class Abstract Control Model interface.
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index 2d92cce260d7..8ac25adf31b4 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -410,19 +410,12 @@ static int acm_submit_read_urbs(struct acm *acm, gfp_t mem_flags)
 
 static void acm_process_read_urb(struct acm *acm, struct urb *urb)
 {
-        struct tty_struct *tty;
-
         if (!urb->actual_length)
                 return;
 
-        tty = tty_port_tty_get(&acm->port);
-        if (!tty)
-                return;
-
-        tty_insert_flip_string(tty, urb->transfer_buffer, urb->actual_length);
-        tty_flip_buffer_push(tty);
-
-        tty_kref_put(tty);
+        tty_insert_flip_string(&acm->port, urb->transfer_buffer,
+                        urb->actual_length);
+        tty_flip_buffer_push(&acm->port);
 }
 
 static void acm_read_bulk_callback(struct urb *urb)
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index c5c6fa60910d..5a0c541daf89 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -762,6 +762,7 @@ config USB_GADGET_TARGET
 
 config USB_G_SERIAL
         tristate "Serial Gadget (with CDC ACM and CDC OBEX support)"
+        depends on TTY
         select USB_U_SERIAL
         select USB_F_ACM
         select USB_LIBCOMPOSITE
@@ -813,6 +814,8 @@ config USB_G_PRINTER
           For more information, see Documentation/usb/gadget_printer.txt
           which includes sample code for accessing the device file.
 
+if TTY
+
 config USB_CDC_COMPOSITE
         tristate "CDC Composite Device (Ethernet and ACM)"
         depends on NET
@@ -900,6 +903,8 @@ config USB_G_MULTI_CDC
 
           If unsure, say "y".
 
+endif # TTY
+
 config USB_G_HID
         tristate "HID Gadget"
         select USB_LIBCOMPOSITE
@@ -916,6 +921,7 @@ config USB_G_HID
 # Standalone / single function gadgets
 config USB_G_DBGP
         tristate "EHCI Debug Device Gadget"
+        depends on TTY
         select USB_LIBCOMPOSITE
         help
           This gadget emulates an EHCI Debug device. This is useful when you want
diff --git a/drivers/usb/gadget/u_serial.c b/drivers/usb/gadget/u_serial.c
index 588a9be18ef8..c5034d9c946b 100644
--- a/drivers/usb/gadget/u_serial.c
+++ b/drivers/usb/gadget/u_serial.c
@@ -496,12 +496,8 @@ static void gs_rx_push(unsigned long _port)
 
                 req = list_first_entry(queue, struct usb_request, list);
 
-                /* discard data if tty was closed */
-                if (!tty)
-                        goto recycle;
-
                 /* leave data queued if tty was rx throttled */
-                if (test_bit(TTY_THROTTLED, &tty->flags))
+                if (tty && test_bit(TTY_THROTTLED, &tty->flags))
                         break;
 
                 switch (req->status) {
@@ -534,7 +530,8 @@ static void gs_rx_push(unsigned long _port)
                                 size -= n;
                         }
 
-                        count = tty_insert_flip_string(tty, packet, size);
+                        count = tty_insert_flip_string(&port->port, packet,
+                                        size);
                         if (count)
                                 do_push = true;
                         if (count != size) {
@@ -547,7 +544,7 @@ static void gs_rx_push(unsigned long _port)
                         }
                         port->n_read = 0;
                 }
-recycle:
+
                 list_move(&req->list, &port->read_pool);
                 port->read_started--;
         }
@@ -555,8 +552,8 @@ recycle:
         /* Push from tty to ldisc; without low_latency set this is handled by
          * a workqueue, so we won't get callbacks and can hold port_lock
          */
-        if (tty && do_push)
-                tty_flip_buffer_push(tty);
+        if (do_push)
+                tty_flip_buffer_push(&port->port);
 
 
         /* We want our data queue to become empty ASAP, keeping data
diff --git a/drivers/usb/serial/Kconfig b/drivers/usb/serial/Kconfig
index dad8363e5b2a..17b7f9ae36ad 100644
--- a/drivers/usb/serial/Kconfig
+++ b/drivers/usb/serial/Kconfig
@@ -4,7 +4,7 @@
 
 menuconfig USB_SERIAL
         tristate "USB Serial Converter support"
-        depends on USB
+        depends on USB && TTY
         ---help---
           Say Y here if you have a USB device that provides normal serial
           ports, or acts like a serial device, and you want to connect it to
diff --git a/drivers/usb/serial/aircable.c b/drivers/usb/serial/aircable.c
index 6d110a3bc7e7..6e320cec397d 100644
--- a/drivers/usb/serial/aircable.c
+++ b/drivers/usb/serial/aircable.c
@@ -119,9 +119,8 @@ static int aircable_probe(struct usb_serial *serial,
         return 0;
 }
 
-static int aircable_process_packet(struct tty_struct *tty,
-                        struct usb_serial_port *port, int has_headers,
-                        char *packet, int len)
+static int aircable_process_packet(struct usb_serial_port *port,
+                int has_headers, char *packet, int len)
 {
         if (has_headers) {
                 len -= HCI_HEADER_LENGTH;
@@ -132,7 +131,7 @@ static int aircable_process_packet(struct tty_struct *tty,
                 return 0;
         }
 
-        tty_insert_flip_string(tty, packet, len);
+        tty_insert_flip_string(&port->port, packet, len);
 
         return len;
 }
@@ -141,28 +140,22 @@ static void aircable_process_read_urb(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         char *data = (char *)urb->transfer_buffer;
-        struct tty_struct *tty;
         int has_headers;
         int count;
         int len;
         int i;
 
-        tty = tty_port_tty_get(&port->port);
-        if (!tty)
-                return;
-
         has_headers = (urb->actual_length > 2 && data[0] == RX_HEADER_0);
 
         count = 0;
         for (i = 0; i < urb->actual_length; i += HCI_COMPLETE_FRAME) {
                 len = min_t(int, urb->actual_length - i, HCI_COMPLETE_FRAME);
-                count += aircable_process_packet(tty, port, has_headers,
+                count += aircable_process_packet(port, has_headers,
                                                                 &data[i], len);
         }
 
         if (count)
-                tty_flip_buffer_push(tty);
-        tty_kref_put(tty);
+                tty_flip_buffer_push(&port->port);
 }
 
 static struct usb_serial_driver aircable_device = {
diff --git a/drivers/usb/serial/ark3116.c b/drivers/usb/serial/ark3116.c
index a88882c0e237..cbd904b8fba5 100644
--- a/drivers/usb/serial/ark3116.c
+++ b/drivers/usb/serial/ark3116.c
@@ -674,7 +674,6 @@ static void ark3116_process_read_urb(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         struct ark3116_private *priv = usb_get_serial_port_data(port);
-        struct tty_struct *tty;
         unsigned char *data = urb->transfer_buffer;
         char tty_flag = TTY_NORMAL;
         unsigned long flags;
@@ -689,10 +688,6 @@ static void ark3116_process_read_urb(struct urb *urb)
         if (!urb->actual_length)
                 return;
 
-        tty = tty_port_tty_get(&port->port);
-        if (!tty)
-                return;
-
         if (lsr & UART_LSR_BRK_ERROR_BITS) {
                 if (lsr & UART_LSR_BI)
                         tty_flag = TTY_BREAK;
@@ -703,12 +698,11 @@ static void ark3116_process_read_urb(struct urb *urb)
 
                 /* overrun is special, not associated with a char */
                 if (lsr & UART_LSR_OE)
-                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                        tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
         }
-        tty_insert_flip_string_fixed_flag(tty, data, tty_flag,
+        tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
                                                         urb->actual_length);
-        tty_flip_buffer_push(tty);
-        tty_kref_put(tty);
+        tty_flip_buffer_push(&port->port);
 }
 
 static struct usb_serial_driver ark3116_device = {
diff --git a/drivers/usb/serial/belkin_sa.c b/drivers/usb/serial/belkin_sa.c
index b72a4c166705..84217e78ded4 100644
--- a/drivers/usb/serial/belkin_sa.c
+++ b/drivers/usb/serial/belkin_sa.c
@@ -242,7 +242,6 @@ static void belkin_sa_process_read_urb(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         struct belkin_sa_private *priv = usb_get_serial_port_data(port);
-        struct tty_struct *tty;
         unsigned char *data = urb->transfer_buffer;
         unsigned long flags;
         unsigned char status;
@@ -259,10 +258,6 @@ static void belkin_sa_process_read_urb(struct urb *urb)
         if (!urb->actual_length)
                 return;
 
-        tty = tty_port_tty_get(&port->port);
-        if (!tty)
-                return;
-
         if (status & BELKIN_SA_LSR_ERR) {
                 /* Break takes precedence over parity, which takes precedence
                  * over framing errors. */
@@ -276,13 +271,12 @@ static void belkin_sa_process_read_urb(struct urb *urb)
 
                 /* Overrun is special, not associated with a char. */
                 if (status & BELKIN_SA_LSR_OE)
-                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                        tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
         }
 
-        tty_insert_flip_string_fixed_flag(tty, data, tty_flag,
+        tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
                                                         urb->actual_length);
-        tty_flip_buffer_push(tty);
-        tty_kref_put(tty);
+        tty_flip_buffer_push(&port->port);
 }
 
 static void belkin_sa_set_termios(struct tty_struct *tty,
diff --git a/drivers/usb/serial/cyberjack.c b/drivers/usb/serial/cyberjack.c
index 69a4fa1cee25..629bd2894506 100644
--- a/drivers/usb/serial/cyberjack.c
+++ b/drivers/usb/serial/cyberjack.c
@@ -324,7 +324,6 @@ static void cyberjack_read_bulk_callback(struct urb *urb)
         struct usb_serial_port *port = urb->context;
         struct cyberjack_private *priv = usb_get_serial_port_data(port);
         struct device *dev = &port->dev;
-        struct tty_struct *tty;
         unsigned char *data = urb->transfer_buffer;
         short todo;
         int result;
@@ -337,16 +336,10 @@ static void cyberjack_read_bulk_callback(struct urb *urb)
                 return;
         }
 
-        tty = tty_port_tty_get(&port->port);
-        if (!tty) {
-                dev_dbg(dev, "%s - ignoring since device not open\n", __func__);
-                return;
-        }
         if (urb->actual_length) {
-                tty_insert_flip_string(tty, data, urb->actual_length);
-                tty_flip_buffer_push(tty);
+                tty_insert_flip_string(&port->port, data, urb->actual_length);
+                tty_flip_buffer_push(&port->port);
         }
-        tty_kref_put(tty);
 
         spin_lock(&priv->lock);
 
diff --git a/drivers/usb/serial/cypress_m8.c b/drivers/usb/serial/cypress_m8.c
index fd8c35fd452e..8efa19d0e9fb 100644
--- a/drivers/usb/serial/cypress_m8.c
+++ b/drivers/usb/serial/cypress_m8.c
@@ -1214,10 +1214,10 @@ static void cypress_read_int_callback(struct urb *urb)
                 spin_unlock_irqrestore(&priv->lock, flags);
 
         /* process read if there is data other than line status */
-        if (tty && bytes > i) {
-                tty_insert_flip_string_fixed_flag(tty, data + i,
+        if (bytes > i) {
+                tty_insert_flip_string_fixed_flag(&port->port, data + i,
                                 tty_flag, bytes - i);
-                tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(&port->port);
         }
 
         spin_lock_irqsave(&priv->lock, flags);
diff --git a/drivers/usb/serial/digi_acceleport.c b/drivers/usb/serial/digi_acceleport.c
index 45d4af62967f..ebe45fa0ed50 100644
--- a/drivers/usb/serial/digi_acceleport.c
+++ b/drivers/usb/serial/digi_acceleport.c
@@ -1399,9 +1399,7 @@ static void digi_read_bulk_callback(struct urb *urb)
 
 static int digi_read_inb_callback(struct urb *urb)
 {
-
         struct usb_serial_port *port = urb->context;
-        struct tty_struct *tty;
         struct digi_port *priv = usb_get_serial_port_data(port);
         int opcode = ((unsigned char *)urb->transfer_buffer)[0];
         int len = ((unsigned char *)urb->transfer_buffer)[1];
@@ -1425,7 +1423,6 @@ static int digi_read_inb_callback(struct urb *urb)
                 return -1;
         }
 
-        tty = tty_port_tty_get(&port->port);
         spin_lock(&priv->dp_port_lock);
 
         /* check for throttle; if set, do not resubmit read urb */
@@ -1435,13 +1432,13 @@ static int digi_read_inb_callback(struct urb *urb)
                 priv->dp_throttle_restart = 1;
 
         /* receive data */
-        if (tty && opcode == DIGI_CMD_RECEIVE_DATA) {
+        if (opcode == DIGI_CMD_RECEIVE_DATA) {
                 /* get flag from port_status */
                 flag = 0;
 
                 /* overrun is special, not associated with a char */
                 if (port_status & DIGI_OVERRUN_ERROR)
-                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                        tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
 
                 /* break takes precedence over parity, */
                 /* which takes precedence over framing errors */
@@ -1455,13 +1452,12 @@ static int digi_read_inb_callback(struct urb *urb)
                 /* data length is len-1 (one byte of len is port_status) */
                 --len;
                 if (len > 0) {
-                        tty_insert_flip_string_fixed_flag(tty, data, flag,
-                                                                        len);
-                        tty_flip_buffer_push(tty);
+                        tty_insert_flip_string_fixed_flag(&port->port, data,
+                                        flag, len);
+                        tty_flip_buffer_push(&port->port);
                 }
         }
         spin_unlock(&priv->dp_port_lock);
-        tty_kref_put(tty);
 
         if (opcode == DIGI_CMD_RECEIVE_DISABLE)
                 dev_dbg(&port->dev, "%s: got RECEIVE_DISABLE\n", __func__);
diff --git a/drivers/usb/serial/f81232.c b/drivers/usb/serial/f81232.c
index 6e4eb57d0177..b1b2dc64b50b 100644
--- a/drivers/usb/serial/f81232.c
+++ b/drivers/usb/serial/f81232.c
@@ -100,7 +100,6 @@ static void f81232_process_read_urb(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         struct f81232_private *priv = usb_get_serial_port_data(port);
-        struct tty_struct *tty;
         unsigned char *data = urb->transfer_buffer;
         char tty_flag = TTY_NORMAL;
         unsigned long flags;
@@ -117,10 +116,6 @@ static void f81232_process_read_urb(struct urb *urb)
         if (!urb->actual_length)
                 return;
 
-        tty = tty_port_tty_get(&port->port);
-        if (!tty)
-                return;
-
         /* break takes precedence over parity, */
         /* which takes precedence over framing errors */
         if (line_status & UART_BREAK_ERROR)
@@ -133,19 +128,19 @@ static void f81232_process_read_urb(struct urb *urb)
 
         /* overrun is special, not associated with a char */
         if (line_status & UART_OVERRUN_ERROR)
-                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
 
         if (port->port.console && port->sysrq) {
                 for (i = 0; i < urb->actual_length; ++i)
                         if (!usb_serial_handle_sysrq_char(port, data[i]))
-                                tty_insert_flip_char(tty, data[i], tty_flag);
+                                tty_insert_flip_char(&port->port, data[i],
+                                                tty_flag);
         } else {
-                tty_insert_flip_string_fixed_flag(tty, data, tty_flag,
+                tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
                                                         urb->actual_length);
         }
 
-        tty_flip_buffer_push(tty);
-        tty_kref_put(tty);
+        tty_flip_buffer_push(&port->port);
 }
 
 static int set_control_lines(struct usb_device *dev, u8 value)
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index d07fccf3bab5..edd162df49ca 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -1960,9 +1960,8 @@ static int ftdi_prepare_write_buffer(struct usb_serial_port *port,
 
 #define FTDI_RS_ERR_MASK (FTDI_RS_BI | FTDI_RS_PE | FTDI_RS_FE | FTDI_RS_OE)
 
-static int ftdi_process_packet(struct tty_struct *tty,
-                struct usb_serial_port *port, struct ftdi_private *priv,
-                char *packet, int len)
+static int ftdi_process_packet(struct usb_serial_port *port,
+                struct ftdi_private *priv, char *packet, int len)
 {
         int i;
         char status;
@@ -2012,7 +2011,7 @@ static int ftdi_process_packet(struct tty_struct *tty,
                 /* Overrun is special, not associated with a char */
                 if (packet[1] & FTDI_RS_OE) {
                         priv->icount.overrun++;
-                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                        tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
                 }
         }
 
@@ -2031,10 +2030,10 @@ static int ftdi_process_packet(struct tty_struct *tty,
         if (port->port.console && port->sysrq) {
                 for (i = 0; i < len; i++, ch++) {
                         if (!usb_serial_handle_sysrq_char(port, *ch))
-                                tty_insert_flip_char(tty, *ch, flag);
+                                tty_insert_flip_char(&port->port, *ch, flag);
                 }
         } else {
-                tty_insert_flip_string_fixed_flag(tty, ch, flag, len);
+                tty_insert_flip_string_fixed_flag(&port->port, ch, flag, len);
         }
 
         return len;
@@ -2043,25 +2042,19 @@ static int ftdi_process_packet(struct tty_struct *tty,
 static void ftdi_process_read_urb(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
-        struct tty_struct *tty;
         struct ftdi_private *priv = usb_get_serial_port_data(port);
         char *data = (char *)urb->transfer_buffer;
         int i;
         int len;
         int count = 0;
 
-        tty = tty_port_tty_get(&port->port);
-        if (!tty)
-                return;
-
         for (i = 0; i < urb->actual_length; i += priv->max_packet_size) {
                 len = min_t(int, urb->actual_length - i, priv->max_packet_size);
-                count += ftdi_process_packet(tty, port, priv, &data[i], len);
+                count += ftdi_process_packet(port, priv, &data[i], len);
         }
 
         if (count)
-                tty_flip_buffer_push(tty);
-        tty_kref_put(tty);
+                tty_flip_buffer_push(&port->port);
 }
 
 static void ftdi_break_ctl(struct tty_struct *tty, int break_state)
diff --git a/drivers/usb/serial/garmin_gps.c b/drivers/usb/serial/garmin_gps.c
index 203358d7e7bc..1a07b12ef341 100644
--- a/drivers/usb/serial/garmin_gps.c
+++ b/drivers/usb/serial/garmin_gps.c
@@ -252,14 +252,11 @@ static inline int isAbortTrfCmnd(const unsigned char *buf)
 static void send_to_tty(struct usb_serial_port *port,
                         char *data, unsigned int actual_length)
 {
-        struct tty_struct *tty = tty_port_tty_get(&port->port);
-
-        if (tty && actual_length) {
+        if (actual_length) {
                 usb_serial_debug_data(&port->dev, __func__, actual_length, data);
-                tty_insert_flip_string(tty, data, actual_length);
-                tty_flip_buffer_push(tty);
+                tty_insert_flip_string(&port->port, data, actual_length);
+                tty_flip_buffer_push(&port->port);
         }
-        tty_kref_put(tty);
 }
 
 
diff --git a/drivers/usb/serial/generic.c b/drivers/usb/serial/generic.c
index 2ea70a631996..4c5c23f1cae5 100644
--- a/drivers/usb/serial/generic.c
+++ b/drivers/usb/serial/generic.c
@@ -313,30 +313,24 @@ EXPORT_SYMBOL_GPL(usb_serial_generic_submit_read_urbs);
 void usb_serial_generic_process_read_urb(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
-        struct tty_struct *tty;
         char *ch = (char *)urb->transfer_buffer;
         int i;
 
         if (!urb->actual_length)
                 return;
 
-        tty = tty_port_tty_get(&port->port);
-        if (!tty)
-                return;
-
         /* The per character mucking around with sysrq path it too slow for
            stuff like 3G modems, so shortcircuit it in the 99.9999999% of cases
            where the USB serial is not a console anyway */
         if (!port->port.console || !port->sysrq)
-                tty_insert_flip_string(tty, ch, urb->actual_length);
+                tty_insert_flip_string(&port->port, ch, urb->actual_length);
         else {
                 for (i = 0; i < urb->actual_length; i++, ch++) {
                         if (!usb_serial_handle_sysrq_char(port, *ch))
-                                tty_insert_flip_char(tty, *ch, TTY_NORMAL);
+                                tty_insert_flip_char(&port->port, *ch, TTY_NORMAL);
                 }
         }
-        tty_flip_buffer_push(tty);
-        tty_kref_put(tty);
+        tty_flip_buffer_push(&port->port);
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_process_read_urb);
 
diff --git a/drivers/usb/serial/io_edgeport.c b/drivers/usb/serial/io_edgeport.c
index 7b770c7f8b11..b00e5cbf741f 100644
--- a/drivers/usb/serial/io_edgeport.c
+++ b/drivers/usb/serial/io_edgeport.c
@@ -232,8 +232,8 @@ static void  process_rcvd_data(struct edgeport_serial *edge_serial,
                                 unsigned char *buffer, __u16 bufferLength);
 static void process_rcvd_status(struct edgeport_serial *edge_serial,
                                 __u8 byte2, __u8 byte3);
-static void edge_tty_recv(struct device *dev, struct tty_struct *tty,
-                                unsigned char *data, int length);
+static void edge_tty_recv(struct usb_serial_port *port, unsigned char *data,
+                int length);
 static void handle_new_msr(struct edgeport_port *edge_port, __u8 newMsr);
 static void handle_new_lsr(struct edgeport_port *edge_port, __u8 lsrData,
                                 __u8 lsr, __u8 data);
@@ -1752,7 +1752,6 @@ static void process_rcvd_data(struct edgeport_serial *edge_serial,
         struct device *dev = &edge_serial->serial->dev->dev;
         struct usb_serial_port *port;
         struct edgeport_port *edge_port;
-        struct tty_struct *tty;
         __u16 lastBufferLength;
         __u16 rxLen;
 
@@ -1860,14 +1859,11 @@ static void process_rcvd_data(struct edgeport_serial *edge_serial,
                                                         edge_serial->rxPort];
                                 edge_port = usb_get_serial_port_data(port);
                                 if (edge_port->open) {
-                                        tty = tty_port_tty_get(
-                                                &edge_port->port->port);
-                                        if (tty) {
-                                                dev_dbg(dev, "%s - Sending %d bytes to TTY for port %d\n",
-                                                        __func__, rxLen, edge_serial->rxPort);
-                                                edge_tty_recv(&edge_serial->serial->dev->dev, tty, buffer, rxLen);
-                                                tty_kref_put(tty);
-                                        }
+                                        dev_dbg(dev, "%s - Sending %d bytes to TTY for port %d\n",
+                                                __func__, rxLen,
+                                                edge_serial->rxPort);
+                                        edge_tty_recv(edge_port->port, buffer,
+                                                        rxLen);
                                         edge_port->icount.rx += rxLen;
                                 }
                                 buffer += rxLen;
@@ -2017,20 +2013,20 @@ static void process_rcvd_status(struct edgeport_serial *edge_serial,
  * edge_tty_recv
  *      this function passes data on to the tty flip buffer
  *****************************************************************************/
-static void edge_tty_recv(struct device *dev, struct tty_struct *tty,
-                                        unsigned char *data, int length)
+static void edge_tty_recv(struct usb_serial_port *port, unsigned char *data,
+                int length)
 {
         int cnt;
 
-        cnt = tty_insert_flip_string(tty, data, length);
+        cnt = tty_insert_flip_string(&port->port, data, length);
         if (cnt < length) {
-                dev_err(dev, "%s - dropping data, %d bytes lost\n",
+                dev_err(&port->dev, "%s - dropping data, %d bytes lost\n",
                                 __func__, length - cnt);
         }
         data += cnt;
         length -= cnt;
 
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&port->port);
 }
 
 
@@ -2086,14 +2082,9 @@ static void handle_new_lsr(struct edgeport_port *edge_port, __u8 lsrData,
         }
 
         /* Place LSR data byte into Rx buffer */
-        if (lsrData) {
-                struct tty_struct *tty =
-                                tty_port_tty_get(&edge_port->port->port);
-                if (tty) {
-                        edge_tty_recv(&edge_port->port->dev, tty, &data, 1);
-                        tty_kref_put(tty);
-                }
-        }
+        if (lsrData)
+                edge_tty_recv(edge_port->port, &data, 1);
+
         /* update input line counters */
         icount = &edge_port->icount;
         if (newLsr & LSR_BREAK)
diff --git a/drivers/usb/serial/io_ti.c b/drivers/usb/serial/io_ti.c
index 641ab3da2d83..c23776679f70 100644
--- a/drivers/usb/serial/io_ti.c
+++ b/drivers/usb/serial/io_ti.c
@@ -201,8 +201,8 @@ static int closing_wait = EDGE_CLOSING_WAIT;
 static bool ignore_cpu_rev;
 static int default_uart_mode;           /* RS232 */
 
-static void edge_tty_recv(struct device *dev, struct tty_struct *tty,
-                          unsigned char *data, int length);
+static void edge_tty_recv(struct usb_serial_port *port, unsigned char *data,
+                int length);
 
 static void stop_read(struct edgeport_port *edge_port);
 static int restart_read(struct edgeport_port *edge_port);
@@ -1484,7 +1484,6 @@ static void handle_new_lsr(struct edgeport_port *edge_port, int lsr_data,
         struct async_icount *icount;
         __u8 new_lsr = (__u8)(lsr & (__u8)(LSR_OVER_ERR | LSR_PAR_ERR |
                                                 LSR_FRM_ERR | LSR_BREAK));
-        struct tty_struct *tty;
 
         dev_dbg(&edge_port->port->dev, "%s - %02x\n", __func__, new_lsr);
 
@@ -1498,13 +1497,8 @@ static void handle_new_lsr(struct edgeport_port *edge_port, int lsr_data,
                 new_lsr &= (__u8)(LSR_OVER_ERR | LSR_BREAK);
 
         /* Place LSR data byte into Rx buffer */
-        if (lsr_data) {
-                tty = tty_port_tty_get(&edge_port->port->port);
-                if (tty) {
-                        edge_tty_recv(&edge_port->port->dev, tty, &data, 1);
-                        tty_kref_put(tty);
-                }
-        }
+        if (lsr_data)
+                edge_tty_recv(edge_port->port, &data, 1);
 
         /* update input line counters */
         icount = &edge_port->icount;
@@ -1620,7 +1614,6 @@ static void edge_bulk_in_callback(struct urb *urb)
         struct edgeport_port *edge_port = urb->context;
         struct device *dev = &edge_port->port->dev;
         unsigned char *data = urb->transfer_buffer;
-        struct tty_struct *tty;
         int retval = 0;
         int port_number;
         int status = urb->status;
@@ -1659,17 +1652,16 @@ static void edge_bulk_in_callback(struct urb *urb)
                 ++data;
         }
 
-        tty = tty_port_tty_get(&edge_port->port->port);
-        if (tty && urb->actual_length) {
+        if (urb->actual_length) {
                 usb_serial_debug_data(dev, __func__, urb->actual_length, data);
                 if (edge_port->close_pending)
                         dev_dbg(dev, "%s - close pending, dropping data on the floor\n",
                                                                 __func__);
                 else
-                        edge_tty_recv(dev, tty, data, urb->actual_length);
+                        edge_tty_recv(edge_port->port, data,
+                                        urb->actual_length);
                 edge_port->icount.rx += urb->actual_length;
         }
-        tty_kref_put(tty);
 
 exit:
         /* continue read unless stopped */
@@ -1684,16 +1676,16 @@ exit:
                 dev_err(dev, "%s - usb_submit_urb failed with result %d\n", __func__, retval);
 }
 
-static void edge_tty_recv(struct device *dev, struct tty_struct *tty,
-                                        unsigned char *data, int length)
+static void edge_tty_recv(struct usb_serial_port *port, unsigned char *data,
+                int length)
 {
         int queued;
 
-        queued = tty_insert_flip_string(tty, data, length);
+        queued = tty_insert_flip_string(&port->port, data, length);
         if (queued < length)
-                dev_err(dev, "%s - dropping data, %d bytes lost\n",
+                dev_err(&port->dev, "%s - dropping data, %d bytes lost\n",
                         __func__, length - queued);
-        tty_flip_buffer_push(tty);
+        tty_flip_buffer_push(&port->port);
 }
 
 static void edge_bulk_out_callback(struct urb *urb)
diff --git a/drivers/usb/serial/ir-usb.c b/drivers/usb/serial/ir-usb.c
index e24e2d4f4c1b..716930ab1bb1 100644
--- a/drivers/usb/serial/ir-usb.c
+++ b/drivers/usb/serial/ir-usb.c
@@ -287,7 +287,6 @@ static void ir_process_read_urb(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         unsigned char *data = urb->transfer_buffer;
-        struct tty_struct *tty;
 
         if (!urb->actual_length)
                 return;
@@ -302,12 +301,8 @@ static void ir_process_read_urb(struct urb *urb)
         if (urb->actual_length == 1)
                 return;
 
-        tty = tty_port_tty_get(&port->port);
-        if (!tty)
-                return;
-        tty_insert_flip_string(tty, data + 1, urb->actual_length - 1);
-        tty_flip_buffer_push(tty);
-        tty_kref_put(tty);
+        tty_insert_flip_string(&port->port, data + 1, urb->actual_length - 1);
+        tty_flip_buffer_push(&port->port);
 }
 
 static void ir_set_termios_callback(struct urb *urb)
diff --git a/drivers/usb/serial/iuu_phoenix.c b/drivers/usb/serial/iuu_phoenix.c
index 1e1fbed65ef2..ff77027160aa 100644
--- a/drivers/usb/serial/iuu_phoenix.c
+++ b/drivers/usb/serial/iuu_phoenix.c
@@ -581,7 +581,6 @@ static void read_buf_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         unsigned char *data = urb->transfer_buffer;
-        struct tty_struct *tty;
         int status = urb->status;
 
         if (status) {
@@ -592,14 +591,12 @@ static void read_buf_callback(struct urb *urb)
         }
 
         dev_dbg(&port->dev, "%s - %i chars to write\n", __func__, urb->actual_length);
-        tty = tty_port_tty_get(&port->port);
         if (data == NULL)
                 dev_dbg(&port->dev, "%s - data is NULL !!!\n", __func__);
-        if (tty && urb->actual_length && data) {
-                tty_insert_flip_string(tty, data, urb->actual_length);
-                tty_flip_buffer_push(tty);
+        if (urb->actual_length && data) {
+                tty_insert_flip_string(&port->port, data, urb->actual_length);
+                tty_flip_buffer_push(&port->port);
         }
-        tty_kref_put(tty);
         iuu_led_activity_on(urb);
 }
 
diff --git a/drivers/usb/serial/keyspan.c b/drivers/usb/serial/keyspan.c
index 3d95637f3d68..1fd1935c8316 100644
--- a/drivers/usb/serial/keyspan.c
+++ b/drivers/usb/serial/keyspan.c
@@ -291,7 +291,6 @@ static void	usa26_indat_callback(struct urb *urb)
         int                     i, err;
         int                     endpoint;
         struct usb_serial_port  *port;
-        struct tty_struct       *tty;
         unsigned char           *data = urb->transfer_buffer;
         int status = urb->status;
 
@@ -304,8 +303,7 @@ static void	usa26_indat_callback(struct urb *urb)
         }
 
         port =  urb->context;
-        tty = tty_port_tty_get(&port->port);
-        if (tty && urb->actual_length) {
+        if (urb->actual_length) {
                 /* 0x80 bit is error flag */
                 if ((data[0] & 0x80) == 0) {
                         /* no errors on individual bytes, only
@@ -315,7 +313,7 @@ static void	usa26_indat_callback(struct urb *urb)
                         else
                                 err = 0;
                         for (i = 1; i < urb->actual_length ; ++i)
-                                tty_insert_flip_char(tty, data[i], err);
+                                tty_insert_flip_char(&port->port, data[i], err);
                 } else {
                         /* some bytes had errors, every byte has status */
                         dev_dbg(&port->dev, "%s - RX error!!!!\n", __func__);
@@ -328,12 +326,12 @@ static void	usa26_indat_callback(struct urb *urb)
                                 if (stat & RXERROR_PARITY)
                                         flag |= TTY_PARITY;
                                 /* XXX should handle break (0x10) */
-                                tty_insert_flip_char(tty, data[i+1], flag);
+                                tty_insert_flip_char(&port->port, data[i+1],
+                                                flag);
                         }
                 }
-                tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(&port->port);
         }
-        tty_kref_put(tty);
 
         /* Resubmit urb so we continue receiving */
         err = usb_submit_urb(urb, GFP_ATOMIC);
@@ -446,7 +444,6 @@ static void usa28_indat_callback(struct urb *urb)
 {
         int                     err;
         struct usb_serial_port  *port;
-        struct tty_struct       *tty;
         unsigned char           *data;
         struct keyspan_port_private             *p_priv;
         int status = urb->status;
@@ -469,12 +466,11 @@ static void usa28_indat_callback(struct urb *urb)
                 p_priv = usb_get_serial_port_data(port);
                 data = urb->transfer_buffer;
 
-                tty = tty_port_tty_get(&port->port);
-                if (tty && urb->actual_length) {
-                        tty_insert_flip_string(tty, data, urb->actual_length);
-                        tty_flip_buffer_push(tty);
+                if (urb->actual_length) {
+                        tty_insert_flip_string(&port->port, data,
+                                        urb->actual_length);
+                        tty_flip_buffer_push(&port->port);
                 }
-                tty_kref_put(tty);
 
                 /* Resubmit urb so we continue receiving */
                 err = usb_submit_urb(urb, GFP_ATOMIC);
@@ -669,7 +665,6 @@ static void	usa49_indat_callback(struct urb *urb)
         int                     i, err;
         int                     endpoint;
         struct usb_serial_port  *port;
-        struct tty_struct       *tty;
         unsigned char           *data = urb->transfer_buffer;
         int status = urb->status;
 
@@ -682,12 +677,11 @@ static void	usa49_indat_callback(struct urb *urb)
         }
 
         port =  urb->context;
-        tty = tty_port_tty_get(&port->port);
-        if (tty && urb->actual_length) {
+        if (urb->actual_length) {
                 /* 0x80 bit is error flag */
                 if ((data[0] & 0x80) == 0) {
                         /* no error on any byte */
-                        tty_insert_flip_string(tty, data + 1,
+                        tty_insert_flip_string(&port->port, data + 1,
                                                 urb->actual_length - 1);
                 } else {
                         /* some bytes had errors, every byte has status */
@@ -700,12 +694,12 @@ static void	usa49_indat_callback(struct urb *urb)
                                 if (stat & RXERROR_PARITY)
                                         flag |= TTY_PARITY;
                                 /* XXX should handle break (0x10) */
-                                tty_insert_flip_char(tty, data[i+1], flag);
+                                tty_insert_flip_char(&port->port, data[i+1],
+                                                flag);
                         }
                 }
-                tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(&port->port);
         }
-        tty_kref_put(tty);
 
         /* Resubmit urb so we continue receiving */
         err = usb_submit_urb(urb, GFP_ATOMIC);
@@ -718,7 +712,6 @@ static void usa49wg_indat_callback(struct urb *urb)
         int                     i, len, x, err;
         struct usb_serial       *serial;
         struct usb_serial_port  *port;
-        struct tty_struct       *tty;
         unsigned char           *data = urb->transfer_buffer;
         int status = urb->status;
 
@@ -743,7 +736,6 @@ static void usa49wg_indat_callback(struct urb *urb)
                                 return;
                         }
                         port = serial->port[data[i++]];
-                        tty = tty_port_tty_get(&port->port);
                         len = data[i++];
 
                         /* 0x80 bit is error flag */
@@ -751,7 +743,8 @@ static void usa49wg_indat_callback(struct urb *urb)
                                 /* no error on any byte */
                                 i++;
                                 for (x = 1; x < len ; ++x)
-                                        tty_insert_flip_char(tty, data[i++], 0);
+                                        tty_insert_flip_char(&port->port,
+                                                        data[i++], 0);
                         } else {
                                 /*
                                  * some bytes had errors, every byte has status
@@ -765,13 +758,12 @@ static void usa49wg_indat_callback(struct urb *urb)
                                         if (stat & RXERROR_PARITY)
                                                 flag |= TTY_PARITY;
                                         /* XXX should handle break (0x10) */
-                                        tty_insert_flip_char(tty,
+                                        tty_insert_flip_char(&port->port,
                                                         data[i+1], flag);
                                         i += 2;
                                 }
                         }
-                        tty_flip_buffer_push(tty);
-                        tty_kref_put(tty);
+                        tty_flip_buffer_push(&port->port);
                 }
         }
 
@@ -792,7 +784,6 @@ static void usa90_indat_callback(struct urb *urb)
         int                     endpoint;
         struct usb_serial_port  *port;
         struct keyspan_port_private             *p_priv;
-        struct tty_struct       *tty;
         unsigned char           *data = urb->transfer_buffer;
         int status = urb->status;
 
@@ -808,12 +799,12 @@ static void usa90_indat_callback(struct urb *urb)
         p_priv = usb_get_serial_port_data(port);
 
         if (urb->actual_length) {
-                tty = tty_port_tty_get(&port->port);
                 /* if current mode is DMA, looks like usa28 format
                    otherwise looks like usa26 data format */
 
                 if (p_priv->baud > 57600)
-                        tty_insert_flip_string(tty, data, urb->actual_length);
+                        tty_insert_flip_string(&port->port, data,
+                                        urb->actual_length);
                 else {
                         /* 0x80 bit is error flag */
                         if ((data[0] & 0x80) == 0) {
@@ -824,8 +815,8 @@ static void usa90_indat_callback(struct urb *urb)
                                 else
                                         err = 0;
                                 for (i = 1; i < urb->actual_length ; ++i)
-                                        tty_insert_flip_char(tty, data[i],
-                                                                        err);
+                                        tty_insert_flip_char(&port->port,
+                                                        data[i], err);
                         }  else {
                         /* some bytes had errors, every byte has status */
                                 dev_dbg(&port->dev, "%s - RX error!!!!\n", __func__);
@@ -838,13 +829,12 @@ static void usa90_indat_callback(struct urb *urb)
                                         if (stat & RXERROR_PARITY)
                                                 flag |= TTY_PARITY;
                                         /* XXX should handle break (0x10) */
-                                        tty_insert_flip_char(tty, data[i+1],
-                                                                        flag);
+                                        tty_insert_flip_char(&port->port,
+                                                        data[i+1], flag);
                                 }
                         }
                 }
-                tty_flip_buffer_push(tty);
-                tty_kref_put(tty);
+                tty_flip_buffer_push(&port->port);
         }
 
         /* Resubmit urb so we continue receiving */
diff --git a/drivers/usb/serial/keyspan_pda.c b/drivers/usb/serial/keyspan_pda.c
index 41b01092af07..3b17d5d13dc8 100644
--- a/drivers/usb/serial/keyspan_pda.c
+++ b/drivers/usb/serial/keyspan_pda.c
@@ -138,7 +138,6 @@ static void keyspan_pda_request_unthrottle(struct work_struct *work)
 static void keyspan_pda_rx_interrupt(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
-        struct tty_struct *tty;
         unsigned char *data = urb->transfer_buffer;
         int retval;
         int status = urb->status;
@@ -163,14 +162,12 @@ static void keyspan_pda_rx_interrupt(struct urb *urb)
         /* see if the message is data or a status interrupt */
         switch (data[0]) {
         case 0:
-                tty = tty_port_tty_get(&port->port);
                  /* rest of message is rx data */
-                if (tty && urb->actual_length) {
-                        tty_insert_flip_string(tty, data + 1,
+                if (urb->actual_length) {
+                        tty_insert_flip_string(&port->port, data + 1,
                                                 urb->actual_length - 1);
-                        tty_flip_buffer_push(tty);
+                        tty_flip_buffer_push(&port->port);
                 }
-                tty_kref_put(tty);
                 break;
         case 1:
                 /* status interrupt */
diff --git a/drivers/usb/serial/kl5kusb105.c b/drivers/usb/serial/kl5kusb105.c
index fc9e14a1e9b3..769d910ae0a5 100644
--- a/drivers/usb/serial/kl5kusb105.c
+++ b/drivers/usb/serial/kl5kusb105.c
@@ -389,7 +389,6 @@ static void klsi_105_process_read_urb(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         unsigned char *data = urb->transfer_buffer;
-        struct tty_struct *tty;
         unsigned len;
 
         /* empty urbs seem to happen, we ignore them */
@@ -401,19 +400,14 @@ static void klsi_105_process_read_urb(struct urb *urb)
                 return;
         }
 
-        tty = tty_port_tty_get(&port->port);
-        if (!tty)
-                return;
-
         len = get_unaligned_le16(data);
         if (len > urb->actual_length - KLSI_HDR_LEN) {
                 dev_dbg(&port->dev, "%s - packet length mismatch\n", __func__);
                 len = urb->actual_length - KLSI_HDR_LEN;
         }
 
-        tty_insert_flip_string(tty, data + KLSI_HDR_LEN, len);
-        tty_flip_buffer_push(tty);
-        tty_kref_put(tty);
+        tty_insert_flip_string(&port->port, data + KLSI_HDR_LEN, len);
+        tty_flip_buffer_push(&port->port);
 }
 
 static void klsi_105_set_termios(struct tty_struct *tty,
diff --git a/drivers/usb/serial/kobil_sct.c b/drivers/usb/serial/kobil_sct.c
index b747ba615d0b..903d938e174b 100644
--- a/drivers/usb/serial/kobil_sct.c
+++ b/drivers/usb/serial/kobil_sct.c
@@ -324,7 +324,6 @@ static void kobil_read_int_callback(struct urb *urb)
 {
         int result;
         struct usb_serial_port *port = urb->context;
-        struct tty_struct *tty;
         unsigned char *data = urb->transfer_buffer;
         int status = urb->status;
 
@@ -333,8 +332,7 @@ static void kobil_read_int_callback(struct urb *urb)
                 return;
         }
 
-        tty = tty_port_tty_get(&port->port);
-        if (tty && urb->actual_length) {
+        if (urb->actual_length) {
 
                 /* BEGIN DEBUG */
                 /*
@@ -353,10 +351,9 @@ static void kobil_read_int_callback(struct urb *urb)
                 */
                 /* END DEBUG */
 
-                tty_insert_flip_string(tty, data, urb->actual_length);
-                tty_flip_buffer_push(tty);
+                tty_insert_flip_string(&port->port, data, urb->actual_length);
+                tty_flip_buffer_push(&port->port);
         }
-        tty_kref_put(tty);
 
         result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
         dev_dbg(&port->dev, "%s - Send read URB returns: %i\n", __func__, result);
diff --git a/drivers/usb/serial/mct_u232.c b/drivers/usb/serial/mct_u232.c
index d9c86516fed4..a64d420f687b 100644
--- a/drivers/usb/serial/mct_u232.c
+++ b/drivers/usb/serial/mct_u232.c
@@ -527,7 +527,6 @@ static void mct_u232_read_int_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         struct mct_u232_private *priv = usb_get_serial_port_data(port);
-        struct tty_struct *tty;
         unsigned char *data = urb->transfer_buffer;
         int retval;
         int status = urb->status;
@@ -557,13 +556,9 @@ static void mct_u232_read_int_callback(struct urb *urb)
          */
         if (urb->transfer_buffer_length > 2) {
                 if (urb->actual_length) {
-                        tty = tty_port_tty_get(&port->port);
-                        if (tty) {
-                                tty_insert_flip_string(tty, data,
-                                                urb->actual_length);
-                                tty_flip_buffer_push(tty);
-                        }
-                        tty_kref_put(tty);
+                        tty_insert_flip_string(&port->port, data,
+                                        urb->actual_length);
+                        tty_flip_buffer_push(&port->port);
                 }
                 goto exit;
         }
diff --git a/drivers/usb/serial/metro-usb.c b/drivers/usb/serial/metro-usb.c
index 3d258448c29a..bf3c7a23553e 100644
--- a/drivers/usb/serial/metro-usb.c
+++ b/drivers/usb/serial/metro-usb.c
@@ -95,7 +95,6 @@ static void metrousb_read_int_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         struct metrousb_private *metro_priv = usb_get_serial_port_data(port);
-        struct tty_struct *tty;
         unsigned char *data = urb->transfer_buffer;
         int throttled = 0;
         int result = 0;
@@ -124,15 +123,13 @@ static void metrousb_read_int_callback(struct urb *urb)
 
 
         /* Set the data read from the usb port into the serial port buffer. */
-        tty = tty_port_tty_get(&port->port);
-        if (tty && urb->actual_length) {
+        if (urb->actual_length) {
                 /* Loop through the data copying each byte to the tty layer. */
-                tty_insert_flip_string(tty, data, urb->actual_length);
+                tty_insert_flip_string(&port->port, data, urb->actual_length);
 
                 /* Force the data to the tty layer. */
-                tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(&port->port);
         }
-        tty_kref_put(tty);
 
         /* Set any port variables. */
         spin_lock_irqsave(&metro_priv->lock, flags);
diff --git a/drivers/usb/serial/mos7720.c b/drivers/usb/serial/mos7720.c
index f57a6b1fe787..e0ebec3b5d6a 100644
--- a/drivers/usb/serial/mos7720.c
+++ b/drivers/usb/serial/mos7720.c
@@ -899,7 +899,6 @@ static void mos7720_bulk_in_callback(struct urb *urb)
         int retval;
         unsigned char *data ;
         struct usb_serial_port *port;
-        struct tty_struct *tty;
         int status = urb->status;
 
         if (status) {
@@ -913,12 +912,10 @@ static void mos7720_bulk_in_callback(struct urb *urb)
 
         data = urb->transfer_buffer;
 
-        tty = tty_port_tty_get(&port->port);
-        if (tty && urb->actual_length) {
-                tty_insert_flip_string(tty, data, urb->actual_length);
-                tty_flip_buffer_push(tty);
+        if (urb->actual_length) {
+                tty_insert_flip_string(&port->port, data, urb->actual_length);
+                tty_flip_buffer_push(&port->port);
         }
-        tty_kref_put(tty);
 
         if (port->read_urb->status != -EINPROGRESS) {
                 retval = usb_submit_urb(port->read_urb, GFP_ATOMIC);
diff --git a/drivers/usb/serial/mos7840.c b/drivers/usb/serial/mos7840.c
index 66d9e088d9d9..809fb329eca5 100644
--- a/drivers/usb/serial/mos7840.c
+++ b/drivers/usb/serial/mos7840.c
@@ -744,7 +744,6 @@ static void mos7840_bulk_in_callback(struct urb *urb)
         struct usb_serial *serial;
         struct usb_serial_port *port;
         struct moschip_port *mos7840_port;
-        struct tty_struct *tty;
         int status = urb->status;
 
         mos7840_port = urb->context;
@@ -773,12 +772,9 @@ static void mos7840_bulk_in_callback(struct urb *urb)
         usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
 
         if (urb->actual_length) {
-                tty = tty_port_tty_get(&mos7840_port->port->port);
-                if (tty) {
-                        tty_insert_flip_string(tty, data, urb->actual_length);
-                        tty_flip_buffer_push(tty);
-                        tty_kref_put(tty);
-                }
+                struct tty_port *tport = &mos7840_port->port->port;
+                tty_insert_flip_string(tport, data, urb->actual_length);
+                tty_flip_buffer_push(tport);
                 mos7840_port->icount.rx += urb->actual_length;
                 smp_wmb();
                 dev_dbg(&port->dev, "mos7840_port->icount.rx is %d:\n", mos7840_port->icount.rx);
diff --git a/drivers/usb/serial/navman.c b/drivers/usb/serial/navman.c
index 1566f8f500ae..38725fc8c2c8 100644
--- a/drivers/usb/serial/navman.c
+++ b/drivers/usb/serial/navman.c
@@ -32,7 +32,6 @@ static void navman_read_int_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         unsigned char *data = urb->transfer_buffer;
-        struct tty_struct *tty;
         int status = urb->status;
         int result;
 
@@ -55,12 +54,10 @@ static void navman_read_int_callback(struct urb *urb)
 
         usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
 
-        tty = tty_port_tty_get(&port->port);
-        if (tty && urb->actual_length) {
-                tty_insert_flip_string(tty, data, urb->actual_length);
-                tty_flip_buffer_push(tty);
+        if (urb->actual_length) {
+                tty_insert_flip_string(&port->port, data, urb->actual_length);
+                tty_flip_buffer_push(&port->port);
         }
-        tty_kref_put(tty);
 
 exit:
         result = usb_submit_urb(urb, GFP_ATOMIC);
diff --git a/drivers/usb/serial/omninet.c b/drivers/usb/serial/omninet.c
index 7818af931a48..1e1cafe287e4 100644
--- a/drivers/usb/serial/omninet.c
+++ b/drivers/usb/serial/omninet.c
@@ -174,13 +174,9 @@ static void omninet_read_bulk_callback(struct urb *urb)
         }
 
         if (urb->actual_length && header->oh_len) {
-                struct tty_struct *tty = tty_port_tty_get(&port->port);
-                if (tty) {
-                        tty_insert_flip_string(tty, data + OMNINET_DATAOFFSET,
-                                                        header->oh_len);
-                        tty_flip_buffer_push(tty);
-                        tty_kref_put(tty);
-                }
+                tty_insert_flip_string(&port->port, data + OMNINET_DATAOFFSET,
+                                header->oh_len);
+                tty_flip_buffer_push(&port->port);
         }
 
         /* Continue trying to always read  */
diff --git a/drivers/usb/serial/opticon.c b/drivers/usb/serial/opticon.c
index c6bfb83efb1e..e13e1a4d3e1e 100644
--- a/drivers/usb/serial/opticon.c
+++ b/drivers/usb/serial/opticon.c
@@ -51,15 +51,8 @@ struct opticon_private {
 static void opticon_process_data_packet(struct usb_serial_port *port,
                                         const unsigned char *buf, size_t len)
 {
-        struct tty_struct *tty;
-
-        tty = tty_port_tty_get(&port->port);
-        if (!tty)
-                return;
-
-        tty_insert_flip_string(tty, buf, len);
-        tty_flip_buffer_push(tty);
-        tty_kref_put(tty);
+        tty_insert_flip_string(&port->port, buf, len);
+        tty_flip_buffer_push(&port->port);
 }
 
 static void opticon_process_status_packet(struct usb_serial_port *port,
diff --git a/drivers/usb/serial/oti6858.c b/drivers/usb/serial/oti6858.c
index d217fd6ee43f..a958fd41b5b3 100644
--- a/drivers/usb/serial/oti6858.c
+++ b/drivers/usb/serial/oti6858.c
@@ -820,7 +820,6 @@ static void oti6858_read_bulk_callback(struct urb *urb)
 {
         struct usb_serial_port *port =  urb->context;
         struct oti6858_private *priv = usb_get_serial_port_data(port);
-        struct tty_struct *tty;
         unsigned char *data = urb->transfer_buffer;
         unsigned long flags;
         int status = urb->status;
@@ -835,12 +834,10 @@ static void oti6858_read_bulk_callback(struct urb *urb)
                 return;
         }
 
-        tty = tty_port_tty_get(&port->port);
-        if (tty != NULL && urb->actual_length > 0) {
-                tty_insert_flip_string(tty, data, urb->actual_length);
-                tty_flip_buffer_push(tty);
+        if (urb->actual_length > 0) {
+                tty_insert_flip_string(&port->port, data, urb->actual_length);
+                tty_flip_buffer_push(&port->port);
         }
-        tty_kref_put(tty);
 
         /* schedule the interrupt urb */
         result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index 600241901361..54adc9125e5c 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -772,7 +772,6 @@ static void pl2303_process_read_urb(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         struct pl2303_private *priv = usb_get_serial_port_data(port);
-        struct tty_struct *tty;
         unsigned char *data = urb->transfer_buffer;
         char tty_flag = TTY_NORMAL;
         unsigned long flags;
@@ -789,10 +788,6 @@ static void pl2303_process_read_urb(struct urb *urb)
         if (!urb->actual_length)
                 return;
 
-        tty = tty_port_tty_get(&port->port);
-        if (!tty)
-                return;
-
         /* break takes precedence over parity, */
         /* which takes precedence over framing errors */
         if (line_status & UART_BREAK_ERROR)
@@ -805,19 +800,19 @@ static void pl2303_process_read_urb(struct urb *urb)
 
         /* overrun is special, not associated with a char */
         if (line_status & UART_OVERRUN_ERROR)
-                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
 
         if (port->port.console && port->sysrq) {
                 for (i = 0; i < urb->actual_length; ++i)
                         if (!usb_serial_handle_sysrq_char(port, data[i]))
-                                tty_insert_flip_char(tty, data[i], tty_flag);
+                                tty_insert_flip_char(&port->port, data[i],
+                                                tty_flag);
         } else {
-                tty_insert_flip_string_fixed_flag(tty, data, tty_flag,
+                tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
                                                         urb->actual_length);
         }
 
-        tty_flip_buffer_push(tty);
-        tty_kref_put(tty);
+        tty_flip_buffer_push(&port->port);
 }
 
 /* All of the device info needed for the PL2303 SIO serial converter */
diff --git a/drivers/usb/serial/quatech2.c b/drivers/usb/serial/quatech2.c
index a8d5110d4cc5..00e6c9bac8a3 100644
--- a/drivers/usb/serial/quatech2.c
+++ b/drivers/usb/serial/quatech2.c
@@ -609,7 +609,6 @@ void qt2_process_read_urb(struct urb *urb)
         struct qt2_serial_private *serial_priv;
         struct usb_serial_port *port;
         struct qt2_port_private *port_priv;
-        struct tty_struct *tty;
         bool escapeflag;
         unsigned char *ch;
         int i;
@@ -620,15 +619,11 @@ void qt2_process_read_urb(struct urb *urb)
                 return;
 
         ch = urb->transfer_buffer;
-        tty = NULL;
         serial = urb->context;
         serial_priv = usb_get_serial_data(serial);
         port = serial->port[serial_priv->current_port];
         port_priv = usb_get_serial_port_data(port);
 
-        if (port_priv->is_open)
-                tty = tty_port_tty_get(&port->port);
-
         for (i = 0; i < urb->actual_length; i++) {
                 ch = (unsigned char *)urb->transfer_buffer + i;
                 if ((i <= (len - 3)) &&
@@ -666,10 +661,7 @@ void qt2_process_read_urb(struct urb *urb)
                                                  __func__);
                                         break;
                                 }
-                                if (tty) {
-                                        tty_flip_buffer_push(tty);
-                                        tty_kref_put(tty);
-                                }
+                                tty_flip_buffer_push(&port->port);
 
                                 newport = *(ch + 3);
 
@@ -683,10 +675,6 @@ void qt2_process_read_urb(struct urb *urb)
                                 serial_priv->current_port = newport;
                                 port = serial->port[serial_priv->current_port];
                                 port_priv = usb_get_serial_port_data(port);
-                                if (port_priv->is_open)
-                                        tty = tty_port_tty_get(&port->port);
-                                else
-                                        tty = NULL;
                                 i += 3;
                                 escapeflag = true;
                                 break;
@@ -697,8 +685,8 @@ void qt2_process_read_urb(struct urb *urb)
                                 escapeflag = true;
                                 break;
                         case QT2_CONTROL_ESCAPE:
-                                tty_buffer_request_room(tty, 2);
-                                tty_insert_flip_string(tty, ch, 2);
+                                tty_buffer_request_room(&port->port, 2);
+                                tty_insert_flip_string(&port->port, ch, 2);
                                 i += 2;
                                 escapeflag = true;
                                 break;
@@ -712,16 +700,11 @@ void qt2_process_read_urb(struct urb *urb)
                                 continue;
                 }
 
-                if (tty) {
-                        tty_buffer_request_room(tty, 1);
-                        tty_insert_flip_string(tty, ch, 1);
-                }
+                tty_buffer_request_room(&port->port, 1);
+                tty_insert_flip_string(&port->port, ch, 1);
         }
 
-        if (tty) {
-                tty_flip_buffer_push(tty);
-                tty_kref_put(tty);
-        }
+        tty_flip_buffer_push(&port->port);
 }
 
 static void qt2_write_bulk_callback(struct urb *urb)
diff --git a/drivers/usb/serial/safe_serial.c b/drivers/usb/serial/safe_serial.c
index c949ce6ef0c6..21cd7bf2a8cc 100644
--- a/drivers/usb/serial/safe_serial.c
+++ b/drivers/usb/serial/safe_serial.c
@@ -207,38 +207,31 @@ static void safe_process_read_urb(struct urb *urb)
         unsigned char *data = urb->transfer_buffer;
         unsigned char length = urb->actual_length;
         int actual_length;
-        struct tty_struct *tty;
         __u16 fcs;
 
         if (!length)
                 return;
 
-        tty = tty_port_tty_get(&port->port);
-        if (!tty)
-                return;
-
         if (!safe)
                 goto out;
 
         fcs = fcs_compute10(data, length, CRC10_INITFCS);
         if (fcs) {
                 dev_err(&port->dev, "%s - bad CRC %x\n", __func__, fcs);
-                goto err;
+                return;
         }
 
         actual_length = data[length - 2] >> 2;
         if (actual_length > (length - 2)) {
                 dev_err(&port->dev, "%s - inconsistent lengths %d:%d\n",
                                 __func__, actual_length, length);
-                goto err;
+                return;
         }
         dev_info(&urb->dev->dev, "%s - actual: %d\n", __func__, actual_length);
         length = actual_length;
 out:
-        tty_insert_flip_string(tty, data, length);
-        tty_flip_buffer_push(tty);
-err:
-        tty_kref_put(tty);
+        tty_insert_flip_string(&port->port, data, length);
+        tty_flip_buffer_push(&port->port);
 }
 
 static int safe_prepare_write_buffer(struct usb_serial_port *port,
diff --git a/drivers/usb/serial/sierra.c b/drivers/usb/serial/sierra.c
index d4426c038c32..c13f6e747748 100644
--- a/drivers/usb/serial/sierra.c
+++ b/drivers/usb/serial/sierra.c
@@ -569,7 +569,6 @@ static void sierra_indat_callback(struct urb *urb)
         int err;
         int endpoint;
         struct usb_serial_port *port;
-        struct tty_struct *tty;
         unsigned char *data = urb->transfer_buffer;
         int status = urb->status;
 
@@ -581,16 +580,12 @@ static void sierra_indat_callback(struct urb *urb)
                         " endpoint %02x\n", __func__, status, endpoint);
         } else {
                 if (urb->actual_length) {
-                        tty = tty_port_tty_get(&port->port);
-                        if (tty) {
-                                tty_insert_flip_string(tty, data,
-                                        urb->actual_length);
-                                tty_flip_buffer_push(tty);
-
-                                tty_kref_put(tty);
-                                usb_serial_debug_data(&port->dev, __func__,
-                                                      urb->actual_length, data);
-                        }
+                        tty_insert_flip_string(&port->port, data,
+                                urb->actual_length);
+                        tty_flip_buffer_push(&port->port);
+
+                        usb_serial_debug_data(&port->dev, __func__,
+                                              urb->actual_length, data);
                 } else {
                         dev_dbg(&port->dev, "%s: empty read urb"
                                 " received\n", __func__);
diff --git a/drivers/usb/serial/spcp8x5.c b/drivers/usb/serial/spcp8x5.c
index a42536af1256..91ff8e3bddbd 100644
--- a/drivers/usb/serial/spcp8x5.c
+++ b/drivers/usb/serial/spcp8x5.c
@@ -462,7 +462,6 @@ static void spcp8x5_process_read_urb(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         struct spcp8x5_private *priv = usb_get_serial_port_data(port);
-        struct tty_struct *tty;
         unsigned char *data = urb->transfer_buffer;
         unsigned long flags;
         u8 status;
@@ -481,9 +480,6 @@ static void spcp8x5_process_read_urb(struct urb *urb)
         if (!urb->actual_length)
                 return;
 
-        tty = tty_port_tty_get(&port->port);
-        if (!tty)
-                return;
 
         if (status & UART_STATE_TRANSIENT_MASK) {
                 /* break takes precedence over parity, which takes precedence
@@ -498,17 +494,21 @@ static void spcp8x5_process_read_urb(struct urb *urb)
 
                 /* overrun is special, not associated with a char */
                 if (status & UART_OVERRUN_ERROR)
-                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
-
-                if (status & UART_DCD)
-                        usb_serial_handle_dcd_change(port, tty,
-                                   priv->line_status & MSR_STATUS_LINE_DCD);
+                        tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
+
+                if (status & UART_DCD) {
+                        struct tty_struct *tty = tty_port_tty_get(&port->port);
+                        if (tty) {
+                                usb_serial_handle_dcd_change(port, tty,
+                                       priv->line_status & MSR_STATUS_LINE_DCD);
+                                tty_kref_put(tty);
+                        }
+                }
         }
 
-        tty_insert_flip_string_fixed_flag(tty, data, tty_flag,
+        tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
                                                         urb->actual_length);
-        tty_flip_buffer_push(tty);
-        tty_kref_put(tty);
+        tty_flip_buffer_push(&port->port);
 }
 
 static int spcp8x5_wait_modem_info(struct usb_serial_port *port,
diff --git a/drivers/usb/serial/ssu100.c b/drivers/usb/serial/ssu100.c
index d938396171e8..b57cf841c5b6 100644
--- a/drivers/usb/serial/ssu100.c
+++ b/drivers/usb/serial/ssu100.c
@@ -579,8 +579,7 @@ static void ssu100_update_lsr(struct usb_serial_port *port, u8 lsr,
 
 }
 
-static int ssu100_process_packet(struct urb *urb,
-                                 struct tty_struct *tty)
+static void ssu100_process_read_urb(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         char *packet = (char *)urb->transfer_buffer;
@@ -595,7 +594,8 @@ static int ssu100_process_packet(struct urb *urb,
                 if (packet[2] == 0x00) {
                         ssu100_update_lsr(port, packet[3], &flag);
                         if (flag == TTY_OVERRUN)
-                                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                                tty_insert_flip_char(&port->port, 0,
+                                                TTY_OVERRUN);
                 }
                 if (packet[2] == 0x01)
                         ssu100_update_msr(port, packet[3]);
@@ -606,34 +606,17 @@ static int ssu100_process_packet(struct urb *urb,
                 ch = packet;
 
         if (!len)
-                return 0;       /* status only */
+                return; /* status only */
 
         if (port->port.console && port->sysrq) {
                 for (i = 0; i < len; i++, ch++) {
                         if (!usb_serial_handle_sysrq_char(port, *ch))
-                                tty_insert_flip_char(tty, *ch, flag);
+                                tty_insert_flip_char(&port->port, *ch, flag);
                 }
         } else
-                tty_insert_flip_string_fixed_flag(tty, ch, flag, len);
-
-        return len;
-}
-
-static void ssu100_process_read_urb(struct urb *urb)
-{
-        struct usb_serial_port *port = urb->context;
-        struct tty_struct *tty;
-        int count;
-
-        tty = tty_port_tty_get(&port->port);
-        if (!tty)
-                return;
-
-        count = ssu100_process_packet(urb, tty);
+                tty_insert_flip_string_fixed_flag(&port->port, ch, flag, len);
 
-        if (count)
-                tty_flip_buffer_push(tty);
-        tty_kref_put(tty);
+        tty_flip_buffer_push(&port->port);
 }
 
 static struct usb_serial_driver ssu100_device = {
diff --git a/drivers/usb/serial/symbolserial.c b/drivers/usb/serial/symbolserial.c
index 701fffa8431f..be05e6caf9a3 100644
--- a/drivers/usb/serial/symbolserial.c
+++ b/drivers/usb/serial/symbolserial.c
@@ -48,7 +48,6 @@ static void symbol_int_callback(struct urb *urb)
         unsigned char *data = urb->transfer_buffer;
         struct usb_serial_port *port = priv->port;
         int status = urb->status;
-        struct tty_struct *tty;
         int result;
         int data_length;
 
@@ -82,12 +81,8 @@ static void symbol_int_callback(struct urb *urb)
                  * we pretty much just ignore the size and send everything
                  * else to the tty layer.
                  */
-                tty = tty_port_tty_get(&port->port);
-                if (tty) {
-                        tty_insert_flip_string(tty, &data[1], data_length);
-                        tty_flip_buffer_push(tty);
-                        tty_kref_put(tty);
-                }
+                tty_insert_flip_string(&port->port, &data[1], data_length);
+                tty_flip_buffer_push(&port->port);
         } else {
                 dev_dbg(&priv->udev->dev,
                         "Improper amount of data received from the device, "
diff --git a/drivers/usb/serial/ti_usb_3410_5052.c b/drivers/usb/serial/ti_usb_3410_5052.c
index f2530d2ef3c4..39cb9b807c3c 100644
--- a/drivers/usb/serial/ti_usb_3410_5052.c
+++ b/drivers/usb/serial/ti_usb_3410_5052.c
@@ -121,8 +121,8 @@ static void ti_interrupt_callback(struct urb *urb);
 static void ti_bulk_in_callback(struct urb *urb);
 static void ti_bulk_out_callback(struct urb *urb);
 
-static void ti_recv(struct device *dev, struct tty_struct *tty,
-        unsigned char *data, int length);
+static void ti_recv(struct usb_serial_port *port, unsigned char *data,
+                int length);
 static void ti_send(struct ti_port *tport);
 static int ti_set_mcr(struct ti_port *tport, unsigned int mcr);
 static int ti_get_lsr(struct ti_port *tport);
@@ -1118,7 +1118,6 @@ static void ti_bulk_in_callback(struct urb *urb)
         struct device *dev = &urb->dev->dev;
         int status = urb->status;
         int retval = 0;
-        struct tty_struct *tty;
 
         switch (status) {
         case 0:
@@ -1145,24 +1144,18 @@ static void ti_bulk_in_callback(struct urb *urb)
                 return;
         }
 
-        tty = tty_port_tty_get(&port->port);
-        if (tty) {
-                if (urb->actual_length) {
-                        usb_serial_debug_data(dev, __func__, urb->actual_length,
-                                              urb->transfer_buffer);
+        if (urb->actual_length) {
+                usb_serial_debug_data(dev, __func__, urb->actual_length,
+                                      urb->transfer_buffer);
 
-                        if (!tport->tp_is_open)
-                                dev_dbg(dev, "%s - port closed, dropping data\n",
-                                        __func__);
-                        else
-                                ti_recv(&urb->dev->dev, tty,
-                                                urb->transfer_buffer,
-                                                urb->actual_length);
-                        spin_lock(&tport->tp_lock);
-                        tport->tp_icount.rx += urb->actual_length;
-                        spin_unlock(&tport->tp_lock);
-                }
-                tty_kref_put(tty);
+                if (!tport->tp_is_open)
+                        dev_dbg(dev, "%s - port closed, dropping data\n",
+                                __func__);
+                else
+                        ti_recv(port, urb->transfer_buffer, urb->actual_length);
+                spin_lock(&tport->tp_lock);
+                tport->tp_icount.rx += urb->actual_length;
+                spin_unlock(&tport->tp_lock);
         }
 
 exit:
@@ -1210,24 +1203,23 @@ static void ti_bulk_out_callback(struct urb *urb)
 }
 
 
-static void ti_recv(struct device *dev, struct tty_struct *tty,
-        unsigned char *data, int length)
+static void ti_recv(struct usb_serial_port *port, unsigned char *data,
+                int length)
 {
         int cnt;
 
         do {
-                cnt = tty_insert_flip_string(tty, data, length);
+                cnt = tty_insert_flip_string(&port->port, data, length);
                 if (cnt < length) {
-                        dev_err(dev, "%s - dropping data, %d bytes lost\n",
+                        dev_err(&port->dev, "%s - dropping data, %d bytes lost\n",
                                                 __func__, length - cnt);
                         if (cnt == 0)
                                 break;
                 }
-                tty_flip_buffer_push(tty);
+                tty_flip_buffer_push(&port->port);
                 data += cnt;
                 length -= cnt;
         } while (length > 0);
-
 }
 
 
diff --git a/drivers/usb/serial/usb_wwan.c b/drivers/usb/serial/usb_wwan.c
index 1355a6cd4508..571965aa1cc0 100644
--- a/drivers/usb/serial/usb_wwan.c
+++ b/drivers/usb/serial/usb_wwan.c
@@ -273,7 +273,6 @@ static void usb_wwan_indat_callback(struct urb *urb)
         int err;
         int endpoint;
         struct usb_serial_port *port;
-        struct tty_struct *tty;
         struct device *dev;
         unsigned char *data = urb->transfer_buffer;
         int status = urb->status;
@@ -286,16 +285,12 @@ static void usb_wwan_indat_callback(struct urb *urb)
                 dev_dbg(dev, "%s: nonzero status: %d on endpoint %02x.\n",
                         __func__, status, endpoint);
         } else {
-                tty = tty_port_tty_get(&port->port);
-                if (tty) {
-                        if (urb->actual_length) {
-                                tty_insert_flip_string(tty, data,
-                                                urb->actual_length);
-                                tty_flip_buffer_push(tty);
-                        } else
-                                dev_dbg(dev, "%s: empty read urb received\n", __func__);
-                        tty_kref_put(tty);
-                }
+                if (urb->actual_length) {
+                        tty_insert_flip_string(&port->port, data,
+                                        urb->actual_length);
+                        tty_flip_buffer_push(&port->port);
+                } else
+                        dev_dbg(dev, "%s: empty read urb received\n", __func__);
 
                 /* Resubmit urb so we continue receiving */
                 err = usb_submit_urb(urb, GFP_ATOMIC);
diff --git a/drivers/video/auo_k190x.c b/drivers/video/auo_k190x.c
index 97f79356141e..53846cb534d4 100644
--- a/drivers/video/auo_k190x.c
+++ b/drivers/video/auo_k190x.c
@@ -11,6 +11,7 @@
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/gpio.h>
+#include <linux/platform_device.h>
 #include <linux/pm_runtime.h>
 #include <linux/fb.h>
 #include <linux/delay.h>
diff --git a/drivers/video/backlight/ot200_bl.c b/drivers/video/backlight/ot200_bl.c
index 469cf0f109d2..fdbb6ee5027c 100644
--- a/drivers/video/backlight/ot200_bl.c
+++ b/drivers/video/backlight/ot200_bl.c
@@ -14,6 +14,7 @@
 #include <linux/fb.h>
 #include <linux/backlight.h>
 #include <linux/gpio.h>
+#include <linux/platform_device.h>
 #include <linux/cs5535.h>
 
 static struct cs5535_mfgpt_timer *pwm_timer;
diff --git a/drivers/video/clps711xfb.c b/drivers/video/clps711xfb.c
index 5a7af0deced2..f00980607b8f 100644
--- a/drivers/video/clps711xfb.c
+++ b/drivers/video/clps711xfb.c
@@ -26,6 +26,7 @@
 #include <linux/fb.h>
 #include <linux/init.h>
 #include <linux/delay.h>
+#include <linux/platform_device.h>
 
 #include <mach/hardware.h>
 #include <asm/mach-types.h>
diff --git a/drivers/video/exynos/exynos_mipi_dsi_common.c b/drivers/video/exynos/exynos_mipi_dsi_common.c
index 3cd29a4fc10a..c70cb8926df6 100644
--- a/drivers/video/exynos/exynos_mipi_dsi_common.c
+++ b/drivers/video/exynos/exynos_mipi_dsi_common.c
@@ -25,6 +25,7 @@
 #include <linux/io.h>
 #include <linux/memory.h>
 #include <linux/delay.h>
+#include <linux/irqreturn.h>
 #include <linux/kthread.h>
 
 #include <video/mipi_display.h>
diff --git a/drivers/video/exynos/exynos_mipi_dsi_lowlevel.c b/drivers/video/exynos/exynos_mipi_dsi_lowlevel.c
index 0ef38ce72af6..95cb99a1fe2d 100644
--- a/drivers/video/exynos/exynos_mipi_dsi_lowlevel.c
+++ b/drivers/video/exynos/exynos_mipi_dsi_lowlevel.c
@@ -21,6 +21,7 @@
 #include <linux/fs.h>
 #include <linux/mm.h>
 #include <linux/ctype.h>
+#include <linux/platform_device.h>
 #include <linux/io.h>
 
 #include <video/exynos_mipi_dsim.h>