...
 
Commits (26)
......@@ -59,6 +59,12 @@ S: Maintained
T: git git://git.denx.de/u-boot-arc.git
F: arch/arc/
ARC HSDK CREG GPIO
M: Eugeniy Paltsev <Eugeniy.Paltsev@synopsys.com>
S: Maintained
L: uboot-snps-arc@synopsys.com
F: drivers/gpio/hsdk-creg-gpio.c
ARM
M: Albert Aribaud <albert.u.boot@aribaud.net>
S: Maintained
......
......@@ -88,11 +88,11 @@ static void boot_jump_linux(bootm_headers_t *images, int flag)
r2 = (unsigned int)env_get("bootargs");
}
smp_set_core_boot_addr((unsigned long)kernel_entry, -1);
smp_kick_all_cpus();
if (!fake)
if (!fake) {
smp_set_core_boot_addr((unsigned long)kernel_entry, -1);
smp_kick_all_cpus();
kernel_entry(r0, 0, r2);
}
}
int do_bootm_linux(int flag, int argc, char *argv[], bootm_headers_t *images)
......
......@@ -278,6 +278,13 @@ void invalidate_icache_all(void)
/* Any write to IC_IVIC register triggers invalidation of entire I$ */
if (icache_status()) {
write_aux_reg(ARC_AUX_IC_IVIC, 1);
/*
* As per ARC HS databook (see chapter 5.3.3.2)
* it is required to add 3 NOPs after each write to IC_IVIC.
*/
__builtin_arc_nop();
__builtin_arc_nop();
__builtin_arc_nop();
read_aux_reg(ARC_AUX_IC_CTRL); /* blocks */
}
}
......
......@@ -80,6 +80,13 @@ config IMX_RGPIO2P
help
This driver supports i.MX7ULP Rapid GPIO2P controller.
config HSDK_CREG_GPIO
bool "HSDK CREG GPIO griver"
depends on DM
default n
help
This driver supports CREG GPIOs on Synopsys HSDK SOC.
config LPC32XX_GPIO
bool "LPC32XX GPIO driver"
depends on DM
......
......@@ -54,6 +54,7 @@ obj-$(CONFIG_GPIO_UNIPHIER) += gpio-uniphier.o
obj-$(CONFIG_ZYNQ_GPIO) += zynq_gpio.o
obj-$(CONFIG_VYBRID_GPIO) += vybrid_gpio.o
obj-$(CONFIG_HIKEY_GPIO) += hi6220_gpio.o
obj-$(CONFIG_HSDK_CREG_GPIO) += hsdk-creg-gpio.o
obj-$(CONFIG_IMX_RGPIO2P) += imx_rgpio2p.o
obj-$(CONFIG_PIC32_GPIO) += pic32_gpio.o
obj-$(CONFIG_MVEBU_GPIO) += mvebu_gpio.o
......
/*
* Synopsys HSDK SDP Generic PLL clock driver
*
* Copyright (C) 2017 Synopsys
* Author: Eugeniy Paltsev <Eugeniy.Paltsev@synopsys.com>
*
* This file is licensed under the terms of the GNU General Public
* License version 2. This program is licensed "as is" without any
* warranty of any kind, whether express or implied.
*/
#include <asm-generic/gpio.h>
#include <asm/io.h>
#include <common.h>
#include <dm.h>
#include <errno.h>
#include <linux/printk.h>
DECLARE_GLOBAL_DATA_PTR;
#define HSDK_CREG_MAX_GPIO 8
#define GPIO_ACTIVATE 0x2
#define GPIO_DEACTIVATE 0x3
#define GPIO_PIN_MASK 0x3
#define BIT_PER_GPIO 2
struct hsdk_creg_gpio {
uint32_t *regs;
};
static int hsdk_creg_gpio_set_value(struct udevice *dev, unsigned oft, int val)
{
struct hsdk_creg_gpio *hcg = dev_get_priv(dev);
uint32_t reg = readl(hcg->regs);
uint32_t cmd = val ? GPIO_DEACTIVATE : GPIO_ACTIVATE;
reg &= ~(GPIO_PIN_MASK << (oft * BIT_PER_GPIO));
reg |= (cmd << (oft * BIT_PER_GPIO));
writel(reg, hcg->regs);
return 0;
}
static int hsdk_creg_gpio_direction_output(struct udevice *dev, unsigned oft,
int val)
{
hsdk_creg_gpio_set_value(dev, oft, val);
return 0;
}
static int hsdk_creg_gpio_direction_input(struct udevice *dev, unsigned oft)
{
pr_err("hsdk-creg-gpio can't be used as input!\n");
return -ENOTSUPP;
}
static int hsdk_creg_gpio_get_value(struct udevice *dev, unsigned int oft)
{
struct hsdk_creg_gpio *hcg = dev_get_priv(dev);
uint32_t val = readl(hcg->regs);
val = (val >> (oft * BIT_PER_GPIO)) & GPIO_PIN_MASK;
return (val == GPIO_DEACTIVATE) ? 1 : 0;
}
static const struct dm_gpio_ops hsdk_creg_gpio_ops = {
.direction_output = hsdk_creg_gpio_direction_output,
.direction_input = hsdk_creg_gpio_direction_input,
.set_value = hsdk_creg_gpio_set_value,
.get_value = hsdk_creg_gpio_get_value,
};
static int hsdk_creg_gpio_probe(struct udevice *dev)
{
struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
struct hsdk_creg_gpio *hcg = dev_get_priv(dev);
hcg->regs = (uint32_t *)devfdt_get_addr_ptr(dev);
uc_priv->gpio_count = dev_read_u32_default(dev, "gpio-count", 1);
if (uc_priv->gpio_count > HSDK_CREG_MAX_GPIO)
uc_priv->gpio_count = HSDK_CREG_MAX_GPIO;
uc_priv->bank_name = dev_read_string(dev, "gpio-bank-name");
if (!uc_priv->bank_name)
uc_priv->bank_name = dev_read_name(dev);
pr_debug("%s GPIO [0x%p] controller with %d gpios probed\n",
uc_priv->bank_name, hcg->regs, uc_priv->gpio_count);
return 0;
}
static const struct udevice_id hsdk_creg_gpio_ids[] = {
{ .compatible = "snps,hsdk-creg-gpio" },
{ }
};
U_BOOT_DRIVER(gpio_hsdk_creg) = {
.name = "gpio_hsdk_creg",
.id = UCLASS_GPIO,
.ops = &hsdk_creg_gpio_ops,
.probe = hsdk_creg_gpio_probe,
.of_match = hsdk_creg_gpio_ids,
.platdata_auto_alloc_size = sizeof(struct hsdk_creg_gpio),
};
......@@ -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 \
......
#!/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
......@@ -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
......
......@@ -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()
......
......@@ -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()
......@@ -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'
......@@ -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
......
......@@ -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()
......@@ -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
......
/dts-v1/;
/ {
#address-cells = <1>;
#size-cells = <1>;
binman {
u-boot-spl {
};
u-boot-spl-bss-pad {
};
u-boot {
};
};
};
/dts-v1/;
/ {
#address-cells = <1>;
#size-cells = <1>;
binman {
size = <16>;
x86-start16-spl {
};
};
};
/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>;
};
};
};
/dts-v1/;
/ {
#address-cells = <1>;
#size-cells = <1>;
binman {
size = <16>;
intel-mrc {
};
};
};
#
# 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"
/*
* 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;
}
/*
* 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;
}
......@@ -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]
......
......@@ -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]
......
......@@ -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:
......
......@@ -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',
......
......@@ -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__":
......
......@@ -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)
......
......@@ -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},
};
......
......@@ -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)
......