fdt: Drop fdt_fallback library
Drop this now-unused library and associated tests. Signed-off-by: Simon Glass <sjg@chromium.org>
This commit is contained in:
Simon Glass
parent
6d804eafc1
commit
160a766425
@ -82,13 +82,3 @@ class TestFdt(unittest.TestCase):
|
||||
self.assertEquals(list, type(prop.value))
|
||||
self.assertEquals(3, len(prop.value))
|
||||
self.assertEquals(['another', 'multi-word', 'message'], prop.value)
|
||||
|
||||
def testFdtFallback(self):
|
||||
fname = self.GetCompiled('34_x86_ucode.dts')
|
||||
dt = FdtScan(fname, True)
|
||||
dt.GetProp('/microcode/update@0', 'data')
|
||||
self.assertEqual('fred',
|
||||
dt.GetProp('/microcode/update@0', 'none', default='fred'))
|
||||
self.assertEqual('12345678 12345679',
|
||||
dt.GetProp('/microcode/update@0', 'data', typespec='x'))
|
||||
self._DeleteProp(dt)
|
||||
|
||||
@ -683,7 +683,7 @@ class TestFunctional(unittest.TestCase):
|
||||
self.assertEqual('nodtb with microcode' + pos_and_size +
|
||||
' somewhere in here', first)
|
||||
|
||||
def _RunPackUbootSingleMicrocode(self, collate):
|
||||
def _RunPackUbootSingleMicrocode(self):
|
||||
"""Test that x86 microcode can be handled correctly
|
||||
|
||||
We expect to see the following in the image, in order:
|
||||
@ -695,8 +695,6 @@ class TestFunctional(unittest.TestCase):
|
||||
# We need the libfdt library to run this test since only that allows
|
||||
# finding the offset of a property. This is required by
|
||||
# Entry_u_boot_dtb_with_ucode.ObtainContents().
|
||||
if not fdt_select.have_libfdt:
|
||||
return
|
||||
data = self._DoReadFile('35_x86_single_ucode.dts', True)
|
||||
|
||||
second = data[len(U_BOOT_NODTB_DATA):]
|
||||
@ -705,34 +703,22 @@ class TestFunctional(unittest.TestCase):
|
||||
third = second[fdt_len:]
|
||||
second = second[:fdt_len]
|
||||
|
||||
if not collate:
|
||||
ucode_data = struct.pack('>2L', 0x12345678, 0x12345679)
|
||||
self.assertIn(ucode_data, second)
|
||||
ucode_pos = second.find(ucode_data) + len(U_BOOT_NODTB_DATA)
|
||||
ucode_data = struct.pack('>2L', 0x12345678, 0x12345679)
|
||||
self.assertIn(ucode_data, second)
|
||||
ucode_pos = second.find(ucode_data) + len(U_BOOT_NODTB_DATA)
|
||||
|
||||
# Check that the microcode pointer was inserted. It should match the
|
||||
# expected position and size
|
||||
pos_and_size = struct.pack('<2L', 0xfffffe00 + ucode_pos,
|
||||
len(ucode_data))
|
||||
first = data[:len(U_BOOT_NODTB_DATA)]
|
||||
self.assertEqual('nodtb with microcode' + pos_and_size +
|
||||
' somewhere in here', first)
|
||||
# Check that the microcode pointer was inserted. It should match the
|
||||
# expected position and size
|
||||
pos_and_size = struct.pack('<2L', 0xfffffe00 + ucode_pos,
|
||||
len(ucode_data))
|
||||
first = data[:len(U_BOOT_NODTB_DATA)]
|
||||
self.assertEqual('nodtb with microcode' + pos_and_size +
|
||||
' somewhere in here', first)
|
||||
|
||||
def testPackUbootSingleMicrocode(self):
|
||||
"""Test that x86 microcode can be handled correctly with fdt_normal.
|
||||
"""
|
||||
self._RunPackUbootSingleMicrocode(False)
|
||||
|
||||
def testPackUbootSingleMicrocodeFallback(self):
|
||||
"""Test that x86 microcode can be handled correctly with fdt_fallback.
|
||||
|
||||
This only supports collating the microcode.
|
||||
"""
|
||||
try:
|
||||
old_val = fdt_select.UseFallback(True)
|
||||
self._RunPackUbootSingleMicrocode(True)
|
||||
finally:
|
||||
fdt_select.UseFallback(old_val)
|
||||
self._RunPackUbootSingleMicrocode()
|
||||
|
||||
def testUBootImg(self):
|
||||
"""Test that u-boot.img can be put in a file"""
|
||||
@ -763,14 +749,12 @@ class TestFunctional(unittest.TestCase):
|
||||
def testMicrocodeWithoutPtrInElf(self):
|
||||
"""Test that a U-Boot binary without the microcode symbol is detected"""
|
||||
# ELF file without a '_dt_ucode_base_size' symbol
|
||||
if not fdt_select.have_libfdt:
|
||||
return
|
||||
try:
|
||||
with open(self.TestFile('u_boot_no_ucode_ptr')) as fd:
|
||||
TestFunctional._MakeInputFile('u-boot', fd.read())
|
||||
|
||||
with self.assertRaises(ValueError) as e:
|
||||
self._RunPackUbootSingleMicrocode(False)
|
||||
self._RunPackUbootSingleMicrocode()
|
||||
self.assertIn("Node '/binman/u-boot-with-ucode-ptr': Cannot locate "
|
||||
"_dt_ucode_base_size symbol in u-boot", str(e.exception))
|
||||
|
||||
|
||||
@ -14,8 +14,8 @@ import fdt_util
|
||||
# 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 FdtFallback and FdtNormal subclasses. See
|
||||
# fdt_select.py for how to create an Fdt object.
|
||||
# implementation is in the FdtNormal subclass. See fdt_select.py for how to
|
||||
# create an Fdt object.
|
||||
|
||||
# A list of types we support
|
||||
(TYPE_BYTE, TYPE_INT, TYPE_STRING, TYPE_BOOL) = range(4)
|
||||
|
||||
@ -1,181 +0,0 @@
|
||||
#!/usr/bin/python
|
||||
#
|
||||
# Copyright (C) 2016 Google, Inc
|
||||
# Written by Simon Glass <sjg@chromium.org>
|
||||
#
|
||||
# SPDX-License-Identifier: GPL-2.0+
|
||||
#
|
||||
|
||||
import command
|
||||
import fdt
|
||||
from fdt import Fdt, NodeBase, PropBase
|
||||
import fdt_util
|
||||
import sys
|
||||
|
||||
# This deals with a device tree, presenting it as a list of Node and Prop
|
||||
# objects, representing nodes and properties, respectively.
|
||||
#
|
||||
# This implementation uses the fdtget tool to access the device tree, so it
|
||||
# is not very efficient for larger trees. The tool is called once for each
|
||||
# node and property in the tree.
|
||||
|
||||
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, name, byte_list_str):
|
||||
PropBase.__init__(self, node, 0, name)
|
||||
if not byte_list_str.strip():
|
||||
self.type = fdt.TYPE_BOOL
|
||||
return
|
||||
self.bytes = [chr(int(byte, 16))
|
||||
for byte in byte_list_str.strip().split(' ')]
|
||||
self.type, self.value = self.BytesToValue(''.join(self.bytes))
|
||||
|
||||
|
||||
class Node(NodeBase):
|
||||
"""A device tree node
|
||||
|
||||
Properties:
|
||||
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 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.
|
||||
"""
|
||||
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
|
||||
node = Node(self._fdt, 0, name, path)
|
||||
self.subnodes.append(node)
|
||||
|
||||
node.Scan()
|
||||
|
||||
def DeleteProp(self, prop_name):
|
||||
"""Delete a property of a node
|
||||
|
||||
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:
|
||||
See superclass
|
||||
"""
|
||||
|
||||
def __init__(self, fname):
|
||||
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
|
||||
|
||||
Args:
|
||||
node: Node name to return children from
|
||||
|
||||
Returns:
|
||||
List of children in the node (each a string node name)
|
||||
|
||||
Raises:
|
||||
CmdError: if the node does not exist.
|
||||
"""
|
||||
out = command.Output('fdtget', self._fname, '-l', node)
|
||||
return out.strip().splitlines()
|
||||
|
||||
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 simply strings - no decoding of lists or numbers
|
||||
is done.
|
||||
|
||||
Raises:
|
||||
CmdError: if the node does not exist.
|
||||
"""
|
||||
out = command.Output('fdtget', self._fname, node, '-p')
|
||||
props = out.strip().splitlines()
|
||||
props_dict = {}
|
||||
for prop in props:
|
||||
name = prop
|
||||
props_dict[prop] = self.GetProp(node, name)
|
||||
return props_dict
|
||||
|
||||
def GetProp(self, node, prop, default=None, typespec=None):
|
||||
"""Get a property from a device tree.
|
||||
|
||||
This looks up the given node and property, and returns the value as a
|
||||
string,
|
||||
|
||||
If the node or property does not exist, this will return the default
|
||||
value.
|
||||
|
||||
Args:
|
||||
node: Full path to node to look up.
|
||||
prop: Property name to look up.
|
||||
default: Default value to return if nothing is present in the fdt,
|
||||
or None to raise in this case. This will be converted to a
|
||||
string.
|
||||
typespec: Type character to use (None for default, 's' for string)
|
||||
|
||||
Returns:
|
||||
string containing the property value.
|
||||
|
||||
Raises:
|
||||
CmdError: if the property does not exist and no default is provided.
|
||||
"""
|
||||
args = [self._fname, node, prop, '-t', 'bx']
|
||||
if default is not None:
|
||||
args += ['-d', str(default)]
|
||||
if typespec is not None:
|
||||
args += ['-t', typespec]
|
||||
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
|
||||
@ -6,31 +6,13 @@
|
||||
# SPDX-License-Identifier: GPL-2.0+
|
||||
#
|
||||
|
||||
import fdt_fallback
|
||||
|
||||
# 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.
|
||||
try:
|
||||
import fdt_normal
|
||||
have_libfdt = True
|
||||
except ImportError:
|
||||
have_libfdt = False
|
||||
import fdt_normal
|
||||
|
||||
force_fallback = False
|
||||
|
||||
def FdtScan(fname, _force_fallback=False):
|
||||
def FdtScan(fname):
|
||||
"""Returns a new Fdt object from the implementation we are using"""
|
||||
if have_libfdt and not force_fallback and not _force_fallback:
|
||||
dtb = fdt_normal.FdtNormal(fname)
|
||||
else:
|
||||
dtb = fdt_fallback.FdtFallback(fname)
|
||||
dtb = fdt_normal.FdtNormal(fname)
|
||||
dtb.Scan()
|
||||
return dtb
|
||||
|
||||
def UseFallback(fallback):
|
||||
global force_fallback
|
||||
|
||||
old_val = force_fallback
|
||||
force_fallback = fallback
|
||||
return old_val
|
||||
|
||||
Loading…
Reference in New Issue
Block a user