xref: /src/sys/arch/amiga/dev/ser.c

/*
 * Copyright (c) 1982, 1986, 1990 The Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *	@(#)ser.c	7.12 (Berkeley) 6/27/91
 */

#include "ser.h"

#if NSER > 0
#include "sys/param.h"
#include "sys/systm.h"
#include "sys/ioctl.h"
#include "sys/tty.h"
#include "sys/proc.h"
#include "sys/conf.h"
#include "sys/file.h"
#include "sys/malloc.h"
#include "sys/uio.h"
#include "sys/kernel.h"
#include "sys/syslog.h"

#include "device.h"
#include "serreg.h"
#include "machine/cpu.h"

#include "../amiga/custom.h"
#include "../amiga/cia.h"

int	serprobe();
struct	driver serdriver = {
	serprobe, "ser",
};

int	serstart(), serparam(), serintr();
extern int ttrstrt();
int	sersoftCAR;
int	ser_active;
int	ser_hasfifo;
int	nser = NSER;
#ifdef SERCONSOLE
int	serconsole = SERCONSOLE;
#else
int	serconsole = -1;
#endif
int	serconsinit;
int	serdefaultrate = TTYDEF_SPEED;
int	sermajor;
struct	serdevice *ser_addr[NSER];
struct	tty ser_cons;
#if 0
struct	tty *ser_tty[NSER] = { &ser_cons };
#else
struct	tty *ser_tty[NSER];
#endif

struct speedtab serspeedtab[] = {
	0,	0,
	50,	SERBRD(50),
	75,	SERBRD(75),
	110,	SERBRD(110),
	134,	SERBRD(134),
	150,	SERBRD(150),
	200,	SERBRD(200),
	300,	SERBRD(300),
	600,	SERBRD(600),
	1200,	SERBRD(1200),
	1800,	SERBRD(1800),
	2400,	SERBRD(2400),
	4800,	SERBRD(4800),
	9600,	SERBRD(9600),
	19200,	SERBRD(19200),
	38400,	SERBRD(38400),
	-1,	-1
};


/* since this UART is not particularly bright (nice put), we'll have to do
   parity stuff on our own. this table contains the 8th bit in 7bit character
   mode, for even parity. If you want odd parity, flip the bit. (for
   generation of the table, see genpar.c) */

u_char even_parity[] = {
   0,  1,  1,  0,  1,  0,  0,  1,  1,  0,  0,  1,  0,  1,  1,  0,
   1,  0,  0,  1,  0,  1,  1,  0,  0,  1,  1,  0,  1,  0,  0,  1,
   1,  0,  0,  1,  0,  1,  1,  0,  0,  1,  1,  0,  1,  0,  0,  1,
   0,  1,  1,  0,  1,  0,  0,  1,  1,  0,  0,  1,  0,  1,  1,  0,
   1,  0,  0,  1,  0,  1,  1,  0,  0,  1,  1,  0,  1,  0,  0,  1,
   0,  1,  1,  0,  1,  0,  0,  1,  1,  0,  0,  1,  0,  1,  1,  0,
   0,  1,  1,  0,  1,  0,  0,  1,  1,  0,  0,  1,  0,  1,  1,  0,
   1,  0,  0,  1,  0,  1,  1,  0,  0,  1,  1,  0,  1,  0,  0,  1,
};


/* since we don't get interrupts for changes on the modem control line,
   well have to fake them by comparing current settings to the settings
   we remembered on last invocation. */
u_char last_ciab_pra;

extern	struct tty *constty;
#ifdef KGDB
#include "machine/remote-sl.h"

extern dev_t kgdb_dev;
extern int kgdb_rate;
extern int kgdb_debug_init;
#endif

#if 0
#define	UNIT(x)		minor(x)
#else
/* just always force this to 0, so we can later interprete special
   settings out of the unit number.. */
#define UNIT(x)		0
#endif

#ifdef DEBUG
long	fifoin[17];
long	fifoout[17];
long	serintrcount[16];
long	sermintcount[16];
#endif

serprobe(ad)
	register struct amiga_device *ad;
{
	register struct serdevice *ser;
	register int unit;

	ser = (struct serdevice *) ad->amiga_addr;
	unit = ad->amiga_unit;
	if (unit == serconsole)
		DELAY(100000);

	ad->amiga_ipl = 2;
	ser_addr[unit] = ser;
	ser_active |= 1 << unit;
	sersoftCAR = ad->amiga_flags;
#ifdef KGDB
	if (kgdb_dev == makedev(sermajor, unit)) {
		if (serconsole == unit)
			kgdb_dev = NODEV; /* can't debug over console port */
		else {
			(void) serinit(unit, kgdb_rate);
			serconsinit = 1;	/* don't re-init in serputc */
			if (kgdb_debug_init) {
				/*
				 * Print prefix of device name,
				 * let kgdb_connect print the rest.
				 */
				printf("ser%d: ", unit);
				kgdb_connect(1);
			} else
				printf("ser%d: kgdb enabled\n", unit);
		}
	}
#endif
	/*
	 * Need to reset baud rate, etc. of next print so reset serconsinit.
	 * Also make sure console is always "hardwired."
	 */
	if (unit == serconsole) {
		serconsinit = 0;
		sersoftCAR |= (1 << unit);
	}
	return (1);
}

/* ARGSUSED */
#ifdef __STDC__
seropen(dev_t dev, int flag, int mode, struct proc *p)
#else
seropen(dev, flag, mode, p)
	dev_t dev;
	int flag, mode;
	struct proc *p;
#endif
{
	register struct tty *tp;
	register int unit;
	int error = 0;
	int s;

	unit = minor (dev);

	if (unit == 1)
	  {
	    unit = 0;
	    sersoftCAR = 0;
	  }
	else if (unit == 2)
	  {
	    unit = 0;
	    sersoftCAR = 0xff;
	  }
	else
	  unit = 0;

	if (unit >= NSER || (ser_active & (1 << unit)) == 0)
		return (ENXIO);
	if(!ser_tty[unit]) {
#if 0
		MALLOC(tp, struct tty *, sizeof(struct tty), M_TTYS, M_WAITOK);
		bzero(tp, sizeof(struct tty));
		ser_tty[unit] = tp;
#else
		tp = ser_tty[unit] = ttymalloc();
		/* default values are not optimal for this device, increase
		   buffers */
		clfree(&tp->t_rawq);
		clfree(&tp->t_canq);
		clfree(&tp->t_outq);
		clalloc(&tp->t_rawq, 8192, 1);
		clalloc(&tp->t_canq, 8192, 1);
		clalloc(&tp->t_outq, 8192, 0);

#endif
	} else
		tp = ser_tty[unit];
	tp->t_oproc = serstart;
	tp->t_param = serparam;
	tp->t_dev = dev;
	if ((tp->t_state & TS_ISOPEN) == 0) {
		tp->t_state |= TS_WOPEN;
		ttychars(tp);
		if (tp->t_ispeed == 0) {
			tp->t_iflag = TTYDEF_IFLAG | IXOFF;	/* XXXXX */
			tp->t_oflag = TTYDEF_OFLAG;
#if 0
			tp->t_cflag = TTYDEF_CFLAG;
#else
			tp->t_cflag = (CREAD | CS8 | CLOCAL);	/* XXXXX */
#endif
			tp->t_lflag = TTYDEF_LFLAG;
			tp->t_ispeed = tp->t_ospeed = serdefaultrate;
		}
		serparam(tp, &tp->t_termios);
		ttsetwater(tp);
	} else if (tp->t_state&TS_XCLUDE && p->p_ucred->cr_uid != 0)
		return (EBUSY);
	(void) sermctl (dev, TIOCM_DTR | TIOCM_RTS, DMSET);
	if ((sersoftCAR & (1 << unit)) || (sermctl(dev, 0, DMGET) & TIOCM_CD))
		tp->t_state |= TS_CARR_ON;
        s = spltty();
	while ((flag&O_NONBLOCK) == 0 && (tp->t_cflag&CLOCAL) == 0 &&
	       (tp->t_state & TS_CARR_ON) == 0) {
		tp->t_state |= TS_WOPEN;
		if (error = ttysleep(tp, (caddr_t)&tp->t_rawq, TTIPRI | PCATCH,
		    ttopen, 0))
			break;
	}
	splx (s);
	if (error == 0)
		error = (*linesw[tp->t_line].l_open)(dev, tp);
	return (error);
}

/*ARGSUSED*/
serclose(dev, flag, mode, p)
	dev_t dev;
	int flag, mode;
	struct proc *p;
{
	register struct tty *tp;
	register struct serdevice *ser;
	register int unit;

	unit = UNIT(dev);

	ser = ser_addr[unit];
	tp = ser_tty[unit];
	(*linesw[tp->t_line].l_close)(tp, flag);
	custom.adkcon = ADKCONF_UARTBRK;	/* clear break */
#ifdef KGDB
	/* do not disable interrupts if debugging */
	if (dev != kgdb_dev)
#endif
	custom.intena = INTF_RBF|INTF_TBE; /* clear interrupt enable */
	custom.intreq = INTF_RBF|INTF_TBE; /* and   interrupt request */
#if 0
/* if the device is closed, it's close, no matter whether we deal with modem
   control signals nor not. */
	if (tp->t_cflag&HUPCL || tp->t_state&TS_WOPEN ||
	    (tp->t_state&TS_ISOPEN) == 0)
#endif
		(void) sermctl(dev, 0, DMSET);
	ttyclose(tp);
#if 0
	if (tp != &ser_cons)
	  {
#if 0
	    FREE(tp, M_TTYS);
#else
	    ttyfree (tp);
#endif
	    ser_tty[unit] = (struct tty *)NULL;
	  }
#endif
	return (0);
}

serread(dev, uio, flag)
	dev_t dev;
	struct uio *uio;
{
	register struct tty *tp = ser_tty[UNIT(dev)];
	int error;

	if (! tp)
	  return ENXIO;

	error = (*linesw[tp->t_line].l_read)(tp, uio, flag);

	return error;
}

serwrite(dev, uio, flag)
	dev_t dev;
	struct uio *uio;
{
	int unit = UNIT(dev);
	register struct tty *tp = ser_tty[unit];

	if (! tp)
	  return ENXIO;

	/*
	 * (XXX) We disallow virtual consoles if the physical console is
	 * a serial port.  This is in case there is a display attached that
	 * is not the console.  In that situation we don't need/want the X
	 * server taking over the console.
	 */
	if (constty && unit == serconsole)
		constty = NULL;
	return ((*linesw[tp->t_line].l_write)(tp, uio, flag));
}


/* don't do any processing of data here, so we store the raw code
   obtained from the uart register. In theory, 110kBaud gibes you
   11kcps, so 16k buffer should be more than enough, interrupt
   latency of 1s should never happen, or something is seriously
   wrong.. */
#define SERIBUF_SIZE 16738
static u_short serbuf[SERIBUF_SIZE];
static u_short *sbrpt = serbuf;
static u_short *sbwpt = serbuf;


/* this is a replacement for the lack of a hardware fifo. 32k should be
   enough (there's only one unit anyway, so this is not going to
   accumulate). */
void
ser_fastint ()
{
  /* we're at RBE-level, which is higher than VBL-level which is used
     to periodically transmit contents of this buffer up one layer,
     so no spl-raising is necessary. */

  register u_short ints, code;

  ints = custom.intreqr & INTF_RBF;
  if (! ints)
    return;

  /* clear interrupt */
  custom.intreq = ints;
  /* this register contains both data and status bits! */
  code = custom.serdatr;

  /* should really not happen, but you never know.. buffer
     overflow. */
  if (sbwpt + 1 == sbrpt
      || (sbwpt == serbuf + SERIBUF_SIZE - 1 && sbrpt == serbuf))
    {
      log (LOG_WARNING, "ser_fastint: buffer overflow!");
      return;
    }

  *sbwpt++ = code;
  if (sbwpt == serbuf + SERIBUF_SIZE)
    sbwpt = serbuf;
}


int
serintr(unit)
	register int unit;
{
	register struct serdevice *ser;
	int s1, s2;

	ser = ser_addr[unit];

	/* make sure we're not interrupted by another
	   vbl, but allow level5 ints */
	s1 = spltty();

	/* ok, pass along any acumulated information .. */
	while (sbrpt != sbwpt)
	  {
	    /* no collision with ser_fastint() */
	    sereint (unit, *sbrpt, ser);
	    /* lock against ser_fastint() */
	    s2 = spl5();
	    {
	      sbrpt++;
	      if (sbrpt == serbuf + SERIBUF_SIZE)
		sbrpt = serbuf;
	    }
	    splx (s2);
	  }

	splx (s1);

#if 0
/* add the code below if you really need it */
	  {
/*
 * Process a received byte.  Inline for speed...
 */
#ifdef KGDB
#define	RCVBYTE() \
	    ch = code & 0xff; \
	    if ((tp->t_state & TS_ISOPEN) == 0) { \
		if (ch == FRAME_END && \
		    kgdb_dev == makedev(sermajor, unit)) \
			kgdb_connect(0); /* trap into kgdb */ \
	    }
#else
#define	RCVBYTE()
#endif
	    RCVBYTE();
	    /* sereint does the receive-processing */
	    sereint (unit, code, ser);
	  }
#endif
}

sereint(unit, stat, ser)
	register int unit, stat;
	register struct serdevice *ser;
{
	register struct tty *tp;
	register int c;
	register u_char ch;

	tp = ser_tty[unit];
	if ((tp->t_state & TS_ISOPEN) == 0) {
#ifdef KGDB
		/* we don't care about parity errors */
		if (kgdb_dev == makedev(sermajor, unit) && c == FRAME_END)
			kgdb_connect(0); /* trap into kgdb */
#endif
		return;
	}
	ch = stat & 0xff;
	c = ch;
	/* all databits 0 including stop indicate break condition */
	if (!(stat & 0x1ff))
	  c |= TTY_FE;

	/* if parity checking enabled, check parity */
	else if ((tp->t_cflag & PARENB) &&
		 (((ch >> 7) + even_parity[ch & 0x7f] + !!(tp->t_cflag & PARODD)) & 1))
	  c |= TTY_PE;

	if (stat & SERDATRF_OVRUN)
	  log(LOG_WARNING, "ser%d: silo overflow\n", unit);

	(*linesw[tp->t_line].l_rint)(c, tp);
}

/* this interrupt is periodically invoked in the vertical blank
   interrupt. It's used to keep track of the modem control lines
   and (new with the fast_int code) to move accumulated data
   up into the tty layer. */
void
sermint(unit)
	register int unit;
{
	register struct tty *tp;
	register u_char stat, last, istat;
	register struct serdevice *ser;

	tp = ser_tty[unit];
	if (!tp)
	  return;

	if ((tp->t_state & (TS_ISOPEN|TS_WOPEN)) == 0)
	  {
	    sbrpt = sbwpt = serbuf;
	    return;
	  }


	/* first empty buffer */
	serintr (0);

	stat = ciab.pra;
	last = last_ciab_pra;
	last_ciab_pra = stat;

	/* check whether any interesting signal changed state */
	istat = stat ^ last;

	if ((istat & CIAB_PRA_CD) && (sersoftCAR & (1 << unit)) == 0)
	  {
	    if (ISDCD (stat))
	      (*linesw[tp->t_line].l_modem)(tp, 1);
	    else if ((*linesw[tp->t_line].l_modem)(tp, 0) == 0)
	      {
	        CLRDTR (stat);
	        CLRRTS (stat);
	        ciab.pra = stat;
	        last_ciab_pra = stat;
	      }
	  }
	else if ((istat & CIAB_PRA_CTS) && (tp->t_state & TS_ISOPEN) &&
		 (tp->t_flags & CRTSCTS))
	  {
	    /* the line is up and we want to do rts/cts flow control */
	    if (ISCTS (stat))
	      {
		tp->t_state &=~ TS_TTSTOP;
		ttstart(tp);
		/* cause tbe-int if we were stuck there */
		custom.intreq = INTF_SETCLR | INTF_TBE;
	      }
	    else
	      tp->t_state |= TS_TTSTOP;
	  }
}

serioctl(dev, cmd, data, flag)
	dev_t dev;
	caddr_t data;
{
	register struct tty *tp;
	register int unit = UNIT(dev);
	register struct serdevice *ser;
	register int error;

	tp = ser_tty[unit];
	if (! tp)
	  return ENXIO;

	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)
		return (error);

	ser = ser_addr[unit];
	switch (cmd) {

	case TIOCSBRK:
		custom.adkcon = ADKCONF_SETCLR | ADKCONF_UARTBRK;
		break;

	case TIOCCBRK:
		custom.adkcon = ADKCONF_UARTBRK;
		break;

	case TIOCSDTR:
		(void) sermctl(dev, TIOCM_DTR | TIOCM_RTS, DMBIS);
		break;

	case TIOCCDTR:
		(void) sermctl(dev, TIOCM_DTR | TIOCM_RTS, DMBIC);
		break;

	case TIOCMSET:
		(void) sermctl(dev, *(int *)data, DMSET);
		break;

	case TIOCMBIS:
		(void) sermctl(dev, *(int *)data, DMBIS);
		break;

	case TIOCMBIC:
		(void) sermctl(dev, *(int *)data, DMBIC);
		break;

	case TIOCMGET:
		*(int *)data = sermctl(dev, 0, DMGET);
		break;

	default:
		return (ENOTTY);
	}
	return (0);
}

serparam(tp, t)
	register struct tty *tp;
	register struct termios *t;
{
	register struct serdevice *ser;
	register int cfcr, cflag = t->c_cflag;
	int unit = UNIT(tp->t_dev);
	int ospeed = ttspeedtab(t->c_ospeed, serspeedtab);

	/* check requested parameters */
        if (ospeed < 0 || (t->c_ispeed && t->c_ispeed != t->c_ospeed))
                return (EINVAL);
        /* and copy to tty */
        tp->t_ispeed = t->c_ispeed;
        tp->t_ospeed = t->c_ospeed;
        tp->t_cflag = cflag;

	custom.intena = INTF_SETCLR | INTF_RBF | INTF_TBE;
	last_ciab_pra = ciab.pra;

	if (ospeed == 0)
	  {
	    (void) sermctl(unit, 0, DMSET);	/* hang up line */
	    return (0);
	  }
	else
	  {
	    /* make sure any previous hangup is undone, ie.
	       reenable DTR. */
	    (void) sermctl (tp->t_dev, TIOCM_DTR | TIOCM_RTS, DMSET);
	  }
	/* set the baud rate */
	custom.serper = (0<<15) | ospeed;  /* select 8 bit mode (instead of 9 bit) */

	return (0);
}


static void
ser_putchar (tp, c)
     struct tty *tp;
     unsigned short c;
{
  /* handle truncation of character if necessary */
  if ((tp->t_cflag & CSIZE) == CS7)
    c &= 0x7f;

  /* handle parity if necessary (forces CS7) */
  if (tp->t_cflag & PARENB)
    {
      if (even_parity[c & 0x7f])
	c |= 0x80;
      if (tp->t_cflag & PARODD)
	c ^= 0x80;
    }

  /* add stop bit(s) */
  if (tp->t_cflag & CSTOPB)
    c |= 0x300;
  else
    c |= 0x100;

  custom.serdat = c;
}


#define SEROBUF_SIZE	1024
static u_char ser_outbuf[SEROBUF_SIZE];
static u_char *sob_ptr=ser_outbuf, *sob_end=ser_outbuf;
void
ser_outintr ()
{
  struct tty *tp = ser_tty[0]; /* hmmmmm */
  unsigned short c;
  int s;

  if (! tp)
    return;

  if (! (custom.intreqr & INTF_TBE))
    return;

  /* clear interrupt */
  custom.intreq = INTF_TBE;

  if (sob_ptr == sob_end)
    {
      s = spltty();
      /* hm, probably not necessary in every case, but WHEN is
	 it necessary? */
      tp->t_state |= TS_TIMEOUT;
      timeout (ttrstrt, tp, 1);
      tp->t_state &= ~TS_BUSY;
      splx (s);
      return;
    }

  if (tp->t_state & TS_TTSTOP)
    return;

  ser_putchar (tp, *sob_ptr++);
}

serstart(tp)
	register struct tty *tp;
{
	register int cc, s;
	int unit;
	register struct serdevice *ser;
	int hiwat = 0;

 	if (! (tp->t_state & TS_ISOPEN))
	  return;

	unit = UNIT(tp->t_dev);
	ser = ser_addr[unit];

	s = spltty();
	if (tp->t_state & (TS_TIMEOUT|TS_BUSY|TS_TTSTOP)) {
		splx(s);
		return;
	}
	tp->t_state |= TS_BUSY;
	cc = tp->t_outq.c_cc;
	if (cc <= tp->t_lowat) {
		if (tp->t_state & TS_ASLEEP) {
			tp->t_state &= ~TS_ASLEEP;
			wakeup(&tp->t_outq);
		}
		selwakeup(&tp->t_wsel);
	}
	/*
	 * Limit the amount of output we do in one burst
	 * to prevent hogging the CPU.
	 */
	if (cc > SEROBUF_SIZE) {
		hiwat++;
		cc = SEROBUF_SIZE;
	}
	cc = q_to_b (&tp->t_outq, ser_outbuf, cc);
	if (cc > 0)
	  {
	    sob_ptr = ser_outbuf;
	    sob_end = ser_outbuf + cc;
	    /* get first character out, then have tbe-interrupts blow out
	       further characters, until buffer is empty, and TS_BUSY
	       gets cleared. */
	    ser_putchar (tp, *sob_ptr++);
	  }
	else
	  tp->t_state &= ~TS_BUSY;

	splx(s);
}

/*
 * Stop output on a line.
 */
/*ARGSUSED*/
serstop(tp, flag)
	register struct tty *tp;
{
	register int s;

	s = spltty();
	if (tp->t_state & TS_BUSY) {
		if ((tp->t_state&TS_TTSTOP)==0)
			tp->t_state |= TS_FLUSH;
	}
	splx(s);
}

sermctl(dev, bits, how)
	dev_t dev;
	int bits, how;
{
	register struct serdevice *ser;
	register int unit;
	u_char ub;
	int s;

	unit = UNIT(dev);
	ser = ser_addr[unit];

	/* convert TIOCM* mask into CIA mask (which is really low-active!!) */
	if (how != DMGET)
	  {
	    ub = 0;
	    if (bits & TIOCM_DTR) ub |= CIAB_PRA_DTR;
	    if (bits & TIOCM_RTS) ub |= CIAB_PRA_RTS;
	    if (bits & TIOCM_CTS) ub |= CIAB_PRA_CTS;
	    if (bits & TIOCM_CD)  ub |= CIAB_PRA_CD;
	    if (bits & TIOCM_RI)  ub |= CIAB_PRA_SEL;	/* collision with /dev/par ! */
	    if (bits & TIOCM_DSR) ub |= CIAB_PRA_DSR;
	  }


	s = spltty();
	switch (how) {

	case DMSET:
		/* invert and set */
		ciab.pra = ~ub;
		break;

	case DMBIC:
		ciab.pra |= ub;
		ub = ~ciab.pra;
		break;

	case DMBIS:
		ciab.pra &= ~ub;
		ub = ~ciab.pra;
		break;

	case DMGET:
		ub = ~ciab.pra;
		break;
	}
	(void) splx(s);

	bits = 0;
	if (ub & CIAB_PRA_DTR) bits |= TIOCM_DTR;
	if (ub & CIAB_PRA_RTS) bits |= TIOCM_RTS;
	if (ub & CIAB_PRA_CTS) bits |= TIOCM_CTS;
	if (ub & CIAB_PRA_CD)  bits |= TIOCM_CD;
	if (ub & CIAB_PRA_SEL) bits |= TIOCM_RI;
	if (ub & CIAB_PRA_DSR) bits |= TIOCM_DSR;

	return bits;
}

/*
 * Following are all routines needed for SER to act as console
 */
#include "../amiga/cons.h"

sercnprobe(cp)
	struct consdev *cp;
{
	int unit = CONUNIT;
	/* locate the major number */
	for (sermajor = 0; sermajor < nchrdev; sermajor++)
		if (cdevsw[sermajor].d_open == seropen)
			break;

	/* XXX: ick */
	unit = CONUNIT;

	/* initialize required fields */
	cp->cn_dev = makedev(sermajor, unit);
#if 0
	/* on ser it really doesn't matter whether we're later
	   using the tty interface or single-character io thru
	   cnputc, so don't reach out to later on remember that
	   our console is here (see ite.c) */
	cp->cn_tp = ser_tty[unit];
#endif
	cp->cn_pri = CN_NORMAL;

	/*
	 * If serconsole is initialized, raise our priority.
	 */
	if (serconsole == unit)
		cp->cn_pri = CN_REMOTE;
#ifdef KGDB
	if (major(kgdb_dev) == 1)			/* XXX */
		kgdb_dev = makedev(sermajor, minor(kgdb_dev));
#endif
}

sercninit(cp)
	struct consdev *cp;
{
	int unit = UNIT(cp->cn_dev);

	serinit(unit, serdefaultrate);
	serconsole = unit;
	serconsinit = 1;
}

serinit(unit, rate)
	int unit, rate;
{
	int s;

#ifdef lint
	stat = unit; if (stat) return;
#endif
	s = splhigh();
	/* might want to fiddle with the CIA later ??? */
	custom.serper = ttspeedtab(rate, serspeedtab);
	splx(s);
}

sercngetc(dev)
{
	u_short stat;
	int c, s;

#ifdef lint
	stat = dev; if (stat) return (0);
#endif
	s = splhigh();
	while (!((stat = custom.serdatr & 0xffff) & SERDATRF_RBF))
		;
	c = stat & 0xff;
	/* clear interrupt */
	custom.intreq = INTF_RBF;
	splx(s);
	return (c);
}

/*
 * Console kernel output character routine.
 */
sercnputc(dev, c)
	dev_t dev;
	register int c;
{
	register int timo;
	short stat;
	int s = splhigh();

#ifdef lint
	stat = dev; if (stat) return;
#endif
	if (serconsinit == 0) {
		(void) serinit(UNIT(dev), serdefaultrate);
		serconsinit = 1;
	}
	/* wait for any pending transmission to finish */
	timo = 50000;
        while (! (custom.serdatr & SERDATRF_TBE) && --timo)
		;
        custom.serdat = (c&0xff) | 0x100;
	/* wait for this transmission to complete */
	timo = 1500000;
        while (! (custom.serdatr & SERDATRF_TBE) && --timo)
		;
	/* wait for the device (my vt100..) to process the data, since
	   we don't do flow-control with cnputc */
        for (timo = 0; timo < 30000; timo++) ;

	/* clear any interrupts generated by this transmission */
        custom.intreq = INTF_TBE;
	splx(s);
}


serspit(c)
	int c;
{
	register struct Custom *cu asm("a2") = CUSTOMbase;
	register int timo asm("d2");
	extern int cold;
	int s;

	if (c == 10)
	  serspit (13);

	s = splhigh();

	/* wait for any pending transmission to finish */
	timo = 500000;
        while (! (cu->serdatr & (SERDATRF_TBE|SERDATRF_TSRE)) && --timo)
		;
        cu->serdat = (c&0xff) | 0x100;
	/* wait for this transmission to complete */
	timo = 15000000;
        while (! (cu->serdatr & SERDATRF_TBE) && --timo)
		;
	/* clear any interrupts generated by this transmission */
        cu->intreq = INTF_TBE;

        for (timo = 0; timo < 30000; timo++) ;

	splx (s);
}

serspits(cp)
     char *cp;
{
  while (*cp)
    serspit(*cp++);
}

int
serselect(dev, rw, p)
	dev_t dev;
	int rw;
	struct proc *p;
{
	register struct tty *tp = ser_tty[UNIT(dev)];
	int nread;
	int s = spltty();
        struct proc *selp;

	switch (rw) {

	case FREAD:
		nread = ttnread(tp);
		if (nread > 0 ||
		   ((tp->t_cflag&CLOCAL) == 0 && (tp->t_state&TS_CARR_ON) == 0))
			goto win;
		selrecord(p, &tp->t_rsel);
		break;

	case FWRITE:
		if (tp->t_outq.c_cc <= tp->t_lowat)
			goto win;
		selrecord(p, &tp->t_wsel);
		break;
	}
	splx(s);
	return (0);
  win:
	splx(s);
	return (1);
}

#endif