817 lines
36 KiB
C
817 lines
36 KiB
C
|
/*
|
||
|
|
PDD layer implementation for peripheral type USBDCD
|
||
|
|
(C) 2013 Freescale, Inc. All rights reserved.
|
||
|
|
|
||
|
|
This file is static and it is generated from API-Factory
|
||
|
|
*/
|
||
|
|
|
||
|
|
#if !defined(USBDCD_PDD_H_)
|
||
|
|
#define USBDCD_PDD_H_
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- Test if supported MCU is active
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
#if !defined(MCU_ACTIVE)
|
||
|
|
// No MCU is active
|
||
|
|
#error USBDCD PDD library: No derivative is active. Place proper #include with PDD memory map before including PDD library.
|
||
|
|
#elif \
|
||
|
|
!defined(MCU_MK20D10) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK20D5) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK20D7) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK20F12) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK20DZ10) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK21D5) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK21D5WS) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK21F12) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK21F12WS) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK22D5) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK22F12) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK24F12) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK40D10) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK40D7) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK40DZ10) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK40X256VMD100) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK50D10) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK50D7) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK50DZ10) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK51D10) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK51D7) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK51DZ10) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK52D10) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK52DZ10) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK53D10) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK53DZ10) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK60D10) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK60F12) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK60F15) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK60DZ10) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK60N512VMD100) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK61F12) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK61F15) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK61F12WS) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK61F15WS) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK63F12) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK63F12WS) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK64F12) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK65F18) /* USBDCD, USBHSDCD */ && \
|
||
|
|
!defined(MCU_MK65F18WS) /* USBDCD, USBHSDCD */ && \
|
||
|
|
!defined(MCU_MK66F18) /* USBDCD, USBHSDCD */ && \
|
||
|
|
!defined(MCU_MK70F12) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK70F15) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK70F12WS) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MK70F15WS) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MKW22D5) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MKW22D5WS) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MKW24D5) /* USBDCD */ && \
|
||
|
|
!defined(MCU_MKW24D5WS) /* USBDCD */ && \
|
||
|
|
!defined(MCU_PCK20L4) /* USBDCD */
|
||
|
|
// Unsupported MCU is active
|
||
|
|
#error USBDCD PDD library: Unsupported derivative is active.
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#include "PDD_Types.h"
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- Method symbol definitions
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/* Status flags constants (for ReadStatusReg macro). */
|
||
|
|
#define USBDCD_PDD_ACTIVE_STATUS_INDICATOR USBDCD_STATUS_ACTIVE_MASK /**< Active status indicator - indicates whether the sequence is running */
|
||
|
|
#define USBDCD_PDD_TIMEOUT_FLAG USBDCD_STATUS_TO_MASK /**< Timeout flag */
|
||
|
|
#define USBDCD_PDD_ERROR_FLAG USBDCD_STATUS_ERR_MASK /**< Error flag */
|
||
|
|
|
||
|
|
/* Receiver status bits constants */
|
||
|
|
#define USBDCD_PDD_DATA_PIN_NOT_DETECTED 0U /**< The module is either not enabled, or the module is enabled but the data pins have not yet been detected */
|
||
|
|
#define USBDCD_PDD_DATA_PIN_CONTACT_COMPLETE 0x40000U /**< Data pin contact detection complete */
|
||
|
|
#define USBDCD_PDD_CHARGER_PORT_COMPLETE 0x80000U /**< Charger port detection complete */
|
||
|
|
#define USBDCD_PDD_CHARGER_TYPE_COMPLETE 0xC0000U /**< Charger type detection complete */
|
||
|
|
|
||
|
|
/* Receiver status bits constants */
|
||
|
|
#define USBDCD_PDD_NO_RESULTS_REPORTED 0U /**< No results to report */
|
||
|
|
#define USBDCD_PDD_ATTACHED_TO_HOST 0x10000U /**< Attached to a standard host */
|
||
|
|
#define USBDCD_PDD_ATTACHED_TO_CHARGING_PORT 0x20000U /**< Attached to a charging port */
|
||
|
|
#define USBDCD_PDD_ATTACHED_TO_DEDICATED_CHARGER 0x30000U /**< Attached to a dedicated charger. */
|
||
|
|
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- PerformSoftwareReset
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Perform a software reset.
|
||
|
|
* @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 value of void type.
|
||
|
|
* @remarks The macro accesses the following registers: USBDCD_CONTROL,
|
||
|
|
* USBHSDCD_CONTROL (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* USBDCD_PDD_PerformSoftwareReset(<peripheral>_BASE_PTR);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_PerformSoftwareReset(PeripheralBase) ( \
|
||
|
|
USBDCD_CONTROL_REG(PeripheralBase) |= \
|
||
|
|
USBDCD_CONTROL_SR_MASK \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- StartChangeDetectionSequence
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Initiate the charger detection sequence.
|
||
|
|
* @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 value of void type.
|
||
|
|
* @remarks The macro accesses the following registers: USBDCD_CONTROL,
|
||
|
|
* USBHSDCD_CONTROL (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* USBDCD_PDD_StartChangeDetectionSequence(<peripheral>_BASE_PTR);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_StartChangeDetectionSequence(PeripheralBase) ( \
|
||
|
|
USBDCD_CONTROL_REG(PeripheralBase) |= \
|
||
|
|
USBDCD_CONTROL_START_MASK \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- EnableInterrupt
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Enables interrupts to the system.
|
||
|
|
* @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 value of void type.
|
||
|
|
* @remarks The macro accesses the following registers: USBDCD_CONTROL,
|
||
|
|
* USBHSDCD_CONTROL (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* USBDCD_PDD_EnableInterrupt(<peripheral>_BASE_PTR);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_EnableInterrupt(PeripheralBase) ( \
|
||
|
|
USBDCD_CONTROL_REG(PeripheralBase) |= \
|
||
|
|
USBDCD_CONTROL_IE_MASK \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- DisableInterrupt
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Disable interrupts to the system.
|
||
|
|
* @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 value of void type.
|
||
|
|
* @remarks The macro accesses the following registers: USBDCD_CONTROL,
|
||
|
|
* USBHSDCD_CONTROL (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* USBDCD_PDD_DisableInterrupt(<peripheral>_BASE_PTR);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_DisableInterrupt(PeripheralBase) ( \
|
||
|
|
USBDCD_CONTROL_REG(PeripheralBase) &= \
|
||
|
|
(uint32)(~(uint32)USBDCD_CONTROL_IE_MASK) \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- GetInterruptFlag
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Gets the status of the 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).
|
||
|
|
* @return Returns a 32-bit value.
|
||
|
|
* @remarks The macro accesses the following registers: USBDCD_CONTROL,
|
||
|
|
* USBHSDCD_CONTROL (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* uint32 result = USBDCD_PDD_GetInterruptFlag(<peripheral>_BASE_PTR);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_GetInterruptFlag(PeripheralBase) ( \
|
||
|
|
(uint32)(USBDCD_CONTROL_REG(PeripheralBase) & USBDCD_CONTROL_IF_MASK) \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- ClearInterruptFlag
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Clears 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).
|
||
|
|
* @return Returns a value of void type.
|
||
|
|
* @remarks The macro accesses the following registers: USBDCD_CONTROL,
|
||
|
|
* USBHSDCD_CONTROL (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* USBDCD_PDD_ClearInterruptFlag(<peripheral>_BASE_PTR);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_ClearInterruptFlag(PeripheralBase) ( \
|
||
|
|
USBDCD_CONTROL_REG(PeripheralBase) |= \
|
||
|
|
USBDCD_CONTROL_IACK_MASK \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- ReadControlReg
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Reads 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: USBDCD_CONTROL,
|
||
|
|
* USBHSDCD_CONTROL (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* uint32 result = USBDCD_PDD_ReadControlReg(<peripheral>_BASE_PTR);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_ReadControlReg(PeripheralBase) ( \
|
||
|
|
USBDCD_CONTROL_REG(PeripheralBase) \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- WriteControlReg
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Writes data specified by the Value parameter into 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 Value to be written to the control register. This parameter is a
|
||
|
|
* 32-bit value.
|
||
|
|
* @return Returns a value of void type.
|
||
|
|
* @remarks The macro accesses the following registers: USBDCD_CONTROL,
|
||
|
|
* USBHSDCD_CONTROL (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* USBDCD_PDD_WriteControlReg(<peripheral>_BASE_PTR, 1);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_WriteControlReg(PeripheralBase, Value) ( \
|
||
|
|
USBDCD_CONTROL_REG(PeripheralBase) = \
|
||
|
|
(uint32)(Value) \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- SetClockSpeedInKhz
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Sets the numerical value of clock speed in kHz.
|
||
|
|
* @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 Clock speed in kHz, value[1..1023]. This parameter is a 10-bit
|
||
|
|
* value.
|
||
|
|
* @return Returns a value of void type.
|
||
|
|
* @remarks The macro accesses the following registers: USBDCD_CLOCK,
|
||
|
|
* USBHSDCD_CLOCK (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* USBDCD_PDD_SetClockSpeedInKhz(<peripheral>_BASE_PTR, 1);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_SetClockSpeedInKhz(PeripheralBase, Value) ( \
|
||
|
|
USBDCD_CLOCK_REG(PeripheralBase) = \
|
||
|
|
(uint32)(( \
|
||
|
|
(uint32)(( \
|
||
|
|
USBDCD_CLOCK_REG(PeripheralBase)) & (( \
|
||
|
|
(uint32)(~(uint32)USBDCD_CLOCK_CLOCK_SPEED_MASK)) & ( \
|
||
|
|
(uint32)(~(uint32)USBDCD_CLOCK_CLOCK_UNIT_MASK))))) | ( \
|
||
|
|
(uint32)((uint32)(Value) << USBDCD_CLOCK_CLOCK_SPEED_SHIFT))) \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- SetClockSpeedInMhz
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Sets the numerical value of clock speed in MHz.
|
||
|
|
* @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 Clock speed in MHz, value[1..1023]. This parameter is a 10-bit
|
||
|
|
* value.
|
||
|
|
* @return Returns a value of void type.
|
||
|
|
* @remarks The macro accesses the following registers: USBDCD_CLOCK,
|
||
|
|
* USBHSDCD_CLOCK (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* USBDCD_PDD_SetClockSpeedInMhz(<peripheral>_BASE_PTR, 1);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_SetClockSpeedInMhz(PeripheralBase, Value) ( \
|
||
|
|
USBDCD_CLOCK_REG(PeripheralBase) = \
|
||
|
|
(uint32)(( \
|
||
|
|
(uint32)(( \
|
||
|
|
USBDCD_CLOCK_REG(PeripheralBase)) & ( \
|
||
|
|
(uint32)(~(uint32)USBDCD_CLOCK_CLOCK_SPEED_MASK)))) | (( \
|
||
|
|
(uint32)((uint32)(Value) << USBDCD_CLOCK_CLOCK_SPEED_SHIFT)) | ( \
|
||
|
|
USBDCD_CLOCK_CLOCK_UNIT_MASK))) \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- ReadClockReg
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Reads clock 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: USBDCD_CLOCK,
|
||
|
|
* USBHSDCD_CLOCK (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* uint32 result = USBDCD_PDD_ReadClockReg(<peripheral>_BASE_PTR);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_ReadClockReg(PeripheralBase) ( \
|
||
|
|
USBDCD_CLOCK_REG(PeripheralBase) \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- WriteClockReg
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Writes data specified by the Value parameter into clock 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 Value to be written to the clock register. This parameter is a
|
||
|
|
* 32-bit value.
|
||
|
|
* @return Returns a value of void type.
|
||
|
|
* @remarks The macro accesses the following registers: USBDCD_CLOCK,
|
||
|
|
* USBHSDCD_CLOCK (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* USBDCD_PDD_WriteClockReg(<peripheral>_BASE_PTR, 1);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_WriteClockReg(PeripheralBase, Value) ( \
|
||
|
|
USBDCD_CLOCK_REG(PeripheralBase) = \
|
||
|
|
(uint32)(Value) \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- GetStatusFlags
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Returns the value of the status 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: USBDCD_STATUS,
|
||
|
|
* USBHSDCD_STATUS (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* uint32 result = USBDCD_PDD_GetStatusFlags(<peripheral>_BASE_PTR);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_GetStatusFlags(PeripheralBase) ( \
|
||
|
|
USBDCD_STATUS_REG(PeripheralBase) \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- GetChargerDetectionSequenceStatus
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Returns charger detection sequence status.
|
||
|
|
* @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 value of "Receiver status bits constants" type. The value
|
||
|
|
* is cast to "uint32".
|
||
|
|
* @remarks The macro accesses the following registers: USBDCD_STATUS,
|
||
|
|
* USBHSDCD_STATUS (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* uint32 result =
|
||
|
|
* USBDCD_PDD_GetChargerDetectionSequenceStatus(<peripheral>_BASE_PTR);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_GetChargerDetectionSequenceStatus(PeripheralBase) ( \
|
||
|
|
(uint32)(USBDCD_STATUS_REG(PeripheralBase) & USBDCD_STATUS_SEQ_STAT_MASK) \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- GetChargerDetectionSequenceResults
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Returns charger detection sequence status.
|
||
|
|
* @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 value of "Receiver status bits constants" type. The value
|
||
|
|
* is cast to "uint32".
|
||
|
|
* @remarks The macro accesses the following registers: USBDCD_STATUS,
|
||
|
|
* USBHSDCD_STATUS (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* uint32 result =
|
||
|
|
* USBDCD_PDD_GetChargerDetectionSequenceResults(<peripheral>_BASE_PTR);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_GetChargerDetectionSequenceResults(PeripheralBase) ( \
|
||
|
|
(uint32)(USBDCD_STATUS_REG(PeripheralBase) & USBDCD_STATUS_SEQ_RES_MASK) \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- ReadStatusReg
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Reads status 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 Use constants from group "Status flags constants (for ReadStatusReg
|
||
|
|
* macro)." for processing return value.
|
||
|
|
* @remarks The macro accesses the following registers: USBDCD_STATUS,
|
||
|
|
* USBHSDCD_STATUS (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* uint32 result = USBDCD_PDD_ReadStatusReg(<peripheral>_BASE_PTR);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_ReadStatusReg(PeripheralBase) ( \
|
||
|
|
USBDCD_STATUS_REG(PeripheralBase) \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- SetSequenceInitiationTime
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Sets the system latency (in ms).
|
||
|
|
* @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 Time System latency (in ms) value[0..1023]. This parameter is a 10-bit
|
||
|
|
* value.
|
||
|
|
* @return Returns a value of void type.
|
||
|
|
* @remarks The macro accesses the following registers: USBDCD_TIMER0,
|
||
|
|
* USBHSDCD_TIMER0 (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* USBDCD_PDD_SetSequenceInitiationTime(<peripheral>_BASE_PTR, 1);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_SetSequenceInitiationTime(PeripheralBase, Time) ( \
|
||
|
|
USBDCD_TIMER0_REG(PeripheralBase) = \
|
||
|
|
(uint32)(( \
|
||
|
|
(uint32)(( \
|
||
|
|
USBDCD_TIMER0_REG(PeripheralBase)) & ( \
|
||
|
|
(uint32)(~(uint32)USBDCD_TIMER0_TSEQ_INIT_MASK)))) | ( \
|
||
|
|
(uint32)((uint32)(Time) << USBDCD_TIMER0_TSEQ_INIT_SHIFT))) \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- GetUnitConnectionTimerElapse
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Returns unit connection timer elapse value (in ms).
|
||
|
|
* @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 12-bit value. The value is cast to "uint16".
|
||
|
|
* @remarks The macro accesses the following registers: USBDCD_TIMER0,
|
||
|
|
* USBHSDCD_TIMER0 (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* uint16 result =
|
||
|
|
* USBDCD_PDD_GetUnitConnectionTimerElapse(<peripheral>_BASE_PTR);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_GetUnitConnectionTimerElapse(PeripheralBase) ( \
|
||
|
|
(uint16)(USBDCD_TIMER0_REG(PeripheralBase) & USBDCD_TIMER0_TUNITCON_MASK) \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- ReadTimer0Reg
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Reads timer 0 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: USBDCD_TIMER0,
|
||
|
|
* USBHSDCD_TIMER0 (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* uint32 result = USBDCD_PDD_ReadTimer0Reg(<peripheral>_BASE_PTR);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_ReadTimer0Reg(PeripheralBase) ( \
|
||
|
|
USBDCD_TIMER0_REG(PeripheralBase) \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- WriteTimer0Reg
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Writes data specified by the Value parameter into timer 0 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 Value to be written to the timer 0 register. This parameter is a
|
||
|
|
* 32-bit value.
|
||
|
|
* @return Returns a value of void type.
|
||
|
|
* @remarks The macro accesses the following registers: USBDCD_TIMER0,
|
||
|
|
* USBHSDCD_TIMER0 (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* USBDCD_PDD_WriteTimer0Reg(<peripheral>_BASE_PTR, 1);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_WriteTimer0Reg(PeripheralBase, Value) ( \
|
||
|
|
USBDCD_TIMER0_REG(PeripheralBase) = \
|
||
|
|
(uint32)(Value) \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- SetTimePeriodToDebounceDpSignal
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Sets the time period (ms) to debounce the D+ signal during the data
|
||
|
|
* pin contact detection phase.
|
||
|
|
* @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 Period Time period (in ms) value[1..1023]. This parameter is a 10-bit
|
||
|
|
* value.
|
||
|
|
* @return Returns a value of void type.
|
||
|
|
* @remarks The macro accesses the following registers: USBDCD_TIMER1,
|
||
|
|
* USBHSDCD_TIMER1 (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* USBDCD_PDD_SetTimePeriodToDebounceDpSignal(<peripheral>_BASE_PTR, 1);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_SetTimePeriodToDebounceDpSignal(PeripheralBase, Period) ( \
|
||
|
|
USBDCD_TIMER1_REG(PeripheralBase) = \
|
||
|
|
(uint32)(( \
|
||
|
|
(uint32)(( \
|
||
|
|
USBDCD_TIMER1_REG(PeripheralBase)) & ( \
|
||
|
|
(uint32)(~(uint32)USBDCD_TIMER1_TDCD_DBNC_MASK)))) | ( \
|
||
|
|
(uint32)((uint32)(Period) << USBDCD_TIMER1_TDCD_DBNC_SHIFT))) \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- SetTimePeriodComparator
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Sets the time period (ms) comparator enabled.
|
||
|
|
* @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 Period Time period (in ms) value[1..1023]. This parameter is a 10-bit
|
||
|
|
* value.
|
||
|
|
* @return Returns a value of void type.
|
||
|
|
* @remarks The macro accesses the following registers: USBDCD_TIMER1,
|
||
|
|
* USBHSDCD_TIMER1 (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* USBDCD_PDD_SetTimePeriodComparator(<peripheral>_BASE_PTR, 1);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_SetTimePeriodComparator(PeripheralBase, Period) ( \
|
||
|
|
USBDCD_TIMER1_REG(PeripheralBase) = \
|
||
|
|
(uint32)(( \
|
||
|
|
(uint32)(( \
|
||
|
|
USBDCD_TIMER1_REG(PeripheralBase)) & ( \
|
||
|
|
(uint32)(~(uint32)USBDCD_TIMER1_TVDPSRC_ON_MASK)))) | ( \
|
||
|
|
(uint32)(Period))) \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- ReadTimer1Reg
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Reads timer 1 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: USBDCD_TIMER1,
|
||
|
|
* USBHSDCD_TIMER1 (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* uint32 result = USBDCD_PDD_ReadTimer1Reg(<peripheral>_BASE_PTR);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_ReadTimer1Reg(PeripheralBase) ( \
|
||
|
|
USBDCD_TIMER1_REG(PeripheralBase) \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- WriteTimer1Reg
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Writes data specified by the Value parameter into timer 1 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 Value to be written to the timer 1 register. This parameter is a
|
||
|
|
* 32-bit value.
|
||
|
|
* @return Returns a value of void type.
|
||
|
|
* @remarks The macro accesses the following registers: USBDCD_TIMER1,
|
||
|
|
* USBHSDCD_TIMER1 (depending on the peripheral).
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* USBDCD_PDD_WriteTimer1Reg(<peripheral>_BASE_PTR, 1);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_WriteTimer1Reg(PeripheralBase, Value) ( \
|
||
|
|
USBDCD_TIMER1_REG(PeripheralBase) = \
|
||
|
|
(uint32)(Value) \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- SetTimePeriodBeforeEnablingDpPullup
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Sets the time period (ms) before enabling D+ pullup.
|
||
|
|
* @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 Period Time period (in ms) value[1..1023]. This parameter is a 10-bit
|
||
|
|
* value.
|
||
|
|
* @return Returns a value of void type.
|
||
|
|
* @remarks The macro accesses the following registers: USBDCD_TIMER2.
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* USBDCD_PDD_SetTimePeriodBeforeEnablingDpPullup(<peripheral>_BASE_PTR,
|
||
|
|
* 1);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_SetTimePeriodBeforeEnablingDpPullup(PeripheralBase, Period) ( \
|
||
|
|
USBDCD_TIMER2_REG(PeripheralBase) = \
|
||
|
|
(uint32)(( \
|
||
|
|
(uint32)(( \
|
||
|
|
USBDCD_TIMER2_REG(PeripheralBase)) & ( \
|
||
|
|
(uint32)(~(uint32)USBDCD_TIMER2_TVDPSRC_CON_MASK)))) | ( \
|
||
|
|
(uint32)((uint32)(Period) << USBDCD_TIMER2_TVDPSRC_CON_SHIFT))) \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- SetTimeBeforeCheckDmLine
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Sets the time period (ms) before check D- line.
|
||
|
|
* @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 Time (in ms) value[1..15]. This parameter is a 4-bit value.
|
||
|
|
* @return Returns a value of void type.
|
||
|
|
* @remarks The macro accesses the following registers: USBDCD_TIMER2.
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* USBDCD_PDD_SetTimeBeforeCheckDmLine(<peripheral>_BASE_PTR, 1);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_SetTimeBeforeCheckDmLine(PeripheralBase, Value) ( \
|
||
|
|
USBDCD_TIMER2_REG(PeripheralBase) = \
|
||
|
|
(uint32)(( \
|
||
|
|
(uint32)(( \
|
||
|
|
USBDCD_TIMER2_REG(PeripheralBase)) & ( \
|
||
|
|
(uint32)(~(uint32)USBDCD_TIMER2_CHECK_DM_MASK)))) | ( \
|
||
|
|
(uint32)(Value))) \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- ReadTimer2Reg
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Reads timer 2 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: USBDCD_TIMER2.
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* uint32 result = USBDCD_PDD_ReadTimer2Reg(<peripheral>_BASE_PTR);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_ReadTimer2Reg(PeripheralBase) ( \
|
||
|
|
USBDCD_TIMER2_REG(PeripheralBase) \
|
||
|
|
)
|
||
|
|
|
||
|
|
/* ----------------------------------------------------------------------------
|
||
|
|
-- WriteTimer2Reg
|
||
|
|
---------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Writes data specified by the Value parameter into timer 2 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 Value to be written to the timer 2 register. This parameter is a
|
||
|
|
* 32-bit value.
|
||
|
|
* @return Returns a value of void type.
|
||
|
|
* @remarks The macro accesses the following registers: USBDCD_TIMER2.
|
||
|
|
* @par Example:
|
||
|
|
* @code
|
||
|
|
* USBDCD_PDD_WriteTimer2Reg(<peripheral>_BASE_PTR, 1);
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
#define USBDCD_PDD_WriteTimer2Reg(PeripheralBase, Value) ( \
|
||
|
|
USBDCD_TIMER2_REG(PeripheralBase) = \
|
||
|
|
(uint32)(Value) \
|
||
|
|
)
|
||
|
|
#endif /* #if defined(USBDCD_PDD_H_) */
|
||
|
|
|
||
|
|
/* USBDCD_PDD.h, eof. */
|