mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-18 08:52:45 +00:00
add a crate dedicated to hosted-mode emulation of baosec-target items
This commit is contained in:
parent
6969d6ca10
commit
5809afebe0
8 changed files with 871 additions and 0 deletions
30
services/cramium-emu/Cargo.toml
Normal file
30
services/cramium-emu/Cargo.toml
Normal file
|
|
@ -0,0 +1,30 @@
|
||||||
|
[package]
|
||||||
|
name = "cramium-emu"
|
||||||
|
version = "0.1.0"
|
||||||
|
edition = "2021"
|
||||||
|
|
||||||
|
[dependencies]
|
||||||
|
xous = "0.9.64"
|
||||||
|
xous-ipc = "0.10.4"
|
||||||
|
xous-names = { package = "xous-api-names", version = "0.9.65" }
|
||||||
|
"ux-api" = { path = "../../libs/ux-api" }
|
||||||
|
"rand" = "0.8"
|
||||||
|
rand_core = "0.6.4"
|
||||||
|
log = "0.4.14"
|
||||||
|
num-derive = { version = "0.4.2", default-features = false }
|
||||||
|
num-traits = { version = "0.2.14", default-features = false }
|
||||||
|
rkyv = { version = "0.8.8", default-features = false, features = [
|
||||||
|
"std",
|
||||||
|
"alloc",
|
||||||
|
] }
|
||||||
|
cramium-api = { path = "../../libs/cramium-api", features = [
|
||||||
|
"derive-rkyv",
|
||||||
|
"std",
|
||||||
|
] }
|
||||||
|
|
||||||
|
[target.'cfg(any(windows,unix))'.dependencies]
|
||||||
|
minifb = "0.26.0"
|
||||||
|
|
||||||
|
[features]
|
||||||
|
hosted-baosec = []
|
||||||
|
default = ["hosted-baosec"]
|
||||||
85
services/cramium-emu/src/camera.rs
Normal file
85
services/cramium-emu/src/camera.rs
Normal file
|
|
@ -0,0 +1,85 @@
|
||||||
|
use cramium_api::camera;
|
||||||
|
use cramium_api::*;
|
||||||
|
|
||||||
|
const EMU_COLS: usize = 320;
|
||||||
|
const EMU_ROWS: usize = 240;
|
||||||
|
|
||||||
|
#[repr(C)]
|
||||||
|
pub struct Ov2640 {
|
||||||
|
frame: [u16; EMU_COLS * EMU_ROWS],
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Ov2640 {
|
||||||
|
/// Safety: clocks must be turned on before this is called
|
||||||
|
pub unsafe fn new() -> Result<Self, xous::Error> { Ok(Self { frame: [0u16; EMU_COLS * EMU_ROWS] }) }
|
||||||
|
|
||||||
|
pub fn release_ifram(&mut self) {}
|
||||||
|
|
||||||
|
pub fn claim_ifram(&mut self) -> Result<(), xous::Error> { Ok(()) }
|
||||||
|
|
||||||
|
pub fn has_ifram(&self) -> bool { false }
|
||||||
|
|
||||||
|
pub fn poke(&self, _i2c: &mut dyn I2cApi, _adr: u8, _dat: u8) {}
|
||||||
|
|
||||||
|
// chip does not support sequential reads
|
||||||
|
pub fn peek(&self, _i2c: &mut dyn I2cApi, _adr: u8, _dat: &mut [u8]) {}
|
||||||
|
|
||||||
|
pub fn init(&mut self, _i2c: &mut dyn I2cApi, _resolution: camera::Resolution) {}
|
||||||
|
|
||||||
|
/// Safety: definitely not safe, but only used in emulation mode so I'm not going to worry about it too
|
||||||
|
/// much.
|
||||||
|
pub fn rx_buf<T: UdmaWidths>(&self) -> &[T] {
|
||||||
|
unsafe {
|
||||||
|
core::slice::from_raw_parts(
|
||||||
|
self.frame.as_ptr() as *const T,
|
||||||
|
self.frame.len() / core::mem::size_of::<T>(),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Safety: definitely not safe, but only used in emulation mode so I'm not going to worry about it too
|
||||||
|
/// much.
|
||||||
|
pub unsafe fn rx_buf_phys<T: UdmaWidths>(&self) -> &[T] {
|
||||||
|
unsafe {
|
||||||
|
core::slice::from_raw_parts(
|
||||||
|
self.frame.as_ptr() as *const T,
|
||||||
|
self.frame.len() / core::mem::size_of::<T>(),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn capture_async(&mut self) {}
|
||||||
|
|
||||||
|
pub fn capture_await(&mut self, _use_yield: bool) {}
|
||||||
|
|
||||||
|
/// For emulation, we fix the resolution at 320x240
|
||||||
|
pub fn resolution(&self) -> (usize, usize) { (EMU_COLS, EMU_ROWS) }
|
||||||
|
|
||||||
|
pub fn set_slicing(&mut self, _ll: (usize, usize), _ur: (usize, usize)) {}
|
||||||
|
|
||||||
|
pub fn disable_slicing(&mut self) {}
|
||||||
|
|
||||||
|
// Commented out to avoid leaking the ColorMode type
|
||||||
|
// pub fn color_mode(&mut self, _i2c: &mut dyn I2cApi, _mode: ColorMode) {}
|
||||||
|
|
||||||
|
// Commented out to avoid leaking the Contrast & Brightness types
|
||||||
|
/*
|
||||||
|
pub fn contrast_brightness(
|
||||||
|
&mut self,
|
||||||
|
_i2c: &mut dyn I2cApi,
|
||||||
|
_contrast: Contrast,
|
||||||
|
_brightness: Brightness,
|
||||||
|
) {
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
|
||||||
|
// Commented out to avoid leaking the Effect types
|
||||||
|
// pub fn effect(&mut self, _i2c: &mut dyn I2cApi, _effect: Effect) {}
|
||||||
|
|
||||||
|
/// Returns (product ID, manufacturer ID) - hard coded to match OV2640 values
|
||||||
|
pub fn read_id(&self, i2c: &mut dyn I2cApi) -> (u16, u16) { (0x2641, 0x7fa2) }
|
||||||
|
|
||||||
|
pub fn delay(&self, quantum: usize) {
|
||||||
|
std::thread::sleep(std::time::Duration::from_millis(quantum as u64));
|
||||||
|
}
|
||||||
|
}
|
||||||
377
services/cramium-emu/src/display.rs
Normal file
377
services/cramium-emu/src/display.rs
Normal file
|
|
@ -0,0 +1,377 @@
|
||||||
|
use std::sync::{Arc, Mutex, mpsc};
|
||||||
|
|
||||||
|
use cramium_api::*;
|
||||||
|
use minifb::{Key, Window, WindowOptions};
|
||||||
|
use ux_api::minigfx::{ColorNative, FrameBuffer, Point};
|
||||||
|
|
||||||
|
pub const COLUMN: isize = 128;
|
||||||
|
pub const ROW: isize = 128;
|
||||||
|
pub const PAGE: u8 = ROW as u8 / 8;
|
||||||
|
|
||||||
|
const MAX_FPS: usize = 60;
|
||||||
|
const DARK_COLOUR: u32 = 0xB5B5AD;
|
||||||
|
const LIGHT_COLOUR: u32 = 0x1B1B19;
|
||||||
|
|
||||||
|
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
|
||||||
|
pub struct MonoColor(ColorNative);
|
||||||
|
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
|
||||||
|
pub enum Mono {
|
||||||
|
Black,
|
||||||
|
White,
|
||||||
|
}
|
||||||
|
impl From<ColorNative> for Mono {
|
||||||
|
fn from(value: ColorNative) -> Self {
|
||||||
|
match value.0 as u32 {
|
||||||
|
DARK_COLOUR => Mono::Black,
|
||||||
|
_ => Mono::White,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl Into<ColorNative> for Mono {
|
||||||
|
fn into(self) -> ColorNative {
|
||||||
|
match self {
|
||||||
|
Mono::Black => ColorNative::from(DARK_COLOUR as usize),
|
||||||
|
Mono::White => ColorNative::from(LIGHT_COLOUR as usize),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[repr(usize)]
|
||||||
|
#[derive(Eq, PartialEq, Copy, Clone)]
|
||||||
|
enum BufferState {
|
||||||
|
A = 0,
|
||||||
|
B = 2048,
|
||||||
|
}
|
||||||
|
impl BufferState {
|
||||||
|
pub fn swap(self) -> Self { if self == BufferState::A { BufferState::B } else { BufferState::A } }
|
||||||
|
|
||||||
|
pub fn as_index(&self) -> usize {
|
||||||
|
match self {
|
||||||
|
BufferState::A => 0,
|
||||||
|
BufferState::B => 1,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The channel for the backend to communicate back to the main thread that it
|
||||||
|
/// has claimed.
|
||||||
|
pub struct MainThreadToken(mpsc::SyncSender<MinifbThread>);
|
||||||
|
|
||||||
|
/// A substitute for the native never type (`!`), which is still unstable on
|
||||||
|
/// `Fn` bounds.
|
||||||
|
pub enum Never {}
|
||||||
|
|
||||||
|
/// Claim the calling thread (which must be a main thread) for use by the
|
||||||
|
/// backend and call the specified closure on a new thread.
|
||||||
|
pub fn claim_main_thread(f: impl FnOnce(MainThreadToken) -> Never + Send + 'static) -> ! {
|
||||||
|
// Some operating systems and GUI frameworks, in particular Cocoa, don't
|
||||||
|
// allow creating an event loop from a thread other than the main thread
|
||||||
|
// (TID 1) and will abort a program on violation (see issue #373), hence we
|
||||||
|
// need to claim the main thread for use by the backend.
|
||||||
|
let (send, recv) = mpsc::sync_channel(0);
|
||||||
|
|
||||||
|
// Call the closure on a fake main thread
|
||||||
|
let fake_main_thread = std::thread::Builder::new()
|
||||||
|
.name("wrapped_main".into())
|
||||||
|
.spawn(move || f(MainThreadToken(send)))
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
// Process up to one request (that's the maximum because
|
||||||
|
// `MainThreadToken: !Clone`)
|
||||||
|
match recv.recv() {
|
||||||
|
Ok(thread_params) => {
|
||||||
|
// Run a GUI event loop. Abort if the fake main thread panics
|
||||||
|
thread_params.run_while(|| !fake_main_thread.is_finished());
|
||||||
|
}
|
||||||
|
Err(mpsc::RecvError) => {}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Join on the fake main thread
|
||||||
|
match fake_main_thread.join() {
|
||||||
|
Ok(x) => match x {},
|
||||||
|
// The default panic handler should have already outputted the panic
|
||||||
|
// message, so we can just call `abort` here
|
||||||
|
Err(_) => std::process::abort(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Encapsulates the data passed to the thread handling minifb screen updates
|
||||||
|
/// and input events.
|
||||||
|
struct MinifbThread {
|
||||||
|
native_buffer: Arc<Mutex<Vec<u32>>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
struct XousKeyboardHandler {
|
||||||
|
kbd: cramium_api::keyboard::Keyboard,
|
||||||
|
left_shift: bool,
|
||||||
|
right_shift: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
pub struct Oled128x128 {
|
||||||
|
native_buffer: Arc<Mutex<Vec<u32>>>, //[u32; WIDTH * HEIGHT],
|
||||||
|
// front and back buffers
|
||||||
|
buffers: [[u32; COLUMN as usize * ROW as usize]; 2],
|
||||||
|
active_buffer: BufferState,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a> Oled128x128 {
|
||||||
|
pub fn new<T>(
|
||||||
|
main_thread_token: MainThreadToken,
|
||||||
|
_perclk_freq: u32,
|
||||||
|
_iox: &'a T,
|
||||||
|
_udma_global: &'a dyn UdmaGlobalConfig,
|
||||||
|
) -> Self {
|
||||||
|
let native_buffer = vec![DARK_COLOUR; COLUMN as usize * ROW as usize];
|
||||||
|
let native_buffer = Arc::new(Mutex::new(native_buffer));
|
||||||
|
|
||||||
|
// Start a GUI event loop on the main thread
|
||||||
|
let thread_params = MinifbThread { native_buffer: Arc::clone(&native_buffer) };
|
||||||
|
main_thread_token.0.send(thread_params).unwrap();
|
||||||
|
|
||||||
|
Self {
|
||||||
|
native_buffer,
|
||||||
|
buffers: [[DARK_COLOUR; COLUMN as usize * ROW as usize]; 2],
|
||||||
|
active_buffer: BufferState::A,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn set_data(&self) {}
|
||||||
|
|
||||||
|
fn set_command(&self) {}
|
||||||
|
|
||||||
|
pub fn buffer_swap(&mut self) { self.active_buffer = self.active_buffer.swap(); }
|
||||||
|
|
||||||
|
pub fn buffer_mut(&mut self) -> &mut [u32] { &mut self.buffers[self.active_buffer.as_index()] }
|
||||||
|
|
||||||
|
pub fn buffer(&self) -> &[u32] { &self.buffers[self.active_buffer.as_index()] }
|
||||||
|
|
||||||
|
pub fn send_command<'b, U>(&'b mut self, _cmd: U)
|
||||||
|
where
|
||||||
|
U: IntoIterator<Item = u8> + 'b,
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn init(&mut self) {}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl FrameBuffer for Oled128x128 {
|
||||||
|
/// Transfers the back buffer
|
||||||
|
fn draw(&mut self) {
|
||||||
|
// this must be opposite of what `buffer` / `buffer_mut` returns
|
||||||
|
let buffer = self.buffers[self.active_buffer.swap().as_index()];
|
||||||
|
let mut native_buffer = self.native_buffer.lock().unwrap();
|
||||||
|
native_buffer.copy_from_slice(&buffer);
|
||||||
|
}
|
||||||
|
|
||||||
|
fn clear(&mut self) { self.buffer_mut().fill(DARK_COLOUR); }
|
||||||
|
|
||||||
|
fn put_pixel(&mut self, p: Point, on: ColorNative) {
|
||||||
|
if p.x > COLUMN || p.y > ROW || p.x < 0 || p.y < 0 {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
let buffer = self.buffer_mut();
|
||||||
|
buffer[(p.x + p.y * ROW) as usize] = on.0 as u32;
|
||||||
|
}
|
||||||
|
|
||||||
|
fn dimensions(&self) -> Point { Point::new(COLUMN, ROW) }
|
||||||
|
|
||||||
|
fn get_pixel(&mut self, p: Point) -> Option<ColorNative> {
|
||||||
|
if p.x > COLUMN || p.y > ROW || p.x < 0 || p.y < 0 {
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
let buffer = self.buffer();
|
||||||
|
let color = ColorNative(buffer[(p.x + p.y * ROW) as usize] as usize);
|
||||||
|
Some(color)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl MinifbThread {
|
||||||
|
pub fn run_while(self, mut predicate: impl FnMut() -> bool) {
|
||||||
|
let mut window = Window::new(
|
||||||
|
"baosec",
|
||||||
|
COLUMN as usize,
|
||||||
|
ROW as usize,
|
||||||
|
WindowOptions {
|
||||||
|
scale_mode: minifb::ScaleMode::AspectRatioStretch,
|
||||||
|
resize: true,
|
||||||
|
..WindowOptions::default()
|
||||||
|
},
|
||||||
|
)
|
||||||
|
.unwrap_or_else(|e| {
|
||||||
|
log::error!("{e:?}");
|
||||||
|
std::process::abort();
|
||||||
|
});
|
||||||
|
|
||||||
|
// Limit the maximum update rate
|
||||||
|
window.set_target_fps(MAX_FPS);
|
||||||
|
|
||||||
|
let xns = xous_names::XousNames::new().unwrap();
|
||||||
|
let kbd = cramium_api::keyboard::Keyboard::new(&xns).unwrap();
|
||||||
|
let keyboard_handler = Box::new(XousKeyboardHandler { kbd, left_shift: false, right_shift: false });
|
||||||
|
window.set_input_callback(keyboard_handler);
|
||||||
|
|
||||||
|
let mut native_buffer = Vec::new();
|
||||||
|
|
||||||
|
while predicate() {
|
||||||
|
// Copy the contents of `native_buffer`. Release the lock
|
||||||
|
// immediately so as not to starve the server thread.
|
||||||
|
native_buffer.clear();
|
||||||
|
native_buffer.extend_from_slice(&self.native_buffer.lock().unwrap());
|
||||||
|
|
||||||
|
// Render the contents of the minifb window and handle input events.
|
||||||
|
// This may block to regulate the update rate.
|
||||||
|
window.update_with_buffer(&native_buffer, COLUMN as usize, ROW as usize).unwrap();
|
||||||
|
if !window.is_open() || window.is_key_down(Key::Escape) {
|
||||||
|
std::process::exit(0);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl XousKeyboardHandler {
|
||||||
|
fn decode_key(&mut self, k: Key) -> char {
|
||||||
|
let shift = self.left_shift || self.right_shift;
|
||||||
|
let base: char = if shift == false {
|
||||||
|
match k {
|
||||||
|
// key maps are commented out so we can use the add_char routine for all the characters
|
||||||
|
// natively handled by mini_fb this allows us to apply the native keyboard map
|
||||||
|
// to all the typed characters, while still passing through the special
|
||||||
|
// keys needed to emulate the special buttons on the device.
|
||||||
|
/* Key::A => 'a',
|
||||||
|
Key::B => 'b',
|
||||||
|
Key::C => 'c',
|
||||||
|
Key::D => 'd',
|
||||||
|
Key::E => 'e',
|
||||||
|
Key::F => 'f',
|
||||||
|
Key::G => 'g',
|
||||||
|
Key::H => 'h',
|
||||||
|
Key::I => 'i',
|
||||||
|
Key::J => 'j',
|
||||||
|
Key::K => 'k',
|
||||||
|
Key::L => 'l',
|
||||||
|
Key::M => 'm',
|
||||||
|
Key::N => 'n',
|
||||||
|
Key::O => 'o',
|
||||||
|
Key::P => 'p',
|
||||||
|
Key::Q => 'q',
|
||||||
|
Key::R => 'r',
|
||||||
|
Key::S => 's',
|
||||||
|
Key::T => 't',
|
||||||
|
Key::U => 'u',
|
||||||
|
Key::V => 'v',
|
||||||
|
Key::W => 'w',
|
||||||
|
Key::X => 'x',
|
||||||
|
Key::Y => 'y',
|
||||||
|
Key::Z => 'z',
|
||||||
|
Key::Key0 => '0',
|
||||||
|
Key::Key1 => '1',
|
||||||
|
Key::Key2 => '2',
|
||||||
|
Key::Key3 => '3',
|
||||||
|
Key::Key4 => '4',
|
||||||
|
Key::Key5 => '5',
|
||||||
|
Key::Key6 => '6',
|
||||||
|
Key::Key7 => '7',
|
||||||
|
Key::Key8 => '8',
|
||||||
|
Key::Key9 => '9',*/
|
||||||
|
Key::Left => '←',
|
||||||
|
Key::Right => '→',
|
||||||
|
Key::Up => '↑',
|
||||||
|
Key::Down => '↓',
|
||||||
|
Key::Home => '∴',
|
||||||
|
Key::Backspace => '\u{0008}',
|
||||||
|
Key::Delete => '\u{0008}',
|
||||||
|
Key::Enter => 0xd_u8.into(),
|
||||||
|
//Key::Space => ' ',
|
||||||
|
//Key::Comma => ',',
|
||||||
|
//Key::Period => '.',
|
||||||
|
Key::F1 => 0x11_u8.into(),
|
||||||
|
Key::F2 => 0x12_u8.into(),
|
||||||
|
Key::F3 => 0x13_u8.into(),
|
||||||
|
Key::F4 => 0x14_u8.into(),
|
||||||
|
Key::F5 => '😊',
|
||||||
|
Key::F6 => '福',
|
||||||
|
_ => '\u{0000}',
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
match k {
|
||||||
|
/* Key::A => 'A',
|
||||||
|
Key::B => 'B',
|
||||||
|
Key::C => 'C',
|
||||||
|
Key::D => 'D',
|
||||||
|
Key::E => 'E',
|
||||||
|
Key::F => 'F',
|
||||||
|
Key::G => 'G',
|
||||||
|
Key::H => 'H',
|
||||||
|
Key::I => 'I',
|
||||||
|
Key::J => 'J',
|
||||||
|
Key::K => 'K',
|
||||||
|
Key::L => 'L',
|
||||||
|
Key::M => 'M',
|
||||||
|
Key::N => 'N',
|
||||||
|
Key::O => 'O',
|
||||||
|
Key::P => 'P',
|
||||||
|
Key::Q => 'Q',
|
||||||
|
Key::R => 'R',
|
||||||
|
Key::S => 'S',
|
||||||
|
Key::T => 'T',
|
||||||
|
Key::U => 'U',
|
||||||
|
Key::V => 'V',
|
||||||
|
Key::W => 'W',
|
||||||
|
Key::X => 'X',
|
||||||
|
Key::Y => 'Y',
|
||||||
|
Key::Z => 'Z',
|
||||||
|
Key::Key0 => ')',
|
||||||
|
Key::Key1 => '!',
|
||||||
|
Key::Key2 => '@',
|
||||||
|
Key::Key3 => '#',
|
||||||
|
Key::Key4 => '$',
|
||||||
|
Key::Key5 => '%',
|
||||||
|
Key::Key6 => '^',
|
||||||
|
Key::Key7 => '&',
|
||||||
|
Key::Key8 => '*',
|
||||||
|
Key::Key9 => '(', */
|
||||||
|
Key::Left => '←',
|
||||||
|
Key::Right => '→',
|
||||||
|
Key::Up => '↑',
|
||||||
|
Key::Down => '↓',
|
||||||
|
Key::Home => '∴',
|
||||||
|
Key::Backspace => '\u{0008}',
|
||||||
|
Key::Delete => '\u{0008}',
|
||||||
|
//Key::Space => ' ',
|
||||||
|
//Key::Comma => '<',
|
||||||
|
//Key::Period => '>',
|
||||||
|
_ => '\u{0000}',
|
||||||
|
}
|
||||||
|
};
|
||||||
|
base
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl minifb::InputCallback for XousKeyboardHandler {
|
||||||
|
fn add_char(&mut self, uni_char: u32) {
|
||||||
|
let c = char::from_u32(uni_char).unwrap_or('\u{0000}');
|
||||||
|
if c != '\u{0008}' && c != '\u{000d}' && c != '\u{007f}' {
|
||||||
|
self.kbd.inject_key(c);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn set_key_state(&mut self, key: minifb::Key, state: bool) {
|
||||||
|
if key == Key::LeftShift {
|
||||||
|
self.left_shift = state;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if key == Key::RightShift {
|
||||||
|
self.right_shift = state;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if !state {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
log::debug!("GFX|hosted: sending key {:?}", key);
|
||||||
|
let c = self.decode_key(key);
|
||||||
|
if c != '\u{0000}' {
|
||||||
|
self.kbd.inject_key(c);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
27
services/cramium-emu/src/i2c.rs
Normal file
27
services/cramium-emu/src/i2c.rs
Normal file
|
|
@ -0,0 +1,27 @@
|
||||||
|
use cramium_api::*;
|
||||||
|
|
||||||
|
pub struct I2c {}
|
||||||
|
|
||||||
|
impl I2c {
|
||||||
|
pub fn new() -> Self { I2c {} }
|
||||||
|
|
||||||
|
/// This is used to pass a list of I2C transactions that must be completed atomically
|
||||||
|
/// No further I2C requests may happen while this is processing.
|
||||||
|
pub fn i2c_transactions(&self, list: I2cTransactions) -> Result<I2cTransactions, xous::Error> {
|
||||||
|
Ok(I2cTransactions { transactions: vec![] })
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl I2cApi for I2c {
|
||||||
|
fn i2c_read(
|
||||||
|
&mut self,
|
||||||
|
_dev: u8,
|
||||||
|
_adr: u8,
|
||||||
|
buf: &mut [u8],
|
||||||
|
_repeated_start: bool,
|
||||||
|
) -> Result<usize, xous::Error> {
|
||||||
|
Ok(buf.len())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn i2c_write(&mut self, _dev: u8, _adr: u8, data: &[u8]) -> Result<usize, xous::Error> { Ok(data.len()) }
|
||||||
|
}
|
||||||
256
services/cramium-emu/src/keyboard.rs
Normal file
256
services/cramium-emu/src/keyboard.rs
Normal file
|
|
@ -0,0 +1,256 @@
|
||||||
|
use cramium_api::keyboard::*;
|
||||||
|
use num_traits::*;
|
||||||
|
use xous::{CID, MessageSender, msg_blocking_scalar_unpack, msg_scalar_unpack};
|
||||||
|
use xous_ipc::Buffer;
|
||||||
|
|
||||||
|
pub fn start_keyboard_service() {
|
||||||
|
std::thread::spawn(move || {
|
||||||
|
keyboard_service();
|
||||||
|
});
|
||||||
|
std::thread::spawn(move || {
|
||||||
|
keyboard_bouncer();
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
fn keyboard_bouncer() {
|
||||||
|
// private server that has no dependencies but a "well-known-name" for the log server
|
||||||
|
// to forward keystrokes into.
|
||||||
|
let sid = xous::create_server_with_address(b"keyboard_bouncer")
|
||||||
|
.expect("couldn't create keyboard log bounce server");
|
||||||
|
let xns = xous_names::XousNames::new().unwrap();
|
||||||
|
let kbd = cramium_api::keyboard::Keyboard::new(&xns).unwrap();
|
||||||
|
let mut msg_opt = None;
|
||||||
|
loop {
|
||||||
|
xous::reply_and_receive_next(sid, &mut msg_opt).unwrap();
|
||||||
|
let msg = msg_opt.as_mut().unwrap();
|
||||||
|
// only one type of message is expected
|
||||||
|
match msg.body.scalar_message() {
|
||||||
|
Some(m) => {
|
||||||
|
if let Some(c) = char::from_u32(m.arg1 as u32) {
|
||||||
|
kbd.inject_key(c);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
_ => {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn keyboard_service() {
|
||||||
|
let xns = xous_names::XousNames::new().unwrap();
|
||||||
|
let kbd_sid = xns.register_name(cramium_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 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
|
||||||
|
let op = FromPrimitive::from_usize(msg.body.id());
|
||||||
|
log::debug!("{:?}", op);
|
||||||
|
match op {
|
||||||
|
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(<u32 as From<u32>>::from(kr.listener_op_id.into()) as usize);
|
||||||
|
}
|
||||||
|
Err(e) => {
|
||||||
|
log::error!("couldn't connect to listener: {:?}", e);
|
||||||
|
listener_conn = None;
|
||||||
|
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(<u32 as From<u32>>::from(kr.listener_op_id.into()) 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, _, _, _, _, {
|
||||||
|
log::warn!("Defaulting to DVORAK map");
|
||||||
|
xous::return_scalar(msg.sender, KeyMap::Dvorak.into()).expect("can't retrieve keymap");
|
||||||
|
}),
|
||||||
|
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 let Some(conn) = listener_conn {
|
||||||
|
if key != '\u{0000}' {
|
||||||
|
if key >= '\u{f700}' && key <= '\u{f8ff}' {
|
||||||
|
log::info!("ignoring key '{}'({:x})", key, key as u32); // ignore Apple PUA characters
|
||||||
|
} else {
|
||||||
|
log::debug!("injecting key '{}'({:x})", key, key as u32); // always be noisy about this, it's an exploit path
|
||||||
|
xous::try_send_message(
|
||||||
|
conn,
|
||||||
|
xous::Message::new_scalar(
|
||||||
|
listener_op.unwrap(),
|
||||||
|
key as u32 as usize,
|
||||||
|
'\u{0000}' as u32 as usize,
|
||||||
|
'\u{0000}' as u32 as usize,
|
||||||
|
'\u{0000}' as u32 as usize,
|
||||||
|
),
|
||||||
|
)
|
||||||
|
.unwrap_or_else(|_| {
|
||||||
|
log::info!("Input overflow, dropping keys!");
|
||||||
|
xous::Result::Ok
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
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)
|
||||||
|
}
|
||||||
|
|
||||||
|
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 => {
|
||||||
|
match c {
|
||||||
|
0x41 => return Ok(Some('↑')),
|
||||||
|
0x42 => return Ok(Some('↓')),
|
||||||
|
0x43 => return Ok(Some('→')),
|
||||||
|
0x44 => return Ok(Some('←')),
|
||||||
|
0x7e => return Err(()), // premature end
|
||||||
|
_ => {
|
||||||
|
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)
|
||||||
|
}
|
||||||
6
services/cramium-emu/src/lib.rs
Normal file
6
services/cramium-emu/src/lib.rs
Normal file
|
|
@ -0,0 +1,6 @@
|
||||||
|
pub mod camera;
|
||||||
|
pub mod display;
|
||||||
|
pub mod i2c;
|
||||||
|
pub mod keyboard;
|
||||||
|
pub mod trng;
|
||||||
|
pub mod udma;
|
||||||
54
services/cramium-emu/src/trng.rs
Normal file
54
services/cramium-emu/src/trng.rs
Normal file
|
|
@ -0,0 +1,54 @@
|
||||||
|
use rand::{CryptoRng, Rng, RngCore};
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct Trng {}
|
||||||
|
impl Trng {
|
||||||
|
pub fn new(_xns: &xous_names::XousNames) -> Result<Self, xous::Error> { Ok(Trng {}) }
|
||||||
|
|
||||||
|
fn reseed(&self) {}
|
||||||
|
|
||||||
|
pub fn get_u32(&self) -> Result<u32, xous::Error> { Ok(rand::thread_rng().gen()) }
|
||||||
|
|
||||||
|
pub fn get_u64(&self) -> Result<u64, xous::Error> { Ok(rand::thread_rng().gen()) }
|
||||||
|
|
||||||
|
pub fn fill_buf(&self, data: &mut [u32]) -> Result<(), xous::Error> {
|
||||||
|
for d in data.iter_mut() {
|
||||||
|
*d = rand::thread_rng().gen();
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// This is copied out of the 0.5 API for rand_core
|
||||||
|
pub fn fill_bytes_via_next(&mut self, dest: &mut [u8]) {
|
||||||
|
use core::mem::transmute;
|
||||||
|
let mut left = dest;
|
||||||
|
while left.len() >= 8 {
|
||||||
|
let (l, r) = { left }.split_at_mut(8);
|
||||||
|
left = r;
|
||||||
|
let chunk: [u8; 8] = unsafe { transmute(rand::thread_rng().next_u64().to_le()) };
|
||||||
|
l.copy_from_slice(&chunk);
|
||||||
|
}
|
||||||
|
let n = left.len();
|
||||||
|
if n > 4 {
|
||||||
|
let chunk: [u8; 8] = unsafe { transmute(rand::thread_rng().next_u64().to_le()) };
|
||||||
|
left.copy_from_slice(&chunk[..n]);
|
||||||
|
} else if n > 0 {
|
||||||
|
let chunk: [u8; 4] = unsafe { transmute(rand::thread_rng().next_u32().to_le()) };
|
||||||
|
left.copy_from_slice(&chunk[..n]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl RngCore for Trng {
|
||||||
|
fn next_u32(&mut self) -> u32 { rand::thread_rng().gen() }
|
||||||
|
|
||||||
|
fn next_u64(&mut self) -> u64 { rand::thread_rng().gen() }
|
||||||
|
|
||||||
|
fn fill_bytes(&mut self, dest: &mut [u8]) { self.fill_bytes_via_next(dest); }
|
||||||
|
|
||||||
|
fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand_core::Error> {
|
||||||
|
Ok(self.fill_bytes(dest))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl CryptoRng for Trng {}
|
||||||
36
services/cramium-emu/src/udma.rs
Normal file
36
services/cramium-emu/src/udma.rs
Normal file
|
|
@ -0,0 +1,36 @@
|
||||||
|
use cramium_api::*;
|
||||||
|
|
||||||
|
pub struct UdmaGlobal {}
|
||||||
|
|
||||||
|
impl UdmaGlobal {
|
||||||
|
pub fn new() -> Self { Self {} }
|
||||||
|
|
||||||
|
pub fn udma_clock_config(&self, _peripheral: PeriphId, _enable: bool) {}
|
||||||
|
|
||||||
|
/// Safety: this event does no checking if an event has been previously mapped. It is up
|
||||||
|
/// to the caller to ensure that no events are being stomped on.
|
||||||
|
pub unsafe fn udma_event_map(
|
||||||
|
&self,
|
||||||
|
_peripheral: PeriphId,
|
||||||
|
_event_type: PeriphEventType,
|
||||||
|
_to_channel: EventChannel,
|
||||||
|
) {
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn reset(&self, _peripheral: PeriphId) {}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl UdmaGlobalConfig for UdmaGlobal {
|
||||||
|
fn clock(&self, peripheral: PeriphId, enable: bool) { self.udma_clock_config(peripheral, enable); }
|
||||||
|
|
||||||
|
unsafe fn udma_event_map(
|
||||||
|
&self,
|
||||||
|
peripheral: PeriphId,
|
||||||
|
event_type: PeriphEventType,
|
||||||
|
to_channel: EventChannel,
|
||||||
|
) {
|
||||||
|
self.udma_event_map(peripheral, event_type, to_channel);
|
||||||
|
}
|
||||||
|
|
||||||
|
fn reset(&self, peripheral: PeriphId) { self.reset(peripheral); }
|
||||||
|
}
|
||||||
Loading…
Reference in a new issue