1 files changed, 228 insertions, 29 deletions

diff --git a/drivers/tty/serial/serial_core.c b/drivers/tty/serial/serial_core.c
index 0fcfd98a9566..2c7230aaefd4 100644
--- a/drivers/tty/serial/serial_core.c
+++ b/drivers/tty/serial/serial_core.c
@@ -610,34 +610,57 @@ static void uart_send_xchar(struct tty_struct *tty, char ch)
 static void uart_throttle(struct tty_struct *tty)
 {
         struct uart_state *state = tty->driver_data;
+        struct uart_port *port = state->uart_port;
+        uint32_t mask = 0;
 
         if (I_IXOFF(tty))
+                mask |= UPF_SOFT_FLOW;
+        if (tty->termios.c_cflag & CRTSCTS)
+                mask |= UPF_HARD_FLOW;
+
+        if (port->flags & mask) {
+                port->ops->throttle(port);
+                mask &= ~port->flags;
+        }
+
+        if (mask & UPF_SOFT_FLOW)
                 uart_send_xchar(tty, STOP_CHAR(tty));
 
-        if (tty->termios.c_cflag & CRTSCTS)
-                uart_clear_mctrl(state->uart_port, TIOCM_RTS);
+        if (mask & UPF_HARD_FLOW)
+                uart_clear_mctrl(port, TIOCM_RTS);
 }
 
 static void uart_unthrottle(struct tty_struct *tty)
 {
         struct uart_state *state = tty->driver_data;
         struct uart_port *port = state->uart_port;
+        uint32_t mask = 0;
+
+        if (I_IXOFF(tty))
+                mask |= UPF_SOFT_FLOW;
+        if (tty->termios.c_cflag & CRTSCTS)
+                mask |= UPF_HARD_FLOW;
 
-        if (I_IXOFF(tty)) {
+        if (port->flags & mask) {
+                port->ops->unthrottle(port);
+                mask &= ~port->flags;
+        }
+
+        if (mask & UPF_SOFT_FLOW) {
                 if (port->x_char)
                         port->x_char = 0;
                 else
                         uart_send_xchar(tty, START_CHAR(tty));
         }
 
-        if (tty->termios.c_cflag & CRTSCTS)
+        if (mask & UPF_HARD_FLOW)
                 uart_set_mctrl(port, TIOCM_RTS);
 }
 
-static void uart_get_info(struct tty_port *port,
-                        struct uart_state *state,
+static void do_uart_get_info(struct tty_port *port,
                         struct serial_struct *retinfo)
 {
+        struct uart_state *state = container_of(port, struct uart_state, port);
         struct uart_port *uport = state->uart_port;
 
         memset(retinfo, 0, sizeof(*retinfo));
@@ -662,17 +685,21 @@ static void uart_get_info(struct tty_port *port,
         retinfo->iomem_base      = (void *)(unsigned long)uport->mapbase;
 }
 
-static int uart_get_info_user(struct uart_state *state,
-                         struct serial_struct __user *retinfo)
+static void uart_get_info(struct tty_port *port,
+                        struct serial_struct *retinfo)
 {
-        struct tty_port *port = &state->port;
-        struct serial_struct tmp;
-
         /* Ensure the state we copy is consistent and no hardware changes
            occur as we go */
         mutex_lock(&port->mutex);
-        uart_get_info(port, state, &tmp);
+        do_uart_get_info(port, retinfo);
         mutex_unlock(&port->mutex);
+}
+
+static int uart_get_info_user(struct tty_port *port,
+                         struct serial_struct __user *retinfo)
+{
+        struct serial_struct tmp;
+        uart_get_info(port, &tmp);
 
         if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
                 return -EFAULT;
@@ -1131,7 +1158,7 @@ uart_ioctl(struct tty_struct *tty, unsigned int cmd,
          */
         switch (cmd) {
         case TIOCGSERIAL:
-                ret = uart_get_info_user(state, uarg);
+                ret = uart_get_info_user(port, uarg);
                 break;
 
         case TIOCSSERIAL:
@@ -1210,9 +1237,22 @@ static void uart_set_termios(struct tty_struct *tty,
                                                 struct ktermios *old_termios)
 {
         struct uart_state *state = tty->driver_data;
+        struct uart_port *uport = state->uart_port;
         unsigned long flags;
         unsigned int cflag = tty->termios.c_cflag;
+        unsigned int iflag_mask = IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK;
+        bool sw_changed = false;
 
+        /*
+         * Drivers doing software flow control also need to know
+         * about changes to these input settings.
+         */
+        if (uport->flags & UPF_SOFT_FLOW) {
+                iflag_mask |= IXANY|IXON|IXOFF;
+                sw_changed =
+                   tty->termios.c_cc[VSTART] != old_termios->c_cc[VSTART] ||
+                   tty->termios.c_cc[VSTOP] != old_termios->c_cc[VSTOP];
+        }
 
         /*
          * These are the bits that are used to setup various
@@ -1220,11 +1260,11 @@ static void uart_set_termios(struct tty_struct *tty,
          * bits in c_cflag; c_[io]speed will always be set
          * appropriately by set_termios() in tty_ioctl.c
          */
-#define RELEVANT_IFLAG(iflag)   ((iflag) & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
         if ((cflag ^ old_termios->c_cflag) == 0 &&
             tty->termios.c_ospeed == old_termios->c_ospeed &&
             tty->termios.c_ispeed == old_termios->c_ispeed &&
-            RELEVANT_IFLAG(tty->termios.c_iflag ^ old_termios->c_iflag) == 0) {
+            ((tty->termios.c_iflag ^ old_termios->c_iflag) & iflag_mask) == 0 &&
+            !sw_changed) {
                 return;
         }
 
@@ -1232,31 +1272,38 @@ static void uart_set_termios(struct tty_struct *tty,
 
         /* Handle transition to B0 status */
         if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD))
-                uart_clear_mctrl(state->uart_port, TIOCM_RTS | TIOCM_DTR);
+                uart_clear_mctrl(uport, TIOCM_RTS | TIOCM_DTR);
         /* Handle transition away from B0 status */
         else if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
                 unsigned int mask = TIOCM_DTR;
                 if (!(cflag & CRTSCTS) ||
                     !test_bit(TTY_THROTTLED, &tty->flags))
                         mask |= TIOCM_RTS;
-                uart_set_mctrl(state->uart_port, mask);
+                uart_set_mctrl(uport, mask);
         }
 
+        /*
+         * If the port is doing h/w assisted flow control, do nothing.
+         * We assume that tty->hw_stopped has never been set.
+         */
+        if (uport->flags & UPF_HARD_FLOW)
+                return;
+
         /* Handle turning off CRTSCTS */
         if ((old_termios->c_cflag & CRTSCTS) && !(cflag & CRTSCTS)) {
-                spin_lock_irqsave(&state->uart_port->lock, flags);
+                spin_lock_irqsave(&uport->lock, flags);
                 tty->hw_stopped = 0;
                 __uart_start(tty);
-                spin_unlock_irqrestore(&state->uart_port->lock, flags);
+                spin_unlock_irqrestore(&uport->lock, flags);
         }
         /* Handle turning on CRTSCTS */
         else if (!(old_termios->c_cflag & CRTSCTS) && (cflag & CRTSCTS)) {
-                spin_lock_irqsave(&state->uart_port->lock, flags);
-                if (!(state->uart_port->ops->get_mctrl(state->uart_port) & TIOCM_CTS)) {
+                spin_lock_irqsave(&uport->lock, flags);
+                if (!(uport->ops->get_mctrl(uport) & TIOCM_CTS)) {
                         tty->hw_stopped = 1;
-                        state->uart_port->ops->stop_tx(state->uart_port);
+                        uport->ops->stop_tx(uport);
                 }
-                spin_unlock_irqrestore(&state->uart_port->lock, flags);
+                spin_unlock_irqrestore(&uport->lock, flags);
         }
 }
 
@@ -2293,6 +2340,8 @@ int uart_register_driver(struct uart_driver *drv)
         if (retval >= 0)
                 return retval;
 
+        for (i = 0; i < drv->nr; i++)
+                tty_port_destroy(&drv->state[i].port);
         put_tty_driver(normal);
 out_kfree:
         kfree(drv->state);
@@ -2312,8 +2361,12 @@ out:
 void uart_unregister_driver(struct uart_driver *drv)
 {
         struct tty_driver *p = drv->tty_driver;
+        unsigned int i;
+
         tty_unregister_driver(p);
         put_tty_driver(p);
+        for (i = 0; i < drv->nr; i++)
+                tty_port_destroy(&drv->state[i].port);
         kfree(drv->state);
         drv->state = NULL;
         drv->tty_driver = NULL;
@@ -2329,21 +2382,166 @@ struct tty_driver *uart_console_device(struct console *co, int *index)
 static ssize_t uart_get_attr_uartclk(struct device *dev,
         struct device_attribute *attr, char *buf)
 {
-        int ret;
+        struct serial_struct tmp;
         struct tty_port *port = dev_get_drvdata(dev);
-        struct uart_state *state = container_of(port, struct uart_state, port);
 
-        mutex_lock(&state->port.mutex);
-        ret = snprintf(buf, PAGE_SIZE, "%d\n", state->uart_port->uartclk);
-        mutex_unlock(&state->port.mutex);
+        uart_get_info(port, &tmp);
+        return snprintf(buf, PAGE_SIZE, "%d\n", tmp.baud_base * 16);
+}
 
-        return ret;
+static ssize_t uart_get_attr_type(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        struct serial_struct tmp;
+        struct tty_port *port = dev_get_drvdata(dev);
+
+        uart_get_info(port, &tmp);
+        return snprintf(buf, PAGE_SIZE, "%d\n", tmp.type);
+}
+static ssize_t uart_get_attr_line(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        struct serial_struct tmp;
+        struct tty_port *port = dev_get_drvdata(dev);
+
+        uart_get_info(port, &tmp);
+        return snprintf(buf, PAGE_SIZE, "%d\n", tmp.line);
+}
+
+static ssize_t uart_get_attr_port(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        struct serial_struct tmp;
+        struct tty_port *port = dev_get_drvdata(dev);
+        unsigned long ioaddr;
+
+        uart_get_info(port, &tmp);
+        ioaddr = tmp.port;
+        if (HIGH_BITS_OFFSET)
+                ioaddr |= (unsigned long)tmp.port_high << HIGH_BITS_OFFSET;
+        return snprintf(buf, PAGE_SIZE, "0x%lX\n", ioaddr);
 }
 
+static ssize_t uart_get_attr_irq(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        struct serial_struct tmp;
+        struct tty_port *port = dev_get_drvdata(dev);
+
+        uart_get_info(port, &tmp);
+        return snprintf(buf, PAGE_SIZE, "%d\n", tmp.irq);
+}
+
+static ssize_t uart_get_attr_flags(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        struct serial_struct tmp;
+        struct tty_port *port = dev_get_drvdata(dev);
+
+        uart_get_info(port, &tmp);
+        return snprintf(buf, PAGE_SIZE, "0x%X\n", tmp.flags);
+}
+
+static ssize_t uart_get_attr_xmit_fifo_size(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        struct serial_struct tmp;
+        struct tty_port *port = dev_get_drvdata(dev);
+
+        uart_get_info(port, &tmp);
+        return snprintf(buf, PAGE_SIZE, "%d\n", tmp.xmit_fifo_size);
+}
+
+
+static ssize_t uart_get_attr_close_delay(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        struct serial_struct tmp;
+        struct tty_port *port = dev_get_drvdata(dev);
+
+        uart_get_info(port, &tmp);
+        return snprintf(buf, PAGE_SIZE, "%d\n", tmp.close_delay);
+}
+
+
+static ssize_t uart_get_attr_closing_wait(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        struct serial_struct tmp;
+        struct tty_port *port = dev_get_drvdata(dev);
+
+        uart_get_info(port, &tmp);
+        return snprintf(buf, PAGE_SIZE, "%d\n", tmp.closing_wait);
+}
+
+static ssize_t uart_get_attr_custom_divisor(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        struct serial_struct tmp;
+        struct tty_port *port = dev_get_drvdata(dev);
+
+        uart_get_info(port, &tmp);
+        return snprintf(buf, PAGE_SIZE, "%d\n", tmp.custom_divisor);
+}
+
+static ssize_t uart_get_attr_io_type(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        struct serial_struct tmp;
+        struct tty_port *port = dev_get_drvdata(dev);
+
+        uart_get_info(port, &tmp);
+        return snprintf(buf, PAGE_SIZE, "%d\n", tmp.io_type);
+}
+
+static ssize_t uart_get_attr_iomem_base(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        struct serial_struct tmp;
+        struct tty_port *port = dev_get_drvdata(dev);
+
+        uart_get_info(port, &tmp);
+        return snprintf(buf, PAGE_SIZE, "0x%lX\n", (unsigned long)tmp.iomem_base);
+}
+
+static ssize_t uart_get_attr_iomem_reg_shift(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        struct serial_struct tmp;
+        struct tty_port *port = dev_get_drvdata(dev);
+
+        uart_get_info(port, &tmp);
+        return snprintf(buf, PAGE_SIZE, "%d\n", tmp.iomem_reg_shift);
+}
+
+static DEVICE_ATTR(type, S_IRUSR | S_IRGRP, uart_get_attr_type, NULL);
+static DEVICE_ATTR(line, S_IRUSR | S_IRGRP, uart_get_attr_line, NULL);
+static DEVICE_ATTR(port, S_IRUSR | S_IRGRP, uart_get_attr_port, NULL);
+static DEVICE_ATTR(irq, S_IRUSR | S_IRGRP, uart_get_attr_irq, NULL);
+static DEVICE_ATTR(flags, S_IRUSR | S_IRGRP, uart_get_attr_flags, NULL);
+static DEVICE_ATTR(xmit_fifo_size, S_IRUSR | S_IRGRP, uart_get_attr_xmit_fifo_size, NULL);
 static DEVICE_ATTR(uartclk, S_IRUSR | S_IRGRP, uart_get_attr_uartclk, NULL);
+static DEVICE_ATTR(close_delay, S_IRUSR | S_IRGRP, uart_get_attr_close_delay, NULL);
+static DEVICE_ATTR(closing_wait, S_IRUSR | S_IRGRP, uart_get_attr_closing_wait, NULL);
+static DEVICE_ATTR(custom_divisor, S_IRUSR | S_IRGRP, uart_get_attr_custom_divisor, NULL);
+static DEVICE_ATTR(io_type, S_IRUSR | S_IRGRP, uart_get_attr_io_type, NULL);
+static DEVICE_ATTR(iomem_base, S_IRUSR | S_IRGRP, uart_get_attr_iomem_base, NULL);
+static DEVICE_ATTR(iomem_reg_shift, S_IRUSR | S_IRGRP, uart_get_attr_iomem_reg_shift, NULL);
 
 static struct attribute *tty_dev_attrs[] = {
+        &dev_attr_type.attr,
+        &dev_attr_line.attr,
+        &dev_attr_port.attr,
+        &dev_attr_irq.attr,
+        &dev_attr_flags.attr,
+        &dev_attr_xmit_fifo_size.attr,
         &dev_attr_uartclk.attr,
+        &dev_attr_close_delay.attr,
+        &dev_attr_closing_wait.attr,
+        &dev_attr_custom_divisor.attr,
+        &dev_attr_io_type.attr,
+        &dev_attr_iomem_base.attr,
+        &dev_attr_iomem_reg_shift.attr,
         NULL,
         };
 
@@ -2356,6 +2554,7 @@ static const struct attribute_group *tty_dev_attr_groups[] = {
         NULL
         };
 
+
 /**
  *      uart_add_one_port - attach a driver-defined port structure
  *      @drv: pointer to the uart low level driver structure for this port