fdt-raw 0.3.0

A low-level, no-std compatible library for parsing Flattened Device Tree (FDT) binary files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

//! Ranges property parser for address translation.
//!
//! This module provides types for parsing the `ranges` property, which maps
//! child bus addresses to parent bus addresses for address translation.

use crate::data::{Bytes, Reader};

/// Ranges property wrapper for parsing address translation entries.
///
/// The `ranges` property maps child bus address ranges to parent bus address
/// ranges, enabling translation between address spaces.
#[derive(Clone)]
pub struct VecRange<'a> {
    address_cells: usize,
    parent_address_cells: usize,
    size_cells: usize,
    data: Bytes<'a>,
}

impl<'a> VecRange<'a> {
    /// Creates a new VecRange parser.
    pub(crate) fn new(
        address_cells: usize,
        parent_address_cells: usize,
        size_cells: usize,
        data: Bytes<'a>,
    ) -> Self {
        Self {
            address_cells,
            parent_address_cells,
            size_cells,
            data,
        }
    }

    /// Returns an iterator over range entries.
    pub fn iter(&self) -> VecRangeIter<'a> {
        VecRangeIter {
            address_cells: self.address_cells,
            parent_address_cells: self.parent_address_cells,
            size_cells: self.size_cells,
            reader: self.data.reader(),
        }
    }
}

/// Range entry information.
///
/// Represents a single entry in a `ranges` property, mapping a child bus
/// address range to a parent bus address range.
#[derive(Debug, Clone)]
pub struct RangeInfo {
    /// Child bus address
    pub child_address: u64,
    /// Parent bus address
    pub parent_address: u64,
    /// Length of the region
    pub length: u64,
}

/// Iterator over range entries.
pub struct VecRangeIter<'a> {
    address_cells: usize,
    parent_address_cells: usize,
    size_cells: usize,
    reader: Reader<'a>,
}

impl<'a> Iterator for VecRangeIter<'a> {
    type Item = RangeInfo;

    fn next(&mut self) -> Option<Self::Item> {
        let child_address = self.reader.read_cells(self.address_cells)?;
        let parent_address = self.reader.read_cells(self.parent_address_cells)?;
        let length = self.reader.read_cells(self.size_cells)?;

        Some(RangeInfo {
            child_address,
            parent_address,
            length,
        })
    }
}