fifo.h

Go to the documentation of this file.

/* Copyright 2014, Peter A. Bigot
 *
 * 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 the software 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 HOLDER 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.
 */

#ifndef BSPACM_INTERNAL_UTILITY_FIFO_H
#define BSPACM_INTERNAL_UTILITY_FIFO_H

#include <bspacm/core.h>
#include <stddef.h>

typedef struct sFIFO {
  volatile uint16_t head;

  volatile uint16_t tail;

  const uint16_t size;

  volatile uint8_t cell[];
} sFIFO;

#define FIFO_DEFINE_ALLOCATION(allocation_, size_)                      \
  static union {                                                        \
    sFIFO fifo;                                                         \
    uint8_t allocation[(size_) + sizeof(sFIFO)];                        \
  } allocation_ = { { 0, 0, sizeof(allocation_) - offsetof(sFIFO, cell) } }

#define FIFO_FROM_ALLOCATION(allocation_) (&(allocation_).fifo)

#define FIFO_ADJUST_OFFSET(fp_,v_) ((v_) % (fp_)->size)

static BSPACM_CORE_INLINE
void
fifo_reset (sFIFO * fp)
{
  fp->head = 0;
  fp->tail = 0;
}

static BSPACM_CORE_INLINE
uint16_t
fifo_length (const sFIFO * fp)
{
  uint16_t h = fp->head;
  uint16_t t = fp->tail;
  return (h - t) + ((h < t) ? fp->size : 0U);
}

static BSPACM_CORE_INLINE
int
fifo_empty (const sFIFO * fp)
{
  return fp->head == fp->tail;
}

static BSPACM_CORE_INLINE
int
fifo_full (const sFIFO * fp)
{
  return (fp->size - 1) == fifo_length(fp);
}

static BSPACM_CORE_INLINE
int
fifo_pop_tail (sFIFO *fp,
               int force_if_empty)
{
  uint16_t t = fp->tail;
  int was_empty = (fp->head == t);
  int rv = was_empty ? -1 : fp->cell[t];
  if (force_if_empty || (! was_empty)) {
    fp->tail = FIFO_ADJUST_OFFSET(fp, 1U + t);
  }
  return rv;
}

static BSPACM_CORE_INLINE
int
fifo_push_head (sFIFO * fp, uint8_t v)
{
  uint16_t h = fp->head;
  uint16_t t = fp->tail;
  int rv = (h != t);

  fp->cell[h] = v;
  h = FIFO_ADJUST_OFFSET(fp, 1U + h);
  fp->head = h;
  if (h == t) {
    (void)fifo_pop_tail(fp, 1);
    rv = -1;
  }
  return rv;
}

static BSPACM_CORE_INLINE
int
fifo_pop_into_buffer (sFIFO * fp,
                      uint8_t * bps,
                      uint8_t * bpe)
{
  uint16_t h = fp->head;
  uint16_t t = fp->tail;
  uint8_t * bp = bps;
  while ((bp < bpe) && (h != t)) {
    *bp++ = fp->cell[t];
    t = FIFO_ADJUST_OFFSET(fp, 1U + t);
  }
  fp->tail = t;
  return bp - bps;
}

#endif /* BSPACM_INTERNAL_UTILITY_FIFO_H */