fsl_soc_src.h

/*
 * Copyright 2019-2021 NXP
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
#ifndef _FSL_SRC_H_
#define _FSL_SRC_H_
 
#include "fsl_common.h"
 
/*******************************************************************************
 * Definitions
 ******************************************************************************/
 
#define FSL_SRC_DRIVER_VERSION (MAKE_VERSION(2, 1, 1))
#define SRC_SLICE_ADDRESS_OFFSET (0x200U)
 
#define SRC_SLICE_AUTHENTICATION_REGISTER_OFFSET  (0x0U)
#define SRC_SLICE_CONTROL_REGISTER_OFFSET         (0x4U)
#define SRC_SLICE_SETPOINT_CONFIG_REGISTER_OFFSET (0x8U)
#define SRC_SLICE_DOMAIN_CONFIG_REGISTER_OFFSET   (0x0CU)
#define SRC_SLICE_STATUS_REGISTER_OFFSET          (0x10U)
 
#define SRC_GET_SLICE_REGISTER_ADDRESS(base, sliceName, registerOffset) \
    (((uint32_t)base) + SRC_SLICE_ADDRESS_OFFSET + ((uint32_t)(sliceName) << 5UL) + (registerOffset))
 
#define SRC_SLICE_STAT_UNDER_RST_MASK (0x1U)
#define SRC_SLICE_STAT_RST_BY_HW_MASK (0x4U)
#define SRC_SLICE_STAT_RST_BY_SW_MASK (0x8U)
 
#define SRC_WHITE_LIST_VALUE(coreName)  (1UL << (uint32_t)(coreName))
#define SRC_ASSIGN_LIST_VALUE(coreName) (1UL << (uint32_t)(coreName))
 
#define SRC_SLICE_AUTHEN_DOMAIN_MODE_MASK   (0x1U)
#define SRC_SLICE_AUTHEN_SETPOINT_MODE_MASK (0x2U)
 
#define SRC_SLICE_AUTHEN_LOCK_MODE_MASK  (0x80U)
#define SRC_SLICE_AUTHEN_LOCK_MODE_SHIFT (7U)
#define SRC_SLICE_AUTHEN_LOCK_MODE(x) \
    (((uint32_t)(((uint32_t)(x)) << SRC_SLICE_AUTHEN_LOCK_MODE_SHIFT)) & SRC_SLICE_AUTHEN_LOCK_MODE_MASK)
 
#define SRC_SLICE_AUTHEN_ASSIGN_LIST_MASK  (0xF00U)
#define SRC_SLICE_AUTHEN_ASSIGN_LIST_SHIFT (8U)
#define SRC_SLICE_AUTHEN_ASSIGN_LIST(x) \
    (((uint32_t)(((uint32_t)(x)) << SRC_SLICE_AUTHEN_ASSIGN_LIST_SHIFT)) & SRC_SLICE_AUTHEN_ASSIGN_LIST_MASK)
 
#define SRC_SLICE_AUTHEN_LOCK_ASSIGN_MASK  (0x8000U)
#define SRC_SLICE_AUTHEN_LOCK_ASSIGN_SHIFT (15)
#define SRC_SLICE_AUTHEN_LOCK_ASSIGN(x) \
    (((uint32_t)(((uint32_t)(x)) << SRC_SLICE_AUTHEN_LOCK_ASSIGN_SHIFT)) & SRC_SLICE_AUTHEN_LOCK_ASSIGN_MASK)
 
#define SRC_SLICE_AUTHEN_WHITE_LIST_MASK  (0xF0000U)
#define SRC_SLICE_AUTHEN_WHITE_LIST_SHIFT (16U)
#define SRC_SLICE_AUTHEN_WHITE_LIST(x) \
    (((uint32_t)(((uint32_t)(x)) << SRC_SLICE_AUTHEN_WHITE_LIST_SHIFT)) & SRC_SLICE_AUTHEN_WHITE_LIST_MASK)
 
#define SRC_SLICE_AUTHEN_LOCK_LIST_MASK  (0x800000U)
#define SRC_SLICE_AUTHEN_LOCK_LIST_SHIFT (23U)
#define SRC_SLICE_AUTHEN_LOCK_LIST(x) \
    (((uint32_t)(((uint32_t)(x)) << SRC_SLICE_AUTHEN_LOCK_LIST_SHIFT)) & SRC_SLICE_AUTHEN_LOCK_LIST_MASK)
 
#define SRC_SLICE_AUTHEN_USER_MASK  (0x1000000U)
#define SRC_SLICE_AUTHEN_USER_SHIFT (24U)
#define SRC_SLICE_AUTHEN_USER(x) \
    (((uint32_t)(((uint32_t)(x)) << SRC_SLICE_AUTHEN_USER_SHIFT)) & SRC_SLICE_AUTHEN_USER_MASK)
 
#define SRC_SLICE_AUTHEN_NONSECURE_MASK  (0x2000000U)
#define SRC_SLICE_AUTHEN_NONSECURE_SHIFT (25U)
#define SRC_SLICE_AUTHEN_NONSECURE(x) \
    (((uint32_t)(((uint32_t)(x)) << SRC_SLICE_AUTHEN_NONSECURE_SHIFT)) & SRC_SLICE_AUTHEN_NONSECURE_MASK)
 
#define SRC_SLICE_AUTHEN_LOCK_SETTING_MASK  (0x80000000U)
#define SRC_SLICE_AUTHEN_LOCK_SETTING_SHIFT (31U)
#define SRC_SLICE_AUTHEN_LOCK_SETTING(x) \
    (((uint32_t)(((uint32_t)(x)) << SRC_SLICE_AUTHEN_LOCK_SETTING_SHIFT)) & SRC_SLICE_AUTHEN_LOCK_SETTING_MASK)
 
typedef enum _src_core_name
{
    kSRC_CM7Core = 0x1U, 
    kSRC_CM4Core = 0x2U, 
} src_core_name_t;
 
typedef enum _src_boot_fuse_selection
{
    kSRC_SerialDownloaderBootFlow = 0U, 
    kSRC_NormalBootFlow           = 1U  
} src_boot_fuse_selection_t;
 
typedef enum _src_global_system_reset_source
{
    kSRC_WdogReset         = 0U,  
    kSRC_Wdog3Reset        = 2U,  
    kSRC_Wdog4Reset        = 4U,  
    kSRC_M4LockUpReset     = 6U,  
    kSRC_M7LockUpReset     = 8U,  
    kSRC_M4RequestReset    = 10U, 
    kSRC_M7RequestReset    = 12U, 
    kSRC_TempsenseReset    = 14U, 
    kSRC_CSUReset          = 16U, 
    kSRC_JageSoftwareReset = 18U, 
    kSRC_OverVoltageReset  = 20U, 
} src_global_system_reset_source_t;
 
enum _src_global_system_reset_status_flags
{
    kSRC_M7CoreIppResetFlag       = 1UL << 0UL,  
    kSRC_M7CoreM7RequestResetFlag = 1UL << 1UL,  
    kSRC_M7CoreM7LockUpResetFlag  = 1UL << 2UL,  
    kSRC_M7CoreCSUResetFlag       = 1UL << 3UL,  
    kSRC_M7CoreIppUserResetFlag   = 1UL << 4UL,  
    kSRC_M7CoreWdogResetFlag      = 1UL << 5UL,  
    kSRC_M7CoreJtagResetFlag      = 1UL << 6UL,  
    kSRC_M7CoreJtagSWResetFlag    = 1UL << 7UL,  
    kSRC_M7CoreWdog3ResetFlag     = 1UL << 8UL,  
    kSRC_M7CoreWdog4ResetFlag     = 1UL << 9UL,  
    kSRC_M7CoreTempsenseResetFlag = 1UL << 10UL, 
    kSRC_M7CoreM4RequestResetFlag = 1UL << 11UL, 
    kSRC_M7CoreM4LockUpResetFlag  = 1UL << 12UL, 
    kSRC_M7CoreOverVoltageResetFlag = 1UL << 13UL, 
    kSRC_M7CoreCdogResetFlag        = 1UL << 14UL, 
    kSRC_M4CoreIppResetFlag       = 1UL << 16UL, 
    kSRC_M4CoreM4RequestResetFlag = 1UL << 17UL, 
    kSRC_M4CoreM4LockUpResetFlag  = 1UL << 18UL, 
    kSRC_M4CoreCSUResetFlag       = 1UL << 19UL, 
    kSRC_M4CoreIppUserResetFlag   = 1UL << 20UL, 
    kSRC_M4CoreWdogResetFlag      = 1UL << 21UL, 
    kSRC_M4CoreJtagResetFlag      = 1UL << 22UL, 
    kSRC_M4CoreJtagSWResetFlag    = 1UL << 23UL, 
    kSRC_M4CoreWdog3ResetFlag     = 1UL << 24UL, 
    kSRC_M4CoreWdog4ResetFlag     = 1UL << 25UL, 
    kSRC_M4CoreTempsenseResetFlag = 1UL << 26UL, 
    kSRC_M4CoreM7RequestResetFlag = 1UL << 27UL, 
    kSRC_M4CoreM7LockUpResetFlag  = 1UL << 28UL, 
    kSRC_M4CoreOverVoltageResetFlag = 1UL << 29UL, 
    kSRC_M4CoreCdogResetFlag        = 1UL << 30UL, 
};
 
typedef enum _src_global_system_reset_mode
{
    kSRC_ResetSystem      = 0x0U, 
    kSRC_DoNotResetSystem = 0x3U, 
} src_global_system_reset_mode_t;
 
typedef enum _src_reset_slice_name
{
    kSRC_MegaSlice    = 0x0U, 
    kSRC_DisplaySlice = 0x1U, 
    kSRC_WakeUpSlice  = 0x2U, 
    kSRC_LpsrSlice    = 0x3U, 
    kSRC_M4CoreSlice  = 0x4U, 
    kSRC_M7CoreSlice  = 0x5U, 
    kSRC_M4DebugSlice = 0x6U, 
    kSRC_M7DebugSlice = 0x7U, 
    kSRC_Usbphy1Slice = 0x8U, 
    kSRC_Usbphy2Slice = 0x9U, 
} src_reset_slice_name_t;
 
enum _src_domain_mode_selection
{
    kSRC_Cpu0RunModeAssertReset     = 1UL << 0UL, 
    kSRC_Cpu0WaitModeAssertReset    = 1UL << 1UL, 
    kSRC_Cpu0StopModeAssertReset    = 1UL << 2UL, 
    kSRC_Cpu0SuspendModeAssertReset = 1UL << 3UL, 
    kSRC_Cpu1RunModeAssertReset     = 1UL << 4UL, 
    kSRC_Cpu1WaitModeAssertReset    = 1UL << 5UL, 
    kSRC_Cpu1StopModeAssertReset    = 1UL << 6UL, 
    kSRC_Cpu1SuspendModeAssertReset = 1UL << 7UL, 
};
 
enum _src_setpoint_selection
{
    kSRC_SetPoint0AssertReset  = 1UL << 0UL,  
    kSRC_SetPoint1AssertReset  = 1UL << 1UL,  
    kSRC_SetPoint2AssertReset  = 1UL << 2UL,  
    kSRC_SetPoint3AssertReset  = 1UL << 3UL,  
    kSRC_SetPoint4AssertReset  = 1UL << 4UL,  
    kSRC_SetPoint5AssertReset  = 1UL << 5UL,  
    kSRC_SetPoint6AssertReset  = 1UL << 6UL,  
    kSRC_SetPoint7AssertReset  = 1UL << 7UL,  
    kSRC_SetPoint8AssertReset  = 1UL << 8UL,  
    kSRC_SetPoint9AssertReset  = 1UL << 9UL,  
    kSRC_SetPoint10AssertReset = 1UL << 10UL, 
    kSRC_SetPoint11AssertReset = 1UL << 11UL, 
    kSRC_SetPoint12AssertReset = 1UL << 12UL, 
    kSRC_SetPoint13AssertReset = 1UL << 13UL, 
    kSRC_SetPoint14AssertReset = 1UL << 14UL, 
    kSRC_SetPoint15AssertReset = 1UL << 15UL, 
};
 
typedef enum _src_general_purpose_register_index
{
    kSRC_GeneralPurposeRegister1 = 0U, 
    kSRC_GeneralPurposeRegister2,      
    kSRC_GeneralPurposeRegister3,      
    kSRC_GeneralPurposeRegister4,      
    kSRC_GeneralPurposeRegister5,      
    kSRC_GeneralPurposeRegister6,      
    kSRC_GeneralPurposeRegister7,      
    kSRC_GeneralPurposeRegister8,      
    kSRC_GeneralPurposeRegister9,      
    kSRC_GeneralPurposeRegister10,     
    kSRC_GeneralPurposeRegister11,     
    kSRC_GeneralPurposeRegister12,     
    kSRC_GeneralPurposeRegister13,     
    kSRC_GeneralPurposeRegister14,     
    kSRC_GeneralPurposeRegister15,     
    kSRC_GeneralPurposeRegister16,     
    kSRC_GeneralPurposeRegister17,     
    kSRC_GeneralPurposeRegister18,     
    kSRC_GeneralPurposeRegister19,     
    kSRC_GeneralPurposeRegister20,     
} src_general_purpose_register_index_t;
 
typedef struct _src_setpoint_authentication
{
    bool enableSetpointTranferReset; 
    uint32_t whiteList;              
    bool lockWhiteList;              
    bool lockSetting;                
    bool allowNonSecureModeAccess;   
    bool allowUserModeAccess;        
} src_setpoint_authentication_t;
 
typedef struct _src_domain_mode_authentication
{
    bool enableDomainModeTransferReset; 
    uint32_t assignList; 
    bool lockAssignList; 
} src_domain_mode_authentication_t;
 
enum _src_slice_reset_source
{
    kSRC_SoftwareReset          = SRC_SLICE_STAT_RST_BY_SW_MASK, 
    kSRC_PowerModeTransferReset = SRC_SLICE_STAT_RST_BY_HW_MASK, 
};
 
typedef enum _src_slice_reset_state
{
    kSRC_SliceResetFinished  = 0U, 
    kSRC_SliceResetInProcess = 1U, 
} src_slice_reset_state_t;
 
/*******************************************************************************
 * API
 ******************************************************************************/
 
#if defined(__cplusplus)
extern "C" {
#endif
 
void SRC_ReleaseCoreReset(SRC_Type *base, src_core_name_t coreName);
 
static inline uint32_t SRC_GetBootConfig(SRC_Type *base)
{
    return base->SBMR1;
}
 
static inline uint8_t SRC_GetBootMode(SRC_Type *base)
{
    return (uint8_t)((base->SBMR2 & SRC_SBMR2_BMOD_MASK) >> SRC_SBMR2_BMOD_SHIFT);
}
 
static inline src_boot_fuse_selection_t SRC_GetBootFuseSelection(SRC_Type *base)
{
    return (src_boot_fuse_selection_t)(uint32_t)((base->SBMR2 & SRC_SBMR2_BT_FUSE_SEL_MASK) >>
                                                 SRC_SBMR2_BT_FUSE_SEL_SHIFT);
}
 
static inline uint8_t SRC_GetSECConfigFuseState(SRC_Type *base)
{
    return (uint8_t)((base->SBMR2 & SRC_SBMR2_SEC_CONFIG_MASK) >> SRC_SBMR2_SEC_CONFIG_SHIFT);
}
 
/* ! @} */
 
void SRC_SetGlobalSystemResetMode(SRC_Type *base,
                                  src_global_system_reset_source_t resetSource,
                                  src_global_system_reset_mode_t resetMode);
 
static inline uint32_t SRC_GetResetStatusFlags(SRC_Type *base)
{
    return base->SRSR;
}
 
static inline void SRC_ClearGlobalSystemResetStatus(SRC_Type *base, uint32_t mask)
{
    base->SRSR = mask;
}
 
void SRC_AssertSliceSoftwareReset(SRC_Type *base, src_reset_slice_name_t sliceName);
 
static inline void SRC_AllowUserModeAccess(SRC_Type *base, src_reset_slice_name_t sliceName, bool enable)
{
    uint32_t authRegAddr;
 
    authRegAddr = SRC_GET_SLICE_REGISTER_ADDRESS(base, sliceName, SRC_SLICE_AUTHENTICATION_REGISTER_OFFSET);
 
    if (enable)
    {
        *(volatile uint32_t *)authRegAddr |= SRC_SLICE_AUTHEN_USER_MASK;
    }
    else
    {
        *(volatile uint32_t *)authRegAddr &= ~SRC_SLICE_AUTHEN_USER_MASK;
    }
}
 
static inline void SRC_AllowNonSecureModeAccess(SRC_Type *base, src_reset_slice_name_t sliceName, bool enable)
{
    uint32_t authRegAddr;
 
    authRegAddr = SRC_GET_SLICE_REGISTER_ADDRESS(base, sliceName, SRC_SLICE_AUTHENTICATION_REGISTER_OFFSET);
 
    if (enable)
    {
        *(volatile uint32_t *)authRegAddr |= SRC_SLICE_AUTHEN_NONSECURE_MASK;
    }
    else
    {
        *(volatile uint32_t *)authRegAddr &= ~SRC_SLICE_AUTHEN_NONSECURE_MASK;
    }
}
 
static inline void SRC_LockAccessSetting(SRC_Type *base, src_reset_slice_name_t sliceName)
{
    uint32_t authRegAddr;
 
    authRegAddr = SRC_GET_SLICE_REGISTER_ADDRESS(base, sliceName, SRC_SLICE_AUTHENTICATION_REGISTER_OFFSET);
 
    *(volatile uint32_t *)authRegAddr |= SRC_SLICE_AUTHEN_LOCK_SETTING_MASK;
}
 
static inline void SRC_SetDomainIdWhiteList(SRC_Type *base, src_reset_slice_name_t sliceName, uint8_t domainId)
{
    uint32_t authRegAddr;
 
    authRegAddr = SRC_GET_SLICE_REGISTER_ADDRESS(base, sliceName, SRC_SLICE_AUTHENTICATION_REGISTER_OFFSET);
 
    *(volatile uint32_t *)authRegAddr = ((*(volatile uint32_t *)authRegAddr) & (~SRC_SLICE_AUTHEN_WHITE_LIST_MASK)) |
                                        SRC_SLICE_AUTHEN_WHITE_LIST(domainId);
}
 
static inline void SRC_LockDomainIdWhiteList(SRC_Type *base, src_reset_slice_name_t sliceName)
{
    uint32_t authRegAddr;
 
    authRegAddr = SRC_GET_SLICE_REGISTER_ADDRESS(base, sliceName, SRC_SLICE_AUTHENTICATION_REGISTER_OFFSET);
 
    *(volatile uint32_t *)authRegAddr |= SRC_SLICE_AUTHEN_LOCK_LIST_MASK;
}
 
static inline void SRC_SetAssignList(SRC_Type *base, src_reset_slice_name_t sliceName, uint32_t assignList)
{
    uint32_t authRegAddr;
 
    authRegAddr = SRC_GET_SLICE_REGISTER_ADDRESS(base, sliceName, SRC_SLICE_AUTHENTICATION_REGISTER_OFFSET);
 
    *(volatile uint32_t *)authRegAddr = ((*(volatile uint32_t *)authRegAddr) & (~SRC_SLICE_AUTHEN_ASSIGN_LIST_MASK)) |
                                        SRC_SLICE_AUTHEN_ASSIGN_LIST(assignList);
}
 
static inline void SRC_LockAssignList(SRC_Type *base, src_reset_slice_name_t sliceName)
{
    uint32_t authRegAddr;
 
    authRegAddr = SRC_GET_SLICE_REGISTER_ADDRESS(base, sliceName, SRC_SLICE_AUTHENTICATION_REGISTER_OFFSET);
 
    *(volatile uint32_t *)authRegAddr |= SRC_SLICE_AUTHEN_LOCK_ASSIGN_MASK;
}
 
static inline void SRC_EnableSetPointTransferReset(SRC_Type *base, src_reset_slice_name_t sliceName, bool enable)
{
    uint32_t authRegAddr;
 
    authRegAddr = SRC_GET_SLICE_REGISTER_ADDRESS(base, sliceName, SRC_SLICE_AUTHENTICATION_REGISTER_OFFSET);
 
    if (enable)
    {
        /* If the setpoint mode transfer reset is enabled, domain mode transfer reset should be disabled. */
        *(volatile uint32_t *)authRegAddr =
            ((*(volatile uint32_t *)authRegAddr) & (~SRC_SLICE_AUTHEN_DOMAIN_MODE_MASK)) |
            SRC_SLICE_AUTHEN_SETPOINT_MODE_MASK;
    }
    else
    {
        *(volatile uint32_t *)authRegAddr &= ~SRC_SLICE_AUTHEN_SETPOINT_MODE_MASK;
    }
}
 
static inline void SRC_EnableDomainModeTransferReset(SRC_Type *base, src_reset_slice_name_t sliceName, bool enable)
{
    uint32_t authRegAddr;
 
    authRegAddr = SRC_GET_SLICE_REGISTER_ADDRESS(base, sliceName, SRC_SLICE_AUTHENTICATION_REGISTER_OFFSET);
 
    if (enable)
    {
        /* If the domain mode transfer reset is enabled, setpoint mode transfer reset should be disabled. */
        *(volatile uint32_t *)authRegAddr =
            ((*(volatile uint32_t *)authRegAddr) & (~SRC_SLICE_AUTHEN_SETPOINT_MODE_MASK)) |
            SRC_SLICE_AUTHEN_DOMAIN_MODE_MASK;
    }
    else
    {
        *(volatile uint32_t *)authRegAddr &= ~SRC_SLICE_AUTHEN_DOMAIN_MODE_MASK;
    }
}
 
void SRC_SetSliceSetPointConfig(SRC_Type *base, src_reset_slice_name_t sliceName, uint32_t setpointConfig);
 
void SRC_SetSliceDomainModeConfig(SRC_Type *base, src_reset_slice_name_t sliceName, uint32_t domainConfig);
 
void SRC_LockSliceMode(SRC_Type *base, src_reset_slice_name_t sliceName);
 
static inline uint32_t SRC_GetSliceResetStatusFlags(SRC_Type *base, src_reset_slice_name_t sliceName)
{
    return (*(volatile uint32_t *)(SRC_GET_SLICE_REGISTER_ADDRESS(base, sliceName, SRC_SLICE_STATUS_REGISTER_OFFSET)) &
            (SRC_SLICE_STAT_RST_BY_HW_MASK | SRC_SLICE_STAT_RST_BY_SW_MASK));
}
 
static inline void SRC_ClearSliceResetStatusFlags(SRC_Type *base, src_reset_slice_name_t sliceName, uint32_t mask)
{
    *(volatile uint32_t *)SRC_GET_SLICE_REGISTER_ADDRESS(base, sliceName, SRC_SLICE_STATUS_REGISTER_OFFSET) = mask;
}
 
/* @} */
 
src_slice_reset_state_t SRC_GetSliceResetState(SRC_Type *base, src_reset_slice_name_t sliceName);
 
static inline void SRC_SetGeneralPurposeRegister(SRC_Type *base,
                                                 src_general_purpose_register_index_t index,
                                                 uint32_t value)
{
    base->GPR[index] = value;
}
 
static inline uint32_t SRC_GetGeneralPurposeRegister(SRC_Type *base, src_general_purpose_register_index_t index)
{
    assert((uint8_t)index < (uint8_t)SRC_GPR_COUNT);
 
    return base->GPR[index];
}
 
#if defined(__cplusplus)
}
#endif /* __cplusplus */
 
#endif /* _FSL_SRC_H_ */