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 <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         char *s;
  30         int (*appl)(int, char *const[]);
  31
  32         /* Don't start if "autostart" is set to "no" */
  33         s = env_get("autostart");
  34         if ((s != NULL) && !strcmp(s, "no")) {
  35                 env_set_hex("filesize", images->os.image_len);
  36                 return 0;
  37         }
  38         appl = (int (*)(int, char * const []))images->ep;
  39         appl(argc, argv);
  40         return 0;
  41 }
  42
  43 /*******************************************************************/
  44 /* OS booting routines */
  45 /*******************************************************************/
  46
  47 #if defined(CONFIG_BOOTM_NETBSD) || defined(CONFIG_BOOTM_PLAN9)
  48 static void copy_args(char *dest, int argc, char *const argv[], char delim)
  49 {
  50         int i;
  51
  52         for (i = 0; i < argc; i++) {
  53                 if (i > 0)
  54                         *dest++ = delim;
  55                 strcpy(dest, argv[i]);
  56                 dest += strlen(argv[i]);
  57         }
  58 }
  59 #endif
  60
  61 #ifdef CONFIG_BOOTM_NETBSD
  62 static int do_bootm_netbsd(int flag, int argc, char *const argv[],
  63                            bootm_headers_t *images)
  64 {
  65         void (*loader)(struct bd_info *, image_header_t *, char *, char *);
  66         image_header_t *os_hdr, *hdr;
  67         ulong kernel_data, kernel_len;
  68         char *cmdline;
  69
  70         if (flag != BOOTM_STATE_OS_GO)
  71                 return 0;
  72
  73 #if defined(CONFIG_FIT)
  74         if (!images->legacy_hdr_valid) {
  75                 fit_unsupported_reset("NetBSD");
  76                 return 1;
  77         }
  78 #endif
  79         hdr = images->legacy_hdr_os;
  80
  81         /*
  82          * Booting a (NetBSD) kernel image
  83          *
  84          * This process is pretty similar to a standalone application:
  85          * The (first part of an multi-) image must be a stage-2 loader,
  86          * which in turn is responsible for loading & invoking the actual
  87          * kernel.  The only differences are the parameters being passed:
  88          * besides the board info strucure, the loader expects a command
  89          * line, the name of the console device, and (optionally) the
  90          * address of the original image header.
  91          */
  92         os_hdr = NULL;
  93         if (image_check_type(&images->legacy_hdr_os_copy, IH_TYPE_MULTI)) {
  94                 image_multi_getimg(hdr, 1, &kernel_data, &kernel_len);
  95                 if (kernel_len)
  96                         os_hdr = hdr;
  97         }
  98
  99         if (argc > 0) {
 100                 ulong len;
 101                 int   i;
 102
 103                 for (i = 0, len = 0; i < argc; i += 1)
 104                         len += strlen(argv[i]) + 1;
 105                 cmdline = malloc(len);
 106                 copy_args(cmdline, argc, argv, ' ');
 107         } else {
 108                 cmdline = env_get("bootargs");
 109                 if (cmdline == NULL)
 110                         cmdline = "";
 111         }
 112
 113         loader = (void (*)(struct bd_info *, image_header_t *, char *, char *))images->ep;
 114
 115         printf("## Transferring control to NetBSD stage-2 loader (at address %08lx) ...\n",
 116                (ulong)loader);
 117
 118         bootstage_mark(BOOTSTAGE_ID_RUN_OS);
 119
 120         /*
 121          * NetBSD Stage-2 Loader Parameters:
 122          *   arg[0]: pointer to board info data
 123          *   arg[1]: image load address
 124          *   arg[2]: char pointer to the console device to use
 125          *   arg[3]: char pointer to the boot arguments
 126          */
 127         (*loader)(gd->bd, os_hdr, "", cmdline);
 128
 129         return 1;
 130 }
 131 #endif /* CONFIG_BOOTM_NETBSD*/
 132
 133 #ifdef CONFIG_LYNXKDI
 134 static int do_bootm_lynxkdi(int flag, int argc, char *const argv[],
 135                             bootm_headers_t *images)
 136 {
 137         image_header_t *hdr = &images->legacy_hdr_os_copy;
 138
 139         if (flag != BOOTM_STATE_OS_GO)
 140                 return 0;
 141
 142 #if defined(CONFIG_FIT)
 143         if (!images->legacy_hdr_valid) {
 144                 fit_unsupported_reset("Lynx");
 145                 return 1;
 146         }
 147 #endif
 148
 149         lynxkdi_boot((image_header_t *)hdr);
 150
 151         return 1;
 152 }
 153 #endif /* CONFIG_LYNXKDI */
 154
 155 #ifdef CONFIG_BOOTM_RTEMS
 156 static int do_bootm_rtems(int flag, int argc, char *const argv[],
 157                           bootm_headers_t *images)
 158 {
 159         void (*entry_point)(struct bd_info *);
 160
 161         if (flag != BOOTM_STATE_OS_GO)
 162                 return 0;
 163
 164 #if defined(CONFIG_FIT)
 165         if (!images->legacy_hdr_valid) {
 166                 fit_unsupported_reset("RTEMS");
 167                 return 1;
 168         }
 169 #endif
 170
 171         entry_point = (void (*)(struct bd_info *))images->ep;
 172
 173         printf("## Transferring control to RTEMS (at address %08lx) ...\n",
 174                (ulong)entry_point);
 175
 176         bootstage_mark(BOOTSTAGE_ID_RUN_OS);
 177
 178         /*
 179          * RTEMS Parameters:
 180          *   r3: ptr to board info data
 181          */
 182         (*entry_point)(gd->bd);
 183
 184         return 1;
 185 }
 186 #endif /* CONFIG_BOOTM_RTEMS */
 187
 188 #if defined(CONFIG_BOOTM_OSE)
 189 static int do_bootm_ose(int flag, int argc, char *const argv[],
 190                         bootm_headers_t *images)
 191 {
 192         void (*entry_point)(void);
 193
 194         if (flag != BOOTM_STATE_OS_GO)
 195                 return 0;
 196
 197 #if defined(CONFIG_FIT)
 198         if (!images->legacy_hdr_valid) {
 199                 fit_unsupported_reset("OSE");
 200                 return 1;
 201         }
 202 #endif
 203
 204         entry_point = (void (*)(void))images->ep;
 205
 206         printf("## Transferring control to OSE (at address %08lx) ...\n",
 207                (ulong)entry_point);
 208
 209         bootstage_mark(BOOTSTAGE_ID_RUN_OS);
 210
 211         /*
 212          * OSE Parameters:
 213          *   None
 214          */
 215         (*entry_point)();
 216
 217         return 1;
 218 }
 219 #endif /* CONFIG_BOOTM_OSE */
 220
 221 #if defined(CONFIG_BOOTM_PLAN9)
 222 static int do_bootm_plan9(int flag, int argc, char *const argv[],
 223                           bootm_headers_t *images)
 224 {
 225         void (*entry_point)(void);
 226         char *s;
 227
 228         if (flag != BOOTM_STATE_OS_GO)
 229                 return 0;
 230
 231 #if defined(CONFIG_FIT)
 232         if (!images->legacy_hdr_valid) {
 233                 fit_unsupported_reset("Plan 9");
 234                 return 1;
 235         }
 236 #endif
 237
 238         /* See README.plan9 */
 239         s = env_get("confaddr");
 240         if (s != NULL) {
 241                 char *confaddr = (char *)hextoul(s, NULL);
 242
 243                 if (argc > 0) {
 244                         copy_args(confaddr, argc, argv, '\n');
 245                 } else {
 246                         s = env_get("bootargs");
 247                         if (s != NULL)
 248                                 strcpy(confaddr, s);
 249                 }
 250         }
 251
 252         entry_point = (void (*)(void))images->ep;
 253
 254         printf("## Transferring control to Plan 9 (at address %08lx) ...\n",
 255                (ulong)entry_point);
 256
 257         bootstage_mark(BOOTSTAGE_ID_RUN_OS);
 258
 259         /*
 260          * Plan 9 Parameters:
 261          *   None
 262          */
 263         (*entry_point)();
 264
 265         return 1;
 266 }
 267 #endif /* CONFIG_BOOTM_PLAN9 */
 268
 269 #if defined(CONFIG_BOOTM_VXWORKS) && \
 270         (defined(CONFIG_PPC) || defined(CONFIG_ARM))
 271
 272 static void do_bootvx_fdt(bootm_headers_t *images)
 273 {
 274 #if defined(CONFIG_OF_LIBFDT)
 275         int ret;
 276         char *bootline;
 277         ulong of_size = images->ft_len;
 278         char **of_flat_tree = &images->ft_addr;
 279         struct lmb *lmb = &images->lmb;
 280
 281         if (*of_flat_tree) {
 282                 boot_fdt_add_mem_rsv_regions(lmb, *of_flat_tree);
 283
 284                 ret = boot_relocate_fdt(lmb, of_flat_tree, &of_size);
 285                 if (ret)
 286                         return;
 287
 288                 /* Update ethernet nodes */
 289                 fdt_fixup_ethernet(*of_flat_tree);
 290
 291                 ret = fdt_add_subnode(*of_flat_tree, 0, "chosen");
 292                 if ((ret >= 0 || ret == -FDT_ERR_EXISTS)) {
 293                         bootline = env_get("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_legacy(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
 347 int do_bootm_vxworks(int flag, int argc, char *const argv[],
 348                      bootm_headers_t *images)
 349 {
 350         char *bootargs;
 351         int pos;
 352         unsigned long vxflags;
 353         bool std_dtb = false;
 354
 355         /* get bootargs env */
 356         bootargs = env_get("bootargs");
 357
 358         if (bootargs != NULL) {
 359                 for (pos = 0; pos < strlen(bootargs); pos++) {
 360                         /* find f=0xnumber flag */
 361                         if ((bootargs[pos] == '=') && (pos >= 1) &&
 362                             (bootargs[pos - 1] == 'f')) {
 363                                 vxflags = hextoul(&bootargs[pos + 1], NULL);
 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, 0, 0);
 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, 0, 0);
 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         /* We expect to return */
 546         images->os.type = IH_TYPE_STANDALONE;
 547
 548         image_buf = map_sysmem(images->ep, images->os.image_len);
 549
 550         efi_ret = efi_run_image(image_buf, images->os.image_len);
 551         if (efi_ret != EFI_SUCCESS)
 552                 return 1;
 553         return 0;
 554 }
 555 #endif
 556
 557 static boot_os_fn *boot_os[] = {
 558         [IH_OS_U_BOOT] = do_bootm_standalone,
 559 #ifdef CONFIG_BOOTM_LINUX
 560         [IH_OS_LINUX] = do_bootm_linux,
 561 #endif
 562 #ifdef CONFIG_BOOTM_NETBSD
 563         [IH_OS_NETBSD] = do_bootm_netbsd,
 564 #endif
 565 #ifdef CONFIG_LYNXKDI
 566         [IH_OS_LYNXOS] = do_bootm_lynxkdi,
 567 #endif
 568 #ifdef CONFIG_BOOTM_RTEMS
 569         [IH_OS_RTEMS] = do_bootm_rtems,
 570 #endif
 571 #if defined(CONFIG_BOOTM_OSE)
 572         [IH_OS_OSE] = do_bootm_ose,
 573 #endif
 574 #if defined(CONFIG_BOOTM_PLAN9)
 575         [IH_OS_PLAN9] = do_bootm_plan9,
 576 #endif
 577 #if defined(CONFIG_BOOTM_VXWORKS) && \
 578         (defined(CONFIG_PPC) || defined(CONFIG_ARM) || defined(CONFIG_RISCV))
 579         [IH_OS_VXWORKS] = do_bootm_vxworks,
 580 #endif
 581 #if defined(CONFIG_CMD_ELF)
 582         [IH_OS_QNX] = do_bootm_qnxelf,
 583 #endif
 584 #ifdef CONFIG_INTEGRITY
 585         [IH_OS_INTEGRITY] = do_bootm_integrity,
 586 #endif
 587 #ifdef CONFIG_BOOTM_OPENRTOS
 588         [IH_OS_OPENRTOS] = do_bootm_openrtos,
 589 #endif
 590 #ifdef CONFIG_BOOTM_OPTEE
 591         [IH_OS_TEE] = do_bootm_tee,
 592 #endif
 593 #ifdef CONFIG_BOOTM_EFI
 594         [IH_OS_EFI] = do_bootm_efi,
 595 #endif
 596 };
 597
 598 /* Allow for arch specific config before we boot */
 599 __weak void arch_preboot_os(void)
 600 {
 601         /* please define platform specific arch_preboot_os() */
 602 }
 603
 604 /* Allow for board specific config before we boot */
 605 __weak void board_preboot_os(void)
 606 {
 607         /* please define board specific board_preboot_os() */
 608 }
 609
 610 int boot_selected_os(int argc, char *const argv[], int state,
 611                      bootm_headers_t *images, boot_os_fn *boot_fn)
 612 {
 613         arch_preboot_os();
 614         board_preboot_os();
 615         boot_fn(state, argc, argv, images);
 616
 617         /* Stand-alone may return when 'autostart' is 'no' */
 618         if (images->os.type == IH_TYPE_STANDALONE ||
 619             IS_ENABLED(CONFIG_SANDBOX) ||
 620             state == BOOTM_STATE_OS_FAKE_GO) /* We expect to return */
 621                 return 0;
 622         bootstage_error(BOOTSTAGE_ID_BOOT_OS_RETURNED);
 623         debug("\n## Control returned to monitor - resetting...\n");
 624
 625         return BOOTM_ERR_RESET;
 626 }
 627
 628 boot_os_fn *bootm_os_get_boot_func(int os)
 629 {
 630 #ifdef CONFIG_NEEDS_MANUAL_RELOC
 631         static bool relocated;
 632
 633         if (!relocated) {
 634                 int i;
 635
 636                 /* relocate boot function table */
 637                 for (i = 0; i < ARRAY_SIZE(boot_os); i++)
 638                         if (boot_os[i] != NULL)
 639                                 boot_os[i] += gd->reloc_off;
 640
 641                 relocated = true;
 642         }
 643 #endif
 644         return boot_os[os];
 645 }