Merge with /pub/scm/linux/kernel/git/torvalds/linux-2.6.git

Signed-off-by: Steve French <sfrench@us.ibm.com>

1 files changed, 153 insertions, 74 deletions

diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index 1b4751412970..b9fd39fd1b5b 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -6,6 +6,7 @@
  * Copyright (c) 1999 Johannes Erdfelt  <johannes@erdfelt.com>
  * Copyright (c) 2000 Vojtech Pavlik    <vojtech@suse.cz>
  * Copyright (c) 2004 Oliver Neukum     <oliver@neukum.name>
+ * Copyright (c) 2005 David Kubicek     <dave@awk.cz>
  *
  * USB Abstract Control Model driver for USB modems and ISDN adapters
  *
@@ -29,6 +30,7 @@
  *              config we want, sysadmin changes bConfigurationValue in sysfs.
  *      v0.23 - use softirq for rx processing, as needed by tty layer
  *      v0.24 - change probe method to evaluate CDC union descriptor
+ *      v0.25 - downstream tasks paralelized to maximize throughput
  */
 
 /*
@@ -63,14 +65,15 @@
 #include <linux/usb_cdc.h>
 #include <asm/byteorder.h>
 #include <asm/unaligned.h>
+#include <linux/list.h>
 
 #include "cdc-acm.h"
 
 /*
  * Version Information
  */
-#define DRIVER_VERSION "v0.23"
-#define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik"
+#define DRIVER_VERSION "v0.25"
+#define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
 
 static struct usb_driver acm_driver;
@@ -284,7 +287,9 @@ exit:
 /* data interface returns incoming bytes, or we got unthrottled */
 static void acm_read_bulk(struct urb *urb, struct pt_regs *regs)
 {
-        struct acm *acm = urb->context;
+        struct acm_rb *buf;
+        struct acm_ru *rcv = urb->context;
+        struct acm *acm = rcv->instance;
         dbg("Entering acm_read_bulk with status %d\n", urb->status);
 
         if (!ACM_READY(acm))
@@ -293,49 +298,104 @@ static void acm_read_bulk(struct urb *urb, struct pt_regs *regs)
         if (urb->status)
                 dev_dbg(&acm->data->dev, "bulk rx status %d\n", urb->status);
 
-        /* calling tty_flip_buffer_push() in_irq() isn't allowed */
-        tasklet_schedule(&acm->bh);
+        buf = rcv->buffer;
+        buf->size = urb->actual_length;
+
+        spin_lock(&acm->read_lock);
+        list_add_tail(&rcv->list, &acm->spare_read_urbs);
+        list_add_tail(&buf->list, &acm->filled_read_bufs);
+        spin_unlock(&acm->read_lock);
+
+        tasklet_schedule(&acm->urb_task);
 }
 
 static void acm_rx_tasklet(unsigned long _acm)
 {
         struct acm *acm = (void *)_acm;
-        struct urb *urb = acm->readurb;
+        struct acm_rb *buf;
         struct tty_struct *tty = acm->tty;
-        unsigned char *data = urb->transfer_buffer;
+        struct acm_ru *rcv;
+        //unsigned long flags;
         int i = 0;
         dbg("Entering acm_rx_tasklet");
 
-        if (urb->actual_length > 0 && !acm->throttle)  {
-                for (i = 0; i < urb->actual_length && !acm->throttle; i++) {
-                        /* if we insert more than TTY_FLIPBUF_SIZE characters,
-                         * we drop them. */
-                        if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                                tty_flip_buffer_push(tty);
-                        }
-                        tty_insert_flip_char(tty, data[i], 0);
-                }
-                dbg("Handed %d bytes to tty layer", i+1);
-                tty_flip_buffer_push(tty);
+        if (!ACM_READY(acm) || acm->throttle)
+                return;
+
+next_buffer:
+        spin_lock(&acm->read_lock);
+        if (list_empty(&acm->filled_read_bufs)) {
+                spin_unlock(&acm->read_lock);
+                goto urbs;
         }
+        buf = list_entry(acm->filled_read_bufs.next,
+                         struct acm_rb, list);
+        list_del(&buf->list);
+        spin_unlock(&acm->read_lock);
+
+        dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d\n", buf, buf->size);
+
+        tty_buffer_request_room(tty, buf->size);
+        if (!acm->throttle)
+                tty_insert_flip_string(tty, buf->base, buf->size);
+        tty_flip_buffer_push(tty);
 
         spin_lock(&acm->throttle_lock);
         if (acm->throttle) {
                 dbg("Throtteling noticed");
-                memmove(data, data + i, urb->actual_length - i);
-                urb->actual_length -= i;
-                acm->resubmit_to_unthrottle = 1;
+                memmove(buf->base, buf->base + i, buf->size - i);
+                buf->size -= i;
                 spin_unlock(&acm->throttle_lock);
+                spin_lock(&acm->read_lock);
+                list_add(&buf->list, &acm->filled_read_bufs);
+                spin_unlock(&acm->read_lock);
                 return;
         }
         spin_unlock(&acm->throttle_lock);
 
-        urb->actual_length = 0;
-        urb->dev = acm->dev;
-
-        i = usb_submit_urb(urb, GFP_ATOMIC);
-        if (i)
-                dev_dbg(&acm->data->dev, "bulk rx resubmit %d\n", i);
+        spin_lock(&acm->read_lock);
+        list_add(&buf->list, &acm->spare_read_bufs);
+        spin_unlock(&acm->read_lock);
+        goto next_buffer;
+
+urbs:
+        while (!list_empty(&acm->spare_read_bufs)) {
+                spin_lock(&acm->read_lock);
+                if (list_empty(&acm->spare_read_urbs)) {
+                        spin_unlock(&acm->read_lock);
+                        return;
+                }
+                rcv = list_entry(acm->spare_read_urbs.next,
+                                 struct acm_ru, list);
+                list_del(&rcv->list);
+                spin_unlock(&acm->read_lock);
+
+                buf = list_entry(acm->spare_read_bufs.next,
+                                 struct acm_rb, list);
+                list_del(&buf->list);
+
+                rcv->buffer = buf;
+
+                usb_fill_bulk_urb(rcv->urb, acm->dev,
+                                  acm->rx_endpoint,
+                                  buf->base,
+                                  acm->readsize,
+                                  acm_read_bulk, rcv);
+                rcv->urb->transfer_dma = buf->dma;
+                rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+
+                dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p\n", rcv->urb, rcv, buf);
+
+                /* This shouldn't kill the driver as unsuccessful URBs are returned to the
+                   free-urbs-pool and resubmited ASAP */
+                if (usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
+                        list_add(&buf->list, &acm->spare_read_bufs);
+                        spin_lock(&acm->read_lock);
+                        list_add(&rcv->list, &acm->spare_read_urbs);
+                        spin_unlock(&acm->read_lock);
+                        return;
+                }
+        }
 }
 
 /* data interface wrote those outgoing bytes */
@@ -369,6 +429,7 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 {
         struct acm *acm;
         int rv = -EINVAL;
+        int i;
         dbg("Entering acm_tty_open.\n");
         
         down(&open_sem);
@@ -382,7 +443,9 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp)
         tty->driver_data = acm;
         acm->tty = tty;
 
-
+        /* force low_latency on so that our tty_push actually forces the data through,
+           otherwise it is scheduled, and with high data rates data can get lost. */
+        tty->low_latency = 1;
 
         if (acm->used++) {
                 goto done;
@@ -394,18 +457,20 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp)
                 goto bail_out;
         }
 
-        acm->readurb->dev = acm->dev;
-        if (usb_submit_urb(acm->readurb, GFP_KERNEL)) {
-                dbg("usb_submit_urb(read bulk) failed");
-                goto bail_out_and_unlink;
-        }
-
         if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS))
                 goto full_bailout;
 
-        /* force low_latency on so that our tty_push actually forces the data through, 
-           otherwise it is scheduled, and with high data rates data can get lost. */
-        tty->low_latency = 1;
+        INIT_LIST_HEAD(&acm->spare_read_urbs);
+        INIT_LIST_HEAD(&acm->spare_read_bufs);
+        INIT_LIST_HEAD(&acm->filled_read_bufs);
+        for (i = 0; i < ACM_NRU; i++) {
+                list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
+        }
+        for (i = 0; i < ACM_NRB; i++) {
+                list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
+        }
+
+        tasklet_schedule(&acm->urb_task);
 
 done:
 err_out:
@@ -413,8 +478,6 @@ err_out:
         return rv;
 
 full_bailout:
-        usb_kill_urb(acm->readurb);
-bail_out_and_unlink:
         usb_kill_urb(acm->ctrlurb);
 bail_out:
         acm->used--;
@@ -424,18 +487,22 @@ bail_out:
 
 static void acm_tty_unregister(struct acm *acm)
 {
+        int i;
+
         tty_unregister_device(acm_tty_driver, acm->minor);
         usb_put_intf(acm->control);
         acm_table[acm->minor] = NULL;
         usb_free_urb(acm->ctrlurb);
-        usb_free_urb(acm->readurb);
         usb_free_urb(acm->writeurb);
+        for (i = 0; i < ACM_NRU; i++)
+                usb_free_urb(acm->ru[i].urb);
         kfree(acm);
 }
 
 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
 {
         struct acm *acm = tty->driver_data;
+        int i;
 
         if (!acm || !acm->used)
                 return;
@@ -446,7 +513,8 @@ static void acm_tty_close(struct tty_struct *tty, struct file *filp)
                         acm_set_control(acm, acm->ctrlout = 0);
                         usb_kill_urb(acm->ctrlurb);
                         usb_kill_urb(acm->writeurb);
-                        usb_kill_urb(acm->readurb);
+                        for (i = 0; i < ACM_NRU; i++)
+                                usb_kill_urb(acm->ru[i].urb);
                 } else
                         acm_tty_unregister(acm);
         }
@@ -528,10 +596,7 @@ static void acm_tty_unthrottle(struct tty_struct *tty)
         spin_lock_bh(&acm->throttle_lock);
         acm->throttle = 0;
         spin_unlock_bh(&acm->throttle_lock);
-        if (acm->resubmit_to_unthrottle) {
-                acm->resubmit_to_unthrottle = 0;
-                acm_read_bulk(acm->readurb, NULL);
-        }
+        tasklet_schedule(&acm->urb_task);
 }
 
 static void acm_tty_break_ctl(struct tty_struct *tty, int state)
@@ -588,7 +653,7 @@ static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int
         return -ENOIOCTLCMD;
 }
 
-static __u32 acm_tty_speed[] = {
+static const __u32 acm_tty_speed[] = {
         0, 50, 75, 110, 134, 150, 200, 300, 600,
         1200, 1800, 2400, 4800, 9600, 19200, 38400,
         57600, 115200, 230400, 460800, 500000, 576000,
@@ -596,7 +661,7 @@ static __u32 acm_tty_speed[] = {
         2500000, 3000000, 3500000, 4000000
 };
 
-static __u8 acm_tty_size[] = {
+static const __u8 acm_tty_size[] = {
         5, 6, 7, 8
 };
 
@@ -694,6 +759,7 @@ static int acm_probe (struct usb_interface *intf,
         int call_interface_num = -1;
         int data_interface_num;
         unsigned long quirks;
+        int i;
 
         /* handle quirks deadly to normal probing*/
         quirks = (unsigned long)id->driver_info;
@@ -833,7 +899,7 @@ skip_normal_probe:
         }
 
         ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
-        readsize = le16_to_cpu(epread->wMaxPacketSize);
+        readsize = le16_to_cpu(epread->wMaxPacketSize)*2;
         acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize);
         acm->control = control_interface;
         acm->data = data_interface;
@@ -842,12 +908,14 @@ skip_normal_probe:
         acm->ctrl_caps = ac_management_function;
         acm->ctrlsize = ctrlsize;
         acm->readsize = readsize;
-        acm->bh.func = acm_rx_tasklet;
-        acm->bh.data = (unsigned long) acm;
+        acm->urb_task.func = acm_rx_tasklet;
+        acm->urb_task.data = (unsigned long) acm;
         INIT_WORK(&acm->work, acm_softint, acm);
         spin_lock_init(&acm->throttle_lock);
         spin_lock_init(&acm->write_lock);
+        spin_lock_init(&acm->read_lock);
         acm->write_ready = 1;
+        acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
 
         buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
         if (!buf) {
@@ -856,13 +924,6 @@ skip_normal_probe:
         }
         acm->ctrl_buffer = buf;
 
-        buf = usb_buffer_alloc(usb_dev, readsize, GFP_KERNEL, &acm->read_dma);
-        if (!buf) {
-                dev_dbg(&intf->dev, "out of memory (read buffer alloc)\n");
-                goto alloc_fail3;
-        }
-        acm->read_buffer = buf;
-
         if (acm_write_buffers_alloc(acm) < 0) {
                 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
                 goto alloc_fail4;
@@ -873,10 +934,25 @@ skip_normal_probe:
                 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
                 goto alloc_fail5;
         }
-        acm->readurb = usb_alloc_urb(0, GFP_KERNEL);
-        if (!acm->readurb) {
-                dev_dbg(&intf->dev, "out of memory (readurb kmalloc)\n");
-                goto alloc_fail6;
+        for (i = 0; i < ACM_NRU; i++) {
+                struct acm_ru *rcv = &(acm->ru[i]);
+
+                if (!(rcv->urb = usb_alloc_urb(0, GFP_KERNEL))) {
+                        dev_dbg(&intf->dev, "out of memory (read urbs usb_alloc_urb)\n");
+                        goto alloc_fail7;
+                }
+
+                rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+                rcv->instance = acm;
+        }
+        for (i = 0; i < ACM_NRB; i++) {
+                struct acm_rb *buf = &(acm->rb[i]);
+
+                // Using usb_buffer_alloc instead of kmalloc as Oliver suggested
+                if (!(buf->base = usb_buffer_alloc(acm->dev, readsize, GFP_KERNEL, &buf->dma))) {
+                        dev_dbg(&intf->dev, "out of memory (read bufs usb_buffer_alloc)\n");
+                        goto alloc_fail7;
+                }
         }
         acm->writeurb = usb_alloc_urb(0, GFP_KERNEL);
         if (!acm->writeurb) {
@@ -889,15 +965,9 @@ skip_normal_probe:
         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
 
-        usb_fill_bulk_urb(acm->readurb, usb_dev, usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress),
-                          acm->read_buffer, readsize, acm_read_bulk, acm);
-        acm->readurb->transfer_flags |= URB_NO_FSBR | URB_NO_TRANSFER_DMA_MAP;
-        acm->readurb->transfer_dma = acm->read_dma;
-
         usb_fill_bulk_urb(acm->writeurb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
                           NULL, acm->writesize, acm_write_bulk, acm);
         acm->writeurb->transfer_flags |= URB_NO_FSBR | URB_NO_TRANSFER_DMA_MAP;
-        /* acm->writeurb->transfer_dma = 0; */
 
         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
 
@@ -917,14 +987,14 @@ skip_normal_probe:
         return 0;
 
 alloc_fail7:
-        usb_free_urb(acm->readurb);
-alloc_fail6:
+        for (i = 0; i < ACM_NRB; i++)
+                usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
+        for (i = 0; i < ACM_NRU; i++)
+                usb_free_urb(acm->ru[i].urb);
         usb_free_urb(acm->ctrlurb);
 alloc_fail5:
         acm_write_buffers_free(acm);
 alloc_fail4:
-        usb_buffer_free(usb_dev, readsize, acm->read_buffer, acm->read_dma);
-alloc_fail3:
         usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
 alloc_fail2:
         kfree(acm);
@@ -936,6 +1006,7 @@ static void acm_disconnect(struct usb_interface *intf)
 {
         struct acm *acm = usb_get_intfdata (intf);
         struct usb_device *usb_dev = interface_to_usbdev(intf);
+        int i;
 
         if (!acm || !acm->dev) {
                 dbg("disconnect on nonexisting interface");
@@ -946,15 +1017,24 @@ static void acm_disconnect(struct usb_interface *intf)
         acm->dev = NULL;
         usb_set_intfdata (intf, NULL);
 
+        tasklet_disable(&acm->urb_task);
+
         usb_kill_urb(acm->ctrlurb);
-        usb_kill_urb(acm->readurb);
         usb_kill_urb(acm->writeurb);
+        for (i = 0; i < ACM_NRU; i++)
+                usb_kill_urb(acm->ru[i].urb);
+
+        INIT_LIST_HEAD(&acm->filled_read_bufs);
+        INIT_LIST_HEAD(&acm->spare_read_bufs);
+
+        tasklet_enable(&acm->urb_task);
 
         flush_scheduled_work(); /* wait for acm_softint */
 
         acm_write_buffers_free(acm);
-        usb_buffer_free(usb_dev, acm->readsize, acm->read_buffer, acm->read_dma);
         usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
+        for (i = 0; i < ACM_NRB; i++)
+                usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
 
         usb_driver_release_interface(&acm_driver, acm->data);
 
@@ -1003,7 +1083,6 @@ static struct usb_device_id acm_ids[] = {
 MODULE_DEVICE_TABLE (usb, acm_ids);
 
 static struct usb_driver acm_driver = {
-        .owner =        THIS_MODULE,
         .name =         "cdc_acm",
         .probe =        acm_probe,
         .disconnect =   acm_disconnect,