fsl_rdc.h

/*
 * Copyright 2017-2021 NXP
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef _FSL_RDC_H_
#define _FSL_RDC_H_
 
#include "fsl_common.h"
 
/******************************************************************************
 * Definitions
 *****************************************************************************/
#define FSL_RDC_DRIVER_VERSION (MAKE_VERSION(2, 2, 0))
 
#define RDC_ACCESS_POLICY(domainID, policy) (uint16_t)((uint16_t)(policy) << ((domainID)*2U))
 
typedef struct _rdc_hardware_config
{
    uint32_t domainNumber : 4; 
    uint32_t masterNumber : 8; 
    uint32_t periphNumber : 8; 
    uint32_t memNumber : 8;    
    uint32_t : 4;
} rdc_hardware_config_t;
 
enum _rdc_interrupts
{
    kRDC_RestoreCompleteInterrupt = RDC_INTCTRL_RCI_EN_MASK,
};
 
enum _rdc_flags
{
    kRDC_PowerDownDomainOn = RDC_STAT_PDS_MASK, 
};
 
typedef struct _rdc_domain_assignment
{
    uint32_t domainId : 2U; 
    uint32_t : 29U;         
    uint32_t lock : 1U;     
} rdc_domain_assignment_t;
 
enum _rdc_access_policy
{
    kRDC_NoAccess  = 0, 
    kRDC_WriteOnly = 1, 
    kRDC_ReadOnly  = 2, 
    kRDC_ReadWrite = 3, 
};
 
typedef struct _rdc_periph_access_config
{
    rdc_periph_t periph; 
    bool lock;           
    bool enableSema;     
    uint16_t policy;     
} rdc_periph_access_config_t;
 
typedef struct _rdc_mem_access_config
{
    rdc_mem_t mem; 
    bool lock;            
    uint64_t baseAddress; 
    uint64_t endAddress;  
    uint16_t policy;      
} rdc_mem_access_config_t;
 
typedef struct _rdc_mem_status
{
    bool hasViolation; 
    uint8_t domainID;  
    uint64_t address;  
} rdc_mem_status_t;
 
/*******************************************************************************
 * API
 ******************************************************************************/
 
#if defined(__cplusplus)
extern "C" {
#endif
 
void RDC_Init(RDC_Type *base);
 
void RDC_Deinit(RDC_Type *base);
 
void RDC_GetHardwareConfig(RDC_Type *base, rdc_hardware_config_t *config);
 
static inline void RDC_EnableInterrupts(RDC_Type *base, uint32_t mask)
{
    base->INTCTRL |= mask;
}
 
static inline void RDC_DisableInterrupts(RDC_Type *base, uint32_t mask)
{
    base->INTCTRL &= ~mask;
}
 
static inline uint32_t RDC_GetInterruptStatus(RDC_Type *base)
{
    return base->INTSTAT;
}
 
static inline void RDC_ClearInterruptStatus(RDC_Type *base, uint32_t mask)
{
    base->INTSTAT = mask;
}
 
static inline uint32_t RDC_GetStatus(RDC_Type *base)
{
    return base->STAT;
}
 
static inline void RDC_ClearStatus(RDC_Type *base, uint32_t mask)
{
    base->STAT = mask;
}
 
void RDC_SetMasterDomainAssignment(RDC_Type *base,
                                   rdc_master_t master,
                                   const rdc_domain_assignment_t *domainAssignment);
 
void RDC_GetDefaultMasterDomainAssignment(rdc_domain_assignment_t *domainAssignment);
 
static inline void RDC_LockMasterDomainAssignment(RDC_Type *base, rdc_master_t master)
{
    assert((uint32_t)master < RDC_MDA_COUNT);
 
    base->MDA[master] |= RDC_MDA_LCK_MASK;
    __DSB();
}
 
void RDC_SetPeriphAccessConfig(RDC_Type *base, const rdc_periph_access_config_t *config);
 
void RDC_GetDefaultPeriphAccessConfig(rdc_periph_access_config_t *config);
 
static inline void RDC_LockPeriphAccessConfig(RDC_Type *base, rdc_periph_t periph)
{
    assert((uint32_t)periph < RDC_PDAP_COUNT);
 
    base->PDAP[periph] |= RDC_PDAP_LCK_MASK;
    __DSB();
}
 
static inline uint8_t RDC_GetPeriphAccessPolicy(RDC_Type *base, rdc_periph_t periph, uint8_t domainId)
{
    assert((uint32_t)periph < RDC_PDAP_COUNT);
 
    return (uint8_t)((base->PDAP[periph] >> (domainId * 2U)) & 0x03U);
}
 
void RDC_SetMemAccessConfig(RDC_Type *base, const rdc_mem_access_config_t *config);
 
void RDC_GetDefaultMemAccessConfig(rdc_mem_access_config_t *config);
 
static inline void RDC_LockMemAccessConfig(RDC_Type *base, rdc_mem_t mem)
{
    assert((uint32_t)mem < RDC_MRC_COUNT);
 
    base->MR[mem].MRC |= RDC_MRC_LCK_MASK;
    __DSB();
}
 
static inline void RDC_SetMemAccessValid(RDC_Type *base, rdc_mem_t mem, bool valid)
{
    assert((uint32_t)mem < RDC_MRC_COUNT);
 
    if (valid)
    {
        base->MR[mem].MRC |= RDC_MRC_ENA_MASK;
    }
    else
    {
        base->MR[mem].MRC &= ~RDC_MRC_ENA_MASK;
    }
    __DSB();
}
 
void RDC_GetMemViolationStatus(RDC_Type *base, rdc_mem_t mem, rdc_mem_status_t *status);
 
static inline void RDC_ClearMemViolationFlag(RDC_Type *base, rdc_mem_t mem)
{
    assert((uint32_t)mem < RDC_MRC_COUNT);
 
    base->MR[mem].MRVS = RDC_MRVS_AD_MASK;
}
 
static inline uint8_t RDC_GetMemAccessPolicy(RDC_Type *base, rdc_mem_t mem, uint8_t domainId)
{
    assert((uint32_t)mem < RDC_MRC_COUNT);
 
    return (uint8_t)((base->MR[mem].MRC >> (domainId * 2U)) & 0x03U);
}
 
static inline uint8_t RDC_GetCurrentMasterDomainId(RDC_Type *base)
{
    return (uint8_t)((base->STAT & RDC_STAT_DID_MASK) >> RDC_STAT_DID_SHIFT);
}
 
#if defined(__cplusplus)
}
#endif
 
#endif /* _FSL_RDC_H_ */