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.
 */
#ifdef CONFIG_RING_BUFFER_LARGE
typedef uint32_t ring_buf_idx_t;
#define RING_BUFFER_MAX_SIZE (UINT32_MAX / 2)
#define RING_BUFFER_SIZE_ASSERT_MSG "Size too big"
#else
typedef uint16_t ring_buf_idx_t;
#define RING_BUFFER_MAX_SIZE (UINT16_MAX / 2)
#define RING_BUFFER_SIZE_ASSERT_MSG "Size too big, please enable CONFIG_RING_BUFFER_LARGE"
#endif
 
 
struct ring_buf_index { ring_buf_idx_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, ring_buf_idx_t value)
{
        buf->put.head = value;
        buf->put.tail = value;
        buf->put.base = value;
        buf->get.head = value;
        buf->get.tail = value;
        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);
}

__deprecated /* use #include <zephyr/sys/ringq.h> instead */
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(const 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(const struct ring_buf *buf)
{
        ring_buf_idx_t allocated = buf->put.head - buf->get.tail;
 
        return buf->size - allocated;
}

__deprecated /* use #include <zephyr/sys/ringq.h> instead */
static inline uint32_t ring_buf_item_space_get(const struct ring_buf *buf)
{
        return ring_buf_space_get(buf) / 4;
}

static inline uint32_t ring_buf_capacity_get(const struct ring_buf *buf)
{
        return buf->size;
}

static inline uint32_t ring_buf_size_get(const struct ring_buf *buf)
{
        ring_buf_idx_t available = buf->put.tail - buf->get.head;
 
        return available;
}

static inline uint32_t ring_buf_put_ptr(struct ring_buf *buf, uint8_t **data, size_t offset)
{
        struct ring_buf_index *ring = &buf->put;
        ring_buf_idx_t head_offset, wrap_size, space;
 
        __ASSERT_NO_MSG(offset <= ring_buf_space_get(buf));
        head_offset = ring->head - ring->base + offset;
        if (unlikely(head_offset >= buf->size)) {
                head_offset -= buf->size;
        }
 
        space = ring_buf_space_get(buf) - offset;
        wrap_size = buf->size - head_offset;
        *data = &buf->buffer[head_offset];
        return MIN(space, wrap_size);
}

static inline void ring_buf_commit(struct ring_buf *buf, size_t size)
{
        ring_buf_idx_t tail_offset;
        struct ring_buf_index *ring = &buf->put;
 
        __ASSERT_NO_MSG(size <= ring_buf_space_get(buf));
        ring->tail += size;
        ring->head = ring->tail;
 
        tail_offset = ring->tail - ring->base;
        if (unlikely(tail_offset >= buf->size)) {
                /* we wrapped: adjust ring->base */
                ring->base += buf->size;
        }
}

static inline uint32_t ring_buf_put_claim(struct ring_buf *buf,
                                          uint8_t **data,
                                          uint32_t size)
{
        uint32_t space = ring_buf_space_get(buf);
        return ring_buf_area_claim(buf, &buf->put, data,
                                   MIN(size, space));
}

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_ptr(struct ring_buf *buf, uint8_t **data, size_t offset)
{
        struct ring_buf_index *ring = &buf->get;
        ring_buf_idx_t head_offset, wrap_size, size;
 
        __ASSERT_NO_MSG(offset <= ring_buf_size_get(buf));
        head_offset = ring->head - ring->base + offset;
        if (unlikely(head_offset >= buf->size)) {
                head_offset -= buf->size;
        }
 
        size = ring_buf_size_get(buf) - offset;
        wrap_size = buf->size - head_offset;
        *data = &buf->buffer[head_offset];
        return MIN(size, wrap_size);
}

static inline void ring_buf_consume(struct ring_buf *buf, size_t size)
{
        ring_buf_idx_t tail_offset;
        struct ring_buf_index *ring = &buf->get;
 
        __ASSERT_NO_MSG(size <= ring_buf_size_get(buf));
        ring->tail += size;
        ring->head = ring->tail;
 
        tail_offset = ring->tail - ring->base;
        if (unlikely(tail_offset >= buf->size)) {
                /* we wrapped: adjust ring->base */
                ring->base += buf->size;
        }
}

static inline uint32_t ring_buf_get_claim(struct ring_buf *buf,
                                          uint8_t **data,
                                          uint32_t size)
{
        uint32_t buf_size = ring_buf_size_get(buf);
        return ring_buf_area_claim(buf, &buf->get, data,
                                   MIN(size, buf_size));
}

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);

__deprecated /* use #include <zephyr/sys/ringq.h> instead */
int ring_buf_item_put(struct ring_buf *buf, uint16_t type, uint8_t value,
                      uint32_t *data, uint8_t size32);

__deprecated /* use #include <zephyr/sys/ringq.h> instead */
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_ */