diff --git a/Cargo.lock b/Cargo.lock
index 3a908f8..ea23f02 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -71,6 +71,7 @@ dependencies = [
  "fugit",
  "hex-literal",
  "panic-halt",
+ "paste",
  "proposed-traits",
 ]
 
@@ -319,6 +320,12 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a513e167849a384b7f9b746e517604398518590a9142f4846a32e3c2a4de7b11"
 
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.95"
diff --git a/Cargo.toml b/Cargo.toml
index b5b3b28..0b117f2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,6 +33,7 @@ embedded-io = "0.6.1"
 fugit = "0.3.7"
 proposed-traits = { git = "https://github.com/rusty1968/proposed_traits.git", package = "proposed-traits", rev = "85641310df5a5276c67f81621b104322cff0286c" }
 hex-literal = "0.4"
+paste = "1.0"
 
 cortex-m = { version = "0.7.5" }
 cortex-m-rt = { version = "0.6.5", features = ["device"] }
diff --git a/src/main.rs b/src/main.rs
index c01aba6..def120d 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,7 +3,6 @@
 #![no_std]
 #![no_main]
 
-use aspeed_ddk::gpio::{gpiol, GpioExt};
 use core::sync::atomic::AtomicBool;
 // use core::arch::asm;
 use aspeed_ddk::uart::{Config, UartController};
@@ -16,10 +15,10 @@ use aspeed_ddk::hace_controller::HaceController;
 use aspeed_ddk::rsa::AspeedRsa;
 use aspeed_ddk::spi;
 use aspeed_ddk::syscon::{ClockId, ResetId, SysCon};
-use embedded_hal::digital::OutputPin;
 use fugit::MillisDurationU32 as MilliSeconds;
 
 use aspeed_ddk::tests::functional::ecdsa_test::run_ecdsa_tests;
+use aspeed_ddk::tests::functional::gpio_test;
 use aspeed_ddk::tests::functional::hash_test::run_hash_tests;
 use aspeed_ddk::tests::functional::hmac_test::run_hmac_tests;
 use aspeed_ddk::tests::functional::rsa_test::run_rsa_tests;
@@ -97,26 +96,6 @@ fn test_wdt(uart: &mut UartController<'_>) {
     }
 }
 
-fn test_gpio_flash_power(uart: &mut UartController<'_>) {
-    let mut delay = DummyDelay {};
-    if true {
-        /* Older demo board required this */
-        let peripherals = unsafe { Peripherals::steal() };
-        let gpio = peripherals.gpio;
-        let gpiol = gpiol::GPIOL::new(gpio).split();
-        uart.write_all(b"\r\n####### GPIO test #######\r\n")
-            .unwrap();
-
-        let mut pl2 = gpiol.pl2.into_push_pull_output();
-        pl2.set_high().unwrap();
-        uart.write_all(b"\r\nGPIOL2 set high\r\n").unwrap();
-        let mut pl3 = gpiol.pl3.into_push_pull_output();
-        pl3.set_high().unwrap();
-        uart.write_all(b"\r\nGPIOL3 set high\r\n").unwrap();
-        delay.delay_ns(1_000_000);
-    }
-}
-
 #[no_mangle]
 pub static HALT: AtomicBool = AtomicBool::new(true);
 
@@ -184,7 +163,7 @@ fn main() -> ! {
 
     let mut rsa = AspeedRsa::new(&secure, delay);
     run_rsa_tests(&mut uart_controller, &mut rsa);
-
+    gpio_test::test_gpioa(&mut uart_controller);
     test_wdt(&mut uart_controller);
 
     let test_spicontroller = false;
@@ -192,7 +171,7 @@ fn main() -> ! {
         spi::spitest::test_fmc(&mut uart_controller);
         spi::spitest::test_spi(&mut uart_controller);
 
-        test_gpio_flash_power(&mut uart_controller);
+        gpio_test::test_gpio_flash_power(&mut uart_controller);
         spi::spitest::test_spi2(&mut uart_controller);
     }
     // Initialize the peripherals here if needed
diff --git a/src/pinctrl.rs b/src/pinctrl.rs
index 5d23a3c..e75aa39 100644
--- a/src/pinctrl.rs
+++ b/src/pinctrl.rs
@@ -1,5 +1,6 @@
 // Licensed under the Apache-2.0 license
 
+use paste::paste;
 pub struct Pinctrl;
 
 pub struct PinctrlPin {
@@ -8,149 +9,522 @@ pub struct PinctrlPin {
     pub clear: bool,
 }
 
-// Pin to be cleared or set
-pub const PIN_SCL0: PinctrlPin = PinctrlPin {
-    offset: 0x414,
-    bit: 28,
-    clear: false,
-};
-pub const PIN_SDA0: PinctrlPin = PinctrlPin {
-    offset: 0x414,
-    bit: 29,
-    clear: false,
-};
-pub const PIN_SCL1: PinctrlPin = PinctrlPin {
-    offset: 0x414,
-    bit: 30,
-    clear: false,
-};
-pub const PIN_SDA1: PinctrlPin = PinctrlPin {
-    offset: 0x414,
-    bit: 31,
-    clear: false,
-};
+macro_rules! gen_pin_pairs {
+    ($reg_name:ident, $offset:expr, $bit:expr) => {
+        paste! {
+            pub const [<PIN_ $reg_name _ $bit>]: PinctrlPin = PinctrlPin {
+                offset: $offset,
+                bit: $bit,
+                clear: false,
+            };
 
-pub const PIN_SCL2: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 0,
-    clear: false,
-};
-pub const PIN_SDA2: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 1,
-    clear: false,
-};
-pub const PIN_SCL3: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 2,
-    clear: false,
-};
-pub const PIN_SDA3: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 3,
-    clear: false,
-};
-pub const PIN_SCL4: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 4,
-    clear: false,
-};
-pub const PIN_SDA4: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 5,
-    clear: false,
-};
-pub const PIN_SCL5: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 6,
-    clear: false,
-};
-pub const PIN_SDA5: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 7,
-    clear: false,
-};
-pub const PIN_SCL6: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 8,
-    clear: false,
-};
-pub const PIN_SDA6: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 9,
-    clear: false,
-};
-pub const PIN_SCL7: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 10,
-    clear: false,
-};
-pub const PIN_SDA7: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 11,
-    clear: false,
-};
-pub const PIN_SCL8: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 12,
-    clear: false,
-};
-pub const PIN_SDA8: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 13,
-    clear: false,
-};
-pub const PIN_SCL9: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 14,
-    clear: false,
-};
-pub const PIN_SDA9: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 15,
-    clear: false,
-};
-pub const CLR_PIN_I3C_SCL0: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 16,
-    clear: true,
-};
-pub const CLR_PIN_I3C_SDA0: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 17,
-    clear: true,
-};
-pub const CLR_PIN_I3C_SCL1: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 18,
-    clear: true,
-};
-pub const CLR_PIN_I3C_SDA1: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 19,
-    clear: true,
-};
-pub const CLR_PIN_I3C_SCL2: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 20,
-    clear: true,
-};
-pub const CLR_PIN_I3C_SDA2: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 21,
-    clear: true,
-};
-pub const CLR_PIN_I3C_SCL3: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 22,
-    clear: true,
-};
-pub const CLR_PIN_I3C_SDA3: PinctrlPin = PinctrlPin {
-    offset: 0x418,
-    bit: 23,
-    clear: true,
-};
+            pub const [<CLR_PIN_ $reg_name _ $bit>]: PinctrlPin = PinctrlPin {
+                offset: $offset,
+                bit: $bit,
+                clear: true,
+            };
+        }
+    };
+}
+
+paste! {
+    gen_pin_pairs!(SCU410, 0x410, 0);
+    gen_pin_pairs!(SCU410, 0x410, 1);
+    gen_pin_pairs!(SCU410, 0x410, 2);
+    gen_pin_pairs!(SCU410, 0x410, 3);
+    gen_pin_pairs!(SCU410, 0x410, 4);
+    gen_pin_pairs!(SCU410, 0x410, 5);
+    gen_pin_pairs!(SCU410, 0x410, 6);
+    gen_pin_pairs!(SCU410, 0x410, 7);
+    gen_pin_pairs!(SCU410, 0x410, 8);
+    gen_pin_pairs!(SCU410, 0x410, 9);
+    gen_pin_pairs!(SCU410, 0x410, 10);
+    gen_pin_pairs!(SCU410, 0x410, 11);
+    gen_pin_pairs!(SCU410, 0x410, 12);
+    gen_pin_pairs!(SCU410, 0x410, 13);
+    gen_pin_pairs!(SCU410, 0x410, 14);
+    gen_pin_pairs!(SCU410, 0x410, 15);
+    gen_pin_pairs!(SCU410, 0x410, 16);
+    gen_pin_pairs!(SCU410, 0x410, 17);
+    gen_pin_pairs!(SCU410, 0x410, 18);
+    gen_pin_pairs!(SCU410, 0x410, 19);
+    gen_pin_pairs!(SCU410, 0x410, 20);
+    gen_pin_pairs!(SCU410, 0x410, 21);
+    gen_pin_pairs!(SCU410, 0x410, 22);
+    gen_pin_pairs!(SCU410, 0x410, 23);
+    gen_pin_pairs!(SCU410, 0x410, 24);
+    gen_pin_pairs!(SCU410, 0x410, 25);
+    gen_pin_pairs!(SCU410, 0x410, 26);
+    gen_pin_pairs!(SCU410, 0x410, 27);
+    gen_pin_pairs!(SCU410, 0x410, 28);
+    gen_pin_pairs!(SCU410, 0x410, 29);
+    gen_pin_pairs!(SCU410, 0x410, 30);
+    gen_pin_pairs!(SCU410, 0x410, 31);
+
+    gen_pin_pairs!(SCU414, 0x414, 0);
+    gen_pin_pairs!(SCU414, 0x414, 1);
+    gen_pin_pairs!(SCU414, 0x414, 2);
+    gen_pin_pairs!(SCU414, 0x414, 3);
+    gen_pin_pairs!(SCU414, 0x414, 4);
+    gen_pin_pairs!(SCU414, 0x414, 5);
+    gen_pin_pairs!(SCU414, 0x414, 6);
+    gen_pin_pairs!(SCU414, 0x414, 7);
+    gen_pin_pairs!(SCU414, 0x414, 8);
+    gen_pin_pairs!(SCU414, 0x414, 9);
+    gen_pin_pairs!(SCU414, 0x414, 10);
+    gen_pin_pairs!(SCU414, 0x414, 11);
+    gen_pin_pairs!(SCU414, 0x414, 12);
+    gen_pin_pairs!(SCU414, 0x414, 13);
+    gen_pin_pairs!(SCU414, 0x414, 14);
+    gen_pin_pairs!(SCU414, 0x414, 15);
+    gen_pin_pairs!(SCU414, 0x414, 16);
+    gen_pin_pairs!(SCU414, 0x414, 17);
+    gen_pin_pairs!(SCU414, 0x414, 18);
+    gen_pin_pairs!(SCU414, 0x414, 19);
+    gen_pin_pairs!(SCU414, 0x414, 20);
+    gen_pin_pairs!(SCU414, 0x414, 21);
+    gen_pin_pairs!(SCU414, 0x414, 22);
+    gen_pin_pairs!(SCU414, 0x414, 23);
+    gen_pin_pairs!(SCU414, 0x414, 24);
+    gen_pin_pairs!(SCU414, 0x414, 25);
+    gen_pin_pairs!(SCU414, 0x414, 26);
+    gen_pin_pairs!(SCU414, 0x414, 27);
+    gen_pin_pairs!(SCU414, 0x414, 28);
+    gen_pin_pairs!(SCU414, 0x414, 29);
+    gen_pin_pairs!(SCU414, 0x414, 30);
+    gen_pin_pairs!(SCU414, 0x414, 31);
+
+    gen_pin_pairs!(SCU418, 0x418, 0);
+    gen_pin_pairs!(SCU418, 0x418, 1);
+    gen_pin_pairs!(SCU418, 0x418, 2);
+    gen_pin_pairs!(SCU418, 0x418, 3);
+    gen_pin_pairs!(SCU418, 0x418, 4);
+    gen_pin_pairs!(SCU418, 0x418, 5);
+    gen_pin_pairs!(SCU418, 0x418, 6);
+    gen_pin_pairs!(SCU418, 0x418, 7);
+    gen_pin_pairs!(SCU418, 0x418, 8);
+    gen_pin_pairs!(SCU418, 0x418, 9);
+    gen_pin_pairs!(SCU418, 0x418, 10);
+    gen_pin_pairs!(SCU418, 0x418, 11);
+    gen_pin_pairs!(SCU418, 0x418, 12);
+    gen_pin_pairs!(SCU418, 0x418, 13);
+    gen_pin_pairs!(SCU418, 0x418, 14);
+    gen_pin_pairs!(SCU418, 0x418, 15);
+    gen_pin_pairs!(SCU418, 0x418, 16);
+    gen_pin_pairs!(SCU418, 0x418, 17);
+    gen_pin_pairs!(SCU418, 0x418, 18);
+    gen_pin_pairs!(SCU418, 0x418, 19);
+    gen_pin_pairs!(SCU418, 0x418, 20);
+    gen_pin_pairs!(SCU418, 0x418, 21);
+    gen_pin_pairs!(SCU418, 0x418, 22);
+    gen_pin_pairs!(SCU418, 0x418, 23);
+    gen_pin_pairs!(SCU418, 0x418, 24);
+    gen_pin_pairs!(SCU418, 0x418, 25);
+    gen_pin_pairs!(SCU418, 0x418, 26);
+    gen_pin_pairs!(SCU418, 0x418, 27);
+    gen_pin_pairs!(SCU418, 0x418, 28);
+    gen_pin_pairs!(SCU418, 0x418, 29);
+    gen_pin_pairs!(SCU418, 0x418, 30);
+    gen_pin_pairs!(SCU418, 0x418, 31);
+
+    gen_pin_pairs!(SCU41C, 0x41C, 0);
+    gen_pin_pairs!(SCU41C, 0x41C, 1);
+    gen_pin_pairs!(SCU41C, 0x41C, 2);
+    gen_pin_pairs!(SCU41C, 0x41C, 3);
+    gen_pin_pairs!(SCU41C, 0x41C, 4);
+    gen_pin_pairs!(SCU41C, 0x41C, 5);
+    gen_pin_pairs!(SCU41C, 0x41C, 6);
+    gen_pin_pairs!(SCU41C, 0x41C, 7);
+    gen_pin_pairs!(SCU41C, 0x41C, 8);
+    gen_pin_pairs!(SCU41C, 0x41C, 9);
+    gen_pin_pairs!(SCU41C, 0x41C, 10);
+    gen_pin_pairs!(SCU41C, 0x41C, 11);
+    gen_pin_pairs!(SCU41C, 0x41C, 12);
+    gen_pin_pairs!(SCU41C, 0x41C, 13);
+    gen_pin_pairs!(SCU41C, 0x41C, 14);
+    gen_pin_pairs!(SCU41C, 0x41C, 15);
+    gen_pin_pairs!(SCU41C, 0x41C, 16);
+    gen_pin_pairs!(SCU41C, 0x41C, 17);
+    gen_pin_pairs!(SCU41C, 0x41C, 18);
+    gen_pin_pairs!(SCU41C, 0x41C, 19);
+    gen_pin_pairs!(SCU41C, 0x41C, 20);
+    gen_pin_pairs!(SCU41C, 0x41C, 21);
+    gen_pin_pairs!(SCU41C, 0x41C, 22);
+    gen_pin_pairs!(SCU41C, 0x41C, 23);
+    gen_pin_pairs!(SCU41C, 0x41C, 24);
+    gen_pin_pairs!(SCU41C, 0x41C, 25);
+    gen_pin_pairs!(SCU41C, 0x41C, 26);
+    gen_pin_pairs!(SCU41C, 0x41C, 27);
+    gen_pin_pairs!(SCU41C, 0x41C, 28);
+    gen_pin_pairs!(SCU41C, 0x41C, 29);
+    gen_pin_pairs!(SCU41C, 0x41C, 30);
+    gen_pin_pairs!(SCU41C, 0x41C, 31);
+
+    gen_pin_pairs!(SCU430, 0x430, 0);
+    gen_pin_pairs!(SCU430, 0x430, 1);
+    gen_pin_pairs!(SCU430, 0x430, 2);
+    gen_pin_pairs!(SCU430, 0x430, 3);
+    gen_pin_pairs!(SCU430, 0x430, 4);
+    gen_pin_pairs!(SCU430, 0x430, 5);
+    gen_pin_pairs!(SCU430, 0x430, 6);
+    gen_pin_pairs!(SCU430, 0x430, 7);
+    gen_pin_pairs!(SCU430, 0x430, 8);
+    gen_pin_pairs!(SCU430, 0x430, 9);
+    gen_pin_pairs!(SCU430, 0x430, 10);
+    gen_pin_pairs!(SCU430, 0x430, 11);
+    gen_pin_pairs!(SCU430, 0x430, 12);
+    gen_pin_pairs!(SCU430, 0x430, 13);
+    gen_pin_pairs!(SCU430, 0x430, 14);
+    gen_pin_pairs!(SCU430, 0x430, 15);
+    gen_pin_pairs!(SCU430, 0x430, 16);
+    gen_pin_pairs!(SCU430, 0x430, 17);
+    gen_pin_pairs!(SCU430, 0x430, 18);
+    gen_pin_pairs!(SCU430, 0x430, 19);
+    gen_pin_pairs!(SCU430, 0x430, 20);
+    gen_pin_pairs!(SCU430, 0x430, 21);
+    gen_pin_pairs!(SCU430, 0x430, 22);
+    gen_pin_pairs!(SCU430, 0x430, 23);
+    gen_pin_pairs!(SCU430, 0x430, 24);
+    gen_pin_pairs!(SCU430, 0x430, 25);
+    gen_pin_pairs!(SCU430, 0x430, 26);
+    gen_pin_pairs!(SCU430, 0x430, 27);
+    gen_pin_pairs!(SCU430, 0x430, 28);
+    gen_pin_pairs!(SCU430, 0x430, 29);
+    gen_pin_pairs!(SCU430, 0x430, 30);
+    gen_pin_pairs!(SCU430, 0x430, 31);
+
+    gen_pin_pairs!(SCU434, 0x434, 0);
+    gen_pin_pairs!(SCU434, 0x434, 1);
+    gen_pin_pairs!(SCU434, 0x434, 2);
+    gen_pin_pairs!(SCU434, 0x434, 3);
+    gen_pin_pairs!(SCU434, 0x434, 4);
+    gen_pin_pairs!(SCU434, 0x434, 5);
+    gen_pin_pairs!(SCU434, 0x434, 6);
+    gen_pin_pairs!(SCU434, 0x434, 7);
+    gen_pin_pairs!(SCU434, 0x434, 8);
+    gen_pin_pairs!(SCU434, 0x434, 9);
+    gen_pin_pairs!(SCU434, 0x434, 10);
+    gen_pin_pairs!(SCU434, 0x434, 11);
+    gen_pin_pairs!(SCU434, 0x434, 12);
+    gen_pin_pairs!(SCU434, 0x434, 13);
+    gen_pin_pairs!(SCU434, 0x434, 14);
+    gen_pin_pairs!(SCU434, 0x434, 15);
+    gen_pin_pairs!(SCU434, 0x434, 16);
+    gen_pin_pairs!(SCU434, 0x434, 17);
+    gen_pin_pairs!(SCU434, 0x434, 18);
+    gen_pin_pairs!(SCU434, 0x434, 19);
+    gen_pin_pairs!(SCU434, 0x434, 20);
+    gen_pin_pairs!(SCU434, 0x434, 21);
+    gen_pin_pairs!(SCU434, 0x434, 22);
+    gen_pin_pairs!(SCU434, 0x434, 23);
+    gen_pin_pairs!(SCU434, 0x434, 24);
+    gen_pin_pairs!(SCU434, 0x434, 25);
+    gen_pin_pairs!(SCU434, 0x434, 26);
+    gen_pin_pairs!(SCU434, 0x434, 27);
+    gen_pin_pairs!(SCU434, 0x434, 28);
+    gen_pin_pairs!(SCU434, 0x434, 29);
+    gen_pin_pairs!(SCU434, 0x434, 30);
+    gen_pin_pairs!(SCU434, 0x434, 31);
 
+    gen_pin_pairs!(SCU4B0, 0x4B0, 0);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 1);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 2);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 3);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 4);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 5);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 6);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 7);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 8);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 9);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 10);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 11);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 12);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 13);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 14);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 15);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 16);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 17);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 18);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 19);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 20);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 21);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 22);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 23);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 24);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 25);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 26);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 27);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 28);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 29);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 30);
+    gen_pin_pairs!(SCU4B0, 0x4B0, 31);
+
+    gen_pin_pairs!(SCU4B4, 0x4B4, 0);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 1);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 2);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 3);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 4);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 5);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 6);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 7);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 8);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 9);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 10);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 11);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 12);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 13);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 14);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 15);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 16);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 17);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 18);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 19);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 20);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 21);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 22);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 23);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 24);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 25);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 26);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 27);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 28);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 29);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 30);
+    gen_pin_pairs!(SCU4B4, 0x4B4, 31);
+
+    gen_pin_pairs!(SCU4B8, 0x4B8, 0);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 1);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 2);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 3);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 4);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 5);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 6);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 7);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 8);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 9);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 10);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 11);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 12);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 13);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 14);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 15);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 16);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 17);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 18);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 19);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 20);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 21);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 22);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 23);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 24);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 25);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 26);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 27);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 28);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 29);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 30);
+    gen_pin_pairs!(SCU4B8, 0x4B8, 31);
+
+    gen_pin_pairs!(SCU4BC, 0x4BC, 0);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 1);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 2);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 3);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 4);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 5);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 6);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 7);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 8);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 9);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 10);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 11);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 12);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 13);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 14);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 15);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 16);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 17);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 18);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 19);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 20);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 21);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 22);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 23);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 24);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 25);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 26);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 27);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 28);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 29);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 30);
+    gen_pin_pairs!(SCU4BC, 0x4BC, 31);
+
+    gen_pin_pairs!(SCU690, 0x690, 0);
+    gen_pin_pairs!(SCU690, 0x690, 1);
+    gen_pin_pairs!(SCU690, 0x690, 2);
+    gen_pin_pairs!(SCU690, 0x690, 3);
+    gen_pin_pairs!(SCU690, 0x690, 4);
+    gen_pin_pairs!(SCU690, 0x690, 5);
+    gen_pin_pairs!(SCU690, 0x690, 6);
+    gen_pin_pairs!(SCU690, 0x690, 7);
+    gen_pin_pairs!(SCU690, 0x690, 8);
+    gen_pin_pairs!(SCU690, 0x690, 9);
+    gen_pin_pairs!(SCU690, 0x690, 10);
+    gen_pin_pairs!(SCU690, 0x690, 11);
+    gen_pin_pairs!(SCU690, 0x690, 12);
+    gen_pin_pairs!(SCU690, 0x690, 13);
+    gen_pin_pairs!(SCU690, 0x690, 14);
+    gen_pin_pairs!(SCU690, 0x690, 15);
+    gen_pin_pairs!(SCU690, 0x690, 16);
+    gen_pin_pairs!(SCU690, 0x690, 17);
+    gen_pin_pairs!(SCU690, 0x690, 18);
+    gen_pin_pairs!(SCU690, 0x690, 19);
+    gen_pin_pairs!(SCU690, 0x690, 20);
+    gen_pin_pairs!(SCU690, 0x690, 21);
+    gen_pin_pairs!(SCU690, 0x690, 22);
+    gen_pin_pairs!(SCU690, 0x690, 23);
+    gen_pin_pairs!(SCU690, 0x690, 24);
+    gen_pin_pairs!(SCU690, 0x690, 25);
+    gen_pin_pairs!(SCU690, 0x690, 26);
+    gen_pin_pairs!(SCU690, 0x690, 27);
+    gen_pin_pairs!(SCU690, 0x690, 28);
+    gen_pin_pairs!(SCU690, 0x690, 29);
+    gen_pin_pairs!(SCU690, 0x690, 30);
+    gen_pin_pairs!(SCU690, 0x690, 31);
+
+    gen_pin_pairs!(SCU694, 0x694, 0);
+    gen_pin_pairs!(SCU694, 0x694, 1);
+    gen_pin_pairs!(SCU694, 0x694, 2);
+    gen_pin_pairs!(SCU694, 0x694, 3);
+    gen_pin_pairs!(SCU694, 0x694, 4);
+    gen_pin_pairs!(SCU694, 0x694, 5);
+    gen_pin_pairs!(SCU694, 0x694, 6);
+    gen_pin_pairs!(SCU694, 0x694, 7);
+    gen_pin_pairs!(SCU694, 0x694, 8);
+    gen_pin_pairs!(SCU694, 0x694, 9);
+    gen_pin_pairs!(SCU694, 0x694, 10);
+    gen_pin_pairs!(SCU694, 0x694, 11);
+    gen_pin_pairs!(SCU694, 0x694, 12);
+    gen_pin_pairs!(SCU694, 0x694, 13);
+    gen_pin_pairs!(SCU694, 0x694, 14);
+    gen_pin_pairs!(SCU694, 0x694, 15);
+    gen_pin_pairs!(SCU694, 0x694, 16);
+    gen_pin_pairs!(SCU694, 0x694, 17);
+    gen_pin_pairs!(SCU694, 0x694, 18);
+    gen_pin_pairs!(SCU694, 0x694, 19);
+    gen_pin_pairs!(SCU694, 0x694, 20);
+    gen_pin_pairs!(SCU694, 0x694, 21);
+    gen_pin_pairs!(SCU694, 0x694, 22);
+    gen_pin_pairs!(SCU694, 0x694, 23);
+    gen_pin_pairs!(SCU694, 0x694, 24);
+    gen_pin_pairs!(SCU694, 0x694, 25);
+    gen_pin_pairs!(SCU694, 0x694, 26);
+    gen_pin_pairs!(SCU694, 0x694, 27);
+    gen_pin_pairs!(SCU694, 0x694, 28);
+    gen_pin_pairs!(SCU694, 0x694, 29);
+    gen_pin_pairs!(SCU694, 0x694, 30);
+    gen_pin_pairs!(SCU694, 0x694, 31);
+
+    gen_pin_pairs!(SCU698, 0x698, 0);
+    gen_pin_pairs!(SCU698, 0x698, 1);
+    gen_pin_pairs!(SCU698, 0x698, 2);
+    gen_pin_pairs!(SCU698, 0x698, 3);
+    gen_pin_pairs!(SCU698, 0x698, 4);
+    gen_pin_pairs!(SCU698, 0x698, 5);
+    gen_pin_pairs!(SCU698, 0x698, 6);
+    gen_pin_pairs!(SCU698, 0x698, 7);
+    gen_pin_pairs!(SCU698, 0x698, 8);
+    gen_pin_pairs!(SCU698, 0x698, 9);
+    gen_pin_pairs!(SCU698, 0x698, 10);
+    gen_pin_pairs!(SCU698, 0x698, 11);
+    gen_pin_pairs!(SCU698, 0x698, 12);
+    gen_pin_pairs!(SCU698, 0x698, 13);
+    gen_pin_pairs!(SCU698, 0x698, 14);
+    gen_pin_pairs!(SCU698, 0x698, 15);
+    gen_pin_pairs!(SCU698, 0x698, 16);
+    gen_pin_pairs!(SCU698, 0x698, 17);
+    gen_pin_pairs!(SCU698, 0x698, 18);
+    gen_pin_pairs!(SCU698, 0x698, 19);
+    gen_pin_pairs!(SCU698, 0x698, 20);
+    gen_pin_pairs!(SCU698, 0x698, 21);
+    gen_pin_pairs!(SCU698, 0x698, 22);
+    gen_pin_pairs!(SCU698, 0x698, 23);
+    gen_pin_pairs!(SCU698, 0x698, 24);
+    gen_pin_pairs!(SCU698, 0x698, 25);
+    gen_pin_pairs!(SCU698, 0x698, 26);
+    gen_pin_pairs!(SCU698, 0x698, 27);
+    gen_pin_pairs!(SCU698, 0x698, 28);
+    gen_pin_pairs!(SCU698, 0x698, 29);
+    gen_pin_pairs!(SCU698, 0x698, 30);
+    gen_pin_pairs!(SCU698, 0x698, 31);
+
+    gen_pin_pairs!(SCU69C, 0x69C, 0);
+    gen_pin_pairs!(SCU69C, 0x69C, 1);
+    gen_pin_pairs!(SCU69C, 0x69C, 2);
+    gen_pin_pairs!(SCU69C, 0x69C, 3);
+    gen_pin_pairs!(SCU69C, 0x69C, 4);
+    gen_pin_pairs!(SCU69C, 0x69C, 5);
+    gen_pin_pairs!(SCU69C, 0x69C, 6);
+    gen_pin_pairs!(SCU69C, 0x69C, 7);
+    gen_pin_pairs!(SCU69C, 0x69C, 8);
+    gen_pin_pairs!(SCU69C, 0x69C, 9);
+    gen_pin_pairs!(SCU69C, 0x69C, 10);
+    gen_pin_pairs!(SCU69C, 0x69C, 11);
+    gen_pin_pairs!(SCU69C, 0x69C, 12);
+    gen_pin_pairs!(SCU69C, 0x69C, 13);
+    gen_pin_pairs!(SCU69C, 0x69C, 14);
+    gen_pin_pairs!(SCU69C, 0x69C, 15);
+    gen_pin_pairs!(SCU69C, 0x69C, 16);
+    gen_pin_pairs!(SCU69C, 0x69C, 17);
+    gen_pin_pairs!(SCU69C, 0x69C, 18);
+    gen_pin_pairs!(SCU69C, 0x69C, 19);
+    gen_pin_pairs!(SCU69C, 0x69C, 20);
+    gen_pin_pairs!(SCU69C, 0x69C, 21);
+    gen_pin_pairs!(SCU69C, 0x69C, 22);
+    gen_pin_pairs!(SCU69C, 0x69C, 23);
+    gen_pin_pairs!(SCU69C, 0x69C, 24);
+    gen_pin_pairs!(SCU69C, 0x69C, 25);
+    gen_pin_pairs!(SCU69C, 0x69C, 26);
+    gen_pin_pairs!(SCU69C, 0x69C, 27);
+    gen_pin_pairs!(SCU69C, 0x69C, 28);
+    gen_pin_pairs!(SCU69C, 0x69C, 29);
+    gen_pin_pairs!(SCU69C, 0x69C, 30);
+    gen_pin_pairs!(SCU69C, 0x69C, 31);
+
+    gen_pin_pairs!(SCU6B0, 0x6B0, 0);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 1);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 2);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 3);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 4);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 5);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 6);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 7);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 8);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 9);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 10);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 11);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 12);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 13);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 14);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 15);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 16);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 17);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 18);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 19);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 20);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 21);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 22);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 23);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 24);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 25);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 26);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 27);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 28);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 29);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 30);
+    gen_pin_pairs!(SCU6B0, 0x6B0, 31);
+}
+
+// Pin to be cleared or set
 pub const PIN_SPI2CS0: PinctrlPin = PinctrlPin {
     offset: 0x41C,
     bit: 30,
@@ -208,44 +582,14 @@ pub const PIN_SPI1DQ3: PinctrlPin = PinctrlPin {
     clear: false,
 };
 
-pub const PIN_SCL10: PinctrlPin = PinctrlPin {
-    offset: 0x4b8,
-    bit: 16,
-    clear: false,
-};
-pub const PIN_SDA10: PinctrlPin = PinctrlPin {
-    offset: 0x4b8,
-    bit: 17,
-    clear: false,
-};
-pub const PIN_SCL11: PinctrlPin = PinctrlPin {
-    offset: 0x4b8,
-    bit: 18,
-    clear: false,
-};
-pub const PIN_SDA11: PinctrlPin = PinctrlPin {
-    offset: 0x4b8,
-    bit: 19,
-    clear: false,
-};
-pub const PIN_SCL12: PinctrlPin = PinctrlPin {
-    offset: 0x4b8,
-    bit: 20,
-    clear: false,
-};
-pub const PIN_SDA12: PinctrlPin = PinctrlPin {
-    offset: 0x4b8,
-    bit: 21,
-    clear: false,
-};
-pub const PIN_SCL13: PinctrlPin = PinctrlPin {
-    offset: 0x4b8,
-    bit: 22,
+pub const PIN_QSPIM2_RST_IN: PinctrlPin = PinctrlPin {
+    offset: 0x69c,
+    bit: 9,
     clear: false,
 };
-pub const PIN_SDA13: PinctrlPin = PinctrlPin {
-    offset: 0x4b8,
-    bit: 23,
+pub const PIN_QSPIM4_RST_IN: PinctrlPin = PinctrlPin {
+    offset: 0x69c,
+    bit: 11,
     clear: false,
 };
 
@@ -1361,40 +1705,210 @@ pub const PINCTRL_SPIM3_PINCTRL0: &[PinctrlPin] = &[
     PIN_SPIM3_MUX_CTRL14,
     PIN_SPIM3_MUX_CTRL32,
 ];
-pub const PINCTRL_I2C0: &[PinctrlPin] = &[PIN_SCL0, PIN_SDA0];
-pub const PINCTRL_I2C1: &[PinctrlPin] = &[PIN_SCL1, PIN_SDA1];
-pub const PINCTRL_I2C2: &[PinctrlPin] = &[PIN_SCL2, PIN_SDA2];
-pub const PINCTRL_I2C3: &[PinctrlPin] = &[PIN_SCL3, PIN_SDA3];
-pub const PINCTRL_I2C4: &[PinctrlPin] = &[PIN_SCL4, PIN_SDA4];
-pub const PINCTRL_I2C5: &[PinctrlPin] = &[PIN_SCL5, PIN_SDA5];
-pub const PINCTRL_I2C6: &[PinctrlPin] = &[PIN_SCL6, PIN_SDA6];
-pub const PINCTRL_I2C7: &[PinctrlPin] = &[PIN_SCL7, PIN_SDA7];
-pub const PINCTRL_I2C8: &[PinctrlPin] = &[PIN_SCL8, PIN_SDA8];
-pub const PINCTRL_I2C9: &[PinctrlPin] = &[PIN_SCL9, PIN_SDA9];
-pub const PINCTRL_I2C10: &[PinctrlPin] =
-    &[PIN_SCL10, PIN_SDA10, CLR_PIN_I3C_SCL0, CLR_PIN_I3C_SDA0];
-pub const PINCTRL_I2C11: &[PinctrlPin] =
-    &[PIN_SCL11, PIN_SDA11, CLR_PIN_I3C_SCL1, CLR_PIN_I3C_SDA1];
-pub const PINCTRL_I2C12: &[PinctrlPin] =
-    &[PIN_SCL12, PIN_SDA12, CLR_PIN_I3C_SCL2, CLR_PIN_I3C_SDA2];
-pub const PINCTRL_I2C13: &[PinctrlPin] =
-    &[PIN_SCL13, PIN_SDA13, CLR_PIN_I3C_SCL3, CLR_PIN_I3C_SDA3];
+
+paste! {
+    pub const PINCTRL_I2C0: &[PinctrlPin] = &[PIN_SCU414_28, PIN_SCU414_29];
+    pub const PINCTRL_I2C1: &[PinctrlPin] = &[PIN_SCU414_30, PIN_SCU414_31];
+    pub const PINCTRL_I2C2: &[PinctrlPin] = &[PIN_SCU418_0, PIN_SCU418_1];
+    pub const PINCTRL_I2C3: &[PinctrlPin] = &[PIN_SCU418_2, PIN_SCU418_3];
+    pub const PINCTRL_I2C4: &[PinctrlPin] = &[PIN_SCU418_4, PIN_SCU418_5];
+    pub const PINCTRL_I2C5: &[PinctrlPin] = &[PIN_SCU418_6, PIN_SCU418_7];
+    pub const PINCTRL_I2C6: &[PinctrlPin] = &[PIN_SCU418_8, PIN_SCU418_9];
+    pub const PINCTRL_I2C7: &[PinctrlPin] = &[PIN_SCU418_10, PIN_SCU418_11];
+    pub const PINCTRL_I2C8: &[PinctrlPin] = &[PIN_SCU418_12, PIN_SCU418_13];
+    pub const PINCTRL_I2C9: &[PinctrlPin] = &[PIN_SCU418_14, PIN_SCU418_15];
+    pub const PINCTRL_I2C10: &[PinctrlPin] =
+        &[PIN_SCU4B8_16, PIN_SCU4B8_17, CLR_PIN_SCU418_16, CLR_PIN_SCU418_17];
+    pub const PINCTRL_I2C11: &[PinctrlPin] =
+        &[PIN_SCU4B8_18, PIN_SCU4B8_19, CLR_PIN_SCU418_18, CLR_PIN_SCU418_19];
+    pub const PINCTRL_I2C12: &[PinctrlPin] =
+        &[PIN_SCU4B8_20, PIN_SCU4B8_21, CLR_PIN_SCU418_20, CLR_PIN_SCU418_21];
+    pub const PINCTRL_I2C13: &[PinctrlPin] =
+        &[PIN_SCU4B8_22, PIN_SCU4B8_23, CLR_PIN_SCU418_22, CLR_PIN_SCU418_23];
+
+    pub const PINCTRL_GPIOA0: &[PinctrlPin] = &[CLR_PIN_SCU410_0, CLR_PIN_SCU4B0_0, CLR_PIN_SCU690_0];
+    pub const PINCTRL_GPIOA1: &[PinctrlPin] = &[CLR_PIN_SCU410_1, CLR_PIN_SCU4B0_1, CLR_PIN_SCU690_1];
+    pub const PINCTRL_GPIOA2: &[PinctrlPin] = &[CLR_PIN_SCU410_2, CLR_PIN_SCU4B0_2, CLR_PIN_SCU690_2];
+    pub const PINCTRL_GPIOA3: &[PinctrlPin] = &[CLR_PIN_SCU410_3, CLR_PIN_SCU4B0_3, CLR_PIN_SCU690_3];
+    pub const PINCTRL_GPIOA4: &[PinctrlPin] = &[CLR_PIN_SCU410_4, CLR_PIN_SCU4B0_4, CLR_PIN_SCU690_4];
+    pub const PINCTRL_GPIOA5: &[PinctrlPin] = &[CLR_PIN_SCU410_5, CLR_PIN_SCU4B0_5, CLR_PIN_SCU690_5];
+    pub const PINCTRL_GPIOA6: &[PinctrlPin] = &[CLR_PIN_SCU410_6, CLR_PIN_SCU4B0_6, CLR_PIN_SCU690_6];
+    pub const PINCTRL_GPIOA7: &[PinctrlPin] = &[CLR_PIN_SCU410_7, CLR_PIN_SCU4B0_7, CLR_PIN_SCU690_7];
+
+    pub const PINCTRL_GPIOB0: &[PinctrlPin] = &[CLR_PIN_SCU410_8, CLR_PIN_SCU4B0_8, CLR_PIN_SCU690_8];
+    pub const PINCTRL_GPIOB1: &[PinctrlPin] = &[CLR_PIN_SCU410_9, CLR_PIN_SCU4B0_9, CLR_PIN_SCU690_9];
+    pub const PINCTRL_GPIOB2: &[PinctrlPin] = &[CLR_PIN_SCU410_10, CLR_PIN_SCU4B0_10, CLR_PIN_SCU690_10];
+    pub const PINCTRL_GPIOB3: &[PinctrlPin] = &[CLR_PIN_SCU410_11, CLR_PIN_SCU4B0_11, CLR_PIN_SCU690_11];
+    pub const PINCTRL_GPIOB4: &[PinctrlPin] = &[CLR_PIN_SCU410_12, CLR_PIN_SCU4B0_12, CLR_PIN_SCU690_12];
+    pub const PINCTRL_GPIOB5: &[PinctrlPin] = &[CLR_PIN_SCU410_13, CLR_PIN_SCU4B0_13, CLR_PIN_SCU690_13];
+    pub const PINCTRL_GPIOB6: &[PinctrlPin] = &[CLR_PIN_SCU410_14, CLR_PIN_SCU4B0_14, CLR_PIN_SCU690_14];
+    pub const PINCTRL_GPIOB7: &[PinctrlPin] = &[CLR_PIN_SCU410_15, CLR_PIN_SCU4B0_15, CLR_PIN_SCU690_15];
+
+    pub const PINCTRL_GPIOC0: &[PinctrlPin] = &[CLR_PIN_SCU410_16, CLR_PIN_SCU4B0_16, CLR_PIN_SCU690_16];
+    pub const PINCTRL_GPIOC1: &[PinctrlPin] = &[CLR_PIN_SCU410_17, CLR_PIN_SCU4B0_17, CLR_PIN_SCU690_17];
+    pub const PINCTRL_GPIOC2: &[PinctrlPin] = &[CLR_PIN_SCU410_18, CLR_PIN_SCU4B0_18, CLR_PIN_SCU690_18];
+    pub const PINCTRL_GPIOC3: &[PinctrlPin] = &[CLR_PIN_SCU410_19, CLR_PIN_SCU4B0_19, CLR_PIN_SCU690_19];
+    pub const PINCTRL_GPIOC4: &[PinctrlPin] = &[CLR_PIN_SCU410_20, CLR_PIN_SCU4B0_20, CLR_PIN_SCU690_20];
+    pub const PINCTRL_GPIOC5: &[PinctrlPin] = &[CLR_PIN_SCU410_21, CLR_PIN_SCU4B0_21, CLR_PIN_SCU690_21];
+    pub const PINCTRL_GPIOC6: &[PinctrlPin] = &[CLR_PIN_SCU410_22, CLR_PIN_SCU4B0_22, CLR_PIN_SCU690_22];
+    pub const PINCTRL_GPIOC7: &[PinctrlPin] = &[CLR_PIN_SCU410_23, CLR_PIN_SCU4B0_23, CLR_PIN_SCU690_23];
+
+    pub const PINCTRL_GPIOD0: &[PinctrlPin] = &[CLR_PIN_SCU410_24, CLR_PIN_SCU4B0_24, CLR_PIN_SCU690_24];
+    pub const PINCTRL_GPIOD1: &[PinctrlPin] = &[CLR_PIN_SCU410_25, CLR_PIN_SCU4B0_25, CLR_PIN_SCU690_25];
+    pub const PINCTRL_GPIOD2: &[PinctrlPin] = &[CLR_PIN_SCU410_26, CLR_PIN_SCU4B0_26, CLR_PIN_SCU690_26];
+    pub const PINCTRL_GPIOD3: &[PinctrlPin] = &[CLR_PIN_SCU410_27, CLR_PIN_SCU4B0_27, CLR_PIN_SCU690_27];
+    pub const PINCTRL_GPIOD4: &[PinctrlPin] = &[CLR_PIN_SCU410_28, CLR_PIN_SCU4B0_28, CLR_PIN_SCU690_28];
+    pub const PINCTRL_GPIOD5: &[PinctrlPin] = &[CLR_PIN_SCU410_29, CLR_PIN_SCU4B0_29, CLR_PIN_SCU690_29];
+    pub const PINCTRL_GPIOD6: &[PinctrlPin] = &[CLR_PIN_SCU410_30, CLR_PIN_SCU4B0_30, CLR_PIN_SCU690_30];
+    pub const PINCTRL_GPIOD7: &[PinctrlPin] = &[CLR_PIN_SCU410_31, CLR_PIN_SCU4B0_31, CLR_PIN_SCU690_31];
+
+    pub const PINCTRL_GPIOE0: &[PinctrlPin] = &[CLR_PIN_SCU414_0, CLR_PIN_SCU4B4_0, CLR_PIN_SCU694_0];
+    pub const PINCTRL_GPIOE1: &[PinctrlPin] = &[CLR_PIN_SCU414_1, CLR_PIN_SCU4B4_1, CLR_PIN_SCU694_1];
+    pub const PINCTRL_GPIOE2: &[PinctrlPin] = &[CLR_PIN_SCU414_2, CLR_PIN_SCU4B4_2, CLR_PIN_SCU694_2];
+    pub const PINCTRL_GPIOE3: &[PinctrlPin] = &[CLR_PIN_SCU414_3, CLR_PIN_SCU4B4_3, CLR_PIN_SCU694_3];
+    pub const PINCTRL_GPIOE4: &[PinctrlPin] = &[CLR_PIN_SCU414_4, CLR_PIN_SCU4B4_4, CLR_PIN_SCU694_4];
+    pub const PINCTRL_GPIOE5: &[PinctrlPin] = &[CLR_PIN_SCU414_5, CLR_PIN_SCU4B4_5, CLR_PIN_SCU694_5];
+    pub const PINCTRL_GPIOE6: &[PinctrlPin] = &[CLR_PIN_SCU414_6, CLR_PIN_SCU4B4_6, CLR_PIN_SCU694_6];
+    pub const PINCTRL_GPIOE7: &[PinctrlPin] = &[CLR_PIN_SCU414_7, CLR_PIN_SCU4B4_7, CLR_PIN_SCU694_7];
+
+    pub const PINCTRL_GPIOF0: &[PinctrlPin] = &[CLR_PIN_SCU414_8, CLR_PIN_SCU4B4_8, CLR_PIN_SCU694_8];
+    pub const PINCTRL_GPIOF1: &[PinctrlPin] = &[CLR_PIN_SCU414_9, CLR_PIN_SCU4B4_9, CLR_PIN_SCU694_9];
+    pub const PINCTRL_GPIOF2: &[PinctrlPin] = &[CLR_PIN_SCU414_10, CLR_PIN_SCU4B4_10, CLR_PIN_SCU694_10];
+    pub const PINCTRL_GPIOF3: &[PinctrlPin] = &[CLR_PIN_SCU414_11, CLR_PIN_SCU4B4_11, CLR_PIN_SCU694_11];
+    pub const PINCTRL_GPIOF4: &[PinctrlPin] = &[CLR_PIN_SCU414_12, CLR_PIN_SCU4B4_12, CLR_PIN_SCU694_12];
+    pub const PINCTRL_GPIOF5: &[PinctrlPin] = &[CLR_PIN_SCU414_13, CLR_PIN_SCU4B4_13, CLR_PIN_SCU694_13];
+    pub const PINCTRL_GPIOF6: &[PinctrlPin] = &[CLR_PIN_SCU414_14, CLR_PIN_SCU4B4_14, CLR_PIN_SCU694_14];
+    pub const PINCTRL_GPIOF7: &[PinctrlPin] = &[CLR_PIN_SCU414_15, CLR_PIN_SCU4B4_15, CLR_PIN_SCU694_15];
+
+    pub const PINCTRL_GPIOG0: &[PinctrlPin] = &[CLR_PIN_SCU414_16, CLR_PIN_SCU4B4_16, CLR_PIN_SCU694_16];
+    pub const PINCTRL_GPIOG1: &[PinctrlPin] = &[CLR_PIN_SCU414_17, CLR_PIN_SCU4B4_17, CLR_PIN_SCU694_17];
+    pub const PINCTRL_GPIOG2: &[PinctrlPin] = &[CLR_PIN_SCU414_18, CLR_PIN_SCU4B4_18, CLR_PIN_SCU694_18];
+    pub const PINCTRL_GPIOG3: &[PinctrlPin] = &[CLR_PIN_SCU414_19, CLR_PIN_SCU4B4_19, CLR_PIN_SCU694_19];
+    pub const PINCTRL_GPIOG4: &[PinctrlPin] = &[CLR_PIN_SCU414_20, CLR_PIN_SCU4B4_20, CLR_PIN_SCU694_20];
+    pub const PINCTRL_GPIOG5: &[PinctrlPin] = &[CLR_PIN_SCU414_21, CLR_PIN_SCU4B4_21, CLR_PIN_SCU694_21];
+    pub const PINCTRL_GPIOG6: &[PinctrlPin] = &[CLR_PIN_SCU414_22, CLR_PIN_SCU4B4_22, CLR_PIN_SCU694_22];
+    pub const PINCTRL_GPIOG7: &[PinctrlPin] = &[CLR_PIN_SCU414_23, CLR_PIN_SCU4B4_23, CLR_PIN_SCU694_23];
+
+    pub const PINCTRL_GPIOH0: &[PinctrlPin] = &[CLR_PIN_SCU414_24, CLR_PIN_SCU4B4_24, CLR_PIN_SCU694_24];
+    pub const PINCTRL_GPIOH1: &[PinctrlPin] = &[CLR_PIN_SCU414_25, CLR_PIN_SCU4B4_25, CLR_PIN_SCU694_25];
+    pub const PINCTRL_GPIOH2: &[PinctrlPin] = &[CLR_PIN_SCU414_26, CLR_PIN_SCU4B4_26, CLR_PIN_SCU694_26];
+    pub const PINCTRL_GPIOH3: &[PinctrlPin] = &[CLR_PIN_SCU414_27, CLR_PIN_SCU4B4_27, CLR_PIN_SCU694_27];
+    pub const PINCTRL_GPIOH4: &[PinctrlPin] = &[CLR_PIN_SCU414_28, CLR_PIN_SCU4B4_28, CLR_PIN_SCU694_28];
+    pub const PINCTRL_GPIOH5: &[PinctrlPin] = &[CLR_PIN_SCU414_29, CLR_PIN_SCU4B4_29, CLR_PIN_SCU694_29];
+    pub const PINCTRL_GPIOH6: &[PinctrlPin] = &[CLR_PIN_SCU414_30];
+    pub const PINCTRL_GPIOH7: &[PinctrlPin] = &[CLR_PIN_SCU414_31];
+
+    pub const PINCTRL_GPIOI0: &[PinctrlPin] = &[CLR_PIN_SCU418_0];
+    pub const PINCTRL_GPIOI1: &[PinctrlPin] = &[CLR_PIN_SCU418_1];
+    pub const PINCTRL_GPIOI2: &[PinctrlPin] = &[CLR_PIN_SCU418_2];
+    pub const PINCTRL_GPIOI3: &[PinctrlPin] = &[CLR_PIN_SCU418_3];
+    pub const PINCTRL_GPIOI4: &[PinctrlPin] = &[CLR_PIN_SCU418_4];
+    pub const PINCTRL_GPIOI5: &[PinctrlPin] = &[CLR_PIN_SCU418_5];
+    pub const PINCTRL_GPIOI6: &[PinctrlPin] = &[CLR_PIN_SCU418_6];
+    pub const PINCTRL_GPIOI7: &[PinctrlPin] = &[CLR_PIN_SCU418_7];
+
+    pub const PINCTRL_GPIOJ0: &[PinctrlPin] = &[CLR_PIN_SCU418_8, CLR_PIN_SCU4B8_8];
+    pub const PINCTRL_GPIOJ1: &[PinctrlPin] = &[CLR_PIN_SCU418_9, CLR_PIN_SCU4B8_9];
+    pub const PINCTRL_GPIOJ2: &[PinctrlPin] = &[CLR_PIN_SCU418_10, CLR_PIN_SCU4B8_10];
+    pub const PINCTRL_GPIOJ3: &[PinctrlPin] = &[CLR_PIN_SCU418_11, CLR_PIN_SCU4B8_11];
+    pub const PINCTRL_GPIOJ4: &[PinctrlPin] = &[CLR_PIN_SCU418_12, CLR_PIN_SCU4B8_12];
+    pub const PINCTRL_GPIOJ5: &[PinctrlPin] = &[CLR_PIN_SCU418_13, CLR_PIN_SCU4B8_13];
+    pub const PINCTRL_GPIOJ6: &[PinctrlPin] = &[CLR_PIN_SCU418_14, CLR_PIN_SCU4B8_14];
+    pub const PINCTRL_GPIOJ7: &[PinctrlPin] = &[CLR_PIN_SCU418_15, CLR_PIN_SCU4B8_15];
+
+    pub const PINCTRL_GPIOK0: &[PinctrlPin] = &[CLR_PIN_SCU418_16, CLR_PIN_SCU4B8_16];
+    pub const PINCTRL_GPIOK1: &[PinctrlPin] = &[CLR_PIN_SCU418_17, CLR_PIN_SCU4B8_17];
+    pub const PINCTRL_GPIOK2: &[PinctrlPin] = &[CLR_PIN_SCU418_18, CLR_PIN_SCU4B8_18];
+    pub const PINCTRL_GPIOK3: &[PinctrlPin] = &[CLR_PIN_SCU418_19, CLR_PIN_SCU4B8_19];
+    pub const PINCTRL_GPIOK4: &[PinctrlPin] = &[CLR_PIN_SCU418_20, CLR_PIN_SCU4B8_20];
+    pub const PINCTRL_GPIOK5: &[PinctrlPin] = &[CLR_PIN_SCU418_21, CLR_PIN_SCU4B8_21];
+    pub const PINCTRL_GPIOK6: &[PinctrlPin] = &[CLR_PIN_SCU418_22, CLR_PIN_SCU4B8_22];
+    pub const PINCTRL_GPIOK7: &[PinctrlPin] = &[CLR_PIN_SCU418_23, CLR_PIN_SCU4B8_23];
+
+    pub const PINCTRL_GPIOL0: &[PinctrlPin] = &[CLR_PIN_SCU418_24];
+    pub const PINCTRL_GPIOL1: &[PinctrlPin] = &[CLR_PIN_SCU418_25];
+    pub const PINCTRL_GPIOL2: &[PinctrlPin] = &[CLR_PIN_SCU418_26];
+    pub const PINCTRL_GPIOL3: &[PinctrlPin] = &[CLR_PIN_SCU418_27];
+    pub const PINCTRL_GPIOL4: &[PinctrlPin] = &[CLR_PIN_SCU418_28, CLR_PIN_SCU4B8_28, CLR_PIN_SCU698_28];
+    pub const PINCTRL_GPIOL5: &[PinctrlPin] = &[CLR_PIN_SCU418_29, CLR_PIN_SCU4B8_29, CLR_PIN_SCU698_29];
+    pub const PINCTRL_GPIOL6: &[PinctrlPin] = &[CLR_PIN_SCU418_30, CLR_PIN_SCU4B8_30, CLR_PIN_SCU698_30];
+    pub const PINCTRL_GPIOL7: &[PinctrlPin] = &[CLR_PIN_SCU418_31, CLR_PIN_SCU4B8_31, CLR_PIN_SCU698_31];
+
+    pub const PINCTRL_GPIOM0: &[PinctrlPin] = &[CLR_PIN_SCU41C_0];
+    pub const PINCTRL_GPIOM1: &[PinctrlPin] = &[CLR_PIN_SCU41C_1];
+    pub const PINCTRL_GPIOM2: &[PinctrlPin] = &[CLR_PIN_SCU41C_2];
+    pub const PINCTRL_GPIOM3: &[PinctrlPin] = &[CLR_PIN_SCU41C_3];
+    pub const PINCTRL_GPIOM4: &[PinctrlPin] = &[CLR_PIN_SCU41C_4];
+    pub const PINCTRL_GPIOM5: &[PinctrlPin] = &[CLR_PIN_SCU41C_5];
+
+    pub const PINCTRL_GPION0: &[PinctrlPin] = &[CLR_PIN_SCU41C_8];
+    pub const PINCTRL_GPION1: &[PinctrlPin] = &[CLR_PIN_SCU41C_9, CLR_PIN_SCU4BC_9, CLR_PIN_SCU69C_9];
+    pub const PINCTRL_GPION2: &[PinctrlPin] = &[CLR_PIN_SCU41C_10];
+    pub const PINCTRL_GPION3: &[PinctrlPin] = &[CLR_PIN_SCU41C_11, CLR_PIN_SCU4BC_11, CLR_PIN_SCU69C_11];
+    pub const PINCTRL_GPION4: &[PinctrlPin] = &[CLR_PIN_SCU41C_12, CLR_PIN_SCU4BC_12];
+    pub const PINCTRL_GPION5: &[PinctrlPin] = &[CLR_PIN_SCU41C_13, CLR_PIN_SCU4BC_13];
+    pub const PINCTRL_GPION6: &[PinctrlPin] = &[CLR_PIN_SCU41C_14, CLR_PIN_SCU4BC_14];
+    pub const PINCTRL_GPION7: &[PinctrlPin] = &[CLR_PIN_SCU41C_15, CLR_PIN_SCU4BC_15];
+
+    pub const PINCTRL_GPIOO0: &[PinctrlPin] = &[CLR_PIN_SCU41C_16, CLR_PIN_SCU4BC_16];
+    pub const PINCTRL_GPIOO1: &[PinctrlPin] = &[CLR_PIN_SCU41C_17, CLR_PIN_SCU4BC_17];
+    pub const PINCTRL_GPIOO2: &[PinctrlPin] = &[CLR_PIN_SCU41C_18, CLR_PIN_SCU4BC_18];
+    pub const PINCTRL_GPIOO3: &[PinctrlPin] = &[CLR_PIN_SCU41C_19, CLR_PIN_SCU4BC_19];
+    pub const PINCTRL_GPIOO4: &[PinctrlPin] = &[CLR_PIN_SCU41C_20, CLR_PIN_SCU4BC_20, CLR_PIN_SCU69C_20];
+    pub const PINCTRL_GPIOO5: &[PinctrlPin] = &[CLR_PIN_SCU41C_21, CLR_PIN_SCU4BC_21, CLR_PIN_SCU69C_21];
+    pub const PINCTRL_GPIOO6: &[PinctrlPin] = &[CLR_PIN_SCU41C_22, CLR_PIN_SCU4BC_22, CLR_PIN_SCU69C_22];
+    pub const PINCTRL_GPIOO7: &[PinctrlPin] = &[CLR_PIN_SCU41C_23, CLR_PIN_SCU4BC_23, CLR_PIN_SCU69C_23];
+
+    pub const PINCTRL_GPIOP0: &[PinctrlPin] = &[CLR_PIN_SCU41C_24, CLR_PIN_SCU4BC_24, CLR_PIN_SCU69C_24];
+    pub const PINCTRL_GPIOP1: &[PinctrlPin] = &[CLR_PIN_SCU41C_25, CLR_PIN_SCU4BC_25];
+    pub const PINCTRL_GPIOP2: &[PinctrlPin] = &[CLR_PIN_SCU41C_26, CLR_PIN_SCU4BC_26];
+    pub const PINCTRL_GPIOP3: &[PinctrlPin] = &[CLR_PIN_SCU41C_27, CLR_PIN_SCU4BC_27];
+    pub const PINCTRL_GPIOP4: &[PinctrlPin] = &[CLR_PIN_SCU41C_28, CLR_PIN_SCU4BC_28];
+    pub const PINCTRL_GPIOP5: &[PinctrlPin] = &[CLR_PIN_SCU41C_29, CLR_PIN_SCU4BC_29];
+    pub const PINCTRL_GPIOP6: &[PinctrlPin] = &[CLR_PIN_SCU41C_30, CLR_PIN_SCU4BC_30, CLR_PIN_SCU69C_30];
+    pub const PINCTRL_GPIOP7: &[PinctrlPin] = &[CLR_PIN_SCU41C_31, CLR_PIN_SCU4BC_31, CLR_PIN_SCU69C_31];
+
+    pub const PINCTRL_GPIOQ0: &[PinctrlPin] = &[CLR_PIN_SCU430_0, CLR_PIN_SCU6B0_0];
+    pub const PINCTRL_GPIOQ1: &[PinctrlPin] = &[CLR_PIN_SCU430_1, CLR_PIN_SCU6B0_1];
+    pub const PINCTRL_GPIOQ2: &[PinctrlPin] = &[CLR_PIN_SCU430_2, CLR_PIN_SCU6B0_2];
+    pub const PINCTRL_GPIOQ3: &[PinctrlPin] = &[CLR_PIN_SCU430_3, CLR_PIN_SCU6B0_3];
+    pub const PINCTRL_GPIOQ4: &[PinctrlPin] = &[CLR_PIN_SCU430_4, CLR_PIN_SCU6B0_4];
+
+    pub const PINCTRL_GPIOR2: &[PinctrlPin] = &[CLR_PIN_SCU430_10];
+    pub const PINCTRL_GPIOR3: &[PinctrlPin] = &[CLR_PIN_SCU430_11];
+
+    pub const PINCTRL_GPIOS2: &[PinctrlPin] = &[CLR_PIN_SCU430_17];
+    pub const PINCTRL_GPIOS3: &[PinctrlPin] = &[CLR_PIN_SCU430_18];
+
+    pub const PINCTRL_GPIOT0: &[PinctrlPin] = &[PIN_SCU430_24];
+    pub const PINCTRL_GPIOT1: &[PinctrlPin] = &[PIN_SCU430_25];
+    pub const PINCTRL_GPIOT2: &[PinctrlPin] = &[PIN_SCU430_26];
+    pub const PINCTRL_GPIOT3: &[PinctrlPin] = &[PIN_SCU430_27];
+    pub const PINCTRL_GPIOT4: &[PinctrlPin] = &[PIN_SCU430_28];
+    pub const PINCTRL_GPIOT5: &[PinctrlPin] = &[PIN_SCU430_29];
+    pub const PINCTRL_GPIOT6: &[PinctrlPin] = &[PIN_SCU430_30];
+    pub const PINCTRL_GPIOT7: &[PinctrlPin] = &[PIN_SCU430_31];
+
+    pub const PINCTRL_GPIOU0: &[PinctrlPin] = &[PIN_SCU434_0];
+    pub const PINCTRL_GPIOU1: &[PinctrlPin] = &[PIN_SCU434_1];
+    pub const PINCTRL_GPIOU2: &[PinctrlPin] = &[PIN_SCU434_2];
+    pub const PINCTRL_GPIOU3: &[PinctrlPin] = &[PIN_SCU434_3];
+    pub const PINCTRL_GPIOU4: &[PinctrlPin] = &[PIN_SCU434_4];
+    pub const PINCTRL_GPIOU5: &[PinctrlPin] = &[PIN_SCU434_5];
+    pub const PINCTRL_GPIOU6: &[PinctrlPin] = &[PIN_SCU434_6];
+    pub const PINCTRL_GPIOU7: &[PinctrlPin] = &[PIN_SCU434_7];
+}
+
 #[macro_export]
 macro_rules! modify_reg {
     ($reg:expr, $bit:expr, $clear:expr) => {{
-        let reg = $reg;
-        let bit = $bit;
-        let clear = $clear;
-
-        reg.modify(|r, w| unsafe {
-            let current = r.bits();
-            let new_val = if clear {
-                current & !(1 << bit)
-            } else {
-                current | (1 << bit)
-            };
-            w.bits(new_val)
-        });
+        let mut val: u32 = $reg.read().bits();
+        if $clear {
+            val &= !(1 << $bit);
+        } else {
+            val |= (1 << $bit);
+        }
+        $reg.write(|w| unsafe { w.bits(val) });
     }};
 }
 
@@ -1413,8 +1927,12 @@ impl Pinctrl {
                 0x4b0 => modify_reg!(scu.scu4b0(), pin.bit, pin.clear),
                 0x4b4 => modify_reg!(scu.scu4b4(), pin.bit, pin.clear),
                 0x4b8 => modify_reg!(scu.scu4b8(), pin.bit, pin.clear),
+                0x4bc => modify_reg!(scu.scu4bc(), pin.bit, pin.clear),
                 0x690 => modify_reg!(scu.scu690(), pin.bit, pin.clear),
                 0x694 => modify_reg!(scu.scu694(), pin.bit, pin.clear),
+                0x698 => modify_reg!(scu.scu698(), pin.bit, pin.clear),
+                0x69c => modify_reg!(scu.scu69c(), pin.bit, pin.clear),
+                0x6b0 => modify_reg!(scu.scu6b0(), pin.bit, pin.clear),
                 _ => {}
             } //match
         } //for
diff --git a/src/tests/functional/gpio_test.rs b/src/tests/functional/gpio_test.rs
new file mode 100644
index 0000000..c971ba6
--- /dev/null
+++ b/src/tests/functional/gpio_test.rs
@@ -0,0 +1,123 @@
+// Licensed under the Apache-2.0 license
+
+use ast1060_pac::Peripherals;
+use embedded_hal::digital::{InputPin, OutputPin, StatefulOutputPin};
+use embedded_io::Write;
+
+use crate::common::DummyDelay;
+use crate::gpio::{gpioa, gpioh, gpiol, gpiom, Floating, GpioExt};
+use crate::pinctrl;
+use crate::uart::UartController;
+use embedded_hal::delay::DelayNs;
+
+pub fn test_gpioa(uart: &mut UartController<'_>) {
+    let peripherals = unsafe { Peripherals::steal() };
+    let gpio = peripherals.gpio;
+
+    pinctrl::Pinctrl::apply_pinctrl_group(pinctrl::PINCTRL_GPIOA0);
+    pinctrl::Pinctrl::apply_pinctrl_group(pinctrl::PINCTRL_GPIOA1);
+    pinctrl::Pinctrl::apply_pinctrl_group(pinctrl::PINCTRL_GPIOA3);
+    pinctrl::Pinctrl::apply_pinctrl_group(pinctrl::PINCTRL_GPIOA4);
+    let gpioa = gpioa::GPIOA::new(gpio).split();
+    uart.write_all(b"\r\n####### GPIO test #######\r\n")
+        .unwrap();
+    // input test
+    let mut pa0 = gpioa.pa0.into_pull_down_input();
+    if pa0.is_low().unwrap() {
+        uart.write_all(b"\rGPIOA pin0 is low\r\n").unwrap();
+    }
+    let mut pa1 = gpioa.pa1.into_pull_up_input();
+    if pa1.is_high().unwrap() {
+        uart.write_all(b"\rGPIOA pin1 is high\r\n").unwrap();
+    }
+    // output test
+    let mut pa3 = gpioa.pa3.into_open_drain_output::<Floating>();
+    pa3.set_low().unwrap();
+    if pa3.is_set_low().unwrap() {
+        uart.write_all(b"\rGPIOA pin3 set low successfully\r\n")
+            .unwrap();
+    }
+    pa3.set_high().unwrap();
+    if pa3.is_set_high().unwrap() {
+        uart.write_all(b"\rGPIOA pin3 set high successfully\r\n")
+            .unwrap();
+    }
+
+    let mut pa4 = gpioa.pa4.into_push_pull_output();
+    pa4.set_low().unwrap();
+    if pa4.is_set_low().unwrap() {
+        uart.write_all(b"\rGPIOA pin4 set low successfully\r\n")
+            .unwrap();
+    }
+    pa4.set_high().unwrap();
+    if pa4.is_set_high().unwrap() {
+        uart.write_all(b"\rGPIOA pin4 set high successfully\r\n")
+            .unwrap();
+    }
+}
+
+pub fn test_gpio_flash_power(uart: &mut UartController<'_>) {
+    let mut delay = DummyDelay {};
+    if true {
+        /* Older demo board required this */
+        let peripherals = unsafe { Peripherals::steal() };
+        let gpio = peripherals.gpio;
+        let gpiol = gpiol::GPIOL::new(gpio).split();
+        uart.write_all(b"\r\n####### GPIO flash power #######\r\n")
+            .unwrap();
+
+        pinctrl::Pinctrl::apply_pinctrl_group(pinctrl::PINCTRL_GPIOL2);
+        pinctrl::Pinctrl::apply_pinctrl_group(pinctrl::PINCTRL_GPIOL3);
+        let mut pl2 = gpiol.pl2.into_push_pull_output();
+        pl2.set_high().unwrap();
+        uart.write_all(b"\r\nGPIOL2 set high\r\n").unwrap();
+        let mut pl3 = gpiol.pl3.into_push_pull_output();
+        pl3.set_high().unwrap();
+        uart.write_all(b"\r\nGPIOL3 set high\r\n").unwrap();
+        delay.delay_ns(1_000_000);
+    }
+}
+#[allow(dead_code)]
+pub fn test_gpio_bmc_reset(uart: &mut UartController<'_>) {
+    {
+        let peripherals = unsafe { Peripherals::steal() };
+        let gpio = peripherals.gpio;
+        let gpiom = gpiom::GPIOM::new(gpio).split();
+        uart.write_all(b"\r\n####### GPIO BMC SRST #######\r\n")
+            .unwrap();
+
+        pinctrl::Pinctrl::apply_pinctrl_group(pinctrl::PINCTRL_GPIOM5);
+        let mut pm5 = gpiom.pm5.into_push_pull_output();
+        pm5.set_low().unwrap();
+        if pm5.is_set_low().unwrap() {
+            uart.write_all(b"\r\nGPIOM pin5 set low successfully\r\n")
+                .unwrap();
+        }
+        pm5.set_high().unwrap();
+        if pm5.is_set_high().unwrap() {
+            uart.write_all(b"\r\nGPIOM pin5 set high successfully\r\n")
+                .unwrap();
+        }
+    }
+
+    {
+        let peripherals = unsafe { Peripherals::steal() };
+        let gpio = peripherals.gpio;
+        let gpioh = gpioh::GPIOH::new(gpio).split();
+        uart.write_all(b"\r\n####### GPIO BMC EXTRST #######\r\n")
+            .unwrap();
+
+        pinctrl::Pinctrl::apply_pinctrl_group(pinctrl::PINCTRL_GPIOH2);
+        let mut ph2 = gpioh.ph2.into_push_pull_output();
+        ph2.set_low().unwrap();
+        if ph2.is_set_low().unwrap() {
+            uart.write_all(b"\r\nGPIOH pin2 set low successfully\r\n")
+                .unwrap();
+        }
+        ph2.set_high().unwrap();
+        if ph2.is_set_high().unwrap() {
+            uart.write_all(b"\r\nGPIOH pin2 set high successfully\r\n")
+                .unwrap();
+        }
+    }
+}
diff --git a/src/tests/functional/mod.rs b/src/tests/functional/mod.rs
index 6a27e6a..3206b64 100644
--- a/src/tests/functional/mod.rs
+++ b/src/tests/functional/mod.rs
@@ -1,6 +1,7 @@
 // Licensed under the Apache-2.0 license
 
 pub mod ecdsa_test;
+pub mod gpio_test;
 pub mod hash_test;
 pub mod hmac_test;
 pub mod rsa_test;