zephyr-build: Include DT node presence configs

Generate a full list of nodes that are present in the given device tree,
and provide a tool that build.rs in the app can use to make these
active.  This will allow conditionals like:

    #[cfg(dt = "aliases::led")]

to be used, which will make it possible to handle nodes being present or
not in the DTS.

See a subsequent patch to the blinky sample for an example of usage.

Signed-off-by: David Brown <[email protected]>

Author: d3zd3z

zephyr-build/src/devicetree/output.rs

@@ -8,6 +8,9 @@
 // Support for particular devices should also be added to the device tree here, so that the nodes
 // make sense for that device, and that there are general accessors that return wrapped node types.
 
+use std::io::Write;
+
+use anyhow::Result;
 use proc_macro2::{Ident, TokenStream};
 use quote::{format_ident, quote};
 
@@ -23,6 +26,20 @@ impl DeviceTree {
         self.node_walk(self.root.as_ref(), None, &augments)
     }
 
+    /// Write to the given file a list of the path names of all of the nodes present in this
+    /// devicetree.
+    pub fn output_node_paths<W: Write>(&self, write: &mut W) -> Result<()> {
+        self.root.as_ref().output_path_walk(write, None)?;
+
+        // Also, output all of the labels.  Technically, this depends on the labels augment being
+        // present.
+        writeln!(write, "labels")?;
+        for label in self.labels.keys() {
+            writeln!(write, "labels::{}", fix_id(label))?;
+        }
+        Ok(())
+    }
+
     fn node_walk(&self, node: &Node, name: Option<&str>, augments: &[Box<dyn Augment>]) -> TokenStream {
         let children = node.children.iter().map(|child| {
             self.node_walk(child.as_ref(), Some(&child.name), augments)
@@ -118,6 +135,29 @@ impl Node {
             crate :: devicetree #(:: #route)*
         }
     }
+
+    /// Walk this tree of nodes, writing out the path names of the nodes that are present.  The name
+    /// of None, indicates the root node.
+    fn output_path_walk<W: Write>(&self, write: &mut W, name: Option<&str>) -> Result<()> {
+        for child in &self.children {
+            let fixed_name = fix_id(&child.name);
+            let child_name = if let Some(name) = name {
+                format!("{}::{}", name, fixed_name)
+            } else {
+                fixed_name
+            };
+
+            writeln!(write, "{}", child_name)?;
+
+            for prop in &child.properties {
+                prop.output_path(write, &child_name)?;
+            }
+
+            child.output_path_walk(write, Some(&child_name))?;
+        }
+
+        Ok(())
+    }
 }
 
 impl Property {
@@ -129,6 +169,17 @@ impl Property {
             None
         }
     }
+
+    // If this property is a single top-level phandle, output that a that path is valid.  It isn't a
+    // real node, but acts like one.
+    fn output_path<W: Write>(&self, write: &mut W, name: &str) -> Result<()> {
+        if let Some(value) = self.get_single_value() {
+            if let Value::Phandle(_) = value {
+                writeln!(write, "{}::{}", name, self.name)?;
+            }
+        }
+        Ok(())
+    }
 }
 
 fn general_property(prop: &Property) -> TokenStream {

zephyr-build/src/lib.rs

@@ -86,6 +86,7 @@ pub fn build_dts() {
     let outdir = env::var("OUT_DIR").expect("OUT_DIR must be set");
     let gen_include = env::var("BINARY_DIR_INCLUDE_GENERATED")
         .expect("BINARY_DIR_INCLUDE_GENERATED");
+    let builddir = env::var("BUILD_DIR").expect("BUILD_DIR");
 
     let augments = env::var("DT_AUGMENTS").expect("DT_AUGMENTS must be set");
     let augments: Vec<String> = augments.split_whitespace().map(String::from).collect();
@@ -111,7 +112,6 @@ pub fn build_dts() {
 
     let generated = format!("{}/devicetree_generated.h", gen_include);
     let dt = DeviceTree::new(&zephyr_dts, generated);
-    let _ = dt;
 
     let out_path = Path::new(&outdir).join("devicetree.rs");
     let mut out = File::create(&out_path).expect("Unable to create devicetree.rs");
@@ -122,6 +122,28 @@ pub fn build_dts() {
     } else {
         writeln!(out, "{}", tokens).unwrap();
     };
+
+    // Output all of the node names in the discovered tree.
+    let all_nodes_path = Path::new(&builddir)
+        .join("rust")
+        .join("all-dt-nodes.txt");
+    let mut out = File::create(&all_nodes_path).expect("Unable to create all-dt-nodex.txt");
+    dt.output_node_paths(&mut out).expect("Unable to write to all-dt-nodes.txt");
+}
+
+/// Generate cfg directives for each of the nodes in the generated device tree.
+///
+/// This assumes that build_dts was already run by the `zephyr` crate, which should happen if this
+/// is called from a user application.
+pub fn dt_cfgs() {
+    let builddir = env::var("BUILD_DIR").expect("BUILD_DIR");
+    let path = Path::new(&builddir)
+        .join("rust")
+        .join("all-dt-nodes.txt");
+    for line in BufReader::new(File::open(&path).expect("Unable to open all-dt-nodes")).lines() {
+        let line = line.expect("Error reading line from all-dt-nodes");
+        println!("cargo:rustc-cfg=dt=\"{}\"", line);
+    }
 }
 
 /// Determine if `rustfmt` is in the path, and can be excecuted. Returns false on any kind of error.