1 files changed, 118 insertions, 137 deletions

diff --git a/drivers/usb/serial/oti6858.c b/drivers/usb/serial/oti6858.c
index a9625c180dc3..81db5715ee25 100644
--- a/drivers/usb/serial/oti6858.c
+++ b/drivers/usb/serial/oti6858.c
@@ -25,7 +25,8 @@
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License.
  *
- * See Documentation/usb/usb-serial.txt for more information on using this driver
+ * See Documentation/usb/usb-serial.txt for more information on using this
+ * driver
  *
  * TODO:
  *  - implement correct flushing for ioctls and oti6858_close()
@@ -49,7 +50,7 @@
 #include <linux/spinlock.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include "oti6858.h"
 
 #define OTI6858_DESCRIPTION \
@@ -135,27 +136,28 @@ struct oti6858_control_pkt {
 
 #define OTI6858_CTRL_PKT_SIZE   sizeof(struct oti6858_control_pkt)
 #define OTI6858_CTRL_EQUALS_PENDING(a, priv) \
-        (    ((a)->divisor == (priv)->pending_setup.divisor) \
+        (((a)->divisor == (priv)->pending_setup.divisor) \
           && ((a)->control == (priv)->pending_setup.control) \
-          && ((a)->frame_fmt == (priv)->pending_setup.frame_fmt) )
+          && ((a)->frame_fmt == (priv)->pending_setup.frame_fmt))
 
 /* function prototypes */
-static int oti6858_open(struct usb_serial_port *port, struct file *filp);
-static void oti6858_close(struct usb_serial_port *port, struct file *filp);
-static void oti6858_set_termios(struct usb_serial_port *port,
-                                struct ktermios *old);
-static int oti6858_ioctl(struct usb_serial_port *port, struct file *file,
+static int oti6858_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp);
+static void oti6858_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp);
+static void oti6858_set_termios(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct ktermios *old);
+static int oti6858_ioctl(struct tty_struct *tty, struct file *file,
                         unsigned int cmd, unsigned long arg);
 static void oti6858_read_int_callback(struct urb *urb);
 static void oti6858_read_bulk_callback(struct urb *urb);
 static void oti6858_write_bulk_callback(struct urb *urb);
-static int oti6858_write(struct usb_serial_port *port,
+static int oti6858_write(struct tty_struct *tty, struct usb_serial_port *port,
                         const unsigned char *buf, int count);
-static int oti6858_write_room(struct usb_serial_port *port);
-static void oti6858_break_ctl(struct usb_serial_port *port, int break_state);
-static int oti6858_chars_in_buffer(struct usb_serial_port *port);
-static int oti6858_tiocmget(struct usb_serial_port *port, struct file *file);
-static int oti6858_tiocmset(struct usb_serial_port *port, struct file *file,
+static int oti6858_write_room(struct tty_struct *tty);
+static int oti6858_chars_in_buffer(struct tty_struct *tty);
+static int oti6858_tiocmget(struct tty_struct *tty, struct file *file);
+static int oti6858_tiocmset(struct tty_struct *tty, struct file *file,
                                 unsigned int set, unsigned int clear);
 static int oti6858_startup(struct usb_serial *serial);
 static void oti6858_shutdown(struct usb_serial *serial);
@@ -184,7 +186,6 @@ static struct usb_serial_driver oti6858_device = {
         .close =                oti6858_close,
         .write =                oti6858_write,
         .ioctl =                oti6858_ioctl,
-        .break_ctl =            oti6858_break_ctl,
         .set_termios =          oti6858_set_termios,
         .tiocmget =             oti6858_tiocmget,
         .tiocmset =             oti6858_tiocmset,
@@ -220,7 +221,7 @@ struct oti6858_private {
         struct delayed_work delayed_setup_work;
 
         wait_queue_head_t intr_wait;
-        struct usb_serial_port *port;   /* USB port with which associated */
+        struct usb_serial_port *port;   /* USB port with which associated */
 };
 
 #undef dbg
@@ -229,7 +230,8 @@ struct oti6858_private {
 
 static void setup_line(struct work_struct *work)
 {
-        struct oti6858_private *priv = container_of(work, struct oti6858_private, delayed_setup_work.work);
+        struct oti6858_private *priv = container_of(work,
+                        struct oti6858_private, delayed_setup_work.work);
         struct usb_serial_port *port = priv->port;
         struct oti6858_control_pkt *new_setup;
         unsigned long flags;
@@ -237,10 +239,12 @@ static void setup_line(struct work_struct *work)
 
         dbg("%s(port = %d)", __func__, port->number);
 
-        if ((new_setup = kmalloc(OTI6858_CTRL_PKT_SIZE, GFP_KERNEL)) == NULL) {
+        new_setup = kmalloc(OTI6858_CTRL_PKT_SIZE, GFP_KERNEL);
+        if (new_setup == NULL) {
                 dev_err(&port->dev, "%s(): out of memory!\n", __func__);
                 /* we will try again */
-                schedule_delayed_work(&priv->delayed_setup_work, msecs_to_jiffies(2));
+                schedule_delayed_work(&priv->delayed_setup_work,
+                                                msecs_to_jiffies(2));
                 return;
         }
 
@@ -256,7 +260,8 @@ static void setup_line(struct work_struct *work)
                 dev_err(&port->dev, "%s(): error reading status\n", __func__);
                 kfree(new_setup);
                 /* we will try again */
-                schedule_delayed_work(&priv->delayed_setup_work, msecs_to_jiffies(2));
+                schedule_delayed_work(&priv->delayed_setup_work,
+                                                        msecs_to_jiffies(2));
                 return;
         }
 
@@ -297,7 +302,8 @@ static void setup_line(struct work_struct *work)
 
 void send_data(struct work_struct *work)
 {
-        struct oti6858_private *priv = container_of(work, struct oti6858_private, delayed_write_work.work);
+        struct oti6858_private *priv = container_of(work,
+                        struct oti6858_private, delayed_write_work.work);
         struct usb_serial_port *port = priv->port;
         int count = 0, result;
         unsigned long flags;
@@ -308,7 +314,8 @@ void send_data(struct work_struct *work)
         spin_lock_irqsave(&priv->lock, flags);
         if (priv->flags.write_urb_in_use) {
                 spin_unlock_irqrestore(&priv->lock, flags);
-                schedule_delayed_work(&priv->delayed_write_work, msecs_to_jiffies(2));
+                schedule_delayed_work(&priv->delayed_write_work,
+                                                msecs_to_jiffies(2));
                 return;
         }
         priv->flags.write_urb_in_use = 1;
@@ -359,8 +366,8 @@ void send_data(struct work_struct *work)
 
 static int oti6858_startup(struct usb_serial *serial)
 {
-        struct usb_serial_port *port = serial->port[0];
-        struct oti6858_private *priv;
+        struct usb_serial_port *port = serial->port[0];
+        struct oti6858_private *priv;
         int i;
 
         for (i = 0; i < serial->num_ports; ++i) {
@@ -375,8 +382,8 @@ static int oti6858_startup(struct usb_serial *serial)
 
                 spin_lock_init(&priv->lock);
                 init_waitqueue_head(&priv->intr_wait);
-//              INIT_WORK(&priv->setup_work, setup_line, serial->port[i]);
-//              INIT_WORK(&priv->write_work, send_data, serial->port[i]);
+/*              INIT_WORK(&priv->setup_work, setup_line, serial->port[i]); */
+/*              INIT_WORK(&priv->write_work, send_data, serial->port[i]); */
                 priv->port = port;
                 INIT_DELAYED_WORK(&priv->delayed_setup_work, setup_line);
                 INIT_DELAYED_WORK(&priv->delayed_write_work, send_data);
@@ -395,7 +402,7 @@ static int oti6858_startup(struct usb_serial *serial)
         return -ENOMEM;
 }
 
-static int oti6858_write(struct usb_serial_port *port,
+static int oti6858_write(struct tty_struct *tty, struct usb_serial_port *port,
                         const unsigned char *buf, int count)
 {
         struct oti6858_private *priv = usb_get_serial_port_data(port);
@@ -413,8 +420,9 @@ static int oti6858_write(struct usb_serial_port *port,
         return count;
 }
 
-static int oti6858_write_room(struct usb_serial_port *port)
+static int oti6858_write_room(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct oti6858_private *priv = usb_get_serial_port_data(port);
         int room = 0;
         unsigned long flags;
@@ -428,8 +436,9 @@ static int oti6858_write_room(struct usb_serial_port *port)
         return room;
 }
 
-static int oti6858_chars_in_buffer(struct usb_serial_port *port)
+static int oti6858_chars_in_buffer(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct oti6858_private *priv = usb_get_serial_port_data(port);
         int chars = 0;
         unsigned long flags;
@@ -443,8 +452,8 @@ static int oti6858_chars_in_buffer(struct usb_serial_port *port)
         return chars;
 }
 
-static void oti6858_set_termios(struct usb_serial_port *port,
-                                struct ktermios *old_termios)
+static void oti6858_set_termios(struct tty_struct *tty,
+                struct usb_serial_port *port, struct ktermios *old_termios)
 {
         struct oti6858_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
@@ -455,22 +464,22 @@ static void oti6858_set_termios(struct usb_serial_port *port,
 
         dbg("%s(port = %d)", __func__, port->number);
 
-        if (!port->tty || !port->tty->termios) {
+        if (!tty) {
                 dbg("%s(): no tty structures", __func__);
                 return;
         }
 
         spin_lock_irqsave(&priv->lock, flags);
         if (!priv->flags.termios_initialized) {
-                *(port->tty->termios) = tty_std_termios;
-                port->tty->termios->c_cflag = B38400 | CS8 | CREAD | HUPCL | CLOCAL;
+                *(tty->termios) = tty_std_termios;
+                tty->termios->c_cflag = B38400 | CS8 | CREAD | HUPCL | CLOCAL;
+                tty->termios->c_ispeed = 38400;
+                tty->termios->c_ospeed = 38400;
                 priv->flags.termios_initialized = 1;
-                port->tty->termios->c_ispeed = 38400;
-                port->tty->termios->c_ospeed = 38400;
         }
         spin_unlock_irqrestore(&priv->lock, flags);
 
-        cflag = port->tty->termios->c_cflag;
+        cflag = tty->termios->c_cflag;
 
         spin_lock_irqsave(&priv->lock, flags);
         divisor = priv->pending_setup.divisor;
@@ -480,19 +489,19 @@ static void oti6858_set_termios(struct usb_serial_port *port,
 
         frame_fmt &= ~FMT_DATA_BITS_MASK;
         switch (cflag & CSIZE) {
-                case CS5:
-                        frame_fmt |= FMT_DATA_BITS_5;
-                        break;
-                case CS6:
-                        frame_fmt |= FMT_DATA_BITS_6;
-                        break;
-                case CS7:
-                        frame_fmt |= FMT_DATA_BITS_7;
-                        break;
-                default:
-                case CS8:
-                        frame_fmt |= FMT_DATA_BITS_8;
-                        break;
+        case CS5:
+                frame_fmt |= FMT_DATA_BITS_5;
+                break;
+        case CS6:
+                frame_fmt |= FMT_DATA_BITS_6;
+                break;
+        case CS7:
+                frame_fmt |= FMT_DATA_BITS_7;
+                break;
+        default:
+        case CS8:
+                frame_fmt |= FMT_DATA_BITS_8;
+                break;
         }
 
         /* manufacturer claims that this device can work with baud rates
@@ -500,7 +509,7 @@ static void oti6858_set_termios(struct usb_serial_port *port,
          * guarantee that any other baud rate will work (especially
          * the higher ones)
          */
-        br = tty_get_baud_rate(port->tty);
+        br = tty_get_baud_rate(tty);
         if (br == 0) {
                 divisor = 0;
         } else {
@@ -511,23 +520,21 @@ static void oti6858_set_termios(struct usb_serial_port *port,
                 new_divisor = (96000000 + 8 * br) / (16 * br);
                 real_br = 96000000 / (16 * new_divisor);
                 divisor = cpu_to_le16(new_divisor);
-                tty_encode_baud_rate(port->tty, real_br, real_br);
+                tty_encode_baud_rate(tty, real_br, real_br);
         }
 
         frame_fmt &= ~FMT_STOP_BITS_MASK;
-        if ((cflag & CSTOPB) != 0) {
+        if ((cflag & CSTOPB) != 0)
                 frame_fmt |= FMT_STOP_BITS_2;
-        } else {
+        else
                 frame_fmt |= FMT_STOP_BITS_1;
-        }
 
         frame_fmt &= ~FMT_PARITY_MASK;
         if ((cflag & PARENB) != 0) {
-                if ((cflag & PARODD) != 0) {
+                if ((cflag & PARODD) != 0)
                         frame_fmt |= FMT_PARITY_ODD;
-                } else {
+                else
                         frame_fmt |= FMT_PARITY_EVEN;
-                }
         } else {
                 frame_fmt |= FMT_PARITY_NONE;
         }
@@ -564,7 +571,8 @@ static void oti6858_set_termios(struct usb_serial_port *port,
         spin_unlock_irqrestore(&priv->lock, flags);
 }
 
-static int oti6858_open(struct usb_serial_port *port, struct file *filp)
+static int oti6858_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct oti6858_private *priv = usb_get_serial_port_data(port);
         struct ktermios tmp_termios;
@@ -578,10 +586,11 @@ static int oti6858_open(struct usb_serial_port *port, struct file *filp)
         usb_clear_halt(serial->dev, port->write_urb->pipe);
         usb_clear_halt(serial->dev, port->read_urb->pipe);
 
-        if (port->open_count != 1)
+        if (port->port.count != 1)
                 return 0;
 
-        if ((buf = kmalloc(OTI6858_CTRL_PKT_SIZE, GFP_KERNEL)) == NULL) {
+        buf = kmalloc(OTI6858_CTRL_PKT_SIZE, GFP_KERNEL);
+        if (buf == NULL) {
                 dev_err(&port->dev, "%s(): out of memory!\n", __func__);
                 return -ENOMEM;
         }
@@ -617,18 +626,19 @@ static int oti6858_open(struct usb_serial_port *port, struct file *filp)
         if (result != 0) {
                 dev_err(&port->dev, "%s(): usb_submit_urb() failed"
                                " with error %d\n", __func__, result);
-                oti6858_close(port, NULL);
+                oti6858_close(tty, port, NULL);
                 return -EPROTO;
         }
 
         /* setup termios */
-        if (port->tty)
-                oti6858_set_termios(port, &tmp_termios);
+        if (tty)
+                oti6858_set_termios(tty, port, &tmp_termios);
 
         return 0;
 }
 
-static void oti6858_close(struct usb_serial_port *port, struct file *filp)
+static void oti6858_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct oti6858_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
@@ -641,7 +651,7 @@ static void oti6858_close(struct usb_serial_port *port, struct file *filp)
         spin_lock_irqsave(&priv->lock, flags);
         timeout = 30 * HZ;      /* PL2303_CLOSING_WAIT */
         init_waitqueue_entry(&wait, current);
-        add_wait_queue(&port->tty->write_wait, &wait);
+        add_wait_queue(&tty->write_wait, &wait);
         dbg("%s(): entering wait loop", __func__);
         for (;;) {
                 set_current_state(TASK_INTERRUPTIBLE);
@@ -654,7 +664,7 @@ static void oti6858_close(struct usb_serial_port *port, struct file *filp)
                 spin_lock_irqsave(&priv->lock, flags);
         }
         set_current_state(TASK_RUNNING);
-        remove_wait_queue(&port->tty->write_wait, &wait);
+        remove_wait_queue(&tty->write_wait, &wait);
         dbg("%s(): after wait loop", __func__);
 
         /* clear out any remaining data in the buffer */
@@ -669,7 +679,7 @@ static void oti6858_close(struct usb_serial_port *port, struct file *filp)
         /* data is in the buffer to compute a delay */
         /* that is not unnecessarily long) */
         /* FIXME
-        bps = tty_get_baud_rate(port->tty);
+        bps = tty_get_baud_rate(tty);
         if (bps > 1200)
                 timeout = max((HZ*2560)/bps,HZ/10);
         else
@@ -690,7 +700,7 @@ static void oti6858_close(struct usb_serial_port *port, struct file *filp)
         usb_kill_urb(port->interrupt_in_urb);
 
         /*
-        if (port->tty && (port->tty->termios->c_cflag) & HUPCL) {
+        if (tty && (tty->termios->c_cflag) & HUPCL) {
                 // drop DTR and RTS
                 spin_lock_irqsave(&priv->lock, flags);
                 priv->pending_setup.control &= ~CONTROL_MASK;
@@ -699,9 +709,10 @@ static void oti6858_close(struct usb_serial_port *port, struct file *filp)
         */
 }
 
-static int oti6858_tiocmset(struct usb_serial_port *port, struct file *file,
+static int oti6858_tiocmset(struct tty_struct *tty, struct file *file,
                                 unsigned int set, unsigned int clear)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct oti6858_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
         u8 control;
@@ -724,16 +735,16 @@ static int oti6858_tiocmset(struct usb_serial_port *port, struct file *file,
         if ((clear & TIOCM_DTR) != 0)
                 control &= ~CONTROL_DTR_HIGH;
 
-        if (control != priv->pending_setup.control) {
+        if (control != priv->pending_setup.control)
                 priv->pending_setup.control = control;
-        }
-        spin_unlock_irqrestore(&priv->lock, flags);
 
+        spin_unlock_irqrestore(&priv->lock, flags);
         return 0;
 }
 
-static int oti6858_tiocmget(struct usb_serial_port *port, struct file *file)
+static int oti6858_tiocmget(struct tty_struct *tty, struct file *file)
 {
+        struct usb_serial_port *port = tty->driver_data;
         struct oti6858_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
         unsigned pin_state;
@@ -779,7 +790,8 @@ static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
         spin_unlock_irqrestore(&priv->lock, flags);
 
         while (1) {
-                wait_event_interruptible(priv->intr_wait, priv->status.pin_state != prev);
+                wait_event_interruptible(priv->intr_wait,
+                                        priv->status.pin_state != prev);
                 if (signal_pending(current))
                         return -ERESTARTSYS;
 
@@ -789,12 +801,11 @@ static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
 
                 changed = prev ^ status;
                 /* FIXME: check if this is correct (active high/low) */
-                if (    ((arg & TIOCM_RNG) && (changed & PIN_RI)) ||
-                        ((arg & TIOCM_DSR) && (changed & PIN_DSR)) ||
-                        ((arg & TIOCM_CD)  && (changed & PIN_DCD)) ||
-                        ((arg & TIOCM_CTS) && (changed & PIN_CTS))) {
-                                return 0;
-                }
+                if (((arg & TIOCM_RNG) && (changed & PIN_RI)) ||
+                    ((arg & TIOCM_DSR) && (changed & PIN_DSR)) ||
+                    ((arg & TIOCM_CD)  && (changed & PIN_DCD)) ||
+                    ((arg & TIOCM_CTS) && (changed & PIN_CTS)))
+                        return 0;
                 prev = status;
         }
 
@@ -802,56 +813,25 @@ static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
         return 0;
 }
 
-static int oti6858_ioctl(struct usb_serial_port *port, struct file *file,
+static int oti6858_ioctl(struct tty_struct *tty, struct file *file,
                         unsigned int cmd, unsigned long arg)
 {
-        void __user *user_arg = (void __user *) arg;
-        unsigned int x;
+        struct usb_serial_port *port = tty->driver_data;
 
         dbg("%s(port = %d, cmd = 0x%04x, arg = 0x%08lx)",
                                 __func__, port->number, cmd, arg);
 
         switch (cmd) {
-                case TIOCMBIS:
-                        if (copy_from_user(&x, user_arg, sizeof(x)))
-                                return -EFAULT;
-                        return oti6858_tiocmset(port, NULL, x, 0);
-
-                case TIOCMBIC:
-                        if (copy_from_user(&x, user_arg, sizeof(x)))
-                                return -EFAULT;
-                        return oti6858_tiocmset(port, NULL, 0, x);
-
-                case TIOCMIWAIT:
-                        dbg("%s(): TIOCMIWAIT", __func__);
-                        return wait_modem_info(port, arg);
-
-                default:
-                        dbg("%s(): 0x%04x not supported", __func__, cmd);
-                        break;
+        case TIOCMIWAIT:
+                dbg("%s(): TIOCMIWAIT", __func__);
+                return wait_modem_info(port, arg);
+        default:
+                dbg("%s(): 0x%04x not supported", __func__, cmd);
+                break;
         }
-
         return -ENOIOCTLCMD;
 }
 
-static void oti6858_break_ctl(struct usb_serial_port *port, int break_state)
-{
-        int state;
-
-        dbg("%s(port = %d)", __func__, port->number);
-
-        state = (break_state == 0) ? 0 : 1;
-        dbg("%s(): turning break %s", __func__, state ? "on" : "off");
-
-        /* FIXME */
-/*
-        result = usb_control_msg (serial->dev, usb_sndctrlpipe (serial->dev, 0),
-                                  BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
-                                  0, NULL, 0, 100);
-        if (result != 0)
-                dbg("%s(): error sending break", __func__);
- */
-}
 
 static void oti6858_shutdown(struct usb_serial *serial)
 {
@@ -964,7 +944,7 @@ static void oti6858_read_int_callback(struct urb *urb)
                 spin_lock_irqsave(&priv->lock, flags);
                 if (priv->flags.write_urb_in_use == 0
                                 && oti6858_buf_data_avail(priv->buf) != 0) {
-                        schedule_delayed_work(&priv->delayed_write_work,0);
+                        schedule_delayed_work(&priv->delayed_write_work, 0);
                         resubmit = 0;
                 }
                 spin_unlock_irqrestore(&priv->lock, flags);
@@ -973,7 +953,7 @@ static void oti6858_read_int_callback(struct urb *urb)
         if (resubmit) {
                 int result;
 
-//              dbg("%s(): submitting interrupt urb", __func__);
+/*              dbg("%s(): submitting interrupt urb", __func__); */
                 urb->dev = port->serial->dev;
                 result = usb_submit_urb(urb, GFP_ATOMIC);
                 if (result != 0) {
@@ -1002,14 +982,16 @@ static void oti6858_read_bulk_callback(struct urb *urb)
         spin_unlock_irqrestore(&priv->lock, flags);
 
         if (status != 0) {
-                if (!port->open_count) {
+                if (!port->port.count) {
                         dbg("%s(): port is closed, exiting", __func__);
                         return;
                 }
                 /*
                 if (status == -EPROTO) {
-                        // PL2303 mysteriously fails with -EPROTO reschedule the read
-                        dbg("%s - caught -EPROTO, resubmitting the urb", __func__);
+                        * PL2303 mysteriously fails with -EPROTO reschedule
+                           the read *
+                        dbg("%s - caught -EPROTO, resubmitting the urb",
+                                                                __func__);
                         result = usb_submit_urb(urb, GFP_ATOMIC);
                         if (result)
                                 dev_err(&urb->dev->dev, "%s - failed resubmitting read urb, error %d\n", __func__, result);
@@ -1020,14 +1002,14 @@ static void oti6858_read_bulk_callback(struct urb *urb)
                 return;
         }
 
-        tty = port->tty;
+        tty = port->port.tty;
         if (tty != NULL && urb->actual_length > 0) {
                 tty_insert_flip_string(tty, data, urb->actual_length);
                 tty_flip_buffer_push(tty);
         }
 
-        // schedule the interrupt urb if we are still open */
-        if (port->open_count != 0) {
+        /* schedule the interrupt urb if we are still open */
+        if (port->port.count != 0) {
                 port->interrupt_in_urb->dev = port->serial->dev;
                 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
                 if (result != 0) {
@@ -1078,7 +1060,7 @@ static void oti6858_write_bulk_callback(struct urb *urb)
 
         priv->flags.write_urb_in_use = 0;
 
-        // schedule the interrupt urb if we are still open */
+        /* schedule the interrupt urb if we are still open */
         port->interrupt_in_urb->dev = port->serial->dev;
         dbg("%s(): submitting interrupt urb", __func__);
         result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
@@ -1153,7 +1135,7 @@ static unsigned int oti6858_buf_data_avail(struct oti6858_buf *pb)
 {
         if (pb == NULL)
                 return 0;
-        return ((pb->buf_size + pb->buf_put - pb->buf_get) % pb->buf_size);
+        return (pb->buf_size + pb->buf_put - pb->buf_get) % pb->buf_size;
 }
 
 /*
@@ -1166,7 +1148,7 @@ static unsigned int oti6858_buf_space_avail(struct oti6858_buf *pb)
 {
         if (pb == NULL)
                 return 0;
-        return ((pb->buf_size + pb->buf_get - pb->buf_put - 1) % pb->buf_size);
+        return (pb->buf_size + pb->buf_get - pb->buf_put - 1) % pb->buf_size;
 }
 
 /*
@@ -1253,13 +1235,12 @@ static int __init oti6858_init(void)
 {
         int retval;
 
-        if ((retval = usb_serial_register(&oti6858_device)) == 0) {
-                if ((retval = usb_register(&oti6858_driver)) != 0)
+        retval = usb_serial_register(&oti6858_device);
+        if (retval == 0) {
+                retval = usb_register(&oti6858_driver);
+                if (retval)
                         usb_serial_deregister(&oti6858_device);
-                else
-                        return 0;
         }
-
         return retval;
 }