Commit 2fe11d5a authored by FUJITA Tomonori's avatar FUJITA Tomonori Committed by David S. Miller
Browse files

rust: net::phy add module_phy_driver macro 



This macro creates an array of kernel's `struct phy_driver` and
registers it. This also corresponds to the kernel's
`MODULE_DEVICE_TABLE` macro, which embeds the information for module
loading into the module binary file.

A PHY driver should use this macro.

Signed-off-by: default avatarFUJITA Tomonori <fujita.tomonori@gmail.com>
Reviewed-by: default avatarAlice Ryhl <aliceryhl@google.com>
Reviewed-by: default avatarBenno Lossin <benno.lossin@proton.me>
Reviewed-by: default avatarAndrew Lunn <andrew@lunn.ch>
Reviewed-by: default avatarTrevor Gross <tmgross@umich.edu>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent f20fd544

rust/kernel/net/phy.rs

+146 −0
Original line number Diff line number Diff line
@@ -753,3 +753,149 @@ const fn as_int(&self) -> u32 { 
        }

    }

}



/// Declares a kernel module for PHYs drivers.

///

/// This creates a static array of kernel's `struct phy_driver` and registers it.

/// This also corresponds to the kernel's `MODULE_DEVICE_TABLE` macro, which embeds the information

/// for module loading into the module binary file. Every driver needs an entry in `device_table`.

///

/// # Examples

///

/// ```

/// # mod module_phy_driver_sample {

/// use kernel::c_str;

/// use kernel::net::phy::{self, DeviceId};

/// use kernel::prelude::*;

///

/// kernel::module_phy_driver! {

///     drivers: [PhySample],

///     device_table: [

///         DeviceId::new_with_driver::<PhySample>()

///     ],

///     name: "rust_sample_phy",

///     author: "Rust for Linux Contributors",

///     description: "Rust sample PHYs driver",

///     license: "GPL",

/// }

///

/// struct PhySample;

///

/// #[vtable]

/// impl phy::Driver for PhySample {

///     const NAME: &'static CStr = c_str!("PhySample");

///     const PHY_DEVICE_ID: phy::DeviceId = phy::DeviceId::new_with_exact_mask(0x00000001);

/// }

/// # }

/// ```

///

/// This expands to the following code:

///

/// ```ignore

/// use kernel::c_str;

/// use kernel::net::phy::{self, DeviceId};

/// use kernel::prelude::*;

///

/// struct Module {

///     _reg: ::kernel::net::phy::Registration,

/// }

///

/// module! {

///     type: Module,

///     name: "rust_sample_phy",

///     author: "Rust for Linux Contributors",

///     description: "Rust sample PHYs driver",

///     license: "GPL",

/// }

///

/// struct PhySample;

///

/// #[vtable]

/// impl phy::Driver for PhySample {

///     const NAME: &'static CStr = c_str!("PhySample");

///     const PHY_DEVICE_ID: phy::DeviceId = phy::DeviceId::new_with_exact_mask(0x00000001);

/// }

///

/// const _: () = {

///     static mut DRIVERS: [::kernel::net::phy::DriverVTable; 1] =

///         [::kernel::net::phy::create_phy_driver::<PhySample>()];

///

///     impl ::kernel::Module for Module {

///         fn init(module: &'static ThisModule) -> Result<Self> {

///             let drivers = unsafe { &mut DRIVERS };

///             let mut reg = ::kernel::net::phy::Registration::register(

///                 module,

///                 ::core::pin::Pin::static_mut(drivers),

///             )?;

///             Ok(Module { _reg: reg })

///         }

///     }

/// };

///

/// #[cfg(MODULE)]

/// #[no_mangle]

/// static __mod_mdio__phydev_device_table: [::kernel::bindings::mdio_device_id; 2] = [

///     ::kernel::bindings::mdio_device_id {

///         phy_id: 0x00000001,

///         phy_id_mask: 0xffffffff,

///     },

///     ::kernel::bindings::mdio_device_id {

///         phy_id: 0,

///         phy_id_mask: 0,

///     },

/// ];

/// ```

#[macro_export]

macro_rules! module_phy_driver {

    (@replace_expr $_t:tt $sub:expr) => {$sub};



    (@count_devices $($x:expr),*) => {

        0usize $(+ $crate::module_phy_driver!(@replace_expr $x 1usize))*

    };



    (@device_table [$($dev:expr),+]) => {

        // SAFETY: C will not read off the end of this constant since the last element is zero.

        #[cfg(MODULE)]

        #[no_mangle]

        static __mod_mdio__phydev_device_table: [$crate::bindings::mdio_device_id;

            $crate::module_phy_driver!(@count_devices $($dev),+) + 1] = [

            $($dev.mdio_device_id()),+,

            $crate::bindings::mdio_device_id {

                phy_id: 0,

                phy_id_mask: 0

            }

        ];

    };



    (drivers: [$($driver:ident),+ $(,)?], device_table: [$($dev:expr),+ $(,)?], $($f:tt)*) => {

        struct Module {

            _reg: $crate::net::phy::Registration,

        }



        $crate::prelude::module! {

            type: Module,

            $($f)*

        }



        const _: () = {

            static mut DRIVERS: [$crate::net::phy::DriverVTable;

                $crate::module_phy_driver!(@count_devices $($driver),+)] =

                [$($crate::net::phy::create_phy_driver::<$driver>()),+];



            impl $crate::Module for Module {

                fn init(module: &'static ThisModule) -> Result<Self> {

                    // SAFETY: The anonymous constant guarantees that nobody else can access

                    // the `DRIVERS` static. The array is used only in the C side.

                    let drivers = unsafe { &mut DRIVERS };

                    let mut reg = $crate::net::phy::Registration::register(

                        module,

                        ::core::pin::Pin::static_mut(drivers),

                    )?;

                    Ok(Module { _reg: reg })

                }

            }

        };



        $crate::module_phy_driver!(@device_table [$($dev),+]);

    }

}