drv/ser.c

   1 /*!
   2  * \file
   3  * <!--
   4  * Copyright 2003,2004 Develer S.r.l. (http://www.develer.com/)
   5  * Copyright 2000 Bernardo Innocenti <bernie@codewiz.org>
   6  * This file is part of DevLib - See devlib/README for information.
   7  * -->
   8  *
   9  * \brief Buffered serial I/O driver
  10  *
  11  * The serial rx interrupt buffers incoming data in a software FIFO
  12  * to decouple the higher level protocols from the line speed.
  13  * Outgoing data is buffered as well for better performance.
  14  * This driver is not optimized for best performance, but it
  15  * has proved to be fast enough to handle transfer rates up to
  16  * 38400bps on a 16MHz 80196.
  17  *
  18  * MODULE CONFIGURATION
  19  *      \li \c CONFIG_SER_HWHANDSHAKE define this preprocessor symbol to enable
  20  *      support for RTS/CTS handshake. Support is incomplete/untested
  21  *      for 80196.
  22  *  \li \c CONFIG_SER_TXTIMEOUT - Enable software serial transmission timeouts
  23  *
  24  *
  25  * \version $Id$
  26  * \author Bernardo Innocenti <bernie@develer.com>
  27  */
  28
  29 /*
  30  * $Log$
  31  * Revision 1.4  2004/06/03 11:27:09  bernie
  32  * Add dual-license information.
  33  *
  34  * Revision 1.3  2004/06/02 21:35:24  aleph
  35  * Serial enhancements: interruptible receive handler and 8 bit serial status for AVR; remove volatile attribute to FIFOBuffer, useless for new fifobuf routens
  36  *
  37  * Revision 1.2  2004/05/23 18:21:53  bernie
  38  * Trim CVS logs and cleanup header info.
  39  *
  40  */
  41
  42 #include <mware/formatwr.h>
  43 #include <drv/kdebug.h>
  44 #include "ser.h"
  45 #include "ser_p.h"
  46 #include "hw.h"
  47
  48 #ifdef CONFIG_KERNEL
  49         #include <kern/proc.h>
  50 #endif
  51 #if defined(CONFIG_SER_TXTIMEOUT) || defined(CONFIG_SER_RXTIMEOUT)
  52         #include <drv/timer.h>
  53 #endif
  54
  55
  56 /* Serial configuration parameters */
  57 #define SER_CTSDELAY        70  /*!< CTS line retry interval (ms) */
  58 #define SER_TXPOLLDELAY      2  /*!< Transmit buffer full retry interval (ms) */
  59 #define SER_RXPOLLDELAY      2  /*!< Receive buffer empty retry interval (ms) */
  60
  61
  62 struct Serial ser_handles[SER_CNT];
  63
  64
  65 /*!
  66  * Inserisce il carattere c nel buffer di trasmissione.
  67  * Questa funzione mette il processo chiamante in attesa
  68  * quando il buffer e' pieno.
  69  *
  70  * \return EOF in caso di errore o timeout, altrimenti
  71  *         il carattere inviato.
  72  */
  73 int ser_putchar(int c, struct Serial *port)
  74 {
  75         if (fifo_isfull_locked(&port->txfifo))
  76         {
  77 #ifdef CONFIG_SER_TXTIMEOUT
  78                 time_t start_time = timer_gettick();
  79 #endif
  80
  81                 /* Attende finche' il buffer e' pieno... */
  82                 do
  83                 {
  84 #ifdef CONFIG_KERN_SCHED
  85                         /* Give up timeslice to other processes. */
  86                         proc_switch();
  87 #endif
  88 #ifdef CONFIG_SER_TXTIMEOUT
  89                         if (timer_gettick() - start_time >= port->txtimeout)
  90                         {
  91                                 port->status |= SERRF_TXTIMEOUT;
  92                                 return EOF;
  93                         }
  94 #endif /* CONFIG_SER_TXTIMEOUT */
  95                 }
  96                 while (fifo_isfull_locked(&port->txfifo));
  97         }
  98
  99         fifo_push(&port->txfifo, (unsigned char)c);
 100
 101         /* (re)trigger tx interrupt */
 102         port->hw->table->enabletxirq(port->hw);
 103
 104         /* Avoid returning signed estended char */
 105         return (int)((unsigned char)c);
 106 }
 107
 108
 109 /*!
 110  * Preleva un carattere dal buffer di ricezione.
 111  * Questa funzione mette il processo chiamante in attesa
 112  * quando il buffer e' vuoto. L'attesa ha un timeout
 113  * di ser_rxtimeout millisecondi.
 114  *
 115  * \return EOF in caso di errore o timeout, altrimenti
 116  *         il carattere ricevuto.
 117  */
 118 int ser_getchar(struct Serial *port)
 119 {
 120         int result;
 121
 122         if (fifo_isempty_locked(&port->rxfifo))
 123         {
 124 #ifdef CONFIG_SER_RXTIMEOUT
 125                 time_t start_time = timer_gettick();
 126 #endif
 127                 /* Wait while buffer is empty */
 128                 do
 129                 {
 130 #ifdef CONFIG_KERN_SCHED
 131                         /* Give up timeslice to other processes. */
 132                         proc_switch();
 133 #endif
 134 #ifdef CONFIG_SER_RXTIMEOUT
 135                         if (timer_gettick() - start_time >= port->rxtimeout)
 136                         {
 137                                 port->status |= SERRF_RXTIMEOUT;
 138                                 return EOF;
 139                         }
 140 #endif /* CONFIG_SER_RXTIMEOUT */
 141                 }
 142                 while (fifo_isempty_locked(&port->rxfifo));
 143         }
 144
 145         /*
 146          * Get a byte from the FIFO (avoiding sign-extension),
 147          * re-enable RTS, then return result.
 148          */
 149         result = (int)(unsigned char)fifo_pop(&port->rxfifo);
 150         return port->status ? EOF : result;
 151 }
 152
 153
 154 /*!
 155  * Preleva un carattere dal buffer di ricezione.
 156  * Se il buffer e' vuoto, ser_getchar_nowait() ritorna
 157  * immediatamente EOF.
 158  */
 159 int ser_getchar_nowait(struct Serial *port)
 160 {
 161         if (fifo_isempty_locked(&port->rxfifo))
 162                 return EOF;
 163
 164         /* NOTE: the double cast prevents unwanted sign extension */
 165         return (int)(unsigned char)fifo_pop(&port->rxfifo);
 166 }
 167
 168
 169 /*!
 170  * Read a line long at most as size and puts it
 171  * in buf.
 172  * \return number of chars read or EOF in case
 173  *         of error.
 174  */
 175 int ser_gets(struct Serial *port, char *buf, int size)
 176 {
 177         return ser_gets_echo(port, buf, size, false);
 178 }
 179
 180
 181 /*!
 182  * Read a line long at most as size and puts it
 183  * in buf, with optional echo.
 184  * \return number of chars read or EOF in case
 185  *         of error.
 186  */
 187 int ser_gets_echo(struct Serial *port, char *buf, int size, bool echo)
 188 {
 189         int i = 0;
 190         int c;
 191
 192         for (;;)
 193         {
 194                 if ((c = ser_getchar(port)) == EOF)
 195                         return -1;
 196                 /* FIXME */
 197                 if (c == '\r' || c == '\n' || i >= size-1)
 198                 {
 199                         buf[i] = '\0';
 200                         if (echo)
 201                                 ser_print(port, "\r\n");
 202                         break;
 203                 }
 204                 buf[i++] = c;
 205                 if (echo)
 206                         ser_putchar(c, port);
 207         }
 208
 209         return i;
 210 }
 211
 212
 213 /*!
 214  * Read at most size bytes and puts them
 215  * in buf.
 216  * \return number of bytes read or EOF in case
 217  *         of error.
 218  */
 219 int ser_read(struct Serial *port, char *buf, size_t size)
 220 {
 221         size_t i = 0;
 222         int c;
 223
 224         while (i < size)
 225         {
 226                 if ((c = ser_getchar(port)) == EOF)
 227                         return EOF;
 228                 buf[i++] = c;
 229         }
 230
 231         return i;
 232 }
 233
 234
 235 /*!
 236  * Write a string to serial.
 237  * \return 0 if OK, EOF in case of error.
 238  */
 239 int ser_print(struct Serial *port, const char *s)
 240 {
 241         while (*s)
 242         {
 243                 if (ser_putchar(*s++, port) == EOF)
 244                         return EOF;
 245         }
 246         return 0;
 247 }
 248
 249
 250 /*!
 251  * \brief Write a buffer to serial.
 252  *
 253  * \return 0 if OK, EOF in case of error.
 254  */
 255 int ser_write(struct Serial *port, const void *buf, size_t len)
 256 {
 257         while (len--)
 258         {
 259                 if (ser_putchar(*((const char *)buf)++, port) == EOF)
 260                         return EOF;
 261         }
 262         return 0;
 263 }
 264
 265
 266 /*!
 267  * Formatted write
 268  */
 269 int ser_printf(struct Serial *port, const char *format, ...)
 270 {
 271         va_list ap;
 272         int len;
 273
 274         ser_setstatus(port, 0);
 275         va_start(ap, format);
 276         len = _formatted_write(format, (void (*)(char, void *))ser_putchar, port, ap);
 277         va_end(ap);
 278
 279         return len;
 280 }
 281
 282 #if defined(CONFIG_SER_RXTIMEOUT) || defined(CONFIG_SER_TXTIMEOUT)
 283 void ser_settimeouts(struct Serial *port, time_t rxtimeout, time_t txtimeout)
 284 {
 285         port->rxtimeout = rxtimeout;
 286         port->txtimeout = txtimeout;
 287 }
 288 #endif /* defined(CONFIG_SER_RXTIMEOUT) || defined(CONFIG_SER_TXTIMEOUT) */
 289
 290
 291 void ser_setbaudrate(struct Serial *port, unsigned long rate)
 292 {
 293         port->hw->table->setbaudrate(port->hw, rate);
 294 }
 295
 296
 297 void ser_setparity(struct Serial *port, int parity)
 298 {
 299         port->hw->table->setparity(port->hw, parity);
 300 }
 301
 302
 303 /*!
 304  * Flush both the RX and TX buffers.
 305  */
 306 void ser_purge(struct Serial *ser)
 307 {
 308         fifo_flush(&ser->rxfifo);
 309         fifo_flush(&ser->txfifo);
 310 }
 311
 312
 313 /*!
 314  * Initialize serial
 315  */
 316 struct Serial *ser_open(unsigned int unit)
 317 {
 318         struct Serial *port;
 319
 320         ASSERT(unit < countof(ser_handles));
 321
 322         port = &ser_handles[unit];
 323
 324         ASSERT(!port->is_open);
 325
 326         port->unit = unit;
 327         port->is_open = true;
 328
 329         /* Initialize circular buffer */
 330         fifo_init(&port->rxfifo, port->rxbuffer, sizeof(port->rxbuffer));
 331         fifo_init(&port->txfifo, port->txbuffer, sizeof(port->txbuffer));
 332
 333         port->hw = ser_hw_getdesc(unit);
 334         port->hw->table->init(port->hw, port);
 335
 336         /* Set default values */
 337 #if defined(CONFIG_SER_RXTIMEOUT) || defined(CONFIG_SER_TXTIMEOUT)
 338         ser_settimeouts(port, CONFIG_SER_RXTIMEOUT, CONFIG_SER_TXTIMEOUT);
 339 #endif
 340         ser_setbaudrate(port, CONFIG_SER_DEFBAUDRATE);
 341
 342         return port;
 343 }
 344
 345
 346 /*!
 347  * Clean up serial port, disabling the associated hardware.
 348  */
 349 void ser_close(struct Serial *port)
 350 {
 351         ASSERT(port->is_open);
 352
 353         port->is_open = false;
 354         port->hw->table->cleanup(port->hw);
 355         port->hw = NULL;
 356 }