mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-17 08:40:52 +00:00
retrofit the kernel and loader to handle resume
and now the even harder debuggening begins...zomg o_O
This commit is contained in:
parent
2d3a643d20
commit
0e2d57c9fb
17 changed files with 435 additions and 471 deletions
|
|
@ -17,12 +17,12 @@ pub fn current_pid() -> PID {
|
||||||
PID::new(satp::read().asid() as _).unwrap()
|
PID::new(satp::read().asid() as _).unwrap()
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn init() {
|
pub fn init(resume: bool) {
|
||||||
unsafe {
|
unsafe {
|
||||||
sie::set_ssoft();
|
sie::set_ssoft();
|
||||||
sie::set_sext();
|
sie::set_sext();
|
||||||
}
|
}
|
||||||
rand::init();
|
rand::init(resume);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Put the core to sleep until an interrupt hits. Returns `true`
|
/// Put the core to sleep until an interrupt hits. Returns `true`
|
||||||
|
|
|
||||||
|
|
@ -7,15 +7,15 @@ use xous_kernel::{MemoryFlags, MemoryType, PID};
|
||||||
|
|
||||||
pub const TRNG_KERNEL: Trng = Trng {
|
pub const TRNG_KERNEL: Trng = Trng {
|
||||||
// the HW device mapping is done in xous-rs/src/lib.rs/init()
|
// the HW device mapping is done in xous-rs/src/lib.rs/init()
|
||||||
// the manually chosen virtuall address has to be in the top 4MiB as it is the only page shared among all processes
|
// the manually chosen virtual address has to be in the top 4MiB as it is the only page shared among all processes
|
||||||
base: 0xffce_0000 as *mut usize,
|
base: 0xffce_0000 as *mut usize, // see https://github.com/betrusted-io/xous-core/blob/master/docs/memory.md
|
||||||
};
|
};
|
||||||
|
|
||||||
pub struct Trng {
|
pub struct Trng {
|
||||||
pub base: *mut usize,
|
pub base: *mut usize,
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn init() {
|
pub fn init(resume: bool) {
|
||||||
// Map the TRNG so that we can allocate names
|
// Map the TRNG so that we can allocate names
|
||||||
// hardware guarantees that:
|
// hardware guarantees that:
|
||||||
// - TRNG will automatically power on
|
// - TRNG will automatically power on
|
||||||
|
|
@ -23,18 +23,20 @@ pub fn init() {
|
||||||
// - Kernel FIFO will fill with TRNGs such that at least the next 512 calls to get_u32() will succeed without delay
|
// - Kernel FIFO will fill with TRNGs such that at least the next 512 calls to get_u32() will succeed without delay
|
||||||
// - The kernel will start a TRNG server
|
// - The kernel will start a TRNG server
|
||||||
// - All further security decisions and policies are 100% delegated to this new server.
|
// - All further security decisions and policies are 100% delegated to this new server.
|
||||||
MemoryManager::with_mut(|memory_manager| {
|
if !resume {
|
||||||
memory_manager
|
MemoryManager::with_mut(|memory_manager| {
|
||||||
.map_range(
|
memory_manager
|
||||||
utra::trng_kernel::HW_TRNG_KERNEL_BASE as *mut u8,
|
.map_range(
|
||||||
((TRNG_KERNEL.base as u32) & !4095) as *mut u8,
|
utra::trng_kernel::HW_TRNG_KERNEL_BASE as *mut u8,
|
||||||
4096,
|
((TRNG_KERNEL.base as u32) & !4095) as *mut u8,
|
||||||
PID::new(1).unwrap(),
|
4096,
|
||||||
MemoryFlags::R | MemoryFlags::W,
|
PID::new(1).unwrap(),
|
||||||
MemoryType::Default,
|
MemoryFlags::R | MemoryFlags::W,
|
||||||
)
|
MemoryType::Default,
|
||||||
.expect("unable to map TRNG")
|
)
|
||||||
});
|
.expect("unable to map TRNG")
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
let trng_kernel_csr = CSR::new(TRNG_KERNEL.base as *mut u32);
|
let trng_kernel_csr = CSR::new(TRNG_KERNEL.base as *mut u32);
|
||||||
while trng_kernel_csr.rf(utra::trng_kernel::STATUS_AVAIL) == 0 {}
|
while trng_kernel_csr.rf(utra::trng_kernel::STATUS_AVAIL) == 0 {}
|
||||||
|
|
|
||||||
|
|
@ -27,7 +27,7 @@ pub fn current_pid() -> PID {
|
||||||
unimplemented!();
|
unimplemented!();
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn init() {}
|
pub fn init(resume: bool) {}
|
||||||
|
|
||||||
pub mod syscall {
|
pub mod syscall {
|
||||||
use crate::arch::Context;
|
use crate::arch::Context;
|
||||||
|
|
|
||||||
|
|
@ -14,7 +14,7 @@ use utralib::generated::*;
|
||||||
))]
|
))]
|
||||||
pub mod debug_print_hardware {
|
pub mod debug_print_hardware {
|
||||||
// the HW device mapping is done in main.rs/init(); the virtual address has to be in the top 4MiB as it is the only page shared among all processes
|
// the HW device mapping is done in main.rs/init(); the virtual address has to be in the top 4MiB as it is the only page shared among all processes
|
||||||
pub const SUPERVISOR_UART_ADDR: *mut usize = 0xffcf_0000 as *mut usize;
|
pub const SUPERVISOR_UART_ADDR: *mut usize = 0xffcf_0000 as *mut usize; // see https://github.com/betrusted-io/xous-core/blob/master/docs/memory.md
|
||||||
|
|
||||||
#[macro_export]
|
#[macro_export]
|
||||||
macro_rules! print
|
macro_rules! print
|
||||||
|
|
|
||||||
|
|
@ -39,61 +39,110 @@ fn handle_panic(_arg: &PanicInfo) -> ! {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
use utralib::generated::*;
|
||||||
|
pub const RESUME_KICKER: ResumeKicker = ResumeKicker {
|
||||||
|
// the manually chosen virtual address has to be in the top 4MiB as it is the only page shared among all processes
|
||||||
|
base: 0xffcd_0000 as *mut usize, // see https://github.com/betrusted-io/xous-core/blob/master/docs/memory.md
|
||||||
|
};
|
||||||
|
|
||||||
|
pub struct ResumeKicker {
|
||||||
|
pub base: *mut usize,
|
||||||
|
}
|
||||||
|
|
||||||
#[cfg(baremetal)]
|
#[cfg(baremetal)]
|
||||||
#[no_mangle]
|
#[no_mangle]
|
||||||
/// This function is called from baremetal startup code to initialize various kernel structures
|
/// This function is called from baremetal startup code to initialize various kernel structures
|
||||||
/// based on arguments passed by the bootloader. It is unused when running under an operating system.
|
/// based on arguments passed by the bootloader. It is unused when running under an operating system.
|
||||||
pub extern "C" fn init(arg_offset: *const u32, init_offset: *const u32, rpt_offset: *mut u32) {
|
pub extern "C" fn init(arg_offset: *const u32, init_offset: *const u32, rpt_offset: *mut u32, resume: bool) {
|
||||||
unsafe { args::KernelArguments::init(arg_offset) };
|
if !resume {
|
||||||
let args = args::KernelArguments::get();
|
unsafe { args::KernelArguments::init(arg_offset) };
|
||||||
// Everything needs memory, so the first thing we should do is initialize the memory manager.
|
let args = args::KernelArguments::get();
|
||||||
crate::mem::MemoryManager::with_mut(|mm| {
|
// Everything needs memory, so the first thing we should do is initialize the memory manager.
|
||||||
mm.init_from_memory(rpt_offset, &args)
|
crate::mem::MemoryManager::with_mut(|mm| {
|
||||||
.expect("couldn't initialize memory manager")
|
mm.init_from_memory(rpt_offset, &args)
|
||||||
});
|
.expect("couldn't initialize memory manager")
|
||||||
SystemServices::with_mut(|system_services| {
|
});
|
||||||
system_services.init_from_memory(init_offset, &args)
|
SystemServices::with_mut(|system_services| {
|
||||||
});
|
system_services.init_from_memory(init_offset, &args)
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
// Now that the memory manager is set up, perform any arch-specific initializations.
|
// Now that the memory manager is set up, perform any arch-specific initializations.
|
||||||
arch::init();
|
// each sub-call will handle things differently depending on the resume state
|
||||||
|
arch::init(resume);
|
||||||
|
|
||||||
// Either map memory using a syscall, or if we're debugging the syscall
|
// Either map memory using a syscall, or if we're debugging the syscall
|
||||||
// handler then directly map it.
|
// handler then directly map it.
|
||||||
#[cfg(any(feature = "debug-print", feature = "print-panics"))]
|
#[cfg(any(feature = "debug-print", feature = "print-panics"))]
|
||||||
{
|
{
|
||||||
use utralib::generated::*;
|
use utralib::generated::*;
|
||||||
// Map the serial port so println!() works as expected.
|
if !resume {
|
||||||
|
// Map the serial port so println!() works as expected.
|
||||||
|
mem::MemoryManager::with_mut(|memory_manager| {
|
||||||
|
memory_manager
|
||||||
|
.map_range(
|
||||||
|
utra::uart::HW_UART_BASE as *mut u8,
|
||||||
|
((debug::SUPERVISOR_UART_ADDR as u32) & !4095) as *mut u8,
|
||||||
|
4096,
|
||||||
|
PID::new(1).unwrap(),
|
||||||
|
MemoryFlags::R | MemoryFlags::W,
|
||||||
|
MemoryType::Default,
|
||||||
|
)
|
||||||
|
.expect("unable to map serial port")
|
||||||
|
});
|
||||||
|
debug::Uart{}.init();
|
||||||
|
println!("KMAIN (clean boot): Supervisor mode started...");
|
||||||
|
println!("Claiming IRQ {} via syscall...", utra::uart::UART_IRQ);
|
||||||
|
xous_kernel::claim_interrupt(utra::uart::UART_IRQ, debug::irq, 0 as *mut usize)
|
||||||
|
.expect("Couldn't claim debug interrupt");
|
||||||
|
print!("}} ");
|
||||||
|
} else {
|
||||||
|
println!("KMAIN (resume): Loader is instructing us to resume...");
|
||||||
|
}
|
||||||
|
|
||||||
|
if !resume {
|
||||||
|
// Print the processed kernel arguments
|
||||||
|
let args = args::KernelArguments::get();
|
||||||
|
println!("Kernel arguments:");
|
||||||
|
for arg in args.iter() {
|
||||||
|
println!(" {}", arg);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if !resume {
|
||||||
|
// map in the resume kicker to its fixed virtual address for the next time we start with a resume
|
||||||
mem::MemoryManager::with_mut(|memory_manager| {
|
mem::MemoryManager::with_mut(|memory_manager| {
|
||||||
memory_manager
|
memory_manager
|
||||||
.map_range(
|
.map_range(
|
||||||
utra::uart::HW_UART_BASE as *mut u8,
|
utra::resumekicker::HW_RESUMEKICKER_BASE as *mut u8,
|
||||||
((debug::SUPERVISOR_UART_ADDR as u32) & !4095) as *mut u8,
|
((RESUME_KICKER.base as u32) & !4095) as *mut u8,
|
||||||
4096,
|
4096,
|
||||||
PID::new(1).unwrap(),
|
PID::new(1).unwrap(),
|
||||||
MemoryFlags::R | MemoryFlags::W,
|
MemoryFlags::R | MemoryFlags::W,
|
||||||
MemoryType::Default,
|
MemoryType::Default,
|
||||||
)
|
)
|
||||||
.expect("unable to map serial port")
|
.expect("unable to map resume kicker for future resume use")
|
||||||
});
|
});
|
||||||
debug::Uart{}.init();
|
|
||||||
println!("KMAIN: Supervisor mode started...");
|
|
||||||
println!("Claiming IRQ {} via syscall...", utra::uart::UART_IRQ);
|
|
||||||
xous_kernel::claim_interrupt(utra::uart::UART_IRQ, debug::irq, 0 as *mut usize)
|
|
||||||
.expect("Couldn't claim debug interrupt");
|
|
||||||
print!("}} ");
|
|
||||||
|
|
||||||
// Print the processed kernel arguments
|
|
||||||
let args = args::KernelArguments::get();
|
|
||||||
println!("Kernel arguments:");
|
|
||||||
for arg in args.iter() {
|
|
||||||
println!(" {}", arg);
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// pump the random number generator to test it
|
// rand::init() already clears the initial pipe, but pump the TRNG a little more out of no other reason than sheer paranoia
|
||||||
for _ in 0..100 {
|
arch::rand::get_u32();
|
||||||
arch::rand::get_u32();
|
arch::rand::get_u32();
|
||||||
|
|
||||||
|
if resume {
|
||||||
|
// this will reload the SIM from its backing store in RAM
|
||||||
|
crate::arch::irq::enable_all_irqs();
|
||||||
|
// we should already have our page mapped from a prior boot
|
||||||
|
let mut resumekicker = CSR::new(RESUME_KICKER.base as *mut u32);
|
||||||
|
|
||||||
|
// this should trigger a pending interrupt immediately
|
||||||
|
// note that the resumekicker's "kick" signal is a wire-OR into the susres SOFT_INT bit
|
||||||
|
// and that the loader will have set EV_ENABLE on this before handing control to the kernel
|
||||||
|
resumekicker.wfo(utra::resumekicker::KICKER_KICK, 1);
|
||||||
|
// when the handler returns to this closing curly brace,
|
||||||
|
// the control flow returns to the asm.S loader
|
||||||
|
// and the very next immediate thing it does is jump to kmain() and schedule the next PID to run!
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -15,8 +15,8 @@ rand = "0.7.3"
|
||||||
[features]
|
[features]
|
||||||
debug-print = []
|
debug-print = []
|
||||||
earlyprintk = []
|
earlyprintk = []
|
||||||
#default = ["debug-print"]
|
default = ["debug-print"]
|
||||||
default = []
|
#default = []
|
||||||
|
|
||||||
[profile.release]
|
[profile.release]
|
||||||
codegen-units = 1 # 1 better optimizations
|
codegen-units = 1 # 1 better optimizations
|
||||||
|
|
|
||||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
|
@ -50,5 +50,8 @@ start_kernel:
|
||||||
// Reposition the stack at the offset passed by $a5
|
// Reposition the stack at the offset passed by $a5
|
||||||
move sp, a5
|
move sp, a5
|
||||||
|
|
||||||
|
// copy the clean suspend marker to the fourth argument slot (a3)
|
||||||
|
move a3, a7
|
||||||
|
|
||||||
// Issue the return, which will jump to $mepc in Supervisor mode
|
// Issue the return, which will jump to $mepc in Supervisor mode
|
||||||
mret
|
mret
|
||||||
|
|
|
||||||
|
|
@ -389,6 +389,7 @@ extern "C" {
|
||||||
entrypoint: usize,
|
entrypoint: usize,
|
||||||
stack: usize,
|
stack: usize,
|
||||||
debug: bool,
|
debug: bool,
|
||||||
|
resume: bool,
|
||||||
) -> !;
|
) -> !;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -1076,8 +1077,10 @@ fn boot_sequence(args: KernelArguments, _signature: u32) -> ! {
|
||||||
|
|
||||||
let (clean, was_forced_suspend) = check_resume(&mut cfg);
|
let (clean, was_forced_suspend) = check_resume(&mut cfg);
|
||||||
if !clean {
|
if !clean {
|
||||||
|
println!("no suspend marker found, doing a cold boot!");
|
||||||
phase_1(&mut cfg);
|
phase_1(&mut cfg);
|
||||||
phase_2(&mut cfg);
|
phase_2(&mut cfg);
|
||||||
|
println!("done initializing for cold boot.");
|
||||||
} else {
|
} else {
|
||||||
use utralib::generated::*;
|
use utralib::generated::*;
|
||||||
// setup for a resume
|
// setup for a resume
|
||||||
|
|
@ -1092,10 +1095,8 @@ fn boot_sequence(args: KernelArguments, _signature: u32) -> ! {
|
||||||
resume_csr.wfo(utra::susres::STATE_RESUME, 1);
|
resume_csr.wfo(utra::susres::STATE_RESUME, 1);
|
||||||
}
|
}
|
||||||
resume_csr.wfo(utra::susres::CONTROL_PAUSE, 1); // ensure that the ticktimer is paused before resuming
|
resume_csr.wfo(utra::susres::CONTROL_PAUSE, 1); // ensure that the ticktimer is paused before resuming
|
||||||
|
resume_csr.wfo(utra::susres::EV_ENABLE_SOFT_INT, 1); // ensure that the soft interrupt is enabled for the kernel to kick
|
||||||
// set the resume marker for the early kernel init
|
println!("clean suspend marker found, doing a resume!");
|
||||||
///////////TODO
|
|
||||||
|
|
||||||
// SATP restore is handled by the `start_kernel` assembly pre-amble
|
// SATP restore is handled by the `start_kernel` assembly pre-amble
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -1130,6 +1131,7 @@ fn boot_sequence(args: KernelArguments, _signature: u32) -> ! {
|
||||||
cfg.processes[0].entrypoint,
|
cfg.processes[0].entrypoint,
|
||||||
cfg.processes[0].sp,
|
cfg.processes[0].sp,
|
||||||
cfg.debug,
|
cfg.debug,
|
||||||
|
clean,
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -139,14 +139,6 @@ pub(crate) const SERVER_NAME_LLIO: &str = "_Low Level I/O manager_";
|
||||||
//////////////////////////////////// OPCODES
|
//////////////////////////////////// OPCODES
|
||||||
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)]
|
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)]
|
||||||
pub(crate) enum Opcode {
|
pub(crate) enum Opcode {
|
||||||
/// not tested - reboot
|
|
||||||
RebootRequest,
|
|
||||||
RebootSocConfirm, // all peripherals + CPU
|
|
||||||
RebootCpuConfirm, // just the CPU, peripherals (in particular the USB debug bridge) keep state
|
|
||||||
|
|
||||||
/// not tested - reboot address
|
|
||||||
RebootVector, //(u32),
|
|
||||||
|
|
||||||
/// not tested - set CRG parameters
|
/// not tested - set CRG parameters
|
||||||
CrgMode, //(ClockMode),
|
CrgMode, //(ClockMode),
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -31,7 +31,6 @@ mod implementation {
|
||||||
|
|
||||||
#[allow(dead_code)]
|
#[allow(dead_code)]
|
||||||
pub struct Llio {
|
pub struct Llio {
|
||||||
reboot_csr: utralib::CSR<u32>,
|
|
||||||
crg_csr: utralib::CSR<u32>,
|
crg_csr: utralib::CSR<u32>,
|
||||||
gpio_csr: utralib::CSR<u32>,
|
gpio_csr: utralib::CSR<u32>,
|
||||||
gpio_susres: RegManager::<{utra::gpio::GPIO_NUMREGS}>,
|
gpio_susres: RegManager::<{utra::gpio::GPIO_NUMREGS}>,
|
||||||
|
|
@ -127,13 +126,6 @@ mod implementation {
|
||||||
pub fn get_i2c_base(&self) -> *mut u32 { self.i2c_csr.base }
|
pub fn get_i2c_base(&self) -> *mut u32 { self.i2c_csr.base }
|
||||||
|
|
||||||
pub fn new(handler_conn: xous::CID, gpio_base: *mut u32) -> Llio {
|
pub fn new(handler_conn: xous::CID, gpio_base: *mut u32) -> Llio {
|
||||||
let reboot_csr = xous::syscall::map_memory(
|
|
||||||
xous::MemoryAddress::new(utra::reboot::HW_REBOOT_BASE),
|
|
||||||
None,
|
|
||||||
4096,
|
|
||||||
xous::MemoryFlags::R | xous::MemoryFlags::W,
|
|
||||||
)
|
|
||||||
.expect("couldn't map Reboot CSR range");
|
|
||||||
let crg_csr = xous::syscall::map_memory(
|
let crg_csr = xous::syscall::map_memory(
|
||||||
xous::MemoryAddress::new(utra::crg::HW_CRG_BASE),
|
xous::MemoryAddress::new(utra::crg::HW_CRG_BASE),
|
||||||
None,
|
None,
|
||||||
|
|
@ -187,7 +179,6 @@ mod implementation {
|
||||||
let ticktimer = ticktimer_server::Ticktimer::new().expect("Couldn't connect to Ticktimer");
|
let ticktimer = ticktimer_server::Ticktimer::new().expect("Couldn't connect to Ticktimer");
|
||||||
|
|
||||||
let mut xl = Llio {
|
let mut xl = Llio {
|
||||||
reboot_csr: CSR::new(reboot_csr.as_mut_ptr() as *mut u32),
|
|
||||||
crg_csr: CSR::new(crg_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_csr: CSR::new(gpio_base),
|
||||||
gpio_susres: RegManager::new(gpio_base),
|
gpio_susres: RegManager::new(gpio_base),
|
||||||
|
|
@ -289,16 +280,6 @@ mod implementation {
|
||||||
self.i2c_susres.resume();
|
self.i2c_susres.resume();
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn reboot(&mut self, reboot_soc: bool) {
|
|
||||||
if reboot_soc {
|
|
||||||
self.reboot_csr.wfo(utra::reboot::SOC_RESET_SOC_RESET, 0xAC);
|
|
||||||
} else {
|
|
||||||
self.reboot_csr.wfo(utra::reboot::CPU_RESET_CPU_RESET, 1);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
pub fn set_reboot_vector(&mut self, vector: u32) {
|
|
||||||
self.reboot_csr.wfo(utra::reboot::ADDR_ADDR, vector);
|
|
||||||
}
|
|
||||||
pub fn gpio_dout(&mut self, d: u32) {
|
pub fn gpio_dout(&mut self, d: u32) {
|
||||||
self.gpio_csr.wfo(utra::gpio::OUTPUT_OUTPUT, d);
|
self.gpio_csr.wfo(utra::gpio::OUTPUT_OUTPUT, d);
|
||||||
}
|
}
|
||||||
|
|
@ -484,8 +465,6 @@ mod implementation {
|
||||||
|
|
||||||
pub fn suspend(&self) {}
|
pub fn suspend(&self) {}
|
||||||
pub fn resume(&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) {}
|
pub fn gpio_dout(&self, _d: u32) {}
|
||||||
pub fn gpio_din(&self, ) -> u32 { 0xDEAD_BEEF }
|
pub fn gpio_din(&self, ) -> u32 { 0xDEAD_BEEF }
|
||||||
pub fn gpio_drive(&self, _d: u32) {}
|
pub fn gpio_drive(&self, _d: u32) {}
|
||||||
|
|
@ -588,220 +567,195 @@ fn xmain() -> ! {
|
||||||
let mut gpio_cb_conns: [Option<ScalarCallback>; 32] = [None; 32];
|
let mut gpio_cb_conns: [Option<ScalarCallback>; 32] = [None; 32];
|
||||||
|
|
||||||
log::trace!("starting main loop");
|
log::trace!("starting main loop");
|
||||||
let mut reboot_requested: bool = false;
|
|
||||||
loop {
|
loop {
|
||||||
let mut msg = xous::receive_message(llio_sid).unwrap();
|
let mut msg = xous::receive_message(llio_sid).unwrap();
|
||||||
log::trace!("Message: {:?}", msg);
|
log::trace!("Message: {:?}", msg);
|
||||||
if reboot_requested {
|
match FromPrimitive::from_usize(msg.body.id()) {
|
||||||
match FromPrimitive::from_usize(msg.body.id()) {
|
Some(Opcode::SuspendResume) => xous::msg_scalar_unpack!(msg, token, _, _, _, {
|
||||||
Some(Opcode::RebootCpuConfirm) => {
|
llio.suspend();
|
||||||
llio.reboot(false);
|
susres.suspend_until_resume(token).expect("couldn't execute suspend/resume");
|
||||||
|
llio.resume();
|
||||||
|
}),
|
||||||
|
Some(Opcode::CrgMode) => msg_scalar_unpack!(msg, _mode, _, _, _, {
|
||||||
|
todo!("CrgMode opcode not yet implemented.");
|
||||||
|
}),
|
||||||
|
Some(Opcode::GpioDataOut) => msg_scalar_unpack!(msg, d, _, _, _, {
|
||||||
|
llio.gpio_dout(d as u32);
|
||||||
|
}),
|
||||||
|
Some(Opcode::GpioDataIn) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
||||||
|
xous::return_scalar(msg.sender, llio.gpio_din() as usize).expect("couldn't return gpio data in");
|
||||||
|
}),
|
||||||
|
Some(Opcode::GpioDataDrive) => msg_scalar_unpack!(msg, d, _, _, _, {
|
||||||
|
llio.gpio_drive(d as u32);
|
||||||
|
}),
|
||||||
|
Some(Opcode::GpioIntMask) => msg_scalar_unpack!(msg, d, _, _, _, {
|
||||||
|
llio.gpio_int_mask(d as u32);
|
||||||
|
}),
|
||||||
|
Some(Opcode::GpioIntAsFalling) => msg_scalar_unpack!(msg, d, _, _, _, {
|
||||||
|
llio.gpio_int_as_falling(d as u32);
|
||||||
|
}),
|
||||||
|
Some(Opcode::GpioIntPending) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
||||||
|
xous::return_scalar(msg.sender, llio.gpio_int_pending() as usize).expect("couldn't return gpio pending vector");
|
||||||
|
}),
|
||||||
|
Some(Opcode::GpioIntEna) => msg_scalar_unpack!(msg, d, _, _, _, {
|
||||||
|
llio.gpio_int_ena(d as u32);
|
||||||
|
}),
|
||||||
|
Some(Opcode::UartMux) => msg_scalar_unpack!(msg, mux, _, _, _, {
|
||||||
|
llio.set_uart_mux(mux.into());
|
||||||
|
}),
|
||||||
|
Some(Opcode::InfoDna) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
||||||
|
let (val1, val2) = llio.get_info_dna();
|
||||||
|
xous::return_scalar2(msg.sender, val1, val2).expect("couldn't return DNA");
|
||||||
|
}),
|
||||||
|
Some(Opcode::InfoGit) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
||||||
|
let (val1, val2) = llio.get_info_git();
|
||||||
|
xous::return_scalar2(msg.sender, val1, val2).expect("couldn't return Git");
|
||||||
|
}),
|
||||||
|
Some(Opcode::InfoPlatform) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
||||||
|
let (val1, val2) = llio.get_info_platform();
|
||||||
|
xous::return_scalar2(msg.sender, val1, val2).expect("couldn't return Platform");
|
||||||
|
}),
|
||||||
|
Some(Opcode::InfoTarget) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
||||||
|
let (val1, val2) = llio.get_info_target();
|
||||||
|
xous::return_scalar2(msg.sender, val1, val2).expect("couldn't return Target");
|
||||||
|
}),
|
||||||
|
Some(Opcode::PowerAudio) => msg_scalar_unpack!(msg, power_on, _, _, _, {
|
||||||
|
if power_on == 0 {
|
||||||
|
llio.power_audio(false);
|
||||||
|
} else {
|
||||||
|
llio.power_audio(true);
|
||||||
}
|
}
|
||||||
Some(Opcode::RebootSocConfirm) => {
|
}),
|
||||||
llio.reboot(true);
|
Some(Opcode::PowerSelf) => msg_scalar_unpack!(msg, power_on, _, _, _, {
|
||||||
|
if power_on == 0 {
|
||||||
|
llio.power_self(false);
|
||||||
|
} else {
|
||||||
|
llio.power_self(true);
|
||||||
}
|
}
|
||||||
_ => reboot_requested = false,
|
}),
|
||||||
|
Some(Opcode::PowerBoostMode) => msg_scalar_unpack!(msg, power_on, _, _, _, {
|
||||||
|
if power_on == 0 {
|
||||||
|
llio.power_boost_mode(false);
|
||||||
|
} else {
|
||||||
|
llio.power_boost_mode(true);
|
||||||
|
}
|
||||||
|
}),
|
||||||
|
Some(Opcode::EcSnoopAllow) => msg_scalar_unpack!(msg, power_on, _, _, _, {
|
||||||
|
if power_on == 0 {
|
||||||
|
llio.ec_snoop_allow(false);
|
||||||
|
} else {
|
||||||
|
llio.ec_snoop_allow(true);
|
||||||
|
}
|
||||||
|
}),
|
||||||
|
Some(Opcode::EcReset) => msg_scalar_unpack!(msg, _, _, _, _, {
|
||||||
|
llio.ec_reset();
|
||||||
|
}),
|
||||||
|
Some(Opcode::EcPowerOn) => msg_scalar_unpack!(msg, _, _, _, _, {
|
||||||
|
llio.ec_power_on();
|
||||||
|
}),
|
||||||
|
Some(Opcode::SelfDestruct) => msg_scalar_unpack!(msg, code, _, _, _, {
|
||||||
|
llio.self_destruct(code as u32);
|
||||||
|
}),
|
||||||
|
Some(Opcode::Vibe) => msg_scalar_unpack!(msg, pattern, _, _, _, {
|
||||||
|
llio.vibe(pattern.into());
|
||||||
|
}),
|
||||||
|
Some(Opcode::AdcVbus) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
||||||
|
xous::return_scalar(msg.sender, llio.xadc_vbus() as _).expect("couldn't return Xadc");
|
||||||
|
}),
|
||||||
|
Some(Opcode::AdcVccInt) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
||||||
|
xous::return_scalar(msg.sender, llio.xadc_vccint() as _).expect("couldn't return Xadc");
|
||||||
|
}),
|
||||||
|
Some(Opcode::AdcVccAux) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
||||||
|
xous::return_scalar(msg.sender, llio.xadc_vccaux() as _).expect("couldn't return Xadc");
|
||||||
|
}),
|
||||||
|
Some(Opcode::AdcVccBram) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
||||||
|
xous::return_scalar(msg.sender, llio.xadc_vccbram() as _).expect("couldn't return Xadc");
|
||||||
|
}),
|
||||||
|
Some(Opcode::AdcUsbN) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
||||||
|
xous::return_scalar(msg.sender, llio.xadc_usbn() as _).expect("couldn't return Xadc");
|
||||||
|
}),
|
||||||
|
Some(Opcode::AdcUsbP) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
||||||
|
xous::return_scalar(msg.sender, llio.xadc_usbp() as _).expect("couldn't return Xadc");
|
||||||
|
}),
|
||||||
|
Some(Opcode::AdcTemperature) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
||||||
|
xous::return_scalar(msg.sender, llio.xadc_temperature() as _).expect("couldn't return Xadc");
|
||||||
|
}),
|
||||||
|
Some(Opcode::AdcGpio5) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
||||||
|
xous::return_scalar(msg.sender, llio.xadc_gpio5() as _).expect("couldn't return Xadc");
|
||||||
|
}),
|
||||||
|
Some(Opcode::AdcGpio2) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
||||||
|
xous::return_scalar(msg.sender, llio.xadc_gpio2() as _).expect("couldn't return Xadc");
|
||||||
|
}),
|
||||||
|
Some(Opcode::IrqI2cTxrxDone) => msg_scalar_unpack!(msg, _, _, _, _, {
|
||||||
|
// I2C state machine handler irq received
|
||||||
|
i2c_machine.handler();
|
||||||
|
}),
|
||||||
|
Some(Opcode::I2cTxRx) => {
|
||||||
|
let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
|
||||||
|
let i2c_txrx = buffer.to_original::<llio::api::I2cTransaction, _>().unwrap();
|
||||||
|
let status = i2c_machine.initiate(i2c_txrx);
|
||||||
|
buffer.replace(status).unwrap();
|
||||||
}
|
}
|
||||||
} else {
|
Some(Opcode::I2cIsBusy) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
||||||
match FromPrimitive::from_usize(msg.body.id()) {
|
let busy = if i2c_machine.is_busy() {1} else {0};
|
||||||
Some(Opcode::SuspendResume) => xous::msg_scalar_unpack!(msg, token, _, _, _, {
|
xous::return_scalar(msg.sender, busy as _).expect("couldn't return I2cIsBusy");
|
||||||
llio.suspend();
|
}),
|
||||||
susres.suspend_until_resume(token).expect("couldn't execute suspend/resume");
|
Some(Opcode::EventUsbAttachSubscribe) => {
|
||||||
llio.resume();
|
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
|
||||||
}),
|
let hookdata = buffer.to_original::<ScalarHook, _>().unwrap();
|
||||||
Some(Opcode::RebootRequest) => {
|
do_hook(hookdata, &mut usb_cb_conns);
|
||||||
reboot_requested = true;
|
}
|
||||||
},
|
Some(Opcode::EventComSubscribe) => {
|
||||||
Some(Opcode::RebootCpuConfirm) => {
|
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
|
||||||
info!("RebootCpuConfirm, but no prior Request. Ignoring.");
|
let hookdata = buffer.to_original::<ScalarHook, _>().unwrap();
|
||||||
},
|
do_hook(hookdata, &mut com_cb_conns);
|
||||||
Some(Opcode::RebootSocConfirm) => {
|
}
|
||||||
info!("RebootSocConfirm, but no prior Request. Ignoring.");
|
Some(Opcode::EventRtcSubscribe) => {
|
||||||
},
|
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
|
||||||
Some(Opcode::RebootVector) => msg_scalar_unpack!(msg, vector, _, _, _, {
|
let hookdata = buffer.to_original::<ScalarHook, _>().unwrap();
|
||||||
llio.set_reboot_vector(vector as u32);
|
do_hook(hookdata, &mut rtc_cb_conns);
|
||||||
}),
|
}
|
||||||
Some(Opcode::CrgMode) => msg_scalar_unpack!(msg, _mode, _, _, _, {
|
Some(Opcode::GpioIntSubscribe) => {
|
||||||
todo!("CrgMode opcode not yet implemented.");
|
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
|
||||||
}),
|
let hookdata = buffer.to_original::<ScalarHook, _>().unwrap();
|
||||||
Some(Opcode::GpioDataOut) => msg_scalar_unpack!(msg, d, _, _, _, {
|
do_hook(hookdata, &mut gpio_cb_conns);
|
||||||
llio.gpio_dout(d as u32);
|
}
|
||||||
}),
|
Some(Opcode::EventComEnable) => msg_scalar_unpack!(msg, ena, _, _, _, {
|
||||||
Some(Opcode::GpioDataIn) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
if ena == 0 {
|
||||||
xous::return_scalar(msg.sender, llio.gpio_din() as usize).expect("couldn't return gpio data in");
|
llio.com_int_ena(false);
|
||||||
}),
|
} else {
|
||||||
Some(Opcode::GpioDataDrive) => msg_scalar_unpack!(msg, d, _, _, _, {
|
llio.com_int_ena(true);
|
||||||
llio.gpio_drive(d as u32);
|
|
||||||
}),
|
|
||||||
Some(Opcode::GpioIntMask) => msg_scalar_unpack!(msg, d, _, _, _, {
|
|
||||||
llio.gpio_int_mask(d as u32);
|
|
||||||
}),
|
|
||||||
Some(Opcode::GpioIntAsFalling) => msg_scalar_unpack!(msg, d, _, _, _, {
|
|
||||||
llio.gpio_int_as_falling(d as u32);
|
|
||||||
}),
|
|
||||||
Some(Opcode::GpioIntPending) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
|
||||||
xous::return_scalar(msg.sender, llio.gpio_int_pending() as usize).expect("couldn't return gpio pending vector");
|
|
||||||
}),
|
|
||||||
Some(Opcode::GpioIntEna) => msg_scalar_unpack!(msg, d, _, _, _, {
|
|
||||||
llio.gpio_int_ena(d as u32);
|
|
||||||
}),
|
|
||||||
Some(Opcode::UartMux) => msg_scalar_unpack!(msg, mux, _, _, _, {
|
|
||||||
llio.set_uart_mux(mux.into());
|
|
||||||
}),
|
|
||||||
Some(Opcode::InfoDna) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
|
||||||
let (val1, val2) = llio.get_info_dna();
|
|
||||||
xous::return_scalar2(msg.sender, val1, val2).expect("couldn't return DNA");
|
|
||||||
}),
|
|
||||||
Some(Opcode::InfoGit) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
|
||||||
let (val1, val2) = llio.get_info_git();
|
|
||||||
xous::return_scalar2(msg.sender, val1, val2).expect("couldn't return Git");
|
|
||||||
}),
|
|
||||||
Some(Opcode::InfoPlatform) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
|
||||||
let (val1, val2) = llio.get_info_platform();
|
|
||||||
xous::return_scalar2(msg.sender, val1, val2).expect("couldn't return Platform");
|
|
||||||
}),
|
|
||||||
Some(Opcode::InfoTarget) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
|
||||||
let (val1, val2) = llio.get_info_target();
|
|
||||||
xous::return_scalar2(msg.sender, val1, val2).expect("couldn't return Target");
|
|
||||||
}),
|
|
||||||
Some(Opcode::PowerAudio) => msg_scalar_unpack!(msg, power_on, _, _, _, {
|
|
||||||
if power_on == 0 {
|
|
||||||
llio.power_audio(false);
|
|
||||||
} else {
|
|
||||||
llio.power_audio(true);
|
|
||||||
}
|
|
||||||
}),
|
|
||||||
Some(Opcode::PowerSelf) => msg_scalar_unpack!(msg, power_on, _, _, _, {
|
|
||||||
if power_on == 0 {
|
|
||||||
llio.power_self(false);
|
|
||||||
} else {
|
|
||||||
llio.power_self(true);
|
|
||||||
}
|
|
||||||
}),
|
|
||||||
Some(Opcode::PowerBoostMode) => msg_scalar_unpack!(msg, power_on, _, _, _, {
|
|
||||||
if power_on == 0 {
|
|
||||||
llio.power_boost_mode(false);
|
|
||||||
} else {
|
|
||||||
llio.power_boost_mode(true);
|
|
||||||
}
|
|
||||||
}),
|
|
||||||
Some(Opcode::EcSnoopAllow) => msg_scalar_unpack!(msg, power_on, _, _, _, {
|
|
||||||
if power_on == 0 {
|
|
||||||
llio.ec_snoop_allow(false);
|
|
||||||
} else {
|
|
||||||
llio.ec_snoop_allow(true);
|
|
||||||
}
|
|
||||||
}),
|
|
||||||
Some(Opcode::EcReset) => msg_scalar_unpack!(msg, _, _, _, _, {
|
|
||||||
llio.ec_reset();
|
|
||||||
}),
|
|
||||||
Some(Opcode::EcPowerOn) => msg_scalar_unpack!(msg, _, _, _, _, {
|
|
||||||
llio.ec_power_on();
|
|
||||||
}),
|
|
||||||
Some(Opcode::SelfDestruct) => msg_scalar_unpack!(msg, code, _, _, _, {
|
|
||||||
llio.self_destruct(code as u32);
|
|
||||||
}),
|
|
||||||
Some(Opcode::Vibe) => msg_scalar_unpack!(msg, pattern, _, _, _, {
|
|
||||||
llio.vibe(pattern.into());
|
|
||||||
}),
|
|
||||||
Some(Opcode::AdcVbus) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
|
||||||
xous::return_scalar(msg.sender, llio.xadc_vbus() as _).expect("couldn't return Xadc");
|
|
||||||
}),
|
|
||||||
Some(Opcode::AdcVccInt) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
|
||||||
xous::return_scalar(msg.sender, llio.xadc_vccint() as _).expect("couldn't return Xadc");
|
|
||||||
}),
|
|
||||||
Some(Opcode::AdcVccAux) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
|
||||||
xous::return_scalar(msg.sender, llio.xadc_vccaux() as _).expect("couldn't return Xadc");
|
|
||||||
}),
|
|
||||||
Some(Opcode::AdcVccBram) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
|
||||||
xous::return_scalar(msg.sender, llio.xadc_vccbram() as _).expect("couldn't return Xadc");
|
|
||||||
}),
|
|
||||||
Some(Opcode::AdcUsbN) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
|
||||||
xous::return_scalar(msg.sender, llio.xadc_usbn() as _).expect("couldn't return Xadc");
|
|
||||||
}),
|
|
||||||
Some(Opcode::AdcUsbP) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
|
||||||
xous::return_scalar(msg.sender, llio.xadc_usbp() as _).expect("couldn't return Xadc");
|
|
||||||
}),
|
|
||||||
Some(Opcode::AdcTemperature) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
|
||||||
xous::return_scalar(msg.sender, llio.xadc_temperature() as _).expect("couldn't return Xadc");
|
|
||||||
}),
|
|
||||||
Some(Opcode::AdcGpio5) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
|
||||||
xous::return_scalar(msg.sender, llio.xadc_gpio5() as _).expect("couldn't return Xadc");
|
|
||||||
}),
|
|
||||||
Some(Opcode::AdcGpio2) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
|
||||||
xous::return_scalar(msg.sender, llio.xadc_gpio2() as _).expect("couldn't return Xadc");
|
|
||||||
}),
|
|
||||||
Some(Opcode::IrqI2cTxrxDone) => msg_scalar_unpack!(msg, _, _, _, _, {
|
|
||||||
// I2C state machine handler irq received
|
|
||||||
i2c_machine.handler();
|
|
||||||
}),
|
|
||||||
Some(Opcode::I2cTxRx) => {
|
|
||||||
let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
|
|
||||||
let i2c_txrx = buffer.to_original::<llio::api::I2cTransaction, _>().unwrap();
|
|
||||||
let status = i2c_machine.initiate(i2c_txrx);
|
|
||||||
buffer.replace(status).unwrap();
|
|
||||||
}
|
}
|
||||||
Some(Opcode::I2cIsBusy) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
}),
|
||||||
let busy = if i2c_machine.is_busy() {1} else {0};
|
Some(Opcode::EventRtcEnable) => msg_scalar_unpack!(msg, ena, _, _, _, {
|
||||||
xous::return_scalar(msg.sender, busy as _).expect("couldn't return I2cIsBusy");
|
if ena == 0 {
|
||||||
}),
|
llio.rtc_int_ena(false);
|
||||||
Some(Opcode::EventUsbAttachSubscribe) => {
|
} else {
|
||||||
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
|
llio.rtc_int_ena(true);
|
||||||
let hookdata = buffer.to_original::<ScalarHook, _>().unwrap();
|
|
||||||
do_hook(hookdata, &mut usb_cb_conns);
|
|
||||||
}
|
}
|
||||||
Some(Opcode::EventComSubscribe) => {
|
}),
|
||||||
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
|
Some(Opcode::EventUsbAttachEnable) => msg_scalar_unpack!(msg, ena, _, _, _, {
|
||||||
let hookdata = buffer.to_original::<ScalarHook, _>().unwrap();
|
if ena == 0 {
|
||||||
do_hook(hookdata, &mut com_cb_conns);
|
llio.usb_int_ena(false);
|
||||||
}
|
} else {
|
||||||
Some(Opcode::EventRtcSubscribe) => {
|
llio.usb_int_ena(true);
|
||||||
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
|
|
||||||
let hookdata = buffer.to_original::<ScalarHook, _>().unwrap();
|
|
||||||
do_hook(hookdata, &mut rtc_cb_conns);
|
|
||||||
}
|
|
||||||
Some(Opcode::GpioIntSubscribe) => {
|
|
||||||
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
|
|
||||||
let hookdata = buffer.to_original::<ScalarHook, _>().unwrap();
|
|
||||||
do_hook(hookdata, &mut gpio_cb_conns);
|
|
||||||
}
|
|
||||||
Some(Opcode::EventComEnable) => msg_scalar_unpack!(msg, ena, _, _, _, {
|
|
||||||
if ena == 0 {
|
|
||||||
llio.com_int_ena(false);
|
|
||||||
} else {
|
|
||||||
llio.com_int_ena(true);
|
|
||||||
}
|
|
||||||
}),
|
|
||||||
Some(Opcode::EventRtcEnable) => msg_scalar_unpack!(msg, ena, _, _, _, {
|
|
||||||
if ena == 0 {
|
|
||||||
llio.rtc_int_ena(false);
|
|
||||||
} else {
|
|
||||||
llio.rtc_int_ena(true);
|
|
||||||
}
|
|
||||||
}),
|
|
||||||
Some(Opcode::EventUsbAttachEnable) => msg_scalar_unpack!(msg, ena, _, _, _, {
|
|
||||||
if ena == 0 {
|
|
||||||
llio.usb_int_ena(false);
|
|
||||||
} else {
|
|
||||||
llio.usb_int_ena(true);
|
|
||||||
}
|
|
||||||
}),
|
|
||||||
Some(Opcode::EventComHappened) => {
|
|
||||||
send_event(&com_cb_conns, 0);
|
|
||||||
},
|
|
||||||
Some(Opcode::EventRtcHappened) => {
|
|
||||||
send_event(&rtc_cb_conns, 0);
|
|
||||||
},
|
|
||||||
Some(Opcode::EventUsbHappened) => {
|
|
||||||
send_event(&usb_cb_conns, 0);
|
|
||||||
},
|
|
||||||
Some(Opcode::GpioIntHappened) => msg_scalar_unpack!(msg, channel, _, _, _, {
|
|
||||||
send_event(&gpio_cb_conns, channel as usize);
|
|
||||||
}),
|
|
||||||
None => {
|
|
||||||
error!("couldn't convert opcode");
|
|
||||||
break;
|
|
||||||
}
|
}
|
||||||
|
}),
|
||||||
|
Some(Opcode::EventComHappened) => {
|
||||||
|
send_event(&com_cb_conns, 0);
|
||||||
|
},
|
||||||
|
Some(Opcode::EventRtcHappened) => {
|
||||||
|
send_event(&rtc_cb_conns, 0);
|
||||||
|
},
|
||||||
|
Some(Opcode::EventUsbHappened) => {
|
||||||
|
send_event(&usb_cb_conns, 0);
|
||||||
|
},
|
||||||
|
Some(Opcode::GpioIntHappened) => msg_scalar_unpack!(msg, channel, _, _, _, {
|
||||||
|
send_event(&gpio_cb_conns, channel as usize);
|
||||||
|
}),
|
||||||
|
None => {
|
||||||
|
error!("couldn't convert opcode");
|
||||||
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -19,6 +19,14 @@ pub(crate) enum Opcode {
|
||||||
/// from the timeout thread
|
/// from the timeout thread
|
||||||
SuspendTimeout,
|
SuspendTimeout,
|
||||||
|
|
||||||
|
/// not tested - reboot
|
||||||
|
RebootRequest,
|
||||||
|
RebootSocConfirm, // all peripherals + CPU
|
||||||
|
RebootCpuConfirm, // just the CPU, peripherals (in particular the USB debug bridge) keep state
|
||||||
|
|
||||||
|
/// not tested - reboot address
|
||||||
|
RebootVector, //(u32),
|
||||||
|
|
||||||
/// exit the server
|
/// exit the server
|
||||||
Quit,
|
Quit,
|
||||||
}
|
}
|
||||||
|
|
@ -206,106 +214,3 @@ impl<const N: usize> SuspendResume for ManagedMem<N> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
// "suspend/resume u32"
|
|
||||||
struct SrU32 {
|
|
||||||
/// offset of the register
|
|
||||||
offset: crate::Register,
|
|
||||||
/// the saved value of the register
|
|
||||||
value: u32,
|
|
||||||
/// the order in which this register should be written. If none, it's written at any convenient time.
|
|
||||||
resume_order: Option<u8>,
|
|
||||||
/// if this register should be in the suspend/resume set
|
|
||||||
do_sr: bool,
|
|
||||||
}
|
|
||||||
|
|
||||||
/* sketching some structs for suspend/resume */
|
|
||||||
struct TicktimerSusres {
|
|
||||||
csr: utralib::CSR<u32>, // new(csr_base) will allocate this register, from the virtual CSR base given to us by the owning server
|
|
||||||
pub control: Option<u32>,
|
|
||||||
pub time1: Option<u32>,
|
|
||||||
pub time0: Option<u32>,
|
|
||||||
pub resume_time1: Option<u32>,
|
|
||||||
pub resume_time0: Option<u32>,
|
|
||||||
pub status: Option<u32>,
|
|
||||||
pub msleep_target1: Option<u32>,
|
|
||||||
pub msleep_target0: Option<u32>,
|
|
||||||
pub ev_status: Option<u32>,
|
|
||||||
pub ev_pending: Option<u32>,
|
|
||||||
pub ev_enable: Option<u32>,
|
|
||||||
pub ticktimer_irq: Option<bool>, // whether to enable or not after resume
|
|
||||||
pub wait_suspend: Option<fn(timeout: u32) -> bool>, // function to call to check if a block can suspend
|
|
||||||
}
|
|
||||||
pub trait SuspendResume {
|
|
||||||
pub fn suspend(&mut self) {
|
|
||||||
/*
|
|
||||||
go through each item of the structure, and if the item is Some(item), access the corresponding
|
|
||||||
register and save it into the register
|
|
||||||
*/
|
|
||||||
}
|
|
||||||
pub fn resume(&mut self) {
|
|
||||||
/*
|
|
||||||
go through each item of the stucture, and if the item is Some(item), unwrap the value and
|
|
||||||
poke it into the register
|
|
||||||
*/
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
enum TickttimerReg {
|
|
||||||
Control = 0,
|
|
||||||
Time1 = 1,
|
|
||||||
Time0 = 2,
|
|
||||||
MSleepTarget1 = 3,
|
|
||||||
//...
|
|
||||||
}
|
|
||||||
//enum TickttimerInterrupt {
|
|
||||||
// Alarm = 0,
|
|
||||||
//}
|
|
||||||
|
|
||||||
struct ManagedReg {
|
|
||||||
offset: TickttimerReg,
|
|
||||||
mask: usize, // mask of data to store
|
|
||||||
value: u32,
|
|
||||||
}
|
|
||||||
//struct ManagedInterrupt {
|
|
||||||
// irq: usize,
|
|
||||||
//}
|
|
||||||
struct ManagedMem {
|
|
||||||
offset: usize, // the starting offset of the volatile memory block
|
|
||||||
mem: [u32; MEMLEN], // backup copy of the memory
|
|
||||||
}
|
|
||||||
// this can operate on the above three structure
|
|
||||||
pub trait SusResOps {
|
|
||||||
fn save();
|
|
||||||
fn restore();
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
Interrupts need no suspend/resume setup:
|
|
||||||
- the hooks and callback locations are all stored in non-volatile SRAM
|
|
||||||
- the SIM register, which contains the mask of interrupts that are enabled, will be restored
|
|
||||||
by the loader on boot
|
|
||||||
|
|
||||||
Between these two facts, all of the interrupt mechanism are transparently handled by the kernel
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
struct SusResManager {
|
|
||||||
csr: utralib::CSR<u32>,
|
|
||||||
pub registers: [Option<ManagedReg>; 12], // max number is set by the utra2svd generator
|
|
||||||
//pub interrupts: [Option<usize>; 1], // if in this list, this interrupt should be enabled
|
|
||||||
|
|
||||||
// i think maybe these go in the library, not in the auto-generated manager structure
|
|
||||||
pub suspend_cb: fn(),
|
|
||||||
pub resume_cb: fn(),
|
|
||||||
}
|
|
||||||
pub trait SusResBlockOps {
|
|
||||||
fn append(reg: ManagedReg); // adds a register to the managed suspend list
|
|
||||||
fn suspend(); // iterates through the list of registers and performs the suspend operation
|
|
||||||
fn resume(); // iterates through the list of registers and performs the resume operation
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
@ -51,6 +51,9 @@ mod implementation {
|
||||||
timer.wfo(utra::timer0::EV_PENDING_ZERO, 0b1);
|
timer.wfo(utra::timer0::EV_PENDING_ZERO, 0b1);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// this is just for testing, remove for production
|
||||||
|
static REBOOT_CSR: core::sync::atomic::AtomicU32 = core::sync::atomic::AtomicU32::new(0);
|
||||||
|
|
||||||
// we do all the suspend/resume coordination in an interrupt context
|
// we do all the suspend/resume coordination in an interrupt context
|
||||||
// the process state is pushed to main memory prior to entering this routine, so it's staged for a resume
|
// the process state is pushed to main memory prior to entering this routine, so it's staged for a resume
|
||||||
// on a clean suspend then resume, the loader will queue up this interrupt to be the first thing to
|
// on a clean suspend then resume, the loader will queue up this interrupt to be the first thing to
|
||||||
|
|
@ -61,12 +64,17 @@ mod implementation {
|
||||||
sr.csr.wfo(utra::susres::EV_PENDING_SOFT_INT, 1);
|
sr.csr.wfo(utra::susres::EV_PENDING_SOFT_INT, 1);
|
||||||
|
|
||||||
// set this to true to do a touch-and-go suspend/resume (no actual power off, but the whole prep cycle in play)
|
// set this to true to do a touch-and-go suspend/resume (no actual power off, but the whole prep cycle in play)
|
||||||
let touch_and_go = true;
|
let touch_and_go = false;
|
||||||
if touch_and_go {
|
if touch_and_go {
|
||||||
sr.csr.wfo(utra::susres::STATE_RESUME, 1);
|
sr.csr.wfo(utra::susres::STATE_RESUME, 1);
|
||||||
}
|
}
|
||||||
|
|
||||||
if sr.csr.rf(utra::susres::STATE_RESUME) == 0 {
|
if sr.csr.rf(utra::susres::STATE_RESUME) == 0 {
|
||||||
|
{ // this is just for testing
|
||||||
|
let mut reboot_csr = CSR::new(REBOOT_CSR.load(Ordering::Relaxed) as *mut u32);
|
||||||
|
reboot_csr.wfo(utra::reboot::SOC_RESET_SOC_RESET, 0xAC);
|
||||||
|
}
|
||||||
|
|
||||||
// power the system down - this should result in an almost immediate loss of power
|
// power the system down - this should result in an almost immediate loss of power
|
||||||
sr.csr.wfo(utra::susres::POWERDOWN_POWERDOWN, 1);
|
sr.csr.wfo(utra::susres::POWERDOWN_POWERDOWN, 1);
|
||||||
|
|
||||||
|
|
@ -90,6 +98,8 @@ mod implementation {
|
||||||
stored_time: Option<u64>,
|
stored_time: Option<u64>,
|
||||||
/// so we can access the build seed and detect if the FPGA image was changed on us
|
/// so we can access the build seed and detect if the FPGA image was changed on us
|
||||||
seed_csr: utralib::CSR<u32>,
|
seed_csr: utralib::CSR<u32>,
|
||||||
|
/// we also own the reboot facility
|
||||||
|
reboot_csr: utralib::CSR<u32>,
|
||||||
}
|
}
|
||||||
impl SusResHw {
|
impl SusResHw {
|
||||||
pub fn new() -> Self {
|
pub fn new() -> Self {
|
||||||
|
|
@ -135,6 +145,14 @@ mod implementation {
|
||||||
xous::MemoryFlags::R | xous::MemoryFlags::W,
|
xous::MemoryFlags::R | xous::MemoryFlags::W,
|
||||||
)
|
)
|
||||||
.expect("couldn't map Seed CSR range");
|
.expect("couldn't map Seed CSR range");
|
||||||
|
let reboot_csr = xous::syscall::map_memory(
|
||||||
|
xous::MemoryAddress::new(utra::reboot::HW_REBOOT_BASE),
|
||||||
|
None,
|
||||||
|
4096,
|
||||||
|
xous::MemoryFlags::R | xous::MemoryFlags::W,
|
||||||
|
)
|
||||||
|
.expect("couldn't map Reboot CSR range");
|
||||||
|
REBOOT_CSR.store(reboot_csr.as_mut_ptr() as u32, Ordering::Relaxed); // for testing only
|
||||||
let mut sr = SusResHw {
|
let mut sr = SusResHw {
|
||||||
csr: CSR::new(csr.as_mut_ptr() as *mut u32),
|
csr: CSR::new(csr.as_mut_ptr() as *mut u32),
|
||||||
os_timer: CSR::new(ostimer_csr.as_mut_ptr() as *mut u32),
|
os_timer: CSR::new(ostimer_csr.as_mut_ptr() as *mut u32),
|
||||||
|
|
@ -142,6 +160,7 @@ mod implementation {
|
||||||
marker,
|
marker,
|
||||||
loader_stack,
|
loader_stack,
|
||||||
seed_csr: CSR::new(seed_csr.as_mut_ptr() as *mut u32),
|
seed_csr: CSR::new(seed_csr.as_mut_ptr() as *mut u32),
|
||||||
|
reboot_csr: CSR::new(reboot_csr.as_mut_ptr() as *mut u32),
|
||||||
};
|
};
|
||||||
|
|
||||||
// start the OS timer running
|
// start the OS timer running
|
||||||
|
|
@ -177,6 +196,17 @@ mod implementation {
|
||||||
sr
|
sr
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub fn reboot(&mut self, reboot_soc: bool) {
|
||||||
|
if reboot_soc {
|
||||||
|
self.reboot_csr.wfo(utra::reboot::SOC_RESET_SOC_RESET, 0xAC);
|
||||||
|
} else {
|
||||||
|
self.reboot_csr.wfo(utra::reboot::CPU_RESET_CPU_RESET, 1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub fn set_reboot_vector(&mut self, vector: u32) {
|
||||||
|
self.reboot_csr.wfo(utra::reboot::ADDR_ADDR, vector);
|
||||||
|
}
|
||||||
|
|
||||||
pub fn setup_timeout_csr(&mut self, cid: xous::CID) -> Result<(), xous::Error> {
|
pub fn setup_timeout_csr(&mut self, cid: xous::CID) -> Result<(), xous::Error> {
|
||||||
xous::send_message(cid,
|
xous::send_message(cid,
|
||||||
xous::Message::new_scalar(crate::TimeoutOpcode::SetCsr.to_usize().unwrap(), self.csr.base as usize, 0, 0, 0)
|
xous::Message::new_scalar(crate::TimeoutOpcode::SetCsr.to_usize().unwrap(), self.csr.base as usize, 0, 0, 0)
|
||||||
|
|
@ -366,6 +396,8 @@ mod implementation {
|
||||||
pub fn new() -> Self {
|
pub fn new() -> Self {
|
||||||
SusResHw {}
|
SusResHw {}
|
||||||
}
|
}
|
||||||
|
pub fn reboot(&self, _reboot_soc: bool) {}
|
||||||
|
pub fn set_reboot_vector(&self, _vector: u32) {}
|
||||||
pub fn do_suspend(&mut self, _forced: bool) {
|
pub fn do_suspend(&mut self, _forced: bool) {
|
||||||
}
|
}
|
||||||
pub fn do_resume(&mut self) -> bool {
|
pub fn do_resume(&mut self) -> bool {
|
||||||
|
|
@ -518,105 +550,130 @@ fn xmain() -> ! {
|
||||||
|
|
||||||
let mut suspend_requested = false;
|
let mut suspend_requested = false;
|
||||||
let mut timeout_pending = false;
|
let mut timeout_pending = false;
|
||||||
|
let mut reboot_requested: bool = false;
|
||||||
|
|
||||||
let mut suspend_subscribers: [Option<ScalarCallback>; 32] = [None; 32];
|
let mut suspend_subscribers: [Option<ScalarCallback>; 32] = [None; 32];
|
||||||
loop {
|
loop {
|
||||||
let msg = xous::receive_message(susres_sid).unwrap();
|
let msg = xous::receive_message(susres_sid).unwrap();
|
||||||
match FromPrimitive::from_usize(msg.body.id()) {
|
if reboot_requested {
|
||||||
Some(Opcode::SuspendEventSubscribe) => {
|
match FromPrimitive::from_usize(msg.body.id()) {
|
||||||
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
|
Some(Opcode::RebootCpuConfirm) => {
|
||||||
let hookdata = buffer.to_original::<ScalarHook, _>().unwrap();
|
susres_hw.reboot(false);
|
||||||
do_hook(hookdata, &mut suspend_subscribers);
|
|
||||||
},
|
|
||||||
Some(Opcode::SuspendReady) => msg_scalar_unpack!(msg, token, _, _, _, {
|
|
||||||
log::trace!("suspendready with token {}", token);
|
|
||||||
if !suspend_requested {
|
|
||||||
log::error!("received a SuspendReady message when a suspend wasn't pending. Ignoring.");
|
|
||||||
continue;
|
|
||||||
}
|
}
|
||||||
if token >= suspend_subscribers.len() {
|
Some(Opcode::RebootSocConfirm) => {
|
||||||
panic!("received a SuspendReady token that's out of range");
|
susres_hw.reboot(true);
|
||||||
}
|
}
|
||||||
if let Some(mut scb) = suspend_subscribers[token] {
|
_ => reboot_requested = false,
|
||||||
if scb.ready_to_suspend {
|
}
|
||||||
log::error!("received a duplicate SuspendReady token: {} from {:?}", token, scb);
|
} else {
|
||||||
|
match FromPrimitive::from_usize(msg.body.id()) {
|
||||||
|
Some(Opcode::RebootRequest) => {
|
||||||
|
reboot_requested = true;
|
||||||
|
},
|
||||||
|
Some(Opcode::RebootCpuConfirm) => {
|
||||||
|
log::error!("RebootCpuConfirm, but no prior Request. Ignoring.");
|
||||||
|
},
|
||||||
|
Some(Opcode::RebootSocConfirm) => {
|
||||||
|
log::error!("RebootSocConfirm, but no prior Request. Ignoring.");
|
||||||
|
},
|
||||||
|
Some(Opcode::RebootVector) => msg_scalar_unpack!(msg, vector, _, _, _, {
|
||||||
|
susres_hw.set_reboot_vector(vector as u32);
|
||||||
|
}),
|
||||||
|
Some(Opcode::SuspendEventSubscribe) => {
|
||||||
|
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
|
||||||
|
let hookdata = buffer.to_original::<ScalarHook, _>().unwrap();
|
||||||
|
do_hook(hookdata, &mut suspend_subscribers);
|
||||||
|
},
|
||||||
|
Some(Opcode::SuspendReady) => msg_scalar_unpack!(msg, token, _, _, _, {
|
||||||
|
log::trace!("suspendready with token {}", token);
|
||||||
|
if !suspend_requested {
|
||||||
|
log::error!("received a SuspendReady message when a suspend wasn't pending. Ignoring.");
|
||||||
|
continue;
|
||||||
}
|
}
|
||||||
scb.ready_to_suspend = true;
|
if token >= suspend_subscribers.len() {
|
||||||
suspend_subscribers[token] = Some(scb);
|
panic!("received a SuspendReady token that's out of range");
|
||||||
|
}
|
||||||
|
if let Some(mut scb) = suspend_subscribers[token] {
|
||||||
|
if scb.ready_to_suspend {
|
||||||
|
log::error!("received a duplicate SuspendReady token: {} from {:?}", token, scb);
|
||||||
|
}
|
||||||
|
scb.ready_to_suspend = true;
|
||||||
|
suspend_subscribers[token] = Some(scb);
|
||||||
|
|
||||||
let mut all_ready = true;
|
let mut all_ready = true;
|
||||||
for maybe_sub in suspend_subscribers.iter() {
|
for maybe_sub in suspend_subscribers.iter() {
|
||||||
if let Some(sub) = maybe_sub {
|
if let Some(sub) = maybe_sub {
|
||||||
if sub.ready_to_suspend == false {
|
if sub.ready_to_suspend == false {
|
||||||
all_ready = false;
|
all_ready = false;
|
||||||
break;
|
break;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
if all_ready {
|
||||||
|
log::trace!("all callbacks reporting in, doing suspend");
|
||||||
|
timeout_pending = false;
|
||||||
|
susres_hw.do_suspend(false);
|
||||||
|
// when do_suspend() returns, it means we've resumed
|
||||||
|
suspend_requested = false;
|
||||||
|
if susres_hw.do_resume() {
|
||||||
|
log::error!("We did a clean shut-down, but bootloader is saying previous suspend was forced. Some peripherals may be in an unclean state!");
|
||||||
}
|
}
|
||||||
|
// this now allows all other threads to commence
|
||||||
|
log::trace!("low-level resume done, restoring execution");
|
||||||
|
RESUME_EXEC.store(true, Ordering::Relaxed);
|
||||||
|
} else {
|
||||||
|
log::trace!("still waiting on callbacks, returning to main loop");
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
panic!("received an invalid token that does not map to a registered suspend listener");
|
||||||
|
}
|
||||||
|
}),
|
||||||
|
Some(Opcode::SuspendRequest) => {
|
||||||
|
suspend_requested = true;
|
||||||
|
// clear the resume gate
|
||||||
|
SHOULD_RESUME.store(false, Ordering::Relaxed);
|
||||||
|
RESUME_EXEC.store(false, Ordering::Relaxed);
|
||||||
|
// clear the ready to suspend flag
|
||||||
|
for maybe_sub in suspend_subscribers.iter_mut() {
|
||||||
|
if let Some(sub) = maybe_sub {
|
||||||
|
sub.ready_to_suspend = false;
|
||||||
};
|
};
|
||||||
}
|
}
|
||||||
if all_ready {
|
// do we want to start the timeout before or after sending the notifications? hmm. 🤔
|
||||||
log::trace!("all callbacks reporting in, doing suspend");
|
timeout_pending = true;
|
||||||
|
send_message(timeout_outgoing_conn,
|
||||||
|
Message::new_scalar(TimeoutOpcode::Run.to_usize().unwrap(), 0, 0, 0, 0)
|
||||||
|
).expect("couldn't initiate timeout before suspend!");
|
||||||
|
|
||||||
|
send_event(&suspend_subscribers);
|
||||||
|
},
|
||||||
|
Some(Opcode::SuspendTimeout) => {
|
||||||
|
if timeout_pending {
|
||||||
|
log::trace!("suspend call has timed out, forcing a suspend");
|
||||||
timeout_pending = false;
|
timeout_pending = false;
|
||||||
susres_hw.do_suspend(false);
|
// force a suspend
|
||||||
|
susres_hw.do_suspend(true);
|
||||||
// when do_suspend() returns, it means we've resumed
|
// when do_suspend() returns, it means we've resumed
|
||||||
suspend_requested = false;
|
suspend_requested = false;
|
||||||
if susres_hw.do_resume() {
|
if susres_hw.do_resume() {
|
||||||
log::error!("We did a clean shut-down, but bootloader is saying previous suspend was forced. Some peripherals may be in an unclean state!");
|
log::error!("We forced a suspend, some peripherals may be in an unclean state!");
|
||||||
|
} else {
|
||||||
|
log::error!("We forced a suspend, but the bootloader is claiming we did a clean suspend. Internal state may be inconsistent.");
|
||||||
}
|
}
|
||||||
// this now allows all other threads to commence
|
|
||||||
log::trace!("low-level resume done, restoring execution");
|
|
||||||
RESUME_EXEC.store(true, Ordering::Relaxed);
|
RESUME_EXEC.store(true, Ordering::Relaxed);
|
||||||
} else {
|
} else {
|
||||||
log::trace!("still waiting on callbacks, returning to main loop");
|
log::trace!("clean suspend timeout received, ignoring");
|
||||||
|
// this means we did a clean suspend, we've resumed, and the timeout came back after the resume
|
||||||
|
// just ignore the message.
|
||||||
}
|
}
|
||||||
} else {
|
|
||||||
panic!("received an invalid token that does not map to a registered suspend listener");
|
|
||||||
}
|
}
|
||||||
}),
|
Some(Opcode::Quit) => {
|
||||||
Some(Opcode::SuspendRequest) => {
|
break
|
||||||
suspend_requested = true;
|
|
||||||
// clear the resume gate
|
|
||||||
SHOULD_RESUME.store(false, Ordering::Relaxed);
|
|
||||||
RESUME_EXEC.store(false, Ordering::Relaxed);
|
|
||||||
// clear the ready to suspend flag
|
|
||||||
for maybe_sub in suspend_subscribers.iter_mut() {
|
|
||||||
if let Some(sub) = maybe_sub {
|
|
||||||
sub.ready_to_suspend = false;
|
|
||||||
};
|
|
||||||
}
|
}
|
||||||
// do we want to start the timeout before or after sending the notifications? hmm. 🤔
|
None => {
|
||||||
timeout_pending = true;
|
log::error!("couldn't convert opcode");
|
||||||
send_message(timeout_outgoing_conn,
|
|
||||||
Message::new_scalar(TimeoutOpcode::Run.to_usize().unwrap(), 0, 0, 0, 0)
|
|
||||||
).expect("couldn't initiate timeout before suspend!");
|
|
||||||
|
|
||||||
send_event(&suspend_subscribers);
|
|
||||||
},
|
|
||||||
Some(Opcode::SuspendTimeout) => {
|
|
||||||
if timeout_pending {
|
|
||||||
log::trace!("suspend call has timed out, forcing a suspend");
|
|
||||||
timeout_pending = false;
|
|
||||||
// force a suspend
|
|
||||||
susres_hw.do_suspend(true);
|
|
||||||
// when do_suspend() returns, it means we've resumed
|
|
||||||
suspend_requested = false;
|
|
||||||
if susres_hw.do_resume() {
|
|
||||||
log::error!("We forced a suspend, some peripherals may be in an unclean state!");
|
|
||||||
} else {
|
|
||||||
log::error!("We forced a suspend, but the bootloader is claiming we did a clean suspend. Internal state may be inconsistent.");
|
|
||||||
}
|
|
||||||
RESUME_EXEC.store(true, Ordering::Relaxed);
|
|
||||||
} else {
|
|
||||||
log::trace!("clean suspend timeout received, ignoring");
|
|
||||||
// this means we did a clean suspend, we've resumed, and the timeout came back after the resume
|
|
||||||
// just ignore the message.
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
Some(Opcode::Quit) => {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
None => {
|
|
||||||
log::error!("couldn't convert opcode");
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
// clean up our program
|
// clean up our program
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue