libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity
rt-thread-official/bsp/imxrt/libraries/MIMXRT1170/MIMXRT1176/drivers/fsl_xrdc2.h

691 lines
23 KiB
C
Raw Blame History

/*
* 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"
/*!
* @addtogroup xrdc2
* @{
*/
/******************************************************************************
* Definitions
*****************************************************************************/
/*! @brief Driver version. */
#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
/*!
* @brief Global configuration lock.
*/
typedef enum _xrdc2_global_config_lock
{
kXRDC2_GlobalConfigLockDisabled, /*!< Lock disabled, registers can be written by any domain. */
kXRDC2_GlobalConfigLockDisabledUntilReset, /*!< Lock disabled until the next reset. */
kXRDC2_GlobalConfigLockOwnerOnly, /*!< Lock enabled, only the lock owner can write. */
kXRDC2_GlobalConfigLockEnabledUntilReset /*!< Lock enabled, all registers are read only until the next reset. */
} xrdc2_global_config_lock_t;
/*!
* @brief XRDC2 secure attribute, the register bit MDACi_MDAj_W0[SA],
* secure/nonsecure attribute output on a hit.
*/
typedef enum _xrdc2_secure_attr
{
kXRDC2_MasterSecure = 0, /*!< Use the bus master's secure/nonsecure attribute directly. */
kXRDC2_ForceSecure = 2, /*!< Force the bus attribute for this master to secure. */
kXRDC2_ForceNonSecure = 3, /*!< Force the bus attribute for this master to non-secure. */
} xrdc2_secure_attr_t;
/*!
* @brief XRDC2 privileged attribute, the register bit MDACi_MDAj_W0[PA],
* defines the privileged/user attribute on a hit.
*/
typedef enum _xrdc2_privilege_attr
{
kXRDC2_MasterPrivilege = 0, /*!< Use the bus master's attribute directly. */
kXRDC2_ForceUser = 2, /*!< Force the bus attribute for this master to user. */
kXRDC2_ForcePrivilege = 3, /*!< Force the bus attribute for this master to privileged. */
} xrdc2_privilege_attr_t;
/*!
* @brief Domain assignment for the bus master.
*
* XRDC2 compares the bus master @e match @e input with the parameter @ref mask
* and @ref match in this structure. If hit, the domain ID, privilege attribute,
* and secure attribute are used for the access.
*/
typedef struct _xrdc2_master_domain_assignment
{
bool lock; /*!< Set true to lock the descriptor. */
xrdc2_privilege_attr_t privilegeAttr; /*!< Privilege attribute. */
xrdc2_secure_attr_t secureAttr; /*!< Secure attribute. */
uint8_t domainId; /*!< Domain ID used when this descriptor hit. */
uint16_t mask; /*!< Mask used for descriptor hit. */
uint16_t match; /*!< Match used for descriptor hit. */
} xrdc2_master_domain_assignment_t;
/*!
* @brief XRDC2 domain access control policy.
*/
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;
/*!
* @brief Access configuration lock mode, the register field PDAC and MRGD LK2.
*/
typedef enum _xrdc2_access_config_lock
{
kXRDC2_AccessConfigLockDisabled = 0U, /*!< Entire PDACn/MRGDn/MSC can be written. */
kXRDC2_AccessConfigLockDisabledUntilReset = 1U, /*!< Entire PDACn/MRGDn/MSC can be written until next reset. */
kXRDC2_AccessConfigLockDomainXOnly = 2U, /*!< Domain x only write the DxACP field. */
kXRDC2_AccessConfigLockEnabledUntilReset = 3U /*!< PDACn/MRGDn/MSC is read-only until the next reset. */
} xrdc2_access_config_lock_t;
/*!
* @brief XRDC2 peripheral domain access control configuration.
*/
typedef struct _xrdc2_periph_access_config
{
xrdc2_access_config_lock_t lockMode; /*!< PDACn lock configuration. */
xrdc2_access_policy_t policy[FSL_FEATURE_XRDC2_DOMAIN_COUNT]; /*!< Access policy for each domain. */
} xrdc2_periph_access_config_t;
/*!
* @brief XRDC2 memory region domain access control configuration.
*/
typedef struct _xrdc2_mem_access_config
{
uint32_t startAddr; /*!< Memory region start address, should be 4k aligned. */
uint32_t endAddr; /*!< Memory region end address, (endAddr + 1) should be 4k aligned. */
xrdc2_access_config_lock_t lockMode; /*!< MRGDn lock configuration. */
xrdc2_access_policy_t policy[FSL_FEATURE_XRDC2_DOMAIN_COUNT]; /*!< Access policy for each domain. */
} xrdc2_mem_access_config_t;
/*!
* @brief XRDC2 memory slot domain access control configuration.
*/
typedef struct _xrdc2_mem_slot_access_config
{
xrdc2_access_config_lock_t lockMode; /*!< Descriptor lock configuration. */
xrdc2_access_policy_t policy[FSL_FEATURE_XRDC2_DOMAIN_COUNT]; /*!< Access policy for each domain. */
} xrdc2_mem_slot_access_config_t;
/*******************************************************************************
* API
******************************************************************************/
#if defined(__cplusplus)
extern "C" {
#endif
/*!
* @brief Initializes the XRDC2 module.
*
* @param base XRDC2 peripheral base address.
*/
void XRDC2_Init(XRDC2_Type *base);
/*!
* @brief De-initializes the XRDC2 module.
*
* @param base XRDC2 peripheral base address.
*/
void XRDC2_Deinit(XRDC2_Type *base);
/*!
* @name XRDC2 manager (XRDC2)
* @{
*/
/*!
* @brief Sets the XRDC2 global valid.
*
* This function sets the XRDC2 global valid or invalid. When the XRDC2 is global
* invalid, all accesses from all bus masters to all slaves are allowed.
*
* @param base XRDC2 peripheral base address.
* @param valid True to valid XRDC2.
*/
void XRDC2_SetGlobalValid(XRDC2_Type *base, bool valid);
/*!
* @brief Gets the domain ID of the current bus master.
*
* This function returns the domain ID of the current bus master.
*
* @param base XRDC2 peripheral base address.
* @return Domain ID of current bus master.
*/
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
}
/*!
* @brief Set the global configuration lock mode.
*
* Once change the lock mode, it could not be changed until next reset.
*
* @param base XRDC2 peripheral base address.
* @param mode The lock mode.
*/
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);
}
/*!
* @brief Gets the domain ID of global configuration lock owner.
*
* @param base XRDC2 peripheral base address.
* @return Domain ID of the global configuration lock owner.
*/
static inline uint8_t XRDC2_GetCurrentGlobalConfigLockOwnerDomainId(XRDC2_Type *base)
{
return (uint8_t)((base->SR & XRDC2_SR_GCLO_MASK) >> XRDC2_SR_GCLO_SHIFT);
}
/*@}*/
/*!
* @name XRDC2 Master Domain Assignment Controller (XRDC2_MDAC).
* @{
*/
/*!
* @brief Gets the default master domain assignment.
*
* This function sets the assignment as follows:
*
* @code
* config->lock = false;
* config->privilegeAttr = kXRDC2_MasterPrivilege;
* config->secureAttr = kXRDC2_MasterSecure;
* config->domainId = 0U;
* config->mask = 0U;
* config->match = 0U;
* @endcode
*
* @param assignment Pointer to the assignment structure.
*/
void XRDC2_GetDefaultMasterDomainAssignment(xrdc2_master_domain_assignment_t *assignment);
/*!
* @brief Sets the processor bus master domain assignment.
*
* @param base XRDC2 peripheral base address.
* @param master Which master to configure.
* @param assignIndex Which assignment register to set.
* @param assignment Pointer to the assignment structure.
*/
void XRDC2_SetMasterDomainAssignment(XRDC2_Type *base,
xrdc2_master_t master,
uint8_t assignIndex,
const xrdc2_master_domain_assignment_t *assignment);
/*!
* @brief Locks the bus master domain assignment register.
*
* This function locks the master domain assignment. One bus master might have
* multiple domain assignment registers. The parameter \p assignIndex specifies
* which assignment register to lock. After it is locked, the register can't be changed
* until next reset.
*
* @param base XRDC2 peripheral base address.
* @param master Which master to configure.
* @param assignIndex Which assignment register to lock.
*/
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;
}
/*!
* @brief Sets the master domain assignment as valid or invalid.
*
* This function sets the master domain assignment as valid or invalid. One bus master might have
* multiple domain assignment registers. The parameter \p assignIndex specifies
* which assignment register to configure.
*
* @param base XRDC2 peripheral base address.
* @param master Which master to configure.
* @param assignIndex Index for the domain assignment register.
* @param valid True to set valid, false to set invalid.
*/
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;
}
}
/*@}*/
/*!
* @name XRDC2 Memory Slot Access Controller (XRDC2_MSC).
* @{
*/
/*!
* @brief Gets the default memory slot access configuration.
*
* This function sets the assignment as follows:
*
* @code
* config->lockMode = kXRDC2_AccessConfigLockDisabled;
* config->policy[0] = kXRDC2_AccessPolicyNone;
* config->policy[1] = kXRDC2_AccessPolicyNone;
* ...
* @endcode
*
* @param config Pointer to the configuration.
*/
void XRDC2_GetMemSlotAccessDefaultConfig(xrdc2_mem_slot_access_config_t *config);
/*!
* @brief Sets the memory slot access policy.
*
* @param base XRDC2 peripheral base address.
* @param memSlot Which memory slot descriptor to set.
* @param config Pointer to the access policy configuration structure.
*/
void XRDC2_SetMemSlotAccessConfig(XRDC2_Type *base,
xrdc2_mem_slot_t memSlot,
const xrdc2_mem_slot_access_config_t *config);
/*!
* @brief Sets the memory slot descriptor as valid or invalid.
*
* @param base XRDC2 peripheral base address.
* @param memSlot Which memory slot descriptor to set.
* @param valid True to set valid, false to set invalid.
*/
void XRDC2_SetMemSlotAccessValid(XRDC2_Type *base, xrdc2_mem_slot_t memSlot, bool valid);
/*!
* @brief Sets the memory slot descriptor lock mode.
*
* @param base XRDC2 peripheral base address.
* @param memSlot Which memory slot descriptor to set.
* @param lockMode The lock mode to set.
*/
void XRDC2_SetMemSlotAccessLockMode(XRDC2_Type *base, xrdc2_mem_slot_t memSlot, xrdc2_access_config_lock_t lockMode);
/*!
* @brief Sets the memory slot access policy for specific domain.
*
* @param base XRDC2 peripheral base address.
* @param memSlot The memory slot to operate.
* @param domainId The ID of the domain whose policy will be changed.
* @param policy The access policy to set.
*/
void XRDC2_SetMemSlotDomainAccessPolicy(XRDC2_Type *base,
xrdc2_mem_slot_t memSlot,
uint8_t domainId,
xrdc2_access_policy_t policy);
/*!
* @brief Enable or disable the memory slot exclusive access lock.
*
* The lock must be enabled first before use. Once disabled, it could not be
* enabled until reset.
*
* @param base XRDC2 peripheral base address.
* @param memSlot The memory slot to operate.
* @param enable True to enable, false to disable.
*/
void XRDC2_EnableMemSlotExclAccessLock(XRDC2_Type *base, xrdc2_mem_slot_t memSlot, bool enable);
/*!
* @brief Get current memory slot exclusive access lock owner.
*
* @param base XRDC2 peripheral base address.
* @param memSlot The memory slot to operate.
* @return The domain ID of the lock owner.
*/
uint8_t XRDC2_GetMemSlotExclAccessLockDomainOwner(XRDC2_Type *base, xrdc2_mem_slot_t memSlot);
/*!
* @brief Try to lock the memory slot exclusive access.
*
* @param base XRDC2 peripheral base address.
* @param memSlot The memory slot to operate.
* @retval kStatus_Fail Failed to lock.
* @retval kStatus_Success Locked succussfully.
*/
status_t XRDC2_TryLockMemSlotExclAccess(XRDC2_Type *base, xrdc2_mem_slot_t memSlot);
/*!
* @brief Lock the memory slot exclusive access using blocking method.
*
* @param base XRDC2 peripheral base address.
* @param memSlot The memory slot to operate.
*
* @note This function must be called when the lock is not disabled.
*/
void XRDC2_LockMemSlotExclAccess(XRDC2_Type *base, xrdc2_mem_slot_t memSlot);
/*!
* @brief Unlock the memory slot exclusive access.
*
* @param base XRDC2 peripheral base address.
* @param memSlot The memory slot to operate.
*
* @note This function must be called by the lock owner.
*/
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;
}
/*!
* @brief Force the memory slot exclusive access lock release.
*
* The master does not own the lock could call this function to force release the lock.
*
* @param base XRDC2 peripheral base address.
* @param memSlot The memory slot to operate.
*/
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;
}
/*@}*/
/*!
* @name XRDC2 Memory Region Controller (XRDC2_MRC)
* @{
*/
/*!
* @brief Gets the default memory access configuration.
*
* This function sets the assignment as follows:
*
* @code
* config->startAddr = 0U;
* config->endAddr = 0xFFFFFFFFU;
* config->lockMode = kXRDC2_AccessConfigLockDisabled;
* config->policy[0] = kXRDC2_AccessPolicyNone;
* config->policy[1] = kXRDC2_AccessPolicyNone;
* ...
* @endcode
*
* @param config Pointer to the configuration.
*/
void XRDC2_GetMemAccessDefaultConfig(xrdc2_mem_access_config_t *config);
/*!
* @brief Sets the memory region access policy.
*
* @param base XRDC2 peripheral base address.
* @param mem Which memory region descriptor to set.
* @param config Pointer to the access policy configuration structure.
*/
void XRDC2_SetMemAccessConfig(XRDC2_Type *base, xrdc2_mem_t mem, const xrdc2_mem_access_config_t *config);
/*!
* @brief Sets the memory region descriptor as valid or invalid.
*
* @param base XRDC2 peripheral base address.
* @param mem Which memory region descriptor to set.
* @param valid True to set valid, false to set invalid.
*/
void XRDC2_SetMemAccessValid(XRDC2_Type *base, xrdc2_mem_t mem, bool valid);
/*!
* @brief Sets the memory descriptor lock mode.
*
* @param base XRDC2 peripheral base address.
* @param mem Which memory descriptor to set.
* @param lockMode The lock mode to set.
*/
void XRDC2_SetMemAccessLockMode(XRDC2_Type *base, xrdc2_mem_t mem, xrdc2_access_config_lock_t lockMode);
/*!
* @brief Sets the memory region access policy for specific domain.
*
* @param base XRDC2 peripheral base address.
* @param mem The memory region to operate.
* @param domainId The ID of the domain whose policy will be changed.
* @param policy The access policy to set.
*/
void XRDC2_SetMemDomainAccessPolicy(XRDC2_Type *base, xrdc2_mem_t mem, uint8_t domainId, xrdc2_access_policy_t policy);
/*!
* @brief Enable or disable the memory region exclusive access lock.
*
* Once disabled, it could not be enabled until reset.
*
* @param base XRDC2 peripheral base address.
* @param mem The memory region to operate.
* @param enable True to enable, false to disable.
*/
void XRDC2_EnableMemExclAccessLock(XRDC2_Type *base, xrdc2_mem_t mem, bool enable);
/*!
* @brief Get current memory region exclusive access lock owner.
*
* @param base XRDC2 peripheral base address.
* @param mem The memory region to operate.
* @return The domain ID of the lock owner.
*/
uint8_t XRDC2_GetMemExclAccessLockDomainOwner(XRDC2_Type *base, xrdc2_mem_t mem);
/*!
* @brief Try to lock the memory region exclusive access.
*
* @param base XRDC2 peripheral base address.
* @param mem The memory region to operate.
* @retval kStatus_Fail Failed to lock.
* @retval kStatus_Success Locked succussfully.
*/
status_t XRDC2_TryLockMemExclAccess(XRDC2_Type *base, xrdc2_mem_t mem);
/*!
* @brief Lock the memory region exclusive access using blocking method.
*
* @param base XRDC2 peripheral base address.
* @param mem The memory region to operate.
*
* @note This function must be called when the lock is not disabled.
*/
void XRDC2_LockMemExclAccess(XRDC2_Type *base, xrdc2_mem_t mem);
/*!
* @brief Unlock the memory region exclusive access.
*
* @param base XRDC2 peripheral base address.
* @param mem The memory region to operate.
*
* @note This function must be called by the lock owner.
*/
void XRDC2_UnlockMemExclAccess(XRDC2_Type *base, xrdc2_mem_t mem);
/*!
* @brief Force the memory region exclusive access lock release.
*
* The master does not own the lock could call this function to force release the lock.
*
* @param base XRDC2 peripheral base address.
* @param mem The memory region to operate.
*/
void XRDC2_ForceMemExclAccessLockRelease(XRDC2_Type *base, xrdc2_mem_t mem);
/*@}*/
/*!
* @name XRDC2 Peripheral Access Controller (XRDC2_PAC)
* @{
*/
/*!
* @brief Gets the default peripheral access configuration.
*
* The default configuration is set as follows:
* @code
* config->lockMode = kXRDC2_AccessConfigLockWritable;
* config->policy[0] = kXRDC2_AccessPolicyNone;
* config->policy[1] = kXRDC2_AccessPolicyNone;
* ...
* config->policy[15] = kXRDC2_AccessPolicyNone;
* @endcode
*
* @param config Pointer to the configuration structure.
*/
void XRDC2_GetPeriphAccessDefaultConfig(xrdc2_periph_access_config_t *config);
/*!
* @brief Sets the peripheral access policy.
*
* @param base XRDC2 peripheral base address.
* @param periph Which peripheral descriptor to set.
* @param config Pointer to the access policy configuration structure.
*/
void XRDC2_SetPeriphAccessConfig(XRDC2_Type *base, xrdc2_periph_t periph, const xrdc2_periph_access_config_t *config);
/*!
* @brief Sets the peripheral descriptor as valid or invalid.
*
* @param base XRDC2 peripheral base address.
* @param periph Which peripheral descriptor to set.
* @param valid True to set valid, false to set invalid.
*/
void XRDC2_SetPeriphAccessValid(XRDC2_Type *base, xrdc2_periph_t periph, bool valid);
/*!
* @brief Sets the peripheral descriptor lock mode.
*
* @param base XRDC2 peripheral base address.
* @param periph Which peripheral descriptor to set.
* @param lockMode The lock mode to set.
*/
void XRDC2_SetPeriphAccessLockMode(XRDC2_Type *base, xrdc2_periph_t periph, xrdc2_access_config_lock_t lockMode);
/*!
* @brief Sets the peripheral access policy for specific domain.
*
* @param base XRDC2 peripheral base address.
* @param periph The peripheral to operate.
* @param domainId The ID of the domain whose policy will be changed.
* @param policy The access policy to set.
*/
void XRDC2_SetPeriphDomainAccessPolicy(XRDC2_Type *base,
xrdc2_periph_t periph,
uint8_t domainId,
xrdc2_access_policy_t policy);
/*!
* @brief Disable the peripheral exclusive access lock.
*
* Once disabled, it could not be enabled until reset.
*
* @param base XRDC2 peripheral base address.
* @param periph The peripheral to operate.
* @param enable True to enable, false to disable.
*/
void XRDC2_EnablePeriphExclAccessLock(XRDC2_Type *base, xrdc2_periph_t periph, bool enable);
/*!
* @brief Get current peripheral exclusive access lock owner.
*
* @param base XRDC2 peripheral base address.
* @param periph The peripheral to operate.
* @return The domain ID of the lock owner.
*/
uint8_t XRDC2_GetPeriphExclAccessLockDomainOwner(XRDC2_Type *base, xrdc2_periph_t periph);
/*!
* @brief Try to lock the peripheral exclusive access.
*
* @param base XRDC2 peripheral base address.
* @param periph The peripheral to operate.
* @retval kStatus_Fail Failed to lock.
* @retval kStatus_Success Locked succussfully.
*/
status_t XRDC2_TryLockPeriphExclAccess(XRDC2_Type *base, xrdc2_periph_t periph);
/*!
* @brief Lock the peripheral exclusive access using blocking method.
*
* @param base XRDC2 peripheral base address.
* @param periph The peripheral to operate.
*
* @note This function must be called when the lock is not disabled.
*/
void XRDC2_LockPeriphExclAccess(XRDC2_Type *base, xrdc2_periph_t periph);
/*!
* @brief Unlock the peripheral exclusive access.
*
* @param base XRDC2 peripheral base address.
* @param periph The peripheral to operate.
*
* @note This function must be called by the lock owner.
*/
void XRDC2_UnlockPeriphExclAccess(XRDC2_Type *base, xrdc2_periph_t periph);
/*!
* @brief Force the peripheral exclusive access lock release.
*
* The master does not own the lock could call this function to force release the lock.
*
* @param base XRDC2 peripheral base address.
* @param periph The peripheral to operate.
*/
void XRDC2_ForcePeriphExclAccessLockRelease(XRDC2_Type *base, xrdc2_periph_t periph);
/*@}*/
#if defined(__cplusplus)
}
#endif
/*!
* @}
*/
#endif /* _FSL_XRDC2_H_ */
View Git Blame Copy Permalink