| /* ------------------------------------------ |
| * Copyright (c) 2016, Synopsys, Inc. All rights reserved. |
| |
| * Redistribution and use in source and binary forms, with or without modification, |
| * are permitted provided that the following conditions are met: |
| |
| * 1) Redistributions of source code must retain the above copyright notice, this |
| * list of conditions and the following disclaimer. |
| |
| * 2) Redistributions in binary form must reproduce the above copyright notice, |
| * this list of conditions and the following disclaimer in the documentation and/or |
| * other materials provided with the distribution. |
| |
| * 3) Neither the name of the Synopsys, Inc., nor the names of its contributors may |
| * be used to endorse or promote products derived from this software without |
| * specific prior written permission. |
| |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND |
| * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
| * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR |
| * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
| * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON |
| * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * \version 2016.05 |
| * \date 2014-06-17 |
| * \author Huaqi Fang(Huaqi.Fang@synopsys.com) |
| --------------------------------------------- */ |
| |
| /** |
| * \defgroup DEVICE_HAL_GPIO GPIO Device HAL Interface |
| * \ingroup DEVICE_HAL_DEF |
| * \brief definitions for gpio device hardware layer (\ref dev_gpio.h) |
| * \details provide interfaces for gpio driver to implement |
| * Here is a diagram for the gpio interface. |
| * |
| * \htmlonly |
| * <div class="imagebox"> |
| * <div style="width: 600px"> |
| * <img src="pic/dev_gpio_hal.jpg" alt="GPIO Device HAL Interface Diagram"/> |
| * <p>GPIO Device HAL Interface Diagram</p> |
| * </div> |
| * </div> |
| * \endhtmlonly |
| * |
| * @{ |
| * |
| * \file |
| * \brief gpio device hardware layer definitions |
| * \details Provide common definitions for gpio device, |
| * then the software developer can develop gpio driver |
| * following these definitions, and the applications |
| * can directly call this definition to realize functions |
| * |
| */ |
| |
| #ifndef _DEVICE_HAL_GPIO_H_ |
| #define _DEVICE_HAL_GPIO_H_ |
| |
| #include "device/device_hal/inc/dev_common.h" |
| |
| /** |
| * \defgroup DEVICE_HAL_GPIO_DEFDIR GPIO Port Direction Definition |
| * \ingroup DEVICE_HAL_GPIO |
| * \brief Define macros to indicate gpio directions |
| * @{ |
| */ |
| /* |
| * defines for gpio directions |
| */ |
| #define GPIO_DIR_INPUT (0) /*!< gpio works as input */ |
| #define GPIO_DIR_OUTPUT (1) /*!< gpio works as output */ |
| /** @} */ |
| |
| /** |
| * \defgroup DEVICE_HAL_GPIO_CTRLCMD GPIO Device Control Commands |
| * \ingroup DEVICE_HAL_GPIO |
| * \brief Definitions for gpio control command, used in \ref dev_gpio::gpio_control "GPIO IO Control" |
| * \details These commands defined here can be used in user code directly. |
| * - Parameters Usage |
| * - For passing parameters like integer, just use uint32_t/int32_t to directly pass values |
| * - For passing parameters for a structure, please use pointer to pass values |
| * - For getting some data, please use pointer to store the return data |
| * - Common Return Values |
| * - \ref E_OK, Control device successfully |
| * - \ref E_CLSED, Device is not opened |
| * - \ref E_OBJ, Device object is not valid or not exists |
| * - \ref E_PAR, Parameter is not valid for current control command |
| * - \ref E_SYS, Control device failed, due to hardware issues such as device is disabled |
| * - \ref E_NOSPT, Control command is not supported or not valid |
| * @{ |
| */ |
| /** |
| * Set the \ref dev_gpio_info::direction "direction" of masked bits of gpio port into \ref GPIO_DIR_INPUT "input" |
| * - Param type : uint32_t |
| * - Param usage : 1 in each bit will be masked. |
| * - Return value explanation : |
| */ |
| #define GPIO_CMD_SET_BIT_DIR_INPUT DEV_SET_SYSCMD(0) |
| /** |
| * Set the \ref dev_gpio_info::direction "direction" of masked bits of gpio port into \ref GPIO_DIR_OUTPUT "output" |
| * - Param type : uint32_t |
| * - Param usage : 1 in each bit will be masked. |
| * - Return value explanation : |
| */ |
| #define GPIO_CMD_SET_BIT_DIR_OUTPUT DEV_SET_SYSCMD(1) |
| /** |
| * Get \ref dev_gpio_info::direction "gpio port direction". |
| * - Param type : uint32_t |
| * - Param usage : 1 bit for 1 bit of gpio port, 0 for input, 1 for output |
| * - Return value explanation : |
| */ |
| #define GPIO_CMD_GET_BIT_DIR DEV_SET_SYSCMD(2) |
| /** |
| * Set gpio interrupt configuration for each bit. |
| * - Param type : \ref DEV_GPIO_INT_CFG * |
| * - Param usage : store gpio interrupt configuration for each bit. |
| * - Return value explanation : |
| */ |
| #define GPIO_CMD_SET_BIT_INT_CFG DEV_SET_SYSCMD(3) |
| /** |
| * Get gpio interrupt configuration for each bit. |
| * - Param type : \ref DEV_GPIO_INT_CFG * |
| * - Param usage : First set int_bit_mask in DEV_GPIO_INT_CFG structure to |
| * the mask of which bit of GPIO you want to get. And the interrupt configuration |
| * will be stored in the structure DEV_GPIO_INT_CFG, each bit stand for each bit of port. |
| * - Return value explanation : |
| */ |
| #define GPIO_CMD_GET_BIT_INT_CFG DEV_SET_SYSCMD(4) |
| /** |
| * Set gpio service routine for each bit. |
| * - Param type : \ref DEV_GPIO_BIT_ISR * |
| * - Param usage : store gpio handler information for each bit, int handler's param will be DEV_GPIO *. |
| * - Return value explanation : |
| */ |
| #define GPIO_CMD_SET_BIT_ISR DEV_SET_SYSCMD(5) |
| /** |
| * Get gpio service routine for each bit. |
| * - Param type : \ref DEV_GPIO_BIT_ISR * |
| * - Param usage : By passing int_bit_ofs in DEV_GPIO_BIT_ISR, |
| * it will return interrupt handler for this bit and store it in int_bit_handler. |
| * - Return value explanation : |
| */ |
| #define GPIO_CMD_GET_BIT_ISR DEV_SET_SYSCMD(6) |
| /** |
| * Enable gpio interrupt of the masked bits. |
| * - Param type : uint32_t |
| * - Param usage : 1 in each bit will be masked. |
| * - Return value explanation : |
| */ |
| #define GPIO_CMD_ENA_BIT_INT DEV_SET_SYSCMD(7) |
| /** |
| * Disable gpio interrupt of the masked bits. |
| * - Param type : uint32_t |
| * - Param usage : 1 in each bit will be masked. |
| * - Return value explanation : |
| */ |
| #define GPIO_CMD_DIS_BIT_INT DEV_SET_SYSCMD(8) |
| /** |
| * Get \ref dev_gpio_info::method "gpio interrupt enable status". |
| * - Param type : uint32_t * |
| * - Param usage : 1 bit for 1 bit of gpio port, 0 for poll, 1 for interrupt |
| * - Return value explanation : |
| */ |
| #define GPIO_CMD_GET_BIT_MTHD DEV_SET_SYSCMD(9) |
| /* @} */ |
| |
| /** |
| * \defgroup DEVICE_HAL_GPIO_INT_CFG_SET GPIO Device Int Configuration Settings |
| * \ingroup DEVICE_HAL_GPIO |
| * \brief definition of gpio interrupt type |
| * @{ |
| */ |
| |
| /* GPIO Mask Defintions */ |
| /** Mask none bits of the max 32bits */ |
| #define GPIO_BITS_MASK_NONE (0) |
| /** Mask all bits of the max 32bits */ |
| #define GPIO_BITS_MASK_ALL (0XFFFFFFFF) |
| |
| /* GPIO Interrupt Type Related Definitions */ |
| |
| /** Level sensitive interrupt type for 1 bit */ |
| #define GPIO_INT_LEVEL_TRIG (0) |
| /** Edge sensitive interrupt type for 1 bit */ |
| #define GPIO_INT_EDGE_TRIG (1) |
| /** Level sensitive interrupt type for all 32 bits */ |
| #define GPIO_INT_LEVEL_TRIG_ALL (0) |
| /** Edge sensitive interrupt type for all 32 bits */ |
| #define GPIO_INT_EDGE_TRIG_ALL (0XFFFFFFFF) |
| |
| /* For bit settings */ |
| /** Set bit interrupt type of gpio into level sensitive */ |
| #define GPIO_INT_BIT_LEVEL_TRIG(bit_ofs) (GPIO_INT_LEVEL_TRIG<<(bit_ofs)) |
| /** Set bit interrupt type of gpio into edge sensitive */ |
| #define GPIO_INT_BIT_EDGE_TRIG(bit_ofs) (GPIO_INT_EDGE_TRIG<<(bit_ofs)) |
| /* For bits settings */ |
| /** Set interrupt type of masked bits of gpio into level sensitive */ |
| #define GPIO_INT_BITS_LEVEL_TRIG(bit_mask) (GPIO_INT_LEVEL_TRIG_ALL&(bit_mask)) |
| /** Set bit interrupt type of gpio into edge sensitive */ |
| #define GPIO_INT_BITS_EDGE_TRIG(bit_mask) (GPIO_INT_EDGE_TRIG_ALL&(bit_mask)) |
| |
| /* GPIO Interrupt Polarity Related Definitions */ |
| |
| /** GPIO Interrupt polarity type enum */ |
| typedef enum gpio_int_polarity { |
| /* Polarity for 1 bit */ |
| GPIO_INT_ACTIVE_LOW = 0, /*!< Active low for level-sensitive interrupt for 1 bit */ |
| GPIO_INT_FALLING_EDGE = 0, /*!< Falling-edge for edge-sensitive interrupt for 1 bit */ |
| GPIO_INT_ACTIVE_HIGH = 1, /*!< Active high for level-sensitive interrupt for 1 bit */ |
| GPIO_INI_RISING_EDGE = 1, /*!< Rising-edge for edge-sensitive interrupt for 1 bit */ |
| /* Polartiy for all 32 bits */ |
| GPIO_INT_ACTIVE_LOW_ALL = 0, /*!< Active low for level-sensitive interrupt for all bits */ |
| GPIO_INT_FALLING_EDGE_ALL = 0, /*!< Falling-edge for edge-sensitive interrupt for all bits */ |
| GPIO_INT_ACTIVE_HIGH_ALL = 0XFFFFFFFF, /*!< Active high for level-sensitive interrupt for all bits */ |
| GPIO_INI_RISING_EDGE_ALL = 0XFFFFFFFF /*!< Rising-edge for edge-sensitive interrupt for all bits */ |
| } GPIO_INT_POLARITY; |
| |
| /* For bit settings */ |
| /** Set bit polarity of gpio into active low */ |
| #define GPIO_INT_BIT_POL_ACT_LOW(bit_ofs) (GPIO_INT_ACTIVE_LOW<<(bit_ofs)) |
| /** Set bit polarity of gpio into active high */ |
| #define GPIO_INT_BIT_POL_ACT_HIGH(bit_ofs) (GPIO_INT_ACTIVE_HIGH<<(bit_ofs)) |
| /** Set bit polarity of gpio into falling edge */ |
| #define GPIO_INT_BIT_POL_FALL_EDGE(bit_ofs) (GPIO_INT_FALLING_EDGE<<(bit_ofs)) |
| /** Set bit polarity of gpio into rising edge */ |
| #define GPIO_INT_BIT_POL_RISE_EDGE(bit_ofs) (GPIO_INI_RISING_EDGE<<(bit_ofs)) |
| |
| /* For bits settings */ |
| /** Set polarity of masked bits of gpio into active low */ |
| #define GPIO_INT_BITS_POL_ACT_LOW(bit_mask) (GPIO_INT_ACTIVE_LOW_ALL&(bit_mask)) |
| /** Set polarity of masked bits of gpio into active high */ |
| #define GPIO_INT_BITS_POL_ACT_HIGH(bit_mask) (GPIO_INT_ACTIVE_HIGH_ALL&(bit_mask)) |
| /** Set polarity of masked bits of gpio into falling edge */ |
| #define GPIO_INT_BITS_POL_FALL_EDGE(bit_mask) (GPIO_INT_FALLING_EDGE_ALL&(bit_mask)) |
| /** Set polarity of masked bits of gpio into rising edge */ |
| #define GPIO_INT_BITS_POL_RISE_EDGE(bit_mask) (GPIO_INI_RISING_EDGE_ALL&(bit_mask)) |
| |
| /* GPIO Interrupt Debounce Related Definitions */ |
| |
| /* For bit settings */ |
| /** Disable debounce circuitry for 1 bit */ |
| #define GPIO_INT_NO_DEBOUNCE (0) |
| /** Enable debounce circuitry for 1 bit */ |
| #define GPIO_INT_DEBOUNCE (1) |
| |
| /* For bits settings */ |
| /** Disable debounce circuitry for all bits */ |
| #define GPIO_INT_NO_DEBOUNCE_ALL (0) |
| /** Enable debounce circuitry for all bits */ |
| #define GPIO_INT_DEBOUNCE_ALL (0XFFFFFFFF) |
| |
| /* For bit settings */ |
| /** Set bit interrupt debounce of gpio into enabled */ |
| #define GPIO_INT_BIT_ENA_DEBOUNCE(bit_ofs) (GPIO_INT_DEBOUNCE<<(bit_ofs)) |
| /** Set bit interrupt debounce of gpio into disabled */ |
| #define GPIO_INT_BIT_DIS_DEBOUNCE(bit_ofs) (GPIO_INT_NO_DEBOUNCE<<(bit_ofs)) |
| /* For bits settings */ |
| /** Set bit interrupt debounce of gpio into enabled */ |
| #define GPIO_INT_BITS_ENA_DEBOUNCE(bit_mask) (GPIO_INT_DEBOUNCE_ALL&(bit_mask)) |
| /** Set bit interrupt debounce of gpio into disabled */ |
| #define GPIO_INT_BITS_DIS_DEBOUNCE(bit_mask) (GPIO_INT_NO_DEBOUNCE_ALL&(bit_mask)) |
| |
| /** GPIO interrupt configuration */ |
| typedef struct dev_gpio_int_cfg { |
| uint32_t int_bit_mask; /*!< interrupt bit mask for gpio */ |
| uint32_t int_bit_type; /*!< \ref GPIO_INT_LEVEL_TRIG "level sensitive" or \ref GPIO_INT_EDGE_TRIG "edge sensitive" for each gpio bit */ |
| uint32_t int_bit_polarity; /*!< active high or low, refer to \ref GPIO_INT_POLARITY for each gpio bit */ |
| uint32_t int_bit_debounce; /*!< \ref GPIO_INT_DEBOUNCE "enable" or \ref GPIO_INT_NO_DEBOUNCE "disable" debounce logic for each gpio bit */ |
| } DEV_GPIO_INT_CFG, * DEV_GPIO_INT_CFG_PTR; |
| |
| /** Default interrupt configuration for all gpio bits */ |
| static const DEV_GPIO_INT_CFG gpio_int_cfg_default = \ |
| {GPIO_BITS_MASK_ALL, GPIO_INT_LEVEL_TRIG_ALL, \ |
| GPIO_INT_ACTIVE_LOW_ALL, GPIO_INT_NO_DEBOUNCE_ALL}; |
| |
| /** GPIO interrupt handler or Interrupt Service Routine(ISR) */ |
| typedef void (*DEV_GPIO_HANDLER) (void *ptr); |
| |
| /** interrupt handler for each port bit */ |
| typedef struct dev_gpio_bit_isr { |
| uint32_t int_bit_ofs; /*!< int bit offset */ |
| DEV_GPIO_HANDLER int_bit_handler; /*!< interrupt handler */ |
| } DEV_GPIO_BIT_ISR, * DEV_GPIO_BIT_ISR_PTR; |
| /* @} */ |
| |
| /** |
| * \defgroup DEVICE_HAL_GPIO_DEVSTRUCT GPIO Device Interface Definition |
| * \ingroup DEVICE_HAL_GPIO |
| * \brief contains definitions of gpio device structure. |
| * \details This structure will be used in user implemented code, which was called |
| * \ref DEVICE_IMPL "Device Driver Implement Layer" for gpio to use in implementation code. |
| * Application developer should use the GPIO API provided here to access to GPIO devices. |
| * BSP developer should follow the API definition to implement GPIO device drivers. |
| * @{ |
| */ |
| /** |
| * \brief gpio information struct definition |
| * \details informations about gpio open count, working status |
| * gpio registers and control block, gpio io direction and interrupt/poll for each bit of gpio |
| * \note Only available for gpio with max 32bits |
| */ |
| typedef struct dev_gpio_info { |
| void *gpio_ctrl; /*!< gpio control related pointer, implemented by bsp developer, and this should be set during gpio object implementation */ |
| uint32_t opn_cnt; /*!< gpio open count, open it will increase 1, close it will decrease 1, 0 for close, >0 for open */ |
| uint32_t direction; /*!< each bit direction of this GPIO, default all \ref GPIO_DIR_INPUT "input" for first open */ |
| uint32_t method; /*!< int/poll method for each bit of GPIO, 0 for poll, 1 for interrupt, default all \ref DEV_POLL_METHOD "poll" for first open */ |
| void * extra; /*!< a extra pointer to get hook to applications which should not used by bsp developer, |
| this should be NULL for first open and you can \ref DEV_GPIO_INFO_SET_EXTRA_OBJECT "set" |
| or \ref DEV_GPIO_INFO_GET_EXTRA_OBJECT "get" the extra information pointer */ |
| } DEV_GPIO_INFO, * DEV_GPIO_INFO_PTR; |
| /** Set extra information pointer of gpio info */ |
| #define DEV_GPIO_INFO_SET_EXTRA_OBJECT(gpio_info_ptr, extra_info) (gpio_info_ptr)->extra = (void *)(extra_info) |
| /** Get extra information pointer of gpio info */ |
| #define DEV_GPIO_INFO_GET_EXTRA_OBJECT(gpio_info_ptr) ((gpio_info_ptr)->extra) |
| |
| /** Method of all gpio bits set to poll */ |
| #define DEV_GPIO_BITS_MTHD_POLL (0) |
| /** Method of all gpio bits set to interrupt */ |
| #define DEV_GPIO_BITS_MTHD_INTERRUPT (0xFFFFFFFF) |
| /** Default method of all gpio bits should be poll for first open */ |
| #define DEV_GPIO_BITS_MTHD_DEFAULT (DEV_GPIO_BITS_MTHD_POLL) |
| |
| /** |
| * \brief gpio device interface definition |
| * \details define gpio device interface, like gpio information structure, |
| * fuctions to open/close/control gpio, write or read data via gpio |
| * \note all this details are implemented by user in user porting code |
| */ |
| typedef struct dev_gpio { |
| DEV_GPIO_INFO gpio_info; /*!< gpio device information */ |
| int32_t (*gpio_open) (uint32_t dir); /*!< open gpio device with pre-defined gpio direction */ |
| int32_t (*gpio_close) (void); /*!< close gpio device */ |
| int32_t (*gpio_control) (uint32_t ctrl_cmd, void *param); /*!< control gpio device */ |
| int32_t (*gpio_write) (uint32_t val, uint32_t mask); /*!< write gpio device with val, only write the masked bits */ |
| int32_t (*gpio_read) (uint32_t *val, uint32_t mask); /*!< read gpio device val, only read the masked bits */ |
| } DEV_GPIO, * DEV_GPIO_PTR; |
| |
| /** |
| * \fn int32_t (* dev_gpio::gpio_open) (uint32_t dir) |
| * \details Open a gpio device with pre-defined io direction. |
| * \param[in] dir gpio direction for each bit |
| * \retval E_OK Open successfully without any issues |
| * \retval E_OPNED If device was opened before with different parameters, |
| * then just increase the \ref dev_gpio_info::opn_cnt "opn_cnt" and return \ref E_OPNED |
| * \retval E_OBJ Device object is not valid |
| * \retval E_PAR Parameter is not valid |
| * \retval E_NOSPT Open settings are not supported |
| */ |
| |
| /** |
| * \fn int32_t (* dev_gpio::gpio_close) (void) |
| * \details Close an gpio device, just decrease the \ref dev_gpio_info::opn_cnt "opn_cnt", |
| * if \ref dev_gpio_info::opn_cnt "opn_cnt" equals 0, then close the device |
| * \retval E_OK Close successfully without any issues(including scenario that device is already closed) |
| * \retval E_OPNED Device is still opened, the device \ref dev_gpio_info::opn_cnt "opn_cnt" decreased by 1 |
| * \retval E_OBJ Device object is not valid |
| */ |
| |
| /** |
| * \fn int32_t (* dev_gpio::gpio_control) (uint32_t ctrl_cmd, void *param) |
| * \details Control an gpio device by \ref ctrl_cmd, with passed \ref param. |
| * you can control gpio device using predefined gpio control commands defined using \ref DEV_SET_SYSCMD |
| * (which must be implemented by bsp developer), such as \ref GPIO_CMD_SET_BIT_DIR_INPUT |
| * "change masked gpio direction to input", and \ref DEVICE_HAL_GPIO_CTRLCMD "more". |
| * And you can also control gpio device using your own specified commands defined using \ref DEV_SET_USRCMD, |
| * but these specified commands should be defined in your own gpio device driver implementation. |
| * \param[in] ctrl_cmd \ref DEVICE_HAL_GPIO_CTRLCMD "control command", to change or get some thing related to gpio |
| * \param[in,out] param parameters that maybe argument of the command, or return values of the command |
| * \retval E_OK Control device successfully |
| * \retval E_CLSED Device is not opened |
| * \retval E_OBJ Device object is not valid or not exists |
| * \retval E_PAR Parameter is not valid for current control command |
| * \retval E_SYS Control device failed, due to hardware issues |
| * \retval E_CTX Control device failed, due to different reasons like in transfer state |
| * \retval E_NOSPT Control command is not supported or not valid, such as interrupt is not supported |
| */ |
| |
| /** |
| * \fn int32_t (* dev_gpio::gpio_write) (uint32_t val, uint32_t mask) |
| * \details Write gpio with \ref val, and only change the masked bits of gpio. |
| * \param[in] val the data that need to write to gpio |
| * \param[in] mask gpio bit mask |
| * \retval E_OK Write gpio with specified value successfully |
| * \retval E_OBJ Device object is not valid or not exists |
| * \retval E_PAR Parameter is not valid |
| */ |
| |
| /** |
| * \fn int32_t (* dev_gpio::gpio_read) (uint32_t *val, uint32_t mask) |
| * \details Read the masked gpio value |
| * \param[out] val pointer to data need to read from gpio |
| * \param[in] mask gpio bit mask |
| * \retval E_OK Read gpio data successfully |
| * \retval E_OBJ Device object is not valid or not exists |
| * \retval E_PAR Parameter is not valid |
| */ |
| |
| /** @} */ |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| /** |
| * \brief get an \ref dev_gpio "gpio device" by gpio device id. |
| * For how to use gpio device hal refer to \ref dev_gpio "Functions in gpio device structure" |
| * \param[in] gpio_id id of gpio, defined by user |
| * \retval !NULL pointer to an \ref dev_gpio "gpio device structure" |
| * \retval NULL failed to find the gpio device by \ref gpio_id |
| * \note need to implemented by user in user code |
| */ |
| extern DEV_GPIO_PTR gpio_get_dev(int32_t gpio_id); |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| /** @} */ |
| #endif /* _DEVICE_HAL_GPIO_H_ */ |