add llio to suspend/resume set

This commit is contained in:
bunnie 2021-04-29 23:15:47 +08:00
parent 1014b53726
commit a55735fb1f
9 changed files with 119 additions and 34 deletions

1
Cargo.lock generated
View file

@ -748,6 +748,7 @@ dependencies = [
"num-derive",
"num-traits",
"rkyv 0.4.3",
"susres",
"ticktimer-server",
"utralib",
"xous",

View file

@ -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}

View file

@ -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 {

View file

@ -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<u32>,
crg_csr: utralib::CSR<u32>,
gpio_csr: utralib::CSR<u32>,
gpio_susres: RegManager::<{utra::gpio::GPIO_NUMREGS}>,
info_csr: utralib::CSR<u32>,
identifier_csr: utralib::CSR<u32>,
i2c_csr: utralib::CSR<u32>,
i2c_susres: RegManager::<{utra::i2c::I2C_NUMREGS}>,
handler_conn: Option<xous::CID>,
event_csr: utralib::CSR<u32>,
event_susres: RegManager::<{utra::btevents::BTEVENTS_NUMREGS}>,
power_csr: utralib::CSR<u32>,
power_susres: RegManager::<{utra::power::POWER_NUMREGS}>,
xadc_csr: utralib::CSR<u32>, // 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<ScalarCallback>; 32] = [None; 32];
let mut com_cb_conns: [Option<ScalarCallback>; 32] = [None; 32];
let mut rtc_cb_conns: [Option<ScalarCallback>; 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;
},

View file

@ -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();
/*

View file

@ -62,6 +62,8 @@ pub struct ManagedReg {
pub mask: Option<usize>,
/// the saved value of the field or register
pub value: Option<usize>,
/// 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<const N: usize> RegManager::<N> 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<usize>) {
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<const N: usize> SuspendResume for RegManager<N> {
}
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);
}
}
/*

View file

@ -13,32 +13,36 @@ pub struct Susres {
execution_gate_conn: CID,
}
impl Susres {
pub fn new(xns: &xous_names::XousNames) -> Result<Self, xous::Error> {
pub fn new(xns: &xous_names::XousNames, cb_discriminant: u32, cid: CID) -> Result<Self, xous::Error> {
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<Self, xous::Error> {
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,

View file

@ -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")]

View file

@ -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();