From f571e3069a98df0fb5398dc6f0e5586746389ff8 Mon Sep 17 00:00:00 2001 From: bunnie Date: Tue, 28 Jun 2022 03:25:33 +0800 Subject: [PATCH] fix regressions on USB suspend/resume the core now enumerates after a suspend/resume cycle, although sometimes it takes two tries for the enumeration to go all the way through. not sure why, yet. --- services/usb-device-xous/src/hw.rs | 55 ++++++++++++++++++++++------ services/usb-device-xous/src/main.rs | 13 ++++++- 2 files changed, 55 insertions(+), 13 deletions(-) diff --git a/services/usb-device-xous/src/hw.rs b/services/usb-device-xous/src/hw.rs index 8e28f2a80..ef88d49f3 100644 --- a/services/usb-device-xous/src/hw.rs +++ b/services/usb-device-xous/src/hw.rs @@ -1,8 +1,7 @@ -use susres::{ManagedMem, SuspendResume}; use usb_device::bus::PollResult; use utralib::generated::*; use crate::*; -use core::sync::atomic::{AtomicPtr, Ordering, AtomicUsize, AtomicU16}; +use core::{sync::atomic::{AtomicPtr, Ordering, AtomicUsize, AtomicU16}, mem::size_of}; use std::sync::{Arc, Mutex}; use usb_device::{class_prelude::*, Result, UsbDirection}; use std::collections::BTreeMap; @@ -25,7 +24,10 @@ pub struct SpinalUsbMgmt { csr: AtomicCsr, // consider using VolatileCell and/or refactory AtomicCsr so it is non-mutable usb: AtomicPtr, eps: AtomicPtr, - srmem: ManagedMem<{ utralib::generated::HW_USBDEV_MEM_LEN / core::mem::size_of::() }>, + // can't use the srmem macro because the memory region window is not exactly the size of the memory to be stored. + sr_descs: [u32; crate::END_OFFSET as usize / size_of::()], + sr_debug: bool, + sr_core: bool, regs: SpinalUdcRegs, tt: ticktimer_server::Ticktimer, } @@ -49,15 +51,16 @@ impl SpinalUsbMgmt { } } } - log::trace!("frame id: {}", self.regs.frame_id()); + log::debug!("frame id: {}", self.regs.frame_id()); log::debug!("usb addr: {}", self.regs.address()); log::debug!("ints: {:x?}", self.regs.interrupts()); - log::trace!("halt: 0x{:x?}", self.regs.halt()); - log::trace!("config: 0x{:x?}", self.regs.config()); - log::trace!("ramsize: {}", self.regs.ramsize()); + log::debug!("halt: 0x{:x?}", self.regs.halt()); + log::debug!("config: 0x{:x?}", self.regs.config()); + log::debug!("ramsize: {}", self.regs.ramsize()); assert!(4096 == self.regs.ramsize(), "hardware ramsize parameter does not match our expectations"); } pub fn connect_device_core(&mut self, state: bool) { + self.sr_core = state; log::trace!("previous state: {}", self.csr.rf(utra::usbdev::USBSELECT_SELECT_DEVICE)); self.csr.rmwf(utra::usbdev::USBSELECT_FORCE_RESET, 1); // give some time for the host to recognize that we've unplugged before swapping our behavior out @@ -94,15 +97,43 @@ impl SpinalUsbMgmt { } } pub fn xous_suspend(&mut self) { + // log::set_max_level(log::LevelFilter::Debug); + // self.print_regs(); + // the core select state is updated in `connect_device_core`, we don't update it here + // but we do record the debug state. + self.sr_debug = self.get_disable_debug(); self.csr.wo(utra::usbdev::EV_PENDING, 0xFFFF_FFFF); self.csr.wo(utra::usbdev::EV_ENABLE, 0x0); - self.srmem.suspend(); + // the descriptor window is manually managed because the sr macro does the whole window + // it turns out only the bottom 4k is relevant; the actual state registers should be + // the naive reset values by right, because we would be entering into this from a + // "reset"/disconnected state anyways + let ptr = self.usb.load(Ordering::SeqCst) as *const u32; + for (index, d) in self.sr_descs.iter_mut().enumerate() { + *d = unsafe{ptr.add(index).read_volatile()}; + } } - pub fn xous_resume(&mut self) { - self.srmem.resume(); + pub fn xous_resume1(&mut self) { + self.regs.clear_all_interrupts(); let p = self.csr.r(utra::usbdev::EV_PENDING); // this has to be expanded out because AtomicPtr is potentially mutable on read self.csr.wo(utra::usbdev::EV_PENDING, p); // clear in case it's pending for some reason self.csr.wfo(utra::usbdev::EV_ENABLE_USB, 1); + + let mut cfg = UdcConfig(0); + cfg.set_pullup_on(true); // required for proper operation + self.regs.set_config(cfg); + + let ptr = self.usb.load(Ordering::SeqCst) as *mut u32; + for (index, &s) in self.sr_descs.iter().enumerate() { + unsafe{ptr.add(index).write_volatile(s)}; + } + self.regs.clear_all_interrupts(); + // self.print_regs(); + // log::set_max_level(log::LevelFilter::Info); + } + pub fn xous_resume2(&mut self) { + self.disable_debug(self.sr_debug); + self.connect_device_core(self.sr_core); } #[allow(dead_code)] pub fn descriptor_from_status(&self, ep_status: &UdcEpStatus) -> SpinalUdcDescriptor { @@ -201,7 +232,9 @@ impl SpinalUsbDevice { eps: AtomicPtr::new(unsafe { (self.usb.as_mut_ptr().add(0x00) as *mut UdcEpStatus).as_mut().unwrap() }), - srmem: ManagedMem::new(self.usb), + sr_descs: [0u32; crate::END_OFFSET as usize / size_of::()], + sr_core: false, // device core is not selected by default + sr_debug: true, // debug is enabled by default regs: self.regs.clone(), tt: ticktimer_server::Ticktimer::new().unwrap(), } diff --git a/services/usb-device-xous/src/main.rs b/services/usb-device-xous/src/main.rs index 31f335d7e..60f69438d 100644 --- a/services/usb-device-xous/src/main.rs +++ b/services/usb-device-xous/src/main.rs @@ -196,11 +196,20 @@ fn main() -> ! { let mut was_suspend = true; loop { let mut msg = xous::receive_message(usbdev_sid).unwrap(); - match FromPrimitive::from_usize(msg.body.id()) { + let opcode: Option = FromPrimitive::from_usize(msg.body.id()); + log::debug!("{:?}", opcode); + match opcode { Some(Opcode::SuspendResume) => msg_scalar_unpack!(msg, token, _, _, _, { usbmgmt.xous_suspend(); susres.suspend_until_resume(token).expect("couldn't execute suspend/resume"); - usbmgmt.xous_resume(); + // resume1 + reset brings us to an initialized state + usbmgmt.xous_resume1(); + match usb_dev.force_reset() { + Err(e) => log::warn!("USB reset on resume failed: {:?}", e), + _ => () + }; + // resume2 brings us to our last application state + usbmgmt.xous_resume2(); lockstatus_force_update = true; // notify the status bar that yes, it does need to redraw the lock status, even if the value hasn't changed since the last read }), Some(Opcode::IsSocCompatible) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {