1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * (C) Copyright 2003
4 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
5 */
6
7 #include <bootm.h>
8 #include <bootstage.h>
9 #include <env.h>
10 #include <image.h>
11 #include <fdt_support.h>
12 #include <log.h>
13 #include <asm/addrspace.h>
14 #include <asm/global_data.h>
15 #include <asm/io.h>
16
17 DECLARE_GLOBAL_DATA_PTR;
18
19 #define LINUX_MAX_ENVS 256
20 #define LINUX_MAX_ARGS 256
21
22 static int linux_argc;
23 static char **linux_argv;
24 static char *linux_argp;
25
26 static char **linux_env;
27 static char *linux_env_p;
28 static int linux_env_idx;
29
linux_cmdline_init(void)30 static void linux_cmdline_init(void)
31 {
32 linux_argc = 1;
33 linux_argv = (char **)CKSEG1ADDR(gd->bd->bi_boot_params);
34 linux_argv[0] = 0;
35 linux_argp = (char *)(linux_argv + LINUX_MAX_ARGS);
36 }
37
linux_cmdline_set(const char * value,size_t len)38 static void linux_cmdline_set(const char *value, size_t len)
39 {
40 linux_argv[linux_argc] = linux_argp;
41 memcpy(linux_argp, value, len);
42 linux_argp[len] = 0;
43
44 linux_argp += len + 1;
45 linux_argc++;
46 }
47
linux_cmdline_dump(void)48 static void linux_cmdline_dump(void)
49 {
50 int i;
51
52 debug("## cmdline argv at 0x%p, argp at 0x%p\n",
53 linux_argv, linux_argp);
54
55 for (i = 1; i < linux_argc; i++)
56 debug(" arg %03d: %s\n", i, linux_argv[i]);
57 }
58
linux_cmdline_legacy(struct bootm_headers * images)59 static void linux_cmdline_legacy(struct bootm_headers *images)
60 {
61 const char *bootargs, *next, *quote;
62
63 linux_cmdline_init();
64
65 bootargs = env_get("bootargs");
66 if (!bootargs)
67 return;
68
69 next = bootargs;
70
71 while (bootargs && *bootargs && linux_argc < LINUX_MAX_ARGS) {
72 quote = strchr(bootargs, '"');
73 next = strchr(bootargs, ' ');
74
75 while (next && quote && quote < next) {
76 /*
77 * we found a left quote before the next blank
78 * now we have to find the matching right quote
79 */
80 next = strchr(quote + 1, '"');
81 if (next) {
82 quote = strchr(next + 1, '"');
83 next = strchr(next + 1, ' ');
84 }
85 }
86
87 if (!next)
88 next = bootargs + strlen(bootargs);
89
90 linux_cmdline_set(bootargs, next - bootargs);
91
92 if (*next)
93 next++;
94
95 bootargs = next;
96 }
97 }
98
linux_cmdline_append(struct bootm_headers * images)99 static void linux_cmdline_append(struct bootm_headers *images)
100 {
101 char buf[24];
102 ulong mem, rd_start, rd_size;
103
104 /* append mem */
105 mem = gd->ram_size >> 20;
106 sprintf(buf, "mem=%luM", mem);
107 linux_cmdline_set(buf, strlen(buf));
108
109 /* append rd_start and rd_size */
110 rd_start = images->initrd_start;
111 rd_size = images->initrd_end - images->initrd_start;
112
113 if (rd_size) {
114 sprintf(buf, "rd_start=0x%08lX", rd_start);
115 linux_cmdline_set(buf, strlen(buf));
116 sprintf(buf, "rd_size=0x%lX", rd_size);
117 linux_cmdline_set(buf, strlen(buf));
118 }
119 }
120
linux_env_init(void)121 static void linux_env_init(void)
122 {
123 linux_env = (char **)(((ulong) linux_argp + 15) & ~15);
124 linux_env[0] = 0;
125 linux_env_p = (char *)(linux_env + LINUX_MAX_ENVS);
126 linux_env_idx = 0;
127 }
128
linux_env_set(const char * env_name,const char * env_val)129 static void linux_env_set(const char *env_name, const char *env_val)
130 {
131 if (linux_env_idx < LINUX_MAX_ENVS - 1) {
132 linux_env[linux_env_idx] = linux_env_p;
133
134 strcpy(linux_env_p, env_name);
135 linux_env_p += strlen(env_name);
136
137 if (CONFIG_IS_ENABLED(MALTA)) {
138 linux_env_p++;
139 linux_env[++linux_env_idx] = linux_env_p;
140 } else {
141 *linux_env_p++ = '=';
142 }
143
144 strcpy(linux_env_p, env_val);
145 linux_env_p += strlen(env_val);
146
147 linux_env_p++;
148 linux_env[++linux_env_idx] = 0;
149 }
150 }
151
linux_env_legacy(struct bootm_headers * images)152 static void linux_env_legacy(struct bootm_headers *images)
153 {
154 char env_buf[12];
155 const char *cp;
156 ulong rd_start, rd_size;
157
158 if (CONFIG_IS_ENABLED(MEMSIZE_IN_BYTES)) {
159 sprintf(env_buf, "%lu", (ulong)gd->ram_size);
160 debug("## Giving linux memsize in bytes, %lu\n",
161 (ulong)gd->ram_size);
162 } else {
163 sprintf(env_buf, "%lu", (ulong)(gd->ram_size >> 20));
164 debug("## Giving linux memsize in MB, %lu\n",
165 (ulong)(gd->ram_size >> 20));
166 }
167
168 rd_start = CKSEG1ADDR(images->initrd_start);
169 rd_size = images->initrd_end - images->initrd_start;
170
171 linux_env_init();
172
173 linux_env_set("memsize", env_buf);
174
175 sprintf(env_buf, "0x%08lX", rd_start);
176 linux_env_set("initrd_start", env_buf);
177
178 sprintf(env_buf, "0x%lX", rd_size);
179 linux_env_set("initrd_size", env_buf);
180
181 sprintf(env_buf, "0x%08X", (uint) (gd->bd->bi_flashstart));
182 linux_env_set("flash_start", env_buf);
183
184 sprintf(env_buf, "0x%X", (uint) (gd->bd->bi_flashsize));
185 linux_env_set("flash_size", env_buf);
186
187 cp = env_get("ethaddr");
188 if (cp)
189 linux_env_set("ethaddr", cp);
190
191 cp = env_get("eth1addr");
192 if (cp)
193 linux_env_set("eth1addr", cp);
194
195 if (CONFIG_IS_ENABLED(MALTA)) {
196 sprintf(env_buf, "%un8r", gd->baudrate);
197 linux_env_set("modetty0", env_buf);
198 }
199 }
200
boot_reloc_fdt(struct bootm_headers * images)201 static int boot_reloc_fdt(struct bootm_headers *images)
202 {
203 /*
204 * In case of legacy uImage's, relocation of FDT is already done
205 * by bootm_run_states() and should not repeated in 'bootm prep'.
206 */
207 if (images->state & BOOTM_STATE_FDT) {
208 debug("## FDT already relocated\n");
209 return 0;
210 }
211
212 #if CONFIG_IS_ENABLED(MIPS_BOOT_FDT) && CONFIG_IS_ENABLED(OF_LIBFDT)
213 boot_fdt_add_mem_rsv_regions(images->ft_addr);
214 return boot_relocate_fdt(&images->ft_addr, &images->ft_len);
215 #else
216 return 0;
217 #endif
218 }
219
220 #if CONFIG_IS_ENABLED(MIPS_BOOT_FDT) && CONFIG_IS_ENABLED(OF_LIBFDT)
arch_fixup_fdt(void * blob)221 int arch_fixup_fdt(void *blob)
222 {
223 u64 mem_start = virt_to_phys((void *)gd->ram_base);
224 u64 mem_size = gd->ram_size;
225
226 return fdt_fixup_memory_banks(blob, &mem_start, &mem_size, 1);
227 }
228 #endif
229
boot_setup_fdt(struct bootm_headers * images)230 static int boot_setup_fdt(struct bootm_headers *images)
231 {
232 images->initrd_start = virt_to_phys((void *)images->initrd_start);
233 images->initrd_end = virt_to_phys((void *)images->initrd_end);
234
235 return image_setup_libfdt(images, images->ft_addr, true);
236 }
237
boot_prep_linux(struct bootm_headers * images)238 static void boot_prep_linux(struct bootm_headers *images)
239 {
240 if (CONFIG_IS_ENABLED(MIPS_BOOT_FDT) && images->ft_len) {
241 boot_reloc_fdt(images);
242 boot_setup_fdt(images);
243 } else {
244 if (CONFIG_IS_ENABLED(MIPS_BOOT_CMDLINE_LEGACY)) {
245 linux_cmdline_legacy(images);
246
247 if (!CONFIG_IS_ENABLED(MIPS_BOOT_ENV_LEGACY))
248 linux_cmdline_append(images);
249
250 linux_cmdline_dump();
251 }
252
253 if (CONFIG_IS_ENABLED(MIPS_BOOT_ENV_LEGACY))
254 linux_env_legacy(images);
255 }
256 }
257
boot_jump_linux(struct bootm_headers * images)258 static void boot_jump_linux(struct bootm_headers *images)
259 {
260 typedef void __noreturn (*kernel_entry_t)(int, ulong, ulong, ulong);
261 kernel_entry_t kernel = (kernel_entry_t) images->ep;
262 ulong linux_extra = 0;
263
264 debug("## Transferring control to Linux (at address %p) ...\n", kernel);
265
266 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
267
268 if (CONFIG_IS_ENABLED(MALTA))
269 linux_extra = gd->ram_size;
270
271 #if IS_ENABLED(CONFIG_BOOTSTAGE_FDT)
272 bootstage_fdt_add_report();
273 #endif
274 #if IS_ENABLED(CONFIG_BOOTSTAGE_REPORT)
275 bootstage_report();
276 #endif
277
278 if (CONFIG_IS_ENABLED(RESTORE_EXCEPTION_VECTOR_BASE))
279 trap_restore();
280
281 if (images->ft_len)
282 kernel(-2, (ulong)images->ft_addr, 0, 0);
283 else
284 kernel(linux_argc, (ulong)linux_argv, (ulong)linux_env,
285 linux_extra);
286 }
287
do_bootm_linux(int flag,struct bootm_info * bmi)288 int do_bootm_linux(int flag, struct bootm_info *bmi)
289 {
290 struct bootm_headers *images = bmi->images;
291
292 /* No need for those on MIPS */
293 if (flag & BOOTM_STATE_OS_BD_T)
294 return -1;
295
296 /*
297 * Cmdline init has been moved to 'bootm prep' because it has to be
298 * done after relocation of ramdisk to always pass correct values
299 * for rd_start and rd_size to Linux kernel.
300 */
301 if (flag & BOOTM_STATE_OS_CMDLINE)
302 return 0;
303
304 if (flag & BOOTM_STATE_OS_PREP) {
305 boot_prep_linux(images);
306 return 0;
307 }
308
309 if (flag & (BOOTM_STATE_OS_GO | BOOTM_STATE_OS_FAKE_GO)) {
310 boot_jump_linux(images);
311 return 0;
312 }
313
314 /* does not return */
315 return 1;
316 }
317