Merge branch 'master' into for-next

Pull linus#master to merge PER_CPU_DEF_ATTRIBUTES and alpha build fix
changes.  As alpha in percpu tree uses 'weak' attribute instead of
inline assembly, there's no need for __used attribute.

Conflicts:
	arch/alpha/include/asm/percpu.h
	arch/mn10300/kernel/vmlinux.lds.S
	include/linux/percpu-defs.h

12 files changed, 142 insertions, 108 deletions

diff --git a/drivers/char/bfin_jtag_comm.c b/drivers/char/bfin_jtag_comm.c
index 44c113d56045..1d7c34c73b20 100644
--- a/drivers/char/bfin_jtag_comm.c
+++ b/drivers/char/bfin_jtag_comm.c
@@ -8,6 +8,10 @@
  * Licensed under the GPL-2 or later.
  */
 
+#define DRV_NAME "bfin-jtag-comm"
+#define DEV_NAME "ttyBFJC"
+#define pr_fmt(fmt) DRV_NAME ": " fmt
+
 #include <linux/circ_buf.h>
 #include <linux/console.h>
 #include <linux/delay.h>
@@ -22,18 +26,14 @@
 #include <linux/tty_flip.h>
 #include <asm/atomic.h>
 
+#define pr_init(fmt, args...) ({ static const __initconst char __fmt[] = fmt; printk(__fmt, ## args); })
+
 /* See the Debug/Emulation chapter in the HRM */
 #define EMUDOF   0x00000001     /* EMUDAT_OUT full & valid */
 #define EMUDIF   0x00000002     /* EMUDAT_IN full & valid */
 #define EMUDOOVF 0x00000004     /* EMUDAT_OUT overflow */
 #define EMUDIOVF 0x00000008     /* EMUDAT_IN overflow */
 
-#define DRV_NAME "bfin-jtag-comm"
-#define DEV_NAME "ttyBFJC"
-
-#define pr_init(fmt, args...) ({ static const __initdata char __fmt[] = fmt; printk(__fmt, ## args); })
-#define debug(fmt, args...) pr_debug(DRV_NAME ": " fmt, ## args)
-
 static inline uint32_t bfin_write_emudat(uint32_t emudat)
 {
         __asm__ __volatile__("emudat = %0;" : : "d"(emudat));
@@ -74,7 +74,7 @@ bfin_jc_emudat_manager(void *arg)
         while (!kthread_should_stop()) {
                 /* no one left to give data to, so sleep */
                 if (bfin_jc_tty == NULL && circ_empty(&bfin_jc_write_buf)) {
-                        debug("waiting for readers\n");
+                        pr_debug("waiting for readers\n");
                         __set_current_state(TASK_UNINTERRUPTIBLE);
                         schedule();
                         __set_current_state(TASK_RUNNING);
@@ -82,7 +82,7 @@ bfin_jc_emudat_manager(void *arg)
 
                 /* no data available, so just chill */
                 if (!(bfin_read_DBGSTAT() & EMUDIF) && circ_empty(&bfin_jc_write_buf)) {
-                        debug("waiting for data (in_len = %i) (circ: %i %i)\n",
+                        pr_debug("waiting for data (in_len = %i) (circ: %i %i)\n",
                                 inbound_len, bfin_jc_write_buf.tail, bfin_jc_write_buf.head);
                         if (inbound_len)
                                 schedule();
@@ -99,11 +99,11 @@ bfin_jc_emudat_manager(void *arg)
                         if (tty != NULL) {
                                 uint32_t emudat = bfin_read_emudat();
                                 if (inbound_len == 0) {
-                                        debug("incoming length: 0x%08x\n", emudat);
+                                        pr_debug("incoming length: 0x%08x\n", emudat);
                                         inbound_len = emudat;
                                 } else {
                                         size_t num_chars = (4 <= inbound_len ? 4 : inbound_len);
-                                        debug("  incoming data: 0x%08x (pushing %zu)\n", emudat, num_chars);
+                                        pr_debug("  incoming data: 0x%08x (pushing %zu)\n", emudat, num_chars);
                                         inbound_len -= num_chars;
                                         tty_insert_flip_string(tty, (unsigned char *)&emudat, num_chars);
                                         tty_flip_buffer_push(tty);
@@ -117,7 +117,7 @@ bfin_jc_emudat_manager(void *arg)
                         if (outbound_len == 0) {
                                 outbound_len = circ_cnt(&bfin_jc_write_buf);
                                 bfin_write_emudat(outbound_len);
-                                debug("outgoing length: 0x%08x\n", outbound_len);
+                                pr_debug("outgoing length: 0x%08x\n", outbound_len);
                         } else {
                                 struct tty_struct *tty;
                                 int tail = bfin_jc_write_buf.tail;
@@ -136,7 +136,7 @@ bfin_jc_emudat_manager(void *arg)
                                 if (tty)
                                         tty_wakeup(tty);
                                 mutex_unlock(&bfin_jc_tty_mutex);
-                                debug("  outgoing data: 0x%08x (pushing %zu)\n", emudat, ate);
+                                pr_debug("  outgoing data: 0x%08x (pushing %zu)\n", emudat, ate);
                         }
                 }
         }
@@ -149,7 +149,7 @@ static int
 bfin_jc_open(struct tty_struct *tty, struct file *filp)
 {
         mutex_lock(&bfin_jc_tty_mutex);
-        debug("open %lu\n", bfin_jc_count);
+        pr_debug("open %lu\n", bfin_jc_count);
         ++bfin_jc_count;
         bfin_jc_tty = tty;
         wake_up_process(bfin_jc_kthread);
@@ -161,7 +161,7 @@ static void
 bfin_jc_close(struct tty_struct *tty, struct file *filp)
 {
         mutex_lock(&bfin_jc_tty_mutex);
-        debug("close %lu\n", bfin_jc_count);
+        pr_debug("close %lu\n", bfin_jc_count);
         if (--bfin_jc_count == 0)
                 bfin_jc_tty = NULL;
         wake_up_process(bfin_jc_kthread);
@@ -174,7 +174,7 @@ bfin_jc_circ_write(const unsigned char *buf, int count)
 {
         int i;
         count = min(count, circ_free(&bfin_jc_write_buf));
-        debug("going to write chunk of %i bytes\n", count);
+        pr_debug("going to write chunk of %i bytes\n", count);
         for (i = 0; i < count; ++i)
                 circ_byte(&bfin_jc_write_buf, bfin_jc_write_buf.head + i) = buf[i];
         bfin_jc_write_buf.head += i;
diff --git a/drivers/char/bsr.c b/drivers/char/bsr.c
index 140ea10ecb88..c02db01f736e 100644
--- a/drivers/char/bsr.c
+++ b/drivers/char/bsr.c
@@ -27,6 +27,7 @@
 #include <linux/cdev.h>
 #include <linux/list.h>
 #include <linux/mm.h>
+#include <asm/pgtable.h>
 #include <asm/io.h>
 
 /*
@@ -75,12 +76,13 @@ static struct class *bsr_class;
 static int bsr_major;
 
 enum {
-        BSR_8   = 0,
-        BSR_16  = 1,
-        BSR_64  = 2,
-        BSR_128 = 3,
-        BSR_UNKNOWN = 4,
-        BSR_MAX = 5,
+        BSR_8    = 0,
+        BSR_16   = 1,
+        BSR_64   = 2,
+        BSR_128  = 3,
+        BSR_4096 = 4,
+        BSR_UNKNOWN = 5,
+        BSR_MAX  = 6,
 };
 
 static unsigned bsr_types[BSR_MAX];
@@ -117,15 +119,22 @@ static int bsr_mmap(struct file *filp, struct vm_area_struct *vma)
 {
         unsigned long size   = vma->vm_end - vma->vm_start;
         struct bsr_dev *dev = filp->private_data;
+        int ret;
 
-        if (size > dev->bsr_len || (size & (PAGE_SIZE-1)))
-                return -EINVAL;
-
-        vma->vm_flags |= (VM_IO | VM_DONTEXPAND);
         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 
-        if (io_remap_pfn_range(vma, vma->vm_start, dev->bsr_addr >> PAGE_SHIFT,
-                               size, vma->vm_page_prot))
+        /* check for the case of a small BSR device and map one 4k page for it*/
+        if (dev->bsr_len < PAGE_SIZE && size == PAGE_SIZE)
+                ret = remap_4k_pfn(vma, vma->vm_start, dev->bsr_addr >> 12,
+                                   vma->vm_page_prot);
+        else if (size <= dev->bsr_len)
+                ret = io_remap_pfn_range(vma, vma->vm_start,
+                                         dev->bsr_addr >> PAGE_SHIFT,
+                                         size, vma->vm_page_prot);
+        else
+                return -EINVAL;
+
+        if (ret)
                 return -EAGAIN;
 
         return 0;
@@ -205,6 +214,11 @@ static int bsr_add_node(struct device_node *bn)
                 cur->bsr_stride = bsr_stride[i];
                 cur->bsr_dev    = MKDEV(bsr_major, i + total_bsr_devs);
 
+                /* if we have a bsr_len of > 4k and less then PAGE_SIZE (64k pages) */
+                /* we can only map 4k of it, so only advertise the 4k in sysfs */
+                if (cur->bsr_len > 4096 && cur->bsr_len < PAGE_SIZE)
+                        cur->bsr_len = 4096;
+
                 switch(cur->bsr_bytes) {
                 case 8:
                         cur->bsr_type = BSR_8;
@@ -218,9 +232,11 @@ static int bsr_add_node(struct device_node *bn)
                 case 128:
                         cur->bsr_type = BSR_128;
                         break;
+                case 4096:
+                        cur->bsr_type = BSR_4096;
+                        break;
                 default:
                         cur->bsr_type = BSR_UNKNOWN;
-                        printk(KERN_INFO "unknown BSR size %d\n",cur->bsr_bytes);
                 }
 
                 cur->bsr_num = bsr_types[cur->bsr_type];
diff --git a/drivers/char/moxa.c b/drivers/char/moxa.c
index 6799588b0099..65b6ff2442c6 100644
--- a/drivers/char/moxa.c
+++ b/drivers/char/moxa.c
@@ -1189,11 +1189,6 @@ static int moxa_open(struct tty_struct *tty, struct file *filp)
                 return -ENODEV;
         }
 
-        if (port % MAX_PORTS_PER_BOARD >= brd->numPorts) {
-                retval = -ENODEV;
-                goto out_unlock;
-        }
-
         ch = &brd->ports[port % MAX_PORTS_PER_BOARD];
         ch->port.count++;
         tty->driver_data = ch;
@@ -1218,8 +1213,8 @@ static int moxa_open(struct tty_struct *tty, struct file *filp)
                                 moxa_close_port(tty);
         } else
                 ch->port.flags |= ASYNC_NORMAL_ACTIVE;
-out_unlock:
         mutex_unlock(&moxa_openlock);
+
         return retval;
 }
 
diff --git a/drivers/char/mxser.c b/drivers/char/mxser.c
index 9533f43a30bb..52d953eb30c3 100644
--- a/drivers/char/mxser.c
+++ b/drivers/char/mxser.c
@@ -1048,8 +1048,6 @@ static int mxser_open(struct tty_struct *tty, struct file *filp)
         if (retval)
                 return retval;
 
-        /* unmark here for very high baud rate (ex. 921600 bps) used */
-        tty->low_latency = 1;
         return 0;
 }
 
diff --git a/drivers/char/n_hdlc.c b/drivers/char/n_hdlc.c
index 461ece591a5b..1c43c8cdee25 100644
--- a/drivers/char/n_hdlc.c
+++ b/drivers/char/n_hdlc.c
@@ -10,7 +10,6 @@
  *      Paul Mackerras <Paul.Mackerras@cs.anu.edu.au>
  *
  * Original release 01/11/99
- * $Id: n_hdlc.c,v 4.8 2003/05/06 21:18:51 paulkf Exp $
  *
  * This code is released under the GNU General Public License (GPL)
  *
@@ -79,7 +78,6 @@
  */
 
 #define HDLC_MAGIC 0x239e
-#define HDLC_VERSION "$Revision: 4.8 $"
 
 #include <linux/module.h>
 #include <linux/init.h>
@@ -114,7 +112,7 @@
 #define MAX_HDLC_FRAME_SIZE 65535 
 #define DEFAULT_RX_BUF_COUNT 10
 #define MAX_RX_BUF_COUNT 60
-#define DEFAULT_TX_BUF_COUNT 1
+#define DEFAULT_TX_BUF_COUNT 3
 
 struct n_hdlc_buf {
         struct n_hdlc_buf *link;
@@ -199,6 +197,31 @@ static void n_hdlc_tty_wakeup(struct tty_struct *tty);
 #define tty2n_hdlc(tty) ((struct n_hdlc *) ((tty)->disc_data))
 #define n_hdlc2tty(n_hdlc)      ((n_hdlc)->tty)
 
+static void flush_rx_queue(struct tty_struct *tty)
+{
+        struct n_hdlc *n_hdlc = tty2n_hdlc(tty);
+        struct n_hdlc_buf *buf;
+
+        while ((buf = n_hdlc_buf_get(&n_hdlc->rx_buf_list)))
+                n_hdlc_buf_put(&n_hdlc->rx_free_buf_list, buf);
+}
+
+static void flush_tx_queue(struct tty_struct *tty)
+{
+        struct n_hdlc *n_hdlc = tty2n_hdlc(tty);
+        struct n_hdlc_buf *buf;
+        unsigned long flags;
+
+        while ((buf = n_hdlc_buf_get(&n_hdlc->tx_buf_list)))
+                n_hdlc_buf_put(&n_hdlc->tx_free_buf_list, buf);
+        spin_lock_irqsave(&n_hdlc->tx_buf_list.spinlock, flags);
+        if (n_hdlc->tbuf) {
+                n_hdlc_buf_put(&n_hdlc->tx_free_buf_list, n_hdlc->tbuf);
+                n_hdlc->tbuf = NULL;
+        }
+        spin_unlock_irqrestore(&n_hdlc->tx_buf_list.spinlock, flags);
+}
+
 static struct tty_ldisc_ops n_hdlc_ldisc = {
         .owner          = THIS_MODULE,
         .magic          = TTY_LDISC_MAGIC,
@@ -211,6 +234,7 @@ static struct tty_ldisc_ops n_hdlc_ldisc = {
         .poll           = n_hdlc_tty_poll,
         .receive_buf    = n_hdlc_tty_receive,
         .write_wakeup   = n_hdlc_tty_wakeup,
+        .flush_buffer   = flush_rx_queue,
 };
 
 /**
@@ -341,10 +365,7 @@ static int n_hdlc_tty_open (struct tty_struct *tty)
         set_bit(TTY_NO_WRITE_SPLIT,&tty->flags);
 #endif
         
-        /* Flush any pending characters in the driver and discipline. */
-        if (tty->ldisc->ops->flush_buffer)
-                tty->ldisc->ops->flush_buffer(tty);
-
+        /* flush receive data from driver */
         tty_driver_flush_buffer(tty);
                 
         if (debuglevel >= DEBUG_LEVEL_INFO)     
@@ -763,6 +784,14 @@ static int n_hdlc_tty_ioctl(struct tty_struct *tty, struct file *file,
                 error = put_user(count, (int __user *)arg);
                 break;
 
+        case TCFLSH:
+                switch (arg) {
+                case TCIOFLUSH:
+                case TCOFLUSH:
+                        flush_tx_queue(tty);
+                }
+                /* fall through to default */
+
         default:
                 error = n_tty_ioctl_helper(tty, file, cmd, arg);
                 break;
@@ -919,8 +948,7 @@ static struct n_hdlc_buf* n_hdlc_buf_get(struct n_hdlc_buf_list *list)
 }       /* end of n_hdlc_buf_get() */
 
 static char hdlc_banner[] __initdata =
-        KERN_INFO "HDLC line discipline: version " HDLC_VERSION
-        ", maxframe=%u\n";
+        KERN_INFO "HDLC line discipline maxframe=%u\n";
 static char hdlc_register_ok[] __initdata =
         KERN_INFO "N_HDLC line discipline registered.\n";
 static char hdlc_register_fail[] __initdata =
diff --git a/drivers/char/n_r3964.c b/drivers/char/n_r3964.c
index d2e93e343226..2e99158ebb8a 100644
--- a/drivers/char/n_r3964.c
+++ b/drivers/char/n_r3964.c
@@ -1062,7 +1062,7 @@ static ssize_t r3964_read(struct tty_struct *tty, struct file *file,
         struct r3964_client_info *pClient;
         struct r3964_message *pMsg;
         struct r3964_client_message theMsg;
-        int count;
+        int ret;
 
         TRACE_L("read()");
 
@@ -1074,8 +1074,8 @@ static ssize_t r3964_read(struct tty_struct *tty, struct file *file,
                 if (pMsg == NULL) {
                         /* no messages available. */
                         if (file->f_flags & O_NONBLOCK) {
-                                unlock_kernel();
-                                return -EAGAIN;
+                                ret = -EAGAIN;
+                                goto unlock;
                         }
                         /* block until there is a message: */
                         wait_event_interruptible(pInfo->read_wait,
@@ -1085,29 +1085,31 @@ static ssize_t r3964_read(struct tty_struct *tty, struct file *file,
                 /* If we still haven't got a message, we must have been signalled */
 
                 if (!pMsg) {
-                        unlock_kernel();
-                        return -EINTR;
+                        ret = -EINTR;
+                        goto unlock;
                 }
 
                 /* deliver msg to client process: */
                 theMsg.msg_id = pMsg->msg_id;
                 theMsg.arg = pMsg->arg;
                 theMsg.error_code = pMsg->error_code;
-                count = sizeof(struct r3964_client_message);
+                ret = sizeof(struct r3964_client_message);
 
                 kfree(pMsg);
                 TRACE_M("r3964_read - msg kfree %p", pMsg);
 
-                if (copy_to_user(buf, &theMsg, count)) {
-                        unlock_kernel();
-                        return -EFAULT;
+                if (copy_to_user(buf, &theMsg, ret)) {
+                        ret = -EFAULT;
+                        goto unlock;
                 }
 
-                TRACE_PS("read - return %d", count);
-                return count;
+                TRACE_PS("read - return %d", ret);
+                goto unlock;
         }
+        ret = -EPERM;
+unlock:
         unlock_kernel();
-        return -EPERM;
+        return ret;
 }
 
 static ssize_t r3964_write(struct tty_struct *tty, struct file *file,
diff --git a/drivers/char/nozomi.c b/drivers/char/nozomi.c
index d6102b644b55..574f1c79b6e6 100644
--- a/drivers/char/nozomi.c
+++ b/drivers/char/nozomi.c
@@ -1591,8 +1591,6 @@ static int ntty_open(struct tty_struct *tty, struct file *file)
 
         /* Enable interrupt downlink for channel */
         if (port->port.count == 1) {
-                /* FIXME: is this needed now ? */
-                tty->low_latency = 1;
                 tty->driver_data = port;
                 tty_port_tty_set(&port->port, tty);
                 DBG1("open: %d", port->token_dl);
diff --git a/drivers/char/pcmcia/cm4000_cs.c b/drivers/char/pcmcia/cm4000_cs.c
index dbb912574569..881934c068c8 100644
--- a/drivers/char/pcmcia/cm4000_cs.c
+++ b/drivers/char/pcmcia/cm4000_cs.c
@@ -1575,7 +1575,8 @@ static long cmm_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                 clear_bit(LOCK_IO, &dev->flags);
                 wake_up_interruptible(&dev->ioq);
 
-                return 0;
+                rc = 0;
+                break;
         case CM_IOCSPTS:
                 {
                         struct ptsreq krnptsreq;
diff --git a/drivers/char/synclink_gt.c b/drivers/char/synclink_gt.c
index 1386625fc4ca..a2e67e6df3a1 100644
--- a/drivers/char/synclink_gt.c
+++ b/drivers/char/synclink_gt.c
@@ -467,7 +467,6 @@ 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 tdma_start(struct slgt_info *info);
 static void tx_load(struct slgt_info *info, const char *buf, unsigned int count);
 
 static void get_signals(struct slgt_info *info);
@@ -795,6 +794,18 @@ static void set_termios(struct tty_struct *tty, struct ktermios *old_termios)
         }
 }
 
+static void update_tx_timer(struct slgt_info *info)
+{
+        /*
+         * use worst case speed of 1200bps to calculate transmit timeout
+         * based on data in buffers (tbuf_bytes) and FIFO (128 bytes)
+         */
+        if (info->params.mode == MGSL_MODE_HDLC) {
+                int timeout  = (tbuf_bytes(info) * 7) + 1000;
+                mod_timer(&info->tx_timer, jiffies + msecs_to_jiffies(timeout));
+        }
+}
+
 static int write(struct tty_struct *tty,
                  const unsigned char *buf, int count)
 {
@@ -838,8 +849,18 @@ start:
                 spin_lock_irqsave(&info->lock,flags);
                 if (!info->tx_active)
                         tx_start(info);
-                else
-                        tdma_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);
         }
 
@@ -1502,10 +1523,9 @@ static int hdlcdev_xmit(struct sk_buff *skb, struct net_device *dev)
         /* save start time for transmit timeout detection */
         dev->trans_start = jiffies;
 
-        /* start hardware transmitter if necessary */
         spin_lock_irqsave(&info->lock,flags);
-        if (!info->tx_active)
-                tx_start(info);
+        tx_start(info);
+        update_tx_timer(info);
         spin_unlock_irqrestore(&info->lock,flags);
 
         return 0;
@@ -3946,50 +3966,19 @@ static void tx_start(struct slgt_info *info)
                         slgt_irq_on(info, IRQ_TXUNDER + IRQ_TXIDLE);
                         /* clear tx idle and underrun status bits */
                         wr_reg16(info, SSR, (unsigned short)(IRQ_TXIDLE + IRQ_TXUNDER));
-                        if (info->params.mode == MGSL_MODE_HDLC)
-                                mod_timer(&info->tx_timer, jiffies +
-                                                msecs_to_jiffies(5000));
                 } else {
                         slgt_irq_off(info, IRQ_TXDATA);
                         slgt_irq_on(info, IRQ_TXIDLE);
                         /* clear tx idle status bit */
                         wr_reg16(info, SSR, IRQ_TXIDLE);
                 }
-                tdma_start(info);
+                /* set 1st descriptor address and start DMA */
+                wr_reg32(info, TDDAR, info->tbufs[info->tbuf_start].pdesc);
+                wr_reg32(info, TDCSR, BIT2 + BIT0);
                 info->tx_active = true;
         }
 }
 
-/*
- * start transmit DMA if inactive and there are unsent buffers
- */
-static void tdma_start(struct slgt_info *info)
-{
-        unsigned int i;
-
-        if (rd_reg32(info, TDCSR) & BIT0)
-                return;
-
-        /* transmit DMA inactive, check for unsent buffers */
-        i = info->tbuf_start;
-        while (!desc_count(info->tbufs[i])) {
-                if (++i == info->tbuf_count)
-                        i = 0;
-                if (i == info->tbuf_current)
-                        return;
-        }
-        info->tbuf_start = i;
-
-        /* there are unsent buffers, start transmit DMA */
-
-        /* reset needed if previous error condition */
-        tdma_reset(info);
-
-        /* set 1st descriptor address */
-        wr_reg32(info, TDDAR, info->tbufs[info->tbuf_start].pdesc);
-        wr_reg32(info, TDCSR, BIT2 + BIT0); /* IRQ + DMA enable */
-}
-
 static void tx_stop(struct slgt_info *info)
 {
         unsigned short val;
@@ -5004,8 +4993,7 @@ static void tx_timeout(unsigned long context)
                 info->icount.txtimeout++;
         }
         spin_lock_irqsave(&info->lock,flags);
-        info->tx_active = false;
-        info->tx_count = 0;
+        tx_stop(info);
         spin_unlock_irqrestore(&info->lock,flags);
 
 #if SYNCLINK_GENERIC_HDLC
diff --git a/drivers/char/tty_ldisc.c b/drivers/char/tty_ldisc.c
index a19e935847b0..913aa8d3f1c5 100644
--- a/drivers/char/tty_ldisc.c
+++ b/drivers/char/tty_ldisc.c
@@ -867,15 +867,22 @@ void tty_ldisc_release(struct tty_struct *tty, struct tty_struct *o_tty)
         tty_ldisc_wait_idle(tty);
 
         /*
-         * Shutdown the current line discipline, and reset it to N_TTY.
-         *
-         * FIXME: this MUST get fixed for the new reflocking
+         * Now kill off the ldisc
          */
+        tty_ldisc_close(tty, tty->ldisc);
+        tty_ldisc_put(tty->ldisc);
+        /* Force an oops if we mess this up */
+        tty->ldisc = NULL;
+
+        /* Ensure the next open requests the N_TTY ldisc */
+        tty_set_termios_ldisc(tty, N_TTY);
 
-        tty_ldisc_reinit(tty);
         /* This will need doing differently if we need to lock */
         if (o_tty)
                 tty_ldisc_release(o_tty, NULL);
+
+        /* And the memory resources remaining (buffers, termios) will be
+           disposed of when the kref hits zero */
 }
 
 /**
diff --git a/drivers/char/tty_port.c b/drivers/char/tty_port.c
index 62dadfc95e34..4e862a75f7ff 100644
--- a/drivers/char/tty_port.c
+++ b/drivers/char/tty_port.c
@@ -193,7 +193,7 @@ int tty_port_block_til_ready(struct tty_port *port,
 {
         int do_clocal = 0, retval;
         unsigned long flags;
-        DECLARE_WAITQUEUE(wait, current);
+        DEFINE_WAIT(wait);
         int cd;
 
         /* block if port is in the process of being closed */
diff --git a/drivers/char/vt_ioctl.c b/drivers/char/vt_ioctl.c
index e6ce632a393e..7539bed0f7e0 100644
--- a/drivers/char/vt_ioctl.c
+++ b/drivers/char/vt_ioctl.c
@@ -396,7 +396,8 @@ int vt_ioctl(struct tty_struct *tty, struct file * file,
         kbd = kbd_table + console;
         switch (cmd) {
         case TIOCLINUX:
-                return tioclinux(tty, arg);
+                ret = tioclinux(tty, arg);
+                break;
         case KIOCSOUND:
                 if (!perm)
                         goto eperm;