mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-16 08:38:26 +00:00
move cache flush on susres to just before the suspend event
- also nail down the interrupt handlers from firing from the COM during suspend - ensure that connects don't happen while scanning
This commit is contained in:
parent
5daf4c4723
commit
5a1139a367
5 changed files with 72 additions and 48 deletions
|
|
@ -101,6 +101,7 @@ mod implementation {
|
|||
pub fn suspend(&mut self) {
|
||||
self.susres.suspend();
|
||||
self.csr.wo(utra::com::EV_ENABLE, 0);
|
||||
self.csr.wo(utra::com::EV_PENDING, 0xFFFF_FFFF);
|
||||
}
|
||||
pub fn resume(&mut self) {
|
||||
self.susres.resume();
|
||||
|
|
|
|||
|
|
@ -227,14 +227,18 @@ mod implementation {
|
|||
self.uartmux_cache = self.gpio_csr.rf(UARTSEL_UARTSEL).into();
|
||||
self.gpio_csr.wfo(utra::gpio::UARTSEL_UARTSEL, 0); // set the kernel UART so we can catch KPs on boot
|
||||
|
||||
self.gpio_susres.suspend();
|
||||
self.event_susres.suspend();
|
||||
self.power_susres.suspend();
|
||||
|
||||
// this happens after suspend, so these disables are "lost" upon resume and replaced with the normal running values
|
||||
self.gpio_csr.wo(utra::gpio::EV_ENABLE, 0);
|
||||
self.event_csr.wo(utra::btevents::EV_ENABLE, 0);
|
||||
self.event_csr.wo(utra::btevents::EV_PENDING, 0xFFFF_FFFF); // really make sure we don't have any spurious events in the queue
|
||||
|
||||
self.gpio_susres.suspend();
|
||||
self.gpio_csr.wo(utra::gpio::EV_ENABLE, 0);
|
||||
self.gpio_csr.wo(utra::gpio::EV_PENDING, 0xFFFF_FFFF);
|
||||
|
||||
self.power_susres.suspend();
|
||||
self.power_csr.wo(utra::power::EV_ENABLE, 0);
|
||||
self.power_csr.wo(utra::power::EV_PENDING, 0xFFFF_FFFF);
|
||||
}
|
||||
pub fn resume(&mut self) {
|
||||
self.power_susres.resume();
|
||||
|
|
@ -736,7 +740,7 @@ fn xmain() -> ! {
|
|||
|
||||
// register a suspend/resume listener
|
||||
let sr_cid = xous::connect(llio_sid).expect("couldn't create suspend callback connection");
|
||||
let mut susres = susres::Susres::new(None, &xns, Opcode::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object");
|
||||
let mut susres = susres::Susres::new(Some(susres::SuspendOrder::Late), &xns, Opcode::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object");
|
||||
let mut latest_activity = 0;
|
||||
|
||||
let mut usb_cb_conns: [Option<ScalarCallback>; 32] = [None; 32];
|
||||
|
|
|
|||
|
|
@ -13,11 +13,12 @@ use locales::t;
|
|||
use crate::ComIntSources;
|
||||
|
||||
#[allow(dead_code)]
|
||||
const BOOT_POLL_INTERVAL_MS: usize = 3_758; // a slightly faster poll during boot so we acquire wifi faster once PDDB is mounted
|
||||
const BOOT_POLL_INTERVAL_MS: usize = 4_758; // a slightly faster poll during boot so we acquire wifi faster once PDDB is mounted
|
||||
/// this is shared externally so other functions (e.g. in status bar) that want to query the net manager know how long to back off, otherwise the status query will block
|
||||
#[allow(dead_code)]
|
||||
const POLL_INTERVAL_MS: usize = 7_151; // stagger slightly off of an integer-seconds interval to even out loads. impacts rssi update frequency.
|
||||
const INTERVALS_BEFORE_RETRY: usize = 3; // how many poll intervals we'll wait before we give up and try a new AP
|
||||
const INTERVALS_BEFORE_RETRY: usize = 3; // how many poll intervals we'll wait before we give up and try a new AP
|
||||
const SCAN_COUNT_MAX: usize = 5;
|
||||
|
||||
#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)]
|
||||
pub(crate) enum ConnectionManagerOpcode {
|
||||
|
|
@ -88,6 +89,7 @@ pub(crate) fn connection_manager(sid: xous::SID, activity_interval: Arc<AtomicU3
|
|||
let mut ssid_list = HashSet::<String>::new(); // we're throwing away the RSSI for now and just going by name
|
||||
let mut ssid_attempted = HashSet::<String>::new();
|
||||
let mut wait_count = 0;
|
||||
let mut scan_count = 0;
|
||||
|
||||
let run_sid = xous::create_server().unwrap();
|
||||
let run_cid = xous::connect(run_sid).unwrap();
|
||||
|
|
@ -162,6 +164,7 @@ pub(crate) fn connection_manager(sid: xous::SID, activity_interval: Arc<AtomicU3
|
|||
if scan_state == SsidScanState::Idle {
|
||||
com.set_ssid_scanning(true).unwrap();
|
||||
scan_state = SsidScanState::Scanning;
|
||||
scan_count = 0; // we only set scan_count to 0 on resumes because we can't be sure what our previous state was
|
||||
}
|
||||
send_message(self_cid, Message::new_scalar(ConnectionManagerOpcode::Poll.to_usize().unwrap(), 0, 0, 0, 0)).expect("couldn't kick off next poll");
|
||||
}
|
||||
|
|
@ -186,6 +189,7 @@ pub(crate) fn connection_manager(sid: xous::SID, activity_interval: Arc<AtomicU3
|
|||
if scan_state == SsidScanState::Idle {
|
||||
com.set_ssid_scanning(true).unwrap();
|
||||
scan_state = SsidScanState::Scanning;
|
||||
scan_count = 0; // we only set scan_count to 0 on resumes because we can't be sure what our previous state was
|
||||
}
|
||||
}
|
||||
WifiState::Error => {
|
||||
|
|
@ -209,7 +213,6 @@ pub(crate) fn connection_manager(sid: xous::SID, activity_interval: Arc<AtomicU3
|
|||
log::info!("{:?}", source);
|
||||
wifi_state = match ConnectResult::decode_u16(raw_arg as u16) {
|
||||
ConnectResult::Success => {
|
||||
com.set_ssid_scanning(false).unwrap();
|
||||
scan_state = SsidScanState::Idle;
|
||||
activity_interval.store(0, Ordering::SeqCst);
|
||||
WifiState::WaitDhcp
|
||||
|
|
@ -221,7 +224,7 @@ pub(crate) fn connection_manager(sid: xous::SID, activity_interval: Arc<AtomicU3
|
|||
ConnectResult::Error => WifiState::Error,
|
||||
ConnectResult::Pending => WifiState::Error,
|
||||
};
|
||||
log::debug!("comint new wifi state: {:?}", wifi_state);
|
||||
log::info!("comint new wifi state: {:?}", wifi_state);
|
||||
}
|
||||
ComIntSources::Disconnect => {
|
||||
log::info!("{:?}", source);
|
||||
|
|
@ -301,24 +304,27 @@ pub(crate) fn connection_manager(sid: xous::SID, activity_interval: Arc<AtomicU3
|
|||
}
|
||||
match wifi_state {
|
||||
WifiState::Unknown | WifiState::Disconnected | WifiState::InvalidAp | WifiState::InvalidAuth => {
|
||||
if scan_state == SsidScanState::Scanning {
|
||||
com.set_ssid_scanning(false).unwrap();
|
||||
scan_state = SsidScanState::Idle;
|
||||
}
|
||||
if let Some(ssid) = get_next_ssid(&mut ssid_list, &mut ssid_attempted, ap_list) {
|
||||
let mut wpa_pw_file = pddb.get(AP_DICT_NAME, &ssid, None, false, false, None, Some(||{})).expect("couldn't retrieve AP password");
|
||||
let mut wp_pw_raw = [0u8; com::api::WF200_PASS_MAX_LEN];
|
||||
if let Ok(readlen) = wpa_pw_file.read(&mut wp_pw_raw) {
|
||||
let pw = std::str::from_utf8(&wp_pw_raw[..readlen]).expect("password was not valid utf-8");
|
||||
log::info!("Attempting wifi connection: {}", ssid);
|
||||
com.wlan_set_ssid(&ssid).expect("couldn't set SSID");
|
||||
com.wlan_set_pass(pw).expect("couldn't set password");
|
||||
com.wlan_join().expect("couldn't issue join command");
|
||||
wifi_state = WifiState::Connecting;
|
||||
if (scan_state == SsidScanState::Idle) || scan_count > SCAN_COUNT_MAX {
|
||||
scan_count = 0;
|
||||
// wait until we're done scanning before trying to connect
|
||||
if let Some(ssid) = get_next_ssid(&mut ssid_list, &mut ssid_attempted, ap_list) {
|
||||
let mut wpa_pw_file = pddb.get(AP_DICT_NAME, &ssid, None, false, false, None, Some(||{})).expect("couldn't retrieve AP password");
|
||||
let mut wp_pw_raw = [0u8; com::api::WF200_PASS_MAX_LEN];
|
||||
if let Ok(readlen) = wpa_pw_file.read(&mut wp_pw_raw) {
|
||||
let pw = std::str::from_utf8(&wp_pw_raw[..readlen]).expect("password was not valid utf-8");
|
||||
log::info!("Attempting wifi connection: {}", ssid);
|
||||
com.wlan_set_ssid(&ssid).expect("couldn't set SSID");
|
||||
com.wlan_set_pass(pw).expect("couldn't set password");
|
||||
com.wlan_join().expect("couldn't issue join command");
|
||||
wifi_state = WifiState::Connecting;
|
||||
}
|
||||
} else {
|
||||
// no SSIDs available, scan again
|
||||
com.set_ssid_scanning(true).unwrap();
|
||||
scan_state = SsidScanState::Scanning;
|
||||
}
|
||||
} else {
|
||||
com.set_ssid_scanning(true).unwrap();
|
||||
scan_state = SsidScanState::Scanning;
|
||||
scan_count += 1;
|
||||
}
|
||||
}
|
||||
WifiState::WaitDhcp | WifiState::Connecting => {
|
||||
|
|
|
|||
|
|
@ -188,7 +188,7 @@ fn xmain() -> ! {
|
|||
log::trace!("ready to accept requests");
|
||||
// register a suspend/resume listener
|
||||
let sr_cid = xous::connect(net_sid).expect("couldn't create suspend callback connection");
|
||||
let mut susres = susres::Susres::new(None, &xns, api::Opcode::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object");
|
||||
let mut susres = susres::Susres::new(Some(susres::SuspendOrder::Early), &xns, api::Opcode::SuspendResume as u32, sr_cid).expect("couldn't create suspend/resume object");
|
||||
|
||||
// kick off the connection manager thread
|
||||
let cm_sid = xous::create_server().expect("couldn't create connection manager server");
|
||||
|
|
@ -1023,8 +1023,21 @@ fn xmain() -> ! {
|
|||
xous::return_scalar(msg.sender, 1).unwrap();
|
||||
}
|
||||
Some(Opcode::SuspendResume) => xous::msg_scalar_unpack!(msg, token, _, _, _, {
|
||||
// handle an suspend/resume state stuff here. right now, it's a NOP
|
||||
com_int_list.clear();
|
||||
com.ints_enable(&com_int_list); // disable all the interrupts
|
||||
|
||||
susres.suspend_until_resume(token).expect("couldn't execute suspend/resume");
|
||||
// re-enable the interrupts
|
||||
com_int_list.clear();
|
||||
com_int_list.push(ComIntSources::WlanIpConfigUpdate);
|
||||
com_int_list.push(ComIntSources::WlanRxReady);
|
||||
com_int_list.push(ComIntSources::BatteryCritical);
|
||||
com_int_list.push(ComIntSources::Connect);
|
||||
com_int_list.push(ComIntSources::Disconnect);
|
||||
com_int_list.push(ComIntSources::WlanSsidScanUpdate);
|
||||
com_int_list.push(ComIntSources::WlanSsidScanFinished);
|
||||
com_int_list.push(ComIntSources::WfxErr);
|
||||
com.ints_enable(&com_int_list);
|
||||
}),
|
||||
Some(Opcode::Quit) => {
|
||||
log::warn!("quit received");
|
||||
|
|
|
|||
|
|
@ -84,7 +84,7 @@ mod implementation {
|
|||
if let Some(cf) = sr.cacheflush {
|
||||
let cf_ptr = cf.as_ptr() as *mut u32;
|
||||
for i in 0..(cf.len() / 4) {
|
||||
unsafe {cf_ptr.add(i).write_volatile(0); }
|
||||
unsafe {cf_ptr.add(i).write_volatile(0xacdc_acdc); }
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -221,26 +221,6 @@ mod implementation {
|
|||
}
|
||||
|
||||
pub fn do_suspend(&mut self, forced: bool) {
|
||||
// allocate memory for the cache flush
|
||||
if self.cacheflush.is_none() {
|
||||
self.cacheflush = Some (
|
||||
xous::syscall::map_memory(
|
||||
None,
|
||||
None,
|
||||
512 * 1024, // L2 cache is 128k, but emperically it doesn't fully flush until 512k is written. Maybe has to do with write-back behavior??
|
||||
xous::MemoryFlags::R | xous::MemoryFlags::W | xous::MemoryFlags::RESERVE,
|
||||
).expect("couldn't allocate RAM for cache flushing")
|
||||
);
|
||||
// the RESERVE flag should pre-allocate the pages, but for good measure
|
||||
// we write all the pages to make sure they are at a defined value
|
||||
if let Some(cf) = self.cacheflush {
|
||||
let cf_ptr = cf.as_ptr() as *mut u32;
|
||||
for i in 0..(cf.len() / 4) {
|
||||
unsafe {cf_ptr.add(i).write_volatile(0); }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "debugprint")]
|
||||
println!("Stopping preemption");
|
||||
// stop pre-emption
|
||||
|
|
@ -344,6 +324,26 @@ mod implementation {
|
|||
index += range;
|
||||
}
|
||||
|
||||
// allocate memory for the cache flush
|
||||
if self.cacheflush.is_none() {
|
||||
self.cacheflush = Some (
|
||||
xous::syscall::map_memory(
|
||||
None,
|
||||
None,
|
||||
512 * 1024, // L2 cache is 128k, but emperically it doesn't fully flush until 512k is written. Maybe has to do with write-back behavior??
|
||||
xous::MemoryFlags::R | xous::MemoryFlags::W | xous::MemoryFlags::RESERVE,
|
||||
).expect("couldn't allocate RAM for cache flushing")
|
||||
);
|
||||
// the RESERVE flag should pre-allocate the pages, but for good measure
|
||||
// we write all the pages to make sure they are at a defined value
|
||||
if let Some(cf) = self.cacheflush {
|
||||
let cf_ptr = cf.as_ptr() as *mut u32;
|
||||
for i in 0..(cf.len() / 4) {
|
||||
unsafe {cf_ptr.add(i).write_volatile(0x0bad_0bad); }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "debugprint")]
|
||||
println!("Triggering suspend interrupt");
|
||||
// trigger an interrupt to process the final suspend bits
|
||||
|
|
|
|||
Loading…
Reference in a new issue