/* PDD layer implementation for peripheral type USB (C) 2013 Freescale, Inc. All rights reserved. This file is static and it is generated from API-Factory */ #if !defined(USB_PDD_H_) #define USB_PDD_H_ /* ---------------------------------------------------------------------------- -- Test if supported MCU is active ---------------------------------------------------------------------------- */ #if !defined(MCU_ACTIVE) // No MCU is active #error USB PDD library: No derivative is active. Place proper #include with PDD memory map before including PDD library. #elif \ !defined(MCU_MK20D10) /* USB0 */ && \ !defined(MCU_MK20D5) /* USB0 */ && \ !defined(MCU_MK20D7) /* USB0 */ && \ !defined(MCU_MK20F12) /* USB0 */ && \ !defined(MCU_MK20DZ10) /* USB0 */ && \ !defined(MCU_MK21D5) /* USB0 */ && \ !defined(MCU_MK21D5WS) /* USB0 */ && \ !defined(MCU_MK21F12) /* USB0 */ && \ !defined(MCU_MK21F12WS) /* USB0 */ && \ !defined(MCU_MK22D5) /* USB0 */ && \ !defined(MCU_MK22F12810) /* USB0 */ && \ !defined(MCU_MK22F12) /* USB0 */ && \ !defined(MCU_MK22F25612) /* USB0 */ && \ !defined(MCU_MK22F51212) /* USB0 */ && \ !defined(MCU_MK24F12) /* USB0 */ && \ !defined(MCU_MK40D10) /* USB0 */ && \ !defined(MCU_MK40D7) /* USB0 */ && \ !defined(MCU_MK40DZ10) /* USB0 */ && \ !defined(MCU_MK40X256VMD100) /* USB0 */ && \ !defined(MCU_MK50D10) /* USB0 */ && \ !defined(MCU_MK50D7) /* USB0 */ && \ !defined(MCU_MK50DZ10) /* USB0 */ && \ !defined(MCU_MK51D10) /* USB0 */ && \ !defined(MCU_MK51D7) /* USB0 */ && \ !defined(MCU_MK51DZ10) /* USB0 */ && \ !defined(MCU_MK52D10) /* USB0 */ && \ !defined(MCU_MK52DZ10) /* USB0 */ && \ !defined(MCU_MK53D10) /* USB0 */ && \ !defined(MCU_MK53DZ10) /* USB0 */ && \ !defined(MCU_MK60D10) /* USB0 */ && \ !defined(MCU_MK60F12) /* USB0 */ && \ !defined(MCU_MK60F15) /* USB0 */ && \ !defined(MCU_MK60DZ10) /* USB0 */ && \ !defined(MCU_MK60N512VMD100) /* USB0 */ && \ !defined(MCU_MK61F12) /* USB0 */ && \ !defined(MCU_MK61F15) /* USB0 */ && \ !defined(MCU_MK61F12WS) /* USB0 */ && \ !defined(MCU_MK61F15WS) /* USB0 */ && \ !defined(MCU_MK63F12) /* USB0 */ && \ !defined(MCU_MK63F12WS) /* USB0 */ && \ !defined(MCU_MK64F12) /* USB0 */ && \ !defined(MCU_MK65F18) /* USB0 */ && \ !defined(MCU_MK65F18WS) /* USB0 */ && \ !defined(MCU_MK66F18) /* USB0 */ && \ !defined(MCU_MK70F12) /* USB0 */ && \ !defined(MCU_MK70F15) /* USB0 */ && \ !defined(MCU_MK70F12WS) /* USB0 */ && \ !defined(MCU_MK70F15WS) /* USB0 */ && \ !defined(MCU_MKL24Z4) /* USB0 */ && \ !defined(MCU_MKL25Z4) /* USB0 */ && \ !defined(MCU_MKL26Z4) /* USB0 */ && \ !defined(MCU_MKL46Z4) /* USB0 */ && \ !defined(MCU_MKW22D5) /* USB0 */ && \ !defined(MCU_MKW22D5WS) /* USB0 */ && \ !defined(MCU_MKW24D5) /* USB0 */ && \ !defined(MCU_MKW24D5WS) /* USB0 */ && \ !defined(MCU_PCK20L4) /* USB0 */ // Unsupported MCU is active #error USB PDD library: Unsupported derivative is active. #endif #include "PDD_Types.h" /* ---------------------------------------------------------------------------- -- Method symbol definitions ---------------------------------------------------------------------------- */ /* Otg interrupt masks */ #define USB_PDD_A_VBUS_CHG_INT USB_OTGICR_AVBUSEN_MASK /**< Vbus change interrupt mask */ #define USB_PDD_B_SESS_CHG_INT USB_OTGICR_BSESSEN_MASK /**< B session change interrupt mask */ #define USB_PDD_SESS_VLD_CHG_INT USB_OTGICR_SESSVLDEN_MASK /**< Session valid change interrupt mask */ #define USB_PDD_LINE_STATE_CHG_INT USB_OTGICR_LINESTATEEN_MASK /**< Line state change interrupt mask */ #define USB_PDD_1_MSEC_INT USB_OTGICR_ONEMSECEN_MASK /**< 1 ms interrupt mask */ #define USB_PDD_ID_CHG_INT USB_OTGICR_IDEN_MASK /**< ID change interrupt mask */ /* Otg interrupt masks */ #define USB_PDD_ALL_INT_FLAGS 0xFFU /**< Value used to mask all Otg interrupts */ /* Otg status masks */ #define USB_PDD_A_VBUS_VALID USB_OTGSTAT_AVBUSVLD_MASK /**< A VBus valid signal mask */ #define USB_PDD_B_SESSION_END USB_OTGSTAT_BSESSEND_MASK /**< B session end signal mask */ #define USB_PDD_SESSION_VALID USB_OTGSTAT_SESS_VLD_MASK /**< Session valid signal mask */ #define USB_PDD_LINE_STABLE USB_OTGSTAT_LINESTATESTABLE_MASK /**< Line stable signal mask */ #define USB_PDD_ID USB_OTGSTAT_ID_MASK /**< ID signal mask */ /* Usb interrupt masks */ #define USB_PDD_STALL_INT USB_INTEN_STALLEN_MASK /**< Stall interrupt mask */ #define USB_PDD_ATTACH_INT USB_INTEN_ATTACHEN_MASK /**< Attach interrupt mask */ #define USB_PDD_RESUME_INT USB_INTEN_RESUMEEN_MASK /**< Resume interrupt mask */ #define USB_PDD_SLEEP_INT USB_INTEN_SLEEPEN_MASK /**< Sleed interrupt mask */ #define USB_PDD_TOK_DNE_INT USB_INTEN_TOKDNEEN_MASK /**< Token done interrupt mask */ #define USB_PDD_SOF_TOK_INT USB_INTEN_SOFTOKEN_MASK /**< Star of frame interrupt mask */ #define USB_PDD_ERROR_INT USB_INTEN_ERROREN_MASK /**< Error interrupt mask */ #define USB_PDD_USB_RST_INT USB_INTEN_USBRSTEN_MASK /**< Bus reset interrupt mask */ /* Error interrupt masks */ #define USB_PDD_BTS_ERR_INT USB_ERREN_BTSERREN_MASK /**< BTS error interrupt mask */ #define USB_PDD_DMA_ERR_INT USB_ERREN_DMAERREN_MASK /**< DNA error interrupt mask */ #define USB_PDD_BTO_ERR_INT USB_ERREN_BTOERREN_MASK /**< BTO errot interrupt mask */ #define USB_PDD_DFN8_INT USB_ERREN_DFN8EN_MASK /**< DFN8 error interrupt mask */ #define USB_PDD_CRC16_INT USB_ERREN_CRC16EN_MASK /**< CRC16 interrupt mask */ #define USB_PDD_CRC5_EOF_INT USB_ERREN_CRC5EOFEN_MASK /**< CRC5 or EOF error interrupt mask */ #define USB_PDD_PID_ERR_INT USB_ERREN_PIDERREN_MASK /**< PID error interrupt mask */ /* Conrol register masks */ #define USB_PDD_JSTATE USB_CTL_JSTATE_MASK /**< J state mask */ #define USB_PDD_SE0 USB_CTL_SE0_MASK /**< SE0 mask */ /* Otg output signal masks */ #define USB_PDD_DP_PU_SIGNAL USB_OBSERVE_DPPU_MASK /**< D+ pull-up signal mask */ #define USB_PDD_DP_PD_SIGNAL USB_OBSERVE_DPPD_MASK /**< D+ pull-down signal mask */ #define USB_PDD_DM_PD_SIGNAL USB_OBSERVE_DMPD_MASK /**< D- pull-down signal mask */ /* Otg input signal masks */ #define USB_PDD_DEVICE_VBUS_DETECT_SIGNAL USB_CONTROL_DPPULLUPNONOTG_MASK /**< Device mode Vbus detect signal mask */ /* Bus speed */ #define USB_PDD_LOW_SPEED 0U /**< Low speed constant */ #define USB_PDD_FULL_SPEED 0x80U /**< Full speed constant */ #define USB_PDD_RESET 0x40U /**< Bus reset state constant */ /* ---------------------------------------------------------------------------- -- ReadPeripheralIdReg ---------------------------------------------------------------------------- */ /** * @brief Reads peripheral ID register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_PERID. * @par Example: * @code * uint8 result = USB_PDD_ReadPeripheralIdReg(_BASE_PTR); * @endcode */ #define USB_PDD_ReadPeripheralIdReg(PeripheralBase) ( \ USB_PERID_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- ReadPeripheralIdComplementReg ---------------------------------------------------------------------------- */ /** * @brief Reads peripheral ID complement register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_IDCOMP. * @par Example: * @code * uint8 result = * USB_PDD_ReadPeripheralIdComplementReg(_BASE_PTR); * @endcode */ #define USB_PDD_ReadPeripheralIdComplementReg(PeripheralBase) ( \ USB_IDCOMP_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- ReadPeripheralRevisionReg ---------------------------------------------------------------------------- */ /** * @brief Reads peripheral revision register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_REV. * @par Example: * @code * uint8 result = * USB_PDD_ReadPeripheralRevisionReg(_BASE_PTR); * @endcode */ #define USB_PDD_ReadPeripheralRevisionReg(PeripheralBase) ( \ USB_REV_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- ReadAdditionalInfoReg ---------------------------------------------------------------------------- */ /** * @brief Reads additional info register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_ADDINFO. * @par Example: * @code * uint8 result = USB_PDD_ReadAdditionalInfoReg(_BASE_PTR); * @endcode */ #define USB_PDD_ReadAdditionalInfoReg(PeripheralBase) ( \ USB_ADDINFO_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- GetOtgInterruptFlags ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Otg interrupt 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Use constants from group "Otg interrupt masks" for processing return * value. * @remarks The macro accesses the following registers: USB0_OTGISTAT. * @par Example: * @code * uint8 result = USB_PDD_GetOtgInterruptFlags(_BASE_PTR); * @endcode */ #define USB_PDD_GetOtgInterruptFlags(PeripheralBase) ( \ USB_OTGISTAT_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- ClearOtgInterruptFlags ---------------------------------------------------------------------------- */ /** * @brief Clears flags defined by the Mask parameter. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Mask Interrupt mask. Use constants from group "Otg interrupt masks". * This parameter is 8 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGISTAT. * @par Example: * @code * USB_PDD_ClearOtgInterruptFlags(_BASE_PTR, * USB_PDD_A_VBUS_CHG_INT); * @endcode */ #define USB_PDD_ClearOtgInterruptFlags(PeripheralBase, Mask) ( \ USB_OTGISTAT_REG(PeripheralBase) = \ (uint8)(Mask) \ ) /* ---------------------------------------------------------------------------- -- GetIdChgInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the ID changed flag. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_OTGISTAT. * @par Example: * @code * uint8 result = USB_PDD_GetIdChgInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_GetIdChgInterruptFlag(PeripheralBase) ( \ (uint8)(USB_OTGISTAT_REG(PeripheralBase) & USB_OTGISTAT_IDCHG_MASK) \ ) /* ---------------------------------------------------------------------------- -- Get1msInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the 1 ms 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_OTGISTAT. * @par Example: * @code * uint8 result = USB_PDD_Get1msInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_Get1msInterruptFlag(PeripheralBase) ( \ (uint8)(USB_OTGISTAT_REG(PeripheralBase) & USB_OTGISTAT_ONEMSEC_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetLineStateChgInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the Line state change flag. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_OTGISTAT. * @par Example: * @code * uint8 result = * USB_PDD_GetLineStateChgInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_GetLineStateChgInterruptFlag(PeripheralBase) ( \ (uint8)(USB_OTGISTAT_REG(PeripheralBase) & USB_OTGISTAT_LINE_STATE_CHG_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetSessVldChgInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the Session valalid changed flag. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_OTGISTAT. * @par Example: * @code * uint8 result = * USB_PDD_GetSessVldChgInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_GetSessVldChgInterruptFlag(PeripheralBase) ( \ (uint8)(USB_OTGISTAT_REG(PeripheralBase) & USB_OTGISTAT_SESSVLDCHG_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetBsessVldChgInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the B session end changed flag. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_OTGISTAT. * @par Example: * @code * uint8 result = * USB_PDD_GetBsessVldChgInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_GetBsessVldChgInterruptFlag(PeripheralBase) ( \ (uint8)(USB_OTGISTAT_REG(PeripheralBase) & USB_OTGISTAT_B_SESS_CHG_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetAVbusChgInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the A Vbus changed flag. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_OTGISTAT. * @par Example: * @code * uint8 result = * USB_PDD_GetAVbusChgInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_GetAVbusChgInterruptFlag(PeripheralBase) ( \ (uint8)(USB_OTGISTAT_REG(PeripheralBase) & USB_OTGISTAT_AVBUSCHG_MASK) \ ) /* ---------------------------------------------------------------------------- -- ClearIdChgInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Clears the ID changed flag. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGISTAT. * @par Example: * @code * USB_PDD_ClearIdChgInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearIdChgInterruptFlag(PeripheralBase) ( \ USB_OTGISTAT_REG(PeripheralBase) |= \ USB_OTGISTAT_IDCHG_MASK \ ) /* ---------------------------------------------------------------------------- -- Clear1msInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Clears the 1 ms flag. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGISTAT. * @par Example: * @code * USB_PDD_Clear1msInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_Clear1msInterruptFlag(PeripheralBase) ( \ USB_OTGISTAT_REG(PeripheralBase) |= \ USB_OTGISTAT_ONEMSEC_MASK \ ) /* ---------------------------------------------------------------------------- -- ClearLineStateChgInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Clears the Line state changed flag. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGISTAT. * @par Example: * @code * USB_PDD_ClearLineStateChgInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearLineStateChgInterruptFlag(PeripheralBase) ( \ USB_OTGISTAT_REG(PeripheralBase) |= \ USB_OTGISTAT_LINE_STATE_CHG_MASK \ ) /* ---------------------------------------------------------------------------- -- ClearSessVldChgInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Clears the Session valid changed flag. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGISTAT. * @par Example: * @code * USB_PDD_ClearSessVldChgInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearSessVldChgInterruptFlag(PeripheralBase) ( \ USB_OTGISTAT_REG(PeripheralBase) |= \ USB_OTGISTAT_SESSVLDCHG_MASK \ ) /* ---------------------------------------------------------------------------- -- ClearBsessVldChgInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Clears the B session end changed flag. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGISTAT. * @par Example: * @code * USB_PDD_ClearBsessVldChgInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearBsessVldChgInterruptFlag(PeripheralBase) ( \ USB_OTGISTAT_REG(PeripheralBase) |= \ USB_OTGISTAT_B_SESS_CHG_MASK \ ) /* ---------------------------------------------------------------------------- -- ClearAVbusChgInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Clears the A Vbus changed flag. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGISTAT. * @par Example: * @code * USB_PDD_ClearAVbusChgInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearAVbusChgInterruptFlag(PeripheralBase) ( \ USB_OTGISTAT_REG(PeripheralBase) |= \ USB_OTGISTAT_AVBUSCHG_MASK \ ) /* ---------------------------------------------------------------------------- -- GetOtgInterruptMask ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Otg interrupt enable register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Use constants from group "Otg interrupt masks" for processing return * value. * @remarks The macro accesses the following registers: USB0_OTGICR. * @par Example: * @code * uint8 result = USB_PDD_GetOtgInterruptMask(_BASE_PTR); * @endcode */ #define USB_PDD_GetOtgInterruptMask(PeripheralBase) ( \ USB_OTGICR_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- SetOtgInterruptMask ---------------------------------------------------------------------------- */ /** * @brief Enables interrupts defined by the Mask parameter. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Mask Interrupt mask. Use constants from group "Otg interrupt masks". * This parameter is 8 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGICR. * @par Example: * @code * USB_PDD_SetOtgInterruptMask(_BASE_PTR, * USB_PDD_A_VBUS_CHG_INT); * @endcode */ #define USB_PDD_SetOtgInterruptMask(PeripheralBase, Mask) ( \ USB_OTGICR_REG(PeripheralBase) = \ (uint8)(Mask) \ ) /* ---------------------------------------------------------------------------- -- EnableIdChgInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the ID changed interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGICR. * @par Example: * @code * USB_PDD_EnableIdChgInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_EnableIdChgInterrupt(PeripheralBase) ( \ USB_OTGICR_REG(PeripheralBase) |= \ USB_OTGICR_IDEN_MASK \ ) /* ---------------------------------------------------------------------------- -- Enable1msInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the 1 ms interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGICR. * @par Example: * @code * USB_PDD_Enable1msInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_Enable1msInterrupt(PeripheralBase) ( \ USB_OTGICR_REG(PeripheralBase) |= \ USB_OTGICR_ONEMSECEN_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableLineStateChgInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the Line stable interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGICR. * @par Example: * @code * USB_PDD_EnableLineStateChgInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_EnableLineStateChgInterrupt(PeripheralBase) ( \ USB_OTGICR_REG(PeripheralBase) |= \ USB_OTGICR_LINESTATEEN_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableSessVldChgInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the Session valid changed interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGICR. * @par Example: * @code * USB_PDD_EnableSessVldChgInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_EnableSessVldChgInterrupt(PeripheralBase) ( \ USB_OTGICR_REG(PeripheralBase) |= \ USB_OTGICR_SESSVLDEN_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableBsessVldChgInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the B session end changed interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGICR. * @par Example: * @code * USB_PDD_EnableBsessVldChgInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_EnableBsessVldChgInterrupt(PeripheralBase) ( \ USB_OTGICR_REG(PeripheralBase) |= \ USB_OTGICR_BSESSEN_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableAVbusChgInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the A Vbus changed interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGICR. * @par Example: * @code * USB_PDD_EnableAVbusChgInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_EnableAVbusChgInterrupt(PeripheralBase) ( \ USB_OTGICR_REG(PeripheralBase) |= \ USB_OTGICR_AVBUSEN_MASK \ ) /* ---------------------------------------------------------------------------- -- DisableIdChgInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the ID changed interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGICR. * @par Example: * @code * USB_PDD_DisableIdChgInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_DisableIdChgInterrupt(PeripheralBase) ( \ USB_OTGICR_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_OTGICR_IDEN_MASK) \ ) /* ---------------------------------------------------------------------------- -- Disable1msInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the 1 ms interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGICR. * @par Example: * @code * USB_PDD_Disable1msInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_Disable1msInterrupt(PeripheralBase) ( \ USB_OTGICR_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_OTGICR_ONEMSECEN_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableLineStateChgInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the Line state changed interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGICR. * @par Example: * @code * USB_PDD_DisableLineStateChgInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_DisableLineStateChgInterrupt(PeripheralBase) ( \ USB_OTGICR_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_OTGICR_LINESTATEEN_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableSessVldChgInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the Session valid changed interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGICR. * @par Example: * @code * USB_PDD_DisableSessVldChgInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_DisableSessVldChgInterrupt(PeripheralBase) ( \ USB_OTGICR_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_OTGICR_SESSVLDEN_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableBsessVldChgInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the B session end changed interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGICR. * @par Example: * @code * USB_PDD_DisableBsessVldChgInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_DisableBsessVldChgInterrupt(PeripheralBase) ( \ USB_OTGICR_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_OTGICR_BSESSEN_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableAVbusChgInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the A Vbus changed interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGICR. * @par Example: * @code * USB_PDD_DisableAVbusChgInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_DisableAVbusChgInterrupt(PeripheralBase) ( \ USB_OTGICR_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_OTGICR_AVBUSEN_MASK) \ ) /* ---------------------------------------------------------------------------- -- ReadOtgStatusReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Otg 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Use constants from group "Otg status masks" for processing return * value. * @remarks The macro accesses the following registers: USB0_OTGSTAT. * @par Example: * @code * uint8 result = USB_PDD_ReadOtgStatusReg(_BASE_PTR); * @endcode */ #define USB_PDD_ReadOtgStatusReg(PeripheralBase) ( \ USB_OTGSTAT_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- BDevice ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the ID bit. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_OTGSTAT. * @par Example: * @code * uint8 result = USB_PDD_BDevice(_BASE_PTR); * @endcode */ #define USB_PDD_BDevice(PeripheralBase) ( \ (uint8)(USB_OTGSTAT_REG(PeripheralBase) & USB_OTGSTAT_ID_MASK) \ ) /* ---------------------------------------------------------------------------- -- LineStateStable ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the Line stable bit. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_OTGSTAT. * @par Example: * @code * uint8 result = USB_PDD_LineStateStable(_BASE_PTR); * @endcode */ #define USB_PDD_LineStateStable(PeripheralBase) ( \ (uint8)(USB_OTGSTAT_REG(PeripheralBase) & USB_OTGSTAT_LINESTATESTABLE_MASK) \ ) /* ---------------------------------------------------------------------------- -- SessionValid ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the Session valid bit. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_OTGSTAT. * @par Example: * @code * uint8 result = USB_PDD_SessionValid(_BASE_PTR); * @endcode */ #define USB_PDD_SessionValid(PeripheralBase) ( \ (uint8)(USB_OTGSTAT_REG(PeripheralBase) & USB_OTGSTAT_SESS_VLD_MASK) \ ) /* ---------------------------------------------------------------------------- -- BSessionEnd ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the B session end bit. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_OTGSTAT. * @par Example: * @code * uint8 result = USB_PDD_BSessionEnd(_BASE_PTR); * @endcode */ #define USB_PDD_BSessionEnd(PeripheralBase) ( \ (uint8)(USB_OTGSTAT_REG(PeripheralBase) & USB_OTGSTAT_BSESSEND_MASK) \ ) /* ---------------------------------------------------------------------------- -- AVBusValid ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the A Vbus valid bit. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_OTGSTAT. * @par Example: * @code * uint8 result = USB_PDD_AVBusValid(_BASE_PTR); * @endcode */ #define USB_PDD_AVBusValid(PeripheralBase) ( \ (uint8)(USB_OTGSTAT_REG(PeripheralBase) & USB_OTGSTAT_AVBUSVLD_MASK) \ ) /* ---------------------------------------------------------------------------- -- ReadOtgStstusReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Otg 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_OTGSTAT. * @par Example: * @code * uint8 result = USB_PDD_ReadOtgStstusReg(_BASE_PTR); * @endcode */ #define USB_PDD_ReadOtgStstusReg(PeripheralBase) ( \ USB_OTGSTAT_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- GetLineStateStableState ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the Line stable bit. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_OTGSTAT. * @par Example: * @code * uint8 result = USB_PDD_GetLineStateStableState(_BASE_PTR); * @endcode */ #define USB_PDD_GetLineStateStableState(PeripheralBase) ( \ (uint8)(USB_OTGSTAT_REG(PeripheralBase) & USB_OTGSTAT_LINESTATESTABLE_MASK) \ ) /* ---------------------------------------------------------------------------- -- ReadOtgControlReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Otg 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_OTGCTL, * USB0_OTGCTL0 (depending on the peripheral). * @par Example: * @code * uint8 result = USB_PDD_ReadOtgControlReg(_BASE_PTR); * @endcode */ #define USB_PDD_ReadOtgControlReg(PeripheralBase) ( \ USB_OTGCTL_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteOtgControlReg ---------------------------------------------------------------------------- */ /** * @brief Writes Value to the Otg 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Otg control register. This parameter is a * 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGCTL, * USB0_OTGCTL0 (depending on the peripheral). * @par Example: * @code * USB_PDD_WriteOtgControlReg(_BASE_PTR, 1); * @endcode */ #define USB_PDD_WriteOtgControlReg(PeripheralBase, Value) ( \ USB_OTGCTL_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- EnableDpPullUp ---------------------------------------------------------------------------- */ /** * @brief Enables/disables D+ pull up. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param State Requested state. 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: USB0_OTGCTL, * USB0_OTGCTL0 (depending on the peripheral). * @par Example: * @code * USB_PDD_EnableDpPullUp(_BASE_PTR, PDD_DISABLE); * @endcode */ #define USB_PDD_EnableDpPullUp(PeripheralBase, State) ( \ USB_OTGCTL_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(USB_OTGCTL_REG(PeripheralBase) & (uint8)(~(uint8)USB_OTGCTL_DPHIGH_MASK))) | ( \ (uint8)((uint8)(State) << USB_OTGCTL_DPHIGH_SHIFT))) \ ) /* ---------------------------------------------------------------------------- -- EnableDpPullDown ---------------------------------------------------------------------------- */ /** * @brief Enables/disables D+ pull down. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param State Requested state. 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: USB0_OTGCTL, * USB0_OTGCTL0 (depending on the peripheral). * @par Example: * @code * USB_PDD_EnableDpPullDown(_BASE_PTR, PDD_DISABLE); * @endcode */ #define USB_PDD_EnableDpPullDown(PeripheralBase, State) ( \ USB_OTGCTL_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(USB_OTGCTL_REG(PeripheralBase) & (uint8)(~(uint8)USB_OTGCTL_DPLOW_MASK))) | ( \ (uint8)((uint8)(State) << USB_OTGCTL_DPLOW_SHIFT))) \ ) /* ---------------------------------------------------------------------------- -- EnableDmPullDown ---------------------------------------------------------------------------- */ /** * @brief Enables/disables D- pull up. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param State Requested state. 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: USB0_OTGCTL, * USB0_OTGCTL0 (depending on the peripheral). * @par Example: * @code * USB_PDD_EnableDmPullDown(_BASE_PTR, PDD_DISABLE); * @endcode */ #define USB_PDD_EnableDmPullDown(PeripheralBase, State) ( \ USB_OTGCTL_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(USB_OTGCTL_REG(PeripheralBase) & (uint8)(~(uint8)USB_OTGCTL_DMLOW_MASK))) | ( \ (uint8)((uint8)(State) << USB_OTGCTL_DMLOW_SHIFT))) \ ) /* ---------------------------------------------------------------------------- -- EnableVBUS ---------------------------------------------------------------------------- */ /** * @brief Enables/disables VBUS. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param State Requested state. 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: USB0_OTGCTL, * USB0_OTGCTL0 (depending on the peripheral). * @par Example: * @code * USB_PDD_EnableVBUS(_BASE_PTR, PDD_DISABLE); * @endcode */ #define USB_PDD_EnableVBUS(PeripheralBase, State) ( \ USB_OTGCTL_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(USB_OTGCTL_REG(PeripheralBase) & (uint8)(~(uint8)USB_OTGCTL__MASK))) | ( \ (uint8)((uint8)(State) << USB_OTGCTL__SHIFT))) \ ) /* ---------------------------------------------------------------------------- -- EnableOtgTermination ---------------------------------------------------------------------------- */ /** * @brief Enables OTG termination. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param State Requested state. 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: USB0_OTGCTL, * USB0_OTGCTL0 (depending on the peripheral). * @par Example: * @code * USB_PDD_EnableOtgTermination(_BASE_PTR, PDD_DISABLE); * @endcode */ #define USB_PDD_EnableOtgTermination(PeripheralBase, State) ( \ USB_OTGCTL_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(USB_OTGCTL_REG(PeripheralBase) & (uint8)(~(uint8)USB_OTGCTL_OTGEN_MASK))) | ( \ (uint8)((uint8)(State) << USB_OTGCTL_OTGEN_SHIFT))) \ ) /* ---------------------------------------------------------------------------- -- EnableVbusCharge ---------------------------------------------------------------------------- */ /** * @brief Enables/disables VBus charge. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param State Requested state. 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: USB0_OTGCTL, * USB0_OTGCTL0 (depending on the peripheral). * @par Example: * @code * USB_PDD_EnableVbusCharge(_BASE_PTR, PDD_DISABLE); * @endcode */ #define USB_PDD_EnableVbusCharge(PeripheralBase, State) ( \ USB_OTGCTL_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(USB_OTGCTL_REG(PeripheralBase) & (uint8)(~(uint8)((uint8)0x1U << 1U)))) | ( \ (uint8)((uint8)(State) << 1U))) \ ) /* ---------------------------------------------------------------------------- -- EnableVbusDischarge ---------------------------------------------------------------------------- */ /** * @brief Enables/disables VBus discharge. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param State Requested state. 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: USB0_OTGCTL, * USB0_OTGCTL0 (depending on the peripheral). * @par Example: * @code * USB_PDD_EnableVbusDischarge(_BASE_PTR, PDD_DISABLE); * @endcode */ #define USB_PDD_EnableVbusDischarge(PeripheralBase, State) ( \ USB_OTGCTL_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(USB_OTGCTL_REG(PeripheralBase) & (uint8)(~(uint8)0x1U))) | ( \ (uint8)(State))) \ ) /* ---------------------------------------------------------------------------- -- SetDeviceModeFullSpeedTermination ---------------------------------------------------------------------------- */ /** * @brief Sets full speed device termination. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGCTL, * USB0_OTGCTL0 (depending on the peripheral). * @par Example: * @code * USB_PDD_SetDeviceModeFullSpeedTermination(_BASE_PTR); * @endcode */ #define USB_PDD_SetDeviceModeFullSpeedTermination(PeripheralBase) ( \ USB_OTGCTL_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(( \ USB_OTGCTL_REG(PeripheralBase)) | (( \ USB_OTGCTL_DPHIGH_MASK) | ( \ USB_OTGCTL_OTGEN_MASK)))) & (( \ (uint8)(~(uint8)USB_OTGCTL_DPLOW_MASK)) & ( \ (uint8)(~(uint8)USB_OTGCTL_DMLOW_MASK)))) \ ) /* ---------------------------------------------------------------------------- -- SetHostModeTermination ---------------------------------------------------------------------------- */ /** * @brief Sets full speed host termination. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGCTL, * USB0_OTGCTL0 (depending on the peripheral). * @par Example: * @code * USB_PDD_SetHostModeTermination(_BASE_PTR); * @endcode */ #define USB_PDD_SetHostModeTermination(PeripheralBase) ( \ USB_OTGCTL_REG(PeripheralBase) = \ 0x34U \ ) /* ---------------------------------------------------------------------------- -- SetNoTermination ---------------------------------------------------------------------------- */ /** * @brief Disables all pull resistors. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OTGCTL, * USB0_OTGCTL0 (depending on the peripheral). * @par Example: * @code * USB_PDD_SetNoTermination(_BASE_PTR); * @endcode */ #define USB_PDD_SetNoTermination(PeripheralBase) ( \ USB_OTGCTL_REG(PeripheralBase) = \ 0x4U \ ) /* ---------------------------------------------------------------------------- -- GetUsbInterruptFlags ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Usb interrupt 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Use constants from group "Usb interrupt masks" for processing return * value. * @remarks The macro accesses the following registers: USB0_ISTAT. * @par Example: * @code * uint8 result = USB_PDD_GetUsbInterruptFlags(_BASE_PTR); * @endcode */ #define USB_PDD_GetUsbInterruptFlags(PeripheralBase) ( \ USB_ISTAT_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- ClearUsbInterruptFlags ---------------------------------------------------------------------------- */ /** * @brief Clears flags defined by the Mask parameter. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Mask Interrupt mask. Use constants from group "Usb interrupt masks". * This parameter is 8 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ISTAT. * @par Example: * @code * USB_PDD_ClearUsbInterruptFlags(_BASE_PTR, * USB_PDD_STALL_INT); * @endcode */ #define USB_PDD_ClearUsbInterruptFlags(PeripheralBase, Mask) ( \ USB_ISTAT_REG(PeripheralBase) = \ (uint8)(Mask) \ ) /* ---------------------------------------------------------------------------- -- GetStallInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Returnes the Stall 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_ISTAT. * @par Example: * @code * uint8 result = USB_PDD_GetStallInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_GetStallInterruptFlag(PeripheralBase) ( \ (uint8)(USB_ISTAT_REG(PeripheralBase) & USB_ISTAT_STALL_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetAttachInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Returnes the Attach 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_ISTAT. * @par Example: * @code * uint8 result = USB_PDD_GetAttachInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_GetAttachInterruptFlag(PeripheralBase) ( \ (uint8)(USB_ISTAT_REG(PeripheralBase) & USB_ISTAT_ATTACH_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetResumeInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Returnes the Resume 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_ISTAT. * @par Example: * @code * uint8 result = USB_PDD_GetResumeInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_GetResumeInterruptFlag(PeripheralBase) ( \ (uint8)(USB_ISTAT_REG(PeripheralBase) & USB_ISTAT_RESUME_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetSuspendInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Returnes the Suspend 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_ISTAT. * @par Example: * @code * uint8 result = USB_PDD_GetSuspendInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_GetSuspendInterruptFlag(PeripheralBase) ( \ (uint8)(USB_ISTAT_REG(PeripheralBase) & USB_ISTAT_SLEEP_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetTokenDoneInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Returnes the Token done 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_ISTAT. * @par Example: * @code * uint8 result = * USB_PDD_GetTokenDoneInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_GetTokenDoneInterruptFlag(PeripheralBase) ( \ (uint8)(USB_ISTAT_REG(PeripheralBase) & USB_ISTAT_TOKDNE_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetSofInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Returnes the Sof 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_ISTAT. * @par Example: * @code * uint8 result = USB_PDD_GetSofInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_GetSofInterruptFlag(PeripheralBase) ( \ (uint8)(USB_ISTAT_REG(PeripheralBase) & USB_ISTAT_SOFTOK_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetErrorInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Returnes the Error 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_ISTAT. * @par Example: * @code * uint8 result = USB_PDD_GetErrorInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_GetErrorInterruptFlag(PeripheralBase) ( \ (uint8)(USB_ISTAT_REG(PeripheralBase) & USB_ISTAT_ERROR_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetBusResetInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Returnes the Bus reset 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_ISTAT. * @par Example: * @code * uint8 result = * USB_PDD_GetBusResetInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_GetBusResetInterruptFlag(PeripheralBase) ( \ (uint8)(USB_ISTAT_REG(PeripheralBase) & USB_ISTAT_USBRST_MASK) \ ) /* ---------------------------------------------------------------------------- -- ClearStallInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Clears the Stall 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ISTAT. * @par Example: * @code * USB_PDD_ClearStallInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearStallInterruptFlag(PeripheralBase) ( \ USB_ISTAT_REG(PeripheralBase) = \ USB_ISTAT_STALL_MASK \ ) /* ---------------------------------------------------------------------------- -- ClearAttachInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Clears the Attach 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ISTAT. * @par Example: * @code * USB_PDD_ClearAttachInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearAttachInterruptFlag(PeripheralBase) ( \ USB_ISTAT_REG(PeripheralBase) = \ USB_ISTAT_ATTACH_MASK \ ) /* ---------------------------------------------------------------------------- -- ClearResumeInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Clears the Resume 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ISTAT. * @par Example: * @code * USB_PDD_ClearResumeInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearResumeInterruptFlag(PeripheralBase) ( \ USB_ISTAT_REG(PeripheralBase) = \ USB_ISTAT_RESUME_MASK \ ) /* ---------------------------------------------------------------------------- -- ClearSuspendInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Clears the Suspend 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ISTAT. * @par Example: * @code * USB_PDD_ClearSuspendInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearSuspendInterruptFlag(PeripheralBase) ( \ USB_ISTAT_REG(PeripheralBase) = \ USB_ISTAT_SLEEP_MASK \ ) /* ---------------------------------------------------------------------------- -- ClearTokenDoneInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Clears the Token done 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ISTAT. * @par Example: * @code * USB_PDD_ClearTokenDoneInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearTokenDoneInterruptFlag(PeripheralBase) ( \ USB_ISTAT_REG(PeripheralBase) = \ USB_ISTAT_TOKDNE_MASK \ ) /* ---------------------------------------------------------------------------- -- ClearSofInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Clears the Sof 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ISTAT. * @par Example: * @code * USB_PDD_ClearSofInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearSofInterruptFlag(PeripheralBase) ( \ USB_ISTAT_REG(PeripheralBase) = \ USB_ISTAT_SOFTOK_MASK \ ) /* ---------------------------------------------------------------------------- -- ClearErrorInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Clears the Error 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ISTAT. * @par Example: * @code * USB_PDD_ClearErrorInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearErrorInterruptFlag(PeripheralBase) ( \ USB_ISTAT_REG(PeripheralBase) = \ USB_ISTAT_ERROR_MASK \ ) /* ---------------------------------------------------------------------------- -- ClearBusResetInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Clears the Bus reset 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ISTAT. * @par Example: * @code * USB_PDD_ClearBusResetInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearBusResetInterruptFlag(PeripheralBase) ( \ USB_ISTAT_REG(PeripheralBase) = \ USB_ISTAT_USBRST_MASK \ ) /* ---------------------------------------------------------------------------- -- GetUsbInterruptMask ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Usb interrupt enable register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Use constants from group "Usb interrupt masks" for processing return * value. * @remarks The macro accesses the following registers: USB0_INTEN. * @par Example: * @code * uint8 result = USB_PDD_GetUsbInterruptMask(_BASE_PTR); * @endcode */ #define USB_PDD_GetUsbInterruptMask(PeripheralBase) ( \ USB_INTEN_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- SetUsbInterruptMask ---------------------------------------------------------------------------- */ /** * @brief Enables interrupts defined by the Mask parameter. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Mask Interrupt mask. Use constants from group "Usb interrupt masks". * This parameter is 8 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_INTEN. * @par Example: * @code * USB_PDD_SetUsbInterruptMask(_BASE_PTR, USB_PDD_STALL_INT); * @endcode */ #define USB_PDD_SetUsbInterruptMask(PeripheralBase, Mask) ( \ USB_INTEN_REG(PeripheralBase) = \ (uint8)(Mask) \ ) /* ---------------------------------------------------------------------------- -- EnableStallInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the Stall interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_INTEN. * @par Example: * @code * USB_PDD_EnableStallInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_EnableStallInterrupt(PeripheralBase) ( \ USB_INTEN_REG(PeripheralBase) |= \ USB_INTEN_STALLEN_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableAttachInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the Attach interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_INTEN. * @par Example: * @code * USB_PDD_EnableAttachInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_EnableAttachInterrupt(PeripheralBase) ( \ USB_INTEN_REG(PeripheralBase) |= \ USB_INTEN_ATTACHEN_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableResumeInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the Reume interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_INTEN. * @par Example: * @code * USB_PDD_EnableResumeInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_EnableResumeInterrupt(PeripheralBase) ( \ USB_INTEN_REG(PeripheralBase) |= \ USB_INTEN_RESUMEEN_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableSuspendInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the Suspend interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_INTEN. * @par Example: * @code * USB_PDD_EnableSuspendInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_EnableSuspendInterrupt(PeripheralBase) ( \ USB_INTEN_REG(PeripheralBase) |= \ USB_INTEN_SLEEPEN_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableTokenDoneInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the Token done interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_INTEN. * @par Example: * @code * USB_PDD_EnableTokenDoneInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_EnableTokenDoneInterrupt(PeripheralBase) ( \ USB_INTEN_REG(PeripheralBase) |= \ USB_INTEN_TOKDNEEN_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableSofInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the Sof interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_INTEN. * @par Example: * @code * USB_PDD_EnableSofInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_EnableSofInterrupt(PeripheralBase) ( \ USB_INTEN_REG(PeripheralBase) |= \ USB_INTEN_SOFTOKEN_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableErrorInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the Error interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_INTEN. * @par Example: * @code * USB_PDD_EnableErrorInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_EnableErrorInterrupt(PeripheralBase) ( \ USB_INTEN_REG(PeripheralBase) |= \ USB_INTEN_ERROREN_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableBusResetInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the Bus reset interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_INTEN. * @par Example: * @code * USB_PDD_EnableBusResetInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_EnableBusResetInterrupt(PeripheralBase) ( \ USB_INTEN_REG(PeripheralBase) |= \ USB_INTEN_USBRSTEN_MASK \ ) /* ---------------------------------------------------------------------------- -- DisableStallInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the Stall interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_INTEN. * @par Example: * @code * USB_PDD_DisableStallInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_DisableStallInterrupt(PeripheralBase) ( \ USB_INTEN_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_INTEN_STALLEN_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableAttachInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the Attach interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_INTEN. * @par Example: * @code * USB_PDD_DisableAttachInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_DisableAttachInterrupt(PeripheralBase) ( \ USB_INTEN_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_INTEN_ATTACHEN_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableResumeInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the Resume interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_INTEN. * @par Example: * @code * USB_PDD_DisableResumeInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_DisableResumeInterrupt(PeripheralBase) ( \ USB_INTEN_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_INTEN_RESUMEEN_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableSuspendInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the Suspend interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_INTEN. * @par Example: * @code * USB_PDD_DisableSuspendInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_DisableSuspendInterrupt(PeripheralBase) ( \ USB_INTEN_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_INTEN_SLEEPEN_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableTokenDoneInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the Token done interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_INTEN. * @par Example: * @code * USB_PDD_DisableTokenDoneInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_DisableTokenDoneInterrupt(PeripheralBase) ( \ USB_INTEN_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_INTEN_TOKDNEEN_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableSofInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the Sof interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_INTEN. * @par Example: * @code * USB_PDD_DisableSofInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_DisableSofInterrupt(PeripheralBase) ( \ USB_INTEN_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_INTEN_SOFTOKEN_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableErrorInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the Error interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_INTEN. * @par Example: * @code * USB_PDD_DisableErrorInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_DisableErrorInterrupt(PeripheralBase) ( \ USB_INTEN_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_INTEN_ERROREN_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableBusResetInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the Bus reset interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_INTEN. * @par Example: * @code * USB_PDD_DisableBusResetInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_DisableBusResetInterrupt(PeripheralBase) ( \ USB_INTEN_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_INTEN_USBRSTEN_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetErrorsInterruptFlags ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Error interrupt 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Use constants from group "Error interrupt masks" for processing * return value. * @remarks The macro accesses the following registers: USB0_ERRSTAT. * @par Example: * @code * uint8 result = USB_PDD_GetErrorsInterruptFlags(_BASE_PTR); * @endcode */ #define USB_PDD_GetErrorsInterruptFlags(PeripheralBase) ( \ USB_ERRSTAT_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- ClearErrorsInterruptFlags ---------------------------------------------------------------------------- */ /** * @brief Clears flags defined by the Mask parameter. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Mask Interrupt mask. Use constants from group "Error interrupt masks". * This parameter is 8 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ERRSTAT. * @par Example: * @code * USB_PDD_ClearErrorsInterruptFlags(_BASE_PTR, * USB_PDD_BTS_ERR_INT); * @endcode */ #define USB_PDD_ClearErrorsInterruptFlags(PeripheralBase, Mask) ( \ USB_ERRSTAT_REG(PeripheralBase) = \ (uint8)(Mask) \ ) /* ---------------------------------------------------------------------------- -- GetBtsErrInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Returns the BTS error 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_ERRSTAT. * @par Example: * @code * uint8 result = USB_PDD_GetBtsErrInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_GetBtsErrInterruptFlag(PeripheralBase) ( \ (uint8)(USB_ERRSTAT_REG(PeripheralBase) & USB_ERRSTAT_BTSERR_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetDmaErrInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Returns the DMA error 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_ERRSTAT. * @par Example: * @code * uint8 result = USB_PDD_GetDmaErrInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_GetDmaErrInterruptFlag(PeripheralBase) ( \ (uint8)(USB_ERRSTAT_REG(PeripheralBase) & USB_ERRSTAT_DMAERR_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetBtoErrInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Returns the BTO error 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_ERRSTAT. * @par Example: * @code * uint8 result = USB_PDD_GetBtoErrInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_GetBtoErrInterruptFlag(PeripheralBase) ( \ (uint8)(USB_ERRSTAT_REG(PeripheralBase) & USB_ERRSTAT_BTOERR_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetDnf8ErrInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Returns the DNF8 error 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_ERRSTAT. * @par Example: * @code * uint8 result = USB_PDD_GetDnf8ErrInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_GetDnf8ErrInterruptFlag(PeripheralBase) ( \ (uint8)(USB_ERRSTAT_REG(PeripheralBase) & USB_ERRSTAT_DFN8_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetCrc16ErrInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Returns the CRC16 error 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_ERRSTAT. * @par Example: * @code * uint8 result = * USB_PDD_GetCrc16ErrInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_GetCrc16ErrInterruptFlag(PeripheralBase) ( \ (uint8)(USB_ERRSTAT_REG(PeripheralBase) & USB_ERRSTAT_CRC16_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetCrc5EofErrInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Returns the CRC5 or EOF error 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_ERRSTAT. * @par Example: * @code * uint8 result = * USB_PDD_GetCrc5EofErrInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_GetCrc5EofErrInterruptFlag(PeripheralBase) ( \ (uint8)(USB_ERRSTAT_REG(PeripheralBase) & USB_ERRSTAT_CRC5EOF_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetPidErrInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Returns the PID error 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_ERRSTAT. * @par Example: * @code * uint8 result = USB_PDD_GetPidErrInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_GetPidErrInterruptFlag(PeripheralBase) ( \ (uint8)(USB_ERRSTAT_REG(PeripheralBase) & USB_ERRSTAT_PIDERR_MASK) \ ) /* ---------------------------------------------------------------------------- -- ClearBtsErrInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Clears the BTS error 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ERRSTAT. * @par Example: * @code * USB_PDD_ClearBtsErrInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearBtsErrInterruptFlag(PeripheralBase) ( \ USB_ERRSTAT_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(USB_ERRSTAT_REG(PeripheralBase) | USB_ERRSTAT_BTSERR_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_PIDERR_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_CRC5EOF_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_CRC16_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_DFN8_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_BTOERR_MASK)) & ( \ (uint8)(~(uint8)USB_ERRSTAT_DMAERR_MASK)))))))) \ ) /* ---------------------------------------------------------------------------- -- ClearDmaErrInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Clears the DMA error 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ERRSTAT. * @par Example: * @code * USB_PDD_ClearDmaErrInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearDmaErrInterruptFlag(PeripheralBase) ( \ USB_ERRSTAT_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(USB_ERRSTAT_REG(PeripheralBase) | USB_ERRSTAT_DMAERR_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_PIDERR_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_CRC5EOF_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_CRC16_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_DFN8_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_BTOERR_MASK)) & ( \ (uint8)(~(uint8)USB_ERRSTAT_BTSERR_MASK)))))))) \ ) /* ---------------------------------------------------------------------------- -- ClearBtoErrInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Clears the BTO error 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ERRSTAT. * @par Example: * @code * USB_PDD_ClearBtoErrInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearBtoErrInterruptFlag(PeripheralBase) ( \ USB_ERRSTAT_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(USB_ERRSTAT_REG(PeripheralBase) | USB_ERRSTAT_BTOERR_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_PIDERR_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_CRC5EOF_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_CRC16_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_DFN8_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_DMAERR_MASK)) & ( \ (uint8)(~(uint8)USB_ERRSTAT_BTSERR_MASK)))))))) \ ) /* ---------------------------------------------------------------------------- -- ClearDnf8ErrInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Clears the DFN8 error 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ERRSTAT. * @par Example: * @code * USB_PDD_ClearDnf8ErrInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearDnf8ErrInterruptFlag(PeripheralBase) ( \ USB_ERRSTAT_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(USB_ERRSTAT_REG(PeripheralBase) | USB_ERRSTAT_DFN8_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_PIDERR_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_CRC5EOF_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_CRC16_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_BTOERR_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_DMAERR_MASK)) & ( \ (uint8)(~(uint8)USB_ERRSTAT_BTSERR_MASK)))))))) \ ) /* ---------------------------------------------------------------------------- -- ClearCrc16ErrInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Clears the CRC16 error 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ERRSTAT. * @par Example: * @code * USB_PDD_ClearCrc16ErrInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearCrc16ErrInterruptFlag(PeripheralBase) ( \ USB_ERRSTAT_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(USB_ERRSTAT_REG(PeripheralBase) | USB_ERRSTAT_CRC16_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_PIDERR_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_CRC5EOF_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_DFN8_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_BTOERR_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_DMAERR_MASK)) & ( \ (uint8)(~(uint8)USB_ERRSTAT_BTSERR_MASK)))))))) \ ) /* ---------------------------------------------------------------------------- -- ClearCrc5EofErrInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Clears the CRC5 or EOF error 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ERRSTAT. * @par Example: * @code * USB_PDD_ClearCrc5EofErrInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearCrc5EofErrInterruptFlag(PeripheralBase) ( \ USB_ERRSTAT_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(USB_ERRSTAT_REG(PeripheralBase) | USB_ERRSTAT_CRC5EOF_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_PIDERR_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_CRC16_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_DFN8_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_BTOERR_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_DMAERR_MASK)) & ( \ (uint8)(~(uint8)USB_ERRSTAT_BTSERR_MASK)))))))) \ ) /* ---------------------------------------------------------------------------- -- ClearPidErrInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Clears the PID error 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ERRSTAT. * @par Example: * @code * USB_PDD_ClearPidErrInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearPidErrInterruptFlag(PeripheralBase) ( \ USB_ERRSTAT_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(USB_ERRSTAT_REG(PeripheralBase) | USB_ERRSTAT_PIDERR_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_CRC5EOF_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_CRC16_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_DFN8_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_BTOERR_MASK)) & (( \ (uint8)(~(uint8)USB_ERRSTAT_DMAERR_MASK)) & ( \ (uint8)(~(uint8)USB_ERRSTAT_BTSERR_MASK)))))))) \ ) /* ---------------------------------------------------------------------------- -- EnableBtsErrInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the BTS error interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ERREN. * @par Example: * @code * USB_PDD_EnableBtsErrInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_EnableBtsErrInterrupt(PeripheralBase) ( \ USB_ERREN_REG(PeripheralBase) |= \ USB_ERREN_BTSERREN_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableDmaErrInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the DMA error interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ERREN. * @par Example: * @code * USB_PDD_EnableDmaErrInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_EnableDmaErrInterrupt(PeripheralBase) ( \ USB_ERREN_REG(PeripheralBase) |= \ USB_ERREN_DMAERREN_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableBtoErrInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the BTO error interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ERREN. * @par Example: * @code * USB_PDD_EnableBtoErrInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_EnableBtoErrInterrupt(PeripheralBase) ( \ USB_ERREN_REG(PeripheralBase) |= \ USB_ERREN_BTOERREN_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableDnf8ErrInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the DNF8 error interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ERREN. * @par Example: * @code * USB_PDD_EnableDnf8ErrInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_EnableDnf8ErrInterrupt(PeripheralBase) ( \ USB_ERREN_REG(PeripheralBase) |= \ USB_ERREN_DFN8EN_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableCrc16ErrInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the CRC16 error interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ERREN. * @par Example: * @code * USB_PDD_EnableCrc16ErrInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_EnableCrc16ErrInterrupt(PeripheralBase) ( \ USB_ERREN_REG(PeripheralBase) |= \ USB_ERREN_CRC16EN_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableCrc5EofErrInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the CRC5 or EOF error interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ERREN. * @par Example: * @code * USB_PDD_EnableCrc5EofErrInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_EnableCrc5EofErrInterrupt(PeripheralBase) ( \ USB_ERREN_REG(PeripheralBase) |= \ USB_ERREN_CRC5EOFEN_MASK \ ) /* ---------------------------------------------------------------------------- -- EnablePidErrInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the PID error interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ERREN. * @par Example: * @code * USB_PDD_EnablePidErrInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_EnablePidErrInterrupt(PeripheralBase) ( \ USB_ERREN_REG(PeripheralBase) |= \ USB_ERREN_PIDERREN_MASK \ ) /* ---------------------------------------------------------------------------- -- DisableBtsErrInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the BTS error interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ERREN. * @par Example: * @code * USB_PDD_DisableBtsErrInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_DisableBtsErrInterrupt(PeripheralBase) ( \ USB_ERREN_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_ERREN_BTSERREN_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableDmaErrInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the DMA error interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ERREN. * @par Example: * @code * USB_PDD_DisableDmaErrInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_DisableDmaErrInterrupt(PeripheralBase) ( \ USB_ERREN_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_ERREN_DMAERREN_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableBtoErrInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the BTO error interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ERREN. * @par Example: * @code * USB_PDD_DisableBtoErrInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_DisableBtoErrInterrupt(PeripheralBase) ( \ USB_ERREN_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_ERREN_BTOERREN_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableDnf8ErrInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the DNF8 error interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ERREN. * @par Example: * @code * USB_PDD_DisableDnf8ErrInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_DisableDnf8ErrInterrupt(PeripheralBase) ( \ USB_ERREN_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_ERREN_DFN8EN_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableCrc16ErrInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the CRC16 error interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ERREN. * @par Example: * @code * USB_PDD_DisableCrc16ErrInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_DisableCrc16ErrInterrupt(PeripheralBase) ( \ USB_ERREN_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_ERREN_CRC16EN_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableCrc5EofErrInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the CRC5 or EOF error interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ERREN. * @par Example: * @code * USB_PDD_DisableCrc5EofErrInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_DisableCrc5EofErrInterrupt(PeripheralBase) ( \ USB_ERREN_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_ERREN_CRC5EOFEN_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisablePidErrInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the PID error interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ERREN. * @par Example: * @code * USB_PDD_DisablePidErrInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_DisablePidErrInterrupt(PeripheralBase) ( \ USB_ERREN_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_ERREN_PIDERREN_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetErrorInterruptMask ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Error interrupt enable register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Use constants from group "Error interrupt masks" for processing * return value. * @remarks The macro accesses the following registers: USB0_ERREN. * @par Example: * @code * uint8 result = USB_PDD_GetErrorInterruptMask(_BASE_PTR); * @endcode */ #define USB_PDD_GetErrorInterruptMask(PeripheralBase) ( \ USB_ERREN_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- SetErrorInterruptMask ---------------------------------------------------------------------------- */ /** * @brief Enables interrupts defined by the Mask parameter. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Mask Interrupt mask. Use constants from group "Error interrupt masks". * This parameter is 8 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ERREN. * @par Example: * @code * USB_PDD_SetErrorInterruptMask(_BASE_PTR, * USB_PDD_BTS_ERR_INT); * @endcode */ #define USB_PDD_SetErrorInterruptMask(PeripheralBase, Mask) ( \ USB_ERREN_REG(PeripheralBase) = \ (uint8)(Mask) \ ) /* ---------------------------------------------------------------------------- -- ReadStatusReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_STAT. * @par Example: * @code * uint8 result = USB_PDD_ReadStatusReg(_BASE_PTR); * @endcode */ #define USB_PDD_ReadStatusReg(PeripheralBase) ( \ USB_STAT_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- GetTransmitIndicator ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the TX bit in 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_STAT. * @par Example: * @code * uint8 result = USB_PDD_GetTransmitIndicator(_BASE_PTR); * @endcode */ #define USB_PDD_GetTransmitIndicator(PeripheralBase) ( \ (uint8)(USB_STAT_REG(PeripheralBase) & USB_STAT_TX_MASK) \ ) /* ---------------------------------------------------------------------------- -- ReadControlReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_CTL, USB0_CTL1 * (depending on the peripheral). * @par Example: * @code * uint8 result = USB_PDD_ReadControlReg(_BASE_PTR); * @endcode */ #define USB_PDD_ReadControlReg(PeripheralBase) ( \ USB_CTL_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteControlReg ---------------------------------------------------------------------------- */ /** * @brief Writes Value to the 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Control register. This parameter is a 8-bit * value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_CTL, USB0_CTL1 * (depending on the peripheral). * @par Example: * @code * USB_PDD_WriteControlReg(_BASE_PTR, 1); * @endcode */ #define USB_PDD_WriteControlReg(PeripheralBase, Value) ( \ USB_CTL_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- GetBusSpeed ---------------------------------------------------------------------------- */ /** * @brief Returns current bus speed. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of "Bus speed" type. The value is cast to "uint8". * @remarks The macro accesses the following registers: USB0_CTL, USB0_CTL1 * (depending on the peripheral). * @par Example: * @code * uint8 result = USB_PDD_GetBusSpeed(_BASE_PTR); * @endcode */ #define USB_PDD_GetBusSpeed(PeripheralBase) ( \ (uint8)(USB_CTL_REG(PeripheralBase) & (uint8)((uint8)0x3U << 6U)) \ ) /* ---------------------------------------------------------------------------- -- GetSE0 ---------------------------------------------------------------------------- */ /** * @brief Returns state of the SEO signal. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_CTL, USB0_CTL1 * (depending on the peripheral). * @par Example: * @code * uint8 result = USB_PDD_GetSE0(_BASE_PTR); * @endcode */ #define USB_PDD_GetSE0(PeripheralBase) ( \ (uint8)(USB_CTL_REG(PeripheralBase) & USB_CTL_SE0_MASK) \ ) /* ---------------------------------------------------------------------------- -- EnableDevice ---------------------------------------------------------------------------- */ /** * @brief Enables/disables Device mode. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param State Requested state. 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: USB0_CTL, USB0_CTL1 * (depending on the peripheral). * @par Example: * @code * USB_PDD_EnableDevice(_BASE_PTR, PDD_DISABLE); * @endcode */ #define USB_PDD_EnableDevice(PeripheralBase, State) ( \ USB_CTL_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(USB_CTL_REG(PeripheralBase) & (uint8)(~(uint8)USB_CTL_USBENSOFEN_MASK))) | ( \ (uint8)(State))) \ ) /* ---------------------------------------------------------------------------- -- EnableSof ---------------------------------------------------------------------------- */ /** * @brief Enables/disables SOF. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param State Requested state. 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: USB0_CTL, USB0_CTL1 * (depending on the peripheral). * @par Example: * @code * USB_PDD_EnableSof(_BASE_PTR, PDD_DISABLE); * @endcode */ #define USB_PDD_EnableSof(PeripheralBase, State) ( \ USB_CTL_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(USB_CTL_REG(PeripheralBase) & (uint8)(~(uint8)USB_CTL_USBENSOFEN_MASK))) | ( \ (uint8)(State))) \ ) /* ---------------------------------------------------------------------------- -- ResetBdtPingPong ---------------------------------------------------------------------------- */ /** * @brief Resets internal logic. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_CTL, USB0_CTL1 * (depending on the peripheral). * @par Example: * @code * USB_PDD_ResetBdtPingPong(_BASE_PTR); * @endcode */ #define USB_PDD_ResetBdtPingPong(PeripheralBase) ( \ (USB_CTL_REG(PeripheralBase) |= \ USB_CTL_ODDRST_MASK), \ (USB_CTL_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_CTL_ODDRST_MASK)) \ ) /* ---------------------------------------------------------------------------- -- StartResumeSignaling ---------------------------------------------------------------------------- */ /** * @brief Starts/stops resume signaling. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param State Requested state. 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: USB0_CTL, USB0_CTL1 * (depending on the peripheral). * @par Example: * @code * USB_PDD_StartResumeSignaling(_BASE_PTR, PDD_DISABLE); * @endcode */ #define USB_PDD_StartResumeSignaling(PeripheralBase, State) ( \ USB_CTL_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(USB_CTL_REG(PeripheralBase) & (uint8)(~(uint8)USB_CTL_RESUME_MASK))) | ( \ (uint8)((uint8)(State) << USB_CTL_RESUME_SHIFT))) \ ) /* ---------------------------------------------------------------------------- -- GetResumeSignalState ---------------------------------------------------------------------------- */ /** * @brief Returns state of resume enable bit. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_CTL, USB0_CTL1 * (depending on the peripheral). * @par Example: * @code * uint8 result = USB_PDD_GetResumeSignalState(_BASE_PTR); * @endcode */ #define USB_PDD_GetResumeSignalState(PeripheralBase) ( \ (uint8)(USB_CTL_REG(PeripheralBase) & USB_CTL_RESUME_MASK) \ ) /* ---------------------------------------------------------------------------- -- EnableHost ---------------------------------------------------------------------------- */ /** * @brief Enables/disables Host mode. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param State Requested state. 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: USB0_CTL, USB0_CTL1 * (depending on the peripheral). * @par Example: * @code * USB_PDD_EnableHost(_BASE_PTR, PDD_DISABLE); * @endcode */ #define USB_PDD_EnableHost(PeripheralBase, State) ( \ USB_CTL_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(USB_CTL_REG(PeripheralBase) & (uint8)(~(uint8)USB_CTL_HOSTMODEEN_MASK))) | ( \ (uint8)((uint8)(State) << USB_CTL_HOSTMODEEN_SHIFT))) \ ) /* ---------------------------------------------------------------------------- -- StartResetSignaling ---------------------------------------------------------------------------- */ /** * @brief Starts/stops reset signaling. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param State Requested state. 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: USB0_CTL, USB0_CTL1 * (depending on the peripheral). * @par Example: * @code * USB_PDD_StartResetSignaling(_BASE_PTR, PDD_DISABLE); * @endcode */ #define USB_PDD_StartResetSignaling(PeripheralBase, State) ( \ USB_CTL_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(USB_CTL_REG(PeripheralBase) & (uint8)(~(uint8)USB_CTL_RESET_MASK))) | ( \ (uint8)((uint8)(State) << USB_CTL_RESET_SHIFT))) \ ) /* ---------------------------------------------------------------------------- -- GetResetSignalState ---------------------------------------------------------------------------- */ /** * @brief Returns state of reset enable bit. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_CTL, USB0_CTL1 * (depending on the peripheral). * @par Example: * @code * uint8 result = USB_PDD_GetResetSignalState(_BASE_PTR); * @endcode */ #define USB_PDD_GetResetSignalState(PeripheralBase) ( \ (uint8)(USB_CTL_REG(PeripheralBase) & USB_CTL_RESET_MASK) \ ) /* ---------------------------------------------------------------------------- -- ClearTxSuspendFlag ---------------------------------------------------------------------------- */ /** * @brief Clears TxSuspend flag. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_CTL, USB0_CTL1 * (depending on the peripheral). * @par Example: * @code * USB_PDD_ClearTxSuspendFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearTxSuspendFlag(PeripheralBase) ( \ USB_CTL_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_CTL_TXSUSPENDTOKENBUSY_MASK) \ ) /* ---------------------------------------------------------------------------- -- ClearTokenBusyFlag ---------------------------------------------------------------------------- */ /** * @brief Clears TokenBusy flag. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_CTL, USB0_CTL1 * (depending on the peripheral). * @par Example: * @code * USB_PDD_ClearTokenBusyFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearTokenBusyFlag(PeripheralBase) ( \ USB_CTL_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_CTL_TXSUSPENDTOKENBUSY_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetTokenBusyFlag ---------------------------------------------------------------------------- */ /** * @brief Returns state of TokenBusy flag. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_CTL, USB0_CTL1 * (depending on the peripheral). * @par Example: * @code * uint8 result = USB_PDD_GetTokenBusyFlag(_BASE_PTR); * @endcode */ #define USB_PDD_GetTokenBusyFlag(PeripheralBase) ( \ (uint8)(USB_CTL_REG(PeripheralBase) & USB_CTL_TXSUSPENDTOKENBUSY_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableModule ---------------------------------------------------------------------------- */ /** * @brief Disables module. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_CTL, USB0_CTL1 * (depending on the peripheral). * @par Example: * @code * USB_PDD_DisableModule(_BASE_PTR); * @endcode */ #define USB_PDD_DisableModule(PeripheralBase) ( \ USB_CTL_REG(PeripheralBase) = \ 0U \ ) /* ---------------------------------------------------------------------------- -- ReadAddressReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Address register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_ADDR. * @par Example: * @code * uint8 result = USB_PDD_ReadAddressReg(_BASE_PTR); * @endcode */ #define USB_PDD_ReadAddressReg(PeripheralBase) ( \ USB_ADDR_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteAddressReg ---------------------------------------------------------------------------- */ /** * @brief Writes Value to the Address register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Address register. This parameter is a 8-bit * value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ADDR. * @par Example: * @code * USB_PDD_WriteAddressReg(_BASE_PTR, 1); * @endcode */ #define USB_PDD_WriteAddressReg(PeripheralBase, Value) ( \ USB_ADDR_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- EnableLowSpeed ---------------------------------------------------------------------------- */ /** * @brief Enables low speed mode. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param State Requested state. 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: USB0_ADDR. * @par Example: * @code * USB_PDD_EnableLowSpeed(_BASE_PTR, PDD_DISABLE); * @endcode */ #define USB_PDD_EnableLowSpeed(PeripheralBase, State) ( \ USB_ADDR_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(USB_ADDR_REG(PeripheralBase) & (uint8)(~(uint8)USB_ADDR_LSEN_MASK))) | ( \ (uint8)((uint8)(State) << USB_ADDR_LSEN_SHIFT))) \ ) /* ---------------------------------------------------------------------------- -- SetDeviceAddress ---------------------------------------------------------------------------- */ /** * @brief Sets device address. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Address New device address. This parameter is a 7-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_ADDR. * @par Example: * @code * USB_PDD_SetDeviceAddress(_BASE_PTR, 1); * @endcode */ #define USB_PDD_SetDeviceAddress(PeripheralBase, Address) ( \ USB_ADDR_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(USB_ADDR_REG(PeripheralBase) & (uint8)(~(uint8)USB_ADDR_ADDR_MASK))) | ( \ (uint8)(Address))) \ ) /* ---------------------------------------------------------------------------- -- ReadBdtPage1Reg ---------------------------------------------------------------------------- */ /** * @brief Reads BDT page 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_BDTPAGE1. * @par Example: * @code * uint8 result = USB_PDD_ReadBdtPage1Reg(_BASE_PTR); * @endcode */ #define USB_PDD_ReadBdtPage1Reg(PeripheralBase) ( \ USB_BDTPAGE1_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteBdtPage1Reg ---------------------------------------------------------------------------- */ /** * @brief Writes data specified by the Value parameter BDT page 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value to be written to the BDT page 1 register. This parameter * is a 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_BDTPAGE1. * @par Example: * @code * USB_PDD_WriteBdtPage1Reg(_BASE_PTR, 1); * @endcode */ #define USB_PDD_WriteBdtPage1Reg(PeripheralBase, Value) ( \ USB_BDTPAGE1_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- GetFrameNumberLow ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Frame number low register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_FRMNUML. * @par Example: * @code * uint8 result = USB_PDD_GetFrameNumberLow(_BASE_PTR); * @endcode */ #define USB_PDD_GetFrameNumberLow(PeripheralBase) ( \ USB_FRMNUML_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- SetFrameNumberLow ---------------------------------------------------------------------------- */ /** * @brief Writes Data to the Frame number low register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Data Value written to the low part of the Frame number register. This * parameter is a 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_FRMNUML. * @par Example: * @code * USB_PDD_SetFrameNumberLow(_BASE_PTR, 1); * @endcode */ #define USB_PDD_SetFrameNumberLow(PeripheralBase, Data) ( \ USB_FRMNUML_REG(PeripheralBase) = \ (uint8)(Data) \ ) /* ---------------------------------------------------------------------------- -- GetFrameNumberHigh ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Frame number high register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_FRMNUMH. * @par Example: * @code * uint8 result = USB_PDD_GetFrameNumberHigh(_BASE_PTR); * @endcode */ #define USB_PDD_GetFrameNumberHigh(PeripheralBase) ( \ USB_FRMNUMH_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- SetFrameNumberHigh ---------------------------------------------------------------------------- */ /** * @brief Writes Data to the Frame number high register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Data Value written to the high part of the Frame number register. This * parameter is a 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_FRMNUMH. * @par Example: * @code * USB_PDD_SetFrameNumberHigh(_BASE_PTR, 1); * @endcode */ #define USB_PDD_SetFrameNumberHigh(PeripheralBase, Data) ( \ USB_FRMNUMH_REG(PeripheralBase) = \ (uint8)(Data) \ ) /* ---------------------------------------------------------------------------- -- ReadTokenReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Token register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_TOKEN. * @par Example: * @code * uint8 result = USB_PDD_ReadTokenReg(_BASE_PTR); * @endcode */ #define USB_PDD_ReadTokenReg(PeripheralBase) ( \ USB_TOKEN_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteTokenReg ---------------------------------------------------------------------------- */ /** * @brief Writes Data to the Token register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Data Value written to the Token register. This parameter is a 8-bit * value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_TOKEN. * @par Example: * @code * USB_PDD_WriteTokenReg(_BASE_PTR, 1); * @endcode */ #define USB_PDD_WriteTokenReg(PeripheralBase, Data) ( \ USB_TOKEN_REG(PeripheralBase) = \ (uint8)(Data) \ ) /* ---------------------------------------------------------------------------- -- ReadSofTresholdReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Sof treshold register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_SOFTHLD. * @par Example: * @code * uint8 result = USB_PDD_ReadSofTresholdReg(_BASE_PTR); * @endcode */ #define USB_PDD_ReadSofTresholdReg(PeripheralBase) ( \ USB_SOFTHLD_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- SetSofTresholdReg ---------------------------------------------------------------------------- */ /** * @brief Writes Data to the Sof theshold register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Data Value written to the Sof treshold register. This parameter is a * 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_SOFTHLD. * @par Example: * @code * USB_PDD_SetSofTresholdReg(_BASE_PTR, 1); * @endcode */ #define USB_PDD_SetSofTresholdReg(PeripheralBase, Data) ( \ USB_SOFTHLD_REG(PeripheralBase) = \ (uint8)(Data) \ ) /* ---------------------------------------------------------------------------- -- ReadBdtPage2Reg ---------------------------------------------------------------------------- */ /** * @brief Reads BDT page 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_BDTPAGE2. * @par Example: * @code * uint8 result = USB_PDD_ReadBdtPage2Reg(_BASE_PTR); * @endcode */ #define USB_PDD_ReadBdtPage2Reg(PeripheralBase) ( \ USB_BDTPAGE2_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteBdtPage2Reg ---------------------------------------------------------------------------- */ /** * @brief Writes data specified by the Value parameter BDT page 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value to be written to the BDT page 2 register. This parameter * is a 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_BDTPAGE2. * @par Example: * @code * USB_PDD_WriteBdtPage2Reg(_BASE_PTR, 1); * @endcode */ #define USB_PDD_WriteBdtPage2Reg(PeripheralBase, Value) ( \ USB_BDTPAGE2_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- ReadBdtPage3Reg ---------------------------------------------------------------------------- */ /** * @brief Reads BDT page 3 register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_BDTPAGE3. * @par Example: * @code * uint8 result = USB_PDD_ReadBdtPage3Reg(_BASE_PTR); * @endcode */ #define USB_PDD_ReadBdtPage3Reg(PeripheralBase) ( \ USB_BDTPAGE3_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteBdtPage3Reg ---------------------------------------------------------------------------- */ /** * @brief Writes data specified by the Value parameter BDT page 3 register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value to be written to the BDT page 3 register. This parameter * is a 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_BDTPAGE3. * @par Example: * @code * USB_PDD_WriteBdtPage3Reg(_BASE_PTR, 1); * @endcode */ #define USB_PDD_WriteBdtPage3Reg(PeripheralBase, Value) ( \ USB_BDTPAGE3_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- ReadEp0CtrlReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the EP0 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: ENDPT[]. * @par Example: * @code * uint8 result = USB_PDD_ReadEp0CtrlReg(_BASE_PTR); * @endcode */ #define USB_PDD_ReadEp0CtrlReg(PeripheralBase) ( \ USB_ENDPT_REG(PeripheralBase,0U) \ ) /* ---------------------------------------------------------------------------- -- WriteEp0CtrlReg ---------------------------------------------------------------------------- */ /** * @brief Writes Data to the EP0 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Data Value written to the EP0 control register. This parameter is a * 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: ENDPT[]. * @par Example: * @code * USB_PDD_WriteEp0CtrlReg(_BASE_PTR, 1); * @endcode */ #define USB_PDD_WriteEp0CtrlReg(PeripheralBase, Data) ( \ USB_ENDPT_REG(PeripheralBase,0U) = \ (uint8)(Data) \ ) /* ---------------------------------------------------------------------------- -- GetEpCtrlRegAddr ---------------------------------------------------------------------------- */ /** * @brief Returns the address of the EP_x register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param EpNum Endpoint number. This parameter is of index type. * @return Returns a 32-bit value. * @remarks The macro accesses the following registers: ENDPT[EpNum]. * @par Example: * @code * uint32 result = USB_PDD_GetEpCtrlRegAddr(_BASE_PTR, * periphID); * @endcode */ #define USB_PDD_GetEpCtrlRegAddr(PeripheralBase, EpNum) ( \ (uint8 *)(void *)&(USB_ENDPT_REG(PeripheralBase,(EpNum))) \ ) /* ---------------------------------------------------------------------------- -- EnableDirectLowSpeedDevice ---------------------------------------------------------------------------- */ /** * @brief Enables/disables direct low speed device. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param State Requested state. 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: ENDPT[]. * @par Example: * @code * USB_PDD_EnableDirectLowSpeedDevice(_BASE_PTR, PDD_DISABLE); * @endcode */ #define USB_PDD_EnableDirectLowSpeedDevice(PeripheralBase, State) ( \ USB_ENDPT_REG(PeripheralBase,0U) = \ (uint8)(( \ (uint8)(( \ USB_ENDPT_REG(PeripheralBase,0U)) & ( \ (uint8)(~(uint8)USB_ENDPT_HOSTWOHUB_MASK)))) | ( \ (uint8)((uint8)(State) << USB_ENDPT_HOSTWOHUB_SHIFT))) \ ) /* ---------------------------------------------------------------------------- -- StallControlEP ---------------------------------------------------------------------------- */ /** * @brief Enables/disables Stall feature for given EP. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param EpNum Endpoint number. This parameter is of index type. * @param State Requested state. 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: ENDPT[EpNum]. * @par Example: * @code * USB_PDD_StallControlEP(_BASE_PTR, periphID, PDD_DISABLE); * @endcode */ #define USB_PDD_StallControlEP(PeripheralBase, EpNum, State) ( \ USB_ENDPT_REG(PeripheralBase,(EpNum)) = \ (uint8)(( \ (uint8)(( \ USB_ENDPT_REG(PeripheralBase,(EpNum))) & ( \ (uint8)(~(uint8)USB_ENDPT_EPSTALL_MASK)))) | ( \ (uint8)((uint8)(State) << USB_ENDPT_EPSTALL_SHIFT))) \ ) /* ---------------------------------------------------------------------------- -- EnableControlEP ---------------------------------------------------------------------------- */ /** * @brief Enables/disables Control EP. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param EpNum Endpoint number. This parameter is of index type. * @param State Requested state. 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: ENDPT[EpNum]. * @par Example: * @code * USB_PDD_EnableControlEP(_BASE_PTR, periphID, PDD_DISABLE); * @endcode */ #define USB_PDD_EnableControlEP(PeripheralBase, EpNum, State) ( \ ((State) == PDD_DISABLE) ? ( \ USB_ENDPT_REG(PeripheralBase,(EpNum)) &= \ (uint8)(( \ (uint8)(~(uint8)USB_ENDPT_RETRYDIS_MASK)) & (( \ (uint8)(~(uint8)USB_ENDPT_EPCTLDIS_MASK)) & (( \ (uint8)(~(uint8)USB_ENDPT_EPRXEN_MASK)) & (( \ (uint8)(~(uint8)USB_ENDPT_EPTXEN_MASK)) & (( \ (uint8)(~(uint8)USB_ENDPT_EPSTALL_MASK)) & ( \ (uint8)(~(uint8)USB_ENDPT_EPHSHK_MASK)))))))) : ( \ USB_ENDPT_REG(PeripheralBase,(EpNum)) = \ (uint8)(( \ (uint8)(( \ USB_ENDPT_REG(PeripheralBase,(EpNum))) & (( \ (uint8)(~(uint8)USB_ENDPT_RETRYDIS_MASK)) & (( \ (uint8)(~(uint8)USB_ENDPT_EPCTLDIS_MASK)) & ( \ (uint8)(~(uint8)USB_ENDPT_EPSTALL_MASK)))))) | (( \ USB_ENDPT_EPRXEN_MASK) | (( \ USB_ENDPT_EPTXEN_MASK) | ( \ USB_ENDPT_EPHSHK_MASK))))) \ ) /* ---------------------------------------------------------------------------- -- EnableBulkOrIntRxEP ---------------------------------------------------------------------------- */ /** * @brief Enables/disables Bulk or Interrupt Rx EP. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param EpNum Endpoint number. This parameter is of index type. * @param State Requested state. 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: ENDPT[EpNum]. * @par Example: * @code * USB_PDD_EnableBulkOrIntRxEP(_BASE_PTR, periphID, * PDD_DISABLE); * @endcode */ #define USB_PDD_EnableBulkOrIntRxEP(PeripheralBase, EpNum, State) ( \ ((State) == PDD_DISABLE) ? ( \ USB_ENDPT_REG(PeripheralBase,(EpNum)) &= \ (uint8)(~(uint8)USB_ENDPT_EPRXEN_MASK)) : ( \ USB_ENDPT_REG(PeripheralBase,(EpNum)) = \ (uint8)(( \ (uint8)(( \ USB_ENDPT_REG(PeripheralBase,(EpNum))) & (( \ (uint8)(~(uint8)USB_ENDPT_RETRYDIS_MASK)) & ( \ (uint8)(~(uint8)USB_ENDPT_EPSTALL_MASK))))) | (( \ USB_ENDPT_EPCTLDIS_MASK) | (( \ USB_ENDPT_EPRXEN_MASK) | ( \ USB_ENDPT_EPHSHK_MASK))))) \ ) /* ---------------------------------------------------------------------------- -- EnableBulkOrIntTxEP ---------------------------------------------------------------------------- */ /** * @brief Enables/disables Bulk or Interrupt Tx EP. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param EpNum Endpoint number. This parameter is of index type. * @param State Requested state. 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: ENDPT[EpNum]. * @par Example: * @code * USB_PDD_EnableBulkOrIntTxEP(_BASE_PTR, periphID, * PDD_DISABLE); * @endcode */ #define USB_PDD_EnableBulkOrIntTxEP(PeripheralBase, EpNum, State) ( \ ((State) == PDD_DISABLE) ? ( \ USB_ENDPT_REG(PeripheralBase,(EpNum)) &= \ (uint8)(~(uint8)USB_ENDPT_EPTXEN_MASK)) : ( \ USB_ENDPT_REG(PeripheralBase,(EpNum)) = \ (uint8)(( \ (uint8)(( \ USB_ENDPT_REG(PeripheralBase,(EpNum))) & (( \ (uint8)(~(uint8)USB_ENDPT_RETRYDIS_MASK)) & ( \ (uint8)(~(uint8)USB_ENDPT_EPSTALL_MASK))))) | (( \ USB_ENDPT_EPCTLDIS_MASK) | (( \ USB_ENDPT_EPTXEN_MASK) | ( \ USB_ENDPT_EPHSHK_MASK))))) \ ) /* ---------------------------------------------------------------------------- -- EnableIsoRxEP ---------------------------------------------------------------------------- */ /** * @brief Enables/disables Isochronous Rx EP. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param EpNum Endpoint number. This parameter is of index type. * @param State Requested state. 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: ENDPT[EpNum]. * @par Example: * @code * USB_PDD_EnableIsoRxEP(_BASE_PTR, periphID, PDD_DISABLE); * @endcode */ #define USB_PDD_EnableIsoRxEP(PeripheralBase, EpNum, State) ( \ ((State) == PDD_DISABLE) ? ( \ USB_ENDPT_REG(PeripheralBase,(EpNum)) &= \ (uint8)(~(uint8)USB_ENDPT_EPRXEN_MASK)) : ( \ USB_ENDPT_REG(PeripheralBase,(EpNum)) = \ (uint8)(( \ (uint8)(( \ USB_ENDPT_REG(PeripheralBase,(EpNum))) & (( \ (uint8)(~(uint8)USB_ENDPT_RETRYDIS_MASK)) & (( \ (uint8)(~(uint8)USB_ENDPT_EPSTALL_MASK)) & ( \ (uint8)(~(uint8)USB_ENDPT_EPHSHK_MASK)))))) | (( \ USB_ENDPT_EPCTLDIS_MASK) | ( \ USB_ENDPT_EPRXEN_MASK)))) \ ) /* ---------------------------------------------------------------------------- -- EnableIsoTxEP ---------------------------------------------------------------------------- */ /** * @brief Enables/disables Isochronous Tx EP. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param EpNum Endpoint number. This parameter is of index type. * @param State Requested state. 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: ENDPT[EpNum]. * @par Example: * @code * USB_PDD_EnableIsoTxEP(_BASE_PTR, periphID, PDD_DISABLE); * @endcode */ #define USB_PDD_EnableIsoTxEP(PeripheralBase, EpNum, State) ( \ ((State) == PDD_DISABLE) ? ( \ USB_ENDPT_REG(PeripheralBase,(EpNum)) &= \ (uint8)(~(uint8)USB_ENDPT_EPTXEN_MASK)) : ( \ USB_ENDPT_REG(PeripheralBase,(EpNum)) = \ (uint8)(( \ (uint8)(( \ USB_ENDPT_REG(PeripheralBase,(EpNum))) & (( \ (uint8)(~(uint8)USB_ENDPT_HOSTWOHUB_MASK)) & (( \ (uint8)(~(uint8)USB_ENDPT_RETRYDIS_MASK)) & (( \ (uint8)(~(uint8)USB_ENDPT_EPSTALL_MASK)) & ( \ (uint8)(~(uint8)USB_ENDPT_EPHSHK_MASK))))))) | (( \ USB_ENDPT_EPCTLDIS_MASK) | ( \ USB_ENDPT_EPTXEN_MASK)))) \ ) /* ---------------------------------------------------------------------------- -- DisableRxEP ---------------------------------------------------------------------------- */ /** * @brief Disables Rx EP. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param EpNum Endpoint number. This parameter is of index type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: ENDPT[EpNum]. * @par Example: * @code * USB_PDD_DisableRxEP(_BASE_PTR, periphID); * @endcode */ #define USB_PDD_DisableRxEP(PeripheralBase, EpNum) ( \ USB_ENDPT_REG(PeripheralBase,(EpNum)) &= \ (uint8)(~(uint8)USB_ENDPT_EPRXEN_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableTxEP ---------------------------------------------------------------------------- */ /** * @brief Disables Tx EP. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param EpNum Endpoint number. This parameter is of index type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: ENDPT[EpNum]. * @par Example: * @code * USB_PDD_DisableTxEP(_BASE_PTR, periphID); * @endcode */ #define USB_PDD_DisableTxEP(PeripheralBase, EpNum) ( \ USB_ENDPT_REG(PeripheralBase,(EpNum)) &= \ (uint8)(~(uint8)USB_ENDPT_EPTXEN_MASK) \ ) /* ---------------------------------------------------------------------------- -- ReadUsbControlReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the USB 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_USBCTRL. * @par Example: * @code * uint8 result = USB_PDD_ReadUsbControlReg(_BASE_PTR); * @endcode */ #define USB_PDD_ReadUsbControlReg(PeripheralBase) ( \ USB_USBCTRL_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteUsbControlReg ---------------------------------------------------------------------------- */ /** * @brief Writes Value to the Usb 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Usb control register. This parameter is a * 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_USBCTRL. * @par Example: * @code * USB_PDD_WriteUsbControlReg(_BASE_PTR, 1); * @endcode */ #define USB_PDD_WriteUsbControlReg(PeripheralBase, Value) ( \ USB_USBCTRL_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- SuspendTransceiver ---------------------------------------------------------------------------- */ /** * @brief Suspends/Wakes up transceiver. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param State Requested state. 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: USB0_USBCTRL. * @par Example: * @code * USB_PDD_SuspendTransceiver(_BASE_PTR, PDD_DISABLE); * @endcode */ #define USB_PDD_SuspendTransceiver(PeripheralBase, State) ( \ USB_USBCTRL_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(USB_USBCTRL_REG(PeripheralBase) & (uint8)(~(uint8)USB_USBCTRL_SUSP_MASK))) | ( \ (uint8)((uint8)(State) << USB_USBCTRL_SUSP_SHIFT))) \ ) /* ---------------------------------------------------------------------------- -- EnableWeakPullDowns ---------------------------------------------------------------------------- */ /** * @brief Enables/disables week pull downs. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param State Requested state. 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: USB0_USBCTRL. * @par Example: * @code * USB_PDD_EnableWeakPullDowns(_BASE_PTR, PDD_DISABLE); * @endcode */ #define USB_PDD_EnableWeakPullDowns(PeripheralBase, State) ( \ USB_USBCTRL_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(USB_USBCTRL_REG(PeripheralBase) & (uint8)(~(uint8)USB_USBCTRL_PDE_MASK))) | ( \ (uint8)((uint8)(State) << USB_USBCTRL_PDE_SHIFT))) \ ) /* ---------------------------------------------------------------------------- -- ReadOtgSignalObserveReg ---------------------------------------------------------------------------- */ /** * @brief Returns content of the Otg observe register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_OBSERVE. * @par Example: * @code * uint8 result = USB_PDD_ReadOtgSignalObserveReg(_BASE_PTR); * @endcode */ #define USB_PDD_ReadOtgSignalObserveReg(PeripheralBase) ( \ USB_OBSERVE_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteOtgSignalObservelReg ---------------------------------------------------------------------------- */ /** * @brief Writes Value to the OTG observe register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Otg observel register. This parameter is a * 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_OBSERVE. * @par Example: * @code * USB_PDD_WriteOtgSignalObservelReg(_BASE_PTR, 1); * @endcode */ #define USB_PDD_WriteOtgSignalObservelReg(PeripheralBase, Value) ( \ USB_OBSERVE_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- GetDpPullUpSignalState ---------------------------------------------------------------------------- */ /** * @brief Returns state of the D+ pull up signal. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_OBSERVE. * @par Example: * @code * uint8 result = USB_PDD_GetDpPullUpSignalState(_BASE_PTR); * @endcode */ #define USB_PDD_GetDpPullUpSignalState(PeripheralBase) ( \ (uint8)(USB_OBSERVE_REG(PeripheralBase) & USB_OBSERVE_DPPU_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetDpPullDownSignalState ---------------------------------------------------------------------------- */ /** * @brief Returns state of the D+ pull down signal. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_OBSERVE. * @par Example: * @code * uint8 result = * USB_PDD_GetDpPullDownSignalState(_BASE_PTR); * @endcode */ #define USB_PDD_GetDpPullDownSignalState(PeripheralBase) ( \ (uint8)(USB_OBSERVE_REG(PeripheralBase) & USB_OBSERVE_DPPD_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetDmPullDownSignalState ---------------------------------------------------------------------------- */ /** * @brief Returns state of the D- pull up signal. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_OBSERVE. * @par Example: * @code * uint8 result = * USB_PDD_GetDmPullDownSignalState(_BASE_PTR); * @endcode */ #define USB_PDD_GetDmPullDownSignalState(PeripheralBase) ( \ (uint8)(USB_OBSERVE_REG(PeripheralBase) & USB_OBSERVE_DMPD_MASK) \ ) /* ---------------------------------------------------------------------------- -- ReadOtgSignalControlReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Otg 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_CONTROL. * @par Example: * @code * uint8 result = USB_PDD_ReadOtgSignalControlReg(_BASE_PTR); * @endcode */ #define USB_PDD_ReadOtgSignalControlReg(PeripheralBase) ( \ USB_CONTROL_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteOtgSignalControlReg ---------------------------------------------------------------------------- */ /** * @brief Writes Value to the OTG 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Otg control register. This parameter is a * 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_CONTROL. * @par Example: * @code * USB_PDD_WriteOtgSignalControlReg(_BASE_PTR, 1); * @endcode */ #define USB_PDD_WriteOtgSignalControlReg(PeripheralBase, Value) ( \ USB_CONTROL_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- ReadTransceiverControlReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Transceiver 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_USBTRC0. * @par Example: * @code * uint8 result = * USB_PDD_ReadTransceiverControlReg(_BASE_PTR); * @endcode */ #define USB_PDD_ReadTransceiverControlReg(PeripheralBase) ( \ USB_USBTRC0_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteTransceiverControlReg ---------------------------------------------------------------------------- */ /** * @brief Writes Value to the Transceiver 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Transceiver control register. This * parameter is a 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_USBTRC0. * @par Example: * @code * USB_PDD_WriteTransceiverControlReg(_BASE_PTR, 1); * @endcode */ #define USB_PDD_WriteTransceiverControlReg(PeripheralBase, Value) ( \ USB_USBTRC0_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- ResetModule ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK20DZ10)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MKL24Z4)) || (defined(MCU_MKL25Z4)) || (defined(MCU_MKL26Z4)) || (defined(MCU_MKL46Z4))) /** * @brief Starts module reset. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_USBTRC0. * @par Example: * @code * USB_PDD_ResetModule(_BASE_PTR); * @endcode */ #define USB_PDD_ResetModule(PeripheralBase) ( \ USB_USBTRC0_REG(PeripheralBase) |= \ (uint8)(USB_USBTRC0_USBRESET_MASK | 0x40U) \ ) #else /* (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK52D10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /** * @brief Starts module reset. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_USBTRC0. * @par Example: * @code * USB_PDD_ResetModule(_BASE_PTR); * @endcode */ #define USB_PDD_ResetModule(PeripheralBase) ( \ USB_USBTRC0_REG(PeripheralBase) |= \ USB_USBTRC0_USBRESET_MASK \ ) #endif /* (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK52D10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- GetModuleResetPendingFlag ---------------------------------------------------------------------------- */ /** * @brief Returns state of module reset pending flag. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_USBTRC0. * @par Example: * @code * uint8 result = * USB_PDD_GetModuleResetPendingFlag(_BASE_PTR); * @endcode */ #define USB_PDD_GetModuleResetPendingFlag(PeripheralBase) ( \ (uint8)(USB_USBTRC0_REG(PeripheralBase) & USB_USBTRC0_USBRESET_MASK) \ ) /* ---------------------------------------------------------------------------- -- ClearAsyncResumeInterruptFlag ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK20DZ10)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MKL24Z4)) || (defined(MCU_MKL25Z4)) || (defined(MCU_MKL26Z4)) || (defined(MCU_MKL46Z4))) /** * @brief Clears asynchronous resume 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_USBTRC0. * @par Example: * @code * USB_PDD_ClearAsyncResumeInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearAsyncResumeInterruptFlag(PeripheralBase) ( \ USB_USBTRC0_REG(PeripheralBase) |= \ (uint8)(USB_USBTRC0_SYNC_DET_MASK | 0x40U) \ ) #else /* (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK52D10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /** * @brief Clears asynchronous resume 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_USBTRC0. * @par Example: * @code * USB_PDD_ClearAsyncResumeInterruptFlag(_BASE_PTR); * @endcode */ #define USB_PDD_ClearAsyncResumeInterruptFlag(PeripheralBase) ( \ USB_USBTRC0_REG(PeripheralBase) |= \ USB_USBTRC0_SYNC_DET_MASK \ ) #endif /* (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK52D10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- EnableAsyncResumeInterrupt ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK20DZ10)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MKL24Z4)) || (defined(MCU_MKL25Z4)) || (defined(MCU_MKL26Z4)) || (defined(MCU_MKL46Z4))) /** * @brief Enables asynchronous resume interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_USBTRC0. * @par Example: * @code * USB_PDD_EnableAsyncResumeInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_EnableAsyncResumeInterrupt(PeripheralBase) ( \ USB_USBTRC0_REG(PeripheralBase) |= \ (uint8)(USB_USBTRC0_USBRESMEN_MASK | 0x40U) \ ) #else /* (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK52D10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /** * @brief Enables asynchronous resume interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_USBTRC0. * @par Example: * @code * USB_PDD_EnableAsyncResumeInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_EnableAsyncResumeInterrupt(PeripheralBase) ( \ USB_USBTRC0_REG(PeripheralBase) |= \ USB_USBTRC0_USBRESMEN_MASK \ ) #endif /* (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK52D10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- DisableAsyncResumeInterrupt ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK20DZ10)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MKL24Z4)) || (defined(MCU_MKL25Z4)) || (defined(MCU_MKL26Z4)) || (defined(MCU_MKL46Z4))) /** * @brief Disables asynchronous resume interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_USBTRC0. * @par Example: * @code * USB_PDD_DisableAsyncResumeInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_DisableAsyncResumeInterrupt(PeripheralBase) ( \ USB_USBTRC0_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(( \ USB_USBTRC0_REG(PeripheralBase)) & ( \ (uint8)(~(uint8)USB_USBTRC0_USBRESMEN_MASK)))) | ( \ 0x40U)) \ ) #else /* (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK52D10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /** * @brief Disables asynchronous resume interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_USBTRC0. * @par Example: * @code * USB_PDD_DisableAsyncResumeInterrupt(_BASE_PTR); * @endcode */ #define USB_PDD_DisableAsyncResumeInterrupt(PeripheralBase) ( \ USB_USBTRC0_REG(PeripheralBase) &= \ (uint8)(~(uint8)USB_USBTRC0_USBRESMEN_MASK) \ ) #endif /* (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK52D10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- ReadFrameAdjustmentReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Frame Adjustment register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: USB0_USBFRMADJUST. * @par Example: * @code * uint8 result = USB_PDD_ReadFrameAdjustmentReg(_BASE_PTR); * @endcode */ #define USB_PDD_ReadFrameAdjustmentReg(PeripheralBase) ( \ USB_USBFRMADJUST_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteFrameAdjustmentReg ---------------------------------------------------------------------------- */ /** * @brief Writes Value to the Frame adjustment register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Frame adjustment register. This parameter * is a 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_USBFRMADJUST. * @par Example: * @code * USB_PDD_WriteFrameAdjustmentReg(_BASE_PTR, 1); * @endcode */ #define USB_PDD_WriteFrameAdjustmentReg(PeripheralBase, Value) ( \ USB_USBFRMADJUST_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- SetFrameAdjustment ---------------------------------------------------------------------------- */ /** * @brief Sets frame adjustment. In Host mode, the frame adjustment is a twos * complement number that adjusts the period of each USB frame in 12-MHz clock * periods. A SOF is normally generated every 12,000 12-MHz clock cycles. The Frame * Adjust Register can adjust this by -128 to +127 to compensate for inaccuracies * in the USB 48-MHz clock. Changes to the ADJ bit take effect at the next start * of the next frame. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Frame adjustment register. This parameter * is a 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: USB0_USBFRMADJUST. * @par Example: * @code * USB_PDD_SetFrameAdjustment(_BASE_PTR, 1); * @endcode */ #define USB_PDD_SetFrameAdjustment(PeripheralBase, Value) ( \ USB_USBFRMADJUST_REG(PeripheralBase) = \ (uint8)(Value) \ ) #endif /* #if defined(USB_PDD_H_) */ /* USB_PDD.h, eof. */