pivot spinor implementation

realizing some core assumptions were wrong, so, scrapping and
restarting
This commit is contained in:
bunnie 2021-07-15 23:00:50 +08:00
parent 98c0054d7e
commit 7e7ae82156
10 changed files with 318 additions and 134 deletions

1
Cargo.lock generated
View file

@ -1671,6 +1671,7 @@ checksum = "fe0f37c9e8f3c5a4a66ad655a93c74daac4ad00c441533bf5c6e7990bb42604e"
name = "spinor"
version = "0.1.0"
dependencies = [
"com",
"log",
"log-server",
"num-derive",

Binary file not shown.

View file

@ -13,6 +13,7 @@ xous-names = { path = "../xous-names" }
log = "0.4"
susres = {path = "../susres"}
trng = { path = "../trng" }
com = { path = "../com" }
rkyv = {version = "0.4.3", default-features = false, features = ["const_generics"]}
xous-ipc = { path = "../../xous-ipc" }

View file

@ -1,6 +1,7 @@
pub(crate) const SERVER_NAME_SPINOR: &str = "_SPINOR Hardware Interface Server_";
pub const SPINOR_SIZE_BYTES: u32 = (128 * 1024 * 1024);
pub const SPINOR_SIZE_BYTES: u32 = 128 * 1024 * 1024; // physical size of the device, used for hardware sanity checks on requests
// note: logical lengths of regions are in xous::definitions
#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)]
pub(crate) enum Opcode {
@ -51,10 +52,11 @@ pub struct WriteRegion {
/// length of data to write
pub len: u32,
/// return code
pub result: Option<SpinorResult>,
pub result: Option<SpinorError>,
}
#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Clone, Copy)]
#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Clone, Copy, num_derive::FromPrimitive, num_derive::ToPrimitive)]
pub enum SpinorError {
NoError,
AbortNotErased,

View file

@ -4,7 +4,8 @@ pub mod api;
pub use api::*;
use xous::{CID, send_message, Message};
use num_traits::ToPrimitive;
use num_traits::*;
use xous_ipc::Buffer;
pub struct Spinor {
conn: CID,
@ -53,21 +54,23 @@ impl Spinor {
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))?;
match buf.to_original() {
Some(wr) => {
match buf.to_original::<WriteRegion, _>() {
Ok(wr) => {
if let Some(res) = wr.result {
match res {
SpinorError::NoError => Ok(()),
_ => Err(res)
}
} else {
SpinorError::ImplementationError
Err(SpinorError::ImplementationError)
}
}
_ => SpinorError::ImplementationError
_ => Err(SpinorError::ImplementationError)
}
}
/// REWORK THIS to take the source data, the patch data, and the offset.
/// note: this implementation will write precisely the slice of u8 contained
/// in data starting from start_addr. If the request is not aligned, the
/// operation is "expensive" in that it will make a copy of the misaligned edges,
@ -97,28 +100,28 @@ impl Spinor {
let u8_to_alignment = self.erase_alignment() - (req_addr & align_mask);
if u8_to_alignment < self.erase_alignment() {
// can't align anything, data is smaller than a page
ret = write_page(data, req_addr);
ret = self.write_page(data, req_addr);
} else {
// issue one mis-aligned request first; this will trigger a partial erase and re-write
write_page(data[0..u8_to_alignment as usize], req_addr)?;
self.write_page(&data[0..u8_to_alignment as usize], req_addr)?;
req_addr += u8_to_alignment;
// now send the rest as aligned; this is much more efficient than streaming a bunch of mis-aligned pages
for page in &data[u8_to_alignment as usize..].chunks(self.erase_alignment() as usize) {
write_data(page, req_addr)?;
for page in data[u8_to_alignment as usize..].chunks(self.erase_alignment() as usize).into_iter() {
self.write_page(page, req_addr)?;
req_addr += self.erase_alignment();
}
}
} else {
// the request is aligned, just issue it; the last page, if mis-aligned, might be a little ugly, but nothing we can do about it.
for page in data.chunks(self.erase_alignment() as usize) {
write_data(page, req_addr)?;
self.write_page(page, req_addr)?;
req_addr += self.erase_alignment();
}
}
// release the write lock before exiting
let _ = send_message(self.conn,
Message::new_blocking_scalar(Opcode::ReleaseExclusive, 0, 0, 0, 0)
Message::new_blocking_scalar(Opcode::ReleaseExclusive.to_usize().unwrap(), 0, 0, 0, 0)
).expect("couldn't send ReleaseExclusive message");
ret
}
@ -127,21 +130,24 @@ impl Spinor {
/// at start_addr; if this is not naturally aligned to an erase block, the operation
/// is "expensive" in that it will make a copy of the misaligned sector, erase the
/// sector, and then re-write the data that was not meant to be erased!
pub fn erase(&mut self, start_addr: u32, num_u8: u32) -> SpinorResult {
pub fn erase(&mut self, start_addr: u32, num_u8: u32) -> SpinorError {
if start_addr & (self.erase_alignment() - 1) != 0 {
}
let response = send_message(self.conn,
Message::new_blocking_scalar(Opcode::Erase.to_usize().unwrap(), start_addr as usize, num_u8 as usize, 0, 0)
Message::new_blocking_scalar(Opcode::EraseRegion.to_usize().unwrap(), start_addr as usize, num_u8 as usize, 0, 0)
).expect("Couldn't send erase command");
if let xous::Result::Scalar1(result) = response {
match FromPrimitive::from_usize(result) {
Some(r) => r,
None => {
log::error!("Couldn't transform return enum: {:?}", result);
SpinorResult::InternalError
SpinorError::ImplementationError
},
}
} else {
log::error!("unexpected return structure: {:#?}", response);
SpinorResult::InternalError
SpinorError::ImplementationError
}
}

View file

@ -4,28 +4,73 @@
mod api;
use api::*;
use num_traits::{ToPrimitive, FromPrimitive};
use num_traits::*;
use xous_ipc::Buffer;
use xous::msg_blocking_scalar_unpack;
use xous::{msg_blocking_scalar_unpack, msg_scalar_unpack};
use core::sync::atomic::{AtomicBool, Ordering};
/*
OK, we have two approaches to doing this block.
1. we own all the read pages, and third party blocks send
requests to us to patch areas
2. we own nothing, and we can only patch areas that are pre-aligned
to word boundaries
We should do (2). Owning everything sucks for everything else.
However, the lib.rs side would be able to take a &[u8] that
represents the readable area, and then another &[u8] that represents
the data we want patched. And then it can format the requests to the
spinor block such that everything is aligned.
*/
#[cfg(target_os = "none")]
mod implementation {
use utralib::generated::*;
use crate::api::*;
use log::info;
use susres::{RegManager, RegOrField, SuspendResume};
use core::sync::atomic::{AtomicBool, AtomicU32, Ordering};
use num_traits::*;
/// TODO: figure out how to make spinor calls "safe"
enum FlashOp {
EraseSector(u32), // 4k sector
WritePage(u32, [u8; 256], u8), // page, data, len
ReadId,
}
static SPINOR_RUNNING: AtomicBool = AtomicBool::new(false);
static SPINOR_RESULT: AtomicU32 = AtomicU32::new(0);
fn spinor_safe_context(_irq_no: usize, arg: *mut usize) {
let spinor = unsafe { &mut *(arg as *mut Spinor) };
let mut result = 0;
match spinor.cur_op {
Some(FlashOp::EraseSector(sector)) => {
},
Some(FlashOp::WritePage(page, data, len)) => {
},
Some(FlashOp::ReadId) => {
let upper = flash_rdid(&mut spinor.csr, 2);
let lower = flash_rdid(&mut spinor.csr, 1);
// re-assemble the ID word from the duplicated bytes read
result = (lower & 0xFF) | ((lower >> 8) & 0xFF00) | (upper & 0xFF_0000);
},
None => {
panic!("Improper entry to SPINOR safe context.");
}
}
spinor.cur_op = None;
SPINOR_RESULT.store(result, Ordering::Relaxed);
spinor.softirq.wfo(utra::spinor_soft_int::EV_PENDING_SPINOR_INT, 1);
SPINOR_RUNNING.store(false, Ordering::Relaxed);
}
/// TODO: write ECC error handler on the other side
fn ecc_handler(_irq_no: usize, arg: *mut usize) {
let spinor = unsafe { &mut *(arg as *mut Spinor) };
@ -38,12 +83,110 @@ mod implementation {
spinor.csr.wfo(utra::spinor::EV_PENDING_ECC_ERROR, 1);
}
fn flash_rdsr(csr: &mut utralib::CSR<u32>, lock_reads: u32) -> u32 {
csr.wfo(utra::spinor::CMD_ARG_CMD_ARG, 0);
csr.wo(utra::spinor::COMMAND,
csr.ms(utra::spinor::COMMAND_EXEC_CMD, 1)
| csr.ms(utra::spinor::COMMAND_LOCK_READS, lock_reads)
| csr.ms(utra::spinor::COMMAND_CMD_CODE, 0x05) // RDSR
| csr.ms(utra::spinor::COMMAND_DUMMY_CYCLES, 4)
| csr.ms(utra::spinor::COMMAND_DATA_WORDS, 1)
| csr.ms(utra::spinor::COMMAND_HAS_ARG, 1)
);
while csr.rf(utra::spinor::STATUS_WIP) != 0 {}
csr.r(utra::spinor::CMD_RBK_DATA)
}
fn flash_rdscur(csr: &mut utralib::CSR<u32>) -> u32 {
csr.wfo(utra::spinor::CMD_ARG_CMD_ARG, 0);
csr.wo(utra::spinor::COMMAND,
csr.ms(utra::spinor::COMMAND_EXEC_CMD, 1)
| csr.ms(utra::spinor::COMMAND_LOCK_READS, 1)
| csr.ms(utra::spinor::COMMAND_CMD_CODE, 0x2B) // RDSCUR
| csr.ms(utra::spinor::COMMAND_DUMMY_CYCLES, 4)
| csr.ms(utra::spinor::COMMAND_DATA_WORDS, 1)
| csr.ms(utra::spinor::COMMAND_HAS_ARG, 1)
);
while csr.rf(utra::spinor::STATUS_WIP) != 0 {}
csr.r(utra::spinor::CMD_RBK_DATA)
}
fn flash_rdid(csr: &mut utralib::CSR<u32>, offset: u32) -> u32 {
csr.wfo(utra::spinor::CMD_ARG_CMD_ARG, 0);
csr.wo(utra::spinor::COMMAND,
csr.ms(utra::spinor::COMMAND_EXEC_CMD, 1)
| csr.ms(utra::spinor::COMMAND_CMD_CODE, 0x9f) // RDID
| csr.ms(utra::spinor::COMMAND_DUMMY_CYCLES, 4)
| csr.ms(utra::spinor::COMMAND_DATA_WORDS, offset) // 2 -> 0x3b3b8080, // 1 -> 0x8080c2c2
| csr.ms(utra::spinor::COMMAND_HAS_ARG, 1)
);
while csr.rf(utra::spinor::STATUS_WIP) != 0 {}
csr.r(utra::spinor::CMD_RBK_DATA)
}
fn flash_wren(csr: &mut utralib::CSR<u32>) {
csr.wfo(utra::spinor::CMD_ARG_CMD_ARG, 0);
csr.wo(utra::spinor::COMMAND,
csr.ms(utra::spinor::COMMAND_EXEC_CMD, 1)
| csr.ms(utra::spinor::COMMAND_CMD_CODE, 0x06) // WREN
| csr.ms(utra::spinor::COMMAND_LOCK_READS, 1)
);
while csr.rf(utra::spinor::STATUS_WIP) != 0 {}
}
fn flash_wrdi(csr: &mut utralib::CSR<u32>) {
csr.wfo(utra::spinor::CMD_ARG_CMD_ARG, 0);
csr.wo(utra::spinor::COMMAND,
csr.ms(utra::spinor::COMMAND_EXEC_CMD, 1)
| csr.ms(utra::spinor::COMMAND_CMD_CODE, 0x04) // WRDI
| csr.ms(utra::spinor::COMMAND_LOCK_READS, 1)
);
while csr.rf(utra::spinor::STATUS_WIP) != 0 {}
}
fn flash_se4b(csr: &mut utralib::CSR<u32>, sector_address: u32) {
csr.wfo(utra::spinor::CMD_ARG_CMD_ARG, sector_address);
csr.wo(utra::spinor::COMMAND,
csr.ms(utra::spinor::COMMAND_EXEC_CMD, 1)
| csr.ms(utra::spinor::COMMAND_CMD_CODE, 0x21) // SE4B
| csr.ms(utra::spinor::COMMAND_HAS_ARG, 1)
| csr.ms(utra::spinor::COMMAND_LOCK_READS, 1)
);
while csr.rf(utra::spinor::STATUS_WIP) != 0 {}
}
fn flash_be4b(csr: &mut utralib::CSR<u32>, block_address: u32) {
csr.wfo(utra::spinor::CMD_ARG_CMD_ARG, block_address);
csr.wo(utra::spinor::COMMAND,
csr.ms(utra::spinor::COMMAND_EXEC_CMD, 1)
| csr.ms(utra::spinor::COMMAND_CMD_CODE, 0xdc) // BE4B
| csr.ms(utra::spinor::COMMAND_HAS_ARG, 1)
| csr.ms(utra::spinor::COMMAND_LOCK_READS, 1)
);
while csr.rf(utra::spinor::STATUS_WIP) != 0 {}
}
fn flash_pp4b(csr: &mut utralib::CSR<u32>, address: u32, data_bytes: u32) {
csr.wfo(utra::spinor::CMD_ARG_CMD_ARG, address);
csr.wo(utra::spinor::COMMAND,
csr.ms(utra::spinor::COMMAND_EXEC_CMD, 1)
| csr.ms(utra::spinor::COMMAND_CMD_CODE, 0x12) // PP4B
| csr.ms(utra::spinor::COMMAND_HAS_ARG, 1)
| csr.ms(utra::spinor::COMMAND_DATA_WORDS, data_bytes / 2)
| csr.ms(utra::spinor::COMMAND_LOCK_READS, 1)
);
while csr.rf(utra::spinor::STATUS_WIP) != 0 {}
}
pub struct Spinor {
id: u32,
handler_conn: xous::CID,
csr: utralib::CSR<u32>,
susres: RegManager::<{utra::spinor::SPINOR_NUMREGS}>,
softirq: utralib::CSR<u32>,
ops_count: u32, // tracks total ops done; also serves as a delay to ensure that the WIP bit updates before being polled
cur_op: Option<FlashOp>,
ticktimer: ticktimer_server::Ticktimer,
// TODO: refactor ecup command to use spinor to operate the reads
}
impl Spinor {
@ -64,11 +207,13 @@ mod implementation {
.expect("couldn't map SPINOR soft interrupt CSR range");
let mut spinor = Spinor {
id: 0,
handler_conn,
csr: CSR::new(csr.as_mut_ptr() as *mut u32),
softirq: CSR::new(softirq.as_mut_ptr() as *mut u32),
susres: RegManager::new(csr.as_mut_ptr() as *mut u32),
ops_count: 0,
cur_op: None,
ticktimer: ticktimer_server::Ticktimer::new().unwrap(),
};
xous::claim_interrupt(
@ -91,9 +236,35 @@ mod implementation {
spinor.susres.push_fixed_value(RegOrField::Reg(utra::spinor::EV_PENDING), 0xFFFF_FFFF);
spinor.susres.push(RegOrField::Reg(utra::spinor::EV_ENABLE), None);
// now populate the id field
spinor.cur_op = Some(FlashOp::ReadId);
SPINOR_RUNNING.store(true, Ordering::Relaxed);
spinor.softirq.wfo(utra::spinor_soft_int::SOFTINT_SOFTINT, 1);
while SPINOR_RUNNING.load(Ordering::Relaxed) {}
spinor.id = SPINOR_RESULT.load(Ordering::Relaxed);
spinor
}
/// changes into the spinor interrupt handler context, which is "safe" for ROM operations because we guarantee
/// we don't touch the SPINOR block inside that interrupt context
fn change_context(&mut self) -> u32 {
if self.cur_op.is_none() {
log::error!("change_context called with no spinor op set. This is an internal error...panicing!");
panic!("change_context called with no spinor op set.");
}
self.ticktimer.ping_wdt();
SPINOR_RUNNING.store(true, Ordering::Relaxed);
self.softirq.wfo(utra::spinor_soft_int::SOFTINT_SOFTINT, 1);
while SPINOR_RUNNING.load(Ordering::Relaxed) {
// there is no timeout condition that makes sense. If we're in a very long flash op -- and they can take hundreds of ms --
// simply timing out and trying to move on could lead to hardware damage as we'd be accessing a ROM that is in progress.
// in other words: if the flash memory is broke, you're broke too, ain't nobody got time for that.
}
self.ticktimer.ping_wdt();
SPINOR_RESULT.load(Ordering::Relaxed)
}
pub fn write_region(&mut self, wr: &mut WriteRegion) {
if wr.start + wr.len > SPINOR_SIZE_BYTES {
wr.result = Some(SpinorError::InvalidRequest);
@ -102,120 +273,67 @@ mod implementation {
}
pub fn erase_region(&mut self, start_adr: u32, num_u8: u32) -> SpinorError {
let mut erased = 0;
let blocksize;
if num_u8 - erased > 4096 {
blocksize = 4096;
} else {
blocksize = 65536;
}
loop {
flash_wren()?;
let status = flash_rdsr(1)?;
// println!("WREN: FLASH status register: 0x{:08x}", status);
if status & 0x02 != 0 {
break;
}
}
if blocksize <= 4096 {
flash_se4b(addr + erased as u32)?;
} else {
flash_be4b(addr + erased as u32)?;
}
erased += blocksize;
loop {
let status = flash_rdsr(1)?;
// println!("BE4B: FLASH status register: 0x{:08x}", status);
if status & 0x01 == 0 {
break;
}
}
let result = flash_rdscur()?;
// println!("erase result: 0x{:08x}", result);
if result & 0x60 != 0 {
error!("E_FAIL/P_FAIL set, programming may have failed.")
}
if flash_rdsr(1)? & 0x02 != 0 {
flash_wrdi()?;
loop {
let status = flash_rdsr(1)?;
// println!("WRDI: FLASH status register: 0x{:08x}", status);
if status & 0x02 == 0 {
break;
}
}
}
SpinorError::NoError
}
pub fn suspend(&mut self) {
self.susres_manager.suspend();
self.susres.suspend();
}
pub fn resume(&mut self) {
self.susres_manager.resume();
self.susres.resume();
self.softirq.wfo(utra::spinor_soft_int::EV_PENDING_SPINOR_INT, 1);
self.softirq.wfo(utra::spinor_soft_int::EV_ENABLE_SPINOR_INT, 1);
}
fn flash_rdsr(&mut self, lock_reads: u32) -> u32 {
self.csr.wfo(utra::spinor::CMD_ARG_CMD_ARG, 0);
self.csr.wo(utra::spinor::COMMAND,
self.csr.ms(utra::spinor::COMMAND_EXEC_CMD, 1)
| self.csr.ms(utra::spinor::COMMAND_LOCK_READS, lock_reads)
| self.csr.ms(utra::spinor::COMMAND_CMD_CODE, 0x05) // RDSR
| self.csr.ms(utra::spinor::COMMAND_DUMMY_CYCLES, 4)
| self.csr.ms(utra::spinor::COMMAND_DATA_WORDS, 1)
| self.csr.ms(utra::spinor::COMMAND_HAS_ARG, 1)
);
self.ops_count += 1; // count number of ops performed; also delays polling of WIP to ensure the command machine has time to respond
while self.csr.rf(utra::spinor::STATUS_WIP) != 0 {}
self.csr.r(utra::spinor::CMD_RBK_DATA)
}
fn flash_rdscur(&mut self) -> u32 {
self.csr.wfo(utra::spinor::CMD_ARG_CMD_ARG, 0);
self.csr.wo(utra::spinor::COMMAND,
self.csr.ms(utra::spinor::COMMAND_EXEC_CMD, 1)
| self.csr.ms(utra::spinor::COMMAND_LOCK_READS, 1)
| self.csr.ms(utra::spinor::COMMAND_CMD_CODE, 0x2B) // RDSCUR
| self.csr.ms(utra::spinor::COMMAND_DUMMY_CYCLES, 4)
| self.csr.ms(utra::spinor::COMMAND_DATA_WORDS, 1)
| self.csr.ms(utra::spinor::COMMAND_HAS_ARG, 1)
);
self.ops_count += 1;
while self.csr.rf(utra::spinor::STATUS_WIP) != 0 {}
self.csr.r(utra::spinor::CMD_RBK_DATA)
}
fn flash_rdid(&mut self, offset: u32) -> u32 {
self.csr.wfo(utra::spinor::CMD_ARG_CMD_ARG, 0);
self.csr.wo(utra::spinor::COMMAND,
self.csr.ms(utra::spinor::COMMAND_EXEC_CMD, 1)
| self.csr.ms(utra::spinor::COMMAND_CMD_CODE, 0x9f) // RDID
| self.csr.ms(utra::spinor::COMMAND_DUMMY_CYCLES, 4)
| self.csr.ms(utra::spinor::COMMAND_DATA_WORDS, offset) // 2 -> 0x3b3b8080, // 1 -> 0x8080c2c2
| self.csr.ms(utra::spinor::COMMAND_HAS_ARG, 1)
);
self.ops_count += 1;
while self.csr.rf(utra::spinor::STATUS_WIP) != 0 {}
self.csr.r(utra::spinor::CMD_RBK_DATA)
}
fn flash_wren(&mut self) {
self.csr.wfo(utra::spinor::CMD_ARG_CMD_ARG, 0);
self.csr.wo(utra::spinor::COMMAND,
self.csr.ms(utra::spinor::COMMAND_EXEC_CMD, 1)
| self.csr.ms(utra::spinor::COMMAND_CMD_CODE, 0x06) // WREN
| self.csr.ms(utra::spinor::COMMAND_LOCK_READS, 1)
);
self.ops_count += 1;
while self.csr.rf(utra::spinor::STATUS_WIP) != 0 {}
}
fn flash_wrdi(&mut self) {
self.csr.wfo(utra::spinor::CMD_ARG_CMD_ARG, 0);
self.csr.wo(utra::spinor::COMMAND,
self.csr.ms(utra::spinor::COMMAND_EXEC_CMD, 1)
| self.csr.ms(utra::spinor::COMMAND_CMD_CODE, 0x04) // WRDI
| self.csr.ms(utra::spinor::COMMAND_LOCK_READS, 1)
);
self.ops_count += 1;
while self.csr.rf(utra::spinor::STATUS_WIP) != 0 {}
}
fn flash_se4b(&mut self, sector_address: u32) {
self.csr.wfo(utra::spinor::CMD_ARG_CMD_ARG, sector_address);
self.csr.wo(utra::spinor::COMMAND,
self.csr.ms(utra::spinor::COMMAND_EXEC_CMD, 1)
| self.csr.ms(utra::spinor::COMMAND_CMD_CODE, 0x21) // SE4B
| self.csr.ms(utra::spinor::COMMAND_HAS_ARG, 1)
| self.csr.ms(utra::spinor::COMMAND_LOCK_READS, 1)
);
self.ops_count += 1;
while self.csr.rf(utra::spinor::STATUS_WIP) != 0 {}
}
fn flash_be4b(&mut self, block_address: u32) {
self.csr.wfo(utra::spinor::CMD_ARG_CMD_ARG, block_address);
self.csr.wo(utra::spinor::COMMAND,
self.csr.ms(utra::spinor::COMMAND_EXEC_CMD, 1)
| self.csr.ms(utra::spinor::COMMAND_CMD_CODE, 0xdc) // BE4B
| self.csr.ms(utra::spinor::COMMAND_HAS_ARG, 1)
| self.csr.ms(utra::spinor::COMMAND_LOCK_READS, 1)
);
self.ops_count += 1;
while self.csr.rf(utra::spinor::STATUS_WIP) != 0 {}
}
fn flash_pp4b(&mut self, address: u32, data_bytes: u32) {
self.csr.wfo(utra::spinor::CMD_ARG_CMD_ARG, address);
self.csr.wo(utra::spinor::COMMAND,
self.csr.ms(utra::spinor::COMMAND_EXEC_CMD, 1)
| self.csr.ms(utra::spinor::COMMAND_CMD_CODE, 0x12) // PP4B
| self.csr.ms(utra::spinor::COMMAND_HAS_ARG, 1)
| self.csr.ms(utra::spinor::COMMAND_DATA_WORDS, data_bytes / 2)
| self.csr.ms(utra::spinor::COMMAND_LOCK_READS, 1)
);
self.ops_count += 1;
while self.csr.rf(utra::spinor::STATUS_WIP) != 0 {}
}
}
}
@ -303,7 +421,8 @@ fn xmain() -> ! {
let spinor_sid = xns.register_name(api::SERVER_NAME_SPINOR, Some(2)).expect("can't register server");
log::trace!("registered with NS -- {:?}", spinor_sid);
let mut spinor = Spinor::new();
let handler_conn = xous::connect(spinor_sid).expect("couldn't create interrupt handler callback connection");
let mut spinor = Spinor::new(handler_conn);
log::trace!("ready to accept requests");
@ -314,6 +433,7 @@ fn xmain() -> ! {
xous::create_thread_4(susres_thread, sid0 as usize, sid1 as usize, sid2 as usize, sid3 as usize).expect("couldn't start susres handler thread");
let mut client_id: Option<[u32; 4]> = None;
let mut ecc_errors: [Option<u32>; 4] = [None, None, None, None]; // just record the first few errors, until we can get `std` and a convenient Vec/Queue
loop {
let mut msg = xous::receive_message(spinor_sid).unwrap();
@ -365,6 +485,23 @@ fn xmain() -> ! {
}
buffer.replace(wr).expect("couldn't return response code to WriteRegion");
},
Some(Opcode::EccError) => msg_scalar_unpack!(msg, address, _overflow, _, _, {
// just some stand-in code -- should probably do something more clever, e.g. a rolling log
// plus some error handling callback. But this is in the distant future once we have enough
// of a system to eventually create such errors...
log::error!("ECC error reported at 0x{:x}", address);
let mut saved = false;
for item in ecc_errors.iter_mut() {
if item.is_none() {
*item = Some(address as u32);
saved = true;
break;
}
}
if !saved {
log::error!("ran out of slots to record ECC errors");
}
}),
None => {
log::error!("couldn't convert opcode");
break

View file

@ -11,4 +11,7 @@ pub(crate) enum Opcode {
/// Suspend/resume callback
SuspendResume = 3,
/// force a WDT update
PingWdt = 4,
}

View file

@ -38,6 +38,12 @@ impl Ticktimer {
0, 0, 0)
).map(|_| ())
}
pub fn ping_wdt(&self) {
send_message(self.conn,
xous::Message::new_scalar(api::Opcode::PingWdt.to_usize().unwrap(), 0, 0, 0, 0)
).expect("Couldn't send WDT ping");
}
}
use core::sync::atomic::{AtomicU32, Ordering};
static REFCOUNT: AtomicU32 = AtomicU32::new(0);

View file

@ -551,6 +551,9 @@ fn xmain() -> ! {
susres.suspend_until_resume(token).expect("couldn't execute suspend/resume");
ticktimer.resume();
}),
Some(api::Opcode::PingWdt) => {
ticktimer.reset_wdt();
},
None => {
error!("couldn't convert opcode");
break

View file

@ -11,10 +11,27 @@ pub type Connection = usize;
pub const MAX_CID: usize = 34;
pub const SOC_REGION_LOC: u32 = 0x2000_0000;
pub const SOC_MAIN_GW_LOC: u32 = 0x2000_0000;
pub const SOC_MAIN_GW_LEN: u32 = 0x0028_0000;
pub const SOC_SEC_GW_LOC: u32 = 0x2028_0000;
pub const SOC_SEC_GW_LEN: u32 = 0x0028_0000;
pub const LOADER_LOC: u32 = 0x2050_0000;
pub const LOADER_LEN: u32 = 0x0048_0000;
pub const KERNEL_LOC: u32 = 0x2098_0000;
pub const KERNEL_LEN: u32 = 0x0038_0000;
pub const SOC_REGION_LEN: u32 = 0x00D0_0000;
pub const PDDB_LOC: u32 = 0x20D0_0000;
pub const PDDB_LEN: u32 = 0x0530_0000; // this reserves space for testing structures
// pub const PDDB_LEN: u32 = 0x0728_0000; // length without testing structure
pub const EC_REGION_LOC: u32 = 0x27F8_0000;
pub const EC_WF200_PKG_LOC: u32 = 0x27F8_0000;
pub const EC_WF200_PKG_LEN: u32 = 0x4_E000;
pub const EC_FW_PKG_LOC: u32 = 0x27FC_E000;
pub const EC_FW_PKG_LEN: u32 = 0x3_2000;
pub const EC_WF200_PKG_LEN: u32 = 0x0004_E000;
pub const EC_FW_PKG_LOC: u32 = 0x27FC_E000;
pub const EC_FW_PKG_LEN: u32 = 0x0003_2000;
pub const EC_REGION_LEN: u32 = 0x0008_0000;
#[derive(Debug, PartialEq, Eq, Ord, PartialOrd, Copy, Clone)]
pub struct MessageSender {
@ -622,6 +639,14 @@ impl MemoryRange {
MemoryRange { addr, size }
}
pub fn addr_in_range(&self, addr: usize) -> bool {
if (addr >= self.addr) && (add < (self.addr + self.size)) {
true
} else {
false
}
}
pub fn len(&self) -> usize {
self.size.get()
}