scripts: dts: edtlib: Add Map dataclass

Add Map dataclass to store `*-map` property.

Signed-off-by: TOKITA Hiroshi <[email protected]>

Author: soburi

scripts/dts/python-devicetree/src/devicetree/edtlib.py

@@ -868,6 +868,42 @@ def name_as_token(self):
         return str_as_token(self.name) if self.name is not None else None
 
 
+@dataclass
+class Map:
+    """
+    Represents a "map" on a node.
+
+    node:
+      The Node instance this map is from
+
+    specifier:
+      The specifier of the map properties.
+
+    map:
+      The <name>-map values
+
+    child_cell:
+      The number of the child cells
+
+    child_addr:
+      The length of the child address cells
+
+    parent_cells:
+      The list of the number of each parent cells
+
+    parent_addrs:
+      The list of the length of each parent address cells
+    """
+
+    node: 'Node'
+    specifier: str
+    map: list[Union[int, str, 'Node']]
+    child_cell: int
+    child_addr: int
+    parent_cells: list[int]
+    parent_addrs: list[int]
+
+
 class Node:
     """
     Represents a devicetree node, augmented with information from bindings, and
@@ -1442,6 +1478,7 @@ def _init_crossrefs(
         )
         self._init_interrupts()
         self._init_pinctrls()
+        self._init_maps()
 
     def _init_props(self, default_prop_types: bool = False,
                     err_on_deprecated: bool = False) -> None:
@@ -1728,6 +1765,40 @@ def _init_regs(self) -> None:
 
         _add_names(node, "reg", self.regs)
 
+    def _init_maps(self) -> None:
+        # Initializes self.maps
+
+        props = self._node.props
+
+        self.maps = []
+
+        def conv_enode(x):
+            return self.edt._node2enode.get(x) if isinstance(x, dtlib_Node) else x
+
+        def get_address_cells(n):
+            try:
+                return _cells(n, "address")
+            except Exception:
+                return _address_cells(n)
+
+        for k in [k for k in props if k.endswith('-map')]:
+            name = k[:-4]
+            map_list = list(map(conv_enode, props[k].to_compound()))
+
+            child_cell = _cells(self._node, name)
+            parent_cells = [_cells(x._node, name) for x in map_list if isinstance(x, Node)]
+
+            child_addr = 0
+            parent_addrs = [0] * len(parent_cells)
+
+            if name == "interrupt":
+                child_addr = get_address_cells(self._node)
+                parent_addrs = [get_address_cells(x._node) for x in map_list if isinstance(x, Node)]
+
+            self.maps.append(
+                Map(self, name, map_list, child_cell, child_addr, parent_cells, parent_addrs)
+            )
+
     def _init_pinctrls(self) -> None:
         # Initializes self.pinctrls from any pinctrl-<index> properties
 

scripts/dts/python-devicetree/tests/test_edtlib.py

@@ -209,6 +209,52 @@ def verify_regs(node, expected_tuples):
     verify_regs(edt.get_node("/reg-nested-ranges/grandparent/parent/node"),
                 [(None, 0x30000000200000001, 0x1)])
 
+def test_map():
+    '''Tests for map properties'''
+    with from_here():
+        edt = edtlib.EDT("test.dts", ["test-bindings"])
+
+    def verify_maps(
+        node,
+        specifier,
+        expected_maps,
+        expected_child_cell,
+        expected_child_addr,
+        expected_parent_cells,
+        expected_parent_addrs,
+    ):
+        def node_to_path(n):
+            return n if isinstance(n, int) else n.path
+
+        for m in [m for m in node.maps if m.specifier == specifier]:
+            maps = list(map(node_to_path, m.map))
+            assert maps == expected_maps
+            assert m.child_cell == expected_child_cell
+            assert m.child_addr == expected_child_addr
+            assert m.parent_cells == expected_parent_cells
+            assert m.parent_addrs == expected_parent_addrs
+
+    verify_maps(edt.get_node("/interrupt-map-test/nexus"), specifier="interrupt",
+                expected_maps=[0, 0, 0, 0, "/interrupt-map-test/controller-0", 0, 0,
+                               0, 0, 0, 1, "/interrupt-map-test/controller-1", 0, 0, 0, 1,
+                               0, 0, 0, 2, "/interrupt-map-test/controller-2", 0, 0, 0, 0, 0, 2,
+                               0, 1, 0, 0, "/interrupt-map-test/controller-0", 0, 3,
+                               0, 1, 0, 1, "/interrupt-map-test/controller-1", 0, 0, 0, 4,
+                               0, 1, 0, 2, "/interrupt-map-test/controller-2", 0, 0, 0, 0, 0, 5],
+                expected_child_cell=2, expected_child_addr=2,
+                expected_parent_cells=[1, 2, 3, 1, 2, 3], expected_parent_addrs=[1, 2, 3, 1, 2, 3])
+
+    verify_maps(edt.get_node("/interrupt-map-bitops-test/nexus"), specifier="interrupt",
+                expected_maps=[6, 6, 6, 6, "/interrupt-map-bitops-test/controller", 2, 1],
+                expected_child_cell=2, expected_child_addr=2,
+                expected_parent_cells=[2], expected_parent_addrs=[0])
+
+    verify_maps(edt.get_node("/gpio-map/connector"), specifier="gpio",
+                expected_maps=[1, 2, "/gpio-map/destination", 5,
+                               3, 4, "/gpio-map/destination", 6],
+                expected_child_cell=2, expected_child_addr=0,
+                expected_parent_cells=[1, 1], expected_parent_addrs=[0, 0])
+
 def test_pinctrl():
     '''Test 'pinctrl-<index>'.'''
     with from_here():