/*
 *
 * Copyright 1999 Digi International (www.digi.com)
 *     Gene Olson    <Gene_Olson at digi dot com>
 *     James Puzzo   <jamesp at digi dot com>
 *     Jeff Randall
 *     Scott Kilau   <scottk at digi dot com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED; without even the
 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 * PURPOSE.  See the GNU General Public License for more details.
 *
 */

/*
 *
 *  Filename:
 *
 *     dgrp_tty.c
 *
 *  Description:
 *
 *     This file implements the tty driver functionality for the
 *     RealPort driver software.
 *
 *  Author:
 *
 *     James A. Puzzo
 *     Ann-Marie Westgate
 *
 */

#include <linux/slab.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <linux/device.h>
#include <linux/sched.h>
#include <linux/uaccess.h>

#include "dgrp_common.h"

#ifndef _POSIX_VDISABLE
#define   _POSIX_VDISABLE ('\0')
#endif

/*
 *      forward declarations
 */

static void drp_param(struct ch_struct *);
static void dgrp_tty_close(struct tty_struct *, struct file *);

/* ioctl helper functions */
static int set_modem_info(struct ch_struct *, unsigned int, unsigned int *);
static int get_modem_info(struct ch_struct *, unsigned int *);
static void dgrp_set_custom_speed(struct ch_struct *, int);
static int dgrp_tty_digigetedelay(struct tty_struct *, int *);
static int dgrp_tty_digisetedelay(struct tty_struct *, int *);
static int dgrp_send_break(struct ch_struct *, int);

static ushort  tty_to_ch_flags(struct tty_struct *, char);
static tcflag_t ch_to_tty_flags(unsigned short, char);

static void dgrp_tty_input_start(struct tty_struct *);
static void dgrp_tty_input_stop(struct tty_struct *);

static void drp_wmove(struct ch_struct *, int, void*, int);

static int dgrp_tty_open(struct tty_struct *, struct file *);
static void dgrp_tty_close(struct tty_struct *, struct file *);
static int dgrp_tty_write(struct tty_struct *, const unsigned char *, int);
static int dgrp_tty_write_room(struct tty_struct *);
static void dgrp_tty_flush_buffer(struct tty_struct *);
static int dgrp_tty_chars_in_buffer(struct tty_struct *);
static int dgrp_tty_ioctl(struct tty_struct *, unsigned int, unsigned long);
static void dgrp_tty_set_termios(struct tty_struct *, struct ktermios *);
static void dgrp_tty_stop(struct tty_struct *);
static void dgrp_tty_start(struct tty_struct *);
static void dgrp_tty_throttle(struct tty_struct *);
static void dgrp_tty_unthrottle(struct tty_struct *);
static void dgrp_tty_hangup(struct tty_struct *);
static int dgrp_tty_put_char(struct tty_struct *, unsigned char);
static int dgrp_tty_tiocmget(struct tty_struct *);
static int dgrp_tty_tiocmset(struct tty_struct *, unsigned int, unsigned int);
static int dgrp_tty_send_break(struct tty_struct *, int);
static void dgrp_tty_send_xchar(struct tty_struct *, char);

/*
 *      tty defines
 */
#define SERIAL_TYPE_NORMAL      1
#define SERIAL_TYPE_CALLOUT     2
#define SERIAL_TYPE_XPRINT      3


/*
 *      tty globals/statics
 */


#define PORTSERVER_DIVIDEND     1843200

/*
 *  Default transparent print information.
 */
static struct digi_struct digi_init = {
        .digi_flags   = DIGI_COOK,      /* Flags                        */
        .digi_maxcps  = 100,            /* Max CPS                      */
        .digi_maxchar = 50,             /* Max chars in print queue     */
        .digi_bufsize = 100,            /* Printer buffer size          */
        .digi_onlen   = 4,              /* size of printer on string    */
        .digi_offlen  = 4,              /* size of printer off string   */
        .digi_onstr   = "\033[5i",      /* ANSI printer on string       */
        .digi_offstr  = "\033[4i",      /* ANSI printer off string      */
        .digi_term    = "ansi"          /* default terminal type        */
};

/*
 *      Define a local default termios struct. All ports will be created
 *      with this termios initially.
 *
 *      This defines a raw port at 9600 baud, 8 data bits, no parity,
 *      1 stop bit.
 */
static struct ktermios DefaultTermios = {
        .c_iflag = (ICRNL | IXON),
        .c_oflag = (OPOST | ONLCR),
        .c_cflag = (B9600 | CS8 | CREAD | HUPCL | CLOCAL),
        .c_lflag = (ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHOCTL
                    | ECHOKE | IEXTEN),
        .c_cc    = INIT_C_CC,
        .c_line  = 0,
};

/* Define our tty operations struct */
static const struct tty_operations dgrp_tty_ops = {
        .open            = dgrp_tty_open,
        .close           = dgrp_tty_close,
        .write           = dgrp_tty_write,
        .write_room      = dgrp_tty_write_room,
        .flush_buffer    = dgrp_tty_flush_buffer,
        .chars_in_buffer = dgrp_tty_chars_in_buffer,
        .flush_chars     = NULL,
        .ioctl           = dgrp_tty_ioctl,
        .set_termios     = dgrp_tty_set_termios,
        .stop            = dgrp_tty_stop,
        .start           = dgrp_tty_start,
        .throttle        = dgrp_tty_throttle,
        .unthrottle      = dgrp_tty_unthrottle,
        .hangup          = dgrp_tty_hangup,
        .put_char        = dgrp_tty_put_char,
        .tiocmget        = dgrp_tty_tiocmget,
        .tiocmset        = dgrp_tty_tiocmset,
        .break_ctl       = dgrp_tty_send_break,
        .send_xchar      = dgrp_tty_send_xchar
};


static int calc_baud_rate(struct un_struct *un)
{
        int i;
        int brate;

        struct baud_rates {
                unsigned int rate;
                unsigned int cflag;
        };

        static struct baud_rates baud_rates[] = {
                { 921600, B921600 },
                { 460800, B460800 },
                { 230400, B230400 },
                { 115200, B115200 },
                {  57600, B57600  },
                {  38400, B38400  },
                {  19200, B19200  },
                {   9600, B9600   },
                {   4800, B4800   },
                {   2400, B2400   },
                {   1200, B1200   },
                {    600, B600    },
                {    300, B300    },
                {    200, B200    },
                {    150, B150    },
                {    134, B134    },
                {    110, B110    },
                {     75, B75     },
                {     50, B50     },
                {      0, B9600  }
        };

        brate = C_BAUD(un->un_tty);

        for (i = 0; baud_rates[i].rate; i++) {
                if (baud_rates[i].cflag == brate)
                        break;
        }

        return baud_rates[i].rate;
}

static int calc_fastbaud_rate(struct un_struct *un, struct ktermios *uts)
{
        int i;
        int brate;

        ulong bauds[2][16] = {
                { /* fastbaud*/
                        0,      57600,   76800, 115200,
                        131657, 153600, 230400, 460800,
                        921600, 1200,   1800,   2400,
                        4800,   9600,   19200,  38400 },
                { /* fastbaud & CBAUDEX */
                        0,      57600,  115200, 230400,
                        460800, 150,    200,    921600,
                        600,    1200,   1800,   2400,
                        4800,   9600,   19200,  38400 }
        };

        brate = C_BAUD(un->un_tty) & 0xff;

        i = (uts->c_cflag & CBAUDEX) ? 1 : 0;


        if ((i >= 0) && (i < 2) && (brate >= 0) && (brate < 16))
                brate = bauds[i][brate];
        else
                brate = 0;

        return brate;
}

/**
 * drp_param() -- send parameter values to be sent to the node
 * @ch: channel structure of port to modify
 *
 * Interprets the tty and modem changes made by an application
 * program (by examining the termios structures) and sets up
 * parameter values to be sent to the node.
 */
static void drp_param(struct ch_struct *ch)
{
        struct nd_struct *nd;
        struct un_struct *un;
        int   brate;
        int   mflow;
        int   xflag;
        int   iflag;
        struct ktermios *tts, *pts, *uts;

        nd = ch->ch_nd;

        /*
         *  If the terminal device is open, use it to set up all tty
         *  modes and functions.  Otherwise use the printer device.
         */

        if (ch->ch_tun.un_open_count) {

                un = &ch->ch_tun;
                tts = &ch->ch_tun.un_tty->termios;

                /*
                 *  If both devices are open, copy critical line
                 *  parameters from the tty device to the printer,
                 *  so that if the tty is closed, the printer will
                 *  continue without disruption.
                 */

                if (ch->ch_pun.un_open_count) {

                        pts = &ch->ch_pun.un_tty->termios;

                        pts->c_cflag ^=
                                (pts->c_cflag ^ tts->c_cflag) &
                                (CBAUD  | CSIZE | CSTOPB | CREAD | PARENB |
                                 PARODD | HUPCL | CLOCAL);

                        pts->c_iflag ^=
                                (pts->c_iflag ^ tts->c_iflag) &
                                (IGNBRK | BRKINT | IGNPAR | PARMRK | INPCK |
                                 ISTRIP | IXON   | IXANY  | IXOFF);

                        pts->c_cc[VSTART] = tts->c_cc[VSTART];
                        pts->c_cc[VSTOP] = tts->c_cc[VSTOP];
                }
        } else if (ch->ch_pun.un_open_count == 0) {
                pr_warn("%s - ch_pun.un_open_count shouldn't be 0\n",
                       __func__);
                return;
        } else {
                un = &ch->ch_pun;
        }

        uts = &un->un_tty->termios;

        /*
         * Determine if FAST writes can be performed.
         */

        if ((ch->ch_digi.digi_flags & DIGI_COOK) != 0 &&
            (ch->ch_tun.un_open_count != 0)  &&
            !((un->un_tty)->ldisc->ops->flags & LDISC_FLAG_DEFINED) &&
            !(L_XCASE(un->un_tty))) {
                ch->ch_flag |= CH_FAST_WRITE;
        } else {
                ch->ch_flag &= ~CH_FAST_WRITE;
        }

        /*
         *  If FAST writes can be performed, and OPOST is on in the
         *  terminal device, do OPOST handling in the server.
         */

        if ((ch->ch_flag & CH_FAST_WRITE) &&
              O_OPOST(un->un_tty) != 0) {
                int oflag = tty_to_ch_flags(un->un_tty, 'o');

                /* add to ch_ocook any processing flags set in the termio */
                ch->ch_ocook |= oflag & (OF_OLCUC |
                                         OF_ONLCR |
                                         OF_OCRNL |
                                         OF_ONLRET |
                                         OF_TABDLY);

                /*
                 * the hpux driver clears any flags set in ch_ocook
                 * from the termios oflag.  It is STILL reported though
                 * by a TCGETA
                 */

                oflag = ch_to_tty_flags(ch->ch_ocook, 'o');
                uts->c_oflag &= ~oflag;

        } else {
                /* clear the ch->ch_ocook flag */
                int oflag = ch_to_tty_flags(ch->ch_ocook, 'o');
                uts->c_oflag |= oflag;
                ch->ch_ocook = 0;
        }

        ch->ch_oflag = ch->ch_ocook;


        ch->ch_flag &= ~CH_FAST_READ;

        /*
         *  Generate channel flags
         */

        if (C_BAUD(un->un_tty) == B0) {
                if (!(ch->ch_flag & CH_BAUD0)) {
                        /* TODO : the HPUX driver flushes line */
                        /* TODO : discipline, I assume I don't have to */

                        ch->ch_tout = ch->ch_tin;
                        ch->ch_rout = ch->ch_rin;

                        ch->ch_break_time = 0;

                        ch->ch_send |= RR_TX_FLUSH | RR_RX_FLUSH;

                        ch->ch_mout &= ~(DM_DTR | DM_RTS);

                        ch->ch_flag |= CH_BAUD0;
                }
        } else if (ch->ch_custom_speed) {
                ch->ch_brate = PORTSERVER_DIVIDEND / ch->ch_custom_speed;

                if (ch->ch_flag & CH_BAUD0) {
                        ch->ch_mout |= DM_DTR | DM_RTS;

                        ch->ch_flag &= ~CH_BAUD0;
                }
        } else {
                /*
                 * Baud rate mapping.
                 *
                 * If FASTBAUD isn't on, we can scan the new baud rate list
                 * as required.
                 *
                 * However, if FASTBAUD is on, we must go to the old
                 * baud rate mapping that existed many many moons ago,
                 * for compatibility reasons.
                 */

                if (!(ch->ch_digi.digi_flags & DIGI_FAST))
                        brate = calc_baud_rate(un);
                else
                        brate = calc_fastbaud_rate(un, uts);

                if (brate == 0)
                        brate = 9600;

                ch->ch_brate = PORTSERVER_DIVIDEND / brate;

                if (ch->ch_flag & CH_BAUD0) {
                        ch->ch_mout |= DM_DTR | DM_RTS;

                        ch->ch_flag &= ~CH_BAUD0;
                }
        }

        /*
         *  Generate channel cflags from the termio.
         */

        ch->ch_cflag = tty_to_ch_flags(un->un_tty, 'c');

        /*
         *  Generate channel iflags from the termio.
         */

        iflag = (int) tty_to_ch_flags(un->un_tty, 'i');

        if (START_CHAR(un->un_tty) == _POSIX_VDISABLE ||
            STOP_CHAR(un->un_tty) == _POSIX_VDISABLE) {
                iflag &= ~(IF_IXON | IF_IXANY | IF_IXOFF);
        }

        ch->ch_iflag = iflag;

        /*
         *  Generate flow control characters
         */

        /*
         * From the POSIX.1 spec (7.1.2.6): "If {_POSIX_VDISABLE}
         * is defined for the terminal device file, and the value
         * of one of the changeable special control characters (see
         * 7.1.1.9) is {_POSIX_VDISABLE}, that function shall be
         * disabled, that is, no input data shall be recognized as
         * the disabled special character."
         *
         * OK, so we don't ever assign S/DXB XON or XOFF to _POSIX_VDISABLE.
         */

        if (uts->c_cc[VSTART] != _POSIX_VDISABLE)
                ch->ch_xon = uts->c_cc[VSTART];
        if (uts->c_cc[VSTOP] != _POSIX_VDISABLE)
                ch->ch_xoff = uts->c_cc[VSTOP];

        ch->ch_lnext = (uts->c_cc[VLNEXT] == _POSIX_VDISABLE ? 0 :
                        uts->c_cc[VLNEXT]);

        /*
         * Also, if either c_cc[START] or c_cc[STOP] is set to
         * _POSIX_VDISABLE, we can't really do software flow
         * control--in either direction--so we turn it off as
         * far as S/DXB is concerned.  In essence, if you disable
         * one, you disable the other too.
         */
        if ((uts->c_cc[VSTART] == _POSIX_VDISABLE) ||
            (uts->c_cc[VSTOP] == _POSIX_VDISABLE))
                ch->ch_iflag &= ~(IF_IXOFF | IF_IXON);

        /*
         *  Update xflags.
         */

        xflag = 0;

        if (ch->ch_digi.digi_flags & DIGI_AIXON)
                xflag = XF_XIXON;

        if ((ch->ch_xxon == _POSIX_VDISABLE) ||
            (ch->ch_xxoff == _POSIX_VDISABLE))
                xflag &= ~XF_XIXON;

        ch->ch_xflag = xflag;


        /*
         *  Figure effective DCD value.
         */

        if (C_CLOCAL(un->un_tty))
                ch->ch_flag |= CH_CLOCAL;
        else
                ch->ch_flag &= ~CH_CLOCAL;

        /*
         *  Check modem signals
         */

        dgrp_carrier(ch);

        /*
         *  Get hardware handshake value.
         */

        mflow = 0;

        if (C_CRTSCTS(un->un_tty))
                mflow |= (DM_RTS | DM_CTS);

        if (ch->ch_digi.digi_flags & RTSPACE)
                mflow |= DM_RTS;

        if (ch->ch_digi.digi_flags & DTRPACE)
                mflow |= DM_DTR;

        if (ch->ch_digi.digi_flags & CTSPACE)
                mflow |= DM_CTS;

        if (ch->ch_digi.digi_flags & DSRPACE)
                mflow |= DM_DSR;

        if (ch->ch_digi.digi_flags & DCDPACE)
                mflow |= DM_CD;

        if (ch->ch_digi.digi_flags & DIGI_RTS_TOGGLE)
                mflow |= DM_RTS_TOGGLE;

        ch->ch_mflow = mflow;

        /*
         *  Send the changes to the server.
         */

        ch->ch_flag |= CH_PARAM;
        (ch->ch_nd)->nd_tx_work = 1;

        if (waitqueue_active(&ch->ch_flag_wait))
                wake_up_interruptible(&ch->ch_flag_wait);
}

/*
 * This function is just used as a callback for timeouts
 * waiting on the ch_sleep flag.
 */
static void wake_up_drp_sleep_timer(unsigned long ptr)
{
        struct ch_struct *ch = (struct ch_struct *) ptr;
        if (ch)
                wake_up(&ch->ch_sleep);
}


/*
 * Set up our own sleep that can't be cancelled
 * until our timeout occurs.
 */
static void drp_my_sleep(struct ch_struct *ch)
{
        struct timer_list drp_wakeup_timer;
        DECLARE_WAITQUEUE(wait, current);

        /*
         * First make sure we're ready to receive the wakeup.
         */

        add_wait_queue(&ch->ch_sleep, &wait);
        current->state = TASK_UNINTERRUPTIBLE;

        /*
         * Since we are uninterruptible, set a timer to
         * unset the uninterruptable state in 1 second.
         */

        init_timer(&drp_wakeup_timer);
        drp_wakeup_timer.function = wake_up_drp_sleep_timer;
        drp_wakeup_timer.data = (unsigned long) ch;
        drp_wakeup_timer.expires = jiffies + (1 * HZ);
        add_timer(&drp_wakeup_timer);

        schedule();

        del_timer(&drp_wakeup_timer);

        remove_wait_queue(&ch->ch_sleep, &wait);
}

/*
 * dgrp_tty_open()
 *
 * returns:
 *    -EBUSY    - this is a callout device and the normal device is active
 *              - there is an error in opening the tty
 *    -ENODEV   - the channel does not exist
 *    -EAGAIN   - we are in the middle of hanging up or closing
 *              - IMMEDIATE_OPEN fails
 *    -ENXIO or -EAGAIN
 *              - if the port is outside physical range
 *    -EINTR    - the open is interrupted
 *
 */
static int dgrp_tty_open(struct tty_struct *tty, struct file *file)
{
        int    retval = 0;
        struct nd_struct  *nd;
        struct ch_struct *ch;
        struct un_struct  *un;
        int    port;
        int    delay_error;
        int    otype;
        int    unf;
        int    wait_carrier;
        int    category;
        int    counts_were_incremented = 0;
        ulong lock_flags;
        DECLARE_WAITQUEUE(wait, current);

        /*
         * Do some initial checks to see if the node and port exist
         */

        nd = nd_struct_get(MAJOR(tty_devnum(tty)));
        port = PORT_NUM(MINOR(tty_devnum(tty)));
        category = OPEN_CATEGORY(MINOR(tty_devnum(tty)));

        if (!nd)
                return -ENODEV;

        if (port >= CHAN_MAX)
                return -ENODEV;

        /*
         *  The channel exists.
         */

        ch = nd->nd_chan + port;

        un = IS_PRINT(MINOR(tty_devnum(tty))) ? &ch->ch_pun : &ch->ch_tun;
        un->un_tty = tty;
        tty->driver_data = un;

        /*
         * If we are in the middle of hanging up,
         * then return an error
         */
        if (tty_hung_up_p(file)) {
                retval = ((un->un_flag & UN_HUP_NOTIFY) ?
                           -EAGAIN : -ERESTARTSYS);
                goto done;
        }

        /*
         * If the port is in the middle of closing, then block
         * until it is done, then try again.
         */
        retval = wait_event_interruptible(un->un_close_wait,
                        ((un->un_flag & UN_CLOSING) == 0));

        if (retval)
                goto done;

        /*
         * If the port is in the middle of a reopen after a network disconnect,
         * wait until it is done, then try again.
         */
        retval = wait_event_interruptible(ch->ch_flag_wait,
                        ((ch->ch_flag & CH_PORT_GONE) == 0));

        if (retval)
                goto done;

        /*
         * If this is a callout device, then just make sure the normal
         * device isn't being used.
         */

        if (tty->driver->subtype == SERIAL_TYPE_CALLOUT) {
                if (un->un_flag & UN_NORMAL_ACTIVE) {
                        retval = -EBUSY;
                        goto done;
                } else {
                        un->un_flag |= UN_CALLOUT_ACTIVE;
                }
        }

        /*
         *  Loop waiting until the open can be successfully completed.
         */

        spin_lock_irqsave(&nd->nd_lock, lock_flags);

        nd->nd_tx_work = 1;

        for (;;) {
                wait_carrier = 0;

                /*
                 * Determine the open type from the flags provided.
                 */

                /*
                 * If the port is not enabled, then exit
                 */
                if (test_bit(TTY_IO_ERROR, &tty->flags)) {
                        /* there was an error in opening the tty */
                        if (un->un_flag & UN_CALLOUT_ACTIVE)
                                retval = -EBUSY;
                        else
                                un->un_flag |= UN_NORMAL_ACTIVE;
                        goto unlock;
                }

                if (file->f_flags & O_NONBLOCK) {

                        /*
                         * if the O_NONBLOCK is set, errors on read and write
                         * must return -EAGAIN immediately and NOT sleep
                         * on the waitqs.
                         */
                        otype = OTYPE_IMMEDIATE;
                        delay_error = -EAGAIN;

                } else if (!OPEN_WAIT_AVAIL(category) ||
                          (file->f_flags & O_NDELAY) != 0) {
                        otype = OTYPE_IMMEDIATE;
                        delay_error = -EBUSY;

                } else if (!OPEN_WAIT_CARRIER(category) ||
                          ((ch->ch_digi.digi_flags & DIGI_FORCEDCD) != 0) ||
                          C_CLOCAL(tty)) {
                        otype = OTYPE_PERSISTENT;
                        delay_error = 0;

                } else {
                        otype = OTYPE_INCOMING;
                        delay_error = 0;
                }

                /*
                 * Handle port currently outside physical port range.
                 */

                if (port >= nd->nd_chan_count) {
                        if (otype == OTYPE_IMMEDIATE) {
                                retval = (nd->nd_state == NS_READY) ?
                                                -ENXIO : -EAGAIN;
                                goto unlock;
                        }
                }

                /*
                 *  Handle port not currently open.
                 */

                else if (ch->ch_open_count == 0) {
                        /*
                         * Return an error when an Incoming Open
                         * response indicates the port is busy.
                         */

                        if (ch->ch_open_error != 0 && otype == ch->ch_otype) {
                                retval = (ch->ch_open_error <= 2) ?
                                          delay_error : -ENXIO;
                                goto unlock;
                        }

                        /*
                         * Fail any new Immediate open if we do not have
                         * a normal connection to the server.
                         */

                        if (nd->nd_state != NS_READY &&
                            otype == OTYPE_IMMEDIATE) {
                                retval = -EAGAIN;
                                goto unlock;
                        }

                        /*
                         * If a Realport open of the correct type has
                         * succeeded, complete the open.
                         */

                        if (ch->ch_state == CS_READY && ch->ch_otype == otype)
                                break;
                }

                /*
                 * Handle port already open and active as a device
                 * of same category.
                 */

                else if ((ch->ch_category == category) ||
                          IS_PRINT(MINOR(tty_devnum(tty)))) {
                        /*
                         * Fail if opening the device now would
                         * violate exclusive use.
                         */
                        unf = ch->ch_tun.un_flag | ch->ch_pun.un_flag;

                        if ((file->f_flags & O_EXCL) || (unf & UN_EXCL)) {
                                retval = -EBUSY;
                                goto unlock;
                        }

                        /*
                         * If the open device is in the hangup state, all
                         * system calls fail except close().
                         */

                        /* TODO : check on hangup_p calls */

                        if (ch->ch_flag & CH_HANGUP) {
                                retval = -ENXIO;
                                goto unlock;
                        }

                        /*
                         * If the port is ready, and carrier is ignored
                         * or present, then complete the open.
                         */

                        if (ch->ch_state == CS_READY &&
                            (otype != OTYPE_INCOMING ||
                            ch->ch_flag & CH_VIRT_CD))
                                break;

                        wait_carrier = 1;
                }

                /*
                 *  Handle port active with a different category device.
                 */

                else {
                        if (otype == OTYPE_IMMEDIATE) {
                                retval = delay_error;
                                goto unlock;
                        }
                }

                /*
                 * Wait until conditions change, then take another
                 * try at the open.
                 */

                ch->ch_wait_count[otype]++;

                if (wait_carrier)
                        ch->ch_wait_carrier++;

                /*
                 * Prepare the task to accept the wakeup, then
                 * release our locks and release control.
                 */

                add_wait_queue(&ch->ch_flag_wait, &wait);
                current->state = TASK_INTERRUPTIBLE;

                spin_unlock_irqrestore(&nd->nd_lock, lock_flags);

                /*
                 * Give up control, we'll come back if we're
                 * interrupted or are woken up.
                 */
                schedule();
                remove_wait_queue(&ch->ch_flag_wait, &wait);

                spin_lock_irqsave(&nd->nd_lock, lock_flags);

                current->state = TASK_RUNNING;

                ch->ch_wait_count[otype]--;

                if (wait_carrier)
                        ch->ch_wait_carrier--;

                nd->nd_tx_work = 1;

                if (signal_pending(current)) {
                        retval = -EINTR;
                        goto unlock;
                }
        } /* end for(;;) */

        /*
         *  The open has succeeded.  No turning back.
         */
        counts_were_incremented = 1;
        un->un_open_count++;
        ch->ch_open_count++;

        /*
         * Initialize the channel, if it's not already open.
         */

        if (ch->ch_open_count == 1) {
                ch->ch_flag = 0;
                ch->ch_inwait = 0;
                ch->ch_category = category;
                ch->ch_pscan_state = 0;

                /* TODO : find out what PS-1 bug Gene was referring to */
                /* TODO : in the following comment. */

                ch->ch_send = RR_TX_START | RR_RX_START;  /* PS-1 bug */

                if (C_CLOCAL(tty) ||
                    ch->ch_s_mlast & DM_CD ||
                    ch->ch_digi.digi_flags & DIGI_FORCEDCD)
                        ch->ch_flag |= CH_VIRT_CD;
                else if (OPEN_FORCES_CARRIER(category))
                        ch->ch_flag |= CH_VIRT_CD;

        }

        /*
         *  Initialize the unit, if it is not already open.
         */

        if (un->un_open_count == 1) {
                /*
                 *  Since all terminal options are always sticky in Linux,
                 *  we don't need the UN_STICKY flag to be handled specially.
                 */
                /* clears all the digi flags, leaves serial flags */
                un->un_flag &= ~UN_DIGI_MASK;

                if (file->f_flags & O_EXCL)
                        un->un_flag |= UN_EXCL;

                /* TODO : include "session" and "pgrp" */

                /*
                 *  In Linux, all terminal parameters are intended to be sticky.
                 *  as a result, we "remove" the code which once reset the ports
                 *  to sane values.
                 */

                drp_param(ch);

        }

        un->un_flag |= UN_INITIALIZED;

        retval = 0;

unlock:

        spin_unlock_irqrestore(&nd->nd_lock, lock_flags);

done:
        /*
         * Linux does a close for every open, even failed ones!
         */
        if (!counts_were_incremented) {
                un->un_open_count++;
                ch->ch_open_count++;
        }

        if (retval)
                dev_err(tty->dev, "tty open bad return (%i)\n", retval);

        return retval;
}




/*
 * dgrp_tty_close() -- close function for tty_operations
 */
static void dgrp_tty_close(struct tty_struct *tty, struct file *file)
{
        struct ch_struct *ch;
        struct un_struct *un;
        struct nd_struct *nd;
        int     tpos;
        int     port;
        int     err = 0;
        int     s = 0;
        ulong  waketime;
        ulong  lock_flags;
        int sent_printer_offstr = 0;

        port = PORT_NUM(MINOR(tty_devnum(tty)));

        un = tty->driver_data;

        if (!un)
                return;

        ch = un->un_ch;

        if (!ch)
                return;

        nd = ch->ch_nd;

        if (!nd)
                return;

        spin_lock_irqsave(&nd->nd_lock, lock_flags);


        /* Used to be on channel basis, now we check on a unit basis. */
        if (un->un_open_count != 1)
                goto unlock;

        /*
         * OK, its the last close on the unit
         */
        un->un_flag |= UN_CLOSING;

        /*
         * Notify the discipline to only process XON/XOFF characters.
         */
        tty->closing = 1;

        /*
         * Wait for output to drain only if this is
         * the last close against the channel
         */

        if (ch->ch_open_count == 1) {
                /*
                 * If its the print device, we need to ensure at all costs that
                 * the offstr will fit. If it won't, flush our tbuf.
                 */
                if (IS_PRINT(MINOR(tty_devnum(tty))) &&
                    (((ch->ch_tout - ch->ch_tin - 1) & TBUF_MASK) <
                    ch->ch_digi.digi_offlen))
                        ch->ch_tin = ch->ch_tout;

                /*
                 * Turn off the printer.  Don't bother checking to see if its
                 * IS_PRINT... Since this is the last close the flag is going
                 * to be cleared, so we MUST make sure the offstr gets inserted
                 * into tbuf.
                 */

                if ((ch->ch_flag & CH_PRON) != 0) {
                        drp_wmove(ch, 0, ch->ch_digi.digi_offstr,
                                  ch->ch_digi.digi_offlen);
                        ch->ch_flag &= ~CH_PRON;
                        sent_printer_offstr = 1;
                }
        }

        /*
         *  Wait until either the output queue has drained, or we see
         *  absolutely no progress for 15 seconds.
         */

        tpos = ch->ch_s_tpos;

        waketime = jiffies + 15 * HZ;

        for (;;) {

                /*
                 *  Make sure the port still exists.
                 */

                if (port >= nd->nd_chan_count) {
                        err = 1;
                        break;
                }

                if (signal_pending(current)) {
                        err = 1;
                        break;
                }

                /*
                 * If the port is idle (not opened on the server), we have
                 * no way of draining/flushing/closing the port on that server.
                 * So break out of loop.
                 */
                if (ch->ch_state == CS_IDLE)
                        break;

                nd->nd_tx_work = 1;

                /*
                 *  Exit if the queues for this unit are empty,
                 *  and either the other unit is still open or all
                 *  data has drained.
                 */

                if ((un->un_tty)->ops->chars_in_buffer ?
                    ((un->un_tty)->ops->chars_in_buffer)(un->un_tty) == 0 : 1) {

                        /*
                         * We don't need to wait for a buffer to drain
                         * if the other unit is open.
                         */

                        if (ch->ch_open_count != un->un_open_count)
                                break;

                        /*
                         *  The wait is complete when all queues are
                         *  drained, and any break in progress is complete.
                         */

                        if (ch->ch_tin == ch->ch_tout &&
                            ch->ch_s_tin == ch->ch_s_tpos &&
                            (ch->ch_send & RR_TX_BREAK) == 0) {
                                break;
                        }
                }

                /*
                 * Flush TX data and exit the wait if NDELAY is set,
                 * or this is not a DIGI printer, and the close timeout
                 * expires.
                 */

                if ((file->f_flags & (O_NDELAY | O_NONBLOCK)) ||
                    ((long)(jiffies - waketime) >= 0 &&
                      (ch->ch_digi.digi_flags & DIGI_PRINTER) == 0)) {

                                /*
                                 * If we sent the printer off string, we cannot
                                 * flush our internal buffers, or we might lose
                                 * the offstr.
                                 */
                                if (!sent_printer_offstr)
                                        dgrp_tty_flush_buffer(tty);

                                spin_unlock_irqrestore(&nd->nd_lock, lock_flags);
                                tty_ldisc_flush(tty);
                                spin_lock_irqsave(&nd->nd_lock, lock_flags);
                                break;
                }

                /*
                 *  Otherwise take a short nap.
                 */

                ch->ch_flag |= CH_DRAIN;

                spin_unlock_irqrestore(&nd->nd_lock, lock_flags);

                schedule_timeout_interruptible(1);
                s = signal_pending(current);

                spin_lock_irqsave(&nd->nd_lock, lock_flags);

                if (s) {
                        /*
                         * If we had sent the printer off string, we now have
                         * some problems.
                         *
                         * The system won't let us sleep since we got an error
                         * back from sleep, presumably because the user did
                         * a ctrl-c...
                         * But we need to ensure that the offstr gets sent!
                         * Thus, we have to do something else besides sleeping.
                         * The plan:
                         * 1) Make this task uninterruptable.
                         * 2) Set up a timer to go off in 1 sec.
                         * 3) Act as tho we just got out of the sleep above.
                         *
                         * Thankfully, in the real world, this just
                         * never happens.
                         */

                        if (sent_printer_offstr) {
                                spin_unlock_irqrestore(&nd->nd_lock,
                                                       lock_flags);
                                drp_my_sleep(ch);
                                spin_lock_irqsave(&nd->nd_lock, lock_flags);
                        } else {
                                err = 1;
                                break;
                        }
                }

                /*
                 *  Restart the wait if any progress is seen.
                 */

                if (ch->ch_s_tpos != tpos) {
                        tpos = ch->ch_s_tpos;

                        /* TODO:  this gives us timeout problems with nist ?? */
                        waketime = jiffies + 15 * HZ;
                }
        }

        /*
         *  Close the line discipline
         */

        /* this is done in tty_io.c */
        /* if ((un->un_tty)->ldisc.close)
         *      ((un->un_tty)->ldisc.close)(un->un_tty);
         */

        /* don't do this here */
        /* un->un_flag = 0; */

        /*
         *  Flush the receive buffer on terminal unit close only.
         */

        if (!IS_PRINT(MINOR(tty_devnum(tty))))
                ch->ch_rout = ch->ch_rin;


        /*
         * Don't permit the close to happen until we get any pending
         * sync request responses.
         * There could be other ports depending upon the response as well.
         *
         * Also, don't permit the close to happen until any parameter
         * changes have been sent out from the state machine as well.
         * This is required because of a ditty -a race with -HUPCL
         * We MUST make sure all channel parameters have been sent to the
         * Portserver before sending a close.
         */

        if ((err != 1) && (ch->ch_state != CS_IDLE)) {
                spin_unlock_irqrestore(&nd->nd_lock, lock_flags);
                s = wait_event_interruptible(ch->ch_flag_wait,
                        ((ch->ch_flag & (CH_WAITING_SYNC | CH_PARAM)) == 0));
                spin_lock_irqsave(&nd->nd_lock, lock_flags);
        }

        /*
         * Cleanup the channel if last unit open.
         */

        if (ch->ch_open_count == 1) {
                ch->ch_flag = 0;
                ch->ch_category = 0;
                ch->ch_send = 0;
                ch->ch_expect = 0;
                ch->ch_tout = ch->ch_tin;
                /* (un->un_tty)->device = 0; */

                if (ch->ch_state == CS_READY)
                        ch->ch_state = CS_SEND_CLOSE;
        }

        /*
         * Send the changes to the server
         */
        if (ch->ch_state != CS_IDLE) {
                ch->ch_flag |= CH_PARAM;
                wake_up_interruptible(&ch->ch_flag_wait);
        }

        nd->nd_tx_work = 1;
        nd->nd_tx_ready = 1;

unlock:
        tty->closing = 0;

        if (ch->ch_open_count <= 0)
                dev_info(tty->dev,
                         "%s - unexpected value for ch->ch_open_count: %i\n",
                         __func__, ch->ch_open_count);
        else
                ch->ch_open_count--;

        if (un->un_open_count <= 0)
                dev_info(tty->dev,
                         "%s - unexpected value for un->un_open_count: %i\n",
                         __func__, un->un_open_count);
        else
                un->un_open_count--;

        un->un_flag &= ~(UN_NORMAL_ACTIVE | UN_CALLOUT_ACTIVE | UN_CLOSING);
        if (waitqueue_active(&un->un_close_wait))
                wake_up_interruptible(&un->un_close_wait);

        spin_unlock_irqrestore(&nd->nd_lock, lock_flags);

        return;

}

static void drp_wmove(struct ch_struct *ch, int from_user, void *buf, int count)
{
        int n;
        int ret = 0;

        ch->ch_nd->nd_tx_work = 1;

        n = TBUF_MAX - ch->ch_tin;

        if (count >= n) {
                if (from_user)
                        ret = copy_from_user(ch->ch_tbuf + ch->ch_tin,
                                             (void __user *) buf, n);
                else
                        memcpy(ch->ch_tbuf + ch->ch_tin, buf, n);

                buf = (char *) buf + n;
                count -= n;
                ch->ch_tin = 0;
        }

        if (from_user)
                ret = copy_from_user(ch->ch_tbuf + ch->ch_tin,
                                     (void __user *) buf, count);
        else
                memcpy(ch->ch_tbuf + ch->ch_tin, buf, count);

        ch->ch_tin += count;
}


static int dgrp_calculate_txprint_bounds(struct ch_struct *ch, int space,
                                         int *un_flag)
{
        clock_t tt;
        clock_t mt;
        unsigned short tmax = 0;

        /*
         * If the terminal device is busy, reschedule when
         * the terminal device becomes idle.
         */

        if (ch->ch_tun.un_open_count != 0 &&
            ch->ch_tun.un_tty->ops->chars_in_buffer &&
            ((ch->ch_tun.un_tty->ops->chars_in_buffer)
             (ch->ch_tun.un_tty) != 0)) {
                *un_flag = UN_PWAIT;
                return 0;
        }

        /*
         * Assure that whenever there is printer data in the output
         * buffer, there always remains enough space after it to
         * turn the printer off.
         */
        space -= ch->ch_digi.digi_offlen;

        if (space <= 0) {
                *un_flag = UN_EMPTY;
                return 0;
        }

        /*
         * We measure printer CPS speed by incrementing
         * ch_cpstime by (HZ / digi_maxcps) for every
         * character we output, restricting output so
         * that ch_cpstime never exceeds lbolt.
         *
         * However if output has not been done for some
         * time, lbolt will grow to very much larger than
         * ch_cpstime, which would allow essentially
         * unlimited amounts of output until ch_cpstime
         * finally caught up.   To avoid this, we adjust
         * cps_time when necessary so the difference
         * between lbolt and ch_cpstime never results
         * in sending more than digi_bufsize characters.
         *
         * This nicely models a printer with an internal
         * buffer of digi_bufsize characters.
         *
         * Get the time between lbolt and ch->ch_cpstime;
         */

        tt = jiffies - ch->ch_cpstime;

        /*
         * Compute the time required to send digi_bufsize
         * characters.
         */

        mt = HZ * ch->ch_digi.digi_bufsize / ch->ch_digi.digi_maxcps;

        /*
         * Compute the number of characters that can be sent
         * without violating the time constraint.   If the
         * direct calculation of this number is bigger than
         * digi_bufsize, limit the number to digi_bufsize,
         * and adjust cpstime to match.
         */

        if ((clock_t)(tt + HZ) > (clock_t)(mt + HZ)) {
                tmax = ch->ch_digi.digi_bufsize;
                ch->ch_cpstime = jiffies - mt;
        } else {
                tmax = ch->ch_digi.digi_maxcps * tt / HZ;
        }

        /*
         * If the time constraint now binds, limit the transmit
         * count accordingly, and tentatively arrange to be
         * rescheduled based on time.
         */

        if (tmax < space) {
                *un_flag = UN_TIME;
                space = tmax;
        }

        /*
         * Compute the total number of characters we can
         * output before the total number of characters known
         * to be in the output queue exceeds digi_maxchar.
         */

        tmax = (ch->ch_digi.digi_maxchar -
                ((ch->ch_tin - ch->ch_tout) & TBUF_MASK) -
                ((ch->ch_s_tin - ch->ch_s_tpos) & 0xffff));


        /*
         * If the digi_maxchar constraint now holds, limit
         * the transmit count accordingly, and arrange to
         * be rescheduled when the queue becomes empty.
         */

        if (space > tmax) {
                *un_flag = UN_EMPTY;
                space = tmax;
        }

        if (space <= 0)
                *un_flag |= UN_EMPTY;

        return space;
}


static int dgrp_tty_write(struct tty_struct *tty,
                          const unsigned char *buf,
                          int count)
{
        struct nd_struct *nd;
        struct un_struct *un;
        struct ch_struct *ch;
        int     space;
        int     n;
        int     t;
        int sendcount;
        int un_flag;
        ulong lock_flags;

        if (tty == NULL)
                return 0;

        un = tty->driver_data;
        if (!un)
                return 0;

        ch = un->un_ch;
        if (!ch)
                return 0;

        nd = ch->ch_nd;
        if (!nd)
                return 0;

        /*
         * Ignore the request if the channel is not ready.
         */
        if (ch->ch_state != CS_READY)
                return 0;

        spin_lock_irqsave(&dgrp_poll_data.poll_lock, lock_flags);

        /*
         * Ignore the request if output is blocked.
         */
        if ((un->un_flag & (UN_EMPTY | UN_LOW | UN_TIME | UN_PWAIT)) != 0) {
                count = 0;
                goto out;
        }

        /*
         * Also ignore the request if DPA has this port open,
         * and is flow controlled on reading more data.
         */
        if (nd->nd_dpa_debug && nd->nd_dpa_flag & DPA_WAIT_SPACE &&
                nd->nd_dpa_port == MINOR(tty_devnum(ch->ch_tun.un_tty))) {
                count = 0;
                goto out;
        }

        /*
         *      Limit amount we will write to the amount of space
         *      available in the channel buffer.
         */
        sendcount = 0;

        space = (ch->ch_tout - ch->ch_tin - 1) & TBUF_MASK;

        /*
         * Handle the printer device.
         */

        un_flag = UN_LOW;

        if (IS_PRINT(MINOR(tty_devnum(tty)))) {
                clock_t tt;
                clock_t mt;
                unsigned short tmax = 0;

                /*
                 * If the terminal device is busy, reschedule when
                 * the terminal device becomes idle.
                 */

                if (ch->ch_tun.un_open_count != 0 &&
                    ((ch->ch_tun.un_tty->ops->chars_in_buffer)
                     (ch->ch_tun.un_tty) != 0)) {
                        un->un_flag |= UN_PWAIT;
                        count = 0;
                        goto out;
                }

                /*
                 * Assure that whenever there is printer data in the output
                 * buffer, there always remains enough space after it to
                 * turn the printer off.
                 */
                space -= ch->ch_digi.digi_offlen;

                /*
                 * Output the printer on string.
                 */

                if ((ch->ch_flag & CH_PRON) == 0) {
                        space -= ch->ch_digi.digi_onlen;

                        if (space < 0) {
                                un->un_flag |= UN_EMPTY;
                                (ch->ch_nd)->nd_tx_work = 1;
                                count = 0;
                                goto out;
                        }

                        drp_wmove(ch, 0, ch->ch_digi.digi_onstr,
                                ch->ch_digi.digi_onlen);

                        ch->ch_flag |= CH_PRON;
                }

                /*
                 * We measure printer CPS speed by incrementing
                 * ch_cpstime by (HZ / digi_maxcps) for every
                 * character we output, restricting output so
                 * that ch_cpstime never exceeds lbolt.
                 *
                 * However if output has not been done for some
                 * time, lbolt will grow to very much larger than
                 * ch_cpstime, which would allow essentially
                 * unlimited amounts of output until ch_cpstime
                 * finally caught up.   To avoid this, we adjust
                 * cps_time when necessary so the difference
                 * between lbolt and ch_cpstime never results
                 * in sending more than digi_bufsize characters.
                 *
                 * This nicely models a printer with an internal
                 * buffer of digi_bufsize characters.
                 *
                 * Get the time between lbolt and ch->ch_cpstime;
                 */

                tt = jiffies - ch->ch_cpstime;

                /*
                 * Compute the time required to send digi_bufsize
                 * characters.
                 */

                mt = HZ * ch->ch_digi.digi_bufsize / ch->ch_digi.digi_maxcps;

                /*
                 * Compute the number of characters that can be sent
                 * without violating the time constraint.   If the
                 * direct calculation of this number is bigger than
                 * digi_bufsize, limit the number to digi_bufsize,
                 * and adjust cpstime to match.
                 */

                if ((clock_t)(tt + HZ) > (clock_t)(mt + HZ)) {
                        tmax = ch->ch_digi.digi_bufsize;
                        ch->ch_cpstime = jiffies - mt;
                } else {
                        tmax = ch->ch_digi.digi_maxcps * tt / HZ;
                }

                /*
                 * If the time constraint now binds, limit the transmit
                 * count accordingly, and tentatively arrange to be
                 * rescheduled based on time.
                 */

                if (tmax < space) {
                        space = tmax;
                        un_flag = UN_TIME;
                }

                /*
                 * Compute the total number of characters we can
                 * output before the total number of characters known
                 * to be in the output queue exceeds digi_maxchar.
                 */

                tmax = (ch->ch_digi.digi_maxchar -
                        ((ch->ch_tin - ch->ch_tout) & TBUF_MASK) -
                        ((ch->ch_s_tin - ch->ch_s_tpos) & 0xffff));


                /*
                 * If the digi_maxchar constraint now holds, limit
                 * the transmit count accordingly, and arrange to
                 * be rescheduled when the queue becomes empty.
                 */

                if (space > tmax) {
                        space = tmax;
                        un_flag = UN_EMPTY;
                }

        }
        /*
         * Handle the terminal device.
         */
        else {

                /*
                 * If the printer device is on, turn it off.
                 */

                if ((ch->ch_flag & CH_PRON) != 0) {

                        space -= ch->ch_digi.digi_offlen;

                        drp_wmove(ch, 0, ch->ch_digi.digi_offstr,
                                  ch->ch_digi.digi_offlen);

                        ch->ch_flag &= ~CH_PRON;
                }
        }

        /*
         *      If space is 0 and its because the ch->tbuf
         *      is full, then Linux will handle a callback when queue
         *      space becomes available.
         *      tty_write returns count = 0
         */

        if (space <= 0) {
                /* the linux tty_io.c handles this if we return 0 */
                /* if (fp->flags & O_NONBLOCK) return -EAGAIN; */

                un->un_flag |= UN_EMPTY;
                (ch->ch_nd)->nd_tx_work = 1;
                count = 0;
                goto out;
        }

        count = min(count, space);

        if (count > 0) {

                un->un_tbusy++;

                /*
                 *      Copy the buffer contents to the ch_tbuf
                 *      being careful to wrap around the circular queue
                 */

                t = TBUF_MAX - ch->ch_tin;
                n = count;

                if (n >= t) {
                        memcpy(ch->ch_tbuf + ch->ch_tin, buf, t);
                        if (nd->nd_dpa_debug && nd->nd_dpa_port ==
                                PORT_NUM(MINOR(tty_devnum(un->un_tty))))
                                dgrp_dpa_data(nd, 0, (char *) buf, t);
                        buf += t;
                        n -= t;
                        ch->ch_tin = 0;
                        sendcount += n;
                }

                memcpy(ch->ch_tbuf + ch->ch_tin, buf, n);
                if (nd->nd_dpa_debug && nd->nd_dpa_port ==
                        PORT_NUM(MINOR(tty_devnum(un->un_tty))))
                        dgrp_dpa_data(nd, 0, (char *) buf, n);
                buf += n;
                ch->ch_tin += n;
                sendcount += n;

                un->un_tbusy--;
                (ch->ch_nd)->nd_tx_work = 1;
                if (ch->ch_edelay != DGRP_RTIME) {
                        (ch->ch_nd)->nd_tx_ready = 1;
                        wake_up_interruptible(&nd->nd_tx_waitq);
                }
        }

        ch->ch_txcount += count;

        if (IS_PRINT(MINOR(tty_devnum(tty)))) {

                /*
                 * Adjust ch_cpstime to account
                 * for the characters just output.
                 */

                if (sendcount > 0) {
                        int cc = HZ * sendcount + ch->ch_cpsrem;

                        ch->ch_cpstime += cc / ch->ch_digi.digi_maxcps;
                        ch->ch_cpsrem   = cc % ch->ch_digi.digi_maxcps;
                }

                /*
                 * If we are now waiting on time, schedule ourself
                 * back when we'll be able to send a block of
                 * digi_maxchar characters.
                 */

                if ((un_flag & UN_TIME) != 0) {
                        ch->ch_waketime = (ch->ch_cpstime +
                                (ch->ch_digi.digi_maxchar * HZ /
                                ch->ch_digi.digi_maxcps));
                }
        }

        /*
         * If the printer unit is waiting for completion
         * of terminal output, get him going again.
         */

        if ((ch->ch_pun.un_flag & UN_PWAIT) != 0)
                (ch->ch_nd)->nd_tx_work = 1;

out:
        spin_unlock_irqrestore(&dgrp_poll_data.poll_lock, lock_flags);

        return count;
}


/*
 *      Put a character into ch->ch_buf
 *
 *      - used by the line discipline for OPOST processing
 */

static int dgrp_tty_put_char(struct tty_struct *tty, unsigned char new_char)
{
        struct un_struct *un;
        struct ch_struct *ch;
        ulong  lock_flags;
        int space;
        int retval = 0;

        if (tty == NULL)
                return 0;

        un = tty->driver_data;
        if (!un)
                return 0;

        ch = un->un_ch;
        if (!ch)
                return 0;

        if (ch->ch_state != CS_READY)
                return 0;

        spin_lock_irqsave(&dgrp_poll_data.poll_lock, lock_flags);


        /*
         *      If space is 0 and its because the ch->tbuf
         *      Warn and dump the character, there isn't anything else
         *      we can do about it.  David_Fries@digi.com
         */

        space = (ch->ch_tout - ch->ch_tin - 1) & TBUF_MASK;

        un->un_tbusy++;

        /*
         * Output the printer on string if device is TXPrint.
         */
        if (IS_PRINT(MINOR(tty_devnum(tty))) && (ch->ch_flag & CH_PRON) == 0) {
                if (space < ch->ch_digi.digi_onlen) {
                        un->un_tbusy--;
                        goto out;
                }
                space -= ch->ch_digi.digi_onlen;
                drp_wmove(ch, 0, ch->ch_digi.digi_onstr,
                          ch->ch_digi.digi_onlen);
                ch->ch_flag |= CH_PRON;
        }

        /*
         * Output the printer off string if device is NOT TXPrint.
         */

        if (!IS_PRINT(MINOR(tty_devnum(tty))) &&
            ((ch->ch_flag & CH_PRON) != 0)) {
                if (space < ch->ch_digi.digi_offlen) {
                        un->un_tbusy--;
                        goto out;
                }

                space -= ch->ch_digi.digi_offlen;
                drp_wmove(ch, 0, ch->ch_digi.digi_offstr,
                          ch->ch_digi.digi_offlen);
                ch->ch_flag &= ~CH_PRON;
        }

        if (!space) {
                un->un_tbusy--;
                goto out;
        }

        /*
         *      Copy the character to the ch_tbuf being
         *      careful to wrap around the circular queue
         */
        ch->ch_tbuf[ch->ch_tin] = new_char;
        ch->ch_tin = (1 + ch->ch_tin) & TBUF_MASK;

        if (IS_PRINT(MINOR(tty_devnum(tty)))) {

                /*
                 * Adjust ch_cpstime to account
                 * for the character just output.
                 */

                int cc = HZ + ch->ch_cpsrem;

                ch->ch_cpstime += cc / ch->ch_digi.digi_maxcps;
                ch->ch_cpsrem   = cc % ch->ch_digi.digi_maxcps;

                /*
                 * If we are now waiting on time, schedule ourself
                 * back when we'll be able to send a block of
                 * digi_maxchar characters.
                 */

                ch->ch_waketime = (ch->ch_cpstime +
                        (ch->ch_digi.digi_maxchar * HZ /
                        ch->ch_digi.digi_maxcps));
        }


        un->un_tbusy--;
        (ch->ch_nd)->nd_tx_work = 1;

        retval = 1;
out:
        spin_unlock_irqrestore(&dgrp_poll_data.poll_lock, lock_flags);
        return retval;
}



/*
 *      Flush TX buffer (make in == out)
 *
 *      check tty_ioctl.c  -- this is called after TCOFLUSH
 */
static void dgrp_tty_flush_buffer(struct tty_struct *tty)
{
        struct un_struct *un;
        struct ch_struct *ch;

        if (!tty)
                return;
        un = tty->driver_data;
        if (!un)
                return;

        ch = un->un_ch;
        if (!ch)
                return;

        ch->ch_tout = ch->ch_tin;
        /* do NOT do this here! */
        /* ch->ch_s_tpos = ch->ch_s_tin = 0; */

        /* send the flush output command now */
        ch->ch_send |= RR_TX_FLUSH;
        (ch->ch_nd)->nd_tx_ready = 1;
        (ch->ch_nd)->nd_tx_work = 1;
        wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);

        if (waitqueue_active(&tty->write_wait))
                wake_up_interruptible(&tty->write_wait);

        tty_wakeup(tty);

}

/*
 *      Return space available in Tx buffer
 *      count = ( ch->ch_tout - ch->ch_tin ) mod (TBUF_MAX - 1)
 */
static int dgrp_tty_write_room(struct tty_struct *tty)
{
        struct un_struct *un;
        struct ch_struct *ch;
        int     count;

        if (!tty)
                return 0;

        un = tty->driver_data;
        if (!un)
                return 0;

        ch = un->un_ch;
        if (!ch)
                return 0;

        count = (ch->ch_tout - ch->ch_tin - 1) & TBUF_MASK;

        /* We *MUST* check this, and return 0 if the Printer Unit cannot
         * take any more data within its time constraints...  If we don't
         * return 0 and the printer has hit it time constraint, the ld will
         * call us back doing a put_char, which cannot be rejected!!!
         */
        if (IS_PRINT(MINOR(tty_devnum(tty)))) {
                int un_flag = 0;
                count = dgrp_calculate_txprint_bounds(ch, count, &un_flag);
                if (count <= 0)
                        count = 0;

                ch->ch_pun.un_flag |= un_flag;
                (ch->ch_nd)->nd_tx_work = 1;
        }

        return count;
}

/*
 *      Return number of characters that have not been transmitted yet.
 *      chars_in_buffer = ( ch->ch_tin - ch->ch_tout ) mod (TBUF_MAX - 1)
 *                      + ( ch->ch_s_tin - ch->ch_s_tout ) mod (0xffff)
 *                      = number of characters "in transit"
 *
 * Remember that sequence number math is always with a sixteen bit
 * mask, not the TBUF_MASK.
 */

static int dgrp_tty_chars_in_buffer(struct tty_struct *tty)
{
        struct un_struct *un;
        struct ch_struct *ch;
        int     count;
        int     count1;

        if (!tty)
                return 0;

        un = tty->driver_data;
        if (!un)
                return 0;

        ch = un->un_ch;
        if (!ch)
                return 0;

        count1 = count = (ch->ch_tin - ch->ch_tout) & TBUF_MASK;
        count += (ch->ch_s_tin - ch->ch_s_tpos) & 0xffff;
        /* one for tbuf, one for the PS */

        /*
         * If we are busy transmitting add 1
         */
        count += un->un_tbusy;

        return count;
}


/*****************************************************************************
 *
 * Helper applications for dgrp_tty_ioctl()
 *
 *****************************************************************************
 */


/**
 * ch_to_tty_flags() -- convert channel flags to termio flags
 * @ch_flag: Digi channel flags
 * @flagtype: type of ch_flag (iflag, oflag or cflag)
 *
 * take the channel flags of the specified type and return the
 * corresponding termio flag
 */
static tcflag_t ch_to_tty_flags(ushort ch_flag, char flagtype)
{
        tcflag_t retval = 0;

        switch (flagtype) {
        case 'i':
                retval = ((ch_flag & IF_IGNBRK) ? IGNBRK : 0)

                     | ((ch_flag & IF_BRKINT) ? BRKINT : 0)
                     | ((ch_flag & IF_IGNPAR) ? IGNPAR : 0)
                     | ((ch_flag & IF_PARMRK) ? PARMRK : 0)
                     | ((ch_flag & IF_INPCK) ? INPCK  : 0)
                     | ((ch_flag & IF_ISTRIP) ? ISTRIP : 0)
                     | ((ch_flag & IF_IXON) ? IXON   : 0)
                     | ((ch_flag & IF_IXANY) ? IXANY  : 0)
                     | ((ch_flag & IF_IXOFF) ? IXOFF  : 0);
                break;

        case 'o':
                retval = ((ch_flag & OF_OLCUC) ? OLCUC : 0)
                     | ((ch_flag & OF_ONLCR) ? ONLCR  : 0)
                     | ((ch_flag & OF_OCRNL) ? OCRNL  : 0)
                     | ((ch_flag & OF_ONOCR) ? ONOCR  : 0)
                     | ((ch_flag & OF_ONLRET) ? ONLRET : 0)
                  /* | ((ch_flag & OF_OTAB3) ? OFILL  : 0) */
                     | ((ch_flag & OF_TABDLY) ? TABDLY : 0);
                break;

        case 'c':
                retval = ((ch_flag & CF_CSTOPB) ? CSTOPB : 0)
                     | ((ch_flag & CF_CREAD) ? CREAD  : 0)
                     | ((ch_flag & CF_PARENB) ? PARENB : 0)
                     | ((ch_flag & CF_PARODD) ? PARODD : 0)
                     | ((ch_flag & CF_HUPCL) ? HUPCL  : 0);

                switch (ch_flag & CF_CSIZE) {
                case CF_CS5:
                        retval |= CS5;
                        break;
                case CF_CS6:
                        retval |= CS6;
                        break;
                case CF_CS7:
                        retval |= CS7;
                        break;
                case CF_CS8:
                        retval |= CS8;
                        break;
                default:
                        retval |= CS8;
                        break;
                }
                break;
        case 'x':
                break;
        case 'l':
                break;
        default:
                return 0;
        }

        return retval;
}


/**
 * tty_to_ch_flags() -- convert termio flags to digi channel flags
 * @tty: pointer to a TTY structure holding flag to be converted
 * @flagtype: identifies which flag (iflags, oflags, or cflags) should
 *                 be converted
 *
 * take the termio flag of the specified type and return the
 * corresponding Digi version of the flags
 */
static ushort tty_to_ch_flags(struct tty_struct *tty, char flagtype)
{
        ushort retval = 0;
        tcflag_t tflag = 0;

        switch (flagtype) {
        case 'i':
                tflag  = tty->termios.c_iflag;
                retval = (I_IGNBRK(tty) ? IF_IGNBRK : 0)
                      | (I_BRKINT(tty) ? IF_BRKINT : 0)
                      | (I_IGNPAR(tty) ? IF_IGNPAR : 0)
                      | (I_PARMRK(tty) ? IF_PARMRK : 0)
                      | (I_INPCK(tty)  ? IF_INPCK  : 0)
                      | (I_ISTRIP(tty) ? IF_ISTRIP : 0)
                      | (I_IXON(tty)   ? IF_IXON   : 0)
                      | (I_IXANY(tty)  ? IF_IXANY  : 0)
                      | (I_IXOFF(tty)  ? IF_IXOFF  : 0);
                break;
        case 'o':
                tflag  = tty->termios.c_oflag;
                /*
                 * If OPOST is set, then do the post processing in the
                 * firmware by setting all the processing flags on.
                 * If ~OPOST, then make sure we are not doing any
                 * output processing!!
                 */
                if (!O_OPOST(tty))
                        retval = 0;
                else
                        retval = (O_OLCUC(tty) ? OF_OLCUC : 0)
                             | (O_ONLCR(tty)  ? OF_ONLCR  : 0)
                             | (O_OCRNL(tty)  ? OF_OCRNL  : 0)
                             | (O_ONOCR(tty)  ? OF_ONOCR  : 0)
                             | (O_ONLRET(tty) ? OF_ONLRET : 0)
                          /* | (O_OFILL(tty)  ? OF_TAB3   : 0) */
                             | (O_TABDLY(tty) ? OF_TABDLY : 0);
                break;
        case 'c':
                tflag  = tty->termios.c_cflag;
                retval = (C_CSTOPB(tty) ? CF_CSTOPB : 0)
                     | (C_CREAD(tty)  ? CF_CREAD  : 0)
                     | (C_PARENB(tty) ? CF_PARENB : 0)
                     | (C_PARODD(tty) ? CF_PARODD : 0)
                     | (C_HUPCL(tty)  ? CF_HUPCL  : 0);
                switch (C_CSIZE(tty)) {
                case CS8:
                        retval |= CF_CS8;
                        break;
                case CS7:
                        retval |= CF_CS7;
                        break;
                case CS6:
                        retval |= CF_CS6;
                        break;
                case CS5:
                        retval |= CF_CS5;
                        break;
                default:
                        retval |= CF_CS8;
                        break;
                }
                break;
        case 'x':
                break;
        case 'l':
                break;
        default:
                return 0;
        }

        return retval;
}


static int dgrp_tty_send_break(struct tty_struct *tty, int msec)
{
        struct un_struct *un;
        struct ch_struct *ch;
        int ret = -EIO;

        if (!tty)
                return ret;

        un = tty->driver_data;
        if (!un)
                return ret;

        ch = un->un_ch;
        if (!ch)
                return ret;

        dgrp_send_break(ch, msec);
        return 0;
}


/*
 * This routine sends a break character out the serial port.
 *
 * duration is in 1/1000's of a second
 */
static int dgrp_send_break(struct ch_struct *ch, int msec)
{
        ulong x;

        wait_event_interruptible(ch->ch_flag_wait,
                ((ch->ch_flag & CH_TX_BREAK) == 0));
        ch->ch_break_time += max(msec, 250);
        ch->ch_send |= RR_TX_BREAK;
        ch->ch_flag |= CH_TX_BREAK;
        (ch->ch_nd)->nd_tx_work = 1;

        x = (msec * HZ) / 1000;
        wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);

        return 0;
}


/*
 * Return modem signals to ld.
 */
static int dgrp_tty_tiocmget(struct tty_struct *tty)
{
        unsigned int mlast;
        struct un_struct *un = tty->driver_data;
        struct ch_struct *ch;

        if (!un)
                return -ENODEV;

        ch = un->un_ch;
        if (!ch)
                return -ENODEV;

        mlast = ((ch->ch_s_mlast & ~(DM_RTS | DM_DTR)) |
                (ch->ch_mout & (DM_RTS | DM_DTR)));

        /* defined in /usr/include/asm/termios.h */
        mlast =   ((mlast & DM_RTS) ? TIOCM_RTS : 0)
                | ((mlast & DM_DTR) ? TIOCM_DTR : 0)
                | ((mlast & DM_CD)  ? TIOCM_CAR : 0)
                | ((mlast & DM_RI)  ? TIOCM_RNG : 0)
                | ((mlast & DM_DSR) ? TIOCM_DSR : 0)
                | ((mlast & DM_CTS) ? TIOCM_CTS : 0);

        return mlast;
}


/*
 *      Set modem lines
 */
static int dgrp_tty_tiocmset(struct tty_struct *tty,
                             unsigned int set, unsigned int clear)
{
        ulong lock_flags;
        struct un_struct *un = tty->driver_data;
        struct ch_struct *ch;

        if (!un)
                return -ENODEV;

        ch = un->un_ch;
        if (!ch)
                return -ENODEV;

        if (set & TIOCM_RTS)
                ch->ch_mout |= DM_RTS;

        if (set & TIOCM_DTR)
                ch->ch_mout |= DM_DTR;

        if (clear & TIOCM_RTS)
                ch->ch_mout &= ~(DM_RTS);

        if (clear & TIOCM_DTR)
                ch->ch_mout &= ~(DM_DTR);

        spin_lock_irqsave(&(ch->ch_nd)->nd_lock, lock_flags);
        ch->ch_flag |= CH_PARAM;
        (ch->ch_nd)->nd_tx_work = 1;
        wake_up_interruptible(&ch->ch_flag_wait);

        spin_unlock_irqrestore(&(ch->ch_nd)->nd_lock, lock_flags);

        return 0;
}



/*
 *      Get current modem status
 */
static int get_modem_info(struct ch_struct *ch, unsigned int *value)
{
        unsigned int mlast;

        mlast = ((ch->ch_s_mlast & ~(DM_RTS | DM_DTR)) |
                (ch->ch_mout    &  (DM_RTS | DM_DTR)));

        /* defined in /usr/include/asm/termios.h */
        mlast =   ((mlast & DM_RTS) ? TIOCM_RTS : 0)
                | ((mlast & DM_DTR) ? TIOCM_DTR : 0)
                | ((mlast & DM_CD)  ? TIOCM_CAR : 0)
                | ((mlast & DM_RI)  ? TIOCM_RNG : 0)
                | ((mlast & DM_DSR) ? TIOCM_DSR : 0)
                | ((mlast & DM_CTS) ? TIOCM_CTS : 0);
        return put_user(mlast, (unsigned int __user *) value);
}

/*
 *      Set modem lines
 */
static int set_modem_info(struct ch_struct *ch, unsigned int command,
                          unsigned int *value)
{
        int error;
        unsigned int arg;
        int mval = 0;
        ulong lock_flags;

        error = access_ok(VERIFY_READ, (void __user *) value, sizeof(int));
        if (error == 0)
                return -EFAULT;

        if (get_user(arg, (unsigned int __user *) value))
                return -EFAULT;
        mval |= ((arg & TIOCM_RTS) ? DM_RTS : 0)
                | ((arg & TIOCM_DTR) ? DM_DTR : 0);

        switch (command) {
        case TIOCMBIS:  /* set flags */
                ch->ch_mout |= mval;
                break;
        case TIOCMBIC:  /* clear flags */
                ch->ch_mout &= ~mval;
                break;
        case TIOCMSET:
                ch->ch_mout = mval;
                break;
        default:
                return -EINVAL;
        }

        spin_lock_irqsave(&(ch->ch_nd)->nd_lock, lock_flags);

        ch->ch_flag |= CH_PARAM;
        (ch->ch_nd)->nd_tx_work = 1;
        wake_up_interruptible(&ch->ch_flag_wait);

        spin_unlock_irqrestore(&(ch->ch_nd)->nd_lock, lock_flags);

        return 0;
}


/*
 *  Assign the custom baud rate to the channel structure
 */
static void dgrp_set_custom_speed(struct ch_struct *ch, int newrate)
{
        int testdiv;
        int testrate_high;
        int testrate_low;

        int deltahigh, deltalow;

        if (newrate < 0)
                newrate = 0;

        /*
         * Since the divisor is stored in a 16-bit integer, we make sure
         * we don't allow any rates smaller than a 16-bit integer would allow.
         * And of course, rates above the dividend won't fly.
         */
        if (newrate && newrate < ((PORTSERVER_DIVIDEND / 0xFFFF) + 1))
                newrate = ((PORTSERVER_DIVIDEND / 0xFFFF) + 1);
        if (newrate && newrate > PORTSERVER_DIVIDEND)
                newrate = PORTSERVER_DIVIDEND;

        while (newrate > 0) {
                testdiv = PORTSERVER_DIVIDEND / newrate;

                /*
                 * If we try to figure out what rate the PortServer would use
                 * with the test divisor, it will be either equal or higher
                 * than the requested baud rate.  If we then determine the
                 * rate with a divisor one higher, we will get the next lower
                 * supported rate below the requested.
                 */
                testrate_high = PORTSERVER_DIVIDEND / testdiv;
                testrate_low  = PORTSERVER_DIVIDEND / (testdiv + 1);

                /*
                 * If the rate for the requested divisor is correct, just
                 * use it and be done.
                 */
                if (testrate_high == newrate)
                        break;

                /*
                 * Otherwise, pick the rate that is closer (i.e. whichever rate
                 * has a smaller delta).
                 */
                deltahigh = testrate_high - newrate;
                deltalow = newrate - testrate_low;

                if (deltahigh < deltalow)
                        newrate = testrate_high;
                else
                        newrate = testrate_low;

                break;
        }

        ch->ch_custom_speed = newrate;

        drp_param(ch);

        return;
}


/*
 # dgrp_tty_digiseta()
 *
 * Ioctl to set the information from ditty.
 *
 * NOTE: DIGI_IXON, DSRPACE, DCDPACE, and DTRPACE are unsupported.  JAR 990922
 */
static int dgrp_tty_digiseta(struct tty_struct *tty,
                             struct digi_struct *new_info)
{
        struct un_struct *un = tty->driver_data;
        struct ch_struct *ch;

        if (!un)
                return -ENODEV;

        ch = un->un_ch;
        if (!ch)
                return -ENODEV;

        if (copy_from_user(&ch->ch_digi, (void __user *) new_info,
                           sizeof(struct digi_struct)))
                return -EFAULT;

        if ((ch->ch_digi.digi_flags & RTSPACE) ||
            (ch->ch_digi.digi_flags & CTSPACE))
                tty->termios.c_cflag |= CRTSCTS;
        else
                tty->termios.c_cflag &= ~CRTSCTS;

        if (ch->ch_digi.digi_maxcps < 1)
                ch->ch_digi.digi_maxcps = 1;

        if (ch->ch_digi.digi_maxcps > 10000)
                ch->ch_digi.digi_maxcps = 10000;

        if (ch->ch_digi.digi_bufsize < 10)
                ch->ch_digi.digi_bufsize = 10;

        if (ch->ch_digi.digi_maxchar < 1)
                ch->ch_digi.digi_maxchar = 1;

        if (ch->ch_digi.digi_maxchar > ch->ch_digi.digi_bufsize)
                ch->ch_digi.digi_maxchar = ch->ch_digi.digi_bufsize;

        if (ch->ch_digi.digi_onlen > DIGI_PLEN)
                ch->ch_digi.digi_onlen = DIGI_PLEN;

        if (ch->ch_digi.digi_offlen > DIGI_PLEN)
                ch->ch_digi.digi_offlen = DIGI_PLEN;

        /* make the changes now */
        drp_param(ch);

        return 0;
}



/*
 * dgrp_tty_digigetedelay()
 *
 * Ioctl to get the current edelay setting.
 *
 *
 *
 */
static int dgrp_tty_digigetedelay(struct tty_struct *tty, int *retinfo)
{
        struct un_struct *un;
        struct ch_struct *ch;
        int tmp;

        if (!retinfo)
                return -EFAULT;

        if (!tty || tty->magic != TTY_MAGIC)
                return -EFAULT;

        un = tty->driver_data;

        if (!un)
                return -ENODEV;

        ch = un->un_ch;
        if (!ch)
                return -ENODEV;

        tmp = ch->ch_edelay;

        if (copy_to_user((void __user *) retinfo, &tmp, sizeof(*retinfo)))
                return -EFAULT;

        return 0;
}


/*
 * dgrp_tty_digisetedelay()
 *
 * Ioctl to set the EDELAY setting
 *
 */
static int dgrp_tty_digisetedelay(struct tty_struct *tty, int *new_info)
{
        struct un_struct *un;
        struct ch_struct *ch;
        int new_digi;

        if (!tty || tty->magic != TTY_MAGIC)
                return -EFAULT;

        un = tty->driver_data;

        if (!un)
                return -ENODEV;

        ch = un->un_ch;
        if (!ch)
                return -ENODEV;

        if (copy_from_user(&new_digi, (void __user *)new_info, sizeof(int)))
                return -EFAULT;

        ch->ch_edelay = new_digi;

        /* make the changes now */
        drp_param(ch);

        return 0;
}


/*
 *      The usual assortment of ioctl's
 *
 *      note:  use tty_check_change to make sure that we are not
 *      changing the state of a terminal when we are not a process
 *      in the forground.  See tty_io.c
 *              rc = tty_check_change(tty);
 *              if (rc) return rc;
 */
static int dgrp_tty_ioctl(struct tty_struct *tty, unsigned int cmd,
                          unsigned long arg)
{
        struct un_struct *un;
        struct ch_struct *ch;
        int rc;
        struct digiflow_struct   dflow;

        if (!tty)
                return -ENODEV;

        un = tty->driver_data;
        if (!un)
                return -ENODEV;

        ch = un->un_ch;
        if (!ch)
                return -ENODEV;

        switch (cmd) {

        /*
         * Here are all the standard ioctl's that we MUST implement
         */

        case TCSBRK:
                /*
                 * TCSBRK is SVID version: non-zero arg --> no break
                 * this behaviour is exploited by tcdrain().
                 *
                 * According to POSIX.1 spec (7.2.2.1.2) breaks should be
                 * between 0.25 and 0.5 seconds
                 */

                rc = tty_check_change(tty);
                if (rc)
                        return rc;
                tty_wait_until_sent(tty, 0);

                if (!arg)
                        rc = dgrp_send_break(ch, 250); /* 1/4 second */

                if (dgrp_tty_chars_in_buffer(tty) != 0)
                        return -EINTR;

                return 0;

        case TCSBRKP:
                /* support for POSIX tcsendbreak()
                 *
                 * According to POSIX.1 spec (7.2.2.1.2) breaks should be
                 * between 0.25 and 0.5 seconds so we'll ask for something
                 * in the middle: 0.375 seconds.
                 */
                rc = tty_check_change(tty);
                if (rc)
                        return rc;
                tty_wait_until_sent(tty, 0);

                rc = dgrp_send_break(ch, arg ? arg*250 : 250);

                if (dgrp_tty_chars_in_buffer(tty) != 0)
                        return -EINTR;
                return 0;

        case TIOCSBRK:
                rc = tty_check_change(tty);
                if (rc)
                        return rc;
                tty_wait_until_sent(tty, 0);

                /*
                 * RealPort doesn't support turning on a break unconditionally.
                 * The RealPort device will stop sending a break automatically
                 * after the specified time value that we send in.
                 */
                rc = dgrp_send_break(ch, 250); /* 1/4 second */

                if (dgrp_tty_chars_in_buffer(tty) != 0)
                        return -EINTR;
                return 0;

        case TIOCCBRK:
                /*
                 * RealPort doesn't support turning off a break unconditionally.
                 * The RealPort device will stop sending a break automatically
                 * after the specified time value that was sent when turning on
                 * the break.
                 */
                return 0;

        case TIOCMGET:
                rc = access_ok(VERIFY_WRITE, (void __user *) arg,
                                 sizeof(unsigned int));
                if (rc == 0)
                        return -EFAULT;
                return get_modem_info(ch, (unsigned int *) arg);

        case TIOCMBIS:
        case TIOCMBIC:
        case TIOCMSET:
                return set_modem_info(ch, cmd, (unsigned int *) arg);

        /*
         * Here are any additional ioctl's that we want to implement
         */

        case TCFLSH:
                /*
                 * The linux tty driver doesn't have a flush
                 * input routine for the driver, assuming all backed
                 * up data is in the line disc. buffers.  However,
                 * we all know that's not the case.  Here, we
                 * act on the ioctl, but then lie and say we didn't
                 * so the line discipline will process the flush
                 * also.
                 */
                rc = tty_check_change(tty);
                if (rc)
                        return rc;

                switch (arg) {
                case TCIFLUSH:
                case TCIOFLUSH:
                        /* only flush input if this is the only open unit */
                        if (!IS_PRINT(MINOR(tty_devnum(tty)))) {
                                ch->ch_rout = ch->ch_rin;
                                ch->ch_send |= RR_RX_FLUSH;
                                (ch->ch_nd)->nd_tx_work = 1;
                                (ch->ch_nd)->nd_tx_ready = 1;
                                wake_up_interruptible(
                                        &(ch->ch_nd)->nd_tx_waitq);
                        }
                        if (arg == TCIFLUSH)
                                break;

                case TCOFLUSH: /* flush output, or the receive buffer */
                        /*
                         * This is handled in the tty_ioctl.c code
                         * calling tty_flush_buffer
                         */
                        break;

                default:
                        /* POSIX.1 says return EINVAL if we got a bad arg */
                        return -EINVAL;
                }
                /* pretend we didn't recognize this IOCTL */
                return -ENOIOCTLCMD;

#ifdef TIOCGETP
        case TIOCGETP:
#endif
        /*****************************************
        Linux           HPUX            Function
        TCSETA          TCSETA          - set the termios
        TCSETAF         TCSETAF         - wait for drain first, then set termios
        TCSETAW         TCSETAW         - wait for drain,
                                        flush the input queue, then set termios
        - looking at the tty_ioctl code, these command all call our
        tty_set_termios at the driver's end, when a TCSETA* is sent,
        it is expecting the tty to have a termio structure,
        NOT a termios structure.  These two structures differ in size
        and the tty_ioctl code does a conversion before processing them both.
        - we should treat the TCSETAW TCSETAF ioctls the same, and let
        the tty_ioctl code do the conversion stuff.

        TCSETS
        TCSETSF         (none)
        TCSETSW
        - the associated tty structure has a termios structure.
        *****************************************/

        case TCGETS:
        case TCGETA:
                return -ENOIOCTLCMD;

        case TCSETAW:
        case TCSETAF:
        case TCSETSF:
        case TCSETSW:
                /*
                 * The linux tty driver doesn't have a flush
                 * input routine for the driver, assuming all backed
                 * up data is in the line disc. buffers.  However,
                 * we all know that's not the case.  Here, we
                 * act on the ioctl, but then lie and say we didn't
                 * so the line discipline will process the flush
                 * also.
                 */

                /*
                 * Also, now that we have TXPrint, we have to check
                 * if this is the TXPrint device and the terminal
                 * device is open. If so, do NOT run check_change,
                 * as the terminal device is ALWAYS the parent.
                 */
                if (!IS_PRINT(MINOR(tty_devnum(tty))) ||
                    !ch->ch_tun.un_open_count) {
                        rc = tty_check_change(tty);
                        if (rc)
                                return rc;
                }

                /* wait for all the characters in tbuf to drain */
                tty_wait_until_sent(tty, 0);

                if ((cmd == TCSETSF) || (cmd == TCSETAF)) {
                        /* flush the contents of the rbuf queue */
                        /* TODO:  check if this is print device? */
                        ch->ch_send |= RR_RX_FLUSH;
                        (ch->ch_nd)->nd_tx_ready = 1;
                        (ch->ch_nd)->nd_tx_work = 1;
                        wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
                        /* do we need to do this?  just to be safe! */
                        ch->ch_rout = ch->ch_rin;
                }

                /* pretend we didn't recognize this */
                return -ENOIOCTLCMD;

        case TCXONC:
                /*
                 * The Linux Line Discipline (LD) would do this for us if we
                 * let it, but we have the special firmware options to do this
                 * the "right way" regardless of hardware or software flow
                 * control so we'll do it outselves instead of letting the LD
                 * do it.
                 */
                rc = tty_check_change(tty);
                if (rc)
                        return rc;

                switch (arg) {
                case TCOON:
                        dgrp_tty_start(tty);
                        return 0;
                case TCOOFF:
                        dgrp_tty_stop(tty);
                        return 0;
                case TCION:
                        dgrp_tty_input_start(tty);
                        return 0;
                case TCIOFF:
                        dgrp_tty_input_stop(tty);
                        return 0;
                default:
                        return -EINVAL;
                }

        case DIGI_GETA:
                /* get information for ditty */
                if (copy_to_user((struct digi_struct __user *) arg,
                                 &ch->ch_digi, sizeof(struct digi_struct)))
                        return -EFAULT;
                break;

        case DIGI_SETAW:
        case DIGI_SETAF:
                /* wait for all the characters in tbuf to drain */
                tty_wait_until_sent(tty, 0);

                if (cmd == DIGI_SETAF) {
                        /* flush the contents of the rbuf queue */
                        /* send down a packet with RR_RX_FLUSH set */
                        ch->ch_send |= RR_RX_FLUSH;
                        (ch->ch_nd)->nd_tx_ready = 1;
                        (ch->ch_nd)->nd_tx_work = 1;
                        wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
                        /* do we need to do this?  just to be safe! */
                        ch->ch_rout = ch->ch_rin;
                }

                /* pretend we didn't recognize this */
                /* fall-through */

        case DIGI_SETA:
                return dgrp_tty_digiseta(tty, (struct digi_struct *) arg);

        case DIGI_SEDELAY:
                return dgrp_tty_digisetedelay(tty, (int *) arg);

        case DIGI_GEDELAY:
                return dgrp_tty_digigetedelay(tty, (int *) arg);

        case DIGI_GETFLOW:
        case DIGI_GETAFLOW:
                if (cmd == (DIGI_GETFLOW)) {
                        dflow.startc = tty->termios.c_cc[VSTART];
                        dflow.stopc = tty->termios.c_cc[VSTOP];
                } else {
                        dflow.startc = ch->ch_xxon;
                        dflow.stopc = ch->ch_xxoff;
                }

                if (copy_to_user((char __user *)arg, &dflow, sizeof(dflow)))
                        return -EFAULT;
                break;

        case DIGI_SETFLOW:
        case DIGI_SETAFLOW:

                if (copy_from_user(&dflow, (char __user *)arg, sizeof(dflow)))
                        return -EFAULT;

                if (cmd == (DIGI_SETFLOW)) {
                        tty->termios.c_cc[VSTART] = dflow.startc;
                        tty->termios.c_cc[VSTOP] = dflow.stopc;
                } else {
                        ch->ch_xxon = dflow.startc;
                        ch->ch_xxoff = dflow.stopc;
                }
                break;

        case DIGI_GETCUSTOMBAUD:
                if (put_user(ch->ch_custom_speed, (unsigned int __user *) arg))
                        return -EFAULT;
                break;

        case DIGI_SETCUSTOMBAUD:
        {
                int new_rate;

                if (get_user(new_rate, (unsigned int __user *) arg))
                        return -EFAULT;
                dgrp_set_custom_speed(ch, new_rate);

                break;
        }

        default:
                return -ENOIOCTLCMD;
        }

        return 0;
}

/*
 *  This routine allows the tty driver to be notified when
 *  the device's termios setting have changed.  Note that we
 *  should be prepared to accept the case where old == NULL
 *  and try to do something rational.
 *
 *  So we need to make sure that our copies of ch_oflag,
 *  ch_clag, and ch_iflag reflect the tty->termios flags.
 */
static void dgrp_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
{
        struct ktermios *ts;
        struct ch_struct *ch;
        struct un_struct *un;

        /* seems silly, but we have to check all these! */
        if (!tty)
                return;

        un = tty->driver_data;
        if (!un)
                return;

        ts = &tty->termios;

        ch = un->un_ch;
        if (!ch)
                return;

        drp_param(ch);

        /* the CLOCAL flag has just been set */
        if (!(old->c_cflag & CLOCAL) && C_CLOCAL(tty))
                wake_up_interruptible(&un->un_open_wait);
}


/*
 *      Throttle receiving data.  We just set a bit and stop reading
 *      data out of the channel buffer.  It will back up and the
 *      FEP will do whatever is necessary to stop the far end.
 */
static void dgrp_tty_throttle(struct tty_struct *tty)
{
        struct ch_struct *ch;

        if (!tty)
                return;

        ch = ((struct un_struct *) tty->driver_data)->un_ch;
        if (!ch)
                return;

        ch->ch_flag |= CH_RXSTOP;
}


static void dgrp_tty_unthrottle(struct tty_struct *tty)
{
        struct ch_struct *ch;

        if (!tty)
                return;

        ch = ((struct un_struct *) tty->driver_data)->un_ch;
        if (!ch)
                return;

        ch->ch_flag &= ~CH_RXSTOP;
}

/*
 *      Stop the transmitter
 */
static void dgrp_tty_stop(struct tty_struct *tty)
{
        struct ch_struct *ch;

        if (!tty)
                return;

        ch = ((struct un_struct *) tty->driver_data)->un_ch;
        if (!ch)
                return;

        ch->ch_send |= RR_TX_STOP;
        ch->ch_send &= ~RR_TX_START;

        /* make the change NOW! */
        (ch->ch_nd)->nd_tx_ready = 1;
        if (waitqueue_active(&(ch->ch_nd)->nd_tx_waitq))
                wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);
}

/*
 *      Start the transmitter
 */
static void dgrp_tty_start(struct tty_struct *tty)
{
        struct ch_struct *ch;

        if (!tty)
                return;

        ch = ((struct un_struct *) tty->driver_data)->un_ch;
        if (!ch)
                return;

        /* TODO: don't do anything if the transmitter is not stopped */

        ch->ch_send |= RR_TX_START;
        ch->ch_send &= ~RR_TX_STOP;

        /* make the change NOW! */
        (ch->ch_nd)->nd_tx_ready = 1;
        (ch->ch_nd)->nd_tx_work = 1;
        if (waitqueue_active(&(ch->ch_nd)->nd_tx_waitq))
                wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);

}

/*
 *      Stop the receiver
 */
static void dgrp_tty_input_stop(struct tty_struct *tty)
{
        struct ch_struct *ch;

        if (!tty)
                return;

        ch = ((struct un_struct *) tty->driver_data)->un_ch;
        if (!ch)
                return;

        ch->ch_send |= RR_RX_STOP;
        ch->ch_send &= ~RR_RX_START;
        (ch->ch_nd)->nd_tx_ready = 1;
        if (waitqueue_active(&(ch->ch_nd)->nd_tx_waitq))
                wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);

}


static void dgrp_tty_send_xchar(struct tty_struct *tty, char c)
{
        struct un_struct *un;
        struct ch_struct *ch;

        if (!tty)
                return;

        un = tty->driver_data;
        if (!un)
                return;

        ch = un->un_ch;
        if (!ch)
                return;
        if (c == STOP_CHAR(tty))
                ch->ch_send |= RR_RX_STOP;
        else if (c == START_CHAR(tty))
                ch->ch_send |= RR_RX_START;

        ch->ch_nd->nd_tx_ready = 1;
        ch->ch_nd->nd_tx_work = 1;

        return;
}


static void dgrp_tty_input_start(struct tty_struct *tty)
{
        struct ch_struct *ch;

        if (!tty)
                return;

        ch = ((struct un_struct *) tty->driver_data)->un_ch;
        if (!ch)
                return;

        ch->ch_send |= RR_RX_START;
        ch->ch_send &= ~RR_RX_STOP;
        (ch->ch_nd)->nd_tx_ready = 1;
        (ch->ch_nd)->nd_tx_work = 1;
        if (waitqueue_active(&(ch->ch_nd)->nd_tx_waitq))
                wake_up_interruptible(&(ch->ch_nd)->nd_tx_waitq);

}


/*
 *      Hangup the port.  Like a close, but don't wait for output
 *      to drain.
 *
 *      How do we close all the channels that are open?
 */
static void dgrp_tty_hangup(struct tty_struct *tty)
{
        struct ch_struct *ch;
        struct nd_struct *nd;
        struct un_struct *un;

        if (!tty)
                return;

        un = tty->driver_data;
        if (!un)
                return;

        ch = un->un_ch;
        if (!ch)
                return;

        nd = ch->ch_nd;

        if (C_HUPCL(tty)) {
                /* LOWER DTR */
                ch->ch_mout &= ~DM_DTR;
                /* Don't do this here */
                /* ch->ch_flag |= CH_HANGUP; */
                ch->ch_nd->nd_tx_ready = 1;
                ch->ch_nd->nd_tx_work  = 1;
                if (waitqueue_active(&ch->ch_flag_wait))
                        wake_up_interruptible(&ch->ch_flag_wait);
        }

}

/************************************************************************/
/*                                                                      */
/*       TTY Initialization/Cleanup Functions                           */
/*                                                                      */
/************************************************************************/

/*
 *      Uninitialize the TTY portion of the supplied node.  Free all
 *      memory and resources associated with this node.  Do it in reverse
 *      allocation order: this might possibly result in less fragmentation
 *      of memory, though I don't know this for sure.
 */
void
dgrp_tty_uninit(struct nd_struct *nd)
{
        unsigned int i;
        char id[3];

        ID_TO_CHAR(nd->nd_ID, id);

        if (nd->nd_ttdriver_flags & SERIAL_TTDRV_REG) {
                tty_unregister_driver(nd->nd_serial_ttdriver);

                kfree(nd->nd_serial_ttdriver->ttys);
                nd->nd_serial_ttdriver->ttys = NULL;

                put_tty_driver(nd->nd_serial_ttdriver);
                nd->nd_ttdriver_flags &= ~SERIAL_TTDRV_REG;
        }

        if (nd->nd_ttdriver_flags & CALLOUT_TTDRV_REG) {
                tty_unregister_driver(nd->nd_callout_ttdriver);

                kfree(nd->nd_callout_ttdriver->ttys);
                nd->nd_callout_ttdriver->ttys = NULL;

                put_tty_driver(nd->nd_callout_ttdriver);
                nd->nd_ttdriver_flags &= ~CALLOUT_TTDRV_REG;
        }

        if (nd->nd_ttdriver_flags & XPRINT_TTDRV_REG) {
                tty_unregister_driver(nd->nd_xprint_ttdriver);

                kfree(nd->nd_xprint_ttdriver->ttys);
                nd->nd_xprint_ttdriver->ttys = NULL;

                put_tty_driver(nd->nd_xprint_ttdriver);
                nd->nd_ttdriver_flags &= ~XPRINT_TTDRV_REG;
        }
        for (i = 0; i < CHAN_MAX; i++)
                tty_port_destroy(&nd->nd_chan[i].port);
}



/*
 *     Initialize the TTY portion of the supplied node.
 */
int
dgrp_tty_init(struct nd_struct *nd)
{
        char id[3];
        int  rc;
        int  i;

        ID_TO_CHAR(nd->nd_ID, id);

        /*
         *  Initialize the TTDRIVER structures.
         */

        nd->nd_serial_ttdriver = alloc_tty_driver(CHAN_MAX);
        if (!nd->nd_serial_ttdriver)
                return -ENOMEM;

        sprintf(nd->nd_serial_name,  "tty_dgrp_%s_", id);

        nd->nd_serial_ttdriver->owner = THIS_MODULE;
        nd->nd_serial_ttdriver->name = nd->nd_serial_name;
        nd->nd_serial_ttdriver->name_base = 0;
        nd->nd_serial_ttdriver->major = 0;
        nd->nd_serial_ttdriver->minor_start = 0;
        nd->nd_serial_ttdriver->type = TTY_DRIVER_TYPE_SERIAL;
        nd->nd_serial_ttdriver->subtype = SERIAL_TYPE_NORMAL;
        nd->nd_serial_ttdriver->init_termios = DefaultTermios;
        nd->nd_serial_ttdriver->driver_name = "dgrp";
        nd->nd_serial_ttdriver->flags = (TTY_DRIVER_REAL_RAW |
                                         TTY_DRIVER_DYNAMIC_DEV |
                                         TTY_DRIVER_HARDWARE_BREAK);

        /* The kernel wants space to store pointers to tty_structs. */
        nd->nd_serial_ttdriver->ttys =
                kzalloc(CHAN_MAX * sizeof(struct tty_struct *), GFP_KERNEL);
        if (!nd->nd_serial_ttdriver->ttys)
                return -ENOMEM;

        tty_set_operations(nd->nd_serial_ttdriver, &dgrp_tty_ops);

        if (!(nd->nd_ttdriver_flags & SERIAL_TTDRV_REG)) {
                /*
                 *   Register tty devices
                 */
                rc = tty_register_driver(nd->nd_serial_ttdriver);
                if (rc < 0) {
                        /*
                         * If errno is EBUSY, this means there are no more
                         * slots available to have us auto-majored.
                         * (Which is currently supported up to 256)
                         *
                         * We can still request majors above 256,
                         * we just have to do it manually.
                         */
                        if (rc == -EBUSY) {
                                int i;
                                int max_majors = 1U << (32 - MINORBITS);
                                for (i = 256; i < max_majors; i++) {
                                        nd->nd_serial_ttdriver->major = i;
                                        rc = tty_register_driver
                                                (nd->nd_serial_ttdriver);
                                        if (rc >= 0)
                                                break;
                                }
                                /* Really fail now, since we ran out
                                 * of majors to try. */
                                if (i == max_majors)
                                        return rc;

                        } else {
                                return rc;
                        }
                }
                nd->nd_ttdriver_flags |= SERIAL_TTDRV_REG;
        }

        nd->nd_callout_ttdriver = alloc_tty_driver(CHAN_MAX);
        if (!nd->nd_callout_ttdriver)
                return -ENOMEM;

        sprintf(nd->nd_callout_name, "cu_dgrp_%s_",  id);

        nd->nd_callout_ttdriver->owner = THIS_MODULE;
        nd->nd_callout_ttdriver->name = nd->nd_callout_name;
        nd->nd_callout_ttdriver->name_base = 0;
        nd->nd_callout_ttdriver->major = nd->nd_serial_ttdriver->major;
        nd->nd_callout_ttdriver->minor_start = 0x40;
        nd->nd_callout_ttdriver->type = TTY_DRIVER_TYPE_SERIAL;
        nd->nd_callout_ttdriver->subtype = SERIAL_TYPE_CALLOUT;
        nd->nd_callout_ttdriver->init_termios = DefaultTermios;
        nd->nd_callout_ttdriver->driver_name = "dgrp";
        nd->nd_callout_ttdriver->flags = (TTY_DRIVER_REAL_RAW |
                                          TTY_DRIVER_DYNAMIC_DEV |
                                          TTY_DRIVER_HARDWARE_BREAK);

        /* The kernel wants space to store pointers to tty_structs. */
        nd->nd_callout_ttdriver->ttys =
                kzalloc(CHAN_MAX * sizeof(struct tty_struct *), GFP_KERNEL);
        if (!nd->nd_callout_ttdriver->ttys)
                return -ENOMEM;

        tty_set_operations(nd->nd_callout_ttdriver, &dgrp_tty_ops);

        if (dgrp_register_cudevices) {
                if (!(nd->nd_ttdriver_flags & CALLOUT_TTDRV_REG)) {
                        /*
                         *   Register cu devices
                         */
                        rc = tty_register_driver(nd->nd_callout_ttdriver);
                        if (rc < 0)
                                return rc;
                        nd->nd_ttdriver_flags |= CALLOUT_TTDRV_REG;
                }
        }


        nd->nd_xprint_ttdriver = alloc_tty_driver(CHAN_MAX);
        if (!nd->nd_xprint_ttdriver)
                return -ENOMEM;

        sprintf(nd->nd_xprint_name,  "pr_dgrp_%s_", id);

        nd->nd_xprint_ttdriver->owner = THIS_MODULE;
        nd->nd_xprint_ttdriver->name = nd->nd_xprint_name;
        nd->nd_xprint_ttdriver->name_base = 0;
        nd->nd_xprint_ttdriver->major = nd->nd_serial_ttdriver->major;
        nd->nd_xprint_ttdriver->minor_start = 0x80;
        nd->nd_xprint_ttdriver->type = TTY_DRIVER_TYPE_SERIAL;
        nd->nd_xprint_ttdriver->subtype = SERIAL_TYPE_XPRINT;
        nd->nd_xprint_ttdriver->init_termios = DefaultTermios;
        nd->nd_xprint_ttdriver->driver_name = "dgrp";
        nd->nd_xprint_ttdriver->flags = (TTY_DRIVER_REAL_RAW |
                                         TTY_DRIVER_DYNAMIC_DEV |
                                         TTY_DRIVER_HARDWARE_BREAK);

        /* The kernel wants space to store pointers to tty_structs. */
        nd->nd_xprint_ttdriver->ttys =
                kzalloc(CHAN_MAX * sizeof(struct tty_struct *), GFP_KERNEL);
        if (!nd->nd_xprint_ttdriver->ttys)
                return -ENOMEM;

        tty_set_operations(nd->nd_xprint_ttdriver, &dgrp_tty_ops);

        if (dgrp_register_prdevices) {
                if (!(nd->nd_ttdriver_flags & XPRINT_TTDRV_REG)) {
                        /*
                         *   Register transparent print devices
                         */
                        rc = tty_register_driver(nd->nd_xprint_ttdriver);
                        if (rc < 0)
                                return rc;
                        nd->nd_ttdriver_flags |= XPRINT_TTDRV_REG;
                }
        }

        for (i = 0; i < CHAN_MAX; i++) {
                struct ch_struct *ch = nd->nd_chan + i;

                ch->ch_nd = nd;
                ch->ch_digi = digi_init;
                ch->ch_edelay = 100;
                ch->ch_custom_speed = 0;
                ch->ch_portnum = i;
                ch->ch_tun.un_ch = ch;
                ch->ch_pun.un_ch = ch;
                ch->ch_tun.un_type = SERIAL_TYPE_NORMAL;
                ch->ch_pun.un_type = SERIAL_TYPE_XPRINT;

                init_waitqueue_head(&(ch->ch_flag_wait));
                init_waitqueue_head(&(ch->ch_sleep));

                init_waitqueue_head(&(ch->ch_tun.un_open_wait));
                init_waitqueue_head(&(ch->ch_tun.un_close_wait));

                init_waitqueue_head(&(ch->ch_pun.un_open_wait));
                init_waitqueue_head(&(ch->ch_pun.un_close_wait));
                tty_port_init(&ch->port);
        }
        return 0;
}