From af64c1cf146bc276decfb1669f115689f3f4931b Mon Sep 17 00:00:00 2001 From: bunnie Date: Mon, 4 Aug 2025 16:11:30 +0800 Subject: [PATCH] add baremetal-cramsoc target for chip bringup --- baremetal/Cargo.toml | 9 +- baremetal/src/asm.rs | 88 ++++- baremetal/src/main.rs | 13 +- baremetal/src/platform/cramium.rs | 2 + baremetal/src/platform/cramium/cramium.rs | 419 +++++++++++++++++++++- baremetal/src/platform/cramium/debug.rs | 145 ++++++++ baremetal/src/platform/cramium/irq.rs | 206 +++++++++++ baremetal/src/platform/cramium/link.x | 2 +- baremetal/src/repl.rs | 2 + xtask/src/builder.rs | 13 + xtask/src/main.rs | 5 + 11 files changed, 891 insertions(+), 13 deletions(-) create mode 100644 baremetal/src/platform/cramium/debug.rs create mode 100644 baremetal/src/platform/cramium/irq.rs diff --git a/baremetal/Cargo.toml b/baremetal/Cargo.toml index fe4a4c430..b821fcd21 100644 --- a/baremetal/Cargo.toml +++ b/baremetal/Cargo.toml @@ -24,7 +24,14 @@ artybio = [ "xous-bio-bdma/baremetal", ] artyvexii = ["utralib/artyvexii", "linked_list_allocator"] -cramium-soc = ["utralib/cramium-soc"] +v0p9 = [] +cramium-soc = [ + "utralib/cramium-soc", + "linked_list_allocator", + "cramium-hal/loader-baosec", + "cramium-api", + "v0p9", +] verilator-only = [] default = ["artyvexii"] diff --git a/baremetal/src/asm.rs b/baremetal/src/asm.rs index 48a38cd55..90a705bd1 100644 --- a/baremetal/src/asm.rs +++ b/baremetal/src/asm.rs @@ -6,6 +6,7 @@ use crate::platform; // Note: inline constants are not yet stable in Rust: https://github.com/rust-lang/rust/pull/104087 #[link_section = ".text.init"] #[export_name = "_start"] +#[cfg(not(feature = "cramium-soc"))] pub extern "C" fn _start() { unsafe { #[rustfmt::skip] @@ -28,6 +29,80 @@ pub extern "C" fn _start() { } } +#[link_section = ".text.init"] +#[export_name = "_start"] +#[cfg(feature = "cramium-soc")] +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", + + // twiddle duart + "li t0, 0x40042000", + // setup etuc + "sw x0, 0x4(t0)", // CR is 0 + "li t1, 29", + "sw t1, 0xc(t0)", + "li t1, 0x1", + "sw t1, 0x4(t0)", // CR is 1 + // print 32 instances of 'Z' (0x5A) + "li t2, 32", + "li t1, 0x5A", + "10:", + "sw t1, 0x0(t0)", + "11:", + "lw t3, 0x8(t0)", // check SR + "bne x0, t3, 11b", // wait for 0 + "addi t2, t2, -1", + "bne x0, t2, 10b", + + // test if ifram is cleared + "li t0, 0x50000000", + "li t1, 0x50040000", + "60:", + "lw t2, 0(t0)", + // if not 0, jump to clearing routine + "bne x0, t2, 30f", + "addi t0, t0, 4", + // loop if we haven't checked all of ifram + "bltu t0, t1, 60b", + // if we got here, all of ifram was 0, continue with boot + "j 50f", + + // clear ifram + "30:", + "sw x0, 0(t0)", + "addi t0, t0, 4", + "bltu t0, t1, 30b", + + // clear main ram + "li t0, 0x61000000", + "li t1, 0x61200000", + "20:", + "sw x0, 0(t0)", + "addi t0, t0, 4", + "bltu t0, t1, 20b", + + ".word 0x500f", + + "50:", + // 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 @@ -35,12 +110,13 @@ pub extern "C" fn abort() -> ! { unsafe { #[rustfmt::skip] asm!( - "li t0, 0xf0000000", - "li t1, 0x00f", - "li t2, 0xf00", - "300:", // abort - "sw t1, 0(t0)", - "sw t2, 0(t0)", + "li t0, 0x40042000", + "li t1, 0x78", + "300:", // abort by printing x (0x78) to duart + "sw t1, 0x0(t0)", + "11:", + "lw t3, 0x8(t0)", // check SR + "bne x0, t3, 11b", // wait for 0 "j 300b", options(noreturn) ); diff --git a/baremetal/src/main.rs b/baremetal/src/main.rs index 10de02b0d..81956802d 100644 --- a/baremetal/src/main.rs +++ b/baremetal/src/main.rs @@ -12,6 +12,7 @@ use core::cell::RefCell; use critical_section::Mutex; use platform::*; +#[allow(unused_imports)] use utralib::*; #[cfg(feature = "artybio")] use xous_bio_bdma::*; @@ -43,9 +44,12 @@ pub fn uart_irq_handler() { /// This function is safe to call exactly once. #[export_name = "rust_entry"] pub unsafe extern "C" fn rust_entry() -> ! { - // turn on a green LED to indicate boot - let mut rgb = CSR::new(utra::rgb::HW_RGB_BASE as *mut u32); - rgb.wfo(utra::rgb::OUT_OUT, 0x002); + #[cfg(any(feature = "artyvexii", feature = "artybio"))] + { + // turn on a green LED to indicate boot + let mut rgb = CSR::new(utra::rgb::HW_RGB_BASE as *mut u32); + rgb.wfo(utra::rgb::OUT_OUT, 0x002); + } crate::platform::early_init(); crate::println!("\n~~Baremetal up!~~\n"); @@ -60,7 +64,9 @@ pub unsafe extern "C" fn rust_entry() -> ! { // The green LEDs flash whenever the FPGA is configured with the Arty BIO design. // The RGB LEDs flash when the CPU is running this code. + #[allow(unused_variables)] let mut count = 0; + #[cfg(any(feature = "artyvexii", feature = "artybio"))] let mut rgb = CSR::new(utra::rgb::HW_RGB_BASE as *mut u32); // provide some feedback on the run state of the BIO by peeking at the program counter @@ -81,6 +87,7 @@ pub unsafe extern "C" fn rust_entry() -> ! { // Animate the LED flashing to indicate repl loop is running delay(1); count += 1; + #[cfg(any(feature = "artyvexii", feature = "artybio"))] rgb.wfo(utra::rgb::OUT_OUT, ((count / 500) as u32) << 6); } } diff --git a/baremetal/src/platform/cramium.rs b/baremetal/src/platform/cramium.rs index a900031bb..7fe9b61ba 100644 --- a/baremetal/src/platform/cramium.rs +++ b/baremetal/src/platform/cramium.rs @@ -1,2 +1,4 @@ pub mod cramium; pub use cramium::*; +pub mod debug; +pub mod irq; diff --git a/baremetal/src/platform/cramium/cramium.rs b/baremetal/src/platform/cramium/cramium.rs index 41e3446a3..f4ec98dd3 100644 --- a/baremetal/src/platform/cramium/cramium.rs +++ b/baremetal/src/platform/cramium/cramium.rs @@ -1,3 +1,12 @@ +use utralib::CSR; +use utralib::utra; +use utralib::utra::sysctrl; + +use crate::platform::{ + debug::setup_rx, + irq::{enable_irq, irq_setup}, +}; + #[global_allocator] static ALLOCATOR: linked_list_allocator::LockedHeap = linked_list_allocator::LockedHeap::empty(); @@ -5,5 +14,411 @@ pub const RAM_SIZE: usize = utralib::generated::HW_SRAM_MEM_LEN; pub const RAM_BASE: usize = utralib::generated::HW_SRAM_MEM; pub const FLASH_BASE: usize = utralib::generated::HW_RERAM_MEM; -#[cfg(all(feature = "cramium-soc", not(feature = "verilator-only")))] -pub fn early_init() {} +pub const HEAP_START: usize = RAM_BASE + 1024 * 1024; // 0x610F_E000 +pub const HEAP_LEN: usize = 1024 * 256; + +// scratch page for exceptions located at top of RAM +// NOTE: there is an additional page above this for exception stack +pub const SCRATCH_PAGE: usize = HEAP_START - 8192; + +pub const UART_IFRAM_ADDR: usize = cramium_hal::board::UART_DMA_TX_BUF_PHYS; + +pub const SYSTEM_CLOCK_FREQUENCY: u32 = 800_000_000; +pub const SYSTEM_TICK_INTERVAL_MS: u32 = 1; + +pub fn early_init() { + let mut uart = crate::debug::Uart {}; + + for _ in 0..100 { + uart.putc('a' as u32 as u8); + } + unsafe { + // this block is mandatory in all cases to get clocks set into some consistent, expected mode + { + let daric_cgu = sysctrl::HW_SYSCTRL_BASE as *mut u32; + // conservative dividers + daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_0.offset()).write_volatile(0x7f7f); + daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_1.offset()).write_volatile(0x7f7f); + daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_2.offset()).write_volatile(0x3f7f); + daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_3.offset()).write_volatile(0x1f3f); + daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_4.offset()).write_volatile(0x0f1f); + // ungate all clocks + daric_cgu.add(utra::sysctrl::SFR_ACLKGR.offset()).write_volatile(0xFF); + daric_cgu.add(utra::sysctrl::SFR_HCLKGR.offset()).write_volatile(0xFF); + daric_cgu.add(utra::sysctrl::SFR_ICLKGR.offset()).write_volatile(0xFF); + daric_cgu.add(utra::sysctrl::SFR_PCLKGR.offset()).write_volatile(0xFF); + // commit clocks + daric_cgu.add(utra::sysctrl::SFR_CGUSET.offset()).write_volatile(0x32); + } + // enable DUART + let duart = utra::duart::HW_DUART_BASE as *mut u32; + duart.add(utra::duart::SFR_CR.offset()).write_volatile(0); + duart.add(utra::duart::SFR_ETUC.offset()).write_volatile(24); + duart.add(utra::duart::SFR_CR.offset()).write_volatile(1); + } + // sram0 requires 1 wait state for writes + let mut sramtrm = CSR::new(utra::coresub_sramtrm::HW_CORESUB_SRAMTRM_BASE as *mut u32); + sramtrm.wo(utra::coresub_sramtrm::SFR_SRAM0, 0x8); + sramtrm.wo(utra::coresub_sramtrm::SFR_SRAM1, 0x8); + + #[cfg(feature = "v0p9")] + { + /* + logic [15:0] trm_ram32kx72 ; assign trm_ram32kx72 = trmdat[0 ]; localparam t_trm IV_trm_ram32kx72 = IV_sram_sp_uhde_inst_sram0; + logic [15:0] trm_ram8kx72 ; assign trm_ram8kx72 = trmdat[1 ]; localparam t_trm IV_trm_ram8kx72 = IV_sram_sp_hde_inst_sram1; + logic [15:0] trm_rf1kx72 ; assign trm_rf1kx72 = trmdat[2 ]; localparam t_trm IV_trm_rf1kx72 = IV_rf_sp_hde_inst_cache; + logic [15:0] trm_rf256x27 ; assign trm_rf256x27 = trmdat[3 ]; localparam t_trm IV_trm_rf256x27 = IV_rf_sp_hde_inst_cache; + logic [15:0] trm_rf512x39 ; assign trm_rf512x39 = trmdat[4 ]; localparam t_trm IV_trm_rf512x39 = IV_rf_sp_hde_inst_cache; + logic [15:0] trm_rf128x31 ; assign trm_rf128x31 = trmdat[5 ]; localparam t_trm IV_trm_rf128x31 = IV_rf_sp_hde_inst_cache; + logic [15:0] trm_dtcm8kx36 ; assign trm_dtcm8kx36 = trmdat[6 ]; localparam t_trm IV_trm_dtcm8kx36 = IV_sram_sp_hde_inst_tcm; + logic [15:0] trm_itcm32kx18 ; assign trm_itcm32kx18 = trmdat[7 ]; localparam t_trm IV_trm_itcm32kx18 = IV_sram_sp_hde_inst_tcm; + logic [15:0] trm_ifram32kx36 ; assign trm_ifram32kx36 = trmdat[8 ]; localparam t_trm IV_trm_ifram32kx36 = IV_sram_sp_uhde_inst; + logic [15:0] trm_sce_sceram_10k ; assign trm_sce_sceram_10k = trmdat[9 ]; localparam t_trm IV_trm_sce_sceram_10k = IV_sram_sp_hde_inst; + logic [15:0] trm_sce_hashram_3k ; assign trm_sce_hashram_3k = trmdat[10]; localparam t_trm IV_trm_sce_hashram_3k = IV_rf_sp_hde_inst; + logic [15:0] trm_sce_aesram_1k ; assign trm_sce_aesram_1k = trmdat[11]; localparam t_trm IV_trm_sce_aesram_1k = IV_rf_sp_hde_inst; + logic [15:0] trm_sce_pkeram_4k ; assign trm_sce_pkeram_4k = trmdat[12]; localparam t_trm IV_trm_sce_pkeram_4k = IV_rf_sp_hde_inst; + logic [15:0] trm_sce_aluram_3k ; assign trm_sce_aluram_3k = trmdat[13]; localparam t_trm IV_trm_sce_aluram_3k = IV_rf_sp_hde_inst; + logic [15:0] trm_sce_mimmdpram ; assign trm_sce_mimmdpram = trmdat[14]; localparam t_trm IV_trm_sce_mimmdpram = IV_rf_2p_hdc_inst; + logic [15:0] trm_rdram1kx32 ; assign trm_rdram1kx32 = trmdat[15]; localparam t_trm IV_trm_rdram1kx32 = IV_rf_2p_hdc_inst_vex; + logic [15:0] trm_rdram512x64 ; assign trm_rdram512x64 = trmdat[16]; localparam t_trm IV_trm_rdram512x64 = IV_rf_2p_hdc_inst_vex; + logic [15:0] trm_rdram128x22 ; assign trm_rdram128x22 = trmdat[17]; localparam t_trm IV_trm_rdram128x22 = IV_rf_2p_hdc_inst_vex; + logic [15:0] trm_rdram32x16 ; assign trm_rdram32x16 = trmdat[18]; localparam t_trm IV_trm_rdram32x16 = IV_rf_2p_hdc_inst_vex; + logic [15:0] trm_bioram1kx32 ; assign trm_bioram1kx32 = trmdat[19]; localparam t_trm IV_trm_bioram1kx32 = IV_rf_sp_hde_inst_cache; + logic [15:0] trm_tx_fifo128x32 ; assign trm_tx_fifo128x32 = trmdat[20]; localparam t_trm IV_trm_tx_fifo128x32 = IV_rf_2p_hdc_inst; + logic [15:0] trm_rx_fifo128x32 ; assign trm_rx_fifo128x32 = trmdat[21]; localparam t_trm IV_trm_rx_fifo128x32 = IV_rf_2p_hdc_inst; + logic [15:0] trm_fifo32x19 ; assign trm_fifo32x19 = trmdat[22]; localparam t_trm IV_trm_fifo32x19 = IV_rf_2p_hdc_inst; + logic [15:0] trm_udcmem_share ; assign trm_udcmem_share = trmdat[23]; localparam t_trm IV_trm_udcmem_share = IV_rf_2p_hdc_inst; + logic [15:0] trm_udcmem_odb ; assign trm_udcmem_odb = trmdat[24]; localparam t_trm IV_trm_udcmem_odb = IV_rf_2p_hdc_inst; + logic [15:0] trm_udcmem_256x64 ; assign trm_udcmem_256x64 = trmdat[25]; localparam t_trm IV_trm_udcmem_256x64 = IV_rf_2p_hdc_inst; + logic [15:0] trm_acram2kx64 ; assign trm_acram2kx64 = trmdat[26]; localparam t_trm IV_trm_acram2kx64 = IV_sram_sp_uhde_inst_sram0; + logic [15:0] trm_aoram1kx36 ; assign trm_aoram1kx36 = trmdat[27]; localparam t_trm IV_trm_aoram1kx36 = IV_sram_sp_hde_inst; + + */ + uart.tiny_write_str("t0\r"); + let mut sramtrm = CSR::new(utra::coresub_sramtrm::HW_CORESUB_SRAMTRM_BASE as *mut u32); + sramtrm.wo(utra::coresub_sramtrm::SFR_CACHE, 0x3); + sramtrm.wo(utra::coresub_sramtrm::SFR_ITCM, 0x3); + sramtrm.wo(utra::coresub_sramtrm::SFR_DTCM, 0x3); + sramtrm.wo(utra::coresub_sramtrm::SFR_VEXRAM, 0x1); + + let mut rbist = CSR::new(utra::rbist_wrp::HW_RBIST_WRP_BASE as *mut u32); + // bio 0.9v settings + rbist.wo(utra::rbist_wrp::SFRCR_TRM, (19 << 16) | 0b011_000_01_0_0_000_0_00); + rbist.wo(utra::rbist_wrp::SFRAR_TRM, 0x5a); + + // vex 0.9v settings + for i in 0..4 { + rbist.wo(utra::rbist_wrp::SFRCR_TRM, ((15 + i) << 16) | 0b001_010_00_0_0_000_0_00); + rbist.wo(utra::rbist_wrp::SFRAR_TRM, 0x5a); + } + + // sram 0.9v settings + rbist.wo(utra::rbist_wrp::SFRCR_TRM, (0 << 16) | 0b011_000_01_0_1_000_0_00); + rbist.wo(utra::rbist_wrp::SFRAR_TRM, 0x5a); + rbist.wo(utra::rbist_wrp::SFRCR_TRM, (1 << 16) | 0b011_000_00_0_0_000_0_00); + rbist.wo(utra::rbist_wrp::SFRAR_TRM, 0x5a); + uart.tiny_write_str("t1\r"); + + // tcm 0.9v + rbist.wo(utra::rbist_wrp::SFRCR_TRM, (6 << 16) | 0b011_000_00_0_0_000_0_00); + rbist.wo(utra::rbist_wrp::SFRAR_TRM, 0x5a); + rbist.wo(utra::rbist_wrp::SFRCR_TRM, (7 << 16) | 0b011_000_00_0_0_000_0_00); + rbist.wo(utra::rbist_wrp::SFRAR_TRM, 0x5a); + + // ifram 0.9v + rbist.wo(utra::rbist_wrp::SFRCR_TRM, (8 << 16) | 0b010_000_00_0_1_000_1_01); + rbist.wo(utra::rbist_wrp::SFRAR_TRM, 0x5a); + + // sce 0.9V + rbist.wo(utra::rbist_wrp::SFRCR_TRM, (9 << 16) | 0b011_000_00_0_0_000_0_00); + rbist.wo(utra::rbist_wrp::SFRAR_TRM, 0x5a); + for i in 0..4 { + rbist.wo(utra::rbist_wrp::SFRCR_TRM, ((10 + i) << 16) | 0b011_000_01_0_1_000_0_00); + rbist.wo(utra::rbist_wrp::SFRAR_TRM, 0x5a); + } + rbist.wo(utra::rbist_wrp::SFRCR_TRM, (14 << 16) | 0b001_010_00_0_0_000_0_00); + rbist.wo(utra::rbist_wrp::SFRAR_TRM, 0x5a); + } + let perclk = unsafe { init_clock_asic(800_000_000) }; + + // setup the static data (hard-coded, because no loader) - necessary for heap + // see build message about non-zero data + let static_data = unsafe { core::slice::from_raw_parts_mut(0x6100_0000 as *mut u8, 20) }; + static_data.fill(0); + static_data[8] = 1; + + // setup other things + setup_rx(perclk); + irq_setup(); + enable_irq(utra::irqarray5::IRQARRAY5_IRQ); + setup_alloc(); +} + +pub fn setup_alloc() { + // Initialize the allocator with heap memory range + crate::println!("Setting up heap @ {:x}-{:x}", HEAP_START, HEAP_START + HEAP_LEN); + crate::println!("Stack @ {:x}-{:x}", HEAP_START + HEAP_LEN, RAM_BASE + RAM_SIZE); + unsafe { + ALLOCATOR.lock().init(HEAP_START as *mut u8, HEAP_LEN); + } +} + +/// Delay function that delays a given number of milliseconds. +pub fn delay(ms: usize) { + let mut timer = utralib::CSR::new(utra::timer0::HW_TIMER0_BASE as *mut u32); + timer.wfo(utra::timer0::EV_PENDING_ZERO, 1); + for _ in 0..ms { + while timer.rf(utra::timer0::EV_PENDING_ZERO) == 0 {} + timer.wfo(utra::timer0::EV_PENDING_ZERO, 1); + } +} + +mod panic_handler { + use core::panic::PanicInfo; + #[panic_handler] + fn handle_panic(_arg: &PanicInfo) -> ! { + crate::println!("{}", _arg); + loop {} + } +} + +// This function supercedes init_clock_asic() and needs to be back-ported +// into xous-core +pub unsafe fn init_clock_asic(freq_hz: u32) -> u32 { + use utra::sysctrl; + let daric_cgu = sysctrl::HW_SYSCTRL_BASE as *mut u32; + let mut cgu = CSR::new(daric_cgu); + + const UNIT_MHZ: u32 = 1000 * 1000; + const PFD_F_MHZ: u32 = 16; + const FREQ_0: u32 = 16 * UNIT_MHZ; + const FREQ_OSC_MHZ: u32 = 48; // Actually 48MHz + const M: u32 = FREQ_OSC_MHZ / PFD_F_MHZ; // - 1; // OSC input was 24, replace with 48 + + const TBL_Q: [u16; 7] = [ + // keep later DIV even number as possible + 0x7777, // 16-32 MHz + 0x7737, // 32-64 + 0x3733, // 64-128 + 0x3313, // 128-256 + 0x3311, // 256-512 // keep ~ 100MHz + 0x3301, // 512-1024 + 0x3301, // 1024-1600 + ]; + const TBL_MUL: [u32; 7] = [ + 64, // 16-32 MHz + 32, // 32-64 + 16, // 64-128 + 8, // 128-256 + 4, // 256-512 + 2, // 512-1024 + 2, // 1024-1600 + ]; + + // Hits a 16:8:4:2:1 ratio on fclk:aclk:hclk:iclk:pclk + // Resulting in 800:400:200:100:50 MHz assuming 800MHz fclk + daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_0.offset()).write_volatile(0x3f7f); // fclk + + // Hits a 8:8:4:2:1 ratio on fclk:aclk:hclk:iclk:pclk + daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_1.offset()).write_volatile(0x3f7f); // aclk + daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_2.offset()).write_volatile(0x1f3f); // hclk + daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_3.offset()).write_volatile(0x0f1f); // iclk + daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_4.offset()).write_volatile(0x070f); // pclk + // perclk divider - set to divide by 16 off of an 800Mhz base. Only found on NTO. + // daric_cgu.add(utra::sysctrl::SFR_CGUFDPER.offset()).write_volatile(0x03_ff_ff); + // perclk divider - set to divide by 8 off of an 800Mhz base. Only found on NTO. + daric_cgu.add(utra::sysctrl::SFR_CGUFDPER.offset()).write_volatile(0x01_ff_ff); + + /* + perclk fields: min-cycle-lp | min-cycle | fd-lp | fd + clkper fd + 0xff : Fperclk = Fclktop/2 + 0x7f: Fperclk = Fclktop/4 + 0x3f : Fperclk = Fclktop/8 + 0x1f : Fperclk = Fclktop/16 + 0x0f : Fperclk = Fclktop/32 + 0x07 : Fperclk = Fclktop/64 + 0x03: Fperclk = Fclktop/128 + 0x01: Fperclk = Fclktop/256 + + min cycle of clktop, F means frequency + Fperclk Max = Fperclk/(min cycle+1)*2 + */ + + // turn off gates + daric_cgu.add(utra::sysctrl::SFR_ACLKGR.offset()).write_volatile(0x2f); + daric_cgu.add(utra::sysctrl::SFR_HCLKGR.offset()).write_volatile(0xff); + daric_cgu.add(utra::sysctrl::SFR_ICLKGR.offset()).write_volatile(0x8f); + daric_cgu.add(utra::sysctrl::SFR_PCLKGR.offset()).write_volatile(0xff); + crate::println!("bef gates set"); + // commit dividers + daric_cgu.add(utra::sysctrl::SFR_CGUSET.offset()).write_volatile(0x32); + crate::println!("gates set"); + + if (0 == (cgu.r(sysctrl::SFR_IPCPLLMN) & 0x0001F000)) + || (0 == (cgu.r(sysctrl::SFR_IPCPLLMN) & 0x00000fff)) + { + // for SIM, avoid div by 0 if unconfigurated + // , default VCO 48MHz / 48 * 1200 = 1.2GHz + // TODO magic numbers + cgu.wo(sysctrl::SFR_IPCPLLMN, ((M << 12) & 0x0001F000) | ((1200) & 0x00000fff)); + cgu.wo(sysctrl::SFR_IPCPLLF, 0); + cgu.wo(sysctrl::SFR_IPCARIPFLOW, 0x32); + } + + // TODO select int/ext osc/xtal + // DARIC_CGU->cgusel1 = 1; // 0: RC, 1: XTAL + cgu.wo(sysctrl::SFR_CGUSEL1, 1); + // DARIC_CGU->cgufscr = FREQ_OSC_MHZ; // external crystal is 48MHz + cgu.wo(sysctrl::SFR_CGUFSCR, FREQ_OSC_MHZ); + // __DSB(); + // DARIC_CGU->cguset = 0x32UL; + cgu.wo(sysctrl::SFR_CGUSET, 0x32); + // __DSB(); + + if freq_hz < 1000000 { + // DARIC_IPC->osc = freqHz; + cgu.wo(sysctrl::SFR_IPCOSC, freq_hz); + // __DSB(); + // DARIC_IPC->ar = 0x0032; // commit, must write 32 + cgu.wo(sysctrl::SFR_IPCARIPFLOW, 0x32); + // __DSB(); + } + // switch to OSC + //DARIC_CGU->cgusel0 = 0; // clktop sel, 0:clksys, 1:clkpll0 + cgu.wo(sysctrl::SFR_CGUSEL0, 0); + // __DSB(); + // DARIC_CGU->cguset = 0x32; // commit + cgu.wo(sysctrl::SFR_CGUSET, 0x32); + //__DSB(); + + if freq_hz < 1000000 { + } else { + let n_fxp24: u64; // fixed point + let f16mhz_log2: u32 = (freq_hz / FREQ_0).ilog2(); + + // PD PLL + // DARIC_IPC->lpen |= 0x02 ; + cgu.wo(sysctrl::SFR_IPCLPEN, cgu.r(sysctrl::SFR_IPCLPEN) | 0x2); + // __DSB(); + // DARIC_IPC->ar = 0x0032; // commit, must write 32 + cgu.wo(sysctrl::SFR_IPCARIPFLOW, 0x32); + // __DSB(); + + // delay + // for (uint32_t i = 0; i < 1024; i++){ + // __NOP(); + //} + for _ in 0..1024 { + unsafe { core::arch::asm!("nop") }; + } + crate::println!("PLL delay 1"); + + n_fxp24 = (((freq_hz as u64) << 24) * TBL_MUL[f16mhz_log2 as usize] as u64 + + PFD_F_MHZ as u64 * UNIT_MHZ as u64 / 2) + / (PFD_F_MHZ as u64 * UNIT_MHZ as u64); // rounded + let n_frac: u32 = (n_fxp24 & 0x00ffffff) as u32; + + // TODO very verbose + //printf ("%s(%4" PRIu32 "MHz) M = %4" PRIu32 ", N = %4" PRIu32 ".%08" PRIu32 ", Q = %2lu, QDiv = + // 0x%04" PRIx16 "\n", __FUNCTION__, freqHz / 1000000, M, (uint32_t)(n_fxp24 >> 24), + // (uint32_t)((uint64_t)(n_fxp24 & 0x00ffffff) * 100000000/(1UL <<24)), TBL_MUL[f16MHzLog2], + // TBL_Q[f16MHzLog2]); DARIC_IPC->pll_mn = ((M << 12) & 0x0001F000) | ((n_fxp24 >> 24) & + // 0x00000fff); // 0x1F598; // ?? + cgu.wo(sysctrl::SFR_IPCPLLMN, ((M << 12) & 0x0001F000) | (((n_fxp24 >> 24) as u32) & 0x00000fff)); + // DARIC_IPC->pll_f = n_frac | ((0 == n_frac) ? 0 : (1UL << 24)); // ?? + cgu.wo(sysctrl::SFR_IPCPLLF, n_frac | if 0 == n_frac { 0 } else { 1u32 << 24 }); + // DARIC_IPC->pll_q = TBL_Q[f16MHzLog2]; // ?? TODO select DIV for VCO freq + cgu.wo(sysctrl::SFR_IPCPLLQ, TBL_Q[f16mhz_log2 as usize] as u32); + // VCO bias CPP bias CPI bias + // 1 2 3 + //DARIC_IPC->ipc = (3 << 6) | (5 << 3) | (5); + // DARIC_IPC->ipc = (1 << 6) | (2 << 3) | (3); + cgu.wo(sysctrl::SFR_IPCCR, (1 << 6) | (2 << 3) | (3)); + // __DSB(); + // DARIC_IPC->ar = 0x0032; // commit + cgu.wo(sysctrl::SFR_IPCARIPFLOW, 0x32); + // __DSB(); + + // DARIC_IPC->lpen &= ~0x02; + cgu.wo(sysctrl::SFR_IPCLPEN, cgu.r(sysctrl::SFR_IPCLPEN) & !0x2); + + //__DSB(); + // DARIC_IPC->ar = 0x0032; // commit + cgu.wo(sysctrl::SFR_IPCARIPFLOW, 0x32); + // __DSB(); + + // delay + // for (uint32_t i = 0; i < 1024; i++){ + // __NOP(); + // } + for _ in 0..1024 { + unsafe { core::arch::asm!("nop") }; + } + crate::println!("PLL delay 2"); + + //printf("read reg a0 : %08" PRIx32"\n", *((volatile uint32_t* )0x400400a0)); + //printf("read reg a4 : %04" PRIx16"\n", *((volatile uint16_t* )0x400400a4)); + //printf("read reg a8 : %04" PRIx16"\n", *((volatile uint16_t* )0x400400a8)); + + // TODO wait/poll lock status? + // DARIC_CGU->cgusel0 = 1; // clktop sel, 0:clksys, 1:clkpll0 + cgu.wo(sysctrl::SFR_CGUSEL0, 1); + // __DSB(); + // DARIC_CGU->cguset = 0x32; // commit + cgu.wo(sysctrl::SFR_CGUSET, 0x32); + crate::println!("clocks set"); + + // __DSB(); + + // printf (" MN: 0x%05x, F: 0x%06x, Q: 0x%04x\n", + // DARIC_IPC->pll_mn, DARIC_IPC->pll_f, DARIC_IPC->pll_q); + // printf (" LPEN: 0x%01x, OSC: 0x%04x, BIAS: 0x%04x,\n", + // DARIC_IPC->lpen, DARIC_IPC->osc, DARIC_IPC->ipc); + } + crate::println!( + "mn {:x}, q{:x}", + (0x400400a0 as *const u32).read_volatile(), + (0x400400a8 as *const u32).read_volatile() + ); + + crate::println!("fsvalid: {}", daric_cgu.add(sysctrl::SFR_CGUFSVLD.offset()).read_volatile()); + let _cgufsfreq0 = daric_cgu.add(sysctrl::SFR_CGUFSSR_FSFREQ0.offset()).read_volatile(); + let _cgufsfreq1 = daric_cgu.add(sysctrl::SFR_CGUFSSR_FSFREQ1.offset()).read_volatile(); + let _cgufsfreq2 = daric_cgu.add(sysctrl::SFR_CGUFSSR_FSFREQ2.offset()).read_volatile(); + let _cgufsfreq3 = daric_cgu.add(sysctrl::SFR_CGUFSSR_FSFREQ3.offset()).read_volatile(); + + crate::println!( + "Internal osc: {} -> {} MHz ({} MHz)", + _cgufsfreq0, + fsfreq_to_hz(_cgufsfreq0), + fsfreq_to_hz_32(_cgufsfreq0) + ); + crate::println!( + "XTAL: {} -> {} MHz ({} MHz)", + _cgufsfreq1, + fsfreq_to_hz(_cgufsfreq1), + fsfreq_to_hz_32(_cgufsfreq1) + ); + crate::println!( + "pll output 0: {} -> {} MHz ({} MHz)", + _cgufsfreq2, + fsfreq_to_hz(_cgufsfreq2), + fsfreq_to_hz_32(_cgufsfreq2) + ); + crate::println!( + "pll output 1: {} -> {} MHz ({} MHz)", + _cgufsfreq3, + fsfreq_to_hz(_cgufsfreq3), + fsfreq_to_hz_32(_cgufsfreq3) + ); + + crate::println!("PLL configured to {} MHz", freq_hz / 1_000_000); + 100_000_000 +} + +#[allow(dead_code)] +fn fsfreq_to_hz(fs_freq: u32) -> u32 { (fs_freq * (48_000_000 / 32)) / 1_000_000 } + +#[allow(dead_code)] +fn fsfreq_to_hz_32(fs_freq: u32) -> u32 { (fs_freq * (32_000_000 / 32)) / 1_000_000 } diff --git a/baremetal/src/platform/cramium/debug.rs b/baremetal/src/platform/cramium/debug.rs new file mode 100644 index 000000000..a7b4ca7f3 --- /dev/null +++ b/baremetal/src/platform/cramium/debug.rs @@ -0,0 +1,145 @@ +use cramium_api::*; +use cramium_hal::iox::Iox; +use cramium_hal::{udma, udma::GlobalConfig}; +use utralib::generated::*; + +/// A trait for serial like drivers which allows reading from a source. +#[allow(dead_code)] +pub trait SerialRead { + /// Read a single byte. + fn getc(&mut self) -> Option; +} +pub struct Uart {} + +#[allow(dead_code)] +impl Uart { + pub fn putc(&self, c: u8) { + let base = utra::duart::HW_DUART_BASE as *mut u32; + let mut uart = CSR::new(base); + if uart.rf(utra::duart::SFR_CR_SFR_CR) == 0 { + uart.wfo(utra::duart::SFR_CR_SFR_CR, 1); + } + while uart.r(utra::duart::SFR_SR) != 0 {} + uart.wo(utra::duart::SFR_TXD, c as u32); + } + + fn put_digit(&mut self, d: u8) { + let nyb = d & 0xF; + let c = if nyb < 10 { nyb + 0x30 } else { nyb + 0x61 - 10 }; + assert!(c >= 0x30, "conversion failed!"); + self.putc(c); + } + + pub fn put_hex(&mut self, c: u8) { + self.put_digit(c >> 4); + self.put_digit(c & 0xF); + } + + pub fn newline(&mut self) { + self.putc(0xa); + self.putc(0xd); + } + + pub fn print_hex_word(&mut self, word: u32) { + for &byte in word.to_be_bytes().iter() { + self.put_hex(byte); + } + } + + pub fn tiny_write_str(&mut self, s: &str) { + for c in s.bytes() { + self.putc(c); + } + } +} + +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(()) + } +} + +impl SerialRead for Uart { + fn getc(&mut self) -> Option { + let uart_buf_addr = crate::platform::UART_IFRAM_ADDR; + let mut udma_uart = unsafe { + // safety: this is safe to call, because we set up clock and events prior to calling new. + udma::Uart::get_handle(utra::udma_uart_1::HW_UDMA_UART_1_BASE, uart_buf_addr, uart_buf_addr) + }; + let mut c = 0u8; + match udma_uart.read_async(&mut c) { + 0 => None, + _ => Some(c), + } + } +} + +#[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)+) + }); +} + +pub fn setup_rx(perclk: u32) { + let iox = Iox::new(utra::iox::HW_IOX_BASE as *mut u32); + iox.set_alternate_function(IoxPort::PD, 13, IoxFunction::AF1); + iox.set_alternate_function(IoxPort::PD, 14, IoxFunction::AF1); + // rx as input, with pull-up + iox.set_gpio_dir(IoxPort::PD, 13, IoxDir::Input); + iox.set_gpio_pullup(IoxPort::PD, 13, IoxEnable::Enable); + // tx as output + iox.set_gpio_dir(IoxPort::PD, 14, IoxDir::Output); + + let udma_global = GlobalConfig::new(); + udma_global.clock_on(PeriphId::Uart1); + udma_global.map_event( + PeriphId::Uart1, + PeriphEventType::Uart(EventUartOffset::Rx), + EventChannel::Channel0, + ); + udma_global.map_event( + PeriphId::Uart1, + PeriphEventType::Uart(EventUartOffset::Tx), + EventChannel::Channel1, + ); + + let baudrate: u32 = 115200; + let freq: u32 = perclk / 2; + + // the address of the UART buffer is "hard-allocated" at an offset one page from the top of + // IFRAM0. This is a convention that must be respected by the UDMA UART library implementation + // for things to work. + let uart_buf_addr = crate::platform::UART_IFRAM_ADDR; + let mut udma_uart = unsafe { + // safety: this is safe to call, because we set up clock and events prior to calling new. + udma::Uart::get_handle(utra::udma_uart_1::HW_UDMA_UART_1_BASE, uart_buf_addr, uart_buf_addr) + }; + udma_uart.set_baud(baudrate, freq); + udma_uart.setup_async_read(); + + // setup interrupt here +} diff --git a/baremetal/src/platform/cramium/irq.rs b/baremetal/src/platform/cramium/irq.rs new file mode 100644 index 000000000..b3ac54ef5 --- /dev/null +++ b/baremetal/src/platform/cramium/irq.rs @@ -0,0 +1,206 @@ +use riscv::register::{mcause, mie, mstatus}; +use vexriscv::register::vexriscv::{mim, mip}; + +use crate::*; + +pub fn irq_setup() { + unsafe { + #[rustfmt::skip] + core::arch::asm!( + // Set trap handler, which will be called + // on interrupts and cpu faults + "la t0, _start_trap", // this first one forces the nop sled symbol to be generated + "la t0, _start_trap_aligned", // this is the actual target + "csrw mtvec, t0", + ); + } + + mim::write(0x0); // first make sure everything is disabled, so we aren't OR'ing in garbage + unsafe { + mstatus::set_mie(); + } + // must enable external interrupts on the CPU for any of the above to matter + unsafe { mie::set_mext() }; +} + +pub fn enable_irq(irq_no: usize) { + // Note that the vexriscv "IRQ Mask" register is inverse-logic -- + // that is, setting a bit in the "mask" register unmasks (i.e. enables) it. + mim::write(mim::read() | (1 << irq_no)); + // must enable external interrupts on the CPU for any of the above to matter + unsafe { mie::set_mext() }; +} + +#[export_name = "_start_trap"] +// #[repr(align(4))] // can't do this yet. +#[inline(never)] +pub unsafe extern "C" fn _start_trap() -> ! { + loop { + // install a NOP sled before _start_trap() until https://github.com/rust-lang/rust/issues/82232 is stable + core::arch::asm!("nop", "nop", "nop", "nop"); + #[export_name = "_start_trap_aligned"] + pub unsafe extern "C" fn _start_trap_aligned() { + #[rustfmt::skip] + core::arch::asm!( + "csrw mscratch, sp", + "li sp, 0x610FE000", // crate::platform::SCRATCH_PAGE - has to be hard-coded + "sw x1, 0*4(sp)", + // Skip SP for now + "sw x3, 2*4(sp)", + "sw x4, 3*4(sp)", + "sw x5, 4*4(sp)", + "sw x6, 5*4(sp)", + "sw x7, 6*4(sp)", + "sw x8, 7*4(sp)", + "sw x9, 8*4(sp)", + "sw x10, 9*4(sp)", + "sw x11, 10*4(sp)", + "sw x12, 11*4(sp)", + "sw x13, 12*4(sp)", + "sw x14, 13*4(sp)", + "sw x15, 14*4(sp)", + "sw x16, 15*4(sp)", + "sw x17, 16*4(sp)", + "sw x18, 17*4(sp)", + "sw x19, 18*4(sp)", + "sw x20, 19*4(sp)", + "sw x21, 20*4(sp)", + "sw x22, 21*4(sp)", + "sw x23, 22*4(sp)", + "sw x24, 23*4(sp)", + "sw x25, 24*4(sp)", + "sw x26, 25*4(sp)", + "sw x27, 26*4(sp)", + "sw x28, 27*4(sp)", + "sw x29, 28*4(sp)", + "sw x30, 29*4(sp)", + "sw x31, 30*4(sp)", + + // Save MEPC + "csrr t0, mepc", + "sw t0, 31*4(sp)", + // Save x1, which was used to calculate the offset. Prior to + // calculating, it was stashed at 0x61006000. + //"li t0, 0x61006000", + //"lw t1, 0*4(t0)", + //"sw t1, 0*4(sp)", + + // Finally, save SP + "csrr t0, mscratch", + "sw t0, 1*4(sp)", + // Restore a default stack pointer + "li sp, 0x61100000", // heap base, grows down + + // Note that registers $a0-$a7 still contain the arguments + "j _start_trap_rust", + // Note to self: trying to assign the scratch and default pages using in(reg) syntax + // clobbers the `a0` register and places the initialization outside of the handler loop + // and there seems to be no way to refer directly to a symbol? the `sym` directive wants + // to refer to an address, not a constant. + ); + } + _start_trap_aligned(); + core::arch::asm!("nop", "nop", "nop", "nop"); + } +} + +#[export_name = "_resume_context"] +#[inline(never)] +pub unsafe extern "C" fn _resume_context(registers: u32) -> ! { + #[rustfmt::skip] + core::arch::asm!( + "move sp, {registers}", + + "lw x1, 0*4(sp)", + // Skip SP for now + "lw x3, 2*4(sp)", + "lw x4, 3*4(sp)", + "lw x5, 4*4(sp)", + "lw x6, 5*4(sp)", + "lw x7, 6*4(sp)", + "lw x8, 7*4(sp)", + "lw x9, 8*4(sp)", + "lw x10, 9*4(sp)", + "lw x11, 10*4(sp)", + "lw x12, 11*4(sp)", + "lw x13, 12*4(sp)", + "lw x14, 13*4(sp)", + "lw x15, 14*4(sp)", + "lw x16, 15*4(sp)", + "lw x17, 16*4(sp)", + "lw x18, 17*4(sp)", + "lw x19, 18*4(sp)", + "lw x20, 19*4(sp)", + "lw x21, 20*4(sp)", + "lw x22, 21*4(sp)", + "lw x23, 22*4(sp)", + "lw x24, 23*4(sp)", + "lw x25, 24*4(sp)", + "lw x26, 25*4(sp)", + "lw x27, 26*4(sp)", + "lw x28, 27*4(sp)", + "lw x29, 28*4(sp)", + "lw x30, 29*4(sp)", + "lw x31, 30*4(sp)", + + // Restore SP + "lw x2, 1*4(sp)", + "mret", + registers = in(reg) registers, + ); + loop {} +} + +/// Just handles specific traps for testing CPU interactions. Doesn't do anything useful with the traps. +#[export_name = "_start_trap_rust"] +pub extern "C" fn trap_handler( + _a0: usize, + _a1: usize, + _a2: usize, + _a3: usize, + _a4: usize, + _a5: usize, + _a6: usize, + _a7: usize, +) -> ! { + let cause: mcause::Mcause = mcause::read(); + // crate::println!("cause {:x}", cause.bits()); + // 2 is illegal instruction + if cause.bits() == 2 { + // skip past the illegal instruction, in case that's what we want to do... + unsafe { + #[rustfmt::skip] + core::arch::asm!( + "csrr t0, mepc", + "addi t0, t0, 4", + "csrw mepc, t0", + ); + } + // ...but also panic. + panic!("Illegal Instruction"); + } else if cause.bits() == 4 { + let epc = riscv::register::mepc::read(); + panic!("Load address misaligned @ {:x}", epc); + } else if cause.bits() == 6 { + let epc = riscv::register::mepc::read(); + panic!("Store address misaligned @ {:x}", epc); + } else if cause.bits() == 0x8000_000b { + // external machine interrupt + // external interrupt. find out which ones triggered it, and clear the source. + let irqs_pending = mip::read(); + if (irqs_pending & (1 << utra::timer0::TIMER0_IRQ)) != 0 { + let ms = SYSTEM_TICK_INTERVAL_MS; + let mut timer0 = CSR::new(utra::timer0::HW_TIMER0_BASE as *mut u32); + timer0.wfo(utra::timer0::EV_PENDING_ZERO, 1); + timer0.wfo(utra::timer0::RELOAD_RELOAD, (SYSTEM_CLOCK_FREQUENCY / 1_000) * ms); + } else if (irqs_pending & (1 << utra::irqarray5::IRQARRAY5_IRQ)) != 0 { + crate::uart_irq_handler(); + } + } + + // re-enable interrupts + unsafe { mie::set_mext() }; + + // crate::println!("restoring from {:x}", crate::platform::SCRATCH_PAGE); + unsafe { _resume_context(crate::platform::SCRATCH_PAGE as u32) }; +} diff --git a/baremetal/src/platform/cramium/link.x b/baremetal/src/platform/cramium/link.x index 0ef02a1bd..02523d01c 100644 --- a/baremetal/src/platform/cramium/link.x +++ b/baremetal/src/platform/cramium/link.x @@ -1,6 +1,6 @@ MEMORY { - FLASH : ORIGIN = 0x60000000, LENGTH = 2M + FLASH : ORIGIN = 0x60000000, LENGTH = 4M RAM : ORIGIN = 0x61000000, LENGTH = 2M } diff --git a/baremetal/src/repl.rs b/baremetal/src/repl.rs index f990b0f66..52aa85bda 100644 --- a/baremetal/src/repl.rs +++ b/baremetal/src/repl.rs @@ -1,6 +1,7 @@ use alloc::string::{String, ToString}; use alloc::vec::Vec; +#[allow(unused_imports)] use utralib::*; #[cfg(feature = "artybio")] use xous_bio_bdma::*; @@ -48,6 +49,7 @@ impl Repl { let cmd = parts.next().unwrap_or("").to_string(); let args: Vec = parts.map(|s| s.to_string()).collect(); match cmd.as_str() { + #[cfg(not(feature = "cramium-soc"))] "mon" => { #[cfg(feature = "artybio")] let bio_ss = BioSharedState::new(); diff --git a/xtask/src/builder.rs b/xtask/src/builder.rs index b1f0ad820..4806967be 100644 --- a/xtask/src/builder.rs +++ b/xtask/src/builder.rs @@ -413,6 +413,19 @@ impl Builder { self } + /// Configure for baremetal bringup + pub fn target_baremetal_cramsoc(&mut self) -> &mut Builder { + self.target = Some(crate::TARGET_TRIPLE_RISCV32.to_string()); + self.target_kernel = Some(crate::TARGET_TRIPLE_RISCV32_KERNEL.to_string()); + self.stream = BuildStream::Release; + self.utra_target = "cramium-soc".to_string(); + self.run_svd2repl = false; + self.loader = CrateSpec::Local("baremetal".to_string(), LoaderRegion::Ram); + // this is actually a dummy, there is no kernel in baremetal + self.kernel = CrateSpec::Local("xous-kernel".to_string(), LoaderRegion::Ram); + self + } + /// Override the default kernel. For example, to use the kernel from crates.io, specify as /// "xous-kernel@0.9.9" #[allow(dead_code)] diff --git a/xtask/src/main.rs b/xtask/src/main.rs index ad6af81e7..ca6d3f447 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -647,6 +647,11 @@ fn main() -> Result<(), Box> { builder.target_artyvexii(); } + Some("baremetal-cramsoc") => { + builder.set_baremetal(true); + builder.target_baremetal_cramsoc(); + } + Some("baosec") => { let board = "board-baosec"; // select the board