scripts: build: check_init_prio: take deferred-init into account

A device with zephyr,deferred-init is initialized by the application, so
we cannot check if it is initialized in "the correct order". On the other
hand, a non-deferred device must not depend on a deferred-init device: this
is guaranteed to be initialized out of order.

Also adjust existing test cases and add a new test case to validate this
behavior.

Signed-off-by: Mathieu Choplain <[email protected]>

Author: mathieuchopstm

scripts/build/check_init_priorities.py

@@ -49,6 +49,11 @@
     ]
 )
 
+# Deferred initialization property name.
+# When present, the device is not initialized during boot.
+# (it is evaluated as if initializing "after everything else")
+_DEFERRED_INIT_PROP_NAME = "zephyr,deferred-init"
+
 # The offset of the init pointer in "struct device", in number of pointers.
 DEVICE_INIT_OFFSET = 5
 
@@ -287,6 +292,30 @@ def _check_dep(self, dev_ord, dep_ord):
                 self.log.info(f"Ignoring priority: {dev_node._binding.compatible}")
                 return
 
+        def _deferred(node):
+            # Even though the property is boolean, it is sometimes present
+            # in node.props despite having value false: check for both
+            # presence *and* value.
+            if (p := node.props.get(_DEFERRED_INIT_PROP_NAME)) is None:
+                return False
+            assert isinstance(p.val, bool)
+            return p.val
+
+        dev_deferred = _deferred(dev_node)
+        dep_deferred = _deferred(dep_node)
+
+        # Deferred devices can depend on any device...
+        if dev_deferred:
+            self.log.info(f"Ignoring deferred device {dev_node.path}")
+            return
+
+        # ...but non-deferred devices cannot depend on them!
+        if dep_deferred:  # we already know dev_deferred==False
+            self._flag_error(
+                f"Non-deferred device {dev_node.path} depends on deferred device {dep_node.path}"
+            )
+            return
+
         dev_prio, dev_init = self._obj.devices.get(dev_ord, (None, None))
         dep_prio, dep_init = self._obj.devices.get(dep_ord, (None, None))
 

scripts/build/check_init_priorities_test.py

@@ -294,7 +294,9 @@ def test_check_dep_no_prio(self, mock_vinit):
 
         validator._ord2node = {1: mock.Mock(), 2: mock.Mock()}
         validator._ord2node[1]._binding = None
+        validator._ord2node[1].props = {}
         validator._ord2node[2]._binding = None
+        validator._ord2node[2].props = {}
 
         validator._obj.devices = {1: (10, "i1")}
         validator._check_dep(1, 2)
@@ -316,8 +318,10 @@ def test_check(self, mock_vinit):
         validator._ord2node = {1: mock.Mock(), 2: mock.Mock()}
         validator._ord2node[1]._binding = None
         validator._ord2node[1].path = "/1"
+        validator._ord2node[1].props = {}
         validator._ord2node[2]._binding = None
         validator._ord2node[2].path = "/2"
+        validator._ord2node[2].props = {}
 
         validator._obj.devices = {1: (10, "i1"), 2: (20, "i2")}
 
@@ -340,8 +344,10 @@ def test_check_same_prio_assert(self, mock_vinit):
         validator._ord2node = {1: mock.Mock(), 2: mock.Mock()}
         validator._ord2node[1]._binding = None
         validator._ord2node[1].path = "/1"
+        validator._ord2node[1].props = {}
         validator._ord2node[2]._binding = None
         validator._ord2node[2].path = "/2"
+        validator._ord2node[2].props = {}
 
         validator._obj.devices = {1: (10, "i1"), 2: (10, "i2")}
 
@@ -379,6 +385,34 @@ def test_check_ignored(self, mock_vinit):
 
         check_init_priorities._IGNORE_COMPATIBLES = save_ignore_compatibles
 
+    @mock.patch("check_init_priorities.Validator.__init__", return_value=None)
+    def test_check_deferred(self, mock_vinit):
+        validator = check_init_priorities.Validator("", "", None, None)
+        validator.log = mock.Mock()
+        validator._obj = mock.Mock()
+        validator.errors = 0
+
+        validator._ord2node = {1: mock.Mock(), 2: mock.Mock()}
+        validator._ord2node[1]._binding = None
+        validator._ord2node[1].path = "/1"
+        validator._ord2node[1].props = {}
+        validator._ord2node[2]._binding = None
+        validator._ord2node[2].path = "/2"
+        validator._ord2node[2].props = {
+            check_init_priorities._DEFERRED_INIT_PROP_NAME: mock.Mock(val=True)
+        }
+
+        validator._obj.devices = {1: (10, "i1"), 2: (5, "i2")}
+
+        validator._check_dep(2, 1)
+        validator._check_dep(1, 2)
+
+        validator.log.info.assert_called_once_with("Ignoring deferred device /2")
+        validator.log.error.assert_has_calls(
+            [mock.call("Non-deferred device /1 depends on deferred device /2")]
+        )
+        self.assertEqual(validator.errors, 1)
+
     @mock.patch("check_init_priorities.Validator._check_dep")
     @mock.patch("check_init_priorities.Validator.__init__", return_value=None)
     def test_check_edt(self, mock_vinit, mock_cd):