mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-16 08:38:26 +00:00
pivot spinor implementation
realizing some core assumptions were wrong, so, scrapping and restarting
This commit is contained in:
parent
98c0054d7e
commit
7e7ae82156
10 changed files with 318 additions and 134 deletions
1
Cargo.lock
generated
1
Cargo.lock
generated
|
|
@ -1671,6 +1671,7 @@ checksum = "fe0f37c9e8f3c5a4a66ad655a93c74daac4ad00c441533bf5c6e7990bb42604e"
|
|||
name = "spinor"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"com",
|
||||
"log",
|
||||
"log-server",
|
||||
"num-derive",
|
||||
|
|
|
|||
Binary file not shown.
|
|
@ -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" }
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -11,4 +11,7 @@ pub(crate) enum Opcode {
|
|||
|
||||
/// Suspend/resume callback
|
||||
SuspendResume = 3,
|
||||
|
||||
/// force a WDT update
|
||||
PingWdt = 4,
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue