mirror of
https://github.com/openmv/openmv.git
synced 2025-11-04 14:49:50 +08:00
1942 lines
55 KiB
C
1942 lines
55 KiB
C
/* 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
|
|
*
|
|
* 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.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);
|
|
}
|
|
}
|
|
|
|
/**<GPIO Instance 0>*/
|
|
#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 */
|
|
|
|
|
|
/**<GPIO Instance 1>*/
|
|
#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 */
|
|
|
|
|
|
/**<GPIO Instance 2>*/
|
|
#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 */
|
|
|
|
|
|
/**<GPIO Instance 3>*/
|
|
#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);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
static int32_t ARM_GPIO3_GetValue (uint8_t pin_no, uint32_t *value)
|
|
{
|
|
return GPIO_GetValue (&GPIO3_RES, pin_no, value);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
static int32_t ARM_GPIO3_Uninitialize (uint8_t pin_no)
|
|
{
|
|
return GPIO_Uninitialize (&GPIO3_RES, pin_no);
|
|
}
|
|
|
|
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 */
|
|
|
|
|
|
/**<GPIO Instance 4>*/
|
|
#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,
|
|
}
|
|
};
|
|
|
|
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 */
|
|
|
|
|
|
/**<GPIO Instance 5>*/
|
|
#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,
|
|
}
|
|
};
|
|
|
|
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 */
|
|
|
|
|
|
/**<GPIO Instance 6>*/
|
|
#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,
|
|
}
|
|
};
|
|
|
|
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);
|
|
}
|
|
|
|
static int32_t ARM_GPIO6_GetDirection (uint8_t pin_no, uint32_t *dir)
|
|
{
|
|
return GPIO_GetDirection (&GPIO6_RES, pin_no, dir);
|
|
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
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 */
|
|
|
|
|
|
/**<GPIO Instance 7>*/
|
|
#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,
|
|
}
|
|
};
|
|
|
|
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);
|
|
}
|
|
|
|
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 */
|
|
|
|
|
|
/**<GPIO Instance 8>*/
|
|
#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,
|
|
}
|
|
};
|
|
|
|
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 */
|
|
|
|
|
|
/**<GPIO Instance 9>*/
|
|
#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,
|
|
}
|
|
};
|
|
|
|
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);
|
|
}
|
|
|
|
static int32_t ARM_GPIO9_SetDirection (uint8_t pin_no, GPIO_PIN_DIRECTION dir)
|
|
{
|
|
return GPIO_SetDirection (&GPIO9_RES, pin_no, dir);
|
|
}
|
|
|
|
static int32_t ARM_GPIO9_GetDirection (uint8_t pin_no, uint32_t *dir)
|
|
{
|
|
return GPIO_GetDirection (&GPIO9_RES, pin_no, dir);
|
|
}
|
|
|
|
static int32_t ARM_GPIO9_SetValue (uint8_t pin_no, GPIO_PIN_OUTPUT_STATE value)
|
|
{
|
|
return GPIO_SetValue (&GPIO9_RES, pin_no, value);
|
|
}
|
|
|
|
static int32_t ARM_GPIO9_GetValue (uint8_t pin_no, uint32_t *value)
|
|
{
|
|
return GPIO_GetValue (&GPIO9_RES, pin_no, value);
|
|
}
|
|
|
|
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 */
|
|
|
|
|
|
/**<GPIO Instance 10>*/
|
|
#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,
|
|
}
|
|
};
|
|
|
|
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 */
|
|
|
|
|
|
/**<GPIO Instance 11>*/
|
|
#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,
|
|
}
|
|
};
|
|
|
|
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 */
|
|
|
|
|
|
/**<GPIO Instance 12>*/
|
|
#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,
|
|
}
|
|
};
|
|
|
|
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 */
|
|
|
|
|
|
/**<GPIO Instance 13>*/
|
|
#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,
|
|
}
|
|
};
|
|
|
|
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 */
|
|
|
|
|
|
/**<GPIO Instance 14>*/
|
|
#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,
|
|
}
|
|
};
|
|
|
|
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);
|
|
}
|
|
|
|
static int32_t ARM_GPIO14_PowerControl (uint8_t pin_no, ARM_POWER_STATE state)
|
|
{
|
|
return GPIO_PowerControl (&GPIO14_RES, pin_no, state);
|
|
}
|
|
|
|
static int32_t ARM_GPIO14_SetDirection (uint8_t pin_no, GPIO_PIN_DIRECTION dir)
|
|
{
|
|
return GPIO_SetDirection (&GPIO14_RES, pin_no, dir);
|
|
}
|
|
|
|
static int32_t ARM_GPIO14_GetDirection (uint8_t pin_no, uint32_t *dir)
|
|
{
|
|
return GPIO_GetDirection (&GPIO14_RES, pin_no, dir);
|
|
}
|
|
|
|
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,
|
|
}
|
|
};
|
|
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);
|
|
}
|
|
|
|
static int32_t ARM_LPGPIO_SetValue (uint8_t pin_no, GPIO_PIN_OUTPUT_STATE value)
|
|
{
|
|
return GPIO_SetValue (&LPGPIO_RES, pin_no, value);
|
|
}
|
|
|
|
static int32_t ARM_LPGPIO_GetValue (uint8_t pin_no, uint32_t *value)
|
|
{
|
|
return GPIO_GetValue (&LPGPIO_RES, pin_no, value);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
static int32_t ARM_LPGPIO_Uninitialize (uint8_t pin_no)
|
|
{
|
|
return GPIO_Uninitialize (&LPGPIO_RES, pin_no);
|
|
}
|
|
|
|
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****/
|