]> pilppa.com Git - linux-2.6-omap-h63xx.git/commitdiff
tty-usb-kobil-sct: Coding style
authorAlan Cox <alan@redhat.com>
Tue, 22 Jul 2008 10:14:10 +0000 (11:14 +0100)
committerLinus Torvalds <torvalds@linux-foundation.org>
Tue, 22 Jul 2008 20:03:25 +0000 (13:03 -0700)
Signed-off-by: Alan Cox <alan@redhat.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
drivers/usb/serial/kobil_sct.c

index 40c67f0096b10f3b2b5397ade28eb455f21d7f70..f0f8353ec1acb9b7b52f761446225c0deff49fa3 100644 (file)
@@ -1,7 +1,7 @@
 /*
  *  KOBIL USB Smart Card Terminal Driver
  *
- *  Copyright (C) 2002  KOBIL Systems GmbH 
+ *  Copyright (C) 2002  KOBIL Systems GmbH
  *  Author: Thomas Wahrenbruch
  *
  *  Contact: linuxusb@kobil.de
@@ -20,7 +20,7 @@
  *
  * Supported readers: USB TWIN, KAAN Standard Plus and SecOVID Reader Plus
  * (Adapter K), B1 Professional and KAAN Professional (Adapter B)
- * 
+ *
  * (21/05/2004) tw
  *      Fix bug with P'n'P readers
  *
@@ -44,7 +44,7 @@
 #include <linux/tty_flip.h>
 #include <linux/module.h>
 #include <linux/spinlock.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 #include <linux/ioctl.h>
@@ -68,13 +68,13 @@ static int debug;
 
 
 /* Function prototypes */
-static int  kobil_startup (struct usb_serial *serial);
-static void kobil_shutdown (struct usb_serial *serial);
-static int  kobil_open (struct tty_struct *tty,
+static int  kobil_startup(struct usb_serial *serial);
+static void kobil_shutdown(struct usb_serial *serial);
+static int  kobil_open(struct tty_struct *tty,
                        struct usb_serial_port *port, struct file *filp);
-static void kobil_close (struct tty_struct *tty, struct usb_serial_port *port,
+static void kobil_close(struct tty_struct *tty, struct usb_serial_port *port,
                        struct file *filp);
-static int  kobil_write (struct tty_struct *tty, struct usb_serial_port *port, 
+static int  kobil_write(struct tty_struct *tty, struct usb_serial_port *port,
                         const unsigned char *buf, int count);
 static int  kobil_write_room(struct tty_struct *tty);
 static int  kobil_ioctl(struct tty_struct *tty, struct file *file,
@@ -82,9 +82,9 @@ static int  kobil_ioctl(struct tty_struct *tty, struct file *file,
 static int  kobil_tiocmget(struct tty_struct *tty, struct file *file);
 static int  kobil_tiocmset(struct tty_struct *tty, struct file *file,
                           unsigned int set, unsigned int clear);
-static void kobil_read_int_callback( struct urb *urb );
-static void kobil_write_callback( struct urb *purb );
-static void kobil_set_termios(struct tty_struct *tty, 
+static void kobil_read_int_callback(struct urb *urb);
+static void kobil_write_callback(struct urb *purb);
+static void kobil_set_termios(struct tty_struct *tty,
                        struct usb_serial_port *port, struct ktermios *old);
 
 
@@ -97,7 +97,7 @@ static struct usb_device_id id_table [] = {
 };
 
 
-MODULE_DEVICE_TABLE (usb, id_table);
+MODULE_DEVICE_TABLE(usb, id_table);
 
 static struct usb_driver kobil_driver = {
        .name =         "kobil",
@@ -134,14 +134,14 @@ static struct usb_serial_driver kobil_device = {
 struct kobil_private {
        int write_int_endpoint_address;
        int read_int_endpoint_address;
-       unsigned char buf[KOBIL_BUF_LENGTH]; // buffer for the APDU to send
-       int filled;  // index of the last char in buf
-       int cur_pos; // index of the next char to send in buf
+       unsigned char buf[KOBIL_BUF_LENGTH]; /* buffer for the APDU to send */
+       int filled;  /* index of the last char in buf */
+       int cur_pos; /* index of the next char to send in buf */
        __u16 device_type;
 };
 
 
-static int kobil_startup (struct usb_serial *serial)
+static int kobil_startup(struct usb_serial *serial)
 {
        int i;
        struct kobil_private *priv;
@@ -152,20 +152,20 @@ static int kobil_startup (struct usb_serial *serial)
        struct usb_host_endpoint *endpoint;
 
        priv = kmalloc(sizeof(struct kobil_private), GFP_KERNEL);
-       if (!priv){
+       if (!priv)
                return -ENOMEM;
-       }
 
        priv->filled = 0;
        priv->cur_pos = 0;
        priv->device_type = le16_to_cpu(serial->dev->descriptor.idProduct);
 
-       switch (priv->device_type){
+       switch (priv->device_type) {
        case KOBIL_ADAPTER_B_PRODUCT_ID:
                printk(KERN_DEBUG "KOBIL B1 PRO / KAAN PRO detected\n");
                break;
        case KOBIL_ADAPTER_K_PRODUCT_ID:
-               printk(KERN_DEBUG "KOBIL KAAN Standard Plus / SecOVID Reader Plus detected\n");
+               printk(KERN_DEBUG
+                 "KOBIL KAAN Standard Plus / SecOVID Reader Plus detected\n");
                break;
        case KOBIL_USBTWIN_PRODUCT_ID:
                printk(KERN_DEBUG "KOBIL USBTWIN detected\n");
@@ -176,37 +176,40 @@ static int kobil_startup (struct usb_serial *serial)
        }
        usb_set_serial_port_data(serial->port[0], priv);
 
-       // search for the necessary endpoints
+       /* search for the necessary endpoints */
        pdev = serial->dev;
-       actconfig = pdev->actconfig;
-       interface = actconfig->interface[0];
+       actconfig = pdev->actconfig;
+       interface = actconfig->interface[0];
        altsetting = interface->cur_altsetting;
-       endpoint = altsetting->endpoint;
-  
-       for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
+       endpoint = altsetting->endpoint;
+
+       for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
                endpoint = &altsetting->endpoint[i];
                if (usb_endpoint_is_int_out(&endpoint->desc)) {
-                       dbg("%s Found interrupt out endpoint. Address: %d", __func__, endpoint->desc.bEndpointAddress);
-                       priv->write_int_endpoint_address = endpoint->desc.bEndpointAddress;
-               }
+                       dbg("%s Found interrupt out endpoint. Address: %d",
+                               __func__, endpoint->desc.bEndpointAddress);
+                       priv->write_int_endpoint_address =
+                               endpoint->desc.bEndpointAddress;
+               }
                if (usb_endpoint_is_int_in(&endpoint->desc)) {
-                       dbg("%s Found interrupt in  endpoint. Address: %d", __func__, endpoint->desc.bEndpointAddress);
-                       priv->read_int_endpoint_address = endpoint->desc.bEndpointAddress;
-               }
+                       dbg("%s Found interrupt in  endpoint. Address: %d",
+                               __func__, endpoint->desc.bEndpointAddress);
+                       priv->read_int_endpoint_address =
+                               endpoint->desc.bEndpointAddress;
+               }
        }
        return 0;
 }
 
 
-static void kobil_shutdown (struct usb_serial *serial)
+static void kobil_shutdown(struct usb_serial *serial)
 {
        int i;
        dbg("%s - port %d", __func__, serial->port[0]->number);
 
-       for (i=0; i < serial->num_ports; ++i) {
-               while (serial->port[i]->port.count > 0) {
-                       kobil_close (NULL, serial->port[i], NULL);
-               }
+       for (i = 0; i < serial->num_ports; ++i) {
+               while (serial->port[i]->port.count > 0)
+                       kobil_close(NULL, serial->port[i], NULL);
                kfree(usb_get_serial_port_data(serial->port[i]));
                usb_set_serial_port_data(serial->port[i], NULL);
        }
@@ -225,7 +228,7 @@ static int kobil_open(struct tty_struct *tty,
        dbg("%s - port %d", __func__, port->number);
        priv = usb_get_serial_port_data(port);
 
-       // someone sets the dev to 0 if the close method has been called
+       /* someone sets the dev to 0 if the close method has been called */
        port->interrupt_in_urb->dev = port->serial->dev;
 
 
@@ -238,96 +241,110 @@ static int kobil_open(struct tty_struct *tty,
 
                /* Default to echo off and other sane device settings */
                tty->termios->c_lflag = 0;
-               tty->termios->c_lflag &= ~(ISIG | ICANON | ECHO | IEXTEN | XCASE);
+               tty->termios->c_lflag &= ~(ISIG | ICANON | ECHO | IEXTEN |
+                                                                XCASE);
                tty->termios->c_iflag = IGNBRK | IGNPAR | IXOFF;
-               tty->termios->c_oflag &= ~ONLCR; // do NOT translate CR to CR-NL (0x0A -> 0x0A 0x0D)
-       }       
-       // allocate memory for transfer buffer
+               /* do NOT translate CR to CR-NL (0x0A -> 0x0A 0x0D) */
+               tty->termios->c_oflag &= ~ONLCR;
+       }
+       /* allocate memory for transfer buffer */
        transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL);
-       if (! transfer_buffer) {
+       if (!transfer_buffer)
                return -ENOMEM;
-       }
-       
-       // allocate write_urb
-       if (!port->write_urb) { 
-               dbg("%s - port %d  Allocating port->write_urb", __func__, port->number);
-               port->write_urb = usb_alloc_urb(0, GFP_KERNEL);  
+
+       /* allocate write_urb */
+       if (!port->write_urb) {
+               dbg("%s - port %d  Allocating port->write_urb",
+                                               __func__, port->number);
+               port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
                if (!port->write_urb) {
-                       dbg("%s - port %d usb_alloc_urb failed", __func__, port->number);
+                       dbg("%s - port %d usb_alloc_urb failed",
+                                               __func__, port->number);
                        kfree(transfer_buffer);
                        return -ENOMEM;
                }
        }
 
-       // allocate memory for write_urb transfer buffer
-       port->write_urb->transfer_buffer = kmalloc(write_urb_transfer_buffer_length, GFP_KERNEL);
-       if (! port->write_urb->transfer_buffer) {
+       /* allocate memory for write_urb transfer buffer */
+       port->write_urb->transfer_buffer =
+                       kmalloc(write_urb_transfer_buffer_length, GFP_KERNEL);
+       if (!port->write_urb->transfer_buffer) {
                kfree(transfer_buffer);
                usb_free_urb(port->write_urb);
                port->write_urb = NULL;
                return -ENOMEM;
-       } 
-
-       // get hardware version
-       result = usb_control_msg( port->serial->dev, 
-                                 usb_rcvctrlpipe(port->serial->dev, 0 ), 
-                                 SUSBCRequest_GetMisc,
-                                 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_IN,
-                                 SUSBCR_MSC_GetHWVersion,
-                                 0,
-                                 transfer_buffer,
-                                 transfer_buffer_length,
-                                 KOBIL_TIMEOUT
+       }
+
+       /* get hardware version */
+       result = usb_control_msg(port->serial->dev,
+                         usb_rcvctrlpipe(port->serial->dev, 0),
+                         SUSBCRequest_GetMisc,
+                         USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_IN,
+                         SUSBCR_MSC_GetHWVersion,
+                         0,
+                         transfer_buffer,
+                         transfer_buffer_length,
+                         KOBIL_TIMEOUT
+       );
+       dbg("%s - port %d Send get_HW_version URB returns: %i",
+               __func__, port->number, result);
+       dbg("Harware version: %i.%i.%i",
+               transfer_buffer[0], transfer_buffer[1], transfer_buffer[2]);
+
+       /* get firmware version */
+       result = usb_control_msg(port->serial->dev,
+                         usb_rcvctrlpipe(port->serial->dev, 0),
+                         SUSBCRequest_GetMisc,
+                         USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_IN,
+                         SUSBCR_MSC_GetFWVersion,
+                         0,
+                         transfer_buffer,
+                         transfer_buffer_length,
+                         KOBIL_TIMEOUT
+       );
+       dbg("%s - port %d Send get_FW_version URB returns: %i",
+                                       __func__, port->number, result);
+       dbg("Firmware version: %i.%i.%i",
+               transfer_buffer[0], transfer_buffer[1], transfer_buffer[2]);
+
+       if (priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID ||
+                       priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID) {
+               /* Setting Baudrate, Parity and Stopbits */
+               result = usb_control_msg(port->serial->dev,
+                         usb_rcvctrlpipe(port->serial->dev, 0),
+                         SUSBCRequest_SetBaudRateParityAndStopBits,
+                         USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
+                         SUSBCR_SBR_9600 | SUSBCR_SPASB_EvenParity |
+                                                       SUSBCR_SPASB_1StopBit,
+                         0,
+                         transfer_buffer,
+                         0,
+                         KOBIL_TIMEOUT
                );
-       dbg("%s - port %d Send get_HW_version URB returns: %i", __func__, port->number, result);
-       dbg("Harware version: %i.%i.%i", transfer_buffer[0], transfer_buffer[1], transfer_buffer[2] );
-       
-       // get firmware version
-       result = usb_control_msg( port->serial->dev, 
-                                 usb_rcvctrlpipe(port->serial->dev, 0 ), 
-                                 SUSBCRequest_GetMisc,
-                                 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_IN,
-                                 SUSBCR_MSC_GetFWVersion,
-                                 0,
-                                 transfer_buffer,
-                                 transfer_buffer_length,
-                                 KOBIL_TIMEOUT
+               dbg("%s - port %d Send set_baudrate URB returns: %i",
+                                       __func__, port->number, result);
+
+               /* reset all queues */
+               result = usb_control_msg(port->serial->dev,
+                         usb_rcvctrlpipe(port->serial->dev, 0),
+                         SUSBCRequest_Misc,
+                         USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
+                         SUSBCR_MSC_ResetAllQueues,
+                         0,
+                         transfer_buffer,
+                         0,
+                         KOBIL_TIMEOUT
                );
-       dbg("%s - port %d Send get_FW_version URB returns: %i", __func__, port->number, result);
-       dbg("Firmware version: %i.%i.%i", transfer_buffer[0], transfer_buffer[1], transfer_buffer[2] );
-
-       if (priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID || priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID) {
-               // Setting Baudrate, Parity and Stopbits
-               result = usb_control_msg( port->serial->dev, 
-                                         usb_rcvctrlpipe(port->serial->dev, 0 ), 
-                                         SUSBCRequest_SetBaudRateParityAndStopBits,
-                                         USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
-                                         SUSBCR_SBR_9600 | SUSBCR_SPASB_EvenParity | SUSBCR_SPASB_1StopBit,
-                                         0,
-                                         transfer_buffer,
-                                         0,
-                                         KOBIL_TIMEOUT
-                       );
-               dbg("%s - port %d Send set_baudrate URB returns: %i", __func__, port->number, result);
-               
-               // reset all queues
-               result = usb_control_msg( port->serial->dev, 
-                                         usb_rcvctrlpipe(port->serial->dev, 0 ), 
-                                         SUSBCRequest_Misc,
-                                         USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
-                                         SUSBCR_MSC_ResetAllQueues,
-                                         0,
-                                         transfer_buffer,
-                                         0,
-                                         KOBIL_TIMEOUT
-                       );
-               dbg("%s - port %d Send reset_all_queues URB returns: %i", __func__, port->number, result);
+               dbg("%s - port %d Send reset_all_queues URB returns: %i",
+                                       __func__, port->number, result);
        }
-       if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID || priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID ||
+       if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID ||
+           priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID ||
            priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) {
-               // start reading (Adapter B 'cause PNP string)
-               result = usb_submit_urb( port->interrupt_in_urb, GFP_ATOMIC  ); 
-               dbg("%s - port %d Send read URB returns: %i", __func__, port->number, result);
+               /* start reading (Adapter B 'cause PNP string) */
+               result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
+               dbg("%s - port %d Send read URB returns: %i",
+                                       __func__, port->number, result);
        }
 
        kfree(transfer_buffer);
@@ -342,7 +359,7 @@ static void kobil_close(struct tty_struct *tty,
 
        if (port->write_urb) {
                usb_kill_urb(port->write_urb);
-               usb_free_urb( port->write_urb );
+               usb_free_urb(port->write_urb);
                port->write_urb = NULL;
        }
        usb_kill_urb(port->interrupt_in_urb);
@@ -356,7 +373,7 @@ static void kobil_read_int_callback(struct urb *urb)
        struct tty_struct *tty;
        unsigned char *data = urb->transfer_buffer;
        int status = urb->status;
-//     char *dbg_data;
+/*     char *dbg_data; */
 
        dbg("%s - port %d", __func__, port->number);
 
@@ -369,48 +386,50 @@ static void kobil_read_int_callback(struct urb *urb)
        tty = port->port.tty;
        if (urb->actual_length) {
 
-               // BEGIN DEBUG
+               /* BEGIN DEBUG */
                /*
-                 dbg_data = kzalloc((3 *  purb->actual_length + 10) * sizeof(char), GFP_KERNEL);
+                 dbg_data = kzalloc((3 *  purb->actual_length + 10)
+                                               * sizeof(char), GFP_KERNEL);
                  if (! dbg_data) {
-                 return;
+                         return;
                  }
-                 for (i = 0; i < purb->actual_length; i++) { 
-                 sprintf(dbg_data +3*i, "%02X ", data[i]); 
+                 for (i = 0; i < purb->actual_length; i++) {
+                         sprintf(dbg_data +3*i, "%02X ", data[i]);
                  }
-                 dbg(" <-- %s", dbg_data );
+                 dbg(" <-- %s", dbg_data);
                  kfree(dbg_data);
                */
-               // END DEBUG
+               /* END DEBUG */
 
                tty_buffer_request_room(tty, urb->actual_length);
                tty_insert_flip_string(tty, data, urb->actual_length);
                tty_flip_buffer_push(tty);
        }
-
-       // someone sets the dev to 0 if the close method has been called
+       /* someone sets the dev to 0 if the close method has been called */
        port->interrupt_in_urb->dev = port->serial->dev;
 
        result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
-       dbg("%s - port %d Send read URB returns: %i", __func__, port->number, result);
+       dbg("%s - port %d Send read URB returns: %i",
+                       __func__, port->number, result);
 }
 
 
-static void kobil_write_callback( struct urb *purb )
+static void kobil_write_callback(struct urb *purb)
 {
 }
 
 
-static int kobil_write (struct tty_struct *tty, struct usb_serial_port *port, 
+static int kobil_write(struct tty_struct *tty, struct usb_serial_port *port,
                        const unsigned char *buf, int count)
 {
        int length = 0;
        int result = 0;
        int todo = 0;
-       struct kobil_private * priv;
+       struct kobil_private *priv;
 
        if (count == 0) {
-               dbg("%s - port %d write request of 0 bytes", __func__, port->number);
+               dbg("%s - port %d write request of 0 bytes",
+                                               __func__, port->number);
                return 0;
        }
 
@@ -421,69 +440,77 @@ static int kobil_write (struct tty_struct *tty, struct usb_serial_port *port,
                return -ENOMEM;
        }
 
-       // Copy data to buffer
-       memcpy (priv->buf + priv->filled, buf, count);
-       usb_serial_debug_data(debug, &port->dev, __func__, count, priv->buf + priv->filled);
+       /* Copy data to buffer */
+       memcpy(priv->buf + priv->filled, buf, count);
+       usb_serial_debug_data(debug, &port->dev, __func__, count,
+                                               priv->buf + priv->filled);
        priv->filled = priv->filled + count;
 
-       // only send complete block. TWIN, KAAN SIM and adapter K use the same protocol.
-       if ( ((priv->device_type != KOBIL_ADAPTER_B_PRODUCT_ID) && (priv->filled > 2) && (priv->filled >= (priv->buf[1] + 3))) || 
-            ((priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID) && (priv->filled > 3) && (priv->filled >= (priv->buf[2] + 4))) ) {
-               
-               // stop reading (except TWIN and KAAN SIM)
-               if ( (priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID) || (priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID) )
+       /* only send complete block. TWIN, KAAN SIM and adapter K
+          use the same protocol. */
+       if (((priv->device_type != KOBIL_ADAPTER_B_PRODUCT_ID) && (priv->filled > 2) && (priv->filled >= (priv->buf[1] + 3))) ||
+            ((priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID) && (priv->filled > 3) && (priv->filled >= (priv->buf[2] + 4)))) {
+               /* stop reading (except TWIN and KAAN SIM) */
+               if ((priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID)
+                       || (priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID))
                        usb_kill_urb(port->interrupt_in_urb);
 
                todo = priv->filled - priv->cur_pos;
 
-               while(todo > 0) {
-                       // max 8 byte in one urb (endpoint size)
+               while (todo > 0) {
+                       /* max 8 byte in one urb (endpoint size) */
                        length = (todo < 8) ? todo : 8;
-                       // copy data to transfer buffer
-                       memcpy(port->write_urb->transfer_buffer, priv->buf + priv->cur_pos, length );
-                       usb_fill_int_urb( port->write_urb,
-                                         port->serial->dev,
-                                         usb_sndintpipe(port->serial->dev, priv->write_int_endpoint_address),
-                                         port->write_urb->transfer_buffer,
-                                         length,
-                                         kobil_write_callback,
-                                         port,
-                                         8
-                               );
+                       /* copy data to transfer buffer */
+                       memcpy(port->write_urb->transfer_buffer,
+                                       priv->buf + priv->cur_pos, length);
+                       usb_fill_int_urb(port->write_urb,
+                                 port->serial->dev,
+                                 usb_sndintpipe(port->serial->dev,
+                                       priv->write_int_endpoint_address),
+                                 port->write_urb->transfer_buffer,
+                                 length,
+                                 kobil_write_callback,
+                                 port,
+                                 8
+                       );
 
                        priv->cur_pos = priv->cur_pos + length;
-                       result = usb_submit_urb( port->write_urb, GFP_NOIO );
-                       dbg("%s - port %d Send write URB returns: %i", __func__, port->number, result);
+                       result = usb_submit_urb(port->write_urb, GFP_NOIO);
+                       dbg("%s - port %d Send write URB returns: %i",
+                                       __func__, port->number, result);
                        todo = priv->filled - priv->cur_pos;
 
-                       if (todo > 0) {
+                       if (todo > 0)
                                msleep(24);
-                       }
+               }
 
-               } // end while
-               
                priv->filled = 0;
                priv->cur_pos = 0;
 
-               // someone sets the dev to 0 if the close method has been called
+               /* someone sets the dev to 0 if the close method
+                  has been called */
                port->interrupt_in_urb->dev = port->serial->dev;
-               
-               // start reading (except TWIN and KAAN SIM)
-               if ( (priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID) || (priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID) ) {
-                       // someone sets the dev to 0 if the close method has been called
+
+               /* start reading (except TWIN and KAAN SIM) */
+               if (priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID ||
+                       priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID) {
+                       /* someone sets the dev to 0 if the close method has
+                          been called */
                        port->interrupt_in_urb->dev = port->serial->dev;
-                       
-                       result = usb_submit_urb( port->interrupt_in_urb, GFP_NOIO ); 
-                       dbg("%s - port %d Send read URB returns: %i", __func__, port->number, result);
+
+                       result = usb_submit_urb(port->interrupt_in_urb,
+                                                               GFP_NOIO);
+                       dbg("%s - port %d Send read URB returns: %i",
+                                       __func__, port->number, result);
                }
        }
        return count;
 }
 
 
-static int kobil_write_room (struct tty_struct *tty)
+static int kobil_write_room(struct tty_struct *tty)
 {
-       //dbg("%s - port %d", __func__, port->number);
+       /* dbg("%s - port %d", __func__, port->number); */
        /* FIXME */
        return 8;
 }
@@ -492,34 +519,34 @@ static int kobil_write_room (struct tty_struct *tty)
 static int kobil_tiocmget(struct tty_struct *tty, struct file *file)
 {
        struct usb_serial_port *port = tty->driver_data;
-       struct kobil_private * priv;
+       struct kobil_private *priv;
        int result;
        unsigned char *transfer_buffer;
        int transfer_buffer_length = 8;
 
        priv = usb_get_serial_port_data(port);
-       if ((priv->device_type == KOBIL_USBTWIN_PRODUCT_ID) || (priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID)) {
-               // This device doesn't support ioctl calls
+       if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID
+                       || priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) {
+               /* This device doesn't support ioctl calls */
                return -EINVAL;
        }
 
-       // allocate memory for transfer buffer
+       /* allocate memory for transfer buffer */
        transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL);
-       if (!transfer_buffer) {
+       if (!transfer_buffer)
                return -ENOMEM;
-       }
 
-       result = usb_control_msg( port->serial->dev, 
-                                 usb_rcvctrlpipe(port->serial->dev, 0 ), 
-                                 SUSBCRequest_GetStatusLineState,
-                                 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_IN,
-                                 0,
-                                 0,
-                                 transfer_buffer,
-                                 transfer_buffer_length,
-                                 KOBIL_TIMEOUT);
-
-       dbg("%s - port %d Send get_status_line_state URB returns: %i. Statusline: %02x", 
+       result = usb_control_msg(port->serial->dev,
+                         usb_rcvctrlpipe(port->serial->dev, 0),
+                         SUSBCRequest_GetStatusLineState,
+                         USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_IN,
+                         0,
+                         0,
+                         transfer_buffer,
+                         transfer_buffer_length,
+                         KOBIL_TIMEOUT);
+
+       dbg("%s - port %d Send get_status_line_state URB returns: %i. Statusline: %02x",
            __func__, port->number, result, transfer_buffer[0]);
 
        result = 0;
@@ -533,7 +560,7 @@ static int kobil_tiocmset(struct tty_struct *tty, struct file *file,
                           unsigned int set, unsigned int clear)
 {
        struct usb_serial_port *port = tty->driver_data;
-       struct kobil_private * priv;
+       struct kobil_private *priv;
        int result;
        int dtr = 0;
        int rts = 0;
@@ -542,16 +569,16 @@ static int kobil_tiocmset(struct tty_struct *tty, struct file *file,
 
        /* FIXME: locking ? */
        priv = usb_get_serial_port_data(port);
-       if ((priv->device_type == KOBIL_USBTWIN_PRODUCT_ID) || (priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID)) {
-               // This device doesn't support ioctl calls
+       if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID
+               || priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) {
+               /* This device doesn't support ioctl calls */
                return -EINVAL;
        }
 
-       // allocate memory for transfer buffer
+       /* allocate memory for transfer buffer */
        transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL);
-       if (! transfer_buffer) {
+       if (!transfer_buffer)
                return -ENOMEM;
-       }
 
        if (set & TIOCM_RTS)
                rts = 1;
@@ -564,34 +591,39 @@ static int kobil_tiocmset(struct tty_struct *tty, struct file *file,
 
        if (priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID) {
                if (dtr != 0)
-                       dbg("%s - port %d Setting DTR", __func__, port->number);
+                       dbg("%s - port %d Setting DTR",
+                                               __func__, port->number);
                else
-                       dbg("%s - port %d Clearing DTR", __func__, port->number);
-               result = usb_control_msg( port->serial->dev, 
-                                         usb_rcvctrlpipe(port->serial->dev, 0 ), 
-                                         SUSBCRequest_SetStatusLinesOrQueues,
-                                         USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
-                                         ((dtr != 0) ? SUSBCR_SSL_SETDTR : SUSBCR_SSL_CLRDTR),
-                                         0,
-                                         transfer_buffer,
-                                         0,
-                                         KOBIL_TIMEOUT);
+                       dbg("%s - port %d Clearing DTR",
+                                               __func__, port->number);
+               result = usb_control_msg(port->serial->dev,
+                         usb_rcvctrlpipe(port->serial->dev, 0),
+                         SUSBCRequest_SetStatusLinesOrQueues,
+                         USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
+                         ((dtr != 0) ? SUSBCR_SSL_SETDTR : SUSBCR_SSL_CLRDTR),
+                         0,
+                         transfer_buffer,
+                         0,
+                         KOBIL_TIMEOUT);
        } else {
                if (rts != 0)
-                       dbg("%s - port %d Setting RTS", __func__, port->number);
+                       dbg("%s - port %d Setting RTS",
+                                               __func__, port->number);
                else
-                       dbg("%s - port %d Clearing RTS", __func__, port->number);
-               result = usb_control_msg( port->serial->dev, 
-                                         usb_rcvctrlpipe(port->serial->dev, 0 ), 
-                                         SUSBCRequest_SetStatusLinesOrQueues,
-                                         USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
-                                         ((rts != 0) ? SUSBCR_SSL_SETRTS : SUSBCR_SSL_CLRRTS),
-                                         0,
-                                         transfer_buffer,
-                                         0,
-                                         KOBIL_TIMEOUT);
+                       dbg("%s - port %d Clearing RTS",
+                                               __func__, port->number);
+               result = usb_control_msg(port->serial->dev,
+                       usb_rcvctrlpipe(port->serial->dev, 0),
+                       SUSBCRequest_SetStatusLinesOrQueues,
+                       USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
+                       ((rts != 0) ? SUSBCR_SSL_SETRTS : SUSBCR_SSL_CLRRTS),
+                       0,
+                       transfer_buffer,
+                       0,
+                       KOBIL_TIMEOUT);
        }
-       dbg("%s - port %d Send set_status_line URB returns: %i", __func__, port->number, result);
+       dbg("%s - port %d Send set_status_line URB returns: %i",
+                                       __func__, port->number, result);
        kfree(transfer_buffer);
        return (result < 0) ? result : 0;
 }
@@ -599,32 +631,35 @@ static int kobil_tiocmset(struct tty_struct *tty, struct file *file,
 static void kobil_set_termios(struct tty_struct *tty,
                        struct usb_serial_port *port, struct ktermios *old)
 {
-       struct kobil_private * priv;
+       struct kobil_private *priv;
        int result;
        unsigned short urb_val = 0;
        int c_cflag = tty->termios->c_cflag;
        speed_t speed;
-       void * settings;
+       void *settings;
 
        priv = usb_get_serial_port_data(port);
-       if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID || priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID)
-               // This device doesn't support ioctl calls
+       if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID ||
+                       priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID)
+               /* This device doesn't support ioctl calls */
                return;
 
-       switch (speed = tty_get_baud_rate(tty)) {
-               case 1200:
-                       urb_val = SUSBCR_SBR_1200;
-                       break;
-               default:
-                       speed = 9600;
-               case 9600:
-                       urb_val = SUSBCR_SBR_9600;
-                       break;
+       speed = tty_get_baud_rate(tty);
+       switch (speed) {
+       case 1200:
+               urb_val = SUSBCR_SBR_1200;
+               break;
+       default:
+               speed = 9600;
+       case 9600:
+               urb_val = SUSBCR_SBR_9600;
+               break;
        }
-       urb_val |= (c_cflag & CSTOPB) ? SUSBCR_SPASB_2StopBits : SUSBCR_SPASB_1StopBit;
+       urb_val |= (c_cflag & CSTOPB) ? SUSBCR_SPASB_2StopBits :
+                                                       SUSBCR_SPASB_1StopBit;
 
        settings = kzalloc(50, GFP_KERNEL);
-       if (! settings)
+       if (!settings)
                return;
 
        sprintf(settings, "%d ", speed);
@@ -644,48 +679,50 @@ static void kobil_set_termios(struct tty_struct *tty,
        tty->termios->c_cflag &= ~CMSPAR;
        tty_encode_baud_rate(tty, speed, speed);
 
-       result = usb_control_msg( port->serial->dev,
-                                 usb_rcvctrlpipe(port->serial->dev, 0 ),
-                                 SUSBCRequest_SetBaudRateParityAndStopBits,
-                                 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
-                                 urb_val,
-                                 0,
-                                 settings,
-                                 0,
-                                 KOBIL_TIMEOUT
+       result = usb_control_msg(port->serial->dev,
+                 usb_rcvctrlpipe(port->serial->dev, 0),
+                 SUSBCRequest_SetBaudRateParityAndStopBits,
+                 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
+                 urb_val,
+                 0,
+                 settings,
+                 0,
+                 KOBIL_TIMEOUT
                );
        kfree(settings);
 }
 
-static int kobil_ioctl(struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg)
+static int kobil_ioctl(struct tty_struct *tty, struct file *file,
+                                       unsigned int cmd, unsigned long arg)
 {
        struct usb_serial_port *port = tty->driver_data;
-       struct kobil_private * priv = usb_get_serial_port_data(port);
+       struct kobil_private *priv = usb_get_serial_port_data(port);
        unsigned char *transfer_buffer;
        int transfer_buffer_length = 8;
        int result;
 
-       if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID || priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID)
-               // This device doesn't support ioctl calls
+       if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID ||
+                       priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID)
+               /* This device doesn't support ioctl calls */
                return 0;
 
        switch (cmd) {
        case TCFLSH:
                transfer_buffer = kmalloc(transfer_buffer_length, GFP_KERNEL);
-               if (! transfer_buffer)
-                       return -ENOBUFS;
-
-               result = usb_control_msg( port->serial->dev, 
-                                         usb_rcvctrlpipe(port->serial->dev, 0 ), 
-                                         SUSBCRequest_Misc,
-                                         USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
-                                         SUSBCR_MSC_ResetAllQueues,
-                                         0,
-                                         NULL,//transfer_buffer,
-                                         0,
-                                         KOBIL_TIMEOUT
+               if (!transfer_buffer)
+                       return -ENOBUFS;
+
+               result = usb_control_msg(port->serial->dev,
+                         usb_rcvctrlpipe(port->serial->dev, 0),
+                         SUSBCRequest_Misc,
+                         USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
+                         SUSBCR_MSC_ResetAllQueues,
+                         0,
+                         NULL, /* transfer_buffer, */
+                         0,
+                         KOBIL_TIMEOUT
                        );
-               
+
                dbg("%s - port %d Send reset_all_queues (FLUSH) URB returns: %i", __func__, port->number, result);
                kfree(transfer_buffer);
                return (result < 0) ? -EIO: 0;
@@ -694,14 +731,14 @@ static int kobil_ioctl(struct tty_struct *tty, struct file * file, unsigned int
        }
 }
 
-static int __init kobil_init (void)
+static int __init kobil_init(void)
 {
        int retval;
        retval = usb_serial_register(&kobil_device);
        if (retval)
                goto failed_usb_serial_register;
        retval = usb_register(&kobil_driver);
-       if (retval) 
+       if (retval)
                goto failed_usb_register;
 
        info(DRIVER_VERSION " " DRIVER_AUTHOR);
@@ -715,18 +752,18 @@ failed_usb_serial_register:
 }
 
 
-static void __exit kobil_exit (void)
+static void __exit kobil_exit(void)
 {
-       usb_deregister (&kobil_driver);
-       usb_serial_deregister (&kobil_device);
+       usb_deregister(&kobil_driver);
+       usb_serial_deregister(&kobil_device);
 }
 
 module_init(kobil_init);
 module_exit(kobil_exit);
 
-MODULE_AUTHOR( DRIVER_AUTHOR );
-MODULE_DESCRIPTION( DRIVER_DESC );
-MODULE_LICENSE( "GPL" );
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
 
 module_param(debug, bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(debug, "Debug enabled or not");