Introduce Rust FSBL

examples/simple/build.rs

@@ -0,0 +1,31 @@
+//! This build script copies the `memory.x` file from the crate root into
+//! a directory where the linker can always find it at build time.
+//! For many projects this is optional, as the linker always searches the
+//! project root directory -- wherever `Cargo.toml` is. However, if you
+//! are using a workspace or have a more complicated build setup, this
+//! build script becomes required. Additionally, by requesting that
+//! Cargo re-run the build script whenever `memory.x` is changed,
+//! updating `memory.x` ensures a rebuild of the application with the
+//! new memory settings.
+
+use std::env;
+use std::fs::File;
+use std::io::Write;
+use std::path::PathBuf;
+
+fn main() {
+    // Put `memory.x` in our output directory and ensure it's
+    // on the linker search path.
+    let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
+    File::create(out.join("memory.x"))
+        .unwrap()
+        .write_all(include_bytes!("memory.x"))
+        .unwrap();
+    println!("cargo:rustc-link-search={}", out.display());
+
+    // By default, Cargo will re-run a build script whenever
+    // any file in the project changes. By specifying `memory.x`
+    // here, we ensure the build script is only re-run when
+    // `memory.x` is changed.
+    println!("cargo:rerun-if-changed=memory.x");
+}

examples/simple/memory.x

@@ -0,0 +1,22 @@
+MEMORY
+{
+  /* Zedboard: 512 MB DDR3. Only use 63 MB for now, should be plenty for a bare-metal app.
+  Leave 1 MB of memory which will be configured as uncached device memory by the MMU. This is
+  recommended for something like DMA descriptors. */
+  CODE(rx) : ORIGIN = 0x00100000, LENGTH = 63M
+  UNCACHED(rx): ORIGIN = 0x4000000, LENGTH = 1M
+}
+
+REGION_ALIAS("DATA", CODE);
+
+SECTIONS
+{
+  /* Uncached memory */
+  .uncached (NOLOAD) : ALIGN(4) {
+    . = ALIGN(4);
+    _sbss_uncached = .;
+    *(.uncached .uncached.*);
+    . = ALIGN(4);
+    _ebss_uncached = .;
+  } > UNCACHED
+}

examples/simple/src/bin/gtc-ticks.rs

@@ -21,7 +21,7 @@ use zynq7000_hal::{
 use zynq7000_rt as _;
 
 // Define the clock frequency as a constant
-const PS_CLOCK_FREQUENCY: Hertz = Hertz::from_raw(33_333_300);
+const PS_CLOCK_FREQUENCY: Hertz = Hertz::from_raw(33_333_333);
 
 static MS_TICKS: AtomicU64 = AtomicU64::new(0);
 

examples/simple/src/bin/logger.rs

@@ -79,7 +79,7 @@ pub fn main() -> ! {
         )
     };
 
-    let boot_mode = BootMode::new();
+    let boot_mode = BootMode::new_from_regs();
     info!("Boot mode: {boot_mode:?}");
 
     let mut led = Output::new_for_mio(mio_pins.mio7, PinState::Low);

examples/simple/src/main.rs

@@ -4,24 +4,33 @@
 
 use core::panic::PanicInfo;
 use cortex_ar::asm::nop;
-use embedded_hal::digital::StatefulOutputPin;
+use embedded_hal::{delay::DelayNs, digital::StatefulOutputPin};
 use zynq7000::PsPeripherals;
 use zynq7000_hal::{
-    gpio::{Output, PinState, mio},
+    clocks::Clocks,
+    gpio::{mio, Output, PinState},
     l2_cache,
+    priv_tim::CpuPrivateTimer,
+    time::Hertz,
 };
 use zynq7000_rt as _;
 
+pub const LIB: Lib = Lib::Hal;
+
 /// One user LED is MIO7
 const ZEDBOARD_LED_MASK: u32 = 1 << 7;
 
+// Define the clock frequency as a constant.
+//
+// Not required for the PAC mode, is required for clean delays in HAL mode.
+const PS_CLOCK_FREQUENCY: Hertz = Hertz::from_raw(33_333_333);
+
 #[derive(Debug)]
 pub enum Lib {
     Pac,
     Hal,
 }
 
-const LIB: Lib = Lib::Hal;
 
 /// Entry point (not called like a normal main function)
 #[unsafe(no_mangle)]
@@ -49,13 +58,14 @@ pub fn main() -> ! {
         }
         Lib::Hal => {
             let dp = PsPeripherals::take().unwrap();
+            let clocks = Clocks::new_from_regs(PS_CLOCK_FREQUENCY).unwrap();
+            // Unwrap okay, we only call this once on core 0 here.
+            let mut cpu_tim = CpuPrivateTimer::take(clocks.arm_clocks()).unwrap();
             let mio_pins = mio::Pins::new(dp.gpio);
             let mut led = Output::new_for_mio(mio_pins.mio7, PinState::High);
             loop {
                 led.toggle().unwrap();
-                for _ in 0..5_000_000 {
-                    nop();
-                }
+                cpu_tim.delay_ms(1000);
             }
         }
     }
@@ -64,22 +74,22 @@ pub fn main() -> ! {
 #[zynq7000_rt::irq]
 pub fn irq_handler() {}
 
-#[unsafe(no_mangle)]
-pub extern "C" fn _abort_handler() {
+#[zynq7000_rt::exception(DataAbort)]
+fn data_abort_handler(_faulting_addr: usize) -> ! {
     loop {
         nop();
     }
 }
 
-#[unsafe(no_mangle)]
-pub extern "C" fn _undefined_handler() {
+#[zynq7000_rt::exception(Undefined)]
+fn undefined_handler(_faulting_addr: usize) -> ! {
     loop {
         nop();
     }
 }
 
-#[unsafe(no_mangle)]
-pub extern "C" fn _prefetch_handler() {
+#[zynq7000_rt::exception(PrefetchAbort)]
+fn prefetch_handler(_faulting_addr: usize) -> ! {
     loop {
         nop();
     }