Merge git://git.denx.de/u-boot-fsl-qoriq
diff --git a/arch/arm/dts/Makefile b/arch/arm/dts/Makefile
index b5427df..078c21b 100644
--- a/arch/arm/dts/Makefile
+++ b/arch/arm/dts/Makefile
@@ -91,6 +91,7 @@
armada-375-db.dtb \
armada-388-clearfog.dtb \
armada-388-gp.dtb \
+ armada-388-helios4.dtb \
armada-385-amc.dtb \
armada-7040-db.dtb \
armada-7040-db-nand.dtb \
diff --git a/arch/arm/dts/armada-388-helios4.dts b/arch/arm/dts/armada-388-helios4.dts
new file mode 100644
index 0000000..049d322
--- /dev/null
+++ b/arch/arm/dts/armada-388-helios4.dts
@@ -0,0 +1,314 @@
+// SPDX-License-Identifier: (GPL-2.0 OR MIT)
+/*
+ * Device Tree file for Helios4
+ * based on SolidRun Clearfog revision A1 rev 2.0 (88F6828)
+ *
+ * Copyright (C) 2017 Aditya Prayoga <aditya@kobol.io>
+ *
+ */
+
+/dts-v1/;
+#include "armada-388.dtsi"
+#include "armada-38x-solidrun-microsom.dtsi"
+
+/ {
+ model = "Helios4";
+ compatible = "kobol,helios4", "marvell,armada388",
+ "marvell,armada385", "marvell,armada380";
+
+ memory {
+ device_type = "memory";
+ reg = <0x00000000 0x80000000>; /* 2 GB */
+ };
+
+ aliases {
+ /* So that mvebu u-boot can update the MAC addresses */
+ ethernet1 = ð0;
+ };
+
+ chosen {
+ stdout-path = "serial0:115200n8";
+ };
+
+ reg_12v: regulator-12v {
+ compatible = "regulator-fixed";
+ regulator-name = "power_brick_12V";
+ regulator-min-microvolt = <12000000>;
+ regulator-max-microvolt = <12000000>;
+ regulator-always-on;
+ };
+
+ reg_3p3v: regulator-3p3v {
+ compatible = "regulator-fixed";
+ regulator-name = "3P3V";
+ regulator-min-microvolt = <3300000>;
+ regulator-max-microvolt = <3300000>;
+ regulator-always-on;
+ vin-supply = <®_12v>;
+ };
+
+ reg_5p0v_hdd: regulator-5v-hdd {
+ compatible = "regulator-fixed";
+ regulator-name = "5V_HDD";
+ regulator-min-microvolt = <5000000>;
+ regulator-max-microvolt = <5000000>;
+ regulator-always-on;
+ vin-supply = <®_12v>;
+ };
+
+ reg_5p0v_usb: regulator-5v-usb {
+ compatible = "regulator-fixed";
+ regulator-name = "USB-PWR";
+ regulator-min-microvolt = <5000000>;
+ regulator-max-microvolt = <5000000>;
+ regulator-boot-on;
+ regulator-always-on;
+ enable-active-high;
+ gpio = <&expander0 6 GPIO_ACTIVE_HIGH>;
+ vin-supply = <®_12v>;
+ };
+
+ system-leds {
+ compatible = "gpio-leds";
+ status-led {
+ label = "helios4:green:status";
+ gpios = <&gpio0 24 GPIO_ACTIVE_LOW>;
+ linux,default-trigger = "heartbeat";
+ default-state = "on";
+ };
+
+ fault-led {
+ label = "helios4:red:fault";
+ gpios = <&gpio0 25 GPIO_ACTIVE_LOW>;
+ default-state = "keep";
+ };
+ };
+
+ io-leds {
+ compatible = "gpio-leds";
+ sata1-led {
+ label = "helios4:green:ata1";
+ gpios = <&gpio1 17 GPIO_ACTIVE_LOW>;
+ linux,default-trigger = "ata1";
+ default-state = "off";
+ };
+ sata2-led {
+ label = "helios4:green:ata2";
+ gpios = <&gpio1 18 GPIO_ACTIVE_LOW>;
+ linux,default-trigger = "ata2";
+ default-state = "off";
+ };
+ sata3-led {
+ label = "helios4:green:ata3";
+ gpios = <&gpio1 20 GPIO_ACTIVE_LOW>;
+ linux,default-trigger = "ata3";
+ default-state = "off";
+ };
+ sata4-led {
+ label = "helios4:green:ata4";
+ gpios = <&gpio1 21 GPIO_ACTIVE_LOW>;
+ linux,default-trigger = "ata4";
+ default-state = "off";
+ };
+ usb-led {
+ label = "helios4:green:usb";
+ gpios = <&gpio1 22 GPIO_ACTIVE_LOW>;
+ linux,default-trigger = "usb-host";
+ default-state = "off";
+ };
+ };
+
+ fan1: j10-pwm {
+ compatible = "pwm-fan";
+ pwms = <&gpio1 9 40000>; /* Target freq:25 kHz */
+ };
+
+ fan2: j17-pwm {
+ compatible = "pwm-fan";
+ pwms = <&gpio1 23 40000>; /* Target freq:25 kHz */
+ };
+
+ usb2_phy: usb2-phy {
+ compatible = "usb-nop-xceiv";
+ vbus-regulator = <®_5p0v_usb>;
+ };
+
+ usb3_phy: usb3-phy {
+ compatible = "usb-nop-xceiv";
+ };
+
+ soc {
+ internal-regs {
+ i2c@11000 {
+ clock-frequency = <400000>;
+ pinctrl-0 = <&i2c0_pins>;
+ pinctrl-names = "default";
+ status = "okay";
+
+ /*
+ * PCA9655 GPIO expander, up to 1MHz clock.
+ * 0-Board Revision bit 0 #
+ * 1-Board Revision bit 1 #
+ * 5-USB3 overcurrent
+ * 6-USB3 power
+ */
+ expander0: gpio-expander@20 {
+ /*
+ * This is how it should be:
+ * compatible = "onnn,pca9655",
+ * "nxp,pca9555";
+ * but you can't do this because of
+ * the way I2C works.
+ */
+ compatible = "nxp,pca9555";
+ gpio-controller;
+ #gpio-cells = <2>;
+ reg = <0x20>;
+ pinctrl-names = "default";
+ pinctrl-0 = <&pca0_pins>;
+ interrupt-parent = <&gpio0>;
+ interrupts = <23 IRQ_TYPE_EDGE_FALLING>;
+ interrupt-controller;
+ #interrupt-cells = <2>;
+
+ board_rev_bit_0 {
+ gpio-hog;
+ gpios = <0 GPIO_ACTIVE_LOW>;
+ input;
+ line-name = "board-rev-0";
+ };
+ board_rev_bit_1 {
+ gpio-hog;
+ gpios = <1 GPIO_ACTIVE_LOW>;
+ input;
+ line-name = "board-rev-1";
+ };
+ usb3_ilimit {
+ gpio-hog;
+ gpios = <5 GPIO_ACTIVE_HIGH>;
+ input;
+ line-name =
+ "usb-overcurrent-status";
+ };
+ };
+
+ temp_sensor: temp@4c {
+ compatible = "ti,lm75";
+ reg = <0x4c>;
+ vcc-supply = <®_3p3v>;
+ };
+ };
+
+ i2c@11100 {
+ /*
+ * External I2C Bus for user peripheral
+ */
+ clock-frequency = <400000>;
+ pinctrl-0 = <&helios_i2c1_pins>;
+ pinctrl-names = "default";
+ status = "okay";
+ };
+
+ sata@a8000 {
+ status = "okay";
+ #address-cells = <1>;
+ #size-cells = <0>;
+
+ sata0: sata-port@0 {
+ reg = <0>;
+ };
+
+ sata1: sata-port@1 {
+ reg = <1>;
+ };
+ };
+
+ sata@e0000 {
+ status = "okay";
+ #address-cells = <1>;
+ #size-cells = <0>;
+
+ sata2: sata-port@0 {
+ reg = <0>;
+ };
+
+ sata3: sata-port@1 {
+ reg = <1>;
+ };
+ };
+
+ spi@10680 {
+ pinctrl-0 = <&spi1_pins
+ µsom_spi1_cs_pins>;
+ pinctrl-names = "default";
+ status = "okay";
+ };
+
+ sdhci@d8000 {
+ bus-width = <4>;
+ cd-gpios = <&gpio0 20 GPIO_ACTIVE_LOW>;
+ no-1-8-v;
+ pinctrl-0 = <&helios_sdhci_pins
+ &helios_sdhci_cd_pins>;
+ pinctrl-names = "default";
+ status = "okay";
+ vmmc = <®_3p3v>;
+ wp-inverted;
+ };
+
+ usb@58000 {
+ usb-phy = <&usb2_phy>;
+ status = "okay";
+ };
+
+ usb3@f0000 {
+ status = "okay";
+ };
+
+ usb3@f8000 {
+ status = "okay";
+ };
+
+ pinctrl@18000 {
+ pca0_pins: pca0-pins {
+ marvell,pins = "mpp23";
+ marvell,function = "gpio";
+ };
+ microsom_phy0_int_pins: microsom-phy0-int-pins {
+ marvell,pins = "mpp18";
+ marvell,function = "gpio";
+ };
+ helios_i2c1_pins: i2c1-pins {
+ marvell,pins = "mpp26", "mpp27";
+ marvell,function = "i2c1";
+ };
+ helios_sdhci_cd_pins: helios-sdhci-cd-pins {
+ marvell,pins = "mpp20";
+ marvell,function = "gpio";
+ };
+ helios_sdhci_pins: helios-sdhci-pins {
+ marvell,pins = "mpp21", "mpp28",
+ "mpp37", "mpp38",
+ "mpp39", "mpp40";
+ marvell,function = "sd0";
+ };
+ helios_led_pins: helios-led-pins {
+ marvell,pins = "mpp24", "mpp25",
+ "mpp49", "mpp50",
+ "mpp52", "mpp53",
+ "mpp54";
+ marvell,function = "gpio";
+ };
+ helios_fan_pins: helios-fan-pins {
+ marvell,pins = "mpp41", "mpp43",
+ "mpp48", "mpp55";
+ marvell,function = "gpio";
+ };
+ microsom_spi1_cs_pins: spi1-cs-pins {
+ marvell,pins = "mpp59";
+ marvell,function = "spi1";
+ };
+ };
+ };
+ };
+};
diff --git a/arch/arm/dts/armada-38x-solidrun-microsom.dtsi b/arch/arm/dts/armada-38x-solidrun-microsom.dtsi
new file mode 100644
index 0000000..a262722
--- /dev/null
+++ b/arch/arm/dts/armada-38x-solidrun-microsom.dtsi
@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: (GPL-2.0 OR MIT)
+/*
+ * Device Tree file for SolidRun Armada 38x Microsom
+ *
+ * Copyright (C) 2015 Russell King
+ *
+ * This board is in development; the contents of this file work with
+ * the A1 rev 2.0 of the board, which does not represent final
+ * production board. Things will change, don't expect this file to
+ * remain compatible info the future.
+ */
+#include <dt-bindings/input/input.h>
+#include <dt-bindings/gpio/gpio.h>
+
+/ {
+ memory {
+ device_type = "memory";
+ reg = <0x00000000 0x10000000>; /* 256 MB */
+ };
+
+ soc {
+ ranges = <MBUS_ID(0xf0, 0x01) 0 0xf1000000 0x100000
+ MBUS_ID(0x01, 0x1d) 0 0xfff00000 0x100000
+ MBUS_ID(0x09, 0x19) 0 0xf1100000 0x10000
+ MBUS_ID(0x09, 0x15) 0 0xf1110000 0x10000
+ MBUS_ID(0x0c, 0x04) 0 0xf1200000 0x100000>;
+
+ internal-regs {
+ rtc@a3800 {
+ /*
+ * If the rtc doesn't work, run "date reset"
+ * twice in u-boot.
+ */
+ status = "okay";
+ };
+ };
+ };
+};
+
+ð0 {
+ /* ethernet@70000 */
+ mac-address = [00 50 43 02 02 01];
+ pinctrl-0 = <&ge0_rgmii_pins>;
+ pinctrl-names = "default";
+ phy = <&phy_dedicated>;
+ phy-mode = "rgmii-id";
+ status = "okay";
+};
+
+&mdio {
+ /*
+ * Add the phy clock here, so the phy can be accessed to read its
+ * IDs prior to binding with the driver.
+ */
+ pinctrl-0 = <&mdio_pins µsom_phy_clk_pins>;
+ pinctrl-names = "default";
+
+ phy_dedicated: ethernet-phy@0 {
+ /*
+ * Annoyingly, the marvell phy driver configures the LED
+ * register, rather than preserving reset-loaded setting.
+ * We undo that rubbish here.
+ */
+ marvell,reg-init = <3 16 0 0x101e>;
+ reg = <0>;
+ };
+};
+
+&pinctrl {
+ microsom_phy_clk_pins: microsom-phy-clk-pins {
+ marvell,pins = "mpp45";
+ marvell,function = "ref";
+ };
+ /* Optional eMMC */
+ microsom_sdhci_pins: microsom-sdhci-pins {
+ marvell,pins = "mpp21", "mpp28", "mpp37",
+ "mpp38", "mpp39", "mpp40";
+ marvell,function = "sd0";
+ };
+};
+
+&spi1 {
+ /* The microsom has an optional W25Q32 on board, connected to CS0 */
+ pinctrl-0 = <&spi1_pins>;
+
+ w25q32: spi-flash@0 {
+ #address-cells = <1>;
+ #size-cells = <1>;
+ compatible = "w25q32", "jedec,spi-nor";
+ reg = <0>; /* Chip select 0 */
+ spi-max-frequency = <3000000>;
+ status = "disabled";
+ };
+};
+
+&uart0 {
+ pinctrl-0 = <&uart0_pins>;
+ pinctrl-names = "default";
+ status = "okay";
+ u-boot,dm-pre-reloc;
+};
diff --git a/arch/arm/mach-mvebu/Kconfig b/arch/arm/mach-mvebu/Kconfig
index f431cff..5415b5a 100644
--- a/arch/arm/mach-mvebu/Kconfig
+++ b/arch/arm/mach-mvebu/Kconfig
@@ -75,6 +75,10 @@
bool "Support ClearFog"
select 88F6820
+config TARGET_HELIOS4
+ bool "Support Helios4"
+ select 88F6820
+
config TARGET_MVEBU_ARMADA_37XX
bool "Support Armada 37xx platforms"
select ARMADA_3700
@@ -132,6 +136,7 @@
config SYS_BOARD
default "clearfog" if TARGET_CLEARFOG
+ default "helios4" if TARGET_HELIOS4
default "mvebu_armada-37xx" if TARGET_MVEBU_ARMADA_37XX
default "db-88f6720" if TARGET_DB_88F6720
default "db-88f6820-gp" if TARGET_DB_88F6820_GP
@@ -146,6 +151,7 @@
config SYS_CONFIG_NAME
default "clearfog" if TARGET_CLEARFOG
+ default "helios4" if TARGET_HELIOS4
default "mvebu_armada-37xx" if TARGET_MVEBU_ARMADA_37XX
default "db-88f6720" if TARGET_DB_88F6720
default "db-88f6820-gp" if TARGET_DB_88F6820_GP
@@ -166,6 +172,7 @@
default "Marvell" if TARGET_DB_88F6820_AMC
default "Marvell" if TARGET_MVEBU_ARMADA_8K
default "solidrun" if TARGET_CLEARFOG
+ default "kobol" if TARGET_HELIOS4
default "Synology" if TARGET_DS414
default "CZ.NIC" if TARGET_TURRIS_OMNIA
default "CZ.NIC" if TARGET_TURRIS_MOX
diff --git a/board/CZ.NIC/turris_omnia/turris_omnia.c b/board/CZ.NIC/turris_omnia/turris_omnia.c
index da663cf..160d30c 100644
--- a/board/CZ.NIC/turris_omnia/turris_omnia.c
+++ b/board/CZ.NIC/turris_omnia/turris_omnia.c
@@ -321,7 +321,11 @@
writel(OMNIA_GPP_OUT_ENA_LOW, MVEBU_GPIO0_BASE + 0x04);
writel(OMNIA_GPP_OUT_ENA_MID, MVEBU_GPIO1_BASE + 0x04);
- /* Disable I2C debug mode blocking 0x64 I2C address */
+ /*
+ * Disable I2C debug mode blocking 0x64 I2C address.
+ * Note: that would be redundant once Turris Omnia migrates to DM_I2C,
+ * because the mvtwsi driver includes equivalent code.
+ */
i2c_debug_reg = readl(MVEBU_TWSI_BASE + MVTWSI_ARMADA_DEBUG_REG);
i2c_debug_reg &= ~(1<<18);
writel(i2c_debug_reg, MVEBU_TWSI_BASE + MVTWSI_ARMADA_DEBUG_REG);
diff --git a/board/kobol/helios4/MAINTAINERS b/board/kobol/helios4/MAINTAINERS
new file mode 100644
index 0000000..c9610de
--- /dev/null
+++ b/board/kobol/helios4/MAINTAINERS
@@ -0,0 +1,6 @@
+HELIOS4 BOARD
+M: Dennis Gilmore <dgilmore@redhat.com>
+S: Maintained
+F: board/kobol/helios4/
+F: include/configs/helios4.h
+F: configs/helios4_defconfig
diff --git a/board/kobol/helios4/Makefile b/board/kobol/helios4/Makefile
new file mode 100644
index 0000000..63f0796
--- /dev/null
+++ b/board/kobol/helios4/Makefile
@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: GPL-2.0+
+#
+# Copyright (C) 2018 Dennis Gilmore <dgilmore@redhat.com>
+
+obj-y := helios4.o
diff --git a/board/kobol/helios4/README b/board/kobol/helios4/README
new file mode 100644
index 0000000..749f048
--- /dev/null
+++ b/board/kobol/helios4/README
@@ -0,0 +1,46 @@
+Update from original Marvell U-Boot to mainline U-Boot:
+-------------------------------------------------------
+
+Generate the U-Boot image with these commands:
+
+$ make helios4_defconfig
+$ make
+
+The resulting image including the SPL binary with the
+full DDR setup is "u-boot-spl.kwb".
+
+Now all you need to do is copy this image on a SD card.
+For example with this command:
+
+$ sudo dd if=u-boot-spl.kwb of=/dev/sdX bs=512 seek=1
+
+Please use the correct device node for your setup instead
+of "/dev/sdX" here!
+
+Boot selection:
+---------------
+
+Before powering up the board, boot selection should be done via the SW1 dip
+switch (0: OFF, 1: ON):
+
+ - SPI: 00010
+ - SD/eMMC: 00111
+ - SATA1: 11100
+ - UART: 11110
+
+Boot from UART:
+---------------
+
+Connect the on-board micro-USB (CF Pro: CON11, CF Base: CON5)
+to your host.
+
+Set the SW1 DIP switches to UART boot (see above).
+
+Run the following command to initiate U-Boot download:
+
+ ./tools/kwboot -p -b u-boot-spl.kwb /dev/ttyUSBX
+
+Use the correct UART device node for /dev/ttyUSBX.
+
+When download finishes start your favorite terminal emulator
+on /dev/ttyUSBX.
diff --git a/board/kobol/helios4/helios4.c b/board/kobol/helios4/helios4.c
new file mode 100644
index 0000000..3416783
--- /dev/null
+++ b/board/kobol/helios4/helios4.c
@@ -0,0 +1,163 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (C) 2018 Dennis Gilmore <dgilmore@redhat.com>
+ * based on board/solidrun/clearfog/clearfog.c
+ */
+
+#include <common.h>
+#include <i2c.h>
+#include <miiphy.h>
+#include <netdev.h>
+#include <asm/io.h>
+#include <asm/arch/cpu.h>
+#include <asm/arch/soc.h>
+
+#include "../drivers/ddr/marvell/a38x/ddr3_init.h"
+#include <../serdes/a38x/high_speed_env_spec.h>
+
+DECLARE_GLOBAL_DATA_PTR;
+
+#define ETH_PHY_CTRL_REG 0
+#define ETH_PHY_CTRL_POWER_DOWN_BIT 11
+#define ETH_PHY_CTRL_POWER_DOWN_MASK BIT(ETH_PHY_CTRL_POWER_DOWN_BIT)
+
+/*
+ * Those values and defines are taken from the Marvell U-Boot version
+ * "u-boot-2013.01-15t1-helios4" as well as the upstream config for clearfog
+ */
+#define BOARD_GPP_OUT_ENA_LOW 0xffffffff
+#define BOARD_GPP_OUT_ENA_MID 0xffffffff
+
+#define BOARD_GPP_OUT_VAL_LOW 0x0
+#define BOARD_GPP_OUT_VAL_MID 0x0
+#define BOARD_GPP_POL_LOW 0x0
+#define BOARD_GPP_POL_MID 0x0
+
+/* IO expander on Marvell GP board includes e.g. fan enabling */
+struct marvell_io_exp {
+ u8 addr;
+ u8 val;
+};
+
+static struct marvell_io_exp io_exp[] = {
+ {6, 0xf9},
+ {2, 0x46}, /* Assert reset signals and enable USB3 current limiter */
+ {6, 0xb9}
+};
+
+static struct serdes_map board_serdes_map[] = {
+ {SATA0, SERDES_SPEED_6_GBPS, SERDES_DEFAULT_MODE, 0, 0},
+ {USB3_HOST0, SERDES_SPEED_5_GBPS, SERDES_DEFAULT_MODE, 0, 0},
+ {SATA1, SERDES_SPEED_6_GBPS, SERDES_DEFAULT_MODE, 0, 0},
+ {SATA3, SERDES_SPEED_6_GBPS, SERDES_DEFAULT_MODE, 0, 0},
+ {SATA2, SERDES_SPEED_6_GBPS, SERDES_DEFAULT_MODE, 0, 0},
+ {USB3_HOST1, SERDES_SPEED_5_GBPS, SERDES_DEFAULT_MODE, 0, 0},
+};
+
+int hws_board_topology_load(struct serdes_map **serdes_map_array, u8 *count)
+{
+ *serdes_map_array = board_serdes_map;
+ *count = ARRAY_SIZE(board_serdes_map);
+ return 0;
+}
+
+/*
+ * Define the DDR layout / topology here in the board file. This will
+ * be used by the DDR3 init code in the SPL U-Boot version to configure
+ * the DDR3 controller.
+ */
+static struct mv_ddr_topology_map board_topology_map = {
+ DEBUG_LEVEL_ERROR,
+ 0x1, /* active interfaces */
+ /* cs_mask, mirror, dqs_swap, ck_swap X PUPs */
+ { { { {0x1, 0, 0, 0},
+ {0x1, 0, 0, 0},
+ {0x1, 0, 0, 0},
+ {0x1, 0, 0, 0},
+ {0x1, 0, 0, 0} },
+ SPEED_BIN_DDR_1600K, /* speed_bin */
+ MV_DDR_DEV_WIDTH_16BIT, /* memory_width */
+ MV_DDR_DIE_CAP_8GBIT, /* mem_size */
+ DDR_FREQ_800, /* frequency */
+ 0, 0, /* cas_wl cas_l */
+ MV_DDR_TEMP_LOW, /* temperature */
+ MV_DDR_TIM_DEFAULT} }, /* timing */
+ BUS_MASK_32BIT_ECC, /* Busses mask */
+ MV_DDR_CFG_DEFAULT, /* ddr configuration data source */
+ { {0} }, /* raw spd data */
+ {0} /* timing parameters */
+};
+
+struct mv_ddr_topology_map *mv_ddr_topology_map_get(void)
+{
+ /* Return the board topology as defined in the board code */
+ return &board_topology_map;
+}
+
+int board_early_init_f(void)
+{
+ /* Configure MPP */
+ writel(0x11111111, MVEBU_MPP_BASE + 0x00);
+ writel(0x11111111, MVEBU_MPP_BASE + 0x04);
+ writel(0x10400011, MVEBU_MPP_BASE + 0x08);
+ writel(0x22043333, MVEBU_MPP_BASE + 0x0c);
+ writel(0x44400002, MVEBU_MPP_BASE + 0x10);
+ writel(0x41144004, MVEBU_MPP_BASE + 0x14);
+ writel(0x40333333, MVEBU_MPP_BASE + 0x18);
+ writel(0x00004444, MVEBU_MPP_BASE + 0x1c);
+
+ /* Set GPP Out value */
+ writel(BOARD_GPP_OUT_VAL_LOW, MVEBU_GPIO0_BASE + 0x00);
+ writel(BOARD_GPP_OUT_VAL_MID, MVEBU_GPIO1_BASE + 0x00);
+
+ /* Set GPP Polarity */
+ writel(BOARD_GPP_POL_LOW, MVEBU_GPIO0_BASE + 0x0c);
+ writel(BOARD_GPP_POL_MID, MVEBU_GPIO1_BASE + 0x0c);
+
+ /* Set GPP Out Enable */
+ writel(BOARD_GPP_OUT_ENA_LOW, MVEBU_GPIO0_BASE + 0x04);
+ writel(BOARD_GPP_OUT_ENA_MID, MVEBU_GPIO1_BASE + 0x04);
+
+ return 0;
+}
+
+int board_init(void)
+{
+ int i;
+
+ /* Address of boot parameters */
+ gd->bd->bi_boot_params = mvebu_sdram_bar(0) + 0x100;
+
+ /* Init I2C IO expanders */
+ for (i = 0; i < ARRAY_SIZE(io_exp); i++) {
+ struct udevice *dev;
+ int ret;
+
+ ret = i2c_get_chip_for_busnum(0, io_exp[i].addr, 1, &dev);
+ if (ret) {
+ printf("Cannot find I2C: %d\n", ret);
+ return 0;
+ }
+
+ ret = dm_i2c_write(dev, io_exp[i].val, &io_exp[i].val, 1);
+ if (ret) {
+ printf("Failed to set IO expander via I2C\n");
+ return -EIO;
+ }
+ }
+
+ return 0;
+}
+
+int checkboard(void)
+{
+ puts("Board: Helios4\n");
+
+ return 0;
+}
+
+int board_eth_init(bd_t *bis)
+{
+ cpu_eth_init(bis); /* Built in controller(s) come first */
+ return pci_eth_init(bis);
+}
diff --git a/board/kobol/helios4/kwbimage.cfg b/board/kobol/helios4/kwbimage.cfg
new file mode 100644
index 0000000..035063b
--- /dev/null
+++ b/board/kobol/helios4/kwbimage.cfg
@@ -0,0 +1,13 @@
+# SPDX-License-Identifier: GPL-2.0+
+#
+# Copyright (C) 2015 Stefan Roese <sr@denx.de>
+#
+
+# Armada 38x use version 1 image format
+VERSION 1
+
+# Boot Media configurations
+BOOT_FROM sdio
+
+# Binary Header (bin_hdr) with DDR3 training code
+BINARY spl/u-boot-spl-dtb.bin 0000005b 00000068
diff --git a/configs/helios4_defconfig b/configs/helios4_defconfig
new file mode 100644
index 0000000..b724285
--- /dev/null
+++ b/configs/helios4_defconfig
@@ -0,0 +1,58 @@
+CONFIG_ARM=y
+CONFIG_ARCH_MVEBU=y
+CONFIG_SYS_TEXT_BASE=0x00800000
+CONFIG_SPL_LIBCOMMON_SUPPORT=y
+CONFIG_SPL_LIBGENERIC_SUPPORT=y
+CONFIG_SYS_MALLOC_F_LEN=0x2000
+CONFIG_TARGET_HELIOS4=y
+CONFIG_SPL_MMC_SUPPORT=y
+CONFIG_SPL_SERIAL_SUPPORT=y
+CONFIG_SPL_LIBDISK_SUPPORT=y
+CONFIG_SPL=y
+CONFIG_DEFAULT_DEVICE_TREE="armada-388-helios4"
+CONFIG_DEBUG_UART=y
+CONFIG_DISTRO_DEFAULTS=y
+CONFIG_BOOTDELAY=3
+CONFIG_SYS_CONSOLE_INFO_QUIET=y
+# CONFIG_DISPLAY_BOARDINFO is not set
+CONFIG_DISPLAY_BOARDINFO_LATE=y
+CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR=0x141
+CONFIG_SPL_I2C_SUPPORT=y
+# CONFIG_CMD_FLASH is not set
+CONFIG_CMD_I2C=y
+CONFIG_CMD_MMC=y
+CONFIG_CMD_PCI=y
+CONFIG_CMD_SF=y
+CONFIG_CMD_SPI=y
+CONFIG_CMD_USB=y
+# CONFIG_CMD_SETEXPR is not set
+CONFIG_CMD_TFTPPUT=y
+CONFIG_CMD_CACHE=y
+CONFIG_CMD_TIME=y
+# CONFIG_SPL_PARTITION_UUIDS is not set
+CONFIG_ENV_IS_IN_MMC=y
+CONFIG_NET_RANDOM_ETHADDR=y
+CONFIG_SPL_OF_TRANSLATE=y
+CONFIG_MMC_SDHCI=y
+CONFIG_MMC_SDHCI_SDMA=y
+CONFIG_MMC_SDHCI_MV=y
+CONFIG_AHCI=y
+CONFIG_SCSI_AHCI=y
+CONFIG_SCSI=y
+CONFIG_SPI_FLASH=y
+CONFIG_SPI_FLASH_BAR=y
+CONFIG_SPI_FLASH_WINBOND=y
+CONFIG_SPI_FLASH_MTD=y
+CONFIG_PHY_GIGE=y
+CONFIG_MVNETA=y
+CONFIG_PCI=y
+CONFIG_DEBUG_UART_BASE=0xd0012000
+CONFIG_DEBUG_UART_CLOCK=250000000
+CONFIG_DEBUG_UART_SHIFT=2
+CONFIG_SYS_NS16550=y
+CONFIG_KIRKWOOD_SPI=y
+CONFIG_USB=y
+CONFIG_DM_USB=y
+CONFIG_DM_I2C=y
+CONFIG_USB_XHCI_HCD=y
+CONFIG_USB_STORAGE=y
diff --git a/drivers/i2c/mvtwsi.c b/drivers/i2c/mvtwsi.c
index f9822e5..74ac0a4 100644
--- a/drivers/i2c/mvtwsi.c
+++ b/drivers/i2c/mvtwsi.c
@@ -11,6 +11,7 @@
#include <i2c.h>
#include <linux/errno.h>
#include <asm/io.h>
+#include <linux/bitops.h>
#include <linux/compat.h>
#ifdef CONFIG_DM_I2C
#include <dm.h>
@@ -57,6 +58,7 @@
u32 status;
u32 baudrate;
u32 soft_reset;
+ u32 debug; /* Dummy field for build compatibility with mvebu */
};
#else
@@ -70,8 +72,10 @@
u32 baudrate; /* When writing */
};
u32 xtnd_slave_addr;
- u32 reserved[2];
+ u32 reserved0[2];
u32 soft_reset;
+ u32 reserved1[27];
+ u32 debug;
};
#endif
@@ -795,6 +799,23 @@
return 0;
}
+static void twsi_disable_i2c_slave(struct mvtwsi_registers *twsi)
+{
+ clrbits_le32(&twsi->debug, BIT(18));
+}
+
+static int mvtwsi_i2c_bind(struct udevice *bus)
+{
+ struct mvtwsi_registers *twsi = devfdt_get_addr_ptr(bus);
+
+ /* Disable the hidden slave in i2c0 of these platforms */
+ if ((IS_ENABLED(CONFIG_ARMADA_38X) || IS_ENABLED(CONFIG_KIRKWOOD))
+ && bus->req_seq == 0)
+ twsi_disable_i2c_slave(twsi);
+
+ return 0;
+}
+
static int mvtwsi_i2c_probe(struct udevice *bus)
{
struct mvtwsi_i2c_dev *dev = dev_get_priv(bus);
@@ -850,6 +871,7 @@
.name = "i2c_mvtwsi",
.id = UCLASS_I2C,
.of_match = mvtwsi_i2c_ids,
+ .bind = mvtwsi_i2c_bind,
.probe = mvtwsi_i2c_probe,
.ofdata_to_platdata = mvtwsi_i2c_ofdata_to_platdata,
.priv_auto_alloc_size = sizeof(struct mvtwsi_i2c_dev),
diff --git a/drivers/mtd/ubi/build.c b/drivers/mtd/ubi/build.c
index 0198d8b..42c5270 100644
--- a/drivers/mtd/ubi/build.c
+++ b/drivers/mtd/ubi/build.c
@@ -1250,7 +1250,7 @@
BUILD_BUG_ON(sizeof(struct ubi_vid_hdr) != 64);
if (mtd_devs > UBI_MAX_DEVICES) {
- pr_err("UBI error: too many MTD devices, maximum is %d",
+ pr_err("UBI error: too many MTD devices, maximum is %d\n",
UBI_MAX_DEVICES);
return -EINVAL;
}
@@ -1262,7 +1262,7 @@
err = misc_register(&ubi_ctrl_cdev);
if (err) {
- pr_err("UBI error: cannot register device");
+ pr_err("UBI error: cannot register device\n");
goto out;
}
@@ -1289,7 +1289,7 @@
mtd = open_mtd_device(p->name);
if (IS_ERR(mtd)) {
err = PTR_ERR(mtd);
- pr_err("UBI error: cannot open mtd %s, error %d",
+ pr_err("UBI error: cannot open mtd %s, error %d\n",
p->name, err);
/* See comment below re-ubi_is_module(). */
if (ubi_is_module())
@@ -1302,7 +1302,7 @@
p->vid_hdr_offs, p->max_beb_per1024);
mutex_unlock(&ubi_devices_mutex);
if (err < 0) {
- pr_err("UBI error: cannot attach mtd%d",
+ pr_err("UBI error: cannot attach mtd%d\n",
mtd->index);
put_mtd_device(mtd);
@@ -1326,7 +1326,7 @@
err = ubiblock_init();
if (err) {
- pr_err("UBI error: block: cannot initialize, error %d", err);
+ pr_err("UBI error: block: cannot initialize, error %d\n", err);
/* See comment above re-ubi_is_module(). */
if (ubi_is_module())
@@ -1353,7 +1353,7 @@
mtd_devs = 0;
#endif
class_unregister(&ubi_class);
- pr_err("UBI error: cannot initialize UBI, error %d", err);
+ pr_err("UBI error: cannot initialize UBI, error %d\n", err);
return err;
}
late_initcall(ubi_init);
diff --git a/include/configs/helios4.h b/include/configs/helios4.h
new file mode 100644
index 0000000..ce912ea
--- /dev/null
+++ b/include/configs/helios4.h
@@ -0,0 +1,172 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+/*
+ * Copyright (C) 2018 Dennis Gilmore <dgilmore@redhat.com>
+ */
+
+#ifndef _CONFIG_HELIOS4_H
+#define _CONFIG_HELIOS4_H
+
+/*
+ * High Level Configuration Options (easy to change)
+ */
+
+/*
+ * TEXT_BASE needs to be below 16MiB, since this area is scrubbed
+ * for DDR ECC byte filling in the SPL before loading the main
+ * U-Boot into it.
+ */
+#define CONFIG_SYS_TCLK 250000000 /* 250MHz */
+
+/*
+ * Commands configuration
+ */
+
+/* SPI NOR flash default params, used by sf commands */
+#define CONFIG_SF_DEFAULT_BUS 1
+
+/*
+ * SDIO/MMC Card Configuration
+ */
+#define CONFIG_SYS_MMC_BASE MVEBU_SDIO_BASE
+
+/* USB/EHCI configuration */
+#define CONFIG_EHCI_IS_TDI
+
+#define CONFIG_ENV_MIN_ENTRIES 128
+
+/*
+ * SATA/SCSI/AHCI configuration
+ */
+#define CONFIG_SCSI_AHCI_PLAT
+#define CONFIG_SYS_SCSI_MAX_SCSI_ID 2
+#define CONFIG_SYS_SCSI_MAX_LUN 2
+#define CONFIG_SYS_SCSI_MAX_DEVICE (CONFIG_SYS_SCSI_MAX_SCSI_ID * \
+ CONFIG_SYS_SCSI_MAX_LUN)
+
+/* Environment in MMC */
+#define CONFIG_SYS_MMC_ENV_DEV 0
+#define CONFIG_ENV_SECT_SIZE 0x200
+#define CONFIG_ENV_SIZE 0x10000
+/*
+ * For SD - reserve 1 LBA for MBR + 1M for u-boot image. The MMC/eMMC
+ * boot image starts @ LBA-0.
+ * As result in MMC/eMMC case it will be a 1 sector gap between u-boot
+ * image and environment
+ */
+#define CONFIG_ENV_OFFSET 0xf0000
+#define CONFIG_ENV_ADDR CONFIG_ENV_OFFSET
+
+#define CONFIG_PHY_MARVELL /* there is a marvell phy */
+#define PHY_ANEG_TIMEOUT 8000 /* PHY needs a longer aneg time */
+
+/* PCIe support */
+#ifndef CONFIG_SPL_BUILD
+#define CONFIG_PCI_MVEBU
+#define CONFIG_PCI_SCAN_SHOW
+#endif
+
+/* Keep device tree and initrd in lower memory so the kernel can access them */
+#define RELOCATION_LIMITS_ENV_SETTINGS \
+ "fdt_high=0x10000000\0" \
+ "initrd_high=0x10000000\0"
+
+/* SPL */
+/*
+ * Select the boot device here
+ *
+ * Currently supported are:
+ * SPL_BOOT_SPI_NOR_FLASH - Booting via SPI NOR flash
+ * SPL_BOOT_SDIO_MMC_CARD - Booting via SDIO/MMC card (partition 1)
+ */
+#define SPL_BOOT_SPI_NOR_FLASH 1
+#define SPL_BOOT_SDIO_MMC_CARD 2
+#define CONFIG_SPL_BOOT_DEVICE SPL_BOOT_SDIO_MMC_CARD
+
+/* Defines for SPL */
+#define CONFIG_SPL_SIZE (140 << 10)
+#define CONFIG_SPL_TEXT_BASE 0x40000030
+#define CONFIG_SPL_MAX_SIZE (CONFIG_SPL_SIZE - 0x0030)
+
+#define CONFIG_SPL_BSS_START_ADDR (0x40000000 + CONFIG_SPL_SIZE)
+#define CONFIG_SPL_BSS_MAX_SIZE (16 << 10)
+
+#ifdef CONFIG_SPL_BUILD
+#define CONFIG_SYS_MALLOC_SIMPLE
+#endif
+
+#define CONFIG_SPL_STACK (0x40000000 + ((192 - 16) << 10))
+#define CONFIG_SPL_BOOTROM_SAVE (CONFIG_SPL_STACK + 4)
+
+#if CONFIG_SPL_BOOT_DEVICE == SPL_BOOT_SPI_NOR_FLASH
+/* SPL related SPI defines */
+#define CONFIG_SYS_SPI_U_BOOT_OFFS 0x20000
+#define CONFIG_SYS_U_BOOT_OFFS CONFIG_SYS_SPI_U_BOOT_OFFS
+#endif
+
+#if CONFIG_SPL_BOOT_DEVICE == SPL_BOOT_SDIO_MMC_CARD
+/* SPL related MMC defines */
+#define CONFIG_SYS_MMC_U_BOOT_OFFS (160 << 10)
+#define CONFIG_SYS_U_BOOT_OFFS CONFIG_SYS_MMC_U_BOOT_OFFS
+#ifdef CONFIG_SPL_BUILD
+#define CONFIG_FIXED_SDHCI_ALIGNED_BUFFER 0x00180000 /* in SDRAM */
+#endif
+#endif
+/*
+ * mv-common.h should be defined after CMD configs since it used them
+ * to enable certain macros
+ */
+#include "mv-common.h"
+
+/* Include the common distro boot environment */
+#ifndef CONFIG_SPL_BUILD
+
+#ifdef CONFIG_MMC
+#define BOOT_TARGET_DEVICES_MMC(func) func(MMC, mmc, 0)
+#else
+#define BOOT_TARGET_DEVICES_MMC(func)
+#endif
+
+#ifdef CONFIG_USB_STORAGE
+#define BOOT_TARGET_DEVICES_USB(func) func(USB, usb, 0)
+#else
+#define BOOT_TARGET_DEVICES_USB(func)
+#endif
+
+#ifdef CONFIG_SATA
+#define BOOT_TARGET_DEVICES_SATA(func) func(SATA, sata, 0)
+#else
+#define BOOT_TARGET_DEVICES_SATA(func)
+#endif
+
+#define BOOT_TARGET_DEVICES(func) \
+ BOOT_TARGET_DEVICES_MMC(func) \
+ BOOT_TARGET_DEVICES_USB(func) \
+ BOOT_TARGET_DEVICES_SATA(func) \
+ func(PXE, pxe, na) \
+ func(DHCP, dhcp, na)
+
+#define KERNEL_ADDR_R __stringify(0x800000)
+#define FDT_ADDR_R __stringify(0x100000)
+#define RAMDISK_ADDR_R __stringify(0x1800000)
+#define SCRIPT_ADDR_R __stringify(0x200000)
+#define PXEFILE_ADDR_R __stringify(0x300000)
+
+#define LOAD_ADDRESS_ENV_SETTINGS \
+ "kernel_addr_r=" KERNEL_ADDR_R "\0" \
+ "fdt_addr_r=" FDT_ADDR_R "\0" \
+ "ramdisk_addr_r=" RAMDISK_ADDR_R "\0" \
+ "scriptaddr=" SCRIPT_ADDR_R "\0" \
+ "pxefile_addr_r=" PXEFILE_ADDR_R "\0"
+
+#include <config_distro_bootcmd.h>
+
+#define CONFIG_EXTRA_ENV_SETTINGS \
+ RELOCATION_LIMITS_ENV_SETTINGS \
+ LOAD_ADDRESS_ENV_SETTINGS \
+ "fdtfile=" CONFIG_DEFAULT_DEVICE_TREE ".dtb\0" \
+ "console=ttyS0,115200\0" \
+ BOOTENV
+
+#endif /* CONFIG_SPL_BUILD */
+
+#endif /* _CONFIG_HELIOS4_H */
diff --git a/test/run b/test/run
index b2d24e3..eb1563d 100755
--- a/test/run
+++ b/test/run
@@ -11,8 +11,7 @@
run_test ./test/py/test.py --bd sandbox --build
# Run tests which require sandbox_spl
-run_test ./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_ofplatdata.py
# Run tests for the flat DT version of sandbox
./test/py/test.py --bd sandbox_flattree --build
diff --git a/tools/binman/README b/tools/binman/README
index b200981..22f21bc 100644
--- a/tools/binman/README
+++ b/tools/binman/README
@@ -302,9 +302,9 @@
align-end:
This sets the alignment of the end of an entry. Some entries require
that they end on an alignment boundary, regardless of where they
- start. If 'align-end' is not provided, no alignment is performed.
-
- Note: This is not yet implemented in binman.
+ start. This does not move the start of the entry, so the contents of
+ the entry will still start at the beginning. But there may be padding
+ at the end. If 'align-end' is not provided, no alignment is performed.
filename:
For 'blob' types this provides the filename containing the binary to
@@ -316,6 +316,13 @@
possible to use any name, and then add (for example) 'type = "u-boot"'
to specify the type.
+pos-unset:
+ Indicates that the position of this entry should not be set by placing
+ it immediately after the entry before. Instead, is set by another
+ entry which knows where this entry should go. When this boolean
+ property is present, binman will give an error if another entry does
+ not set the position (with the GetPositions() method).
+
The attributes supported for images are described below. Several are similar
to those for entries.
@@ -387,6 +394,57 @@
Examples of the above options can be found in the tests. See the
tools/binman/test directory.
+It is possible to have the same binary appear multiple times in the image,
+either by using a unit number suffix (u-boot@0, u-boot@1) or by using a
+different name for each and specifying the type with the 'type' attribute.
+
+
+Sections and hiearchical images
+-------------------------------
+
+Sometimes it is convenient to split an image into several pieces, each of which
+contains its own set of binaries. An example is a flash device where part of
+the image is read-only and part is read-write. We can set up sections for each
+of these, and place binaries in them independently. The image is still produced
+as a single output file.
+
+This feature provides a way of creating hierarchical images. For example here
+is an example image with two copies of U-Boot. One is read-only (ro), intended
+to be written only in the factory. Another is read-write (rw), so that it can be
+upgraded in the field. The sizes are fixed so that the ro/rw boundary is known
+and can be programmed:
+
+ binman {
+ section@0 {
+ read-only;
+ name-prefix = "ro-";
+ size = <0x100000>;
+ u-boot {
+ };
+ };
+ section@1 {
+ name-prefix = "rw-";
+ size = <0x100000>;
+ u-boot {
+ };
+ };
+ };
+
+This image could be placed into a SPI flash chip, with the protection boundary
+set at 1MB.
+
+A few special properties are provided for sections:
+
+read-only:
+ Indicates that this section is read-only. This has no impact on binman's
+ operation, but his property can be read at run time.
+
+name-prefix:
+ This string is prepended to all the names of the binaries in the
+ section. In the example above, the 'u-boot' binaries which actually be
+ renamed to 'ro-u-boot' and 'rw-u-boot'. This can be useful to
+ distinguish binaries with otherwise identical names.
+
Special properties
------------------
@@ -498,6 +556,25 @@
to fill in such symbols in U-Boot proper, as well.
+Map files
+---------
+
+The -m option causes binman to output a .map file for each image that it
+generates. This shows the position and size of each entry. For example:
+
+ Position Size Name
+ 00000000 00000010 section@0
+ 00000000 00000004 u-boot
+ 00000010 00000010 section@1
+ 00000000 00000004 u-boot
+
+This shows a hierarchical image with two sections, each with a single entry. The
+positions of the sections are absolute hex byte offsets within the image. The
+positions of the entries are relative to their respective sections. The size of
+each entry is also shown, in bytes (hex). The indentation shows the entries
+nested inside their sections.
+
+
Code coverage
-------------
@@ -547,7 +624,7 @@
a reasonably simple and sound design but has expanded greatly over the
years. In particular its handling of x86 images is convoluted.
-Quite a few lessons have been learned which are hopefully be applied here.
+Quite a few lessons have been learned which are hopefully applied here.
Design notes
@@ -578,17 +655,13 @@
'Access to binman entry positions at run time' above
- Use of-platdata to make the information available to code that is unable
to use device tree (such as a very small SPL image)
-- Write an image map to a text file
- Allow easy building of images by specifying just the board name
- Produce a full Python binding for libfdt (for upstream)
- Add an option to decode an image into the constituent binaries
-- Suppoort hierarchical images (packing of binaries into another binary
- which is then placed in the image)
- Support building an image for a board (-b) more completely, with a
configurable build directory
- Consider making binman work with buildman, although if it is used in the
Makefile, this will be automatic
-- Implement align-end
--
Simon Glass <sjg@chromium.org>
diff --git a/tools/binman/binman.py b/tools/binman/binman.py
index fa2f551..31b0453 100755
--- a/tools/binman/binman.py
+++ b/tools/binman/binman.py
@@ -23,15 +23,18 @@
# Bring in the libfdt module
sys.path.insert(0, 'scripts/dtc/pylibfdt')
-# Also allow entry-type modules to be brought in from the etype directory.
-sys.path.insert(0, os.path.join(our_path, 'etype'))
-
import cmdline
import command
import control
-def RunTests(debug):
- """Run the functional tests and any embedded doctests"""
+def RunTests(debug, args):
+ """Run the functional tests and any embedded doctests
+
+ Args:
+ debug: True to enable debugging, which shows a full stack trace on error
+ args: List of positional args provided to binman. This can hold a test
+ name to execute (as in 'binman -t testSections', for example)
+ """
import elf_test
import entry_test
import fdt_test
@@ -53,9 +56,16 @@
# 'entry' module.
suite = unittest.TestLoader().loadTestsFromTestCase(entry_test.TestEntry)
suite.run(result)
+ test_name = args and args[0] or None
for module in (ftest.TestFunctional, fdt_test.TestFdt, elf_test.TestElf,
image_test.TestImage):
- suite = unittest.TestLoader().loadTestsFromTestCase(module)
+ if test_name:
+ try:
+ suite = unittest.TestLoader().loadTestsFromName(args[0], module)
+ except AttributeError:
+ continue
+ else:
+ suite = unittest.TestLoader().loadTestsFromTestCase(module)
suite.run(result)
print result
@@ -114,7 +124,7 @@
sys.tracebacklimit = 0
if options.test:
- ret_code = RunTests(options.debug)
+ ret_code = RunTests(options.debug, args[1:])
elif options.test_coverage:
RunTestCoverage()
diff --git a/tools/binman/bsection.py b/tools/binman/bsection.py
new file mode 100644
index 0000000..3f30f6e
--- /dev/null
+++ b/tools/binman/bsection.py
@@ -0,0 +1,318 @@
+# SPDX-License-Identifier: GPL-2.0+
+# Copyright (c) 2018 Google, Inc
+# Written by Simon Glass <sjg@chromium.org>
+#
+# Base class for sections (collections of entries)
+#
+
+from __future__ import print_function
+
+from collections import OrderedDict
+import sys
+
+import fdt_util
+import re
+import tools
+
+class Section(object):
+ """A section which contains multiple entries
+
+ A section represents a collection of entries. There must be one or more
+ sections in an image. Sections are used to group entries together.
+
+ Attributes:
+ _node: Node object that contains the section definition in device tree
+ _size: Section size in bytes, or None if not known yet
+ _align_size: Section size alignment, or None
+ _pad_before: Number of bytes before the first entry starts. This
+ effectively changes the place where entry position 0 starts
+ _pad_after: Number of bytes after the last entry ends. The last
+ entry will finish on or before this boundary
+ _pad_byte: Byte to use to pad the section where there is no entry
+ _sort: True if entries should be sorted by position, False if they
+ must be in-order in the device tree description
+ _skip_at_start: Number of bytes before the first entry starts. These
+ effectively adjust the starting position of entries. For example,
+ if _pad_before is 16, then the first entry would start at 16.
+ An entry with pos = 20 would in fact be written at position 4
+ in the image file.
+ _end_4gb: Indicates that the section ends at the 4GB boundary. This is
+ used for x86 images, which want to use positions such that a
+ memory address (like 0xff800000) is the first entry position.
+ This causes _skip_at_start to be set to the starting memory
+ address.
+ _name_prefix: Prefix to add to the name of all entries within this
+ section
+ _entries: OrderedDict() of entries
+ """
+ def __init__(self, name, node, test=False):
+ global entry
+ global Entry
+ import entry
+ from entry import Entry
+
+ self._node = node
+ self._size = None
+ self._align_size = None
+ self._pad_before = 0
+ self._pad_after = 0
+ self._pad_byte = 0
+ self._sort = False
+ self._skip_at_start = 0
+ self._end_4gb = False
+ self._name_prefix = ''
+ self._entries = OrderedDict()
+ if not test:
+ self._ReadNode()
+ self._ReadEntries()
+
+ def _ReadNode(self):
+ """Read properties from the section node"""
+ self._size = fdt_util.GetInt(self._node, 'size')
+ self._align_size = fdt_util.GetInt(self._node, 'align-size')
+ if tools.NotPowerOfTwo(self._align_size):
+ self._Raise("Alignment size %s must be a power of two" %
+ self._align_size)
+ self._pad_before = fdt_util.GetInt(self._node, 'pad-before', 0)
+ self._pad_after = fdt_util.GetInt(self._node, 'pad-after', 0)
+ self._pad_byte = fdt_util.GetInt(self._node, 'pad-byte', 0)
+ self._sort = fdt_util.GetBool(self._node, 'sort-by-pos')
+ self._end_4gb = fdt_util.GetBool(self._node, 'end-at-4gb')
+ if self._end_4gb and not self._size:
+ self._Raise("Section size must be provided when using end-at-4gb")
+ if self._end_4gb:
+ self._skip_at_start = 0x100000000 - self._size
+ self._name_prefix = fdt_util.GetString(self._node, 'name-prefix')
+
+ def _ReadEntries(self):
+ for node in self._node.subnodes:
+ entry = Entry.Create(self, node)
+ entry.SetPrefix(self._name_prefix)
+ self._entries[node.name] = entry
+
+ def CheckSize(self):
+ """Check that the section contents does not exceed its size, etc."""
+ contents_size = 0
+ for entry in self._entries.values():
+ contents_size = max(contents_size, entry.pos + entry.size)
+
+ contents_size -= self._skip_at_start
+
+ size = self._size
+ if not size:
+ size = self._pad_before + contents_size + self._pad_after
+ size = tools.Align(size, self._align_size)
+
+ if self._size and contents_size > self._size:
+ self._Raise("contents size %#x (%d) exceeds section size %#x (%d)" %
+ (contents_size, contents_size, self._size, self._size))
+ if not self._size:
+ self._size = size
+ if self._size != tools.Align(self._size, self._align_size):
+ self._Raise("Size %#x (%d) does not match align-size %#x (%d)" %
+ (self._size, self._size, self._align_size, self._align_size))
+ return size
+
+ def _Raise(self, msg):
+ """Raises an error for this section
+
+ Args:
+ msg: Error message to use in the raise string
+ Raises:
+ ValueError()
+ """
+ raise ValueError("Section '%s': %s" % (self._node.path, msg))
+
+ def GetPath(self):
+ """Get the path of an image (in the FDT)
+
+ Returns:
+ Full path of the node for this image
+ """
+ return self._node.path
+
+ def FindEntryType(self, etype):
+ """Find an entry type in the section
+
+ Args:
+ etype: Entry type to find
+ Returns:
+ entry matching that type, or None if not found
+ """
+ for entry in self._entries.values():
+ if entry.etype == etype:
+ return entry
+ return None
+
+ def GetEntryContents(self):
+ """Call ObtainContents() for each entry
+
+ This calls each entry's ObtainContents() a few times until they all
+ return True. We stop calling an entry's function once it returns
+ True. This allows the contents of one entry to depend on another.
+
+ After 3 rounds we give up since it's likely an error.
+ """
+ todo = self._entries.values()
+ for passnum in range(3):
+ next_todo = []
+ for entry in todo:
+ if not entry.ObtainContents():
+ next_todo.append(entry)
+ todo = next_todo
+ if not todo:
+ break
+
+ def _SetEntryPosSize(self, name, pos, size):
+ """Set the position and size of an entry
+
+ Args:
+ name: Entry name to update
+ pos: New position
+ size: New size
+ """
+ entry = self._entries.get(name)
+ if not entry:
+ self._Raise("Unable to set pos/size for unknown entry '%s'" % name)
+ entry.SetPositionSize(self._skip_at_start + pos, size)
+
+ def GetEntryPositions(self):
+ """Handle entries that want to set the position/size of other entries
+
+ This calls each entry's GetPositions() method. If it returns a list
+ of entries to update, it updates them.
+ """
+ for entry in self._entries.values():
+ pos_dict = entry.GetPositions()
+ for name, info in pos_dict.iteritems():
+ self._SetEntryPosSize(name, *info)
+
+ def PackEntries(self):
+ """Pack all entries into the section"""
+ pos = self._skip_at_start
+ for entry in self._entries.values():
+ pos = entry.Pack(pos)
+
+ def _SortEntries(self):
+ """Sort entries by position"""
+ entries = sorted(self._entries.values(), key=lambda entry: entry.pos)
+ self._entries.clear()
+ for entry in entries:
+ self._entries[entry._node.name] = entry
+
+ def CheckEntries(self):
+ """Check that entries do not overlap or extend outside the section"""
+ if self._sort:
+ self._SortEntries()
+ pos = 0
+ prev_name = 'None'
+ for entry in self._entries.values():
+ entry.CheckPosition()
+ if (entry.pos < self._skip_at_start or
+ entry.pos >= self._skip_at_start + self._size):
+ entry.Raise("Position %#x (%d) is outside the section starting "
+ "at %#x (%d)" %
+ (entry.pos, entry.pos, self._skip_at_start,
+ self._skip_at_start))
+ if entry.pos < pos:
+ entry.Raise("Position %#x (%d) overlaps with previous entry '%s' "
+ "ending at %#x (%d)" %
+ (entry.pos, entry.pos, prev_name, pos, pos))
+ pos = entry.pos + entry.size
+ prev_name = entry.GetPath()
+
+ def ProcessEntryContents(self):
+ """Call the ProcessContents() method for each entry
+
+ This is intended to adjust the contents as needed by the entry type.
+ """
+ for entry in self._entries.values():
+ entry.ProcessContents()
+
+ def WriteSymbols(self):
+ """Write symbol values into binary files for access at run time"""
+ for entry in self._entries.values():
+ entry.WriteSymbols(self)
+
+ def BuildSection(self, fd, base_pos):
+ """Write the section to a file"""
+ fd.seek(base_pos)
+ fd.write(self.GetData())
+
+ def GetData(self):
+ """Write the section to a file"""
+ section_data = chr(self._pad_byte) * self._size
+
+ for entry in self._entries.values():
+ data = entry.GetData()
+ base = self._pad_before + entry.pos - self._skip_at_start
+ section_data = (section_data[:base] + data +
+ section_data[base + len(data):])
+ return section_data
+
+ def LookupSymbol(self, sym_name, optional, msg):
+ """Look up a symbol in an ELF file
+
+ Looks up a symbol in an ELF file. Only entry types which come from an
+ ELF image can be used by this function.
+
+ At present the only entry property supported is pos.
+
+ Args:
+ sym_name: Symbol name in the ELF file to look up in the format
+ _binman_<entry>_prop_<property> where <entry> is the name of
+ the entry and <property> is the property to find (e.g.
+ _binman_u_boot_prop_pos). As a special case, you can append
+ _any to <entry> to have it search for any matching entry. E.g.
+ _binman_u_boot_any_prop_pos will match entries called u-boot,
+ u-boot-img and u-boot-nodtb)
+ optional: True if the symbol is optional. If False this function
+ will raise if the symbol is not found
+ msg: Message to display if an error occurs
+
+ Returns:
+ Value that should be assigned to that symbol, or None if it was
+ optional and not found
+
+ Raises:
+ ValueError if the symbol is invalid or not found, or references a
+ property which is not supported
+ """
+ m = re.match(r'^_binman_(\w+)_prop_(\w+)$', sym_name)
+ if not m:
+ raise ValueError("%s: Symbol '%s' has invalid format" %
+ (msg, sym_name))
+ entry_name, prop_name = m.groups()
+ entry_name = entry_name.replace('_', '-')
+ entry = self._entries.get(entry_name)
+ if not entry:
+ if entry_name.endswith('-any'):
+ root = entry_name[:-4]
+ for name in self._entries:
+ if name.startswith(root):
+ rest = name[len(root):]
+ if rest in ['', '-img', '-nodtb']:
+ entry = self._entries[name]
+ if not entry:
+ err = ("%s: Entry '%s' not found in list (%s)" %
+ (msg, entry_name, ','.join(self._entries.keys())))
+ if optional:
+ print('Warning: %s' % err, file=sys.stderr)
+ return None
+ raise ValueError(err)
+ if prop_name == 'pos':
+ return entry.pos
+ else:
+ raise ValueError("%s: No such property '%s'" % (msg, prop_name))
+
+ def GetEntries(self):
+ return self._entries
+
+ def WriteMap(self, fd, indent):
+ """Write a map of the section to a .map file
+
+ Args:
+ fd: File to write the map to
+ """
+ for entry in self._entries.values():
+ entry.WriteMap(fd, indent)
diff --git a/tools/binman/cmdline.py b/tools/binman/cmdline.py
index e9e0434..bf63919 100644
--- a/tools/binman/cmdline.py
+++ b/tools/binman/cmdline.py
@@ -30,6 +30,8 @@
help='Add a path to a directory to use for input files')
parser.add_option('-H', '--full-help', action='store_true',
default=False, help='Display the README file')
+ parser.add_option('-m', '--map', action='store_true',
+ default=False, help='Output a map file for each image')
parser.add_option('-O', '--outdir', type='string',
action='store', help='Path to directory to use for intermediate and '
'output files')
diff --git a/tools/binman/control.py b/tools/binman/control.py
index bc8ed8e..9243472 100644
--- a/tools/binman/control.py
+++ b/tools/binman/control.py
@@ -112,6 +112,8 @@
image.ProcessEntryContents()
image.WriteSymbols()
image.BuildImage()
+ if options.map:
+ image.WriteMap()
finally:
tools.FinaliseOutputDir()
finally:
diff --git a/tools/binman/elf.py b/tools/binman/elf.py
index 50085a3..0ae3b61 100644
--- a/tools/binman/elf.py
+++ b/tools/binman/elf.py
@@ -75,7 +75,7 @@
return None
return sym.address
-def LookupAndWriteSymbols(elf_fname, entry, image):
+def LookupAndWriteSymbols(elf_fname, entry, section):
"""Replace all symbols in an entry with their correct values
The entry contents is updated so that values for referenced symbols will be
@@ -87,7 +87,7 @@
elf_fname: Filename of ELF image containing the symbol information for
entry
entry: Entry to process
- image: Image which can be used to lookup symbol values
+ section: Section which can be used to lookup symbol values
"""
fname = tools.GetInputFilename(elf_fname)
syms = GetSymbols(fname, ['image', 'binman'])
@@ -98,8 +98,8 @@
return
for name, sym in syms.iteritems():
if name.startswith('_binman'):
- msg = ("Image '%s': Symbol '%s'\n in entry '%s'" %
- (image.GetPath(), name, entry.GetPath()))
+ msg = ("Section '%s': Symbol '%s'\n in entry '%s'" %
+ (section.GetPath(), name, entry.GetPath()))
offset = sym.address - base.address
if offset < 0 or offset + sym.size > entry.contents_size:
raise ValueError('%s has offset %x (size %x) but the contents '
@@ -114,7 +114,7 @@
(msg, sym.size))
# Look up the symbol in our entry tables.
- value = image.LookupSymbol(name, sym.weak, msg)
+ value = section.LookupSymbol(name, sym.weak, msg)
if value is not None:
value += base.address
else:
diff --git a/tools/binman/elf_test.py b/tools/binman/elf_test.py
index 4abde12..fb6e451 100644
--- a/tools/binman/elf_test.py
+++ b/tools/binman/elf_test.py
@@ -40,12 +40,12 @@
def GetPath(self):
return 'entry_path'
-class FakeImage:
+class FakeSection:
def __init__(self, sym_value=1):
self.sym_value = sym_value
def GetPath(self):
- return 'image_path'
+ return 'section_path'
def LookupSymbol(self, name, weak, msg):
return self.sym_value
@@ -67,51 +67,51 @@
def testMissingFile(self):
entry = FakeEntry(10)
- image = FakeImage()
+ section = FakeSection()
with self.assertRaises(ValueError) as e:
- syms = elf.LookupAndWriteSymbols('missing-file', entry, image)
+ syms = elf.LookupAndWriteSymbols('missing-file', entry, section)
self.assertIn("Filename 'missing-file' not found in input path",
str(e.exception))
def testOutsideFile(self):
entry = FakeEntry(10)
- image = FakeImage()
+ section = FakeSection()
elf_fname = os.path.join(binman_dir, 'test', 'u_boot_binman_syms')
with self.assertRaises(ValueError) as e:
- syms = elf.LookupAndWriteSymbols(elf_fname, entry, image)
+ syms = elf.LookupAndWriteSymbols(elf_fname, entry, section)
self.assertIn('entry_path has offset 4 (size 8) but the contents size '
'is a', str(e.exception))
def testMissingImageStart(self):
entry = FakeEntry(10)
- image = FakeImage()
+ section = FakeSection()
elf_fname = os.path.join(binman_dir, 'test', 'u_boot_binman_syms_bad')
- self.assertEqual(elf.LookupAndWriteSymbols(elf_fname, entry, image),
+ self.assertEqual(elf.LookupAndWriteSymbols(elf_fname, entry, section),
None)
def testBadSymbolSize(self):
entry = FakeEntry(10)
- image = FakeImage()
+ section = FakeSection()
elf_fname = os.path.join(binman_dir, 'test', 'u_boot_binman_syms_size')
with self.assertRaises(ValueError) as e:
- syms = elf.LookupAndWriteSymbols(elf_fname, entry, image)
+ syms = elf.LookupAndWriteSymbols(elf_fname, entry, section)
self.assertIn('has size 1: only 4 and 8 are supported',
str(e.exception))
def testNoValue(self):
entry = FakeEntry(20)
- image = FakeImage(sym_value=None)
+ section = FakeSection(sym_value=None)
elf_fname = os.path.join(binman_dir, 'test', 'u_boot_binman_syms')
- syms = elf.LookupAndWriteSymbols(elf_fname, entry, image)
+ syms = elf.LookupAndWriteSymbols(elf_fname, entry, section)
self.assertEqual(chr(255) * 16 + 'a' * 4, entry.data)
def testDebug(self):
elf.debug = True
entry = FakeEntry(20)
- image = FakeImage()
+ section = FakeSection()
elf_fname = os.path.join(binman_dir, 'test', 'u_boot_binman_syms')
with capture_sys_output() as (stdout, stderr):
- syms = elf.LookupAndWriteSymbols(elf_fname, entry, image)
+ syms = elf.LookupAndWriteSymbols(elf_fname, entry, section)
elf.debug = False
self.assertTrue(len(stdout.getvalue()) > 0)
diff --git a/tools/binman/etype/entry.py b/tools/binman/entry.py
similarity index 74%
rename from tools/binman/etype/entry.py
rename to tools/binman/entry.py
index c331312..e4d688c 100644
--- a/tools/binman/etype/entry.py
+++ b/tools/binman/entry.py
@@ -4,6 +4,8 @@
# Base class for all entries
#
+from __future__ import print_function
+
# importlib was introduced in Python 2.7 but there was a report of it not
# working in 2.7.12, so we work around this:
# http://lists.denx.de/pipermail/u-boot/2016-October/269729.html
@@ -14,15 +16,19 @@
have_importlib = False
import fdt_util
+import os
+import sys
import tools
modules = {}
+our_path = os.path.dirname(os.path.realpath(__file__))
+
class Entry(object):
- """An Entry in the image
+ """An Entry in the section
An entry corresponds to a single node in the device-tree description
- of the image. Each entry ends up being a part of the final image.
+ of the section. Each entry ends up being a part of the final section.
Entries can be placed either right next to each other, or with padding
between them. The type of the entry determines the data that is in it.
@@ -30,9 +36,9 @@
Entry.
Attributes:
- image: The image containing this entry
+ section: The section containing this entry
node: The node that created this entry
- pos: Absolute position of entry within the image, None if not known
+ pos: Absolute position of entry within the section, None if not known
size: Entry size in bytes, None if not known
contents_size: Size of contents in bytes, 0 by default
align: Entry start position alignment, or None
@@ -42,10 +48,11 @@
pad_after: Number of pad bytes after the contents, 0 if none
data: Contents of entry (string of bytes)
"""
- def __init__(self, image, etype, node, read_node=True):
- self.image = image
+ def __init__(self, section, etype, node, read_node=True, name_prefix=''):
+ self.section = section
self.etype = etype
self._node = node
+ self.name = node and (name_prefix + node.name) or 'none'
self.pos = None
self.size = None
self.contents_size = 0
@@ -59,11 +66,11 @@
self.ReadNode()
@staticmethod
- def Create(image, node, etype=None):
+ def Create(section, node, etype=None):
"""Create a new entry for a node.
Args:
- image: Image object containing this node
+ section: Image object containing this node
node: Node object containing information about the entry to create
etype: Entry type to use, or None to work it out (used for tests)
@@ -72,11 +79,20 @@
"""
if not etype:
etype = fdt_util.GetString(node, 'type', node.name)
+
+ # Convert something like 'u-boot@0' to 'u_boot' since we are only
+ # interested in the type.
module_name = etype.replace('-', '_')
+ if '@' in module_name:
+ module_name = module_name.split('@')[0]
module = modules.get(module_name)
+ # Also allow entry-type modules to be brought in from the etype directory.
+
# Import the module if we have not already done so.
if not module:
+ old_path = sys.path
+ sys.path.insert(0, os.path.join(our_path, 'etype'))
try:
if have_importlib:
module = importlib.import_module(module_name)
@@ -85,11 +101,13 @@
except ImportError:
raise ValueError("Unknown entry type '%s' in node '%s'" %
(etype, node.path))
+ finally:
+ sys.path = old_path
modules[module_name] = module
# Call its constructor to get the object we want.
obj = getattr(module, 'Entry_%s' % module_name)
- return obj(image, etype, node)
+ return obj(section, etype, node)
def ReadNode(self):
"""Read entry information from the node
@@ -111,6 +129,15 @@
self.align_end = fdt_util.GetInt(self._node, 'align-end')
self.pos_unset = fdt_util.GetBool(self._node, 'pos-unset')
+ def SetPrefix(self, prefix):
+ """Set the name prefix for a node
+
+ Args:
+ prefix: Prefix to set, or '' to not use a prefix
+ """
+ if prefix:
+ self.name = prefix + self.name
+
def ObtainContents(self):
"""Figure out the contents of an entry.
@@ -122,7 +149,7 @@
return True
def Pack(self, pos):
- """Figure out how to pack the entry into the image
+ """Figure out how to pack the entry into the section
Most of the time the entries are not fully specified. There may be
an alignment but no size. In that case we take the size from the
@@ -134,10 +161,10 @@
entry will be know.
Args:
- Current image position pointer
+ Current section position pointer
Returns:
- New image position pointer (after this entry)
+ New section position pointer (after this entry)
"""
if self.pos is None:
if self.pos_unset:
@@ -198,10 +225,29 @@
def ProcessContents(self):
pass
- def WriteSymbols(self, image):
+ def WriteSymbols(self, section):
"""Write symbol values into binary files for access at run time
Args:
- image: Image containing the entry
+ section: Section containing the entry
"""
pass
+
+ def CheckPosition(self):
+ """Check that the entry positions are correct
+
+ This is used for entries which have extra position requirements (other
+ than having to be fully inside their section). Sub-classes can implement
+ this function and raise if there is a problem.
+ """
+ pass
+
+ def WriteMap(self, fd, indent):
+ """Write a map of the entry to a .map file
+
+ Args:
+ fd: File to write the map to
+ indent: Curent indent level of map (0=none, 1=one level, etc.)
+ """
+ print('%s%08x %08x %s' % (' ' * indent, self.pos, self.size,
+ self.name), file=fd)
diff --git a/tools/binman/etype/_testing.py b/tools/binman/etype/_testing.py
index b166a71..c376dd5 100644
--- a/tools/binman/etype/_testing.py
+++ b/tools/binman/etype/_testing.py
@@ -10,8 +10,8 @@
import tools
class Entry__testing(Entry):
- def __init__(self, image, etype, node):
- Entry.__init__(self, image, etype, node)
+ def __init__(self, section, etype, node):
+ Entry.__init__(self, section, etype, node)
def ObtainContents(self):
self.data = 'a'
diff --git a/tools/binman/etype/blob.py b/tools/binman/etype/blob.py
index 10e59e9..16b1e5f 100644
--- a/tools/binman/etype/blob.py
+++ b/tools/binman/etype/blob.py
@@ -10,8 +10,8 @@
import tools
class Entry_blob(Entry):
- def __init__(self, image, etype, node):
- Entry.__init__(self, image, etype, node)
+ def __init__(self, section, etype, node):
+ Entry.__init__(self, section, etype, node)
self._filename = fdt_util.GetString(self._node, "filename", self.etype)
def ObtainContents(self):
diff --git a/tools/binman/etype/intel_cmc.py b/tools/binman/etype/intel_cmc.py
index 07cad2e..b8621e0 100644
--- a/tools/binman/etype/intel_cmc.py
+++ b/tools/binman/etype/intel_cmc.py
@@ -9,5 +9,5 @@
from blob import Entry_blob
class Entry_intel_cmc(Entry_blob):
- def __init__(self, image, etype, node):
- Entry_blob.__init__(self, image, etype, node)
+ def __init__(self, section, etype, node):
+ Entry_blob.__init__(self, section, etype, node)
diff --git a/tools/binman/etype/intel_descriptor.py b/tools/binman/etype/intel_descriptor.py
index 4e0c85b..0e78655 100644
--- a/tools/binman/etype/intel_descriptor.py
+++ b/tools/binman/etype/intel_descriptor.py
@@ -32,8 +32,8 @@
size of the ME region, allowing us to place the ME binary in the right
place.
"""
- def __init__(self, image, etype, node):
- Entry_blob.__init__(self, image, etype, node)
+ def __init__(self, section, etype, node):
+ Entry_blob.__init__(self, section, etype, node)
self._regions = []
def GetPositions(self):
diff --git a/tools/binman/etype/intel_fsp.py b/tools/binman/etype/intel_fsp.py
index 827bd22..cb80a61 100644
--- a/tools/binman/etype/intel_fsp.py
+++ b/tools/binman/etype/intel_fsp.py
@@ -9,5 +9,5 @@
from blob import Entry_blob
class Entry_intel_fsp(Entry_blob):
- def __init__(self, image, etype, node):
- Entry_blob.__init__(self, image, etype, node)
+ def __init__(self, section, etype, node):
+ Entry_blob.__init__(self, section, etype, node)
diff --git a/tools/binman/etype/intel_me.py b/tools/binman/etype/intel_me.py
index e02e485..0682ead 100644
--- a/tools/binman/etype/intel_me.py
+++ b/tools/binman/etype/intel_me.py
@@ -9,5 +9,5 @@
from blob import Entry_blob
class Entry_intel_me(Entry_blob):
- def __init__(self, image, etype, node):
- Entry_blob.__init__(self, image, etype, node)
+ def __init__(self, section, etype, node):
+ Entry_blob.__init__(self, section, etype, node)
diff --git a/tools/binman/etype/intel_mrc.py b/tools/binman/etype/intel_mrc.py
index 7c01b77..305ac98 100644
--- a/tools/binman/etype/intel_mrc.py
+++ b/tools/binman/etype/intel_mrc.py
@@ -9,8 +9,8 @@
from blob import Entry_blob
class Entry_intel_mrc(Entry_blob):
- def __init__(self, image, etype, node):
- Entry_blob.__init__(self, image, etype, node)
+ def __init__(self, section, etype, node):
+ Entry_blob.__init__(self, section, etype, node)
def GetDefaultFilename(self):
return 'mrc.bin'
diff --git a/tools/binman/etype/intel_vbt.py b/tools/binman/etype/intel_vbt.py
index 4f082c3..d4e8c3f 100644
--- a/tools/binman/etype/intel_vbt.py
+++ b/tools/binman/etype/intel_vbt.py
@@ -8,5 +8,5 @@
from blob import Entry_blob
class Entry_intel_vbt(Entry_blob):
- def __init__(self, image, etype, node):
- Entry_blob.__init__(self, image, etype, node)
+ def __init__(self, section, etype, node):
+ Entry_blob.__init__(self, section, etype, node)
diff --git a/tools/binman/etype/intel_vga.py b/tools/binman/etype/intel_vga.py
index 277fff1..140dd40 100644
--- a/tools/binman/etype/intel_vga.py
+++ b/tools/binman/etype/intel_vga.py
@@ -9,5 +9,5 @@
from blob import Entry_blob
class Entry_intel_vga(Entry_blob):
- def __init__(self, image, etype, node):
- Entry_blob.__init__(self, image, etype, node)
+ def __init__(self, section, etype, node):
+ Entry_blob.__init__(self, section, etype, node)
diff --git a/tools/binman/etype/section.py b/tools/binman/etype/section.py
new file mode 100644
index 0000000..139fcad
--- /dev/null
+++ b/tools/binman/etype/section.py
@@ -0,0 +1,59 @@
+# SPDX-License-Identifier: GPL-2.0+
+# Copyright (c) 2018 Google, Inc
+# Written by Simon Glass <sjg@chromium.org>
+#
+# Entry-type module for sections, which are entries which can contain other
+# entries.
+#
+
+from entry import Entry
+import fdt_util
+import tools
+
+import bsection
+
+class Entry_section(Entry):
+ def __init__(self, image, etype, node):
+ Entry.__init__(self, image, etype, node)
+ self._section = bsection.Section(node.name, node)
+
+ def ObtainContents(self):
+ self._section.GetEntryContents()
+
+ def GetData(self):
+ return self._section.GetData()
+
+ def GetPositions(self):
+ """Handle entries that want to set the position/size of other entries
+
+ This calls each entry's GetPositions() method. If it returns a list
+ of entries to update, it updates them.
+ """
+ self._section.GetEntryPositions()
+ return {}
+
+ def Pack(self, pos):
+ """Pack all entries into the section"""
+ self._section.PackEntries()
+ self.size = self._section.CheckSize()
+ return super(Entry_section, self).Pack(pos)
+
+ def WriteSymbols(self, section):
+ """Write symbol values into binary files for access at run time"""
+ self._section.WriteSymbols()
+
+ def ProcessContents(self):
+ self._section.ProcessEntryContents()
+ super(Entry_section, self).ProcessContents()
+
+ def CheckPosition(self):
+ self._section.CheckEntries()
+
+ def WriteMap(self, fd, indent):
+ """Write a map of the section to a .map file
+
+ Args:
+ fd: File to write the map to
+ """
+ super(Entry_section, self).WriteMap(fd, indent)
+ self._section.WriteMap(fd, indent + 1)
diff --git a/tools/binman/etype/u_boot.py b/tools/binman/etype/u_boot.py
index fc212d0..b6058bf 100644
--- a/tools/binman/etype/u_boot.py
+++ b/tools/binman/etype/u_boot.py
@@ -9,8 +9,8 @@
from blob import Entry_blob
class Entry_u_boot(Entry_blob):
- def __init__(self, image, etype, node):
- Entry_blob.__init__(self, image, etype, node)
+ def __init__(self, section, etype, node):
+ Entry_blob.__init__(self, section, etype, node)
def GetDefaultFilename(self):
return 'u-boot.bin'
diff --git a/tools/binman/etype/u_boot_dtb.py b/tools/binman/etype/u_boot_dtb.py
index f6704db..dd3c5b2 100644
--- a/tools/binman/etype/u_boot_dtb.py
+++ b/tools/binman/etype/u_boot_dtb.py
@@ -9,8 +9,8 @@
from blob import Entry_blob
class Entry_u_boot_dtb(Entry_blob):
- def __init__(self, image, etype, node):
- Entry_blob.__init__(self, image, etype, node)
+ def __init__(self, section, etype, node):
+ Entry_blob.__init__(self, section, etype, node)
def GetDefaultFilename(self):
return 'u-boot.dtb'
diff --git a/tools/binman/etype/u_boot_dtb_with_ucode.py b/tools/binman/etype/u_boot_dtb_with_ucode.py
index bedc398..1e530d6 100644
--- a/tools/binman/etype/u_boot_dtb_with_ucode.py
+++ b/tools/binman/etype/u_boot_dtb_with_ucode.py
@@ -16,8 +16,8 @@
See Entry_u_boot_ucode for full details of the 3 entries involved in this
process.
"""
- def __init__(self, image, etype, node):
- Entry_blob.__init__(self, image, etype, node)
+ def __init__(self, section, etype, node):
+ Entry_blob.__init__(self, section, etype, node)
self.ucode_data = ''
self.collate = False
self.ucode_offset = None
@@ -29,10 +29,12 @@
def ObtainContents(self):
Entry_blob.ObtainContents(self)
- # If the image does not need microcode, there is nothing to do
- ucode_dest_entry = self.image.FindEntryType('u-boot-spl-with-ucode-ptr')
+ # If the section does not need microcode, there is nothing to do
+ ucode_dest_entry = self.section.FindEntryType(
+ 'u-boot-spl-with-ucode-ptr')
if not ucode_dest_entry or not ucode_dest_entry.target_pos:
- ucode_dest_entry = self.image.FindEntryType('u-boot-with-ucode-ptr')
+ ucode_dest_entry = self.section.FindEntryType(
+ 'u-boot-with-ucode-ptr')
if not ucode_dest_entry or not ucode_dest_entry.target_pos:
return True
diff --git a/tools/binman/etype/u_boot_img.py b/tools/binman/etype/u_boot_img.py
index d5f1eb3..6e0b736 100644
--- a/tools/binman/etype/u_boot_img.py
+++ b/tools/binman/etype/u_boot_img.py
@@ -9,8 +9,8 @@
from blob import Entry_blob
class Entry_u_boot_img(Entry_blob):
- def __init__(self, image, etype, node):
- Entry_blob.__init__(self, image, etype, node)
+ def __init__(self, section, etype, node):
+ Entry_blob.__init__(self, section, etype, node)
def GetDefaultFilename(self):
return 'u-boot.img'
diff --git a/tools/binman/etype/u_boot_nodtb.py b/tools/binman/etype/u_boot_nodtb.py
index 183b897..ca9e53a 100644
--- a/tools/binman/etype/u_boot_nodtb.py
+++ b/tools/binman/etype/u_boot_nodtb.py
@@ -9,8 +9,8 @@
from blob import Entry_blob
class Entry_u_boot_nodtb(Entry_blob):
- def __init__(self, image, etype, node):
- Entry_blob.__init__(self, image, etype, node)
+ def __init__(self, section, etype, node):
+ Entry_blob.__init__(self, section, etype, node)
def GetDefaultFilename(self):
return 'u-boot-nodtb.bin'
diff --git a/tools/binman/etype/u_boot_spl.py b/tools/binman/etype/u_boot_spl.py
index 6a1c123..9edd2da 100644
--- a/tools/binman/etype/u_boot_spl.py
+++ b/tools/binman/etype/u_boot_spl.py
@@ -11,12 +11,12 @@
from blob import Entry_blob
class Entry_u_boot_spl(Entry_blob):
- def __init__(self, image, etype, node):
- Entry_blob.__init__(self, image, etype, node)
+ def __init__(self, section, etype, node):
+ Entry_blob.__init__(self, section, etype, node)
self.elf_fname = 'spl/u-boot-spl'
def GetDefaultFilename(self):
return 'spl/u-boot-spl.bin'
- def WriteSymbols(self, image):
- elf.LookupAndWriteSymbols(self.elf_fname, self, image)
+ def WriteSymbols(self, section):
+ elf.LookupAndWriteSymbols(self.elf_fname, self, section)
diff --git a/tools/binman/etype/u_boot_spl_bss_pad.py b/tools/binman/etype/u_boot_spl_bss_pad.py
index d14122b..3d2dea2 100644
--- a/tools/binman/etype/u_boot_spl_bss_pad.py
+++ b/tools/binman/etype/u_boot_spl_bss_pad.py
@@ -14,8 +14,8 @@
import tools
class Entry_u_boot_spl_bss_pad(Entry_blob):
- def __init__(self, image, etype, node):
- Entry_blob.__init__(self, image, etype, node)
+ def __init__(self, section, etype, node):
+ Entry_blob.__init__(self, section, etype, node)
def ObtainContents(self):
fname = tools.GetInputFilename('spl/u-boot-spl')
diff --git a/tools/binman/etype/u_boot_spl_dtb.py b/tools/binman/etype/u_boot_spl_dtb.py
index 43d2377..eefa1ff 100644
--- a/tools/binman/etype/u_boot_spl_dtb.py
+++ b/tools/binman/etype/u_boot_spl_dtb.py
@@ -9,8 +9,8 @@
from blob import Entry_blob
class Entry_u_boot_spl_dtb(Entry_blob):
- def __init__(self, image, etype, node):
- Entry_blob.__init__(self, image, etype, node)
+ def __init__(self, section, etype, node):
+ Entry_blob.__init__(self, section, etype, node)
def GetDefaultFilename(self):
return 'spl/u-boot-spl.dtb'
diff --git a/tools/binman/etype/u_boot_spl_nodtb.py b/tools/binman/etype/u_boot_spl_nodtb.py
index 5b058b4..99e56eb 100644
--- a/tools/binman/etype/u_boot_spl_nodtb.py
+++ b/tools/binman/etype/u_boot_spl_nodtb.py
@@ -9,8 +9,8 @@
from blob import Entry_blob
class Entry_u_boot_spl_nodtb(Entry_blob):
- def __init__(self, image, etype, node):
- Entry_blob.__init__(self, image, etype, node)
+ def __init__(self, section, etype, node):
+ Entry_blob.__init__(self, section, etype, node)
def GetDefaultFilename(self):
return 'spl/u-boot-spl-nodtb.bin'
diff --git a/tools/binman/etype/u_boot_spl_with_ucode_ptr.py b/tools/binman/etype/u_boot_spl_with_ucode_ptr.py
index 1e3181a..0dfe268 100644
--- a/tools/binman/etype/u_boot_spl_with_ucode_ptr.py
+++ b/tools/binman/etype/u_boot_spl_with_ucode_ptr.py
@@ -19,8 +19,8 @@
See Entry_u_boot_ucode for full details of the entries involved in this
process.
"""
- def __init__(self, image, etype, node):
- Entry_u_boot_with_ucode_ptr.__init__(self, image, etype, node)
+ def __init__(self, section, etype, node):
+ Entry_u_boot_with_ucode_ptr.__init__(self, section, etype, node)
self.elf_fname = 'spl/u-boot-spl'
def GetDefaultFilename(self):
diff --git a/tools/binman/etype/u_boot_ucode.py b/tools/binman/etype/u_boot_ucode.py
index 10130a2..3a0cff7 100644
--- a/tools/binman/etype/u_boot_ucode.py
+++ b/tools/binman/etype/u_boot_ucode.py
@@ -51,13 +51,13 @@
the Entry_u_boot_dtb_with_ucode entry, and uses it as the
contents of this entry.
"""
- def __init__(self, image, etype, node):
- Entry_blob.__init__(self, image, etype, node)
+ def __init__(self, section, etype, node):
+ Entry_blob.__init__(self, section, etype, node)
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')
- ucode_dest_entry_spl = self.image.FindEntryType(
+ # If the section does not need microcode, there is nothing to do
+ ucode_dest_entry = self.section.FindEntryType('u-boot-with-ucode-ptr')
+ ucode_dest_entry_spl = self.section.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)):
@@ -65,12 +65,12 @@
return True
# Get the microcode from the device tree entry
- fdt_entry = self.image.FindEntryType('u-boot-dtb-with-ucode')
+ fdt_entry = self.section.FindEntryType('u-boot-dtb-with-ucode')
if not fdt_entry or not fdt_entry.ucode_data:
return False
if not fdt_entry.collate:
- # This section can be empty
+ # This binary can be empty
self.data = ''
return True
diff --git a/tools/binman/etype/u_boot_with_ucode_ptr.py b/tools/binman/etype/u_boot_with_ucode_ptr.py
index 04b9f7c..41c2ded 100644
--- a/tools/binman/etype/u_boot_with_ucode_ptr.py
+++ b/tools/binman/etype/u_boot_with_ucode_ptr.py
@@ -20,8 +20,8 @@
See Entry_u_boot_ucode for full details of the 3 entries involved in this
process.
"""
- def __init__(self, image, etype, node):
- Entry_blob.__init__(self, image, etype, node)
+ def __init__(self, section, etype, node):
+ Entry_blob.__init__(self, section, etype, node)
self.elf_fname = 'u-boot'
self.target_pos = None
@@ -45,24 +45,24 @@
return
# Get the position of the microcode
- ucode_entry = self.image.FindEntryType('u-boot-ucode')
+ ucode_entry = self.section.FindEntryType('u-boot-ucode')
if not ucode_entry:
self.Raise('Cannot find microcode region u-boot-ucode')
- # Check the target pos is in the image. If it is not, then U-Boot is
+ # Check the target pos is in the section. If it is not, then U-Boot is
# being linked incorrectly, or is being placed at the wrong position
- # in the image.
+ # in the section.
#
- # The image must be set up so that U-Boot is placed at the
+ # The section must be set up so that U-Boot is placed at the
# flash address to which it is linked. For example, if
# CONFIG_SYS_TEXT_BASE is 0xfff00000, and the ROM is 8MB, then
- # the U-Boot region must start at position 7MB in the image. In this
+ # the U-Boot region must start at position 7MB in the section. In this
# case the ROM starts at 0xff800000, so the position of the first
- # entry in the image corresponds to that.
+ # entry in the section corresponds to that.
if (self.target_pos < self.pos or
self.target_pos >= self.pos + self.size):
self.Raise('Microcode pointer _dt_ucode_base_size at %08x is '
- 'outside the image ranging from %08x to %08x' %
+ 'outside the section ranging from %08x to %08x' %
(self.target_pos, self.pos, self.pos + self.size))
# Get the microcode, either from u-boot-ucode or u-boot-dtb-with-ucode.
@@ -72,7 +72,7 @@
if ucode_entry.size:
pos, size = ucode_entry.pos, ucode_entry.size
else:
- dtb_entry = self.image.FindEntryType('u-boot-dtb-with-ucode')
+ dtb_entry = self.section.FindEntryType('u-boot-dtb-with-ucode')
if not dtb_entry:
self.Raise('Cannot find microcode region u-boot-dtb-with-ucode')
pos = dtb_entry.pos + dtb_entry.ucode_offset
diff --git a/tools/binman/etype/x86_start16.py b/tools/binman/etype/x86_start16.py
index 01e5b8b..23d27f0 100644
--- a/tools/binman/etype/x86_start16.py
+++ b/tools/binman/etype/x86_start16.py
@@ -9,8 +9,8 @@
from blob import Entry_blob
class Entry_x86_start16(Entry_blob):
- def __init__(self, image, etype, node):
- Entry_blob.__init__(self, image, etype, node)
+ def __init__(self, section, etype, node):
+ Entry_blob.__init__(self, section, etype, node)
def GetDefaultFilename(self):
return 'u-boot-x86-16bit.bin'
diff --git a/tools/binman/etype/x86_start16_spl.py b/tools/binman/etype/x86_start16_spl.py
index f0abbf0..176420b 100644
--- a/tools/binman/etype/x86_start16_spl.py
+++ b/tools/binman/etype/x86_start16_spl.py
@@ -9,8 +9,8 @@
from blob import Entry_blob
class Entry_x86_start16_spl(Entry_blob):
- def __init__(self, image, etype, node):
- Entry_blob.__init__(self, image, etype, node)
+ def __init__(self, section, etype, node):
+ Entry_blob.__init__(self, section, etype, node)
def GetDefaultFilename(self):
return 'spl/u-boot-x86-16bit-spl.bin'
diff --git a/tools/binman/ftest.py b/tools/binman/ftest.py
index a3abbc4b..eb8a079 100644
--- a/tools/binman/ftest.py
+++ b/tools/binman/ftest.py
@@ -146,15 +146,19 @@
# 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'):
@@ -165,10 +169,10 @@
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)
@@ -179,7 +183,7 @@
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
@@ -189,16 +193,18 @@
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
@@ -206,22 +212,36 @@
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
@@ -270,13 +290,13 @@
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]
@@ -326,7 +346,7 @@
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.
@@ -334,7 +354,7 @@
'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).
@@ -413,7 +433,7 @@
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
@@ -456,7 +476,7 @@
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
@@ -540,7 +560,7 @@
"""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):
@@ -563,14 +583,14 @@
"""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):
@@ -620,7 +640,7 @@
"""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):
@@ -628,7 +648,7 @@
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):
@@ -800,13 +820,13 @@
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)])
@@ -823,7 +843,7 @@
"""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):
@@ -909,6 +929,36 @@
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)
if __name__ == "__main__":
unittest.main()
diff --git a/tools/binman/image.py b/tools/binman/image.py
index b10b188..835b66c 100644
--- a/tools/binman/image.py
+++ b/tools/binman/image.py
@@ -13,6 +13,7 @@
import sys
import fdt_util
+import bsection
import tools
class Image:
@@ -27,158 +28,36 @@
_node: Node object that contains the image definition in device tree
_name: Image name
_size: Image size in bytes, or None if not known yet
- _align_size: Image size alignment, or None
- _pad_before: Number of bytes before the first entry starts. This
- effectively changes the place where entry position 0 starts
- _pad_after: Number of bytes after the last entry ends. The last
- entry will finish on or before this boundary
- _pad_byte: Byte to use to pad the image where there is no entry
_filename: Output filename for image
- _sort: True if entries should be sorted by position, False if they
- must be in-order in the device tree description
- _skip_at_start: Number of bytes before the first entry starts. These
- effecively adjust the starting position of entries. For example,
- if _pad_before is 16, then the first entry would start at 16.
- An entry with pos = 20 would in fact be written at position 4
- in the image file.
- _end_4gb: Indicates that the image ends at the 4GB boundary. This is
- used for x86 images, which want to use positions such that a
- memory address (like 0xff800000) is the first entry position.
- This causes _skip_at_start to be set to the starting memory
- address.
- _entries: OrderedDict() of entries
+ _sections: Sections present in this image (may be one or more)
+
+ Args:
+ test: True if this is being called from a test of Images. This this case
+ there is no device tree defining the structure of the section, so
+ we create a section manually.
"""
def __init__(self, name, node, test=False):
- global entry
- global Entry
- import entry
- from entry import Entry
-
self._node = node
self._name = name
self._size = None
- self._align_size = None
- self._pad_before = 0
- self._pad_after = 0
- self._pad_byte = 0
self._filename = '%s.bin' % self._name
- self._sort = False
- self._skip_at_start = 0
- self._end_4gb = False
- self._entries = OrderedDict()
-
- if not test:
+ if test:
+ self._section = bsection.Section('main-section', self._node, True)
+ else:
self._ReadNode()
- self._ReadEntries()
def _ReadNode(self):
"""Read properties from the image node"""
self._size = fdt_util.GetInt(self._node, 'size')
- self._align_size = fdt_util.GetInt(self._node, 'align-size')
- if tools.NotPowerOfTwo(self._align_size):
- self._Raise("Alignment size %s must be a power of two" %
- self._align_size)
- self._pad_before = fdt_util.GetInt(self._node, 'pad-before', 0)
- self._pad_after = fdt_util.GetInt(self._node, 'pad-after', 0)
- self._pad_byte = fdt_util.GetInt(self._node, 'pad-byte', 0)
filename = fdt_util.GetString(self._node, 'filename')
if filename:
self._filename = filename
- self._sort = fdt_util.GetBool(self._node, 'sort-by-pos')
- self._end_4gb = fdt_util.GetBool(self._node, 'end-at-4gb')
- if self._end_4gb and not self._size:
- self._Raise("Image size must be provided when using end-at-4gb")
- if self._end_4gb:
- self._skip_at_start = 0x100000000 - self._size
-
- def CheckSize(self):
- """Check that the image contents does not exceed its size, etc."""
- contents_size = 0
- for entry in self._entries.values():
- contents_size = max(contents_size, entry.pos + entry.size)
-
- contents_size -= self._skip_at_start
-
- size = self._size
- if not size:
- size = self._pad_before + contents_size + self._pad_after
- size = tools.Align(size, self._align_size)
-
- if self._size and contents_size > self._size:
- self._Raise("contents size %#x (%d) exceeds image size %#x (%d)" %
- (contents_size, contents_size, self._size, self._size))
- if not self._size:
- self._size = size
- if self._size != tools.Align(self._size, self._align_size):
- self._Raise("Size %#x (%d) does not match align-size %#x (%d)" %
- (self._size, self._size, self._align_size, self._align_size))
-
- def _Raise(self, msg):
- """Raises an error for this image
-
- Args:
- msg: Error message to use in the raise string
- Raises:
- ValueError()
- """
- raise ValueError("Image '%s': %s" % (self._node.path, msg))
-
- def GetPath(self):
- """Get the path of an image (in the FDT)
-
- Returns:
- Full path of the node for this image
- """
- return self._node.path
-
- def _ReadEntries(self):
- for node in self._node.subnodes:
- self._entries[node.name] = Entry.Create(self, node)
-
- def FindEntryType(self, etype):
- """Find an entry type in the image
-
- Args:
- etype: Entry type to find
- Returns:
- entry matching that type, or None if not found
- """
- for entry in self._entries.values():
- if entry.etype == etype:
- return entry
- return None
+ self._section = bsection.Section('main-section', self._node)
def GetEntryContents(self):
- """Call ObtainContents() for each entry
-
- This calls each entry's ObtainContents() a few times until they all
- return True. We stop calling an entry's function once it returns
- True. This allows the contents of one entry to depend on another.
-
- After 3 rounds we give up since it's likely an error.
+ """Call ObtainContents() for the section
"""
- todo = self._entries.values()
- for passnum in range(3):
- next_todo = []
- for entry in todo:
- if not entry.ObtainContents():
- next_todo.append(entry)
- todo = next_todo
- if not todo:
- break
-
- def _SetEntryPosSize(self, name, pos, size):
- """Set the position and size of an entry
-
- Args:
- name: Entry name to update
- pos: New position
- size: New size
- """
- entry = self._entries.get(name)
- if not entry:
- self._Raise("Unable to set pos/size for unknown entry '%s'" % name)
- entry.SetPositionSize(self._skip_at_start + pos, size)
+ self._section.GetEntryContents()
def GetEntryPositions(self):
"""Handle entries that want to set the position/size of other entries
@@ -186,119 +65,44 @@
This calls each entry's GetPositions() method. If it returns a list
of entries to update, it updates them.
"""
- for entry in self._entries.values():
- pos_dict = entry.GetPositions()
- for name, info in pos_dict.iteritems():
- self._SetEntryPosSize(name, *info)
+ self._section.GetEntryPositions()
def PackEntries(self):
"""Pack all entries into the image"""
- pos = self._skip_at_start
- for entry in self._entries.values():
- pos = entry.Pack(pos)
+ self._section.PackEntries()
- def _SortEntries(self):
- """Sort entries by position"""
- entries = sorted(self._entries.values(), key=lambda entry: entry.pos)
- self._entries.clear()
- for entry in entries:
- self._entries[entry._node.name] = entry
+ def CheckSize(self):
+ """Check that the image contents does not exceed its size, etc."""
+ self._size = self._section.CheckSize()
def CheckEntries(self):
"""Check that entries do not overlap or extend outside the image"""
- if self._sort:
- self._SortEntries()
- pos = 0
- prev_name = 'None'
- for entry in self._entries.values():
- if (entry.pos < self._skip_at_start or
- entry.pos >= self._skip_at_start + self._size):
- entry.Raise("Position %#x (%d) is outside the image starting "
- "at %#x (%d)" %
- (entry.pos, entry.pos, self._skip_at_start,
- self._skip_at_start))
- if entry.pos < pos:
- entry.Raise("Position %#x (%d) overlaps with previous entry '%s' "
- "ending at %#x (%d)" %
- (entry.pos, entry.pos, prev_name, pos, pos))
- pos = entry.pos + entry.size
- prev_name = entry.GetPath()
+ self._section.CheckEntries()
def ProcessEntryContents(self):
"""Call the ProcessContents() method for each entry
This is intended to adjust the contents as needed by the entry type.
"""
- for entry in self._entries.values():
- entry.ProcessContents()
+ self._section.ProcessEntryContents()
def WriteSymbols(self):
"""Write symbol values into binary files for access at run time"""
- for entry in self._entries.values():
- entry.WriteSymbols(self)
+ self._section.WriteSymbols()
def BuildImage(self):
"""Write the image to a file"""
fname = tools.GetOutputFilename(self._filename)
with open(fname, 'wb') as fd:
- fd.write(chr(self._pad_byte) * self._size)
+ self._section.BuildSection(fd, 0)
- for entry in self._entries.values():
- data = entry.GetData()
- fd.seek(self._pad_before + entry.pos - self._skip_at_start)
- fd.write(data)
+ def GetEntries(self):
+ return self._section.GetEntries()
- def LookupSymbol(self, sym_name, optional, msg):
- """Look up a symbol in an ELF file
-
- Looks up a symbol in an ELF file. Only entry types which come from an
- ELF image can be used by this function.
-
- At present the only entry property supported is pos.
-
- Args:
- sym_name: Symbol name in the ELF file to look up in the format
- _binman_<entry>_prop_<property> where <entry> is the name of
- the entry and <property> is the property to find (e.g.
- _binman_u_boot_prop_pos). As a special case, you can append
- _any to <entry> to have it search for any matching entry. E.g.
- _binman_u_boot_any_prop_pos will match entries called u-boot,
- u-boot-img and u-boot-nodtb)
- optional: True if the symbol is optional. If False this function
- will raise if the symbol is not found
- msg: Message to display if an error occurs
-
- Returns:
- Value that should be assigned to that symbol, or None if it was
- optional and not found
-
- Raises:
- ValueError if the symbol is invalid or not found, or references a
- property which is not supported
- """
- m = re.match(r'^_binman_(\w+)_prop_(\w+)$', sym_name)
- if not m:
- raise ValueError("%s: Symbol '%s' has invalid format" %
- (msg, sym_name))
- entry_name, prop_name = m.groups()
- entry_name = entry_name.replace('_', '-')
- entry = self._entries.get(entry_name)
- if not entry:
- if entry_name.endswith('-any'):
- root = entry_name[:-4]
- for name in self._entries:
- if name.startswith(root):
- rest = name[len(root):]
- if rest in ['', '-img', '-nodtb']:
- entry = self._entries[name]
- if not entry:
- err = ("%s: Entry '%s' not found in list (%s)" %
- (msg, entry_name, ','.join(self._entries.keys())))
- if optional:
- print('Warning: %s' % err, file=sys.stderr)
- return None
- raise ValueError(err)
- if prop_name == 'pos':
- return entry.pos
- else:
- raise ValueError("%s: No such property '%s'" % (msg, prop_name))
+ def WriteMap(self):
+ """Write a map of the image to a .map file"""
+ filename = '%s.map' % self._name
+ fname = tools.GetOutputFilename(filename)
+ with open(fname, 'w') as fd:
+ print('%8s %8s %s' % ('Position', 'Size', 'Name'), file=fd)
+ self._section.WriteMap(fd, 0)
diff --git a/tools/binman/image_test.py b/tools/binman/image_test.py
index 44a5a2c..45dd237 100644
--- a/tools/binman/image_test.py
+++ b/tools/binman/image_test.py
@@ -12,25 +12,28 @@
class TestImage(unittest.TestCase):
def testInvalidFormat(self):
image = Image('name', 'node', test=True)
+ section = image._section
with self.assertRaises(ValueError) as e:
- image.LookupSymbol('_binman_something_prop_', False, 'msg')
+ section.LookupSymbol('_binman_something_prop_', False, 'msg')
self.assertIn(
"msg: Symbol '_binman_something_prop_' has invalid format",
str(e.exception))
def testMissingSymbol(self):
image = Image('name', 'node', test=True)
- image._entries = {}
+ section = image._section
+ section._entries = {}
with self.assertRaises(ValueError) as e:
- image.LookupSymbol('_binman_type_prop_pname', False, 'msg')
+ section.LookupSymbol('_binman_type_prop_pname', False, 'msg')
self.assertIn("msg: Entry 'type' not found in list ()",
str(e.exception))
def testMissingSymbolOptional(self):
image = Image('name', 'node', test=True)
- image._entries = {}
+ section = image._section
+ section._entries = {}
with capture_sys_output() as (stdout, stderr):
- val = image.LookupSymbol('_binman_type_prop_pname', True, 'msg')
+ val = section.LookupSymbol('_binman_type_prop_pname', True, 'msg')
self.assertEqual(val, None)
self.assertEqual("Warning: msg: Entry 'type' not found in list ()\n",
stderr.getvalue())
@@ -38,7 +41,8 @@
def testBadProperty(self):
image = Image('name', 'node', test=True)
- image._entries = {'u-boot': 1}
+ section = image._section
+ section._entries = {'u-boot': 1}
with self.assertRaises(ValueError) as e:
- image.LookupSymbol('_binman_u_boot_prop_bad', False, 'msg')
+ section.LookupSymbol('_binman_u_boot_prop_bad', False, 'msg')
self.assertIn("msg: No such property 'bad", str(e.exception))
diff --git a/tools/binman/test/54_unit_address.dts b/tools/binman/test/54_unit_address.dts
new file mode 100644
index 0000000..3216dbb
--- /dev/null
+++ b/tools/binman/test/54_unit_address.dts
@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: GPL-2.0+
+
+/dts-v1/;
+
+/ {
+ #address-cells = <1>;
+ #size-cells = <1>;
+
+ binman {
+ u-boot@0 {
+ };
+ u-boot@1 {
+ };
+ };
+};
diff --git a/tools/binman/test/55_sections.dts b/tools/binman/test/55_sections.dts
new file mode 100644
index 0000000..2ada395
--- /dev/null
+++ b/tools/binman/test/55_sections.dts
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: GPL-2.0+
+
+/dts-v1/;
+
+/ {
+ #address-cells = <1>;
+ #size-cells = <1>;
+
+ binman {
+ pad-byte = <0x26>;
+ size = <0x28>;
+ section@0 {
+ read-only;
+ size = <0x10>;
+ pad-byte = <0x21>;
+
+ u-boot {
+ };
+ };
+ section@1 {
+ size = <0x10>;
+ pad-byte = <0x61>;
+
+ u-boot {
+ };
+ };
+ };
+};
diff --git a/tools/binman/test/56_name_prefix.dts b/tools/binman/test/56_name_prefix.dts
new file mode 100644
index 0000000..f38c80e
--- /dev/null
+++ b/tools/binman/test/56_name_prefix.dts
@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: GPL-2.0+
+
+/dts-v1/;
+
+/ {
+ #address-cells = <1>;
+ #size-cells = <1>;
+
+ binman {
+ pad-byte = <0x26>;
+ size = <0x28>;
+ section@0 {
+ read-only;
+ name-prefix = "ro-";
+ size = <0x10>;
+ pad-byte = <0x21>;
+
+ u-boot {
+ };
+ };
+ section@1 {
+ name-prefix = "rw-";
+ size = <0x10>;
+ pad-byte = <0x61>;
+
+ u-boot {
+ };
+ };
+ };
+};
diff --git a/tools/buildman/README b/tools/buildman/README
index 6c43c54..7660190 100644
--- a/tools/buildman/README
+++ b/tools/buildman/README
@@ -1008,6 +1008,34 @@
option to Kconfig. To disable this behaviour, use --squash-config-y.
+Checking the environment
+========================
+
+When converting CONFIG options which manipulate the default environment,
+a common requirement is to check that the default environment has not
+changed due to the conversion. Buildman supports this with the -U option,
+used after a build. This shows differences in the default environment
+between one commit and the next.
+
+For example:
+
+$ buildman -b squash brppt1 -sU
+boards.cfg is up to date. Nothing to do.
+Summary of 2 commits for 3 boards (3 threads, 3 jobs per thread)
+01: Migrate bootlimit to Kconfig
+02: Squashed commit of the following:
+ c brppt1_mmc: altbootcmd=mmc dev 1; run mmcboot0; -> mmc dev 1; run mmcboot0
+ c brppt1_spi: altbootcmd=mmc dev 1; run mmcboot0; -> mmc dev 1; run mmcboot0
+ + brppt1_nand: altbootcmd=run usbscript
+ - brppt1_nand: altbootcmd=run usbscript
+(no errors to report)
+
+This shows that commit 2 modified the value of 'altbootcmd' for 'brppt1_mmc'
+and 'brppt1_spi', removing a trailing semicolon. 'brppt1_nand' gained an a
+value for 'altbootcmd', but lost one for ' altbootcmd'.
+
+The -U option uses the u-boot.env files which are produced by a build.
+
Other options
=============
diff --git a/tools/buildman/builder.py b/tools/buildman/builder.py
index 2ccdee0..a5a2ffd 100644
--- a/tools/buildman/builder.py
+++ b/tools/buildman/builder.py
@@ -127,6 +127,15 @@
val = val ^ hash(key) & hash(value)
return val
+class Environment:
+ """Holds information about environment variables for a board."""
+ def __init__(self, target):
+ self.target = target
+ self.environment = {}
+
+ def Add(self, key, value):
+ self.environment[key] = value
+
class Builder:
"""Class for building U-Boot for a particular commit.
@@ -199,13 +208,17 @@
value is itself a dictionary:
key: config name
value: config value
+ environment: Dictionary keyed by environment variable, Each
+ value is the value of environment variable.
"""
- def __init__(self, rc, err_lines, sizes, func_sizes, config):
+ def __init__(self, rc, err_lines, sizes, func_sizes, config,
+ environment):
self.rc = rc
self.err_lines = err_lines
self.sizes = sizes
self.func_sizes = func_sizes
self.config = config
+ self.environment = environment
def __init__(self, toolchains, base_dir, git_dir, num_threads, num_jobs,
gnu_make='make', checkout=True, show_unknown=True, step=1,
@@ -310,7 +323,8 @@
def SetDisplayOptions(self, show_errors=False, show_sizes=False,
show_detail=False, show_bloat=False,
- list_error_boards=False, show_config=False):
+ list_error_boards=False, show_config=False,
+ show_environment=False):
"""Setup display options for the builder.
show_errors: True to show summarised error/warning info
@@ -319,6 +333,7 @@
show_bloat: Show detail for each function
list_error_boards: Show the boards which caused each error/warning
show_config: Show config deltas
+ show_environment: Show environment deltas
"""
self._show_errors = show_errors
self._show_sizes = show_sizes
@@ -326,6 +341,7 @@
self._show_bloat = show_bloat
self._list_error_boards = list_error_boards
self._show_config = show_config
+ self._show_environment = show_environment
def _AddTimestamp(self):
"""Add a new timestamp to the list and record the build period.
@@ -609,8 +625,33 @@
config[key] = value
return config
+ def _ProcessEnvironment(self, fname):
+ """Read in a uboot.env file
+
+ This function reads in environment variables from a file.
+
+ Args:
+ fname: Filename to read
+
+ Returns:
+ Dictionary:
+ key: environment variable (e.g. bootlimit)
+ value: value of environment variable (e.g. 1)
+ """
+ environment = {}
+ if os.path.exists(fname):
+ with open(fname) as fd:
+ for line in fd.read().split('\0'):
+ try:
+ key, value = line.split('=', 1)
+ environment[key] = value
+ except ValueError:
+ # ignore lines we can't parse
+ pass
+ return environment
+
def GetBuildOutcome(self, commit_upto, target, read_func_sizes,
- read_config):
+ read_config, read_environment):
"""Work out the outcome of a build.
Args:
@@ -618,6 +659,7 @@
target: Target board to check
read_func_sizes: True to read function size information
read_config: True to read .config and autoconf.h files
+ read_environment: True to read uboot.env files
Returns:
Outcome object
@@ -627,6 +669,7 @@
sizes = {}
func_sizes = {}
config = {}
+ environment = {}
if os.path.exists(done_file):
with open(done_file, 'r') as fd:
return_code = int(fd.readline())
@@ -676,12 +719,18 @@
fname = os.path.join(output_dir, name)
config[name] = self._ProcessConfig(fname)
- return Builder.Outcome(rc, err_lines, sizes, func_sizes, config)
+ if read_environment:
+ output_dir = self.GetBuildDir(commit_upto, target)
+ fname = os.path.join(output_dir, 'uboot.env')
+ environment = self._ProcessEnvironment(fname)
- return Builder.Outcome(OUTCOME_UNKNOWN, [], {}, {}, {})
+ return Builder.Outcome(rc, err_lines, sizes, func_sizes, config,
+ environment)
+
+ return Builder.Outcome(OUTCOME_UNKNOWN, [], {}, {}, {}, {})
def GetResultSummary(self, boards_selected, commit_upto, read_func_sizes,
- read_config):
+ read_config, read_environment):
"""Calculate a summary of the results of building a commit.
Args:
@@ -689,6 +738,7 @@
commit_upto: Commit number to summarize (0..self.count-1)
read_func_sizes: True to read function size information
read_config: True to read .config and autoconf.h files
+ read_environment: True to read uboot.env files
Returns:
Tuple:
@@ -705,6 +755,9 @@
value is itself a dictionary:
key: config name
value: config value
+ Dictionary keyed by board.target. Each value is a dictionary:
+ key: environment variable
+ value: value of environment variable
"""
def AddLine(lines_summary, lines_boards, line, board):
line = line.rstrip()
@@ -720,10 +773,12 @@
warn_lines_summary = []
warn_lines_boards = {}
config = {}
+ environment = {}
for board in boards_selected.itervalues():
outcome = self.GetBuildOutcome(commit_upto, board.target,
- read_func_sizes, read_config)
+ read_func_sizes, read_config,
+ read_environment)
board_dict[board.target] = outcome
last_func = None
last_was_warning = False
@@ -756,8 +811,14 @@
tconfig.Add(fname, key, value)
config[board.target] = tconfig
+ tenvironment = Environment(board.target)
+ if outcome.environment:
+ for key, value in outcome.environment.iteritems():
+ tenvironment.Add(key, value)
+ environment[board.target] = tenvironment
+
return (board_dict, err_lines_summary, err_lines_boards,
- warn_lines_summary, warn_lines_boards, config)
+ warn_lines_summary, warn_lines_boards, config, environment)
def AddOutcome(self, board_dict, arch_list, changes, char, color):
"""Add an output to our list of outcomes for each architecture
@@ -810,12 +871,14 @@
"""
self._base_board_dict = {}
for board in board_selected:
- self._base_board_dict[board] = Builder.Outcome(0, [], [], {}, {})
+ self._base_board_dict[board] = Builder.Outcome(0, [], [], {}, {},
+ {})
self._base_err_lines = []
self._base_warn_lines = []
self._base_err_line_boards = {}
self._base_warn_line_boards = {}
self._base_config = None
+ self._base_environment = None
def PrintFuncSizeDetail(self, fname, old, new):
grow, shrink, add, remove, up, down = 0, 0, 0, 0, 0, 0
@@ -1010,8 +1073,8 @@
def PrintResultSummary(self, board_selected, board_dict, err_lines,
err_line_boards, warn_lines, warn_line_boards,
- config, show_sizes, show_detail, show_bloat,
- show_config):
+ config, environment, show_sizes, show_detail,
+ show_bloat, show_config, show_environment):
"""Compare results with the base results and display delta.
Only boards mentioned in board_selected will be considered. This
@@ -1036,10 +1099,13 @@
value is itself a dictionary:
key: config name
value: config value
+ environment: Dictionary keyed by environment variable, Each
+ value is the value of environment variable.
show_sizes: Show image size deltas
show_detail: Show detail for each board
show_bloat: Show detail for each function
show_config: Show config changes
+ show_environment: Show environment changes
"""
def _BoardList(line, line_boards):
"""Helper function to get a line of boards containing a line
@@ -1188,6 +1254,36 @@
self.PrintSizeSummary(board_selected, board_dict, show_detail,
show_bloat)
+ if show_environment and self._base_environment:
+ lines = []
+
+ for target in board_dict:
+ if target not in board_selected:
+ continue
+
+ tbase = self._base_environment[target]
+ tenvironment = environment[target]
+ environment_plus = {}
+ environment_minus = {}
+ environment_change = {}
+ base = tbase.environment
+ for key, value in tenvironment.environment.iteritems():
+ if key not in base:
+ environment_plus[key] = value
+ for key, value in base.iteritems():
+ if key not in tenvironment.environment:
+ environment_minus[key] = value
+ for key, value in base.iteritems():
+ new_value = tenvironment.environment.get(key)
+ if new_value and value != new_value:
+ desc = '%s -> %s' % (value, new_value)
+ environment_change[key] = desc
+
+ _AddConfig(lines, target, environment_plus, environment_minus,
+ environment_change)
+
+ _OutputConfigInfo(lines)
+
if show_config and self._base_config:
summary = {}
arch_config_plus = {}
@@ -1294,6 +1390,7 @@
self._base_err_line_boards = err_line_boards
self._base_warn_line_boards = warn_line_boards
self._base_config = config
+ self._base_environment = environment
# Get a list of boards that did not get built, if needed
not_built = []
@@ -1306,10 +1403,11 @@
def ProduceResultSummary(self, commit_upto, commits, board_selected):
(board_dict, err_lines, err_line_boards, warn_lines,
- warn_line_boards, config) = self.GetResultSummary(
+ warn_line_boards, config, environment) = self.GetResultSummary(
board_selected, commit_upto,
read_func_sizes=self._show_bloat,
- read_config=self._show_config)
+ read_config=self._show_config,
+ read_environment=self._show_environment)
if commits:
msg = '%02d: %s' % (commit_upto + 1,
commits[commit_upto].subject)
@@ -1317,8 +1415,8 @@
self.PrintResultSummary(board_selected, board_dict,
err_lines if self._show_errors else [], err_line_boards,
warn_lines if self._show_errors else [], warn_line_boards,
- config, self._show_sizes, self._show_detail,
- self._show_bloat, self._show_config)
+ config, environment, self._show_sizes, self._show_detail,
+ self._show_bloat, self._show_config, self._show_environment)
def ShowSummary(self, commits, board_selected):
"""Show a build summary for U-Boot for a given board list.
diff --git a/tools/buildman/builderthread.py b/tools/buildman/builderthread.py
index 0efe80d..c84ba6a 100644
--- a/tools/buildman/builderthread.py
+++ b/tools/buildman/builderthread.py
@@ -351,6 +351,16 @@
lines.append(size_result.stdout.splitlines()[1] + ' ' +
rodata_size)
+ # Extract the environment from U-Boot and dump it out
+ cmd = ['%sobjcopy' % self.toolchain.cross, '-O', 'binary',
+ '-j', '.rodata.default_environment',
+ 'env/built-in.o', 'uboot.env']
+ command.RunPipe([cmd], capture=True,
+ capture_stderr=True, cwd=result.out_dir,
+ raise_on_error=False, env=env)
+ ubootenv = os.path.join(result.out_dir, 'uboot.env')
+ self.CopyFiles(result.out_dir, build_dir, '', ['uboot.env'])
+
# Write out the image sizes file. This is similar to the output
# of binutil's 'size' utility, but it omits the header line and
# adds an additional hex value at the end of each line for the
diff --git a/tools/buildman/cmdline.py b/tools/buildman/cmdline.py
index b8ddd47..e493b1a 100644
--- a/tools/buildman/cmdline.py
+++ b/tools/buildman/cmdline.py
@@ -92,6 +92,8 @@
default=None, help='Number of builder threads to use')
parser.add_option('-u', '--show_unknown', action='store_true',
default=False, help='Show boards with unknown build result')
+ parser.add_option('-U', '--show-environment', action='store_true',
+ default=False, help='Show environment changes in summary')
parser.add_option('-v', '--verbose', action='store_true',
default=False, help='Show build results while the build progresses')
parser.add_option('-V', '--verbose-build', action='store_true',
diff --git a/tools/buildman/control.py b/tools/buildman/control.py
index 4ac4386..bc08197 100644
--- a/tools/buildman/control.py
+++ b/tools/buildman/control.py
@@ -319,7 +319,8 @@
builder.SetDisplayOptions(options.show_errors, options.show_sizes,
options.show_detail, options.show_bloat,
options.list_error_boards,
- options.show_config)
+ options.show_config,
+ options.show_environment)
if options.summary:
builder.ShowSummary(commits, board_selected)
else:
diff --git a/tools/buildman/func_test.py b/tools/buildman/func_test.py
index 9206fb2..363db9d 100644
--- a/tools/buildman/func_test.py
+++ b/tools/buildman/func_test.py
@@ -327,6 +327,9 @@
def _HandleCommandObjdump(self, args):
return command.CommandResult(return_code=0)
+ def _HandleCommandObjcopy(self, args):
+ return command.CommandResult(return_code=0)
+
def _HandleCommandSize(self, args):
return command.CommandResult(return_code=0)
@@ -359,6 +362,8 @@
return self._HandleCommandNm(args)
elif cmd.endswith('objdump'):
return self._HandleCommandObjdump(args)
+ elif cmd.endswith('objcopy'):
+ return self._HandleCommandObjcopy(args)
elif cmd.endswith( 'size'):
return self._HandleCommandSize(args)
diff --git a/tools/patman/test.py b/tools/patman/test.py
index 343efc9..c7ba4e6 100644
--- a/tools/patman/test.py
+++ b/tools/patman/test.py
@@ -148,7 +148,7 @@
--- /dev/null
+++ b/common/bootstage.c
@@ -0,0 +1,37 @@
-+/* SPDX-License-Identifier: GPL-2.0+ */
++// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (c) 2011, Google Inc. All rights reserved.
+ *