mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-19 09:00:54 +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"
|
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.
|
|
@ -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" }
|
||||||
|
|
|
||||||
|
|
@ -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,
|
||||||
|
|
|
||||||
|
|
@ -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
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -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
|
||||||
|
|
|
||||||
|
|
@ -11,4 +11,7 @@ pub(crate) enum Opcode {
|
||||||
|
|
||||||
/// Suspend/resume callback
|
/// Suspend/resume callback
|
||||||
SuspendResume = 3,
|
SuspendResume = 3,
|
||||||
|
|
||||||
|
/// force a WDT update
|
||||||
|
PingWdt = 4,
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -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);
|
||||||
|
|
|
||||||
|
|
@ -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
|
||||||
|
|
|
||||||
|
|
@ -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()
|
||||||
}
|
}
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue