rust: adt: Add adt property string iterator

This will be used to check all compatible strings in
`adt_is_compatible()`. For now use it to implement ADTNode::compatible()
returning the n-th compatible string on rust side and the C wrapper
function adt_is_compatible_at().

Signed-off-by: Janne Grunau <[email protected]>

Author: jannau

rust/src/adt.rs

@@ -37,6 +37,38 @@ pub struct ADTProperty {
     value: [u8],
 }
 
+/// ADTPropertyStringIterator
+#[derive(Debug)]
+pub struct ADTPropertyStringIterator<'a> {
+    value: &'a [u8],
+}
+
+impl<'a> Iterator for ADTPropertyStringIterator<'a> {
+    type Item = &'a str;
+
+    fn next(&mut self) -> Option<&'a str> {
+        match CStr::from_bytes_until_nul(self.value) {
+            Ok(cs) => match cs.to_str() {
+                Ok(s) => {
+                    match self.value.iter().position(|&x| x == 0) {
+                        Some(nul) => self.value = &self.value[(nul + 1)..],
+                        None => self.value = &[],
+                    }
+                    Some(s)
+                }
+                Err(_) => {
+                    self.value = &[];
+                    None
+                }
+            },
+            Err(_) => {
+                self.value = &[];
+                None
+            }
+        }
+    }
+}
+
 #[repr(C, packed(1))]
 pub struct ADTSegmentRanges {
     phys: u64,
@@ -423,6 +455,11 @@ impl ADTNode {
     pub fn is_compatible(&self, compatible: &str) -> Result<bool, AdtError> {
         Ok(self.named_prop("compatible")?.str()?.contains(compatible))
     }
+
+    pub fn compatible(&self, index: usize) -> Option<&str> {
+        let prop = self.named_prop("compatible").ok()?;
+        prop.str_iter().nth(index)
+    }
 }
 
 impl ADTProperty {
@@ -534,6 +571,12 @@ impl ADTProperty {
         }
     }
 
+    pub fn str_iter<'a>(&'a self) -> ADTPropertyStringIterator<'a> {
+        ADTPropertyStringIterator {
+            value: unsafe { core::slice::from_raw_parts(self.value.as_ptr(), self.size as usize) },
+        }
+    }
+
     pub fn set(&mut self, val: &[u8]) -> Result<usize, AdtError> {
         if val.len() != self.size as usize {
             return Err(AdtError::BadLength);
@@ -769,6 +812,18 @@ pub unsafe extern "C" fn adt_is_compatible(
         .unwrap()
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn adt_is_compatible_at(
+    _dt: *const c_void,
+    offset: c_int,
+    compat: *const c_char,
+    index: usize,
+) -> bool {
+    let strcompat: &str = unsafe { CStr::from_ptr(compat).to_str().unwrap() };
+    let ptr: *const ADTNode = unsafe { adt.add(offset as usize) as *const ADTNode };
+    ADTNode::from_ptr(ptr).unwrap().compatible(index).unwrap() == strcompat
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn adt_get_name(_dt: *const c_void, offset: c_int) -> *const c_char {
     let ptr: *const ADTNode = unsafe { adt.add(offset as usize) as *const ADTNode };

src/adt.h

@@ -56,6 +56,7 @@ int adt_getprop_copy(const void *adt, int nodeoffset, const char *name, void *ou
 
 int adt_get_reg(const void *adt, int *path, const char *prop, int idx, u64 *addr, u64 *size);
 bool adt_is_compatible(const void *adt, int nodeoffset, const char *compat);
+bool adt_is_compatible_at(const void *adt, int nodeoffset, const char *compat, size_t index);
 
 #define ADT_FOREACH_CHILD(adt, node)                                                               \
     for (int _child_count = adt_get_child_count(adt, node); _child_count; _child_count = 0)        \