demonstrate switching of core between configurations using shell commands

This commit is contained in:
bunnie 2022-08-10 18:58:55 +08:00
parent 2aebf6819a
commit d1bd99a7f2
6 changed files with 268 additions and 150 deletions

View file

@ -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();
}
}

View file

@ -19,15 +19,19 @@ impl<'a> ShellCmdApi<'a> for Usb {
fn process(&mut self, args: xous_ipc::String::<1024>, _env: &mut CommonEnv) -> Result<Option<xous_ipc::String::<1024>>, xous::Error> {
let mut ret = xous_ipc::String::<1024>::new();
let helpstring = "usb [hid] [debug] [send <string>] [status] [leds] [lock] [unlock] [kbdtest]";
let helpstring = "usb [hid] [fido] [debug] [send <string>] [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(),

View file

@ -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<usize> for UsbDeviceType {
type Error = &'static str;
fn try_from(value: usize) -> Result<Self, Self::Error> {
match value {
0 => Ok(UsbDeviceType::Debug),
1 => Ok(UsbDeviceType::FidoKbd),
2 => Ok(UsbDeviceType::Fido),
_ => Err("Invalid UsbDeviceType specifier"),
}
}
}

View file

@ -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),

View file

@ -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)
}
}

View file

@ -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::<NKROBootKeyboardInterface<'_, _, _,>, _>();
keyboard.write_report(&Vec::<Keyboard>::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<xous::MessageEnvelope> = 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::<NKROBootKeyboardInterface<'_, _, _,>, _>();
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::<RawFidoInterface<'_, _>, _>()
} else {
c1.interface::<RawFidoInterface<'_, _>, _>()
};
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::<U2fMsgIpc, _>().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<Opcode> = 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::<RawFidoInterface<'_, _>, _>();
let u2f = match view {
Views::FidoWithKbd => composite.interface::<RawFidoInterface<'_, _>, _>(),
Views::FidoOnly => fido_class.interface::<RawFidoInterface<'_, _>, _>(),
};
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::<NKROBootKeyboardInterface<'_, _, _,>, _>();
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::<NKROBootKeyboardInterface<'_, _, _,>, _>();
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::<RawFidoInterface<'_, _>, _>())
} else {
None
}
}
let u2f = composite.interface::<RawFidoInterface<'_, _>, _>();
Views::FidoOnly => {
if fido_dev.poll(&mut [&mut fido_class]) {
Some(fido_class.interface::<RawFidoInterface<'_, _>, _>())
} 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::<Keyboard>::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::<NKROBootKeyboardInterface<'_, _, _,>, _>();
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::<Keyboard>::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::<NKROBootKeyboardInterface<'_, _, _,>, _>();
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::<api::UsbString, _>().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::<NKROBootKeyboardInterface<'_, _, _,>, _>();
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::<NKROBootKeyboardInterface<'_, _, _,>, _>();
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();