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: (58 commits)
  tty: split the lock up a bit further
  tty: Move the leader test in disassociate
  tty: Push the bkl down a bit in the hangup code
  tty: Push the lock down further into the ldisc code
  tty: push the BKL down into the handlers a bit
  tty: moxa: split open lock
  tty: moxa: Kill the use of lock_kernel
  tty: moxa: Fix modem op locking
  tty: moxa: Kill off the throttle method
  tty: moxa: Locking clean up
  tty: moxa: rework the locking a bit
  tty: moxa: Use more tty_port ops
  tty: isicom: fix deadlock on shutdown
  tty: mxser: Use the new locking rules to fix setserial properly
  tty: mxser: use the tty_port_open method
  tty: isicom: sort out the board init logic
  tty: isicom: switch to the new tty_port_open helper
  tty: tty_port: Add a kref object to the tty port
  tty: istallion: tty port open/close methods
  tty: stallion: Convert to the tty_port_open/close methods
  ...

1 files changed, 199 insertions, 104 deletions

diff --git a/drivers/mmc/card/sdio_uart.c b/drivers/mmc/card/sdio_uart.c
index b8e7c5ae981e..f53755533e7e 100644
--- a/drivers/mmc/card/sdio_uart.c
+++ b/drivers/mmc/card/sdio_uart.c
@@ -29,6 +29,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
+#include <linux/sched.h>
 #include <linux/mutex.h>
 #include <linux/seq_file.h>
 #include <linux/serial_reg.h>
@@ -73,11 +74,10 @@ struct uart_icount {
 };
 
 struct sdio_uart_port {
+        struct tty_port         port;
         struct kref             kref;
         struct tty_struct       *tty;
         unsigned int            index;
-        unsigned int            opened;
-        struct mutex            open_lock;
         struct sdio_func        *func;
         struct mutex            func_lock;
         struct task_struct      *in_sdio_uart_irq;
@@ -87,6 +87,7 @@ struct sdio_uart_port {
         struct uart_icount      icount;
         unsigned int            uartclk;
         unsigned int            mctrl;
+        unsigned int            rx_mctrl;
         unsigned int            read_status_mask;
         unsigned int            ignore_status_mask;
         unsigned char           x_char;
@@ -102,7 +103,6 @@ static int sdio_uart_add_port(struct sdio_uart_port *port)
         int index, ret = -EBUSY;
 
         kref_init(&port->kref);
-        mutex_init(&port->open_lock);
         mutex_init(&port->func_lock);
         spin_lock_init(&port->write_lock);
 
@@ -151,6 +151,7 @@ static void sdio_uart_port_put(struct sdio_uart_port *port)
 static void sdio_uart_port_remove(struct sdio_uart_port *port)
 {
         struct sdio_func *func;
+        struct tty_struct *tty;
 
         BUG_ON(sdio_uart_table[port->index] != port);
 
@@ -165,15 +166,19 @@ static void sdio_uart_port_remove(struct sdio_uart_port *port)
          * give up on that port ASAP.
          * Beware: the lock ordering is critical.
          */
-        mutex_lock(&port->open_lock);
+        mutex_lock(&port->port.mutex);
         mutex_lock(&port->func_lock);
         func = port->func;
         sdio_claim_host(func);
         port->func = NULL;
         mutex_unlock(&port->func_lock);
-        if (port->opened)
-                tty_hangup(port->tty);
-        mutex_unlock(&port->open_lock);
+        tty = tty_port_tty_get(&port->port);
+        /* tty_hangup is async so is this safe as is ?? */
+        if (tty) {
+                tty_hangup(tty);
+                tty_kref_put(tty);
+        }
+        mutex_unlock(&port->port.mutex);
         sdio_release_irq(func);
         sdio_disable_func(func);
         sdio_release_host(func);
@@ -217,6 +222,8 @@ static unsigned int sdio_uart_get_mctrl(struct sdio_uart_port *port)
         unsigned char status;
         unsigned int ret;
 
+        /* FIXME: What stops this losing the delta bits and breaking
+           sdio_uart_check_modem_status ? */
         status = sdio_in(port, UART_MSR);
 
         ret = 0;
@@ -391,7 +398,7 @@ static void sdio_uart_stop_rx(struct sdio_uart_port *port)
 static void sdio_uart_receive_chars(struct sdio_uart_port *port,
                                     unsigned int *status)
 {
-        struct tty_struct *tty = port->tty;
+        struct tty_struct *tty = tty_port_tty_get(&port->port);
         unsigned int ch, flag;
         int max_count = 256;
 
@@ -428,24 +435,30 @@ static void sdio_uart_receive_chars(struct sdio_uart_port *port,
                 }
 
                 if ((*status & port->ignore_status_mask & ~UART_LSR_OE) == 0)
-                        tty_insert_flip_char(tty, ch, flag);
+                        if (tty)
+                                tty_insert_flip_char(tty, ch, flag);
 
                 /*
                  * Overrun is special.  Since it's reported immediately,
                  * it doesn't affect the current character.
                  */
                 if (*status & ~port->ignore_status_mask & UART_LSR_OE)
-                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                        if (tty)
+                                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
 
                 *status = sdio_in(port, UART_LSR);
         } while ((*status & UART_LSR_DR) && (max_count-- > 0));
-        tty_flip_buffer_push(tty);
+        if (tty) {
+                tty_flip_buffer_push(tty);
+                tty_kref_put(tty);
+        }
 }
 
 static void sdio_uart_transmit_chars(struct sdio_uart_port *port)
 {
         struct circ_buf *xmit = &port->xmit;
         int count;
+        struct tty_struct *tty;
 
         if (port->x_char) {
                 sdio_out(port, UART_TX, port->x_char);
@@ -453,8 +466,13 @@ static void sdio_uart_transmit_chars(struct sdio_uart_port *port)
                 port->x_char = 0;
                 return;
         }
-        if (circ_empty(xmit) || port->tty->stopped || port->tty->hw_stopped) {
+
+        tty = tty_port_tty_get(&port->port);
+
+        if (tty == NULL || circ_empty(xmit) ||
+                                tty->stopped || tty->hw_stopped) {
                 sdio_uart_stop_tx(port);
+                tty_kref_put(tty);
                 return;
         }
 
@@ -468,15 +486,17 @@ static void sdio_uart_transmit_chars(struct sdio_uart_port *port)
         } while (--count > 0);
 
         if (circ_chars_pending(xmit) < WAKEUP_CHARS)
-                tty_wakeup(port->tty);
+                tty_wakeup(tty);
 
         if (circ_empty(xmit))
                 sdio_uart_stop_tx(port);
+        tty_kref_put(tty);
 }
 
 static void sdio_uart_check_modem_status(struct sdio_uart_port *port)
 {
         int status;
+        struct tty_struct *tty;
 
         status = sdio_in(port, UART_MSR);
 
@@ -487,25 +507,39 @@ static void sdio_uart_check_modem_status(struct sdio_uart_port *port)
                 port->icount.rng++;
         if (status & UART_MSR_DDSR)
                 port->icount.dsr++;
-        if (status & UART_MSR_DDCD)
+        if (status & UART_MSR_DDCD) {
                 port->icount.dcd++;
+                /* DCD raise - wake for open */
+                if (status & UART_MSR_DCD)
+                        wake_up_interruptible(&port->port.open_wait);
+                else {
+                        /* DCD drop - hang up if tty attached */
+                        tty = tty_port_tty_get(&port->port);
+                        if (tty) {
+                                tty_hangup(tty);
+                                tty_kref_put(tty);
+                        }
+                }
+        }
         if (status & UART_MSR_DCTS) {
                 port->icount.cts++;
-                if (port->tty->termios->c_cflag & CRTSCTS) {
+                tty = tty_port_tty_get(&port->port);
+                if (tty && (tty->termios->c_cflag & CRTSCTS)) {
                         int cts = (status & UART_MSR_CTS);
-                        if (port->tty->hw_stopped) {
+                        if (tty->hw_stopped) {
                                 if (cts) {
-                                        port->tty->hw_stopped = 0;
+                                        tty->hw_stopped = 0;
                                         sdio_uart_start_tx(port);
-                                        tty_wakeup(port->tty);
+                                        tty_wakeup(tty);
                                 }
                         } else {
                                 if (!cts) {
-                                        port->tty->hw_stopped = 1;
+                                        tty->hw_stopped = 1;
                                         sdio_uart_stop_tx(port);
                                 }
                         }
                 }
+                tty_kref_put(tty);
         }
 }
 
@@ -542,8 +576,62 @@ static void sdio_uart_irq(struct sdio_func *func)
         port->in_sdio_uart_irq = NULL;
 }
 
-static int sdio_uart_startup(struct sdio_uart_port *port)
+static int uart_carrier_raised(struct tty_port *tport)
+{
+        struct sdio_uart_port *port =
+                        container_of(tport, struct sdio_uart_port, port);
+        unsigned int ret = sdio_uart_claim_func(port);
+        if (ret)        /* Missing hardware shoudn't block for carrier */
+                return 1;
+        ret = sdio_uart_get_mctrl(port);
+        sdio_uart_release_func(port);
+        if (ret & TIOCM_CAR)
+                return 1;
+        return 0;
+}
+
+/**
+ *      uart_dtr_rts            -        port helper to set uart signals
+ *      @tport: tty port to be updated
+ *      @onoff: set to turn on DTR/RTS
+ *
+ *      Called by the tty port helpers when the modem signals need to be
+ *      adjusted during an open, close and hangup.
+ */
+
+static void uart_dtr_rts(struct tty_port *tport, int onoff)
+{
+        struct sdio_uart_port *port =
+                        container_of(tport, struct sdio_uart_port, port);
+        int ret = sdio_uart_claim_func(port);
+        if (ret)
+                return;
+        if (onoff == 0)
+                sdio_uart_clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
+        else
+                sdio_uart_set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
+        sdio_uart_release_func(port);
+}
+
+/**
+ *      sdio_uart_activate      -       start up hardware
+ *      @tport: tty port to activate
+ *      @tty: tty bound to this port
+ *
+ *      Activate a tty port. The port locking guarantees us this will be
+ *      run exactly once per set of opens, and if successful will see the
+ *      shutdown method run exactly once to match. Start up and shutdown are
+ *      protected from each other by the internal locking and will not run
+ *      at the same time even during a hangup event.
+ *
+ *      If we successfully start up the port we take an extra kref as we
+ *      will keep it around until shutdown when the kref is dropped.
+ */
+
+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;
 
@@ -551,7 +639,7 @@ static int sdio_uart_startup(struct sdio_uart_port *port)
          * Set the TTY IO error marker - we will only clear this
          * once we have successfully opened the port.
          */
-        set_bit(TTY_IO_ERROR, &port->tty->flags);
+        set_bit(TTY_IO_ERROR, &tty->flags);
 
         /* Initialise and allocate the transmit buffer. */
         page = __get_free_page(GFP_KERNEL);
@@ -592,19 +680,19 @@ static int sdio_uart_startup(struct sdio_uart_port *port)
          */
         sdio_out(port, UART_LCR, UART_LCR_WLEN8);
 
-        port->ier = UART_IER_RLSI | UART_IER_RDI | UART_IER_RTOIE | UART_IER_UUE;
+        port->ier = UART_IER_RLSI|UART_IER_RDI|UART_IER_RTOIE|UART_IER_UUE;
         port->mctrl = TIOCM_OUT2;
 
-        sdio_uart_change_speed(port, port->tty->termios, NULL);
+        sdio_uart_change_speed(port, tty->termios, NULL);
 
-        if (port->tty->termios->c_cflag & CBAUD)
+        if (tty->termios->c_cflag & CBAUD)
                 sdio_uart_set_mctrl(port, TIOCM_RTS | TIOCM_DTR);
 
-        if (port->tty->termios->c_cflag & CRTSCTS)
+        if (tty->termios->c_cflag & CRTSCTS)
                 if (!(sdio_uart_get_mctrl(port) & TIOCM_CTS))
-                        port->tty->hw_stopped = 1;
+                        tty->hw_stopped = 1;
 
-        clear_bit(TTY_IO_ERROR, &port->tty->flags);
+        clear_bit(TTY_IO_ERROR, &tty->flags);
 
         /* Kick the IRQ handler once while we're still holding the host lock */
         sdio_uart_irq(port->func);
@@ -621,8 +709,20 @@ err1:
         return ret;
 }
 
-static void sdio_uart_shutdown(struct sdio_uart_port *port)
+/**
+ *      sdio_uart_shutdown      -       stop hardware
+ *      @tport: tty port to shut down
+ *
+ *      Deactivate a tty port. The port locking guarantees us this will be
+ *      run only if a successful matching activate already ran. The two are
+ *      protected from each other by the internal locking and will not run
+ *      at the same time even during a hangup event.
+ */
+
+static void sdio_uart_shutdown(struct tty_port *tport)
 {
+        struct sdio_uart_port *port =
+                        container_of(tport, struct sdio_uart_port, port);
         int ret;
 
         ret = sdio_uart_claim_func(port);
@@ -631,12 +731,6 @@ static void sdio_uart_shutdown(struct sdio_uart_port *port)
 
         sdio_uart_stop_rx(port);
 
-        /* TODO: wait here for TX FIFO to drain */
-
-        /* Turn off DTR and RTS early. */
-        if (port->tty->termios->c_cflag & HUPCL)
-                sdio_uart_clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
-
         /* Disable interrupts from this port */
         sdio_release_irq(port->func);
         port->ier = 0;
@@ -661,77 +755,70 @@ skip:
         free_page((unsigned long)port->xmit.buf);
 }
 
-static int sdio_uart_open(struct tty_struct *tty, struct file *filp)
+/**
+ *      sdio_uart_install       -       install method
+ *      @driver: the driver in use (sdio_uart in our case)
+ *      @tty: the tty being bound
+ *
+ *      Look up and bind the tty and the driver together. Initialize
+ *      any needed private data (in our case the termios)
+ */
+
+static int sdio_uart_install(struct tty_driver *driver, struct tty_struct *tty)
 {
-        struct sdio_uart_port *port;
-        int ret;
+        int idx = tty->index;
+        struct sdio_uart_port *port = sdio_uart_port_get(idx);
+        int ret = tty_init_termios(tty);
+
+        if (ret == 0) {
+                tty_driver_kref_get(driver);
+                tty->count++;
+                /* This is the ref sdio_uart_port get provided */
+                tty->driver_data = port;
+                driver->ttys[idx] = tty;
+        } else
+                sdio_uart_port_put(port);
+        return ret;
+}
 
-        port = sdio_uart_port_get(tty->index);
-        if (!port)
-                return -ENODEV;
+/**
+ *      sdio_uart_cleanup       -       called on the last tty kref drop
+ *      @tty: the tty being destroyed
+ *
+ *      Called asynchronously when the last reference to the tty is dropped.
+ *      We cannot destroy the tty->driver_data port kref until this point
+ */
 
-        mutex_lock(&port->open_lock);
+static void sdio_uart_cleanup(struct tty_struct *tty)
+{
+        struct sdio_uart_port *port = tty->driver_data;
+        tty->driver_data = NULL;        /* Bug trap */
+        sdio_uart_port_put(port);
+}
 
-        /*
-         * Make sure not to mess up with a dead port
-         * which has not been closed yet.
-         */
-        if (tty->driver_data && tty->driver_data != port) {
-                mutex_unlock(&port->open_lock);
-                sdio_uart_port_put(port);
-                return -EBUSY;
-        }
+/*
+ *      Open/close/hangup is now entirely boilerplate
+ */
 
-        if (!port->opened) {
-                tty->driver_data = port;
-                port->tty = tty;
-                ret = sdio_uart_startup(port);
-                if (ret) {
-                        tty->driver_data = NULL;
-                        port->tty = NULL;
-                        mutex_unlock(&port->open_lock);
-                        sdio_uart_port_put(port);
-                        return ret;
-                }
-        }
-        port->opened++;
-        mutex_unlock(&port->open_lock);
-        return 0;
+static int sdio_uart_open(struct tty_struct *tty, struct file *filp)
+{
+        struct sdio_uart_port *port = tty->driver_data;
+        return tty_port_open(&port->port, tty, filp);
 }
 
 static void sdio_uart_close(struct tty_struct *tty, struct file * filp)
 {
         struct sdio_uart_port *port = tty->driver_data;
+        tty_port_close(&port->port, tty, filp);
+}
 
-        if (!port)
-                return;
-
-        mutex_lock(&port->open_lock);
-        BUG_ON(!port->opened);
-
-        /*
-         * This is messy.  The tty layer calls us even when open()
-         * returned an error.  Ignore this close request if tty->count
-         * is larger than port->count.
-         */
-        if (tty->count > port->opened) {
-                mutex_unlock(&port->open_lock);
-                return;
-        }
-
-        if (--port->opened == 0) {
-                tty->closing = 1;
-                sdio_uart_shutdown(port);
-                tty_ldisc_flush(tty);
-                port->tty = NULL;
-                tty->driver_data = NULL;
-                tty->closing = 0;
-        }
-        mutex_unlock(&port->open_lock);
-        sdio_uart_port_put(port);
+static void sdio_uart_hangup(struct tty_struct *tty)
+{
+        struct sdio_uart_port *port = tty->driver_data;
+        tty_port_hangup(&port->port);
 }
 
-static int sdio_uart_write(struct tty_struct * tty, const unsigned char *buf,
+static int sdio_uart_write(struct tty_struct *tty, const unsigned char *buf,
                            int count)
 {
         struct sdio_uart_port *port = tty->driver_data;
@@ -756,7 +843,7 @@ static int sdio_uart_write(struct tty_struct * tty, const unsigned char *buf,
         }
         spin_unlock(&port->write_lock);
 
-        if ( !(port->ier & UART_IER_THRI)) {
+        if (!(port->ier & UART_IER_THRI)) {
                 int err = sdio_uart_claim_func(port);
                 if (!err) {
                         sdio_uart_start_tx(port);
@@ -843,17 +930,12 @@ static void sdio_uart_unthrottle(struct tty_struct *tty)
         sdio_uart_release_func(port);
 }
 
-static void sdio_uart_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
+static void sdio_uart_set_termios(struct tty_struct *tty,
+                                                struct ktermios *old_termios)
 {
         struct sdio_uart_port *port = tty->driver_data;
         unsigned int cflag = tty->termios->c_cflag;
 
-#define RELEVANT_IFLAG(iflag)   ((iflag) & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
-
-        if ((cflag ^ old_termios->c_cflag) == 0 &&
-            RELEVANT_IFLAG(tty->termios->c_iflag ^ old_termios->c_iflag) == 0)
-                return;
-
         if (sdio_uart_claim_func(port) != 0)
                 return;
 
@@ -928,7 +1010,7 @@ static int sdio_uart_tiocmset(struct tty_struct *tty, struct file *file,
         int result;
 
         result = sdio_uart_claim_func(port);
-        if(!result) {
+        if (!result) {
                 sdio_uart_update_mctrl(port, set, clear);
                 sdio_uart_release_func(port);
         }
@@ -946,7 +1028,7 @@ static int sdio_uart_proc_show(struct seq_file *m, void *v)
                 struct sdio_uart_port *port = sdio_uart_port_get(i);
                 if (port) {
                         seq_printf(m, "%d: uart:SDIO", i);
-                        if(capable(CAP_SYS_ADMIN)) {
+                        if (capable(CAP_SYS_ADMIN)) {
                                 seq_printf(m, " tx:%d rx:%d",
                                               port->icount.tx, port->icount.rx);
                                 if (port->icount.frame)
@@ -994,6 +1076,13 @@ static const struct file_operations sdio_uart_proc_fops = {
         .release        = single_release,
 };
 
+static const struct tty_port_operations sdio_uart_port_ops = {
+        .dtr_rts = uart_dtr_rts,
+        .carrier_raised = uart_carrier_raised,
+        .shutdown = sdio_uart_shutdown,
+        .activate = sdio_uart_activate,
+};
+
 static const struct tty_operations sdio_uart_ops = {
         .open                   = sdio_uart_open,
         .close                  = sdio_uart_close,
@@ -1004,9 +1093,12 @@ static const struct tty_operations sdio_uart_ops = {
         .throttle               = sdio_uart_throttle,
         .unthrottle             = sdio_uart_unthrottle,
         .set_termios            = sdio_uart_set_termios,
+        .hangup                 = sdio_uart_hangup,
         .break_ctl              = sdio_uart_break_ctl,
         .tiocmget               = sdio_uart_tiocmget,
         .tiocmset               = sdio_uart_tiocmset,
+        .install                = sdio_uart_install,
+        .cleanup                = sdio_uart_cleanup,
         .proc_fops              = &sdio_uart_proc_fops,
 };
 
@@ -1043,7 +1135,7 @@ static int sdio_uart_probe(struct sdio_func *func,
                 }
                 if (!tpl) {
                         printk(KERN_WARNING
-                               "%s: can't find tuple 0x91 subtuple 0 (SUBTPL_SIOREG) for GPS class\n",
+       "%s: can't find tuple 0x91 subtuple 0 (SUBTPL_SIOREG) for GPS class\n",
                                sdio_func_id(func));
                         kfree(port);
                         return -EINVAL;
@@ -1068,13 +1160,16 @@ static int sdio_uart_probe(struct sdio_func *func,
 
         port->func = func;
         sdio_set_drvdata(func, port);
+        tty_port_init(&port->port);
+        port->port.ops = &sdio_uart_port_ops;
 
         ret = sdio_uart_add_port(port);
         if (ret) {
                 kfree(port);
         } else {
                 struct device *dev;
-                dev = tty_register_device(sdio_uart_tty_driver, port->index, &func->dev);
+                dev = tty_register_device(sdio_uart_tty_driver,
+                                                port->index, &func->dev);
                 if (IS_ERR(dev)) {
                         sdio_uart_port_remove(port);
                         ret = PTR_ERR(dev);