Skip to main content

fdt_raw/node/prop/
ranges.rs

1//! Ranges property parser for address translation.
2//!
3//! This module provides types for parsing the `ranges` property, which maps
4//! child bus addresses to parent bus addresses for address translation.
5
6use crate::data::{Bytes, Reader};
7
8/// Ranges property wrapper for parsing address translation entries.
9///
10/// The `ranges` property maps child bus address ranges to parent bus address
11/// ranges, enabling translation between address spaces.
12#[derive(Clone)]
13pub struct VecRange<'a> {
14    address_cells: usize,
15    parent_address_cells: usize,
16    size_cells: usize,
17    data: Bytes<'a>,
18}
19
20impl<'a> VecRange<'a> {
21    /// Creates a new VecRange parser.
22    pub(crate) fn new(
23        address_cells: usize,
24        parent_address_cells: usize,
25        size_cells: usize,
26        data: Bytes<'a>,
27    ) -> Self {
28        Self {
29            address_cells,
30            parent_address_cells,
31            size_cells,
32            data,
33        }
34    }
35
36    /// Returns an iterator over range entries.
37    pub fn iter(&self) -> VecRangeIter<'a> {
38        VecRangeIter {
39            address_cells: self.address_cells,
40            parent_address_cells: self.parent_address_cells,
41            size_cells: self.size_cells,
42            reader: self.data.reader(),
43        }
44    }
45}
46
47/// Range entry information.
48///
49/// Represents a single entry in a `ranges` property, mapping a child bus
50/// address range to a parent bus address range.
51#[derive(Debug, Clone)]
52pub struct RangeInfo {
53    /// Child bus address
54    pub child_address: u64,
55    /// Parent bus address
56    pub parent_address: u64,
57    /// Length of the region
58    pub length: u64,
59}
60
61/// Iterator over range entries.
62pub struct VecRangeIter<'a> {
63    address_cells: usize,
64    parent_address_cells: usize,
65    size_cells: usize,
66    reader: Reader<'a>,
67}
68
69impl<'a> Iterator for VecRangeIter<'a> {
70    type Item = RangeInfo;
71
72    fn next(&mut self) -> Option<Self::Item> {
73        let child_address = self.reader.read_cells(self.address_cells)?;
74        let parent_address = self.reader.read_cells(self.parent_address_cells)?;
75        let length = self.reader.read_cells(self.size_cells)?;
76
77        Some(RangeInfo {
78            child_address,
79            parent_address,
80            length,
81        })
82    }
83}