ser.c

Go to the documentation of this file.

#include "ser.h"
#include "wdt.h"
#include "ser_p.h"
#include <mware/formatwr.h>
#include <cfg/debug.h>
#include <appconfig.h>

#include <string.h> /* memset */

/*
 * 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_DEFBAUDRATE)
    #error CONFIG_SER_DEFBAUDRATE missing in config.h
#endif

#if CONFIG_KERNEL
    #include <kern/proc.h>
#endif

#if CONFIG_SER_TXTIMEOUT != -1 || CONFIG_SER_RXTIMEOUT != -1
    #include <drv/timer.h>
#endif


struct Serial ser_handles[SER_CNT];

static int ser_putchar(int c, struct Serial *port)
{
    if (fifo_isfull_locked(&port->txfifo))
    {
#if CONFIG_SER_TXTIMEOUT != -1
        /* If timeout == 0 we don't want to wait */
        if (port->txtimeout == 0)
            return EOF;

        ticks_t start_time = timer_clock();
#endif

        /* Wait while buffer is full... */
        do
        {
            wdt_reset();
#if CONFIG_KERNEL && CONFIG_KERN_SCHED
            /* Give up timeslice to other processes. */
            proc_switch();
#endif
#if CONFIG_SER_TXTIMEOUT != -1
            if (timer_clock() - start_time >= port->txtimeout)
            {
                ATOMIC(port->status |= SERRF_TXTIMEOUT);
                return EOF;
            }
#endif /* CONFIG_SER_TXTIMEOUT */
        }
        while (fifo_isfull_locked(&port->txfifo));
    }

    fifo_push_locked(&port->txfifo, (unsigned char)c);

    /* (re)trigger tx interrupt */
    port->hw->table->txStart(port->hw);

    /* Avoid returning signed extended char */
    return (int)((unsigned char)c);
}


static int ser_getchar(struct Serial *port)
{
    if (fifo_isempty_locked(&port->rxfifo))
    {
#if CONFIG_SER_RXTIMEOUT != -1
        /* If timeout == 0 we don't want to wait for chars */
        if (port->rxtimeout == 0)
            return EOF;

        ticks_t start_time = timer_clock();
#endif
        /* Wait while buffer is empty */
        do
        {
            wdt_reset();
#if CONFIG_KERNEL && CONFIG_KERN_SCHED
            /* Give up timeslice to other processes. */
            proc_switch();
#endif
#if CONFIG_SER_RXTIMEOUT != -1
            if (timer_clock() - start_time >= port->rxtimeout)
            {
                ATOMIC(port->status |= SERRF_RXTIMEOUT);
                return EOF;
            }
#endif /* CONFIG_SER_RXTIMEOUT */
        }
        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.
     */
    if (ser_getstatus(port) & SERRF_RX)
        return EOF;
    return (int)(unsigned char)fifo_pop_locked(&port->rxfifo);
}

int ser_getchar_nowait(struct KFileSerial *fd)
{
    if (fifo_isempty_locked(&fd->ser->rxfifo))
        return EOF;

    /* NOTE: the double cast prevents unwanted sign extension */
    return (int)(unsigned char)fifo_pop_locked(&fd->ser->rxfifo);
}



static size_t ser_read(struct KFile *fd, void *_buf, size_t size)
{
    KFileSerial *fds = KFILESERIAL(fd);

    size_t i = 0;
    char *buf = (char *)_buf;
    int c;

    while (i < size)
    {
        if ((c = ser_getchar(fds->ser)) == EOF)
            break;
        buf[i++] = c;
    }

    return i;
}

static size_t ser_write(struct KFile *fd, const void *_buf, size_t size)
{
    KFileSerial *fds = KFILESERIAL(fd);
    const char *buf = (const char *)_buf;
    size_t i = 0;

    while (size--)
    {
        if (ser_putchar(*buf++, fds->ser) == EOF)
            break;
        i++;
    }
    return i;
}


#if CONFIG_SER_RXTIMEOUT != -1 || CONFIG_SER_TXTIMEOUT != -1
void ser_settimeouts(struct KFileSerial *fd, mtime_t rxtimeout, mtime_t txtimeout)
{
    fd->ser->rxtimeout = ms_to_ticks(rxtimeout);
    fd->ser->txtimeout = ms_to_ticks(txtimeout);
}
#endif /* CONFIG_SER_RXTIMEOUT || CONFIG_SER_TXTIMEOUT */

#if CONFIG_SER_RXTIMEOUT != -1

void ser_resync(struct KFileSerial *fd, mtime_t delay)
{
    mtime_t old_rxtimeout = ticks_to_ms(fd->ser->rxtimeout);

    ser_settimeouts(fd, delay, ticks_to_ms(fd->ser->txtimeout));
    do
    {
        ser_setstatus(fd->ser, 0);
        ser_getchar(fd->ser);
    }
    while (!(ser_getstatus(fd->ser) & SERRF_RXTIMEOUT));

    /* Restore port to an usable status */
    ser_setstatus(fd->ser, 0);
    ser_settimeouts(fd, old_rxtimeout, ticks_to_ms(fd->ser->txtimeout));
}
#endif /* CONFIG_SER_RXTIMEOUT */


void ser_setbaudrate(struct KFileSerial *fd, unsigned long rate)
{
    fd->ser->hw->table->setBaudrate(fd->ser->hw, rate);
}


void ser_setparity(struct KFileSerial *fd, int parity)
{
    fd->ser->hw->table->setParity(fd->ser->hw, parity);
}

static int ser_error(struct KFile *fd)
{
    KFileSerial *fds = KFILESERIAL(fd);
    return ser_getstatus(fds->ser);
}

static void ser_clearerr(struct KFile *fd)
{
    KFileSerial *fds = KFILESERIAL(fd);
    ser_setstatus(fds->ser, 0);
}



void ser_purge(struct KFileSerial *fd)
{
    ser_purgeRx(fd);
    ser_purgeTx(fd);
}

void ser_purgeRx(struct KFileSerial *fd)
{
    fifo_flush_locked(&fd->ser->rxfifo);
}

void ser_purgeTx(struct KFileSerial *fd)
{
    fifo_flush_locked(&fd->ser->txfifo);
}


static int ser_flush(struct KFile *fd)
{
    KFileSerial *fds = KFILESERIAL(fd);

    /*
     * Wait until the FIFO becomes empty, and then until the byte currently in
     * the hardware register gets shifted out.
     */
    while (!fifo_isempty(&fds->ser->txfifo)
           || fds->ser->hw->table->txSending(fds->ser->hw))
    {
        #if CONFIG_KERNEL && CONFIG_KERN_SCHED
            /* Give up timeslice to other processes. */
            proc_switch();
        #endif
            wdt_reset();
    }
    return 0;
}


static struct Serial *ser_open(struct KFileSerial *fd, 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->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);

    fd->ser = port;
    /* Set default values */
#if CONFIG_SER_RXTIMEOUT != -1 || CONFIG_SER_TXTIMEOUT != -1
    ser_settimeouts(fd, CONFIG_SER_RXTIMEOUT, CONFIG_SER_TXTIMEOUT);
#endif
#if CONFIG_SER_DEFBAUDRATE
    ser_setbaudrate(fd, CONFIG_SER_DEFBAUDRATE);
#endif

    /* Clear error flags */
    ser_setstatus(port, 0);

    return port;
}


static int ser_close(struct KFile *fd)
{
    KFileSerial *fds = KFILESERIAL(fd);
    Serial *port = fds->ser;

    ASSERT(port->is_open);
    DB(port->is_open = false);

    // Wait until we finish sending everything
    ser_flush(fd);

    port->hw->table->cleanup(port->hw);
    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(fds);
    return 0;
}

static struct KFile *ser_reopen(struct KFile *fd)
{
    KFileSerial *fds = KFILESERIAL(fd);

    ser_close(fd);
    ser_open(fds, fds->ser->unit);
    return (KFile *)fds;
}

void ser_init(struct KFileSerial *fds, unsigned int unit)
{
    memset(fds, 0, sizeof(*fds));

    DB(fds->fd._type = KFT_SERIAL);
    fds->fd.reopen = ser_reopen;
    fds->fd.close = ser_close;
    fds->fd.read = ser_read;
    fds->fd.write = ser_write;
    fds->fd.flush = ser_flush;
    fds->fd.error = ser_error;
    fds->fd.clearerr = ser_clearerr;
    ser_open(fds, unit);
}


static size_t spimaster_read(struct KFile *fd, void *_buf, size_t size)
{
    KFileSerial *fd_spi = KFILESERIAL(fd);

    ser_flush(&fd_spi->fd);
    ser_purgeRx(fd_spi);

    size_t total_rd = 0;
    uint8_t *buf = (uint8_t *)_buf;
    int c;

    while (size--)
    {
        /*
         * Send and receive chars 1 by 1, otherwise the rxfifo
         * will overrun.
         */
        ser_putchar(0, fd_spi->ser);

        if ((c = ser_getchar(fd_spi->ser)) == EOF)
            break;

        *buf++ = c;
        total_rd++;
    }
    return total_rd;
}

static size_t spimaster_write(struct KFile *fd, const void *buf, size_t size)
{
    KFileSerial *fd_spi = KFILESERIAL(fd);

    ser_purgeRx(fd_spi);

    return ser_write(&fd_spi->fd, buf, size);
}


void spimaster_init(KFileSerial *fds, unsigned int unit)
{
    ser_init(fds, unit);
    fds->fd.read = spimaster_read;
    fds->fd.write = spimaster_write;
}