Mirrors/u-boot
2
0
Fork 0
mirror of https://github.com/AsahiLinux/u-boot synced 2024-11-28 15:41:40 +00:00
Code Issues Projects Releases Packages Wiki Activity

Prepare v2022.01-rc3

Browse source 
-----BEGIN PGP SIGNATURE-----
 
 iQGzBAABCgAdFiEEGjx/cOCPqxcHgJu/FHw5/5Y0tywFAmGk/4sACgkQFHw5/5Y0
 tyyjtgwAo0jCRa1Vyc5z2RrINGdARoPhNcCnBNMYEVTjH9uP0/Mzlpo4i1IWX5qP
 nEuVmP01KjtWDRNy7Cpr45/j2PkTZ0THqXGZKpTG/yALdUKZw0wbzeh/CMllWh0A
 9yJfMbv2/IV79rbb6osxItjusSr5PnrU5fHsR+zUfC8NRZpzWGfpH8a6NpfGvGYo
 3OUKNJrGv930C3MqVnUEHPIuz+vL9fWLSs/rK/JHVZt+ALU45uYtz4cKycMoElVd
 IUJe3mhKhw0k8dO8R+p3UAEFrP+LZdcBLgCt8wRQK6Yl4lcxYOtZgYuJuM9Kp20s
 abqIuky3TWwFjpNM60Gmo63Yf967jOeI/lfITq2juZ5TBlNKOO6Z/NRVUsHkNKFG
 7qJC14/NxuSdN4u9s2h+rJBBGYc+BzWVO/ikigHnsCeFQYfafJpGTnPSJr55OU5X
 eeB6l3blx6jwxOPAz0JhLecZb4e027R+eKionirMEnVPENtnJjF1d+CulkekahUO
 LvdqKaBE
 =h4j5
 -----END PGP SIGNATURE-----

Merge tag 'v2022.01-rc3' into next

Prepare v2022.01-rc3

Signed-off-by: Tom Rini <trini@konsulko.com>
This commit is contained in:
Tom Rini 2021-11-29 12:00:57 -05:00
commit 2402c93130
77 changed files with 2130 additions and 344 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
MAINTAINERS
View file

@ -668,6 +668,7 @@ F: drivers/mtd/jedec_flash.c
CLOCK
M: Lukasz Majewski <lukma@denx.de>
M: Sean Anderson <seanga2@gmail.com>
S: Maintained
T: git https://source.denx.de/u-boot/custodians/u-boot-clk.git
F: drivers/clk/
@ -768,6 +769,18 @@ S: Maintained
F: doc/usage/environment.rst
F: scripts/env2string.awk
FASTBOOT
S: Orphaned
F: cmd/fastboot.c
F: doc/android/fastboot*.rst
F: include/fastboot.h
F: include/fastboot-internal.h
F: include/net/fastboot.h
F: drivers/fastboot/
F: drivers/usb/gadget/f_fastboot.c
F: net/fastboot.c
F: test/dm/fastboot.c
FPGA
M: Michal Simek <michal.simek@xilinx.com>
S: Maintained

4
Makefile
View file

@ -3,7 +3,7 @@
VERSION = 2022
PATCHLEVEL = 01
SUBLEVEL =
EXTRAVERSION = -rc2
EXTRAVERSION = -rc3
NAME =
# *DOCUMENTATION*
@ -1247,7 +1247,7 @@ binary_size_check: u-boot-nodtb.bin FORCE
echo "u-boot.map shows a binary size of $$map_size" >&2 ; \
echo " but u-boot-nodtb.bin shows $$file_size" >&2 ; \
exit 1; \
fi \
fi; \
fi
ifeq ($(CONFIG_INIT_SP_RELATIVE)$(CONFIG_OF_SEPARATE),yy)

1
arch/arm/dts/Makefile
View file

@ -319,6 +319,7 @@ dtb-$(CONFIG_ARCH_ZYNQMP) += \
avnet-ultra96-rev1.dtb \
avnet-ultrazedev-cc-v1.0-ultrazedev-som-v1.0.dtb \
zynqmp-a2197-revA.dtb \
zynqmp-dlc21-revA.dtb \
zynqmp-e-a2197-00-revA.dtb \
zynqmp-g-a2197-00-revA.dtb \
zynqmp-m-a2197-01-revA.dtb \

221
arch/arm/dts/zynqmp-dlc21-revA.dts Normal file
View file

@ -0,0 +1,221 @@
// SPDX-License-Identifier: GPL-2.0
/*
* dts file for Xilinx ZynqMP DLC21 revA
*
* (C) Copyright 2019 - 2021, Xilinx, Inc.
*
* Michal Simek <michal.simek@xilinx.com>
*/
/dts-v1/;
#include "zynqmp.dtsi"
#include "zynqmp-clk-ccf.dtsi"
#include <dt-bindings/gpio/gpio.h>
#include <dt-bindings/phy/phy.h>
#include <include/dt-bindings/gpio/gpio.h>
/ {
model = "Smartlynq+ DLC21 RevA";
compatible = "xlnx,zynqmp-dlc21-revA", "xlnx,zynqmp-dlc21",
"xlnx,zynqmp";
aliases {
ethernet0 = &gem0;
gpio0 = &gpio;
i2c0 = &i2c0;
mmc0 = &sdhci0;
mmc1 = &sdhci1;
rtc0 = &rtc;
serial0 = &uart0;
serial2 = &dcc;
usb0 = &usb0;
usb1 = &usb1;
spi0 = &spi0;
nvmem0 = &eeprom;
};
chosen {
bootargs = "earlycon";
stdout-path = "serial0:115200n8";
};
memory@0 {
device_type = "memory";
reg = <0 0 0 0x80000000>, <0x8 0 0x3 0x80000000>;
};
si5332_1: si5332_1 { /* clk0_sgmii - u142 */
compatible = "fixed-clock";
#clock-cells = <0>;
clock-frequency = <125000000>;
};
si5332_2: si5332_2 { /* clk1_usb - u142 */
compatible = "fixed-clock";
#clock-cells = <0>;
clock-frequency = <26000000>;
};
};
&sdhci0 { /* emmc MIO 13-23 - with some settings 16GB */
status = "okay";
non-removable;
disable-wp;
bus-width = <8>;
xlnx,mio_bank = <0>;
};
&sdhci1 { /* sd1 MIO45-51 cd in place */
status = "okay";
no-1-8-v;
disable-wp;
xlnx,mio_bank = <1>;
};
&psgtr {
status = "okay";
/* sgmii, usb3 */
clocks = <&si5332_1>, <&si5332_2>;
clock-names = "ref0", "ref1";
};
&uart0 { /* uart0 MIO38-39 */
status = "okay";
u-boot,dm-pre-reloc;
};
&gem0 {
status = "okay";
phy-handle = <&phy0>;
phy-mode = "sgmii"; /* DTG generates this properly 1512 */
is-internal-pcspma;
/* phy-reset-gpios = <&gpio 142 GPIO_ACTIVE_LOW>; */
phy0: ethernet-phy@0 {
reg = <0>;
};
};
&gpio {
status = "okay";
gpio-line-names = "", "", "", "", "", /* 0 - 4 */
"", "", "", "", "", /* 5 - 9 */
"", "", "", "EMMC_DAT0", "EMMC_DAT1", /* 10 - 14 */
"EMMC_DAT2", "EMMC_DAT3", "EMMC_DAT4", "EMMC_DAT5", "EMMC_DAT6", /* 15 - 19 */
"EMMC_DAT7", "EMMC_CMD", "EMMC_CLK", "EMMC_RST_B", "", /* 20 - 24 */
"", "DISP_SCL", "DISP_DC_B", "DISP_RES_B", "DISP_CS_B", /* 25 - 29 */
"", "DISP_SDI", "SYSTEM_RST_R_B", "", "I2C0_SCL", /* 30 - 34 */
"I2C0_SDA", "", "", "UART0_RXD_IN", "UART0_TXD_OUT", /* 35 - 39 */
"", "", "ETH_RESET_B", "", "", /* 40 - 44 */
"SD1_CD_B", "SD1_DATA0", "SD1_DATA1", "SD1_DATA2", "SD1_DATA3", /* 45 - 49 */
"SD1_CMD", "SD1_CLK", "USB0_CLK", "USB0_DIR", "USB0_DATA2", /* 50 - 54 */
"USB0_NXT", "USB0_DATA0", "USB0_DATA1", "USB0_STP", "USB0_DATA3", /* 55 - 59 */
"USB0_DATA4", "USB0_DATA5", "USB0_DATA6", "USB0_DATA7", "USB1_CLK", /* 60 - 64 */
"USB1_DIR", "USB1_DATA2", "USB1_NXT", "USB1_DATA0", "USB1_DATA1", /* 65 - 69 */
"USB1_STP", "USB1_DATA3", "USB1_DATA4", "USB1_DATA5", "USB1_DATA6", /* 70 - 74 */
"USB1_DATA7", "ETH_MDC", "ETH_MDIO", /* 75 - 77, MIO end and EMIO start */
"", "", /* 78 - 79 */
"", "", "", "", "", /* 80 - 84 */
"", "", "", "", "", /* 85 -89 */
"", "", "", "", "", /* 90 - 94 */
"", "VCCO_500_RBIAS", "VCCO_501_RBIAS", "VCCO_502_RBIAS", "VCCO_500_RBIAS_LED", /* 95 - 99 */
"VCCO_501_RBIAS_LED", "VCCO_502_RBIAS_LED", "SYSCTLR_VCCINT_EN", "SYSCTLR_VCC_IO_SOC_EN", "SYSCTLR_VCC_PMC_EN", /* 100 - 104 */
"", "", "", "", "", /* 105 - 109 */
"SYSCTLR_VCCO_500_EN", "SYSCTLR_VCCO_501_EN", "SYSCTLR_VCCO_502_EN", "SYSCTLR_VCCO_503_EN", "SYSCTLR_VCC1V8_EN", /* 110 - 114 */
"SYSCTLR_VCC3V3_EN", "SYSCTLR_VCC1V2_DDR4_EN", "SYSCTLR_VCC1V1_LP4_EN", "SYSCTLR_VDD1_1V8_LP4_EN", "SYSCTLR_VADJ_FMC_EN", /* 115 - 119 */
"", "", "", "SYSCTLR_UTIL_1V13_EN", "SYSCTLR_UTIL_1V8_EN", /* 120 - 124 */
"SYSCTLR_UTIL_2V5_EN", "", "", "", "", /* 125 - 129 */
"", "", "SYSCTLR_USBC_SBU1", "SYSCTLR_USBC_SBU2", "", /* 130 - 134 */
"", "SYSCTLR_MIC2005_EN_B", "SYSCTLR_MIC2005_FAULT_B", "SYSCTLR_TUSB320_INT_B", "SYSCTLR_TUSB320_ID", /* 135 - 139 */
"", "", "SYSCTLR_ETH_RESET_B", "", "", /* 140 - 144 */
"", "", "", "", "", /* 145 - 149 */
"", "", "", "", "", /* 150 - 154 */
"", "", "", "", "", /* 155 - 159 */
"", "", "", "", "", /* 160 - 164 */
"", "", "", "", "", /* 165 - 169 */
"", "", "", ""; /* 170 - 174 */
};
&i2c0 { /* MIO34/35 */
status = "okay";
clock-frequency = <400000>;
jtag_vref: mcp4725@62 {
compatible = "microchip,mcp4725";
reg = <0x62>;
vref-millivolt = <3300>;
};
eeprom: eeprom@50 { /* u46 */
compatible = "atmel,24c32";
reg = <0x50>;
};
/* u138 - TUSB320IRWBR - for USB-C */
};
&usb0 {
status = "okay";
xlnx,usb-polarity = <0>;
xlnx,usb-reset-mode = <0>;
};
&dwc3_0 {
status = "okay";
dr_mode = "peripheral";
snps,dis_u2_susphy_quirk;
snps,dis_u3_susphy_quirk;
maximum-speed = "super-speed";
phy-names = "usb3-phy";
phys = <&psgtr 1 PHY_TYPE_USB3 0 1>;
};
&usb1 {
status = "disabled"; /* Any unknown issue with USB-C */
xlnx,usb-polarity = <0>;
xlnx,usb-reset-mode = <0>;
};
&dwc3_1 {
/delete-property/ phy-names ;
/delete-property/ phys ;
dr_mode = "host";
maximum-speed = "high-speed";
snps,dis_u2_susphy_quirk ;
snps,dis_u3_susphy_quirk ;
status = "okay";
};
&xilinx_ams {
status = "okay";
};
&ams_ps {
status = "okay";
};
&ams_pl {
status = "okay";
};
&spi0 {
status = "okay";
is-decoded-cs = <0>;
num-cs = <1>;
u-boot,dm-pre-reloc;
displayspi@0 {
compatible = "syncoam,seps525";
u-boot,dm-pre-reloc;
reg = <0>;
status = "okay";
spi-max-frequency = <10000000>;
spi-cpol;
spi-cpha;
rotate = <0>;
fps = <50>;
buswidth = <8>;
txbuflen = <64000>;
reset-gpios = <&gpio 0x1c GPIO_ACTIVE_LOW>;
dc-gpios = <&gpio 0x1b GPIO_ACTIVE_HIGH>;
debug = <0>;
};
};

2
arch/arm/dts/zynqmp-p-a2197-00-revA.dts
View file

@ -46,7 +46,7 @@
si5332_1: si5332_1 { /* clk0_sgmii - u142 */
compatible = "fixed-clock";
#clock-cells = <0>;
clock-frequency = <33333333>; /* FIXME */
clock-frequency = <125000000>;
};
si5332_2: si5332_2 { /* clk1_usb - u142 */

4
arch/arm/lib/crt0_64.S
View file

@ -108,6 +108,10 @@ ENTRY(_main)
bic sp, x0, #0xf /* 16-byte alignment for ABI compliance */
ldr x18, [x18, #GD_NEW_GD] /* x18 <- gd->new_gd */
/* Skip relocation in case gd->gd_flags & GD_FLG_SKIP_RELOC */
ldr x0, [x18, #GD_FLAGS] /* x0 <- gd->flags */
tbnz x0, 11, relocation_return /* GD_FLG_SKIP_RELOC is bit 11 */
adr lr, relocation_return
#if CONFIG_POSITION_INDEPENDENT
/* Add in link-vs-runtime offset */

2
arch/arm/lib/memcpy.S
View file

@ -210,7 +210,7 @@ ENTRY(memcpy)
orr r9, r9, ip, lspush #\push
mov ip, ip, lspull #\pull
orr ip, ip, lr, lspush #\push
str8w r0, r3, r4, r5, r6, r7, r8, r9, ip, , abort=19f
str8w r0, r3, r4, r5, r6, r7, r8, r9, ip, abort=19f
bge 12b
PLD( cmn r2, #96 )
PLD( bge 13b )

4
arch/arm/mach-imx/mx6/Kconfig
View file

@ -569,7 +569,7 @@ config TARGET_KP_IMX6Q_TPC
imply CMD_SPL
config TARGET_TQMA6
bool "TQ Systems TQMa6 board"
bool "TQ-Systems TQMa6 board"
select BOARD_EARLY_INIT_F
select BOARD_LATE_INIT
select MXC_SPI
@ -688,7 +688,7 @@ source "board/somlabs/visionsom-6ull/Kconfig"
source "board/technexion/pico-imx6/Kconfig"
source "board/technexion/pico-imx6ul/Kconfig"
source "board/tbs/tbs2910/Kconfig"
source "board/tqc/tqma6/Kconfig"
source "board/tq/tqma6/Kconfig"
source "board/toradex/apalis_imx6/Kconfig"
source "board/toradex/colibri_imx6/Kconfig"
source "board/toradex/colibri-imx6ull/Kconfig"

9
arch/arm/mach-zynqmp/Kconfig
View file

@ -25,6 +25,7 @@ config SPL_SPI
default y if ZYNQ_QSPI
config SYS_BOARD
string "Board name"
default "zynqmp"
config SYS_VENDOR
@ -149,6 +150,14 @@ config SPL_ZYNQMP_ALT_BOOTMODE_ENABLED
Overwrite bootmode selected via boot mode pins to tell SPL what should
be the next boot device.
config SPL_ZYNQMP_RESTORE_JTAG
bool "Restore JTAG"
depends on SPL
help
Booting SPL in secure mode causes the CSU to disable the JTAG interface
even if no eFuses were burnt. This option restores the interface if
possible.
config ZYNQ_SDHCI_MAX_FREQ
default 200000000

31
arch/arm/mach-zynqmp/include/mach/hardware.h
View file

@ -39,20 +39,26 @@
#define RESET_REASON_INTERNAL BIT(1)
#define RESET_REASON_EXTERNAL BIT(0)
#define CRLAPB_DBG_LPD_CTRL_SETUP_CLK 0x01002002
#define CRLAPB_RST_LPD_DBG_RESET 0
struct crlapb_regs {
u32 reserved0[36];
u32 cpu_r5_ctrl; /* 0x90 */
u32 reserved1[37];
u32 reserved1[7];
u32 dbg_lpd_ctrl; /* 0xB0 */
u32 reserved2[29];
u32 timestamp_ref_ctrl; /* 0x128 */
u32 reserved2[53];
u32 reserved3[53];
u32 boot_mode; /* 0x200 */
u32 reserved3_0[7];
u32 reserved4_0[7];
u32 reset_reason; /* 0x220 */
u32 reserved3_1[6];
u32 reserved4_1[6];
u32 rst_lpd_top; /* 0x23C */
u32 reserved4[4];
u32 rst_lpd_dbg; /* 0x240 */
u32 reserved5[3];
u32 boot_pin_ctrl; /* 0x250 */
u32 reserved5[21];
u32 reserved6[21];
};
#define crlapb_base ((struct crlapb_regs *)ZYNQMP_CRL_APB_BASEADDR)
@ -141,12 +147,23 @@ struct apu_regs {
#define ZYNQMP_SILICON_VER_MASK 0xF
#define ZYNQMP_SILICON_VER_SHIFT 0
#define CSU_JTAG_SEC_GATE_DISABLE GENMASK(7, 0)
#define CSU_JTAG_DAP_ENABLE_DEBUG GENMASK(7, 0)
#define CSU_JTAG_CHAIN_WR_SETUP GENMASK(1, 0)
#define CSU_PCAP_PROG_RELEASE_PL BIT(0)
struct csu_regs {
u32 reserved0[4];
u32 multi_boot;
u32 reserved1[11];
u32 reserved1[7];
u32 jtag_chain_status_wr;
u32 jtag_chain_status;
u32 jtag_sec;
u32 jtag_dap_cfg;
u32 idcode;
u32 version;
u32 reserved2[3055];
u32 pcap_prog;
};
#define csu_base ((struct csu_regs *)ZYNQMP_CSU_BASEADDR)

6
arch/sandbox/cpu/start.c
View file

@ -434,8 +434,10 @@ void __efi_runtime EFIAPI efi_reset_system(
efi_status_t reset_status,
unsigned long data_size, void *reset_data)
{
os_fd_restore();
os_relaunch(os_argv);
if (reset_type == EFI_RESET_SHUTDOWN)
sandbox_exit();
else
sandbox_reset();
}
void sandbox_reset(void)

1
board/emulation/common/Makefile
View file

@ -2,4 +2,3 @@
obj-$(CONFIG_SYS_MTDPARTS_RUNTIME) += qemu_mtdparts.o
obj-$(CONFIG_SET_DFU_ALT_INFO) += qemu_dfu.o
obj-$(CONFIG_EFI_CAPSULE_FIRMWARE_MANAGEMENT) += qemu_capsule.o

2
board/socionext/developerbox/developerbox.c
View file

@ -82,6 +82,8 @@ int board_init(void)
{
gd->bd->bi_boot_params = CONFIG_SYS_LOAD_ADDR + LOAD_OFFSET;
gd->env_addr = (ulong)&default_environment[0];
synquacer_setup_scbm_smmu();
return 0;

8
board/tqc/tqma6/Kconfig → board/tq/tqma6/Kconfig
View file

@ -4,7 +4,7 @@ config SYS_BOARD
default "tqma6"
config SYS_VENDOR
default "tqc"
default "tq"
config SYS_CONFIG_NAME
default "tqma6"
@ -89,8 +89,8 @@ config SYS_TEXT_BASE
default 0x4fc00000 if TQMA6Q || TQMA6DL
config IMX_CONFIG
default "board/tqc/tqma6/tqma6q.cfg" if TQMA6Q
default "board/tqc/tqma6/tqma6dl.cfg" if TQMA6DL
default "board/tqc/tqma6/tqma6s.cfg" if TQMA6S
default "board/tq/tqma6/tqma6q.cfg" if TQMA6Q
default "board/tq/tqma6/tqma6dl.cfg" if TQMA6DL
default "board/tq/tqma6/tqma6s.cfg" if TQMA6S
endif

4
board/tqc/tqma6/MAINTAINERS → board/tq/tqma6/MAINTAINERS
View file

@ -1,6 +1,6 @@
TQ SYSTEMS TQMA6 BOARD
TQ-SYSTEMS TQMA6 BOARD
M: Markus Niebel <Markus.Niebel@tq-group.com>
S: Maintained
F: board/tqc/tqma6/
F: board/tq/tqma6/
F: include/configs/tqma6.h
F: configs/tqma6*_defconfig

0
board/tqc/tqma6/Makefile → board/tq/tqma6/Makefile
View file

6
board/tqc/tqma6/README → board/tq/tqma6/README
View file

@ -1,7 +1,7 @@
U-Boot for the TQ Systems TQMa6 modules
U-Boot for the TQ-Systems TQMa6 modules
This file contains information for the port of
U-Boot to the TQ Systems TQMa6 modules.
U-Boot to the TQ-Systems TQMa6 modules.
1. Boot source
--------------
@ -14,7 +14,7 @@ The following boot source is supported:
2. Building
------------
To build U-Boot for the TQ Systems TQMa6 modules:
To build U-Boot for the TQ-Systems TQMa6 modules:
make tqma6<x>_<baseboard>_<boot>_config
make

0
board/tqc/tqma6/clocks.cfg → board/tq/tqma6/clocks.cfg
View file

2
board/tqc/tqma6/tqma6.c → board/tq/tqma6/tqma6.c
View file

@ -3,7 +3,7 @@
* Copyright (C) 2012 Freescale Semiconductor, Inc.
* Author: Fabio Estevam <fabio.estevam@freescale.com>
*
* Copyright (C) 2013, 2014 TQ Systems (ported SabreSD to TQMa6x)
* Copyright (C) 2013, 2014 TQ-Systems (ported SabreSD to TQMa6x)
* Author: Markus Niebel <markus.niebel@tq-group.com>
*/

2
board/tqc/tqma6/tqma6_bb.h → board/tq/tqma6/tqma6_bb.h
View file

@ -1,6 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0+ */
/*
* Copyright (C) 2013, 2014 TQ Systems
* Copyright (C) 2013, 2014 TQ-Systems
* Author: Markus Niebel <markus.niebel@tq-group.com>
*/

2
board/tqc/tqma6/tqma6_mba6.c → board/tq/tqma6/tqma6_mba6.c
View file

@ -3,7 +3,7 @@
* Copyright (C) 2012 Freescale Semiconductor, Inc.
* Author: Fabio Estevam <fabio.estevam@freescale.com>
*
* Copyright (C) 2013, 2014 TQ Systems (ported SabreSD to TQMa6x)
* Copyright (C) 2013, 2014 TQ-Systems (ported SabreSD to TQMa6x)
* Author: Markus Niebel <markus.niebel@tq-group.com>
*/

2
board/tqc/tqma6/tqma6_wru4.c → board/tq/tqma6/tqma6_wru4.c
View file

@ -3,7 +3,7 @@
* Copyright (C) 2012 Freescale Semiconductor, Inc.
* Author: Fabio Estevam <fabio.estevam@freescale.com>
*
* Copyright (C) 2013, 2014 TQ Systems (ported SabreSD to TQMa6x)
* Copyright (C) 2013, 2014 TQ-Systems (ported SabreSD to TQMa6x)
* Author: Markus Niebel <markus.niebel@tq-group.com>
*
* Copyright (C) 2015 Stefan Roese <sr@denx.de>

0
board/tqc/tqma6/tqma6dl.cfg → board/tq/tqma6/tqma6dl.cfg
View file

0
board/tqc/tqma6/tqma6q.cfg → board/tq/tqma6/tqma6q.cfg
View file

0
board/tqc/tqma6/tqma6s.cfg → board/tq/tqma6/tqma6s.cfg
View file

922
board/xilinx/zynqmp/zynqmp-dlc21-revA/psu_init_gpl.c Normal file
View file

@ -0,0 +1,922 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* (c) Copyright 2015 Xilinx, Inc. All rights reserved.
*/
#include <asm/arch/psu_init_gpl.h>
#include <xil_io.h>
static unsigned long psu_pll_init_data(void)
{
psu_mask_write(0xFF5E0034, 0xFE7FEDEFU, 0x7E4B0C62U);
psu_mask_write(0xFF5E0030, 0x00717F00U, 0x00014000U);
psu_mask_write(0xFF5E0030, 0x00000008U, 0x00000008U);
psu_mask_write(0xFF5E0030, 0x00000001U, 0x00000001U);
psu_mask_write(0xFF5E0030, 0x00000001U, 0x00000000U);
mask_poll(0xFF5E0040, 0x00000002U);
psu_mask_write(0xFF5E0030, 0x00000008U, 0x00000000U);
psu_mask_write(0xFF5E0048, 0x00003F00U, 0x00000200U);
psu_mask_write(0xFF5E0038, 0x8000FFFFU, 0x00000000U);
psu_mask_write(0xFF5E0108, 0x013F3F07U, 0x01012300U);
psu_mask_write(0xFF5E0024, 0xFE7FEDEFU, 0x7E4B0C82U);
psu_mask_write(0xFF5E0020, 0x00717F00U, 0x00015A00U);
psu_mask_write(0xFF5E0020, 0x00000008U, 0x00000008U);
psu_mask_write(0xFF5E0020, 0x00000001U, 0x00000001U);
psu_mask_write(0xFF5E0020, 0x00000001U, 0x00000000U);
mask_poll(0xFF5E0040, 0x00000001U);
psu_mask_write(0xFF5E0020, 0x00000008U, 0x00000000U);
psu_mask_write(0xFF5E0044, 0x00003F00U, 0x00000300U);
psu_mask_write(0xFF5E0028, 0x8000FFFFU, 0x00000000U);
psu_mask_write(0xFD1A0024, 0xFE7FEDEFU, 0x7E4B0C62U);
psu_mask_write(0xFD1A0020, 0x00717F00U, 0x00014800U);
psu_mask_write(0xFD1A0020, 0x00000008U, 0x00000008U);
psu_mask_write(0xFD1A0020, 0x00000001U, 0x00000001U);
psu_mask_write(0xFD1A0020, 0x00000001U, 0x00000000U);
mask_poll(0xFD1A0044, 0x00000001U);
psu_mask_write(0xFD1A0020, 0x00000008U, 0x00000000U);
psu_mask_write(0xFD1A0048, 0x00003F00U, 0x00000300U);
psu_mask_write(0xFD1A0028, 0x8000FFFFU, 0x00000000U);
psu_mask_write(0xFD1A0030, 0xFE7FEDEFU, 0x7E4B0C62U);
psu_mask_write(0xFD1A002C, 0x00717F00U, 0x00014000U);
psu_mask_write(0xFD1A002C, 0x00000008U, 0x00000008U);
psu_mask_write(0xFD1A002C, 0x00000001U, 0x00000001U);
psu_mask_write(0xFD1A002C, 0x00000001U, 0x00000000U);
mask_poll(0xFD1A0044, 0x00000002U);
psu_mask_write(0xFD1A002C, 0x00000008U, 0x00000000U);
psu_mask_write(0xFD1A004C, 0x00003F00U, 0x00000200U);
psu_mask_write(0xFD1A0034, 0x8000FFFFU, 0x00000000U);
psu_mask_write(0xFD1A003C, 0xFE7FEDEFU, 0x7E4B0C62U);
psu_mask_write(0xFD1A0038, 0x00717F00U, 0x00014000U);
psu_mask_write(0xFD1A0038, 0x00000008U, 0x00000008U);
psu_mask_write(0xFD1A0038, 0x00000001U, 0x00000001U);
psu_mask_write(0xFD1A0038, 0x00000001U, 0x00000000U);
mask_poll(0xFD1A0044, 0x00000004U);
psu_mask_write(0xFD1A0038, 0x00000008U, 0x00000000U);
psu_mask_write(0xFD1A0050, 0x00003F00U, 0x00000200U);
psu_mask_write(0xFD1A0040, 0x8000FFFFU, 0x00000000U);
return 1;
}
static unsigned long psu_clock_init_data(void)
{
psu_mask_write(0xFF5E0050, 0x063F3F07U, 0x06013C00U);
psu_mask_write(0xFF180360, 0x00000003U, 0x00000001U);
psu_mask_write(0xFF180308, 0x00000006U, 0x00000006U);
psu_mask_write(0xFF5E0100, 0x013F3F07U, 0x01010600U);
psu_mask_write(0xFF5E0060, 0x023F3F07U, 0x02010600U);
psu_mask_write(0xFF5E0064, 0x023F3F07U, 0x02010600U);
psu_mask_write(0xFF5E004C, 0x023F3F07U, 0x02031900U);
psu_mask_write(0xFF5E006C, 0x013F3F07U, 0x01010800U);
psu_mask_write(0xFF5E0070, 0x013F3F07U, 0x01010800U);
psu_mask_write(0xFF18030C, 0x00020003U, 0x00000000U);
psu_mask_write(0xFF5E0074, 0x013F3F07U, 0x01010F00U);
psu_mask_write(0xFF5E0120, 0x013F3F07U, 0x01010F00U);
psu_mask_write(0xFF5E007C, 0x013F3F07U, 0x01010702U);
psu_mask_write(0xFF5E0090, 0x01003F07U, 0x01000302U);
psu_mask_write(0xFF5E009C, 0x01003F07U, 0x01000400U);
psu_mask_write(0xFF5E00A4, 0x01003F07U, 0x01000800U);
psu_mask_write(0xFF5E00A8, 0x01003F07U, 0x01000200U);
psu_mask_write(0xFF5E00AC, 0x01003F07U, 0x01000F02U);
psu_mask_write(0xFF5E00B0, 0x01003F07U, 0x01000602U);
psu_mask_write(0xFF5E00B8, 0x01003F07U, 0x01000200U);
psu_mask_write(0xFF5E00C0, 0x013F3F07U, 0x01010502U);
psu_mask_write(0xFF5E00C4, 0x013F3F07U, 0x01010802U);
psu_mask_write(0xFF5E00C8, 0x013F3F07U, 0x01010402U);
psu_mask_write(0xFF5E00CC, 0x013F3F07U, 0x01030A00U);
psu_mask_write(0xFF5E0108, 0x013F3F07U, 0x01011E02U);
psu_mask_write(0xFF5E0104, 0x00000007U, 0x00000000U);
psu_mask_write(0xFF5E0128, 0x01003F07U, 0x01000104U);
psu_mask_write(0xFD1A0060, 0x03003F07U, 0x03000100U);
psu_mask_write(0xFD1A0068, 0x01003F07U, 0x01000200U);
psu_mask_write(0xFD1A0080, 0x00003F07U, 0x00000200U);
psu_mask_write(0xFD1A0084, 0x07003F07U, 0x07000100U);
psu_mask_write(0xFD1A00B8, 0x01003F07U, 0x01000203U);
psu_mask_write(0xFD1A00BC, 0x01003F07U, 0x01000203U);
psu_mask_write(0xFD1A00C0, 0x01003F07U, 0x01000202U);
psu_mask_write(0xFD1A00C4, 0x01003F07U, 0x01000502U);
psu_mask_write(0xFD1A00F8, 0x00003F07U, 0x00000200U);
psu_mask_write(0xFF180380, 0x000000FFU, 0x00000000U);
psu_mask_write(0xFD610100, 0x00000001U, 0x00000000U);
psu_mask_write(0xFF180300, 0x00000001U, 0x00000000U);
psu_mask_write(0xFF410050, 0x00000001U, 0x00000000U);
return 1;
}
static unsigned long psu_ddr_init_data(void)
{
psu_mask_write(0xFD1A0108, 0x00000008U, 0x00000008U);
psu_mask_write(0xFD070000, 0xE30FBE3DU, 0x43041010U);
psu_mask_write(0xFD070010, 0x8000F03FU, 0x00000030U);
psu_mask_write(0xFD070020, 0x000003F3U, 0x00000200U);
psu_mask_write(0xFD070024, 0xFFFFFFFFU, 0x00800000U);
psu_mask_write(0xFD070030, 0x0000007FU, 0x00000008U);
psu_mask_write(0xFD070034, 0x00FFFF1FU, 0x00408410U);
psu_mask_write(0xFD070050, 0x00F1F1F4U, 0x00210000U);
psu_mask_write(0xFD070054, 0x0FFF0FFFU, 0x00000000U);
psu_mask_write(0xFD070060, 0x00000073U, 0x00000001U);
psu_mask_write(0xFD070064, 0x0FFF83FFU, 0x00818126U);
psu_mask_write(0xFD070070, 0x00000017U, 0x00000010U);
psu_mask_write(0xFD070074, 0x00000003U, 0x00000000U);
psu_mask_write(0xFD0700C4, 0x3F000391U, 0x10000200U);
psu_mask_write(0xFD0700C8, 0x01FF1F3FU, 0x0040051FU);
psu_mask_write(0xFD0700D0, 0xC3FF0FFFU, 0x00020106U);
psu_mask_write(0xFD0700D4, 0x01FF7F0FU, 0x00020000U);
psu_mask_write(0xFD0700D8, 0x0000FF0FU, 0x00002305U);
psu_mask_write(0xFD0700DC, 0xFFFFFFFFU, 0x07300501U);
psu_mask_write(0xFD0700E0, 0xFFFFFFFFU, 0x00200200U);
psu_mask_write(0xFD0700E4, 0x00FF03FFU, 0x00210004U);
psu_mask_write(0xFD0700E8, 0xFFFFFFFFU, 0x00000700U);
psu_mask_write(0xFD0700EC, 0xFFFF0000U, 0x08190000U);
psu_mask_write(0xFD0700F0, 0x0000003FU, 0x00000010U);
psu_mask_write(0xFD0700F4, 0x00000FFFU, 0x0000066FU);
psu_mask_write(0xFD070100, 0x7F3F7F3FU, 0x110C2412U);
psu_mask_write(0xFD070104, 0x001F1F7FU, 0x0004041CU);
psu_mask_write(0xFD070108, 0x3F3F3F3FU, 0x0708060DU);
psu_mask_write(0xFD07010C, 0x3FF3F3FFU, 0x0050400CU);
psu_mask_write(0xFD070110, 0x1F0F0F1FU, 0x08030309U);
psu_mask_write(0xFD070114, 0x0F0F3F1FU, 0x06060403U);
psu_mask_write(0xFD070118, 0x0F0F000FU, 0x01010004U);
psu_mask_write(0xFD07011C, 0x00000F0FU, 0x00000606U);
psu_mask_write(0xFD070120, 0x7F7F7F7FU, 0x04040D0BU);
psu_mask_write(0xFD070124, 0x40070F3FU, 0x0002020BU);
psu_mask_write(0xFD07012C, 0x7F1F031FU, 0x1607010EU);
psu_mask_write(0xFD070130, 0x00030F1FU, 0x00020608U);
psu_mask_write(0xFD070180, 0xF7FF03FFU, 0x81000040U);
psu_mask_write(0xFD070184, 0x3FFFFFFFU, 0x020196E5U);
psu_mask_write(0xFD070190, 0x1FBFBF3FU, 0x048B820BU);
psu_mask_write(0xFD070194, 0xF31F0F0FU, 0x00030304U);
psu_mask_write(0xFD070198, 0x0FF1F1F1U, 0x07000101U);
psu_mask_write(0xFD07019C, 0x000000F1U, 0x00000021U);
psu_mask_write(0xFD0701A0, 0xC3FF03FFU, 0x00400003U);
psu_mask_write(0xFD0701A4, 0x00FF00FFU, 0x00C800FFU);
psu_mask_write(0xFD0701B0, 0x00000007U, 0x00000000U);
psu_mask_write(0xFD0701B4, 0x00003F3FU, 0x00000909U);
psu_mask_write(0xFD0701C0, 0x00000007U, 0x00000001U);
psu_mask_write(0xFD070200, 0x0000001FU, 0x00000018U);
psu_mask_write(0xFD070204, 0x001F1F1FU, 0x001F0909U);
psu_mask_write(0xFD070208, 0x0F0F0F0FU, 0x01010101U);
psu_mask_write(0xFD07020C, 0x0F0F0F0FU, 0x0F010101U);
psu_mask_write(0xFD070210, 0x00000F0FU, 0x00000F0FU);
psu_mask_write(0xFD070214, 0x0F0F0F0FU, 0x070F0707U);
psu_mask_write(0xFD070218, 0x8F0F0F0FU, 0x07070707U);
psu_mask_write(0xFD07021C, 0x00000F0FU, 0x00000F07U);
psu_mask_write(0xFD070220, 0x00001F1FU, 0x00000700U);
psu_mask_write(0xFD070224, 0x0F0F0F0FU, 0x07070707U);
psu_mask_write(0xFD070228, 0x0F0F0F0FU, 0x07070707U);
psu_mask_write(0xFD07022C, 0x0000000FU, 0x00000007U);
psu_mask_write(0xFD070240, 0x0F1F0F7CU, 0x06000600U);
psu_mask_write(0xFD070244, 0x00003333U, 0x00000201U);
psu_mask_write(0xFD070250, 0x7FFF3F07U, 0x01002001U);
psu_mask_write(0xFD070264, 0xFF00FFFFU, 0x08000040U);
psu_mask_write(0xFD07026C, 0xFF00FFFFU, 0x08000040U);
psu_mask_write(0xFD070280, 0xFFFFFFFFU, 0x00000000U);
psu_mask_write(0xFD070284, 0xFFFFFFFFU, 0x00000000U);
psu_mask_write(0xFD070288, 0xFFFFFFFFU, 0x00000000U);
psu_mask_write(0xFD07028C, 0xFFFFFFFFU, 0x00000000U);
psu_mask_write(0xFD070290, 0x0000FFFFU, 0x00000000U);
psu_mask_write(0xFD070294, 0x00000001U, 0x00000001U);
psu_mask_write(0xFD070300, 0x00000011U, 0x00000001U);
psu_mask_write(0xFD07030C, 0x80000033U, 0x00000000U);
psu_mask_write(0xFD070320, 0x00000001U, 0x00000000U);
psu_mask_write(0xFD070400, 0x00000111U, 0x00000101U);
psu_mask_write(0xFD070404, 0x000073FFU, 0x0000200FU);
psu_mask_write(0xFD070408, 0x000073FFU, 0x0000200FU);
psu_mask_write(0xFD070490, 0x00000001U, 0x00000001U);
psu_mask_write(0xFD070494, 0x0033000FU, 0x0020000BU);
psu_mask_write(0xFD070498, 0x07FF07FFU, 0x00000000U);
psu_mask_write(0xFD0704B4, 0x000073FFU, 0x0000200FU);
psu_mask_write(0xFD0704B8, 0x000073FFU, 0x0000200FU);
psu_mask_write(0xFD070540, 0x00000001U, 0x00000001U);
psu_mask_write(0xFD070544, 0x03330F0FU, 0x02000B03U);
psu_mask_write(0xFD070548, 0x07FF07FFU, 0x00000000U);
psu_mask_write(0xFD070564, 0x000073FFU, 0x0000200FU);
psu_mask_write(0xFD070568, 0x000073FFU, 0x0000200FU);
psu_mask_write(0xFD0705F0, 0x00000001U, 0x00000001U);
psu_mask_write(0xFD0705F4, 0x03330F0FU, 0x02000B03U);
psu_mask_write(0xFD0705F8, 0x07FF07FFU, 0x00000000U);
psu_mask_write(0xFD070614, 0x000073FFU, 0x0000200FU);
psu_mask_write(0xFD070618, 0x000073FFU, 0x0000200FU);
psu_mask_write(0xFD0706A0, 0x00000001U, 0x00000001U);
psu_mask_write(0xFD0706A4, 0x0033000FU, 0x00100003U);
psu_mask_write(0xFD0706A8, 0x07FF07FFU, 0x0000004FU);
psu_mask_write(0xFD0706AC, 0x0033000FU, 0x00100003U);
psu_mask_write(0xFD0706B0, 0x000007FFU, 0x0000004FU);
psu_mask_write(0xFD0706C4, 0x000073FFU, 0x0000200FU);
psu_mask_write(0xFD0706C8, 0x000073FFU, 0x0000200FU);
psu_mask_write(0xFD070750, 0x00000001U, 0x00000001U);
psu_mask_write(0xFD070754, 0x0033000FU, 0x00100003U);
psu_mask_write(0xFD070758, 0x07FF07FFU, 0x0000004FU);
psu_mask_write(0xFD07075C, 0x0033000FU, 0x00100003U);
psu_mask_write(0xFD070760, 0x000007FFU, 0x0000004FU);
psu_mask_write(0xFD070774, 0x000073FFU, 0x0000200FU);
psu_mask_write(0xFD070778, 0x000073FFU, 0x0000200FU);
psu_mask_write(0xFD070800, 0x00000001U, 0x00000001U);
psu_mask_write(0xFD070804, 0x0033000FU, 0x00100003U);
psu_mask_write(0xFD070808, 0x07FF07FFU, 0x0000004FU);
psu_mask_write(0xFD07080C, 0x0033000FU, 0x00100003U);
psu_mask_write(0xFD070810, 0x000007FFU, 0x0000004FU);
psu_mask_write(0xFD070F04, 0x000001FFU, 0x00000000U);
psu_mask_write(0xFD070F08, 0x000000FFU, 0x00000000U);
psu_mask_write(0xFD070F0C, 0x000001FFU, 0x00000010U);
psu_mask_write(0xFD070F10, 0x000000FFU, 0x0000000FU);
psu_mask_write(0xFD072190, 0x1FBFBF3FU, 0x07828002U);
psu_mask_write(0xFD1A0108, 0x0000000CU, 0x00000000U);
psu_mask_write(0xFD080010, 0xFFFFFFFFU, 0x07001E00U);
psu_mask_write(0xFD080018, 0xFFFFFFFFU, 0x00F10010U);
psu_mask_write(0xFD08001C, 0xFFFFFFFFU, 0x55AA5480U);
psu_mask_write(0xFD080024, 0xFFFFFFFFU, 0x010100F4U);
psu_mask_write(0xFD080040, 0xFFFFFFFFU, 0x42C21590U);
psu_mask_write(0xFD080044, 0xFFFFFFFFU, 0xD05512C0U);
psu_mask_write(0xFD080068, 0xFFFFFFFFU, 0x01100000U);
psu_mask_write(0xFD080090, 0xFFFFFFFFU, 0x02A04161U);
psu_mask_write(0xFD0800C0, 0xFFFFFFFFU, 0x00000000U);
psu_mask_write(0xFD0800C4, 0xFFFFFFFFU, 0x000000E0U);
psu_mask_write(0xFD080100, 0xFFFFFFFFU, 0x0800040CU);
psu_mask_write(0xFD080110, 0xFFFFFFFFU, 0x06240F08U);
psu_mask_write(0xFD080114, 0xFFFFFFFFU, 0x28170008U);
psu_mask_write(0xFD080118, 0xFFFFFFFFU, 0x000F0300U);
psu_mask_write(0xFD08011C, 0xFFFFFFFFU, 0x83000800U);
psu_mask_write(0xFD080120, 0xFFFFFFFFU, 0x024B2B07U);
psu_mask_write(0xFD080124, 0xFFFFFFFFU, 0x00370F08U);
psu_mask_write(0xFD080128, 0xFFFFFFFFU, 0x00000E0FU);
psu_mask_write(0xFD080140, 0xFFFFFFFFU, 0x08400020U);
psu_mask_write(0xFD080144, 0xFFFFFFFFU, 0x00000C80U);
psu_mask_write(0xFD080150, 0xFFFFFFFFU, 0x00000000U);
psu_mask_write(0xFD080154, 0xFFFFFFFFU, 0x00000200U);
psu_mask_write(0xFD080180, 0xFFFFFFFFU, 0x00000630U);
psu_mask_write(0xFD080184, 0xFFFFFFFFU, 0x00000501U);
psu_mask_write(0xFD080188, 0xFFFFFFFFU, 0x00000020U);
psu_mask_write(0xFD08018C, 0xFFFFFFFFU, 0x00000200U);
psu_mask_write(0xFD080190, 0xFFFFFFFFU, 0x00000000U);
psu_mask_write(0xFD080194, 0xFFFFFFFFU, 0x00000700U);
psu_mask_write(0xFD080198, 0xFFFFFFFFU, 0x00000819U);
psu_mask_write(0xFD0801AC, 0xFFFFFFFFU, 0x00000000U);
psu_mask_write(0xFD0801B0, 0xFFFFFFFFU, 0x0000004DU);
psu_mask_write(0xFD0801B4, 0xFFFFFFFFU, 0x00000008U);
psu_mask_write(0xFD0801B8, 0xFFFFFFFFU, 0x0000004DU);
psu_mask_write(0xFD0801D8, 0xFFFFFFFFU, 0x00000000U);
psu_mask_write(0xFD080200, 0xFFFFFFFFU, 0x810091C7U);
psu_mask_write(0xFD080204, 0xFFFFFFFFU, 0x00030236U);
psu_mask_write(0xFD080240, 0xFFFFFFFFU, 0x00141054U);
psu_mask_write(0xFD080250, 0xFFFFFFFFU, 0x00088000U);
psu_mask_write(0xFD080414, 0xFFFFFFFFU, 0x12344000U);
psu_mask_write(0xFD0804F4, 0xFFFFFFFFU, 0x00000005U);
psu_mask_write(0xFD080500, 0xFFFFFFFFU, 0x30000028U);
psu_mask_write(0xFD080508, 0xFFFFFFFFU, 0x00000000U);
psu_mask_write(0xFD08050C, 0xFFFFFFFFU, 0x00000005U);
psu_mask_write(0xFD080510, 0xFFFFFFFFU, 0x00000000U);
psu_mask_write(0xFD080520, 0xFFFFFFFFU, 0x0300B0CEU);
psu_mask_write(0xFD080528, 0xFFFFFFFFU, 0xF9032019U);
psu_mask_write(0xFD08052C, 0xFFFFFFFFU, 0x07F001E3U);
psu_mask_write(0xFD080544, 0xFFFFFFFFU, 0x00000000U);
psu_mask_write(0xFD080548, 0xFFFFFFFFU, 0x00000000U);
psu_mask_write(0xFD080558, 0xFFFFFFFFU, 0x00000000U);
psu_mask_write(0xFD08055C, 0xFFFFFFFFU, 0x00000000U);
psu_mask_write(0xFD080560, 0xFFFFFFFFU, 0x00000000U);
psu_mask_write(0xFD080564, 0xFFFFFFFFU, 0x00000000U);
psu_mask_write(0xFD080680, 0xFFFFFFFFU, 0x008AAA58U);
psu_mask_write(0xFD080684, 0xFFFFFFFFU, 0x000079DDU);
psu_mask_write(0xFD080694, 0xFFFFFFFFU, 0x01E10210U);
psu_mask_write(0xFD080698, 0xFFFFFFFFU, 0x01E10000U);
psu_mask_write(0xFD0806A4, 0xFFFFFFFFU, 0x000879DBU);
psu_mask_write(0xFD080700, 0xFFFFFFFFU, 0x40800604U);
psu_mask_write(0xFD080704, 0xFFFFFFFFU, 0x00007FFFU);
psu_mask_write(0xFD08070C, 0xFFFFFFFFU, 0x3F000008U);
psu_mask_write(0xFD080710, 0xFFFFFFFFU, 0x0E00B03CU);
psu_mask_write(0xFD080714, 0xFFFFFFFFU, 0x09094F4FU);
psu_mask_write(0xFD080718, 0xFFFFFFFFU, 0x09092B2BU);
psu_mask_write(0xFD080800, 0xFFFFFFFFU, 0x40800604U);
psu_mask_write(0xFD080804, 0xFFFFFFFFU, 0x00007FFFU);
psu_mask_write(0xFD08080C, 0xFFFFFFFFU, 0x3F000008U);
psu_mask_write(0xFD080810, 0xFFFFFFFFU, 0x0E00B03CU);
psu_mask_write(0xFD080814, 0xFFFFFFFFU, 0x09094F4FU);
psu_mask_write(0xFD080818, 0xFFFFFFFFU, 0x09092B2BU);
psu_mask_write(0xFD080900, 0xFFFFFFFFU, 0x40800604U);
psu_mask_write(0xFD080904, 0xFFFFFFFFU, 0x00007FFFU);
psu_mask_write(0xFD08090C, 0xFFFFFFFFU, 0x3F000008U);
psu_mask_write(0xFD080910, 0xFFFFFFFFU, 0x0E00B00CU);
psu_mask_write(0xFD080914, 0xFFFFFFFFU, 0x09094F4FU);
psu_mask_write(0xFD080918, 0xFFFFFFFFU, 0x09092B2BU);
psu_mask_write(0xFD080A00, 0xFFFFFFFFU, 0x40800604U);
psu_mask_write(0xFD080A04, 0xFFFFFFFFU, 0x00007FFFU);
psu_mask_write(0xFD080A0C, 0xFFFFFFFFU, 0x3F000008U);
psu_mask_write(0xFD080A10, 0xFFFFFFFFU, 0x0E00B00CU);
psu_mask_write(0xFD080A14, 0xFFFFFFFFU, 0x09094F4FU);
psu_mask_write(0xFD080A18, 0xFFFFFFFFU, 0x09092B2BU);
psu_mask_write(0xFD080B00, 0xFFFFFFFFU, 0x80803660U);
psu_mask_write(0xFD080B04, 0xFFFFFFFFU, 0x55556000U);
psu_mask_write(0xFD080B08, 0xFFFFFFFFU, 0xAAAAAAAAU);
psu_mask_write(0xFD080B0C, 0xFFFFFFFFU, 0x0029A4A4U);
psu_mask_write(0xFD080B10, 0xFFFFFFFFU, 0x0C00B000U);
psu_mask_write(0xFD080B14, 0xFFFFFFFFU, 0x09094F4FU);
psu_mask_write(0xFD080B18, 0xFFFFFFFFU, 0x09092B2BU);
psu_mask_write(0xFD080C00, 0xFFFFFFFFU, 0x80803660U);
psu_mask_write(0xFD080C04, 0xFFFFFFFFU, 0x55556000U);
psu_mask_write(0xFD080C08, 0xFFFFFFFFU, 0xAAAAAAAAU);
psu_mask_write(0xFD080C0C, 0xFFFFFFFFU, 0x0029A4A4U);
psu_mask_write(0xFD080C10, 0xFFFFFFFFU, 0x0C00B000U);
psu_mask_write(0xFD080C14, 0xFFFFFFFFU, 0x09094F4FU);
psu_mask_write(0xFD080C18, 0xFFFFFFFFU, 0x09092B2BU);
psu_mask_write(0xFD080D00, 0xFFFFFFFFU, 0x80803660U);
psu_mask_write(0xFD080D04, 0xFFFFFFFFU, 0x55556000U);
psu_mask_write(0xFD080D08, 0xFFFFFFFFU, 0xAAAAAAAAU);
psu_mask_write(0xFD080D0C, 0xFFFFFFFFU, 0x0029A4A4U);
psu_mask_write(0xFD080D10, 0xFFFFFFFFU, 0x0C00B000U);
psu_mask_write(0xFD080D14, 0xFFFFFFFFU, 0x09094F4FU);
psu_mask_write(0xFD080D18, 0xFFFFFFFFU, 0x09092B2BU);
psu_mask_write(0xFD080E00, 0xFFFFFFFFU, 0x80803660U);
psu_mask_write(0xFD080E04, 0xFFFFFFFFU, 0x55556000U);
psu_mask_write(0xFD080E08, 0xFFFFFFFFU, 0xAAAAAAAAU);
psu_mask_write(0xFD080E0C, 0xFFFFFFFFU, 0x0029A4A4U);
psu_mask_write(0xFD080E10, 0xFFFFFFFFU, 0x0C00B000U);
psu_mask_write(0xFD080E14, 0xFFFFFFFFU, 0x09094F4FU);
psu_mask_write(0xFD080E18, 0xFFFFFFFFU, 0x09092B2BU);
psu_mask_write(0xFD080F00, 0xFFFFFFFFU, 0x80803660U);
psu_mask_write(0xFD080F04, 0xFFFFFFFFU, 0x55556000U);
psu_mask_write(0xFD080F08, 0xFFFFFFFFU, 0xAAAAAAAAU);
psu_mask_write(0xFD080F0C, 0xFFFFFFFFU, 0x0029A4A4U);
psu_mask_write(0xFD080F10, 0xFFFFFFFFU, 0x0C00B000U);
psu_mask_write(0xFD080F14, 0xFFFFFFFFU, 0x09094F4FU);
psu_mask_write(0xFD080F18, 0xFFFFFFFFU, 0x09092B2BU);
psu_mask_write(0xFD081400, 0xFFFFFFFFU, 0x2A019FFEU);
psu_mask_write(0xFD081404, 0xFFFFFFFFU, 0x01100000U);
psu_mask_write(0xFD08141C, 0xFFFFFFFFU, 0x01264300U);
psu_mask_write(0xFD08142C, 0xFFFFFFFFU, 0x00041800U);
psu_mask_write(0xFD081430, 0xFFFFFFFFU, 0x70800000U);
psu_mask_write(0xFD081440, 0xFFFFFFFFU, 0x2A019FFEU);
psu_mask_write(0xFD081444, 0xFFFFFFFFU, 0x01100000U);
psu_mask_write(0xFD08145C, 0xFFFFFFFFU, 0x01264300U);
psu_mask_write(0xFD08146C, 0xFFFFFFFFU, 0x00041800U);
psu_mask_write(0xFD081470, 0xFFFFFFFFU, 0x70800000U);
psu_mask_write(0xFD081480, 0xFFFFFFFFU, 0x15019FFEU);
psu_mask_write(0xFD081484, 0xFFFFFFFFU, 0x21100000U);
psu_mask_write(0xFD08149C, 0xFFFFFFFFU, 0x01266300U);
psu_mask_write(0xFD0814AC, 0xFFFFFFFFU, 0x00041800U);
psu_mask_write(0xFD0814B0, 0xFFFFFFFFU, 0x70400000U);
psu_mask_write(0xFD0814C0, 0xFFFFFFFFU, 0x15019FFEU);
psu_mask_write(0xFD0814C4, 0xFFFFFFFFU, 0x21100000U);
psu_mask_write(0xFD0814DC, 0xFFFFFFFFU, 0x01266300U);
psu_mask_write(0xFD0814EC, 0xFFFFFFFFU, 0x00041800U);
psu_mask_write(0xFD0814F0, 0xFFFFFFFFU, 0x70400000U);
psu_mask_write(0xFD081500, 0xFFFFFFFFU, 0x15019FFEU);
psu_mask_write(0xFD081504, 0xFFFFFFFFU, 0x21100000U);
psu_mask_write(0xFD08151C, 0xFFFFFFFFU, 0x01266300U);
psu_mask_write(0xFD08152C, 0xFFFFFFFFU, 0x00041800U);
psu_mask_write(0xFD081530, 0xFFFFFFFFU, 0x70400000U);
psu_mask_write(0xFD0817DC, 0xFFFFFFFFU, 0x012643C4U);
return 1;
}
static unsigned long psu_ddr_qos_init_data(void)
{
psu_mask_write(0xFD360008, 0x0000000FU, 0x00000000U);
psu_mask_write(0xFD36001C, 0x0000000FU, 0x00000000U);
psu_mask_write(0xFD370008, 0x0000000FU, 0x00000000U);
psu_mask_write(0xFD37001C, 0x0000000FU, 0x00000000U);
psu_mask_write(0xFD380008, 0x0000000FU, 0x00000000U);
psu_mask_write(0xFD38001C, 0x0000000FU, 0x00000000U);
psu_mask_write(0xFD390008, 0x0000000FU, 0x00000000U);
psu_mask_write(0xFD39001C, 0x0000000FU, 0x00000000U);
psu_mask_write(0xFD3A0008, 0x0000000FU, 0x00000000U);
psu_mask_write(0xFD3A001C, 0x0000000FU, 0x00000000U);
psu_mask_write(0xFD3B0008, 0x0000000FU, 0x00000000U);
psu_mask_write(0xFD3B001C, 0x0000000FU, 0x00000000U);
psu_mask_write(0xFF9B0008, 0x0000000FU, 0x00000000U);
psu_mask_write(0xFF9B001C, 0x0000000FU, 0x00000000U);
return 1;
}
static unsigned long psu_mio_init_data(void)
{
psu_mask_write(0xFF180034, 0x000000FEU, 0x00000008U);
psu_mask_write(0xFF180038, 0x000000FEU, 0x00000008U);
psu_mask_write(0xFF18003C, 0x000000FEU, 0x00000008U);
psu_mask_write(0xFF180040, 0x000000FEU, 0x00000008U);
psu_mask_write(0xFF180044, 0x000000FEU, 0x00000008U);
psu_mask_write(0xFF180048, 0x000000FEU, 0x00000008U);
psu_mask_write(0xFF18004C, 0x000000FEU, 0x00000008U);
psu_mask_write(0xFF180050, 0x000000FEU, 0x00000008U);
psu_mask_write(0xFF180054, 0x000000FEU, 0x00000008U);
psu_mask_write(0xFF180058, 0x000000FEU, 0x00000008U);
psu_mask_write(0xFF18005C, 0x000000FEU, 0x00000008U);
psu_mask_write(0xFF180068, 0x000000FEU, 0x00000080U);
psu_mask_write(0xFF18006C, 0x000000FEU, 0x00000000U);
psu_mask_write(0xFF180070, 0x000000FEU, 0x00000000U);
psu_mask_write(0xFF180074, 0x000000FEU, 0x00000080U);
psu_mask_write(0xFF180078, 0x000000FEU, 0x00000080U);
psu_mask_write(0xFF18007C, 0x000000FEU, 0x00000080U);
psu_mask_write(0xFF180080, 0x000000FEU, 0x00000000U);
psu_mask_write(0xFF180084, 0x000000FEU, 0x00000000U);
psu_mask_write(0xFF180088, 0x000000FEU, 0x00000040U);
psu_mask_write(0xFF18008C, 0x000000FEU, 0x00000040U);
psu_mask_write(0xFF180090, 0x000000FEU, 0x00000000U);
psu_mask_write(0xFF180094, 0x000000FEU, 0x00000000U);
psu_mask_write(0xFF180098, 0x000000FEU, 0x000000C0U);
psu_mask_write(0xFF18009C, 0x000000FEU, 0x000000C0U);
psu_mask_write(0xFF1800A0, 0x000000FEU, 0x00000000U);
psu_mask_write(0xFF1800A4, 0x000000FEU, 0x00000000U);
psu_mask_write(0xFF1800A8, 0x000000FEU, 0x00000000U);
psu_mask_write(0xFF1800AC, 0x000000FEU, 0x00000000U);
psu_mask_write(0xFF1800B0, 0x000000FEU, 0x00000000U);
psu_mask_write(0xFF1800B4, 0x000000FEU, 0x00000010U);
psu_mask_write(0xFF1800B8, 0x000000FEU, 0x00000010U);
psu_mask_write(0xFF1800BC, 0x000000FEU, 0x00000010U);
psu_mask_write(0xFF1800C0, 0x000000FEU, 0x00000010U);
psu_mask_write(0xFF1800C4, 0x000000FEU, 0x00000010U);
psu_mask_write(0xFF1800C8, 0x000000FEU, 0x00000010U);
psu_mask_write(0xFF1800CC, 0x000000FEU, 0x00000010U);
psu_mask_write(0xFF1800D0, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF1800D4, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF1800D8, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF1800DC, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF1800E0, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF1800E4, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF1800E8, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF1800EC, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF1800F0, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF1800F4, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF1800F8, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF1800FC, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF180100, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF180104, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF180108, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF18010C, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF180110, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF180114, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF180118, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF18011C, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF180120, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF180124, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF180128, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF18012C, 0x000000FEU, 0x00000004U);
psu_mask_write(0xFF180130, 0x000000FEU, 0x00000060U);
psu_mask_write(0xFF180134, 0x000000FEU, 0x00000060U);
psu_mask_write(0xFF180204, 0xFCFFE000U, 0x00000000U);
psu_mask_write(0xFF180208, 0xFFFFFFFFU, 0x00B02040U);
psu_mask_write(0xFF18020C, 0x00003FFFU, 0x0000000BU);
psu_mask_write(0xFF180138, 0x03FFFFFFU, 0x03FFFFFFU);
psu_mask_write(0xFF18013C, 0x03FFFFFFU, 0x03FFFFFFU);
psu_mask_write(0xFF180140, 0x03FFFFFFU, 0x033FFFFFU);
psu_mask_write(0xFF180144, 0x03FFFFFFU, 0x03FFFFFFU);
psu_mask_write(0xFF180148, 0x03FFFFFFU, 0x03FFFFFFU);
psu_mask_write(0xFF18014C, 0x03FFFFFFU, 0x03FFFFFFU);
psu_mask_write(0xFF180154, 0x03FFFFFFU, 0x03FFFFFFU);
psu_mask_write(0xFF180158, 0x03FFFFFFU, 0x03FFFFFFU);
psu_mask_write(0xFF18015C, 0x03FFFFFFU, 0x01FF9FFFU);
psu_mask_write(0xFF180160, 0x03FFFFFFU, 0x03FFFFFFU);
psu_mask_write(0xFF180164, 0x03FFFFFFU, 0x03FFFFFFU);
psu_mask_write(0xFF180168, 0x03FFFFFFU, 0x03F76FFFU);
psu_mask_write(0xFF180170, 0x03FFFFFFU, 0x03FFFFFFU);
psu_mask_write(0xFF180174, 0x03FFFFFFU, 0x03FFFFFFU);
psu_mask_write(0xFF180178, 0x03FFFFFFU, 0x02FBFFBFU);
psu_mask_write(0xFF18017C, 0x03FFFFFFU, 0x03FFFFFFU);
psu_mask_write(0xFF180180, 0x03FFFFFFU, 0x03FFFFFFU);
psu_mask_write(0xFF180184, 0x03FFFFFFU, 0x03FF4FF4U);
psu_mask_write(0xFF180200, 0x0000000FU, 0x00000000U);
return 1;
}
static unsigned long psu_peripherals_pre_init_data(void)
{
psu_mask_write(0xFF5E0108, 0x013F3F07U, 0x01012302U);
return 1;
}
static unsigned long psu_peripherals_init_data(void)
{
psu_mask_write(0xFD1A0100, 0x0000807CU, 0x00000000U);
psu_mask_write(0xFF5E0238, 0x001A0000U, 0x00000000U);
psu_mask_write(0xFF5E023C, 0x0093C018U, 0x00000000U);
psu_mask_write(0xFF5E0230, 0x00000001U, 0x00000000U);
psu_mask_write(0xFF5E023C, 0x00000C00U, 0x00000000U);
psu_mask_write(0xFF5E0238, 0x00000060U, 0x00000000U);
psu_mask_write(0xFF180310, 0x00008001U, 0x00000001U);
psu_mask_write(0xFF180320, 0x33843384U, 0x00801284U);
psu_mask_write(0xFF18031C, 0x00007FFEU, 0x00006450U);
psu_mask_write(0xFF180358, 0x00080000U, 0x00080000U);
psu_mask_write(0xFF18031C, 0x7FFE0000U, 0x64500000U);
psu_mask_write(0xFF180358, 0x00000008U, 0x00000008U);
psu_mask_write(0xFF180324, 0x000003C0U, 0x00000000U);
psu_mask_write(0xFF180324, 0x03C00000U, 0x00000000U);
psu_mask_write(0xFF5E0238, 0x00000200U, 0x00000000U);
psu_mask_write(0xFF5E0238, 0x00008000U, 0x00000000U);
psu_mask_write(0xFF5E0238, 0x00000008U, 0x00000000U);
psu_mask_write(0xFF5E0238, 0x00007800U, 0x00000000U);
psu_mask_write(0xFF5E0238, 0x00000002U, 0x00000000U);
psu_mask_write(0xFF000034, 0x000000FFU, 0x00000005U);
psu_mask_write(0xFF000018, 0x0000FFFFU, 0x0000008FU);
psu_mask_write(0xFF000000, 0x000001FFU, 0x00000017U);
psu_mask_write(0xFF000004, 0x000003FFU, 0x00000020U);
psu_mask_write(0xFF5E0238, 0x00040000U, 0x00000000U);
psu_mask_write(0xFF4B0024, 0x000000FFU, 0x000000FFU);
psu_mask_write(0xFFCA5000, 0x00001FFFU, 0x00000000U);
psu_mask_write(0xFD5C0060, 0x000F000FU, 0x00000000U);
psu_mask_write(0xFFA60040, 0x80000000U, 0x80000000U);
psu_mask_write(0xFF260020, 0xFFFFFFFFU, 0x01FC9F08U);
psu_mask_write(0xFF260000, 0x00000001U, 0x00000001U);
psu_mask_write(0xFF5E0250, 0x00000F0FU, 0x00000202U);
mask_delay(1);
psu_mask_write(0xFF5E0250, 0x00000F0FU, 0x00000002U);
mask_delay(5);
psu_mask_write(0xFF5E0250, 0x00000F0FU, 0x00000202U);
return 1;
}
static unsigned long psu_serdes_init_data(void)
{
psu_mask_write(0xFD410000, 0x0000001FU, 0x0000000FU);
psu_mask_write(0xFD410004, 0x0000001FU, 0x00000008U);
psu_mask_write(0xFD402860, 0x00000080U, 0x00000080U);
psu_mask_write(0xFD402864, 0x00000080U, 0x00000080U);
psu_mask_write(0xFD406094, 0x00000010U, 0x00000010U);
psu_mask_write(0xFD406368, 0x000000FFU, 0x00000038U);
psu_mask_write(0xFD40636C, 0x00000007U, 0x00000003U);
psu_mask_write(0xFD406370, 0x000000FFU, 0x000000F4U);
psu_mask_write(0xFD406374, 0x000000FFU, 0x00000031U);
psu_mask_write(0xFD406378, 0x000000FFU, 0x00000002U);
psu_mask_write(0xFD40637C, 0x00000033U, 0x00000030U);
psu_mask_write(0xFD40106C, 0x0000000FU, 0x0000000FU);
psu_mask_write(0xFD4000F4, 0x0000000BU, 0x0000000BU);
psu_mask_write(0xFD40506C, 0x00000003U, 0x00000003U);
psu_mask_write(0xFD4040F4, 0x00000003U, 0x00000003U);
psu_mask_write(0xFD4050CC, 0x00000020U, 0x00000020U);
psu_mask_write(0xFD401074, 0x00000010U, 0x00000010U);
psu_mask_write(0xFD405074, 0x00000010U, 0x00000010U);
psu_mask_write(0xFD409074, 0x00000010U, 0x00000010U);
psu_mask_write(0xFD40D074, 0x00000010U, 0x00000010U);
psu_mask_write(0xFD40189C, 0x00000080U, 0x00000080U);
psu_mask_write(0xFD4018F8, 0x000000FFU, 0x0000007DU);
psu_mask_write(0xFD4018FC, 0x000000FFU, 0x0000007DU);
psu_mask_write(0xFD401990, 0x000000FFU, 0x00000000U);
psu_mask_write(0xFD401924, 0x000000FFU, 0x00000082U);
psu_mask_write(0xFD401928, 0x000000FFU, 0x00000000U);
psu_mask_write(0xFD401900, 0x000000FFU, 0x00000064U);
psu_mask_write(0xFD40192C, 0x000000FFU, 0x00000000U);
psu_mask_write(0xFD401980, 0x000000FFU, 0x000000FFU);
psu_mask_write(0xFD401914, 0x000000FFU, 0x000000FFU);
psu_mask_write(0xFD401918, 0x00000001U, 0x00000001U);
psu_mask_write(0xFD401940, 0x000000FFU, 0x000000FFU);
psu_mask_write(0xFD401944, 0x00000001U, 0x00000001U);
psu_mask_write(0xFD401994, 0x00000007U, 0x00000007U);
psu_mask_write(0xFD40589C, 0x00000080U, 0x00000080U);
psu_mask_write(0xFD4058F8, 0x000000FFU, 0x0000001AU);
psu_mask_write(0xFD4058FC, 0x000000FFU, 0x0000001AU);
psu_mask_write(0xFD405990, 0x000000FFU, 0x00000010U);
psu_mask_write(0xFD405924, 0x000000FFU, 0x000000FEU);
psu_mask_write(0xFD405928, 0x000000FFU, 0x00000000U);
psu_mask_write(0xFD405900, 0x000000FFU, 0x0000001AU);
psu_mask_write(0xFD40592C, 0x000000FFU, 0x00000000U);
psu_mask_write(0xFD405980, 0x000000FFU, 0x000000FFU);
psu_mask_write(0xFD405914, 0x000000FFU, 0x000000F7U);
psu_mask_write(0xFD405918, 0x00000001U, 0x00000001U);
psu_mask_write(0xFD405940, 0x000000FFU, 0x000000F7U);
psu_mask_write(0xFD405944, 0x00000001U, 0x00000001U);
psu_mask_write(0xFD405994, 0x00000007U, 0x00000007U);
psu_mask_write(0xFD409994, 0x00000007U, 0x00000007U);
psu_mask_write(0xFD40D994, 0x00000007U, 0x00000007U);
psu_mask_write(0xFD40107C, 0x0000000FU, 0x00000001U);
psu_mask_write(0xFD40507C, 0x0000000FU, 0x00000001U);
psu_mask_write(0xFD40907C, 0x0000000FU, 0x00000001U);
psu_mask_write(0xFD40D07C, 0x0000000FU, 0x00000001U);
psu_mask_write(0xFD4019A4, 0x000000FFU, 0x000000FFU);
psu_mask_write(0xFD401038, 0x00000040U, 0x00000040U);
psu_mask_write(0xFD40102C, 0x00000040U, 0x00000040U);
psu_mask_write(0xFD4059A4, 0x000000FFU, 0x000000FFU);
psu_mask_write(0xFD405038, 0x00000040U, 0x00000040U);
psu_mask_write(0xFD40502C, 0x00000040U, 0x00000040U);
psu_mask_write(0xFD4099A4, 0x000000FFU, 0x000000FFU);
psu_mask_write(0xFD409038, 0x00000040U, 0x00000040U);
psu_mask_write(0xFD40902C, 0x00000040U, 0x00000040U);
psu_mask_write(0xFD40D9A4, 0x000000FFU, 0x000000FFU);
psu_mask_write(0xFD40D038, 0x00000040U, 0x00000040U);
psu_mask_write(0xFD40D02C, 0x00000040U, 0x00000040U);
psu_mask_write(0xFD4019AC, 0x00000003U, 0x00000000U);
psu_mask_write(0xFD4059AC, 0x00000003U, 0x00000000U);
psu_mask_write(0xFD4099AC, 0x00000003U, 0x00000000U);
psu_mask_write(0xFD40D9AC, 0x00000003U, 0x00000000U);
psu_mask_write(0xFD401978, 0x00000010U, 0x00000010U);
psu_mask_write(0xFD405978, 0x00000010U, 0x00000010U);
psu_mask_write(0xFD409978, 0x00000010U, 0x00000010U);
psu_mask_write(0xFD40D978, 0x00000010U, 0x00000010U);
psu_mask_write(0xFD410010, 0x00000077U, 0x00000035U);
psu_mask_write(0xFD410040, 0x00000003U, 0x00000000U);
psu_mask_write(0xFD410044, 0x00000003U, 0x00000000U);
return 1;
}
static unsigned long psu_resetout_init_data(void)
{
psu_mask_write(0xFF5E023C, 0x00000400U, 0x00000000U);
psu_mask_write(0xFF9D0080, 0x00000001U, 0x00000001U);
psu_mask_write(0xFF9D007C, 0x00000001U, 0x00000000U);
psu_mask_write(0xFF5E023C, 0x00000140U, 0x00000000U);
psu_mask_write(0xFF5E023C, 0x00000800U, 0x00000000U);
psu_mask_write(0xFF9E0080, 0x00000001U, 0x00000001U);
psu_mask_write(0xFF9E007C, 0x00000001U, 0x00000001U);
psu_mask_write(0xFF5E023C, 0x00000280U, 0x00000000U);
psu_mask_write(0xFF5E0230, 0x00000001U, 0x00000000U);
psu_mask_write(0xFE20C200, 0x00023FFFU, 0x00022457U);
psu_mask_write(0xFE20C630, 0x003FFF00U, 0x00000000U);
psu_mask_write(0xFE20C11C, 0x00000600U, 0x00000600U);
psu_mask_write(0xFE20C12C, 0x00004000U, 0x00004000U);
psu_mask_write(0xFE30C200, 0x00023FFFU, 0x00022457U);
psu_mask_write(0xFE30C630, 0x003FFF00U, 0x00000000U);
psu_mask_write(0xFE30C12C, 0x00004000U, 0x00004000U);
psu_mask_write(0xFE30C11C, 0x00000400U, 0x00000400U);
psu_mask_write(0xFD480064, 0x00000200U, 0x00000200U);
mask_poll(0xFD4023E4, 0x00000010U);
mask_poll(0xFD4063E4, 0x00000010U);
return 1;
}
static unsigned long psu_resetin_init_data(void)
{
psu_mask_write(0xFF5E023C, 0x00000540U, 0x00000540U);
psu_mask_write(0xFF5E023C, 0x00000A80U, 0x00000A80U);
psu_mask_write(0xFF5E0230, 0x00000001U, 0x00000001U);
return 1;
}
static unsigned long psu_afi_config(void)
{
psu_mask_write(0xFD1A0100, 0x00001F80U, 0x00000000U);
psu_mask_write(0xFF5E023C, 0x00080000U, 0x00000000U);
psu_mask_write(0xFD615000, 0x00000F00U, 0x00000A00U);
psu_mask_write(0xFF419000, 0x00000300U, 0x00000000U);
psu_mask_write(0xFD360000, 0x00000003U, 0x00000000U);
psu_mask_write(0xFD360014, 0x00000003U, 0x00000000U);
return 1;
}
static unsigned long psu_ddr_phybringup_data(void)
{
unsigned int regval = 0;
unsigned int pll_retry = 10;
unsigned int pll_locked = 0;
int cur_r006_trefprd;
while ((pll_retry > 0) && (!pll_locked)) {
Xil_Out32(0xFD080004, 0x00040010);
Xil_Out32(0xFD080004, 0x00040011);
while ((Xil_In32(0xFD080030) & 0x1) != 1)
;
pll_locked = (Xil_In32(0xFD080030) & 0x80000000)
>> 31;
pll_locked &= (Xil_In32(0xFD0807E0) & 0x10000)
>> 16;
pll_locked &= (Xil_In32(0xFD0809E0) & 0x10000)
>> 16;
pll_retry--;
}
Xil_Out32(0xFD0800C4, Xil_In32(0xFD0800C4) | (pll_retry << 16));
if (!pll_locked)
return 0;
Xil_Out32(0xFD080004U, 0x00040063U);
while ((Xil_In32(0xFD080030U) & 0x0000000FU) != 0x0000000FU)
;
prog_reg(0xFD080004U, 0x00000001U, 0x00000000U, 0x00000001U);
while ((Xil_In32(0xFD080030U) & 0x000000FFU) != 0x0000001FU)
;
Xil_Out32(0xFD0701B0U, 0x00000001U);
Xil_Out32(0xFD070320U, 0x00000001U);
while ((Xil_In32(0xFD070004U) & 0x0000000FU) != 0x00000001U)
;
prog_reg(0xFD080014U, 0x00000040U, 0x00000006U, 0x00000001U);
Xil_Out32(0xFD080004, 0x0004FE01);
regval = Xil_In32(0xFD080030);
while (regval != 0x80000FFF)
regval = Xil_In32(0xFD080030);
regval = ((Xil_In32(0xFD080030) & 0x1FFF0000) >> 18);
if (regval != 0)
return 0;
Xil_Out32(0xFD080200U, 0x110091C7U);
cur_r006_trefprd = (Xil_In32(0xFD080018U) & 0x0003FFFFU) >> 0x00000000U;
prog_reg(0xFD080018, 0x3FFFF, 0x0, cur_r006_trefprd);
prog_reg(0xFD08001CU, 0x00000018U, 0x00000003U, 0x00000003U);
prog_reg(0xFD08142CU, 0x00000030U, 0x00000004U, 0x00000003U);
prog_reg(0xFD08146CU, 0x00000030U, 0x00000004U, 0x00000003U);
prog_reg(0xFD0814ACU, 0x00000030U, 0x00000004U, 0x00000003U);
prog_reg(0xFD0814ECU, 0x00000030U, 0x00000004U, 0x00000003U);
prog_reg(0xFD08152CU, 0x00000030U, 0x00000004U, 0x00000003U);
Xil_Out32(0xFD080004, 0x00060001);
regval = Xil_In32(0xFD080030);
while ((regval & 0x80004001) != 0x80004001)
regval = Xil_In32(0xFD080030);
prog_reg(0xFD08001CU, 0x00000018U, 0x00000003U, 0x00000000U);
prog_reg(0xFD08142CU, 0x00000030U, 0x00000004U, 0x00000000U);
prog_reg(0xFD08146CU, 0x00000030U, 0x00000004U, 0x00000000U);
prog_reg(0xFD0814ACU, 0x00000030U, 0x00000004U, 0x00000000U);
prog_reg(0xFD0814ECU, 0x00000030U, 0x00000004U, 0x00000000U);
prog_reg(0xFD08152CU, 0x00000030U, 0x00000004U, 0x00000000U);
Xil_Out32(0xFD080200U, 0x810091C7U);
prog_reg(0xFD080018, 0x3FFFF, 0x0, cur_r006_trefprd);
Xil_Out32(0xFD080004, 0x0000C001);
regval = Xil_In32(0xFD080030);
while ((regval & 0x80000C01) != 0x80000C01)
regval = Xil_In32(0xFD080030);
Xil_Out32(0xFD070180U, 0x01000040U);
Xil_Out32(0xFD070060U, 0x00000000U);
prog_reg(0xFD080014U, 0x00000040U, 0x00000006U, 0x00000000U);
return 1;
}
static int serdes_enb_coarse_saturation(void)
{
Xil_Out32(0xFD402094, 0x00000010);
Xil_Out32(0xFD406094, 0x00000010);
Xil_Out32(0xFD40A094, 0x00000010);
Xil_Out32(0xFD40E094, 0x00000010);
return 1;
}
static int serdes_fixcal_code(void)
{
int maskstatus = 1;
unsigned int rdata = 0;
unsigned int match_pmos_code[23];
unsigned int match_nmos_code[23];
unsigned int match_ical_code[7];
unsigned int match_rcal_code[7];
unsigned int p_code = 0, n_code = 0, i_code = 0, r_code = 0;
unsigned int repeat_count = 0;
unsigned int L3_TM_CALIB_DIG20 = 0;
unsigned int L3_TM_CALIB_DIG19 = 0;
unsigned int L3_TM_CALIB_DIG18 = 0;
unsigned int L3_TM_CALIB_DIG16 = 0;
unsigned int L3_TM_CALIB_DIG15 = 0;
unsigned int L3_TM_CALIB_DIG14 = 0;
int count = 0, i = 0;
rdata = Xil_In32(0xFD40289C);
rdata = rdata & ~0x03;
rdata = rdata | 0x1;
Xil_Out32(0xFD40289C, rdata);
do {
if (count == 1100000)
break;
rdata = Xil_In32(0xFD402B1C);
count++;
} while ((rdata & 0x0000000E) != 0x0000000E);
for (i = 0; i < 23; i++) {
match_pmos_code[i] = 0;
match_nmos_code[i] = 0;
}
for (i = 0; i < 7; i++) {
match_ical_code[i] = 0;
match_rcal_code[i] = 0;
}
do {
Xil_Out32(0xFD410010, 0x00000000);
Xil_Out32(0xFD410014, 0x00000000);
Xil_Out32(0xFD410010, 0x00000001);
Xil_Out32(0xFD410014, 0x00000000);
maskstatus = mask_poll(0xFD40EF14, 0x2);
if (maskstatus == 0) {
xil_printf("#SERDES initialization timed out\n\r");
return maskstatus;
}
p_code = mask_read(0xFD40EF18, 0xFFFFFFFF);
n_code = mask_read(0xFD40EF1C, 0xFFFFFFFF);
;
i_code = mask_read(0xFD40EF24, 0xFFFFFFFF);
r_code = mask_read(0xFD40EF28, 0xFFFFFFFF);
;
if (p_code >= 0x26 && p_code <= 0x3C)
match_pmos_code[p_code - 0x26] += 1;
if (n_code >= 0x26 && n_code <= 0x3C)
match_nmos_code[n_code - 0x26] += 1;
if (i_code >= 0xC && i_code <= 0x12)
match_ical_code[i_code - 0xc] += 1;
if (r_code >= 0x6 && r_code <= 0xC)
match_rcal_code[r_code - 0x6] += 1;
} while (repeat_count++ < 10);
for (i = 0; i < 23; i++) {
if (match_pmos_code[i] >= match_pmos_code[0]) {
match_pmos_code[0] = match_pmos_code[i];
p_code = 0x26 + i;
}
if (match_nmos_code[i] >= match_nmos_code[0]) {
match_nmos_code[0] = match_nmos_code[i];
n_code = 0x26 + i;
}
}
for (i = 0; i < 7; i++) {
if (match_ical_code[i] >= match_ical_code[0]) {
match_ical_code[0] = match_ical_code[i];
i_code = 0xC + i;
}
if (match_rcal_code[i] >= match_rcal_code[0]) {
match_rcal_code[0] = match_rcal_code[i];
r_code = 0x6 + i;
}
}
L3_TM_CALIB_DIG20 = mask_read(0xFD40EC50, 0xFFFFFFF0);
L3_TM_CALIB_DIG20 = L3_TM_CALIB_DIG20 | 0x8 | ((p_code >> 2) & 0x7);
L3_TM_CALIB_DIG19 = mask_read(0xFD40EC4C, 0xFFFFFF18);
L3_TM_CALIB_DIG19 = L3_TM_CALIB_DIG19 | ((p_code & 0x3) << 6)
| 0x20 | 0x4 | ((n_code >> 3) & 0x3);
L3_TM_CALIB_DIG18 = mask_read(0xFD40EC48, 0xFFFFFF0F);
L3_TM_CALIB_DIG18 = L3_TM_CALIB_DIG18 | ((n_code & 0x7) << 5) | 0x10;
L3_TM_CALIB_DIG16 = mask_read(0xFD40EC40, 0xFFFFFFF8);
L3_TM_CALIB_DIG16 = L3_TM_CALIB_DIG16 | ((r_code >> 1) & 0x7);
L3_TM_CALIB_DIG15 = mask_read(0xFD40EC3C, 0xFFFFFF30);
L3_TM_CALIB_DIG15 = L3_TM_CALIB_DIG15 | ((r_code & 0x1) << 7)
| 0x40 | 0x8 | ((i_code >> 1) & 0x7);
L3_TM_CALIB_DIG14 = mask_read(0xFD40EC38, 0xFFFFFF3F);
L3_TM_CALIB_DIG14 = L3_TM_CALIB_DIG14 | ((i_code & 0x1) << 7) | 0x40;
Xil_Out32(0xFD40EC50, L3_TM_CALIB_DIG20);
Xil_Out32(0xFD40EC4C, L3_TM_CALIB_DIG19);
Xil_Out32(0xFD40EC48, L3_TM_CALIB_DIG18);
Xil_Out32(0xFD40EC40, L3_TM_CALIB_DIG16);
Xil_Out32(0xFD40EC3C, L3_TM_CALIB_DIG15);
Xil_Out32(0xFD40EC38, L3_TM_CALIB_DIG14);
return maskstatus;
}
static int init_serdes(void)
{
int status = 1;
status &= psu_resetin_init_data();
status &= serdes_fixcal_code();
status &= serdes_enb_coarse_saturation();
status &= psu_serdes_init_data();
status &= psu_resetout_init_data();
return status;
}
static void init_peripheral(void)
{
psu_mask_write(0xFD5F0018, 0x8000001FU, 0x8000001FU);
}
int psu_init(void)
{
int status = 1;
status &= psu_mio_init_data();
status &= psu_peripherals_pre_init_data();
status &= psu_pll_init_data();
status &= psu_clock_init_data();
status &= psu_ddr_init_data();
status &= psu_ddr_phybringup_data();
status &= psu_peripherals_init_data();
status &= init_serdes();
init_peripheral();
status &= psu_afi_config();
psu_ddr_qos_init_data();
if (status == 0)
return 1;
return 0;
}

48
board/xilinx/zynqmp/zynqmp.c
View file

@ -358,6 +358,21 @@ static int multi_boot(void)
return multiboot;
}
#if defined(CONFIG_SPL_BUILD)
static void restore_jtag(void)
{
if (current_el() != 3)
return;
writel(CSU_JTAG_SEC_GATE_DISABLE, &csu_base->jtag_sec);
writel(CSU_JTAG_DAP_ENABLE_DEBUG, &csu_base->jtag_dap_cfg);
writel(CSU_JTAG_CHAIN_WR_SETUP, &csu_base->jtag_chain_status_wr);
writel(CRLAPB_DBG_LPD_CTRL_SETUP_CLK, &crlapb_base->dbg_lpd_ctrl);
writel(CRLAPB_RST_LPD_DBG_RESET, &crlapb_base->rst_lpd_dbg);
writel(CSU_PCAP_PROG_RELEASE_PL, &csu_base->pcap_prog);
}
#endif
#define PS_SYSMON_ANALOG_BUS_VAL 0x3210
#define PS_SYSMON_ANALOG_BUS_REG 0xFFA50914
@ -377,6 +392,10 @@ int board_init(void)
zynqmp_pmufw_load_config_object(zynqmp_pm_cfg_obj,
zynqmp_pm_cfg_obj_size);
printf("Silicon version:\t%d\n", zynqmp_get_silicon_version());
/* the CSU disables the JTAG interface when secure boot is enabled */
if (CONFIG_IS_ENABLED(ZYNQMP_RESTORE_JTAG))
restore_jtag();
#else
if (CONFIG_IS_ENABLED(DM_I2C) && CONFIG_IS_ENABLED(I2C_EEPROM))
xilinx_read_eeprom();
@ -477,7 +496,7 @@ ulong board_get_usable_ram_top(ulong total_size)
lmb_init(&lmb);
lmb_add(&lmb, gd->ram_base, gd->ram_size);
boot_fdt_add_mem_rsv_regions(&lmb, (void *)gd->fdt_blob);
size = ALIGN(CONFIG_SYS_MALLOC_LEN + total_size, MMU_SECTION_SIZE),
size = ALIGN(CONFIG_SYS_MALLOC_LEN + total_size, MMU_SECTION_SIZE);
reg = lmb_alloc(&lmb, size, MMU_SECTION_SIZE);
if (!reg)
@ -621,7 +640,7 @@ int board_late_init(void)
const char *mode;
char *new_targets;
char *env_targets;
int ret;
int ret, multiboot;
#if defined(CONFIG_USB_ETHER) && !defined(CONFIG_USB_GADGET_DOWNLOAD)
usb_ether_init();
@ -639,6 +658,10 @@ int board_late_init(void)
if (ret)
return ret;
multiboot = multi_boot();
if (multiboot >= 0)
env_set_hex("multiboot", multiboot);
bootmode = zynqmp_get_bootmode();
puts("Bootmode: ");
@ -691,7 +714,7 @@ int board_late_init(void)
break;
case SD1_LSHFT_MODE:
puts("LVL_SHFT_");
/* fall through */
fallthrough;
case SD_MODE1:
puts("SD_MODE1\n");
if (uclass_get_device_by_name(UCLASS_MMC,
@ -845,6 +868,10 @@ void set_dfu_alt_info(char *interface, char *devstr)
memset(buf, 0, sizeof(buf));
multiboot = multi_boot();
if (multiboot < 0)
multiboot = 0;
multiboot = env_get_hex("multiboot", multiboot);
debug("Multiboot: %d\n", multiboot);
switch (zynqmp_get_bootmode()) {
@ -856,20 +883,23 @@ void set_dfu_alt_info(char *interface, char *devstr)
if (!multiboot)
snprintf(buf, DFU_ALT_BUF_LEN,
"mmc %d:1=boot.bin fat %d 1;"
"u-boot.itb fat %d 1",
bootseq, bootseq, bootseq);
"%s fat %d 1",
bootseq, bootseq,
CONFIG_SPL_FS_LOAD_PAYLOAD_NAME, bootseq);
else
snprintf(buf, DFU_ALT_BUF_LEN,
"mmc %d:1=boot%04d.bin fat %d 1;"
"u-boot.itb fat %d 1",
bootseq, multiboot, bootseq, bootseq);
"%s fat %d 1",
bootseq, multiboot, bootseq,
CONFIG_SPL_FS_LOAD_PAYLOAD_NAME, bootseq);
break;
case QSPI_MODE_24BIT:
case QSPI_MODE_32BIT:
snprintf(buf, DFU_ALT_BUF_LEN,
"sf 0:0=boot.bin raw %x 0x1500000;"
"u-boot.itb raw 0x%x 0x500000",
multiboot * SZ_32K, CONFIG_SYS_SPI_U_BOOT_OFFS);
"%s raw 0x%x 0x500000",
multiboot * SZ_32K, CONFIG_SPL_FS_LOAD_PAYLOAD_NAME,
CONFIG_SYS_SPI_U_BOOT_OFFS);
break;
default:
return;

1
boot/image-board.c
View file

@ -14,6 +14,7 @@
#include <env.h>
#include <fpga.h>
#include <image.h>
#include <init.h>
#include <mapmem.h>
#include <rtc.h>
#include <watchdog.h>

6
boot/image.c
View file

@ -9,6 +9,7 @@
#ifndef USE_HOSTCC
#include <common.h>
#include <env.h>
#include <init.h>
#include <lmb.h>
#include <log.h>
#include <malloc.h>
@ -29,11 +30,6 @@
#include <linux/errno.h>
#include <asm/io.h>
#ifdef CONFIG_CMD_BDI
extern int do_bdinfo(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[]);
#endif
DECLARE_GLOBAL_DATA_PTR;
/* Set this if we have less than 4 MB of malloc() space */

17
cmd/tpm-v1.c
View file

@ -406,9 +406,9 @@ static int do_tpm_load_key_by_sha1(struct cmd_tbl *cmdtp, int flag, int argc,
void *key;
struct udevice *dev;
rc = get_tpm(&dev);
if (rc)
return rc;
err = get_tpm(&dev);
if (err)
return err;
if (argc < 5)
return CMD_RET_USAGE;
@ -420,7 +420,7 @@ static int do_tpm_load_key_by_sha1(struct cmd_tbl *cmdtp, int flag, int argc,
return CMD_RET_FAILURE;
parse_byte_string(argv[4], usage_auth, NULL);
err = tpm_find_key_sha1(usage_auth, parent_hash, &parent_handle);
err = tpm1_find_key_sha1(dev, usage_auth, parent_hash, &parent_handle);
if (err) {
printf("Could not find matching parent key (err = %d)\n", err);
return CMD_RET_FAILURE;
@ -428,7 +428,7 @@ static int do_tpm_load_key_by_sha1(struct cmd_tbl *cmdtp, int flag, int argc,
printf("Found parent key %08x\n", parent_handle);
err = tpm_load_key2_oiap(parent_handle, key, key_len, usage_auth,
err = tpm1_load_key2_oiap(dev, parent_handle, key, key_len, usage_auth,
&key_handle);
if (!err) {
printf("Key handle is 0x%x\n", key_handle);
@ -582,6 +582,7 @@ static int do_tpm_flush(struct cmd_tbl *cmdtp, int flag, int argc,
static int do_tpm_list(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
struct udevice *dev;
int type = 0;
u16 res_count;
u8 buf[288];
@ -589,6 +590,10 @@ static int do_tpm_list(struct cmd_tbl *cmdtp, int flag, int argc,
int err;
uint i;
err = get_tpm(&dev);
if (err)
return err;
if (argc != 2)
return CMD_RET_USAGE;
@ -619,7 +624,7 @@ static int do_tpm_list(struct cmd_tbl *cmdtp, int flag, int argc,
}
/* fetch list of already loaded resources in the TPM */
err = tpm_get_capability(TPM_CAP_HANDLE, type, buf,
err = tpm_get_capability(dev, TPM_CAP_HANDLE, type, buf,
sizeof(buf));
if (err) {
printf("tpm_get_capability returned error %d.\n", err);

12
common/board_f.c
View file

@ -673,11 +673,7 @@ static int reloc_bloblist(void)
static int setup_reloc(void)
{
if (gd->flags & GD_FLG_SKIP_RELOC) {
debug("Skipping relocation due to flag\n");
return 0;
}
if (!(gd->flags & GD_FLG_SKIP_RELOC)) {
#ifdef CONFIG_SYS_TEXT_BASE
#ifdef ARM
gd->reloc_off = gd->relocaddr - (unsigned long)__image_copy_start;
@ -691,12 +687,18 @@ static int setup_reloc(void)
gd->reloc_off = gd->relocaddr - CONFIG_SYS_TEXT_BASE;
#endif
#endif
}
memcpy(gd->new_gd, (char *)gd, sizeof(gd_t));
if (gd->flags & GD_FLG_SKIP_RELOC) {
debug("Skipping relocation due to flag\n");
} else {
debug("Relocation Offset is: %08lx\n", gd->reloc_off);
debug("Relocating to %08lx, new gd at %08lx, sp at %08lx\n",
gd->relocaddr, (ulong)map_to_sysmem(gd->new_gd),
gd->start_addr_sp);
}
return 0;
}

2
configs/xilinx_zynqmp_virt_defconfig
View file

@ -81,7 +81,7 @@ CONFIG_CMD_MTDPARTS_SHOW_NET_SIZES=y
CONFIG_CMD_UBI=y
CONFIG_PARTITION_TYPE_GUID=y
CONFIG_SPL_OF_CONTROL=y
CONFIG_OF_LIST="avnet-ultra96-rev1 zynqmp-a2197-revA zynqmp-e-a2197-00-revA zynqmp-g-a2197-00-revA zynqmp-m-a2197-01-revA zynqmp-m-a2197-02-revA zynqmp-m-a2197-03-revA zynqmp-p-a2197-00-revA zynqmp-zc1232-revA zynqmp-zc1254-revA zynqmp-zc1751-xm015-dc1 zynqmp-zc1751-xm016-dc2 zynqmp-zc1751-xm017-dc3 zynqmp-zc1751-xm018-dc4 zynqmp-zc1751-xm019-dc5 zynqmp-zcu100-revC zynqmp-zcu102-rev1.1 zynqmp-zcu102-rev1.0 zynqmp-zcu102-revA zynqmp-zcu102-revB zynqmp-zcu104-revA zynqmp-zcu104-revC zynqmp-zcu106-revA zynqmp-zcu111-revA zynqmp-zcu1275-revA zynqmp-zcu1275-revB zynqmp-zcu1285-revA zynqmp-zcu208-revA zynqmp-zcu216-revA zynqmp-topic-miamimp-xilinx-xdp-v1r1 zynqmp-sm-k26-revA zynqmp-smk-k26-revA"
CONFIG_OF_LIST="avnet-ultra96-rev1 zynqmp-a2197-revA zynqmp-e-a2197-00-revA zynqmp-g-a2197-00-revA zynqmp-m-a2197-01-revA zynqmp-m-a2197-02-revA zynqmp-m-a2197-03-revA zynqmp-p-a2197-00-revA zynqmp-zc1232-revA zynqmp-zc1254-revA zynqmp-zc1751-xm015-dc1 zynqmp-zc1751-xm016-dc2 zynqmp-zc1751-xm017-dc3 zynqmp-zc1751-xm018-dc4 zynqmp-zc1751-xm019-dc5 zynqmp-zcu100-revC zynqmp-zcu102-rev1.1 zynqmp-zcu102-rev1.0 zynqmp-zcu102-revA zynqmp-zcu102-revB zynqmp-zcu104-revA zynqmp-zcu104-revC zynqmp-zcu106-revA zynqmp-zcu111-revA zynqmp-zcu1275-revA zynqmp-zcu1275-revB zynqmp-zcu1285-revA zynqmp-zcu208-revA zynqmp-zcu216-revA zynqmp-topic-miamimp-xilinx-xdp-v1r1 zynqmp-sm-k26-revA zynqmp-smk-k26-revA zynqmp-dlc21-revA"
CONFIG_OF_SPL_REMOVE_PROPS="pinctrl-0 pinctrl-names interrupt-parent interrupts iommus power-domains"
CONFIG_ENV_IS_NOWHERE=y
CONFIG_ENV_IS_IN_FAT=y

7
disk/part.c
View file

@ -668,6 +668,13 @@ int part_get_info_by_name_type(struct blk_desc *dev_desc, const char *name,
part_drv = part_driver_lookup_type(dev_desc);
if (!part_drv)
return -1;
if (!part_drv->get_info) {
log_debug("## Driver %s does not have the get_info() method\n",
part_drv->name);
return -ENOSYS;
}
for (i = 1; i < part_drv->max_entries; i++) {
ret = part_drv->get_info(dev_desc, i, info);
if (ret != 0) {

19
doc/README.usb
View file

@ -18,8 +18,8 @@ How it works:
-------------
The USB (at least the USB UHCI) needs a frame list (4k), transfer
descripor and queue headers which are all located in the main memory.
The UHCI allocates every milisecond the PCI bus and reads the current
descriptor and queue headers which are all located in the main memory.
The UHCI allocates every millisecond the PCI bus and reads the current
frame pointer. This may cause to crash the OS during boot. So the USB
_MUST_ be stopped during OS boot. This is the reason, why the USB is
NOT automatically started during start-up. If someone needs the USB
@ -27,10 +27,10 @@ he has to start it and should therefore be aware that he had to stop
it before booting the OS.
For USB keyboards this can be done by a script which is automatically
started after the U-Boot is up and running. To boot an OS with a an
started after the U-Boot is up and running. To boot an OS with a
USB keyboard another script is necessary, which first disables the
USB and then executes the boot command. If the boot command fails,
the script can reenable the USB kbd.
the script can re-enable the USB keyboard.
Common USB Commands:
- usb start:
@ -40,7 +40,7 @@ Common USB Commands:
- usb info [dev]: shows all USB infos of the device dev, or of all
the devices
- usb stop [f]: stops the USB. If f==1 the USB will also stop if
an USB keyboard is assigned as stdin. The stdin
a USB keyboard is assigned as stdin. The stdin
is then switched to serial input.
Storage USB Commands:
- usb scan: scans the USB for storage devices. The USB must be
@ -124,7 +124,7 @@ bootp
To enable USB Host Ethernet in U-Boot, your platform must of course
support USB with CONFIG_CMD_USB enabled and working. You will need to
add some config settings to your board config:
add some settings to your board configuration:
CONFIG_CMD_USB=y /* the 'usb' interactive command */
CONFIG_USB_HOST_ETHER=y /* Enable USB Ethernet adapters */
@ -158,7 +158,7 @@ settings should start you off:
You can also set the default IP address of your board and the server
as well as the default file to load when a 'bootp' command is issued.
However note that encoding these individual network settings into a
common exectuable is discouraged, as it leads to potential conflicts,
common executable is discouraged, as it leads to potential conflicts,
and all the parameters can either get stored in the board's external
environment, or get obtained from the bootp server if not set.
@ -166,7 +166,6 @@ environment, or get obtained from the bootp server if not set.
#define CONFIG_SERVERIP 10.0.0.1 (replace with your value)
#define CONFIG_BOOTFILE "uImage"
The 'usb start' command should identify the adapter something like this:
CrOS> usb start
@ -211,8 +210,8 @@ MAC Addresses
Most Ethernet dongles have a built-in MAC address which is unique in the
world. This is important so that devices on the network can be
distinguised from each other. MAC address conflicts are evil and
generally result in strange and eratic behaviour.
distinguished from each other. MAC address conflicts are evil and
generally result in strange and erratic behaviour.
Some boards have USB Ethernet chips on-board, and these sometimes do not
have an assigned MAC address. In this case it is up to you to assign

1
doc/api/index.rst
View file

@ -10,6 +10,7 @@ U-Boot API documentation
efi
getopt
linker_lists
lmb
logging
pinctrl
rng

7
doc/api/lmb.rst Normal file
View file

@ -0,0 +1,7 @@
.. SPDX-License-Identifier: GPL-2.0+
Logical memory blocks
=====================
.. kernel-doc:: include/lmb.h
:internal:

2
doc/board/siemens/iot2050.rst
View file

@ -49,7 +49,7 @@ OP-TEE:
.. code-block:: text
$ make PLATFORM=k3-am65x CFG_ARM64_core=y CFG_TEE_CORE_LOG_LEVEL=2 CFG_CONSOLE_UART=1
$ make PLATFORM=k3-am65x CFG_ARM64_core=y CFG_TEE_CORE_LOG_LEVEL=2 CFG_CONSOLE_UART=1 CFG_USER_TA_TARGETS="ta_arm64"
U-Boot:

16
doc/develop/trace.rst
View file

@ -4,7 +4,7 @@
Tracing in U-Boot
=================
U-Boot supports a simple tracing feature which allows a record of excecution
U-Boot supports a simple tracing feature which allows a record of execution
to be collected and sent to a host machine for analysis. At present the
main use for this is to profile boot time.
@ -161,10 +161,10 @@ limit of the trace buffer size you have specified. Once that is exhausted
no more data will be collected.
Collecting trace data has an affect on execution time/performance. You
will notice this particularly with trvial functions - the overhead of
will notice this particularly with trivial functions - the overhead of
recording their execution may even exceed their normal execution time.
In practice this doesn't matter much so long as you are aware of the
effect. Once you have done your optimisations, turn off tracing before
effect. Once you have done your optimizations, turn off tracing before
doing end-to-end timing.
The best time to start tracing is right at the beginning of U-Boot. The
@ -184,7 +184,7 @@ the OS. In practical terms, U-Boot runs the 'fakegocmd' environment
variable at this point. This variable should have a short script which
collects the trace data and writes it somewhere.
Trace data collection relies on a microsecond timer, accesed through
Trace data collection relies on a microsecond timer, accessed through
timer_get_us(). So the first think you should do is make sure that
this produces sensible results for your board. Suitable sources for
this timer include high resolution timers, PWMs or profile timers if
@ -285,7 +285,7 @@ Options
Specify U-Boot map file
-p <trace_file>
Specifiy profile/trace file
Specify profile/trace file
Commands:
@ -315,11 +315,11 @@ time:
2. Build U-Boot with tracing and run it. Note the difference in boot time
(it is common for tracing to add 10% to the time)
3. Collect the trace information as descibed above. Use this to find where
3. Collect the trace information as described above. Use this to find where
all the time is being spent.
4. Take a look at that code and see if you can optimise it. Perhaps it is
possible to speed up the initialisation of a device, or remove an unused
4. Take a look at that code and see if you can optimize it. Perhaps it is
possible to speed up the initialization of a device, or remove an unused
feature.
5. Rebuild, run and collect again. Compare your results.

10
drivers/firmware/firmware-zynqmp.c
View file

@ -29,6 +29,10 @@ static int ipi_req(const u32 *req, size_t req_len, u32 *res, size_t res_maxlen)
{
struct zynqmp_ipi_msg msg;
int ret;
u32 buffer[PAYLOAD_ARG_CNT];
if (!res)
res = buffer;
if (req_len > PMUFW_PAYLOAD_ARG_CNT ||
res_maxlen > PMUFW_PAYLOAD_ARG_CNT)
@ -164,6 +168,7 @@ int __maybe_unused xilinx_pm_request(u32 api_id, u32 arg0, u32 arg1, u32 arg2,
* firmware API is limited by the SMC call size
*/
u32 regs[] = {api_id, arg0, arg1, arg2, arg3};
int ret;
if (api_id == PM_FPGA_LOAD) {
/* Swap addr_hi/low because of incompatibility */
@ -173,7 +178,10 @@ int __maybe_unused xilinx_pm_request(u32 api_id, u32 arg0, u32 arg1, u32 arg2,
regs[2] = temp;
}
ipi_req(regs, PAYLOAD_ARG_CNT, ret_payload, PAYLOAD_ARG_CNT);
ret = ipi_req(regs, PAYLOAD_ARG_CNT, ret_payload,
PAYLOAD_ARG_CNT);
if (ret)
return ret;
#else
return -EPERM;
#endif

6
drivers/mmc/zynq_sdhci.c
View file

@ -69,6 +69,12 @@ __weak int zynqmp_mmio_write(const u32 address, const u32 mask, const u32 value)
return 0;
}
__weak int xilinx_pm_request(u32 api_id, u32 arg0, u32 arg1, u32 arg2,
u32 arg3, u32 *ret_payload)
{
return 0;
}
#if defined(CONFIG_ARCH_ZYNQMP) || defined(CONFIG_ARCH_VERSAL)
/* Default settings for ZynqMP Clock Phases */
static const u32 zynqmp_iclk_phases[] = {0, 63, 63, 0, 63, 0,

2
drivers/net/zynq_gem.c
View file

@ -60,6 +60,7 @@
#define ZYNQ_GEM_NWCFG_SPEED100 0x00000001 /* 100 Mbps operation */
#define ZYNQ_GEM_NWCFG_SPEED1000 0x00000400 /* 1Gbps operation */
#define ZYNQ_GEM_NWCFG_FDEN 0x00000002 /* Full Duplex mode */
#define ZYNQ_GEM_NWCFG_NO_BRDC BIT(5) /* No broadcast */
#define ZYNQ_GEM_NWCFG_FSREM 0x00020000 /* FCS removal */
#define ZYNQ_GEM_NWCFG_SGMII_ENBL 0x08000000 /* SGMII Enable */
#define ZYNQ_GEM_NWCFG_PCS_SEL 0x00000800 /* PCS select */
@ -77,6 +78,7 @@
#define ZYNQ_GEM_NWCFG_INIT (ZYNQ_GEM_DBUS_WIDTH | \
ZYNQ_GEM_NWCFG_FDEN | \
ZYNQ_GEM_NWCFG_NO_BRDC | \
ZYNQ_GEM_NWCFG_FSREM | \
ZYNQ_GEM_NWCFG_MDCCLKDIV)

2
drivers/pinctrl/meson/pinctrl-meson-gx-pmx.c
View file

@ -145,7 +145,7 @@ static const struct dm_gpio_ops meson_gx_gpio_ops = {
.direction_output = meson_gpio_direction_output,
};
const struct driver meson_gx_gpio_driver = {
U_BOOT_DRIVER(meson_gx_gpio_driver) = {
.name = "meson-gx-gpio",
.id = UCLASS_GPIO,
.probe = meson_gpio_probe,

2
drivers/pinctrl/meson/pinctrl-meson-gx.h
View file

@ -43,6 +43,6 @@ struct meson_gx_pmx_data {
}
extern const struct pinctrl_ops meson_gx_pinctrl_ops;
extern const struct driver meson_gx_gpio_driver;
extern U_BOOT_DRIVER(meson_gx_gpio_driver);
#endif /* __PINCTRL_MESON_GX_H__ */

4
drivers/pinctrl/meson/pinctrl-meson-gxbb.c
View file

@ -439,7 +439,7 @@ struct meson_pinctrl_data meson_gxbb_periphs_pinctrl_data = {
.num_groups = ARRAY_SIZE(meson_gxbb_periphs_groups),
.num_funcs = ARRAY_SIZE(meson_gxbb_periphs_functions),
.num_banks = ARRAY_SIZE(meson_gxbb_periphs_banks),
.gpio_driver = &meson_gx_gpio_driver,
.gpio_driver = DM_DRIVER_REF(meson_gx_gpio_driver),
};
struct meson_pinctrl_data meson_gxbb_aobus_pinctrl_data = {
@ -452,7 +452,7 @@ struct meson_pinctrl_data meson_gxbb_aobus_pinctrl_data = {
.num_groups = ARRAY_SIZE(meson_gxbb_aobus_groups),
.num_funcs = ARRAY_SIZE(meson_gxbb_aobus_functions),
.num_banks = ARRAY_SIZE(meson_gxbb_aobus_banks),
.gpio_driver = &meson_gx_gpio_driver,
.gpio_driver = DM_DRIVER_REF(meson_gx_gpio_driver),
};
static const struct udevice_id meson_gxbb_pinctrl_match[] = {

4
drivers/pinctrl/meson/pinctrl-meson-gxl.c
View file

@ -701,7 +701,7 @@ struct meson_pinctrl_data meson_gxl_periphs_pinctrl_data = {
.num_groups = ARRAY_SIZE(meson_gxl_periphs_groups),
.num_funcs = ARRAY_SIZE(meson_gxl_periphs_functions),
.num_banks = ARRAY_SIZE(meson_gxl_periphs_banks),
.gpio_driver = &meson_gx_gpio_driver,
.gpio_driver = DM_DRIVER_REF(meson_gx_gpio_driver),
};
struct meson_pinctrl_data meson_gxl_aobus_pinctrl_data = {
@ -714,7 +714,7 @@ struct meson_pinctrl_data meson_gxl_aobus_pinctrl_data = {
.num_groups = ARRAY_SIZE(meson_gxl_aobus_groups),
.num_funcs = ARRAY_SIZE(meson_gxl_aobus_functions),
.num_banks = ARRAY_SIZE(meson_gxl_aobus_banks),
.gpio_driver = &meson_gx_gpio_driver,
.gpio_driver = DM_DRIVER_REF(meson_gx_gpio_driver),
};
static const struct udevice_id meson_gxl_pinctrl_match[] = {

11
drivers/spi/zynqmp_gqspi.c
View file

@ -37,6 +37,7 @@
*/
#define GQSPI_IXR_TXNFULL_MASK 0x00000004 /* QSPI TX FIFO Overflow */
#define GQSPI_IXR_TXFULL_MASK 0x00000008 /* QSPI TX FIFO is full */
#define GQSPI_IXR_TXFIFOEMPTY_MASK 0x00000100 /* QSPI TX FIFO is Empty */
#define GQSPI_IXR_RXNEMTY_MASK 0x00000010 /* QSPI RX FIFO Not Empty */
#define GQSPI_IXR_GFEMTY_MASK 0x00000080 /* QSPI Generic FIFO Empty */
#define GQSPI_IXR_GFNFULL_MASK 0x00000200 /* QSPI GENFIFO not full */
@ -279,9 +280,6 @@ static void zynqmp_qspi_chipselect(struct zynqmp_qspi_priv *priv, int is_on)
debug("GFIFO_CMD_CS: 0x%x\n", gqspi_fifo_reg);
/* Dummy generic FIFO entry */
zynqmp_qspi_fill_gen_fifo(priv, 0);
zynqmp_qspi_fill_gen_fifo(priv, gqspi_fifo_reg);
}
@ -470,6 +468,13 @@ static int zynqmp_qspi_fill_tx_fifo(struct zynqmp_qspi_priv *priv, u32 size)
}
}
ret = wait_for_bit_le32(&regs->isr, GQSPI_IXR_TXFIFOEMPTY_MASK, 1,
GQSPI_TIMEOUT, 1);
if (ret) {
printf("%s: Timeout\n", __func__);
return ret;
}
priv->tx_buf += len;
return 0;
}

22
drivers/tpm/tpm_atmel_twi.c
View file

@ -52,7 +52,10 @@ static int tpm_atmel_twi_close(struct udevice *dev)
*/
static int tpm_atmel_twi_get_desc(struct udevice *dev, char *buf, int size)
{
return 0;
if (size < 50)
return -ENOSPC;
return snprintf(buf, size, "Atmel AT97SC3204T I2C 1.2 TPM (%s)", dev->name);
}
/*
@ -81,22 +84,15 @@ static int tpm_atmel_twi_xfer(struct udevice *dev,
print_buffer(0, (void *)sendbuf, 1, send_size, 0);
#endif
#if !CONFIG_IS_ENABLED(DM_I2C)
res = i2c_write(0x29, 0, 0, (uchar *)sendbuf, send_size);
#else
res = dm_i2c_write(dev, 0, sendbuf, send_size);
#endif
if (res) {
printf("i2c_write returned %d\n", res);
return -1;
}
start = get_timer(0);
#if !CONFIG_IS_ENABLED(DM_I2C)
while ((res = i2c_read(0x29, 0, 0, recvbuf, 10)))
#else
while ((res = dm_i2c_read(dev, 0, recvbuf, 10)))
#endif
{
/* TODO Use TIS_TIMEOUT from tpm_tis_infineon.h */
if (get_timer(start) > ATMEL_TPM_TIMEOUT_MS) {
@ -116,16 +112,11 @@ static int tpm_atmel_twi_xfer(struct udevice *dev,
return -1;
} else {
*recv_len = hdr_recv_len;
#if !CONFIG_IS_ENABLED(DM_I2C)
res = i2c_read(0x29, 0, 0, recvbuf, *recv_len);
#else
res = dm_i2c_read(dev, 0, recvbuf, *recv_len);
#endif
}
}
if (res) {
printf("i2c_read returned %d (rlen=%d)\n", res, *recv_len);
printf("i2c_read returned %d (rlen=%zu)\n", res, *recv_len);
#ifdef DEBUG
print_buffer(0, recvbuf, 1, *recv_len, 0);
#endif
@ -143,6 +134,7 @@ static int tpm_atmel_twi_xfer(struct udevice *dev,
static int tpm_atmel_twi_probe(struct udevice *dev)
{
i2c_set_chip_offset_len(dev, 0);
return 0;
}

19
include/configs/meson64_android.h
View file

@ -140,25 +140,28 @@
"echo Fastboot forced by usb rom boot;" \
"setenv run_fastboot 1;" \
"fi;" \
"if test \"${run_fastboot}\" -eq 0; then " \
"if gpt verify mmc ${mmcdev} ${partitions}; then; " \
"else " \
"echo Broken MMC partition scheme;" \
"setenv run_fastboot 1;" \
"fi; " \
"fi;" \
"if test \"${run_fastboot}\" -eq 0; then " \
"if bcb load " __stringify(CONFIG_FASTBOOT_FLASH_MMC_DEV) " " \
CONTROL_PARTITION "; then " \
"if bcb test command = bootonce-bootloader; then " \
"echo BCB: Bootloader boot...; " \
"bcb clear command; bcb store; " \
"setenv run_fastboot 1;" \
"fi; " \
"if bcb test command = boot-fastboot; then " \
"elif bcb test command = boot-fastboot; then " \
"echo BCB: fastboot userspace boot...; " \
"setenv force_recovery 1;" \
"fi; " \
"else " \
"echo Warning: BCB is corrupted or does not exist; " \
"fi;" \
"fi;" \
"if test \"${run_fastboot}\" -eq 1; then " \
"echo Running Fastboot...;" \
"fastboot " __stringify(CONFIG_FASTBOOT_USB_DEV) "; " \
@ -230,16 +233,24 @@
"echo Running Android...;" \
BOOT_CMD \
"fi;" \
"echo Failed to boot Android...;" \
"reset\0"
"echo Failed to boot Android...;\0"
#define BOOTENV_DEV_NAME_SYSTEM(devtypeu, devtypel, instance) \
"system "
#define BOOTENV_DEV_PANIC(devtypeu, devtypel, instance) \
"bootcmd_panic=" \
"fastboot " __stringify(CONFIG_FASTBOOT_USB_DEV) "; " \
"reset\0"
#define BOOTENV_DEV_NAME_PANIC(devtypeu, devtypel, instance) \
"panic "
#define BOOT_TARGET_DEVICES(func) \
func(FASTBOOT, fastboot, na) \
func(RECOVERY, recovery, na) \
func(SYSTEM, system, na) \
func(PANIC, panic, na) \
#define PREBOOT_LOAD_LOGO \
"if test \"${boot_source}\" != \"usb\" && " \

2
include/configs/synquacer.h
View file

@ -52,7 +52,7 @@
/* #define CONFIG_SYS_PCI_64BIT 1 */
#define DEFAULT_DFU_ALT_INFO "dfu_alt_info=" \
"mtd mx66u51235f=u-boot.bin raw 200000 100000;" \
"mtd nor1=u-boot.bin raw 200000 100000;" \
"fip.bin raw 180000 78000;" \
"optee.bin raw 500000 100000\0"

2
include/configs/tqma6.h
View file

@ -2,7 +2,7 @@
/*
* Copyright (C) 2013, 2014, 2017 Markus Niebel <Markus.Niebel@tq-group.com>
*
* Configuration settings for the TQ Systems TQMa6<Q,D,DL,S> module.
* Configuration settings for the TQ-Systems TQMa6<Q,D,DL,S> module.
*/
#ifndef __CONFIG_H

2
include/configs/tqma6_mba6.h
View file

@ -2,7 +2,7 @@
/*
* Copyright (C) 2013 - 2017 Markus Niebel <Markus.Niebel@tq-group.com>
*
* Configuration settings for the TQ Systems TQMa6<Q,D,DL,S> module on
* Configuration settings for the TQ-Systems TQMa6<Q,D,DL,S> module on
* MBa6 starter kit
*/

55
include/efi_api.h
View file

@ -20,8 +20,8 @@
#include <charset.h>
#include <pe.h>
/* UEFI spec version 2.8 */
#define EFI_SPECIFICATION_VERSION (2 << 16 | 80)
/* UEFI spec version 2.9 */
#define EFI_SPECIFICATION_VERSION (2 << 16 | 90)
/* Types and defines for EFI CreateEvent */
enum efi_timer_delay {
@ -360,10 +360,15 @@ struct efi_runtime_services {
};
/* EFI event group GUID definitions */
#define EFI_EVENT_GROUP_EXIT_BOOT_SERVICES \
EFI_GUID(0x27abf055, 0xb1b8, 0x4c26, 0x80, 0x48, \
0x74, 0x8f, 0x37, 0xba, 0xa2, 0xdf)
#define EFI_EVENT_GROUP_BEFORE_EXIT_BOOT_SERVICES \
EFI_GUID(0x8be0e274, 0x3970, 0x4b44, 0x80, 0xc5, \
0x1a, 0xb9, 0x50, 0x2f, 0x3b, 0xfc)
#define EFI_EVENT_GROUP_VIRTUAL_ADDRESS_CHANGE \
EFI_GUID(0x13fa7698, 0xc831, 0x49c7, 0x87, 0xea, \
0x8f, 0x43, 0xfc, 0xc2, 0x51, 0x96)
@ -376,6 +381,10 @@ struct efi_runtime_services {
EFI_GUID(0x7ce88fb3, 0x4bd7, 0x4679, 0x87, 0xa8, \
0xa8, 0xd8, 0xde, 0xe5, 0x0d, 0x2b)
#define EFI_EVENT_GROUP_AFTER_READY_TO_BOOT \
EFI_GUID(0x3a2a00ad, 0x98b9, 0x4cdf, 0xa4, 0x78, \
0x70, 0x27, 0x77, 0xf1, 0xc1, 0xb)
#define EFI_EVENT_GROUP_RESET_SYSTEM \
EFI_GUID(0x62da6a56, 0x13fb, 0x485a, 0xa8, 0xda, \
0xa3, 0xdd, 0x79, 0x12, 0xcb, 0x6b)
@ -417,6 +426,15 @@ struct efi_runtime_services {
EFI_GUID(0x1e2ed096, 0x30e2, 0x4254, 0xbd, \
0x89, 0x86, 0x3b, 0xbe, 0xf8, 0x23, 0x25)
/**
* struct efi_configuration_table - EFI Configuration Table
*
* This table contains a set of GUID/pointer pairs.
* The EFI Configuration Table may contain at most one instance of each table type.
*
* @guid: GUID that uniquely identifies the system configuration table
* @table: A pointer to the table associated with guid
*/
struct efi_configuration_table {
efi_guid_t guid;
void *table;
@ -424,6 +442,29 @@ struct efi_configuration_table {
#define EFI_SYSTEM_TABLE_SIGNATURE ((u64)0x5453595320494249ULL)
/**
* struct efi_system_table - EFI System Table
*
* EFI System Table contains pointers to the runtime and boot services tables.
*
* @hdr: The table header for the EFI System Table
* @fw_vendor: A pointer to a null terminated string that identifies the vendor
* that produces the system firmware
* @fw_revision: The revision of the system firmware
* @con_in_handle: The handle for the active console input device
* @con_in: A pointer to the EFI_SIMPLE_TEXT_INPUT_PROTOCOL interface
* that is associated with con_in_handle
* @con_out_handle: The handle for the active console output device
* @con_out: A pointer to the EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL interface
* that is associated with con_out_handle
* @stderr_handle: The handle for the active standard error console device
* @std_err: A pointer to the EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL interface
* that is associated with stderr_handle
* @runtime: A pointer to the EFI Runtime Services Table
* @boottime: A pointer to the EFI Boot Services Table
* @nr_tables: The number of system configuration tables
* @tables: A pointer to the system configuration tables
*/
struct efi_system_table {
struct efi_table_hdr hdr;
u16 *fw_vendor; /* physical addr of wchar_t vendor string */
@ -1809,7 +1850,7 @@ struct efi_system_resource_table {
0x34, 0x7d, 0x37, 0x56, 0x65, 0xa7)
/**
* win_certificate_uefi_guid - A certificate that encapsulates
* struct win_certificate_uefi_guid - A certificate that encapsulates
* a GUID-specific signature
*
* @hdr: Windows certificate header
@ -1823,7 +1864,7 @@ struct win_certificate_uefi_guid {
} __attribute__((__packed__));
/**
* efi_variable_authentication_2 - A time-based authentication method
* struct efi_variable_authentication_2 - A time-based authentication method
* descriptor
*
* This structure describes an authentication information for
@ -1840,7 +1881,7 @@ struct efi_variable_authentication_2 {
} __attribute__((__packed__));
/**
* efi_firmware_image_authentication - Capsule authentication method
* struct efi_firmware_image_authentication - Capsule authentication method
* descriptor
*
* This structure describes an authentication information for
@ -1858,7 +1899,7 @@ struct efi_firmware_image_authentication {
/**
* efi_signature_data - A format of signature
* struct efi_signature_data - A format of signature
*
* This structure describes a single signature in signature database.
*
@ -1871,7 +1912,7 @@ struct efi_signature_data {
} __attribute__((__packed__));
/**
* efi_signature_list - A format of signature database
* struct efi_signature_list - A format of signature database
*
* This structure describes a list of signatures with the same type.
* An authenticated variable's value is a concatenation of one or more

2
include/init.h
View file

@ -332,6 +332,8 @@ void bdinfo_print_mhz(const char *name, unsigned long hz);
/* Show arch-specific information for the 'bd' command */
void arch_print_bdinfo(void);
int do_bdinfo(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
#endif /* __ASSEMBLY__ */
/* Put only stuff here that the assembler can digest */

62
include/lmb.h
View file

@ -27,6 +27,7 @@ enum lmb_flags {
*
* @base: Base address of the region.
* @size: Size of the region
* @flags: memory region attributes
*/
struct lmb_property {
phys_addr_t base;
@ -73,64 +74,49 @@ struct lmb {
#endif
};
extern void lmb_init(struct lmb *lmb);
extern void lmb_init_and_reserve(struct lmb *lmb, struct bd_info *bd,
void *fdt_blob);
extern void lmb_init_and_reserve_range(struct lmb *lmb, phys_addr_t base,
void lmb_init(struct lmb *lmb);
void lmb_init_and_reserve(struct lmb *lmb, struct bd_info *bd, void *fdt_blob);
void lmb_init_and_reserve_range(struct lmb *lmb, phys_addr_t base,
phys_size_t size, void *fdt_blob);
extern long lmb_add(struct lmb *lmb, phys_addr_t base, phys_size_t size);
extern long lmb_reserve(struct lmb *lmb, phys_addr_t base, phys_size_t size);
long lmb_add(struct lmb *lmb, phys_addr_t base, phys_size_t size);
long lmb_reserve(struct lmb *lmb, phys_addr_t base, phys_size_t size);
/**
* lmb_reserve_flags - Reserve one region with a specific flags bitfield.
*
* @lmb the logical memory block struct
* @base base address of the memory region
* @size size of the memory region
* @flags flags for the memory region
* @return 0 if OK, > 0 for coalesced region or a negative error code.
* @lmb: the logical memory block struct
* @base: base address of the memory region
* @size: size of the memory region
* @flags: flags for the memory region
* Return: 0 if OK, > 0 for coalesced region or a negative error code.
*/
long lmb_reserve_flags(struct lmb *lmb, phys_addr_t base,
phys_size_t size, enum lmb_flags flags);
extern phys_addr_t lmb_alloc(struct lmb *lmb, phys_size_t size, ulong align);
extern phys_addr_t lmb_alloc_base(struct lmb *lmb, phys_size_t size, ulong align,
phys_addr_t lmb_alloc(struct lmb *lmb, phys_size_t size, ulong align);
phys_addr_t lmb_alloc_base(struct lmb *lmb, phys_size_t size, ulong align,
phys_addr_t max_addr);
extern phys_addr_t __lmb_alloc_base(struct lmb *lmb, phys_size_t size, ulong align,
phys_addr_t __lmb_alloc_base(struct lmb *lmb, phys_size_t size, ulong align,
phys_addr_t max_addr);
extern phys_addr_t lmb_alloc_addr(struct lmb *lmb, phys_addr_t base,
phys_size_t size);
extern phys_size_t lmb_get_free_size(struct lmb *lmb, phys_addr_t addr);
extern int lmb_is_reserved(struct lmb *lmb, phys_addr_t addr);
phys_addr_t lmb_alloc_addr(struct lmb *lmb, phys_addr_t base, phys_size_t size);
phys_size_t lmb_get_free_size(struct lmb *lmb, phys_addr_t addr);
int lmb_is_reserved(struct lmb *lmb, phys_addr_t addr);
/**
* lmb_is_reserved_flags - test if tha address is in reserved region with a bitfield flag
*
* @lmb the logical memory block struct
* @addr address to be tested
* @flags flags bitfied to be tested
* @return 0 if not reserved or reserved without the requested flag else 1
* @lmb: the logical memory block struct
* @addr: address to be tested
* @flags: flags bitfied to be tested
* Return: if not reserved or reserved without the requested flag else 1
*/
int lmb_is_reserved_flags(struct lmb *lmb, phys_addr_t addr, int flags);
extern long lmb_free(struct lmb *lmb, phys_addr_t base, phys_size_t size);
long lmb_free(struct lmb *lmb, phys_addr_t base, phys_size_t size);
extern void lmb_dump_all(struct lmb *lmb);
extern void lmb_dump_all_force(struct lmb *lmb);
static inline phys_size_t
lmb_size_bytes(struct lmb_region *type, unsigned long region_nr)
{
return type->region[region_nr].size;
}
void lmb_dump_all(struct lmb *lmb);
void lmb_dump_all_force(struct lmb *lmb);
void board_lmb_reserve(struct lmb *lmb);
void arch_lmb_reserve(struct lmb *lmb);
void arch_lmb_reserve_generic(struct lmb *lmb, ulong sp, ulong end, ulong align);
/* Low level functions */
static inline bool lmb_is_nomap(struct lmb_property *m)
{
return m->flags & LMB_NOMAP;
}
#endif /* __KERNEL__ */
#endif /* _LINUX_LMB_H */

2
lib/Kconfig
View file

@ -793,7 +793,7 @@ config LMB
Support the library logical memory blocks.
config LMB_USE_MAX_REGIONS
bool "Use a commun number of memory and reserved regions in lmb lib"
bool "Use a common number of memory and reserved regions in lmb lib"
depends on LMB
default y
help

3
lib/asm-offsets.c
View file

@ -29,6 +29,9 @@ int main(void)
DEFINE(GD_SIZE, sizeof(struct global_data));
DEFINE(GD_BD, offsetof(struct global_data, bd));
DEFINE(GD_FLAGS, offsetof(struct global_data, flags));
#if CONFIG_VAL(SYS_MALLOC_F_LEN)
DEFINE(GD_MALLOC_BASE, offsetof(struct global_data, malloc_base));
#endif

17
lib/efi_loader/efi_boottime.c
View file

@ -71,6 +71,9 @@ const efi_guid_t efi_guid_driver_binding_protocol =
/* event group ExitBootServices() invoked */
const efi_guid_t efi_guid_event_group_exit_boot_services =
EFI_EVENT_GROUP_EXIT_BOOT_SERVICES;
/* event group before ExitBootServices() invoked */
const efi_guid_t efi_guid_event_group_before_exit_boot_services =
EFI_EVENT_GROUP_BEFORE_EXIT_BOOT_SERVICES;
/* event group SetVirtualAddressMap() invoked */
const efi_guid_t efi_guid_event_group_virtual_address_change =
EFI_EVENT_GROUP_VIRTUAL_ADDRESS_CHANGE;
@ -2123,6 +2126,16 @@ static efi_status_t EFIAPI efi_exit_boot_services(efi_handle_t image_handle,
if (!systab.boottime)
goto out;
/* Notify EFI_EVENT_GROUP_BEFORE_EXIT_BOOT_SERVICES event group. */
list_for_each_entry(evt, &efi_events, link) {
if (evt->group &&
!guidcmp(evt->group,
&efi_guid_event_group_before_exit_boot_services)) {
efi_signal_event(evt);
break;
}
}
/* Stop all timer related activities */
timers_enabled = false;
@ -2154,6 +2167,7 @@ static efi_status_t EFIAPI efi_exit_boot_services(efi_handle_t image_handle,
}
if (!efi_st_keep_devices) {
bootm_disable_interrupts();
if (IS_ENABLED(CONFIG_USB_DEVICE))
udc_disconnect();
board_quiesce_devices();
@ -2166,9 +2180,6 @@ static efi_status_t EFIAPI efi_exit_boot_services(efi_handle_t image_handle,
/* Fix up caches for EFI payloads if necessary */
efi_exit_caches();
/* This stops all lingering devices */
bootm_disable_interrupts();
/* Disable boot time services */
systab.con_in_handle = NULL;
systab.con_in = NULL;

47
lib/efi_loader/efi_capsule.c
View file

@ -1037,30 +1037,45 @@ efi_status_t __weak efi_load_capsule_drivers(void)
}
/**
* check_run_capsules - Check whether capsule update should run
* check_run_capsules() - check whether capsule update should run
*
* The spec says OsIndications must be set in order to run the capsule update
* on-disk. Since U-Boot doesn't support runtime SetVariable, allow capsules to
* run explicitly if CONFIG_EFI_IGNORE_OSINDICATIONS is selected
*
* Return: EFI_SUCCESS if update to run, EFI_NOT_FOUND otherwise
*/
static bool check_run_capsules(void)
static efi_status_t check_run_capsules(void)
{
u64 os_indications;
efi_uintn_t size;
efi_status_t ret;
if (IS_ENABLED(CONFIG_EFI_IGNORE_OSINDICATIONS))
return true;
efi_status_t r;
size = sizeof(os_indications);
ret = efi_get_variable_int(L"OsIndications", &efi_global_variable_guid,
r = efi_get_variable_int(L"OsIndications", &efi_global_variable_guid,
NULL, &size, &os_indications, NULL);
if (ret == EFI_SUCCESS &&
(os_indications
& EFI_OS_INDICATIONS_FILE_CAPSULE_DELIVERY_SUPPORTED))
return true;
if (r != EFI_SUCCESS || size != sizeof(os_indications))
return EFI_NOT_FOUND;
return false;
if (os_indications &
EFI_OS_INDICATIONS_FILE_CAPSULE_DELIVERY_SUPPORTED) {
os_indications &=
~EFI_OS_INDICATIONS_FILE_CAPSULE_DELIVERY_SUPPORTED;
r = efi_set_variable_int(L"OsIndications",
&efi_global_variable_guid,
EFI_VARIABLE_NON_VOLATILE |
EFI_VARIABLE_BOOTSERVICE_ACCESS |
EFI_VARIABLE_RUNTIME_ACCESS,
sizeof(os_indications),
&os_indications, false);
if (r != EFI_SUCCESS)
log_err("Setting %ls failed\n", L"OsIndications");
return EFI_SUCCESS;
} else if (IS_ENABLED(CONFIG_EFI_IGNORE_OSINDICATIONS)) {
return EFI_SUCCESS;
} else {
return EFI_NOT_FOUND;
}
}
/**
@ -1078,7 +1093,7 @@ efi_status_t efi_launch_capsules(void)
unsigned int nfiles, index, i;
efi_status_t ret;
if (!check_run_capsules())
if (check_run_capsules() != EFI_SUCCESS)
return EFI_SUCCESS;
index = get_last_capsule();
@ -1108,13 +1123,13 @@ efi_status_t efi_launch_capsules(void)
log_err("Applying capsule %ls failed\n",
files[i]);
/* create CapsuleXXXX */
set_capsule_result(index, capsule, ret);
free(capsule);
} else {
log_err("Reading capsule %ls failed\n", files[i]);
}
/* create CapsuleXXXX */
set_capsule_result(index, capsule, ret);
/* delete a capsule either in case of success or failure */
ret = efi_capsule_delete_file(files[i]);
if (ret != EFI_SUCCESS)

4
lib/efi_loader/efi_disk.c
View file

@ -424,7 +424,7 @@ static efi_status_t efi_disk_add_dev(
&efi_block_io_guid, &diskobj->ops,
guid, NULL, NULL));
if (ret != EFI_SUCCESS)
return ret;
goto error;
/*
* On partitions or whole disks without partitions install the
@ -573,7 +573,7 @@ efi_status_t efi_disk_register(void)
if (ret) {
log_err("ERROR: failure to add disk device %s, r = %lu\n",
dev->name, ret & ~EFI_ERROR_MASK);
return ret;
continue;
}
disks++;

36
lib/efi_loader/efi_setup.c
View file

@ -175,36 +175,6 @@ static efi_status_t efi_init_os_indications(void)
}
/**
* efi_clear_os_indications() - clear OsIndications
*
* Clear EFI_OS_INDICATIONS_FILE_CAPSULE_DELIVERY_SUPPORTED
*/
static efi_status_t efi_clear_os_indications(void)
{
efi_uintn_t size;
u64 os_indications;
efi_status_t ret;
size = sizeof(os_indications);
ret = efi_get_variable_int(L"OsIndications", &efi_global_variable_guid,
NULL, &size, &os_indications, NULL);
if (ret != EFI_SUCCESS)
os_indications = 0;
else
os_indications &=
~EFI_OS_INDICATIONS_FILE_CAPSULE_DELIVERY_SUPPORTED;
ret = efi_set_variable_int(L"OsIndications", &efi_global_variable_guid,
EFI_VARIABLE_NON_VOLATILE |
EFI_VARIABLE_BOOTSERVICE_ACCESS |
EFI_VARIABLE_RUNTIME_ACCESS,
sizeof(os_indications), &os_indications,
false);
if (ret != EFI_SUCCESS)
log_err("Setting %ls failed\n", L"OsIndications");
return ret;
}
/**
* efi_init_obj_list() - Initialize and populate EFI object list
*
@ -212,7 +182,7 @@ static efi_status_t efi_clear_os_indications(void)
*/
efi_status_t efi_init_obj_list(void)
{
efi_status_t r, ret = EFI_SUCCESS;
efi_status_t ret = EFI_SUCCESS;
/* Initialize once only */
if (efi_obj_list_initialized != OBJ_LIST_NOT_INITIALIZED)
@ -331,11 +301,7 @@ efi_status_t efi_init_obj_list(void)
if (IS_ENABLED(CONFIG_EFI_CAPSULE_ON_DISK) &&
!IS_ENABLED(CONFIG_EFI_CAPSULE_ON_DISK_EARLY))
ret = efi_launch_capsules();
out:
r = efi_clear_os_indications();
if (ret == EFI_SUCCESS)
ret = r;
efi_obj_list_initialized = ret;
return ret;
}

114
lib/efi_loader/efi_tcg2.c
View file

@ -18,6 +18,7 @@
#include <smbios.h>
#include <version_string.h>
#include <tpm-v2.h>
#include <tpm_api.h>
#include <u-boot/hash-checksum.h>
#include <u-boot/sha1.h>
#include <u-boot/sha256.h>
@ -27,6 +28,17 @@
#include <linux/unaligned/generic.h>
#include <hexdump.h>
/**
* struct event_log_buffer - internal eventlog management structure
*
* @buffer: eventlog buffer
* @final_buffer: finalevent config table buffer
* @pos: current position of 'buffer'
* @final_pos: current position of 'final_buffer'
* @get_event_called: true if GetEventLog has been invoked at least once
* @ebs_called: true if ExitBootServices has been invoked
* @truncated: true if the 'buffer' is truncated
*/
struct event_log_buffer {
void *buffer;
void *final_buffer;
@ -34,6 +46,7 @@ struct event_log_buffer {
size_t final_pos; /* final events config table position */
size_t last_event_size;
bool get_event_called;
bool ebs_called;
bool truncated;
};
@ -186,39 +199,29 @@ static efi_status_t tcg2_pcr_extend(struct udevice *dev, u32 pcr_index,
return EFI_SUCCESS;
}
/* tcg2_agile_log_append - Append an agile event to out eventlog
/* put_event - Append an agile event to an eventlog
*
* @pcr_index: PCR index
* @event_type: type of event added
* @digest_list: list of digest algorithms to add
* @size: size of event
* @event: event to add
* @log: log buffer to append the event
*
* @Return: status code
*/
static efi_status_t tcg2_agile_log_append(u32 pcr_index, u32 event_type,
struct tpml_digest_values *digest_list,
u32 size, u8 event[])
static void put_event(u32 pcr_index, u32 event_type,
struct tpml_digest_values *digest_list, u32 size,
u8 event[], void *log)
{
void *log = (void *)((uintptr_t)event_log.buffer + event_log.pos);
size_t pos;
size_t i;
u32 event_size;
if (event_log.get_event_called)
log = (void *)((uintptr_t)event_log.final_buffer +
event_log.final_pos);
/*
* size refers to the length of event[] only, we need to check against
* the final tcg_pcr_event2 size
*/
event_size = size + tcg_event_final_size(digest_list);
if (event_log.pos + event_size > TPM2_EVENT_LOG_SIZE ||
event_log.final_pos + event_size > TPM2_EVENT_LOG_SIZE) {
event_log.truncated = true;
return EFI_VOLUME_FULL;
}
put_unaligned_le32(pcr_index, log);
pos = offsetof(struct tcg_pcr_event2, event_type);
@ -242,25 +245,62 @@ static efi_status_t tcg2_agile_log_append(u32 pcr_index, u32 event_type,
memcpy((void *)((uintptr_t)log + pos), event, size);
pos += size;
/* make sure the calculated buffer is what we checked against */
/*
* make sure the calculated buffer is what we checked against
* This check should never fail. It checks the code above is
* calculating the right length for the event we are adding
*/
if (pos != event_size)
return EFI_INVALID_PARAMETER;
/* if GetEventLog hasn't been called update the normal log */
if (!event_log.get_event_called) {
event_log.pos += pos;
event_log.last_event_size = pos;
} else {
/* if GetEventLog has been called update config table log */
struct efi_tcg2_final_events_table *final_event;
final_event =
(struct efi_tcg2_final_events_table *)(event_log.final_buffer);
final_event->number_of_events++;
event_log.final_pos += pos;
log_err("Appending to the EventLog failed\n");
}
return EFI_SUCCESS;
/* tcg2_agile_log_append - Append an agile event to an eventlog
*
* @pcr_index: PCR index
* @event_type: type of event added
* @digest_list: list of digest algorithms to add
* @size: size of event
* @event: event to add
* @log: log buffer to append the event
*
* @Return: status code
*/
static efi_status_t tcg2_agile_log_append(u32 pcr_index, u32 event_type,
struct tpml_digest_values *digest_list,
u32 size, u8 event[])
{
void *log = (void *)((uintptr_t)event_log.buffer + event_log.pos);
u32 event_size = size + tcg_event_final_size(digest_list);
struct efi_tcg2_final_events_table *final_event;
efi_status_t ret = EFI_SUCCESS;
/* if ExitBootServices hasn't been called update the normal log */
if (!event_log.ebs_called) {
if (event_log.truncated ||
event_log.pos + event_size > TPM2_EVENT_LOG_SIZE) {
event_log.truncated = true;
return EFI_VOLUME_FULL;
}
put_event(pcr_index, event_type, digest_list, size, event, log);
event_log.pos += event_size;
event_log.last_event_size = event_size;
}
if (!event_log.get_event_called)
return ret;
/* if GetEventLog has been called update FinalEventLog as well */
if (event_log.final_pos + event_size > TPM2_EVENT_LOG_SIZE)
return EFI_VOLUME_FULL;
log = (void *)((uintptr_t)event_log.final_buffer + event_log.final_pos);
put_event(pcr_index, event_type, digest_list, size, event, log);
final_event = event_log.final_buffer;
final_event->number_of_events++;
event_log.final_pos += event_size;
return ret;
}
/**
@ -1303,6 +1343,7 @@ static efi_status_t efi_init_event_log(void)
event_log.pos = 0;
event_log.last_event_size = 0;
event_log.get_event_called = false;
event_log.ebs_called = false;
event_log.truncated = false;
/*
@ -1472,7 +1513,7 @@ static efi_status_t tcg2_measure_boot_variable(struct udevice *dev)
&var_data_size);
if (!bootvar) {
log_info("%ls not found\n", boot_name);
log_debug("%ls not found\n", boot_name);
continue;
}
@ -1792,6 +1833,7 @@ efi_tcg2_notify_exit_boot_services(struct efi_event *event, void *context)
EFI_ENTRY("%p, %p", event, context);
event_log.ebs_called = true;
ret = platform_get_tpm2_device(&dev);
if (ret != EFI_SUCCESS)
goto out;
@ -1902,6 +1944,7 @@ efi_status_t efi_tcg2_register(void)
efi_status_t ret = EFI_SUCCESS;
struct udevice *dev;
struct efi_event *event;
u32 err;
ret = platform_get_tpm2_device(&dev);
if (ret != EFI_SUCCESS) {
@ -1909,6 +1952,13 @@ efi_status_t efi_tcg2_register(void)
return EFI_SUCCESS;
}
/* initialize the TPM as early as possible. */
err = tpm_startup(dev, TPM_ST_CLEAR);
if (err) {
log_err("TPM startup failed\n");
goto fail;
}
ret = efi_init_event_log();
if (ret != EFI_SUCCESS)
goto fail;

67
lib/efi_selftest/efi_selftest_exitbootservices.c
View file

@ -10,9 +10,34 @@
#include <efi_selftest.h>
static efi_guid_t guid_before_exit_boot_services =
EFI_GUID(0x8be0e274, 0x3970, 0x4b44, 0x80, 0xc5,
0x1a, 0xb9, 0x50, 0x2f, 0x3b, 0xfc);
#define CAPACITY 4
struct notification_record {
unsigned int count;
unsigned int type[CAPACITY];
};
struct notification_context {
struct notification_record *record;
unsigned int type;
};
static struct efi_boot_services *boottime;
static struct efi_event *event_notify;
static unsigned int notification_count;
struct notification_record record;
struct notification_context context_before = {
.record = &record,
.type = 1,
};
struct notification_context context = {
.record = &record,
.type = 2,
};
/*
* Notification function, increments the notification count.
@ -20,11 +45,15 @@ static unsigned int notification_count;
* @event notified event
* @context pointer to the notification count
*/
static void EFIAPI notify(struct efi_event *event, void *context)
static void EFIAPI ebs_notify(struct efi_event *event, void *context)
{
unsigned int *count = context;
struct notification_context *ctx = context;
++*count;
if (ctx->record->count >= CAPACITY)
return;
ctx->record->type[ctx->record->count] = ctx->type;
ctx->record->count++;
}
/*
@ -43,15 +72,23 @@ static int setup(const efi_handle_t handle,
boottime = systable->boottime;
notification_count = 0;
ret = boottime->create_event(EVT_SIGNAL_EXIT_BOOT_SERVICES,
TPL_CALLBACK, notify,
(void *)&notification_count,
TPL_CALLBACK, ebs_notify,
&context,
&event_notify);
if (ret != EFI_SUCCESS) {
efi_st_error("could not create event\n");
return EFI_ST_FAILURE;
}
ret = boottime->create_event_ex(0, TPL_CALLBACK, ebs_notify,
&context_before,
&guid_before_exit_boot_services,
&event_notify);
if (ret != EFI_SUCCESS) {
efi_st_error("could not create event\n");
return EFI_ST_FAILURE;
}
return EFI_ST_SUCCESS;
}
@ -68,13 +105,21 @@ static int setup(const efi_handle_t handle,
*/
static int execute(void)
{
if (notification_count != 1) {
efi_st_error("ExitBootServices was not notified\n");
if (record.count != 2) {
efi_st_error("Incorrect event count %u\n", record.count);
return EFI_ST_FAILURE;
}
if (record.type[0] != 1) {
efi_st_error("EFI_GROUP_BEFORE_EXIT_BOOT_SERVICE not notified\n");
return EFI_ST_FAILURE;
}
if (record.type[1] != 2) {
efi_st_error("EVT_SIGNAL_EXIT_BOOT_SERVICES was not notified\n");
return EFI_ST_FAILURE;
}
efi_st_exit_boot_services();
if (notification_count != 1) {
efi_st_error("ExitBootServices was notified twice\n");
if (record.count != 2) {
efi_st_error("Incorrect event count %u\n", record.count);
return EFI_ST_FAILURE;
}
return EFI_ST_SUCCESS;

15
lib/efi_selftest/efi_selftest_fdt.c
View file

@ -23,23 +23,24 @@ static const char *fdt;
static const efi_guid_t fdt_guid = EFI_FDT_GUID;
static const efi_guid_t acpi_guid = EFI_ACPI_TABLE_GUID;
/*
* Convert FDT value to host endianness.
/**
* f2h() - convert FDT value to host endianness.
*
* @val FDT value
* @return converted value
* UEFI code is always low endian. The FDT is big endian.
*
* @val: FDT value
* Return: converted value
*/
static uint32_t f2h(fdt32_t val)
{
char *buf = (char *)&val;
char i;
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
/* Swap the bytes */
i = buf[0]; buf[0] = buf[3]; buf[3] = i;
i = buf[1]; buf[1] = buf[2]; buf[2] = i;
#endif
return *(uint32_t *)buf;
return val;
}
/**

5
lib/lmb.c
View file

@ -13,6 +13,7 @@
#include <malloc.h>
#include <asm/global_data.h>
#include <asm/sections.h>
DECLARE_GLOBAL_DATA_PTR;
@ -144,6 +145,10 @@ void arch_lmb_reserve_generic(struct lmb *lmb, ulong sp, ulong end, ulong align)
bank_end = end - 1;
lmb_reserve(lmb, sp, bank_end - sp + 1);
if (gd->flags & GD_FLG_SKIP_RELOC)
lmb_reserve(lmb, (phys_addr_t)(uintptr_t)_start, gd->mon_len);
break;
}
}

4
lib/tpm-v1.c
View file

@ -840,7 +840,7 @@ u32 tpm1_find_key_sha1(struct udevice *dev, const u8 auth[20],
unsigned int i;
/* fetch list of already loaded keys in the TPM */
err = tpm_get_capability(dev, TPM_CAP_HANDLE, TPM_RT_KEY, buf,
err = tpm1_get_capability(dev, TPM_CAP_HANDLE, TPM_RT_KEY, buf,
sizeof(buf));
if (err)
return -1;
@ -852,7 +852,7 @@ u32 tpm1_find_key_sha1(struct udevice *dev, const u8 auth[20],
/* now search a(/ the) key which we can access with the given auth */
for (i = 0; i < key_count; ++i) {
buf_len = sizeof(buf);
err = tpm_get_pub_key_oiap(key_handles[i], auth, buf, &buf_len);
err = tpm1_get_pub_key_oiap(dev, key_handles[i], auth, buf, &buf_len);
if (err && err != TPM_AUTHFAIL)
return -1;
if (err)

2
scripts/Makefile.autoconf
View file

@ -61,7 +61,7 @@ quiet_cmd_autoconf = GEN $@
if [ -n "${KCONFIG_IGNORE_DUPLICATES}" ] || \
! grep -q "$${line%=*}=" include/config/auto.conf; then \
echo "$$line"; \
fi \
fi; \
done > $@
quiet_cmd_u_boot_cfg = CFG $@

365
scripts/spelling.txt
View file

File diff suppressed because it is too large Load diff

5
test/lib/lmb.c
View file

@ -12,6 +12,11 @@
#include <test/test.h>
#include <test/ut.h>
static inline bool lmb_is_nomap(struct lmb_property *m)
{
return m->flags & LMB_NOMAP;
}
static int check_lmb(struct unit_test_state *uts, struct lmb *lmb,
phys_addr_t ram_base, phys_size_t ram_size,
unsigned long num_reserved,

18
test/print_ut.c
View file

@ -31,6 +31,7 @@ static int print_guid(struct unit_test_state *uts)
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
};
char str[40];
int ret;
sprintf(str, "%pUb", guid);
ut_assertok(strcmp("01020304-0506-0708-090a-0b0c0d0e0f10", str));
@ -40,6 +41,9 @@ static int print_guid(struct unit_test_state *uts)
ut_assertok(strcmp("04030201-0605-0807-090a-0b0c0d0e0f10", str));
sprintf(str, "%pUL", guid);
ut_assertok(strcmp("04030201-0605-0807-090A-0B0C0D0E0F10", str));
ret = snprintf(str, 4, "%pUL", guid);
ut_asserteq(0, str[3]);
ut_asserteq(36, ret);
return 0;
}
@ -349,6 +353,20 @@ static int print_itoa(struct unit_test_state *uts)
}
PRINT_TEST(print_itoa, 0);
static int snprint(struct unit_test_state *uts)
{
char buf[10] = "xxxxxxxxx";
int ret;
ret = snprintf(buf, 4, "%s:%s", "abc", "def");
ut_asserteq(0, buf[3]);
ut_asserteq(7, ret);
ret = snprintf(buf, 4, "%s:%d", "abc", 9999);
ut_asserteq(8, ret);
return 0;
}
PRINT_TEST(snprint, 0);
static int print_xtoa(struct unit_test_state *uts)
{
ut_asserteq_str("7f", simple_xtoa(127));

14
test/py/multiplexed_log.py
View file

@ -2,8 +2,10 @@
# Copyright (c) 2015 Stephen Warren
# Copyright (c) 2015-2016, NVIDIA CORPORATION. All rights reserved.
# Generate an HTML-formatted log file containing multiple streams of data,
# each represented in a well-delineated/-structured fashion.
"""
Generate an HTML-formatted log file containing multiple streams of data,
each represented in a well-delineated/-structured fashion.
"""
import datetime
import html
@ -180,7 +182,7 @@ class RunAndLog(object):
raise exception
return output
class SectionCtxMgr(object):
class SectionCtxMgr:
"""A context manager for Python's "with" statement, which allows a certain
portion of test code to be logged to a separate section of the log file.
Objects of this type should be created by factory functions in the Logfile
@ -208,7 +210,7 @@ class SectionCtxMgr(object):
def __exit__(self, extype, value, traceback):
self.log.end_section(self.marker)
class Logfile(object):
class Logfile:
"""Generates an HTML-formatted log file containing multiple streams of
data, each represented in a well-delineated/-structured fashion."""
@ -322,8 +324,8 @@ $(document).ready(function () {
# The set of characters that should be represented as hexadecimal codes in
# the log file.
_nonprint = {ord('%')}
_nonprint.update({c for c in range(0, 32) if c not in (9, 10)})
_nonprint.update({c for c in range(127, 256)})
_nonprint.update(c for c in range(0, 32) if c not in (9, 10))
_nonprint.update(range(127, 256))
def _escape(self, data):
"""Render data format suitable for inclusion in an HTML document.

10
test/py/tests/test_efi_loader.py
View file

@ -6,9 +6,6 @@
# Test efi loader implementation
import pytest
import u_boot_utils
"""
Note: This test relies on boardenv_* containing configuration values to define
which network environment is available for testing. Without this, the parts
@ -50,6 +47,9 @@ env__efi_loader_helloworld_file = {
}
"""
import pytest
import u_boot_utils
net_set_up = False
def test_efi_pre_commands(u_boot_console):
@ -80,7 +80,7 @@ def test_efi_setup_dhcp(u_boot_console):
env_vars = u_boot_console.config.env.get('env__net_static_env_vars', None)
if not env_vars:
pytest.skip('No DHCP server available')
return None
return
u_boot_console.run_command('setenv autoload no')
output = u_boot_console.run_command('dhcp')
@ -193,7 +193,7 @@ def test_efi_grub_net(u_boot_console):
check_smbios = u_boot_console.config.env.get('env__efi_loader_check_smbios', False)
if check_smbios:
u_boot_console.wait_for('grub>')
output = u_boot_console.run_command('lsefisystab', wait_for_prompt=False, wait_for_echo=False)
u_boot_console.run_command('lsefisystab', wait_for_prompt=False, wait_for_echo=False)
u_boot_console.wait_for('SMBIOS')
# Then exit cleanly

6
test/py/tests/test_efi_selftest.py
View file

@ -73,8 +73,7 @@ def test_efi_selftest_text_input(u_boot_console):
This function calls the text input EFI selftest.
"""
u_boot_console.run_command(cmd='setenv efi_selftest text input')
output = u_boot_console.run_command(cmd='bootefi selftest',
wait_for_prompt=False)
u_boot_console.run_command(cmd='bootefi selftest', wait_for_prompt=False)
m = u_boot_console.p.expect([r'To terminate type \'x\''])
if m != 0:
raise Exception('No prompt for \'text input\' test')
@ -143,8 +142,7 @@ def test_efi_selftest_text_input_ex(u_boot_console):
This function calls the extended text input EFI selftest.
"""
u_boot_console.run_command(cmd='setenv efi_selftest extended text input')
output = u_boot_console.run_command(cmd='bootefi selftest',
wait_for_prompt=False)
u_boot_console.run_command(cmd='bootefi selftest', wait_for_prompt=False)
m = u_boot_console.p.expect([r'To terminate type \'CTRL\+x\''])
if m != 0:
raise Exception('No prompt for \'text input\' test')

6
test/py/u_boot_console_exec_attach.py
View file

@ -2,8 +2,10 @@
# Copyright (c) 2015 Stephen Warren
# Copyright (c) 2015-2016, NVIDIA CORPORATION. All rights reserved.
# Logic to interact with U-Boot running on real hardware, typically via a
# physical serial port.
"""
Logic to interact with U-Boot running on real hardware, typically via a
physical serial port.
"""
import sys
from u_boot_spawn import Spawn

4
test/py/u_boot_console_sandbox.py
View file

@ -2,7 +2,9 @@
# Copyright (c) 2015 Stephen Warren
# Copyright (c) 2015-2016, NVIDIA CORPORATION. All rights reserved.
# Logic to interact with the sandbox port of U-Boot, running as a sub-process.
"""
Logic to interact with the sandbox port of U-Boot, running as a sub-process.
"""
import time
from u_boot_spawn import Spawn

24
test/py/u_boot_spawn.py
View file

@ -1,7 +1,9 @@
# SPDX-License-Identifier: GPL-2.0
# Copyright (c) 2015-2016, NVIDIA CORPORATION. All rights reserved.
# Logic to spawn a sub-process and interact with its stdio.
"""
Logic to spawn a sub-process and interact with its stdio.
"""
import os
import re
@ -9,12 +11,12 @@ import pty
import signal
import select
import time
import traceback
class Timeout(Exception):
"""An exception sub-class that indicates that a timeout occurred."""
pass
class Spawn(object):
class Spawn:
"""Represents the stdio of a freshly created sub-process. Commands may be
sent to the process, and responses waited for.
@ -58,14 +60,14 @@ class Spawn(object):
os.execvp(args[0], args)
except:
print('CHILD EXECEPTION:')
import traceback
traceback.print_exc()
finally:
os._exit(255)
try:
self.poll = select.poll()
self.poll.register(self.fd, select.POLLIN | select.POLLPRI | select.POLLERR | select.POLLHUP | select.POLLNVAL)
self.poll.register(self.fd, select.POLLIN | select.POLLPRI | select.POLLERR |
select.POLLHUP | select.POLLNVAL)
except:
self.close()
raise
@ -106,7 +108,7 @@ class Spawn(object):
elif os.WIFSIGNALED(status):
signum = os.WTERMSIG(status)
self.exit_code = -signum
self.exit_info = 'signal %d (%s)' % (signum, signal.Signals(signum))
self.exit_info = 'signal %d (%s)' % (signum, signal.Signals(signum).name)
self.waited = True
return False, self.exit_code, self.exit_info
@ -196,13 +198,11 @@ class Spawn(object):
# shouldn't and explain why. This is much more friendly than
# just dying with an I/O error
if err.errno == 5: # Input/output error
alive, exit_code, info = self.checkalive()
alive, _, info = self.checkalive()
if alive:
raise
else:
raise err
raise ValueError('U-Boot exited with %s' % info)
else:
raise
raise err
if self.logfile_read:
self.logfile_read.write(c)
self.buf += c
@ -227,7 +227,7 @@ class Spawn(object):
"""
os.close(self.fd)
for i in range(100):
for _ in range(100):
if not self.isalive():
break
time.sleep(0.1)

25
test/py/u_boot_utils.py
View file

@ -1,17 +1,20 @@
# SPDX-License-Identifier: GPL-2.0
# Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
# Utility code shared across multiple tests.
"""
Utility code shared across multiple tests.
"""
import hashlib
import inspect
import os
import os.path
import pytest
import pathlib
import signal
import sys
import time
import re
import pytest
def md5sum_data(data):
"""Calculate the MD5 hash of some data.
@ -48,7 +51,7 @@ def md5sum_file(fn, max_length=None):
data = fh.read(*params)
return md5sum_data(data)
class PersistentRandomFile(object):
class PersistentRandomFile:
"""Generate and store information about a persistent file containing
random data."""
@ -144,7 +147,7 @@ def wait_until_file_open_fails(fn, ignore_errors):
Nothing.
"""
for i in range(100):
for _ in range(100):
fh = attempt_to_open_file(fn)
if not fh:
return
@ -193,9 +196,9 @@ def run_and_log_expect_exception(u_boot_console, cmd, retcode, msg):
try:
runner = u_boot_console.log.get_runner(cmd[0], sys.stdout)
runner.run(cmd)
except Exception as e:
assert(retcode == runner.exit_status)
assert(msg in runner.output)
except Exception:
assert retcode == runner.exit_status
assert msg in runner.output
else:
raise Exception("Expected an exception with retcode %d message '%s',"
"but it was not raised" % (retcode, msg))
@ -280,17 +283,17 @@ class PersistentFileHelperCtxMgr(object):
if filename_timestamp < self.module_timestamp:
self.log.action('Removing stale generated file ' +
self.filename)
os.unlink(self.filename)
pathlib.Path(self.filename).unlink()
def __exit__(self, extype, value, traceback):
if extype:
try:
os.path.unlink(self.filename)
except:
pathlib.Path(self.filename).unlink()
except Exception:
pass
return
logged = False
for i in range(20):
for _ in range(20):
filename_timestamp = os.path.getmtime(self.filename)
if filename_timestamp > self.module_timestamp:
break

20
tools/relocate-rela.c
View file

@ -63,7 +63,7 @@ int main(int argc, char **argv)
{
FILE *f;
int i, num;
uint64_t rela_start, rela_end, text_base;
uint64_t rela_start, rela_end, text_base, file_size;
if (argc != 5) {
fprintf(stderr, "Statically apply ELF rela relocations\n");
@ -87,8 +87,7 @@ int main(int argc, char **argv)
return 3;
}
if (rela_start > rela_end || rela_start < text_base ||
(rela_end - rela_start) % sizeof(Elf64_Rela)) {
if (rela_start > rela_end || rela_start < text_base) {
fprintf(stderr, "%s: bad rela bounds\n", argv[0]);
return 3;
}
@ -96,6 +95,21 @@ int main(int argc, char **argv)
rela_start -= text_base;
rela_end -= text_base;
fseek(f, 0, SEEK_END);
file_size = ftell(f);
rewind(f);
if (rela_end > file_size) {
// Most likely compiler inserted some section that didn't get
// objcopy-ed into the final binary
rela_end = file_size;
}
if ((rela_end - rela_start) % sizeof(Elf64_Rela)) {
fprintf(stderr, "%s: rela size isn't a multiple of Elf64_Rela\n", argv[0]);
return 3;
}
num = (rela_end - rela_start) / sizeof(Elf64_Rela);
for (i = 0; i < num; i++) {