ring_buffer.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_SYS_RING_BUFFER_H_
#define ZEPHYR_INCLUDE_SYS_RING_BUFFER_H_
 
#include <zephyr/sys/util.h>
#include <errno.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* The limit is used by algorithm for distinguishing between empty and full
 * state.
 */
#define RING_BUFFER_MAX_SIZE 0x80000000U
#define RING_BUFFER_SIZE_ASSERT_MSG \
        "Size too big"
 
struct ring_buf_index { int32_t head, tail, base; };
 
struct ring_buf {
        uint8_t *buffer;
        struct ring_buf_index put;
        struct ring_buf_index get;
        uint32_t size;
};
 
uint32_t ring_buf_area_claim(struct ring_buf *buf, struct ring_buf_index *ring,
                             uint8_t **data, uint32_t size);
int ring_buf_area_finish(struct ring_buf *buf, struct ring_buf_index *ring,
                         uint32_t size);
 
static inline void ring_buf_internal_reset(struct ring_buf *buf, int32_t value)
{
        buf->put.head = buf->put.tail = buf->put.base = value;
        buf->get.head = buf->get.tail = buf->get.base = value;
}
 
#define RING_BUF_INIT(buf, size8)       \
{                                       \
        .buffer = buf,                  \
        .size = size8,                  \
}
 
#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 = RING_BUF_INIT(_ring_buffer_data_##name, size8)
 
#define RING_BUF_ITEM_DECLARE(name, size32) \
        BUILD_ASSERT((size32) < RING_BUFFER_MAX_SIZE / 4,\
                RING_BUFFER_SIZE_ASSERT_MSG); \
        static uint32_t __noinit _ring_buffer_data_##name[size32]; \
        struct ring_buf name = { \
                .buffer = (uint8_t *) _ring_buffer_data_##name, \
                .size = 4 * (size32) \
        }
 
#define RING_BUF_ITEM_DECLARE_SIZE(name, size32) \
        RING_BUF_ITEM_DECLARE(name, size32)
 
#define RING_BUF_ITEM_DECLARE_POW2(name, pow) \
        RING_BUF_ITEM_DECLARE(name, BIT(pow))
 
#define RING_BUF_ITEM_SIZEOF(expr) DIV_ROUND_UP(sizeof(expr), sizeof(uint32_t))
 
static inline void ring_buf_init(struct ring_buf *buf,
                                 uint32_t size,
                                 uint8_t *data)
{
        __ASSERT(size < RING_BUFFER_MAX_SIZE, RING_BUFFER_SIZE_ASSERT_MSG);
 
        buf->size = size;
        buf->buffer = data;
        ring_buf_internal_reset(buf, 0);
}
 
static inline void ring_buf_item_init(struct ring_buf *buf,
                                      uint32_t size,
                                      uint32_t *data)
{
        __ASSERT(size < RING_BUFFER_MAX_SIZE / 4, RING_BUFFER_SIZE_ASSERT_MSG);
        ring_buf_init(buf, 4 * size, (uint8_t *)data);
}
 
static inline bool ring_buf_is_empty(struct ring_buf *buf)
{
        return buf->get.head == buf->put.tail;
}
 
static inline void ring_buf_reset(struct ring_buf *buf)
{
        ring_buf_internal_reset(buf, 0);
}
 
static inline uint32_t ring_buf_space_get(struct ring_buf *buf)
{
        return buf->size - (buf->put.head - buf->get.tail);
}
 
static inline uint32_t ring_buf_item_space_get(struct ring_buf *buf)
{
        return ring_buf_space_get(buf) / 4;
}
 
static inline uint32_t ring_buf_capacity_get(struct ring_buf *buf)
{
        return buf->size;
}
 
static inline uint32_t ring_buf_size_get(struct ring_buf *buf)
{
        return buf->put.tail - buf->get.head;
}
 
static inline uint32_t ring_buf_put_claim(struct ring_buf *buf,
                                          uint8_t **data,
                                          uint32_t size)
{
        return ring_buf_area_claim(buf, &buf->put, data,
                                   MIN(size, ring_buf_space_get(buf)));
}
 
static inline int ring_buf_put_finish(struct ring_buf *buf, uint32_t size)
{
        return ring_buf_area_finish(buf, &buf->put, size);
}
 
uint32_t ring_buf_put(struct ring_buf *buf, const uint8_t *data, uint32_t size);
 
static inline uint32_t ring_buf_get_claim(struct ring_buf *buf,
                                          uint8_t **data,
                                          uint32_t size)
{
        return ring_buf_area_claim(buf, &buf->get, data,
                                   MIN(size, ring_buf_size_get(buf)));
}
 
static inline int ring_buf_get_finish(struct ring_buf *buf, uint32_t size)
{
        return ring_buf_area_finish(buf, &buf->get, size);
}
 
uint32_t ring_buf_get(struct ring_buf *buf, uint8_t *data, uint32_t size);
 
uint32_t ring_buf_peek(struct ring_buf *buf, uint8_t *data, uint32_t size);
 
int ring_buf_item_put(struct ring_buf *buf, uint16_t type, uint8_t value,
                      uint32_t *data, uint8_t size32);
 
int ring_buf_item_get(struct ring_buf *buf, uint16_t *type, uint8_t *value,
                      uint32_t *data, uint8_t *size32);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_SYS_RING_BUFFER_H_ */