common/Can.cxx

Go to the documentation of this file.

 
#include <cstdint>
#include <algorithm>
#include <fcntl.h>
#include "Devtab.hxx"
#include "Can.hxx"
#include "can_frame.h"
 
unsigned Can::numReceivedPackets_{0};
unsigned Can::numTransmittedPackets_{0};
 
void Can::flush_buffers()
{
    txBuf->flush();
    rxBuf->flush();
}
 
ssize_t Can::read(File *file, void *buf, size_t count)
{
    HASSERT((count % sizeof(struct can_frame)) == 0);
 
    struct can_frame *data = (struct can_frame*)buf;
    ssize_t result = 0;
    
    count /= sizeof(struct can_frame);
 
    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 frames_read = rxBuf->get(data, count < 8 ? count : 8);
        portEXIT_CRITICAL();
 
        if (frames_read == 0)
        {
            /* no more data to receive */
            if ((file->flags & O_NONBLOCK) || result > 0)
            {
                break;
            }
            else
            {
                /* wait for data to come in */
                rxBuf->block_until_condition(file, true);
            }
        }
 
        count -= frames_read;
        result += frames_read;
        data += frames_read;
    }
 
    if (!result && (file->flags & O_NONBLOCK))
    {
        return -EAGAIN;
    }
 
    return result * sizeof(struct can_frame);
}
 
ssize_t Can::write(File *file, const void *buf, size_t count)
{
    HASSERT((count % sizeof(struct can_frame)) == 0);
 
    const struct can_frame *data = (const struct can_frame*)buf;
    ssize_t result = 0;
 
    count /= sizeof(struct can_frame);
 
    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 frames_written = txBuf->put(data, count < 8 ? count : 8);
 
        if (frames_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_msg();
            portEXIT_CRITICAL();
            result += frames_written;
            count -= frames_written;
            data += frames_written;
        }
    }
 
    if (!result && (file->flags & O_NONBLOCK))
    {
        return -EAGAIN;
    }
 
    return result * sizeof(struct can_frame);
}
 
bool Can::select(File* file, int mode)
{
    portENTER_CRITICAL();
    bool retval = false;
    switch (mode)
    {
        case FREAD:
            if (rxBuf->pending() > 0)
            {
                retval = true;
            }
            else
            {
                rxBuf->select_insert();
            }
            break;
        case FWRITE:
            if (txBuf->space() > 0)
            {
                retval = true;
            }
            else
            {
                txBuf->select_insert();
            }
            break;
        default:
        case 0:
            /* we don't support any exceptions */
            break;
    }
    portEXIT_CRITICAL();
 
    return retval;
}