1 /* 2 * (C) Copyright 2000-2009 3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de. 4 * 5 * SPDX-License-Identifier: GPL-2.0+ 6 */ 7 8 #include <common.h> 9 #include <bootm.h> 10 #include <fdt_support.h> 11 #include <libfdt.h> 12 #include <malloc.h> 13 #include <vxworks.h> 14 15 DECLARE_GLOBAL_DATA_PTR; 16 17 static int do_bootm_standalone(int flag, int argc, char * const argv[], 18 bootm_headers_t *images) 19 { 20 char *s; 21 int (*appl)(int, char *const[]); 22 23 /* Don't start if "autostart" is set to "no" */ 24 s = getenv("autostart"); 25 if ((s != NULL) && !strcmp(s, "no")) { 26 setenv_hex("filesize", images->os.image_len); 27 return 0; 28 } 29 appl = (int (*)(int, char * const []))images->ep; 30 appl(argc, argv); 31 return 0; 32 } 33 34 /*******************************************************************/ 35 /* OS booting routines */ 36 /*******************************************************************/ 37 38 #if defined(CONFIG_BOOTM_NETBSD) || defined(CONFIG_BOOTM_PLAN9) 39 static void copy_args(char *dest, int argc, char * const argv[], char delim) 40 { 41 int i; 42 43 for (i = 0; i < argc; i++) { 44 if (i > 0) 45 *dest++ = delim; 46 strcpy(dest, argv[i]); 47 dest += strlen(argv[i]); 48 } 49 } 50 #endif 51 52 #ifdef CONFIG_BOOTM_NETBSD 53 static int do_bootm_netbsd(int flag, int argc, char * const argv[], 54 bootm_headers_t *images) 55 { 56 void (*loader)(bd_t *, image_header_t *, char *, char *); 57 image_header_t *os_hdr, *hdr; 58 ulong kernel_data, kernel_len; 59 char *consdev; 60 char *cmdline; 61 62 if (flag != BOOTM_STATE_OS_GO) 63 return 0; 64 65 #if defined(CONFIG_FIT) 66 if (!images->legacy_hdr_valid) { 67 fit_unsupported_reset("NetBSD"); 68 return 1; 69 } 70 #endif 71 hdr = images->legacy_hdr_os; 72 73 /* 74 * Booting a (NetBSD) kernel image 75 * 76 * This process is pretty similar to a standalone application: 77 * The (first part of an multi-) image must be a stage-2 loader, 78 * which in turn is responsible for loading & invoking the actual 79 * kernel. The only differences are the parameters being passed: 80 * besides the board info strucure, the loader expects a command 81 * line, the name of the console device, and (optionally) the 82 * address of the original image header. 83 */ 84 os_hdr = NULL; 85 if (image_check_type(&images->legacy_hdr_os_copy, IH_TYPE_MULTI)) { 86 image_multi_getimg(hdr, 1, &kernel_data, &kernel_len); 87 if (kernel_len) 88 os_hdr = hdr; 89 } 90 91 consdev = ""; 92 #if defined(CONFIG_8xx_CONS_SMC1) 93 consdev = "smc1"; 94 #elif defined(CONFIG_8xx_CONS_SMC2) 95 consdev = "smc2"; 96 #elif defined(CONFIG_8xx_CONS_SCC2) 97 consdev = "scc2"; 98 #elif defined(CONFIG_8xx_CONS_SCC3) 99 consdev = "scc3"; 100 #endif 101 102 if (argc > 0) { 103 ulong len; 104 int i; 105 106 for (i = 0, len = 0; i < argc; i += 1) 107 len += strlen(argv[i]) + 1; 108 cmdline = malloc(len); 109 copy_args(cmdline, argc, argv, ' '); 110 } else { 111 cmdline = getenv("bootargs"); 112 if (cmdline == NULL) 113 cmdline = ""; 114 } 115 116 loader = (void (*)(bd_t *, image_header_t *, char *, char *))images->ep; 117 118 printf("## Transferring control to NetBSD stage-2 loader (at address %08lx) ...\n", 119 (ulong)loader); 120 121 bootstage_mark(BOOTSTAGE_ID_RUN_OS); 122 123 /* 124 * NetBSD Stage-2 Loader Parameters: 125 * arg[0]: pointer to board info data 126 * arg[1]: image load address 127 * arg[2]: char pointer to the console device to use 128 * arg[3]: char pointer to the boot arguments 129 */ 130 (*loader)(gd->bd, os_hdr, consdev, cmdline); 131 132 return 1; 133 } 134 #endif /* CONFIG_BOOTM_NETBSD*/ 135 136 #ifdef CONFIG_LYNXKDI 137 static int do_bootm_lynxkdi(int flag, int argc, char * const argv[], 138 bootm_headers_t *images) 139 { 140 image_header_t *hdr = &images->legacy_hdr_os_copy; 141 142 if (flag != BOOTM_STATE_OS_GO) 143 return 0; 144 145 #if defined(CONFIG_FIT) 146 if (!images->legacy_hdr_valid) { 147 fit_unsupported_reset("Lynx"); 148 return 1; 149 } 150 #endif 151 152 lynxkdi_boot((image_header_t *)hdr); 153 154 return 1; 155 } 156 #endif /* CONFIG_LYNXKDI */ 157 158 #ifdef CONFIG_BOOTM_RTEMS 159 static int do_bootm_rtems(int flag, int argc, char * const argv[], 160 bootm_headers_t *images) 161 { 162 void (*entry_point)(bd_t *); 163 164 if (flag != BOOTM_STATE_OS_GO) 165 return 0; 166 167 #if defined(CONFIG_FIT) 168 if (!images->legacy_hdr_valid) { 169 fit_unsupported_reset("RTEMS"); 170 return 1; 171 } 172 #endif 173 174 entry_point = (void (*)(bd_t *))images->ep; 175 176 printf("## Transferring control to RTEMS (at address %08lx) ...\n", 177 (ulong)entry_point); 178 179 bootstage_mark(BOOTSTAGE_ID_RUN_OS); 180 181 /* 182 * RTEMS Parameters: 183 * r3: ptr to board info data 184 */ 185 (*entry_point)(gd->bd); 186 187 return 1; 188 } 189 #endif /* CONFIG_BOOTM_RTEMS */ 190 191 #if defined(CONFIG_BOOTM_OSE) 192 static int do_bootm_ose(int flag, int argc, char * const argv[], 193 bootm_headers_t *images) 194 { 195 void (*entry_point)(void); 196 197 if (flag != BOOTM_STATE_OS_GO) 198 return 0; 199 200 #if defined(CONFIG_FIT) 201 if (!images->legacy_hdr_valid) { 202 fit_unsupported_reset("OSE"); 203 return 1; 204 } 205 #endif 206 207 entry_point = (void (*)(void))images->ep; 208 209 printf("## Transferring control to OSE (at address %08lx) ...\n", 210 (ulong)entry_point); 211 212 bootstage_mark(BOOTSTAGE_ID_RUN_OS); 213 214 /* 215 * OSE Parameters: 216 * None 217 */ 218 (*entry_point)(); 219 220 return 1; 221 } 222 #endif /* CONFIG_BOOTM_OSE */ 223 224 #if defined(CONFIG_BOOTM_PLAN9) 225 static int do_bootm_plan9(int flag, int argc, char * const argv[], 226 bootm_headers_t *images) 227 { 228 void (*entry_point)(void); 229 char *s; 230 231 if (flag != BOOTM_STATE_OS_GO) 232 return 0; 233 234 #if defined(CONFIG_FIT) 235 if (!images->legacy_hdr_valid) { 236 fit_unsupported_reset("Plan 9"); 237 return 1; 238 } 239 #endif 240 241 /* See README.plan9 */ 242 s = getenv("confaddr"); 243 if (s != NULL) { 244 char *confaddr = (char *)simple_strtoul(s, NULL, 16); 245 246 if (argc > 0) { 247 copy_args(confaddr, argc, argv, '\n'); 248 } else { 249 s = getenv("bootargs"); 250 if (s != NULL) 251 strcpy(confaddr, s); 252 } 253 } 254 255 entry_point = (void (*)(void))images->ep; 256 257 printf("## Transferring control to Plan 9 (at address %08lx) ...\n", 258 (ulong)entry_point); 259 260 bootstage_mark(BOOTSTAGE_ID_RUN_OS); 261 262 /* 263 * Plan 9 Parameters: 264 * None 265 */ 266 (*entry_point)(); 267 268 return 1; 269 } 270 #endif /* CONFIG_BOOTM_PLAN9 */ 271 272 #if defined(CONFIG_BOOTM_VXWORKS) && \ 273 (defined(CONFIG_PPC) || defined(CONFIG_ARM)) 274 275 void do_bootvx_fdt(bootm_headers_t *images) 276 { 277 #if defined(CONFIG_OF_LIBFDT) 278 int ret; 279 char *bootline; 280 ulong of_size = images->ft_len; 281 char **of_flat_tree = &images->ft_addr; 282 struct lmb *lmb = &images->lmb; 283 284 if (*of_flat_tree) { 285 boot_fdt_add_mem_rsv_regions(lmb, *of_flat_tree); 286 287 ret = boot_relocate_fdt(lmb, of_flat_tree, &of_size); 288 if (ret) 289 return; 290 291 fdt_fixup_ethernet(*of_flat_tree); 292 293 ret = fdt_add_subnode(*of_flat_tree, 0, "chosen"); 294 if ((ret >= 0 || ret == -FDT_ERR_EXISTS)) { 295 bootline = getenv("bootargs"); 296 if (bootline) { 297 ret = fdt_find_and_setprop(*of_flat_tree, 298 "/chosen", "bootargs", 299 bootline, 300 strlen(bootline) + 1, 1); 301 if (ret < 0) { 302 printf("## ERROR: %s : %s\n", __func__, 303 fdt_strerror(ret)); 304 return; 305 } 306 } 307 } else { 308 printf("## ERROR: %s : %s\n", __func__, 309 fdt_strerror(ret)); 310 return; 311 } 312 } 313 #endif 314 315 boot_prep_vxworks(images); 316 317 bootstage_mark(BOOTSTAGE_ID_RUN_OS); 318 319 #if defined(CONFIG_OF_LIBFDT) 320 printf("## Starting vxWorks at 0x%08lx, device tree at 0x%08lx ...\n", 321 (ulong)images->ep, (ulong)*of_flat_tree); 322 #else 323 printf("## Starting vxWorks at 0x%08lx\n", (ulong)images->ep); 324 #endif 325 326 boot_jump_vxworks(images); 327 328 puts("## vxWorks terminated\n"); 329 } 330 331 static int do_bootm_vxworks(int flag, int argc, char * const argv[], 332 bootm_headers_t *images) 333 { 334 if (flag != BOOTM_STATE_OS_GO) 335 return 0; 336 337 #if defined(CONFIG_FIT) 338 if (!images->legacy_hdr_valid) { 339 fit_unsupported_reset("VxWorks"); 340 return 1; 341 } 342 #endif 343 344 do_bootvx_fdt(images); 345 346 return 1; 347 } 348 #endif 349 350 #if defined(CONFIG_CMD_ELF) 351 static int do_bootm_qnxelf(int flag, int argc, char * const argv[], 352 bootm_headers_t *images) 353 { 354 char *local_args[2]; 355 char str[16]; 356 int dcache; 357 358 if (flag != BOOTM_STATE_OS_GO) 359 return 0; 360 361 #if defined(CONFIG_FIT) 362 if (!images->legacy_hdr_valid) { 363 fit_unsupported_reset("QNX"); 364 return 1; 365 } 366 #endif 367 368 sprintf(str, "%lx", images->ep); /* write entry-point into string */ 369 local_args[0] = argv[0]; 370 local_args[1] = str; /* and provide it via the arguments */ 371 372 /* 373 * QNX images require the data cache is disabled. 374 */ 375 dcache = dcache_status(); 376 if (dcache) 377 dcache_disable(); 378 379 do_bootelf(NULL, 0, 2, local_args); 380 381 if (dcache) 382 dcache_enable(); 383 384 return 1; 385 } 386 #endif 387 388 #ifdef CONFIG_INTEGRITY 389 static int do_bootm_integrity(int flag, int argc, char * const argv[], 390 bootm_headers_t *images) 391 { 392 void (*entry_point)(void); 393 394 if (flag != BOOTM_STATE_OS_GO) 395 return 0; 396 397 #if defined(CONFIG_FIT) 398 if (!images->legacy_hdr_valid) { 399 fit_unsupported_reset("INTEGRITY"); 400 return 1; 401 } 402 #endif 403 404 entry_point = (void (*)(void))images->ep; 405 406 printf("## Transferring control to INTEGRITY (at address %08lx) ...\n", 407 (ulong)entry_point); 408 409 bootstage_mark(BOOTSTAGE_ID_RUN_OS); 410 411 /* 412 * INTEGRITY Parameters: 413 * None 414 */ 415 (*entry_point)(); 416 417 return 1; 418 } 419 #endif 420 421 #ifdef CONFIG_BOOTM_OPENRTOS 422 static int do_bootm_openrtos(int flag, int argc, char * const argv[], 423 bootm_headers_t *images) 424 { 425 void (*entry_point)(void); 426 427 if (flag != BOOTM_STATE_OS_GO) 428 return 0; 429 430 entry_point = (void (*)(void))images->ep; 431 432 printf("## Transferring control to OpenRTOS (at address %08lx) ...\n", 433 (ulong)entry_point); 434 435 bootstage_mark(BOOTSTAGE_ID_RUN_OS); 436 437 /* 438 * OpenRTOS Parameters: 439 * None 440 */ 441 (*entry_point)(); 442 443 return 1; 444 } 445 #endif 446 447 static boot_os_fn *boot_os[] = { 448 [IH_OS_U_BOOT] = do_bootm_standalone, 449 #ifdef CONFIG_BOOTM_LINUX 450 [IH_OS_LINUX] = do_bootm_linux, 451 #endif 452 #ifdef CONFIG_BOOTM_NETBSD 453 [IH_OS_NETBSD] = do_bootm_netbsd, 454 #endif 455 #ifdef CONFIG_LYNXKDI 456 [IH_OS_LYNXOS] = do_bootm_lynxkdi, 457 #endif 458 #ifdef CONFIG_BOOTM_RTEMS 459 [IH_OS_RTEMS] = do_bootm_rtems, 460 #endif 461 #if defined(CONFIG_BOOTM_OSE) 462 [IH_OS_OSE] = do_bootm_ose, 463 #endif 464 #if defined(CONFIG_BOOTM_PLAN9) 465 [IH_OS_PLAN9] = do_bootm_plan9, 466 #endif 467 #if defined(CONFIG_BOOTM_VXWORKS) && \ 468 (defined(CONFIG_PPC) || defined(CONFIG_ARM)) 469 [IH_OS_VXWORKS] = do_bootm_vxworks, 470 #endif 471 #if defined(CONFIG_CMD_ELF) 472 [IH_OS_QNX] = do_bootm_qnxelf, 473 #endif 474 #ifdef CONFIG_INTEGRITY 475 [IH_OS_INTEGRITY] = do_bootm_integrity, 476 #endif 477 #ifdef CONFIG_BOOTM_OPENRTOS 478 [IH_OS_OPENRTOS] = do_bootm_openrtos, 479 #endif 480 }; 481 482 /* Allow for arch specific config before we boot */ 483 __weak void arch_preboot_os(void) 484 { 485 /* please define platform specific arch_preboot_os() */ 486 } 487 488 int boot_selected_os(int argc, char * const argv[], int state, 489 bootm_headers_t *images, boot_os_fn *boot_fn) 490 { 491 arch_preboot_os(); 492 boot_fn(state, argc, argv, images); 493 494 /* Stand-alone may return when 'autostart' is 'no' */ 495 if (images->os.type == IH_TYPE_STANDALONE || 496 IS_ENABLED(CONFIG_SANDBOX) || 497 state == BOOTM_STATE_OS_FAKE_GO) /* We expect to return */ 498 return 0; 499 bootstage_error(BOOTSTAGE_ID_BOOT_OS_RETURNED); 500 debug("\n## Control returned to monitor - resetting...\n"); 501 502 return BOOTM_ERR_RESET; 503 } 504 505 boot_os_fn *bootm_os_get_boot_func(int os) 506 { 507 #ifdef CONFIG_NEEDS_MANUAL_RELOC 508 static bool relocated; 509 510 if (!relocated) { 511 int i; 512 513 /* relocate boot function table */ 514 for (i = 0; i < ARRAY_SIZE(boot_os); i++) 515 if (boot_os[i] != NULL) 516 boot_os[i] += gd->reloc_off; 517 518 relocated = true; 519 } 520 #endif 521 return boot_os[os]; 522 } 523