Open Firmware Device Tree Unittest

  ----------------------------------
  
  Author: Gaurav Minocha <gaurav.minocha.os@gmail.com>
  
  1. Introduction

  This document explains how the test data required for executing OF unittest

  is attached to the live tree dynamically, independent of the machine's
  architecture.
  
  It is recommended to read the following documents before moving ahead.
  
  [1] Documentation/devicetree/usage-model.txt
  [2] http://www.devicetree.org/Device_Tree_Usage
  
  OF Selftest has been designed to test the interface (include/linux/of.h)
  provided to device driver developers to fetch the device information..etc.
  from the unflattened device tree data structure. This interface is used by
  most of the device drivers in various use cases.
  
  
  2. Test-data

  The Device Tree Source file (drivers/of/unittest-data/testcases.dts) contains

  the test data required for executing the unit tests automated in

  drivers/of/unittest.c. Currently, following Device Tree Source Include files
  (.dtsi) are included in testcases.dts:

  drivers/of/unittest-data/tests-interrupts.dtsi
  drivers/of/unittest-data/tests-platform.dtsi
  drivers/of/unittest-data/tests-phandle.dtsi
  drivers/of/unittest-data/tests-match.dtsi

  
  When the kernel is build with OF_SELFTEST enabled, then the following make rule
  
  $(obj)/%.dtb: $(src)/%.dts FORCE
  	$(call if_changed_dep, dtc)

  is used to compile the DT source file (testcases.dts) into a binary blob
  (testcases.dtb), also referred as flattened DT.

  
  After that, using the following rule the binary blob above is wrapped as an

  assembly file (testcases.dtb.S).

  
  $(obj)/%.dtb.S: $(obj)/%.dtb
  	$(call cmd, dt_S_dtb)

  The assembly file is compiled into an object file (testcases.dtb.o), and is

  linked into the kernel image.
  
  
  2.1. Adding the test data
  
  Un-flattened device tree structure:
  
  Un-flattened device tree consists of connected device_node(s) in form of a tree
  structure described below.
  
  // following struct members are used to construct the tree
  struct device_node {
      ...
      struct  device_node *parent;
      struct  device_node *child;
      struct  device_node *sibling;

      ...
   };

  Figure 1, describes a generic structure of machine's un-flattened device tree

  considering only child and sibling pointers. There exists another pointer,
  *parent, that is used to traverse the tree in the reverse direction. So, at
  a particular level the child node and all the sibling nodes will have a parent

  pointer pointing to a common node (e.g. child1, sibling2, sibling3, sibling4's

  parent points to root node)

  root ('/')

     |
  child1 -> sibling2 -> sibling3 -> sibling4 -> null
     |         |           |           |
     |         |           |          null
     |         |           |
     |         |        child31 -> sibling32 -> null
     |         |           |          |
     |         |          null       null
     |         |
     |      child21 -> sibling22 -> sibling23 -> null
     |         |          |            |
     |        null       null         null
     |
  child11 -> sibling12 -> sibling13 -> sibling14 -> null
     |           |           |            |
     |           |           |           null
     |           |           |
    null        null       child131 -> null
                             |
                            null
  
  Figure 1: Generic structure of un-flattened device tree

  Before executing OF unittest, it is required to attach the test data to

  machine's device tree (if present). So, when selftest_data_add() is called,
  at first it reads the flattened device tree data linked into the kernel image
  via the following kernel symbols:
  
  __dtb_testcases_begin - address marking the start of test data blob
  __dtb_testcases_end   - address marking the end of test data blob

  Secondly, it calls of_fdt_unflatten_tree() to unflatten the flattened
  blob. And finally, if the machine's device tree (i.e live tree) is present,

  then it attaches the unflattened test data tree to the live tree, else it
  attaches itself as a live device tree.
  
  attach_node_and_children() uses of_attach_node() to attach the nodes into the
  live tree as explained below. To explain the same, the test data tree described
   in Figure 2 is attached to the live tree described in Figure 1.

  root ('/')

      |
   testcase-data
      |
   test-child0 -> test-sibling1 -> test-sibling2 -> test-sibling3 -> null
      |               |                |                |
   test-child01      null             null             null

  Figure 2: Example test data tree to be attached to live tree.

  According to the scenario above, the live tree is already present so it isn't
  required to attach the root('/') node. All other nodes are attached by calling

  of_attach_node() on each node.
  
  In the function of_attach_node(), the new node is attached as the child of the
  given parent in live tree. But, if parent already has a child then the new node
  replaces the current child and turns it into its sibling. So, when the testcase
  data node is attached to the live tree above (Figure 1), the final structure is
   as shown in Figure 3.

  root ('/')

     |
  testcase-data -> child1 -> sibling2 -> sibling3 -> sibling4 -> null
     |               |          |           |           |
   (...)             |          |           |          null
                     |          |         child31 -> sibling32 -> null
                     |          |           |           |
                     |          |          null        null
                     |          |
                     |        child21 -> sibling22 -> sibling23 -> null
                     |          |           |            |
                     |         null        null         null
                     |
                  child11 -> sibling12 -> sibling13 -> sibling14 -> null
                     |          |            |            |
                    null       null          |           null
                                             |
                                          child131 -> null
                                             |
                                            null
  -----------------------------------------------------------------------

  root ('/')

     |
  testcase-data -> child1 -> sibling2 -> sibling3 -> sibling4 -> null
     |               |          |           |           |
     |             (...)      (...)       (...)        null
     |
  test-sibling3 -> test-sibling2 -> test-sibling1 -> test-child0 -> null
     |                |                   |                |
    null             null                null         test-child01
  
  
  Figure 3: Live device tree structure after attaching the testcase-data.
  
  
  Astute readers would have noticed that test-child0 node becomes the last
  sibling compared to the earlier structure (Figure 2). After attaching first
  test-child0 the test-sibling1 is attached that pushes the child node
  (i.e. test-child0) to become a sibling and makes itself a child node,
   as mentioned above.
  
  If a duplicate node is found (i.e. if a node with same full_name property is

  already present in the live tree), then the node isn't attached rather its
  properties are updated to the live tree's node by calling the function

  update_node_properties().
  
  
  2.2. Removing the test data
  
  Once the test case execution is complete, selftest_data_remove is called in
  order to remove the device nodes attached initially (first the leaf nodes are
  detached and then moving up the parent nodes are removed, and eventually the
  whole tree). selftest_data_remove() calls detach_node_and_children() that uses
  of_detach_node() to detach the nodes from the live device tree.

  To detach a node, of_detach_node() either updates the child pointer of given
  node's parent to its sibling or attaches the previous sibling to the given
  node's sibling, as appropriate. That is it :)