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