stm32/afio: use type inference for timer remaps as well.

1 files changed, 41 insertions, 90 deletions

diff --git a/embassy-stm32/build.rs b/embassy-stm32/build.rs
index f55e1e0c9..0d3582c9d 100644
--- a/embassy-stm32/build.rs
+++ b/embassy-stm32/build.rs
@@ -1391,58 +1391,51 @@ fn main() {
                         })
                     }
 
-                    let pin_trait_impl = p
-                        .afio
-                        .as_ref()
-                        .and_then(|afio| {
-                            if p.name.starts_with("TIM") {
-                                // timers are handled by timer_afio_impl!()
-                                return None;
-                            }
-
-                            let values = afio
-                                .values
-                                .iter()
-                                .filter(|v| v.pins.contains(&pin.pin))
-                                .map(|v| v.value)
-                                .collect::<Vec<_>>();
+                    let pin_trait_impl = if let Some(afio) = &p.afio {
+                        let values = afio
+                            .values
+                            .iter()
+                            .filter(|v| v.pins.contains(&pin.pin))
+                            .map(|v| v.value)
+                            .collect::<Vec<_>>();
 
-                            if values.is_empty() {
-                                None
-                            } else {
-                                let setter = format_ident!("set_{}", afio.field.to_lowercase());
-                                let type_and_values = if is_bool_field("AFIO", afio.register, afio.field) {
-                                    let values = values.iter().map(|&v| v > 0);
-                                    quote!(AfioRemapBool, [#(#values),*])
-                                } else {
-                                    quote!(AfioRemap, [#(#values),*])
-                                };
-
-                                Some(quote! {
-                                    pin_trait_afio_impl!(#tr, #peri, #pin_name, {#setter, #type_and_values});
-                                })
-                            }
-                        })
-                        .unwrap_or_else(|| {
-                            let peripherals_with_afio = [
-                                "CAN",
-                                "CEC",
-                                "ETH",
-                                "I2C",
-                                "SPI",
-                                "SUBGHZSPI",
-                                "USART",
-                                "UART",
-                                "LPUART",
-                            ];
-                            let af_or_not_applicable = if peripherals_with_afio.iter().any(|&x| p.name.starts_with(x)) {
-                                quote!(0, crate::gpio::AfioRemapNotApplicable)
+                        if values.is_empty() {
+                            None
+                        } else {
+                            let reg = format_ident!("{}", afio.register.to_lowercase());
+                            let setter = format_ident!("set_{}", afio.field.to_lowercase());
+                            let type_and_values = if is_bool_field("AFIO", afio.register, afio.field) {
+                                let values = values.iter().map(|&v| v > 0);
+                                quote!(AfioRemapBool, [#(#values),*])
                             } else {
-                                quote!(#af)
+                                quote!(AfioRemap, [#(#values),*])
                             };
 
-                            quote!(pin_trait_impl!(#tr, #peri, #pin_name, #af_or_not_applicable);)
-                        });
+                            Some(quote! {
+                                pin_trait_afio_impl!(#tr, #peri, #pin_name, {#reg, #setter, #type_and_values});
+                            })
+                        }
+                    } else {
+                        let peripherals_with_afio = [
+                            "CAN",
+                            "CEC",
+                            "ETH",
+                            "I2C",
+                            "SPI",
+                            "SUBGHZSPI",
+                            "USART",
+                            "UART",
+                            "LPUART",
+                            "TIM",
+                        ];
+                        let af_or_not_applicable = if peripherals_with_afio.iter().any(|&x| p.name.starts_with(x)) {
+                            quote!(0, crate::gpio::AfioRemapNotApplicable)
+                        } else {
+                            quote!(#af)
+                        };
+
+                        Some(quote!(pin_trait_impl!(#tr, #peri, #pin_name, #af_or_not_applicable);))
+                    };
 
                     g.extend(pin_trait_impl);
                 }
@@ -1970,48 +1963,6 @@ fn main() {
     });
 
     // ========
-    // Generate timer AFIO impls
-
-    for p in METADATA.peripherals {
-        if p.name.starts_with("TIM") {
-            let pname = format_ident!("{}", p.name);
-            let afio = if let Some(afio) = &p.afio {
-                let register = format_ident!("{}", afio.register.to_lowercase());
-                let setter = format_ident!("set_{}", afio.field.to_lowercase());
-
-                let swj_cfg = if afio.register == "MAPR" {
-                    quote!(w.set_swj_cfg(crate::pac::afio::vals::SwjCfg::NO_OP);)
-                } else {
-                    quote!()
-                };
-                let bool_eval = if is_bool_field("AFIO", &afio.register, &afio.field) {
-                    quote!(> 0)
-                } else {
-                    quote!()
-                };
-
-                let values = afio.values.iter().map(|v| {
-                    let mapr_value = v.value;
-                    let pin = v.pins.iter().map(|p| {
-                        let port_num = p.chars().nth(1).unwrap() as u8 - b'A';
-                        let pin_num = p[2..].parse::<u8>().unwrap();
-                        port_num * 16 + pin_num
-                    });
-                    quote!(#mapr_value, [#(#pin),*])
-                });
-
-                quote! {
-                    , |v| crate::pac::AFIO.#register().modify(|w| { #swj_cfg w.#setter(v #bool_eval); }), #({#values}),*
-                }
-            } else {
-                quote!()
-            };
-
-            g.extend(quote!(timer_afio_impl!(#pname #afio);));
-        }
-    }
-
-    // ========
     // Generate gpio_block() function
 
     let gpio_base = METADATA.peripherals.iter().find(|p| p.name == "GPIOA").unwrap().address as usize;