microwatt/verilator/uart-verilator.c

#include <signal.h>
#include <poll.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <termios.h>
#include <stdlib.h>

/* Should we exit simulation on ctrl-c or pass it through? */
#define EXIT_ON_CTRL_C

#define BAUD 115200
/* Round to nearest */
#define BITWIDTH ((CLK_FREQUENCY+(BAUD/2))/BAUD)

/*
 * Our UART uses 16x oversampling, so at 50 MHz and 115200 baud
 * each sample is: 50000000/(115200*16) = 27 clock cycles. This
 * means each bit is off by 0.47% so for 8 bits plus a start and
 * stop bit the errors add to be 4.7%.
 */
static double error = 0.05;

enum state {
	IDLE, START_BIT, BITS, STOP_BIT, ERROR
};

static enum state tx_state = IDLE;
static unsigned long tx_countbits;
static unsigned char tx_bits;
static unsigned char tx_byte;
static unsigned char tx_prev;

/*
 * Return an error if the transition is not close enough to the start or
 * the end of an expected bit.
 */
static bool is_error(unsigned long bits)
{
	double e = 1.0 * tx_countbits / BITWIDTH;

	if ((e <= (1.0-error)) && (e >= error))
		return true;

	return false;
}

void uart_tx(unsigned char tx)
{
	switch (tx_state) {
		case IDLE:
			if (tx == 0) {
				tx_state = START_BIT;
				tx_countbits = BITWIDTH;
				tx_bits = 0;
				tx_byte = 0;
			}
			break;

		case START_BIT:
			tx_countbits--;
			if (tx == 1) {
				if (is_error(tx_countbits)) {
					printf("START_BIT error %ld %ld\n", BITWIDTH, tx_countbits);
					tx_countbits = BITWIDTH*2;
					tx_state = ERROR;
					break;
				}
			}

			if (tx_countbits == 0) {
				tx_state = BITS;
				tx_countbits = BITWIDTH;
			}
			break;

		case BITS:
			tx_countbits--;
			if (tx_countbits == BITWIDTH/2) {
				tx_byte = tx_byte | (tx << tx_bits);
				tx_bits = tx_bits + 1;
			}

			if (tx != tx_prev) {
				if (is_error(tx_countbits)) {
					printf("BITS error %ld %ld\n", BITWIDTH, tx_countbits);
					tx_countbits = BITWIDTH*2;
					tx_state = ERROR;
					break;
				}
			}

			if (tx_countbits == 0) {
				if (tx_bits == 8) {
					tx_state = STOP_BIT;
				}
				tx_countbits = BITWIDTH;
			}
			break;

		case STOP_BIT:
			tx_countbits--;

			if (tx == 0) {
				if (is_error(tx_countbits)) {
					printf("STOP_BIT error %ld %ld\n", BITWIDTH, tx_countbits);
					tx_countbits = BITWIDTH*2;
					tx_state = ERROR;
					break;
				}
				/* Go straight to idle */
				write(STDOUT_FILENO, &tx_byte, 1);
				tx_state = IDLE;
			}

			if (tx_countbits == 0) {
				write(STDOUT_FILENO, &tx_byte, 1);
				tx_state = IDLE;
			}
			break;

		case ERROR:
			tx_countbits--;
			if (tx_countbits == 0) {
				tx_state = IDLE;
			}

			break;
	}

	tx_prev = tx;
}

static struct termios oldt;

static void disable_raw_mode(void)
{
	tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
}

static void enable_raw_mode(void)
{
	static bool initialized = false;

	if (!initialized) {
		static struct termios newt;

		tcgetattr(STDIN_FILENO, &oldt);
		newt = oldt;
		cfmakeraw(&newt);
#ifdef EXIT_ON_CTRL_C
		newt.c_lflag |= ISIG;
#endif
		tcsetattr(STDIN_FILENO, TCSANOW, &newt);
		initialized = true;
		atexit(disable_raw_mode);
	}
}

static int nonblocking_read(unsigned char *c)
{
	int ret;
	unsigned long val = 0;
	struct pollfd fdset[1];

	enable_raw_mode();

	memset(fdset, 0, sizeof(fdset));

	fdset[0].fd = STDIN_FILENO;
	fdset[0].events = POLLIN;

	ret = poll(fdset, 1, 0);
	if (ret == 0)
		return false;

	ret = read(STDIN_FILENO, &val, 1);
	if (ret != 1) {
		fprintf(stderr, "%s: read of stdin returns %d\n", __func__, ret);
		exit(1);
	}

	if (ret == 1) {
		*c = val;
		return true;
	} else {
		return false;
	}
}

static enum state rx_state = IDLE;
static unsigned char rx_char;
static unsigned long rx_countbits;
static unsigned char rx_bit;
static unsigned char rx = 1;

/* Avoid calling poll() too much */
#define RX_INTERVAL 10000
static unsigned long rx_sometimes;

unsigned char uart_rx(void)
{
	unsigned char c;

	switch (rx_state) {
		case IDLE:
			if (rx_sometimes++ >= RX_INTERVAL) {
				rx_sometimes = 0;

				if (nonblocking_read(&c)) {
					rx_state = START_BIT;
					rx_char = c;
					rx_countbits = BITWIDTH;
					rx_bit = 0;
					rx = 0;
				}
			}

			break;

		case START_BIT:
			rx_countbits--;
			if (rx_countbits == 0) {
				rx_state = BITS;
				rx_countbits = BITWIDTH;
				rx = rx_char & 1;
			}
			break;

		case BITS:
			rx_countbits--;
			if (rx_countbits == 0) {
				rx_bit = rx_bit + 1;
				if (rx_bit == 8) {
					rx = 1;
					rx_state = STOP_BIT;
				} else {
					rx = (rx_char >> rx_bit) & 1;
				}
				rx_countbits = BITWIDTH;
			}
			break;

		case STOP_BIT:
			rx_countbits--;
			if (rx_countbits == 0) {
				rx_state = IDLE;
			}
			break;
	}

	return rx;
}