mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-19 09:00:54 +00:00
some progress .. seeing setup packets now
This commit is contained in:
parent
6b04f0e73c
commit
adf8eb6519
2 changed files with 143 additions and 104 deletions
|
|
@ -27,6 +27,28 @@ pub fn log_init() -> *mut u32 {
|
||||||
|
|
||||||
const NUM_ENDPOINTS: usize = 16;
|
const NUM_ENDPOINTS: usize = 16;
|
||||||
|
|
||||||
|
fn handle_usb(_irq_no: usize, arg: *mut usize) {
|
||||||
|
let usb = unsafe { &mut *(arg as *mut SpinalUsbDevice) };
|
||||||
|
let pending = usb.csr.r(utra::usbdev::EV_PENDING);
|
||||||
|
|
||||||
|
usb.ints.store(
|
||||||
|
usb.regs.interrupts().0,
|
||||||
|
Ordering::SeqCst
|
||||||
|
);
|
||||||
|
let mut cfg = UdcConfig(0);
|
||||||
|
cfg.set_disable_ints(true); // to be enabled only when all the interrupts are handled
|
||||||
|
cfg.set_pullup_on(true);
|
||||||
|
usb.regs.set_config(cfg);
|
||||||
|
|
||||||
|
usb.regs.clear_all_interrupts();
|
||||||
|
// also: do we halt the cores??
|
||||||
|
|
||||||
|
usb.csr.wo(utra::usbdev::EV_PENDING, pending);
|
||||||
|
|
||||||
|
xous::try_send_message(usb.conn,
|
||||||
|
xous::Message::new_scalar(Opcode::UsbIrqHandler.to_usize().unwrap(), 0, 0, 0, 0)).ok();
|
||||||
|
}
|
||||||
|
|
||||||
bitfield! {
|
bitfield! {
|
||||||
pub struct UdcInterrupts(u32);
|
pub struct UdcInterrupts(u32);
|
||||||
impl Debug;
|
impl Debug;
|
||||||
|
|
@ -64,12 +86,13 @@ bitfield! {
|
||||||
pub struct SpinalUdcRegs {
|
pub struct SpinalUdcRegs {
|
||||||
regs: AtomicPtr<u32>,
|
regs: AtomicPtr<u32>,
|
||||||
}
|
}
|
||||||
const FRAME_OFFSET: usize = 0;
|
// constants in UsbDeviceCtrl.scala (L111-116) are in hex
|
||||||
const ADDRESS_OFFSET: usize = 4;
|
const FRAME_OFFSET: usize = 0x0;
|
||||||
const INT_OFFSET: usize = 8;
|
const ADDRESS_OFFSET: usize = 0x4;
|
||||||
const HALT_OFFSET: usize = 12;
|
const INT_OFFSET: usize = 0x8;
|
||||||
const CONFIG_OFFSET: usize = 16;
|
const HALT_OFFSET: usize = 0xC;
|
||||||
const RAMSIZE_OFFSET: usize = 20;
|
const CONFIG_OFFSET: usize = 0x10;
|
||||||
|
const RAMSIZE_OFFSET: usize = 0x20;
|
||||||
#[allow(dead_code)]
|
#[allow(dead_code)]
|
||||||
impl SpinalUdcRegs {
|
impl SpinalUdcRegs {
|
||||||
pub fn new(ptr: *mut u32) -> SpinalUdcRegs {
|
pub fn new(ptr: *mut u32) -> SpinalUdcRegs {
|
||||||
|
|
@ -134,20 +157,15 @@ impl SpinalUdcRegs {
|
||||||
}
|
}
|
||||||
pub fn set_config(&self, cfg: UdcConfig) {
|
pub fn set_config(&self, cfg: UdcConfig) {
|
||||||
unsafe {
|
unsafe {
|
||||||
self.regs.load(Ordering::SeqCst).add(CONFIG_OFFSET / size_of::<u32>()).write_volatile(cfg.0 | 1) // 0x1 => enable pullup
|
self.regs.load(Ordering::SeqCst).add(CONFIG_OFFSET / size_of::<u32>()).write_volatile(cfg.0)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
/// the ram starting at 0 has a size of 1 << ramsize. Only the lower 4 bits are valid, but the field takes up a u32
|
/// the ram starting at 0 has a size of 1 << ramsize. Only the lower 4 bits are valid, but the field takes up a u32
|
||||||
/// the returned value is the properly computed bytes as read out by the hardware field (no further maths needed)
|
/// the returned value is the properly computed bytes as read out by the hardware field (no further maths needed)
|
||||||
pub fn ramsize(&self) -> u32 {
|
pub fn ramsize(&self) -> u32 {
|
||||||
unsafe {
|
|
||||||
self.regs.load(Ordering::SeqCst).add(RAMSIZE_OFFSET / size_of::<u32>()).read_volatile()
|
|
||||||
}
|
|
||||||
/*
|
|
||||||
1 << (unsafe {
|
1 << (unsafe {
|
||||||
self.regs.load(Ordering::SeqCst).add(RAMSIZE_OFFSET / size_of::<u32>()).read_volatile()
|
self.regs.load(Ordering::SeqCst).add(RAMSIZE_OFFSET / size_of::<u32>()).read_volatile()
|
||||||
} & 0xF)
|
} & 0xF)
|
||||||
*/
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -273,27 +291,6 @@ impl SpinalUdcDescriptor {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
fn handle_usb(_irq_no: usize, arg: *mut usize) {
|
|
||||||
let usb = unsafe { &mut *(arg as *mut SpinalUsbDevice) };
|
|
||||||
let pending = usb.csr.r(utra::usbdev::EV_PENDING);
|
|
||||||
|
|
||||||
usb.ints.store(
|
|
||||||
usb.regs.interrupts().0,
|
|
||||||
Ordering::SeqCst
|
|
||||||
);
|
|
||||||
let mut cfg = UdcConfig(0);
|
|
||||||
cfg.set_disable_ints(true); // to be enabled only when all the interrupts are handled
|
|
||||||
usb.regs.set_config(cfg);
|
|
||||||
|
|
||||||
usb.regs.clear_all_interrupts();
|
|
||||||
// also: do we halt the cores??
|
|
||||||
|
|
||||||
xous::try_send_message(usb.conn,
|
|
||||||
xous::Message::new_scalar(Opcode::UsbIrqHandler.to_usize().unwrap(), 0, 0, 0, 0)).ok();
|
|
||||||
usb.csr.wo(utra::usbdev::EV_PENDING, pending);
|
|
||||||
}
|
|
||||||
|
|
||||||
pub struct SpinalUsbMgmt {
|
pub struct SpinalUsbMgmt {
|
||||||
csr: AtomicCsr<u32>, // consider using VolatileCell and/or refactory AtomicCsr so it is non-mutable
|
csr: AtomicCsr<u32>, // consider using VolatileCell and/or refactory AtomicCsr so it is non-mutable
|
||||||
usb: AtomicPtr<u8>,
|
usb: AtomicPtr<u8>,
|
||||||
|
|
@ -303,6 +300,7 @@ pub struct SpinalUsbMgmt {
|
||||||
}
|
}
|
||||||
impl SpinalUsbMgmt {
|
impl SpinalUsbMgmt {
|
||||||
pub fn print_regs(&self) {
|
pub fn print_regs(&self) {
|
||||||
|
/*
|
||||||
for i in 0..8 {
|
for i in 0..8 {
|
||||||
let offset = 0xff00 + i * 4;
|
let offset = 0xff00 + i * 4;
|
||||||
log::info!(
|
log::info!(
|
||||||
|
|
@ -310,30 +308,32 @@ impl SpinalUsbMgmt {
|
||||||
offset,
|
offset,
|
||||||
unsafe{(self.usb.load(Ordering::SeqCst).add(offset) as *mut u32).read_volatile()},
|
unsafe{(self.usb.load(Ordering::SeqCst).add(offset) as *mut u32).read_volatile()},
|
||||||
);
|
);
|
||||||
}
|
} */
|
||||||
//unsafe{self.usb.load(Ordering::SeqCst).add(0xff10 / size_of::<u32>()).write_volatile(0x4)};
|
//unsafe{self.usb.load(Ordering::SeqCst).add(0xff10 / size_of::<u32>()).write_volatile(0x4)};
|
||||||
for i in 0..16 {
|
for i in 0..16 {
|
||||||
let ep_status = self.status_from_index(i);
|
let ep_status = self.status_from_index(i);
|
||||||
log::info!("ep{}_status: {:?}", i, ep_status);
|
if ep_status.enable() {
|
||||||
if ep_status.head_offset() != 0 {
|
log::info!("ep{}_status: {:x?}", i, ep_status);
|
||||||
let desc = self.descriptor_from_status(&ep_status);
|
if ep_status.head_offset() != 0 {
|
||||||
log::info!("offset: {}, in_progress: {}, length: {}", desc.offset(), desc.in_progress(), desc.length());
|
let desc = self.descriptor_from_status(&ep_status);
|
||||||
}
|
log::info!("offset: {}, in_progress: {}, length: {}", desc.offset(), desc.in_progress(), desc.length());
|
||||||
if i == 0 {
|
}
|
||||||
let setup_data_base = unsafe{self.usb.load(Ordering::SeqCst).add(0x40) as *mut u32};
|
if i == 0 {
|
||||||
log::info!("setup area: {:x?}{:x?}",
|
let setup_data_base = unsafe{self.usb.load(Ordering::SeqCst).add(0x40) as *mut u32};
|
||||||
unsafe{setup_data_base.add(0).read_volatile()}.to_le_bytes(),
|
log::info!("setup area: {:x?}{:x?}",
|
||||||
unsafe{setup_data_base.add(1).read_volatile()}.to_le_bytes()
|
unsafe{setup_data_base.add(0).read_volatile()}.to_le_bytes(),
|
||||||
);
|
unsafe{setup_data_base.add(1).read_volatile()}.to_le_bytes()
|
||||||
|
);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
log::info!("frame id: {}", self.regs.frame_id());
|
log::info!("frame id: {}", self.regs.frame_id());
|
||||||
log::info!("usb addr: {}", self.regs.address());
|
log::info!("usb addr: {}", self.regs.address());
|
||||||
log::info!("ints: {:x?}", self.regs.interrupts());
|
log::info!("ints: {:x?}", self.regs.interrupts());
|
||||||
log::info!("halt: 0x{:x?}", self.regs.halt());
|
log::info!("halt: 0x{:x?}", self.regs.halt());
|
||||||
log::info!("config: 0x{:x?}", self.regs.config());
|
log::info!("config: 0x{:x?}", self.regs.config());
|
||||||
log::info!("ramsize: {}", self.regs.ramsize());
|
log::info!("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) {
|
pub fn connect_device_core(&mut self, state: bool) {
|
||||||
log::info!("previous state: {}", self.csr.rf(utra::usbdev::USBSELECT_USBSELECT));
|
log::info!("previous state: {}", self.csr.rf(utra::usbdev::USBSELECT_USBSELECT));
|
||||||
|
|
@ -431,6 +431,7 @@ impl SpinalUsbDevice {
|
||||||
// also have to enable ints at the SpinalHDL layer
|
// also have to enable ints at the SpinalHDL layer
|
||||||
let mut cfg = UdcConfig(0);
|
let mut cfg = UdcConfig(0);
|
||||||
cfg.set_enable_ints(true);
|
cfg.set_enable_ints(true);
|
||||||
|
cfg.set_pullup_on(true);
|
||||||
usbdev.regs.set_config(cfg);
|
usbdev.regs.set_config(cfg);
|
||||||
|
|
||||||
usbdev
|
usbdev
|
||||||
|
|
@ -469,18 +470,37 @@ impl SpinalUsbDevice {
|
||||||
pub fn dealloc_region(&mut self, offset: u32) -> bool {
|
pub fn dealloc_region(&mut self, offset: u32) -> bool {
|
||||||
dealloc_inner(&mut self.allocs.lock().unwrap(), offset)
|
dealloc_inner(&mut self.allocs.lock().unwrap(), offset)
|
||||||
}
|
}
|
||||||
pub fn descriptor_from_status(&self, ep_status: &UdcEpStatus) -> SpinalUdcDescriptor {
|
pub(crate) fn descriptor_from_status(&self, ep_status: &UdcEpStatus) -> SpinalUdcDescriptor {
|
||||||
SpinalUdcDescriptor::new(
|
SpinalUdcDescriptor::new(
|
||||||
unsafe{ self.usb.as_mut_ptr().add(
|
unsafe{ self.usb.as_mut_ptr().add(
|
||||||
ep_status.head_offset() as usize * 16
|
ep_status.head_offset() as usize * 16
|
||||||
) as *mut u32}
|
) as *mut u32}
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
pub fn status_from_index(&self, index: usize) -> UdcEpStatus {
|
pub(crate) fn status_read_volatile(&self, index: usize) -> UdcEpStatus {
|
||||||
unsafe {
|
unsafe {
|
||||||
self.eps.load(Ordering::SeqCst).add(index).read_volatile()
|
self.eps.load(Ordering::SeqCst).add(index).read_volatile()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
pub(crate) fn status_write_volatile(&self, index: usize, ep_status: UdcEpStatus) {
|
||||||
|
unsafe {
|
||||||
|
self.eps.load(Ordering::SeqCst).add(index).write_volatile(ep_status)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub(crate) fn udc_hard_halt(&self, index: usize) {
|
||||||
|
self.regs.set_halt(UdcHalt(index as u32 | 0x10));
|
||||||
|
let mut iters = 0;
|
||||||
|
while !self.regs.halt().enable_ack() {
|
||||||
|
xous::yield_slice();
|
||||||
|
iters += 1;
|
||||||
|
if iters == 1000 {
|
||||||
|
log::info!("udc_hard_halt possibly timed out");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub(crate) fn udc_hard_unhalt(&self, index: usize) {
|
||||||
|
self.regs.set_halt(UdcHalt(index as u32));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl UsbBus for SpinalUsbDevice {
|
impl UsbBus for SpinalUsbDevice {
|
||||||
|
|
@ -536,11 +556,7 @@ impl UsbBus for SpinalUsbDevice {
|
||||||
ep_status.set_enable(true);
|
ep_status.set_enable(true);
|
||||||
log::info!("ep{}_status: {:?}", index, ep_status);
|
log::info!("ep{}_status: {:?}", index, ep_status);
|
||||||
|
|
||||||
// unsafe volatile write to commit the computed ep_status state
|
self.status_write_volatile(index, ep_status);
|
||||||
// it's up to us to make sure we got the right type and index bounds :-/
|
|
||||||
// couldn't find an abstraction in Rust that met the simultaneous demands
|
|
||||||
// of the hardware along side the external USB crate.
|
|
||||||
unsafe{self.eps.load(Ordering::SeqCst).add(index).write_volatile(ep_status)};
|
|
||||||
|
|
||||||
core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst);
|
core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst);
|
||||||
log::info!("returning endpoint {}", index);
|
log::info!("returning endpoint {}", index);
|
||||||
|
|
@ -608,7 +624,7 @@ impl UsbBus for SpinalUsbDevice {
|
||||||
/// Implementations may also return other errors if applicable.
|
/// Implementations may also return other errors if applicable.
|
||||||
fn write(&self, ep_addr: EndpointAddress, buf: &[u8]) -> Result<usize> {
|
fn write(&self, ep_addr: EndpointAddress, buf: &[u8]) -> Result<usize> {
|
||||||
log::info!("write ep{}", ep_addr.index());
|
log::info!("write ep{}", ep_addr.index());
|
||||||
let ep_status = self.status_from_index(ep_addr.index());
|
let ep_status = self.status_read_volatile(ep_addr.index());
|
||||||
let descriptor = self.descriptor_from_status(&ep_status);
|
let descriptor = self.descriptor_from_status(&ep_status);
|
||||||
if buf.len() > ep_status.max_packet_size() as usize {
|
if buf.len() > ep_status.max_packet_size() as usize {
|
||||||
Err(UsbError::BufferOverflow)
|
Err(UsbError::BufferOverflow)
|
||||||
|
|
@ -631,6 +647,7 @@ impl UsbBus for SpinalUsbDevice {
|
||||||
descriptor.write_data(index, w);
|
descriptor.write_data(index, w);
|
||||||
}
|
}
|
||||||
core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst);
|
core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst);
|
||||||
|
log::info!("ep{} write: {:x?}", ep_addr.index(), &buf);
|
||||||
Ok(buf.len())
|
Ok(buf.len())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -654,14 +671,15 @@ impl UsbBus for SpinalUsbDevice {
|
||||||
///
|
///
|
||||||
/// Implementations may also return other errors if applicable.
|
/// Implementations may also return other errors if applicable.
|
||||||
fn read(&self, ep_addr: EndpointAddress, buf: &mut [u8]) -> Result<usize> {
|
fn read(&self, ep_addr: EndpointAddress, buf: &mut [u8]) -> Result<usize> {
|
||||||
log::info!("read ep{}", ep_addr.index());
|
log::info!("read ep{} into buf of len {}", ep_addr.index(), buf.len());
|
||||||
let ep_status = self.status_from_index(ep_addr.index());
|
let ep_status = self.status_read_volatile(ep_addr.index());
|
||||||
let descriptor = self.descriptor_from_status(&ep_status);
|
let descriptor = self.descriptor_from_status(&ep_status);
|
||||||
if descriptor.in_progress() {
|
if descriptor.in_progress() {
|
||||||
log::info!("read called but descriptor was in progress")
|
log::info!("read called but descriptor was in progress")
|
||||||
}
|
}
|
||||||
let len = descriptor.length();
|
let len = descriptor.length();
|
||||||
if buf.len() > len {
|
if buf.len() < len {
|
||||||
|
log::info!("would overflow: {} > {}", buf.len(), len);
|
||||||
return Err(UsbError::BufferOverflow)
|
return Err(UsbError::BufferOverflow)
|
||||||
}
|
}
|
||||||
descriptor.set_desc1(0, buf.len());
|
descriptor.set_desc1(0, buf.len());
|
||||||
|
|
@ -675,6 +693,7 @@ impl UsbBus for SpinalUsbDevice {
|
||||||
if ep_addr.index() == 0 {
|
if ep_addr.index() == 0 {
|
||||||
// hard coded to 8 bytes in hardware
|
// hard coded to 8 bytes in hardware
|
||||||
if buf.len() < 8 {
|
if buf.len() < 8 {
|
||||||
|
log::info!("ep0 read would overflow, aborting");
|
||||||
return Err(UsbError::BufferOverflow)
|
return Err(UsbError::BufferOverflow)
|
||||||
}
|
}
|
||||||
// setup data is in a special, fixed location
|
// setup data is in a special, fixed location
|
||||||
|
|
@ -687,17 +706,21 @@ impl UsbBus for SpinalUsbDevice {
|
||||||
&unsafe{setup_data_base.add(1).read_volatile()}
|
&unsafe{setup_data_base.add(1).read_volatile()}
|
||||||
.to_le_bytes()
|
.to_le_bytes()
|
||||||
);
|
);
|
||||||
|
log::info!("ep0 read: {:x?}", &buf[..8]);
|
||||||
Ok(8)
|
Ok(8)
|
||||||
} else {
|
} else {
|
||||||
if len % 4 != 0 {
|
if len % 4 != 0 {
|
||||||
log::info!("non-word aligned length encountered, need code to handle this case");
|
log::info!("non-word aligned length encountered, need code to handle this case");
|
||||||
}
|
}
|
||||||
|
log::info!("reading data len {} into buf of {}", len, buf.len());
|
||||||
for i in 0..len / 4 {
|
for i in 0..len / 4 {
|
||||||
let word = descriptor.read_data(i);
|
log::info!("data {}", i);
|
||||||
for (&src, dst) in word.to_le_bytes().iter().zip(buf[i*4..(i+1)*4].iter_mut()) {
|
let word = descriptor.read_data(i).to_le_bytes();
|
||||||
*dst = src;
|
log::info!("is {:x?}", word);
|
||||||
}
|
buf[i*4..(i+1)*4].copy_from_slice(&word);
|
||||||
|
log::info!("copied slice");
|
||||||
}
|
}
|
||||||
|
log::info!("ep{} read: {:x?}", ep_addr.index(), &buf[..len]);
|
||||||
Ok(len)
|
Ok(len)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -706,34 +729,30 @@ impl UsbBus for SpinalUsbDevice {
|
||||||
/// should be prepared to receive data again.
|
/// should be prepared to receive data again.
|
||||||
fn set_stalled(&self, ep_addr: EndpointAddress, stalled: bool) {
|
fn set_stalled(&self, ep_addr: EndpointAddress, stalled: bool) {
|
||||||
log::info!("set_stalled{}->{}", ep_addr.index(), stalled);
|
log::info!("set_stalled{}->{}", ep_addr.index(), stalled);
|
||||||
// it looks like a STALL condition could be forced even on unallocated endpoints, so
|
if ep_addr.index() == 0 && (self.regs.interrupts().ep0_setup() | UdcInterrupts(self.ints.load(Ordering::SeqCst)).ep0_setup()) {
|
||||||
// we alias into the register block and force it to happen.
|
log::info!("not stalling ep0 during setup");
|
||||||
let mut ep_status = unsafe {
|
return;
|
||||||
self.eps.load(Ordering::SeqCst).add(ep_addr.index()).read_volatile()
|
}
|
||||||
};
|
self.udc_hard_halt(ep_addr.index());
|
||||||
|
let mut ep_status = self.status_read_volatile(ep_addr.index());
|
||||||
match (stalled, ep_addr.direction()) {
|
match (stalled, ep_addr.direction()) {
|
||||||
(true, UsbDirection::In) => {
|
(true, UsbDirection::In) => {
|
||||||
ep_status.set_force_nack(false);
|
|
||||||
ep_status.set_force_stall(true);
|
ep_status.set_force_stall(true);
|
||||||
},
|
},
|
||||||
(true, UsbDirection::Out) => ep_status.set_force_stall(true),
|
(true, UsbDirection::Out) => ep_status.set_force_stall(true),
|
||||||
(false, UsbDirection::In) => {
|
(false, UsbDirection::In) => {
|
||||||
ep_status.set_force_nack(true); // not sure if this is correct -- STM32 reference sets state to "nack" but the meaning might be different for this core
|
|
||||||
ep_status.set_force_stall(false);
|
ep_status.set_force_stall(false);
|
||||||
},
|
},
|
||||||
(false, UsbDirection::Out) => ep_status.set_force_stall(false),
|
(false, UsbDirection::Out) => ep_status.set_force_stall(false),
|
||||||
};
|
};
|
||||||
// single volatile commit of the results
|
// single volatile commit of the results
|
||||||
unsafe {
|
self.status_write_volatile(ep_addr.index(), ep_status);
|
||||||
self.eps.load(Ordering::SeqCst).add(ep_addr.index()).write_volatile(ep_status)
|
self.udc_hard_unhalt(ep_addr.index());
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Gets whether the STALL condition is set for an endpoint.
|
/// Gets whether the STALL condition is set for an endpoint.
|
||||||
fn is_stalled(&self, ep_addr: EndpointAddress) -> bool {
|
fn is_stalled(&self, ep_addr: EndpointAddress) -> bool {
|
||||||
let ep_status = unsafe {
|
let ep_status = self.status_read_volatile(ep_addr.index());
|
||||||
self.eps.load(Ordering::SeqCst).add(ep_addr.index()).read_volatile()
|
|
||||||
};
|
|
||||||
log::info!("is_stalled{} -> {}", ep_addr.index(), ep_status.force_stall());
|
log::info!("is_stalled{} -> {}", ep_addr.index(), ep_status.force_stall());
|
||||||
ep_status.force_stall()
|
ep_status.force_stall()
|
||||||
}
|
}
|
||||||
|
|
@ -756,26 +775,10 @@ impl UsbBus for SpinalUsbDevice {
|
||||||
/// Gets information about events and incoming data. Usually called in a loop or from an
|
/// Gets information about events and incoming data. Usually called in a loop or from an
|
||||||
/// interrupt handler. See the [`PollResult`] struct for more information.
|
/// interrupt handler. See the [`PollResult`] struct for more information.
|
||||||
fn poll(&self) -> PollResult {
|
fn poll(&self) -> PollResult {
|
||||||
let mut interrupts = UdcInterrupts(self.ints. load(Ordering::SeqCst));
|
let mut interrupts = UdcInterrupts(self.ints.load(Ordering::SeqCst));
|
||||||
log::info!("poll {}, {:x?}", interrupts.0, interrupts);
|
log::info!("******> poll handler interrupts: {}, {:x?}", interrupts.0, interrupts);
|
||||||
let poll_result =
|
let poll_result =
|
||||||
if interrupts.disconnect() {
|
if interrupts.endpoint() != 0 || interrupts.ep0_setup() {
|
||||||
log::info!("disconnect");
|
|
||||||
interrupts.set_disconnect(false);
|
|
||||||
PollResult::Reset
|
|
||||||
} else if interrupts.resume() {
|
|
||||||
log::info!("resume");
|
|
||||||
interrupts.set_reset(false);
|
|
||||||
PollResult::Resume
|
|
||||||
} else if interrupts.reset() {
|
|
||||||
log::info!("reset");
|
|
||||||
interrupts.set_reset(false);
|
|
||||||
PollResult::Reset
|
|
||||||
} else if interrupts.suspend() {
|
|
||||||
log::info!("suspend");
|
|
||||||
interrupts.set_suspend(false);
|
|
||||||
PollResult::Suspend
|
|
||||||
} else if interrupts.endpoint() != 0 || interrupts.ep0_setup() {
|
|
||||||
let ep_setup = if interrupts.ep0_setup() {
|
let ep_setup = if interrupts.ep0_setup() {
|
||||||
log::info!("ep0");
|
log::info!("ep0");
|
||||||
interrupts.set_ep0_setup(false);
|
interrupts.set_ep0_setup(false);
|
||||||
|
|
@ -792,7 +795,7 @@ impl UsbBus for SpinalUsbDevice {
|
||||||
if (interrupts.endpoint() & (1 << bit)) != 0 {
|
if (interrupts.endpoint() & (1 << bit)) != 0 {
|
||||||
log::info!("ep{}", bit);
|
log::info!("ep{}", bit);
|
||||||
// form a descriptor from the memory range assigned to the EP
|
// form a descriptor from the memory range assigned to the EP
|
||||||
let ep_status = self.status_from_index(bit);
|
let ep_status = self.status_read_volatile(bit);
|
||||||
let descriptor = self.descriptor_from_status(&ep_status);
|
let descriptor = self.descriptor_from_status(&ep_status);
|
||||||
if descriptor.direction() == UsbDirection::Out {
|
if descriptor.direction() == UsbDirection::Out {
|
||||||
ep_out |= 1 << bit;
|
ep_out |= 1 << bit;
|
||||||
|
|
@ -806,17 +809,46 @@ impl UsbBus for SpinalUsbDevice {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
PollResult::Data { ep_out, ep_in_complete, ep_setup }
|
PollResult::Data { ep_out, ep_in_complete, ep_setup }
|
||||||
|
} else if interrupts.reset() {
|
||||||
|
interrupts.set_reset(false);
|
||||||
|
log::info!("aft reset: {:x?}", interrupts.0);
|
||||||
|
PollResult::Reset
|
||||||
|
} else if interrupts.resume() {
|
||||||
|
interrupts.set_reset(false);
|
||||||
|
log::info!("aft resume: {:x?}", interrupts.0);
|
||||||
|
PollResult::Resume
|
||||||
|
} else if interrupts.suspend() {
|
||||||
|
interrupts.set_suspend(false);
|
||||||
|
log::info!("aft suspend: {:x?}", interrupts.0);
|
||||||
|
PollResult::Suspend
|
||||||
|
} else if interrupts.disconnect() {
|
||||||
|
interrupts.set_disconnect(false);
|
||||||
|
log::info!("aft disconnect: {:x?}", interrupts.0);
|
||||||
|
PollResult::Reset
|
||||||
} else {
|
} else {
|
||||||
PollResult::None
|
PollResult::None
|
||||||
};
|
};
|
||||||
|
self.ints.store(interrupts.0, Ordering::SeqCst);
|
||||||
if interrupts.0 == 0 {
|
if interrupts.0 == 0 {
|
||||||
// all interrupts handled, re-enable nterrupts
|
// prep a cfg value prior to polling the self.regs.interrupts() register to minimize the profile of the race condition
|
||||||
let mut cfg = UdcConfig(0);
|
let mut cfg = UdcConfig(0);
|
||||||
cfg.set_enable_ints(true); // to be enabled only when all the interrupts are handled
|
cfg.set_enable_ints(true); // to be enabled only when all the interrupts are handled
|
||||||
self.regs.set_config(cfg);
|
cfg.set_pullup_on(true);
|
||||||
|
// all previous interrupts handled, re-enable interrupts
|
||||||
|
let new_ints = self.regs.interrupts().0;
|
||||||
|
if new_ints != 0 {
|
||||||
|
self.regs.clear_all_interrupts();
|
||||||
|
self.ints.store(new_ints, Ordering::SeqCst);
|
||||||
|
log::info!("new interrupts happened while handling existing interrupts, re-entering");
|
||||||
|
xous::try_send_message(self.conn,
|
||||||
|
xous::Message::new_scalar(Opcode::UsbIrqHandler.to_usize().unwrap(), 0, 0, 0, 0)).ok();
|
||||||
|
} else {
|
||||||
|
self.regs.set_config(cfg);
|
||||||
|
// TODO: there is a race condition between when we check new_ints and we enable interrupts below. Fix this.
|
||||||
|
log::info!("all ints handled, re-enabling interrupts");
|
||||||
|
}
|
||||||
} else {
|
} else {
|
||||||
log::info!("more interrupts to handle: {:x}, {:x?}", interrupts.0, interrupts);
|
log::info!("more interrupts to handle: {:x}, {:x?}", interrupts.0, interrupts);
|
||||||
self.ints.store(interrupts.0, Ordering::SeqCst);
|
|
||||||
// re-enter the interrupt handler to handle the next interrupt
|
// re-enter the interrupt handler to handle the next interrupt
|
||||||
xous::try_send_message(self.conn,
|
xous::try_send_message(self.conn,
|
||||||
xous::Message::new_scalar(Opcode::UsbIrqHandler.to_usize().unwrap(), 0, 0, 0, 0)).ok();
|
xous::Message::new_scalar(Opcode::UsbIrqHandler.to_usize().unwrap(), 0, 0, 0, 0)).ok();
|
||||||
|
|
@ -837,9 +869,19 @@ impl UsbBus for SpinalUsbDevice {
|
||||||
/// simulating a disconnect or it has not been enabled at creation time.
|
/// simulating a disconnect or it has not been enabled at creation time.
|
||||||
fn force_reset(&self) -> Result<()> {
|
fn force_reset(&self) -> Result<()> {
|
||||||
log::info!("force_reset");
|
log::info!("force_reset");
|
||||||
self.csr.wfo(utra::usbdev::USBSELECT_USBSELECT, 0);
|
|
||||||
|
let mut cfg = UdcConfig(0);
|
||||||
|
cfg.set_disable_ints(true);
|
||||||
|
cfg.set_pullup_off(true);
|
||||||
|
self.regs.set_config(cfg);
|
||||||
|
|
||||||
self.tt.sleep_ms(5).unwrap();
|
self.tt.sleep_ms(5).unwrap();
|
||||||
self.csr.wfo(utra::usbdev::USBSELECT_USBSELECT, 1);
|
|
||||||
|
let mut cfg = UdcConfig(0);
|
||||||
|
cfg.set_enable_ints(true); // to be enabled only when all the interrupts are handled
|
||||||
|
cfg.set_pullup_on(true);
|
||||||
|
self.regs.set_config(cfg);
|
||||||
|
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -72,11 +72,9 @@ fn xmain() -> ! {
|
||||||
std::thread::spawn({
|
std::thread::spawn({
|
||||||
move || {
|
move || {
|
||||||
let tt = ticktimer_server::Ticktimer::new().unwrap();
|
let tt = ticktimer_server::Ticktimer::new().unwrap();
|
||||||
let mut keepalive = 0;
|
|
||||||
loop {
|
loop {
|
||||||
|
// keeps the WDT from firing
|
||||||
tt.sleep_ms(2500).unwrap();
|
tt.sleep_ms(2500).unwrap();
|
||||||
log::info!("keepalive {}", keepalive);
|
|
||||||
keepalive += 1;
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
|
|
@ -113,7 +111,6 @@ fn xmain() -> ! {
|
||||||
let mut cmdline = String::new();
|
let mut cmdline = String::new();
|
||||||
loop {
|
loop {
|
||||||
let msg = xous::receive_message(usbdev_sid).unwrap();
|
let msg = xous::receive_message(usbdev_sid).unwrap();
|
||||||
log::info!("msg: {:?}", msg);
|
|
||||||
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::SuspendResume) => xous::msg_scalar_unpack!(msg, token, _, _, _, {
|
||||||
kbd.suspend();
|
kbd.suspend();
|
||||||
|
|
@ -238,7 +235,7 @@ fn xmain() -> ! {
|
||||||
}
|
}
|
||||||
|
|
||||||
pub(crate) const START_OFFSET: u32 = 0x0048 + 8; // align spinal free space to 16-byte boundary
|
pub(crate) const START_OFFSET: u32 = 0x0048 + 8; // align spinal free space to 16-byte boundary
|
||||||
pub(crate) const END_OFFSET: u32 = 0xFF00;
|
pub(crate) const END_OFFSET: u32 = 0x1000; // derived from RAMSIZE parameter: this could be a dynamically read out constant, but, in practice, it's part of the hardware
|
||||||
/// USB endpoint allocator. The SpinalHDL USB controller appears as a block of
|
/// USB endpoint allocator. The SpinalHDL USB controller appears as a block of
|
||||||
/// unstructured memory to the host. You can specify pointers into the memory with
|
/// unstructured memory to the host. You can specify pointers into the memory with
|
||||||
/// an offset and length to define where various USB descriptors should be placed.
|
/// an offset and length to define where various USB descriptors should be placed.
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue