/*
 * This is a simple FIFO implementation using a circular buffer.
 *
 * Heavily inspired by http://lwn.net/Articles/101808/
 * 
 * Could probably generalise in a similar fashion to sys/queue.h
 *
 */

#include <assert.h>
#include <pthread.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>

#define min(a, b)		\
   ({ __typeof__ (a) _a = (a);	\
       __typeof__ (b) _b = (b);	\
       _a < _b ? _a : _b; })

struct fifo {
    unsigned int	rdidx;
    unsigned int	wridx;
    unsigned int	size;
    unsigned int	len;
    uint8_t		buffer[0];
};

/*
 * fifo_alloc - allocates a new FIFO
 * @size: the size of the internal buffer.
 *
 */
struct fifo *
fifo_alloc(unsigned int size) {
    struct fifo		*fifo;

    if ((fifo = malloc(sizeof(struct fifo) + size)) == NULL)
	return NULL;
	
    fifo->rdidx = fifo->wridx = 0;
    fifo->size = size;
    fifo->len = 0;

    return fifo;
}

/*
 * fifo_free - frees the FIFO
 * @fifo: the fifo to be freed.
 */
void
fifo_free(struct fifo *fifo) {
    free(fifo);
}

/*
 * fifo_reset - removes the entire FIFO contents
 * @fifo: the fifo to be emptied.
 */
void
fifo_reset(struct fifo *fifo) {

    fifo->rdidx = fifo->wridx = 0;
    fifo->len = 0;
}

/*
 * fifo_put - puts some data into the FIFO
 * @fifo: the fifo to be used.
 * @buffer: the data to be added.
 * @len: the length of the data to be added.
 *
 * This function copies at most 'len' bytes from the 'buffer' into
 * the FIFO depending on the free space, and returns the number of
 * bytes copied. 
 */
unsigned int
fifo_put(struct fifo *fifo, uint8_t *buffer, unsigned int len) {
    unsigned int	total, remaining;
	
    total = remaining = min(len, fifo->size - fifo->len);
    while (remaining > 0) {
	unsigned int l = min(remaining, fifo->size - fifo->wridx);
	memcpy(fifo->buffer + fifo->wridx, buffer, l);
	fifo->wridx += l;
	fifo->wridx %= fifo->size;
	fifo->len += l;
	buffer += l;
	remaining -= l;
    }

    return total;
}

/*
 * fifo_get - gets some data from the FIFO
 * @fifo: the fifo to be used.
 * @buffer: where the data must be copied.
 * @len: the size of the destination buffer.
 *
 * This function copies at most 'len' bytes from the FIFO into the
 * 'buffer' and returns the number of copied bytes.
 */
unsigned int
fifo_get(struct fifo *fifo, uint8_t *buffer, unsigned int len) {
    unsigned int	total, remaining;

    total = remaining = min(len, fifo->len);
    while (remaining > 0) {
	unsigned int l = min(remaining, fifo->size - fifo->rdidx);
	memcpy(buffer, fifo->buffer + fifo->rdidx, l);
	fifo->rdidx += l;
	fifo->rdidx %= fifo->size;
	fifo->len -= l;
	buffer += l;
	remaining -= l;
    }

    return total;
}

/*
 * fifo_unget - puts some data into the FIFO head
 * @fifo: the fifo to be used.
 * @buffer: the data to be added.
 * @len: the length of the data to be added.
 *
 * This function copies at most 'len' bytes from the 'buffer' into
 * the FIFO depending on the free space, and returns the number of
 * bytes copied. 
 */
unsigned int
fifo_unget(struct fifo *fifo, uint8_t *buffer, unsigned int len) {
    unsigned int	total, remaining, l;
    int			dst;
    
    total = remaining = min(len, fifo->size - fifo->len);

    /* Index to start putting data back */
    dst = fifo->rdidx - len;
    while (dst < 0)
	dst += fifo->size;
    
    while (remaining > 0) {
	l = min(remaining, fifo->size - dst);
	memcpy(fifo->buffer + dst, buffer, l);

	fifo->len += l;
	buffer += l;
	remaining -= l;
    }

    fifo->rdidx = dst;
    
    return total;
}

/*
 * fifo_avail - returns the number of bytes available for reading in the FIFO
 * @fifo: the fifo to be used.
 */
unsigned int
fifo_avail(struct fifo *fifo) {
    unsigned int	result;
	
    result = fifo->len;

    return result;
}

/*
 * fifo_space - returns the number of bytes available for writing in the FIFO
 * @fifo: the fifo to be used.
 */
unsigned int
fifo_space(struct fifo *fifo) {
    unsigned int	result;
	
    result = fifo->size - fifo->len;

    return result;
}
