Mirrors/u-boot
2
0
Fork 0
mirror of https://github.com/AsahiLinux/u-boot synced 2024-11-25 22:20:45 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge git://git.denx.de/u-boot-dm

Browse source
This commit is contained in:
Tom Rini 2017-11-23 22:48:35 -05:00
commit bb7ab1ccfe
25 changed files with 455 additions and 138 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
scripts/Makefile.lib
View file

@ -165,17 +165,27 @@ cpp_flags = -Wp,-MD,$(depfile) $(NOSTDINC_FLAGS) $(UBOOTINCLUDE) \
ld_flags = $(LDFLAGS) $(ldflags-y)
# Try these files in order to find the U-Boot-specific .dtsi include file
u_boot_dtsi_options = $(wildcard $(dir $<)$(basename $(notdir $<))-u-boot.dtsi) \
u_boot_dtsi_options = $(strip $(wildcard $(dir $<)$(basename $(notdir $<))-u-boot.dtsi) \
$(wildcard $(dir $<)$(subst $\",,$(CONFIG_SYS_SOC))-u-boot.dtsi) \
$(wildcard $(dir $<)$(subst $\",,$(CONFIG_SYS_CPU))-u-boot.dtsi) \
$(wildcard $(dir $<)$(subst $\",,$(CONFIG_SYS_VENDOR))-u-boot.dtsi) \
$(wildcard $(dir $<)u-boot.dtsi)
$(wildcard $(dir $<)u-boot.dtsi))
u_boot_dtsi_options_raw = $(warning Automatic .dtsi inclusion: options: \
$(dir $<)$(basename $(notdir $<))-u-boot.dtsi \
$(dir $<)$(subst $\",,$(CONFIG_SYS_SOC))-u-boot.dtsi \
$(dir $<)$(subst $\",,$(CONFIG_SYS_CPU))-u-boot.dtsi \
$(dir $<)$(subst $\",,$(CONFIG_SYS_VENDOR))-u-boot.dtsi \
$(dir $<)u-boot.dtsi ... \
found: $(if $(u_boot_dtsi_options),"$(u_boot_dtsi_options)",nothing!))
# Uncomment for debugging
# $(warning u_boot_dtsi_options: $(u_boot_dtsi_options))
# This shows all the files that were considered and the one that we chose.
# u_boot_dtsi_options_debug = $(u_boot_dtsi_options_raw)
# We use the first match
u_boot_dtsi = $(notdir $(firstword $(u_boot_dtsi_options)))
u_boot_dtsi = $(strip $(u_boot_dtsi_options_debug) \
$(notdir $(firstword $(u_boot_dtsi_options))))
# Modified for U-Boot
dtc_cpp_flags = -Wp,-MD,$(depfile).pre.tmp -nostdinc \

20
test/run
View file

@ -1,10 +1,24 @@
#!/bin/sh
#!/bin/bash
run_test() {
$@
[ $? -ne 0 ] && result=$((result+1))
echo "result $result"
}
# Run all tests that the standard sandbox build can support
./test/py/test.py --bd sandbox --build
run_test ./test/py/test.py --bd sandbox --build
# Run tests which require sandbox_spl
./test/py/test.py --bd sandbox_spl --build -k test/py/tests/test_ofplatdata.py
run_test ./test/py/test.py --bd sandbox_spl --build -k \
test/py/tests/test_ofplatdata.py
# Run tests for the flat DT version of sandbox
./test/py/test.py --bd sandbox_flattree --build
if [ $result == 0 ]; then
echo "Tests passed!"
else
echo "Tests FAILED"
exit 1
fi

24
tools/binman/README
View file

@ -206,6 +206,27 @@ for its instructions in the 'binman' node.
Binman has a few other options which you can see by running 'binman -h'.
Enabling binman for a board
---------------------------
At present binman is invoked from a rule in the main Makefile. Typically you
will have a rule like:
ifneq ($(CONFIG_ARCH_<something>),)
u-boot-<your_suffix>.bin: <input_file_1> <input_file_2> checkbinman FORCE
$(call if_changed,binman)
endif
This assumes that u-boot-<your_suffix>.bin is a target, and is the final file
that you need to produce. You can make it a target by adding it to ALL-y
either in the main Makefile or in a config.mk file in your arch subdirectory.
Once binman is executed it will pick up its instructions from a device-tree
file, typically <soc>-u-boot.dtsi, where <soc> is your CONFIG_SYS_SOC value.
You can use other, more specific CONFIG options - see 'Automatic .dtsi
inclusion' below.
Image description format
------------------------
@ -446,7 +467,8 @@ If you are having trouble figuring out what is going on, you can uncomment
the 'warning' line in scripts/Makefile.lib to see what it has found:
# Uncomment for debugging
# $(warning binman_dtsi_options: $(binman_dtsi_options))
# This shows all the files that were considered and the one that we chose.
# u_boot_dtsi_options_debug = $(u_boot_dtsi_options_raw)
Code coverage

42
tools/binman/binman.py
View file

@ -10,6 +10,7 @@
"""See README for more information"""
import glob
import os
import sys
import traceback
@ -34,7 +35,7 @@ def RunTests():
"""Run the functional tests and any embedded doctests"""
import entry_test
import fdt_test
import func_test
import ftest
import test
import doctest
@ -44,8 +45,12 @@ def RunTests():
suite.run(result)
sys.argv = [sys.argv[0]]
for module in (func_test.TestFunctional, fdt_test.TestFdt,
entry_test.TestEntry):
# Run the entry tests first ,since these need to be the first to import the
# 'entry' module.
suite = unittest.TestLoader().loadTestsFromTestCase(entry_test.TestEntry)
suite.run(result)
for module in (ftest.TestFunctional, fdt_test.TestFdt):
suite = unittest.TestLoader().loadTestsFromTestCase(module)
suite.run(result)
@ -53,22 +58,41 @@ def RunTests():
for test, err in result.errors:
print test.id(), err
for test, err in result.failures:
print err
print err, result.failures
if result.errors or result.failures:
print 'binman tests FAILED'
return 1
return 0
def RunTestCoverage():
"""Run the tests and check that we get 100% coverage"""
# This uses the build output from sandbox_spl to get _libfdt.so
cmd = ('PYTHONPATH=%s/sandbox_spl/tools coverage run '
cmd = ('PYTHONPATH=$PYTHONPATH:%s/sandbox_spl/tools coverage run '
'--include "tools/binman/*.py" --omit "*test*,*binman.py" '
'tools/binman/binman.py -t' % options.build_dir)
os.system(cmd)
stdout = command.Output('coverage', 'report')
coverage = stdout.splitlines()[-1].split(' ')[-1]
lines = stdout.splitlines()
test_set= set([os.path.basename(line.split()[0])
for line in lines if '/etype/' in line])
glob_list = glob.glob(os.path.join(our_path, 'etype/*.py'))
all_set = set([os.path.basename(item) for item in glob_list])
missing_list = all_set
missing_list.difference_update(test_set)
missing_list.remove('_testing.py')
coverage = lines[-1].split(' ')[-1]
ok = True
if missing_list:
print 'Missing tests for %s' % (', '.join(missing_list))
ok = False
if coverage != '100%':
print stdout
print "Type 'coverage html' to get a report in htmlcov/index.html"
raise ValueError('Coverage error: %s, but should be 100%%' % coverage)
print 'Coverage error: %s, but should be 100%%' % coverage
ok = False
if not ok:
raise ValueError('Test coverage failure')
def RunBinman(options, args):
"""Main entry point to binman once arguments are parsed
@ -86,7 +110,7 @@ def RunBinman(options, args):
sys.tracebacklimit = 0
if options.test:
RunTests()
ret_code = RunTests()
elif options.test_coverage:
RunTestCoverage()

36
tools/binman/entry_test.py
View file

@ -7,21 +7,55 @@
# Test for the Entry class
import collections
import os
import sys
import unittest
import entry
import fdt
import fdt_util
import tools
class TestEntry(unittest.TestCase):
def GetNode(self):
binman_dir = os.path.dirname(os.path.realpath(sys.argv[0]))
tools.PrepareOutputDir(None)
fname = fdt_util.EnsureCompiled(
os.path.join(binman_dir,('test/05_simple.dts')))
dtb = fdt.FdtScan(fname)
return dtb.GetNode('/binman/u-boot')
def test1EntryNoImportLib(self):
"""Test that we can import Entry subclassess successfully"""
sys.modules['importlib'] = None
global entry
import entry
entry.Entry.Create(None, self.GetNode(), 'u-boot')
def test2EntryImportLib(self):
del sys.modules['importlib']
global entry
reload(entry)
entry.Entry.Create(None, self.GetNode(), 'u-boot-spl')
tools._RemoveOutputDir()
del entry
def testEntryContents(self):
"""Test the Entry bass class"""
import entry
base_entry = entry.Entry(None, None, None, read_node=False)
self.assertEqual(True, base_entry.ObtainContents())
def testUnknownEntry(self):
"""Test that unknown entry types are detected"""
import entry
Node = collections.namedtuple('Node', ['name', 'path'])
node = Node('invalid-name', 'invalid-path')
with self.assertRaises(ValueError) as e:
entry.Entry.Create(None, node, node.name)
self.assertIn("Unknown entry type 'invalid-name' in node "
"'invalid-path'", str(e.exception))
if __name__ == "__main__":
unittest.main()

2
tools/binman/etype/u_boot_spl_with_ucode_ptr.py
View file

@ -25,4 +25,4 @@ class Entry_u_boot_spl_with_ucode_ptr(Entry_u_boot_with_ucode_ptr):
self.elf_fname = 'spl/u-boot-spl'
def GetDefaultFilename(self):
return 'spl/u-boot-spl.bin'
return 'spl/u-boot-spl-nodtb.bin'

11
tools/binman/etype/u_boot_ucode.py
View file

@ -58,13 +58,10 @@ class Entry_u_boot_ucode(Entry_blob):
def ObtainContents(self):
# If the image does not need microcode, there is nothing to do
ucode_dest_entry = self.image.FindEntryType('u-boot-with-ucode-ptr')
if ucode_dest_entry and not ucode_dest_entry.target_pos:
self.data = ''
return True
# Handle microcode in SPL image as well
ucode_dest_entry = self.image.FindEntryType('u-boot-spl-with-ucode-ptr')
if ucode_dest_entry and not ucode_dest_entry.target_pos:
ucode_dest_entry_spl = self.image.FindEntryType(
'u-boot-spl-with-ucode-ptr')
if ((not ucode_dest_entry or not ucode_dest_entry.target_pos) and
(not ucode_dest_entry_spl or not ucode_dest_entry_spl.target_pos)):
self.data = ''
return True

108
tools/binman/func_test.py → tools/binman/ftest.py
View file

@ -20,25 +20,27 @@ import binman
import cmdline
import command
import control
import entry
import fdt
import fdt_util
import tools
import tout
# Contents of test files, corresponding to different entry types
U_BOOT_DATA = '1234'
U_BOOT_IMG_DATA = 'img'
U_BOOT_SPL_DATA = '567'
BLOB_DATA = '89'
ME_DATA = '0abcd'
VGA_DATA = 'vga'
U_BOOT_DTB_DATA = 'udtb'
X86_START16_DATA = 'start16'
U_BOOT_NODTB_DATA = 'nodtb with microcode pointer somewhere in here'
FSP_DATA = 'fsp'
CMC_DATA = 'cmc'
VBT_DATA = 'vbt'
U_BOOT_DATA = '1234'
U_BOOT_IMG_DATA = 'img'
U_BOOT_SPL_DATA = '567'
BLOB_DATA = '89'
ME_DATA = '0abcd'
VGA_DATA = 'vga'
U_BOOT_DTB_DATA = 'udtb'
X86_START16_DATA = 'start16'
X86_START16_SPL_DATA = 'start16spl'
U_BOOT_NODTB_DATA = 'nodtb with microcode pointer somewhere in here'
U_BOOT_SPL_NODTB_DATA = 'splnodtb with microcode pointer somewhere in here'
FSP_DATA = 'fsp'
CMC_DATA = 'cmc'
VBT_DATA = 'vbt'
MRC_DATA = 'mrc'
class TestFunctional(unittest.TestCase):
"""Functional tests for binman
@ -56,6 +58,9 @@ class TestFunctional(unittest.TestCase):
"""
@classmethod
def setUpClass(self):
global entry
import entry
# Handle the case where argv[0] is 'python'
self._binman_dir = os.path.dirname(os.path.realpath(sys.argv[0]))
self._binman_pathname = os.path.join(self._binman_dir, 'binman')
@ -72,10 +77,15 @@ class TestFunctional(unittest.TestCase):
TestFunctional._MakeInputFile('vga.bin', VGA_DATA)
TestFunctional._MakeInputFile('u-boot.dtb', U_BOOT_DTB_DATA)
TestFunctional._MakeInputFile('u-boot-x86-16bit.bin', X86_START16_DATA)
TestFunctional._MakeInputFile('spl/u-boot-x86-16bit-spl.bin',
X86_START16_SPL_DATA)
TestFunctional._MakeInputFile('u-boot-nodtb.bin', U_BOOT_NODTB_DATA)
TestFunctional._MakeInputFile('spl/u-boot-spl-nodtb.bin',
U_BOOT_SPL_NODTB_DATA)
TestFunctional._MakeInputFile('fsp.bin', FSP_DATA)
TestFunctional._MakeInputFile('cmc.bin', CMC_DATA)
TestFunctional._MakeInputFile('vbt.bin', VBT_DATA)
TestFunctional._MakeInputFile('mrc.bin', MRC_DATA)
self._output_setup = False
# ELF file with a '_dt_ucode_base_size' symbol
@ -644,19 +654,11 @@ class TestFunctional(unittest.TestCase):
data = self._DoReadFile('33_x86-start16.dts')
self.assertEqual(X86_START16_DATA, data[:len(X86_START16_DATA)])
def testPackUbootMicrocode(self):
"""Test that x86 microcode can be handled correctly
We expect to see the following in the image, in order:
u-boot-nodtb.bin with a microcode pointer inserted at the correct
place
u-boot.dtb with the microcode removed
the microcode
"""
data = self._DoReadFile('34_x86_ucode.dts', True)
def _RunMicrocodeTest(self, dts_fname, nodtb_data):
data = self._DoReadFile(dts_fname, True)
# Now check the device tree has no microcode
second = data[len(U_BOOT_NODTB_DATA):]
second = data[len(nodtb_data):]
fname = tools.GetOutputFilename('test.dtb')
with open(fname, 'wb') as fd:
fd.write(second)
@ -671,17 +673,30 @@ class TestFunctional(unittest.TestCase):
# Check that the microcode appears immediately after the Fdt
# This matches the concatenation of the data properties in
# the /microcode/update@xxx nodes in x86_ucode.dts.
# 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(U_BOOT_NODTB_DATA) + fdt_len
ucode_pos = len(nodtb_data) + fdt_len
# 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)]
first = data[:len(nodtb_data)]
return first, pos_and_size
def testPackUbootMicrocode(self):
"""Test that x86 microcode can be handled correctly
We expect to see the following in the image, in order:
u-boot-nodtb.bin with a microcode pointer inserted at the correct
place
u-boot.dtb with the microcode removed
the microcode
"""
first, pos_and_size = self._RunMicrocodeTest('34_x86_ucode.dts',
U_BOOT_NODTB_DATA)
self.assertEqual('nodtb with microcode' + pos_and_size +
' somewhere in here', first)
@ -811,3 +826,42 @@ class TestFunctional(unittest.TestCase):
"""Test that an image with a VBT binary can be created"""
data = self._DoReadFile('46_intel-vbt.dts')
self.assertEqual(VBT_DATA, data[:len(VBT_DATA)])
def testSplBssPad(self):
"""Test that we can pad SPL's BSS with zeros"""
# ELF file with a '__bss_size' symbol
with open(self.TestFile('bss_data')) as fd:
TestFunctional._MakeInputFile('spl/u-boot-spl', fd.read())
data = self._DoReadFile('47_spl_bss_pad.dts')
self.assertEqual(U_BOOT_SPL_DATA + (chr(0) * 10) + U_BOOT_DATA, data)
def testPackStart16Spl(self):
"""Test that an image with an x86 start16 region can be created"""
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
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
"""
# 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)
self.assertEqual('splnodtb with microc' + pos_and_size +
'ter somewhere in here', first)
def testPackMrc(self):
"""Test that an image with an MRC binary can be created"""
data = self._DoReadFile('50_intel_mrc.dts')
self.assertEqual(MRC_DATA, data[:len(MRC_DATA)])
if __name__ == "__main__":
unittest.main()

7
tools/binman/image.py
View file

@ -9,8 +9,6 @@
from collections import OrderedDict
from operator import attrgetter
import entry
from entry import Entry
import fdt_util
import tools
@ -48,6 +46,11 @@ class Image:
_entries: OrderedDict() of entries
"""
def __init__(self, name, node):
global entry
global Entry
import entry
from entry import Entry
self._node = node
self._name = name
self._size = None

17
tools/binman/test/47_spl_bss_pad.dts Normal file
View file

@ -0,0 +1,17 @@
/dts-v1/;
/ {
#address-cells = <1>;
#size-cells = <1>;
binman {
u-boot-spl {
};
u-boot-spl-bss-pad {
};
u-boot {
};
};
};

13
tools/binman/test/48_x86-start16-spl.dts Normal file
View file

@ -0,0 +1,13 @@
/dts-v1/;
/ {
#address-cells = <1>;
#size-cells = <1>;
binman {
size = <16>;
x86-start16-spl {
};
};
};

29
tools/binman/test/49_x86_ucode_spl.dts Normal file
View file

@ -0,0 +1,29 @@
/dts-v1/;
/ {
#address-cells = <1>;
#size-cells = <1>;
binman {
sort-by-pos;
end-at-4gb;
size = <0x200>;
u-boot-spl-with-ucode-ptr {
};
u-boot-dtb-with-ucode {
};
u-boot-ucode {
};
};
microcode {
update@0 {
data = <0x12345678 0x12345679>;
};
update@1 {
data = <0xabcd0000 0x78235609>;
};
};
};

13
tools/binman/test/50_intel_mrc.dts Normal file
View file

@ -0,0 +1,13 @@
/dts-v1/;
/ {
#address-cells = <1>;
#size-cells = <1>;
binman {
size = <16>;
intel-mrc {
};
};
};

39
tools/binman/test/Makefile Normal file
View file

@ -0,0 +1,39 @@
#
# Builds test programs
#
# Copyright (C) 2017 Google, Inc
# Written by Simon Glass <sjg@chromium.org>
#
# SPDX-License-Identifier: GPL-2.0+
#
CFLAGS := -march=i386 -m32 -nostdlib -I ../../../include
LDS_UCODE := -T u_boot_ucode_ptr.lds
TARGETS = u_boot_ucode_ptr u_boot_no_ucode_ptr bss_data
all: $(TARGETS)
u_boot_no_ucode_ptr: CFLAGS += $(LDS_UCODE)
u_boot_no_ucode_ptr: u_boot_no_ucode_ptr.c
u_boot_ucode_ptr: CFLAGS += $(LDS_UCODE)
u_boot_ucode_ptr: u_boot_ucode_ptr.c
bss_data: CFLAGS += bss_data.lds
bss_data: bss_data.c
clean:
rm -f $(TARGETS)
help:
@echo "Makefile for binman test programs"
@echo
@echo "Intended for use on x86 hosts"
@echo
@echo "Targets:"
@echo
@echo -e "\thelp - Print help (this is it!)"
@echo -e "\tall - Builds test programs (default targget)"
@echo -e "\tclean - Delete output files"

BIN
tools/binman/test/bss_data Executable file
View file

Binary file not shown.

18
tools/binman/test/bss_data.c Normal file
View file

@ -0,0 +1,18 @@
/*
* Copyright (c) 2016 Google, Inc
*
* SPDX-License-Identifier: GPL-2.0+
*
* Simple program to create a _dt_ucode_base_size symbol which can be read
* by 'nm'. This is used by binman tests.
*/
int bss_data[10];
int __bss_size = sizeof(bss_data);
int main()
{
bss_data[2] = 2;
return 0;
}

16
tools/binman/test/bss_data.lds Normal file
View file

@ -0,0 +1,16 @@
/*
* Copyright (c) 2016 Google, Inc
*
* SPDX-License-Identifier: GPL-2.0+
*/
OUTPUT_FORMAT("elf32-i386", "elf32-i386", "elf32-i386")
OUTPUT_ARCH(i386)
ENTRY(_start)
SECTIONS
{
. = 0xfffffdf0;
_start = .;
__bss_size = 10;
}

4
tools/binman/test/u_boot_no_ucode_ptr.c
View file

@ -5,10 +5,6 @@
*
* Simple program to create a bad _dt_ucode_base_size symbol to create an
* error when it is used. This is used by binman tests.
*
* Build with:
* cc -march=i386 -m32 -o u_boot_no_ucode_ptr -T u_boot_ucode_ptr.lds \
-nostdlib u_boot_no_ucode_ptr.c
*/
static unsigned long not__dt_ucode_base_size[2]

4
tools/binman/test/u_boot_ucode_ptr.c
View file

@ -5,10 +5,6 @@
*
* Simple program to create a _dt_ucode_base_size symbol which can be read
* by 'nm'. This is used by binman tests.
*
* Build with:
* cc -march=i386 -m32 -o u_boot_ucode_ptr -T u_boot_ucode_ptr.lds -nostdlib \
u_boot_ucode_ptr.c
*/
static unsigned long _dt_ucode_base_size[2]

6
tools/buildman/buildman.py
View file

@ -30,7 +30,7 @@ import patchstream
import terminal
import toolchain
def RunTests():
def RunTests(skip_net_tests):
import func_test
import test
import doctest
@ -41,6 +41,8 @@ def RunTests():
suite.run(result)
sys.argv = [sys.argv[0]]
if skip_net_tests:
test.use_network = False
for module in (test.TestBuild, func_test.TestFunctional):
suite = unittest.TestLoader().loadTestsFromTestCase(module)
suite.run(result)
@ -56,7 +58,7 @@ options, args = cmdline.ParseArgs()
# Run our meagre tests
if options.test:
RunTests()
RunTests(options.skip_net_tests)
# Build selected commits for selected boards
else:

2
tools/buildman/cmdline.py
View file

@ -82,6 +82,8 @@ def ParseArgs():
default=False, help='Show a build summary')
parser.add_option('-S', '--show-sizes', action='store_true',
default=False, help='Show image size variation in summary')
parser.add_option('--skip-net-tests', action='store_true', default=False,
help='Skip tests which need the network')
parser.add_option('--step', type='int',
default=1, help='Only build every n commits (0=just first and last)')
parser.add_option('-t', '--test', action='store_true', dest='test',

38
tools/buildman/test.py
View file

@ -24,6 +24,8 @@ import commit
import terminal
import toolchain
use_network = True
settings_data = '''
# Buildman settings file
@ -89,6 +91,7 @@ boards = [
['Active', 'arm', 'armv7', '', 'Tester', 'ARM Board 1', 'board0', ''],
['Active', 'arm', 'armv7', '', 'Tester', 'ARM Board 2', 'board1', ''],
['Active', 'powerpc', 'powerpc', '', 'Tester', 'PowerPC board 1', 'board2', ''],
['Active', 'powerpc', 'mpc83xx', '', 'Tester', 'PowerPC board 2', 'board3', ''],
['Active', 'sandbox', 'sandbox', '', 'Tester', 'Sandbox board', 'board4', ''],
]
@ -311,50 +314,60 @@ class TestBuild(unittest.TestCase):
def testBoardSingle(self):
"""Test single board selection"""
self.assertEqual(self.boards.SelectBoards(['sandbox']),
{'all': 1, 'sandbox': 1})
{'all': ['board4'], 'sandbox': ['board4']})
def testBoardArch(self):
"""Test single board selection"""
self.assertEqual(self.boards.SelectBoards(['arm']),
{'all': 2, 'arm': 2})
{'all': ['board0', 'board1'],
'arm': ['board0', 'board1']})
def testBoardArchSingle(self):
"""Test single board selection"""
self.assertEqual(self.boards.SelectBoards(['arm sandbox']),
{'all': 3, 'arm': 2, 'sandbox' : 1})
{'sandbox': ['board4'],
'all': ['board0', 'board1', 'board4'],
'arm': ['board0', 'board1']})
def testBoardArchSingleMultiWord(self):
"""Test single board selection"""
self.assertEqual(self.boards.SelectBoards(['arm', 'sandbox']),
{'all': 3, 'arm': 2, 'sandbox' : 1})
{'sandbox': ['board4'], 'all': ['board0', 'board1', 'board4'], 'arm': ['board0', 'board1']})
def testBoardSingleAnd(self):
"""Test single board selection"""
self.assertEqual(self.boards.SelectBoards(['Tester & arm']),
{'all': 2, 'Tester&arm': 2})
{'Tester&arm': ['board0', 'board1'], 'all': ['board0', 'board1']})
def testBoardTwoAnd(self):
"""Test single board selection"""
self.assertEqual(self.boards.SelectBoards(['Tester', '&', 'arm',
'Tester' '&', 'powerpc',
'sandbox']),
{'all': 5, 'Tester&powerpc': 2, 'Tester&arm': 2,
'sandbox' : 1})
{'sandbox': ['board4'],
'all': ['board0', 'board1', 'board2', 'board3',
'board4'],
'Tester&powerpc': ['board2', 'board3'],
'Tester&arm': ['board0', 'board1']})
def testBoardAll(self):
"""Test single board selection"""
self.assertEqual(self.boards.SelectBoards([]), {'all': 5})
self.assertEqual(self.boards.SelectBoards([]),
{'all': ['board0', 'board1', 'board2', 'board3',
'board4']})
def testBoardRegularExpression(self):
"""Test single board selection"""
self.assertEqual(self.boards.SelectBoards(['T.*r&^Po']),
{'T.*r&^Po': 2, 'all': 2})
{'all': ['board2', 'board3'],
'T.*r&^Po': ['board2', 'board3']})
def testBoardDuplicate(self):
"""Test single board selection"""
self.assertEqual(self.boards.SelectBoards(['sandbox sandbox',
'sandbox']),
{'all': 1, 'sandbox': 1})
{'all': ['board4'], 'sandbox': ['board4']})
def CheckDirs(self, build, dirname):
self.assertEqual('base%s' % dirname, build._GetOutputDir(1))
self.assertEqual('base%s/fred' % dirname,
@ -410,8 +423,9 @@ class TestBuild(unittest.TestCase):
def testToolchainDownload(self):
"""Test that we can download toolchains"""
self.assertEqual('https://www.kernel.org/pub/tools/crosstool/files/bin/x86_64/4.9.0/x86_64-gcc-4.9.0-nolibc_arm-unknown-linux-gnueabi.tar.xz',
self.toolchains.LocateArchUrl('arm'))
if use_network:
self.assertEqual('https://www.kernel.org/pub/tools/crosstool/files/bin/x86_64/4.9.0/x86_64-gcc-4.9.0-nolibc_arm-unknown-linux-gnueabi.tar.xz',
self.toolchains.LocateArchUrl('arm'))
if __name__ == "__main__":

3
tools/dtoc/fdt_util.py
View file

@ -75,7 +75,8 @@ def EnsureCompiled(fname):
search_list = []
for path in search_paths:
search_list.extend(['-i', path])
args = ['-I', 'dts', '-o', dtb_output, '-O', 'dtb']
args = ['-I', 'dts', '-o', dtb_output, '-O', 'dtb',
'-W', 'no-unit_address_vs_reg']
args.extend(search_list)
args.append(dts_input)
command.Run('dtc', *args)

82
tools/dtoc/test_dtoc.py
View file

@ -26,6 +26,27 @@ import tools
our_path = os.path.dirname(os.path.realpath(__file__))
HEADER = '''/*
* DO NOT MODIFY
*
* This file was generated by dtoc from a .dtb (device tree binary) file.
*/
#include <stdbool.h>
#include <libfdt.h>'''
C_HEADER = '''/*
* DO NOT MODIFY
*
* This file was generated by dtoc from a .dtb (device tree binary) file.
*/
#include <common.h>
#include <dm.h>
#include <dt-structs.h>
'''
def get_dtb_file(dts_fname):
"""Compile a .dts file to a .dtb
@ -104,13 +125,12 @@ class TestDtoc(unittest.TestCase):
dtb_platdata.run_steps(['struct'], dtb_file, False, output)
with open(output) as infile:
lines = infile.read().splitlines()
self.assertEqual(['#include <stdbool.h>', '#include <libfdt.h>'], lines)
self.assertEqual(HEADER.splitlines(), lines)
dtb_platdata.run_steps(['platdata'], dtb_file, False, output)
with open(output) as infile:
lines = infile.read().splitlines()
self.assertEqual(['#include <common.h>', '#include <dm.h>',
'#include <dt-structs.h>', ''], lines)
self.assertEqual(C_HEADER.splitlines() + [''], lines)
def test_simple(self):
"""Test output from some simple nodes with various types of data"""
@ -119,8 +139,7 @@ class TestDtoc(unittest.TestCase):
dtb_platdata.run_steps(['struct'], dtb_file, False, output)
with open(output) as infile:
data = infile.read()
self.assertEqual('''#include <stdbool.h>
#include <libfdt.h>
self.assertEqual(HEADER + '''
struct dtd_sandbox_i2c_test {
};
struct dtd_sandbox_pmic_test {
@ -144,10 +163,7 @@ struct dtd_sandbox_spl_test_2 {
dtb_platdata.run_steps(['platdata'], dtb_file, False, output)
with open(output) as infile:
data = infile.read()
self.assertEqual('''#include <common.h>
#include <dm.h>
#include <dt-structs.h>
self.assertEqual(C_HEADER + '''
static struct dtd_sandbox_spl_test dtv_spl_test = {
\t.bytearray\t\t= {0x6, 0x0, 0x0},
\t.byteval\t\t= 0x5,
@ -225,8 +241,7 @@ U_BOOT_DEVICE(pmic_at_9) = {
dtb_platdata.run_steps(['struct'], dtb_file, False, output)
with open(output) as infile:
data = infile.read()
self.assertEqual('''#include <stdbool.h>
#include <libfdt.h>
self.assertEqual(HEADER + '''
struct dtd_source {
\tstruct phandle_2_arg clocks[4];
};
@ -238,10 +253,7 @@ struct dtd_target {
dtb_platdata.run_steps(['platdata'], dtb_file, False, output)
with open(output) as infile:
data = infile.read()
self.assertEqual('''#include <common.h>
#include <dm.h>
#include <dt-structs.h>
self.assertEqual(C_HEADER + '''
static struct dtd_target dtv_phandle_target = {
\t.intval\t\t\t= 0x0,
};
@ -291,8 +303,7 @@ U_BOOT_DEVICE(phandle_source) = {
dtb_platdata.run_steps(['struct'], dtb_file, False, output)
with open(output) as infile:
data = infile.read()
self.assertEqual('''#include <stdbool.h>
#include <libfdt.h>
self.assertEqual(HEADER + '''
struct dtd_compat1 {
\tfdt32_t\t\tintval;
};
@ -303,10 +314,7 @@ struct dtd_compat1 {
dtb_platdata.run_steps(['platdata'], dtb_file, False, output)
with open(output) as infile:
data = infile.read()
self.assertEqual('''#include <common.h>
#include <dm.h>
#include <dt-structs.h>
self.assertEqual(C_HEADER + '''
static struct dtd_compat1 dtv_spl_test = {
\t.intval\t\t\t= 0x1,
};
@ -325,8 +333,7 @@ U_BOOT_DEVICE(spl_test) = {
dtb_platdata.run_steps(['struct'], dtb_file, False, output)
with open(output) as infile:
data = infile.read()
self.assertEqual('''#include <stdbool.h>
#include <libfdt.h>
self.assertEqual(HEADER + '''
struct dtd_test1 {
\tfdt64_t\t\treg[2];
};
@ -341,10 +348,7 @@ struct dtd_test3 {
dtb_platdata.run_steps(['platdata'], dtb_file, False, output)
with open(output) as infile:
data = infile.read()
self.assertEqual('''#include <common.h>
#include <dm.h>
#include <dt-structs.h>
self.assertEqual(C_HEADER + '''
static struct dtd_test1 dtv_test1 = {
\t.reg\t\t\t= {0x1234, 0x5678},
};
@ -381,8 +385,7 @@ U_BOOT_DEVICE(test3) = {
dtb_platdata.run_steps(['struct'], dtb_file, False, output)
with open(output) as infile:
data = infile.read()
self.assertEqual('''#include <stdbool.h>
#include <libfdt.h>
self.assertEqual(HEADER + '''
struct dtd_test1 {
\tfdt32_t\t\treg[2];
};
@ -394,10 +397,7 @@ struct dtd_test2 {
dtb_platdata.run_steps(['platdata'], dtb_file, False, output)
with open(output) as infile:
data = infile.read()
self.assertEqual('''#include <common.h>
#include <dm.h>
#include <dt-structs.h>
self.assertEqual(C_HEADER + '''
static struct dtd_test1 dtv_test1 = {
\t.reg\t\t\t= {0x1234, 0x5678},
};
@ -425,8 +425,7 @@ U_BOOT_DEVICE(test2) = {
dtb_platdata.run_steps(['struct'], dtb_file, False, output)
with open(output) as infile:
data = infile.read()
self.assertEqual('''#include <stdbool.h>
#include <libfdt.h>
self.assertEqual(HEADER + '''
struct dtd_test1 {
\tfdt64_t\t\treg[2];
};
@ -441,10 +440,7 @@ struct dtd_test3 {
dtb_platdata.run_steps(['platdata'], dtb_file, False, output)
with open(output) as infile:
data = infile.read()
self.assertEqual('''#include <common.h>
#include <dm.h>
#include <dt-structs.h>
self.assertEqual(C_HEADER + '''
static struct dtd_test1 dtv_test1 = {
\t.reg\t\t\t= {0x123400000000, 0x5678},
};
@ -481,8 +477,7 @@ U_BOOT_DEVICE(test3) = {
dtb_platdata.run_steps(['struct'], dtb_file, False, output)
with open(output) as infile:
data = infile.read()
self.assertEqual('''#include <stdbool.h>
#include <libfdt.h>
self.assertEqual(HEADER + '''
struct dtd_test1 {
\tfdt64_t\t\treg[2];
};
@ -497,10 +492,7 @@ struct dtd_test3 {
dtb_platdata.run_steps(['platdata'], dtb_file, False, output)
with open(output) as infile:
data = infile.read()
self.assertEqual('''#include <common.h>
#include <dm.h>
#include <dt-structs.h>
self.assertEqual(C_HEADER + '''
static struct dtd_test1 dtv_test1 = {
\t.reg\t\t\t= {0x1234, 0x567800000000},
};

41
tools/patman/test.py
View file

@ -88,8 +88,7 @@ Signed-off-by: Simon Glass <sjg@chromium.org>
os.remove(expname)
def GetData(self, data_type):
data='''
From 4924887af52713cabea78420eff03badea8f0035 Mon Sep 17 00:00:00 2001
data='''From 4924887af52713cabea78420eff03badea8f0035 Mon Sep 17 00:00:00 2001
From: Simon Glass <sjg@chromium.org>
Date: Thu, 7 Apr 2011 10:14:41 -0700
Subject: [PATCH 1/4] Add microsecond boot time measurement
@ -101,6 +100,7 @@ an available microsecond counter.
%s
---
README | 11 ++++++++
MAINTAINERS | 3 ++
common/bootstage.c | 50 ++++++++++++++++++++++++++++++++++++
include/bootstage.h | 71 +++++++++++++++++++++++++++++++++++++++++++++++++++
include/common.h | 8 ++++++
@ -130,19 +130,31 @@ index 6f3748d..f9e4e65 100644
- Standalone program support:
CONFIG_STANDALONE_LOAD_ADDR
diff --git a/MAINTAINERS b/MAINTAINERS
index b167b028ec..beb7dc634f 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -474,3 +474,8 @@ S: Maintained
T: git git://git.denx.de/u-boot.git
F: *
F: */
+
+BOOTSTAGE
+M: Simon Glass <sjg@chromium.org>
+L: u-boot@lists.denx.de
+F: common/bootstage.c
diff --git a/common/bootstage.c b/common/bootstage.c
new file mode 100644
index 0000000..2234c87
--- /dev/null
+++ b/common/bootstage.c
@@ -0,0 +1,39 @@
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2011, Google Inc. All rights reserved.
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+
+/*
+ * This module records the progress of boot and arbitrary commands, and
+ * permits accurate timestamping of each. The records can optionally be
@ -151,26 +163,25 @@ index 0000000..2234c87
+
+#include <common.h>
+
+
+struct bootstage_record {
+ uint32_t time_us;
+ u32 time_us;
+ const char *name;
+};
+
+static struct bootstage_record record[BOOTSTAGE_COUNT];
+
+uint32_t bootstage_mark(enum bootstage_id id, const char *name)
+u32 bootstage_mark(enum bootstage_id id, const char *name)
+{
+ struct bootstage_record *rec = &record[id];
+
+ /* Only record the first event for each */
+%sif (!rec->name) {
+ rec->time_us = (uint32_t)timer_get_us();
+ rec->time_us = (u32)timer_get_us();
+ rec->name = name;
+ }
+ if (!rec->name &&
+ %ssomething_else) {
+ rec->time_us = (uint32_t)timer_get_us();
+ rec->time_us = (u32)timer_get_us();
+ rec->name = name;
+ }
+%sreturn rec->time_us;
@ -210,7 +221,7 @@ index 0000000..2234c87
self.assertEqual(result.errors, 0)
self.assertEqual(result.warnings, 0)
self.assertEqual(result.checks, 0)
self.assertEqual(result.lines, 56)
self.assertEqual(result.lines, 62)
os.remove(inf)
def testNoSignoff(self):
@ -221,18 +232,18 @@ index 0000000..2234c87
self.assertEqual(result.errors, 1)
self.assertEqual(result.warnings, 0)
self.assertEqual(result.checks, 0)
self.assertEqual(result.lines, 56)
self.assertEqual(result.lines, 62)
os.remove(inf)
def testSpaces(self):
inf = self.SetupData('spaces')
result = checkpatch.CheckPatch(inf)
self.assertEqual(result.ok, False)
self.assertEqual(len(result.problems), 2)
self.assertEqual(len(result.problems), 3)
self.assertEqual(result.errors, 0)
self.assertEqual(result.warnings, 2)
self.assertEqual(result.warnings, 3)
self.assertEqual(result.checks, 0)
self.assertEqual(result.lines, 56)
self.assertEqual(result.lines, 62)
os.remove(inf)
def testIndent(self):
@ -243,7 +254,7 @@ index 0000000..2234c87
self.assertEqual(result.errors, 0)
self.assertEqual(result.warnings, 0)
self.assertEqual(result.checks, 1)
self.assertEqual(result.lines, 56)
self.assertEqual(result.lines, 62)
os.remove(inf)