arch/arm/lib/bootm.c

   1 /* Copyright (C) 2011
   2  * Corscience GmbH & Co. KG - Simon Schwarz <schwarz@corscience.de>
   3  *  - Added prep subcommand support
   4  *  - Reorganized source - modeled after powerpc version
   5  *
   6  * (C) Copyright 2002
   7  * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
   8  * Marius Groeger <mgroeger@sysgo.de>
   9  *
  10  * Copyright (C) 2001  Erik Mouw (J.A.K.Mouw@its.tudelft.nl)
  11  *
  12  * SPDX-License-Identifier:     GPL-2.0+
  13  */
  14
  15 #include <common.h>
  16 #include <command.h>
  17 #include <dm.h>
  18 #include <dm/root.h>
  19 #include <image.h>
  20 #include <u-boot/zlib.h>
  21 #include <asm/byteorder.h>
  22 #include <linux/libfdt.h>
  23 #include <mapmem.h>
  24 #include <fdt_support.h>
  25 #include <asm/bootm.h>
  26 #include <asm/secure.h>
  27 #include <linux/compiler.h>
  28 #include <bootm.h>
  29 #include <vxworks.h>
  30
  31 #ifdef CONFIG_ARMV7_NONSEC
  32 #include <asm/armv7.h>
  33 #endif
  34 #include <asm/setup.h>
  35
  36 DECLARE_GLOBAL_DATA_PTR;
  37
  38 static struct tag *params;
  39
  40 static ulong get_sp(void)
  41 {
  42         ulong ret;
  43
  44         asm("mov %0, sp" : "=r"(ret) : );
  45         return ret;
  46 }
  47
  48 void arch_lmb_reserve(struct lmb *lmb)
  49 {
  50         ulong sp, bank_end;
  51         int bank;
  52
  53         /*
  54          * Booting a (Linux) kernel image
  55          *
  56          * Allocate space for command line and board info - the
  57          * address should be as high as possible within the reach of
  58          * the kernel (see CONFIG_SYS_BOOTMAPSZ settings), but in unused
  59          * memory, which means far enough below the current stack
  60          * pointer.
  61          */
  62         sp = get_sp();
  63         debug("## Current stack ends at 0x%08lx ", sp);
  64
  65         /* adjust sp by 4K to be safe */
  66         sp -= 4096;
  67         for (bank = 0; bank < CONFIG_NR_DRAM_BANKS; bank++) {
  68                 if (sp < gd->bd->bi_dram[bank].start)
  69                         continue;
  70                 bank_end = gd->bd->bi_dram[bank].start +
  71                         gd->bd->bi_dram[bank].size;
  72                 if (sp >= bank_end)
  73                         continue;
  74                 lmb_reserve(lmb, sp, bank_end - sp);
  75                 break;
  76         }
  77 }
  78
  79 __weak void board_quiesce_devices(void)
  80 {
  81 }
  82
  83 /**
  84  * announce_and_cleanup() - Print message and prepare for kernel boot
  85  *
  86  * @fake: non-zero to do everything except actually boot
  87  */
  88 static void announce_and_cleanup(int fake)
  89 {
  90         printf("\nStarting kernel ...%s\n\n", fake ?
  91                 "(fake run for tracing)" : "");
  92         bootstage_mark_name(BOOTSTAGE_ID_BOOTM_HANDOFF, "start_kernel");
  93 #ifdef CONFIG_BOOTSTAGE_FDT
  94         bootstage_fdt_add_report();
  95 #endif
  96 #ifdef CONFIG_BOOTSTAGE_REPORT
  97         bootstage_report();
  98 #endif
  99
 100 #ifdef CONFIG_USB_DEVICE
 101         udc_disconnect();
 102 #endif
 103
 104         board_quiesce_devices();
 105
 106         /*
 107          * Call remove function of all devices with a removal flag set.
 108          * This may be useful for last-stage operations, like cancelling
 109          * of DMA operation or releasing device internal buffers.
 110          */
 111         dm_remove_devices_flags(DM_REMOVE_ACTIVE_ALL);
 112
 113         cleanup_before_linux();
 114 }
 115
 116 static void setup_start_tag (bd_t *bd)
 117 {
 118         params = (struct tag *)bd->bi_boot_params;
 119
 120         params->hdr.tag = ATAG_CORE;
 121         params->hdr.size = tag_size (tag_core);
 122
 123         params->u.core.flags = 0;
 124         params->u.core.pagesize = 0;
 125         params->u.core.rootdev = 0;
 126
 127         params = tag_next (params);
 128 }
 129
 130 static void setup_memory_tags(bd_t *bd)
 131 {
 132         int i;
 133
 134         for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
 135                 params->hdr.tag = ATAG_MEM;
 136                 params->hdr.size = tag_size (tag_mem32);
 137
 138                 params->u.mem.start = bd->bi_dram[i].start;
 139                 params->u.mem.size = bd->bi_dram[i].size;
 140
 141                 params = tag_next (params);
 142         }
 143 }
 144
 145 static void setup_commandline_tag(bd_t *bd, char *commandline)
 146 {
 147         char *p;
 148
 149         if (!commandline)
 150                 return;
 151
 152         /* eat leading white space */
 153         for (p = commandline; *p == ' '; p++);
 154
 155         /* skip non-existent command lines so the kernel will still
 156          * use its default command line.
 157          */
 158         if (*p == '\0')
 159                 return;
 160
 161         params->hdr.tag = ATAG_CMDLINE;
 162         params->hdr.size =
 163                 (sizeof (struct tag_header) + strlen (p) + 1 + 4) >> 2;
 164
 165         strcpy (params->u.cmdline.cmdline, p);
 166
 167         params = tag_next (params);
 168 }
 169
 170 static void setup_initrd_tag(bd_t *bd, ulong initrd_start, ulong initrd_end)
 171 {
 172         /* an ATAG_INITRD node tells the kernel where the compressed
 173          * ramdisk can be found. ATAG_RDIMG is a better name, actually.
 174          */
 175         params->hdr.tag = ATAG_INITRD2;
 176         params->hdr.size = tag_size (tag_initrd);
 177
 178         params->u.initrd.start = initrd_start;
 179         params->u.initrd.size = initrd_end - initrd_start;
 180
 181         params = tag_next (params);
 182 }
 183
 184 static void setup_serial_tag(struct tag **tmp)
 185 {
 186         struct tag *params = *tmp;
 187         struct tag_serialnr serialnr;
 188
 189         get_board_serial(&serialnr);
 190         params->hdr.tag = ATAG_SERIAL;
 191         params->hdr.size = tag_size (tag_serialnr);
 192         params->u.serialnr.low = serialnr.low;
 193         params->u.serialnr.high= serialnr.high;
 194         params = tag_next (params);
 195         *tmp = params;
 196 }
 197
 198 static void setup_revision_tag(struct tag **in_params)
 199 {
 200         u32 rev = 0;
 201
 202         rev = get_board_rev();
 203         params->hdr.tag = ATAG_REVISION;
 204         params->hdr.size = tag_size (tag_revision);
 205         params->u.revision.rev = rev;
 206         params = tag_next (params);
 207 }
 208
 209 static void setup_end_tag(bd_t *bd)
 210 {
 211         params->hdr.tag = ATAG_NONE;
 212         params->hdr.size = 0;
 213 }
 214
 215 __weak void setup_board_tags(struct tag **in_params) {}
 216
 217 #ifdef CONFIG_ARM64
 218 static void do_nonsec_virt_switch(void)
 219 {
 220         smp_kick_all_cpus();
 221         dcache_disable();       /* flush cache before swtiching to EL2 */
 222 }
 223 #endif
 224
 225 /* Subcommand: PREP */
 226 static void boot_prep_linux(bootm_headers_t *images)
 227 {
 228         char *commandline = env_get("bootargs");
 229
 230         if (IMAGE_ENABLE_OF_LIBFDT && images->ft_len) {
 231 #ifdef CONFIG_OF_LIBFDT
 232                 debug("using: FDT\n");
 233                 if (image_setup_linux(images)) {
 234                         printf("FDT creation failed! hanging...");
 235                         hang();
 236                 }
 237 #endif
 238         } else if (BOOTM_ENABLE_TAGS) {
 239                 debug("using: ATAGS\n");
 240                 setup_start_tag(gd->bd);
 241                 if (BOOTM_ENABLE_SERIAL_TAG)
 242                         setup_serial_tag(&params);
 243                 if (BOOTM_ENABLE_CMDLINE_TAG)
 244                         setup_commandline_tag(gd->bd, commandline);
 245                 if (BOOTM_ENABLE_REVISION_TAG)
 246                         setup_revision_tag(&params);
 247                 if (BOOTM_ENABLE_MEMORY_TAGS)
 248                         setup_memory_tags(gd->bd);
 249                 if (BOOTM_ENABLE_INITRD_TAG) {
 250                         /*
 251                          * In boot_ramdisk_high(), it may relocate ramdisk to
 252                          * a specified location. And set images->initrd_start &
 253                          * images->initrd_end to relocated ramdisk's start/end
 254                          * addresses. So use them instead of images->rd_start &
 255                          * images->rd_end when possible.
 256                          */
 257                         if (images->initrd_start && images->initrd_end) {
 258                                 setup_initrd_tag(gd->bd, images->initrd_start,
 259                                                  images->initrd_end);
 260                         } else if (images->rd_start && images->rd_end) {
 261                                 setup_initrd_tag(gd->bd, images->rd_start,
 262                                                  images->rd_end);
 263                         }
 264                 }
 265                 setup_board_tags(&params);
 266                 setup_end_tag(gd->bd);
 267         } else {
 268                 printf("FDT and ATAGS support not compiled in - hanging\n");
 269                 hang();
 270         }
 271 }
 272
 273 __weak bool armv7_boot_nonsec_default(void)
 274 {
 275 #ifdef CONFIG_ARMV7_BOOT_SEC_DEFAULT
 276         return false;
 277 #else
 278         return true;
 279 #endif
 280 }
 281
 282 #ifdef CONFIG_ARMV7_NONSEC
 283 bool armv7_boot_nonsec(void)
 284 {
 285         char *s = env_get("bootm_boot_mode");
 286         bool nonsec = armv7_boot_nonsec_default();
 287
 288         if (s && !strcmp(s, "sec"))
 289                 nonsec = false;
 290
 291         if (s && !strcmp(s, "nonsec"))
 292                 nonsec = true;
 293
 294         return nonsec;
 295 }
 296 #endif
 297
 298 #ifdef CONFIG_ARM64
 299 __weak void update_os_arch_secondary_cores(uint8_t os_arch)
 300 {
 301 }
 302
 303 #ifdef CONFIG_ARMV8_SWITCH_TO_EL1
 304 static void switch_to_el1(void)
 305 {
 306         if ((IH_ARCH_DEFAULT == IH_ARCH_ARM64) &&
 307             (images.os.arch == IH_ARCH_ARM))
 308                 armv8_switch_to_el1(0, (u64)gd->bd->bi_arch_number,
 309                                     (u64)images.ft_addr, 0,
 310                                     (u64)images.ep,
 311                                     ES_TO_AARCH32);
 312         else
 313                 armv8_switch_to_el1((u64)images.ft_addr, 0, 0, 0,
 314                                     images.ep,
 315                                     ES_TO_AARCH64);
 316 }
 317 #endif
 318 #endif
 319
 320 /* Subcommand: GO */
 321 static void boot_jump_linux(bootm_headers_t *images, int flag)
 322 {
 323 #ifdef CONFIG_ARM64
 324         void (*kernel_entry)(void *fdt_addr, void *res0, void *res1,
 325                         void *res2);
 326         int fake = (flag & BOOTM_STATE_OS_FAKE_GO);
 327
 328         kernel_entry = (void (*)(void *fdt_addr, void *res0, void *res1,
 329                                 void *res2))images->ep;
 330
 331         debug("## Transferring control to Linux (at address %lx)...\n",
 332                 (ulong) kernel_entry);
 333         bootstage_mark(BOOTSTAGE_ID_RUN_OS);
 334
 335         announce_and_cleanup(fake);
 336
 337         if (!fake) {
 338 #ifdef CONFIG_ARMV8_PSCI
 339                 armv8_setup_psci();
 340 #endif
 341                 do_nonsec_virt_switch();
 342
 343                 update_os_arch_secondary_cores(images->os.arch);
 344
 345 #ifdef CONFIG_ARMV8_SWITCH_TO_EL1
 346                 armv8_switch_to_el2((u64)images->ft_addr, 0, 0, 0,
 347                                     (u64)switch_to_el1, ES_TO_AARCH64);
 348 #else
 349                 if ((IH_ARCH_DEFAULT == IH_ARCH_ARM64) &&
 350                     (images->os.arch == IH_ARCH_ARM))
 351                         armv8_switch_to_el2(0, (u64)gd->bd->bi_arch_number,
 352                                             (u64)images->ft_addr, 0,
 353                                             (u64)images->ep,
 354                                             ES_TO_AARCH32);
 355                 else
 356                         armv8_switch_to_el2((u64)images->ft_addr, 0, 0, 0,
 357                                             images->ep,
 358                                             ES_TO_AARCH64);
 359 #endif
 360         }
 361 #else
 362         unsigned long machid = gd->bd->bi_arch_number;
 363         char *s;
 364         void (*kernel_entry)(int zero, int arch, uint params);
 365         unsigned long r2;
 366         int fake = (flag & BOOTM_STATE_OS_FAKE_GO);
 367
 368         kernel_entry = (void (*)(int, int, uint))images->ep;
 369 #ifdef CONFIG_CPU_V7M
 370         ulong addr = (ulong)kernel_entry | 1;
 371         kernel_entry = (void *)addr;
 372 #endif
 373         s = env_get("machid");
 374         if (s) {
 375                 if (strict_strtoul(s, 16, &machid) < 0) {
 376                         debug("strict_strtoul failed!\n");
 377                         return;
 378                 }
 379                 printf("Using machid 0x%lx from environment\n", machid);
 380         }
 381
 382         debug("## Transferring control to Linux (at address %08lx)" \
 383                 "...\n", (ulong) kernel_entry);
 384         bootstage_mark(BOOTSTAGE_ID_RUN_OS);
 385         announce_and_cleanup(fake);
 386
 387         if (IMAGE_ENABLE_OF_LIBFDT && images->ft_len)
 388                 r2 = (unsigned long)images->ft_addr;
 389         else
 390                 r2 = gd->bd->bi_boot_params;
 391
 392         if (!fake) {
 393 #ifdef CONFIG_ARMV7_NONSEC
 394                 if (armv7_boot_nonsec()) {
 395                         armv7_init_nonsec();
 396                         secure_ram_addr(_do_nonsec_entry)(kernel_entry,
 397                                                           0, machid, r2);
 398                 } else
 399 #endif
 400                         kernel_entry(0, machid, r2);
 401         }
 402 #endif
 403 }
 404
 405 /* Main Entry point for arm bootm implementation
 406  *
 407  * Modeled after the powerpc implementation
 408  * DIFFERENCE: Instead of calling prep and go at the end
 409  * they are called if subcommand is equal 0.
 410  */
 411 int do_bootm_linux(int flag, int argc, char * const argv[],
 412                    bootm_headers_t *images)
 413 {
 414         /* No need for those on ARM */
 415         if (flag & BOOTM_STATE_OS_BD_T || flag & BOOTM_STATE_OS_CMDLINE)
 416                 return -1;
 417
 418         if (flag & BOOTM_STATE_OS_PREP) {
 419                 boot_prep_linux(images);
 420                 return 0;
 421         }
 422
 423         if (flag & (BOOTM_STATE_OS_GO | BOOTM_STATE_OS_FAKE_GO)) {
 424                 boot_jump_linux(images, flag);
 425                 return 0;
 426         }
 427
 428         boot_prep_linux(images);
 429         boot_jump_linux(images, flag);
 430         return 0;
 431 }
 432
 433 #if defined(CONFIG_BOOTM_VXWORKS)
 434 void boot_prep_vxworks(bootm_headers_t *images)
 435 {
 436 #if defined(CONFIG_OF_LIBFDT)
 437         int off;
 438
 439         if (images->ft_addr) {
 440                 off = fdt_path_offset(images->ft_addr, "/memory");
 441                 if (off < 0) {
 442                         if (arch_fixup_fdt(images->ft_addr))
 443                                 puts("## WARNING: fixup memory failed!\n");
 444                 }
 445         }
 446 #endif
 447         cleanup_before_linux();
 448 }
 449 void boot_jump_vxworks(bootm_headers_t *images)
 450 {
 451         /* ARM VxWorks requires device tree physical address to be passed */
 452         ((void (*)(void *))images->ep)(images->ft_addr);
 453 }
 454 #endif