mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-16 08:38:26 +00:00
add llio to suspend/resume set
This commit is contained in:
parent
1014b53726
commit
a55735fb1f
9 changed files with 119 additions and 34 deletions
1
Cargo.lock
generated
1
Cargo.lock
generated
|
|
@ -748,6 +748,7 @@ dependencies = [
|
|||
"num-derive",
|
||||
"num-traits",
|
||||
"rkyv 0.4.3",
|
||||
"susres",
|
||||
"ticktimer-server",
|
||||
"utralib",
|
||||
"xous",
|
||||
|
|
|
|||
|
|
@ -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}
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
},
|
||||
|
|
|
|||
|
|
@ -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();
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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")]
|
||||
|
|
|
|||
|
|
@ -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();
|
||||
|
|
|
|||
Loading…
Reference in a new issue