path: root/bsp/hc32f4a0/Libraries/HC32F4A0_StdPeriph_Driver/src/hc32f4a0_gpio.c

/**
 *******************************************************************************
 * @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<<u16PinPos)) != 0U)
            {
                PCRx = (__IO uint16_t *)((uint32_t)(&M4_GPIO->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)
 *****************************************************************************/