Merge git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/tty-2.6

* git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/tty-2.6: (36 commits)
  jsm: fixing error if the driver fails to load
  jsm: removing the uart structure and filename on error
  tty: Add a new VT mode which is like VT_PROCESS but doesn't require a VT_RELDISP ioctl call
  tty: Keep the default buffering to sub-page units
  tty: Fix up char drivers request_room usage
  tty: Fix the ldisc hangup race
  serial: timberdale: Remove dependancies
  nozomi: Tidy up the PCI table
  nozomi: Fix mutex handling
  nozomi: Add tty_port usage
  sdio_uart: Use kfifo instead of the messy circ stuff
  serial: bcm63xx_uart: allow more than one uart to be registered.
  serial: bcm63xx_uart: don't use kfree() on non kmalloced area.
  serial: bfin_5xx: pull in linux/io.h for ioremap prototypes
  serial: bfin_5xx: kgdboc should accept gdb break only when it is active
  serial: bfin_5xx: need to disable DMA TX interrupt too
  serial: bfin_5xx: remove useless gpio handling with hard flow control
  Char: synclink, remove unnecessary checks
  tty: declare MODULE_FIRMWARE in various drivers
  ip2: Add module parameter.
  ...

36 files changed, 978 insertions, 652 deletions

diff --git a/drivers/char/cyclades.c b/drivers/char/cyclades.c
index 4254457d3911..b861c08263a4 100644
--- a/drivers/char/cyclades.c
+++ b/drivers/char/cyclades.c
@@ -158,13 +158,11 @@ static unsigned int cy_isa_addresses[] = {
 
 #define NR_ISA_ADDRS ARRAY_SIZE(cy_isa_addresses)
 
-#ifdef MODULE
 static long maddr[NR_CARDS];
 static int irq[NR_CARDS];
 
 module_param_array(maddr, long, NULL, 0);
 module_param_array(irq, int, NULL, 0);
-#endif
 
 #endif                          /* CONFIG_ISA */
 
@@ -598,12 +596,6 @@ static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip,
         save_car = readb(base_addr + (CyCAR << index));
         cy_writeb(base_addr + (CyCAR << index), save_xir);
 
-        /* validate the port# (as configured and open) */
-        if (channel + chip * 4 >= cinfo->nports) {
-                cy_writeb(base_addr + (CySRER << index),
-                          readb(base_addr + (CySRER << index)) & ~CyTxRdy);
-                goto end;
-        }
         info = &cinfo->ports[channel + chip * 4];
         tty = tty_port_tty_get(&info->port);
         if (tty == NULL) {
@@ -3316,13 +3308,10 @@ static int __init cy_detect_isa(void)
         unsigned short cy_isa_irq, nboard;
         void __iomem *cy_isa_address;
         unsigned short i, j, cy_isa_nchan;
-#ifdef MODULE
         int isparam = 0;
-#endif
 
         nboard = 0;
 
-#ifdef MODULE
         /* Check for module parameters */
         for (i = 0; i < NR_CARDS; i++) {
                 if (maddr[i] || i) {
@@ -3332,7 +3321,6 @@ static int __init cy_detect_isa(void)
                 if (!maddr[i])
                         break;
         }
-#endif
 
         /* scan the address table probing for Cyclom-Y/ISA boards */
         for (i = 0; i < NR_ISA_ADDRS; i++) {
@@ -3353,11 +3341,10 @@ static int __init cy_detect_isa(void)
                         iounmap(cy_isa_address);
                         continue;
                 }
-#ifdef MODULE
+
                 if (isparam && i < NR_CARDS && irq[i])
                         cy_isa_irq = irq[i];
                 else
-#endif
                         /* find out the board's irq by probing */
                         cy_isa_irq = detect_isa_irq(cy_isa_address);
                 if (cy_isa_irq == 0) {
@@ -4208,3 +4195,4 @@ module_exit(cy_cleanup_module);
 MODULE_LICENSE("GPL");
 MODULE_VERSION(CY_VERSION);
 MODULE_ALIAS_CHARDEV_MAJOR(CYCLADES_MAJOR);
+MODULE_FIRMWARE("cyzfirm.bin");
diff --git a/drivers/char/hvc_console.c b/drivers/char/hvc_console.c
index 4c3b59be286a..465185fc0f52 100644
--- a/drivers/char/hvc_console.c
+++ b/drivers/char/hvc_console.c
@@ -146,7 +146,7 @@ static void hvc_console_print(struct console *co, const char *b,
                 return;
 
         /* This console adapter was removed so it is not usable. */
-        if (vtermnos[index] < 0)
+        if (vtermnos[index] == -1)
                 return;
 
         while (count > 0 || i > 0) {
diff --git a/drivers/char/ip2/ip2main.c b/drivers/char/ip2/ip2main.c
index 517271c762e6..911e1da6def2 100644
--- a/drivers/char/ip2/ip2main.c
+++ b/drivers/char/ip2/ip2main.c
@@ -208,6 +208,7 @@ static int DumpFifoBuffer( char __user *, int);
 
 static void ip2_init_board(int, const struct firmware *);
 static unsigned short find_eisa_board(int);
+static int ip2_setup(char *str);
 
 /***************/
 /* Static Data */
@@ -263,7 +264,7 @@ static int tracewrap;
 /* Macros */
 /**********/
 
-#if defined(MODULE) && defined(IP2DEBUG_OPEN)
+#ifdef IP2DEBUG_OPEN
 #define DBG_CNT(s) printk(KERN_DEBUG "(%s): [%x] ttyc=%d, modc=%x -> %s\n", \
                     tty->name,(pCh->flags), \
                     tty->count,/*GET_USE_COUNT(module)*/0,s)
@@ -285,7 +286,10 @@ MODULE_AUTHOR("Doug McNash");
 MODULE_DESCRIPTION("Computone IntelliPort Plus Driver");
 MODULE_LICENSE("GPL");
 
+#define MAX_CMD_STR     50
+
 static int poll_only;
+static char cmd[MAX_CMD_STR];
 
 static int Eisa_irq;
 static int Eisa_slot;
@@ -309,6 +313,8 @@ module_param_array(io, int, NULL, 0);
 MODULE_PARM_DESC(io, "I/O ports for IntelliPort Cards");
 module_param(poll_only, bool, 0);
 MODULE_PARM_DESC(poll_only, "Do not use card interrupts");
+module_param_string(ip2, cmd, MAX_CMD_STR, 0);
+MODULE_PARM_DESC(ip2, "Contains module parameter passed with 'ip2='");
 
 /* for sysfs class support */
 static struct class *ip2_class;
@@ -487,7 +493,6 @@ static const struct firmware *ip2_request_firmware(void)
         return fw;
 }
 
-#ifndef MODULE
 /******************************************************************************
  *      ip2_setup:
  *              str: kernel command line string
@@ -531,7 +536,6 @@ static int __init ip2_setup(char *str)
         return 1;
 }
 __setup("ip2=", ip2_setup);
-#endif /* !MODULE */
 
 static int __init ip2_loadmain(void)
 {
@@ -539,14 +543,20 @@ static int __init ip2_loadmain(void)
         int err = 0;
         i2eBordStrPtr pB = NULL;
         int rc = -1;
-        struct pci_dev *pdev = NULL;
         const struct firmware *fw = NULL;
+        char *str;
+
+        str = cmd;
 
         if (poll_only) {
                 /* Hard lock the interrupts to zero */
                 irq[0] = irq[1] = irq[2] = irq[3] = poll_only = 0;
         }
 
+        /* Check module parameter with 'ip2=' has been passed or not */
+        if (!poll_only && (!strncmp(str, "ip2=", 4)))
+                ip2_setup(str);
+
         ip2trace(ITRC_NO_PORT, ITRC_INIT, ITRC_ENTER, 0);
 
         /* process command line arguments to modprobe or
@@ -612,6 +622,7 @@ static int __init ip2_loadmain(void)
                 case PCI:
 #ifdef CONFIG_PCI
                 {
+                        struct pci_dev *pdev = NULL;
                         u32 addr;
                         int status;
 
@@ -626,7 +637,7 @@ static int __init ip2_loadmain(void)
 
                         if (pci_enable_device(pdev)) {
                                 dev_err(&pdev->dev, "can't enable device\n");
-                                break;
+                                goto out;
                         }
                         ip2config.type[i] = PCI;
                         ip2config.pci_dev[i] = pci_dev_get(pdev);
@@ -638,6 +649,8 @@ static int __init ip2_loadmain(void)
                                 dev_err(&pdev->dev, "I/O address error\n");
 
                         ip2config.irq[i] = pdev->irq;
+out:
+                        pci_dev_put(pdev);
                 }
 #else
                         printk(KERN_ERR "IP2: PCI card specified but PCI "
@@ -656,7 +669,6 @@ static int __init ip2_loadmain(void)
                         break;
                 }       /* switch */
         }       /* for */
-        pci_dev_put(pdev);
 
         for (i = 0; i < IP2_MAX_BOARDS; ++i) {
                 if (ip2config.addr[i]) {
@@ -3197,3 +3209,5 @@ static struct pci_device_id ip2main_pci_tbl[] __devinitdata = {
 };
 
 MODULE_DEVICE_TABLE(pci, ip2main_pci_tbl);
+
+MODULE_FIRMWARE("intelliport2.bin");
diff --git a/drivers/char/isicom.c b/drivers/char/isicom.c
index 300d5bd6cd06..be2e8f9a27c3 100644
--- a/drivers/char/isicom.c
+++ b/drivers/char/isicom.c
@@ -113,6 +113,8 @@
  *              64-bit verification
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/kernel.h>
@@ -140,7 +142,6 @@
 #define InterruptTheCard(base) outw(0, (base) + 0xc)
 #define ClearInterrupt(base) inw((base) + 0x0a)
 
-#define pr_dbg(str...) pr_debug("ISICOM: " str)
 #ifdef DEBUG
 #define isicom_paranoia_check(a, b, c) __isicom_paranoia_check((a), (b), (c))
 #else
@@ -249,8 +250,7 @@ static int lock_card(struct isi_board *card)
                 spin_unlock_irqrestore(&card->card_lock, card->flags);
                 msleep(10);
         }
-        printk(KERN_WARNING "ISICOM: Failed to lock Card (0x%lx)\n",
-                card->base);
+        pr_warning("Failed to lock Card (0x%lx)\n", card->base);
 
         return 0;       /* Failed to acquire the card! */
 }
@@ -379,13 +379,13 @@ static inline int __isicom_paranoia_check(struct isi_port const *port,
         char *name, const char *routine)
 {
         if (!port) {
-                printk(KERN_WARNING "ISICOM: Warning: bad isicom magic for "
-                        "dev %s in %s.\n", name, routine);
+                pr_warning("Warning: bad isicom magic for dev %s in %s.\n",
+                           name, routine);
                 return 1;
         }
         if (port->magic != ISICOM_MAGIC) {
-                printk(KERN_WARNING "ISICOM: Warning: NULL isicom port for "
-                        "dev %s in %s.\n", name, routine);
+                pr_warning("Warning: NULL isicom port for dev %s in %s.\n",
+                           name, routine);
                 return 1;
         }
 
@@ -450,8 +450,8 @@ static void isicom_tx(unsigned long _data)
                 if (!(inw(base + 0x02) & (1 << port->channel)))
                         continue;
 
-                pr_dbg("txing %d bytes, port%d.\n", txcount,
-                        port->channel + 1);
+                pr_debug("txing %d bytes, port%d.\n",
+                         txcount, port->channel + 1);
                 outw((port->channel << isi_card[card].shift_count) | txcount,
                         base);
                 residue = NO;
@@ -547,8 +547,8 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id)
         byte_count = header & 0xff;
 
         if (channel + 1 > card->port_count) {
-                printk(KERN_WARNING "ISICOM: isicom_interrupt(0x%lx): "
-                        "%d(channel) > port_count.\n", base, channel+1);
+                pr_warning("%s(0x%lx): %d(channel) > port_count.\n",
+                           __func__, base, channel+1);
                 outw(0x0000, base+0x04); /* enable interrupts */
                 spin_unlock(&card->card_lock);
                 return IRQ_HANDLED;
@@ -582,14 +582,15 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id)
                                 if (port->status & ISI_DCD) {
                                         if (!(header & ISI_DCD)) {
                                         /* Carrier has been lost  */
-                                                pr_dbg("interrupt: DCD->low.\n"
-                                                        );
+                                                pr_debug("%s: DCD->low.\n",
+                                                         __func__);
                                                 port->status &= ~ISI_DCD;
                                                 tty_hangup(tty);
                                         }
                                 } else if (header & ISI_DCD) {
                                 /* Carrier has been detected */
-                                        pr_dbg("interrupt: DCD->high.\n");
+                                        pr_debug("%s: DCD->high.\n",
+                                                __func__);
                                         port->status |= ISI_DCD;
                                         wake_up_interruptible(&port->port.open_wait);
                                 }
@@ -641,17 +642,19 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id)
                         break;
 
                 case 2: /* Statistics            */
-                        pr_dbg("isicom_interrupt: stats!!!.\n");
+                        pr_debug("%s: stats!!!\n", __func__);
                         break;
 
                 default:
-                        pr_dbg("Intr: Unknown code in status packet.\n");
+                        pr_debug("%s: Unknown code in status packet.\n",
+                                 __func__);
                         break;
                 }
         } else {                                /* Data   Packet */
 
                 count = tty_prepare_flip_string(tty, &rp, byte_count & ~1);
-                pr_dbg("Intr: Can rx %d of %d bytes.\n", count, byte_count);
+                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);
@@ -661,8 +664,8 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id)
                         byte_count -= 2;
                 }
                 if (byte_count > 0) {
-                        pr_dbg("Intr(0x%lx:%d): Flip buffer overflow! dropping "
-                                "bytes...\n", base, channel + 1);
+                        pr_debug("%s(0x%lx:%d): Flip buffer overflow! dropping bytes...\n",
+                                 __func__, base, channel + 1);
                 /* drain out unread xtra data */
                 while (byte_count > 0) {
                                 inw(base);
@@ -888,8 +891,8 @@ static void isicom_shutdown_port(struct isi_port *port)
         struct isi_board *card = port->card;
 
         if (--card->count < 0) {
-                pr_dbg("isicom_shutdown_port: bad board(0x%lx) count %d.\n",
-                        card->base, card->count);
+                pr_debug("%s: bad board(0x%lx) count %d.\n",
+                         __func__, card->base, card->count);
                 card->count = 0;
         }
         /* last port was closed, shutdown that board too */
@@ -1681,13 +1684,13 @@ static int __init isicom_init(void)
 
         retval = tty_register_driver(isicom_normal);
         if (retval) {
-                pr_dbg("Couldn't register the dialin driver\n");
+                pr_debug("Couldn't register the dialin driver\n");
                 goto err_puttty;
         }
 
         retval = pci_register_driver(&isicom_driver);
         if (retval < 0) {
-                printk(KERN_ERR "ISICOM: Unable to register pci driver.\n");
+                pr_err("Unable to register pci driver.\n");
                 goto err_unrtty;
         }
 
@@ -1717,3 +1720,8 @@ module_exit(isicom_exit);
 MODULE_AUTHOR("MultiTech");
 MODULE_DESCRIPTION("Driver for the ISI series of cards by MultiTech");
 MODULE_LICENSE("GPL");
+MODULE_FIRMWARE("isi608.bin");
+MODULE_FIRMWARE("isi608em.bin");
+MODULE_FIRMWARE("isi616em.bin");
+MODULE_FIRMWARE("isi4608.bin");
+MODULE_FIRMWARE("isi4616.bin");
diff --git a/drivers/char/moxa.c b/drivers/char/moxa.c
index 63ee3bbc1ce4..166495d6a1d7 100644
--- a/drivers/char/moxa.c
+++ b/drivers/char/moxa.c
@@ -164,24 +164,25 @@ static unsigned int moxaFuncTout = HZ / 2;
 static unsigned int moxaLowWaterChk;
 static DEFINE_MUTEX(moxa_openlock);
 static DEFINE_SPINLOCK(moxa_lock);
-/* Variables for insmod */
-#ifdef MODULE
+
 static unsigned long baseaddr[MAX_BOARDS];
 static unsigned int type[MAX_BOARDS];
 static unsigned int numports[MAX_BOARDS];
-#endif
 
 MODULE_AUTHOR("William Chen");
 MODULE_DESCRIPTION("MOXA Intellio Family Multiport Board Device Driver");
 MODULE_LICENSE("GPL");
-#ifdef MODULE
+MODULE_FIRMWARE("c218tunx.cod");
+MODULE_FIRMWARE("cp204unx.cod");
+MODULE_FIRMWARE("c320tunx.cod");
+
 module_param_array(type, uint, NULL, 0);
 MODULE_PARM_DESC(type, "card type: C218=2, C320=4");
 module_param_array(baseaddr, ulong, NULL, 0);
 MODULE_PARM_DESC(baseaddr, "base address");
 module_param_array(numports, uint, NULL, 0);
 MODULE_PARM_DESC(numports, "numports (ignored for C218)");
-#endif
+
 module_param(ttymajor, int, 0);
 
 /*
@@ -1024,6 +1025,8 @@ static int __init moxa_init(void)
 {
         unsigned int isabrds = 0;
         int retval = 0;
+        struct moxa_board_conf *brd = moxa_boards;
+        unsigned int i;
 
         printk(KERN_INFO "MOXA Intellio family driver version %s\n",
                         MOXA_VERSION);
@@ -1051,10 +1054,7 @@ static int __init moxa_init(void)
         }
 
         /* Find the boards defined from module args. */
-#ifdef MODULE
-        {
-        struct moxa_board_conf *brd = moxa_boards;
-        unsigned int i;
+
         for (i = 0; i < MAX_BOARDS; i++) {
                 if (!baseaddr[i])
                         break;
@@ -1087,8 +1087,6 @@ static int __init moxa_init(void)
                         isabrds++;
                 }
         }
-        }
-#endif
 
 #ifdef CONFIG_PCI
         retval = pci_register_driver(&moxa_pci_driver);
diff --git a/drivers/char/mxser.c b/drivers/char/mxser.c
index 3d923065d9a2..e0c5d2a69046 100644
--- a/drivers/char/mxser.c
+++ b/drivers/char/mxser.c
@@ -895,8 +895,7 @@ static int mxser_activate(struct tty_port *port, struct tty_struct *tty)
         if (inb(info->ioaddr + UART_LSR) == 0xff) {
                 spin_unlock_irqrestore(&info->slock, flags);
                 if (capable(CAP_SYS_ADMIN)) {
-                        if (tty)
-                                set_bit(TTY_IO_ERROR, &tty->flags);
+                        set_bit(TTY_IO_ERROR, &tty->flags);
                         return 0;
                 } else
                         return -ENODEV;
diff --git a/drivers/char/nozomi.c b/drivers/char/nozomi.c
index 2ad7d37afbd0..a3f32a15fde4 100644
--- a/drivers/char/nozomi.c
+++ b/drivers/char/nozomi.c
@@ -136,10 +136,6 @@ static int debug;
 #define RECEIVE_BUF_MAX         4
 
 
-/* Define all types of vendors and devices to support */
-#define VENDOR1         0x1931  /* Vendor Option */
-#define DEVICE1         0x000c  /* HSDPA card */
-
 #define R_IIR           0x0000  /* Interrupt Identity Register */
 #define R_FCR           0x0000  /* Flow Control Register */
 #define R_IER           0x0004  /* Interrupt Enable Register */
@@ -371,6 +367,8 @@ struct port {
         struct mutex tty_sem;
         wait_queue_head_t tty_wait;
         struct async_icount tty_icount;
+
+        struct nozomi *dc;
 };
 
 /* Private data one for each card in the system */
@@ -405,7 +403,7 @@ struct buffer {
 
 /*    Global variables */
 static const struct pci_device_id nozomi_pci_tbl[] __devinitconst = {
-        {PCI_DEVICE(VENDOR1, DEVICE1)},
+        {PCI_DEVICE(0x1931, 0x000c)},   /* Nozomi HSDPA */
         {},
 };
 
@@ -414,6 +412,8 @@ MODULE_DEVICE_TABLE(pci, nozomi_pci_tbl);
 static struct nozomi *ndevs[NOZOMI_MAX_CARDS];
 static struct tty_driver *ntty_driver;
 
+static const struct tty_port_operations noz_tty_port_ops;
+
 /*
  * find card by tty_index
  */
@@ -853,8 +853,6 @@ static int receive_data(enum port_type index, struct nozomi *dc)
                 goto put;
         }
 
-        tty_buffer_request_room(tty, size);
-
         while (size > 0) {
                 read_mem32((u32 *) buf, addr + offset, RECEIVE_BUF_MAX);
 
@@ -1473,9 +1471,11 @@ static int __devinit nozomi_card_init(struct pci_dev *pdev,
 
         for (i = 0; i < MAX_PORT; i++) {
                 struct device *tty_dev;
-
-                mutex_init(&dc->port[i].tty_sem);
-                tty_port_init(&dc->port[i].port);
+                struct port *port = &dc->port[i];
+                port->dc = dc;
+                mutex_init(&port->tty_sem);
+                tty_port_init(&port->port);
+                port->port.ops = &noz_tty_port_ops;
                 tty_dev = tty_register_device(ntty_driver, dc->index_start + i,
                                                         &pdev->dev);
 
@@ -1600,67 +1600,74 @@ static void set_dtr(const struct tty_struct *tty, int dtr)
  * ----------------------------------------------------------------------------
  */
 
-/* Called when the userspace process opens the tty, /dev/noz*.  */
-static int ntty_open(struct tty_struct *tty, struct file *file)
+static int ntty_install(struct tty_driver *driver, struct tty_struct *tty)
 {
         struct port *port = get_port_by_tty(tty);
         struct nozomi *dc = get_dc_by_tty(tty);
-        unsigned long flags;
-
+        int ret;
         if (!port || !dc || dc->state != NOZOMI_STATE_READY)
                 return -ENODEV;
-
-        if (mutex_lock_interruptible(&port->tty_sem))
-                return -ERESTARTSYS;
-
-        port->port.count++;
-        dc->open_ttys++;
-
-        /* Enable interrupt downlink for channel */
-        if (port->port.count == 1) {
-                tty->driver_data = port;
-                tty_port_tty_set(&port->port, tty);
-                DBG1("open: %d", port->token_dl);
-                spin_lock_irqsave(&dc->spin_mutex, flags);
-                dc->last_ier = dc->last_ier | port->token_dl;
-                writew(dc->last_ier, dc->reg_ier);
-                spin_unlock_irqrestore(&dc->spin_mutex, flags);
+        ret = tty_init_termios(tty);
+        if (ret == 0) {
+                tty_driver_kref_get(driver);
+                driver->ttys[tty->index] = tty;
         }
-        mutex_unlock(&port->tty_sem);
-        return 0;
+        return ret;
 }
 
-/* Called when the userspace process close the tty, /dev/noz*. Also
-   called immediately if ntty_open fails in which case tty->driver_data
-   will be NULL an we exit by the first return */
+static void ntty_cleanup(struct tty_struct *tty)
+{
+        tty->driver_data = NULL;
+}
 
-static void ntty_close(struct tty_struct *tty, struct file *file)
+static int ntty_activate(struct tty_port *tport, struct tty_struct *tty)
 {
-        struct nozomi *dc = get_dc_by_tty(tty);
-        struct port *nport = tty->driver_data;
-        struct tty_port *port = &nport->port;
+        struct port *port = container_of(tport, struct port, port);
+        struct nozomi *dc = port->dc;
         unsigned long flags;
 
-        if (!dc || !nport)
-                return;
+        DBG1("open: %d", port->token_dl);
+        spin_lock_irqsave(&dc->spin_mutex, flags);
+        dc->last_ier = dc->last_ier | port->token_dl;
+        writew(dc->last_ier, dc->reg_ier);
+        dc->open_ttys++;
+        spin_unlock_irqrestore(&dc->spin_mutex, flags);
+        printk("noz: activated %d: %p\n", tty->index, tport);
+        return 0;
+}
 
-        /* Users cannot interrupt a close */
-        mutex_lock(&nport->tty_sem);
+static int ntty_open(struct tty_struct *tty, struct file *filp)
+{
+        struct port *port = get_port_by_tty(tty);
+        return tty_port_open(&port->port, tty, filp);
+}
 
-        WARN_ON(!port->count);
+static void ntty_shutdown(struct tty_port *tport)
+{
+        struct port *port = container_of(tport, struct port, port);
+        struct nozomi *dc = port->dc;
+        unsigned long flags;
 
+        DBG1("close: %d", port->token_dl);
+        spin_lock_irqsave(&dc->spin_mutex, flags);
+        dc->last_ier &= ~(port->token_dl);
+        writew(dc->last_ier, dc->reg_ier);
         dc->open_ttys--;
-        port->count--;
+        spin_unlock_irqrestore(&dc->spin_mutex, flags);
+        printk("noz: shutdown %p\n", tport);
+}
 
-        if (port->count == 0) {
-                DBG1("close: %d", nport->token_dl);
-                tty_port_tty_set(port, NULL);
-                spin_lock_irqsave(&dc->spin_mutex, flags);
-                dc->last_ier &= ~(nport->token_dl);
-                writew(dc->last_ier, dc->reg_ier);
-                spin_unlock_irqrestore(&dc->spin_mutex, flags);
-        }
-        mutex_unlock(&nport->tty_sem);
+static void ntty_close(struct tty_struct *tty, struct file *filp)
+{
+        struct port *port = tty->driver_data;
+        if (port)
+                tty_port_close(&port->port, tty, filp);
+}
+
+static void ntty_hangup(struct tty_struct *tty)
+{
+        struct port *port = tty->driver_data;
+        tty_port_hangup(&port->port);
 }
 
 /*
@@ -1680,15 +1687,7 @@ static int ntty_write(struct tty_struct *tty, const unsigned char *buffer,
         if (!dc || !port)
                 return -ENODEV;
 
-        if (unlikely(!mutex_trylock(&port->tty_sem))) {
-                /*
-                 * must test lock as tty layer wraps calls
-                 * to this function with BKL
-                 */
-                dev_err(&dc->pdev->dev, "Would have deadlocked - "
-                        "return EAGAIN\n");
-                return -EAGAIN;
-        }
+        mutex_lock(&port->tty_sem);
 
         if (unlikely(!port->port.count)) {
                 DBG1(" ");
@@ -1728,25 +1727,23 @@ exit:
  * This method is called by the upper tty layer.
  *   #according to sources N_TTY.c it expects a value >= 0 and
  *    does not check for negative values.
+ *
+ * If the port is unplugged report lots of room and let the bits
+ * dribble away so we don't block anything.
  */
 static int ntty_write_room(struct tty_struct *tty)
 {
         struct port *port = tty->driver_data;
-        int room = 0;
+        int room = 4096;
         const struct nozomi *dc = get_dc_by_tty(tty);
 
-        if (!dc || !port)
-                return 0;
-        if (!mutex_trylock(&port->tty_sem))
-                return 0;
-
-        if (!port->port.count)
-                goto exit;
-
-        room = port->fifo_ul.size - kfifo_len(&port->fifo_ul);
-
-exit:
-        mutex_unlock(&port->tty_sem);
+        if (dc) {
+                mutex_lock(&port->tty_sem);
+                if (port->port.count)
+                        room = port->fifo_ul.size -
+                                        kfifo_len(&port->fifo_ul);
+                mutex_unlock(&port->tty_sem);
+        }
         return room;
 }
 
@@ -1906,10 +1903,16 @@ exit_in_buffer:
         return rval;
 }
 
+static const struct tty_port_operations noz_tty_port_ops = {
+        .activate = ntty_activate,
+        .shutdown = ntty_shutdown,
+};
+
 static const struct tty_operations tty_ops = {
         .ioctl = ntty_ioctl,
         .open = ntty_open,
         .close = ntty_close,
+        .hangup = ntty_hangup,
         .write = ntty_write,
         .write_room = ntty_write_room,
         .unthrottle = ntty_unthrottle,
@@ -1917,6 +1920,8 @@ static const struct tty_operations tty_ops = {
         .chars_in_buffer = ntty_chars_in_buffer,
         .tiocmget = ntty_tiocmget,
         .tiocmset = ntty_tiocmset,
+        .install = ntty_install,
+        .cleanup = ntty_cleanup,
 };
 
 /* Module initialization */
diff --git a/drivers/char/serial167.c b/drivers/char/serial167.c
index 452370af95de..986aa606a6b6 100644
--- a/drivers/char/serial167.c
+++ b/drivers/char/serial167.c
@@ -658,8 +658,7 @@ static irqreturn_t cd2401_rx_interrupt(int irq, void *dev_id)
                         info->mon.char_max = char_count;
                 info->mon.char_last = char_count;
 #endif
-                len = tty_buffer_request_room(tty, char_count);
-                while (len--) {
+                while (char_count--) {
                         data = base_addr[CyRDR];
                         tty_insert_flip_char(tty, data, TTY_NORMAL);
 #ifdef CYCLOM_16Y_HACK
diff --git a/drivers/char/specialix.c b/drivers/char/specialix.c
index 268e17f9ec3f..07ac14d949ce 100644
--- a/drivers/char/specialix.c
+++ b/drivers/char/specialix.c
@@ -646,8 +646,6 @@ static void sx_receive(struct specialix_board *bp)
         dprintk(SX_DEBUG_RX, "port: %p: count: %d\n", port, count);
         port->hits[count > 8 ? 9 : count]++;
 
-        tty_buffer_request_room(tty, count);
-
         while (count--)
                 tty_insert_flip_char(tty, sx_in(bp, CD186x_RDR), TTY_NORMAL);
         tty_flip_buffer_push(tty);
diff --git a/drivers/char/synclink.c b/drivers/char/synclink.c
index 4846b73ef28d..0658fc548222 100644
--- a/drivers/char/synclink.c
+++ b/drivers/char/synclink.c
@@ -2031,7 +2031,7 @@ static int mgsl_put_char(struct tty_struct *tty, unsigned char ch)
         if (mgsl_paranoia_check(info, tty->name, "mgsl_put_char"))
                 return 0;
 
-        if (!tty || !info->xmit_buf)
+        if (!info->xmit_buf)
                 return 0;
 
         spin_lock_irqsave(&info->irq_spinlock, flags);
@@ -2121,7 +2121,7 @@ static int mgsl_write(struct tty_struct * tty,
         if (mgsl_paranoia_check(info, tty->name, "mgsl_write"))
                 goto cleanup;
 
-        if (!tty || !info->xmit_buf)
+        if (!info->xmit_buf)
                 goto cleanup;
 
         if ( info->params.mode == MGSL_MODE_HDLC ||
diff --git a/drivers/char/synclink_gt.c b/drivers/char/synclink_gt.c
index 8678f0c8699d..4561ce2fba6d 100644
--- a/drivers/char/synclink_gt.c
+++ b/drivers/char/synclink_gt.c
@@ -468,7 +468,7 @@ static unsigned int free_tbuf_count(struct slgt_info *info);
 static unsigned int tbuf_bytes(struct slgt_info *info);
 static void reset_tbufs(struct slgt_info *info);
 static void tdma_reset(struct slgt_info *info);
-static void tx_load(struct slgt_info *info, const char *buf, unsigned int count);
+static bool tx_load(struct slgt_info *info, const char *buf, unsigned int count);
 
 static void get_signals(struct slgt_info *info);
 static void set_signals(struct slgt_info *info);
@@ -813,59 +813,32 @@ static int write(struct tty_struct *tty,
         int ret = 0;
         struct slgt_info *info = tty->driver_data;
         unsigned long flags;
-        unsigned int bufs_needed;
 
         if (sanity_check(info, tty->name, "write"))
-                goto cleanup;
+                return -EIO;
+
         DBGINFO(("%s write count=%d\n", info->device_name, count));
 
-        if (!info->tx_buf)
-                goto cleanup;
+        if (!info->tx_buf || (count > info->max_frame_size))
+                return -EIO;
 
-        if (count > info->max_frame_size) {
-                ret = -EIO;
-                goto cleanup;
-        }
+        if (!count || tty->stopped || tty->hw_stopped)
+                return 0;
 
-        if (!count)
-                goto cleanup;
+        spin_lock_irqsave(&info->lock, flags);
 
-        if (!info->tx_active && info->tx_count) {
+        if (info->tx_count) {
                 /* send accumulated data from send_char() */
-                tx_load(info, info->tx_buf, info->tx_count);
-                goto start;
+                if (!tx_load(info, info->tx_buf, info->tx_count))
+                        goto cleanup;
+                info->tx_count = 0;
         }
-        bufs_needed = (count/DMABUFSIZE);
-        if (count % DMABUFSIZE)
-                ++bufs_needed;
-        if (bufs_needed > free_tbuf_count(info))
-                goto cleanup;
 
-        ret = info->tx_count = count;
-        tx_load(info, buf, count);
-        goto start;
-
-start:
-        if (info->tx_count && !tty->stopped && !tty->hw_stopped) {
-                spin_lock_irqsave(&info->lock,flags);
-                if (!info->tx_active)
-                        tx_start(info);
-                else if (!(rd_reg32(info, TDCSR) & BIT0)) {
-                        /* transmit still active but transmit DMA stopped */
-                        unsigned int i = info->tbuf_current;
-                        if (!i)
-                                i = info->tbuf_count;
-                        i--;
-                        /* if DMA buf unsent must try later after tx idle */
-                        if (desc_count(info->tbufs[i]))
-                                ret = 0;
-                }
-                if (ret > 0)
-                        update_tx_timer(info);
-                spin_unlock_irqrestore(&info->lock,flags);
-        }
+        if (tx_load(info, buf, count))
+                ret = count;
 
 cleanup:
+        spin_unlock_irqrestore(&info->lock, flags);
         DBGINFO(("%s write rc=%d\n", info->device_name, ret));
         return ret;
 }
@@ -882,7 +855,7 @@ static int put_char(struct tty_struct *tty, unsigned char ch)
         if (!info->tx_buf)
                 return 0;
         spin_lock_irqsave(&info->lock,flags);
-        if (!info->tx_active && (info->tx_count < info->max_frame_size)) {
+        if (info->tx_count < info->max_frame_size) {
                 info->tx_buf[info->tx_count++] = ch;
                 ret = 1;
         }
@@ -981,10 +954,8 @@ static void flush_chars(struct tty_struct *tty)
         DBGINFO(("%s flush_chars start transmit\n", info->device_name));
 
         spin_lock_irqsave(&info->lock,flags);
-        if (!info->tx_active && info->tx_count) {
-                tx_load(info, info->tx_buf,info->tx_count);
-                tx_start(info);
-        }
+        if (info->tx_count && tx_load(info, info->tx_buf, info->tx_count))
+                info->tx_count = 0;
         spin_unlock_irqrestore(&info->lock,flags);
 }
 
@@ -997,10 +968,9 @@ static void flush_buffer(struct tty_struct *tty)
                 return;
         DBGINFO(("%s flush_buffer\n", info->device_name));
 
-        spin_lock_irqsave(&info->lock,flags);
-        if (!info->tx_active)
-                info->tx_count = 0;
-        spin_unlock_irqrestore(&info->lock,flags);
+        spin_lock_irqsave(&info->lock, flags);
+        info->tx_count = 0;
+        spin_unlock_irqrestore(&info->lock, flags);
 
         tty_wakeup(tty);
 }
@@ -1033,12 +1003,10 @@ static void tx_release(struct tty_struct *tty)
         if (sanity_check(info, tty->name, "tx_release"))
                 return;
         DBGINFO(("%s tx_release\n", info->device_name));
-        spin_lock_irqsave(&info->lock,flags);
-        if (!info->tx_active && info->tx_count) {
-                tx_load(info, info->tx_buf, info->tx_count);
-                tx_start(info);
-        }
-        spin_unlock_irqrestore(&info->lock,flags);
+        spin_lock_irqsave(&info->lock, flags);
+        if (info->tx_count && tx_load(info, info->tx_buf, info->tx_count))
+                info->tx_count = 0;
+        spin_unlock_irqrestore(&info->lock, flags);
 }
 
 /*
@@ -1506,27 +1474,25 @@ static netdev_tx_t hdlcdev_xmit(struct sk_buff *skb,
 
         DBGINFO(("%s hdlc_xmit\n", dev->name));
 
+        if (!skb->len)
+                return NETDEV_TX_OK;
+
         /* stop sending until this frame completes */
         netif_stop_queue(dev);
 
-        /* copy data to device buffers */
-        info->tx_count = skb->len;
-        tx_load(info, skb->data, skb->len);
-
         /* update network statistics */
         dev->stats.tx_packets++;
         dev->stats.tx_bytes += skb->len;
 
-        /* done with socket buffer, so free it */
-        dev_kfree_skb(skb);
-
         /* save start time for transmit timeout detection */
         dev->trans_start = jiffies;
 
-        spin_lock_irqsave(&info->lock,flags);
-        tx_start(info);
-        update_tx_timer(info);
-        spin_unlock_irqrestore(&info->lock,flags);
+        spin_lock_irqsave(&info->lock, flags);
+        tx_load(info, skb->data, skb->len);
+        spin_unlock_irqrestore(&info->lock, flags);
+
+        /* done with socket buffer, so free it */
+        dev_kfree_skb(skb);
 
         return NETDEV_TX_OK;
 }
@@ -2180,7 +2146,7 @@ static void isr_serial(struct slgt_info *info)
 
         if (info->params.mode == MGSL_MODE_ASYNC) {
                 if (status & IRQ_TXIDLE) {
-                        if (info->tx_count)
+                        if (info->tx_active)
                                 isr_txeom(info, status);
                 }
                 if (info->rx_pio && (status & IRQ_RXDATA))
@@ -2276,13 +2242,42 @@ static void isr_tdma(struct slgt_info *info)
         }
 }
 
+/*
+ * return true if there are unsent tx DMA buffers, otherwise false
+ *
+ * if there are unsent buffers then info->tbuf_start
+ * is set to index of first unsent buffer
+ */
+static bool unsent_tbufs(struct slgt_info *info)
+{
+        unsigned int i = info->tbuf_current;
+        bool rc = false;
+
+        /*
+         * search backwards from last loaded buffer (precedes tbuf_current)
+         * for first unsent buffer (desc_count > 0)
+         */
+
+        do {
+                if (i)
+                        i--;
+                else
+                        i = info->tbuf_count - 1;
+                if (!desc_count(info->tbufs[i]))
+                        break;
+                info->tbuf_start = i;
+                rc = true;
+        } while (i != info->tbuf_current);
+
+        return rc;
+}
+
 static void isr_txeom(struct slgt_info *info, unsigned short status)
 {
         DBGISR(("%s txeom status=%04x\n", info->device_name, status));
 
         slgt_irq_off(info, IRQ_TXDATA + IRQ_TXIDLE + IRQ_TXUNDER);
         tdma_reset(info);
-        reset_tbufs(info);
         if (status & IRQ_TXUNDER) {
                 unsigned short val = rd_reg16(info, TCR);
                 wr_reg16(info, TCR, (unsigned short)(val | BIT2)); /* set reset bit */
@@ -2297,8 +2292,12 @@ static void isr_txeom(struct slgt_info *info, unsigned short status)
                                 info->icount.txok++;
                 }
 
+                if (unsent_tbufs(info)) {
+                        tx_start(info);
+                        update_tx_timer(info);
+                        return;
+                }
                 info->tx_active = false;
-                info->tx_count = 0;
 
                 del_timer(&info->tx_timer);
 
@@ -3949,7 +3948,7 @@ static void tx_start(struct slgt_info *info)
                 info->tx_enabled = true;
         }
 
-        if (info->tx_count) {
+        if (desc_count(info->tbufs[info->tbuf_start])) {
                 info->drop_rts_on_tx_done = false;
 
                 if (info->params.mode != MGSL_MODE_ASYNC) {
@@ -4772,25 +4771,36 @@ static unsigned int tbuf_bytes(struct slgt_info *info)
 }
 
 /*
- * load transmit DMA buffer(s) with data
+ * load data into transmit DMA buffer ring and start transmitter if needed
+ * return true if data accepted, otherwise false (buffers full)
  */
-static void tx_load(struct slgt_info *info, const char *buf, unsigned int size)
+static bool tx_load(struct slgt_info *info, const char *buf, unsigned int size)
 {
         unsigned short count;
         unsigned int i;
         struct slgt_desc *d;
 
-        if (size == 0)
-                return;
+        /* check required buffer space */
+        if (DIV_ROUND_UP(size, DMABUFSIZE) > free_tbuf_count(info))
+                return false;
 
         DBGDATA(info, buf, size, "tx");
 
+        /*
+         * copy data to one or more DMA buffers in circular ring
+         * tbuf_start   = first buffer for this data
+         * tbuf_current = next free buffer
+         *
+         * Copy all data before making data visible to DMA controller by
+         * setting descriptor count of the first buffer.
+         * This prevents an active DMA controller from reading the first DMA
+         * buffers of a frame and stopping before the final buffers are filled.
+         */
+
         info->tbuf_start = i = info->tbuf_current;
 
         while (size) {
                 d = &info->tbufs[i];
-                if (++i == info->tbuf_count)
-                        i = 0;
 
                 count = (unsigned short)((size > DMABUFSIZE) ? DMABUFSIZE : size);
                 memcpy(d->buf, buf, count);
@@ -4808,11 +4818,27 @@ static void tx_load(struct slgt_info *info, const char *buf, unsigned int size)
                 else
                         set_desc_eof(*d, 0);
 
-                set_desc_count(*d, count);
+                /* set descriptor count for all but first buffer */
+                if (i != info->tbuf_start)
+                        set_desc_count(*d, count);
                 d->buf_count = count;
+
+                if (++i == info->tbuf_count)
+                        i = 0;
         }
 
         info->tbuf_current = i;
+
+        /* set first buffer count to make new data visible to DMA controller */
+        d = &info->tbufs[info->tbuf_start];
+        set_desc_count(*d, d->buf_count);
+
+        /* start transmitter if needed and update transmit timeout */
+        if (!info->tx_active)
+                tx_start(info);
+        update_tx_timer(info);
+
+        return true;
 }
 
 static int register_test(struct slgt_info *info)
@@ -4934,9 +4960,7 @@ static int loopback_test(struct slgt_info *info)
         spin_lock_irqsave(&info->lock,flags);
         async_mode(info);
         rx_start(info);
-        info->tx_count = count;
         tx_load(info, buf, count);
-        tx_start(info);
         spin_unlock_irqrestore(&info->lock, flags);
 
         /* wait for receive complete */
diff --git a/drivers/char/tty_buffer.c b/drivers/char/tty_buffer.c
index 66fa4e10d76b..f27c4d6d956e 100644
--- a/drivers/char/tty_buffer.c
+++ b/drivers/char/tty_buffer.c
@@ -247,7 +247,8 @@ int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars,
 {
         int copied = 0;
         do {
-                int space = tty_buffer_request_room(tty, size - copied);
+                int goal = min(size - copied, TTY_BUFFER_PAGE);
+                int space = tty_buffer_request_room(tty, goal);
                 struct tty_buffer *tb = tty->buf.tail;
                 /* If there is no space then tb may be NULL */
                 if (unlikely(space == 0))
@@ -283,7 +284,8 @@ int tty_insert_flip_string_flags(struct tty_struct *tty,
 {
         int copied = 0;
         do {
-                int space = tty_buffer_request_room(tty, size - copied);
+                int goal = min(size - copied, TTY_BUFFER_PAGE);
+                int space = tty_buffer_request_room(tty, goal);
                 struct tty_buffer *tb = tty->buf.tail;
                 /* If there is no space then tb may be NULL */
                 if (unlikely(space == 0))
diff --git a/drivers/char/tty_ldisc.c b/drivers/char/tty_ldisc.c
index 3f653f7d849f..500e740ec5e4 100644
--- a/drivers/char/tty_ldisc.c
+++ b/drivers/char/tty_ldisc.c
@@ -706,12 +706,13 @@ static void tty_reset_termios(struct tty_struct *tty)
 /**
  *      tty_ldisc_reinit        -       reinitialise the tty ldisc
  *      @tty: tty to reinit
+ *      @ldisc: line discipline to reinitialize
  *
- *      Switch the tty back to N_TTY line discipline and leave the
- *      ldisc state closed
+ *      Switch the tty to a line discipline and leave the ldisc
+ *      state closed
  */
 
-static void tty_ldisc_reinit(struct tty_struct *tty)
+static void tty_ldisc_reinit(struct tty_struct *tty, int ldisc)
 {
         struct tty_ldisc *ld;
 
@@ -721,10 +722,10 @@ static void tty_ldisc_reinit(struct tty_struct *tty)
         /*
          *      Switch the line discipline back
          */
-        ld = tty_ldisc_get(N_TTY);
+        ld = tty_ldisc_get(ldisc);
         BUG_ON(IS_ERR(ld));
         tty_ldisc_assign(tty, ld);
-        tty_set_termios_ldisc(tty, N_TTY);
+        tty_set_termios_ldisc(tty, ldisc);
 }
 
 /**
@@ -745,6 +746,8 @@ static void tty_ldisc_reinit(struct tty_struct *tty)
 void tty_ldisc_hangup(struct tty_struct *tty)
 {
         struct tty_ldisc *ld;
+        int reset = tty->driver->flags & TTY_DRIVER_RESET_TERMIOS;
+        int err = 0;
 
         /*
          * FIXME! What are the locking issues here? This may me overdoing
@@ -772,25 +775,32 @@ void tty_ldisc_hangup(struct tty_struct *tty)
         wake_up_interruptible_poll(&tty->read_wait, POLLIN);
         /*
          * Shutdown the current line discipline, and reset it to
-         * N_TTY.
+         * N_TTY if need be.
+         *
+         * Avoid racing set_ldisc or tty_ldisc_release
          */
-        if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
-                /* Avoid racing set_ldisc or tty_ldisc_release */
-                mutex_lock(&tty->ldisc_mutex);
-                tty_ldisc_halt(tty);
-                if (tty->ldisc) {       /* Not yet closed */
-                        /* Switch back to N_TTY */
-                        tty_ldisc_reinit(tty);
-                        /* At this point we have a closed ldisc and we want to
-                           reopen it. We could defer this to the next open but
-                           it means auditing a lot of other paths so this is
-                           a FIXME */
+        mutex_lock(&tty->ldisc_mutex);
+        tty_ldisc_halt(tty);
+        /* At this point we have a closed ldisc and we want to
+           reopen it. We could defer this to the next open but
+           it means auditing a lot of other paths so this is
+           a FIXME */
+        if (tty->ldisc) {       /* Not yet closed */
+                if (reset == 0) {
+                        tty_ldisc_reinit(tty, tty->termios->c_line);
+                        err = tty_ldisc_open(tty, tty->ldisc);
+                }
+                /* If the re-open fails or we reset then go to N_TTY. The
+                   N_TTY open cannot fail */
+                if (reset || err) {
+                        tty_ldisc_reinit(tty, N_TTY);
                         WARN_ON(tty_ldisc_open(tty, tty->ldisc));
-                        tty_ldisc_enable(tty);
                 }
-                mutex_unlock(&tty->ldisc_mutex);
-                tty_reset_termios(tty);
+                tty_ldisc_enable(tty);
         }
+        mutex_unlock(&tty->ldisc_mutex);
+        if (reset)
+                tty_reset_termios(tty);
 }
 
 /**
diff --git a/drivers/char/vt_ioctl.c b/drivers/char/vt_ioctl.c
index 6aa10284104a..87778dcf8727 100644
--- a/drivers/char/vt_ioctl.c
+++ b/drivers/char/vt_ioctl.c
@@ -888,7 +888,7 @@ int vt_ioctl(struct tty_struct *tty, struct file * file,
                         ret = -EFAULT;
                         goto out;
                 }
-                if (tmp.mode != VT_AUTO && tmp.mode != VT_PROCESS) {
+                if (tmp.mode != VT_AUTO && tmp.mode != VT_PROCESS && tmp.mode != VT_PROCESS_AUTO) {
                         ret = -EINVAL;
                         goto out;
                 }
@@ -1622,7 +1622,7 @@ static void complete_change_console(struct vc_data *vc)
          * telling it that it has acquired. Also check if it has died and
          * clean up (similar to logic employed in change_console())
          */
-        if (vc->vt_mode.mode == VT_PROCESS) {
+        if (vc->vt_mode.mode == VT_PROCESS || vc->vt_mode.mode == VT_PROCESS_AUTO) {
                 /*
                  * Send the signal as privileged - kill_pid() will
                  * tell us if the process has gone or something else
@@ -1682,7 +1682,7 @@ void change_console(struct vc_data *new_vc)
          * vt to auto control.
          */
         vc = vc_cons[fg_console].d;
-        if (vc->vt_mode.mode == VT_PROCESS) {
+        if (vc->vt_mode.mode == VT_PROCESS || vc->vt_mode.mode == VT_PROCESS_AUTO) {
                 /*
                  * Send the signal as privileged - kill_pid() will
                  * tell us if the process has gone or something else
@@ -1693,27 +1693,28 @@ void change_console(struct vc_data *new_vc)
                  */
                 vc->vt_newvt = new_vc->vc_num;
                 if (kill_pid(vc->vt_pid, vc->vt_mode.relsig, 1) == 0) {
+                        if(vc->vt_mode.mode == VT_PROCESS)
+                                /*
+                                 * It worked. Mark the vt to switch to and
+                                 * return. The process needs to send us a
+                                 * VT_RELDISP ioctl to complete the switch.
+                                 */
+                                return;
+                } else {
                         /*
-                         * It worked. Mark the vt to switch to and
-                         * return. The process needs to send us a
-                         * VT_RELDISP ioctl to complete the switch.
+                         * The controlling process has died, so we revert back to
+                         * normal operation. In this case, we'll also change back
+                         * to KD_TEXT mode. I'm not sure if this is strictly correct
+                         * but it saves the agony when the X server dies and the screen
+                         * remains blanked due to KD_GRAPHICS! It would be nice to do
+                         * this outside of VT_PROCESS but there is no single process
+                         * to account for and tracking tty count may be undesirable.
                          */
-                        return;
+                        reset_vc(vc);
                 }
 
                 /*
-                 * The controlling process has died, so we revert back to
-                 * normal operation. In this case, we'll also change back
-                 * to KD_TEXT mode. I'm not sure if this is strictly correct
-                 * but it saves the agony when the X server dies and the screen
-                 * remains blanked due to KD_GRAPHICS! It would be nice to do
-                 * this outside of VT_PROCESS but there is no single process
-                 * to account for and tracking tty count may be undesirable.
-                 */
-                reset_vc(vc);
-
-                /*
-                 * Fall through to normal (VT_AUTO) handling of the switch...
+                 * Fall through to normal (VT_AUTO and VT_PROCESS_AUTO) handling of the switch...
                  */
         }
 
diff --git a/drivers/mmc/card/sdio_uart.c b/drivers/mmc/card/sdio_uart.c
index f53755533e7e..3fab78ba8952 100644
--- a/drivers/mmc/card/sdio_uart.c
+++ b/drivers/mmc/card/sdio_uart.c
@@ -37,6 +37,7 @@
 #include <linux/gfp.h>
 #include <linux/tty.h>
 #include <linux/tty_flip.h>
+#include <linux/kfifo.h>
 
 #include <linux/mmc/core.h>
 #include <linux/mmc/card.h>
@@ -47,19 +48,9 @@
 #define UART_NR         8       /* Number of UARTs this driver can handle */
 
 
-#define UART_XMIT_SIZE  PAGE_SIZE
+#define FIFO_SIZE       PAGE_SIZE
 #define WAKEUP_CHARS    256
 
-#define circ_empty(circ)        ((circ)->head == (circ)->tail)
-#define circ_clear(circ)        ((circ)->head = (circ)->tail = 0)
-
-#define circ_chars_pending(circ) \
-                (CIRC_CNT((circ)->head, (circ)->tail, UART_XMIT_SIZE))
-
-#define circ_chars_free(circ) \
-                (CIRC_SPACE((circ)->head, (circ)->tail, UART_XMIT_SIZE))
-
-
 struct uart_icount {
         __u32   cts;
         __u32   dsr;
@@ -82,7 +73,7 @@ struct sdio_uart_port {
         struct mutex            func_lock;
         struct task_struct      *in_sdio_uart_irq;
         unsigned int            regs_offset;
-        struct circ_buf         xmit;
+        struct kfifo            xmit_fifo;
         spinlock_t              write_lock;
         struct uart_icount      icount;
         unsigned int            uartclk;
@@ -105,6 +96,8 @@ static int sdio_uart_add_port(struct sdio_uart_port *port)
         kref_init(&port->kref);
         mutex_init(&port->func_lock);
         spin_lock_init(&port->write_lock);
+        if (kfifo_alloc(&port->xmit_fifo, FIFO_SIZE, GFP_KERNEL))
+                return -ENOMEM;
 
         spin_lock(&sdio_uart_table_lock);
         for (index = 0; index < UART_NR; index++) {
@@ -140,6 +133,7 @@ static void sdio_uart_port_destroy(struct kref *kref)
 {
         struct sdio_uart_port *port =
                 container_of(kref, struct sdio_uart_port, kref);
+        kfifo_free(&port->xmit_fifo);
         kfree(port);
 }
 
@@ -456,9 +450,11 @@ static void sdio_uart_receive_chars(struct sdio_uart_port *port,
 
 static void sdio_uart_transmit_chars(struct sdio_uart_port *port)
 {
-        struct circ_buf *xmit = &port->xmit;
+        struct kfifo *xmit = &port->xmit_fifo;
         int count;
         struct tty_struct *tty;
+        u8 iobuf[16];
+        int len;
 
         if (port->x_char) {
                 sdio_out(port, UART_TX, port->x_char);
@@ -469,27 +465,25 @@ static void sdio_uart_transmit_chars(struct sdio_uart_port *port)
 
         tty = tty_port_tty_get(&port->port);
 
-        if (tty == NULL || circ_empty(xmit) ||
+        if (tty == NULL || !kfifo_len(xmit) ||
                                 tty->stopped || tty->hw_stopped) {
                 sdio_uart_stop_tx(port);
                 tty_kref_put(tty);
                 return;
         }
 
-        count = 16;
-        do {
-                sdio_out(port, UART_TX, xmit->buf[xmit->tail]);
-                xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
+        len = kfifo_out_locked(xmit, iobuf, 16, &port->write_lock);
+        for (count = 0; count < len; count++) {
+                sdio_out(port, UART_TX, iobuf[count]);
                 port->icount.tx++;
-                if (circ_empty(xmit))
-                        break;
-        } while (--count > 0);
+        }
 
-        if (circ_chars_pending(xmit) < WAKEUP_CHARS)
+        len = kfifo_len(xmit);
+        if (len < WAKEUP_CHARS) {
                 tty_wakeup(tty);
-
-        if (circ_empty(xmit))
-                sdio_uart_stop_tx(port);
+                if (len == 0)
+                        sdio_uart_stop_tx(port);
+        }
         tty_kref_put(tty);
 }
 
@@ -632,7 +626,6 @@ static int sdio_uart_activate(struct tty_port *tport, struct tty_struct *tty)
 {
         struct sdio_uart_port *port =
                         container_of(tport, struct sdio_uart_port, port);
-        unsigned long page;
         int ret;
 
         /*
@@ -641,22 +634,17 @@ static int sdio_uart_activate(struct tty_port *tport, struct tty_struct *tty)
          */
         set_bit(TTY_IO_ERROR, &tty->flags);
 
-        /* Initialise and allocate the transmit buffer. */
-        page = __get_free_page(GFP_KERNEL);
-        if (!page)
-                return -ENOMEM;
-        port->xmit.buf = (unsigned char *)page;
-        circ_clear(&port->xmit);
+        kfifo_reset(&port->xmit_fifo);
 
         ret = sdio_uart_claim_func(port);
         if (ret)
-                goto err1;
+                return ret;
         ret = sdio_enable_func(port->func);
         if (ret)
-                goto err2;
+                goto err1;
         ret = sdio_claim_irq(port->func, sdio_uart_irq);
         if (ret)
-                goto err3;
+                goto err2;
 
         /*
          * Clear the FIFO buffers and disable them.
@@ -700,12 +688,10 @@ static int sdio_uart_activate(struct tty_port *tport, struct tty_struct *tty)
         sdio_uart_release_func(port);
         return 0;
 
-err3:
-        sdio_disable_func(port->func);
 err2:
-        sdio_uart_release_func(port);
+        sdio_disable_func(port->func);
 err1:
-        free_page((unsigned long)port->xmit.buf);
+        sdio_uart_release_func(port);
         return ret;
 }
 
@@ -727,7 +713,7 @@ static void sdio_uart_shutdown(struct tty_port *tport)
 
         ret = sdio_uart_claim_func(port);
         if (ret)
-                goto skip;
+                return;
 
         sdio_uart_stop_rx(port);
 
@@ -749,10 +735,6 @@ static void sdio_uart_shutdown(struct tty_port *tport)
         sdio_disable_func(port->func);
 
         sdio_uart_release_func(port);
-
-skip:
-        /* Free the transmit buffer page. */
-        free_page((unsigned long)port->xmit.buf);
 }
 
 /**
@@ -822,27 +804,12 @@ static int sdio_uart_write(struct tty_struct *tty, const unsigned char *buf,
                            int count)
 {
         struct sdio_uart_port *port = tty->driver_data;
-        struct circ_buf *circ = &port->xmit;
-        int c, ret = 0;
+        int ret;
 
         if (!port->func)
                 return -ENODEV;
 
-        spin_lock(&port->write_lock);
-        while (1) {
-                c = CIRC_SPACE_TO_END(circ->head, circ->tail, UART_XMIT_SIZE);
-                if (count < c)
-                        c = count;
-                if (c <= 0)
-                        break;
-                memcpy(circ->buf + circ->head, buf, c);
-                circ->head = (circ->head + c) & (UART_XMIT_SIZE - 1);
-                buf += c;
-                count -= c;
-                ret += c;
-        }
-        spin_unlock(&port->write_lock);
-
+        ret = kfifo_in_locked(&port->xmit_fifo, buf, count, &port->write_lock);
         if (!(port->ier & UART_IER_THRI)) {
                 int err = sdio_uart_claim_func(port);
                 if (!err) {
@@ -859,13 +826,13 @@ static int sdio_uart_write(struct tty_struct *tty, const unsigned char *buf,
 static int sdio_uart_write_room(struct tty_struct *tty)
 {
         struct sdio_uart_port *port = tty->driver_data;
-        return port ? circ_chars_free(&port->xmit) : 0;
+        return FIFO_SIZE - kfifo_len(&port->xmit_fifo);
 }
 
 static int sdio_uart_chars_in_buffer(struct tty_struct *tty)
 {
         struct sdio_uart_port *port = tty->driver_data;
-        return port ? circ_chars_pending(&port->xmit) : 0;
+        return kfifo_len(&port->xmit_fifo);
 }
 
 static void sdio_uart_send_xchar(struct tty_struct *tty, char ch)
diff --git a/drivers/parport/parport_pc.c b/drivers/parport/parport_pc.c
index ad113b0f62db..0950fa40684f 100644
--- a/drivers/parport/parport_pc.c
+++ b/drivers/parport/parport_pc.c
@@ -2908,6 +2908,7 @@ enum parport_pc_pci_cards {
         netmos_9805,
         netmos_9815,
         netmos_9901,
+        netmos_9865,
         quatech_sppxp100,
 };
 
@@ -2989,6 +2990,7 @@ static struct parport_pc_pci {
         /* netmos_9805 */               { 1, { { 0, -1 }, } },
         /* netmos_9815 */               { 2, { { 0, -1 }, { 2, -1 }, } },
         /* netmos_9901 */               { 1, { { 0, -1 }, } },
+        /* netmos_9865 */               { 1, { { 0, -1 }, } },
         /* quatech_sppxp100 */          { 1, { { 0, 1 }, } },
 };
 
@@ -3092,6 +3094,10 @@ static const struct pci_device_id parport_pc_pci_tbl[] = {
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, netmos_9815 },
         { PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9901,
           0xA000, 0x2000, 0, 0, netmos_9901 },
+        { PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9865,
+          0xA000, 0x1000, 0, 0, netmos_9865 },
+        { PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9865,
+          0xA000, 0x2000, 0, 0, netmos_9865 },
         /* Quatech SPPXP-100 Parallel port PCI ExpressCard */
         { PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_SPPXP_100,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, quatech_sppxp100 },
diff --git a/drivers/serial/68328serial.c b/drivers/serial/68328serial.c
index d935b2d04f93..ae0251ef6f4e 100644
--- a/drivers/serial/68328serial.c
+++ b/drivers/serial/68328serial.c
@@ -153,8 +153,6 @@ static int baud_table[] = {
         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
         9600, 19200, 38400, 57600, 115200, 0 };
 
-#define BAUD_TABLE_SIZE (sizeof(baud_table)/sizeof(baud_table[0]))
-
 /* Sets or clears DTR/RTS on the requested line */
 static inline void m68k_rtsdtr(struct m68k_serial *ss, int set)
 {
@@ -1406,10 +1404,10 @@ static void m68328_set_baud(void)
         USTCNT = ustcnt & ~USTCNT_TXEN;
 
 again:
-        for (i = 0; i < sizeof(baud_table) / sizeof(baud_table[0]); i++)
+        for (i = 0; i < ARRAY_SIZE(baud_table); i++)
                 if (baud_table[i] == m68328_console_baud)
                         break;
-        if (i >= sizeof(baud_table) / sizeof(baud_table[0])) {
+        if (i >= ARRAY_SIZE(baud_table)) {
                 m68328_console_baud = 9600;
                 goto again;
         }
@@ -1435,7 +1433,7 @@ int m68328_console_setup(struct console *cp, char *arg)
         if (arg)
                 n = simple_strtoul(arg,NULL,0);
 
-        for (i = 0; i < BAUD_TABLE_SIZE; i++)
+        for (i = 0; i < ARRAY_SIZE(baud_table); i++)
                 if (baud_table[i] == n)
                         break;
         if (i < BAUD_TABLE_SIZE) {
diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
index a81ff7bc5fa1..7c4ebe6ee18b 100644
--- a/drivers/serial/8250.c
+++ b/drivers/serial/8250.c
@@ -2690,6 +2690,15 @@ static void __init serial8250_isa_init_ports(void)
         }
 }
 
+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;
+}
+
 static void __init
 serial8250_register_ports(struct uart_driver *drv, struct device *dev)
 {
@@ -2706,6 +2715,10 @@ serial8250_register_ports(struct uart_driver *drv, struct device *dev)
                 struct uart_8250_port *up = &serial8250_ports[i];
 
                 up->port.dev = dev;
+
+                if (up->port.flags & UPF_FIXED_TYPE)
+                        serial8250_init_fixed_type_port(up, up->port.type);
+
                 uart_add_one_port(drv, &up->port);
         }
 }
@@ -3118,12 +3131,8 @@ int serial8250_register_port(struct uart_port *port)
                 if (port->dev)
                         uart->port.dev = port->dev;
 
-                if (port->flags & UPF_FIXED_TYPE) {
-                        uart->port.type = port->type;
-                        uart->port.fifosize = uart_config[port->type].fifo_size;
-                        uart->capabilities = uart_config[port->type].flags;
-                        uart->tx_loadsz = uart_config[port->type].tx_loadsz;
-                }
+                if (port->flags & UPF_FIXED_TYPE)
+                        serial8250_init_fixed_type_port(uart, port->type);
 
                 set_io_from_upio(&uart->port);
                 /* Possibly override default I/O functions.  */
diff --git a/drivers/serial/8250_pci.c b/drivers/serial/8250_pci.c
index b28af13c45a1..01c012da4e26 100644
--- a/drivers/serial/8250_pci.c
+++ b/drivers/serial/8250_pci.c
@@ -760,7 +760,8 @@ static int pci_netmos_init(struct pci_dev *dev)
         /* subdevice 0x00PS means <P> parallel, <S> serial */
         unsigned int num_serial = dev->subsystem_device & 0xf;
 
-        if (dev->device == PCI_DEVICE_ID_NETMOS_9901)
+        if ((dev->device == PCI_DEVICE_ID_NETMOS_9901) ||
+                (dev->device == PCI_DEVICE_ID_NETMOS_9865))
                 return 0;
         if (dev->subsystem_vendor == PCI_VENDOR_ID_IBM &&
                         dev->subsystem_device == 0x0299)
@@ -1479,6 +1480,7 @@ enum pci_board_num_t {
 
         pbn_b0_bt_1_115200,
         pbn_b0_bt_2_115200,
+        pbn_b0_bt_4_115200,
         pbn_b0_bt_8_115200,
 
         pbn_b0_bt_1_460800,
@@ -1703,6 +1705,12 @@ static struct pciserial_board pci_boards[] __devinitdata = {
                 .base_baud      = 115200,
                 .uart_offset    = 8,
         },
+        [pbn_b0_bt_4_115200] = {
+                .flags          = FL_BASE0|FL_BASE_BARS,
+                .num_ports      = 4,
+                .base_baud      = 115200,
+                .uart_offset    = 8,
+        },
         [pbn_b0_bt_8_115200] = {
                 .flags          = FL_BASE0|FL_BASE_BARS,
                 .num_ports      = 8,
@@ -3191,6 +3199,15 @@ static struct pci_device_id serial_pci_tbl[] = {
                 0x1208, 0x0004, 0, 0,
                 pbn_b0_4_921600 },
 
+        {       PCI_VENDOR_ID_KORENIX, PCI_DEVICE_ID_KORENIX_JETCARDF2,
+                0x1204, 0x0004, 0, 0,
+                pbn_b0_4_921600 },
+        {       PCI_VENDOR_ID_KORENIX, PCI_DEVICE_ID_KORENIX_JETCARDF2,
+                0x1208, 0x0004, 0, 0,
+                pbn_b0_4_921600 },
+        {       PCI_VENDOR_ID_KORENIX, PCI_DEVICE_ID_KORENIX_JETCARDF3,
+                0x1208, 0x0004, 0, 0,
+                pbn_b0_4_921600 },
         /*
          * Dell Remote Access Card 4 - Tim_T_Murphy@Dell.com
          */
@@ -3649,6 +3666,18 @@ static struct pci_device_id serial_pci_tbl[] = {
                 0, 0, pbn_b0_1_115200 },
 
         /*
+         * Best Connectivity PCI Multi I/O cards
+         */
+
+        {       PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9865,
+                0xA000, 0x1000,
+                0, 0, pbn_b0_1_115200 },
+
+        {       PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9865,
+                0xA000, 0x3004,
+                0, 0, pbn_b0_bt_4_115200 },
+
+        /*
          * These entries match devices with class COMMUNICATION_SERIAL,
          * COMMUNICATION_MODEM or COMMUNICATION_MULTISERIAL
          */
diff --git a/drivers/serial/Kconfig b/drivers/serial/Kconfig
index 888a0ce91c4b..746e07033dce 100644
--- a/drivers/serial/Kconfig
+++ b/drivers/serial/Kconfig
@@ -1418,42 +1418,37 @@ config SERIAL_BFIN_SPORT
           To compile this driver as a module, choose M here: the
           module will be called bfin_sport_uart.
 
-choice
-        prompt "Baud rate for Blackfin SPORT UART"
-        depends on SERIAL_BFIN_SPORT
-        default SERIAL_SPORT_BAUD_RATE_57600
-        help
-          Choose a baud rate for the SPORT UART, other uart settings are
-          8 bit, 1 stop bit, no parity, no flow control.
-
-config SERIAL_SPORT_BAUD_RATE_115200
-        bool "115200"
-
-config SERIAL_SPORT_BAUD_RATE_57600
-        bool "57600"
+config SERIAL_BFIN_SPORT_CONSOLE
+        bool "Console on Blackfin sport emulated uart"
+        depends on SERIAL_BFIN_SPORT=y
+        select SERIAL_CORE_CONSOLE
 
-config SERIAL_SPORT_BAUD_RATE_38400
-        bool "38400"
+config SERIAL_BFIN_SPORT0_UART
+        bool "Enable UART over SPORT0"
+        depends on SERIAL_BFIN_SPORT && !(BF542 || BF542M || BF544 || BF544M)
+        help
+          Enable UART over SPORT0
 
-config SERIAL_SPORT_BAUD_RATE_19200
-        bool "19200"
+config SERIAL_BFIN_SPORT1_UART
+        bool "Enable UART over SPORT1"
+        depends on SERIAL_BFIN_SPORT
+        help
+          Enable UART over SPORT1
 
-config SERIAL_SPORT_BAUD_RATE_9600
-        bool "9600"
-endchoice
+config SERIAL_BFIN_SPORT2_UART
+        bool "Enable UART over SPORT2"
+        depends on SERIAL_BFIN_SPORT && (BF54x || BF538 || BF539)
+        help
+          Enable UART over SPORT2
 
-config SPORT_BAUD_RATE
-        int
-        depends on SERIAL_BFIN_SPORT
-        default 115200 if (SERIAL_SPORT_BAUD_RATE_115200)
-        default 57600 if (SERIAL_SPORT_BAUD_RATE_57600)
-        default 38400 if (SERIAL_SPORT_BAUD_RATE_38400)
-        default 19200 if (SERIAL_SPORT_BAUD_RATE_19200)
-        default 9600 if (SERIAL_SPORT_BAUD_RATE_9600)
+config SERIAL_BFIN_SPORT3_UART
+        bool "Enable UART over SPORT3"
+        depends on SERIAL_BFIN_SPORT && (BF54x || BF538 || BF539)
+        help
+          Enable UART over SPORT3
 
 config SERIAL_TIMBERDALE
         tristate "Support for timberdale UART"
-        depends on MFD_TIMBERDALE
         select SERIAL_CORE
         ---help---
         Add support for UART controller on timberdale.
diff --git a/drivers/serial/atmel_serial.c b/drivers/serial/atmel_serial.c
index 9d948bccafaf..2c9bf9b68327 100644
--- a/drivers/serial/atmel_serial.c
+++ b/drivers/serial/atmel_serial.c
@@ -1213,6 +1213,24 @@ static int atmel_verify_port(struct uart_port *port, struct serial_struct *ser)
         return ret;
 }
 
+#ifdef CONFIG_CONSOLE_POLL
+static int atmel_poll_get_char(struct uart_port *port)
+{
+        while (!(UART_GET_CSR(port) & ATMEL_US_RXRDY))
+                cpu_relax();
+
+        return UART_GET_CHAR(port);
+}
+
+static void atmel_poll_put_char(struct uart_port *port, unsigned char ch)
+{
+        while (!(UART_GET_CSR(port) & ATMEL_US_TXRDY))
+                cpu_relax();
+
+        UART_PUT_CHAR(port, ch);
+}
+#endif
+
 static struct uart_ops atmel_pops = {
         .tx_empty       = atmel_tx_empty,
         .set_mctrl      = atmel_set_mctrl,
@@ -1232,6 +1250,10 @@ static struct uart_ops atmel_pops = {
         .config_port    = atmel_config_port,
         .verify_port    = atmel_verify_port,
         .pm             = atmel_serial_pm,
+#ifdef CONFIG_CONSOLE_POLL
+        .poll_get_char  = atmel_poll_get_char,
+        .poll_put_char  = atmel_poll_put_char,
+#endif
 };
 
 /*
diff --git a/drivers/serial/bcm63xx_uart.c b/drivers/serial/bcm63xx_uart.c
index 37ad0c449937..a1a0e55d0807 100644
--- a/drivers/serial/bcm63xx_uart.c
+++ b/drivers/serial/bcm63xx_uart.c
@@ -35,7 +35,7 @@
 #include <bcm63xx_regs.h>
 #include <bcm63xx_io.h>
 
-#define BCM63XX_NR_UARTS        1
+#define BCM63XX_NR_UARTS        2
 
 static struct uart_port ports[BCM63XX_NR_UARTS];
 
@@ -784,7 +784,7 @@ static struct uart_driver bcm_uart_driver = {
         .dev_name       = "ttyS",
         .major          = TTY_MAJOR,
         .minor          = 64,
-        .nr             = 1,
+        .nr             = BCM63XX_NR_UARTS,
         .cons           = BCM63XX_CONSOLE,
 };
 
@@ -826,11 +826,12 @@ static int __devinit bcm_uart_probe(struct platform_device *pdev)
         port->dev = &pdev->dev;
         port->fifosize = 16;
         port->uartclk = clk_get_rate(clk) / 2;
+        port->line = pdev->id;
         clk_put(clk);
 
         ret = uart_add_one_port(&bcm_uart_driver, port);
         if (ret) {
-                kfree(port);
+                ports[pdev->id].membase = 0;
                 return ret;
         }
         platform_set_drvdata(pdev, port);
diff --git a/drivers/serial/bfin_5xx.c b/drivers/serial/bfin_5xx.c
index 50abb7e557f4..fcf273e3f48c 100644
--- a/drivers/serial/bfin_5xx.c
+++ b/drivers/serial/bfin_5xx.c
@@ -14,6 +14,7 @@
 
 #include <linux/module.h>
 #include <linux/ioport.h>
+#include <linux/io.h>
 #include <linux/init.h>
 #include <linux/console.h>
 #include <linux/sysrq.h>
@@ -237,7 +238,8 @@ static void bfin_serial_rx_chars(struct bfin_serial_port *uart)
 
 #if defined(CONFIG_KGDB_SERIAL_CONSOLE) || \
         defined(CONFIG_KGDB_SERIAL_CONSOLE_MODULE)
-        if (kgdb_connected && kgdboc_port_line == uart->port.line)
+        if (kgdb_connected && kgdboc_port_line == uart->port.line
+                && kgdboc_break_enabled)
                 if (ch == 0x3) {/* Ctrl + C */
                         kgdb_breakpoint();
                         return;
@@ -488,6 +490,7 @@ void bfin_serial_rx_dma_timeout(struct bfin_serial_port *uart)
 {
         int x_pos, pos;
 
+        dma_disable_irq(uart->tx_dma_channel);
         dma_disable_irq(uart->rx_dma_channel);
         spin_lock_bh(&uart->port.lock);
 
@@ -521,6 +524,7 @@ void bfin_serial_rx_dma_timeout(struct bfin_serial_port *uart)
         }
 
         spin_unlock_bh(&uart->port.lock);
+        dma_enable_irq(uart->tx_dma_channel);
         dma_enable_irq(uart->rx_dma_channel);
 
         mod_timer(&(uart->rx_dma_timer), jiffies + DMA_RX_FLUSH_JIFFIES);
@@ -746,15 +750,6 @@ static int bfin_serial_startup(struct uart_port *port)
                         Status interrupt.\n");
         }
 
-        if (uart->cts_pin >= 0) {
-                gpio_request(uart->cts_pin, DRIVER_NAME);
-                gpio_direction_output(uart->cts_pin, 1);
-        }
-        if (uart->rts_pin >= 0) {
-                gpio_request(uart->rts_pin, DRIVER_NAME);
-                gpio_direction_output(uart->rts_pin, 0);
-        }
-
         /* CTS RTS PINs are negative assertive. */
         UART_PUT_MCR(uart, ACTS);
         UART_SET_IER(uart, EDSSI);
@@ -801,10 +796,6 @@ static void bfin_serial_shutdown(struct uart_port *port)
                 gpio_free(uart->rts_pin);
 #endif
 #ifdef CONFIG_SERIAL_BFIN_HARD_CTSRTS
-        if (uart->cts_pin >= 0)
-                gpio_free(uart->cts_pin);
-        if (uart->rts_pin >= 0)
-                gpio_free(uart->rts_pin);
         if (UART_GET_IER(uart) && EDSSI)
                 free_irq(uart->status_irq, uart);
 #endif
@@ -1409,8 +1400,7 @@ static int bfin_serial_remove(struct platform_device *dev)
                         continue;
                 uart_remove_one_port(&bfin_serial_reg, &bfin_serial_ports[i].port);
                 bfin_serial_ports[i].port.dev = NULL;
-#if defined(CONFIG_SERIAL_BFIN_CTSRTS) || \
-        defined(CONFIG_SERIAL_BFIN_HARD_CTSRTS)
+#if defined(CONFIG_SERIAL_BFIN_CTSRTS)
                 gpio_free(bfin_serial_ports[i].cts_pin);
                 gpio_free(bfin_serial_ports[i].rts_pin);
 #endif
diff --git a/drivers/serial/bfin_sport_uart.c b/drivers/serial/bfin_sport_uart.c
index 088bb35475f1..7c72888fbf94 100644
--- a/drivers/serial/bfin_sport_uart.c
+++ b/drivers/serial/bfin_sport_uart.c
@@ -1,27 +1,11 @@
 /*
- * File:        linux/drivers/serial/bfin_sport_uart.c
+ * Blackfin On-Chip Sport Emulated UART Driver
  *
- * Based on:    drivers/serial/bfin_5xx.c by Aubrey Li.
- * Author:      Roy Huang <roy.huang@analog.com>
+ * Copyright 2006-2009 Analog Devices Inc.
  *
- * Created:     Nov 22, 2006
- * Copyright:   (c) 2006-2007 Analog Devices Inc.
- * Description: this driver enable SPORTs on Blackfin emulate UART.
+ * Enter bugs at http://blackfin.uclinux.org/
  *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see the file COPYING, or write
- * to the Free Software Foundation, Inc.,
- * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ * Licensed under the GPL-2 or later.
  */
 
 /*
@@ -29,39 +13,18 @@
  * http://www.analog.com/UploadedFiles/Application_Notes/399447663EE191.pdf
  * This application note describe how to implement a UART on a Sharc DSP,
  * but this driver is implemented on Blackfin Processor.
+ * Transmit Frame Sync is not used by this driver to transfer data out.
  */
 
-/* After reset, there is a prelude of low level pulse when transmit data first
- * time. No addtional pulse in following transmit.
- * According to document:
- * The SPORTs are ready to start transmitting or receiving data no later than
- * three serial clock cycles after they are enabled in the SPORTx_TCR1 or
- * SPORTx_RCR1 register. No serial clock cycles are lost from this point on.
- * The first internal frame sync will occur one frame sync delay after the
- * SPORTs are ready. External frame syncs can occur as soon as the SPORT is
- * ready.
- */
+/* #define DEBUG */
 
-/* Thanks to Axel Alatalo <axel@rubico.se> for fixing sport rx bug. Sometimes
- * sport receives data incorrectly. The following is Axel's words.
- * As EE-191, sport rx samples 3 times of the UART baudrate and takes the
- * middle smaple of every 3 samples as the data bit. For a 8-N-1 UART setting,
- * 30 samples will be required for a byte. If transmitter sends a 1/3 bit short
- * byte due to buadrate drift, then the 30th sample of a byte, this sample is
- * also the third sample of the stop bit, will happens on the immediately
- * following start bit which will be thrown away and missed. Thus since parts
- * of the startbit will be missed and the receiver will begin to drift, the
- * effect accumulates over time until synchronization is lost.
- * If only require 2 samples of the stopbit (by sampling in total 29 samples),
- * then a to short byte as in the case above will be tolerated. Then the 1/3
- * early startbit will trigger a framesync since the last read is complete
- * after only 2/3 stopbit and framesync is active during the last 1/3 looking
- * for a possible early startbit. */
-
-//#define DEBUG
+#define DRV_NAME "bfin-sport-uart"
+#define DEVICE_NAME     "ttySS"
+#define pr_fmt(fmt) DRV_NAME ": " fmt
 
 #include <linux/module.h>
 #include <linux/ioport.h>
+#include <linux/io.h>
 #include <linux/init.h>
 #include <linux/console.h>
 #include <linux/sysrq.h>
@@ -75,23 +38,36 @@
 
 #include "bfin_sport_uart.h"
 
+#ifdef CONFIG_SERIAL_BFIN_SPORT0_UART
 unsigned short bfin_uart_pin_req_sport0[] =
         {P_SPORT0_TFS, P_SPORT0_DTPRI, P_SPORT0_TSCLK, P_SPORT0_RFS, \
          P_SPORT0_DRPRI, P_SPORT0_RSCLK, P_SPORT0_DRSEC, P_SPORT0_DTSEC, 0};
-
+#endif
+#ifdef CONFIG_SERIAL_BFIN_SPORT1_UART
 unsigned short bfin_uart_pin_req_sport1[] =
         {P_SPORT1_TFS, P_SPORT1_DTPRI, P_SPORT1_TSCLK, P_SPORT1_RFS, \
         P_SPORT1_DRPRI, P_SPORT1_RSCLK, P_SPORT1_DRSEC, P_SPORT1_DTSEC, 0};
-
-#define DRV_NAME "bfin-sport-uart"
+#endif
+#ifdef CONFIG_SERIAL_BFIN_SPORT2_UART
+unsigned short bfin_uart_pin_req_sport2[] =
+        {P_SPORT2_TFS, P_SPORT2_DTPRI, P_SPORT2_TSCLK, P_SPORT2_RFS, \
+        P_SPORT2_DRPRI, P_SPORT2_RSCLK, P_SPORT2_DRSEC, P_SPORT2_DTSEC, 0};
+#endif
+#ifdef CONFIG_SERIAL_BFIN_SPORT3_UART
+unsigned short bfin_uart_pin_req_sport3[] =
+        {P_SPORT3_TFS, P_SPORT3_DTPRI, P_SPORT3_TSCLK, P_SPORT3_RFS, \
+        P_SPORT3_DRPRI, P_SPORT3_RSCLK, P_SPORT3_DRSEC, P_SPORT3_DTSEC, 0};
+#endif
 
 struct sport_uart_port {
         struct uart_port        port;
-        char                    *name;
-
-        int                     tx_irq;
-        int                     rx_irq;
         int                     err_irq;
+        unsigned short          csize;
+        unsigned short          rxmask;
+        unsigned short          txmask1;
+        unsigned short          txmask2;
+        unsigned char           stopb;
+/*      unsigned char           parib; */
 };
 
 static void sport_uart_tx_chars(struct sport_uart_port *up);
@@ -99,36 +75,42 @@ static void sport_stop_tx(struct uart_port *port);
 
 static inline void tx_one_byte(struct sport_uart_port *up, unsigned int value)
 {
-        pr_debug("%s value:%x\n", __func__, value);
-        /* Place a Start and Stop bit */
+        pr_debug("%s value:%x, mask1=0x%x, mask2=0x%x\n", __func__, value,
+                up->txmask1, up->txmask2);
+
+        /* Place Start and Stop bits */
         __asm__ __volatile__ (
-                "R2 = b#01111111100;"
-                "R3 = b#10000000001;"
-                "%0 <<= 2;"
-                "%0 = %0 & R2;"
-                "%0 = %0 | R3;"
-                : "=d"(value)
-                : "d"(value)
-                : "ASTAT", "R2", "R3"
+                "%[val] <<= 1;"
+                "%[val] = %[val] & %[mask1];"
+                "%[val] = %[val] | %[mask2];"
+                : [val]"+d"(value)
+                : [mask1]"d"(up->txmask1), [mask2]"d"(up->txmask2)
+                : "ASTAT"
         );
         pr_debug("%s value:%x\n", __func__, value);
 
         SPORT_PUT_TX(up, value);
 }
 
-static inline unsigned int rx_one_byte(struct sport_uart_port *up)
+static inline unsigned char rx_one_byte(struct sport_uart_port *up)
 {
-        unsigned int value, extract;
+        unsigned int value;
+        unsigned char extract;
         u32 tmp_mask1, tmp_mask2, tmp_shift, tmp;
 
-        value = SPORT_GET_RX32(up);
-        pr_debug("%s value:%x\n", __func__, value);
+        if ((up->csize + up->stopb) > 7)
+                value = SPORT_GET_RX32(up);
+        else
+                value = SPORT_GET_RX(up);
+
+        pr_debug("%s value:%x, cs=%d, mask=0x%x\n", __func__, value,
+                up->csize, up->rxmask);
 
-        /* Extract 8 bits data */
+        /* Extract data */
         __asm__ __volatile__ (
                 "%[extr] = 0;"
-                "%[mask1] = 0x1801(Z);"
-                "%[mask2] = 0x0300(Z);"
+                "%[mask1] = %[rxmask];"
+                "%[mask2] = 0x0200(Z);"
                 "%[shift] = 0;"
                 "LSETUP(.Lloop_s, .Lloop_e) LC0 = %[lc];"
                 ".Lloop_s:"
@@ -138,9 +120,9 @@ static inline unsigned int rx_one_byte(struct sport_uart_port *up)
                 "%[mask1] = %[mask1] - %[mask2];"
                 ".Lloop_e:"
                 "%[shift] += 1;"
-                : [val]"=d"(value), [extr]"=d"(extract), [shift]"=d"(tmp_shift), [tmp]"=d"(tmp),
-                  [mask1]"=d"(tmp_mask1), [mask2]"=d"(tmp_mask2)
-                : "d"(value), [lc]"a"(8)
+                : [extr]"=&d"(extract), [shift]"=&d"(tmp_shift), [tmp]"=&d"(tmp),
+                  [mask1]"=&d"(tmp_mask1), [mask2]"=&d"(tmp_mask2)
+                : [val]"d"(value), [rxmask]"d"(up->rxmask), [lc]"a"(up->csize)
                 : "ASTAT", "LB0", "LC0", "LT0"
         );
 
@@ -148,29 +130,28 @@ static inline unsigned int rx_one_byte(struct sport_uart_port *up)
         return extract;
 }
 
-static int sport_uart_setup(struct sport_uart_port *up, int sclk, int baud_rate)
+static int sport_uart_setup(struct sport_uart_port *up, int size, int baud_rate)
 {
-        int tclkdiv, tfsdiv, rclkdiv;
+        int tclkdiv, rclkdiv;
+        unsigned int sclk = get_sclk();
 
-        /* Set TCR1 and TCR2 */
-        SPORT_PUT_TCR1(up, (LATFS | ITFS | TFSR | TLSBIT | ITCLK));
-        SPORT_PUT_TCR2(up, 10);
+        /* Set TCR1 and TCR2, TFSR is not enabled for uart */
+        SPORT_PUT_TCR1(up, (ITFS | TLSBIT | ITCLK));
+        SPORT_PUT_TCR2(up, size + 1);
         pr_debug("%s TCR1:%x, TCR2:%x\n", __func__, SPORT_GET_TCR1(up), SPORT_GET_TCR2(up));
 
         /* Set RCR1 and RCR2 */
         SPORT_PUT_RCR1(up, (RCKFE | LARFS | LRFS | RFSR | IRCLK));
-        SPORT_PUT_RCR2(up, 28);
+        SPORT_PUT_RCR2(up, (size + 1) * 2 - 1);
         pr_debug("%s RCR1:%x, RCR2:%x\n", __func__, SPORT_GET_RCR1(up), SPORT_GET_RCR2(up));
 
-        tclkdiv = sclk/(2 * baud_rate) - 1;
-        tfsdiv = 12;
-        rclkdiv = sclk/(2 * baud_rate * 3) - 1;
+        tclkdiv = sclk / (2 * baud_rate) - 1;
+        rclkdiv = sclk / (2 * baud_rate * 2) - 1;
         SPORT_PUT_TCLKDIV(up, tclkdiv);
-        SPORT_PUT_TFSDIV(up, tfsdiv);
         SPORT_PUT_RCLKDIV(up, rclkdiv);
         SSYNC();
-        pr_debug("%s sclk:%d, baud_rate:%d, tclkdiv:%d, tfsdiv:%d, rclkdiv:%d\n",
-                        __func__, sclk, baud_rate, tclkdiv, tfsdiv, rclkdiv);
+        pr_debug("%s sclk:%d, baud_rate:%d, tclkdiv:%d, rclkdiv:%d\n",
+                        __func__, sclk, baud_rate, tclkdiv, rclkdiv);
 
         return 0;
 }
@@ -181,23 +162,29 @@ static irqreturn_t sport_uart_rx_irq(int irq, void *dev_id)
         struct tty_struct *tty = up->port.state->port.tty;
         unsigned int ch;
 
-        do {
+        spin_lock(&up->port.lock);
+
+        while (SPORT_GET_STAT(up) & RXNE) {
                 ch = rx_one_byte(up);
                 up->port.icount.rx++;
 
-                if (uart_handle_sysrq_char(&up->port, ch))
-                        ;
-                else
+                if (!uart_handle_sysrq_char(&up->port, ch))
                         tty_insert_flip_char(tty, ch, TTY_NORMAL);
-        } while (SPORT_GET_STAT(up) & RXNE);
+        }
         tty_flip_buffer_push(tty);
 
+        spin_unlock(&up->port.lock);
+
         return IRQ_HANDLED;
 }
 
 static irqreturn_t sport_uart_tx_irq(int irq, void *dev_id)
 {
-        sport_uart_tx_chars(dev_id);
+        struct sport_uart_port *up = dev_id;
+
+        spin_lock(&up->port.lock);
+        sport_uart_tx_chars(up);
+        spin_unlock(&up->port.lock);
 
         return IRQ_HANDLED;
 }
@@ -208,6 +195,8 @@ static irqreturn_t sport_uart_err_irq(int irq, void *dev_id)
         struct tty_struct *tty = up->port.state->port.tty;
         unsigned int stat = SPORT_GET_STAT(up);
 
+        spin_lock(&up->port.lock);
+
         /* Overflow in RX FIFO */
         if (stat & ROVF) {
                 up->port.icount.overrun++;
@@ -216,15 +205,16 @@ static irqreturn_t sport_uart_err_irq(int irq, void *dev_id)
         }
         /* These should not happen */
         if (stat & (TOVF | TUVF | RUVF)) {
-                printk(KERN_ERR "SPORT Error:%s %s %s\n",
-                                (stat & TOVF)?"TX overflow":"",
-                                (stat & TUVF)?"TX underflow":"",
-                                (stat & RUVF)?"RX underflow":"");
+                pr_err("SPORT Error:%s %s %s\n",
+                       (stat & TOVF) ? "TX overflow" : "",
+                       (stat & TUVF) ? "TX underflow" : "",
+                       (stat & RUVF) ? "RX underflow" : "");
                 SPORT_PUT_TCR1(up, SPORT_GET_TCR1(up) & ~TSPEN);
                 SPORT_PUT_RCR1(up, SPORT_GET_RCR1(up) & ~RSPEN);
         }
         SSYNC();
 
+        spin_unlock(&up->port.lock);
         return IRQ_HANDLED;
 }
 
@@ -232,60 +222,37 @@ static irqreturn_t sport_uart_err_irq(int irq, void *dev_id)
 static int sport_startup(struct uart_port *port)
 {
         struct sport_uart_port *up = (struct sport_uart_port *)port;
-        char buffer[20];
-        int retval;
+        int ret;
 
         pr_debug("%s enter\n", __func__);
-        snprintf(buffer, 20, "%s rx", up->name);
-        retval = request_irq(up->rx_irq, sport_uart_rx_irq, IRQF_SAMPLE_RANDOM, buffer, up);
-        if (retval) {
-                printk(KERN_ERR "Unable to request interrupt %s\n", buffer);
-                return retval;
+        ret = request_irq(up->port.irq, sport_uart_rx_irq, 0,
+                "SPORT_UART_RX", up);
+        if (ret) {
+                dev_err(port->dev, "unable to request SPORT RX interrupt\n");
+                return ret;
         }
 
-        snprintf(buffer, 20, "%s tx", up->name);
-        retval = request_irq(up->tx_irq, sport_uart_tx_irq, IRQF_SAMPLE_RANDOM, buffer, up);
-        if (retval) {
-                printk(KERN_ERR "Unable to request interrupt %s\n", buffer);
+        ret = request_irq(up->port.irq+1, sport_uart_tx_irq, 0,
+                "SPORT_UART_TX", up);
+        if (ret) {
+                dev_err(port->dev, "unable to request SPORT TX interrupt\n");
                 goto fail1;
         }
 
-        snprintf(buffer, 20, "%s err", up->name);
-        retval = request_irq(up->err_irq, sport_uart_err_irq, IRQF_SAMPLE_RANDOM, buffer, up);
-        if (retval) {
-                printk(KERN_ERR "Unable to request interrupt %s\n", buffer);
+        ret = request_irq(up->err_irq, sport_uart_err_irq, 0,
+                "SPORT_UART_STATUS", up);
+        if (ret) {
+                dev_err(port->dev, "unable to request SPORT status interrupt\n");
                 goto fail2;
         }
 
-        if (port->line) {
-                if (peripheral_request_list(bfin_uart_pin_req_sport1, DRV_NAME))
-                        goto fail3;
-        } else {
-                if (peripheral_request_list(bfin_uart_pin_req_sport0, DRV_NAME))
-                        goto fail3;
-        }
-
-        sport_uart_setup(up, get_sclk(), port->uartclk);
-
-        /* Enable receive interrupt */
-        SPORT_PUT_RCR1(up, (SPORT_GET_RCR1(up) | RSPEN));
-        SSYNC();
-
         return 0;
+ fail2:
+        free_irq(up->port.irq+1, up);
+ fail1:
+        free_irq(up->port.irq, up);
 
-
-fail3:
-        printk(KERN_ERR DRV_NAME
-                ": Requesting Peripherals failed\n");
-
-        free_irq(up->err_irq, up);
-fail2:
-        free_irq(up->tx_irq, up);
-fail1:
-        free_irq(up->rx_irq, up);
-
-        return retval;
-
+        return ret;
 }
 
 static void sport_uart_tx_chars(struct sport_uart_port *up)
@@ -344,20 +311,17 @@ static void sport_set_mctrl(struct uart_port *port, unsigned int mctrl)
 static void sport_stop_tx(struct uart_port *port)
 {
         struct sport_uart_port *up = (struct sport_uart_port *)port;
-        unsigned int stat;
 
         pr_debug("%s enter\n", __func__);
 
-        stat = SPORT_GET_STAT(up);
-        while(!(stat & TXHRE)) {
-                udelay(1);
-                stat = SPORT_GET_STAT(up);
-        }
         /* Although the hold register is empty, last byte is still in shift
-         * register and not sent out yet. If baud rate is lower than default,
-         * delay should be longer. For example, if the baud rate is 9600,
-         * the delay must be at least 2ms by experience */
-        udelay(500);
+         * register and not sent out yet. So, put a dummy data into TX FIFO.
+         * Then, sport tx stops when last byte is shift out and the dummy
+         * data is moved into the shift register.
+         */
+        SPORT_PUT_TX(up, 0xffff);
+        while (!(SPORT_GET_STAT(up) & TXHRE))
+                cpu_relax();
 
         SPORT_PUT_TCR1(up, (SPORT_GET_TCR1(up) & ~TSPEN));
         SSYNC();
@@ -370,6 +334,7 @@ static void sport_start_tx(struct uart_port *port)
         struct sport_uart_port *up = (struct sport_uart_port *)port;
 
         pr_debug("%s enter\n", __func__);
+
         /* Write data into SPORT FIFO before enable SPROT to transmit */
         sport_uart_tx_chars(up);
 
@@ -403,37 +368,24 @@ static void sport_shutdown(struct uart_port *port)
 {
         struct sport_uart_port *up = (struct sport_uart_port *)port;
 
-        pr_debug("%s enter\n", __func__);
+        dev_dbg(port->dev, "%s enter\n", __func__);
 
         /* Disable sport */
         SPORT_PUT_TCR1(up, (SPORT_GET_TCR1(up) & ~TSPEN));
         SPORT_PUT_RCR1(up, (SPORT_GET_RCR1(up) & ~RSPEN));
         SSYNC();
 
-        if (port->line) {
-                peripheral_free_list(bfin_uart_pin_req_sport1);
-        } else {
-                peripheral_free_list(bfin_uart_pin_req_sport0);
-        }
-
-        free_irq(up->rx_irq, up);
-        free_irq(up->tx_irq, up);
+        free_irq(up->port.irq, up);
+        free_irq(up->port.irq+1, up);
         free_irq(up->err_irq, up);
 }
 
-static void sport_set_termios(struct uart_port *port,
-                struct ktermios *termios, struct ktermios *old)
-{
-        pr_debug("%s enter, c_cflag:%08x\n", __func__, termios->c_cflag);
-        uart_update_timeout(port, CS8 ,port->uartclk);
-}
-
 static const char *sport_type(struct uart_port *port)
 {
         struct sport_uart_port *up = (struct sport_uart_port *)port;
 
         pr_debug("%s enter\n", __func__);
-        return up->name;
+        return up->port.type == PORT_BFIN_SPORT ? "BFIN-SPORT-UART" : NULL;
 }
 
 static void sport_release_port(struct uart_port *port)
@@ -461,6 +413,110 @@ static int sport_verify_port(struct uart_port *port, struct serial_struct *ser)
         return 0;
 }
 
+static void sport_set_termios(struct uart_port *port,
+                struct ktermios *termios, struct ktermios *old)
+{
+        struct sport_uart_port *up = (struct sport_uart_port *)port;
+        unsigned long flags;
+        int i;
+
+        pr_debug("%s enter, c_cflag:%08x\n", __func__, termios->c_cflag);
+
+        switch (termios->c_cflag & CSIZE) {
+        case CS8:
+                up->csize = 8;
+                break;
+        case CS7:
+                up->csize = 7;
+                break;
+        case CS6:
+                up->csize = 6;
+                break;
+        case CS5:
+                up->csize = 5;
+                break;
+        default:
+                pr_warning("requested word length not supported\n");
+        }
+
+        if (termios->c_cflag & CSTOPB) {
+                up->stopb = 1;
+        }
+        if (termios->c_cflag & PARENB) {
+                pr_warning("PAREN bits is not supported yet\n");
+                /* up->parib = 1; */
+        }
+
+        port->read_status_mask = OE;
+        if (termios->c_iflag & INPCK)
+                port->read_status_mask |= (FE | PE);
+        if (termios->c_iflag & (BRKINT | PARMRK))
+                port->read_status_mask |= BI;
+
+        /*
+         * Characters to ignore
+         */
+        port->ignore_status_mask = 0;
+        if (termios->c_iflag & IGNPAR)
+                port->ignore_status_mask |= FE | PE;
+        if (termios->c_iflag & IGNBRK) {
+                port->ignore_status_mask |= BI;
+                /*
+                 * If we're ignoring parity and break indicators,
+                 * ignore overruns too (for real raw support).
+                 */
+                if (termios->c_iflag & IGNPAR)
+                        port->ignore_status_mask |= OE;
+        }
+
+        /* RX extract mask */
+        up->rxmask = 0x01 | (((up->csize + up->stopb) * 2 - 1) << 0x8);
+        /* TX masks, 8 bit data and 1 bit stop for example:
+         * mask1 = b#0111111110
+         * mask2 = b#1000000000
+         */
+        for (i = 0, up->txmask1 = 0; i < up->csize; i++)
+                up->txmask1 |= (1<<i);
+        up->txmask2 = (1<<i);
+        if (up->stopb) {
+                ++i;
+                up->txmask2 |= (1<<i);
+        }
+        up->txmask1 <<= 1;
+        up->txmask2 <<= 1;
+        /* uart baud rate */
+        port->uartclk = uart_get_baud_rate(port, termios, old, 0, get_sclk()/16);
+
+        spin_lock_irqsave(&up->port.lock, flags);
+
+        /* Disable UART */
+        SPORT_PUT_TCR1(up, SPORT_GET_TCR1(up) & ~TSPEN);
+        SPORT_PUT_RCR1(up, SPORT_GET_RCR1(up) & ~RSPEN);
+
+        sport_uart_setup(up, up->csize + up->stopb, port->uartclk);
+
+        /* driver TX line high after config, one dummy data is
+         * necessary to stop sport after shift one byte
+         */
+        SPORT_PUT_TX(up, 0xffff);
+        SPORT_PUT_TX(up, 0xffff);
+        SPORT_PUT_TCR1(up, (SPORT_GET_TCR1(up) | TSPEN));
+        SSYNC();
+        while (!(SPORT_GET_STAT(up) & TXHRE))
+                cpu_relax();
+        SPORT_PUT_TCR1(up, SPORT_GET_TCR1(up) & ~TSPEN);
+        SSYNC();
+
+        /* Port speed changed, update the per-port timeout. */
+        uart_update_timeout(port, termios->c_cflag, port->uartclk);
+
+        /* Enable sport rx */
+        SPORT_PUT_RCR1(up, SPORT_GET_RCR1(up) | RSPEN);
+        SSYNC();
+
+        spin_unlock_irqrestore(&up->port.lock, flags);
+}
+
 struct uart_ops sport_uart_ops = {
         .tx_empty       = sport_tx_empty,
         .set_mctrl      = sport_set_mctrl,
@@ -480,138 +536,319 @@ struct uart_ops sport_uart_ops = {
         .verify_port    = sport_verify_port,
 };
 
-static struct sport_uart_port sport_uart_ports[] = {
-        { /* SPORT 0 */
-                .name   = "SPORT0",
-                .tx_irq = IRQ_SPORT0_TX,
-                .rx_irq = IRQ_SPORT0_RX,
-                .err_irq= IRQ_SPORT0_ERROR,
-                .port   = {
-                        .type           = PORT_BFIN_SPORT,
-                        .iotype         = UPIO_MEM,
-                        .membase        = (void __iomem *)SPORT0_TCR1,
-                        .mapbase        = SPORT0_TCR1,
-                        .irq            = IRQ_SPORT0_RX,
-                        .uartclk        = CONFIG_SPORT_BAUD_RATE,
-                        .fifosize       = 8,
-                        .ops            = &sport_uart_ops,
-                        .line           = 0,
-                },
-        }, { /* SPORT 1 */
-                .name   = "SPORT1",
-                .tx_irq = IRQ_SPORT1_TX,
-                .rx_irq = IRQ_SPORT1_RX,
-                .err_irq= IRQ_SPORT1_ERROR,
-                .port   = {
-                        .type           = PORT_BFIN_SPORT,
-                        .iotype         = UPIO_MEM,
-                        .membase        = (void __iomem *)SPORT1_TCR1,
-                        .mapbase        = SPORT1_TCR1,
-                        .irq            = IRQ_SPORT1_RX,
-                        .uartclk        = CONFIG_SPORT_BAUD_RATE,
-                        .fifosize       = 8,
-                        .ops            = &sport_uart_ops,
-                        .line           = 1,
-                },
+#define BFIN_SPORT_UART_MAX_PORTS 4
+
+static struct sport_uart_port *bfin_sport_uart_ports[BFIN_SPORT_UART_MAX_PORTS];
+
+#ifdef CONFIG_SERIAL_BFIN_SPORT_CONSOLE
+static int __init
+sport_uart_console_setup(struct console *co, char *options)
+{
+        struct sport_uart_port *up;
+        int baud = 57600;
+        int bits = 8;
+        int parity = 'n';
+        int flow = 'n';
+
+        /* Check whether an invalid uart number has been specified */
+        if (co->index < 0 || co->index >= BFIN_SPORT_UART_MAX_PORTS)
+                return -ENODEV;
+
+        up = bfin_sport_uart_ports[co->index];
+        if (!up)
+                return -ENODEV;
+
+        if (options)
+                uart_parse_options(options, &baud, &parity, &bits, &flow);
+
+        return uart_set_options(&up->port, co, baud, parity, bits, flow);
+}
+
+static void sport_uart_console_putchar(struct uart_port *port, int ch)
+{
+        struct sport_uart_port *up = (struct sport_uart_port *)port;
+
+        while (SPORT_GET_STAT(up) & TXF)
+                barrier();
+
+        tx_one_byte(up, ch);
+}
+
+/*
+ * Interrupts are disabled on entering
+ */
+static void
+sport_uart_console_write(struct console *co, const char *s, unsigned int count)
+{
+        struct sport_uart_port *up = bfin_sport_uart_ports[co->index];
+        unsigned long flags;
+
+        spin_lock_irqsave(&up->port.lock, flags);
+
+        if (SPORT_GET_TCR1(up) & TSPEN)
+                uart_console_write(&up->port, s, count, sport_uart_console_putchar);
+        else {
+                /* dummy data to start sport */
+                while (SPORT_GET_STAT(up) & TXF)
+                        barrier();
+                SPORT_PUT_TX(up, 0xffff);
+                /* Enable transmit, then an interrupt will generated */
+                SPORT_PUT_TCR1(up, (SPORT_GET_TCR1(up) | TSPEN));
+                SSYNC();
+
+                uart_console_write(&up->port, s, count, sport_uart_console_putchar);
+
+                /* Although the hold register is empty, last byte is still in shift
+                 * register and not sent out yet. So, put a dummy data into TX FIFO.
+                 * Then, sport tx stops when last byte is shift out and the dummy
+                 * data is moved into the shift register.
+                 */
+                while (SPORT_GET_STAT(up) & TXF)
+                        barrier();
+                SPORT_PUT_TX(up, 0xffff);
+                while (!(SPORT_GET_STAT(up) & TXHRE))
+                        barrier();
+
+                /* Stop sport tx transfer */
+                SPORT_PUT_TCR1(up, (SPORT_GET_TCR1(up) & ~TSPEN));
+                SSYNC();
         }
+
+        spin_unlock_irqrestore(&up->port.lock, flags);
+}
+
+static struct uart_driver sport_uart_reg;
+
+static struct console sport_uart_console = {
+        .name           = DEVICE_NAME,
+        .write          = sport_uart_console_write,
+        .device         = uart_console_device,
+        .setup          = sport_uart_console_setup,
+        .flags          = CON_PRINTBUFFER,
+        .index          = -1,
+        .data           = &sport_uart_reg,
 };
 
+#define SPORT_UART_CONSOLE      (&sport_uart_console)
+#else
+#define SPORT_UART_CONSOLE      NULL
+#endif /* CONFIG_SERIAL_BFIN_SPORT_CONSOLE */
+
+
 static struct uart_driver sport_uart_reg = {
         .owner          = THIS_MODULE,
-        .driver_name    = "SPORT-UART",
-        .dev_name       = "ttySS",
+        .driver_name    = DRV_NAME,
+        .dev_name       = DEVICE_NAME,
         .major          = 204,
         .minor          = 84,
-        .nr             = ARRAY_SIZE(sport_uart_ports),
-        .cons           = NULL,
+        .nr             = BFIN_SPORT_UART_MAX_PORTS,
+        .cons           = SPORT_UART_CONSOLE,
 };
 
-static int sport_uart_suspend(struct platform_device *dev, pm_message_t state)
+#ifdef CONFIG_PM
+static int sport_uart_suspend(struct device *dev)
 {
-        struct sport_uart_port *sport = platform_get_drvdata(dev);
+        struct sport_uart_port *sport = dev_get_drvdata(dev);
 
-        pr_debug("%s enter\n", __func__);
+        dev_dbg(dev, "%s enter\n", __func__);
         if (sport)
                 uart_suspend_port(&sport_uart_reg, &sport->port);
 
         return 0;
 }
 
-static int sport_uart_resume(struct platform_device *dev)
+static int sport_uart_resume(struct device *dev)
 {
-        struct sport_uart_port *sport = platform_get_drvdata(dev);
+        struct sport_uart_port *sport = dev_get_drvdata(dev);
 
-        pr_debug("%s enter\n", __func__);
+        dev_dbg(dev, "%s enter\n", __func__);
         if (sport)
                 uart_resume_port(&sport_uart_reg, &sport->port);
 
         return 0;
 }
 
-static int sport_uart_probe(struct platform_device *dev)
+static struct dev_pm_ops bfin_sport_uart_dev_pm_ops = {
+        .suspend        = sport_uart_suspend,
+        .resume         = sport_uart_resume,
+};
+#endif
+
+static int __devinit sport_uart_probe(struct platform_device *pdev)
 {
-        pr_debug("%s enter\n", __func__);
-        sport_uart_ports[dev->id].port.dev = &dev->dev;
-        uart_add_one_port(&sport_uart_reg, &sport_uart_ports[dev->id].port);
-        platform_set_drvdata(dev, &sport_uart_ports[dev->id]);
+        struct resource *res;
+        struct sport_uart_port *sport;
+        int ret = 0;
 
-        return 0;
+        dev_dbg(&pdev->dev, "%s enter\n", __func__);
+
+        if (pdev->id < 0 || pdev->id >= BFIN_SPORT_UART_MAX_PORTS) {
+                dev_err(&pdev->dev, "Wrong sport uart platform device id.\n");
+                return -ENOENT;
+        }
+
+        if (bfin_sport_uart_ports[pdev->id] == NULL) {
+                bfin_sport_uart_ports[pdev->id] =
+                        kmalloc(sizeof(struct sport_uart_port), GFP_KERNEL);
+                sport = bfin_sport_uart_ports[pdev->id];
+                if (!sport) {
+                        dev_err(&pdev->dev,
+                                "Fail to kmalloc sport_uart_port\n");
+                        return -ENOMEM;
+                }
+
+                ret = peripheral_request_list(
+                        (unsigned short *)pdev->dev.platform_data, DRV_NAME);
+                if (ret) {
+                        dev_err(&pdev->dev,
+                                "Fail to request SPORT peripherals\n");
+                        goto out_error_free_mem;
+                }
+
+                spin_lock_init(&sport->port.lock);
+                sport->port.fifosize  = SPORT_TX_FIFO_SIZE,
+                sport->port.ops       = &sport_uart_ops;
+                sport->port.line      = pdev->id;
+                sport->port.iotype    = UPIO_MEM;
+                sport->port.flags     = UPF_BOOT_AUTOCONF;
+
+                res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+                if (res == NULL) {
+                        dev_err(&pdev->dev, "Cannot get IORESOURCE_MEM\n");
+                        ret = -ENOENT;
+                        goto out_error_free_peripherals;
+                }
+
+                sport->port.membase = ioremap(res->start,
+                        res->end - res->start);
+                if (!sport->port.membase) {
+                        dev_err(&pdev->dev, "Cannot map sport IO\n");
+                        ret = -ENXIO;
+                        goto out_error_free_peripherals;
+                }
+
+                sport->port.irq = platform_get_irq(pdev, 0);
+                if (sport->port.irq < 0) {
+                        dev_err(&pdev->dev, "No sport RX/TX IRQ specified\n");
+                        ret = -ENOENT;
+                        goto out_error_unmap;
+                }
+
+                sport->err_irq = platform_get_irq(pdev, 1);
+                if (sport->err_irq < 0) {
+                        dev_err(&pdev->dev, "No sport status IRQ specified\n");
+                        ret = -ENOENT;
+                        goto out_error_unmap;
+                }
+        }
+
+#ifdef CONFIG_SERIAL_BFIN_SPORT_CONSOLE
+        if (!is_early_platform_device(pdev)) {
+#endif
+                sport = bfin_sport_uart_ports[pdev->id];
+                sport->port.dev = &pdev->dev;
+                dev_set_drvdata(&pdev->dev, sport);
+                ret = uart_add_one_port(&sport_uart_reg, &sport->port);
+#ifdef CONFIG_SERIAL_BFIN_SPORT_CONSOLE
+        }
+#endif
+        if (!ret)
+                return 0;
+
+        if (sport) {
+out_error_unmap:
+                iounmap(sport->port.membase);
+out_error_free_peripherals:
+                peripheral_free_list(
+                        (unsigned short *)pdev->dev.platform_data);
+out_error_free_mem:
+                kfree(sport);
+                bfin_sport_uart_ports[pdev->id] = NULL;
+        }
+
+        return ret;
 }
 
-static int sport_uart_remove(struct platform_device *dev)
+static int __devexit sport_uart_remove(struct platform_device *pdev)
 {
-        struct sport_uart_port *sport = platform_get_drvdata(dev);
+        struct sport_uart_port *sport = platform_get_drvdata(pdev);
 
-        pr_debug("%s enter\n", __func__);
-        platform_set_drvdata(dev, NULL);
+        dev_dbg(&pdev->dev, "%s enter\n", __func__);
+        dev_set_drvdata(&pdev->dev, NULL);
 
-        if (sport)
+        if (sport) {
                 uart_remove_one_port(&sport_uart_reg, &sport->port);
+                iounmap(sport->port.membase);
+                peripheral_free_list(
+                        (unsigned short *)pdev->dev.platform_data);
+                kfree(sport);
+                bfin_sport_uart_ports[pdev->id] = NULL;
+        }
 
         return 0;
 }
 
 static struct platform_driver sport_uart_driver = {
         .probe          = sport_uart_probe,
-        .remove         = sport_uart_remove,
-        .suspend        = sport_uart_suspend,
-        .resume         = sport_uart_resume,
+        .remove         = __devexit_p(sport_uart_remove),
         .driver         = {
                 .name   = DRV_NAME,
+#ifdef CONFIG_PM
+                .pm     = &bfin_sport_uart_dev_pm_ops,
+#endif
         },
 };
 
+#ifdef CONFIG_SERIAL_BFIN_SPORT_CONSOLE
+static __initdata struct early_platform_driver early_sport_uart_driver = {
+        .class_str = DRV_NAME,
+        .pdrv = &sport_uart_driver,
+        .requested_id = EARLY_PLATFORM_ID_UNSET,
+};
+
+static int __init sport_uart_rs_console_init(void)
+{
+        early_platform_driver_register(&early_sport_uart_driver, DRV_NAME);
+
+        early_platform_driver_probe(DRV_NAME, BFIN_SPORT_UART_MAX_PORTS, 0);
+
+        register_console(&sport_uart_console);
+
+        return 0;
+}
+console_initcall(sport_uart_rs_console_init);
+#endif
+
 static int __init sport_uart_init(void)
 {
         int ret;
 
-        pr_debug("%s enter\n", __func__);
+        pr_info("Serial: Blackfin uart over sport driver\n");
+
         ret = uart_register_driver(&sport_uart_reg);
-        if (ret != 0) {
-                printk(KERN_ERR "Failed to register %s:%d\n",
+        if (ret) {
+                pr_err("failed to register %s:%d\n",
                                 sport_uart_reg.driver_name, ret);
                 return ret;
         }
 
         ret = platform_driver_register(&sport_uart_driver);
-        if (ret != 0) {
-                printk(KERN_ERR "Failed to register sport uart driver:%d\n", ret);
+        if (ret) {
+                pr_err("failed to register sport uart driver:%d\n", ret);
                 uart_unregister_driver(&sport_uart_reg);
         }
 
-
-        pr_debug("%s exit\n", __func__);
         return ret;
 }
+module_init(sport_uart_init);
 
 static void __exit sport_uart_exit(void)
 {
-        pr_debug("%s enter\n", __func__);
         platform_driver_unregister(&sport_uart_driver);
         uart_unregister_driver(&sport_uart_reg);
 }
-
-module_init(sport_uart_init);
 module_exit(sport_uart_exit);
 
+MODULE_AUTHOR("Sonic Zhang, Roy Huang");
+MODULE_DESCRIPTION("Blackfin serial over SPORT driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/serial/bfin_sport_uart.h b/drivers/serial/bfin_sport_uart.h
index 671d41cc1a3f..abe03614e4df 100644
--- a/drivers/serial/bfin_sport_uart.h
+++ b/drivers/serial/bfin_sport_uart.h
@@ -1,29 +1,23 @@
 /*
- * File:        linux/drivers/serial/bfin_sport_uart.h
+ * Blackfin On-Chip Sport Emulated UART Driver
  *
- * Based on:    include/asm-blackfin/mach-533/bfin_serial_5xx.h
- * Author:      Roy Huang <roy.huang>analog.com>
+ * Copyright 2006-2008 Analog Devices Inc.
  *
- * Created:     Nov 22, 2006
- * Copyright:   (C) Analog Device Inc.
- * Description: this driver enable SPORTs on Blackfin emulate UART.
+ * Enter bugs at http://blackfin.uclinux.org/
  *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see the file COPYING, or write
- * to the Free Software Foundation, Inc.,
- * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ * Licensed under the GPL-2 or later.
  */
 
+/*
+ * This driver and the hardware supported are in term of EE-191 of ADI.
+ * http://www.analog.com/UploadedFiles/Application_Notes/399447663EE191.pdf
+ * This application note describe how to implement a UART on a Sharc DSP,
+ * but this driver is implemented on Blackfin Processor.
+ * Transmit Frame Sync is not used by this driver to transfer data out.
+ */
+
+#ifndef _BFIN_SPORT_UART_H
+#define _BFIN_SPORT_UART_H
 
 #define OFFSET_TCR1             0x00    /* Transmit Configuration 1 Register */
 #define OFFSET_TCR2             0x04    /* Transmit Configuration 2 Register */
@@ -61,3 +55,7 @@
 #define SPORT_PUT_RCLKDIV(sport, v)     bfin_write16(((sport)->port.membase + OFFSET_RCLKDIV), v)
 #define SPORT_PUT_RFSDIV(sport, v)      bfin_write16(((sport)->port.membase + OFFSET_RFSDIV), v)
 #define SPORT_PUT_STAT(sport, v)        bfin_write16(((sport)->port.membase + OFFSET_STAT), v)
+
+#define SPORT_TX_FIFO_SIZE      8
+
+#endif /* _BFIN_SPORT_UART_H */
diff --git a/drivers/serial/icom.c b/drivers/serial/icom.c
index 0028b6f89ce6..53a468227056 100644
--- a/drivers/serial/icom.c
+++ b/drivers/serial/icom.c
@@ -751,7 +751,6 @@ static void recv_interrupt(u16 port_int_reg, struct icom_port *icom_port)
                 trace(icom_port, "FID_STATUS", status);
                 count = cpu_to_le16(icom_port->statStg->rcv[rcv_buff].leLength);
 
-                count = tty_buffer_request_room(tty, count);
                 trace(icom_port, "RCV_COUNT", count);
 
                 trace(icom_port, "REAL_COUNT", count);
@@ -1654,4 +1653,6 @@ MODULE_DESCRIPTION("IBM iSeries Serial IOA driver");
 MODULE_SUPPORTED_DEVICE
     ("IBM iSeries 2745, 2771, 2772, 2742, 2793 and 2805 Communications adapters");
 MODULE_LICENSE("GPL");
-
+MODULE_FIRMWARE("icom_call_setup.bin");
+MODULE_FIRMWARE("icom_res_dce.bin");
+MODULE_FIRMWARE("icom_asc.bin");
diff --git a/drivers/serial/imx.c b/drivers/serial/imx.c
index 60d665a17a88..d00fcf8e6c70 100644
--- a/drivers/serial/imx.c
+++ b/drivers/serial/imx.c
@@ -1279,7 +1279,7 @@ static int serial_imx_probe(struct platform_device *pdev)
                 sport->use_irda = 1;
 #endif
 
-        if (pdata->init) {
+        if (pdata && pdata->init) {
                 ret = pdata->init(pdev);
                 if (ret)
                         goto clkput;
@@ -1292,7 +1292,7 @@ static int serial_imx_probe(struct platform_device *pdev)
 
         return 0;
 deinit:
-        if (pdata->exit)
+        if (pdata && pdata->exit)
                 pdata->exit(pdev);
 clkput:
         clk_put(sport->clk);
@@ -1321,7 +1321,7 @@ static int serial_imx_remove(struct platform_device *pdev)
 
         clk_disable(sport->clk);
 
-        if (pdata->exit)
+        if (pdata && pdata->exit)
                 pdata->exit(pdev);
 
         iounmap(sport->port.membase);
diff --git a/drivers/serial/ioc3_serial.c b/drivers/serial/ioc3_serial.c
index 85dc0410ac1a..23ba6b40b3ac 100644
--- a/drivers/serial/ioc3_serial.c
+++ b/drivers/serial/ioc3_serial.c
@@ -1411,8 +1411,7 @@ static int receive_chars(struct uart_port *the_port)
         read_count = do_read(the_port, ch, MAX_CHARS);
         if (read_count > 0) {
                 flip = 1;
-                read_room = tty_buffer_request_room(tty, read_count);
-                tty_insert_flip_string(tty, ch, read_room);
+                read_room = tty_insert_flip_string(tty, ch, read_count);
                 the_port->icount.rx += read_count;
         }
         spin_unlock_irqrestore(&the_port->lock, pflags);
diff --git a/drivers/serial/jsm/jsm_driver.c b/drivers/serial/jsm/jsm_driver.c
index 108c3e0471fd..12cb5e446a4f 100644
--- a/drivers/serial/jsm/jsm_driver.c
+++ b/drivers/serial/jsm/jsm_driver.c
@@ -179,6 +179,7 @@ static int __devinit jsm_probe_one(struct pci_dev *pdev, const struct pci_device
 
         return 0;
  out_free_irq:
+        jsm_remove_uart_port(brd);
         free_irq(brd->irq, brd);
  out_iounmap:
         iounmap(brd->re_map_membase);
diff --git a/drivers/serial/jsm/jsm_tty.c b/drivers/serial/jsm/jsm_tty.c
index cd95e215550d..5673ca9dfdc8 100644
--- a/drivers/serial/jsm/jsm_tty.c
+++ b/drivers/serial/jsm/jsm_tty.c
@@ -432,7 +432,7 @@ int __devinit jsm_tty_init(struct jsm_board *brd)
 
 int jsm_uart_port_init(struct jsm_board *brd)
 {
-        int i;
+        int i, rc;
         unsigned int line;
         struct jsm_channel *ch;
 
@@ -467,8 +467,11 @@ int jsm_uart_port_init(struct jsm_board *brd)
                 } else
                         set_bit(line, linemap);
                 brd->channels[i]->uart_port.line = line;
-                if (uart_add_one_port (&jsm_uart_driver, &brd->channels[i]->uart_port))
-                        printk(KERN_INFO "jsm: add device failed\n");
+                rc = uart_add_one_port (&jsm_uart_driver, &brd->channels[i]->uart_port);
+                if (rc){
+                        printk(KERN_INFO "jsm: Port %d failed. Aborting...\n", i);
+                        return rc;
+                }
                 else
                         printk(KERN_INFO "jsm: Port %d added\n", i);
         }
diff --git a/drivers/serial/msm_serial.c b/drivers/serial/msm_serial.c
index b05c5aa02cb4..ecdc0facf7ee 100644
--- a/drivers/serial/msm_serial.c
+++ b/drivers/serial/msm_serial.c
@@ -691,6 +691,7 @@ static int __init msm_serial_probe(struct platform_device *pdev)
         struct msm_port *msm_port;
         struct resource *resource;
         struct uart_port *port;
+        int irq;
 
         if (unlikely(pdev->id < 0 || pdev->id >= UART_NR))
                 return -ENXIO;
@@ -711,9 +712,10 @@ static int __init msm_serial_probe(struct platform_device *pdev)
                 return -ENXIO;
         port->mapbase = resource->start;
 
-        port->irq = platform_get_irq(pdev, 0);
-        if (unlikely(port->irq < 0))
+        irq = platform_get_irq(pdev, 0);
+        if (unlikely(irq < 0))
                 return -ENXIO;
+        port->irq = irq;
 
         platform_set_drvdata(pdev, port);
 
diff --git a/drivers/serial/timbuart.c b/drivers/serial/timbuart.c
index 34b31da01d09..7bf10264a6ac 100644
--- a/drivers/serial/timbuart.c
+++ b/drivers/serial/timbuart.c
@@ -421,7 +421,7 @@ static struct uart_driver timbuart_driver = {
 
 static int timbuart_probe(struct platform_device *dev)
 {
-        int err;
+        int err, irq;
         struct timbuart_port *uart;
         struct resource *iomem;
 
@@ -453,11 +453,12 @@ static int timbuart_probe(struct platform_device *dev)
         uart->port.mapbase = iomem->start;
         uart->port.membase = NULL;
 
-        uart->port.irq = platform_get_irq(dev, 0);
-        if (uart->port.irq < 0) {
+        irq = platform_get_irq(dev, 0);
+        if (irq < 0) {
                 err = -EINVAL;
                 goto err_register;
         }
+        uart->port.irq = irq;
 
         tasklet_init(&uart->tasklet, timbuart_tasklet, (unsigned long)uart);
 
diff --git a/drivers/usb/serial/keyspan_pda.c b/drivers/usb/serial/keyspan_pda.c
index 1296a097f5c3..84f08e968e0b 100644
--- a/drivers/usb/serial/keyspan_pda.c
+++ b/drivers/usb/serial/keyspan_pda.c
@@ -789,6 +789,13 @@ static int keyspan_pda_fake_startup(struct usb_serial *serial)
         return 1;
 }
 
+#ifdef KEYSPAN
+MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw");
+#endif
+#ifdef XIRCOM
+MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw");
+#endif
+
 static int keyspan_pda_startup(struct usb_serial *serial)
 {
 
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index c0e207c0c45a..9f688d243b86 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -2332,6 +2332,8 @@
 #define PCI_VENDOR_ID_KORENIX           0x1982
 #define PCI_DEVICE_ID_KORENIX_JETCARDF0 0x1600
 #define PCI_DEVICE_ID_KORENIX_JETCARDF1 0x16ff
+#define PCI_DEVICE_ID_KORENIX_JETCARDF2 0x1700
+#define PCI_DEVICE_ID_KORENIX_JETCARDF3 0x17ff
 
 #define PCI_VENDOR_ID_QMI               0x1a32
 
@@ -2696,6 +2698,7 @@
 #define PCI_DEVICE_ID_NETMOS_9835       0x9835
 #define PCI_DEVICE_ID_NETMOS_9845       0x9845
 #define PCI_DEVICE_ID_NETMOS_9855       0x9855
+#define PCI_DEVICE_ID_NETMOS_9865       0x9865
 #define PCI_DEVICE_ID_NETMOS_9901       0x9901
 
 #define PCI_VENDOR_ID_3COM_2            0xa727
diff --git a/include/linux/tty.h b/include/linux/tty.h
index 6abfcf5b5887..d96e5882f129 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -68,6 +68,16 @@ struct tty_buffer {
         unsigned long data[0];
 };
 
+/*
+ * We default to dicing tty buffer allocations to this many characters
+ * in order to avoid multiple page allocations. We assume tty_buffer itself
+ * is under 256 bytes. See tty_buffer_find for the allocation logic this
+ * must match
+ */
+
+#define TTY_BUFFER_PAGE         ((PAGE_SIZE  - 256) / 2)
+
+
 struct tty_bufhead {
         struct delayed_work work;
         spinlock_t lock;
diff --git a/include/linux/vt.h b/include/linux/vt.h
index d5dd0bc408fd..778b7b2a47d4 100644
--- a/include/linux/vt.h
+++ b/include/linux/vt.h
@@ -27,7 +27,7 @@ struct vt_mode {
 #define VT_SETMODE      0x5602  /* set mode of active vt */
 #define         VT_AUTO         0x00    /* auto vt switching */
 #define         VT_PROCESS      0x01    /* process controls switching */
-#define         VT_ACKACQ       0x02    /* acknowledge switch */
+#define         VT_PROCESS_AUTO 0x02    /* process is notified of switching */
 
 struct vt_stat {
         unsigned short v_active;        /* active vt */
@@ -38,6 +38,7 @@ struct vt_stat {
 #define VT_SENDSIG      0x5604  /* signal to send to bitmask of vts */
 
 #define VT_RELDISP      0x5605  /* release display */
+#define         VT_ACKACQ       0x02    /* acknowledge switch */
 
 #define VT_ACTIVATE     0x5606  /* make vt active */
 #define VT_WAITACTIVE   0x5607  /* wait for vt active */