println works

lib/lib_serial/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "lib_serial"
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
+lazy_static = { version = "1.5.0", default-features = false, features = ["spin_no_std"] }
+spin = "0.9.8"
+x86_64 = "0.15.2"
+

lib/lib_serial/src/io.rs

@@ -0,0 +1,23 @@
+use core::arch::asm;
+
+#[inline]
+pub unsafe fn inb(port: u16) -> u8 {
+    let value: u8;
+    asm!(
+        "in al, dx",
+        out("al") value,
+        in("dx") port,
+        options(nomem, nostack, preserves_flags)
+    );
+    value
+}
+
+#[inline]
+pub unsafe fn outb(port: u16, value: u8) {
+    asm!(
+        "out dx, al",
+        in("dx") port,
+        in("al") value,
+        options(nomem, nostack, preserves_flags)
+    );
+}

lib/lib_serial/src/lib.rs

@@ -0,0 +1,157 @@
+#![no_std]
+
+use core::{fmt, sync::atomic::{AtomicUsize, Ordering}};
+use spin::Mutex;
+use lazy_static::lazy_static;
+
+mod io;
+use io::*;
+use x86_64::instructions::interrupts;
+
+static PORT: u16 = 0x3f8;
+static mut BUFFER: [u8; 256] = [0; 256];
+static BUFFER_LEN: AtomicUsize = AtomicUsize::new(0);
+
+lazy_static!{
+    static ref READER: Mutex<Option<Reader>> = Mutex::new(None);
+    static ref WRITER: Mutex<Option<Writer>> = Mutex::new(None);
+}
+
+struct Reader;
+
+struct Writer;
+
+impl fmt::Write for Writer {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        for c in s.chars() {
+            self.write_byte(c as u8);
+        }
+        Ok(())
+    }
+}
+
+impl Writer {
+    unsafe fn write_success(&self) -> bool {
+        inb(PORT + 5) & 0x20 != 0
+    }
+
+    pub fn write_byte(&self, data: u8) { unsafe {
+        while !self.write_success() {};
+        outb(PORT + 0, data);
+    }}
+}
+
+
+pub fn init() -> Result<(), &'static str> {
+    if let Err(e) = test() {
+        return Err(e);
+    }
+
+    if READER.lock().is_none() {
+        *READER.lock() = Some(Reader);
+    }
+
+    if WRITER.lock().is_none() {
+        *WRITER.lock() = Some(Writer);
+    }
+
+    Ok(())
+}
+
+pub fn test() -> Result<(), &'static str> {
+    unsafe {
+        outb(PORT + 1, 0x00);    // Disable all interrupts
+        outb(PORT + 3, 0x80);    // Enable DLAB (set baud rate divisor)
+        outb(PORT + 0, 0x03);    // Set divisor to 3 (lo byte) 38400 baud
+        outb(PORT + 1, 0x00);    //                  (hi byte)
+        outb(PORT + 3, 0x03);    // 8 bits, no parity, one stop bit
+        outb(PORT + 2, 0xC7);    // Enable FIFO, clear them, with 14-bytethreshold
+        outb(PORT + 4, 0x0B);    // IRQs enabled, RTS/DSR set
+        outb(PORT + 4, 0x1E);    // Set in loopback mode, test the serial chip
+        outb(PORT + 0, 0xAE);    // Test serial chip (send byte 0xAE and check if serial returns same byte)
+
+        if inb(PORT + 0)  != 0xAE {
+            return Err("serial test failed")
+        }
+
+        outb(PORT + 4, 0x0F);
+    }
+
+    Ok(())
+}
+
+impl Reader {
+    pub fn read_str_to_buffer(&mut self) { unsafe {
+        while !self.read_ready() {};
+
+        BUFFER_LEN.store(0, Ordering::SeqCst);
+
+        while BUFFER_LEN.load(Ordering::SeqCst) < 256 {
+            let c = self.read();
+            BUFFER[BUFFER_LEN.load(Ordering::SeqCst)] = c;
+            if c as char == '\r' {
+                break;
+            }
+            BUFFER_LEN.fetch_add(1, Ordering::SeqCst);
+        }
+
+        serial_println!("returning")
+    }}
+
+    unsafe fn read_ready(&self) -> bool {
+        inb(PORT + 5) & 1 != 0
+    }
+
+    pub fn read(&self) -> u8 { unsafe {
+        while !self.read_ready() {};
+        return inb(PORT + 0);
+    }}
+}
+
+pub fn _serial_write(args: fmt::Arguments) {
+    use core::fmt::Write;
+
+    interrupts::without_interrupts(|| {
+        if let Some(writer) = WRITER.lock().as_mut() {
+            writer.write_fmt(args).unwrap();
+        }
+    })    
+}
+
+#[macro_export]
+macro_rules! serial_println {
+    () => ($crate::serial_print!("\n"));
+    ($($arg:tt)*) => ($crate::serial_print!("{}\n", format_args!($($arg)*)));
+}
+
+#[macro_export]
+macro_rules! serial_print {
+    ($($arg:tt)*) => ($crate::_serial_write(format_args!($($arg)*)));
+}
+
+pub fn serial_read() -> &'static str {
+    serial_println!("getting value!");
+
+    interrupts::without_interrupts(|| {
+        if let Some(reader) = READER.lock().as_mut() {
+            serial_println!("stuff happnin.");
+            reader.read_str_to_buffer();
+        } else {
+            serial_println!("failed to get writer");
+        }
+    });
+
+    serial_println!("eee");
+
+    let i = BUFFER_LEN.load(Ordering::SeqCst);
+
+    return unsafe {
+        if i != 0 {
+            core::str::from_utf8(&BUFFER[..i - 1]).unwrap()
+        } else { 
+            serial_println!("empty string");
+            ""
+        }
+    }
+}
+