From 9767b293804f5c019afd525a97d3c13cb6536393 Mon Sep 17 00:00:00 2001 From: bunnie Date: Wed, 22 May 2024 02:27:34 +0800 Subject: [PATCH] add hw drivers to HAL & keyboard driver this is currently just a stand-in to provide API compat with with precursor keyboards. eventually we'll need to patch the console UART (which is output to the log crate) into the keyboard as an injector source. --- services/cram-hal-service/src/hw.rs | 1 + services/cram-hal-service/src/hw/keyboard.rs | 215 +++++++++++++++++++ 2 files changed, 216 insertions(+) create mode 100644 services/cram-hal-service/src/hw.rs create mode 100644 services/cram-hal-service/src/hw/keyboard.rs diff --git a/services/cram-hal-service/src/hw.rs b/services/cram-hal-service/src/hw.rs new file mode 100644 index 000000000..cce11f66e --- /dev/null +++ b/services/cram-hal-service/src/hw.rs @@ -0,0 +1 @@ +mod keyboard; diff --git a/services/cram-hal-service/src/hw/keyboard.rs b/services/cram-hal-service/src/hw/keyboard.rs new file mode 100644 index 000000000..b1e141f0b --- /dev/null +++ b/services/cram-hal-service/src/hw/keyboard.rs @@ -0,0 +1,215 @@ +use num_traits::*; +use xous::{msg_blocking_scalar_unpack, msg_scalar_unpack, MessageSender, CID}; +use xous_ipc::Buffer; + +use crate::api; +use crate::api::keyboard::*; + +fn start_keyboard_service() { + std::thread::spawn(move || { + keyboard_service(); + }); +} + +fn keyboard_service() { + let xns = xous_names::XousNames::new().unwrap(); + let kbd_sid = xns.register_name(api::SERVER_NAME_KBD, None).expect("can't register server"); + + let mut listener_conn: Option = None; + let mut listener_op: Option = None; + let mut raw_listener_conn: Option = None; + let mut raw_listener_op: Option = None; + let mut observer_conn: Option = None; + let mut observer_op: Option = None; + + let mut esc_index: Option = None; + let mut esc_chars = [0u8; 16]; + // storage for any blocking listeners + let mut blocking_listener = Vec::::new(); + + loop { + let msg = xous::receive_message(kbd_sid).unwrap(); // this blocks until we get a message + log::trace!("Message: {:?}", msg); + match FromPrimitive::from_usize(msg.body.id()) { + Some(KeyboardOpcode::BlockingKeyListener) => { + blocking_listener.push(msg.sender); + } + Some(KeyboardOpcode::RegisterListener) => { + let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; + let kr = buffer.as_flat::().unwrap(); + match xns.request_connection_blocking(kr.server_name.as_str()) { + Ok(cid) => { + listener_conn = Some(cid); + listener_op = Some(kr.listener_op_id as usize); + } + Err(e) => { + log::error!("couldn't connect to listener: {:?}", e); + listener_conn = None; + listener_op = None; + } + } + } + Some(KeyboardOpcode::RegisterRawListener) => { + let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; + let kr = buffer.as_flat::().unwrap(); + match xns.request_connection_blocking(kr.server_name.as_str()) { + Ok(cid) => { + raw_listener_conn = Some(cid); + raw_listener_op = Some(kr.listener_op_id as u32); + } + Err(e) => { + log::error!("couldn't connect to listener: {:?}", e); + raw_listener_conn = None; + raw_listener_op = None; + } + } + } + Some(KeyboardOpcode::RegisterKeyObserver) => { + let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; + let kr = buffer.as_flat::().unwrap(); + if observer_conn.is_none() { + match xns.request_connection_blocking(kr.server_name.as_str()) { + Ok(cid) => { + observer_conn = Some(cid); + observer_op = Some(kr.listener_op_id as usize); + } + Err(e) => { + log::error!("couldn't connect to observer: {:?}", e); + observer_conn = None; + observer_op = None; + } + } + } + } + Some(KeyboardOpcode::SelectKeyMap) => { + todo!(); + } + Some(KeyboardOpcode::GetKeyMap) => msg_blocking_scalar_unpack!(msg, _, _, _, _, { + todo!(); + }), + Some(KeyboardOpcode::SetRepeat) => msg_scalar_unpack!(msg, _rate, _delay, _, _, { + todo!(); + }), + Some(KeyboardOpcode::SetChordInterval) => msg_scalar_unpack!(msg, _delay, _, _, _, { + todo!(); + }), + Some(KeyboardOpcode::InjectKey) => msg_scalar_unpack!(msg, k, _, _, _, { + // key substitutions to help things work better + // 1b5b317e = home + // 1b5b44 = left + // 1b5b43 = right + // 1b5b41 = up + // 1b5b42 = down + let key = match esc_index { + Some(i) => { + esc_chars[i] = (k & 0xff) as u8; + match esc_match(&esc_chars[..i + 1]) { + Ok(m) => { + if let Some(code) = m { + // Ok(Some(code)) is a character found + esc_chars = [0u8; 16]; + esc_index = None; + code + } else { + // Ok(None) means we're still accumulating characters + if i + 1 < esc_chars.len() { + esc_index = Some(i + 1); + } else { + esc_index = None; + esc_chars = [0u8; 16]; + } + '\u{0000}' + } + } + // invalid sequence encountered, abort + Err(_) => { + log::warn!("Unhandled escape sequence: {:x?}", &esc_chars[..i + 1]); + esc_chars = [0u8; 16]; + esc_index = None; + '\u{0000}' + } + } + } + _ => { + if k == 0x1b { + esc_index = Some(1); + esc_chars = [0u8; 16]; // clear the full search array with every escape sequence init + esc_chars[0] = 0x1b; + '\u{0000}' + } else { + let bs_del_fix = if k == 0x7f { 0x08 } else { k }; + core::char::from_u32(bs_del_fix as u32).unwrap_or('\u{0000}') + } + } + }; + + if observer_conn.is_some() && observer_op.is_some() { + log::trace!("sending observer key"); + xous::try_send_message( + observer_conn.unwrap(), + xous::Message::new_scalar(observer_op.unwrap(), 0, 0, 0, 0), + ) + .ok(); + } + + for listener in blocking_listener.drain(..) { + // we must unblock anyways once the key is hit; even if the key is invalid, + // send the invalid key. The receiving library function will clean this up into a + // nil-response vector. + xous::return_scalar2(listener, key as u32 as usize, 0).unwrap(); + } + }), + Some(KeyboardOpcode::HandlerTrigger) => { + todo!("Write this once we have an IRQ handler for keyboard interrupts"); + } + None => { + log::error!("couldn't convert KeyboardOpcode"); + break; + } + } + } + xns.unregister_server(kbd_sid).unwrap(); + xous::destroy_server(kbd_sid).unwrap(); + xous::terminate_process(0) +} + +#[cfg(not(feature = "rawserial"))] +fn esc_match(esc_chars: &[u8]) -> Result, ()> { + let mut extended = Vec::::new(); + for (i, &c) in esc_chars.iter().enumerate() { + match i { + 0 => { + if c != 0x1b { + return Err(()); + } + } + 1 => { + if c != 0x5b { + return Err(()); + } + } + 2 => match c { + 0x41 => return Ok(Some('↑')), + 0x42 => return Ok(Some('↓')), + 0x43 => return Ok(Some('→')), + 0x44 => return Ok(Some('←')), + 0x7e => return Err(()), // premature end + _ => extended.push(c), + }, + _ => { + if c == 0x7e { + if extended.len() == 1 { + if extended[0] == 0x31 { + return Ok(Some('∴')); + } + } else { + return Err(()); // code unrecognized + } + } else { + extended.push(c) + } + } + } + } + Ok(None) +}