rust: types: add little-endian type

It allows us to read/write data in little-endian format. Compared to
just using the correctly-sized integer type, it has the advantage of
forcing users to convert to and from little endian format (which will be
no-ops in little-endian architectures).

Signed-off-by: Wedson Almeida Filho <walmeida@microsoft.com>

Author: wedsonaf

rust/kernel/types.rs

@@ -395,3 +395,48 @@ pub enum Either<L, R> {
     /// Constructs an instance of [`Either`] containing a value of type `R`.
     Right(R),
 }
+
+/// A type that can be represented in little-endian bytes.
+pub trait LittleEndian {
+    /// Converts from native to little-endian encoding.
+    fn to_le(self) -> Self;
+
+    /// Converts from little-endian to native encoding.
+    fn to_native(self) -> Self;
+}
+
+macro_rules! define_le {
+    ($($t:ty),+) => {
+        $(
+        impl LittleEndian for $t {
+            fn to_le(self) -> Self {
+                Self::to_le(self)
+            }
+
+            fn to_native(self) -> Self {
+                Self::from_le(self)
+            }
+        }
+        )*
+    };
+}
+
+define_le!(u16, u32, u64);
+
+/// A little-endian representation of `T`.
+#[derive(Clone, Copy)]
+#[repr(transparent)]
+pub struct LE<T: LittleEndian + Copy>(T);
+
+impl<T: LittleEndian + Copy> LE<T> {
+    /// Returns the native-endian value.
+    pub fn value(&self) -> T {
+        self.0.to_native()
+    }
+}
+
+impl<T: LittleEndian + Copy> core::convert::From<T> for LE<T> {
+    fn from(value: T) -> LE<T> {
+        LE(value.to_le())
+    }
+}