Merge pull request #11 from jamesmunns/james/impl-clocks

Implement initial `clock` driver.

This PR introduces an initial two-phase clock driver system:

1. The first stage is responsible for initializing the core/system clocks at the time of `embassy_mcxa::init()`
2. The second stage is done on creation of peripherals

This work is limited to currently used clocks and peripherals, but has room for expansion for later peripherals. This model is based on the preliminary refactoring performed for the `embassy-imxrt` crate.

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);
 }