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