custom virtio-drivers

pass the compile

Author: lhw

Cargo.lock

@@ -21,7 +21,7 @@ default = []
 
 [dependencies]
 cfg-if = "1.0"
-log = "< 0.4.22"
+log = "0.4"
 spinlock = { path = "../spinlock" }
 crate_interface = { version = "0.1.1" }
 chrono = { version = "0.4", optional = true }

crates/axlog/Cargo.toml

@@ -10,4 +10,4 @@ repository = "https://github.com/rcore-os/arceos/tree/main/crates/driver_pci"
 documentation = "https://rcore-os.github.io/arceos/driver_pci/index.html"
 
 [dependencies]
-virtio-drivers = { git = "https://github.com/syswonder/virtio-drivers.git", rev = "62dbe5a"}
+virtio-drivers = { git = "https://github.com/syswonder/virtio-drivers.git", rev = "31f6555"}

crates/driver_pci/Cargo.toml

@@ -17,11 +17,11 @@
 
 #![no_std]
 
-pub use virtio_drivers::transport::pci::bus::{BarInfo, Cam, HeaderType, MemoryBarType, PciError};
+pub use virtio_drivers::transport::pci::bus::{BarInfo, Cam, HeaderType, MemoryBarType, PciError, MmioCam};
 pub use virtio_drivers::transport::pci::bus::{
     CapabilityInfo, Command, DeviceFunction, DeviceFunctionInfo, PciRoot, Status,
 };
-
+pub use virtio_drivers::transport::pci::bus::ConfigurationAccess;
 /// Used to allocate MMIO regions for PCI BARs.
 pub struct PciRangeAllocator {
     _start: u64,

crates/driver_pci/src/lib.rs

@@ -28,4 +28,4 @@ driver_net = { path = "../driver_net", optional = true }
 driver_display = { path = "../driver_display", optional = true }
 driver_9p = { path = "../driver_9p", optional = true }
 driver_console = { path = "../driver_console", optional = true }
-virtio-drivers = { git = "https://github.com/syswonder/virtio-drivers.git", rev = "62dbe5a" }
+virtio-drivers = { git = "https://github.com/syswonder/virtio-drivers.git", rev = "31f6555" }

crates/driver_virtio/Cargo.toml

@@ -53,13 +53,13 @@ impl<H: Hal, T: Transport> BlockDriverOps for VirtIoBlkDev<H, T> {
 
     fn read_block(&mut self, block_id: u64, buf: &mut [u8]) -> DevResult {
         self.inner
-            .read_block(block_id as _, buf)
+            .read_blocks(block_id as _, buf)
             .map_err(as_dev_err)
     }
 
     fn write_block(&mut self, block_id: u64, buf: &[u8]) -> DevResult {
         self.inner
-            .write_block(block_id as _, buf)
+            .write_blocks(block_id as _, buf)
             .map_err(as_dev_err)
     }
 

crates/driver_virtio/src/blk.rs

@@ -14,7 +14,7 @@ use virtio_drivers::{device::console::VirtIOConsole as InnerDev, transport::Tran
 
 /// VirtIO console device
 pub struct VirtIoConsoleDev<H: Hal, T: Transport> {
-    inner: InnerDev<'static, H, T>,
+    inner: InnerDev<H, T>,
 }
 
 unsafe impl<H: Hal, T: Transport> Send for VirtIoConsoleDev<H, T> {}

crates/driver_virtio/src/console.rs

@@ -16,7 +16,7 @@ use virtio_drivers::{device::gpu::VirtIOGpu as InnerDev, transport::Transport, H
 
 /// The VirtIO GPU device driver.
 pub struct VirtIoGpuDev<H: Hal, T: Transport> {
-    inner: InnerDev<'static, H, T>,
+    inner: InnerDev<H, T>,
     info: DisplayInfo,
 }
 

crates/driver_virtio/src/gpu.rs

@@ -45,6 +45,7 @@ pub use self::net::VirtIoNetDev;
 #[cfg(feature = "v9p")]
 pub use self::v9p::VirtIo9pDev;
 
+use virtio_drivers::transport::pci::bus::ConfigurationAccess;
 pub use virtio_drivers::transport::pci::bus as pci;
 pub use virtio_drivers::transport::{mmio::MmioTransport, pci::PciTransport, Transport};
 pub use virtio_drivers::{BufferDirection, Hal as VirtIoHal, PhysAddr};
@@ -59,13 +60,13 @@ use virtio_drivers::transport::DeviceType as VirtIoDevType;
 /// for later operations. Otherwise, returns [`None`].
 pub fn probe_mmio_device(
     reg_base: *mut u8,
-    _reg_size: usize,
-) -> Option<(DeviceType, MmioTransport)> {
+    reg_size: usize,
+) -> Option<(DeviceType, MmioTransport<'static>)> {
     use core::ptr::NonNull;
     use virtio_drivers::transport::mmio::VirtIOHeader;
 
     let header = NonNull::new(reg_base as *mut VirtIOHeader).unwrap();
-    let transport = unsafe { MmioTransport::new(header) }.ok()?;
+    let transport = unsafe { MmioTransport::new(header,reg_size) }.ok()?;
     let dev_type = as_dev_type(transport.device_type())?;
     Some((dev_type, transport))
 }
@@ -74,18 +75,23 @@ pub fn probe_mmio_device(
 ///
 /// If the device is recognized, returns the device type and a transport object
 /// for later operations. Otherwise, returns [`None`].
-pub fn probe_pci_device<H: VirtIoHal>(
-    root: &mut PciRoot,
+pub fn probe_pci_device<H, C>(
+    root: &mut PciRoot<C>,
     bdf: DeviceFunction,
     dev_info: &DeviceFunctionInfo,
-) -> Option<(DeviceType, PciTransport)> {
+) -> Option<(DeviceType, PciTransport)>
+where
+    H: VirtIoHal,
+    C: ConfigurationAccess,
+{
     use virtio_drivers::transport::pci::virtio_device_type;
 
     let dev_type = virtio_device_type(dev_info).and_then(as_dev_type)?;
-    let transport = PciTransport::new::<H>(root, bdf).ok()?;
+    let transport = PciTransport::new::<H, C>(root, bdf).ok()?;
     Some((dev_type, transport))
 }
 
+
 const fn as_dev_type(t: VirtIoDevType) -> Option<DeviceType> {
     use VirtIoDevType::*;
     match t {

crates/driver_virtio/src/lib.rs

@@ -99,12 +99,12 @@ impl<H: Hal, T: Transport, const QS: usize> NetDriverOps for VirtIoNetDev<H, T,
 
     #[inline]
     fn can_transmit(&self) -> bool {
-        !self.free_tx_bufs.is_empty() && self.inner.can_transmit()
+        !self.free_tx_bufs.is_empty() && self.inner.can_send()
     }
 
     #[inline]
     fn can_receive(&self) -> bool {
-        self.inner.can_receive()
+        self.inner.poll_receive().is_some()
     }
 
     #[inline]