diff options
Diffstat (limited to 'rust/kernel/drm/device.rs')
| -rw-r--r-- | rust/kernel/drm/device.rs | 182 |
1 files changed, 182 insertions, 0 deletions
diff --git a/rust/kernel/drm/device.rs b/rust/kernel/drm/device.rs new file mode 100644 index 000000000000..7651246d38dc --- /dev/null +++ b/rust/kernel/drm/device.rs @@ -0,0 +1,182 @@ +// 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 + 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()) } + } + + #[allow(clippy::missing_safety_doc)] + 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> {} |