RCL_Buffer.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020-2025, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef ti_drivers_RCL_Buffers_h__include
#define ti_drivers_RCL_Buffers_h__include

#include <stdint.h>
#include <ti/drivers/utils/List.h>

typedef enum {
    RCL_BufferStatePending  = 0U, 
    RCL_BufferStateInUse    = 1U, 
    RCL_BufferStateFinished = 2U  
} RCL_BufferState;

typedef struct RCL_Buffer_TxBuffer_s      RCL_Buffer_TxBuffer;
typedef struct RCL_Buffer_DataEntry_s     RCL_Buffer_DataEntry;
typedef struct RCL_MultiBuffer_s          RCL_MultiBuffer;
typedef struct RCL_MultiBuffer_ListInfo_s RCL_MultiBuffer_ListInfo;

struct RCL_Buffer_TxBuffer_s {
    List_Elem            __elem__;
    RCL_BufferState      state;                                  
    uint16_t             length   __attribute__ ((aligned (4))); 
    uint8_t              numPad;                                 
    uint8_t              pad0;                                   
    uint8_t              data[];                                 
};

struct RCL_Buffer_DataEntry_s {
    uint16_t             length  __attribute__ ((aligned (4))); 
    uint8_t              numPad;                                
    uint8_t              pad0;                                  
    uint8_t              data[];                                
};

struct RCL_MultiBuffer_s {
    List_Elem            __elem__;
    RCL_BufferState      state;       
    uint16_t             length;      
    uint16_t             headIndex;   
    uint16_t             tailIndex;   
    uint8_t              data[];      
};

struct RCL_MultiBuffer_ListInfo_s {
    List_List            *multiBuffers;    
    RCL_MultiBuffer      *nextBuffer;      
    uint16_t             nextIndex;        
};

#define RCL_Buffer_bytesToWords(byteLen) (((byteLen) + sizeof(uint32_t) - 1) / sizeof(uint32_t))

/* Include the data entry's length field and padding to uint32_t boundary */
#define RCL_Buffer_DataEntry_paddedLen(len) (RCL_Buffer_bytesToWords((len) + sizeof(uint16_t)) * sizeof(uint32_t))

#define RCL_Buffer_entryLen(numPad, hdrLen, dataLen) (RCL_Buffer_DataEntry_paddedLen(sizeof(uint8_t) + (numPad) + (hdrLen) + (dataLen)))

#define RCL_TxBuffer_len(numPad, hdrLen, dataLen) (offsetof(RCL_Buffer_TxBuffer, length) + RCL_Buffer_entryLen(numPad, hdrLen, dataLen))

#define RCL_TxBuffer_len_u32(numPad, hdrLen, dataLen) (RCL_Buffer_bytesToWords(RCL_TxBuffer_len(numPad, hdrLen, dataLen)))

#define RCL_MultiBuffer_len(dataLen) (offsetof(RCL_MultiBuffer, data) + (dataLen))

#define RCL_MultiBuffer_len_u32(dataLen) (RCL_Buffer_bytesToWords(RCL_MultiBuffer_len(dataLen)))

static inline RCL_Buffer_TxBuffer *RCL_TxBuffer_get(List_List *list)
{
    return (RCL_Buffer_TxBuffer *)List_get(list);
}

static inline RCL_Buffer_TxBuffer *RCL_TxBuffer_head(List_List *list)
{
    return (RCL_Buffer_TxBuffer *) (list->head);
}

static inline RCL_Buffer_TxBuffer *RCL_TxBuffer_next(RCL_Buffer_TxBuffer *elem)
{
    return (RCL_Buffer_TxBuffer *)(((List_Elem *)elem)->next);
}

extern uint8_t *RCL_TxBuffer_init(RCL_Buffer_TxBuffer *buffer, uint32_t numPad, uint32_t hdrLen,
                                  uint32_t dataLen);

extern void RCL_TxBuffer_put(List_List *list, RCL_Buffer_TxBuffer *elem);

static inline RCL_MultiBuffer *RCL_MultiBuffer_head(List_List *list)
{
    return (RCL_MultiBuffer *) (list->head);
}

static inline RCL_MultiBuffer *RCL_MultiBuffer_next(RCL_MultiBuffer *elem)
{
    return (RCL_MultiBuffer *)(((List_Elem *)elem)->next);
}

static inline RCL_MultiBuffer *RCL_MultiBuffer_get(List_List *list)
{
    return (RCL_MultiBuffer *)List_get(list);
}

extern void RCL_MultiBuffer_clear(RCL_MultiBuffer *buffer);

extern void RCL_MultiBuffer_init(RCL_MultiBuffer *buffer, size_t size);

extern RCL_Buffer_DataEntry *RCL_MultiBuffer_RxEntry_get(List_List *list, List_List *consumedBuffers);

extern bool RCL_MultiBuffer_RxEntry_isEmpty(List_List *list);

extern void RCL_MultiBuffer_ListInfo_init(RCL_MultiBuffer_ListInfo *listInfo, List_List *list);

extern RCL_Buffer_DataEntry *RCL_MultiBuffer_RxEntry_next(RCL_MultiBuffer_ListInfo *listInfo);

extern bool RCL_MultiBuffer_RxEntry_isLast(RCL_MultiBuffer_ListInfo *listInfo);

extern void RCL_MultiBuffer_put(List_List *list, RCL_MultiBuffer *elem);

 size_t RCL_Buffer_readPartialRxBuffer(RCL_Buffer_DataEntry *dataEntry, size_t entrySize);
RCL_MultiBuffer *RCL_MultiBuffer_findFirstWritableBuffer(RCL_MultiBuffer *head);

RCL_MultiBuffer *RCL_MultiBuffer_getBuffer(RCL_MultiBuffer *curBuffer,
                                           uint32_t minLength);

uint32_t RCL_MultiBuffer_findAvailableRxSpace(const RCL_MultiBuffer *curBuffer);

static inline uint8_t *RCL_MultiBuffer_getNextWritableByte(RCL_MultiBuffer *curBuffer)
{
    return & curBuffer->data[curBuffer->tailIndex];
}

static inline void RCL_MultiBuffer_commitBytes(RCL_MultiBuffer *curBuffer, uint32_t numBytes)
{
    curBuffer->tailIndex += numBytes;
}
#endif