1 files changed, 326 insertions, 27 deletions

diff --git a/embassy-nxp/build.rs b/embassy-nxp/build.rs
index f3c062c87..f53c29161 100644
--- a/embassy-nxp/build.rs
+++ b/embassy-nxp/build.rs
@@ -4,10 +4,12 @@ use std::process::Command;
 use std::{env, fs};
 
 use cfg_aliases::cfg_aliases;
-#[cfg(feature = "_rt1xxx")]
 use nxp_pac::metadata;
+use nxp_pac::metadata::{METADATA, Peripheral};
 #[allow(unused)]
 use proc_macro2::TokenStream;
+use proc_macro2::{Ident, Literal, Span};
+use quote::format_ident;
 #[allow(unused)]
 use quote::quote;
 
@@ -31,56 +33,188 @@ fn main() {
     .unwrap()
     .to_ascii_lowercase();
 
+    let singletons = singletons(&mut cfgs);
+
     cfg_aliases! {
         rt1xxx: { any(feature = "mimxrt1011", feature = "mimxrt1062") },
-        gpio1: { any(feature = "mimxrt1011", feature = "mimxrt1062") },
-        gpio2: { any(feature = "mimxrt1011", feature = "mimxrt1062") },
-        gpio3: { feature = "mimxrt1062" },
-        gpio4: { feature = "mimxrt1062" },
-        gpio5: { any(feature = "mimxrt1011", feature = "mimxrt1062") },
     }
 
     eprintln!("chip: {chip_name}");
 
-    generate_code();
+    generate_code(&mut cfgs, &singletons);
 }
 
-#[cfg(feature = "_rt1xxx")]
-fn generate_iomuxc() -> TokenStream {
-    use proc_macro2::{Ident, Span};
+/// A peripheral singleton returned by `embassy_nxp::init`.
+struct Singleton {
+    name: String,
 
-    let pads = metadata::iomuxc::IOMUXC_REGISTERS.iter().map(|registers| {
-        let name = Ident::new(&registers.name, Span::call_site());
-        let address = registers.pad_ctl;
+    /// A cfg guard which indicates whether the `Peripherals` struct will give the user this singleton.
+    cfg: Option<TokenStream>,
+}
 
-        quote! {
-            pub const #name: u32 = #address;
+fn singletons(cfgs: &mut common::CfgSet) -> Vec<Singleton> {
+    let mut singletons = Vec::new();
+
+    for peripheral in METADATA.peripherals {
+        // GPIO and DMA are generated in a 2nd pass.
+        let skip_singleton = if peripheral.name.starts_with("GPIO") || peripheral.name.starts_with("DMA") {
+            true
+        } else {
+            false
+        };
+
+        if !skip_singleton {
+            singletons.push(Singleton {
+                name: peripheral.name.into(),
+                cfg: None,
+            });
         }
-    });
+    }
 
-    let muxes = metadata::iomuxc::IOMUXC_REGISTERS.iter().map(|registers| {
-        let name = Ident::new(&registers.name, Span::call_site());
-        let address = registers.mux_ctl;
+    cfgs.declare_all(&[
+        "gpio1",
+        "gpio1_hi",
+        "gpio2",
+        "gpio2_hi",
+        "gpio3",
+        "gpio3_hi",
+        "gpio4",
+        "gpio4_hi",
+        "gpio5",
+        "gpio5_hi",
+        "gpio10",
+        "gpio10_hi",
+    ]);
 
-        quote! {
-            pub const #name: u32 = #address;
+    for peripheral in METADATA.peripherals.iter().filter(|p| p.name.starts_with("GPIO")) {
+        let number = peripheral.name.strip_prefix("GPIO").unwrap();
+        assert!(number.parse::<u8>().is_ok());
+        cfgs.enable(format!("gpio{}", number));
+
+        for signal in peripheral.signals.iter() {
+            let pin_number = signal.name.parse::<u8>().unwrap();
+
+            if pin_number > 15 {
+                cfgs.enable(format!("gpio{}_hi", number));
+            }
+
+            // GPIO signals only defined a single signal, on a single pin.
+            assert_eq!(signal.pins.len(), 1);
+
+            singletons.push(Singleton {
+                name: signal.pins[0].pin.into(),
+                cfg: None,
+            });
+        }
+    }
+
+    for peripheral in METADATA.peripherals.iter().filter(|p| p.name.starts_with("DMA")) {
+        let instance = peripheral.name.strip_prefix("DMA").unwrap();
+        assert!(instance.parse::<u8>().is_ok());
+
+        for signal in peripheral.signals.iter() {
+            let channel_number = signal.name.parse::<u8>().unwrap();
+            let name = format!("DMA{instance}_CH{channel_number}");
+
+            // DMA has no pins.
+            assert!(signal.pins.is_empty());
+
+            singletons.push(Singleton { name, cfg: None });
+        }
+    }
+
+    for peripheral in METADATA.peripherals.iter().filter(|p| p.name.starts_with("SCT")) {
+        let instance = peripheral.name.strip_prefix("SCT").unwrap();
+        assert!(instance.parse::<u8>().is_ok());
+
+        for signal in peripheral.signals.iter() {
+            if !signal.name.starts_with("OUT") {
+                continue;
+            }
+
+            let channel_number = signal.name.strip_prefix("OUT").unwrap().parse::<u8>().unwrap();
+            let name = format!("SCT{instance}_OUT{channel_number}");
+
+            singletons.push(Singleton { name, cfg: None });
         }
+    }
+
+    singletons
+}
+
+#[cfg(feature = "_rt1xxx")]
+fn generate_iomuxc() -> TokenStream {
+    let iomuxc_pad_impls = metadata::METADATA
+        .pins
+        .iter()
+        .filter(|p| p.iomuxc.as_ref().filter(|i| i.mux.is_some()).is_some())
+        .map(|pin| {
+            let Some(ref iomuxc) = pin.iomuxc else {
+                panic!("Pin {} has no IOMUXC definitions", pin.name);
+            };
+
+            let name = Ident::new(pin.name, Span::call_site());
+            let mux = iomuxc.mux.unwrap();
+            let pad = iomuxc.pad;
+
+            quote! {
+                impl_iomuxc_pad!(#name, #pad, #mux);
+            }
+        });
+
+    let base_match_arms = metadata::METADATA
+        .peripherals
+        .iter()
+        .filter(|p| p.name.starts_with("GPIO"))
+        .map(|peripheral| {
+            peripheral.signals.iter().map(|signal| {
+                // All GPIO signals have a single pin.
+                let pin = &signal.pins[0];
+                let instance = peripheral.name.strip_prefix("GPIO").unwrap();
+                let bank_match = format_ident!("Gpio{}", instance);
+                let pin_number = signal.name.parse::<u8>().unwrap();
+                let pin_ident = Ident::new(pin.pin, Span::call_site());
+
+                quote! {
+                    (Bank::#bank_match, #pin_number) => <crate::peripherals::#pin_ident as crate::iomuxc::SealedPad>
+                }
+            })
+        })
+        .flatten()
+        .collect::<Vec<_>>();
+
+    let pad_match_arms = base_match_arms.iter().map(|arm| {
+        quote! { #arm::PAD }
+    });
+
+    let mux_match_arms = base_match_arms.iter().map(|arm| {
+        quote! { #arm::MUX }
     });
 
     quote! {
-        pub mod iomuxc {
-            pub mod pads {
-                #(#pads)*
+        #(#iomuxc_pad_impls)*
+
+        pub(crate) fn iomuxc_pad(bank: crate::gpio::Bank, pin: u8) -> *mut () {
+            use crate::gpio::Bank;
+
+            match (bank, pin) {
+                #(#pad_match_arms),*,
+                _ => unreachable!()
             }
+        }
+
+        pub(crate) fn iomuxc_mux(bank: crate::gpio::Bank, pin: u8) -> Option<*mut ()> {
+            use crate::gpio::Bank;
 
-            pub mod muxes {
-                #(#muxes)*
+            match (bank, pin) {
+                #(#mux_match_arms),*,
+                _ => unreachable!()
             }
         }
     }
 }
 
-fn generate_code() {
+fn generate_code(cfgs: &mut common::CfgSet, singletons: &[Singleton]) {
     #[allow(unused)]
     use std::fmt::Write;
 
@@ -88,14 +222,179 @@ fn generate_code() {
     #[allow(unused_mut)]
     let mut output = String::new();
 
+    writeln!(&mut output, "{}", peripherals(singletons)).unwrap();
+
     #[cfg(feature = "_rt1xxx")]
     writeln!(&mut output, "{}", generate_iomuxc()).unwrap();
 
+    writeln!(&mut output, "{}", interrupts()).unwrap();
+    writeln!(&mut output, "{}", impl_peripherals(cfgs, singletons)).unwrap();
+
     let out_file = out_dir.join("_generated.rs").to_string_lossy().to_string();
     fs::write(&out_file, output).unwrap();
     rustfmt(&out_file);
 }
 
+fn interrupts() -> TokenStream {
+    let interrupts = METADATA.interrupts.iter().map(|interrupt| format_ident!("{interrupt}"));
+
+    quote! {
+        embassy_hal_internal::interrupt_mod!(#(#interrupts),*);
+    }
+}
+
+fn peripherals(singletons: &[Singleton]) -> TokenStream {
+    let defs = singletons.iter().map(|s| {
+        let ident = Ident::new(&s.name, Span::call_site());
+        quote! { #ident }
+    });
+
+    let peripherals = singletons.iter().map(|s| {
+        let ident = Ident::new(&s.name, Span::call_site());
+        let cfg = s.cfg.clone().unwrap_or_else(|| quote! {});
+        quote! {
+            #cfg
+            #ident
+        }
+    });
+
+    quote! {
+        embassy_hal_internal::peripherals_definition!(#(#defs),*);
+        embassy_hal_internal::peripherals_struct!(#(#peripherals),*);
+    }
+}
+
+fn impl_gpio_pin(impls: &mut Vec<TokenStream>, peripheral: &Peripheral) {
+    let instance = peripheral.name.strip_prefix("GPIO").unwrap();
+    let bank = format_ident!("Gpio{}", instance);
+    // let pin =
+
+    for signal in peripheral.signals.iter() {
+        let pin_number = signal.name.parse::<u8>().unwrap();
+        let pin = Ident::new(signal.pins[0].pin, Span::call_site());
+
+        impls.push(quote! {
+            impl_pin!(#pin, #bank, #pin_number);
+        });
+    }
+}
+
+fn impl_dma_channel(impls: &mut Vec<TokenStream>, peripheral: &Peripheral) {
+    let instance = Ident::new(peripheral.name, Span::call_site());
+
+    for signal in peripheral.signals.iter() {
+        let channel_number = signal.name.parse::<u8>().unwrap();
+        let channel_name = format_ident!("{instance}_CH{channel_number}");
+
+        impls.push(quote! {
+            impl_dma_channel!(#instance, #channel_name, #channel_number);
+        });
+    }
+}
+
+fn impl_usart(impls: &mut Vec<TokenStream>, peripheral: &Peripheral) {
+    let instance = Ident::new(peripheral.name, Span::call_site());
+    let flexcomm = Ident::new(
+        peripheral.flexcomm.expect("LPC55 must specify FLEXCOMM instance"),
+        Span::call_site(),
+    );
+    let number = Literal::u8_unsuffixed(peripheral.name.strip_prefix("USART").unwrap().parse::<u8>().unwrap());
+
+    impls.push(quote! {
+        impl_usart_instance!(#instance, #flexcomm, #number);
+    });
+
+    for signal in peripheral.signals {
+        let r#macro = match signal.name {
+            "TXD" => format_ident!("impl_usart_txd_pin"),
+            "RXD" => format_ident!("impl_usart_rxd_pin"),
+            _ => unreachable!(),
+        };
+
+        for pin in signal.pins {
+            let alt = format_ident!("ALT{}", pin.alt);
+            let pin = format_ident!("{}", pin.pin);
+
+            impls.push(quote! {
+                #r#macro!(#pin, #instance, #alt);
+            });
+        }
+    }
+
+    for dma_mux in peripheral.dma_muxing {
+        assert_eq!(dma_mux.mux, "DMA0", "TODO: USART for more than LPC55");
+
+        let r#macro = match dma_mux.signal {
+            "TX" => format_ident!("impl_usart_tx_channel"),
+            "RX" => format_ident!("impl_usart_rx_channel"),
+            _ => unreachable!(),
+        };
+
+        let channel = format_ident!("DMA0_CH{}", dma_mux.request);
+
+        impls.push(quote! {
+            #r#macro!(#instance, #channel);
+        });
+    }
+}
+
+fn impl_sct(impls: &mut Vec<TokenStream>, peripheral: &Peripheral) {
+    let instance = Ident::new(peripheral.name, Span::call_site());
+
+    impls.push(quote! {
+        impl_sct_instance!(#instance);
+    });
+
+    for signal in peripheral.signals.iter() {
+        if signal.name.starts_with("OUT") {
+            let channel_number = signal.name.strip_prefix("OUT").unwrap().parse::<u8>().unwrap();
+
+            let channel_name = format_ident!("{instance}_OUT{channel_number}");
+
+            impls.push(quote! {
+                impl_sct_output_instance!(#instance, #channel_name, #channel_number);
+            });
+
+            if signal.name.starts_with("OUT") {
+                for pin in signal.pins {
+                    let pin_name = format_ident!("{}", pin.pin);
+                    let alt = format_ident!("ALT{}", pin.alt);
+
+                    impls.push(quote! {
+                        impl_sct_output_pin!(#instance, #channel_name, #pin_name, #alt);
+                    });
+                }
+            }
+        }
+    }
+}
+
+fn impl_peripherals(_cfgs: &mut common::CfgSet, _singletons: &[Singleton]) -> TokenStream {
+    let mut impls = Vec::new();
+
+    for peripheral in metadata::METADATA.peripherals.iter() {
+        if peripheral.name.starts_with("GPIO") {
+            impl_gpio_pin(&mut impls, peripheral);
+        }
+
+        if peripheral.name.starts_with("DMA") {
+            impl_dma_channel(&mut impls, peripheral);
+        }
+
+        if peripheral.name.starts_with("USART") {
+            impl_usart(&mut impls, peripheral);
+        }
+
+        if peripheral.name.starts_with("SCT") {
+            impl_sct(&mut impls, peripheral);
+        }
+    }
+
+    quote! {
+        #(#impls)*
+    }
+}
+
 /// rustfmt a given path.
 /// Failures are logged to stderr and ignored.
 fn rustfmt(path: impl AsRef<Path>) {