/**
|
*******************************************************************************
|
* @file ring_buffer.h
|
* @create 2024
|
* @author Panchip BLE GROUP
|
* @note
|
* Copyright (c) 2024 Shanghai Panchip Microelectronics Co.,Ltd.
|
*
|
*******************************************************************************
|
*/
|
|
/** @file */
|
|
#ifndef ZEPHYR_INCLUDE_SYS_RING_BUFFER_H_
|
#define ZEPHYR_INCLUDE_SYS_RING_BUFFER_H_
|
|
// #include <kernel.h>
|
// #include <sys/util.h>
|
#include "PanSeries.h"
|
#include <string.h>
|
|
#ifdef __cplusplus
|
extern "C" {
|
#endif
|
|
#define __ASSERT(test, fmt, ...) { }
|
#define __ASSERT_EVAL(expr1, expr2, test, fmt, ...) expr1
|
#define __ASSERT_NO_MSG(test) { if (!test) { while (1); } }
|
|
#define likely(x) __builtin_expect(!!(x), 1)
|
#define unlikely(x) __builtin_expect(!!(x), 0)
|
|
/**
|
* @def Z_MIN
|
* @brief The smaller value between @p a and @p b.
|
* @note Arguments are evaluated twice.
|
*/
|
/* Use Z_MIN for a GCC-only, single evaluation version */
|
#define Z_MIN(a, b) (((a) < (b)) ? (a) : (b))
|
|
/**
|
* @brief Is @p x a power of two?
|
* @param x value to check
|
* @return true if @p x is a power of two, false otherwise
|
*/
|
static inline bool is_power_of_two(unsigned int x)
|
{
|
return (x != 0U) && ((x & (x - 1U)) == 0U);
|
}
|
|
#define Z_EPERM 1 /**< Not owner */
|
#define Z_ENOENT 2 /**< No such file or directory */
|
#define Z_ESRCH 3 /**< No such context */
|
#define Z_EINTR 4 /**< Interrupted system call */
|
#define Z_EIO 5 /**< I/O error */
|
#define Z_ENXIO 6 /**< No such device or address */
|
#define Z_E2BIG 7 /**< Arg list too long */
|
#define Z_ENOEXEC 8 /**< Exec format error */
|
#define Z_EBADF 9 /**< Bad file number */
|
#define Z_ECHILD 10 /**< No children */
|
#define Z_EAGAIN 11 /**< No more contexts */
|
#define Z_ENOMEM 12 /**< Not enough core */
|
#define Z_EACCES 13 /**< Permission denied */
|
#define Z_EFAULT 14 /**< Bad address */
|
#define Z_ENOTBLK 15 /**< Block device required */
|
#define Z_EBUSY 16 /**< Mount device busy */
|
#define Z_EEXIST 17 /**< File exists */
|
#define Z_EXDEV 18 /**< Cross-device link */
|
#define Z_ENODEV 19 /**< No such device */
|
#define Z_ENOTDIR 20 /**< Not a directory */
|
#define Z_EISDIR 21 /**< Is a directory */
|
#define Z_EINVAL 22 /**< Invalid argument */
|
#define Z_ENFILE 23 /**< File table overflow */
|
#define Z_EMFILE 24 /**< Too many open files */
|
#define Z_ENOTTY 25 /**< Not a typewriter */
|
#define Z_ETXTBSY 26 /**< Text file busy */
|
#define Z_EFBIG 27 /**< File too large */
|
#define Z_ENOSPC 28 /**< No space left on device */
|
#define Z_ESPIPE 29 /**< Illegal seek */
|
#define Z_EROFS 30 /**< Read-only file system */
|
#define Z_EMLINK 31 /**< Too many links */
|
#define Z_EPIPE 32 /**< Broken pipe */
|
#define Z_EDOM 33 /**< Argument too large */
|
#define Z_ERANGE 34 /**< Result too large */
|
#define Z_ENOMSG 35 /**< Unexpected message type */
|
#define Z_EDEADLK 45 /**< Resource deadlock avoided */
|
#define Z_ENOLCK 46 /**< No locks available */
|
#define Z_ENOSTR 60 /**< STREAMS device required */
|
#define Z_ENODATA 61 /**< Missing expected message data */
|
#define Z_ETIME 62 /**< STREAMS timeout occurred */
|
#define Z_ENOSR 63 /**< Insufficient memory */
|
#define Z_EPROTO 71 /**< Generic STREAMS error */
|
#define Z_EBADMSG 77 /**< Invalid STREAMS message */
|
#define Z_ENOSYS 88 /**< Function not implemented */
|
#define Z_ENOTEMPTY 90 /**< Directory not empty */
|
#define Z_ENAMETOOLONG 91 /**< File name too long */
|
#define Z_ELOOP 92 /**< Too many levels of symbolic links */
|
#define Z_EOPNOTSUPP 95 /**< Operation not supported on socket */
|
#define Z_EPFNOSUPPORT 96 /**< Protocol family not supported */
|
#define Z_ECONNRESET 104 /**< Connection reset by peer */
|
#define Z_ENOBUFS 105 /**< No buffer space available */
|
#define Z_EAFNOSUPPORT 106 /**< Addr family not supported */
|
#define Z_EPROTOTYPE 107 /**< Protocol wrong type for socket */
|
#define Z_ENOTSOCK 108 /**< Socket operation on non-socket */
|
#define Z_ENOPROTOOPT 109 /**< Protocol not available */
|
#define Z_ESHUTDOWN 110 /**< Can't send after socket shutdown */
|
#define Z_ECONNREFUSED 111 /**< Connection refused */
|
#define Z_EADDRINUSE 112 /**< Address already in use */
|
#define Z_ECONNABORTED 113 /**< Software caused connection abort */
|
#define Z_ENETUNREACH 114 /**< Network is unreachable */
|
#define Z_ENETDOWN 115 /**< Network is down */
|
#define Z_ETIMEDOUT 116 /**< Connection timed out */
|
#define Z_EHOSTDOWN 117 /**< Host is down */
|
#define Z_EHOSTUNREACH 118 /**< No route to host */
|
#define Z_EINPROGRESS 119 /**< Operation now in progress */
|
#define Z_EALREADY 120 /**< Operation already in progress */
|
#define Z_EDESTADDRREQ 121 /**< Destination address required */
|
#define Z_EMSGSIZE 122 /**< Message size */
|
#define Z_EPROTONOSUPPORT 123 /**< Protocol not supported */
|
#define Z_ESOCKTNOSUPPORT 124 /**< Socket type not supported */
|
#define Z_EADDRNOTAVAIL 125 /**< Can't assign requested address */
|
#define Z_ENETRESET 126 /**< Network dropped connection on reset */
|
#define Z_EISCONN 127 /**< Socket is already connected */
|
#define Z_ENOTCONN 128 /**< Socket is not connected */
|
#define Z_ETOOMANYREFS 129 /**< Too many references: can't splice */
|
#define Z_ENOTSUP 134 /**< Unsupported value */
|
#define Z_EILSEQ 138 /**< Illegal byte sequence */
|
#define Z_EOVERFLOW 139 /**< Value overflow */
|
#define Z_ECANCELED 140 /**< Operation canceled */
|
|
#define Z_EWOULDBLOCK EAGAIN /**< Operation would block */
|
|
#define SIZE32_OF(x) (sizeof((x)) / sizeof(uint32_t))
|
|
/* The limit is used by algorithm for distinguishing between empty and full
|
* state.
|
*/
|
#define RING_BUFFER_MAX_SIZE 0x80000000
|
|
#define RING_BUFFER_SIZE_ASSERT_MSG \
|
"Size too big, if it is the ring buffer test check custom max size"
|
/**
|
* @brief A structure to represent a ring buffer
|
*/
|
struct ring_buf {
|
uint32_t head; /**< Index in buf for the head element */
|
uint32_t tail; /**< Index in buf for the tail element */
|
union ring_buf_misc {
|
struct ring_buf_misc_item_mode {
|
uint32_t dropped_put_count; /**< Running tally of the
|
* number of failed put
|
* attempts.
|
*/
|
} item_mode;
|
struct ring_buf_misc_byte_mode {
|
uint32_t tmp_tail;
|
uint32_t tmp_head;
|
} byte_mode;
|
} misc;
|
uint32_t size; /**< Size of buf in 32-bit chunks */
|
|
union ring_buf_buffer {
|
uint32_t *buf32; /**< Memory region for stored entries */
|
uint8_t *buf8;
|
} buf;
|
uint32_t mask; /**< Modulo mask if size is a power of 2 */
|
|
// struct k_spinlock lock;
|
};
|
|
/**
|
* @defgroup ring_buffer_apis Ring Buffer APIs
|
* @ingroup datastructure_apis
|
* @{
|
*/
|
|
/**
|
* @brief Define and initialize a high performance ring buffer.
|
*
|
* This macro establishes a ring buffer whose size must be a power of 2;
|
* that is, the ring buffer contains 2^pow 32-bit words, where @a pow is
|
* the specified ring buffer size exponent. A high performance ring buffer
|
* doesn't require the use of modulo arithmetic operations to maintain itself.
|
*
|
* The ring buffer can be accessed outside the module where it is defined
|
* using:
|
*
|
* @code extern struct ring_buf <name>; @endcode
|
*
|
* @param name Name of the ring buffer.
|
* @param pow Ring buffer size exponent.
|
*/
|
#define RING_BUF_ITEM_DECLARE_POW2(name, pow) \
|
BUILD_ASSERT((1 << pow) < RING_BUFFER_MAX_SIZE, \
|
RING_BUFFER_SIZE_ASSERT_MSG); \
|
static uint32_t __noinit _ring_buffer_data_##name[BIT(pow)]; \
|
struct ring_buf name = { \
|
.size = (BIT(pow)), \
|
.mask = (BIT(pow)) - 1, \
|
.buf = { .buf32 = _ring_buffer_data_##name } \
|
}
|
|
/**
|
* @brief Define and initialize a standard ring buffer.
|
*
|
* This macro establishes a ring buffer of an arbitrary size. A standard
|
* ring buffer uses modulo arithmetic operations to maintain itself.
|
*
|
* The ring buffer can be accessed outside the module where it is defined
|
* using:
|
*
|
* @code extern struct ring_buf <name>; @endcode
|
*
|
* @param name Name of the ring buffer.
|
* @param size32 Size of ring buffer (in 32-bit words).
|
*/
|
#define RING_BUF_ITEM_DECLARE_SIZE(name, size32) \
|
BUILD_ASSERT(size32 < RING_BUFFER_MAX_SIZE, \
|
RING_BUFFER_SIZE_ASSERT_MSG); \
|
static uint32_t __noinit _ring_buffer_data_##name[size32]; \
|
struct ring_buf name = { \
|
.size = size32, \
|
.buf = { .buf32 = _ring_buffer_data_##name } \
|
}
|
|
/**
|
* @brief Define and initialize a ring buffer for byte data.
|
*
|
* This macro establishes a ring buffer of an arbitrary size.
|
*
|
* The ring buffer can be accessed outside the module where it is defined
|
* using:
|
*
|
* @code extern struct ring_buf <name>; @endcode
|
*
|
* @param name Name of the ring buffer.
|
* @param size8 Size of ring buffer (in bytes).
|
*/
|
#define RING_BUF_DECLARE(name, size8) \
|
BUILD_ASSERT(size8 < RING_BUFFER_MAX_SIZE, \
|
RING_BUFFER_SIZE_ASSERT_MSG); \
|
static uint8_t __noinit _ring_buffer_data_##name[size8]; \
|
struct ring_buf name = { \
|
.size = size8, \
|
.buf = { .buf8 = _ring_buffer_data_##name } \
|
}
|
|
|
/**
|
* @brief Initialize a ring buffer.
|
*
|
* This routine initializes a ring buffer, prior to its first use. It is only
|
* used for ring buffers not defined using RING_BUF_DECLARE,
|
* RING_BUF_ITEM_DECLARE_POW2 or RING_BUF_ITEM_DECLARE_SIZE.
|
*
|
* Setting @a size to a power of 2 establishes a high performance ring buffer
|
* that doesn't require the use of modulo arithmetic operations to maintain
|
* itself.
|
*
|
* @param buf Address of ring buffer.
|
* @param size Ring buffer size (in 32-bit words or bytes).
|
* @param data Ring buffer data area (uint32_t data[size] or uint8_t data[size]
|
* for bytes mode).
|
*/
|
static inline void ring_buf_init(struct ring_buf *buf,
|
uint32_t size,
|
void *data)
|
{
|
__ASSERT(size < RING_BUFFER_MAX_SIZE, RING_BUFFER_SIZE_ASSERT_MSG);
|
|
memset(buf, 0, sizeof(struct ring_buf));
|
buf->size = size;
|
buf->buf.buf32 = (uint32_t *)data;
|
if (is_power_of_two(size)) {
|
buf->mask = size - 1U;
|
} else {
|
buf->mask = 0U;
|
}
|
}
|
|
/**
|
* @brief Determine if a ring buffer is empty.
|
*
|
* @param buf Address of ring buffer.
|
*
|
* @return 1 if the ring buffer is empty, or 0 if not.
|
*/
|
int ring_buf_is_empty(struct ring_buf *buf);
|
|
/**
|
* @brief Reset ring buffer state.
|
*
|
* @param buf Address of ring buffer.
|
*/
|
static inline void ring_buf_reset(struct ring_buf *buf)
|
{
|
buf->head = 0;
|
buf->tail = 0;
|
memset(&buf->misc, 0, sizeof(buf->misc));
|
}
|
|
/**
|
* @brief Determine free space in a ring buffer.
|
*
|
* @param buf Address of ring buffer.
|
*
|
* @return Ring buffer free space (in 32-bit words or bytes).
|
*/
|
uint32_t ring_buf_space_get(struct ring_buf *buf);
|
|
/**
|
* @brief Return ring buffer capacity.
|
*
|
* @param buf Address of ring buffer.
|
*
|
* @return Ring buffer capacity (in 32-bit words or bytes).
|
*/
|
static inline uint32_t ring_buf_capacity_get(struct ring_buf *buf)
|
{
|
return buf->size;
|
}
|
|
/**
|
* @brief Determine used space in a ring buffer.
|
*
|
* @param buf Address of ring buffer.
|
*
|
* @return Ring buffer space used (in 32-bit words or bytes).
|
*/
|
uint32_t ring_buf_size_get(struct ring_buf *buf);
|
|
/**
|
* @brief Write a data item to a ring buffer.
|
*
|
* This routine writes a data item to ring buffer @a buf. The data item
|
* is an array of 32-bit words (from zero to 1020 bytes in length),
|
* coupled with a 16-bit type identifier and an 8-bit integer value.
|
*
|
* @warning
|
* Use cases involving multiple writers to the ring buffer must prevent
|
* concurrent write operations, either by preventing all writers from
|
* being preempted or by using a mutex to govern writes to the ring buffer.
|
*
|
* @param buf Address of ring buffer.
|
* @param type Data item's type identifier (application specific).
|
* @param value Data item's integer value (application specific).
|
* @param data Address of data item.
|
* @param size32 Data item size (number of 32-bit words).
|
*
|
* @retval 0 Data item was written.
|
* @retval -EMSGSIZE Ring buffer has insufficient free space.
|
*/
|
int ring_buf_item_put(struct ring_buf *buf, uint16_t type, uint8_t value,
|
uint32_t *data, uint8_t size32);
|
|
/**
|
* @brief Read a data item from a ring buffer.
|
*
|
* This routine reads a data item from ring buffer @a buf. The data item
|
* is an array of 32-bit words (up to 1020 bytes in length),
|
* coupled with a 16-bit type identifier and an 8-bit integer value.
|
*
|
* @warning
|
* Use cases involving multiple reads of the ring buffer must prevent
|
* concurrent read operations, either by preventing all readers from
|
* being preempted or by using a mutex to govern reads to the ring buffer.
|
*
|
* @param buf Address of ring buffer.
|
* @param type Area to store the data item's type identifier.
|
* @param value Area to store the data item's integer value.
|
* @param data Area to store the data item. Can be NULL to discard data.
|
* @param size32 Size of the data item storage area (number of 32-bit chunks).
|
*
|
* @retval 0 Data item was fetched; @a size32 now contains the number of
|
* 32-bit words read into data area @a data.
|
* @retval -EAGAIN Ring buffer is empty.
|
* @retval -EMSGSIZE Data area @a data is too small; @a size32 now contains
|
* the number of 32-bit words needed.
|
*/
|
int ring_buf_item_get(struct ring_buf *buf, uint16_t *type, uint8_t *value,
|
uint32_t *data, uint8_t *size32);
|
|
/**
|
* @brief Allocate buffer for writing data to a ring buffer.
|
*
|
* With this routine, memory copying can be reduced since internal ring buffer
|
* can be used directly by the user. Once data is written to allocated area
|
* number of bytes written can be confirmed (see @ref ring_buf_put_finish).
|
*
|
* @warning
|
* Use cases involving multiple writers to the ring buffer must prevent
|
* concurrent write operations, either by preventing all writers from
|
* being preempted or by using a mutex to govern writes to the ring buffer.
|
*
|
* @warning
|
* Ring buffer instance should not mix byte access and item access
|
* (calls prefixed with ring_buf_item_).
|
*
|
* @param[in] buf Address of ring buffer.
|
* @param[out] data Pointer to the address. It is set to a location within
|
* ring buffer.
|
* @param[in] size Requested allocation size (in bytes).
|
*
|
* @return Size of allocated buffer which can be smaller than requested if
|
* there is not enough free space or buffer wraps.
|
*/
|
uint32_t ring_buf_put_claim(struct ring_buf *buf,
|
uint8_t **data,
|
uint32_t size);
|
|
/**
|
* @brief Indicate number of bytes written to allocated buffers.
|
*
|
* @warning
|
* Use cases involving multiple writers to the ring buffer must prevent
|
* concurrent write operations, either by preventing all writers from
|
* being preempted or by using a mutex to govern writes to the ring buffer.
|
*
|
* @warning
|
* Ring buffer instance should not mix byte access and item access
|
* (calls prefixed with ring_buf_item_).
|
*
|
* @param buf Address of ring buffer.
|
* @param size Number of valid bytes in the allocated buffers.
|
*
|
* @retval 0 Successful operation.
|
* @retval -EINVAL Provided @a size exceeds free space in the ring buffer.
|
*/
|
int ring_buf_put_finish(struct ring_buf *buf, uint32_t size);
|
|
/**
|
* @brief Write (copy) data to a ring buffer.
|
*
|
* This routine writes data to a ring buffer @a buf.
|
*
|
* @warning
|
* Use cases involving multiple writers to the ring buffer must prevent
|
* concurrent write operations, either by preventing all writers from
|
* being preempted or by using a mutex to govern writes to the ring buffer.
|
*
|
* @warning
|
* Ring buffer instance should not mix byte access and item access
|
* (calls prefixed with ring_buf_item_).
|
*
|
* @param buf Address of ring buffer.
|
* @param data Address of data.
|
* @param size Data size (in bytes).
|
*
|
* @retval Number of bytes written.
|
*/
|
uint32_t ring_buf_put(struct ring_buf *buf, const uint8_t *data, uint32_t size);
|
|
/**
|
* @brief Get address of a valid data in a ring buffer.
|
*
|
* With this routine, memory copying can be reduced since internal ring buffer
|
* can be used directly by the user. Once data is processed it can be freed
|
* using @ref ring_buf_get_finish.
|
*
|
* @warning
|
* Use cases involving multiple reads of the ring buffer must prevent
|
* concurrent read operations, either by preventing all readers from
|
* being preempted or by using a mutex to govern reads to the ring buffer.
|
*
|
* @warning
|
* Ring buffer instance should not mix byte access and item access
|
* (calls prefixed with ring_buf_item_).
|
*
|
* @param[in] buf Address of ring buffer.
|
* @param[out] data Pointer to the address. It is set to a location within
|
* ring buffer.
|
* @param[in] size Requested size (in bytes).
|
*
|
* @return Number of valid bytes in the provided buffer which can be smaller
|
* than requested if there is not enough free space or buffer wraps.
|
*/
|
uint32_t ring_buf_get_claim(struct ring_buf *buf,
|
uint8_t **data,
|
uint32_t size);
|
|
/**
|
* @brief Indicate number of bytes read from claimed buffer.
|
*
|
* @warning
|
* Use cases involving multiple reads of the ring buffer must prevent
|
* concurrent read operations, either by preventing all readers from
|
* being preempted or by using a mutex to govern reads to the ring buffer.
|
*
|
* @warning
|
* Ring buffer instance should not mix byte access and item mode
|
* (calls prefixed with ring_buf_item_).
|
*
|
* @param buf Address of ring buffer.
|
* @param size Number of bytes that can be freed.
|
*
|
* @retval 0 Successful operation.
|
* @retval -EINVAL Provided @a size exceeds valid bytes in the ring buffer.
|
*/
|
int ring_buf_get_finish(struct ring_buf *buf, uint32_t size);
|
|
/**
|
* @brief Read data from a ring buffer.
|
*
|
* This routine reads data from a ring buffer @a buf.
|
*
|
* @warning
|
* Use cases involving multiple reads of the ring buffer must prevent
|
* concurrent read operations, either by preventing all readers from
|
* being preempted or by using a mutex to govern reads to the ring buffer.
|
*
|
* @warning
|
* Ring buffer instance should not mix byte access and item mode
|
* (calls prefixed with ring_buf_item_).
|
*
|
* @param buf Address of ring buffer.
|
* @param data Address of the output buffer. Can be NULL to discard data.
|
* @param size Data size (in bytes).
|
*
|
* @retval Number of bytes written to the output buffer.
|
*/
|
uint32_t ring_buf_get(struct ring_buf *buf, uint8_t *data, uint32_t size);
|
|
/**
|
* @brief Peek at data from a ring buffer.
|
*
|
* This routine reads data from a ring buffer @a buf without removal.
|
*
|
* @warning
|
* Use cases involving multiple reads of the ring buffer must prevent
|
* concurrent read operations, either by preventing all readers from
|
* being preempted or by using a mutex to govern reads to the ring buffer.
|
*
|
* @warning
|
* Ring buffer instance should not mix byte access and item mode
|
* (calls prefixed with ring_buf_item_).
|
*
|
* @warning
|
* Multiple calls to peek will result in the same data being 'peeked'
|
* multiple times. To remove data, use either @ref ring_buf_get or
|
* @ref ring_buf_get_claim followed by @ref ring_buf_get_finish with a
|
* non-zero `size`.
|
*
|
* @param buf Address of ring buffer.
|
* @param data Address of the output buffer. Cannot be NULL.
|
* @param size Data size (in bytes).
|
*
|
* @retval Number of bytes written to the output buffer.
|
*/
|
uint32_t ring_buf_peek(struct ring_buf *buf, uint8_t *data, uint32_t size);
|
|
/**
|
* @brief Get data pointer from a ring buffer.
|
*
|
* This routine get data pointer from a ring buffer @a buf.
|
*
|
* @warning
|
* Use cases involving multiple reads of the ring buffer must prevent
|
* concurrent read operations, either by preventing all readers from
|
* being preempted or by using a mutex to govern reads to the ring buffer.
|
*
|
* @warning
|
* Ring buffer instance should not mix byte access and item mode
|
* (calls prefixed with ring_buf_item_).
|
*
|
* @param buf Address of ring buffer.
|
* @param data Address of the output buffer. Can be NULL to discard data.
|
* @param size Data size (in bytes).
|
*
|
* @retval Address of the output buffer.
|
*/
|
uint8_t *ring_buf_get_direct(struct ring_buf *buf, uint8_t *data, uint32_t size);
|
|
/**
|
* @brief Set data pointer to a ring buffer.
|
*
|
* This routine set data pointer to a ring buffer @a buf.
|
*
|
* @warning
|
* Use cases involving multiple writers to the ring buffer must prevent
|
* concurrent write operations, either by preventing all writers from
|
* being preempted or by using a mutex to govern writes to the ring buffer.
|
*
|
* @warning
|
* Ring buffer instance should not mix byte access and item access
|
* (calls prefixed with ring_buf_item_).
|
*
|
* @param buf Address of ring buffer.
|
* @param data Address of data.
|
* @param size Data size (in bytes).
|
*
|
* @retval buf Address of of bytes set.
|
*/
|
uint8_t *ring_buf_put_direct(struct ring_buf *buf, uint8_t *data, uint32_t size);
|
|
#ifdef __cplusplus
|
}
|
#endif
|
|
#endif /* ZEPHYR_INCLUDE_SYS_RING_BUFFER_H_ */
|
