acpi

nel_os_kernel/src/acpi.rs

@@ -0,0 +1,26 @@
+use core::ptr::NonNull;
+
+use acpi::{AcpiHandler, PhysicalMapping};
+
+#[derive(Clone)]
+pub struct KernelAcpiHandler;
+
+impl AcpiHandler for KernelAcpiHandler {
+    unsafe fn map_physical_region<T>(
+        &self,
+        physical_address: usize,
+        size: usize,
+    ) -> acpi::PhysicalMapping<Self, T> {
+        unsafe {
+            PhysicalMapping::new(
+                physical_address,
+                NonNull::new(physical_address as *mut _).unwrap(),
+                size,
+                size,
+                self.clone(),
+            )
+        }
+    }
+
+    fn unmap_physical_region<T>(_region: &acpi::PhysicalMapping<Self, T>) {}
+}

nel_os_kernel/src/graphics.rs

@@ -1,4 +1,5 @@
 use ab_glyph::{Font, FontRef, ScaleFont};
+use alloc::vec::Vec;
 use lazy_static::lazy_static;
 use nel_os_common::gop::{FrameBuffer as RawFrameBuffer, PixelFormat as RawPixelFormat};
 use spin::Mutex;
@@ -22,14 +23,20 @@ pub struct FrameBuffer {
 
     pub pixel_format: PixelFormat,
 
+    pub background_color: (u8, u8, u8),
+
     pub text_cursor: (usize, usize),
+
+    pub text_buffer: Vec<Vec<char>>,
+    pub textscreen_width: usize,
+    pub textscreen_height: usize,
 }
 
 unsafe impl Send for FrameBuffer {}
 unsafe impl Sync for FrameBuffer {}
 
 impl FrameBuffer {
-    pub fn from_raw_buffer(raw_buffer: &RawFrameBuffer) -> Self {
+    pub fn from_raw_buffer(raw_buffer: &RawFrameBuffer, background_color: (u8, u8, u8)) -> Self {
         Self {
             frame_buffer: raw_buffer.frame_buffer,
             width: raw_buffer.width,
@@ -40,7 +47,11 @@ impl FrameBuffer {
                 RawPixelFormat::Rgb => PixelFormat::Rgb,
                 RawPixelFormat::Bgr => PixelFormat::Bgr,
             },
+            background_color,
             text_cursor: (0, 0),
+            text_buffer: Vec::new(),
+            textscreen_width: raw_buffer.width / 8,
+            textscreen_height: raw_buffer.height / 14,
         }
     }
 
@@ -76,39 +87,47 @@ impl FrameBuffer {
         }
     }
 
-    pub fn print_text(&mut self, text: &str) {
-        let (mut x, mut y) = self.text_cursor;
-
-        for c in text.chars() {
-            if c == '\n' {
-                x = 0;
-                y += 14;
-
-                continue;
-            }
-
-            self.draw_char(c, x, y);
-            x += 8;
-            if x + 8 > self.width {
-                x = 0;
-                y += 14;
+    pub fn clear(&self) {
+        let (r, g, b) = self.background_color;
+        for y in 0..self.height {
+            for x in 0..self.width {
+                self.draw_pixel(r, g, b, x, y);
             }
         }
-
-        self.text_cursor = (x, y);
     }
 
-    pub fn print_char(&mut self, c: char) {
-        let (x, y) = self.text_cursor;
-
-        self.draw_char(c, x, y);
-        self.text_cursor.0 += 8;
-        if self.text_cursor.0 >= self.width {
-            self.text_cursor.0 = 0;
-            self.text_cursor.1 += 14;
+    pub fn update_textscreen(&mut self) {
+        self.clear();
+        for (y, line) in self.text_buffer.iter().enumerate() {
+            let mut x = 0;
+            for &c in line {
+                self.draw_char(c, x, y * 14);
+                x += 8;
+            }
         }
     }
 
+    pub fn add_text_line(&mut self, text: &str) {
+        if self.text_buffer.len() >= self.textscreen_height {
+            self.text_buffer.remove(0);
+        }
+        self.text_buffer.push(text.chars().collect());
+    }
+
+    pub fn clear_text(&mut self) {
+        self.text_cursor = (0, 0);
+        self.text_buffer.clear();
+        self.clear();
+    }
+
+    pub fn print_text(&mut self, text: &str) {
+        let lines = text.lines();
+        for line in lines {
+            self.add_text_line(line);
+        }
+        self.update_textscreen();
+    }
+
     pub fn draw_char(&self, c: char, x: usize, y: usize) {
         let font = FontRef::try_from_slice(FONT).unwrap();
 

nel_os_kernel/src/main.rs

@@ -4,6 +4,7 @@
 
 extern crate alloc;
 
+pub mod acpi;
 pub mod constant;
 pub mod cpuid;
 pub mod graphics;
@@ -16,9 +17,11 @@ use core::arch::asm;
 use core::panic::PanicInfo;
 use core::ptr::addr_of;
 
+use ::acpi::AcpiTables;
 use x86_64::{registers::control::Cr3, structures::paging::OffsetPageTable, VirtAddr};
 
 use crate::{
+    acpi::KernelAcpiHandler,
     constant::{KERNEL_STACK_SIZE, PKG_VERSION},
     graphics::{FrameBuffer, FRAME_BUFFER},
     memory::{allocator, memory::BitmapMemoryTable, paging},
@@ -112,13 +115,8 @@ pub extern "sysv64" fn main(boot_info: &nel_os_common::BootInfo) {
 
     allocator::init_heap(&mut mapper, &mut bitmap_table).unwrap();
 
-    let frame_buffer = FrameBuffer::from_raw_buffer(&boot_info.frame_buffer);
-
-    for x in 0..frame_buffer.width {
-        for y in 0..frame_buffer.height {
-            frame_buffer.draw_pixel(64, 64, 64, x, y);
-        }
-    }
+    let frame_buffer = FrameBuffer::from_raw_buffer(&boot_info.frame_buffer, (64, 64, 64));
+    frame_buffer.clear();
 
     FRAME_BUFFER.lock().replace(frame_buffer);
 
@@ -141,11 +139,13 @@ pub extern "sysv64" fn main(boot_info: &nel_os_common::BootInfo) {
         usable_frame as f64 * 4. / 1024. / 1024.
     );
 
-    x86_64::instructions::interrupts::int3();
+    info!("RSDP: {:#x}", boot_info.rsdp);
 
-    unsafe {
-        *(0xffdeadbeaf as *mut u8) = 0x43;
-    }
+    let acpi_tables =
+        unsafe { AcpiTables::from_rsdp(KernelAcpiHandler, boot_info.rsdp as usize) }.unwrap();
+    let platform_info = acpi_tables.platform_info().unwrap();
+    let processor_info = platform_info.processor_info;
+    info!("Processor info: {:#x?}", processor_info);
 
     hlt_loop();
 }