mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-17 08:40:52 +00:00
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.
This commit is contained in:
parent
7d6bd3f086
commit
9767b29380
2 changed files with 216 additions and 0 deletions
1
services/cram-hal-service/src/hw.rs
Normal file
1
services/cram-hal-service/src/hw.rs
Normal file
|
|
@ -0,0 +1 @@
|
|||
mod keyboard;
|
||||
215
services/cram-hal-service/src/hw/keyboard.rs
Normal file
215
services/cram-hal-service/src/hw/keyboard.rs
Normal file
|
|
@ -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<CID> = None;
|
||||
let mut listener_op: Option<usize> = None;
|
||||
let mut raw_listener_conn: Option<CID> = None;
|
||||
let mut raw_listener_op: Option<u32> = None;
|
||||
let mut observer_conn: Option<CID> = None;
|
||||
let mut observer_op: Option<usize> = None;
|
||||
|
||||
let mut esc_index: Option<usize> = None;
|
||||
let mut esc_chars = [0u8; 16];
|
||||
// storage for any blocking listeners
|
||||
let mut blocking_listener = Vec::<MessageSender>::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::<KeyboardRegistration, _>().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::<KeyboardRegistration, _>().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::<KeyboardRegistration, _>().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<Option<char>, ()> {
|
||||
let mut extended = Vec::<u8>::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)
|
||||
}
|
||||
Loading…
Reference in a new issue