leandrof/u-boot
1
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'next'

Browse Source 
Signed-off-by: Tom Rini <trini@konsulko.com>
This commit is contained in:
Tom Rini
2021-01-11 13:55:03 -05:00
parent c4fddedc48 bc0b99bd8b
commit d71be19902
1517 changed files with 16850 additions and 8686 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
common/Kconfig.boot
View File

@@ -865,6 +865,23 @@ config BOOTARGS
CONFIG_BOOTARGS goes into the environment value "bootargs". Note that
this value will also override the "chosen" node in FDT blob.
config BOOTARGS_SUBST
bool "Support substituting strings in boot arguments"
help
This allows substituting string values in the boot arguments. These
are applied after the commandline has been built.
One use for this is to insert the root-disk UUID into the command
line where bootargs contains "root=${uuid}"
setenv bootargs "console= root=${uuid}"
# Set the 'uuid' environment variable
part uuid mmc 2:2 uuid
# Command-line substitution will put the real uuid into the
# kernel command line
bootm
config USE_BOOTCOMMAND
bool "Enable a default value for bootcmd"
help

174
common/bootm.c
View File

@@ -7,6 +7,7 @@
#ifndef USE_HOSTCC
#include <common.h>
#include <bootstage.h>
#include <cli.h>
#include <cpu_func.h>
#include <env.h>
#include <errno.h>
@@ -19,6 +20,7 @@
#include <net.h>
#include <asm/cache.h>
#include <asm/io.h>
#include <linux/sizes.h>
#if defined(CONFIG_CMD_USB)
#include <usb.h>
#endif
@@ -35,6 +37,8 @@
#define CONFIG_SYS_BOOTM_LEN 0x800000
#endif
#define MAX_CMDLINE_SIZE SZ_4K
#define IH_INITRD_ARCH IH_ARCH_DEFAULT
#ifndef USE_HOSTCC
@@ -465,18 +469,34 @@ ulong bootm_disable_interrupts(void)
return iflag;
}
#if defined(CONFIG_SILENT_CONSOLE) && !defined(CONFIG_SILENT_U_BOOT_ONLY)
#define CONSOLE_ARG "console="
#define CONSOLE_ARG_SIZE sizeof(CONSOLE_ARG)
#define CONSOLE_ARG "console="
#define CONSOLE_ARG_LEN (sizeof(CONSOLE_ARG) - 1)
static void fixup_silent_linux(void)
/**
* fixup_silent_linux() - Handle silencing the linux boot if required
*
* This uses the silent_linux envvar to control whether to add/set a "console="
* parameter to the command line
*
* @buf: Buffer containing the string to process
* @maxlen: Maximum length of buffer
* @return 0 if OK, -ENOSPC if @maxlen is too small
*/
static int fixup_silent_linux(char *buf, int maxlen)
{
char *buf;
const char *env_val;
char *cmdline = env_get("bootargs");
int want_silent;
char *cmdline;
int size;
/*
* Move the input string to the end of buffer. The output string will be
* built up at the start.
*/
size = strlen(buf) + 1;
if (size * 2 > maxlen)
return -ENOSPC;
cmdline = buf + maxlen - size;
memmove(cmdline, buf, size);
/*
* Only fix cmdline when requested. The environment variable can be:
*
@@ -486,44 +506,132 @@ static void fixup_silent_linux(void)
*/
want_silent = env_get_yesno("silent_linux");
if (want_silent == 0)
return;
return 0;
else if (want_silent == -1 && !(gd->flags & GD_FLG_SILENT))
return;
return 0;
debug("before silent fix-up: %s\n", cmdline);
if (cmdline && (cmdline[0] != '\0')) {
if (*cmdline) {
char *start = strstr(cmdline, CONSOLE_ARG);
/* Allocate space for maximum possible new command line */
buf = malloc(strlen(cmdline) + 1 + CONSOLE_ARG_LEN + 1);
if (!buf) {
debug("%s: out of memory\n", __func__);
return;
}
/* Check space for maximum possible new command line */
if (size + CONSOLE_ARG_SIZE > maxlen)
return -ENOSPC;
if (start) {
char *end = strchr(start, ' ');
int num_start_bytes = start - cmdline + CONSOLE_ARG_LEN;
int start_bytes;
strncpy(buf, cmdline, num_start_bytes);
start_bytes = start - cmdline + CONSOLE_ARG_SIZE - 1;
strncpy(buf, cmdline, start_bytes);
if (end)
strcpy(buf + num_start_bytes, end);
strcpy(buf + start_bytes, end);
else
buf[num_start_bytes] = '\0';
buf[start_bytes] = '\0';
} else {
sprintf(buf, "%s %s", cmdline, CONSOLE_ARG);
}
env_val = buf;
if (buf + strlen(buf) >= cmdline)
return -ENOSPC;
} else {
buf = NULL;
env_val = CONSOLE_ARG;
if (maxlen < sizeof(CONSOLE_ARG))
return -ENOSPC;
strcpy(buf, CONSOLE_ARG);
}
debug("after silent fix-up: %s\n", buf);
return 0;
}
/**
* process_subst() - Handle substitution of ${...} fields in the environment
*
* Handle variable substitution in the provided buffer
*
* @buf: Buffer containing the string to process
* @maxlen: Maximum length of buffer
* @return 0 if OK, -ENOSPC if @maxlen is too small
*/
static int process_subst(char *buf, int maxlen)
{
char *cmdline;
int size;
int ret;
/* Move to end of buffer */
size = strlen(buf) + 1;
cmdline = buf + maxlen - size;
if (buf + size > cmdline)
return -ENOSPC;
memmove(cmdline, buf, size);
ret = cli_simple_process_macros(cmdline, buf, cmdline - buf);
return ret;
}
int bootm_process_cmdline(char *buf, int maxlen, int flags)
{
int ret;
/* Check config first to enable compiler to eliminate code */
if (IS_ENABLED(CONFIG_SILENT_CONSOLE) &&
!IS_ENABLED(CONFIG_SILENT_U_BOOT_ONLY) &&
(flags & BOOTM_CL_SILENT)) {
ret = fixup_silent_linux(buf, maxlen);
if (ret)
return log_msg_ret("silent", ret);
}
if (IS_ENABLED(CONFIG_BOOTARGS_SUBST) && (flags & BOOTM_CL_SUBST)) {
ret = process_subst(buf, maxlen);
if (ret)
return log_msg_ret("silent", ret);
}
env_set("bootargs", env_val);
debug("after silent fix-up: %s\n", env_val);
free(buf);
return 0;
}
int bootm_process_cmdline_env(int flags)
{
const int maxlen = MAX_CMDLINE_SIZE;
bool do_silent;
const char *env;
char *buf;
int ret;
/* First check if any action is needed */
do_silent = IS_ENABLED(CONFIG_SILENT_CONSOLE) &&
!IS_ENABLED(CONFIG_SILENT_U_BOOT_ONLY) && (flags & BOOTM_CL_SILENT);
if (!do_silent && !IS_ENABLED(CONFIG_BOOTARGS_SUBST))
return 0;
env = env_get("bootargs");
if (env && strlen(env) >= maxlen)
return -E2BIG;
buf = malloc(maxlen);
if (!buf)
return -ENOMEM;
if (env)
strcpy(buf, env);
else
*buf = '\0';
ret = bootm_process_cmdline(buf, maxlen, flags);
if (!ret) {
ret = env_set("bootargs", buf);
/*
* If buf is "" and bootargs does not exist, this will produce
* an error trying to delete bootargs. Ignore it
*/
if (ret == -ENOENT)
ret = 0;
}
free(buf);
if (ret)
return log_msg_ret("env", ret);
return 0;
}
#endif /* CONFIG_SILENT_CONSOLE */
/**
* Execute selected states of the bootm command.
@@ -627,10 +735,12 @@ int do_bootm_states(struct cmd_tbl *cmdtp, int flag, int argc,
if (!ret && (states & BOOTM_STATE_OS_BD_T))
ret = boot_fn(BOOTM_STATE_OS_BD_T, argc, argv, images);
if (!ret && (states & BOOTM_STATE_OS_PREP)) {
#if defined(CONFIG_SILENT_CONSOLE) && !defined(CONFIG_SILENT_U_BOOT_ONLY)
if (images->os.os == IH_OS_LINUX)
fixup_silent_linux();
#endif
ret = bootm_process_cmdline_env(images->os.os == IH_OS_LINUX);
if (ret) {
printf("Cmdline setup failed (err=%d)\n", ret);
ret = CMD_RET_FAILURE;
goto err;
}
ret = boot_fn(BOOTM_STATE_OS_PREP, argc, argv, images);
}

3
common/cli_hush.c
View File

@@ -84,9 +84,6 @@
#include <cli.h>
#include <cli_hush.h>
#include <command.h> /* find_cmd */
#ifndef CONFIG_SYS_PROMPT_HUSH_PS2
#define CONFIG_SYS_PROMPT_HUSH_PS2 "> "
#endif
#endif
#ifndef __U_BOOT__
#include <ctype.h> /* isalpha, isdigit */

17
common/cli_simple.c
View File

@@ -60,13 +60,14 @@ int cli_simple_parse_line(char *line, char *argv[])
return nargs;
}
void cli_simple_process_macros(const char *input, char *output)
int cli_simple_process_macros(const char *input, char *output, int max_size)
{
char c, prev;
const char *varname_start = NULL;
int inputcnt = strlen(input);
int outputcnt = CONFIG_SYS_CBSIZE;
int outputcnt = max_size;
int state = 0; /* 0 = waiting for '$' */
int ret;
/* 1 = waiting for '(' or '{' */
/* 2 = waiting for ')' or '}' */
@@ -157,13 +158,18 @@ void cli_simple_process_macros(const char *input, char *output)
prev = c;
}
if (outputcnt)
ret = inputcnt ? -ENOSPC : 0;
if (outputcnt) {
*output = 0;
else
} else {
*(output - 1) = 0;
ret = -ENOSPC;
}
debug_parser("[PROCESS_MACROS] OUTPUT len %zd: \"%s\"\n",
strlen(output_start), output_start);
return ret;
}
/*
@@ -239,7 +245,8 @@ int cli_simple_run_command(const char *cmd, int flag)
debug_parser("token: \"%s\"\n", token);
/* find macros in this token and replace them */
cli_simple_process_macros(token, finaltoken);
cli_simple_process_macros(token, finaltoken,
sizeof(finaltoken));
/* Extract arguments */
argc = cli_simple_parse_line(finaltoken, argv);

4
common/command.c
View File

@@ -475,13 +475,13 @@ int cmd_get_data_size(char* arg, int default_size)
case 'l':
return 4;
case 's':
return -2;
return CMD_DATA_SIZE_STR;
case 'q':
if (MEM_SUPPORT_64BIT_DATA)
return 8;
/* no break */
default:
return -1;
return CMD_DATA_SIZE_ERR;
}
}
return default_size;

3
common/image-fdt.c
View File

@@ -407,6 +407,9 @@ int boot_get_fdt(int flag, int argc, char *const argv[], uint8_t arch,
&fit_uname_config,
arch, &load, &len);
if (fdt_noffset < 0)
goto error;
images->fit_hdr_fdt = map_sysmem(fdt_addr, 0);
images->fit_uname_fdt = fit_uname_fdt;
images->fit_noffset_fdt = fdt_noffset;

4
common/lcd_simplefb.c
View File

@@ -22,7 +22,7 @@ static int lcd_dt_simplefb_configure_node(void *blob, int off)
const char *name;
ulong fb_base;
#ifdef CONFIG_DM_VIDEO
struct video_uc_platdata *plat;
struct video_uc_plat *plat;
struct video_priv *uc_priv;
struct udevice *dev;
int ret;
@@ -31,7 +31,7 @@ static int lcd_dt_simplefb_configure_node(void *blob, int off)
if (ret)
return ret;
uc_priv = dev_get_uclass_priv(dev);
plat = dev_get_uclass_platdata(dev);
plat = dev_get_uclass_plat(dev);
xsize = uc_priv->xsize;
ysize = uc_priv->ysize;
bpix = uc_priv->bpix;

4
common/main.c
View File

@@ -16,6 +16,7 @@
#include <init.h>
#include <net.h>
#include <version.h>
#include <efi_loader.h>
static void run_preboot_environment_command(void)
{
@@ -53,6 +54,9 @@ void main_loop(void)
if (IS_ENABLED(CONFIG_UPDATE_TFTP))
update_tftp(0UL, NULL, NULL);
if (IS_ENABLED(CONFIG_EFI_CAPSULE_ON_DISK_EARLY))
efi_launch_capsules();
s = bootdelay_process();
if (cli_process_fdt(&s))
cli_secure_boot_cmd(s);

18
common/spl/Kconfig
View File

@@ -113,6 +113,15 @@ config SPL_FSL_PBL
Create boot binary having SPL binary in PBI format concatenated with
u-boot binary.
config SPL_ALLOC_BD
bool "Allocate memory for bd_info"
default y if X86 || SANDBOX
help
Some boards don't allocate space for this in their board_init_f()
code. In this case U-Boot can allocate space for gd->bd in the
standard SPL flow (board_init_r()). Enable this option to support
this feature.
endmenu
config HANDOFF
@@ -1276,6 +1285,15 @@ config SPL_ATF
is loaded by SPL (which is considered as BL2 in ATF terminology).
More detail at: https://github.com/ARM-software/arm-trusted-firmware
config SPL_ATF_LOAD_IMAGE_V2
bool "Use the new LOAD_IMAGE_V2 parameter passing"
depends on SPL_ATF
help
Some platforms use the newer LOAD_IMAGE_V2 parameter passing.
If you want to load a bl31 image from the SPL and need the new
method, say Y.
config SPL_ATF_NO_PLATFORM_PARAM
bool "Pass no platform parameter"
depends on SPL_ATF

20
common/spl/spl.c
View File

@@ -53,9 +53,6 @@ binman_sym_declare(ulong, spl, image_pos);
binman_sym_declare(ulong, spl, size);
#endif
/* Define board data structure */
static struct bd_info bdata __attribute__ ((section(".data")));
/*
* Board-specific Platform code can reimplement show_boot_progress () if needed
*/
@@ -443,14 +440,19 @@ static int spl_common_init(bool setup_malloc)
return 0;
}
void spl_set_bd(void)
int spl_alloc_bd(void)
{
/*
* NOTE: On some platforms (e.g. x86) bdata may be in flash and not
* writeable.
*/
if (!gd->bd)
gd->bd = &bdata;
if (!gd->bd) {
gd->bd = malloc(sizeof(*gd->bd));
if (!gd->bd)
return -ENOMEM;
}
return 0;
}
int spl_early_init(void)
@@ -600,8 +602,6 @@ void board_init_r(gd_t *dummy1, ulong dummy2)
debug(">>" SPL_TPL_PROMPT "board_init_r()\n");
spl_set_bd();
#if defined(CONFIG_SYS_SPL_MALLOC_START)
mem_malloc_init(CONFIG_SYS_SPL_MALLOC_START,
CONFIG_SYS_SPL_MALLOC_SIZE);
@@ -611,6 +611,10 @@ void board_init_r(gd_t *dummy1, ulong dummy2)
if (spl_init())
hang();
}
if (IS_ENABLED(CONFIG_SPL_ALLOC_BD) && spl_alloc_bd()) {
puts("Cannot alloc bd\n");
hang();
}
#if !defined(CONFIG_PPC) && !defined(CONFIG_ARCH_MX6)
/*
* timer_init() does not exist on PPC systems. The timer is initialized

127
common/spl/spl_atf.c
View File

@@ -18,13 +18,36 @@
#include <spl.h>
#include <asm/cache.h>
static struct bl2_to_bl31_params_mem bl31_params_mem;
static struct bl31_params *bl2_to_bl31_params;
/* Holds all the structures we need for bl31 parameter passing */
struct bl2_to_bl31_params_mem {
struct bl31_params bl31_params;
struct atf_image_info bl31_image_info;
struct atf_image_info bl32_image_info;
struct atf_image_info bl33_image_info;
struct entry_point_info bl33_ep_info;
struct entry_point_info bl32_ep_info;
struct entry_point_info bl31_ep_info;
};
__weak struct bl31_params *bl2_plat_get_bl31_params(uintptr_t bl32_entry,
uintptr_t bl33_entry,
uintptr_t fdt_addr)
struct bl2_to_bl31_params_mem_v2 {
struct bl_params bl_params;
struct bl_params_node bl31_params_node;
struct bl_params_node bl32_params_node;
struct bl_params_node bl33_params_node;
struct atf_image_info bl31_image_info;
struct atf_image_info bl32_image_info;
struct atf_image_info bl33_image_info;
struct entry_point_info bl33_ep_info;
struct entry_point_info bl32_ep_info;
struct entry_point_info bl31_ep_info;
};
struct bl31_params *bl2_plat_get_bl31_params_default(uintptr_t bl32_entry,
uintptr_t bl33_entry,
uintptr_t fdt_addr)
{
static struct bl2_to_bl31_params_mem bl31_params_mem;
struct bl31_params *bl2_to_bl31_params;
struct entry_point_info *bl32_ep_info;
struct entry_point_info *bl33_ep_info;
@@ -78,6 +101,87 @@ __weak struct bl31_params *bl2_plat_get_bl31_params(uintptr_t bl32_entry,
return bl2_to_bl31_params;
}
__weak struct bl31_params *bl2_plat_get_bl31_params(uintptr_t bl32_entry,
uintptr_t bl33_entry,
uintptr_t fdt_addr)
{
return bl2_plat_get_bl31_params_default(bl32_entry, bl33_entry,
fdt_addr);
}
struct bl_params *bl2_plat_get_bl31_params_v2_default(uintptr_t bl32_entry,
uintptr_t bl33_entry,
uintptr_t fdt_addr)
{
static struct bl2_to_bl31_params_mem_v2 bl31_params_mem;
struct bl_params *bl_params;
struct bl_params_node *bl_params_node;
/*
* Initialise the memory for all the arguments that needs to
* be passed to BL31
*/
memset(&bl31_params_mem, 0, sizeof(bl31_params_mem));
/* Assign memory for TF related information */
bl_params = &bl31_params_mem.bl_params;
SET_PARAM_HEAD(bl_params, ATF_PARAM_BL_PARAMS, ATF_VERSION_2, 0);
bl_params->head = &bl31_params_mem.bl31_params_node;
/* Fill BL31 related information */
bl_params_node = &bl31_params_mem.bl31_params_node;
bl_params_node->image_id = ATF_BL31_IMAGE_ID;
bl_params_node->image_info = &bl31_params_mem.bl31_image_info;
bl_params_node->ep_info = &bl31_params_mem.bl31_ep_info;
bl_params_node->next_params_info = &bl31_params_mem.bl32_params_node;
SET_PARAM_HEAD(bl_params_node->image_info, ATF_PARAM_IMAGE_BINARY,
ATF_VERSION_2, 0);
/* Fill BL32 related information */
bl_params_node = &bl31_params_mem.bl32_params_node;
bl_params_node->image_id = ATF_BL32_IMAGE_ID;
bl_params_node->image_info = &bl31_params_mem.bl32_image_info;
bl_params_node->ep_info = &bl31_params_mem.bl32_ep_info;
bl_params_node->next_params_info = &bl31_params_mem.bl33_params_node;
SET_PARAM_HEAD(bl_params_node->ep_info, ATF_PARAM_EP,
ATF_VERSION_2, ATF_EP_SECURE);
/* secure payload is optional, so set pc to 0 if absent */
bl_params_node->ep_info->args.arg3 = fdt_addr;
bl_params_node->ep_info->pc = bl32_entry ? bl32_entry : 0;
bl_params_node->ep_info->spsr = SPSR_64(MODE_EL1, MODE_SP_ELX,
DISABLE_ALL_EXECPTIONS);
SET_PARAM_HEAD(bl_params_node->image_info, ATF_PARAM_IMAGE_BINARY,
ATF_VERSION_2, 0);
/* Fill BL33 related information */
bl_params_node = &bl31_params_mem.bl33_params_node;
bl_params_node->image_id = ATF_BL33_IMAGE_ID;
bl_params_node->image_info = &bl31_params_mem.bl33_image_info;
bl_params_node->ep_info = &bl31_params_mem.bl33_ep_info;
bl_params_node->next_params_info = NULL;
SET_PARAM_HEAD(bl_params_node->ep_info, ATF_PARAM_EP,
ATF_VERSION_2, ATF_EP_NON_SECURE);
/* BL33 expects to receive the primary CPU MPID (through x0) */
bl_params_node->ep_info->args.arg0 = 0xffff & read_mpidr();
bl_params_node->ep_info->pc = bl33_entry;
bl_params_node->ep_info->spsr = SPSR_64(MODE_EL2, MODE_SP_ELX,
DISABLE_ALL_EXECPTIONS);
SET_PARAM_HEAD(bl_params_node->image_info, ATF_PARAM_IMAGE_BINARY,
ATF_VERSION_2, 0);
return bl_params;
}
__weak struct bl_params *bl2_plat_get_bl31_params_v2(uintptr_t bl32_entry,
uintptr_t bl33_entry,
uintptr_t fdt_addr)
{
return bl2_plat_get_bl31_params_v2_default(bl32_entry, bl33_entry,
fdt_addr);
}
static inline void raw_write_daif(unsigned int daif)
{
__asm__ __volatile__("msr DAIF, %0\n\t" : : "r" (daif) : "memory");
@@ -88,16 +192,21 @@ typedef void (*atf_entry_t)(struct bl31_params *params, void *plat_params);
static void bl31_entry(uintptr_t bl31_entry, uintptr_t bl32_entry,
uintptr_t bl33_entry, uintptr_t fdt_addr)
{
struct bl31_params *bl31_params;
atf_entry_t atf_entry = (atf_entry_t)bl31_entry;
void *bl31_params;
bl31_params = bl2_plat_get_bl31_params(bl32_entry, bl33_entry,
fdt_addr);
if (CONFIG_IS_ENABLED(ATF_LOAD_IMAGE_V2))
bl31_params = bl2_plat_get_bl31_params_v2(bl32_entry,
bl33_entry,
fdt_addr);
else
bl31_params = bl2_plat_get_bl31_params(bl32_entry, bl33_entry,
fdt_addr);
raw_write_daif(SPSR_EXCEPTION_MASK);
dcache_disable();
atf_entry((void *)bl31_params, (void *)fdt_addr);
atf_entry(bl31_params, (void *)fdt_addr);
}
static int spl_fit_images_find(void *blob, int os)

47
common/spl/spl_fit.c
View File

@@ -494,6 +494,23 @@ static int spl_fit_image_get_os(const void *fit, int noffset, uint8_t *os)
#endif
}
/*
* The purpose of the FIT load buffer is to provide a memory location that is
* independent of the load address of any FIT component.
*/
static void *spl_get_fit_load_buffer(size_t size)
{
void *buf;
buf = malloc(size);
if (!buf) {
pr_err("Could not get FIT buffer of %lu bytes\n", (ulong)size);
pr_err("\tcheck CONFIG_SYS_SPL_MALLOC_SIZE\n");
buf = spl_get_load_buffer(0, size);
}
return buf;
}
/*
* Weak default function to allow customizing SPL fit loading for load-only
* use cases by allowing to skip the parsing/processing of the FIT contents
@@ -508,12 +525,12 @@ int spl_load_simple_fit(struct spl_image_info *spl_image,
struct spl_load_info *info, ulong sector, void *fit)
{
int sectors;
ulong size;
ulong size, hsize;
unsigned long count;
struct spl_image_info image_info;
int node = -1;
int images, ret;
int base_offset, hsize, align_len = ARCH_DMA_MINALIGN - 1;
int base_offset;
int index = 0;
int firmware_node;
@@ -529,24 +546,14 @@ int spl_load_simple_fit(struct spl_image_info *spl_image,
/*
* So far we only have one block of data from the FIT. Read the entire
* thing, including that first block, placing it so it finishes before
* where we will load the image.
*
* Note that we will load the image such that its first byte will be
* at the load address. Since that byte may be part-way through a
* block, we may load the image up to one block before the load
* address. So take account of that here by subtracting an addition
* block length from the FIT start position.
*
* In fact the FIT has its own load address, but we assume it cannot
* be before CONFIG_SYS_TEXT_BASE.
* thing, including that first block.
*
* For FIT with data embedded, data is loaded as part of FIT image.
* For FIT with external data, data is not loaded in this step.
*/
hsize = (size + info->bl_len + align_len) & ~align_len;
fit = spl_get_load_buffer(-hsize, hsize);
sectors = get_aligned_image_size(info, size, 0);
hsize = sectors * info->bl_len;
fit = spl_get_fit_load_buffer(hsize);
count = info->read(info, sector, sectors, fit);
debug("fit read sector %lx, sectors=%d, dst=%p, count=%lu, size=0x%lx\n",
sector, sectors, fit, count, size);
@@ -558,6 +565,16 @@ int spl_load_simple_fit(struct spl_image_info *spl_image,
if (spl_load_simple_fit_skip_processing())
return 0;
if (IS_ENABLED(CONFIG_SPL_FIT_SIGNATURE)) {
int conf_offset = fit_find_config_node(fit);
printf("## Checking hash(es) for config %s ... ",
fit_get_name(fit, conf_offset, NULL));
if (fit_config_verify(fit, conf_offset))
return -EPERM;
puts("OK\n");
}
/* find the node holding the images information */
images = fdt_path_offset(fit, FIT_IMAGES_PATH);
if (images < 0) {

6
common/usb_hub.c
View File

@@ -958,9 +958,9 @@ UCLASS_DRIVER(usb_hub) = {
.post_bind = dm_scan_fdt_dev,
.post_probe = usb_hub_post_probe,
.child_pre_probe = usb_child_pre_probe,
.per_child_auto_alloc_size = sizeof(struct usb_device),
.per_child_platdata_auto_alloc_size = sizeof(struct usb_dev_platdata),
.per_device_auto_alloc_size = sizeof(struct usb_hub_device),
.per_child_auto = sizeof(struct usb_device),
.per_child_plat_auto = sizeof(struct usb_dev_plat),
.per_device_auto = sizeof(struct usb_hub_device),
};
static const struct usb_device_id hub_id_table[] = {

18
common/usb_storage.c
View File

@@ -146,7 +146,7 @@ int usb_stor_info(void)
for (blk_first_device(IF_TYPE_USB, &dev);
dev;
blk_next_device(&dev)) {
struct blk_desc *desc = dev_get_uclass_platdata(dev);
struct blk_desc *desc = dev_get_uclass_plat(dev);
printf(" Device %d: ", desc->devnum);
dev_print(desc);
@@ -203,11 +203,11 @@ static int usb_stor_probe_device(struct usb_device *udev)
debug("\n\nProbing for storage\n");
#if CONFIG_IS_ENABLED(BLK)
/*
* We store the us_data in the mass storage device's platdata. It
* We store the us_data in the mass storage device's plat. It
* is shared by all LUNs (block devices) attached to this mass storage
* device.
*/
data = dev_get_platdata(udev->dev);
data = dev_get_plat(udev->dev);
if (!usb_storage_probe(udev, 0, data))
return 0;
max_lun = usb_get_max_lun(data);
@@ -225,7 +225,7 @@ static int usb_stor_probe_device(struct usb_device *udev)
return ret;
}
blkdev = dev_get_uclass_platdata(dev);
blkdev = dev_get_uclass_plat(dev);
blkdev->target = 0xff;
blkdev->lun = lun;
@@ -431,8 +431,8 @@ static int us_one_transfer(struct us_data *us, int pipe, char *buf, int length)
return 0;
}
/* if our try counter reaches 0, bail out */
debug(" %ld, data %d\n",
us->pusb_dev->status, partial);
debug(" %ld, data %d\n",
us->pusb_dev->status, partial);
if (!maxtry--)
return result;
}
@@ -1147,7 +1147,7 @@ static unsigned long usb_stor_read(struct blk_desc *block_dev, lbaint_t blknr,
return 0;
/* Setup device */
#if CONFIG_IS_ENABLED(BLK)
block_dev = dev_get_uclass_platdata(dev);
block_dev = dev_get_uclass_plat(dev);
udev = dev_get_parent_priv(dev_get_parent(dev));
debug("\nusb_read: udev %d\n", block_dev->devnum);
#else
@@ -1231,7 +1231,7 @@ static unsigned long usb_stor_write(struct blk_desc *block_dev, lbaint_t blknr,
/* Setup device */
#if CONFIG_IS_ENABLED(BLK)
block_dev = dev_get_uclass_platdata(dev);
block_dev = dev_get_uclass_plat(dev);
udev = dev_get_parent_priv(dev_get_parent(dev));
debug("\nusb_read: udev %d\n", block_dev->devnum);
#else
@@ -1529,7 +1529,7 @@ U_BOOT_DRIVER(usb_mass_storage) = {
.of_match = usb_mass_storage_ids,
.probe = usb_mass_storage_probe,
#if CONFIG_IS_ENABLED(BLK)
.platdata_auto_alloc_size = sizeof(struct us_data),
.plat_auto = sizeof(struct us_data),
#endif
};