fsl_xrdc2.h

/*
 * Copyright 2019-2020 NXP
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef _FSL_XRDC2_H_
#define _FSL_XRDC2_H_
 
#include "fsl_common.h"
 
/******************************************************************************
 * Definitions
 *****************************************************************************/
#define FSL_XRDC2_DRIVER_VERSION (MAKE_VERSION(2, 0, 2))
 
/* Definitions for XRDC2 Exclusive access lock. */
#define XRDC2_EAL_FORCE_RELEASE_MAGIC_0 0x02000046UL
#define XRDC2_EAL_FORCE_RELEASE_MAGIC_1 0x02000052UL
 
#define XRDC2_EAL_DISABLE             (0UL << XRDC2_MSC_MSAC_W1_EAL_SHIFT)
#define XRDC2_EAL_DISABLE_UNTIL_RESET (1UL << XRDC2_MSC_MSAC_W1_EAL_SHIFT)
#define XRDC2_EAL_UNLOCKED            (2UL << XRDC2_MSC_MSAC_W1_EAL_SHIFT)
#define XRDC2_EAL_LOCKED              (3UL << XRDC2_MSC_MSAC_W1_EAL_SHIFT)
 
#define XRDC2_EAL_MASK XRDC2_MSC_MSAC_W1_EAL_MASK
 
typedef enum _xrdc2_global_config_lock
{
    kXRDC2_GlobalConfigLockDisabled,           
    kXRDC2_GlobalConfigLockDisabledUntilReset, 
    kXRDC2_GlobalConfigLockOwnerOnly,          
    kXRDC2_GlobalConfigLockEnabledUntilReset   
} xrdc2_global_config_lock_t;
 
typedef enum _xrdc2_secure_attr
{
    kXRDC2_MasterSecure   = 0, 
    kXRDC2_ForceSecure    = 2, 
    kXRDC2_ForceNonSecure = 3, 
} xrdc2_secure_attr_t;
 
typedef enum _xrdc2_privilege_attr
{
    kXRDC2_MasterPrivilege = 0, 
    kXRDC2_ForceUser       = 2, 
    kXRDC2_ForcePrivilege  = 3, 
} xrdc2_privilege_attr_t;
 
typedef struct _xrdc2_master_domain_assignment
{
    bool lock;                            
    xrdc2_privilege_attr_t privilegeAttr; 
    xrdc2_secure_attr_t secureAttr;       
    uint8_t domainId;                     
    uint16_t mask;                        
    uint16_t match;                       
} xrdc2_master_domain_assignment_t;
 
typedef enum _xrdc2_access_policy
{
    /*                               policy SecurePriv  SecureUser  NonSecurePriv  NonSecureUsr */
    kXRDC2_AccessPolicyNone = 0U, /*  000      none        none        none            none     */
    kXRDC2_AccessPolicyAlt1 = 1U, /*  001      r             r         none            none     */
    kXRDC2_AccessPolicyAlt2 = 2U, /*  010      r,w         none        none            none     */
    kXRDC2_AccessPolicyAlt3 = 3U, /*  011      r,w          r,w        none            none     */
    kXRDC2_AccessPolicyAlt4 = 4U, /*  100      r,w          r,w         r              none     */
    kXRDC2_AccessPolicyAlt5 = 5U, /*  101      r,w          r,w         r                r      */
    kXRDC2_AccessPolicyAlt6 = 6U, /*  110      r,w          r,w         r,w            none     */
    kXRDC2_AccessPolicyAll  = 7U  /*  111      r,w          r,w         r,w             r,w     */
} xrdc2_access_policy_t;
 
typedef enum _xrdc2_access_config_lock
{
    kXRDC2_AccessConfigLockDisabled           = 0U, 
    kXRDC2_AccessConfigLockDisabledUntilReset = 1U, 
    kXRDC2_AccessConfigLockDomainXOnly        = 2U, 
    kXRDC2_AccessConfigLockEnabledUntilReset  = 3U  
} xrdc2_access_config_lock_t;
 
typedef struct _xrdc2_periph_access_config
{
    xrdc2_access_config_lock_t lockMode;                          
    xrdc2_access_policy_t policy[FSL_FEATURE_XRDC2_DOMAIN_COUNT]; 
} xrdc2_periph_access_config_t;
 
typedef struct _xrdc2_mem_access_config
{
    uint32_t startAddr;                  
    uint32_t endAddr;                    
    xrdc2_access_config_lock_t lockMode; 
    xrdc2_access_policy_t policy[FSL_FEATURE_XRDC2_DOMAIN_COUNT]; 
} xrdc2_mem_access_config_t;
 
typedef struct _xrdc2_mem_slot_access_config
{
    xrdc2_access_config_lock_t lockMode;                          
    xrdc2_access_policy_t policy[FSL_FEATURE_XRDC2_DOMAIN_COUNT]; 
} xrdc2_mem_slot_access_config_t;
 
/*******************************************************************************
 * API
 ******************************************************************************/
 
#if defined(__cplusplus)
extern "C" {
#endif
 
void XRDC2_Init(XRDC2_Type *base);
 
void XRDC2_Deinit(XRDC2_Type *base);
 
void XRDC2_SetGlobalValid(XRDC2_Type *base, bool valid);
 
static inline uint8_t XRDC2_GetCurrentMasterDomainId(XRDC2_Type *base)
{
#if defined(XRDC2_SR_DIN_MASK)
    return (uint8_t)((base->SR & XRDC2_SR_DIN_MASK) >> XRDC2_SR_DIN_SHIFT);
#else
    return (uint8_t)((base->SR & XRDC2_SR_DID_MASK) >> XRDC2_SR_DID_SHIFT);
#endif
}
 
static inline void XRDC2_SetGlobalConfigLock(XRDC2_Type *base, xrdc2_global_config_lock_t mode)
{
    base->MCR = (base->MCR & ~XRDC2_MCR_GCL_MASK) | XRDC2_MCR_GCL(mode);
}
 
static inline uint8_t XRDC2_GetCurrentGlobalConfigLockOwnerDomainId(XRDC2_Type *base)
{
    return (uint8_t)((base->SR & XRDC2_SR_GCLO_MASK) >> XRDC2_SR_GCLO_SHIFT);
}
 
void XRDC2_GetDefaultMasterDomainAssignment(xrdc2_master_domain_assignment_t *assignment);
 
void XRDC2_SetMasterDomainAssignment(XRDC2_Type *base,
                                     xrdc2_master_t master,
                                     uint8_t assignIndex,
                                     const xrdc2_master_domain_assignment_t *assignment);
 
static inline void XRDC2_LockMasterDomainAssignment(XRDC2_Type *base, xrdc2_master_t master, uint8_t assignIndex)
{
    base->MDACI_MDAJ[master][assignIndex].MDAC_MDA_W1 |= XRDC2_MDAC_MDA_W1_DL_MASK;
}
 
static inline void XRDC2_SetMasterDomainAssignmentValid(XRDC2_Type *base,
                                                        xrdc2_master_t master,
                                                        uint8_t assignIndex,
                                                        bool valid)
{
    if (valid)
    {
        base->MDACI_MDAJ[master][assignIndex].MDAC_MDA_W1 |= XRDC2_MDAC_MDA_W1_VLD_MASK;
    }
    else
    {
        base->MDACI_MDAJ[master][assignIndex].MDAC_MDA_W1 &= ~XRDC2_MDAC_MDA_W1_VLD_MASK;
    }
}
 
void XRDC2_GetMemSlotAccessDefaultConfig(xrdc2_mem_slot_access_config_t *config);
 
void XRDC2_SetMemSlotAccessConfig(XRDC2_Type *base,
                                  xrdc2_mem_slot_t memSlot,
                                  const xrdc2_mem_slot_access_config_t *config);
 
void XRDC2_SetMemSlotAccessValid(XRDC2_Type *base, xrdc2_mem_slot_t memSlot, bool valid);
 
void XRDC2_SetMemSlotAccessLockMode(XRDC2_Type *base, xrdc2_mem_slot_t memSlot, xrdc2_access_config_lock_t lockMode);
 
void XRDC2_SetMemSlotDomainAccessPolicy(XRDC2_Type *base,
                                        xrdc2_mem_slot_t memSlot,
                                        uint8_t domainId,
                                        xrdc2_access_policy_t policy);
 
void XRDC2_EnableMemSlotExclAccessLock(XRDC2_Type *base, xrdc2_mem_slot_t memSlot, bool enable);
 
uint8_t XRDC2_GetMemSlotExclAccessLockDomainOwner(XRDC2_Type *base, xrdc2_mem_slot_t memSlot);
 
status_t XRDC2_TryLockMemSlotExclAccess(XRDC2_Type *base, xrdc2_mem_slot_t memSlot);
 
void XRDC2_LockMemSlotExclAccess(XRDC2_Type *base, xrdc2_mem_slot_t memSlot);
 
static inline void XRDC2_UnlockMemSlotExclAccess(XRDC2_Type *base, xrdc2_mem_slot_t memSlot)
{
    base->MSCI_MSAC_WK[(uint32_t)memSlot].MSC_MSAC_W1 = XRDC2_EAL_UNLOCKED;
}
 
static inline void XRDC2_ForceMemSlotExclAccessLockRelease(XRDC2_Type *base, xrdc2_mem_slot_t memSlot)
{
    base->MSCI_MSAC_WK[(uint32_t)memSlot].MSC_MSAC_W1 = XRDC2_EAL_FORCE_RELEASE_MAGIC_0;
    base->MSCI_MSAC_WK[(uint32_t)memSlot].MSC_MSAC_W1 = XRDC2_EAL_FORCE_RELEASE_MAGIC_1;
}
 
void XRDC2_GetMemAccessDefaultConfig(xrdc2_mem_access_config_t *config);
 
void XRDC2_SetMemAccessConfig(XRDC2_Type *base, xrdc2_mem_t mem, const xrdc2_mem_access_config_t *config);
 
void XRDC2_SetMemAccessValid(XRDC2_Type *base, xrdc2_mem_t mem, bool valid);
 
void XRDC2_SetMemAccessLockMode(XRDC2_Type *base, xrdc2_mem_t mem, xrdc2_access_config_lock_t lockMode);
 
void XRDC2_SetMemDomainAccessPolicy(XRDC2_Type *base, xrdc2_mem_t mem, uint8_t domainId, xrdc2_access_policy_t policy);
 
void XRDC2_EnableMemExclAccessLock(XRDC2_Type *base, xrdc2_mem_t mem, bool enable);
 
uint8_t XRDC2_GetMemExclAccessLockDomainOwner(XRDC2_Type *base, xrdc2_mem_t mem);
 
status_t XRDC2_TryLockMemExclAccess(XRDC2_Type *base, xrdc2_mem_t mem);
 
void XRDC2_LockMemExclAccess(XRDC2_Type *base, xrdc2_mem_t mem);
 
void XRDC2_UnlockMemExclAccess(XRDC2_Type *base, xrdc2_mem_t mem);
 
void XRDC2_ForceMemExclAccessLockRelease(XRDC2_Type *base, xrdc2_mem_t mem);
 
void XRDC2_GetPeriphAccessDefaultConfig(xrdc2_periph_access_config_t *config);
 
void XRDC2_SetPeriphAccessConfig(XRDC2_Type *base, xrdc2_periph_t periph, const xrdc2_periph_access_config_t *config);
 
void XRDC2_SetPeriphAccessValid(XRDC2_Type *base, xrdc2_periph_t periph, bool valid);
 
void XRDC2_SetPeriphAccessLockMode(XRDC2_Type *base, xrdc2_periph_t periph, xrdc2_access_config_lock_t lockMode);
 
void XRDC2_SetPeriphDomainAccessPolicy(XRDC2_Type *base,
                                       xrdc2_periph_t periph,
                                       uint8_t domainId,
                                       xrdc2_access_policy_t policy);
 
void XRDC2_EnablePeriphExclAccessLock(XRDC2_Type *base, xrdc2_periph_t periph, bool enable);
 
uint8_t XRDC2_GetPeriphExclAccessLockDomainOwner(XRDC2_Type *base, xrdc2_periph_t periph);
 
status_t XRDC2_TryLockPeriphExclAccess(XRDC2_Type *base, xrdc2_periph_t periph);
 
void XRDC2_LockPeriphExclAccess(XRDC2_Type *base, xrdc2_periph_t periph);
 
void XRDC2_UnlockPeriphExclAccess(XRDC2_Type *base, xrdc2_periph_t periph);
 
void XRDC2_ForcePeriphExclAccessLockRelease(XRDC2_Type *base, xrdc2_periph_t periph);
 
#if defined(__cplusplus)
}
#endif
 
#endif /* _FSL_XRDC2_H_ */