X-Git-Url: https://codewiz.org/gitweb?a=blobdiff_plain;f=drv%2Fser_avr.c;h=aa239de4af9f038426fca84fccfbcc7b0c25c013;hb=86ca446c6d5113066d6c16e602acff01aee5ae29;hp=e7513590143820ddaab6898bffd5bb0f6b3435fe;hpb=86cf322544e9546782ee25606ccd2f1dbb50c39b;p=bertos.git

diff --git a/drv/ser_avr.c b/drv/ser_avr.c
index e7513590..aa239de4 100755
--- a/drv/ser_avr.c
+++ b/drv/ser_avr.c
@@ -38,6 +38,36 @@
 
 /*#*
  *#* $Log$
+ *#* Revision 1.24  2005/01/14 00:49:16  aleph
+ *#* Rename callbacks; SerialHardwareVT.txSending: New callback; Add SPI_BUS macros.
+ *#*
+ *#* Revision 1.23  2005/01/11 18:09:07  aleph
+ *#* Add ATmega8 SPI port definitions; Fix transmit complete IRQ bug; add strobe macros to uart1 and spi
+ *#*
+ *#* Revision 1.22  2004/12/31 17:47:45  bernie
+ *#* Rename UNUSED() to UNUSED_ARG().
+ *#*
+ *#* Revision 1.21  2004/12/13 12:07:06  bernie
+ *#* DISABLE_IRQSAVE/ENABLE_IRQRESTORE: Convert to IRQ_SAVE_DISABLE/IRQ_RESTORE.
+ *#*
+ *#* Revision 1.20  2004/12/13 11:51:43  bernie
+ *#* Fix a latent bug with reentrant serial IRQs.
+ *#*
+ *#* Revision 1.19  2004/12/13 11:51:08  bernie
+ *#* DISABLE_INTS/ENABLE_INTS: Convert to IRQ_DISABLE/IRQ_ENABLE.
+ *#*
+ *#* Revision 1.18  2004/12/08 08:03:48  bernie
+ *#* Doxygen fixes.
+ *#*
+ *#* Revision 1.17  2004/10/19 07:52:35  bernie
+ *#* Reset parity bits before overwriting them (Fixed by batt in project_ks).
+ *#*
+ *#* Revision 1.16  2004/10/03 18:45:48  bernie
+ *#* Convert to new-style config macros; Allow compiling with a C++ compiler (mostly).
+ *#*
+ *#* Revision 1.15  2004/09/14 21:05:36  bernie
+ *#* Use debug.h instead of kdebug.h; Use new AVR pin names; Spelling fixes.
+ *#*
  *#* Revision 1.14  2004/09/06 21:50:00  bernie
  *#* Spelling fixes.
  *#*
@@ -81,11 +111,12 @@
 #include "config.h"
 #include "hw.h"  /* Required for bus macros overrides */
 
-#include <drv/kdebug.h>
+#include <debug.h>
 #include <drv/timer.h>
 #include <mware/fifobuf.h>
 
 #include <avr/signal.h>
+#include <avr/io.h>
 
 
 /*!
@@ -181,6 +212,9 @@
 	 *
 	 * The default is no action.
 	 */
+	#ifdef __doxygen__
+	#define SER_UART0_BUS_TXOFF
+	#endif
 #endif
 
 #ifndef SER_UART1_BUS_TXINIT
@@ -213,21 +247,64 @@
 	 *
 	 * \see SER_UART0_BUS_TXOFF
 	 */
+	#ifdef __doxygen__
+	#define SER_UART1_BUS_TXOFF
+	#endif
+#endif
+/*\}*/
+
+
+/*!
+ * \name Overridable SPI hooks
+ *
+ * These can be redefined in hw.h to implement
+ * special bus policies such as slave select pin handling, etc.
+ *
+ * \{
+ */
+#ifndef SER_SPI_BUS_TXINIT
+	/*!
+	 * \def SER_SPI_BUS_TXINIT
+	 *
+	 * Default TXINIT macro - invoked in spi_init()
+	 * The default is no action.
+	 */
+	#define SER_SPI_BUS_TXINIT
+#endif
+
+#ifndef SER_SPI_BUS_TXCLOSE
+	/*!
+	 * \def SER_SPI_BUS_TXCLOSE
+	 *
+	 * Invoked after the last character has been transmitted.
+	 * The default is no action.
+	 */
+	#define SER_SPI_BUS_TXCLOSE
 #endif
 /*\}*/
 
 
 /* SPI port and pin configuration */
-#define SPI_PORT      PORTB
-#define SPI_DDR       DDRB
-#define SPI_SCK_BIT   PORTB1
-#define SPI_MOSI_BIT  PORTB2
-#define SPI_MISO_BIT  PORTB3
-
-/* USART registers definitions */
-#if defined(__AVR_ATmega64__) || defined(__AVR_ATmega128__)
+#if CPU_AVR_ATMEGA64 || CPU_AVR_ATMEGA128 || CPU_AVR_ATMEGA103
+	#define SPI_PORT      PORTB
+	#define SPI_DDR       DDRB
+	#define SPI_SCK_BIT   PB1
+	#define SPI_MOSI_BIT  PB2
+	#define SPI_MISO_BIT  PB3
+#elif CPU_AVR_ATMEGA8
+	#define SPI_PORT      PORTB
+	#define SPI_DDR       DDRB
+	#define SPI_SCK_BIT   PB5
+	#define SPI_MOSI_BIT  PB3
+	#define SPI_MISO_BIT  PB4
+#else
+	#error Unknown architecture
+#endif
+
+/* USART register definitions */
+#if CPU_AVR_ATMEGA64 || CPU_AVR_ATMEGA128
 	#define AVR_HAS_UART1 1
-#elif defined(__AVR_ATmega8__)
+#elif CPU_AVR_ATMEGA8
 	#define AVR_HAS_UART1 0
 	#define UCSR0A UCSRA
 	#define UCSR0B UCSRB
@@ -237,7 +314,8 @@
 	#define UBRR0H UBRRH
 	#define SIG_UART0_DATA SIG_UART_DATA
 	#define SIG_UART0_RECV SIG_UART_RECV
-#elif defined(__AVR_ATmega103__)
+	#define SIG_UART0_TRANS SIG_UART_TRANS
+#elif CPU_AVR_ATMEGA103
 	#define AVR_HAS_UART1 0
 	#define UCSR0B UCR
 	#define UDR0   UDR
@@ -245,6 +323,7 @@
 	#define UBRR0L UBRR
 	#define SIG_UART0_DATA SIG_UART_DATA
 	#define SIG_UART0_RECV SIG_UART_RECV
+	#define SIG_UART0_TRANS SIG_UART_TRANS
 #else
 	#error Unknown architecture
 #endif
@@ -305,12 +384,11 @@ struct AvrSerial
 
 
 /*
- * These are to trick GCC into *not* using
- * absolute addressing mode when accessing
- * ser_handles, which is very expensive.
+ * These are to trick GCC into *not* using absolute addressing mode
+ * when accessing ser_handles, which is very expensive.
  *
- * Accessing through these pointers generates
- * much shorter (and hopefully faster) code.
+ * Accessing through these pointers generates much shorter
+ * (and hopefully faster) code.
  */
 struct Serial *ser_uart0 = &ser_handles[SER_UART0];
 #if AVR_HAS_UART1
@@ -323,13 +401,16 @@ struct Serial *ser_spi = &ser_handles[SER_SPI];
 /*
  * Callbacks
  */
-static void uart0_init(UNUSED(struct SerialHardware *, _hw), UNUSED(struct Serial *, ser))
+static void uart0_init(
+	UNUSED_ARG(struct SerialHardware *, _hw),
+	UNUSED_ARG(struct Serial *, ser))
 {
 	SER_UART0_BUS_TXINIT;
 	RTS_ON;
+	SER_STROBE_INIT;
 }
 
-static void uart0_cleanup(UNUSED(struct SerialHardware *, _hw))
+static void uart0_cleanup(UNUSED_ARG(struct SerialHardware *, _hw))
 {
 	UCSR0B = 0;
 }
@@ -339,10 +420,9 @@ static void uart0_enabletxirq(struct SerialHardware *_hw)
 	struct AvrSerial *hw = (struct AvrSerial *)_hw;
 
 	/*
-	 * WARNING: racy code here!  The tx interrupt
-	 * sets hw->sending to false when it runs with
-	 * an empty fifo.  The order of the statements
-	 * in the if-block matters.
+	 * WARNING: racy code here!  The tx interrupt sets hw->sending to false
+	 * when it runs with an empty fifo.  The order of statements in the
+	 * if-block matters.
 	 */
 	if (!hw->sending)
 	{
@@ -351,7 +431,7 @@ static void uart0_enabletxirq(struct SerialHardware *_hw)
 	}
 }
 
-static void uart0_setbaudrate(UNUSED(struct SerialHardware *, _hw), unsigned long rate)
+static void uart0_setbaudrate(UNUSED_ARG(struct SerialHardware *, _hw), unsigned long rate)
 {
 	/* Compute baud-rate period */
 	uint16_t period = (((CLOCK_FREQ / 16UL) + (rate / 2)) / rate) - 1;
@@ -364,23 +444,25 @@ static void uart0_setbaudrate(UNUSED(struct SerialHardware *, _hw), unsigned lon
 	//DB(kprintf("uart0_setbaudrate(rate=%lu): period=%d\n", rate, period);)
 }
 
-static void uart0_setparity(UNUSED(struct SerialHardware *, _hw), int parity)
+static void uart0_setparity(UNUSED_ARG(struct SerialHardware *, _hw), int parity)
 {
-#ifndef __AVR_ATmega103__
-	UCSR0C |= (parity) << UPM0;
+#if !CPU_AVR_ATMEGA103
+	UCSR0C = (UCSR0C & ~(BV(UPM1) | BV(UPM0))) | ((parity) << UPM0);
 #endif
 }
 
 #if AVR_HAS_UART1
 
-static void uart1_init(UNUSED(struct SerialHardware *, _hw), UNUSED(struct Serial *, ser))
+static void uart1_init(
+	UNUSED_ARG(struct SerialHardware *, _hw),
+	UNUSED_ARG(struct Serial *, ser))
 {
 	SER_UART1_BUS_TXINIT;
 	RTS_ON;
 	SER_STROBE_INIT;
 }
 
-static void uart1_cleanup(UNUSED(struct SerialHardware *, _hw))
+static void uart1_cleanup(UNUSED_ARG(struct SerialHardware *, _hw))
 {
 	UCSR1B = 0;
 }
@@ -402,7 +484,7 @@ static void uart1_enabletxirq(struct SerialHardware *_hw)
 	}
 }
 
-static void uart1_setbaudrate(UNUSED(struct SerialHardware *, _hw), unsigned long rate)
+static void uart1_setbaudrate(UNUSED_ARG(struct SerialHardware *, _hw), unsigned long rate)
 {
 	/* Compute baud-rate period */
 	uint16_t period = (((CLOCK_FREQ / 16UL) + (rate / 2)) / rate) - 1;
@@ -413,14 +495,14 @@ static void uart1_setbaudrate(UNUSED(struct SerialHardware *, _hw), unsigned lon
 	//DB(kprintf("uart1_setbaudrate(rate=%ld): period=%d\n", rate, period);)
 }
 
-static void uart1_setparity(UNUSED(struct SerialHardware *, _hw), int parity)
+static void uart1_setparity(UNUSED_ARG(struct SerialHardware *, _hw), int parity)
 {
-	UCSR1C |= (parity) << UPM0;
+	UCSR1C = (UCSR1C & ~(BV(UPM1) | BV(UPM0))) | ((parity) << UPM0);
 }
 
 #endif // AVR_HAS_UART1
 
-static void spi_init(UNUSED(struct SerialHardware *, _hw), UNUSED(struct Serial *, ser))
+static void spi_init(UNUSED_ARG(struct SerialHardware *, _hw), UNUSED_ARG(struct Serial *, ser))
 {
 	/*
 	 * Set MOSI and SCK ports out, MISO in.
@@ -439,11 +521,18 @@ static void spi_init(UNUSED(struct SerialHardware *, _hw), UNUSED(struct Serial
 	SPI_DDR &= ~BV(SPI_MISO_BIT);
 	/* Enable SPI, IRQ on, Master, CPU_CLOCK/16 */
 	SPCR = BV(SPE) | BV(SPIE) | BV(MSTR) | BV(SPR0);
+
+	SER_SPI_BUS_TXINIT;
+
+	SER_STROBE_INIT;
 }
 
-static void spi_cleanup(UNUSED(struct SerialHardware *, _hw))
+static void spi_cleanup(UNUSED_ARG(struct SerialHardware *, _hw))
 {
 	SPCR = 0;
+
+	SER_SPI_BUS_TXCLOSE;
+
 	/* Set all pins as inputs */
 	SPI_DDR &= ~(BV(SPI_MISO_BIT) | BV(SPI_MOSI_BIT) | BV(SPI_SCK_BIT));
 }
@@ -453,7 +542,7 @@ static void spi_starttx(struct SerialHardware *_hw)
 	struct AvrSerial *hw = (struct AvrSerial *)_hw;
 
 	cpuflags_t flags;
-	DISABLE_IRQSAVE(flags);
+	IRQ_SAVE_DISABLE(flags);
 
 	/* Send data only if the SPI is not already transmitting */
 	if (!hw->sending && !fifo_isempty(&ser_spi->txfifo))
@@ -462,86 +551,107 @@ static void spi_starttx(struct SerialHardware *_hw)
 		SPDR = fifo_pop(&ser_spi->txfifo);
 	}
 
-	ENABLE_IRQRESTORE(flags);
+	IRQ_RESTORE(flags);
 }
 
-static void spi_setbaudrate(UNUSED(struct SerialHardware *, _hw), UNUSED(unsigned long, rate))
+static void spi_setbaudrate(
+	UNUSED_ARG(struct SerialHardware *, _hw),
+	UNUSED_ARG(unsigned long, rate))
 {
 	// nop
 }
 
-static void spi_setparity(UNUSED(struct SerialHardware *, _hw), UNUSED(int, parity))
+static void spi_setparity(UNUSED_ARG(struct SerialHardware *, _hw), UNUSED_ARG(int, parity))
 {
 	// nop
 }
 
+static bool tx_sending(struct SerialHardware* _hw)
+{
+	struct AvrSerial *hw = (struct AvrSerial *)_hw;
+	return hw->sending;
+}
 
 
+
+// FIXME: move into compiler.h?  Ditch?
+#if COMPILER_C99
+	#define	C99INIT(name,val) .name = val
+#elif defined(__GNUC__)
+	#define C99INIT(name,val) name: val
+#else
+	#warning No designated initializers, double check your code
+	#define C99INIT(name,val) (val)
+#endif
+
 /*
  * High-level interface data structures
  */
 static const struct SerialHardwareVT UART0_VT =
 {
-	.init = uart0_init,
-	.cleanup = uart0_cleanup,
-	.setbaudrate = uart0_setbaudrate,
-	.setparity = uart0_setparity,
-	.enabletxirq = uart0_enabletxirq,
+	C99INIT(init, uart0_init),
+	C99INIT(cleanup, uart0_cleanup),
+	C99INIT(setBaudrate, uart0_setbaudrate),
+	C99INIT(setParity, uart0_setparity),
+	C99INIT(txStart, uart0_enabletxirq),
+	C99INIT(txSending, tx_sending),
 };
 
 #if AVR_HAS_UART1
 static const struct SerialHardwareVT UART1_VT =
 {
-	.init = uart1_init,
-	.cleanup = uart1_cleanup,
-	.setbaudrate = uart1_setbaudrate,
-	.setparity = uart1_setparity,
-	.enabletxirq = uart1_enabletxirq,
+	C99INIT(init, uart1_init),
+	C99INIT(cleanup, uart1_cleanup),
+	C99INIT(setBaudrate, uart1_setbaudrate),
+	C99INIT(setParity, uart1_setparity),
+	C99INIT(txStart, uart1_enabletxirq),
+	C99INIT(txSending, tx_sending),
 };
 #endif // AVR_HAS_UART1
 
 static const struct SerialHardwareVT SPI_VT =
 {
-	.init = spi_init,
-	.cleanup = spi_cleanup,
-	.setbaudrate = spi_setbaudrate,
-	.setparity = spi_setparity,
-	.enabletxirq = spi_starttx,
+	C99INIT(init, spi_init),
+	C99INIT(cleanup, spi_cleanup),
+	C99INIT(setBaudrate, spi_setbaudrate),
+	C99INIT(setParity, spi_setparity),
+	C99INIT(txStart, spi_starttx),
+	C99INIT(txSending, tx_sending),
 };
 
 static struct AvrSerial UARTDescs[SER_CNT] =
 {
 	{
-		.hw = {
-			.table = &UART0_VT,
-			.txbuffer = uart0_txbuffer,
-			.rxbuffer = uart0_rxbuffer,
-			.txbuffer_size = CONFIG_UART0_TXBUFSIZE,
-			.rxbuffer_size = CONFIG_UART0_RXBUFSIZE,
+		C99INIT(hw, /**/) {
+			C99INIT(table, &UART0_VT),
+			C99INIT(txbuffer, uart0_txbuffer),
+			C99INIT(rxbuffer, uart0_rxbuffer),
+			C99INIT(txbuffer_size, sizeof(uart0_txbuffer)),
+			C99INIT(rxbuffer_size, sizeof(uart0_rxbuffer)),
 		},
-		.sending = false,
+		C99INIT(sending, false),
 	},
 #if AVR_HAS_UART1
 	{
-		.hw = {
-			.table = &UART1_VT,
-			.txbuffer = uart1_txbuffer,
-			.rxbuffer = uart1_rxbuffer,
-			.txbuffer_size = CONFIG_UART1_TXBUFSIZE,
-			.rxbuffer_size = CONFIG_UART1_RXBUFSIZE,
+		C99INIT(hw, /**/) {
+			C99INIT(table, &UART1_VT),
+			C99INIT(txbuffer, uart1_txbuffer),
+			C99INIT(rxbuffer, uart1_rxbuffer),
+			C99INIT(txbuffer_size, sizeof(uart1_txbuffer)),
+			C99INIT(rxbuffer_size, sizeof(uart1_rxbuffer)),
 		},
-		.sending = false,
+		C99INIT(sending, false),
 	},
 #endif
 	{
-		.hw = {
-			.table = &SPI_VT,
-			.txbuffer = spi_txbuffer,
-			.rxbuffer = spi_rxbuffer,
-			.txbuffer_size = CONFIG_SPI_TXBUFSIZE,
-			.rxbuffer_size = CONFIG_SPI_RXBUFSIZE,
+		C99INIT(hw, /**/) {
+			C99INIT(table, &SPI_VT),
+			C99INIT(txbuffer, spi_txbuffer),
+			C99INIT(rxbuffer, spi_rxbuffer),
+			C99INIT(txbuffer_size, sizeof(spi_txbuffer)),
+			C99INIT(rxbuffer_size, sizeof(spi_rxbuffer)),
 		},
-		.sending = false,
+		C99INIT(sending, false),
 	}
 };
 
@@ -552,7 +662,6 @@ struct SerialHardware* ser_hw_getdesc(int unit)
 }
 
 
-
 /*
  * Interrupt handlers
  */
@@ -706,7 +815,7 @@ SIGNAL(SIG_UART1_TRANS)
  * Serial 0 RX complete interrupt handler.
  *
  * This handler is interruptible.
- * Interrupt are re-enabled as soon as recv complete interrupt is
+ * Interrupt are reenabled as soon as recv complete interrupt is
  * disabled. Using INTERRUPT() is troublesome when the serial
  * is heavily loaded, because an interrupt could be retriggered
  * when executing the handler prologue before RXCIE is disabled.
@@ -723,7 +832,7 @@ SIGNAL(SIG_UART0_RECV)
 
 	/* Disable Recv complete IRQ */
 	//UCSR0B &= ~BV(RXCIE);
-	//ENABLE_INTS;
+	//IRQ_ENABLE;
 
 	/* Should be read before UDR */
 	ser_uart0->status |= UCSR0A & (SERRF_RXSROVERRUN | SERRF_FRAMEERROR);
@@ -746,8 +855,8 @@ SIGNAL(SIG_UART0_RECV)
 #endif
 	}
 
-	/* Re-enable receive complete int */
-	//DISABLE_INTS;
+	/* Reenable receive complete int */
+	//IRQ_DISABLE;
 	//UCSR0B |= BV(RXCIE);
 
 	SER_STROBE_OFF;
@@ -760,7 +869,7 @@ SIGNAL(SIG_UART0_RECV)
  * Serial 1 RX complete interrupt handler.
  *
  * This handler is interruptible.
- * Interrupt are re-enabled as soon as recv complete interrupt is
+ * Interrupt are reenabled as soon as recv complete interrupt is
  * disabled. Using INTERRUPT() is troublesome when the serial
  * is heavily loaded, because an interrupt could be retriggered
  * when executing the handler prologue before RXCIE is disabled.
@@ -773,7 +882,7 @@ SIGNAL(SIG_UART1_RECV)
 
 	/* Disable Recv complete IRQ */
 	//UCSR1B &= ~BV(RXCIE);
-	//ENABLE_INTS;
+	//IRQ_ENABLE;
 
 	/* Should be read before UDR */
 	ser_uart1->status |= UCSR1A & (SERRF_RXSROVERRUN | SERRF_FRAMEERROR);
@@ -796,6 +905,7 @@ SIGNAL(SIG_UART1_RECV)
 #endif
 	}
 	/* Re-enable receive complete int */
+	//IRQ_DISABLE;
 	//UCSR1B |= BV(RXCIE);
 
 	SER_STROBE_OFF;
@@ -809,6 +919,8 @@ SIGNAL(SIG_UART1_RECV)
  */
 SIGNAL(SIG_SPI)
 {
+	SER_STROBE_ON;
+
 	/* Read incoming byte. */
 	if (!fifo_isfull(&ser_spi->rxfifo))
 		fifo_push(&ser_spi->rxfifo, SPDR);
@@ -823,4 +935,6 @@ SIGNAL(SIG_SPI)
 		SPDR = fifo_pop(&ser_spi->txfifo);
 	else
 		UARTDescs[SER_SPI].sending = false;
+
+	SER_STROBE_OFF;
 }