diff --git a/kernel/src/arch/riscv.rs b/kernel/src/arch/riscv.rs index df6885888..9d55d8ddf 100644 --- a/kernel/src/arch/riscv.rs +++ b/kernel/src/arch/riscv.rs @@ -17,12 +17,12 @@ pub fn current_pid() -> PID { PID::new(satp::read().asid() as _).unwrap() } -pub fn init() { +pub fn init(resume: bool) { unsafe { sie::set_ssoft(); sie::set_sext(); } - rand::init(); + rand::init(resume); } /// Put the core to sleep until an interrupt hits. Returns `true` diff --git a/kernel/src/arch/riscv/rand.rs b/kernel/src/arch/riscv/rand.rs index 2fdfebc90..ba258139f 100644 --- a/kernel/src/arch/riscv/rand.rs +++ b/kernel/src/arch/riscv/rand.rs @@ -7,15 +7,15 @@ use xous_kernel::{MemoryFlags, MemoryType, PID}; pub const TRNG_KERNEL: Trng = Trng { // 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 - base: 0xffce_0000 as *mut usize, + // 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, // see https://github.com/betrusted-io/xous-core/blob/master/docs/memory.md }; pub struct Trng { pub base: *mut usize, } -pub fn init() { +pub fn init(resume: bool) { // Map the TRNG so that we can allocate names // hardware guarantees that: // - 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 // - The kernel will start a TRNG server // - All further security decisions and policies are 100% delegated to this new server. - MemoryManager::with_mut(|memory_manager| { - memory_manager - .map_range( - utra::trng_kernel::HW_TRNG_KERNEL_BASE as *mut u8, - ((TRNG_KERNEL.base as u32) & !4095) as *mut u8, - 4096, - PID::new(1).unwrap(), - MemoryFlags::R | MemoryFlags::W, - MemoryType::Default, - ) - .expect("unable to map TRNG") - }); + if !resume { + MemoryManager::with_mut(|memory_manager| { + memory_manager + .map_range( + utra::trng_kernel::HW_TRNG_KERNEL_BASE as *mut u8, + ((TRNG_KERNEL.base as u32) & !4095) as *mut u8, + 4096, + PID::new(1).unwrap(), + MemoryFlags::R | MemoryFlags::W, + MemoryType::Default, + ) + .expect("unable to map TRNG") + }); + } let trng_kernel_csr = CSR::new(TRNG_KERNEL.base as *mut u32); while trng_kernel_csr.rf(utra::trng_kernel::STATUS_AVAIL) == 0 {} diff --git a/kernel/src/arch/x86_64.rs b/kernel/src/arch/x86_64.rs index 4e6c17ef7..662ee7d46 100644 --- a/kernel/src/arch/x86_64.rs +++ b/kernel/src/arch/x86_64.rs @@ -27,7 +27,7 @@ pub fn current_pid() -> PID { unimplemented!(); } -pub fn init() {} +pub fn init(resume: bool) {} pub mod syscall { use crate::arch::Context; diff --git a/kernel/src/debug.rs b/kernel/src/debug.rs index afba24bec..cb55c9f95 100644 --- a/kernel/src/debug.rs +++ b/kernel/src/debug.rs @@ -14,7 +14,7 @@ use utralib::generated::*; ))] 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 - 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_rules! print diff --git a/kernel/src/main.rs b/kernel/src/main.rs index 5e12efa48..6f6d7d81e 100644 --- a/kernel/src/main.rs +++ b/kernel/src/main.rs @@ -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)] #[no_mangle] /// 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. -pub extern "C" fn init(arg_offset: *const u32, init_offset: *const u32, rpt_offset: *mut u32) { - unsafe { args::KernelArguments::init(arg_offset) }; - let args = args::KernelArguments::get(); - // Everything needs memory, so the first thing we should do is initialize the memory manager. - crate::mem::MemoryManager::with_mut(|mm| { - 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) - }); +pub extern "C" fn init(arg_offset: *const u32, init_offset: *const u32, rpt_offset: *mut u32, resume: bool) { + if !resume { + unsafe { args::KernelArguments::init(arg_offset) }; + let args = args::KernelArguments::get(); + // Everything needs memory, so the first thing we should do is initialize the memory manager. + crate::mem::MemoryManager::with_mut(|mm| { + 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) + }); + } // 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 // handler then directly map it. #[cfg(any(feature = "debug-print", feature = "print-panics"))] { 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| { memory_manager .map_range( - utra::uart::HW_UART_BASE as *mut u8, - ((debug::SUPERVISOR_UART_ADDR as u32) & !4095) as *mut u8, + utra::resumekicker::HW_RESUMEKICKER_BASE as *mut u8, + ((RESUME_KICKER.base as u32) & !4095) as *mut u8, 4096, PID::new(1).unwrap(), MemoryFlags::R | MemoryFlags::W, 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 - for _ in 0..100 { - arch::rand::get_u32(); + // rand::init() already clears the initial pipe, but pump the TRNG a little more out of no other reason than sheer paranoia + 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! } } diff --git a/loader/Cargo.toml b/loader/Cargo.toml index e00c26420..1ecd16198 100644 --- a/loader/Cargo.toml +++ b/loader/Cargo.toml @@ -15,8 +15,8 @@ rand = "0.7.3" [features] debug-print = [] earlyprintk = [] -#default = ["debug-print"] -default = [] +default = ["debug-print"] +#default = [] [profile.release] codegen-units = 1 # 1 better optimizations diff --git a/loader/bin/riscv32i-unknown-none-elf.a b/loader/bin/riscv32i-unknown-none-elf.a index 2a092a4b0..44a5e4783 100644 Binary files a/loader/bin/riscv32i-unknown-none-elf.a and b/loader/bin/riscv32i-unknown-none-elf.a differ diff --git a/loader/bin/riscv32imac-unknown-none-elf.a b/loader/bin/riscv32imac-unknown-none-elf.a index a307283d9..c7453a931 100644 Binary files a/loader/bin/riscv32imac-unknown-none-elf.a and b/loader/bin/riscv32imac-unknown-none-elf.a differ diff --git a/loader/bin/riscv32imc-unknown-none-elf.a b/loader/bin/riscv32imc-unknown-none-elf.a index a307283d9..c7453a931 100644 Binary files a/loader/bin/riscv32imc-unknown-none-elf.a and b/loader/bin/riscv32imc-unknown-none-elf.a differ diff --git a/loader/bin/riscv64gc-unknown-none-elf.a b/loader/bin/riscv64gc-unknown-none-elf.a index 72c00d117..eacb3a42b 100644 Binary files a/loader/bin/riscv64gc-unknown-none-elf.a and b/loader/bin/riscv64gc-unknown-none-elf.a differ diff --git a/loader/bin/riscv64imac-unknown-none-elf.a b/loader/bin/riscv64imac-unknown-none-elf.a index 72c00d117..eacb3a42b 100644 Binary files a/loader/bin/riscv64imac-unknown-none-elf.a and b/loader/bin/riscv64imac-unknown-none-elf.a differ diff --git a/loader/src/asm.S b/loader/src/asm.S index e164ceaaf..4b3eb6e82 100644 --- a/loader/src/asm.S +++ b/loader/src/asm.S @@ -50,5 +50,8 @@ start_kernel: // Reposition the stack at the offset passed by $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 mret diff --git a/loader/src/main.rs b/loader/src/main.rs index 227a9e84a..50a1f42b6 100644 --- a/loader/src/main.rs +++ b/loader/src/main.rs @@ -389,6 +389,7 @@ extern "C" { entrypoint: usize, stack: usize, debug: bool, + resume: bool, ) -> !; } @@ -1076,8 +1077,10 @@ fn boot_sequence(args: KernelArguments, _signature: u32) -> ! { let (clean, was_forced_suspend) = check_resume(&mut cfg); if !clean { + println!("no suspend marker found, doing a cold boot!"); phase_1(&mut cfg); phase_2(&mut cfg); + println!("done initializing for cold boot."); } else { use utralib::generated::*; // 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::CONTROL_PAUSE, 1); // ensure that the ticktimer is paused before resuming - - // set the resume marker for the early kernel init - ///////////TODO - + resume_csr.wfo(utra::susres::EV_ENABLE_SOFT_INT, 1); // ensure that the soft interrupt is enabled for the kernel to kick + println!("clean suspend marker found, doing a resume!"); // 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].sp, cfg.debug, + clean, ); } } diff --git a/services/llio/src/api.rs b/services/llio/src/api.rs index dab5f9d22..adb93e165 100644 --- a/services/llio/src/api.rs +++ b/services/llio/src/api.rs @@ -139,14 +139,6 @@ pub(crate) const SERVER_NAME_LLIO: &str = "_Low Level I/O manager_"; //////////////////////////////////// OPCODES #[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)] 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 CrgMode, //(ClockMode), diff --git a/services/llio/src/main.rs b/services/llio/src/main.rs index 73edbb04d..0654e7bad 100644 --- a/services/llio/src/main.rs +++ b/services/llio/src/main.rs @@ -31,7 +31,6 @@ mod implementation { #[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}>, @@ -127,13 +126,6 @@ mod implementation { pub fn get_i2c_base(&self) -> *mut u32 { self.i2c_csr.base } 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( xous::MemoryAddress::new(utra::crg::HW_CRG_BASE), None, @@ -187,7 +179,6 @@ mod implementation { let ticktimer = ticktimer_server::Ticktimer::new().expect("Couldn't connect to Ticktimer"); 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), gpio_csr: CSR::new(gpio_base), gpio_susres: RegManager::new(gpio_base), @@ -289,16 +280,6 @@ mod implementation { 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) { self.gpio_csr.wfo(utra::gpio::OUTPUT_OUTPUT, d); } @@ -484,8 +465,6 @@ mod implementation { 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) {} pub fn gpio_din(&self, ) -> u32 { 0xDEAD_BEEF } pub fn gpio_drive(&self, _d: u32) {} @@ -588,220 +567,195 @@ fn xmain() -> ! { let mut gpio_cb_conns: [Option; 32] = [None; 32]; log::trace!("starting main loop"); - let mut reboot_requested: bool = false; loop { let mut msg = xous::receive_message(llio_sid).unwrap(); log::trace!("Message: {:?}", msg); - if reboot_requested { - match FromPrimitive::from_usize(msg.body.id()) { - Some(Opcode::RebootCpuConfirm) => { - llio.reboot(false); + 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::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::().unwrap(); + let status = i2c_machine.initiate(i2c_txrx); + buffer.replace(status).unwrap(); } - } 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; - }, - Some(Opcode::RebootCpuConfirm) => { - info!("RebootCpuConfirm, but no prior Request. Ignoring."); - }, - Some(Opcode::RebootSocConfirm) => { - info!("RebootSocConfirm, but no prior Request. Ignoring."); - }, - Some(Opcode::RebootVector) => msg_scalar_unpack!(msg, vector, _, _, _, { - llio.set_reboot_vector(vector as u32); - }), - 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::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::().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}; + xous::return_scalar(msg.sender, busy as _).expect("couldn't return I2cIsBusy"); + }), + Some(Opcode::EventUsbAttachSubscribe) => { + let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; + let hookdata = buffer.to_original::().unwrap(); + do_hook(hookdata, &mut usb_cb_conns); + } + Some(Opcode::EventComSubscribe) => { + let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; + let hookdata = buffer.to_original::().unwrap(); + do_hook(hookdata, &mut com_cb_conns); + } + Some(Opcode::EventRtcSubscribe) => { + let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; + let hookdata = buffer.to_original::().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::().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::I2cIsBusy) => msg_blocking_scalar_unpack!(msg, _, _, _, _, { - let busy = if i2c_machine.is_busy() {1} else {0}; - xous::return_scalar(msg.sender, busy as _).expect("couldn't return I2cIsBusy"); - }), - Some(Opcode::EventUsbAttachSubscribe) => { - let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; - let hookdata = buffer.to_original::().unwrap(); - do_hook(hookdata, &mut usb_cb_conns); + }), + Some(Opcode::EventRtcEnable) => msg_scalar_unpack!(msg, ena, _, _, _, { + if ena == 0 { + llio.rtc_int_ena(false); + } else { + llio.rtc_int_ena(true); } - Some(Opcode::EventComSubscribe) => { - let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; - let hookdata = buffer.to_original::().unwrap(); - do_hook(hookdata, &mut com_cb_conns); - } - Some(Opcode::EventRtcSubscribe) => { - let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; - let hookdata = buffer.to_original::().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::().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::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; } } } diff --git a/services/susres/src/api.rs b/services/susres/src/api.rs index bab2b286a..5d09022db 100644 --- a/services/susres/src/api.rs +++ b/services/susres/src/api.rs @@ -19,6 +19,14 @@ pub(crate) enum Opcode { /// from the timeout thread 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 Quit, } @@ -206,106 +214,3 @@ impl SuspendResume for ManagedMem { } } } - - - - -/* -// "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, - /// if this register should be in the suspend/resume set - do_sr: bool, -} - -/* sketching some structs for suspend/resume */ -struct TicktimerSusres { - csr: utralib::CSR, // new(csr_base) will allocate this register, from the virtual CSR base given to us by the owning server - pub control: Option, - pub time1: Option, - pub time0: Option, - pub resume_time1: Option, - pub resume_time0: Option, - pub status: Option, - pub msleep_target1: Option, - pub msleep_target0: Option, - pub ev_status: Option, - pub ev_pending: Option, - pub ev_enable: Option, - pub ticktimer_irq: Option, // whether to enable or not after resume - pub wait_suspend: Option 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, - pub registers: [Option; 12], // max number is set by the utra2svd generator - //pub interrupts: [Option; 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 -} -*/ \ No newline at end of file diff --git a/services/susres/src/main.rs b/services/susres/src/main.rs index fe0989622..8c2712f98 100644 --- a/services/susres/src/main.rs +++ b/services/susres/src/main.rs @@ -51,6 +51,9 @@ mod implementation { 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 // 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 @@ -61,12 +64,17 @@ mod implementation { 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) - let touch_and_go = true; + let touch_and_go = false; if touch_and_go { sr.csr.wfo(utra::susres::STATE_RESUME, 1); } 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 sr.csr.wfo(utra::susres::POWERDOWN_POWERDOWN, 1); @@ -90,6 +98,8 @@ mod implementation { stored_time: Option, /// so we can access the build seed and detect if the FPGA image was changed on us seed_csr: utralib::CSR, + /// we also own the reboot facility + reboot_csr: utralib::CSR, } impl SusResHw { pub fn new() -> Self { @@ -135,6 +145,14 @@ mod implementation { xous::MemoryFlags::R | xous::MemoryFlags::W, ) .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 { csr: CSR::new(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, loader_stack, 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 @@ -177,6 +196,17 @@ mod implementation { 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> { xous::send_message(cid, 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 { 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_resume(&mut self) -> bool { @@ -518,105 +550,130 @@ fn xmain() -> ! { let mut suspend_requested = false; let mut timeout_pending = false; + let mut reboot_requested: bool = false; let mut suspend_subscribers: [Option; 32] = [None; 32]; loop { let msg = xous::receive_message(susres_sid).unwrap(); - match FromPrimitive::from_usize(msg.body.id()) { - Some(Opcode::SuspendEventSubscribe) => { - let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; - let hookdata = buffer.to_original::().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; + if reboot_requested { + match FromPrimitive::from_usize(msg.body.id()) { + Some(Opcode::RebootCpuConfirm) => { + susres_hw.reboot(false); } - if token >= suspend_subscribers.len() { - panic!("received a SuspendReady token that's out of range"); + Some(Opcode::RebootSocConfirm) => { + susres_hw.reboot(true); } - if let Some(mut scb) = suspend_subscribers[token] { - if scb.ready_to_suspend { - log::error!("received a duplicate SuspendReady token: {} from {:?}", token, scb); + _ => reboot_requested = false, + } + } 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::().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; - suspend_subscribers[token] = Some(scb); + if token >= suspend_subscribers.len() { + 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; - for maybe_sub in suspend_subscribers.iter() { - if let Some(sub) = maybe_sub { - if sub.ready_to_suspend == false { - all_ready = false; - break; + let mut all_ready = true; + for maybe_sub in suspend_subscribers.iter() { + if let Some(sub) = maybe_sub { + if sub.ready_to_suspend == false { + all_ready = false; + 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 { - log::trace!("all callbacks reporting in, doing suspend"); + // do we want to start the timeout before or after sending the notifications? hmm. 🤔 + 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; - susres_hw.do_suspend(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 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); } 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::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; - }; + Some(Opcode::Quit) => { + break } - // do we want to start the timeout before or after sending the notifications? hmm. 🤔 - 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; - // 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. + None => { + log::error!("couldn't convert opcode"); } } - Some(Opcode::Quit) => { - break - } - None => { - log::error!("couldn't convert opcode"); - } } } // clean up our program