add cbo.flush support for vexii targets

Spinor is the one location where memory changes out "from underneath
the CPU" in a cacheable region. This happens when we update a block
of FLASH.

Vex-ii has a physically tagged d-cache, but the cbo.flush instruction
needs the *virtual* address to be passed (it then goes through a page
walk or TLB lookup to resolve the tag). The virtual address only
exists and can be correctly resolved to a physical address in the
process space of the owner of the region that maps to the SPINOR
FLASH. Thus, we introduce a flush routine in the lib.rs side that
calls the cbo.flush instruction on every line that has been potentially
modified by the flash write routine.

Note that cbo.flush is not yet natively supported by Rust stable,
so it's coded as a series of hex words fixed to a given register (a0)
to avoid introducing a nightly dependency. Once the cbo.flush
assembly instructions stabilize we can make the assembly read more
nicely, but functionally it should compile to exactly the same code.
This commit is contained in:
bunnie 2025-07-21 19:04:59 +08:00
parent 77d7094d3b
commit 6eaf3501bd
3 changed files with 69 additions and 7 deletions

View file

@ -34,6 +34,7 @@ rand = "0.8.5"
[features]
precursor = ["utralib/precursor"]
vexii-test = []
hosted = ["utralib/hosted"]
renode = ["utralib/renode"]
extra_flush = []

View file

@ -18,6 +18,15 @@ use num_traits::*;
use xous::{CID, Message, send_message};
use xous_ipc::Buffer;
pub unsafe fn flush_block(addr: usize) {
core::arch::asm!(
"mv a0, {addr}",
".word 0x0025200f", /* cbo.flush 0(a0) */
addr = in(reg) addr,
out("a0") _, // clobber a0; without this, the compiler can't know that a0 actually "mattered"
);
}
#[derive(Debug)]
pub struct Spinor {
conn: CID,
@ -100,10 +109,45 @@ impl Spinor {
}
#[cfg(not(test))]
fn send_write_region(&self, wr: &WriteRegion) -> Result<(), SpinorError> {
fn send_write_region(&self, wr: &WriteRegion, _sector: &[u8]) -> Result<(), SpinorError> {
let mut buf = Buffer::into_buf(*wr).or(Err(SpinorError::IpcError))?;
buf.lend_mut(self.conn, Opcode::WriteRegion.to_u32().unwrap()).or(Err(SpinorError::IpcError))?;
// vexii requires virtually addressed region to be flushed. Sector contains the virtual address range
// to be flushed. Therefore, the cache flush routine needs to end up in the lib.rs side of things,
// to be called upon return from the spinor server's successful write of the region.
#[cfg(feature = "vexii-test")]
{
const VEXII_CACHE_LINE_WIDTH_BYTES: usize = 64;
let unaligned_start = _sector.as_ptr() as usize;
let aligned_start = unaligned_start & !(VEXII_CACHE_LINE_WIDTH_BYTES - 1);
let unaligned_len = _sector.len();
// add in the extra bytes we need at the "start" to round down to a cache line on the start
let partially_aligned_len = unaligned_len + (unaligned_start - aligned_start);
// add in the extra bytes we need at the "end" to round up to end at a cache line
let aligned_len = (partially_aligned_len + (VEXII_CACHE_LINE_WIDTH_BYTES - 1))
& !(VEXII_CACHE_LINE_WIDTH_BYTES - 1);
log::debug!(
"Flushing from {:x}-{:x} -> {:x}-{:x}",
unaligned_start,
unaligned_start + unaligned_len,
aligned_start,
aligned_start + aligned_len
);
// now use cbo.flush on each line - this is coded as binary because Rust still requires
// nightly to understand cbo.flush.
for i in (aligned_start..aligned_start + aligned_len).step_by(VEXII_CACHE_LINE_WIDTH_BYTES) {
// in any case, don't run past the length of the allocated area - this will cause a page fault
if i < unaligned_start + unaligned_len {
unsafe {
flush_block(i);
}
} else {
log::info!("Ignoring flush overrun @ {:x}", i);
}
}
}
match buf.to_original::<WriteRegion, _>() {
Ok(wr) => {
if let Some(res) = wr.result {
@ -120,7 +164,7 @@ impl Spinor {
}
#[cfg(test)]
fn send_write_region(&self, wr: &WriteRegion) -> Result<(), SpinorError> {
fn send_write_region(&self, wr: &WriteRegion, _sector_dummy: &[u8]) -> Result<(), SpinorError> {
let mut i = 0;
if !wr.clean_patch {
assert!(
@ -241,7 +285,7 @@ impl Spinor {
/// lazy and you just send a large amount of unchanged data with a couple small changes scattered
/// about, this will not be "smart" about it and do a diff and optimally patch sub-regions. It
/// will erase and re-write the entire region included in the patch. It must also be a multiple of
/// two u8s in length, because the DDR interface can only tranfer even multiples of bytes.
/// two u8s in length, because the DDR interface can only transfer even multiples of bytes.
/// `patch_index` is the offset relative to the base address of `region` to patch. It is *not* relative to
/// the base of FLASH, it is relative to the base of `region`. You can think of it as the index into
/// the `region` slice where the patch data should go. patch_index /can/ have an odd byte offset,
@ -365,7 +409,7 @@ impl Spinor {
wr.start = patch_start
.expect("check region did not intersect patch region; this shouldn't be possible.");
wr.len = data_index as u32;
ret = self.send_write_region(&wr);
ret = self.send_write_region(&wr, sector);
if ret.is_err() {
break;
}
@ -403,7 +447,7 @@ impl Spinor {
// if the requested patch data happens to be identical to the existing data already, don't
// even send the request.
if dirty {
ret = self.send_write_region(&wr);
ret = self.send_write_region(&wr, sector);
if ret.is_err() {
break; // abort fast if we encounter an error
}
@ -509,7 +553,7 @@ mod tests {
wr.data[2] = 0xCC;
wr.data[3] = 0xDD;
let mut spinor = Spinor::new();
let ret = spinor.send_write_region(&wr);
let ret = spinor.send_write_region(&wr, &[0]);
assert!(ret.is_ok(), "spinor write returned an error");
for (addr, &byte) in EMU_FLASH.lock().unwrap().iter().enumerate() {
@ -538,7 +582,7 @@ mod tests {
wr.data[8] = 0x3;
wr.data[9] = 0x4;
wr.len = 10;
let ret = spinor.send_write_region(&wr);
let ret = spinor.send_write_region(&wr, &[0]);
assert!(ret.is_ok(), "spinor write returned an error");
for (addr, &byte) in EMU_FLASH.lock().unwrap().iter().enumerate() {

View file

@ -570,6 +570,7 @@ mod implementation {
/// Not sure why :-/, but, I stopped caring because ".word 0x500F" works!
#[inline]
fn flush_dcache(&self, _start: u32, _len: u32) {
#[cfg(not(feature = "vexii-test"))]
unsafe {
#[rustfmt::skip]
core::arch::asm!(
@ -585,6 +586,22 @@ mod implementation {
"nop",
);
}
#[cfg(feature = "vexii-test")]
unsafe {
// fence.i / fence invalidates only i-cache, and syncs write-back of d-cache but
// d-cache is not invalidated. We need to explicitly invalidate d-cache range, which
// means we need to know what addresses we're updating. The arguments to the flush
// instruction need to be virtual addresses in the process space of the process
// that might be reading the data. Thus, we do not implement the invalidation here,
// but instead we do it in the lib.rs file of the spinor crate, so that the caller
// is doing the invalidation within their address space after interactions with the
// spinor server have occurred.
#[rustfmt::skip]
core::arch::asm!(
"fence.i",
"fence",
);
}
// augment with manual flushing, because the above instruction didn't seem to do the trick??
#[cfg(feature = "extra_flush")]
{