1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192
//! Watchdog Timer (WDT) driver.
//!
//! This HAL implements a basic watchdog timer with 1..=8 handles.
//! Once the watchdog has been started, it cannot be stopped.
use crate::pac::WDT;
use crate::peripherals;
const MIN_TICKS: u32 = 15;
/// WDT configuration.
#[non_exhaustive]
pub struct Config {
/// Number of 32768 Hz ticks in each watchdog period.
///
/// Note: there is a minimum of 15 ticks (458 microseconds). If a lower
/// number is provided, 15 ticks will be used as the configured value.
pub timeout_ticks: u32,
/// Should the watchdog continue to count during sleep modes?
pub run_during_sleep: bool,
/// Should the watchdog continue to count when the CPU is halted for debug?
pub run_during_debug_halt: bool,
}
impl Config {
/// Create a config structure from the current configuration of the WDT
/// peripheral.
pub fn try_new(_wdt: &peripherals::WDT) -> Option<Self> {
let r = unsafe { &*WDT::ptr() };
#[cfg(not(feature = "_nrf9160"))]
let runstatus = r.runstatus.read().runstatus().bit();
#[cfg(feature = "_nrf9160")]
let runstatus = r.runstatus.read().runstatuswdt().bit();
if runstatus {
let config = r.config.read();
Some(Self {
timeout_ticks: r.crv.read().bits(),
run_during_sleep: config.sleep().bit(),
run_during_debug_halt: config.halt().bit(),
})
} else {
None
}
}
}
impl Default for Config {
fn default() -> Self {
Self {
timeout_ticks: 32768, // 1 second
run_during_debug_halt: true,
run_during_sleep: true,
}
}
}
/// Watchdog driver.
pub struct Watchdog {
_private: (),
}
impl Watchdog {
/// Try to create a new watchdog driver.
///
/// This function will return an error if the watchdog is already active
/// with a `config` different to the requested one, or a different number of
/// enabled handles.
///
/// `N` must be between 1 and 8, inclusive.
#[inline]
pub fn try_new<const N: usize>(
wdt: peripherals::WDT,
config: Config,
) -> Result<(Self, [WatchdogHandle; N]), peripherals::WDT> {
assert!(N >= 1 && N <= 8);
let r = unsafe { &*WDT::ptr() };
let crv = config.timeout_ticks.max(MIN_TICKS);
let rren = (1u32 << N) - 1;
#[cfg(not(feature = "_nrf9160"))]
let runstatus = r.runstatus.read().runstatus().bit();
#[cfg(feature = "_nrf9160")]
let runstatus = r.runstatus.read().runstatuswdt().bit();
if runstatus {
let curr_config = r.config.read();
if curr_config.halt().bit() != config.run_during_debug_halt
|| curr_config.sleep().bit() != config.run_during_sleep
|| r.crv.read().bits() != crv
|| r.rren.read().bits() != rren
{
return Err(wdt);
}
} else {
r.config.write(|w| {
w.sleep().bit(config.run_during_sleep);
w.halt().bit(config.run_during_debug_halt);
w
});
r.intenset.write(|w| w.timeout().set_bit());
r.crv.write(|w| unsafe { w.bits(crv) });
r.rren.write(|w| unsafe { w.bits(rren) });
r.tasks_start.write(|w| unsafe { w.bits(1) });
}
let this = Self { _private: () };
const DUMMY_HANDLE: WatchdogHandle = WatchdogHandle { index: 0 };
let mut handles = [DUMMY_HANDLE; N];
for i in 0..N {
handles[i] = WatchdogHandle { index: i as u8 };
handles[i].pet();
}
Ok((this, handles))
}
/// Enable the watchdog interrupt.
///
/// NOTE: Although the interrupt will occur, there is no way to prevent
/// the reset from occurring. From the time the event was fired, the
/// system will reset two LFCLK ticks later (61 microseconds) if the
/// interrupt has been enabled.
#[inline(always)]
pub fn enable_interrupt(&mut self) {
let r = unsafe { &*WDT::ptr() };
r.intenset.write(|w| w.timeout().set_bit());
}
/// Disable the watchdog interrupt.
///
/// NOTE: This has no effect on the reset caused by the Watchdog.
#[inline(always)]
pub fn disable_interrupt(&mut self) {
let r = unsafe { &*WDT::ptr() };
r.intenclr.write(|w| w.timeout().set_bit());
}
/// Is the watchdog still awaiting pets from any handle?
///
/// This reports whether sufficient pets have been received from all
/// handles to prevent a reset this time period.
#[inline(always)]
pub fn awaiting_pets(&self) -> bool {
let r = unsafe { &*WDT::ptr() };
let enabled = r.rren.read().bits();
let status = r.reqstatus.read().bits();
(status & enabled) == 0
}
}
/// Watchdog handle.
pub struct WatchdogHandle {
index: u8,
}
impl WatchdogHandle {
/// Pet the watchdog.
///
/// This function pets the given watchdog handle.
///
/// NOTE: All active handles must be pet within the time interval to
/// prevent a reset from occurring.
#[inline]
pub fn pet(&mut self) {
let r = unsafe { &*WDT::ptr() };
r.rr[self.index as usize].write(|w| w.rr().reload());
}
/// Has this handle been pet within the current window?
pub fn is_pet(&self) -> bool {
let r = unsafe { &*WDT::ptr() };
let rd = r.reqstatus.read().bits();
let idx = self.index as usize;
((rd >> idx) & 0x1) == 0
}
/// Steal a watchdog handle by index.
///
/// Safety: watchdog must be initialized, index must be between 0 and N-1 where
/// N is the handle count when initializing.
pub unsafe fn steal(index: u8) -> Self {
Self { index }
}
}