/** ******************************************************************************* * @file hc32f4a0_gpio.c * @brief This file provides firmware functions to manage the General Purpose * Input/Output(GPIO). @verbatim Change Logs: Date Author Notes 2020-06-12 Zhangxl First version 2020-09-18 Zhangxl Optimize GPIO_DeInit() API @endverbatim ******************************************************************************* * Copyright (C) 2020, Huada Semiconductor Co., Ltd. All rights reserved. * * This software component is licensed by HDSC under BSD 3-Clause license * (the "License"); You may not use this file except in compliance with the * License. You may obtain a copy of the License at: * opensource.org/licenses/BSD-3-Clause * ******************************************************************************* */ /******************************************************************************* * Include files ******************************************************************************/ #include "hc32f4a0_gpio.h" #include "hc32f4a0_utility.h" /** * @addtogroup HC32F4A0_DDL_Driver * @{ */ /** * @defgroup DDL_GPIO GPIO * @brief GPIO Driver Library * @{ */ #if (DDL_GPIO_ENABLE == DDL_ON) /******************************************************************************* * Local type definitions ('typedef') ******************************************************************************/ /******************************************************************************* * Local pre-processor symbols/macros ('#define') ******************************************************************************/ /** * @defgroup GPIO_Local_Macros GPIO Local Macros * @{ */ /** * @defgroup GPIO_Registers_Reset_Value GPIO Registers Reset Value * @{ */ #define GPIO_PSPCR_RESET_VALUE (0x001FU) #define GPIO_PCCR_RESET_VALUE (0x1000U) #define GPIO_PINAER_RESET_VALUE (0x0000U) /** * @} */ /** * @defgroup GPIO_Check_Parameters_Validity GPIO Check Parameters Validity * @{ */ /*! Parameter validity check for pin state. */ #define IS_GPIO_PIN_STATE(state) \ ( ((state) == PIN_STATE_RESET) || \ ((state) == PIN_STATE_SET)) /*! Parameter validity check for pin direction. */ #define IS_GPIO_DIR(dir) \ ( ((dir) == PIN_DIR_IN) || \ ((dir) == PIN_DIR_OUT)) /*! Parameter validity check for pin output type. */ #define IS_GPIO_OTYPE(otype) \ ( ((otype) == PIN_OTYPE_CMOS) || \ ((otype) == PIN_OTYPE_NMOS)) /*! Parameter validity check for pin driver capacity. */ #define IS_GPIO_PIN_DRV(drv) \ ( ((drv) == PIN_DRV_LOW) || \ ((drv) == PIN_DRV_MID) || \ ((drv) == PIN_DRV_HIGH)) /*! Parameter validity check for pin latch function. */ #define IS_GPIO_LATCH(latch) \ ( ((latch) == PIN_LATCH_OFF) || \ ((latch) == PIN_LATCH_ON)) /*! Parameter validity check for internal pull-up resistor. */ #define IS_GPIO_PIN_PU(pu) \ ( ((pu) == PIN_PU_OFF) || \ ((pu) == PIN_PU_ON)) /*! Parameter validity check for pin state invert. */ #define IS_GPIO_PIN_INVERT(invert) \ ( ((invert) == PIN_INVERT_OFF) || \ ((invert) == PIN_INVERT_ON)) /*! Parameter validity check for pin input type. */ #define IS_GPIO_ITYPE(itype) \ ( ((itype) == PIN_ITYPE_SMT) || \ ((itype) == PIN_ITYPE_CMOS)) /*! Parameter validity check for external interrupt function. */ #define IS_GPIO_EXINT(exint) \ ( ((exint) == PIN_EXINT_OFF) || \ ((exint) == PIN_EXINT_ON)) /*! Parameter validity check for pin attribute. */ #define IS_GPIO_ATTR(attr) \ ( ((attr) == PIN_ATTR_DIGITAL) || \ ((attr) == PIN_ATTR_ANALOG)) /*! Parameter validity check for pin number. */ #define IS_GPIO_PIN(pin) (((pin) & GPIO_PIN_MASK ) != 0x0000U) /*! Parameter validity check for port source. */ #define IS_GPIO_PORT(port) \ ( ((port) != 0x00U) && \ (((port) | GPIO_PORT_MASK) == GPIO_PORT_MASK)) /*! Parameter validity check for port source. */ #define IS_GPIO_PORT_SOURCE(port) \ ( ((port) == GPIO_PORT_A) || \ ((port) == GPIO_PORT_B) || \ ((port) == GPIO_PORT_C) || \ ((port) == GPIO_PORT_D) || \ ((port) == GPIO_PORT_E) || \ ((port) == GPIO_PORT_F) || \ ((port) == GPIO_PORT_G) || \ ((port) == GPIO_PORT_H) || \ ((port) == GPIO_PORT_I)) /*! Parameter validity check for pin function. */ #define IS_GPIO_FUNC(func) \ ( ((func) <= GPIO_FUNC_20) || \ (((func) >= GPIO_FUNC_32) && ((func) <= GPIO_FUNC_63))) /*! Parameter validity check for debug pin definition. */ #define IS_GPIO_DEBUG_PORT(port) \ ( ((port) != 0x00U) && \ (((port) | GPIO_PIN_DEBUG_JTAG) == GPIO_PIN_DEBUG_JTAG)) /*! Parameter validity check for pin sub-function setting. */ #define IS_GPIO_PIN_BFE(bfe) \ ( ((bfe) == PIN_SUBFUNC_ENABLE) || \ ((bfe) == PIN_SUBFUNC_DISABLE)) /*! Parameter validity check for pin read wait cycle. */ #define IS_GPIO_READ_WAIT(wait) \ ( ((wait) == GPIO_READ_WAIT_0) || \ ((wait) == GPIO_READ_WAIT_1) || \ ((wait) == GPIO_READ_WAIT_2) || \ ((wait) == GPIO_READ_WAIT_3) || \ ((wait) == GPIO_READ_WAIT_4) || \ ((wait) == GPIO_READ_WAIT_5) || \ ((wait) == GPIO_READ_WAIT_6) || \ ((wait) == GPIO_READ_WAIT_7)) /* Check GPIO register lock status. */ #define IS_GPIO_UNLOCKED() (GPIO_PWPR_WE == (M4_GPIO->PWPR & GPIO_PWPR_WE)) /** * @} */ /** * @} */ /******************************************************************************* * Global variable definitions (declared in header file with 'extern') ******************************************************************************/ /******************************************************************************* * Local function prototypes ('static') ******************************************************************************/ /******************************************************************************* * Local variable definitions ('static') ******************************************************************************/ /******************************************************************************* * Function implementation - global ('extern') and local ('static') ******************************************************************************/ /** * @defgroup GPIO_Global_Functions GPIO Global Functions * @{ */ /** * @brief Initialize GPIO. * @param [in] u8Port: GPIO_PORT_x, x can be (A~I) to select the GPIO peripheral * @param [in] u16Pin: GPIO_PIN_x, x can be (00~15) to select the PIN index * @param [in] pstcGpioInit: Pointer to a stc_gpio_init_t structure that * contains configuration information. * @retval Ok: GPIO initialize successful * ErrorInvalidParameter: NULL pointer */ en_result_t GPIO_Init(uint8_t u8Port, uint16_t u16Pin, const stc_gpio_init_t *pstcGpioInit) { __IO uint16_t *PCRx; uint16_t u16PinPos; uint16_t u16PCRVal; en_result_t enRet = Ok; /* Check if pointer is NULL */ if (NULL == pstcGpioInit) { enRet = ErrorInvalidParameter; } else { /* Parameter validity checking */ DDL_ASSERT(IS_GPIO_PORT_SOURCE(u8Port)); DDL_ASSERT(IS_GPIO_PIN(u16Pin)); DDL_ASSERT(IS_GPIO_PIN_STATE(pstcGpioInit->u16PinState)); DDL_ASSERT(IS_GPIO_DIR(pstcGpioInit->u16PinDir)); DDL_ASSERT(IS_GPIO_OTYPE(pstcGpioInit->u16PinOType)); DDL_ASSERT(IS_GPIO_PIN_DRV(pstcGpioInit->u16PinDrv)); DDL_ASSERT(IS_GPIO_LATCH(pstcGpioInit->u16Latch)); DDL_ASSERT(IS_GPIO_PIN_PU(pstcGpioInit->u16PullUp)); DDL_ASSERT(IS_GPIO_PIN_INVERT(pstcGpioInit->u16Invert)); DDL_ASSERT(IS_GPIO_ITYPE(pstcGpioInit->u16PinIType)); DDL_ASSERT(IS_GPIO_EXINT(pstcGpioInit->u16ExInt)); DDL_ASSERT(IS_GPIO_UNLOCKED()); for (u16PinPos = 0U; u16PinPos < 16U; u16PinPos++) { if ((u16Pin & (1UL<PCRA0) + \ ((uint32_t)(u8Port) * 0x40UL) + u16PinPos * 4UL); u16PCRVal = pstcGpioInit->u16ExInt | pstcGpioInit->u16PinIType | \ pstcGpioInit->u16Invert | pstcGpioInit->u16PullUp | \ pstcGpioInit->u16Latch | pstcGpioInit->u16PinDrv | \ pstcGpioInit->u16PinOType | pstcGpioInit->u16PinState | \ pstcGpioInit->u16PinDir | pstcGpioInit->u16PinAttr; WRITE_REG16(*PCRx, u16PCRVal); } } } return enRet; } /** * @brief De-init GPIO register to default value * @param None * @retval None */ void GPIO_DeInit(void) { stc_gpio_init_t stcGpioInit; DDL_ASSERT(IS_GPIO_UNLOCKED()); (void)GPIO_StructInit(&stcGpioInit); /* PORTA reset */ (void)GPIO_Init(GPIO_PORT_A, GPIO_PIN_ALL, &stcGpioInit); /* PORTB reset */ (void)GPIO_Init(GPIO_PORT_B, GPIO_PIN_ALL, &stcGpioInit); /* PORTC reset */ (void)GPIO_Init(GPIO_PORT_C, GPIO_PIN_ALL, &stcGpioInit); /* PORTD reset */ (void)GPIO_Init(GPIO_PORT_D, GPIO_PIN_ALL, &stcGpioInit); /* PORTE reset */ (void)GPIO_Init(GPIO_PORT_E, GPIO_PIN_ALL, &stcGpioInit); /* PORTF reset */ (void)GPIO_Init(GPIO_PORT_F, GPIO_PIN_ALL, &stcGpioInit); /* PORTG reset */ (void)GPIO_Init(GPIO_PORT_G, GPIO_PIN_ALL, &stcGpioInit); /* PORTH reset */ (void)GPIO_Init(GPIO_PORT_H, GPIO_PIN_ALL, &stcGpioInit); /* PORTI reset */ (void)GPIO_Init(GPIO_PORT_I, (GPIO_PIN_00 | GPIO_PIN_01 | GPIO_PIN_02 | \ GPIO_PIN_03 | GPIO_PIN_04 | GPIO_PIN_05 | \ GPIO_PIN_06 | GPIO_PIN_07 | GPIO_PIN_08 | \ GPIO_PIN_09 | GPIO_PIN_10 | GPIO_PIN_11 | \ GPIO_PIN_12 | GPIO_PIN_13), &stcGpioInit); /* PORT global register reset */ WRITE_REG16(M4_GPIO->PSPCR, GPIO_PSPCR_RESET_VALUE); WRITE_REG16(M4_GPIO->PCCR, GPIO_PCCR_RESET_VALUE); WRITE_REG16(M4_GPIO->PINAER, GPIO_PINAER_RESET_VALUE); } /** * @brief Initialize GPIO config structure. Fill each pstcGpioInit with default value * @param [in] pstcGpioInit: Pointer to a stc_gpio_init_t structure that * contains configuration information. * @retval Ok: GPIO structure initialize successful * ErrorInvalidParameter: NULL pointer */ en_result_t GPIO_StructInit(stc_gpio_init_t *pstcGpioInit) { en_result_t enRet = Ok; /* Check if pointer is NULL */ if (NULL == pstcGpioInit) { enRet = ErrorInvalidParameter; } else { /* Reset GPIO init structure parameters values */ pstcGpioInit->u16PinState = PIN_STATE_RESET; pstcGpioInit->u16PinDir = PIN_DIR_IN; pstcGpioInit->u16PinOType = PIN_OTYPE_CMOS; pstcGpioInit->u16PinDrv = PIN_DRV_LOW; pstcGpioInit->u16Latch = PIN_LATCH_OFF; pstcGpioInit->u16PullUp = PIN_PU_OFF; pstcGpioInit->u16Invert = PIN_INVERT_OFF; pstcGpioInit->u16PinIType = PIN_ITYPE_SMT; pstcGpioInit->u16ExInt = PIN_EXINT_OFF; pstcGpioInit->u16PinAttr = PIN_ATTR_DIGITAL; } return enRet; } /** * @brief GPIO debug port configure. Set debug pins to GPIO * @param [in] u8DebugPort * @arg GPIO_PIN_SWDIO * @arg GPIO_PIN_SWCLK * @arg GPIO_PIN_SWO * @arg GPIO_PIN_DEBUG_SWD * @arg GPIO_PIN_TCK * @arg GPIO_PIN_TMS * @arg GPIO_PIN_TDO * @arg GPIO_PIN_TDI * @arg GPIO_PIN_TRST * @arg GPIO_PIN_DEBUG_JTAG * @param [in] enNewState * @arg Enable: set to debug port (SWD/JTAG) * @arg Disable: set to GPIO * @retval None */ void GPIO_SetDebugPort(uint8_t u8DebugPort, en_functional_state_t enNewState) { /* Parameter validity checking */ DDL_ASSERT(IS_GPIO_DEBUG_PORT(u8DebugPort)); DDL_ASSERT(IS_FUNCTIONAL_STATE(enNewState)); DDL_ASSERT(IS_GPIO_UNLOCKED()); if (Enable == enNewState) { SET_REG16_BIT(M4_GPIO->PSPCR, ((uint16_t)u8DebugPort & GPIO_PSPCR_SPFE)); } else { CLEAR_REG16_BIT(M4_GPIO->PSPCR, ((uint16_t)u8DebugPort & GPIO_PSPCR_SPFE)); } } /** * @brief Set specified Port Pin function , and turn ON/OFF its sub-function * @param [in] u8Port: GPIO_PORT_x, x can be (A~I) to select the GPIO peripheral * @param [in] u16Pin: GPIO_PIN_x, x can be (00~15) to select the PIN index * @param [in] u8Func: GPIO_FUNC_x, x can be selected from GPIO function definitions * @param [in] u16BFE: GPIO Sub-function enable setting * @arg PIN_SUBFUNC_ENABLE * @arg PIN_SUBFUNC_DISABLE * @retval None */ void GPIO_SetFunc(uint8_t u8Port, uint16_t u16Pin, uint8_t u8Func, uint16_t u16BFE) { __IO uint16_t *PFSRx; uint8_t u8PinPos; /* Parameter validity checking */ DDL_ASSERT(IS_GPIO_PORT_SOURCE(u8Port)); DDL_ASSERT(IS_GPIO_PIN(u16Pin)); DDL_ASSERT(IS_GPIO_FUNC(u8Func)); DDL_ASSERT(IS_GPIO_PIN_BFE(u16BFE)); DDL_ASSERT(IS_GPIO_UNLOCKED()); for (u8PinPos = 0U; u8PinPos < 16U; u8PinPos++) { if ((u16Pin & (uint16_t)(1UL << u8PinPos)) != 0U) { PFSRx = (__IO uint16_t *)((uint32_t)(&M4_GPIO->PFSRA0) + \ (uint32_t)(u8Port * 0x40UL) + u8PinPos * 4UL); WRITE_REG16(*PFSRx, (u16BFE | (uint16_t)u8Func)); } } } /** * @brief Set the sub-function, it's a global configuration * @param [in] u8Func: GPIO_FUNC_x, x can be selected from GPIO function definitions * @retval None */ void GPIO_SetSubFunc(uint8_t u8Func) { DDL_ASSERT(IS_GPIO_FUNC(u8Func)); DDL_ASSERT(IS_GPIO_UNLOCKED()); MODIFY_REG16(M4_GPIO->PCCR, GPIO_PCCR_BFSEL, u8Func); } /** * @brief Initialize GPIO. * @param [in] u8Port: GPIO_PORT_x, x can be (A~I) to select the GPIO peripheral * @param [in] u16Pin: GPIO_PIN_x, x can be (00~15) to select the PIN index * @param [in] enNewState * @arg Enable: set specified pin output enable * @arg Disable: set specified pin output disable * @retval None */ void GPIO_OE(uint8_t u8Port, uint16_t u16Pin, en_functional_state_t enNewState) { __IO uint16_t *POERx; /* Parameter validity checking */ DDL_ASSERT(IS_GPIO_PORT_SOURCE(u8Port)); DDL_ASSERT(IS_GPIO_PIN(u16Pin)); DDL_ASSERT(IS_FUNCTIONAL_STATE(enNewState)); POERx = (__IO uint16_t *)((uint32_t)(&M4_GPIO->POERA) + 0x10UL * u8Port); if (Enable == enNewState) { SET_REG16_BIT(*POERx, u16Pin); } else { CLEAR_REG16_BIT(*POERx, u16Pin); } } /** * @brief GPIO read wait cycle configure. * @param [in] u16ReadWait * @arg GPIO_READ_WAIT_0: ~ 50MHz * @arg GPIO_READ_WAIT_1: 50 ~ 100MHz * @arg GPIO_READ_WAIT_2: 100 ~ 150MHz * @arg GPIO_READ_WAIT_3: 150 ~ 200MHz * @arg GPIO_READ_WAIT_4: 200 ~ 250MHz * @arg GPIO_READ_WAIT_5: 250MHz above * @arg GPIO_READ_WAIT_6: 250MHz above * @arg GPIO_READ_WAIT_7: 250MHz above * @retval None */ void GPIO_SetReadWaitCycle(uint16_t u16ReadWait) { DDL_ASSERT(IS_GPIO_READ_WAIT(u16ReadWait)); DDL_ASSERT(IS_GPIO_UNLOCKED()); MODIFY_REG16(M4_GPIO->PCCR, GPIO_PCCR_RDWT, u16ReadWait); } /** * @brief GPIO input MOS always ON configure. * @param [in] u16PortIdx: Port index * @arg GPIO_PORTA_IDX * @arg GPIO_PORTB_IDX * @arg GPIO_PORTC_IDX * @arg GPIO_PORTD_IDX * @arg GPIO_PORTE_IDX * @arg GPIO_PORTF_IDX * @arg GPIO_PORTG_IDX * @arg GPIO_PORTH_IDX * @arg GPIO_PORTI_IDX * @arg GPIO_PORT_ALL * @param [in] enNewState * @arg Enable: set input MOS always ON * @arg Disable: set input MOS turns on while read operation * @retval None */ void GPIO_InMOSCmd(uint16_t u16PortIdx, en_functional_state_t enNewState) { DDL_ASSERT(IS_GPIO_PORT(u16PortIdx)); DDL_ASSERT(IS_FUNCTIONAL_STATE(enNewState)); DDL_ASSERT(IS_GPIO_UNLOCKED()); if (Enable == enNewState) { SET_REG16_BIT(M4_GPIO->PINAER, u16PortIdx); } else { CLEAR_REG16_BIT(M4_GPIO->PINAER, u16PortIdx); } } /** * @brief Read specified GPIO input data port pins * @param [in] u8Port: GPIO_PORT_x, x can be (A~I) to select the GPIO peripheral * @param [in] u16Pin: GPIO_PIN_x, x can be (00~15) to select the PIN index * @retval Specified GPIO port pin input value */ en_pin_state_t GPIO_ReadInputPins(uint8_t u8Port, uint16_t u16Pin) { __IO uint16_t *PIDRx; /* Parameter validity checking */ DDL_ASSERT(IS_GPIO_PORT_SOURCE(u8Port)); DDL_ASSERT(IS_GPIO_PIN(u16Pin)); PIDRx = (__IO uint16_t *)((uint32_t)(&M4_GPIO->PIDRA) + 0x10UL * u8Port); return ((READ_REG16(*PIDRx) & (u16Pin)) != 0U) ? Pin_Set : Pin_Reset; } /** * @brief Read specified GPIO input data port * @param [in] u8Port: GPIO_PORT_x, x can be (A~I) to select the GPIO peripheral * @retval Specified GPIO port input value */ uint16_t GPIO_ReadInputPort(uint8_t u8Port) { __IO uint16_t *PIDRx; /* Parameter validity checking */ DDL_ASSERT(IS_GPIO_PORT_SOURCE(u8Port)); PIDRx = (__IO uint16_t *)((uint32_t)(&M4_GPIO->PIDRA) + 0x10UL * u8Port); return READ_REG16(*PIDRx); } /** * @brief Read specified GPIO output data port pins * @param [in] u8Port: GPIO_PORT_x, x can be (A~I) to select the GPIO peripheral * @param [in] u16Pin: GPIO_PIN_x, x can be (00~15) to select the PIN index * @retval Specified GPIO port pin output value */ en_pin_state_t GPIO_ReadOutputPins(uint8_t u8Port, uint16_t u16Pin) { __IO uint16_t *PODRx; /* Parameter validity checking */ DDL_ASSERT(IS_GPIO_PORT_SOURCE(u8Port)); DDL_ASSERT(IS_GPIO_PIN(u16Pin)); PODRx = (__IO uint16_t *)((uint32_t)(&M4_GPIO->PODRA) + 0x10UL * u8Port); return ((*PODRx & (u16Pin)) != 0U) ? Pin_Set : Pin_Reset; } /** * @brief Read specified GPIO output data port * @param [in] u8Port: GPIO_PORT_x, x can be (A~I) to select the GPIO peripheral * @retval Specified GPIO port output value */ uint16_t GPIO_ReadOutputPort(uint8_t u8Port) { __IO uint16_t *PODRx; /* Parameter validity checking */ DDL_ASSERT(IS_GPIO_PORT_SOURCE(u8Port)); PODRx = (__IO uint16_t *)((uint32_t)(&M4_GPIO->PODRA) + 0x10UL * u8Port); return READ_REG16(*PODRx); } /** * @brief Set specified GPIO output data port pins * @param [in] u8Port: GPIO_PORT_x, x can be (A~I) to select the GPIO peripheral * @param [in] u16Pin: GPIO_PIN_x, x can be (00~15) to select the PIN index * @retval None */ void GPIO_SetPins(uint8_t u8Port, uint16_t u16Pin) { __IO uint16_t *POSRx; /* Parameter validity checking */ DDL_ASSERT(IS_GPIO_PORT_SOURCE(u8Port)); DDL_ASSERT(IS_GPIO_PIN(u16Pin)); POSRx = (__IO uint16_t *)((uint32_t)(&M4_GPIO->POSRA) + 0x10UL * u8Port); SET_REG16_BIT(*POSRx, u16Pin); } /** * @brief Reset specified GPIO output data port pins * @param [in] u8Port: GPIO_PORT_x, x can be (A~I) to select the GPIO peripheral * @param [in] u16Pin: GPIO_PIN_x, x can be (00~15) to select the PIN index * @retval None */ void GPIO_ResetPins(uint8_t u8Port, uint16_t u16Pin) { __IO uint16_t *PORRx; /* Parameter validity checking */ DDL_ASSERT(IS_GPIO_PORT_SOURCE(u8Port)); DDL_ASSERT(IS_GPIO_PIN(u16Pin)); PORRx = (__IO uint16_t *)((uint32_t)(&M4_GPIO->PORRA) + 0x10UL * u8Port); SET_REG16_BIT(*PORRx, u16Pin); } /** * @brief Write specified GPIO data port * @param [in] u8Port: GPIO_PORT_x, x can be (A~I) to select the GPIO peripheral * @param [in] u16PortVal: Pin output value * @retval None */ void GPIO_WritePort(uint8_t u8Port, uint16_t u16PortVal) { __IO uint16_t *PODRx; /* Parameter validity checking */ DDL_ASSERT(IS_GPIO_PORT_SOURCE(u8Port)); PODRx = (__IO uint16_t *)((uint32_t)(&M4_GPIO->PODRA) + 0x10UL * u8Port); WRITE_REG16(*PODRx, u16PortVal); } /** * @brief Toggle specified GPIO output data port pin * @param [in] u8Port: GPIO_PORT_x, x can be (A~I) to select the GPIO peripheral * @param [in] u16Pin: GPIO_PIN_x, x can be (00~15) to select the PIN index * @retval None */ void GPIO_TogglePins(uint8_t u8Port, uint16_t u16Pin) { __IO uint16_t *POTRx; /* Parameter validity checking */ DDL_ASSERT(IS_GPIO_PORT_SOURCE(u8Port)); DDL_ASSERT(IS_GPIO_PIN(u16Pin)); POTRx = (__IO uint16_t *)((uint32_t)(&M4_GPIO->POTRA) + 0x10UL * u8Port); SET_REG16_BIT(*POTRx, u16Pin); } /** * @} */ #endif /* DDL_GPIO_ENABLE */ /** * @} */ /** * @} */ /****************************************************************************** * EOF (not truncated) *****************************************************************************/