1 files changed, 50 insertions, 48 deletions

diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index cc274fdf2627..ce6c1a65a544 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -50,7 +50,7 @@ static struct usb_driver usb_serial_driver = {
         .disconnect =   usb_serial_disconnect,
         .suspend =      usb_serial_suspend,
         .resume =       usb_serial_resume,
-        .no_dynamic_id =        1,
+        .no_dynamic_id =        1,
         .supports_autosuspend = 1,
 };
 
@@ -260,6 +260,10 @@ static int serial_activate(struct tty_port *tport, struct tty_struct *tty)
         else
                 retval = port->serial->type->open(tty, port);
         mutex_unlock(&serial->disc_mutex);
+
+        if (retval < 0)
+                retval = usb_translate_errors(retval);
+
         return retval;
 }
 
@@ -360,7 +364,8 @@ static int serial_write(struct tty_struct *tty, const unsigned char *buf,
 
         /* pass on to the driver specific version of this function */
         retval = port->serial->type->write(tty, port, buf, count);
-
+        if (retval < 0)
+                retval = usb_translate_errors(retval);
 exit:
         return retval;
 }
@@ -562,8 +567,8 @@ 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->read_urbs); ++i)
+                usb_kill_urb(port->read_urbs[i]);
         for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
                 usb_kill_urb(port->write_urbs[i]);
         /*
@@ -595,17 +600,17 @@ static void port_release(struct device *dev)
         kill_traffic(port);
         cancel_work_sync(&port->work);
 
-        usb_free_urb(port->read_urb);
-        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->read_urbs); ++i) {
+                usb_free_urb(port->read_urbs[i]);
+                kfree(port->bulk_in_buffers[i]);
+        }
         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);
         kfree(port->interrupt_in_buffer);
         kfree(port->interrupt_out_buffer);
         kfree(port);
@@ -686,16 +691,18 @@ static int serial_carrier_raised(struct tty_port *port)
 {
         struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
         struct usb_serial_driver *drv = p->serial->type;
+
         if (drv->carrier_raised)
                 return drv->carrier_raised(p);
         /* No carrier control - don't block */
-        return 1;       
+        return 1;
 }
 
 static void serial_dtr_rts(struct tty_port *port, int on)
 {
         struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
         struct usb_serial_driver *drv = p->serial->type;
+
         if (drv->dtr_rts)
                 drv->dtr_rts(p, on);
 }
@@ -724,6 +731,7 @@ int usb_serial_probe(struct usb_interface *interface,
         unsigned int minor;
         int buffer_size;
         int i;
+        int j;
         int num_interrupt_in = 0;
         int num_interrupt_out = 0;
         int num_bulk_in = 0;
@@ -906,38 +914,41 @@ int usb_serial_probe(struct usb_interface *interface,
         for (i = 0; i < num_bulk_in; ++i) {
                 endpoint = bulk_in_endpoint[i];
                 port = serial->port[i];
-                port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
-                if (!port->read_urb) {
-                        dev_err(&interface->dev, "No free urbs available\n");
-                        goto probe_error;
-                }
                 buffer_size = max_t(int, serial->type->bulk_in_size,
                                 usb_endpoint_maxp(endpoint));
                 port->bulk_in_size = buffer_size;
                 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
-                port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
-                if (!port->bulk_in_buffer) {
-                        dev_err(&interface->dev,
+
+                for (j = 0; j < ARRAY_SIZE(port->read_urbs); ++j) {
+                        set_bit(j, &port->read_urbs_free);
+                        port->read_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
+                        if (!port->read_urbs[j]) {
+                                dev_err(&interface->dev,
+                                                "No free urbs available\n");
+                                goto probe_error;
+                        }
+                        port->bulk_in_buffers[j] = kmalloc(buffer_size,
+                                                                GFP_KERNEL);
+                        if (!port->bulk_in_buffers[j]) {
+                                dev_err(&interface->dev,
                                         "Couldn't allocate bulk_in_buffer\n");
-                        goto probe_error;
-                }
-                usb_fill_bulk_urb(port->read_urb, dev,
-                                usb_rcvbulkpipe(dev,
+                                goto probe_error;
+                        }
+                        usb_fill_bulk_urb(port->read_urbs[j], dev,
+                                        usb_rcvbulkpipe(dev,
                                                 endpoint->bEndpointAddress),
-                                port->bulk_in_buffer, buffer_size,
-                                serial->type->read_bulk_callback, port);
+                                        port->bulk_in_buffers[j], buffer_size,
+                                        serial->type->read_bulk_callback,
+                                        port);
+                }
+
+                port->read_urb = port->read_urbs[0];
+                port->bulk_in_buffer = port->bulk_in_buffers[0];
         }
 
         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);
-                if (!port->write_urb) {
-                        dev_err(&interface->dev, "No free urbs available\n");
-                        goto probe_error;
-                }
                 if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL))
                         goto probe_error;
                 buffer_size = serial->type->bulk_out_size;
@@ -945,17 +956,7 @@ int usb_serial_probe(struct usb_interface *interface,
                         buffer_size = usb_endpoint_maxp(endpoint);
                 port->bulk_out_size = buffer_size;
                 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
-                port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
-                if (!port->bulk_out_buffer) {
-                        dev_err(&interface->dev,
-                                        "Couldn't allocate bulk_out_buffer\n");
-                        goto probe_error;
-                }
-                usb_fill_bulk_urb(port->write_urb, dev,
-                                usb_sndbulkpipe(dev,
-                                        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);
@@ -978,6 +979,9 @@ int usb_serial_probe(struct usb_interface *interface,
                                         serial->type->write_bulk_callback,
                                         port);
                 }
+
+                port->write_urb = port->write_urbs[0];
+                port->bulk_out_buffer = port->bulk_out_buffers[0];
         }
 
         if (serial->type->read_int_callback) {
@@ -1196,7 +1200,7 @@ static const struct tty_operations serial_ops = {
         .open =                 serial_open,
         .close =                serial_close,
         .write =                serial_write,
-        .hangup =               serial_hangup,
+        .hangup =               serial_hangup,
         .write_room =           serial_write_room,
         .ioctl =                serial_ioctl,
         .set_termios =          serial_set_termios,
@@ -1206,9 +1210,9 @@ static const struct tty_operations serial_ops = {
         .chars_in_buffer =      serial_chars_in_buffer,
         .tiocmget =             serial_tiocmget,
         .tiocmset =             serial_tiocmset,
-        .get_icount =           serial_get_icount,
-        .cleanup =              serial_cleanup,
-        .install =              serial_install,
+        .get_icount =           serial_get_icount,
+        .cleanup =              serial_cleanup,
+        .install =              serial_install,
         .proc_fops =            &serial_proc_fops,
 };
 
@@ -1237,7 +1241,7 @@ static int __init usb_serial_init(void)
 
         usb_serial_tty_driver->owner = THIS_MODULE;
         usb_serial_tty_driver->driver_name = "usbserial";
-        usb_serial_tty_driver->name =   "ttyUSB";
+        usb_serial_tty_driver->name = "ttyUSB";
         usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
         usb_serial_tty_driver->minor_start = 0;
         usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
@@ -1336,7 +1340,6 @@ static void fixup_generic(struct usb_serial_driver *device)
 
 int usb_serial_register(struct usb_serial_driver *driver)
 {
-        /* must be called with BKL held */
         int retval;
 
         if (usb_disabled())
@@ -1374,7 +1377,6 @@ EXPORT_SYMBOL_GPL(usb_serial_register);
 
 void usb_serial_deregister(struct usb_serial_driver *device)
 {
-        /* must be called with BKL held */
         printk(KERN_INFO "USB Serial deregistering driver %s\n",
                device->description);
         mutex_lock(&table_lock);