// SPDX-License-Identifier: GPL-2.0 OR MIT //! DRM device.//!//! C header: [`include/drm/drm_device.h`](srctree/include/drm/drm_device.h) use crate::{    alloc::allocator::Kmalloc,    bindings, device,    drm::{        self,        driver::AllocImpl, //    },    error::from_err_ptr,    prelude::*,    sync::aref::{        ARef,        AlwaysRefCounted, //    },    types::Opaque,    workqueue::{        HasDelayedWork,        HasWork,        Work,        WorkItem, //    },};use core::{    alloc::Layout,    mem,    ops::Deref,    ptr::{        self,        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::Driver` implementation.////// The device is always reference-counted.////// # Invariants////// `self.dev` is a valid instance of a `struct device`.#[repr(C)]pub struct Device<T: drm::Driver> {    dev: Opaque<bindings::drm_device>,    data: T::Data,} impl<T: drm::Driver> Device<T> {    const VTABLE: bindings::drm_driver = drm_legacy_fields! {        load: None,        open: Some(drm::File::<T::File>::open_callback),        postclose: Some(drm::File::<T::File>::postclose_callback),        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,        fbdev_probe: None,         major: T::INFO.major,        minor: T::INFO.minor,        patchlevel: T::INFO.patchlevel,        name: crate::str::as_char_ptr_in_const_context(T::INFO.name).cast_mut(),        desc: crate::str::as_char_ptr_in_const_context(T::INFO.desc).cast_mut(),         driver_features: drm::driver::FEAT_GEM,        ioctls: T::IOCTLS.as_ptr(),        num_ioctls: T::IOCTLS.len() as i32,        fops: &Self::GEM_FOPS,    };     const GEM_FOPS: bindings::file_operations = drm::gem::create_fops();     /// Create a new `drm::Device` for a `drm::Driver`.    pub fn new(dev: &device::Device, data: impl PinInit<T::Data, Error>) -> Result<ARef<Self>> {        // `__drm_dev_alloc` uses `kmalloc()` to allocate memory, hence ensure a `kmalloc()`        // compatible `Layout`.        let layout = Kmalloc::aligned_layout(Layout::new::<Self>());         // Use a temporary vtable without a `release` callback until `data` is initialized, so        // init failure can release the DRM device without dropping uninitialized fields.        let alloc_vtable = bindings::drm_driver {            release: None,            ..Self::VTABLE        };         // SAFETY:        // - `alloc_vtable` reference remains valid until no longer used,        // - `dev` is valid by its type invarants,        let raw_drm: *mut Self = unsafe {            bindings::__drm_dev_alloc(                dev.as_raw(),                &alloc_vtable,                layout.size(),                mem::offset_of!(Self, dev),            )        }        .cast();        let raw_drm = NonNull::new(from_err_ptr(raw_drm)?).ok_or(ENOMEM)?;         // SAFETY: `raw_drm` is a valid pointer to `Self`, given that `__drm_dev_alloc` was        // successful.        let drm_dev = unsafe { Self::into_drm_device(raw_drm) };         // SAFETY: `raw_drm` is a valid pointer to `Self`.        let raw_data = unsafe { ptr::addr_of_mut!((*raw_drm.as_ptr()).data) };         // SAFETY:        // - `raw_data` is a valid pointer to uninitialized memory.        // - `raw_data` will not move until it is dropped.        unsafe { data.__pinned_init(raw_data) }.inspect_err(|_| {            // SAFETY: `__drm_dev_alloc()` was successful, hence `drm_dev` must be valid and the            // refcount must be non-zero.            unsafe { bindings::drm_dev_put(drm_dev) };        })?;         // SAFETY: `drm_dev` is still private to this function.        unsafe { (*drm_dev).driver = const { &Self::VTABLE } };         // SAFETY: The reference count is one, and now we take ownership of that reference as a        // `drm::Device`.        Ok(unsafe { ARef::from_raw(raw_drm) })    }     pub(crate) fn as_raw(&self) -> *mut bindings::drm_device {        self.dev.get()    }     /// # Safety    ///    /// `ptr` must be a valid pointer to a `struct device` embedded in `Self`.    unsafe fn from_drm_device(ptr: *const bindings::drm_device) -> *mut Self {        // SAFETY: By the safety requirements of this function `ptr` is a valid pointer to a        // `struct drm_device` embedded in `Self`.        unsafe { crate::container_of!(Opaque::cast_from(ptr), Self, dev) }.cast_mut()    }     /// # Safety    ///    /// `ptr` must be a valid pointer to `Self`.    unsafe fn into_drm_device(ptr: NonNull<Self>) -> *mut bindings::drm_device {        // SAFETY: By the safety requirements of this function, `ptr` is a valid pointer to `Self`.        unsafe { &raw mut (*ptr.as_ptr()).dev }.cast()    }     /// 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.    ///    /// Additionally, callers must ensure that the `struct device`, `ptr` is pointing to, is    /// embedded in `Self`.    #[doc(hidden)]    pub unsafe fn from_raw<'a>(ptr: *const bindings::drm_device) -> &'a Self {        // SAFETY: By the safety requirements of this function `ptr` is a valid pointer to a        // `struct drm_device` embedded in `Self`.        let ptr = unsafe { Self::from_drm_device(ptr) };         // SAFETY: `ptr` is valid by the safety requirements of this function.        unsafe { &*ptr.cast() }    }     extern "C" fn release(ptr: *mut bindings::drm_device) {        // SAFETY: `ptr` is a valid pointer to a `struct drm_device` and embedded in `Self`.        let this = unsafe { Self::from_drm_device(ptr) };         // SAFETY:        // - When `release` runs it is guaranteed that there is no further access to `this`.        // - `this` is valid for dropping.        unsafe { core::ptr::drop_in_place(this) };    }} impl<T: drm::Driver> Deref for Device<T> {    type Target = T::Data;     fn deref(&self) -> &Self::Target {        &self.data    }} // SAFETY: DRM device objects are always reference counted and the get/put functions// satisfy the requirements.unsafe impl<T: drm::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: `obj` is a valid pointer to `Self`.        let drm_dev = unsafe { Self::into_drm_device(obj) };         // SAFETY: The safety requirements guarantee that the refcount is non-zero.        unsafe { bindings::drm_dev_put(drm_dev) };    }} impl<T: drm::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::from_raw((*self.as_raw()).dev) }    }} // SAFETY: A `drm::Device` can be released from any thread.unsafe impl<T: drm::Driver> Send for Device<T> {} // SAFETY: A `drm::Device` can be shared among threads because all immutable methods are protected// by the synchronization in `struct drm_device`.unsafe impl<T: drm::Driver> Sync for Device<T> {} impl<T, const ID: u64> WorkItem<ID> for Device<T>where    T: drm::Driver,    T::Data: WorkItem<ID, Pointer = ARef<Device<T>>>,    T::Data: HasWork<Device<T>, ID>,{    type Pointer = ARef<Device<T>>;     fn run(ptr: ARef<Device<T>>) {        T::Data::run(ptr);    }} // SAFETY://// - `raw_get_work` and `work_container_of` return valid pointers by relying on// `T::Data::raw_get_work` and `container_of`. In particular, `T::Data` is// stored inline in `drm::Device`, so the `container_of` call is valid.//// - The two methods are true inverses of each other: given `ptr: *mut// Device<T>`, `raw_get_work` will return a `*mut Work<Device<T>, ID>` through// `T::Data::raw_get_work` and given a `ptr: *mut Work<Device<T>, ID>`,// `work_container_of` will return a `*mut Device<T>` through `container_of`.unsafe impl<T, const ID: u64> HasWork<Device<T>, ID> for Device<T>where    T: drm::Driver,    T::Data: HasWork<Device<T>, ID>,{    unsafe fn raw_get_work(ptr: *mut Self) -> *mut Work<Device<T>, ID> {        // SAFETY: The caller promises that `ptr` points to a valid `Device<T>`.        let data_ptr = unsafe { &raw mut (*ptr).data };         // SAFETY: `data_ptr` is a valid pointer to `T::Data`.        unsafe { T::Data::raw_get_work(data_ptr) }    }     unsafe fn work_container_of(ptr: *mut Work<Device<T>, ID>) -> *mut Self {        // SAFETY: The caller promises that `ptr` points at a `Work` field in        // `T::Data`.        let data_ptr = unsafe { T::Data::work_container_of(ptr) };         // SAFETY: `T::Data` is stored as the `data` field in `Device<T>`.        unsafe { crate::container_of!(data_ptr, Self, data) }    }} // SAFETY: Our `HasWork<T, ID>` implementation returns a `work_struct` that is// stored in the `work` field of a `delayed_work` with the same access rules as// the `work_struct` owing to the bound on `T::Data: HasDelayedWork<Device<T>,// ID>`, which requires that `T::Data::raw_get_work` return a `work_struct` that// is inside a `delayed_work`.unsafe impl<T, const ID: u64> HasDelayedWork<Device<T>, ID> for Device<T>where    T: drm::Driver,    T::Data: HasDelayedWork<Device<T>, ID>,{}