common/spl/spl_nor.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2012 Stefan Roese <sr@denx.de>
   4  */
   5
   6 #include <common.h>
   7 #include <spl.h>
   8
   9 static ulong spl_nor_load_read(struct spl_load_info *load, ulong sector,
  10                                ulong count, void *buf)
  11 {
  12         debug("%s: sector %lx, count %lx, buf %p\n",
  13               __func__, sector, count, buf);
  14         memcpy(buf, (void *)sector, count);
  15
  16         return count;
  17 }
  18
  19 unsigned long __weak spl_nor_get_uboot_base(void)
  20 {
  21         return CONFIG_SYS_UBOOT_BASE;
  22 }
  23
  24 static int spl_nor_load_image(struct spl_image_info *spl_image,
  25                               struct spl_boot_device *bootdev)
  26 {
  27         int ret;
  28         __maybe_unused const struct image_header *header;
  29         __maybe_unused struct spl_load_info load;
  30
  31         /*
  32          * Loading of the payload to SDRAM is done with skipping of
  33          * the mkimage header in this SPL NOR driver
  34          */
  35         spl_image->flags |= SPL_COPY_PAYLOAD_ONLY;
  36
  37 #ifdef CONFIG_SPL_OS_BOOT
  38         if (!spl_start_uboot()) {
  39                 /*
  40                  * Load Linux from its location in NOR flash to its defined
  41                  * location in SDRAM
  42                  */
  43                 header = (const struct image_header *)CONFIG_SYS_OS_BASE;
  44 #ifdef CONFIG_SPL_LOAD_FIT
  45                 if (image_get_magic(header) == FDT_MAGIC) {
  46                         debug("Found FIT\n");
  47                         load.bl_len = 1;
  48                         load.read = spl_nor_load_read;
  49
  50                         ret = spl_load_simple_fit(spl_image, &load,
  51                                                   CONFIG_SYS_OS_BASE,
  52                                                   (void *)header);
  53
  54                         return ret;
  55                 }
  56 #endif
  57                 if (image_get_os(header) == IH_OS_LINUX) {
  58                         /* happy - was a Linux */
  59
  60                         ret = spl_parse_image_header(spl_image, header);
  61                         if (ret)
  62                                 return ret;
  63
  64                         memcpy((void *)spl_image->load_addr,
  65                                (void *)(CONFIG_SYS_OS_BASE +
  66                                         sizeof(struct image_header)),
  67                                spl_image->size);
  68 #ifdef CONFIG_SYS_FDT_BASE
  69                         spl_image->arg = (void *)CONFIG_SYS_FDT_BASE;
  70 #endif
  71
  72                         return 0;
  73                 } else {
  74                         puts("The Expected Linux image was not found.\n"
  75                              "Please check your NOR configuration.\n"
  76                              "Trying to start u-boot now...\n");
  77                 }
  78         }
  79 #endif
  80
  81         /*
  82          * Load real U-Boot from its location in NOR flash to its
  83          * defined location in SDRAM
  84          */
  85 #ifdef CONFIG_SPL_LOAD_FIT
  86         header = (const struct image_header *)spl_nor_get_uboot_base();
  87         if (image_get_magic(header) == FDT_MAGIC) {
  88                 debug("Found FIT format U-Boot\n");
  89                 load.bl_len = 1;
  90                 load.read = spl_nor_load_read;
  91                 ret = spl_load_simple_fit(spl_image, &load,
  92                                           spl_nor_get_uboot_base(),
  93                                           (void *)header);
  94
  95                 return ret;
  96         }
  97 #endif
  98         if (IS_ENABLED(CONFIG_SPL_LOAD_IMX_CONTAINER)) {
  99                 load.bl_len = 1;
 100                 load.read = spl_nor_load_read;
 101                 return spl_load_imx_container(spl_image, &load,
 102                                               spl_nor_get_uboot_base());
 103         }
 104
 105         ret = spl_parse_image_header(spl_image,
 106                         (const struct image_header *)spl_nor_get_uboot_base());
 107         if (ret)
 108                 return ret;
 109
 110         memcpy((void *)(unsigned long)spl_image->load_addr,
 111                (void *)(spl_nor_get_uboot_base() + sizeof(struct image_header)),
 112                spl_image->size);
 113
 114         return 0;
 115 }
 116 SPL_LOAD_IMAGE_METHOD("NOR", 0, BOOT_DEVICE_NOR, spl_nor_load_image);