diff --git a/apps/vault/src/ux/framework.rs b/apps/vault/src/ux/framework.rs index 590a067b4..010a1c046 100644 --- a/apps/vault/src/ux/framework.rs +++ b/apps/vault/src/ux/framework.rs @@ -10,6 +10,7 @@ use std::io::{Read, Write as FsWrite}; use actions::ActionOp; use std::sync::atomic::Ordering as AtomicOrdering; use std::convert::TryFrom; +use usb_device_xous::UsbDeviceType; /// Display list for items. "name" is the key by which the list is sorted. /// "extra" is more information about the item, which should not be part of the sort. @@ -91,6 +92,7 @@ pub(crate) struct VaultUx { /// usb interface usb_dev: usb_device_xous::UsbHid, + usb_type: UsbDeviceType, /// totp redraw state last_epoch: u64, @@ -179,6 +181,7 @@ impl VaultUx { last_epoch: current_time / 30, current_time, last_query: String::new(), + usb_type: UsbDeviceType::FidoKbd, } } @@ -773,7 +776,7 @@ impl VaultUx { } } pub(crate) fn ensure_hid(&self) { - self.usb_dev.ensure_core(usb_device_xous::UsbDeviceType::Hid).unwrap(); + self.usb_dev.ensure_core(self.usb_type).unwrap(); self.usb_dev.restrict_debug_access(true).unwrap(); } } \ No newline at end of file diff --git a/services/shellchat/src/cmds/usb.rs b/services/shellchat/src/cmds/usb.rs index 3b0b6ac33..ad038ead4 100644 --- a/services/shellchat/src/cmds/usb.rs +++ b/services/shellchat/src/cmds/usb.rs @@ -19,15 +19,19 @@ impl<'a> ShellCmdApi<'a> for Usb { fn process(&mut self, args: xous_ipc::String::<1024>, _env: &mut CommonEnv) -> Result>, xous::Error> { let mut ret = xous_ipc::String::<1024>::new(); - let helpstring = "usb [hid] [debug] [send ] [status] [leds] [lock] [unlock] [kbdtest]"; + let helpstring = "usb [hid] [fido] [debug] [send ] [status] [leds] [lock] [unlock] [kbdtest]"; let mut tokens = args.as_str().unwrap().split(' '); if let Some(sub_cmd) = tokens.next() { match sub_cmd { "hid" => { - self.usb_dev.switch_to_core(usb_device_xous::UsbDeviceType::Hid).unwrap(); - write!(ret, "USB connected to HID core").unwrap(); + self.usb_dev.ensure_core(usb_device_xous::UsbDeviceType::FidoKbd).unwrap(); + write!(ret, "USB connected to HID (FIDO + keyboard) core").unwrap(); + } + "fido" => { + self.usb_dev.ensure_core(usb_device_xous::UsbDeviceType::Fido).unwrap(); + write!(ret, "USB connected to FIDO-only core").unwrap(); } "debug" => { self.usb_dev.switch_to_core(usb_device_xous::UsbDeviceType::Debug).unwrap(); @@ -36,7 +40,7 @@ impl<'a> ShellCmdApi<'a> for Usb { } "send" => { match self.usb_dev.get_current_core() { - Ok(UsbDeviceType::Hid) => { + Ok(UsbDeviceType::FidoKbd) => { let mut val = String::new(); join_tokens(&mut val, &mut tokens); match self.usb_dev.send_str(&val) { @@ -58,7 +62,7 @@ impl<'a> ShellCmdApi<'a> for Usb { } test_str.push('\n'); match self.usb_dev.get_current_core() { - Ok(UsbDeviceType::Hid) => { + Ok(UsbDeviceType::FidoKbd) => { match self.usb_dev.send_str(&test_str) { Ok(n) => write!(ret, "Sent {} test string", n).unwrap(), Err(_e) => write!(ret, "Can't send: are we connected to a host?").unwrap(), @@ -73,7 +77,7 @@ impl<'a> ShellCmdApi<'a> for Usb { "status" => { match self.usb_dev.get_current_core() { Ok(UsbDeviceType::Debug) => write!(ret, "Debug core connected").unwrap(), - Ok(UsbDeviceType::Hid) => { + Ok(UsbDeviceType::FidoKbd) => { match self.usb_dev.status() { UsbDeviceState::Configured => write!(ret, "HID core connected to host").unwrap(), UsbDeviceState::Suspend => write!(ret, "HID in suspend").unwrap(), @@ -85,7 +89,7 @@ impl<'a> ShellCmdApi<'a> for Usb { } "leds" => { match self.usb_dev.get_current_core() { - Ok(UsbDeviceType::Hid) => { + Ok(UsbDeviceType::FidoKbd) => { match self.usb_dev.get_led_state() { Ok(leds) => write!(ret, "LEDs: {:?}", leds).unwrap(), _ => write!(ret, "Not connected to USB host or other error").unwrap(), diff --git a/services/usb-device-xous/src/api.rs b/services/usb-device-xous/src/api.rs index bcd55b93c..6e97c9015 100644 --- a/services/usb-device-xous/src/api.rs +++ b/services/usb-device-xous/src/api.rs @@ -61,4 +61,25 @@ pub enum U2fCode { RxAck, Hangup, Denied, +} + +#[derive(Eq, PartialEq, Copy, Clone)] +#[repr(usize)] +pub enum UsbDeviceType { + Debug = 0, + FidoKbd = 1, + Fido = 2, +} +use std::convert::TryFrom; +impl TryFrom for UsbDeviceType { + type Error = &'static str; + + fn try_from(value: usize) -> Result { + match value { + 0 => Ok(UsbDeviceType::Debug), + 1 => Ok(UsbDeviceType::FidoKbd), + 2 => Ok(UsbDeviceType::Fido), + _ => Err("Invalid UsbDeviceType specifier"), + } + } } \ No newline at end of file diff --git a/services/usb-device-xous/src/hw.rs b/services/usb-device-xous/src/hw.rs index c290ac4c0..3356d0ab4 100644 --- a/services/usb-device-xous/src/hw.rs +++ b/services/usb-device-xous/src/hw.rs @@ -60,6 +60,20 @@ impl SpinalUsbMgmt { log::debug!("ramsize: {}", self.regs.ramsize()); assert!(4096 == self.regs.ramsize(), "hardware ramsize parameter does not match our expectations"); } + /// Force and hold the reset pin according to the state selected + pub fn ll_reset(&mut self, state: bool) { + self.csr.rmwf(utra::usbdev::USBSELECT_FORCE_RESET, if state {1} else {0}); + } + /// does not encode resets, leaves timing to the caller + pub fn ll_connect_device_core(&mut self, state: bool) { + if state { + log::trace!("connecting USB device core"); + self.csr.rmwf(utra::usbdev::USBSELECT_SELECT_DEVICE, 1); + } else { + log::trace!("connecting USB debug core"); + self.csr.rmwf(utra::usbdev::USBSELECT_SELECT_DEVICE, 0); + } + } 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)); @@ -239,6 +253,24 @@ impl SpinalUsbDevice { usbdev } + /// Creates a clone that has access to all the address space, but none of the allocations + pub fn clone_unalloc(&self) -> SpinalUsbDevice { + let usb = self.usb.clone(); + SpinalUsbDevice { + conn: self.conn, + csr_addr: self.csr_addr, + csr: AtomicCsr::new(self.csr.base.load(Ordering::SeqCst)), + regs: SpinalUdcRegs::new(unsafe{usb.as_mut_ptr().add(0xFF00) as *mut u32}), + eps: AtomicPtr::new(unsafe { + (usb.as_mut_ptr().add(0x00) as *mut UdcEpStatus).as_mut().unwrap() + }), + usb, + view: AllocView::default(), + tt: ticktimer_server::Ticktimer::new().unwrap(), + address: AtomicUsize::new(0), + read_allowed: AtomicU16::new(0), + } + } pub fn get_iface(&self) -> SpinalUsbMgmt { SpinalUsbMgmt { csr: AtomicCsr::new(self.csr_addr as *mut u32), diff --git a/services/usb-device-xous/src/lib.rs b/services/usb-device-xous/src/lib.rs index 20078203e..bb7712a2c 100644 --- a/services/usb-device-xous/src/lib.rs +++ b/services/usb-device-xous/src/lib.rs @@ -11,11 +11,6 @@ use packed_struct::PackedStruct; use xous_ipc::Buffer; pub use usbd_human_interface_device::device::fido::RawFidoMsg; -pub enum UsbDeviceType { - Debug = 0, - Hid = 1, -} - #[derive(Debug)] pub struct UsbHid { conn: CID, @@ -53,10 +48,7 @@ impl UsbHid { self.conn, Message::new_blocking_scalar( Opcode::SwitchCores.to_usize().unwrap(), - match core { - UsbDeviceType::Debug => 0, - UsbDeviceType::Hid => 1, - }, + core as usize, 0, 0, 0 ) ) { @@ -75,10 +67,7 @@ impl UsbHid { self.conn, Message::new_blocking_scalar( Opcode::EnsureCore.to_usize().unwrap(), - match core { - UsbDeviceType::Debug => 0, - UsbDeviceType::Hid => 1, - }, + core as usize, 0, 0, 0 ) ) { @@ -102,7 +91,8 @@ impl UsbHid { Ok(xous::Result::Scalar1(code)) => { match code { 0 => Ok(UsbDeviceType::Debug), - 1 => Ok(UsbDeviceType::Hid), + 1 => Ok(UsbDeviceType::FidoKbd), + 2 => Ok(UsbDeviceType::Fido), _ => Err(xous::Error::InternalError) } } diff --git a/services/usb-device-xous/src/main_hw.rs b/services/usb-device-xous/src/main_hw.rs index babfcdf20..07d94526b 100644 --- a/services/usb-device-xous/src/main_hw.rs +++ b/services/usb-device-xous/src/main_hw.rs @@ -2,13 +2,12 @@ use crate::*; use num_traits::*; use usb_device_xous::KeyboardLedsReport; +use usb_device_xous::UsbDeviceType; use usbd_human_interface_device::device::fido::RawFidoMsg; use usbd_human_interface_device::device::fido::RawFidoInterface; use xous::{msg_scalar_unpack, msg_blocking_scalar_unpack}; use xous_semver::SemVer; use core::num::NonZeroU8; -use core::sync::atomic::{AtomicUsize, Ordering}; -use std::sync::Arc; use usb_device::prelude::*; use usb_device::class_prelude::*; @@ -41,6 +40,10 @@ impl Clock for EmbeddedClock { } } +/// Time allowed for switchover between device core types. It's longer because some hosts +/// get really confused when you have the same VID/PID show up with a different set of endpoints. +const EXTENDED_CORE_RESET_MS: usize = 4000; +#[derive(Eq, PartialEq)] #[repr(usize)] enum Views { FidoWithKbd = 0, @@ -110,9 +113,13 @@ pub(crate) fn main_hw() -> ! { log::info!("consuming listener: {:?}", fido_listener); } - // this is a super-unsafe reach-around that shifts the hardware view based on the variable `view` - let mut usbdev = SpinalUsbDevice::new(usbdev_sid); - let mut usbmgmt = usbdev.get_iface(); + let usb_fidokbd_dev = SpinalUsbDevice::new(usbdev_sid); + let mut usbmgmt = usb_fidokbd_dev.get_iface(); + // before doing any allocs, clone a copy of the hardware access structure so we can build a second + // view into the hardware with only FIDO descriptors + let usb_fido_dev = usb_fidokbd_dev.clone_unalloc(); + // track which view is visible on the device core + let mut view = Views::FidoWithKbd; // register a suspend/resume listener let cid = xous::connect(usbdev_sid).expect("couldn't create suspend callback connection"); @@ -123,7 +130,7 @@ pub(crate) fn main_hw() -> ! { cid ).expect("couldn't create suspend/resume object"); - let usb_alloc = UsbBusAllocator::new(usbdev); + let usb_alloc = UsbBusAllocator::new(usb_fidokbd_dev); let clock = EmbeddedClock::new(); let mut composite = UsbHidClassBuilder::new() @@ -143,19 +150,19 @@ pub(crate) fn main_hw() -> ! { let keyboard = composite.interface::, _>(); keyboard.write_report(&Vec::::new()).ok(); keyboard.tick().ok(); - /* - view.store(Views::FidoOnly as usize, Ordering::SeqCst); + + let fido_alloc = UsbBusAllocator::new(usb_fido_dev); let mut fido_class = UsbHidClassBuilder::new() .add_interface( RawFidoInterface::default_config() ) - .build(&usb_alloc); + .build(&fido_alloc); - let mut fido_dev = UsbDeviceBuilder::new(&usb_alloc, UsbVidPid(0x1209, 0x3613)) + let mut fido_dev = UsbDeviceBuilder::new(&fido_alloc, UsbVidPid(0x1209, 0x3613)) .manufacturer("Kosagi") .product("Precursor") .serial_number(&serial_number) - .build(); */ + .build(); let mut led_state: KeyboardLedsReport = KeyboardLedsReport::default(); let mut fido_listener: Option = None; @@ -167,51 +174,6 @@ pub(crate) fn main_hw() -> ! { let mut lockstatus_force_update = true; // some state to track if we've been through a susupend/resume, to help out the status thread with its UX update after a restart-from-cold let mut was_suspend = true; - /* - let mut mode: bool = false; - if if mode { - usb_dev.poll(&mut [&mut c0]) - } else { - usb_dev.poll(&mut [&mut c1]) - } - { - if mode { - let keyboard = c0.interface::, _>(); - match keyboard.read_report() { - Ok(l) => { - log::info!("keyboard LEDs: {:?}", l); - led_state = l; - } - Err(e) => log::trace!("KEYB ERR: {:?}", e), - } - } - let u2f = - if mode { - c0.interface::, _>() - } else { - c1.interface::, _>() - }; - match u2f.read_report() { - Ok(u2f_report) => { - if let Some(mut listener) = fido_listener.take() { - let mut response = unsafe { - Buffer::from_memory_message_mut(listener.body.memory_message_mut().unwrap()) - }; - let mut buf = response.to_original::().unwrap(); - assert_eq!(buf.code, U2fCode::RxWait, "Expected U2fcode::RxWait in wrapper"); - buf.data.copy_from_slice(&u2f_report.packet); - log::trace!("ret deferred data {:x?}", &u2f_report.packet[..8]); - buf.code = U2fCode::RxAck; - response.replace(buf).unwrap(); - } else { - log::debug!("Got U2F packet, but no server to respond...queuing."); - fido_rx_queue.push_back(u2f_report.packet); - } - }, - Err(e) => log::trace!("U2F ERR: {:?}", e), - } - } - */ loop { let mut msg = xous::receive_message(usbdev_sid).unwrap(); let opcode: Option = FromPrimitive::from_usize(msg.body.id()); @@ -222,10 +184,20 @@ pub(crate) fn main_hw() -> ! { susres.suspend_until_resume(token).expect("couldn't execute suspend/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), - _ => () - }; + match view { + Views::FidoWithKbd => { + match usb_dev.force_reset() { + Err(e) => log::warn!("USB reset on resume failed: {:?}", e), + _ => () + }; + } + Views::FidoOnly => { + match fido_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 @@ -276,7 +248,10 @@ pub(crate) fn main_hw() -> ! { let mut u2f_msg = RawFidoMsg::default(); assert_eq!(u2f_ipc.code, U2fCode::Tx, "Expected U2fCode::Tx in wrapper"); u2f_msg.packet.copy_from_slice(&u2f_ipc.data); - let u2f = composite.interface::, _>(); + let u2f = match view { + Views::FidoWithKbd => composite.interface::, _>(), + Views::FidoOnly => fido_class.interface::, _>(), + }; u2f.write_report(&u2f_msg).ok(); log::debug!("sent U2F packet {:x?}", u2f_ipc.data); u2f_ipc.code = U2fCode::TxAck; @@ -286,19 +261,31 @@ pub(crate) fn main_hw() -> ! { buffer.replace(u2f_ipc).unwrap(); } Some(Opcode::UsbIrqHandler) => { - if usb_dev.poll(&mut [&mut composite]) { - #[cfg(feature="emukbd")] - { - let keyboard = composite.interface::, _>(); - match keyboard.read_report() { - Ok(l) => { - log::info!("keyboard LEDs: {:?}", l); - led_state = l; + let maybe_u2f = match view { + Views::FidoWithKbd => { + if usb_dev.poll(&mut [&mut composite]) { + let keyboard = composite.interface::, _>(); + match keyboard.read_report() { + Ok(l) => { + log::info!("keyboard LEDs: {:?}", l); + led_state = l; + } + Err(e) => log::trace!("KEYB ERR: {:?}", e), } - Err(e) => log::trace!("KEYB ERR: {:?}", e), + Some(composite.interface::, _>()) + } else { + None } } - let u2f = composite.interface::, _>(); + Views::FidoOnly => { + if fido_dev.poll(&mut [&mut fido_class]) { + Some(fido_class.interface::, _>()) + } else { + None + } + } + }; + if let Some(u2f) = maybe_u2f { match u2f.read_report() { Ok(u2f_report) => { if let Some(mut listener) = fido_listener.take() { @@ -319,7 +306,12 @@ pub(crate) fn main_hw() -> ! { Err(e) => log::trace!("U2F ERR: {:?}", e), } } - if usb_dev.state() == UsbDeviceState::Suspend { + + let is_suspend = match view { + Views::FidoWithKbd => usb_dev.state() == UsbDeviceState::Suspend, + Views::FidoOnly => fido_dev.state() == UsbDeviceState::Suspend, + }; + if is_suspend { log::info!("suspend detected"); if was_suspend == false { // FIDO listener needs to know when USB was unplugged, so that it can reset state per FIDO2 spec @@ -338,35 +330,102 @@ pub(crate) fn main_hw() -> ! { was_suspend = false; } }, + // always triggers a reset when called Some(Opcode::SwitchCores) => msg_blocking_scalar_unpack!(msg, core, _, _, _, { - if core == 1 { - log::info!("Connecting USB device core; disconnecting debug USB core"); - usbmgmt.connect_device_core(true); - } else { - log::info!("Connecting debug core; disconnecting USB device core"); - usbmgmt.connect_device_core(false); + let devtype: UsbDeviceType = core.try_into().unwrap(); + match devtype { + UsbDeviceType::Debug => { + log::info!("Connecting debug core; disconnecting USB device core"); + usbmgmt.connect_device_core(false); + } + UsbDeviceType::FidoKbd => { + // need to recode to also consider the view type + log::info!("Connecting USB device core; disconnecting debug USB core"); + match view { + Views::FidoWithKbd => usbmgmt.connect_device_core(true), + Views::FidoOnly => { + view = Views::FidoWithKbd; + usbmgmt.ll_reset(true); + tt.sleep_ms(1000).ok(); + usbmgmt.ll_connect_device_core(true); + tt.sleep_ms(EXTENDED_CORE_RESET_MS).ok(); + usbmgmt.ll_reset(false); + } + } + } + UsbDeviceType::Fido => { + match view { + Views::FidoOnly => usbmgmt.connect_device_core(true), + Views::FidoWithKbd => { + view = Views::FidoOnly; + usbmgmt.ll_reset(true); + tt.sleep_ms(1000).ok(); + usbmgmt.ll_connect_device_core(true); + tt.sleep_ms(EXTENDED_CORE_RESET_MS).ok(); + usbmgmt.ll_reset(false); + } + } + } } xous::return_scalar(msg.sender, 0).unwrap(); }), + // does not trigger a reset if we're already on the core Some(Opcode::EnsureCore) => msg_blocking_scalar_unpack!(msg, core, _, _, _, { - if core == 1 { - if !usbmgmt.is_device_connected() { - log::info!("Connecting USB device core; disconnecting debug USB core"); - usbmgmt.connect_device_core(true); + let devtype: UsbDeviceType = core.try_into().unwrap(); + match devtype { + UsbDeviceType::Debug => { + if usbmgmt.is_device_connected() { + log::info!("Connecting debug core; disconnecting USB device core"); + usbmgmt.connect_device_core(false); + } } - } else { - if usbmgmt.is_device_connected() { - log::info!("Connecting debug core; disconnecting USB device core"); - usbmgmt.connect_device_core(false); + UsbDeviceType::FidoKbd => { + if !usbmgmt.is_device_connected() { + log::info!("Connecting USB device core; disconnecting debug USB core"); + view = Views::FidoWithKbd; + usbmgmt.connect_device_core(true); + } else { + if view != Views::FidoWithKbd { + view = Views::FidoWithKbd; + usbmgmt.ll_reset(true); + tt.sleep_ms(1000).ok(); + usbmgmt.ll_connect_device_core(true); + tt.sleep_ms(EXTENDED_CORE_RESET_MS).ok(); + usbmgmt.ll_reset(false); + } else { + // type matches, do nothing + } + } + } + UsbDeviceType::Fido => { + if !usbmgmt.is_device_connected() { + log::info!("Connecting USB device core; disconnecting debug USB core"); + view = Views::FidoOnly; + usbmgmt.connect_device_core(true); + } else { + if view != Views::FidoOnly { + view = Views::FidoOnly; + usbmgmt.ll_reset(true); + tt.sleep_ms(1000).ok(); + usbmgmt.ll_connect_device_core(true); + tt.sleep_ms(EXTENDED_CORE_RESET_MS).ok(); + usbmgmt.ll_reset(false); + } else { + // type matches, do nothing + } + } } } xous::return_scalar(msg.sender, 0).unwrap(); }), Some(Opcode::WhichCore) => msg_blocking_scalar_unpack!(msg, _, _, _, _, { if usbmgmt.is_device_connected() { - xous::return_scalar(msg.sender, 1).unwrap(); + match view { + Views::FidoWithKbd => xous::return_scalar(msg.sender, UsbDeviceType::FidoKbd as usize).unwrap(), + Views::FidoOnly => xous::return_scalar(msg.sender, UsbDeviceType::Fido as usize).unwrap(), + } } else { - xous::return_scalar(msg.sender, 0).unwrap(); + xous::return_scalar(msg.sender, UsbDeviceType::Debug as usize).unwrap(); } }), Some(Opcode::RestrictDebugAccess) => msg_scalar_unpack!(msg, restrict, _, _, _, { @@ -414,59 +473,68 @@ pub(crate) fn main_hw() -> ! { lockstatus_force_update = false; }), Some(Opcode::LinkStatus) => msg_blocking_scalar_unpack!(msg, _, _, _, _, { - xous::return_scalar(msg.sender, usb_dev.state() as usize).unwrap(); + match view { + Views::FidoWithKbd => xous::return_scalar(msg.sender, usb_dev.state() as usize).unwrap(), + Views::FidoOnly => xous::return_scalar(msg.sender, fido_dev.state() as usize).unwrap(), + } }), Some(Opcode::SendKeyCode) => msg_blocking_scalar_unpack!(msg, code0, code1, code2, autoup, { - if usb_dev.state() == UsbDeviceState::Configured { - let mut codes = Vec::::new(); - if code0 != 0 { - codes.push(Keyboard::from_primitive(code0 as u8)); - } - if code1 != 0 { - codes.push(Keyboard::from_primitive(code1 as u8)); - } - if code2 != 0 { - codes.push(Keyboard::from_primitive(code2 as u8)); - } - let auto_up = if autoup == 1 {true} else {false}; - #[cfg(feature="emukbd")] - { - let keyboard = composite.interface::, _>(); - keyboard.write_report(&codes).ok(); - keyboard.tick().ok(); - tt.sleep_ms(30).ok(); - if auto_up { - keyboard.write_report(&[]).ok(); // this is the key-up + match view { + Views::FidoWithKbd => { + if usb_dev.state() == UsbDeviceState::Configured { + let mut codes = Vec::::new(); + if code0 != 0 { + codes.push(Keyboard::from_primitive(code0 as u8)); + } + if code1 != 0 { + codes.push(Keyboard::from_primitive(code1 as u8)); + } + if code2 != 0 { + codes.push(Keyboard::from_primitive(code2 as u8)); + } + let auto_up = if autoup == 1 {true} else {false}; + let keyboard = composite.interface::, _>(); + keyboard.write_report(&codes).ok(); keyboard.tick().ok(); tt.sleep_ms(30).ok(); + if auto_up { + keyboard.write_report(&[]).ok(); // this is the key-up + keyboard.tick().ok(); + tt.sleep_ms(30).ok(); + } + xous::return_scalar(msg.sender, 0).unwrap(); + } else { + xous::return_scalar(msg.sender, 1).unwrap(); } } - xous::return_scalar(msg.sender, 0).unwrap(); - } else { - xous::return_scalar(msg.sender, 1).unwrap(); + Views::FidoOnly => { + xous::return_scalar(msg.sender, 1).unwrap(); + } } }), Some(Opcode::SendString) => { let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) }; let mut usb_send = buffer.to_original::().unwrap(); let mut sent = 0; - for ch in usb_send.s.as_str().unwrap().chars() { - // ASSUME: user's keyboard type matches the preference on their Precursor device. - let codes = match native_map { - KeyMap::Dvorak => mappings::char_to_hid_code_dvorak(ch), - _ => mappings::char_to_hid_code_us101(ch), - }; - #[cfg(feature="emukbd")] - { - let keyboard = composite.interface::, _>(); - keyboard.write_report(&codes).ok(); - keyboard.tick().ok(); - tt.sleep_ms(30).ok(); - keyboard.write_report(&[]).ok(); // this is the key-up - keyboard.tick().ok(); - tt.sleep_ms(30).ok(); + match view { + Views::FidoWithKbd => { + for ch in usb_send.s.as_str().unwrap().chars() { + // ASSUME: user's keyboard type matches the preference on their Precursor device. + let codes = match native_map { + KeyMap::Dvorak => mappings::char_to_hid_code_dvorak(ch), + _ => mappings::char_to_hid_code_us101(ch), + }; + let keyboard = composite.interface::, _>(); + keyboard.write_report(&codes).ok(); + keyboard.tick().ok(); + tt.sleep_ms(30).ok(); + keyboard.write_report(&[]).ok(); // this is the key-up + keyboard.tick().ok(); + tt.sleep_ms(30).ok(); + sent += 1; + } } - sent += 1; + _ => {} // do nothing; will report that 0 characters were sent } usb_send.sent = Some(sent); buffer.replace(usb_send).unwrap();