mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-16 08:38:26 +00:00
give loopback its own rx buffer
instead of sharing the wifi buffer loopback has its own buffer. this eliminates a race condition that happens whenever an Rx happens to happen on the wifi interface while there's loopback traffic in progress. also, i see a lot of opportunities to optimize the net stack now that i have tweaked this path; it might be interesting to break the receive interrupt out directly into the COM crate instead of passing it through LLIO then NET then COM and having COM drain the RX buffer immediately into a local "infinite" sized queue. The llio->net->com loop exists because the interrupt handler for all the i/o is shared within one hardware block, but maybe i can create an additional interrupt responder for the com interface just to optimize things a bit in a future SOC update. Alternatively, I could move all the interrupts into COM and not have them resident in LLIO. This would optimize for COM latency at the expence of I2C latency, but that's probably OK because I2C is much less latency sensitive (i2c and com interrupt, as mentioned above, share the same hardware block for external pin-based interrupts).
This commit is contained in:
parent
e71efd3333
commit
6f86aee991
3 changed files with 40 additions and 21 deletions
|
|
@ -540,19 +540,6 @@ impl Com {
|
|||
if pkt.len() > NET_MTU {
|
||||
return Err(xous::Error::OutOfMemory)
|
||||
}
|
||||
{
|
||||
// this is a hack to make loopbacks work on smoltcp. Work-around taken from Redox, but tracking this issue as well:
|
||||
// https://github.com/smoltcp-rs/smoltcp/issues/50 and https://github.com/smoltcp-rs/smoltcp/issues/55
|
||||
// Inject the loopback packets. loopback packets always take priority, for now.
|
||||
if let Some(loop_packet) = self.loopback_buf.borrow_mut().pop_front() {
|
||||
// pkt.len() is almost always not loop_packet.len(), just copy the first bit that can fit and the rest is garbarge...
|
||||
for (&s, d) in loop_packet.iter().zip(pkt.iter_mut()) {
|
||||
*d = s;
|
||||
}
|
||||
// skips polling the COM -- let's hope there wasn't a race condition on the interrupt
|
||||
return Ok(())
|
||||
}
|
||||
}
|
||||
let mut prealloc: [u8; NET_MTU] = [0; NET_MTU];
|
||||
let len_bytes = (pkt.len() as u16).to_be_bytes();
|
||||
prealloc[0] = len_bytes[0];
|
||||
|
|
@ -566,6 +553,19 @@ impl Com {
|
|||
Ok(())
|
||||
}
|
||||
|
||||
pub fn wlan_fetch_loopback_packet(&self, pkt: &mut [u8]) -> Result<(), xous::Error> {
|
||||
// this is a hack to make loopbacks work on smoltcp. Work-around taken from Redox, but tracking this issue as well:
|
||||
// https://github.com/smoltcp-rs/smoltcp/issues/50 and https://github.com/smoltcp-rs/smoltcp/issues/55
|
||||
// Inject the loopback packets. loopback packets always take priority, for now.
|
||||
if let Some(loop_packet) = self.loopback_buf.borrow_mut().pop_front() {
|
||||
// pkt.len() is almost always not loop_packet.len(), just copy the first bit that can fit and the rest is garbarge...
|
||||
for (&s, d) in loop_packet.iter().zip(pkt.iter_mut()) {
|
||||
*d = s;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// this is a hack to make loopbacks work on smoltcp. Work-around taken from Redox, but tracking this issue as well:
|
||||
// https://github.com/smoltcp-rs/smoltcp/issues/50 and https://github.com/smoltcp-rs/smoltcp/issues/55
|
||||
// this function handles enqueuing packets for local injection
|
||||
|
|
|
|||
|
|
@ -13,6 +13,8 @@ use smoltcp::{
|
|||
|
||||
use crate::{MAC_ADDRESS_LSB, MAC_ADDRESS_MSB};
|
||||
use core::sync::atomic::Ordering;
|
||||
use std::collections::VecDeque;
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
pub struct NetPhy {
|
||||
rx_buffer: [u8; NET_MTU],
|
||||
|
|
@ -20,6 +22,8 @@ pub struct NetPhy {
|
|||
com: Com,
|
||||
rx_avail: Option<u16>,
|
||||
loopback_conn: xous::CID,
|
||||
// tracks the length (and count) of the loopback packets pending
|
||||
loopback_pending: Arc::<Mutex::<VecDeque<u16>>>,
|
||||
}
|
||||
|
||||
impl<'a> NetPhy {
|
||||
|
|
@ -30,6 +34,7 @@ impl<'a> NetPhy {
|
|||
com: Com::new(&xns).unwrap(),
|
||||
rx_avail: None,
|
||||
loopback_conn,
|
||||
loopback_pending: Arc::new(Mutex::new(VecDeque::new())),
|
||||
}
|
||||
}
|
||||
// returns None if there was a slot to put the availability into
|
||||
|
|
@ -49,18 +54,26 @@ impl<'a> phy::Device<'a> for NetPhy {
|
|||
type TxToken = NetPhyTxToken<'a>;
|
||||
|
||||
fn receive(&'a mut self) -> Option<(Self::RxToken, Self::TxToken)> {
|
||||
if let Some(rx_len) = self.rx_avail.take() {
|
||||
self.com.wlan_fetch_packet(&mut self.rx_buffer[..rx_len as usize]).expect("Couldn't call wlan_fetch_packet in device adapter");
|
||||
if let Some(rx_len) = self.loopback_pending.lock().unwrap().pop_front() {
|
||||
// loopback takes precedence
|
||||
self.com.wlan_fetch_loopback_packet(&mut self.rx_buffer[..rx_len as usize]).expect("Couldn't call wlan_fetch_packet in device adapter");
|
||||
|
||||
Some((NetPhyRxToken{buf: &mut self.rx_buffer[..rx_len as usize]},
|
||||
NetPhyTxToken{buf: &mut self.tx_buffer[..], com: & self.com, loopback_conn: self.loopback_conn}))
|
||||
NetPhyTxToken{buf: &mut self.tx_buffer[..], com: & self.com, loopback_conn: self.loopback_conn, loopback_count: self.loopback_pending.clone()}))
|
||||
} else {
|
||||
None
|
||||
if let Some(rx_len) = self.rx_avail.take() {
|
||||
self.com.wlan_fetch_packet(&mut self.rx_buffer[..rx_len as usize]).expect("Couldn't call wlan_fetch_packet in device adapter");
|
||||
|
||||
Some((NetPhyRxToken{buf: &mut self.rx_buffer[..rx_len as usize]},
|
||||
NetPhyTxToken{buf: &mut self.tx_buffer[..], com: & self.com, loopback_conn: self.loopback_conn, loopback_count: self.loopback_pending.clone()}))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn transmit(&'a mut self) -> Option<Self::TxToken> {
|
||||
Some(NetPhyTxToken{buf: &mut self.tx_buffer[..], com: &self.com, loopback_conn: self.loopback_conn})
|
||||
Some(NetPhyTxToken{buf: &mut self.tx_buffer[..], com: &self.com, loopback_conn: self.loopback_conn, loopback_count: self.loopback_pending.clone()})
|
||||
}
|
||||
|
||||
fn capabilities(&self) -> DeviceCapabilities {
|
||||
|
|
@ -90,10 +103,12 @@ pub struct NetPhyTxToken<'a> {
|
|||
buf: &'a mut [u8],
|
||||
com: &'a Com,
|
||||
loopback_conn: xous::CID,
|
||||
loopback_count: Arc::<Mutex::<VecDeque<u16>>>,
|
||||
}
|
||||
impl <'a> NetPhyTxToken<'a> {
|
||||
/// Initiates the Rx side of things to read out the loopback packet that was queued
|
||||
fn loopback_rx(&self, rxlen: usize) {
|
||||
self.loopback_count.lock().unwrap().push_back(rxlen as u16);
|
||||
xous::try_send_message(self.loopback_conn,
|
||||
xous::Message::new_scalar(crate::Opcode::LoopbackRx.to_usize().unwrap(), rxlen, 0, 0, 0)
|
||||
).ok();
|
||||
|
|
|
|||
|
|
@ -1263,11 +1263,15 @@ fn main() -> ! {
|
|||
}
|
||||
}
|
||||
}
|
||||
Some(Opcode::LoopbackRx) => msg_scalar_unpack!(msg, rxlen, _, _, _, {
|
||||
Some(Opcode::LoopbackRx) => msg_scalar_unpack!(msg, _rxlen, _, _, _, {
|
||||
/*
|
||||
// the rx buf for loopback is different from the wlan interface
|
||||
// loopback uses an "infinite" internal buffer with its own length tracking, so we don't need
|
||||
// to track rxlen
|
||||
match iface.device_mut().push_rx_avail(rxlen as u16) {
|
||||
None => {} //log::info!("pushed {} bytes avail to iface", rxlen),
|
||||
Some(_) => log::warn!("Got more packets, but smoltcp didn't drain them in time"),
|
||||
}
|
||||
Some(_) => log::warn!("Got more loopback packets, but smoltcp didn't drain them in time"),
|
||||
} */
|
||||
match xous::try_send_message(
|
||||
net_conn,
|
||||
Message::new_scalar(
|
||||
|
|
|
|||
Loading…
Reference in a new issue