xref: /illumos-gate/usr/src/uts/sun4u/serengeti/io/sgcn.c (revision 03831d35)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * Serengeti console driver, see sys/sgcn.h for more information
 * This driver uses the QPAIR form of STREAMS Perimeters to serialize access
 * to the read and write STREAMS queues.
 */

#include <sys/errno.h>
#include <sys/stat.h>
#include <sys/kmem.h>
#include <sys/conf.h>
#include <sys/termios.h>
#include <sys/modctl.h>
#include <sys/kbio.h>
#include <sys/stropts.h>
#include <sys/stream.h>
#include <sys/strsun.h>
#include <sys/sysmacros.h>
#include <sys/promif.h>
#include <sys/prom_plat.h>
#include <sys/sgsbbc.h>
#include <sys/sgsbbc_iosram.h>
#include <sys/sgcn.h>
#include <sys/serengeti.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/strsubr.h>

/*
 * Here we define several macros for accessing console IOSRAM
 */

#define	POINTER(base, field)	((caddr_t)&base.field)
#define	OFFSETOF(base, field)	((caddr_t)&base.field - (caddr_t)&base)

#define	RW_CONSOLE_READ		0xAAAA
#define	RW_CONSOLE_WRITE	0xBBBB

#define	CONSOLE_READ(buf, len)	sgcn_rw(RW_CONSOLE_READ, buf, len)
#define	CONSOLE_WRITE(buf, len)	sgcn_rw(RW_CONSOLE_WRITE, buf, len)

#define	SGCN_MI_IDNUM		0xABCD
#define	SGCN_MI_HIWAT		2048*2048
#define	SGCN_MI_LOWAT		128

/* dev_ops and cb_ops for device driver */
static int sgcn_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
static int sgcn_attach(dev_info_t *, ddi_attach_cmd_t);
static int sgcn_detach(dev_info_t *, ddi_detach_cmd_t);
static int sgcn_open(queue_t *, dev_t *, int, int, cred_t *);
static int sgcn_close(queue_t *, int, cred_t *);
static int sgcn_wput(queue_t *, mblk_t *);
static int sgcn_wsrv(queue_t *);
static int sgcn_rsrv(queue_t *);

/* interrupt handlers */
static void sgcn_data_in_handler(caddr_t);
static void sgcn_space_2_out_handler(caddr_t);
static void sgcn_break_handler(caddr_t);

/* other internal sgcn routines */
static void sgcn_ioctl(queue_t *, mblk_t *);
static void sgcn_reioctl(void *);
static void sgcn_start(void);
static int sgcn_transmit(queue_t *, mblk_t *);
static void sgcn_flush(void);
static int sgcn_read_header(int, cnsram_header *);
static int sgcn_rw(int, caddr_t, int);
static void sgcn_log_error(int, int);

/* circular buffer routines */
static int circular_buffer_write(int, int, int, int, caddr_t, int);
static int circular_buffer_read(int, int, int, int, caddr_t, int);

static boolean_t abort_charseq_recognize(uchar_t);
static void sg_abort_seq_handler(char *);

static	sgcn_t *sgcn_state;
static uchar_t	sgcn_stopped = FALSE;
static int	sgcn_timeout_period = 20;	/* time out in seconds */

/* streams structures */
static struct module_info minfo = {
	SGCN_MI_IDNUM,	/* mi_idnum		*/
	"sgcn",		/* mi_idname		*/
	0,		/* mi_minpsz		*/
	INFPSZ,		/* mi_maxpsz		*/
	SGCN_MI_HIWAT,	/* mi_hiwat		*/
	SGCN_MI_LOWAT	/* mi_lowat		*/
};

static struct qinit rinit = {
	putq,		/* qi_putp		*/
	sgcn_rsrv,	/* qi_srvp		*/
	sgcn_open,	/* qi_qopen		*/
	sgcn_close,	/* qi_qclose		*/
	NULL,		/* qi_qadmin		*/
	&minfo,		/* qi_minfo		*/
	NULL		/* qi_mstat		*/
};

static struct qinit winit = {
	sgcn_wput,	/* qi_putp		*/
	sgcn_wsrv,	/* qi_srvp		*/
	sgcn_open,	/* qi_qopen		*/
	sgcn_close,	/* qi_qclose		*/
	NULL,		/* qi_qadmin		*/
	&minfo,		/* qi_minfo		*/
	NULL		/* qi_mstat		*/
};

static struct streamtab sgcnstrinfo = {
	&rinit,
	&winit,
	NULL,
	NULL
};

/* standard device driver structures */
static struct cb_ops sgcn_cb_ops = {
	nulldev,		/* open()		*/
	nulldev,		/* close()		*/
	nodev,			/* strategy()		*/
	nodev,			/* print()		*/
	nodev,			/* dump()		*/
	nodev,			/* read()		*/
	nodev,			/* write()		*/
	nodev,			/* ioctl()		*/
	nodev,			/* devmap()		*/
	nodev,			/* mmap()		*/
	nodev,			/* segmap()		*/
	nochpoll,		/* poll()		*/
	ddi_prop_op,		/* prop_op()		*/
	&sgcnstrinfo,		/* cb_str		*/
	D_MP | D_MTQPAIR		/* cb_flag		*/
};

static struct dev_ops sgcn_ops = {
	DEVO_REV,
	0,			/* refcnt		*/
	sgcn_getinfo,		/* getinfo()		*/
	nulldev,		/* identify()		*/
	nulldev,		/* probe()		*/
	sgcn_attach,		/* attach()		*/
	sgcn_detach,		/* detach()		*/
	nodev,			/* reset()		*/
	&sgcn_cb_ops,		/* cb_ops		*/
	(struct bus_ops *)NULL,	/* bus_ops		*/
	NULL			/* power()		*/
};

static struct modldrv modldrv = {
	&mod_driverops,
	"Serengeti console driver v%I%",
	&sgcn_ops
};

static struct modlinkage modlinkage = {
	MODREV_1,
	(void*)&modldrv,
	NULL
};


/* driver configuration routines */
int
_init(void)
{
	int error;

	sgcn_state = kmem_zalloc(sizeof (sgcn_t), KM_SLEEP);

	error = mod_install(&modlinkage);

	if (error == 0) {
		mutex_init(&sgcn_state->sgcn_lock, NULL, MUTEX_DRIVER, NULL);
	} else {
		kmem_free(sgcn_state, sizeof (sgcn_t));
	}

	return (error);
}

int
_fini(void)
{
	/* can't remove console driver */
	return (EBUSY);
}

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}

/*
 * sgcn_attach is called at startup time.
 * There is only once instance of this driver.
 */
static int
sgcn_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	extern int ddi_create_internal_pathname(
	    dev_info_t *, char *, int, minor_t);
	cnsram_header	header;
	int		rv;

	if (cmd != DDI_ATTACH)
		return (DDI_FAILURE);

	if (ddi_create_internal_pathname(dip, "sgcn", S_IFCHR, 0)
	    != DDI_SUCCESS)
		return (DDI_FAILURE);

	/* prepare some data structures in soft state */
	mutex_enter(&sgcn_state->sgcn_lock);

	sgcn_state->sgcn_dip = dip;

	mutex_exit(&sgcn_state->sgcn_lock);

	/*
	 * We need to verify IOSRAM is intact at startup time. If by
	 * any chance IOSRAM is corrupted, that means SC is not ready.
	 * All we can do is stopping.
	 */
	rv = iosram_read(SBBC_CONSOLE_KEY, 0, (caddr_t)&header,
		sizeof (cnsram_header));
	if (rv != 0)
		cmn_err(CE_PANIC, "sgcn_attach(): Reading from IOSRAM failed");
	if (header.cnsram_magic != CNSRAM_MAGIC)
		cmn_err(CE_PANIC, "sgcn_attach(): Wrong IOSRAM console buffer");
	if (!header.cnsram_in_end && !header.cnsram_in_begin)
		cmn_err(CE_PANIC, "sgcn_attach(): Wrong IOSRAM input buffer");
	if (!header.cnsram_out_end && !header.cnsram_out_begin)
		cmn_err(CE_PANIC, "sgcn_attach(): Wrong IOSRAM output buffer");
	/*
	 * XXX need to add extra check for version no.
	 */

	/* Allocate console input buffer */
	sgcn_state->sgcn_inbuf_size =
		header.cnsram_in_end - header.cnsram_in_begin;
	sgcn_state->sgcn_inbuf =
		kmem_alloc(sgcn_state->sgcn_inbuf_size, KM_SLEEP);
#ifdef SGCN_DEBUG
	prom_printf("Allocated %d(0x%X) bytes for console\n",
		sgcn_state->sgcn_inbuf_size);
#endif

	(void) prom_serengeti_set_console_input(SGCN_CLNT_STR);

	abort_seq_handler = sg_abort_seq_handler;

#ifdef SGCN_DEBUG
	prom_printf("sgcn_attach(): SGCN driver attached\n");
#endif
	return (DDI_SUCCESS);

}

/* ARGSUSED */
static int
sgcn_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{

	if (cmd == DDI_DETACH)
		return (DDI_FAILURE);

#ifdef SGCN_DEBUG
	prom_printf("sgcn_detach(): SGCN driver detached\n");
#endif
	return (DDI_SUCCESS);
}

/* ARGSUSED */
static int
sgcn_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
	int error = DDI_FAILURE;

	switch (infocmd) {
	case DDI_INFO_DEVT2DEVINFO:
		if (sgcn_state) {
			*result = (void *) sgcn_state->sgcn_dip;
			error = DDI_SUCCESS;
		}
		break;

	case DDI_INFO_DEVT2INSTANCE:
		if (getminor((dev_t)arg) == 0) {
			*result = (void *)0;
			error = DDI_SUCCESS;
		}
		break;
	}

	return (error);
}

/* streams open & close */
/* ARGSUSED */
static int
sgcn_open(queue_t *q, dev_t *devp, int oflag, int sflag, cred_t *credp)
{
	tty_common_t	*tty;
	int		unit = getminor(*devp);

	if (unit != 0)
		return (ENXIO);

	/* stream already open */
	if (q->q_ptr) {
		return (DDI_SUCCESS);
	}

	if (!sgcn_state) {
		cmn_err(CE_WARN, "sgcn_open(): sgcn is not configured by\
				autoconfig\n");
		return (ENXIO);
	}

	mutex_enter(&sgcn_state->sgcn_lock);
	tty = &(sgcn_state->sgcn_tty);

	tty->t_readq = q;
	tty->t_writeq = WR(q);

	/* Link the RD and WR Q's */

	q->q_ptr = WR(q)->q_ptr = (caddr_t)sgcn_state;
	sgcn_state->sgcn_readq = RD(q);
	sgcn_state->sgcn_writeq = WR(q);
	qprocson(q);

	mutex_exit(&sgcn_state->sgcn_lock);

	/* initialize interrupt handler */
	iosram_reg_intr(SBBC_CONSOLE_IN,
	    (sbbc_intrfunc_t)sgcn_data_in_handler, NULL,
	    &sgcn_state->sgcn_sbbc_in_state,
	    &sgcn_state->sgcn_sbbc_in_lock);
	iosram_reg_intr(SBBC_CONSOLE_SPACE_OUT,
	    (sbbc_intrfunc_t)sgcn_space_2_out_handler, NULL,
	    &sgcn_state->sgcn_sbbc_outspace_state,
	    &sgcn_state->sgcn_sbbc_outspace_lock);
	iosram_reg_intr(SBBC_CONSOLE_BRK,
	    (sbbc_intrfunc_t)sgcn_break_handler, NULL,
	    &sgcn_state->sgcn_sbbc_brk_state,
	    &sgcn_state->sgcn_sbbc_brk_lock);

	return (DDI_SUCCESS);
}

/* ARGSUSED */
static int
sgcn_close(queue_t *q, int flag, cred_t *credp)
{
	int ret;

	ASSERT(sgcn_state == q->q_ptr);

	if (sgcn_state->sgcn_wbufcid != 0) {
		unbufcall(sgcn_state->sgcn_wbufcid);
	}

	ret = iosram_unreg_intr(SBBC_CONSOLE_BRK);
	ASSERT(ret == 0);

	ret = iosram_unreg_intr(SBBC_CONSOLE_SPACE_OUT);
	ASSERT(ret == 0);

	ret = iosram_unreg_intr(SBBC_CONSOLE_IN);
	ASSERT(ret == 0);

	ttycommon_close(&sgcn_state->sgcn_tty);

	qprocsoff(q);
	q->q_ptr = WR(q)->q_ptr = NULL;
	sgcn_state->sgcn_readq = NULL;
	sgcn_state->sgcn_writeq = NULL;

	return (DDI_SUCCESS);
}

/*
 * Put procedure for write queue.
 * Respond to M_IOCTL, M_DATA and M_FLUSH messages here;
 * It put's the data onto internal sgcn_output_q.
 */
static int
sgcn_wput(queue_t *q, mblk_t *mp)
{

#ifdef SGCN_DEBUG
	struct iocblk *iocp;
	int i;
#endif

	ASSERT(sgcn_state == q->q_ptr);

	if (!mp->b_datap) {
		cmn_err(CE_PANIC, "sgcn_wput(): null datap");
	}

#ifdef SGCN_DEBUG
	prom_printf("sgcn_wput(): SGCN wput q=%X mp=%X rd=%X wr=%X type=%X\n",
		q, mp, mp->b_rptr, mp->b_wptr, mp->b_datap->db_type);
#endif

	switch (mp->b_datap->db_type) {
	case M_IOCTL:
	case M_CTL:
#ifdef SGCN_DEBUG
		iocp = (struct iocblk *)mp->b_rptr;
		prom_printf("sgcn_wput(): M_IOCTL cmd=%X TIOC=%X\n",
			iocp->ioc_cmd, TIOC);
#endif
		switch (((struct iocblk *)mp->b_rptr)->ioc_cmd) {
		case TCSETSW:
		case TCSETSF:
		case TCSETAW:
		case TCSETAF:
		case TCSBRK:
			/*
			 * The change do not take effect until all
			 * output queued before them is drained.
			 * Put this message on the queue, so that
			 * "sgcn_start" will see it when it's done
			 * with the output before it. Poke the start
			 * routine, just in case.
			 */
			putq(q, mp);
			sgcn_start();
			break;
		default:
			sgcn_ioctl(q, mp);
		}
		break;

	case M_FLUSH:
		if (*mp->b_rptr & FLUSHW) {
			flushq(q, FLUSHDATA);
			*mp->b_rptr &= ~FLUSHW;
		}
		if (*mp->b_rptr & FLUSHR) {
			flushq(RD(q), FLUSHDATA);
			qreply(q, mp);
		} else {
			freemsg(mp);
		}
		break;

	case M_STOP:
		sgcn_stopped = TRUE;
		freemsg(mp);
		break;

	case M_START:
		sgcn_stopped = FALSE;
		freemsg(mp);
		qenable(q);	/* Start up delayed messages */
		break;

	case M_DATA:
		/*
		 * Queue the message up to be transmitted,
		 * and poke the start routine.
		 */
#ifdef SGCN_DEBUG
		if (mp->b_rptr < mp->b_wptr) {
		prom_printf("sgcn_wput(): DATA q=%X mp=%X rd=%X wr=%X\n",
			q, mp, mp->b_rptr, mp->b_wptr);
		prom_printf("sgcn_wput(): [[[[[");
		for (i = 0; i < mp->b_wptr-mp->b_rptr; i++) {
			prom_printf("%c", *(mp->b_rptr+i));
		}
		prom_printf("]]]]]\n");
		}
#endif /* SGCN_DEBUG */
		(void) putq(q, mp);
		sgcn_start();
		break;

	default:
		freemsg(mp);
	}

	return (0);
}

/*
 * Process an "ioctl" message sent down to us.
 */
static void
sgcn_ioctl(queue_t *q, mblk_t *mp)
{
	struct iocblk	*iocp;
	tty_common_t	*tty;
	mblk_t		*datamp;
	int		data_size;
	int		error = 0;

#ifdef SGCN_DEBUG
	prom_printf("sgcn_ioctl(): q=%X mp=%X\n", q, mp);
#endif
	iocp = (struct iocblk *)mp->b_rptr;
	tty = &(sgcn_state->sgcn_tty);

	if (tty->t_iocpending != NULL) {
		freemsg(tty->t_iocpending);
		tty->t_iocpending = NULL;
	}
	data_size = ttycommon_ioctl(tty, q, mp, &error);
	if (data_size != 0) {
		if (sgcn_state->sgcn_wbufcid)
			unbufcall(sgcn_state->sgcn_wbufcid);
		/* call sgcn_reioctl() */
		sgcn_state->sgcn_wbufcid =
			bufcall(data_size, BPRI_HI, sgcn_reioctl, sgcn_state);
		return;
	}

	if (error < 0) {
		iocp = (struct iocblk *)mp->b_rptr;
		/*
		 * "ttycommon_ioctl" didn't do anything; we process it here.
		 */
		error = 0;
		switch (iocp->ioc_cmd) {
		case TCSBRK:
		case TIOCSBRK:
		case TIOCCBRK:
		case TIOCMSET:
		case TIOCMBIS:
		case TIOCMBIC:
			if (iocp->ioc_count != TRANSPARENT)
				mioc2ack(mp, NULL, 0, 0);
			else
				mcopyin(mp, NULL, sizeof (int), NULL);
			break;

		case TIOCMGET:
			datamp = allocb(sizeof (int), BPRI_MED);
			if (datamp == NULL) {
				error = EAGAIN;
				break;
			}

			*(int *)datamp->b_rptr = 0;

			if (iocp->ioc_count != TRANSPARENT)
				mioc2ack(mp, datamp, sizeof (int), 0);
			else
				mcopyout(mp, NULL, sizeof (int), NULL, datamp);
			break;

		default:
			error = EINVAL;
			break;
		}
	}
	if (error != 0) {
		iocp->ioc_count = 0;
		iocp->ioc_error = error;
		mp->b_datap->db_type = M_IOCNAK;
	}
	qreply(q, mp);
}

static void
sgcn_reioctl(void *unit)
{
	queue_t		*q;
	mblk_t		*mp;
	sgcn_t		*sgcnp = (sgcn_t *)unit;

	if (!sgcnp->sgcn_wbufcid) {
		return;
	}
	sgcnp->sgcn_wbufcid = 0;
	if ((q = sgcnp->sgcn_tty.t_writeq) == NULL) {
		return;
	}

	if ((mp = sgcnp->sgcn_tty.t_iocpending) != NULL) {
		sgcnp->sgcn_tty.t_iocpending = NULL;
		sgcn_ioctl(q, mp);
	}
}

static void
sgcn_start()
{

	queue_t *q;
	mblk_t *mp;
	int retval;

	/*
	 * read stream queue and remove data from the queue and
	 * transmit them if possible
	 */
	q = sgcn_state->sgcn_writeq;
	ASSERT(q != NULL);
	while (mp = getq(q)) {
		switch (mp->b_datap->db_type) {
		case M_IOCTL:
			/*
			 * These are those IOCTLs queued up
			 * do it now
			 */
			sgcn_ioctl(q, mp);
			continue;
		default:
			/*
			 * M_DATA
			 * Copy it from stream queue buffer to
			 * sgcn buffer
			 */
			retval = sgcn_transmit(q, mp);

			if (retval == EBUSY) {
				/*
				 * Console output buffer is full for
				 * sgcn_timeout_period seconds, assume
				 * SC is dead, drop all console output
				 * data from stream queue.
				 */
				if (sgcn_state->sgcn_sc_active <
				    gethrestime_sec() - sgcn_timeout_period)
					sgcn_flush();
				return;
			} else if (retval == EAGAIN) {
				/*
				 * Console output just became full
				 * return
				 */
				mutex_enter(&sgcn_state->sgcn_lock);
				sgcn_state->sgcn_sc_active = gethrestime_sec();
				mutex_exit(&sgcn_state->sgcn_lock);
				return;
			} else {
				/* send more console output */
				mutex_enter(&sgcn_state->sgcn_lock);
				sgcn_state->sgcn_sc_active = gethrestime_sec();
				mutex_exit(&sgcn_state->sgcn_lock);
			}
		} /* switch */
	}

}

static int
sgcn_transmit(queue_t *q, mblk_t *mp)
{
	caddr_t		buf;
	mblk_t		*bp;
	int		len, oldlen;

#ifdef SGCN_DEBUG
	prom_printf("sgcn_transmit(): q=%X mp=%X\n", q, mp);
#endif
	do {
		bp = mp;
		oldlen = len = bp->b_wptr - bp->b_rptr;
		buf = (caddr_t)bp->b_rptr;
		len = CONSOLE_WRITE(buf, len);
		if (len > 0)
			iosram_send_intr(SBBC_CONSOLE_OUT);
		if (len >= 0 && len < oldlen) {
			/* IOSRAM is full, we are not done with mp yet */
			bp->b_rptr += len;
			(void) putbq(q, mp);
			if (len)
				return (EAGAIN);
			else
				return (EBUSY);
		}
		mp = bp->b_cont;
		freeb(bp);
	} while (mp);

	return (0);
}

/*
 * called when SC first establishes console connection
 * drop all the data on the output queue
 */
static void
sgcn_flush()
{
	queue_t *q;
	mblk_t *mp;

	q = sgcn_state->sgcn_writeq;

	prom_printf("sgcn_flush(): WARNING console output is dropped "
		"time=%lX\n", gethrestime_sec());
	while (mp = getq(q)) {
		freemsg(mp);
	}

}

uint64_t sgcn_input_dropped;

/*
 * Interrupt handlers
 * All handlers register with SBBC driver and must follow SBBC interrupt
 * delivery conventions.
 */
/*
 * SC sends an interrupt when new data comes in
 */
/* ARGSUSED */
void
sgcn_data_in_handler(caddr_t arg)
{
	caddr_t		buf = sgcn_state->sgcn_inbuf;
	int		i, len;
	mblk_t		*mp;

	/*
	 * change interrupt state so that SBBC won't trigger
	 * another one.
	 */
	mutex_enter(&sgcn_state->sgcn_sbbc_in_lock);
	sgcn_state->sgcn_sbbc_in_state = SBBC_INTR_RUNNING;
	mutex_exit(&sgcn_state->sgcn_sbbc_in_lock);

	/* update sgcn_state for SC activity information */
	mutex_enter(&sgcn_state->sgcn_lock);
	sgcn_state->sgcn_sc_active = gethrestime_sec();
	mutex_exit(&sgcn_state->sgcn_lock);

	/* enter our perimeter */
	entersq(sgcn_state->sgcn_readq->q_syncq, SQ_CALLBACK);

	for (;;) {

		/* read from console input IOSRAM */
		len = CONSOLE_READ(buf, sgcn_state->sgcn_inbuf_size);

		if (len <= 0) {

			mutex_enter(&sgcn_state->sgcn_sbbc_in_lock);

			len = CONSOLE_READ(buf, sgcn_state->sgcn_inbuf_size);

			if (len <= 0) {
				sgcn_state->sgcn_sbbc_in_state = SBBC_INTR_IDLE;
				mutex_exit(&sgcn_state->sgcn_sbbc_in_lock);

				/* leave our perimeter */
				leavesq(sgcn_state->sgcn_readq->q_syncq,
					SQ_CALLBACK);
				return;
			} else {
				mutex_exit(&sgcn_state->sgcn_sbbc_in_lock);
			}

		}

		iosram_send_intr(SBBC_CONSOLE_SPACE_IN);

		if (abort_enable == KIOCABORTALTERNATE) {
			for (i = 0; i < len; i ++) {
				if (abort_charseq_recognize(buf[i]))
					abort_sequence_enter((char *)NULL);
			}
		}

		/* put console input onto stream */
		if (sgcn_state->sgcn_readq) {
			if ((mp = allocb(len, BPRI_MED)) == (mblk_t *)NULL) {
				sgcn_input_dropped += len;
				cmn_err(CE_WARN,
				    "sgcn_data_in_handler(): allocb failed"
				    " (console input dropped.)");
			} else {
				bcopy(buf, mp->b_wptr, len);
				mp->b_wptr += len;
				putnext(sgcn_state->sgcn_readq, mp);
			}
		}
	}

}

/*
 * SC sends an interrupt when it takes output data
 * from a full IOSRAM
 */
/* ARGSUSED */
void
sgcn_space_2_out_handler(caddr_t arg)
{
	/*
	 * change interrupt state so that SBBC won't trigger
	 * another one.
	 */
	mutex_enter(&sgcn_state->sgcn_sbbc_outspace_lock);
	sgcn_state->sgcn_sbbc_outspace_state = SBBC_INTR_RUNNING;
	mutex_exit(&sgcn_state->sgcn_sbbc_outspace_lock);

	mutex_enter(&sgcn_state->sgcn_lock);
	sgcn_state->sgcn_sc_active = gethrestime_sec();
	mutex_exit(&sgcn_state->sgcn_lock);

	if (sgcn_state->sgcn_writeq != NULL)
		qenable(sgcn_state->sgcn_writeq);

	/* restore interrupt state */
	mutex_enter(&sgcn_state->sgcn_sbbc_outspace_lock);
	sgcn_state->sgcn_sbbc_outspace_state = SBBC_INTR_IDLE;
	mutex_exit(&sgcn_state->sgcn_sbbc_outspace_lock);
}

/*
 * SC sends an interrupt when it detects BREAK sequence
 */
/* ARGSUSED */
void
sgcn_break_handler(caddr_t arg)
{
	/*
	 * change interrupt state so that SBBC won't trigger
	 * another one.
	 */
	mutex_enter(&sgcn_state->sgcn_sbbc_brk_lock);
	sgcn_state->sgcn_sbbc_brk_state = SBBC_INTR_RUNNING;
	mutex_exit(&sgcn_state->sgcn_sbbc_brk_lock);

	if (abort_enable != KIOCABORTALTERNATE)
		abort_sequence_enter((char *)NULL);

	/* restore interrupt state */
	mutex_enter(&sgcn_state->sgcn_sbbc_brk_lock);
	sgcn_state->sgcn_sbbc_brk_state = SBBC_INTR_IDLE;
	mutex_exit(&sgcn_state->sgcn_sbbc_brk_lock);
}

/*
 * reporting errors in console driver sgcn.
 * since we can not trust console driver at this time, we need to
 * log errors in other system logs
 * error codes:
 *	EIO - iosram interface failed
 *	EPROTO - IOSRAM is corrupted
 *	EINVAL - invalid argument
 */
#define	SGCN_MAX_ERROR		100
static void
sgcn_log_error(int when, int what)
{
	char error_msg[256], error_code[256];
	static uint_t	error_counter = 0;

	error_counter ++;

	if (error_counter > SGCN_MAX_ERROR) {
		error_counter = 0;
		strcpy(error_msg, "!Too many sgcn errors");
	} else {
		(void) sprintf(error_code, "Error %d", what);

		(void) sprintf(error_msg, "!%s at %s",
		    (what == EIO) ? "IOSRAM interface failed" :
		    (what == EPROTO) ? "IOSRAM corrupted" :
		    (what == EINVAL) ? "Invalid argument" :
		    error_code,
		    (when == RW_CONSOLE_READ) ? "console input" :
		    (when == RW_CONSOLE_WRITE) ? "console output, dropped" :
		    "console I/O");
	}

	cmn_err(CE_WARN, error_msg);
}

static int
sgcn_read_header(int rw, cnsram_header *header)
{
	int	rv;

	/* check IOSRAM contents and read pointers */
	rv = iosram_read(SBBC_CONSOLE_KEY, 0, (caddr_t)header,
		sizeof (cnsram_header));
	if (rv != 0) {
		return (-1);
	}

	/*
	 * Since the header is read in a byte-by-byte fashion
	 * using ddi_rep_get8, we need to re-read the producer
	 * or consumer pointer as integer in case it has changed
	 * after part of the previous value has been read.
	 */
	if (rw == RW_CONSOLE_READ) {
		rv = iosram_read(SBBC_CONSOLE_KEY,
			OFFSETOF((*header), cnsram_in_wrptr),
			POINTER((*header), cnsram_in_wrptr),
			sizeof (header->cnsram_in_wrptr));
	} else if (rw == RW_CONSOLE_WRITE) {
		rv = iosram_read(SBBC_CONSOLE_KEY,
			OFFSETOF((*header), cnsram_out_rdptr),
			POINTER((*header), cnsram_out_rdptr),
			sizeof (header->cnsram_out_rdptr));
	} else
		rv = -1;

	return (rv);
}

static int
sgcn_rw(int rw, caddr_t buf, int len)
{
	cnsram_header	header;
	int		rv, size, nbytes;

#ifdef SGCN_DEBUG
	prom_printf("sgcn_rw() rw = %X buf = %p len = %d\n",
		rw, buf, len);
#endif /* SGCN_DEBUG */
	if (len == 0)
		return (0);

	/* sanity check */
	if (buf == NULL || len < 0) {
		sgcn_log_error(rw, EINVAL);
		return (-1);
	}

	/* check IOSRAM contents and read pointers */
	rv = sgcn_read_header(rw, &header);
	if (rv != 0) {
		sgcn_log_error(rw, EIO);
		return (-1);
	}
	if (header.cnsram_magic != CNSRAM_MAGIC) {
		sgcn_log_error(rw, EPROTO);
		return (-1);
	}

	if (rw == RW_CONSOLE_READ)
		size = header.cnsram_in_end - header.cnsram_in_begin;
	else if (rw == RW_CONSOLE_WRITE)
		size = header.cnsram_out_end - header.cnsram_out_begin;
	if (size < 0) {
		sgcn_log_error(rw, EPROTO);
		return (-1);
	}

	if (rw == RW_CONSOLE_READ)
		nbytes = circular_buffer_read(
			header.cnsram_in_begin,
				header.cnsram_in_end,
				header.cnsram_in_rdptr,
				header.cnsram_in_wrptr, buf, len);
	else if (rw == RW_CONSOLE_WRITE)
		nbytes = circular_buffer_write(
			header.cnsram_out_begin,
				header.cnsram_out_end,
				header.cnsram_out_rdptr,
				header.cnsram_out_wrptr, buf, len);

	/*
	 * error log was done in circular buffer routines,
	 * no need to call sgcn_log_error() here
	 */
	if (nbytes < 0)
		return (-1);

	if (nbytes == 0)
		return (0);

	if (rw == RW_CONSOLE_READ) {
		header.cnsram_in_rdptr =
		    (header.cnsram_in_rdptr - header.cnsram_in_begin
			+ nbytes)
		    % size + header.cnsram_in_begin;
		rv = iosram_write(SBBC_CONSOLE_KEY,
			OFFSETOF(header, cnsram_in_rdptr),
			POINTER(header, cnsram_in_rdptr),
			sizeof (header.cnsram_in_rdptr));
	} else if (rw == RW_CONSOLE_WRITE) {
		header.cnsram_out_wrptr =
		    (header.cnsram_out_wrptr - header.cnsram_out_begin
			+ nbytes)
		    % size + header.cnsram_out_begin;
		rv = iosram_write(SBBC_CONSOLE_KEY,
			OFFSETOF(header, cnsram_out_wrptr),
			POINTER(header, cnsram_out_wrptr),
			sizeof (header.cnsram_out_wrptr));
	}
	if (rv != 0) {
		sgcn_log_error(rw, EIO);
		return (-1);
	}

	return (nbytes);
}

/*
 * Circular buffer interfaces
 *
 * See sgcn.h for circular buffer structure
 *
 * The circular buffer is empty when read ptr == write ptr
 * and is full when read ptr is one ahead of write ptr
 */
/*
 * Write to circular buffer in IOSRAM
 * input:
 *	buf	buffer in main memory, contains data to be written
 *	len	length of data in bytes
 *	begin, end, rd, wr	buffer pointers
 * return value:
 *	actual bytes written.
 */
static int
circular_buffer_write(int begin, int end, int rd, int wr, caddr_t buf, int len)
{
	int		size, space, space_at_end;
	int		rv = 0;

	size = end - begin;
	if (size <= 0) {
		rv = EINVAL;
		goto out;
	}

	if ((len = ((len >= size) ? (size-1) : len)) == 0)
		return (0);	/* The buffer's full, so just return 0 now. */

	space = (rd - wr + size - 1) % size;
	len = min(len, space);
	space_at_end = end - wr;

	if (rd > wr || rd <= wr && space_at_end >= len) { /* one piece */
		/* write console data */
		rv = iosram_write(SBBC_CONSOLE_KEY, wr, buf, len);
		if (rv != 0) goto out;
	} else { /* break into two pieces because of circular buffer */
		/* write console data */
		if (space_at_end) {
			rv = iosram_write(SBBC_CONSOLE_KEY,
			    wr, buf, space_at_end);
			if (rv != 0) goto out;
		}
		if (len - space_at_end) {
			rv = iosram_write(SBBC_CONSOLE_KEY,
			    begin, buf+space_at_end, len-space_at_end);
			if (rv != 0) goto out;
		}
	}
	return (len);
out:
	sgcn_log_error(RW_CONSOLE_WRITE, rv);
	return (-1);
}

/*
 * Read from circular buffer in IOSRAM
 * input:
 *	buf	preallocated buffer in memory
 *	len	size of buf
 *	begin, end, rd, wr	buffer pointers
 * return value:
 *	actual bytes read
 */
/* ARGSUSED */
static int
circular_buffer_read(int begin, int end, int rd, int wr, caddr_t buf, int len)
{
	int		size, nbytes, nbytes_at_end;
	int		rv = 0;

	size = end - begin;
	if (size <= 0) {
		rv = EINVAL;
		goto out;
	}
	nbytes = (wr - rd + size) % size;

	nbytes = min(nbytes, len);

	if (wr > rd) { /* one piece */
		rv = iosram_read(SBBC_CONSOLE_KEY, rd, buf, nbytes);
		if (rv != 0) goto out;
	} else { /* break into two pieces because of circular buffer */
		nbytes_at_end = min(nbytes, end - rd);
		/* read console data */
		if (nbytes_at_end) {
			rv = iosram_read(SBBC_CONSOLE_KEY,
			    rd, buf, nbytes_at_end);
			if (rv != 0) goto out;
		}
		if (nbytes-nbytes_at_end) {
			rv = iosram_read(SBBC_CONSOLE_KEY,
			    begin, buf+nbytes_at_end, nbytes-nbytes_at_end);
			if (rv != 0) goto out;
		}
	}
	return (nbytes);
out:
	sgcn_log_error(RW_CONSOLE_READ, rv);
	return (-1);
}

/*
 * Check for abort character sequence, copied from zs_async.c
 */
#define	CNTRL(c) ((c)&037)

static boolean_t
abort_charseq_recognize(uchar_t ch)
{
	static int state = 0;
	static char sequence[] = { '\r', '~', CNTRL('b') };

	if (ch == sequence[state]) {
		if (++state >= sizeof (sequence)) {
			state = 0;
			return (B_TRUE);
		}
	} else {
		state = (ch == sequence[0]) ? 1 : 0;
	}
	return (B_FALSE);
}

static void
sg_abort_seq_handler(char *msg)
{
	char	key_switch;
	int	rv;

	/* read virtual keyswitch position from IOSRAM */
	rv = iosram_read(SBBC_KEYSWITCH_KEY, 0, &key_switch, 1);
	if (rv != 0) {
		/* default to not secure if read failed */
		cmn_err(CE_NOTE, "!Read keyswitch failed (%d)", rv);
		key_switch = 0;
	}
	if (key_switch & SG_KEYSWITCH_POSN_SECURE) {
		cmn_err(CE_NOTE, "!Keyswitch is in secure mode");
	} else {
		debug_enter(msg);
	}
}

static int
sgcn_rsrv(queue_t *q)
{
	mblk_t	*mp;

	if (sgcn_stopped == TRUE) {
		return (0);
	}

	mutex_enter(&sgcn_state->sgcn_lock);
	sgcn_state->sgcn_sc_active = gethrestime_sec();
	mutex_exit(&sgcn_state->sgcn_lock);

	while ((mp = getq(q)) != NULL) {
		if (canputnext(q)) {
			putnext(q, mp);
		} else if (mp->b_datap->db_type >= QPCTL) {
			putbq(q, mp);
		}
	}

	return (0);
}

/* ARGSUSED */
static int
sgcn_wsrv(queue_t *q)
{
	if (sgcn_stopped == TRUE)
		return (0);

	mutex_enter(&sgcn_state->sgcn_lock);
	sgcn_state->sgcn_sc_active = gethrestime_sec();
	mutex_exit(&sgcn_state->sgcn_lock);

	if (sgcn_state->sgcn_writeq != NULL)
		sgcn_start();

	return (0);
}