fifo.c

/* --COPYRIGHT--,BSD

 * Copyright (c) 2010, Texas Instruments Incorporated

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 * *  Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 *

 * *  Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * *  Neither the name of Texas Instruments Incorporated nor the names of

 *    its contributors may be used to endorse or promote products derived

 *    from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;

 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,

 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,

 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 * --/COPYRIGHT--*/

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <pthread.h>

#include "fifo.h"

#define MODULE_NAME     "Fifo"

typedef struct Fifo_Object {

    pthread_mutex_t mutex;

    int             numBufs;

    short           flush;

    int             pipes[2];

} Fifo_Object;

const Fifo_Attrs Fifo_Attrs_DEFAULT = {

    0

};

/******************************************************************************

 * Fifo_create

 ******************************************************************************/

Fifo_Handle Fifo_create(Fifo_Attrs *attrs)

{

    Fifo_Handle hFifo;

    if (attrs == NULL) {

        printf("NULL attrs not supported\n");

        return NULL;

    }

    hFifo = calloc(1, sizeof(Fifo_Object));

    if (hFifo == NULL) {

        printf("Failed to allocate space for Fifo Object\n");

        return NULL;

    }

    if (pipe(hFifo->pipes)) {

        free(hFifo);

        return NULL;

    }

    pthread_mutex_init(&hFifo->mutex, NULL);

    return hFifo;

}

/******************************************************************************

 * Fifo_delete

 ******************************************************************************/

int Fifo_delete(Fifo_Handle hFifo)

{

    int ret = FIFO_EOK;

    if (hFifo) {

        if (close(hFifo->pipes[0])) {

            ret = FIFO_EIO;

        }

        if (close(hFifo->pipes[1])) {

            ret = FIFO_EIO;

        }

        pthread_mutex_destroy(&hFifo->mutex);

        free(hFifo);

    }

    return ret;

}

/******************************************************************************

 * Fifo_get

 ******************************************************************************/

int Fifo_get(Fifo_Handle hFifo, void** ptrPtr)

{

    int flush;

    int numBytes;

    //assert(hFifo);

    //assert(ptrPtr);

    pthread_mutex_lock(&hFifo->mutex);

    flush = hFifo->flush;

    pthread_mutex_unlock(&hFifo->mutex);

    if (flush) {

        return FIFO_EFLUSH;

    }

    numBytes = read(hFifo->pipes[0], *ptrPtr, sizeof(void*));

    if (numBytes != sizeof(void*)) {

        pthread_mutex_lock(&hFifo->mutex);

        flush = hFifo->flush;

        if (flush) {

            hFifo->flush = 0;

        }

        pthread_mutex_unlock(&hFifo->mutex);

        if (flush) {

            return FIFO_EFLUSH;

        }

        return FIFO_EIO;

    }

    pthread_mutex_lock(&hFifo->mutex);

    hFifo->numBufs--;

    pthread_mutex_unlock(&hFifo->mutex);

    return FIFO_EOK;

}

/******************************************************************************

 * Fifo_flush

 ******************************************************************************/

int Fifo_flush(Fifo_Handle hFifo)

{

    char ch = 0xff;

    //assert(hFifo);

    pthread_mutex_lock(&hFifo->mutex);

    hFifo->flush = 1;

    pthread_mutex_unlock(&hFifo->mutex);

    /* Make sure any Fifo_get() calls are unblocked */

    if (write(hFifo->pipes[1], &ch, 1) != 1) {

        return FIFO_EIO;

    }

    return FIFO_EOK;

}

/******************************************************************************

 * Fifo_put

 ******************************************************************************/

int Fifo_put(Fifo_Handle hFifo, void* ptr)

{

    //assert(hFifo);

    //assert(ptr);

    pthread_mutex_lock(&hFifo->mutex);

    hFifo->numBufs++;

    pthread_mutex_unlock(&hFifo->mutex);

    if (write(hFifo->pipes[1], &ptr, sizeof(void*)) != sizeof(void*)) {

        return FIFO_EIO;

    }

    return FIFO_EOK;

}

/******************************************************************************

 * Fifo_getNumEntries

 ******************************************************************************/

int Fifo_getNumEntries(Fifo_Handle hFifo)

{

    int numEntries;

    //assert(hFifo);

    pthread_mutex_lock(&hFifo->mutex);

    numEntries = hFifo->numBufs;

    pthread_mutex_unlock(&hFifo->mutex);

    return numEntries;

}