603 lines
26 KiB
C
603 lines
26 KiB
C
/*
|
|
PDD layer implementation for peripheral type PIT
|
|
(C) 2013 Freescale, Inc. All rights reserved.
|
|
|
|
This file is static and it is generated from API-Factory
|
|
*/
|
|
|
|
#if !defined(PIT_PDD_H_)
|
|
#define PIT_PDD_H_
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- Test if supported MCU is active
|
|
---------------------------------------------------------------------------- */
|
|
|
|
#if !defined(MCU_ACTIVE)
|
|
// No MCU is active
|
|
#error PIT PDD library: No derivative is active. Place proper #include with PDD memory map before including PDD library.
|
|
#elif \
|
|
!defined(MCU_MK10D10) /* PIT */ && \
|
|
!defined(MCU_MK10D5) /* PIT */ && \
|
|
!defined(MCU_MK10D7) /* PIT */ && \
|
|
!defined(MCU_MK10F12) /* PIT */ && \
|
|
!defined(MCU_MK10DZ10) /* PIT */ && \
|
|
!defined(MCU_MK11D5) /* PIT */ && \
|
|
!defined(MCU_MK11D5WS) /* PIT */ && \
|
|
!defined(MCU_MK12D5) /* PIT */ && \
|
|
!defined(MCU_MK20D10) /* PIT */ && \
|
|
!defined(MCU_MK20D5) /* PIT */ && \
|
|
!defined(MCU_MK20D7) /* PIT */ && \
|
|
!defined(MCU_MK20F12) /* PIT */ && \
|
|
!defined(MCU_MK20DZ10) /* PIT */ && \
|
|
!defined(MCU_MK21D5) /* PIT */ && \
|
|
!defined(MCU_MK21D5WS) /* PIT */ && \
|
|
!defined(MCU_MK21F12) /* PIT */ && \
|
|
!defined(MCU_MK21F12WS) /* PIT */ && \
|
|
!defined(MCU_MK22D5) /* PIT */ && \
|
|
!defined(MCU_MK22F12810) /* PIT */ && \
|
|
!defined(MCU_MK22F12) /* PIT */ && \
|
|
!defined(MCU_MK22F25612) /* PIT */ && \
|
|
!defined(MCU_MK22F51212) /* PIT */ && \
|
|
!defined(MCU_MK24F12) /* PIT */ && \
|
|
!defined(MCU_MK30D10) /* PIT */ && \
|
|
!defined(MCU_MK30D7) /* PIT */ && \
|
|
!defined(MCU_MK30DZ10) /* PIT */ && \
|
|
!defined(MCU_MK40D10) /* PIT */ && \
|
|
!defined(MCU_MK40D7) /* PIT */ && \
|
|
!defined(MCU_MK40DZ10) /* PIT */ && \
|
|
!defined(MCU_MK40X256VMD100) /* PIT */ && \
|
|
!defined(MCU_MK50D10) /* PIT */ && \
|
|
!defined(MCU_MK50D7) /* PIT */ && \
|
|
!defined(MCU_MK50DZ10) /* PIT */ && \
|
|
!defined(MCU_MK51D10) /* PIT */ && \
|
|
!defined(MCU_MK51D7) /* PIT */ && \
|
|
!defined(MCU_MK51DZ10) /* PIT */ && \
|
|
!defined(MCU_MK52D10) /* PIT */ && \
|
|
!defined(MCU_MK52DZ10) /* PIT */ && \
|
|
!defined(MCU_MK53D10) /* PIT */ && \
|
|
!defined(MCU_MK53DZ10) /* PIT */ && \
|
|
!defined(MCU_MK60D10) /* PIT */ && \
|
|
!defined(MCU_MK60F12) /* PIT */ && \
|
|
!defined(MCU_MK60F15) /* PIT */ && \
|
|
!defined(MCU_MK60DZ10) /* PIT */ && \
|
|
!defined(MCU_MK60N512VMD100) /* PIT */ && \
|
|
!defined(MCU_MK61F12) /* PIT */ && \
|
|
!defined(MCU_MK61F15) /* PIT */ && \
|
|
!defined(MCU_MK61F12WS) /* PIT */ && \
|
|
!defined(MCU_MK61F15WS) /* PIT */ && \
|
|
!defined(MCU_MK63F12) /* PIT */ && \
|
|
!defined(MCU_MK63F12WS) /* PIT */ && \
|
|
!defined(MCU_MK64F12) /* PIT */ && \
|
|
!defined(MCU_MK65F18) /* PIT */ && \
|
|
!defined(MCU_MK65F18WS) /* PIT */ && \
|
|
!defined(MCU_MK66F18) /* PIT */ && \
|
|
!defined(MCU_MK70F12) /* PIT */ && \
|
|
!defined(MCU_MK70F15) /* PIT */ && \
|
|
!defined(MCU_MK70F12WS) /* PIT */ && \
|
|
!defined(MCU_MK70F15WS) /* PIT */ && \
|
|
!defined(MCU_MKE02Z2) /* PIT */ && \
|
|
!defined(MCU_MKE02Z4) /* PIT */ && \
|
|
!defined(MCU_SKEAZN642) /* PIT */ && \
|
|
!defined(MCU_MKE04Z1284) /* PIT */ && \
|
|
!defined(MCU_MKE04Z4) /* PIT */ && \
|
|
!defined(MCU_SKEAZN84) /* PIT */ && \
|
|
!defined(MCU_MKE06Z4) /* PIT */ && \
|
|
!defined(MCU_MKL04Z4) /* PIT */ && \
|
|
!defined(MCU_MKL05Z4) /* PIT */ && \
|
|
!defined(MCU_MKL14Z4) /* PIT */ && \
|
|
!defined(MCU_MKL15Z4) /* PIT */ && \
|
|
!defined(MCU_MKL16Z4) /* PIT */ && \
|
|
!defined(MCU_MKL24Z4) /* PIT */ && \
|
|
!defined(MCU_MKL25Z4) /* PIT */ && \
|
|
!defined(MCU_MKL26Z4) /* PIT */ && \
|
|
!defined(MCU_MKL34Z4) /* PIT */ && \
|
|
!defined(MCU_MKL36Z4) /* PIT */ && \
|
|
!defined(MCU_MKL46Z4) /* PIT */ && \
|
|
!defined(MCU_MKV31F12810) /* PIT */ && \
|
|
!defined(MCU_MKV31F25612) /* PIT */ && \
|
|
!defined(MCU_MKV31F51212) /* PIT */ && \
|
|
!defined(MCU_MKW01Z4) /* PIT */ && \
|
|
!defined(MCU_MKW21D5) /* PIT */ && \
|
|
!defined(MCU_MKW21D5WS) /* PIT */ && \
|
|
!defined(MCU_MKW22D5) /* PIT */ && \
|
|
!defined(MCU_MKW22D5WS) /* PIT */ && \
|
|
!defined(MCU_MKW24D5) /* PIT */ && \
|
|
!defined(MCU_MKW24D5WS) /* PIT */ && \
|
|
!defined(MCU_PCK20L4) /* PIT */ && \
|
|
!defined(MCU_SKEAZ1284) /* PIT */
|
|
// Unsupported MCU is active
|
|
#error PIT PDD library: Unsupported derivative is active.
|
|
#endif
|
|
|
|
#include "PDD_Types.h"
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- Method symbol definitions
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/* PIT channel constants */
|
|
#define PIT_PDD_CHANNEL_0 0U /**< 0 */
|
|
#define PIT_PDD_CHANNEL_1 0x1U /**< 1 */
|
|
#define PIT_PDD_CHANNEL_2 0x2U /**< 2 */
|
|
#define PIT_PDD_CHANNEL_3 0x3U /**< 3 */
|
|
|
|
/* Module clock constants */
|
|
#define PIT_PDD_CLOCK_ENABLED 0U /**< Enabled */
|
|
#define PIT_PDD_CLOCK_DISABLED PIT_MCR_MDIS_MASK /**< Disabled */
|
|
|
|
/* Freeze constants */
|
|
#define PIT_PDD_TIMERS_RUN 0U /**< Run */
|
|
#define PIT_PDD_TIMERS_STOPPED PIT_MCR_FRZ_MASK /**< Stopped */
|
|
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- GetInterruptMask
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Returns interrupt mask.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param ChannelIdx PIT channel index. Use constants from group "PIT channel
|
|
* constants". This parameter is 32 bits wide.
|
|
* @return Returns a 32-bit value.
|
|
* @remarks The macro accesses the following registers: TCTRL[ChannelIdx].
|
|
* @par Example:
|
|
* @code
|
|
* uint32 result = PIT_PDD_GetInterruptMask(<peripheral>_BASE_PTR,
|
|
* PIT_PDD_CHANNEL_0);
|
|
* @endcode
|
|
*/
|
|
#define PIT_PDD_GetInterruptMask(PeripheralBase, ChannelIdx) ( \
|
|
(uint32)(PIT_TCTRL_REG(PeripheralBase,(ChannelIdx)) & PIT_TCTRL_TIE_MASK) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- GetInterruptFlag
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Returns interrupt flag bit.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param ChannelIdx PIT channel index. Use constants from group "PIT channel
|
|
* constants". This parameter is 32 bits wide.
|
|
* @return Returns a 32-bit value.
|
|
* @remarks The macro accesses the following registers: TFLG[ChannelIdx].
|
|
* @par Example:
|
|
* @code
|
|
* uint32 result = PIT_PDD_GetInterruptFlag(<peripheral>_BASE_PTR,
|
|
* PIT_PDD_CHANNEL_0);
|
|
* @endcode
|
|
*/
|
|
#define PIT_PDD_GetInterruptFlag(PeripheralBase, ChannelIdx) ( \
|
|
(uint32)(PIT_TFLG_REG(PeripheralBase,(ChannelIdx)) & PIT_TFLG_TIF_MASK) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- EnableInterrupt
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Enables the PIT interrupt.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param ChannelIdx PIT channel index. Use constants from group "PIT channel
|
|
* constants". This parameter is 32 bits wide.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: TCTRL[ChannelIdx].
|
|
* @par Example:
|
|
* @code
|
|
* PIT_PDD_EnableInterrupt(<peripheral>_BASE_PTR, PIT_PDD_CHANNEL_0);
|
|
* @endcode
|
|
*/
|
|
#define PIT_PDD_EnableInterrupt(PeripheralBase, ChannelIdx) ( \
|
|
PIT_TCTRL_REG(PeripheralBase,(ChannelIdx)) |= \
|
|
PIT_TCTRL_TIE_MASK \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- DisableInterrupt
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Disables the PIT interrupt.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param ChannelIdx PIT channel index. Use constants from group "PIT channel
|
|
* constants". This parameter is 32 bits wide.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: TCTRL[ChannelIdx].
|
|
* @par Example:
|
|
* @code
|
|
* PIT_PDD_DisableInterrupt(<peripheral>_BASE_PTR, PIT_PDD_CHANNEL_0);
|
|
* @endcode
|
|
*/
|
|
#define PIT_PDD_DisableInterrupt(PeripheralBase, ChannelIdx) ( \
|
|
PIT_TCTRL_REG(PeripheralBase,(ChannelIdx)) &= \
|
|
(uint32)(~(uint32)PIT_TCTRL_TIE_MASK) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- ClearInterruptFlag
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Clears PIT interrupt flag.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param ChannelIdx PIT channel index. Use constants from group "PIT channel
|
|
* constants". This parameter is 32 bits wide.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: TFLG[ChannelIdx],
|
|
* LDVAL[ChannelIdx] (depending on the peripheral).
|
|
* @par Example:
|
|
* @code
|
|
* PIT_PDD_ClearInterruptFlag(<peripheral>_BASE_PTR, PIT_PDD_CHANNEL_0);
|
|
* @endcode
|
|
*/
|
|
#define PIT_PDD_ClearInterruptFlag(PeripheralBase, ChannelIdx) ( \
|
|
(PIT_TFLG_REG(PeripheralBase,(ChannelIdx)) = \
|
|
PIT_TFLG_TIF_MASK), \
|
|
(void)PIT_LDVAL_REG(PeripheralBase,(ChannelIdx)) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- ModuleClock
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Enables/disables PIT module clock.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param Clock New value of the clock. Use constants from group "Module clock
|
|
* constants". This parameter is 32 bits wide.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: PIT_MCR.
|
|
* @par Example:
|
|
* @code
|
|
* PIT_PDD_ModuleClock(<peripheral>_BASE_PTR, PIT_PDD_CLOCK_ENABLED);
|
|
* @endcode
|
|
*/
|
|
#define PIT_PDD_ModuleClock(PeripheralBase, Clock) ( \
|
|
PIT_MCR_REG(PeripheralBase) = \
|
|
(uint32)(( \
|
|
(uint32)(PIT_MCR_REG(PeripheralBase) & (uint32)(~(uint32)PIT_MCR_MDIS_MASK))) | ( \
|
|
(uint32)(Clock))) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- ModuleFreeze
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Allows the timers to be stopped when the device enters debug mode.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param Freeze New value of the freeze. Use constants from group "Freeze
|
|
* constants". This parameter is 32 bits wide.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: PIT_MCR.
|
|
* @par Example:
|
|
* @code
|
|
* PIT_PDD_ModuleFreeze(<peripheral>_BASE_PTR, PIT_PDD_TIMERS_RUN);
|
|
* @endcode
|
|
*/
|
|
#define PIT_PDD_ModuleFreeze(PeripheralBase, Freeze) ( \
|
|
PIT_MCR_REG(PeripheralBase) = \
|
|
(uint32)(( \
|
|
(uint32)(PIT_MCR_REG(PeripheralBase) & (uint32)(~(uint32)PIT_MCR_FRZ_MASK))) | ( \
|
|
(uint32)(Freeze))) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- WriteLoadReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Writes value to the load register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param ChannelIdx PIT channel index. Use constants from group "PIT channel
|
|
* constants". This parameter is 32 bits wide.
|
|
* @param Value New content of the load register. This parameter is a 32-bit
|
|
* value.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: LDVAL[ChannelIdx].
|
|
* @par Example:
|
|
* @code
|
|
* PIT_PDD_WriteLoadReg(<peripheral>_BASE_PTR, PIT_PDD_CHANNEL_0, 1);
|
|
* @endcode
|
|
*/
|
|
#define PIT_PDD_WriteLoadReg(PeripheralBase, ChannelIdx, Value) ( \
|
|
PIT_LDVAL_REG(PeripheralBase,(ChannelIdx)) = \
|
|
(uint32)(Value) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- ReadLoadReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Returns the content of the load register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param ChannelIdx PIT channel index. Use constants from group "PIT channel
|
|
* constants". This parameter is 32 bits wide.
|
|
* @return Returns a 32-bit value.
|
|
* @remarks The macro accesses the following registers: LDVAL[ChannelIdx].
|
|
* @par Example:
|
|
* @code
|
|
* uint32 result = PIT_PDD_ReadLoadReg(<peripheral>_BASE_PTR,
|
|
* PIT_PDD_CHANNEL_0);
|
|
* @endcode
|
|
*/
|
|
#define PIT_PDD_ReadLoadReg(PeripheralBase, ChannelIdx) ( \
|
|
PIT_LDVAL_REG(PeripheralBase,(ChannelIdx)) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- ReadTimerValueReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Returns the content of the current timer value register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param ChannelIdx PIT channel index. Use constants from group "PIT channel
|
|
* constants". This parameter is 32 bits wide.
|
|
* @return Returns a 32-bit value.
|
|
* @remarks The macro accesses the following registers: CVAL[ChannelIdx].
|
|
* @par Example:
|
|
* @code
|
|
* uint32 result = PIT_PDD_ReadTimerValueReg(<peripheral>_BASE_PTR,
|
|
* PIT_PDD_CHANNEL_0);
|
|
* @endcode
|
|
*/
|
|
#define PIT_PDD_ReadTimerValueReg(PeripheralBase, ChannelIdx) ( \
|
|
PIT_CVAL_REG(PeripheralBase,(ChannelIdx)) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- EnableDevice
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Enables the PIT channel device.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param ChannelIdx PIT channel index. Use constants from group "PIT channel
|
|
* constants". This parameter is 32 bits wide.
|
|
* @param State Requested state of PIT channel. This parameter is of "Global
|
|
* enumeration used for specifying general enable/disable states (PDD_DISABLE
|
|
* and PDD_ENABLE defined in PDD_Types.h)" type.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: TCTRL[ChannelIdx].
|
|
* @par Example:
|
|
* @code
|
|
* PIT_PDD_EnableDevice(<peripheral>_BASE_PTR, PIT_PDD_CHANNEL_0,
|
|
* PDD_DISABLE);
|
|
* @endcode
|
|
*/
|
|
#define PIT_PDD_EnableDevice(PeripheralBase, ChannelIdx, State) ( \
|
|
PIT_TCTRL_REG(PeripheralBase,(ChannelIdx)) = \
|
|
(uint32)(( \
|
|
(uint32)(( \
|
|
PIT_TCTRL_REG(PeripheralBase,(ChannelIdx))) & ( \
|
|
(uint32)(~(uint32)PIT_TCTRL_TEN_MASK)))) | ( \
|
|
(uint32)(State))) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- GetEnableDeviceStatus
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Returns current state of PIT channel device.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param ChannelIdx PIT channel index. Use constants from group "PIT channel
|
|
* constants". This parameter is 32 bits wide.
|
|
* @return Returns a 32-bit value.
|
|
* @remarks The macro accesses the following registers: TCTRL[ChannelIdx].
|
|
* @par Example:
|
|
* @code
|
|
* uint32 result = PIT_PDD_GetEnableDeviceStatus(<peripheral>_BASE_PTR,
|
|
* PIT_PDD_CHANNEL_0);
|
|
* @endcode
|
|
*/
|
|
#define PIT_PDD_GetEnableDeviceStatus(PeripheralBase, ChannelIdx) ( \
|
|
(uint32)(PIT_TCTRL_REG(PeripheralBase,(ChannelIdx)) & PIT_TCTRL_TEN_MASK) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- WriteModuleControlReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Writes value to the module control register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param Value New content of the module control register. This parameter is a
|
|
* 32-bit value.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: PIT_MCR.
|
|
* @par Example:
|
|
* @code
|
|
* PIT_PDD_WriteModuleControlReg(<peripheral>_BASE_PTR, 1);
|
|
* @endcode
|
|
*/
|
|
#define PIT_PDD_WriteModuleControlReg(PeripheralBase, Value) ( \
|
|
PIT_MCR_REG(PeripheralBase) = \
|
|
(uint32)(Value) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- ReadModuleControlReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Returns the content of the module control register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @return Returns a 32-bit value.
|
|
* @remarks The macro accesses the following registers: PIT_MCR.
|
|
* @par Example:
|
|
* @code
|
|
* uint32 result = PIT_PDD_ReadModuleControlReg(<peripheral>_BASE_PTR);
|
|
* @endcode
|
|
*/
|
|
#define PIT_PDD_ReadModuleControlReg(PeripheralBase) ( \
|
|
PIT_MCR_REG(PeripheralBase) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- WriteTimerControlReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Writes value to the timer control register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param ChannelIdx PIT channel index. Use constants from group "PIT channel
|
|
* constants". This parameter is 32 bits wide.
|
|
* @param Value New content of the timer control register. This parameter is a
|
|
* 32-bit value.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: TCTRL[ChannelIdx].
|
|
* @par Example:
|
|
* @code
|
|
* PIT_PDD_WriteTimerControlReg(<peripheral>_BASE_PTR, PIT_PDD_CHANNEL_0,
|
|
* 1);
|
|
* @endcode
|
|
*/
|
|
#define PIT_PDD_WriteTimerControlReg(PeripheralBase, ChannelIdx, Value) ( \
|
|
PIT_TCTRL_REG(PeripheralBase,(ChannelIdx)) = \
|
|
(uint32)(Value) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- ReadTimerControlReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Returns the content of the timer control register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param ChannelIdx PIT channel index. Use constants from group "PIT channel
|
|
* constants". This parameter is 32 bits wide.
|
|
* @return Returns a 32-bit value.
|
|
* @remarks The macro accesses the following registers: TCTRL[ChannelIdx].
|
|
* @par Example:
|
|
* @code
|
|
* uint32 result = PIT_PDD_ReadTimerControlReg(<peripheral>_BASE_PTR,
|
|
* PIT_PDD_CHANNEL_0);
|
|
* @endcode
|
|
*/
|
|
#define PIT_PDD_ReadTimerControlReg(PeripheralBase, ChannelIdx) ( \
|
|
PIT_TCTRL_REG(PeripheralBase,(ChannelIdx)) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- WriteTimerFlagReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Writes value to the timer flag register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param ChannelIdx PIT channel index. Use constants from group "PIT channel
|
|
* constants". This parameter is 32 bits wide.
|
|
* @param Value New content of the timer flag register. This parameter is a
|
|
* 32-bit value.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: TFLG[ChannelIdx].
|
|
* @par Example:
|
|
* @code
|
|
* PIT_PDD_WriteTimerFlagReg(<peripheral>_BASE_PTR, PIT_PDD_CHANNEL_0, 1);
|
|
* @endcode
|
|
*/
|
|
#define PIT_PDD_WriteTimerFlagReg(PeripheralBase, ChannelIdx, Value) ( \
|
|
PIT_TFLG_REG(PeripheralBase,(ChannelIdx)) = \
|
|
(uint32)(Value) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- ReadTimerFlagReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Returns the content of the timer flag register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param ChannelIdx PIT channel index. Use constants from group "PIT channel
|
|
* constants". This parameter is 32 bits wide.
|
|
* @return Returns a 32-bit value.
|
|
* @remarks The macro accesses the following registers: TFLG[ChannelIdx].
|
|
* @par Example:
|
|
* @code
|
|
* uint32 result = PIT_PDD_ReadTimerFlagReg(<peripheral>_BASE_PTR,
|
|
* PIT_PDD_CHANNEL_0);
|
|
* @endcode
|
|
*/
|
|
#define PIT_PDD_ReadTimerFlagReg(PeripheralBase, ChannelIdx) ( \
|
|
PIT_TFLG_REG(PeripheralBase,(ChannelIdx)) \
|
|
)
|
|
#endif /* #if defined(PIT_PDD_H_) */
|
|
|
|
/* PIT_PDD.h, eof. */
|