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" name = "spinor"
version = "0.1.0" version = "0.1.0"
dependencies = [ dependencies = [
"com",
"log", "log",
"log-server", "log-server",
"num-derive", "num-derive",

Binary file not shown.

View file

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

View file

@ -1,6 +1,7 @@
pub(crate) const SERVER_NAME_SPINOR: &str = "_SPINOR Hardware Interface Server_"; 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)] #[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)]
pub(crate) enum Opcode { pub(crate) enum Opcode {
@ -51,10 +52,11 @@ pub struct WriteRegion {
/// length of data to write /// length of data to write
pub len: u32, pub len: u32,
/// return code /// 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 { pub enum SpinorError {
NoError, NoError,
AbortNotErased, AbortNotErased,

View file

@ -4,7 +4,8 @@ pub mod api;
pub use api::*; pub use api::*;
use xous::{CID, send_message, Message}; use xous::{CID, send_message, Message};
use num_traits::ToPrimitive; use num_traits::*;
use xous_ipc::Buffer;
pub struct Spinor { pub struct Spinor {
conn: CID, conn: CID,
@ -53,21 +54,23 @@ impl Spinor {
let mut buf = Buffer::into_buf(wr).or(Err(SpinorError::IpcError))?; 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))?; buf.lend_mut(self.conn, Opcode::WriteRegion.to_u32().unwrap()).or(Err(SpinorError::IpcError))?;
match buf.to_original() { match buf.to_original::<WriteRegion, _>() {
Some(wr) => { Ok(wr) => {
if let Some(res) = wr.result { if let Some(res) = wr.result {
match res { match res {
SpinorError::NoError => Ok(()), SpinorError::NoError => Ok(()),
_ => Err(res) _ => Err(res)
} }
} else { } 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 /// note: this implementation will write precisely the slice of u8 contained
/// in data starting from start_addr. If the request is not aligned, the /// 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, /// 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); let u8_to_alignment = self.erase_alignment() - (req_addr & align_mask);
if u8_to_alignment < self.erase_alignment() { if u8_to_alignment < self.erase_alignment() {
// can't align anything, data is smaller than a page // can't align anything, data is smaller than a page
ret = write_page(data, req_addr); ret = self.write_page(data, req_addr);
} else { } else {
// issue one mis-aligned request first; this will trigger a partial erase and re-write // 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; req_addr += u8_to_alignment;
// now send the rest as aligned; this is much more efficient than streaming a bunch of mis-aligned pages // 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) { for page in data[u8_to_alignment as usize..].chunks(self.erase_alignment() as usize).into_iter() {
write_data(page, req_addr)?; self.write_page(page, req_addr)?;
req_addr += self.erase_alignment(); req_addr += self.erase_alignment();
} }
} }
} else { } 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. // 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) { 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(); req_addr += self.erase_alignment();
} }
} }
// release the write lock before exiting // release the write lock before exiting
let _ = send_message(self.conn, 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"); ).expect("couldn't send ReleaseExclusive message");
ret ret
} }
@ -127,21 +130,24 @@ impl Spinor {
/// at start_addr; if this is not naturally aligned to an erase block, the operation /// 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 /// 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! /// 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, 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"); ).expect("Couldn't send erase command");
if let xous::Result::Scalar1(result) = response { if let xous::Result::Scalar1(result) = response {
match FromPrimitive::from_usize(result) { match FromPrimitive::from_usize(result) {
Some(r) => r, Some(r) => r,
None => { None => {
log::error!("Couldn't transform return enum: {:?}", result); log::error!("Couldn't transform return enum: {:?}", result);
SpinorResult::InternalError SpinorError::ImplementationError
}, },
} }
} else { } else {
log::error!("unexpected return structure: {:#?}", response); log::error!("unexpected return structure: {:#?}", response);
SpinorResult::InternalError SpinorError::ImplementationError
} }
} }

View file

@ -4,28 +4,73 @@
mod api; mod api;
use api::*; use api::*;
use num_traits::{ToPrimitive, FromPrimitive}; use num_traits::*;
use xous_ipc::Buffer; 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}; 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")] #[cfg(target_os = "none")]
mod implementation { mod implementation {
use utralib::generated::*; use utralib::generated::*;
use crate::api::*; use crate::api::*;
use log::info;
use susres::{RegManager, RegOrField, SuspendResume}; 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) { fn spinor_safe_context(_irq_no: usize, arg: *mut usize) {
let spinor = unsafe { &mut *(arg as *mut Spinor) }; 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.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) { fn ecc_handler(_irq_no: usize, arg: *mut usize) {
let spinor = unsafe { &mut *(arg as *mut Spinor) }; let spinor = unsafe { &mut *(arg as *mut Spinor) };
@ -38,12 +83,110 @@ mod implementation {
spinor.csr.wfo(utra::spinor::EV_PENDING_ECC_ERROR, 1); 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 { pub struct Spinor {
id: u32,
handler_conn: xous::CID, handler_conn: xous::CID,
csr: utralib::CSR<u32>, csr: utralib::CSR<u32>,
susres: RegManager::<{utra::spinor::SPINOR_NUMREGS}>, susres: RegManager::<{utra::spinor::SPINOR_NUMREGS}>,
softirq: utralib::CSR<u32>, 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 { impl Spinor {
@ -64,11 +207,13 @@ mod implementation {
.expect("couldn't map SPINOR soft interrupt CSR range"); .expect("couldn't map SPINOR soft interrupt CSR range");
let mut spinor = Spinor { let mut spinor = Spinor {
id: 0,
handler_conn, handler_conn,
csr: CSR::new(csr.as_mut_ptr() as *mut u32), csr: CSR::new(csr.as_mut_ptr() as *mut u32),
softirq: CSR::new(softirq.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), 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( 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_fixed_value(RegOrField::Reg(utra::spinor::EV_PENDING), 0xFFFF_FFFF);
spinor.susres.push(RegOrField::Reg(utra::spinor::EV_ENABLE), None); 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 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) { pub fn write_region(&mut self, wr: &mut WriteRegion) {
if wr.start + wr.len > SPINOR_SIZE_BYTES { if wr.start + wr.len > SPINOR_SIZE_BYTES {
wr.result = Some(SpinorError::InvalidRequest); wr.result = Some(SpinorError::InvalidRequest);
@ -102,120 +273,67 @@ mod implementation {
} }
pub fn erase_region(&mut self, start_adr: u32, num_u8: u32) -> SpinorError { 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) { pub fn suspend(&mut self) {
self.susres_manager.suspend(); self.susres.suspend();
} }
pub fn resume(&mut self) { 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_PENDING_SPINOR_INT, 1);
self.softirq.wfo(utra::spinor_soft_int::EV_ENABLE_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"); let spinor_sid = xns.register_name(api::SERVER_NAME_SPINOR, Some(2)).expect("can't register server");
log::trace!("registered with NS -- {:?}", spinor_sid); 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"); 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"); 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 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 { loop {
let mut msg = xous::receive_message(spinor_sid).unwrap(); 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"); 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 => { None => {
log::error!("couldn't convert opcode"); log::error!("couldn't convert opcode");
break break

View file

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

View file

@ -38,6 +38,12 @@ impl Ticktimer {
0, 0, 0) 0, 0, 0)
).map(|_| ()) ).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}; use core::sync::atomic::{AtomicU32, Ordering};
static REFCOUNT: AtomicU32 = AtomicU32::new(0); 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"); susres.suspend_until_resume(token).expect("couldn't execute suspend/resume");
ticktimer.resume(); ticktimer.resume();
}), }),
Some(api::Opcode::PingWdt) => {
ticktimer.reset_wdt();
},
None => { None => {
error!("couldn't convert opcode"); error!("couldn't convert opcode");
break break

View file

@ -11,10 +11,27 @@ pub type Connection = usize;
pub const MAX_CID: usize = 34; 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_LOC: u32 = 0x27F8_0000;
pub const EC_WF200_PKG_LEN: u32 = 0x4_E000; pub const EC_WF200_PKG_LEN: u32 = 0x0004_E000;
pub const EC_FW_PKG_LOC: u32 = 0x27FC_E000; pub const EC_FW_PKG_LOC: u32 = 0x27FC_E000;
pub const EC_FW_PKG_LEN: u32 = 0x3_2000; 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)] #[derive(Debug, PartialEq, Eq, Ord, PartialOrd, Copy, Clone)]
pub struct MessageSender { pub struct MessageSender {
@ -622,6 +639,14 @@ impl MemoryRange {
MemoryRange { addr, size } 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 { pub fn len(&self) -> usize {
self.size.get() self.size.get()
} }