[U-Boot] [PATCH 15/19] fdt: Drop fdt_fallback library

Simon Glass sjg at chromium.org
Mon Apr 17 02:22:29 UTC 2017


Drop this now-unused library and associated tests.

Signed-off-by: Simon Glass <sjg at chromium.org>
---

 tools/binman/fdt_test.py   |  10 ---
 tools/binman/func_test.py  |  42 ++++-------
 tools/dtoc/fdt.py          |   4 +-
 tools/dtoc/fdt_fallback.py | 181 ---------------------------------------------
 tools/dtoc/fdt_select.py   |  24 +-----
 5 files changed, 18 insertions(+), 243 deletions(-)
 delete mode 100644 tools/dtoc/fdt_fallback.py

diff --git a/tools/binman/fdt_test.py b/tools/binman/fdt_test.py
index 65fb947386..df2b0a6af7 100644
--- a/tools/binman/fdt_test.py
+++ b/tools/binman/fdt_test.py
@@ -82,13 +82,3 @@ class TestFdt(unittest.TestCase):
         self.assertEquals(list, type(prop.value))
         self.assertEquals(3, len(prop.value))
         self.assertEquals(['another', 'multi-word', 'message'], prop.value)
-
-    def testFdtFallback(self):
-        fname = self.GetCompiled('34_x86_ucode.dts')
-        dt = FdtScan(fname, True)
-        dt.GetProp('/microcode/update at 0', 'data')
-        self.assertEqual('fred',
-            dt.GetProp('/microcode/update at 0', 'none', default='fred'))
-        self.assertEqual('12345678 12345679',
-            dt.GetProp('/microcode/update at 0', 'data', typespec='x'))
-        self._DeleteProp(dt)
diff --git a/tools/binman/func_test.py b/tools/binman/func_test.py
index 740fa9e4e2..7328d03b5c 100644
--- a/tools/binman/func_test.py
+++ b/tools/binman/func_test.py
@@ -683,7 +683,7 @@ class TestFunctional(unittest.TestCase):
         self.assertEqual('nodtb with microcode' + pos_and_size +
                          ' somewhere in here', first)
 
-    def _RunPackUbootSingleMicrocode(self, collate):
+    def _RunPackUbootSingleMicrocode(self):
         """Test that x86 microcode can be handled correctly
 
         We expect to see the following in the image, in order:
@@ -695,8 +695,6 @@ class TestFunctional(unittest.TestCase):
         # We need the libfdt library to run this test since only that allows
         # finding the offset of a property. This is required by
         # Entry_u_boot_dtb_with_ucode.ObtainContents().
-        if not fdt_select.have_libfdt:
-            return
         data = self._DoReadFile('35_x86_single_ucode.dts', True)
 
         second = data[len(U_BOOT_NODTB_DATA):]
@@ -705,34 +703,22 @@ class TestFunctional(unittest.TestCase):
         third = second[fdt_len:]
         second = second[:fdt_len]
 
-        if not collate:
-            ucode_data = struct.pack('>2L', 0x12345678, 0x12345679)
-            self.assertIn(ucode_data, second)
-            ucode_pos = second.find(ucode_data) + len(U_BOOT_NODTB_DATA)
+        ucode_data = struct.pack('>2L', 0x12345678, 0x12345679)
+        self.assertIn(ucode_data, second)
+        ucode_pos = second.find(ucode_data) + len(U_BOOT_NODTB_DATA)
 
-            # Check that the microcode pointer was inserted. It should match the
-            # expected position and size
-            pos_and_size = struct.pack('<2L', 0xfffffe00 + ucode_pos,
-                                    len(ucode_data))
-            first = data[:len(U_BOOT_NODTB_DATA)]
-            self.assertEqual('nodtb with microcode' + pos_and_size +
-                            ' somewhere in here', first)
+        # Check that the microcode pointer was inserted. It should match the
+        # expected position and size
+        pos_and_size = struct.pack('<2L', 0xfffffe00 + ucode_pos,
+                                   len(ucode_data))
+        first = data[:len(U_BOOT_NODTB_DATA)]
+        self.assertEqual('nodtb with microcode' + pos_and_size +
+                         ' somewhere in here', first)
 
     def testPackUbootSingleMicrocode(self):
         """Test that x86 microcode can be handled correctly with fdt_normal.
         """
-        self._RunPackUbootSingleMicrocode(False)
-
-    def testPackUbootSingleMicrocodeFallback(self):
-        """Test that x86 microcode can be handled correctly with fdt_fallback.
-
-        This only supports collating the microcode.
-        """
-        try:
-            old_val = fdt_select.UseFallback(True)
-            self._RunPackUbootSingleMicrocode(True)
-        finally:
-            fdt_select.UseFallback(old_val)
+        self._RunPackUbootSingleMicrocode()
 
     def testUBootImg(self):
         """Test that u-boot.img can be put in a file"""
@@ -763,14 +749,12 @@ class TestFunctional(unittest.TestCase):
     def testMicrocodeWithoutPtrInElf(self):
         """Test that a U-Boot binary without the microcode symbol is detected"""
         # ELF file without a '_dt_ucode_base_size' symbol
-        if not fdt_select.have_libfdt:
-            return
         try:
             with open(self.TestFile('u_boot_no_ucode_ptr')) as fd:
                 TestFunctional._MakeInputFile('u-boot', fd.read())
 
             with self.assertRaises(ValueError) as e:
-                self._RunPackUbootSingleMicrocode(False)
+                self._RunPackUbootSingleMicrocode()
             self.assertIn("Node '/binman/u-boot-with-ucode-ptr': Cannot locate "
                     "_dt_ucode_base_size symbol in u-boot", str(e.exception))
 
diff --git a/tools/dtoc/fdt.py b/tools/dtoc/fdt.py
index c40b9b6bab..dedd3d7501 100644
--- a/tools/dtoc/fdt.py
+++ b/tools/dtoc/fdt.py
@@ -14,8 +14,8 @@ import fdt_util
 # This deals with a device tree, presenting it as an assortment of Node and
 # Prop objects, representing nodes and properties, respectively. This file
 # contains the base classes and defines the high-level API. Most of the
-# implementation is in the FdtFallback and FdtNormal subclasses. See
-# fdt_select.py for how to create an Fdt object.
+# implementation is in the FdtNormal subclass. See fdt_select.py for how to
+# create an Fdt object.
 
 # A list of types we support
 (TYPE_BYTE, TYPE_INT, TYPE_STRING, TYPE_BOOL) = range(4)
diff --git a/tools/dtoc/fdt_fallback.py b/tools/dtoc/fdt_fallback.py
deleted file mode 100644
index 23e26796c8..0000000000
--- a/tools/dtoc/fdt_fallback.py
+++ /dev/null
@@ -1,181 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright (C) 2016 Google, Inc
-# Written by Simon Glass <sjg at chromium.org>
-#
-# SPDX-License-Identifier:      GPL-2.0+
-#
-
-import command
-import fdt
-from fdt import Fdt, NodeBase, PropBase
-import fdt_util
-import sys
-
-# This deals with a device tree, presenting it as a list of Node and Prop
-# objects, representing nodes and properties, respectively.
-#
-# This implementation uses the fdtget tool to access the device tree, so it
-# is not very efficient for larger trees. The tool is called once for each
-# node and property in the tree.
-
-class Prop(PropBase):
-    """A device tree property
-
-    Properties:
-        name: Property name (as per the device tree)
-        value: Property value as a string of bytes, or a list of strings of
-            bytes
-        type: Value type
-    """
-    def __init__(self, node, name, byte_list_str):
-        PropBase.__init__(self, node, 0, name)
-        if not byte_list_str.strip():
-            self.type = fdt.TYPE_BOOL
-            return
-        self.bytes = [chr(int(byte, 16))
-                      for byte in byte_list_str.strip().split(' ')]
-        self.type, self.value = self.BytesToValue(''.join(self.bytes))
-
-
-class Node(NodeBase):
-    """A device tree node
-
-    Properties:
-        name: Device tree node tname
-        path: Full path to node, along with the node name itself
-        _fdt: Device tree object
-        subnodes: A list of subnodes for this node, each a Node object
-        props: A dict of properties for this node, each a Prop object.
-            Keyed by property name
-    """
-    def __init__(self, fdt, offset, name, path):
-        NodeBase.__init__(self, fdt, offset, name, path)
-
-    def Scan(self):
-        """Scan a node's properties and subnodes
-
-        This fills in the props and subnodes properties, recursively
-        searching into subnodes so that the entire tree is built.
-        """
-        for name, byte_list_str in self._fdt.GetProps(self.path).items():
-            prop = Prop(self, name, byte_list_str)
-            self.props[name] = prop
-
-        for name in self._fdt.GetSubNodes(self.path):
-            sep = '' if self.path[-1] == '/' else '/'
-            path = self.path + sep + name
-            node = Node(self._fdt, 0, name, path)
-            self.subnodes.append(node)
-
-            node.Scan()
-
-    def DeleteProp(self, prop_name):
-        """Delete a property of a node
-
-        The property is deleted using fdtput.
-
-        Args:
-            prop_name: Name of the property to delete
-        Raises:
-            CommandError if the property does not exist
-        """
-        args = [self._fdt._fname, '-d', self.path, prop_name]
-        command.Output('fdtput', *args)
-        del self.props[prop_name]
-
-class FdtFallback(Fdt):
-    """Provides simple access to a flat device tree blob using fdtget/fdtput
-
-    Properties:
-        See superclass
-    """
-
-    def __init__(self, fname):
-        Fdt.__init__(self, fname)
-        if self._fname:
-            self._fname = fdt_util.EnsureCompiled(self._fname)
-
-    def GetSubNodes(self, node):
-        """Returns a list of sub-nodes of a given node
-
-        Args:
-            node: Node name to return children from
-
-        Returns:
-            List of children in the node (each a string node name)
-
-        Raises:
-            CmdError: if the node does not exist.
-        """
-        out = command.Output('fdtget', self._fname, '-l', node)
-        return out.strip().splitlines()
-
-    def GetProps(self, node):
-        """Get all properties from a node
-
-        Args:
-            node: full path to node name to look in
-
-        Returns:
-            A dictionary containing all the properties, indexed by node name.
-            The entries are simply strings - no decoding of lists or numbers
-            is done.
-
-        Raises:
-            CmdError: if the node does not exist.
-        """
-        out = command.Output('fdtget', self._fname, node, '-p')
-        props = out.strip().splitlines()
-        props_dict = {}
-        for prop in props:
-            name = prop
-            props_dict[prop] = self.GetProp(node, name)
-        return props_dict
-
-    def GetProp(self, node, prop, default=None, typespec=None):
-        """Get a property from a device tree.
-
-        This looks up the given node and property, and returns the value as a
-        string,
-
-        If the node or property does not exist, this will return the default
-        value.
-
-        Args:
-            node: Full path to node to look up.
-            prop: Property name to look up.
-            default: Default value to return if nothing is present in the fdt,
-                or None to raise in this case. This will be converted to a
-                string.
-            typespec: Type character to use (None for default, 's' for string)
-
-        Returns:
-            string containing the property value.
-
-        Raises:
-            CmdError: if the property does not exist and no default is provided.
-        """
-        args = [self._fname, node, prop, '-t', 'bx']
-        if default is not None:
-          args += ['-d', str(default)]
-        if typespec is not None:
-          args += ['-t', typespec]
-        out = command.Output('fdtget', *args)
-        return out.strip()
-
-    @classmethod
-    def Node(self, fdt, offset, name, path):
-        """Create a new node
-
-        This is used by Fdt.Scan() to create a new node using the correct
-        class.
-
-        Args:
-            fdt: Fdt object
-            offset: Offset of node
-            name: Node name
-            path: Full path to node
-        """
-        node = Node(fdt, offset, name, path)
-        return node
diff --git a/tools/dtoc/fdt_select.py b/tools/dtoc/fdt_select.py
index ea78c527fc..54a3ef2e46 100644
--- a/tools/dtoc/fdt_select.py
+++ b/tools/dtoc/fdt_select.py
@@ -6,31 +6,13 @@
 # SPDX-License-Identifier:      GPL-2.0+
 #
 
-import fdt_fallback
-
 # Bring in either the normal fdt library (which relies on libfdt) or the
 # fallback one (which uses fdtget and is slower). Both provide the same
 # interface for this file to use.
-try:
-    import fdt_normal
-    have_libfdt = True
-except ImportError:
-    have_libfdt = False
-
-force_fallback = False
+import fdt_normal
 
-def FdtScan(fname, _force_fallback=False):
+def FdtScan(fname):
     """Returns a new Fdt object from the implementation we are using"""
-    if have_libfdt and not force_fallback and not _force_fallback:
-        dtb = fdt_normal.FdtNormal(fname)
-    else:
-        dtb = fdt_fallback.FdtFallback(fname)
+    dtb = fdt_normal.FdtNormal(fname)
     dtb.Scan()
     return dtb
-
-def UseFallback(fallback):
-    global force_fallback
-
-    old_val = force_fallback
-    force_fallback = fallback
-    return old_val
-- 
2.12.2.762.g0e3151a226-goog



More information about the U-Boot mailing list