mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-20 09:03:28 +00:00
improve serial support; add stubs to allow for console i/o
This commit is contained in:
parent
5e01661dbf
commit
ce05053536
4 changed files with 283 additions and 48 deletions
|
|
@ -54,6 +54,5 @@ hosted = ["utralib/hosted"]
|
||||||
renode = ["utralib/renode"]
|
renode = ["utralib/renode"]
|
||||||
minimal = ["mass-storage"]
|
minimal = ["mass-storage"]
|
||||||
mass-storage = ["usbd_scsi", "usbd_mass_storage"]
|
mass-storage = ["usbd_scsi", "usbd_mass_storage"]
|
||||||
serial = []
|
|
||||||
mjolnir = [] # the big hammer for debugging Spinal USB issues. A raw memory dump of config and descriptor space. Use with care.
|
mjolnir = [] # the big hammer for debugging Spinal USB issues. A raw memory dump of config and descriptor space. Use with care.
|
||||||
default = ["serial"]
|
default = []
|
||||||
|
|
|
||||||
|
|
@ -1,53 +1,68 @@
|
||||||
|
// Note: the log server relies on this name not changing in order to hook the serial port for logging output.
|
||||||
|
// changing this name shouldn't lead to a crash, but it will lead to the USB driver being undiscoverable by the log crate.
|
||||||
pub(crate) const SERVER_NAME_USB_DEVICE: &'static str = "_Xous USB device driver_";
|
pub(crate) const SERVER_NAME_USB_DEVICE: &'static str = "_Xous USB device driver_";
|
||||||
|
|
||||||
#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)]
|
#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)]
|
||||||
pub(crate) enum Opcode {
|
pub(crate) enum Opcode {
|
||||||
/// Returns the link status
|
/// Returns the link status
|
||||||
LinkStatus,
|
LinkStatus = 0,
|
||||||
/// Send a keyboard code
|
/// Send a keyboard code
|
||||||
SendKeyCode,
|
SendKeyCode = 1,
|
||||||
/// "Type" a string to the keyboard
|
/// "Type" a string to the keyboard. This API is relied upon by the log crate.
|
||||||
SendString,
|
SendString = 2,
|
||||||
/// Get the current LED state
|
/// Get the current LED state
|
||||||
GetLedState,
|
GetLedState = 3,
|
||||||
/// Switch to a specified device core
|
/// Switch to a specified device core
|
||||||
SwitchCores,
|
SwitchCores = 4,
|
||||||
/// Makes sure a given core is selected
|
/// Makes sure a given core is selected
|
||||||
EnsureCore,
|
EnsureCore = 5,
|
||||||
/// Check which core is connected
|
/// Check which core is connected
|
||||||
WhichCore,
|
WhichCore = 6,
|
||||||
/// Restrict the debug core
|
/// Restrict the debug core
|
||||||
RestrictDebugAccess,
|
RestrictDebugAccess = 7,
|
||||||
/// Retrieve restriction state
|
/// Retrieve restriction state
|
||||||
IsRestricted,
|
IsRestricted = 8,
|
||||||
/// Set-and-check of USB debug restriction
|
/// Set-and-check of USB debug restriction
|
||||||
DebugUsbOp,
|
DebugUsbOp = 9,
|
||||||
|
|
||||||
/// Send a U2F message
|
/// Send a U2F message
|
||||||
U2fTx,
|
U2fTx = 128,
|
||||||
/// Blocks the caller, waiting for a U2F message
|
/// Blocks the caller, waiting for a U2F message
|
||||||
U2fRxDeferred,
|
U2fRxDeferred = 129,
|
||||||
/// A bump from the timeout process to check if U2fRx has timed out
|
/// A bump from the timeout process to check if U2fRx has timed out
|
||||||
U2fRxTimeout,
|
U2fRxTimeout = 130,
|
||||||
|
|
||||||
/// Query if the HID driver was able to start
|
/// Query if the HID driver was able to start
|
||||||
IsSocCompatible,
|
IsSocCompatible = 256,
|
||||||
|
|
||||||
|
/// Hook serial ASCII listener
|
||||||
|
SerialHookAscii = 512,
|
||||||
|
/// Hook serial binary listener
|
||||||
|
SerialHookBinary = 513,
|
||||||
|
/// Flush any serial buffers
|
||||||
|
SerialFlush = 514,
|
||||||
|
/// Hook eager serial sender. This is mean for e.g. using Precursor as an infinite source of random data.
|
||||||
|
SerialHookEagerSender = 515,
|
||||||
|
|
||||||
#[cfg(feature="mass-storage")]
|
#[cfg(feature="mass-storage")]
|
||||||
SetBlockDevice,
|
SetBlockDevice = 1024,
|
||||||
#[cfg(feature="mass-storage")]
|
#[cfg(feature="mass-storage")]
|
||||||
SetBlockDeviceSID,
|
SetBlockDeviceSID = 1025,
|
||||||
#[cfg(feature="mass-storage")]
|
#[cfg(feature="mass-storage")]
|
||||||
ResetBlockDevice,
|
ResetBlockDevice = 1026,
|
||||||
|
|
||||||
/// Handle the USB interrupt
|
/// Handle the USB interrupt
|
||||||
UsbIrqHandler,
|
UsbIrqHandler = 2048,
|
||||||
/// Suspend/resume callback
|
/// Suspend/resume callback
|
||||||
SuspendResume,
|
SuspendResume = 2049,
|
||||||
/// Exits the server
|
/// Exits the server
|
||||||
Quit,
|
Quit = 4096,
|
||||||
|
|
||||||
|
/// API used by the logging crate. The number is hard-coded; don't change it.
|
||||||
|
LogString = 8192,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// The log crate depends on this API not changing.
|
||||||
#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Copy, Clone)]
|
#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Copy, Clone)]
|
||||||
pub struct UsbString {
|
pub struct UsbString {
|
||||||
pub s: xous_ipc::String::<4000>,
|
pub s: xous_ipc::String::<4000>,
|
||||||
|
|
@ -83,7 +98,6 @@ pub enum UsbDeviceType {
|
||||||
Fido = 2,
|
Fido = 2,
|
||||||
#[cfg(feature="mass-storage")]
|
#[cfg(feature="mass-storage")]
|
||||||
MassStorage = 3,
|
MassStorage = 3,
|
||||||
#[cfg(feature="serial")]
|
|
||||||
Serial = 4,
|
Serial = 4,
|
||||||
}
|
}
|
||||||
use std::convert::TryFrom;
|
use std::convert::TryFrom;
|
||||||
|
|
@ -97,9 +111,22 @@ impl TryFrom<usize> for UsbDeviceType {
|
||||||
2 => Ok(UsbDeviceType::Fido),
|
2 => Ok(UsbDeviceType::Fido),
|
||||||
#[cfg(feature="mass-storage")]
|
#[cfg(feature="mass-storage")]
|
||||||
3 => Ok(UsbDeviceType::MassStorage),
|
3 => Ok(UsbDeviceType::MassStorage),
|
||||||
#[cfg(feature="serial")]
|
|
||||||
4 => Ok(UsbDeviceType::Serial),
|
4 => Ok(UsbDeviceType::Serial),
|
||||||
_ => Err("Invalid UsbDeviceType specifier"),
|
_ => Err("Invalid UsbDeviceType specifier"),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub const SERIAL_ASCII_BUFLEN: usize = 512;
|
||||||
|
pub const SERIAL_BINARY_BUFLEN: usize = 128;
|
||||||
|
#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Copy, Clone)]
|
||||||
|
pub struct UsbSerialAscii {
|
||||||
|
pub s: xous_ipc::String::<SERIAL_ASCII_BUFLEN>,
|
||||||
|
pub delimiter: Option<char>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Copy, Clone)]
|
||||||
|
pub struct UsbSerialBinary {
|
||||||
|
pub d: [u8; SERIAL_BINARY_BUFLEN],
|
||||||
|
pub len: usize,
|
||||||
|
}
|
||||||
|
|
|
||||||
|
|
@ -133,7 +133,6 @@ impl UsbHid {
|
||||||
2 => Ok(UsbDeviceType::Fido),
|
2 => Ok(UsbDeviceType::Fido),
|
||||||
#[cfg(feature="mass-storage")]
|
#[cfg(feature="mass-storage")]
|
||||||
3 => Ok(UsbDeviceType::MassStorage),
|
3 => Ok(UsbDeviceType::MassStorage),
|
||||||
#[cfg(feature="serial")]
|
|
||||||
4 => Ok(UsbDeviceType::Serial),
|
4 => Ok(UsbDeviceType::Serial),
|
||||||
_ => Err(xous::Error::InternalError)
|
_ => Err(xous::Error::InternalError)
|
||||||
}
|
}
|
||||||
|
|
@ -243,6 +242,8 @@ impl UsbHid {
|
||||||
_ => Err(xous::Error::UseBeforeInit),
|
_ => Err(xous::Error::UseBeforeInit),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
/// This will attempt to send a string using an API based on the currently connected device
|
||||||
|
/// If it's a Keyboard, it will "type" it; if it's a UART, it will just blast it out the Tx.
|
||||||
pub fn send_str(&self, s: &str) -> Result<usize, xous::Error> {
|
pub fn send_str(&self, s: &str) -> Result<usize, xous::Error> {
|
||||||
let serializer = UsbString {
|
let serializer = UsbString {
|
||||||
s: xous_ipc::String::<4000>::from_str(s),
|
s: xous_ipc::String::<4000>::from_str(s),
|
||||||
|
|
@ -339,6 +340,43 @@ impl UsbHid {
|
||||||
_ => Err(xous::Error::InternalError),
|
_ => Err(xous::Error::InternalError),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
/// Blocks until an ASCII string terminated by `delimiter` is received on serial; if `None`, it
|
||||||
|
/// will return as soon as a character (or series of characters) have been received (thus the return
|
||||||
|
/// `String` will be piecemeal)
|
||||||
|
pub fn serial_wait_ascii(&self, delimiter: Option<char>) -> String {
|
||||||
|
let req = UsbSerialAscii {
|
||||||
|
s: xous_ipc::String::new(),
|
||||||
|
delimiter
|
||||||
|
};
|
||||||
|
let mut buf = Buffer::into_buf(req).or(Err(xous::Error::InternalError)).expect("Internal error");
|
||||||
|
buf.lend_mut(self.conn, Opcode::SerialHookAscii.to_u32().unwrap()).or(Err(xous::Error::InternalError)).expect("Internal error");
|
||||||
|
let resp = buf.to_original::<UsbSerialAscii, _>().unwrap();
|
||||||
|
resp.s.to_str().to_string()
|
||||||
|
}
|
||||||
|
/// Blocks until enough binary data has been received to fill the buffer
|
||||||
|
/// Another thread can be used to call serial_flush() if we don't want to
|
||||||
|
/// block forever and we're receiving small amounts of binary data.
|
||||||
|
pub fn serial_wait_binary(&self) -> Vec::<u8> {
|
||||||
|
let req = UsbSerialBinary {
|
||||||
|
d: [0u8; SERIAL_BINARY_BUFLEN],
|
||||||
|
len: 0,
|
||||||
|
};
|
||||||
|
let mut buf = Buffer::into_buf(req).or(Err(xous::Error::InternalError)).expect("Internal error");
|
||||||
|
buf.lend_mut(self.conn, Opcode::SerialHookBinary.to_u32().unwrap()).or(Err(xous::Error::InternalError)).expect("Internal error");
|
||||||
|
let resp = buf.to_original::<UsbSerialBinary, _>().unwrap();
|
||||||
|
resp.d[..resp.len].to_vec()
|
||||||
|
}
|
||||||
|
/// Non-blocking call that issues a serial flush command to the USB stack
|
||||||
|
pub fn serial_flush(&self) -> Result<(), xous::Error> {
|
||||||
|
send_message(
|
||||||
|
self.conn,
|
||||||
|
Message::new_scalar(
|
||||||
|
Opcode::SerialFlush.to_usize().unwrap(),
|
||||||
|
0, 0, 0, 0
|
||||||
|
)
|
||||||
|
).map(|_| ())
|
||||||
|
}
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
use core::sync::atomic::{AtomicU32, Ordering};
|
use core::sync::atomic::{AtomicU32, Ordering};
|
||||||
|
|
|
||||||
|
|
@ -27,7 +27,6 @@ use keyboard::KeyMap;
|
||||||
use xous_ipc::Buffer;
|
use xous_ipc::Buffer;
|
||||||
use std::collections::VecDeque;
|
use std::collections::VecDeque;
|
||||||
|
|
||||||
#[cfg(feature="serial")]
|
|
||||||
use usbd_serial::SerialPort;
|
use usbd_serial::SerialPort;
|
||||||
|
|
||||||
pub struct EmbeddedClock {
|
pub struct EmbeddedClock {
|
||||||
|
|
@ -58,7 +57,6 @@ enum Views {
|
||||||
FidoOnly = 1,
|
FidoOnly = 1,
|
||||||
#[cfg(feature="mass-storage")]
|
#[cfg(feature="mass-storage")]
|
||||||
MassStorage = 2,
|
MassStorage = 2,
|
||||||
#[cfg(feature="serial")]
|
|
||||||
Serial = 3,
|
Serial = 3,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -69,6 +67,19 @@ enum TimeoutOp {
|
||||||
Quit,
|
Quit,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
enum SerialListenMode {
|
||||||
|
// this just causes data incoming to be printed to the debug log; it is the default
|
||||||
|
NoListener,
|
||||||
|
// this assumes there will be a CR/LF character to delimit lines (the `char` arg), and
|
||||||
|
// will buffer data until two conditions are met: 1) a listener is hooked and 2) a CR/LF is received.
|
||||||
|
// This will "infinitely" buffer incoming characters if no listener is hooked.
|
||||||
|
AsciiListener(Option<char>),
|
||||||
|
// this will simply buffer the data until the `usize` argument is met and passes it back to
|
||||||
|
// hooked listener. If this mode is set and there is no listener, it will buffer data "indefinitely"
|
||||||
|
// (e.g. until local heap is exhausted and the system panics)
|
||||||
|
BinaryListener,
|
||||||
|
}
|
||||||
|
|
||||||
pub(crate) fn main_hw() -> ! {
|
pub(crate) fn main_hw() -> ! {
|
||||||
log_server::init_wait().unwrap();
|
log_server::init_wait().unwrap();
|
||||||
log::set_max_level(log::LevelFilter::Info);
|
log::set_max_level(log::LevelFilter::Info);
|
||||||
|
|
@ -179,7 +190,6 @@ pub(crate) fn main_hw() -> ! {
|
||||||
// do the same thing for mass storage
|
// do the same thing for mass storage
|
||||||
#[cfg(feature="mass-storage")]
|
#[cfg(feature="mass-storage")]
|
||||||
let ums_dev = SpinalUsbDevice::new(usbdev_sid, usb.clone(), csr.clone());
|
let ums_dev = SpinalUsbDevice::new(usbdev_sid, usb.clone(), csr.clone());
|
||||||
#[cfg(feature="serial")]
|
|
||||||
let serial_dev = SpinalUsbDevice::new(usbdev_sid, usb.clone(), csr.clone());
|
let serial_dev = SpinalUsbDevice::new(usbdev_sid, usb.clone(), csr.clone());
|
||||||
|
|
||||||
// track which view is visible on the device core
|
// track which view is visible on the device core
|
||||||
|
|
@ -255,14 +265,10 @@ pub(crate) fn main_hw() -> ! {
|
||||||
.build();
|
.build();
|
||||||
|
|
||||||
// Serial
|
// Serial
|
||||||
#[cfg(feature="serial")]
|
|
||||||
const SERIAL_BUF_LEN: usize = 1024;
|
const SERIAL_BUF_LEN: usize = 1024;
|
||||||
#[cfg(feature="serial")]
|
|
||||||
let serial_alloc = UsbBusAllocator::new(serial_dev);
|
let serial_alloc = UsbBusAllocator::new(serial_dev);
|
||||||
#[cfg(feature="serial")]
|
|
||||||
// this will create a default port with 128 bytes of backing store
|
// this will create a default port with 128 bytes of backing store
|
||||||
let mut serial_port = SerialPort::new(&serial_alloc);
|
let mut serial_port = SerialPort::new(&serial_alloc);
|
||||||
#[cfg(feature="serial")]
|
|
||||||
let mut serial_device = UsbDeviceBuilder::new(&serial_alloc, UsbVidPid(0x1209, 0x3613))
|
let mut serial_device = UsbDeviceBuilder::new(&serial_alloc, UsbVidPid(0x1209, 0x3613))
|
||||||
.manufacturer("Kosagi")
|
.manufacturer("Kosagi")
|
||||||
.product("Precursor")
|
.product("Precursor")
|
||||||
|
|
@ -270,6 +276,10 @@ pub(crate) fn main_hw() -> ! {
|
||||||
.self_powered(false)
|
.self_powered(false)
|
||||||
.max_power(500)
|
.max_power(500)
|
||||||
.build();
|
.build();
|
||||||
|
let mut serial_listener: Option<xous::MessageEnvelope> = None;
|
||||||
|
let mut serial_listen_mode: SerialListenMode = SerialListenMode::NoListener;
|
||||||
|
let mut serial_buf = Vec::<u8>::new();
|
||||||
|
let mut serial_rx_trigger = false; // when true, the condition was met to pass data to the listener (but the listener was not yet installed)
|
||||||
|
|
||||||
let mut led_state: KeyboardLedsReport = KeyboardLedsReport::default();
|
let mut led_state: KeyboardLedsReport = KeyboardLedsReport::default();
|
||||||
let mut fido_listener: Option<xous::MessageEnvelope> = None;
|
let mut fido_listener: Option<xous::MessageEnvelope> = None;
|
||||||
|
|
@ -431,7 +441,6 @@ pub(crate) fn main_hw() -> ! {
|
||||||
_ => ()
|
_ => ()
|
||||||
};
|
};
|
||||||
}
|
}
|
||||||
#[cfg(feature="serial")]
|
|
||||||
Views::Serial => {
|
Views::Serial => {
|
||||||
match serial_device.force_reset() {
|
match serial_device.force_reset() {
|
||||||
Err(e) => log::warn!("USB reset on resume failed: {:?}", e),
|
Err(e) => log::warn!("USB reset on resume failed: {:?}", e),
|
||||||
|
|
@ -521,7 +530,6 @@ pub(crate) fn main_hw() -> ! {
|
||||||
Views::FidoOnly => fido_class.interface::<RawFidoInterface<'_, _>, _>(),
|
Views::FidoOnly => fido_class.interface::<RawFidoInterface<'_, _>, _>(),
|
||||||
#[cfg(feature="mass-storage")]
|
#[cfg(feature="mass-storage")]
|
||||||
Views::MassStorage => panic!("did not expect u2f tx when in mass storage mode!"),
|
Views::MassStorage => panic!("did not expect u2f tx when in mass storage mode!"),
|
||||||
#[cfg(feature="serial")]
|
|
||||||
Views::Serial => panic!("did not expect u2f tx while in serial mode!"),
|
Views::Serial => panic!("did not expect u2f tx while in serial mode!"),
|
||||||
};
|
};
|
||||||
u2f.write_report(&u2f_msg).ok();
|
u2f.write_report(&u2f_msg).ok();
|
||||||
|
|
@ -563,19 +571,87 @@ pub(crate) fn main_hw() -> ! {
|
||||||
}
|
}
|
||||||
None
|
None
|
||||||
},
|
},
|
||||||
#[cfg(feature="serial")]
|
|
||||||
Views::Serial => {
|
Views::Serial => {
|
||||||
if serial_device.poll(&mut [&mut serial_port]) {
|
if serial_device.poll(&mut [&mut serial_port]) {
|
||||||
let mut data = [0u8; SERIAL_BUF_LEN];
|
let mut data = [0u8; SERIAL_BUF_LEN];
|
||||||
match serial_port.read(&mut data) {
|
match serial_listen_mode {
|
||||||
Ok(len) => {
|
SerialListenMode::NoListener => {
|
||||||
log::info!("Serial got data: {:x?}", &data[..len]);
|
match serial_port.read(&mut data) {
|
||||||
|
Ok(len) => {
|
||||||
|
match std::str::from_utf8(&data[..len]) {
|
||||||
|
Ok(s) => log::info!("USB serial ascii: {}", s),
|
||||||
|
Err(_) => {
|
||||||
|
log::info!("USB serial binary: {:x?}", &data[..len]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Err(e) => {
|
||||||
|
log::info!("Serial read error: {:?}", e);
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
Err(e) => {
|
SerialListenMode::AsciiListener(maybe_delimiter) => {
|
||||||
log::info!("Serial read error: {:?}", e);
|
let readlen = serial_port.read(&mut data).unwrap_or(0);
|
||||||
|
if readlen == 0 {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if let Some(delimiter) = maybe_delimiter {
|
||||||
|
if !delimiter.is_ascii() {
|
||||||
|
log::warn!("Chosen ASCII delimiter {} is not ASCII. Serial receive will not function properly.", delimiter);
|
||||||
|
}
|
||||||
|
if !serial_rx_trigger { // once true, sticks as true
|
||||||
|
serial_rx_trigger = data[..readlen].iter().find(|&&c| c == (delimiter as u8)).is_some();
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
serial_rx_trigger = true;
|
||||||
|
}
|
||||||
|
// append the incoming data to the main buffer
|
||||||
|
for &d in &data[..readlen] {
|
||||||
|
serial_buf.push(d);
|
||||||
|
}
|
||||||
|
// now see if we should pass it back to the listener (if it is hooked)
|
||||||
|
if serial_rx_trigger && serial_listener.is_some() {
|
||||||
|
let mut rx_msg = serial_listener.take().unwrap();
|
||||||
|
let mut response = unsafe {
|
||||||
|
Buffer::from_memory_message_mut(rx_msg.body.memory_message_mut().unwrap())
|
||||||
|
};
|
||||||
|
let mut buf = response.to_original::<UsbSerialAscii, _>().unwrap();
|
||||||
|
use std::fmt::Write; // is this really the best way to do it? probably not.
|
||||||
|
write!(buf.s, "{}", std::string::String::from_utf8_lossy(&serial_buf)).ok();
|
||||||
|
|
||||||
|
response.replace(buf).unwrap();
|
||||||
|
// the rx_msg will drop and respond to the listener
|
||||||
|
serial_rx_trigger = false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
SerialListenMode::BinaryListener => {
|
||||||
|
let readlen = serial_port.read(&mut data).unwrap_or(0);
|
||||||
|
if readlen == 0 {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
// append the incoming data to the main buffer
|
||||||
|
for &d in &data[..readlen] {
|
||||||
|
serial_buf.push(d);
|
||||||
|
}
|
||||||
|
if serial_buf.len() >= SERIAL_BINARY_BUFLEN {
|
||||||
|
match serial_listener.take() {
|
||||||
|
Some(mut rx_msg) => {
|
||||||
|
let mut response = unsafe {
|
||||||
|
Buffer::from_memory_message_mut(rx_msg.body.memory_message_mut().unwrap())
|
||||||
|
};
|
||||||
|
let mut buf = response.to_original::<UsbSerialBinary, _>().unwrap();
|
||||||
|
buf.d.copy_from_slice(serial_buf.drain(..SERIAL_BINARY_BUFLEN).as_slice());
|
||||||
|
buf.len = SERIAL_BINARY_BUFLEN;
|
||||||
|
response.replace(buf).unwrap();
|
||||||
|
// the rx_msg will drop and respond to the listener
|
||||||
|
}
|
||||||
|
None => {
|
||||||
|
// do nothing, keep queuing data...
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
// TODO: add a listener here and report read data to the listener
|
|
||||||
}
|
}
|
||||||
None
|
None
|
||||||
},
|
},
|
||||||
|
|
@ -608,7 +684,6 @@ pub(crate) fn main_hw() -> ! {
|
||||||
Views::FidoOnly => fido_dev.state() == UsbDeviceState::Suspend,
|
Views::FidoOnly => fido_dev.state() == UsbDeviceState::Suspend,
|
||||||
#[cfg(feature="mass-storage")]
|
#[cfg(feature="mass-storage")]
|
||||||
Views::MassStorage => ums_device.state() == UsbDeviceState::Suspend,
|
Views::MassStorage => ums_device.state() == UsbDeviceState::Suspend,
|
||||||
#[cfg(feature="serial")]
|
|
||||||
Views::Serial => serial_device.state() == UsbDeviceState::Suspend,
|
Views::Serial => serial_device.state() == UsbDeviceState::Suspend,
|
||||||
};
|
};
|
||||||
if is_suspend {
|
if is_suspend {
|
||||||
|
|
@ -685,7 +760,6 @@ pub(crate) fn main_hw() -> ! {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
#[cfg(feature="serial")]
|
|
||||||
UsbDeviceType::Serial => {
|
UsbDeviceType::Serial => {
|
||||||
log::info!("Connecting device serial");
|
log::info!("Connecting device serial");
|
||||||
match view {
|
match view {
|
||||||
|
|
@ -771,7 +845,6 @@ pub(crate) fn main_hw() -> ! {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
#[cfg(feature="serial")]
|
|
||||||
UsbDeviceType::Serial => {
|
UsbDeviceType::Serial => {
|
||||||
log::info!("Ensuring serial device");
|
log::info!("Ensuring serial device");
|
||||||
if !usbmgmt.is_device_connected() {
|
if !usbmgmt.is_device_connected() {
|
||||||
|
|
@ -798,7 +871,6 @@ pub(crate) fn main_hw() -> ! {
|
||||||
Views::FidoOnly => xous::return_scalar(msg.sender, UsbDeviceType::Fido as usize).unwrap(),
|
Views::FidoOnly => xous::return_scalar(msg.sender, UsbDeviceType::Fido as usize).unwrap(),
|
||||||
#[cfg(feature="mass-storage")]
|
#[cfg(feature="mass-storage")]
|
||||||
Views::MassStorage => xous::return_scalar(msg.sender, UsbDeviceType::MassStorage as usize).unwrap(),
|
Views::MassStorage => xous::return_scalar(msg.sender, UsbDeviceType::MassStorage as usize).unwrap(),
|
||||||
#[cfg(feature="serial")]
|
|
||||||
Views::Serial => xous::return_scalar(msg.sender, UsbDeviceType::Serial as usize).unwrap(),
|
Views::Serial => xous::return_scalar(msg.sender, UsbDeviceType::Serial as usize).unwrap(),
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
|
|
@ -855,7 +927,6 @@ pub(crate) fn main_hw() -> ! {
|
||||||
Views::FidoOnly => xous::return_scalar(msg.sender, fido_dev.state() as usize).unwrap(),
|
Views::FidoOnly => xous::return_scalar(msg.sender, fido_dev.state() as usize).unwrap(),
|
||||||
#[cfg(feature="mass-storage")]
|
#[cfg(feature="mass-storage")]
|
||||||
Views::MassStorage => xous::return_scalar(msg.sender, ums_device.state() as usize).unwrap(),
|
Views::MassStorage => xous::return_scalar(msg.sender, ums_device.state() as usize).unwrap(),
|
||||||
#[cfg(feature="serial")]
|
|
||||||
Views::Serial => xous::return_scalar(msg.sender, serial_device.state() as usize).unwrap(),
|
Views::Serial => xous::return_scalar(msg.sender, serial_device.state() as usize).unwrap(),
|
||||||
}
|
}
|
||||||
}),
|
}),
|
||||||
|
|
@ -893,6 +964,38 @@ pub(crate) fn main_hw() -> ! {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}),
|
}),
|
||||||
|
Some(Opcode::LogString) => {
|
||||||
|
// the logger API is "best effort" only. Because retries and response codes can cause problems
|
||||||
|
// in the logger API, if anything goes wrong, we prefer to discard characters rather than get
|
||||||
|
// the whole subsystem stuck in some awful recursive error handling hell.
|
||||||
|
match view {
|
||||||
|
Views::Serial => {
|
||||||
|
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
|
||||||
|
let usb_send = buffer.to_original::<api::UsbString, _>().unwrap();
|
||||||
|
// this is implemented as a "blocking write": the routine will block until the data has all been written.
|
||||||
|
let send_data = usb_send.s.as_bytes();
|
||||||
|
let to_send = usb_send.s.len();
|
||||||
|
let mut sent = 0;
|
||||||
|
while sent < to_send {
|
||||||
|
match serial_port.write(&send_data[sent..to_send]) {
|
||||||
|
Ok(written) => {
|
||||||
|
sent += written;
|
||||||
|
}
|
||||||
|
Err(_) => {
|
||||||
|
// just drop characters
|
||||||
|
}
|
||||||
|
}
|
||||||
|
match serial_port.flush() {
|
||||||
|
Ok(_) => {},
|
||||||
|
Err(_) => {
|
||||||
|
// just drop characters
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
_ => {} // do nothing; don't fail, don't report any error.
|
||||||
|
}
|
||||||
|
}
|
||||||
Some(Opcode::SendString) => {
|
Some(Opcode::SendString) => {
|
||||||
let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
|
let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
|
||||||
let mut usb_send = buffer.to_original::<api::UsbString, _>().unwrap();
|
let mut usb_send = buffer.to_original::<api::UsbString, _>().unwrap();
|
||||||
|
|
@ -954,6 +1057,74 @@ pub(crate) fn main_hw() -> ! {
|
||||||
led_state.pack_to_slice(&mut code).unwrap();
|
led_state.pack_to_slice(&mut code).unwrap();
|
||||||
xous::return_scalar(msg.sender, code[0] as usize).unwrap();
|
xous::return_scalar(msg.sender, code[0] as usize).unwrap();
|
||||||
}),
|
}),
|
||||||
|
Some(Opcode::SerialHookAscii) => {
|
||||||
|
let maybe_delimiter = {
|
||||||
|
let buffer = unsafe {
|
||||||
|
Buffer::from_memory_message(msg.body.memory_message().unwrap())
|
||||||
|
};
|
||||||
|
let data = buffer.to_original::<UsbSerialAscii, _>().unwrap();
|
||||||
|
data.delimiter
|
||||||
|
};
|
||||||
|
serial_listen_mode = SerialListenMode::AsciiListener(maybe_delimiter);
|
||||||
|
serial_listener = Some(msg);
|
||||||
|
},
|
||||||
|
Some(Opcode::SerialHookBinary) => {
|
||||||
|
serial_listen_mode = SerialListenMode::BinaryListener;
|
||||||
|
serial_listener = Some(msg);
|
||||||
|
},
|
||||||
|
Some(Opcode::SerialFlush) => msg_scalar_unpack!(msg, _, _, _, _, {
|
||||||
|
// this will hardware flush any pending items in usb_serial driver
|
||||||
|
serial_port.flush().ok();
|
||||||
|
// this tries to return any data that's pending within the main loop's buffers
|
||||||
|
match serial_listen_mode {
|
||||||
|
SerialListenMode::BinaryListener => {
|
||||||
|
match serial_listener.take() {
|
||||||
|
Some(mut rx_msg) => {
|
||||||
|
let mut response = unsafe {
|
||||||
|
Buffer::from_memory_message_mut(rx_msg.body.memory_message_mut().unwrap())
|
||||||
|
};
|
||||||
|
let mut buf = response.to_original::<UsbSerialBinary, _>().unwrap();
|
||||||
|
let chars_avail = serial_buf.len().min(SERIAL_BINARY_BUFLEN);
|
||||||
|
buf.len = chars_avail;
|
||||||
|
buf.d.copy_from_slice(serial_buf.drain(..chars_avail).as_slice());
|
||||||
|
response.replace(buf).unwrap();
|
||||||
|
// the rx_msg will drop and respond to the listener
|
||||||
|
}
|
||||||
|
None => {
|
||||||
|
// do nothing, keep queuing data...
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
SerialListenMode::AsciiListener(_) => {
|
||||||
|
match serial_listener.take() {
|
||||||
|
Some(mut rx_msg) => {
|
||||||
|
let mut response = unsafe {
|
||||||
|
Buffer::from_memory_message_mut(rx_msg.body.memory_message_mut().unwrap())
|
||||||
|
};
|
||||||
|
let mut buf = response.to_original::<UsbSerialAscii, _>().unwrap();
|
||||||
|
use std::fmt::Write; // is this really the best way to do it? probably not.
|
||||||
|
write!(buf.s, "{}", std::string::String::from_utf8_lossy(&serial_buf)).ok();
|
||||||
|
|
||||||
|
response.replace(buf).unwrap();
|
||||||
|
// the rx_msg will drop and respond to the listener
|
||||||
|
serial_rx_trigger = false;
|
||||||
|
}
|
||||||
|
None => {} // do nothing
|
||||||
|
}
|
||||||
|
}
|
||||||
|
_ => {}
|
||||||
|
}
|
||||||
|
}),
|
||||||
|
Some(Opcode::SerialHookEagerSender) => msg_scalar_unpack!(msg, interval, trng_mode, _, _, {
|
||||||
|
// TODO
|
||||||
|
// I think the strategy here is when this is called, we start a thread that polls at some
|
||||||
|
// interval in milliseconds (taken as an argument) to see if the Tx buffer is empty and
|
||||||
|
// if rts() is true; and if so, jams more binary data into the pipe.
|
||||||
|
//
|
||||||
|
// It also takes a trng_mode argument which is used to select either CPRNG whitened output
|
||||||
|
// (which is the default mode), or direct raw data from the RO or the Avalanche generator;
|
||||||
|
// this is used to help characterize the raw entropy sources.
|
||||||
|
}),
|
||||||
Some(Opcode::Quit) => {
|
Some(Opcode::Quit) => {
|
||||||
log::warn!("Quit received, goodbye world!");
|
log::warn!("Quit received, goodbye world!");
|
||||||
break;
|
break;
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue