mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-15 08:30:02 +00:00
add libstd time handler glue stubs
This commit is contained in:
parent
0abd4a1db6
commit
86ab8c392d
1 changed files with 279 additions and 0 deletions
279
services/status/src/time.rs
Normal file
279
services/status/src/time.rs
Normal file
|
|
@ -0,0 +1,279 @@
|
|||
/// The `time_server` is unique is that it is written for exclusive use by `libstd` to extract time.
|
||||
///
|
||||
/// It also has a single hook that is callable from the PDDB to initialize a time value once the
|
||||
/// PDDB itself has been initialized. Because time initialization breaks several abstractions, the
|
||||
/// system is forced to reboot after time is initialized.
|
||||
///
|
||||
/// Q: why don't we integrate this into the ticktimer?
|
||||
/// A: The ticktimer must be (1) lightweight and (2) used as a dependency by almost everything.
|
||||
/// Pulling this functionality into the ticktimer both makes it heavier, and also more importantly,
|
||||
/// creates circular dependencies on `llio` and `pddb`.
|
||||
///
|
||||
/// System time is composed of:
|
||||
/// "hardware `u64`"" + "offset to RT" -> SystemTime
|
||||
/// "offset to RT" is composed of:
|
||||
/// - offset to UTC
|
||||
/// - offset to current TZ
|
||||
/// "hardware `u64`" composed of:
|
||||
/// - the current number of seconds counted by the RTC module
|
||||
/// *or*
|
||||
/// - the number of seconds counted by the RTC module at time T + ticktimer offset since T
|
||||
/// The second representation is an optimization to avoid hitting the I2C module constantly to
|
||||
/// read RTC, plus you get milliseconds resolution. Time "T" can be updated at any time by just
|
||||
/// reading the RTC and noting the ticktimer offset at the point of reading.
|
||||
use std::thread;
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use llio::*;
|
||||
use pddb::Pddb;
|
||||
use std::io::{Read, Write, Seek, SeekFrom};
|
||||
use num_traits::*;
|
||||
use utralib::utra::ticktimer;
|
||||
|
||||
/// This is a "well known name" used by `libstd` to connect to the time server
|
||||
const TIME_SERVER_PUBLIC: &'static [u8; 16] = b"timeserverpublic";
|
||||
/// This is the registered name for a dedicated private API channel to the PDDB for doing the time reset
|
||||
pub const TIME_SERVER_PDDB: &'static str = "_dedicated pddb timeserver connection_";
|
||||
/// Dictionary for RTC settings
|
||||
pub const TIME_SERVER_DICT: &'static str = "sys.rtc";
|
||||
/// This is the UTC offset from the current hardware RTC reading. This should be fixed once time is set.
|
||||
pub const TIME_SERVER_UTC_OFFSET: &'static str = "utc_offset";
|
||||
/// This is the offset from UTC to the display time zone. This can vary when the user changes time zones.
|
||||
pub const TIME_SERVER_TZ_OFFSET: &'static str = "tz_offset";
|
||||
|
||||
const CTL3: usize = 0;
|
||||
const SECS: usize = 1;
|
||||
const MINS: usize = 2;
|
||||
const HOURS: usize = 3;
|
||||
const DAYS: usize = 4;
|
||||
// note 5 is skipped - this is weekdays, and is unused
|
||||
const MONTHS: usize = 6;
|
||||
const YEARS: usize = 7;
|
||||
|
||||
/// Do not modify the discriminants in this structure. They are used in `libstd` directly.
|
||||
#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)]
|
||||
pub(crate) enum TimeOp {
|
||||
/// Sync offsets to hardware RTC
|
||||
HwSync = 0,
|
||||
/// Suspend/resume call
|
||||
SusRes = 1,
|
||||
/// Indicates the current time is precisely the provided number of ms since EPOCH
|
||||
SetUtcTimeMs = 2,
|
||||
/// Get UTC time in ms since EPOCH
|
||||
GetUtcTimeMs = 3,
|
||||
/// Get local time in ms since EPOCH
|
||||
GetLocalTimeMs = 4,
|
||||
/// Sets the timezone offset, in milliseconds.
|
||||
SetTzOffsetMs = 5,
|
||||
}
|
||||
|
||||
/// Do not modify the discriminants in this structure. They are used in `libstd` directly.
|
||||
#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)]
|
||||
pub(crate) enum PrivTimeOp {
|
||||
/// Reset the hardware RTC count
|
||||
ResetRtc = 0,
|
||||
}
|
||||
|
||||
pub fn start_time_server() {
|
||||
// the public SID is well known and accessible by anyone who uses `libstd`
|
||||
let pub_sid = xous::create_server_with_address(&TIME_SERVER_PUBLIC)
|
||||
.expect("Couldn't create Ticktimer server");
|
||||
|
||||
let xns = xous_names::XousNames::new().unwrap();
|
||||
// we expect exactly one connection from the PDDB
|
||||
let priv_sid = xns.register_name(TIME_SERVER_PDDB, Some(1)).expect("can't register server");
|
||||
let mut i2c = llio::I2c::new(&xns);
|
||||
let trng = trng::Trng::new(&xns).unwrap();
|
||||
let llio = llio::Llio::new(&xns);
|
||||
|
||||
let rtc_checked = Arc::new(AtomicBool::new(false));
|
||||
|
||||
// this thread handles reading & updating the time offset from the PDDB
|
||||
thread::spawn({
|
||||
let rtc_checked = rtc_checked.clone();
|
||||
move || {
|
||||
let mut utc_offset_ms = 0i64;
|
||||
let mut tz_offset_ms = 0i64;
|
||||
let tt = ticktimer_server::Ticktimer::new().unwrap();
|
||||
// this routine can't proceed until the RTC has passed its power-on sanity checks
|
||||
while !rtc_checked.load(Ordering::SeqCst) {
|
||||
tt.sleep_ms(42).unwrap();
|
||||
}
|
||||
let mut start_rtc_secs = llio.get_rtc_secs().expect("couldn't read RTC offset value");
|
||||
let mut start_tt_ms = tt.elapsed_ms();
|
||||
|
||||
// register a suspend/resume listener
|
||||
let sr_cid = xous::connect(priv_sid).expect("couldn't create suspend callback connection");
|
||||
let mut susres = susres::Susres::new(
|
||||
Some(susres::SuspendOrder::Early),
|
||||
&xns,
|
||||
TimeOp::SusRes as u32,
|
||||
sr_cid
|
||||
).expect("couldn't create suspend/resume object");
|
||||
|
||||
let mut pddb = Pddb::new();
|
||||
pddb.is_mounted_blocking(None);
|
||||
let mut offset_handle = Pddb::new();
|
||||
let mut offset_key = offset_handle.get(
|
||||
TIME_SERVER_DICT,
|
||||
TIME_SERVER_UTC_OFFSET,
|
||||
None, false, true,
|
||||
Some(8),
|
||||
None::<fn()>
|
||||
).expect("couldn't open UTC offset key");
|
||||
let mut tz_handle = Pddb::new();
|
||||
let mut tz_key = tz_handle.get(
|
||||
TIME_SERVER_DICT,
|
||||
TIME_SERVER_TZ_OFFSET,
|
||||
None, false, true,
|
||||
Some(8),
|
||||
None::<fn()>
|
||||
).expect("couldn't open TZ offset key");
|
||||
let mut offset_buf = [0u8; 8];
|
||||
if offset_key.read(&mut offset_buf).unwrap_or(0) == 8 {
|
||||
utc_offset_ms = i64::from_le_bytes(offset_buf);
|
||||
} // else 0 is the error value, so leave it at that.
|
||||
let mut tz_buf = [0u8; 8];
|
||||
if tz_key.read(&mut tz_buf).unwrap_or(0) == 8 {
|
||||
tz_offset_ms = i64::from_le_bytes(tz_buf);
|
||||
}
|
||||
loop {
|
||||
let msg = xous::receive_message(priv_sid).unwrap();
|
||||
match FromPrimitive::from_usize(msg.body.id()) {
|
||||
Some(TimeOp::SusRes) => xous::msg_scalar_unpack!(msg, token, _, _, _, {
|
||||
susres.suspend_until_resume(token).expect("couldn't execute suspend/resume");
|
||||
// resync time on resume
|
||||
start_rtc_secs = llio.get_rtc_secs().expect("couldn't read RTC offset value");
|
||||
start_tt_ms = tt.elapsed_ms();
|
||||
}),
|
||||
Some(TimeOp::HwSync) => {
|
||||
start_rtc_secs = llio.get_rtc_secs().expect("couldn't read RTC offset value");
|
||||
start_tt_ms = tt.elapsed_ms();
|
||||
},
|
||||
Some(TimeOp::GetUtcTimeMs) => xous::msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
||||
let t =
|
||||
start_rtc_secs as i64 * 1000i64
|
||||
+ (tt.elapsed_ms() - start_tt_ms) as i64
|
||||
+ utc_offset_ms;
|
||||
assert!(t > 0, "time result is negative, this is an error");
|
||||
xous::return_scalar2(msg.sender,
|
||||
((t >> 32) & 0xFFFF_FFFF) as usize,
|
||||
(t & 0xFFFF_FFFF) as usize,
|
||||
).expect("couldn't respond to GetUtcTimeMs");
|
||||
}),
|
||||
Some(TimeOp::GetLocalTimeMs) => xous::msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
||||
let t =
|
||||
start_rtc_secs as i64 * 1000i64
|
||||
+ (tt.elapsed_ms() - start_tt_ms) as i64
|
||||
+ utc_offset_ms
|
||||
+ tz_offset_ms;
|
||||
assert!(t > 0, "time result is negative, this is an error");
|
||||
xous::return_scalar2(msg.sender,
|
||||
((t >> 32) & 0xFFFF_FFFF) as usize,
|
||||
(t & 0xFFFF_FFFF) as usize,
|
||||
).expect("couldn't respond to GetLocalTimeMs");
|
||||
}),
|
||||
Some(TimeOp::SetUtcTimeMs) => xous::msg_scalar_unpack!(msg, utc_hi_ms, utc_lo_ms, _, _, {
|
||||
let utc_time_ms = (utc_hi_ms as i64) << 32 | (utc_lo_ms as i64);
|
||||
start_rtc_secs = llio.get_rtc_secs().expect("couldn't read RTC offset value");
|
||||
start_tt_ms = tt.elapsed_ms();
|
||||
let offset =
|
||||
utc_time_ms -
|
||||
(start_rtc_secs as i64) * 1000;
|
||||
utc_offset_ms = offset;
|
||||
offset_key.seek(SeekFrom::Start(0)).expect("couldn't seek");
|
||||
assert_eq!(offset_key.write(&offset.to_le_bytes()).unwrap_or(0), 8, "couldn't commit UTC time offset to PDDB");
|
||||
offset_key.flush().expect("couldn't flush PDDB");
|
||||
}),
|
||||
Some(TimeOp::SetTzOffsetMs) => xous::msg_scalar_unpack!(msg, tz_hi_ms, tz_lo_ms, _, _, {
|
||||
let tz_ms = ((tz_hi_ms as i64) << 32) | (tz_lo_ms as i64);
|
||||
// sanity check with very broad bounds: I don't know of any time zones that are more than +/2 days from UTC
|
||||
// 86400 seconds in a day, times 1000 milliseconds, times 2 days
|
||||
if tz_ms < -(86400 * 1000 * 2) ||
|
||||
tz_ms > 86400 * 1000 * 2 {
|
||||
log::warn!("Requested timezone offset {} is out of bounds, ignoring!", tz_ms);
|
||||
continue;
|
||||
} else {
|
||||
tz_offset_ms = tz_ms;
|
||||
tz_key.seek(SeekFrom::Start(0)).expect("couldn't seek");
|
||||
assert_eq!(tz_key.write(&tz_ms.to_le_bytes()).unwrap_or(0), 8, "couldn't commit TZ time offset to PDDB");
|
||||
tz_key.flush().expect("couldn't flush PDDB");
|
||||
}
|
||||
}),
|
||||
_ => log::error!("Time server public thread received unknown opcode: {:?}", msg),
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// this thread handles more sensitive operations on the RTC.
|
||||
thread::spawn({
|
||||
let rtc_checked = rtc_checked.clone();
|
||||
move || {
|
||||
// on boot, do the validation checks of the RTC. If it is not initialized or corrupted, fix it.
|
||||
let mut settings = [0u8; 8];
|
||||
loop {
|
||||
match i2c.i2c_read(ABRTCMC_I2C_ADR, ABRTCMC_CONTROL3, &mut settings, None) {
|
||||
Ok(I2cStatus::ResponseReadOk) => break,
|
||||
_ => {
|
||||
log::error!("Couldn't check RTC, retrying!");
|
||||
xous::yield_slice(); // recheck in a fast loop, we really should be able to grab this resource on boot.
|
||||
},
|
||||
};
|
||||
}
|
||||
if is_rtc_invalid(&settings) {
|
||||
settings[CTL3] = (Control3::BATT_STD_BL_EN).bits();
|
||||
let mut start_time = trng.get_u64().unwrap();
|
||||
// set the clock to a random start time from 1 to 10 years into its maximum range of 100 years
|
||||
settings[SECS] = (start_time & 0xFF) as u8 % 60;
|
||||
start_time >>= 8;
|
||||
settings[MINS] = (start_time & 0xFF) as u8 % 60;
|
||||
start_time >>= 8;
|
||||
settings[HOURS] = (start_time & 0xFF) as u8 % 24;
|
||||
start_time >>= 8;
|
||||
settings[DAYS] = (start_time & 0xFF) as u8 % 28 + 1;
|
||||
start_time >>= 8;
|
||||
settings[MONTHS] = (start_time & 0xFF) as u8 % 12 + 1;
|
||||
start_time >>= 8;
|
||||
settings[YEARS] = (start_time & 0xFF) as u8 % 10 + 1;
|
||||
i2c.i2c_write(ABRTCMC_I2C_ADR, ABRTCMC_CONTROL3, &settings).expect("RTC access error");
|
||||
}
|
||||
rtc_checked.store(true, Ordering::SeqCst);
|
||||
loop {
|
||||
let msg = xous::receive_message(priv_sid).unwrap();
|
||||
match FromPrimitive::from_usize(msg.body.id()) {
|
||||
Some(PrivTimeOp::ResetRtc) => xous::msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
||||
settings[CTL3] = (Control3::BATT_STD_BL_EN).bits();
|
||||
let mut start_time = trng.get_u64().unwrap();
|
||||
// set the clock to a random start time from 1 to 10 years into its maximum range of 100 years
|
||||
settings[SECS] = (start_time & 0xFF) as u8 % 60;
|
||||
start_time >>= 8;
|
||||
settings[MINS] = (start_time & 0xFF) as u8 % 60;
|
||||
start_time >>= 8;
|
||||
settings[HOURS] = (start_time & 0xFF) as u8 % 24;
|
||||
start_time >>= 8;
|
||||
settings[DAYS] = (start_time & 0xFF) as u8 % 28 + 1;
|
||||
start_time >>= 8;
|
||||
settings[MONTHS] = (start_time & 0xFF) as u8 % 12 + 1;
|
||||
start_time >>= 8;
|
||||
settings[YEARS] = (start_time & 0xFF) as u8 % 10 + 1;
|
||||
i2c.i2c_write(ABRTCMC_I2C_ADR, ABRTCMC_CONTROL3, &settings).expect("RTC access error");
|
||||
xous::return_scalar(msg.sender, 0).unwrap();
|
||||
}),
|
||||
_ => log::error!("Time server private thread received unknown opcode: {:?}", msg),
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
fn is_rtc_invalid(settings: &[u8]) -> bool {
|
||||
(settings[CTL3] != (Control3::BATT_STD_BL_EN).bits()) // power switchover setting should be initialized
|
||||
|| (settings[SECS] & 0x80 != 0) // clock integrity should be guaranteed
|
||||
|| (settings[SECS] > 59)
|
||||
|| (settings[MINS] > 59)
|
||||
|| (settings[HOURS] > 23) // 24 hour mode is default and assumed
|
||||
|| (settings[DAYS] > 31) || (settings[DAYS] == 0)
|
||||
|| (settings[MONTHS] > 12) || (settings[MONTHS] == 0)
|
||||
|| (settings[YEARS] > 99)
|
||||
}
|
||||
Loading…
Reference in a new issue