drm/asahi: Adapt to v6.15 + v6.16-rc1 rust / driver-core(rust)

Signed-off-by: Janne Grunau <j@jannau.net>

Author: jannau

drivers/gpu/drm/asahi/buffer.rs

@@ -38,6 +38,7 @@ use crate::fw::types::*;
 use crate::util::*;
 use crate::{alloc, fw, gpu, hw, mmu, slotalloc};
 use core::sync::atomic::Ordering;
+use kernel::new_mutex;
 use kernel::prelude::*;
 use kernel::sync::{Arc, Mutex};
 use kernel::{c_str, static_lock_class};
@@ -398,7 +399,7 @@ impl Buffer::ver {
 
         Ok(Buffer::ver {
             inner: Arc::pin_init(
-                Mutex::new(BufferInner::ver {
+                new_mutex!(BufferInner::ver {
                     info,
                     ualloc,
                     ualloc_priv,

drivers/gpu/drm/asahi/channel.rs

@@ -14,13 +14,11 @@ use crate::fw::channels::*;
 use crate::fw::initdata::{raw, ChannelRing};
 use crate::fw::types::*;
 use crate::{buffer, event, gpu, mem};
-use core::time::Duration;
 use kernel::{
     c_str,
-    delay::coarse_sleep,
     prelude::*,
     sync::Arc,
-    time::{clock, Now},
+    time::{delay::fsleep, Delta, Instant},
 };
 
 pub(crate) use crate::fw::channels::PipeType;
@@ -146,7 +144,7 @@ where
                 );
                 // TODO: block properly on incoming messages?
                 while next_wptr == rptr {
-                    coarse_sleep(Duration::from_millis(8));
+                    fsleep(Delta::from_millis(8));
                     rptr = T::rptr(raw);
                 }
             }
@@ -164,11 +162,12 @@ where
     /// completion of a cache management or invalidation operation synchronously (which
     /// the firmware normally completes fast enough not to be worth sleeping for).
     /// If the poll takes longer than 10ms, this switches to sleeping between polls.
-    pub(crate) fn wait_for(&mut self, wptr: u32, timeout_ms: u64) -> Result {
-        const MAX_FAST_POLL: u64 = 10;
-        let start = clock::KernelTime::now();
-        let timeout_fast = Duration::from_millis(timeout_ms.min(MAX_FAST_POLL));
-        let timeout_slow = Duration::from_millis(timeout_ms);
+    pub(crate) fn wait_for(&mut self, wptr: u32, timeout_ms: i64) -> Result {
+        const MAX_FAST_POLL: i64 = 10;
+        let start = Instant::now();
+        let timeout_ms = timeout_ms.max(1);
+        let timeout_fast = Delta::from_millis(timeout_ms.min(MAX_FAST_POLL));
+        let timeout_slow = Delta::from_millis(timeout_ms);
         self.ring.state.with(|raw, _inner| {
             while start.elapsed() < timeout_fast {
                 if T::rptr(raw) == wptr {
@@ -180,7 +179,7 @@ where
                 if T::rptr(raw) == wptr {
                     return Ok(());
                 }
-                coarse_sleep(Duration::from_millis(5));
+                fsleep(Delta::from_millis(5));
                 mem::sync();
             }
             Err(ETIMEDOUT)
@@ -197,7 +196,7 @@ pub(crate) struct DeviceControlChannel {
 
 #[versions(AGX)]
 impl DeviceControlChannel::ver {
-    const COMMAND_TIMEOUT_MS: u64 = 1000;
+    const COMMAND_TIMEOUT_MS: i64 = 1000;
 
     /// Allocate a new Device Control channel.
     pub(crate) fn new(
@@ -266,7 +265,7 @@ pub(crate) struct FwCtlChannel {
 }
 
 impl FwCtlChannel {
-    const COMMAND_TIMEOUT_MS: u64 = 1000;
+    const COMMAND_TIMEOUT_MS: i64 = 1000;
 
     /// Allocate a new Firmware Control channel.
     pub(crate) fn new(

drivers/gpu/drm/asahi/driver.rs

@@ -3,18 +3,14 @@
 //! Top-level GPU driver implementation.
 
 use kernel::{
-    c_str, drm, drm::drv, drm::ioctl, error::Result, of, platform, prelude::*, sync::Arc,
+    c_str, device::Core, drm, drm::ioctl, error::Result, of, platform, prelude::*, sync::Arc,
 };
 
 use crate::{debug, file, gem, gpu, hw, regs};
 
-use kernel::dma::Device;
 use kernel::macros::vtable;
 use kernel::types::ARef;
 
-/// Convenience type alias for the `device::Data` type for this driver.
-// type DeviceData = device::Data<drv::Registration<AsahiDriver>, regs::Resources, AsahiData>;
-
 /// Holds a reference to the top-level `GpuManager` object.
 // pub(crate) struct AsahiData {
 //     pub(crate) dev: ARef<device::Device>,
@@ -25,45 +21,50 @@ use kernel::types::ARef;
 pub(crate) struct AsahiData {
     #[pin]
     pub(crate) gpu: Arc<dyn gpu::GpuManager>,
-    pub(crate) pdev: platform::Device,
+    pub(crate) pdev: ARef<platform::Device>,
     pub(crate) resources: regs::Resources,
 }
 
+unsafe impl Send for AsahiData {}
+unsafe impl Sync for AsahiData {}
+
 pub(crate) struct AsahiDriver {
-    _reg: drm::drv::Registration<Self>,
-    pub(crate) data: Arc<AsahiData>,
+    #[allow(dead_code)]
+    drm: ARef<drm::Device<Self>>,
 }
 
+unsafe impl Send for AsahiDriver {}
+unsafe impl Sync for AsahiDriver {}
+
 /// Convenience type alias for the DRM device type for this driver.
-pub(crate) type AsahiDevice = kernel::drm::device::Device<AsahiDriver>;
+pub(crate) type AsahiDevice = drm::device::Device<AsahiDriver>;
 pub(crate) type AsahiDevRef = ARef<AsahiDevice>;
 
 /// DRM Driver metadata
-const INFO: drv::DriverInfo = drv::DriverInfo {
+const INFO: drm::driver::DriverInfo = drm::driver::DriverInfo {
     major: 0,
     minor: 0,
     patchlevel: 0,
     name: c_str!("asahi"),
     desc: c_str!("Apple AGX Graphics"),
-    date: c_str!("20220831"),
 };
 
 /// DRM Driver implementation for `AsahiDriver`.
 #[vtable]
-impl drv::Driver for AsahiDriver {
+impl drm::driver::Driver for AsahiDriver {
     /// Our `DeviceData` type, reference-counted
-    type Data = Arc<AsahiData>;
+    type Data = AsahiData;
     /// Our `File` type.
     type File = file::File;
     /// Our `Object` type.
-    type Object = gem::Object;
+    type Object = gem::AsahiObject;
 
-    const INFO: drv::DriverInfo = INFO;
-    const FEATURES: u32 = drv::FEAT_GEM
-        | drv::FEAT_RENDER
-        | drv::FEAT_SYNCOBJ
-        | drv::FEAT_SYNCOBJ_TIMELINE
-        | drv::FEAT_GEM_GPUVA;
+    const INFO: drm::driver::DriverInfo = INFO;
+    const FEATURES: u32 = drm::driver::FEAT_GEM
+        | drm::driver::FEAT_RENDER
+        | drm::driver::FEAT_SYNCOBJ
+        | drm::driver::FEAT_SYNCOBJ_TIMELINE
+        | drm::driver::FEAT_GEM_GPUVA;
 
     kernel::declare_drm_ioctls! {
         (ASAHI_GET_PARAMS,      drm_asahi_get_params,
@@ -138,16 +139,18 @@ impl platform::Driver for AsahiDriver {
     const OF_ID_TABLE: Option<of::IdTable<Self::IdInfo>> = Some(&OF_TABLE);
 
     /// Device probe function.
-    fn probe(pdev: &mut platform::Device, info: Option<&Self::IdInfo>) -> Result<Pin<KBox<Self>>> {
+    fn probe(
+        pdev: &platform::Device<Core>,
+        info: Option<&Self::IdInfo>,
+    ) -> Result<Pin<KBox<Self>>> {
         debug::update_debug_flags();
 
-        let dev = pdev.clone();
-
         dev_info!(pdev.as_ref(), "Probing...\n");
 
         let cfg = info.ok_or(ENODEV)?;
 
-        pdev.dma_set_mask_and_coherent((1 << cfg.uat_oas) - 1)?;
+        pdev.as_ref()
+            .dma_set_mask_and_coherent((1 << cfg.uat_oas) - 1)?;
 
         let res = regs::Resources::new(pdev)?;
 
@@ -160,7 +163,9 @@ impl platform::Driver for AsahiDriver {
         let node = pdev.as_ref().of_node().ok_or(EIO)?;
         let compat: KVec<u32> = node.get_property(c_str!("apple,firmware-compat"))?;
 
-        let drm = drm::device::Device::<AsahiDriver>::new(dev.as_ref())?;
+        let raw_drm = unsafe { drm::device::Device::<AsahiDriver>::new_uninit(pdev.as_ref())? };
+
+        let drm: AsahiDevRef = unsafe { ARef::from_raw(raw_drm) };
 
         let gpu = match (cfg.gpu_gen, cfg.gpu_variant, compat.as_slice()) {
             (hw::GpuGen::G13, _, &[12, 3, 0]) => {
@@ -190,19 +195,18 @@ impl platform::Driver for AsahiDriver {
             }
         };
 
-        let data = Arc::pin_init(
-            try_pin_init!(AsahiData {
-                gpu,
-                pdev: pdev.clone(),
-                resources: res,
-            }),
-            GFP_KERNEL,
-        )?;
+        let data = try_pin_init!(AsahiData {
+            gpu,
+            pdev: pdev.into(),
+            resources: res,
+        });
+
+        let drm = unsafe { AsahiDevice::init_data(raw_drm, data)? };
 
-        data.gpu.init()?;
+        (*drm).gpu.init()?;
 
-        let reg = drm::drv::Registration::new(drm, data.clone(), 0)?;
+        drm::driver::Registration::new_foreign_owned(&drm, pdev.as_ref(), 0)?;
 
-        Ok(KBox::new(Self { _reg: reg, data }, GFP_KERNEL)?.into())
+        Ok(KBox::new(Self { drm }, GFP_KERNEL)?.into())
     }
 }