feat: add dyn platform and driver support

feat: add iomap api

feat: add gicv2 gicv3

- Introduced a new block driver module with implementations for block operations.
- Added virtio block driver support with MMIO transport.
- Refactored interrupt controller (GIC) driver probes to use OnProbeError for error handling.
- Enhanced dynamic driver probing to include block devices when the "block" feature is enabled.
- Improved error handling in block driver operations by mapping errors between driver and I/O layers.

feat: add axklib

Author: ZR233

Cargo.lock

@@ -17,10 +17,12 @@ members = [
     "modules/axsync",
     "modules/axtask",
     "modules/axipi",
+    "modules/axklib-impl",
 
     "api/axfeat",
     "api/arceos_api",
     "api/arceos_posix_api",
+    "api/axklib",
 
     "ulib/axstd",
     "ulib/axlibc",
@@ -51,6 +53,7 @@ axlibc = { path = "ulib/axlibc" }
 arceos_api = { path = "api/arceos_api" }
 arceos_posix_api = { path = "api/arceos_posix_api" }
 axfeat = { path = "api/axfeat" }
+axklib = {path = "api/axklib"}
 
 axalloc = { path = "modules/axalloc" }
 axconfig = { path = "modules/axconfig" }

Cargo.toml

@@ -19,7 +19,7 @@ smp = ["axhal/smp", "axruntime/smp", "axtask?/smp", "kspin/smp"]
 fp-simd = ["axhal/fp-simd"]
 
 # Interrupts
-irq = ["axhal/irq", "axruntime/irq", "axtask?/irq"]
+irq = ["axhal/irq", "axruntime/irq", "axtask?/irq", "axklib-impl?/irq"]
 ipi = ["irq", "dep:axipi", "axhal/ipi", "axruntime/ipi"]
 
 # Custom or default platforms
@@ -57,6 +57,7 @@ display = ["alloc", "paging", "axdriver/virtio-gpu", "dep:axdisplay", "axruntime
 rtc = ["axhal/rtc", "axruntime/rtc"]
 
 # Device drivers
+driver-dyn = ["axruntime/driver-dyn","axdriver?/dyn", "dep:axklib-impl"]
 bus-mmio = ["axdriver?/bus-mmio"]
 bus-pci = ["axdriver?/bus-pci"]
 driver-ramdisk = ["axdriver?/ramdisk", "axfs?/use-ramdisk"]
@@ -85,3 +86,4 @@ axsync = { workspace = true, optional = true }
 axtask = { workspace = true, optional = true }
 axipi = { workspace = true, optional = true }
 kspin = { version = "0.1", optional = true }
+axklib-impl = {path = "../../modules/axklib-impl", optional = true}

api/axfeat/Cargo.toml

@@ -39,3 +39,6 @@
 //! [ArceOS]: https://github.com/arceos-org/arceos
 
 #![no_std]
+
+#[cfg(feature = "driver-dyn")]
+extern crate axklib_impl;

api/axfeat/src/lib.rs

@@ -0,0 +1,19 @@
+[package]
+name = "axklib"
+version.workspace = true
+edition.workspace = true
+authors = ["周睿 <zrufo747@outlook.com>"]
+license.workspace = true
+homepage.workspace = true
+documentation.workspace = true
+repository.workspace = true
+keywords.workspace = true
+categories.workspace = true
+
+[features]
+irq = []
+
+[dependencies]
+trait-ffi = "0.2"
+memory_addr = "0.4"
+axerrno = "0.1"

api/axklib/Cargo.toml

@@ -0,0 +1,101 @@
+//! axklib — small kernel-helper abstractions used across the microkernel
+//!
+//! This crate exposes a tiny, no_std-compatible trait (`Klib`) that the
+//! platform/board layer must implement. The trait provides a handful of
+//! common kernel helpers such as memory mapping helpers, timing utilities,
+//! and IRQ registration. The implementation is supplied by the platform
+//! (see `modules/axklib-impl`) and consumed by drivers and other modules.
+//!
+//! The crate also provides small convenience modules (`mem`, `time`, `irq`)
+//! that re-export the trait methods with shorter names to make call sites
+//! more ergonomic.
+//!
+//! Example usage:
+//!
+//! ```ignore
+//! // map 4K of device MMIO at physical address `paddr`
+//! let vaddr = axklib::mem::iomap(paddr, 0x1000)?;
+//!
+//! // busy-wait for 100 microseconds
+//! axklib::time::busy_wait(core::time::Duration::from_micros(100));
+//!
+//! // register an IRQ handler
+//! axklib::irq::register(32, my_irq_handler);
+//! ```
+
+#![no_std]
+// #![allow(missing_docs)]
+
+use core::time::Duration;
+
+pub use axerrno::AxResult;
+/// Type alias for a simple IRQ handler function pointer.
+///
+/// Handlers use the raw ABI required by the platform and take no arguments.
+pub type IrqHandler = fn();
+
+pub use memory_addr::{PhysAddr, VirtAddr};
+
+use trait_ffi::*;
+
+/// The kernel helper trait that platform implementations must provide.
+#[def_extern_trait]
+pub trait Klib {
+    /// Map a physical memory region into the kernel's virtual address space.
+    ///
+    /// Parameters:
+    /// - `addr`: The physical start address of the region to map.
+    /// - `size`: The size in bytes of the region to map. Typically page-aligned.
+    ///
+    /// Returns:
+    /// - `Ok(VirtAddr)` with the virtual address corresponding to the mapped
+    ///   physical region on success.
+    /// - `Err(_)` with an `AxResult` error code on failure.
+    ///
+    /// Notes:
+    /// - The returned `VirtAddr` is page-aligned when the underlying mapping
+    ///   mechanism requires it.
+    /// - The actual mapping behavior is platform-specific; callers should
+    ///   treat this as an allocation-like operation and ensure the mapping
+    ///   is later cleaned up if the platform/ABI requires it.
+    fn mem_iomap(addr: PhysAddr, size: usize) -> AxResult<VirtAddr>;
+
+    /// Busy-wait the current execution context for the provided duration.
+    ///
+    /// This is intended for short delays where sleeping or timer-based
+    /// suspension is not available or not appropriate (for example, very
+    /// early boot or simple spin-waits). Implementations should aim to be
+    /// reasonably accurate for small durations but exact timing guarantees
+    /// are platform-dependent.
+    fn time_busy_wait(dur: Duration);
+
+    /// Enable or disable the edge/level for a platform IRQ.
+    ///
+    /// `irq` is a platform IRQ number. `enabled` selects whether the IRQ
+    /// should be enabled (true) or disabled (false).
+    fn irq_set_enable(irq: usize, enabled: bool);
+
+    /// Register a simple IRQ handler for the given IRQ number.
+    ///
+    /// Returns `true` if the handler was successfully registered, `false`
+    /// otherwise. The exact semantics (e.g. whether multiple handlers are
+    /// allowed) are platform-specific; callers should consult the platform
+    /// implementation.
+    fn irq_register(irq: usize, handler: IrqHandler) -> bool;
+}
+
+/// Convenience re-export for memory IO mapping.
+pub mod mem {
+    pub use super::klib::mem_iomap as iomap;
+}
+
+/// Convenience re-export for busy-wait timing.
+pub mod time {
+    pub use super::klib::time_busy_wait as busy_wait;
+}
+
+/// Convenience re-exports for IRQ operations.
+pub mod irq {
+    pub use super::klib::irq_register as register;
+    pub use super::klib::irq_set_enable as set_enable;
+}

api/axklib/src/lib.rs

@@ -1,48 +1,69 @@
 [package]
-name = "axdriver"
-version.workspace = true
-edition.workspace = true
 authors = ["Yuekai Jia <equation618@gmail.com>", "ChengXiang Qi <kuangjux@outlook.com>"]
 description = "ArceOS device drivers"
-license.workspace = true
+documentation = "https://arceos-org.github.io/arceos/axdriver/index.html"
+edition.workspace = true
 homepage.workspace = true
+license.workspace = true
+name = "axdriver"
 repository = "https://github.com/arceos-org/arceos/tree/main/modules/axdriver"
-documentation = "https://arceos-org.github.io/arceos/axdriver/index.html"
+version.workspace = true
 
 [features]
-dyn = []
+block = ["axdriver_block"]
 bus-mmio = []
 bus-pci = ["dep:axdriver_pci", "dep:axhal", "dep:axconfig"]
-net = ["axdriver_net"]
-block = ["axdriver_block"]
 display = ["axdriver_display"]
+dyn = [
+  "dep:rdrive",
+  "dep:arm-gic-driver",
+  "arm-gic-driver?/rdif",
+  "dep:rdif-intc",
+  "dep:rdif-block",
+  "dep:dma-api",
+  "dep:axklib",
+]
+net = ["axdriver_net"]
 
 # Enabled by features `virtio-*`
 virtio = ["axdriver_virtio", "dep:axalloc", "dep:axhal", "dep:axconfig"]
 
 # various types of drivers
-virtio-blk = ["block", "virtio", "axdriver_virtio/block"]
-virtio-net = ["net", "virtio", "axdriver_virtio/net"]
-virtio-gpu = ["display", "virtio", "axdriver_virtio/gpu"]
-ramdisk = ["block", "axdriver_block/ramdisk"]
 bcm2835-sdhci = ["block", "axdriver_block/bcm2835-sdhci"]
-ixgbe = ["net", "axdriver_net/ixgbe", "dep:axalloc", "dep:axhal", "dep:axdma"]
 fxmac = ["net", "axdriver_net/fxmac", "dep:axalloc", "dep:axhal", "dep:axdma"]
+ixgbe = ["net", "axdriver_net/ixgbe", "dep:axalloc", "dep:axhal", "dep:axdma"]
+ramdisk = ["block", "axdriver_block/ramdisk"]
+virtio-blk = ["block", "virtio", "axdriver_virtio/block"]
+virtio-gpu = ["display", "virtio", "axdriver_virtio/gpu"]
+virtio-net = ["net", "virtio", "axdriver_virtio/net"]
 # more devices example: e1000 = ["net", "axdriver_net/e1000"]
 
 default = ["bus-pci"]
 
 [dependencies]
-log = "=0.4.21"
+axalloc = {workspace = true, optional = true}
+axconfig = {workspace = true, optional = true}
+axdma = {workspace = true, optional = true}
+axklib = {workspace = true, optional = true}
+
+axdriver_base = {git = "https://github.com/arceos-org/axdriver_crates.git", tag = "v0.1.2"}
+axdriver_block = {git = "https://github.com/arceos-org/axdriver_crates.git", tag = "v0.1.2", optional = true}
+axdriver_display = {git = "https://github.com/arceos-org/axdriver_crates.git", tag = "v0.1.2", optional = true}
+axdriver_net = {git = "https://github.com/arceos-org/axdriver_crates.git", tag = "v0.1.2", optional = true}
+axdriver_pci = {git = "https://github.com/arceos-org/axdriver_crates.git", tag = "v0.1.2", optional = true}
+axdriver_virtio = {git = "https://github.com/arceos-org/axdriver_crates.git", tag = "v0.1.2", optional = true}
+axerrno = "0.1"
+axhal = {workspace = true, optional = true}
 cfg-if = "1.0"
 crate_interface = "0.1.4"
-axdriver_base = { git = "https://github.com/arceos-org/axdriver_crates.git", tag = "v0.1.2" }
-axdriver_block = { git = "https://github.com/arceos-org/axdriver_crates.git", tag = "v0.1.2", optional = true }
-axdriver_net = { git = "https://github.com/arceos-org/axdriver_crates.git", tag = "v0.1.2", optional = true }
-axdriver_display = { git = "https://github.com/arceos-org/axdriver_crates.git", tag = "v0.1.2", optional = true }
-axdriver_pci = { git = "https://github.com/arceos-org/axdriver_crates.git", tag = "v0.1.2", optional = true }
-axdriver_virtio = { git = "https://github.com/arceos-org/axdriver_crates.git", tag = "v0.1.2", optional = true }
-axalloc = { workspace = true, optional = true }
-axhal = { workspace = true, optional = true }
-axconfig = { workspace = true, optional = true }
-axdma = { workspace = true, optional = true }
+dma-api = {version = "0.5", features = ["alloc"], optional = true}
+lazyinit = "0.2"
+log = "=0.4.21"
+memory_addr = "0.4"
+rdif-block = {version = "0.6.2", optional = true}
+rdif-intc = {version = "0.12", optional = true}
+rdrive = {version = "0.18", optional = true}
+spin = "0.10"
+
+[target.'cfg(target_arch = "aarch64")'.dependencies]
+arm-gic-driver = {version = "0.15", optional = true}

modules/axdriver/Cargo.toml

@@ -0,0 +1,105 @@
+use axdriver_base::{BaseDriverOps, DevError, DevResult, DeviceType};
+use axdriver_block::BlockDriverOps;
+use rdif_block::BlkError;
+use rdrive::Device;
+use spin::Mutex;
+
+#[cfg(feature = "virtio-blk")]
+mod virtio;
+
+pub struct Block {
+    dev: Device<rdif_block::Block>,
+    queue: Mutex<rdif_block::CmdQueue>,
+}
+
+impl BaseDriverOps for Block {
+    fn device_type(&self) -> DeviceType {
+        DeviceType::Block
+    }
+    fn device_name(&self) -> &str {
+        self.dev.descriptor().name
+    }
+}
+
+impl BlockDriverOps for Block {
+    fn num_blocks(&self) -> u64 {
+        self.queue.lock().num_blocks() as _
+    }
+    fn block_size(&self) -> usize {
+        self.queue.lock().block_size()
+    }
+    fn flush(&mut self) -> DevResult {
+        Ok(())
+    }
+
+    fn read_block(&mut self, block_id: u64, buf: &mut [u8]) -> DevResult {
+        let blk_count = buf.len() / self.block_size();
+        let blocks = self
+            .queue
+            .lock()
+            .read_blocks_blocking(block_id as _, blk_count);
+        for (block, chunk) in blocks.into_iter().zip(buf.chunks_mut(self.block_size())) {
+            let block = block.map_err(maping_blk_err_to_dev_err)?;
+            if block.len() != chunk.len() {
+                return Err(DevError::Io);
+            }
+            chunk.copy_from_slice(&block);
+        }
+        Ok(())
+    }
+
+    fn write_block(&mut self, block_id: u64, buf: &[u8]) -> DevResult {
+        let blocks = self.queue.lock().write_blocks_blocking(block_id as _, buf);
+        for block in blocks {
+            block.map_err(maping_blk_err_to_dev_err)?;
+        }
+        Ok(())
+    }
+}
+
+impl From<Device<rdif_block::Block>> for Block {
+    fn from(base: Device<rdif_block::Block>) -> Self {
+        let queue = base.lock().unwrap().create_queue().unwrap();
+        Self {
+            dev: base,
+            queue: Mutex::new(queue),
+        }
+    }
+}
+
+fn maping_blk_err_to_dev_err(err: BlkError) -> DevError {
+    match err {
+        BlkError::NotSupported => DevError::Unsupported,
+        BlkError::Retry => DevError::Again,
+        BlkError::NoMemory => DevError::NoMemory,
+        BlkError::InvalidBlockIndex(_) => DevError::InvalidParam,
+        BlkError::Other(error) => {
+            error!("Block device error: {error}");
+            DevError::Io
+        }
+    }
+}
+
+fn maping_dev_err_to_blk_err(err: DevError) -> BlkError {
+    match err {
+        DevError::Again => BlkError::Retry,
+        DevError::AlreadyExists => BlkError::Other("Already exists".into()),
+        DevError::BadState => BlkError::Other("Bad internal state".into()),
+        DevError::InvalidParam => BlkError::Other("Invalid parameter".into()),
+        DevError::Io => BlkError::Other("I/O error".into()),
+        DevError::NoMemory => BlkError::NoMemory,
+        DevError::ResourceBusy => BlkError::Other("Resource busy".into()),
+        DevError::Unsupported => BlkError::NotSupported,
+    }
+}
+
+pub trait PlatformDeviceBlock {
+    fn register_block<T: rdif_block::Interface>(self, dev: T);
+}
+
+impl PlatformDeviceBlock for rdrive::PlatformDevice {
+    fn register_block<T: rdif_block::Interface>(self, dev: T) {
+        let dev = rdif_block::Block::new(dev);
+        self.register(dev);
+    }
+}