common/bootm_os.c

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