tools/dtoc/fdt_fallback.py

   1 #!/usr/bin/python
   2 #
   3 # Copyright (C) 2016 Google, Inc
   4 # Written by Simon Glass <sjg@chromium.org>
   5 #
   6 # SPDX-License-Identifier:      GPL-2.0+
   7 #
   8
   9 import command
  10 import fdt
  11 from fdt import Fdt, NodeBase, PropBase
  12 import fdt_util
  13 import sys
  14
  15 # This deals with a device tree, presenting it as a list of Node and Prop
  16 # objects, representing nodes and properties, respectively.
  17 #
  18 # This implementation uses the fdtget tool to access the device tree, so it
  19 # is not very efficient for larger trees. The tool is called once for each
  20 # node and property in the tree.
  21
  22 class Prop(PropBase):
  23     """A device tree property
  24
  25     Properties:
  26         name: Property name (as per the device tree)
  27         value: Property value as a string of bytes, or a list of strings of
  28             bytes
  29         type: Value type
  30     """
  31     def __init__(self, node, name, byte_list_str):
  32         PropBase.__init__(self, node, 0, name)
  33         if not byte_list_str.strip():
  34             self.type = fdt.TYPE_BOOL
  35             return
  36         self.bytes = [chr(int(byte, 16))
  37                       for byte in byte_list_str.strip().split(' ')]
  38         self.type, self.value = self.BytesToValue(''.join(self.bytes))
  39
  40
  41 class Node(NodeBase):
  42     """A device tree node
  43
  44     Properties:
  45         name: Device tree node tname
  46         path: Full path to node, along with the node name itself
  47         _fdt: Device tree object
  48         subnodes: A list of subnodes for this node, each a Node object
  49         props: A dict of properties for this node, each a Prop object.
  50             Keyed by property name
  51     """
  52     def __init__(self, fdt, offset, name, path):
  53         NodeBase.__init__(self, fdt, offset, name, path)
  54
  55     def Scan(self):
  56         """Scan a node's properties and subnodes
  57
  58         This fills in the props and subnodes properties, recursively
  59         searching into subnodes so that the entire tree is built.
  60         """
  61         for name, byte_list_str in self._fdt.GetProps(self.path).iteritems():
  62             prop = Prop(self, name, byte_list_str)
  63             self.props[name] = prop
  64
  65         for name in self._fdt.GetSubNodes(self.path):
  66             sep = '' if self.path[-1] == '/' else '/'
  67             path = self.path + sep + name
  68             node = Node(self._fdt, 0, name, path)
  69             self.subnodes.append(node)
  70
  71             node.Scan()
  72
  73
  74 class FdtFallback(Fdt):
  75     """Provides simple access to a flat device tree blob using fdtget/fdtput
  76
  77     Properties:
  78         See superclass
  79     """
  80
  81     def __init__(self, fname):
  82         Fdt.__init__(self, fname)
  83
  84     def GetSubNodes(self, node):
  85         """Returns a list of sub-nodes of a given node
  86
  87         Args:
  88             node: Node name to return children from
  89
  90         Returns:
  91             List of children in the node (each a string node name)
  92
  93         Raises:
  94             CmdError: if the node does not exist.
  95         """
  96         out = command.Output('fdtget', self._fname, '-l', node)
  97         return out.strip().splitlines()
  98
  99     def GetProps(self, node, convert_dashes=False):
 100         """Get all properties from a node
 101
 102         Args:
 103             node: full path to node name to look in
 104             convert_dashes: True to convert - to _ in node names
 105
 106         Returns:
 107             A dictionary containing all the properties, indexed by node name.
 108             The entries are simply strings - no decoding of lists or numbers
 109             is done.
 110
 111         Raises:
 112             CmdError: if the node does not exist.
 113         """
 114         out = command.Output('fdtget', self._fname, node, '-p')
 115         props = out.strip().splitlines()
 116         props_dict = {}
 117         for prop in props:
 118             name = prop
 119             if convert_dashes:
 120                 prop = re.sub('-', '_', prop)
 121             props_dict[prop] = self.GetProp(node, name)
 122         return props_dict
 123
 124     def GetProp(self, node, prop, default=None, typespec=None):
 125         """Get a property from a device tree.
 126
 127         This looks up the given node and property, and returns the value as a
 128         string,
 129
 130         If the node or property does not exist, this will return the default
 131         value.
 132
 133         Args:
 134             node: Full path to node to look up.
 135             prop: Property name to look up.
 136             default: Default value to return if nothing is present in the fdt,
 137                 or None to raise in this case. This will be converted to a
 138                 string.
 139             typespec: Type character to use (None for default, 's' for string)
 140
 141         Returns:
 142             string containing the property value.
 143
 144         Raises:
 145             CmdError: if the property does not exist and no default is provided.
 146         """
 147         args = [self._fname, node, prop, '-t', 'bx']
 148         if default is not None:
 149           args += ['-d', str(default)]
 150         if typespec is not None:
 151           args += ['-t%s' % typespec]
 152         out = command.Output('fdtget', *args)
 153         return out.strip()
 154
 155     @classmethod
 156     def Node(self, fdt, offset, name, path):
 157         """Create a new node
 158
 159         This is used by Fdt.Scan() to create a new node using the correct
 160         class.
 161
 162         Args:
 163             fdt: Fdt object
 164             offset: Offset of node
 165             name: Node name
 166             path: Full path to node
 167         """
 168         node = Node(fdt, offset, name, path)
 169         return node