oc_mem_lld.c

#include <oc_mem_lld.h>
#include <oc_interrupts.h>
#include <oc_lsf.h>
#include <oc_module.h>
#include <oc_mcs.h>

#define _________________________________________LOCAL_VARIABLES_SECTION____________________________________________________________________

static oC_MEM_LLD_Interrupt_t BusFaultInterruptHandler          = NULL;
static oC_MEM_LLD_Interrupt_t MemoryFaultInterruptHandler       = NULL;
static bool                   BusFaultInterruptEnabledFlag      = false;
static bool                   MemoryFaultInterruptEnabledFlag   = false;

//static bool                   ModuleEnabledFlag                 = false;

#undef  _________________________________________LOCAL_VARIABLES_SECTION____________________________________________________________________

#define _________________________________________INTERFACE_FUNCTIONS_SECTION________________________________________________________________



//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_MEM_LLD_TurnOnDriver( void )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_Module_TurnOffVerification(&errorCode , oC_Module_MEM_LLD))
    {
        oC_MCS_EnterCriticalSection();
        BusFaultInterruptHandler        = NULL;
        MemoryFaultInterruptHandler     = NULL;
        BusFaultInterruptEnabledFlag    = false;
        MemoryFaultInterruptEnabledFlag = false;

        oC_Module_TurnOn(oC_Module_MEM_LLD);
        oC_MCS_ExitCriticalSection();

        errorCode                       = oC_ErrorCode_None;
    }
    else
    {
        errorCode = oC_ErrorCode_ModuleIsTurnedOn;
    }
    return errorCode;
}
//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_MEM_LLD_TurnOffDriver( void )
{
    oC_ErrorCode_t errorCode        = oC_ErrorCode_ImplementError;

    if(oC_Module_TurnOnVerification(&errorCode , oC_Module_MEM_LLD))
    {
        oC_MCS_EnterCriticalSection();
        oC_Module_TurnOff(oC_Module_MEM_LLD);
        MemoryFaultInterruptEnabledFlag = false;
        BusFaultInterruptEnabledFlag    = false;

        if(
            oC_AssignErrorCodeIfFalse(&errorCode , oC_MCS_DisableInterrupt(BusFault_IRQn)         , oC_ErrorCode_CannotTurnOffInterruptInMachineModule) &&
            oC_AssignErrorCodeIfFalse(&errorCode , oC_MCS_DisableInterrupt(MemoryManagement_IRQn) , oC_ErrorCode_CannotTurnOffInterruptInMachineModule)
            )
        {
            errorCode = oC_ErrorCode_None;
        }
        oC_MCS_ExitCriticalSection();
    }
    else
    {
        errorCode = oC_ErrorCode_ModuleNotStartedYet;
    }

    return errorCode;
}
//==========================================================================================================================================
//==========================================================================================================================================
void * oC_MEM_LLD_GetRamStartAddress( void )
{
    return oC_LSF_GetRamStart();
}

//==========================================================================================================================================
//==========================================================================================================================================
void * oC_MEM_LLD_GetRamEndAddress( void )
{
    return oC_LSF_GetRamEnd();
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_MEM_LLD_Size_t oC_MEM_LLD_GetRamSize( void )
{
    return oC_LSF_GetRamSize();
}

//==========================================================================================================================================
//==========================================================================================================================================
void * oC_MEM_LLD_GetFlashStartAddress( void )
{
    return oC_LSF_GetRomStart();
}

//==========================================================================================================================================
//==========================================================================================================================================
void * oC_MEM_LLD_GetFlashEndAddress( void )
{
    return oC_LSF_GetRomEnd();
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_MEM_LLD_Size_t oC_MEM_LLD_GetFlashSize( void )
{
    return oC_LSF_GetRomSize();
}

//==========================================================================================================================================
//==========================================================================================================================================
void * oC_MEM_LLD_GetHeapStartAddress( void )
{
    return oC_LSF_GetHeapStart();
}

//==========================================================================================================================================
//==========================================================================================================================================
void * oC_MEM_LLD_GetHeapEndAddress( void )
{
    return oC_LSF_GetHeapEnd();
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_MEM_LLD_Size_t oC_MEM_LLD_GetHeapSize( void )
{
    return oC_LSF_GetHeapSize();
}

//==========================================================================================================================================
//==========================================================================================================================================
void * oC_MEM_LLD_GetStackStartAddress( void )
{
    return oC_LSF_GetStackStart();
}

//==========================================================================================================================================
//==========================================================================================================================================
void * oC_MEM_LLD_GetStackEndAddress( void )
{
    return oC_LSF_GetStackEnd();
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_MEM_LLD_Size_t oC_MEM_LLD_GetStackSize( void )
{
    return oC_LSF_GetStackSize();
}

//==========================================================================================================================================
//==========================================================================================================================================
void * oC_MEM_LLD_GetDataStartAddress( void )
{
    return oC_LSF_GetDataStart();
}

//==========================================================================================================================================
//==========================================================================================================================================
void * oC_MEM_LLD_GetDataEndAddress( void )
{
    return oC_LSF_GetDataEnd();
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_MEM_LLD_Size_t oC_MEM_LLD_GetDataSize( void )
{
    return oC_LSF_GetDataSize();
}

//==========================================================================================================================================
//==========================================================================================================================================
void * oC_MEM_LLD_GetBssStartAddress( void )
{
    return oC_LSF_GetBssStart();
}

//==========================================================================================================================================
//==========================================================================================================================================
void * oC_MEM_LLD_GetBssEndAddress( void )
{
    return oC_LSF_GetBssEnd();
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_MEM_LLD_Size_t oC_MEM_LLD_GetBssSize( void )
{
    return oC_LSF_GetBssSize();
}

//==========================================================================================================================================
//==========================================================================================================================================
void * oC_MEM_LLD_GetDmaRamStartAddress( void )
{
    return oC_LSF_GetDmaStart();
}

//==========================================================================================================================================
//==========================================================================================================================================
void * oC_MEM_LLD_GetDmaRamEndAddress( void )
{
    return oC_LSF_GetDmaEnd();
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_MEM_LLD_Size_t oC_MEM_LLD_GetDmaRamSize( void )
{
    return oC_LSF_GetDmaSize();
}

//==========================================================================================================================================
//==========================================================================================================================================
void * oC_MEM_LLD_GetUsedFlashStartAddress( void )
{
    return oC_LSF_GetTextStart();
}

//==========================================================================================================================================
//==========================================================================================================================================
void * oC_MEM_LLD_GetUsedFlashEndAddress( void )
{
    return oC_LSF_GetTextEnd();
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_MEM_LLD_Size_t oC_MEM_LLD_GetUsedFlashSize( void )
{
    return oC_LSF_GetTextSize();
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_MEM_LLD_Size_t oC_MEM_LLD_GetAlignmentSize( void )
{
    return oC_MCS_MEMORY_ALIGNMENT;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_MEM_LLD_IsRamAddress( const void * Address )
{
    return oC_LSF_IsRamAddress(Address);
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_MEM_LLD_IsExternalAddress( const void * Address )
{
    return oC_LSF_IsExternalAddress(Address);
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_MEM_LLD_IsFlashAddress( const void * Address )
{
    return oC_LSF_IsRomAddress(Address);
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_MEM_LLD_IsUsedFlashAddress( const void * Address )
{
    return (Address > oC_LSF_GetTextStart()) && (Address < oC_LSF_GetTextEnd());
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_MEM_LLD_IsHeapAddress( const void * Address )
{
    return (Address >= oC_LSF_GetHeapStart()) && (Address < oC_LSF_GetHeapEnd());
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_MEM_LLD_IsDmaRamAddress( const void * Address )
{
    return oC_LSF_IsDmaAddress(Address);
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_MEM_LLD_SetMemoryFaultInterrupt( oC_MEM_LLD_Interrupt_t Interrupt )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if( oC_MEM_LLD_IsRamAddress(Interrupt) || oC_MEM_LLD_IsUsedFlashAddress(Interrupt))
    {
        if(
             oC_Module_TurnOnVerification(  &errorCode , oC_Module_MEM_LLD) &&
             oC_AssignErrorCodeIfFalse(     &errorCode , MemoryFaultInterruptHandler == NULL , oC_ErrorCode_InterruptHandlerAlreadySet)
                )
        {
            /* Must not turn off interrupts, because there is no possible to turn it on, when
             * the handler is not set.                                                        */
            MemoryFaultInterruptHandler     = Interrupt;
            errorCode                       = oC_ErrorCode_None;
        }
    }
    else
    {
        errorCode = oC_ErrorCode_WrongAddress;
    }


    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_MEM_LLD_SetBusFaultInterrupt( oC_MEM_LLD_Interrupt_t Interrupt )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if( oC_MEM_LLD_IsRamAddress(Interrupt) || oC_MEM_LLD_IsUsedFlashAddress(Interrupt))
    {
        if(
             oC_Module_TurnOnVerification(  &errorCode , oC_Module_MEM_LLD) &&
             oC_AssignErrorCodeIfFalse(     &errorCode , BusFaultInterruptHandler == NULL    , oC_ErrorCode_InterruptHandlerAlreadySet)
                )
        {
            /* Must not turn off interrupts, because there is no possible to turn it on, when
             * the handler is not set.                                                        */
            BusFaultInterruptHandler        = Interrupt;
            errorCode                       = oC_ErrorCode_None;
        }
    }
    else
    {
        errorCode = oC_ErrorCode_WrongAddress;
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_MEM_LLD_TurnOnMemoryFaultInterrupt( void )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(
        oC_Module_TurnOnVerification(   &errorCode , oC_Module_MEM_LLD) &&
        oC_AssignErrorCodeIfFalse(&errorCode , MemoryFaultInterruptHandler != NULL , oC_ErrorCode_InterruptHandlerNotSet)
           )
    {
        if( oC_MCS_EnableInterrupt( MemoryManagement_IRQn ) )
        {
            errorCode = oC_ErrorCode_None;
        }
        else
        {
            errorCode = oC_ErrorCode_CannotTurnOnInterruptInMachineModule;
        }
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_MEM_LLD_TurnOffMemoryFaultInterrupt( void )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if( oC_MCS_DisableInterrupt( MemoryManagement_IRQn ) )
    {
        errorCode = oC_ErrorCode_None;
    }
    else
    {
        errorCode = oC_ErrorCode_CannotTurnOnInterruptInMachineModule;
    }

    return errorCode;
}
//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_MEM_LLD_TurnOnBusFaultInterrupt( void )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(
        oC_Module_TurnOnVerification(   &errorCode , oC_Module_MEM_LLD) &&
        oC_AssignErrorCodeIfFalse(&errorCode , BusFaultInterruptHandler != NULL    , oC_ErrorCode_InterruptHandlerNotSet)
           )
    {
        if( oC_MCS_EnableInterrupt( BusFault_IRQn ) )
        {
            errorCode = oC_ErrorCode_None;
        }
        else
        {
            errorCode = oC_ErrorCode_CannotTurnOnInterruptInMachineModule;
        }
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_MEM_LLD_TurnOffBusFaultInterrupt( void )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if( oC_MCS_DisableInterrupt( BusFault_IRQn ) )
    {
        errorCode = oC_ErrorCode_None;
    }
    else
    {
        errorCode = oC_ErrorCode_CannotTurnOnInterruptInMachineModule;
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_MEM_LLD_IsMemoryFaultInterruptTurnedOn( void )
{
    bool interruptTurnedOn = false;

    if( MemoryFaultInterruptEnabledFlag )
    {
        interruptTurnedOn = oC_MCS_IsInterruptEnabled( MemoryManagement_IRQn );
    }

    return interruptTurnedOn;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_MEM_LLD_IsBusFaultInterruptTurnedOn( void )
{
    bool interruptTurnedOn = false;

    if( BusFaultInterruptEnabledFlag )
    {
        interruptTurnedOn = oC_MCS_IsInterruptEnabled( BusFault_IRQn );
    }

    return interruptTurnedOn;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_MEM_LLD_ConfigureMemoryRegion( oC_MEM_LLD_MemoryRegionConfig_t * Config )
{
    oC_ErrorCode_t                  errorCode           = oC_ErrorCode_ImplementError;
    oC_MCS_MemoryRegionConfig_t     mcsConfig;

    if(
        oC_Module_TurnOnVerification(   &errorCode , oC_Module_MEM_LLD) &&
        ErrorCondition( oC_LSF_IsCorrectAddress(Config) , oC_ErrorCode_WrongAddress)
           )
    {
        mcsConfig.AlignSize         = false;
        mcsConfig.BaseAddress       = Config->BaseAddress;
        mcsConfig.Bufforable        = Config->Bufforable;
        mcsConfig.Cacheable         = Config->Cachable;
        mcsConfig.Power             = Config->Power;
        mcsConfig.PrivilegedAccess  = Config->PrivilegedAccess;
        mcsConfig.UserAccess        = Config->UserAccess;
        mcsConfig.RegionNumber      = Config->RegionNumber;
        mcsConfig.Shareable         = false;
        mcsConfig.Size              = Config->Size;

        if(Config->FindFreeRegion == false || ErrorCondition(oC_MCS_ReadFreeRegionNumber(&mcsConfig.RegionNumber) , oC_ErrorCode_NoChannelAvailable))
        {
            if(oC_AssignErrorCode(&errorCode , oC_MCS_ConfigureMemoryRegion(&mcsConfig)))
            {
                if(  Config->FindFreeRegion == true
                  && ErrorCondition( oC_LSF_IsRamAddress(Config) || oC_LSF_IsExternalAddress(Config) , oC_ErrorCode_OutputAddressNotInRAM )
                     )
                {
                    Config->RegionNumber = mcsConfig.RegionNumber;
                }
                errorCode = oC_ErrorCode_None;
            }
        }
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_MEM_LLD_SetMemoryAccessMode( oC_MEM_LLD_MemoryAccessMode_t Mode )
{
    return oC_MCS_SetMemoryAccessMode(Mode);
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_MEM_LLD_MemoryAccessMode_t oC_MEM_LLD_GetMemoryAccessMode( void )
{
    return oC_MCS_GetMemoryAccessMode();
}

#undef  _________________________________________INTERFACE_FUNCTIONS_SECTION________________________________________________________________

#define _________________________________________INTERRUPTS_SECTION_________________________________________________________________________

//==========================================================================================================================================
//==========================================================================================================================================
oC_InterruptHandler(SYSTEM_INT, BusFault)
{
    if(BusFaultInterruptHandler && BusFaultInterruptEnabledFlag)
    {
        BusFaultInterruptHandler();
    }
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_InterruptHandler(SYSTEM_INT, MemoryManagement)
{
    if(MemoryFaultInterruptHandler && MemoryFaultInterruptEnabledFlag)
    {
        MemoryFaultInterruptHandler();
    }
}

#undef  _________________________________________INTERRUPTS_SECTION_________________________________________________________________________