/*-
 * Copyright (C) 1993	Allen K. Briggs, Chris P. Caputo,
 *			Michael L. Finch, Bradley A. Grantham, and
 *			Lawrence A. Kesteloot
 * 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 Alice Group.
 * 4. The names of the Alice Group or any of its members may not be used
 *    to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE ALICE GROUP ``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 ALICE GROUP 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.
 *
 */
#ident "$Id: ser.c,v 1.1.1.1 1993/09/29 06:09:27 briggs Exp $"

/*
 *	Mac II serial device interface
 *
 * 	Information used in this source was gleaned from low-memory
 *	 global variables in MacOS and the Advanced Micro Devices
 *	 1992 Data Book/Handbook.
 */

#define NSER 2	/* Could be more later with proprietary serial iface? */

#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/uio.h"
#include "sys/kernel.h"
#include "sys/syslog.h"

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


#define DEBUG

volatile unsigned char *sccA = (unsigned char *) 0x50004000;

int	serstart(), serparam(), serintr();
int	ser_active = 0;
int	nser = NSER;
int	serdefaultrate = TTYDEF_SPEED;
int	sermajor;
struct	tty *ser_tty[NSER];

extern	struct tty *constty;

#define	UNIT(x)		minor(x)


char serial_id_string[] = "Two MacII serial devices built in.";
char serial_debug_id_string[] = "Two MacII serial devices--one in use for debugging.";
char serial_0_string[] = "MacBSD Serial Driver, Port 0\n\r";
char serial_1_string[] = "MacBSD Serial Driver, Port 1\n\r";


unsigned char ser_0_init_bytes[]={
#if 0	/* BG -- I made this table from scratch according to the docs. */
	9, SER_W9_NV | SER_W9_DLC,	/* No interrupt vector */
					/* Disable lower chain */	
	4, SER_W4_1SBIT,		/* One stop bit, clock times 1 */
	10, SER_W10_NRZ,		/* NRZ mode encoding */
	11, SER_W11_TXBR | SER_W11_RXBR,/* Receive and Transmit using BR clock */
	12, 102,			
	13, 0,				/* Time code for 19200 baud */
	14, SER_W14_ENBBR,		/* Enable BR clock */
	15, SER_W15_ABRTINT,		/* Abort pending interrupts */
	3, SER_W3_RX8DBITS | SER_W3_ENBRX,
					/* Receive 8 bit data, rx int ready */
	5, SER_W5_TX8DBITS | SER_W5_ENBTX,
					/* Receive 8 bit data, rx int ready */
	0, SER_W0_ENBRXRDY,		/* Enable rx int on next char */
	1, SER_W1_ENBRXRDY | SER_W1_ENBTXRDY,
					/* Enable receive and transmit ints */
	9, SER_W9_MIE			/* Enable Master Interrupt */
#else	/* but it doesn't work as well as this hacked job does: */
	2, 0,
	10, 0,
	11, 0x50,
	4, 0x44,
	3, 0xc1,
	5, 0xea,
	14, 0x01,
	15, 0x80,
	12, 4,
	13, 0,
	1, 0x13,
	0, 0x10,
	0, 0x20,
	0, 0x08,
	9, 0x0C
#endif
};

unsigned char ser_1_init_bytes[]={
	2, 0,
	10, 0,
	11, 0x50,
	4, 0x44,
	3, 0xc1,
	5, 0xea,
	14, 0x01,
	15, 0x80,
	12, 4,
	13, 0,
	1, 0x13,
	0, 0x10,
	0, 0x20,
	0, 0x08,
	9, 0x0C
};


void SER_DOCNTL(
	int unit,
	int reg,
	int data)
{
	if(reg != 0)
		SCCCNTL(unit) = (unsigned char)reg;
	SCCCNTL(unit) = (unsigned char)data;
}

int SER_STATUS(
	int unit,
	int reg)
{
	if(reg != 0)
		SCCCNTL(unit) = (unsigned char)reg;
	return(SCCCNTL(unit));
}


serinit(register struct macdriver *md)
{
extern	int serial_boot_echo;
	int bcount;
	int i;
	int s;

#if defined(DEBUG)
	printf("ser: entering serinit()\n");
#endif

	md->hwfound = 1;
	md->name = serial_id_string;

	if (serial_boot_echo) {
		md->name = serial_debug_id_string;
	}
	SER_DOCNTL(0, 9, 0xc0);	/* force hardware reset */

	s = splhigh();
		/* initialize port 0 */
	bcount = sizeof(ser_0_init_bytes);
	for(i = 0; i < bcount; i += 2){
		SER_DOCNTL(0, ser_0_init_bytes[i], ser_0_init_bytes[i + 1]);
	}
	for(i = 0; i < 10; i++)
		SCCRDWR(0) = "Hello, 0\r\n"[i];

	splx(s);

#if 1
	s = splhigh();
		/* initialize port 1 */
	bcount = sizeof(ser_1_init_bytes);
	for(i = 0; i < bcount; i += 2){
		SER_DOCNTL(1, ser_1_init_bytes[i], ser_1_init_bytes[i + 1]);
	}
	for(i = 0; i < 10; i++)
		SCCRDWR(1) = "Hello, 1\r\n"[i];

	splx(s);

#endif

#if defined(DEBUG)
	printf("ser: exiting serinit()\n");
#endif
	return(1);
}


/* ARGSUSED */
seropen(dev_t dev, int flag, int mode, struct proc *p)
{
	register struct tty *tp;
	register int unit;
	int error = 0;
 
#if defined(DEBUG)
	printf("ser: entered seropen(%d, %d, %d, xx)\n", dev, flag, mode);
#endif
	unit = UNIT(dev);
	if (unit >= NSER ){
		return (ENXIO);
	}
	ser_active |= 1 << unit;
	if (ser_tty[unit]) {
		tp = ser_tty[unit];
	} else {
		tp = ser_tty[unit] = ttymalloc();
	}
	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;
			tp->t_oflag = TTYDEF_OFLAG;
			tp->t_cflag = TTYDEF_CFLAG;
			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){
		printf("ser%d: device is busy.\n", unit);
		return (EBUSY);
	}

		/* serial device open code */
	/* SER_DOCNTL(unit, 5, SER_W5_RTSON | SER_W5_DTRON); */
	if(SER_STATUS(unit, 0) & SER_R0_DCD)
		tp->t_state |= TS_CARR_ON;
		/* end serial device open code */

	(void) 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;
	}
	(void) spl0();
	if (error == 0)
		error = (*linesw[tp->t_line].l_open)(dev, tp);

#if defined(DEBUG)
	printf("ser: exiting seropen()\n");
#endif

	return (error);
}
 
/*ARGSUSED*/
serclose(dev_t dev, int flag, int mode, struct proc *p)
{
	register struct tty *tp;
	register int unit;
 
#if defined(DEBUG)
	printf("ser: entered serclose()\n");
#endif
	unit = UNIT(dev);
	tp = ser_tty[unit];
	(*linesw[tp->t_line].l_close)(tp, flag);

		/* serial device close code */
	/* SER_DOCNTL(unit, 5, SER_W5_BREAK); */
	/* SER_DOCNTL(unit, 1, 0);	/* Disables all ints */
	if (tp->t_cflag&HUPCL || tp->t_state&TS_WOPEN ||
	    (tp->t_state&TS_ISOPEN) == 0)
		SER_DOCNTL(unit, 5, 0);	/* turn RTS and DTR off */
	ser_active &= ~(1 << unit);
		/* end of serial device close code */

	ttyclose(tp);
	ttyfree(tp);
	ser_tty[unit] = NULL;
#if defined(DEBUG)
	printf("ser: exiting serclose()\n");
#endif
	return (0);
}
 
serread(dev, uio, flag)
	dev_t dev;
	struct uio *uio;
	int flag;
{
	register struct tty *tp = ser_tty[UNIT(dev)];
#if defined(DEBUG)
	printf("ser: called serread()\n");
#endif
 
	return ((*linesw[tp->t_line].l_read)(tp, uio, flag));
}
 
serwrite(dev, uio, flag)
	dev_t dev;
	struct uio *uio;
	int flag;
{
	int unit = UNIT(dev);
	register struct tty *tp = ser_tty[unit];
 
#if defined(DEBUG)
	printf("ser: called serwrite()\n");
#endif
	return ((*linesw[tp->t_line].l_write)(tp, uio, flag));
}

#define OUTBUFLEN	128
static unsigned char ser_outbuf[NSER][OUTBUFLEN];
static unsigned char ser_outlen[NSER] = {0,0};
static unsigned char ser_outtail[NSER] = {0,0};
 
serintr()
{
	/* serial interrupt code */
   /* This function is called by locore.s on a level 4 interrupt. */

   int reg0, ch, s;
   unsigned char c;
   char str[20];
   register struct tty *tp;
   static int int_so_far = 0;

   if(int_so_far < 10)printf("ser: interrupt %d\n", int_so_far++);

   tp = ser_tty[0];

   reg0 = SCCCNTL(0);	/* Should be SER_STATUS(0, 0) */

   while(reg0 & SER_R0_RXREADY)
   {
      printf("ser:0 rx rdy\n");
      ch = SCCRDWR(0);
      SER_DOCNTL(0, 0, SER_W0_RSTIUS); /* Reset external/status interrupt */
      if ((tp->t_state & TS_ISOPEN) != 0)
         (*linesw[tp->t_line].l_rint)(ch, tp);
   }

   if(reg0 & SER_R0_TXREADY)
   {
      /* write_ack = 0; */
      printf("ser:0 tx rdy\n");
      SER_DOCNTL(0, 0, SER_W0_RSTTXPND);
      SER_DOCNTL(0, 0, SER_W0_RSTIUS);
      if (ser_outlen[0] > 0)
      {
        s = splhigh();
        c = ser_outbuf[0][ser_outtail[0]];
        ser_outtail[0] = (ser_outtail[0] + 1) % OUTBUFLEN;
	SCCRDWR(0) = c;
        /* write_ack = 1; */
        ser_outlen[0]--;
        splx(s);
      }
   }

   tp = ser_tty[1];
   reg0 = SCCCNTL(1);	/* Should be SER_STATUS(1, 0) */

   while(reg0 & SER_R0_RXREADY)
   {
      printf("ser:1 rx rdy\n");
      ch = SCCRDWR(1);
      SER_DOCNTL(1, 0, SER_W0_RSTIUS); /* Reset external/status interrupt */
      if ((tp->t_state & TS_ISOPEN) != 0)
         (*linesw[tp->t_line].l_rint)(ch, tp);
   }

   if(reg0 & SER_R0_TXREADY)
   {
      /* write_ack = 0; */
      printf("ser:1 tx rdy\n");
      SER_DOCNTL(1, 0, SER_W0_RSTTXPND);
      SER_DOCNTL(1, 0, SER_W0_RSTIUS);
      if (ser_outlen[1] > 0)
      {
        s = splhigh();
        c = ser_outbuf[1][ser_outtail[1]];
        ser_outtail[1] = (ser_outtail[1] + 1) % OUTBUFLEN;
	printf("ser1: sent '%c'\n", c);
	SCCRDWR(1) = c;
        /* write_ack = 1; */
        ser_outlen[1]--;
        splx(s);
      }
   }

   return(1);
	/* end of serial interrupt code */
}


serioctl(dev, cmd, data, flag)
	dev_t dev;
	int cmd;
	caddr_t data;
	int flag;
{
	register struct tty *tp;
	register int unit = UNIT(dev);
	register int error;
 
#if defined(DEBUG)
	printf("ser: entering ioctl()\n");
#endif
	tp = ser_tty[unit];
	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);

	switch (cmd) {
#if 0
	case TIOCSBRK:	/* turn break on */
		dca->dca_cfcr |= CFCR_SBREAK;
		break;

	case TIOCCBRK:	/* turn break off */
		dca->dca_cfcr &= ~CFCR_SBREAK;
		break;

	case TIOCSDTR:	/* set DTR */
		(void) dcamctl(dev, MCR_DTR | MCR_RTS, DMBIS);
		break;

	case TIOCCDTR:	/* clear DTR */
		(void) dcamctl(dev, MCR_DTR | MCR_RTS, DMBIC);
		break;

	case TIOCMSET:	/* set modem control bits */
		(void) dcamctl(dev, *(int *)data, DMSET);
		break;

	case TIOCMBIS:	/* OR bits on */
		(void) dcamctl(dev, *(int *)data, DMBIS);
		break;

	case TIOCMBIC:  /* AND bits off */
		(void) dcamctl(dev, *(int *)data, DMBIC);
		break;

	case TIOCMGET:	/* get modem bits */
		*(int *)data = dcamctl(dev, 0, DMGET);
		break;

#endif
	default:
		printf("ser%d: ioctl(,%d,,)\n", UNIT(dev), cmd);
		return (ENOTTY);
	}
#if defined(DEBUG)
	printf("ser: exiting ioctl()\n");
#endif
	return (0);
}

serparam(tp, t)
	register struct tty *tp;
	register struct termios *t;
{
	register int cflag = t->c_cflag;
	unsigned char rbits, dbits, reg4;
	int unit = UNIT(tp->t_dev);
	int ospeed = t->c_ospeed;

#if defined(DEBUG)
	printf("ser: entering serparam()\n");
#endif
 
	/* check requested parameters */
        if (ospeed < 0 || (t->c_ispeed && t->c_ispeed != t->c_ospeed)){
		printf("ser: serparam() returning EINVAL\n");
                return (EINVAL);
	}
        /* and copy to tty */
        tp->t_ispeed = t->c_ispeed;
        tp->t_ospeed = t->c_ospeed;
        tp->t_cflag = cflag;

		/* Start of serial specific param code */
	/* SER_DOCNTL(unit, 1, SER_W1_ENBTXRDY | SER_W1_ENBRXRDY); */
	/* SER_DOCNTL(unit, 0, SER_W0_ENBRXRDY); */
	if(ospeed == 0)			/* Hang up */
		SER_DOCNTL(unit, 5, 0);	/* turn RTS and DTR off */
	SER_DOCNTL(unit, 12, SERBRD(ospeed) & 0xff);
	SER_DOCNTL(unit, 13, (SERBRD(ospeed) >> 8) & 0xff);
	rbits = SER_W3_ENBRX;
	dbits = SER_W5_ENBTX;
	switch (cflag&CSIZE) {
	    case CS5:
		rbits |= SER_W3_RX5DBITS;
		dbits |= SER_W5_TX5DBITS;
		break;
	    case CS6:
		rbits |= SER_W3_RX6DBITS;
		dbits |= SER_W5_TX6DBITS;
		break;
	    case CS7:
		rbits |= SER_W3_RX7DBITS;
		dbits |= SER_W5_TX7DBITS;
		break;
	    case CS8:
		rbits |= SER_W3_RX8DBITS;
		dbits |= SER_W5_TX8DBITS;
		break;
	}
	reg4 = 0;
	if(cflag & PARENB)
		reg4 |= (cflag & PARODD) ? SER_W4_PARODD : SER_W4_PAREVEN;
	if(cflag & CSTOPB)
		reg4 |= SER_W4_2SBIT;
	else
		reg4 |= SER_W4_1SBIT;
	/* SER_DOCNTL(unit, 3, dbits); */
	/* SER_DOCNTL(unit, 5, rbits); */
	/* SER_DOCNTL(unit, 4, reg4); */
		/* End of serial specific param code */

#if defined(DEBUG)
	printf("ser: exiting serparam()\n");
#endif
	return (0);
}
 
serstart(tp)
	register struct tty *tp;
{
	register struct dcadevice *dca;
	int s, unit, c;
	int i;
 
#if defined(DEBUG)
	printf("ser: entering serstart()\n");
#endif
	unit = UNIT(tp->t_dev);
	s = spltty();
	if (tp->t_state & (TS_TIMEOUT|TS_TTSTOP))
		goto out;
	if (tp->t_outq.c_cc <= tp->t_lowat) {
		if (tp->t_state&TS_ASLEEP) {
			tp->t_state &= ~TS_ASLEEP;
			wakeup((caddr_t)&tp->t_outq);
		}
		selwakeup(&(tp->t_wsel));
	}
	if (tp->t_outq.c_cc == 0)
		goto out;
	tp->t_state |= TS_BUSY;
	if(tp->t_outq.c_cc){
		/* Really should check to see if the port is busy. */
		c = (char)getc(&tp->t_outq);
	}
	while(tp->t_outq.c_cc)
	{
		/* put characters into a buffer that serintr() will empty */
		/*  out on transmit-ready interrupts. */
		while(tp->t_outq.c_cc && ser_outlen[unit] < OUTBUFLEN){
			ser_outbuf[unit][ser_outtail[unit] + (ser_outlen[unit]++)
			    % OUTBUFLEN] = (char)getc(&tp->t_outq);
		}
	}
	tp->t_state &= ~TS_BUSY;

	SER_DOCNTL(unit, 0, 0x48);
	SCCRDWR(unit) = c;	/* to start chain */

out:
#if defined(DEBUG)
	printf("ser: exiting serstart()\n");
#endif
	splx(s);
}
 
/*
 * Stop output on a line.
 */
/*ARGSUSED*/
serstop(tp, flag)
	register struct tty *tp;
	int flag;
{
	register int s;

#if defined(DEBUG)
	printf("ser: entering serstop()\n");
#endif
	s = spltty();
	if (tp->t_state & TS_BUSY) {
		if ((tp->t_state&TS_TTSTOP)==0)
			tp->t_state |= TS_FLUSH;
	}
#if defined(DEBUG)
	printf("ser: exiting serstop()\n");
#endif
	splx(s);
}