Implement the abstraction for a `struct drm_device`.
A `drm::device::Device` creates a static const `struct drm_driver` filled
with the data from the `drm::drv::Driver` trait implementation of the
actual driver creating the `drm::device::Device`.
Co-developed-by: Asahi Lina <lina@xxxxxxxxxxxxx>
Signed-off-by: Asahi Lina <lina@xxxxxxxxxxxxx>
Signed-off-by: Danilo Krummrich <dakr@xxxxxxxxxx>
---
rust/bindings/bindings_helper.h | 1 +
rust/kernel/drm/device.rs | 180 ++++++++++++++++++++++++++++++++
rust/kernel/drm/mod.rs | 1 +
3 files changed, 182 insertions(+)
create mode 100644 rust/kernel/drm/device.rs
diff --git a/rust/bindings/bindings_helper.h b/rust/bindings/bindings_helper.h
index dc19cb789536..1d12ee7d3c97 100644
--- a/rust/bindings/bindings_helper.h
+++ b/rust/bindings/bindings_helper.h
@@ -6,6 +6,7 @@
* Sorted alphabetically.
*/
+#include <drm/drm_device.h>
#include <drm/drm_drv.h>
#include <drm/drm_ioctl.h>
#include <kunit/test.h>
diff --git a/rust/kernel/drm/device.rs b/rust/kernel/drm/device.rs
new file mode 100644
index 000000000000..c62516f79221
--- /dev/null
+++ b/rust/kernel/drm/device.rs
@@ -0,0 +1,180 @@
+// SPDX-License-Identifier: GPL-2.0 OR MIT
+
+//! DRM device.
+//!
+//! C header: [`include/linux/drm/drm_device.h`](srctree/include/linux/drm/drm_device.h)
+
+use crate::{
+ bindings, device, drm,
+ drm::drv::AllocImpl,
+ error::code::*,
+ error::from_err_ptr,
+ error::Result,
+ types::{ARef, AlwaysRefCounted, ForeignOwnable, Opaque},
+};
+use core::{ffi::c_void, marker::PhantomData, ptr::NonNull};
+
+#[cfg(CONFIG_DRM_LEGACY)]
+macro_rules! drm_legacy_fields {
+ ( $($field:ident: $val:expr),* $(,)? ) => {
+ bindings::drm_driver {
+ $( $field: $val ),*,
+ firstopen: None,
+ preclose: None,
+ dma_ioctl: None,
+ dma_quiescent: None,
+ context_dtor: None,
+ irq_handler: None,
+ irq_preinstall: None,
+ irq_postinstall: None,
+ irq_uninstall: None,
+ get_vblank_counter: None,
+ enable_vblank: None,
+ disable_vblank: None,
+ dev_priv_size: 0,
+ }
+ }
+}
+
+#[cfg(not(CONFIG_DRM_LEGACY))]
+macro_rules! drm_legacy_fields {
+ ( $($field:ident: $val:expr),* $(,)? ) => {
+ bindings::drm_driver {
+ $( $field: $val ),*
+ }
+ }
+}
+
+/// A typed DRM device with a specific `drm::drv::Driver` implementation. The device is always
+/// reference-counted.
+///
+/// # Invariants
+///
+/// `drm_dev_release()` can be called from any non-atomic context.
+#[repr(transparent)]
+pub struct Device<T: drm::drv::Driver>(Opaque<bindings::drm_device>, PhantomData<T>);
+
+impl<T: drm::drv::Driver> Device<T> {
+ const VTABLE: bindings::drm_driver = drm_legacy_fields! {
+ load: None,
+ open: None, // TODO: File abstraction
+ postclose: None, // TODO: File abstraction
+ lastclose: None,
+ unload: None,
+ release: Some(Self::release),
+ master_set: None,
+ master_drop: None,
+ debugfs_init: None,
+ gem_create_object: T::Object::ALLOC_OPS.gem_create_object,
+ prime_handle_to_fd: T::Object::ALLOC_OPS.prime_handle_to_fd,
+ prime_fd_to_handle: T::Object::ALLOC_OPS.prime_fd_to_handle,
+ gem_prime_import: T::Object::ALLOC_OPS.gem_prime_import,
+ gem_prime_import_sg_table: T::Object::ALLOC_OPS.gem_prime_import_sg_table,
+ dumb_create: T::Object::ALLOC_OPS.dumb_create,
+ dumb_map_offset: T::Object::ALLOC_OPS.dumb_map_offset,
+ show_fdinfo: None,
+
+ major: T::INFO.major,
+ minor: T::INFO.minor,
+ patchlevel: T::INFO.patchlevel,
+ name: T::INFO.name.as_char_ptr() as *mut _,
+ desc: T::INFO.desc.as_char_ptr() as *mut _,
+ date: T::INFO.date.as_char_ptr() as *mut _,
+
+ driver_features: T::FEATURES,
+ ioctls: T::IOCTLS.as_ptr(),
+ num_ioctls: T::IOCTLS.len() as i32,
+ fops: core::ptr::null_mut() as _,
+ };
+
+ /// Create a new `drm::device::Device` for a `drm::drv::Driver`.
+ pub fn new(dev: &device::Device, data: T::Data) -> Result<ARef<Self>> {
+ // SAFETY: `dev` is valid by its type invarants; `VTABLE`, as a `const` is pinned to the
+ // read-only section of the compilation.
+ let raw_drm = unsafe { bindings::drm_dev_alloc(&Self::VTABLE, dev.as_raw()) };
+ let raw_drm = NonNull::new(from_err_ptr(raw_drm)? as *mut _).ok_or(ENOMEM)?;
+
+ let data_ptr = <T::Data as ForeignOwnable>::into_foreign(data);
+
+ // SAFETY: The reference count is one, and now we take ownership of that reference as a
+ // drm::device::Device.
+ let drm = unsafe { ARef::<Self>::from_raw(raw_drm) };
+
+ // SAFETY: Safe as we set `dev_private` once at device creation.
+ unsafe { drm.set_raw_data(data_ptr) };
+
+ Ok(drm)
+ }
+
+ pub(crate) fn as_raw(&self) -> *mut bindings::drm_device {
+ self.0.get()
+ }
+
+ /// Not intended to be called externally, except via declare_drm_ioctls!()
+ ///
+ /// # Safety
+ ///
+ /// Callers must ensure that `ptr` is valid, non-null, and has a non-zero reference count,
+ /// i.e. it must be ensured that the reference count of the C `struct drm_device` `ptr` points
+ /// to can't drop to zero, for the duration of this function call and the entire duration when
+ /// the returned reference exists.
+ #[doc(hidden)]
+ pub unsafe fn borrow<'a>(ptr: *const bindings::drm_device) -> &'a Self {
+ // SAFETY: Safe by the safety requirements of this function.
+ unsafe { &*ptr.cast() }
+ }
+
+ pub(crate) fn raw_data(&self) -> *const c_void {
+ // SAFETY: `self` is guaranteed to hold a valid `bindings::drm_device` pointer.
+ unsafe { *self.as_raw() }.dev_private
+ }
+
+ // SAFETY: Must be called only once after device creation.
+ unsafe fn set_raw_data(&self, ptr: *const c_void) {
+ // SAFETY: Safe as by the safety precondition.
+ unsafe { &mut *self.as_raw() }.dev_private = ptr as _;
+ }
+
+ /// Returns a borrowed reference to the user data associated with this Device.
+ pub fn data(&self) -> <T::Data as ForeignOwnable>::Borrowed<'_> {
+ // SAFETY: `dev_private` is always set at device creation.
+ unsafe { T::Data::borrow(self.raw_data()) }
+ }
+
+ unsafe extern "C" fn release(drm: *mut bindings::drm_device) {
+ // SAFETY: Guaranteed to be a valid pointer to a `struct drm_device`.
+ let drm = unsafe { Self::borrow(drm) };
+
+ // SAFETY: `Self::data` is always converted and set on device creation.
+ unsafe { <T::Data as ForeignOwnable>::from_foreign(drm.raw_data()) };
+ }
+}
+
+// SAFETY: DRM device objects are always reference counted and the get/put functions
+// satisfy the requirements.
+unsafe impl<T: drm::drv::Driver> AlwaysRefCounted for Device<T> {
+ fn inc_ref(&self) {
+ // SAFETY: The existence of a shared reference guarantees that the refcount is non-zero.
+ unsafe { bindings::drm_dev_get(self.as_raw()) };
+ }
+
+ unsafe fn dec_ref(obj: NonNull<Self>) {
+ // SAFETY: The safety requirements guarantee that the refcount is non-zero.
+ unsafe { bindings::drm_dev_put(obj.cast().as_ptr()) };
+ }
+}
+
+impl<T: drm::drv::Driver> AsRef<device::Device> for Device<T> {
+ fn as_ref(&self) -> &device::Device {
+ // SAFETY: `bindings::drm_device::dev` is valid as long as the DRM device itself is valid,
+ // which is guaranteed by the type invariant.
+ unsafe { device::Device::as_ref((*self.as_raw()).dev) }
+ }
+}
+
+// SAFETY: As by the type invariant `Device` can be sent to any thread.
+unsafe impl<T: drm::drv::Driver> Send for Device<T> {}
+
+// SAFETY: `Device` can be shared among threads because all immutable methods are protected by the
+// synchronization in `struct drm_device`.
+unsafe impl<T: drm::drv::Driver> Sync for Device<T> {}
diff --git a/rust/kernel/drm/mod.rs b/rust/kernel/drm/mod.rs
index d987c56b3cec..69376b3c6db9 100644
--- a/rust/kernel/drm/mod.rs
+++ b/rust/kernel/drm/mod.rs
@@ -2,5 +2,6 @@
//! DRM subsystem abstractions.
+pub mod device;
pub mod drv;
pub mod ioctl;
--
2.45.1
