[z180-stamp.git] / avr / serial.c

/*
 * (C) Copyright 2014 Leo C. <erbl259-lmu@yahoo.de>
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/atomic.h>
#include <errno.h>
#include <stdio.h>

#include "ring.h"
#include "serial.h"


static int _write(char c, FILE *stream);
static FILE mystdout = FDEV_SETUP_STREAM(_write,
		NULL, _FDEV_SETUP_WRITE);


#define BUFFER_SIZE 128

#if ((BUFFER_SIZE-1) & BUFFER_SIZE)
# error: BUFFER_SIZE not power of 2
#endif

#if ((BUFFER_SIZE) > 256)
# error: BUFFER_SIZE
#endif

struct ring rx_ring;
struct ring tx_ring;
uint8_t rx_ring_buffer[BUFFER_SIZE];
uint8_t tx_ring_buffer[BUFFER_SIZE];


/* Initialize UART */

void usart0_setup(unsigned long baud) {

	ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {

		PRR0 &= ~_BV(PRUSART0);
		UCSR0B = 0;

		/* Initialize ring buffers. */
		ring_init(&rx_ring, rx_ring_buffer, BUFFER_SIZE);
		ring_init(&tx_ring, tx_ring_buffer, BUFFER_SIZE);

		UCSR0A = 0;
		UBRR0  = F_CPU / baud / 16 - 1;
		UCSR0B = _BV(RXCIE0) | _BV(RXEN0) | _BV(TXEN0);
		UCSR0C = 3 << UCSZ00;
	};
}

/*--------------------------------------------------------------------------*/

/* UART RXC interrupt */

ISR(USART0_RX_vect)
{
	uint8_t d;

	d = UDR0;
	ring_write_ch(&rx_ring, d);
}

/* UART UDRE interrupt */

ISR(USART0_UDRE_vect)
{
	int d = ring_read_ch(&tx_ring);

	if (d < 0) {
		/* Disable TX empty interrupt. */
		UCSR0B = _BV(RXCIE0) | _BV(RXEN0) | _BV(TXEN0);
	} else {
		UDR0 = d;
	}
}

/*--------------------------------------------------------------------------*/

void serial_setup(unsigned long baud)
{
	stdout = &mystdout;
	usart0_setup(baud);
}

/*--------------------------------------------------------------------------*/

int _write(char c, FILE *stream)
{
	(void) stream;

	if (c == '\n')
		serial_putc('\r');
	serial_putc(c);

	return 0;
}

int serial_getc(void)
{
	return ring_read_ch(&rx_ring);
}

void serial_putc(char data)
{
	while (ring_write_ch(&tx_ring, data) < 0)
		;

	/* Enable the TXE interrupt. */
	UCSR0B = _BV(RXCIE0) | _BV(RXEN0) | _BV(TXEN0) | _BV(UDRIE0);
}

uint_fast8_t serial_tstc(void)
{
	return !ring_is_empty(&rx_ring);
}
Commit	Line	Data
0c5890bb	1	/*
35edb766 L	2	* (C) Copyright 2014 Leo C. <erbl259-lmu@yahoo.de>
	3	*
	4	* SPDX-License-Identifier: GPL-2.0+
0c5890bb L	5	*/
	6
	7	#include <avr/io.h>
	8	#include <avr/interrupt.h>
	9	#include <util/atomic.h>
	10	#include <errno.h>
	11	#include <stdio.h>
	12
762a42ef	13	#include "ring.h"
0c5890bb L	14	#include "serial.h"
	15
	16
	17	static int _write(char c, FILE *stream);
35edb766	18	static FILE mystdout = FDEV_SETUP_STREAM(_write,
0c5890bb L	19	NULL, _FDEV_SETUP_WRITE);
0c5890bb L	20
0c5890bb	21
0c5890bb	22
41d36f28	23	#define BUFFER_SIZE 128
0c5890bb L	24
	25	#if ((BUFFER_SIZE-1) & BUFFER_SIZE)
	26	# error: BUFFER_SIZE not power of 2
	27	#endif
	28
	29	#if ((BUFFER_SIZE) > 256)
35edb766	30	# error: BUFFER_SIZE
0c5890bb L	31	#endif
	32
	33	struct ring rx_ring;
	34	struct ring tx_ring;
	35	uint8_t rx_ring_buffer[BUFFER_SIZE];
	36	uint8_t tx_ring_buffer[BUFFER_SIZE];
	37
	38
0c5890bb L	39
	40	/* Initialize UART */
	41
f14850db	42	void usart0_setup(unsigned long baud) {
0c5890bb L	43
	44	ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
	45
	46	PRR0 &= ~_BV(PRUSART0);
	47	UCSR0B = 0;
	48
	49	/* Initialize ring buffers. */
	50	ring_init(&rx_ring, rx_ring_buffer, BUFFER_SIZE);
	51	ring_init(&tx_ring, tx_ring_buffer, BUFFER_SIZE);
	52
762a42ef	53	UCSR0A = 0;
f14850db	54	UBRR0 = F_CPU / baud / 16 - 1;
0c5890bb L	55	UCSR0B = _BV(RXCIE0) \| _BV(RXEN0) \| _BV(TXEN0);
	56	UCSR0C = 3 << UCSZ00;
	57	};
	58	}
	59
762a42ef	60	/--------------------------------------------------------------------------/
0c5890bb L	61
	62	/* UART RXC interrupt */
	63
	64	ISR(USART0_RX_vect)
	65	{
	66	uint8_t d;
	67
	68	d = UDR0;
762a42ef	69	ring_write_ch(&rx_ring, d);
0c5890bb L	70	}
	71
	72	/* UART UDRE interrupt */
	73
	74	ISR(USART0_UDRE_vect)
	75	{
762a42ef	76	int d = ring_read_ch(&tx_ring);
0c5890bb	77
762a42ef L	78	if (d < 0) {
762a42ef L	79	/* Disable TX empty interrupt. */
0c5890bb	80	UCSR0B = _BV(RXCIE0) \| _BV(RXEN0) \| _BV(TXEN0);
0c5890bb	81	} else {
762a42ef	82	UDR0 = d;
0c5890bb L	83	}
	84	}
	85
0c5890bb L	86	/--------------------------------------------------------------------------/
0c5890bb L	87
f14850db	88	void serial_setup(unsigned long baud)
0c5890bb L	89	{
0c5890bb L	90	stdout = &mystdout;
f14850db	91	usart0_setup(baud);
0c5890bb L	92	}
	93
	94	/--------------------------------------------------------------------------/
	95
	96	int _write(char c, FILE *stream)
	97	{
	98	(void) stream;
	99
	100	if (c == '\n')
	101	serial_putc('\r');
	102	serial_putc(c);
	103
	104	return 0;
	105	}
	106
	107	int serial_getc(void)
	108	{
	109	return ring_read_ch(&rx_ring);
	110	}
	111
d684c216	112	void serial_putc(char data)
0c5890bb L	113	{
	114	while (ring_write_ch(&tx_ring, data) < 0)
	115	;
762a42ef L	116
	117	/* Enable the TXE interrupt. */
	118	UCSR0B = _BV(RXCIE0) \| _BV(RXEN0) \| _BV(TXEN0) \| _BV(UDRIE0);
0c5890bb L	119	}
0c5890bb L	120
d684c216 L	121	uint_fast8_t serial_tstc(void)
	122	{
	123	return !ring_is_empty(&rx_ring);
	124	}