fifobuf.h

Go to the documentation of this file.

#ifndef STRUCT_FIFO_H
#define STRUCT_FIFO_H

#include <cpu/types.h>
#include <cpu/irq.h>
#include <cfg/debug.h>

typedef struct FIFOBuffer
{
    unsigned char * volatile head;
    unsigned char * volatile tail;
    unsigned char *begin;
    unsigned char *end;
} FIFOBuffer;


#define ASSERT_VALID_FIFO(fifo) \
    ATOMIC( \
        ASSERT((fifo)->head >= (fifo)->begin); \
        ASSERT((fifo)->head <= (fifo)->end); \
        ASSERT((fifo)->tail >= (fifo)->begin); \
        ASSERT((fifo)->tail <= (fifo)->end); \
    )


INLINE bool fifo_isempty(const FIFOBuffer *fb)
{
    //ASSERT_VALID_FIFO(fb);
    return fb->head == fb->tail;
}


INLINE bool fifo_isfull(const FIFOBuffer *fb)
{
    //ASSERT_VALID_FIFO(fb);
    return
        ((fb->head == fb->begin) && (fb->tail == fb->end))
        || (fb->tail == fb->head - 1);
}


INLINE void fifo_push(FIFOBuffer *fb, unsigned char c)
{
#ifdef __MWERKS__
#pragma interrupt called
#endif
    //ASSERT_VALID_FIFO(fb);

    /* Write at tail position */
    *(fb->tail) = c;

    if (UNLIKELY(fb->tail == fb->end))
        /* wrap tail around */
        fb->tail = fb->begin;
    else
        /* Move tail forward */
        fb->tail++;
}


INLINE unsigned char fifo_pop(FIFOBuffer *fb)
{
#ifdef __MWERKS__
#pragma interrupt called
#endif
    //ASSERT_VALID_FIFO(fb);

    if (UNLIKELY(fb->head == fb->end))
    {
        /* wrap head around */
        fb->head = fb->begin;
        return *(fb->end);
    }
    else
        /* move head forward */
        return *(fb->head++);
}


INLINE void fifo_flush(FIFOBuffer *fb)
{
    //ASSERT_VALID_FIFO(fb);
    fb->head = fb->tail;
}


#if CPU_REG_BITS >= CPU_BITS_PER_PTR

    /*
     * 16/32bit CPUs that can update a pointer with a single write
     * operation, no need to disable interrupts.
     */
    #define fifo_isempty_locked(fb) fifo_isempty((fb))
    #define fifo_push_locked(fb, c) fifo_push((fb), (c))
    #define fifo_pop_locked(fb)     fifo_pop((fb))
    #define fifo_flush_locked(fb)   fifo_flush((fb))

#else /* CPU_REG_BITS < CPU_BITS_PER_PTR */

    INLINE bool fifo_isempty_locked(const FIFOBuffer *fb)
    {
        bool result;
        ATOMIC(result = fifo_isempty(fb));
        return result;
    }


    INLINE void fifo_push_locked(FIFOBuffer *fb, unsigned char c)
    {
        ATOMIC(fifo_push(fb, c));
    }

    /* Probably not really needed, but hard to prove. */
    INLINE unsigned char fifo_pop_locked(FIFOBuffer *fb)
    {
        unsigned char c;
        ATOMIC(c = fifo_pop(fb));
        return c;
    }

    INLINE void fifo_flush_locked(FIFOBuffer *fb)
    {
        ATOMIC(fifo_flush(fb));
    }

#endif /* CPU_REG_BITS < BITS_PER_PTR */


INLINE bool fifo_isfull_locked(const FIFOBuffer *_fb)
{
    bool result;
    ATOMIC(result = fifo_isfull(_fb));
    return result;
}


INLINE void fifo_init(FIFOBuffer *fb, unsigned char *buf, size_t size)
{
    /* FIFO buffers have a known bug with 1-byte buffers. */
    ASSERT(size > 1);

    fb->head = fb->tail = fb->begin = buf;
    fb->end = buf + size - 1;
}

INLINE size_t fifo_len(FIFOBuffer *fb)
{
    return fb->end - fb->begin;
}


#if 0

/*
 * UNTESTED: if uncommented, to be moved in fifobuf.c
 */
void fifo_pushblock(FIFOBuffer *fb, unsigned char *block, size_t len)
{
    size_t freelen;

    /* Se c'e' spazio da tail alla fine del buffer */
    if (fb->tail >= fb->head)
    {
        freelen = fb->end - fb->tail + 1;

        /* C'e' abbastanza spazio per scrivere tutto il blocco? */
        if (freelen < len)
        {
            /* Scrivi quello che entra fino alla fine del buffer */
            memcpy(fb->tail, block, freelen);
            block += freelen;
            len -= freelen;
            fb->tail = fb->begin;
        }
        else
        {
            /* Scrivi tutto il blocco */
            memcpy(fb->tail, block, len);
            fb->tail += len;
            return;
        }
    }

    for(;;)
    {
        while (!(freelen = fb->head - fb->tail - 1))
            Delay(FIFO_POLLDELAY);

        /* C'e' abbastanza spazio per scrivere tutto il blocco? */
        if (freelen < len)
        {
            /* Scrivi quello che entra fino alla fine del buffer */
            memcpy(fb->tail, block, freelen);
            block += freelen;
            len -= freelen;
            fb->tail += freelen;
        }
        else
        {
            /* Scrivi tutto il blocco */
            memcpy(fb->tail, block, len);
            fb->tail += len;
            return;
        }
    }
}
#endif

#endif /* STRUCT_FIFO_H */