odroid: remove CONFIG_DM_I2C_COMPAT config

[platform/kernel/u-boot.git] / tools / dtoc / fdt_fallback.py

diff --git a/tools/dtoc/fdt_fallback.py b/tools/dtoc/fdt_fallback.py
index 14decf3..23e2679 100644 (file)
--- a/tools/dtoc/fdt_fallback.py
+++ b/tools/dtoc/fdt_fallback.py
@@ -7,6 +7,8 @@
 #
 
 import command
 #
 
 import command

+import fdt
+from fdt import Fdt, NodeBase, PropBase

 import fdt_util
 import sys
 
 import fdt_util
 import sys
 


@@ -17,7 +19,7 @@ import sys
 # is not very efficient for larger trees. The tool is called once for each
 # node and property in the tree.
 
 # is not very efficient for larger trees. The tool is called once for each
 # node and property in the tree.
 

-class Prop:
+class Prop(PropBase):

     """A device tree property
 
     Properties:
     """A device tree property
 
     Properties:


@@ -26,52 +28,17 @@ class Prop:
             bytes
         type: Value type
     """
             bytes
         type: Value type
     """

-    def __init__(self, name, byte_list_str):
-        self.name = name
-        self.value = None
+    def __init__(self, node, name, byte_list_str):
+        PropBase.__init__(self, node, 0, name)

         if not byte_list_str.strip():
         if not byte_list_str.strip():

-            self.type = fdt_util.TYPE_BOOL
+            self.type = fdt.TYPE_BOOL

             return
             return

-        bytes = [chr(int(byte, 16)) for byte in byte_list_str.strip().split(' ')]
-        self.type, self.value = fdt_util.BytesToValue(''.join(bytes))
+        self.bytes = [chr(int(byte, 16))
+                      for byte in byte_list_str.strip().split(' ')]
+        self.type, self.value = self.BytesToValue(''.join(self.bytes))

 
 

-    def GetPhandle(self):
-        """Get a (single) phandle value from a property

 
 

-        Gets the phandle valuie from a property and returns it as an integer
-        """
-        return fdt_util.fdt32_to_cpu(self.value[:4])
-
-    def Widen(self, newprop):
-        """Figure out which property type is more general
-
-        Given a current property and a new property, this function returns the
-        one that is less specific as to type. The less specific property will
-        be ble to represent the data in the more specific property. This is
-        used for things like:
-
-            node1 {
-                compatible = "fred";
-                value = <1>;
-            };
-            node1 {
-                compatible = "fred";
-                value = <1 2>;
-            };
-
-        He we want to use an int array for 'value'. The first property
-        suggests that a single int is enough, but the second one shows that
-        it is not. Calling this function with these two propertes would
-        update the current property to be like the second, since it is less
-        specific.
-        """
-        if newprop.type < self.type:
-            self.type = newprop.type
-
-        if type(newprop.value) == list and type(self.value) != list:
-            self.value = newprop.value
-
-class Node:
+class Node(NodeBase):

     """A device tree node
 
     Properties:
     """A device tree node
 
     Properties:


@@ -82,12 +49,8 @@ class Node:
         props: A dict of properties for this node, each a Prop object.
             Keyed by property name
     """
         props: A dict of properties for this node, each a Prop object.
             Keyed by property name
     """

-    def __init__(self, fdt, name, path):
-        self.name = name
-        self.path = path
-        self._fdt = fdt
-        self.subnodes = []
-        self.props = {}
+    def __init__(self, fdt, offset, name, path):
+        NodeBase.__init__(self, fdt, offset, name, path)

 
     def Scan(self):
         """Scan a node's properties and subnodes
 
     def Scan(self):
         """Scan a node's properties and subnodes


@@ -95,45 +58,43 @@ class Node:
         This fills in the props and subnodes properties, recursively
         searching into subnodes so that the entire tree is built.
         """
         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).iteritems():
-            prop = Prop(name, byte_list_str)
+        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
             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, name, path)
+            node = Node(self._fdt, 0, name, path)

             self.subnodes.append(node)
 
             node.Scan()
 
             self.subnodes.append(node)
 
             node.Scan()
 

+    def DeleteProp(self, prop_name):
+        """Delete a property of a node

 
 

-class Fdt:
-    """Provides simple access to a flat device tree blob.
+        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:
 
     Properties:

-      fname: Filename of fdt
-      _root: Root of device tree (a Node object)
+        See superclass

     """
 
     def __init__(self, fname):
     """
 
     def __init__(self, fname):

-        self.fname = fname
-
-    def Scan(self):
-        """Scan a device tree, building up a tree of Node objects
-
-        This fills in the self._root property
-        """
-        self._root = Node(self, '/', '/')
-        self._root.Scan()
-
-    def GetRoot(self):
-        """Get the root Node of the device tree
-
-        Returns:
-            The root Node object
-        """
-        return self._root
+        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
 
     def GetSubNodes(self, node):
         """Returns a list of sub-nodes of a given node


@@ -147,15 +108,14 @@ class Fdt:
         Raises:
             CmdError: if the node does not exist.
         """
         Raises:
             CmdError: if the node does not exist.
         """

-        out = command.Output('fdtget', self.fname, '-l', node)
+        out = command.Output('fdtget', self._fname, '-l', node)

         return out.strip().splitlines()
 
         return out.strip().splitlines()
 

-    def GetProps(self, node, convert_dashes=False):
+    def GetProps(self, node):

         """Get all properties from a node
 
         Args:
             node: full path to node name to look in
         """Get all properties from a node
 
         Args:
             node: full path to node name to look in

-            convert_dashes: True to convert - to _ in node names

 
         Returns:
             A dictionary containing all the properties, indexed by node name.
 
         Returns:
             A dictionary containing all the properties, indexed by node name.


@@ -165,13 +125,11 @@ class Fdt:
         Raises:
             CmdError: if the node does not exist.
         """
         Raises:
             CmdError: if the node does not exist.
         """

-        out = command.Output('fdtget', self.fname, node, '-p')
+        out = command.Output('fdtget', self._fname, node, '-p')

         props = out.strip().splitlines()
         props_dict = {}
         for prop in props:
             name = prop
         props = out.strip().splitlines()
         props_dict = {}
         for prop in props:
             name = prop

-            if convert_dashes:
-                prop = re.sub('-', '_', prop)

             props_dict[prop] = self.GetProp(node, name)
         return props_dict
 
             props_dict[prop] = self.GetProp(node, name)
         return props_dict
 


@@ -198,10 +156,26 @@ class Fdt:
         Raises:
             CmdError: if the property does not exist and no default is provided.
         """
         Raises:
             CmdError: if the property does not exist and no default is provided.
         """

-        args = [self.fname, node, prop, '-t', 'bx']
+        args = [self._fname, node, prop, '-t', 'bx']

         if default is not None:
           args += ['-d', str(default)]
         if typespec is not None:
         if default is not None:
           args += ['-d', str(default)]
         if typespec is not None:

-          args += ['-t%s' % typespec]
+          args += ['-t', typespec]

         out = command.Output('fdtget', *args)
         return out.strip()
         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