Difuse/u-boot
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge branch 'master' of https://source.denx.de/u-boot/custodians/u-boot-marvell

Browse source 
- mvebu: Boot support for 4K Native disks (Pali)
- a38x: Perform DDR training sequence again for 2nd boot (Tony)
This commit is contained in:
Tom Rini 2023-04-14 10:50:55 -04:00
commit 12c1e57824
37 changed files with 199 additions and 91 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
arch/arm/mach-mvebu/Kconfig
View file

@ -381,6 +381,16 @@ config MVEBU_SPL_NAND_BADBLK_LOCATION
Value 0x0 = SLC flash = BBI at page 0 or page 1
Value 0x1 = MLC flash = BBI at last page in the block
config MVEBU_SPL_SATA_BLKSZ
int "SATA block size"
depends on MVEBU_SPL_BOOT_DEVICE_SATA
range 512 32768
default 512
help
Block size of the SATA disk in bytes.
Typically 512 bytes for majority of disks
and 4096 bytes for 4K Native disks.
config MVEBU_EFUSE
bool "Enable eFuse support"
depends on HAVE_MVEBU_EFUSE

5
arch/arm/mach-mvebu/Makefile
View file

@ -73,6 +73,11 @@ KWB_CFG_NAND_BLKSZ = $(CONFIG_SYS_NAND_BLOCK_SIZE)
KWB_CFG_NAND_BADBLK_LOCATION = $(CONFIG_MVEBU_SPL_NAND_BADBLK_LOCATION)
endif
ifneq ($(CONFIG_MVEBU_SPL_BOOT_DEVICE_SATA),)
KWB_REPLACE += SATA_BLKSZ
KWB_CFG_SATA_BLKSZ = $(CONFIG_MVEBU_SPL_SATA_BLKSZ)
endif
ifneq ($(CONFIG_SECURED_MODE_IMAGE),)
KWB_REPLACE += CSK_INDEX
KWB_CFG_CSK_INDEX = $(CONFIG_SECURED_MODE_CSK_INDEX)

3
arch/arm/mach-mvebu/kwbimage.cfg.in
View file

@ -16,6 +16,9 @@ VERSION 1
#@NAND_BLKSZ
#@NAND_BADBLK_LOCATION
# SATA configuration
#@SATA_BLKSZ
# Enable BootROM output via DEBUG flag on SoCs which require it
#@DEBUG

11
arch/arm/mach-mvebu/spl.c
View file

@ -208,10 +208,15 @@ int spl_parse_board_header(struct spl_image_info *spl_image,
/*
* For SATA srcaddr is specified in number of sectors.
* This expects that sector size is 512 bytes.
* Retrieve block size of the first SCSI device (same
* code used by the spl_sata_load_image_raw() function)
* or fallback to default sector size of 512 bytes.
*/
if (IS_ENABLED(CONFIG_SPL_SATA) && mhdr->blockid == IBR_HDR_SATA_ID)
spl_image->offset *= 512;
if (IS_ENABLED(CONFIG_SPL_SATA) && mhdr->blockid == IBR_HDR_SATA_ID) {
struct blk_desc *blk_dev = blk_get_devnum_by_uclass_id(UCLASS_SCSI, 0);
unsigned long blksz = blk_dev ? blk_dev->blksz : 512;
spl_image->offset *= blksz;
}
if (spl_image->offset % 4 != 0) {
printf("ERROR: Wrong srcaddr (0x%08x) in kwbimage\n",

7
cmd/mvebu/bubt.c
View file

@ -924,8 +924,11 @@ static int check_image_header(void)
offset = le32_to_cpu(hdr->srcaddr);
size = le32_to_cpu(hdr->blocksize);
if (hdr->blockid == 0x78) /* SATA id */
offset *= 512;
if (hdr->blockid == 0x78) { /* SATA id */
struct blk_desc *blk_dev = IS_ENABLED(BLK) ? blk_get_devnum_by_uclass_id(UCLASS_SCSI, 0) : NULL;
unsigned long blksz = blk_dev ? blk_dev->blksz : 512;
offset *= blksz;
}
if (offset % 4 != 0 || size < 4 || size % 4 != 0) {
printf("Error: Bad A38x image blocksize.\n");

7
drivers/ddr/marvell/a38x/mv_ddr_plat.c
View file

@ -1363,13 +1363,6 @@ int mv_ddr_pre_training_soc_config(const char *ddr_type)
DRAM_RESET_MASK_MASKED << DRAM_RESET_MASK_OFFS);
}
/* Check if DRAM is already initialized */
if (reg_read(REG_BOOTROM_ROUTINE_ADDR) &
(1 << REG_BOOTROM_ROUTINE_DRAM_INIT_OFFS)) {
printf("%s Training Sequence - 2nd boot - Skip\n", ddr_type);
return MV_OK;
}
/* Fix read ready phases for all SOC in reg 0x15c8 */
reg_val = reg_read(TRAINING_DBG_3_REG);

2
tools/aisimage.c
View file

@ -113,7 +113,7 @@ static int get_ais_table_id(uint32_t *ptr)
return -1;
}
static void aisimage_print_header(const void *hdr)
static void aisimage_print_header(const void *hdr, struct image_tool_params *params)
{
struct ais_header *ais_hdr = (struct ais_header *)hdr;
uint32_t *ptr;

2
tools/atmelimage.c
View file

@ -182,7 +182,7 @@ static void atmel_print_pmecc_header(const uint32_t word)
printf("\t\t====================\n");
}
static void atmel_print_header(const void *ptr)
static void atmel_print_header(const void *ptr, struct image_tool_params *params)
{
uint32_t *ints = (uint32_t *)ptr;
size_t pos;

7
tools/default_image.c
View file

@ -41,6 +41,11 @@ static int image_check_params(struct image_tool_params *params)
(params->lflag && (params->dflag || params->fflag)));
}
static void image_print_header(const void *ptr, struct image_tool_params *params)
{
image_print_contents(ptr);
}
static int image_verify_header(unsigned char *ptr, int image_size,
struct image_tool_params *params)
{
@ -201,7 +206,7 @@ U_BOOT_IMAGE_TYPE(
(void *)&header,
image_check_params,
image_verify_header,
image_print_contents,
image_print_header,
image_set_header,
image_extract_subimage,
image_check_image_types,

5
tools/fit_common.c
View file

@ -23,6 +23,11 @@
#include <image.h>
#include <u-boot/crc.h>
void fit_print_header(const void *fit, struct image_tool_params *params)
{
fit_print_contents(fit);
}
int fit_verify_header(unsigned char *ptr, int image_size,
struct image_tool_params *params)
{

2
tools/fit_common.h
View file

@ -10,6 +10,8 @@
#include "mkimage.h"
#include <image.h>
void fit_print_header(const void *fit, struct image_tool_params *params);
/**
* Verify the format of FIT header pointed to by ptr
*

2
tools/fit_image.c
View file

@ -944,7 +944,7 @@ U_BOOT_IMAGE_TYPE(
(void *)&header,
fit_check_params,
fit_verify_header,
fit_print_contents,
fit_print_header,
NULL,
fit_extract_contents,
fit_check_image_types,

2
tools/gpimage.c
View file

@ -41,7 +41,7 @@ static int gpimage_verify_header(unsigned char *ptr, int image_size,
return gph_verify_header(gph, 1);
}
static void gpimage_print_header(const void *ptr)
static void gpimage_print_header(const void *ptr, struct image_tool_params *params)
{
const struct gp_header *gph = (struct gp_header *)ptr;

4
tools/imagetool.c
View file

@ -66,7 +66,7 @@ int imagetool_verify_print_header(
*/
if ((*curr)->print_header) {
if (!params->quiet)
(*curr)->print_header(ptr);
(*curr)->print_header(ptr, params);
} else {
fprintf(stderr,
"%s: print_header undefined for %s\n",
@ -103,7 +103,7 @@ static int imagetool_verify_print_header_by_type(
*/
if (tparams->print_header) {
if (!params->quiet)
tparams->print_header(ptr);
tparams->print_header(ptr, params);
} else {
fprintf(stderr,
"%s: print_header undefined for %s\n",

2
tools/imagetool.h
View file

@ -132,7 +132,7 @@ struct image_type_params {
*/
int (*verify_header) (unsigned char *, int, struct image_tool_params *);
/* Prints image information abstracting from image header */
void (*print_header) (const void *);
void (*print_header) (const void *, struct image_tool_params *);
/*
* The header or image contents need to be set as per image type to
* be generated using this callback function.

2
tools/imx8image.c
View file

@ -30,7 +30,7 @@ static void imx8image_set_header(void *ptr, struct stat *sbuf, int ifd,
{
}
static void imx8image_print_header(const void *ptr)
static void imx8image_print_header(const void *ptr, struct image_tool_params *params)
{
}

2
tools/imx8mimage.c
View file

@ -60,7 +60,7 @@ static void imx8mimage_set_header(void *ptr, struct stat *sbuf, int ifd,
{
}
static void imx8mimage_print_header(const void *ptr)
static void imx8mimage_print_header(const void *ptr, struct image_tool_params *params)
{
}

2
tools/imximage.c
View file

@ -813,7 +813,7 @@ static int imximage_verify_header(unsigned char *ptr, int image_size,
return 0;
}
static void imximage_print_header(const void *ptr)
static void imximage_print_header(const void *ptr, struct image_tool_params *params)
{
struct imx_header *imx_hdr = (struct imx_header *) ptr;
uint32_t version = detect_imximage_version(imx_hdr);

144
tools/kwbimage.c
View file

@ -116,6 +116,7 @@ enum image_cfg_type {
IMAGE_CFG_NAND_BADBLK_LOCATION,
IMAGE_CFG_NAND_ECC_MODE,
IMAGE_CFG_NAND_PAGESZ,
IMAGE_CFG_SATA_BLKSZ,
IMAGE_CFG_CPU,
IMAGE_CFG_BINARY,
IMAGE_CFG_DATA,
@ -147,6 +148,7 @@ static const char * const id_strs[] = {
[IMAGE_CFG_NAND_BADBLK_LOCATION] = "NAND_BADBLK_LOCATION",
[IMAGE_CFG_NAND_ECC_MODE] = "NAND_ECC_MODE",
[IMAGE_CFG_NAND_PAGESZ] = "NAND_PAGE_SIZE",
[IMAGE_CFG_SATA_BLKSZ] = "SATA_BLKSZ",
[IMAGE_CFG_CPU] = "CPU",
[IMAGE_CFG_BINARY] = "BINARY",
[IMAGE_CFG_DATA] = "DATA",
@ -185,6 +187,7 @@ struct image_cfg_element {
unsigned int nandbadblklocation;
unsigned int nandeccmode;
unsigned int nandpagesz;
unsigned int satablksz;
struct ext_hdr_v0_reg regdata;
unsigned int regdata_delay;
unsigned int baudrate;
@ -992,13 +995,21 @@ static int image_fill_xip_header(void *image, struct image_tool_params *params)
return 1;
}
static unsigned int image_get_satablksz(void)
{
struct image_cfg_element *e;
e = image_find_option(IMAGE_CFG_SATA_BLKSZ);
return e ? e->satablksz : 512;
}
static size_t image_headersz_align(size_t headersz, uint8_t blockid)
{
/*
* Header needs to be 4-byte aligned, which is already ensured by code
* above. Moreover UART images must have header aligned to 128 bytes
* (xmodem block size), NAND images to 256 bytes (ECC calculation),
* and SATA and SDIO images to 512 bytes (storage block size).
* SDIO images to 512 bytes (SDHC/SDXC fixed block size) and SATA
* images to specified storage block size (default 512 bytes).
* Note that SPI images do not have to have header size aligned
* to 256 bytes because it is possible to read from SPI storage from
* any offset (read offset does not have to be aligned to block size).
@ -1007,8 +1018,10 @@ static size_t image_headersz_align(size_t headersz, uint8_t blockid)
return ALIGN(headersz, 128);
else if (blockid == IBR_HDR_NAND_ID)
return ALIGN(headersz, 256);
else if (blockid == IBR_HDR_SATA_ID || blockid == IBR_HDR_SDIO_ID)
else if (blockid == IBR_HDR_SDIO_ID)
return ALIGN(headersz, 512);
else if (blockid == IBR_HDR_SATA_ID)
return ALIGN(headersz, image_get_satablksz());
else
return headersz;
}
@ -1076,12 +1089,11 @@ static void *image_create_v0(size_t *dataoff, struct image_tool_params *params,
if (e)
main_hdr->nandbadblklocation = e->nandbadblklocation;
/*
* For SATA srcaddr is specified in number of sectors.
* This expects the sector size to be 512 bytes.
*/
if (main_hdr->blockid == IBR_HDR_SATA_ID)
main_hdr->srcaddr = cpu_to_le32(le32_to_cpu(main_hdr->srcaddr) / 512);
/* For SATA srcaddr is specified in number of sectors. */
if (main_hdr->blockid == IBR_HDR_SATA_ID) {
params->bl_len = image_get_satablksz();
main_hdr->srcaddr = cpu_to_le32(le32_to_cpu(main_hdr->srcaddr) / params->bl_len);
}
/* For PCIe srcaddr is not used and must be set to 0xFFFFFFFF. */
if (main_hdr->blockid == IBR_HDR_PEX_ID)
@ -1533,12 +1545,11 @@ static void *image_create_v1(size_t *dataoff, struct image_tool_params *params,
if (e)
main_hdr->flags = e->debug ? 0x1 : 0;
/*
* For SATA srcaddr is specified in number of sectors.
* This expects the sector size to be 512 bytes.
*/
if (main_hdr->blockid == IBR_HDR_SATA_ID)
main_hdr->srcaddr = cpu_to_le32(le32_to_cpu(main_hdr->srcaddr) / 512);
/* For SATA srcaddr is specified in number of sectors. */
if (main_hdr->blockid == IBR_HDR_SATA_ID) {
params->bl_len = image_get_satablksz();
main_hdr->srcaddr = cpu_to_le32(le32_to_cpu(main_hdr->srcaddr) / params->bl_len);
}
/* For PCIe srcaddr is not used and must be set to 0xFFFFFFFF. */
if (main_hdr->blockid == IBR_HDR_PEX_ID)
@ -1702,6 +1713,13 @@ static int image_create_config_parse_oneline(char *line,
case IMAGE_CFG_NAND_PAGESZ:
el->nandpagesz = strtoul(value1, NULL, 16);
break;
case IMAGE_CFG_SATA_BLKSZ:
el->satablksz = strtoul(value1, NULL, 0);
if (el->satablksz & (el->satablksz-1)) {
fprintf(stderr, "Invalid SATA block size '%s'\n", value1);
return -1;
}
break;
case IMAGE_CFG_BINARY:
argi = 0;
@ -1893,6 +1911,8 @@ static void kwbimage_set_header(void *ptr, struct stat *sbuf, int ifd,
struct stat s;
int ret;
params->bl_len = 1;
/*
* Do not use sbuf->st_size as it contains size with padding.
* We need original image data size, so stat original file.
@ -1972,7 +1992,7 @@ static void kwbimage_set_header(void *ptr, struct stat *sbuf, int ifd,
free(image);
}
static void kwbimage_print_header(const void *ptr)
static void kwbimage_print_header(const void *ptr, struct image_tool_params *params)
{
struct main_hdr_v0 *mhdr = (struct main_hdr_v0 *)ptr;
struct bin_hdr_v0 *bhdr;
@ -2004,10 +2024,11 @@ static void kwbimage_print_header(const void *ptr)
genimg_print_size(le32_to_cpu(mhdr->blocksize) - sizeof(uint32_t));
printf("Data Offset: ");
if (mhdr->blockid == IBR_HDR_SATA_ID)
printf("%u Sector%s (LBA)\n", le32_to_cpu(mhdr->srcaddr),
printf("%u Sector%s (LBA) = ", le32_to_cpu(mhdr->srcaddr),
le32_to_cpu(mhdr->srcaddr) != 1 ? "s" : "");
else
genimg_print_size(le32_to_cpu(mhdr->srcaddr));
genimg_print_size(le32_to_cpu(mhdr->srcaddr) * params->bl_len);
if (mhdr->blockid == IBR_HDR_SATA_ID)
printf("Sector Size: %u Bytes\n", params->bl_len);
if (mhdr->blockid == IBR_HDR_SPI_ID && le32_to_cpu(mhdr->destaddr) == 0xFFFFFFFF) {
printf("Load Address: XIP\n");
printf("Execute Offs: %08x\n", le32_to_cpu(mhdr->execaddr));
@ -2033,6 +2054,7 @@ static int kwbimage_verify_header(unsigned char *ptr, int image_size,
uint32_t offset;
uint32_t size;
uint8_t csum;
int blksz;
if (header_size > 192*1024)
return -FDT_ERR_BADSTRUCTURE;
@ -2091,12 +2113,28 @@ static int kwbimage_verify_header(unsigned char *ptr, int image_size,
return -FDT_ERR_BADSTRUCTURE;
}
if (size < 4 || size % 4 != 0)
return -FDT_ERR_BADSTRUCTURE;
/*
* For SATA srcaddr is specified in number of sectors.
* This expects that sector size is 512 bytes.
* Try all possible sector sizes which are power of two,
* at least 512 bytes and up to the 32 kB.
*/
if (blockid == IBR_HDR_SATA_ID)
offset *= 512;
if (blockid == IBR_HDR_SATA_ID) {
for (blksz = 512; blksz < 0x10000; blksz *= 2) {
if (offset * blksz > image_size || offset * blksz + size > image_size)
break;
if (image_checksum32(ptr + offset * blksz, size - 4) ==
*(uint32_t *)(ptr + offset * blksz + size - 4)) {
params->bl_len = blksz;
return 0;
}
}
return -FDT_ERR_BADSTRUCTURE;
}
/*
* For PCIe srcaddr is always set to 0xFFFFFFFF.
@ -2105,21 +2143,17 @@ static int kwbimage_verify_header(unsigned char *ptr, int image_size,
if (blockid == IBR_HDR_PEX_ID && offset == 0xFFFFFFFF)
offset = header_size;
if (offset > image_size || offset % 4 != 0)
return -FDT_ERR_BADSTRUCTURE;
if (size < 4 || offset + size > image_size || size % 4 != 0)
if (offset % 4 != 0 || offset > image_size || offset + size > image_size)
return -FDT_ERR_BADSTRUCTURE;
if (image_checksum32(ptr + offset, size - 4) !=
*(uint32_t *)(ptr + offset + size - 4))
return -FDT_ERR_BADSTRUCTURE;
params->bl_len = 1;
return 0;
}
static int kwbimage_align_size(int bootfrom, int alloc_len, struct stat s);
static int kwbimage_generate(struct image_tool_params *params,
struct image_type_params *tparams)
{
@ -2130,6 +2164,8 @@ static int kwbimage_generate(struct image_tool_params *params,
int version;
void *hdr;
int ret;
int align, size;
unsigned int satablksz;
fcfg = fopen(params->imagename, "r");
if (!fcfg) {
@ -2167,6 +2203,7 @@ static int kwbimage_generate(struct image_tool_params *params,
bootfrom = image_get_bootfrom();
version = image_get_version();
satablksz = image_get_satablksz();
switch (version) {
/*
* Fallback to version 0 if no version is provided in the
@ -2211,6 +2248,30 @@ static int kwbimage_generate(struct image_tool_params *params,
tparams->header_size = alloc_len;
tparams->hdr = hdr;
/*
* Final SATA images must be aligned to disk block size.
* Final SDIO images must be aligned to 512 bytes.
* Final SPI and NAND images must be aligned to 256 bytes.
* Final UART image must be aligned to 128 bytes.
*/
if (bootfrom == IBR_HDR_SATA_ID)
align = satablksz;
else if (bootfrom == IBR_HDR_SDIO_ID)
align = 512;
else if (bootfrom == IBR_HDR_SPI_ID || bootfrom == IBR_HDR_NAND_ID)
align = 256;
else if (bootfrom == IBR_HDR_UART_ID)
align = 128;
else
align = 4;
/*
* The resulting image needs to be 4-byte aligned. At least
* the Marvell hdrparser tool complains if its unaligned.
* After the image data is stored 4-byte checksum.
*/
size = 4 + (align - (alloc_len + s.st_size + 4) % align) % align;
/*
* This function should return aligned size of the datafile.
* When skipcpy is set (datafile is skipped) then return value of this
@ -2218,33 +2279,13 @@ static int kwbimage_generate(struct image_tool_params *params,
* into the preallocated header size.
*/
if (params->skipcpy) {
tparams->header_size += kwbimage_align_size(bootfrom, alloc_len, s);
tparams->header_size += size;
return 0;
} else {
return kwbimage_align_size(bootfrom, alloc_len, s);
return size;
}
}
static int kwbimage_align_size(int bootfrom, int alloc_len, struct stat s)
{
/*
* The resulting image needs to be 4-byte aligned. At least
* the Marvell hdrparser tool complains if its unaligned.
* After the image data is stored 4-byte checksum.
* Final UART image must be aligned to 128 bytes.
* Final SPI and NAND images must be aligned to 256 bytes.
* Final SATA and SDIO images must be aligned to 512 bytes.
*/
if (bootfrom == IBR_HDR_SPI_ID || bootfrom == IBR_HDR_NAND_ID)
return 4 + (256 - (alloc_len + s.st_size + 4) % 256) % 256;
else if (bootfrom == IBR_HDR_SATA_ID || bootfrom == IBR_HDR_SDIO_ID)
return 4 + (512 - (alloc_len + s.st_size + 4) % 512) % 512;
else if (bootfrom == IBR_HDR_UART_ID)
return 4 + (128 - (alloc_len + s.st_size + 4) % 128) % 128;
else
return 4 + (4 - s.st_size % 4) % 4;
}
static int kwbimage_generate_config(void *ptr, struct image_tool_params *params)
{
struct main_hdr_v0 *mhdr0 = (struct main_hdr_v0 *)ptr;
@ -2306,6 +2347,9 @@ static int kwbimage_generate_config(void *ptr, struct image_tool_params *params)
if (version == 0 && mhdr->blockid == IBR_HDR_SATA_ID)
fprintf(f, "SATA_PIO_MODE %u\n", (unsigned)mhdr0->satapiomode);
if (mhdr->blockid == IBR_HDR_SATA_ID)
fprintf(f, "SATA_BLKSZ %u\n", params->bl_len);
/*
* Addresses and sizes which are specified by mkimage command line
* arguments and not in kwbimage config file
@ -2486,7 +2530,7 @@ static int kwbimage_extract_subimage(void *ptr, struct image_tool_params *params
offset = le32_to_cpu(mhdr->srcaddr);
if (mhdr->blockid == IBR_HDR_SATA_ID)
offset *= 512;
offset *= params->bl_len;
if (mhdr->blockid == IBR_HDR_PEX_ID && offset == 0xFFFFFFFF)
offset = header_size;

35
tools/kwboot.c
View file

@ -1991,6 +1991,39 @@ _inject_baudrate_change_code(void *img, size_t *size, int for_data,
}
}
static int
kwboot_img_guess_sata_blksz(void *img, uint32_t blkoff, uint32_t data_size, size_t total_size)
{
uint32_t sum, *ptr, *end;
int blksz;
/*
* Try all possible sector sizes which are power of two,
* at least 512 bytes and up to the 32 kB.
*/
for (blksz = 512; blksz < 0x10000; blksz *= 2) {
if (blkoff * blksz > total_size ||
blkoff * blksz + data_size > total_size ||
data_size % 4)
break;
/*
* Calculate data checksum and if it matches
* then tried blksz should be correct.
*/
ptr = img + blkoff * blksz;
end = (void *)ptr + data_size - 4;
for (sum = 0; ptr < end; ptr++)
sum += *ptr;
if (sum == *end)
return blksz;
}
/* Fallback to 512 bytes */
return 512;
}
static const char *
kwboot_img_type(uint8_t blockid)
{
@ -2049,7 +2082,7 @@ kwboot_img_patch(void *img, size_t *size, int baudrate)
switch (hdr->blockid) {
case IBR_HDR_SATA_ID:
hdr->srcaddr = cpu_to_le32(srcaddr * 512);
hdr->srcaddr = cpu_to_le32(srcaddr * kwboot_img_guess_sata_blksz(img, srcaddr, le32_to_cpu(hdr->blocksize), *size));
break;
case IBR_HDR_PEX_ID:

2
tools/lpc32xximage.c
View file

@ -125,7 +125,7 @@ static void print_hdr_byte(struct nand_page_0_boot_header *hdr, int ofs)
printf("header[%d] = %02x\n", ofs, hdr->data[ofs]);
}
static void lpc32xximage_print_header(const void *ptr)
static void lpc32xximage_print_header(const void *ptr, struct image_tool_params *params)
{
struct nand_page_0_boot_header *hdr =
(struct nand_page_0_boot_header *)ptr;

2
tools/mkimage.c
View file

@ -790,7 +790,7 @@ int main(int argc, char **argv)
/* Print the image information by processing image header */
if (tparams->print_header)
tparams->print_header (ptr);
tparams->print_header (ptr, &params);
else {
fprintf (stderr, "%s: Can't print header for %s\n",
params.cmdname, tparams->name);

2
tools/mtk_image.c
View file

@ -510,7 +510,7 @@ static int mtk_image_verify_header(unsigned char *ptr, int image_size,
return -1;
}
static void mtk_image_print_header(const void *ptr)
static void mtk_image_print_header(const void *ptr, struct image_tool_params *params)
{
struct legacy_img_hdr *hdr = (struct legacy_img_hdr *)ptr;
union lk_hdr *lk = (union lk_hdr *)ptr;

2
tools/mxsimage.c
View file

@ -2239,7 +2239,7 @@ static int mxsimage_verify_header(unsigned char *ptr, int image_size,
return mxsimage_verify_print_header(params->imagefile, 1);
}
static void mxsimage_print_header(const void *hdr)
static void mxsimage_print_header(const void *hdr, struct image_tool_params *params)
{
if (imagefile)
mxsimage_verify_print_header(imagefile, 0);

2
tools/omapimage.c
View file

@ -85,7 +85,7 @@ static void omapimage_print_section(struct ch_settings *chs)
chs->flags);
}
static void omapimage_print_header(const void *ptr)
static void omapimage_print_header(const void *ptr, struct image_tool_params *params)
{
const struct ch_toc *toc = (struct ch_toc *)ptr;
const struct gp_header *gph =

2
tools/pblimage.c
View file

@ -254,7 +254,7 @@ static int pblimage_verify_header(unsigned char *ptr, int image_size,
return 0;
}
static void pblimage_print_header(const void *ptr)
static void pblimage_print_header(const void *ptr, struct image_tool_params *params)
{
printf("Image Type: Freescale PBL Boot Image\n");
}

2
tools/rkcommon.c
View file

@ -481,7 +481,7 @@ int rkcommon_verify_header(unsigned char *buf, int size,
return -ENOENT;
}
void rkcommon_print_header(const void *buf)
void rkcommon_print_header(const void *buf, struct image_tool_params *params)
{
struct header0_info header0;
struct header0_info_v2 header0_v2;

2
tools/rkcommon.h
View file

@ -68,7 +68,7 @@ int rkcommon_verify_header(unsigned char *buf, int size,
*
* @buf: Pointer to the image (can be a read-only file-mapping)
*/
void rkcommon_print_header(const void *buf);
void rkcommon_print_header(const void *buf, struct image_tool_params *params);
/**
* rkcommon_need_rc4_spl() - check if rc4 encoded spl is required

2
tools/socfpgaimage.c
View file

@ -313,7 +313,7 @@ static void socfpgaimage_print_header_v1(struct socfpga_header_v1 *header)
le16_to_cpu(header->checksum));
}
static void socfpgaimage_print_header(const void *ptr)
static void socfpgaimage_print_header(const void *ptr, struct image_tool_params *params)
{
const void *header = ptr + HEADER_OFFSET;
struct socfpga_header_v0 *header_v0;

2
tools/stm32image.c
View file

@ -99,7 +99,7 @@ static int stm32image_verify_header(unsigned char *ptr, int image_size,
return 0;
}
static void stm32image_print_header(const void *ptr)
static void stm32image_print_header(const void *ptr, struct image_tool_params *params)
{
struct stm32_header *stm32hdr = (struct stm32_header *)ptr;

2
tools/sunxi_egon.c
View file

@ -82,7 +82,7 @@ static int egon_verify_header(unsigned char *ptr, int image_size,
return EXIT_SUCCESS;
}
static void egon_print_header(const void *buf)
static void egon_print_header(const void *buf, struct image_tool_params *params)
{
const struct boot_file_head *header = buf;

2
tools/sunxi_toc0.c
View file

@ -757,7 +757,7 @@ static const char *toc0_item_name(uint32_t name)
return "(unknown)";
}
static void toc0_print_header(const void *buf)
static void toc0_print_header(const void *buf, struct image_tool_params *params)
{
const struct toc0_main_info *main_info = buf;
const struct toc0_item_info *item_info = (void *)(main_info + 1);

2
tools/ublimage.c
View file

@ -202,7 +202,7 @@ static int ublimage_verify_header(unsigned char *ptr, int image_size,
return 0;
}
static void ublimage_print_header(const void *ptr)
static void ublimage_print_header(const void *ptr, struct image_tool_params *params)
{
struct ubl_header *ubl_hdr = (struct ubl_header *) ptr;

2
tools/vybridimage.c
View file

@ -134,7 +134,7 @@ static void vybridimage_print_hdr_field(struct nand_page_0_boot_header *hdr,
printf("header.fcb[%d] = %08x\n", idx, hdr->fcb[idx]);
}
static void vybridimage_print_header(const void *ptr)
static void vybridimage_print_header(const void *ptr, struct image_tool_params *params)
{
struct nand_page_0_boot_header *hdr =
(struct nand_page_0_boot_header *)ptr;

2
tools/zynqimage.c
View file

@ -163,7 +163,7 @@ static int zynqimage_verify_header(unsigned char *ptr, int image_size,
return 0;
}
static void zynqimage_print_header(const void *ptr)
static void zynqimage_print_header(const void *ptr, struct image_tool_params *params)
{
struct zynq_header *zynqhdr = (struct zynq_header *)ptr;
int i;

2
tools/zynqmpimage.c
View file

@ -209,7 +209,7 @@ static void print_partition(const void *ptr, const struct partition_header *ph)
printf(" Checksum : 0x%08x\n", le32_to_cpu(ph->checksum));
}
void zynqmpimage_print_header(const void *ptr)
void zynqmpimage_print_header(const void *ptr, struct image_tool_params *params)
{
struct zynqmp_header *zynqhdr = (struct zynqmp_header *)ptr;
int i;

2
tools/zynqmpimage.h
View file

@ -133,6 +133,6 @@ struct zynqmp_header {
};
void zynqmpimage_default_header(struct zynqmp_header *ptr);
void zynqmpimage_print_header(const void *ptr);
void zynqmpimage_print_header(const void *ptr, struct image_tool_params *params);
#endif /* _ZYNQMPIMAGE_H_ */