added driver framework

:3
Color video works!!!!!!!!!!!!!!!!!!!
2024-09-11 02:30:48 +03:00 · 2024-09-03 16:07:38 +03:00 · 2024-09-03 16:03:07 +03:00 · 2024-09-02 20:55:25 +03:00 · 2024-09-02 17:51:10 +03:00
34 changed files with 850 additions and 265 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,6 +2,16 @@
 # It is not intended for manual editing.
 version = 3

+[[package]]
+name = "acpi"
+version = "5.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e248409195304021f61b39ba2628f62a45a3abf6119669d44b3399d60eabe4c3"
+dependencies = [
+ "bit_field",
+ "log",
+]
+
 [[package]]
 name = "ahash"
 version = "0.8.11"
@@ -20,12 +30,24 @@ version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5c6cb57a04249c6480766f7f7cef5467412af1490f8d1e243141daddada3264f"

+[[package]]
+name = "anyhow"
+version = "1.0.87"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10f00e1f6e58a40e807377c75c6a7f97bf9044fab57816f2414e6f5f4499d7b8"
+
 [[package]]
 name = "autocfg"
 version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"

+[[package]]
+name = "az"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b7e4c2464d97fe331d41de9d5db0def0a96f4d823b8b32a2efd503578988973"
+
 [[package]]
 name = "bit_field"
 version = "0.10.2"
@@ -40,9 +62,15 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"

 [[package]]
 name = "bitflags"
-version = "2.5.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"

 [[package]]
 name = "cfg-if"
@@ -87,13 +115,45 @@ checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"

 [[package]]
 name = "derive_more"
-version = "0.99.17"
+version = "0.99.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321"
+checksum = "5f33878137e4dafd7fa914ad4e259e18a4e8e532b9617a2d0150262bf53abfce"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 1.0.109",
+ "syn 2.0.77",
+]
+
+[[package]]
+name = "embedded-graphics"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0649998afacf6d575d126d83e68b78c0ab0e00ca2ac7e9b3db11b4cbe8274ef0"
+dependencies = [
+ "az",
+ "byteorder",
+ "embedded-graphics-core",
+ "float-cmp",
+ "micromath",
+]
+
+[[package]]
+name = "embedded-graphics-core"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba9ecd261f991856250d2207f6d8376946cd9f412a2165d3b75bc87a0bc7a044"
+dependencies = [
+ "az",
+ "byteorder",
+]
+
+[[package]]
+name = "float-cmp"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "98de4bbd547a563b716d8dfa9aad1cb19bfab00f4fa09a6a4ed21dbcf44ce9c4"
+dependencies = [
+ "num-traits",
 ]

 [[package]]
@@ -110,31 +170,43 @@ dependencies = [
 name = "kernel"
 version = "0.1.0"
 dependencies = [
- "bitflags 2.5.0",
+ "acpi",
+ "anyhow",
+ "bitflags 2.6.0",
+ "cfg-if",
 "crossbeam",
+ "embedded-graphics",
 "hashbrown",
 "lazy_static",
+ "libm",
 "log",
 "multiboot2",
 "once",
 "pc-keyboard",
 "pic8259",
- "spin 0.9.8",
+ "ps2",
+ "spin",
 "talc",
 "uart_16550",
 "x86",
- "x86_64",
+ "x86_64 0.15.1",
 ]

 [[package]]
 name = "lazy_static"
-version = "1.4.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 dependencies = [
- "spin 0.5.2",
+ "spin",
 ]

+[[package]]
+name = "libm"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
+
 [[package]]
 name = "lock_api"
 version = "0.4.12"
@@ -147,9 +219,15 @@ dependencies = [

 [[package]]
 name = "log"
-version = "0.4.21"
+version = "0.4.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
+checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
+
+[[package]]
+name = "micromath"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3c8dda44ff03a2f238717214da50f65d5a53b45cd213a7370424ffdb6fae815"

 [[package]]
 name = "multiboot2"
@@ -157,13 +235,22 @@ version = "0.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ad7ef048d4783355163fd0c874aac3db54b919dc6a86dc29bb13f67308b114b0"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
 "derive_more",
 "log",
 "ptr_meta",
 "uefi-raw",
 ]

+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
 [[package]]
 name = "once"
 version = "0.3.4"
@@ -188,18 +275,28 @@ version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "62d9a86c292b165f757e47e7fd66855def189b2564609bc4203727b27c33db22"
 dependencies = [
- "x86_64",
+ "x86_64 0.15.1",
 ]

 [[package]]
 name = "proc-macro2"
-version = "1.0.85"
+version = "1.0.86"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22244ce15aa966053a896d1accb3a6e68469b97c7f33f284b99f0d576879fc23"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
 dependencies = [
 "unicode-ident",
 ]

+[[package]]
+name = "ps2"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfef03bb1362e6a23a211efe8c72e2eeb6888f51fb329cdfa07bb470986ea7d0"
+dependencies = [
+ "bitflags 1.3.2",
+ "x86_64 0.14.12",
+]
+
 [[package]]
 name = "ptr_meta"
 version = "0.2.0"
@@ -222,9 +319,9 @@ dependencies = [

 [[package]]
 name = "quote"
-version = "1.0.36"
+version = "1.0.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
 dependencies = [
 "proc-macro2",
 ]
@@ -250,12 +347,6 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"

-[[package]]
-name = "spin"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
-
 [[package]]
 name = "spin"
 version = "0.9.8"
@@ -298,11 +389,11 @@ dependencies = [

 [[package]]
 name = "uart_16550"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6dc00444796f6c71f47c85397a35e9c4dbf9901902ac02386940d178e2b78687"
+checksum = "4922792855b1bce30997fbaa5418597902c278a92d20dfe348e6f062c3bd861d"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.6.0",
 "rustversion",
 "x86",
 ]
@@ -313,7 +404,7 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "efa8716f52e8cab8bcedfd5052388a0f263b69fe5cc2561548dc6a530678333c"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
 "ptr_meta",
 "uguid",
 ]
@@ -353,6 +444,18 @@ dependencies = [
 "raw-cpuid",
 ]

+[[package]]
+name = "x86_64"
+version = "0.14.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96cb6fd45bfeab6a5055c5bffdb08768bd0c069f1d946debe585bbb380a7c062"
+dependencies = [
+ "bit_field",
+ "bitflags 2.6.0",
+ "rustversion",
+ "volatile",
+]
+
 [[package]]
 name = "x86_64"
 version = "0.15.1"
@@ -360,7 +463,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4bc79523af8abf92fb1a970c3e086c5a343f6bcc1a0eb890f575cbb3b45743df"
 dependencies = [
 "bit_field",
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
 "rustversion",
 "volatile",
 ]
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,3 +5,8 @@ members = [

 exclude = ["boot"]
 resolver = "2"
+
+
+[profile.release]
+strip = false
+
--- a/boot/multiboot.s
+++ b/boot/multiboot.s
@@ -1,3 +1,10 @@
+%define VIDEO_MODE 0
+
+section .data
+global __VIDEO_MODE
+__VIDEO_MODE: db VIDEO_MODE
+
+
 section .multiboot_header
 header_start:
    dd 0xe85250d6                ; magic number (multiboot 2)
@@ -8,7 +15,17 @@ header_start:

    ; insert optional multiboot tags here

-    ; required end tag
+%if VIDEO_MODE
+    dw 5 ; type
+    dw 1 ; flags
+    dd 20 ; size
+    dd 0  ; width
+    dd 0  ; height
+    dd 24  ; depth
+    ; grub 2 expects 8 byte alignment
+    dw 0 ; padding
+    dw 0 ; padding
+%endif
    dw 0    ; type
    dw 0    ; flags
    dd 8    ; size
--- a/build.sh
+++ b/build.sh
@@ -2,6 +2,9 @@ BUILD_DIR="./target"
 BIN="$BUILD_DIR/poppin.bin"
 ISO="$BUILD_DIR/poppin.iso"

+# config
+VIDEO_MODE=true;
+
 set -e

 function cmd_exists() {
@@ -77,7 +80,7 @@ function run_qemu() {
    qemu-system-x86_64 \
        -cdrom $ISO \
        -serial stdio \
-        -device VGA
+        -device VGA --enable-kvm
        # -d int        \
 }

@@ -128,7 +131,7 @@ case $1 in
        build_dev
    ;;
    run-qemu-gdb)
-        build
+        build_dev
        run_qemu_gdb
    ;;
    *)
--- a/kernel/Cargo.toml
+++ b/kernel/Cargo.toml
@@ -2,7 +2,6 @@
 name = "kernel"
 version = "0.1.0"
 edition = "2021"
-test=false

 [lib]
 name="kernel"
@@ -10,19 +9,22 @@ test=false
 crate-type=["staticlib"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

-[profile.release]
-strip = false
-
 [dependencies]
+acpi = "5.0.0"
+anyhow = { version = "1.0.87", default-features = false }
 bitflags = "2.5.0"
+cfg-if = "1.0.0"
 crossbeam = { version = "0.8.4", default-features = false, features = ["alloc"] }
+embedded-graphics = "0.8.1"
 hashbrown = "0.14.5"
 lazy_static = { version = "1.4.0", features = ["spin_no_std"] }
+libm = "0.2.8"
 log = "0.4.21"
 multiboot2 = "0.20.2"
 once = "0.3.4"
 pc-keyboard = "0.7.0"
 pic8259 = "0.11.0"
+ps2 = "0.2.0"
 spin = "0.9.8"
 talc = "4.4.1"
 uart_16550 = "0.3.0"
--- a/kernel/src/acpi/mod.rs
+++ b/kernel/src/acpi/mod.rs
@@ -0,0 +1,22 @@
+use core::{cell::RefCell, ops::DerefMut};
+
+use acpi::AcpiHandler;
+use alloc::boxed::Box;
+
+use crate::mem::{paging::ActivePageTable, Frame};
+
+#[derive(Debug, Clone)]
+struct AcpiMapper {
+    apt: RefCell<ActivePageTable>
+}
+
+impl AcpiMapper {
+    pub fn new(apt: ActivePageTable) -> Self {
+        Self {
+            apt: RefCell::new(apt)
+        }
+    }
+}
+
+
+
--- a/kernel/src/drivers/mod.rs
+++ b/kernel/src/drivers/mod.rs
@@ -0,0 +1,105 @@
+use core::fmt::Debug;
+use alloc::{boxed::Box, string::{String, ToString}, vec::Vec, vec};
+use hashbrown::HashMap;
+use spin::{Mutex, MutexGuard};
+
+use crate::utils::as_any_mut;
+
+pub mod ps2;
+
+lazy_static::lazy_static!(
+    pub static ref DRIVER_MGR: Mutex<DriverHandler> = Mutex::new(DriverHandler::new());
+);
+
+type RegisterFn = fn(
+    name: &mut String,
+    author: &mut String,
+    license: &mut String,
+) -> Box<dyn Driver>;
+
+pub trait Driver: Debug + Send{
+    fn new() -> impl Driver where Self: Sized;
+    fn register(
+        name: &mut String,
+        author: &mut String,
+        license: &mut String,
+    ) -> Box<dyn Driver> where Self: Sized {
+        *name = alloc::format!("YOUR_DRIVER_NAME");
+        *author = alloc::format!("Your Name <your@email.tld>");
+        *license = alloc::format!("GPLv3");
+
+        // Box::new(Self::new())
+        todo!()
+    }
+    fn startup(&mut self) -> anyhow::Result<()> {
+        Ok(())
+    }
+    fn shutdown(&mut self) -> anyhow::Result<()> {
+        Ok(())
+    }
+
+}
+
+
+#[derive(Debug)]
+pub struct DriverHandler {
+    drivers: HashMap<String, Box<dyn Driver>>,
+}
+
+impl DriverHandler {
+    pub fn new() -> Self {
+        Self {
+            drivers: HashMap::new(),
+        }
+    }
+    
+    #[inline]
+    pub fn get_instance<'i>() -> MutexGuard<'i, Self> {
+        DRIVER_MGR.lock()
+    }
+
+    pub fn load_drivers(&mut self) {
+        for driver_reg_fn in Self::get_all_driver_entries() {
+            let mut name = String::new();
+            let mut author = String::new();
+            let mut license = String::new();
+            let driver = (driver_reg_fn)(&mut name, &mut author, &mut license);
+            log::info!("Loaded driver '{name}' ({license})");
+            self.drivers.insert(name, driver);
+        }
+    }
+    
+    pub fn get_driver<T: Driver + 'static>(&mut self, name: &str) -> Option<&mut T> {
+        if let Some(d) = self.drivers.get_mut(&name.to_string()) {
+            unsafe {
+                // Lets hope for the best
+                Some(as_any_mut(d).downcast_mut_unchecked::<T>())
+            }
+        } else {
+            None
+        }
+    }
+
+    pub fn start_drivers(&mut self) {
+        for (name, driver) in &mut self.drivers {
+            if let Err(e) = driver.startup() {
+                log::error!("Driver '{name}' had an error on startup: {e}");
+            }
+        }
+    }
+
+    pub fn stop_drivers(&mut self) {
+        for (name, driver) in &mut self.drivers {
+            if let Err(e) = driver.shutdown() {
+                log::error!("Driver '{name}' had an error on shutdown: {e}");
+            }
+        }
+    }
+
+    #[inline]
+    fn get_all_driver_entries() -> Vec<RegisterFn> {
+        vec![
+            ps2::Ps2Driver::register,
+        ]
+    }
+}
--- a/kernel/src/drivers/ps2/mod.rs
+++ b/kernel/src/drivers/ps2/mod.rs
@@ -0,0 +1,43 @@
+use alloc::{boxed::Box, format, string::String};
+use anyhow::bail;
+
+use super::Driver;
+
+
+#[derive(Debug)]
+pub struct Ps2Driver{
+
+}
+
+impl Ps2Driver {
+    pub fn test(&self) -> String {
+        String::from("hewo")
+    }
+
+}
+
+impl Driver for Ps2Driver {
+    fn new() -> impl Driver where Self: Sized {
+        Self {
+
+        }
+    }
+    fn register(
+            name: &mut alloc::string::String,
+            author: &mut alloc::string::String,
+            license: &mut alloc::string::String,
+        ) -> Box<dyn Driver> where Self: Sized {
+        *name = format!("PS/2");
+        *author = format!("MCorange <mcorange@mcorangehq.xyz>");
+        *license = format!("GPLv3");
+        Box::new(Self::new())
+    }
+
+    fn startup(&mut self) -> anyhow::Result<()> {
+        Ok(()) 
+    }
+
+    fn shutdown(&mut self) -> anyhow::Result<()> {
+        Ok(())
+    }
+}
--- a/kernel/src/events/mod.rs
+++ b/kernel/src/events/mod.rs
@@ -37,12 +37,10 @@ impl EventManager {
    }

    pub fn dispatch(&self, ev: &Event){
-        for listener in &self.listeners {
-            if let Some(l) = listener {
-                if discriminant(ev) == discriminant(&l.typ) {
+        for listener in self.listeners.iter().flatten() {
+            if discriminant(ev) == discriminant(&listener.typ) {
                // TODO: Do something with the result
-                    let _ = (l.func)(ev);
-                }
+                let _ = (listener.func)(ev);
            }
        }
    }
--- a/kernel/src/gdt/mod.rs
+++ b/kernel/src/gdt/mod.rs
@@ -21,14 +21,12 @@ lazy_static! {
            
            #[allow(unused_unsafe)]
            let stack_start = VirtAddr::from_ptr(unsafe { addr_of!(STACK) });
-            let stack_end = stack_start + STACK_SIZE as u64;
-            stack_end
+            stack_start + STACK_SIZE as u64
        };
        tss.privilege_stack_table[0] = {
            #[allow(unused_unsafe)]
            let stack_start = VirtAddr::from_ptr(unsafe { addr_of!(PRIV_TSS_STACK) });
-            let stack_end = stack_start + STACK_SIZE as u64;
-            stack_end
+            stack_start + STACK_SIZE as u64
        };
        tss
    };
--- a/kernel/src/interrupts/handlers/mod.rs
+++ b/kernel/src/interrupts/handlers/mod.rs
@@ -1,23 +1,13 @@
 use x86_64::structures::idt::{InterruptStackFrame, PageFaultErrorCode};
-use crate::{events::EVENTMAN, interrupts::InterruptIndex};
+use crate::interrupts::InterruptIndex;

-mod ps2_keyboard;
-
-pub use ps2_keyboard::ps2_kb_int;
+pub mod ps2;
+pub mod timer;

 pub extern "x86-interrupt" fn breakpoint(sf: InterruptStackFrame){
    log::error!("EXCEPT: BREAKPOINT\n{:#?}", sf);
 }

-pub extern "x86-interrupt" fn timer_interrupt(_: InterruptStackFrame){
-    //log::debug!("INT: TIMER\n{:#?}", sf);
-    // print!(".");
-    // EVENTMAN.lock().dispatch(&crate::events::Event::TimerInterrupt(None));
-    unsafe {
-        super::PICS.lock()
-            .notify_end_of_interrupt(InterruptIndex::Timer as u8);
-    }
-}
 pub extern "x86-interrupt" fn double_fault(stack_frame: InterruptStackFrame, _: u64) -> ! {
    panic!("EXCEPT: DOUBLE FAULT \n{:#?}", stack_frame);
 }
--- a/kernel/src/interrupts/handlers/ps2_keyboard.rs
+++ b/kernel/src/interrupts/handlers/ps2_keyboard.rs
@@ -1,16 +1,13 @@
-use hashbrown::HashSet;
-use pc_keyboard::{DecodedKey, KeyState};
-use spin::Mutex;
-use x86_64::structures::idt::InterruptStackFrame;
+use x86_64::{instructions::port::Port, structures::idt::InterruptStackFrame};

 use crate::{events::EVENTMAN, interrupts::PICS};

-pub struct Ps2KbPressEvent(DecodedKey);
+const PS2_PORT: u16 = 0x60;

+// https://wiki.osdev.org/PS/2_Keyboard
 pub extern "x86-interrupt" fn ps2_kb_int(_sf: InterruptStackFrame){
-    use pc_keyboard::{layouts, DecodedKey, HandleControl, Keyboard, ScancodeSet1};
+    use pc_keyboard::{layouts, HandleControl, Keyboard, ScancodeSet1};
    use spin::Mutex;
-    use x86_64::instructions::port::Port;

    lazy_static::lazy_static! {
        static ref KEYBOARD: Mutex<Keyboard<layouts::Us104Key, ScancodeSet1>> =
@@ -20,7 +17,7 @@ pub extern "x86-interrupt" fn ps2_kb_int(_sf: InterruptStackFrame){
    }
    
    let mut keyboard = KEYBOARD.lock();
-    let mut port = Port::new(0x60);
+    let mut port = Port::new(PS2_PORT);

    let scancode: u8 = unsafe { port.read() };
    if let Ok(Some(key_event)) = keyboard.add_byte(scancode) {
@@ -28,6 +25,6 @@ pub extern "x86-interrupt" fn ps2_kb_int(_sf: InterruptStackFrame){
    }
    unsafe {
        PICS.lock()
-            .notify_end_of_interrupt(super::InterruptIndex::Keyboard as u8);
+            .notify_end_of_interrupt(super::InterruptIndex::Ps2Keyboard.get());
    }
 }
--- a/kernel/src/interrupts/handlers/timer.rs
+++ b/kernel/src/interrupts/handlers/timer.rs
@@ -0,0 +1,14 @@
+use x86_64::structures::idt::InterruptStackFrame;
+
+use crate::interrupts::{InterruptIndex, PICS};
+
+pub extern "x86-interrupt" fn timer_interrupt(_: InterruptStackFrame){
+    //log::debug!("INT: TIMER\n{:#?}", sf);
+    // print!(".");
+    // EVENTMAN.lock().dispatch(&crate::events::Event::TimerInterrupt(None));
+    unsafe {
+        PICS.lock()
+            .notify_end_of_interrupt(InterruptIndex::Timer.get());
+    }
+}
+
--- a/kernel/src/interrupts/mod.rs
+++ b/kernel/src/interrupts/mod.rs
@@ -14,10 +14,11 @@ lazy_static::lazy_static! {

        idt.breakpoint.set_handler_fn(handlers::breakpoint);
        idt.page_fault.set_handler_fn(handlers::page_fault);
-        idt[InterruptIndex::Timer as u8]
-            .set_handler_fn(handlers::timer_interrupt);
-        idt[InterruptIndex::Keyboard as u8]
-            .set_handler_fn(handlers::ps2_kb_int);
+        idt[InterruptIndex::Timer.get()]
+            .set_handler_fn(handlers::timer::timer_interrupt);
+
+        idt[InterruptIndex::Ps2Keyboard.get()]
+            .set_handler_fn(handlers::ps2::ps2_kb_int);


        unsafe {
@@ -31,11 +32,52 @@ lazy_static::lazy_static! {
 pub static PICS: spin::Mutex<ChainedPics> =
        spin::Mutex::new(unsafe { ChainedPics::new(PIC_1_OFFSET, PIC_2_OFFSET) });

+
+/// https://wiki.osdev.org/Interrupts
+/// | IRQ  | Description                                              |
+/// |------|----------------------------------------------------------|
+/// |  0   | Programmable Interrupt Timer Interrupt                   |
+/// |  1   | Keyboard Interrupt                                       |
+/// |  2   | Cascade (used internally by the two PICs. never raised)  |
+/// |  3   | COM2 (if enabled)                                        |
+/// |  4   | COM1 (if enabled)                                        |
+/// |  5   | LPT2 (if enabled)                                        |
+/// |  6   | Floppy Disk                                              |
+/// |  7   | LPT1 / Unreliable "spurious" interrupt (usually)         |
+/// |  8   | CMOS real-time clock (if enabled)                        |
+/// |  9   | Free for peripherals / legacy SCSI / NIC                 |
+/// |  10  | Free for peripherals / SCSI / NIC                        |
+/// |  11  | Free for peripherals / SCSI / NIC                        |
+/// |  12  | PS2 Mouse                                                |
+/// |  13  | FPU / Coprocessor / Inter-processor                      |
+/// |  14  | Primary ATA Hard Disk                                    |
+/// |  15  | Secondary ATA Hard Disk                                  |
+#[allow(dead_code)]
 #[derive(Debug, Clone, Copy)]
 #[repr(u8)]
 pub enum InterruptIndex {
-    Timer = PIC_1_OFFSET,
-    Keyboard, // PS/2
+    Timer = 0,
+    Ps2Keyboard,
+    Cascade,
+    Com2,
+    Com1,
+    Lpt2,
+    FloppyDisk,
+    Lpt1,
+    Cmos,
+    Ffp0,
+    Ffp1,
+    Ffp2,
+    Ps2Mouse,
+    Fpu,
+    PrimAtaHdd,
+    SecAtaHdd,
+}
+
+impl InterruptIndex {
+    pub fn get(self) -> u8 {
+        (self as u8) + PIC_1_OFFSET
+    }
 }

 pub fn init_idt() {
--- a/kernel/src/lib.rs
+++ b/kernel/src/lib.rs
@@ -5,14 +5,16 @@
 #![allow(internal_features)]
 #![feature(ptr_internals)]
 #![feature(allocator_api)]
+#![feature(downcast_unchecked)]

-use core::ptr::addr_of;
+use std::{input::Keyboard, vga::video::Color};

-use alloc::vec::Vec;
-use pc_keyboard::{DecodedKey, KeyCode};
-use x86_64::instructions::nop;
-
-use crate::{gdt::PRIV_TSS_STACK, scheduler::{executor::Executor, Task}, utils::jmp_to_usermode};
+use mem::paging::ActivePageTable;
+use multiboot2::{BootInformation, BootInformationHeader};
+use pc_keyboard::KeyCode;
+use embedded_graphics::prelude::*;
+use scheduler::{executor::Executor, Task};
+use utils::acpi_shutdown;

 extern crate alloc;

@@ -26,58 +28,61 @@ mod events;
 mod mem;
 mod scheduler;
 mod std;
+mod drivers;
+mod acpi;

-
-
-#[no_mangle]
-extern "C" fn kmain(mb2_info_addr: usize) -> ! {
-    // Init
+fn init(mb2p: *const BootInformationHeader) -> ActivePageTable {
    logger::init(log::LevelFilter::Trace).unwrap();
    gdt::init();
    interrupts::init_idt();
    utils::enable_nxe_bit();
    utils::enable_write_protect_bit();
    std::init();
+    let active_table = mem::init(mb2p);
+    {
+        let mut dm = drivers::DriverHandler::get_instance();
+        dm.load_drivers();
+        dm.start_drivers();
+    }
+    active_table
+}

-    let active_table = mem::init(mb2_info_addr);
-    
-    //unsafe {
-    //    jmp_to_usermode(active_table, usermode_code as *const () as usize, addr_of!(PRIV_TSS_STACK) as *const () as usize);
-    //}
-
-    //let mut executor = Executor::new();
-    //executor.spawn(Task::new(usermode_code()));
-    //executor.run();
-
-    //let mut a = Vec::new();
+fn shutdown() -> ! {
+    {
+        let mut dm = drivers::DriverHandler::get_instance();
+        dm.stop_drivers();
+    }
    

-    //a.push(6);
-    //a.push(9);
-    //a.push(4);
-    //a.push(2);
-    //a.push(0);
+    acpi_shutdown()
+}

-    //log::error!("{:?}", a); 
+#[no_mangle]
+extern "C" fn kmain(mb2p: *const BootInformationHeader) -> ! {
+    // let sch = Executor::new();
+    let _ = init(mb2p);


-    
-    // EVENTMAN.lock().add_listener(events::Event::Ps2KeyPress(None), |k| {
-    //    let Event::Ps2KeyPress(v) = k else {panic!()};
-    //
-    //    log::debug!("Keypress event received! ({:?})", v.unwrap());
-    //   Ok(())
-    // });
-
-    // let (level_4_page_table, _) = Cr3::read();
-    // println!("Level 4 page table at: {:?}", level_4_page_table.start_address());
-    log::info!("end of work");
-    loop {
-        if std::input::is_key_down(KeyCode::A) {
-            log::info!(":3");
+    {   
+        let mut dm = drivers::DriverHandler::get_instance();
+        let driver = dm.get_driver::<drivers::ps2::Ps2Driver>("PS/2");
+        if let Some(driver) = driver {
+            log::debug!("{:?}", driver.test());
        }
    } 
-    // utils::hcf();
+    
+    'mainloop: loop {
+        if Keyboard::is_key_down(KeyCode::A) {
+           // vc.fill_screen(Color::new(0xFF, 0, 0));
+        } else {
+            //vc.fill_screen(Color::new(0, 0xFF, 0));
+        }
+
+        if Keyboard::are_keys_down(&[KeyCode::LAlt, KeyCode::F4]) {
+            break 'mainloop;
+        }
+    }
+    shutdown()
 }


@@ -88,6 +93,3 @@ fn panic(pi: &core::panic::PanicInfo) -> ! {
 }


-async fn usermode_code() {
-    log::info!("Hello from usermode!");
-}
--- a/kernel/src/logger/mod.rs
+++ b/kernel/src/logger/mod.rs
@@ -1,12 +1,9 @@
-
+use core::fmt::Write;
 use log::{Level, LevelFilter, Metadata, Record, SetLoggerError};
-
 use crate::logger::serial::{write_com, ANSI_COLORS, COM0};
+use crate::std::vga::text::{Color, ColorCode, WRITER};

-use self::vga::{Color, ColorCode, WRITER};

-#[macro_use]
-pub mod vga;
 pub mod serial;
 #[macro_use]
 pub mod macros;
@@ -16,7 +13,6 @@ pub static LOGGER: KLogger = KLogger;
 pub struct KLogger;


-
 const C_TRACE: ColorCode = ColorCode::new(Color::Cyan, Color::Black);
 const C_DEBUG: ColorCode = ColorCode::new(Color::Blue, Color::Black);
 const C_INFO: ColorCode = ColorCode::new(Color::Green, Color::Black);
@@ -32,51 +28,77 @@ impl log::Log for KLogger {

    fn log(&self, record: &Record) {
        if self.enabled(record.metadata()) {
-            {WRITER.lock().set_color(Color::Magenta, Color::Black); }
-            print!("[");
-            write_com(&COM0, format_args!("{}[", ANSI_COLORS::MAGENTA));
-            match record.level() {
-                Level::Trace => {
-                    {WRITER.lock().set_color_code(C_TRACE); }
-                    print!("TRACE");
-                    write_com(&COM0, format_args!("{}TRACE", ANSI_COLORS::BLUE2));
+            if !crate::std::vga::video::is_video_mode_enabled() {
+                self.log_vga(record).unwrap();
            }
-                Level::Debug => {
-                    {WRITER.lock().set_color_code(C_DEBUG); }
-                    print!("DEBUG");
-                    write_com(&COM0, format_args!("{}DEBUG", ANSI_COLORS::BLUE));
-                }
-                Level::Info => {
-                    {WRITER.lock().set_color_code(C_INFO); }
-                    print!("INFO");
-                    write_com(&COM0, format_args!("{}INFO", ANSI_COLORS::GREEN));
-                }
-                Level::Warn => {
-                    {WRITER.lock().set_color_code(C_WARN); }
-                    print!("WARN");
-                    write_com(&COM0, format_args!("{}WARN", ANSI_COLORS::YELLOW));
-                }
-                Level::Error => {
-                    {WRITER.lock().set_color_code(C_ERROR); }
-                    print!("ERROR");
-                    write_com(&COM0, format_args!("{}ERROR", ANSI_COLORS::RED));
-                }
-            }
-            {WRITER.lock().set_color(Color::Magenta, Color::Black); }
-            print!("]");
-            {WRITER.lock().set_color_code(C_NORMAL); }
-
-            write_com(&COM0, format_args!("{}]", ANSI_COLORS::MAGENTA));
-            
-            println!(" {}: {}", record.module_path().unwrap_or(""), record.args());
-
-            write_com(&COM0, format_args!(" {}{}: {}\n", ANSI_COLORS::RESET, record.module_path().unwrap_or(""), record.args()));
+            self.log_serial(record)
        }
    }

    fn flush(&self) {}
 }

+impl KLogger {
+    fn log_vga(&self, record: &Record) -> core::fmt::Result {
+        let mut f = WRITER.lock();
+        f.set_color(Color::Magenta, Color::Black);
+        write!(f, "[")?;
+        match record.level() {
+            Level::Trace => {
+                f.set_color_code(C_TRACE);
+                write!(f, "TRACE")?;
+            }
+            Level::Debug => {
+                f.set_color_code(C_DEBUG);
+                write!(f, "DEBUG")?;
+            }
+            Level::Info => {
+                f.set_color_code(C_INFO);
+                write!(f, "INFO")?;
+            }
+            Level::Warn => {
+                f.set_color_code(C_WARN);
+                write!(f, "WARN")?;
+            }
+            Level::Error => {
+                f.set_color_code(C_ERROR);
+                write!(f, "ERROR")?;
+            }
+        }
+        f.set_color(Color::Magenta, Color::Black);
+        write!(f, "]")?;
+        f.set_color_code(C_NORMAL);
+
+        writeln!(f, " {}: {}", record.module_path().unwrap_or(""), record.args())?;
+        Ok(())
+    }
+    fn log_serial(&self, record: &Record) {
+        {WRITER.lock().set_color(Color::Magenta, Color::Black); }
+            write_com(&COM0, format_args!("{}[", ANSI_COLORS::MAGENTA));
+            match record.level() {
+                Level::Trace => {
+                    write_com(&COM0, format_args!("{}TRACE", ANSI_COLORS::BLUE2));
+                }
+                Level::Debug => {
+                    write_com(&COM0, format_args!("{}DEBUG", ANSI_COLORS::BLUE));
+                }
+                Level::Info => {
+                    write_com(&COM0, format_args!("{}INFO", ANSI_COLORS::GREEN));
+                }
+                Level::Warn => {
+                    write_com(&COM0, format_args!("{}WARN", ANSI_COLORS::YELLOW));
+                }
+                Level::Error => {
+                    write_com(&COM0, format_args!("{}ERROR", ANSI_COLORS::RED));
+                }
+            }
+
+            write_com(&COM0, format_args!("{}]", ANSI_COLORS::MAGENTA));            
+            write_com(&COM0, format_args!(" {}{}: {}\n", ANSI_COLORS::RESET, record.module_path().unwrap_or(""), record.args()));
+
+    }
+}
+
 pub fn init(lvl: LevelFilter) ->  Result<(), SetLoggerError> {
    log::set_logger(&LOGGER)?;
    log::set_max_level(lvl);
--- a/kernel/src/logger/vga/macros.rs
+++ b/kernel/src/logger/vga/macros.rs
@@ -1,30 +0,0 @@
-use core::fmt;
-use x86_64::instructions::interrupts;
-
-use crate::logger::vga::Writer;
-
-impl fmt::Write for Writer {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        self.write_string(s);
-        Ok(())
-    }
-}
-
-#[macro_export]
-macro_rules! print {
-    ($($arg:tt)*) => ($crate::logger::vga::macros::_print(format_args!($($arg)*)));
-}
-
-#[macro_export]
-macro_rules! println {
-    () => ($crate::print!("\n"));
-    ($($arg:tt)*) => ($crate::print!("{}\n", format_args!($($arg)*)));
-}
-
-#[doc(hidden)]
-pub fn _print(args: fmt::Arguments) {
-    use core::fmt::Write;
-    interrupts::without_interrupts(|| {
-        crate::logger::vga::WRITER.lock().write_fmt(args).unwrap();
-    });
-}
--- a/kernel/src/mem/heap/mod.rs
+++ b/kernel/src/mem/heap/mod.rs
@@ -2,7 +2,7 @@

 //use x86_64::align_up;

-pub const HEAP_START: usize = 0o_000_001_000_000_0000; // 0x40000000 - 0x40019000
+pub const HEAP_START: usize = 0x40000000; // 0x40000000 - 0x40019000
 pub const HEAP_SIZE: usize = 100 * 1024; // 100 KiB

 // A simple allocator that allocates memory linearly and ignores freed memory.
--- a/kernel/src/mem/mod.rs
+++ b/kernel/src/mem/mod.rs
@@ -20,7 +20,9 @@ static GLOBAL_ALLOCATOR: Talck<spin::Mutex<()>, ErrOnOom> = Talc::new(ErrOnOom).

 pub struct DummyAlloc;
 unsafe impl GlobalAlloc for DummyAlloc {
-    unsafe fn alloc(&self, _: Layout) -> *mut u8 { 0 as *mut u8 }
+    unsafe fn alloc(&self, _: Layout) -> *mut u8 { 
+        core::ptr::null_mut::<u8>()
+    }
    unsafe fn dealloc(&self, _ptr: *mut u8, _: Layout) {}
 }

@@ -33,7 +35,7 @@ pub struct Frame {


 impl Frame {
-    fn containing_address(address: usize) -> Frame {
+    pub fn containing_address(address: usize) -> Frame {
        Frame{ number: address / PAGE_SIZE }
    }
    fn start_address(&self) -> paging::PhysicalAddress {
@@ -122,12 +124,14 @@ pub struct MemInfo<'a>{
    pub kernel_end: usize,
    pub mb_start: usize,
    pub mb_end: usize,
+    pub vga_vide_start: usize,
+    pub vga_vide_size: usize,
 }

 impl MemInfo<'_> {
-    pub fn load(mb_ptr: usize) -> Self {
+    pub fn load(mb_ptr: *const BootInformationHeader) -> Self {
        let boot_info = unsafe {
-            multiboot2::BootInformation::load(mb_ptr as *const BootInformationHeader).unwrap()
+            multiboot2::BootInformation::load(mb_ptr).unwrap()
        };
        let mmap_tag = boot_info.memory_map_tag().unwrap();

@@ -146,22 +150,27 @@ impl MemInfo<'_> {
        let kernel_end = elf_secs.clone().filter(|s| s.is_allocated()).map(|s| s.end_address()).min().unwrap() as usize;
        let mb_start = boot_info.start_address();
        let mb_end = boot_info.end_address();
+        let vv_info = boot_info.framebuffer_tag().unwrap().unwrap();
+        let vv_start = vv_info.address();
+        let vv_size = vv_info.pitch() * vv_info.height();

        //log::debug!("Kernel: start: 0x{:x} sz: 0x{:x}", mi.kernel_start, mi.kernel_end - mi.kernel_start);
        //log::debug!("Multiboot: start: 0x{:x} sz: 0x{:x}", mi.mb_start, mi.mb_end - mi.mb_start);
        
        Self {
-            boot_info:unsafe { multiboot2::BootInformation::load(mb_ptr as *const BootInformationHeader).unwrap()},
+            boot_info: unsafe { multiboot2::BootInformation::load(mb_ptr).unwrap()},
            mem_area_iter: MemoryAreaIter::new(mmap_tag),
            kernel_start,
            kernel_end,
            mb_start,
            mb_end,
+            vga_vide_start: vv_start as usize,
+            vga_vide_size: vv_size as usize
        }
    }
 }

-pub fn init(mb_ptr: usize) -> paging::ActivePageTable {
+pub fn init(mb_ptr: *const BootInformationHeader) -> paging::ActivePageTable {
    once::assert_has_not_been_called!("mem::init must be called only once");
    let mem_info = MemInfo::load(mb_ptr);
    let mut frame_alloc = area_frame_alloc::AreaFrameAllocator::new(&mem_info);
--- a/kernel/src/mem/paging/entry.rs
+++ b/kernel/src/mem/paging/entry.rs
@@ -28,13 +28,13 @@ impl EntryFlags {

        if section.flags().contains(ElfSectionFlags::ALLOCATED) {
            // section is loaded to memory
-            flags = flags | EntryFlags::PRESENT;
+            flags |= EntryFlags::PRESENT;
        }
        if section.flags().contains(ElfSectionFlags::WRITABLE) {
-            flags = flags | EntryFlags::WRITABLE;
+            flags |= EntryFlags::WRITABLE;
        }
        if !section.flags().contains(ElfSectionFlags::EXECUTABLE) {
-            flags = flags | EntryFlags::NO_EXECUTE;
+            flags |= EntryFlags::NO_EXECUTE;
        }

        flags
--- a/kernel/src/mem/paging/mapper.rs
+++ b/kernel/src/mem/paging/mapper.rs
@@ -7,10 +7,11 @@ use super::{
    Frame, FrameAllocator,
    PAGE_SIZE, PhysicalAddress,
    VirtualAddress, Page,
-    ENTRY_COUNT, InactivePageTable
+    ENTRY_COUNT,
 };
 use core::ptr::Unique;

+#[derive(Debug, Clone)]
 pub struct Mapper {
    p4: Unique<Table<Level4>>,
 }
--- a/kernel/src/mem/paging/mod.rs
+++ b/kernel/src/mem/paging/mod.rs
@@ -1,3 +1,4 @@
+#![allow(unexpected_cfgs)]
 use core::ops::{Deref, DerefMut};
 use self::{entry::*, mapper::Mapper, temporary::TemporaryPage};
 use super::{Frame, FrameAllocator, MemInfo, PAGE_SIZE};
@@ -19,7 +20,7 @@ pub struct Page {
   number: usize,
 }

-
+#[derive(Debug, Clone)]
 pub struct ActivePageTable {
    mapper: Mapper
 }
@@ -38,7 +39,6 @@ impl DerefMut for ActivePageTable {
 }


-
 impl ActivePageTable {
    unsafe fn new() -> ActivePageTable {
        ActivePageTable {
@@ -119,8 +119,8 @@ impl InactivePageTable {

 impl Page {
    pub fn containing_address(address: VirtualAddress) -> Page {
-        assert!(address < 0x0000_8000_0000_0000 ||
-            address >= 0xffff_8000_0000_0000,
+        assert!(
+            !(0x0000_8000_0000_0000..0xffff_8000_0000_0000).contains(&address),
            "invalid address: 0x{:x}", address);
        Page { number: address / PAGE_SIZE }
    }
@@ -137,7 +137,7 @@ impl Page {
        (self.number >> 9) & 0o777
    }
    fn p1_index(&self) -> usize {
-        (self.number >> 0) & 0o777
+        self.number & 0o777
    }
    pub fn range_inclusive(start: Page, end: Page) -> PageIter {
        PageIter {
@@ -204,8 +204,15 @@ pub fn remap_the_kernel<A>(allocator: &mut A, mem_info: &MemInfo) -> ActivePageT
                mapper.identity_map(frame, flags, allocator);
            }
        }
-        let vga_buffer_frame = Frame::containing_address(0xb8000);
-        mapper.identity_map(vga_buffer_frame, EntryFlags::WRITABLE, allocator);
+        let vga_text_buffer_frame = Frame::containing_address(0xb8000);
+        mapper.identity_map(vga_text_buffer_frame, EntryFlags::WRITABLE, allocator);
+
+        let vga_video_buffer_frame_start = Frame::containing_address(mem_info.vga_vide_start);
+        let vga_video_buffer_frame_end = Frame::containing_address(mem_info.vga_vide_start + mem_info.vga_vide_size);
+        for frame in Frame::range_inclusive(vga_video_buffer_frame_start, vga_video_buffer_frame_end) {
+            //mapper.identity_map(frame, EntryFlags::WRITABLE | EntryFlags::WRITE_THROUGH, allocator);
+        }
+
        let multiboot_start = Frame::containing_address(mem_info.boot_info.start_address());
        let multiboot_end = Frame::containing_address(mem_info.boot_info.end_address() - 1);
        for frame in Frame::range_inclusive(multiboot_start, multiboot_end) {
@@ -225,8 +232,7 @@ pub fn remap_the_kernel<A>(allocator: &mut A, mem_info: &MemInfo) -> ActivePageT
    active_table
 }

-
-
+#[cfg(disabled)]
 pub fn test_paging<A>(allocator: &mut A)
    where A: FrameAllocator
 {
--- a/kernel/src/mem/paging/tables.rs
+++ b/kernel/src/mem/paging/tables.rs
@@ -44,12 +44,12 @@ impl<L> Table<L> where L: HierarchicalLevel {
        self.next_table_mut(index).unwrap()
    }

-    pub fn next_table<'a>(&'a self, index: usize) -> Option<&'a Table<L::NextLevel>> {
+    pub fn next_table(&self, index: usize) -> Option<&Table<L::NextLevel>> {
        self.next_table_address(index)
            .map(|address| unsafe { &*(address as *const _) })
    }

-    pub fn next_table_mut<'a>(&'a mut self, index: usize) -> Option<&'a mut Table<L::NextLevel>> {
+    pub fn next_table_mut(&mut self, index: usize) -> Option<&mut Table<L::NextLevel>> {
        self.next_table_address(index)
            .map(|address| unsafe { &mut *(address as *mut _) })
    }
--- a/kernel/src/mem/paging/temporary.rs
+++ b/kernel/src/mem/paging/temporary.rs
@@ -18,7 +18,7 @@ impl TemporaryPage {
        where A: FrameAllocator
    {
        TemporaryPage {
-            page: page,
+            page,
            allocator: TinyAllocator::new(allocator),
        }
    }
--- a/kernel/src/scheduler/executor.rs
+++ b/kernel/src/scheduler/executor.rs
@@ -1,3 +1,4 @@
+#![allow(dead_code)]
 use core::task::{Context, Poll, Waker};

 use super::{Task, TaskId};
@@ -53,7 +54,7 @@ impl Executor {
            };
            let waker = waker_cache
                .entry(task_id)
-                .or_insert_with(|| TaskWaker::new(task_id, task_queue.clone()));
+                .or_insert_with(|| TaskWaker::new_waker(task_id, task_queue.clone()));
            let mut context = Context::from_waker(waker);
            match task.poll(&mut context) {
                Poll::Ready(()) => {
@@ -77,7 +78,7 @@ impl TaskWaker {
    fn wake_task(&self) {
        self.task_queue.push(self.task_id).expect("task_queue full");
    }
-    fn new(task_id: TaskId, task_queue: Arc<ArrayQueue<TaskId>>) -> Waker {
+    fn new_waker(task_id: TaskId, task_queue: Arc<ArrayQueue<TaskId>>) -> Waker {
        Waker::from(Arc::new(TaskWaker {
            task_id,
            task_queue,
@@ -96,3 +97,4 @@ impl Wake for TaskWaker {
 }


+
--- a/kernel/src/scheduler/mod.rs
+++ b/kernel/src/scheduler/mod.rs
@@ -1,3 +1,4 @@
+#![allow(dead_code)]
 use core::{future::Future, pin::Pin, sync::atomic::{AtomicU64, Ordering}, task::{Context, Poll}};
 use alloc::boxed::Box;

--- a/kernel/src/std/input.rs
+++ b/kernel/src/std/input.rs
@@ -1,15 +1,17 @@
-use alloc::{boxed::Box, collections::{btree_set::BTreeSet, vec_deque::VecDeque}, sync::Arc, vec::Vec};
-use hashbrown::HashSet;
-use lazy_static::lazy_static;
-use pc_keyboard::{DecodedKey, KeyCode, KeyEvent, KeyState};
-use spin::Mutex;
-use x86_64::instructions::nop;
+use core::{arch::asm, future::Future};

-use crate::events::{Event, EVENTMAN};
+use alloc::{collections::{btree_set::BTreeSet, vec_deque::VecDeque}, vec::Vec};
+use pc_keyboard::{KeyCode, KeyEvent, KeyState};
+use spin::{Lazy, Mutex, MutexGuard};
+use x86_64::instructions::port::{Port, PortGeneric, ReadWriteAccess};
+
+use crate::{events::{Event, EVENTMAN}, scheduler::{executor::Executor, Task}};
 static mut KEYS_PRESSED: Mutex<BTreeSet<KeyCode>> = Mutex::new(BTreeSet::new());
 static mut KEY_BUF: VecDeque<KeyEvent> = VecDeque::new();
 const KEY_BUF_MAX_LEN: usize = 32;

+pub struct Keyboard;
+impl Keyboard {
    pub(super) unsafe fn init() {
        EVENTMAN.lock().add_listener(crate::events::Event::Ps2KeyEvent(None), |e| {
            let Event::Ps2KeyEvent(ke) = e else {panic!()};
@@ -21,9 +23,12 @@ pub(super) unsafe fn init() {
            }

            Ok(())
-   }) 
+        });
    }
    
+    pub fn keys_pressed<'a>() -> MutexGuard<'a, BTreeSet<KeyCode>> {
+        unsafe { KEYS_PRESSED.lock() }
+    }
    // TODO: It is possible for `KEY_BUF` to get overfilled and lose data and make keys stuck.
    // Possibly run this every now an again somehow
    unsafe fn process_events() {
@@ -31,10 +36,10 @@ unsafe fn process_events() {
            if let Some(ke) = KEY_BUF.pop_front() {
                match ke.state {
                    KeyState::Down => {
-                    KEYS_PRESSED.lock().insert(ke.code);
+                        Self::keys_pressed().insert(ke.code);
                    }
                    KeyState::Up => {
-                    KEYS_PRESSED.lock().remove(&ke.code);
+                        Self::keys_pressed().remove(&ke.code);
                    }
                    _ => ()
                }
@@ -42,9 +47,48 @@ unsafe fn process_events() {
        }
    }

+    
    pub fn is_key_down(key: KeyCode) -> bool {
        unsafe {
-        process_events();
-        return KEYS_PRESSED.lock().contains(&key);
+            Self::process_events();
+            return Self::keys_pressed().contains(&key);
        }
    }
+
+    pub fn are_keys_down(keys: &[KeyCode]) -> bool {
+        for key in keys {
+            if !Self::keys_pressed().contains(key) {
+                return false;
+            }
+        }
+        true
+    }
+
+
+}
+
+pub static MOUSE: Lazy<Mutex<Mouse>> = Lazy::new(|| Mutex::new(Mouse::new()));
+
+pub struct Mouse {
+}
+
+impl Mouse {
+    pub const fn new() -> Self {
+        Self {
+        }
+    }
+    
+    fn get()  {
+        let a = MOUSE.lock();
+    }
+
+    pub(super) fn init() {
+    }
+
+    fn on_move() {
+        
+    }
+
+
+}
+
--- a/kernel/src/std/mod.rs
+++ b/kernel/src/std/mod.rs
@@ -1,8 +1,11 @@
-pub mod input;
+use crate::scheduler::executor::Executor;

+pub mod input;
+pub mod vga;
+pub mod typemap;



 pub fn init() {
-    unsafe { input::init(); };
+    unsafe { input::Keyboard::init(); };
 }
--- a/kernel/src/std/typemap.rs
+++ b/kernel/src/std/typemap.rs
@@ -0,0 +1,37 @@
+use core::{any::{Any, TypeId}, marker::PhantomData, ops::Deref};
+
+use alloc::{borrow::ToOwned, boxed::Box, vec};
+use hashbrown::HashMap;
+
+
+#[derive(Debug)]
+pub struct TypeMap<'a> {
+    map: HashMap<TypeId, Box<dyn Any>>,
+    _phantom: PhantomData<&'a ()>
+}
+
+impl TypeMap<'_> {
+    pub fn new() -> Self {
+        Self {
+            map: HashMap::new(),
+            _phantom: PhantomData
+        }
+    }
+
+    pub fn insert<T: 'static>(&mut self, value: T) {
+        self.map.insert(TypeId::of::<T>(), Box::new(value));
+    }
+
+    pub fn get<T: 'static>(&self) -> Option<&T> {
+        self.map.get(&TypeId::of::<T>()).and_then(|boxed| boxed.downcast_ref::<T>())
+    }
+}
+
+
+impl<'a> IntoIterator for TypeMap<'a> {
+    type Item = (TypeId, Box<dyn Any>);
+    type IntoIter = hashbrown::hash_map::IntoIter<TypeId, Box<dyn Any>>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.map.into_iter() 
+    }
+}
--- a/kernel/src/std/vga/mod.rs
+++ b/kernel/src/std/vga/mod.rs
@@ -0,0 +1,2 @@
+pub mod text;
+pub mod video;
--- a/kernel/src/std/vga/text/mod.rs
+++ b/kernel/src/std/vga/text/mod.rs
@@ -1,9 +1,7 @@
 use x86::io::{outb, inb};

 use spin::Mutex;
-
-#[macro_use]
-pub mod macros;
+use x86_64::instructions::interrupts;

 lazy_static::lazy_static!{
    pub static ref WRITER: Mutex<Writer> = Mutex::new(Writer::new());
@@ -93,7 +91,7 @@ impl Writer {
        }
    }

-    pub fn write_string(&mut self, s: &str) {
+    fn write_string(&mut self, s: &str) {
        for c in s.as_bytes() {
            match c {
                // printable ASCII byte or newline
@@ -197,3 +195,12 @@ pub fn get_cursor_position() -> (u16, u16) {
    }
    (pos / (BUFFER_WIDTH as u16), pos % (BUFFER_WIDTH as u16))
 }
+
+impl core::fmt::Write for Writer {
+    fn write_str(&mut self, s: &str) -> core::fmt::Result {
+        interrupts::without_interrupts(|| {    
+            self.write_string(s);
+        });
+        Ok(())
+    }
+}
--- a/kernel/src/std/vga/video/mod.rs
+++ b/kernel/src/std/vga/video/mod.rs
@@ -0,0 +1,120 @@
+mod util;
+
+use embedded_graphics::{pixelcolor::Rgb888, prelude::{DrawTarget, OriginDimensions, PixelColor, RgbColor, Size}};
+use multiboot2::{BootInformation, BootInformationHeader, FramebufferTag, FramebufferType, TagTrait};
+pub use util::is_video_mode_enabled;
+
+
+#[derive(Clone, Copy)]
+pub struct Color {
+    r: u8,
+    g: u8,
+    b: u8,
+}
+
+impl Color {
+    pub fn new(r: u8, g: u8, b: u8) -> Self {
+        Self {r, g, b}
+    }
+}
+#[derive(Clone, Copy)]
+pub struct VideoControler{
+    component_size: u8,
+    r_ofs: u8,
+    g_ofs: u8,
+    b_ofs: u8,
+    buf_addr: u64,
+    pitch: usize,
+    size: [usize; 2],
+    bpp: u8
+}
+
+impl VideoControler {
+    pub fn new(mb2p: *const BootInformationHeader) -> Self {
+        let boot_info = unsafe { BootInformation::load(mb2p).unwrap() };
+        let fbt = boot_info.framebuffer_tag().unwrap().unwrap();
+        let FramebufferType::RGB { red, green, blue } = fbt.buffer_type().unwrap() else {
+            panic!();
+        };
+
+        assert!(red.size == green.size && green.size == blue.size);
+        log::info!("VGA VIDEO addr: {:x}", fbt.address());
+        log::info!("{fbt:#?}");
+        
+        Self {
+            component_size: red.size,
+            r_ofs: red.position,
+            g_ofs: green.position,
+            b_ofs: blue.position,
+            buf_addr: fbt.address(),
+            size: [fbt.width() as usize, fbt.height() as usize],
+            pitch: fbt.pitch() as usize,
+            bpp: fbt.bpp(),
+        }
+    }
+
+    pub fn set_px(&self, x: usize, y: usize, c: Color) {
+        assert!(x <= self.size[0] && y <= self.size[1]);
+        let ptr = self.buf_addr as *mut () as *mut u8;
+        let px = ptr.wrapping_add((self.bpp / 8) as usize * x + self.pitch * y);
+        unsafe {
+            *px.wrapping_add((self.r_ofs / 8) as usize) = c.r;
+            *px.wrapping_add((self.g_ofs / 8) as usize) = c.g;
+            *px.wrapping_add((self.b_ofs / 8) as usize) = c.b;
+        }
+    }
+
+    pub fn fill_screen(&self, c: Color) {    
+        for x in 0..self.size[0] {
+            for y in 0..self.size[1] {
+                self.set_px(x, y, c);
+            }
+        }
+    }
+
+    pub fn fill_screen_grad(&self, start: Color, end: Color) {
+        let diag = libm::sqrt((self.size[0].pow(2) + self.size[1].pow(2)) as f64);
+        for x in 0..self.size[0] {
+            for y in 0..self.size[1] {
+                let dist = libm::sqrt((x.pow(2) + y.pow(2)) as f64);
+                let fact = dist / diag;
+                let color = Color::new(
+                    start.r + (fact * (end.r - start.r) as f64) as u8,    
+                    start.g + (fact * (end.g - start.g) as f64) as u8,    
+                    start.b + (fact * (end.b - start.b) as f64) as u8,    
+                );
+                self.set_px(x, y, color);
+            }
+        }
+    }
+}
+
+impl DrawTarget for VideoControler {
+    type Color = Rgb888;
+    type Error = &'static str;
+    fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error>
+        where
+            I: IntoIterator<Item = embedded_graphics::Pixel<Self::Color>> {
+        for px in pixels {
+            self.set_px(
+                px.0.x as usize,
+                px.0.y as usize,
+                px.1.into()
+            )
+        }
+
+        Ok(())
+    }
+}
+
+impl OriginDimensions for VideoControler {
+    fn size(&self) -> embedded_graphics::prelude::Size {
+        Size::new(self.size[0] as u32, self.size[1] as u32)
+    }
+}
+
+impl From<Rgb888> for Color {
+    fn from(c: Rgb888) -> Self {
+        Color::new(c.r(), c.g(), c.b())
+    }
+}
--- a/kernel/src/std/vga/video/util.rs
+++ b/kernel/src/std/vga/video/util.rs
@@ -0,0 +1,9 @@
+extern "C" {
+    static __VIDEO_MODE: u8;
+}
+
+pub fn is_video_mode_enabled() -> bool {
+    unsafe {
+        __VIDEO_MODE == 1
+    }
+}
--- a/kernel/src/utils.rs
+++ b/kernel/src/utils.rs
@@ -1,7 +1,7 @@
-use core::arch::asm;
+use core::{any::Any, arch::asm};

 use x86::msr::{rdmsr, wrmsr, IA32_EFER};
-use x86_64::{instructions, registers::{control::{Cr0, Cr0Flags}, segmentation::{Segment, DS}}, PrivilegeLevel};
+use x86_64::{instructions::{self, port::PortWriteOnly}, registers::{control::{Cr0, Cr0Flags}, segmentation::{Segment, DS}}, PrivilegeLevel};

 use crate::mem::paging::{ActivePageTable, VirtualAddress};

@@ -54,3 +54,14 @@ pub unsafe fn jmp_to_usermode(apt: ActivePageTable, code: VirtualAddress, stack_
        code = in(reg) code_addr, sa = in(reg) sa_addr, cs = in(reg) cs_idx, ds = in(reg) ds_idx);
 }

+pub fn acpi_shutdown() -> ! {
+    let mut port = x86_64::instructions::port::Port::new(0x0604);
+    unsafe {
+        port.write(0x2000_u16);
+    }
+    loop {hcf()}
+}
+
+pub fn as_any_mut<T: Any>(i: &mut T) -> &mut dyn Any {
+    i as &mut dyn Any
+}
Author	SHA1	Message	Date
MCorange	adec09d9b0	added driver framework	2024-09-11 02:30:48 +03:00
MCorange	62bbebf693	:3	2024-09-03 16:07:38 +03:00
MCorange	4349fe9c6e	Color video works!!!!!!!!!!!!!!!!!!!	2024-09-03 16:03:07 +03:00
MCorange	08b2d22662	This will be the end of me	2024-09-02 20:55:25 +03:00
MCorange	12e9a068e9	clippy stuff	2024-09-02 17:51:10 +03:00