From 5b2799267d27ebffa2ba6d96270ecb223fcfe821 Mon Sep 17 00:00:00 2001 From: Vladimir Umek Date: Fri, 19 Jul 2024 13:44:08 +0200 Subject: [PATCH] Add CMSIS GPIO driver that uses GPIO interface specification introduced by CMSIS 6 - See: https://arm-software.github.io/CMSIS_6/latest/Driver/group__gpio__interface__gr.html --- AlifSemiconductor.Ensemble.pdsc | 11 + Alif_CMSIS/Include/Driver_GPIO.h | 157 -- Alif_CMSIS/Source/Driver_GPIO.c | 2340 +++++------------------ Alif_CMSIS/Source/Driver_GPIO_Private.h | 270 ++- 4 files changed, 654 insertions(+), 2124 deletions(-) delete mode 100644 Alif_CMSIS/Include/Driver_GPIO.h diff --git a/AlifSemiconductor.Ensemble.pdsc b/AlifSemiconductor.Ensemble.pdsc index 6513dc2..79b7250 100644 --- a/AlifSemiconductor.Ensemble.pdsc +++ b/AlifSemiconductor.Ensemble.pdsc @@ -1176,6 +1176,17 @@ + + GPIO driver for Alif Semiconductor SOC + + #define RTE_Drivers_GPIO0 1 /* Driver GPIO0 */ + + + + + + + UART Driver for Alif Semiconductor SOC diff --git a/Alif_CMSIS/Include/Driver_GPIO.h b/Alif_CMSIS/Include/Driver_GPIO.h deleted file mode 100644 index 08beef5..0000000 --- a/Alif_CMSIS/Include/Driver_GPIO.h +++ /dev/null @@ -1,157 +0,0 @@ -/* Copyright (C) 2022 Alif Semiconductor - All Rights Reserved. - * Use, distribution and modification of this code is permitted under the - * terms stated in the Alif Semiconductor Software License Agreement - * - * You should have received a copy of the Alif Semiconductor Software - * License Agreement with this file. If not, please write to: - * contact@alifsemi.com, or visit: https://alifsemi.com/license - * - */ - -/**************************************************************************//** - * @file Driver_GPIO.h - * @author Girish BN - * @email girish.bn@alifsemi.com - * @version V1.0.0 - * @date 21-Aug-2020 - * @brief CMSIS-Driver for GPIO. - * @bug None. - * @Note None - ******************************************************************************/ -#ifndef __DRIVER_GPIO_H__ -#define __DRIVER_GPIO_H__ - -#include "Driver_Common.h" - -#define _ARM_Driver_GPIO_(n) Driver_GPIO##n -#define ARM_Driver_GPIO_(n) _ARM_Driver_GPIO_(n) - -#define GPIO_PIN_SOFTWARE_MODE (1) -#define GPIO_PIN_HARDWARE_MODE (2) - -/****** GPIO Control code : ARM_GPIO_ENABLE_INTERRUPT arg definition *****/ -#define ARM_GPIO_IRQ_POLARITY_LOW 0x00000000 -#define ARM_GPIO_IRQ_POLARITY_HIGH 0x00000001 - -#define ARM_GPIO_IRQ_EDGE_SENSITIVE_SINGLE 0x00000000 -#define ARM_GPIO_IRQ_EDGE_SENSITIVE_BOTH 0x00000002 - -#define ARM_GPIO_IRQ_SENSITIVE_LEVEL 0x00000000 -#define ARM_GPIO_IRQ_SENSITIVE_EDGE 0x00000004 - -/****** GPIO Control code : ARM_GPIO_CONFIG_FLEXIO arg definition *****/ -#define ARM_GPIO_FLEXIO_VOLT_3V3 0x0 -#define ARM_GPIO_FLEXIO_VOLT_1V8 0x1 - -/****** GPIO Control code : ARM_GPIO_CONFIG_MODE arg definition *****/ -#define ARM_GPIO_MODE_SOFTWARE 0x0 -#define ARM_GPIO_MODE_HARDWARE 0x1 - -/****** GPIO Interrupt events *****/ -#define ARM_GPIO_IRQ_EVENT_EXTERNAL (1) - -/**< Initialization GPIO call back function declaration >*/ -typedef void (*ARM_GPIO_SignalEvent_t) (uint32_t event); - -/**< GPIO Control codes >*/ -typedef enum _GPIO_OPERATION { - ARM_GPIO_CONFIG_DEBOUNCE, /***/ - ARM_GPIO_ENABLE_INTERRUPT, /***/ - ARM_GPIO_DISABLE_INTERRUPT, /***/ - ARM_GPIO_GET_CONFIG_VALUE1, /***/ - ARM_GPIO_GET_CONFIG_VALUE2, /***/ - ARM_GPIO_CONFIG_FLEXIO, /***/ - ARM_GPIO_CONFIG_MODE /***/ -} GPIO_OPERATION; - -typedef enum _GPIO_PIN_DIRECTION { - GPIO_PIN_DIRECTION_INPUT, /***/ - GPIO_PIN_DIRECTION_OUTPUT, /***/ -} GPIO_PIN_DIRECTION; - -typedef enum _GPIO_PIN_OUTPUT_STATE { - GPIO_PIN_OUTPUT_STATE_LOW, /***/ - GPIO_PIN_OUTPUT_STATE_HIGH, /***/ - GPIO_PIN_OUTPUT_STATE_TOGGLE, /***/ -} GPIO_PIN_OUTPUT_STATE; - -typedef enum _GPIO_PIN_STATE { - GPIO_PIN_STATE_LOW, /***/ - GPIO_PIN_STATE_HIGH, /***/ -} GPIO_PIN_STATE; - -/** - \fn int32_t ARM_GPIO_Initialize (uint8_t pin_no, ARM_GPIO_SignalEvent_t cb_event); - \brief Initialize GPIO interface and register signal (callback) functions. - \param[in] pin_no: GPIO Pin number - \param[in] cb_event: Pointer to \ref ARM_GPIO_SignalEvent_t callback function - \param[out] int32_t: execution_status - - \fn int32_t ARM_GPIO_PowerControl (uint8_t pin_no, ARM_POWER_STATE state); - \brief Control GPIO interface power. - \param[in] pin_no: GPIO Pin number - \param[in] state: Power state - - ARM_POWER_OFF : power off: no operation possible - - ARM_POWER_LOW : low power mode: retain state, detect and signal wake-up events - - ARM_POWER_FULL: power on: full operation at maximum performance - \param[out] int32_t: execution_status - - \fn int32_t ARM_GPIO_SetDirection (uint32_t pin_no, GPIO_PIN_DIRECTION dir); - \brief Function Configure the GPIO to Input or Output operation . - \param[in] pin_no: GPIO Pin number. - \param[in] dir: GPIO direction. - \param[out] int32_t: execution status. - - \fn int32_t ARM_GPIO_GetDirection (uint32_t pin_no, uint32_t *dir); - \brief Function to get the GPIO direction . - \param[in] pin_no: GPIO Pin number. - \param[in] *dir: pointer to get the status of GPIO direction. - \param[out] int32_t: execution status. - - \fn int32_t ARM_GPIO_SetValue (uint32_t pin_no, GPIO_PIN_OUTPUT_STATE value); - \brief Function Configure the GPIO pin Output state. - \param[in] pin_no: GPIO Pin number. - \param[in] value: Set the output pin status. - \param[out] int32_t: execution status. - - \fn int32_t ARM_GPIO_GetValue (uint32_t pin_no, uint32_t *value); - \brief Function read the input GPIO status . - \param[in] pin_no: GPIO Pin number. - \param[in] *value: pointer to get the input pin status. - \param[out] int32_t: execution status. - - \fn int32_t ARM_GPIO_Control (uint8_t pin_no, uint32_t control_code, uint32_t *arg); - \brief Control GPIO interface. - \param[in] pin_no: GPIO Pin number - \param[in] control_code: control operation - - ARM_GPIO_CONFIG_DEBOUNCE: Perform the GPIO De-bounce configuration. - - ARM_GPIO_ENABLE_INTERRUPT: GPIO ENABLE interrupt configuration. - - ARM_GPIO_DISABLE_INTERRUPT: GPIO DISABLE interrupt configuration. - - ARM_GPIO_GET_CONFIG_VALUE1: get Config reg-1 value. - - ARM_GPIO_GET_CONFIG_VALUE2: get Config reg-2 value. - - ARM_GPIO_CONFIG_FLEXIO: Voltage config for FLEXIO GPIO. - - ARM_GPIO_CONFIG_MODE: GPIO config for GPIO Data Source Mode. - \param[in] *arg: pointer to operation parameters - \param[out] int32_t : execution_status - - \fn int32_t ARM_GPIO_Uninitialize (uint32_t pin_no); - \brief UnInitialize GPIO interface and register signal (callback) functions. - \param[in] pin_no: GPIO Pin number. - \param[out] int32_t: execution status. -*/ - -/** - * \brief Access structure of Gpio module. -*/ -typedef struct _ARM_DRIVER_GPIO { - int32_t (*Initialize) (uint8_t pin_no, ARM_GPIO_SignalEvent_t cb_event); /**< Pointer to \ref ARM_GPIO_Initialize : Initialize GPIO interface >*/ - int32_t (*PowerControl) (uint8_t pin_no, ARM_POWER_STATE state); /**< Pointer to \ref ARM_GPIO_PowerControl : Control GPIO interface power. >*/ - int32_t (*SetDirection) (uint8_t pin_no, GPIO_PIN_DIRECTION dir); /**< Pointer to \ref ARM_GPIO_SetDirection : Set GPIO direction. >*/ - int32_t (*GetDirection) (uint8_t pin_no, uint32_t *dir); /**< Pointer to \ref ARM_GPIO_GetDirection : Get GPIO direction. >*/ - int32_t (*SetValue) (uint8_t pin_no, GPIO_PIN_OUTPUT_STATE value); /**< Pointer to \ref ARM_GPIO_SetValue : Set GPIO Output pin status>*/ - int32_t (*GetValue) (uint8_t pin_no, uint32_t *value); /**< Pointer to \ref ARM_GPIO_GetValue : Get GPIO input pin status>*/ - int32_t (*Control) (uint8_t pin_no, GPIO_OPERATION control_code, uint32_t *arg); /**< Pointer to \ref ARM_GPIO_Control : Control GPIO interface.>*/ - int32_t (*Uninitialize) (uint8_t pin_no); /**< Pointer to \ref ARM_GPIO_Uninitialize : Un-initialize the GPIO Pin configuration >*/ -} ARM_DRIVER_GPIO; - -#endif /* __DRIVER_GPIO_H__ */ diff --git a/Alif_CMSIS/Source/Driver_GPIO.c b/Alif_CMSIS/Source/Driver_GPIO.c index ac627fe..6eae50f 100644 --- a/Alif_CMSIS/Source/Driver_GPIO.c +++ b/Alif_CMSIS/Source/Driver_GPIO.c @@ -1,1941 +1,511 @@ -/* Copyright (C) 2023 Alif Semiconductor - All Rights Reserved. - * Use, distribution and modification of this code is permitted under the - * terms stated in the Alif Semiconductor Software License Agreement +/* + * Copyright (c) 2024 ARM Limited. All rights reserved. * - * You should have received a copy of the Alif Semiconductor Software - * License Agreement with this file. If not, please write to: - * contact@alifsemi.com, or visit: https://alifsemi.com/license + * SPDX-License-Identifier: Apache-2.0 * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * $Date: 16. July 2024 + * $Revision: V1.0 + * + * Project: GPIO Driver for Alif Semiconductor Ensemble */ -/**************************************************************************//** - * @file Driver_GPIO.c - * @author Girish BN, Manoj A Murudi - * @email girish.bn@alifsemi.com, manoj.murudi@alifsemi.com - * @version V1.0.0 - * @date 29-March-2023 - * @brief CMSIS Driver for GPIO. - * @bug None. - * @Note None - ******************************************************************************/ - -#include "Driver_GPIO.h" #include "Driver_GPIO_Private.h" -#include "gpio.h" -#include "sys_ctrl_gpio.h" - -#if !(RTE_GPIO0 || RTE_GPIO1 || RTE_GPIO2 || RTE_GPIO3 || RTE_GPIO4 || RTE_GPIO5 || RTE_GPIO6 || RTE_GPIO7 || \ - RTE_GPIO8 || RTE_GPIO9 || RTE_GPIO10 || RTE_GPIO11 || RTE_GPIO12 || RTE_GPI13 || RTE_GPI14 || RTE_LPGPIO) -#error "GPIO is not enabled in the RTE_Device.h" -#endif - -#if !defined(RTE_Drivers_GPIO) -#error "GPIO is not enabled in the RTE_Components.h" -#endif - -/** - \fn int32_t GPIO_Initialize (GPIO_RESOURCES *GPIO, ARM_GPIO_SignalEvent_t cb_event, uint8_t pin_no) - \brief Initialize the gpio pin - \param cb_event : Pointer to gpio Event \ref GPIO_SignalEvent - \param GPIO : Pointer to gpio device resources - \param pin_no : pin to be configured. - \return execution_status -*/ -static int32_t GPIO_Initialize (GPIO_RESOURCES *GPIO, ARM_GPIO_SignalEvent_t cb_event, uint8_t pin_no) -{ - if (pin_no >= GPIO_PORT_MAX_PIN_NUMBER) - { - return ARM_DRIVER_ERROR_PARAMETER; - } - - /* mask the interrupt */ - gpio_mask_interrupt (GPIO->reg_base, pin_no); - - GPIO->cb_event[pin_no] = cb_event; - - GPIO->state.initialized = 1; - - return ARM_DRIVER_OK; -} - -/** - * @fn int32_t GPIO_PowerControl(GPIO_RESOURCES *GPIO, uint8_t pin_no, ARM_POWER_STATE state). - * @brief Handles the gpio power. - * @note none. - * @param GPIO : Pointer to gpio resources structure. - * @param pin_no : pin to be configured. - * @param state : power state. - * @retval \ref execution_status - */ -static int32_t GPIO_PowerControl (GPIO_RESOURCES *GPIO, uint8_t pin_no, ARM_POWER_STATE state) -{ - if (pin_no >= GPIO_PORT_MAX_PIN_NUMBER) - { - return ARM_DRIVER_ERROR_PARAMETER; - } - - switch (state) - { - case ARM_POWER_OFF: - { - if (GPIO->state.powered == 0) - { - return ARM_DRIVER_OK; - } - - GPIO->state.powered = 0; - break; - } - case ARM_POWER_FULL: - { - if (GPIO->state.initialized == 0) - { - return ARM_DRIVER_ERROR; - } - - GPIO->state.powered = 1; - break; - } - case ARM_POWER_LOW: - default: - { - return ARM_DRIVER_ERROR_UNSUPPORTED; - } - } - return ARM_DRIVER_OK; -} - -/** - * @fn int32_t GPIO_SetDirection (GPIO_RESOURCES *GPIO, uint8_t pin_no, GPIO_PIN_DIRECTION dir) - * @brief Set the direction for gpio pin. - * @note none. - * @param GPIO : Pointer to gpio resources structure. - * @param pin_no : pin to be configured. - * @param dir : direction to be set. - * @retval \ref execution_status - */ -static int32_t GPIO_SetDirection (GPIO_RESOURCES *GPIO, uint8_t pin_no, GPIO_PIN_DIRECTION dir) -{ - if (GPIO->state.powered == 0) - { - return ARM_DRIVER_ERROR; - } - if (pin_no >= GPIO_PORT_MAX_PIN_NUMBER) - { - return ARM_DRIVER_ERROR_PARAMETER; - } - - switch (dir) - { - case GPIO_PIN_DIRECTION_INPUT: - { - /**< Configuring Pin's to Input Direction >*/ - gpio_set_direction_input(GPIO->reg_base, pin_no); - break; - } - case GPIO_PIN_DIRECTION_OUTPUT: - { - /**< Configuring Pin's to Output Direction >*/ - gpio_set_direction_output(GPIO->reg_base, pin_no); - break; - } - default: - { - return ARM_DRIVER_ERROR_PARAMETER; - } - } - return ARM_DRIVER_OK; -} - -/** - * @fn int32_t GPIO_GetDirection (GPIO_RESOURCES *GPIO, uint8_t pin_no, uint32_t *dir) - * @brief Read gpio pin direction. - * @note none. - * @param GPIO : Pointer to gpio resources structure. - * @param pin_no : pin to be configured. - * @param dir : Pointer to the variable where direction should be stored. - * @retval \ref execution_status - */ -static int32_t GPIO_GetDirection (GPIO_RESOURCES *GPIO, uint8_t pin_no, uint32_t *dir) -{ - if (GPIO->state.powered == 0) - { - return ARM_DRIVER_ERROR; - } - if (pin_no >= GPIO_PORT_MAX_PIN_NUMBER) - { - return ARM_DRIVER_ERROR_PARAMETER; - } - if (dir == NULL) - { - return ARM_DRIVER_ERROR_PARAMETER; - } - - if (gpio_get_direction (GPIO->reg_base, pin_no)) - { - *dir = GPIO_PIN_DIRECTION_OUTPUT; - } - else - { - *dir = GPIO_PIN_DIRECTION_INPUT; - } - - return ARM_DRIVER_OK; -} - -/** - * @fn int32_t GPIO_SetValue (GPIO_RESOURCES *GPIO, uint8_t pin_no, GPIO_PIN_OUTPUT_STATE value) - * @brief Set value for gpio pin. - * @note none. - * @param GPIO : Pointer to gpio resources structure. - * @param pin_no : pin to be configured. - * @param value : value to be set. - * @retval \ref execution_status - */ -static int32_t GPIO_SetValue (GPIO_RESOURCES *GPIO, uint8_t pin_no, GPIO_PIN_OUTPUT_STATE value) -{ - if (GPIO->state.powered == 0) - { - return ARM_DRIVER_ERROR; - } - if (pin_no >= GPIO_PORT_MAX_PIN_NUMBER) - { - return ARM_DRIVER_ERROR_PARAMETER; - } - - switch (value) - { - case GPIO_PIN_OUTPUT_STATE_LOW: - { - /**< Set LOW(0) to the pin >*/ - gpio_set_value_low (GPIO->reg_base, pin_no); - break; - } - case GPIO_PIN_OUTPUT_STATE_HIGH: - { - /**< Set HIGH(1) to the pin >*/ - gpio_set_value_high (GPIO->reg_base, pin_no); - break; - } - case GPIO_PIN_OUTPUT_STATE_TOGGLE: - { - /**< Toggle pin value >*/ - gpio_toggle_value (GPIO->reg_base, pin_no); - break; - } - default: - { - return ARM_DRIVER_ERROR_PARAMETER; - } - } - return ARM_DRIVER_OK; -} - -/** - * @fn int32_t GPIO_GetValue (GPIO_RESOURCES *GPIO, uint8_t pin_no, uint32_t *value) - * @brief Read gpio pin data value. - * @note none. - * @param GPIO : Pointer to gpio resources structure. - * @param pin_no: pin to be configured. - * @param value : Pointer to the variable in which gpio data should be stored. - * @retval \ref execution_status - */ -static int32_t GPIO_GetValue (GPIO_RESOURCES *GPIO, uint8_t pin_no, uint32_t *value) -{ - if (GPIO->state.powered == 0) - { - return ARM_DRIVER_ERROR; - } - if (pin_no >= GPIO_PORT_MAX_PIN_NUMBER) - { - return ARM_DRIVER_ERROR_PARAMETER; - } - - if (gpio_get_value (GPIO->reg_base, pin_no)) - { - *value = GPIO_PIN_STATE_HIGH; - } - else - { - *value = GPIO_PIN_STATE_LOW; - } - - return ARM_DRIVER_OK; -} - -/** - * @fn int32_t GPIO_Control (GPIO_RESOURCES *GPIO, uint8_t pin_no, GPIO_OPERATION control_code, uint32_t *arg) - * @brief Used to configure gpio. - * @note none. - * @param GPIO : Pointer to gpio resources structure. - * @param pin_no : pin to be configured. - * @param control_code : control code to configure. - * @param arg : Pointer to an argument. - * @retval \ref execution_status - */ -static int32_t GPIO_Control (GPIO_RESOURCES *GPIO, uint8_t pin_no, GPIO_OPERATION control_code, uint32_t *arg) -{ - if (GPIO->state.powered == 0) - { - return ARM_DRIVER_ERROR; - } - if (pin_no >= GPIO_PORT_MAX_PIN_NUMBER) - { - return ARM_DRIVER_ERROR_PARAMETER; - } - switch (control_code) - { - case ARM_GPIO_CONFIG_DEBOUNCE : - { - if (!arg) - { - return ARM_DRIVER_ERROR_PARAMETER; - } - if (GPIO->gpio_id == LPGPIO_INSTANCE) - { - return ARM_DRIVER_ERROR_UNSUPPORTED; - } - - if(*arg) - { - /* Enable Debounce clock from EXPMST0 */ - enable_gpio_debounce_clk (GPIO->gpio_id); - - /* Set Debounce clock divider from EXPMST0 */ - set_gpio_debounce_clkdiv (GPIO->db_clkdiv, GPIO->gpio_id); - - /* Enable De-bounce operation */ - gpio_enable_debounce (GPIO->reg_base, pin_no); - } - else - { - /* Disable Debounce clock from EXPMST0 */ - disable_gpio_debounce_clk (GPIO->gpio_id); - - /* Disable De-bounce operation */ - gpio_disable_debounce (GPIO->reg_base, pin_no); - } - - break; - } - case ARM_GPIO_ENABLE_INTERRUPT : - { - if (!arg) - { - return ARM_DRIVER_ERROR_PARAMETER; - } - - /**< Enable interrupt >*/ - gpio_enable_interrupt (GPIO->reg_base, pin_no); - - /**< Unmask interrupt >*/ - gpio_unmask_interrupt (GPIO->reg_base, pin_no); - - if (ARM_GPIO_BIT_IRQ_BOTH_EDGE(*arg)) - { - /**< Configure interrupt for both edge >*/ - gpio_interrupt_set_both_edge_trigger (GPIO->reg_base, pin_no); - } - else - { - if (ARM_GPIO_BIT_IRQ_SENSITIVE(*arg)) - { - /**< Configure interrupt as edge sensitive >*/ - gpio_interrupt_set_edge_trigger (GPIO->reg_base, pin_no); - } - else - { - /**< Configure interrupt as level sensitive >*/ - gpio_interrupt_set_level_trigger (GPIO->reg_base, pin_no); - } - - if (ARM_GPIO_BIT_IRQ_POLARITY(*arg)) - { - /**< Configure interrupt for high edge >*/ - gpio_interrupt_set_polarity_high (GPIO->reg_base, pin_no); - } - else - { - /**< Configure interrupt for low edge >*/ - gpio_interrupt_set_polarity_low (GPIO->reg_base, pin_no); - } - } - - gpio_interrupt_eoi(GPIO->reg_base, pin_no); - - NVIC_ClearPendingIRQ (GPIO->IRQ_base_num + pin_no); - NVIC_SetPriority ((GPIO->IRQ_base_num + pin_no), GPIO->IRQ_priority[pin_no]); - NVIC_EnableIRQ (GPIO->IRQ_base_num + pin_no); - - break; - } - case ARM_GPIO_DISABLE_INTERRUPT : - { - /* setting to default values */ - gpio_disable_interrupt (GPIO->reg_base, pin_no); - gpio_mask_interrupt (GPIO->reg_base, pin_no); - gpio_interrupt_set_polarity_low (GPIO->reg_base, pin_no); - gpio_interrupt_set_level_trigger (GPIO->reg_base, pin_no); - - NVIC_ClearPendingIRQ (GPIO->IRQ_base_num + pin_no); - NVIC_DisableIRQ (GPIO->IRQ_base_num + pin_no); - break; - } - case ARM_GPIO_GET_CONFIG_VALUE1 : - { - if (!arg) - { - return ARM_DRIVER_ERROR_PARAMETER; - } - - *arg = gpio_read_config1 (GPIO->reg_base); - break; - } - case ARM_GPIO_GET_CONFIG_VALUE2 : - { - if (!arg) - { - return ARM_DRIVER_ERROR_PARAMETER; - } - - *arg = gpio_read_config2 (GPIO->reg_base); - break; - } - case ARM_GPIO_CONFIG_FLEXIO : - { - if (!((GPIO->gpio_id == GPIO7_INSTANCE) || (GPIO->gpio_id == LPGPIO_INSTANCE))) - { - return ARM_DRIVER_ERROR_UNSUPPORTED; - } - - if (GPIO->gpio_id == LPGPIO_INSTANCE) - { - if (!(lpgpio_is_flexio (pin_no))) - { - return ARM_DRIVER_ERROR_UNSUPPORTED; - } - } - else - { - if (!(gpio_is_flexio (pin_no))) - { - return ARM_DRIVER_ERROR_UNSUPPORTED; - } - } - - if (!arg) - { - return ARM_DRIVER_ERROR_PARAMETER; - } - - if (*arg) - { - set_flexio_gpio_voltage_1v8(); - } - else - { - set_flexio_gpio_voltage_3v3(); - } - break; - } - case ARM_GPIO_CONFIG_MODE : - { - if (GPIO->gpio_id != LPGPIO_INSTANCE) - { - return ARM_DRIVER_ERROR_UNSUPPORTED; - } - - if (*arg) - { - gpio_set_hardware_mode(GPIO->reg_base, pin_no); - } - else - { - gpio_set_software_mode(GPIO->reg_base, pin_no); - } - break; - } - default: - { - return ARM_DRIVER_ERROR; - } - } - - return ARM_DRIVER_OK; -} - -/** - * @fn int32_t GPIO_Uninitialize (GPIO_RESOURCES *GPIO, uint8_t pin_no) - * @brief Un-Initialize the gpio. - * @note none. - * @param GPIO : Pointer to gpio resources structure. - * @param pin_no : pin to be configured. - * @retval \ref execution_status - */ -static int32_t GPIO_Uninitialize (GPIO_RESOURCES *GPIO, uint8_t pin_no) -{ - if (GPIO->state.initialized == 0) - { - return ARM_DRIVER_OK; - } - if (pin_no >= GPIO_PORT_MAX_PIN_NUMBER) - { - return ARM_DRIVER_ERROR_PARAMETER; - } - - GPIO->cb_event[pin_no] = NULL; - - GPIO->state.initialized = 0; - - return ARM_DRIVER_OK; -} - -/** - \fn void GPIO_IRQ_Handler (GPIO_RESOURCES *GPIO, uint8_t pin_no) - \brief Initialize the gpio pin - \param cb_event : Pointer to gpio Event \ref GPIO_SignalEvent - \param GPIO : Pointer to gpio device resources - @param pin_no : pin to be configured. - \return execution_status -*/ -static void GPIO_IRQ_Handler (GPIO_RESOURCES *GPIO, uint8_t pin_no) -{ - /* clear pin interrupt */ - gpio_interrupt_eoi(GPIO->reg_base, pin_no); - - if (GPIO->cb_event[pin_no] != NULL) - { - GPIO->cb_event[pin_no](ARM_GPIO_IRQ_EVENT_EXTERNAL); - } -} - -/***/ -#if RTE_GPIO0 -static GPIO_RESOURCES GPIO0_RES = { - .reg_base = (GPIO_Type*) GPIO0_BASE, - .IRQ_base_num = GPIO0_IRQ0_IRQn, - .gpio_id = GPIO0_INSTANCE, - .db_clkdiv = RTE_GPIO0_DB_CLK_DIV, - .IRQ_priority = { - RTE_GPIO0_PIN0_IRQ_PRIORITY, - RTE_GPIO0_PIN1_IRQ_PRIORITY, - RTE_GPIO0_PIN2_IRQ_PRIORITY, - RTE_GPIO0_PIN3_IRQ_PRIORITY, - RTE_GPIO0_PIN4_IRQ_PRIORITY, - RTE_GPIO0_PIN5_IRQ_PRIORITY, - RTE_GPIO0_PIN6_IRQ_PRIORITY, - RTE_GPIO0_PIN7_IRQ_PRIORITY - } -}; - -void GPIO0_IRQ0Handler (void) { GPIO_IRQ_Handler (&GPIO0_RES, 0); } - -void GPIO0_IRQ1Handler (void) { GPIO_IRQ_Handler (&GPIO0_RES, 1); } - -void GPIO0_IRQ2Handler (void) { GPIO_IRQ_Handler (&GPIO0_RES, 2); } - -void GPIO0_IRQ3Handler (void) { GPIO_IRQ_Handler (&GPIO0_RES, 3); } - -void GPIO0_IRQ4Handler (void) { GPIO_IRQ_Handler (&GPIO0_RES, 4); } - -void GPIO0_IRQ5Handler (void) { GPIO_IRQ_Handler (&GPIO0_RES, 5); } - -void GPIO0_IRQ6Handler (void) { GPIO_IRQ_Handler (&GPIO0_RES, 6); } - -void GPIO0_IRQ7Handler (void) { GPIO_IRQ_Handler (&GPIO0_RES, 7); } - - -static int32_t ARM_GPIO0_Initialize (uint8_t pin_no, ARM_GPIO_SignalEvent_t cb_event) -{ - return GPIO_Initialize (&GPIO0_RES, cb_event, pin_no); -} - -static int32_t ARM_GPIO0_PowerControl (uint8_t pin_no, ARM_POWER_STATE state) -{ - return GPIO_PowerControl (&GPIO0_RES, pin_no, state); -} - -static int32_t ARM_GPIO0_SetDirection (uint8_t pin_no, GPIO_PIN_DIRECTION dir) -{ - return GPIO_SetDirection (&GPIO0_RES, pin_no, dir); -} - -static int32_t ARM_GPIO0_GetDirection (uint8_t pin_no, uint32_t *dir) -{ - return GPIO_GetDirection (&GPIO0_RES, pin_no, dir); -} - -static int32_t ARM_GPIO0_SetValue (uint8_t pin_no, GPIO_PIN_OUTPUT_STATE value) -{ - return GPIO_SetValue (&GPIO0_RES, pin_no, value); -} - -static int32_t ARM_GPIO0_GetValue (uint8_t pin_no, uint32_t *value) -{ - return GPIO_GetValue (&GPIO0_RES, pin_no, value); -} - -static int32_t ARM_GPIO0_Control (uint8_t pin_no, GPIO_OPERATION control_code, uint32_t *arg) -{ - return GPIO_Control (&GPIO0_RES, pin_no, control_code, arg); -} - -static int32_t ARM_GPIO0_Uninitialize (uint8_t pin_no) { - - return GPIO_Uninitialize (&GPIO0_RES, pin_no); -} - -extern ARM_DRIVER_GPIO Driver_GPIO0; -ARM_DRIVER_GPIO Driver_GPIO0 = { - ARM_GPIO0_Initialize, - ARM_GPIO0_PowerControl, - ARM_GPIO0_SetDirection, - ARM_GPIO0_GetDirection, - ARM_GPIO0_SetValue, - ARM_GPIO0_GetValue, - ARM_GPIO0_Control, - ARM_GPIO0_Uninitialize -}; -#endif /* RTE_GPIO0 */ - - -/***/ -#if RTE_GPIO1 -static GPIO_RESOURCES GPIO1_RES = { - .reg_base = (GPIO_Type*) GPIO1_BASE, - .IRQ_base_num = GPIO1_IRQ0_IRQn, - .gpio_id = GPIO1_INSTANCE, - .db_clkdiv = RTE_GPIO1_DB_CLK_DIV, - .IRQ_priority = { - RTE_GPIO1_PIN0_IRQ_PRIORITY, - RTE_GPIO1_PIN1_IRQ_PRIORITY, - RTE_GPIO1_PIN2_IRQ_PRIORITY, - RTE_GPIO1_PIN3_IRQ_PRIORITY, - RTE_GPIO1_PIN4_IRQ_PRIORITY, - RTE_GPIO1_PIN5_IRQ_PRIORITY, - RTE_GPIO1_PIN6_IRQ_PRIORITY, - RTE_GPIO1_PIN7_IRQ_PRIORITY - } -}; - -void GPIO1_IRQ0Handler (void) { GPIO_IRQ_Handler (&GPIO1_RES, 0); } - -void GPIO1_IRQ1Handler (void) { GPIO_IRQ_Handler (&GPIO1_RES, 1); } - -void GPIO1_IRQ2Handler (void) { GPIO_IRQ_Handler (&GPIO1_RES, 2); } - -void GPIO1_IRQ3Handler (void) { GPIO_IRQ_Handler (&GPIO1_RES, 3); } - -void GPIO1_IRQ4Handler (void) { GPIO_IRQ_Handler (&GPIO1_RES, 4); } - -void GPIO1_IRQ5Handler (void) { GPIO_IRQ_Handler (&GPIO1_RES, 5); } - -void GPIO1_IRQ6Handler (void) { GPIO_IRQ_Handler (&GPIO1_RES, 6); } - -void GPIO1_IRQ7Handler (void) { GPIO_IRQ_Handler (&GPIO1_RES, 7); } - -static int32_t ARM_GPIO1_Initialize (uint8_t pin_no, ARM_GPIO_SignalEvent_t cb_event) -{ - return GPIO_Initialize (&GPIO1_RES, cb_event, pin_no); -} - -static int32_t ARM_GPIO1_PowerControl (uint8_t pin_no, ARM_POWER_STATE state) -{ - return GPIO_PowerControl (&GPIO1_RES, pin_no, state); -} - -static int32_t ARM_GPIO1_SetDirection (uint8_t pin_no, GPIO_PIN_DIRECTION dir) -{ - return GPIO_SetDirection (&GPIO1_RES, pin_no, dir); -} - -static int32_t ARM_GPIO1_GetDirection (uint8_t pin_no, uint32_t *dir) -{ - return GPIO_GetDirection (&GPIO1_RES, pin_no, dir); -} - -static int32_t ARM_GPIO1_SetValue (uint8_t pin_no, GPIO_PIN_OUTPUT_STATE value) -{ - return GPIO_SetValue (&GPIO1_RES, pin_no, value); -} - -static int32_t ARM_GPIO1_GetValue (uint8_t pin_no, uint32_t *value) -{ - return GPIO_GetValue (&GPIO1_RES, pin_no, value); -} - -static int32_t ARM_GPIO1_Control (uint8_t pin_no, GPIO_OPERATION control_code, uint32_t *arg) -{ - return GPIO_Control (&GPIO1_RES, pin_no, control_code, arg); -} - -static int32_t ARM_GPIO1_Uninitialize (uint8_t pin_no) { - - return GPIO_Uninitialize (&GPIO1_RES, pin_no); -} - -extern ARM_DRIVER_GPIO Driver_GPIO1; -ARM_DRIVER_GPIO Driver_GPIO1 = { - ARM_GPIO1_Initialize, - ARM_GPIO1_PowerControl, - ARM_GPIO1_SetDirection, - ARM_GPIO1_GetDirection, - ARM_GPIO1_SetValue, - ARM_GPIO1_GetValue, - ARM_GPIO1_Control, - ARM_GPIO1_Uninitialize -}; -#endif /* RTE_GPIO1 */ - - -/***/ -#if RTE_GPIO2 -static GPIO_RESOURCES GPIO2_RES = { - .reg_base = (GPIO_Type*) GPIO2_BASE, - .IRQ_base_num = GPIO2_IRQ0_IRQn, - .gpio_id = GPIO2_INSTANCE, - .db_clkdiv = RTE_GPIO2_DB_CLK_DIV, - .IRQ_priority = { - RTE_GPIO2_PIN0_IRQ_PRIORITY, - RTE_GPIO2_PIN1_IRQ_PRIORITY, - RTE_GPIO2_PIN2_IRQ_PRIORITY, - RTE_GPIO2_PIN3_IRQ_PRIORITY, - RTE_GPIO2_PIN4_IRQ_PRIORITY, - RTE_GPIO2_PIN5_IRQ_PRIORITY, - RTE_GPIO2_PIN6_IRQ_PRIORITY, - RTE_GPIO2_PIN7_IRQ_PRIORITY - } -}; - -void GPIO2_IRQ0Handler (void) { GPIO_IRQ_Handler (&GPIO2_RES, 0); } - -void GPIO2_IRQ1Handler (void) { GPIO_IRQ_Handler (&GPIO2_RES, 1); } - -void GPIO2_IRQ2Handler (void) { GPIO_IRQ_Handler (&GPIO2_RES, 2); } - -void GPIO2_IRQ3Handler (void) { GPIO_IRQ_Handler (&GPIO2_RES, 3); } - -void GPIO2_IRQ4Handler (void) { GPIO_IRQ_Handler (&GPIO2_RES, 4); } - -void GPIO2_IRQ5Handler (void) { GPIO_IRQ_Handler (&GPIO2_RES, 5); } - -void GPIO2_IRQ6Handler (void) { GPIO_IRQ_Handler (&GPIO2_RES, 6); } - -void GPIO2_IRQ7Handler (void) { GPIO_IRQ_Handler (&GPIO2_RES, 7); } - -static int32_t ARM_GPIO2_Initialize (uint8_t pin_no, ARM_GPIO_SignalEvent_t cb_event) -{ - return GPIO_Initialize (&GPIO2_RES, cb_event, pin_no); -} - -static int32_t ARM_GPIO2_PowerControl (uint8_t pin_no, ARM_POWER_STATE state) -{ - return GPIO_PowerControl (&GPIO2_RES, pin_no, state); -} - -static int32_t ARM_GPIO2_SetDirection (uint8_t pin_no, GPIO_PIN_DIRECTION dir) -{ - return GPIO_SetDirection (&GPIO2_RES, pin_no, dir); -} - -static int32_t ARM_GPIO2_GetDirection (uint8_t pin_no, uint32_t *dir) -{ - return GPIO_GetDirection (&GPIO2_RES, pin_no, dir); -} - -static int32_t ARM_GPIO2_SetValue (uint8_t pin_no, GPIO_PIN_OUTPUT_STATE value) -{ - return GPIO_SetValue (&GPIO2_RES, pin_no, value); -} - -static int32_t ARM_GPIO2_GetValue (uint8_t pin_no, uint32_t *value) -{ - return GPIO_GetValue (&GPIO2_RES, pin_no, value); -} - -static int32_t ARM_GPIO2_Control (uint8_t pin_no, GPIO_OPERATION control_code, uint32_t *arg) -{ - return GPIO_Control (&GPIO2_RES, pin_no, control_code, arg); -} - -static int32_t ARM_GPIO2_Uninitialize (uint8_t pin_no) -{ - return GPIO_Uninitialize (&GPIO2_RES, pin_no); -} - -extern ARM_DRIVER_GPIO Driver_GPIO2; -ARM_DRIVER_GPIO Driver_GPIO2 = { - ARM_GPIO2_Initialize, - ARM_GPIO2_PowerControl, - ARM_GPIO2_SetDirection, - ARM_GPIO2_GetDirection, - ARM_GPIO2_SetValue, - ARM_GPIO2_GetValue, - ARM_GPIO2_Control, - ARM_GPIO2_Uninitialize -}; -#endif /* RTE_GPIO2 */ - - -/***/ -#if RTE_GPIO3 -static GPIO_RESOURCES GPIO3_RES = { - .reg_base = (GPIO_Type*) GPIO3_BASE, - .IRQ_base_num = GPIO3_IRQ0_IRQn, - .gpio_id = GPIO3_INSTANCE, - .db_clkdiv = RTE_GPIO3_DB_CLK_DIV, - .IRQ_priority = { - RTE_GPIO3_PIN0_IRQ_PRIORITY, - RTE_GPIO3_PIN1_IRQ_PRIORITY, - RTE_GPIO3_PIN2_IRQ_PRIORITY, - RTE_GPIO3_PIN3_IRQ_PRIORITY, - RTE_GPIO3_PIN4_IRQ_PRIORITY, - RTE_GPIO3_PIN5_IRQ_PRIORITY, - RTE_GPIO3_PIN6_IRQ_PRIORITY, - RTE_GPIO3_PIN7_IRQ_PRIORITY - } -}; - -void GPIO3_IRQ0Handler (void) { GPIO_IRQ_Handler (&GPIO3_RES, 0); } - -void GPIO3_IRQ1Handler (void) { GPIO_IRQ_Handler (&GPIO3_RES, 1); } - -void GPIO3_IRQ2Handler (void) { GPIO_IRQ_Handler (&GPIO3_RES, 2); } - -void GPIO3_IRQ3Handler (void) { GPIO_IRQ_Handler (&GPIO3_RES, 3); } - -void GPIO3_IRQ4Handler (void) { GPIO_IRQ_Handler (&GPIO3_RES, 4); } - -void GPIO3_IRQ5Handler (void) { GPIO_IRQ_Handler (&GPIO3_RES, 5); } - -void GPIO3_IRQ6Handler (void) { GPIO_IRQ_Handler (&GPIO3_RES, 6); } - -void GPIO3_IRQ7Handler (void) { GPIO_IRQ_Handler (&GPIO3_RES, 7); } - -static int32_t ARM_GPIO3_Initialize (uint8_t pin_no, ARM_GPIO_SignalEvent_t cb_event) -{ - return GPIO_Initialize (&GPIO3_RES, cb_event, pin_no); -} - -static int32_t ARM_GPIO3_PowerControl (uint8_t pin_no, ARM_POWER_STATE state) -{ - return GPIO_PowerControl (&GPIO3_RES, pin_no, state); -} - -static int32_t ARM_GPIO3_SetDirection (uint8_t pin_no, GPIO_PIN_DIRECTION dir) -{ - return GPIO_SetDirection (&GPIO3_RES, pin_no, dir); -} +#include "pinconf.h" +#include "gpio.h" -static int32_t ARM_GPIO3_GetDirection (uint8_t pin_no, uint32_t *dir) -{ - return GPIO_GetDirection (&GPIO3_RES, pin_no, dir); -} -static int32_t ARM_GPIO3_SetValue (uint8_t pin_no, GPIO_PIN_OUTPUT_STATE value) -{ - return GPIO_SetValue (&GPIO3_RES, pin_no, value); +// Pin mapping +// 0 .. 7: P0_0..7 (GPIO0) +// 8 .. 15: P1_0..7 (GPIO1) +// 16 .. 23: P2_0..7 (GPIO2) +// 24 .. 31: P3_0..7 (GPIO3) +// 32 .. 39: P4_0..7 (GPIO4) +// 40 .. 47: P5_0..7 (GPIO5) +// 48 .. 55: P6_0..7 (GPIO6) +// 56 .. 63: P7_0..7 (GPIO7) +// 64 .. 71: P8_0..7 (GPIO8) +// 72 .. 79: P9_0..7 (GPIO9) +// 80 .. 87: P10_0..7 (GPIO10) +// 88 .. 95: P11_0..7 (GPIO11) +// 96 .. 103: P12_0..7 (GPIO12) +// 104 .. 111: P13_0..7 (GPIO13) +// 112 .. 119: P14_0..7 (GPIO14) +// 120 .. 127: P15_0..7 (LPGPIO) + + +#define GPIO_MAX_PORTS 16U +#define GPIO_MAX_PINS 128U + +// GPIOx IRQ Numbers +static IRQn_Type const GPIO_IRQn[GPIO_MAX_PORTS] = { + GPIO0_IRQ0_IRQn, GPIO1_IRQ0_IRQn, GPIO2_IRQ0_IRQn, GPIO3_IRQ0_IRQn, + GPIO4_IRQ0_IRQn, GPIO5_IRQ0_IRQn, GPIO6_IRQ0_IRQn, GPIO7_IRQ0_IRQn, + GPIO8_IRQ0_IRQn, GPIO9_IRQ0_IRQn, GPIO10_IRQ0_IRQn, GPIO11_IRQ0_IRQn, + GPIO12_IRQ0_IRQn, GPIO13_IRQ0_IRQn, GPIO14_IRQ0_IRQn, LPGPIO_IRQ0_IRQn +}; + +// GPIOx Base Pointers +static uint32_t const GPIO_Base[GPIO_MAX_PORTS] = { + GPIO0_BASE, GPIO1_BASE, GPIO2_BASE, GPIO3_BASE, + GPIO4_BASE, GPIO5_BASE, GPIO6_BASE, GPIO7_BASE, + GPIO8_BASE, GPIO9_BASE, GPIO10_BASE, GPIO11_BASE, + GPIO12_BASE, GPIO13_BASE, GPIO14_BASE, LPGPIO_BASE +}; + + +// Signal Event callback functions +static ARM_GPIO_SignalEvent_t SignalEvent[GPIO_MAX_PORTS][8]; + + +// Common GPIO IRQ Handler +static void GPIO_IRQHandler (uint32_t gpio_num, uint32_t pin_num) { + GPIO_Type *gpio = (GPIO_Type *)GPIO_Base[gpio_num]; + ARM_GPIO_Pin_t pin; + uint32_t event; + + /* Clear pin interrupt */ + gpio_interrupt_eoi(gpio, pin_num); + + if (SignalEvent[gpio_num][pin_num] != NULL) { + pin = (8U * gpio_num) + pin_num; + + /* Determine interrupt polarity/edge */ + if (gpio->GPIO_INT_POLARITY & (1U << pin_num)) { + /* Active-high polarity / Rising edge */ + event = ARM_GPIO_EVENT_RISING_EDGE; + } else { + event = ARM_GPIO_EVENT_FALLING_EDGE; + } + + SignalEvent[gpio_num][pin_num](pin, event); + } +} + +void GPIO0_IRQ0Handler (void){ GPIO_IRQHandler(0U, 0U); } +void GPIO0_IRQ1Handler (void){ GPIO_IRQHandler(0U, 1U); } +void GPIO0_IRQ2Handler (void){ GPIO_IRQHandler(0U, 2U); } +void GPIO0_IRQ3Handler (void){ GPIO_IRQHandler(0U, 3U); } +void GPIO0_IRQ4Handler (void){ GPIO_IRQHandler(0U, 4U); } +void GPIO0_IRQ5Handler (void){ GPIO_IRQHandler(0U, 5U); } +void GPIO0_IRQ6Handler (void){ GPIO_IRQHandler(0U, 6U); } +void GPIO0_IRQ7Handler (void){ GPIO_IRQHandler(0U, 7U); } + +void GPIO1_IRQ0Handler (void){ GPIO_IRQHandler(1U, 0U); } +void GPIO1_IRQ1Handler (void){ GPIO_IRQHandler(1U, 1U); } +void GPIO1_IRQ2Handler (void){ GPIO_IRQHandler(1U, 2U); } +void GPIO1_IRQ3Handler (void){ GPIO_IRQHandler(1U, 3U); } +void GPIO1_IRQ4Handler (void){ GPIO_IRQHandler(1U, 4U); } +void GPIO1_IRQ5Handler (void){ GPIO_IRQHandler(1U, 5U); } +void GPIO1_IRQ6Handler (void){ GPIO_IRQHandler(1U, 6U); } +void GPIO1_IRQ7Handler (void){ GPIO_IRQHandler(1U, 7U); } + +void GPIO2_IRQ0Handler (void){ GPIO_IRQHandler(2U, 0U); } +void GPIO2_IRQ1Handler (void){ GPIO_IRQHandler(2U, 1U); } +void GPIO2_IRQ2Handler (void){ GPIO_IRQHandler(2U, 2U); } +void GPIO2_IRQ3Handler (void){ GPIO_IRQHandler(2U, 3U); } +void GPIO2_IRQ4Handler (void){ GPIO_IRQHandler(2U, 4U); } +void GPIO2_IRQ5Handler (void){ GPIO_IRQHandler(2U, 5U); } +void GPIO2_IRQ6Handler (void){ GPIO_IRQHandler(2U, 6U); } +void GPIO2_IRQ7Handler (void){ GPIO_IRQHandler(2U, 7U); } + +void GPIO3_IRQ0Handler (void){ GPIO_IRQHandler(3U, 0U); } +void GPIO3_IRQ1Handler (void){ GPIO_IRQHandler(3U, 1U); } +void GPIO3_IRQ2Handler (void){ GPIO_IRQHandler(3U, 2U); } +void GPIO3_IRQ3Handler (void){ GPIO_IRQHandler(3U, 3U); } +void GPIO3_IRQ4Handler (void){ GPIO_IRQHandler(3U, 4U); } +void GPIO3_IRQ5Handler (void){ GPIO_IRQHandler(3U, 5U); } +void GPIO3_IRQ6Handler (void){ GPIO_IRQHandler(3U, 6U); } +void GPIO3_IRQ7Handler (void){ GPIO_IRQHandler(3U, 7U); } + +void GPIO4_IRQ0Handler (void){ GPIO_IRQHandler(4U, 0U); } +void GPIO4_IRQ1Handler (void){ GPIO_IRQHandler(4U, 1U); } +void GPIO4_IRQ2Handler (void){ GPIO_IRQHandler(4U, 2U); } +void GPIO4_IRQ3Handler (void){ GPIO_IRQHandler(4U, 3U); } +void GPIO4_IRQ4Handler (void){ GPIO_IRQHandler(4U, 4U); } +void GPIO4_IRQ5Handler (void){ GPIO_IRQHandler(4U, 5U); } +void GPIO4_IRQ6Handler (void){ GPIO_IRQHandler(4U, 6U); } +void GPIO4_IRQ7Handler (void){ GPIO_IRQHandler(4U, 7U); } + +void GPIO5_IRQ0Handler (void){ GPIO_IRQHandler(5U, 0U); } +void GPIO5_IRQ1Handler (void){ GPIO_IRQHandler(5U, 1U); } +void GPIO5_IRQ2Handler (void){ GPIO_IRQHandler(5U, 2U); } +void GPIO5_IRQ3Handler (void){ GPIO_IRQHandler(5U, 3U); } +void GPIO5_IRQ4Handler (void){ GPIO_IRQHandler(5U, 4U); } +void GPIO5_IRQ5Handler (void){ GPIO_IRQHandler(5U, 5U); } +void GPIO5_IRQ6Handler (void){ GPIO_IRQHandler(5U, 6U); } +void GPIO5_IRQ7Handler (void){ GPIO_IRQHandler(5U, 7U); } + +void GPIO6_IRQ0Handler (void){ GPIO_IRQHandler(6U, 0U); } +void GPIO6_IRQ1Handler (void){ GPIO_IRQHandler(6U, 1U); } +void GPIO6_IRQ2Handler (void){ GPIO_IRQHandler(6U, 2U); } +void GPIO6_IRQ3Handler (void){ GPIO_IRQHandler(6U, 3U); } +void GPIO6_IRQ4Handler (void){ GPIO_IRQHandler(6U, 4U); } +void GPIO6_IRQ5Handler (void){ GPIO_IRQHandler(6U, 5U); } +void GPIO6_IRQ6Handler (void){ GPIO_IRQHandler(6U, 6U); } +void GPIO6_IRQ7Handler (void){ GPIO_IRQHandler(6U, 7U); } + +void GPIO7_IRQ0Handler (void){ GPIO_IRQHandler(7U, 0U); } +void GPIO7_IRQ1Handler (void){ GPIO_IRQHandler(7U, 1U); } +void GPIO7_IRQ2Handler (void){ GPIO_IRQHandler(7U, 2U); } +void GPIO7_IRQ3Handler (void){ GPIO_IRQHandler(7U, 3U); } +void GPIO7_IRQ4Handler (void){ GPIO_IRQHandler(7U, 4U); } +void GPIO7_IRQ5Handler (void){ GPIO_IRQHandler(7U, 5U); } +void GPIO7_IRQ6Handler (void){ GPIO_IRQHandler(7U, 6U); } +void GPIO7_IRQ7Handler (void){ GPIO_IRQHandler(7U, 7U); } + +void GPIO8_IRQ0Handler (void){ GPIO_IRQHandler(8U, 0U); } +void GPIO8_IRQ1Handler (void){ GPIO_IRQHandler(8U, 1U); } +void GPIO8_IRQ2Handler (void){ GPIO_IRQHandler(8U, 2U); } +void GPIO8_IRQ3Handler (void){ GPIO_IRQHandler(8U, 3U); } +void GPIO8_IRQ4Handler (void){ GPIO_IRQHandler(8U, 4U); } +void GPIO8_IRQ5Handler (void){ GPIO_IRQHandler(8U, 5U); } +void GPIO8_IRQ6Handler (void){ GPIO_IRQHandler(8U, 6U); } +void GPIO8_IRQ7Handler (void){ GPIO_IRQHandler(8U, 7U); } + +void GPIO9_IRQ0Handler (void){ GPIO_IRQHandler(9U, 0U); } +void GPIO9_IRQ1Handler (void){ GPIO_IRQHandler(9U, 1U); } +void GPIO9_IRQ2Handler (void){ GPIO_IRQHandler(9U, 2U); } +void GPIO9_IRQ3Handler (void){ GPIO_IRQHandler(9U, 3U); } +void GPIO9_IRQ4Handler (void){ GPIO_IRQHandler(9U, 4U); } +void GPIO9_IRQ5Handler (void){ GPIO_IRQHandler(9U, 5U); } +void GPIO9_IRQ6Handler (void){ GPIO_IRQHandler(9U, 6U); } +void GPIO9_IRQ7Handler (void){ GPIO_IRQHandler(9U, 7U); } + +void GPIO10_IRQ0Handler (void){ GPIO_IRQHandler(10U, 0U); } +void GPIO10_IRQ1Handler (void){ GPIO_IRQHandler(10U, 1U); } +void GPIO10_IRQ2Handler (void){ GPIO_IRQHandler(10U, 2U); } +void GPIO10_IRQ3Handler (void){ GPIO_IRQHandler(10U, 3U); } +void GPIO10_IRQ4Handler (void){ GPIO_IRQHandler(10U, 4U); } +void GPIO10_IRQ5Handler (void){ GPIO_IRQHandler(10U, 5U); } +void GPIO10_IRQ6Handler (void){ GPIO_IRQHandler(10U, 6U); } +void GPIO10_IRQ7Handler (void){ GPIO_IRQHandler(10U, 7U); } + +void GPIO11_IRQ0Handler (void){ GPIO_IRQHandler(11U, 0U); } +void GPIO11_IRQ1Handler (void){ GPIO_IRQHandler(11U, 1U); } +void GPIO11_IRQ2Handler (void){ GPIO_IRQHandler(11U, 2U); } +void GPIO11_IRQ3Handler (void){ GPIO_IRQHandler(11U, 3U); } +void GPIO11_IRQ4Handler (void){ GPIO_IRQHandler(11U, 4U); } +void GPIO11_IRQ5Handler (void){ GPIO_IRQHandler(11U, 5U); } +void GPIO11_IRQ6Handler (void){ GPIO_IRQHandler(11U, 6U); } +void GPIO11_IRQ7Handler (void){ GPIO_IRQHandler(11U, 7U); } + +void GPIO12_IRQ0Handler (void){ GPIO_IRQHandler(12U, 0U); } +void GPIO12_IRQ1Handler (void){ GPIO_IRQHandler(12U, 1U); } +void GPIO12_IRQ2Handler (void){ GPIO_IRQHandler(12U, 2U); } +void GPIO12_IRQ3Handler (void){ GPIO_IRQHandler(12U, 3U); } +void GPIO12_IRQ4Handler (void){ GPIO_IRQHandler(12U, 4U); } +void GPIO12_IRQ5Handler (void){ GPIO_IRQHandler(12U, 5U); } +void GPIO12_IRQ6Handler (void){ GPIO_IRQHandler(12U, 6U); } +void GPIO12_IRQ7Handler (void){ GPIO_IRQHandler(12U, 7U); } + +void GPIO13_IRQ0Handler (void){ GPIO_IRQHandler(13U, 0U); } +void GPIO13_IRQ1Handler (void){ GPIO_IRQHandler(13U, 1U); } +void GPIO13_IRQ2Handler (void){ GPIO_IRQHandler(13U, 2U); } +void GPIO13_IRQ3Handler (void){ GPIO_IRQHandler(13U, 3U); } +void GPIO13_IRQ4Handler (void){ GPIO_IRQHandler(13U, 4U); } +void GPIO13_IRQ5Handler (void){ GPIO_IRQHandler(13U, 5U); } +void GPIO13_IRQ6Handler (void){ GPIO_IRQHandler(13U, 6U); } +void GPIO13_IRQ7Handler (void){ GPIO_IRQHandler(13U, 7U); } + +void GPIO14_IRQ0Handler (void){ GPIO_IRQHandler(14U, 0U); } +void GPIO14_IRQ1Handler (void){ GPIO_IRQHandler(14U, 1U); } +void GPIO14_IRQ2Handler (void){ GPIO_IRQHandler(14U, 2U); } +void GPIO14_IRQ3Handler (void){ GPIO_IRQHandler(14U, 3U); } +void GPIO14_IRQ4Handler (void){ GPIO_IRQHandler(14U, 4U); } +void GPIO14_IRQ5Handler (void){ GPIO_IRQHandler(14U, 5U); } +void GPIO14_IRQ6Handler (void){ GPIO_IRQHandler(14U, 6U); } +void GPIO14_IRQ7Handler (void){ GPIO_IRQHandler(14U, 7U); } + +void LPGPIO_IRQ0Handler (void){ GPIO_IRQHandler(15U, 0U); } +void LPGPIO_IRQ1Handler (void){ GPIO_IRQHandler(15U, 1U); } +void LPGPIO_IRQ2Handler (void){ GPIO_IRQHandler(15U, 2U); } +void LPGPIO_IRQ3Handler (void){ GPIO_IRQHandler(15U, 3U); } +void LPGPIO_IRQ4Handler (void){ GPIO_IRQHandler(15U, 4U); } +void LPGPIO_IRQ5Handler (void){ GPIO_IRQHandler(15U, 5U); } +void LPGPIO_IRQ6Handler (void){ GPIO_IRQHandler(15U, 6U); } +void LPGPIO_IRQ7Handler (void){ GPIO_IRQHandler(15U, 7U); } + + +// Setup GPIO Interface +static int32_t GPIO_Setup (ARM_GPIO_Pin_t pin, ARM_GPIO_SignalEvent_t cb_event) { + GPIO_Type *gpio; + uint32_t gpio_num; + uint32_t pin_num; + int32_t status; + + if (pin >= GPIO_MAX_PINS) { + status = ARM_GPIO_ERROR_PIN; + } + else { + gpio_num = pin >> 3U; + pin_num = pin & 0x7U; + + /* Setup I/O signal multiplexer */ + pinconf_set(gpio_num, pin_num, PINMUX_ALTERNATE_FUNCTION_0, PADCTRL_READ_ENABLE | + PADCTRL_SLEW_RATE_FAST | + PADCTRL_DRIVER_DISABLED_HIGH_Z | + PADCTRL_OUTPUT_DRIVE_STRENGTH_2MA); + + gpio = (GPIO_Type *)GPIO_Base[gpio_num]; + + /* Default direction is input */ + gpio_set_direction_input(gpio, pin_num); + + if (cb_event == NULL) { + /* Disable interrupt if no callback installed */ + gpio_disable_interrupt(gpio, pin_num); + } + else { + /* Save pin callback event */ + SignalEvent[gpio_num][pin_num] = cb_event; + + /* Enable peripheral interrupt generation */ + gpio_mask_interrupt(gpio, pin_num); + + /* Enable NVIC interrupt generation */ + NVIC_EnableIRQ((IRQn_Type)(GPIO_IRQn[gpio_num] + pin_num)); + + /* Enable interrupt */ + gpio_enable_interrupt(gpio, pin_num); + } + + status = ARM_DRIVER_OK; + } + + return status; +} + +// Set GPIO Direction +static int32_t GPIO_SetDirection (ARM_GPIO_Pin_t pin, ARM_GPIO_DIRECTION direction) { + GPIO_Type *gpio; + uint32_t gpio_num; + uint32_t pin_num; + int32_t status; + + if (pin >= GPIO_MAX_PINS) { + status = ARM_GPIO_ERROR_PIN; + } + else { + status = ARM_DRIVER_OK; + + gpio_num = pin >> 3U; + pin_num = pin & 0x7U; + + gpio = (GPIO_Type *)GPIO_Base[gpio_num]; + + if (direction == ARM_GPIO_INPUT) { + gpio_set_direction_input(gpio, pin_num); + } + else if (direction == ARM_GPIO_OUTPUT) { + gpio_set_direction_output(gpio, pin_num); + } + else { + status = ARM_DRIVER_ERROR_PARAMETER; + } + } + + return status; } -static int32_t ARM_GPIO3_GetValue (uint8_t pin_no, uint32_t *value) -{ - return GPIO_GetValue (&GPIO3_RES, pin_no, value); -} +// Set GPIO Output Mode +static int32_t GPIO_SetOutputMode (ARM_GPIO_Pin_t pin, ARM_GPIO_OUTPUT_MODE mode) { + uint32_t gpio_num; + uint32_t pin_num; + int32_t status; + uint8_t alt_func; + uint8_t pad_ctrl; -static int32_t ARM_GPIO3_Control (uint8_t pin_no, GPIO_OPERATION control_code, uint32_t *arg) -{ - return GPIO_Control (&GPIO3_RES, pin_no, control_code, arg); -} + if (pin >= GPIO_MAX_PINS) { + status = ARM_GPIO_ERROR_PIN; + } + else { + status = ARM_DRIVER_OK; -static int32_t ARM_GPIO3_Uninitialize (uint8_t pin_no) -{ - return GPIO_Uninitialize (&GPIO3_RES, pin_no); -} + gpio_num = pin >> 3U; + pin_num = pin & 0x7U; -extern ARM_DRIVER_GPIO Driver_GPIO3; -ARM_DRIVER_GPIO Driver_GPIO3 = { - ARM_GPIO3_Initialize, - ARM_GPIO3_PowerControl, - ARM_GPIO3_SetDirection, - ARM_GPIO3_GetDirection, - ARM_GPIO3_SetValue, - ARM_GPIO3_GetValue, - ARM_GPIO3_Control, - ARM_GPIO3_Uninitialize -}; -#endif /* RTE_GPIO3 */ - - -/***/ -#if RTE_GPIO4 -static GPIO_RESOURCES GPIO4_RES = { - .reg_base = (GPIO_Type*) GPIO4_BASE, - .IRQ_base_num = GPIO4_IRQ0_IRQn, - .gpio_id = GPIO4_INSTANCE, - .db_clkdiv = RTE_GPIO4_DB_CLK_DIV, - .IRQ_priority = { - RTE_GPIO4_PIN0_IRQ_PRIORITY, - RTE_GPIO4_PIN1_IRQ_PRIORITY, - RTE_GPIO4_PIN2_IRQ_PRIORITY, - RTE_GPIO4_PIN3_IRQ_PRIORITY, - RTE_GPIO4_PIN4_IRQ_PRIORITY, - RTE_GPIO4_PIN5_IRQ_PRIORITY, - RTE_GPIO4_PIN6_IRQ_PRIORITY, - RTE_GPIO4_PIN7_IRQ_PRIORITY, + /* Read current configuration */ + if (pinconf_get(gpio_num, pin_num, &alt_func, &pad_ctrl) != 0) { + status = ARM_GPIO_ERROR_PIN; } -}; - -void GPIO4_IRQ0Handler (void) { GPIO_IRQ_Handler (&GPIO4_RES, 0); } - -void GPIO4_IRQ1Handler (void) { GPIO_IRQ_Handler (&GPIO4_RES, 1); } - -void GPIO4_IRQ2Handler (void) { GPIO_IRQ_Handler (&GPIO4_RES, 2); } - -void GPIO4_IRQ3Handler (void) { GPIO_IRQ_Handler (&GPIO4_RES, 3); } - -void GPIO4_IRQ4Handler (void) { GPIO_IRQ_Handler (&GPIO4_RES, 4); } - -void GPIO4_IRQ5Handler (void) { GPIO_IRQ_Handler (&GPIO4_RES, 5); } - -void GPIO4_IRQ6Handler (void) { GPIO_IRQ_Handler (&GPIO4_RES, 6); } - -void GPIO4_IRQ7Handler (void) { GPIO_IRQ_Handler (&GPIO4_RES, 7); } - -static int32_t ARM_GPIO4_Initialize (uint8_t pin_no, ARM_GPIO_SignalEvent_t cb_event) -{ - return GPIO_Initialize (&GPIO4_RES, cb_event, pin_no); -} - -static int32_t ARM_GPIO4_PowerControl (uint8_t pin_no, ARM_POWER_STATE state) -{ - return GPIO_PowerControl (&GPIO4_RES, pin_no, state); -} - -static int32_t ARM_GPIO4_SetDirection (uint8_t pin_no, GPIO_PIN_DIRECTION dir) -{ - return GPIO_SetDirection (&GPIO4_RES, pin_no, dir); -} - -static int32_t ARM_GPIO4_GetDirection (uint8_t pin_no, uint32_t *dir) -{ - int32_t ret = GPIO_GetDirection (&GPIO4_RES, pin_no, dir); - return ret; -} - -static int32_t ARM_GPIO4_SetValue (uint8_t pin_no, GPIO_PIN_OUTPUT_STATE value) -{ - return GPIO_SetValue (&GPIO4_RES, pin_no, value); -} - -static int32_t ARM_GPIO4_GetValue (uint8_t pin_no, uint32_t *value) -{ - return GPIO_GetValue (&GPIO4_RES, pin_no, value); -} - -static int32_t ARM_GPIO4_Control (uint8_t pin_no, GPIO_OPERATION control_code, uint32_t *arg) -{ - return GPIO_Control (&GPIO4_RES, pin_no, control_code, arg); -} - -static int32_t ARM_GPIO4_Uninitialize (uint8_t pin_no) -{ - return GPIO_Uninitialize (&GPIO4_RES, pin_no); -} - -extern ARM_DRIVER_GPIO Driver_GPIO4; -ARM_DRIVER_GPIO Driver_GPIO4 = { - ARM_GPIO4_Initialize, - ARM_GPIO4_PowerControl, - ARM_GPIO4_SetDirection, - ARM_GPIO4_GetDirection, - ARM_GPIO4_SetValue, - ARM_GPIO4_GetValue, - ARM_GPIO4_Control, - ARM_GPIO4_Uninitialize -}; -#endif /* RTE_GPIO4 */ - - -/***/ -#if RTE_GPIO5 -static GPIO_RESOURCES GPIO5_RES = { - .reg_base = (GPIO_Type*) GPIO5_BASE, - .IRQ_base_num = GPIO5_IRQ0_IRQn, - .gpio_id = GPIO5_INSTANCE, - .db_clkdiv = RTE_GPIO5_DB_CLK_DIV, - .IRQ_priority = { - RTE_GPIO5_PIN0_IRQ_PRIORITY, - RTE_GPIO5_PIN1_IRQ_PRIORITY, - RTE_GPIO5_PIN2_IRQ_PRIORITY, - RTE_GPIO5_PIN3_IRQ_PRIORITY, - RTE_GPIO5_PIN4_IRQ_PRIORITY, - RTE_GPIO5_PIN5_IRQ_PRIORITY, - RTE_GPIO5_PIN6_IRQ_PRIORITY, - RTE_GPIO5_PIN7_IRQ_PRIORITY, + else { + if (mode == ARM_GPIO_PUSH_PULL) { + pad_ctrl &= ~(PADCTRL_DRIVER_OPEN_DRAIN); + } + else if (mode == ARM_GPIO_OPEN_DRAIN) { + pad_ctrl |= PADCTRL_DRIVER_OPEN_DRAIN; + } + else { + status = ARM_DRIVER_ERROR_PARAMETER; + } } -}; - -void GPIO5_IRQ0Handler (void) { GPIO_IRQ_Handler (&GPIO5_RES, 0); } - -void GPIO5_IRQ1Handler (void) { GPIO_IRQ_Handler (&GPIO5_RES, 1); } -void GPIO5_IRQ2Handler (void) { GPIO_IRQ_Handler (&GPIO5_RES, 2); } - -void GPIO5_IRQ3Handler (void) { GPIO_IRQ_Handler (&GPIO5_RES, 3); } - -void GPIO5_IRQ4Handler (void) { GPIO_IRQ_Handler (&GPIO5_RES, 4); } - -void GPIO5_IRQ5Handler (void) { GPIO_IRQ_Handler (&GPIO5_RES, 5); } - -void GPIO5_IRQ6Handler (void) { GPIO_IRQ_Handler (&GPIO5_RES, 6); } - -void GPIO5_IRQ7Handler (void) { GPIO_IRQ_Handler (&GPIO5_RES, 7); } - -static int32_t ARM_GPIO5_Initialize (uint8_t pin_no, ARM_GPIO_SignalEvent_t cb_event) -{ - return GPIO_Initialize (&GPIO5_RES, cb_event, pin_no); -} - -static int32_t ARM_GPIO5_PowerControl (uint8_t pin_no, ARM_POWER_STATE state) -{ - return GPIO_PowerControl (&GPIO5_RES, pin_no, state); -} - -static int32_t ARM_GPIO5_SetDirection (uint8_t pin_no, GPIO_PIN_DIRECTION dir) -{ - return GPIO_SetDirection (&GPIO5_RES, pin_no, dir); -} - -static int32_t ARM_GPIO5_GetDirection (uint8_t pin_no, uint32_t *dir) -{ - int32_t ret = GPIO_GetDirection (&GPIO5_RES, pin_no, dir); - return ret; -} - -static int32_t ARM_GPIO5_SetValue (uint8_t pin_no, GPIO_PIN_OUTPUT_STATE value) -{ - return GPIO_SetValue (&GPIO5_RES, pin_no, value); -} - -static int32_t ARM_GPIO5_GetValue (uint8_t pin_no, uint32_t *value) -{ - return GPIO_GetValue (&GPIO5_RES, pin_no, value); -} - -static int32_t ARM_GPIO5_Control (uint8_t pin_no, GPIO_OPERATION control_code, uint32_t *arg) -{ - return GPIO_Control (&GPIO5_RES, pin_no, control_code, arg); -} - -static int32_t ARM_GPIO5_Uninitialize (uint8_t pin_no) -{ - return GPIO_Uninitialize (&GPIO5_RES, pin_no); -} - -extern ARM_DRIVER_GPIO Driver_GPIO5; -ARM_DRIVER_GPIO Driver_GPIO5 = { - ARM_GPIO5_Initialize, - ARM_GPIO5_PowerControl, - ARM_GPIO5_SetDirection, - ARM_GPIO5_GetDirection, - ARM_GPIO5_SetValue, - ARM_GPIO5_GetValue, - ARM_GPIO5_Control, - ARM_GPIO5_Uninitialize -}; -#endif /* RTE_GPIO5 */ - - -/***/ -#if RTE_GPIO6 -static GPIO_RESOURCES GPIO6_RES = { - .reg_base = (GPIO_Type*) GPIO6_BASE, - .IRQ_base_num = GPIO6_IRQ0_IRQn, - .gpio_id = GPIO6_INSTANCE, - .db_clkdiv = RTE_GPIO6_DB_CLK_DIV, - .IRQ_priority = { - RTE_GPIO6_PIN0_IRQ_PRIORITY, - RTE_GPIO6_PIN1_IRQ_PRIORITY, - RTE_GPIO6_PIN2_IRQ_PRIORITY, - RTE_GPIO6_PIN3_IRQ_PRIORITY, - RTE_GPIO6_PIN4_IRQ_PRIORITY, - RTE_GPIO6_PIN5_IRQ_PRIORITY, - RTE_GPIO6_PIN6_IRQ_PRIORITY, - RTE_GPIO6_PIN7_IRQ_PRIORITY, + if (status == ARM_DRIVER_OK) { + /* Apply new configuration */ + (void)pinconf_set (gpio_num, pin_num, PINMUX_ALTERNATE_FUNCTION_0, pad_ctrl); } -}; - -void GPIO6_IRQ0Handler (void) { GPIO_IRQ_Handler (&GPIO6_RES, 0); } - -void GPIO6_IRQ1Handler (void) { GPIO_IRQ_Handler (&GPIO6_RES, 1); } - -void GPIO6_IRQ2Handler (void) { GPIO_IRQ_Handler (&GPIO6_RES, 2); } - -void GPIO6_IRQ3Handler (void) { GPIO_IRQ_Handler (&GPIO6_RES, 3); } - -void GPIO6_IRQ4Handler (void) { GPIO_IRQ_Handler (&GPIO6_RES, 4); } + } -void GPIO6_IRQ5Handler (void) { GPIO_IRQ_Handler (&GPIO6_RES, 5); } - -void GPIO6_IRQ6Handler (void) { GPIO_IRQ_Handler (&GPIO6_RES, 6); } - -void GPIO6_IRQ7Handler (void) { GPIO_IRQ_Handler (&GPIO6_RES, 7); } - -static int32_t ARM_GPIO6_Initialize (uint8_t pin_no, ARM_GPIO_SignalEvent_t cb_event) -{ - return GPIO_Initialize (&GPIO6_RES, cb_event, pin_no); -} - -static int32_t ARM_GPIO6_PowerControl (uint8_t pin_no, ARM_POWER_STATE state) -{ - return GPIO_PowerControl (&GPIO6_RES, pin_no, state); -} - -static int32_t ARM_GPIO6_SetDirection (uint8_t pin_no, GPIO_PIN_DIRECTION dir) -{ - return GPIO_SetDirection (&GPIO6_RES, pin_no, dir); + return status; } -static int32_t ARM_GPIO6_GetDirection (uint8_t pin_no, uint32_t *dir) -{ - return GPIO_GetDirection (&GPIO6_RES, pin_no, dir); +// Set GPIO Pull Resistor +static int32_t GPIO_SetPullResistor (ARM_GPIO_Pin_t pin, ARM_GPIO_PULL_RESISTOR resistor) { + uint32_t gpio_num; + uint32_t pin_num; + int32_t status; + uint8_t alt_func; + uint8_t pad_ctrl; -} + if (pin >= GPIO_MAX_PINS) { + status = ARM_GPIO_ERROR_PIN; + } + else { + status = ARM_DRIVER_OK; -static int32_t ARM_GPIO6_SetValue (uint8_t pin_no, GPIO_PIN_OUTPUT_STATE value) -{ - return GPIO_SetValue (&GPIO6_RES, pin_no, value); -} - -static int32_t ARM_GPIO6_GetValue (uint8_t pin_no, uint32_t *value) -{ - return GPIO_GetValue (&GPIO6_RES, pin_no, value); -} - -static int32_t ARM_GPIO6_Control (uint8_t pin_no, GPIO_OPERATION control_code, uint32_t *arg) -{ - return GPIO_Control (&GPIO6_RES, pin_no, control_code, arg); -} - -static int32_t ARM_GPIO6_Uninitialize (uint8_t pin_no) -{ - return GPIO_Uninitialize (&GPIO6_RES, pin_no); -} + gpio_num = pin >> 3U; + pin_num = pin & 0x7U; -extern ARM_DRIVER_GPIO Driver_GPIO6; -ARM_DRIVER_GPIO Driver_GPIO6 = { - ARM_GPIO6_Initialize, - ARM_GPIO6_PowerControl, - ARM_GPIO6_SetDirection, - ARM_GPIO6_GetDirection, - ARM_GPIO6_SetValue, - ARM_GPIO6_GetValue, - ARM_GPIO6_Control, - ARM_GPIO6_Uninitialize -}; -#endif /* RTE_GPIO6 */ - - -/***/ -#if RTE_GPIO7 -static GPIO_RESOURCES GPIO7_RES = { - .reg_base = (GPIO_Type*) GPIO7_BASE, - .IRQ_base_num = GPIO7_IRQ0_IRQn, - .gpio_id = GPIO7_INSTANCE, - .db_clkdiv = RTE_GPIO7_DB_CLK_DIV, - .IRQ_priority = { - RTE_GPIO7_PIN0_IRQ_PRIORITY, - RTE_GPIO7_PIN1_IRQ_PRIORITY, - RTE_GPIO7_PIN2_IRQ_PRIORITY, - RTE_GPIO7_PIN3_IRQ_PRIORITY, - RTE_GPIO7_PIN4_IRQ_PRIORITY, - RTE_GPIO7_PIN5_IRQ_PRIORITY, - RTE_GPIO7_PIN6_IRQ_PRIORITY, - RTE_GPIO7_PIN7_IRQ_PRIORITY, + /* Read current configuration */ + if (pinconf_get(gpio_num, pin_num, &alt_func, &pad_ctrl) != 0) { + status = ARM_GPIO_ERROR_PIN; } -}; - -void GPIO7_IRQ0Handler (void) { GPIO_IRQ_Handler (&GPIO7_RES, 0); } - -void GPIO7_IRQ1Handler (void) { GPIO_IRQ_Handler (&GPIO7_RES, 1); } - -void GPIO7_IRQ2Handler (void) { GPIO_IRQ_Handler (&GPIO7_RES, 2); } - -void GPIO7_IRQ3Handler (void) { GPIO_IRQ_Handler (&GPIO7_RES, 3); } - -void GPIO7_IRQ4Handler (void) { GPIO_IRQ_Handler (&GPIO7_RES, 4); } - -void GPIO7_IRQ5Handler (void) { GPIO_IRQ_Handler (&GPIO7_RES, 5); } - -void GPIO7_IRQ6Handler (void) { GPIO_IRQ_Handler (&GPIO7_RES, 6); } - -void GPIO7_IRQ7Handler (void) { GPIO_IRQ_Handler (&GPIO7_RES, 7); } - -static int32_t ARM_GPIO7_Initialize (uint8_t pin_no, ARM_GPIO_SignalEvent_t cb_event) -{ - return GPIO_Initialize (&GPIO7_RES, cb_event, pin_no); -} - -static int32_t ARM_GPIO7_PowerControl (uint8_t pin_no, ARM_POWER_STATE state) -{ - return GPIO_PowerControl (&GPIO7_RES, pin_no, state); -} - -static int32_t ARM_GPIO7_SetDirection (uint8_t pin_no, GPIO_PIN_DIRECTION dir) -{ - return GPIO_SetDirection (&GPIO7_RES, pin_no, dir); -} - -static int32_t ARM_GPIO7_GetDirection (uint8_t pin_no, uint32_t *dir) -{ - return GPIO_GetDirection (&GPIO7_RES, pin_no, dir); -} - -static int32_t ARM_GPIO7_SetValue (uint8_t pin_no, GPIO_PIN_OUTPUT_STATE value) -{ - return GPIO_SetValue (&GPIO7_RES, pin_no, value); -} - -static int32_t ARM_GPIO7_GetValue (uint8_t pin_no, uint32_t *value) -{ - return GPIO_GetValue (&GPIO7_RES, pin_no, value); -} + else { + pad_ctrl &= ~(PADCTRL_DRIVER_DISABLED_HIGH_Z | + PADCTRL_DRIVER_DISABLED_PULL_UP | + PADCTRL_DRIVER_DISABLED_PULL_DOWN | + PADCTRL_DRIVER_DISABLED_BUS_REPEATER); -static int32_t ARM_GPIO7_Control (uint8_t pin_no, GPIO_OPERATION control_code, uint32_t *arg) -{ - return GPIO_Control (&GPIO7_RES, pin_no, control_code, arg); -} - -static int32_t ARM_GPIO7_Uninitialize (uint8_t pin_no) -{ - return GPIO_Uninitialize (&GPIO7_RES, pin_no); -} - -extern ARM_DRIVER_GPIO Driver_GPIO7; -ARM_DRIVER_GPIO Driver_GPIO7 = { - ARM_GPIO7_Initialize, - ARM_GPIO7_PowerControl, - ARM_GPIO7_SetDirection, - ARM_GPIO7_GetDirection, - ARM_GPIO7_SetValue, - ARM_GPIO7_GetValue, - ARM_GPIO7_Control, - ARM_GPIO7_Uninitialize -}; -#endif /* RTE_GPIO7 */ - - -/***/ -#if RTE_GPIO8 -static GPIO_RESOURCES GPIO8_RES = { - .reg_base = (GPIO_Type*) GPIO8_BASE, - .IRQ_base_num = GPIO8_IRQ0_IRQn, - .gpio_id = GPIO8_INSTANCE, - .db_clkdiv = RTE_GPIO8_DB_CLK_DIV, - .IRQ_priority = { - RTE_GPIO8_PIN0_IRQ_PRIORITY, - RTE_GPIO8_PIN1_IRQ_PRIORITY, - RTE_GPIO8_PIN2_IRQ_PRIORITY, - RTE_GPIO8_PIN3_IRQ_PRIORITY, - RTE_GPIO8_PIN4_IRQ_PRIORITY, - RTE_GPIO8_PIN5_IRQ_PRIORITY, - RTE_GPIO8_PIN6_IRQ_PRIORITY, - RTE_GPIO8_PIN7_IRQ_PRIORITY, + if (resistor == ARM_GPIO_PULL_NONE) { + pad_ctrl |= PADCTRL_DRIVER_DISABLED_HIGH_Z; + } + else if (resistor == ARM_GPIO_PULL_UP) { + pad_ctrl |= PADCTRL_DRIVER_DISABLED_PULL_UP; + } + else if (resistor == ARM_GPIO_PULL_DOWN) { + pad_ctrl |= PADCTRL_DRIVER_DISABLED_PULL_DOWN; + } + else { + status = ARM_DRIVER_ERROR_PARAMETER; + } } -}; - -void GPIO8_IRQ0Handler (void) { GPIO_IRQ_Handler (&GPIO8_RES, 0); } - -void GPIO8_IRQ1Handler (void) { GPIO_IRQ_Handler (&GPIO8_RES, 1); } -void GPIO8_IRQ2Handler (void) { GPIO_IRQ_Handler (&GPIO8_RES, 2); } - -void GPIO8_IRQ3Handler (void) { GPIO_IRQ_Handler (&GPIO8_RES, 3); } - -void GPIO8_IRQ4Handler (void) { GPIO_IRQ_Handler (&GPIO8_RES, 4); } - -void GPIO8_IRQ5Handler (void) { GPIO_IRQ_Handler (&GPIO8_RES, 5); } - -void GPIO8_IRQ6Handler (void) { GPIO_IRQ_Handler (&GPIO8_RES, 6); } - -void GPIO8_IRQ7Handler (void) { GPIO_IRQ_Handler (&GPIO8_RES, 7); } - -static int32_t ARM_GPIO8_Initialize (uint8_t pin_no, ARM_GPIO_SignalEvent_t cb_event) -{ - return GPIO_Initialize (&GPIO8_RES, cb_event, pin_no); -} - -static int32_t ARM_GPIO8_PowerControl (uint8_t pin_no, ARM_POWER_STATE state) -{ - return GPIO_PowerControl (&GPIO8_RES, pin_no, state); -} - -static int32_t ARM_GPIO8_SetDirection (uint8_t pin_no, GPIO_PIN_DIRECTION dir) -{ - return GPIO_SetDirection (&GPIO8_RES, pin_no, dir); -} - -static int32_t ARM_GPIO8_GetDirection (uint8_t pin_no, uint32_t *dir) -{ - return GPIO_GetDirection (&GPIO8_RES, pin_no, dir); -} - -static int32_t ARM_GPIO8_SetValue (uint8_t pin_no, GPIO_PIN_OUTPUT_STATE value) -{ - return GPIO_SetValue (&GPIO8_RES, pin_no, value); -} - -static int32_t ARM_GPIO8_GetValue (uint8_t pin_no, uint32_t *value) -{ - return GPIO_GetValue (&GPIO8_RES, pin_no, value); -} - -static int32_t ARM_GPIO8_Control (uint8_t pin_no, GPIO_OPERATION control_code, uint32_t *arg) -{ - return GPIO_Control (&GPIO8_RES, pin_no, control_code, arg); -} - -static int32_t ARM_GPIO8_Uninitialize (uint8_t pin_no) -{ - return GPIO_Uninitialize (&GPIO8_RES, pin_no); -} - -extern ARM_DRIVER_GPIO Driver_GPIO8; -ARM_DRIVER_GPIO Driver_GPIO8 = { - ARM_GPIO8_Initialize, - ARM_GPIO8_PowerControl, - ARM_GPIO8_SetDirection, - ARM_GPIO8_GetDirection, - ARM_GPIO8_SetValue, - ARM_GPIO8_GetValue, - ARM_GPIO8_Control, - ARM_GPIO8_Uninitialize -}; -#endif /* RTE_GPIO8 */ - - -/***/ -#if RTE_GPIO9 -static GPIO_RESOURCES GPIO9_RES = { - .reg_base = (GPIO_Type*) GPIO9_BASE, - .IRQ_base_num = GPIO9_IRQ0_IRQn, - .gpio_id = GPIO9_INSTANCE, - .db_clkdiv = RTE_GPIO9_DB_CLK_DIV, - .IRQ_priority = { - RTE_GPIO9_PIN0_IRQ_PRIORITY, - RTE_GPIO9_PIN1_IRQ_PRIORITY, - RTE_GPIO9_PIN2_IRQ_PRIORITY, - RTE_GPIO9_PIN3_IRQ_PRIORITY, - RTE_GPIO9_PIN4_IRQ_PRIORITY, - RTE_GPIO9_PIN5_IRQ_PRIORITY, - RTE_GPIO9_PIN6_IRQ_PRIORITY, - RTE_GPIO9_PIN7_IRQ_PRIORITY, + if (status == ARM_DRIVER_OK) { + /* Apply new configuration */ + (void)pinconf_set (gpio_num, pin_num, PINMUX_ALTERNATE_FUNCTION_0, pad_ctrl); } -}; - -void GPIO9_IRQ0Handler (void) { GPIO_IRQ_Handler (&GPIO9_RES, 0); } - -void GPIO9_IRQ1Handler (void) { GPIO_IRQ_Handler (&GPIO9_RES, 1); } - -void GPIO9_IRQ2Handler (void) { GPIO_IRQ_Handler (&GPIO9_RES, 2); } - -void GPIO9_IRQ3Handler (void) { GPIO_IRQ_Handler (&GPIO9_RES, 3); } - -void GPIO9_IRQ4Handler (void) { GPIO_IRQ_Handler (&GPIO9_RES, 4); } - -void GPIO9_IRQ5Handler (void) { GPIO_IRQ_Handler (&GPIO9_RES, 5); } + } -void GPIO9_IRQ6Handler (void) { GPIO_IRQ_Handler (&GPIO9_RES, 6); } - -void GPIO9_IRQ7Handler (void) { GPIO_IRQ_Handler (&GPIO9_RES, 7); } - -static int32_t ARM_GPIO9_Initialize (uint8_t pin_no, ARM_GPIO_SignalEvent_t cb_event) -{ - return GPIO_Initialize (&GPIO9_RES, cb_event, pin_no); -} - -static int32_t ARM_GPIO9_PowerControl (uint8_t pin_no, ARM_POWER_STATE state) -{ - return GPIO_PowerControl (&GPIO9_RES, pin_no, state); + return status; } -static int32_t ARM_GPIO9_SetDirection (uint8_t pin_no, GPIO_PIN_DIRECTION dir) -{ - return GPIO_SetDirection (&GPIO9_RES, pin_no, dir); -} +// Set GPIO Event Trigger +static int32_t GPIO_SetEventTrigger (ARM_GPIO_Pin_t pin, ARM_GPIO_EVENT_TRIGGER trigger) { + GPIO_Type *gpio; + uint32_t gpio_num; + uint32_t pin_num; + int32_t status; -static int32_t ARM_GPIO9_GetDirection (uint8_t pin_no, uint32_t *dir) -{ - return GPIO_GetDirection (&GPIO9_RES, pin_no, dir); -} + if (pin >= GPIO_MAX_PINS) { + status = ARM_GPIO_ERROR_PIN; + } + else { + status = ARM_DRIVER_OK; -static int32_t ARM_GPIO9_SetValue (uint8_t pin_no, GPIO_PIN_OUTPUT_STATE value) -{ - return GPIO_SetValue (&GPIO9_RES, pin_no, value); -} + gpio_num = pin >> 3U; + pin_num = pin & 0x7U; -static int32_t ARM_GPIO9_GetValue (uint8_t pin_no, uint32_t *value) -{ - return GPIO_GetValue (&GPIO9_RES, pin_no, value); -} + gpio = (GPIO_Type *)GPIO_Base[gpio_num]; -static int32_t ARM_GPIO9_Control (uint8_t pin_no, GPIO_OPERATION control_code, uint32_t *arg) -{ - return GPIO_Control (&GPIO9_RES, pin_no, control_code, arg); -} - -static int32_t ARM_GPIO9_Uninitialize (uint8_t pin_no) -{ - return GPIO_Uninitialize (&GPIO9_RES, pin_no); -} - -extern ARM_DRIVER_GPIO Driver_GPIO9; -ARM_DRIVER_GPIO Driver_GPIO9 = { - ARM_GPIO9_Initialize, - ARM_GPIO9_PowerControl, - ARM_GPIO9_SetDirection, - ARM_GPIO9_GetDirection, - ARM_GPIO9_SetValue, - ARM_GPIO9_GetValue, - ARM_GPIO9_Control, - ARM_GPIO9_Uninitialize -}; -#endif /* RTE_GPIO9 */ - - -/***/ -#if RTE_GPIO10 -static GPIO_RESOURCES GPIO10_RES = { - .reg_base = (GPIO_Type*) GPIO10_BASE, - .IRQ_base_num = GPIO10_IRQ0_IRQn, - .gpio_id = GPIO10_INSTANCE, - .db_clkdiv = RTE_GPIO10_DB_CLK_DIV, - .IRQ_priority = { - RTE_GPIO10_PIN0_IRQ_PRIORITY, - RTE_GPIO10_PIN1_IRQ_PRIORITY, - RTE_GPIO10_PIN2_IRQ_PRIORITY, - RTE_GPIO10_PIN3_IRQ_PRIORITY, - RTE_GPIO10_PIN4_IRQ_PRIORITY, - RTE_GPIO10_PIN5_IRQ_PRIORITY, - RTE_GPIO10_PIN6_IRQ_PRIORITY, - RTE_GPIO10_PIN7_IRQ_PRIORITY, + if (trigger == ARM_GPIO_TRIGGER_NONE) { + /* No trigger, just disable interrupt */ + gpio_disable_interrupt(gpio, pin_num); } -}; - -void GPIO10_IRQ0Handler (void) { GPIO_IRQ_Handler (&GPIO10_RES, 0); } - -void GPIO10_IRQ1Handler (void) { GPIO_IRQ_Handler (&GPIO10_RES, 1); } - -void GPIO10_IRQ2Handler (void) { GPIO_IRQ_Handler (&GPIO10_RES, 2); } - -void GPIO10_IRQ3Handler (void) { GPIO_IRQ_Handler (&GPIO10_RES, 3); } - -void GPIO10_IRQ4Handler (void) { GPIO_IRQ_Handler (&GPIO10_RES, 4); } - -void GPIO10_IRQ5Handler (void) { GPIO_IRQ_Handler (&GPIO10_RES, 5); } - -void GPIO10_IRQ6Handler (void) { GPIO_IRQ_Handler (&GPIO10_RES, 6); } - -void GPIO10_IRQ7Handler (void) { GPIO_IRQ_Handler (&GPIO10_RES, 7); } - -static int32_t ARM_GPIO10_Initialize (uint8_t pin_no, ARM_GPIO_SignalEvent_t cb_event) -{ - return GPIO_Initialize (&GPIO10_RES, cb_event, pin_no); -} - -static int32_t ARM_GPIO10_PowerControl (uint8_t pin_no, ARM_POWER_STATE state) -{ - return GPIO_PowerControl (&GPIO10_RES, pin_no, state); -} - -static int32_t ARM_GPIO10_SetDirection (uint8_t pin_no, GPIO_PIN_DIRECTION dir) -{ - return GPIO_SetDirection (&GPIO10_RES, pin_no, dir); -} - -static int32_t ARM_GPIO10_GetDirection (uint8_t pin_no, uint32_t *dir) -{ - return GPIO_GetDirection (&GPIO10_RES, pin_no, dir); -} - -static int32_t ARM_GPIO10_SetValue (uint8_t pin_no, GPIO_PIN_OUTPUT_STATE value) -{ - return GPIO_SetValue (&GPIO10_RES, pin_no, value); -} - -static int32_t ARM_GPIO10_GetValue (uint8_t pin_no, uint32_t *value) -{ - return GPIO_GetValue (&GPIO10_RES, pin_no, value); -} - -static int32_t ARM_GPIO10_Control (uint8_t pin_no, GPIO_OPERATION control_code, uint32_t *arg) -{ - return GPIO_Control (&GPIO10_RES, pin_no, control_code, arg); -} - -static int32_t ARM_GPIO10_Uninitialize (uint8_t pin_no) -{ - return GPIO_Uninitialize (&GPIO10_RES, pin_no); -} - -extern ARM_DRIVER_GPIO Driver_GPIO10; -ARM_DRIVER_GPIO Driver_GPIO10 = { - ARM_GPIO10_Initialize, - ARM_GPIO10_PowerControl, - ARM_GPIO10_SetDirection, - ARM_GPIO10_GetDirection, - ARM_GPIO10_SetValue, - ARM_GPIO10_GetValue, - ARM_GPIO10_Control, - ARM_GPIO10_Uninitialize -}; -#endif /* RTE_GPIO10 */ - - -/***/ -#if RTE_GPIO11 -static GPIO_RESOURCES GPIO11_RES = { - .reg_base = (GPIO_Type*) GPIO11_BASE, - .IRQ_base_num = GPIO11_IRQ0_IRQn, - .gpio_id = GPIO11_INSTANCE, - .db_clkdiv = RTE_GPIO11_DB_CLK_DIV, - .IRQ_priority = { - RTE_GPIO11_PIN0_IRQ_PRIORITY, - RTE_GPIO11_PIN1_IRQ_PRIORITY, - RTE_GPIO11_PIN2_IRQ_PRIORITY, - RTE_GPIO11_PIN3_IRQ_PRIORITY, - RTE_GPIO11_PIN4_IRQ_PRIORITY, - RTE_GPIO11_PIN5_IRQ_PRIORITY, - RTE_GPIO11_PIN6_IRQ_PRIORITY, - RTE_GPIO11_PIN7_IRQ_PRIORITY, + else if (trigger == ARM_GPIO_TRIGGER_RISING_EDGE) { + /* Rising edge triggers interrupt */ + gpio_interrupt_set_edge_trigger (gpio, pin_num); + gpio_interrupt_set_polarity_high(gpio, pin_num); } -}; - -void GPIO11_IRQ0Handler (void) { GPIO_IRQ_Handler (&GPIO11_RES, 0); } - -void GPIO11_IRQ1Handler (void) { GPIO_IRQ_Handler (&GPIO11_RES, 1); } - -void GPIO11_IRQ2Handler (void) { GPIO_IRQ_Handler (&GPIO11_RES, 2); } - -void GPIO11_IRQ3Handler (void) { GPIO_IRQ_Handler (&GPIO11_RES, 3); } - -void GPIO11_IRQ4Handler (void) { GPIO_IRQ_Handler (&GPIO11_RES, 4); } - -void GPIO11_IRQ5Handler (void) { GPIO_IRQ_Handler (&GPIO11_RES, 5); } - -void GPIO11_IRQ6Handler (void) { GPIO_IRQ_Handler (&GPIO11_RES, 6); } - -void GPIO11_IRQ7Handler (void) { GPIO_IRQ_Handler (&GPIO11_RES, 7); } - -static int32_t ARM_GPIO11_Initialize (uint8_t pin_no, ARM_GPIO_SignalEvent_t cb_event) -{ - return GPIO_Initialize (&GPIO11_RES, cb_event, pin_no); -} - -static int32_t ARM_GPIO11_PowerControl (uint8_t pin_no, ARM_POWER_STATE state) -{ - return GPIO_PowerControl (&GPIO11_RES, pin_no, state); -} - -static int32_t ARM_GPIO11_SetDirection (uint8_t pin_no, GPIO_PIN_DIRECTION dir) -{ - return GPIO_SetDirection (&GPIO11_RES, pin_no, dir); -} - -static int32_t ARM_GPIO11_GetDirection (uint8_t pin_no, uint32_t *dir) -{ - return GPIO_GetDirection (&GPIO11_RES, pin_no, dir); -} - -static int32_t ARM_GPIO11_SetValue (uint8_t pin_no, GPIO_PIN_OUTPUT_STATE value) -{ - return GPIO_SetValue (&GPIO11_RES, pin_no, value); -} - -static int32_t ARM_GPIO11_GetValue (uint8_t pin_no, uint32_t *value) -{ - return GPIO_GetValue (&GPIO11_RES, pin_no, value); -} - -static int32_t ARM_GPIO11_Control (uint8_t pin_no, GPIO_OPERATION control_code, uint32_t *arg) -{ - return GPIO_Control (&GPIO11_RES, pin_no, control_code, arg); -} - -static int32_t ARM_GPIO11_Uninitialize (uint8_t pin_no) -{ - return GPIO_Uninitialize (&GPIO11_RES, pin_no); -} - -extern ARM_DRIVER_GPIO Driver_GPIO11; -ARM_DRIVER_GPIO Driver_GPIO11 = { - ARM_GPIO11_Initialize, - ARM_GPIO11_PowerControl, - ARM_GPIO11_SetDirection, - ARM_GPIO11_GetDirection, - ARM_GPIO11_SetValue, - ARM_GPIO11_GetValue, - ARM_GPIO11_Control, - ARM_GPIO11_Uninitialize -}; -#endif /* RTE_GPIO11 */ - - -/***/ -#if RTE_GPIO12 -static GPIO_RESOURCES GPIO12_RES = { - .reg_base = (GPIO_Type*) GPIO12_BASE, - .IRQ_base_num = GPIO12_IRQ0_IRQn, - .gpio_id = GPIO12_INSTANCE, - .db_clkdiv = RTE_GPIO12_DB_CLK_DIV, - .IRQ_priority = { - RTE_GPIO12_PIN0_IRQ_PRIORITY, - RTE_GPIO12_PIN1_IRQ_PRIORITY, - RTE_GPIO12_PIN2_IRQ_PRIORITY, - RTE_GPIO12_PIN3_IRQ_PRIORITY, - RTE_GPIO12_PIN4_IRQ_PRIORITY, - RTE_GPIO12_PIN5_IRQ_PRIORITY, - RTE_GPIO12_PIN6_IRQ_PRIORITY, - RTE_GPIO12_PIN7_IRQ_PRIORITY, + else if (trigger == ARM_GPIO_TRIGGER_FALLING_EDGE) { + /* Falling edge triggers interrupt */ + gpio_interrupt_set_edge_trigger(gpio, pin_num); + gpio_interrupt_set_polarity_low(gpio, pin_num); } -}; - -void GPIO12_IRQ0Handler (void) { GPIO_IRQ_Handler (&GPIO12_RES, 0); } - -void GPIO12_IRQ1Handler (void) { GPIO_IRQ_Handler (&GPIO12_RES, 1); } - -void GPIO12_IRQ2Handler (void) { GPIO_IRQ_Handler (&GPIO12_RES, 2); } - -void GPIO12_IRQ3Handler (void) { GPIO_IRQ_Handler (&GPIO12_RES, 3); } - -void GPIO12_IRQ4Handler (void) { GPIO_IRQ_Handler (&GPIO12_RES, 4); } - -void GPIO12_IRQ5Handler (void) { GPIO_IRQ_Handler (&GPIO12_RES, 5); } - -void GPIO12_IRQ6Handler (void) { GPIO_IRQ_Handler (&GPIO12_RES, 6); } - -void GPIO12_IRQ7Handler (void) { GPIO_IRQ_Handler (&GPIO12_RES, 7); } - -static int32_t ARM_GPIO12_Initialize (uint8_t pin_no, ARM_GPIO_SignalEvent_t cb_event) -{ - return GPIO_Initialize (&GPIO12_RES, cb_event, pin_no); -} - -static int32_t ARM_GPIO12_PowerControl (uint8_t pin_no, ARM_POWER_STATE state) -{ - return GPIO_PowerControl (&GPIO12_RES, pin_no, state); -} - -static int32_t ARM_GPIO12_SetDirection (uint8_t pin_no, GPIO_PIN_DIRECTION dir) -{ - return GPIO_SetDirection (&GPIO12_RES, pin_no, dir); -} - -static int32_t ARM_GPIO12_GetDirection (uint8_t pin_no, uint32_t *dir) -{ - return GPIO_GetDirection (&GPIO12_RES, pin_no, dir); -} - -static int32_t ARM_GPIO12_SetValue (uint8_t pin_no, GPIO_PIN_OUTPUT_STATE value) -{ - return GPIO_SetValue (&GPIO12_RES, pin_no, value); -} - -static int32_t ARM_GPIO12_GetValue (uint8_t pin_no, uint32_t *value) -{ - return GPIO_GetValue (&GPIO12_RES, pin_no, value); -} - -static int32_t ARM_GPIO12_Control (uint8_t pin_no, GPIO_OPERATION control_code, uint32_t *arg) -{ - return GPIO_Control (&GPIO12_RES, pin_no, control_code, arg); -} - -static int32_t ARM_GPIO12_Uninitialize (uint8_t pin_no) -{ - return GPIO_Uninitialize (&GPIO12_RES, pin_no); -} - -extern ARM_DRIVER_GPIO Driver_GPIO12; -ARM_DRIVER_GPIO Driver_GPIO12 = { - ARM_GPIO12_Initialize, - ARM_GPIO12_PowerControl, - ARM_GPIO12_SetDirection, - ARM_GPIO12_GetDirection, - ARM_GPIO12_SetValue, - ARM_GPIO12_GetValue, - ARM_GPIO12_Control, - ARM_GPIO12_Uninitialize -}; -#endif /* RTE_GPIO12 */ - - -/***/ -#if RTE_GPIO13 -static GPIO_RESOURCES GPIO13_RES = { - .reg_base = (GPIO_Type*) GPIO13_BASE, - .IRQ_base_num = GPIO13_IRQ0_IRQn, - .gpio_id = GPIO13_INSTANCE, - .db_clkdiv = RTE_GPIO13_DB_CLK_DIV, - .IRQ_priority = { - RTE_GPIO13_PIN0_IRQ_PRIORITY, - RTE_GPIO13_PIN1_IRQ_PRIORITY, - RTE_GPIO13_PIN2_IRQ_PRIORITY, - RTE_GPIO13_PIN3_IRQ_PRIORITY, - RTE_GPIO13_PIN4_IRQ_PRIORITY, - RTE_GPIO13_PIN5_IRQ_PRIORITY, - RTE_GPIO13_PIN6_IRQ_PRIORITY, - RTE_GPIO13_PIN7_IRQ_PRIORITY, + else if (trigger == ARM_GPIO_TRIGGER_EITHER_EDGE) { + /* Either rising or falling edge triggers interrupt */ + gpio_interrupt_set_both_edge_trigger(gpio, pin_num); } -}; - -void GPIO13_IRQ0Handler (void) { GPIO_IRQ_Handler (&GPIO13_RES, 0); } - -void GPIO13_IRQ1Handler (void) { GPIO_IRQ_Handler (&GPIO13_RES, 1); } - -void GPIO13_IRQ2Handler (void) { GPIO_IRQ_Handler (&GPIO13_RES, 2); } - -void GPIO13_IRQ3Handler (void) { GPIO_IRQ_Handler (&GPIO13_RES, 3); } - -void GPIO13_IRQ4Handler (void) { GPIO_IRQ_Handler (&GPIO13_RES, 4); } - -void GPIO13_IRQ5Handler (void) { GPIO_IRQ_Handler (&GPIO13_RES, 5); } - -void GPIO13_IRQ6Handler (void) { GPIO_IRQ_Handler (&GPIO13_RES, 6); } - -void GPIO13_IRQ7Handler (void) { GPIO_IRQ_Handler (&GPIO13_RES, 7); } - -static int32_t ARM_GPIO13_Initialize (uint8_t pin_no, ARM_GPIO_SignalEvent_t cb_event) -{ - return GPIO_Initialize (&GPIO13_RES, cb_event, pin_no); -} - -static int32_t ARM_GPIO13_PowerControl (uint8_t pin_no, ARM_POWER_STATE state) -{ - return GPIO_PowerControl (&GPIO13_RES, pin_no, state); -} - -static int32_t ARM_GPIO13_SetDirection (uint8_t pin_no, GPIO_PIN_DIRECTION dir) -{ - return GPIO_SetDirection (&GPIO13_RES, pin_no, dir); -} - -static int32_t ARM_GPIO13_GetDirection (uint8_t pin_no, uint32_t *dir) -{ - return GPIO_GetDirection (&GPIO13_RES, pin_no, dir); -} - -static int32_t ARM_GPIO13_SetValue (uint8_t pin_no, GPIO_PIN_OUTPUT_STATE value) -{ - return GPIO_SetValue (&GPIO13_RES, pin_no, value); -} - -static int32_t ARM_GPIO13_GetValue (uint8_t pin_no, uint32_t *value) -{ - return GPIO_GetValue (&GPIO13_RES, pin_no, value); -} - -static int32_t ARM_GPIO13_Control (uint8_t pin_no, GPIO_OPERATION control_code, uint32_t *arg) -{ - return GPIO_Control (&GPIO13_RES, pin_no, control_code, arg); -} - -static int32_t ARM_GPIO13_Uninitialize (uint8_t pin_no) -{ - return GPIO_Uninitialize (&GPIO13_RES, pin_no); -} - -extern ARM_DRIVER_GPIO Driver_GPIO13; -ARM_DRIVER_GPIO Driver_GPIO13 = { - ARM_GPIO13_Initialize, - ARM_GPIO13_PowerControl, - ARM_GPIO13_SetDirection, - ARM_GPIO13_GetDirection, - ARM_GPIO13_SetValue, - ARM_GPIO13_GetValue, - ARM_GPIO13_Control, - ARM_GPIO13_Uninitialize -}; -#endif /* RTE_GPIO13 */ - - -/***/ -#if RTE_GPIO14 -static GPIO_RESOURCES GPIO14_RES = { - .reg_base = (GPIO_Type*) GPIO14_BASE, - .IRQ_base_num = GPIO14_IRQ0_IRQn, - .gpio_id = GPIO14_INSTANCE, - .db_clkdiv = RTE_GPIO14_DB_CLK_DIV, - .IRQ_priority = { - RTE_GPIO14_PIN0_IRQ_PRIORITY, - RTE_GPIO14_PIN1_IRQ_PRIORITY, - RTE_GPIO14_PIN2_IRQ_PRIORITY, - RTE_GPIO14_PIN3_IRQ_PRIORITY, - RTE_GPIO14_PIN4_IRQ_PRIORITY, - RTE_GPIO14_PIN5_IRQ_PRIORITY, - RTE_GPIO14_PIN6_IRQ_PRIORITY, - RTE_GPIO14_PIN7_IRQ_PRIORITY, + else { + status = ARM_DRIVER_ERROR_PARAMETER; } -}; - -void GPIO14_IRQ0Handler (void) { GPIO_IRQ_Handler (&GPIO14_RES, 0); } - -void GPIO14_IRQ1Handler (void) { GPIO_IRQ_Handler (&GPIO14_RES, 1); } - -void GPIO14_IRQ2Handler (void) { GPIO_IRQ_Handler (&GPIO14_RES, 2); } - -void GPIO14_IRQ3Handler (void) { GPIO_IRQ_Handler (&GPIO14_RES, 3); } + } -void GPIO14_IRQ4Handler (void) { GPIO_IRQ_Handler (&GPIO14_RES, 4); } - -void GPIO14_IRQ5Handler (void) { GPIO_IRQ_Handler (&GPIO14_RES, 5); } - -void GPIO14_IRQ6Handler (void) { GPIO_IRQ_Handler (&GPIO14_RES, 6); } - -void GPIO14_IRQ7Handler (void) { GPIO_IRQ_Handler (&GPIO14_RES, 7); } - -static int32_t ARM_GPIO14_Initialize (uint8_t pin_no, ARM_GPIO_SignalEvent_t cb_event) -{ - return GPIO_Initialize (&GPIO14_RES, cb_event, pin_no); + return status; } -static int32_t ARM_GPIO14_PowerControl (uint8_t pin_no, ARM_POWER_STATE state) -{ - return GPIO_PowerControl (&GPIO14_RES, pin_no, state); -} +// Set GPIO Output Level +static void GPIO_SetOutput (ARM_GPIO_Pin_t pin, uint32_t val) { + GPIO_Type *gpio; + uint32_t gpio_num; + uint32_t pin_num; -static int32_t ARM_GPIO14_SetDirection (uint8_t pin_no, GPIO_PIN_DIRECTION dir) -{ - return GPIO_SetDirection (&GPIO14_RES, pin_no, dir); -} + if (pin < GPIO_MAX_PINS) { + gpio_num = pin >> 3U; + pin_num = pin & 0x7U; -static int32_t ARM_GPIO14_GetDirection (uint8_t pin_no, uint32_t *dir) -{ - return GPIO_GetDirection (&GPIO14_RES, pin_no, dir); -} + gpio = (GPIO_Type *)GPIO_Base[gpio_num]; -static int32_t ARM_GPIO14_SetValue (uint8_t pin_no, GPIO_PIN_OUTPUT_STATE value) -{ - return GPIO_SetValue (&GPIO14_RES, pin_no, value); -} - -static int32_t ARM_GPIO14_GetValue (uint8_t pin_no, uint32_t *value) -{ - return GPIO_GetValue (&GPIO14_RES, pin_no, value); -} - -static int32_t ARM_GPIO14_Control (uint8_t pin_no, GPIO_OPERATION control_code, uint32_t *arg) -{ - return GPIO_Control (&GPIO14_RES, pin_no, control_code, arg); -} - -static int32_t ARM_GPIO14_Uninitialize (uint8_t pin_no) -{ - return GPIO_Uninitialize (&GPIO14_RES, pin_no); -} - -extern ARM_DRIVER_GPIO Driver_GPIO14; -ARM_DRIVER_GPIO Driver_GPIO14 = { - ARM_GPIO14_Initialize, - ARM_GPIO14_PowerControl, - ARM_GPIO14_SetDirection, - ARM_GPIO14_GetDirection, - ARM_GPIO14_SetValue, - ARM_GPIO14_GetValue, - ARM_GPIO14_Control, - ARM_GPIO14_Uninitialize -}; -#endif /* RTE_GPIO14 */ - - -/**< Low Power GPIO >*/ -#if RTE_LPGPIO -static GPIO_RESOURCES LPGPIO_RES = { - .reg_base = (GPIO_Type*) LPGPIO_BASE, - .gpio_id = LPGPIO_INSTANCE, - .IRQ_base_num = LPGPIO_IRQ0_IRQn, - .IRQ_priority = { - RTE_LPGPIO_PIN0_IRQ_PRIORITY, - RTE_LPGPIO_PIN1_IRQ_PRIORITY, - RTE_LPGPIO_PIN2_IRQ_PRIORITY, - RTE_LPGPIO_PIN3_IRQ_PRIORITY, - RTE_LPGPIO_PIN4_IRQ_PRIORITY, - RTE_LPGPIO_PIN5_IRQ_PRIORITY, - RTE_LPGPIO_PIN6_IRQ_PRIORITY, - RTE_LPGPIO_PIN7_IRQ_PRIORITY, + if (val == 0U) { + gpio_set_value_low(gpio, pin_num); + } else { + gpio_set_value_high(gpio, pin_num); } -}; -void LPGPIO_IRQ0Handler (void) { GPIO_IRQ_Handler (&LPGPIO_RES, 0); } - -void LPGPIO_IRQ1Handler (void) { GPIO_IRQ_Handler (&LPGPIO_RES, 1); } - -void LPGPIO_IRQ2Handler (void) { GPIO_IRQ_Handler (&LPGPIO_RES, 2); } - -void LPGPIO_IRQ3Handler (void) { GPIO_IRQ_Handler (&LPGPIO_RES, 3); } - -void LPGPIO_IRQ4Handler (void) { GPIO_IRQ_Handler (&LPGPIO_RES, 4); } - -void LPGPIO_IRQ5Handler (void) { GPIO_IRQ_Handler (&LPGPIO_RES, 5); } - -void LPGPIO_IRQ6Handler (void) { GPIO_IRQ_Handler (&LPGPIO_RES, 6); } - -void LPGPIO_IRQ7Handler (void) { GPIO_IRQ_Handler (&LPGPIO_RES, 7); } - -static int32_t ARM_LPGPIO_Initialize (uint8_t pin_no, ARM_GPIO_SignalEvent_t cb_event) -{ - return GPIO_Initialize (&LPGPIO_RES, cb_event, pin_no); -} - -static int32_t ARM_LPGPIO_PowerControl (uint8_t pin_no, ARM_POWER_STATE state) -{ - return GPIO_PowerControl (&LPGPIO_RES, pin_no, state); -} - -static int32_t ARM_LPGPIO_SetDirection (uint8_t pin_no, GPIO_PIN_DIRECTION dir) -{ - return GPIO_SetDirection (&LPGPIO_RES, pin_no, dir); + } } -static int32_t ARM_LPGPIO_GetDirection (uint8_t pin_no, uint32_t *dir) -{ - return GPIO_GetDirection (&LPGPIO_RES, pin_no, dir); -} +// Get GPIO Input Level +static uint32_t GPIO_GetInput (ARM_GPIO_Pin_t pin) { + GPIO_Type *gpio; + uint32_t gpio_num; + uint32_t pin_num; + uint32_t val; -static int32_t ARM_LPGPIO_SetValue (uint8_t pin_no, GPIO_PIN_OUTPUT_STATE value) -{ - return GPIO_SetValue (&LPGPIO_RES, pin_no, value); -} + if (pin >= GPIO_MAX_PINS) { + val = 0U; + } + else { + gpio_num = pin >> 3U; + pin_num = pin & 0x7U; -static int32_t ARM_LPGPIO_GetValue (uint8_t pin_no, uint32_t *value) -{ - return GPIO_GetValue (&LPGPIO_RES, pin_no, value); -} + gpio = (GPIO_Type *)GPIO_Base[gpio_num]; -static int32_t ARM_LPGPIO_Control (uint8_t pin_no, GPIO_OPERATION control_code, uint32_t *arg) -{ - return GPIO_Control (&LPGPIO_RES, pin_no, control_code, arg); -} + val = gpio_get_value(gpio, pin_num); + } -static int32_t ARM_LPGPIO_Uninitialize (uint8_t pin_no) -{ - return GPIO_Uninitialize (&LPGPIO_RES, pin_no); + return val; } -extern ARM_DRIVER_GPIO Driver_GPIOLP; -ARM_DRIVER_GPIO Driver_GPIOLP = { - ARM_LPGPIO_Initialize, - ARM_LPGPIO_PowerControl, - ARM_LPGPIO_SetDirection, - ARM_LPGPIO_GetDirection, - ARM_LPGPIO_SetValue, - ARM_LPGPIO_GetValue, - ARM_LPGPIO_Control, - ARM_LPGPIO_Uninitialize -}; - -/* ---------- LPGPIO instance name Aliases ---------- */ -extern ARM_DRIVER_GPIO __attribute__((alias("Driver_GPIOLP"))) Driver_GPIO15; -#endif /* RTE_LPGPIO */ -/************************ (C) COPYRIGHT ALIF SEMICONDUCTOR *****END OF FILE****/ +// GPIO Driver access structure +ARM_DRIVER_GPIO Driver_GPIO0 = { + GPIO_Setup, + GPIO_SetDirection, + GPIO_SetOutputMode, + GPIO_SetPullResistor, + GPIO_SetEventTrigger, + GPIO_SetOutput, + GPIO_GetInput +}; \ No newline at end of file diff --git a/Alif_CMSIS/Source/Driver_GPIO_Private.h b/Alif_CMSIS/Source/Driver_GPIO_Private.h index dd5eb9f..035e7e8 100644 --- a/Alif_CMSIS/Source/Driver_GPIO_Private.h +++ b/Alif_CMSIS/Source/Driver_GPIO_Private.h @@ -1,101 +1,207 @@ -/* Copyright (C) 2023 Alif Semiconductor - All Rights Reserved. - * Use, distribution and modification of this code is permitted under the - * terms stated in the Alif Semiconductor Software License Agreement +/* + * Copyright (c) 2024 ARM Limited. All rights reserved. * - * You should have received a copy of the Alif Semiconductor Software - * License Agreement with this file. If not, please write to: - * contact@alifsemi.com, or visit: https://alifsemi.com/license + * SPDX-License-Identifier: Apache-2.0 * + * Licensed under the Apache License, Version 2.0 (the License); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * $Date: 16. July 2024 + * $Revision: V1.0 + * + * Project: GPIO Driver for Alif Semiconductor Ensemble */ -/**************************************************************************//** - * @file Driver_GPIO_Private.h - * @author Girish BN, Manoj A Murudi - * @email girish.bn@alifsemi.com, manoj.murudi@alifsemi.com - * @version V1.0.0 - * @date 29-March-2023 - * @brief Header file for GPIO. - * @bug None. - * @Note None - ******************************************************************************/ - #ifndef DRIVER_GPIO_PRIVATE_H_ - #define DRIVER_GPIO_PRIVATE_H_ -#ifdef __cplusplus -extern "C" -{ -#endif - -#include "RTE_Device.h" #include "RTE_Components.h" #include CMSIS_device_header #include "Driver_GPIO.h" -#include "gpio.h" -#define GPIO_PORT_MAX_PIN_NUMBER 0x8U /* Number of pins in each port */ - -#define ARM_GPIO_BIT_IRQ_POLARITY_Pos 0U ///< bits - 0 -#define ARM_GPIO_BIT_IRQ_POLARITY_Msk (1U << ARM_GPIO_BIT_IRQ_POLARITY_Pos) -#define ARM_GPIO_BIT_IRQ_POLARITY(x) (((x)& ARM_GPIO_BIT_IRQ_POLARITY_Msk) >> ARM_GPIO_BIT_IRQ_POLARITY_Pos) - -#define ARM_GPIO_BIT_IRQ_BOTH_EDGE_Pos 1U ///< bits - 1 -#define ARM_GPIO_BIT_IRQ_BOTH_EDGE_Msk (1U << ARM_GPIO_BIT_IRQ_BOTH_EDGE_Pos) -#define ARM_GPIO_BIT_IRQ_BOTH_EDGE(x) (((x)& ARM_GPIO_BIT_IRQ_BOTH_EDGE_Msk) >> ARM_GPIO_BIT_IRQ_BOTH_EDGE_Pos) - -#define ARM_GPIO_BIT_IRQ_SENSITIVE_Pos 2U ///< bits - 2 -#define ARM_GPIO_BIT_IRQ_SENSITIVE_Msk (1U << ARM_GPIO_BIT_IRQ_SENSITIVE_Pos) -#define ARM_GPIO_BIT_IRQ_SENSITIVE(x) (((x)& ARM_GPIO_BIT_IRQ_SENSITIVE_Msk) >> ARM_GPIO_BIT_IRQ_SENSITIVE_Pos) - -/** - * enum GPIO_INSTANCE. - * GPIO instances. - */ -typedef enum _GPIO_INSTANCE +#ifdef __cplusplus +extern "C" { - GPIO0_INSTANCE, - GPIO1_INSTANCE, - GPIO2_INSTANCE, - GPIO3_INSTANCE, - GPIO4_INSTANCE, - GPIO5_INSTANCE, - GPIO6_INSTANCE, - GPIO7_INSTANCE, - GPIO8_INSTANCE, - GPIO9_INSTANCE, - GPIO10_INSTANCE, - GPIO11_INSTANCE, - GPIO12_INSTANCE, - GPIO13_INSTANCE, - GPIO14_INSTANCE, - LPGPIO_INSTANCE -} GPIO_INSTANCE; - -typedef struct _GPIO_DRV_STATE { - uint32_t initialized : 1; /* Driver Initialized*/ - uint32_t powered : 1; /* Driver powered */ - uint32_t reserved : 30;/* Reserved */ -} GPIO_DRV_STATE; - -/** - * @brief GPIO Resources - */ -typedef struct _GPIO_RESOURCES { - GPIO_Type *reg_base; /**< GPIO PORT Base Address>**/ - IRQn_Type IRQ_base_num; /**< GPIO PORT IRQ base Num>**/ - uint16_t db_clkdiv; /**< GPIO PORT debounce clk divisor: only for GPIO 0-14 >**/ - GPIO_DRV_STATE state; /**< GPIO PORT status flag >**/ - uint8_t IRQ_priority[GPIO_PORT_MAX_PIN_NUMBER]; /**< GPIO PIN IRQ priority >**/ - GPIO_INSTANCE gpio_id; /**< GPIO instance >*/ - ARM_GPIO_SignalEvent_t cb_event[GPIO_PORT_MAX_PIN_NUMBER]; /**< GPIO Call back function >*/ -} GPIO_RESOURCES; +#endif + +// Pin mapping +#define GPIO_PIN(port, pin) ((8U * port) + (pin)) + +#define GPIO_P0(n) ( 0U + (n)) +#define GPIO_P1(n) ( 8U + (n)) +#define GPIO_P2(n) ( 16U + (n)) +#define GPIO_P3(n) ( 24U + (n)) +#define GPIO_P4(n) ( 32U + (n)) +#define GPIO_P5(n) ( 40U + (n)) +#define GPIO_P7(n) ( 48U + (n)) +#define GPIO_P8(n) ( 56U + (n)) +#define GPIO_P9(n) ( 64U + (n)) +#define GPIO_P10(n) ( 72U + (n)) +#define GPIO_P11(n) ( 80U + (n)) +#define GPIO_P12(n) ( 88U + (n)) +#define GPIO_P13(n) (104U + (n)) +#define GPIO_P15(n) (112U + (n)) + +// GPIOx IRQ Handlers +extern void GPIO0_IRQ0Handler (void); +extern void GPIO0_IRQ1Handler (void); +extern void GPIO0_IRQ2Handler (void); +extern void GPIO0_IRQ3Handler (void); +extern void GPIO0_IRQ4Handler (void); +extern void GPIO0_IRQ5Handler (void); +extern void GPIO0_IRQ6Handler (void); +extern void GPIO0_IRQ7Handler (void); + +extern void GPIO1_IRQ0Handler (void); +extern void GPIO1_IRQ1Handler (void); +extern void GPIO1_IRQ2Handler (void); +extern void GPIO1_IRQ3Handler (void); +extern void GPIO1_IRQ4Handler (void); +extern void GPIO1_IRQ5Handler (void); +extern void GPIO1_IRQ6Handler (void); +extern void GPIO1_IRQ7Handler (void); + +extern void GPIO2_IRQ0Handler (void); +extern void GPIO2_IRQ1Handler (void); +extern void GPIO2_IRQ2Handler (void); +extern void GPIO2_IRQ3Handler (void); +extern void GPIO2_IRQ4Handler (void); +extern void GPIO2_IRQ5Handler (void); +extern void GPIO2_IRQ6Handler (void); +extern void GPIO2_IRQ7Handler (void); + +extern void GPIO3_IRQ0Handler (void); +extern void GPIO3_IRQ1Handler (void); +extern void GPIO3_IRQ2Handler (void); +extern void GPIO3_IRQ3Handler (void); +extern void GPIO3_IRQ4Handler (void); +extern void GPIO3_IRQ5Handler (void); +extern void GPIO3_IRQ6Handler (void); +extern void GPIO3_IRQ7Handler (void); + +extern void GPIO4_IRQ0Handler (void); +extern void GPIO4_IRQ1Handler (void); +extern void GPIO4_IRQ2Handler (void); +extern void GPIO4_IRQ3Handler (void); +extern void GPIO4_IRQ4Handler (void); +extern void GPIO4_IRQ5Handler (void); +extern void GPIO4_IRQ6Handler (void); +extern void GPIO4_IRQ7Handler (void); + +extern void GPIO5_IRQ0Handler (void); +extern void GPIO5_IRQ1Handler (void); +extern void GPIO5_IRQ2Handler (void); +extern void GPIO5_IRQ3Handler (void); +extern void GPIO5_IRQ4Handler (void); +extern void GPIO5_IRQ5Handler (void); +extern void GPIO5_IRQ6Handler (void); +extern void GPIO5_IRQ7Handler (void); + +extern void GPIO6_IRQ0Handler (void); +extern void GPIO6_IRQ1Handler (void); +extern void GPIO6_IRQ2Handler (void); +extern void GPIO6_IRQ3Handler (void); +extern void GPIO6_IRQ4Handler (void); +extern void GPIO6_IRQ5Handler (void); +extern void GPIO6_IRQ6Handler (void); +extern void GPIO6_IRQ7Handler (void); + +extern void GPIO7_IRQ0Handler (void); +extern void GPIO7_IRQ1Handler (void); +extern void GPIO7_IRQ2Handler (void); +extern void GPIO7_IRQ3Handler (void); +extern void GPIO7_IRQ4Handler (void); +extern void GPIO7_IRQ5Handler (void); +extern void GPIO7_IRQ6Handler (void); +extern void GPIO7_IRQ7Handler (void); + +extern void GPIO8_IRQ0Handler (void); +extern void GPIO8_IRQ1Handler (void); +extern void GPIO8_IRQ2Handler (void); +extern void GPIO8_IRQ3Handler (void); +extern void GPIO8_IRQ4Handler (void); +extern void GPIO8_IRQ5Handler (void); +extern void GPIO8_IRQ6Handler (void); +extern void GPIO8_IRQ7Handler (void); + +extern void GPIO9_IRQ0Handler (void); +extern void GPIO9_IRQ1Handler (void); +extern void GPIO9_IRQ2Handler (void); +extern void GPIO9_IRQ3Handler (void); +extern void GPIO9_IRQ4Handler (void); +extern void GPIO9_IRQ5Handler (void); +extern void GPIO9_IRQ6Handler (void); +extern void GPIO9_IRQ7Handler (void); + +extern void GPIO10_IRQ0Handler (void); +extern void GPIO10_IRQ1Handler (void); +extern void GPIO10_IRQ2Handler (void); +extern void GPIO10_IRQ3Handler (void); +extern void GPIO10_IRQ4Handler (void); +extern void GPIO10_IRQ5Handler (void); +extern void GPIO10_IRQ6Handler (void); +extern void GPIO10_IRQ7Handler (void); + +extern void GPIO11_IRQ0Handler (void); +extern void GPIO11_IRQ1Handler (void); +extern void GPIO11_IRQ2Handler (void); +extern void GPIO11_IRQ3Handler (void); +extern void GPIO11_IRQ4Handler (void); +extern void GPIO11_IRQ5Handler (void); +extern void GPIO11_IRQ6Handler (void); +extern void GPIO11_IRQ7Handler (void); + +extern void GPIO12_IRQ0Handler (void); +extern void GPIO12_IRQ1Handler (void); +extern void GPIO12_IRQ2Handler (void); +extern void GPIO12_IRQ3Handler (void); +extern void GPIO12_IRQ4Handler (void); +extern void GPIO12_IRQ5Handler (void); +extern void GPIO12_IRQ6Handler (void); +extern void GPIO12_IRQ7Handler (void); + +extern void GPIO13_IRQ0Handler (void); +extern void GPIO13_IRQ1Handler (void); +extern void GPIO13_IRQ2Handler (void); +extern void GPIO13_IRQ3Handler (void); +extern void GPIO13_IRQ4Handler (void); +extern void GPIO13_IRQ5Handler (void); +extern void GPIO13_IRQ6Handler (void); +extern void GPIO13_IRQ7Handler (void); + +extern void GPIO14_IRQ0Handler (void); +extern void GPIO14_IRQ1Handler (void); +extern void GPIO14_IRQ2Handler (void); +extern void GPIO14_IRQ3Handler (void); +extern void GPIO14_IRQ4Handler (void); +extern void GPIO14_IRQ5Handler (void); +extern void GPIO14_IRQ6Handler (void); +extern void GPIO14_IRQ7Handler (void); + +extern void LPGPIO_IRQ0Handler (void); +extern void LPGPIO_IRQ1Handler (void); +extern void LPGPIO_IRQ2Handler (void); +extern void LPGPIO_IRQ3Handler (void); +extern void LPGPIO_IRQ4Handler (void); +extern void LPGPIO_IRQ5Handler (void); +extern void LPGPIO_IRQ6Handler (void); +extern void LPGPIO_IRQ7Handler (void); + +// GPIO0 Driver access structure +extern ARM_DRIVER_GPIO Driver_GPIO0; #ifdef __cplusplus } #endif #endif /* DRIVER_GPIO_PRIVATE_H_ */ - -/************************ (C) COPYRIGHT ALIF SEMICONDUCTOR *****END OF FILE****/