xref: /csrg-svn/sys/vax/if/ACC/driver/if_x29.c (revision 49758)

/*
 *
 *     X.29 option for dda driver for UNIX and Ultrix
 *      ________________________________________________________
 *     /                                                        \
 *    |          AAA          CCCCCCCCCCCCCC    CCCCCCCCCCCCCC   |
 *    |         AAAAA        CCCCCCCCCCCCCCCC  CCCCCCCCCCCCCCCC  |
 *    |        AAAAAAA       CCCCCCCCCCCCCCCCC CCCCCCCCCCCCCCCCC |
 *    |       AAAA AAAA      CCCC              CCCC              |
 *    |      AAAA   AAAA     CCCC              CCCC              |
 *    |     AAAA     AAAA    CCCC              CCCC              |
 *    |    AAAA       AAAA   CCCC              CCCC              |
 *    |   AAAA  AAAAAAAAAAA  CCCCCCCCCCCCCCCCC CCCCCCCCCCCCCCCCC |
 *    |  AAAA    AAAAAAAAAAA CCCCCCCCCCCCCCCC  CCCCCCCCCCCCCCCC  |
 *    | AAAA      AAAAAAAAA   CCCCCCCCCCCCCC    CCCCCCCCCCCCCC   |
 *     \________________________________________________________/
 *
 *      Copyright (c) 1987 by Advanced Computer Communications
 *      720 Santa Barbara Street, Santa Barbara, California  93101
 *      (805) 963-9431
 *
 * File:
 *      if_x29.c
 *
 * Author:
 *
 * Project:
 *      Development of PAD on 6250 software.
 *
 * Function:
 *      To enable network connections on ACP_XX to communicate with UNIX.
 *
 * Components:
 *      - files if_x29.c
 *
 * Configuration Entry:
 *
 *      device dda0 at uba? csr 0166740 vector ddainta ddaintb
 *
 * Usage Notes:
 *
 *      - make devices in /dev and edit /etc/ttys for those x29
 *        devices which you want in your configuration
 *
 * System Notes:
 *
 *       Refer to the installation instructions, readme.txt, which
 *       are included on the driver distribution medium.
 *
 * Revision History at end of file
 */

/*
 *	For efficiency, it is a good idea to modify XXBOARDS when using
 *	less than 4 boards with the X29 option.  If using more than 32
 *	lines per board, you should modify XXBOARDS, XXLPERBRD, LOG2_XXBOARDS
 *	and LOG2_XXLPERBRD.
 *
 *	Minor numbers are laid out as follows (by default):
 *		(MSB) PBBLLLLL (LSB)
 *	Where P is a flag to determine if the line is outbound (pad) or
 *	inbound (tty).  BB is the board number (0-3), and LLLLL is the
 *	X29 line on a board (0-31).  Some customers may need more than
 *	32 lines/board.  If there are less than 2 boards,  one may shift
 *	the break-point between lines and boards:
 *
 *	up to 4 boards, 32 lines/board	(default)
 *		(MSB) PBBLLLLL (LSB)
 *			XXBOARDS  = 4,   LOG2_XXBOARDS  = 2
 *			XXLPERBRD = 32,	 LOG2_XXLPERBRD = 5
 *	up to 2 boards, 64 lines/board:
 *		(MSB) PBLLLLLL (LSB)
 *			XXBOARDS  = 2,   LOG2_XXBOARDS  = 1
 *			XXLPERBRD = 64,  LOG2_XXLPERBRD = 6
 *	only 1 board, 128 (actually, 126, as 126 = max svc):
 *		(MSB) PLLLLLLL (LSB)
 *			XXBOARDS  = 1,   LOG2_XXBOARDS  = 0
 *			XXLPERBRD = 128, LOG2_XXLPERBRD = 7
 *
 *	(obviously, these are all powers of two)
 */

#define	XXBOARDS	4	/* # boards running x29 */
#define	LOG2_XXBOARDS	2	/* # bits of board info */

#define XXLPERBRD	32	/* # lines per board */
#define	LOG2_XXLPERBRD	5	/* # bits of line info */

/*
 * If you require an 8-bit data path and have no parity misconfigurations,
 * you may change PARITY_MASKs to 0377.  This will leave parity stripping
 * to the ttdriver.  However,  the ttdriver won't strip parity when in
 * raw mode (e.g. at the Password: prompt),  so one symptom of a parity
 * misconfiguration is that users can't login (CR gets received as 0x8D).
 */

#define	INPUT_PARITY_MASK  0177	/* strip off the 8th bit */
#define	OUTPUT_PARITY_MASK 0377	/* don't strip off the 8th bit */

/*
 * macro to translate a device number to the unit (i.e. ACP_n250)
 * with which it is associated and the port on said unit
 */

#define UNIT(x) ((minor(x) >> LOG2_XXLPERBRD) & LOG2_XXBOARDS)

#define LINE(x)	  (minor(x) & 0177)	/* index into line table */
#define XXSHOW(x) (minor(x) == 255)	/* special "show" device */
#define IS_PAD(x) (minor(x) & 0200)	/* msb is the pad/tty selector */
#define MAJLINE(x) ((x) & ~0x80)	/* major plus corrected minor # */

#define NXXLINES        (XXBOARDS * XXLPERBRD)	/* number of total x29 lines */

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%                                                             %%*/
/*%%                   LOCAL  FUNCTIONS                          %%*/
/*%%                                                             %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

PRIVATE void    xxcntl();
PRIVATE void    xxclear();
PRIVATE void    xxshow();
PRIVATE void    xxpadhandle();
PRIVATE int     xxpadparse();
PRIVATE int     xxpadcall();
PRIVATE void    xxpadmsg();
PRIVATE void	xx_qbit_msg();
PRIVATE void    xx_tp_hangup();
PRIVATE void    x29_init();
PRIVATE void    x29_dhandle();
PRIVATE int	x29_break_reply_is_required();

#if ACC_ULTRIX >= 30
static  int	ttbreakc();		/* always keep this private */
#endif

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%                                                             %%*/
/*%%                   LOCAL  VARIABLES                          %%*/
/*%%                                                             %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

#define SET_PAD		2
#define READ_PAD	4
#define SET_READ_PAD	6
#define PAR_INDICATION	0
#define INVITE_CLEAR	1
#define BREAK_INDIC	3
#define PAD_ERROR	5

/* command codes */
#define XX_C_BREAK	001
#define XX_C_PAD	002
#define XX_C_CLOSE	003
#define XX_C_HOST	004

struct tty      xx_tty[NXXLINES];	/* tty structures */

#define MODE_UNUSED 0			/* !just for sanity checks only! */
#define	MODE_HOST 1			/* port in host mode (incoming) */
#define	MODE_PAD  2			/* port in pad mode (outgoing) */

char            xxmode[NXXLINES];	/* mode of port */

int             xxstart();

typedef struct {
    char            ref;
    char            val;
} x29_pad_pair;

PRIVATE x29_pad_pair x29_break_ack_params[] =
{
 8, 0				/* ref 8 -- normal output to terminal */
};

PRIVATE x29_pad_pair x29_callout_params[] =
{
 1, 0				/* ref 1 -- no recall char */
};

PRIVATE x29_pad_pair x29_callin_setparams[] =
{ /* these are the preferred paramters when calling in to Unix */
 2, 0,				/* ref 2 -- no echo */
 3, 127,			/* ref 3 -- forward data on any char */
 8, 0,				/* ref 8 -- normal data delivery to terminal */
 9, 0,				/* ref 9 -- no padding after carriage return */
 10, 0,				/* ref 10 -- no line folding */
 13, 0,				/* ref 13 -- no line feed after CR */
 15, 0				/* ref 15 -- no local edit */
};

/******************************************************************************
 *  PAD CONTROL INFORMATION AND DEFINITIONS
 ******************************************************************************/

/* definitions for the pad state field p_state */
#define PS_IDLE	0		/* not opened state */
#define PS_COM  1		/* the pad for this line is in command state */
#define PS_PAD  2		/* this line has data passing though the pad */
#define PS_WAIT	3		/* waiting state */
#define PS_XFR	4		/* data transfer state */

#define P_LINELEN	20
#define P_NOBLOCK	0

typedef struct padinfo {
    short           p_state;	/* pad state */
    char            p_line[P_LINELEN];	/* built up line */
    char            p_idx;	/* index into p_line */
    int		    p_flow;	/* index into mbuf when flow off,
				   P_NOBLOCK if not flowed off */
    struct mbuf    *p_msav;	/* place to hang mbuf when flow controlled */
    struct mbuf    *p_mchsav;	/* place to save mbuf chain '' '' '' */
} padinfo;
padinfo         xx_padinfo[NXXLINES];


/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%                                                             %%*/
/*%%                   GLOBAL ROUTINES                           %%*/
/*%%                                                             %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%                       XXOPEN()                              %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*                                                                 */
/*  Purpose:                                                       */
/*                                                                 */
/*  Open a line.                                                   */
/*                                                                 */
/*  Call:           xxopen(dev, flag)                              */
/*  Argument:       dev:   device                                  */
/*                  flag:  indicates type of open, "nonblocking"   */
/*                         "or block if in use"                    */
/*  Returns:        0 for success, else nonzero error code         */
/*  Called by:      kernel software software,  this routine is in  */
/*                  the cdevsw table                               */
/*                                                                 */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

/*ARGSUSED*/
xxopen(dev, flag)
dev_t           dev;
int             flag;
{
    register struct tty *tp;
    register        d;
    register        s;
    int             unit,
                    i;
#if ACC_ULTRIX > 00
    int             inuse;	/* store inuse bit while sleeping */
#endif

    unit = UNIT(dev);
    d = LINE(dev);

    if (XXSHOW(dev)) {		/* minor device 255 */
	xxshow();
	return (EPIPE);
    }

    /* PST NOTE TO SELF: change the test as follows:
     *	make this d >= NXXLINES, then check to see if unit is present,
     *  Keep that sleep() in the thingy below, so we don't get bouncing
     *  gettys eating up cpu time.
     */
    if ((d >= NXXLINES))
	return (ENXIO);

    /* wait for interface to come up */
    while (dda_softc[unit].dda_state != S_LINK_UP)
	sleep(&dda_softc[unit].dda_state, TTIPRI);

    tp = &xx_tty[d];
    if ((tp->t_state & TS_XCLUDE) && u.u_uid != 0)
	return EBUSY;

    /* make sure the port isn't already open in a conflicting manner */
    /* i.e. can't open /dev/padJ0 and /dev/ttyJ0 at the same time */
    if (tp->t_state & (TS_WOPEN | TS_ISOPEN)) {
	if ((IS_PAD(dev) && (xxmode[d] == MODE_HOST)) ||
	    ((!IS_PAD(dev)) && (xxmode[d] == MODE_PAD)))
	    return EBUSY;
    }

#ifdef	DDADEBUG
	if (DDADBCH(96, unit)) {
		DDALOG(LOG_DEBUG)
		    "dda%d:(x29) open line %d flag %o in %s mode\n",
		    unit, d, flag, (IS_PAD(dev) ? "pad" : "host")
		DDAELOG;
	}
#endif  DDADEBUG

    tp->t_oproc = xxstart;
    tp->t_state |= TS_WOPEN;

    /* if first open initialize state */
    if ((tp->t_state & TS_ISOPEN) == 0) {
	ttychars(tp);

#if ACC_ULTRIX >= 30		/* posix compliant tty driver */
	if (tp->t_cflag & CBAUD == 0) {
	    tp->t_iflag = IGNPAR | ICRNL | IXON | IXANY | IXOFF;
	    tp->t_oflag = OPOST | ONLCR;
	    tp->t_cflag = B9600 | CS8 | CREAD | HUPCL;
	    tp->t_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHONL;
	    tp->t_line = 0;
	}
#else				/* v7 tty driver */
	if (tp->t_ispeed == 0) {
	    tp->t_ispeed = B9600;
	    tp->t_ospeed = B9600;
	    tp->t_flags = CRMOD | ANYP;
	}
#endif
	xxparam(dev);
    }
    if (IS_PAD(dev)) {
	tp->t_state |= TS_CARR_ON;
	xxmode[d] = MODE_PAD;
	xxcntl(tp, XX_C_PAD, unit);
    } else {
	if ((tp->t_state & TS_CARR_ON) == 0) {
	    xxmode[d] = MODE_HOST;
	    xxcntl(tp, XX_C_HOST, unit);
	    tp->t_flags |= ECHO;
#if ACC_ULTRIX < 31	/* on everything other than Ultrix 3.1 */
	    /* on close tell ACP_XX to drop line */
	    tp->t_state |= TS_HUPCLS;
#endif
	}
    }
    /* if xxcntl did not get called (state had carrier off) or xxcntl's
     * search for a free lcn failed, then t_addr will be 0, so punt */
    if (tp->t_addr == 0) {
	tp->t_pgrp = 0;
	tp->t_state = 0;
	xxmode[d] = MODE_UNUSED;
	return (EBUSY);
    }
    xx_padinfo[d].p_flow = P_NOBLOCK;
    s = splimp();

#if ACC_ULTRIX > 00
    if (flag & O_NDELAY) {
	if (!IS_PAD(dev))
	    tp->t_state |= TS_ONDELAY;
    } else
#endif
	while ((tp->t_state & TS_CARR_ON) == 0) {
	    tp->t_state |= TS_WOPEN;
#if ACC_ULTRIX > 00
	    inuse = tp->t_state & TS_INUSE;
#endif
	    sleep(&tp->t_rawq, TTIPRI);

	    /* wakeup came from xxclear */
	    if ((tp->t_state & TS_WOPEN) == 0) {
		splx(s);
		return (EPIPE);
	    }
#if ACC_ULTRIX > 00
	    /* if port became "inuse" while we slept, return */
	    if ((flag & O_BLKINUSE) && (!inuse) &&
		(tp->t_state & TS_INUSE)) {
		splx(s);
		return (EALREADY);
	    }
#endif
	}

    splx(s);
    i = ((*linesw[tp->t_line].l_open) (dev, tp));
    if (tp->t_pgrp == 0)
	tp->t_pgrp = u.u_procp->p_pid;
    return (i);
}

/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%                       XXCLOSE()                             %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*                                                                 */
/*  Purpose:                                                       */
/*                                                                 */
/*  Close a line.                                                  */
/*                                                                 */
/*  Call:           xxclose(dev, flag)                             */
/*  Argument:       dev:   device                                  */
/*                  flag:  unused                                  */
/*  Returns:        nothing                                        */
/*  Called by:      kernel software,  this routine is in the	   */
/*		    cdevsw table                                   */
/*                                                                 */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

/*ARGSUSED*/
xxclose(dev, flag, mode, p)
dev_t           dev;
int             flag, mode;
struct proc	*p;
{
    register struct tty *tp;
    register        d;
    d = LINE(dev);
    tp = &xx_tty[d];

#ifdef	DDADEBUG
	if (DDADBCH(97, UNIT(dev))) {
		DDALOG(LOG_DEBUG) "dda%d:(x29) closing line %d\n", UNIT(dev), d
		DDAELOG;
	}
#endif  DDADEBUG

	/* PST NOTE TO SELF:
	 *	Add the 629 driver code for timing out the close below,
	 *	because the line could be flowed off and it would hang
	 * 	forever */

    (*linesw[tp->t_line].l_close) (tp, flag);

#if ACC_ULTRIX >= 31
    if ((tp->t_cflag & HUPCL) || ((tp->t_state & TS_ISOPEN) == 0)) {
#else
    if ((tp->t_state & TS_HUPCLS) || ((tp->t_state & TS_ISOPEN) == 0)) {
#endif

#ifdef	DDADEBUG
	if (DDADBCH(97, UNIT(dev))) {
		DDALOG(LOG_DEBUG) "dda%d:(x29) close: tp->t_state = %x\n",
				  UNIT(dev), tp->t_state
		DDAELOG;
	}
#endif  DDADEBUG

	if (tp->t_state & TS_CARR_ON)
	    xxcntl(tp, XX_C_CLOSE, UNIT(dev));
	tp->t_state &= ~TS_CARR_ON;
	xxmode[d] = MODE_UNUSED;
    }
    ttyclose(tp);
}

/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%                       XXREAD()                              %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*                                                                 */
/*  Purpose:                                                       */
/*                                                                 */
/*  Read from a line.                                              */
/*                                                                 */
/*  Call:           xxread(dev, uio)                               */
/*  Argument:       dev:   device                                  */
/*                  uio:   pointer to uio structure                */
/*  Returns:        0 for success, else nonzero error code         */
/*  Called by:      kernel software,  this routine is in	   */
/*                  the cdevsw table                               */
/*                                                                 */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

xxread(dev, uio)
dev_t           dev;
struct uio     *uio;
{
    register struct tty *tp;
    register int    l,
                    error;

    if (dda_softc[UNIT(dev)].dda_state != S_LINK_UP)
	return (ENXIO);

    l = LINE(dev);
    tp = &xx_tty[l];
    error = (*linesw[tp->t_line].l_read)(tp, uio);

    if (xx_padinfo[l].p_flow != P_NOBLOCK) {	/* currently blocked? */
	if (tp->t_flags & (RAW | CBREAK)) {	/* using raw q? */
	    if (tp->t_rawq.c_cc < TTYHOG / 8) {	/* if rawq is low, then
						 * it's time to unblock */
		x29_dhandle(&dda_softc[UNIT(dev)],
			    (struct dda_cb *) (tp->t_addr), 1);
	    }
	/* else cooked mode, different test */
	/* canonical q empty? then it's time to unblock */
	} else if (tp->t_canq.c_cc == 0) {
	    x29_dhandle(&dda_softc[UNIT(dev)],
			(struct dda_cb *) (tp->t_addr), 1);
	}
    }
    return (error);
}

/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%                       XXWRITE()                             %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*                                                                 */
/*  Purpose:                                                       */
/*                                                                 */
/*  Write on a line.                                               */
/*                                                                 */
/*  Call:           xxwrite(dev, uio)                              */
/*  Argument:       dev:   device                                  */
/*                  uio:   pointer to uio structure                */
/*  Returns:        0 for success, else nonzero error code         */
/*  Called by:      kernel software software,  this routine is in  */
/*                  the cdevsw table                               */
/*                                                                 */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

xxwrite(dev, uio)
dev_t           dev;
struct uio     *uio;
{
    register struct tty *tp;
    if (dda_softc[UNIT(dev)].dda_state != S_LINK_UP)
	return (ENXIO);
    tp = &xx_tty[LINE(dev)];
    return (*linesw[tp->t_line].l_write)(tp, uio);
}

/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%                       XXIOCTL()                             %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*                                                                 */
/*  Purpose:                                                       */
/*                                                                 */
/*  Process ioctl request.                                         */
/*                                                                 */
/*  Call:           xxioctl(dev, cmd, data, flag)                  */
/*  Argument:       dev:   device                                  */
/*                  cmd:   ioctl command                           */
/*                  data:  pointer to data                         */
/*                  flag:  ignored                                 */
/*  Returns:        0 for sucess, else nonzero error code          */
/*  Called by:      kernel software software,  this routine is in  */
/*                  the cdevsw table                               */
/*                                                                 */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

#define TIOACCQBIT (int)(0x80800000|('t'<<8)|125)

xxioctl(dev, cmd, data, flag)
dev_t           dev;
caddr_t         data;
{
    register struct tty *tp;
    int             error;
    tp = &xx_tty[LINE(dev)];
    if (cmd == TIOACCQBIT) {
#ifdef	DDADEBUG
	if (DDADBCH(98, UNIT(dev))) {
		DDALOG(LOG_DEBUG) "dda%d:(x29) ioctl qbit msg: cmd=%x ACC=%x\n",
				  UNIT(dev), cmd, TIOACCQBIT
		DDAELOG;
	}
#endif  DDADEBUG
	xx_qbit_msg(tp, UNIT(dev), data);
	return (0);
    }
    error = (*linesw[tp->t_line].l_ioctl) (tp, cmd, data, flag);
    if (error >= 0)
	return (error);
    error = ttioctl(tp, cmd, data, flag);
    if (error >= 0) {
	if (cmd == TIOCSETP || cmd == TIOCSETN)
	    xxparam(dev);
	return (error);
    }
    switch (cmd) {
    case TIOCREMOTE:
	if (xxmode[LINE(dev)] == 0)
	    return (EBUSY);
	xxcntl(tp, XX_C_PAD, UNIT(dev));
	break;
    case TIOCSBRK:
	xxcntl(tp, XX_C_BREAK, UNIT(dev));
	break;
    case TIOCCBRK:
    case TIOCSDTR:
    case TIOCCDTR:
	break;
    default:
	return (ENOTTY);
    }
    return (0);
}

/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%                        XXPARAM()                            %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*                                                                 */
/*  Purpose:                                                       */
/*                                                                 */
/*  Set parameters from open or stty.                              */
/*  This routine is being left in as a dummy in case in the future */
/*  there is a mechanism for the host to send information i.e.     */
/*  "hangup line" to the ACP _XX                                   */
/*                                                                 */
/*  Call:           xxparam(dev)                                   */
/*  Argument:       dev:   device                                  */
/*  Returns:        none                                           */
/*  Called by:      none                                           */
/*                                                                 */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*ARGSUSED*/
xxparam(dev)
dev_t           dev;
{
}

/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%                        XXSTART()                            %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*                                                                 */
/*  Purpose:                                                       */
/*                                                                 */
/*  Start (restart) transmission on a given line.  This is the     */
/*  start routine which is called from above by the tty driver and */
/*  from below on a transmission complete interrupt for a given    */
/*  line.                                                          */
/*                                                                 */
/*  Call:           xxstart(tp)                                    */
/*  Argument:       tp:   pointer to tty structure                 */
/*  Returns:        none                                           */
/*  Called by:      tty driver                                     */
/*                  xxreset()                                      */
/*                                                                 */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

xxstart(tp)
register struct tty *tp;
{
    register struct dda_softc *ds;
    register int    nch,
                    cc,
		    k;
    register struct dda_cb *dc;
    register char  *cp,
                   *p;
    struct ifqueue *oq;
    struct mbuf    *m;
    padinfo	   *pp;
    int             unit,
                    line,
                    s,
		    j;
    extern int      ttrstrt();

    line = tp - xx_tty;
    unit = UNIT(line);
    dc = (struct dda_cb *) tp->t_addr;
    ds = &dda_softc[unit];
    pp = &xx_padinfo[line];

    s = splimp();

#ifdef	DDADEBUG
    if (DDADBCH(99, unit)) {
	DDALOG(LOG_DEBUG) "dda%d:(x29) xxstart: line %d t_state = %x\n",
			  unit, line, tp->t_state
	DDAELOG;
    }
#endif  DDADEBUG

    /* If it's currently active, or delaying, no need to do anything. */
    if ((tp->t_state & TS_CARR_ON) == 0) {
	tp->t_state &= ~(TS_TTSTOP | TS_BUSY);
	ttyflush(tp, FREAD | FWRITE);
	tp->t_state &= ~TS_ASLEEP;
	wakeup((caddr_t) &tp->t_outq);
	goto out;
    }
    if (tp->t_state & (TS_TIMEOUT | TS_BUSY | TS_TTSTOP))
	goto out;

    /* wait for free */
    if (dda_softc[unit].dda_state != S_LINK_UP) {
	ttyflush(tp, FREAD | FWRITE);
        DMESG(unit, 96, (DDALOG(LOG_ERR)
			"dda%d:(x29) xxstart: unit offline\n", unit DDAELOG) );
	goto out;
    }
    /* If the writer was sleeping on output overflow, wake him when low tide
     * is reached. */
    if (tp->t_outq.c_cc <= TTLOWAT(tp)) {
	if (tp->t_state & TS_ASLEEP) {
	    tp->t_state &= ~TS_ASLEEP;
	    wakeup((caddr_t) &tp->t_outq);
	}
	if (tp->t_wsel) {
	    selwakeup(tp->t_wsel, tp->t_state & TS_WCOLL);
	    tp->t_wsel = 0;
	    tp->t_state &= ~TS_WCOLL;
	}
    }
    /* restart transmission unless output queue is empty */
    if (tp->t_outq.c_cc == 0)
	goto out;

    /* if this is an outbound pad line and it's in command mode */
    if (pp->p_state == PS_COM) {
	xxpadhandle(ds, tp, pp);
	goto out;
    }

    /* Allocate an mbuf to stuff the chars into */
    m = 0;
    MGET(m, M_DONTWAIT, MT_DATA);
    if (m == 0) {
        DMESG(unit, 97, (DDALOG(LOG_ERR)
			"dda%d:(x29) xxstart: could not get mbuf\n",
			unit DDAELOG) );
	goto out;
    }
    cp = mtod(m, char *);
    cc = 0;

    /* copy at most MLEN-1 chars out -- must save one byte for subfunc */
    while ((cc < MLEN - 1) && (tp->t_outq.c_cc > 0)) {
	if (tp->t_flags & (RAW | LITOUT))
	    nch = ndqb(&tp->t_outq, 0);
	else {
	    nch = ndqb(&tp->t_outq, 0200);
	    if (nch == 0) {	/* if first item was a delay */
		(void) getc(&tp->t_outq);	/* discard the character */
		continue;
	    }
	}
	if (nch > (MLEN - 1) - cc)
	    nch = (MLEN - 1) - cc;

	/* If any characters were set up, start transmission; */
	if (nch) {
	    j = q_to_b(&tp->t_outq, cp, nch);

#if OUTPUT_PARITY_MASK != 0377
	    /* strip all characters as desired */
	    for (p = cp, k = j; k; k--, p++)
		*p &= OUTPUT_PARITY_MASK;
#endif

#ifdef	DDADEBUG
	    if (DDADBCH(100, unit) && j != nch) {
		DDALOG(LOG_DEBUG)
		    "dda%d:(x29) xxstart: asked for %d got %d chars\n",
		    unit, nch, j
		DDAELOG;
	    }
#endif  DDADEBUG

	    cc += nch;
	    cp += nch;
	} else
	    break;
    }

#ifdef	DDADEBUG
    if (DDADBCH(101, unit)) {
	DDALOG(LOG_DEBUG) "dda%d:(x29) xxstart: mbuf %x len %d\n",
			  unit, m, m->m_len
	DDAELOG;
    }
#endif

    /* if any data was stuffed into the mbuf then send it */
    if (cc) {
	m->m_dat[MLEN - 1] = 0;	/* subfunction: no Q-bit */
	m->m_len = cc;
	oq = &(dc->dc_oq);	/* point to output queue */
	if (IF_QFULL(oq)) {	/* if q full */
	    IF_DROP(oq);	/* drop the data */
	    m_freem(m);
	    ds->dda_if.if_collisions++;	/* for netstat display */
	    splx(s);
	    return (ENOBUFS);
	}
	IF_ENQUEUE(oq, m);	/* otherwise queue it */
	tp->t_state |= TS_BUSY;
	dda_start(ds, dc);	/* and try to output */
    } else
	m_freem(m);

out:
    if (dc->dc_lcn != 0)	/* something left in oq? */
	dda_start(ds, dc);	/* restart output */
    splx(s);
    return (0);
}

/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%                        XXRESET()                            %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*                                                                 */
/*  Purpose:                                                       */
/*                                                                 */
/*  In response to UNIBUS reset, reset state and restart           */
/*  transmitters.                                                  */
/*                                                                 */
/*  Call:           xxreset(uban)                                  */
/*  Argument:       uban:  UNIBUS adaptor number                   */
/*  Returns:        none                                           */
/*  Called by:      kernel software in response to UNIBUS reset    */
/*                                                                 */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*ARGSUSED*/
xxreset(uban)
int uban;
{
}

/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%                        XXSTOP()                             %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*                                                                 */
/*  Purpose:                                                       */
/*                                                                 */
/*  Dummy stop routine.                                            */
/*                                                                 */
/*  Call:           xxstop(tp, flag)                               */
/*  Argument:       tp:    pointer to tty structure                */
/*                  flag:  indicates                               */
/*  Returns:        none                                           */
/*  Called by:      none                                           */
/*                                                                 */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*ARGSUSED*/
xxstop(tp, flag)
struct tty     *tp;
int             flag;
{
}

/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%                        XXSELECT()                           %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*                                                                 */
/*  Purpose:                                                       */
/*                                                                 */
/*  Circumvent bug in our bastardized design which causes ttselect */
/*  to fail.							   */
/*                                                                 */
/*  Call:           xxselect(dev, rw)                              */
/*  Argument:       dev:   device                                  */
/*                  rw:    read or write indicator                 */
/*  Returns:        0 or 1                                         */
/*  Called by:      none                                           */
/*                                                                 */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

xxselect(dev, rw)
dev_t           dev;
int             rw;
{
#ifdef	DDADEBUG
    int unit = UNIT(dev);
    if (DDADBCH(102, unit))
	DDALOG(LOG_DEBUG) "dda%d:(x29) select()\n", unit DDAELOG;
#endif  DDADEBUG

    return (ttselect(MAJLINE(dev), rw));
}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%                                                             %%*/
/*%%                   LOCAL  FUNCTIONS                          %%*/
/*%%                                                             %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%                      X29_SUPR()                             %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*                                                                 */
/*  Purpose:                                                       */
/*                                                                 */
/*       This routine processes received supervisor messages.      */
/*       Depending on the message type, the appropriate action is  */
/*       taken.                                                    */
/*                                                                 */
/*  Call:              x29_supr(ds, p)                             */
/*  Arguments:         ds:  pointer to dev control block struct    */
/*                     p:   pointer to a character array           */
/*                              containing the supervisor message  */
/*  Returns:           nothing                                     */
/*  Called by:         dda_supr()                                  */
/*                                                                 */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

PRIVATE void
x29_supr(ds, p)
struct dda_softc *ds;
u_char          p[];
{
    register struct dda_cb *dc;
    register struct tty *tp;
    register int    lcn;
    int   	    maxlcn;
    int		    line;

#ifdef DDADEBUG
    if (DDADBCH(103, ds->dda_if.if_unit)) {
	DDALOG(LOG_DEBUG) "dda%d:(x29) x29_supr()\n", ds->dda_if.if_unit
	DDAELOG;
    }
#endif  DDADEBUG

    switch (p[0]) {
    case LINE_STATUS:		/* link status msg */
    case RESTART:		/* restart received */
    case RSTRT_ACK:		/* restart ack */
    case STATRESP:		/* Statistics Response from FEP */
	DMESG(ds->dda_if.if_unit, 98, (DDALOG(LOG_ERR)
		"dda%d:(x29) x29_supr: unexpected message type\n",
		ds->dda_if.if_unit DDAELOG));
	break;
    case ANSWER:		/* call answered */
	lcn = p[1] / 2;
	dc = &(ds->dda_cb[lcn]);
	if (dc->dc_state == LC_CALL_PENDING) {	/* if a call pending */
	    decode_answer(p, dc);
	    dc->dc_state = LC_DATA_IDLE;	/* set state */
	    dc->dc_flags = DC_X29;
	    line = dc->dc_line;			/* which line are we? */
#ifdef DDADEBUG
	    if (DDADBCH(114, ds->dda_if.if_unit)) {
		DDALOG(LOG_DEBUG) "dda%d:(x29) x29_supr: answer: line=%d\n",
			ds->dda_if.if_unit, line
		DDAELOG;
	    }
#endif  DDADEBUG

	    if (line == -1) {				/* fubar! */
		DMESG(ds->dda_if.if_unit, 107, (DDALOG(LOG_ERR)
		    "dda%d:(x29) x29_supr: answer: line was -1, VC 0x%x\n",
		    ds->dda_if.if_unit, p[1] DDAELOG));
	    }

	    xx_padinfo[line].p_state = PS_PAD;
	    xxstart(&xx_tty[line]);
	} else {
	    DMESG(ds->dda_if.if_unit, 108, (DDALOG(LOG_ERR)
		"dda%d:(x29) x29_supr: unexpected answer on LCN %d\n",
		ds->dda_if.if_unit, lcn DDAELOG));
	}
	if (LOG_CALLS) {
	    DDALOG(LOG_INFO) "dda%d:(x29) LCN %d: connected\n",
			     ds->dda_if.if_unit, lcn
	    DDAELOG;
	}
	break;

    case RING:			/* incoming call */
	if (decode_ring(p)) {
	    /* find a free lcn associated with a XX_HOST open */
	    dc = &ds->dda_cb[1];
	    maxlcn = nddach[ds->dda_if.if_unit];
	    for (lcn = 1; lcn <= maxlcn; lcn++) {
		if (dc->dc_state == LC_IDLE && dc->dc_flags & DC_X29W)
		    break;
		dc++;
	    }
	    if (lcn > maxlcn) {				/* if no free lcn's */
		if (LOG_BUSY) {
		    DDALOG(LOG_ERR)
			"dda%d:(x29) no free X29W lcns, call rejected, vc=0x%x\n",
			ds->dda_if.if_unit, p[1]
		    DDAELOG;
		}
		send_supr(ds, CLEARVC, p[2], 0);	/* clear call */
		break;					/* exit case */
	    }

	    /* got a good lcn, now use it */

#ifdef DDADEBUG
	    if (DDADBCH(103, ds->dda_if.if_unit)) {
		DDALOG(LOG_ERR) "dda%d:(x29) supr_msg: call from 0x%0x\n",
		       ds->dda_if.if_unit, (u_long) dc->dc_inaddr.s_addr
		DDAELOG;
	    }
#endif DDADEBUG

	    dc->dc_state = LC_DATA_IDLE;	/* set state */
	    dc->dc_pktsizein = 0;
	    dc->dc_pktsizeout = 0;
	    dc->dc_wsizein = 0;
	    dc->dc_wsizeout = 0;
	    dc->dc_flags = DC_X29;
	    send_supr(ds, ANSWER, lcn * 2, p[2]);	/* send answer */
	    if (LOG_CALLS) {
		DDALOG(LOG_INFO) "dda%d:(x29) Call accepted LCN %d\n",
	  		         ds->dda_if.if_unit, dc->dc_lcn
		DDAELOG;
	    }

	    line = dc->dc_line;

#ifdef DDADEBUG
	    if (DDADBCH(114, ds->dda_if.if_unit)) {
		DDALOG(LOG_DEBUG) "dda%d:(x29) x29_supr: ring: line=%d\n",
			ds->dda_if.if_unit, line
		DDAELOG;
	    }
#endif  DDADEBUG

	    if (line == -1) {				/* fubar! */
		DMESG(ds->dda_if.if_unit, 107, (DDALOG(LOG_ERR)
		    "dda%d:(x29) x29_supr: ring: line was -1, VC 0x%x\n",
		    ds->dda_if.if_unit, p[1] DDAELOG));
		break;
	    }

	    tp = &xx_tty[line];
	    xx_padinfo[line].p_state = PS_XFR;
	    wakeup((caddr_t) &tp->t_rawq);
	    tp->t_state |= TS_CARR_ON;
#if ACC_ULTRIX > 00
	    tp->t_state &= ~TS_ONDELAY;
#endif
	    /* I would prefer to wait a bit before sending this */
	    send_x29_param_msg(ds, dc, SET_PAD,
			       x29_callin_setparams,
			       sizeof(x29_callin_setparams));
	} else {		/* bad decode */
	    send_supr(ds, CLEARVC, p[2], 0);	/* clear call */
	    DMESG(ds->dda_if.if_unit, 100, (DDALOG(LOG_ERR)
		"dda%d:(x29) Bad decode, call REJECTED VC 0x%x\n",
		ds->dda_if.if_unit, p[1] DDAELOG));
	}
	break;

    case CLEARLC:		/* clear by LCN */
	lcn = p[1] / 2;		/* get LCN */
	dc = &(ds->dda_cb[lcn]);
	if (dc->dc_state != LC_CLR_PENDING) {	/* if no clear pending */
	    send_supr(ds, CLEARLC, p[1], 0);	/* ack the clear */
	}
	if (dc->dc_state == LC_CALL_PENDING)	/* call is cleared */
	    DMESG(ds->dda_if.if_unit, 101, (DDALOG(LOG_ERR)
	    	"dda%d:(x29) Call cleared LCN %d (%x %x)\n",
	        ds->dda_if.if_unit, dc->dc_lcn, p[2], p[4] DDAELOG));

	hist_lcn_state(ds->dda_if.if_unit, dc->dc_state, LC_IDLE);
	dc->dc_state = LC_IDLE;
	dc->dc_timer = TMO_OFF;	/* stop timer */
	dc->dc_wsizein = dc->dc_wsizeout = 0;
	dc->dc_pktsizein = dc->dc_pktsizeout = 0;
	abort_io(ds->dda_if.if_unit, lcn);
	xx_tp_hangup(ds, dc);	/* will clear flags */
	break;

    case CLEARVC:		/* clear by VCN */
	send_supr(ds, CLEARVC, p[1], 0);	/* send clear ack */
	if (LOG_CALLS) {
	    DDALOG(LOG_INFO)
		"dda%d:(x29) Network cleared VC %x (%x %x)\n",
	        ds->dda_if.if_unit, p[1], p[2], p[4]
	    DDAELOG;
	}
	break;

    case RESET:		/* X25 reset */
	send_supr(ds, RESET_ACK, p[1], 0);	/* send reset ack */
	abort_io(ds->dda_if.if_unit, (int) p[1] / 2);
	DMESG(ds->dda_if.if_unit, 102, (DDALOG(LOG_ERR)
	    "dda%d:(x29) X25 RESET on LCN %d (%x %x)\n",
	    ds->dda_if.if_unit, p[1] / 2, p[2], p[4] DDAELOG));
	break;

    case INTERRUPT:		/* X25 interrupt */
#ifdef INDICATE_BREAK_ON_INTERRUPT
	lcn  = p[1] / 2;
	dc   = &(ds->dda_cb[lcn]);

	line = dc->dc_line;

	if (line == -1) {				/* fubar! */
	    DMESG(ds->dda_if.if_unit, 107, (DDALOG(LOG_ERR)
		"dda%d:(x29) x29_supr: break: line was -1, VC 0x%x\n",
		ds->dda_if.if_unit, p[1] DDAELOG));
	    break;
	}

	tp   = &xx_tty[line];

	if (tp->t_flags & RAW)
	    c = 0;
	else
#if ACC_ULTRIX >= 30
	    c = tp->c_cc[VINTR];/* else make it the interrupt */
#else
	    c = tp->t_intrc;	/* else make it the interrupt */
#endif
#if NBK > 0
	if (tp->t_line == NETLDISC) {
	    BKINPUT(c, tp);
	} else
#endif
	    (*linesw[tp->t_line].l_rint) (c, tp);
	/* send_supr (ds, INTR_ACK, p[1], 0); 	not needed -- done by FE */
#endif
	break;

    case INTR_ACK:
	/* quietly drop the acknowledgement */
	break;
    default:
	DMESG(ds->dda_if.if_unit, 104, (DDALOG(LOG_ERR)
	    "dda%d:(x29) supervisor error (%x %x %x %x)\n",
	    ds->dda_if.if_unit, p[0], p[1], p[2], p[3] DDAELOG));
    }
}

	/* hangup any attached processes */
PRIVATE void
xx_tp_hangup(ds, dc)
struct dda_softc *ds;
register struct dda_cb *dc;
{
    register struct tty *tp;
    register padinfo    *pp;
    register int         line;

    line = dc->dc_line;

    if (line == -1) {				/* fubar! */
	DMESG(ds->dda_if.if_unit, 107, (DDALOG(LOG_ERR)
	    "dda%d:(x29) xx_tp_hangup: line was -1\n",
	    ds->dda_if.if_unit DDAELOG));
	return;
    }

    tp   = &xx_tty[line];
    pp   = &xx_padinfo[line];

    if (pp->p_flow != P_NOBLOCK) {	/* currently blocked? */
	register struct hdx_chan *hc;
	hc = (struct hdx_chan *) & dc->dc_rchan;
	dda_rrq(ds, hc);	/* make sure we hang a read */
    }
    pp->p_flow = P_NOBLOCK;
    tp->t_state &= ~(TS_CARR_ON | TS_ASLEEP | TS_BUSY);
    ttyflush(tp, FREAD | FWRITE);
    gsignal(tp->t_pgrp, SIGHUP);
    gsignal(tp->t_pgrp, SIGCONT);
    tp->t_state &= ~TS_ASLEEP;
    wakeup((caddr_t) &tp->t_outq);
    xxmode[line] = MODE_UNUSED;
    tp->t_addr = (caddr_t) NULL;
    pp->p_state = PS_IDLE;
    if (pp->p_mchsav) {
	m_freem(pp->p_mchsav);
	pp->p_msav = pp->p_mchsav = (struct mbuf *) NULL;
    }
    dc->dc_flags &= ~(DC_X29 | DC_X29W);	/* release to others */
}

/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%                      X29_DATA()                             %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*                                                                 */
/*  Purpose:                                                       */
/*                                                                 */
/*    This routine is called when a data channel I/O completes.    */
/*    If the completion was for a write, an attempt is made to     */
/*    start output on the next packet waiting for output on that   */
/*    LCN.  If the completion was for a read, the received packet  */
/*    is sent to the IP input queue (if no error) and another read */
/*    is started on the LCN.                                       */
/*                                                                 */
/*  Call:              x29_data(ds, hc, cc, cnt)                   */
/*  Argument:          ds:  device control block                   */
/*                     hc:  half duplex channel control block      */
/*                     cc:   Mailbox I/O completion status         */
/*                     cnt:  byte count                            */
/*  Returns:           nothing                                     */
/*  Called by:         ddainta()                                   */
/*                                                                 */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

#define QBIT	0x80

PRIVATE void
x29_data(ds, hc, cc, cnt, subcc)
register struct dda_softc *ds;
register struct hdx_chan *hc;
int             cc,
                cnt,
                subcc;
{
    register struct dda_cb *dc = &(ds->dda_cb[hc->hc_chan / 2]);
    register struct tty *tp;

#ifdef DDADEBUG
    if (DDADBCH(104, ds->dda_if.if_unit)) {
 	DDALOG(LOG_DEBUG)
	    "dda%d:(x29) x29_data: chan=%x cc=%x cnt=%x subcc=%x\n",
	    ds->dda_if.if_unit, hc->hc_chan, cc, cnt, subcc
	DDAELOG;
    }
#endif DDADEBUG

    if (hc->hc_chan & 0x01) {	/* if write, fire up next output */
#ifdef DDADEBUG
	dc->dc_out_t = TMO_OFF;	/* turn off output completion timer */
#endif

	if ((hc->hc_func != DDAABT) && (hc->hc_curr = hc->hc_curr->m_next))
	    dda_wrq(ds, hc, 0);
	else {
	    /* it is abort | no more data left */
	    char            qbit_indicator;
	    qbit_indicator = hc->hc_mbuf->m_dat[MLEN - 1];
	    m_freem(hc->hc_mbuf);
	    hc->hc_mbuf = hc->hc_curr = (struct mbuf *) 0;
	    if (hc->hc_func == DDAABT) {
		hc->hc_func &= ~DDAABT;
		hc->hc_inv &= ~INVALID_MBUF;
	    } else
		ds->dda_if.if_opackets++;
	    dc->dc_flags &= ~DC_OBUSY;

	    if (qbit_indicator == QBIT) {	/* Q-bit packet? */
		dda_start(ds, dc);		/* restart output */
	    } else {
		tp = &xx_tty[dc->dc_line];
		tp->t_state &= ~TS_BUSY;
		xxstart(tp);	/* restart tty output */
	    }
	}

	/* it's a packet coming in from the front end to the host */
    } else {
#ifdef DDADEBUG
	dc->dc_flags &= ~DC_IPEND;
#endif
	hc = &dc->dc_rchan;

#ifdef DDADEBUG
	if (DDADBCH(105, ds->dda_if.if_unit)) {
	    u_char         *p;
	    DDALOG(LOG_DEBUG) "dda%d:(x29) ", ds->dda_if.if_unit DDAELOG;
	    p = mtod(hc->hc_curr, u_char *);
	    prt_bytes(ds->dda_if.if_unit, "received data", p, (cnt < 64 ? cnt : 64));
	}
	if (DDADBCH(106, ds->dda_if.if_unit)) {
	    DDALOG(LOG_DEBUG)
		"dda%d:(x29) x29_data: read complete mbuf=%x curr=%x\n",
		ds->dda_if.if_unit, hc->hc_mbuf, hc->hc_curr
	    DDAELOG;
	}
#endif DDADEBUG

	if (dc->dc_state != LC_DATA_IDLE) {
	    m_freem(hc->hc_mbuf);	/* toss the packet, lcn is dead */
	    hc->hc_mbuf = hc->hc_curr = (struct mbuf *) 0;
	} else if (cc == DDAIOCOK || (cc == DDAIOCOKP && !(subcc & QBIT))) {
	/* Queue up I/O completion OK transfers and I/O OK with more data
	 * pending transfers (as long as it's not a Qbit message).
	 * This algorythm operates differently than the IP handler due
	 * to the fact that we don't need to wait for the entire X.25
	 * packet to arrive on the host before we assemble it.  To do
	 * so should be OK,  but unfortunately it seems some brain-dead
	 * PAD's generate packets with the M-bit set if they have more
	 * data in their internal buffers.  This can cause the system
	 * to burn up mbufs waiting for us to finally receive a packet
	 * with the M-bit not set.  However, we should hold up on processing
	 * packets with both the Q-bit and the M-bit set until we receive
	 * the entire Q-bit message.  If we get 30k Q-bit packets, we will
	 * die, but that is obscenely absurd in the first place.
	 * (sigh)	-- pst 7-19-89
	 */

#ifdef DDADEBUG
	    if (DDADBCH(107, ds->dda_if.if_unit)) {
		DDALOG(LOG_DEBUG)
		    "dda%d:(x29) x29_data: chan=%x DDAIOCOK\n",
		    ds->dda_if.if_unit, hc->hc_chan
		DDAELOG;
	    }
#endif DDADEBUG
	    hc->hc_curr->m_len += cnt;	/* update byte count */

	    ds->dda_if.if_ipackets++;
	    /* HANDLE THE DATA HERE */
	    if (subcc & QBIT) {
		int             len;
		char           *mcp;
		mcp = mtod(hc->hc_curr, char *);
		len = hc->hc_curr->m_len;

#ifdef DDADEBUG
		if (DDADBCH(108, ds->dda_if.if_unit))
		    prt_bytes(ds->dda_if.if_unit,
			      "(x29) Qbit:", mcp, (len < 64 ? len : 64));
#endif DDADEBUG

		if (*mcp == BREAK_INDIC) {	/* Break indication? */
		    register struct tty *tp;
		    if (x29_break_reply_is_required(mcp, len)) {
			/* tell pad to stop discarding output */
			send_x29_param_msg(ds, dc, SET_PAD,
					   x29_break_ack_params, 2);
		    }
		    hc->hc_curr->m_len = 1;	/* change data to single byte */
		    tp = &xx_tty[dc->dc_line];
		    if (tp->t_flags & RAW)	/* if port is in raw mode, */
			*mcp = 0;	/* make the byte a null */
		    else
#if ACC_ULTRIX >= 30
			*mcp = tp->t_cc[VINTR];	/* else make it the interrupt */
#else
			*mcp = tp->t_intrc;	/* else make it the interrupt */
#endif
		    x29_dhandle(ds, dc, 0);
		    return;
		} else if (*mcp & READ_PAD) {
		    if (len == 1)	/* just a message, no params? */
			send_x29_param_msg(ds, dc, PAR_INDICATION,
					   x29_callout_params,
					   sizeof(x29_callout_params));
		    else
			send_x29_param_msg(ds, dc, PAR_INDICATION, mcp + 1, len - 1);
		    m_freem(hc->hc_mbuf);
		    hc->hc_mbuf = hc->hc_curr = (struct mbuf *) 0;
		} else {
		    m_freem(hc->hc_mbuf);
		    hc->hc_mbuf = hc->hc_curr = (struct mbuf *) 0;
		}
	    } else {			/* not Qbit data, process normally */
		x29_dhandle(ds, dc, 0);
		return;
	    }
	} else if (cc == DDAIOCOKP) {	/* good completion, more data pending */
	    hc->hc_curr->m_len += cnt;
	} else {			/* toss packet */
	    m_freem(hc->hc_mbuf);
	    hc->hc_mbuf = hc->hc_curr = (struct mbuf *) 0;
	}
	/* hang a new data read */
#ifdef DDADEBUG
	dc->dc_flags |= DC_IPEND;
#endif
	dda_rrq(ds, hc);
    }
}

/* this routine copies chars from the dc_rchan mbuf to the upper
 * level software.  If all the characters are read then the mbuf is
 * freed and a new read is hung on the channel.
 *
 * This routine is called from below by the int A handler and from above
 * by the device read routine.
 */

PRIVATE void
x29_dhandle(ds, dc, restart)
register struct dda_softc *ds;
register struct dda_cb *dc;
int             restart;
{
    register struct tty *tp;
    register struct hdx_chan *hc;
    register padinfo *pp;
    u_char         *cp,
                    c;
    struct mbuf    *m2,
                   *m;
    int             s,
                    line;
    register int    j;
    static int      recurse = 0;

    s = splimp();

    if (recurse) {	/* don't allow ourselves to be called recursively */
	splx(s);
	return;
    } else
	recurse = 1;

    hc = (struct hdx_chan *) &dc->dc_rchan;

    line = dc->dc_line;

    tp = &xx_tty[line];
    pp = &xx_padinfo[line];

    if (restart) {		/* trying to restart input? */
	j  = pp->p_flow;
	m  = pp->p_mchsav;
	m2 = pp->p_msav;

#ifdef DDADEBUG
	if (DDADBCH(109, ds->dda_if.if_unit)) {
	    DDALOG(LOG_DEBUG)
		"dda%d:(x29) flow restart [%d] in %x\n",
		ds->dda_if.if_unit, j, m
	    DDAELOG;
	}
#endif DDADEBUG

    } else {
	j = P_NOBLOCK;
	m2 = m = hc->hc_mbuf;	/* que mbuf chain */
    }

    if (m == 0) {
	DMESG(ds->dda_if.if_unit, 105, (DDALOG(LOG_ERR)
		"dda%d:(x29) x29_dhandle: null mbuf\n",
		ds->dda_if.if_unit DDAELOG));
	hc->hc_mbuf = hc->hc_curr = (struct mbuf *) NULL;
	dda_rrq(ds, hc);
	goto out;
    }
    while (m2) {
	cp = mtod(m2, u_char *);
	for (; j < m2->m_len; j++) {
	    c = cp[j] & INPUT_PARITY_MASK;
	    if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= TTYHOG - 2)
		if (!ttbreakc(c, tp))
		    continue;	/* dump the character */
#if NBK > 0
	    if (tp->t_line == NETLDISC) {
		BKINPUT(c, tp);
	    } else
#endif
		(*linesw[tp->t_line].l_rint) (c, tp);


	    /* Block further input iff: Current input > threshold AND input
	     * is available to user program */

	    if ((tp->t_rawq.c_cc + tp->t_canq.c_cc) >= TTYHOG / 4 &&
		((tp->t_flags & (RAW | CBREAK)) || (tp->t_canq.c_cc > 0))) {
#ifdef DDADEBUG
		if (DDADBCH(109, ds->dda_if.if_unit)) {
		    DDALOG(LOG_DEBUG)
			"dda%d:(x29) flow on [%d] in %x of %d\n",
			ds->dda_if.if_unit, j, m2, m2->m_len
		    DDAELOG;
		}
#endif DDADEBUG
		pp->p_flow = j + 1;
		pp->p_msav = m2;
		pp->p_mchsav = m;
		if (restart == 0)
		    hc->hc_mbuf = hc->hc_curr = (struct mbuf *) NULL;
		goto out;
	    }
	}
	m2 = m2->m_next;
	j = P_NOBLOCK;
    }
    if (restart)
	pp->p_msav = pp->p_mchsav = (struct mbuf *) NULL;

    m_freem(m);
    hc->hc_mbuf = hc->hc_curr = (struct mbuf *) NULL;
    pp->p_flow  = P_NOBLOCK;

#ifdef DDADEBUG
    dc->dc_flags |= DC_IPEND;
#endif

    dda_rrq(ds, hc);

out:
    recurse = 0;
    splx(s);
}

PRIVATE void
xx_qbit_msg(tp, unit, msg)
register struct tty *tp;
int             unit;
char           *msg;
{
    register struct dda_cb *dc;
    register struct dda_softc *ds;
    int             s;

    ds = &dda_softc[unit];
    dc = (struct dda_cb *) tp->t_addr;
    s = splimp();

#ifdef DDADEBUG
    if (DDADBCH(110, unit)) {
	DDALOG(LOG_DEBUG)
	    "dda%d:(x29) xx_qbit_msg: %d %d %d\n",
	    unit, msg[0], msg[1], msg[2]
	DDAELOG;
    }
#endif DDADEBUG

    if (msg[1] < (MLEN - 4))
	send_x29_param_msg(ds, dc, msg[0], msg + 2, msg[1]);
    splx(s);
}

/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%                        XXCNTL()                             %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*                                                                 */
/*  Purpose:                                                       */
/*                                                                 */
/*  Do modem control functions on a line.                          */
/*                                                                 */
/*  Call:           xxcntl(tp, c, d)                               */
/*  Argument:       tp:   pointer to tty structure                 */
/*                  c:    function code                            */
/*                  unit: for unit number                          */
/*  Returns:        none                                           */
/*  Called by:      xxopen()                                       */
/*                  xxclose()                                      */
/*                  xxread()                                       */
/*                  xxint()                                        */
/*                                                                 */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

PRIVATE void
xxcntl(tp, c, unit)
register struct tty *tp;
int             c,
                unit;
{
    register struct dda_cb *dc;
    register struct dda_softc *ds;
    register padinfo *pp;
    int             s,
                    l;

    l = tp - xx_tty;
    ds = &dda_softc[unit];
    pp = &xx_padinfo[l];
    s = splimp();

#ifdef DDADEBUG
    if (DDADBCH(111, unit)) {
	DDALOG(LOG_DEBUG)
	    "dda%d:(x29) xxcntl: tp=0x%x line=%d\n", unit, tp, l
	DDAELOG;
    }
#endif DDADEBUG

    switch (c) {
    case XX_C_PAD:
	if (tp->t_addr)
	    break;
	if (dc = find_free_lcn(ds)) { /* race against locate_x25_lcn */
	    dc->dc_flags = DC_X29;
	    dc->dc_line = l;
	    pp->p_state = PS_COM;
	    tp->t_addr = (caddr_t) dc;
	    tp->t_flags &= ~ECHO;
	    pp->p_flow = P_NOBLOCK;
	    pp->p_msav = pp->p_mchsav = (struct mbuf *) NULL;
	    pp->p_idx = 0;
	    pp->p_line[0] = '\0';
	} else
	    tp->t_addr = (caddr_t) NULL;
	break;
    case XX_C_HOST:
	if (tp->t_addr)
	    break;
	if (dc = find_free_lcn(ds)) { /* race against locate_x25_lcn */
	    dc->dc_flags = DC_X29W;
	    dc->dc_line = l;
	    pp->p_state = PS_WAIT;
	    pp->p_flow = P_NOBLOCK;
	    pp->p_msav = pp->p_mchsav = (struct mbuf *) NULL;
	    tp->t_addr = (caddr_t) dc;
	} else
	    tp->t_addr = (caddr_t) NULL;
	break;
    case XX_C_CLOSE:
	pp->p_state = PS_IDLE;
	if (pp->p_mchsav) {
	    m_freem(pp->p_mchsav);
	    pp->p_msav = pp->p_mchsav = (struct mbuf *) NULL;
	}
	dc = (struct dda_cb *) tp->t_addr;
	if (dc == 0)
	    break;
	if (pp->p_flow != P_NOBLOCK) {	/* currently blocked? */
	    register struct hdx_chan *hc;
	    hc = (struct hdx_chan *) &dc->dc_rchan;
	    dda_rrq(ds, hc);		/* make sure we hang a read */
	}
#ifdef	DDADEBUG
	if (DDADBCH(111, unit)) {
	    static char *st[] = { "lcn down", "lcn restart", "idle",
				  "call pending", "data idle", "clear pending"
				};
	    DDALOG(LOG_DEBUG)
		"dda%d:(x29) xxcntl: close state: %s\n", unit, st[dc->dc_state]
	    DDAELOG;
	}
#endif DDADEBUG

	if (dc->dc_state == LC_DATA_IDLE || dc->dc_state == LC_CALL_PENDING)
	    clear_lcn(ds, dc);	/* send clear & set state to clr_pending */
				/* timers will convert it to LC_IDLE later */

#ifdef	DDADEBUG
	else
	    if (DDADBCH(111, unit)) {
		DDALOG(LOG_DEBUG)
		    "dda%d:(x29) xxcntl: warning: state not data_idle\n", unit
		DDAELOG;
	    }
#endif

	dc->dc_flags &= ~(DC_X29 | DC_X29W);	/* release to others */
	tp->t_addr = (caddr_t) NULL;
	break;
    case XX_C_BREAK:

	/* really should look at X.3 parameters to decide if an interrupt
	 * packet should be sent. instead, we take an action which assumes
	 * PAD parameter 7 has value 21 */
	dc = (struct dda_cb *) tp->t_addr;
	send_supr(ds, INTERRUPT, dc->dc_lcn * 2, 0);
	send_x29_param_msg(ds, dc, BREAK_INDIC, 0, 0);
	break;
    }
    splx(s);
}

/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%                     X29_INIT()                              %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*                                                                 */
/*  Purpose:                                                       */
/*                                                                 */
/*  Software reset, clear lines.                                   */
/*                                                                 */
/*  Call:           x29_init(unit, active);                        */
/*  Argument:       unit:  ACP _XX device                          */
/*  Returns:        none                                           */
/*  Called by:      none                                           */
/*                                                                 */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

PRIVATE void
x29_init(unit, active)
int             unit,
                active;
{
    register int    i;
    register padinfo *pp;

#ifdef	DDADEBUG
    if (DDADBCH(113, unit)) {
	DDALOG(LOG_DEBUG) "dda%d:(x29) x29_init() active=%d\n",
			  unit, active
	DDAELOG;
    }
#endif  DDADEBUG

    if (active)
	xxclear(unit);
    else {
	for (i = 0; i < XXLPERBRD; i++) {
	    xx_tty[unit * XXLPERBRD + i].t_state = PS_IDLE;
	    pp = &xx_padinfo[unit * XXLPERBRD + i];
	    pp->p_state = PS_IDLE;
	    pp->p_flow  = P_NOBLOCK;
	    pp->p_msav  = pp ->p_mchsav = (struct mbuf *) NULL;
	}
    }
}

PRIVATE void
xxclear(unit)
int             unit;
{
    register struct tty *tp;
    register struct dda_softc *ds;
    register struct dda_cb *dc;
    int             i,
                    state;

    ds = &dda_softc[unit];
    for (i = 0, tp = &xx_tty[unit * XXLPERBRD]; i < XXLPERBRD; i++, tp++) {
	state = tp->t_state;
#ifdef	DDADEBUG
	if (DDADBCH(112, unit) && state) {
	    DDALOG(LOG_DEBUG)
		"dda%d:(x29) xxclear: line=%d pgrp=%d state=%d\n",
		unit, i, tp->t_pgrp, state
	    DDAELOG;
	}
#endif  DDADEBUG
	if (state & TS_WOPEN) {
	    tp->t_state &= ~TS_WOPEN;
	    wakeup(&tp->t_rawq);
	}
	if (tp->t_state) {
	    dc = (struct dda_cb *) tp->t_addr;
	    if (dc) {
		xx_tp_hangup(ds, dc);
		dc->dc_line = -1;	/* break correspondence */
	    }
	}
    }
}

/*@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%                        XXSHOW()                             %%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*                                                                 */
/*  Purpose:                                                       */
/*                                                                 */
/*      Show status of each active unit                            */
/*                                                                 */
/*  Call:           xxshow()                                       */
/*  Argument:       none		                           */
/*  Returns:        none                                           */
/*  Called by:      none                                           */
/*                                                                 */
/*##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

PRIVATE void
xxshow()
{
    register struct tty *tp;
    register padinfo    *pp;
    int                  unit,
                         i;
    static char	        *st[] = { "idle", " com", " pad", "wait", "xfer" };


    for (unit = 0; unit < (NDDA < XXBOARDS ? NDDA : XXBOARDS); unit++) {
	uprintf("\nACP5250/6250 X29 driver: state of unit %d -\n", unit);
	uprintf("line\tstate\tlcn\tflow\ttstate\ttflags\n");

	for (i = 0, tp = &xx_tty[unit * XXLPERBRD]; i < XXLPERBRD; i++, tp++) {
	    if (tp->t_state) {
		pp = &xx_padinfo[i];
		uprintf("%d:\t%s\t%d\t%d\t%x\t%x\n", i, st[pp->p_state],
		       (struct dda_cb *) (tp->t_addr) - dda_softc[unit].dda_cb,
		       pp->p_flow, tp->t_state, tp->t_flags);
	    }
	}
    }
    uprintf("remaining lines free\n");
}

/******************************************************************************
 *                           PAD CODE
 ******************************************************************************/
/* PADCHARUP - Pass a character up towards the user */
#define PADCHARUP(c,tp) (*linesw[(tp)->t_line].l_rint) ((c), (tp))

PRIVATE void
xxpadhandle(ds, tp, pi)
struct dda_softc *ds;
struct tty     *tp;		/* pointer to relevant tty structure */
padinfo        *pi;		/* pointer to relevant padinfo structure */
{
    register int    i;
    register char   c;
    register struct dda_cb *dc;
    int             nch;
    char            tbuf[CBSIZE];	/* CBSIZE is number of char in a
					 * cblock */
    nch = q_to_b(&tp->t_outq, tbuf, CBSIZE);

    /* handle characters in command state. Its OK if were slow here because
     * there is a person on the other end of the discussion */
    dc = (struct dda_cb *) tp->t_addr;
    for (i = 0; i < nch; i++) {
	if (pi->p_idx >= P_LINELEN) {
	    xxpadmsg("\r\ncommand too long\r\n@", tp);
	    pi->p_idx = 0;
	    return;
	}
	c = pi->p_line[pi->p_idx] = tbuf[i] & INPUT_PARITY_MASK;
	if (c == '\r' || c == '\n') {
	    PADCHARUP('\r', tp);
	    PADCHARUP('\n', tp);
	    pi->p_line[pi->p_idx] = '\0';
	    if (dc && dc->dc_state != LC_IDLE) {
		xxpadmsg("cannot call, line is in transition\r\n", tp);
		if (dc && dc->dc_state == LC_CALL_PENDING)
		    xxpadmsg("previous call still pending\r\n", tp);
	    } else if (xxpadparse(ds, pi, tp) == 0)
		PADCHARUP('@', tp);
	    pi->p_idx = 0;
	} else if (c == '\b' || c == '\177') {
	    if (pi->p_idx) {
		pi->p_idx--;
		xxpadmsg("\b \b", tp);
	    }
	} else {
	    pi->p_idx++;
	    PADCHARUP(c, tp);
	}
    }
}

PRIVATE int
xxpadparse(ds, pi, tp)
struct dda_softc *ds;
padinfo        *pi;
struct tty     *tp;
{
    char           *p = pi->p_line;

    if (*p == 'c' || *p == 'C') {	/* connect command */
	for (p++; *p == ' '; *p++);
	if (*p < '0' || *p > '9')
	    xxpadmsg("???\r\n", tp);
	else			/* place a call */
	    return xxpadcall(ds, p, tp);
    } else if (*p)
	xxpadmsg("invalid command\r\n", tp);
    return 0;
}

PRIVATE int
xxpadcall(ds, addr, tp)
struct dda_softc *ds;
char           *addr;
struct tty     *tp;
{
    register int    i = 0;
    struct in_addr  in;

    while (addr[i]) {
	if (addr[i] < '0' || addr[i] > '9') {
	    xxpadmsg("invalid address\r\n", tp);
	    return 0;
	}
	i++;
    }
    ddacb_called_addr[0] = i;
    bcopy(addr, ddacb_called_addr + 1, i);
    ddacb_user_data[0] = (u_char) 0;	/* no user data for now */
    in.s_addr = 0;
    return make_x25_call(ds, (struct dda_cb *) tp->t_addr, in, X25_PROTO_X29);
}

PRIVATE void
xxpadmsg(s, tp)
char           *s;
struct tty     *tp;
{
    while (*s) {
	PADCHARUP(*s, tp);
	s++;
    }
}

/*
 * This routine is used to respond to
 * READ_PARAMS and SET_READ_PARAMS requests, and also
 * to send out a SET_PARAMS request for incoming calls.
 * The outgoing pad supports NO parameters.
 */
send_x29_param_msg(ds, dc, type, msg, len)
register struct dda_cb *dc;
register struct dda_softc *ds;
x29_pad_pair   *msg;
{
    struct mbuf    *m;
    u_char         *p;
    short           i;
    register struct ifqueue *oq;
    m = 0;			/* Allocate an mbuf to stuff the chars into */
    MGET(m, M_DONTWAIT, MT_DATA);
    if (m == 0) {
	DMESG(ds->dda_if.if_unit, 106, (DDALOG(LOG_ERR)
		"dda%d:(x29) couldn't get mbuf for QBIT message\n",
		ds->dda_if.if_unit DDAELOG));
	return;
    }
    m->m_dat[MLEN - 1] = QBIT;	/* set Q-bit */
    p = mtod(m, u_char *);
    len = len / 2;
    *p++ = type;
    if (type == PAR_INDICATION) {	/* our pad supports NO parameters */
	for (i = 0; i < len; i++) {
	    *p++ = msg[i].ref | 0x80;	/* set invalid bit */
	    *p++ = 1;		/* not implemented */
	}
    } else {			/* BREAK_INDIC, SET_PAD to ack break */
	for (i = 0; i < len; i++) {
	    *p++ = msg[i].ref;
	    *p++ = msg[i].val;
	}
    }
    m->m_len = 1 + 2 * len;
    oq = &(dc->dc_oq);		/* point to output queue */
    if (IF_QFULL(oq)) {		/* if q full */
	IF_DROP(oq);		/* drop the data */
	m_freem(m);
	ds->dda_if.if_collisions++;	/* for netstat display */
    } else {
	IF_ENQUEUE(oq, m);	/* otherwise queue it */
	dda_start(ds, dc);	/* and try to output */
    }
}

PRIVATE int
x29_break_reply_is_required(mcp, len)
char           *mcp;
int             len;
{
    mcp++;			/* skip over break indication msg */
    while (len > 1) {		/* while there are parameters left, */
	if ((*mcp == 8) && (mcp[1] == 1))	/* paramter 8 set to 1? */
	    return 1;		/* yes */
	mcp += 2;
	len -= 2;
    }
    return 0;
}

/*
 * Ultrix 3.0 removed the old ttbreakc() kernel routine when moving to
 * a posix compliant driver.  Here it is again, (for our local use only!!!)
 *
 */
#if ACC_ULTRIX >= 30
static int
ttbreakc(c, tp)
register        c;
register struct tty *tp;
{
    return (c == tp->t_cc[VEOL] || c == tp->t_cc[VEOF] ||
	    c == tp->t_cc[VEOL2] || c == '\r' && (tp->t_flags & CRMOD));
}
#endif


/*
Revision History:

09-Jun-1988: Unknown (Brad?)
	Initial implementation.
15-Feb-1989: Paul Traina
	Fixed point bug in send_x29_prm_msg
08-Mar-1989: Steve Johnson
	Fixed bug in xx_flow logic
24-May-1989: Paul Traina
	Upgraded for Ultrix 3.0
28-May-1989: Paul Traina
	Added more driver intelligence to disable pad durring call pending
31-May-1989: Paul Traina
	Added flexible mapping for # of boards per unit
04-Jun-1989: Paul Traina
	Fixed driver to dequeue Q-bit X29 packets from the mbuf chain properly.
19-Jun-1989: Paul Traina
	Fixed previous fix-- will need to go over if-elseif logic more
	carefully to make sure we're doing the right thing.  It should be
	recoded.
	Modernized entire debug code suite, changed xxshow functionality to
	use the uprintf() kernel call to display data on user's terminal for
	the xxshow hack.
12-Jul-1989: Paul Traina
	Changed format of some debug messages.  Removed LOCAL_VOID in
	favor of PRIVATE routine to aid in debugging.  Simplified some
	chunky logic.
18-Jul-1989: Paul Traina
	Flipped search order for finding a free X29W lcn at RING time.
	Moved the dc_key.ttyline field out of the union and made it dc_line.
	This fixed the Dartmouth singleuser bug.
19-Jul-1989: Paul Traina
	Changed the packet decode logic in x29_data to immediately process
	packets with more data pending (i.e. the M-bit) right away, instead
	of queuing them up.  (Note: it still queues up Q-bit packets)  This
	may fix the Dartmouth mbuf problem with blasting uploads.
27-Jul-1989: Paul Traina
	Removed 8-bit strip in x29_dhandle.
01-Aug-1989: Paul Traina
	Added additional two parameters to make_x25_call for userdata/length
	for merge with new pad software.
02-Aug-1989: Paul Traina
	Reinserted 8-bit strip on data received from the net.  (uses
	PARITY_MASK define for easy change).
	Fixed forward declaration of ttbreakc().
	Improved readability of xxshow output.
	Removed "super" pad code.
	Modified ps_state to be a real state variable.
03-Aug-1989: Paul Traina
	Reversed earlier change to xxselect which didn't pass major #.
	Modified xxshow output to not use %nd which isn't supported in BSD.
28-Aug-1989: Paul Traina
	Changed parameters of make_x25_call -- plug user data field directly.
14-Nov-1989: Paul Traina
	Added support for Ultrix 3.1 which uses HUPCL instead of HUPCLS
	because of that stupid termio interface (sigh).
16-Nov-1989: Paul Traina
	Changed parity mask to input_parity_mask, added output_parity_mask.
*/