/*
 * Copyright (c) 2000, 2001, 2002, 2003, 2004, 2005, 2008, 2009
 *	The President and Fellows of Harvard College.
 *
 * 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. 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 UNIVERSITY 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 UNIVERSITY 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.
 */

/*
 * Machine (and hardware) independent console driver.
 *
 * We expose a simple interface to the rest of the kernel: "putch" to
 * print a character, "getch" to read one.
 *
 * As long as the device we're connected to does, we allow printing in
 * an interrupt handler or with interrupts off (by polling),
 * transparently to the caller. Note that getch by polling is not
 * supported, although such support could be added without undue
 * difficulty.
 *
 * Note that nothing happens until we have a device to write to. A
 * buffer of size DELAYBUFSIZE is used to hold output that is
 * generated before this point. This means that (1) using kprintf for
 * debugging problems that occur early in initialization is awkward,
 * and (2) if the system crashes before we find a console, no output
 * at all may appear.
 *
 * Note that we have no input buffering; characters typed too rapidly
 * will be lost.
 */

#include <types.h>
#include <kern/errno.h>
#include <lib.h>
#include <uio.h>
#include <thread.h>
#include <current.h>
#include <synch.h>
#include <generic/console.h>
#include <vfs.h>
#include <device.h>
#include "autoconf.h"

/*
 * The console device.
 */
static struct con_softc *the_console = NULL;

/*
 * Lock so user I/Os are atomic.
 * We use two locks so readers waiting for input don't lock out writers.
 */
static struct lock *con_userlock_read = NULL;
static struct lock *con_userlock_write = NULL;

//////////////////////////////////////////////////

/*
 * This is for accumulating characters printed before the
 * console is set up. Upon console setup they are dumped 
 * to the actual console; thenceforth this space is unused.
 */
#define DELAYBUFSIZE  1024
static char delayed_outbuf[DELAYBUFSIZE];
static size_t delayed_outbuf_pos=0;

static
void
putch_delayed(int ch)
{
	/*
	 * No synchronization needed: called only during system startup
	 * by main thread.
	 */

	KASSERT(delayed_outbuf_pos < sizeof(delayed_outbuf));
	delayed_outbuf[delayed_outbuf_pos++] = ch;
}

static
void
flush_delay_buf(void)
{
	size_t i;
	for (i=0; i<delayed_outbuf_pos; i++) {
		putch(delayed_outbuf[i]);
	}
	delayed_outbuf_pos = 0;
}

//////////////////////////////////////////////////

/*
 * Print a character, using polling instead of interrupts to wait for
 * I/O completion.
 */
static
void
putch_polled(struct con_softc *cs, int ch)
{
	cs->cs_sendpolled(cs->cs_devdata, ch);
}

static
void
putch_prepare_polled(struct con_softc *cs)
{
	if (cs->cs_startpolling != NULL) {
		cs->cs_startpolling(cs->cs_devdata);
	}
}

static
void
putch_complete_polled(struct con_softc *cs)
{
	if (cs->cs_endpolling != NULL) {
		cs->cs_endpolling(cs->cs_devdata);
	}
}

//////////////////////////////////////////////////

/*
 * Print a character, using interrupts to wait for I/O completion.
 */
static
void
putch_intr(struct con_softc *cs, int ch)
{
	P(cs->cs_wsem);
	cs->cs_send(cs->cs_devdata, ch);
}

/*
 * Read a character, using interrupts to wait for I/O completion.
 */
static
int
getch_intr(struct con_softc *cs)
{
	unsigned char ret;

	P(cs->cs_rsem);
	ret = cs->cs_gotchars[cs->cs_gotchars_tail];
	cs->cs_gotchars_tail =
		(cs->cs_gotchars_tail + 1) % CONSOLE_INPUT_BUFFER_SIZE;
	return ret;
}

/*
 * Called from underlying device when a read-ready interrupt occurs.
 *
 * Note: if gotchars_head == gotchars_tail, the buffer is empty. Thus
 * if gotchars_head+1 == gotchars_tail, the buffer is full. A slightly
 * tidier way to implement this check (that avoids wasting a slot,
 * too) would be with a second semaphore used with a nonblocking P,
 * but we don't have that in OS/161.
 */
void
con_input(void *vcs, int ch)
{
	struct con_softc *cs = vcs;
	unsigned nexthead;

	nexthead = (cs->cs_gotchars_head + 1) % CONSOLE_INPUT_BUFFER_SIZE;
	if (nexthead == cs->cs_gotchars_tail) {
		/* overflow; drop character */
		return;
	}

	cs->cs_gotchars[cs->cs_gotchars_head] = ch;
	cs->cs_gotchars_head = nexthead;
		
	V(cs->cs_rsem);
}

/*
 * Called from underlying device when a write-done interrupt occurs.
 */
void
con_start(void *vcs)
{
	struct con_softc *cs = vcs;

	V(cs->cs_wsem);
}

//////////////////////////////////////////////////

/*
 * Exported interface.
 * 
 * Warning: putch must work even in an interrupt handler or with
 * interrupts disabled, and before the console is probed. getch need
 * not, and does not.
 */

void
putch(int ch)
{
	struct con_softc *cs = the_console;

	if (cs==NULL) {
		putch_delayed(ch);
	}
	else if (curthread->t_in_interrupt || curthread->t_iplhigh_count > 0) {
		putch_polled(cs, ch);
	}
	else {
		putch_intr(cs, ch);
	}
}

void
putch_prepare(void)
{
	struct con_softc *cs = the_console;

	if (cs == NULL) {
		/* nothing */
	}
	else if (curthread->t_in_interrupt || curthread->t_iplhigh_count > 0) {
		putch_prepare_polled(cs);
	}
	else {
		/* nothing */
	}
}

void
putch_complete(void)
{
	struct con_softc *cs = the_console;

	if (cs == NULL) {
		/* nothing */
	}
	else if (curthread->t_in_interrupt || curthread->t_iplhigh_count > 0) {
		putch_complete_polled(cs);
	}
	else {
		/* nothing */
	}
}

int
getch(void)
{
	struct con_softc *cs = the_console;
	KASSERT(cs != NULL);
	KASSERT(!curthread->t_in_interrupt && curthread->t_iplhigh_count == 0);

	return getch_intr(cs);
}

////////////////////////////////////////////////////////////

/*
 * VFS interface functions
 */

static
int
con_open(struct device *dev, int openflags)
{
	(void)dev;
	(void)openflags;
	return 0;
}

static
int
con_close(struct device *dev)
{
	(void)dev;
	return 0;
}

static
int
con_io(struct device *dev, struct uio *uio)
{
	int result;
	char ch;
	struct lock *lk;

	(void)dev;  // unused

	if (uio->uio_rw==UIO_READ) {
		lk = con_userlock_read;
	}
	else {
		lk = con_userlock_write;
	}

	KASSERT(lk != NULL);
	lock_acquire(lk);

	while (uio->uio_resid > 0) {
		if (uio->uio_rw==UIO_READ) {
			ch = getch();
			if (ch=='\r') {
				ch = '\n';
			}
			result = uiomove(&ch, 1, uio);
			if (result) {
				lock_release(lk);
				return result;
			}
			if (ch=='\n') {
				break;
			}
		}
		else {
			result = uiomove(&ch, 1, uio);
			if (result) {
				lock_release(lk);
				return result;
			}
			if (ch=='\n') {
				putch('\r');
			}
			putch(ch);
		}
	}
	lock_release(lk);
	return 0;
}

static
int
con_ioctl(struct device *dev, int op, userptr_t data)
{
	/* No ioctls. */
	(void)dev;
	(void)op;
	(void)data;
	return EINVAL;
}

static
int
attach_console_to_vfs(struct con_softc *cs)
{
	struct device *dev;
	int result;

	dev = kmalloc(sizeof(*dev));
	if (dev==NULL) {
		return ENOMEM;
	}

	dev->d_open = con_open;
	dev->d_close = con_close;
	dev->d_io = con_io;
	dev->d_ioctl = con_ioctl;
	dev->d_blocks = 0;
	dev->d_blocksize = 1;
	dev->d_data = cs;

	result = vfs_adddev("con", dev, 0);
	if (result) {
		kfree(dev);
		return result;
	}

	return 0;
}

////////////////////////////////////////////////////////////

/*
 * Config routine called by autoconf.c after we are attached to something.
 */

int
config_con(struct con_softc *cs, int unit)
{
	struct semaphore *rsem, *wsem;
	struct lock *rlk, *wlk;

	/*
	 * Only allow one system console.
	 * Further devices that could be the system console are ignored.
	 *
	 * Do not hardwire the console to be "con1" instead of "con0",
	 * or these asserts will go off.
	 */
	if (unit>0) {
		KASSERT(the_console!=NULL);
		return ENODEV;
	}
	KASSERT(the_console==NULL);

	rsem = sem_create("console read", 0);
	if (rsem == NULL) {
		return ENOMEM;
	}
	wsem = sem_create("console write", 1);
	if (wsem == NULL) {
		sem_destroy(rsem);
		return ENOMEM;
	}
	rlk = lock_create("console-lock-read");
	if (rlk == NULL) {
		sem_destroy(rsem);
		sem_destroy(wsem);
		return ENOMEM;
	}
	wlk = lock_create("console-lock-write");
	if (wlk == NULL) {
		lock_destroy(rlk);
		sem_destroy(rsem);
		sem_destroy(wsem);
		return ENOMEM;
	}

	cs->cs_rsem = rsem; 
	cs->cs_wsem = wsem; 
	cs->cs_gotchars_head = 0;
	cs->cs_gotchars_tail = 0;

	the_console = cs;
	con_userlock_read = rlk;
	con_userlock_write = wlk;

	flush_delay_buf();

	return attach_console_to_vfs(cs);
}