14 files changed, 239 insertions, 270 deletions

diff --git a/examples/src/bin/adc_interrupt.rs b/examples/src/bin/adc_interrupt.rs
index e174a5272..6812ba5d3 100644
--- a/examples/src/bin/adc_interrupt.rs
+++ b/examples/src/bin/adc_interrupt.rs
@@ -2,13 +2,16 @@
 #![no_main]
 
 use embassy_executor::Spawner;
-use embassy_mcxa_examples::{init_adc, init_uart2};
+use embassy_mcxa_examples::init_adc_pins;
 use hal::adc::{LpadcConfig, TriggerPriorityPolicy};
+use hal::clocks::periph_helpers::{AdcClockSel, Div4};
+use hal::clocks::PoweredClock;
+use hal::lpuart::{Config, Lpuart};
 use hal::pac::adc1::cfg::{Pwrsel, Refsel};
 use hal::pac::adc1::cmdl1::{Adch, Mode};
 use hal::pac::adc1::ctrl::CalAvgs;
 use hal::pac::adc1::tctrl::Tcmd;
-use hal::{bind_interrupts, uart, InterruptExt};
+use hal::{bind_interrupts, InterruptExt};
 use {defmt_rtt as _, embassy_mcxa as hal, panic_probe as _};
 
 bind_interrupts!(struct Irqs {
@@ -23,17 +26,29 @@ static KEEP_ADC: unsafe extern "C" fn() = ADC1;
 async fn main(_spawner: Spawner) {
     let p = hal::init(hal::config::Config::default());
 
+    // Create UART configuration
+    let config = Config {
+        baudrate_bps: 115_200,
+        enable_tx: true,
+        enable_rx: true,
+        ..Default::default()
+    };
+
+    // Create UART instance using LPUART2 with PIO2_2 as TX and PIO2_3 as RX
     unsafe {
-        init_uart2(hal::pac());
+        embassy_mcxa_examples::init_uart2_pins(hal::pac());
     }
-
-    let src = unsafe { hal::clocks::uart2_src_hz(hal::pac()) };
-    let uart = uart::Uart::<uart::Lpuart2>::new(p.LPUART2, uart::Config::new(src));
-
+    let mut uart = Lpuart::new_blocking(
+        p.LPUART2, // Peripheral
+        p.PIO2_2,  // TX pin
+        p.PIO2_3,  // RX pin
+        config,
+    )
+    .unwrap();
     uart.write_str_blocking("\r\n=== ADC interrupt Example ===\r\n");
 
     unsafe {
-        init_adc(hal::pac());
+        init_adc_pins(hal::pac());
     }
 
     let adc_config = LpadcConfig {
@@ -47,6 +62,9 @@ async fn main(_spawner: Spawner) {
         enable_conv_pause: false,
         conv_pause_delay: 0,
         fifo_watermark: 0,
+        power: PoweredClock::NormalEnabledDeepSleepDisabled,
+        source: AdcClockSel::FroLfDiv,
+        div: Div4::no_div(),
     };
     let adc = hal::adc::Adc::<hal::adc::Adc1>::new(p.ADC1, adc_config);
 
diff --git a/examples/src/bin/adc_polling.rs b/examples/src/bin/adc_polling.rs
index 741551d49..421306e9b 100644
--- a/examples/src/bin/adc_polling.rs
+++ b/examples/src/bin/adc_polling.rs
@@ -4,13 +4,15 @@
 use core::fmt::Write;
 
 use embassy_executor::Spawner;
-use embassy_mcxa_examples::{init_adc, init_uart2};
+use embassy_mcxa_examples::{init_adc_pins, init_uart2_pins};
 use hal::adc::{ConvResult, LpadcConfig, TriggerPriorityPolicy};
+use hal::clocks::periph_helpers::{AdcClockSel, Div4};
+use hal::clocks::PoweredClock;
+use hal::lpuart::{Config, Lpuart};
 use hal::pac::adc1::cfg::{Pwrsel, Refsel};
 use hal::pac::adc1::cmdl1::{Adch, Mode};
 use hal::pac::adc1::ctrl::CalAvgs;
 use hal::pac::adc1::tctrl::Tcmd;
-use hal::uart;
 use heapless::String;
 use {defmt_rtt as _, embassy_mcxa as hal, panic_probe as _};
 
@@ -21,16 +23,33 @@ async fn main(_spawner: Spawner) {
     let p = hal::init(hal::config::Config::default());
 
     unsafe {
-        init_uart2(hal::pac());
+        init_uart2_pins(hal::pac());
     }
 
-    let src = unsafe { hal::clocks::uart2_src_hz(hal::pac()) };
-    let uart = uart::Uart::<uart::Lpuart2>::new(p.LPUART2, uart::Config::new(src));
+    // Create UART configuration
+    let config = Config {
+        baudrate_bps: 115_200,
+        enable_tx: true,
+        enable_rx: true,
+        ..Default::default()
+    };
+
+    // Create UART instance using LPUART2 with PIO2_2 as TX and PIO2_3 as RX
+    unsafe {
+        init_uart2_pins(hal::pac());
+    }
+    let mut uart = Lpuart::new_blocking(
+        p.LPUART2, // Peripheral
+        p.PIO2_2,  // TX pin
+        p.PIO2_3,  // RX pin
+        config,
+    )
+    .unwrap();
 
     uart.write_str_blocking("\r\n=== ADC polling Example ===\r\n");
 
     unsafe {
-        init_adc(hal::pac());
+        init_adc_pins(hal::pac());
     }
 
     let adc_config = LpadcConfig {
@@ -44,6 +63,9 @@ async fn main(_spawner: Spawner) {
         enable_conv_pause: false,
         conv_pause_delay: 0,
         fifo_watermark: 0,
+        power: PoweredClock::NormalEnabledDeepSleepDisabled,
+        source: AdcClockSel::FroLfDiv,
+        div: Div4::no_div(),
     };
     let adc = hal::adc::Adc::<hal::adc::Adc1>::new(p.ADC1, adc_config);
 
diff --git a/examples/src/bin/blink.rs b/examples/src/bin/blink.rs
index c36fc9421..d8b158d50 100644
--- a/examples/src/bin/blink.rs
+++ b/examples/src/bin/blink.rs
@@ -4,7 +4,7 @@
 use embassy_executor::Spawner;
 use embassy_mcxa as hal;
 use embassy_mcxa::bind_interrupts;
-use embassy_mcxa_examples::{init_led, init_ostimer0};
+use embassy_mcxa_examples::init_led_gpio_clocks;
 use embassy_time::{Duration, Timer};
 use hal::gpio::pins::PIO3_18;
 use hal::gpio::{Level, Output};
@@ -23,8 +23,7 @@ async fn main(_spawner: Spawner) {
     let _p = hal::init(hal::config::Config::default());
 
     unsafe {
-        init_led(hal::pac());
-        init_ostimer0(hal::pac());
+        init_led_gpio_clocks(hal::pac());
     }
 
     defmt::info!("Blink example");
diff --git a/examples/src/bin/hello.rs b/examples/src/bin/hello.rs
index 5c4336d50..207c157c3 100644
--- a/examples/src/bin/hello.rs
+++ b/examples/src/bin/hello.rs
@@ -2,12 +2,11 @@
 #![no_main]
 
 use embassy_executor::Spawner;
-use embassy_mcxa_examples::init_uart2;
-use hal::uart;
+use hal::lpuart::{Blocking, Config, Lpuart};
 use {defmt_rtt as _, embassy_mcxa as hal, panic_probe as _};
 
 /// Simple helper to write a byte as hex to UART
-fn write_hex_byte(uart: &hal::uart::Uart<hal::uart::Lpuart2>, byte: u8) {
+fn write_hex_byte(uart: &mut Lpuart<'_, Blocking>, byte: u8) {
     const HEX_DIGITS: &[u8] = b"0123456789ABCDEF";
     uart.write_byte(HEX_DIGITS[(byte >> 4) as usize]);
     uart.write_byte(HEX_DIGITS[(byte & 0xF) as usize]);
@@ -19,15 +18,25 @@ async fn main(_spawner: Spawner) {
 
     defmt::info!("boot");
 
-    // Board-level init for UART2 clocks and pins.
+    // Create UART configuration
+    let config = Config {
+        baudrate_bps: 115_200,
+        enable_tx: true,
+        enable_rx: true,
+        ..Default::default()
+    };
+
+    // Create UART instance using LPUART2 with PIO2_2 as TX and PIO2_3 as RX
     unsafe {
-        init_uart2(hal::pac());
+        embassy_mcxa_examples::init_uart2_pins(hal::pac());
     }
-
-    // Get UART source frequency from clock configuration
-    // Using hardcoded frequency for now - dynamic detection may have issues
-    let src = 12_000_000; // FRO_LF_DIV at 12MHz with DIV=0
-    let uart = uart::Uart::<uart::Lpuart2>::new(p.LPUART2, uart::Config::new(src));
+    let mut uart = Lpuart::new_blocking(
+        p.LPUART2, // Peripheral
+        p.PIO2_2,  // TX pin
+        p.PIO2_3,  // RX pin
+        config,
+    )
+    .unwrap();
 
     // Print welcome message before any async delays to guarantee early console output
     uart.write_str_blocking("\r\n=== MCXA276 UART Echo Demo ===\r\n");
@@ -66,7 +75,7 @@ async fn main(_spawner: Spawner) {
                     let num_str = &command[4..];
                     if let Ok(num) = parse_u8(num_str) {
                         uart.write_str_blocking("Hex: 0x");
-                        write_hex_byte(&uart, num);
+                        write_hex_byte(&mut uart, num);
                         uart.write_str_blocking("\r\n");
                     } else {
                         uart.write_str_blocking("Invalid number for hex command\r\n");
diff --git a/examples/src/bin/lpuart_buffered.rs b/examples/src/bin/lpuart_buffered.rs
index 480d8e1f7..642d4af65 100644
--- a/examples/src/bin/lpuart_buffered.rs
+++ b/examples/src/bin/lpuart_buffered.rs
@@ -5,24 +5,24 @@ use embassy_executor::Spawner;
 use embassy_mcxa as hal;
 use embassy_mcxa::interrupt::typelevel::Handler;
 use embassy_mcxa::lpuart::buffered::BufferedLpuart;
+use embassy_mcxa::lpuart::Config;
 use embassy_mcxa::{bind_interrupts, lpuart};
-use embassy_mcxa_examples::{init_ostimer0, init_uart2};
+use embassy_mcxa_examples::init_uart2_pins;
 use embedded_io_async::{Read, Write};
 
 // Bind OS_EVENT for timers plus LPUART2 IRQ for the buffered driver
 bind_interrupts!(struct Irqs {
-    LPUART2 => lpuart::buffered::BufferedInterruptHandler::<lpuart::lib::peripherals::LPUART2>;
+    LPUART2 => lpuart::buffered::BufferedInterruptHandler::<hal::peripherals::LPUART2>;
 });
 
 // Wrapper function for the interrupt handler
 unsafe extern "C" fn lpuart2_handler() {
-    lpuart::buffered::BufferedInterruptHandler::<lpuart::lib::peripherals::LPUART2>::on_interrupt();
+    lpuart::buffered::BufferedInterruptHandler::<hal::peripherals::LPUART2>::on_interrupt();
 }
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let _p = hal::init(hal::config::Config::default());
-    let p2 = lpuart::lib::init();
+    let p = hal::init(hal::config::Config::default());
 
     unsafe {
         hal::interrupt::install_irq_handler(hal::pac::Interrupt::LPUART2, lpuart2_handler);
@@ -32,12 +32,11 @@ async fn main(_spawner: Spawner) {
     hal::interrupt::LPUART2.configure_for_uart(hal::interrupt::Priority::P3);
 
     unsafe {
-        init_uart2(hal::pac());
-        init_ostimer0(hal::pac());
+        init_uart2_pins(hal::pac());
     }
 
     // UART configuration (enable both TX and RX)
-    let config = lpuart::Config {
+    let config = Config {
         baudrate_bps: 115_200,
         enable_tx: true,
         enable_rx: true,
@@ -51,9 +50,9 @@ async fn main(_spawner: Spawner) {
 
     // Create a buffered LPUART2 instance with both TX and RX
     let mut uart = BufferedLpuart::new(
-        p2.LPUART2,
-        p2.PIO2_2, // TX pin
-        p2.PIO2_3, // RX pin
+        p.LPUART2,
+        p.PIO2_2, // TX pin
+        p.PIO2_3, // RX pin
         Irqs,
         &mut tx_buf,
         &mut rx_buf,
diff --git a/examples/src/bin/lpuart_polling.rs b/examples/src/bin/lpuart_polling.rs
index 215714569..bea82c33e 100644
--- a/examples/src/bin/lpuart_polling.rs
+++ b/examples/src/bin/lpuart_polling.rs
@@ -2,20 +2,20 @@
 #![no_main]
 
 use embassy_executor::Spawner;
-use embassy_mcxa_examples::init_uart2;
-use hal::lpuart::{lib, Config, Lpuart};
+use embassy_mcxa_examples::init_uart2_pins;
 use {defmt_rtt as _, embassy_mcxa as hal, panic_probe as _};
 
+use crate::hal::lpuart::{Config, Lpuart};
+
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let _p = hal::init(hal::config::Config::default());
-    let p2 = lib::init();
+    let p = hal::init(hal::config::Config::default());
 
     defmt::info!("boot");
 
     // Board-level init for UART2 clocks and pins.
     unsafe {
-        init_uart2(hal::pac());
+        init_uart2_pins(hal::pac());
     }
 
     // Create UART configuration
@@ -28,9 +28,9 @@ async fn main(_spawner: Spawner) {
 
     // Create UART instance using LPUART2 with PIO2_2 as TX and PIO2_3 as RX
     let lpuart = Lpuart::new_blocking(
-        p2.LPUART2, // Peripheral
-        p2.PIO2_2,  // TX pin
-        p2.PIO2_3,  // RX pin
+        p.LPUART2, // Peripheral
+        p.PIO2_2,  // TX pin
+        p.PIO2_3,  // RX pin
         config,
     )
     .unwrap();
diff --git a/examples/src/bin/ostimer_alarm.rs b/examples/src/bin/ostimer_alarm.rs
index 953f98c01..03fb93319 100644
--- a/examples/src/bin/ostimer_alarm.rs
+++ b/examples/src/bin/ostimer_alarm.rs
@@ -5,8 +5,10 @@ use core::sync::atomic::{AtomicBool, Ordering};
 
 use embassy_executor::Spawner;
 use embassy_mcxa::bind_interrupts;
-use embassy_mcxa_examples::{init_ostimer0, init_uart2};
-use hal::uart;
+use embassy_mcxa::clocks::periph_helpers::OstimerClockSel;
+use embassy_mcxa::clocks::PoweredClock;
+use embassy_mcxa::lpuart::{Config, Lpuart};
+use embassy_mcxa_examples::init_uart2_pins;
 use {defmt_rtt as _, embassy_mcxa as hal, panic_probe as _};
 
 // Bind only OS_EVENT, and retain the symbol explicitly so it can't be GC'ed.
@@ -30,13 +32,26 @@ fn alarm_callback() {
 async fn main(_spawner: Spawner) {
     let p = hal::init(hal::config::Config::default());
 
-    // Enable/clock OSTIMER0 and UART2 before touching their registers
+    // Create UART configuration
+    let config = Config {
+        baudrate_bps: 115_200,
+        enable_tx: true,
+        enable_rx: true,
+        ..Default::default()
+    };
+
+    // Create UART instance using LPUART2 with PIO2_2 as TX and PIO2_3 as RX
     unsafe {
-        init_ostimer0(hal::pac());
-        init_uart2(hal::pac());
+        init_uart2_pins(hal::pac());
     }
-    let src = unsafe { hal::clocks::uart2_src_hz(hal::pac()) };
-    let uart = uart::Uart::<uart::Lpuart2>::new(p.LPUART2, uart::Config::new(src));
+    let mut uart = Lpuart::new_blocking(
+        p.LPUART2, // Peripheral
+        p.PIO2_2,  // TX pin
+        p.PIO2_3,  // RX pin
+        config,
+    )
+    .unwrap();
+
     uart.write_str_blocking("OSTIMER Alarm Example\n");
 
     // Initialize embassy-time global driver backed by OSTIMER0
@@ -45,9 +60,10 @@ async fn main(_spawner: Spawner) {
     // Create OSTIMER instance
     let config = hal::ostimer::Config {
         init_match_max: true,
-        clock_frequency_hz: 1_000_000, // 1MHz
+        power: PoweredClock::NormalEnabledDeepSleepDisabled,
+        source: OstimerClockSel::Clk1M,
     };
-    let ostimer = hal::ostimer::Ostimer::<hal::ostimer::Ostimer0>::new(p.OSTIMER0, config, hal::pac());
+    let ostimer = hal::ostimer::Ostimer::<hal::ostimer::Ostimer0>::new(p.OSTIMER0, config);
 
     // Create alarm with callback
     let alarm = hal::ostimer::Alarm::new()
diff --git a/examples/src/bin/ostimer_async.rs b/examples/src/bin/ostimer_async.rs
index 34862b61f..881f09374 100644
--- a/examples/src/bin/ostimer_async.rs
+++ b/examples/src/bin/ostimer_async.rs
@@ -3,9 +3,9 @@
 
 use embassy_executor::Spawner;
 use embassy_mcxa::bind_interrupts;
-use embassy_mcxa_examples::{init_ostimer0, init_uart2};
+use embassy_mcxa_examples::init_uart2_pins;
 use embassy_time::{Duration, Timer};
-use hal::uart;
+use hal::lpuart::{Config, Lpuart};
 use {defmt_rtt as _, embassy_mcxa as hal, panic_probe as _};
 
 // Bind only OS_EVENT, and retain the symbol explicitly so it can’t be GC’ed.
@@ -19,16 +19,28 @@ static KEEP_OS_EVENT: unsafe extern "C" fn() = OS_EVENT;
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let _p = hal::init(hal::config::Config::default());
+    let p = hal::init(hal::config::Config::default());
 
-    // Enable/clock OSTIMER0 and UART2 before touching their registers
+    // Create UART configuration
+    let config = Config {
+        baudrate_bps: 115_200,
+        enable_tx: true,
+        enable_rx: true,
+        ..Default::default()
+    };
+
+    // Create UART instance using LPUART2 with PIO2_2 as TX and PIO2_3 as RX
     unsafe {
-        init_ostimer0(hal::pac());
-        init_uart2(hal::pac());
+        init_uart2_pins(hal::pac());
     }
-    let src = unsafe { hal::clocks::uart2_src_hz(hal::pac()) };
-    let uart = uart::Uart::<uart::Lpuart2>::new(_p.LPUART2, uart::Config::new(src));
-    uart.write_str_blocking("boot\n");
+    let mut uart = Lpuart::new_blocking(
+        p.LPUART2, // Peripheral
+        p.PIO2_2,  // TX pin
+        p.PIO2_3,  // RX pin
+        config,
+    )
+    .unwrap();
+    uart.blocking_write(b"boot\n").unwrap();
 
     // Avoid mass NVIC writes here; DefaultHandler now safely returns.
 
diff --git a/examples/src/bin/ostimer_counter.rs b/examples/src/bin/ostimer_counter.rs
index 20044760a..2fbc251b9 100644
--- a/examples/src/bin/ostimer_counter.rs
+++ b/examples/src/bin/ostimer_counter.rs
@@ -7,7 +7,9 @@
 #![no_main]
 
 use embassy_executor::Spawner;
-use embassy_mcxa_examples::{init_ostimer0, init_uart2};
+use embassy_mcxa::clocks::periph_helpers::OstimerClockSel;
+use embassy_mcxa::clocks::PoweredClock;
+use embassy_mcxa::lpuart::{Blocking, Config, Lpuart};
 use embassy_time::{Duration, Timer};
 use hal::bind_interrupts;
 use {defmt_rtt as _, embassy_mcxa as hal, panic_probe as _};
@@ -20,13 +22,25 @@ bind_interrupts!(struct Irqs {
 async fn main(_spawner: Spawner) {
     let p = hal::init(Default::default());
 
-    // Enable/clock OSTIMER0 and UART2 before touching their registers
+    // Create UART configuration
+    let config = Config {
+        baudrate_bps: 115_200,
+        enable_tx: true,
+        enable_rx: true,
+        ..Default::default()
+    };
+
+    // Create UART instance using LPUART2 with PIO2_2 as TX and PIO2_3 as RX
     unsafe {
-        init_ostimer0(hal::pac());
-        init_uart2(hal::pac());
+        embassy_mcxa_examples::init_uart2_pins(hal::pac());
     }
-    let src = unsafe { hal::clocks::uart2_src_hz(hal::pac()) };
-    let mut uart = hal::uart::Uart::<hal::uart::Lpuart2>::new(p.LPUART2, hal::uart::Config::new(src));
+    let mut uart = Lpuart::new_blocking(
+        p.LPUART2, // Peripheral
+        p.PIO2_2,  // TX pin
+        p.PIO2_3,  // RX pin
+        config,
+    )
+    .unwrap();
 
     uart.write_str_blocking("OSTIMER Counter Reading and Reset Example\n");
 
@@ -41,9 +55,9 @@ async fn main(_spawner: Spawner) {
         p.OSTIMER0,
         hal::ostimer::Config {
             init_match_max: true,
-            clock_frequency_hz: 1_000_000,
+            power: PoweredClock::NormalEnabledDeepSleepDisabled,
+            source: OstimerClockSel::Clk1M,
         },
-        hal::pac(),
     );
 
     // Read initial counter value
@@ -89,7 +103,7 @@ async fn main(_spawner: Spawner) {
 }
 
 // Helper function to write a u64 value as decimal string
-fn write_u64(uart: &mut hal::uart::Uart<hal::uart::Lpuart2>, value: u64) {
+fn write_u64(uart: &mut Lpuart<'_, Blocking>, value: u64) {
     if value == 0 {
         uart.write_str_blocking("0");
         return;
diff --git a/examples/src/bin/ostimer_race_test.rs b/examples/src/bin/ostimer_race_test.rs
index 720a058d5..168a952cd 100644
--- a/examples/src/bin/ostimer_race_test.rs
+++ b/examples/src/bin/ostimer_race_test.rs
@@ -12,7 +12,9 @@
 use core::sync::atomic::{AtomicU32, Ordering};
 
 use embassy_executor::Spawner;
-use embassy_mcxa_examples::{init_ostimer0, init_uart2};
+use embassy_mcxa::clocks::periph_helpers::OstimerClockSel;
+use embassy_mcxa::clocks::PoweredClock;
+use embassy_mcxa::lpuart::{Blocking, Config, Lpuart};
 use embassy_time::{Duration, Timer};
 use hal::bind_interrupts;
 use {defmt_rtt as _, embassy_mcxa as hal, panic_probe as _};
@@ -41,7 +43,7 @@ fn alarm_callback() {
     }
 }
 
-fn report_default_handler(uart: &mut hal::uart::Uart<hal::uart::Lpuart2>) {
+fn report_default_handler(uart: &mut Lpuart<'_, Blocking>) {
     let snapshot = hal::interrupt::default_handler_snapshot();
     if snapshot.count == 0 {
         return;
@@ -70,13 +72,25 @@ fn report_default_handler(uart: &mut hal::uart::Uart<hal::uart::Lpuart2>) {
 async fn main(_spawner: Spawner) {
     let p = hal::init(Default::default());
 
-    // Enable/clock OSTIMER0 and UART2 before touching their registers
+    // Create UART configuration
+    let config = Config {
+        baudrate_bps: 115_200,
+        enable_tx: true,
+        enable_rx: true,
+        ..Default::default()
+    };
+
+    // Create UART instance using LPUART2 with PIO2_2 as TX and PIO2_3 as RX
     unsafe {
-        init_ostimer0(hal::pac());
-        init_uart2(hal::pac());
+        embassy_mcxa_examples::init_uart2_pins(hal::pac());
     }
-    let src = unsafe { hal::clocks::uart2_src_hz(hal::pac()) };
-    let mut uart = hal::uart::Uart::<hal::uart::Lpuart2>::new(p.LPUART2, hal::uart::Config::new(src));
+    let mut uart = Lpuart::new_blocking(
+        p.LPUART2, // Peripheral
+        p.PIO2_2,  // TX pin
+        p.PIO2_3,  // RX pin
+        config,
+    )
+    .unwrap();
 
     uart.write_str_blocking("OSTIMER Race Condition Test Starting...\n");
 
@@ -95,9 +109,9 @@ async fn main(_spawner: Spawner) {
         p.OSTIMER0,
         hal::ostimer::Config {
             init_match_max: true,
-            clock_frequency_hz: 1_000_000,
+            power: PoweredClock::NormalEnabledDeepSleepDisabled,
+            source: OstimerClockSel::Clk1M,
         },
-        hal::pac(),
     );
 
     uart.write_str_blocking("OSTIMER instance created\n");
@@ -136,7 +150,7 @@ async fn main(_spawner: Spawner) {
 // Test rapid alarm scheduling to stress interrupt handling
 async fn test_rapid_alarms(
     ostimer: &hal::ostimer::Ostimer<'_, hal::ostimer::Ostimer0>,
-    uart: &mut hal::uart::Uart<hal::uart::Lpuart2>,
+    uart: &mut Lpuart<'_, Blocking>,
 ) {
     let initial_count = ALARM_CALLBACK_COUNT.load(Ordering::SeqCst);
 
@@ -173,7 +187,7 @@ async fn test_rapid_alarms(
 // Test reading counter while interrupts are firing
 async fn test_counter_reading_during_interrupts(
     ostimer: &hal::ostimer::Ostimer<'_, hal::ostimer::Ostimer0>,
-    uart: &mut hal::uart::Uart<hal::uart::Lpuart2>,
+    uart: &mut Lpuart<'_, Blocking>,
 ) {
     let initial_interrupt_count = INTERRUPT_COUNT.load(Ordering::SeqCst);
 
@@ -234,7 +248,7 @@ async fn test_counter_reading_during_interrupts(
 // Test concurrent timer operations (embassy-time + alarms)
 async fn test_concurrent_operations(
     ostimer: &hal::ostimer::Ostimer<'_, hal::ostimer::Ostimer0>,
-    uart: &mut hal::uart::Uart<hal::uart::Lpuart2>,
+    uart: &mut Lpuart<'_, Blocking>,
 ) {
     let initial_interrupt_count = INTERRUPT_COUNT.load(Ordering::SeqCst);
 
@@ -263,7 +277,7 @@ async fn test_concurrent_operations(
 // Test timer reset during active operations
 async fn test_reset_during_operation(
     ostimer: &hal::ostimer::Ostimer<'_, hal::ostimer::Ostimer0>,
-    uart: &mut hal::uart::Uart<hal::uart::Lpuart2>,
+    uart: &mut Lpuart<'_, Blocking>,
     peripherals: &hal::pac::Peripherals,
 ) {
     let initial_counter = ostimer.now();
@@ -304,7 +318,7 @@ async fn test_reset_during_operation(
 }
 
 // Helper function to write a u32 value as decimal string
-fn write_u32(uart: &mut hal::uart::Uart<hal::uart::Lpuart2>, value: u32) {
+fn write_u32(uart: &mut Lpuart<'_, Blocking>, value: u32) {
     if value == 0 {
         uart.write_str_blocking("0");
         return;
@@ -339,7 +353,7 @@ fn write_u32(uart: &mut hal::uart::Uart<hal::uart::Lpuart2>, value: u32) {
     }
 }
 
-fn write_hex32(uart: &mut hal::uart::Uart<hal::uart::Lpuart2>, value: u32) {
+fn write_hex32(uart: &mut Lpuart<'_, Blocking>, value: u32) {
     let mut buf = [b'0'; 8];
     let mut tmp = value;
     for i in (0..8).rev() {
@@ -351,15 +365,13 @@ fn write_hex32(uart: &mut hal::uart::Uart<hal::uart::Lpuart2>, value: u32) {
         };
         tmp >>= 4;
     }
-    for b in &buf {
-        uart.write_byte(*b);
-    }
+    uart.blocking_write(&buf).unwrap();
 }
 
 // Helper function to write a u64 value as decimal string
-fn write_u64(uart: &mut hal::uart::Uart<hal::uart::Lpuart2>, value: u64) {
+fn write_u64(uart: &mut Lpuart<'_, Blocking>, value: u64) {
     if value == 0 {
-        uart.write_str_blocking("0");
+        uart.blocking_write(b"0").unwrap();
         return;
     }
 
@@ -377,17 +389,17 @@ fn write_u64(uart: &mut hal::uart::Uart<hal::uart::Lpuart2>, value: u64) {
     while i > 0 {
         i -= 1;
         match buffer[i] {
-            b'0' => uart.write_str_blocking("0"),
-            b'1' => uart.write_str_blocking("1"),
-            b'2' => uart.write_str_blocking("2"),
-            b'3' => uart.write_str_blocking("3"),
-            b'4' => uart.write_str_blocking("4"),
-            b'5' => uart.write_str_blocking("5"),
-            b'6' => uart.write_str_blocking("6"),
-            b'7' => uart.write_str_blocking("7"),
-            b'8' => uart.write_str_blocking("8"),
-            b'9' => uart.write_str_blocking("9"),
-            _ => uart.write_str_blocking("?"),
+            b'0' => uart.blocking_write(b"0").unwrap(),
+            b'1' => uart.blocking_write(b"1").unwrap(),
+            b'2' => uart.blocking_write(b"2").unwrap(),
+            b'3' => uart.blocking_write(b"3").unwrap(),
+            b'4' => uart.blocking_write(b"4").unwrap(),
+            b'5' => uart.blocking_write(b"5").unwrap(),
+            b'6' => uart.blocking_write(b"6").unwrap(),
+            b'7' => uart.blocking_write(b"7").unwrap(),
+            b'8' => uart.blocking_write(b"8").unwrap(),
+            b'9' => uart.blocking_write(b"9").unwrap(),
+            _ => uart.blocking_write(b"?").unwrap(),
         }
     }
 }
diff --git a/examples/src/bin/rtc_alarm.rs b/examples/src/bin/rtc_alarm.rs
index dc07b5757..40a1207df 100644
--- a/examples/src/bin/rtc_alarm.rs
+++ b/examples/src/bin/rtc_alarm.rs
@@ -3,11 +3,11 @@
 
 use embassy_executor::Spawner;
 use embassy_mcxa as hal;
-use embassy_mcxa_examples::init_uart2;
+use hal::lpuart::{Config, Lpuart};
 use hal::rtc::{RtcDateTime, RtcInterruptEnable};
-use hal::{uart, InterruptExt};
+use hal::InterruptExt;
 
-type MyRtc = hal::rtc::Rtc<hal::rtc::Rtc0>;
+type MyRtc = hal::rtc::Rtc<'static, hal::rtc::Rtc0>;
 
 use embassy_mcxa::bind_interrupts;
 use {defmt_rtt as _, panic_probe as _};
@@ -24,17 +24,28 @@ static KEEP_RTC: unsafe extern "C" fn() = RTC;
 async fn main(_spawner: Spawner) {
     let p = hal::init(hal::config::Config::default());
 
+    // Create UART configuration
+    let config = Config {
+        baudrate_bps: 115_200,
+        enable_tx: true,
+        enable_rx: true,
+        ..Default::default()
+    };
+
+    // Create UART instance using LPUART2 with PIO2_2 as TX and PIO2_3 as RX
     unsafe {
-        init_uart2(hal::pac());
+        embassy_mcxa_examples::init_uart2_pins(hal::pac());
     }
-
-    let src = unsafe { hal::clocks::uart2_src_hz(hal::pac()) };
-    let uart = uart::Uart::<uart::Lpuart2>::new(p.LPUART2, uart::Config::new(src));
+    let mut uart = Lpuart::new_blocking(
+        p.LPUART2, // Peripheral
+        p.PIO2_2,  // TX pin
+        p.PIO2_3,  // RX pin
+        config,
+    )
+    .unwrap();
 
     uart.write_str_blocking("\r\n=== RTC Alarm Example ===\r\n");
 
-    unsafe { hal::clocks::init_fro16k(hal::pac()) };
-
     let rtc_config = hal::rtc::get_default_config();
 
     let rtc = MyRtc::new(p.RTC0, rtc_config);
diff --git a/examples/src/bin/uart_interrupt.rs b/examples/src/bin/uart_interrupt.rs
deleted file mode 100644
index 100588727..000000000
--- a/examples/src/bin/uart_interrupt.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-#![no_std]
-#![no_main]
-
-use embassy_executor::Spawner;
-use embassy_mcxa::bind_interrupts;
-use embassy_mcxa_examples::init_uart2;
-use hal::interrupt::typelevel::Handler;
-use hal::uart;
-use {defmt_rtt as _, embassy_mcxa as hal, panic_probe as _};
-
-// Bind LPUART2 interrupt to our handler
-bind_interrupts!(struct Irqs {
-    LPUART2 => hal::uart::UartInterruptHandler;
-});
-
-#[used]
-#[no_mangle]
-static KEEP_LPUART2: unsafe extern "C" fn() = LPUART2;
-
-// Wrapper function for the interrupt handler
-unsafe extern "C" fn lpuart2_handler() {
-    hal::uart::UartInterruptHandler::on_interrupt();
-}
-
-#[embassy_executor::main]
-async fn main(_spawner: Spawner) {
-    let _p = hal::init(hal::config::Config::default());
-
-    // Enable/clock UART2 before touching its registers
-    unsafe {
-        init_uart2(hal::pac());
-    }
-    let src = unsafe { hal::clocks::uart2_src_hz(hal::pac()) };
-    let uart = uart::Uart::<uart::Lpuart2>::new(_p.LPUART2, uart::Config::new(src));
-
-    // Configure LPUART2 interrupt for UART operation BEFORE any UART usage
-    hal::interrupt::LPUART2.configure_for_uart(hal::interrupt::Priority::from(3));
-
-    // Manually install the interrupt handler and enable RX IRQs in the peripheral
-    unsafe {
-        hal::interrupt::LPUART2.install_handler(lpuart2_handler);
-        // Enable RX interrupts so the handler actually fires on incoming bytes
-        uart.enable_rx_interrupts();
-    }
-
-    // Print welcome message
-    uart.write_str_blocking("UART interrupt echo demo starting...\r\n");
-    uart.write_str_blocking("Type characters to echo them back.\r\n");
-
-    // Log using defmt if enabled
-    defmt::info!("UART interrupt echo demo starting...");
-
-    loop {
-        // Check if we have received any data
-        if uart.rx_data_available() {
-            if let Some(byte) = uart.try_read_byte() {
-                // Echo it back
-                uart.write_byte(byte);
-                uart.write_str_blocking(" (received)\r\n");
-            }
-        } else {
-            // No data available, wait a bit before checking again
-            cortex_m::asm::delay(12_000_000); // ~1 second at 12MHz
-        }
-    }
-}
diff --git a/examples/src/common/mod.rs b/examples/src/common/mod.rs
deleted file mode 100644
index 8cb4590f8..000000000
--- a/examples/src/common/mod.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-//! Shared board-specific helpers for the FRDM-MCXA276 examples.
-//! These live with the examples so the HAL stays generic.
-
-use hal::{clocks, pins, reset};
-use {embassy_mcxa as hal, panic_probe as _};
-
-/// Initialize clocks and pin muxing for UART2 debug console.
-/// Safe to call multiple times; writes are idempotent for our use.
-#[allow(dead_code)]
-pub unsafe fn init_uart2(p: &hal::pac::Peripherals) {
-    clocks::ensure_frolf_running(p);
-    clocks::enable_uart2_port2(p);
-    reset::release_reset_port2(p);
-    reset::release_reset_lpuart2(p);
-    pins::configure_uart2_pins_port2();
-    clocks::select_uart2_clock(p);
-}
-
-/// Initialize clocks for the LED GPIO/PORT used by the blink example.
-#[allow(dead_code)]
-pub unsafe fn init_led(p: &hal::pac::Peripherals) {
-    clocks::enable_led_port(p);
-    reset::release_reset_gpio3(p);
-    reset::release_reset_port3(p);
-}
-
-/// Initialize clocks for OSTIMER0 (1 MHz source).
-#[allow(dead_code)]
-pub unsafe fn init_ostimer0(p: &hal::pac::Peripherals) {
-    clocks::ensure_frolf_running(p);
-    clocks::enable_ostimer0(p);
-    reset::release_reset_ostimer0(p);
-    clocks::select_ostimer0_clock_1m(p);
-}
-
-/// Initialize clocks and pin muxing for ADC.
-#[allow(dead_code)]
-pub unsafe fn init_adc(p: &hal::pac::Peripherals) {
-    clocks::ensure_frolf_running(p);
-    clocks::enable_adc(p);
-    reset::release_reset_port1(p);
-    reset::release_reset_adc1(p);
-    pins::configure_adc_pins();
-    clocks::select_adc_clock(p);
-}
diff --git a/examples/src/lib.rs b/examples/src/lib.rs
index cf4194559..4bb334da5 100644
--- a/examples/src/lib.rs
+++ b/examples/src/lib.rs
@@ -1,63 +1,31 @@
 #![no_std]
+#![allow(clippy::missing_safety_doc)]
 
 //! Shared board-specific helpers for the FRDM-MCXA276 examples.
 //! These live with the examples so the HAL stays generic.
 
-use hal::{clocks, pins, reset};
+use hal::{clocks, pins};
 use {defmt_rtt as _, embassy_mcxa as hal, panic_probe as _};
 
 /// Initialize clocks and pin muxing for UART2 debug console.
 /// Safe to call multiple times; writes are idempotent for our use.
-///
-/// # Safety
-///
-/// Called only once to initialize the peripheral
-#[allow(dead_code)]
-pub unsafe fn init_uart2(p: &hal::pac::Peripherals) {
-    clocks::ensure_frolf_running(p);
-    clocks::enable_uart2_port2(p);
-    reset::release_reset_port2(p);
-    reset::release_reset_lpuart2(p);
+pub unsafe fn init_uart2_pins(_p: &hal::pac::Peripherals) {
+    // NOTE: Lpuart has been updated to properly enable + reset its own clocks.
+    // GPIO has not.
+    _ = clocks::enable_and_reset::<hal::peripherals::PORT2>(&clocks::periph_helpers::NoConfig);
     pins::configure_uart2_pins_port2();
-    clocks::select_uart2_clock(p);
 }
 
 /// Initialize clocks for the LED GPIO/PORT used by the blink example.
-///
-/// # Safety
-///
-/// Called only once to initialize the peripheral
-#[allow(dead_code)]
-pub unsafe fn init_led(p: &hal::pac::Peripherals) {
-    clocks::enable_led_port(p);
-    reset::release_reset_gpio3(p);
-    reset::release_reset_port3(p);
-}
-
-/// Initialize clocks for OSTIMER0 (1 MHz source).
-///
-/// # Safety
-///
-/// Called only once to initialize the peripheral
-#[allow(dead_code)]
-pub unsafe fn init_ostimer0(p: &hal::pac::Peripherals) {
-    clocks::ensure_frolf_running(p);
-    clocks::enable_ostimer0(p);
-    reset::release_reset_ostimer0(p);
-    clocks::select_ostimer0_clock_1m(p);
+pub unsafe fn init_led_gpio_clocks(_p: &hal::pac::Peripherals) {
+    _ = clocks::enable_and_reset::<hal::peripherals::PORT3>(&clocks::periph_helpers::NoConfig);
+    _ = clocks::enable_and_reset::<hal::peripherals::GPIO3>(&clocks::periph_helpers::NoConfig);
 }
 
 /// Initialize clocks and pin muxing for ADC.
-///
-/// # Safety
-///
-/// Called only once to initialize the peripheral
-#[allow(dead_code)]
-pub unsafe fn init_adc(p: &hal::pac::Peripherals) {
-    clocks::ensure_frolf_running(p);
-    clocks::enable_adc(p);
-    reset::release_reset_port1(p);
-    reset::release_reset_adc1(p);
+pub unsafe fn init_adc_pins(_p: &hal::pac::Peripherals) {
+    // NOTE: Lpuart has been updated to properly enable + reset its own clocks.
+    // GPIO has not.
+    _ = clocks::enable_and_reset::<hal::peripherals::PORT1>(&clocks::periph_helpers::NoConfig);
     pins::configure_adc_pins();
-    clocks::select_adc_clock(p);
 }