GitHub-Mirror/u-boot
2
0
Fork 0
mirror of https://github.com/Fishwaldo/u-boot.git synced 2025-06-06 06:41:40 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

fdt: Merge fdt_normal with its base class

Browse source 
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>
This commit is contained in:
Simon Glass 2017-05-27 07:38:28 -06:00
parent 515d3f0801
commit 7b75b4482d
3 changed files with 158 additions and 254 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

178
tools/dtoc/fdt.py
View file

@ -10,12 +10,15 @@ import struct
import sys import sys
import fdt_util import fdt_util
import libfdt
# This deals with a device tree, presenting it as an assortment of Node and # This deals with a device tree, presenting it as an assortment of Node and
# Prop objects, representing nodes and properties, respectively. This file # Prop objects, representing nodes and properties, respectively. This file
# contains the base classes and defines the high-level API. Most of the # contains the base classes and defines the high-level API. See fdt_select.py
# implementation is in the FdtNormal subclass. See fdt_select.py for how to # for how to create an Fdt object.
# 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 # A list of types we support
(TYPE_BYTE, TYPE_INT, TYPE_STRING, TYPE_BOOL) = range(4) (TYPE_BYTE, TYPE_INT, TYPE_STRING, TYPE_BOOL) = range(4)
@ -25,7 +28,7 @@ def CheckErr(errnum, msg):
raise ValueError('Error %d: %s: %s' % raise ValueError('Error %d: %s: %s' %
(errnum, libfdt.fdt_strerror(errnum), msg)) (errnum, libfdt.fdt_strerror(errnum), msg))
class PropBase: class Prop:
"""A device tree property """A device tree property
Properties: Properties:
@ -34,11 +37,17 @@ class PropBase:
bytes bytes
type: Value type type: Value type
""" """
def __init__(self, node, offset, name): def __init__(self, node, offset, name, bytes):
self._node = node self._node = node
self._offset = offset self._offset = offset
self.name = name self.name = name
self.value = None 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): def GetPhandle(self):
"""Get a (single) phandle value from a property """Get a (single) phandle value from a property
@ -148,15 +157,12 @@ class PropBase:
def GetOffset(self): def GetOffset(self):
"""Get the offset of a property """Get the offset of a property
This can be implemented by subclasses.
Returns: Returns:
The offset of the property (struct fdt_property) within the The offset of the property (struct fdt_property) within the file
file, or None if not known.
""" """
return None return self._node._fdt.GetStructOffset(self._offset)
class NodeBase: class Node:
"""A device tree node """A device tree node
Properties: Properties:
@ -189,25 +195,65 @@ class NodeBase:
return subnode return subnode
return None return None
def Scan(self): def Offset(self):
"""Scan the subnodes of a node """Returns the offset of a node, after checking the cache
This should be implemented by subclasses This should be used instead of self._offset directly, to ensure that
the cache does not contain invalid offsets.
""" """
raise NotImplementedError() 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): def DeleteProp(self, prop_name):
"""Delete a property of a node """Delete a property of a node
This should be implemented by subclasses The property is deleted and the offset cache is invalidated.
Args: Args:
prop_name: Name of the property to delete 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: class Fdt:
"""Provides simple access to a flat device tree blob. """Provides simple access to a flat device tree blob using libfdts.
Properties: Properties:
fname: Filename of fdt fname: Filename of fdt
@ -215,6 +261,13 @@ class Fdt:
""" """
def __init__(self, fname): def __init__(self, fname):
self._fname = 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='/'): def Scan(self, root='/'):
"""Scan a device tree, building up a tree of Node objects """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 """Flush device tree changes back to the file
If the device tree has changed in memory, write it 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): def Pack(self):
"""Pack the device tree down to its minimum size """Pack the device tree down to its minimum size
When nodes and properties shrink or are deleted, wasted space can When nodes and properties shrink or are deleted, wasted space can
build up in the device tree binary. Subclasses can implement this build up in the device tree binary.
to remove that spare space.
""" """
pass 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
"""
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

226
tools/dtoc/fdt_normal.py
View file

@ -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

8
tools/dtoc/fdt_select.py
View file

@ -6,13 +6,11 @@
# SPDX-License-Identifier: GPL-2.0+ # SPDX-License-Identifier: GPL-2.0+
# #
# Bring in either the normal fdt library (which relies on libfdt) or the # Bring in the normal fdt library (which relies on libfdt)
# fallback one (which uses fdtget and is slower). Both provide the same import fdt
# interface for this file to use.
import fdt_normal
def FdtScan(fname): def FdtScan(fname):
"""Returns a new Fdt object from the implementation we are using""" """Returns a new Fdt object from the implementation we are using"""
dtb = fdt_normal.FdtNormal(fname) dtb = fdt.Fdt(fname)
dtb.Scan() dtb.Scan()
return dtb return dtb