diff --git a/Cargo.lock b/Cargo.lock index c4470396b..ba2fd87f1 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -390,6 +390,7 @@ dependencies = [ "com", "graphics-server", "heapless", + "ime-frontend", "keyboard", "log", "log-server", @@ -525,12 +526,49 @@ version = "2.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4" +[[package]] +name = "ime-frontend" +version = "0.1.0" +dependencies = [ + "graphics-server", + "heapless", + "log", + "log-server", + "rkyv", + "ticktimer-server", + "utralib", + "xous", + "xous-names", +] + +[[package]] +name = "ime-plugin-shell" +version = "0.1.0" +dependencies = [ + "heapless", + "log", + "log-server", + "rkyv", + "ticktimer-server", + "utralib", + "xous", + "xous-names", +] + [[package]] name = "itoa" version = "0.4.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dd25036021b0de88a0aff6b850051563c6516d0bf53f8638938edbb9de732736" +[[package]] +name = "kernel-test" +version = "0.1.0" +dependencies = [ + "utralib", + "xous", +] + [[package]] name = "keyboard" version = "0.1.0" diff --git a/Cargo.toml b/Cargo.toml index 668f8f7ba..23d88ecfd 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -14,10 +14,13 @@ members = [ "services/fcc-agent", "services/xous-names", "services/keyboard", + "services/kernel-test", "services/trng", "services/gam", "services/benchmark", "services/benchmark-target", + "services/ime-frontend", + "services/ime-plugin-shell", "svd2utra", "xtask", "imports/blitstr-ref", @@ -40,6 +43,8 @@ default-members = [ "imports/com_rs-ref", "services/benchmark", "services/benchmark-target", + "services/ime-frontend", + "services/ime-plugin-shell", ] # These packages have custom RUSTFLAGS, so if they diff --git a/kernel/src/arch/riscv/mem.rs b/kernel/src/arch/riscv/mem.rs index 26208df97..fb6007d63 100644 --- a/kernel/src/arch/riscv/mem.rs +++ b/kernel/src/arch/riscv/mem.rs @@ -593,6 +593,12 @@ pub fn virt_to_phys(virt: usize) -> Result { // Ensure the entry hasn't already been mapped. if l0_pt.entries[vpn0] & MMUFlags::VALID.bits() == 0 { + // The memory has been reserved, but isn't pointing anywhere yet. + if l0_pt.entries[vpn0] != 0 { + return Err(xous_kernel::Error::MemoryInUse); + } + + // The address hasn't been allocated return Err(xous_kernel::Error::BadAddress); } Ok((l0_pt.entries[vpn0] >> 10) << 12) diff --git a/kernel/src/debug.rs b/kernel/src/debug.rs index 6c63b6ee2..8b2c1f463 100644 --- a/kernel/src/debug.rs +++ b/kernel/src/debug.rs @@ -6,6 +6,9 @@ use core::fmt::{Error, Write}; #[cfg(baremetal)] use utralib::generated::*; +#[allow(dead_code)] // this is unused in hosted mode, kill the warning +static mut INITIALIZED: bool = false; + #[macro_use] #[cfg(all( not(test), @@ -67,12 +70,17 @@ pub struct Uart { #[cfg(baremetal)] impl Uart { #[allow(dead_code)] - pub fn enable_rx(self) { + pub fn init(self) { + unsafe { INITIALIZED = true }; let mut uart_csr = CSR::new(0xffcf_0000 as *mut u32); uart_csr.rmwf(utra::uart::EV_ENABLE_RX, 1); } pub fn putc(&self, c: u8) { + if unsafe { INITIALIZED != true } { + return; + } + let mut uart_csr = CSR::new(0xffcf_0000 as *mut u32); // Wait until TXFULL is `0` while uart_csr.r(utra::uart::TXFULL) != 0 { diff --git a/kernel/src/main.rs b/kernel/src/main.rs index e97364cfc..2a9b61dd7 100644 --- a/kernel/src/main.rs +++ b/kernel/src/main.rs @@ -76,8 +76,8 @@ pub extern "C" fn init(arg_offset: *const u32, init_offset: *const u32, rpt_offs ) .expect("unable to map serial port") }); + debug::Uart{}.init(); println!("KMAIN: Supervisor mode started..."); - debug::Uart{}.enable_rx(); println!("Claiming IRQ {} via syscall...", utra::uart::UART_IRQ); xous_kernel::claim_interrupt(utra::uart::UART_IRQ, debug::irq, 0 as *mut usize) .expect("Couldn't claim debug interrupt"); diff --git a/kernel/src/mem.rs b/kernel/src/mem.rs index 25be8e4b9..7c2dda727 100644 --- a/kernel/src/mem.rs +++ b/kernel/src/mem.rs @@ -290,7 +290,6 @@ impl MemoryManager { // Look for a sequence of `size` pages that are free. for potential_start in (initial..end - size).step_by(PAGE_SIZE) { - // println!(" Checking {:08x}...", potential_start); let mut all_free = true; for check_page in (potential_start..potential_start + size).step_by(PAGE_SIZE) { if !crate::arch::mem::address_available(check_page) { @@ -313,7 +312,6 @@ impl MemoryManager { } for potential_start in (start..initial).step_by(PAGE_SIZE) { - // println!(" Checking {:08x}...", potential_start); let mut all_free = true; for check_page in (potential_start..potential_start + size).step_by(PAGE_SIZE) { if !crate::arch::mem::address_available(check_page) { @@ -334,7 +332,6 @@ impl MemoryManager { return Ok(potential_start as *mut u8); } } - // println!("Couldn't find virtual address"); Err(xous_kernel::Error::BadAddress) }) } diff --git a/kernel/src/services.rs b/kernel/src/services.rs index be8810c05..d56cabcd3 100644 --- a/kernel/src/services.rs +++ b/kernel/src/services.rs @@ -36,7 +36,7 @@ pub struct SystemServices { _syscall_depth: usize, } -#[derive(Debug, Copy, Clone, PartialEq)] +#[derive(Copy, Clone, PartialEq)] pub enum ProcessState { /// This is an unallocated, free process Free, @@ -62,6 +62,20 @@ pub enum ProcessState { Sleeping, } +impl core::fmt::Debug for ProcessState { + fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::result::Result<(), core::fmt::Error> { + use ProcessState::*; + match *self { + Free => write!(fmt, "Free"), + Allocated => write!(fmt, "Allocated"), + Setup(ti) => write!(fmt, "Setup({:?})", ti), + Ready(rt) => write!(fmt, "Ready({:b})", rt), + Running(rt) => write!(fmt, "Running({:b})", rt), + Sleeping => write!(fmt, "Sleeping"), + } + } +} + impl Default for ProcessState { fn default() -> ProcessState { ProcessState::Free @@ -541,7 +555,6 @@ impl SystemServices { /// Mark the specified context as ready to run. If the thread is Sleeping, mark /// it as Ready. pub fn ready_thread(&mut self, pid: PID, tid: TID) -> Result<(), xous_kernel::Error> { - // assert!(tid == INITIAL_TID); let process = self.get_process_mut(pid)?; process.state = match process.state { ProcessState::Free => { @@ -684,10 +697,13 @@ impl SystemServices { ProcessState::Running(new_mask) } }; + // println!( - // "switch_to_thread({}:{:?}): New state is {:?}", + // "switch_to_thread({}:{:?}): New state is {:?} Thread is ", // pid, tid, process.state // ); + // ArchProcess::with_current(|current| current.print_thread()); + Ok(()) } @@ -705,6 +721,8 @@ impl SystemServices { // "switch_from_thread({}:{}): Old state was {:?}", // pid, tid, process.state // ); + // ArchProcess::with_current(|current| current.print_thread()); + process.state = match process.state { ProcessState::Running(x) if x & (1 << tid) != 0 => panic!( "PID {} thread {} was already queued for running when `switch_from_thread()` was called", @@ -798,6 +816,7 @@ impl SystemServices { "\n\r KERNEL({},{}): Activating process {} thread {}", previous_pid, previous_tid, new_pid, new_tid ); + //ArchProcess::with_current(|current| current.print_thread()); } // Save state if the PID has changed. This will activate the new memory @@ -823,11 +842,6 @@ impl SystemServices { new.state ); if new_tid == 0 { - print!( - "PID {}: Looking for a valid context in the mask {:08b}", - new_pid, x, - ); - //new_tid = 0; new_tid = (new.current_thread + 1) as usize; while x & (1 << new_tid) == 0 { new_tid += 1; @@ -835,22 +849,22 @@ impl SystemServices { new_tid = 0; } else if new_tid == (new.current_thread + 1) as usize { // If we've looped around, return an error. - println!("Looked through all contexts and couldn't find one that was ready"); + // println!("Looked through all contexts and couldn't find one that was ready"); return Err(xous_kernel::Error::ProcessNotFound); } } new.current_thread = new_tid as _; - println!(" -- picked thread {}", new_tid); + // println!(" -- picked thread {}", new_tid); } else if x & (1 << new_tid) == 0 { - println!( - "thread is {:?}, which is not valid for new thread {}", - new.state, new_tid - ); + // println!( + // "thread is {:?}, which is not valid for new thread {}", + // new.state, new_tid + // ); return Err(xous_kernel::Error::ProcessNotFound); } } ProcessState::Sleeping => { - println!("PID {} was sleeping", new_pid); + // println!("PID {} was sleeping", new_pid); return Err(xous_kernel::Error::ProcessNotFound); } } @@ -928,50 +942,53 @@ impl SystemServices { // previous_pid, previous.state, can_resume // ); } else { - // if self.current_thread(previous_pid) == new_tid { - // if !can_resume { - // panic!("tried to switch to our own context without resume"); - // } - // return Ok(new_tid); - // } + let new = self.get_process_mut(new_pid)?; - // we can get here if we're activating a new thread in the same process - //return Ok(new_tid); + // If we wanted to switch to a "new" thread, and it's the same + // as the one we just switched from, do nothing. + if new.current_thread == new_tid { + if !can_resume { + panic!("tried to switch to our own context without resume"); + } + return Ok(new_tid); + } - let new = self.get_process_mut(new_pid)?; /* - new.state = match new.state { - ProcessState::Running(x) if (x & 1 << new_tid) == 0 => { - return Err(xous_kernel::Error::ProcessNotFound) - } - // ProcessState::Running(x) => { - // if can_resume { - // ProcessState::Running((x | (1 << previous_tid)) & !(1 << new_tid)) - // } else { - // ProcessState::Running(x | (1 << previous_tid)) - // } - // } - other => */ - panic!( - "PID {} invalid process state (not Running): {:?}", - previous_pid, new.state - ) /*, - }*/ - ; - // if advance_thread { - // new.current_thread += 1; - // if new.current_thread as TID > arch::process::MAX_CONTEXT { - // new.current_thread = 0; - // } - // } + // Transition to the new state. + new.state = if let ProcessState::Running(x) = new.state { + let previous_tid = new.current_thread; + // If no new thread is specified, take the previous + // thread. If that is not runnable, do a round-robin + // search for the next available thread. + if new_tid == 0 { + new_tid = (new.current_thread + 1) as usize; + while x & (1 << new_tid) == 0 { + new_tid += 1; + if new_tid > arch::process::MAX_THREAD { + new_tid = 0; + } else if new_tid == (new.current_thread + 1) as usize { + // If we've looped around, return an error. + return Err(xous_kernel::Error::ProcessNotFound); + } + } + new.current_thread = new_tid as _; + } else if x & (1 << new_tid) == 0 { + return Err(xous_kernel::Error::ProcessNotFound); + } + // Mark the previous TID as being runnable, and remove the new TID + // from the list of threads that can be run. + ProcessState::Running(x & !(1 << new_tid) | if can_resume { 1 << previous_tid } else { 0 }) + } else { + panic!( + "PID {} invalid process state (not Running): {:?}", + previous_pid, new.state + ) + }; } - // self.pid = new_pid; let mut process = crate::arch::process::Process::current(); - // Restore the previous context, if one exists. + // Restore the previous thread, if one exists. process.set_thread(new_tid)?; - // self.processes[new_pid.get() as usize - 1].current_thread = new_tid as u8; - // let _ctx = process.current_context(); Ok(new_tid) } diff --git a/kernel/src/syscall.rs b/kernel/src/syscall.rs index 1627355e3..48596cbe8 100644 --- a/kernel/src/syscall.rs +++ b/kernel/src/syscall.rs @@ -578,8 +578,6 @@ pub fn handle(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallResult } pub fn handle_inner(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallResult { - // let pid = arch::current_pid(); - match call { SysCall::MapMemory(phys, virt, size, req_flags) => { MemoryManager::with_mut(|mm| { diff --git a/services/com/src/main.rs b/services/com/src/main.rs index 00c0f3e33..607f8ba34 100644 --- a/services/com/src/main.rs +++ b/services/com/src/main.rs @@ -178,9 +178,8 @@ mod implementation { use crate::WorkRequest; use com_rs_ref as com_rs; use com_rs::*; - use log::{error, info}; + use log::error; - #[macro_use] use heapless::Vec; use heapless::consts::*; @@ -201,7 +200,7 @@ mod implementation { 0xDEAD as u16 } - pub fn wait_txrx(&mut self, tx: u16, timeout: Option) -> u16 { + pub fn wait_txrx(&mut self, _tx: u16, _timeout: Option) -> u16 { 0xDEAD as u16 } diff --git a/services/gam/Cargo.toml b/services/gam/Cargo.toml index 53453bd1a..b7d4a7f1f 100644 --- a/services/gam/Cargo.toml +++ b/services/gam/Cargo.toml @@ -19,6 +19,7 @@ heapless = "0.5" log = "0.4" com = { path = "../com"} blitstr-ref = { path = "../../imports/blitstr-ref" } +ime-frontend = {path="../ime-frontend"} [target.'cfg(not(any(windows,unix)))'.dependencies] diff --git a/services/gam/src/api.rs b/services/gam/src/api.rs index f7dec886f..22b6c39c8 100644 --- a/services/gam/src/api.rs +++ b/services/gam/src/api.rs @@ -1,7 +1,5 @@ use xous::{Message, ScalarMessage}; -use graphics_server::api::{Point, Rectangle, TextView, TextViewResult, Gid, Line, RoundedRectangle, Circle}; -use blitstr_ref as blitstr; -use blitstr::{GlyphStyle, Cursor}; +use graphics_server::api::{Rectangle, TextView, Gid, Line, RoundedRectangle, Circle}; #[derive(Debug, rkyv::Archive, rkyv::Unarchive, Copy, Clone)] pub enum GamObjectType { diff --git a/services/gam/src/canvas.rs b/services/gam/src/canvas.rs index 19a7e42f9..463b92ca5 100644 --- a/services/gam/src/canvas.rs +++ b/services/gam/src/canvas.rs @@ -1,13 +1,10 @@ use core::cmp::Ordering; use heapless::binary_heap::{BinaryHeap, Max}; use heapless::FnvIndexMap; -use heapless::Vec; use heapless::consts::*; use graphics_server::*; use log::{error, info}; -use crate::api::*; - #[derive(Debug, Copy, Clone, Eq, PartialEq)] pub enum CanvasState { // the initial state of every Canvas. Not drawable. @@ -41,6 +38,8 @@ pub struct Canvas { // enables scroll/pan of objects within a region pan_offset: Point, } + +#[allow(dead_code)] impl Canvas { pub fn new(clip_rect: Rectangle, trust_level: u8, trng_conn: xous::CID, pan_offset: Option) -> Result { diff --git a/services/gam/src/lib.rs b/services/gam/src/lib.rs index 959f59f6f..0a97e9184 100644 --- a/services/gam/src/lib.rs +++ b/services/gam/src/lib.rs @@ -5,17 +5,17 @@ use api::*; use rkyv::Write; use rkyv::Unarchive; -use graphics_server::api::{TextOp, TextView, TextViewResult}; +use graphics_server::api::{TextOp, TextView}; -use graphics_server::api::{Rectangle, Point, Gid, TextBounds, Line}; -use log::{error, info}; +use graphics_server::api::{Point, Gid, Line}; +use log::info; /// this "posts" a textview -- it's not a "draw" as the update is neither guaranteed nor instantaneous /// the GAM first has to check that the textview is allowed to be updated, and then it will decide when /// the actual screen update is allowed pub fn post_textview(gam_cid: xous::CID, tv: &mut TextView) -> Result<(), xous::Error> { tv.set_op(TextOp::Render); - let mut rkyv_tv = api::Opcode::RenderTextView(*tv); + let rkyv_tv = api::Opcode::RenderTextView(*tv); let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); let pos = writer.archive(&rkyv_tv).expect("GAM_API: couldn't archive textview"); let mut xous_buffer = writer.into_inner(); @@ -39,14 +39,14 @@ pub fn post_textview(gam_cid: xous::CID, tv: &mut TextView) -> Result<(), xous:: } pub fn draw_line(gam_cid: xous::CID, gid: Gid, line: Line) -> Result<(), xous::Error> { - let mut rkyv_tv = api::Opcode::RenderObject( + let rkyv_tv = api::Opcode::RenderObject( GamObject { canvas: gid, obj: GamObjectType::Line(line), }); let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); let pos = writer.archive(&rkyv_tv).expect("GAM_API: couldn't archive GamObject"); - let mut xous_buffer = writer.into_inner(); + let xous_buffer = writer.into_inner(); xous_buffer.lend(gam_cid, pos as u32).expect("GAM_API: GamObject operation failure"); diff --git a/services/gam/src/main.rs b/services/gam/src/main.rs index f77adaf62..a0d1aebdf 100644 --- a/services/gam/src/main.rs +++ b/services/gam/src/main.rs @@ -9,16 +9,13 @@ mod canvas; use canvas::*; use blitstr_ref as blitstr; -use blitstr::{Cursor, GlyphStyle}; -use com::*; +use blitstr::GlyphStyle; use graphics_server::*; -use log::{error, info}; -use xous::String; +use log::info; use core::convert::TryFrom; -use heapless::binary_heap::{BinaryHeap, Max}; use heapless::FnvIndexMap; use heapless::consts::*; @@ -138,13 +135,18 @@ fn xmain() -> ! { // the status bar is a trusted element managed by the OS, and we are chosing to domicile this in the GAM process for now xous::create_thread_simple(status_thread, chatlayout.status.gid()).expect("GAM: couldn't create status thread"); + // connect to the IME front end, and set its canvas + /* + info!("GAM: acquiring connection to IMEF..."); + let imef_conn = xous_names::request_connection_blocking(xous::names::SERVER_NAME_IME_FRONT).expect("GAM: can't connect to the IME front end"); + ime_frontend::set_canvas(imef_conn, chatlayout.input).expect("GAM: couldn't set IMEF canvas"); + */ let mut last_time: u64 = ticktimer_server::elapsed_ms(ticktimer_conn).unwrap(); info!("GAM: entering main loop"); loop { - // /* let maybe_env = xous::try_receive_message(gam_sid).unwrap(); match maybe_env { - Some(envelope) => { // */ + Some(envelope) => { // let envelope = xous::receive_message(gam_sid).unwrap(); if debug1 {info!("GAM: Message: {:?}", envelope); } if let Ok(opcode) = Opcode::try_from(&envelope.body) { @@ -222,9 +224,6 @@ fn xmain() -> ! { // silently fail if a bogus Gid is given??? } }, - TextOp::ComputeBounds => { - - }, }; }, _ => panic!("GAM: invalid mutable borrow message"), @@ -244,16 +243,16 @@ fn xmain() -> ! { if canvas.is_drawable() { match obj.obj { GamObjectType::Line(line) => { - graphics_server::draw_line(gfx_conn, line); + graphics_server::draw_line(gfx_conn, line).expect("GAM: couldn't draw line"); }, GamObjectType::Circ(circ) => { - graphics_server::draw_circle(gfx_conn, circ); + graphics_server::draw_circle(gfx_conn, circ).expect("GAM: couldn't draw circle"); }, GamObjectType::Rect(rect) => { - graphics_server::draw_rectangle(gfx_conn, rect); + graphics_server::draw_rectangle(gfx_conn, rect).expect("GAM: couldn't draw rectangle"); }, GamObjectType::RoundRect(rr) => { - graphics_server::draw_rounded_rectangle(gfx_conn, rr); + graphics_server::draw_rounded_rectangle(gfx_conn, rr).expect("GAM: couldn't draw rounded rectangle"); } } } else { @@ -273,13 +272,13 @@ fn xmain() -> ! { }, _ => xous::yield_slice(), // envelope implements Drop(), which includes a call to syscall::return_memory(self.sender, message.buf) - } // */ - //graphics_server::flush(gfx_conn).expect("GAM: couldn't flush buffer to screen"); - ///* + } + if let Ok(elapsed_time) = ticktimer_server::elapsed_ms(ticktimer_conn) { if elapsed_time - last_time > 33 { // rate limit updates to 30fps + last_time = elapsed_time; graphics_server::flush(gfx_conn).expect("GAM: couldn't flush buffer to screen"); } - }//*/ + } } } diff --git a/services/gam/src/status.rs b/services/gam/src/status.rs index 44c3359a8..98f9692f0 100644 --- a/services/gam/src/status.rs +++ b/services/gam/src/status.rs @@ -1,5 +1,3 @@ -use crate::api::*; - use log::{error, info}; use com::api::BattStats; use graphics_server::*; @@ -18,7 +16,6 @@ pub fn status_thread(canvas_gid: [u32; 4]) { let ticktimer_conn = xous::connect(xous::SID::from_bytes(b"ticktimer-server").unwrap()).unwrap(); let com_conn = xous_names::request_connection_blocking(xous::names::SERVER_NAME_COM).expect("GAM|status: can't connect to COM"); - let gfx_conn = xous_names::request_connection_blocking(xous::names::SERVER_NAME_GFX).expect("GAM|status: can't connect to COM"); let gam_conn = xous_names::request_connection_blocking(xous::names::SERVER_NAME_GAM).expect("GAM|status: can't connect to GAM"); if debug1{info!("GAM|status: getting screen size");} @@ -46,7 +43,7 @@ pub fn status_thread(canvas_gid: [u32; 4]) { battstats_tv.draw_border = false; battstats_tv.margin = Point::new(0, 0); - let mut stats: BattStats = BattStats::default(); + let mut stats: BattStats; let mut last_time: u64 = ticktimer_server::elapsed_ms(ticktimer_conn).unwrap(); let mut stats_phase: usize = 0; let mut last_seconds: usize = ((last_time / 1000) % 60) as usize; @@ -59,6 +56,9 @@ pub fn status_thread(canvas_gid: [u32; 4]) { )).expect("GAM|status: Can't draw border line"); com::request_battstat_events(xous::names::SERVER_NAME_STATUS, com_conn).expect("GAM|status: couldn't request events from COM"); + // prime the loop + com::get_batt_stats_nb(com_conn).expect("Can't get battery stats from COM"); + last_seconds = last_seconds - 1; // this will force the uptime to redraw info!("GAM|status: starting main loop"); loop { let maybe_env = xous::try_receive_message(status_sid).unwrap(); diff --git a/services/graphics-server/src/api/shapes.rs b/services/graphics-server/src/api/shapes.rs index 27c38de6c..bf2fd8c37 100644 --- a/services/graphics-server/src/api/shapes.rs +++ b/services/graphics-server/src/api/shapes.rs @@ -2,7 +2,7 @@ use crate::op::{HEIGHT, WIDTH}; use crate::api::{Point, DrawStyle}; use blitstr_ref as blitstr; use blitstr::{ClipRect}; -use core::{cmp::{max, min}, ops::Add}; +use core::{cmp::{max, min}}; #[derive(Debug, Clone, Copy, rkyv::Archive, rkyv::Unarchive)] pub struct Rectangle { diff --git a/services/graphics-server/src/api/text.rs b/services/graphics-server/src/api/text.rs index ad5481865..53f1f2f88 100644 --- a/services/graphics-server/src/api/text.rs +++ b/services/graphics-server/src/api/text.rs @@ -2,8 +2,6 @@ use crate::api::{Point, Rectangle, Gid}; use blitstr_ref as blitstr; use blitstr::{GlyphStyle, Cursor}; -use log::info; - /// coordinates are local to the canvas, not absolute to the screen #[derive(Debug, Copy, Clone, rkyv::Archive, rkyv::Unarchive)] pub enum TextBounds { @@ -46,12 +44,6 @@ impl From for TextOp { // roughly 168 bytes to represent the rest of the struct, and we want to fill out the 4096 byte page with text const TEXTVIEW_LEN: usize = 3072; -#[derive(Copy, Clone, rkyv::Archive, Debug, rkyv::Unarchive)] -pub struct TextViewResult { - pub bounds_computed: Option, - pub cursor: Cursor, -} - #[derive(Copy, Clone, rkyv::Archive, rkyv::Unarchive)] pub struct TextView { // this is the operation as specified for the GAM. Note this is different from the "op" when sent to graphics-server diff --git a/services/graphics-server/src/lib.rs b/services/graphics-server/src/lib.rs index e429d629d..6b4cfe022 100644 --- a/services/graphics-server/src/lib.rs +++ b/services/graphics-server/src/lib.rs @@ -120,7 +120,7 @@ pub fn draw_textview(cid: CID, tv: &mut TextView) -> Result<(), xous::Error> { use rkyv::Write; use rkyv::Unarchive; - let mut rkyv_tv = api::Opcode::DrawTextView(*tv); + let rkyv_tv = api::Opcode::DrawTextView(*tv); let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); let pos = writer.archive(&rkyv_tv).expect("couldn't archive textview"); let mut xous_buffer = writer.into_inner(); @@ -129,14 +129,13 @@ pub fn draw_textview(cid: CID, tv: &mut TextView) -> Result<(), xous::Error> { let returned = unsafe { rkyv::archived_value::(xous_buffer.as_ref(), pos)}; if let rkyv::Archived::::DrawTextView(result) = returned { - let tvr: TextView = result.unarchive(); - tv.bounds_computed = tvr.bounds_computed; - tv.cursor = tvr.cursor; + let tvr: TextView = result.unarchive(); + tv.bounds_computed = tvr.bounds_computed; + tv.cursor = tvr.cursor; + Ok(()) } else { let tvr = returned.unarchive(); - info!("draw_textview saw a return of {:?}", tvr); - panic!("draw_textview got a return value from the server that isn't expected or handled"); + info!("draw_textview saw an unhandled return type of {:?}", tvr); + Err(xous::Error::InternalError) } - - Ok(()) } diff --git a/services/graphics-server/src/main.rs b/services/graphics-server/src/main.rs index 92c3a92e1..b555ec9a9 100644 --- a/services/graphics-server/src/main.rs +++ b/services/graphics-server/src/main.rs @@ -8,7 +8,6 @@ use api::Opcode; use core::pin::Pin; use rkyv::{archived_value, Unarchive, archived_value_mut}; -use core::convert::TryInto; mod backend; use backend::XousDisplay; @@ -163,13 +162,13 @@ fn xmain() -> ! { TextBounds::BoundingBox(r) => { tv.bounds_computed = Some(r); }, - TextBounds::GrowableFromBr(br, width) => { + TextBounds::GrowableFromBr(_br, _width) => { unimplemented!() }, - TextBounds::GrowableFromTl(tl, width) => { + TextBounds::GrowableFromTl(_tl, _width) => { unimplemented!() }, - TextBounds::GrowableFromBl(bl, width) => { + TextBounds::GrowableFromBl(_bl, _width) => { unimplemented!() } } diff --git a/services/graphics-server/src/op.rs b/services/graphics-server/src/op.rs index d18de9e90..ab51693ae 100644 --- a/services/graphics-server/src/op.rs +++ b/services/graphics-server/src/op.rs @@ -1,6 +1,4 @@ -use crate::api::{Circle, DrawStyle, Line, Pixel, PixelColor, Point, Rectangle, TextView, RoundedRectangle}; -use log::info; -use blitstr_ref as blitstr; +use crate::api::{Circle, DrawStyle, Line, Pixel, PixelColor, Point, Rectangle, RoundedRectangle}; /// LCD Frame buffer bounds pub const LCD_WORDS_PER_LINE: usize = 11; @@ -456,7 +454,7 @@ impl Iterator for RoundedRectangleIterator { } pub fn rounded_rectangle(fb: &mut LcdFB, rr: RoundedRectangle) { - /// left off: compute the four quadrants + // compute the four quadrants // call the rr iterator on the rectangle // then call it on one each of the four circle quadrants diff --git a/services/ime-frontend/Cargo.toml b/services/ime-frontend/Cargo.toml new file mode 100644 index 000000000..65b9022d1 --- /dev/null +++ b/services/ime-frontend/Cargo.toml @@ -0,0 +1,24 @@ +[package] +name = "ime-frontend" +version = "0.1.0" +authors = ["bunnie "] +edition = "2018" +description = "IME front end" + +[dependencies] +xous = { path = "../../xous-rs" } +heapless = "0.5.6" +log-server = { path = "../log-server" } +ticktimer-server = { path = "../ticktimer-server" } +xous-names = { path = "../xous-names" } +graphics-server = {path = "../graphics-server"} +log = "0.4" +rkyv = { version = "0.3.1", default_features = false } + + +[target.'cfg(not(any(windows,unix)))'.dependencies] +utralib = { path = "../../utralib"} + +[features] +debugprint = [] +default = [] # "debugprint" diff --git a/services/ime-frontend/src/api.rs b/services/ime-frontend/src/api.rs new file mode 100644 index 000000000..b5a9b84c2 --- /dev/null +++ b/services/ime-frontend/src/api.rs @@ -0,0 +1,37 @@ +use xous::{Message, ScalarMessage}; + +use graphics_server::Gid; + +#[allow(dead_code)] +#[derive(Debug, rkyv::Archive, rkyv::Unarchive)] +pub enum Opcode { + /// informs me where my canvas is + SetCanvas(Gid), + + /// set prediction. Must be a String of the name of a server that is loaded in the system. + SetPrediction(xous::String<256>), +} + +impl core::convert::TryFrom<& Message> for Opcode { + type Error = &'static str; + fn try_from(message: & Message) -> Result { + match message { + Message::Scalar(m) => match m.id { + 0 => Ok(Opcode::SetCanvas(Gid::new([m.arg1 as _, m.arg2 as _, m.arg3 as _, m.arg4 as _]))), + _ => Err("IMEF api: unknown Scalar ID"), + }, + _ => Err("IMEF api: unhandled message type"), + } + } +} + +impl Into for Opcode { + fn into(self) -> Message { + match self { + Opcode::SetCanvas(gid) => Message::Scalar(ScalarMessage { + id: 0, arg1: gid.gid()[0] as _, arg2: gid.gid()[1] as _, arg3: gid.gid()[2] as _, arg4: gid.gid()[3] as _ + }), + _ => panic!("IMEF api: Opcode type not handled by into()"), + } + } +} diff --git a/services/ime-frontend/src/lib.rs b/services/ime-frontend/src/lib.rs new file mode 100644 index 000000000..9e585e165 --- /dev/null +++ b/services/ime-frontend/src/lib.rs @@ -0,0 +1,9 @@ +#![cfg_attr(target_os = "none", no_std)] + +pub mod api; +use xous::{CID, send_message}; + +pub fn set_canvas(cid: CID, g: graphics_server::Gid) -> Result<(), xous::Error> { + send_message(cid, api::Opcode::SetCanvas(g).into())?; + Ok(()) +} diff --git a/services/ime-frontend/src/main.rs b/services/ime-frontend/src/main.rs new file mode 100644 index 000000000..6695b62b3 --- /dev/null +++ b/services/ime-frontend/src/main.rs @@ -0,0 +1,105 @@ +#![cfg_attr(target_os = "none", no_std)] +#![cfg_attr(target_os = "none", no_main)] + +mod api; +use api::*; + +use core::convert::TryFrom; + +use log::{error, info}; + +use graphics_server::Gid; +use heapless::Vec; +use heapless::consts::U32; + +/* +what else do we need: + - current string that is being built up + - cursor position in string, so we can do insertion/deletion + */ +fn draw_canvas(gam_conn: xous::CID, canvas: Gid, pred_conn: xous::CID, newkeys: [char; 4]) { + + // this is just reference to remind me how to decode the key array + for &k in newkeys.iter() { + if k != '\u{0000}' { + key_queue.push(k).unwrap(); + if debug1{info!("IMEF: got key '{}'", k);} + } + } +} + + +#[xous::xous_main] +fn xmain() -> ! { + let debug1 = true; + log_server::init_wait().unwrap(); + info!("IMEF: my PID is {}", xous::process::id()); + + let imef_sid = xous_names::register_name(xous::names::SERVER_NAME_IME_FRONT).expect("IMEF: can't register server"); + info!("IMEF: registered with NS -- {:?}", imef_sid); + + let kbd_conn = xous_names::request_connection_blocking(xous::names::SERVER_NAME_KBD).expect("IMEF: can't connect to KBD"); + keyboard::request_events(xous::names::SERVER_NAME_IME_FRONT, kbd_conn).expect("IMEF: couldn't request events from keyboard"); + + let gam_conn = xous_names::request_connection_blocking(xous::names::SERVER_NAME_GAM).expect("IMEF: can't connect to GAM"); + + // set a "default" prediction that is a shell-like history buffer of things previously typed + let mut prediction_conn = xous_names::request_connection_blocking(xous::names::SERVER_NAME_IME_PLUGIN_SHELL) + .expect("IMEF: can't connect to shell prediction engine"); + + // The first message should be my Gid from the GAM. + let mut canvas: Gid = Gid::new([0,0,0,0]); + info!("IMEF: waiting for my canvas Gid"); + loop { + let envelope = xous::receive_message(imef_sid).unwrap(); + if let Ok(opcode) = Opcode::try_from(&envelope.body) { + match opcode { + Opcode::SetCanvas(g) => { + canvas = g; + }, + _ => info!("IMEF: expected canvas Gid, but got {:?}", opcode) + } + } else { + info!("IMEF: expected canvas Gid, but got other message first {:?}", envelope); + } + } + + let mut key_queue: Vec = Vec::new(); + info!("IMEF: entering main loop"); + loop { + let envelope = xous::receive_message(imef_sid).unwrap(); + if let Ok(opcode) = Opcode::try_from(&envelope.body) { + match opcode { + Opcode::SetCanvas(g) => { + // there are valid reasons for this to happen, but it should be rare. + info!("IMEF: warning: canvas Gid has been reset"); + canvas = g; + }, + _ => info!("IMEF: unhandled opcode {:?}", opcode) + } + } else if let xous::Message::Borrow(m) = &msg.body { + let buf = unsafe { xous::XousBuffer::from_memory_message(m) }; + let bytes = Pin::new(buf.as_ref()); + let value = unsafe { + archived_value::(&bytes, m.id as usize) + }; + match &*value { + rkyv::Archived::::SetPrediction(rkyv_s) => { + let s: xous::String<4096> = rkyv_s.unarchive(); + prediction_conn = xous_names::request_connection(s.as_str()); + }, + _ => panic!("IME_SH: invalid response from server -- corruption occurred in MemoryMessage") + }; + } else if let Ok(opcode) = keyboard::api::Opcode::try_from(&envelope.body) { + match opcode { + keyboard::api::Opcode::KeyboardEvent(keys) => { + draw_canvas(gam_conn, canvas, prediction_conn, keys); + }, + _ => error!("IMEF: received KBD event opcode that wasn't expected"), + } + } else { + info!("IMEF: expected canvas Gid, but got {:?}", envelope); + } + } + +} diff --git a/services/ime-plugin-shell/Cargo.toml b/services/ime-plugin-shell/Cargo.toml new file mode 100644 index 000000000..7a9c6243f --- /dev/null +++ b/services/ime-plugin-shell/Cargo.toml @@ -0,0 +1,23 @@ +[package] +name = "ime-plugin-shell" +version = "0.1.0" +authors = ["bunnie "] +edition = "2018" +description = "IME Shell Plugin" + +[dependencies] +xous = { path = "../../xous-rs" } +heapless = "0.5.6" +log-server = { path = "../log-server" } +ticktimer-server = { path = "../ticktimer-server" } +xous-names = { path = "../xous-names" } +log = "0.4" +rkyv = { version = "0.3.1", default_features = false } + + +[target.'cfg(not(any(windows,unix)))'.dependencies] +utralib = { path = "../../utralib"} + +[features] +debugprint = [] +default = [] # "debugprint" diff --git a/services/ime-plugin-shell/src/api.rs b/services/ime-plugin-shell/src/api.rs new file mode 100644 index 000000000..4609814d7 --- /dev/null +++ b/services/ime-plugin-shell/src/api.rs @@ -0,0 +1,21 @@ +use xous::{Message, ScalarMessage}; + +#[derive(Debug, rkyv::Archive, rkyv::Unarchive)] +pub struct Prediction { + index: u32, + string: xous::String, +} + +#[allow(dead_code)] +#[derive(Debug, rkyv::Archive, rkyv::Unarchive)] +pub enum Opcode { + /// update with the latest input candidate. Replaces the previous input. + Input(xous::String), + + /// feed back to the IME plugin as to what was picked, so predictions can be updated + Picked(xous::String), + + /// fetch the prediction at a given index, where the index is ordered from 0..N, where 0 is the most likely prediction + /// if there is no prediction available, just return an empty string + Prediction(Prediction), +} diff --git a/services/ime-plugin-shell/src/lib.rs b/services/ime-plugin-shell/src/lib.rs new file mode 100644 index 000000000..da550a86b --- /dev/null +++ b/services/ime-plugin-shell/src/lib.rs @@ -0,0 +1,60 @@ +#![cfg_attr(target_os = "none", no_std)] + +pub mod api; +use xous::{CID, send_message, String}; + +pub fn set_input(cid: CID, s: String) -> Result<(), xous::Error> { + use rkyv::Write; + + let mut rkyv_input = api::Opcode::Input(*s); + let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); + let pos = writer.archive(&rkyv_s).expect("IMES|API: couldn't archive input string"); + let mut xous_buffer = writer.into_inner(); + + xous_buffer.lend(cid, pos as u32).expect("IMES|API: set_input operation failure"); + + Ok(()) +} + +pub fn feedback_picked(cid: CID, s: String) -> Result<(), xous::Error> { + use rkyv::Write; + + let mut rkyv_input = api::Opcode::Picked(*s); + let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); + let pos = writer.archive(&rkyv_s).expect("IMES|API: couldn't archive picked string"); + let mut xous_buffer = writer.into_inner(); + + xous_buffer.lend(cid, pos as u32).expect("IMES|API: feedback_picked operation failure"); + + Ok(()) +} + +pub fn get_prediction(cid: CID, index: u32) -> Result { + use rkyv::Write; + use rkyv::Unarchive; + + let mut mutstr = xous::String::new(); + let mut prediction = api::Prediction { + index, + string: mutstr + }; + let mut pred_op = api::Opcode::Prediction(*prediction); + + let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); + let pos = writer.archive(&pred_op).expect("IMES|API: couldn't archive prediction request"); + let mut xous_buffer = writer.into_inner(); + + xous_buffer.lend_mut(cid, pos as u32).expect("IMES|API: prediction fetch operation failure"); + + let returned = unsafe { rkyv::archived_value::(xous_buffer.as_ref(), pos)}; + if let rkyv::Archived::::Prediction(result) = returned { + let pred_r: api::Prediction = result.unarchive(); + + let retstring: xous::String = pred_r.string.clone(); + Ok(retstring) + } else { + let r = returned.unarchive(); + info!("get_prediciton saw an unhandled return of {:?}", r); + Err(xous::Error::InvalidString) + } +} \ No newline at end of file diff --git a/services/ime-plugin-shell/src/main.rs b/services/ime-plugin-shell/src/main.rs new file mode 100644 index 000000000..66a218ad0 --- /dev/null +++ b/services/ime-plugin-shell/src/main.rs @@ -0,0 +1,87 @@ +#![cfg_attr(target_os = "none", no_std)] +#![cfg_attr(target_os = "none", no_main)] + +mod api; +use api::*; + +use core::convert::TryFrom; + +use log::{error, info}; + +use heapless::spsc::Queue; +use heapless::consts::U3; + +#[xous::xous_main] +fn xmain() -> ! { + let debug1 = true; + log_server::init_wait().unwrap(); + info!("IME_SH: my PID is {}", xous::process::id()); + + let ime_sh_sid = xous_names::register_name(xous::names::SERVER_NAME_IME_PLUGIN_SHELL).expect("IME_SH: can't register server"); + info!("IME_SH: registered with NS -- {:?}", ime_sh_sid); + + let imef_conn = xous_names::request_connection_blocking(xous::names::SERVER_NAME_IME_FRONT).expect("IME_SH: can't connect to IMEF"); + + info!("IME_SH: ready to accept requests"); + + let mut history: Queue = Queue::new(); // this has 2^3 elements = 8 + let history_max = 8; + + loop { + let envelope = xous::receive_message(ime_sh_sid).unwrap(); + if let xous::Message::Borrow(m) = &msg.body { + let buf = unsafe { xous::XousBuffer::from_memory_message(m) }; + let bytes = Pin::new(buf.as_ref()); + let value = unsafe { + archived_value::(&bytes, m.id as usize) + }; + match &*value { + rkyv::Archived::::Input(rkyv_s) => { + let s: xous::String<4096> = rkyv_s.unarchive(); + if history.len() == history_max { + history.dequeue()?; + } + history.enqueue(s).expect("IME_SH: couldn't store history"); + }, + rkyv::Archived::::Picked(rkyv_s) => { + let s: xous::String<4096> = rkyv_s.unarchive(); + if debug1{info!("Received prediction feedback but ignored: {}", s);} + }, + _ => panic!("IME_SH: invalid response from server -- corruption occurred in MemoryMessage") + }; + } else if let xous::Message::MutableBorrow(m) = &msg.body { + let mut buf = unsafe { xous::XousBuffer::from_memory_message(m) }; + let value = unsafe { + archived_value_mut::(Pin::new(buf.as_mut()), m.id as usize) + }; + match &*value { + rkyv::Archived::::Prediction(pred_r) => { + let mut prediction: api::Prediction = pred_r.unarchive(); + if history.len() > 0 { + let mut index = prediction.index; + if index >= history.len() { + index = history.len() - 1; + } + let mut i = history_len(); + let mut retstr = xous::String::new(); + for s in history.iter() { + // iterator is from oldest to newest, so do some math to go from newest to oldest + if (history.len() - i) == index { + retstr = s; + break; + } + i = i + 1; + } + prediction.string = s; + } else { // there is no history + // return the empty string + prediction.string = xous::String::new(); + } + } + } + } else { + info!("IME_SH: received unknown message type {}", envelope); + panic!("IME_SH: received unknown message type"); + } + } +} diff --git a/services/kernel-test/Cargo.toml b/services/kernel-test/Cargo.toml new file mode 100644 index 000000000..743b522e3 --- /dev/null +++ b/services/kernel-test/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "kernel-test" +version = "0.1.0" +authors = ["Sean Cross "] +edition = "2018" +description = "Program to test various aspects of the kernel" + +[dependencies] +xous = { path = "../../xous-rs" } + +[target.'cfg(not(any(windows,unix)))'.dependencies] +utralib = { path = "../../utralib"} + +[features] +logging = [] # adding this allocates the UART for logging of Xous +default = ["logging"] diff --git a/services/kernel-test/README.md b/services/kernel-test/README.md new file mode 100644 index 000000000..f1d1ca67f --- /dev/null +++ b/services/kernel-test/README.md @@ -0,0 +1,5 @@ +# Kernel Test + +Run various tests inside the kernel. + +This is supposed to be the only program running. diff --git a/services/kernel-test/build.rs b/services/kernel-test/build.rs new file mode 100644 index 000000000..43c3deb4f --- /dev/null +++ b/services/kernel-test/build.rs @@ -0,0 +1,17 @@ +// NOTE: Adapted from cortex-m/build.rs +use std::env; + +fn main() { + let target = env::var("TARGET").unwrap(); + + let target_os = target.split('-').nth(2).unwrap_or("none"); + + // If we're not running on a desktop-class operating system, emit the "baremetal" + // config setting. This will enable software to do tasks such as + // managing memory. + if target_os == "none" { + println!("cargo:rustc-cfg=baremetal"); + } + + println!("cargo:rerun-if-changed=build.rs"); +} diff --git a/services/kernel-test/src/debug.rs b/services/kernel-test/src/debug.rs new file mode 100644 index 000000000..b215ab28f --- /dev/null +++ b/services/kernel-test/src/debug.rs @@ -0,0 +1,111 @@ +use core::fmt::{Error, Write}; + +use utralib::generated::*; + +#[macro_export] +macro_rules! print +{ + ($($args:tt)+) => ({ + use core::fmt::Write; + let _ = write!(crate::debug::Uart {}, $($args)+); + }); +} +#[macro_export] +macro_rules! println +{ + () => ({ + print!("\r\n") + }); + ($fmt:expr) => ({ + print!(concat!($fmt, "\r\n")) + }); + ($fmt:expr, $($args:tt)+) => ({ + print!(concat!($fmt, "\r\n"), $($args)+) + }); +} + +fn handle_irq(irq_no: usize, arg: *mut usize) { + print!("Handling IRQ {} (arg: {:08x}): ", irq_no, arg as usize); + + while let Some(c) = { crate::debug::Uart {} }.getc() { + print!("{}", c as char); + } + println!(); +} + +pub struct Uart {} + +// this is a hack to bypass an explicit initialization/allocation step for the debug structure +pub static mut DEFAULT_UART_ADDR: *mut usize = 0x0000_0000 as *mut usize; + +pub const DEFAULT: Uart = Uart {}; + +impl Uart { + fn map_uart(&self) { + /* + Note: the memory address and interrupt specified here needs to map to a unique hardware + UART resource. Modify in this function as necessary. + */ + let uart = xous::syscall::map_memory( + xous::MemoryAddress::new(utra::console::HW_CONSOLE_BASE), + None, + 4096, + xous::MemoryFlags::R | xous::MemoryFlags::W, + ) + .expect("couldn't map debug uart"); + unsafe { + DEFAULT_UART_ADDR = uart.as_mut_ptr() as _; + } + println!("Mapped UART @ {:08x}", uart.addr.get()); + // core::mem::forget(uart); + + println!("Allocating IRQ..."); + xous::claim_interrupt( + utra::console::CONSOLE_IRQ, + handle_irq, + core::ptr::null_mut::(), + ) + .expect("unable to allocate IRQ"); + self.enable_rx(); + } + + pub fn putc(&self, c: u8) { + if unsafe { DEFAULT_UART_ADDR } as usize == 0 { + self.map_uart(); + } + let mut uart_csr = CSR::new(unsafe { DEFAULT_UART_ADDR as *mut u32 }); + + // Wait until TXFULL is `0` + while uart_csr.r(utra::uart::TXFULL) != 0 {} + uart_csr.wo(utra::uart::RXTX, c as u32); + } + + pub fn enable_rx(&self) { + let mut uart_csr = CSR::new(unsafe { DEFAULT_UART_ADDR as *mut u32 }); + uart_csr.rmwf(utra::uart::EV_ENABLE_RX, 1); + } + + pub fn getc(&self) -> Option { + if unsafe { DEFAULT_UART_ADDR } as usize == 0 { + self.map_uart(); + } + let mut uart_csr = CSR::new(unsafe { DEFAULT_UART_ADDR as *mut u32 }); + match uart_csr.rf(utra::uart::EV_PENDING_RX) { + 0 => None, + ack => { + let c = Some(uart_csr.rf(utra::uart::RXTX_RXTX) as u8); + uart_csr.wfo(utra::uart::EV_PENDING_RX, ack); + c + } + } + } +} + +impl Write for Uart { + fn write_str(&mut self, s: &str) -> Result<(), Error> { + for c in s.bytes() { + self.putc(c); + } + Ok(()) + } +} diff --git a/services/kernel-test/src/log_string.rs b/services/kernel-test/src/log_string.rs new file mode 100644 index 000000000..53c07ffda --- /dev/null +++ b/services/kernel-test/src/log_string.rs @@ -0,0 +1,57 @@ +use core::fmt; +use core::slice; + +pub struct LogString<'a> { + raw_slice: &'a mut [u8], + pub s: &'a str, + pub len: u32, + msg_len: &'a mut Option, +} + +impl<'a> LogString<'a> { + pub fn from_message(message: &'a mut xous::MemoryMessage) -> LogString<'a> { + // println!("LOG: Message address is at {:08x} (whole message: {:?})", message.buf.addr.get(), message); + let raw_slice = unsafe { slice::from_raw_parts_mut(message.buf.as_ptr() as *mut u8, message.buf.len() as usize) }; + let starting_length = message.valid.map(|x| x.get()).unwrap_or(0); + + // print!("LOG: String @ {:08x}:", message.buf.as_ptr() as usize); + // for offset in 0..starting_length { + // print!(" {:02x}", raw_slice[offset]); + // } + // println!(" (length: {})", starting_length); + + LogString { + s: unsafe { + core::str::from_utf8_unchecked(slice::from_raw_parts( + message.buf.as_ptr() as *mut u8, + starting_length, + )) + }, + len: starting_length as u32, + raw_slice, + msg_len: &mut message.valid, + } + } +} + +impl<'a> fmt::Display for LogString<'a> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self.s) + } +} + +impl<'a> fmt::Write for LogString<'a> { + fn write_str(&mut self, s: &str) -> Result<(), fmt::Error> { + for c in s.bytes() { + if self.len as usize < self.raw_slice.len() { + self.raw_slice[self.len as usize] = c; + self.len += 1; + } + } + self.s = unsafe { + core::str::from_utf8_unchecked(slice::from_raw_parts(self.raw_slice.as_ptr(), self.len as usize)) + }; + *self.msg_len = Some(xous::MemorySize::new(self.len as usize).unwrap()); + Ok(()) + } +} diff --git a/services/kernel-test/src/main.rs b/services/kernel-test/src/main.rs new file mode 100644 index 000000000..b8242d049 --- /dev/null +++ b/services/kernel-test/src/main.rs @@ -0,0 +1,336 @@ +#![cfg_attr(target_os = "none", no_std)] +#![cfg_attr(target_os = "none", no_main)] + +#[cfg(baremetal)] +#[macro_use] +mod debug; + +use core::fmt::Write; +use xous::String; + +#[cfg(not(target_os = "none"))] +mod implementation { + use core::fmt::{Error, Write}; + use std::sync::mpsc::{channel, Receiver, Sender}; + + enum ControlMessage { + Text(String), + Byte(u8), + Exit, + } + + pub struct Output { + tx: Sender, + rx: Receiver, + stdout: std::io::Stdout, + } + + pub fn init() -> Output { + let (tx, rx) = channel(); + + Output { + tx, + rx, + stdout: std::io::stdout(), + } + } + + impl Output { + pub fn run(&mut self) { + use std::io::Write; + loop { + match self.rx.recv_timeout(std::time::Duration::from_millis(50)) { + Ok(msg) => match msg { + ControlMessage::Exit => break, + ControlMessage::Text(s) => print!("{}", s), + ControlMessage::Byte(s) => { + let mut handle = self.stdout.lock(); + handle.write_all(&[s]).unwrap(); + } + }, + Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {} + Err(e) => panic!("Error: {}", e), + } + } + } + + pub fn get_writer(&self) -> OutputWriter { + OutputWriter { + tx: self.tx.clone(), + } + } + } + + impl Drop for Output { + fn drop(&mut self) { + self.tx.send(ControlMessage::Exit).unwrap(); + } + } + + impl Write for Output { + fn write_str(&mut self, s: &str) -> Result<(), Error> { + // It would be nice if this worked with &str + self.tx.send(ControlMessage::Text(s.to_owned())).unwrap(); + Ok(()) + } + } + + pub struct OutputWriter { + tx: Sender, + } + + impl OutputWriter { + pub fn putc(&self, c: u8) { + self.tx.send(ControlMessage::Byte(c)).unwrap(); + } + } + + impl Write for OutputWriter { + fn write_str(&mut self, s: &str) -> Result<(), Error> { + // It would be nice if this worked with &str + self.tx.send(ControlMessage::Text(s.to_owned())).unwrap(); + Ok(()) + } + } +} + +#[cfg(target_os = "none")] +mod implementation { + use core::fmt::{Error, Write}; + use utralib::generated::*; + + pub struct Output {} + + pub fn init() -> Output { + if cfg!(feature = "logging") { + let uart = xous::syscall::map_memory( + xous::MemoryAddress::new(utra::console::HW_CONSOLE_BASE), + None, + 4096, + xous::MemoryFlags::R | xous::MemoryFlags::W, + ) + .expect("couldn't map serial port"); + unsafe { crate::debug::DEFAULT_UART_ADDR = uart.as_mut_ptr() as _ }; + println!("Mapped UART @ {:08x}", uart.addr.get()); + + println!("Process: map success!"); + crate::debug::DEFAULT.enable_rx(); + + println!("Allocating IRQ..."); + xous::syscall::claim_interrupt( + utra::console::CONSOLE_IRQ, + handle_irq, + core::ptr::null_mut::(), + ) + .expect("couldn't claim interrupt"); + println!("Claimed IRQ {}", utra::console::CONSOLE_IRQ); + } + Output {} + } + + impl Output { + pub fn get_writer(&self) -> OutputWriter { + OutputWriter {} + } + + pub fn run(&mut self) { + loop { + xous::wait_event(); + } + } + } + + fn handle_irq(irq_no: usize, arg: *mut usize) { + if cfg!(feature = "logging") { + print!("Handling IRQ {} (arg: {:08x}): ", irq_no, arg as usize); + + while let Some(c) = crate::debug::DEFAULT.getc() { + print!("0x{:02x}", c); + } + println!(); + } + } + + pub struct OutputWriter {} + + impl OutputWriter { + pub fn putc(&self, c: u8) { + if cfg!(feature = "logging") { + let mut uart_csr = CSR::new(unsafe { crate::debug::DEFAULT_UART_ADDR as *mut u32 }); + + // Wait until TXFULL is `0` + while uart_csr.r(utra::uart::TXFULL) != 0 {} + uart_csr.wo(utra::uart::RXTX, c as u32); + } + } + } + + impl Write for OutputWriter { + fn write_str(&mut self, s: &str) -> Result<(), Error> { + for c in s.bytes() { + self.putc(c); + if c == '\n' as u8 { + self.putc('\r' as u8); + } + } + Ok(()) + } + } +} + +fn handle_scalar( + output: &mut implementation::OutputWriter, + sender: xous::MessageSender, + msg: &xous::ScalarMessage, + sender_pid: xous::PID, +) { + match msg.id { + 1000 => writeln!(output, "PANIC from PID {} | {}", sender_pid, sender).unwrap(), + 1100 => (), + 1101..=1132 => { + let mut output_bfr = [0u8; core::mem::size_of::() * 4]; + let output_iter = output_bfr.iter_mut(); + + // Combine the four arguments to form a single + // contiguous buffer. Note: The buffer size will change + // depending on the platfor's `usize` length. + let arg1_bytes = msg.arg1.to_le_bytes(); + let arg2_bytes = msg.arg2.to_le_bytes(); + let arg3_bytes = msg.arg3.to_le_bytes(); + let arg4_bytes = msg.arg4.to_le_bytes(); + let input_iter = arg1_bytes + .iter() + .chain(arg2_bytes.iter()) + .chain(arg3_bytes.iter()) + .chain(arg4_bytes.iter()); + for (dest, src) in output_iter.zip(input_iter) { + *dest = *src; + } + let total_chars = msg.id - 1100; + for (idx, c) in output_bfr.iter().enumerate() { + if idx >= total_chars { + break; + } + output.putc(*c); + } + } + 1200 => writeln!(output, "Terminating process").unwrap(), + _ => writeln!( + output, + "Unrecognized scalar message from {}: {:#?}", + sender, msg + ) + .unwrap(), + } +} + +fn reader_thread(mut output: implementation::OutputWriter) { + writeln!(output, "LOG: Xous Logging Server starting up...").unwrap(); + + writeln!(output, "LOG: ****************************************************************").unwrap(); + // time stamp isn't actually the time stamp of the build, unfortunately. It's the time stamp of the + // last time you managed to force a rebuild that also causes log-server to be rebuilt, not necessarily + // capturing the build time of the very most recent change! + // writeln!(output, "LOG: *** Built: {:49} ***", env!("VERGEN_BUILD_TIMESTAMP")).unwrap(); + writeln!(output, "LOG: ****************************************************************").unwrap(); + let server_addr = xous::create_server_with_address(b"xous-log-server ").unwrap(); + writeln!(output, "LOG: Server listening on address {:?}", server_addr).unwrap(); + + let mut counter: usize = 0; + loop { + if counter.trailing_zeros() >= 12 { + writeln!(output, "LOG: Counter tick: {}", counter).unwrap(); + } + counter += 1; + // writeln!(output, "LOG: Waiting for an event...").unwrap(); + let mut envelope = + xous::syscall::receive_message(server_addr).expect("couldn't get address"); + let sender = envelope.sender; + // writeln!(output, "LOG: Got message envelope: {:?}", envelope).unwrap(); + match &mut envelope.body { + xous::Message::Scalar(msg) => handle_scalar(&mut output, sender, msg, envelope.sender.pid().unwrap()), + xous::Message::BlockingScalar(msg) => { + writeln!( + output, + "LOG: BlockingScalar message from {}: {:?}", + envelope.sender, msg + ) + .unwrap(); + } + xous::Message::Move(msg) => { + String::<4000>::from_message(msg) + .map(|log_entry: String<4000>| { + writeln!( + output, + "LOG: Moved log message from {}: {}", + sender, log_entry + ) + .unwrap() + }) + .or_else(|e| { + writeln!(output, "LOG: unable to convert Move message to str: {}", e) + }) + .ok(); + } + xous::Message::Borrow(msg) => { + String::<4000>::from_message(msg) + .map(|log_entry: String<4000>| writeln!(output, "{}", log_entry).unwrap()) + .or_else(|e| { + writeln!( + output, + "LOG: unable to convert Borrow message to str: {}", + e + ) + }) + .ok(); + } + xous::Message::MutableBorrow(msg) => { + String::<4000>::from_message(msg) + .map(|mut log_entry: String<4000>| { + writeln!( + output, + "LOG: Mutable borrowed log message from {} len {}:\n\r {}\n\r", + sender, + log_entry.len(), + log_entry, + ) + .unwrap(); + writeln!(log_entry, " << HELLO FROM THE SERVER").unwrap(); + }) + .or_else(|e| { + writeln!( + output, + "LOG: unable to convert MutableBorrow message to str: {}", + e + ) + }) + .ok(); + } + } + } +} + +fn writer_thread(_ignored: usize) { + let mut counter = 0; + loop { + let conn = xous::connect(xous::SID::from_bytes(b"xous-log-server ").unwrap()).unwrap(); + let mut buffer = xous::String::<4000>::new(); + write!(buffer, "Hello, myself! Loop: {}", counter).unwrap(); + buffer.lend(conn).unwrap(); + + counter += 1; + } +} + +#[xous::xous_main] +fn test_main() -> ! { + let mut output = implementation::init(); + let writer = output.get_writer(); + println!("LOG: my PID is {}", xous::process::id()); + println!("LOG: Creating the reader thread"); + xous::create_thread_simple(reader_thread, writer).unwrap(); + xous::create_thread_simple(writer_thread, 0usize).unwrap(); + println!("LOG: Running the output"); + output.run(); + loop {} +} diff --git a/services/keyboard/src/main.rs b/services/keyboard/src/main.rs index 2effb1b85..1ce4a3b4d 100644 --- a/services/keyboard/src/main.rs +++ b/services/keyboard/src/main.rs @@ -19,6 +19,7 @@ use xous::buffer; use rkyv::{archived_value, Write}; /// Compute the dvorak key mapping of row/col to key tuples +#[allow(dead_code)] fn map_dvorak(code: RowCol) -> ScanCode { let rc = (code.r, code.c); @@ -93,6 +94,7 @@ fn map_dvorak(code: RowCol) -> ScanCode { /// Compute the dvorak key mapping of row/col to key tuples +#[allow(dead_code)] fn map_qwerty(code: RowCol) -> ScanCode { let rc = (code.r, code.c); @@ -743,9 +745,10 @@ mod implementation { use heapless::Vec; use heapless::consts::*; use crate::api::*; - use crate::{map_dvorak, map_qwerty}; - use log::{error, info}; + //use crate::{map_dvorak, map_qwerty}; + //use log::{error, info}; + #[allow(dead_code)] pub struct Keyboard { map: KeyMap, rate: u32, diff --git a/services/trng/src/main.rs b/services/trng/src/main.rs index 7c8401e34..91d65bb0b 100644 --- a/services/trng/src/main.rs +++ b/services/trng/src/main.rs @@ -110,8 +110,7 @@ mod implementation { // a stub to try to avoid breaking hosted mode for as long as possible. #[cfg(not(target_os = "none"))] mod implementation { - use crate::api::*; - use log::{error, info}; + use log::info; pub struct Trng { seed: u32, @@ -131,6 +130,7 @@ mod implementation { lfsr } + #[allow(dead_code)] pub fn wait_full(&self) { } pub fn get_trng(&mut self, _count: usize) -> [u32; 2] { diff --git a/xous-rs/src/definitions.rs b/xous-rs/src/definitions.rs index d7ce1f3a4..b2b7b9b42 100644 --- a/xous-rs/src/definitions.rs +++ b/xous-rs/src/definitions.rs @@ -491,6 +491,17 @@ impl From for MemoryType { } } +impl core::fmt::Display for MemoryType { + fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + match *self { + MemoryType::Default => write!(fmt, "Default"), + MemoryType::Heap => write!(fmt, "Heap"), + MemoryType::Stack => write!(fmt, "Stack"), + MemoryType::Messages => write!(fmt, "Messages"), + } + } +} + #[repr(C)] #[derive(Debug, PartialEq)] pub enum Result { diff --git a/xous-rs/src/names.rs b/xous-rs/src/names.rs index 7dc987e82..e8873bdd4 100644 --- a/xous-rs/src/names.rs +++ b/xous-rs/src/names.rs @@ -13,6 +13,8 @@ pub const SERVER_NAME_KBD: &str = "_Matrix keyboard driver_"; pub const SERVER_NAME_TRNG: &str = "_TRNG manager_"; pub const SERVER_NAME_GAM: &str = "_Graphical Abstraction Manager_"; pub const SERVER_NAME_STATUS: &str = "_Status bar manager_"; +pub const SERVER_NAME_IME_FRONT: &str = "_IME front end_"; +pub const SERVER_NAME_IME_PLUGIN_SHELL: &str = "_IME shell plugin_"; pub const SERVER_NAME_FCCAGENT: &str = "_Agent for EMC Testing_"; pub const SERVER_NAME_BENCHMARK: &str= "_Benchmark target_"; diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 0dd4174d1..c92bf1509 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -39,12 +39,14 @@ fn try_main() -> Result<(), DynError> { let hw_pkgs = [ "gam", //"shell", + //"ime-frontend", + //"ime-plugin-shell", "graphics-server", "ticktimer-server", "log-server", "com", "xous-names", - //"keyboard", + "keyboard", "trng", //"llio", ]; @@ -71,6 +73,7 @@ fn try_main() -> Result<(), DynError> { let task = env::args().nth(1); match task.as_deref() { Some("renode-image") => renode_image(false, &hw_pkgs)?, + Some("renode-test") => renode_image(false, &["kernel-test"])?, Some("renode-image-debug") => renode_image(true, &hw_pkgs)?, Some("run") => run(false)?, Some("hw-image") => build_hw_image(false, env::args().nth(2), &hw_pkgs)?, @@ -85,7 +88,8 @@ fn try_main() -> Result<(), DynError> { fn print_help() { eprintln!( "Tasks: -renode-image builds a test image for renode +renode-image builds a functional image for renode +renode-test builds a test image for renode renode-image-debug builds a test image for renode in debug mode hw-image [soc.svd] builds an image for real hardware run runs a release build using a hosted environment @@ -188,6 +192,8 @@ fn run(debug: bool) -> Result<(), DynError> { let init = [ //"shell", "gam", + //"ime-frontend", + //"ime-plugin-shell", //"benchmark", //"benchmark-target", "log-server",