Serial.cxx

Go to the documentation of this file.

 
#include <cstdint>
#include <fcntl.h>
#include "Devtab.hxx"
#include "Serial.hxx"
#include "can_ioctl.h"
 
void Serial::flush_buffers()
{
    if (txBuf)
    {
        txBuf->flush();
    }
    if (rxBuf)
    {
        rxBuf->flush();
    }
}
 
ssize_t Serial::read(File *file, void *buf, size_t count)
{
    unsigned char *data = (unsigned char *)buf;
    ssize_t result = 0;
 
    while (count)
    {
        portENTER_CRITICAL();
        /* We limit the amount of bytes we read with each iteration in order
         * to limit the amount of time that interrupts are disabled and
         * preserve our real-time performance.
         */
        size_t bytes_read = rxBuf->get(data, count < 64 ? count : 64);
        portEXIT_CRITICAL();
 
        if (bytes_read == 0)
        {
            /* no more data to receive */
            if ((file->flags & O_NONBLOCK) || result > 0)
            {
                break;
            }
            else
            {
                /* wait for data to come in, this call will release the
                 * critical section lock.
                 */
                rxBuf->block_until_condition(file, true);
            }
        }
 
        count -= bytes_read;
        result += bytes_read;
        data += bytes_read;
    }
 
    if (!result && (file->flags & O_NONBLOCK))
    {
        return -EAGAIN;
    }
 
    return result;
}
 
ssize_t Serial::write(File *file, const void *buf, size_t count)
{
    const unsigned char *data = (const unsigned char *)buf;
    ssize_t result = 0;
 
    while (count)
    {
        portENTER_CRITICAL();
        /* We limit the amount of bytes we write with each iteration in order
         * to limit the amount of time that interrupts are disabled and
         * preserve our real-time performance.
         */
        size_t bytes_written = txBuf->put(data, count < 64 ? count : 64);
 
        if (bytes_written == 0)
        {
            portEXIT_CRITICAL();
            /* no more data to receive */
            if ((file->flags & O_NONBLOCK) || result > 0)
            {
                break;
            }
            else
            {
                /* wait for space to be available, this call will release the
                 * critical section lock.
                 */
                txBuf->block_until_condition(file, false);
            }
        }
        else
        {
            tx_char();
            portEXIT_CRITICAL();
            count -= bytes_written;
            result += bytes_written;
            data += bytes_written;
        }
    }
 
    if (!result && (file->flags & O_NONBLOCK))
    {
        return -EAGAIN;
    }
 
    return result;
}
 
int Serial::ioctl(File *file, unsigned long int key, unsigned long data)
{
    return -1;
}
 
bool Serial::select(File *file, int mode)
{
    bool retval = false;
    switch (mode)
    {
        case FREAD:
            portENTER_CRITICAL();
            if (rxBuf->pending() > 0)
            {
                retval = true;
            }
            else
            {
                rxBuf->select_insert();
            }
            portEXIT_CRITICAL();
            break;
        case FWRITE:
            portENTER_CRITICAL();
            if (txBuf->space() > 0)
            {
                retval = true;
            }
            else
            {
                txBuf->select_insert();
            }
            portEXIT_CRITICAL();
            break;
        default:
        case 0:
            /* we don't support any exceptions */
            break;
    }
    return retval;
}