rc = dgnc_start();
 
        if (rc < 0) {
-               return(rc);
+               return rc;
        }
 
        /*
        }
 
        DPR_INIT(("Finished init_module. Returning %d\n", rc));
-       return (rc);
+       return rc;
 }
 
 
                        if (rc <= 0) {
                                APR(("Can't register dgnc driver device (%d)\n", rc));
                                rc = -ENXIO;
-                               return(rc);
+                               return rc;
                        }
                        dgnc_Major = rc;
 
 
                if (rc < 0) {
                        APR(("tty preinit - not enough memory (%d)\n", rc));
-                       return(rc);
+                       return rc;
                }
 
                /* Start the poller */
                dgnc_driver_state = DRIVER_READY;
        }
 
-       return(rc);
+       return rc;
 }
 
 /*
        (struct dgnc_board *) kzalloc(sizeof(struct dgnc_board), GFP_KERNEL);
        if (!brd) {
                APR(("memory allocation for board structure failed\n"));
-               return(-ENOMEM);
+               return -ENOMEM;
        }
 
        /* make a temporary message buffer for the boot messages */
        if (!brd->msgbuf) {
                kfree(brd);
                APR(("memory allocation for board msgbuf failed\n"));
-               return(-ENOMEM);
+               return -ENOMEM;
        }
 
        /* store the info for the board we've found */
 
        default:
                APR(("Did not find any compatible Neo or Classic PCI boards in system.\n"));
-               return (-ENXIO);
+               return -ENXIO;
 
        }
 
 
        wake_up_interruptible(&brd->state_wait);
 
-       return(0);
+       return 0;
 
 failed:
 
-       return (-ENXIO);
+       return -ENXIO;
 
 }
 
        DPR_INIT(("dgnc_finalize_board_init() - start\n"));
 
        if (!brd || brd->magic != DGNC_BOARD_MAGIC)
-               return(-ENODEV);
+               return -ENODEV;
 
        DPR_INIT(("dgnc_finalize_board_init() - start #2\n"));
 
                        DPR_INIT(("Requested and received usage of IRQ %d\n", brd->irq));
                }
        }
-       return(rc);
+       return rc;
 }
 
 /*
 {
        current->state = TASK_INTERRUPTIBLE;
        schedule_timeout((ms * HZ) / 1000);
-       return (signal_pending(current));
+       return signal_pending(current);
 }
 
 
 {
        switch(cmd) {
 
-       case TCGETA:            return("TCGETA");
-       case TCGETS:            return("TCGETS");
-       case TCSETA:            return("TCSETA");
-       case TCSETS:            return("TCSETS");
-       case TCSETAW:           return("TCSETAW");
-       case TCSETSW:           return("TCSETSW");
-       case TCSETAF:           return("TCSETAF");
-       case TCSETSF:           return("TCSETSF");
-       case TCSBRK:            return("TCSBRK");
-       case TCXONC:            return("TCXONC");
-       case TCFLSH:            return("TCFLSH");
-       case TIOCGSID:          return("TIOCGSID");
-
-       case TIOCGETD:          return("TIOCGETD");
-       case TIOCSETD:          return("TIOCSETD");
-       case TIOCGWINSZ:        return("TIOCGWINSZ");
-       case TIOCSWINSZ:        return("TIOCSWINSZ");
-
-       case TIOCMGET:          return("TIOCMGET");
-       case TIOCMSET:          return("TIOCMSET");
-       case TIOCMBIS:          return("TIOCMBIS");
-       case TIOCMBIC:          return("TIOCMBIC");
+       case TCGETA:            return "TCGETA";
+       case TCGETS:            return "TCGETS";
+       case TCSETA:            return "TCSETA";
+       case TCSETS:            return "TCSETS";
+       case TCSETAW:           return "TCSETAW";
+       case TCSETSW:           return "TCSETSW";
+       case TCSETAF:           return "TCSETAF";
+       case TCSETSF:           return "TCSETSF";
+       case TCSBRK:            return "TCSBRK";
+       case TCXONC:            return "TCXONC";
+       case TCFLSH:            return "TCFLSH";
+       case TIOCGSID:          return "TIOCGSID";
+
+       case TIOCGETD:          return "TIOCGETD";
+       case TIOCSETD:          return "TIOCSETD";
+       case TIOCGWINSZ:        return "TIOCGWINSZ";
+       case TIOCSWINSZ:        return "TIOCSWINSZ";
+
+       case TIOCMGET:          return "TIOCMGET";
+       case TIOCMSET:          return "TIOCMSET";
+       case TIOCMBIS:          return "TIOCMBIS";
+       case TIOCMBIC:          return "TIOCMBIC";
 
        /* from digi.h */
-       case DIGI_SETA:         return("DIGI_SETA");
-       case DIGI_SETAW:        return("DIGI_SETAW");
-       case DIGI_SETAF:        return("DIGI_SETAF");
-       case DIGI_SETFLOW:      return("DIGI_SETFLOW");
-       case DIGI_SETAFLOW:     return("DIGI_SETAFLOW");
-       case DIGI_GETFLOW:      return("DIGI_GETFLOW");
-       case DIGI_GETAFLOW:     return("DIGI_GETAFLOW");
-       case DIGI_GETA:         return("DIGI_GETA");
-       case DIGI_GEDELAY:      return("DIGI_GEDELAY");
-       case DIGI_SEDELAY:      return("DIGI_SEDELAY");
-       case DIGI_GETCUSTOMBAUD: return("DIGI_GETCUSTOMBAUD");
-       case DIGI_SETCUSTOMBAUD: return("DIGI_SETCUSTOMBAUD");
-       case TIOCMODG:          return("TIOCMODG");
-       case TIOCMODS:          return("TIOCMODS");
-       case TIOCSDTR:          return("TIOCSDTR");
-       case TIOCCDTR:          return("TIOCCDTR");
-
-       default:                return("unknown");
+       case DIGI_SETA:         return "DIGI_SETA";
+       case DIGI_SETAW:        return "DIGI_SETAW";
+       case DIGI_SETAF:        return "DIGI_SETAF";
+       case DIGI_SETFLOW:      return "DIGI_SETFLOW";
+       case DIGI_SETAFLOW:     return "DIGI_SETAFLOW";
+       case DIGI_GETFLOW:      return "DIGI_GETFLOW";
+       case DIGI_GETAFLOW:     return "DIGI_GETAFLOW";
+       case DIGI_GETA:         return "DIGI_GETA";
+       case DIGI_GEDELAY:      return "DIGI_GEDELAY";
+       case DIGI_SEDELAY:      return "DIGI_SEDELAY";
+       case DIGI_GETCUSTOMBAUD: return "DIGI_GETCUSTOMBAUD";
+       case DIGI_SETCUSTOMBAUD: return "DIGI_SETCUSTOMBAUD";
+       case TIOCMODG:          return "TIOCMODG";
+       case TIOCMODS:          return "TIOCMODS";
+       case TIOCSDTR:          return "TIOCSDTR";
+       case TIOCCDTR:          return "TIOCCDTR";
+
+       default:                return "unknown";
        }
 }
 
 
 #define DGNC_VERIFY_BOARD(p, bd)                       \
        if (!p)                                         \
-               return (0);                             \
+               return 0;                               \
                                                        \
        bd = dev_get_drvdata(p);                        \
        if (!bd || bd->magic != DGNC_BOARD_MAGIC)       \
-               return (0);                             \
+               return 0;                               \
        if (bd->state != BOARD_READY)                   \
-               return (0);                             \
+               return 0;                               \
 
 
 
        struct un_t *un;
 
        if (!d)
-               return (0);
+               return 0;
        un = (struct un_t *) dev_get_drvdata(d);
        if (!un || un->magic != DGNC_UNIT_MAGIC)
-               return (0);
+               return 0;
        ch = un->un_ch;
        if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
-               return (0);
+               return 0;
        bd = ch->ch_bd;
        if (!bd || bd->magic != DGNC_BOARD_MAGIC)
-               return (0);
+               return 0;
        if (bd->state != BOARD_READY)
-               return (0);
+               return 0;
 
        return snprintf(buf, PAGE_SIZE, "%s", un->un_open_count ? "Open" : "Closed");
 }
        struct un_t *un;
 
        if (!d)
-               return (0);
+               return 0;
        un = (struct un_t *) dev_get_drvdata(d);
        if (!un || un->magic != DGNC_UNIT_MAGIC)
-               return (0);
+               return 0;
        ch = un->un_ch;
        if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
-               return (0);
+               return 0;
        bd = ch->ch_bd;
        if (!bd || bd->magic != DGNC_BOARD_MAGIC)
-               return (0);
+               return 0;
        if (bd->state != BOARD_READY)
-               return (0);
+               return 0;
 
        return snprintf(buf, PAGE_SIZE, "%d\n", ch->ch_old_baud);
 }
        struct un_t *un;
 
        if (!d)
-               return (0);
+               return 0;
        un = (struct un_t *) dev_get_drvdata(d);
        if (!un || un->magic != DGNC_UNIT_MAGIC)
-               return (0);
+               return 0;
        ch = un->un_ch;
        if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
-               return (0);
+               return 0;
        bd = ch->ch_bd;
        if (!bd || bd->magic != DGNC_BOARD_MAGIC)
-               return (0);
+               return 0;
        if (bd->state != BOARD_READY)
-               return (0);
+               return 0;
 
        if (ch->ch_open_count) {
                return snprintf(buf, PAGE_SIZE, "%s %s %s %s %s %s\n",
        struct un_t *un;
 
        if (!d)
-               return (0);
+               return 0;
        un = (struct un_t *) dev_get_drvdata(d);
        if (!un || un->magic != DGNC_UNIT_MAGIC)
-               return (0);
+               return 0;
        ch = un->un_ch;
        if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
-               return (0);
+               return 0;
        bd = ch->ch_bd;
        if (!bd || bd->magic != DGNC_BOARD_MAGIC)
-               return (0);
+               return 0;
        if (bd->state != BOARD_READY)
-               return (0);
+               return 0;
 
        return snprintf(buf, PAGE_SIZE, "%x\n", ch->ch_c_iflag);
 }
        struct un_t *un;
 
        if (!d)
-               return (0);
+               return 0;
        un = (struct un_t *) dev_get_drvdata(d);
        if (!un || un->magic != DGNC_UNIT_MAGIC)
-               return (0);
+               return 0;
        ch = un->un_ch;
        if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
-               return (0);
+               return 0;
        bd = ch->ch_bd;
        if (!bd || bd->magic != DGNC_BOARD_MAGIC)
-               return (0);
+               return 0;
        if (bd->state != BOARD_READY)
-               return (0);
+               return 0;
 
        return snprintf(buf, PAGE_SIZE, "%x\n", ch->ch_c_cflag);
 }
        struct un_t *un;
 
        if (!d)
-               return (0);
+               return 0;
        un = (struct un_t *) dev_get_drvdata(d);
        if (!un || un->magic != DGNC_UNIT_MAGIC)
-               return (0);
+               return 0;
        ch = un->un_ch;
        if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
-               return (0);
+               return 0;
        bd = ch->ch_bd;
        if (!bd || bd->magic != DGNC_BOARD_MAGIC)
-               return (0);
+               return 0;
        if (bd->state != BOARD_READY)
-               return (0);
+               return 0;
 
        return snprintf(buf, PAGE_SIZE, "%x\n", ch->ch_c_oflag);
 }
        struct un_t *un;
 
        if (!d)
-               return (0);
+               return 0;
        un = (struct un_t *) dev_get_drvdata(d);
        if (!un || un->magic != DGNC_UNIT_MAGIC)
-               return (0);
+               return 0;
        ch = un->un_ch;
        if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
-               return (0);
+               return 0;
        bd = ch->ch_bd;
        if (!bd || bd->magic != DGNC_BOARD_MAGIC)
-               return (0);
+               return 0;
        if (bd->state != BOARD_READY)
-               return (0);
+               return 0;
 
        return snprintf(buf, PAGE_SIZE, "%x\n", ch->ch_c_lflag);
 }
        struct un_t *un;
 
        if (!d)
-               return (0);
+               return 0;
        un = (struct un_t *) dev_get_drvdata(d);
        if (!un || un->magic != DGNC_UNIT_MAGIC)
-               return (0);
+               return 0;
        ch = un->un_ch;
        if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
-               return (0);
+               return 0;
        bd = ch->ch_bd;
        if (!bd || bd->magic != DGNC_BOARD_MAGIC)
-               return (0);
+               return 0;
        if (bd->state != BOARD_READY)
-               return (0);
+               return 0;
 
        return snprintf(buf, PAGE_SIZE, "%x\n", ch->ch_digi.digi_flags);
 }
        struct un_t *un;
 
        if (!d)
-               return (0);
+               return 0;
        un = (struct un_t *) dev_get_drvdata(d);
        if (!un || un->magic != DGNC_UNIT_MAGIC)
-               return (0);
+               return 0;
        ch = un->un_ch;
        if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
-               return (0);
+               return 0;
        bd = ch->ch_bd;
        if (!bd || bd->magic != DGNC_BOARD_MAGIC)
-               return (0);
+               return 0;
        if (bd->state != BOARD_READY)
-               return (0);
+               return 0;
 
        return snprintf(buf, PAGE_SIZE, "%ld\n", ch->ch_rxcount);
 }
        struct un_t *un;
 
        if (!d)
-               return (0);
+               return 0;
        un = (struct un_t *) dev_get_drvdata(d);
        if (!un || un->magic != DGNC_UNIT_MAGIC)
-               return (0);
+               return 0;
        ch = un->un_ch;
        if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
-               return (0);
+               return 0;
        bd = ch->ch_bd;
        if (!bd || bd->magic != DGNC_BOARD_MAGIC)
-               return (0);
+               return 0;
        if (bd->state != BOARD_READY)
-               return (0);
+               return 0;
 
        return snprintf(buf, PAGE_SIZE, "%ld\n", ch->ch_txcount);
 }
        struct un_t *un;
 
        if (!d)
-               return (0);
+               return 0;
        un = (struct un_t *) dev_get_drvdata(d);
        if (!un || un->magic != DGNC_UNIT_MAGIC)
-               return (0);
+               return 0;
        ch = un->un_ch;
        if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
-               return (0);
+               return 0;
        bd = ch->ch_bd;
        if (!bd || bd->magic != DGNC_BOARD_MAGIC)
-               return (0);
+               return 0;
        if (bd->state != BOARD_READY)
-               return (0);
+               return 0;
 
        return snprintf(buf, PAGE_SIZE, "%sn%d%c\n",
                (un->un_type == DGNC_PRINT) ? "pr" : "tty",
 
 
        if (!dgnc_TmpWriteBuf) {
                DPR_INIT(("unable to allocate tmp write buf"));
-               return (-ENOMEM);
+               return -ENOMEM;
        }
 
-       return(0);
+       return 0;
 }
 
 
         */
        brd->SerialDriver.ttys = kzalloc(brd->maxports * sizeof(struct tty_struct *), GFP_KERNEL);
        if (!brd->SerialDriver.ttys)
-               return(-ENOMEM);
+               return -ENOMEM;
 
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
        brd->SerialDriver.refcount = brd->TtyRefCnt;
 
        brd->SerialDriver.termios = kzalloc(brd->maxports * sizeof(struct ktermios *), GFP_KERNEL);
        if (!brd->SerialDriver.termios)
-               return(-ENOMEM);
+               return -ENOMEM;
 
 #if LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0)
        brd->SerialDriver.termios_locked = kzalloc(brd->maxports * sizeof(struct ktermios *), GFP_KERNEL);
        if (!brd->SerialDriver.termios_locked)
-               return(-ENOMEM);
+               return -ENOMEM;
 #endif
        /*
         * Entry points for driver.  Called by the kernel from
                rc = tty_register_driver(&brd->SerialDriver);
                if (rc < 0) {
                        APR(("Can't register tty device (%d)\n", rc));
-                       return(rc);
+                       return rc;
                }
                brd->dgnc_Major_Serial_Registered = TRUE;
        }
         */
        brd->PrintDriver.ttys = kzalloc(brd->maxports * sizeof(struct tty_struct *), GFP_KERNEL);
        if (!brd->PrintDriver.ttys)
-               return(-ENOMEM);
+               return -ENOMEM;
 
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
        brd->PrintDriver.refcount = brd->TtyRefCnt;
 
        brd->PrintDriver.termios = kzalloc(brd->maxports * sizeof(struct ktermios *), GFP_KERNEL);
        if (!brd->PrintDriver.termios)
-               return(-ENOMEM);
+               return -ENOMEM;
 
 #if LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0)
        brd->PrintDriver.termios_locked = kzalloc(brd->maxports * sizeof(struct ktermios *), GFP_KERNEL);
        if (!brd->PrintDriver.termios_locked)
-               return(-ENOMEM);
+               return -ENOMEM;
 #endif
 
        /*
                rc = tty_register_driver(&brd->PrintDriver);
                if (rc < 0) {
                        APR(("Can't register Transparent Print device (%d)\n", rc));
-                       return(rc);
+                       return rc;
                }
                brd->dgnc_Major_TransparentPrint_Registered = TRUE;
        }
 
        DPR_INIT(("DGNC REGISTER TTY: MAJOR: %d\n", brd->SerialDriver.major));
 
-       return (rc);
+       return rc;
 }
 
 
        struct channel_t *ch;
 
        if (!brd)
-               return (-ENXIO);
+               return -ENXIO;
 
        DPR_INIT(("dgnc_tty_init start\n"));
 
 
        DPR_INIT(("dgnc_tty_init finish\n"));
 
-       return (0);
+       return 0;
 }
 
 
        DGNC_UNLOCK(ch->ch_lock, lock_flags);
 
        DPR_OPEN(("dgnc_tty_open finished\n"));
-       return (rc);
+       return rc;
 }
 
 
        int     sleep_on_un_flags = 0;
 
        if (!tty || tty->magic != TTY_MAGIC || !file || !ch || ch->magic != DGNC_CHANNEL_MAGIC) {
-               return (-ENXIO);
+               return -ENXIO;
        }
 
        un = tty->driver_data;
        if (!un || un->magic != DGNC_UNIT_MAGIC) {
-               return (-ENXIO);
+               return -ENXIO;
        }
 
        DPR_OPEN(("dgnc_block_til_ready - before block.\n"));
 
        if (retval) {
                DPR_OPEN(("dgnc_block_til_ready - done. error. retval: %x\n", retval));
-               return(retval);
+               return retval;
        }
 
        DPR_OPEN(("dgnc_block_til_ready - done no error. jiffies: %lu\n", jiffies));
 
-       return(0);
+       return 0;
 }
 
 
        ulong   lock_flags = 0;
 
        if (tty == NULL)
-               return(0);
+               return 0;
 
        un = tty->driver_data;
        if (!un || un->magic != DGNC_UNIT_MAGIC)
-               return (0);
+               return 0;
 
        ch = un->un_ch;
        if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
-               return (0);
+               return 0;
 
        DGNC_LOCK(ch->ch_lock, lock_flags);
 
        DPR_WRITE(("dgnc_tty_chars_in_buffer. Port: %x - %d (head: %d tail: %d)\n",
                ch->ch_portnum, chars, thead, ttail));
 
-       return(chars);
+       return chars;
 }
 
 
        struct un_t *un = NULL;
 
        if (!tty)
-               return (bytes_available);
+               return bytes_available;
 
        un = tty->driver_data;
        if (!un || un->magic != DGNC_UNIT_MAGIC)
-               return (bytes_available);
+               return bytes_available;
 
        ch = un->un_ch;
        if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
-               return (bytes_available);
+               return bytes_available;
 
        /*
         * If its not the Transparent print device, return
         * the full data amount.
         */
        if (un->un_type != DGNC_PRINT)
-               return (bytes_available);
+               return bytes_available;
 
        if (ch->ch_digi.digi_maxcps > 0 && ch->ch_digi.digi_bufsize > 0 ) {
                int cps_limit = 0;
                bytes_available = min(cps_limit, bytes_available);
        }
 
-       return (bytes_available);
+       return bytes_available;
 }
 
 
        ulong   lock_flags = 0;
 
        if (tty == NULL || dgnc_TmpWriteBuf == NULL)
-               return(0);
+               return 0;
 
        un = tty->driver_data;
        if (!un || un->magic != DGNC_UNIT_MAGIC)
-               return (0);
+               return 0;
 
        ch = un->un_ch;
        if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
-               return (0);
+               return 0;
 
        DGNC_LOCK(ch->ch_lock, lock_flags);
 
 
        DPR_WRITE(("dgnc_tty_write_room - %d tail: %d head: %d\n", ret, tail, head));
 
-       return(ret);
+       return ret;
 }
 
 
        int from_user = 0;
 
        if (tty == NULL || dgnc_TmpWriteBuf == NULL)
-               return(0);
+               return 0;
 
        un = tty->driver_data;
        if (!un || un->magic != DGNC_UNIT_MAGIC)
-               return(0);
+               return 0;
 
        ch = un->un_ch;
        if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
-               return(0);
+               return 0;
 
        if (!count)
-               return(0);
+               return 0;
 
        DPR_WRITE(("dgnc_tty_write: Port: %x tty=%p user=%d len=%d\n",
                ch->ch_portnum, tty, from_user, count));
         */
        if (count <= 0) {
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
-               return(0);
+               return 0;
        }
 
        /*
         */
        if (count <= 0) {
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
-               return(0);
+               return 0;
        }
 
        if (from_user) {
                 */
                /* we're allowed to block if it's from_user */
                if (down_interruptible(&dgnc_TmpWriteSem)) {
-                       return (-EINTR);
+                       return -EINTR;
                }
 
                /*
 
                if (!count) {
                        up(&dgnc_TmpWriteSem);
-                       return(-EFAULT);
+                       return -EFAULT;
                }
 
                DGNC_LOCK(ch->ch_lock, lock_flags);
                ch->ch_bd->bd_ops->copy_data_from_queue_to_uart(ch);
        }
 
-       return (count);
+       return count;
 }
 
 
 
        DPR_IOCTL(("dgnc_tty_tiocmset finish\n"));
 
-       return (0);
+       return 0;
 }
 
 
 
        DPR_IOCTL(("dgnc_tty_send_break finish\n"));
 
-       return (0);
+       return 0;
 
 }
 
        DPR_IOCTL(("dgnc_getmstat start\n"));
 
        if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
-               return(-ENXIO);
+               return -ENXIO;
 
        DGNC_LOCK(ch->ch_lock, lock_flags);
 
 
        DPR_IOCTL(("dgnc_getmstat finish\n"));
 
-       return(result);
+       return result;
 }
 
 
        DPR_IOCTL(("dgnc_get_modem_info start\n"));
 
        if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
-               return(-ENXIO);
+               return -ENXIO;
 
        result = dgnc_get_mstat(ch);
 
        if (result < 0)
-               return (-ENXIO);
+               return -ENXIO;
 
        rc = put_user(result, value);
 
        DPR_IOCTL(("dgnc_get_modem_info finish\n"));
-       return(rc);
+       return rc;
 }
 
 
 
        ret = get_user(arg, value);
        if (ret)
-               return(ret);
+               return ret;
 
        switch (command) {
        case TIOCMBIS:
                break;
 
        default:
-               return(-EINVAL);
+               return -EINVAL;
        }
 
        DGNC_LOCK(ch->ch_lock, lock_flags);
 
        DPR_IOCTL(("dgnc_set_modem_info finish\n"));
 
-       return (0);
+       return 0;
 }
 
 
        ulong   lock_flags;
 
        if (!retinfo)
-               return (-EFAULT);
+               return -EFAULT;
 
        if (!tty || tty->magic != TTY_MAGIC)
-               return (-EFAULT);
+               return -EFAULT;
 
        un = tty->driver_data;
        if (!un || un->magic != DGNC_UNIT_MAGIC)
-               return (-EFAULT);
+               return -EFAULT;
 
        ch = un->un_ch;
        if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
-               return (-EFAULT);
+               return -EFAULT;
 
        memset(&tmp, 0, sizeof(tmp));
 
        DGNC_UNLOCK(ch->ch_lock, lock_flags);
 
        if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
-               return (-EFAULT);
+               return -EFAULT;
 
-       return (0);
+       return 0;
 }
 
 
        DPR_IOCTL(("DIGI_SETA start\n"));
 
        if (!tty || tty->magic != TTY_MAGIC)
-               return (-EFAULT);
+               return -EFAULT;
 
        un = tty->driver_data;
        if (!un || un->magic != DGNC_UNIT_MAGIC)
-               return (-EFAULT);
+               return -EFAULT;
 
        ch = un->un_ch;
        if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
-               return (-EFAULT);
+               return -EFAULT;
 
        bd = ch->ch_bd;
        if (!bd || bd->magic != DGNC_BOARD_MAGIC)
-               return (-EFAULT);
+               return -EFAULT;
 
        if (copy_from_user(&new_digi, new_info, sizeof(struct digi_t))) {
                DPR_IOCTL(("DIGI_SETA failed copy_from_user\n"));
-               return(-EFAULT);
+               return -EFAULT;
        }
 
        DGNC_LOCK(ch->ch_lock, lock_flags);
 
        DPR_IOCTL(("DIGI_SETA finish\n"));
 
-       return(0);
+       return 0;
 }
 
 
        void __user *uarg = (void __user *) arg;
 
        if (!tty || tty->magic != TTY_MAGIC)
-               return (-ENODEV);
+               return -ENODEV;
 
        un = tty->driver_data;
        if (!un || un->magic != DGNC_UNIT_MAGIC)
-               return (-ENODEV);
+               return -ENODEV;
 
        ch = un->un_ch;
        if (!ch || ch->magic != DGNC_CHANNEL_MAGIC)
-               return (-ENODEV);
+               return -ENODEV;
 
        bd = ch->ch_bd;
        if (!bd || bd->magic != DGNC_BOARD_MAGIC)
-               return (-ENODEV);
+               return -ENODEV;
 
        DPR_IOCTL(("dgnc_tty_ioctl start on port %d - cmd %s (%x), arg %lx\n",
                ch->ch_portnum, dgnc_ioctl_name(cmd), cmd, arg));
        if (un->un_open_count <= 0) {
                DPR_BASIC(("dgnc_tty_ioctl - unit not open.\n"));
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
-               return(-EIO);
+               return -EIO;
        }
 
        switch (cmd) {
                rc = tty_check_change(tty);
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
                if (rc) {
-                       return(rc);
+                       return rc;
                }
 
                rc = ch->ch_bd->bd_ops->drain(tty, 0);
 
                if (rc) {
                        DPR_IOCTL(("dgnc_tty_ioctl - bad return: %d ", rc));
-                       return(-EINTR);
+                       return -EINTR;
                }
 
                DGNC_LOCK(ch->ch_lock, lock_flags);
                DPR_IOCTL(("dgnc_tty_ioctl finish on port %d - cmd %s (%x), arg %lx\n",
                        ch->ch_portnum, dgnc_ioctl_name(cmd), cmd, arg));
 
-               return(0);
+               return 0;
 
 
        case TCSBRKP:
                rc = tty_check_change(tty);
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
                if (rc) {
-                       return(rc);
+                       return rc;
                }
 
                rc = ch->ch_bd->bd_ops->drain(tty, 0);
                if (rc) {
                        DPR_IOCTL(("dgnc_tty_ioctl - bad return: %d ", rc));
-                       return(-EINTR);
+                       return -EINTR;
                }
 
                DGNC_LOCK(ch->ch_lock, lock_flags);
                DPR_IOCTL(("dgnc_tty_ioctl finish on port %d - cmd %s (%x), arg %lx\n",
                        ch->ch_portnum, dgnc_ioctl_name(cmd), cmd, arg));
 
-               return(0);
+               return 0;
 
        case TIOCSBRK:
                rc = tty_check_change(tty);
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
                if (rc) {
-                       return(rc);
+                       return rc;
                }
 
                rc = ch->ch_bd->bd_ops->drain(tty, 0);
                if (rc) {
                        DPR_IOCTL(("dgnc_tty_ioctl - bad return: %d ", rc));
-                       return(-EINTR);
+                       return -EINTR;
                }
 
                DGNC_LOCK(ch->ch_lock, lock_flags);
                DPR_IOCTL(("dgnc_tty_ioctl finish on port %d - cmd %s (%x), arg %lx\n",
                        ch->ch_portnum, dgnc_ioctl_name(cmd), cmd, arg));
 
-               return(0);
+               return 0;
 
        case TIOCCBRK:
                /* Do Nothing */
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
 
                rc = put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned long __user *) arg);
-               return(rc);
+               return rc;
 
        case TIOCSSOFTCAR:
 
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
                rc = get_user(arg, (unsigned long __user *) arg);
                if (rc)
-                       return(rc);
+                       return rc;
 
                DGNC_LOCK(ch->ch_lock, lock_flags);
                tty->termios.c_cflag = ((tty->termios.c_cflag & ~CLOCAL) | (arg ? CLOCAL : 0));
                ch->ch_bd->bd_ops->param(tty);
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
 
-               return(0);
+               return 0;
 
        case TIOCMGET:
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
-               return(dgnc_get_modem_info(ch, uarg));
+               return dgnc_get_modem_info(ch, uarg);
 
        case TIOCMBIS:
        case TIOCMBIC:
        case TIOCMSET:
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
-               return(dgnc_set_modem_info(tty, cmd, uarg));
+               return dgnc_set_modem_info(tty, cmd, uarg);
 
                /*
                 * Here are any additional ioctl's that we want to implement
                rc = tty_check_change(tty);
                if (rc) {
                        DGNC_UNLOCK(ch->ch_lock, lock_flags);
-                       return(rc);
+                       return rc;
                }
 
                if ((arg == TCIFLUSH) || (arg == TCIOFLUSH)) {
 
                /* pretend we didn't recognize this IOCTL */
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
-               return(-ENOIOCTLCMD);
+               return -ENOIOCTLCMD;
        case TCSETSF:
        case TCSETSW:
                /*
                rc = ch->ch_bd->bd_ops->drain(tty, 0);
                if (rc) {
                        DPR_IOCTL(("dgnc_tty_ioctl - bad return: %d\n", rc));
-                       return(-EINTR);
+                       return -EINTR;
                }
 
                DPR_IOCTL(("dgnc_tty_ioctl finish on port %d - cmd %s (%x), arg %lx\n",
                        ch->ch_portnum, dgnc_ioctl_name(cmd), cmd, arg));
 
                /* pretend we didn't recognize this */
-               return(-ENOIOCTLCMD);
+               return -ENOIOCTLCMD;
 
        case TCSETAW:
 
                rc = ch->ch_bd->bd_ops->drain(tty, 0);
                if (rc) {
                        DPR_IOCTL(("dgnc_tty_ioctl - bad return: %d ", rc));
-                       return(-EINTR);
+                       return -EINTR;
                }
 
                /* pretend we didn't recognize this */
-               return(-ENOIOCTLCMD);
+               return -ENOIOCTLCMD;
 
        case TCXONC:
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
                /* Make the ld do it */
-               return(-ENOIOCTLCMD);
+               return -ENOIOCTLCMD;
 
        case DIGI_GETA:
                /* get information for ditty */
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
-               return(dgnc_tty_digigeta(tty, uarg));
+               return dgnc_tty_digigeta(tty, uarg);
 
        case DIGI_SETAW:
        case DIGI_SETAF:
                        rc = ch->ch_bd->bd_ops->drain(tty, 0);
                        if (rc) {
                                DPR_IOCTL(("dgnc_tty_ioctl - bad return: %d ", rc));
-                               return(-EINTR);
+                               return -EINTR;
                        }
                        DGNC_LOCK(ch->ch_lock, lock_flags);
                }
 
        case DIGI_SETA:
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
-               return(dgnc_tty_digiseta(tty, uarg));
+               return dgnc_tty_digiseta(tty, uarg);
 
        case DIGI_LOOPBACK:
                {
                        DGNC_UNLOCK(ch->ch_lock, lock_flags);
                        rc = get_user(loopback, (unsigned int __user *) arg);
                        if (rc)
-                               return(rc);
+                               return rc;
                        DGNC_LOCK(ch->ch_lock, lock_flags);
 
                        /* Enable/disable internal loopback for this port */
 
                        ch->ch_bd->bd_ops->param(tty);
                        DGNC_UNLOCK(ch->ch_lock, lock_flags);
-                       return(0);
+                       return 0;
                }
 
        case DIGI_GETCUSTOMBAUD:
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
                rc = put_user(ch->ch_custom_speed, (unsigned int __user *) arg);
-               return(rc);
+               return rc;
 
        case DIGI_SETCUSTOMBAUD:
        {
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
                rc = get_user(new_rate, (unsigned int __user *) arg);
                if (rc)
-                       return(rc);
+                       return rc;
                DGNC_LOCK(ch->ch_lock, lock_flags);
                dgnc_set_custom_speed(ch, new_rate);
                ch->ch_bd->bd_ops->param(tty);
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
-               return(0);
+               return 0;
        }
 
        /*
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
                rc = get_user(c, (unsigned char __user *) arg);
                if (rc)
-                       return(rc);
+                       return rc;
                DGNC_LOCK(ch->ch_lock, lock_flags);
                ch->ch_bd->bd_ops->send_immediate_char(ch, c);
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
-               return(0);
+               return 0;
        }
 
        /*
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
 
                if (copy_to_user(uarg, &buf, sizeof(struct digi_getcounter))) {
-                       return (-EFAULT);
+                       return -EFAULT;
                }
-               return(0);
+               return 0;
        }
 
        /*
 
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
                rc = put_user(events, (unsigned int __user *) arg);
-               return(rc);
+               return rc;
        }
 
        /*
                 * Get data from user first.
                 */
                if (copy_from_user(&buf, uarg, sizeof(struct digi_getbuffer))) {
-                       return (-EFAULT);
+                       return -EFAULT;
                }
 
                DGNC_LOCK(ch->ch_lock, lock_flags);
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
 
                if (copy_to_user(uarg, &buf, sizeof(struct digi_getbuffer))) {
-                       return (-EFAULT);
+                       return -EFAULT;
                }
-               return(0);
+               return 0;
        }
        default:
                DGNC_UNLOCK(ch->ch_lock, lock_flags);
                DPR_IOCTL(("dgnc_tty_ioctl end - cmd %s (%x), arg %lx\n",
                        dgnc_ioctl_name(cmd), cmd, arg));
 
-               return(-ENOIOCTLCMD);
+               return -ENOIOCTLCMD;
        }
 
        DGNC_UNLOCK(ch->ch_lock, lock_flags);
        DPR_IOCTL(("dgnc_tty_ioctl end - cmd %s (%x), arg %lx\n",
                dgnc_ioctl_name(cmd), cmd, arg));
 
-       return(0);
+       return 0;
 }