init commit

examples/simple/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "blinky"
+version = "0.1.0"
+authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
+edition = "2024"
+description = "Simple examples for the Zynq7000 SoC"
+homepage = "https://egit.irs.uni-stuttgart.de/rust/zynq7000-rs"
+repository = "https://egit.irs.uni-stuttgart.de/rust/zynq7000-rs"
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+cortex-ar = { git = "https://github.com/us-irs/cortex-ar.git", branch = "cortex-a-addition", features = ["critical-section-single-core"] }
+zynq7000-rt = { path = "../../zynq7000-rt" }
+zynq7000 = { path = "../../zynq7000" }
+zynq7000-hal = { path = "../../zynq7000-hal" }
+embedded-io = "0.6"
+embedded-hal = "1"
+fugit = "0.3"
+log = "0.4"

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

@@ -0,0 +1,132 @@
+//! Example which uses the global timer for a simple tick counter.
+#![no_std]
+#![no_main]
+
+use core::{panic::PanicInfo, sync::atomic::AtomicU64};
+use cortex_ar::asm::nop;
+use embedded_hal::digital::StatefulOutputPin;
+use embedded_io::Write;
+use log::{error, info};
+use zynq7000_hal::{
+    clocks::Clocks,
+    gic::{GicConfigurator, GicInterruptHelper, Interrupt},
+    gpio::{MioPins, PinState},
+    gtc::Gtc,
+    prelude::*,
+    time::Hertz,
+    uart::{ClkConfigRaw, Uart, UartConfig},
+};
+
+use zynq7000_rt as _;
+
+// Define the clock frequency as a constant
+const PS_CLOCK_FREQUENCY: Hertz = Hertz::from_raw(33_333_300);
+
+static MS_TICKS: AtomicU64 = AtomicU64::new(0);
+
+/// Entry point (not called like a normal main function)
+#[unsafe(no_mangle)]
+pub extern "C" fn boot_core(cpu_id: u32) -> ! {
+    if cpu_id != 0 {
+        panic!("unexpected CPU ID {}", cpu_id);
+    }
+    main();
+}
+
+#[unsafe(export_name = "main")]
+pub fn main() -> ! {
+    let dp = zynq7000::PsPeripherals::take().unwrap();
+    // Clock was already initialized by PS7 Init TCL script or FSBL, we just read it.
+    let clocks = Clocks::new_from_regs(PS_CLOCK_FREQUENCY).unwrap();
+    // Set up the global interrupt controller.
+    let mut gic = GicConfigurator::new_with_init(dp.gicc, dp.gicd);
+    gic.enable_all_interrupts();
+    gic.set_all_spi_interrupt_targets_cpu0();
+    gic.enable();
+    // Enable interrupt exception.
+    unsafe { gic.enable_interrupts() };
+    // Set up the UART, we are logging with it.
+    let uart_clk_config = ClkConfigRaw::new_autocalc_with_error(clocks.io_clocks(), 115200)
+        .unwrap()
+        .0;
+    let mut gtc = Gtc::new(dp.gtc, clocks.arm_clocks());
+    let ticks = gtc.frequency_to_ticks(1000.Hz());
+    gtc.set_auto_increment_value(ticks);
+    gtc.set_comparator(gtc.read_timer() + ticks as u64);
+    gtc.enable_auto_increment();
+    gtc.enable_interrupt();
+    gtc.enable();
+
+    // This structure holds all MIO pins.
+    let mio_pins = MioPins::new(dp.gpio);
+    let uart_tx = mio_pins.mio48.into_uart();
+    let uart_rx = mio_pins.mio49.into_uart();
+    let mut uart = Uart::new_with_mio(
+        dp.uart_1,
+        UartConfig::new_with_clk_config(uart_clk_config),
+        (uart_tx, uart_rx),
+    )
+    .unwrap();
+    uart.write_all(b"-- Zynq 7000 GTC Ticks example --\n\r")
+        .unwrap();
+    // Safety: We are not multi-threaded yet.
+    unsafe { zynq7000_hal::log::init_unsafe_single_core(uart, log::LevelFilter::Trace, false) };
+
+    let mut led = mio_pins.mio7.into_output(PinState::Low);
+    loop {
+        info!(
+            "MS_TICKS: {}",
+            MS_TICKS.load(core::sync::atomic::Ordering::Relaxed)
+        );
+        led.toggle().unwrap();
+        for _ in 0..5_000_000 {
+            nop();
+        }
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn _irq_handler() {
+    let mut gic_helper = GicInterruptHelper::new();
+    let irq_info = gic_helper.acknowledge_interrupt();
+    match irq_info.interrupt() {
+        Interrupt::Sgi(_) => (),
+        Interrupt::Ppi(ppi_interrupt) => {
+            if ppi_interrupt == zynq7000_hal::gic::PpiInterrupt::GlobalTimer {
+                MS_TICKS.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
+            }
+        }
+        Interrupt::Spi(_spi_interrupt) => (),
+        Interrupt::Invalid(_) => (),
+        Interrupt::Spurious => (),
+    }
+    gic_helper.end_of_interrupt(irq_info);
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn _abort_handler() {
+    loop {
+        nop();
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn _undefined_handler() {
+    loop {
+        nop();
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn _prefetch_handler() {
+    loop {
+        nop();
+    }
+}
+
+/// Panic handler
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    error!("Panic: {:?}", info);
+    loop {}
+}

examples/simple/src/bin/logger.rs

@@ -0,0 +1,135 @@
+//! Example which uses the UART1 to send log messages.
+#![no_std]
+#![no_main]
+
+use core::{panic::PanicInfo, sync::atomic::AtomicU64};
+use cortex_ar::asm::nop;
+use embedded_hal::digital::StatefulOutputPin;
+use embedded_io::Write;
+use log::{error, info};
+use zynq7000_hal::{
+    BootMode,
+    clocks::Clocks,
+    gic::{GicConfigurator, GicInterruptHelper, Interrupt},
+    gpio::{MioPins, PinState},
+    gtc::Gtc,
+    prelude::*,
+    time::Hertz,
+    uart::{ClkConfigRaw, Uart, UartConfig},
+};
+
+use zynq7000_rt as _;
+
+// Define the clock frequency as a constant
+const PS_CLOCK_FREQUENCY: Hertz = Hertz::from_raw(33_333_300);
+
+static MS_TICKS: AtomicU64 = AtomicU64::new(0);
+
+/// Entry point (not called like a normal main function)
+#[unsafe(no_mangle)]
+pub extern "C" fn boot_core(cpu_id: u32) -> ! {
+    if cpu_id != 0 {
+        panic!("unexpected CPU ID {}", cpu_id);
+    }
+    main();
+}
+
+#[unsafe(export_name = "main")]
+pub fn main() -> ! {
+    let dp = zynq7000::PsPeripherals::take().unwrap();
+    // Clock was already initialized by PS7 Init TCL script or FSBL, we just read it.
+    let clocks = Clocks::new_from_regs(PS_CLOCK_FREQUENCY).unwrap();
+    // Set up the global interrupt controller.
+    let mut gic = GicConfigurator::new_with_init(dp.gicc, dp.gicd);
+    gic.enable_all_interrupts();
+    gic.set_all_spi_interrupt_targets_cpu0();
+    gic.enable();
+    // Enable interrupt exception.
+    unsafe { gic.enable_interrupts() };
+    // Set up the UART, we are logging with it.
+    let uart_clk_config = ClkConfigRaw::new_autocalc_with_error(clocks.io_clocks(), 115200)
+        .unwrap()
+        .0;
+    let mut gtc = Gtc::new(dp.gtc, clocks.arm_clocks());
+    let ticks = gtc.frequency_to_ticks(1000.Hz());
+    gtc.set_auto_increment_value(ticks);
+    gtc.set_comparator(gtc.read_timer() + ticks as u64);
+    gtc.enable_auto_increment();
+    gtc.enable_interrupt();
+    gtc.enable();
+    let mio_pins = MioPins::new(dp.gpio);
+    let uart_tx = mio_pins.mio48.into_uart();
+    let uart_rx = mio_pins.mio49.into_uart();
+
+    let mut uart = Uart::new_with_mio(
+        dp.uart_1,
+        UartConfig::new_with_clk_config(uart_clk_config),
+        (uart_tx, uart_rx),
+    )
+    .unwrap();
+    uart.write_all(b"-- Zynq 7000 Logging example --\n\r")
+        .unwrap();
+    // Safety: We are not multi-threaded yet.
+    unsafe { zynq7000_hal::log::init_unsafe_single_core(uart, log::LevelFilter::Trace, false) };
+
+    let boot_mode = BootMode::new();
+    info!("Boot mode: {:?}", boot_mode);
+
+    let mut led = mio_pins.mio7.into_output(PinState::Low);
+    loop {
+        let gtc = gtc.read_timer();
+        info!("Hello, world!");
+        info!("GTC ticks: {}", gtc);
+        led.toggle().unwrap();
+        for _ in 0..5_000_000 {
+            nop();
+        }
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn _irq_handler() {
+    let mut gic_helper = GicInterruptHelper::new();
+    let irq_info = gic_helper.acknowledge_interrupt();
+    match irq_info.interrupt() {
+        Interrupt::Sgi(_) => (),
+        Interrupt::Ppi(ppi_interrupt) => {
+            if ppi_interrupt == zynq7000_hal::gic::PpiInterrupt::GlobalTimer {
+                // TODO: Call embassy on interrupt handler here soon.
+                MS_TICKS.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
+            }
+        }
+        Interrupt::Spi(_spi_interrupt) => (),
+        Interrupt::Invalid(_) => (),
+        Interrupt::Spurious => (),
+    }
+    gic_helper.end_of_interrupt(irq_info);
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn _abort_handler() {
+    loop {
+        nop();
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn _undefined_handler() {
+    loop {
+        nop();
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn _prefetch_handler() {
+    loop {
+        nop();
+    }
+}
+
+/// Panic handler
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    error!("Panic: {:?}", info);
+    loop {}
+}

examples/simple/src/main.rs

@@ -0,0 +1,90 @@
+//! Simple blinky app, showing a PAC variant and a HAL variant.
+#![no_std]
+#![no_main]
+
+use core::panic::PanicInfo;
+use cortex_ar::asm::nop;
+use embedded_hal::digital::StatefulOutputPin;
+use zynq7000::PsPeripherals;
+use zynq7000_hal::gpio::{MioPins, PinState};
+use zynq7000_rt as _;
+
+/// One user LED is MIO7
+const ZEDBOARD_LED_MASK: u32 = 1 << 7;
+
+#[derive(Debug)]
+pub enum Lib {
+    Pac,
+    Hal,
+}
+
+const LIB: Lib = Lib::Hal;
+
+/// Entry point (not called like a normal main function)
+#[unsafe(no_mangle)]
+pub extern "C" fn boot_core(cpu_id: u32) -> ! {
+    if cpu_id != 0 {
+        panic!("unexpected CPU ID {}", cpu_id);
+    }
+    main();
+}
+
+#[unsafe(export_name = "main")]
+pub fn main() -> ! {
+    match LIB {
+        Lib::Pac => {
+            let mut gpio = unsafe { zynq7000::gpio::Gpio::new_mmio_fixed() };
+            gpio.bank_0().modify_dirm(|v| v | ZEDBOARD_LED_MASK);
+            gpio.bank_0().modify_out_en(|v| v | ZEDBOARD_LED_MASK);
+            loop {
+                gpio.modify_out_0(|v| v ^ ZEDBOARD_LED_MASK);
+                for _ in 0..5_000_000 {
+                    nop();
+                }
+            }
+        }
+        Lib::Hal => {
+            let dp = PsPeripherals::take().unwrap();
+            let mio_pins = MioPins::new(dp.gpio);
+            let mut led = mio_pins.mio7.into_output(PinState::High);
+            loop {
+                led.toggle().unwrap();
+                for _ in 0..5_000_000 {
+                    nop();
+                }
+            }
+        }
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn _irq_handler() {}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn _abort_handler() {
+    loop {
+        nop();
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn _undefined_handler() {
+    loop {
+        nop();
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn _prefetch_handler() {
+    loop {
+        nop();
+    }
+}
+
+/// Panic handler
+#[panic_handler]
+fn panic(_info: &PanicInfo) -> ! {
+    loop {
+        nop();
+    }
+}