Merge pull request #14 from woshiluo/pmu

Add support for `riscv,pmu` device

Author: luojia65

.gitignore

@@ -4,4 +4,6 @@ Cargo.lock
 
 # Visual Studio Code configuration files
 .vscode/
-*.dts
+
+*.dtb
+!examples/*.dtb

Cargo.toml

@@ -14,14 +14,12 @@ edition = "2024"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-serde = { version = "1.0", default-features = false }
-erased-serde = "0.4"
-
-[dev-dependencies]
-serde_derive = "1.0"
+serde = { version = "1.0", default-features = false, features = ["derive"] }
+dyn_serde = { version = "1.0.2", default-features = false, optional = true }
 
 [features]
-default = ["std"]
+default = ["std", "ser"]
 
+ser = ["dep:dyn_serde"]
 std = ["serde/std"]
 alloc = ["serde/alloc"]

examples/hifive-unmatched-a00.rs

@@ -1,7 +1,7 @@
 extern crate alloc;
 
 use alloc::collections::BTreeMap;
-use serde_derive::Deserialize;
+use serde::Deserialize;
 use serde_device_tree::Compatible;
 
 #[derive(Debug, Deserialize)]

examples/qemu-virt.rs

@@ -1,8 +1,7 @@
 //! 这是一个 `from_raw_mut` 反序列化设备树的示例。不需要 `alloc`。
 // extern crate alloc;
 
-// 在实际使用中，将这里的 `serde_derive::Deserialize` 改为 `serde::Deserialize`。
-use serde_derive::Deserialize;
+use serde::Deserialize;
 
 // - `DtbPtr`: 验证设备树首部正确性，后续也可借助这个类型传递设备树，多次解析不必重复验证。
 // - `Dtb`: 管理反序列化出的类型生命周期。

examples/serialize.rs

@@ -1,4 +1,4 @@
-use serde_derive::Serialize;
+use serde::Serialize;
 use std::io::prelude::*;
 
 const MAX_SIZE: usize = 256 + 32;

src/de.rs

@@ -42,7 +42,7 @@ use serde::de;
 /// # });
 /// # aligned_data.data[..BUFFER_SIZE].clone_from_slice(RAW_DEVICE_TREE);
 /// # let fdt_ptr = aligned_data.data.as_ptr();
-/// use serde_derive::Deserialize;
+/// use serde::Deserialize;
 ///
 /// #[derive(Debug, Deserialize)]
 /// struct Tree<'a> {
@@ -516,7 +516,7 @@ mod tests {
     #[cfg(feature = "alloc")]
     use alloc::format;
     #[cfg(any(feature = "std", feature = "alloc"))]
-    use serde_derive::Deserialize;
+    use serde::Deserialize;
     #[cfg(feature = "std")]
     use std::format;
 

src/de_mut/matrix.rs

@@ -0,0 +1,128 @@
+use crate::de_mut::ValueCursor;
+use serde::{Deserialize, Serialize};
+
+pub struct Matrix<'de, const T: usize> {
+    data: &'de [u32],
+}
+
+pub struct MatrixItem<'de, const T: usize> {
+    offset: usize,
+    data: &'de [u32],
+}
+
+impl<'de, const T: usize> Matrix<'de, T> {
+    #[inline(always)]
+    pub fn get_block_size() -> usize {
+        // Block size in bytes.
+        T * 4
+    }
+
+    #[inline(always)]
+    pub fn iter(&self) -> MatrixItem<'de, T> {
+        MatrixItem {
+            offset: 0,
+            data: self.data,
+        }
+    }
+
+    #[inline(always)]
+    pub fn len(&self) -> usize {
+        self.data.len() / T
+    }
+
+    #[inline(always)]
+    pub fn is_empty(&self) -> bool {
+        self.data.len() != 0
+    }
+
+    #[inline(always)]
+    pub fn get(&self, i: usize) -> &'de [u32] {
+        &self.data[i * T..(i + 1) * T]
+    }
+}
+
+impl<'de, const T: usize> Iterator for MatrixItem<'de, T> {
+    type Item = &'de [u32];
+
+    #[inline(always)]
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.data.len() <= self.offset {
+            return None;
+        }
+        let result = &self.data[self.offset..self.offset + T];
+        self.offset += T;
+        Some(result)
+    }
+}
+
+impl<'de, const T: usize> Deserialize<'de> for Matrix<'_, T> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let value_deserialzer = super::ValueDeserializer::deserialize(deserializer)?;
+        let data = match value_deserialzer.cursor {
+            ValueCursor::Prop(_, cursor) => cursor.data_on(value_deserialzer.dtb),
+            _ => unreachable!(),
+        };
+        if data.len() % Self::get_block_size() != 0 {
+            panic!("unaligned matrix");
+        }
+        let (prefix, data, suffix) = unsafe { data.align_to::<u32>() };
+        if !prefix.is_empty() || !suffix.is_empty() {
+            panic!("Not support unaligned data");
+        }
+
+        Ok(Self { data })
+    }
+}
+
+impl<const T: usize> Serialize for Matrix<'_, T> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeSeq;
+        let mut seq = serializer.serialize_seq(Some(self.data.len()))?;
+        for x in self.data {
+            seq.serialize_element(x)?;
+        }
+        seq.end()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Matrix;
+    use crate::{Dtb, DtbPtr, buildin::Node, from_raw_mut};
+    use serde::Serialize;
+
+    const MAX_SIZE: usize = 256;
+    #[test]
+    fn base_ser_test() {
+        #[derive(Serialize)]
+        struct Base {
+            pub hello: [u32; 16],
+        }
+        let array: [u32; 16] = [0xdeadbeef; 16];
+        let mut buf1 = [0u8; MAX_SIZE];
+
+        {
+            let base = Base { hello: array };
+            crate::ser::to_dtb(&base, &[], &mut buf1).unwrap();
+        }
+
+        let ptr = DtbPtr::from_raw(buf1.as_mut_ptr()).unwrap();
+        let dtb = Dtb::from(ptr).share();
+        let node: Node = from_raw_mut(&dtb).unwrap();
+        let matrix = node.get_prop("hello").unwrap().deserialize::<Matrix<4>>();
+        let mut count = 0;
+        for x in matrix.iter() {
+            for y in x {
+                count += 1;
+                assert_eq!(u32::from_be(*y), 0xdeadbeef);
+            }
+        }
+        assert_eq!(count, 16);
+    }
+}

src/de_mut/mod.rs

@@ -7,6 +7,7 @@ use serde::de;
 mod cursor;
 mod data;
 // mod group;
+mod matrix;
 pub(crate) mod node;
 mod node_seq;
 mod reg;
@@ -18,11 +19,11 @@ mod structs;
 const VALUE_DESERIALIZER_NAME: &str = "$serde_device_tree$de_mut$ValueDeserializer";
 pub(crate) const NODE_NAME: &str = "$serde_device_tree$de_mut$Node";
 pub(crate) const NODE_NODE_ITEM_NAME: &str = "$serde_device_tree$de_mut$Node$NodeItem";
-pub(crate) const NODE_PROP_ITEM_NAME: &str = "$serde_device_tree$de_mut$Node$PropItem";
+// pub(crate) const NODE_PROP_ITEM_NAME: &str = "$serde_device_tree$de_mut$Node$PropItem";
 
 pub use structs::{Dtb, DtbPtr};
 pub mod buildin {
-    pub use super::{node::Node, node_seq::NodeSeq, reg::Reg, str_seq::StrSeq};
+    pub use super::{matrix::Matrix, node::Node, node_seq::NodeSeq, reg::Reg, str_seq::StrSeq};
 }
 
 use cursor::{BodyCursor, Cursor, MultiNodeCursor, PropCursor};

src/de_mut/node.rs

@@ -54,10 +54,18 @@ pub struct PropItem<'de> {
 impl<'de> Node<'de> {
     pub fn deserialize<T: Deserialize<'de>>(&self) -> T {
         use super::ValueCursor;
+        let result = match self.cursor.clone().move_on(self.dtb) {
+            Cursor::Title(c) => {
+                let (name, _) = c.split_on(self.dtb);
+                let take_result = c.take_node_on(self.dtb, name);
+                take_result
+            }
+            _ => unreachable!("Node's cursor should on its start"),
+        };
         T::deserialize(&mut ValueDeserializer {
             dtb: self.dtb,
             reg: self.reg,
-            cursor: ValueCursor::Body(self.cursor),
+            cursor: ValueCursor::NodeIn(result),
         })
         .unwrap()
     }
@@ -302,7 +310,7 @@ impl<'de> PropItem<'de> {
         .unwrap()
     }
 }
-impl<'se> Serialize for NodeItem<'se> {
+impl Serialize for NodeItem<'_> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
@@ -311,7 +319,7 @@ impl<'se> Serialize for NodeItem<'se> {
     }
 }
 
-impl<'se> Serialize for PropItem<'se> {
+impl Serialize for PropItem<'_> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
@@ -320,7 +328,7 @@ impl<'se> Serialize for PropItem<'se> {
     }
 }
 
-impl<'se> Serialize for Node<'se> {
+impl Serialize for Node<'_> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,

src/de_mut/node_seq.rs

@@ -178,7 +178,7 @@ impl<'de> NodeSeqItem<'de> {
 mod tests {
     use crate::buildin::{NodeSeq, Reg};
     use crate::{Dtb, DtbPtr, from_raw_mut};
-    use serde_derive::Deserialize;
+    use serde::Deserialize;
 
     const RAW_DEVICE_TREE: &[u8] = include_bytes!("../../examples/bl808.dtb");
     const BUFFER_SIZE: usize = RAW_DEVICE_TREE.len();