1
2
3
4
5
6
7#include <common.h>
8#include <bootm.h>
9#include <bootstage.h>
10#include <cpu_func.h>
11#include <efi_loader.h>
12#include <env.h>
13#include <fdt_support.h>
14#include <image.h>
15#include <lmb.h>
16#include <log.h>
17#include <asm/global_data.h>
18#include <linux/libfdt.h>
19#include <malloc.h>
20#include <mapmem.h>
21#include <vxworks.h>
22#include <tee/optee.h>
23
24DECLARE_GLOBAL_DATA_PTR;
25
26static int do_bootm_standalone(int flag, int argc, char *const argv[],
27 struct bootm_headers *images)
28{
29 int (*appl)(int, char *const[]);
30
31 if (!env_get_autostart()) {
32 env_set_hex("filesize", images->os.image_len);
33 return 0;
34 }
35 appl = (int (*)(int, char * const []))images->ep;
36 appl(argc, argv);
37 return 0;
38}
39
40
41
42
43
44#if defined(CONFIG_BOOTM_NETBSD) || defined(CONFIG_BOOTM_PLAN9)
45static void copy_args(char *dest, int argc, char *const argv[], char delim)
46{
47 int i;
48
49 for (i = 0; i < argc; i++) {
50 if (i > 0)
51 *dest++ = delim;
52 strcpy(dest, argv[i]);
53 dest += strlen(argv[i]);
54 }
55}
56#endif
57
58static void __maybe_unused fit_unsupported_reset(const char *msg)
59{
60 if (CONFIG_IS_ENABLED(FIT_VERBOSE)) {
61 printf("! FIT images not supported for '%s' - must reset board to recover!\n",
62 msg);
63 }
64}
65
66#ifdef CONFIG_BOOTM_NETBSD
67static int do_bootm_netbsd(int flag, int argc, char *const argv[],
68 struct bootm_headers *images)
69{
70 void (*loader)(struct bd_info *bd, struct legacy_img_hdr *hdr,
71 char *console, char *cmdline);
72 struct legacy_img_hdr *os_hdr, *hdr;
73 ulong kernel_data, kernel_len;
74 char *cmdline;
75
76 if (flag != BOOTM_STATE_OS_GO)
77 return 0;
78
79#if defined(CONFIG_FIT)
80 if (!images->legacy_hdr_valid) {
81 fit_unsupported_reset("NetBSD");
82 return 1;
83 }
84#endif
85 hdr = images->legacy_hdr_os;
86
87
88
89
90
91
92
93
94
95
96
97
98 os_hdr = NULL;
99 if (image_check_type(&images->legacy_hdr_os_copy, IH_TYPE_MULTI)) {
100 image_multi_getimg(hdr, 1, &kernel_data, &kernel_len);
101 if (kernel_len)
102 os_hdr = hdr;
103 }
104
105 if (argc > 0) {
106 ulong len;
107 int i;
108
109 for (i = 0, len = 0; i < argc; i += 1)
110 len += strlen(argv[i]) + 1;
111 cmdline = malloc(len);
112 copy_args(cmdline, argc, argv, ' ');
113 } else {
114 cmdline = env_get("bootargs");
115 if (cmdline == NULL)
116 cmdline = "";
117 }
118
119 loader = (void (*)(struct bd_info *, struct legacy_img_hdr *, char *, char *))images->ep;
120
121 printf("## Transferring control to NetBSD stage-2 loader (at address %08lx) ...\n",
122 (ulong)loader);
123
124 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
125
126
127
128
129
130
131
132
133 (*loader)(gd->bd, os_hdr, "", cmdline);
134
135 return 1;
136}
137#endif
138
139#ifdef CONFIG_BOOTM_RTEMS
140static int do_bootm_rtems(int flag, int argc, char *const argv[],
141 struct bootm_headers *images)
142{
143 void (*entry_point)(struct bd_info *);
144
145 if (flag != BOOTM_STATE_OS_GO)
146 return 0;
147
148#if defined(CONFIG_FIT)
149 if (!images->legacy_hdr_valid) {
150 fit_unsupported_reset("RTEMS");
151 return 1;
152 }
153#endif
154
155 entry_point = (void (*)(struct bd_info *))images->ep;
156
157 printf("## Transferring control to RTEMS (at address %08lx) ...\n",
158 (ulong)entry_point);
159
160 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
161
162
163
164
165
166 (*entry_point)(gd->bd);
167
168 return 1;
169}
170#endif
171
172#if defined(CONFIG_BOOTM_OSE)
173static int do_bootm_ose(int flag, int argc, char *const argv[],
174 struct bootm_headers *images)
175{
176 void (*entry_point)(void);
177
178 if (flag != BOOTM_STATE_OS_GO)
179 return 0;
180
181#if defined(CONFIG_FIT)
182 if (!images->legacy_hdr_valid) {
183 fit_unsupported_reset("OSE");
184 return 1;
185 }
186#endif
187
188 entry_point = (void (*)(void))images->ep;
189
190 printf("## Transferring control to OSE (at address %08lx) ...\n",
191 (ulong)entry_point);
192
193 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
194
195
196
197
198
199 (*entry_point)();
200
201 return 1;
202}
203#endif
204
205#if defined(CONFIG_BOOTM_PLAN9)
206static int do_bootm_plan9(int flag, int argc, char *const argv[],
207 struct bootm_headers *images)
208{
209 void (*entry_point)(void);
210 char *s;
211
212 if (flag != BOOTM_STATE_OS_GO)
213 return 0;
214
215#if defined(CONFIG_FIT)
216 if (!images->legacy_hdr_valid) {
217 fit_unsupported_reset("Plan 9");
218 return 1;
219 }
220#endif
221
222
223 s = env_get("confaddr");
224 if (s != NULL) {
225 char *confaddr = (char *)hextoul(s, NULL);
226
227 if (argc > 0) {
228 copy_args(confaddr, argc, argv, '\n');
229 } else {
230 s = env_get("bootargs");
231 if (s != NULL)
232 strcpy(confaddr, s);
233 }
234 }
235
236 entry_point = (void (*)(void))images->ep;
237
238 printf("## Transferring control to Plan 9 (at address %08lx) ...\n",
239 (ulong)entry_point);
240
241 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
242
243
244
245
246
247 (*entry_point)();
248
249 return 1;
250}
251#endif
252
253#if defined(CONFIG_BOOTM_VXWORKS) && \
254 (defined(CONFIG_PPC) || defined(CONFIG_ARM))
255
256static void do_bootvx_fdt(struct bootm_headers *images)
257{
258#if defined(CONFIG_OF_LIBFDT)
259 int ret;
260 char *bootline;
261 ulong of_size = images->ft_len;
262 char **of_flat_tree = &images->ft_addr;
263 struct lmb *lmb = &images->lmb;
264
265 if (*of_flat_tree) {
266 boot_fdt_add_mem_rsv_regions(lmb, *of_flat_tree);
267
268 ret = boot_relocate_fdt(lmb, of_flat_tree, &of_size);
269 if (ret)
270 return;
271
272
273 fdt_fixup_ethernet(*of_flat_tree);
274
275 ret = fdt_add_subnode(*of_flat_tree, 0, "chosen");
276 if ((ret >= 0 || ret == -FDT_ERR_EXISTS)) {
277 bootline = env_get("bootargs");
278 if (bootline) {
279 ret = fdt_find_and_setprop(*of_flat_tree,
280 "/chosen", "bootargs",
281 bootline,
282 strlen(bootline) + 1, 1);
283 if (ret < 0) {
284 printf("## ERROR: %s : %s\n", __func__,
285 fdt_strerror(ret));
286 return;
287 }
288 }
289 } else {
290 printf("## ERROR: %s : %s\n", __func__,
291 fdt_strerror(ret));
292 return;
293 }
294 }
295#endif
296
297 boot_prep_vxworks(images);
298
299 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
300
301#if defined(CONFIG_OF_LIBFDT)
302 printf("## Starting vxWorks at 0x%08lx, device tree at 0x%08lx ...\n",
303 (ulong)images->ep, (ulong)*of_flat_tree);
304#else
305 printf("## Starting vxWorks at 0x%08lx\n", (ulong)images->ep);
306#endif
307 flush();
308
309 boot_jump_vxworks(images);
310
311 puts("## vxWorks terminated\n");
312}
313
314static int do_bootm_vxworks_legacy(int flag, int argc, char *const argv[],
315 struct bootm_headers *images)
316{
317 if (flag != BOOTM_STATE_OS_GO)
318 return 0;
319
320#if defined(CONFIG_FIT)
321 if (!images->legacy_hdr_valid) {
322 fit_unsupported_reset("VxWorks");
323 return 1;
324 }
325#endif
326
327 do_bootvx_fdt(images);
328
329 return 1;
330}
331
332int do_bootm_vxworks(int flag, int argc, char *const argv[],
333 struct bootm_headers *images)
334{
335 char *bootargs;
336 int pos;
337 unsigned long vxflags;
338 bool std_dtb = false;
339
340
341 bootargs = env_get("bootargs");
342
343 if (bootargs != NULL) {
344 for (pos = 0; pos < strlen(bootargs); pos++) {
345
346 if ((bootargs[pos] == '=') && (pos >= 1) &&
347 (bootargs[pos - 1] == 'f')) {
348 vxflags = hextoul(&bootargs[pos + 1], NULL);
349 if (vxflags & VXWORKS_SYSFLG_STD_DTB)
350 std_dtb = true;
351 }
352 }
353 }
354
355 if (std_dtb) {
356 if (flag & BOOTM_STATE_OS_PREP)
357 printf(" Using standard DTB\n");
358 return do_bootm_linux(flag, argc, argv, images);
359 } else {
360 if (flag & BOOTM_STATE_OS_PREP)
361 printf(" !!! WARNING !!! Using legacy DTB\n");
362 return do_bootm_vxworks_legacy(flag, argc, argv, images);
363 }
364}
365#endif
366
367#if defined(CONFIG_CMD_ELF)
368static int do_bootm_qnxelf(int flag, int argc, char *const argv[],
369 struct bootm_headers *images)
370{
371 char *local_args[2];
372 char str[16];
373 int dcache;
374
375 if (flag != BOOTM_STATE_OS_GO)
376 return 0;
377
378#if defined(CONFIG_FIT)
379 if (!images->legacy_hdr_valid) {
380 fit_unsupported_reset("QNX");
381 return 1;
382 }
383#endif
384
385 sprintf(str, "%lx", images->ep);
386 local_args[0] = argv[0];
387 local_args[1] = str;
388
389
390
391
392 dcache = dcache_status();
393 if (dcache)
394 dcache_disable();
395
396 do_bootelf(NULL, 0, 2, local_args);
397
398 if (dcache)
399 dcache_enable();
400
401 return 1;
402}
403#endif
404
405#ifdef CONFIG_INTEGRITY
406static int do_bootm_integrity(int flag, int argc, char *const argv[],
407 struct bootm_headers *images)
408{
409 void (*entry_point)(void);
410
411 if (flag != BOOTM_STATE_OS_GO)
412 return 0;
413
414#if defined(CONFIG_FIT)
415 if (!images->legacy_hdr_valid) {
416 fit_unsupported_reset("INTEGRITY");
417 return 1;
418 }
419#endif
420
421 entry_point = (void (*)(void))images->ep;
422
423 printf("## Transferring control to INTEGRITY (at address %08lx) ...\n",
424 (ulong)entry_point);
425
426 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
427
428
429
430
431
432 (*entry_point)();
433
434 return 1;
435}
436#endif
437
438#ifdef CONFIG_BOOTM_OPENRTOS
439static int do_bootm_openrtos(int flag, int argc, char *const argv[],
440 struct bootm_headers *images)
441{
442 void (*entry_point)(void);
443
444 if (flag != BOOTM_STATE_OS_GO)
445 return 0;
446
447 entry_point = (void (*)(void))images->ep;
448
449 printf("## Transferring control to OpenRTOS (at address %08lx) ...\n",
450 (ulong)entry_point);
451
452 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
453
454
455
456
457
458 (*entry_point)();
459
460 return 1;
461}
462#endif
463
464#ifdef CONFIG_BOOTM_OPTEE
465static int do_bootm_tee(int flag, int argc, char *const argv[],
466 struct bootm_headers *images)
467{
468 int ret;
469
470
471 if (images->os.os != IH_OS_TEE) {
472 return 1;
473 };
474
475
476 ret = optee_verify_bootm_image(images->os.image_start,
477 images->os.load,
478 images->os.image_len);
479 if (ret)
480 return ret;
481
482
483 ret = bootm_find_images(flag, argc, argv, 0, 0);
484 if (ret)
485 return ret;
486
487
488 return do_bootm_linux(flag, argc, argv, images);
489}
490#endif
491
492#ifdef CONFIG_BOOTM_EFI
493static int do_bootm_efi(int flag, int argc, char *const argv[],
494 struct bootm_headers *images)
495{
496 int ret;
497 efi_status_t efi_ret;
498 void *image_buf;
499
500 if (flag != BOOTM_STATE_OS_GO)
501 return 0;
502
503
504 ret = bootm_find_images(flag, argc, argv, 0, 0);
505 if (ret)
506 return ret;
507
508
509 efi_ret = efi_init_obj_list();
510 if (efi_ret != EFI_SUCCESS) {
511 printf("## Failed to initialize UEFI sub-system: r = %lu\n",
512 efi_ret & ~EFI_ERROR_MASK);
513 return 1;
514 }
515
516
517 efi_ret = efi_install_fdt(images->ft_len
518 ? images->ft_addr : EFI_FDT_USE_INTERNAL);
519 if (efi_ret != EFI_SUCCESS) {
520 printf("## Failed to install device tree: r = %lu\n",
521 efi_ret & ~EFI_ERROR_MASK);
522 return 1;
523 }
524
525
526 printf("## Transferring control to EFI (at address %08lx) ...\n",
527 images->ep);
528 bootstage_mark(BOOTSTAGE_ID_RUN_OS);
529
530
531 images->os.type = IH_TYPE_STANDALONE;
532
533 image_buf = map_sysmem(images->ep, images->os.image_len);
534
535 efi_ret = efi_run_image(image_buf, images->os.image_len);
536 if (efi_ret != EFI_SUCCESS)
537 return 1;
538 return 0;
539}
540#endif
541
542static boot_os_fn *boot_os[] = {
543 [IH_OS_U_BOOT] = do_bootm_standalone,
544#ifdef CONFIG_BOOTM_LINUX
545 [IH_OS_LINUX] = do_bootm_linux,
546#endif
547#ifdef CONFIG_BOOTM_NETBSD
548 [IH_OS_NETBSD] = do_bootm_netbsd,
549#endif
550#ifdef CONFIG_BOOTM_RTEMS
551 [IH_OS_RTEMS] = do_bootm_rtems,
552#endif
553#if defined(CONFIG_BOOTM_OSE)
554 [IH_OS_OSE] = do_bootm_ose,
555#endif
556#if defined(CONFIG_BOOTM_PLAN9)
557 [IH_OS_PLAN9] = do_bootm_plan9,
558#endif
559#if defined(CONFIG_BOOTM_VXWORKS) && \
560 (defined(CONFIG_PPC) || defined(CONFIG_ARM) || defined(CONFIG_RISCV))
561 [IH_OS_VXWORKS] = do_bootm_vxworks,
562#endif
563#if defined(CONFIG_CMD_ELF)
564 [IH_OS_QNX] = do_bootm_qnxelf,
565#endif
566#ifdef CONFIG_INTEGRITY
567 [IH_OS_INTEGRITY] = do_bootm_integrity,
568#endif
569#ifdef CONFIG_BOOTM_OPENRTOS
570 [IH_OS_OPENRTOS] = do_bootm_openrtos,
571#endif
572#ifdef CONFIG_BOOTM_OPTEE
573 [IH_OS_TEE] = do_bootm_tee,
574#endif
575#ifdef CONFIG_BOOTM_EFI
576 [IH_OS_EFI] = do_bootm_efi,
577#endif
578};
579
580
581__weak void arch_preboot_os(void)
582{
583
584}
585
586
587__weak void board_preboot_os(void)
588{
589
590}
591
592int boot_selected_os(int argc, char *const argv[], int state,
593 struct bootm_headers *images, boot_os_fn *boot_fn)
594{
595 arch_preboot_os();
596 board_preboot_os();
597 boot_fn(state, argc, argv, images);
598
599
600 if (images->os.type == IH_TYPE_STANDALONE ||
601 IS_ENABLED(CONFIG_SANDBOX) ||
602 state == BOOTM_STATE_OS_FAKE_GO)
603 return 0;
604 bootstage_error(BOOTSTAGE_ID_BOOT_OS_RETURNED);
605 debug("\n## Control returned to monitor - resetting...\n");
606
607 return BOOTM_ERR_RESET;
608}
609
610boot_os_fn *bootm_os_get_boot_func(int os)
611{
612#ifdef CONFIG_NEEDS_MANUAL_RELOC
613 static bool relocated;
614
615 if (!relocated) {
616 int i;
617
618
619 for (i = 0; i < ARRAY_SIZE(boot_os); i++)
620 if (boot_os[i] != NULL)
621 boot_os[i] += gd->reloc_off;
622
623 relocated = true;
624 }
625#endif
626 return boot_os[os];
627}
628
