diff --git a/Cargo.lock b/Cargo.lock index 1aa5aa44f..60faace00 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1671,6 +1671,7 @@ checksum = "fe0f37c9e8f3c5a4a66ad655a93c74daac4ad00c441533bf5c6e7990bb42604e" name = "spinor" version = "0.1.0" dependencies = [ + "com", "log", "log-server", "num-derive", diff --git a/precursors/soc_csr.bin b/precursors/soc_csr.bin index 6ff2bdf74..e0afc3891 100755 Binary files a/precursors/soc_csr.bin and b/precursors/soc_csr.bin differ diff --git a/services/spinor/Cargo.toml b/services/spinor/Cargo.toml index 224b8f34a..971818c74 100644 --- a/services/spinor/Cargo.toml +++ b/services/spinor/Cargo.toml @@ -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" } diff --git a/services/spinor/src/api.rs b/services/spinor/src/api.rs index 343feeb94..3cc469665 100644 --- a/services/spinor/src/api.rs +++ b/services/spinor/src/api.rs @@ -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, + pub result: Option, } -#[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, diff --git a/services/spinor/src/lib.rs b/services/spinor/src/lib.rs index a91df27e7..035c12091 100644 --- a/services/spinor/src/lib.rs +++ b/services/spinor/src/lib.rs @@ -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::() { + 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 } } diff --git a/services/spinor/src/main.rs b/services/spinor/src/main.rs index 0bcb9c91a..d1380028d 100644 --- a/services/spinor/src/main.rs +++ b/services/spinor/src/main.rs @@ -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, 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 { + 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, 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) { + 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) { + 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, 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, 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, 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, susres: RegManager::<{utra::spinor::SPINOR_NUMREGS}>, softirq: utralib::CSR, - 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, + 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; 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 diff --git a/services/ticktimer-server/src/api.rs b/services/ticktimer-server/src/api.rs index 963eab83d..dfddde563 100644 --- a/services/ticktimer-server/src/api.rs +++ b/services/ticktimer-server/src/api.rs @@ -11,4 +11,7 @@ pub(crate) enum Opcode { /// Suspend/resume callback SuspendResume = 3, + + /// force a WDT update + PingWdt = 4, } diff --git a/services/ticktimer-server/src/lib.rs b/services/ticktimer-server/src/lib.rs index 696f8b72a..1d1adaee5 100644 --- a/services/ticktimer-server/src/lib.rs +++ b/services/ticktimer-server/src/lib.rs @@ -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); diff --git a/services/ticktimer-server/src/main.rs b/services/ticktimer-server/src/main.rs index 2131aa809..263d539b4 100644 --- a/services/ticktimer-server/src/main.rs +++ b/services/ticktimer-server/src/main.rs @@ -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 diff --git a/xous-rs/src/definitions.rs b/xous-rs/src/definitions.rs index b9e7d2c10..f1a2a7399 100644 --- a/xous-rs/src/definitions.rs +++ b/xous-rs/src/definitions.rs @@ -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() }