1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 2016 Marvell International Ltd.
4 * https://spdx.org/licenses
18 #include <spi_flash.h>
27 #include <u-boot/sha1.h>
28 #include <u-boot/sha256.h>
30 #ifndef CONFIG_SYS_MMC_ENV_DEV
31 #define CONFIG_SYS_MMC_ENV_DEV 0
34 #if defined(CONFIG_ARMADA_8K)
35 #define MAIN_HDR_MAGIC 0xB105B002
37 struct mvebu_image_header
{
39 u32 prolog_size
; /* 4-7 */
40 u32 prolog_checksum
; /* 8-11 */
41 u32 boot_image_size
; /* 12-15 */
42 u32 boot_image_checksum
; /* 16-19 */
43 u32 rsrvd0
; /* 20-23 */
44 u32 load_addr
; /* 24-27 */
45 u32 exec_addr
; /* 28-31 */
48 u8 ext_count
; /* 34 */
49 u8 aux_flags
; /* 35 */
50 u32 io_arg_0
; /* 36-39 */
51 u32 io_arg_1
; /* 40-43 */
52 u32 io_arg_2
; /* 43-47 */
53 u32 io_arg_3
; /* 48-51 */
54 u32 rsrvd1
; /* 52-55 */
55 u32 rsrvd2
; /* 56-59 */
56 u32 rsrvd3
; /* 60-63 */
58 #elif defined(CONFIG_ARMADA_3700) /* A3700 */
59 #define HASH_SUM_LEN 16
60 #define IMAGE_VERSION_3_6_0 0x030600
61 #define IMAGE_VERSION_3_5_0 0x030500
63 struct common_tim_data
{
69 u32 reserved
[5]; /* Reserve 20 bytes */
76 struct mvebu_image_info
{
82 u32 image_size_to_hash
;
83 u32 hash_algorithm_id
;
84 u32 hash
[HASH_SUM_LEN
]; /* Reserve 512 bits for the hash */
87 u32 encrypt_start_offset
;
92 /* Structure of the main header, version 1 (Armada 370/38x/XP) */
93 struct a38x_main_hdr_v1
{
96 u16 reserved2
; /* 0x2-0x3 */
97 u32 blocksize
; /* 0x4-0x7 */
99 u8 headersz_msb
; /* 0x9 */
100 u16 headersz_lsb
; /* 0xA-0xB */
101 u32 srcaddr
; /* 0xC-0xF */
102 u32 destaddr
; /* 0x10-0x13 */
103 u32 execaddr
; /* 0x14-0x17 */
104 u8 options
; /* 0x18 */
105 u8 nandblocksize
; /* 0x19 */
106 u8 nandbadblklocation
; /* 0x1A */
107 u8 reserved4
; /* 0x1B */
108 u16 reserved5
; /* 0x1C-0x1D */
110 u8 checksum
; /* 0x1F */
113 struct a38x_boot_mode
{
118 /* The blockid header field values used to indicate boot device of image */
119 struct a38x_boot_mode a38x_boot_modes
[] = {
132 size_t (*read
)(const char *file_name
);
133 int (*write
)(size_t image_size
);
137 static ulong
get_load_addr(void)
139 const char *addr_str
;
142 addr_str
= env_get("loadaddr");
144 addr
= simple_strtoul(addr_str
, NULL
, 16);
146 addr
= CONFIG_SYS_LOAD_ADDR
;
151 /********************************************************************
153 ********************************************************************/
154 #if CONFIG_IS_ENABLED(DM_MMC) && CONFIG_IS_ENABLED(MMC_WRITE)
155 static int mmc_burn_image(size_t image_size
)
162 const u8 mmc_dev_num
= CONFIG_SYS_MMC_ENV_DEV
;
164 struct blk_desc
*blk_desc
;
166 mmc
= find_mmc_device(mmc_dev_num
);
168 printf("No SD/MMC/eMMC card found\n");
174 printf("%s(%d) init failed\n", IS_SD(mmc
) ? "SD" : "MMC",
179 #ifdef CONFIG_SYS_MMC_ENV_PART
180 if (mmc
->part_num
!= CONFIG_SYS_MMC_ENV_PART
) {
181 err
= mmc_switch_part(mmc_dev_num
, CONFIG_SYS_MMC_ENV_PART
);
183 printf("MMC partition switch failed\n");
189 /* SD reserves LBA-0 for MBR and boots from LBA-1,
190 * MMC/eMMC boots from LBA-0
192 start_lba
= IS_SD(mmc
) ? 1 : 0;
194 blk_count
= image_size
/ mmc
->write_bl_len
;
195 if (image_size
% mmc
->write_bl_len
)
198 blk_desc
= mmc_get_blk_desc(mmc
);
200 printf("Error - failed to obtain block descriptor\n");
203 blk_written
= blk_dwrite(blk_desc
, start_lba
, blk_count
,
204 (void *)get_load_addr());
206 blk_count
= image_size
/ mmc
->block_dev
.blksz
;
207 if (image_size
% mmc
->block_dev
.blksz
)
210 blk_written
= mmc
->block_dev
.block_write(mmc_dev_num
,
211 start_lba
, blk_count
,
212 (void *)get_load_addr());
213 #endif /* CONFIG_BLK */
214 if (blk_written
!= blk_count
) {
215 printf("Error - written %#lx blocks\n", blk_written
);
220 #ifdef CONFIG_SYS_MMC_ENV_PART
221 if (mmc
->part_num
!= CONFIG_SYS_MMC_ENV_PART
)
222 mmc_switch_part(mmc_dev_num
, mmc
->part_num
);
228 static size_t mmc_read_file(const char *file_name
)
233 const u8 mmc_dev_num
= CONFIG_SYS_MMC_ENV_DEV
;
235 mmc
= find_mmc_device(mmc_dev_num
);
237 printf("No SD/MMC/eMMC card found\n");
242 printf("%s(%d) init failed\n", IS_SD(mmc
) ? "SD" : "MMC",
247 /* Load from data partition (0) */
248 if (fs_set_blk_dev("mmc", "0", FS_TYPE_ANY
)) {
249 printf("Error: MMC 0 not found\n");
253 /* Perfrom file read */
254 rc
= fs_read(file_name
, get_load_addr(), 0, 0, &act_read
);
261 static int is_mmc_active(void)
265 #else /* CONFIG_DM_MMC */
266 static int mmc_burn_image(size_t image_size
)
271 static size_t mmc_read_file(const char *file_name
)
276 static int is_mmc_active(void)
280 #endif /* CONFIG_DM_MMC */
282 /********************************************************************
284 ********************************************************************/
285 #ifdef CONFIG_SPI_FLASH
286 static int spi_burn_image(size_t image_size
)
289 struct spi_flash
*flash
;
292 /* Probe the SPI bus to get the flash device */
293 flash
= spi_flash_probe(CONFIG_ENV_SPI_BUS
,
295 CONFIG_SF_DEFAULT_SPEED
,
296 CONFIG_SF_DEFAULT_MODE
);
298 printf("Failed to probe SPI Flash\n");
302 #ifdef CONFIG_SPI_FLASH_PROTECTION
303 spi_flash_protect(flash
, 0);
305 erase_bytes
= image_size
+
306 (flash
->erase_size
- image_size
% flash
->erase_size
);
307 printf("Erasing %d bytes (%d blocks) at offset 0 ...",
308 erase_bytes
, erase_bytes
/ flash
->erase_size
);
309 ret
= spi_flash_erase(flash
, 0, erase_bytes
);
315 printf("Writing %d bytes from 0x%lx to offset 0 ...",
316 (int)image_size
, get_load_addr());
317 ret
= spi_flash_write(flash
, 0, image_size
, (void *)get_load_addr());
323 #ifdef CONFIG_SPI_FLASH_PROTECTION
324 spi_flash_protect(flash
, 1);
330 static int is_spi_active(void)
335 #else /* CONFIG_SPI_FLASH */
336 static int spi_burn_image(size_t image_size
)
341 static int is_spi_active(void)
345 #endif /* CONFIG_SPI_FLASH */
347 /********************************************************************
349 ********************************************************************/
350 #ifdef CONFIG_CMD_NAND
351 static int nand_burn_image(size_t image_size
)
355 struct mtd_info
*mtd
;
357 mtd
= get_nand_dev_by_index(nand_curr_device
);
359 puts("\nno devices available\n");
362 block_size
= mtd
->erasesize
;
364 /* Align U-Boot size to currently used blocksize */
365 image_size
= ((image_size
+ (block_size
- 1)) & (~(block_size
- 1)));
367 /* Erase the U-Boot image space */
368 printf("Erasing 0x%x - 0x%x:...", 0, (int)image_size
);
369 ret
= nand_erase(mtd
, 0, image_size
);
376 /* Write the image to flash */
377 printf("Writing %d bytes from 0x%lx to offset 0 ... ",
378 (int)image_size
, get_load_addr());
379 ret
= nand_write(mtd
, 0, &image_size
, (void *)get_load_addr());
389 static int is_nand_active(void)
394 #else /* CONFIG_CMD_NAND */
395 static int nand_burn_image(size_t image_size
)
400 static int is_nand_active(void)
404 #endif /* CONFIG_CMD_NAND */
406 /********************************************************************
408 ********************************************************************/
409 #if defined(CONFIG_USB_STORAGE) && defined(CONFIG_BLK)
410 static size_t usb_read_file(const char *file_name
)
418 if (usb_init() < 0) {
419 printf("Error: usb_init failed\n");
423 /* Try to recognize storage devices immediately */
424 blk_first_device(IF_TYPE_USB
, &dev
);
426 printf("Error: USB storage device not found\n");
430 /* Always load from usb 0 */
431 if (fs_set_blk_dev("usb", "0", FS_TYPE_ANY
)) {
432 printf("Error: USB 0 not found\n");
436 /* Perfrom file read */
437 rc
= fs_read(file_name
, get_load_addr(), 0, 0, &act_read
);
444 static int is_usb_active(void)
449 #else /* defined(CONFIG_USB_STORAGE) && defined (CONFIG_BLK) */
450 static size_t usb_read_file(const char *file_name
)
455 static int is_usb_active(void)
459 #endif /* defined(CONFIG_USB_STORAGE) && defined (CONFIG_BLK) */
461 /********************************************************************
463 ********************************************************************/
464 #ifdef CONFIG_CMD_NET
465 static size_t tftp_read_file(const char *file_name
)
468 * update global variable image_load_addr before tftp file from network
470 image_load_addr
= get_load_addr();
471 return net_loop(TFTPGET
);
474 static int is_tftp_active(void)
480 static size_t tftp_read_file(const char *file_name
)
485 static int is_tftp_active(void)
489 #endif /* CONFIG_CMD_NET */
501 struct bubt_dev bubt_devs
[BUBT_MAX_DEV
] = {
502 {"tftp", tftp_read_file
, NULL
, is_tftp_active
},
503 {"usb", usb_read_file
, NULL
, is_usb_active
},
504 {"mmc", mmc_read_file
, mmc_burn_image
, is_mmc_active
},
505 {"spi", NULL
, spi_burn_image
, is_spi_active
},
506 {"nand", NULL
, nand_burn_image
, is_nand_active
},
509 static int bubt_write_file(struct bubt_dev
*dst
, size_t image_size
)
512 printf("Error: Write not supported on device %s\n", dst
->name
);
516 return dst
->write(image_size
);
519 #if defined(CONFIG_ARMADA_8K)
520 u32
do_checksum32(u32
*start
, int32_t len
)
534 static int check_image_header(void)
536 struct mvebu_image_header
*hdr
=
537 (struct mvebu_image_header
*)get_load_addr();
538 u32 header_len
= hdr
->prolog_size
;
540 u32 checksum_ref
= hdr
->prolog_checksum
;
543 * For now compare checksum, and magic. Later we can
544 * verify more stuff on the header like interface type, etc
546 if (hdr
->magic
!= MAIN_HDR_MAGIC
) {
547 printf("ERROR: Bad MAGIC 0x%08x != 0x%08x\n",
548 hdr
->magic
, MAIN_HDR_MAGIC
);
552 /* The checksum value is discarded from checksum calculation */
553 hdr
->prolog_checksum
= 0;
555 checksum
= do_checksum32((u32
*)hdr
, header_len
);
556 if (checksum
!= checksum_ref
) {
557 printf("Error: Bad Image checksum. 0x%x != 0x%x\n",
558 checksum
, checksum_ref
);
562 /* Restore the checksum before writing */
563 hdr
->prolog_checksum
= checksum_ref
;
564 printf("Image checksum...OK!\n");
568 #elif defined(CONFIG_ARMADA_3700) /* Armada 3700 */
569 static int check_image_header(void)
571 struct common_tim_data
*hdr
= (struct common_tim_data
*)get_load_addr();
573 u8 hash_160_output
[SHA1_SUM_LEN
];
574 u8 hash_256_output
[SHA256_SUM_LEN
];
575 sha1_context hash1_text
;
576 sha256_context hash256_text
;
578 u32 hash_algorithm_id
;
579 u32 image_size_to_hash
;
580 u32 flash_entry_addr
;
582 u32 internal_hash
[HASH_SUM_LEN
];
584 u32 num_of_image
= hdr
->num_images
;
585 u32 version
= hdr
->version
;
586 u32 trusted
= hdr
->trusted
;
588 /* bubt checksum validation only supports nontrusted images */
590 printf("bypass image validation, ");
591 printf("only untrusted image is supported now\n");
594 /* only supports image version 3.5 and 3.6 */
595 if (version
!= IMAGE_VERSION_3_5_0
&& version
!= IMAGE_VERSION_3_6_0
) {
596 printf("Error: Unsupported Image version = 0x%08x\n", version
);
599 /* validate images hash value */
600 for (image_num
= 0; image_num
< num_of_image
; image_num
++) {
601 struct mvebu_image_info
*info
=
602 (struct mvebu_image_info
*)(get_load_addr() +
603 sizeof(struct common_tim_data
) +
604 image_num
* sizeof(struct mvebu_image_info
));
605 hash_algorithm_id
= info
->hash_algorithm_id
;
606 image_size_to_hash
= info
->image_size_to_hash
;
607 flash_entry_addr
= info
->flash_entry_addr
;
608 hash_value
= info
->hash
;
609 buff
= (const u8
*)(get_load_addr() + flash_entry_addr
);
611 if (image_num
== 0) {
613 * The first image includes hash values in its content.
614 * For hash calculation, we need to save the original
615 * hash values to a local variable that will be
616 * copied back for comparsion and set all zeros to
617 * the orignal hash values for calculating new value.
618 * First image original format :
619 * x...x (datum1) x...x(orig. hash values) x...x(datum2)
620 * Replaced first image format :
621 * x...x (datum1) 0...0(hash values) x...x(datum2)
623 memcpy(internal_hash
, hash_value
,
624 sizeof(internal_hash
));
625 memset(hash_value
, 0, sizeof(internal_hash
));
627 if (image_size_to_hash
== 0) {
628 printf("Warning: Image_%d hash checksum is disabled, ",
630 printf("skip the image validation.\n");
633 switch (hash_algorithm_id
) {
635 sha1_starts(&hash1_text
);
636 sha1_update(&hash1_text
, buff
, image_size_to_hash
);
637 sha1_finish(&hash1_text
, hash_160_output
);
638 hash_output
= hash_160_output
;
641 sha256_starts(&hash256_text
);
642 sha256_update(&hash256_text
, buff
, image_size_to_hash
);
643 sha256_finish(&hash256_text
, hash_256_output
);
644 hash_output
= hash_256_output
;
647 printf("Error: Unsupported hash_algorithm_id = %d\n",
652 memcpy(hash_value
, internal_hash
,
653 sizeof(internal_hash
));
654 if (memcmp(hash_value
, hash_output
, hash_algorithm_id
) != 0) {
655 printf("Error: Image_%d checksum is not correct\n",
660 printf("Image checksum...OK!\n");
664 #elif defined(CONFIG_ARMADA_38X)
665 static size_t a38x_header_size(const struct a38x_main_hdr_v1
*h
)
668 return (h
->headersz_msb
<< 16) | le16_to_cpu(h
->headersz_lsb
);
670 printf("Error: Invalid A38x image (header version 0x%x unknown)!\n",
675 static uint8_t image_checksum8(const void *start
, size_t len
)
689 static int check_image_header(void)
692 const struct a38x_main_hdr_v1
*hdr
=
693 (struct a38x_main_hdr_v1
*)get_load_addr();
694 const size_t image_size
= a38x_header_size(hdr
);
699 checksum
= image_checksum8(hdr
, image_size
);
700 checksum
-= hdr
->checksum
;
701 if (checksum
!= hdr
->checksum
) {
702 printf("Error: Bad A38x image checksum. 0x%x != 0x%x\n",
703 checksum
, hdr
->checksum
);
707 printf("Image checksum...OK!\n");
710 #else /* Not ARMADA? */
711 static int check_image_header(void)
713 printf("bubt cmd does not support this SoC device or family!\n");
718 static int bubt_check_boot_mode(const struct bubt_dev
*dst
)
720 if (IS_ENABLED(CONFIG_ARMADA_38X
)) {
722 const struct a38x_main_hdr_v1
*hdr
=
723 (struct a38x_main_hdr_v1
*)get_load_addr();
725 for (mode
= 0; mode
< ARRAY_SIZE(a38x_boot_modes
); mode
++) {
726 if (strcmp(a38x_boot_modes
[mode
].name
, dst
->name
) == 0)
730 if (a38x_boot_modes
[mode
].id
== hdr
->blockid
)
733 for (int i
= 0; i
< ARRAY_SIZE(a38x_boot_modes
); i
++) {
734 if (a38x_boot_modes
[i
].id
== hdr
->blockid
) {
735 printf("Error: A38x image meant to be booted from "
736 "\"%s\", not \"%s\"!\n",
737 a38x_boot_modes
[i
].name
, dst
->name
);
742 printf("Error: unknown boot device in A38x image header: "
743 "0x%x\n", hdr
->blockid
);
750 static int bubt_verify(const struct bubt_dev
*dst
)
754 /* Check a correct image header exists */
755 err
= check_image_header();
757 printf("Error: Image header verification failed\n");
761 err
= bubt_check_boot_mode(dst
);
763 printf("Error: Image boot mode verification failed\n");
770 static int bubt_read_file(struct bubt_dev
*src
)
775 printf("Error: Read not supported on device \"%s\"\n",
780 image_size
= src
->read(net_boot_file_name
);
781 if (image_size
<= 0) {
782 printf("Error: Failed to read file %s from %s\n",
783 net_boot_file_name
, src
->name
);
790 static int bubt_is_dev_active(struct bubt_dev
*dev
)
793 printf("Device \"%s\" not supported by U-Boot image\n",
798 if (!dev
->active()) {
799 printf("Device \"%s\" is inactive\n", dev
->name
);
806 struct bubt_dev
*find_bubt_dev(char *dev_name
)
810 for (dev
= 0; dev
< BUBT_MAX_DEV
; dev
++) {
811 if (strcmp(bubt_devs
[dev
].name
, dev_name
) == 0)
812 return &bubt_devs
[dev
];
818 #define DEFAULT_BUBT_SRC "tftp"
820 #ifndef DEFAULT_BUBT_DST
821 #ifdef CONFIG_MVEBU_SPI_BOOT
822 #define DEFAULT_BUBT_DST "spi"
823 #elif defined(CONFIG_MVEBU_NAND_BOOT)
824 #define DEFAULT_BUBT_DST "nand"
825 #elif defined(CONFIG_MVEBU_MMC_BOOT)
826 #define DEFAULT_BUBT_DST "mmc"
828 #define DEFAULT_BUBT_DST "error"
830 #endif /* DEFAULT_BUBT_DST */
832 int do_bubt_cmd(cmd_tbl_t
*cmdtp
, int flag
, int argc
, char * const argv
[])
834 struct bubt_dev
*src
, *dst
;
836 char src_dev_name
[8];
837 char dst_dev_name
[8];
842 copy_filename(net_boot_file_name
,
843 CONFIG_MVEBU_UBOOT_DFLT_NAME
,
844 sizeof(net_boot_file_name
));
846 copy_filename(net_boot_file_name
, argv
[1],
847 sizeof(net_boot_file_name
));
850 strncpy(dst_dev_name
, argv
[2], 8);
852 name
= DEFAULT_BUBT_DST
;
853 strncpy(dst_dev_name
, name
, 8);
857 strncpy(src_dev_name
, argv
[3], 8);
859 strncpy(src_dev_name
, DEFAULT_BUBT_SRC
, 8);
861 /* Figure out the destination device */
862 dst
= find_bubt_dev(dst_dev_name
);
864 printf("Error: Unknown destination \"%s\"\n", dst_dev_name
);
868 if (!bubt_is_dev_active(dst
))
871 /* Figure out the source device */
872 src
= find_bubt_dev(src_dev_name
);
874 printf("Error: Unknown source \"%s\"\n", src_dev_name
);
878 if (!bubt_is_dev_active(src
))
881 printf("Burning U-Boot image \"%s\" from \"%s\" to \"%s\"\n",
882 net_boot_file_name
, src
->name
, dst
->name
);
884 image_size
= bubt_read_file(src
);
888 err
= bubt_verify(dst
);
892 err
= bubt_write_file(dst
, image_size
);
900 bubt
, 4, 0, do_bubt_cmd
,
901 "Burn a u-boot image to flash",
902 "[file-name] [destination [source]]\n"
903 "\t-file-name The image file name to burn. Default = flash-image.bin\n"
904 "\t-destination Flash to burn to [spi, nand, mmc]. Default = active boot device\n"
905 "\t-source The source to load image from [tftp, usb, mmc]. Default = tftp\n"
907 "\tbubt - Burn flash-image.bin from tftp to active boot device\n"
908 "\tbubt flash-image-new.bin nand - Burn flash-image-new.bin from tftp to NAND flash\n"
909 "\tbubt backup-flash-image.bin mmc usb - Burn backup-flash-image.bin from usb to MMC\n"