mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-15 08:30:02 +00:00
Refactor remaining tests for multi-bank RAM op
BDMA memory pages for each core are now on separate pages, with each core having a private memory space. Also add code readback tests, debug PC & trap test
This commit is contained in:
parent
2bf77883ee
commit
d665805523
5 changed files with 236 additions and 142 deletions
|
|
@ -3,7 +3,7 @@ use crate::*;
|
|||
const PIN_SDA: u32 = 2;
|
||||
const PIN_SCL: u32 = 3;
|
||||
|
||||
pub fn i2c_test() {
|
||||
pub fn i2c_test() -> usize {
|
||||
print!("I2C tests\r");
|
||||
|
||||
// clear prior test config state
|
||||
|
|
@ -17,7 +17,7 @@ pub fn i2c_test() {
|
|||
bio_ss.bio.wo(utra::bio_bdma::SFR_CTRL, 0x0);
|
||||
let code = crate::i2c::i2c_driver();
|
||||
print!("code length {}\r", code.len());
|
||||
bio_ss.load_code(code, 0);
|
||||
bio_ss.load_code(code, 0, BioCore::Core0);
|
||||
|
||||
// configure & run the 0th machine
|
||||
// 400kHz clock -> 100kHz toggle rate = 0x7D0_0000 @ 800MHz rate FCLK
|
||||
|
|
@ -93,14 +93,16 @@ pub fn i2c_test() {
|
|||
bio_ss.bio.wo(utra::bio_bdma::SFR_IRQMASK_0, 0);
|
||||
if passing {
|
||||
print!("===I2C tests PASS===\r");
|
||||
1
|
||||
} else {
|
||||
print!("===I2C tests FAIL===\r");
|
||||
0
|
||||
}
|
||||
}
|
||||
|
||||
/// This just generates some more complex I2C waveforms; we don't have a full I2C hardware
|
||||
/// unit in the upper level test bench, so we use manual waveform checking.
|
||||
pub fn complex_i2c_test() {
|
||||
pub fn complex_i2c_test() -> usize {
|
||||
print!("Complex I2C transactions\r");
|
||||
let mut bio_ss = BioSharedState::new();
|
||||
let mut i2c =
|
||||
|
|
@ -124,4 +126,5 @@ pub fn complex_i2c_test() {
|
|||
Err(_) => print!("read test FAIL\r"),
|
||||
}
|
||||
print!("===Exit complex I2C transactions===\r");
|
||||
1
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@ use utralib::utra::bio_bdma::{SFR_EVENT_STATUS_SFR_EVENT_STATUS, SFR_FLEVEL_PCLK
|
|||
use super::report_api;
|
||||
use crate::*;
|
||||
|
||||
pub fn spi_test() {
|
||||
pub fn spi_test() -> usize {
|
||||
print!("SPI test\r");
|
||||
|
||||
// clear prior test config state
|
||||
|
|
@ -15,7 +15,12 @@ pub fn spi_test() {
|
|||
bio_ss.bio.wo(utra::bio_bdma::SFR_CTRL, 0x0);
|
||||
let code = spi_driver();
|
||||
print!("SPI code length {}\r", code.len());
|
||||
bio_ss.load_code(code, 0);
|
||||
// this test does same code on all machines, with ID-based dispatch to
|
||||
// select which machine runs.
|
||||
bio_ss.load_code(code, 0, BioCore::Core0);
|
||||
bio_ss.load_code(code, 0, BioCore::Core1);
|
||||
bio_ss.load_code(code, 0, BioCore::Core2);
|
||||
bio_ss.load_code(code, 0, BioCore::Core3);
|
||||
|
||||
// configure fifo trigger levels
|
||||
bio_ss.bio.wfo(utra::bio_bdma::SFR_ELEVEL_FIFO_EVENT_LEVEL0, 4);
|
||||
|
|
@ -47,17 +52,18 @@ pub fn spi_test() {
|
|||
| bio_ss.bio.ms(utra::bio_bdma::SFR_EXTCLOCK_EXTCLK_GPIO_3, 9),
|
||||
);
|
||||
|
||||
// start cores 2 & 3
|
||||
bio_ss.bio.wo(utra::bio_bdma::SFR_CTRL, 0xCCC);
|
||||
// start all cores -- core 0 & 1 should "gutter"
|
||||
bio_ss.bio.wo(utra::bio_bdma::SFR_CTRL, 0xFFF);
|
||||
|
||||
let mut i = 0;
|
||||
let mut j = 0;
|
||||
const TEST_LEN: usize = 32;
|
||||
let mut retvals = [0u32; TEST_LEN];
|
||||
loop {
|
||||
// print!("dbg pc: {:x}\r", bio_ss.bio.r(utra::bio_bdma::SFR_DBG2));
|
||||
// fill the FIFO
|
||||
while (((bio_ss.bio.rf(SFR_EVENT_STATUS_SFR_EVENT_STATUS) >> 24) & 0x1) != 0) && (i < TEST_LEN) {
|
||||
// report_api(i as u32 | 0xAA00);
|
||||
// print!(" Tx {:x}\r", i as u32 | 0xAA00);
|
||||
bio_ss.bio.wo(utra::bio_bdma::SFR_TXF0, i as u32 | 0xAA00);
|
||||
i += 1;
|
||||
}
|
||||
|
|
@ -71,6 +77,8 @@ pub fn spi_test() {
|
|||
}
|
||||
}
|
||||
print!("iter ");
|
||||
print!("dbg pc 2: {:x}\r", bio_ss.bio.r(utra::bio_bdma::SFR_DBG2));
|
||||
print!("dbg pc 3: {:x}\r", bio_ss.bio.r(utra::bio_bdma::SFR_DBG3));
|
||||
while j < TEST_LEN {
|
||||
while bio_ss.bio.rf(SFR_FLEVEL_PCLK_REGFIFO_LEVEL1) == 0 {} // wait until there's something there
|
||||
retvals[j] = bio_ss.bio.r(utra::bio_bdma::SFR_RXF1);
|
||||
|
|
@ -78,13 +86,15 @@ pub fn spi_test() {
|
|||
print!("{} ", j);
|
||||
}
|
||||
print!("\r");
|
||||
print!("dbg pc 2: {:x}\r", bio_ss.bio.r(utra::bio_bdma::SFR_DBG2));
|
||||
print!("dbg pc 3: {:x}\r", bio_ss.bio.r(utra::bio_bdma::SFR_DBG3));
|
||||
for (index, &val) in retvals.iter().enumerate() {
|
||||
print!("SPI rbk {:x}\r", val);
|
||||
// the XOR to 0xAAAA is just a mask we threw in to test immediate loads
|
||||
assert!(val == ((0xAA00 | index as u32) ^ 0xAAAA));
|
||||
}
|
||||
|
||||
report_api(0x51C0_600D);
|
||||
print!("==SPI PASS==\r");
|
||||
1
|
||||
}
|
||||
|
||||
// This is written to also test some additional features:
|
||||
|
|
@ -103,17 +113,6 @@ bio_code!(
|
|||
spi_driver,
|
||||
SPI_DRIVER_START,
|
||||
SPI_DRIVER_END,
|
||||
"j 90f",
|
||||
"nop",
|
||||
"j 90f",
|
||||
"nop",
|
||||
"j 90f",
|
||||
"nop",
|
||||
"j 90f",
|
||||
"nop",
|
||||
"retmask:",
|
||||
".word 0x0000AAAA", // just a random mask for testing immediate loads
|
||||
"90:",
|
||||
// dispatch based on machine ID
|
||||
"srli x1, x31, 30",
|
||||
"li x2, 0",
|
||||
|
|
@ -124,10 +123,14 @@ bio_code!(
|
|||
"beq x1, x2, 82f",
|
||||
"li x2, 3",
|
||||
"beq x1, x2, 83f",
|
||||
"retmask:",
|
||||
".align 4",
|
||||
".word 0x0000AAAA", // just a random mask for testing immediate loads
|
||||
"80:", // machine 0
|
||||
"j 80b",
|
||||
"81:", // machine 1
|
||||
"j 81b",
|
||||
".align 4",
|
||||
"82:", // machine 2 - tx on bit 8, clock on bit 9, chip select on bit 10
|
||||
"li x1, 0x700", // setup output mask bits
|
||||
"mv x26, x1", // mask
|
||||
|
|
@ -297,6 +300,7 @@ bio_code!(
|
|||
"mv x20, x0", // meet CS min-high time (if necessary)
|
||||
"beqz x20, 20b", // wait quantum & loop back -- x20 reads back as 0
|
||||
|
||||
".align 4",
|
||||
"83:", // machine 3 - rx on bit 8, clock on bit 9, chip select on bit 10
|
||||
"li x1, 0x700", // setup mask bits
|
||||
"mv x26, x1", // mask
|
||||
|
|
|
|||
|
|
@ -8,12 +8,12 @@ use crate::*;
|
|||
// this test requires manual inspection of the outputs
|
||||
// the GPIO pins should toggle with 0x11, 0x12, 0x13...
|
||||
// at the specified quantum rate of the machine.
|
||||
pub fn hello_world() {
|
||||
pub fn hello_world() -> usize {
|
||||
print!("hello world test\r");
|
||||
let mut bio_ss = BioSharedState::new();
|
||||
let simple_test_code = hello_world_code();
|
||||
// copy code to reset vector for 0th machine
|
||||
bio_ss.load_code(simple_test_code, 0);
|
||||
bio_ss.load_code(simple_test_code, 0, BioCore::Core0);
|
||||
|
||||
// configure & run the 0th machine
|
||||
// /32 clock
|
||||
|
|
@ -21,6 +21,7 @@ pub fn hello_world() {
|
|||
// start the machine
|
||||
bio_ss.bio.wo(utra::bio_bdma::SFR_CTRL, 0x111);
|
||||
print!("===hello world PASS===\r");
|
||||
1
|
||||
}
|
||||
#[rustfmt::skip]
|
||||
bio_code!(hello_world_code, HELLO_START, HELLO_END,
|
||||
|
|
@ -37,13 +38,19 @@ bio_code!(hello_world_code, HELLO_START, HELLO_END,
|
|||
// the GPIO pins should toggle with the following pattern:
|
||||
// 0x41312111, 0x42322212, 0x43332313, etc.
|
||||
// and they should be in sync-lock, no ragged transitions
|
||||
pub fn hello_multiverse() {
|
||||
pub fn hello_multiverse() -> usize {
|
||||
print!("multiverse\r");
|
||||
let mut bio_ss = BioSharedState::new();
|
||||
// stop all the machines, so that code can be loaded
|
||||
bio_ss.bio.wo(utra::bio_bdma::SFR_CTRL, 0x0);
|
||||
let code = multiverse_code();
|
||||
bio_ss.load_code(code, 0);
|
||||
let code0 = multiverse_code0();
|
||||
bio_ss.load_code(code0, 0, BioCore::Core0);
|
||||
let code1 = multiverse_code1();
|
||||
bio_ss.load_code(code1, 0, BioCore::Core1);
|
||||
let code2 = multiverse_code2();
|
||||
bio_ss.load_code(code2, 0, BioCore::Core2);
|
||||
let code3 = multiverse_code3();
|
||||
bio_ss.load_code(code3, 0, BioCore::Core3);
|
||||
|
||||
// configure & run the 0th machine
|
||||
// /32 clock
|
||||
|
|
@ -63,31 +70,13 @@ pub fn hello_multiverse() {
|
|||
// start all the machines, all at once
|
||||
bio_ss.bio.wo(utra::bio_bdma::SFR_CTRL, 0xfff);
|
||||
print!("===multiverse PASS===\r");
|
||||
1
|
||||
}
|
||||
#[rustfmt::skip]
|
||||
bio_code!(multiverse_code, MULTIVERSE_START, MULTIVERSE_END,
|
||||
// Reset vectors for each core are aligned to 4-byte boundaries
|
||||
// As long as the jump target is <2kiB from reset, this will emit
|
||||
// a C-instruction, so it needs padding with a NOP. Unfortunately,
|
||||
// I can't seem to figure out a way to force the assembler to always
|
||||
// encode as uncompressed, so, you have to be aware of the jump destination
|
||||
// for the assembler output to line up according to your expectation :(
|
||||
//
|
||||
// using 'c.j' syntax for the jump causes the assembler to emit an error,
|
||||
// but the code still compiles, so...avoiding that for now. might be a bug,
|
||||
// but I am very not interested in fixing that today.
|
||||
//
|
||||
// Also note that labels can only be numbers from 0-99, and, due to an llvm
|
||||
bio_code!(multiverse_code0, MULTIVERSE0_START, MULTIVERSE0_END,
|
||||
// Note that labels can only be numbers from 0-99, and, due to an llvm
|
||||
// bug, labels made exclusively of 0 or 1 should be avoided because they get
|
||||
// interpreted as binary numbers. dat's some jank in the tank!!
|
||||
"j 90f",
|
||||
"nop",
|
||||
"j 91f",
|
||||
"nop",
|
||||
"j 92f",
|
||||
"nop",
|
||||
"j 93f",
|
||||
"nop",
|
||||
// mach 0 code
|
||||
"90:",
|
||||
// x26 sets the GPIO mask
|
||||
|
|
@ -100,7 +89,10 @@ bio_code!(multiverse_code, MULTIVERSE_START, MULTIVERSE_END,
|
|||
"mv x21, x1",
|
||||
// x20 write causes core to wait until next sync quantum
|
||||
"mv x20, zero",
|
||||
"j 4b",
|
||||
"j 4b"
|
||||
);
|
||||
#[rustfmt::skip]
|
||||
bio_code!(multiverse_code1, MULTIVERSE1_START, MULTIVERSE1_END,
|
||||
// mach 1 code
|
||||
"91:",
|
||||
"li x2, 0xFF00",
|
||||
|
|
@ -110,7 +102,10 @@ bio_code!(multiverse_code, MULTIVERSE_START, MULTIVERSE_END,
|
|||
"add x1, x1, 0x1",
|
||||
"slli x21, x1, 8",
|
||||
"mv x20, zero",
|
||||
"j 5b",
|
||||
"j 5b"
|
||||
);
|
||||
#[rustfmt::skip]
|
||||
bio_code!(multiverse_code2, MULTIVERSE2_START, MULTIVERSE2_END,
|
||||
// mach 2 code
|
||||
"92:",
|
||||
"li x2, 0xFF0000",
|
||||
|
|
@ -120,7 +115,10 @@ bio_code!(multiverse_code, MULTIVERSE_START, MULTIVERSE_END,
|
|||
"add x1, x1, 0x1",
|
||||
"slli x21, x1, 16",
|
||||
"mv x20, zero",
|
||||
"j 6b",
|
||||
"j 6b"
|
||||
);
|
||||
#[rustfmt::skip]
|
||||
bio_code!(multiverse_code3, MULTIVERSE3_START, MULTIVERSE3_END,
|
||||
// mach 3 code
|
||||
"93:",
|
||||
"li x2, 0xFF000000",
|
||||
|
|
@ -141,7 +139,7 @@ bio_code!(multiverse_code, MULTIVERSE_START, MULTIVERSE_END,
|
|||
// but with a glitch before major transitions. The output could
|
||||
// be sync'd locked, but we leave it off for this test so we have
|
||||
// a demo of how things look when it's off.
|
||||
pub fn fifo_basic() {
|
||||
pub fn fifo_basic() -> usize {
|
||||
print!("FIFO basic\r");
|
||||
// clear any prior test config state
|
||||
let mut test_cfg = CSR::new(utra::csrtest::HW_CSRTEST_BASE as *mut u32);
|
||||
|
|
@ -150,8 +148,46 @@ pub fn fifo_basic() {
|
|||
let mut bio_ss = BioSharedState::new();
|
||||
// stop all the machines, so that code can be loaded
|
||||
bio_ss.bio.wo(utra::bio_bdma::SFR_CTRL, 0x0);
|
||||
let code = fifo_basic_code();
|
||||
bio_ss.load_code(code, 0);
|
||||
bio_ss.load_code(fifo_basic0_code(), 0, BioCore::Core0);
|
||||
bio_ss.load_code(fifo_basic1_code(), 0, BioCore::Core1);
|
||||
bio_ss.load_code(fifo_basic2_code(), 0, BioCore::Core2);
|
||||
bio_ss.load_code(fifo_basic3_code(), 0, BioCore::Core3);
|
||||
|
||||
// expect no error
|
||||
match bio_ss.verify_code(&fifo_basic0_code(), 0, BioCore::Core0) {
|
||||
Err(BioError::CodeCheck(at)) => {
|
||||
print!("Core 0 rbk fail at {}\r", at);
|
||||
return 0;
|
||||
}
|
||||
_ => (),
|
||||
}
|
||||
match bio_ss.verify_code(&fifo_basic1_code(), 0, BioCore::Core1) {
|
||||
Err(BioError::CodeCheck(at)) => {
|
||||
print!("Core 1 rbk fail at {}\r", at);
|
||||
return 0;
|
||||
}
|
||||
_ => (),
|
||||
}
|
||||
match bio_ss.verify_code(&fifo_basic2_code(), 0, BioCore::Core2) {
|
||||
Err(BioError::CodeCheck(at)) => {
|
||||
print!("Core 2 rbk fail at {}\r", at);
|
||||
return 0;
|
||||
}
|
||||
_ => (),
|
||||
}
|
||||
match bio_ss.verify_code(&fifo_basic3_code(), 0, BioCore::Core3) {
|
||||
Err(BioError::CodeCheck(at)) => {
|
||||
print!("Core 3 rbk fail at {}\r", at);
|
||||
return 0;
|
||||
}
|
||||
_ => (),
|
||||
}
|
||||
|
||||
// expect error
|
||||
if bio_ss.verify_code(&fifo_basic1_code(), 0, BioCore::Core0).is_ok() {
|
||||
print!("FAIL: Core 0 passed check with false code\r");
|
||||
return 0;
|
||||
}
|
||||
|
||||
// configure & run the 0th machine
|
||||
// / 16. clock
|
||||
|
|
@ -164,17 +200,10 @@ pub fn fifo_basic() {
|
|||
// start all the machines, all at once
|
||||
bio_ss.bio.wo(utra::bio_bdma::SFR_CTRL, 0xfff);
|
||||
print!("===FIFO basic PASS===\r");
|
||||
1
|
||||
}
|
||||
#[rustfmt::skip]
|
||||
bio_code!(fifo_basic_code, FIFO_BASIC_START, FIFO_BASIC_END,
|
||||
"j 90f",
|
||||
"nop",
|
||||
"j 91f",
|
||||
"nop",
|
||||
"j 92f",
|
||||
"nop",
|
||||
"j 93f",
|
||||
"nop",
|
||||
bio_code!(fifo_basic0_code, FIFO_BASIC0_START, FIFO_BASIC0_END,
|
||||
// mach 0 code
|
||||
"90:",
|
||||
"li x2, 0xFFFF",
|
||||
|
|
@ -187,7 +216,10 @@ bio_code!(fifo_basic_code, FIFO_BASIC_START, FIFO_BASIC_END,
|
|||
"mv x19, x1",
|
||||
"mv x20, zero",
|
||||
"mv x1, x19",
|
||||
"j 11b",
|
||||
"j 11b"
|
||||
);
|
||||
#[rustfmt::skip]
|
||||
bio_code!(fifo_basic1_code, FIFO_BASIC1_START, FIFO_BASIC1_END,
|
||||
// mach 1 code
|
||||
"91:",
|
||||
"li x2, 0xFFFF0000",
|
||||
|
|
@ -200,12 +232,18 @@ bio_code!(fifo_basic_code, FIFO_BASIC_START, FIFO_BASIC_END,
|
|||
"mv x18, x1",
|
||||
"mv x20, zero",
|
||||
"mv x1, x18",
|
||||
"j 21b",
|
||||
"j 21b"
|
||||
);
|
||||
#[rustfmt::skip]
|
||||
bio_code!(fifo_basic2_code, FIFO_BASIC2_START, FIFO_BASIC2_END,
|
||||
// mach 2 code
|
||||
"92:",
|
||||
"addi x18, x18, 2", // increment the value in fifo by 2
|
||||
"mv x20, zero",
|
||||
"j 92b",
|
||||
"j 92b"
|
||||
);
|
||||
#[rustfmt::skip]
|
||||
bio_code!(fifo_basic3_code, FIFO_BASIC3_START, FIFO_BASIC3_END,
|
||||
// mach 3 code
|
||||
"93:",
|
||||
"li x2, 0x40000",
|
||||
|
|
@ -228,7 +266,7 @@ bio_code!(fifo_basic_code, FIFO_BASIC_START, FIFO_BASIC_END,
|
|||
//
|
||||
// GPIO outputs are run without snapping in this case, because there is just one
|
||||
// machine updating outputs and no need to do that.
|
||||
pub fn host_fifo_tests() {
|
||||
pub fn host_fifo_tests() -> usize {
|
||||
print!("Host FIFO tests\r");
|
||||
// clear prior test config state
|
||||
let mut test_cfg = CSR::new(utra::csrtest::HW_CSRTEST_BASE as *mut u32);
|
||||
|
|
@ -237,8 +275,8 @@ pub fn host_fifo_tests() {
|
|||
let mut bio_ss = BioSharedState::new();
|
||||
// stop all the machines, so that code can be loaded
|
||||
bio_ss.bio.wo(utra::bio_bdma::SFR_CTRL, 0x0);
|
||||
let code = fifo_host_bitbang();
|
||||
bio_ss.load_code(code, 0);
|
||||
bio_ss.load_code(fifo_host0_bitbang(), 0, BioCore::Core0);
|
||||
bio_ss.load_code(fifo_host1_bitbang(), 0, BioCore::Core1);
|
||||
// reset all the fifos
|
||||
bio_ss.bio.wo(utra::bio_bdma::SFR_FIFO_CLR, 0xF);
|
||||
|
||||
|
|
@ -297,8 +335,9 @@ pub fn host_fifo_tests() {
|
|||
test_cfg.wo(utra::csrtest::WTEST, 0);
|
||||
// stop machine & load code
|
||||
bio_ss.bio.wo(utra::bio_bdma::SFR_CTRL, 0x0);
|
||||
let code = fifo_host_bitbang_level_trig();
|
||||
bio_ss.load_code(code, 0);
|
||||
bio_ss.load_code(fifo_host0_bitbang_level_trig(), 0, BioCore::Core0);
|
||||
bio_ss.load_code(fifo_host1_bitbang_level_trig(), 0, BioCore::Core1);
|
||||
bio_ss.load_code(fifo_host2_bitbang_level_trig(), 0, BioCore::Core2);
|
||||
|
||||
// clear all events
|
||||
bio_ss.bio.wfo(utra::bio_bdma::SFR_EVENT_CLR_SFR_EVENT_CLR, 0xFFFF_FF);
|
||||
|
|
@ -352,17 +391,17 @@ pub fn host_fifo_tests() {
|
|||
print!("stop_check {:x}\r", stop_check);
|
||||
assert!(stop_check == stop_val);
|
||||
print!("===Host FIFO PASS===\r");
|
||||
1
|
||||
}
|
||||
#[rustfmt::skip]
|
||||
bio_code!(fifo_host_bitbang, FIFO_HOST_BITBANG_START, FIFO_HOST_BITBANG_END,
|
||||
"j 90f",
|
||||
"nop",
|
||||
"j 91f",
|
||||
"nop",
|
||||
bio_code!(fifo_host0_bitbang, FIFO_HOST0_BITBANG_START, FIFO_HOST0_BITBANG_END,
|
||||
"90:",
|
||||
"mv x21, x16",
|
||||
"mv x20, zero",
|
||||
"j 90b",
|
||||
"j 90b"
|
||||
);
|
||||
#[rustfmt::skip]
|
||||
bio_code!(fifo_host1_bitbang, FIFO_HOST1_BITBANG_START, FIFO_HOST1_BITBANG_END,
|
||||
"91:",
|
||||
"mv x20, zero",
|
||||
"mv x17, x21",
|
||||
|
|
@ -386,15 +425,9 @@ bio_code!(fifo_host_bitbang, FIFO_HOST_BITBANG_START, FIFO_HOST_BITBANG_END,
|
|||
// - acks core 0 on event bit 3
|
||||
#[rustfmt::skip]
|
||||
bio_code!(
|
||||
fifo_host_bitbang_level_trig,
|
||||
FIFO_HOST_BITBANG_LEVEL_TRIG_START,
|
||||
FIFO_HOST_BITBANG_LEVEL_TRIG_END,
|
||||
"j 90f",
|
||||
"nop",
|
||||
"j 91f",
|
||||
"nop",
|
||||
"j 92f",
|
||||
"nop",
|
||||
fifo_host0_bitbang_level_trig,
|
||||
FIFO_HOST0_BITBANG_LEVEL_TRIG_START,
|
||||
FIFO_HOST0_BITBANG_LEVEL_TRIG_END,
|
||||
"90:", // machine 0
|
||||
"li x2, 0xfeedface",
|
||||
"mv x21, x2", // init gpio to the "i'm here" sentinel
|
||||
|
|
@ -409,7 +442,13 @@ bio_code!(
|
|||
"mv x28, x4", // set the bit that machine 2 is listening to
|
||||
"mv x3, x30", // wait for ack that gpio was sampled
|
||||
"mv x29, x3", // clear the trigger
|
||||
"j 20b",
|
||||
"j 20b"
|
||||
);
|
||||
#[rustfmt::skip]
|
||||
bio_code!(
|
||||
fifo_host1_bitbang_level_trig,
|
||||
FIFO_HOST1_BITBANG_LEVEL_TRIG_START,
|
||||
FIFO_HOST1_BITBANG_LEVEL_TRIG_END,
|
||||
"91:", // machine 1
|
||||
"li x1, 0x1", // event bit 0
|
||||
"mv x27, x1", // set trigger mask
|
||||
|
|
@ -418,7 +457,13 @@ bio_code!(
|
|||
"and x2, x2, x1", // mask event result
|
||||
"mv x29, x2", // clear the event trigger
|
||||
"mv x17, x21", // gpio in -> fifo1
|
||||
"j 21b",
|
||||
"j 21b"
|
||||
);
|
||||
#[rustfmt::skip]
|
||||
bio_code!(
|
||||
fifo_host2_bitbang_level_trig,
|
||||
FIFO_HOST2_BITBANG_LEVEL_TRIG_START,
|
||||
FIFO_HOST2_BITBANG_LEVEL_TRIG_END,
|
||||
"92:", // machine 2
|
||||
"li x2, 0x2", // event bit 1
|
||||
"mv x27, x2", // set trigger mask
|
||||
|
|
@ -442,7 +487,7 @@ struct FifoLevelTestConfig {
|
|||
|
||||
// This can be done without any code running on the machines; the host can
|
||||
// set and observe all fifo levels and triggers directly.
|
||||
pub fn fifo_level_tests() {
|
||||
pub fn fifo_level_tests() -> usize {
|
||||
print!("FIFO level comprehensive\r");
|
||||
// clear prior test config state
|
||||
let mut test_cfg = CSR::new(utra::csrtest::HW_CSRTEST_BASE as *mut u32);
|
||||
|
|
@ -711,10 +756,11 @@ pub fn fifo_level_tests() {
|
|||
bio_ss.bio.wo(irq_mask_reg, 0);
|
||||
}
|
||||
}
|
||||
print!("===FIFO level comprehensive PASS===\r")
|
||||
print!("===FIFO level comprehensive PASS===\r");
|
||||
1
|
||||
}
|
||||
|
||||
pub fn aclk_tests() {
|
||||
pub fn aclk_tests() -> usize {
|
||||
print!("ACLK test\r");
|
||||
// clear any prior test config state
|
||||
let mut test_cfg = CSR::new(utra::csrtest::HW_CSRTEST_BASE as *mut u32);
|
||||
|
|
@ -724,7 +770,7 @@ pub fn aclk_tests() {
|
|||
// stop all the machines, so that code can be loaded
|
||||
bio_ss.bio.wo(utra::bio_bdma::SFR_CTRL, 0x0);
|
||||
let code = aclk_code();
|
||||
bio_ss.load_code(code, 0);
|
||||
bio_ss.load_code(code, 0, BioCore::Core1);
|
||||
|
||||
// configure & run the 0th machine
|
||||
bio_ss.bio.wo(utra::bio_bdma::SFR_QDIV1, 0xA_0000);
|
||||
|
|
@ -751,23 +797,11 @@ pub fn aclk_tests() {
|
|||
|
||||
assert!(results[6] - results[5] == 10); // related to the clock divider
|
||||
print!("===ACLK test PASS===\r");
|
||||
1
|
||||
}
|
||||
|
||||
#[rustfmt::skip]
|
||||
bio_code!(aclk_code, ACLK_START, ACLK_END,
|
||||
"j 90f",
|
||||
"nop",
|
||||
"j 91f",
|
||||
"nop",
|
||||
"j 92f",
|
||||
"nop",
|
||||
"j 93f",
|
||||
"nop",
|
||||
// mach 0 code
|
||||
"90:",
|
||||
"j 90b",
|
||||
// mach 1 code
|
||||
"91:",
|
||||
"mv x17, x31",
|
||||
"mv x17, x31",
|
||||
"mv x17, x31",
|
||||
|
|
@ -777,13 +811,5 @@ bio_code!(aclk_code, ACLK_START, ACLK_END,
|
|||
"mv x20, x0",
|
||||
"mv x17, x31",
|
||||
"mv x20, x0",
|
||||
"mv x17, x31",
|
||||
"40:",
|
||||
"j 40b",
|
||||
// mach 2 code
|
||||
"92:",
|
||||
"j 92b",
|
||||
// mach 3 code
|
||||
"93:",
|
||||
"j 93b"
|
||||
"mv x17, x31"
|
||||
);
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ impl<'a> BioI2C<'a> {
|
|||
bio_ss.bio.wo(utra::bio_bdma::SFR_CTRL, 0x0);
|
||||
let code = i2c_driver();
|
||||
print!("I2C code length: {} bytes\r", code.len());
|
||||
bio_ss.load_code(code, 0);
|
||||
bio_ss.load_code(code, 0, BioCore::Core0);
|
||||
|
||||
if hs {
|
||||
// 1600kHz clock -> 400kHz toggle rate = 0x1F4_0000 @ 800MHz rate FCLK
|
||||
|
|
@ -196,14 +196,6 @@ bio_code!(
|
|||
i2c_driver,
|
||||
I2C_DRIVER_START,
|
||||
I2C_DRIVER_END,
|
||||
"j 90f",
|
||||
"nop",
|
||||
"j 91f",
|
||||
"nop",
|
||||
"j 92f",
|
||||
"nop",
|
||||
"j 93f",
|
||||
"nop",
|
||||
"90:", // machine 0 code
|
||||
"mv x1, x16", // x1 <- initiation command
|
||||
"andi x2, x1, 1", // x2 <- r/w bit. write if 0.
|
||||
|
|
@ -339,12 +331,5 @@ bio_code!(
|
|||
// REPORT
|
||||
"slli x8, x8, 16", // shift NACK count into place
|
||||
"add x18, x7, x8", // x18 <- send ACK + NACK
|
||||
"j 90b", // wait for next command
|
||||
// gutter unused machines
|
||||
"91:",
|
||||
"j 91b",
|
||||
"92:",
|
||||
"j 92b",
|
||||
"93:",
|
||||
"j 93b"
|
||||
"j 90b" // wait for next command
|
||||
);
|
||||
|
|
|
|||
|
|
@ -31,6 +31,8 @@
|
|||
//! - x31 r/- [31:30] -> core ID; [29:0] -> cpu clocks since reset
|
||||
|
||||
#![cfg_attr(feature = "baremetal", no_std)]
|
||||
use core::mem::size_of;
|
||||
|
||||
use utralib::generated::*;
|
||||
|
||||
#[cfg(feature = "tests")]
|
||||
|
|
@ -38,6 +40,15 @@ pub mod bio_tests;
|
|||
|
||||
pub mod i2c;
|
||||
|
||||
#[repr(usize)]
|
||||
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
|
||||
pub enum BioCore {
|
||||
Core0 = 0,
|
||||
Core1 = 1,
|
||||
Core2 = 2,
|
||||
Core3 = 3,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum BioError {
|
||||
/// specified state machine is not valid
|
||||
|
|
@ -46,6 +57,8 @@ pub enum BioError {
|
|||
Oom,
|
||||
/// no more machines available
|
||||
NoFreeMachines,
|
||||
/// Loaded code did not match, first error at argument
|
||||
CodeCheck(usize),
|
||||
}
|
||||
|
||||
pub fn get_id() -> u32 {
|
||||
|
|
@ -71,19 +84,35 @@ pub fn lfsr_next_u32(state: u32) -> u32 {
|
|||
(state << 1) + bit
|
||||
}
|
||||
|
||||
pub const BIO_PRIVATE_MEM_LEN: usize = 4096;
|
||||
|
||||
pub struct BioSharedState {
|
||||
pub bio: CSR<u32>,
|
||||
pub imem_slice: &'static mut [u32],
|
||||
pub imem_slice: [&'static mut [u32]; 4],
|
||||
}
|
||||
impl BioSharedState {
|
||||
#[cfg(feature = "baremetal")]
|
||||
pub fn new() -> Self {
|
||||
// map the instruction memory
|
||||
let imem_slice = unsafe {
|
||||
core::slice::from_raw_parts_mut(
|
||||
utralib::generated::HW_BIO_RAM_MEM as *mut u32,
|
||||
utralib::generated::HW_BIO_RAM_MEM_LEN,
|
||||
)
|
||||
[
|
||||
core::slice::from_raw_parts_mut(
|
||||
utralib::generated::HW_BIO_IMEM0_MEM as *mut u32,
|
||||
HW_BIO_IMEM0_MEM_LEN / size_of::<u32>(),
|
||||
),
|
||||
core::slice::from_raw_parts_mut(
|
||||
utralib::generated::HW_BIO_IMEM1_MEM as *mut u32,
|
||||
HW_BIO_IMEM1_MEM_LEN / size_of::<u32>(),
|
||||
),
|
||||
core::slice::from_raw_parts_mut(
|
||||
utralib::generated::HW_BIO_IMEM2_MEM as *mut u32,
|
||||
HW_BIO_IMEM2_MEM_LEN / size_of::<u32>(),
|
||||
),
|
||||
core::slice::from_raw_parts_mut(
|
||||
utralib::generated::HW_BIO_IMEM3_MEM as *mut u32,
|
||||
HW_BIO_IMEM3_MEM_LEN / size_of::<u32>(),
|
||||
),
|
||||
]
|
||||
};
|
||||
|
||||
BioSharedState { bio: CSR::new(utra::bio_bdma::HW_BIO_BDMA_BASE as *mut u32), imem_slice }
|
||||
|
|
@ -99,36 +128,83 @@ impl BioSharedState {
|
|||
)
|
||||
.unwrap();
|
||||
|
||||
let imem: xous::MemoryRange = xous::syscall::map_memory(
|
||||
xous::MemoryAddress::new(utra::bio_bdma::HW_BIO_RAM_MEM),
|
||||
let imem0 = xous::syscall::map_memory(
|
||||
xous::MemoryAddress::new(utralib::HW_BIO_IMEM0_MEM),
|
||||
None,
|
||||
utra::bio_bdma::HW_BIO_RAM_MEM_LEN,
|
||||
utralib::HW_BIO_IMEM0_MEM_LEN,
|
||||
xous::MemoryFlags::R | xous::MemoryFlags::W,
|
||||
)
|
||||
.unwrap();
|
||||
let imem1 = xous::syscall::map_memory(
|
||||
xous::MemoryAddress::new(utralib::HW_BIO_IMEM1_MEM),
|
||||
None,
|
||||
utralib::HW_BIO_IMEM1_MEM_LEN,
|
||||
xous::MemoryFlags::R | xous::MemoryFlags::W,
|
||||
)
|
||||
.unwrap();
|
||||
let imem2 = xous::syscall::map_memory(
|
||||
xous::MemoryAddress::new(utralib::HW_BIO_IMEM2_MEM),
|
||||
None,
|
||||
utralib::HW_BIO_IMEM2_MEM_LEN,
|
||||
xous::MemoryFlags::R | xous::MemoryFlags::W,
|
||||
)
|
||||
.unwrap();
|
||||
let imem3 = xous::syscall::map_memory(
|
||||
xous::MemoryAddress::new(utralib::HW_BIO_IMEM3_MEM),
|
||||
None,
|
||||
utralib::HW_BIO_IMEM3_MEM_LEN,
|
||||
xous::MemoryFlags::R | xous::MemoryFlags::W,
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
BioSharedState {
|
||||
bio: CSR::new(csr.as_mut_ptr() as *mut u32),
|
||||
imem_slice: unsafe { imem.as_slice_mut() },
|
||||
imem_slice: unsafe {
|
||||
[imem0.as_slice_mut(), imem1.as_slice_mut(), imem2.as_slice_mut(), imem3.as_slice_mut()]
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
pub fn load_code(&mut self, prog: &[u8], offset_bytes: usize) {
|
||||
pub fn load_code(&mut self, prog: &[u8], offset_bytes: usize, core: BioCore) {
|
||||
let offset = offset_bytes / core::mem::size_of::<u32>();
|
||||
for (i, chunk) in prog.chunks(4).enumerate() {
|
||||
if chunk.len() == 4 {
|
||||
let word: u32 = u32::from_le_bytes(chunk.try_into().unwrap());
|
||||
self.imem_slice[i + offset] = word;
|
||||
self.imem_slice[core as usize][i + offset] = word;
|
||||
} else {
|
||||
// copy the last word as a "ragged word"
|
||||
let mut ragged_word = 0;
|
||||
for (j, &b) in chunk.iter().enumerate() {
|
||||
ragged_word |= (b as u32) << (4 - chunk.len() + j);
|
||||
}
|
||||
self.imem_slice[i + offset] = ragged_word;
|
||||
self.imem_slice[core as usize][i + offset] = ragged_word;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn verify_code(&mut self, prog: &[u8], offset_bytes: usize, core: BioCore) -> Result<(), BioError> {
|
||||
let offset = offset_bytes / core::mem::size_of::<u32>();
|
||||
for (i, chunk) in prog.chunks(4).enumerate() {
|
||||
if chunk.len() == 4 {
|
||||
let word: u32 = u32::from_le_bytes(chunk.try_into().unwrap());
|
||||
let rbk = self.imem_slice[core as usize][i + offset];
|
||||
if rbk != word {
|
||||
print!("{:?} expected {:x} got {:x} at {}\r", core, word, rbk, i + offset);
|
||||
return Err(BioError::CodeCheck(i + offset));
|
||||
}
|
||||
} else {
|
||||
// copy the last word as a "ragged word"
|
||||
let mut ragged_word = 0;
|
||||
for (j, &b) in chunk.iter().enumerate() {
|
||||
ragged_word |= (b as u32) << (4 - chunk.len() + j);
|
||||
}
|
||||
if self.imem_slice[core as usize][i + offset] != ragged_word {
|
||||
return Err(BioError::CodeCheck(i + offset));
|
||||
};
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[macro_export]
|
||||
|
|
|
|||
Loading…
Reference in a new issue