-#
+# SPDX-License-Identifier: GPL-2.0+
# Copyright (c) 2016 Google, Inc
# Written by Simon Glass <sjg@chromium.org>
#
-# SPDX-License-Identifier: GPL-2.0+
-#
# To run a single test, change to this directory, and:
#
# python -m unittest func_test.TestFunctional.testHelp
# options.verbosity = tout.DEBUG
return control.Binman(options, args)
- def _DoTestFile(self, fname, debug=False):
+ def _DoTestFile(self, fname, debug=False, map=False):
"""Run binman with a given test file
Args:
- fname: Device tree source filename to use (e.g. 05_simple.dts)
+ fname: Device-tree source filename to use (e.g. 05_simple.dts)
+ debug: True to enable debugging output
+ map: True to output map files for the images
"""
args = ['-p', '-I', self._indir, '-d', self.TestFile(fname)]
if debug:
args.append('-D')
+ if map:
+ args.append('-m')
return self._DoBinman(*args)
def _SetupDtb(self, fname, outfile='u-boot.dtb'):
Args:
fname: Filename of .dts file to read
- outfile: Output filename for compiled device tree binary
+ outfile: Output filename for compiled device-tree binary
Returns:
- Contents of device tree binary
+ Contents of device-tree binary
"""
if not self._output_setup:
tools.PrepareOutputDir(self._indir, True)
TestFunctional._MakeInputFile(outfile, data)
return data
- def _DoReadFileDtb(self, fname, use_real_dtb=False):
+ def _DoReadFileDtb(self, fname, use_real_dtb=False, map=False):
"""Run binman and return the resulting image
This runs binman with a given test file and then reads the resulting
Raises an assertion failure if binman returns a non-zero exit code.
Args:
- fname: Device tree source filename to use (e.g. 05_simple.dts)
+ fname: Device-tree source filename to use (e.g. 05_simple.dts)
use_real_dtb: True to use the test file as the contents of
the u-boot-dtb entry. Normally this is not needed and the
test contents (the U_BOOT_DTB_DATA string) can be used.
But in some test we need the real contents.
+ map: True to output map files for the images
Returns:
Tuple:
Resulting image contents
Device tree contents
+ Map data showing contents of image (or None if none)
"""
dtb_data = None
# Use the compiled test file as the u-boot-dtb input
dtb_data = self._SetupDtb(fname)
try:
- retcode = self._DoTestFile(fname)
+ retcode = self._DoTestFile(fname, map=map)
self.assertEqual(0, retcode)
# Find the (only) image, read it and return its contents
image = control.images['image']
fname = tools.GetOutputFilename('image.bin')
self.assertTrue(os.path.exists(fname))
+ if map:
+ map_fname = tools.GetOutputFilename('image.map')
+ with open(map_fname) as fd:
+ map_data = fd.read()
+ else:
+ map_data = None
with open(fname) as fd:
- return fd.read(), dtb_data
+ return fd.read(), dtb_data, map_data
finally:
# Put the test file back
if use_real_dtb:
TestFunctional._MakeInputFile('u-boot.dtb', U_BOOT_DTB_DATA)
def _DoReadFile(self, fname, use_real_dtb=False):
- """Helper function which discards the device-tree binary"""
+ """Helper function which discards the device-tree binary
+
+ Args:
+ fname: Device-tree source filename to use (e.g. 05_simple.dts)
+ use_real_dtb: True to use the test file as the contents of
+ the u-boot-dtb entry. Normally this is not needed and the
+ test contents (the U_BOOT_DTB_DATA string) can be used.
+ But in some test we need the real contents.
+ """
return self._DoReadFileDtb(fname, use_real_dtb)[0]
@classmethod
pos += entry.size
def GetFdtLen(self, dtb):
- """Get the totalsize field from a device tree binary
+ """Get the totalsize field from a device-tree binary
Args:
- dtb: Device tree binary contents
+ dtb: Device-tree binary contents
Returns:
- Total size of device tree binary, from the header
+ Total size of device-tree binary, from the header
"""
return struct.unpack('>L', dtb[4:8])[0]
"""Test that the full help is displayed with -H"""
result = self._RunBinman('-H')
help_file = os.path.join(self._binman_dir, 'README')
- self.assertEqual(len(result.stdout), os.path.getsize(help_file))
+ # Remove possible extraneous strings
+ extra = '::::::::::::::\n' + help_file + '\n::::::::::::::\n'
+ gothelp = result.stdout.replace(extra, '')
+ self.assertEqual(len(gothelp), os.path.getsize(help_file))
self.assertEqual(0, len(result.stderr))
self.assertEqual(0, result.return_code)
str(e.exception))
def testMissingDt(self):
- """Test that an invalid device tree file generates an error"""
+ """Test that an invalid device-tree file generates an error"""
with self.assertRaises(Exception) as e:
self._RunBinman('-d', 'missing_file')
# We get one error from libfdt, and a different one from fdtget.
'No such file or directory'], str(e.exception))
def testBrokenDt(self):
- """Test that an invalid device tree source file generates an error
+ """Test that an invalid device-tree source file generates an error
Since this is a source file it should be compiled and the error
will come from the device-tree compiler (dtc).
self.assertEqual(0, retcode)
self.assertIn('image', control.images)
image = control.images['image']
- entries = image._entries
+ entries = image.GetEntries()
self.assertEqual(5, len(entries))
# First u-boot
self.assertEqual(0, retcode)
self.assertIn('image', control.images)
image = control.images['image']
- entries = image._entries
+ entries = image.GetEntries()
self.assertEqual(5, len(entries))
# First u-boot with padding before and after
"""Test that entries which overflow the image size are detected"""
with self.assertRaises(ValueError) as e:
self._DoTestFile('16_pack_image_overflow.dts')
- self.assertIn("Image '/binman': contents size 0x4 (4) exceeds image "
+ self.assertIn("Section '/binman': contents size 0x4 (4) exceeds section "
"size 0x3 (3)", str(e.exception))
def testPackImageSize(self):
"""Test that invalid image alignment is detected"""
with self.assertRaises(ValueError) as e:
self._DoTestFile('19_pack_inv_image_align.dts')
- self.assertIn("Image '/binman': Size 0x7 (7) does not match "
+ self.assertIn("Section '/binman': Size 0x7 (7) does not match "
"align-size 0x8 (8)", str(e.exception))
def testPackAlignPowerOf2(self):
"""Test that invalid image alignment is detected"""
with self.assertRaises(ValueError) as e:
self._DoTestFile('20_pack_inv_image_align_power2.dts')
- self.assertIn("Image '/binman': Alignment size 131 must be a power of "
+ self.assertIn("Section '/binman': Alignment size 131 must be a power of "
"two", str(e.exception))
def testImagePadByte(self):
"""Test that the end-at-4gb property requires a size property"""
with self.assertRaises(ValueError) as e:
self._DoTestFile('27_pack_4gb_no_size.dts')
- self.assertIn("Image '/binman': Image size must be provided when "
+ self.assertIn("Section '/binman': Section size must be provided when "
"using end-at-4gb", str(e.exception))
def testPackX86RomOutside(self):
with self.assertRaises(ValueError) as e:
self._DoTestFile('28_pack_4gb_outside.dts')
self.assertIn("Node '/binman/u-boot': Position 0x0 (0) is outside "
- "the image starting at 0xffffffe0 (4294967264)",
+ "the section starting at 0xffffffe0 (4294967264)",
str(e.exception))
def testPackX86Rom(self):
data = self._DoReadFile('33_x86-start16.dts')
self.assertEqual(X86_START16_DATA, data[:len(X86_START16_DATA)])
- def _RunMicrocodeTest(self, dts_fname, nodtb_data):
+ def _RunMicrocodeTest(self, dts_fname, nodtb_data, ucode_second=False):
+ """Handle running a test for insertion of microcode
+
+ Args:
+ dts_fname: Name of test .dts file
+ nodtb_data: Data that we expect in the first section
+ ucode_second: True if the microsecond entry is second instead of
+ third
+
+ Returns:
+ Tuple:
+ Contents of first region (U-Boot or SPL)
+ Position and size components of microcode pointer, as inserted
+ in the above (two 4-byte words)
+ """
data = self._DoReadFile(dts_fname, True)
# Now check the device tree has no microcode
- second = data[len(nodtb_data):]
+ if ucode_second:
+ ucode_content = data[len(nodtb_data):]
+ ucode_pos = len(nodtb_data)
+ dtb_with_ucode = ucode_content[16:]
+ fdt_len = self.GetFdtLen(dtb_with_ucode)
+ else:
+ dtb_with_ucode = data[len(nodtb_data):]
+ fdt_len = self.GetFdtLen(dtb_with_ucode)
+ ucode_content = dtb_with_ucode[fdt_len:]
+ ucode_pos = len(nodtb_data) + fdt_len
fname = tools.GetOutputFilename('test.dtb')
with open(fname, 'wb') as fd:
- fd.write(second)
+ fd.write(dtb_with_ucode)
dtb = fdt.FdtScan(fname)
ucode = dtb.GetNode('/microcode')
self.assertTrue(ucode)
for node in ucode.subnodes:
self.assertFalse(node.props.get('data'))
- fdt_len = self.GetFdtLen(second)
- third = second[fdt_len:]
-
# Check that the microcode appears immediately after the Fdt
# This matches the concatenation of the data properties in
# the /microcode/update@xxx nodes in 34_x86_ucode.dts.
ucode_data = struct.pack('>4L', 0x12345678, 0x12345679, 0xabcd0000,
0x78235609)
- self.assertEqual(ucode_data, third[:len(ucode_data)])
- ucode_pos = len(nodtb_data) + fdt_len
+ self.assertEqual(ucode_data, ucode_content[:len(ucode_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(nodtb_data)]
- return first, pos_and_size
+ u_boot = data[:len(nodtb_data)]
+ return u_boot, pos_and_size
def testPackUbootMicrocode(self):
"""Test that x86 microcode can be handled correctly
self._DoReadFile('40_x86_ucode_not_in_image.dts', True)
self.assertIn("Node '/binman/u-boot-with-ucode-ptr': Microcode "
"pointer _dt_ucode_base_size at fffffe14 is outside the "
- "image ranging from 00000000 to 0000002e", str(e.exception))
+ "section ranging from 00000000 to 0000002e", str(e.exception))
def testWithoutMicrocode(self):
"""Test that we can cope with an image without microcode (e.g. qemu)"""
with open(self.TestFile('u_boot_no_ucode_ptr')) as fd:
TestFunctional._MakeInputFile('u-boot', fd.read())
- data, dtb = self._DoReadFileDtb('44_x86_optional_ucode.dts', True)
+ data, dtb, _ = self._DoReadFileDtb('44_x86_optional_ucode.dts', True)
# Now check the device tree has no microcode
self.assertEqual(U_BOOT_NODTB_DATA, data[:len(U_BOOT_NODTB_DATA)])
"""Test that microcode must be placed within the image"""
with self.assertRaises(ValueError) as e:
self._DoReadFile('41_unknown_pos_size.dts', True)
- self.assertIn("Image '/binman': Unable to set pos/size for unknown "
+ self.assertIn("Section '/binman': Unable to set pos/size for unknown "
"entry 'invalid-entry'", str(e.exception))
def testPackFsp(self):
data = self._DoReadFile('48_x86-start16-spl.dts')
self.assertEqual(X86_START16_SPL_DATA, data[:len(X86_START16_SPL_DATA)])
- def testPackUbootSplMicrocode(self):
- """Test that x86 microcode can be handled correctly in SPL
+ def _PackUbootSplMicrocode(self, dts, ucode_second=False):
+ """Helper function for microcode tests
We expect to see the following in the image, in order:
u-boot-spl-nodtb.bin with a microcode pointer inserted at the
correct place
u-boot.dtb with the microcode removed
the microcode
+
+ Args:
+ dts: Device tree file to use for test
+ ucode_second: True if the microsecond entry is second instead of
+ third
"""
# ELF file with a '_dt_ucode_base_size' symbol
with open(self.TestFile('u_boot_ucode_ptr')) as fd:
TestFunctional._MakeInputFile('spl/u-boot-spl', fd.read())
- first, pos_and_size = self._RunMicrocodeTest('49_x86_ucode_spl.dts',
- U_BOOT_SPL_NODTB_DATA)
+ first, pos_and_size = self._RunMicrocodeTest(dts, U_BOOT_SPL_NODTB_DATA,
+ ucode_second=ucode_second)
self.assertEqual('splnodtb with microc' + pos_and_size +
'ter somewhere in here', first)
+ def testPackUbootSplMicrocode(self):
+ """Test that x86 microcode can be handled correctly in SPL"""
+ self._PackUbootSplMicrocode('49_x86_ucode_spl.dts')
+
+ def testPackUbootSplMicrocodeReorder(self):
+ """Test that order doesn't matter for microcode entries
+
+ This is the same as testPackUbootSplMicrocode but when we process the
+ u-boot-ucode entry we have not yet seen the u-boot-dtb-with-ucode
+ entry, so we reply on binman to try later.
+ """
+ self._PackUbootSplMicrocode('58_x86_ucode_spl_needs_retry.dts',
+ ucode_second=True)
+
def testPackMrc(self):
"""Test that an image with an MRC binary can be created"""
data = self._DoReadFile('50_intel_mrc.dts')
sym_values + U_BOOT_SPL_DATA[16:])
self.assertEqual(expected, data)
+ def testPackUnitAddress(self):
+ """Test that we support multiple binaries with the same name"""
+ data = self._DoReadFile('54_unit_address.dts')
+ self.assertEqual(U_BOOT_DATA + U_BOOT_DATA, data)
+
+ def testSections(self):
+ """Basic test of sections"""
+ data = self._DoReadFile('55_sections.dts')
+ expected = U_BOOT_DATA + '!' * 12 + U_BOOT_DATA + 'a' * 12 + '&' * 8
+ self.assertEqual(expected, data)
+
+ def testMap(self):
+ """Tests outputting a map of the images"""
+ _, _, map_data = self._DoReadFileDtb('55_sections.dts', map=True)
+ self.assertEqual('''Position Size Name
+00000000 00000010 section@0
+ 00000000 00000004 u-boot
+00000010 00000010 section@1
+ 00000000 00000004 u-boot
+''', map_data)
+
+ def testNamePrefix(self):
+ """Tests that name prefixes are used"""
+ _, _, map_data = self._DoReadFileDtb('56_name_prefix.dts', map=True)
+ self.assertEqual('''Position Size Name
+00000000 00000010 section@0
+ 00000000 00000004 ro-u-boot
+00000010 00000010 section@1
+ 00000000 00000004 rw-u-boot
+''', map_data)
+
+ def testUnknownContents(self):
+ """Test that obtaining the contents works as expected"""
+ with self.assertRaises(ValueError) as e:
+ self._DoReadFile('57_unknown_contents.dts', True)
+ self.assertIn("Section '/binman': Internal error: Could not complete "
+ "processing of contents: remaining [<_testing.Entry__testing ",
+ str(e.exception))
+
+ def testBadChangeSize(self):
+ """Test that trying to change the size of an entry fails"""
+ with self.assertRaises(ValueError) as e:
+ self._DoReadFile('59_change_size.dts', True)
+ self.assertIn("Node '/binman/_testing': Cannot update entry size from "
+ '2 to 1', str(e.exception))
+
if __name__ == "__main__":
unittest.main()