USB: serial: reimplement generic fifo-based writes

Reimplement fifo-based writes in the generic driver using a multiple
pre-allocated urb scheme.

In contrast to multi-urb writes, no allocations (of urbs or buffers) are
made during run-time and there is less pressure on the host stack
queues as currently only two urbs are used (implementation is generic
and can handle more than two urbs as well, though).

Initial tests using ftdi_sio show that the implementation achieves the
same (maximum) throughput at high baudrates as multi-urb writes. The CPU
usage is much lower than for multi-urb writes for small write requests
and only slightly higher for large (e.g. 2k) requests (due to extra copy
via fifo?).

Also outperforms multi-urb writes for small write requests on an
embedded arm-9 system, where multi-urb writes are CPU-bound at high
baudrates (perf reveals that a lot of time is spent in the host stack
enqueue function -- could perhaps be a bug as well).

Keeping the original write_urb, buffer and flag for now as there are
other drivers depending on them.

Signed-off-by: Johan Hovold <jhovold@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

1 files changed, 33 insertions, 0 deletions

diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index 8249fd8381fb..941c2d409f85 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -548,8 +548,12 @@ static void usb_serial_port_work(struct work_struct *work)
 
 static void kill_traffic(struct usb_serial_port *port)
 {
+        int i;
+
         usb_kill_urb(port->read_urb);
         usb_kill_urb(port->write_urb);
+        for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
+                usb_kill_urb(port->write_urbs[i]);
         /*
          * This is tricky.
          * Some drivers submit the read_urb in the
@@ -568,6 +572,7 @@ static void kill_traffic(struct usb_serial_port *port)
 static void port_release(struct device *dev)
 {
         struct usb_serial_port *port = to_usb_serial_port(dev);
+        int i;
 
         dbg ("%s - %s", __func__, dev_name(dev));
 
@@ -582,6 +587,10 @@ 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);
+        for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) {
+                usb_free_urb(port->write_urbs[i]);
+                kfree(port->bulk_out_buffers[i]);
+        }
         kfifo_free(&port->write_fifo);
         kfree(port->bulk_in_buffer);
         kfree(port->bulk_out_buffer);
@@ -920,6 +929,8 @@ int usb_serial_probe(struct usb_interface *interface,
         }
 
         for (i = 0; i < num_bulk_out; ++i) {
+                int j;
+
                 endpoint = bulk_out_endpoint[i];
                 port = serial->port[i];
                 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
@@ -945,6 +956,28 @@ int usb_serial_probe(struct usb_interface *interface,
                                         endpoint->bEndpointAddress),
                                 port->bulk_out_buffer, buffer_size,
                                 serial->type->write_bulk_callback, port);
+                for (j = 0; j < ARRAY_SIZE(port->write_urbs); ++j) {
+                        set_bit(j, &port->write_urbs_free);
+                        port->write_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
+                        if (!port->write_urbs[j]) {
+                                dev_err(&interface->dev,
+                                                "No free urbs available\n");
+                                goto probe_error;
+                        }
+                        port->bulk_out_buffers[j] = kmalloc(buffer_size,
+                                                                GFP_KERNEL);
+                        if (!port->bulk_out_buffers[j]) {
+                                dev_err(&interface->dev,
+                                        "Couldn't allocate bulk_out_buffer\n");
+                                goto probe_error;
+                        }
+                        usb_fill_bulk_urb(port->write_urbs[j], dev,
+                                        usb_sndbulkpipe(dev,
+                                                endpoint->bEndpointAddress),
+                                        port->bulk_out_buffers[j], buffer_size,
+                                        serial->type->write_bulk_callback,
+                                        port);
+                }
         }
 
         if (serial->type->read_int_callback) {