Merge pull request #145 from lulf/generic-config

Pass config directly to chip specific configure function

embassy-macros/src/chip/nrf.rs

@@ -1,60 +1,15 @@
 use crate::path::ModulePrefix;
-use darling::FromMeta;
 use proc_macro2::TokenStream;
-use quote::{format_ident, quote};
+use quote::quote;
-use syn::spanned::Spanned;
 
-#[derive(Debug, FromMeta)]
+pub fn generate(embassy_prefix: &ModulePrefix, config: syn::Expr) -> TokenStream {
-pub enum HfclkSource {
+    let embassy_path = embassy_prefix.append("embassy").path();
-    Internal,
+    let embassy_nrf_path = embassy_prefix.append("embassy_nrf").path();
-    ExternalXtal,
-}
-
-impl Default for HfclkSource {
-    fn default() -> Self {
-        Self::Internal
-    }
-}
-
-#[derive(Debug, FromMeta)]
-pub enum LfclkSource {
-    InternalRC,
-    Synthesized,
-    ExternalXtal,
-    ExternalLowSwing,
-    ExternalFullSwing,
-}
-
-impl Default for LfclkSource {
-    fn default() -> Self {
-        Self::InternalRC
-    }
-}
-
-#[derive(Debug, FromMeta, Default)]
-pub struct Args {
-    #[darling(default)]
-    pub embassy_prefix: ModulePrefix,
-    #[darling(default)]
-    pub hfclk_source: HfclkSource,
-    #[darling(default)]
-    pub lfclk_source: LfclkSource,
-}
-
-pub fn generate(args: &Args) -> TokenStream {
-    let hfclk_source = format_ident!("{}", format!("{:?}", args.hfclk_source));
-    let lfclk_source = format_ident!("{}", format!("{:?}", args.lfclk_source));
-
-    let embassy_path = args.embassy_prefix.append("embassy").path();
-    let embassy_nrf_path = args.embassy_prefix.append("embassy_nrf").path();
 
     quote!(
         use #embassy_nrf_path::{interrupt, peripherals, rtc};
 
-        let mut config = #embassy_nrf_path::system::Config::default();
+        unsafe { #embassy_nrf_path::system::configure(#config) };
-        config.hfclk_source = #embassy_nrf_path::system::HfclkSource::#hfclk_source;
-        config.lfclk_source = #embassy_nrf_path::system::LfclkSource::#lfclk_source;
-        unsafe { #embassy_nrf_path::system::configure(config) };
 
         let mut rtc = rtc::RTC::new(unsafe { <peripherals::RTC1 as #embassy_path::util::Steal>::steal() }, interrupt::take!(RTC1));
         let rtc = unsafe { make_static(&mut rtc) };

embassy-macros/src/chip/rp.rs

@@ -1,20 +1,12 @@
 use crate::path::ModulePrefix;
-use darling::FromMeta;
 use proc_macro2::TokenStream;
 use quote::quote;
 
-#[derive(Debug, FromMeta, Default)]
+pub fn generate(embassy_prefix: &ModulePrefix, config: syn::Expr) -> TokenStream {
-pub struct Args {
+    let embassy_rp_path = embassy_prefix.append("embassy_rp").path();
-    #[darling(default)]
-    pub embassy_prefix: ModulePrefix,
-}
-
-pub fn generate(args: &Args) -> TokenStream {
-    let embassy_rp_path = args.embassy_prefix.append("embassy_rp").path();
     quote!(
         use #embassy_rp_path::{interrupt, peripherals};
 
-        let mut config = #embassy_rp_path::system::Config::default();
+        unsafe { #embassy_rp_path::system::configure(#config) };
-        unsafe { #embassy_rp_path::system::configure(config) };
     )
 }

embassy-macros/src/chip/stm32.rs

@@ -1,57 +1,19 @@
 use crate::path::ModulePrefix;
-use darling::FromMeta;
 use proc_macro2::TokenStream;
-use quote::{format_ident, quote};
+use quote::quote;
-use syn::spanned::Spanned;
 
-#[derive(Debug, FromMeta, Default)]
+pub fn generate(embassy_prefix: &ModulePrefix, config: syn::Expr) -> TokenStream {
-pub struct Args {
+    let embassy_path = embassy_prefix.append("embassy").path();
-    #[darling(default)]
+    let embassy_stm32_path = embassy_prefix.append("embassy_stm32").path();
-    pub embassy_prefix: ModulePrefix,
-    #[darling(default)]
-    pub use_hse: Option<u32>,
-    #[darling(default)]
-    pub sysclk: Option<u32>,
-    #[darling(default)]
-    pub pclk1: Option<u32>,
-    #[darling(default)]
-    pub require_pll48clk: bool,
-}
-
-pub fn generate(args: &Args) -> TokenStream {
-    let embassy_path = args.embassy_prefix.append("embassy").path();
-    let embassy_stm32_path = args.embassy_prefix.append("embassy_stm32").path();
-
-    let mut clock_cfg_args = quote! {};
-    if args.use_hse.is_some() {
-        let mhz = args.use_hse.unwrap();
-        clock_cfg_args = quote! { #clock_cfg_args.use_hse(#mhz.mhz()) };
-    }
-
-    if args.sysclk.is_some() {
-        let mhz = args.sysclk.unwrap();
-        clock_cfg_args = quote! { #clock_cfg_args.sysclk(#mhz.mhz()) };
-    }
-
-    if args.pclk1.is_some() {
-        let mhz = args.pclk1.unwrap();
-        clock_cfg_args = quote! { #clock_cfg_args.pclk1(#mhz.mhz()) };
-    }
-
-    if args.require_pll48clk {
-        clock_cfg_args = quote! { #clock_cfg_args.require_pll48clk() };
-    }
 
     quote!(
         use #embassy_stm32_path::{rtc, interrupt, Peripherals, pac, hal::rcc::RccExt, hal::time::U32Ext};
 
-        let dp = pac::Peripherals::take().unwrap();
+        unsafe { #embassy_stm32_path::system::configure(#config) };
-        let rcc = dp.RCC.constrain();
-        let clocks = rcc.cfgr#clock_cfg_args.freeze();
 
-        unsafe { Peripherals::set_peripherals(clocks) };
+        let (dp, clocks) = Peripherals::take().unwrap();
 
-        let mut rtc = rtc::RTC::new(dp.TIM3, interrupt::take!(TIM3), clocks);
+        let mut rtc = rtc::RTC::new(dp.TIM2, interrupt::take!(TIM2), clocks);
         let rtc = unsafe { make_static(&mut rtc) };
         rtc.start();
         let mut alarm = rtc.alarm1();
@@ -60,5 +22,7 @@ pub fn generate(args: &Args) -> TokenStream {
 
         let alarm = unsafe { make_static(&mut alarm) };
         executor.set_alarm(alarm);
+
+        unsafe { Peripherals::set_peripherals(clocks) };
     )
 }

embassy-macros/src/lib.rs

@@ -212,13 +212,13 @@ mod chip;
 #[path = "chip/rp.rs"]
 mod chip;
 
-#[cfg(feature = "std")]
+#[derive(Debug, FromMeta)]
-mod chip {
+struct MainArgs {
-    #[derive(Debug, darling::FromMeta, Default)]
-    pub struct Args {
     #[darling(default)]
-        pub embassy_prefix: crate::path::ModulePrefix,
+    embassy_prefix: ModulePrefix,
-    }
+
+    #[darling(default)]
+    config: Option<syn::LitStr>,
 }
 
 #[cfg(any(feature = "nrf", feature = "stm32", feature = "rp"))]
@@ -227,7 +227,7 @@ pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
     let macro_args = syn::parse_macro_input!(args as syn::AttributeArgs);
     let task_fn = syn::parse_macro_input!(item as syn::ItemFn);
 
-    let macro_args = match chip::Args::from_list(&macro_args) {
+    let macro_args = match MainArgs::from_list(&macro_args) {
         Ok(v) => v,
         Err(e) => {
             return TokenStream::from(e.write_errors());
@@ -270,10 +270,21 @@ pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
         return TokenStream::new();
     }
 
-    let embassy_prefix_lit = macro_args.embassy_prefix.literal();
+    let embassy_prefix = macro_args.embassy_prefix;
-    let embassy_path = macro_args.embassy_prefix.append("embassy").path();
+    let embassy_prefix_lit = embassy_prefix.literal();
-    let task_fn_body = task_fn.block.clone();
+    let embassy_path = embassy_prefix.append("embassy").path();
-    let chip_setup = chip::generate(&macro_args);
+    let task_fn_body = task_fn.block;
+
+    let config = macro_args
+        .config
+        .map(|s| s.parse::<syn::Expr>().unwrap())
+        .unwrap_or_else(|| {
+            syn::Expr::Verbatim(quote! {
+                Default::default()
+            })
+        });
+
+    let chip_setup = chip::generate(&embassy_prefix, config);
 
     let result = quote! {
         #[#embassy_path::task(embassy_prefix = #embassy_prefix_lit)]
@@ -288,6 +299,7 @@ pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
             }
 
             let mut executor = #embassy_path::executor::Executor::new();
+
             let executor = unsafe { make_static(&mut executor) };
 
             #chip_setup
@@ -307,7 +319,7 @@ pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
     let macro_args = syn::parse_macro_input!(args as syn::AttributeArgs);
     let task_fn = syn::parse_macro_input!(item as syn::ItemFn);
 
-    let macro_args = match chip::Args::from_list(&macro_args) {
+    let macro_args = match MainArgs::from_list(&macro_args) {
         Ok(v) => v,
         Err(e) => {
             return TokenStream::from(e.write_errors());

embassy-stm32-examples/src/bin/rtc_async.rs

@@ -10,6 +10,7 @@ use example_common::*;
 
 use defmt::panic;
 use embassy;
+
 use embassy::executor::Spawner;
 use embassy::time::{Duration, Timer};
 use embassy_stm32;
@@ -31,7 +32,7 @@ async fn run2() {
     }
 }
 
-#[embassy::main(use_hse = 16)]
+#[embassy::main(config = "embassy_stm32::system::Config::new().use_hse(16)")]
 async fn main(spawner: Spawner) {
     let (dp, clocks) = embassy_stm32::Peripherals::take().unwrap();
 

embassy-stm32-examples/src/bin/serial.rs

@@ -22,7 +22,7 @@ use embassy_stm32::pac as stm32;
 use embassy_stm32::serial;
 use futures::pin_mut;
 
-#[embassy::main(use_hse = 16, sysclk = 48, pclk1 = 24)]
+#[embassy::main(config = "embassy_stm32::system::Config::new().use_hse(16).sysclk(48).pclk1(24)")]
 async fn main(spawner: Spawner) {
     let (dp, clocks) = embassy_stm32::Peripherals::take().unwrap();
     let cp = cortex_m::peripheral::Peripherals::take().unwrap();

embassy-stm32-examples/src/bin/usb_serial.rs

@@ -92,7 +92,9 @@ async fn run1(bus: &'static mut UsbBusAllocator<UsbBus<USB>>) {
 
 static USB_BUS: Forever<UsbBusAllocator<UsbBus<USB>>> = Forever::new();
 
-#[embassy::main(use_hse = 25, sysclk = 48, require_pll48clk)]
+#[embassy::main(
+    config = "embassy_stm32::system::Config::new().use_hse(25).sysclk(48).require_pll48clk()"
+)]
 async fn main(spawner: Spawner) -> ! {
     static mut EP_MEMORY: [u32; 1024] = [0; 1024];
 

embassy-stm32/Cargo.toml

@@ -38,6 +38,7 @@ embassy = { version = "0.1.0", path = "../embassy" }
 embassy-macros = { version = "0.1.0", path = "../embassy-macros", features = ["stm32"]}
 embassy-extras = {version = "0.1.0", path = "../embassy-extras" }
 
+atomic-polyfill = "0.1.1"
 defmt = { version = "0.2.0", optional = true }
 log = { version = "0.4.11", optional = true }
 cortex-m-rt = "0.6.13"

embassy-stm32/src/f4/mod.rs

@@ -1,2 +1,4 @@
+pub mod rtc;
 pub mod serial;
 pub mod spi;
+pub mod system;

embassy-stm32/src/f4/system.rs

@@ -0,0 +1,61 @@
+use crate::{hal::prelude::*, pac, Peripherals};
+
+#[derive(Default)]
+pub struct Config {
+    pub use_hse: Option<u32>,
+    pub sysclk: Option<u32>,
+    pub pclk1: Option<u32>,
+    pub require_pll48clk: bool,
+}
+
+impl Config {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    pub fn use_hse(mut self, freq: u32) -> Self {
+        self.use_hse = Some(freq);
+        self
+    }
+
+    pub fn sysclk(mut self, freq: u32) -> Self {
+        self.sysclk = Some(freq);
+        self
+    }
+
+    pub fn pclk1(mut self, freq: u32) -> Self {
+        self.pclk1 = Some(freq);
+        self
+    }
+
+    pub fn require_pll48clk(mut self) -> Self {
+        self.require_pll48clk = true;
+        self
+    }
+}
+
+/// safety: must only call once.
+pub unsafe fn configure(config: Config) {
+    let dp = pac::Peripherals::take().unwrap();
+    let mut cfgr = dp.RCC.constrain().cfgr;
+
+    if let Some(hz) = config.use_hse {
+        cfgr = cfgr.use_hse(hz.mhz());
+    };
+
+    if let Some(hz) = config.sysclk {
+        cfgr = cfgr.sysclk(hz.mhz());
+    };
+
+    if let Some(hz) = config.pclk1 {
+        cfgr = cfgr.pclk1(hz.mhz());
+    };
+
+    if config.require_pll48clk {
+        cfgr = cfgr.require_pll48clk();
+    };
+
+    let clocks = cfgr.freeze();
+
+    unsafe { Peripherals::set_peripherals(clocks) };
+}

embassy-stm32/src/l0/mod.rs

@@ -0,0 +1,2 @@
+pub mod rtc;
+pub mod system;

embassy-stm32/src/l0/rtc.rs

@@ -0,0 +1,371 @@
+use crate::hal::rcc::Clocks;
+use atomic_polyfill::{compiler_fence, AtomicU32, Ordering};
+use core::cell::Cell;
+use core::convert::TryInto;
+
+use embassy::interrupt::InterruptExt;
+use embassy::time::{Clock, TICKS_PER_SECOND};
+
+use crate::interrupt;
+use crate::interrupt::{CriticalSection, Interrupt, Mutex};
+
+// RTC timekeeping works with something we call "periods", which are time intervals
+// of 2^15 ticks. The RTC counter value is 16 bits, so one "overflow cycle" is 2 periods.
+//
+// A `period` count is maintained in parallel to the RTC hardware `counter`, like this:
+// - `period` and `counter` start at 0
+// - `period` is incremented on overflow (at counter value 0)
+// - `period` is incremented "midway" between overflows (at counter value 0x8000)
+//
+// Therefore, when `period` is even, counter is in 0..0x7FFF. When odd, counter is in 0x8000..0xFFFF
+// This allows for now() to return the correct value even if it races an overflow.
+//
+// To get `now()`, `period` is read first, then `counter` is read. If the counter value matches
+// the expected range for the `period` parity, we're done. If it doesn't, this means that
+// a new period start has raced us between reading `period` and `counter`, so we assume the `counter` value
+// corresponds to the next period.
+//
+// `period` is a 32bit integer, so It overflows on 2^32 * 2^15 / 32768 seconds of uptime, which is 136 years.
+fn calc_now(period: u32, counter: u16) -> u64 {
+    ((period as u64) << 15) + ((counter as u32 ^ ((period & 1) << 15)) as u64)
+}
+
+struct AlarmState {
+    timestamp: Cell<u64>,
+    callback: Cell<Option<(fn(*mut ()), *mut ())>>,
+}
+
+impl AlarmState {
+    fn new() -> Self {
+        Self {
+            timestamp: Cell::new(u64::MAX),
+            callback: Cell::new(None),
+        }
+    }
+}
+
+// TODO: This is sometimes wasteful, try to find a better way
+const ALARM_COUNT: usize = 3;
+
+/// RTC timer that can be used by the executor and to set alarms.
+///
+/// It can work with Timers 2 and 3.
+
+/// This timer works internally with a unit of 2^15 ticks, which means that if a call to
+/// [`embassy::time::Clock::now`] is blocked for that amount of ticks the returned value will be
+/// wrong (an old value). The current default tick rate is 32768 ticks per second.
+pub struct RTC<T: Instance> {
+    rtc: T,
+    irq: T::Interrupt,
+
+    /// Number of 2^23 periods elapsed since boot.
+    period: AtomicU32,
+
+    /// Timestamp at which to fire alarm. u64::MAX if no alarm is scheduled.
+    alarms: Mutex<[AlarmState; ALARM_COUNT]>,
+
+    clocks: Clocks,
+}
+
+impl<T: Instance> RTC<T> {
+    pub fn new(rtc: T, irq: T::Interrupt, clocks: Clocks) -> Self {
+        Self {
+            rtc,
+            irq,
+            period: AtomicU32::new(0),
+            alarms: Mutex::new([AlarmState::new(), AlarmState::new(), AlarmState::new()]),
+            clocks,
+        }
+    }
+
+    pub fn start(&'static self) {
+        self.rtc.enable_clock();
+        self.rtc.stop_and_reset();
+
+        let freq = T::pclk(&self.clocks);
+        let psc = freq / TICKS_PER_SECOND as u32 - 1;
+        let psc: u16 = psc.try_into().unwrap();
+
+        self.rtc.set_psc_arr(psc, u16::MAX);
+        // Mid-way point
+        self.rtc.set_compare(0, 0x8000);
+        self.rtc.set_compare_interrupt(0, true);
+
+        self.irq.set_handler(|ptr| unsafe {
+            let this = &*(ptr as *const () as *const Self);
+            this.on_interrupt();
+        });
+        self.irq.set_handler_context(self as *const _ as *mut _);
+        self.irq.unpend();
+        self.irq.enable();
+
+        self.rtc.start();
+    }
+
+    fn on_interrupt(&self) {
+        if self.rtc.overflow_interrupt_status() {
+            self.rtc.overflow_clear_flag();
+            self.next_period();
+        }
+
+        // Half overflow
+        if self.rtc.compare_interrupt_status(0) {
+            self.rtc.compare_clear_flag(0);
+            self.next_period();
+        }
+
+        for n in 1..=ALARM_COUNT {
+            if self.rtc.compare_interrupt_status(n) {
+                self.rtc.compare_clear_flag(n);
+                interrupt::free(|cs| self.trigger_alarm(n, cs));
+            }
+        }
+    }
+
+    fn next_period(&self) {
+        interrupt::free(|cs| {
+            let period = self.period.fetch_add(1, Ordering::Relaxed) + 1;
+            let t = (period as u64) << 15;
+
+            for n in 1..=ALARM_COUNT {
+                let alarm = &self.alarms.borrow(cs)[n - 1];
+                let at = alarm.timestamp.get();
+
+                let diff = at - t;
+                if diff < 0xc000 {
+                    self.rtc.set_compare(n, at as u16);
+                    self.rtc.set_compare_interrupt(n, true);
+                }
+            }
+        })
+    }
+
+    fn trigger_alarm(&self, n: usize, cs: &CriticalSection) {
+        self.rtc.set_compare_interrupt(n, false);
+
+        let alarm = &self.alarms.borrow(cs)[n - 1];
+        alarm.timestamp.set(u64::MAX);
+
+        // Call after clearing alarm, so the callback can set another alarm.
+        if let Some((f, ctx)) = alarm.callback.get() {
+            f(ctx);
+        }
+    }
+
+    fn set_alarm_callback(&self, n: usize, callback: fn(*mut ()), ctx: *mut ()) {
+        interrupt::free(|cs| {
+            let alarm = &self.alarms.borrow(cs)[n - 1];
+            alarm.callback.set(Some((callback, ctx)));
+        })
+    }
+
+    fn set_alarm(&self, n: usize, timestamp: u64) {
+        interrupt::free(|cs| {
+            let alarm = &self.alarms.borrow(cs)[n - 1];
+            alarm.timestamp.set(timestamp);
+
+            let t = self.now();
+            if timestamp <= t {
+                self.trigger_alarm(n, cs);
+                return;
+            }
+
+            let diff = timestamp - t;
+            if diff < 0xc000 {
+                let safe_timestamp = timestamp.max(t + 3);
+                self.rtc.set_compare(n, safe_timestamp as u16);
+                self.rtc.set_compare_interrupt(n, true);
+            } else {
+                self.rtc.set_compare_interrupt(n, false);
+            }
+        });
+    }
+
+    pub fn alarm1(&'static self) -> Alarm<T> {
+        Alarm { n: 1, rtc: self }
+    }
+    pub fn alarm2(&'static self) -> Option<Alarm<T>> {
+        if T::REAL_ALARM_COUNT >= 2 {
+            Some(Alarm { n: 2, rtc: self })
+        } else {
+            None
+        }
+    }
+    pub fn alarm3(&'static self) -> Option<Alarm<T>> {
+        if T::REAL_ALARM_COUNT >= 3 {
+            Some(Alarm { n: 3, rtc: self })
+        } else {
+            None
+        }
+    }
+}
+
+impl<T: Instance> embassy::time::Clock for RTC<T> {
+    fn now(&self) -> u64 {
+        let period = self.period.load(Ordering::Relaxed);
+        compiler_fence(Ordering::Acquire);
+        let counter = self.rtc.counter();
+        calc_now(period, counter)
+    }
+}
+
+pub struct Alarm<T: Instance> {
+    n: usize,
+    rtc: &'static RTC<T>,
+}
+
+impl<T: Instance> embassy::time::Alarm for Alarm<T> {
+    fn set_callback(&self, callback: fn(*mut ()), ctx: *mut ()) {
+        self.rtc.set_alarm_callback(self.n, callback, ctx);
+    }
+
+    fn set(&self, timestamp: u64) {
+        self.rtc.set_alarm(self.n, timestamp);
+    }
+
+    fn clear(&self) {
+        self.rtc.set_alarm(self.n, u64::MAX);
+    }
+}
+
+mod sealed {
+    pub trait Sealed {}
+}
+
+pub trait Instance: sealed::Sealed + Sized + 'static {
+    type Interrupt: Interrupt;
+    const REAL_ALARM_COUNT: usize;
+
+    fn enable_clock(&self);
+    fn set_compare(&self, n: usize, value: u16);
+    fn set_compare_interrupt(&self, n: usize, enable: bool);
+    fn compare_interrupt_status(&self, n: usize) -> bool;
+    fn compare_clear_flag(&self, n: usize);
+    fn overflow_interrupt_status(&self) -> bool;
+    fn overflow_clear_flag(&self);
+    // This method should ensure that the values are really updated before returning
+    fn set_psc_arr(&self, psc: u16, arr: u16);
+    fn stop_and_reset(&self);
+    fn start(&self);
+    fn counter(&self) -> u16;
+    fn pclk(clocks: &Clocks) -> u32;
+}
+
+#[allow(unused_macros)]
+macro_rules! impl_timer {
+    ($module:ident: ($TYPE:ident, $INT:ident,  $timXen:ident, $timXrst:ident, $apbenr:ident, $apbrstr:ident, $pclk: ident)) => {
+        mod $module {
+            use super::*;
+            use crate::hal::pac::{$TYPE, RCC};
+
+            impl sealed::Sealed for $TYPE {}
+
+            impl Instance for $TYPE {
+                type Interrupt = interrupt::$INT;
+                const REAL_ALARM_COUNT: usize = 3;
+
+                fn enable_clock(&self) {
+                    // NOTE(unsafe) It will only be used for atomic operations
+                    unsafe {
+                        let rcc = &*RCC::ptr();
+
+                        rcc.$apbenr.modify(|_, w| w.$timXen().set_bit());
+                        rcc.$apbrstr.modify(|_, w| w.$timXrst().set_bit());
+                        rcc.$apbrstr.modify(|_, w| w.$timXrst().clear_bit());
+                    }
+                }
+
+                fn set_compare(&self, n: usize, value: u16) {
+                    // NOTE(unsafe) these registers accept all the range of u16 values
+                    match n {
+                        0 => self.ccr1.write(|w| unsafe { w.bits(value.into()) }),
+                        1 => self.ccr2.write(|w| unsafe { w.bits(value.into()) }),
+                        2 => self.ccr3.write(|w| unsafe { w.bits(value.into()) }),
+                        3 => self.ccr4.write(|w| unsafe { w.bits(value.into()) }),
+                        _ => {}
+                    }
+                }
+
+                fn set_compare_interrupt(&self, n: usize, enable: bool) {
+                    if n > 3 {
+                        return;
+                    }
+                    let bit = n as u8 + 1;
+                    unsafe {
+                        if enable {
+                            self.dier.modify(|r, w| w.bits(r.bits() | (1 << bit)));
+                        } else {
+                            self.dier.modify(|r, w| w.bits(r.bits() & !(1 << bit)));
+                        }
+                    }
+                }
+
+                fn compare_interrupt_status(&self, n: usize) -> bool {
+                    let status = self.sr.read();
+                    match n {
+                        0 => status.cc1if().bit_is_set(),
+                        1 => status.cc2if().bit_is_set(),
+                        2 => status.cc3if().bit_is_set(),
+                        3 => status.cc4if().bit_is_set(),
+                        _ => false,
+                    }
+                }
+
+                fn compare_clear_flag(&self, n: usize) {
+                    if n > 3 {
+                        return;
+                    }
+                    let bit = n as u8 + 1;
+                    unsafe {
+                        self.sr.modify(|r, w| w.bits(r.bits() & !(1 << bit)));
+                    }
+                }
+
+                fn overflow_interrupt_status(&self) -> bool {
+                    self.sr.read().uif().bit_is_set()
+                }
+
+                fn overflow_clear_flag(&self) {
+                    unsafe {
+                        self.sr.modify(|_, w| w.uif().clear_bit());
+                    }
+                }
+
+                fn set_psc_arr(&self, psc: u16, arr: u16) {
+                    // NOTE(unsafe) All u16 values are valid
+                    self.psc.write(|w| unsafe { w.bits(psc.into()) });
+                    self.arr.write(|w| unsafe { w.bits(arr.into()) });
+
+                    unsafe {
+                        // Set URS, generate update, clear URS
+                        self.cr1.modify(|_, w| w.urs().set_bit());
+                        self.egr.write(|w| w.ug().set_bit());
+                        self.cr1.modify(|_, w| w.urs().clear_bit());
+                    }
+                }
+
+                fn stop_and_reset(&self) {
+                    unsafe {
+                        self.cr1.modify(|_, w| w.cen().clear_bit());
+                    }
+                    self.cnt.reset();
+                }
+
+                fn start(&self) {
+                    self.cr1.modify(|_, w| w.cen().set_bit());
+                }
+
+                fn counter(&self) -> u16 {
+                    self.cnt.read().bits() as u16
+                }
+
+                fn pclk(clocks: &Clocks) -> u32 {
+                    clocks.$pclk().0
+                }
+            }
+        }
+    };
+}
+
+impl_timer!(tim2: (TIM2, TIM2, tim2en, tim2rst, apb1enr, apb1rstr, apb1_tim_clk));
+impl_timer!(tim3: (TIM3, TIM3, tim3en, tim3rst, apb1enr, apb1rstr, apb1_tim_clk));

embassy-stm32/src/l0/system.rs

@@ -0,0 +1,17 @@
+use crate::{hal, pac, Peripherals};
+
+pub use hal::{
+    prelude::*,
+    rcc::{Clocks, Config},
+};
+
+/// safety: must only call once.
+pub unsafe fn configure(config: Config) {
+    let dp = pac::Peripherals::take().unwrap();
+
+    let rcc = dp.RCC.freeze(config);
+
+    let clocks = rcc.clocks;
+
+    unsafe { Peripherals::set_peripherals(clocks) };
+}

embassy-stm32/src/lib.rs

@@ -49,6 +49,12 @@ pub use {stm32f4xx_hal as hal, stm32f4xx_hal::stm32 as pac};
 #[cfg(any(feature = "stm32l0x1", feature = "stm32l0x2", feature = "stm32l0x3",))]
 pub use {stm32l0xx_hal as hal, stm32l0xx_hal::pac};
 
+#[cfg(any(feature = "stm32l0x1", feature = "stm32l0x2", feature = "stm32l0x3",))]
+mod l0;
+
+#[cfg(any(feature = "stm32l0x1", feature = "stm32l0x2", feature = "stm32l0x3",))]
+pub use l0::{rtc, system};
+
 pub mod fmt;
 
 pub mod exti;
@@ -89,26 +95,7 @@ pub mod can;
     feature = "stm32f469",
     feature = "stm32f479",
 ))]
-pub mod rtc;
+pub use f4::{rtc, serial, spi, system};
-
-#[cfg(any(
-    feature = "stm32f401",
-    feature = "stm32f405",
-    feature = "stm32f407",
-    feature = "stm32f412",
-    feature = "stm32f413",
-    feature = "stm32f415",
-    feature = "stm32f417",
-    feature = "stm32f423",
-    feature = "stm32f427",
-    feature = "stm32f429",
-    feature = "stm32f437",
-    feature = "stm32f439",
-    feature = "stm32f446",
-    feature = "stm32f469",
-    feature = "stm32f479",
-))]
-pub use f4::{serial, spi};
 
 #[cfg(any(
     feature = "stm32f401",
@@ -452,3 +439,40 @@ embassy_extras::std_peripherals! {
     FPU_CPACR,
     SCB_ACTRL,
 }
+
+#[cfg(feature = "stm32l0x2")]
+embassy_extras::std_peripherals! {
+    SPI1,
+    SPI2,
+    USART1,
+    USART2,
+    USART4,
+    USART5,
+    I2C1,
+    I2C2,
+    I2C3,
+    RNG,
+    TIM2,
+    TIM3,
+    TIM6,
+    TIM7,
+    TIM21,
+    TIM22,
+    DAC,
+    RTC,
+    PWR,
+    CRC,
+    GPIOA,
+    GPIOB,
+    GPIOC,
+    GPIOD,
+    GPIOE,
+    GPIOH,
+    SYSCFG,
+    DMA1,
+    EXTI,
+    ADC,
+    IWDG,
+    WWDG,
+    DBG,
+}