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 357 if (flag != BOOTM_STATE_OS_GO) 358 return 0; 359 360 #if defined(CONFIG_FIT) 361 if (!images->legacy_hdr_valid) { 362 fit_unsupported_reset("QNX"); 363 return 1; 364 } 365 #endif 366 367 sprintf(str, "%lx", images->ep); /* write entry-point into string */ 368 local_args[0] = argv[0]; 369 local_args[1] = str; /* and provide it via the arguments */ 370 do_bootelf(NULL, 0, 2, local_args); 371 372 return 1; 373 } 374 #endif 375 376 #ifdef CONFIG_INTEGRITY 377 static int do_bootm_integrity(int flag, int argc, char * const argv[], 378 bootm_headers_t *images) 379 { 380 void (*entry_point)(void); 381 382 if (flag != BOOTM_STATE_OS_GO) 383 return 0; 384 385 #if defined(CONFIG_FIT) 386 if (!images->legacy_hdr_valid) { 387 fit_unsupported_reset("INTEGRITY"); 388 return 1; 389 } 390 #endif 391 392 entry_point = (void (*)(void))images->ep; 393 394 printf("## Transferring control to INTEGRITY (at address %08lx) ...\n", 395 (ulong)entry_point); 396 397 bootstage_mark(BOOTSTAGE_ID_RUN_OS); 398 399 /* 400 * INTEGRITY Parameters: 401 * None 402 */ 403 (*entry_point)(); 404 405 return 1; 406 } 407 #endif 408 409 #ifdef CONFIG_BOOTM_OPENRTOS 410 static int do_bootm_openrtos(int flag, int argc, char * const argv[], 411 bootm_headers_t *images) 412 { 413 void (*entry_point)(void); 414 415 if (flag != BOOTM_STATE_OS_GO) 416 return 0; 417 418 entry_point = (void (*)(void))images->ep; 419 420 printf("## Transferring control to OpenRTOS (at address %08lx) ...\n", 421 (ulong)entry_point); 422 423 bootstage_mark(BOOTSTAGE_ID_RUN_OS); 424 425 /* 426 * OpenRTOS Parameters: 427 * None 428 */ 429 (*entry_point)(); 430 431 return 1; 432 } 433 #endif 434 435 static boot_os_fn *boot_os[] = { 436 [IH_OS_U_BOOT] = do_bootm_standalone, 437 #ifdef CONFIG_BOOTM_LINUX 438 [IH_OS_LINUX] = do_bootm_linux, 439 #endif 440 #ifdef CONFIG_BOOTM_NETBSD 441 [IH_OS_NETBSD] = do_bootm_netbsd, 442 #endif 443 #ifdef CONFIG_LYNXKDI 444 [IH_OS_LYNXOS] = do_bootm_lynxkdi, 445 #endif 446 #ifdef CONFIG_BOOTM_RTEMS 447 [IH_OS_RTEMS] = do_bootm_rtems, 448 #endif 449 #if defined(CONFIG_BOOTM_OSE) 450 [IH_OS_OSE] = do_bootm_ose, 451 #endif 452 #if defined(CONFIG_BOOTM_PLAN9) 453 [IH_OS_PLAN9] = do_bootm_plan9, 454 #endif 455 #if defined(CONFIG_BOOTM_VXWORKS) && \ 456 (defined(CONFIG_PPC) || defined(CONFIG_ARM)) 457 [IH_OS_VXWORKS] = do_bootm_vxworks, 458 #endif 459 #if defined(CONFIG_CMD_ELF) 460 [IH_OS_QNX] = do_bootm_qnxelf, 461 #endif 462 #ifdef CONFIG_INTEGRITY 463 [IH_OS_INTEGRITY] = do_bootm_integrity, 464 #endif 465 #ifdef CONFIG_BOOTM_OPENRTOS 466 [IH_OS_OPENRTOS] = do_bootm_openrtos, 467 #endif 468 }; 469 470 /* Allow for arch specific config before we boot */ 471 __weak void arch_preboot_os(void) 472 { 473 /* please define platform specific arch_preboot_os() */ 474 } 475 476 int boot_selected_os(int argc, char * const argv[], int state, 477 bootm_headers_t *images, boot_os_fn *boot_fn) 478 { 479 arch_preboot_os(); 480 boot_fn(state, argc, argv, images); 481 482 /* Stand-alone may return when 'autostart' is 'no' */ 483 if (images->os.type == IH_TYPE_STANDALONE || 484 state == BOOTM_STATE_OS_FAKE_GO) /* We expect to return */ 485 return 0; 486 bootstage_error(BOOTSTAGE_ID_BOOT_OS_RETURNED); 487 #ifdef DEBUG 488 puts("\n## Control returned to monitor - resetting...\n"); 489 #endif 490 return BOOTM_ERR_RESET; 491 } 492 493 boot_os_fn *bootm_os_get_boot_func(int os) 494 { 495 #ifdef CONFIG_NEEDS_MANUAL_RELOC 496 static bool relocated; 497 498 if (!relocated) { 499 int i; 500 501 /* relocate boot function table */ 502 for (i = 0; i < ARRAY_SIZE(boot_os); i++) 503 if (boot_os[i] != NULL) 504 boot_os[i] += gd->reloc_off; 505 506 relocated = true; 507 } 508 #endif 509 return boot_os[os]; 510 } 511