update fifo
This commit is contained in:
parent
45ea2ff358
commit
c961bb47fe
|
@ -7,7 +7,7 @@
|
||||||
|
|
||||||
Software License Agreement (BSD License)
|
Software License Agreement (BSD License)
|
||||||
|
|
||||||
Copyright (c) 2013, hathach (tinyusb.org)
|
Copyright (c) 2018, hathach (tinyusb.org)
|
||||||
All rights reserved.
|
All rights reserved.
|
||||||
|
|
||||||
Redistribution and use in source and binary forms, with or without
|
Redistribution and use in source and binary forms, with or without
|
||||||
|
@ -35,18 +35,36 @@
|
||||||
This file is part of the tinyusb stack.
|
This file is part of the tinyusb stack.
|
||||||
*/
|
*/
|
||||||
/**************************************************************************/
|
/**************************************************************************/
|
||||||
#include <string.h>
|
|
||||||
#include "fifo.h"
|
#include "fifo.h"
|
||||||
|
|
||||||
//static inline void mutex_lock (fifo_t* f) ATTR_ALWAYS_INLINE;
|
/*------------------------------------------------------------------*/
|
||||||
//static inline void mutex_unlock (fifo_t* f) ATTR_ALWAYS_INLINE;
|
/*
|
||||||
#define mutex_lock(f)
|
*------------------------------------------------------------------*/
|
||||||
#define mutex_unlock(f)
|
#if CFG_FIFO_MUTEX
|
||||||
|
|
||||||
static inline bool is_fifo_initalized(fifo_t* f) ATTR_ALWAYS_INLINE;
|
#define mutex_lock_if_needed(_ff) if (_ff->mutex) fifo_mutex_lock(_ff->mutex)
|
||||||
|
#define mutex_unlock_if_needed(_ff) if (_ff->mutex) fifo_mutex_unlock(_ff->mutex)
|
||||||
|
|
||||||
|
#else
|
||||||
|
|
||||||
|
#define mutex_lock_if_needed(_ff)
|
||||||
|
#define mutex_unlock_if_needed(_ff)
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
||||||
|
static inline uint16_t min16_of(uint16_t x, uint16_t y)
|
||||||
|
{
|
||||||
|
return (x < y) ? x : y;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool fifo_initalized(fifo_t* f)
|
||||||
|
{
|
||||||
|
return (f->buffer != NULL) && (f->depth > 0) && (f->item_size > 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
/**************************************************************************/
|
/******************************************************************************/
|
||||||
/*!
|
/*!
|
||||||
@brief Read one byte out of the RX buffer.
|
@brief Read one byte out of the RX buffer.
|
||||||
|
|
||||||
|
@ -56,20 +74,18 @@ static inline bool is_fifo_initalized(fifo_t* f) ATTR_ALWAYS_INLINE;
|
||||||
|
|
||||||
@param[in] f
|
@param[in] f
|
||||||
Pointer to the FIFO buffer to manipulate
|
Pointer to the FIFO buffer to manipulate
|
||||||
@param[in] data
|
@param[in] p_buffer
|
||||||
Pointer to the place holder for data read from the buffer
|
Pointer to the place holder for data read from the buffer
|
||||||
|
|
||||||
@returns TRUE if the queue is not empty
|
@returns TRUE if the queue is not empty
|
||||||
*/
|
*/
|
||||||
/**************************************************************************/
|
/******************************************************************************/
|
||||||
bool fifo_read(fifo_t* f, void * p_buffer)
|
bool fifo_read(fifo_t* f, void * p_buffer)
|
||||||
{
|
{
|
||||||
if( !is_fifo_initalized(f) || fifo_is_empty(f) )
|
if( !fifo_initalized(f) ) return false;
|
||||||
{
|
if( fifo_is_empty(f) ) return false;
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
mutex_lock(f);
|
mutex_lock_if_needed(f);
|
||||||
|
|
||||||
memcpy(p_buffer,
|
memcpy(p_buffer,
|
||||||
f->buffer + (f->rd_idx * f->item_size),
|
f->buffer + (f->rd_idx * f->item_size),
|
||||||
|
@ -77,36 +93,108 @@ bool fifo_read(fifo_t* f, void * p_buffer)
|
||||||
f->rd_idx = (f->rd_idx + 1) % f->depth;
|
f->rd_idx = (f->rd_idx + 1) % f->depth;
|
||||||
f->count--;
|
f->count--;
|
||||||
|
|
||||||
mutex_unlock(f);
|
mutex_unlock_if_needed(f);
|
||||||
|
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
/**************************************************************************/
|
/******************************************************************************/
|
||||||
/*!
|
/*!
|
||||||
@brief Write one byte into the RX buffer.
|
@brief This function will read n elements into the array index specified by
|
||||||
|
|
||||||
This function will write one byte into the array index specified by
|
|
||||||
the write pointer and increment the write index. If the write index
|
the write pointer and increment the write index. If the write index
|
||||||
exceeds the max buffer size, then it will roll over to zero.
|
exceeds the max buffer size, then it will roll over to zero.
|
||||||
|
|
||||||
@param[in] f
|
@param[in] f
|
||||||
Pointer to the FIFO buffer to manipulate
|
Pointer to the FIFO buffer to manipulate
|
||||||
@param[in] data
|
@param[in] p_data
|
||||||
|
The pointer to data location
|
||||||
|
@param[in] count
|
||||||
|
Number of element that buffer can afford
|
||||||
|
|
||||||
|
@returns number of bytes read from the FIFO
|
||||||
|
*/
|
||||||
|
/******************************************************************************/
|
||||||
|
uint16_t fifo_read_n (fifo_t* f, void * p_buffer, uint16_t count)
|
||||||
|
{
|
||||||
|
if( !fifo_initalized(f) ) return false;
|
||||||
|
if( fifo_is_empty(f) ) return false;
|
||||||
|
|
||||||
|
/* Limit up to fifo's count */
|
||||||
|
count = min16_of(count, f->count);
|
||||||
|
if( count == 0 ) return 0;
|
||||||
|
|
||||||
|
mutex_lock_if_needed(f);
|
||||||
|
|
||||||
|
/* Could copy up to 2 portions marked as 'x' if queue is wrapped around
|
||||||
|
* case 1: ....RxxxxW.......
|
||||||
|
* case 2: xxxxxW....Rxxxxxx
|
||||||
|
*/
|
||||||
|
// uint16_t index2upper = min16_of(count, f->count-f->rd_idx);
|
||||||
|
|
||||||
|
uint8_t* p_buf = (uint8_t*) p_buffer;
|
||||||
|
uint16_t len = 0;
|
||||||
|
while( (len < count) && fifo_read(f, p_buf) )
|
||||||
|
{
|
||||||
|
len++;
|
||||||
|
p_buf += f->item_size;
|
||||||
|
}
|
||||||
|
|
||||||
|
mutex_unlock_if_needed(f);
|
||||||
|
|
||||||
|
return len;
|
||||||
|
}
|
||||||
|
|
||||||
|
/******************************************************************************/
|
||||||
|
/*!
|
||||||
|
@brief Reads one item without removing it from the FIFO
|
||||||
|
|
||||||
|
@param[in] f
|
||||||
|
Pointer to the FIFO buffer to manipulate
|
||||||
|
@param[in] position
|
||||||
|
Position to read from in the FIFO buffer
|
||||||
|
@param[in] p_buffer
|
||||||
|
Pointer to the place holder for data read from the buffer
|
||||||
|
|
||||||
|
@returns TRUE if the queue is not empty
|
||||||
|
*/
|
||||||
|
/******************************************************************************/
|
||||||
|
bool fifo_peek_at(fifo_t* f, uint16_t position, void * p_buffer)
|
||||||
|
{
|
||||||
|
if ( !fifo_initalized(f) ) return false;
|
||||||
|
if ( position >= f->count ) return false;
|
||||||
|
|
||||||
|
// rd_idx is position=0
|
||||||
|
uint16_t index = (f->rd_idx + position) % f->depth;
|
||||||
|
memcpy(p_buffer,
|
||||||
|
f->buffer + (index * f->item_size),
|
||||||
|
f->item_size);
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
/******************************************************************************/
|
||||||
|
/*!
|
||||||
|
@brief Write one element into the RX buffer.
|
||||||
|
|
||||||
|
This function will write one element into the array index specified by
|
||||||
|
the write pointer and increment the write index. If the write index
|
||||||
|
exceeds the max buffer size, then it will roll over to zero.
|
||||||
|
|
||||||
|
@param[in] f
|
||||||
|
Pointer to the FIFO buffer to manipulate
|
||||||
|
@param[in] p_data
|
||||||
The byte to add to the FIFO
|
The byte to add to the FIFO
|
||||||
|
|
||||||
@returns TRUE if the data was written to the FIFO (overwrittable
|
@returns TRUE if the data was written to the FIFO (overwrittable
|
||||||
FIFO will always return TRUE)
|
FIFO will always return TRUE)
|
||||||
*/
|
*/
|
||||||
/**************************************************************************/
|
/******************************************************************************/
|
||||||
bool fifo_write(fifo_t* f, void const * p_data)
|
bool fifo_write(fifo_t* f, void const * p_data)
|
||||||
{
|
{
|
||||||
if ( !is_fifo_initalized(f) || (fifo_is_full(f) && !f->overwritable) )
|
if ( !fifo_initalized(f) ) return false;
|
||||||
{
|
if ( fifo_is_full(f) && !f->overwritable ) return false;
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
mutex_lock(f);
|
mutex_lock_if_needed(f);
|
||||||
|
|
||||||
memcpy( f->buffer + (f->wr_idx * f->item_size),
|
memcpy( f->buffer + (f->wr_idx * f->item_size),
|
||||||
p_data,
|
p_data,
|
||||||
|
@ -117,75 +205,61 @@ bool fifo_write(fifo_t* f, void const * p_data)
|
||||||
if (fifo_is_full(f))
|
if (fifo_is_full(f))
|
||||||
{
|
{
|
||||||
f->rd_idx = f->wr_idx; // keep the full state (rd == wr && len = size)
|
f->rd_idx = f->wr_idx; // keep the full state (rd == wr && len = size)
|
||||||
}else
|
}
|
||||||
|
else
|
||||||
{
|
{
|
||||||
f->count++;
|
f->count++;
|
||||||
}
|
}
|
||||||
|
|
||||||
mutex_unlock(f);
|
mutex_unlock_if_needed(f);
|
||||||
|
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
/**************************************************************************/
|
/******************************************************************************/
|
||||||
|
/*!
|
||||||
|
@brief This function will write n elements into the array index specified by
|
||||||
|
the write pointer and increment the write index. If the write index
|
||||||
|
exceeds the max buffer size, then it will roll over to zero.
|
||||||
|
|
||||||
|
@param[in] f
|
||||||
|
Pointer to the FIFO buffer to manipulate
|
||||||
|
@param[in] p_data
|
||||||
|
The pointer to data to add to the FIFO
|
||||||
|
@param[in] count
|
||||||
|
Number of element
|
||||||
|
@return Number of written elements
|
||||||
|
*/
|
||||||
|
/******************************************************************************/
|
||||||
|
uint16_t fifo_write_n(fifo_t* f, void const * p_data, uint16_t count)
|
||||||
|
{
|
||||||
|
if ( count == 0 ) return 0;
|
||||||
|
|
||||||
|
uint8_t* p_buf = (uint8_t*) p_data;
|
||||||
|
|
||||||
|
uint16_t len = 0;
|
||||||
|
while( (len < count) && fifo_write(f, p_buf) )
|
||||||
|
{
|
||||||
|
len++;
|
||||||
|
p_buf += f->item_size;
|
||||||
|
}
|
||||||
|
|
||||||
|
return len;
|
||||||
|
}
|
||||||
|
|
||||||
|
/******************************************************************************/
|
||||||
/*!
|
/*!
|
||||||
@brief Clear the fifo read and write pointers and set length to zero
|
@brief Clear the fifo read and write pointers and set length to zero
|
||||||
|
|
||||||
@param[in] f
|
@param[in] f
|
||||||
Pointer to the FIFO buffer to manipulate
|
Pointer to the FIFO buffer to manipulate
|
||||||
*/
|
*/
|
||||||
/**************************************************************************/
|
/******************************************************************************/
|
||||||
void fifo_clear(fifo_t *f)
|
void fifo_clear(fifo_t *f)
|
||||||
{
|
{
|
||||||
mutex_lock(f);
|
mutex_lock_if_needed(f);
|
||||||
|
|
||||||
f->rd_idx = f->wr_idx = f->count = 0;
|
f->rd_idx = f->wr_idx = f->count = 0;
|
||||||
|
|
||||||
mutex_unlock(f);
|
mutex_unlock_if_needed(f);
|
||||||
}
|
|
||||||
|
|
||||||
//--------------------------------------------------------------------+
|
|
||||||
// HELPER FUNCTIONS
|
|
||||||
//--------------------------------------------------------------------+
|
|
||||||
|
|
||||||
/**************************************************************************/
|
|
||||||
/*!
|
|
||||||
@brief Disables the IRQ specified in the FIFO's 'irq' field
|
|
||||||
to prevent reads/write issues with interrupts
|
|
||||||
|
|
||||||
@param[in] f
|
|
||||||
Pointer to the FIFO that should be protected
|
|
||||||
*/
|
|
||||||
/**************************************************************************/
|
|
||||||
//static inline void mutex_lock (fifo_t* f)
|
|
||||||
//{
|
|
||||||
// if (f->irq > 0)
|
|
||||||
// {
|
|
||||||
// #if !defined (_TEST_)
|
|
||||||
// NVIC_DisableIRQ(f->irq);
|
|
||||||
// #endif
|
|
||||||
// }
|
|
||||||
//}
|
|
||||||
|
|
||||||
/**************************************************************************/
|
|
||||||
/*!
|
|
||||||
@brief Re-enables the IRQ specified in the FIFO's 'irq' field
|
|
||||||
|
|
||||||
@param[in] f
|
|
||||||
Pointer to the FIFO that should be protected
|
|
||||||
*/
|
|
||||||
/**************************************************************************/
|
|
||||||
//static inline void mutex_unlock (fifo_t* f)
|
|
||||||
//{
|
|
||||||
// if (f->irq > 0)
|
|
||||||
// {
|
|
||||||
// #if !defined (_TEST_)
|
|
||||||
// NVIC_EnableIRQ(f->irq);
|
|
||||||
// #endif
|
|
||||||
// }
|
|
||||||
//}
|
|
||||||
|
|
||||||
static inline bool is_fifo_initalized(fifo_t* f)
|
|
||||||
{
|
|
||||||
return !( f->buffer == NULL || f->depth == 0 || f->item_size == 0);
|
|
||||||
}
|
}
|
||||||
|
|
|
@ -7,7 +7,7 @@
|
||||||
|
|
||||||
Software License Agreement (BSD License)
|
Software License Agreement (BSD License)
|
||||||
|
|
||||||
Copyright (c) 2013, hathach (tinyusb.org)
|
Copyright (c) 2018, hathach (tinyusb.org)
|
||||||
All rights reserved.
|
All rights reserved.
|
||||||
|
|
||||||
Redistribution and use in source and binary forms, with or without
|
Redistribution and use in source and binary forms, with or without
|
||||||
|
@ -43,12 +43,36 @@
|
||||||
#ifndef _TUSB_FIFO_H_
|
#ifndef _TUSB_FIFO_H_
|
||||||
#define _TUSB_FIFO_H_
|
#define _TUSB_FIFO_H_
|
||||||
|
|
||||||
#include "common/common.h"
|
#define CFG_FIFO_MUTEX 0
|
||||||
|
|
||||||
|
#include <stdint.h>
|
||||||
|
#include <stdbool.h>
|
||||||
|
#include <string.h>
|
||||||
|
|
||||||
#ifdef __cplusplus
|
#ifdef __cplusplus
|
||||||
extern "C" {
|
extern "C" {
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
#if CFG_FIFO_MUTEX
|
||||||
|
|
||||||
|
/*Mutex port for newt*/
|
||||||
|
#include "os/os_mutex.h"
|
||||||
|
|
||||||
|
#define fifo_mutex_t struct os_mutex
|
||||||
|
|
||||||
|
#define fifo_mutex_lock(m) os_mutex_pend(m, OS_TIMEOUT_NEVER)
|
||||||
|
#define fifo_mutex_unlock(m) os_mutex_release(m)
|
||||||
|
|
||||||
|
/* Internal use only */
|
||||||
|
#define _mutex_declare(m) .mutex = m
|
||||||
|
|
||||||
|
#else
|
||||||
|
|
||||||
|
#define _mutex_declare(m)
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
||||||
|
|
||||||
/** \struct fifo_t
|
/** \struct fifo_t
|
||||||
* \brief Simple Circular FIFO
|
* \brief Simple Circular FIFO
|
||||||
*/
|
*/
|
||||||
|
@ -61,7 +85,11 @@ typedef struct
|
||||||
volatile uint16_t wr_idx ; ///< write pointer
|
volatile uint16_t wr_idx ; ///< write pointer
|
||||||
volatile uint16_t rd_idx ; ///< read pointer
|
volatile uint16_t rd_idx ; ///< read pointer
|
||||||
bool overwritable ;
|
bool overwritable ;
|
||||||
// IRQn_Type irq;
|
|
||||||
|
#if CFG_FIFO_MUTEX
|
||||||
|
fifo_mutex_t * const mutex;
|
||||||
|
#endif
|
||||||
|
|
||||||
} fifo_t;
|
} fifo_t;
|
||||||
|
|
||||||
#define FIFO_DEF(name, ff_depth, type, is_overwritable) /*, irq_mutex)*/ \
|
#define FIFO_DEF(name, ff_depth, type, is_overwritable) /*, irq_mutex)*/ \
|
||||||
|
@ -72,30 +100,49 @@ typedef struct
|
||||||
.item_size = sizeof(type),\
|
.item_size = sizeof(type),\
|
||||||
.overwritable = is_overwritable,\
|
.overwritable = is_overwritable,\
|
||||||
/*.irq = irq_mutex*/\
|
/*.irq = irq_mutex*/\
|
||||||
|
_mutex_declare(_mutex)\
|
||||||
}
|
}
|
||||||
|
|
||||||
bool fifo_write(fifo_t* f, void const * p_data);
|
|
||||||
bool fifo_read(fifo_t* f, void * p_buffer);
|
|
||||||
void fifo_clear(fifo_t *f);
|
void fifo_clear(fifo_t *f);
|
||||||
|
|
||||||
static inline bool fifo_is_empty(fifo_t* f) ATTR_PURE ATTR_ALWAYS_INLINE;
|
bool fifo_write (fifo_t* f, void const * p_data);
|
||||||
|
uint16_t fifo_write_n (fifo_t* f, void const * p_data, uint16_t count);
|
||||||
|
|
||||||
|
bool fifo_read (fifo_t* f, void * p_buffer);
|
||||||
|
uint16_t fifo_read_n (fifo_t* f, void * p_buffer, uint16_t count);
|
||||||
|
|
||||||
|
bool fifo_peek_at (fifo_t* f, uint16_t position, void * p_buffer);
|
||||||
|
|
||||||
|
static inline bool fifo_peek(fifo_t* f, void * p_buffer)
|
||||||
|
{
|
||||||
|
return fifo_peek_at(f, 0, p_buffer);
|
||||||
|
}
|
||||||
|
|
||||||
static inline bool fifo_is_empty(fifo_t* f)
|
static inline bool fifo_is_empty(fifo_t* f)
|
||||||
{
|
{
|
||||||
return (f->count == 0);
|
return (f->count == 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
static inline bool fifo_is_full(fifo_t* f) ATTR_PURE ATTR_ALWAYS_INLINE;
|
|
||||||
static inline bool fifo_is_full(fifo_t* f)
|
static inline bool fifo_is_full(fifo_t* f)
|
||||||
{
|
{
|
||||||
return (f->count == f->depth);
|
return (f->count == f->depth);
|
||||||
}
|
}
|
||||||
|
|
||||||
static inline uint16_t fifo_get_length(fifo_t* f) ATTR_PURE ATTR_ALWAYS_INLINE;
|
|
||||||
static inline uint16_t fifo_get_length(fifo_t* f)
|
static inline uint16_t fifo_get_length(fifo_t* f)
|
||||||
{
|
{
|
||||||
return f->count;
|
return f->count;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static inline uint16_t fifo_remaining(fifo_t* f)
|
||||||
|
{
|
||||||
|
return f->depth - f->count;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline uint16_t fifo_depth(fifo_t* f)
|
||||||
|
{
|
||||||
|
return f->depth;
|
||||||
|
}
|
||||||
|
|
||||||
#ifdef __cplusplus
|
#ifdef __cplusplus
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
Loading…
Reference in New Issue