Get rid of lifetime-riddled Sleep stuff

nickray · nickray · commit ebcbbeff0054 · 2019-11-09T02:12:51.000+01:00
diff --git a/.gitignore b/.gitignore
@@ -10,4 +10,6 @@ core
 /jlink-fw-sw
 .idea/
 **/venv
-
+**/sdk-drivers
+**/sdk-examples
+notes.txt
diff --git a/Makefile b/Makefile
@@ -32,18 +32,6 @@ fetch-docs:
 	curl -s https://www.segger.com/downloads/jlink/UM08036 \
 		-o ref/gdbextensions-jlink.pdf
 
-#
-# Maintenance
-#
-
-VERSION := $(shell grep version Cargo.toml|head -1|cut -d' ' -f 3|tr -d '"')
-version:
-	echo $(VERSION)
-
-tag:
-	git tag -a $(VERSION) -m"v$(VERSION)"
-	git push origin $(VERSION)
-
 #
 # CI
 #
diff --git a/VERSION b/VERSION
diff --git a/examples/led_sleep.rs.deactivated b/examples/led_sleep.rs.deactivated
@@ -12,6 +12,8 @@ use lpc55s6x_hal as hal;
 #[entry]
 fn main() -> ! {
     let hal = hal::new();
+    let anactrl = hal.anactrl;
+    let pmc = hal.pmc;
     let mut syscon = hal.syscon;
     // dbg!(syscon.get_num_wait_states());
     let mut gpio = hal.gpio.enabled(&mut syscon);
@@ -39,18 +41,17 @@ fn main() -> ! {
         .into_gpio_pin(&mut iocon, &mut gpio)
         .into_output(hal::drivers::pins::Level::High); // start turned off
 
-    // let iocon = iocon.disabled(&mut syscon);
-    // iocon.release();
+    let clocks = hal::ClockRequirements::default()
+        .configure(&mut anactrl, &mut pmc, &mut syscon)
+        .unwrap();
 
-    let clock = hal::peripherals::syscon::Fro1MhzUtickClock::take()
-        .unwrap()
-        .enable(&mut syscon);
+    let token = clocks.support_utick_token().unwrap();
 
-    let mut utick = hal.utick.enabled(&mut syscon, &clock);
+    let mut utick = hal.utick.enabled(&mut syscon, &token);
 
     let delay = hal::time::Ticks {
         value: 500_000,
-        clock: &clock,
+        // clock: &clock,
     }; // 500 ms = 0.5 s
 
     let mut sleep = hal::time::Busy::wrap(&mut utick);
diff --git a/examples/led_utick.rs b/examples/led_utick.rs
@@ -4,35 +4,47 @@
 // extern crate panic_semihosting;  // 4004 bytes
 extern crate panic_halt; // 672 bytes
 
-// use cortex_m::asm;
 use cortex_m_rt::entry;
-// use nb::block;
 
-use hal::{drivers::pins::Level, prelude::*};
 use lpc55s6x_hal as hal;
+use hal::{
+    drivers::pins::Level,
+    prelude::*,
+};
 
-// macro_rules! kitt {
-//     ($( $led:ident ),+ ) => ({
-//         $led.set_low().unwrap();
-//         utick.start(1_000_000u32);
-//         utick.blocking_wait();
-//         $led.set_high().unwrap();
-//     }, *);
-// }
+macro_rules! kitt {
+    ($utick:ident, $($led:ident),+ ) => ($(
+
+        // low = on
+        $led.set_low().unwrap();
+
+        $utick.start(1_000_000u32);
+        $utick.blocking_wait();
+
+        // high = off
+        $led.set_high().unwrap();
+
+    )*);
+}
 
 #[entry]
 fn main() -> ! {
     let hal = hal::new();
+
+    let mut anactrl = hal.anactrl;
+    let mut pmc = hal.pmc;
     let mut syscon = hal.syscon;
+
+    let clocks = hal::ClockRequirements::default()
+        .configure(&mut anactrl, &mut pmc, &mut syscon)
+        .unwrap();
+
+    let token = clocks.support_utick_token().unwrap();
+    let mut utick = hal.utick.enabled(&mut syscon, &token);
+
     let mut gpio = hal.gpio.enabled(&mut syscon);
     let mut iocon = hal.iocon.enabled(&mut syscon);
     let pins = hal::Pins::take().unwrap();
-    let fro1mhz = hal::peripherals::syscon::Fro1MhzUtickClock::take()
-        .unwrap()
-        .enable(&mut syscon);
-    let mut utick = hal.utick.enabled(&mut syscon, &fro1mhz);
-    // let (utick, fro1mhz) = utick.disabled(&mut syscon);
-    // let mut utick = utick.enabled(&mut syscon, fro1mhz);
 
     // R = pio1_6
     // G = pio1_7
@@ -54,21 +66,6 @@ fn main() -> ! {
         .into_output(Level::High);
 
     loop {
-        // kitt!(red, green, blue);
-        red.set_low().unwrap();
-        utick.start(1_000_000u32);
-        // block!(utick.wait()).unwrap();
-        utick.blocking_wait();
-        red.set_high().unwrap();
-
-        green.set_low().unwrap();
-        utick.start(1_000_000u32);
-        utick.blocking_wait();
-        green.set_high().unwrap();
-
-        blue.set_low().unwrap();
-        utick.start(1_000_000u32);
-        utick.blocking_wait();
-        blue.set_high().unwrap();
+        kitt!(utick, red, green, blue);
     }
 }
diff --git a/src/drivers/clocks.rs b/src/drivers/clocks.rs
@@ -13,6 +13,7 @@ use crate::typestates::{
     // clock_state,
     ClocksSupportFlexcommToken,
     ClocksSupportUsbfsToken,
+    ClocksSupportUtickToken,
 };
 use crate::{
     peripherals::{
@@ -63,6 +64,10 @@ impl Clocks {
             None
         }
     }
+
+    pub fn support_utick_token(&self) -> Option<ClocksSupportUtickToken> {
+        Some(ClocksSupportUtickToken{__: ()})
+    }
 }
 
 /// Output of Pll is: M/(2NP) times input
@@ -184,9 +189,14 @@ impl ClockRequirements {
         // unsafe { pmc.raw.pdruncfgclr0.write(|w| w.bits(1u32 << 5)) };
         // but it's hidden in UM, so let's assume this is always cleared
 
-        // turn on both 12mhz and 96mhz clocks
+        // turn on 1mhz, 12mhz and 96mhz clocks
         anactrl.raw.fro192m_ctrl.modify(|_, w| w.ena_96mhzclk().enable());
         anactrl.raw.fro192m_ctrl.modify(|_, w| w.ena_12mhzclk().enable());
+        // TODO: not clear what the difference of these two is; eg. are both needed?
+        syscon.raw.clock_ctrl.modify(|_, w| w
+            .fro1mhz_clk_ena().enable()
+            .fro1mhz_utick_ena().enable()
+        );
 
         let (main_clock, sys_divider) = match freq {
             freq if freq <= 12.mhz() && 12 % freq.0 == 0 => {
diff --git a/src/peripherals/syscon.rs b/src/peripherals/syscon.rs
@@ -19,13 +19,13 @@
 // use cortex_m_semihosting::dbg;
 
 // use crate::raw;
-use crate::{
-    time::{
-        self,
-        clock,
-    },
-    typestates::init_state,
-};
+// use crate::{
+//     time::{
+//         self,
+//         clock,
+//     },
+//     typestates::init_state,
+// };
 
 crate::wrap_always_on_peripheral!(Syscon, SYSCON);
 
@@ -309,65 +309,3 @@ impl_reset_control!(raw::UTICK0, utick_rst, presetctrl1);
 
 impl_reset_control!(raw::USBFSH, usb0_hostm_rst, usb0_hosts_rst, presetctrl2);
 
-static mut FRO1MHZUTICKCLOCK_TAKEN: bool = false;
-
-pub struct Fro1MhzUtickClock<State = init_state::Disabled> {
-    _state: State,
-}
-
-impl Fro1MhzUtickClock<init_state::Disabled> {
-    pub fn take() -> Option<Self> {
-        if unsafe { FRO1MHZUTICKCLOCK_TAKEN } {
-            None
-        } else {
-            Some(unsafe {
-                FRO1MHZUTICKCLOCK_TAKEN = true;
-                Fro1MhzUtickClock::steal()
-            })
-        }
-    }
-
-    pub fn release(self) {
-        unsafe { FRO1MHZUTICKCLOCK_TAKEN = false };
-    }
-
-    pub unsafe fn steal() -> Self {
-        Fro1MhzUtickClock {
-            _state: init_state::Disabled,
-        }
-    }
-
-    /// Enable the FRO1MHZ UTICK clock
-    pub fn enable(self, syscon: &mut Syscon) -> Fro1MhzUtickClock<init_state::Enabled> {
-        syscon
-            .raw
-            .clock_ctrl
-            .modify(|_, w| w.fro1mhz_utick_ena().enable());
-
-        Fro1MhzUtickClock {
-            _state: init_state::Enabled(()),
-        }
-    }
-}
-
-impl Fro1MhzUtickClock<init_state::Enabled> {
-    /// Disable the FRO1MHZ UTICK clock
-    pub fn disable(self, syscon: &mut Syscon) -> Fro1MhzUtickClock<init_state::Disabled> {
-        syscon
-            .raw
-            .clock_ctrl
-            .modify(|_, w| w.fro1mhz_utick_ena().disable());
-
-        Fro1MhzUtickClock {
-            _state: init_state::Disabled,
-        }
-    }
-}
-
-impl<State> time::Frequency for Fro1MhzUtickClock<State> {
-    fn hz(&self) -> u32 {
-        1_000_000
-    }
-}
-
-impl clock::Enabled for Fro1MhzUtickClock<init_state::Enabled> {}
diff --git a/src/peripherals/utick.rs b/src/peripherals/utick.rs
@@ -7,63 +7,44 @@
 //!
 //! # Examples: led.rs, led_utick.rs
 
+// TODO: move this to drivers section,
+// possibly merge with ctimers when they're implemented
+
 use embedded_hal::timer;
 use nb;
 use void::Void;
 
 use crate::{
     raw,
     peripherals::{
-        syscon::{
-            self,
-            Fro1MhzUtickClock,
-        },
+        syscon,
     },
     typestates::{
         init_state,
+        ClocksSupportUtickToken,
     },
 };
 
 crate::wrap_stateful_peripheral!(Utick, UTICK0);
 
-pub type EnabledUtick<'fro1mhz> =
-    Utick<init_state::Enabled<&'fro1mhz Fro1MhzUtickClock<init_state::Enabled>>>;
+pub type EnabledUtick = Utick<init_state::Enabled>;
 
 impl<State> Utick<State> {
-    /// Enable the UTICK
-    ///
-    /// Consume a UTICK in `Disabled` state, return an instance in `Enabled` state.
-    pub fn enabled<'fro1mhz>(
+    pub fn enabled(
         mut self,
         syscon: &mut syscon::Syscon,
-        fro1mhz: &'fro1mhz Fro1MhzUtickClock<init_state::Enabled>,
-    ) -> EnabledUtick<'fro1mhz> {
+        _clocktree_token: &ClocksSupportUtickToken,
+    ) -> EnabledUtick {
         syscon.enable_clock(&mut self.raw);
         syscon.reset(&mut self.raw);
 
-        // Below is no longer needed, since we require passing in an enabled FRO1MHZ.
-        // Maybe these references will have to go again though due to RTFM...
-        //
-        // NB: UM says bit 4 (FRO_HF_FREQM_ENA), which is incorrect
-        // Empirically, it is enough to enable `fro1mhz_utick_ena`,
-        // even if `fro1mhz_clk_ena` is explicitly disabled.
-        // unsafe { &*crate::raw::SYSCON::ptr() }
-        //     .clock_ctrl
-        //     .modify(|_, w| w.fro1mhz_utick_ena().enable());
-
         Utick {
             raw: self.raw,
-            _state: init_state::Enabled(fro1mhz),
+            _state: init_state::Enabled(()),
         }
     }
 
-    /// Disable the UTICK
-    ///
-    /// Consume a UTICK in `Enabled` state, return an instance in `Disabled` state.
     pub fn disabled(mut self, syscon: &mut syscon::Syscon) -> Utick<init_state::Disabled> {
-        // unsafe { &*crate::raw::SYSCON::ptr() }
-        //     .clock_ctrl
-        //     .modify(|_, w| w.fro1mhz_utick_ena().disable());
         syscon.disable_clock(&mut self.raw);
 
         Utick {
@@ -73,7 +54,9 @@ impl<State> Utick<State> {
     }
 }
 
-impl timer::Cancel for EnabledUtick<'_> {
+// TODO: This does not feel like it belongs here.
+
+impl timer::Cancel for EnabledUtick {
     type Error = Void;
 
     fn cancel(&mut self) -> Result<(), Self::Error> {
@@ -84,7 +67,7 @@ impl timer::Cancel for EnabledUtick<'_> {
 }
 
 // TODO: also implement Periodic for UTICK
-impl timer::CountDown for EnabledUtick<'_> {
+impl timer::CountDown for EnabledUtick {
     type Time = u32;
 
     fn start<T>(&mut self, timeout: T)
@@ -117,17 +100,9 @@ impl timer::CountDown for EnabledUtick<'_> {
     }
 }
 
-impl EnabledUtick<'_> {
+// TODO: Either get rid of `nb` or get rid of this
+impl EnabledUtick {
     pub fn blocking_wait(&mut self) {
         while self.raw.stat.read().active().bit_is_set() {}
     }
 }
-
-/// A clock that is usable by the micro-tick timer (UTICK)
-///
-/// This trait is implemented for all clocks that are supported by the UTICK,
-/// which is just FRO1MHZ.
-/// The user shouldn't need to implement this trait themselves.
-pub trait Clock {}
-
-impl Clock for Fro1MhzUtickClock<init_state::Enabled> {}
diff --git a/src/prelude.rs b/src/prelude.rs
@@ -5,7 +5,7 @@ pub use crate::traits::wg::prelude::*;
 pub use crate::traits::wg::digital::v2::OutputPin as _embedded_hal_digital_v2_OutputPin;
 pub use crate::traits::wg::digital::v2::StatefulOutputPin as _embedded_hal_digital_v2_StatefulOutputPin;
 
-pub use crate::time::Sleep as _lpc55s6x_hal_time_Sleep;
+// pub use crate::time::Sleep as _lpc55s6x_hal_time_Sleep;
 pub use crate::time::U32Ext as _lpc55s6x_hal_time_U32Ext;
 
 // Good idea? Bad idea?
diff --git a/src/time.rs b/src/time.rs
diff --git a/src/typestates.rs b/src/typestates.rs
diff --git a/unused-link.x b/unused-link.x
