Adapter_BackEnd.c

Go to the documentation of this file.

 
#include "pch.h"
 
#include "Adapter_BackEnd.h"
 
#define BLOCK_0_NAME "gorp"
#define BLOCK_1_NAME "baba"
#define BLOCK_2_NAME "yaga"
 
const char* BLOCK_NAME_0 = BLOCK_0_NAME;
const char* BLOCK_NAME_1 = BLOCK_1_NAME;
const char* BLOCK_NAME_2 = BLOCK_2_NAME;
 
#define MAX_DATA_SIZE 32
 
typedef struct
{
    const char* name;
 
    bool locked;                   
 
    uint32_t data[MAX_DATA_SIZE];
} MemoryBlock;
 
static MemoryBlock memory_blocks[] = {
    { BLOCK_0_NAME, false, { 0 } },
    { BLOCK_1_NAME, false, { 0 } },
    { BLOCK_2_NAME, false, { 0 } }
};
 
 
static size_t memory_block_count = _countof(memory_blocks);
 
static int _FindBlock(const char* blockName)
{
    int foundIndex = -1;
 
    for (size_t index = 0; index < memory_block_count; index++)
    {
        if (strcmp(memory_blocks[index].name, blockName) == 0)
        {
            foundIndex = (int)index;
            break;
        }
    }
    return foundIndex;
}
 
static bool _ConvertHandleToBlockIndex(int dataHandle, int* memoryIndex)
{
    bool isValidHandle = false;
 
    if (memoryIndex != NULL)
    {
        int index = dataHandle;
        if (index >= 0 && index < (int)memory_block_count)
        {
            *memoryIndex = index;
            isValidHandle = true;
        }
    }
 
    return isValidHandle;
}
 
 
static bool _IsValidOffset(int chunkOffset)
{
    return chunkOffset >= 0 && chunkOffset < DDR_MAX_OFFSET;
}
 
// DDR_OpenMemoryBlock()
DDR_ErrorCode DDR_OpenMemoryBlock(const char* blockName, int* dataHandle)
{
    DDR_ErrorCode errorCode = DDR_ErrorCode_Null_Argument;
 
    if (blockName != NULL && dataHandle != NULL)
    {
        *dataHandle = DDR_INVALID_HANDLE;
        errorCode = DDR_ErrorCode_Invalid_Block_Name;
        int foundBlockIndex = _FindBlock(blockName);
        if (foundBlockIndex != -1)
        {
            errorCode = DDR_ErrorCode_Block_Already_Opened;
            if (!memory_blocks[foundBlockIndex].locked)
            {
                memory_blocks[foundBlockIndex].locked = true;
                // Note: We are using the index as the handle
                *dataHandle = foundBlockIndex;
                errorCode = DDR_ErrorCode_Success;
                memset(memory_blocks[foundBlockIndex].data, 0xff, sizeof(memory_blocks[foundBlockIndex].data));
            }
        }
    }
 
    return errorCode;
}
 
// DDR_CloseMemoryBlock()
DDR_ErrorCode DDR_CloseMemoryBlock(int dataHandle)
{
    DDR_ErrorCode errorCode = DDR_ErrorCode_Invalid_Handle;
 
    int memoryIndex = -1;
    if (_ConvertHandleToBlockIndex(dataHandle, &memoryIndex))
    {
        errorCode = DDR_ErrorCode_Block_Not_Opened;
        if (memory_blocks[memoryIndex].locked)
        {
            memory_blocks[memoryIndex].locked = false;
            errorCode = DDR_ErrorCode_Success;
        }
    }
 
    return errorCode;
}
 
// DDR_GetMemorySize()
DDR_ErrorCode DDR_GetMemorySize(int dataHandle, int* memorySizeInChunks)
{
    DDR_ErrorCode errorCode = DDR_ErrorCode_Null_Argument;
    if (memorySizeInChunks != NULL)
    {
        errorCode = DDR_ErrorCode_Invalid_Handle;
        int memoryIndex = -1;
        if (_ConvertHandleToBlockIndex(dataHandle, &memoryIndex))
        {
            *memorySizeInChunks = MAX_DATA_SIZE;
            errorCode = DDR_ErrorCode_Success;
        }
    }
 
    return errorCode;
}
 
// DDR_GetDataChunk()
DDR_ErrorCode DDR_GetDataChunk(int dataHandle, int chunkOffset, uint32_t* value)
{
    DDR_ErrorCode errorCode = DDR_ErrorCode_Null_Argument;
 
    if (value != NULL)
    {
        int memoryIndex = -1;
        if (_ConvertHandleToBlockIndex(dataHandle, &memoryIndex))
        {
            errorCode = DDR_ErrorCode_Block_Not_Opened;
            if (memory_blocks[memoryIndex].locked)
            {
                errorCode = DDR_ErrorCode_Invalid_Offset;
                if (_IsValidOffset(chunkOffset))
                {
                    *value = memory_blocks[memoryIndex].data[chunkOffset];
                    errorCode = DDR_ErrorCode_Success;
                }
            }
        }
    }
 
    return errorCode;
}
 
// DDR_SetDataChunk()
DDR_ErrorCode DDR_SetDataChunk(int dataHandle, int chunkOffset, uint32_t value)
{
    DDR_ErrorCode errorCode = DDR_ErrorCode_Invalid_Handle;
    int memoryIndex = -1;
    if (_ConvertHandleToBlockIndex(dataHandle, &memoryIndex))
    {
        errorCode = DDR_ErrorCode_Block_Not_Opened;
        if (memory_blocks[memoryIndex].locked)
        {
            errorCode = DDR_ErrorCode_Invalid_Offset;
            if (_IsValidOffset(chunkOffset))
            {
                memory_blocks[memoryIndex].data[chunkOffset] = value;
                errorCode = DDR_ErrorCode_Success;
            }
        }
    }
 
    return errorCode;
}