1 files changed, 75 insertions, 30 deletions

diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 5fc13e717911..bd4298bb6750 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -73,6 +73,7 @@ struct ftdi_private {
                                  */
         int flags;              /* some ASYNC_xxxx flags are supported */
         unsigned long last_dtr_rts;     /* saved modem control outputs */
+        struct async_icount     icount;
         wait_queue_head_t delta_msr_wait; /* Used for TIOCMIWAIT */
         char prev_status, diff_status;        /* Used for TIOCMIWAIT */
         char transmit_empty;    /* If transmitter is empty or not */
@@ -207,6 +208,8 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_XF_640_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_XF_642_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_DSS20_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_URBAN_0_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_URBAN_1_PID) },
         { USB_DEVICE(FTDI_NF_RIC_VID, FTDI_NF_RIC_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_VNHCPCUSB_D_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_MTXORB_0_PID) },
@@ -745,6 +748,8 @@ static struct usb_device_id id_table_combined [] = {
                 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
         { USB_DEVICE(FTDI_VID, LMI_LM3S_EVAL_BOARD_PID),
                 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
+        { USB_DEVICE(FTDI_VID, LMI_LM3S_ICDI_BOARD_PID),
+                .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
         { USB_DEVICE(FTDI_VID, FTDI_TURTELIZER_PID),
                 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
         { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID_USB60F) },
@@ -885,6 +890,8 @@ static void ftdi_set_termios(struct tty_struct *tty,
 static int  ftdi_tiocmget(struct tty_struct *tty);
 static int  ftdi_tiocmset(struct tty_struct *tty,
                         unsigned int set, unsigned int clear);
+static int ftdi_get_icount(struct tty_struct *tty,
+                           struct serial_icounter_struct *icount);
 static int  ftdi_ioctl(struct tty_struct *tty,
                         unsigned int cmd, unsigned long arg);
 static void ftdi_break_ctl(struct tty_struct *tty, int break_state);
@@ -919,6 +926,7 @@ static struct usb_serial_driver ftdi_sio_device = {
         .prepare_write_buffer = ftdi_prepare_write_buffer,
         .tiocmget =             ftdi_tiocmget,
         .tiocmset =             ftdi_tiocmset,
+        .get_icount =           ftdi_get_icount,
         .ioctl =                ftdi_ioctl,
         .set_termios =          ftdi_set_termios,
         .break_ctl =            ftdi_break_ctl,
@@ -1486,7 +1494,7 @@ static void ftdi_set_max_packet_size(struct usb_serial_port *port)
         }
 
         /* set max packet size based on descriptor */
-        priv->max_packet_size = le16_to_cpu(ep_desc->wMaxPacketSize);
+        priv->max_packet_size = usb_endpoint_maxp(ep_desc);
 
         dev_info(&udev->dev, "Setting MaxPacketSize %d\n", priv->max_packet_size);
 }
@@ -1646,6 +1654,7 @@ static int ftdi_sio_port_probe(struct usb_serial_port *port)
 
         kref_init(&priv->kref);
         mutex_init(&priv->cfg_lock);
+        memset(&priv->icount, 0x00, sizeof(priv->icount));
         init_waitqueue_head(&priv->delta_msr_wait);
 
         priv->flags = ASYNC_LOW_LATENCY;
@@ -1909,6 +1918,7 @@ static int ftdi_prepare_write_buffer(struct usb_serial_port *port,
                         c = kfifo_out(&port->write_fifo, &buffer[i + 1], len);
                         if (!c)
                                 break;
+                        priv->icount.tx += c;
                         buffer[i] = (c << 2) + 1;
                         count += c + 1;
                 }
@@ -1916,6 +1926,7 @@ static int ftdi_prepare_write_buffer(struct usb_serial_port *port,
         } else {
                 count = kfifo_out_locked(&port->write_fifo, dest, size,
                                                                 &port->lock);
+                priv->icount.tx += count;
         }
 
         return count;
@@ -1943,6 +1954,14 @@ static int ftdi_process_packet(struct tty_struct *tty,
            N.B. packet may be processed more than once, but differences
            are only processed once.  */
         status = packet[0] & FTDI_STATUS_B0_MASK;
+        if (status & FTDI_RS0_CTS)
+                priv->icount.cts++;
+        if (status & FTDI_RS0_DSR)
+                priv->icount.dsr++;
+        if (status & FTDI_RS0_RI)
+                priv->icount.rng++;
+        if (status & FTDI_RS0_RLSD)
+                priv->icount.dcd++;
         if (status != priv->prev_status) {
                 priv->diff_status |= status ^ priv->prev_status;
                 wake_up_interruptible(&priv->delta_msr_wait);
@@ -1955,15 +1974,20 @@ static int ftdi_process_packet(struct tty_struct *tty,
                  * over framing errors */
                 if (packet[1] & FTDI_RS_BI) {
                         flag = TTY_BREAK;
+                        priv->icount.brk++;
                         usb_serial_handle_break(port);
                 } else if (packet[1] & FTDI_RS_PE) {
                         flag = TTY_PARITY;
+                        priv->icount.parity++;
                 } else if (packet[1] & FTDI_RS_FE) {
                         flag = TTY_FRAME;
+                        priv->icount.frame++;
                 }
                 /* Overrun is special, not associated with a char */
-                if (packet[1] & FTDI_RS_OE)
+                if (packet[1] & FTDI_RS_OE) {
+                        priv->icount.overrun++;
                         tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                }
         }
 
         /* save if the transmitter is empty or not */
@@ -1975,6 +1999,7 @@ static int ftdi_process_packet(struct tty_struct *tty,
         len -= 2;
         if (!len)
                 return 0;       /* status only */
+        priv->icount.rx += len;
         ch = packet + 2;
 
         if (port->port.console && port->sysrq) {
@@ -2079,13 +2104,19 @@ static void ftdi_set_termios(struct tty_struct *tty,
 
         cflag = termios->c_cflag;
 
-        /* FIXME -For this cut I don't care if the line is really changing or
-           not  - so just do the change regardless  - should be able to
-           compare old_termios and tty->termios */
+        if (old_termios->c_cflag == termios->c_cflag
+            && old_termios->c_ispeed == termios->c_ispeed
+            && old_termios->c_ospeed == termios->c_ospeed)
+                goto no_c_cflag_changes;
+
         /* NOTE These routines can get interrupted by
            ftdi_sio_read_bulk_callback  - need to examine what this means -
            don't see any problems yet */
 
+        if ((old_termios->c_cflag & (CSIZE|PARODD|PARENB|CMSPAR|CSTOPB)) ==
+            (termios->c_cflag & (CSIZE|PARODD|PARENB|CMSPAR|CSTOPB)))
+                goto no_data_parity_stop_changes;
+
         /* Set number of data bits, parity, stop bits */
 
         urb_value = 0;
@@ -2126,6 +2157,7 @@ static void ftdi_set_termios(struct tty_struct *tty,
         }
 
         /* Now do the baudrate */
+no_data_parity_stop_changes:
         if ((cflag & CBAUD) == B0) {
                 /* Disable flow control */
                 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
@@ -2153,6 +2185,7 @@ static void ftdi_set_termios(struct tty_struct *tty,
 
         /* Set flow control */
         /* Note device also supports DTR/CD (ugh) and Xon/Xoff in hardware */
+no_c_cflag_changes:
         if (cflag & CRTSCTS) {
                 dbg("%s Setting to CRTSCTS flow control", __func__);
                 if (usb_control_msg(dev,
@@ -2277,11 +2310,34 @@ static int ftdi_tiocmset(struct tty_struct *tty,
         return update_mctrl(port, set, clear);
 }
 
+static int ftdi_get_icount(struct tty_struct *tty,
+                                struct serial_icounter_struct *icount)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct ftdi_private *priv = usb_get_serial_port_data(port);
+        struct async_icount *ic = &priv->icount;
+
+        icount->cts = ic->cts;
+        icount->dsr = ic->dsr;
+        icount->rng = ic->rng;
+        icount->dcd = ic->dcd;
+        icount->tx = ic->tx;
+        icount->rx = ic->rx;
+        icount->frame = ic->frame;
+        icount->parity = ic->parity;
+        icount->overrun = ic->overrun;
+        icount->brk = ic->brk;
+        icount->buf_overrun = ic->buf_overrun;
+        return 0;
+}
+
 static int ftdi_ioctl(struct tty_struct *tty,
                                         unsigned int cmd, unsigned long arg)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct ftdi_private *priv = usb_get_serial_port_data(port);
+        struct async_icount cnow;
+        struct async_icount cprev;
 
         dbg("%s cmd 0x%04x", __func__, cmd);
 
@@ -2301,41 +2357,30 @@ static int ftdi_ioctl(struct tty_struct *tty,
          * - mask passed in arg for lines of interest
          *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
          * Caller should use TIOCGICOUNT to see which one it was.
-         * (except that the driver doesn't support it !)
          *
          * This code is borrowed from linux/drivers/char/serial.c
          */
         case TIOCMIWAIT:
-                while (priv != NULL) {
+                cprev = priv->icount;
+                while (1) {
                         interruptible_sleep_on(&priv->delta_msr_wait);
                         /* see if a signal did it */
                         if (signal_pending(current))
                                 return -ERESTARTSYS;
-                        else {
-                                char diff = priv->diff_status;
-
-                                if (diff == 0)
-                                        return -EIO; /* no change => error */
-
-                                /* Consume all events */
-                                priv->diff_status = 0;
-
-                                /* Return 0 if caller wanted to know about
-                                   these bits */
-                                if (((arg & TIOCM_RNG) && (diff & FTDI_RS0_RI)) ||
-                                    ((arg & TIOCM_DSR) && (diff & FTDI_RS0_DSR)) ||
-                                    ((arg & TIOCM_CD)  && (diff & FTDI_RS0_RLSD)) ||
-                                    ((arg & TIOCM_CTS) && (diff & FTDI_RS0_CTS))) {
-                                        return 0;
-                                }
-                                /*
-                                 * Otherwise caller can't care less about what
-                                 * happened,and so we continue to wait for more
-                                 * events.
-                                 */
+                        cnow = priv->icount;
+                        if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
+                            cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
+                                return -EIO; /* no change => error */
+                        if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
+                            ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
+                            ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
+                            ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
+                                return 0;
                         }
+                        cprev = cnow;
                 }
-                return 0;
+                /* not reached */
+                break;
         case TIOCSERGETLSR:
                 return get_lsr_info(port, (struct serial_struct __user *)arg);
                 break;