drm/asahi: Switch to the kernel crate Zeroable trait

Signed-off-by: Asahi Lina <[email protected]>

Author: hoshinolina

drivers/gpu/drm/asahi/alloc.rs

@@ -16,7 +16,7 @@ use kernel::{c_str, drm::mm, error::Result, prelude::*, str::CString, sync::Lock
 
 use crate::debug::*;
 use crate::driver::AsahiDevice;
-use crate::fw::types::Zeroed;
+use crate::fw::types::Zeroable;
 use crate::mmu;
 use crate::object::{GpuArray, GpuObject, GpuOnlyArray, GpuStruct, GpuWeakPointer};
 
@@ -244,7 +244,7 @@ pub(crate) trait Allocator {
         &mut self,
     ) -> Result<GpuObject<T, GenericAlloc<T, Self::Raw>>>
     where
-        for<'a> <T as GpuStruct>::Raw<'a>: Default + Zeroed,
+        for<'a> <T as GpuStruct>::Raw<'a>: Default + Zeroable,
     {
         GpuObject::<T, GenericAlloc<T, Self::Raw>>::new_default(self.alloc_object()?)
     }

drivers/gpu/drm/asahi/channel.rs

@@ -22,7 +22,7 @@ pub(crate) use crate::fw::channels::PipeType;
 /// A receive (FW->driver) channel.
 pub(crate) struct RxChannel<T: RxChannelState, U: Copy + Default>
 where
-    for<'a> <T as GpuStruct>::Raw<'a>: Debug + Default + Zeroed,
+    for<'a> <T as GpuStruct>::Raw<'a>: Debug + Default + Zeroable,
 {
     ring: ChannelRing<T, U>,
     // FIXME: needs feature(generic_const_exprs)
@@ -33,7 +33,7 @@ where
 
 impl<T: RxChannelState, U: Copy + Default> RxChannel<T, U>
 where
-    for<'a> <T as GpuStruct>::Raw<'a>: Debug + Default + Zeroed,
+    for<'a> <T as GpuStruct>::Raw<'a>: Debug + Default + Zeroable,
 {
     /// Allocates a new receive channel with a given message count.
     pub(crate) fn new(alloc: &mut gpu::KernelAllocators, count: usize) -> Result<RxChannel<T, U>> {
@@ -87,7 +87,7 @@ where
 /// A transmit (driver->FW) channel.
 pub(crate) struct TxChannel<T: TxChannelState, U: Copy + Default>
 where
-    for<'a> <T as GpuStruct>::Raw<'a>: Debug + Default + Zeroed,
+    for<'a> <T as GpuStruct>::Raw<'a>: Debug + Default + Zeroable,
 {
     ring: ChannelRing<T, U>,
     wptr: u32,
@@ -96,7 +96,7 @@ where
 
 impl<T: TxChannelState, U: Copy + Default> TxChannel<T, U>
 where
-    for<'a> <T as GpuStruct>::Raw<'a>: Debug + Default + Zeroed,
+    for<'a> <T as GpuStruct>::Raw<'a>: Debug + Default + Zeroable,
 {
     /// Allocates a new cached transmit channel with a given message count.
     pub(crate) fn new(alloc: &mut gpu::KernelAllocators, count: usize) -> Result<TxChannel<T, U>> {

drivers/gpu/drm/asahi/float.rs

@@ -23,12 +23,14 @@
 //! related to slightly non-compliant rounding.
 
 use core::ops;
-use kernel::{of, prelude::*};
+use kernel::{init::Zeroable, of, prelude::*};
 
 /// An IEEE754-compatible floating point number implemented in software.
 #[derive(Default, Debug, Copy, Clone)]
 pub(crate) struct F32(u32);
 
+unsafe impl Zeroable for F32 {}
+
 #[derive(Default, Debug, Copy, Clone)]
 struct F32U {
     sign: bool,

drivers/gpu/drm/asahi/fw/channels.rs

@@ -34,7 +34,7 @@ pub(crate) mod raw {
 
 pub(crate) trait RxChannelState: GpuStruct + Debug + Default
 where
-    for<'a> <Self as GpuStruct>::Raw<'a>: Default + Zeroed,
+    for<'a> <Self as GpuStruct>::Raw<'a>: Default + Zeroable,
 {
     const SUB_CHANNELS: usize;
 

drivers/gpu/drm/asahi/fw/types.rs

@@ -14,6 +14,7 @@ pub(crate) use ::alloc::boxed::Box;
 pub(crate) use core::fmt::Debug;
 pub(crate) use core::marker::PhantomData;
 pub(crate) use core::sync::atomic::{AtomicI32, AtomicU32, AtomicU64};
+pub(crate) use kernel::init::Zeroable;
 pub(crate) use kernel::macros::versions;
 
 // Make the trait visible
@@ -53,7 +54,7 @@ pub(crate) struct FwStamp(pub(crate) AtomicU32);
 #[repr(C, packed(1))]
 pub(crate) struct U64(pub(crate) u64);
 
-unsafe impl Zeroed for U64 {}
+unsafe impl Zeroable for U64 {}
 
 impl fmt::Debug for U64 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -70,7 +71,7 @@ impl fmt::Debug for U64 {
 #[repr(C, packed(1))]
 pub(crate) struct U32(pub(crate) u32);
 
-unsafe impl Zeroed for U32 {}
+unsafe impl Zeroable for U32 {}
 
 impl fmt::Debug for U32 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -79,16 +80,6 @@ impl fmt::Debug for U32 {
     }
 }
 
-unsafe impl Zeroed for u8 {}
-unsafe impl Zeroed for u16 {}
-unsafe impl Zeroed for u32 {}
-unsafe impl Zeroed for u64 {}
-unsafe impl Zeroed for i8 {}
-unsafe impl Zeroed for i16 {}
-unsafe impl Zeroed for i32 {}
-unsafe impl Zeroed for i64 {}
-unsafe impl Zeroed for F32 {}
-
 /// Create a dummy `Debug` implementation, for when we need it but it's too painful to write by
 /// hand or not very useful.
 #[macro_export]
@@ -102,46 +93,32 @@ macro_rules! no_debug {
     };
 }
 
-/// Types which can be safely initialized with an all-zero bit pattern.
-///
-/// See: https://github.com/rust-lang/rfcs/issues/2626
-///
-/// # Safety
-///
-/// This trait must only be implemented if a type only contains primitive types which can be
-/// zero-initialized, FFI structs intended to be zero-initialized, or other types which impl Zeroed.
-pub(crate) unsafe trait Zeroed: Default {
-    fn zeroed() -> Self {
-        // SAFETY: The user is responsible for ensuring this is safe.
-        unsafe { core::mem::zeroed() }
-    }
-}
-
-/// Implement Zeroed for a given type (and Default along with it).
+/// Implement Zeroable for a given type (and Default along with it).
 ///
 /// # Safety
 ///
 /// This macro must only be used if a type only contains primitive types which can be
-/// zero-initialized, FFI structs intended to be zero-initialized, or other types which impl Zeroed.
+/// zero-initialized, FFI structs intended to be zero-initialized, or other types which
+/// impl Zeroable.
 #[macro_export]
 macro_rules! default_zeroed {
     (<$($lt:lifetime),*>, $type:ty) => {
         impl<$($lt),*> Default for $type {
             fn default() -> $type {
-                Zeroed::zeroed()
+                ::kernel::init::Zeroable::zeroed()
             }
         }
         // SAFETY: The user is responsible for ensuring this is safe.
-        unsafe impl<$($lt),*> Zeroed for $type {}
+        unsafe impl<$($lt),*> ::kernel::init::Zeroable for $type {}
     };
     ($type:ty) => {
         impl Default for $type {
             fn default() -> $type {
-                Zeroed::zeroed()
+                ::kernel::init::Zeroable::zeroed()
             }
         }
         // SAFETY: The user is responsible for ensuring this is safe.
-        unsafe impl Zeroed for $type {}
+        unsafe impl ::kernel::init::Zeroable for $type {}
     };
 }
 
@@ -151,11 +128,11 @@ macro_rules! default_zeroed {
 pub(crate) struct Pad<const N: usize>([u8; N]);
 
 /// SAFETY: Primitive type, safe to zero-init.
-unsafe impl<const N: usize> Zeroed for Pad<N> {}
+unsafe impl<const N: usize> Zeroable for Pad<N> {}
 
 impl<const N: usize> Default for Pad<N> {
     fn default() -> Self {
-        Zeroed::zeroed()
+        Zeroable::zeroed()
     }
 }
 
@@ -165,7 +142,7 @@ impl<const N: usize> fmt::Debug for Pad<N> {
     }
 }
 
-/// A convenience type for a fixed-sized array with Default/Zeroed impls.
+/// A convenience type for a fixed-sized array with Default/Zeroable impls.
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub(crate) struct Array<const N: usize, T>([T; N]);
@@ -176,12 +153,12 @@ impl<const N: usize, T> Array<N, T> {
     }
 }
 
-// SAFETY: Arrays of Zeroed values can be safely Zeroed.
-unsafe impl<const N: usize, T: Zeroed> Zeroed for Array<N, T> {}
+// SAFETY: Arrays of Zeroable values can be safely Zeroable.
+unsafe impl<const N: usize, T: Zeroable> Zeroable for Array<N, T> {}
 
-impl<const N: usize, T: Zeroed> Default for Array<N, T> {
+impl<const N: usize, T: Zeroable> Default for Array<N, T> {
     fn default() -> Self {
-        Zeroed::zeroed()
+        Zeroable::zeroed()
     }
 }
 
@@ -224,11 +201,12 @@ impl<const N: usize, T: Sized + fmt::Debug> fmt::Debug for Array<N, T> {
 #[macro_export]
 macro_rules! trivial_gpustruct {
     ($type:ident) => {
-        #[derive(Debug, Default)]
+        #[derive(Debug)]
         pub(crate) struct $type {}
 
         impl GpuStruct for $type {
             type Raw<'a> = raw::$type;
         }
+        $crate::default_zeroed!($type);
     };
 }

drivers/gpu/drm/asahi/object.rs

@@ -57,7 +57,7 @@ use core::{mem, ptr, slice};
 
 use crate::alloc::Allocation;
 use crate::debug::*;
-use crate::fw::types::Zeroed;
+use crate::fw::types::Zeroable;
 
 const DEBUG_CLASS: DebugFlags = DebugFlags::Object;
 
@@ -450,13 +450,13 @@ where
 
 impl<T: GpuStruct + Default, U: Allocation<T>> GpuObject<T, U>
 where
-    for<'a> <T as GpuStruct>::Raw<'a>: Default + Zeroed,
+    for<'a> <T as GpuStruct>::Raw<'a>: Default + Zeroable,
 {
     /// Create a new GpuObject with default data. `T` must implement `Default` and `T::Raw` must
-    /// implement `Zeroed`, since the GPU-side memory is initialized by zeroing.
+    /// implement `Zeroable`, since the GPU-side memory is initialized by zeroing.
     pub(crate) fn new_default(alloc: U) -> Result<Self> {
         GpuObject::<T, U>::new_inplace(alloc, Default::default(), |_inner, raw| {
-            // SAFETY: `raw` is valid here, and `T::Raw` implements `Zeroed`.
+            // SAFETY: `raw` is valid here, and `T::Raw` implements `Zeroable`.
             Ok(unsafe {
                 ptr::write_bytes(raw, 0, 1);
                 (*raw).assume_init_mut()

drivers/gpu/drm/asahi/place.rs

@@ -30,9 +30,9 @@
 ///
 /// The macro supports most Rust initialization syntax including type paths, generic arguments,
 /// and nested structures. Nested structures are themselves initialized in-place field by field.
-/// `..Default::default()` is supported, but this macro converts it to `..Zeroed::zeroed()`, as it
+/// `..Default::default()` is supported, but this macro converts it to `..Zeroable::zeroed()`, as it
 /// initializes those structs by zero-initializing the underlying memory. Usage of
-/// `..Default::default()` with a type not implementing `Zeroed` will result in a compile error.
+/// `..Default::default()` with a type not implementing `Zeroable` will result in a compile error.
 ///
 /// Usage:
 /// ```
@@ -81,11 +81,11 @@ macro_rules! place {
     // Zero-initialize structure if the initializer ends in ..default::Default()
     (@STRUCT_ZERO $ptr:ident, {$($typ_init:tt)*} { $($f:ident $(: $v:expr)?),* $(,)? }) => {};
     (@STRUCT_ZERO $ptr:ident, {$($typ_init:tt)*} { $($($f:ident $(: $v:expr)?),*,)? ..Default::default() }) => {{
-        // Check that the structure actually implements Zeroed
+        // Check that the structure actually implements Zeroable
         const _: () = {
             fn _check_default() {
                 let _ = $($typ_init)* {
-                    ..Zeroed::zeroed()
+                    ..Zeroable::zeroed()
                 };
             }
         };
@@ -103,7 +103,7 @@ macro_rules! place {
                     $f $(: $v)?
                 ),*
                 ,)?
-                ..Zeroed::zeroed()
+                ..Zeroable::zeroed()
             };
         } else {
             {$($body)*}