Update Red Bear driver substrate

Red Bear OS Team

local/recipes/drivers/redox-driver-sys/source/src/dma.rs

@@ -1,7 +1,8 @@
 use core::ptr::NonNull;
 use std::sync::atomic::{AtomicI32, Ordering};
 
-use redox_syscall::flag::{MAP_PRIVATE, O_CLOEXEC, PROT_READ, PROT_WRITE};
+use redox_syscall::data::Map;
+use redox_syscall::flag::{MapFlags, MAP_PRIVATE, O_CLOEXEC, PROT_READ, PROT_WRITE};
 use redox_syscall::PAGE_SIZE;
 use syscall as redox_syscall;
 
@@ -155,18 +156,15 @@ impl DmaBuffer {
         let region_fd = libredox::call::openat(mem_fd as usize, &path, O_CLOEXEC as i32, 0)
             .map_err(|e| DriverError::Io(std::io::Error::from_raw_os_error(e.errno())))?;
 
-        // Map it into our address space
-        let ptr = unsafe {
-            libredox::call::mmap(libredox::call::MmapArgs {
-                fd: region_fd as usize,
-                offset: 0,
-                length: size,
-                flags: MAP_PRIVATE.bits() as u32,
-                prot: (PROT_READ | PROT_WRITE).bits() as u32,
-                addr: core::ptr::null_mut(),
-            })
-        }
-        .map_err(|e| {
+        let map = Map {
+            offset: 0,
+            size,
+            flags: MapFlags::from_bits_truncate((MAP_PRIVATE | PROT_READ | PROT_WRITE).bits()),
+            address: 0,
+        };
+
+        // Map it into our address space through SYS_FMAP with combined map+prot flags.
+        let ptr = unsafe { redox_syscall::call::fmap(region_fd as usize, &map) }.map_err(|e| {
             let _ = libredox::call::close(region_fd as usize);
             DriverError::MappingFailed {
                 phys: 0,

local/recipes/drivers/redox-driver-sys/source/src/io.rs

@@ -1,3 +1,4 @@
+#[cfg(all(target_arch = "x86_64", target_os = "redox"))]
 use syscall as redox_syscall;
 
 use crate::Result;

local/recipes/drivers/redox-driver-sys/source/src/lib.rs

@@ -12,14 +12,18 @@
 //!
 //! ```no_run
 //! use redox_driver_sys::pci::PciDevice;
+//! use redox_driver_sys::Result;
 //!
-//! // Open a PCI device by location
-//! let dev = PciDevice::open(0, 0x10, 0, 0)?;
-//! let vendor = dev.vendor_id();
-//! let bars = dev.parse_bars()?;
-//! if let Some(bar) = bars[0].memory_info() {
-//!     let mmio = dev.map_bar(0, bar.addr, bar.size)?;
-//!     let reg = mmio.read32(0);
+//! fn example() -> Result<()> {
+//!     // Open a PCI device by location
+//!     let mut dev = PciDevice::open(0, 0x10, 0, 0)?;
+//!     let _vendor = dev.vendor_id();
+//!     let bars = dev.parse_bars()?;
+//!     if let Some((addr, size)) = bars[0].memory_info() {
+//!         let mmio = dev.map_bar(0, addr, size)?;
+//!         let _reg = mmio.read32(0);
+//!     }
+//!     Ok(())
 //! }
 //! ```
 

local/recipes/drivers/redox-driver-sys/source/src/memory.rs

@@ -1,6 +1,7 @@
 use core::ptr;
 use core::sync::atomic::{AtomicPtr, Ordering};
 
+use redox_syscall::data::Map;
 use redox_syscall::flag::{
     MAP_SHARED, O_CLOEXEC, O_RDONLY, O_RDWR, O_WRONLY, PROT_READ, PROT_WRITE,
 };
@@ -110,20 +111,19 @@ impl MmioRegion {
         let root_fd = ensure_memory_root()?;
         let mem_fd = root_fd.openat(&path, (O_CLOEXEC | mode) as i32, 0)?;
 
-        let ptr = unsafe {
-            libredox::call::mmap(libredox::call::MmapArgs {
-                fd: mem_fd.raw(),
-                offset: phys_addr,
-                length: aligned_size,
-                flags: MAP_SHARED.bits() as u32,
-                prot: mmap_prot.bits() as u32,
-                addr: ptr::null_mut(),
-            })
-        }
-        .map_err(|e| DriverError::MappingFailed {
-            phys: phys_addr,
-            size,
-            reason: format!("{e:?}"),
+        let map = Map {
+            offset: phys_addr as usize,
+            size: aligned_size,
+            flags: mmap_prot | redox_syscall::MapFlags::from_bits_truncate(MAP_SHARED.bits()),
+            address: 0,
+        };
+
+        let ptr = unsafe { redox_syscall::call::fmap(mem_fd.raw(), &map) }.map_err(|e| {
+            DriverError::MappingFailed {
+                phys: phys_addr,
+                size,
+                reason: format!("{e:?}"),
+            }
         })?;
 
         Ok(Self {

local/recipes/drivers/redox-driver-sys/source/src/pci.rs

@@ -585,7 +585,7 @@ impl std::io::Write for PciDevice {
     }
 }
 
-pub fn enumerate_pci_class(class: u8) -> Result<Vec<PciDeviceInfo>> {
+fn enumerate_pci_filtered(class: Option<u8>) -> Result<Vec<PciDeviceInfo>> {
     let entries = std::fs::read_dir("/scheme/pci")?;
     let mut devices = Vec::new();
 
@@ -609,8 +609,10 @@ pub fn enumerate_pci_class(class: u8) -> Result<Vec<PciDeviceInfo>> {
                 continue;
             }
             let class_code = data[0x0b];
-            if class_code != class {
-                continue;
+            if let Some(class) = class {
+                if class_code != class {
+                    continue;
+                }
             }
             let vendor_id = u16::from_le_bytes([data[0x00], data[0x01]]);
             let device_id = u16::from_le_bytes([data[0x02], data[0x03]]);
@@ -641,12 +643,23 @@ pub fn enumerate_pci_class(class: u8) -> Result<Vec<PciDeviceInfo>> {
     }
 
     log::debug!(
-        "PCI enumeration for class {class:#04x}: found {} devices",
+        "PCI enumeration{}: found {} devices",
+        class
+            .map(|class| format!(" for class {class:#04x}"))
+            .unwrap_or_default(),
         devices.len()
     );
     Ok(devices)
 }
 
+pub fn enumerate_pci_class(class: u8) -> Result<Vec<PciDeviceInfo>> {
+    enumerate_pci_filtered(Some(class))
+}
+
+pub fn enumerate_pci_all() -> Result<Vec<PciDeviceInfo>> {
+    enumerate_pci_filtered(None)
+}
+
 fn parse_scheme_entry(name: &str) -> Option<PciLocation> {
     let parts: Vec<&str> = name.splitn(3, "--").collect();
     if parts.len() != 3 {