]> pilppa.com Git - linux-2.6-omap-h63xx.git/commitdiff
usb_serial: some coding style fixes
authorAlan Cox <alan@lxorguk.ukuu.org.uk>
Tue, 29 Apr 2008 13:35:39 +0000 (14:35 +0100)
committerGreg Kroah-Hartman <gregkh@suse.de>
Fri, 2 May 2008 17:25:58 +0000 (10:25 -0700)
Signed-off-by: Alan Cox <alan@redhat.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
drivers/usb/serial/aircable.c
drivers/usb/serial/airprime.c
drivers/usb/serial/ark3116.c
drivers/usb/serial/ch341.c

index 9b1bb347dc2d7e0b1865c4f36191118b207e5dde..db6f97a93c02c3b813e8feafd17ba6cb2acb1efc 100644 (file)
@@ -147,7 +147,7 @@ static void serial_buf_free(struct circ_buf *cb)
  */
 static int serial_buf_data_avail(struct circ_buf *cb)
 {
-       return CIRC_CNT(cb->head,cb->tail,AIRCABLE_BUF_SIZE);
+       return CIRC_CNT(cb->head, cb->tail, AIRCABLE_BUF_SIZE);
 }
 
 /*
@@ -171,7 +171,7 @@ static int serial_buf_put(struct circ_buf *cb, const char *buf, int count)
                cb->head = (cb->head + c) & (AIRCABLE_BUF_SIZE-1);
                buf += c;
                count -= c;
-               ret= c;
+               ret = c;
        }
        return ret;
 }
@@ -197,7 +197,7 @@ static int serial_buf_get(struct circ_buf *cb, char *buf, int count)
                cb->tail = (cb->tail + c) & (AIRCABLE_BUF_SIZE-1);
                buf += c;
                count -= c;
-               ret= c;
+               ret = c;
        }
        return ret;
 }
@@ -208,7 +208,7 @@ static void aircable_send(struct usb_serial_port *port)
 {
        int count, result;
        struct aircable_private *priv = usb_get_serial_port_data(port);
-       unsigned charbuf;
+       unsigned char *buf;
        __le16 *dbuf;
        dbg("%s - port %d", __func__, port->number);
        if (port->write_urb_busy)
@@ -229,7 +229,8 @@ static void aircable_send(struct usb_serial_port *port)
        buf[1] = TX_HEADER_1;
        dbuf = (__le16 *)&buf[2];
        *dbuf = cpu_to_le16((u16)count);
-       serial_buf_get(priv->tx_buf,buf + HCI_HEADER_LENGTH, MAX_HCI_FRAMESIZE);
+       serial_buf_get(priv->tx_buf, buf + HCI_HEADER_LENGTH,
+                                                       MAX_HCI_FRAMESIZE);
 
        memcpy(port->write_urb->transfer_buffer, buf,
               count + HCI_HEADER_LENGTH);
@@ -261,7 +262,7 @@ static void aircable_read(struct work_struct *work)
        struct tty_struct *tty;
        unsigned char *data;
        int count;
-       if (priv->rx_flags & THROTTLED){
+       if (priv->rx_flags & THROTTLED) {
                if (priv->rx_flags & ACTUALLY_THROTTLED)
                        schedule_work(&priv->rx_work);
                return;
@@ -282,10 +283,10 @@ static void aircable_read(struct work_struct *work)
        count = min(64, serial_buf_data_avail(priv->rx_buf));
 
        if (count <= 0)
-               return; //We have finished sending everything.
+               return; /* We have finished sending everything. */
 
        tty_prepare_flip_string(tty, &data, count);
-       if (!data){
+       if (!data) {
                err("%s- kzalloc(%d) failed.", __func__, count);
                return;
        }
@@ -304,9 +305,10 @@ static void aircable_read(struct work_struct *work)
 static int aircable_probe(struct usb_serial *serial,
                          const struct usb_device_id *id)
 {
-       struct usb_host_interface *iface_desc = serial->interface->cur_altsetting;
+       struct usb_host_interface *iface_desc = serial->interface->
+                                                               cur_altsetting;
        struct usb_endpoint_descriptor *endpoint;
-       int num_bulk_out=0;
+       int num_bulk_out = 0;
        int i;
 
        for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
@@ -325,13 +327,13 @@ static int aircable_probe(struct usb_serial *serial,
        return 0;
 }
 
-static int aircable_attach (struct usb_serial *serial)
+static int aircable_attach(struct usb_serial *serial)
 {
        struct usb_serial_port *port = serial->port[0];
        struct aircable_private *priv;
 
        priv = kzalloc(sizeof(struct aircable_private), GFP_KERNEL);
-       if (!priv){
+       if (!priv) {
                err("%s- kmalloc(%Zd) failed.", __func__,
                        sizeof(struct aircable_private));
                return -ENOMEM;
@@ -392,7 +394,7 @@ static int aircable_write(struct usb_serial_port *port,
 
        usb_serial_debug_data(debug, &port->dev, __func__, count, source);
 
-       if (!count){
+       if (!count) {
                dbg("%s - write request of 0 bytes", __func__);
                return count;
        }
@@ -418,31 +420,31 @@ static void aircable_write_bulk_callback(struct urb *urb)
 
        /* This has been taken from cypress_m8.c cypress_write_int_callback */
        switch (status) {
-               case 0:
-                       /* success */
-                       break;
-               case -ECONNRESET:
-               case -ENOENT:
-               case -ESHUTDOWN:
-                       /* this urb is terminated, clean up */
-                       dbg("%s - urb shutting down with status: %d",
-                           __func__, status);
-                       port->write_urb_busy = 0;
+       case 0:
+               /* success */
+               break;
+       case -ECONNRESET:
+       case -ENOENT:
+       case -ESHUTDOWN:
+               /* this urb is terminated, clean up */
+               dbg("%s - urb shutting down with status: %d",
+                   __func__, status);
+               port->write_urb_busy = 0;
+               return;
+       default:
+               /* error in the urb, so we have to resubmit it */
+               dbg("%s - Overflow in write", __func__);
+               dbg("%s - nonzero write bulk status received: %d",
+                   __func__, status);
+               port->write_urb->transfer_buffer_length = 1;
+               port->write_urb->dev = port->serial->dev;
+               result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
+               if (result)
+                       dev_err(&urb->dev->dev,
+                           "%s - failed resubmitting write urb, error %d\n",
+                                                       __func__, result);
+               else
                        return;
-               default:
-                       /* error in the urb, so we have to resubmit it */
-                       dbg("%s - Overflow in write", __func__);
-                       dbg("%s - nonzero write bulk status received: %d",
-                           __func__, status);
-                       port->write_urb->transfer_buffer_length = 1;
-                       port->write_urb->dev = port->serial->dev;
-                       result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
-                       if (result)
-                               dev_err(&urb->dev->dev,
-                                       "%s - failed resubmitting write urb, error %d\n",
-                                       __func__, result);
-                       else
-                               return;
        }
 
        port->write_urb_busy = 0;
@@ -472,11 +474,11 @@ static void aircable_read_bulk_callback(struct urb *urb)
                        dbg("%s - caught -EPROTO, resubmitting the urb",
                            __func__);
                        usb_fill_bulk_urb(port->read_urb, port->serial->dev,
-                                         usb_rcvbulkpipe(port->serial->dev,
-                                                         port->bulk_in_endpointAddress),
-                                         port->read_urb->transfer_buffer,
-                                         port->read_urb->transfer_buffer_length,
-                                         aircable_read_bulk_callback, port);
+                               usb_rcvbulkpipe(port->serial->dev,
+                                       port->bulk_in_endpointAddress),
+                               port->read_urb->transfer_buffer,
+                               port->read_urb->transfer_buffer_length,
+                               aircable_read_bulk_callback, port);
 
                        result = usb_submit_urb(urb, GFP_ATOMIC);
                        if (result)
@@ -490,7 +492,7 @@ static void aircable_read_bulk_callback(struct urb *urb)
        }
 
        usb_serial_debug_data(debug, &port->dev, __func__,
-                               urb->actual_length,urb->transfer_buffer);
+                               urb->actual_length, urb->transfer_buffer);
 
        tty = port->tty;
        if (tty && urb->actual_length) {
@@ -507,9 +509,9 @@ static void aircable_read_bulk_callback(struct urb *urb)
                        no_packages = urb->actual_length / (HCI_COMPLETE_FRAME);
 
                        if (urb->actual_length % HCI_COMPLETE_FRAME != 0)
-                               no_packages+=1;
+                               no_packages++;
 
-                       for (i = 0; i < no_packages ;i++) {
+                       for (i = 0; i < no_packagesi++) {
                                if (remaining > (HCI_COMPLETE_FRAME))
                                        package_length = HCI_COMPLETE_FRAME;
                                else
@@ -529,7 +531,7 @@ static void aircable_read_bulk_callback(struct urb *urb)
        if (port->open_count) {
                usb_fill_bulk_urb(port->read_urb, port->serial->dev,
                                  usb_rcvbulkpipe(port->serial->dev,
-                                                 port->bulk_in_endpointAddress),
+                                         port->bulk_in_endpointAddress),
                                  port->read_urb->transfer_buffer,
                                  port->read_urb->transfer_buffer_length,
                                  aircable_read_bulk_callback, port);
@@ -602,7 +604,7 @@ static struct usb_serial_driver aircable_device = {
        .unthrottle =           aircable_unthrottle,
 };
 
-static int __init aircable_init (void)
+static int __init aircable_init(void)
 {
        int retval;
        retval = usb_serial_register(&aircable_device);
@@ -619,7 +621,7 @@ failed_usb_register:
        return retval;
 }
 
-static void __exit aircable_exit (void)
+static void __exit aircable_exit(void)
 {
        usb_deregister(&aircable_driver);
        usb_serial_deregister(&aircable_device);
index 7290b41fa11c33cf0dfb36f2b01a8b2a1d9495a8..0798c14ce787767718e216b000cc8e6aef10c5ed 100644 (file)
@@ -68,8 +68,9 @@ static int airprime_send_setup(struct usb_serial_port *port)
                        val |= 0x02;
 
                return usb_control_msg(serial->dev,
-                               usb_rcvctrlpipe(serial->dev, 0),
-                               0x22,0x21,val,0,NULL,0,USB_CTRL_SET_TIMEOUT);
+                                       usb_rcvctrlpipe(serial->dev, 0),
+                                       0x22, 0x21, val, 0, NULL, 0,
+                                       USB_CTRL_SET_TIMEOUT);
        }
 
        return 0;
@@ -90,17 +91,19 @@ static void airprime_read_bulk_callback(struct urb *urb)
                    __func__, status);
                return;
        }
-       usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length, data);
+       usb_serial_debug_data(debug, &port->dev, __func__,
+                                               urb->actual_length, data);
 
        tty = port->tty;
        if (tty && urb->actual_length) {
-               tty_insert_flip_string (tty, data, urb->actual_length);
-               tty_flip_buffer_push (tty);
+               tty_insert_flip_string(tty, data, urb->actual_length);
+               tty_flip_buffer_push(tty);
        }
 
-       result = usb_submit_urb (urb, GFP_ATOMIC);
+       result = usb_submit_urb(urb, GFP_ATOMIC);
        if (result)
-               dev_err(&port->dev, "%s - failed resubmitting read urb, error %d\n",
+               dev_err(&port->dev,
+                       "%s - failed resubmitting read urb, error %d\n",
                        __func__, result);
        return;
 }
@@ -115,7 +118,7 @@ static void airprime_write_bulk_callback(struct urb *urb)
        dbg("%s - port %d", __func__, port->number);
 
        /* free up the transfer buffer, as usb_free_urb() does not do this */
-       kfree (urb->transfer_buffer);
+       kfree(urb->transfer_buffer);
 
        if (status)
                dbg("%s - nonzero write bulk status received: %d",
@@ -171,7 +174,7 @@ static int airprime_open(struct usb_serial_port *port, struct file *filp)
                }
                usb_fill_bulk_urb(urb, serial->dev,
                                  usb_rcvbulkpipe(serial->dev,
-                                                 port->bulk_out_endpointAddress),
+                                         port->bulk_out_endpointAddress),
                                  buffer, buffer_size,
                                  airprime_read_bulk_callback, port);
                result = usb_submit_urb(urb, GFP_KERNEL);
@@ -183,7 +186,8 @@ static int airprime_open(struct usb_serial_port *port, struct file *filp)
                                __func__, i, port->number, result);
                        goto errout;
                }
-               /* remember this urb so we can kill it when the port is closed */
+               /* remember this urb so we can kill it when the
+                  port is closed */
                priv->read_urbp[i] = urb;
        }
 
@@ -192,22 +196,22 @@ static int airprime_open(struct usb_serial_port *port, struct file *filp)
        goto out;
 
  errout:
-       /* some error happened, cancel any submitted urbs and clean up anything that
-          got allocated successfully */
+       /* some error happened, cancel any submitted urbs and clean up
+          anything that got allocated successfully */
 
        while (i-- != 0) {
                urb = priv->read_urbp[i];
                buffer = urb->transfer_buffer;
-               usb_kill_urb (urb);
-               usb_free_urb (urb);
-               kfree (buffer);
+               usb_kill_urb(urb);
+               usb_free_urb(urb);
+               kfree(buffer);
        }
 
  out:
        return result;
 }
 
-static void airprime_close(struct usb_serial_port *port, struct file * filp)
+static void airprime_close(struct usb_serial_port *port, struct file *filp)
 {
        struct airprime_private *priv = usb_get_serial_port_data(port);
        int i;
@@ -223,13 +227,13 @@ static void airprime_close(struct usb_serial_port *port, struct file * filp)
        mutex_unlock(&port->serial->disc_mutex);
 
        for (i = 0; i < NUM_READ_URBS; ++i) {
-               usb_kill_urb (priv->read_urbp[i]);
-               kfree (priv->read_urbp[i]->transfer_buffer);
-               usb_free_urb (priv->read_urbp[i]);
+               usb_kill_urb(priv->read_urbp[i]);
+               kfree(priv->read_urbp[i]->transfer_buffer);
+               usb_free_urb(priv->read_urbp[i]);
        }
 
        /* free up private structure */
-       kfree (priv);
+       kfree(priv);
        usb_set_serial_port_data(port, NULL);
 }
 
@@ -259,10 +263,10 @@ static int airprime_write(struct usb_serial_port *port,
        urb = usb_alloc_urb(0, GFP_ATOMIC);
        if (!urb) {
                dev_err(&port->dev, "no more free urbs\n");
-               kfree (buffer);
+               kfree(buffer);
                return -ENOMEM;
        }
-       memcpy (buffer, buf, count);
+       memcpy(buffer, buf, count);
 
        usb_serial_debug_data(debug, &port->dev, __func__, count, buffer);
 
@@ -279,7 +283,7 @@ static int airprime_write(struct usb_serial_port *port,
                        "%s - usb_submit_urb(write bulk) failed with status = %d\n",
                        __func__, status);
                count = status;
-               kfree (buffer);
+               kfree(buffer);
        } else {
                spin_lock_irqsave(&priv->lock, flags);
                ++priv->outstanding_urbs;
@@ -287,7 +291,7 @@ static int airprime_write(struct usb_serial_port *port,
        }
        /* we are done with this urb, so let the host driver
         * really free it when it is finished with it */
-       usb_free_urb (urb);
+       usb_free_urb(urb);
        return count;
 }
 
@@ -315,8 +319,10 @@ static int __init airprime_init(void)
 {
        int retval;
 
-       airprime_device.num_ports =
-               (endpoints > 0 && endpoints <= MAX_BULK_EPS) ? endpoints : NUM_BULK_EPS;
+       airprime_device.num_ports = endpoints;
+       if (endpoints < 0 || endpoints >= MAX_BULK_EPS)
+               airprime_device.num_ports = NUM_BULK_EPS;
+
        retval = usb_serial_register(&airprime_device);
        if (retval)
                return retval;
@@ -341,6 +347,7 @@ MODULE_LICENSE("GPL");
 module_param(debug, bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(debug, "Debug enabled");
 module_param(buffer_size, int, 0);
-MODULE_PARM_DESC(buffer_size, "Size of the transfer buffers in bytes (default 4096)");
+MODULE_PARM_DESC(buffer_size,
+               "Size of the transfer buffers in bytes (default 4096)");
 module_param(endpoints, int, 0);
 MODULE_PARM_DESC(endpoints, "Number of bulk EPs to configure (default 3)");
index 599ab2e548a7c3e483abc255471ee5b92838c90e..77895c8f8f3189fb774acb59cad0f3f3a324cbad 100644 (file)
@@ -24,7 +24,7 @@
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 #include <linux/serial.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 
 
 static int debug;
@@ -246,29 +246,29 @@ static void ark3116_set_termios(struct usb_serial_port *port,
        baud = tty_get_baud_rate(port->tty);
 
        switch (baud) {
-               case 75:
-               case 150:
-               case 300:
-               case 600:
-               case 1200:
-               case 1800:
-               case 2400:
-               case 4800:
-               case 9600:
-               case 19200:
-               case 38400:
-               case 57600:
-               case 115200:
-               case 230400:
-               case 460800:
-                       /* Report the resulting rate back to the caller */
-                       tty_encode_baud_rate(port->tty, baud, baud);
-                       break;
-               /* set 9600 as default (if given baudrate is invalid for example) */
-               default:
-                       tty_encode_baud_rate(port->tty, 9600, 9600);
-               case 0:
-                       baud = 9600;
+       case 75:
+       case 150:
+       case 300:
+       case 600:
+       case 1200:
+       case 1800:
+       case 2400:
+       case 4800:
+       case 9600:
+       case 19200:
+       case 38400:
+       case 57600:
+       case 115200:
+       case 230400:
+       case 460800:
+               /* Report the resulting rate back to the caller */
+               tty_encode_baud_rate(port->tty, baud, baud);
+               break;
+       /* set 9600 as default (if given baudrate is invalid for example) */
+       default:
+               tty_encode_baud_rate(port->tty, 9600, 9600);
+       case 0:
+               baud = 9600;
        }
 
        /*
@@ -380,19 +380,19 @@ static int ark3116_ioctl(struct usb_serial_port *port, struct file *file,
        switch (cmd) {
        case TIOCGSERIAL:
                /* XXX: Some of these values are probably wrong. */
-               memset(&serstruct, 0, sizeof (serstruct));
+               memset(&serstruct, 0, sizeof(serstruct));
                serstruct.type = PORT_16654;
                serstruct.line = port->serial->minor;
                serstruct.port = port->number;
                serstruct.custom_divisor = 0;
                serstruct.baud_base = 460800;
 
-               if (copy_to_user(user_arg, &serstruct, sizeof (serstruct)))
+               if (copy_to_user(user_arg, &serstruct, sizeof(serstruct)))
                        return -EFAULT;
 
                return 0;
        case TIOCSSERIAL:
-               if (copy_from_user(&serstruct, user_arg, sizeof (serstruct)))
+               if (copy_from_user(&serstruct, user_arg, sizeof(serstruct)))
                        return -EFAULT;
                return 0;
        default:
index d947d955bceb9504d9beae2d9877ddb41c105e28..ba28fdc9ccd2f589a2ec5038616dc91795fd9757 100644 (file)
@@ -130,7 +130,7 @@ static int ch341_get_status(struct usb_device *dev)
                return -ENOMEM;
 
        r = ch341_control_in(dev, 0x95, 0x0706, 0, buffer, size);
-       if ( r < 0)
+       if (r < 0)
                goto out;
 
        /* Not having the datasheet for the CH341, we ignore the bytes returned