diff --git a/drivers/gpu/drm/rvkms/plane.rs b/drivers/gpu/drm/rvkms/plane.rs
index 54c4bbda64d8e..d98a1f7bf79e2 100644
--- a/drivers/gpu/drm/rvkms/plane.rs
+++ b/drivers/gpu/drm/rvkms/plane.rs
@@ -20,7 +20,7 @@ pub(crate) struct DriverPlane {
 impl plane::DriverPlane for DriverPlane {
     type Initializer = impl PinInit<Self, Error>;
 
-    type State = RvkmsPlaneState;
+    type State = PlaneState;
 
     type Driver = RvkmsDriver;
 
diff --git a/rust/kernel/drm/kms/plane.rs b/rust/kernel/drm/kms/plane.rs
index 78c8e370b997c..73c285445be63 100644
--- a/rust/kernel/drm/kms/plane.rs
+++ b/rust/kernel/drm/kms/plane.rs
@@ -13,6 +13,7 @@
     sync::{Arc, ArcBorrow},
     init::InPlaceInit,
     offset_of,
+    private::Sealed,
 };
 use core::{
     cell::UnsafeCell,
@@ -62,14 +63,16 @@ pub trait DriverPlane: Send + Sync + Sized {
     /// The parent driver implementation
     type Driver: KmsDriver;
 
-    /// The type for this driver's drm_plane_state implementation
-    type State: DriverPlaneState;
+    /// The full type for this driver's drm_plane_state implementation. Drivers which don't need
+    /// special DRM helpers for their plane states may just use `PlaneState<T>` here, where `T` is
+    /// their private state struct which implements `DriverPlaneState`
+    type State: IntoPlaneState;
 
     /// Create a new plane for this driver
     fn new(device: &Device<Self::Driver>, args: Self::Args) -> Self::Initializer;
 }
 
-impl<T: DriverPlane> crate::private::Sealed for Plane<T> {}
+impl<T: DriverPlane> Sealed for Plane<T> {}
 
 impl<T: DriverPlane> ModeObject for Plane<T> {
     type Driver = T::Driver;
@@ -177,6 +180,70 @@ pub(super) fn raw_mut_ptr(&self) -> *mut bindings::drm_plane {
     unsafe { drop(Box::from_raw(plane as *mut Plane<T>)) };
 }
 
+/// Operations implemented by any base atomic plane state. These are implemented by DRM to provide
+/// wrappers around the generic atomic plane state, along with various plane state helpers.
+///
+/// SAFETY: Incorrect implementation of these methods will result in UB, users should take care to
+/// read through the documentation of each method - especially the provided methods.
+pub unsafe trait IntoPlaneState: Default + Sealed {
+    /// Consume the box for this plane state without dropping its contents, and return a reference
+    /// to it's base plane state to hand off to DRM
+    ///
+    /// Implementors must override this if their data layout does not start with
+    /// `bindings::drm_plane_state`.
+    fn into_raw(self: Box<Self>) -> *mut bindings::drm_plane_state {
+        // Our data layout starts with drm_plane_state
+        Box::into_raw(self).cast()
+    }
+
+    /// Reconstruct the box for this plate state for deallocation
+    ///
+    /// Implementors must override this if their data layout does not start with
+    /// `bindings::drm_plane_state`.
+    unsafe fn from_raw(ptr: *mut bindings::drm_plane_state) -> Box<Self> {
+        // SAFETY: Users of this default promise their data layout starts with drm_plane_state
+        unsafe { Box::from_raw(ptr.cast()) }
+    }
+
+    /// Get a mutable reference to the raw `bindings::drm_plane_state` contained within this type
+    /// that we can pass to DRM
+    fn as_raw_mut(&mut self) -> &mut bindings::drm_plane_state {
+        // SAFETY: Users of this default promise their data layout starts with drm_plane_state
+        unsafe { mem::transmute(self) }
+    }
+
+    /// Get an immutable reference to this type from the given raw `bindings::drm_plane_state`
+    /// pointer
+    ///
+    /// Implementors must override this if their data layout does not start with
+    /// `bindings::drm_plane_state`.
+    ///
+    /// SAFETY: The caller guarantees `ptr` is contained within a valid instance of `Self`
+    unsafe fn ref_from_raw<'a>(ptr: *const bindings::drm_plane_state) -> &'a Self {
+        // SAFETY: Users of this default promise their data layout starts with drm_plane_state
+        unsafe { &*ptr.cast() }
+    }
+
+    /// Get a mutable reference to this type from the given raw `bindings::drm_plane_state` pointer
+    ///
+    /// SAFETY: The caller guarantees `ptr` is contained within a valid instance of `Self`
+    unsafe fn ref_from_raw_mut<'a>(ptr: *mut bindings::drm_plane_state) -> &'a mut Self {
+        // SAFETY: Users of this default promise their data layout starts with drm_plane_state
+        unsafe { &mut (*ptr.cast()) }
+    }
+
+    // Allocate a "duplicated" copy of this state, which usually involves calling DRM's helper
+    // function for this plane state type
+    fn __duplicate_state(&self, plane: *mut bindings::drm_plane) -> Result<Box<Self>>;
+
+    // Call DRM's destroy helper for this type of plane state. Note this only cleans up the base DRM
+    // state struct and does not de-allocate its `Box`.
+    fn __destroy_state(state: *mut bindings::drm_plane_state);
+
+    // Call DRM's reset helper for this type of plane state.
+    fn __reset_state(plane: *mut bindings::drm_plane, state: *mut bindings::drm_plane_state);
+}
+
 #[derive(Default)]
 #[repr(C)]
 pub struct PlaneState<T: DriverPlaneState> {
@@ -190,46 +257,35 @@ pub trait DriverPlaneState: Clone + Default + Sized {
     type Plane: DriverPlane;
 }
 
-impl<T: DriverPlaneState> PlaneState<T> {
-    /// Consume this struct without dropping it, and return a pointer to its base `drm_plane_state`
-    /// which can be handed off to DRM.
-    fn into_raw(self: Box<Self>) -> *mut bindings::drm_plane_state {
-        let this = Box::into_raw(self);
+impl<T: DriverPlaneState> Sealed for PlaneState<T> {}
 
-        unsafe { &mut (*this).state }
-    }
+// SAFETY: Our data layout starts with drm_plane_state
+unsafe impl<T: DriverPlaneState> IntoPlaneState for PlaneState<T> {
+    fn __duplicate_state(&self, plane: *mut bindings::drm_plane) -> Result<Box<Self>> {
+        let mut new: Box<Self> = Box::try_init(try_init!(Self {
+            state: bindings::drm_plane_state { ..Default::default() },
+            inner: self.inner.clone()
+        }))?;
 
-    /// Consume a raw pointer and recover the original `Box<PlaneState<T>>`
-    ///
-    /// SAFETY: Callers must ensure that ptr contains a valid instance of `PlaneState<T>`
-    unsafe fn from_raw(ptr: *mut bindings::drm_plane_state) -> Box<Self> {
-        unsafe { Box::from_raw(ptr as *mut _) }
-    }
+        // SAFETY: FFI call with no special requirements
+        unsafe { bindings::__drm_atomic_helper_plane_duplicate_state(plane, new.as_raw_mut()) };
 
-    /// Obtain a reference back to the `PlaneState<T>`
-    ///
-    /// SAFETY: Callers must ensure that ptr contains a valid instance of `PlaneState<T>`.
-    unsafe fn as_ref<'a>(ptr: *const bindings::drm_plane_state) -> &'a Self {
-        unsafe { &*(ptr as *const _) }
+        Ok(new)
     }
 
-    /// Obtain a mutable reference back to the PlaneState<T>
-    ///
-    /// SAFETY: Callers must ensure that ptr contains a valid instance of `PlaneState<T>`, and that
-    /// no other references to this `PlaneState<T>` exist for the lifetime of this reference
-    unsafe fn as_mut_ref<'a>(ptr: *mut bindings::drm_plane_state) -> &'a mut Self {
-        unsafe { &mut *(ptr as *mut _) }
+    fn __destroy_state(state: *mut bindings::drm_plane_state) {
+        // SAFETY: This would not be called without a plane state to destroy
+        unsafe { bindings::__drm_atomic_helper_plane_destroy_state(state) };
     }
 
-    /// Obtain a mutable pointer to the base plane state, for use in FFI calls
-    unsafe fn as_mut_ptr(&mut self) -> *mut bindings::drm_plane_state {
-        &mut self.state
+    fn __reset_state(plane: *mut bindings::drm_plane, state: *mut bindings::drm_plane_state) {
+        unsafe { bindings::__drm_atomic_helper_plane_reset(plane, state) }
     }
 }
 
 unsafe impl Zeroable for bindings::drm_plane_state { }
 
-unsafe extern "C" fn atomic_duplicate_state_callback<T: DriverPlaneState>(
+unsafe extern "C" fn atomic_duplicate_state_callback<T: IntoPlaneState>(
     plane: *mut bindings::drm_plane
 ) -> *mut bindings::drm_plane_state
 {
@@ -240,55 +296,38 @@ unsafe impl Zeroable for bindings::drm_plane_state { }
         return null_mut();
     }
 
-    // SAFETY: We just verified that `state` is non-null, and we're guaranteed by our bindings that
-    // `state` is of type `PlaneState<T>`.
-    let state = unsafe { PlaneState::<T>::as_ref(state) };
-
-    let mut new: Result<Box<PlaneState<T>>> = Box::try_init(try_init!(PlaneState::<T> {
-        state: bindings::drm_plane_state { ..Default::default() },
-        inner: state.inner.clone()
-    }));
-
-    if let Ok(mut new) = new {
-        // SAFETY: Just a lil' FFI call, nothing special here
-        unsafe { bindings::__drm_atomic_helper_plane_duplicate_state(plane, new.as_mut_ptr()) };
-
-        new.into_raw()
-    } else {
-        null_mut()
-    }
+    // SAFETY: We just checked that the state is non-null, and we're guaranteed this operation is
+    // safe via type invariance
+    unsafe { T::ref_from_raw(state) }.__duplicate_state(plane).map_or(null_mut(), T::into_raw)
 }
 
-unsafe extern "C" fn atomic_destroy_state_callback<T: DriverPlaneState>(
+unsafe extern "C" fn atomic_destroy_state_callback<T: IntoPlaneState>(
     _plane: *mut bindings::drm_plane,
-    plane_state: *mut bindings::drm_plane_state
+    state: *mut bindings::drm_plane_state
 ) {
-    // SAFETY: This callback wouldn't be called unless there a plane state to destroy
-    unsafe { bindings::__drm_atomic_helper_plane_destroy_state(plane_state) };
+    T::__destroy_state(state);
 
-    // SAFETY: We're guaranteed by type invariants that plane_state is of type PlaneState<T>, and
-    // since this is the destructor callback for DRM - we're guaranteed to hold the only remaining
-    // reference to this state
-    unsafe { drop(PlaneState::<T>::from_raw(plane_state)) };
+    // SAFETY: We're guaranteed by type invariance that state of type T, and __destroy_state() does
+    // not perform any deallocations
+    drop(unsafe { T::from_raw(state) });
 }
 
-unsafe extern "C" fn plane_reset_callback<T: DriverPlaneState>(
+unsafe extern "C" fn plane_reset_callback<T: IntoPlaneState>(
     plane: *mut bindings::drm_plane,
 ) {
-    // SAFETY: The only entrypoint to this function lives in `plane` so it must be valid, and
+    // SAFETY: The only entrypoint to this function lives in `plane` so it must be valid
     let state = unsafe { (*plane).state };
     if !state.is_null() {
-        // SAFETY: We're guaranteed by type invariance that this plane's state is of type
-        // DriverPlaneState<T>
+        // SAFETY: We're guaranteed by type invariance that this planes state is of type T
         unsafe { atomic_destroy_state_callback::<T>(plane, state) }
     }
 
     // Unfortunately, this is the best we can do at the moment as this FFI callback was mistakenly
     // presumed to be infallible :(
-    let new = Box::try_new(PlaneState::<T>::default()).expect("Blame the API, sorry!");
+    let new = Box::try_new(T::default()).expect("Blame the API, sorry!");
 
-    // SAFETY: DRM takes ownership of the state from here and assigns it to the plane
-    unsafe { bindings::__drm_atomic_helper_plane_reset(plane, new.into_raw()) };
+    // DRM takes ownership of the state from here, resets it, and then assigns it to the plane
+    T::__reset_state(plane, new.into_raw());
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
