diff --git a/Cargo.lock b/Cargo.lock index b530a5876..870a39454 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -748,6 +748,7 @@ dependencies = [ "num-derive", "num-traits", "rkyv 0.4.3", + "susres", "ticktimer-server", "utralib", "xous", diff --git a/services/llio/Cargo.toml b/services/llio/Cargo.toml index f65d824a7..7818d6c80 100644 --- a/services/llio/Cargo.toml +++ b/services/llio/Cargo.toml @@ -12,6 +12,7 @@ ticktimer-server = {path = "../ticktimer-server"} xous = {path = "../../xous-rs"} xous-ipc = {path = "../../xous-ipc"} xous-names = {path = "../xous-names"} +susres = {path = "../susres"} num-derive = {version = "0.3", default-features = false} num-traits = {version = "0.2", default-features = false} diff --git a/services/llio/src/api.rs b/services/llio/src/api.rs index 292b9a322..dab5f9d22 100644 --- a/services/llio/src/api.rs +++ b/services/llio/src/api.rs @@ -213,6 +213,9 @@ pub(crate) enum Opcode { EventComHappened, EventRtcHappened, EventUsbHappened, + + /// SuspendResume callback + SuspendResume, } #[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)] pub(crate) enum EventCallback { diff --git a/services/llio/src/main.rs b/services/llio/src/main.rs index 2c50ee77c..73edbb04d 100644 --- a/services/llio/src/main.rs +++ b/services/llio/src/main.rs @@ -27,18 +27,23 @@ mod implementation { use log::{error, info}; use utralib::generated::*; use num_traits::ToPrimitive; + use susres::{RegManager, RegOrField, SuspendResume}; #[allow(dead_code)] pub struct Llio { reboot_csr: utralib::CSR, crg_csr: utralib::CSR, gpio_csr: utralib::CSR, + gpio_susres: RegManager::<{utra::gpio::GPIO_NUMREGS}>, info_csr: utralib::CSR, identifier_csr: utralib::CSR, i2c_csr: utralib::CSR, + i2c_susres: RegManager::<{utra::i2c::I2C_NUMREGS}>, handler_conn: Option, event_csr: utralib::CSR, + event_susres: RegManager::<{utra::btevents::BTEVENTS_NUMREGS}>, power_csr: utralib::CSR, + power_susres: RegManager::<{utra::power::POWER_NUMREGS}>, xadc_csr: utralib::CSR, // be careful with this as XADC is shared with TRNG ticktimer: ticktimer_server::Ticktimer, destruct_armed: bool, @@ -185,12 +190,16 @@ mod implementation { reboot_csr: CSR::new(reboot_csr.as_mut_ptr() as *mut u32), crg_csr: CSR::new(crg_csr.as_mut_ptr() as *mut u32), gpio_csr: CSR::new(gpio_base), + gpio_susres: RegManager::new(gpio_base), info_csr: CSR::new(info_csr.as_mut_ptr() as *mut u32), identifier_csr: CSR::new(identifier_csr.as_mut_ptr() as *mut u32), i2c_csr: CSR::new(i2c_csr.as_mut_ptr() as *mut u32), + i2c_susres: RegManager::new(i2c_csr.as_mut_ptr() as *mut u32), handler_conn: Some(handler_conn), // connection for messages from IRQ handler event_csr: CSR::new(event_csr.as_mut_ptr() as *mut u32), + event_susres: RegManager::new(event_csr.as_mut_ptr() as *mut u32), power_csr: CSR::new(power_csr.as_mut_ptr() as *mut u32), + power_susres: RegManager::new(power_csr.as_mut_ptr() as *mut u32), xadc_csr: CSR::new(xadc_csr.as_mut_ptr() as *mut u32), ticktimer, destruct_armed: false, @@ -237,8 +246,48 @@ mod implementation { // now enable interrupts xl.i2c_csr.wfo(utra::i2c::EV_ENABLE_TXRX_DONE, 1); + // setup suspend/resume manager + xl.i2c_susres.push(RegOrField::Field(utra::i2c::PRESCALE_PRESCALE), None); + xl.i2c_susres.push(RegOrField::Reg(utra::i2c::CONTROL), None); + xl.i2c_susres.push_fixed_value(RegOrField::Reg(utra::i2c::EV_PENDING), 0xFFFF_FFFF); // clear pending interrupts + xl.i2c_susres.push(RegOrField::Reg(utra::i2c::EV_ENABLE), None); + + xl.gpio_susres.push(RegOrField::Reg(utra::gpio::DRIVE), None); + xl.gpio_susres.push(RegOrField::Reg(utra::gpio::OUTPUT), None); + xl.gpio_susres.push(RegOrField::Reg(utra::gpio::INTPOL), None); + xl.gpio_susres.push(RegOrField::Reg(utra::gpio::INTENA), None); + xl.gpio_susres.push_fixed_value(RegOrField::Reg(utra::gpio::EV_PENDING), 0xFFFF_FFFF); + xl.gpio_susres.push(RegOrField::Reg(utra::gpio::EV_ENABLE), None); + xl.gpio_susres.push(RegOrField::Field(utra::gpio::UARTSEL_UARTSEL), None); + + xl.event_susres.push_fixed_value(RegOrField::Reg(utra::btevents::EV_PENDING), 0xFFFF_FFFF); + xl.event_susres.push(RegOrField::Reg(utra::btevents::EV_ENABLE), None); + + xl.power_susres.push(RegOrField::Reg(utra::power::POWER), None); + xl.power_susres.push(RegOrField::Reg(utra::power::VIBE), None); + xl.power_susres.push_fixed_value(RegOrField::Reg(utra::power::EV_PENDING), 0xFFFF_FFFF); + xl.power_susres.push(RegOrField::Reg(utra::power::EV_ENABLE), None); + xl } + pub fn suspend(&mut self) { + self.i2c_susres.suspend(); + self.gpio_susres.suspend(); + self.event_susres.suspend(); + self.power_susres.suspend(); + + // this happens after suspend, so these disables are "lost" upon resume and replaced with the normal running values + self.i2c_csr.wo(utra::i2c::EV_ENABLE, 0); + self.gpio_csr.wo(utra::gpio::EV_ENABLE, 0); + self.event_csr.wo(utra::btevents::EV_ENABLE, 0); + self.power_csr.wo(utra::power::EV_ENABLE, 0); + } + pub fn resume(&mut self) { + self.power_susres.resume(); + self.event_susres.resume(); + self.gpio_susres.resume(); + self.i2c_susres.resume(); + } pub fn reboot(&mut self, reboot_soc: bool) { if reboot_soc { @@ -433,6 +482,8 @@ mod implementation { } pub fn get_i2c_base(&self) -> *mut u32 { 0 as *mut u32 } + pub fn suspend(&self) {} + pub fn resume(&self) {} pub fn reboot(&self, _reboot_soc: bool) {} pub fn set_reboot_vector(&self, _vector: u32) {} pub fn gpio_dout(&self, _d: u32) {} @@ -527,6 +578,10 @@ fn xmain() -> ! { // create an i2c state machine handler let mut i2c_machine = I2cStateMachine::new(ticktimer, llio.get_i2c_base()); + // register a suspend/resume listener + let sr_cid = xous::connect(llio_sid).expect("couldn't create suspend callback connection"); + let mut susres = susres::Susres::new(&xns, Opcode::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object"); + let mut usb_cb_conns: [Option; 32] = [None; 32]; let mut com_cb_conns: [Option; 32] = [None; 32]; let mut rtc_cb_conns: [Option; 32] = [None; 32]; @@ -549,6 +604,11 @@ fn xmain() -> ! { } } else { match FromPrimitive::from_usize(msg.body.id()) { + Some(Opcode::SuspendResume) => xous::msg_scalar_unpack!(msg, token, _, _, _, { + llio.suspend(); + susres.suspend_until_resume(token).expect("couldn't execute suspend/resume"); + llio.resume(); + }), Some(Opcode::RebootRequest) => { reboot_requested = true; }, diff --git a/services/rkyv-test-client/src/main.rs b/services/rkyv-test-client/src/main.rs index ec5652c31..6175bdaf0 100644 --- a/services/rkyv-test-client/src/main.rs +++ b/services/rkyv-test-client/src/main.rs @@ -49,7 +49,7 @@ fn rkyv_test_client() -> ! { let xns = xous_names::XousNames::new().unwrap(); - let mut susres = susres::Susres::new(&xns).unwrap(); + let mut susres = susres::Susres::new_without_hook(&xns).unwrap(); let mut com = com::Com::new(&xns).unwrap(); com.hook_batt_stats(handle_battstats).unwrap(); /* diff --git a/services/susres/src/api.rs b/services/susres/src/api.rs index 1d8ab8117..bab2b286a 100644 --- a/services/susres/src/api.rs +++ b/services/susres/src/api.rs @@ -62,6 +62,8 @@ pub struct ManagedReg { pub mask: Option, /// the saved value of the field or register pub value: Option, + /// if true, value is static and should not be updated during suspend, but restored to this value ta resume + pub fixed_value: bool, } //#[derive(Debug)] @@ -88,12 +90,28 @@ impl RegManager:: where ManagedReg: core::marker::Copy { res_epilogue: None, } } + pub fn push_fixed_value(&mut self, mr: RegOrField, value: usize) { + let mrt = ManagedReg { + item: mr, + mask: None, + value: Some(value), + fixed_value: true, + }; + for entry in self.registers.iter_mut() { + if entry.is_none() { + *entry = Some(mrt); + return; + } + } + panic!("Ran out of space pushing to suspend/resume manager structure. Please increase the allocated size!"); + } // push registers into the manager in the order you want them suspended pub fn push(&mut self, mr: RegOrField, mask_override: Option) { let mrt = ManagedReg { item: mr, mask: mask_override, value: None, + fixed_value: false, }; for entry in self.registers.iter_mut() { if entry.is_none() { @@ -119,12 +137,14 @@ impl SuspendResume for RegManager { } for entry in self.registers.iter_mut().rev() { if let Some(reg) = entry { - // masking is done on the write side - match reg.item { - RegOrField::Field(field) => reg.value = Some(self.csr.rf(field) as usize), - RegOrField::Reg(r) => reg.value = Some(self.csr.r(r) as usize), + if !reg.fixed_value { + // masking is done on the write side + match reg.item { + RegOrField::Field(field) => reg.value = Some(self.csr.rf(field) as usize), + RegOrField::Reg(r) => reg.value = Some(self.csr.r(r) as usize), + } + *entry = Some(*reg); } - *entry = Some(*reg); } } /* diff --git a/services/susres/src/lib.rs b/services/susres/src/lib.rs index 08edb29d7..a7e9fc8df 100644 --- a/services/susres/src/lib.rs +++ b/services/susres/src/lib.rs @@ -13,32 +13,36 @@ pub struct Susres { execution_gate_conn: CID, } impl Susres { - pub fn new(xns: &xous_names::XousNames) -> Result { + pub fn new(xns: &xous_names::XousNames, cb_discriminant: u32, cid: CID) -> Result { let conn = xns.request_connection_blocking(api::SERVER_NAME_SUSRES).expect("Can't connect to SUSRES"); let execution_gate_conn = xns.request_connection_blocking(api::SERVER_NAME_EXEC_GATE).expect("Can't connect to the execution gate"); + + let sid = xous::create_server().unwrap(); + let sid_tuple = sid.to_u32(); + xous::create_thread_4(suspend_cb_server, sid_tuple.0 as usize, sid_tuple.1 as usize, sid_tuple.2 as usize, sid_tuple.3 as usize).unwrap(); + let hookdata = ScalarHook { + sid: sid_tuple, + id: cb_discriminant, + cid, + }; + let buf = Buffer::into_buf(hookdata).or(Err(xous::Error::InternalError))?; + buf.lend(conn, Opcode::SuspendEventSubscribe.to_u32().unwrap())?; + Ok(Susres { conn, - suspend_cb_sid: None, + suspend_cb_sid: Some(sid), execution_gate_conn, }) } - pub fn hook_suspend_callback(&mut self, id: u32, cid: CID) -> Result<(), xous::Error> { - if self.suspend_cb_sid.is_none() { - let sid = xous::create_server().unwrap(); - self.suspend_cb_sid = Some(sid); - let sid_tuple = sid.to_u32(); - xous::create_thread_4(suspend_cb_server, sid_tuple.0 as usize, sid_tuple.1 as usize, sid_tuple.2 as usize, sid_tuple.3 as usize).unwrap(); - let hookdata = ScalarHook { - sid: sid_tuple, - id, - cid, - }; - let buf = Buffer::into_buf(hookdata).or(Err(xous::Error::InternalError))?; - buf.lend(self.conn, Opcode::SuspendEventSubscribe.to_u32().unwrap()).map(|_|()) - } else { - Err(xous::Error::MemoryInUse) // can't hook it twice - } + pub fn new_without_hook(xns: &xous_names::XousNames) -> Result { + let conn = xns.request_connection_blocking(api::SERVER_NAME_SUSRES)?; + Ok(Susres { + conn, + suspend_cb_sid: None, + execution_gate_conn: 0, + }) } + pub fn initiate_suspend(&mut self) -> Result<(), xous::Error> { log::trace!("suspend initiated"); send_message(self.conn, @@ -46,6 +50,9 @@ impl Susres { ).map(|_|()) } pub fn suspend_until_resume(&mut self, token: usize) -> Result<(), xous::Error> { + if self.suspend_cb_sid.is_none() { // this happens if you created without a hook + return Err(xous::Error::UseBeforeInit) + } log::trace!("telling the server we're ready to suspend"); // first tell the susres server that we're ready to suspend send_message(self.conn, diff --git a/services/ticktimer-server/src/main.rs b/services/ticktimer-server/src/main.rs index f0f0473b9..4ea77ae18 100644 --- a/services/ticktimer-server/src/main.rs +++ b/services/ticktimer-server/src/main.rs @@ -177,6 +177,7 @@ mod implementation { xtt.ticktimer_sr_manager.push(RegOrField::Reg(utra::ticktimer::MSLEEP_TARGET0), None); xtt.ticktimer_sr_manager.push(RegOrField::Reg(utra::ticktimer::MSLEEP_TARGET1), None); + xtt.ticktimer_sr_manager.push_fixed_value(RegOrField::Reg(utra::ticktimer::EV_PENDING), 0xFFFF_FFFF); xtt.ticktimer_sr_manager.push(RegOrField::Reg(utra::ticktimer::EV_ENABLE), None); xtt @@ -500,12 +501,8 @@ fn xmain() -> ! { // register a suspend/resume listener let xns = xous_names::XousNames::new().unwrap(); - let mut susres = susres::Susres::new(&xns).expect("couldn't create suspend/resume object"); let sr_cid = xous::connect(ticktimer_server).expect("couldn't create suspend callback connection"); - { - use num_traits::ToPrimitive; - susres.hook_suspend_callback(api::Opcode::SuspendResume.to_usize().unwrap() as u32, sr_cid).expect("couldn't register suspend/resume listener"); - } + let mut susres = susres::Susres::new(&xns, api::Opcode::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object"); loop { #[cfg(feature = "watchdog")] diff --git a/services/trng/src/main.rs b/services/trng/src/main.rs index c198a0830..4fc6d7502 100644 --- a/services/trng/src/main.rs +++ b/services/trng/src/main.rs @@ -384,12 +384,8 @@ fn xmain() -> ! { log::trace!("ready to accept requests"); // register a suspend/resume listener - let mut susres = susres::Susres::new(&xns).expect("couldn't create suspend/resume object"); let sr_cid = xous::connect(trng_sid).expect("couldn't create suspend callback connection"); - { - use num_traits::ToPrimitive; - susres.hook_suspend_callback(api::Opcode::SuspendResume.to_usize().unwrap() as u32, sr_cid).expect("couldn't register suspend/resume listener"); - } + let mut susres = susres::Susres::new(&xns, api::Opcode::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object"); loop { let msg = xous::receive_message(trng_sid).unwrap();