diff --git a/drivers/pinctrl/CMakeLists.txt b/drivers/pinctrl/CMakeLists.txt index 656fc5f27d1..521f1e61c19 100644 --- a/drivers/pinctrl/CMakeLists.txt +++ b/drivers/pinctrl/CMakeLists.txt @@ -32,3 +32,4 @@ zephyr_library_sources_ifdef(CONFIG_PINCTRL_GECKO pinctrl_gecko.c) zephyr_library_sources_ifdef(CONFIG_PINCTRL_TI_K3 pinctrl_ti_k3.c) zephyr_library_sources_ifdef(CONFIG_PINCTRL_EMSDP pinctrl_emsdp.c) zephyr_library_sources_ifdef(CONFIG_PINCTRL_TI_CC32XX pinctrl_ti_cc32xx.c) +zephyr_library_sources_ifdef(CONFIG_PINCTRL_NUMAKER pinctrl_numaker.c) diff --git a/drivers/pinctrl/Kconfig b/drivers/pinctrl/Kconfig index b16821edff8..80551869d59 100644 --- a/drivers/pinctrl/Kconfig +++ b/drivers/pinctrl/Kconfig @@ -61,5 +61,6 @@ source "drivers/pinctrl/Kconfig.gecko" source "drivers/pinctrl/Kconfig.ti_k3" source "drivers/pinctrl/Kconfig.emsdp" source "drivers/pinctrl/Kconfig.ti_cc32xx" +source "drivers/pinctrl/Kconfig.numaker" endif # PINCTRL diff --git a/drivers/pinctrl/Kconfig.numaker b/drivers/pinctrl/Kconfig.numaker new file mode 100644 index 00000000000..ba4960ed2e2 --- /dev/null +++ b/drivers/pinctrl/Kconfig.numaker @@ -0,0 +1,11 @@ +# Nuvoton NuMaker Pin Controller configuration options + +# Copyright (c) 2023 Nuvoton Technology Corporation. +# SPDX-License-Identifier: Apache-2.0 + +config PINCTRL_NUMAKER + bool "Nuvoton NuMaker pin controller driver" + default y + depends on DT_HAS_NUVOTON_NUMAKER_PINCTRL_ENABLED + help + This option enables the pin controller driver for Nuvoton NuMaker MCUs. diff --git a/drivers/pinctrl/pinctrl_numaker.c b/drivers/pinctrl/pinctrl_numaker.c new file mode 100644 index 00000000000..2799e0a43c1 --- /dev/null +++ b/drivers/pinctrl/pinctrl_numaker.c @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2023 Nuvoton Technology Corporation. + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#define DT_DRV_COMPAT nuvoton_numaker_pinctrl + +#include +#include + +/** + * Configure pin multi-function + */ +static void configure_pin(const pinctrl_soc_pin_t *pin) +{ + uint32_t pin_mux = pin->pin_mux; + uint32_t pin_index = PIN_INDEX(pin_mux); + uint32_t port_index = PORT_INDEX(pin_mux); + uint32_t mfp_cfg = MFP_CFG(pin_mux); + + /* Get mfp_base, it should be == (&SYS->GPA_MFP0) in M467 */ + uint32_t mfp_base = DT_REG_ADDR(DT_NODELABEL(pinctrl)); + + uint32_t *GPx_MFPx = ((uint32_t *)mfp_base) + port_index * 4 + (pin_index / 4); + uint32_t pinMask = NU_MFP_MASK(pin_index); + + /* + * E.g.: SYS->GPA_MFP0 = (SYS->GPA_MFP0 & (~SYS_GPA_MFP0_PA0MFP_Msk) ) | + * SYS_GPA_MFP0_PA0MFP_SC0_CD; + */ + *GPx_MFPx = (*GPx_MFPx & (~pinMask)) | mfp_cfg; +} + +/* Pinctrl API implementation */ +int pinctrl_configure_pins(const pinctrl_soc_pin_t *pins, uint8_t pin_cnt, uintptr_t reg) +{ + ARG_UNUSED(reg); + + /* Configure all peripheral devices' properties here. */ + for (uint8_t i = 0U; i < pin_cnt; i++) { + configure_pin(&pins[i]); + } + + return 0; +} diff --git a/dts/arm/nuvoton/m46x.dtsi b/dts/arm/nuvoton/m46x.dtsi index c87995e43de..e06344fb7ac 100644 --- a/dts/arm/nuvoton/m46x.dtsi +++ b/dts/arm/nuvoton/m46x.dtsi @@ -6,6 +6,7 @@ #include #include +#include / { cpus { @@ -36,6 +37,14 @@ clock-frequency = <200000000>; #clock-cells = <0>; }; + + soc { + pinctrl: pin-controller@40000500 { + compatible = "nuvoton,numaker-pinctrl"; + reg = <0x40000500 0xa0>; + status = "okay"; + }; + }; }; &nvic { diff --git a/dts/bindings/pinctrl/nuvoton,numaker-pinctrl.yaml b/dts/bindings/pinctrl/nuvoton,numaker-pinctrl.yaml new file mode 100644 index 00000000000..1e2d4f631d0 --- /dev/null +++ b/dts/bindings/pinctrl/nuvoton,numaker-pinctrl.yaml @@ -0,0 +1,80 @@ +# Copyright (c) Nuvoton Technology Corp. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +description: | + Pin controller is responsible for controlling pin function + selection and pin properties. For example, for example you can + use this node to set UART0 RX as pin PB12 to fulfill SYS_GPB_MFP3_PB12MFP_UART0_RXD. + + The node has the 'pinctrl' node label set in your SoC's devicetree, + so you can modify it like this: + + &pinctrl { + /* your modifications go here */ + }; + + All device pin configurations should be placed in child nodes of the + 'pinctrl' node, as shown in this example: + + &pinctrl { + /* configuration for the uart0 "default" state */ + uart0_default: uart0_default { + /* configure PB13 as UART0 TX and PB12 as UART0 RX */ + pinmux = , ; + }; + }; + + + To link pin configurations with a device, use a pinctrl-N property for some + number N, like this example you could place in your board's DTS file: + + #include "board-pinctrl.dtsi" + + &uart0 { + pinctrl-0 = <&uart0_default>; + pinctrl-names = "default"; + }; + +compatible: "nuvoton,numaker-pinctrl" + +include: + - name: base.yaml + - name: pincfg-node.yaml + child-binding: + property-allowlist: + - drive-push-pull + - drive-open-drain + - bias-disable + - bias-pull-down + - bias-pull-up + +child-binding: + description: | + Each child node defines the configuration for a particular state. + properties: + pinmux: + required: true + type: array + description: | + An array of pins sharing the same group properties. The pins should + be defined using pre-defined macros or, alternatively, using NVT_PINMUX + macros depending on the pinmux model used by the SoC series. + drive-strength: + type: string + default: "low" + enum: + - "low" + - "fast" + description: | + Set the driving strength of a pin. Hardware default configuration is low and + it's enough to drive most components, like as LED, CAN transceiver and so on. + slew-rate: + type: string + default: "low" + enum: + - "fast" + - "low" + description: | + Set the speed of a pin. This setting effectively limits the + slew rate of the output signal. Hardware default configuration is low. + Fast slew rate could support high speed pins, like as SPI CLK up to 50MHz. diff --git a/include/zephyr/dt-bindings/pinctrl/numaker-m46x-pinctrl.h b/include/zephyr/dt-bindings/pinctrl/numaker-m46x-pinctrl.h new file mode 100644 index 00000000000..0df188e41a8 --- /dev/null +++ b/include/zephyr/dt-bindings/pinctrl/numaker-m46x-pinctrl.h @@ -0,0 +1,2154 @@ +/* + * Copyright (c) 2023 Nuvoton Technology Corporation. + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef ZEPHYR_INCLUDE_DT_BINDINGS_PINCTRL_NUMAKER_M46X_PINCTRL_H +#define ZEPHYR_INCLUDE_DT_BINDINGS_PINCTRL_NUMAKER_M46X_PINCTRL_H + +/* Beginning of M460 BSP sys_reg.h pin-mux module copy */ + +#define NUMAKER_SYS_GPA_MFP0_PA0MFP_Pos (0) +#define NUMAKER_SYS_GPA_MFP0_PA1MFP_Pos (8) +#define NUMAKER_SYS_GPA_MFP0_PA2MFP_Pos (16) +#define NUMAKER_SYS_GPA_MFP0_PA3MFP_Pos (24) +#define NUMAKER_SYS_GPA_MFP1_PA4MFP_Pos (0) +#define NUMAKER_SYS_GPA_MFP1_PA5MFP_Pos (8) +#define NUMAKER_SYS_GPA_MFP1_PA6MFP_Pos (16) +#define NUMAKER_SYS_GPA_MFP1_PA7MFP_Pos (24) +#define NUMAKER_SYS_GPA_MFP2_PA8MFP_Pos (0) +#define NUMAKER_SYS_GPA_MFP2_PA9MFP_Pos (8) +#define NUMAKER_SYS_GPA_MFP2_PA10MFP_Pos (16) +#define NUMAKER_SYS_GPA_MFP2_PA11MFP_Pos (24) +#define NUMAKER_SYS_GPA_MFP3_PA12MFP_Pos (0) +#define NUMAKER_SYS_GPA_MFP3_PA13MFP_Pos (8) +#define NUMAKER_SYS_GPA_MFP3_PA14MFP_Pos (16) +#define NUMAKER_SYS_GPA_MFP3_PA15MFP_Pos (24) + +#define NUMAKER_SYS_GPB_MFP0_PB0MFP_Pos (0) +#define NUMAKER_SYS_GPB_MFP0_PB1MFP_Pos (8) +#define NUMAKER_SYS_GPB_MFP0_PB2MFP_Pos (16) +#define NUMAKER_SYS_GPB_MFP0_PB3MFP_Pos (24) +#define NUMAKER_SYS_GPB_MFP1_PB4MFP_Pos (0) +#define NUMAKER_SYS_GPB_MFP1_PB5MFP_Pos (8) +#define NUMAKER_SYS_GPB_MFP1_PB6MFP_Pos (16) +#define NUMAKER_SYS_GPB_MFP1_PB7MFP_Pos (24) +#define NUMAKER_SYS_GPB_MFP2_PB8MFP_Pos (0) +#define NUMAKER_SYS_GPB_MFP2_PB9MFP_Pos (8) +#define NUMAKER_SYS_GPB_MFP2_PB10MFP_Pos (16) +#define NUMAKER_SYS_GPB_MFP2_PB11MFP_Pos (24) +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos (0) +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos (8) +#define NUMAKER_SYS_GPB_MFP3_PB14MFP_Pos (16) +#define NUMAKER_SYS_GPB_MFP3_PB15MFP_Pos (24) + +#define NUMAKER_SYS_GPC_MFP0_PC0MFP_Pos (0) +#define NUMAKER_SYS_GPC_MFP0_PC1MFP_Pos (8) +#define NUMAKER_SYS_GPC_MFP0_PC2MFP_Pos (16) +#define NUMAKER_SYS_GPC_MFP0_PC3MFP_Pos (24) +#define NUMAKER_SYS_GPC_MFP1_PC4MFP_Pos (0) +#define NUMAKER_SYS_GPC_MFP1_PC5MFP_Pos (8) +#define NUMAKER_SYS_GPC_MFP1_PC6MFP_Pos (16) +#define NUMAKER_SYS_GPC_MFP1_PC7MFP_Pos (24) +#define NUMAKER_SYS_GPC_MFP2_PC8MFP_Pos (0) +#define NUMAKER_SYS_GPC_MFP2_PC9MFP_Pos (8) +#define NUMAKER_SYS_GPC_MFP2_PC10MFP_Pos (16) +#define NUMAKER_SYS_GPC_MFP2_PC11MFP_Pos (24) +#define NUMAKER_SYS_GPC_MFP3_PC12MFP_Pos (0) +#define NUMAKER_SYS_GPC_MFP3_PC13MFP_Pos (8) +#define NUMAKER_SYS_GPC_MFP3_PC14MFP_Pos (16) + +#define NUMAKER_SYS_GPD_MFP0_PD0MFP_Pos (0) +#define NUMAKER_SYS_GPD_MFP0_PD1MFP_Pos (8) +#define NUMAKER_SYS_GPD_MFP0_PD2MFP_Pos (16) +#define NUMAKER_SYS_GPD_MFP0_PD3MFP_Pos (24) +#define NUMAKER_SYS_GPD_MFP1_PD4MFP_Pos (0) +#define NUMAKER_SYS_GPD_MFP1_PD5MFP_Pos (8) +#define NUMAKER_SYS_GPD_MFP1_PD6MFP_Pos (16) +#define NUMAKER_SYS_GPD_MFP1_PD7MFP_Pos (24) +#define NUMAKER_SYS_GPD_MFP2_PD8MFP_Pos (0) +#define NUMAKER_SYS_GPD_MFP2_PD9MFP_Pos (8) +#define NUMAKER_SYS_GPD_MFP2_PD10MFP_Pos (16) +#define NUMAKER_SYS_GPD_MFP2_PD11MFP_Pos (24) +#define NUMAKER_SYS_GPD_MFP3_PD12MFP_Pos (0) +#define NUMAKER_SYS_GPD_MFP3_PD13MFP_Pos (8) +#define NUMAKER_SYS_GPD_MFP3_PD14MFP_Pos (16) + +#define NUMAKER_SYS_GPE_MFP0_PE0MFP_Pos (0) +#define NUMAKER_SYS_GPE_MFP0_PE1MFP_Pos (8) +#define NUMAKER_SYS_GPE_MFP0_PE2MFP_Pos (16) +#define NUMAKER_SYS_GPE_MFP0_PE3MFP_Pos (24) +#define NUMAKER_SYS_GPE_MFP1_PE4MFP_Pos (0) +#define NUMAKER_SYS_GPE_MFP1_PE5MFP_Pos (8) +#define NUMAKER_SYS_GPE_MFP1_PE6MFP_Pos (16) +#define NUMAKER_SYS_GPE_MFP1_PE7MFP_Pos (24) +#define NUMAKER_SYS_GPE_MFP2_PE8MFP_Pos (0) +#define NUMAKER_SYS_GPE_MFP2_PE9MFP_Pos (8) +#define NUMAKER_SYS_GPE_MFP2_PE10MFP_Pos (16) +#define NUMAKER_SYS_GPE_MFP2_PE11MFP_Pos (24) +#define NUMAKER_SYS_GPE_MFP3_PE12MFP_Pos (0) +#define NUMAKER_SYS_GPE_MFP3_PE13MFP_Pos (8) +#define NUMAKER_SYS_GPE_MFP3_PE14MFP_Pos (16) +#define NUMAKER_SYS_GPE_MFP3_PE15MFP_Pos (24) + +#define NUMAKER_SYS_GPF_MFP0_PF0MFP_Pos (0) +#define NUMAKER_SYS_GPF_MFP0_PF1MFP_Pos (8) +#define NUMAKER_SYS_GPF_MFP0_PF2MFP_Pos (16) +#define NUMAKER_SYS_GPF_MFP0_PF3MFP_Pos (24) +#define NUMAKER_SYS_GPF_MFP1_PF4MFP_Pos (0) +#define NUMAKER_SYS_GPF_MFP1_PF5MFP_Pos (8) +#define NUMAKER_SYS_GPF_MFP1_PF6MFP_Pos (16) +#define NUMAKER_SYS_GPF_MFP1_PF7MFP_Pos (24) +#define NUMAKER_SYS_GPF_MFP2_PF8MFP_Pos (0) +#define NUMAKER_SYS_GPF_MFP2_PF9MFP_Pos (8) +#define NUMAKER_SYS_GPF_MFP2_PF10MFP_Pos (16) +#define NUMAKER_SYS_GPF_MFP2_PF11MFP_Pos (24) + +#define NUMAKER_SYS_GPG_MFP0_PG0MFP_Pos (0) +#define NUMAKER_SYS_GPG_MFP0_PG1MFP_Pos (8) +#define NUMAKER_SYS_GPG_MFP0_PG2MFP_Pos (16) +#define NUMAKER_SYS_GPG_MFP0_PG3MFP_Pos (24) +#define NUMAKER_SYS_GPG_MFP1_PG4MFP_Pos (0) +#define NUMAKER_SYS_GPG_MFP1_PG5MFP_Pos (8) +#define NUMAKER_SYS_GPG_MFP1_PG6MFP_Pos (16) +#define NUMAKER_SYS_GPG_MFP1_PG7MFP_Pos (24) +#define NUMAKER_SYS_GPG_MFP2_PG8MFP_Pos (0) +#define NUMAKER_SYS_GPG_MFP2_PG9MFP_Pos (8) +#define NUMAKER_SYS_GPG_MFP2_PG10MFP_Pos (16) +#define NUMAKER_SYS_GPG_MFP2_PG11MFP_Pos (24) +#define NUMAKER_SYS_GPG_MFP3_PG12MFP_Pos (0) +#define NUMAKER_SYS_GPG_MFP3_PG13MFP_Pos (8) +#define NUMAKER_SYS_GPG_MFP3_PG14MFP_Pos (16) +#define NUMAKER_SYS_GPG_MFP3_PG15MFP_Pos (24) + +#define NUMAKER_SYS_GPH_MFP0_PH0MFP_Pos (0) +#define NUMAKER_SYS_GPH_MFP0_PH1MFP_Pos (8) +#define NUMAKER_SYS_GPH_MFP0_PH2MFP_Pos (16) +#define NUMAKER_SYS_GPH_MFP0_PH3MFP_Pos (24) +#define NUMAKER_SYS_GPH_MFP1_PH4MFP_Pos (0) +#define NUMAKER_SYS_GPH_MFP1_PH5MFP_Pos (8) +#define NUMAKER_SYS_GPH_MFP1_PH6MFP_Pos (16) +#define NUMAKER_SYS_GPH_MFP1_PH7MFP_Pos (24) +#define NUMAKER_SYS_GPH_MFP2_PH8MFP_Pos (0) +#define NUMAKER_SYS_GPH_MFP2_PH9MFP_Pos (8) +#define NUMAKER_SYS_GPH_MFP2_PH10MFP_Pos (16) +#define NUMAKER_SYS_GPH_MFP2_PH11MFP_Pos (24) +#define NUMAKER_SYS_GPH_MFP3_PH12MFP_Pos (0) +#define NUMAKER_SYS_GPH_MFP3_PH13MFP_Pos (8) +#define NUMAKER_SYS_GPH_MFP3_PH14MFP_Pos (16) +#define NUMAKER_SYS_GPH_MFP3_PH15MFP_Pos (24) + +#define NUMAKER_SYS_GPI_MFP1_PI6MFP_Pos (16) +#define NUMAKER_SYS_GPI_MFP1_PI7MFP_Pos (24) +#define NUMAKER_SYS_GPI_MFP2_PI8MFP_Pos (0) +#define NUMAKER_SYS_GPI_MFP2_PI9MFP_Pos (8) +#define NUMAKER_SYS_GPI_MFP2_PI10MFP_Pos (16) +#define NUMAKER_SYS_GPI_MFP2_PI11MFP_Pos (24) +#define NUMAKER_SYS_GPI_MFP3_PI12MFP_Pos (0) +#define NUMAKER_SYS_GPI_MFP3_PI13MFP_Pos (8) +#define NUMAKER_SYS_GPI_MFP3_PI14MFP_Pos (16) +#define NUMAKER_SYS_GPI_MFP3_PI15MFP_Pos (24) + +#define NUMAKER_SYS_GPJ_MFP0_PJ0MFP_Pos (0) +#define NUMAKER_SYS_GPJ_MFP0_PJ1MFP_Pos (8) +#define NUMAKER_SYS_GPJ_MFP0_PJ2MFP_Pos (16) +#define NUMAKER_SYS_GPJ_MFP0_PJ3MFP_Pos (24) +#define NUMAKER_SYS_GPJ_MFP1_PJ4MFP_Pos (0) +#define NUMAKER_SYS_GPJ_MFP1_PJ5MFP_Pos (8) +#define NUMAKER_SYS_GPJ_MFP1_PJ6MFP_Pos (16) +#define NUMAKER_SYS_GPJ_MFP1_PJ7MFP_Pos (24) +#define NUMAKER_SYS_GPJ_MFP2_PJ8MFP_Pos (0) +#define NUMAKER_SYS_GPJ_MFP2_PJ9MFP_Pos (8) +#define NUMAKER_SYS_GPJ_MFP2_PJ10MFP_Pos (16) +#define NUMAKER_SYS_GPJ_MFP2_PJ11MFP_Pos (24) +#define NUMAKER_SYS_GPJ_MFP3_PJ12MFP_Pos (0) +#define NUMAKER_SYS_GPJ_MFP3_PJ13MFP_Pos (8) + +/* End of M460 BSP sys_reg.h pin-mux module copy */ + +/* Beginning of M460 BSP sys.h pin-mux module copy */ + +/* + *---------------------------------------------------------------------------- + * Multi-Function constant definitions. + *---------------------------------------------------------------------------- + */ + +/* PA.0 MFP */ +#define NUMAKER_SYS_GPA_MFP0_PA0MFP_GPIO (0x00UL << NUMAKER_SYS_GPA_MFP0_PA0MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA0MFP_SPIM_MOSI (0x02UL << NUMAKER_SYS_GPA_MFP0_PA0MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA0MFP_QSPI0_MOSI0 (0x03UL << NUMAKER_SYS_GPA_MFP0_PA0MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA0MFP_SPI0_MOSI (0x04UL << NUMAKER_SYS_GPA_MFP0_PA0MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA0MFP_SD1_DAT0 (0x05UL << NUMAKER_SYS_GPA_MFP0_PA0MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA0MFP_SC0_CLK (0x06UL << NUMAKER_SYS_GPA_MFP0_PA0MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA0MFP_UART0_RXD (0x07UL << NUMAKER_SYS_GPA_MFP0_PA0MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA0MFP_UART1_nRTS (0x08UL << NUMAKER_SYS_GPA_MFP0_PA0MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA0MFP_I2C2_SDA (0x09UL << NUMAKER_SYS_GPA_MFP0_PA0MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA0MFP_CCAP_DATA6 (0x0aUL << NUMAKER_SYS_GPA_MFP0_PA0MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA0MFP_BPWM0_CH0 (0x0cUL << NUMAKER_SYS_GPA_MFP0_PA0MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA0MFP_EPWM0_CH5 (0x0dUL << NUMAKER_SYS_GPA_MFP0_PA0MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA0MFP_EQEI3_B (0x0eUL << NUMAKER_SYS_GPA_MFP0_PA0MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA0MFP_DAC0_ST (0x0fUL << NUMAKER_SYS_GPA_MFP0_PA0MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA0MFP_PSIO0_CH7 (0x11UL << NUMAKER_SYS_GPA_MFP0_PA0MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA0MFP_BMC19 (0x14UL << NUMAKER_SYS_GPA_MFP0_PA0MFP_Pos) + +/* PA.1 MFP */ +#define NUMAKER_SYS_GPA_MFP0_PA1MFP_GPIO (0x00UL << NUMAKER_SYS_GPA_MFP0_PA1MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA1MFP_SPIM_MISO (0x02UL << NUMAKER_SYS_GPA_MFP0_PA1MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA1MFP_QSPI0_MISO0 (0x03UL << NUMAKER_SYS_GPA_MFP0_PA1MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA1MFP_SPI0_MISO (0x04UL << NUMAKER_SYS_GPA_MFP0_PA1MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA1MFP_SD1_DAT1 (0x05UL << NUMAKER_SYS_GPA_MFP0_PA1MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA1MFP_SC0_DAT (0x06UL << NUMAKER_SYS_GPA_MFP0_PA1MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA1MFP_UART0_TXD (0x07UL << NUMAKER_SYS_GPA_MFP0_PA1MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA1MFP_UART1_nCTS (0x08UL << NUMAKER_SYS_GPA_MFP0_PA1MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA1MFP_I2C2_SCL (0x09UL << NUMAKER_SYS_GPA_MFP0_PA1MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA1MFP_CCAP_DATA7 (0x0aUL << NUMAKER_SYS_GPA_MFP0_PA1MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA1MFP_BPWM0_CH1 (0x0cUL << NUMAKER_SYS_GPA_MFP0_PA1MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA1MFP_EPWM0_CH4 (0x0dUL << NUMAKER_SYS_GPA_MFP0_PA1MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA1MFP_EQEI3_A (0x0eUL << NUMAKER_SYS_GPA_MFP0_PA1MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA1MFP_DAC1_ST (0x0fUL << NUMAKER_SYS_GPA_MFP0_PA1MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA1MFP_PSIO0_CH6 (0x11UL << NUMAKER_SYS_GPA_MFP0_PA1MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA1MFP_BMC18 (0x14UL << NUMAKER_SYS_GPA_MFP0_PA1MFP_Pos) + +/* PA.2 MFP */ +#define NUMAKER_SYS_GPA_MFP0_PA2MFP_GPIO (0x00UL << NUMAKER_SYS_GPA_MFP0_PA2MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA2MFP_SPIM_CLK (0x02UL << NUMAKER_SYS_GPA_MFP0_PA2MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA2MFP_QSPI0_CLK (0x03UL << NUMAKER_SYS_GPA_MFP0_PA2MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA2MFP_SPI0_CLK (0x04UL << NUMAKER_SYS_GPA_MFP0_PA2MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA2MFP_SD1_DAT2 (0x05UL << NUMAKER_SYS_GPA_MFP0_PA2MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA2MFP_SC0_RST (0x06UL << NUMAKER_SYS_GPA_MFP0_PA2MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA2MFP_UART4_RXD (0x07UL << NUMAKER_SYS_GPA_MFP0_PA2MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA2MFP_UART1_RXD (0x08UL << NUMAKER_SYS_GPA_MFP0_PA2MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA2MFP_I2C1_SDA (0x09UL << NUMAKER_SYS_GPA_MFP0_PA2MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA2MFP_I2C0_SMBSUS (0x0aUL << NUMAKER_SYS_GPA_MFP0_PA2MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA2MFP_BPWM0_CH2 (0x0cUL << NUMAKER_SYS_GPA_MFP0_PA2MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA2MFP_EPWM0_CH3 (0x0dUL << NUMAKER_SYS_GPA_MFP0_PA2MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA2MFP_EQEI3_INDEX (0x0eUL << NUMAKER_SYS_GPA_MFP0_PA2MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA2MFP_PSIO0_CH5 (0x11UL << NUMAKER_SYS_GPA_MFP0_PA2MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA2MFP_BMC17 (0x14UL << NUMAKER_SYS_GPA_MFP0_PA2MFP_Pos) + +/* PA.3 MFP */ +#define NUMAKER_SYS_GPA_MFP0_PA3MFP_GPIO (0x00UL << NUMAKER_SYS_GPA_MFP0_PA3MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA3MFP_SPIM_SS (0x02UL << NUMAKER_SYS_GPA_MFP0_PA3MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA3MFP_QSPI0_SS (0x03UL << NUMAKER_SYS_GPA_MFP0_PA3MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA3MFP_SPI0_SS (0x04UL << NUMAKER_SYS_GPA_MFP0_PA3MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA3MFP_SD1_DAT3 (0x05UL << NUMAKER_SYS_GPA_MFP0_PA3MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA3MFP_SC0_PWR (0x06UL << NUMAKER_SYS_GPA_MFP0_PA3MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA3MFP_UART4_TXD (0x07UL << NUMAKER_SYS_GPA_MFP0_PA3MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA3MFP_UART1_TXD (0x08UL << NUMAKER_SYS_GPA_MFP0_PA3MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA3MFP_I2C1_SCL (0x09UL << NUMAKER_SYS_GPA_MFP0_PA3MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA3MFP_I2C0_SMBAL (0x0aUL << NUMAKER_SYS_GPA_MFP0_PA3MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA3MFP_BPWM0_CH3 (0x0cUL << NUMAKER_SYS_GPA_MFP0_PA3MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA3MFP_EPWM0_CH2 (0x0dUL << NUMAKER_SYS_GPA_MFP0_PA3MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA3MFP_EQEI0_B (0x0eUL << NUMAKER_SYS_GPA_MFP0_PA3MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA3MFP_EPWM1_BRAKE1 (0x0fUL << NUMAKER_SYS_GPA_MFP0_PA3MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA3MFP_PSIO0_CH4 (0x11UL << NUMAKER_SYS_GPA_MFP0_PA3MFP_Pos) +#define NUMAKER_SYS_GPA_MFP0_PA3MFP_BMC16 (0x14UL << NUMAKER_SYS_GPA_MFP0_PA3MFP_Pos) + +/* PA.4 MFP */ +#define NUMAKER_SYS_GPA_MFP1_PA4MFP_GPIO (0x00UL << NUMAKER_SYS_GPA_MFP1_PA4MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA4MFP_SPIM_D3 (0x02UL << NUMAKER_SYS_GPA_MFP1_PA4MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA4MFP_QSPI0_MOSI1 (0x03UL << NUMAKER_SYS_GPA_MFP1_PA4MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA4MFP_SPI0_I2SMCLK (0x04UL << NUMAKER_SYS_GPA_MFP1_PA4MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA4MFP_SD1_CLK (0x05UL << NUMAKER_SYS_GPA_MFP1_PA4MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA4MFP_SC0_nCD (0x06UL << NUMAKER_SYS_GPA_MFP1_PA4MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA4MFP_UART0_nRTS (0x07UL << NUMAKER_SYS_GPA_MFP1_PA4MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA4MFP_UART5_RXD (0x08UL << NUMAKER_SYS_GPA_MFP1_PA4MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA4MFP_I2C0_SDA (0x09UL << NUMAKER_SYS_GPA_MFP1_PA4MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA4MFP_CAN0_RXD (0x0aUL << NUMAKER_SYS_GPA_MFP1_PA4MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA4MFP_UART0_RXD (0x0bUL << NUMAKER_SYS_GPA_MFP1_PA4MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA4MFP_BPWM0_CH4 (0x0cUL << NUMAKER_SYS_GPA_MFP1_PA4MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA4MFP_EPWM0_CH1 (0x0dUL << NUMAKER_SYS_GPA_MFP1_PA4MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA4MFP_EQEI0_A (0x0eUL << NUMAKER_SYS_GPA_MFP1_PA4MFP_Pos) + +/* PA.5 MFP */ +#define NUMAKER_SYS_GPA_MFP1_PA5MFP_GPIO (0x00UL << NUMAKER_SYS_GPA_MFP1_PA5MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA5MFP_SPIM_D2 (0x02UL << NUMAKER_SYS_GPA_MFP1_PA5MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA5MFP_QSPI0_MISO1 (0x03UL << NUMAKER_SYS_GPA_MFP1_PA5MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA5MFP_SPI1_I2SMCLK (0x04UL << NUMAKER_SYS_GPA_MFP1_PA5MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA5MFP_SD1_CMD (0x05UL << NUMAKER_SYS_GPA_MFP1_PA5MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA5MFP_SC2_nCD (0x06UL << NUMAKER_SYS_GPA_MFP1_PA5MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA5MFP_UART0_nCTS (0x07UL << NUMAKER_SYS_GPA_MFP1_PA5MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA5MFP_UART5_TXD (0x08UL << NUMAKER_SYS_GPA_MFP1_PA5MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA5MFP_I2C0_SCL (0x09UL << NUMAKER_SYS_GPA_MFP1_PA5MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA5MFP_CAN0_TXD (0x0aUL << NUMAKER_SYS_GPA_MFP1_PA5MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA5MFP_UART0_TXD (0x0bUL << NUMAKER_SYS_GPA_MFP1_PA5MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA5MFP_BPWM0_CH5 (0x0cUL << NUMAKER_SYS_GPA_MFP1_PA5MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA5MFP_EPWM0_CH0 (0x0dUL << NUMAKER_SYS_GPA_MFP1_PA5MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA5MFP_EQEI0_INDEX (0x0eUL << NUMAKER_SYS_GPA_MFP1_PA5MFP_Pos) + +/* PA.6 MFP */ +#define NUMAKER_SYS_GPA_MFP1_PA6MFP_GPIO (0x00UL << NUMAKER_SYS_GPA_MFP1_PA6MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA6MFP_EBI_AD6 (0x02UL << NUMAKER_SYS_GPA_MFP1_PA6MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA6MFP_EMAC0_RMII_RXERR (0x03UL << NUMAKER_SYS_GPA_MFP1_PA6MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA6MFP_SPI1_SS (0x04UL << NUMAKER_SYS_GPA_MFP1_PA6MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA6MFP_SD1_nCD (0x05UL << NUMAKER_SYS_GPA_MFP1_PA6MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA6MFP_SC2_CLK (0x06UL << NUMAKER_SYS_GPA_MFP1_PA6MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA6MFP_UART0_RXD (0x07UL << NUMAKER_SYS_GPA_MFP1_PA6MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA6MFP_I2C1_SDA (0x08UL << NUMAKER_SYS_GPA_MFP1_PA6MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA6MFP_QSPI1_MOSI1 (0x09UL << NUMAKER_SYS_GPA_MFP1_PA6MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA6MFP_EPWM1_CH5 (0x0bUL << NUMAKER_SYS_GPA_MFP1_PA6MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA6MFP_BPWM1_CH3 (0x0cUL << NUMAKER_SYS_GPA_MFP1_PA6MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA6MFP_ACMP1_WLAT (0x0dUL << NUMAKER_SYS_GPA_MFP1_PA6MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA6MFP_TM3 (0x0eUL << NUMAKER_SYS_GPA_MFP1_PA6MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA6MFP_INT0 (0x0fUL << NUMAKER_SYS_GPA_MFP1_PA6MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA6MFP_SPI5_CLK (0x11UL << NUMAKER_SYS_GPA_MFP1_PA6MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA6MFP_KPI_COL0 (0x12UL << NUMAKER_SYS_GPA_MFP1_PA6MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA6MFP_SPI6_CLK (0x13UL << NUMAKER_SYS_GPA_MFP1_PA6MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA6MFP_BMC15 (0x14UL << NUMAKER_SYS_GPA_MFP1_PA6MFP_Pos) + +/* PA.7 MFP */ +#define NUMAKER_SYS_GPA_MFP1_PA7MFP_GPIO (0x00UL << NUMAKER_SYS_GPA_MFP1_PA7MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA7MFP_EBI_AD7 (0x02UL << NUMAKER_SYS_GPA_MFP1_PA7MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA7MFP_EMAC0_RMII_CRSDV (0x03UL << NUMAKER_SYS_GPA_MFP1_PA7MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA7MFP_SPI1_CLK (0x04UL << NUMAKER_SYS_GPA_MFP1_PA7MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA7MFP_SC2_DAT (0x06UL << NUMAKER_SYS_GPA_MFP1_PA7MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA7MFP_UART0_TXD (0x07UL << NUMAKER_SYS_GPA_MFP1_PA7MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA7MFP_I2C1_SCL (0x08UL << NUMAKER_SYS_GPA_MFP1_PA7MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA7MFP_QSPI1_MISO1 (0x09UL << NUMAKER_SYS_GPA_MFP1_PA7MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA7MFP_EPWM1_CH4 (0x0bUL << NUMAKER_SYS_GPA_MFP1_PA7MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA7MFP_BPWM1_CH2 (0x0cUL << NUMAKER_SYS_GPA_MFP1_PA7MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA7MFP_ACMP0_WLAT (0x0dUL << NUMAKER_SYS_GPA_MFP1_PA7MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA7MFP_TM2 (0x0eUL << NUMAKER_SYS_GPA_MFP1_PA7MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA7MFP_INT1 (0x0fUL << NUMAKER_SYS_GPA_MFP1_PA7MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA7MFP_SPI5_SS (0x11UL << NUMAKER_SYS_GPA_MFP1_PA7MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA7MFP_KPI_COL1 (0x12UL << NUMAKER_SYS_GPA_MFP1_PA7MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA7MFP_SPI6_SS (0x13UL << NUMAKER_SYS_GPA_MFP1_PA7MFP_Pos) +#define NUMAKER_SYS_GPA_MFP1_PA7MFP_BMC14 (0x14UL << NUMAKER_SYS_GPA_MFP1_PA7MFP_Pos) + +/* PA.8 MFP */ +#define NUMAKER_SYS_GPA_MFP2_PA8MFP_GPIO (0x00UL << NUMAKER_SYS_GPA_MFP2_PA8MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA8MFP_EADC1_CH4 (0x01UL << NUMAKER_SYS_GPA_MFP2_PA8MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA8MFP_EADC2_CH4 (0x01UL << NUMAKER_SYS_GPA_MFP2_PA8MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA8MFP_EBI_ALE (0x02UL << NUMAKER_SYS_GPA_MFP2_PA8MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA8MFP_SC2_CLK (0x03UL << NUMAKER_SYS_GPA_MFP2_PA8MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA8MFP_SPI2_MOSI (0x04UL << NUMAKER_SYS_GPA_MFP2_PA8MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA8MFP_SD1_DAT0 (0x05UL << NUMAKER_SYS_GPA_MFP2_PA8MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA8MFP_USCI0_CTL1 (0x06UL << NUMAKER_SYS_GPA_MFP2_PA8MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA8MFP_UART1_RXD (0x07UL << NUMAKER_SYS_GPA_MFP2_PA8MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA8MFP_UART7_RXD (0x08UL << NUMAKER_SYS_GPA_MFP2_PA8MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA8MFP_BPWM0_CH3 (0x09UL << NUMAKER_SYS_GPA_MFP2_PA8MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA8MFP_EQEI1_B (0x0aUL << NUMAKER_SYS_GPA_MFP2_PA8MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA8MFP_ECAP0_IC2 (0x0bUL << NUMAKER_SYS_GPA_MFP2_PA8MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA8MFP_I2S1_DO (0x0cUL << NUMAKER_SYS_GPA_MFP2_PA8MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA8MFP_TM3_EXT (0x0dUL << NUMAKER_SYS_GPA_MFP2_PA8MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA8MFP_INT4 (0x0fUL << NUMAKER_SYS_GPA_MFP2_PA8MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA8MFP_BMC9 (0x14UL << NUMAKER_SYS_GPA_MFP2_PA8MFP_Pos) + +/* PA.9 MFP */ +#define NUMAKER_SYS_GPA_MFP2_PA9MFP_GPIO (0x00UL << NUMAKER_SYS_GPA_MFP2_PA9MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA9MFP_EADC1_CH5 (0x01UL << NUMAKER_SYS_GPA_MFP2_PA9MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA9MFP_EADC2_CH5 (0x01UL << NUMAKER_SYS_GPA_MFP2_PA9MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA9MFP_EBI_MCLK (0x02UL << NUMAKER_SYS_GPA_MFP2_PA9MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA9MFP_SC2_DAT (0x03UL << NUMAKER_SYS_GPA_MFP2_PA9MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA9MFP_SPI2_MISO (0x04UL << NUMAKER_SYS_GPA_MFP2_PA9MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA9MFP_SD1_DAT1 (0x05UL << NUMAKER_SYS_GPA_MFP2_PA9MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA9MFP_USCI0_DAT1 (0x06UL << NUMAKER_SYS_GPA_MFP2_PA9MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA9MFP_UART1_TXD (0x07UL << NUMAKER_SYS_GPA_MFP2_PA9MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA9MFP_UART7_TXD (0x08UL << NUMAKER_SYS_GPA_MFP2_PA9MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA9MFP_BPWM0_CH2 (0x09UL << NUMAKER_SYS_GPA_MFP2_PA9MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA9MFP_EQEI1_A (0x0aUL << NUMAKER_SYS_GPA_MFP2_PA9MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA9MFP_ECAP0_IC1 (0x0bUL << NUMAKER_SYS_GPA_MFP2_PA9MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA9MFP_I2S1_DI (0x0cUL << NUMAKER_SYS_GPA_MFP2_PA9MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA9MFP_TM2_EXT (0x0dUL << NUMAKER_SYS_GPA_MFP2_PA9MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA9MFP_SWDH_DAT (0x0fUL << NUMAKER_SYS_GPA_MFP2_PA9MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA9MFP_BMC8 (0x14UL << NUMAKER_SYS_GPA_MFP2_PA9MFP_Pos) + +/* PA.10 MFP */ +#define NUMAKER_SYS_GPA_MFP2_PA10MFP_GPIO (0x00UL << NUMAKER_SYS_GPA_MFP2_PA10MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA10MFP_EADC1_CH6 (0x01UL << NUMAKER_SYS_GPA_MFP2_PA10MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA10MFP_EADC2_CH6 (0x01UL << NUMAKER_SYS_GPA_MFP2_PA10MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA10MFP_ACMP1_P0 (0x01UL << NUMAKER_SYS_GPA_MFP2_PA10MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA10MFP_EBI_nWR (0x02UL << NUMAKER_SYS_GPA_MFP2_PA10MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA10MFP_SC2_RST (0x03UL << NUMAKER_SYS_GPA_MFP2_PA10MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA10MFP_SPI2_CLK (0x04UL << NUMAKER_SYS_GPA_MFP2_PA10MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA10MFP_SD1_DAT2 (0x05UL << NUMAKER_SYS_GPA_MFP2_PA10MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA10MFP_USCI0_DAT0 (0x06UL << NUMAKER_SYS_GPA_MFP2_PA10MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA10MFP_I2C2_SDA (0x07UL << NUMAKER_SYS_GPA_MFP2_PA10MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA10MFP_UART6_RXD (0x08UL << NUMAKER_SYS_GPA_MFP2_PA10MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA10MFP_BPWM0_CH1 (0x09UL << NUMAKER_SYS_GPA_MFP2_PA10MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA10MFP_EQEI1_INDEX (0x0aUL << NUMAKER_SYS_GPA_MFP2_PA10MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA10MFP_ECAP0_IC0 (0x0bUL << NUMAKER_SYS_GPA_MFP2_PA10MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA10MFP_I2S1_MCLK (0x0cUL << NUMAKER_SYS_GPA_MFP2_PA10MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA10MFP_TM1_EXT (0x0dUL << NUMAKER_SYS_GPA_MFP2_PA10MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA10MFP_DAC0_ST (0x0eUL << NUMAKER_SYS_GPA_MFP2_PA10MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA10MFP_SWDH_CLK (0x0fUL << NUMAKER_SYS_GPA_MFP2_PA10MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA10MFP_KPI_ROW5 (0x12UL << NUMAKER_SYS_GPA_MFP2_PA10MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA10MFP_BMC7 (0x14UL << NUMAKER_SYS_GPA_MFP2_PA10MFP_Pos) + +/* PA.11 MFP */ +#define NUMAKER_SYS_GPA_MFP2_PA11MFP_GPIO (0x00UL << NUMAKER_SYS_GPA_MFP2_PA11MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA11MFP_EADC1_CH7 (0x01UL << NUMAKER_SYS_GPA_MFP2_PA11MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA11MFP_EADC2_CH7 (0x01UL << NUMAKER_SYS_GPA_MFP2_PA11MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA11MFP_ACMP0_P0 (0x01UL << NUMAKER_SYS_GPA_MFP2_PA11MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA11MFP_EBI_nRD (0x02UL << NUMAKER_SYS_GPA_MFP2_PA11MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA11MFP_SC2_PWR (0x03UL << NUMAKER_SYS_GPA_MFP2_PA11MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA11MFP_SPI2_SS (0x04UL << NUMAKER_SYS_GPA_MFP2_PA11MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA11MFP_SD1_DAT3 (0x05UL << NUMAKER_SYS_GPA_MFP2_PA11MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA11MFP_USCI0_CLK (0x06UL << NUMAKER_SYS_GPA_MFP2_PA11MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA11MFP_I2C2_SCL (0x07UL << NUMAKER_SYS_GPA_MFP2_PA11MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA11MFP_UART6_TXD (0x08UL << NUMAKER_SYS_GPA_MFP2_PA11MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA11MFP_BPWM0_CH0 (0x09UL << NUMAKER_SYS_GPA_MFP2_PA11MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA11MFP_EPWM0_SYNC_OUT (0x0aUL << NUMAKER_SYS_GPA_MFP2_PA11MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA11MFP_I2S1_BCLK (0x0cUL << NUMAKER_SYS_GPA_MFP2_PA11MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA11MFP_TM0_EXT (0x0dUL << NUMAKER_SYS_GPA_MFP2_PA11MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA11MFP_DAC1_ST (0x0eUL << NUMAKER_SYS_GPA_MFP2_PA11MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA11MFP_KPI_ROW4 (0x12UL << NUMAKER_SYS_GPA_MFP2_PA11MFP_Pos) +#define NUMAKER_SYS_GPA_MFP2_PA11MFP_BMC6 (0x14UL << NUMAKER_SYS_GPA_MFP2_PA11MFP_Pos) + +/* PA.12 MFP */ +#define NUMAKER_SYS_GPA_MFP3_PA12MFP_GPIO (0x00UL << NUMAKER_SYS_GPA_MFP3_PA12MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA12MFP_I2S0_BCLK (0x02UL << NUMAKER_SYS_GPA_MFP3_PA12MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA12MFP_UART4_TXD (0x03UL << NUMAKER_SYS_GPA_MFP3_PA12MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA12MFP_I2C1_SCL (0x04UL << NUMAKER_SYS_GPA_MFP3_PA12MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA12MFP_SPI2_SS (0x05UL << NUMAKER_SYS_GPA_MFP3_PA12MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA12MFP_CAN0_TXD (0x06UL << NUMAKER_SYS_GPA_MFP3_PA12MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA12MFP_SC2_PWR (0x07UL << NUMAKER_SYS_GPA_MFP3_PA12MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA12MFP_SD1_nCD (0x08UL << NUMAKER_SYS_GPA_MFP3_PA12MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA12MFP_SPI0_SS (0x09UL << NUMAKER_SYS_GPA_MFP3_PA12MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA12MFP_QSPI1_MISO0 (0x0aUL << NUMAKER_SYS_GPA_MFP3_PA12MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA12MFP_BPWM1_CH2 (0x0bUL << NUMAKER_SYS_GPA_MFP3_PA12MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA12MFP_EQEI1_INDEX (0x0cUL << NUMAKER_SYS_GPA_MFP3_PA12MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA12MFP_ECAP3_IC0 (0x0dUL << NUMAKER_SYS_GPA_MFP3_PA12MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA12MFP_USB_VBUS (0x0eUL << NUMAKER_SYS_GPA_MFP3_PA12MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA12MFP_PSIO0_CH4 (0x11UL << NUMAKER_SYS_GPA_MFP3_PA12MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA12MFP_SPI10_SS (0x13UL << NUMAKER_SYS_GPA_MFP3_PA12MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA12MFP_BMC12 (0x14UL << NUMAKER_SYS_GPA_MFP3_PA12MFP_Pos) + +/* PA.13 MFP */ +#define NUMAKER_SYS_GPA_MFP3_PA13MFP_GPIO (0x00UL << NUMAKER_SYS_GPA_MFP3_PA13MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA13MFP_I2S0_MCLK (0x02UL << NUMAKER_SYS_GPA_MFP3_PA13MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA13MFP_UART4_RXD (0x03UL << NUMAKER_SYS_GPA_MFP3_PA13MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA13MFP_I2C1_SDA (0x04UL << NUMAKER_SYS_GPA_MFP3_PA13MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA13MFP_SPI2_CLK (0x05UL << NUMAKER_SYS_GPA_MFP3_PA13MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA13MFP_CAN0_RXD (0x06UL << NUMAKER_SYS_GPA_MFP3_PA13MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA13MFP_SC2_RST (0x07UL << NUMAKER_SYS_GPA_MFP3_PA13MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA13MFP_SPI0_CLK (0x09UL << NUMAKER_SYS_GPA_MFP3_PA13MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA13MFP_QSPI1_MOSI0 (0x0aUL << NUMAKER_SYS_GPA_MFP3_PA13MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA13MFP_BPWM1_CH3 (0x0bUL << NUMAKER_SYS_GPA_MFP3_PA13MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA13MFP_EQEI1_A (0x0cUL << NUMAKER_SYS_GPA_MFP3_PA13MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA13MFP_ECAP3_IC1 (0x0dUL << NUMAKER_SYS_GPA_MFP3_PA13MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA13MFP_USB_D_N (0x0eUL << NUMAKER_SYS_GPA_MFP3_PA13MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA13MFP_PSIO0_CH5 (0x11UL << NUMAKER_SYS_GPA_MFP3_PA13MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA13MFP_SPI10_CLK (0x13UL << NUMAKER_SYS_GPA_MFP3_PA13MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA13MFP_BMC13 (0x14UL << NUMAKER_SYS_GPA_MFP3_PA13MFP_Pos) + +/* PA.14 MFP */ +#define NUMAKER_SYS_GPA_MFP3_PA14MFP_GPIO (0x00UL << NUMAKER_SYS_GPA_MFP3_PA14MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA14MFP_I2S0_DI (0x02UL << NUMAKER_SYS_GPA_MFP3_PA14MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA14MFP_UART0_TXD (0x03UL << NUMAKER_SYS_GPA_MFP3_PA14MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA14MFP_EBI_AD5 (0x04UL << NUMAKER_SYS_GPA_MFP3_PA14MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA14MFP_SPI2_MISO (0x05UL << NUMAKER_SYS_GPA_MFP3_PA14MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA14MFP_I2C2_SCL (0x06UL << NUMAKER_SYS_GPA_MFP3_PA14MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA14MFP_SC2_DAT (0x07UL << NUMAKER_SYS_GPA_MFP3_PA14MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA14MFP_SPI0_MISO (0x09UL << NUMAKER_SYS_GPA_MFP3_PA14MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA14MFP_BPWM1_CH4 (0x0bUL << NUMAKER_SYS_GPA_MFP3_PA14MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA14MFP_EQEI1_B (0x0cUL << NUMAKER_SYS_GPA_MFP3_PA14MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA14MFP_ECAP3_IC2 (0x0dUL << NUMAKER_SYS_GPA_MFP3_PA14MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA14MFP_USB_D_P (0x0eUL << NUMAKER_SYS_GPA_MFP3_PA14MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA14MFP_I2C0_SCL (0x10UL << NUMAKER_SYS_GPA_MFP3_PA14MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA14MFP_PSIO0_CH6 (0x11UL << NUMAKER_SYS_GPA_MFP3_PA14MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA14MFP_SPI10_MISO (0x13UL << NUMAKER_SYS_GPA_MFP3_PA14MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA14MFP_BMC14 (0x14UL << NUMAKER_SYS_GPA_MFP3_PA14MFP_Pos) + +/* PA.15 MFP */ +#define NUMAKER_SYS_GPA_MFP3_PA15MFP_GPIO (0x00UL << NUMAKER_SYS_GPA_MFP3_PA15MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA15MFP_I2S0_DO (0x02UL << NUMAKER_SYS_GPA_MFP3_PA15MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA15MFP_UART0_RXD (0x03UL << NUMAKER_SYS_GPA_MFP3_PA15MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA15MFP_SPIM_MOSI (0x04UL << NUMAKER_SYS_GPA_MFP3_PA15MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA15MFP_SPI2_MOSI (0x05UL << NUMAKER_SYS_GPA_MFP3_PA15MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA15MFP_I2C2_SDA (0x06UL << NUMAKER_SYS_GPA_MFP3_PA15MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA15MFP_SC2_CLK (0x07UL << NUMAKER_SYS_GPA_MFP3_PA15MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA15MFP_SPI0_MOSI (0x09UL << NUMAKER_SYS_GPA_MFP3_PA15MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA15MFP_BPWM1_CH5 (0x0bUL << NUMAKER_SYS_GPA_MFP3_PA15MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA15MFP_EPWM0_SYNC_IN (0x0cUL << NUMAKER_SYS_GPA_MFP3_PA15MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA15MFP_EQEI3_INDEX (0x0dUL << NUMAKER_SYS_GPA_MFP3_PA15MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA15MFP_USB_OTG_ID (0x0eUL << NUMAKER_SYS_GPA_MFP3_PA15MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA15MFP_I2C0_SDA (0x10UL << NUMAKER_SYS_GPA_MFP3_PA15MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA15MFP_PSIO0_CH7 (0x11UL << NUMAKER_SYS_GPA_MFP3_PA15MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA15MFP_SPI10_MOSI (0x13UL << NUMAKER_SYS_GPA_MFP3_PA15MFP_Pos) +#define NUMAKER_SYS_GPA_MFP3_PA15MFP_BMC15 (0x14UL << NUMAKER_SYS_GPA_MFP3_PA15MFP_Pos) + +/* PB.0 MFP */ +#define NUMAKER_SYS_GPB_MFP0_PB0MFP_GPIO (0x00UL << NUMAKER_SYS_GPB_MFP0_PB0MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB0MFP_EADC0_CH0 (0x01UL << NUMAKER_SYS_GPB_MFP0_PB0MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB0MFP_EADC1_CH8 (0x01UL << NUMAKER_SYS_GPB_MFP0_PB0MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB0MFP_EADC2_CH8 (0x01UL << NUMAKER_SYS_GPB_MFP0_PB0MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB0MFP_ACMP3_N (0x01UL << NUMAKER_SYS_GPB_MFP0_PB0MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB0MFP_EBI_ADR9 (0x02UL << NUMAKER_SYS_GPB_MFP0_PB0MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB0MFP_SD0_CMD (0x03UL << NUMAKER_SYS_GPB_MFP0_PB0MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB0MFP_SPI2_I2SMCLK (0x04UL << NUMAKER_SYS_GPB_MFP0_PB0MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB0MFP_USCI0_CTL0 (0x06UL << NUMAKER_SYS_GPB_MFP0_PB0MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB0MFP_UART2_RXD (0x07UL << NUMAKER_SYS_GPB_MFP0_PB0MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB0MFP_SPI0_I2SMCLK (0x08UL << NUMAKER_SYS_GPB_MFP0_PB0MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB0MFP_I2C1_SDA (0x09UL << NUMAKER_SYS_GPB_MFP0_PB0MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB0MFP_I2S1_LRCK (0x0aUL << NUMAKER_SYS_GPB_MFP0_PB0MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB0MFP_EPWM0_CH5 (0x0bUL << NUMAKER_SYS_GPB_MFP0_PB0MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB0MFP_EPWM1_CH5 (0x0cUL << NUMAKER_SYS_GPB_MFP0_PB0MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB0MFP_EPWM0_BRAKE1 (0x0dUL << NUMAKER_SYS_GPB_MFP0_PB0MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB0MFP_ACMP3_O (0x0eUL << NUMAKER_SYS_GPB_MFP0_PB0MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB0MFP_QSPI0_MOSI1 (0x0fUL << NUMAKER_SYS_GPB_MFP0_PB0MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB0MFP_KPI_ROW3 (0x12UL << NUMAKER_SYS_GPB_MFP0_PB0MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB0MFP_SPI4_MOSI (0x13UL << NUMAKER_SYS_GPB_MFP0_PB0MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB0MFP_BMC5 (0x14UL << NUMAKER_SYS_GPB_MFP0_PB0MFP_Pos) + +/* PB.1 MFP */ +#define NUMAKER_SYS_GPB_MFP0_PB1MFP_GPIO (0x00UL << NUMAKER_SYS_GPB_MFP0_PB1MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB1MFP_EADC0_CH1 (0x01UL << NUMAKER_SYS_GPB_MFP0_PB1MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB1MFP_EADC1_CH9 (0x01UL << NUMAKER_SYS_GPB_MFP0_PB1MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB1MFP_EADC2_CH9 (0x01UL << NUMAKER_SYS_GPB_MFP0_PB1MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB1MFP_ACMP3_P0 (0x01UL << NUMAKER_SYS_GPB_MFP0_PB1MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB1MFP_EBI_ADR8 (0x02UL << NUMAKER_SYS_GPB_MFP0_PB1MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB1MFP_SD0_CLK (0x03UL << NUMAKER_SYS_GPB_MFP0_PB1MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB1MFP_EMAC0_RMII_RXERR (0x04UL << NUMAKER_SYS_GPB_MFP0_PB1MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB1MFP_SPI1_I2SMCLK (0x05UL << NUMAKER_SYS_GPB_MFP0_PB1MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB1MFP_SPI3_I2SMCLK (0x06UL << NUMAKER_SYS_GPB_MFP0_PB1MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB1MFP_UART2_TXD (0x07UL << NUMAKER_SYS_GPB_MFP0_PB1MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB1MFP_I2C1_SCL (0x09UL << NUMAKER_SYS_GPB_MFP0_PB1MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB1MFP_I2S0_LRCK (0x0aUL << NUMAKER_SYS_GPB_MFP0_PB1MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB1MFP_EPWM0_CH4 (0x0bUL << NUMAKER_SYS_GPB_MFP0_PB1MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB1MFP_EPWM1_CH4 (0x0cUL << NUMAKER_SYS_GPB_MFP0_PB1MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB1MFP_EPWM0_BRAKE0 (0x0dUL << NUMAKER_SYS_GPB_MFP0_PB1MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB1MFP_ACMP2_O (0x0eUL << NUMAKER_SYS_GPB_MFP0_PB1MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB1MFP_QSPI0_MISO1 (0x0fUL << NUMAKER_SYS_GPB_MFP0_PB1MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB1MFP_KPI_ROW2 (0x12UL << NUMAKER_SYS_GPB_MFP0_PB1MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB1MFP_SPI4_MISO (0x13UL << NUMAKER_SYS_GPB_MFP0_PB1MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB1MFP_BMC4 (0x14UL << NUMAKER_SYS_GPB_MFP0_PB1MFP_Pos) + +/* PB.2 MFP */ +#define NUMAKER_SYS_GPB_MFP0_PB2MFP_GPIO (0x00UL << NUMAKER_SYS_GPB_MFP0_PB2MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB2MFP_EADC0_CH2 (0x01UL << NUMAKER_SYS_GPB_MFP0_PB2MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB2MFP_EADC1_CH10 (0x01UL << NUMAKER_SYS_GPB_MFP0_PB2MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB2MFP_ACMP0_P1 (0x01UL << NUMAKER_SYS_GPB_MFP0_PB2MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB2MFP_EBI_ADR3 (0x02UL << NUMAKER_SYS_GPB_MFP0_PB2MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB2MFP_SD0_DAT0 (0x03UL << NUMAKER_SYS_GPB_MFP0_PB2MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB2MFP_EMAC0_RMII_CRSDV (0x04UL << NUMAKER_SYS_GPB_MFP0_PB2MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB2MFP_SPI1_SS (0x05UL << NUMAKER_SYS_GPB_MFP0_PB2MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB2MFP_UART1_RXD (0x06UL << NUMAKER_SYS_GPB_MFP0_PB2MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB2MFP_UART5_nCTS (0x07UL << NUMAKER_SYS_GPB_MFP0_PB2MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB2MFP_SC0_PWR (0x09UL << NUMAKER_SYS_GPB_MFP0_PB2MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB2MFP_I2S0_DO (0x0aUL << NUMAKER_SYS_GPB_MFP0_PB2MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB2MFP_EPWM0_CH3 (0x0bUL << NUMAKER_SYS_GPB_MFP0_PB2MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB2MFP_I2C1_SDA (0x0cUL << NUMAKER_SYS_GPB_MFP0_PB2MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB2MFP_TM3 (0x0eUL << NUMAKER_SYS_GPB_MFP0_PB2MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB2MFP_INT3 (0x0fUL << NUMAKER_SYS_GPB_MFP0_PB2MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB2MFP_PSIO0_CH7 (0x11UL << NUMAKER_SYS_GPB_MFP0_PB2MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB2MFP_KPI_ROW1 (0x12UL << NUMAKER_SYS_GPB_MFP0_PB2MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB2MFP_SPI4_CLK (0x13UL << NUMAKER_SYS_GPB_MFP0_PB2MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB2MFP_BMC3 (0x14UL << NUMAKER_SYS_GPB_MFP0_PB2MFP_Pos) + +/* PB.3 MFP */ +#define NUMAKER_SYS_GPB_MFP0_PB3MFP_GPIO (0x00UL << NUMAKER_SYS_GPB_MFP0_PB3MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB3MFP_EADC0_CH3 (0x01UL << NUMAKER_SYS_GPB_MFP0_PB3MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB3MFP_EADC1_CH11 (0x01UL << NUMAKER_SYS_GPB_MFP0_PB3MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB3MFP_ACMP0_N (0x01UL << NUMAKER_SYS_GPB_MFP0_PB3MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB3MFP_EBI_ADR2 (0x02UL << NUMAKER_SYS_GPB_MFP0_PB3MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB3MFP_SD0_DAT1 (0x03UL << NUMAKER_SYS_GPB_MFP0_PB3MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB3MFP_EMAC0_RMII_RXD1 (0x04UL << NUMAKER_SYS_GPB_MFP0_PB3MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB3MFP_SPI1_CLK (0x05UL << NUMAKER_SYS_GPB_MFP0_PB3MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB3MFP_UART1_TXD (0x06UL << NUMAKER_SYS_GPB_MFP0_PB3MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB3MFP_UART5_nRTS (0x07UL << NUMAKER_SYS_GPB_MFP0_PB3MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB3MFP_SC0_RST (0x09UL << NUMAKER_SYS_GPB_MFP0_PB3MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB3MFP_I2S0_DI (0x0aUL << NUMAKER_SYS_GPB_MFP0_PB3MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB3MFP_EPWM0_CH2 (0x0bUL << NUMAKER_SYS_GPB_MFP0_PB3MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB3MFP_I2C1_SCL (0x0cUL << NUMAKER_SYS_GPB_MFP0_PB3MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB3MFP_TM2 (0x0eUL << NUMAKER_SYS_GPB_MFP0_PB3MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB3MFP_INT2 (0x0fUL << NUMAKER_SYS_GPB_MFP0_PB3MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB3MFP_PSIO0_CH6 (0x11UL << NUMAKER_SYS_GPB_MFP0_PB3MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB3MFP_KPI_ROW0 (0x12UL << NUMAKER_SYS_GPB_MFP0_PB3MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB3MFP_SPI4_SS (0x13UL << NUMAKER_SYS_GPB_MFP0_PB3MFP_Pos) +#define NUMAKER_SYS_GPB_MFP0_PB3MFP_BMC2 (0x14UL << NUMAKER_SYS_GPB_MFP0_PB3MFP_Pos) + +/* PB.4 MFP */ +#define NUMAKER_SYS_GPB_MFP1_PB4MFP_GPIO (0x00UL << NUMAKER_SYS_GPB_MFP1_PB4MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB4MFP_EADC0_CH4 (0x01UL << NUMAKER_SYS_GPB_MFP1_PB4MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB4MFP_ACMP1_P1 (0x01UL << NUMAKER_SYS_GPB_MFP1_PB4MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB4MFP_EBI_ADR1 (0x02UL << NUMAKER_SYS_GPB_MFP1_PB4MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB4MFP_SD0_DAT2 (0x03UL << NUMAKER_SYS_GPB_MFP1_PB4MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB4MFP_EMAC0_RMII_RXD0 (0x04UL << NUMAKER_SYS_GPB_MFP1_PB4MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB4MFP_SPI1_MOSI (0x05UL << NUMAKER_SYS_GPB_MFP1_PB4MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB4MFP_I2C0_SDA (0x06UL << NUMAKER_SYS_GPB_MFP1_PB4MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB4MFP_UART5_RXD (0x07UL << NUMAKER_SYS_GPB_MFP1_PB4MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB4MFP_SC0_DAT (0x09UL << NUMAKER_SYS_GPB_MFP1_PB4MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB4MFP_I2S0_MCLK (0x0aUL << NUMAKER_SYS_GPB_MFP1_PB4MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB4MFP_EPWM0_CH1 (0x0bUL << NUMAKER_SYS_GPB_MFP1_PB4MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB4MFP_UART2_RXD (0x0cUL << NUMAKER_SYS_GPB_MFP1_PB4MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB4MFP_TM1 (0x0eUL << NUMAKER_SYS_GPB_MFP1_PB4MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB4MFP_INT1 (0x0fUL << NUMAKER_SYS_GPB_MFP1_PB4MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB4MFP_PSIO0_CH5 (0x11UL << NUMAKER_SYS_GPB_MFP1_PB4MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB4MFP_KPI_COL7 (0x12UL << NUMAKER_SYS_GPB_MFP1_PB4MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB4MFP_BMC1 (0x14UL << NUMAKER_SYS_GPB_MFP1_PB4MFP_Pos) + +/* PB.5 MFP */ +#define NUMAKER_SYS_GPB_MFP1_PB5MFP_GPIO (0x00UL << NUMAKER_SYS_GPB_MFP1_PB5MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB5MFP_EADC0_CH5 (0x01UL << NUMAKER_SYS_GPB_MFP1_PB5MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB5MFP_ACMP1_N (0x01UL << NUMAKER_SYS_GPB_MFP1_PB5MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB5MFP_EBI_ADR0 (0x02UL << NUMAKER_SYS_GPB_MFP1_PB5MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB5MFP_SD0_DAT3 (0x03UL << NUMAKER_SYS_GPB_MFP1_PB5MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB5MFP_EMAC0_RMII_REFCLK (0x04UL << NUMAKER_SYS_GPB_MFP1_PB5MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB5MFP_SPI1_MISO (0x05UL << NUMAKER_SYS_GPB_MFP1_PB5MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB5MFP_I2C0_SCL (0x06UL << NUMAKER_SYS_GPB_MFP1_PB5MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB5MFP_UART5_TXD (0x07UL << NUMAKER_SYS_GPB_MFP1_PB5MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB5MFP_SC0_CLK (0x09UL << NUMAKER_SYS_GPB_MFP1_PB5MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB5MFP_I2S0_BCLK (0x0aUL << NUMAKER_SYS_GPB_MFP1_PB5MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB5MFP_EPWM0_CH0 (0x0bUL << NUMAKER_SYS_GPB_MFP1_PB5MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB5MFP_UART2_TXD (0x0cUL << NUMAKER_SYS_GPB_MFP1_PB5MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB5MFP_TM0 (0x0eUL << NUMAKER_SYS_GPB_MFP1_PB5MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB5MFP_INT0 (0x0fUL << NUMAKER_SYS_GPB_MFP1_PB5MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB5MFP_PSIO0_CH4 (0x11UL << NUMAKER_SYS_GPB_MFP1_PB5MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB5MFP_KPI_COL6 (0x12UL << NUMAKER_SYS_GPB_MFP1_PB5MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB5MFP_BMC0 (0x14UL << NUMAKER_SYS_GPB_MFP1_PB5MFP_Pos) + +/* PB.6 MFP */ +#define NUMAKER_SYS_GPB_MFP1_PB6MFP_GPIO (0x00UL << NUMAKER_SYS_GPB_MFP1_PB6MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB6MFP_EADC0_CH6 (0x01UL << NUMAKER_SYS_GPB_MFP1_PB6MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB6MFP_EADC2_CH14 (0x01UL << NUMAKER_SYS_GPB_MFP1_PB6MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB6MFP_ACMP2_N (0x01UL << NUMAKER_SYS_GPB_MFP1_PB6MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB6MFP_EBI_nWRH (0x02UL << NUMAKER_SYS_GPB_MFP1_PB6MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB6MFP_EMAC0_PPS (0x03UL << NUMAKER_SYS_GPB_MFP1_PB6MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB6MFP_CAN1_RXD (0x05UL << NUMAKER_SYS_GPB_MFP1_PB6MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB6MFP_UART1_RXD (0x06UL << NUMAKER_SYS_GPB_MFP1_PB6MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB6MFP_SD1_CLK (0x07UL << NUMAKER_SYS_GPB_MFP1_PB6MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB6MFP_EBI_nCS1 (0x08UL << NUMAKER_SYS_GPB_MFP1_PB6MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB6MFP_BPWM1_CH5 (0x0aUL << NUMAKER_SYS_GPB_MFP1_PB6MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB6MFP_EPWM1_BRAKE1 (0x0bUL << NUMAKER_SYS_GPB_MFP1_PB6MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB6MFP_EPWM1_CH5 (0x0cUL << NUMAKER_SYS_GPB_MFP1_PB6MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB6MFP_INT4 (0x0dUL << NUMAKER_SYS_GPB_MFP1_PB6MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB6MFP_USB_VBUS_EN (0x0eUL << NUMAKER_SYS_GPB_MFP1_PB6MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB6MFP_ACMP1_O (0x0fUL << NUMAKER_SYS_GPB_MFP1_PB6MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB6MFP_SPI3_MOSI (0x10UL << NUMAKER_SYS_GPB_MFP1_PB6MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB6MFP_KPI_COL5 (0x12UL << NUMAKER_SYS_GPB_MFP1_PB6MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB6MFP_SPI1_SS (0x13UL << NUMAKER_SYS_GPB_MFP1_PB6MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB6MFP_BMC31 (0x14UL << NUMAKER_SYS_GPB_MFP1_PB6MFP_Pos) + +/* PB.7 MFP */ +#define NUMAKER_SYS_GPB_MFP1_PB7MFP_GPIO (0x00UL << NUMAKER_SYS_GPB_MFP1_PB7MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB7MFP_EADC0_CH7 (0x01UL << NUMAKER_SYS_GPB_MFP1_PB7MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB7MFP_EADC2_CH15 (0x01UL << NUMAKER_SYS_GPB_MFP1_PB7MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB7MFP_ACMP2_P0 (0x01UL << NUMAKER_SYS_GPB_MFP1_PB7MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB7MFP_EBI_nWRL (0x02UL << NUMAKER_SYS_GPB_MFP1_PB7MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB7MFP_EMAC0_RMII_TXEN (0x03UL << NUMAKER_SYS_GPB_MFP1_PB7MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB7MFP_CAN1_TXD (0x05UL << NUMAKER_SYS_GPB_MFP1_PB7MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB7MFP_UART1_TXD (0x06UL << NUMAKER_SYS_GPB_MFP1_PB7MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB7MFP_SD1_CMD (0x07UL << NUMAKER_SYS_GPB_MFP1_PB7MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB7MFP_EBI_nCS0 (0x08UL << NUMAKER_SYS_GPB_MFP1_PB7MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB7MFP_BPWM1_CH4 (0x0aUL << NUMAKER_SYS_GPB_MFP1_PB7MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB7MFP_EPWM1_BRAKE0 (0x0bUL << NUMAKER_SYS_GPB_MFP1_PB7MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB7MFP_EPWM1_CH4 (0x0cUL << NUMAKER_SYS_GPB_MFP1_PB7MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB7MFP_INT5 (0x0dUL << NUMAKER_SYS_GPB_MFP1_PB7MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB7MFP_USB_VBUS_ST (0x0eUL << NUMAKER_SYS_GPB_MFP1_PB7MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB7MFP_ACMP0_O (0x0fUL << NUMAKER_SYS_GPB_MFP1_PB7MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB7MFP_SPI3_MISO (0x10UL << NUMAKER_SYS_GPB_MFP1_PB7MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB7MFP_KPI_COL4 (0x12UL << NUMAKER_SYS_GPB_MFP1_PB7MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB7MFP_SPI1_CLK (0x13UL << NUMAKER_SYS_GPB_MFP1_PB7MFP_Pos) +#define NUMAKER_SYS_GPB_MFP1_PB7MFP_BMC30 (0x14UL << NUMAKER_SYS_GPB_MFP1_PB7MFP_Pos) + +/* PB.8 MFP */ +#define NUMAKER_SYS_GPB_MFP2_PB8MFP_GPIO (0x00UL << NUMAKER_SYS_GPB_MFP2_PB8MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB8MFP_EADC0_CH8 (0x01UL << NUMAKER_SYS_GPB_MFP2_PB8MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB8MFP_ACMP2_P1 (0x01UL << NUMAKER_SYS_GPB_MFP2_PB8MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB8MFP_EBI_ADR19 (0x02UL << NUMAKER_SYS_GPB_MFP2_PB8MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB8MFP_EMAC0_RMII_TXD1 (0x03UL << NUMAKER_SYS_GPB_MFP2_PB8MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB8MFP_UART0_RXD (0x05UL << NUMAKER_SYS_GPB_MFP2_PB8MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB8MFP_UART1_nRTS (0x06UL << NUMAKER_SYS_GPB_MFP2_PB8MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB8MFP_I2C1_SMBSUS (0x07UL << NUMAKER_SYS_GPB_MFP2_PB8MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB8MFP_UART7_RXD (0x08UL << NUMAKER_SYS_GPB_MFP2_PB8MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB8MFP_I2C0_SDA (0x09UL << NUMAKER_SYS_GPB_MFP2_PB8MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB8MFP_BPWM1_CH3 (0x0aUL << NUMAKER_SYS_GPB_MFP2_PB8MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB8MFP_SPI3_MOSI (0x0bUL << NUMAKER_SYS_GPB_MFP2_PB8MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB8MFP_CAN2_RXD (0x0cUL << NUMAKER_SYS_GPB_MFP2_PB8MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB8MFP_INT6 (0x0dUL << NUMAKER_SYS_GPB_MFP2_PB8MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB8MFP_EADC2_ST (0x0eUL << NUMAKER_SYS_GPB_MFP2_PB8MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB8MFP_BMC23 (0x14UL << NUMAKER_SYS_GPB_MFP2_PB8MFP_Pos) + +/* PB.9 MFP */ +#define NUMAKER_SYS_GPB_MFP2_PB9MFP_GPIO (0x00UL << NUMAKER_SYS_GPB_MFP2_PB9MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB9MFP_EADC0_CH9 (0x01UL << NUMAKER_SYS_GPB_MFP2_PB9MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB9MFP_ACMP2_P2 (0x01UL << NUMAKER_SYS_GPB_MFP2_PB9MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB9MFP_EBI_ADR18 (0x02UL << NUMAKER_SYS_GPB_MFP2_PB9MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB9MFP_EMAC0_RMII_TXD0 (0x03UL << NUMAKER_SYS_GPB_MFP2_PB9MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB9MFP_UART0_TXD (0x05UL << NUMAKER_SYS_GPB_MFP2_PB9MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB9MFP_UART1_nCTS (0x06UL << NUMAKER_SYS_GPB_MFP2_PB9MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB9MFP_I2C1_SMBAL (0x07UL << NUMAKER_SYS_GPB_MFP2_PB9MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB9MFP_UART7_TXD (0x08UL << NUMAKER_SYS_GPB_MFP2_PB9MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB9MFP_I2C0_SCL (0x09UL << NUMAKER_SYS_GPB_MFP2_PB9MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB9MFP_BPWM1_CH2 (0x0aUL << NUMAKER_SYS_GPB_MFP2_PB9MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB9MFP_SPI3_MISO (0x0bUL << NUMAKER_SYS_GPB_MFP2_PB9MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB9MFP_CAN2_TXD (0x0cUL << NUMAKER_SYS_GPB_MFP2_PB9MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB9MFP_INT7 (0x0dUL << NUMAKER_SYS_GPB_MFP2_PB9MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB9MFP_CCAP_HSYNC (0x0eUL << NUMAKER_SYS_GPB_MFP2_PB9MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB9MFP_BMC22 (0x14UL << NUMAKER_SYS_GPB_MFP2_PB9MFP_Pos) + +/* PB.10 MFP */ +#define NUMAKER_SYS_GPB_MFP2_PB10MFP_GPIO (0x00UL << NUMAKER_SYS_GPB_MFP2_PB10MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB10MFP_EADC0_CH10 (0x01UL << NUMAKER_SYS_GPB_MFP2_PB10MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB10MFP_ACMP2_P3 (0x01UL << NUMAKER_SYS_GPB_MFP2_PB10MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB10MFP_EBI_ADR17 (0x02UL << NUMAKER_SYS_GPB_MFP2_PB10MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB10MFP_EMAC0_RMII_MDIO (0x03UL << NUMAKER_SYS_GPB_MFP2_PB10MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB10MFP_UART0_nRTS (0x05UL << NUMAKER_SYS_GPB_MFP2_PB10MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB10MFP_UART4_RXD (0x06UL << NUMAKER_SYS_GPB_MFP2_PB10MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB10MFP_I2C1_SDA (0x07UL << NUMAKER_SYS_GPB_MFP2_PB10MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB10MFP_CAN0_RXD (0x08UL << NUMAKER_SYS_GPB_MFP2_PB10MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB10MFP_BPWM1_CH1 (0x0aUL << NUMAKER_SYS_GPB_MFP2_PB10MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB10MFP_SPI3_SS (0x0bUL << NUMAKER_SYS_GPB_MFP2_PB10MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB10MFP_CCAP_VSYNC (0x0cUL << NUMAKER_SYS_GPB_MFP2_PB10MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB10MFP_HSUSB_VBUS_EN (0x0eUL << NUMAKER_SYS_GPB_MFP2_PB10MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB10MFP_BMC21 (0x14UL << NUMAKER_SYS_GPB_MFP2_PB10MFP_Pos) + +/* PB.11 MFP */ +#define NUMAKER_SYS_GPB_MFP2_PB11MFP_GPIO (0x00UL << NUMAKER_SYS_GPB_MFP2_PB11MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB11MFP_EADC0_CH11 (0x01UL << NUMAKER_SYS_GPB_MFP2_PB11MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB11MFP_EBI_ADR16 (0x02UL << NUMAKER_SYS_GPB_MFP2_PB11MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB11MFP_EMAC0_RMII_MDC (0x03UL << NUMAKER_SYS_GPB_MFP2_PB11MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB11MFP_UART0_nCTS (0x05UL << NUMAKER_SYS_GPB_MFP2_PB11MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB11MFP_UART4_TXD (0x06UL << NUMAKER_SYS_GPB_MFP2_PB11MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB11MFP_I2C1_SCL (0x07UL << NUMAKER_SYS_GPB_MFP2_PB11MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB11MFP_CAN0_TXD (0x08UL << NUMAKER_SYS_GPB_MFP2_PB11MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB11MFP_SPI0_I2SMCLK (0x09UL << NUMAKER_SYS_GPB_MFP2_PB11MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB11MFP_BPWM1_CH0 (0x0aUL << NUMAKER_SYS_GPB_MFP2_PB11MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB11MFP_SPI3_CLK (0x0bUL << NUMAKER_SYS_GPB_MFP2_PB11MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB11MFP_CCAP_SFIELD (0x0cUL << NUMAKER_SYS_GPB_MFP2_PB11MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB11MFP_HSUSB_VBUS_ST (0x0eUL << NUMAKER_SYS_GPB_MFP2_PB11MFP_Pos) +#define NUMAKER_SYS_GPB_MFP2_PB11MFP_BMC20 (0x14UL << NUMAKER_SYS_GPB_MFP2_PB11MFP_Pos) + +/* PB.12 MFP */ +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_GPIO (0x00UL << NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_EADC0_CH12 (0x01UL << NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_EADC1_CH12 (0x01UL << NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_DAC0_OUT (0x01UL << NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_ACMP0_P2 (0x01UL << NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_ACMP1_P2 (0x01UL << NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_EBI_AD15 (0x02UL << NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_SC1_CLK (0x03UL << NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_SPI0_MOSI (0x04UL << NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_USCI0_CLK (0x05UL << NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_UART0_RXD (0x06UL << NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_UART3_nCTS (0x07UL << NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_I2C2_SDA (0x08UL << NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_SD0_nCD (0x09UL << NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_CCAP_SCLK (0x0aUL << NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_EPWM1_CH3 (0x0bUL << NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_ETMC_TRACE_DATA3 (0x0cUL << NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_TM3_EXT (0x0dUL << NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_CAN3_RXD (0x0eUL << NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_SPI3_SS (0x10UL << NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_PSIO0_CH3 (0x11UL << NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_KPI_COL3 (0x12UL << NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB12MFP_BMC29 (0x14UL << NUMAKER_SYS_GPB_MFP3_PB12MFP_Pos) + +/* PB.13 MFP */ +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_GPIO (0x00UL << NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_EADC0_CH13 (0x01UL << NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_EADC1_CH13 (0x01UL << NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_DAC1_OUT (0x01UL << NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_ACMP0_P3 (0x01UL << NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_ACMP1_P3 (0x01UL << NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_EBI_AD14 (0x02UL << NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_SC1_DAT (0x03UL << NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_SPI0_MISO (0x04UL << NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_USCI0_DAT0 (0x05UL << NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_UART0_TXD (0x06UL << NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_UART3_nRTS (0x07UL << NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_I2C2_SCL (0x08UL << NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_CCAP_PIXCLK (0x0aUL << NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_EPWM1_CH2 (0x0bUL << NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_ETMC_TRACE_DATA2 (0x0cUL << NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_TM2_EXT (0x0dUL << NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_CAN3_TXD (0x0eUL << NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_SPI3_CLK (0x10UL << NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_PSIO0_CH2 (0x11UL << NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_KPI_COL2 (0x12UL << NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_SPI9_MISO (0x13UL << NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB13MFP_BMC28 (0x14UL << NUMAKER_SYS_GPB_MFP3_PB13MFP_Pos) + +/* PB.14 MFP */ +#define NUMAKER_SYS_GPB_MFP3_PB14MFP_GPIO (0x00UL << NUMAKER_SYS_GPB_MFP3_PB14MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB14MFP_EADC0_CH14 (0x01UL << NUMAKER_SYS_GPB_MFP3_PB14MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB14MFP_EADC1_CH14 (0x01UL << NUMAKER_SYS_GPB_MFP3_PB14MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB14MFP_EBI_AD13 (0x02UL << NUMAKER_SYS_GPB_MFP3_PB14MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB14MFP_SC1_RST (0x03UL << NUMAKER_SYS_GPB_MFP3_PB14MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB14MFP_SPI0_CLK (0x04UL << NUMAKER_SYS_GPB_MFP3_PB14MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB14MFP_USCI0_DAT1 (0x05UL << NUMAKER_SYS_GPB_MFP3_PB14MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB14MFP_UART0_nRTS (0x06UL << NUMAKER_SYS_GPB_MFP3_PB14MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB14MFP_UART3_RXD (0x07UL << NUMAKER_SYS_GPB_MFP3_PB14MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB14MFP_I2C2_SMBSUS (0x08UL << NUMAKER_SYS_GPB_MFP3_PB14MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB14MFP_CCAP_DATA0 (0x09UL << NUMAKER_SYS_GPB_MFP3_PB14MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB14MFP_EPWM1_CH1 (0x0bUL << NUMAKER_SYS_GPB_MFP3_PB14MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB14MFP_ETMC_TRACE_DATA1 (0x0cUL << NUMAKER_SYS_GPB_MFP3_PB14MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB14MFP_TM1_EXT (0x0dUL << NUMAKER_SYS_GPB_MFP3_PB14MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB14MFP_CLKO (0x0eUL << NUMAKER_SYS_GPB_MFP3_PB14MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB14MFP_USB_VBUS_ST (0x0fUL << NUMAKER_SYS_GPB_MFP3_PB14MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB14MFP_PSIO0_CH1 (0x11UL << NUMAKER_SYS_GPB_MFP3_PB14MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB14MFP_KPI_COL1 (0x12UL << NUMAKER_SYS_GPB_MFP3_PB14MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB14MFP_SPI9_SS (0x13UL << NUMAKER_SYS_GPB_MFP3_PB14MFP_Pos) + +/* PB.15 MFP */ +#define NUMAKER_SYS_GPB_MFP3_PB15MFP_GPIO (0x00UL << NUMAKER_SYS_GPB_MFP3_PB15MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB15MFP_EADC0_CH15 (0x01UL << NUMAKER_SYS_GPB_MFP3_PB15MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB15MFP_EADC1_CH15 (0x01UL << NUMAKER_SYS_GPB_MFP3_PB15MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB15MFP_EBI_AD12 (0x02UL << NUMAKER_SYS_GPB_MFP3_PB15MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB15MFP_SC1_PWR (0x03UL << NUMAKER_SYS_GPB_MFP3_PB15MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB15MFP_SPI0_SS (0x04UL << NUMAKER_SYS_GPB_MFP3_PB15MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB15MFP_USCI0_CTL1 (0x05UL << NUMAKER_SYS_GPB_MFP3_PB15MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB15MFP_UART0_nCTS (0x06UL << NUMAKER_SYS_GPB_MFP3_PB15MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB15MFP_UART3_TXD (0x07UL << NUMAKER_SYS_GPB_MFP3_PB15MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB15MFP_I2C2_SMBAL (0x08UL << NUMAKER_SYS_GPB_MFP3_PB15MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB15MFP_CCAP_DATA1 (0x09UL << NUMAKER_SYS_GPB_MFP3_PB15MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB15MFP_EPWM0_BRAKE1 (0x0aUL << NUMAKER_SYS_GPB_MFP3_PB15MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB15MFP_EPWM1_CH0 (0x0bUL << NUMAKER_SYS_GPB_MFP3_PB15MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB15MFP_ETMC_TRACE_DATA0 (0x0cUL << NUMAKER_SYS_GPB_MFP3_PB15MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB15MFP_TM0_EXT (0x0dUL << NUMAKER_SYS_GPB_MFP3_PB15MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB15MFP_USB_VBUS_EN (0x0eUL << NUMAKER_SYS_GPB_MFP3_PB15MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB15MFP_HSUSB_VBUS_EN (0x0fUL << NUMAKER_SYS_GPB_MFP3_PB15MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB15MFP_PSIO0_CH0 (0x11UL << NUMAKER_SYS_GPB_MFP3_PB15MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB15MFP_KPI_COL0 (0x12UL << NUMAKER_SYS_GPB_MFP3_PB15MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB15MFP_SPI9_CLK (0x13UL << NUMAKER_SYS_GPB_MFP3_PB15MFP_Pos) +#define NUMAKER_SYS_GPB_MFP3_PB15MFP_BMC27 (0x14UL << NUMAKER_SYS_GPB_MFP3_PB15MFP_Pos) + +/* PC.0 MFP */ +#define NUMAKER_SYS_GPC_MFP0_PC0MFP_GPIO (0x00UL << NUMAKER_SYS_GPC_MFP0_PC0MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC0MFP_EBI_AD0 (0x02UL << NUMAKER_SYS_GPC_MFP0_PC0MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC0MFP_SPIM_MOSI (0x03UL << NUMAKER_SYS_GPC_MFP0_PC0MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC0MFP_QSPI0_MOSI0 (0x04UL << NUMAKER_SYS_GPC_MFP0_PC0MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC0MFP_SC1_CLK (0x05UL << NUMAKER_SYS_GPC_MFP0_PC0MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC0MFP_I2S0_LRCK (0x06UL << NUMAKER_SYS_GPC_MFP0_PC0MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC0MFP_SPI1_SS (0x07UL << NUMAKER_SYS_GPC_MFP0_PC0MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC0MFP_UART2_RXD (0x08UL << NUMAKER_SYS_GPC_MFP0_PC0MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC0MFP_I2C0_SDA (0x09UL << NUMAKER_SYS_GPC_MFP0_PC0MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC0MFP_CAN2_RXD (0x0aUL << NUMAKER_SYS_GPC_MFP0_PC0MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC0MFP_EPWM1_CH5 (0x0cUL << NUMAKER_SYS_GPC_MFP0_PC0MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC0MFP_CCAP_DATA0 (0x0dUL << NUMAKER_SYS_GPC_MFP0_PC0MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC0MFP_ACMP1_O (0x0eUL << NUMAKER_SYS_GPC_MFP0_PC0MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC0MFP_EADC1_ST (0x0fUL << NUMAKER_SYS_GPC_MFP0_PC0MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC0MFP_HBI_D2 (0x10UL << NUMAKER_SYS_GPC_MFP0_PC0MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC0MFP_QSPI1_CLK (0x11UL << NUMAKER_SYS_GPC_MFP0_PC0MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC0MFP_KPI_ROW5 (0x12UL << NUMAKER_SYS_GPC_MFP0_PC0MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC0MFP_SPI7_MOSI (0x13UL << NUMAKER_SYS_GPC_MFP0_PC0MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC0MFP_BMC25 (0x14UL << NUMAKER_SYS_GPC_MFP0_PC0MFP_Pos) + +/* PC.1 MFP */ +#define NUMAKER_SYS_GPC_MFP0_PC1MFP_GPIO (0x00UL << NUMAKER_SYS_GPC_MFP0_PC1MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC1MFP_EBI_AD1 (0x02UL << NUMAKER_SYS_GPC_MFP0_PC1MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC1MFP_SPIM_MISO (0x03UL << NUMAKER_SYS_GPC_MFP0_PC1MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC1MFP_QSPI0_MISO0 (0x04UL << NUMAKER_SYS_GPC_MFP0_PC1MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC1MFP_SC1_DAT (0x05UL << NUMAKER_SYS_GPC_MFP0_PC1MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC1MFP_I2S0_DO (0x06UL << NUMAKER_SYS_GPC_MFP0_PC1MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC1MFP_SPI1_CLK (0x07UL << NUMAKER_SYS_GPC_MFP0_PC1MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC1MFP_UART2_TXD (0x08UL << NUMAKER_SYS_GPC_MFP0_PC1MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC1MFP_I2C0_SCL (0x09UL << NUMAKER_SYS_GPC_MFP0_PC1MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC1MFP_CAN2_TXD (0x0aUL << NUMAKER_SYS_GPC_MFP0_PC1MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC1MFP_EPWM1_CH4 (0x0cUL << NUMAKER_SYS_GPC_MFP0_PC1MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC1MFP_CCAP_DATA1 (0x0dUL << NUMAKER_SYS_GPC_MFP0_PC1MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC1MFP_ACMP0_O (0x0eUL << NUMAKER_SYS_GPC_MFP0_PC1MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC1MFP_EADC0_ST (0x0fUL << NUMAKER_SYS_GPC_MFP0_PC1MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC1MFP_HBI_RWDS (0x10UL << NUMAKER_SYS_GPC_MFP0_PC1MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC1MFP_QSPI1_SS (0x11UL << NUMAKER_SYS_GPC_MFP0_PC1MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC1MFP_KPI_ROW4 (0x12UL << NUMAKER_SYS_GPC_MFP0_PC1MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC1MFP_SPI7_MISO (0x13UL << NUMAKER_SYS_GPC_MFP0_PC1MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC1MFP_BMC24 (0x14UL << NUMAKER_SYS_GPC_MFP0_PC1MFP_Pos) + +/* PC.2 MFP */ +#define NUMAKER_SYS_GPC_MFP0_PC2MFP_GPIO (0x00UL << NUMAKER_SYS_GPC_MFP0_PC2MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC2MFP_EBI_AD2 (0x02UL << NUMAKER_SYS_GPC_MFP0_PC2MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC2MFP_SPIM_CLK (0x03UL << NUMAKER_SYS_GPC_MFP0_PC2MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC2MFP_QSPI0_CLK (0x04UL << NUMAKER_SYS_GPC_MFP0_PC2MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC2MFP_SC1_RST (0x05UL << NUMAKER_SYS_GPC_MFP0_PC2MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC2MFP_I2S0_DI (0x06UL << NUMAKER_SYS_GPC_MFP0_PC2MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC2MFP_SPI1_MOSI (0x07UL << NUMAKER_SYS_GPC_MFP0_PC2MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC2MFP_UART2_nCTS (0x08UL << NUMAKER_SYS_GPC_MFP0_PC2MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC2MFP_I2C0_SMBSUS (0x09UL << NUMAKER_SYS_GPC_MFP0_PC2MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC2MFP_CAN1_RXD (0x0aUL << NUMAKER_SYS_GPC_MFP0_PC2MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC2MFP_UART3_RXD (0x0bUL << NUMAKER_SYS_GPC_MFP0_PC2MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC2MFP_EPWM1_CH3 (0x0cUL << NUMAKER_SYS_GPC_MFP0_PC2MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC2MFP_CCAP_DATA2 (0x0dUL << NUMAKER_SYS_GPC_MFP0_PC2MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC2MFP_QSPI1_MOSI0 (0x0eUL << NUMAKER_SYS_GPC_MFP0_PC2MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC2MFP_I2C3_SDA (0x0fUL << NUMAKER_SYS_GPC_MFP0_PC2MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC2MFP_HBI_nRESET (0x10UL << NUMAKER_SYS_GPC_MFP0_PC2MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC2MFP_PSIO0_CH3 (0x11UL << NUMAKER_SYS_GPC_MFP0_PC2MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC2MFP_KPI_ROW3 (0x12UL << NUMAKER_SYS_GPC_MFP0_PC2MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC2MFP_SPI7_CLK (0x13UL << NUMAKER_SYS_GPC_MFP0_PC2MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC2MFP_BMC23 (0x14UL << NUMAKER_SYS_GPC_MFP0_PC2MFP_Pos) + +/* PC.3 MFP */ +#define NUMAKER_SYS_GPC_MFP0_PC3MFP_GPIO (0x00UL << NUMAKER_SYS_GPC_MFP0_PC3MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC3MFP_EBI_AD3 (0x02UL << NUMAKER_SYS_GPC_MFP0_PC3MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC3MFP_SPIM_SS (0x03UL << NUMAKER_SYS_GPC_MFP0_PC3MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC3MFP_QSPI0_SS (0x04UL << NUMAKER_SYS_GPC_MFP0_PC3MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC3MFP_SC1_PWR (0x05UL << NUMAKER_SYS_GPC_MFP0_PC3MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC3MFP_I2S0_MCLK (0x06UL << NUMAKER_SYS_GPC_MFP0_PC3MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC3MFP_SPI1_MISO (0x07UL << NUMAKER_SYS_GPC_MFP0_PC3MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC3MFP_UART2_nRTS (0x08UL << NUMAKER_SYS_GPC_MFP0_PC3MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC3MFP_I2C0_SMBAL (0x09UL << NUMAKER_SYS_GPC_MFP0_PC3MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC3MFP_CAN1_TXD (0x0aUL << NUMAKER_SYS_GPC_MFP0_PC3MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC3MFP_UART3_TXD (0x0bUL << NUMAKER_SYS_GPC_MFP0_PC3MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC3MFP_EPWM1_CH2 (0x0cUL << NUMAKER_SYS_GPC_MFP0_PC3MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC3MFP_CCAP_DATA3 (0x0dUL << NUMAKER_SYS_GPC_MFP0_PC3MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC3MFP_QSPI1_MISO0 (0x0eUL << NUMAKER_SYS_GPC_MFP0_PC3MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC3MFP_I2C3_SCL (0x0fUL << NUMAKER_SYS_GPC_MFP0_PC3MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC3MFP_HBI_nCS (0x10UL << NUMAKER_SYS_GPC_MFP0_PC3MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC3MFP_PSIO0_CH2 (0x11UL << NUMAKER_SYS_GPC_MFP0_PC3MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC3MFP_KPI_ROW2 (0x12UL << NUMAKER_SYS_GPC_MFP0_PC3MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC3MFP_SPI7_SS (0x13UL << NUMAKER_SYS_GPC_MFP0_PC3MFP_Pos) +#define NUMAKER_SYS_GPC_MFP0_PC3MFP_BMC22 (0x14UL << NUMAKER_SYS_GPC_MFP0_PC3MFP_Pos) + +/* PC.4 MFP */ +#define NUMAKER_SYS_GPC_MFP1_PC4MFP_GPIO (0x00UL << NUMAKER_SYS_GPC_MFP1_PC4MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC4MFP_EBI_AD4 (0x02UL << NUMAKER_SYS_GPC_MFP1_PC4MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC4MFP_SPIM_D3 (0x03UL << NUMAKER_SYS_GPC_MFP1_PC4MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC4MFP_QSPI0_MOSI1 (0x04UL << NUMAKER_SYS_GPC_MFP1_PC4MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC4MFP_SC1_nCD (0x05UL << NUMAKER_SYS_GPC_MFP1_PC4MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC4MFP_I2S0_BCLK (0x06UL << NUMAKER_SYS_GPC_MFP1_PC4MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC4MFP_SPI1_I2SMCLK (0x07UL << NUMAKER_SYS_GPC_MFP1_PC4MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC4MFP_UART2_RXD (0x08UL << NUMAKER_SYS_GPC_MFP1_PC4MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC4MFP_I2C1_SDA (0x09UL << NUMAKER_SYS_GPC_MFP1_PC4MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC4MFP_CAN0_RXD (0x0aUL << NUMAKER_SYS_GPC_MFP1_PC4MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC4MFP_UART4_RXD (0x0bUL << NUMAKER_SYS_GPC_MFP1_PC4MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC4MFP_EPWM1_CH1 (0x0cUL << NUMAKER_SYS_GPC_MFP1_PC4MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC4MFP_CCAP_DATA4 (0x0dUL << NUMAKER_SYS_GPC_MFP1_PC4MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC4MFP_QSPI1_CLK (0x0eUL << NUMAKER_SYS_GPC_MFP1_PC4MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC4MFP_I2C3_SMBSUS (0x0fUL << NUMAKER_SYS_GPC_MFP1_PC4MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC4MFP_HBI_CK (0x10UL << NUMAKER_SYS_GPC_MFP1_PC4MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC4MFP_PSIO0_CH1 (0x11UL << NUMAKER_SYS_GPC_MFP1_PC4MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC4MFP_KPI_ROW1 (0x12UL << NUMAKER_SYS_GPC_MFP1_PC4MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC4MFP_BMC21 (0x14UL << NUMAKER_SYS_GPC_MFP1_PC4MFP_Pos) + +/* PC.5 MFP */ +#define NUMAKER_SYS_GPC_MFP1_PC5MFP_GPIO (0x00UL << NUMAKER_SYS_GPC_MFP1_PC5MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC5MFP_EBI_AD5 (0x02UL << NUMAKER_SYS_GPC_MFP1_PC5MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC5MFP_SPIM_D2 (0x03UL << NUMAKER_SYS_GPC_MFP1_PC5MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC5MFP_QSPI0_MISO1 (0x04UL << NUMAKER_SYS_GPC_MFP1_PC5MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC5MFP_UART2_TXD (0x08UL << NUMAKER_SYS_GPC_MFP1_PC5MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC5MFP_I2C1_SCL (0x09UL << NUMAKER_SYS_GPC_MFP1_PC5MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC5MFP_CAN0_TXD (0x0aUL << NUMAKER_SYS_GPC_MFP1_PC5MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC5MFP_UART4_TXD (0x0bUL << NUMAKER_SYS_GPC_MFP1_PC5MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC5MFP_EPWM1_CH0 (0x0cUL << NUMAKER_SYS_GPC_MFP1_PC5MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC5MFP_CCAP_DATA5 (0x0dUL << NUMAKER_SYS_GPC_MFP1_PC5MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC5MFP_QSPI1_SS (0x0eUL << NUMAKER_SYS_GPC_MFP1_PC5MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC5MFP_I2C3_SMBAL (0x0fUL << NUMAKER_SYS_GPC_MFP1_PC5MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC5MFP_HBI_nCK (0x10UL << NUMAKER_SYS_GPC_MFP1_PC5MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC5MFP_PSIO0_CH0 (0x11UL << NUMAKER_SYS_GPC_MFP1_PC5MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC5MFP_KPI_ROW0 (0x12UL << NUMAKER_SYS_GPC_MFP1_PC5MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC5MFP_BMC20 (0x14UL << NUMAKER_SYS_GPC_MFP1_PC5MFP_Pos) + +/* PC.6 MFP */ +#define NUMAKER_SYS_GPC_MFP1_PC6MFP_GPIO (0x00UL << NUMAKER_SYS_GPC_MFP1_PC6MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC6MFP_EBI_AD8 (0x02UL << NUMAKER_SYS_GPC_MFP1_PC6MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC6MFP_EMAC0_RMII_RXD1 (0x03UL << NUMAKER_SYS_GPC_MFP1_PC6MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC6MFP_SPI1_MOSI (0x04UL << NUMAKER_SYS_GPC_MFP1_PC6MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC6MFP_UART4_RXD (0x05UL << NUMAKER_SYS_GPC_MFP1_PC6MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC6MFP_SC2_RST (0x06UL << NUMAKER_SYS_GPC_MFP1_PC6MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC6MFP_UART0_nRTS (0x07UL << NUMAKER_SYS_GPC_MFP1_PC6MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC6MFP_I2C1_SMBSUS (0x08UL << NUMAKER_SYS_GPC_MFP1_PC6MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC6MFP_UART6_RXD (0x09UL << NUMAKER_SYS_GPC_MFP1_PC6MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC6MFP_ACMP3_WLAT (0x0aUL << NUMAKER_SYS_GPC_MFP1_PC6MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC6MFP_EPWM1_CH3 (0x0bUL << NUMAKER_SYS_GPC_MFP1_PC6MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC6MFP_BPWM1_CH1 (0x0cUL << NUMAKER_SYS_GPC_MFP1_PC6MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC6MFP_CAN3_RXD (0x0dUL << NUMAKER_SYS_GPC_MFP1_PC6MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC6MFP_TM1 (0x0eUL << NUMAKER_SYS_GPC_MFP1_PC6MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC6MFP_INT2 (0x0fUL << NUMAKER_SYS_GPC_MFP1_PC6MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC6MFP_KPI_COL2 (0x12UL << NUMAKER_SYS_GPC_MFP1_PC6MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC6MFP_SPI6_MOSI (0x13UL << NUMAKER_SYS_GPC_MFP1_PC6MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC6MFP_BMC25 (0x14UL << NUMAKER_SYS_GPC_MFP1_PC6MFP_Pos) + +/* PC.7 MFP */ +#define NUMAKER_SYS_GPC_MFP1_PC7MFP_GPIO (0x00UL << NUMAKER_SYS_GPC_MFP1_PC7MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC7MFP_EBI_AD9 (0x02UL << NUMAKER_SYS_GPC_MFP1_PC7MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC7MFP_EMAC0_RMII_RXD0 (0x03UL << NUMAKER_SYS_GPC_MFP1_PC7MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC7MFP_SPI1_MISO (0x04UL << NUMAKER_SYS_GPC_MFP1_PC7MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC7MFP_UART4_TXD (0x05UL << NUMAKER_SYS_GPC_MFP1_PC7MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC7MFP_SC2_PWR (0x06UL << NUMAKER_SYS_GPC_MFP1_PC7MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC7MFP_UART0_nCTS (0x07UL << NUMAKER_SYS_GPC_MFP1_PC7MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC7MFP_I2C1_SMBAL (0x08UL << NUMAKER_SYS_GPC_MFP1_PC7MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC7MFP_UART6_TXD (0x09UL << NUMAKER_SYS_GPC_MFP1_PC7MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC7MFP_ACMP2_WLAT (0x0aUL << NUMAKER_SYS_GPC_MFP1_PC7MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC7MFP_EPWM1_CH2 (0x0bUL << NUMAKER_SYS_GPC_MFP1_PC7MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC7MFP_BPWM1_CH0 (0x0cUL << NUMAKER_SYS_GPC_MFP1_PC7MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC7MFP_CAN3_TXD (0x0dUL << NUMAKER_SYS_GPC_MFP1_PC7MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC7MFP_TM0 (0x0eUL << NUMAKER_SYS_GPC_MFP1_PC7MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC7MFP_INT3 (0x0fUL << NUMAKER_SYS_GPC_MFP1_PC7MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC7MFP_KPI_COL3 (0x12UL << NUMAKER_SYS_GPC_MFP1_PC7MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC7MFP_SPI6_MISO (0x13UL << NUMAKER_SYS_GPC_MFP1_PC7MFP_Pos) +#define NUMAKER_SYS_GPC_MFP1_PC7MFP_BMC24 (0x14UL << NUMAKER_SYS_GPC_MFP1_PC7MFP_Pos) + +/* PC.8 MFP */ +#define NUMAKER_SYS_GPC_MFP2_PC8MFP_GPIO (0x00UL << NUMAKER_SYS_GPC_MFP2_PC8MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC8MFP_EBI_ADR16 (0x02UL << NUMAKER_SYS_GPC_MFP2_PC8MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC8MFP_EMAC0_RMII_REFCLK (0x03UL << NUMAKER_SYS_GPC_MFP2_PC8MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC8MFP_I2C0_SDA (0x04UL << NUMAKER_SYS_GPC_MFP2_PC8MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC8MFP_UART4_nCTS (0x05UL << NUMAKER_SYS_GPC_MFP2_PC8MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC8MFP_UART1_RXD (0x08UL << NUMAKER_SYS_GPC_MFP2_PC8MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC8MFP_EPWM1_CH1 (0x0bUL << NUMAKER_SYS_GPC_MFP2_PC8MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC8MFP_BPWM1_CH4 (0x0cUL << NUMAKER_SYS_GPC_MFP2_PC8MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC8MFP_KPI_COL4 (0x12UL << NUMAKER_SYS_GPC_MFP2_PC8MFP_Pos) + +/* PC.9 MFP */ +#define NUMAKER_SYS_GPC_MFP2_PC9MFP_GPIO (0x00UL << NUMAKER_SYS_GPC_MFP2_PC9MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC9MFP_EADC2_CH10 (0x01UL << NUMAKER_SYS_GPC_MFP2_PC9MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC9MFP_ACMP3_P1 (0x01UL << NUMAKER_SYS_GPC_MFP2_PC9MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC9MFP_EBI_ADR7 (0x02UL << NUMAKER_SYS_GPC_MFP2_PC9MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC9MFP_UART6_nCTS (0x05UL << NUMAKER_SYS_GPC_MFP2_PC9MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC9MFP_SPI3_SS (0x06UL << NUMAKER_SYS_GPC_MFP2_PC9MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC9MFP_UART3_RXD (0x07UL << NUMAKER_SYS_GPC_MFP2_PC9MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC9MFP_CAN1_RXD (0x09UL << NUMAKER_SYS_GPC_MFP2_PC9MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC9MFP_I2C4_SMBSUS (0x0aUL << NUMAKER_SYS_GPC_MFP2_PC9MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC9MFP_EPWM1_CH3 (0x0cUL << NUMAKER_SYS_GPC_MFP2_PC9MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC9MFP_EADC1_ST (0x0eUL << NUMAKER_SYS_GPC_MFP2_PC9MFP_Pos) + +/* PC.10 MFP */ +#define NUMAKER_SYS_GPC_MFP2_PC10MFP_GPIO (0x00UL << NUMAKER_SYS_GPC_MFP2_PC10MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC10MFP_EADC2_CH11 (0x01UL << NUMAKER_SYS_GPC_MFP2_PC10MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC10MFP_ACMP3_P2 (0x01UL << NUMAKER_SYS_GPC_MFP2_PC10MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC10MFP_EBI_ADR6 (0x02UL << NUMAKER_SYS_GPC_MFP2_PC10MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC10MFP_UART6_nRTS (0x05UL << NUMAKER_SYS_GPC_MFP2_PC10MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC10MFP_SPI3_CLK (0x06UL << NUMAKER_SYS_GPC_MFP2_PC10MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC10MFP_UART3_TXD (0x07UL << NUMAKER_SYS_GPC_MFP2_PC10MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC10MFP_CAN1_TXD (0x09UL << NUMAKER_SYS_GPC_MFP2_PC10MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC10MFP_I2C4_SMBAL (0x0aUL << NUMAKER_SYS_GPC_MFP2_PC10MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC10MFP_ECAP1_IC0 (0x0bUL << NUMAKER_SYS_GPC_MFP2_PC10MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC10MFP_EPWM1_CH2 (0x0cUL << NUMAKER_SYS_GPC_MFP2_PC10MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC10MFP_EADC1_ST (0x0eUL << NUMAKER_SYS_GPC_MFP2_PC10MFP_Pos) + +/* PC.11 MFP */ +#define NUMAKER_SYS_GPC_MFP2_PC11MFP_GPIO (0x00UL << NUMAKER_SYS_GPC_MFP2_PC11MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC11MFP_EADC2_CH12 (0x01UL << NUMAKER_SYS_GPC_MFP2_PC11MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC11MFP_ACMP3_P3 (0x01UL << NUMAKER_SYS_GPC_MFP2_PC11MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC11MFP_EBI_ADR5 (0x02UL << NUMAKER_SYS_GPC_MFP2_PC11MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC11MFP_UART0_RXD (0x03UL << NUMAKER_SYS_GPC_MFP2_PC11MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC11MFP_I2C0_SDA (0x04UL << NUMAKER_SYS_GPC_MFP2_PC11MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC11MFP_UART6_RXD (0x05UL << NUMAKER_SYS_GPC_MFP2_PC11MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC11MFP_SPI3_MOSI (0x06UL << NUMAKER_SYS_GPC_MFP2_PC11MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC11MFP_I2C4_SDA (0x0aUL << NUMAKER_SYS_GPC_MFP2_PC11MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC11MFP_ECAP1_IC1 (0x0bUL << NUMAKER_SYS_GPC_MFP2_PC11MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC11MFP_EPWM1_CH1 (0x0cUL << NUMAKER_SYS_GPC_MFP2_PC11MFP_Pos) +#define NUMAKER_SYS_GPC_MFP2_PC11MFP_ACMP1_O (0x0eUL << NUMAKER_SYS_GPC_MFP2_PC11MFP_Pos) + +/* PC.12 MFP */ +#define NUMAKER_SYS_GPC_MFP3_PC12MFP_GPIO (0x00UL << NUMAKER_SYS_GPC_MFP3_PC12MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC12MFP_EADC2_CH13 (0x01UL << NUMAKER_SYS_GPC_MFP3_PC12MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC12MFP_EBI_ADR4 (0x02UL << NUMAKER_SYS_GPC_MFP3_PC12MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC12MFP_UART0_TXD (0x03UL << NUMAKER_SYS_GPC_MFP3_PC12MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC12MFP_I2C0_SCL (0x04UL << NUMAKER_SYS_GPC_MFP3_PC12MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC12MFP_UART6_TXD (0x05UL << NUMAKER_SYS_GPC_MFP3_PC12MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC12MFP_SPI3_MISO (0x06UL << NUMAKER_SYS_GPC_MFP3_PC12MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC12MFP_SC0_nCD (0x09UL << NUMAKER_SYS_GPC_MFP3_PC12MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC12MFP_I2C4_SCL (0x0aUL << NUMAKER_SYS_GPC_MFP3_PC12MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC12MFP_ECAP1_IC2 (0x0bUL << NUMAKER_SYS_GPC_MFP3_PC12MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC12MFP_EPWM1_CH0 (0x0cUL << NUMAKER_SYS_GPC_MFP3_PC12MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC12MFP_ACMP0_O (0x0eUL << NUMAKER_SYS_GPC_MFP3_PC12MFP_Pos) + +/* PC.13 MFP */ +#define NUMAKER_SYS_GPC_MFP3_PC13MFP_GPIO (0x00UL << NUMAKER_SYS_GPC_MFP3_PC13MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC13MFP_EADC1_CH3 (0x01UL << NUMAKER_SYS_GPC_MFP3_PC13MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC13MFP_EADC2_CH3 (0x01UL << NUMAKER_SYS_GPC_MFP3_PC13MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC13MFP_EBI_ADR10 (0x02UL << NUMAKER_SYS_GPC_MFP3_PC13MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC13MFP_SC2_nCD (0x03UL << NUMAKER_SYS_GPC_MFP3_PC13MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC13MFP_SPI2_I2SMCLK (0x04UL << NUMAKER_SYS_GPC_MFP3_PC13MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC13MFP_CAN1_TXD (0x05UL << NUMAKER_SYS_GPC_MFP3_PC13MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC13MFP_USCI0_CTL0 (0x06UL << NUMAKER_SYS_GPC_MFP3_PC13MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC13MFP_UART2_TXD (0x07UL << NUMAKER_SYS_GPC_MFP3_PC13MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC13MFP_UART8_nCTS (0x08UL << NUMAKER_SYS_GPC_MFP3_PC13MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC13MFP_BPWM0_CH4 (0x09UL << NUMAKER_SYS_GPC_MFP3_PC13MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC13MFP_CLKO (0x0dUL << NUMAKER_SYS_GPC_MFP3_PC13MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC13MFP_EADC0_ST (0x0eUL << NUMAKER_SYS_GPC_MFP3_PC13MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC13MFP_SPI9_SS (0x13UL << NUMAKER_SYS_GPC_MFP3_PC13MFP_Pos) + +/* PC.14 MFP */ +#define NUMAKER_SYS_GPC_MFP3_PC14MFP_GPIO (0x00UL << NUMAKER_SYS_GPC_MFP3_PC14MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC14MFP_EBI_AD11 (0x02UL << NUMAKER_SYS_GPC_MFP3_PC14MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC14MFP_SC1_nCD (0x03UL << NUMAKER_SYS_GPC_MFP3_PC14MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC14MFP_SPI0_I2SMCLK (0x04UL << NUMAKER_SYS_GPC_MFP3_PC14MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC14MFP_USCI0_CTL0 (0x05UL << NUMAKER_SYS_GPC_MFP3_PC14MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC14MFP_QSPI0_CLK (0x06UL << NUMAKER_SYS_GPC_MFP3_PC14MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC14MFP_TRACE_SWO (0x0aUL << NUMAKER_SYS_GPC_MFP3_PC14MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC14MFP_EPWM0_SYNC_IN (0x0bUL << NUMAKER_SYS_GPC_MFP3_PC14MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC14MFP_ETMC_TRACE_CLK (0x0cUL << NUMAKER_SYS_GPC_MFP3_PC14MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC14MFP_TM1 (0x0dUL << NUMAKER_SYS_GPC_MFP3_PC14MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC14MFP_USB_VBUS_ST (0x0eUL << NUMAKER_SYS_GPC_MFP3_PC14MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC14MFP_HSUSB_VBUS_ST (0x0fUL << NUMAKER_SYS_GPC_MFP3_PC14MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC14MFP_SPI9_MOSI (0x13UL << NUMAKER_SYS_GPC_MFP3_PC14MFP_Pos) +#define NUMAKER_SYS_GPC_MFP3_PC14MFP_BMC26 (0x14UL << NUMAKER_SYS_GPC_MFP3_PC14MFP_Pos) + +/* PD.0 MFP */ +#define NUMAKER_SYS_GPD_MFP0_PD0MFP_GPIO (0x00UL << NUMAKER_SYS_GPD_MFP0_PD0MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD0MFP_EBI_AD13 (0x02UL << NUMAKER_SYS_GPD_MFP0_PD0MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD0MFP_USCI0_CLK (0x03UL << NUMAKER_SYS_GPD_MFP0_PD0MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD0MFP_SPI0_MOSI (0x04UL << NUMAKER_SYS_GPD_MFP0_PD0MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD0MFP_UART3_RXD (0x05UL << NUMAKER_SYS_GPD_MFP0_PD0MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD0MFP_I2C2_SDA (0x06UL << NUMAKER_SYS_GPD_MFP0_PD0MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD0MFP_SC2_CLK (0x07UL << NUMAKER_SYS_GPD_MFP0_PD0MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD0MFP_I2S1_DO (0x0aUL << NUMAKER_SYS_GPD_MFP0_PD0MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD0MFP_EQEI2_A (0x0cUL << NUMAKER_SYS_GPD_MFP0_PD0MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD0MFP_ECAP2_IC1 (0x0dUL << NUMAKER_SYS_GPD_MFP0_PD0MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD0MFP_TM2 (0x0eUL << NUMAKER_SYS_GPD_MFP0_PD0MFP_Pos) + +/* PD.1 MFP */ +#define NUMAKER_SYS_GPD_MFP0_PD1MFP_GPIO (0x00UL << NUMAKER_SYS_GPD_MFP0_PD1MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD1MFP_EBI_AD12 (0x02UL << NUMAKER_SYS_GPD_MFP0_PD1MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD1MFP_USCI0_DAT0 (0x03UL << NUMAKER_SYS_GPD_MFP0_PD1MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD1MFP_SPI0_MISO (0x04UL << NUMAKER_SYS_GPD_MFP0_PD1MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD1MFP_UART3_TXD (0x05UL << NUMAKER_SYS_GPD_MFP0_PD1MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD1MFP_I2C2_SCL (0x06UL << NUMAKER_SYS_GPD_MFP0_PD1MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD1MFP_SC2_DAT (0x07UL << NUMAKER_SYS_GPD_MFP0_PD1MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD1MFP_I2S1_DI (0x0aUL << NUMAKER_SYS_GPD_MFP0_PD1MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD1MFP_EQEI2_INDEX (0x0cUL << NUMAKER_SYS_GPD_MFP0_PD1MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD1MFP_ECAP2_IC0 (0x0dUL << NUMAKER_SYS_GPD_MFP0_PD1MFP_Pos) + +/* PD.2 MFP */ +#define NUMAKER_SYS_GPD_MFP0_PD2MFP_GPIO (0x00UL << NUMAKER_SYS_GPD_MFP0_PD2MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD2MFP_EBI_AD11 (0x02UL << NUMAKER_SYS_GPD_MFP0_PD2MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD2MFP_USCI0_DAT1 (0x03UL << NUMAKER_SYS_GPD_MFP0_PD2MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD2MFP_SPI0_CLK (0x04UL << NUMAKER_SYS_GPD_MFP0_PD2MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD2MFP_UART3_nCTS (0x05UL << NUMAKER_SYS_GPD_MFP0_PD2MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD2MFP_SC2_RST (0x07UL << NUMAKER_SYS_GPD_MFP0_PD2MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD2MFP_UART0_RXD (0x09UL << NUMAKER_SYS_GPD_MFP0_PD2MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD2MFP_I2S1_MCLK (0x0aUL << NUMAKER_SYS_GPD_MFP0_PD2MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD2MFP_EQEI3_B (0x0dUL << NUMAKER_SYS_GPD_MFP0_PD2MFP_Pos) + +/* PD.3 MFP */ +#define NUMAKER_SYS_GPD_MFP0_PD3MFP_GPIO (0x00UL << NUMAKER_SYS_GPD_MFP0_PD3MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD3MFP_EBI_AD10 (0x02UL << NUMAKER_SYS_GPD_MFP0_PD3MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD3MFP_USCI0_CTL1 (0x03UL << NUMAKER_SYS_GPD_MFP0_PD3MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD3MFP_SPI0_SS (0x04UL << NUMAKER_SYS_GPD_MFP0_PD3MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD3MFP_UART3_nRTS (0x05UL << NUMAKER_SYS_GPD_MFP0_PD3MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD3MFP_SC2_PWR (0x07UL << NUMAKER_SYS_GPD_MFP0_PD3MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD3MFP_SC1_nCD (0x08UL << NUMAKER_SYS_GPD_MFP0_PD3MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD3MFP_UART0_TXD (0x09UL << NUMAKER_SYS_GPD_MFP0_PD3MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD3MFP_I2S1_BCLK (0x0aUL << NUMAKER_SYS_GPD_MFP0_PD3MFP_Pos) +#define NUMAKER_SYS_GPD_MFP0_PD3MFP_EQEI3_A (0x0dUL << NUMAKER_SYS_GPD_MFP0_PD3MFP_Pos) + +/* PD.4 MFP */ +#define NUMAKER_SYS_GPD_MFP1_PD4MFP_GPIO (0x00UL << NUMAKER_SYS_GPD_MFP1_PD4MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD4MFP_USCI0_CTL0 (0x03UL << NUMAKER_SYS_GPD_MFP1_PD4MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD4MFP_I2C1_SDA (0x04UL << NUMAKER_SYS_GPD_MFP1_PD4MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD4MFP_SPI1_SS (0x05UL << NUMAKER_SYS_GPD_MFP1_PD4MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD4MFP_SC1_CLK (0x08UL << NUMAKER_SYS_GPD_MFP1_PD4MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD4MFP_USB_VBUS_ST (0x0eUL << NUMAKER_SYS_GPD_MFP1_PD4MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD4MFP_PSIO0_CH7 (0x11UL << NUMAKER_SYS_GPD_MFP1_PD4MFP_Pos) + +/* PD.5 MFP */ +#define NUMAKER_SYS_GPD_MFP1_PD5MFP_GPIO (0x00UL << NUMAKER_SYS_GPD_MFP1_PD5MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD5MFP_I2C1_SCL (0x04UL << NUMAKER_SYS_GPD_MFP1_PD5MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD5MFP_SPI1_CLK (0x05UL << NUMAKER_SYS_GPD_MFP1_PD5MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD5MFP_SC1_DAT (0x08UL << NUMAKER_SYS_GPD_MFP1_PD5MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD5MFP_ACMP1_O (0x0eUL << NUMAKER_SYS_GPD_MFP1_PD5MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD5MFP_EADC1_ST (0x0fUL << NUMAKER_SYS_GPD_MFP1_PD5MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD5MFP_HBI_nRESET (0x10UL << NUMAKER_SYS_GPD_MFP1_PD5MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD5MFP_PSIO0_CH6 (0x11UL << NUMAKER_SYS_GPD_MFP1_PD5MFP_Pos) + +/* PD.6 MFP */ +#define NUMAKER_SYS_GPD_MFP1_PD6MFP_GPIO (0x00UL << NUMAKER_SYS_GPD_MFP1_PD6MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD6MFP_EBI_AD5 (0x02UL << NUMAKER_SYS_GPD_MFP1_PD6MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD6MFP_UART1_RXD (0x03UL << NUMAKER_SYS_GPD_MFP1_PD6MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD6MFP_I2C0_SDA (0x04UL << NUMAKER_SYS_GPD_MFP1_PD6MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD6MFP_SPI1_MOSI (0x05UL << NUMAKER_SYS_GPD_MFP1_PD6MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD6MFP_QSPI1_MOSI0 (0x06UL << NUMAKER_SYS_GPD_MFP1_PD6MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD6MFP_SC1_RST (0x08UL << NUMAKER_SYS_GPD_MFP1_PD6MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD6MFP_ACMP0_O (0x0eUL << NUMAKER_SYS_GPD_MFP1_PD6MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD6MFP_EADC0_ST (0x0fUL << NUMAKER_SYS_GPD_MFP1_PD6MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD6MFP_HBI_D0 (0x10UL << NUMAKER_SYS_GPD_MFP1_PD6MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD6MFP_PSIO0_CH5 (0x11UL << NUMAKER_SYS_GPD_MFP1_PD6MFP_Pos) + +/* PD.7 MFP */ +#define NUMAKER_SYS_GPD_MFP1_PD7MFP_GPIO (0x00UL << NUMAKER_SYS_GPD_MFP1_PD7MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD7MFP_EBI_AD4 (0x02UL << NUMAKER_SYS_GPD_MFP1_PD7MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD7MFP_UART1_TXD (0x03UL << NUMAKER_SYS_GPD_MFP1_PD7MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD7MFP_I2C0_SCL (0x04UL << NUMAKER_SYS_GPD_MFP1_PD7MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD7MFP_SPI1_MISO (0x05UL << NUMAKER_SYS_GPD_MFP1_PD7MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD7MFP_QSPI1_MISO0 (0x06UL << NUMAKER_SYS_GPD_MFP1_PD7MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD7MFP_CCAP_HSYNC (0x07UL << NUMAKER_SYS_GPD_MFP1_PD7MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD7MFP_SC1_PWR (0x08UL << NUMAKER_SYS_GPD_MFP1_PD7MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD7MFP_HBI_D1 (0x10UL << NUMAKER_SYS_GPD_MFP1_PD7MFP_Pos) +#define NUMAKER_SYS_GPD_MFP1_PD7MFP_PSIO0_CH4 (0x11UL << NUMAKER_SYS_GPD_MFP1_PD7MFP_Pos) + +/* PD.8 MFP */ +#define NUMAKER_SYS_GPD_MFP2_PD8MFP_GPIO (0x00UL << NUMAKER_SYS_GPD_MFP2_PD8MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD8MFP_EBI_AD6 (0x02UL << NUMAKER_SYS_GPD_MFP2_PD8MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD8MFP_I2C2_SDA (0x03UL << NUMAKER_SYS_GPD_MFP2_PD8MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD8MFP_UART2_nRTS (0x04UL << NUMAKER_SYS_GPD_MFP2_PD8MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD8MFP_UART7_RXD (0x05UL << NUMAKER_SYS_GPD_MFP2_PD8MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD8MFP_CAN2_RXD (0x06UL << NUMAKER_SYS_GPD_MFP2_PD8MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD8MFP_PSIO0_CH3 (0x11UL << NUMAKER_SYS_GPD_MFP2_PD8MFP_Pos) + +/* PD.9 MFP */ +#define NUMAKER_SYS_GPD_MFP2_PD9MFP_GPIO (0x00UL << NUMAKER_SYS_GPD_MFP2_PD9MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD9MFP_EBI_AD7 (0x02UL << NUMAKER_SYS_GPD_MFP2_PD9MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD9MFP_I2C2_SCL (0x03UL << NUMAKER_SYS_GPD_MFP2_PD9MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD9MFP_UART2_nCTS (0x04UL << NUMAKER_SYS_GPD_MFP2_PD9MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD9MFP_UART7_TXD (0x05UL << NUMAKER_SYS_GPD_MFP2_PD9MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD9MFP_CAN2_TXD (0x06UL << NUMAKER_SYS_GPD_MFP2_PD9MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD9MFP_PSIO0_CH2 (0x11UL << NUMAKER_SYS_GPD_MFP2_PD9MFP_Pos) + +/* PD.10 MFP */ +#define NUMAKER_SYS_GPD_MFP2_PD10MFP_GPIO (0x00UL << NUMAKER_SYS_GPD_MFP2_PD10MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD10MFP_EADC1_CH0 (0x01UL << NUMAKER_SYS_GPD_MFP2_PD10MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD10MFP_EADC2_CH0 (0x01UL << NUMAKER_SYS_GPD_MFP2_PD10MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD10MFP_EBI_nCS2 (0x02UL << NUMAKER_SYS_GPD_MFP2_PD10MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD10MFP_UART1_RXD (0x03UL << NUMAKER_SYS_GPD_MFP2_PD10MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD10MFP_CAN0_RXD (0x04UL << NUMAKER_SYS_GPD_MFP2_PD10MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD10MFP_UART8_RXD (0x08UL << NUMAKER_SYS_GPD_MFP2_PD10MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD10MFP_EQEI0_B (0x0aUL << NUMAKER_SYS_GPD_MFP2_PD10MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD10MFP_ECAP3_IC2 (0x0bUL << NUMAKER_SYS_GPD_MFP2_PD10MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD10MFP_INT7 (0x0fUL << NUMAKER_SYS_GPD_MFP2_PD10MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD10MFP_SPI9_MOSI (0x13UL << NUMAKER_SYS_GPD_MFP2_PD10MFP_Pos) + +/* PD.11 MFP */ +#define NUMAKER_SYS_GPD_MFP2_PD11MFP_GPIO (0x00UL << NUMAKER_SYS_GPD_MFP2_PD11MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD11MFP_EADC1_CH1 (0x01UL << NUMAKER_SYS_GPD_MFP2_PD11MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD11MFP_EADC2_CH1 (0x01UL << NUMAKER_SYS_GPD_MFP2_PD11MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD11MFP_EBI_nCS1 (0x02UL << NUMAKER_SYS_GPD_MFP2_PD11MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD11MFP_UART1_TXD (0x03UL << NUMAKER_SYS_GPD_MFP2_PD11MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD11MFP_CAN0_TXD (0x04UL << NUMAKER_SYS_GPD_MFP2_PD11MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD11MFP_UART8_TXD (0x08UL << NUMAKER_SYS_GPD_MFP2_PD11MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD11MFP_EQEI0_A (0x0aUL << NUMAKER_SYS_GPD_MFP2_PD11MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD11MFP_ECAP3_IC1 (0x0bUL << NUMAKER_SYS_GPD_MFP2_PD11MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD11MFP_INT6 (0x0fUL << NUMAKER_SYS_GPD_MFP2_PD11MFP_Pos) +#define NUMAKER_SYS_GPD_MFP2_PD11MFP_SPI9_MISO (0x13UL << NUMAKER_SYS_GPD_MFP2_PD11MFP_Pos) + +/* PD.12 MFP */ +#define NUMAKER_SYS_GPD_MFP3_PD12MFP_GPIO (0x00UL << NUMAKER_SYS_GPD_MFP3_PD12MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD12MFP_EADC1_CH2 (0x01UL << NUMAKER_SYS_GPD_MFP3_PD12MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD12MFP_EADC2_CH2 (0x01UL << NUMAKER_SYS_GPD_MFP3_PD12MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD12MFP_EBI_nCS0 (0x02UL << NUMAKER_SYS_GPD_MFP3_PD12MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD12MFP_CAN1_RXD (0x05UL << NUMAKER_SYS_GPD_MFP3_PD12MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD12MFP_UART2_RXD (0x07UL << NUMAKER_SYS_GPD_MFP3_PD12MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD12MFP_UART8_nRTS (0x08UL << NUMAKER_SYS_GPD_MFP3_PD12MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD12MFP_BPWM0_CH5 (0x09UL << NUMAKER_SYS_GPD_MFP3_PD12MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD12MFP_EQEI0_INDEX (0x0aUL << NUMAKER_SYS_GPD_MFP3_PD12MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD12MFP_ECAP3_IC0 (0x0bUL << NUMAKER_SYS_GPD_MFP3_PD12MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD12MFP_CLKO (0x0dUL << NUMAKER_SYS_GPD_MFP3_PD12MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD12MFP_EADC0_ST (0x0eUL << NUMAKER_SYS_GPD_MFP3_PD12MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD12MFP_INT5 (0x0fUL << NUMAKER_SYS_GPD_MFP3_PD12MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD12MFP_SPI9_CLK (0x13UL << NUMAKER_SYS_GPD_MFP3_PD12MFP_Pos) + +/* PD.13 MFP */ +#define NUMAKER_SYS_GPD_MFP3_PD13MFP_GPIO (0x00UL << NUMAKER_SYS_GPD_MFP3_PD13MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD13MFP_EBI_AD10 (0x02UL << NUMAKER_SYS_GPD_MFP3_PD13MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD13MFP_SD0_nCD (0x03UL << NUMAKER_SYS_GPD_MFP3_PD13MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD13MFP_SPI0_I2SMCLK (0x04UL << NUMAKER_SYS_GPD_MFP3_PD13MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD13MFP_SPI1_I2SMCLK (0x05UL << NUMAKER_SYS_GPD_MFP3_PD13MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD13MFP_QSPI1_MOSI0 (0x06UL << NUMAKER_SYS_GPD_MFP3_PD13MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD13MFP_SC2_nCD (0x07UL << NUMAKER_SYS_GPD_MFP3_PD13MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD13MFP_SD1_CLK (0x08UL << NUMAKER_SYS_GPD_MFP3_PD13MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD13MFP_UART6_RXD (0x09UL << NUMAKER_SYS_GPD_MFP3_PD13MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD13MFP_I2S1_LRCK (0x0aUL << NUMAKER_SYS_GPD_MFP3_PD13MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD13MFP_BPWM0_CH0 (0x0bUL << NUMAKER_SYS_GPD_MFP3_PD13MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD13MFP_EQEI2_B (0x0cUL << NUMAKER_SYS_GPD_MFP3_PD13MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD13MFP_ECAP2_IC2 (0x0dUL << NUMAKER_SYS_GPD_MFP3_PD13MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD13MFP_CLKO (0x0eUL << NUMAKER_SYS_GPD_MFP3_PD13MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD13MFP_EADC0_ST (0x0fUL << NUMAKER_SYS_GPD_MFP3_PD13MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD13MFP_QSPI1_MOSI1 (0x13UL << NUMAKER_SYS_GPD_MFP3_PD13MFP_Pos) + +/* PD.14 MFP */ +#define NUMAKER_SYS_GPD_MFP3_PD14MFP_GPIO (0x00UL << NUMAKER_SYS_GPD_MFP3_PD14MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD14MFP_EBI_nCS0 (0x02UL << NUMAKER_SYS_GPD_MFP3_PD14MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD14MFP_SPI3_I2SMCLK (0x03UL << NUMAKER_SYS_GPD_MFP3_PD14MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD14MFP_SC1_nCD (0x04UL << NUMAKER_SYS_GPD_MFP3_PD14MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD14MFP_SPI0_I2SMCLK (0x05UL << NUMAKER_SYS_GPD_MFP3_PD14MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD14MFP_I2S1_BCLK (0x0aUL << NUMAKER_SYS_GPD_MFP3_PD14MFP_Pos) +#define NUMAKER_SYS_GPD_MFP3_PD14MFP_EPWM0_CH4 (0x0bUL << NUMAKER_SYS_GPD_MFP3_PD14MFP_Pos) + +/* PE.0 MFP */ +#define NUMAKER_SYS_GPE_MFP0_PE0MFP_GPIO (0x00UL << NUMAKER_SYS_GPE_MFP0_PE0MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE0MFP_EBI_AD11 (0x02UL << NUMAKER_SYS_GPE_MFP0_PE0MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE0MFP_QSPI0_MOSI0 (0x03UL << NUMAKER_SYS_GPE_MFP0_PE0MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE0MFP_SC2_CLK (0x04UL << NUMAKER_SYS_GPE_MFP0_PE0MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE0MFP_I2S0_MCLK (0x05UL << NUMAKER_SYS_GPE_MFP0_PE0MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE0MFP_SPI1_MOSI (0x06UL << NUMAKER_SYS_GPE_MFP0_PE0MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE0MFP_UART3_RXD (0x07UL << NUMAKER_SYS_GPE_MFP0_PE0MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE0MFP_I2C1_SDA (0x08UL << NUMAKER_SYS_GPE_MFP0_PE0MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE0MFP_UART4_nRTS (0x09UL << NUMAKER_SYS_GPE_MFP0_PE0MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE0MFP_UART8_RXD (0x0aUL << NUMAKER_SYS_GPE_MFP0_PE0MFP_Pos) + +/* PE.1 MFP */ +#define NUMAKER_SYS_GPE_MFP0_PE1MFP_GPIO (0x00UL << NUMAKER_SYS_GPE_MFP0_PE1MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE1MFP_EBI_AD10 (0x02UL << NUMAKER_SYS_GPE_MFP0_PE1MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE1MFP_QSPI0_MISO0 (0x03UL << NUMAKER_SYS_GPE_MFP0_PE1MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE1MFP_SC2_DAT (0x04UL << NUMAKER_SYS_GPE_MFP0_PE1MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE1MFP_I2S0_BCLK (0x05UL << NUMAKER_SYS_GPE_MFP0_PE1MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE1MFP_SPI1_MISO (0x06UL << NUMAKER_SYS_GPE_MFP0_PE1MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE1MFP_UART3_TXD (0x07UL << NUMAKER_SYS_GPE_MFP0_PE1MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE1MFP_I2C1_SCL (0x08UL << NUMAKER_SYS_GPE_MFP0_PE1MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE1MFP_UART4_nCTS (0x09UL << NUMAKER_SYS_GPE_MFP0_PE1MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE1MFP_UART8_TXD (0x0aUL << NUMAKER_SYS_GPE_MFP0_PE1MFP_Pos) + +/* PE.2 MFP */ +#define NUMAKER_SYS_GPE_MFP0_PE2MFP_GPIO (0x00UL << NUMAKER_SYS_GPE_MFP0_PE2MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE2MFP_EBI_ALE (0x02UL << NUMAKER_SYS_GPE_MFP0_PE2MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE2MFP_SD0_DAT0 (0x03UL << NUMAKER_SYS_GPE_MFP0_PE2MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE2MFP_SPIM_MOSI (0x04UL << NUMAKER_SYS_GPE_MFP0_PE2MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE2MFP_SPI3_MOSI (0x05UL << NUMAKER_SYS_GPE_MFP0_PE2MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE2MFP_SC0_CLK (0x06UL << NUMAKER_SYS_GPE_MFP0_PE2MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE2MFP_USCI0_CLK (0x07UL << NUMAKER_SYS_GPE_MFP0_PE2MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE2MFP_UART6_nCTS (0x08UL << NUMAKER_SYS_GPE_MFP0_PE2MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE2MFP_UART7_RXD (0x09UL << NUMAKER_SYS_GPE_MFP0_PE2MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE2MFP_UART8_nRTS (0x0aUL << NUMAKER_SYS_GPE_MFP0_PE2MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE2MFP_EQEI0_B (0x0bUL << NUMAKER_SYS_GPE_MFP0_PE2MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE2MFP_EPWM0_CH5 (0x0cUL << NUMAKER_SYS_GPE_MFP0_PE2MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE2MFP_BPWM0_CH0 (0x0dUL << NUMAKER_SYS_GPE_MFP0_PE2MFP_Pos) + +/* PE.3 MFP */ +#define NUMAKER_SYS_GPE_MFP0_PE3MFP_GPIO (0x00UL << NUMAKER_SYS_GPE_MFP0_PE3MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE3MFP_EBI_MCLK (0x02UL << NUMAKER_SYS_GPE_MFP0_PE3MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE3MFP_SD0_DAT1 (0x03UL << NUMAKER_SYS_GPE_MFP0_PE3MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE3MFP_SPIM_MISO (0x04UL << NUMAKER_SYS_GPE_MFP0_PE3MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE3MFP_SPI3_MISO (0x05UL << NUMAKER_SYS_GPE_MFP0_PE3MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE3MFP_SC0_DAT (0x06UL << NUMAKER_SYS_GPE_MFP0_PE3MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE3MFP_USCI0_DAT0 (0x07UL << NUMAKER_SYS_GPE_MFP0_PE3MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE3MFP_UART6_nRTS (0x08UL << NUMAKER_SYS_GPE_MFP0_PE3MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE3MFP_UART7_TXD (0x09UL << NUMAKER_SYS_GPE_MFP0_PE3MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE3MFP_UART8_nCTS (0x0aUL << NUMAKER_SYS_GPE_MFP0_PE3MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE3MFP_EQEI0_A (0x0bUL << NUMAKER_SYS_GPE_MFP0_PE3MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE3MFP_EPWM0_CH4 (0x0cUL << NUMAKER_SYS_GPE_MFP0_PE3MFP_Pos) +#define NUMAKER_SYS_GPE_MFP0_PE3MFP_BPWM0_CH1 (0x0dUL << NUMAKER_SYS_GPE_MFP0_PE3MFP_Pos) + +/* PE.4 MFP */ +#define NUMAKER_SYS_GPE_MFP1_PE4MFP_GPIO (0x00UL << NUMAKER_SYS_GPE_MFP1_PE4MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE4MFP_EBI_nWR (0x02UL << NUMAKER_SYS_GPE_MFP1_PE4MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE4MFP_SD0_DAT2 (0x03UL << NUMAKER_SYS_GPE_MFP1_PE4MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE4MFP_SPIM_CLK (0x04UL << NUMAKER_SYS_GPE_MFP1_PE4MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE4MFP_SPI3_CLK (0x05UL << NUMAKER_SYS_GPE_MFP1_PE4MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE4MFP_SC0_RST (0x06UL << NUMAKER_SYS_GPE_MFP1_PE4MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE4MFP_USCI0_DAT1 (0x07UL << NUMAKER_SYS_GPE_MFP1_PE4MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE4MFP_UART6_RXD (0x08UL << NUMAKER_SYS_GPE_MFP1_PE4MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE4MFP_UART7_nCTS (0x09UL << NUMAKER_SYS_GPE_MFP1_PE4MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE4MFP_UART9_RXD (0x0aUL << NUMAKER_SYS_GPE_MFP1_PE4MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE4MFP_EQEI0_INDEX (0x0bUL << NUMAKER_SYS_GPE_MFP1_PE4MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE4MFP_EPWM0_CH3 (0x0cUL << NUMAKER_SYS_GPE_MFP1_PE4MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE4MFP_BPWM0_CH2 (0x0dUL << NUMAKER_SYS_GPE_MFP1_PE4MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE4MFP_PSIO0_CH3 (0x11UL << NUMAKER_SYS_GPE_MFP1_PE4MFP_Pos) + +/* PE.5 MFP */ +#define NUMAKER_SYS_GPE_MFP1_PE5MFP_GPIO (0x00UL << NUMAKER_SYS_GPE_MFP1_PE5MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE5MFP_EBI_nRD (0x02UL << NUMAKER_SYS_GPE_MFP1_PE5MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE5MFP_SD0_DAT3 (0x03UL << NUMAKER_SYS_GPE_MFP1_PE5MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE5MFP_SPIM_SS (0x04UL << NUMAKER_SYS_GPE_MFP1_PE5MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE5MFP_SPI3_SS (0x05UL << NUMAKER_SYS_GPE_MFP1_PE5MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE5MFP_SC0_PWR (0x06UL << NUMAKER_SYS_GPE_MFP1_PE5MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE5MFP_USCI0_CTL1 (0x07UL << NUMAKER_SYS_GPE_MFP1_PE5MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE5MFP_UART6_TXD (0x08UL << NUMAKER_SYS_GPE_MFP1_PE5MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE5MFP_UART7_nRTS (0x09UL << NUMAKER_SYS_GPE_MFP1_PE5MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE5MFP_UART9_TXD (0x0aUL << NUMAKER_SYS_GPE_MFP1_PE5MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE5MFP_EQEI1_B (0x0bUL << NUMAKER_SYS_GPE_MFP1_PE5MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE5MFP_EPWM0_CH2 (0x0cUL << NUMAKER_SYS_GPE_MFP1_PE5MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE5MFP_BPWM0_CH3 (0x0dUL << NUMAKER_SYS_GPE_MFP1_PE5MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE5MFP_PSIO0_CH2 (0x11UL << NUMAKER_SYS_GPE_MFP1_PE5MFP_Pos) + +/* PE.6 MFP */ +#define NUMAKER_SYS_GPE_MFP1_PE6MFP_GPIO (0x00UL << NUMAKER_SYS_GPE_MFP1_PE6MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE6MFP_SD0_CLK (0x03UL << NUMAKER_SYS_GPE_MFP1_PE6MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE6MFP_SPIM_D3 (0x04UL << NUMAKER_SYS_GPE_MFP1_PE6MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE6MFP_SPI3_I2SMCLK (0x05UL << NUMAKER_SYS_GPE_MFP1_PE6MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE6MFP_SC0_nCD (0x06UL << NUMAKER_SYS_GPE_MFP1_PE6MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE6MFP_USCI0_CTL0 (0x07UL << NUMAKER_SYS_GPE_MFP1_PE6MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE6MFP_UART5_RXD (0x08UL << NUMAKER_SYS_GPE_MFP1_PE6MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE6MFP_CAN1_RXD (0x09UL << NUMAKER_SYS_GPE_MFP1_PE6MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE6MFP_UART9_nRTS (0x0aUL << NUMAKER_SYS_GPE_MFP1_PE6MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE6MFP_EQEI1_A (0x0bUL << NUMAKER_SYS_GPE_MFP1_PE6MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE6MFP_EPWM0_CH1 (0x0cUL << NUMAKER_SYS_GPE_MFP1_PE6MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE6MFP_BPWM0_CH4 (0x0dUL << NUMAKER_SYS_GPE_MFP1_PE6MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE6MFP_ACMP3_O (0x0eUL << NUMAKER_SYS_GPE_MFP1_PE6MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE6MFP_PSIO0_CH1 (0x11UL << NUMAKER_SYS_GPE_MFP1_PE6MFP_Pos) + +/* PE.7 MFP */ +#define NUMAKER_SYS_GPE_MFP1_PE7MFP_GPIO (0x00UL << NUMAKER_SYS_GPE_MFP1_PE7MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE7MFP_SD0_CMD (0x03UL << NUMAKER_SYS_GPE_MFP1_PE7MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE7MFP_SPIM_D2 (0x04UL << NUMAKER_SYS_GPE_MFP1_PE7MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE7MFP_UART5_TXD (0x08UL << NUMAKER_SYS_GPE_MFP1_PE7MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE7MFP_CAN1_TXD (0x09UL << NUMAKER_SYS_GPE_MFP1_PE7MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE7MFP_UART9_nCTS (0x0aUL << NUMAKER_SYS_GPE_MFP1_PE7MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE7MFP_EQEI1_INDEX (0x0bUL << NUMAKER_SYS_GPE_MFP1_PE7MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE7MFP_EPWM0_CH0 (0x0cUL << NUMAKER_SYS_GPE_MFP1_PE7MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE7MFP_BPWM0_CH5 (0x0dUL << NUMAKER_SYS_GPE_MFP1_PE7MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE7MFP_ACMP2_O (0x0eUL << NUMAKER_SYS_GPE_MFP1_PE7MFP_Pos) +#define NUMAKER_SYS_GPE_MFP1_PE7MFP_PSIO0_CH0 (0x11UL << NUMAKER_SYS_GPE_MFP1_PE7MFP_Pos) + +/* PE.8 MFP */ +#define NUMAKER_SYS_GPE_MFP2_PE8MFP_GPIO (0x00UL << NUMAKER_SYS_GPE_MFP2_PE8MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE8MFP_EBI_ADR10 (0x02UL << NUMAKER_SYS_GPE_MFP2_PE8MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE8MFP_EMAC0_RMII_MDC (0x03UL << NUMAKER_SYS_GPE_MFP2_PE8MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE8MFP_I2S0_BCLK (0x04UL << NUMAKER_SYS_GPE_MFP2_PE8MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE8MFP_SPI2_CLK (0x05UL << NUMAKER_SYS_GPE_MFP2_PE8MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE8MFP_UART2_TXD (0x07UL << NUMAKER_SYS_GPE_MFP2_PE8MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE8MFP_EPWM0_CH0 (0x0aUL << NUMAKER_SYS_GPE_MFP2_PE8MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE8MFP_EPWM0_BRAKE0 (0x0bUL << NUMAKER_SYS_GPE_MFP2_PE8MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE8MFP_ECAP0_IC0 (0x0cUL << NUMAKER_SYS_GPE_MFP2_PE8MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE8MFP_EQEI2_INDEX (0x0dUL << NUMAKER_SYS_GPE_MFP2_PE8MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE8MFP_TRACE_DATA3 (0x0eUL << NUMAKER_SYS_GPE_MFP2_PE8MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE8MFP_ECAP3_IC0 (0x0fUL << NUMAKER_SYS_GPE_MFP2_PE8MFP_Pos) + +/* PE.9 MFP */ +#define NUMAKER_SYS_GPE_MFP2_PE9MFP_GPIO (0x00UL << NUMAKER_SYS_GPE_MFP2_PE9MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE9MFP_EBI_ADR11 (0x02UL << NUMAKER_SYS_GPE_MFP2_PE9MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE9MFP_EMAC0_RMII_MDIO (0x03UL << NUMAKER_SYS_GPE_MFP2_PE9MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE9MFP_I2S0_MCLK (0x04UL << NUMAKER_SYS_GPE_MFP2_PE9MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE9MFP_SPI2_MISO (0x05UL << NUMAKER_SYS_GPE_MFP2_PE9MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE9MFP_UART2_RXD (0x07UL << NUMAKER_SYS_GPE_MFP2_PE9MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE9MFP_EPWM0_CH1 (0x0aUL << NUMAKER_SYS_GPE_MFP2_PE9MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE9MFP_EPWM0_BRAKE1 (0x0bUL << NUMAKER_SYS_GPE_MFP2_PE9MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE9MFP_ECAP0_IC1 (0x0cUL << NUMAKER_SYS_GPE_MFP2_PE9MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE9MFP_EQEI2_A (0x0dUL << NUMAKER_SYS_GPE_MFP2_PE9MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE9MFP_TRACE_DATA2 (0x0eUL << NUMAKER_SYS_GPE_MFP2_PE9MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE9MFP_ECAP3_IC1 (0x0fUL << NUMAKER_SYS_GPE_MFP2_PE9MFP_Pos) + +/* PE.10 MFP */ +#define NUMAKER_SYS_GPE_MFP2_PE10MFP_GPIO (0x00UL << NUMAKER_SYS_GPE_MFP2_PE10MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE10MFP_EBI_ADR12 (0x02UL << NUMAKER_SYS_GPE_MFP2_PE10MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE10MFP_EMAC0_RMII_TXD0 (0x03UL << NUMAKER_SYS_GPE_MFP2_PE10MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE10MFP_I2S0_DI (0x04UL << NUMAKER_SYS_GPE_MFP2_PE10MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE10MFP_SPI2_MOSI (0x05UL << NUMAKER_SYS_GPE_MFP2_PE10MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE10MFP_UART3_TXD (0x07UL << NUMAKER_SYS_GPE_MFP2_PE10MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE10MFP_EPWM0_CH2 (0x0aUL << NUMAKER_SYS_GPE_MFP2_PE10MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE10MFP_EPWM1_BRAKE0 (0x0bUL << NUMAKER_SYS_GPE_MFP2_PE10MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE10MFP_ECAP0_IC2 (0x0cUL << NUMAKER_SYS_GPE_MFP2_PE10MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE10MFP_EQEI2_B (0x0dUL << NUMAKER_SYS_GPE_MFP2_PE10MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE10MFP_TRACE_DATA1 (0x0eUL << NUMAKER_SYS_GPE_MFP2_PE10MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE10MFP_ECAP3_IC2 (0x0fUL << NUMAKER_SYS_GPE_MFP2_PE10MFP_Pos) + +/* PE.11 MFP */ +#define NUMAKER_SYS_GPE_MFP2_PE11MFP_GPIO (0x00UL << NUMAKER_SYS_GPE_MFP2_PE11MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE11MFP_EBI_ADR13 (0x02UL << NUMAKER_SYS_GPE_MFP2_PE11MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE11MFP_EMAC0_RMII_TXD1 (0x03UL << NUMAKER_SYS_GPE_MFP2_PE11MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE11MFP_I2S0_DO (0x04UL << NUMAKER_SYS_GPE_MFP2_PE11MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE11MFP_SPI2_SS (0x05UL << NUMAKER_SYS_GPE_MFP2_PE11MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE11MFP_UART3_RXD (0x07UL << NUMAKER_SYS_GPE_MFP2_PE11MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE11MFP_UART1_nCTS (0x08UL << NUMAKER_SYS_GPE_MFP2_PE11MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE11MFP_EPWM0_CH3 (0x0aUL << NUMAKER_SYS_GPE_MFP2_PE11MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE11MFP_EPWM1_BRAKE1 (0x0bUL << NUMAKER_SYS_GPE_MFP2_PE11MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE11MFP_ECAP1_IC2 (0x0dUL << NUMAKER_SYS_GPE_MFP2_PE11MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE11MFP_TRACE_DATA0 (0x0eUL << NUMAKER_SYS_GPE_MFP2_PE11MFP_Pos) +#define NUMAKER_SYS_GPE_MFP2_PE11MFP_KPI_COL7 (0x12UL << NUMAKER_SYS_GPE_MFP2_PE11MFP_Pos) + +/* PE.12 MFP */ +#define NUMAKER_SYS_GPE_MFP3_PE12MFP_GPIO (0x00UL << NUMAKER_SYS_GPE_MFP3_PE12MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE12MFP_EBI_ADR14 (0x02UL << NUMAKER_SYS_GPE_MFP3_PE12MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE12MFP_EMAC0_RMII_TXEN (0x03UL << NUMAKER_SYS_GPE_MFP3_PE12MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE12MFP_I2S0_LRCK (0x04UL << NUMAKER_SYS_GPE_MFP3_PE12MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE12MFP_SPI2_I2SMCLK (0x05UL << NUMAKER_SYS_GPE_MFP3_PE12MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE12MFP_UART1_nRTS (0x08UL << NUMAKER_SYS_GPE_MFP3_PE12MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE12MFP_EPWM0_CH4 (0x0aUL << NUMAKER_SYS_GPE_MFP3_PE12MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE12MFP_ECAP1_IC1 (0x0dUL << NUMAKER_SYS_GPE_MFP3_PE12MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE12MFP_TRACE_CLK (0x0eUL << NUMAKER_SYS_GPE_MFP3_PE12MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE12MFP_KPI_COL6 (0x12UL << NUMAKER_SYS_GPE_MFP3_PE12MFP_Pos) + +/* PE.13 MFP */ +#define NUMAKER_SYS_GPE_MFP3_PE13MFP_GPIO (0x00UL << NUMAKER_SYS_GPE_MFP3_PE13MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE13MFP_EBI_ADR15 (0x02UL << NUMAKER_SYS_GPE_MFP3_PE13MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE13MFP_EMAC0_PPS (0x03UL << NUMAKER_SYS_GPE_MFP3_PE13MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE13MFP_I2C0_SCL (0x04UL << NUMAKER_SYS_GPE_MFP3_PE13MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE13MFP_UART4_nRTS (0x05UL << NUMAKER_SYS_GPE_MFP3_PE13MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE13MFP_UART1_TXD (0x08UL << NUMAKER_SYS_GPE_MFP3_PE13MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE13MFP_EPWM0_CH5 (0x0aUL << NUMAKER_SYS_GPE_MFP3_PE13MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE13MFP_EPWM1_CH0 (0x0bUL << NUMAKER_SYS_GPE_MFP3_PE13MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE13MFP_BPWM1_CH5 (0x0cUL << NUMAKER_SYS_GPE_MFP3_PE13MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE13MFP_ECAP1_IC0 (0x0dUL << NUMAKER_SYS_GPE_MFP3_PE13MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE13MFP_TRACE_SWO (0x0eUL << NUMAKER_SYS_GPE_MFP3_PE13MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE13MFP_KPI_COL5 (0x12UL << NUMAKER_SYS_GPE_MFP3_PE13MFP_Pos) + +/* PE.14 MFP */ +#define NUMAKER_SYS_GPE_MFP3_PE14MFP_GPIO (0x00UL << NUMAKER_SYS_GPE_MFP3_PE14MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE14MFP_EBI_AD8 (0x02UL << NUMAKER_SYS_GPE_MFP3_PE14MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE14MFP_UART2_TXD (0x03UL << NUMAKER_SYS_GPE_MFP3_PE14MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE14MFP_CAN0_TXD (0x04UL << NUMAKER_SYS_GPE_MFP3_PE14MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE14MFP_SD1_nCD (0x05UL << NUMAKER_SYS_GPE_MFP3_PE14MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE14MFP_UART6_TXD (0x06UL << NUMAKER_SYS_GPE_MFP3_PE14MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE14MFP_PSIO0_CH0 (0x11UL << NUMAKER_SYS_GPE_MFP3_PE14MFP_Pos) + +/* PE.15 MFP */ +#define NUMAKER_SYS_GPE_MFP3_PE15MFP_GPIO (0x00UL << NUMAKER_SYS_GPE_MFP3_PE15MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE15MFP_EBI_AD9 (0x02UL << NUMAKER_SYS_GPE_MFP3_PE15MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE15MFP_UART2_RXD (0x03UL << NUMAKER_SYS_GPE_MFP3_PE15MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE15MFP_CAN0_RXD (0x04UL << NUMAKER_SYS_GPE_MFP3_PE15MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE15MFP_UART6_RXD (0x06UL << NUMAKER_SYS_GPE_MFP3_PE15MFP_Pos) +#define NUMAKER_SYS_GPE_MFP3_PE15MFP_PSIO0_CH1 (0x11UL << NUMAKER_SYS_GPE_MFP3_PE15MFP_Pos) + +/* PF.0 MFP */ +#define NUMAKER_SYS_GPF_MFP0_PF0MFP_GPIO (0x00UL << NUMAKER_SYS_GPF_MFP0_PF0MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF0MFP_UART1_TXD (0x02UL << NUMAKER_SYS_GPF_MFP0_PF0MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF0MFP_I2C1_SCL (0x03UL << NUMAKER_SYS_GPF_MFP0_PF0MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF0MFP_UART0_TXD (0x04UL << NUMAKER_SYS_GPF_MFP0_PF0MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF0MFP_SC1_DAT (0x05UL << NUMAKER_SYS_GPF_MFP0_PF0MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF0MFP_I2S0_DO (0x06UL << NUMAKER_SYS_GPF_MFP0_PF0MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF0MFP_UART2_TXD (0x08UL << NUMAKER_SYS_GPF_MFP0_PF0MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF0MFP_I2C0_SCL (0x09UL << NUMAKER_SYS_GPF_MFP0_PF0MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF0MFP_CAN2_TXD (0x0aUL << NUMAKER_SYS_GPF_MFP0_PF0MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF0MFP_EPWM1_CH4 (0x0bUL << NUMAKER_SYS_GPF_MFP0_PF0MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF0MFP_BPWM1_CH0 (0x0cUL << NUMAKER_SYS_GPF_MFP0_PF0MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF0MFP_ACMP0_O (0x0dUL << NUMAKER_SYS_GPF_MFP0_PF0MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF0MFP_ICE_DAT (0x0eUL << NUMAKER_SYS_GPF_MFP0_PF0MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF0MFP_EADC0_ST (0x0fUL << NUMAKER_SYS_GPF_MFP0_PF0MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF0MFP_QSPI1_MISO0 (0x13UL << NUMAKER_SYS_GPF_MFP0_PF0MFP_Pos) + +/* PF.1 MFP */ +#define NUMAKER_SYS_GPF_MFP0_PF1MFP_GPIO (0x00UL << NUMAKER_SYS_GPF_MFP0_PF1MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF1MFP_UART1_RXD (0x02UL << NUMAKER_SYS_GPF_MFP0_PF1MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF1MFP_I2C1_SDA (0x03UL << NUMAKER_SYS_GPF_MFP0_PF1MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF1MFP_UART0_RXD (0x04UL << NUMAKER_SYS_GPF_MFP0_PF1MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF1MFP_SC1_CLK (0x05UL << NUMAKER_SYS_GPF_MFP0_PF1MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF1MFP_I2S0_LRCK (0x06UL << NUMAKER_SYS_GPF_MFP0_PF1MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF1MFP_UART2_RXD (0x08UL << NUMAKER_SYS_GPF_MFP0_PF1MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF1MFP_I2C0_SDA (0x09UL << NUMAKER_SYS_GPF_MFP0_PF1MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF1MFP_CAN2_RXD (0x0aUL << NUMAKER_SYS_GPF_MFP0_PF1MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF1MFP_EPWM1_CH5 (0x0bUL << NUMAKER_SYS_GPF_MFP0_PF1MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF1MFP_BPWM1_CH1 (0x0cUL << NUMAKER_SYS_GPF_MFP0_PF1MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF1MFP_ACMP1_O (0x0dUL << NUMAKER_SYS_GPF_MFP0_PF1MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF1MFP_ICE_CLK (0x0eUL << NUMAKER_SYS_GPF_MFP0_PF1MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF1MFP_EADC1_ST (0x0fUL << NUMAKER_SYS_GPF_MFP0_PF1MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF1MFP_QSPI1_MOSI0 (0x13UL << NUMAKER_SYS_GPF_MFP0_PF1MFP_Pos) + +/* PF.2 MFP */ +#define NUMAKER_SYS_GPF_MFP0_PF2MFP_GPIO (0x00UL << NUMAKER_SYS_GPF_MFP0_PF2MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF2MFP_EBI_nCS1 (0x02UL << NUMAKER_SYS_GPF_MFP0_PF2MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF2MFP_UART0_RXD (0x03UL << NUMAKER_SYS_GPF_MFP0_PF2MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF2MFP_I2C0_SDA (0x04UL << NUMAKER_SYS_GPF_MFP0_PF2MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF2MFP_QSPI0_CLK (0x05UL << NUMAKER_SYS_GPF_MFP0_PF2MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF2MFP_UART9_RXD (0x07UL << NUMAKER_SYS_GPF_MFP0_PF2MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF2MFP_XT1_OUT (0x0aUL << NUMAKER_SYS_GPF_MFP0_PF2MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF2MFP_BPWM1_CH1 (0x0bUL << NUMAKER_SYS_GPF_MFP0_PF2MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF2MFP_I2C4_SMBSUS (0x0cUL << NUMAKER_SYS_GPF_MFP0_PF2MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF2MFP_ACMP3_O (0x0dUL << NUMAKER_SYS_GPF_MFP0_PF2MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF2MFP_BMC13 (0x14UL << NUMAKER_SYS_GPF_MFP0_PF2MFP_Pos) + +/* PF.3 MFP */ +#define NUMAKER_SYS_GPF_MFP0_PF3MFP_GPIO (0x00UL << NUMAKER_SYS_GPF_MFP0_PF3MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF3MFP_EBI_nCS0 (0x02UL << NUMAKER_SYS_GPF_MFP0_PF3MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF3MFP_UART0_TXD (0x03UL << NUMAKER_SYS_GPF_MFP0_PF3MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF3MFP_I2C0_SCL (0x04UL << NUMAKER_SYS_GPF_MFP0_PF3MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF3MFP_UART9_TXD (0x07UL << NUMAKER_SYS_GPF_MFP0_PF3MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF3MFP_XT1_IN (0x0aUL << NUMAKER_SYS_GPF_MFP0_PF3MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF3MFP_BPWM1_CH0 (0x0bUL << NUMAKER_SYS_GPF_MFP0_PF3MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF3MFP_I2C4_SMBAL (0x0cUL << NUMAKER_SYS_GPF_MFP0_PF3MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF3MFP_ACMP2_O (0x0dUL << NUMAKER_SYS_GPF_MFP0_PF3MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF3MFP_EADC2_ST (0x0fUL << NUMAKER_SYS_GPF_MFP0_PF3MFP_Pos) +#define NUMAKER_SYS_GPF_MFP0_PF3MFP_BMC12 (0x14UL << NUMAKER_SYS_GPF_MFP0_PF3MFP_Pos) + +/* PF.4 MFP */ +#define NUMAKER_SYS_GPF_MFP1_PF4MFP_GPIO (0x00UL << NUMAKER_SYS_GPF_MFP1_PF4MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF4MFP_UART2_TXD (0x02UL << NUMAKER_SYS_GPF_MFP1_PF4MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF4MFP_EBI_AD0 (0x03UL << NUMAKER_SYS_GPF_MFP1_PF4MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF4MFP_UART2_nRTS (0x04UL << NUMAKER_SYS_GPF_MFP1_PF4MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF4MFP_EPWM0_CH1 (0x07UL << NUMAKER_SYS_GPF_MFP1_PF4MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF4MFP_BPWM0_CH5 (0x08UL << NUMAKER_SYS_GPF_MFP1_PF4MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF4MFP_X32_OUT (0x0aUL << NUMAKER_SYS_GPF_MFP1_PF4MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF4MFP_EADC1_ST (0x0bUL << NUMAKER_SYS_GPF_MFP1_PF4MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF4MFP_I2C4_SDA (0x0cUL << NUMAKER_SYS_GPF_MFP1_PF4MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF4MFP_EQEI2_B (0x0dUL << NUMAKER_SYS_GPF_MFP1_PF4MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF4MFP_SPI5_MISO (0x13UL << NUMAKER_SYS_GPF_MFP1_PF4MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF4MFP_BMC11 (0x14UL << NUMAKER_SYS_GPF_MFP1_PF4MFP_Pos) + +/* PF.5 MFP */ +#define NUMAKER_SYS_GPF_MFP1_PF5MFP_GPIO (0x00UL << NUMAKER_SYS_GPF_MFP1_PF5MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF5MFP_UART2_RXD (0x02UL << NUMAKER_SYS_GPF_MFP1_PF5MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF5MFP_EBI_AD1 (0x03UL << NUMAKER_SYS_GPF_MFP1_PF5MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF5MFP_UART2_nCTS (0x04UL << NUMAKER_SYS_GPF_MFP1_PF5MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF5MFP_EPWM0_CH0 (0x07UL << NUMAKER_SYS_GPF_MFP1_PF5MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF5MFP_BPWM0_CH4 (0x08UL << NUMAKER_SYS_GPF_MFP1_PF5MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF5MFP_EPWM0_SYNC_OUT (0x09UL << NUMAKER_SYS_GPF_MFP1_PF5MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF5MFP_X32_IN (0x0aUL << NUMAKER_SYS_GPF_MFP1_PF5MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF5MFP_EADC0_ST (0x0bUL << NUMAKER_SYS_GPF_MFP1_PF5MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF5MFP_I2C4_SCL (0x0cUL << NUMAKER_SYS_GPF_MFP1_PF5MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF5MFP_EQEI2_A (0x0dUL << NUMAKER_SYS_GPF_MFP1_PF5MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF5MFP_SPI5_MOSI (0x13UL << NUMAKER_SYS_GPF_MFP1_PF5MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF5MFP_BMC10 (0x14UL << NUMAKER_SYS_GPF_MFP1_PF5MFP_Pos) + +/* PF.6 MFP */ +#define NUMAKER_SYS_GPF_MFP1_PF6MFP_GPIO (0x00UL << NUMAKER_SYS_GPF_MFP1_PF6MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF6MFP_EBI_ADR19 (0x02UL << NUMAKER_SYS_GPF_MFP1_PF6MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF6MFP_SC0_CLK (0x03UL << NUMAKER_SYS_GPF_MFP1_PF6MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF6MFP_I2S0_LRCK (0x04UL << NUMAKER_SYS_GPF_MFP1_PF6MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF6MFP_SPI0_MOSI (0x05UL << NUMAKER_SYS_GPF_MFP1_PF6MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF6MFP_UART4_RXD (0x06UL << NUMAKER_SYS_GPF_MFP1_PF6MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF6MFP_EBI_nCS0 (0x07UL << NUMAKER_SYS_GPF_MFP1_PF6MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF6MFP_CAN2_RXD (0x08UL << NUMAKER_SYS_GPF_MFP1_PF6MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF6MFP_SPI3_I2SMCLK (0x09UL << NUMAKER_SYS_GPF_MFP1_PF6MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF6MFP_TAMPER0 (0x0aUL << NUMAKER_SYS_GPF_MFP1_PF6MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF6MFP_EQEI2_INDEX (0x0dUL << NUMAKER_SYS_GPF_MFP1_PF6MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF6MFP_TRACE_SWO (0x0eUL << NUMAKER_SYS_GPF_MFP1_PF6MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF6MFP_SPI5_CLK (0x13UL << NUMAKER_SYS_GPF_MFP1_PF6MFP_Pos) + +/* PF.7 MFP */ +#define NUMAKER_SYS_GPF_MFP1_PF7MFP_GPIO (0x00UL << NUMAKER_SYS_GPF_MFP1_PF7MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF7MFP_EBI_ADR18 (0x02UL << NUMAKER_SYS_GPF_MFP1_PF7MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF7MFP_SC0_DAT (0x03UL << NUMAKER_SYS_GPF_MFP1_PF7MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF7MFP_I2S0_DO (0x04UL << NUMAKER_SYS_GPF_MFP1_PF7MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF7MFP_SPI0_MISO (0x05UL << NUMAKER_SYS_GPF_MFP1_PF7MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF7MFP_UART4_TXD (0x06UL << NUMAKER_SYS_GPF_MFP1_PF7MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF7MFP_CCAP_DATA0 (0x07UL << NUMAKER_SYS_GPF_MFP1_PF7MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF7MFP_CAN2_TXD (0x08UL << NUMAKER_SYS_GPF_MFP1_PF7MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF7MFP_TAMPER1 (0x0aUL << NUMAKER_SYS_GPF_MFP1_PF7MFP_Pos) +#define NUMAKER_SYS_GPF_MFP1_PF7MFP_SPI5_SS (0x13UL << NUMAKER_SYS_GPF_MFP1_PF7MFP_Pos) + +/* PF.8 MFP */ +#define NUMAKER_SYS_GPF_MFP2_PF8MFP_GPIO (0x00UL << NUMAKER_SYS_GPF_MFP2_PF8MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF8MFP_EBI_ADR17 (0x02UL << NUMAKER_SYS_GPF_MFP2_PF8MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF8MFP_SC0_RST (0x03UL << NUMAKER_SYS_GPF_MFP2_PF8MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF8MFP_I2S0_DI (0x04UL << NUMAKER_SYS_GPF_MFP2_PF8MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF8MFP_SPI0_CLK (0x05UL << NUMAKER_SYS_GPF_MFP2_PF8MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF8MFP_UART5_nCTS (0x06UL << NUMAKER_SYS_GPF_MFP2_PF8MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF8MFP_CCAP_DATA1 (0x07UL << NUMAKER_SYS_GPF_MFP2_PF8MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF8MFP_CAN1_RXD (0x08UL << NUMAKER_SYS_GPF_MFP2_PF8MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF8MFP_TAMPER2 (0x0aUL << NUMAKER_SYS_GPF_MFP2_PF8MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF8MFP_UART9_RXD (0x0bUL << NUMAKER_SYS_GPF_MFP2_PF8MFP_Pos) + +/* PF.9 MFP */ +#define NUMAKER_SYS_GPF_MFP2_PF9MFP_GPIO (0x00UL << NUMAKER_SYS_GPF_MFP2_PF9MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF9MFP_EBI_ADR16 (0x02UL << NUMAKER_SYS_GPF_MFP2_PF9MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF9MFP_SC0_PWR (0x03UL << NUMAKER_SYS_GPF_MFP2_PF9MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF9MFP_I2S0_MCLK (0x04UL << NUMAKER_SYS_GPF_MFP2_PF9MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF9MFP_SPI0_SS (0x05UL << NUMAKER_SYS_GPF_MFP2_PF9MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF9MFP_UART5_nRTS (0x06UL << NUMAKER_SYS_GPF_MFP2_PF9MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF9MFP_CCAP_DATA2 (0x07UL << NUMAKER_SYS_GPF_MFP2_PF9MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF9MFP_CAN1_TXD (0x08UL << NUMAKER_SYS_GPF_MFP2_PF9MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF9MFP_TAMPER3 (0x0aUL << NUMAKER_SYS_GPF_MFP2_PF9MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF9MFP_UART9_TXD (0x0bUL << NUMAKER_SYS_GPF_MFP2_PF9MFP_Pos) + +/* PF.10 MFP */ +#define NUMAKER_SYS_GPF_MFP2_PF10MFP_GPIO (0x00UL << NUMAKER_SYS_GPF_MFP2_PF10MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF10MFP_EBI_ADR15 (0x02UL << NUMAKER_SYS_GPF_MFP2_PF10MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF10MFP_SC0_nCD (0x03UL << NUMAKER_SYS_GPF_MFP2_PF10MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF10MFP_I2S0_BCLK (0x04UL << NUMAKER_SYS_GPF_MFP2_PF10MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF10MFP_SPI0_I2SMCLK (0x05UL << NUMAKER_SYS_GPF_MFP2_PF10MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF10MFP_UART5_RXD (0x06UL << NUMAKER_SYS_GPF_MFP2_PF10MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF10MFP_CCAP_DATA3 (0x07UL << NUMAKER_SYS_GPF_MFP2_PF10MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF10MFP_CAN3_RXD (0x08UL << NUMAKER_SYS_GPF_MFP2_PF10MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF10MFP_TAMPER4 (0x0aUL << NUMAKER_SYS_GPF_MFP2_PF10MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF10MFP_UART9_nRTS (0x0bUL << NUMAKER_SYS_GPF_MFP2_PF10MFP_Pos) + +/* PF.11 MFP */ +#define NUMAKER_SYS_GPF_MFP2_PF11MFP_GPIO (0x00UL << NUMAKER_SYS_GPF_MFP2_PF11MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF11MFP_EBI_ADR14 (0x02UL << NUMAKER_SYS_GPF_MFP2_PF11MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF11MFP_SPI2_MOSI (0x03UL << NUMAKER_SYS_GPF_MFP2_PF11MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF11MFP_UART5_TXD (0x06UL << NUMAKER_SYS_GPF_MFP2_PF11MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF11MFP_CCAP_DATA4 (0x07UL << NUMAKER_SYS_GPF_MFP2_PF11MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF11MFP_CAN3_TXD (0x08UL << NUMAKER_SYS_GPF_MFP2_PF11MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF11MFP_TAMPER5 (0x0aUL << NUMAKER_SYS_GPF_MFP2_PF11MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF11MFP_UART9_nCTS (0x0bUL << NUMAKER_SYS_GPF_MFP2_PF11MFP_Pos) +#define NUMAKER_SYS_GPF_MFP2_PF11MFP_TM3 (0x0dUL << NUMAKER_SYS_GPF_MFP2_PF11MFP_Pos) + +/* PG.0 MFP */ +#define NUMAKER_SYS_GPG_MFP0_PG0MFP_GPIO (0x00UL << NUMAKER_SYS_GPG_MFP0_PG0MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG0MFP_EBI_ADR8 (0x02UL << NUMAKER_SYS_GPG_MFP0_PG0MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG0MFP_I2C0_SCL (0x04UL << NUMAKER_SYS_GPG_MFP0_PG0MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG0MFP_I2C1_SMBAL (0x05UL << NUMAKER_SYS_GPG_MFP0_PG0MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG0MFP_UART2_RXD (0x06UL << NUMAKER_SYS_GPG_MFP0_PG0MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG0MFP_CAN1_TXD (0x07UL << NUMAKER_SYS_GPG_MFP0_PG0MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG0MFP_UART1_TXD (0x08UL << NUMAKER_SYS_GPG_MFP0_PG0MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG0MFP_I2C3_SCL (0x09UL << NUMAKER_SYS_GPG_MFP0_PG0MFP_Pos) + +/* PG.1 MFP */ +#define NUMAKER_SYS_GPG_MFP0_PG1MFP_GPIO (0x00UL << NUMAKER_SYS_GPG_MFP0_PG1MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG1MFP_EBI_ADR9 (0x02UL << NUMAKER_SYS_GPG_MFP0_PG1MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG1MFP_SPI2_I2SMCLK (0x03UL << NUMAKER_SYS_GPG_MFP0_PG1MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG1MFP_I2C0_SDA (0x04UL << NUMAKER_SYS_GPG_MFP0_PG1MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG1MFP_I2C1_SMBSUS (0x05UL << NUMAKER_SYS_GPG_MFP0_PG1MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG1MFP_UART2_TXD (0x06UL << NUMAKER_SYS_GPG_MFP0_PG1MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG1MFP_CAN1_RXD (0x07UL << NUMAKER_SYS_GPG_MFP0_PG1MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG1MFP_UART1_RXD (0x08UL << NUMAKER_SYS_GPG_MFP0_PG1MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG1MFP_I2C3_SDA (0x09UL << NUMAKER_SYS_GPG_MFP0_PG1MFP_Pos) + +/* PG.2 MFP */ +#define NUMAKER_SYS_GPG_MFP0_PG2MFP_GPIO (0x00UL << NUMAKER_SYS_GPG_MFP0_PG2MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG2MFP_EBI_ADR11 (0x02UL << NUMAKER_SYS_GPG_MFP0_PG2MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG2MFP_SPI2_SS (0x03UL << NUMAKER_SYS_GPG_MFP0_PG2MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG2MFP_I2C0_SMBAL (0x04UL << NUMAKER_SYS_GPG_MFP0_PG2MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG2MFP_I2C1_SCL (0x05UL << NUMAKER_SYS_GPG_MFP0_PG2MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG2MFP_CCAP_DATA7 (0x07UL << NUMAKER_SYS_GPG_MFP0_PG2MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG2MFP_I2C3_SMBAL (0x09UL << NUMAKER_SYS_GPG_MFP0_PG2MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG2MFP_TM0 (0x0dUL << NUMAKER_SYS_GPG_MFP0_PG2MFP_Pos) + +/* PG.3 MFP */ +#define NUMAKER_SYS_GPG_MFP0_PG3MFP_GPIO (0x00UL << NUMAKER_SYS_GPG_MFP0_PG3MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG3MFP_EBI_ADR12 (0x02UL << NUMAKER_SYS_GPG_MFP0_PG3MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG3MFP_SPI2_CLK (0x03UL << NUMAKER_SYS_GPG_MFP0_PG3MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG3MFP_I2C0_SMBSUS (0x04UL << NUMAKER_SYS_GPG_MFP0_PG3MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG3MFP_I2C1_SDA (0x05UL << NUMAKER_SYS_GPG_MFP0_PG3MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG3MFP_CCAP_DATA6 (0x07UL << NUMAKER_SYS_GPG_MFP0_PG3MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG3MFP_I2C3_SMBSUS (0x09UL << NUMAKER_SYS_GPG_MFP0_PG3MFP_Pos) +#define NUMAKER_SYS_GPG_MFP0_PG3MFP_TM1 (0x0dUL << NUMAKER_SYS_GPG_MFP0_PG3MFP_Pos) + +/* PG.4 MFP */ +#define NUMAKER_SYS_GPG_MFP1_PG4MFP_GPIO (0x00UL << NUMAKER_SYS_GPG_MFP1_PG4MFP_Pos) +#define NUMAKER_SYS_GPG_MFP1_PG4MFP_EBI_ADR13 (0x02UL << NUMAKER_SYS_GPG_MFP1_PG4MFP_Pos) +#define NUMAKER_SYS_GPG_MFP1_PG4MFP_SPI2_MISO (0x03UL << NUMAKER_SYS_GPG_MFP1_PG4MFP_Pos) +#define NUMAKER_SYS_GPG_MFP1_PG4MFP_CCAP_DATA5 (0x07UL << NUMAKER_SYS_GPG_MFP1_PG4MFP_Pos) +#define NUMAKER_SYS_GPG_MFP1_PG4MFP_TM2 (0x0dUL << NUMAKER_SYS_GPG_MFP1_PG4MFP_Pos) + +/* PG.5 MFP */ +#define NUMAKER_SYS_GPG_MFP1_PG5MFP_GPIO (0x00UL << NUMAKER_SYS_GPG_MFP1_PG5MFP_Pos) +#define NUMAKER_SYS_GPG_MFP1_PG5MFP_EBI_nCS1 (0x02UL << NUMAKER_SYS_GPG_MFP1_PG5MFP_Pos) +#define NUMAKER_SYS_GPG_MFP1_PG5MFP_SPI3_SS (0x03UL << NUMAKER_SYS_GPG_MFP1_PG5MFP_Pos) +#define NUMAKER_SYS_GPG_MFP1_PG5MFP_SC1_PWR (0x04UL << NUMAKER_SYS_GPG_MFP1_PG5MFP_Pos) +#define NUMAKER_SYS_GPG_MFP1_PG5MFP_I2C3_SMBAL (0x08UL << NUMAKER_SYS_GPG_MFP1_PG5MFP_Pos) +#define NUMAKER_SYS_GPG_MFP1_PG5MFP_I2S1_MCLK (0x0aUL << NUMAKER_SYS_GPG_MFP1_PG5MFP_Pos) +#define NUMAKER_SYS_GPG_MFP1_PG5MFP_EPWM0_CH3 (0x0bUL << NUMAKER_SYS_GPG_MFP1_PG5MFP_Pos) + +/* PG.6 MFP */ +#define NUMAKER_SYS_GPG_MFP1_PG6MFP_GPIO (0x00UL << NUMAKER_SYS_GPG_MFP1_PG6MFP_Pos) +#define NUMAKER_SYS_GPG_MFP1_PG6MFP_EBI_nCS2 (0x02UL << NUMAKER_SYS_GPG_MFP1_PG6MFP_Pos) +#define NUMAKER_SYS_GPG_MFP1_PG6MFP_SPI3_CLK (0x03UL << NUMAKER_SYS_GPG_MFP1_PG6MFP_Pos) +#define NUMAKER_SYS_GPG_MFP1_PG6MFP_SC1_RST (0x04UL << NUMAKER_SYS_GPG_MFP1_PG6MFP_Pos) +#define NUMAKER_SYS_GPG_MFP1_PG6MFP_I2C3_SMBSUS (0x08UL << NUMAKER_SYS_GPG_MFP1_PG6MFP_Pos) +#define NUMAKER_SYS_GPG_MFP1_PG6MFP_I2S1_DI (0x0aUL << NUMAKER_SYS_GPG_MFP1_PG6MFP_Pos) +#define NUMAKER_SYS_GPG_MFP1_PG6MFP_EPWM0_CH2 (0x0bUL << NUMAKER_SYS_GPG_MFP1_PG6MFP_Pos) + +/* PG.7 MFP */ +#define NUMAKER_SYS_GPG_MFP1_PG7MFP_GPIO (0x00UL << NUMAKER_SYS_GPG_MFP1_PG7MFP_Pos) +#define NUMAKER_SYS_GPG_MFP1_PG7MFP_EBI_nWRL (0x02UL << NUMAKER_SYS_GPG_MFP1_PG7MFP_Pos) +#define NUMAKER_SYS_GPG_MFP1_PG7MFP_SPI3_MISO (0x03UL << NUMAKER_SYS_GPG_MFP1_PG7MFP_Pos) +#define NUMAKER_SYS_GPG_MFP1_PG7MFP_SC1_DAT (0x04UL << NUMAKER_SYS_GPG_MFP1_PG7MFP_Pos) +#define NUMAKER_SYS_GPG_MFP1_PG7MFP_I2C3_SCL (0x08UL << NUMAKER_SYS_GPG_MFP1_PG7MFP_Pos) +#define NUMAKER_SYS_GPG_MFP1_PG7MFP_I2S1_DO (0x0aUL << NUMAKER_SYS_GPG_MFP1_PG7MFP_Pos) +#define NUMAKER_SYS_GPG_MFP1_PG7MFP_EPWM0_CH1 (0x0bUL << NUMAKER_SYS_GPG_MFP1_PG7MFP_Pos) + +/* PG.8 MFP */ +#define NUMAKER_SYS_GPG_MFP2_PG8MFP_GPIO (0x00UL << NUMAKER_SYS_GPG_MFP2_PG8MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG8MFP_EBI_nWRH (0x02UL << NUMAKER_SYS_GPG_MFP2_PG8MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG8MFP_SPI3_MOSI (0x03UL << NUMAKER_SYS_GPG_MFP2_PG8MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG8MFP_SC1_CLK (0x04UL << NUMAKER_SYS_GPG_MFP2_PG8MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG8MFP_I2C3_SDA (0x08UL << NUMAKER_SYS_GPG_MFP2_PG8MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG8MFP_I2S1_LRCK (0x0aUL << NUMAKER_SYS_GPG_MFP2_PG8MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG8MFP_EPWM0_CH0 (0x0bUL << NUMAKER_SYS_GPG_MFP2_PG8MFP_Pos) + +/* PG.9 MFP */ +#define NUMAKER_SYS_GPG_MFP2_PG9MFP_GPIO (0x00UL << NUMAKER_SYS_GPG_MFP2_PG9MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG9MFP_EBI_AD0 (0x02UL << NUMAKER_SYS_GPG_MFP2_PG9MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG9MFP_SD1_DAT3 (0x03UL << NUMAKER_SYS_GPG_MFP2_PG9MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG9MFP_SPIM_D2 (0x04UL << NUMAKER_SYS_GPG_MFP2_PG9MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG9MFP_QSPI1_MISO1 (0x05UL << NUMAKER_SYS_GPG_MFP2_PG9MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG9MFP_CCAP_PIXCLK (0x07UL << NUMAKER_SYS_GPG_MFP2_PG9MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG9MFP_I2C4_SCL (0x08UL << NUMAKER_SYS_GPG_MFP2_PG9MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG9MFP_ECAP2_IC0 (0x09UL << NUMAKER_SYS_GPG_MFP2_PG9MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG9MFP_BPWM0_CH5 (0x0cUL << NUMAKER_SYS_GPG_MFP2_PG9MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG9MFP_HBI_D4 (0x10UL << NUMAKER_SYS_GPG_MFP2_PG9MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG9MFP_SPI8_SS (0x13UL << NUMAKER_SYS_GPG_MFP2_PG9MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG9MFP_BMC16 (0x14UL << NUMAKER_SYS_GPG_MFP2_PG9MFP_Pos) + +/* PG.10 MFP */ +#define NUMAKER_SYS_GPG_MFP2_PG10MFP_GPIO (0x00UL << NUMAKER_SYS_GPG_MFP2_PG10MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG10MFP_EBI_AD1 (0x02UL << NUMAKER_SYS_GPG_MFP2_PG10MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG10MFP_SD1_DAT2 (0x03UL << NUMAKER_SYS_GPG_MFP2_PG10MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG10MFP_SPIM_D3 (0x04UL << NUMAKER_SYS_GPG_MFP2_PG10MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG10MFP_QSPI1_MOSI1 (0x05UL << NUMAKER_SYS_GPG_MFP2_PG10MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG10MFP_CCAP_SCLK (0x07UL << NUMAKER_SYS_GPG_MFP2_PG10MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG10MFP_I2C4_SDA (0x08UL << NUMAKER_SYS_GPG_MFP2_PG10MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG10MFP_ECAP2_IC1 (0x09UL << NUMAKER_SYS_GPG_MFP2_PG10MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG10MFP_BPWM0_CH4 (0x0cUL << NUMAKER_SYS_GPG_MFP2_PG10MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG10MFP_HBI_D3 (0x10UL << NUMAKER_SYS_GPG_MFP2_PG10MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG10MFP_SPI8_CLK (0x13UL << NUMAKER_SYS_GPG_MFP2_PG10MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG10MFP_BMC17 (0x14UL << NUMAKER_SYS_GPG_MFP2_PG10MFP_Pos) + +/* PG.11 MFP */ +#define NUMAKER_SYS_GPG_MFP2_PG11MFP_GPIO (0x00UL << NUMAKER_SYS_GPG_MFP2_PG11MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG11MFP_EBI_AD2 (0x02UL << NUMAKER_SYS_GPG_MFP2_PG11MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG11MFP_SD1_DAT1 (0x03UL << NUMAKER_SYS_GPG_MFP2_PG11MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG11MFP_SPIM_SS (0x04UL << NUMAKER_SYS_GPG_MFP2_PG11MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG11MFP_QSPI1_SS (0x05UL << NUMAKER_SYS_GPG_MFP2_PG11MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG11MFP_UART7_TXD (0x06UL << NUMAKER_SYS_GPG_MFP2_PG11MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG11MFP_CCAP_SFIELD (0x07UL << NUMAKER_SYS_GPG_MFP2_PG11MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG11MFP_I2C4_SMBAL (0x08UL << NUMAKER_SYS_GPG_MFP2_PG11MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG11MFP_ECAP2_IC2 (0x09UL << NUMAKER_SYS_GPG_MFP2_PG11MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG11MFP_BPWM0_CH3 (0x0cUL << NUMAKER_SYS_GPG_MFP2_PG11MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG11MFP_HBI_D0 (0x10UL << NUMAKER_SYS_GPG_MFP2_PG11MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG11MFP_SPI8_MOSI (0x13UL << NUMAKER_SYS_GPG_MFP2_PG11MFP_Pos) +#define NUMAKER_SYS_GPG_MFP2_PG11MFP_BMC18 (0x14UL << NUMAKER_SYS_GPG_MFP2_PG11MFP_Pos) + +/* PG.12 MFP */ +#define NUMAKER_SYS_GPG_MFP3_PG12MFP_GPIO (0x00UL << NUMAKER_SYS_GPG_MFP3_PG12MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG12MFP_EBI_AD3 (0x02UL << NUMAKER_SYS_GPG_MFP3_PG12MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG12MFP_SD1_DAT0 (0x03UL << NUMAKER_SYS_GPG_MFP3_PG12MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG12MFP_SPIM_CLK (0x04UL << NUMAKER_SYS_GPG_MFP3_PG12MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG12MFP_QSPI1_CLK (0x05UL << NUMAKER_SYS_GPG_MFP3_PG12MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG12MFP_UART7_RXD (0x06UL << NUMAKER_SYS_GPG_MFP3_PG12MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG12MFP_CCAP_VSYNC (0x07UL << NUMAKER_SYS_GPG_MFP3_PG12MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG12MFP_I2C4_SMBSUS (0x08UL << NUMAKER_SYS_GPG_MFP3_PG12MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG12MFP_BPWM0_CH2 (0x0cUL << NUMAKER_SYS_GPG_MFP3_PG12MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG12MFP_HBI_D1 (0x10UL << NUMAKER_SYS_GPG_MFP3_PG12MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG12MFP_SPI8_MISO (0x13UL << NUMAKER_SYS_GPG_MFP3_PG12MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG12MFP_BMC19 (0x14UL << NUMAKER_SYS_GPG_MFP3_PG12MFP_Pos) + +/* PG.13 MFP */ +#define NUMAKER_SYS_GPG_MFP3_PG13MFP_GPIO (0x00UL << NUMAKER_SYS_GPG_MFP3_PG13MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG13MFP_EBI_AD4 (0x02UL << NUMAKER_SYS_GPG_MFP3_PG13MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG13MFP_SD1_CMD (0x03UL << NUMAKER_SYS_GPG_MFP3_PG13MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG13MFP_SPIM_MISO (0x04UL << NUMAKER_SYS_GPG_MFP3_PG13MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG13MFP_QSPI1_MISO0 (0x05UL << NUMAKER_SYS_GPG_MFP3_PG13MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG13MFP_UART6_TXD (0x06UL << NUMAKER_SYS_GPG_MFP3_PG13MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG13MFP_CCAP_HSYNC (0x07UL << NUMAKER_SYS_GPG_MFP3_PG13MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG13MFP_BPWM0_CH1 (0x0cUL << NUMAKER_SYS_GPG_MFP3_PG13MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG13MFP_HBI_D5 (0x10UL << NUMAKER_SYS_GPG_MFP3_PG13MFP_Pos) + +/* PG.14 MFP */ +#define NUMAKER_SYS_GPG_MFP3_PG14MFP_GPIO (0x00UL << NUMAKER_SYS_GPG_MFP3_PG14MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG14MFP_EBI_AD5 (0x02UL << NUMAKER_SYS_GPG_MFP3_PG14MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG14MFP_SD1_CLK (0x03UL << NUMAKER_SYS_GPG_MFP3_PG14MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG14MFP_SPIM_MOSI (0x04UL << NUMAKER_SYS_GPG_MFP3_PG14MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG14MFP_QSPI1_MOSI0 (0x05UL << NUMAKER_SYS_GPG_MFP3_PG14MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG14MFP_UART6_RXD (0x06UL << NUMAKER_SYS_GPG_MFP3_PG14MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG14MFP_BPWM0_CH0 (0x0cUL << NUMAKER_SYS_GPG_MFP3_PG14MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG14MFP_HBI_D6 (0x10UL << NUMAKER_SYS_GPG_MFP3_PG14MFP_Pos) + +/* PG.15 MFP */ +#define NUMAKER_SYS_GPG_MFP3_PG15MFP_GPIO (0x00UL << NUMAKER_SYS_GPG_MFP3_PG15MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG15MFP_SD1_nCD (0x03UL << NUMAKER_SYS_GPG_MFP3_PG15MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG15MFP_CLKO (0x0eUL << NUMAKER_SYS_GPG_MFP3_PG15MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG15MFP_EADC0_ST (0x0fUL << NUMAKER_SYS_GPG_MFP3_PG15MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG15MFP_HBI_D7 (0x10UL << NUMAKER_SYS_GPG_MFP3_PG15MFP_Pos) +#define NUMAKER_SYS_GPG_MFP3_PG15MFP_QSPI1_MISO1 (0x13UL << NUMAKER_SYS_GPG_MFP3_PG15MFP_Pos) + +/* PH.0 MFP */ +#define NUMAKER_SYS_GPH_MFP0_PH0MFP_GPIO (0x00UL << NUMAKER_SYS_GPH_MFP0_PH0MFP_Pos) +#define NUMAKER_SYS_GPH_MFP0_PH0MFP_EBI_ADR7 (0x02UL << NUMAKER_SYS_GPH_MFP0_PH0MFP_Pos) +#define NUMAKER_SYS_GPH_MFP0_PH0MFP_UART5_TXD (0x04UL << NUMAKER_SYS_GPH_MFP0_PH0MFP_Pos) +#define NUMAKER_SYS_GPH_MFP0_PH0MFP_TM0_EXT (0x0dUL << NUMAKER_SYS_GPH_MFP0_PH0MFP_Pos) + +/* PH.1 MFP */ +#define NUMAKER_SYS_GPH_MFP0_PH1MFP_GPIO (0x00UL << NUMAKER_SYS_GPH_MFP0_PH1MFP_Pos) +#define NUMAKER_SYS_GPH_MFP0_PH1MFP_EBI_ADR6 (0x02UL << NUMAKER_SYS_GPH_MFP0_PH1MFP_Pos) +#define NUMAKER_SYS_GPH_MFP0_PH1MFP_UART5_RXD (0x04UL << NUMAKER_SYS_GPH_MFP0_PH1MFP_Pos) +#define NUMAKER_SYS_GPH_MFP0_PH1MFP_TM1_EXT (0x0dUL << NUMAKER_SYS_GPH_MFP0_PH1MFP_Pos) + +/* PH.2 MFP */ +#define NUMAKER_SYS_GPH_MFP0_PH2MFP_GPIO (0x00UL << NUMAKER_SYS_GPH_MFP0_PH2MFP_Pos) +#define NUMAKER_SYS_GPH_MFP0_PH2MFP_EBI_ADR5 (0x02UL << NUMAKER_SYS_GPH_MFP0_PH2MFP_Pos) +#define NUMAKER_SYS_GPH_MFP0_PH2MFP_UART5_nRTS (0x04UL << NUMAKER_SYS_GPH_MFP0_PH2MFP_Pos) +#define NUMAKER_SYS_GPH_MFP0_PH2MFP_UART4_TXD (0x05UL << NUMAKER_SYS_GPH_MFP0_PH2MFP_Pos) +#define NUMAKER_SYS_GPH_MFP0_PH2MFP_I2C0_SCL (0x06UL << NUMAKER_SYS_GPH_MFP0_PH2MFP_Pos) +#define NUMAKER_SYS_GPH_MFP0_PH2MFP_TM2_EXT (0x0dUL << NUMAKER_SYS_GPH_MFP0_PH2MFP_Pos) + +/* PH.3 MFP */ +#define NUMAKER_SYS_GPH_MFP0_PH3MFP_GPIO (0x00UL << NUMAKER_SYS_GPH_MFP0_PH3MFP_Pos) +#define NUMAKER_SYS_GPH_MFP0_PH3MFP_EBI_ADR4 (0x02UL << NUMAKER_SYS_GPH_MFP0_PH3MFP_Pos) +#define NUMAKER_SYS_GPH_MFP0_PH3MFP_SPI1_I2SMCLK (0x03UL << NUMAKER_SYS_GPH_MFP0_PH3MFP_Pos) +#define NUMAKER_SYS_GPH_MFP0_PH3MFP_UART5_nCTS (0x04UL << NUMAKER_SYS_GPH_MFP0_PH3MFP_Pos) +#define NUMAKER_SYS_GPH_MFP0_PH3MFP_UART4_RXD (0x05UL << NUMAKER_SYS_GPH_MFP0_PH3MFP_Pos) +#define NUMAKER_SYS_GPH_MFP0_PH3MFP_I2C0_SDA (0x06UL << NUMAKER_SYS_GPH_MFP0_PH3MFP_Pos) +#define NUMAKER_SYS_GPH_MFP0_PH3MFP_TM3_EXT (0x0dUL << NUMAKER_SYS_GPH_MFP0_PH3MFP_Pos) + +/* PH.4 MFP */ +#define NUMAKER_SYS_GPH_MFP1_PH4MFP_GPIO (0x00UL << NUMAKER_SYS_GPH_MFP1_PH4MFP_Pos) +#define NUMAKER_SYS_GPH_MFP1_PH4MFP_EBI_ADR3 (0x02UL << NUMAKER_SYS_GPH_MFP1_PH4MFP_Pos) +#define NUMAKER_SYS_GPH_MFP1_PH4MFP_SPI1_MISO (0x03UL << NUMAKER_SYS_GPH_MFP1_PH4MFP_Pos) +#define NUMAKER_SYS_GPH_MFP1_PH4MFP_UART7_nRTS (0x04UL << NUMAKER_SYS_GPH_MFP1_PH4MFP_Pos) +#define NUMAKER_SYS_GPH_MFP1_PH4MFP_UART6_TXD (0x05UL << NUMAKER_SYS_GPH_MFP1_PH4MFP_Pos) + +/* PH.5 MFP */ +#define NUMAKER_SYS_GPH_MFP1_PH5MFP_GPIO (0x00UL << NUMAKER_SYS_GPH_MFP1_PH5MFP_Pos) +#define NUMAKER_SYS_GPH_MFP1_PH5MFP_EBI_ADR2 (0x02UL << NUMAKER_SYS_GPH_MFP1_PH5MFP_Pos) +#define NUMAKER_SYS_GPH_MFP1_PH5MFP_SPI1_MOSI (0x03UL << NUMAKER_SYS_GPH_MFP1_PH5MFP_Pos) +#define NUMAKER_SYS_GPH_MFP1_PH5MFP_UART7_nCTS (0x04UL << NUMAKER_SYS_GPH_MFP1_PH5MFP_Pos) +#define NUMAKER_SYS_GPH_MFP1_PH5MFP_UART6_RXD (0x05UL << NUMAKER_SYS_GPH_MFP1_PH5MFP_Pos) + +/* PH.6 MFP */ +#define NUMAKER_SYS_GPH_MFP1_PH6MFP_GPIO (0x00UL << NUMAKER_SYS_GPH_MFP1_PH6MFP_Pos) +#define NUMAKER_SYS_GPH_MFP1_PH6MFP_EBI_ADR1 (0x02UL << NUMAKER_SYS_GPH_MFP1_PH6MFP_Pos) +#define NUMAKER_SYS_GPH_MFP1_PH6MFP_SPI1_CLK (0x03UL << NUMAKER_SYS_GPH_MFP1_PH6MFP_Pos) +#define NUMAKER_SYS_GPH_MFP1_PH6MFP_UART7_TXD (0x04UL << NUMAKER_SYS_GPH_MFP1_PH6MFP_Pos) +#define NUMAKER_SYS_GPH_MFP1_PH6MFP_UART9_nCTS (0x07UL << NUMAKER_SYS_GPH_MFP1_PH6MFP_Pos) + +/* PH.7 MFP */ +#define NUMAKER_SYS_GPH_MFP1_PH7MFP_GPIO (0x00UL << NUMAKER_SYS_GPH_MFP1_PH7MFP_Pos) +#define NUMAKER_SYS_GPH_MFP1_PH7MFP_EBI_ADR0 (0x02UL << NUMAKER_SYS_GPH_MFP1_PH7MFP_Pos) +#define NUMAKER_SYS_GPH_MFP1_PH7MFP_SPI1_SS (0x03UL << NUMAKER_SYS_GPH_MFP1_PH7MFP_Pos) +#define NUMAKER_SYS_GPH_MFP1_PH7MFP_UART7_RXD (0x04UL << NUMAKER_SYS_GPH_MFP1_PH7MFP_Pos) +#define NUMAKER_SYS_GPH_MFP1_PH7MFP_UART9_nRTS (0x07UL << NUMAKER_SYS_GPH_MFP1_PH7MFP_Pos) + +/* PH.8 MFP */ +#define NUMAKER_SYS_GPH_MFP2_PH8MFP_GPIO (0x00UL << NUMAKER_SYS_GPH_MFP2_PH8MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH8MFP_EBI_AD12 (0x02UL << NUMAKER_SYS_GPH_MFP2_PH8MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH8MFP_QSPI0_CLK (0x03UL << NUMAKER_SYS_GPH_MFP2_PH8MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH8MFP_SC2_PWR (0x04UL << NUMAKER_SYS_GPH_MFP2_PH8MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH8MFP_I2S0_DI (0x05UL << NUMAKER_SYS_GPH_MFP2_PH8MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH8MFP_SPI1_CLK (0x06UL << NUMAKER_SYS_GPH_MFP2_PH8MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH8MFP_UART3_nRTS (0x07UL << NUMAKER_SYS_GPH_MFP2_PH8MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH8MFP_I2C1_SMBAL (0x08UL << NUMAKER_SYS_GPH_MFP2_PH8MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH8MFP_I2C2_SCL (0x09UL << NUMAKER_SYS_GPH_MFP2_PH8MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH8MFP_UART1_TXD (0x0aUL << NUMAKER_SYS_GPH_MFP2_PH8MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH8MFP_UART9_nCTS (0x0dUL << NUMAKER_SYS_GPH_MFP2_PH8MFP_Pos) + +/* PH.9 MFP */ +#define NUMAKER_SYS_GPH_MFP2_PH9MFP_GPIO (0x00UL << NUMAKER_SYS_GPH_MFP2_PH9MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH9MFP_EBI_AD13 (0x02UL << NUMAKER_SYS_GPH_MFP2_PH9MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH9MFP_QSPI0_SS (0x03UL << NUMAKER_SYS_GPH_MFP2_PH9MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH9MFP_SC2_RST (0x04UL << NUMAKER_SYS_GPH_MFP2_PH9MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH9MFP_I2S0_DO (0x05UL << NUMAKER_SYS_GPH_MFP2_PH9MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH9MFP_SPI1_SS (0x06UL << NUMAKER_SYS_GPH_MFP2_PH9MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH9MFP_UART3_nCTS (0x07UL << NUMAKER_SYS_GPH_MFP2_PH9MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH9MFP_I2C1_SMBSUS (0x08UL << NUMAKER_SYS_GPH_MFP2_PH9MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH9MFP_I2C2_SDA (0x09UL << NUMAKER_SYS_GPH_MFP2_PH9MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH9MFP_UART1_RXD (0x0aUL << NUMAKER_SYS_GPH_MFP2_PH9MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH9MFP_UART9_nRTS (0x0dUL << NUMAKER_SYS_GPH_MFP2_PH9MFP_Pos) + +/* PH.10 MFP */ +#define NUMAKER_SYS_GPH_MFP2_PH10MFP_GPIO (0x00UL << NUMAKER_SYS_GPH_MFP2_PH10MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH10MFP_EBI_AD14 (0x02UL << NUMAKER_SYS_GPH_MFP2_PH10MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH10MFP_QSPI0_MISO1 (0x03UL << NUMAKER_SYS_GPH_MFP2_PH10MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH10MFP_SC2_nCD (0x04UL << NUMAKER_SYS_GPH_MFP2_PH10MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH10MFP_I2S0_LRCK (0x05UL << NUMAKER_SYS_GPH_MFP2_PH10MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH10MFP_SPI1_I2SMCLK (0x06UL << NUMAKER_SYS_GPH_MFP2_PH10MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH10MFP_UART4_TXD (0x07UL << NUMAKER_SYS_GPH_MFP2_PH10MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH10MFP_UART0_TXD (0x08UL << NUMAKER_SYS_GPH_MFP2_PH10MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH10MFP_UART9_TXD (0x0dUL << NUMAKER_SYS_GPH_MFP2_PH10MFP_Pos) + +/* PH.11 MFP */ +#define NUMAKER_SYS_GPH_MFP2_PH11MFP_GPIO (0x00UL << NUMAKER_SYS_GPH_MFP2_PH11MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH11MFP_EBI_AD15 (0x02UL << NUMAKER_SYS_GPH_MFP2_PH11MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH11MFP_QSPI0_MOSI1 (0x03UL << NUMAKER_SYS_GPH_MFP2_PH11MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH11MFP_UART4_RXD (0x07UL << NUMAKER_SYS_GPH_MFP2_PH11MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH11MFP_UART0_RXD (0x08UL << NUMAKER_SYS_GPH_MFP2_PH11MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH11MFP_EPWM0_CH5 (0x0bUL << NUMAKER_SYS_GPH_MFP2_PH11MFP_Pos) +#define NUMAKER_SYS_GPH_MFP2_PH11MFP_UART9_RXD (0x0dUL << NUMAKER_SYS_GPH_MFP2_PH11MFP_Pos) + +/* PH.12 MFP */ +#define NUMAKER_SYS_GPH_MFP3_PH12MFP_GPIO (0x00UL << NUMAKER_SYS_GPH_MFP3_PH12MFP_Pos) +#define NUMAKER_SYS_GPH_MFP3_PH12MFP_EBI_AD0 (0x02UL << NUMAKER_SYS_GPH_MFP3_PH12MFP_Pos) +#define NUMAKER_SYS_GPH_MFP3_PH12MFP_UART9_TXD (0x03UL << NUMAKER_SYS_GPH_MFP3_PH12MFP_Pos) +#define NUMAKER_SYS_GPH_MFP3_PH12MFP_QSPI1_MISO1 (0x06UL << NUMAKER_SYS_GPH_MFP3_PH12MFP_Pos) +#define NUMAKER_SYS_GPH_MFP3_PH12MFP_CCAP_PIXCLK (0x07UL << NUMAKER_SYS_GPH_MFP3_PH12MFP_Pos) +#define NUMAKER_SYS_GPH_MFP3_PH12MFP_CAN3_TXD (0x0aUL << NUMAKER_SYS_GPH_MFP3_PH12MFP_Pos) +#define NUMAKER_SYS_GPH_MFP3_PH12MFP_HBI_nCK (0x10UL << NUMAKER_SYS_GPH_MFP3_PH12MFP_Pos) + +/* PH.13 MFP */ +#define NUMAKER_SYS_GPH_MFP3_PH13MFP_GPIO (0x00UL << NUMAKER_SYS_GPH_MFP3_PH13MFP_Pos) +#define NUMAKER_SYS_GPH_MFP3_PH13MFP_EBI_AD1 (0x02UL << NUMAKER_SYS_GPH_MFP3_PH13MFP_Pos) +#define NUMAKER_SYS_GPH_MFP3_PH13MFP_UART9_RXD (0x03UL << NUMAKER_SYS_GPH_MFP3_PH13MFP_Pos) +#define NUMAKER_SYS_GPH_MFP3_PH13MFP_QSPI1_MOSI1 (0x06UL << NUMAKER_SYS_GPH_MFP3_PH13MFP_Pos) +#define NUMAKER_SYS_GPH_MFP3_PH13MFP_CCAP_SCLK (0x07UL << NUMAKER_SYS_GPH_MFP3_PH13MFP_Pos) +#define NUMAKER_SYS_GPH_MFP3_PH13MFP_CAN3_RXD (0x0aUL << NUMAKER_SYS_GPH_MFP3_PH13MFP_Pos) +#define NUMAKER_SYS_GPH_MFP3_PH13MFP_HBI_nCS (0x10UL << NUMAKER_SYS_GPH_MFP3_PH13MFP_Pos) + +/* PH.14 MFP */ +#define NUMAKER_SYS_GPH_MFP3_PH14MFP_GPIO (0x00UL << NUMAKER_SYS_GPH_MFP3_PH14MFP_Pos) +#define NUMAKER_SYS_GPH_MFP3_PH14MFP_EBI_AD2 (0x02UL << NUMAKER_SYS_GPH_MFP3_PH14MFP_Pos) +#define NUMAKER_SYS_GPH_MFP3_PH14MFP_QSPI1_SS (0x06UL << NUMAKER_SYS_GPH_MFP3_PH14MFP_Pos) +#define NUMAKER_SYS_GPH_MFP3_PH14MFP_CCAP_SFIELD (0x07UL << NUMAKER_SYS_GPH_MFP3_PH14MFP_Pos) +#define NUMAKER_SYS_GPH_MFP3_PH14MFP_HBI_D3 (0x10UL << NUMAKER_SYS_GPH_MFP3_PH14MFP_Pos) + +/* PH.15 MFP */ +#define NUMAKER_SYS_GPH_MFP3_PH15MFP_GPIO (0x00UL << NUMAKER_SYS_GPH_MFP3_PH15MFP_Pos) +#define NUMAKER_SYS_GPH_MFP3_PH15MFP_EBI_AD3 (0x02UL << NUMAKER_SYS_GPH_MFP3_PH15MFP_Pos) +#define NUMAKER_SYS_GPH_MFP3_PH15MFP_QSPI1_CLK (0x06UL << NUMAKER_SYS_GPH_MFP3_PH15MFP_Pos) +#define NUMAKER_SYS_GPH_MFP3_PH15MFP_CCAP_VSYNC (0x07UL << NUMAKER_SYS_GPH_MFP3_PH15MFP_Pos) +#define NUMAKER_SYS_GPH_MFP3_PH15MFP_HBI_D2 (0x10UL << NUMAKER_SYS_GPH_MFP3_PH15MFP_Pos) + +/* PI.6 MFP */ +#define NUMAKER_SYS_GPI_MFP1_PI6MFP_GPIO (0x00UL << NUMAKER_SYS_GPI_MFP1_PI6MFP_Pos) +#define NUMAKER_SYS_GPI_MFP1_PI6MFP_SC1_nCD (0x05UL << NUMAKER_SYS_GPI_MFP1_PI6MFP_Pos) +#define NUMAKER_SYS_GPI_MFP1_PI6MFP_I2S0_BCLK (0x06UL << NUMAKER_SYS_GPI_MFP1_PI6MFP_Pos) +#define NUMAKER_SYS_GPI_MFP1_PI6MFP_SPI1_I2SMCLK (0x07UL << NUMAKER_SYS_GPI_MFP1_PI6MFP_Pos) +#define NUMAKER_SYS_GPI_MFP1_PI6MFP_UART2_TXD (0x08UL << NUMAKER_SYS_GPI_MFP1_PI6MFP_Pos) +#define NUMAKER_SYS_GPI_MFP1_PI6MFP_I2C1_SCL (0x09UL << NUMAKER_SYS_GPI_MFP1_PI6MFP_Pos) +#define NUMAKER_SYS_GPI_MFP1_PI6MFP_CAN3_TXD (0x0dUL << NUMAKER_SYS_GPI_MFP1_PI6MFP_Pos) +#define NUMAKER_SYS_GPI_MFP1_PI6MFP_USB_VBUS_ST (0x0fUL << NUMAKER_SYS_GPI_MFP1_PI6MFP_Pos) + +/* PI.7 MFP */ +#define NUMAKER_SYS_GPI_MFP1_PI7MFP_GPIO (0x00UL << NUMAKER_SYS_GPI_MFP1_PI7MFP_Pos) +#define NUMAKER_SYS_GPI_MFP1_PI7MFP_SC1_PWR (0x05UL << NUMAKER_SYS_GPI_MFP1_PI7MFP_Pos) +#define NUMAKER_SYS_GPI_MFP1_PI7MFP_I2S0_MCLK (0x06UL << NUMAKER_SYS_GPI_MFP1_PI7MFP_Pos) +#define NUMAKER_SYS_GPI_MFP1_PI7MFP_SPI1_MISO (0x07UL << NUMAKER_SYS_GPI_MFP1_PI7MFP_Pos) +#define NUMAKER_SYS_GPI_MFP1_PI7MFP_UART2_RXD (0x08UL << NUMAKER_SYS_GPI_MFP1_PI7MFP_Pos) +#define NUMAKER_SYS_GPI_MFP1_PI7MFP_I2C1_SDA (0x09UL << NUMAKER_SYS_GPI_MFP1_PI7MFP_Pos) +#define NUMAKER_SYS_GPI_MFP1_PI7MFP_CAN3_RXD (0x0dUL << NUMAKER_SYS_GPI_MFP1_PI7MFP_Pos) +#define NUMAKER_SYS_GPI_MFP1_PI7MFP_USB_VBUS_EN (0x0fUL << NUMAKER_SYS_GPI_MFP1_PI7MFP_Pos) + +/* PI.8 MFP */ +#define NUMAKER_SYS_GPI_MFP2_PI8MFP_GPIO (0x00UL << NUMAKER_SYS_GPI_MFP2_PI8MFP_Pos) +#define NUMAKER_SYS_GPI_MFP2_PI8MFP_SC1_RST (0x05UL << NUMAKER_SYS_GPI_MFP2_PI8MFP_Pos) +#define NUMAKER_SYS_GPI_MFP2_PI8MFP_I2S0_DI (0x06UL << NUMAKER_SYS_GPI_MFP2_PI8MFP_Pos) +#define NUMAKER_SYS_GPI_MFP2_PI8MFP_SPI1_MOSI (0x07UL << NUMAKER_SYS_GPI_MFP2_PI8MFP_Pos) +#define NUMAKER_SYS_GPI_MFP2_PI8MFP_UART2_nRTS (0x08UL << NUMAKER_SYS_GPI_MFP2_PI8MFP_Pos) +#define NUMAKER_SYS_GPI_MFP2_PI8MFP_I2C0_SMBAL (0x09UL << NUMAKER_SYS_GPI_MFP2_PI8MFP_Pos) +#define NUMAKER_SYS_GPI_MFP2_PI8MFP_CAN2_TXD (0x0dUL << NUMAKER_SYS_GPI_MFP2_PI8MFP_Pos) + +/* PI.9 MFP */ +#define NUMAKER_SYS_GPI_MFP2_PI9MFP_GPIO (0x00UL << NUMAKER_SYS_GPI_MFP2_PI9MFP_Pos) +#define NUMAKER_SYS_GPI_MFP2_PI9MFP_SC1_DAT (0x05UL << NUMAKER_SYS_GPI_MFP2_PI9MFP_Pos) +#define NUMAKER_SYS_GPI_MFP2_PI9MFP_I2S0_DO (0x06UL << NUMAKER_SYS_GPI_MFP2_PI9MFP_Pos) +#define NUMAKER_SYS_GPI_MFP2_PI9MFP_SPI1_CLK (0x07UL << NUMAKER_SYS_GPI_MFP2_PI9MFP_Pos) +#define NUMAKER_SYS_GPI_MFP2_PI9MFP_UART2_nCTS (0x08UL << NUMAKER_SYS_GPI_MFP2_PI9MFP_Pos) +#define NUMAKER_SYS_GPI_MFP2_PI9MFP_I2C0_SMBSUS (0x09UL << NUMAKER_SYS_GPI_MFP2_PI9MFP_Pos) +#define NUMAKER_SYS_GPI_MFP2_PI9MFP_CAN2_RXD (0x0dUL << NUMAKER_SYS_GPI_MFP2_PI9MFP_Pos) + +/* PI.10 MFP */ +#define NUMAKER_SYS_GPI_MFP2_PI10MFP_GPIO (0x00UL << NUMAKER_SYS_GPI_MFP2_PI10MFP_Pos) +#define NUMAKER_SYS_GPI_MFP2_PI10MFP_SC1_CLK (0x05UL << NUMAKER_SYS_GPI_MFP2_PI10MFP_Pos) +#define NUMAKER_SYS_GPI_MFP2_PI10MFP_I2S0_LRCK (0x06UL << NUMAKER_SYS_GPI_MFP2_PI10MFP_Pos) +#define NUMAKER_SYS_GPI_MFP2_PI10MFP_SPI1_SS (0x07UL << NUMAKER_SYS_GPI_MFP2_PI10MFP_Pos) +#define NUMAKER_SYS_GPI_MFP2_PI10MFP_UART2_TXD (0x08UL << NUMAKER_SYS_GPI_MFP2_PI10MFP_Pos) +#define NUMAKER_SYS_GPI_MFP2_PI10MFP_I2C0_SCL (0x09UL << NUMAKER_SYS_GPI_MFP2_PI10MFP_Pos) +#define NUMAKER_SYS_GPI_MFP2_PI10MFP_CAN3_TXD (0x0dUL << NUMAKER_SYS_GPI_MFP2_PI10MFP_Pos) + +/* PI.11 MFP */ +#define NUMAKER_SYS_GPI_MFP2_PI11MFP_GPIO (0x00UL << NUMAKER_SYS_GPI_MFP2_PI11MFP_Pos) +#define NUMAKER_SYS_GPI_MFP2_PI11MFP_UART2_RXD (0x08UL << NUMAKER_SYS_GPI_MFP2_PI11MFP_Pos) +#define NUMAKER_SYS_GPI_MFP2_PI11MFP_I2C0_SDA (0x09UL << NUMAKER_SYS_GPI_MFP2_PI11MFP_Pos) +#define NUMAKER_SYS_GPI_MFP2_PI11MFP_CAN3_RXD (0x0dUL << NUMAKER_SYS_GPI_MFP2_PI11MFP_Pos) + +/* PI.12 MFP */ +#define NUMAKER_SYS_GPI_MFP3_PI12MFP_GPIO (0x00UL << NUMAKER_SYS_GPI_MFP3_PI12MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI12MFP_SPIM_SS (0x03UL << NUMAKER_SYS_GPI_MFP3_PI12MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI12MFP_QSPI0_MISO1 (0x04UL << NUMAKER_SYS_GPI_MFP3_PI12MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI12MFP_CAN0_TXD (0x0aUL << NUMAKER_SYS_GPI_MFP3_PI12MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI12MFP_UART4_TXD (0x0bUL << NUMAKER_SYS_GPI_MFP3_PI12MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI12MFP_EPWM1_CH0 (0x0cUL << NUMAKER_SYS_GPI_MFP3_PI12MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI12MFP_I2C3_SMBAL (0x0fUL << NUMAKER_SYS_GPI_MFP3_PI12MFP_Pos) + +/* PI.13 MFP */ +#define NUMAKER_SYS_GPI_MFP3_PI13MFP_GPIO (0x00UL << NUMAKER_SYS_GPI_MFP3_PI13MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI13MFP_SPIM_MISO (0x03UL << NUMAKER_SYS_GPI_MFP3_PI13MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI13MFP_QSPI0_MOSI1 (0x04UL << NUMAKER_SYS_GPI_MFP3_PI13MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI13MFP_CAN0_RXD (0x0aUL << NUMAKER_SYS_GPI_MFP3_PI13MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI13MFP_UART4_RXD (0x0bUL << NUMAKER_SYS_GPI_MFP3_PI13MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI13MFP_EPWM1_CH1 (0x0cUL << NUMAKER_SYS_GPI_MFP3_PI13MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI13MFP_I2C3_SMBSUS (0x0fUL << NUMAKER_SYS_GPI_MFP3_PI13MFP_Pos) + +/* PI.14 MFP */ +#define NUMAKER_SYS_GPI_MFP3_PI14MFP_GPIO (0x00UL << NUMAKER_SYS_GPI_MFP3_PI14MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI14MFP_SPIM_D2 (0x03UL << NUMAKER_SYS_GPI_MFP3_PI14MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI14MFP_QSPI0_SS (0x04UL << NUMAKER_SYS_GPI_MFP3_PI14MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI14MFP_UART8_nCTS (0x07UL << NUMAKER_SYS_GPI_MFP3_PI14MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI14MFP_CAN1_TXD (0x0aUL << NUMAKER_SYS_GPI_MFP3_PI14MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI14MFP_UART3_TXD (0x0bUL << NUMAKER_SYS_GPI_MFP3_PI14MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI14MFP_EPWM1_CH2 (0x0cUL << NUMAKER_SYS_GPI_MFP3_PI14MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI14MFP_I2C3_SCL (0x0fUL << NUMAKER_SYS_GPI_MFP3_PI14MFP_Pos) + +/* PI.15 MFP */ +#define NUMAKER_SYS_GPI_MFP3_PI15MFP_GPIO (0x00UL << NUMAKER_SYS_GPI_MFP3_PI15MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI15MFP_SPIM_D3 (0x03UL << NUMAKER_SYS_GPI_MFP3_PI15MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI15MFP_QSPI0_CLK (0x04UL << NUMAKER_SYS_GPI_MFP3_PI15MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI15MFP_UART8_nRTS (0x07UL << NUMAKER_SYS_GPI_MFP3_PI15MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI15MFP_CAN1_RXD (0x0aUL << NUMAKER_SYS_GPI_MFP3_PI15MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI15MFP_UART3_RXD (0x0bUL << NUMAKER_SYS_GPI_MFP3_PI15MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI15MFP_EPWM1_CH3 (0x0cUL << NUMAKER_SYS_GPI_MFP3_PI15MFP_Pos) +#define NUMAKER_SYS_GPI_MFP3_PI15MFP_I2C3_SDA (0x0fUL << NUMAKER_SYS_GPI_MFP3_PI15MFP_Pos) + +/* PJ.0 MFP */ +#define NUMAKER_SYS_GPJ_MFP0_PJ0MFP_GPIO (0x00UL << NUMAKER_SYS_GPJ_MFP0_PJ0MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP0_PJ0MFP_SPIM_CLK (0x03UL << NUMAKER_SYS_GPJ_MFP0_PJ0MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP0_PJ0MFP_QSPI0_MISO0 (0x04UL << NUMAKER_SYS_GPJ_MFP0_PJ0MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP0_PJ0MFP_UART8_TXD (0x07UL << NUMAKER_SYS_GPJ_MFP0_PJ0MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP0_PJ0MFP_CAN2_TXD (0x0aUL << NUMAKER_SYS_GPJ_MFP0_PJ0MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP0_PJ0MFP_EPWM1_CH4 (0x0cUL << NUMAKER_SYS_GPJ_MFP0_PJ0MFP_Pos) + +/* PJ.1 MFP */ +#define NUMAKER_SYS_GPJ_MFP0_PJ1MFP_GPIO (0x00UL << NUMAKER_SYS_GPJ_MFP0_PJ1MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP0_PJ1MFP_SPIM_MOSI (0x03UL << NUMAKER_SYS_GPJ_MFP0_PJ1MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP0_PJ1MFP_QSPI0_MOSI0 (0x04UL << NUMAKER_SYS_GPJ_MFP0_PJ1MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP0_PJ1MFP_UART8_RXD (0x07UL << NUMAKER_SYS_GPJ_MFP0_PJ1MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP0_PJ1MFP_CAN2_RXD (0x0aUL << NUMAKER_SYS_GPJ_MFP0_PJ1MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP0_PJ1MFP_EPWM1_CH5 (0x0cUL << NUMAKER_SYS_GPJ_MFP0_PJ1MFP_Pos) + +/* PJ.2 MFP */ +#define NUMAKER_SYS_GPJ_MFP0_PJ2MFP_GPIO (0x00UL << NUMAKER_SYS_GPJ_MFP0_PJ2MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP0_PJ2MFP_EBI_AD5 (0x02UL << NUMAKER_SYS_GPJ_MFP0_PJ2MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP0_PJ2MFP_UART8_nCTS (0x03UL << NUMAKER_SYS_GPJ_MFP0_PJ2MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP0_PJ2MFP_QSPI1_SS (0x06UL << NUMAKER_SYS_GPJ_MFP0_PJ2MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP0_PJ2MFP_CCAP_DATA5 (0x07UL << NUMAKER_SYS_GPJ_MFP0_PJ2MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP0_PJ2MFP_CAN0_TXD (0x0aUL << NUMAKER_SYS_GPJ_MFP0_PJ2MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP0_PJ2MFP_HBI_RWDS (0x10UL << NUMAKER_SYS_GPJ_MFP0_PJ2MFP_Pos) + +/* PJ.3 MFP */ +#define NUMAKER_SYS_GPJ_MFP0_PJ3MFP_GPIO (0x00UL << NUMAKER_SYS_GPJ_MFP0_PJ3MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP0_PJ3MFP_EBI_AD4 (0x02UL << NUMAKER_SYS_GPJ_MFP0_PJ3MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP0_PJ3MFP_UART8_nRTS (0x03UL << NUMAKER_SYS_GPJ_MFP0_PJ3MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP0_PJ3MFP_QSPI1_CLK (0x06UL << NUMAKER_SYS_GPJ_MFP0_PJ3MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP0_PJ3MFP_CCAP_DATA4 (0x07UL << NUMAKER_SYS_GPJ_MFP0_PJ3MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP0_PJ3MFP_CAN0_RXD (0x0aUL << NUMAKER_SYS_GPJ_MFP0_PJ3MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP0_PJ3MFP_HBI_D7 (0x10UL << NUMAKER_SYS_GPJ_MFP0_PJ3MFP_Pos) + +/* PJ.4 MFP */ +#define NUMAKER_SYS_GPJ_MFP1_PJ4MFP_GPIO (0x00UL << NUMAKER_SYS_GPJ_MFP1_PJ4MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP1_PJ4MFP_EBI_AD3 (0x02UL << NUMAKER_SYS_GPJ_MFP1_PJ4MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP1_PJ4MFP_UART8_TXD (0x03UL << NUMAKER_SYS_GPJ_MFP1_PJ4MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP1_PJ4MFP_QSPI1_MISO0 (0x06UL << NUMAKER_SYS_GPJ_MFP1_PJ4MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP1_PJ4MFP_CCAP_DATA3 (0x07UL << NUMAKER_SYS_GPJ_MFP1_PJ4MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP1_PJ4MFP_CAN1_TXD (0x0aUL << NUMAKER_SYS_GPJ_MFP1_PJ4MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP1_PJ4MFP_HBI_D6 (0x10UL << NUMAKER_SYS_GPJ_MFP1_PJ4MFP_Pos) + +/* PJ.5 MFP */ +#define NUMAKER_SYS_GPJ_MFP1_PJ5MFP_GPIO (0x00UL << NUMAKER_SYS_GPJ_MFP1_PJ5MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP1_PJ5MFP_EBI_AD2 (0x02UL << NUMAKER_SYS_GPJ_MFP1_PJ5MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP1_PJ5MFP_UART8_RXD (0x03UL << NUMAKER_SYS_GPJ_MFP1_PJ5MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP1_PJ5MFP_QSPI1_MOSI0 (0x06UL << NUMAKER_SYS_GPJ_MFP1_PJ5MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP1_PJ5MFP_CCAP_DATA2 (0x07UL << NUMAKER_SYS_GPJ_MFP1_PJ5MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP1_PJ5MFP_CAN1_RXD (0x0aUL << NUMAKER_SYS_GPJ_MFP1_PJ5MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP1_PJ5MFP_HBI_D5 (0x10UL << NUMAKER_SYS_GPJ_MFP1_PJ5MFP_Pos) + +/* PJ.6 MFP */ +#define NUMAKER_SYS_GPJ_MFP1_PJ6MFP_GPIO (0x00UL << NUMAKER_SYS_GPJ_MFP1_PJ6MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP1_PJ6MFP_EBI_AD1 (0x02UL << NUMAKER_SYS_GPJ_MFP1_PJ6MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP1_PJ6MFP_UART9_nCTS (0x03UL << NUMAKER_SYS_GPJ_MFP1_PJ6MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP1_PJ6MFP_CCAP_DATA1 (0x07UL << NUMAKER_SYS_GPJ_MFP1_PJ6MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP1_PJ6MFP_CAN2_TXD (0x0aUL << NUMAKER_SYS_GPJ_MFP1_PJ6MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP1_PJ6MFP_HBI_D4 (0x10UL << NUMAKER_SYS_GPJ_MFP1_PJ6MFP_Pos) + +/* PJ.7 MFP */ +#define NUMAKER_SYS_GPJ_MFP1_PJ7MFP_GPIO (0x00UL << NUMAKER_SYS_GPJ_MFP1_PJ7MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP1_PJ7MFP_EBI_AD0 (0x02UL << NUMAKER_SYS_GPJ_MFP1_PJ7MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP1_PJ7MFP_UART9_nRTS (0x03UL << NUMAKER_SYS_GPJ_MFP1_PJ7MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP1_PJ7MFP_CCAP_DATA0 (0x07UL << NUMAKER_SYS_GPJ_MFP1_PJ7MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP1_PJ7MFP_CAN2_RXD (0x0aUL << NUMAKER_SYS_GPJ_MFP1_PJ7MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP1_PJ7MFP_HBI_CK (0x10UL << NUMAKER_SYS_GPJ_MFP1_PJ7MFP_Pos) + +/* PJ.8 MFP */ +#define NUMAKER_SYS_GPJ_MFP2_PJ8MFP_GPIO (0x00UL << NUMAKER_SYS_GPJ_MFP2_PJ8MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ8MFP_EBI_nRD (0x02UL << NUMAKER_SYS_GPJ_MFP2_PJ8MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ8MFP_SD1_DAT3 (0x03UL << NUMAKER_SYS_GPJ_MFP2_PJ8MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ8MFP_SPIM_SS (0x04UL << NUMAKER_SYS_GPJ_MFP2_PJ8MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ8MFP_UART7_TXD (0x06UL << NUMAKER_SYS_GPJ_MFP2_PJ8MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ8MFP_CAN2_TXD (0x0bUL << NUMAKER_SYS_GPJ_MFP2_PJ8MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ8MFP_BPWM0_CH5 (0x0cUL << NUMAKER_SYS_GPJ_MFP2_PJ8MFP_Pos) + +/* PJ.9 MFP */ +#define NUMAKER_SYS_GPJ_MFP2_PJ9MFP_GPIO (0x00UL << NUMAKER_SYS_GPJ_MFP2_PJ9MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ9MFP_EBI_nWR (0x02UL << NUMAKER_SYS_GPJ_MFP2_PJ9MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ9MFP_SD1_DAT2 (0x03UL << NUMAKER_SYS_GPJ_MFP2_PJ9MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ9MFP_SPIM_MISO (0x04UL << NUMAKER_SYS_GPJ_MFP2_PJ9MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ9MFP_UART7_RXD (0x06UL << NUMAKER_SYS_GPJ_MFP2_PJ9MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ9MFP_CAN2_RXD (0x0bUL << NUMAKER_SYS_GPJ_MFP2_PJ9MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ9MFP_BPWM0_CH4 (0x0cUL << NUMAKER_SYS_GPJ_MFP2_PJ9MFP_Pos) + +/* PJ.10 MFP */ +#define NUMAKER_SYS_GPJ_MFP2_PJ10MFP_GPIO (0x00UL << NUMAKER_SYS_GPJ_MFP2_PJ10MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ10MFP_EBI_MCLK (0x02UL << NUMAKER_SYS_GPJ_MFP2_PJ10MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ10MFP_SD1_DAT1 (0x03UL << NUMAKER_SYS_GPJ_MFP2_PJ10MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ10MFP_SPIM_D2 (0x04UL << NUMAKER_SYS_GPJ_MFP2_PJ10MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ10MFP_UART6_TXD (0x06UL << NUMAKER_SYS_GPJ_MFP2_PJ10MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ10MFP_I2C4_SCL (0x08UL << NUMAKER_SYS_GPJ_MFP2_PJ10MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ10MFP_ECAP2_IC0 (0x09UL << NUMAKER_SYS_GPJ_MFP2_PJ10MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ10MFP_CAN0_TXD (0x0bUL << NUMAKER_SYS_GPJ_MFP2_PJ10MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ10MFP_BPWM0_CH3 (0x0cUL << NUMAKER_SYS_GPJ_MFP2_PJ10MFP_Pos) + +/* PJ.11 MFP */ +#define NUMAKER_SYS_GPJ_MFP2_PJ11MFP_GPIO (0x00UL << NUMAKER_SYS_GPJ_MFP2_PJ11MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ11MFP_EBI_ALE (0x02UL << NUMAKER_SYS_GPJ_MFP2_PJ11MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ11MFP_SD1_DAT0 (0x03UL << NUMAKER_SYS_GPJ_MFP2_PJ11MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ11MFP_SPIM_D3 (0x04UL << NUMAKER_SYS_GPJ_MFP2_PJ11MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ11MFP_UART6_RXD (0x06UL << NUMAKER_SYS_GPJ_MFP2_PJ11MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ11MFP_I2C4_SDA (0x08UL << NUMAKER_SYS_GPJ_MFP2_PJ11MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ11MFP_ECAP2_IC1 (0x09UL << NUMAKER_SYS_GPJ_MFP2_PJ11MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ11MFP_CAN0_RXD (0x0bUL << NUMAKER_SYS_GPJ_MFP2_PJ11MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP2_PJ11MFP_BPWM0_CH2 (0x0cUL << NUMAKER_SYS_GPJ_MFP2_PJ11MFP_Pos) + +/* PJ.12 MFP */ +#define NUMAKER_SYS_GPJ_MFP3_PJ12MFP_GPIO (0x00UL << NUMAKER_SYS_GPJ_MFP3_PJ12MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP3_PJ12MFP_EBI_nCS0 (0x02UL << NUMAKER_SYS_GPJ_MFP3_PJ12MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP3_PJ12MFP_SD1_CMD (0x03UL << NUMAKER_SYS_GPJ_MFP3_PJ12MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP3_PJ12MFP_SPIM_CLK (0x04UL << NUMAKER_SYS_GPJ_MFP3_PJ12MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP3_PJ12MFP_I2C4_SMBAL (0x08UL << NUMAKER_SYS_GPJ_MFP3_PJ12MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP3_PJ12MFP_ECAP2_IC2 (0x09UL << NUMAKER_SYS_GPJ_MFP3_PJ12MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP3_PJ12MFP_CAN1_TXD (0x0bUL << NUMAKER_SYS_GPJ_MFP3_PJ12MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP3_PJ12MFP_BPWM0_CH1 (0x0cUL << NUMAKER_SYS_GPJ_MFP3_PJ12MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP3_PJ12MFP_HSUSB_VBUS_ST (0x0fUL << NUMAKER_SYS_GPJ_MFP3_PJ12MFP_Pos) + +/* PJ.13 MFP */ +#define NUMAKER_SYS_GPJ_MFP3_PJ13MFP_GPIO (0x00UL << NUMAKER_SYS_GPJ_MFP3_PJ13MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP3_PJ13MFP_SD1_CLK (0x03UL << NUMAKER_SYS_GPJ_MFP3_PJ13MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP3_PJ13MFP_SPIM_MOSI (0x04UL << NUMAKER_SYS_GPJ_MFP3_PJ13MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP3_PJ13MFP_I2C4_SMBSUS (0x08UL << NUMAKER_SYS_GPJ_MFP3_PJ13MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP3_PJ13MFP_CAN1_RXD (0x0bUL << NUMAKER_SYS_GPJ_MFP3_PJ13MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP3_PJ13MFP_BPWM0_CH0 (0x0cUL << NUMAKER_SYS_GPJ_MFP3_PJ13MFP_Pos) +#define NUMAKER_SYS_GPJ_MFP3_PJ13MFP_HSUSB_VBUS_EN (0x0fUL << NUMAKER_SYS_GPJ_MFP3_PJ13MFP_Pos) + +/* End of M460 BSP sys.h pin-mux module copy */ + +#endif diff --git a/soc/arm/nuvoton_numaker/common/pinctrl_soc.h b/soc/arm/nuvoton_numaker/common/pinctrl_soc.h new file mode 100644 index 00000000000..9a8320bdff2 --- /dev/null +++ b/soc/arm/nuvoton_numaker/common/pinctrl_soc.h @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2023 Nuvoton Technology Corporation. + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef _NUVOTON_NUMAKER_PINCTRL_SOC_H_ +#define _NUVOTON_NUMAKER_PINCTRL_SOC_H_ + +#include +#include + +#define PORT_INDEX(pinmux) (((pinmux)&0xF0000000) >> 28) +#define PIN_INDEX(pinmux) (((pinmux)&0x0F000000) >> 24) +#define MFP_CFG(pinmux) (((pinmux)&0x000000FF) << ((PIN_INDEX(pinmux) % 4) * 8)) +#define NU_MFP_POS(pinindex) ((pinindex % 4) * 8) +#define NU_MFP_MASK(pinindex) (0x1f << NU_MFP_POS(pinindex)) + +typedef struct pinctrl_soc_pin_t { + uint32_t pin_mux; +} pinctrl_soc_pin_t; + +#define NUMAKER_DT_PIN(node_id, prop, idx) {.pin_mux = DT_PROP_BY_IDX(node_id, prop, idx)}, + +#define Z_PINCTRL_STATE_PIN_INIT(node_id, prop, idx) NUMAKER_DT_PIN(node_id, prop, idx) + +#define Z_PINCTRL_STATE_PINS_INIT(node_id, prop) \ + { \ + DT_FOREACH_PROP_ELEM(DT_PHANDLE(node_id, prop), pinmux, Z_PINCTRL_STATE_PIN_INIT) \ + } + +#endif /* _NUVOTON_NUMAKER_PINCTRL_SOC_H_ */