import command
import control
import elf
+import elf_test
import fdt
from etype import fdtmap
from etype import image_header
U_BOOT_DATA = b'1234'
U_BOOT_IMG_DATA = b'img'
U_BOOT_SPL_DATA = b'56780123456789abcde'
-U_BOOT_TPL_DATA = b'tpl'
+U_BOOT_TPL_DATA = b'tpl9876543210fedcb'
BLOB_DATA = b'89'
ME_DATA = b'0abcd'
VGA_DATA = b'vga'
TestFunctional._MakeInputFile('bmpblk.bin', BMPBLK_DATA)
TestFunctional._MakeInputFile('refcode.bin', REFCODE_DATA)
+ cls._elf_testdir = os.path.join(cls._indir, 'elftest')
+ elf_test.BuildElfTestFiles(cls._elf_testdir)
+
# ELF file with a '_dt_ucode_base_size' symbol
- with open(cls.TestFile('u_boot_ucode_ptr'), 'rb') as fd:
- TestFunctional._MakeInputFile('u-boot', fd.read())
+ TestFunctional._MakeInputFile('u-boot',
+ tools.ReadFile(cls.ElfTestFile('u_boot_ucode_ptr')))
# Intel flash descriptor file
with open(cls.TestFile('descriptor.bin'), 'rb') as fd:
Args:
Filename of ELF file to use as SPL
"""
- with open(cls.TestFile(src_fname), 'rb') as fd:
- TestFunctional._MakeInputFile('spl/u-boot-spl', fd.read())
+ TestFunctional._MakeInputFile('spl/u-boot-spl',
+ tools.ReadFile(cls.ElfTestFile(src_fname)))
+
+ @classmethod
+ def _SetupTplElf(cls, src_fname='bss_data'):
+ """Set up an ELF file with a '_dt_ucode_base_size' symbol
+
+ Args:
+ Filename of ELF file to use as TPL
+ """
+ TestFunctional._MakeInputFile('tpl/u-boot-tpl',
+ tools.ReadFile(cls.ElfTestFile(src_fname)))
@classmethod
def TestFile(cls, fname):
return os.path.join(cls._binman_dir, 'test', fname)
+ @classmethod
+ def ElfTestFile(cls, fname):
+ return os.path.join(cls._elf_testdir, fname)
+
def AssertInList(self, grep_list, target):
"""Assert that at least one of a list of things is in a target
"""Test that the end-at-4gb and skip-at-size property can't be used
together"""
with self.assertRaises(ValueError) as e:
- self._DoTestFile('80_4gb_and_skip_at_start_together.dts')
+ self._DoTestFile('098_4gb_and_skip_at_start_together.dts')
self.assertIn("Image '/binman': Provide either 'end-at-4gb' or "
"'skip-at-start'", str(e.exception))
def testPackX86Rom(self):
"""Test that a basic x86 ROM can be created"""
self._SetupSplElf()
- data = self._DoReadFile('029_x86-rom.dts')
+ data = self._DoReadFile('029_x86_rom.dts')
self.assertEqual(U_BOOT_DATA + tools.GetBytes(0, 7) + U_BOOT_SPL_DATA +
tools.GetBytes(0, 2), data)
"""Test that an invalid Intel descriptor entry is detected"""
TestFunctional._MakeInputFile('descriptor.bin', b'')
with self.assertRaises(ValueError) as e:
- self._DoTestFile('031_x86-rom-me.dts')
+ self._DoTestFile('031_x86_rom_me.dts')
self.assertIn("Node '/binman/intel-descriptor': Cannot find Intel Flash Descriptor (FD) signature",
str(e.exception))
def testPackX86RomBadDesc(self):
"""Test that the Intel requires a descriptor entry"""
with self.assertRaises(ValueError) as e:
- self._DoTestFile('030_x86-rom-me-no-desc.dts')
+ self._DoTestFile('030_x86_rom_me_no_desc.dts')
self.assertIn("Node '/binman/intel-me': No offset set with "
"offset-unset: should another entry provide this correct "
"offset?", str(e.exception))
def testPackX86RomMe(self):
"""Test that an x86 ROM with an ME region can be created"""
- data = self._DoReadFile('031_x86-rom-me.dts')
+ data = self._DoReadFile('031_x86_rom_me.dts')
expected_desc = tools.ReadFile(self.TestFile('descriptor.bin'))
if data[:0x1000] != expected_desc:
self.fail('Expected descriptor binary at start of image')
def testPackVga(self):
"""Test that an image with a VGA binary can be created"""
- data = self._DoReadFile('032_intel-vga.dts')
+ data = self._DoReadFile('032_intel_vga.dts')
self.assertEqual(VGA_DATA, data[:len(VGA_DATA)])
def testPackStart16(self):
"""Test that an image with an x86 start16 region can be created"""
- data = self._DoReadFile('033_x86-start16.dts')
+ data = self._DoReadFile('033_x86_start16.dts')
self.assertEqual(X86_START16_DATA, data[:len(X86_START16_DATA)])
def testPackPowerpcMpc85xxBootpgResetvec(self):
"""Test that an image with powerpc-mpc85xx-bootpg-resetvec can be
created"""
- data = self._DoReadFile('81_powerpc_mpc85xx_bootpg_resetvec.dts')
+ data = self._DoReadFile('150_powerpc_mpc85xx_bootpg_resetvec.dts')
self.assertEqual(PPC_MPC85XX_BR_DATA, data[:len(PPC_MPC85XX_BR_DATA)])
def _RunMicrocodeTest(self, dts_fname, nodtb_data, ucode_second=False):
"""Test that a U-Boot binary without the microcode symbol is detected"""
# ELF file without a '_dt_ucode_base_size' symbol
try:
- with open(self.TestFile('u_boot_no_ucode_ptr'), 'rb') as fd:
- TestFunctional._MakeInputFile('u-boot', fd.read())
+ TestFunctional._MakeInputFile('u-boot',
+ tools.ReadFile(self.ElfTestFile('u_boot_no_ucode_ptr')))
with self.assertRaises(ValueError) as e:
self._RunPackUbootSingleMicrocode()
finally:
# Put the original file back
- with open(self.TestFile('u_boot_ucode_ptr'), 'rb') as fd:
- TestFunctional._MakeInputFile('u-boot', fd.read())
+ TestFunctional._MakeInputFile('u-boot',
+ tools.ReadFile(self.ElfTestFile('u_boot_ucode_ptr')))
def testMicrocodeNotInImage(self):
"""Test that microcode must be placed within the image"""
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'), 'rb') as fd:
- TestFunctional._MakeInputFile('u-boot', fd.read())
+ TestFunctional._MakeInputFile('u-boot',
+ tools.ReadFile(self.ElfTestFile('u_boot_no_ucode_ptr')))
data, dtb, _, _ = self._DoReadFileDtb('044_x86_optional_ucode.dts', True)
# Now check the device tree has no microcode
def testPackFsp(self):
"""Test that an image with a FSP binary can be created"""
- data = self._DoReadFile('042_intel-fsp.dts')
+ data = self._DoReadFile('042_intel_fsp.dts')
self.assertEqual(FSP_DATA, data[:len(FSP_DATA)])
def testPackCmc(self):
"""Test that an image with a CMC binary can be created"""
- data = self._DoReadFile('043_intel-cmc.dts')
+ data = self._DoReadFile('043_intel_cmc.dts')
self.assertEqual(CMC_DATA, data[:len(CMC_DATA)])
def testPackVbt(self):
"""Test that an image with a VBT binary can be created"""
- data = self._DoReadFile('046_intel-vbt.dts')
+ data = self._DoReadFile('046_intel_vbt.dts')
self.assertEqual(VBT_DATA, data[:len(VBT_DATA)])
def testSplBssPad(self):
def testPackStart16Spl(self):
"""Test that an image with an x86 start16 SPL region can be created"""
- data = self._DoReadFile('048_x86-start16-spl.dts')
+ data = self._DoReadFile('048_x86_start16_spl.dts')
self.assertEqual(X86_START16_SPL_DATA, data[:len(X86_START16_SPL_DATA)])
def _PackUbootSplMicrocode(self, dts, ucode_second=False):
def testSymbols(self):
"""Test binman can assign symbols embedded in U-Boot"""
- elf_fname = self.TestFile('u_boot_binman_syms')
+ elf_fname = self.ElfTestFile('u_boot_binman_syms')
syms = elf.GetSymbols(elf_fname, ['binman', 'image'])
addr = elf.GetSymbolAddress(elf_fname, '__image_copy_start')
self.assertEqual(syms['_binman_u_boot_spl_prop_offset'].address, addr)
self._SetupSplElf('u_boot_binman_syms')
data = self._DoReadFile('053_symbols.dts')
- sym_values = struct.pack('<LQL', 0x24 + 0, 0x24 + 24, 0x24 + 20)
+ sym_values = struct.pack('<LQL', 0, 24, 20)
expected = (sym_values + U_BOOT_SPL_DATA[16:] +
tools.GetBytes(0xff, 1) + U_BOOT_DATA + sym_values +
U_BOOT_SPL_DATA[16:])
"'other'", str(e.exception))
def testTpl(self):
- """Test that an image with TPL and ots device tree can be created"""
+ """Test that an image with TPL and its device tree can be created"""
# ELF file with a '__bss_size' symbol
- with open(self.TestFile('bss_data'), 'rb') as fd:
- TestFunctional._MakeInputFile('tpl/u-boot-tpl', fd.read())
+ self._SetupTplElf()
data = self._DoReadFile('078_u_boot_tpl.dts')
self.assertEqual(U_BOOT_TPL_DATA + U_BOOT_TPL_DTB_DATA, data)
def testPackStart16Tpl(self):
"""Test that an image with an x86 start16 TPL region can be created"""
- data = self._DoReadFile('081_x86-start16-tpl.dts')
+ data = self._DoReadFile('081_x86_start16_tpl.dts')
self.assertEqual(X86_START16_TPL_DATA, data[:len(X86_START16_TPL_DATA)])
def testSelectImage(self):
u-boot-tpl.dtb with the microcode removed
the microcode
"""
- with open(self.TestFile('u_boot_ucode_ptr'), 'rb') as fd:
- TestFunctional._MakeInputFile('tpl/u-boot-tpl', fd.read())
+ self._SetupTplElf('u_boot_ucode_ptr')
first, pos_and_size = self._RunMicrocodeTest('093_x86_tpl_ucode.dts',
U_BOOT_TPL_NODTB_DATA)
self.assertEqual(b'tplnodtb with microc' + pos_and_size +
def testElf(self):
"""Basic test of ELF entries"""
self._SetupSplElf()
- with open(self.TestFile('bss_data'), 'rb') as fd:
- TestFunctional._MakeInputFile('tpl/u-boot-tpl', fd.read())
- with open(self.TestFile('bss_data'), 'rb') as fd:
+ self._SetupTplElf()
+ with open(self.ElfTestFile('bss_data'), 'rb') as fd:
TestFunctional._MakeInputFile('-boot', fd.read())
data = self._DoReadFile('096_elf.dts')
def testElfStrip(self):
"""Basic test of ELF entries"""
self._SetupSplElf()
- with open(self.TestFile('bss_data'), 'rb') as fd:
+ with open(self.ElfTestFile('bss_data'), 'rb') as fd:
TestFunctional._MakeInputFile('-boot', fd.read())
data = self._DoReadFile('097_elf_strip.dts')
fname: Filename of input file to provide (fitimage.bin or ifwi.bin)
"""
self._SetupSplElf()
+ self._SetupTplElf()
# Intel Integrated Firmware Image (IFWI) file
with gzip.open(self.TestFile('%s.gz' % fname), 'rb') as fd:
subpart='IBBP', entry_name='IBBL')
tpl_data = tools.ReadFile(tpl_fname)
- self.assertEqual(tpl_data[:len(U_BOOT_TPL_DATA)], U_BOOT_TPL_DATA)
+ self.assertEqual(U_BOOT_TPL_DATA, tpl_data[:len(U_BOOT_TPL_DATA)])
def testPackX86RomIfwi(self):
"""Test that an x86 ROM with Integrated Firmware Image can be created"""
self._SetupIfwi('fitimage.bin')
- data = self._DoReadFile('111_x86-rom-ifwi.dts')
+ data = self._DoReadFile('111_x86_rom_ifwi.dts')
self._CheckIfwi(data)
def testPackX86RomIfwiNoDesc(self):
"""Test that an x86 ROM with IFWI can be created from an ifwi.bin file"""
self._SetupIfwi('ifwi.bin')
- data = self._DoReadFile('112_x86-rom-ifwi-nodesc.dts')
+ data = self._DoReadFile('112_x86_rom_ifwi_nodesc.dts')
self._CheckIfwi(data)
def testPackX86RomIfwiNoData(self):
"""Test that an x86 ROM with IFWI handles missing data"""
self._SetupIfwi('ifwi.bin')
with self.assertRaises(ValueError) as e:
- data = self._DoReadFile('113_x86-rom-ifwi-nodata.dts')
+ data = self._DoReadFile('113_x86_rom_ifwi_nodata.dts')
self.assertIn('Could not complete processing of contents',
str(e.exception))
data = self._DoReadFile('146_x86_reset16_tpl.dts')
self.assertEqual(X86_RESET16_TPL_DATA, data[:len(X86_RESET16_TPL_DATA)])
+ def testPackIntelFit(self):
+ """Test that an image with an Intel FIT and pointer can be created"""
+ data = self._DoReadFile('147_intel_fit.dts')
+ self.assertEqual(U_BOOT_DATA, data[:len(U_BOOT_DATA)])
+ fit = data[16:32];
+ self.assertEqual(b'_FIT_ \x01\x00\x00\x00\x00\x01\x80}' , fit)
+ ptr = struct.unpack('<i', data[0x40:0x44])[0]
+
+ image = control.images['image']
+ entries = image.GetEntries()
+ expected_ptr = entries['intel-fit'].image_pos - (1 << 32)
+ self.assertEqual(expected_ptr, ptr)
+
+ def testPackIntelFitMissing(self):
+ """Test detection of a FIT pointer with not FIT region"""
+ with self.assertRaises(ValueError) as e:
+ self._DoReadFile('148_intel_fit_missing.dts')
+ self.assertIn("'intel-fit-ptr' section must have an 'intel-fit' sibling",
+ str(e.exception))
+
+ def testSymbolsTplSection(self):
+ """Test binman can assign symbols embedded in U-Boot TPL in a section"""
+ self._SetupSplElf('u_boot_binman_syms')
+ self._SetupTplElf('u_boot_binman_syms')
+ data = self._DoReadFile('149_symbols_tpl.dts')
+ sym_values = struct.pack('<LQL', 4, 0x18, 0x30)
+ upto1 = 4 + len(U_BOOT_SPL_DATA)
+ expected1 = tools.GetBytes(0xff, 4) + sym_values + U_BOOT_SPL_DATA[16:]
+ self.assertEqual(expected1, data[:upto1])
+
+ upto2 = upto1 + 1 + len(U_BOOT_SPL_DATA)
+ expected2 = tools.GetBytes(0xff, 1) + sym_values + U_BOOT_SPL_DATA[16:]
+ self.assertEqual(expected2, data[upto1:upto2])
+
+ upto3 = 0x30 + len(U_BOOT_DATA)
+ expected3 = tools.GetBytes(0xff, 5) + U_BOOT_DATA
+ self.assertEqual(expected3, data[upto2:upto3])
+
+ expected4 = sym_values + U_BOOT_TPL_DATA[16:]
+ self.assertEqual(expected4, data[upto3:])
+
+ def testPackX86RomIfwiSectiom(self):
+ """Test that a section can be placed in an IFWI region"""
+ self._SetupIfwi('fitimage.bin')
+ data = self._DoReadFile('151_x86_rom_ifwi_section.dts')
+ self._CheckIfwi(data)
+
if __name__ == "__main__":
unittest.main()
projects / platform / kernel / u-boot.git / blobdiff