drm/asahi: gpu: Implement mapping timestamp buffers

Signed-off-by: Asahi Lina <lina@asahilina.net>

Author: hoshinolina

drivers/gpu/drm/asahi/gem.rs

@@ -84,7 +84,26 @@ impl ObjectRef {
         if !self.gem.kernel {
             return Err(EINVAL);
         }
-        vm.map_in_range(self.gem.size(), &self.gem, alignment, range, prot, guard)
+        vm.map_in_range(&self.gem, 0..self.gem.size(), alignment, range, prot, guard)
+    }
+
+    /// Maps a range within an object into a given `Vm` at any free address within a given range.
+    pub(crate) fn map_range_into_range(
+        &mut self,
+        vm: &crate::mmu::Vm,
+        obj_range: Range<usize>,
+        range: Range<u64>,
+        alignment: u64,
+        prot: u32,
+        guard: bool,
+    ) -> Result<crate::mmu::KernelMapping> {
+        if obj_range.end > self.gem.size() {
+            return Err(EINVAL);
+        }
+        if self.gem.flags & uapi::ASAHI_GEM_VM_PRIVATE != 0 && vm.is_extobj(&self.gem) {
+            return Err(EINVAL);
+        }
+        vm.map_in_range(&self.gem, obj_range, alignment, range, prot, guard)
     }
 
     /// Maps an object into a given `Vm` at a specific address.

drivers/gpu/drm/asahi/gpu.rs

@@ -278,6 +278,12 @@ pub(crate) trait GpuManager: Send + Sync {
     fn free_context(&self, data: KBox<fw::types::GpuObject<fw::workqueue::GpuContextData>>);
     /// Check whether the GPU is crashed
     fn is_crashed(&self) -> bool;
+    /// Map a BO as a timestamp buffer
+    fn map_timestamp_buffer(
+        &self,
+        bo: gem::ObjectRef,
+        range: Range<usize>,
+    ) -> Result<mmu::KernelMapping>;
 }
 
 /// Private generic trait for functions that don't need to escape this module.
@@ -1488,6 +1494,21 @@ impl GpuManager for GpuManager::ver {
     fn is_crashed(&self) -> bool {
         self.crashed.load(Ordering::Relaxed)
     }
+
+    fn map_timestamp_buffer(
+        &self,
+        mut bo: gem::ObjectRef,
+        range: Range<usize>,
+    ) -> Result<mmu::KernelMapping> {
+        bo.map_range_into_range(
+            self.uat.kernel_vm(),
+            range,
+            IOVA_KERN_TIMESTAMP_RANGE,
+            mmu::UAT_PGSZ as u64,
+            mmu::PROT_FW_SHARED_RW,
+            false,
+        )
+    }
 }
 
 #[versions(AGX)]

drivers/gpu/drm/asahi/mmu.rs

@@ -488,12 +488,13 @@ impl VmInner {
         let mut iova = node.start();
         let guard = node.bo.as_ref().ok_or(EINVAL)?.inner().sgt.lock();
         let sgt = guard.as_ref().ok_or(EINVAL)?;
+        let mut offset = node.offset;
 
         for range in sgt.iter() {
-            let addr = range.dma_address();
-            let len = range.dma_len();
+            let mut addr = range.dma_address();
+            let mut len = range.dma_len();
 
-            if (addr | len | iova as usize) & UAT_PGMSK != 0 {
+            if (offset | addr | len | iova as usize) & UAT_PGMSK != 0 {
                 dev_err!(
                     self.dev.as_ref(),
                     "MMU: KernelMapping {:#x}:{:#x} -> {:#x} is not page-aligned\n",
@@ -504,6 +505,17 @@ impl VmInner {
                 return Err(EINVAL);
             }
 
+            if offset > 0 {
+                let skip = len.min(offset);
+                addr += skip;
+                len -= skip;
+                offset -= skip;
+            }
+
+            if len == 0 {
+                continue;
+            }
+
             mod_dev_dbg!(
                 self.dev,
                 "MMU: map: {:#x}:{:#x} -> {:#x}\n",
@@ -592,6 +604,7 @@ pub(crate) struct KernelMappingInner {
     owner: ARef<gpuvm::GpuVm<VmInner>>,
     uat_inner: Arc<UatInner>,
     prot: u32,
+    offset: usize,
     mapped_size: usize,
 }
 
@@ -1084,13 +1097,14 @@ impl Vm {
     #[allow(clippy::too_many_arguments)]
     pub(crate) fn map_in_range(
         &self,
-        size: usize,
         gem: &gem::Object,
+        object_range: Range<usize>,
         alignment: u64,
         range: Range<u64>,
         prot: u32,
         guard: bool,
     ) -> Result<KernelMapping> {
+        let size = object_range.range();
         let sgt = gem.sg_table()?;
         let mut inner = self.inner.exec_lock(Some(gem))?;
         let vm_bo = inner.obtain_bo()?;
@@ -1109,6 +1123,7 @@ impl Vm {
                 prot,
                 bo: Some(vm_bo),
                 _gem: Some(gem.reference()),
+                offset: object_range.start,
                 mapped_size: size,
             },
             (size + if guard { UAT_PGSZ } else { 0 }) as u64, // Add guard page
@@ -1152,6 +1167,7 @@ impl Vm {
                 prot,
                 bo: Some(vm_bo),
                 _gem: Some(gem.reference()),
+                offset: 0,
                 mapped_size: size,
             },
             addr,
@@ -1253,6 +1269,7 @@ impl Vm {
                 prot,
                 bo: None,
                 _gem: None,
+                offset: 0,
                 mapped_size: size,
             },
             iova,