drm/asahi: Convert to ARef<Device<T>> DRM device API

Signed-off-by: Asahi Lina <[email protected]>

Author: hoshinolina

drivers/gpu/drm/asahi/alloc.rs

@@ -15,7 +15,7 @@
 use kernel::{c_str, drm::mm, error::Result, prelude::*, str::CString, sync::LockClassKey};
 
 use crate::debug::*;
-use crate::driver::AsahiDevice;
+use crate::driver::{AsahiDevRef, AsahiDevice};
 use crate::fw::types::Zeroable;
 use crate::mmu;
 use crate::object::{GpuArray, GpuObject, GpuOnlyArray, GpuStruct, GpuWeakPointer};
@@ -410,7 +410,7 @@ pub(crate) trait Allocator {
 /// `ptr` is either None or a valid, non-null pointer to the CPU view of the object.
 /// `gpu_ptr` is the GPU-side VA of the object.
 pub(crate) struct SimpleAllocation {
-    dev: AsahiDevice,
+    dev: AsahiDevRef,
     ptr: Option<NonNull<u8>>,
     gpu_ptr: u64,
     size: usize,
@@ -461,7 +461,7 @@ impl RawAllocation for SimpleAllocation {
 /// the guard page after the allocation, which can be useful to validate that the firmware's or
 /// GPU's idea of object size what we expect.
 pub(crate) struct SimpleAllocator {
-    dev: AsahiDevice,
+    dev: AsahiDevRef,
     start: u64,
     end: u64,
     prot: u32,
@@ -490,7 +490,7 @@ impl SimpleAllocator {
             cpu_maps = true;
         }
         Ok(SimpleAllocator {
-            dev: dev.clone(),
+            dev: dev.into(),
             vm: vm.clone(),
             start,
             end,
@@ -572,7 +572,7 @@ impl Allocator for SimpleAllocator {
 ///
 /// This is wrapped in an `mm::Node`.
 pub(crate) struct HeapAllocationInner {
-    dev: AsahiDevice,
+    dev: AsahiDevRef,
     ptr: Option<NonNull<u8>>,
     real_size: usize,
 }
@@ -664,7 +664,7 @@ impl RawAllocation for HeapAllocation {
 ///
 /// This is wrapped by an `mm::Allocator`.
 struct HeapAllocatorInner {
-    dev: AsahiDevice,
+    dev: AsahiDevRef,
     allocated: usize,
     backing_objects: Vec<(crate::gem::ObjectRef, u64)>,
     garbage: Option<Vec<mm::Node<HeapAllocatorInner, HeapAllocationInner>>>,
@@ -678,7 +678,7 @@ struct HeapAllocatorInner {
 /// The heap is composed of a series of GEM objects. This implementation only ever grows the heap,
 /// never shrinks it.
 pub(crate) struct HeapAllocator {
-    dev: AsahiDevice,
+    dev: AsahiDevRef,
     start: u64,
     end: u64,
     top: u64,
@@ -720,7 +720,7 @@ impl HeapAllocator {
         let name = CString::try_from_fmt(name)?;
 
         let inner = HeapAllocatorInner {
-            dev: dev.clone(),
+            dev: dev.into(),
             allocated: 0,
             backing_objects: Vec::new(),
             // TODO: This clearly needs a try_clone() or similar
@@ -739,7 +739,7 @@ impl HeapAllocator {
         )?;
 
         Ok(HeapAllocator {
-            dev: dev.clone(),
+            dev: dev.into(),
             vm: vm.clone(),
             start,
             end,

drivers/gpu/drm/asahi/channel.rs

@@ -9,7 +9,7 @@
 //! implementation.
 
 use crate::debug::*;
-use crate::driver::AsahiDevice;
+use crate::driver::{AsahiDevRef, AsahiDevice};
 use crate::fw::channels::*;
 use crate::fw::initdata::{raw, ChannelRing};
 use crate::fw::types::*;
@@ -185,7 +185,7 @@ where
 /// Device Control channel for global device management commands.
 #[versions(AGX)]
 pub(crate) struct DeviceControlChannel {
-    dev: AsahiDevice,
+    dev: AsahiDevRef,
     ch: TxChannel<ChannelState, DeviceControlMsg::ver>,
 }
 
@@ -199,7 +199,7 @@ impl DeviceControlChannel::ver {
         alloc: &mut gpu::KernelAllocators,
     ) -> Result<DeviceControlChannel::ver> {
         Ok(DeviceControlChannel::ver {
-            dev: dev.clone(),
+            dev: dev.into(),
             ch: TxChannel::<ChannelState, DeviceControlMsg::ver>::new(alloc, 0x100)?,
         })
     }
@@ -224,7 +224,7 @@ impl DeviceControlChannel::ver {
 /// Pipe channel to submit WorkQueue execution requests.
 #[versions(AGX)]
 pub(crate) struct PipeChannel {
-    dev: AsahiDevice,
+    dev: AsahiDevRef,
     ch: TxChannel<ChannelState, PipeMsg::ver>,
 }
 
@@ -236,7 +236,7 @@ impl PipeChannel::ver {
         alloc: &mut gpu::KernelAllocators,
     ) -> Result<PipeChannel::ver> {
         Ok(PipeChannel::ver {
-            dev: dev.clone(),
+            dev: dev.into(),
             ch: TxChannel::<ChannelState, PipeMsg::ver>::new(alloc, 0x100)?,
         })
     }
@@ -255,7 +255,7 @@ impl PipeChannel::ver {
 
 /// Firmware Control channel, used for secure cache flush requests.
 pub(crate) struct FwCtlChannel {
-    dev: AsahiDevice,
+    dev: AsahiDevRef,
     ch: TxChannel<FwCtlChannelState, FwCtlMsg>,
 }
 
@@ -268,7 +268,7 @@ impl FwCtlChannel {
         alloc: &mut gpu::KernelAllocators,
     ) -> Result<FwCtlChannel> {
         Ok(FwCtlChannel {
-            dev: dev.clone(),
+            dev: dev.into(),
             ch: TxChannel::<FwCtlChannelState, FwCtlMsg>::new_uncached(alloc, 0x100)?,
         })
     }
@@ -293,7 +293,7 @@ impl FwCtlChannel {
 /// Event channel, used to notify the driver of command completions, GPU faults and errors, and
 /// other events.
 pub(crate) struct EventChannel {
-    dev: AsahiDevice,
+    dev: AsahiDevRef,
     ch: RxChannel<ChannelState, RawEventMsg>,
     mgr: Arc<event::EventManager>,
     gpu: Option<Arc<dyn gpu::GpuManager>>,
@@ -307,7 +307,7 @@ impl EventChannel {
         mgr: Arc<event::EventManager>,
     ) -> Result<EventChannel> {
         Ok(EventChannel {
-            dev: dev.clone(),
+            dev: dev.into(),
             ch: RxChannel::<ChannelState, RawEventMsg>::new(alloc, 0x100)?,
             mgr,
             gpu: None,
@@ -378,7 +378,7 @@ impl EventChannel {
 /// levels), and it also uses a side buffer to actually hold the log messages, only passing around
 /// pointers in the main buffer.
 pub(crate) struct FwLogChannel {
-    dev: AsahiDevice,
+    dev: AsahiDevRef,
     ch: RxChannel<FwLogChannelState, RawFwLogMsg>,
     payload_buf: GpuArray<RawFwLogPayloadMsg>,
 }
@@ -393,7 +393,7 @@ impl FwLogChannel {
         alloc: &mut gpu::KernelAllocators,
     ) -> Result<FwLogChannel> {
         Ok(FwLogChannel {
-            dev: dev.clone(),
+            dev: dev.into(),
             ch: RxChannel::<FwLogChannelState, RawFwLogMsg>::new(alloc, Self::RING_SIZE)?,
             payload_buf: alloc
                 .shared
@@ -467,7 +467,7 @@ impl FwLogChannel {
 }
 
 pub(crate) struct KTraceChannel {
-    dev: AsahiDevice,
+    dev: AsahiDevRef,
     ch: RxChannel<ChannelState, RawKTraceMsg>,
 }
 
@@ -480,7 +480,7 @@ impl KTraceChannel {
         alloc: &mut gpu::KernelAllocators,
     ) -> Result<KTraceChannel> {
         Ok(KTraceChannel {
-            dev: dev.clone(),
+            dev: dev.into(),
             ch: RxChannel::<ChannelState, RawKTraceMsg>::new(alloc, 0x200)?,
         })
     }
@@ -502,7 +502,7 @@ impl KTraceChannel {
 /// Not really implemented other than debug logs yet...
 #[versions(AGX)]
 pub(crate) struct StatsChannel {
-    dev: AsahiDevice,
+    dev: AsahiDevRef,
     ch: RxChannel<ChannelState, RawStatsMsg::ver>,
 }
 
@@ -514,7 +514,7 @@ impl StatsChannel::ver {
         alloc: &mut gpu::KernelAllocators,
     ) -> Result<StatsChannel::ver> {
         Ok(StatsChannel::ver {
-            dev: dev.clone(),
+            dev: dev.into(),
             ch: RxChannel::<ChannelState, RawStatsMsg::ver>::new(alloc, 0x100)?,
         })
     }

drivers/gpu/drm/asahi/driver.rs

@@ -10,6 +10,7 @@ use crate::{debug, file, gem, gpu, hw, regs};
 
 use kernel::device::RawDevice;
 use kernel::macros::vtable;
+use kernel::types::ARef;
 
 /// Driver metadata
 const INFO: drv::DriverInfo = drv::DriverInfo {
@@ -37,6 +38,7 @@ pub(crate) struct AsahiDriver;
 
 /// Convenience type alias for the DRM device type for this driver.
 pub(crate) type AsahiDevice = kernel::drm::device::Device<AsahiDriver>;
+pub(crate) type AsahiDevRef = ARef<AsahiDevice>;
 
 /// DRM Driver implementation for `AsahiDriver`.
 #[vtable]

drivers/gpu/drm/asahi/gpu.rs

@@ -32,7 +32,7 @@ use kernel::{
 
 use crate::alloc::Allocator;
 use crate::debug::*;
-use crate::driver::AsahiDevice;
+use crate::driver::{AsahiDevRef, AsahiDevice};
 use crate::fw::channels::PipeType;
 use crate::fw::types::{U32, U64};
 use crate::{
@@ -190,7 +190,7 @@ pub(crate) struct SequenceIDs {
 #[versions(AGX)]
 #[pin_data]
 pub(crate) struct GpuManager {
-    dev: AsahiDevice,
+    dev: AsahiDevRef,
     cfg: &'static hw::HwConfig,
     dyncfg: hw::DynConfig,
     pub(crate) initdata: fw::types::GpuObject<fw::initdata::InitData::ver>,
@@ -620,7 +620,7 @@ impl GpuManager::ver {
         }))?;
 
         let x = UniqueArc::pin_init(try_pin_init!(GpuManager::ver {
-            dev: dev.clone(),
+            dev: dev.into(),
             cfg,
             dyncfg: *dyncfg,
             initdata: *initdata,

drivers/gpu/drm/asahi/mmu.rs

@@ -181,7 +181,7 @@ const PAGETABLES_SIZE: usize = UAT_PGSZ;
 
 /// Inner data for a Vm instance. This is reference-counted by the outer Vm object.
 struct VmInner {
-    dev: driver::AsahiDevice,
+    dev: driver::AsahiDevRef,
     is_kernel: bool,
     min_va: usize,
     max_va: usize,
@@ -618,7 +618,7 @@ impl UatInner {
 
 /// Top-level UAT manager object
 pub(crate) struct Uat {
-    dev: driver::AsahiDevice,
+    dev: driver::AsahiDevRef,
     cfg: &'static hw::HwConfig,
     pagetables_rgn: UatRegion,
 
@@ -765,15 +765,15 @@ impl io_pgtable::FlushOps for Uat {
 impl Vm {
     /// Create a new virtual memory address space
     fn new(
-        dev: driver::AsahiDevice,
+        dev: &driver::AsahiDevice,
         uat_inner: Arc<UatInner>,
         cfg: &'static hw::HwConfig,
         is_kernel: bool,
         id: u64,
         file_id: u64,
     ) -> Result<Vm> {
         let page_table = AppleUAT::new(
-            &dev,
+            dev,
             io_pgtable::Config {
                 pgsize_bitmap: UAT_PGSZ,
                 ias: if is_kernel { UAT_IAS_KERN } else { UAT_IAS },
@@ -807,7 +807,7 @@ impl Vm {
             file_id,
             inner: Arc::pin_init(new_mutex!(
                 VmInner {
-                    dev,
+                    dev: dev.into(),
                     min_va,
                     max_va,
                     is_kernel,
@@ -1168,14 +1168,7 @@ impl Uat {
 
     /// Creates a new `Vm` linked to this UAT.
     pub(crate) fn new_vm(&self, id: u64, file_id: u64) -> Result<Vm> {
-        Vm::new(
-            self.dev.clone(),
-            self.inner.clone(),
-            self.cfg,
-            false,
-            id,
-            file_id,
-        )
+        Vm::new(&self.dev, self.inner.clone(), self.cfg, false, id, file_id)
     }
 
     /// Creates the reference-counted inner data for a new `Uat` instance.
@@ -1218,16 +1211,16 @@ impl Uat {
         let pagetables_rgn = Self::map_region(dev, c_str!("pagetables"), PAGETABLES_SIZE, true)?;
 
         dev_info!(dev, "MMU: Creating kernel page tables\n");
-        let kernel_lower_vm = Vm::new(dev.clone(), inner.clone(), cfg, false, 1, 0)?;
-        let kernel_vm = Vm::new(dev.clone(), inner.clone(), cfg, true, 0, 0)?;
+        let kernel_lower_vm = Vm::new(dev, inner.clone(), cfg, false, 1, 0)?;
+        let kernel_vm = Vm::new(dev, inner.clone(), cfg, true, 0, 0)?;
 
         dev_info!(dev, "MMU: Kernel page tables created\n");
 
         let ttb0 = kernel_lower_vm.ttb();
         let ttb1 = kernel_vm.ttb();
 
         let uat = Self {
-            dev: dev.clone(),
+            dev: dev.into(),
             cfg,
             pagetables_rgn,
             kernel_vm,

drivers/gpu/drm/asahi/queue/mod.rs

@@ -18,7 +18,7 @@ use kernel::{
 
 use crate::alloc::Allocator;
 use crate::debug::*;
-use crate::driver::AsahiDevice;
+use crate::driver::{AsahiDevRef, AsahiDevice};
 use crate::fw::types::*;
 use crate::gpu::GpuManager;
 use crate::inner_weak_ptr;
@@ -94,7 +94,7 @@ impl SubQueueJob::ver {
 
 #[versions(AGX)]
 pub(crate) struct Queue {
-    dev: AsahiDevice,
+    dev: AsahiDevRef,
     _sched: sched::Scheduler<QueueJob::ver>,
     entity: sched::Entity<QueueJob::ver>,
     vm: mmu::Vm,
@@ -156,7 +156,7 @@ impl dma_fence::FenceOps for JobFence::ver {
 
 #[versions(AGX)]
 pub(crate) struct QueueJob {
-    dev: AsahiDevice,
+    dev: AsahiDevRef,
     vm_bind: mmu::VmBind,
     op_guard: Option<gpu::OpGuard>,
     sj_vtx: Option<SubQueueJob::ver>,
@@ -407,7 +407,7 @@ impl Queue::ver {
         };
 
         let mut ret = Queue::ver {
-            dev: dev.clone(),
+            dev: dev.into(),
             _sched: sched,
             entity,
             vm,