add an initial baremetal trial target

just prints hello world for now!

Author: bunnie

baremetal/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "baremetal"
+version = "0.1.0"
+authors = ["bunnie <[email protected]>"]
+edition = "2018"
+description = "Baremetal target"
+
+[dependencies]
+xous = "0.9.66"
+utralib = { version = "0.1.25", optional = true, default-features = false }
+cramium-hal = { path = "../libs/cramium-hal", optional = true, default-features = false }
+cramium-api = { path = "../libs/cramium-api", optional = true, default-features = false }
+riscv = { version = "0.5.6", package = "xous-riscv" }
+linked_list_allocator = { version = "0.10.5", optional = true }
+
+[features]
+artybio = ["utralib/artybio", "linked_list_allocator"]
+cramium-soc = ["utralib/cramium-soc"]
+
+verilator-only = []
+debug-print = []
+default = ["artybio", "debug-print"]

baremetal/build.rs

@@ -0,0 +1,40 @@
+// NOTE: Adapted from cortex-m/build.rs
+use std::env;
+use std::fs;
+use std::io::Write;
+use std::path::PathBuf;
+
+fn main() {
+    let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
+    let target = env::var("TARGET").unwrap();
+
+    let linker_file_path = if target.starts_with("riscv") {
+        println!("cargo:rustc-link-search={}", out_dir.display());
+        #[cfg(feature = "cramium-soc")]
+        let p = PathBuf::from("src/platform/cramium/link.x");
+        #[cfg(feature = "artybio")]
+        let p = PathBuf::from("src/platform/artybio/link.x");
+
+        println!("cargo:rerun-if-changed={}", p.clone().into_os_string().into_string().unwrap());
+        println!("cargo:rustc-link-arg=-Tlink.x");
+
+        p
+    } else {
+        unreachable!("unsupported target");
+    };
+
+    println!("{}", out_dir.join("link.x").display());
+    // Put the linker script somewhere the linker can find it
+    std::fs::OpenOptions::new()
+        .create(true)
+        .write(true)
+        .truncate(true)
+        .open(out_dir.join("link.x"))
+        .unwrap()
+        .write_all(fs::read_to_string(linker_file_path).expect("linker file read").as_bytes())
+        .unwrap();
+    println!("cargo:rustc-link-search={}", out_dir.display());
+
+    println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo:rerun-if-changed=link.x");
+}

baremetal/src/asm.rs

@@ -0,0 +1,43 @@
+use core::arch::asm;
+
+use crate::platform;
+// Assembly stubs for entering into the loader, and exiting it.
+
+// Note: inline constants are not yet stable in Rust: https://github.com/rust-lang/rust/pull/104087
+#[link_section = ".text.init"]
+#[export_name = "_start"]
+pub extern "C" fn _start() {
+    unsafe {
+        #[rustfmt::skip]
+        asm! (
+            // Place the stack pointer at the end of RAM
+            "mv          sp, {ram_top}",
+            // subtract four from sp to make room for a DMA "gutter"
+            "addi        sp, sp, -4",
+
+            // Install a machine mode trap handler
+            "la          t0, abort",
+            "csrw        mtvec, t0",
+
+            // Start Rust
+            "j   rust_entry",
+
+            ram_top = in(reg) (platform::RAM_BASE + platform::RAM_SIZE),
+            options(noreturn)
+        );
+    }
+}
+
+#[link_section = ".text.init"]
+#[export_name = "abort"]
+/// This is only used in debug mode
+pub extern "C" fn abort() -> ! {
+    unsafe {
+        #[rustfmt::skip]
+        asm!(
+            "300:", // abort
+            "j 300b",
+            options(noreturn)
+        );
+    }
+}

baremetal/src/main.rs

@@ -0,0 +1,36 @@
+#![cfg_attr(not(test), no_main)]
+#![cfg_attr(not(test), no_std)]
+
+// contains runtime setup
+mod asm;
+
+mod platform;
+use platform::*;
+
+/// Entrypoint
+/// This makes the program self-sufficient by setting up memory page assignment
+/// and copying the arguments to RAM.
+/// Assume the bootloader has already set up the stack to point to the end of RAM.
+///
+/// # Safety
+///
+/// This function is safe to call exactly once.
+#[export_name = "rust_entry"]
+pub unsafe extern "C" fn rust_entry() -> ! {
+    let mut count = 0;
+    loop {
+        crate::println!("hello world {}!\n", count);
+        count += 1;
+    }
+}
+
+// Install a panic handler when not running tests.
+#[cfg(all(not(test)))]
+mod panic_handler {
+    use core::panic::PanicInfo;
+    #[panic_handler]
+    fn handle_panic(_arg: &PanicInfo) -> ! {
+        crate::println!("{}", _arg);
+        loop {}
+    }
+}

baremetal/src/platform.rs

@@ -0,0 +1,9 @@
+#[cfg(any(feature = "cramium-soc"))]
+mod cramium;
+#[cfg(any(feature = "cramium-soc"))]
+pub use cramium::*;
+
+#[cfg(any(feature = "artybio"))]
+mod artybio;
+#[cfg(any(feature = "artybio"))]
+pub use artybio::*;

baremetal/src/platform/artybio.rs

@@ -0,0 +1,3 @@
+pub mod artybio;
+pub use artybio::*;
+pub mod debug;

baremetal/src/platform/artybio/artybio.rs

@@ -0,0 +1,8 @@
+#[global_allocator]
+static ALLOCATOR: linked_list_allocator::LockedHeap = linked_list_allocator::LockedHeap::empty();
+
+pub const RAM_SIZE: usize = utralib::generated::HW_MAIN_RAM_MEM_LEN;
+pub const RAM_BASE: usize = utralib::generated::HW_MAIN_RAM_MEM;
+
+#[cfg(all(feature = "cramium-soc", not(feature = "verilator-only")))]
+pub fn early_init() {}

baremetal/src/platform/artybio/debug.rs

@@ -0,0 +1,50 @@
+use utralib::generated::*;
+pub struct Uart {
+    // pub base: *mut u32,
+}
+
+impl Uart {
+    pub fn putc(&self, c: u8) {
+        let base = utra::uart::HW_UART_BASE as *mut u32;
+        let mut uart = CSR::new(base);
+        // Wait until TXFULL is `0`
+        while uart.r(utra::uart::TXFULL) != 0 {}
+        uart.wo(utra::uart::RXTX, c as u32)
+    }
+}
+
+use core::fmt::{Error, Write};
+impl Write for Uart {
+    fn write_str(&mut self, s: &str) -> Result<(), Error> {
+        for c in s.bytes() {
+            self.putc(c);
+        }
+        Ok(())
+    }
+}
+
+#[macro_use]
+pub mod debug_print_hardware {
+    #[macro_export]
+    macro_rules! print
+    {
+        ($($args:tt)+) => ({
+                use core::fmt::Write;
+                let _ = write!(crate::debug::Uart {}, $($args)+);
+        });
+    }
+}
+
+#[macro_export]
+macro_rules! println
+{
+    () => ({
+        $crate::print!("\r\n")
+    });
+    ($fmt:expr) => ({
+        $crate::print!(concat!($fmt, "\r\n"))
+    });
+    ($fmt:expr, $($args:tt)+) => ({
+        $crate::print!(concat!($fmt, "\r\n"), $($args)+)
+    });
+}

baremetal/src/platform/artybio/link.x

@@ -0,0 +1,179 @@
+MEMORY
+{
+  FLASH : ORIGIN = 0x40000000, LENGTH = 4M
+  RAM : ORIGIN = 0x40400000, LENGTH = 4M
+}
+
+REGION_ALIAS("REGION_TEXT", FLASH);
+REGION_ALIAS("REGION_RODATA", FLASH);
+REGION_ALIAS("REGION_DATA", RAM);
+REGION_ALIAS("REGION_BSS", RAM);
+REGION_ALIAS("REGION_STACK", RAM);
+REGION_ALIAS("REGION_HEAP", RAM);
+
+/* Size of the main kernel stack */
+_stack_size = 16K;
+_eheap = ORIGIN(RAM) + LENGTH(RAM);
+
+
+PROVIDE(_stext = ORIGIN(REGION_TEXT));
+PROVIDE(_stack_start = ORIGIN(REGION_STACK) + LENGTH(REGION_STACK));
+PROVIDE(_max_hart_id = 0);
+PROVIDE(_hart_stack_size = 2K);
+PROVIDE(_heap_size = 0);
+
+PROVIDE(trap_handler = default_trap_handler);
+
+/* # Pre-initialization function */
+/* If the user overrides this using the `#[pre_init]` attribute or by creating a `__pre_init` function,
+   then the function this points to will be called before the RAM is initialized. */
+PROVIDE(__pre_init = default_pre_init);
+
+/* # Multi-processing hook function
+   fn _mp_hook() -> bool;
+
+   This function is called from all the harts and must return true only for one hart,
+   which will perform memory initialization. For other harts it must return false
+   and implement wake-up in platform-dependent way (e.g. after waiting for a user interrupt).
+*/
+PROVIDE(_mp_hook = default_mp_hook);
+
+ENTRY(_start)
+
+SECTIONS
+{
+  .text.dummy (NOLOAD) :
+  {
+    /* This section is intended to make _stext address work */
+    . = ABSOLUTE(_stext);
+  } > REGION_TEXT
+
+  .text _stext :
+  {
+    /* Put reset handler first in .text section so it ends up as the entry */
+    /* point of the program. */
+    KEEP(*(.text.init));
+    KEEP(*(.init));
+    KEEP(*(.init.rust));
+    . = ALIGN(4);
+    KEEP(*(.trap));
+    KEEP(*(.trap.rust));
+
+    *(.text .text.*);
+  } > REGION_TEXT
+
+  .rodata : ALIGN(4)
+  {
+    *(.rodata .rodata.*);
+
+    /* 4-byte align the end (VMA) of this section.
+       This is required by LLD to ensure the LMA of the following .data
+       section will have the correct alignment. */
+    . = ALIGN(4);
+    _etext = .;
+  } > REGION_RODATA
+
+  .data : ALIGN(4)
+  {
+    _sidata = LOADADDR(.data);
+    _sdata = .;
+    /* Must be called __global_pointer$ for linker relaxations to work. */
+    PROVIDE(__global_pointer$ = . + 0x800);
+    *(.sdata .sdata.* .sdata2 .sdata2.*);
+    *(.data .data.*);
+    . = ALIGN(4);
+    _edata = .;
+  } > REGION_DATA AT > REGION_RODATA
+
+  .bss (NOLOAD) :
+  {
+    _sbss = .;
+    *(.sbss .sbss.* .bss .bss.*);
+    . = ALIGN(4);
+    _ebss = .;
+  } > REGION_BSS
+
+  /* fictitious region that represents the memory available for the stack */
+  .stack (NOLOAD) :
+  {
+    _sstack = .;
+    . += _stack_size;
+    . = ALIGN(4096);
+    _estack = .;
+  } > REGION_STACK
+
+  /* fictitious region that represents the memory available for the heap */
+  .heap (NOLOAD) :
+  {
+    . = ALIGN(4);
+    _sheap = .;
+    /* _eheap is defined elsewhere and is the remainder of RAM */
+  } > REGION_HEAP
+
+  /* fake output .got section */
+  /* Dynamic relocations are unsupported. This section is only used to detect
+     relocatable code in the input files and raise an error if relocatable code
+     is found */
+  .got (INFO) :
+  {
+    KEEP(*(.got .got.*));
+  }
+
+  /* Discard .eh_frame, we are not doing unwind on panic so it is not needed */
+  /DISCARD/ :
+  {
+    *(.eh_frame);
+    *(.eh_frame_hdr);
+  }
+}
+
+/* Do not exceed this mark in the error messages above                                    | */
+ASSERT(ORIGIN(REGION_TEXT) % 4 == 0, "
+ERROR(riscv-rt): the start of the REGION_TEXT must be 4-byte aligned");
+
+ASSERT(ORIGIN(REGION_RODATA) % 4 == 0, "
+ERROR(riscv-rt): the start of the REGION_RODATA must be 4-byte aligned");
+
+ASSERT(ORIGIN(REGION_DATA) % 4 == 0, "
+ERROR(riscv-rt): the start of the REGION_DATA must be 4-byte aligned");
+
+ASSERT(ORIGIN(REGION_HEAP) % 4 == 0, "
+ERROR(riscv-rt): the start of the REGION_HEAP must be 4-byte aligned");
+
+ASSERT(ORIGIN(REGION_TEXT) % 4 == 0, "
+ERROR(riscv-rt): the start of the REGION_TEXT must be 4-byte aligned");
+
+ASSERT(ORIGIN(REGION_STACK) % 4 == 0, "
+ERROR(riscv-rt): the start of the REGION_STACK must be 4-byte aligned");
+
+ASSERT(_stext % 4 == 0, "
+ERROR(riscv-rt): `_stext` must be 4-byte aligned");
+
+ASSERT(_sdata % 4 == 0 && _edata % 4 == 0, "
+BUG(riscv-rt): .data is not 4-byte aligned");
+
+ASSERT(_sidata % 4 == 0, "
+BUG(riscv-rt): the LMA of .data is not 4-byte aligned");
+
+ASSERT(_sbss % 4 == 0 && _ebss % 4 == 0, "
+BUG(riscv-rt): .bss is not 4-byte aligned");
+
+ASSERT(_sheap % 4 == 0, "
+BUG(riscv-rt): start of .heap is not 4-byte aligned");
+
+ASSERT(_stext + SIZEOF(.text) < ORIGIN(REGION_TEXT) + LENGTH(REGION_TEXT), "
+ERROR(riscv-rt): The .text section must be placed inside the REGION_TEXT region.
+Set _stext to an address smaller than 'ORIGIN(REGION_TEXT) + LENGTH(REGION_TEXT)'");
+
+ASSERT(SIZEOF(.stack) > (_max_hart_id + 1) * _hart_stack_size, "
+ERROR(riscv-rt): .stack section is too small for allocating stacks for all the harts.
+Consider changing `_max_hart_id` or `_hart_stack_size`.");
+
+ASSERT(SIZEOF(.got) == 0, "
+.got section detected in the input files. Dynamic relocations are not
+supported. If you are linking to C code compiled using the `gcc` crate
+then modify your build script to compile the C code _without_ the
+-fPIC flag. See the documentation of the `gcc::Config.fpic` method for
+details.");
+
+/* Do not exceed this mark in the error messages above                                    | */