USB: use kfifo to buffer usb-generic serial writes

When do_output_char() attempts to write a carriage return/line feed sequence,
it first checks to see how much buffer room is available. If there are at least
two characters free, it will write the carriage return/line feed with two calls
to tty_put_char(). It calls the tty_operation functions write() for devices that
don't support the tty_operations function put_char(). If the USB generic serial
device's write URB is not in use, it will return the buffer size when asked how
much room is available. The write() of the carriage return will cause it to mark
the write URB busy, so the subsequent write() of the line feed will be ignored.

This patch uses the kfifo infrastructure to implement a write FIFO that
accurately returns the amount of space available in the buffer.

Signed-off-by: David VomLehn <dvomlehn@cisco.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

3 files changed, 134 insertions, 81 deletions

diff --git a/drivers/usb/serial/generic.c b/drivers/usb/serial/generic.c
index d9398e9f30ce..deba08c7a015 100644
--- a/drivers/usb/serial/generic.c
+++ b/drivers/usb/serial/generic.c
@@ -19,7 +19,7 @@
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 #include <linux/uaccess.h>
-
+#include <linux/kfifo.h>
 
 static int debug;
 
@@ -166,24 +166,6 @@ static void generic_cleanup(struct usb_serial_port *port)
         }
 }
 
-int usb_serial_generic_resume(struct usb_serial *serial)
-{
-        struct usb_serial_port *port;
-        int i, c = 0, r;
-
-        for (i = 0; i < serial->num_ports; i++) {
-                port = serial->port[i];
-                if (port->port.count && port->read_urb) {
-                        r = usb_submit_urb(port->read_urb, GFP_NOIO);
-                        if (r < 0)
-                                c++;
-                }
-        }
-
-        return c ? -EIO : 0;
-}
-EXPORT_SYMBOL_GPL(usb_serial_generic_resume);
-
 void usb_serial_generic_close(struct usb_serial_port *port)
 {
         dbg("%s - port %d", __func__, port->number);
@@ -272,12 +254,81 @@ error_no_buffer:
         return bwrite;
 }
 
+/**
+ * usb_serial_generic_write_start - kick off an URB write
+ * @port:       Pointer to the &struct usb_serial_port data
+ *
+ * Returns the number of bytes queued on success. This will be zero if there
+ * was nothing to send. Otherwise, it returns a negative errno value
+ */
+static int usb_serial_generic_write_start(struct usb_serial_port *port)
+{
+        struct usb_serial *serial = port->serial;
+        unsigned char *data;
+        int result;
+        int count;
+        unsigned long flags;
+        bool start_io;
+
+        /* Atomically determine whether we can and need to start a USB
+         * operation. */
+        spin_lock_irqsave(&port->lock, flags);
+        if (port->write_urb_busy)
+                start_io = false;
+        else {
+                start_io = (__kfifo_len(port->write_fifo) != 0);
+                port->write_urb_busy = start_io;
+        }
+        spin_unlock_irqrestore(&port->lock, flags);
+
+        if (!start_io)
+                return 0;
+
+        data = port->write_urb->transfer_buffer;
+        count = kfifo_get(port->write_fifo, data, port->bulk_out_size);
+        usb_serial_debug_data(debug, &port->dev, __func__, count, data);
+
+        /* set up our urb */
+        usb_fill_bulk_urb(port->write_urb, serial->dev,
+                           usb_sndbulkpipe(serial->dev,
+                                port->bulk_out_endpointAddress),
+                           port->write_urb->transfer_buffer, count,
+                           ((serial->type->write_bulk_callback) ?
+                             serial->type->write_bulk_callback :
+                             usb_serial_generic_write_bulk_callback),
+                           port);
+
+        /* send the data out the bulk port */
+        result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
+        if (result) {
+                dev_err(&port->dev,
+                        "%s - failed submitting write urb, error %d\n",
+                                                __func__, result);
+                /* don't have to grab the lock here, as we will
+                   retry if != 0 */
+                port->write_urb_busy = 0;
+        } else
+                result = count;
+
+        return result;
+}
+
+/**
+ * usb_serial_generic_write - generic write function for serial USB devices
+ * @tty:        Pointer to &struct tty_struct for the device
+ * @port:       Pointer to the &usb_serial_port structure for the device
+ * @buf:        Pointer to the data to write
+ * @count:      Number of bytes to write
+ *
+ * Returns the number of characters actually written, which may be anything
+ * from zero to @count. If an error occurs, it returns the negative errno
+ * value.
+ */
 int usb_serial_generic_write(struct tty_struct *tty,
         struct usb_serial_port *port, const unsigned char *buf, int count)
 {
         struct usb_serial *serial = port->serial;
         int result;
-        unsigned char *data;
 
         dbg("%s - port %d", __func__, port->number);
 
@@ -287,57 +338,20 @@ int usb_serial_generic_write(struct tty_struct *tty,
         }
 
         /* only do something if we have a bulk out endpoint */
-        if (serial->num_bulk_out) {
-                unsigned long flags;
-
-                if (serial->type->max_in_flight_urbs)
-                        return usb_serial_multi_urb_write(tty, port,
-                                                          buf, count);
-
-                spin_lock_irqsave(&port->lock, flags);
-                if (port->write_urb_busy) {
-                        spin_unlock_irqrestore(&port->lock, flags);
-                        dbg("%s - already writing", __func__);
-                        return 0;
-                }
-                port->write_urb_busy = 1;
-                spin_unlock_irqrestore(&port->lock, flags);
-
-                count = (count > port->bulk_out_size) ?
-                                        port->bulk_out_size : count;
-
-                memcpy(port->write_urb->transfer_buffer, buf, count);
-                data = port->write_urb->transfer_buffer;
-                usb_serial_debug_data(debug, &port->dev, __func__, count, data);
+        if (!serial->num_bulk_out)
+                return 0;
 
-                /* set up our urb */
-                usb_fill_bulk_urb(port->write_urb, serial->dev,
-                                   usb_sndbulkpipe(serial->dev,
-                                        port->bulk_out_endpointAddress),
-                                   port->write_urb->transfer_buffer, count,
-                                   ((serial->type->write_bulk_callback) ?
-                                     serial->type->write_bulk_callback :
-                                     usb_serial_generic_write_bulk_callback),
-                                   port);
+        if (serial->type->max_in_flight_urbs)
+                return usb_serial_multi_urb_write(tty, port,
+                                                  buf, count);
 
-                /* send the data out the bulk port */
-                port->write_urb_busy = 1;
-                result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
-                if (result) {
-                        dev_err(&port->dev,
-                                "%s - failed submitting write urb, error %d\n",
-                                                        __func__, result);
-                        /* don't have to grab the lock here, as we will
-                           retry if != 0 */
-                        port->write_urb_busy = 0;
-                } else
-                        result = count;
+        count = kfifo_put(port->write_fifo, buf, count);
+        result = usb_serial_generic_write_start(port);
 
-                return result;
-        }
+        if (result >= 0)
+                result = count;
 
-        /* no bulk out, so return 0 bytes written */
-        return 0;
+        return result;
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_write);
 
@@ -355,9 +369,8 @@ int usb_serial_generic_write_room(struct tty_struct *tty)
                         room = port->bulk_out_size *
                                 (serial->type->max_in_flight_urbs -
                                  port->urbs_in_flight);
-        } else if (serial->num_bulk_out && !(port->write_urb_busy)) {
-                room = port->bulk_out_size;
-        }
+        } else if (serial->num_bulk_out)
+                room = port->write_fifo->size - __kfifo_len(port->write_fifo);
         spin_unlock_irqrestore(&port->lock, flags);
 
         dbg("%s - returns %d", __func__, room);
@@ -377,11 +390,8 @@ int usb_serial_generic_chars_in_buffer(struct tty_struct *tty)
                 spin_lock_irqsave(&port->lock, flags);
                 chars = port->tx_bytes_flight;
                 spin_unlock_irqrestore(&port->lock, flags);
-        } else if (serial->num_bulk_out) {
-                /* FIXME: Locking */
-                if (port->write_urb_busy)
-                        chars = port->write_urb->transfer_buffer_length;
-        }
+        } else if (serial->num_bulk_out)
+                chars = kfifo_len(port->write_fifo);
 
         dbg("%s - returns %d", __func__, chars);
         return chars;
@@ -485,16 +495,23 @@ void usb_serial_generic_write_bulk_callback(struct urb *urb)
                 if (port->urbs_in_flight < 0)
                         port->urbs_in_flight = 0;
                 spin_unlock_irqrestore(&port->lock, flags);
+
+                if (status) {
+                        dbg("%s - nonzero multi-urb write bulk status "
+                                "received: %d", __func__, status);
+                        return;
+                }
         } else {
-                /* Handle the case for single urb mode */
                 port->write_urb_busy = 0;
-        }
 
-        if (status) {
-                dbg("%s - nonzero write bulk status received: %d",
-                    __func__, status);
-                return;
+                if (status) {
+                        dbg("%s - nonzero multi-urb write bulk status "
+                                "received: %d", __func__, status);
+                        kfifo_reset(port->write_fifo);
+                } else
+                        usb_serial_generic_write_start(port);
         }
+
         usb_serial_port_softint(port);
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_write_bulk_callback);
@@ -559,6 +576,33 @@ int usb_serial_handle_break(struct usb_serial_port *port)
 }
 EXPORT_SYMBOL_GPL(usb_serial_handle_break);
 
+int usb_serial_generic_resume(struct usb_serial *serial)
+{
+        struct usb_serial_port *port;
+        int i, c = 0, r;
+
+        for (i = 0; i < serial->num_ports; i++) {
+                port = serial->port[i];
+                if (!port->port.count)
+                        continue;
+
+                if (port->read_urb) {
+                        r = usb_submit_urb(port->read_urb, GFP_NOIO);
+                        if (r < 0)
+                                c++;
+                }
+
+                if (port->write_urb) {
+                        r = usb_serial_generic_write_start(port);
+                        if (r < 0)
+                                c++;
+                }
+        }
+
+        return c ? -EIO : 0;
+}
+EXPORT_SYMBOL_GPL(usb_serial_generic_resume);
+
 void usb_serial_generic_disconnect(struct usb_serial *serial)
 {
         int i;
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index 45975b4984ea..ff75a3589e7e 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -35,6 +35,7 @@
 #include <linux/serial.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
+#include <linux/kfifo.h>
 #include "pl2303.h"
 
 /*
@@ -625,6 +626,8 @@ static void port_release(struct device *dev)
         usb_free_urb(port->write_urb);
         usb_free_urb(port->interrupt_in_urb);
         usb_free_urb(port->interrupt_out_urb);
+        if (!IS_ERR(port->write_fifo) && port->write_fifo)
+                kfifo_free(port->write_fifo);
         kfree(port->bulk_in_buffer);
         kfree(port->bulk_out_buffer);
         kfree(port->interrupt_in_buffer);
@@ -964,6 +967,10 @@ int usb_serial_probe(struct usb_interface *interface,
                         dev_err(&interface->dev, "No free urbs available\n");
                         goto probe_error;
                 }
+                port->write_fifo = kfifo_alloc(PAGE_SIZE, GFP_KERNEL,
+                        &port->lock);
+                if (IS_ERR(port->write_fifo))
+                        goto probe_error;
                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
                 port->bulk_out_size = buffer_size;
                 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
diff --git a/include/linux/usb/serial.h b/include/linux/usb/serial.h
index 7b85e327af91..c17eb64d7213 100644
--- a/include/linux/usb/serial.h
+++ b/include/linux/usb/serial.h
@@ -59,6 +59,7 @@ enum port_dev_state {
  * @bulk_out_buffer: pointer to the bulk out buffer for this port.
  * @bulk_out_size: the size of the bulk_out_buffer, in bytes.
  * @write_urb: pointer to the bulk out struct urb for this port.
+ * @write_fifo: kfifo used to buffer outgoing data
  * @write_urb_busy: port`s writing status
  * @bulk_out_endpointAddress: endpoint address for the bulk out pipe for this
  *      port.
@@ -96,6 +97,7 @@ struct usb_serial_port {
         unsigned char           *bulk_out_buffer;
         int                     bulk_out_size;
         struct urb              *write_urb;
+        struct kfifo            *write_fifo;
         int                     write_urb_busy;
         __u8                    bulk_out_endpointAddress;