import fdt_util
import libfdt
+from libfdt import QUIET_NOTFOUND
# This deals with a device tree, presenting it as an assortment of Node and
# Prop objects, representing nodes and properties, respectively. This file
else:
return TYPE_INT, val
+ @classmethod
def GetEmpty(self, type):
"""Get an empty / zero value of the given type
This fills in the props and subnodes properties, recursively
searching into subnodes so that the entire tree is built.
"""
+ fdt_obj = self._fdt._fdt_obj
self.props = self._fdt.GetProps(self)
- phandle = self.props.get('phandle')
+ phandle = fdt_obj.get_phandle(self.Offset())
if phandle:
- val = fdt_util.fdt32_to_cpu(phandle.value)
- self._fdt.phandle_to_node[val] = self
+ self._fdt.phandle_to_node[phandle] = self
- offset = libfdt.fdt_first_subnode(self._fdt.GetFdt(), self.Offset())
+ offset = fdt_obj.first_subnode(self.Offset(), QUIET_NOTFOUND)
while offset >= 0:
sep = '' if self.path[-1] == '/' else '/'
- name = self._fdt._fdt_obj.get_name(offset)
+ name = fdt_obj.get_name(offset)
path = self.path + sep + name
node = Node(self._fdt, self, offset, name, path)
self.subnodes.append(node)
node.Scan()
- offset = libfdt.fdt_next_subnode(self._fdt.GetFdt(), offset)
+ offset = fdt_obj.next_subnode(offset, QUIET_NOTFOUND)
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.
"""
+ fdt_obj = self._fdt._fdt_obj
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)
+ offset = fdt_obj.first_subnode(self._offset, QUIET_NOTFOUND)
for subnode in self.subnodes:
subnode.Refresh(offset)
- offset = libfdt.fdt_next_subnode(self._fdt.GetFdt(), offset)
+ offset = fdt_obj.next_subnode(offset, QUIET_NOTFOUND)
def DeleteProp(self, prop_name):
"""Delete a property of a node
Raises:
ValueError if the property does not exist
"""
- CheckErr(libfdt.fdt_delprop(self._fdt.GetFdt(), self.Offset(), prop_name),
+ CheckErr(self._fdt._fdt_obj.delprop(self.Offset(), prop_name),
"Node '%s': delete property: '%s'" % (self.path, prop_name))
del self.props[prop_name]
self._fdt.Invalidate()
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)
+ self._fdt_obj = libfdt.Fdt(fd.read())
def Scan(self, root='/'):
"""Scan a device tree, building up a tree of Node objects
If the device tree has changed in memory, write it back to the file.
"""
with open(self._fname, 'wb') as fd:
- fd.write(self._fdt)
+ fd.write(self._fdt_obj.as_bytearray())
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.
"""
- CheckErr(libfdt.fdt_pack(self._fdt), 'pack')
- fdt_len = libfdt.fdt_totalsize(self._fdt)
- del self._fdt[fdt_len:]
+ CheckErr(self._fdt_obj.pack(), 'pack')
+ self.Invalidate()
- def GetFdt(self):
+ def GetContents(self):
"""Get the contents of the FDT
Returns:
The FDT contents as a string of bytes
"""
- return self._fdt
+ return self._fdt_obj.as_bytearray()
+
+ def GetFdtObj(self):
+ """Get the contents of the FDT
- def CheckErr(errnum, msg):
+ Returns:
+ The FDT contents as a libfdt.Fdt object
+ """
+ return self._fdt_obj
+
+ def CheckErr(self, 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.
ValueError: if the node does not exist.
"""
props_dict = {}
- poffset = libfdt.fdt_first_property_offset(self._fdt, node._offset)
+ poffset = self._fdt_obj.first_property_offset(node._offset,
+ QUIET_NOTFOUND)
while poffset >= 0:
p = self._fdt_obj.get_property_by_offset(poffset)
- prop = Prop(node, poffset, p.name, p.value)
+ prop = Prop(node, poffset, p.name, p)
props_dict[prop.name] = prop
- poffset = libfdt.fdt_next_property_offset(self._fdt, poffset)
+ poffset = self._fdt_obj.next_property_offset(poffset,
+ QUIET_NOTFOUND)
return props_dict
def Invalidate(self):
Returns:
Position of @offset within the device tree binary
"""
- return libfdt.fdt_off_dt_struct(self._fdt) + offset
+ return self._fdt_obj.off_dt_struct() + offset
@classmethod
def Node(self, fdt, parent, offset, name, path):