Add RTC drivers.

Prints out time on startup. Needs APIs so OS can query and set time.

Author: jonathanpallant

Cargo.lock

@@ -42,6 +42,12 @@ fugit = "0.3"
 pc-keyboard = "0.7.0"
 # Useful queues and other structures
 heapless = "0.7"
+# The Dallas DS1307 RTC driver
+ds1307 = "0.5.0"
+# The Microchip MCP7940x RTC driver
+mcp794xx = "0.3.0"
+# I2C Bus Sharing
+shared-bus = "0.2"
 
 [[bin]]
 name = "neotron-pico-bios"

Cargo.toml

@@ -45,6 +45,7 @@ pub static BOOT2_FIRMWARE: [u8; 256] = rp2040_boot2::BOOT_LOADER_W25Q080;
 // Sub-modules
 // -----------------------------------------------------------------------------
 
+pub mod rtc;
 pub mod vga;
 
 // -----------------------------------------------------------------------------
@@ -64,6 +65,7 @@ use cortex_m_rt::entry;
 use critical_section::Mutex;
 use defmt::info;
 use defmt_rtt as _;
+use ds1307::{Datelike, Timelike};
 use embedded_hal::{
 	blocking::spi::{Transfer as _SpiTransfer, Write as _SpiWrite},
 	digital::v2::{InputPin, OutputPin},
@@ -121,6 +123,19 @@ struct Hardware {
 	interrupts_pending: u8,
 	/// The number of IRQs we've had
 	irq_count: u32,
+	/// Our I2C Bus
+	i2c: shared_bus::BusManagerSimple<
+		hal::i2c::I2C<
+			pac::I2C1,
+			(
+				Pin<bank0::Gpio14, Function<hal::gpio::I2C>>,
+				Pin<bank0::Gpio15, Function<hal::gpio::I2C>>,
+			),
+			hal::i2c::Controller,
+		>,
+	>,
+	/// Our RTC
+	rtc: rtc::Rtc,
 }
 
 /// Flips between true and false so we always send a unique read request
@@ -159,8 +174,6 @@ struct Pins {
 	blue2: Pin<bank0::Gpio12, Function<pac::PIO0>>,
 	blue3: Pin<bank0::Gpio13, Function<pac::PIO0>>,
 	npower_save: Pin<bank0::Gpio23, Output<PushPull>>,
-	i2c_sda: Pin<bank0::Gpio14, Function<hal::gpio::I2C>>,
-	i2c_scl: Pin<bank0::Gpio15, Function<hal::gpio::I2C>>,
 	spi_cipo: Pin<bank0::Gpio16, Function<hal::gpio::Spi>>,
 	nspi_cs_io: Pin<bank0::Gpio17, Output<PushPull>>,
 	spi_clk: Pin<bank0::Gpio18, Function<hal::gpio::Spi>>,
@@ -372,11 +385,28 @@ fn main() -> ! {
 		sio.gpio_bank0,
 		&mut pp.RESETS,
 		pp.SPI0,
+		pp.I2C1,
 		clocks,
 		delay,
 	);
 	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);
@@ -483,6 +513,7 @@ impl Hardware {
 		sio: hal::sio::SioGpioBank0,
 		resets: &mut pac::RESETS,
 		spi: pac::SPI0,
+		i2c: pac::I2C1,
 		clocks: ClocksManager,
 		delay: cortex_m::delay::Delay,
 	) -> (Hardware, IrqPin) {
@@ -492,6 +523,27 @@ impl Hardware {
 		// pin 25 to track render loop timing. This avoids trying to 'move' the pin
 		// over to Core 1.
 		let _pico_led = hal_pins.led.into_push_pull_output();
+		let raw_i2c = hal::i2c::I2C::i2c1(
+			i2c,
+			{
+				let mut pin = hal_pins.gpio14.into_mode();
+				pin.set_drive_strength(hal::gpio::OutputDriveStrength::EightMilliAmps);
+				pin.set_slew_rate(hal::gpio::OutputSlewRate::Fast);
+				pin
+			},
+			{
+				let mut pin = hal_pins.gpio15.into_mode();
+				pin.set_drive_strength(hal::gpio::OutputDriveStrength::EightMilliAmps);
+				pin.set_slew_rate(hal::gpio::OutputSlewRate::Fast);
+				pin
+			},
+			100.kHz(),
+			resets,
+			&clocks.system_clock,
+		);
+		let i2c = shared_bus::BusManagerSimple::new(raw_i2c);
+		let proxy = i2c.acquire_i2c();
+		let rtc = rtc::Rtc::new(proxy);
 
 		(
 			Hardware {
@@ -587,18 +639,6 @@ impl Hardware {
 						pin.set_slew_rate(hal::gpio::OutputSlewRate::Fast);
 						pin
 					},
-					i2c_sda: {
-						let mut pin = hal_pins.gpio14.into_mode();
-						pin.set_drive_strength(hal::gpio::OutputDriveStrength::EightMilliAmps);
-						pin.set_slew_rate(hal::gpio::OutputSlewRate::Fast);
-						pin
-					},
-					i2c_scl: {
-						let mut pin = hal_pins.gpio15.into_mode();
-						pin.set_drive_strength(hal::gpio::OutputDriveStrength::EightMilliAmps);
-						pin.set_slew_rate(hal::gpio::OutputSlewRate::Fast);
-						pin
-					},
 					spi_cipo: {
 						let mut pin = hal_pins.gpio16.into_mode();
 						pin.set_drive_strength(hal::gpio::OutputDriveStrength::EightMilliAmps);
@@ -652,11 +692,20 @@ impl Hardware {
 				bmc_buffer: [0u8; 64],
 				interrupts_pending: 0,
 				irq_count: 0,
+				i2c,
+				rtc,
 			},
 			hal_pins.gpio20.into_pull_up_input(),
 		)
 	}
 
+	// i2c_sda: {
+	//
+	// },
+	// i2c_scl: {
+	//
+	// },
+
 	/// Perform some SPI operation with the I/O chip selected.
 	///
 	/// You are required to have called `self.release_cs_lines()` previously,

src/main.rs

@@ -0,0 +1,80 @@
+//! RTC support for the Neotron Pico BIOS
+//!
+//! We could have one of two RTCs fitted. This module abstracts that away.
+
+pub use ds1307::{DateTimeAccess, NaiveDateTime};
+
+pub enum Rtc {
+	Ds1307,
+	Mcp7940n,
+	None,
+}
+
+impl Rtc {
+	/// Create a new RTC object.
+	///
+	/// The `bus` is dropped at the end of the function, so use a `&mut`
+	/// reference, or a disposable shared-bus proxy.
+	pub fn new<T, E>(bus: T) -> Rtc
+	where
+		T: embedded_hal::blocking::i2c::WriteRead<Error = E>
+			+ embedded_hal::blocking::i2c::Write<Error = E>,
+	{
+		let mut mcp7940n = mcp794xx::Mcp794xx::new_mcp7940n(bus);
+
+		match mcp7940n.is_oscillator_running() {
+			Ok(true) => {
+				defmt::info!("MCP7940N found and ticking");
+				return Rtc::Mcp7940n;
+			}
+			Ok(false) => {
+				defmt::info!("MCP7940N found, and has started ticking");
+				let _ = mcp7940n.enable_external_oscillator();
+				let _ = mcp7940n.enable();
+				return Rtc::Mcp7940n;
+			}
+			Err(_e) => defmt::info!("MCP7940N not found"),
+		}
+
+		let bus = mcp7940n.destroy();
+
+		let mut ds1307 = ds1307::Ds1307::new(bus);
+		match ds1307.running() {
+			Ok(true) => {
+				defmt::info!("DS1307 found and ticking");
+				return Rtc::Ds1307;
+			}
+			Ok(false) => {
+				defmt::info!("DS1307 found, and has started ticking");
+				let _ = ds1307.set_running();
+				return Rtc::Ds1307;
+			}
+			Err(_e) => defmt::info!("DS1307 not found"),
+		}
+
+		Rtc::None
+	}
+
+	/// Get 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 get_time<T, E>(&self, bus: T) -> Result<NaiveDateTime, ()>
+	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| ())
+			}
+			Self::Mcp7940n => {
+				let mut driver = mcp794xx::Mcp794xx::new_mcp7940n(bus);
+				driver.datetime().map_err(|_e| ())
+			}
+			Self::None => Err(()),
+		}
+	}
+}