Implement BIOS API to set new date/time.

thejpster · thejpster · commit 6d9e79ea9e78 · 2023-04-06T21:54:15.000+01:00
diff --git a/src/main.rs b/src/main.rs
@@ -65,7 +65,7 @@ use cortex_m_rt::entry;
 use critical_section::Mutex;
 use defmt::info;
 use defmt_rtt as _;
-use ds1307::{Datelike, Timelike};
+use ds1307::{Datelike, NaiveDateTime, Timelike};
 use embedded_hal::{
 	blocking::spi::{Transfer as _SpiTransfer, Write as _SpiWrite},
 	digital::v2::{InputPin, OutputPin},
@@ -97,6 +97,9 @@ use neotron_common_bios as common;
 // Types
 // -----------------------------------------------------------------------------
 
+/// What we count our system ticks in
+type Duration = fugit::Duration<u64, 1, 1_000_000>;
+
 /// The type of our IRQ input pin from the MCP23S17.
 type IrqPin = Pin<bank0::Gpio20, Input<PullUp>>;
 
@@ -130,8 +133,10 @@ struct Hardware {
 	irq_count: u32,
 	/// Our I2C Bus
 	i2c: shared_bus::BusManagerSimple<hal::i2c::I2C<pac::I2C1, I2cPins, hal::i2c::Controller>>,
-	/// Our RTC
+	/// Our External RTC (on the I2C bus)
 	rtc: rtc::Rtc,
+	/// The time we started up at, in microseconds since the Neotron epoch
+	bootup_at: Duration,
 	/// A Timer
 	timer: hal::timer::Timer,
 }
@@ -269,6 +274,9 @@ static API_CALLS: common::Api = common::Api {
 	power_idle,
 };
 
+/// Seconds between the Neotron Epoch (2000-011-011T00:00:00) and the UNIX Epoch (1970-01-01T00:00:00).
+const SECONDS_BETWEEN_UNIX_AND_NEOTRON_EPOCH: i64 = 946684800;
+
 extern "C" {
 	static mut _flash_os_start: u32;
 	static mut _flash_os_len: u32;
@@ -381,31 +389,15 @@ fn main() -> ! {
 		pp.IO_BANK0,
 		pp.PADS_BANK0,
 		sio.gpio_bank0,
-		&mut pp.RESETS,
 		pp.SPI0,
 		pp.I2C1,
+		pp.TIMER,
 		clocks,
 		delay,
-		pp.TIMER,
+		&mut pp.RESETS,
 	);
 	hw.init_io_chip();
 	hw.set_hdd_led(false);
-	match hw.rtc.get_time(hw.i2c.acquire_i2c()) {
-		Ok(time) => {
-			defmt::info!(
-				"Time: {:04}-{:02}-{:02} {:02}:{:02}:{:02}",
-				time.year(),
-				time.month(),
-				time.day(),
-				time.hour(),
-				time.minute(),
-				time.second()
-			);
-		}
-		Err(_) => {
-			defmt::info!("Time: Unknown");
-		}
-	}
 
 	nirq_io.set_interrupt_enabled(hal::gpio::Interrupt::EdgeLow, true);
 	nirq_io.set_interrupt_enabled(hal::gpio::Interrupt::EdgeHigh, true);
@@ -511,12 +503,12 @@ impl Hardware {
 		bank: pac::IO_BANK0,
 		pads: pac::PADS_BANK0,
 		sio: hal::sio::SioGpioBank0,
-		resets: &mut pac::RESETS,
 		spi: pac::SPI0,
 		i2c: pac::I2C1,
+		timer: pac::TIMER,
 		clocks: ClocksManager,
 		delay: cortex_m::delay::Delay,
-		timer: pac::TIMER,
+		resets: &mut pac::RESETS,
 	) -> (Hardware, IrqPin) {
 		let hal_pins = rp_pico::Pins::new(bank, pads, sio, resets);
 		// We construct the pin here and then throw it away. Then Core 1 does
@@ -544,8 +536,30 @@ impl Hardware {
 		);
 		let i2c = shared_bus::BusManagerSimple::new(raw_i2c);
 		let proxy = i2c.acquire_i2c();
-		let rtc = rtc::Rtc::new(proxy);
+		let mut external_rtc = rtc::Rtc::new(proxy);
 		let timer = hal::timer::Timer::new(timer, resets);
+		// Do a conversion from external RTC time (chrono::NaiveDateTime) to a format we can track
+		let ticks_at_boot_us = match external_rtc.get_time(i2c.acquire_i2c()) {
+			Ok(time) => {
+				defmt::info!(
+					"Time: {:04}-{:02}-{:02} {:02}:{:02}:{:02}",
+					time.year(),
+					time.month(),
+					time.day(),
+					time.hour(),
+					time.minute(),
+					time.second()
+				);
+				let ticks_at_boot_us =
+					time.timestamp_micros() - (SECONDS_BETWEEN_UNIX_AND_NEOTRON_EPOCH * 1_000_000);
+				defmt::info!("Ticks at boot: {}", ticks_at_boot_us);
+				ticks_at_boot_us
+			}
+			Err(_) => {
+				defmt::info!("Time: Unknown");
+				0
+			}
+		};
 
 		(
 			Hardware {
@@ -695,7 +709,8 @@ impl Hardware {
 				interrupts_pending: 0,
 				irq_count: 0,
 				i2c,
-				rtc,
+				rtc: external_rtc,
+				bootup_at: Duration::from_ticks(ticks_at_boot_us as u64),
 				timer,
 			},
 			hal_pins.gpio20.into_pull_up_input(),
@@ -890,7 +905,7 @@ impl Hardware {
 		if INTERRUPT_PENDING.load(Ordering::Relaxed) {
 			// The IO chip reports 0 for pending, 1 for not pending.
 			self.interrupts_pending = self.io_read_interrupts() ^ 0xFF;
-			defmt::info!("MCP23S17 IRQ pins: 0b{:08b}", self.interrupts_pending);
+			defmt::debug!("MCP23S17 IRQ pins: 0b{:08b}", self.interrupts_pending);
 			// Change the debug LEDs so we can see the interrupts
 			self.irq_count = self.irq_count.wrapping_add(1);
 			self.set_debug_leds((self.irq_count & 0x0F) as u8);
@@ -1285,8 +1300,22 @@ pub extern "C" fn serial_read(
 /// If the BIOS does not have a battery-backed clock, or if that battery has
 /// failed to keep time, the system starts up assuming it is the epoch.
 pub extern "C" fn time_clock_get() -> common::Time {
-	// TODO: Read from the MCP7940N
-	common::Time { secs: 0, nsecs: 0 }
+	// We track real-time using the RP2040 1 MHz timer. We noted the wall-time at boot-up.
+
+	let ticks_since_epoch = critical_section::with(|cs| {
+		let mut lock = HARDWARE.borrow_ref_mut(cs);
+		let hw = lock.as_mut().unwrap();
+		// We can unwrap this because we set the day-of-week correctly on startup
+		let ticks_since_boot = hw.timer.get_counter().duration_since_epoch();
+		ticks_since_boot + hw.bootup_at
+	});
+
+	let nanos_since_epoch = ticks_since_epoch.to_nanos();
+
+	let secs = (nanos_since_epoch / 1_000_000_000) as u32;
+	let nsecs = (nanos_since_epoch % 1_000_000_000) as u32;
+	defmt::info!("Time is {}.{:09}s", secs, nsecs);
+	common::Time { secs, nsecs }
 }
 
 /// Set the current wall time.
@@ -1298,8 +1327,49 @@ pub extern "C" fn time_clock_get() -> common::Time {
 /// time (e.g. the user has updated the current time, or if you get a GPS
 /// fix). The BIOS should push the time out to the battery-backed Real
 /// Time Clock, if it has one.
-pub extern "C" fn time_clock_set(_time: common::Time) {
-	// TODO: Update the MCP7940N RTC
+pub extern "C" fn time_clock_set(time: common::Time) {
+	critical_section::with(|cs| {
+		let mut lock = HARDWARE.borrow_ref_mut(cs);
+		let hw = lock.as_mut().unwrap();
+
+		// 1. How long have we been running, in 1 MHz ticks?
+		let ticks_since_boot = hw.timer.get_counter().duration_since_epoch();
+
+		// 2. What is the given time as 1 MHz ticks since the epoch?
+		let ticks_since_epoch = u64::from(time.secs) * 1_000_000 + u64::from(time.nsecs / 1000);
+		let ticks_since_epoch = Duration::from_ticks(ticks_since_epoch);
+
+		// 3. Work backwards, and find the time it must have been when we booted up.
+		let ticks_at_boot = ticks_since_epoch
+			.checked_sub(ticks_since_boot)
+			.unwrap_or_else(|| Duration::from_ticks(0));
+
+		// 4. Store that value
+		defmt::info!("Ticks at boot: {}", ticks_at_boot.ticks());
+		hw.bootup_at = ticks_at_boot;
+
+		// 5. Convert to calendar time
+		if let Some(new_time) = NaiveDateTime::from_timestamp_opt(
+			i64::from(time.secs) + SECONDS_BETWEEN_UNIX_AND_NEOTRON_EPOCH,
+			time.nsecs,
+		) {
+			// 6. Update the hardware RTC as well
+			match hw.rtc.set_time(hw.i2c.acquire_i2c(), new_time) {
+				Ok(_) => {
+					defmt::info!("Time set in RTC OK");
+				}
+				Err(rtc::Error::BusError(_)) => {
+					defmt::warn!("Failed to talk to RTC to set time");
+				}
+				Err(rtc::Error::DriverBug) => {
+					defmt::warn!("RTC driver failed");
+				}
+				Err(rtc::Error::NoRtcFound) => {
+					defmt::info!("Not setting time - no RTC found");
+				}
+			}
+		}
+	});
 }
 
 /// Get the configuration data block.
diff --git a/src/rtc.rs b/src/rtc.rs
@@ -10,6 +10,13 @@ pub enum Rtc {
 	None,
 }
 
+/// The ways this module can fail
+pub enum Error<E> {
+	BusError(E),
+	DriverBug,
+	NoRtcFound,
+}
+
 impl Rtc {
 	/// Create a new RTC object.
 	///
@@ -60,21 +67,56 @@ impl Rtc {
 	/// We don't care about timezones - this is basic Gregorian naive wall-clock date/time.
 	///
 	/// You get `Err()` if the RTC doesn't respond or wasn't found on start-up.
-	pub fn get_time<T, E>(&self, bus: T) -> Result<NaiveDateTime, ()>
+	pub fn get_time<T, E>(&mut self, bus: T) -> Result<NaiveDateTime, Error<E>>
+	where
+		T: embedded_hal::blocking::i2c::WriteRead<Error = E>
+			+ embedded_hal::blocking::i2c::Write<Error = E>,
+	{
+		match self {
+			Self::Ds1307 => {
+				let mut driver = ds1307::Ds1307::new(bus);
+				driver.datetime().map_err(|e| match e {
+					ds1307::Error::I2C(bus_error) => Error::BusError(bus_error),
+					ds1307::Error::InvalidInputData => Error::DriverBug,
+				})
+			}
+			Self::Mcp7940n => {
+				let mut driver = mcp794xx::Mcp794xx::new_mcp7940n(bus);
+				driver.datetime().map_err(|e| match e {
+					mcp794xx::Error::Comm(bus_error) => Error::BusError(bus_error),
+					mcp794xx::Error::InvalidInputData => Error::DriverBug,
+				})
+			}
+			Self::None => Err(Error::NoRtcFound),
+		}
+	}
+
+	/// Set the current wall-time
+	///
+	/// We don't care about timezones - this is basic Gregorian naive wall-clock date/time.
+	///
+	/// You get `Err()` if the RTC doesn't respond or wasn't found on start-up.
+	pub fn set_time<T, E>(&mut self, bus: T, new_time: NaiveDateTime) -> Result<(), Error<E>>
 	where
 		T: embedded_hal::blocking::i2c::WriteRead<Error = E>
 			+ embedded_hal::blocking::i2c::Write<Error = E>,
 	{
 		match self {
 			Self::Ds1307 => {
 				let mut driver = ds1307::Ds1307::new(bus);
-				driver.datetime().map_err(|_e| ())
+				driver.set_datetime(&new_time).map_err(|e| match e {
+					ds1307::Error::I2C(bus_error) => Error::BusError(bus_error),
+					ds1307::Error::InvalidInputData => Error::DriverBug,
+				})
 			}
 			Self::Mcp7940n => {
 				let mut driver = mcp794xx::Mcp794xx::new_mcp7940n(bus);
-				driver.datetime().map_err(|_e| ())
+				driver.set_datetime(&new_time).map_err(|e| match e {
+					mcp794xx::Error::Comm(bus_error) => Error::BusError(bus_error),
+					mcp794xx::Error::InvalidInputData => Error::DriverBug,
+				})
 			}
-			Self::None => Err(()),
+			Self::None => Err(Error::NoRtcFound),
 		}
 	}
 }
