[refactor] move utils into component

components/utils/ring_buffer/ring_buffer.c

@@ -0,0 +1,675 @@
+/**
+ * @file ring_buffer.c
+ * @brief
+ *
+ * Copyright (c) 2021 Bouffalolab team
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.  The
+ * ASF licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the
+ * License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+#include "ring_buffer.h"
+
+/** @addtogroup  BL_Common_Component
+ *  @{
+ */
+
+/** @addtogroup  RING_BUFFER
+ *  @{
+ */
+
+/** @defgroup  RING_BUFFER_Private_Macros
+ *  @{
+ */
+
+/*@} end of group RING_BUFFER_Private_Macros */
+
+/** @defgroup  RING_BUFFER_Private_Types
+ *  @{
+ */
+
+/*@} end of group RING_BUFFER_Private_Types */
+
+/** @defgroup  RING_BUFFER_Private_Fun_Declaration
+ *  @{
+ */
+
+/*@} end of group RING_BUFFER_Private_Fun_Declaration */
+
+/** @defgroup  RING_BUFFER_Private_Variables
+ *  @{
+ */
+
+/*@} end of group RING_BUFFER_Private_Variables */
+
+/** @defgroup  RING_BUFFER_Global_Variables
+ *  @{
+ */
+
+/*@} end of group RING_BUFFER_Global_Variables */
+
+/** @defgroup  RING_BUFFER_Private_Functions
+ *  @{
+ */
+
+/*@} end of group RING_BUFFER_Private_Functions */
+
+/** @defgroup  RING_BUFFER_Public_Functions
+ *  @{
+ */
+
+/****************************************************************************/ /**
+ * @brief  Ring buffer init function
+ *
+ * @param  rbType: Ring buffer type structure pointer
+ * @param  buffer: Pointer of ring buffer
+ * @param  size: Size of ring buffer
+ * @param  lockCb: Ring buffer lock callback function pointer
+ * @param  unlockCb: Ring buffer unlock callback function pointer
+ *
+ * @return SUCCESS
+ *
+*******************************************************************************/
+void Ring_Buffer_Init(Ring_Buffer_Type *rbType, uint8_t *buffer, uint32_t size, ringBuffer_Lock_Callback *lockCb, ringBuffer_Lock_Callback *unlockCb)
+{
+    /* Init ring buffer pointer */
+    rbType->pointer = buffer;
+
+    /* Init read/write mirror and index */
+    rbType->readMirror = 0;
+    rbType->readIndex = 0;
+    rbType->writeMirror = 0;
+    rbType->writeIndex = 0;
+
+    /* Set ring buffer size */
+    rbType->size = size;
+
+    /* Set lock and unlock callback function */
+    rbType->lock = lockCb;
+    rbType->unlock = unlockCb;
+}
+
+/****************************************************************************/ /**
+ * @brief  Ring buffer reset function
+ *
+ * @param  rbType: Ring buffer type structure pointer
+ *
+ * @return SUCCESS
+ *
+*******************************************************************************/
+void Ring_Buffer_Reset(Ring_Buffer_Type *rbType)
+{
+    if (rbType->lock != NULL) {
+        rbType->lock();
+    }
+
+    /* Clear read/write mirror and index */
+    rbType->readMirror = 0;
+    rbType->readIndex = 0;
+    rbType->writeMirror = 0;
+    rbType->writeIndex = 0;
+
+    if (rbType->unlock != NULL) {
+        rbType->unlock();
+    }
+}
+
+/****************************************************************************/ /**
+ * @brief  Use callback function to write ring buffer function
+ *
+ * @param  rbType: Ring buffer type structure pointer
+ * @param  length: Length of data want to write
+ * @param  writeCb: Callback function pointer
+ * @param  parameter: Parameter that callback function may use
+ *
+ * @return Length of data actually write
+ *
+*******************************************************************************/
+uint32_t Ring_Buffer_Write_Callback(Ring_Buffer_Type *rbType, uint32_t length, ringBuffer_Write_Callback *writeCb, void *parameter)
+{
+    uint32_t sizeRemained = Ring_Buffer_Get_Empty_Length(rbType);
+
+    if (writeCb == NULL) {
+        return 0;
+    }
+
+    if (rbType->lock != NULL) {
+        rbType->lock();
+    }
+
+    /* Ring buffer has no space for new data */
+    if (sizeRemained == 0) {
+        if (rbType->unlock != NULL) {
+            rbType->unlock();
+        }
+
+        return 0;
+    }
+
+    /* Drop part of data when length out of space remained */
+    if (length > sizeRemained) {
+        length = sizeRemained;
+    }
+
+    /* Get size of space remained in current mirror */
+    sizeRemained = rbType->size - rbType->writeIndex;
+
+    if (sizeRemained > length) {
+        /* Space remained is enough for data in current mirror */
+        writeCb(parameter, &rbType->pointer[rbType->writeIndex], length);
+        rbType->writeIndex += length;
+    } else {
+        /* Data is divided to two parts with different mirror */
+        writeCb(parameter, &rbType->pointer[rbType->writeIndex], sizeRemained);
+        writeCb(parameter, &rbType->pointer[0], length - sizeRemained);
+        rbType->writeIndex = length - sizeRemained;
+        rbType->writeMirror = ~rbType->writeMirror;
+    }
+
+    if (rbType->unlock != NULL) {
+        rbType->unlock();
+    }
+
+    return length;
+}
+
+/****************************************************************************/ /**
+ * @brief  Copy data from data buffer to ring buffer function
+ *
+ * @param  parameter: Pointer to source pointer
+ * @param  dest: Ring buffer to write
+ * @param  length: Length of data to write
+ *
+ * @return None
+ *
+*******************************************************************************/
+static void Ring_Buffer_Write_Copy(void *parameter, uint8_t *dest, uint32_t length)
+{
+    uint8_t **src = (uint8_t **)parameter;
+
+    arch_memcpy_fast(dest, *src, length);
+    *src += length;
+}
+
+/****************************************************************************/ /**
+ * @brief  Write ring buffer function
+ *
+ * @param  rbType: Ring buffer type structure pointer
+ * @param  data: Data to write
+ * @param  length: Length of data
+ *
+ * @return Length of data writted actually
+ *
+*******************************************************************************/
+uint32_t Ring_Buffer_Write(Ring_Buffer_Type *rbType, const uint8_t *data, uint32_t length)
+{
+    return Ring_Buffer_Write_Callback(rbType, length, Ring_Buffer_Write_Copy, &data);
+}
+
+/****************************************************************************/ /**
+ * @brief  Write 1 byte to ring buffer function
+ *
+ * @param  rbType: Ring buffer type structure pointer
+ * @param  data: Data to write
+ *
+ * @return Length of data writted actually
+ *
+*******************************************************************************/
+uint32_t Ring_Buffer_Write_Byte(Ring_Buffer_Type *rbType, const uint8_t data)
+{
+    if (rbType->lock != NULL) {
+        rbType->lock();
+    }
+
+    /* Ring buffer has no space for new data */
+    if (!Ring_Buffer_Get_Empty_Length(rbType)) {
+        if (rbType->unlock != NULL) {
+            rbType->unlock();
+        }
+
+        return 0;
+    }
+
+    rbType->pointer[rbType->writeIndex] = data;
+
+    /* Judge to change index and mirror */
+    if (rbType->writeIndex != (rbType->size - 1)) {
+        rbType->writeIndex++;
+    } else {
+        rbType->writeIndex = 0;
+        rbType->writeMirror = ~rbType->writeMirror;
+    }
+
+    if (rbType->unlock != NULL) {
+        rbType->unlock();
+    }
+
+    return 1;
+}
+
+/****************************************************************************/ /**
+ * @brief  Write ring buffer function, old data will be covered by new data when ring buffer is
+ *         full
+ *
+ * @param  rbType: Ring buffer type structure pointer
+ * @param  data: Data to write
+ * @param  length: Length of data
+ *
+ * @return Length of data writted actually
+ *
+*******************************************************************************/
+uint32_t Ring_Buffer_Write_Force(Ring_Buffer_Type *rbType, const uint8_t *data, uint32_t length)
+{
+    uint32_t sizeRemained = Ring_Buffer_Get_Empty_Length(rbType);
+    uint32_t indexRemained = rbType->size - rbType->writeIndex;
+
+    if (rbType->lock != NULL) {
+        rbType->lock();
+    }
+
+    /* Drop extra data when data length is large than size of ring buffer */
+    if (length > rbType->size) {
+        data = &data[length - rbType->size];
+        length = rbType->size;
+    }
+
+    if (indexRemained > length) {
+        /* Space remained is enough for data in current mirror */
+        arch_memcpy_fast(&rbType->pointer[rbType->writeIndex], data, length);
+        rbType->writeIndex += length;
+
+        /* Update read index */
+        if (length > sizeRemained) {
+            rbType->readIndex = rbType->writeIndex;
+        }
+    } else {
+        /* Data is divided to two parts with different mirror */
+        arch_memcpy_fast(&rbType->pointer[rbType->writeIndex], data, indexRemained);
+        arch_memcpy_fast(&rbType->pointer[0], &data[indexRemained], length - indexRemained);
+        rbType->writeIndex = length - indexRemained;
+        rbType->writeMirror = ~rbType->writeMirror;
+
+        /* Update read index and mirror */
+        if (length > sizeRemained) {
+            rbType->readIndex = rbType->writeIndex;
+            rbType->readMirror = ~rbType->readMirror;
+        }
+    }
+
+    if (rbType->unlock != NULL) {
+        rbType->unlock();
+    }
+
+    return length;
+}
+
+/****************************************************************************/ /**
+ * @brief  Write 1 byte to ring buffer function, old data will be covered by new data when ring
+ *         buffer is full
+ *
+ * @param  rbType: Ring buffer type structure pointer
+ * @param  data: Data to write
+ *
+ * @return Length of data writted actually
+ *
+*******************************************************************************/
+uint32_t Ring_Buffer_Write_Byte_Force(Ring_Buffer_Type *rbType, const uint8_t data)
+{
+    Ring_Buffer_Status_Type status = Ring_Buffer_Get_Status(rbType);
+
+    if (rbType->lock != NULL) {
+        rbType->lock();
+    }
+
+    rbType->pointer[rbType->writeIndex] = data;
+
+    /* Judge to change index and mirror */
+    if (rbType->writeIndex == rbType->size - 1) {
+        rbType->writeIndex = 0;
+        rbType->writeMirror = ~rbType->writeMirror;
+
+        /* Update read index and mirror */
+        if (status == RING_BUFFER_FULL) {
+            rbType->readIndex = rbType->writeIndex;
+            rbType->readMirror = ~rbType->readMirror;
+        }
+    } else {
+        rbType->writeIndex++;
+
+        /* Update read index */
+        if (status == RING_BUFFER_FULL) {
+            rbType->readIndex = rbType->writeIndex;
+        }
+    }
+
+    if (rbType->unlock != NULL) {
+        rbType->unlock();
+    }
+
+    return 1;
+}
+
+/****************************************************************************/ /**
+ * @brief  Use callback function to read ring buffer function
+ *
+ * @param  rbType: Ring buffer type structure pointer
+ * @param  length: Length of data want to read
+ * @param  readCb: Callback function pointer
+ * @param  parameter: Parameter that callback function may use
+ *
+ * @return Length of data actually read
+ *
+*******************************************************************************/
+uint32_t Ring_Buffer_Read_Callback(Ring_Buffer_Type *rbType, uint32_t length, ringBuffer_Read_Callback *readCb, void *parameter)
+{
+    uint32_t size = Ring_Buffer_Get_Length(rbType);
+
+    if (readCb == NULL) {
+        return 0;
+    }
+
+    if (rbType->lock != NULL) {
+        rbType->lock();
+    }
+
+    /* Ring buffer has no data */
+    if (!size) {
+        if (rbType->unlock != NULL) {
+            rbType->unlock();
+        }
+
+        return 0;
+    }
+
+    /* Ring buffer do not have enough data */
+    if (size < length) {
+        length = size;
+    }
+
+    /* Get size of space remained in current mirror */
+    size = rbType->size - rbType->readIndex;
+
+    if (size > length) {
+        /* Read all data needed */
+        readCb(parameter, &rbType->pointer[rbType->readIndex], length);
+        rbType->readIndex += length;
+    } else {
+        /* Read two part of data in different mirror */
+        readCb(parameter, &rbType->pointer[rbType->readIndex], size);
+        readCb(parameter, &rbType->pointer[0], length - size);
+        rbType->readIndex = length - size;
+        rbType->readMirror = ~rbType->readMirror;
+    }
+
+    if (rbType->unlock != NULL) {
+        rbType->unlock();
+    }
+
+    return length;
+}
+
+/****************************************************************************/ /**
+ * @brief  Copy data from ring buffer to data buffer function
+ *
+ * @param  parameter: Pointer to destination pointer
+ * @param  data: Data buffer to copy
+ * @param  length: Length of data to copy
+ *
+ * @return None
+ *
+*******************************************************************************/
+static void Ring_Buffer_Read_Copy(void *parameter, uint8_t *data, uint32_t length)
+{
+    uint8_t **dest = (uint8_t **)parameter;
+
+    arch_memcpy_fast(*dest, data, length);
+    *dest += length;
+}
+
+/****************************************************************************/ /**
+ * @brief  Read ring buffer function
+ *
+ * @param  rbType: Ring buffer type structure pointer
+ * @param  data: Buffer for data read
+ * @param  length: Length of data to read
+ *
+ * @return Length of data read actually
+ *
+*******************************************************************************/
+uint32_t Ring_Buffer_Read(Ring_Buffer_Type *rbType, uint8_t *data, uint32_t length)
+{
+    return Ring_Buffer_Read_Callback(rbType, length, Ring_Buffer_Read_Copy, &data);
+}
+
+/****************************************************************************/ /**
+ * @brief  Read 1 byte from ring buffer function
+ *
+ * @param  rbType: Ring buffer type structure pointer
+ * @param  data: Data read
+ *
+ * @return Length of data actually read
+ *
+*******************************************************************************/
+uint32_t Ring_Buffer_Read_Byte(Ring_Buffer_Type *rbType, uint8_t *data)
+{
+    if (rbType->lock != NULL) {
+        rbType->lock();
+    }
+
+    /* Ring buffer has no data */
+    if (!Ring_Buffer_Get_Length(rbType)) {
+        if (rbType->unlock != NULL) {
+            rbType->unlock();
+        }
+
+        return 0;
+    }
+
+    /* Read data */
+    *data = rbType->pointer[rbType->readIndex];
+
+    /* Update read index and mirror */
+    if (rbType->readIndex == rbType->size - 1) {
+        rbType->readIndex = 0;
+        rbType->readMirror = ~rbType->readMirror;
+    } else {
+        rbType->readIndex++;
+    }
+
+    if (rbType->unlock != NULL) {
+        rbType->unlock();
+    }
+
+    return 1;
+}
+
+/****************************************************************************/ /**
+ * @brief  Read ring buffer function, do not remove from buffer actually
+ *
+ * @param  rbType: Ring buffer type structure pointer
+ * @param  data: Buffer for data read
+ * @param  length: Length of data to read
+ *
+ * @return Length of data read actually
+ *
+*******************************************************************************/
+uint32_t Ring_Buffer_Peek(Ring_Buffer_Type *rbType, uint8_t *data, uint32_t length)
+{
+    uint32_t size = Ring_Buffer_Get_Length(rbType);
+
+    if (rbType->lock != NULL) {
+        rbType->lock();
+    }
+
+    /* Ring buffer has no data */
+    if (!size) {
+        if (rbType->unlock != NULL) {
+            rbType->unlock();
+        }
+
+        return 0;
+    }
+
+    /* Ring buffer do not have enough data */
+    if (size < length) {
+        length = size;
+    }
+
+    /* Get size of space remained in current mirror */
+    size = rbType->size - rbType->readIndex;
+
+    if (size > length) {
+        /* Read all data needed */
+        arch_memcpy_fast(data, &rbType->pointer[rbType->readIndex], length);
+    } else {
+        /* Read two part of data in different mirror */
+        arch_memcpy_fast(data, &rbType->pointer[rbType->readIndex], size);
+        arch_memcpy_fast(&data[size], &rbType->pointer[0], length - size);
+    }
+
+    if (rbType->unlock != NULL) {
+        rbType->unlock();
+    }
+
+    return length;
+}
+
+/****************************************************************************/ /**
+ * @brief  Read 1 byte from ring buffer function, do not remove from buffer actually
+ *
+ * @param  rbType: Ring buffer type structure pointer
+ * @param  data: Data read
+ *
+ * @return Length of data actually read
+ *
+*******************************************************************************/
+uint32_t Ring_Buffer_Peek_Byte(Ring_Buffer_Type *rbType, uint8_t *data)
+{
+    if (rbType->lock != NULL) {
+        rbType->lock();
+    }
+
+    /* Ring buffer has no data */
+    if (!Ring_Buffer_Get_Length(rbType)) {
+        if (rbType->unlock != NULL) {
+            rbType->unlock();
+        }
+
+        return 0;
+    }
+
+    /* Read data */
+    *data = rbType->pointer[rbType->readIndex];
+
+    if (rbType->unlock != NULL) {
+        rbType->unlock();
+    }
+
+    return 1;
+}
+
+/****************************************************************************/ /**
+ * @brief  Get length of data in ring buffer function
+ *
+ * @param  rbType: Ring buffer type structure pointer
+ *
+ * @return Length of data
+ *
+*******************************************************************************/
+uint32_t Ring_Buffer_Get_Length(Ring_Buffer_Type *rbType)
+{
+    uint32_t readMirror = 0;
+    uint32_t writeMirror = 0;
+    uint32_t readIndex = 0;
+    uint32_t writeIndex = 0;
+    uint32_t size = 0;
+
+    if (rbType->lock != NULL) {
+        rbType->lock();
+    }
+
+    readMirror = rbType->readMirror;
+    writeMirror = rbType->writeMirror;
+    readIndex = rbType->readIndex;
+    writeIndex = rbType->writeIndex;
+    size = rbType->size;
+
+    if (rbType->unlock != NULL) {
+        rbType->unlock();
+    }
+
+    if (readMirror == writeMirror) {
+        return writeIndex - readIndex;
+    } else {
+        return size - (readIndex - writeIndex);
+    }
+}
+
+/****************************************************************************/ /**
+ * @brief  Get space remained in ring buffer function
+ *
+ * @param  rbType: Ring buffer type structure pointer
+ *
+ * @return Length of space remained
+ *
+*******************************************************************************/
+uint32_t Ring_Buffer_Get_Empty_Length(Ring_Buffer_Type *rbType)
+{
+    return (rbType->size - Ring_Buffer_Get_Length(rbType));
+}
+
+/****************************************************************************/ /**
+ * @brief  Get ring buffer status function
+ *
+ * @param  rbType: Ring buffer type structure pointer
+ *
+ * @return Status of ring buffer
+ *
+*******************************************************************************/
+Ring_Buffer_Status_Type Ring_Buffer_Get_Status(Ring_Buffer_Type *rbType)
+{
+    if (rbType->lock != NULL) {
+        rbType->lock();
+    }
+
+    /* Judge empty or full */
+    if (rbType->readIndex == rbType->writeIndex) {
+        if (rbType->readMirror == rbType->writeMirror) {
+            if (rbType->unlock != NULL) {
+                rbType->unlock();
+            }
+
+            return RING_BUFFER_EMPTY;
+        } else {
+            if (rbType->unlock != NULL) {
+                rbType->unlock();
+            }
+
+            return RING_BUFFER_FULL;
+        }
+    }
+
+    if (rbType->unlock != NULL) {
+        rbType->unlock();
+    }
+
+    return RING_BUFFER_PARTIAL;
+}
+
+/*@} end of group RING_BUFFER_Public_Functions */
+
+/*@} end of group RING_BUFFER */
+
+/*@} end of group BL_Common_Component */

components/utils/ring_buffer/ring_buffer.h

@@ -0,0 +1,116 @@
+/**
+ * @file ring_buffer.h
+ * @brief
+ *
+ * Copyright (c) 2021 Bouffalolab team
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.  The
+ * ASF licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the
+ * License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+#ifndef __RING_BUFFER_H__
+#define __RING_BUFFER_H__
+
+#include "bflb_core.h"
+
+/** @addtogroup  BL_Common_Component
+ *  @{
+ */
+
+/** @addtogroup  RING_BUFFER
+ *  @{
+ */
+
+/** @defgroup  RING_BUFFER_Public_Types
+ *  @{
+ */
+
+/**
+ *  @brief Ring buffer status type definition
+ */
+typedef enum {
+    RING_BUFFER_EMPTY,   /*!< Ring buffer is empty */
+    RING_BUFFER_PARTIAL, /*!< Ring buffer has partial data */
+    RING_BUFFER_FULL,    /*!< Ring buffer is full */
+} Ring_Buffer_Status_Type;
+
+/**
+ *  @brief Ring buffer structure definition
+ */
+typedef struct
+{
+    uint8_t *pointer;     /*!< Pointer of ring buffer */
+    uint8_t readMirror;   /*!< Read mirror,used to judge empty or full */
+    uint32_t readIndex;   /*!< Index of read address */
+    uint8_t writeMirror;  /*!< Write mirror,used to judge empty or full */
+    uint32_t writeIndex;  /*!< Index of write address */
+    uint32_t size;        /*!< Size of ring buffer */
+    void (*lock)(void);   /*!< Lock ring buffer */
+    void (*unlock)(void); /*!< Unlock ring buffer */
+} Ring_Buffer_Type;
+
+/*@} end of group RING_BUFFER_Public_Types */
+
+/** @defgroup  RING_BUFFER_Public_Constants
+ *  @{
+ */
+
+/** @defgroup  RING_BUFFER_STATUS_TYPE
+ *  @{
+ */
+#define IS_RING_BUFFER_STATUS_TYPE(type) (((type) == RING_BUFFER_EMPTY) ||   \
+                                          ((type) == RING_BUFFER_PARTIAL) || \
+                                          ((type) == RING_BUFFER_FULL))
+
+/*@} end of group RING_BUFFER_Public_Constants */
+
+/** @defgroup  RING_BUFFER_Public_Macros
+ *  @{
+ */
+typedef void(ringBuffer_Lock_Callback)(void);
+typedef void(ringBuffer_Read_Callback)(void *, uint8_t *, uint32_t);
+typedef void(ringBuffer_Write_Callback)(void *, uint8_t *, uint32_t);
+
+/*@} end of group RING_BUFFER_Public_Macros */
+
+/** @defgroup  RING_BUFFER_Public_Functions
+ *  @{
+ */
+void Ring_Buffer_Init(Ring_Buffer_Type *rbType, uint8_t *buffer, uint32_t size, ringBuffer_Lock_Callback *lockCb,
+                             ringBuffer_Lock_Callback *unlockCb);
+void Ring_Buffer_Reset(Ring_Buffer_Type *rbType);
+uint32_t Ring_Buffer_Write_Callback(Ring_Buffer_Type *rbType, uint32_t length, ringBuffer_Write_Callback *writeCb,
+                                    void *parameter);
+uint32_t Ring_Buffer_Write(Ring_Buffer_Type *rbType, const uint8_t *data, uint32_t length);
+uint32_t Ring_Buffer_Write_Byte(Ring_Buffer_Type *rbType, const uint8_t data);
+uint32_t Ring_Buffer_Write_Force(Ring_Buffer_Type *rbType, const uint8_t *data, uint32_t length);
+uint32_t Ring_Buffer_Write_Byte_Force(Ring_Buffer_Type *rbType, const uint8_t data);
+uint32_t Ring_Buffer_Read_Callback(Ring_Buffer_Type *rbType, uint32_t length, ringBuffer_Read_Callback *readCb,
+                                   void *parameter);
+uint32_t Ring_Buffer_Read(Ring_Buffer_Type *rbType, uint8_t *data, uint32_t length);
+uint32_t Ring_Buffer_Read_Byte(Ring_Buffer_Type *rbType, uint8_t *data);
+uint32_t Ring_Buffer_Peek(Ring_Buffer_Type *rbType, uint8_t *data, uint32_t length);
+uint32_t Ring_Buffer_Peek_Byte(Ring_Buffer_Type *rbType, uint8_t *data);
+uint32_t Ring_Buffer_Get_Length(Ring_Buffer_Type *rbType);
+uint32_t Ring_Buffer_Get_Empty_Length(Ring_Buffer_Type *rbType);
+Ring_Buffer_Status_Type Ring_Buffer_Get_Status(Ring_Buffer_Type *rbType);
+
+/*@} end of group RING_BUFFER_Public_Functions */
+
+/*@} end of group RING_BUFFER */
+
+/*@} end of group BL_Common_Component */
+
+#endif /* __RING_BUFFER_H__ */