X-Git-Url: https://codewiz.org/gitweb?a=blobdiff_plain;f=drv%2Fser.c;h=8c95a9d774c85b1c107e165d7a5867be5033f8fc;hb=0628041b72ccf33890a673e46b0cd8035acf3a06;hp=663366753d72ef5ce29e772fc83e78cd29c6ff58;hpb=977bdf19f5de44f9dfef74b640d085eee00f456a;p=bertos.git diff --git a/drv/ser.c b/drv/ser.c index 66336675..8c95a9d7 100755 --- a/drv/ser.c +++ b/drv/ser.c @@ -1,9 +1,9 @@ -/*! +/** * \file * * * \brief Buffered serial I/O driver @@ -28,6 +28,69 @@ /*#* *#* $Log$ + *#* Revision 1.37 2007/06/07 14:35:12 batt + *#* Merge from project_ks. + *#* + *#* Revision 1.36 2007/01/29 11:30:29 batt + *#* Reimplement ser_clearstatus as a macro. + *#* + *#* Revision 1.35 2007/01/27 20:47:12 batt + *#* Add clear status. + *#* + *#* Revision 1.34 2006/11/20 15:07:40 batt + *#* Revert unneeded locked functions. + *#* + *#* Revision 1.33 2006/11/17 18:15:55 batt + *#* Avoid race conditions. + *#* + *#* Revision 1.32 2006/11/17 17:03:58 batt + *#* Implement ser_setstatus and ser_getstatus as functions to avoid race conditions. + *#* + *#* Revision 1.31 2006/07/21 10:58:00 batt + *#* Use timer_clock() instead of obsolete timer_ticks(). + *#* + *#* Revision 1.30 2006/07/19 12:56:26 bernie + *#* Convert to new Doxygen style. + *#* + *#* Revision 1.29 2006/05/18 00:39:30 bernie + *#* ser_open(): Document a bit more. + *#* + *#* Revision 1.28 2006/02/17 22:23:06 bernie + *#* Update POSIX serial emulator. + *#* + *#* Revision 1.27 2005/11/27 23:33:40 bernie + *#* Use appconfig.h instead of cfg/config.h. + *#* + *#* Revision 1.26 2005/11/04 16:20:02 bernie + *#* Fix reference to README.devlib in header. + *#* + *#* Revision 1.25 2005/04/11 19:10:27 bernie + *#* Include top-level headers from cfg/ subdir. + *#* + *#* Revision 1.24 2005/01/21 20:13:15 aleph + *#* Fix drain at ser_close() + *#* + *#* Revision 1.23 2005/01/14 00:47:07 aleph + *#* ser_drain(): Wait for hw transmission complete. + *#* + *#* Revision 1.22 2004/12/08 08:56:14 bernie + *#* Rename time_t to mtime_t. + *#* + *#* Revision 1.21 2004/11/16 18:10:13 bernie + *#* Add sanity checks for missing configuration parameters. + *#* + *#* Revision 1.20 2004/10/19 11:48:00 bernie + *#* Remove unused variable. + *#* + *#* Revision 1.19 2004/10/19 08:14:13 bernie + *#* Fix a few longstanding bugs wrt status handling (made by rasky on scfirm). + *#* + *#* Revision 1.18 2004/09/20 03:31:15 bernie + *#* Sanitize for C++. + *#* + *#* Revision 1.17 2004/09/14 21:06:07 bernie + *#* Use debug.h instead of kdebug.h; Spelling fixes. + *#* *#* Revision 1.16 2004/09/06 21:40:50 bernie *#* Move buffer handling in chip-specific driver. *#* @@ -75,30 +138,58 @@ *#* *#*/ -#include -#include #include "ser.h" + +#if CONFIG_WATCHDOG + #include "wdt.h" +#endif + #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 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. @@ -112,20 +203,23 @@ int ser_putchar(int c, struct Serial *port) if (fifo_isfull_locked(&port->txfifo)) { #if CONFIG_SER_TXTIMEOUT != -1 - time_t start_time = timer_ticks(); + ticks_t start_time = timer_clock(); #endif /* Attende finche' il buffer e' pieno... */ do { -#if defined(CONFIG_KERN_SCHED) && CONFIG_KERN_SCHED +#if CONFIG_WATCHDOG + wdt_reset(); +#endif +#if CONFIG_KERNEL && CONFIG_KERN_SCHED /* Give up timeslice to other processes. */ proc_switch(); #endif #if CONFIG_SER_TXTIMEOUT != -1 - if (timer_ticks() - start_time >= port->txtimeout) + if (timer_clock() - start_time >= port->txtimeout) { - port->status |= SERRF_TXTIMEOUT; + ATOMIC(port->status |= SERRF_TXTIMEOUT); return EOF; } #endif /* CONFIG_SER_TXTIMEOUT */ @@ -136,14 +230,14 @@ int ser_putchar(int c, struct Serial *port) 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 @@ -154,41 +248,43 @@ int ser_putchar(int c, struct Serial *port) */ int ser_getchar(struct Serial *port) { - int result; - if (fifo_isempty_locked(&port->rxfifo)) { #if CONFIG_SER_RXTIMEOUT != -1 - time_t start_time = timer_ticks(); + ticks_t start_time = timer_clock(); #endif /* Wait while buffer is empty */ do { -#if defined(CONFIG_KERN_SCHED) && CONFIG_KERN_SCHED +#if CONFIG_WATCHDOG + wdt_reset(); +#endif +#if CONFIG_KERNEL && CONFIG_KERN_SCHED /* Give up timeslice to other processes. */ proc_switch(); #endif #if CONFIG_SER_RXTIMEOUT != -1 - if (timer_ticks() - start_time >= port->rxtimeout) + 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_locked(&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. @@ -204,8 +300,8 @@ int ser_getchar_nowait(struct Serial *port) #if CONFIG_SER_GETS -/*! - * Read a line long at most as size and puts it +/** + * Read a line long at most as size and put it * in buf. * \return number of chars read or EOF in case * of error. @@ -216,7 +312,7 @@ int ser_gets(struct Serial *port, char *buf, int size) } -/*! +/** * Read a line long at most as size and put it * in buf, with optional echo. * @@ -254,7 +350,7 @@ int ser_gets_echo(struct Serial *port, char *buf, int size, bool echo) #endif /* !CONFIG_SER_GETS */ -/*! +/** * Read at most \a size bytes from \a port and put them in \a buf * * \return number of bytes actually read, or EOF in @@ -277,7 +373,7 @@ int ser_read(struct Serial *port, void *buf, size_t size) } -/*! +/** * Write a string to serial. * \return 0 if OK, EOF in case of error. */ @@ -292,7 +388,7 @@ int ser_print(struct Serial *port, const char *s) } -/*! +/** * \brief Write a buffer to serial. * * \return 0 if OK, EOF in case of error. @@ -301,7 +397,7 @@ int ser_print(struct Serial *port, const char *s) */ int ser_write(struct Serial *port, const void *_buf, size_t len) { - const char *buf = _buf; + const char *buf = (const char *)_buf; while (len--) { @@ -313,7 +409,7 @@ int ser_write(struct Serial *port, const void *_buf, size_t len) #if CONFIG_PRINTF -/*! +/** * Formatted write */ int ser_printf(struct Serial *port, const char *format, ...) @@ -321,7 +417,6 @@ 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); @@ -332,27 +427,27 @@ int ser_printf(struct Serial *port, const char *format, ...) #if CONFIG_SER_RXTIMEOUT != -1 || CONFIG_SER_TXTIMEOUT != -1 -void ser_settimeouts(struct Serial *port, time_t rxtimeout, time_t txtimeout) +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 /* CONFIG_SER_RXTIMEOUT || CONFIG_SER_TXTIMEOUT */ #if CONFIG_SER_RXTIMEOUT != -1 -/*! - * Discard input to resynchronize with remote end +/** + * 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, time_t delay) +void ser_resync(struct Serial *port, mtime_t delay) { - time_t old_rxtimeout = port->rxtimeout; + mtime_t old_rxtimeout = ticks_to_ms(port->rxtimeout); - ser_settimeouts(port, delay, port->txtimeout); + ser_settimeouts(port, delay, ticks_to_ms(port->txtimeout)); do { ser_setstatus(port, 0); @@ -362,24 +457,24 @@ void ser_resync(struct Serial *port, time_t delay) /* Restore port to an usable status */ ser_setstatus(port, 0); - ser_settimeouts(port, old_rxtimeout, port->txtimeout); + 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 *port) @@ -389,7 +484,7 @@ void ser_purge(struct Serial *port) } -/*! +/** * Wait until all pending output is completely * transmitted to the other end. * @@ -399,18 +494,28 @@ void ser_purge(struct Serial *port) */ void ser_drain(struct Serial *ser) { - while (!fifo_isempty(&ser->txfifo)) + /* + * 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 defined(CONFIG_KERN_SCHED) && CONFIG_KERN_SCHED + #if CONFIG_KERNEL && CONFIG_KERN_SCHED /* Give up timeslice to other processes. */ proc_switch(); -#endif + #endif + #if CONFIG_WATCHDOG + wdt_reset(); + #endif } } -/*! - * Initialize serial +/** + * Initialize a serial port. + * + * \param unit Serial unit to open. Possible values are architecture dependant. */ struct Serial *ser_open(unsigned int unit) { @@ -427,6 +532,8 @@ struct Serial *ser_open(unsigned int unit) 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); @@ -440,11 +547,14 @@ struct Serial *ser_open(unsigned int unit) 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) @@ -452,6 +562,15 @@ 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->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); }