From 31235c254765ccf63fe127f1aabab617262328f5 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Mon, 10 Apr 2023 14:42:59 +0800 Subject: [PATCH] kernel: initial lcdpanic implementation Panic to the LCD when the kernel panics. Signed-off-by: Sean Cross --- docs/memory.md | 2 + kernel/src/arch/riscv/irq.rs | 3 +- kernel/src/arch/riscv/panic.rs | 19 ++ kernel/src/arch/riscv/process.rs | 108 ++++---- .../src/platform/precursor/font6x12_1bpp.raw | Bin 0 -> 864 bytes kernel/src/platform/precursor/lcdpanic.rs | 250 ++++++++++++++++++ kernel/src/platform/precursor/mod.rs | 2 + 7 files changed, 327 insertions(+), 57 deletions(-) create mode 100644 kernel/src/platform/precursor/font6x12_1bpp.raw create mode 100644 kernel/src/platform/precursor/lcdpanic.rs diff --git a/docs/memory.md b/docs/memory.md index b64c5e810..d3b2c4e5c 100644 --- a/docs/memory.md +++ b/docs/memory.md @@ -57,6 +57,8 @@ assigned to every process simply by mapping megapage 1023 (`0xffc00000`). | 0xff801000 | Context data (registers, etc.) | 0xff802000 | Return address from syscalls (never allocated) | 0xffc00000 | Kernel arguments, allocation tables +| 0xffca0000 | Kernel LCD framebuffer page +| 0xffcb0000 | Kernel LCD CSR page | 0xffcc0000 | Kernel GDB UART CSR page | 0xffcd0000 | Kernel WFI CSR page | 0xffce0000 | Kernel TRNG CSR page diff --git a/kernel/src/arch/riscv/irq.rs b/kernel/src/arch/riscv/irq.rs index 72945ba06..3aaa47428 100644 --- a/kernel/src/arch/riscv/irq.rs +++ b/kernel/src/arch/riscv/irq.rs @@ -176,8 +176,7 @@ pub extern "C" fn trap_handler( { let pid = current_pid(); let ex = RiscvException::from_regs(sc.bits(), sepc::read(), stval::read()); - print!("KERNEL({}): RISC-V fault: {} - ", pid, ex); - panic!("Maybe ran out of kernel stack?"); + panic!("KERNEL({}): RISC-V fault: {} - maybe ran out of kernel stack?", pid, ex); } let pid = current_pid(); diff --git a/kernel/src/arch/riscv/panic.rs b/kernel/src/arch/riscv/panic.rs index 967667fd0..00d9ccb2a 100644 --- a/kernel/src/arch/riscv/panic.rs +++ b/kernel/src/arch/riscv/panic.rs @@ -5,6 +5,25 @@ use core::panic::PanicInfo; #[panic_handler] fn handle_panic(_arg: &PanicInfo) -> ! { println!("PANIC in PID {}: {}", crate::arch::current_pid(), _arg); + use crate::platform::precursor::lcdpanic::ErrorWriter; + use core::fmt::Write; + if let Ok(mut writer) = ErrorWriter::new() { + writeln!( + writer, + "PANIC in PID {}: {}", + crate::arch::current_pid(), + _arg + ) + .ok(); + let process = crate::arch::process::Process::current(); + writeln!(writer, "Current thread: {}", process.current_tid()).ok(); + writeln!( + writer, + "{}", + crate::arch::process::Process::current().current_thread() + ) + .ok(); + } loop { arch::idle(); } diff --git a/kernel/src/arch/riscv/process.rs b/kernel/src/arch/riscv/process.rs index 63694e322..aad6fe336 100644 --- a/kernel/src/arch/riscv/process.rs +++ b/kernel/src/arch/riscv/process.rs @@ -238,7 +238,7 @@ impl Process { &process.threads[thread] } - #[cfg(feature="gdb-stub")] + #[cfg(feature = "gdb-stub")] pub fn for_each_thread_mut(&self, mut op: F) where F: FnMut(TID, &Thread), @@ -458,60 +458,7 @@ impl Process { pub fn print_thread(_tid: TID, _thread: &Thread) { println!("Thread {}:", _tid); - println!( - "PC:{:08x} SP:{:08x} RA:{:08x}", - _thread.sepc, _thread.registers[1], _thread.registers[0] - ); - println!( - "GP:{:08x} TP:{:08x}", - _thread.registers[2], _thread.registers[3] - ); - println!( - "T0:{:08x} T1:{:08x} T2:{:08x}", - _thread.registers[4], _thread.registers[5], _thread.registers[6] - ); - println!( - "T3:{:08x} T4:{:08x} T5:{:08x} T6:{:08x}", - _thread.registers[27], - _thread.registers[28], - _thread.registers[29], - _thread.registers[30] - ); - println!( - "S0:{:08x} S1:{:08x} S2:{:08x} S3:{:08x}", - _thread.registers[7], - _thread.registers[8], - _thread.registers[17], - _thread.registers[18] - ); - println!( - "S4:{:08x} S5:{:08x} S6:{:08x} S7:{:08x}", - _thread.registers[19], - _thread.registers[20], - _thread.registers[21], - _thread.registers[22] - ); - println!( - "S8:{:08x} S9:{:08x} S10:{:08x} S11:{:08x}", - _thread.registers[23], - _thread.registers[24], - _thread.registers[25], - _thread.registers[26] - ); - println!( - "A0:{:08x} A1:{:08x} A2:{:08x} A3:{:08x}", - _thread.registers[9], - _thread.registers[10], - _thread.registers[11], - _thread.registers[12] - ); - println!( - "A4:{:08x} A5:{:08x} A6:{:08x} A7:{:08x}", - _thread.registers[13], - _thread.registers[14], - _thread.registers[15], - _thread.registers[16] - ); + print!("{}", _thread); } /// Create a brand-new process. The memory space must already be set up. @@ -596,6 +543,57 @@ impl Thread { } } +impl core::fmt::Display for Thread { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + writeln!( + f, + "PC:{:08x} SP:{:08x} RA:{:08x}", + self.sepc, self.registers[1], self.registers[0] + )?; + writeln!( + f, + "GP:{:08x} TP:{:08x}", + self.registers[2], self.registers[3] + )?; + writeln!( + f, + "T0:{:08x} T1:{:08x} T2:{:08x}", + self.registers[4], self.registers[5], self.registers[6] + )?; + writeln!( + f, + "T3:{:08x} T4:{:08x} T5:{:08x} T6:{:08x}", + self.registers[27], self.registers[28], self.registers[29], self.registers[30] + )?; + writeln!( + f, + "S0:{:08x} S1:{:08x} S2:{:08x} S3:{:08x}", + self.registers[7], self.registers[8], self.registers[17], self.registers[18] + )?; + writeln!( + f, + "S4:{:08x} S5:{:08x} S6:{:08x} S7:{:08x}", + self.registers[19], self.registers[20], self.registers[21], self.registers[22] + )?; + writeln!( + f, + "S8:{:08x} S9:{:08x} S10:{:08x} S11:{:08x}", + self.registers[23], self.registers[24], self.registers[25], self.registers[26] + )?; + writeln!( + f, + "A0:{:08x} A1:{:08x} A2:{:08x} A3:{:08x}", + self.registers[9], self.registers[10], self.registers[11], self.registers[12] + )?; + writeln!( + f, + "A4:{:08x} A5:{:08x} A6:{:08x} A7:{:08x}", + self.registers[13], self.registers[14], self.registers[15], self.registers[16] + )?; + Ok(()) + } +} + pub fn set_current_pid(pid: PID) { let pid_idx = (pid.get() - 1) as usize; unsafe { diff --git a/kernel/src/platform/precursor/font6x12_1bpp.raw b/kernel/src/platform/precursor/font6x12_1bpp.raw new file mode 100644 index 0000000000000000000000000000000000000000..3a25b9beb67c1b5d6da398ac2155f6fffaab5530 GIT binary patch literal 864 zcmZ{iL2KJE6vtnLHxv*>@j~e?MK*Sm=9FAYw?mN~m&v#0wjImLSZ~>O=>`K4($yV4 z1k*#0qjWoLUn1)Y{upc1jC_qf*(vE@ec19(fBpURcoIAS0EVxL?YbbeYKVZWzw?3X zlDB^NAfgDsLj6k!A{>_7A87IHcjbzr-aOQWP64*oEnWCIK>hok#ykQzdfvVqV}3zU zN5zCJ#{UlOF00<6X@scWAp5DBMlA#>!~4&L?$}+M##N@3XS@L-!xdwZ;1iL;|M&0yi@WT z^2W}PQq+CB=58bf%gdBsxXDpk)wic*wqIS;0MNcO;TF(}mH{^+GF~F!rlEH^XPfy_ z|7ZPC&cMrJ*H*!beV)N|R4_-bU=JsAy@DQsTsNK>+q_s(*Y?x%vOfgO?Ja}ho&6_> zzMVd-9T^s8PWiU^2s2PFq5p@yZ=M}D66AP|JJ>fd;sX1|9KYo_#uIx4x#yN_J8tXP YEB>9bl}SCBeX41YMaDAkoX2L5zk5iW6aWAK literal 0 HcmV?d00001 diff --git a/kernel/src/platform/precursor/lcdpanic.rs b/kernel/src/platform/precursor/lcdpanic.rs new file mode 100644 index 000000000..1378a003e --- /dev/null +++ b/kernel/src/platform/precursor/lcdpanic.rs @@ -0,0 +1,250 @@ +use crate::mem::MemoryManager; +use utralib::generated::*; +use xous_kernel::PID; + +const FB_WIDTH_WORDS: usize = 11; +const FB_WIDTH_PIXELS: usize = 336; +const FB_LINES: usize = 536; +const FB_SIZE: usize = FB_WIDTH_WORDS * FB_LINES; // 44 bytes by 536 lines + // this font is from the embedded graphics crate https://docs.rs/embedded-graphics/0.7.1/embedded_graphics/ +const FONT_IMAGE: &'static [u8] = include_bytes!("font6x12_1bpp.raw"); +const CHAR_HEIGHT: u32 = 12; +const CHAR_WIDTH: u32 = 6; +const FONT_IMAGE_WIDTH: u32 = 96; +const LEFT_MARGIN: i16 = 2; + +const LCD_CONTROL_VIRT: usize = 0xffcb_0000; +const LCD_FB_VIRT: usize = 0xffca_0000; + +#[derive(Clone, Copy)] +struct Point { + x: i16, + y: i16, +} + +pub struct ErrorWriter { + gfx: Gfx, + point: Point, +} + +impl ErrorWriter { + pub fn new() -> Result { + let gfx = Gfx::new()?; + let point = Point { + x: LEFT_MARGIN, + y: 15, + }; + Ok(ErrorWriter { gfx, point }) + } +} + +impl core::fmt::Write for ErrorWriter { + fn write_str(&mut self, s: &str) -> core::fmt::Result { + let mut point = self.point; + self.gfx.msg(s, &mut point); + self.point = point; + Ok(()) + } +} + +#[derive(PartialEq, Eq)] +enum Color { + Light, + Dark, +} + +struct Gfx { + csr: utralib::CSR, + fb: &'static mut [u32], +} + +impl Gfx { + pub fn new() -> Result { + // Steal the LCD from userspace + if MemoryManager::with_mut(|memory_manager| { + crate::arch::mem::map_page_inner( + memory_manager, + PID::new(1).unwrap(), + HW_MEMLCD_BASE as usize, + LCD_CONTROL_VIRT, + xous_kernel::MemoryFlags::R | xous_kernel::MemoryFlags::W, + false, + ) + }) + .is_err() + { + return Err("unable to map LCD"); + } + + // Steal the LCD from userspace + for i in (0..(FB_WIDTH_WORDS * FB_LINES * 4 + 4096)).step_by(4096) { + if MemoryManager::with_mut(|memory_manager| { + crate::arch::mem::map_page_inner( + memory_manager, + PID::new(1).unwrap(), + HW_MEMLCD_MEM as usize + i, + LCD_FB_VIRT + i, + xous_kernel::MemoryFlags::R | xous_kernel::MemoryFlags::W, + false, + ) + }) + .is_err() + { + return Err("unable to map LCD"); + } + } + let mut gfx = Gfx { + csr: CSR::new(LCD_CONTROL_VIRT as *mut u32), + fb: unsafe { core::slice::from_raw_parts_mut(LCD_FB_VIRT as *mut u32, FB_SIZE) }, + }; + + gfx.init(100_000_000); + + for (i, word) in gfx.fb.iter_mut().enumerate() { + if i % 2 == 0 { + *word = 0xAAAA_AAAA; + } else { + *word = 0x5555_5555; + } + } + Ok(gfx) + } + + pub fn init(&mut self, clk_mhz: u32) { + self.csr + .wfo(utra::memlcd::PRESCALER_PRESCALER, (clk_mhz / 2_000_000) - 1); + } + + #[allow(dead_code)] + pub fn update_all(&mut self) { + self.csr.wfo(utra::memlcd::COMMAND_UPDATEALL, 1); + } + + pub fn update_dirty(&mut self) { + self.csr.wfo(utra::memlcd::COMMAND_UPDATEDIRTY, 1); + } + + pub fn busy(&self) -> bool { + self.csr.rf(utra::memlcd::BUSY_BUSY) == 1 + } + + pub fn flush(&mut self) { + self.update_dirty(); + while self.busy() {} + // clear the dirty bits + for lines in 0..FB_LINES { + self.fb[lines * FB_WIDTH_WORDS + (FB_WIDTH_WORDS - 1)] &= 0x0000_FFFF; + } + } + + fn char_offset(&self, c: u8) -> u32 { + let fallback = b' ' as u32 - b' ' as u32; + if c < b' ' { + return fallback; + } + if c <= b'~' { + return c as u32 - b' ' as u32; + } + fallback + } + + pub fn msg(&mut self, text: &str, pos: &mut Point) { + // this routine is adapted from the embedded graphics crate https://docs.rs/embedded-graphics/0.7.1/embedded_graphics/ + let char_per_row = FONT_IMAGE_WIDTH / CHAR_WIDTH; + for current_char in text.as_bytes() { + let mut char_walk_x = 0; + let mut char_walk_y = 0; + + // See if we need to wrap. We do this at the top in order to avoid + // inserting an extra lf if the line is exactly as wide as the screen. + if *current_char != b'\n' + && *current_char != b'\r' + && pos.x + (3 * CHAR_WIDTH as i16) >= FB_WIDTH_PIXELS as i16 - LEFT_MARGIN + { + // Line wrapping + pos.x = LEFT_MARGIN as i16; + pos.y += CHAR_HEIGHT as i16; + } + + loop { + // Char _code_ offset from first char, most often a space + // E.g. first char = ' ' (32), target char = '!' (33), offset = 33 - 32 = 1 + let char_offset = self.char_offset(*current_char); + let row = char_offset / char_per_row; + + // Top left corner of character, in pixels + let char_x = (char_offset - (row * char_per_row)) * CHAR_WIDTH; + let char_y = row * CHAR_HEIGHT; + + // Bit index + // = X pixel offset for char + // + Character row offset (row 0 = 0, row 1 = (192 * 8) = 1536) + // + X offset for the pixel block that comprises this char + // + Y offset for pixel block + let bitmap_bit_index = char_x + + (FONT_IMAGE_WIDTH * char_y) + + char_walk_x + + (char_walk_y * FONT_IMAGE_WIDTH); + + let bitmap_byte = bitmap_bit_index / 8; + let bitmap_bit = 7 - (bitmap_bit_index % 8); + + let color = if FONT_IMAGE[bitmap_byte as usize] & (1 << bitmap_bit) != 0 { + Color::Light + } else { + Color::Dark + }; + + let x = pos.x + CHAR_WIDTH as i16 + char_walk_x as i16; + let y = pos.y + char_walk_y as i16; + + // draw color at x, y + if (*current_char != b'\r') && (*current_char != b'\n') { + // don't draw CRLF specials + self.draw_pixel(Point { x, y }, color); + } + + char_walk_x += 1; + + if char_walk_x >= CHAR_WIDTH { + char_walk_x = 0; + char_walk_y += 1; + + // Done with this char, move on to the next one + if char_walk_y >= CHAR_HEIGHT { + if *current_char == b'\n' { + // '\n' + pos.x = LEFT_MARGIN as i16; + pos.y += CHAR_HEIGHT as i16; + } else if *current_char == b'\r' { + // '\r' + } else { + pos.x += CHAR_WIDTH as i16; + } + + break; + } + } + } + } + self.flush(); + } + + pub fn draw_pixel(&mut self, pix: Point, color: Color) { + let mut clip_y: usize = pix.y as usize; + if clip_y >= FB_LINES { + clip_y = FB_LINES - 1; + } + let clip_x: usize = pix.x as usize; + if clip_x >= FB_WIDTH_PIXELS { + clip_y = FB_WIDTH_PIXELS - 1; + } + if color == Color::Light { + self.fb[(clip_x + clip_y * FB_WIDTH_WORDS * 32) / 32] |= 1 << (clip_x % 32) + } else { + self.fb[(clip_x + clip_y * FB_WIDTH_WORDS * 32) / 32] &= !(1 << (clip_x % 32)) + } + // set the dirty bit on the line that contains the pixel + self.fb[clip_y * FB_WIDTH_WORDS + (FB_WIDTH_WORDS - 1)] |= 0x1_0000; + } +} diff --git a/kernel/src/platform/precursor/mod.rs b/kernel/src/platform/precursor/mod.rs index 6e4a2c396..bc0e06a24 100644 --- a/kernel/src/platform/precursor/mod.rs +++ b/kernel/src/platform/precursor/mod.rs @@ -3,6 +3,8 @@ #[cfg(feature = "gdb-stub")] pub mod gdbuart; +#[cfg(all(feature = "print-panics"))] +pub mod lcdpanic; pub mod rand; #[cfg(any(feature = "debug-print", feature = "print-panics"))] pub mod uart;