update

Author: ZR233

Cargo.lock

@@ -52,7 +52,7 @@ display = ["alloc", "paging", "axdriver/virtio-gpu", "dep:axdisplay", "axruntime
 rtc = ["axhal/rtc", "axruntime/rtc"]
 
 # Device drivers
-driver-dyn = ["axruntime/driver","axdriver?/dyn"]
+driver-dyn = ["axruntime/driver-dyn","axdriver?/dyn"]
 bus-mmio = ["axdriver?/bus-mmio"]
 bus-pci = ["axdriver?/bus-pci"]
 driver-ramdisk = ["axdriver?/ramdisk", "axfs?/use-ramdisk"]

api/axfeat/Cargo.toml

@@ -10,7 +10,7 @@ repository = "https://github.com/arceos-org/arceos/tree/main/modules/axdriver"
 documentation = "https://arceos-org.github.io/arceos/axdriver/index.html"
 
 [features]
-dyn = ["dep:rdrive", "dep:axmm", "dep:arm-gic-driver"]
+dyn = ["dep:rdrive", "dep:arm-gic-driver"]
 bus-mmio = []
 bus-pci = ["dep:axdriver_pci", "dep:axhal", "dep:axconfig"]
 net = ["axdriver_net"]
@@ -47,7 +47,8 @@ axhal = { workspace = true, optional = true }
 axconfig = { workspace = true, optional = true }
 axdma = { workspace = true, optional = true }
 rdrive = { version = "0.15", optional = true }
-axmm = { workspace = true, optional = true }
+axerrno = "0.1"
+lazyinit = "0.2"
 
 [target.'cfg(target_arch = "aarch64")'.dependencies]
 arm-gic-driver = { version = "0.14", optional = true }

modules/axdriver/Cargo.toml

@@ -1,6 +1,4 @@
 #[cfg(bus = "mmio")]
-#[allow(unused)]
 mod mmio;
 #[cfg(bus = "pci")]
-#[allow(unused)]
 mod pci;

modules/axdriver/src/bus/mod.rs

@@ -4,8 +4,7 @@ use alloc::format;
 use axdriver_base::DeviceType;
 use axdriver_block::BlockDriverOps;
 use axdriver_virtio::MmioTransport;
-use axhal::mem::{MemoryAddr, PhysAddr};
-use core::ptr::NonNull;
+use axhal::mem::PhysAddr;
 use rdrive::{
     DriverGeneric, PlatformDevice, driver::block::*, module_driver, probe::OnProbeError,
     register::FdtInfo,
@@ -30,27 +29,19 @@ module_driver!(
 );
 
 fn probe(info: FdtInfo<'_>, plat_dev: PlatformDevice) -> Result<(), OnProbeError> {
-    let mut reg = info.node.reg().ok_or(OnProbeError::other(alloc::format!(
-        "[{}] has no reg",
-        info.node.name()
-    )))?;
+    let base_reg = info
+        .node
+        .reg()
+        .and_then(|mut regs| regs.next())
+        .ok_or(OnProbeError::other(alloc::format!(
+            "[{}] has no reg",
+            info.node.name()
+        )))?;
 
-    let base_reg = reg.next().unwrap();
     let mmio_size = base_reg.size.unwrap_or(0x1000);
     let mmio_base = PhysAddr::from_usize(base_reg.address as usize);
-    let aligned_base = mmio_base.align_down_4k();
-    let offset = mmio_base - aligned_base;
 
-    let aligned_end = (mmio_base + mmio_size).align_up_4k();
-    let aligned_mmio_size = aligned_end - aligned_base;
-
-    let aligned_mmio_base: NonNull<u8> = iomap(aligned_base, aligned_mmio_size)?;
-    let mmio_base = unsafe { aligned_mmio_base.as_ptr().add(offset) };
-
-    debug!(
-        "virtio block device MMIO base address: {:?}, size: {}",
-        mmio_base, mmio_size
-    );
+    let mmio_base = iomap(mmio_base, mmio_size)?.as_ptr();
 
     let (ty, transport) =
         axdriver_virtio::probe_mmio_device(mmio_base, mmio_size).ok_or(OnProbeError::NotMatch)?;
@@ -67,11 +58,8 @@ fn probe(info: FdtInfo<'_>, plat_dev: PlatformDevice) -> Result<(), OnProbeError
     })?;
 
     let dev = BlockDivce(dev);
-
     plat_dev.register_block(dev);
-
     debug!("virtio block device registered successfully");
-
     Ok(())
 }
 

modules/axdriver/src/dyn_drivers/blk/virtio.rs

@@ -1,11 +1,8 @@
 use core::{error::Error, ptr::NonNull};
 
 use alloc::{boxed::Box, format};
-use axhal::{
-    mem::{MemoryAddr, PhysAddr, phys_to_virt},
-    paging::MappingFlags,
-};
-use axmm::AxError;
+use axerrno::AxError;
+use axhal::mem::{MemoryAddr, PhysAddr, phys_to_virt};
 
 mod intc;
 
@@ -15,23 +12,25 @@ pub mod blk;
 #[allow(unused)]
 /// maps a mmio physical address to a virtual address.
 fn iomap(addr: PhysAddr, size: usize) -> Result<NonNull<u8>, Box<dyn Error>> {
-    let end = (addr.as_usize() + size).align_up_4k();
+    let end = (addr + size).align_up_4k();
     let start = addr.align_down_4k();
-    let size = end - start.as_usize();
+    let offset = addr - start;
+    let size = end - start;
+    let iomap = *crate::IO_MAP_FUNC
+        .get()
+        .ok_or_else(|| format!("IO map function not initialized"))?;
 
-    let start_virt = phys_to_virt(start);
-
-    match axmm::kernel_aspace().lock().map_linear(
-        start_virt,
-        addr,
-        size,
-        MappingFlags::READ | MappingFlags::WRITE | MappingFlags::DEVICE,
-    ) {
-        Ok(_) | Err(AxError::AlreadyExists) => {}
+    let virt = match iomap(start, size) {
+        Ok(val) => val,
+        Err(AxError::AlreadyExists) => phys_to_virt(start),
         Err(e) => {
-            Err(format!("Failed to map MMIO region {:?}: {}", start_virt, e))?;
+            return Err(format!(
+                "Failed to map MMIO region: {:?} (addr: {:?}, size: {:#x})",
+                e, start, size
+            )
+            .into());
         }
-    }
-
+    };
+    let start_virt = virt + offset;
     Ok(NonNull::new(start_virt.as_mut_ptr()).unwrap())
 }

modules/axdriver/src/dyn_drivers/mod.rs

@@ -67,6 +67,7 @@ extern crate alloc;
 #[macro_use]
 mod macros;
 
+#[cfg(not(feature = "dyn"))]
 mod bus;
 mod drivers;
 mod dummy;
@@ -83,11 +84,13 @@ mod dyn_drivers;
 
 pub mod prelude;
 
-use axhal::mem::phys_to_virt;
-
 #[allow(unused_imports)]
 use self::prelude::*;
 pub use self::structs::{AxDeviceContainer, AxDeviceEnum};
+use axerrno::AxResult;
+use axhal::mem::phys_to_virt;
+use axhal::mem::{PhysAddr, VirtAddr};
+use lazyinit::LazyInit;
 
 #[cfg(feature = "block")]
 pub use self::structs::AxBlockDevice;
@@ -96,6 +99,9 @@ pub use self::structs::AxDisplayDevice;
 #[cfg(feature = "net")]
 pub use self::structs::AxNetDevice;
 
+pub type IoMapFunc = fn(PhysAddr, usize) -> AxResult<VirtAddr>;
+static IO_MAP_FUNC: LazyInit<IoMapFunc> = LazyInit::new();
+
 /// A structure that contains all device drivers, organized by their category.
 #[derive(Default)]
 pub struct AllDevices {
@@ -160,7 +166,13 @@ impl AllDevices {
 }
 
 /// Sets up the device driver subsystem.
-pub fn setup(dtb: usize) {
+pub fn setup(dtb: usize, io_map_func: IoMapFunc) {
+    IO_MAP_FUNC.init_once(io_map_func);
+    if dtb == 0 {
+        warn!("Device tree base address is 0, skipping device driver setup.");
+        return;
+    }
+
     let dtb_virt = phys_to_virt(dtb.into());
     if let Some(dtb) = core::ptr::NonNull::new(dtb_virt.as_mut_ptr()) {
         structs::setup(dtb);

modules/axdriver/src/lib.rs

@@ -12,7 +12,7 @@ mod backend;
 pub use self::aspace::AddrSpace;
 pub use self::backend::Backend;
 
-pub use axerrno::{AxError, AxResult};
+use axerrno::{AxError, AxResult};
 use axhal::mem::phys_to_virt;
 use kspin::SpinNoIrq;
 use lazyinit::LazyInit;

modules/axmm/src/lib.rs

@@ -17,7 +17,7 @@ irq = ["axhal/irq", "axtask?/irq", "percpu", "kernel_guard"]
 tls = ["axhal/tls", "axtask?/tls"]
 alloc = ["axalloc"]
 paging = ["axhal/paging", "axmm"]
-driver = ["axdriver"]
+driver-dyn = ["axdriver"]
 
 multitask = ["axtask/multitask"]
 fs = ["axdriver", "axfs"]
@@ -36,6 +36,7 @@ axfs = { workspace = true, optional = true }
 axnet = { workspace = true, optional = true }
 axdisplay = { workspace = true, optional = true }
 axtask = { workspace = true, optional = true }
+axerrno = "0.1"
 
 crate_interface = "0.1"
 percpu = { version = "0.2", optional = true }

modules/axruntime/Cargo.toml

@@ -147,8 +147,8 @@ pub extern "C" fn rust_main(cpu_id: usize, dtb: usize) -> ! {
     #[cfg(feature = "paging")]
     axmm::init_memory_management();
 
-    #[cfg(feature = "driver")]
-    axdriver::setup(dtb);
+    #[cfg(feature = "driver-dyn")]
+    axdriver::setup(dtb, iomap);
 
     info!("Initialize platform devices...");
     axhal::platform_init();
@@ -273,3 +273,20 @@ fn init_tls() {
     unsafe { axhal::asm::write_thread_pointer(main_tls.tls_ptr() as usize) };
     core::mem::forget(main_tls);
 }
+
+#[cfg(feature = "driver-dyn")]
+fn iomap(addr: axhal::mem::PhysAddr, size: usize) -> axerrno::AxResult<axhal::mem::VirtAddr> {
+    let virt = axhal::mem::phys_to_virt(addr);
+    #[cfg(feature = "paging")]
+    {
+        use axhal::paging::MappingFlags;
+
+        axmm::kernel_aspace().lock().map_linear(
+            virt,
+            addr,
+            size,
+            MappingFlags::DEVICE | MappingFlags::READ | MappingFlags::WRITE,
+        )?;
+    }
+    Ok(virt)
+}