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 ret = fdt_add_subnode(*of_flat_tree, 0, "chosen"); 292 if ((ret >= 0 || ret == -FDT_ERR_EXISTS)) { 293 bootline = getenv("bootargs"); 294 if (bootline) { 295 ret = fdt_find_and_setprop(*of_flat_tree, 296 "/chosen", "bootargs", 297 bootline, 298 strlen(bootline) + 1, 1); 299 if (ret < 0) { 300 printf("## ERROR: %s : %s\n", __func__, 301 fdt_strerror(ret)); 302 return; 303 } 304 } 305 } else { 306 printf("## ERROR: %s : %s\n", __func__, 307 fdt_strerror(ret)); 308 return; 309 } 310 } 311 #endif 312 313 boot_prep_vxworks(images); 314 315 bootstage_mark(BOOTSTAGE_ID_RUN_OS); 316 317 #if defined(CONFIG_OF_LIBFDT) 318 printf("## Starting vxWorks at 0x%08lx, device tree at 0x%08lx ...\n", 319 (ulong)images->ep, (ulong)*of_flat_tree); 320 #else 321 printf("## Starting vxWorks at 0x%08lx\n", (ulong)images->ep); 322 #endif 323 324 boot_jump_vxworks(images); 325 326 puts("## vxWorks terminated\n"); 327 } 328 329 static int do_bootm_vxworks(int flag, int argc, char * const argv[], 330 bootm_headers_t *images) 331 { 332 if (flag != BOOTM_STATE_OS_GO) 333 return 0; 334 335 #if defined(CONFIG_FIT) 336 if (!images->legacy_hdr_valid) { 337 fit_unsupported_reset("VxWorks"); 338 return 1; 339 } 340 #endif 341 342 do_bootvx_fdt(images); 343 344 return 1; 345 } 346 #endif 347 348 #if defined(CONFIG_CMD_ELF) 349 static int do_bootm_qnxelf(int flag, int argc, char * const argv[], 350 bootm_headers_t *images) 351 { 352 char *local_args[2]; 353 char str[16]; 354 int dcache; 355 356 if (flag != BOOTM_STATE_OS_GO) 357 return 0; 358 359 #if defined(CONFIG_FIT) 360 if (!images->legacy_hdr_valid) { 361 fit_unsupported_reset("QNX"); 362 return 1; 363 } 364 #endif 365 366 sprintf(str, "%lx", images->ep); /* write entry-point into string */ 367 local_args[0] = argv[0]; 368 local_args[1] = str; /* and provide it via the arguments */ 369 370 /* 371 * QNX images require the data cache is disabled. 372 */ 373 dcache = dcache_status(); 374 if (dcache) 375 dcache_disable(); 376 377 do_bootelf(NULL, 0, 2, local_args); 378 379 if (dcache) 380 dcache_enable(); 381 382 return 1; 383 } 384 #endif 385 386 #ifdef CONFIG_INTEGRITY 387 static int do_bootm_integrity(int flag, int argc, char * const argv[], 388 bootm_headers_t *images) 389 { 390 void (*entry_point)(void); 391 392 if (flag != BOOTM_STATE_OS_GO) 393 return 0; 394 395 #if defined(CONFIG_FIT) 396 if (!images->legacy_hdr_valid) { 397 fit_unsupported_reset("INTEGRITY"); 398 return 1; 399 } 400 #endif 401 402 entry_point = (void (*)(void))images->ep; 403 404 printf("## Transferring control to INTEGRITY (at address %08lx) ...\n", 405 (ulong)entry_point); 406 407 bootstage_mark(BOOTSTAGE_ID_RUN_OS); 408 409 /* 410 * INTEGRITY Parameters: 411 * None 412 */ 413 (*entry_point)(); 414 415 return 1; 416 } 417 #endif 418 419 #ifdef CONFIG_BOOTM_OPENRTOS 420 static int do_bootm_openrtos(int flag, int argc, char * const argv[], 421 bootm_headers_t *images) 422 { 423 void (*entry_point)(void); 424 425 if (flag != BOOTM_STATE_OS_GO) 426 return 0; 427 428 entry_point = (void (*)(void))images->ep; 429 430 printf("## Transferring control to OpenRTOS (at address %08lx) ...\n", 431 (ulong)entry_point); 432 433 bootstage_mark(BOOTSTAGE_ID_RUN_OS); 434 435 /* 436 * OpenRTOS Parameters: 437 * None 438 */ 439 (*entry_point)(); 440 441 return 1; 442 } 443 #endif 444 445 static boot_os_fn *boot_os[] = { 446 [IH_OS_U_BOOT] = do_bootm_standalone, 447 #ifdef CONFIG_BOOTM_LINUX 448 [IH_OS_LINUX] = do_bootm_linux, 449 #endif 450 #ifdef CONFIG_BOOTM_NETBSD 451 [IH_OS_NETBSD] = do_bootm_netbsd, 452 #endif 453 #ifdef CONFIG_LYNXKDI 454 [IH_OS_LYNXOS] = do_bootm_lynxkdi, 455 #endif 456 #ifdef CONFIG_BOOTM_RTEMS 457 [IH_OS_RTEMS] = do_bootm_rtems, 458 #endif 459 #if defined(CONFIG_BOOTM_OSE) 460 [IH_OS_OSE] = do_bootm_ose, 461 #endif 462 #if defined(CONFIG_BOOTM_PLAN9) 463 [IH_OS_PLAN9] = do_bootm_plan9, 464 #endif 465 #if defined(CONFIG_BOOTM_VXWORKS) && \ 466 (defined(CONFIG_PPC) || defined(CONFIG_ARM)) 467 [IH_OS_VXWORKS] = do_bootm_vxworks, 468 #endif 469 #if defined(CONFIG_CMD_ELF) 470 [IH_OS_QNX] = do_bootm_qnxelf, 471 #endif 472 #ifdef CONFIG_INTEGRITY 473 [IH_OS_INTEGRITY] = do_bootm_integrity, 474 #endif 475 #ifdef CONFIG_BOOTM_OPENRTOS 476 [IH_OS_OPENRTOS] = do_bootm_openrtos, 477 #endif 478 }; 479 480 /* Allow for arch specific config before we boot */ 481 __weak void arch_preboot_os(void) 482 { 483 /* please define platform specific arch_preboot_os() */ 484 } 485 486 int boot_selected_os(int argc, char * const argv[], int state, 487 bootm_headers_t *images, boot_os_fn *boot_fn) 488 { 489 arch_preboot_os(); 490 boot_fn(state, argc, argv, images); 491 492 /* Stand-alone may return when 'autostart' is 'no' */ 493 if (images->os.type == IH_TYPE_STANDALONE || 494 IS_ENABLED(CONFIG_SANDBOX) || 495 state == BOOTM_STATE_OS_FAKE_GO) /* We expect to return */ 496 return 0; 497 bootstage_error(BOOTSTAGE_ID_BOOT_OS_RETURNED); 498 debug("\n## Control returned to monitor - resetting...\n"); 499 500 return BOOTM_ERR_RESET; 501 } 502 503 boot_os_fn *bootm_os_get_boot_func(int os) 504 { 505 #ifdef CONFIG_NEEDS_MANUAL_RELOC 506 static bool relocated; 507 508 if (!relocated) { 509 int i; 510 511 /* relocate boot function table */ 512 for (i = 0; i < ARRAY_SIZE(boot_os); i++) 513 if (boot_os[i] != NULL) 514 boot_os[i] += gd->reloc_off; 515 516 relocated = true; 517 } 518 #endif 519 return boot_os[os]; 520 } 521