X-Git-Url: https://codewiz.org/gitweb?a=blobdiff_plain;f=drv%2Fser.c;h=e776075b5f0609e12d34e9f472d71cb6020df63b;hb=272271646858e81780184331f386656203223575;hp=96c93df59370946432de6ae8d61c5bc26577109b;hpb=0375780817109b6ab5cd4f36ccf80650b2fe77d5;p=bertos.git diff --git a/drv/ser.c b/drv/ser.c old mode 100755 new mode 100644 index 96c93df5..e776075b --- a/drv/ser.c +++ b/drv/ser.c @@ -1,9 +1,34 @@ -/*! +/** * \file * * * \brief Buffered serial I/O driver @@ -16,9 +41,9 @@ * 38400bps on a 16MHz 80196. * * MODULE CONFIGURATION - * \li \c CONFIG_SER_HWHANDSHAKE define this preprocessor symbol to enable - * support for RTS/CTS handshake. Support is incomplete/untested - * for 80196. + * + * \li \c CONFIG_SER_HWHANDSHAKE - set to 1 to enable RTS/CTS handshake. + * Support is incomplete/untested. * \li \c CONFIG_SER_TXTIMEOUT - Enable software serial transmission timeouts * * @@ -26,57 +51,56 @@ * \author Bernardo Innocenti */ -/* - * $Log$ - * Revision 1.1 2004/05/23 18:10:11 bernie - * Import drv/ modules. - * - * Revision 1.5 2004/05/14 12:47:26 rasky - * Importato nuovo supporto seriale per AVR da Stefano - * - * Revision 1.4 2004/04/29 16:40:23 rasky - * Durante i busy loop della seriale, chiama la proc_switch() per cambiare processo - * - * Revision 1.3 2004/04/21 17:38:24 rasky - * New application - * - * Revision 1.16 2004/04/03 18:30:49 aleph - * Move timeout defines in config, private define in .c - * - * Revision 1.15 2004/03/29 17:01:02 aleph - * Add function to set serial parity, fix it when ser_open is used - * - * Revision 1.14 2004/03/29 16:19:33 aleph - * Add ser_cleanup function; Various code improvements - * - * Revision 1.13 2004/03/24 15:48:53 bernie - * Remove Copyright messages from Doxygen output - */ - -#include -#include #include "ser.h" + +#include "wdt.h" + #include "ser_p.h" -#include "hw.h" +#include +#include +#include -#ifdef CONFIG_KERNEL +/* + * Sanity check for config parameters required by this module. + */ +#if !defined(CONFIG_KERNEL) || ((CONFIG_KERNEL != 0) && CONFIG_KERNEL != 1) + #error CONFIG_KERNEL must be set to either 0 or 1 in config.h +#endif +#if !defined(CONFIG_SER_RXTIMEOUT) + #error CONFIG_SER_TXTIMEOUT missing in config.h +#endif +#if !defined(CONFIG_SER_RXTIMEOUT) + #error CONFIG_SER_RXTIMEOUT missing in config.h +#endif +#if !defined(CONFIG_SER_GETS) || ((CONFIG_SER_GETS != 0) && CONFIG_SER_GETS != 1) + #error CONFIG_SER_GETS must be set to either 0 or 1 in config.h +#endif +#if !defined(CONFIG_SER_DEFBAUDRATE) + #error CONFIG_SER_DEFBAUDRATE missing in config.h +#endif +#if !defined(CONFIG_PRINTF) + #error CONFIG_PRINTF missing in config.h +#endif + +#if CONFIG_KERNEL #include #endif -#if defined(CONFIG_SER_TXTIMEOUT) || defined(CONFIG_SER_RXTIMEOUT) + +#if CONFIG_SER_TXTIMEOUT != -1 || CONFIG_SER_RXTIMEOUT != -1 #include #endif /* Serial configuration parameters */ -#define SER_CTSDELAY 70 /*!< CTS line retry interval (ms) */ -#define SER_TXPOLLDELAY 2 /*!< Transmit buffer full retry interval (ms) */ -#define SER_RXPOLLDELAY 2 /*!< Receive buffer empty retry interval (ms) */ +#define SER_CTSDELAY 70 /**< CTS line retry interval (ms) */ +#define SER_TXPOLLDELAY 2 /**< Transmit buffer full retry interval (ms) */ +#define SER_RXPOLLDELAY 2 /**< Receive buffer empty retry interval (ms) */ struct Serial ser_handles[SER_CNT]; -/*! +/** * Inserisce il carattere c nel buffer di trasmissione. * Questa funzione mette il processo chiamante in attesa * quando il buffer e' pieno. @@ -86,23 +110,25 @@ struct Serial ser_handles[SER_CNT]; */ int ser_putchar(int c, struct Serial *port) { + //ASSERT_VALID_FIFO(&port->txfifo); if (fifo_isfull_locked(&port->txfifo)) { -#ifdef CONFIG_SER_TXTIMEOUT - time_t start_time = timer_gettick(); +#if CONFIG_SER_TXTIMEOUT != -1 + ticks_t start_time = timer_clock(); #endif /* Attende finche' il buffer e' pieno... */ do { -#ifdef CONFIG_KERN_SCHED + wdt_reset(); +#if CONFIG_KERNEL && CONFIG_KERN_SCHED /* Give up timeslice to other processes. */ proc_switch(); #endif -#ifdef CONFIG_SER_TXTIMEOUT - if (timer_gettick() - start_time >= port->txtimeout) +#if CONFIG_SER_TXTIMEOUT != -1 + if (timer_clock() - start_time >= port->txtimeout) { - port->status |= SERRF_TXTIMEOUT; + ATOMIC(port->status |= SERRF_TXTIMEOUT); return EOF; } #endif /* CONFIG_SER_TXTIMEOUT */ @@ -110,17 +136,17 @@ int ser_putchar(int c, struct Serial *port) while (fifo_isfull_locked(&port->txfifo)); } - fifo_push(&port->txfifo, (unsigned char)c); + fifo_push_locked(&port->txfifo, (unsigned char)c); /* (re)trigger tx interrupt */ - port->hw->table->enabletxirq(port->hw); + port->hw->table->txStart(port->hw); - /* Avoid returning signed estended char */ + /* Avoid returning signed extended char */ return (int)((unsigned char)c); } -/*! +/** * Preleva un carattere dal buffer di ricezione. * Questa funzione mette il processo chiamante in attesa * quando il buffer e' vuoto. L'attesa ha un timeout @@ -131,41 +157,41 @@ int ser_putchar(int c, struct Serial *port) */ int ser_getchar(struct Serial *port) { - int result; - if (fifo_isempty_locked(&port->rxfifo)) { -#ifdef CONFIG_SER_RXTIMEOUT - time_t start_time = timer_gettick(); +#if CONFIG_SER_RXTIMEOUT != -1 + ticks_t start_time = timer_clock(); #endif /* Wait while buffer is empty */ do { -#ifdef CONFIG_KERN_SCHED + wdt_reset(); +#if CONFIG_KERNEL && CONFIG_KERN_SCHED /* Give up timeslice to other processes. */ proc_switch(); #endif -#ifdef CONFIG_SER_RXTIMEOUT - if (timer_gettick() - start_time >= port->rxtimeout) +#if CONFIG_SER_RXTIMEOUT != -1 + if (timer_clock() - start_time >= port->rxtimeout) { - port->status |= SERRF_RXTIMEOUT; + ATOMIC(port->status |= SERRF_RXTIMEOUT); return EOF; } #endif /* CONFIG_SER_RXTIMEOUT */ } - while (fifo_isempty_locked(&port->rxfifo)); + while (fifo_isempty_locked(&port->rxfifo) && (ser_getstatus(port) & SERRF_RX) == 0); } /* * Get a byte from the FIFO (avoiding sign-extension), * re-enable RTS, then return result. */ - result = (int)(unsigned char)fifo_pop(&port->rxfifo); - return port->status ? EOF : result; + if (ser_getstatus(port) & SERRF_RX) + return EOF; + return (int)(unsigned char)fifo_pop_locked(&port->rxfifo); } -/*! +/** * Preleva un carattere dal buffer di ricezione. * Se il buffer e' vuoto, ser_getchar_nowait() ritorna * immediatamente EOF. @@ -176,12 +202,13 @@ int ser_getchar_nowait(struct Serial *port) return EOF; /* NOTE: the double cast prevents unwanted sign extension */ - return (int)(unsigned char)fifo_pop(&port->rxfifo); + return (int)(unsigned char)fifo_pop_locked(&port->rxfifo); } -/*! - * Read a line long at most as size and puts it +#if CONFIG_SER_GETS +/** + * Read a line long at most as size and put it * in buf. * \return number of chars read or EOF in case * of error. @@ -192,10 +219,11 @@ int ser_gets(struct Serial *port, char *buf, int size) } -/*! - * Read a line long at most as size and puts it +/** + * Read a line long at most as size and put it * in buf, with optional echo. - * \return number of chars read or EOF in case + * + * \return number of chars read, or EOF in case * of error. */ int ser_gets_echo(struct Serial *port, char *buf, int size, bool echo) @@ -206,7 +234,11 @@ int ser_gets_echo(struct Serial *port, char *buf, int size, bool echo) for (;;) { if ((c = ser_getchar(port)) == EOF) + { + buf[i] = '\0'; return -1; + } + /* FIXME */ if (c == '\r' || c == '\n' || i >= size-1) { @@ -222,31 +254,33 @@ int ser_gets_echo(struct Serial *port, char *buf, int size, bool echo) return i; } +#endif /* !CONFIG_SER_GETS */ -/*! - * Read at most size bytes and puts them - * in buf. - * \return number of bytes read or EOF in case - * of error. +/** + * Read at most \a size bytes from \a port and put them in \a buf + * + * \return number of bytes actually read, or EOF in + * case of error. */ -int ser_read(struct Serial *port, char *buf, size_t size) +int ser_read(struct Serial *port, void *buf, size_t size) { size_t i = 0; + char *_buf = (char *)buf; int c; while (i < size) { if ((c = ser_getchar(port)) == EOF) return EOF; - buf[i++] = c; + _buf[i++] = c; } return i; } -/*! +/** * Write a string to serial. * \return 0 if OK, EOF in case of error. */ @@ -261,23 +295,28 @@ int ser_print(struct Serial *port, const char *s) } -/*! +/** * \brief Write a buffer to serial. * * \return 0 if OK, EOF in case of error. + * + * \todo Optimize with fifo_pushblock() */ -int ser_write(struct Serial *port, const void *buf, size_t len) +int ser_write(struct Serial *port, const void *_buf, size_t len) { + const char *buf = (const char *)_buf; + while (len--) { - if (ser_putchar(*((const char *)buf)++, port) == EOF) + if (ser_putchar(*buf++, port) == EOF) return EOF; } return 0; } -/*! +#if CONFIG_PRINTF +/** * Formatted write */ int ser_printf(struct Serial *port, const char *format, ...) @@ -285,86 +324,158 @@ int ser_printf(struct Serial *port, const char *format, ...) va_list ap; int len; - ser_setstatus(port, 0); va_start(ap, format); len = _formatted_write(format, (void (*)(char, void *))ser_putchar, port, ap); va_end(ap); return len; } +#endif /* CONFIG_PRINTF */ + -#if defined(CONFIG_SER_RXTIMEOUT) || defined(CONFIG_SER_TXTIMEOUT) -void ser_settimeouts(struct Serial *port, time_t rxtimeout, time_t txtimeout) +#if CONFIG_SER_RXTIMEOUT != -1 || CONFIG_SER_TXTIMEOUT != -1 +void ser_settimeouts(struct Serial *port, mtime_t rxtimeout, mtime_t txtimeout) { - port->rxtimeout = rxtimeout; - port->txtimeout = txtimeout; + port->rxtimeout = ms_to_ticks(rxtimeout); + port->txtimeout = ms_to_ticks(txtimeout); } -#endif /* defined(CONFIG_SER_RXTIMEOUT) || defined(CONFIG_SER_TXTIMEOUT) */ +#endif /* CONFIG_SER_RXTIMEOUT || CONFIG_SER_TXTIMEOUT */ + +#if CONFIG_SER_RXTIMEOUT != -1 +/** + * Discard input to resynchronize with remote end. + * + * Discard incoming data until the port stops receiving + * characters for at least \a delay milliseconds. + * + * \note Serial errors are reset before and after executing the purge. + */ +void ser_resync(struct Serial *port, mtime_t delay) +{ + mtime_t old_rxtimeout = ticks_to_ms(port->rxtimeout); + + ser_settimeouts(port, delay, ticks_to_ms(port->txtimeout)); + do + { + ser_setstatus(port, 0); + ser_getchar(port); + } + while (!(ser_getstatus(port) & SERRF_RXTIMEOUT)); + + /* Restore port to an usable status */ + ser_setstatus(port, 0); + ser_settimeouts(port, old_rxtimeout, ticks_to_ms(port->txtimeout)); +} +#endif /* CONFIG_SER_RXTIMEOUT */ void ser_setbaudrate(struct Serial *port, unsigned long rate) { - port->hw->table->setbaudrate(port->hw, rate); + port->hw->table->setBaudrate(port->hw, rate); } void ser_setparity(struct Serial *port, int parity) { - port->hw->table->setparity(port->hw, parity); + port->hw->table->setParity(port->hw, parity); } -/*! +/** * Flush both the RX and TX buffers. */ -void ser_purge(struct Serial *ser) +void ser_purge(struct Serial *port) { - fifo_flush(&ser->rxfifo); - fifo_flush(&ser->txfifo); + fifo_flush_locked(&port->rxfifo); + fifo_flush_locked(&port->txfifo); } -/*! - * Initialize serial +/** + * Wait until all pending output is completely + * transmitted to the other end. + * + * \note The current implementation only checks the + * software transmission queue. Any hardware + * FIFOs are ignored. + */ +void ser_drain(struct Serial *ser) +{ + /* + * Wait until the FIFO becomes empty, and then until the byte currently in + * the hardware register gets shifted out. + */ + while (!fifo_isempty(&ser->txfifo) + || ser->hw->table->txSending(ser->hw)) + { + #if CONFIG_KERNEL && CONFIG_KERN_SCHED + /* Give up timeslice to other processes. */ + proc_switch(); + #endif + wdt_reset(); + } +} + + +/** + * Initialize a serial port. + * + * \param unit Serial unit to open. Possible values are architecture dependant. */ struct Serial *ser_open(unsigned int unit) { struct Serial *port; ASSERT(unit < countof(ser_handles)); - port = &ser_handles[unit]; ASSERT(!port->is_open); + DB(port->is_open = true;) port->unit = unit; - port->is_open = true; - - /* Initialize circular buffer */ - fifo_init(&port->rxfifo, port->rxbuffer, sizeof(port->rxbuffer)); - fifo_init(&port->txfifo, port->txbuffer, sizeof(port->txbuffer)); port->hw = ser_hw_getdesc(unit); + + /* Initialize circular buffers */ + ASSERT(port->hw->txbuffer); + ASSERT(port->hw->rxbuffer); + fifo_init(&port->txfifo, port->hw->txbuffer, port->hw->txbuffer_size); + fifo_init(&port->rxfifo, port->hw->rxbuffer, port->hw->rxbuffer_size); + port->hw->table->init(port->hw, port); /* Set default values */ -#if defined(CONFIG_SER_RXTIMEOUT) || defined(CONFIG_SER_TXTIMEOUT) +#if CONFIG_SER_RXTIMEOUT != -1 || CONFIG_SER_TXTIMEOUT != -1 ser_settimeouts(port, CONFIG_SER_RXTIMEOUT, CONFIG_SER_TXTIMEOUT); #endif +#if CONFIG_SER_DEFBAUDRATE ser_setbaudrate(port, CONFIG_SER_DEFBAUDRATE); +#endif + + /* Clear error flags */ + ser_setstatus(port, 0); return port; } -/*! +/** * Clean up serial port, disabling the associated hardware. */ void ser_close(struct Serial *port) { ASSERT(port->is_open); + DB(port->is_open = false;) + + // Wait until we finish sending everything + ser_drain(port); - port->is_open = false; port->hw->table->cleanup(port->hw); - port->hw = NULL; + DB(port->hw = NULL;) + + /* + * We purge the FIFO buffer only after the low-level cleanup, so that + * we are sure that there are no more interrupts. + */ + ser_purge(port); }