]> git.sur5r.net Git - u-boot/blob - common/spl/spl_nand.c
dm: replace dm_dbg() with pr_debug()
[u-boot] / common / spl / spl_nand.c
1 /*
2  * Copyright (C) 2011
3  * Corscience GmbH & Co. KG - Simon Schwarz <schwarz@corscience.de>
4  *
5  * SPDX-License-Identifier:     GPL-2.0+
6  */
7 #include <common.h>
8 #include <config.h>
9 #include <spl.h>
10 #include <asm/io.h>
11 #include <nand.h>
12 #include <libfdt_env.h>
13 #include <fdt.h>
14
15 #if defined(CONFIG_SPL_NAND_RAW_ONLY)
16 int spl_nand_load_image(struct spl_image_info *spl_image,
17                         struct spl_boot_device *bootdev)
18 {
19         nand_init();
20
21         nand_spl_load_image(CONFIG_SYS_NAND_U_BOOT_OFFS,
22                             CONFIG_SYS_NAND_U_BOOT_SIZE,
23                             (void *)CONFIG_SYS_NAND_U_BOOT_DST);
24         spl_set_header_raw_uboot(spl_image);
25         nand_deselect();
26
27         return 0;
28 }
29 #else
30
31 static ulong spl_nand_fit_read(struct spl_load_info *load, ulong offs,
32                                ulong size, void *dst)
33 {
34         int ret;
35
36         ret = nand_spl_load_image(offs, size, dst);
37         if (!ret)
38                 return size;
39         else
40                 return 0;
41 }
42
43 static int spl_nand_load_element(struct spl_image_info *spl_image,
44                                  int offset, struct image_header *header)
45 {
46         int err;
47
48         err = nand_spl_load_image(offset, sizeof(*header), (void *)header);
49         if (err)
50                 return err;
51
52         if (IS_ENABLED(CONFIG_SPL_LOAD_FIT) &&
53             image_get_magic(header) == FDT_MAGIC) {
54                 struct spl_load_info load;
55
56                 debug("Found FIT\n");
57                 load.dev = NULL;
58                 load.priv = NULL;
59                 load.filename = NULL;
60                 load.bl_len = 1;
61                 load.read = spl_nand_fit_read;
62                 return spl_load_simple_fit(spl_image, &load, offset, header);
63         } else {
64                 err = spl_parse_image_header(spl_image, header);
65                 if (err)
66                         return err;
67                 return nand_spl_load_image(offset, spl_image->size,
68                                            (void *)(ulong)spl_image->load_addr);
69         }
70 }
71
72 static int spl_nand_load_image(struct spl_image_info *spl_image,
73                                struct spl_boot_device *bootdev)
74 {
75         int err;
76         struct image_header *header;
77         int *src __attribute__((unused));
78         int *dst __attribute__((unused));
79
80 #ifdef CONFIG_SPL_NAND_SOFTECC
81         debug("spl: nand - using sw ecc\n");
82 #else
83         debug("spl: nand - using hw ecc\n");
84 #endif
85         nand_init();
86
87         /*use CONFIG_SYS_TEXT_BASE as temporary storage area */
88         header = (struct image_header *)(CONFIG_SYS_TEXT_BASE);
89 #ifdef CONFIG_SPL_OS_BOOT
90         if (!spl_start_uboot()) {
91                 /*
92                  * load parameter image
93                  * load to temp position since nand_spl_load_image reads
94                  * a whole block which is typically larger than
95                  * CONFIG_CMD_SPL_WRITE_SIZE therefore may overwrite
96                  * following sections like BSS
97                  */
98                 nand_spl_load_image(CONFIG_CMD_SPL_NAND_OFS,
99                         CONFIG_CMD_SPL_WRITE_SIZE,
100                         (void *)CONFIG_SYS_TEXT_BASE);
101                 /* copy to destintion */
102                 for (dst = (int *)CONFIG_SYS_SPL_ARGS_ADDR,
103                                 src = (int *)CONFIG_SYS_TEXT_BASE;
104                                 src < (int *)(CONFIG_SYS_TEXT_BASE +
105                                 CONFIG_CMD_SPL_WRITE_SIZE);
106                                 src++, dst++) {
107                         writel(readl(src), dst);
108                 }
109
110                 /* load linux */
111                 nand_spl_load_image(CONFIG_SYS_NAND_SPL_KERNEL_OFFS,
112                         sizeof(*header), (void *)header);
113                 err = spl_parse_image_header(spl_image, header);
114                 if (err)
115                         return err;
116                 if (header->ih_os == IH_OS_LINUX) {
117                         /* happy - was a linux */
118                         err = nand_spl_load_image(
119                                 CONFIG_SYS_NAND_SPL_KERNEL_OFFS,
120                                 spl_image->size,
121                                 (void *)spl_image->load_addr);
122                         nand_deselect();
123                         return err;
124                 } else {
125                         puts("The Expected Linux image was not "
126                                 "found. Please check your NAND "
127                                 "configuration.\n");
128                         puts("Trying to start u-boot now...\n");
129                 }
130         }
131 #endif
132 #ifdef CONFIG_NAND_ENV_DST
133         spl_nand_load_element(spl_image, CONFIG_ENV_OFFSET, header);
134 #ifdef CONFIG_ENV_OFFSET_REDUND
135         spl_nand_load_element(spl_image, CONFIG_ENV_OFFSET_REDUND, header);
136 #endif
137 #endif
138         /* Load u-boot */
139         err = spl_nand_load_element(spl_image, CONFIG_SYS_NAND_U_BOOT_OFFS,
140                                     header);
141 #ifdef CONFIG_SYS_NAND_U_BOOT_OFFS_REDUND
142 #if CONFIG_SYS_NAND_U_BOOT_OFFS != CONFIG_SYS_NAND_U_BOOT_OFFS_REDUND
143         if (err)
144                 err = spl_nand_load_element(spl_image,
145                                             CONFIG_SYS_NAND_U_BOOT_OFFS_REDUND,
146                                             header);
147 #endif
148 #endif
149         nand_deselect();
150         return err;
151 }
152 #endif
153 /* Use priorty 1 so that Ubi can override this */
154 SPL_LOAD_IMAGE_METHOD("NAND", 1, BOOT_DEVICE_NAND, spl_nand_load_image);