fdt: Merge fdt_normal with its base class

Since we only have one Fdt implementation now we don't need to have a base
class. Merge the implementation and the base class together.

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

3 files changed, 157 insertions, 253 deletions

diff --git a/tools/dtoc/fdt.py b/tools/dtoc/fdt.py
index dedd3d75010..bff31d1c921 100644
--- a/tools/dtoc/fdt.py
+++ b/tools/dtoc/fdt.py
@@ -10,12 +10,15 @@ import struct
 import sys
 
 import fdt_util
+import libfdt
 
 # 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 FdtNormal subclass. See fdt_select.py for how to
-# create an Fdt object.
+# contains the base classes and defines the high-level API. See fdt_select.py
+# for how to create an Fdt object.
+
+# This implementation uses a libfdt Python library to access the device tree,
+# so it is fairly efficient.
 
 # A list of types we support
 (TYPE_BYTE, TYPE_INT, TYPE_STRING, TYPE_BOOL) = range(4)
@@ -25,7 +28,7 @@ def CheckErr(errnum, msg):
         raise ValueError('Error %d: %s: %s' %
             (errnum, libfdt.fdt_strerror(errnum), msg))
 
-class PropBase:
+class Prop:
     """A device tree property
 
     Properties:
@@ -34,11 +37,17 @@ class PropBase:
             bytes
         type: Value type
     """
-    def __init__(self, node, offset, name):
+    def __init__(self, node, offset, name, bytes):
         self._node = node
         self._offset = offset
         self.name = name
         self.value = None
+        self.bytes = str(bytes)
+        if not bytes:
+            self.type = TYPE_BOOL
+            self.value = True
+            return
+        self.type, self.value = self.BytesToValue(bytes)
 
     def GetPhandle(self):
         """Get a (single) phandle value from a property
@@ -148,15 +157,12 @@ class PropBase:
     def GetOffset(self):
         """Get the offset of a property
 
-        This can be implemented by subclasses.
-
         Returns:
-            The offset of the property (struct fdt_property) within the
-            file, or None if not known.
+            The offset of the property (struct fdt_property) within the file
         """
-        return None
+        return self._node._fdt.GetStructOffset(self._offset)
 
-class NodeBase:
+class Node:
     """A device tree node
 
     Properties:
@@ -189,25 +195,65 @@ class NodeBase:
                 return subnode
         return None
 
+    def Offset(self):
+        """Returns the offset of a node, after checking the cache
+
+        This should be used instead of self._offset directly, to ensure that
+        the cache does not contain invalid offsets.
+        """
+        self._fdt.CheckCache()
+        return self._offset
+
     def Scan(self):
-        """Scan the subnodes of a node
+        """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.
+        """
+        self.props = self._fdt.GetProps(self)
+
+        offset = libfdt.fdt_first_subnode(self._fdt.GetFdt(), self.Offset())
+        while offset >= 0:
+            sep = '' if self.path[-1] == '/' else '/'
+            name = self._fdt._fdt_obj.get_name(offset)
+            path = self.path + sep + name
+            node = Node(self._fdt, offset, name, path)
+            self.subnodes.append(node)
 
-        This should be implemented by subclasses
+            node.Scan()
+            offset = libfdt.fdt_next_subnode(self._fdt.GetFdt(), offset)
+
+    def Refresh(self, my_offset):
+        """Fix up the _offset for each node, recursively
+
+        Note: This does not take account of property offsets - these will not
+        be updated.
         """
-        raise NotImplementedError()
+        if self._offset != my_offset:
+            #print '%s: %d -> %d\n' % (self.path, self._offset, my_offset)
+            self._offset = my_offset
+        offset = libfdt.fdt_first_subnode(self._fdt.GetFdt(), self._offset)
+        for subnode in self.subnodes:
+            subnode.Refresh(offset)
+            offset = libfdt.fdt_next_subnode(self._fdt.GetFdt(), offset)
 
     def DeleteProp(self, prop_name):
         """Delete a property of a node
 
-        This should be implemented by subclasses
+        The property is deleted and the offset cache is invalidated.
 
         Args:
             prop_name: Name of the property to delete
+        Raises:
+            ValueError if the property does not exist
         """
-        raise NotImplementedError()
+        CheckErr(libfdt.fdt_delprop(self._fdt.GetFdt(), self.Offset(), prop_name),
+                 "Node '%s': delete property: '%s'" % (self.path, prop_name))
+        del self.props[prop_name]
+        self._fdt.Invalidate()
 
 class Fdt:
-    """Provides simple access to a flat device tree blob.
+    """Provides simple access to a flat device tree blob using libfdts.
 
     Properties:
       fname: Filename of fdt
@@ -215,6 +261,13 @@ class Fdt:
     """
     def __init__(self, fname):
         self._fname = fname
+        self._cached_offsets = False
+        if self._fname:
+            self._fname = fdt_util.EnsureCompiled(self._fname)
+
+            with open(self._fname) as fd:
+                self._fdt = bytearray(fd.read())
+                self._fdt_obj = libfdt.Fdt(self._fdt)
 
     def Scan(self, root='/'):
         """Scan a device tree, building up a tree of Node objects
@@ -256,15 +309,94 @@ class Fdt:
         """Flush device tree changes back to the file
 
         If the device tree has changed in memory, write it back to the file.
-        Subclasses can implement this if needed.
         """
-        pass
+        with open(self._fname, 'wb') as fd:
+            fd.write(self._fdt)
 
     def Pack(self):
         """Pack the device tree down to its minimum size
 
         When nodes and properties shrink or are deleted, wasted space can
-        build up in the device tree binary. Subclasses can implement this
-        to remove that spare space.
+        build up in the device tree binary.
+        """
+        CheckErr(libfdt.fdt_pack(self._fdt), 'pack')
+        fdt_len = libfdt.fdt_totalsize(self._fdt)
+        del self._fdt[fdt_len:]
+
+    def GetFdt(self):
+        """Get the contents of the FDT
+
+        Returns:
+            The FDT contents as a string of bytes
+        """
+        return self._fdt
+
+    def CheckErr(errnum, msg):
+        if errnum:
+            raise ValueError('Error %d: %s: %s' %
+                (errnum, libfdt.fdt_strerror(errnum), msg))
+
+
+    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 Prop objects.
+
+        Raises:
+            ValueError: if the node does not exist.
+        """
+        props_dict = {}
+        poffset = libfdt.fdt_first_property_offset(self._fdt, node._offset)
+        while poffset >= 0:
+            p = self._fdt_obj.get_property_by_offset(poffset)
+            prop = Prop(node, poffset, p.name, p.value)
+            props_dict[prop.name] = prop
+
+            poffset = libfdt.fdt_next_property_offset(self._fdt, poffset)
+        return props_dict
+
+    def Invalidate(self):
+        """Mark our offset cache as invalid"""
+        self._cached_offsets = False
+
+    def CheckCache(self):
+        """Refresh the offset cache if needed"""
+        if self._cached_offsets:
+            return
+        self.Refresh()
+        self._cached_offsets = True
+
+    def Refresh(self):
+        """Refresh the offset cache"""
+        self._root.Refresh(0)
+
+    def GetStructOffset(self, offset):
+        """Get the file offset of a given struct offset
+
+        Args:
+            offset: Offset within the 'struct' region of the device tree
+        Returns:
+            Position of @offset within the device tree binary
         """
-        pass
+        return libfdt.fdt_off_dt_struct(self._fdt) + offset
+
+    @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_normal.py b/tools/dtoc/fdt_normal.py
deleted file mode 100644
index a0e58a44642..00000000000
--- a/tools/dtoc/fdt_normal.py
+++ /dev/null
@@ -1,226 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright (C) 2016 Google, Inc
-# Written by Simon Glass <sjg@chromium.org>
-#
-# SPDX-License-Identifier:      GPL-2.0+
-#
-
-import struct
-import sys
-
-import fdt
-from fdt import Fdt, NodeBase, PropBase
-import fdt_util
-import libfdt
-
-
-# This deals with a device tree, presenting it as a list of Node and Prop
-# objects, representing nodes and properties, respectively.
-#
-# This implementation uses a libfdt Python library to access the device tree,
-# so it is fairly efficient.
-
-def CheckErr(errnum, msg):
-    if errnum:
-        raise ValueError('Error %d: %s: %s' %
-            (errnum, libfdt.fdt_strerror(errnum), msg))
-
-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, offset, name, bytes):
-        PropBase.__init__(self, node, offset, name)
-        self.bytes = str(bytes)
-        if not bytes:
-            self.type = fdt.TYPE_BOOL
-            self.value = True
-            return
-        self.type, self.value = self.BytesToValue(bytes)
-
-    def GetOffset(self):
-        """Get the offset of a property
-
-        Returns:
-            The offset of the property (struct fdt_property) within the file
-        """
-        return self._node._fdt.GetStructOffset(self._offset)
-
-class Node(NodeBase):
-    """A device tree node
-
-    Properties:
-        offset: Integer offset in the device tree
-        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 Offset(self):
-        """Returns the offset of a node, after checking the cache
-
-        This should be used instead of self._offset directly, to ensure that
-        the cache does not contain invalid offsets.
-        """
-        self._fdt.CheckCache()
-        return self._offset
-
-    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.
-        """
-        self.props = self._fdt.GetProps(self)
-
-        offset = libfdt.fdt_first_subnode(self._fdt.GetFdt(), self.Offset())
-        while offset >= 0:
-            sep = '' if self.path[-1] == '/' else '/'
-            name = self._fdt._fdt_obj.get_name(offset)
-            path = self.path + sep + name
-            node = Node(self._fdt, offset, name, path)
-            self.subnodes.append(node)
-
-            node.Scan()
-            offset = libfdt.fdt_next_subnode(self._fdt.GetFdt(), offset)
-
-    def Refresh(self, my_offset):
-        """Fix up the _offset for each node, recursively
-
-        Note: This does not take account of property offsets - these will not
-        be updated.
-        """
-        if self._offset != my_offset:
-            #print '%s: %d -> %d\n' % (self.path, self._offset, my_offset)
-            self._offset = my_offset
-        offset = libfdt.fdt_first_subnode(self._fdt.GetFdt(), self._offset)
-        for subnode in self.subnodes:
-            subnode.Refresh(offset)
-            offset = libfdt.fdt_next_subnode(self._fdt.GetFdt(), offset)
-
-    def DeleteProp(self, prop_name):
-        """Delete a property of a node
-
-        The property is deleted and the offset cache is invalidated.
-
-        Args:
-            prop_name: Name of the property to delete
-        Raises:
-            ValueError if the property does not exist
-        """
-        CheckErr(libfdt.fdt_delprop(self._fdt.GetFdt(), self.Offset(), prop_name),
-                 "Node '%s': delete property: '%s'" % (self.path, prop_name))
-        del self.props[prop_name]
-        self._fdt.Invalidate()
-
-class FdtNormal(Fdt):
-    """Provides simple access to a flat device tree blob using libfdt.
-
-    Properties:
-        _fdt: Device tree contents (bytearray)
-        _cached_offsets: True if all the nodes have a valid _offset property,
-            False if something has changed to invalidate the offsets
-    """
-    def __init__(self, fname):
-        Fdt.__init__(self, fname)
-        self._cached_offsets = False
-        if self._fname:
-            self._fname = fdt_util.EnsureCompiled(self._fname)
-
-            with open(self._fname) as fd:
-                self._fdt = bytearray(fd.read())
-                self._fdt_obj = libfdt.Fdt(self._fdt)
-
-    def GetFdt(self):
-        """Get the contents of the FDT
-
-        Returns:
-            The FDT contents as a string of bytes
-        """
-        return self._fdt
-
-    def Flush(self):
-        """Flush device tree changes back to the file"""
-        with open(self._fname, 'wb') as fd:
-            fd.write(self._fdt)
-
-    def Pack(self):
-        """Pack the device tree down to its minimum size"""
-        CheckErr(libfdt.fdt_pack(self._fdt), 'pack')
-        fdt_len = libfdt.fdt_totalsize(self._fdt)
-        del self._fdt[fdt_len:]
-
-    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 Prop objects.
-
-        Raises:
-            ValueError: if the node does not exist.
-        """
-        props_dict = {}
-        poffset = libfdt.fdt_first_property_offset(self._fdt, node._offset)
-        while poffset >= 0:
-            p = self._fdt_obj.get_property_by_offset(poffset)
-            prop = Prop(node, poffset, p.name, p.value)
-            props_dict[prop.name] = prop
-
-            poffset = libfdt.fdt_next_property_offset(self._fdt, poffset)
-        return props_dict
-
-    def Invalidate(self):
-        """Mark our offset cache as invalid"""
-        self._cached_offsets = False
-
-    def CheckCache(self):
-        """Refresh the offset cache if needed"""
-        if self._cached_offsets:
-            return
-        self.Refresh()
-        self._cached_offsets = True
-
-    def Refresh(self):
-        """Refresh the offset cache"""
-        self._root.Refresh(0)
-
-    def GetStructOffset(self, offset):
-        """Get the file offset of a given struct offset
-
-        Args:
-            offset: Offset within the 'struct' region of the device tree
-        Returns:
-            Position of @offset within the device tree binary
-        """
-        return libfdt.fdt_off_dt_struct(self._fdt) + offset
-
-    @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 54a3ef2e46e..d6337ea2277 100644
--- a/tools/dtoc/fdt_select.py
+++ b/tools/dtoc/fdt_select.py
@@ -6,13 +6,11 @@
 # SPDX-License-Identifier:      GPL-2.0+
 #
 
-# 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.
-import fdt_normal
+# Bring in the normal fdt library (which relies on libfdt)
+import fdt
 
 def FdtScan(fname):
     """Returns a new Fdt object from the implementation we are using"""
-    dtb = fdt_normal.FdtNormal(fname)
+    dtb = fdt.Fdt(fname)
     dtb.Scan()
     return dtb