| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <F3853912-2C1C-4F9B-89B0-3168689F35B3@nvidia.com>
Date: Mon, 6 Oct 2025 17:56:11 +0000
From: Edwin Peer <epeer@...dia.com>
To: Joel Fernandes <joelagnelf@...dia.com>
CC: "linux-kernel@...r.kernel.org" <linux-kernel@...r.kernel.org>,
"rust-for-linux@...r.kernel.org" <rust-for-linux@...r.kernel.org>,
"dri-devel@...ts.freedesktop.org" <dri-devel@...ts.freedesktop.org>,
"dakr@...nel.org" <dakr@...nel.org>, Alexandre Courbot <acourbot@...dia.com>,
Alistair Popple <apopple@...dia.com>, Miguel Ojeda <ojeda@...nel.org>, Alex
Gaynor <alex.gaynor@...il.com>, Boqun Feng <boqun.feng@...il.com>, Gary Guo
<gary@...yguo.net>, "bjorn3_gh@...tonmail.com" <bjorn3_gh@...tonmail.com>,
Benno Lossin <lossin@...nel.org>, Andreas Hindborg <a.hindborg@...nel.org>,
Alice Ryhl <aliceryhl@...gle.com>, Trevor Gross <tmgross@...ch.edu>, David
Airlie <airlied@...il.com>, Simona Vetter <simona@...ll.ch>, Maarten
Lankhorst <maarten.lankhorst@...ux.intel.com>, Maxime Ripard
<mripard@...nel.org>, Thomas Zimmermann <tzimmermann@...e.de>, John Hubbard
<jhubbard@...dia.com>, Timur Tabi <ttabi@...dia.com>,
"joel@...lfernandes.org" <joel@...lfernandes.org>, Elle Rhumsaa
<elle@...thered-steel.dev>, Yury Norov <yury.norov@...il.com>, Daniel Almeida
<daniel.almeida@...labora.com>, Andrea Righi <arighi@...dia.com>,
"nouveau@...ts.freedesktop.org" <nouveau@...ts.freedesktop.org>
Subject: Re: [PATCH v6 1/5] nova-core: bitfield: Move bitfield-specific code
from register! into new macro
Hi Joel,
I recognize that this patch is intended to be a code move, but I’m seeing this code for the first time, hence the comments regarding the content below.
On Oct 3, 2025, at 8:47 AM, Joel Fernandes <joelagnelf@...dia.com> wrote:
> The bitfield-specific into new macro. This will be used to define
> structs with bitfields, similar to C language.
>
> Reviewed-by: Elle Rhumsaa <elle@...thered-steel.dev>
> Reviewed-by: Alexandre Courbot <acourbot@...dia.com>
> Signed-off-by: Joel Fernandes <joelagnelf@...dia.com>
> ---
> drivers/gpu/nova-core/bitfield.rs | 316 +++++++++++++++++++++++++++
> drivers/gpu/nova-core/nova_core.rs | 3 +
> drivers/gpu/nova-core/regs/macros.rs | 259 +---------------------
> 3 files changed, 329 insertions(+), 249 deletions(-)
> create mode 100644 drivers/gpu/nova-core/bitfield.rs
>
> diff --git a/drivers/gpu/nova-core/bitfield.rs b/drivers/gpu/nova-core/bitfield.rs
> new file mode 100644
> index 000000000000..dd0ef2016ff8
> --- /dev/null
> +++ b/drivers/gpu/nova-core/bitfield.rs
> @@ -0,0 +1,316 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +//! Bitfield library for Rust structures
> +//!
> +//! Support for defining bitfields in Rust structures. Also used by the [`register!`] macro.
> +
> +/// Defines a struct with accessors to access bits within an inner unsigned integer.
> +///
> +/// # Syntax
> +///
> +/// ```rust
> +/// use nova_core::bitfield;
> +///
> +/// #[derive(Debug, Clone, Copy, Default)]
> +/// enum Mode {
> +/// #[default]
> +/// Low = 0,
> +/// High = 1,
> +/// Auto = 2,
> +/// }
> +///
> +/// impl TryFrom<u8> for Mode {
> +/// type Error = u8;
> +/// fn try_from(value: u8) -> Result<Self, Self::Error> {
> +/// match value {
> +/// 0 => Ok(Mode::Low),
> +/// 1 => Ok(Mode::High),
> +/// 2 => Ok(Mode::Auto),
> +/// _ => Err(value),
> +/// }
> +/// }
> +/// }
> +///
> +/// impl From<Mode> for u32 {
> +/// fn from(mode: Mode) -> u32 {
> +/// mode as u32
> +/// }
> +/// }
Is there a reason for the asymmetry in the From conversions for the user facing enum type? Here we have u8 in the one direction and u32 in the other. It looks like the latter is required by the use of u32:from() in the set_<field>() accessor, but the macro would be more ergonomic if it handled the necessary upcast conversions internally too.
> +///
> +/// #[derive(Debug, Clone, Copy, Default)]
> +/// enum State {
> +/// #[default]
> +/// Inactive = 0,
> +/// Active = 1,
> +/// }
> +///
> +/// impl From<bool> for State {
> +/// fn from(value: bool) -> Self {
> +/// if value { State::Active } else { State::Inactive }
> +/// }
> +/// }
> +///
> +/// impl From<State> for u32 {
> +/// fn from(state: State) -> u32 {
> +/// state as u32
> +/// }
> +/// }
Similarly for bool vs u32.
> +///
> +/// bitfield! {
> +/// struct ControlReg {
> +/// 3:0 mode as u8 ?=> Mode;
> +/// 7:7 state as bool => State;
> +/// }
> +/// }
> +/// ```
> +///
> +/// This generates a struct with:
> +/// - Field accessors: `mode()`, `state()`, etc.
> +/// - Field setters: `set_mode()`, `set_state()`, etc. (supports chaining with builder pattern).
> +/// - Debug and Default implementations.
> +///
> +/// Fields are defined as follows:
> +///
> +/// - `as <type>` simply returns the field value casted to <type>, typically `u32`, `u16`, `u8` or
> +/// `bool`. Note that `bool` fields must have a range of 1 bit.
> +/// - `as <type> => <into_type>` calls `<into_type>`'s `From::<<type>>` implementation and returns
> +/// the result.
> +/// - `as <type> ?=> <try_into_type>` calls `<try_into_type>`'s `TryFrom::<<type>>` implementation
> +/// and returns the result. This is useful with fields for which not all values are valid.
> +macro_rules! bitfield {
> + // Main entry point - defines the bitfield struct with fields
> + (struct $name:ident $(, $comment:literal)? { $($fields:tt)* }) => {
> + bitfield!(@core $name $(, $comment)? { $($fields)* });
> + };
> +
> + // All rules below are helpers.
> +
> + // Defines the wrapper `$name` type, as well as its relevant implementations (`Debug`,
> + // `Default`, `BitOr`, and conversion to the value type) and field accessor methods.
> + (@core $name:ident $(, $comment:literal)? { $($fields:tt)* }) => {
> + $(
> + #[doc=$comment]
> + )?
> + #[repr(transparent)]
> + #[derive(Clone, Copy)]
> + pub(crate) struct $name(u32);
> +
> + impl ::core::ops::BitOr for $name {
> + type Output = Self;
> +
> + fn bitor(self, rhs: Self) -> Self::Output {
> + Self(self.0 | rhs.0)
> + }
> + }
Why do we implement BitOr for the register type? Seems a bit out of place for an abstraction that is trying to provide a safer field level access API.
> +
> + impl ::core::convert::From<$name> for u32 {
> + fn from(val: $name) -> u32 {
> + val.0
> + }
> + }
> +
> + bitfield!(@fields_dispatcher $name { $($fields)* });
> + };
> +
> + // Captures the fields and passes them to all the implementers that require field information.
> + //
> + // Used to simplify the matching rules for implementers, so they don't need to match the entire
> + // complex fields rule even though they only make use of part of it.
> + (@fields_dispatcher $name:ident {
> + $($hi:tt:$lo:tt $field:ident as $type:tt
> + $(?=> $try_into_type:ty)?
> + $(=> $into_type:ty)?
> + $(, $comment:literal)?
> + ;
> + )*
> + }
> + ) => {
> + bitfield!(@field_accessors $name {
> + $(
> + $hi:$lo $field as $type
> + $(?=> $try_into_type)?
> + $(=> $into_type)?
> + $(, $comment)?
> + ;
> + )*
> + });
> + bitfield!(@debug $name { $($field;)* });
> + bitfield!(@default $name { $($field;)* });
> + };
> +
> + // Defines all the field getter/setter methods for `$name`.
> + (
> + @field_accessors $name:ident {
> + $($hi:tt:$lo:tt $field:ident as $type:tt
> + $(?=> $try_into_type:ty)?
> + $(=> $into_type:ty)?
> + $(, $comment:literal)?
> + ;
> + )*
> + }
> + ) => {
> + $(
> + bitfield!(@check_field_bounds $hi:$lo $field as $type);
> + )*
> +
> + #[allow(dead_code)]
> + impl $name {
> + $(
> + bitfield!(@field_accessor $name $hi:$lo $field as $type
> + $(?=> $try_into_type)?
> + $(=> $into_type)?
> + $(, $comment)?
> + ;
> + );
> + )*
> + }
> + };
> +
> + // Boolean fields must have `$hi == $lo`.
> + (@check_field_bounds $hi:tt:$lo:tt $field:ident as bool) => {
> + #[allow(clippy::eq_op)]
> + const _: () = {
> + ::kernel::build_assert!(
> + $hi == $lo,
> + concat!("boolean field `", stringify!($field), "` covers more than one bit")
> + );
> + };
> + };
> +
> + // Non-boolean fields must have `$hi >= $lo`.
> + (@check_field_bounds $hi:tt:$lo:tt $field:ident as $type:tt) => {
> + #[allow(clippy::eq_op)]
> + const _: () = {
> + ::kernel::build_assert!(
> + $hi >= $lo,
> + concat!("field `", stringify!($field), "`'s MSB is smaller than its LSB")
> + );
> + };
> + };
It would also be good to find a way to catch overlapping field definitions.
> +
> + // Catches fields defined as `bool` and convert them into a boolean value.
> + (
> + @field_accessor $name:ident $hi:tt:$lo:tt $field:ident as bool => $into_type:ty
> + $(, $comment:literal)?;
> + ) => {
> + bitfield!(
> + @leaf_accessor $name $hi:$lo $field
> + { |f| <$into_type>::from(if f != 0 { true } else { false }) }
if f != 0 { true } else {false} => f != 0
> + $into_type => $into_type $(, $comment)?;
> + );
> + };
> +
> + // Shortcut for fields defined as `bool` without the `=>` syntax.
> + (
> + @field_accessor $name:ident $hi:tt:$lo:tt $field:ident as bool $(, $comment:literal)?;
> + ) => {
> + bitfield!(@field_accessor $name $hi:$lo $field as bool => bool $(, $comment)?;);
> + };
> +
> + // Catches the `?=>` syntax for non-boolean fields.
> + (
> + @field_accessor $name:ident $hi:tt:$lo:tt $field:ident as $type:tt ?=> $try_into_type:ty
> + $(, $comment:literal)?;
> + ) => {
> + bitfield!(@leaf_accessor $name $hi:$lo $field
> + { |f| <$try_into_type>::try_from(f as $type) } $try_into_type =>
> + ::core::result::Result<
> + $try_into_type,
> + <$try_into_type as ::core::convert::TryFrom<$type>>::Error
> + >
> + $(, $comment)?;);
> + };
> +
> + // Catches the `=>` syntax for non-boolean fields.
> + (
> + @field_accessor $name:ident $hi:tt:$lo:tt $field:ident as $type:tt => $into_type:ty
> + $(, $comment:literal)?;
> + ) => {
> + bitfield!(@leaf_accessor $name $hi:$lo $field
> + { |f| <$into_type>::from(f as $type) } $into_type => $into_type $(, $comment)?;);
> + };
> +
> + // Shortcut for non-boolean fields defined without the `=>` or `?=>` syntax.
> + (
> + @field_accessor $name:ident $hi:tt:$lo:tt $field:ident as $type:tt
> + $(, $comment:literal)?;
> + ) => {
> + bitfield!(@field_accessor $name $hi:$lo $field as $type => $type $(, $comment)?;);
> + };
I realize that the additional From conversion and closure invocation this produces will likely be optimized out when compiling at a suitable optimization level, but this is inefficient for register accesses in non-optimized debug builds:
https://godbolt.org/z/YcTGh9xor
It should be relatively straightforward to have the macro construct appropriate wrappers for an inline accessor function only when the conversions are needed, which would compile to something more efficient by construction.
> +
> + // Generates the accessor methods for a single field.
> + (
> + @leaf_accessor $name:ident $hi:tt:$lo:tt $field:ident
> + { $process:expr } $to_type:ty => $res_type:ty $(, $comment:literal)?;
> + ) => {
> + ::kernel::macros::paste!(
> + const [<$field:upper _RANGE>]: ::core::ops::RangeInclusive<u8> = $lo..=$hi;
> + const [<$field:upper _MASK>]: u32 = ((((1 << $hi) - 1) << 1) + 1) - ((1 << $lo) - 1);
I note that genmask, introduced in a subsequent patch, also uses this construction (based on the range, which does not appear to be used by current code).
Using const MASK: u32 = (1 << $hi - $lo + 1) - 1 << $lo would be more clear.
It can also be a good idea to first right shift the value in the accessor and then utilize an unshifted mask, since smaller constant masks can lend themselves to more efficient immediate instructions (as in the godbolt link above).
> + const [<$field:upper _SHIFT>]: u32 = Self::[<$field:upper _MASK>].trailing_zeros();
const SHIFT: u32 = $lo;
> + );
> +
> + $(
> + #[doc="Returns the value of this field:"]
> + #[doc=$comment]
> + )?
> + #[inline(always)]
> + pub(crate) fn $field(self) -> $res_type {
> + ::kernel::macros::paste!(
> + const MASK: u32 = $name::[<$field:upper _MASK>];
> + const SHIFT: u32 = $name::[<$field:upper _SHIFT>];
> + );
> + let field = ((self.0 & MASK) >> SHIFT);
> +
> + $process(field)
> + }
> +
> + ::kernel::macros::paste!(
> + $(
> + #[doc="Sets the value of this field:"]
> + #[doc=$comment]
> + )?
> + #[inline(always)]
> + pub(crate) fn [<set_ $field>](mut self, value: $to_type) -> Self {
> + const MASK: u32 = $name::[<$field:upper _MASK>];
> + const SHIFT: u32 = $name::[<$field:upper _SHIFT>];
> + let value = (u32::from(value) << SHIFT) & MASK;
> + self.0 = (self.0 & !MASK) | value;
> +
> + self
> + }
> + );
> + };
> +
> + // Generates the `Debug` implementation for `$name`.
> + (@debug $name:ident { $($field:ident;)* }) => {
> + impl ::core::fmt::Debug for $name {
> + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
> + f.debug_struct(stringify!($name))
> + .field("<raw>", &format_args!("{:#x}", &self.0))
> + $(
> + .field(stringify!($field), &self.$field())
> + )*
> + .finish()
> + }
> + }
> + };
> +
> + // Generates the `Default` implementation for `$name`.
> + (@default $name:ident { $($field:ident;)* }) => {
> + /// Returns a value for the bitfield where all fields are set to their default value.
> + impl ::core::default::Default for $name {
> + fn default() -> Self {
> + #[allow(unused_mut)]
> + let mut value = Self(Default::default());
> +
> + ::kernel::macros::paste!(
> + $(
> + value.[<set_ $field>](Default::default());
> + )*
> + );
> +
> + value
> + }
> + }
> + };
> +}
> diff --git a/drivers/gpu/nova-core/nova_core.rs b/drivers/gpu/nova-core/nova_core.rs
> index fffcaee2249f..112277c7921e 100644
> --- a/drivers/gpu/nova-core/nova_core.rs
> +++ b/drivers/gpu/nova-core/nova_core.rs
> @@ -2,6 +2,9 @@
>
> //! Nova Core GPU Driver
>
> +#[macro_use]
> +mod bitfield;
> +
> mod dma;
> mod driver;
> mod falcon;
> diff --git a/drivers/gpu/nova-core/regs/macros.rs b/drivers/gpu/nova-core/regs/macros.rs
> index 754c14ee7f40..945d15a2c529 100644
> --- a/drivers/gpu/nova-core/regs/macros.rs
> +++ b/drivers/gpu/nova-core/regs/macros.rs
> @@ -8,7 +8,8 @@
> //!
> //! The `register!` macro in this module provides an intuitive and readable syntax for defining a
> //! dedicated type for each register. Each such type comes with its own field accessors that can
> -//! return an error if a field's value is invalid.
> +//! return an error if a field's value is invalid. Please look at the [`bitfield`] macro for the
> +//! complete syntax of fields definitions.
>
> /// Trait providing a base address to be added to the offset of a relative register to obtain
> /// its actual offset.
> @@ -54,15 +55,6 @@ pub(crate) trait RegisterBase<T> {
> /// BOOT_0::alter(&bar, |r| r.set_major_revision(3).set_minor_revision(10));
> /// ```
> ///
> -/// Fields are defined as follows:
> -///
> -/// - `as <type>` simply returns the field value casted to <type>, typically `u32`, `u16`, `u8` or
> -/// `bool`. Note that `bool` fields must have a range of 1 bit.
> -/// - `as <type> => <into_type>` calls `<into_type>`'s `From::<<type>>` implementation and returns
> -/// the result.
> -/// - `as <type> ?=> <try_into_type>` calls `<try_into_type>`'s `TryFrom::<<type>>` implementation
> -/// and returns the result. This is useful with fields for which not all values are valid.
> -///
> /// The documentation strings are optional. If present, they will be added to the type's
> /// definition, or the field getter and setter methods they are attached to.
> ///
> @@ -284,25 +276,25 @@ pub(crate) trait RegisterBase<T> {
> macro_rules! register {
> // Creates a register at a fixed offset of the MMIO space.
> ($name:ident @ $offset:literal $(, $comment:literal)? { $($fields:tt)* } ) => {
> - register!(@core $name $(, $comment)? { $($fields)* } );
> + bitfield!(struct $name $(, $comment)? { $($fields)* } );
> register!(@io_fixed $name @ $offset);
> };
>
> // Creates an alias register of fixed offset register `alias` with its own fields.
> ($name:ident => $alias:ident $(, $comment:literal)? { $($fields:tt)* } ) => {
> - register!(@core $name $(, $comment)? { $($fields)* } );
> + bitfield!(struct $name $(, $comment)? { $($fields)* } );
> register!(@io_fixed $name @ $alias::OFFSET);
> };
>
> // Creates a register at a relative offset from a base address provider.
> ($name:ident @ $base:ty [ $offset:literal ] $(, $comment:literal)? { $($fields:tt)* } ) => {
> - register!(@core $name $(, $comment)? { $($fields)* } );
> + bitfield!(struct $name $(, $comment)? { $($fields)* } );
> register!(@io_relative $name @ $base [ $offset ]);
> };
>
> // Creates an alias register of relative offset register `alias` with its own fields.
> ($name:ident => $base:ty [ $alias:ident ] $(, $comment:literal)? { $($fields:tt)* }) => {
> - register!(@core $name $(, $comment)? { $($fields)* } );
> + bitfield!(struct $name $(, $comment)? { $($fields)* } );
> register!(@io_relative $name @ $base [ $alias::OFFSET ]);
> };
>
> @@ -313,7 +305,7 @@ macro_rules! register {
> }
> ) => {
> static_assert!(::core::mem::size_of::<u32>() <= $stride);
> - register!(@core $name $(, $comment)? { $($fields)* } );
> + bitfield!(struct $name $(, $comment)? { $($fields)* } );
> register!(@io_array $name @ $offset [ $size ; $stride ]);
> };
>
> @@ -334,7 +326,7 @@ macro_rules! register {
> $(, $comment:literal)? { $($fields:tt)* }
> ) => {
> static_assert!(::core::mem::size_of::<u32>() <= $stride);
> - register!(@core $name $(, $comment)? { $($fields)* } );
> + bitfield!(struct $name $(, $comment)? { $($fields)* } );
> register!(@io_relative_array $name @ $base [ $offset [ $size ; $stride ] ]);
> };
>
> @@ -356,7 +348,7 @@ macro_rules! register {
> }
> ) => {
> static_assert!($idx < $alias::SIZE);
> - register!(@core $name $(, $comment)? { $($fields)* } );
> + bitfield!(struct $name $(, $comment)? { $($fields)* } );
> register!(@io_relative $name @ $base [ $alias::OFFSET + $idx * $alias::STRIDE ] );
> };
>
> @@ -365,241 +357,10 @@ macro_rules! register {
> // to avoid it being interpreted in place of the relative register array alias rule.
> ($name:ident => $alias:ident [ $idx:expr ] $(, $comment:literal)? { $($fields:tt)* }) => {
> static_assert!($idx < $alias::SIZE);
> - register!(@core $name $(, $comment)? { $($fields)* } );
> + bitfield!(struct $name $(, $comment)? { $($fields)* } );
> register!(@io_fixed $name @ $alias::OFFSET + $idx * $alias::STRIDE );
> };
>
> - // All rules below are helpers.
> -
> - // Defines the wrapper `$name` type, as well as its relevant implementations (`Debug`,
> - // `Default`, `BitOr`, and conversion to the value type) and field accessor methods.
> - (@core $name:ident $(, $comment:literal)? { $($fields:tt)* }) => {
> - $(
> - #[doc=$comment]
> - )?
> - #[repr(transparent)]
> - #[derive(Clone, Copy)]
> - pub(crate) struct $name(u32);
> -
> - impl ::core::ops::BitOr for $name {
> - type Output = Self;
> -
> - fn bitor(self, rhs: Self) -> Self::Output {
> - Self(self.0 | rhs.0)
> - }
> - }
> -
> - impl ::core::convert::From<$name> for u32 {
> - fn from(reg: $name) -> u32 {
> - reg.0
> - }
> - }
> -
> - register!(@fields_dispatcher $name { $($fields)* });
> - };
> -
> - // Captures the fields and passes them to all the implementers that require field information.
> - //
> - // Used to simplify the matching rules for implementers, so they don't need to match the entire
> - // complex fields rule even though they only make use of part of it.
> - (@fields_dispatcher $name:ident {
> - $($hi:tt:$lo:tt $field:ident as $type:tt
> - $(?=> $try_into_type:ty)?
> - $(=> $into_type:ty)?
> - $(, $comment:literal)?
> - ;
> - )*
> - }
> - ) => {
> - register!(@field_accessors $name {
> - $(
> - $hi:$lo $field as $type
> - $(?=> $try_into_type)?
> - $(=> $into_type)?
> - $(, $comment)?
> - ;
> - )*
> - });
> - register!(@debug $name { $($field;)* });
> - register!(@default $name { $($field;)* });
> - };
> -
> - // Defines all the field getter/methods methods for `$name`.
> - (
> - @field_accessors $name:ident {
> - $($hi:tt:$lo:tt $field:ident as $type:tt
> - $(?=> $try_into_type:ty)?
> - $(=> $into_type:ty)?
> - $(, $comment:literal)?
> - ;
> - )*
> - }
> - ) => {
> - $(
> - register!(@check_field_bounds $hi:$lo $field as $type);
> - )*
> -
> - #[allow(dead_code)]
> - impl $name {
> - $(
> - register!(@field_accessor $name $hi:$lo $field as $type
> - $(?=> $try_into_type)?
> - $(=> $into_type)?
> - $(, $comment)?
> - ;
> - );
> - )*
> - }
> - };
> -
> - // Boolean fields must have `$hi == $lo`.
> - (@check_field_bounds $hi:tt:$lo:tt $field:ident as bool) => {
> - #[allow(clippy::eq_op)]
> - const _: () = {
> - ::kernel::build_assert!(
> - $hi == $lo,
> - concat!("boolean field `", stringify!($field), "` covers more than one bit")
> - );
> - };
> - };
> -
> - // Non-boolean fields must have `$hi >= $lo`.
> - (@check_field_bounds $hi:tt:$lo:tt $field:ident as $type:tt) => {
> - #[allow(clippy::eq_op)]
> - const _: () = {
> - ::kernel::build_assert!(
> - $hi >= $lo,
> - concat!("field `", stringify!($field), "`'s MSB is smaller than its LSB")
> - );
> - };
> - };
> -
> - // Catches fields defined as `bool` and convert them into a boolean value.
> - (
> - @field_accessor $name:ident $hi:tt:$lo:tt $field:ident as bool => $into_type:ty
> - $(, $comment:literal)?;
> - ) => {
> - register!(
> - @leaf_accessor $name $hi:$lo $field
> - { |f| <$into_type>::from(if f != 0 { true } else { false }) }
> - $into_type => $into_type $(, $comment)?;
> - );
> - };
> -
> - // Shortcut for fields defined as `bool` without the `=>` syntax.
> - (
> - @field_accessor $name:ident $hi:tt:$lo:tt $field:ident as bool $(, $comment:literal)?;
> - ) => {
> - register!(@field_accessor $name $hi:$lo $field as bool => bool $(, $comment)?;);
> - };
> -
> - // Catches the `?=>` syntax for non-boolean fields.
> - (
> - @field_accessor $name:ident $hi:tt:$lo:tt $field:ident as $type:tt ?=> $try_into_type:ty
> - $(, $comment:literal)?;
> - ) => {
> - register!(@leaf_accessor $name $hi:$lo $field
> - { |f| <$try_into_type>::try_from(f as $type) } $try_into_type =>
> - ::core::result::Result<
> - $try_into_type,
> - <$try_into_type as ::core::convert::TryFrom<$type>>::Error
> - >
> - $(, $comment)?;);
> - };
> -
> - // Catches the `=>` syntax for non-boolean fields.
> - (
> - @field_accessor $name:ident $hi:tt:$lo:tt $field:ident as $type:tt => $into_type:ty
> - $(, $comment:literal)?;
> - ) => {
> - register!(@leaf_accessor $name $hi:$lo $field
> - { |f| <$into_type>::from(f as $type) } $into_type => $into_type $(, $comment)?;);
> - };
> -
> - // Shortcut for non-boolean fields defined without the `=>` or `?=>` syntax.
> - (
> - @field_accessor $name:ident $hi:tt:$lo:tt $field:ident as $type:tt
> - $(, $comment:literal)?;
> - ) => {
> - register!(@field_accessor $name $hi:$lo $field as $type => $type $(, $comment)?;);
> - };
> -
> - // Generates the accessor methods for a single field.
> - (
> - @leaf_accessor $name:ident $hi:tt:$lo:tt $field:ident
> - { $process:expr } $to_type:ty => $res_type:ty $(, $comment:literal)?;
> - ) => {
> - ::kernel::macros::paste!(
> - const [<$field:upper _RANGE>]: ::core::ops::RangeInclusive<u8> = $lo..=$hi;
> - const [<$field:upper _MASK>]: u32 = ((((1 << $hi) - 1) << 1) + 1) - ((1 << $lo) - 1);
> - const [<$field:upper _SHIFT>]: u32 = Self::[<$field:upper _MASK>].trailing_zeros();
> - );
> -
> - $(
> - #[doc="Returns the value of this field:"]
> - #[doc=$comment]
> - )?
> - #[inline(always)]
> - pub(crate) fn $field(self) -> $res_type {
> - ::kernel::macros::paste!(
> - const MASK: u32 = $name::[<$field:upper _MASK>];
> - const SHIFT: u32 = $name::[<$field:upper _SHIFT>];
> - );
> - let field = ((self.0 & MASK) >> SHIFT);
> -
> - $process(field)
> - }
> -
> - ::kernel::macros::paste!(
> - $(
> - #[doc="Sets the value of this field:"]
> - #[doc=$comment]
> - )?
> - #[inline(always)]
> - pub(crate) fn [<set_ $field>](mut self, value: $to_type) -> Self {
> - const MASK: u32 = $name::[<$field:upper _MASK>];
> - const SHIFT: u32 = $name::[<$field:upper _SHIFT>];
> - let value = (u32::from(value) << SHIFT) & MASK;
> - self.0 = (self.0 & !MASK) | value;
> -
> - self
> - }
> - );
> - };
> -
> - // Generates the `Debug` implementation for `$name`.
> - (@debug $name:ident { $($field:ident;)* }) => {
> - impl ::core::fmt::Debug for $name {
> - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
> - f.debug_struct(stringify!($name))
> - .field("<raw>", &format_args!("{:#x}", &self.0))
> - $(
> - .field(stringify!($field), &self.$field())
> - )*
> - .finish()
> - }
> - }
> - };
> -
> - // Generates the `Default` implementation for `$name`.
> - (@default $name:ident { $($field:ident;)* }) => {
> - /// Returns a value for the register where all fields are set to their default value.
> - impl ::core::default::Default for $name {
> - fn default() -> Self {
> - #[allow(unused_mut)]
> - let mut value = Self(Default::default());
> -
> - ::kernel::macros::paste!(
> - $(
> - value.[<set_ $field>](Default::default());
> - )*
> - );
> -
> - value
> - }
> - }
> - };
> -
> // Generates the IO accessors for a fixed offset register.
> (@io_fixed $name:ident @ $offset:expr) => {
> #[allow(dead_code)]
> --
> 2.34.1
Regards,
Edwin Peer
>
Powered by blists - more mailing lists