update

Author: ZR233

Cargo.toml

@@ -1,3 +1,4 @@
 [workspace]
 members = ["any-uart", "hello"]
 resolver = "3"
+exclude = ["dtb"]

README.md

@@ -25,7 +25,8 @@ fn phys_to_virt(addr: usize) -> *mut u8 {
     addr as *mut u8
 }
 
-if let Some((mut tx, _rx)) = any_uart::init(NonNull::new(dtb_addr).unwrap(), phys_to_virt) {
+if let Some(mut uart) = any_uart::init(NonNull::new(dtb_addr).unwrap(), phys_to_virt) {
+    let mut tx = uart.tx.take().unwrap();
     let _ = tx.write_str_blocking("Hello, world!\n");
 }
 ```
@@ -37,5 +38,5 @@ cargo install ostool
 # test with qemu
 cargo test -p hello --test test -- --show-output
 # test with uboot
-cargo test -p hello --test test -- --show-output --uboot
+cargo test --release -p hello --test test -- --show-output --uboot
 ```

any-uart/Cargo.toml

@@ -1,15 +1,20 @@
 [package]
 name = "any-uart"
-version = "0.1.1"
+version = "0.2.0"
 edition = "2024"
 authors = ["周睿 <[email protected]>"]
 description = "Init early console from device tree, mostly for Arm"
-keywords = ["pl011", "no-std", "earlycon", "dtb", "arm"]
+keywords = ["pl011", "8250", "no-std", "earlycon", "dtb", "arm"]
 license = "MIT"
 categories = ["no-std", "embedded", "hardware-support"]
 repository = "https://github.com/rcore-os/any-uart"
 readme = "../README.md"
 
+[features]
+alloc = []
+
+
 [dependencies]
 fdt-parser = "0.4"
 embedded-hal-nb = "1.0"
+bitflags = "2.8"

any-uart/src/api.rs

@@ -1,39 +1,49 @@
-use core::sync::atomic::{Ordering, fence};
-
-use crate::{Console, Error, UartData};
+use crate::{Console, ErrorKind, IrqEvent, UartData};
 
 pub struct AuxMini {}
 
 impl Console for AuxMini {
-    fn put(uart: UartData, byte: u8) -> Result<(), Error> {
-        const TXFF: u32 = 1 << 5;
-
+    fn put(uart: UartData, byte: u8) -> Result<(), ErrorKind> {
         unsafe {
-            let state = uart.reg_u8(0x24) as *const u32;
-
-            if state.read_volatile() & TXFF != 0 {
-                return Err(Error::WouldBlock);
-            }
-            fence(Ordering::Release);
             let data = uart.reg::<u32>(0);
             data.write_volatile(byte as _);
-
             Ok(())
         }
     }
 
-    fn get(uart: UartData) -> Result<u8, Error> {
-        const RX_READY: u32 = 1 << 0;
-        let state = uart.reg_u8(0x24) as *const u32;
-
-        // Wait until there is data in the FIFO
+    fn get(uart: UartData) -> Result<u8, ErrorKind> {
         unsafe {
-            if state.read_volatile() & RX_READY == 0 {
-                return Err(Error::WouldBlock);
-            }
             let data = uart.reg::<u32>(0);
 
             Ok(data.read_volatile() as _)
         }
     }
+
+    fn set_irq_enable(_uart: UartData, _enable: bool) {
+        todo!()
+    }
+
+    fn get_irq_enable(_uart: UartData) -> bool {
+        todo!()
+    }
+
+    fn clean_irq_event(_uart: UartData, _event: IrqEvent) {
+        todo!()
+    }
+
+    fn can_put(uart: UartData) -> bool {
+        const TXFF: u32 = 1 << 5;
+        let state = uart.reg_u8(0x24) as *const u32;
+        unsafe { state.read_volatile() & TXFF == 0 }
+    }
+
+    fn can_get(uart: UartData) -> bool {
+        const RX_READY: u32 = 1 << 0;
+        let state = uart.reg_u8(0x24) as *const u32;
+        unsafe { state.read_volatile() & RX_READY != 0 }
+    }
+
+    fn get_irq_event(_uart: UartData) -> IrqEvent {
+        todo!()
+    }
 }