common/bootm_os.c

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