Struct fdt::Fdt

pub struct Fdt<'a> { /* private fields */ }

A flattened devicetree located somewhere in memory

Note on Debug impl: by default the Debug impl of this struct will not print any useful information, if you would like a best-effort tree print which looks similar to dtc’s output, enable the pretty-printing feature

Implementations

impl<'a> Fdt<'a>

pub fn new(data: &'a [u8]) -> Result<Self, FdtError>

Construct a new Fdt from a byte buffer

Note: this function does not require that the data be 4-byte aligned

Examples found in repository

examples/tree_print.rs (line 6)

fn main() {
    let fdt = fdt::Fdt::new(MY_FDT).unwrap();

    print_node(fdt.find_node("/").unwrap(), 0);
}

examples/basic_info.rs (line 4)

fn main() {
    let fdt = fdt::Fdt::new(MY_FDT).unwrap();

    println!("This is a devicetree representation of a {}", fdt.root().model());
    println!("...which is compatible with at least: {}", fdt.root().compatible().first());
    println!("...and has {} CPU(s)", fdt.cpus().count());
    println!(
        "...and has at least one memory location at: {:#X}\n",
        fdt.memory().regions().next().unwrap().starting_address as usize
    );

    let chosen = fdt.chosen();
    if let Some(bootargs) = chosen.bootargs() {
        println!("The bootargs are: {:?}", bootargs);
    }

    if let Some(stdout) = chosen.stdout() {
        println!("It would write stdout to: {}", stdout.name);
    }

    let soc = fdt.find_node("/soc");
    println!("Does it have a `/soc` node? {}", if soc.is_some() { "yes" } else { "no" });
    if let Some(soc) = soc {
        println!("...and it has the following children:");
        for child in soc.children() {
            println!("    {}", child.name);
        }
    }
}

pub unsafe fn from_ptr(ptr: *const u8) -> Result<Self, FdtError>

Safety

This function performs a read to verify the magic value. If the pointer is invalid this can result in undefined behavior.

Note: this function does not require that the data be 4-byte aligned

pub fn aliases(&self) -> Option<Aliases<'_, 'a>>

Return the /aliases node, if one exists

pub fn chosen(&self) -> Chosen<'_, 'a>

Searches for the /chosen node, which is always available

Examples found in repository

examples/basic_info.rs (line 14)

fn main() {
    let fdt = fdt::Fdt::new(MY_FDT).unwrap();

    println!("This is a devicetree representation of a {}", fdt.root().model());
    println!("...which is compatible with at least: {}", fdt.root().compatible().first());
    println!("...and has {} CPU(s)", fdt.cpus().count());
    println!(
        "...and has at least one memory location at: {:#X}\n",
        fdt.memory().regions().next().unwrap().starting_address as usize
    );

    let chosen = fdt.chosen();
    if let Some(bootargs) = chosen.bootargs() {
        println!("The bootargs are: {:?}", bootargs);
    }

    if let Some(stdout) = chosen.stdout() {
        println!("It would write stdout to: {}", stdout.name);
    }

    let soc = fdt.find_node("/soc");
    println!("Does it have a `/soc` node? {}", if soc.is_some() { "yes" } else { "no" });
    if let Some(soc) = soc {
        println!("...and it has the following children:");
        for child in soc.children() {
            println!("    {}", child.name);
        }
    }
}

pub fn cpus(&self) -> impl Iterator<Item = Cpu<'_, 'a>>

Return the /cpus node, which is always available

Examples found in repository

examples/basic_info.rs (line 8)

fn main() {
    let fdt = fdt::Fdt::new(MY_FDT).unwrap();

    println!("This is a devicetree representation of a {}", fdt.root().model());
    println!("...which is compatible with at least: {}", fdt.root().compatible().first());
    println!("...and has {} CPU(s)", fdt.cpus().count());
    println!(
        "...and has at least one memory location at: {:#X}\n",
        fdt.memory().regions().next().unwrap().starting_address as usize
    );

    let chosen = fdt.chosen();
    if let Some(bootargs) = chosen.bootargs() {
        println!("The bootargs are: {:?}", bootargs);
    }

    if let Some(stdout) = chosen.stdout() {
        println!("It would write stdout to: {}", stdout.name);
    }

    let soc = fdt.find_node("/soc");
    println!("Does it have a `/soc` node? {}", if soc.is_some() { "yes" } else { "no" });
    if let Some(soc) = soc {
        println!("...and it has the following children:");
        for child in soc.children() {
            println!("    {}", child.name);
        }
    }
}

pub fn memory(&self) -> Memory<'_, 'a>

Returns the memory node, which is always available

Examples found in repository

examples/basic_info.rs (line 11)

fn main() {
    let fdt = fdt::Fdt::new(MY_FDT).unwrap();

    println!("This is a devicetree representation of a {}", fdt.root().model());
    println!("...which is compatible with at least: {}", fdt.root().compatible().first());
    println!("...and has {} CPU(s)", fdt.cpus().count());
    println!(
        "...and has at least one memory location at: {:#X}\n",
        fdt.memory().regions().next().unwrap().starting_address as usize
    );

    let chosen = fdt.chosen();
    if let Some(bootargs) = chosen.bootargs() {
        println!("The bootargs are: {:?}", bootargs);
    }

    if let Some(stdout) = chosen.stdout() {
        println!("It would write stdout to: {}", stdout.name);
    }

    let soc = fdt.find_node("/soc");
    println!("Does it have a `/soc` node? {}", if soc.is_some() { "yes" } else { "no" });
    if let Some(soc) = soc {
        println!("...and it has the following children:");
        for child in soc.children() {
            println!("    {}", child.name);
        }
    }
}

pub fn memory_reservations(
&self
) -> impl Iterator<Item = MemoryReservation> + 'a

Returns an iterator over the memory reservations

pub fn root(&self) -> Root<'_, 'a>

Return the root (/) node, which is always available

Examples found in repository

examples/basic_info.rs (line 6)

fn main() {
    let fdt = fdt::Fdt::new(MY_FDT).unwrap();

    println!("This is a devicetree representation of a {}", fdt.root().model());
    println!("...which is compatible with at least: {}", fdt.root().compatible().first());
    println!("...and has {} CPU(s)", fdt.cpus().count());
    println!(
        "...and has at least one memory location at: {:#X}\n",
        fdt.memory().regions().next().unwrap().starting_address as usize
    );

    let chosen = fdt.chosen();
    if let Some(bootargs) = chosen.bootargs() {
        println!("The bootargs are: {:?}", bootargs);
    }

    if let Some(stdout) = chosen.stdout() {
        println!("It would write stdout to: {}", stdout.name);
    }

    let soc = fdt.find_node("/soc");
    println!("Does it have a `/soc` node? {}", if soc.is_some() { "yes" } else { "no" });
    if let Some(soc) = soc {
        println!("...and it has the following children:");
        for child in soc.children() {
            println!("    {}", child.name);
        }
    }
}

pub fn find_node(&self, path: &str) -> Option<FdtNode<'_, 'a>>

Returns the first node that matches the node path, if you want all that match the path, use find_all_nodes. This will automatically attempt to resolve aliases if path is not found.

Node paths must begin with a leading / and are ASCII only. Passing in an invalid node path or non-ASCII node name in the path will return None, as they will not be found within the devicetree structure.

Note: if the address of a node name is left out, the search will find the first node that has a matching name, ignoring the address portion if it exists.

Examples found in repository

examples/tree_print.rs (line 8)

fn main() {
    let fdt = fdt::Fdt::new(MY_FDT).unwrap();

    print_node(fdt.find_node("/").unwrap(), 0);
}

examples/basic_info.rs (line 23)

fn main() {
    let fdt = fdt::Fdt::new(MY_FDT).unwrap();

    println!("This is a devicetree representation of a {}", fdt.root().model());
    println!("...which is compatible with at least: {}", fdt.root().compatible().first());
    println!("...and has {} CPU(s)", fdt.cpus().count());
    println!(
        "...and has at least one memory location at: {:#X}\n",
        fdt.memory().regions().next().unwrap().starting_address as usize
    );

    let chosen = fdt.chosen();
    if let Some(bootargs) = chosen.bootargs() {
        println!("The bootargs are: {:?}", bootargs);
    }

    if let Some(stdout) = chosen.stdout() {
        println!("It would write stdout to: {}", stdout.name);
    }

    let soc = fdt.find_node("/soc");
    println!("Does it have a `/soc` node? {}", if soc.is_some() { "yes" } else { "no" });
    if let Some(soc) = soc {
        println!("...and it has the following children:");
        for child in soc.children() {
            println!("    {}", child.name);
        }
    }
}

pub fn find_compatible(&self, with: &[&str]) -> Option<FdtNode<'_, 'a>>

Searches for a node which contains a compatible property and contains one of the strings inside of with

pub fn find_phandle(&self, phandle: u32) -> Option<FdtNode<'_, 'a>>

Searches for the given phandle

pub fn find_all_nodes(
&self,
path: &'a str
) -> impl Iterator<Item = FdtNode<'_, 'a>>

Returns an iterator over all of the available nodes with the given path. This does not attempt to find any node with the same name as the provided path, if you’re looking to do that, Fdt::all_nodes will allow you to iterate over each node’s name and filter for the desired node(s).

For example:

static MY_FDT: &[u8] = include_bytes!("../dtb/test.dtb");

let fdt = fdt::Fdt::new(MY_FDT).unwrap();

for node in fdt.find_all_nodes("/soc/virtio_mmio") {
    println!("{}", node.name);
}

prints:

virtio_mmio@10008000
virtio_mmio@10007000
virtio_mmio@10006000
virtio_mmio@10005000
virtio_mmio@10004000
virtio_mmio@10003000
virtio_mmio@10002000
virtio_mmio@10001000

pub fn all_nodes(&self) -> impl Iterator<Item = FdtNode<'_, 'a>>

Returns an iterator over all of the nodes in the devicetree, depth-first

pub fn strings(&self) -> impl Iterator<Item = &'a str>

Returns an iterator over all of the strings inside of the strings block

pub fn total_size(&self) -> usize

Total size of the devicetree in bytes

Trait Implementations

impl<'a> Clone for Fdt<'a>

fn clone(&self) -> Fdt<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Fdt<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Copy for Fdt<'a>