/******************************************************************************* * Function Name: Cy_WDT_Lock ****************************************************************************//** * * Locks out configuration changes to the Watchdog Timer register. * * After this function is called, the WDT configuration cannot be changed until * Cy_WDT_Unlock() is called. * *******************************************************************************/ void Cy_WDT_Lock(void) { uint32_t interruptState; interruptState = Cy_SysLib_EnterCriticalSection(); SRSS->WDT_CTL |= _VAL2FLD(SRSS_WDT_CTL_WDT_LOCK, CY_SRSS_WDT_LOCK_BITS); Cy_SysLib_ExitCriticalSection(interruptState); }
/******************************************************************************* * Function Name: Cy_WDT_Unlock ****************************************************************************//** * * Unlocks the Watchdog Timer configuration register. * *******************************************************************************/ void Cy_WDT_Unlock(void) { uint32_t interruptState; interruptState = Cy_SysLib_EnterCriticalSection(); /* The WDT lock is to be removed by two writes */ SRSS->WDT_CTL = ((SRSS->WDT_CTL & (uint32_t)(~SRSS_WDT_CTL_WDT_LOCK_Msk)) | CY_SRSS_WDT_LOCK_BIT0); SRSS->WDT_CTL |= CY_SRSS_WDT_LOCK_BIT1; Cy_SysLib_ExitCriticalSection(interruptState); }
/******************************************************************************* * Function Name: Cy_IPC_Sema_Set ****************************************************************************//** * * This function tries to acquire a semaphore. If the * semaphore is not available, this function returns immediately with * CY_IPC_SEMA_LOCKED. * * It first acquires the IPC channel that is used for all the semaphores, sets * the semaphore if it is cleared, then releases the IPC channel used for the * semaphore. * * \param semaNumber * The semaphore number to acquire. * * \param preemptable * When this parameter is enabled the function can be preempted by another * task or other forms of context switching in an RTOS environment. * * \note * If <b>preemptable</b> is enabled (true), the user must ensure that there are * no deadlocks in the system, which can be caused by an interrupt that occurs * after the IPC channel is locked. Unless the user is ready to handle IPC * channel locks correctly at the application level, set <b>premptable</b> to * false. * * \return Status of the operation * \retval CY_IPC_SEMA_SUCCESS: The semaphore was set successfully * \retval CY_IPC_SEMA_LOCKED: The semaphore channel is busy or locked * by another process * \retval CY_IPC_SEMA_NOT_ACQUIRED: Semaphore was already set * \retval CY_IPC_SEMA_OUT_OF_RANGE: The semaphore number is not valid * * \funcusage * \snippet IPC_sut_01.cydsn/main_cm4.c snippet_Cy_IPC_Sema_Set * *******************************************************************************/ cy_en_ipcsema_status_t Cy_IPC_Sema_Set(uint32_t semaNumber, bool preemptable) { uint32_t semaIndex; uint32_t semaMask; uint32_t interruptState = 0ul; cy_stc_ipc_sema_t *semaStruct; cy_en_ipcsema_status_t retStatus = CY_IPC_SEMA_LOCKED; /* Get pointer to structure */ semaStruct = (cy_stc_ipc_sema_t *)Cy_IPC_Drv_ReadDataValue(cy_semaIpcStruct); if (semaNumber < semaStruct->maxSema) { semaIndex = semaNumber / CY_IPC_SEMA_PER_WORD; semaMask = (uint32_t)(1ul << (semaNumber - (semaIndex * CY_IPC_SEMA_PER_WORD) )); if (!preemptable) { interruptState = Cy_SysLib_EnterCriticalSection(); } /* Check to make sure the IPC channel is released If so, check if specific channel can be locked. */ if(CY_IPC_DRV_SUCCESS == Cy_IPC_Drv_LockAcquire (cy_semaIpcStruct)) { if((semaStruct->arrayPtr[semaIndex] & semaMask) == 0ul) { semaStruct->arrayPtr[semaIndex] |= semaMask; retStatus = CY_IPC_SEMA_SUCCESS; } else { retStatus = CY_IPC_SEMA_NOT_ACQUIRED; } /* Release, but do not trigger a release event */ (void) Cy_IPC_Drv_LockRelease (cy_semaIpcStruct, CY_IPC_NO_NOTIFICATION); } if (!preemptable) { Cy_SysLib_ExitCriticalSection(interruptState); } } else { retStatus = CY_IPC_SEMA_OUT_OF_RANGE; } return(retStatus); }
/******************************************************************************* * Function Name: Cy_SCB_EZI2C_GetActivity ****************************************************************************//** * * Returns a non-zero value if an I2C Read or Write cycle has occurred since the * last time this function was called. All flags are reset to zero at the end of * this function call, except the \ref CY_SCB_EZI2C_STATUS_BUSY. * * \param base * The pointer to the EZI2C SCB instance. * * \param context * The pointer to the context structure \ref cy_stc_scb_ezi2c_context_t * allocated by the user. The structure is used during the EZI2C operation for * internal configuration and data retention. The user must not modify anything * in this structure. * * \return * \ref group_scb_ezi2c_macros_get_activity. * *******************************************************************************/ uint32_t Cy_SCB_EZI2C_GetActivity(CySCB_Type const *base, cy_stc_scb_ezi2c_context_t *context) { uint32_t intrState; uint32_t retStatus; /* Suppress a compiler warning about unused variables */ (void) base; intrState = Cy_SysLib_EnterCriticalSection(); retStatus = context->status; context->status &= CY_SCB_EZI2C_STATUS_BUSY; Cy_SysLib_ExitCriticalSection(intrState); return (retStatus); }
/******************************************************************************* * Function Name: Cy_WDT_Init ****************************************************************************//** * * Initializes the Watchdog timer to its default state. * * The given default setting of the WDT: * The WDT is unlocked and disabled. * The WDT match value is 4096. * None of ignore bits are set: the whole WDT counter bits are checked against * the match value. * *******************************************************************************/ void Cy_WDT_Init(void) { uint32_t interruptState; interruptState = Cy_SysLib_EnterCriticalSection(); /* Unlock the WDT by two writes */ SRSS->WDT_CTL = ((SRSS->WDT_CTL & (uint32_t)(~SRSS_WDT_CTL_WDT_LOCK_Msk)) | CY_SRSS_WDT_LOCK_BIT0); SRSS->WDT_CTL |= CY_SRSS_WDT_LOCK_BIT1; Cy_WDT_Disable(); Cy_WDT_SetMatch(CY_SRSS_WDT_DEFAULT_MATCH_VALUE); Cy_WDT_SetIgnoreBits(CY_SRSS_WDT_DEFAULT_IGNORE_BITS); Cy_SysLib_ExitCriticalSection(interruptState); }