USB: remove BKL comments

[cascardo/linux.git] / drivers / usb / serial / usb-serial.c

diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index cc274fd..ce6c1a6 100644 (file)
--- 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);