src/gpu/i915/mod.rs

@@ -1,6 +1,7 @@
 use std::{ffi::OsString, os::fd::{AsRawFd, OwnedFd}};
-use crate::{native, uapi::{self, i915::DrmGemTileInfo}};
+use crate::uapi::i915::DrmGemHandle;
-use uapi::i915::DrmGemHandle;
+
+use super::super::uapi;
 use std::path::Path;
 use std::fs::File;
 
@@ -18,42 +19,6 @@ pub struct GemHandle<'a> {
     pub node: &'a DrmDeviceNode,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[repr(u32)]
-pub enum DrmCacheType {
-    None    = native::I915_CACHING_NONE,
-    Cached  = native::I915_CACHING_CACHED,
-    Display = native::I915_CACHING_DISPLAY,
-}
-
-impl From<u32> for DrmCacheType {
-    fn from(val: u32) -> DrmCacheType {
-        match val {
-            native::I915_CACHING_NONE => DrmCacheType::None,
-            native::I915_CACHING_CACHED => DrmCacheType::Cached,
-            native::I915_CACHING_DISPLAY => DrmCacheType::Display,
-            _ => panic!("Invalid cache type encountered"),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct GemTileInfo {
-    pub tiling_mode: u32,
-    pub swizzle_mode: u32,
-    pub phys_swizzle_mode: u32,
-}
-
-impl From<DrmGemTileInfo> for GemTileInfo {
-    fn from(info: DrmGemTileInfo) -> GemTileInfo {
-        GemTileInfo {
-            tiling_mode: info.tiling_mode,
-            swizzle_mode: info.swizzle_mode,
-            phys_swizzle_mode: info.phys_swizzle_mode,
-        }
-    }
-}
-
 /// An owned GEM handle that will be closed when dropped
 impl GemHandle<'_> {
     pub fn new(node: &DrmDeviceNode, size: u64) -> Option<GemHandle> {
@@ -82,14 +47,6 @@ impl GemHandle<'_> {
         return unsafe { uapi::i915::close_gem_ref(self.node.fd.as_raw_fd(), &self.handle) };
     }
 
-    pub fn get_tiling(&self) -> Result<GemTileInfo, GemIoctlError> {
-        uapi::i915::gem_get_tiling(self.node.fd.as_raw_fd(), &self.handle).map(|info| GemTileInfo::from(info))
-    }
-
-    pub fn get_caching(&self) -> Result<DrmCacheType, GemIoctlError> {
-        uapi::i915::gem_get_caching(self.node.fd.as_raw_fd(), &self.handle).map(|info| DrmCacheType::try_from(info).unwrap())
-    }
-
     pub fn has_tiling(&self) -> Result<bool, uapi::i915::GemIoctlError> {
         uapi::i915::gem_has_tiling(self.node.fd.as_raw_fd(), &self.handle)
     }

src/uapi/i915/mod.rs

@@ -204,19 +204,10 @@ pub fn close_gem(fd: RawFd, handle: DrmGemHandle) -> Result<(), i32> {
 pub enum GemIoctlError {
     InvalidHandle,
     PermissionDenied,
-    UnsupportedOnDevice,
-    UnsupportedOnHandle,
     Unknown(i32),
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub fn gem_has_tiling(fd: RawFd, handle: &DrmGemHandle) -> Result<bool, GemIoctlError> {
-pub struct DrmGemTileInfo {
-    pub tiling_mode: u32,
-    pub swizzle_mode: u32,
-    pub phys_swizzle_mode: u32,
-}
-
-pub fn gem_get_tiling(fd: RawFd, handle: &DrmGemHandle) -> Result<DrmGemTileInfo, GemIoctlError> {
     unsafe {
         let mut tiling = native::drm_i915_gem_get_tiling {
             handle: handle.handle,
@@ -225,47 +216,12 @@ pub fn gem_get_tiling(fd: RawFd, handle: &DrmGemHandle) -> Result<DrmGemTileInfo
             phys_swizzle_mode: 0,
         };
         let res = libc::ioctl(fd, native::DRM_IOCTL_I915_GEM_GET_TILING, &mut tiling);
-        let tile_info = DrmGemTileInfo {
-            tiling_mode: tiling.tiling_mode,
-            swizzle_mode: tiling.swizzle_mode,
-            phys_swizzle_mode: tiling.phys_swizzle_mode,
-        };
-        let errno = *libc::__errno_location();
-        match errno {
-            0 => Ok(tile_info),
-            libc::ENOENT => Err(GemIoctlError::InvalidHandle),
-            libc::EPERM => Err(GemIoctlError::PermissionDenied),
-            libc::EOPNOTSUPP => Err(GemIoctlError::UnsupportedOnDevice),
-            _ => Err(GemIoctlError::Unknown(res)),
-        }
-    }
-}
-
-pub fn gem_has_tiling(fd: RawFd, handle: &DrmGemHandle) -> Result<bool, GemIoctlError> {
-    let res = gem_get_tiling(fd, handle);
-    if res.is_ok() {
-        return Ok(true);
-    }
-    if res.is_err() && res.unwrap_err() == GemIoctlError::UnsupportedOnDevice {
-        return Ok(false);
-    }
-    return Err(res.unwrap_err());
-}
-
-pub fn gem_get_caching(fd: RawFd, handle: &DrmGemHandle) -> Result<u32, GemIoctlError> {
-    unsafe {
-        let mut caching = native::drm_i915_gem_caching {
-            handle: handle.handle,
-            caching: 0,
-        };
-        let res = libc::ioctl(fd, native::DRM_IOCTL_I915_GEM_GET_CACHING, &mut caching);
         let errno = *libc::__errno_location();
         match errno {
-            0 => Ok(caching.caching),
+            0 => Ok(true),
             libc::ENOENT => Err(GemIoctlError::InvalidHandle),
             libc::EPERM => Err(GemIoctlError::PermissionDenied),
-            libc::ENODEV => Err(GemIoctlError::UnsupportedOnDevice),
+            libc::EINVAL => Ok(false),
-            libc::EOPNOTSUPP => Err(GemIoctlError::UnsupportedOnHandle),
             _ => Err(GemIoctlError::Unknown(res)),
         }
     }
@@ -281,6 +237,7 @@ pub fn gem_is_valid(fd: RawFd, handle: &DrmGemHandle) -> Result<bool, GemIoctlEr
         return Ok(false);
     }
 
+    println!("Unexpected error: {:?}", res.unwrap_err());
     return Err(res.unwrap_err());
 }
 

tests/tests_i915_gpu.rs

@@ -126,12 +126,4 @@ fn test_i915_gpu_gem_has_tiling() {
     let device = i915::find_device().expect("Failed to find i915 device");
     let gem = i915::GemHandle::new(&device.node, 4096).expect("Failed to create gem handle");
     assert!(gem.has_tiling().unwrap());
-}
-
-#[test]
-fn test_i915_gpu_fences() {
-    let device = i915::find_device().expect("Failed to find i915 device");
-    let num_fences = device.get_param(native::I915_PARAM_NUM_FENCES_AVAIL).expect("Failed to get fences");
-    println!("Number of fences: {}", num_fences);
-    assert!(num_fences > 0);
 }

tests/tests_raw.rs

@@ -1,5 +1,6 @@
 use intel_gpu::*;
 use std::ffi::c_void;
+use std::ffi::CStr;
 use nix::{self};
 
 #[test]
@@ -27,6 +28,13 @@ fn test_raw_drm_version() {
             desc_len: 128,
         };
         assert!(libc::ioctl(fd, native::DRM_IOCTL_VERSION, &mut version) == 0);
+        println!("version_major: {}, version_minor: {}, version_patchlevel: {}, name: {:?}, date: {:?}, desc: {:?}", 
+            version.version_major, 
+            version.version_minor, 
+            version.version_patchlevel, 
+            CStr::from_ptr(version.name), 
+            CStr::from_ptr(version.date), 
+            CStr::from_ptr(version.desc));
     }
 }
 

tests/tests_uapi.rs

@@ -1,11 +1,9 @@
 #![allow(unused_imports)]
 
-use gpu::i915::GemHandle;
 use intel_gpu::*;
-use uapi::i915::{self, DrmGemHandle};
+use uapi::i915;
 use std::fs;
 use std::{fs::File, os::fd::{AsRawFd, RawFd}};
-use std::thread;
 
 #[test]
 fn test_i915_uapi_get_version() {
@@ -80,26 +78,4 @@ fn test_i915_uapi_gem_tiling() {
     // TODO figure out which devices this holds for
     assert!(i915::gem_has_tiling(node.fd.as_raw_fd(), &gem).is_ok_and(|e| e == true));
     i915::close_gem(node.fd.as_raw_fd(), gem).expect("Failed to close gem");
-}
-
-#[test]
-fn test_i915_uapi_gem_caching() {
-    let node = i915::find_node().expect("Failed to find i915 fd");
-    let gem = i915::make_gem(node.fd.as_raw_fd(), 4096).expect("Failed to make gem");
-    let caching = i915::gem_get_caching(node.fd.as_raw_fd(), &gem).expect("Failed to get caching");
-    assert!(caching > 0);
-    i915::close_gem(node.fd.as_raw_fd(), gem).expect("Failed to close gem");
-}
-
-#[test]
-fn test_i915_uapi_gem_thread() {
-    let node = i915::find_node().expect("Failed to find i915 fd");
-    let gem = i915::make_gem(node.fd.as_raw_fd(), 4096).expect("Failed to make gem");
-    thread::scope(|s| {
-        let handle = s.spawn(|| {
-            assert!(i915::gem_is_valid(node.fd.as_raw_fd(), &gem).unwrap());
-        });
-        assert!(i915::gem_is_valid(node.fd.as_raw_fd(), &gem).unwrap());
-        handle.join().expect("Failed to join thread");
-    });
 }