arch/mips/lib/bootm.c

   1 /*
   2  * (C) Copyright 2003
   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 <command.h>
  10 #include <image.h>
  11 #include <u-boot/zlib.h>
  12 #include <asm/byteorder.h>
  13 #include <asm/addrspace.h>
  14
  15 DECLARE_GLOBAL_DATA_PTR;
  16
  17 #define LINUX_MAX_ENVS          256
  18 #define LINUX_MAX_ARGS          256
  19
  20 static int linux_argc;
  21 static char **linux_argv;
  22 static char *linux_argp;
  23
  24 static char **linux_env;
  25 static char *linux_env_p;
  26 static int linux_env_idx;
  27
  28 static ulong arch_get_sp(void)
  29 {
  30         ulong ret;
  31
  32         __asm__ __volatile__("move %0, $sp" : "=r"(ret) : );
  33
  34         return ret;
  35 }
  36
  37 void arch_lmb_reserve(struct lmb *lmb)
  38 {
  39         ulong sp;
  40
  41         sp = arch_get_sp();
  42         debug("## Current stack ends at 0x%08lx\n", sp);
  43
  44         /* adjust sp by 4K to be safe */
  45         sp -= 4096;
  46         lmb_reserve(lmb, sp, CONFIG_SYS_SDRAM_BASE + gd->ram_size - sp);
  47 }
  48
  49 static void linux_cmdline_init(void)
  50 {
  51         linux_argc = 1;
  52         linux_argv = (char **)UNCACHED_SDRAM(gd->bd->bi_boot_params);
  53         linux_argv[0] = 0;
  54         linux_argp = (char *)(linux_argv + LINUX_MAX_ARGS);
  55 }
  56
  57 static void linux_cmdline_set(const char *value, size_t len)
  58 {
  59         linux_argv[linux_argc] = linux_argp;
  60         memcpy(linux_argp, value, len);
  61         linux_argp[len] = 0;
  62
  63         linux_argp += len + 1;
  64         linux_argc++;
  65 }
  66
  67 static void linux_cmdline_dump(void)
  68 {
  69         int i;
  70
  71         debug("## cmdline argv at 0x%p, argp at 0x%p\n",
  72               linux_argv, linux_argp);
  73
  74         for (i = 1; i < linux_argc; i++)
  75                 debug("   arg %03d: %s\n", i, linux_argv[i]);
  76 }
  77
  78 static void boot_cmdline_linux(bootm_headers_t *images)
  79 {
  80         const char *bootargs, *next, *quote;
  81
  82         linux_cmdline_init();
  83
  84         bootargs = getenv("bootargs");
  85         if (!bootargs)
  86                 return;
  87
  88         next = bootargs;
  89
  90         while (bootargs && *bootargs && linux_argc < LINUX_MAX_ARGS) {
  91                 quote = strchr(bootargs, '"');
  92                 next = strchr(bootargs, ' ');
  93
  94                 while (next && quote && quote < next) {
  95                         /*
  96                          * we found a left quote before the next blank
  97                          * now we have to find the matching right quote
  98                          */
  99                         next = strchr(quote + 1, '"');
 100                         if (next) {
 101                                 quote = strchr(next + 1, '"');
 102                                 next = strchr(next + 1, ' ');
 103                         }
 104                 }
 105
 106                 if (!next)
 107                         next = bootargs + strlen(bootargs);
 108
 109                 linux_cmdline_set(bootargs, next - bootargs);
 110
 111                 if (*next)
 112                         next++;
 113
 114                 bootargs = next;
 115         }
 116
 117         linux_cmdline_dump();
 118 }
 119
 120 static void linux_env_init(void)
 121 {
 122         linux_env = (char **)(((ulong) linux_argp + 15) & ~15);
 123         linux_env[0] = 0;
 124         linux_env_p = (char *)(linux_env + LINUX_MAX_ENVS);
 125         linux_env_idx = 0;
 126 }
 127
 128 static void linux_env_set(const char *env_name, const char *env_val)
 129 {
 130         if (linux_env_idx < LINUX_MAX_ENVS - 1) {
 131                 linux_env[linux_env_idx] = linux_env_p;
 132
 133                 strcpy(linux_env_p, env_name);
 134                 linux_env_p += strlen(env_name);
 135
 136                 *linux_env_p++ = '=';
 137
 138                 strcpy(linux_env_p, env_val);
 139                 linux_env_p += strlen(env_val);
 140
 141                 linux_env_p++;
 142                 linux_env[++linux_env_idx] = 0;
 143         }
 144 }
 145
 146 static void boot_prep_linux(bootm_headers_t *images)
 147 {
 148         char env_buf[12];
 149         const char *cp;
 150         ulong rd_start, rd_size;
 151
 152 #ifdef CONFIG_MEMSIZE_IN_BYTES
 153         sprintf(env_buf, "%lu", (ulong)gd->ram_size);
 154         debug("## Giving linux memsize in bytes, %lu\n", (ulong)gd->ram_size);
 155 #else
 156         sprintf(env_buf, "%lu", (ulong)(gd->ram_size >> 20));
 157         debug("## Giving linux memsize in MB, %lu\n",
 158               (ulong)(gd->ram_size >> 20));
 159 #endif /* CONFIG_MEMSIZE_IN_BYTES */
 160
 161         rd_start = UNCACHED_SDRAM(images->initrd_start);
 162         rd_size = images->initrd_end - images->initrd_start;
 163
 164         linux_env_init();
 165
 166         linux_env_set("memsize", env_buf);
 167
 168         sprintf(env_buf, "0x%08lX", rd_start);
 169         linux_env_set("initrd_start", env_buf);
 170
 171         sprintf(env_buf, "0x%lX", rd_size);
 172         linux_env_set("initrd_size", env_buf);
 173
 174         sprintf(env_buf, "0x%08X", (uint) (gd->bd->bi_flashstart));
 175         linux_env_set("flash_start", env_buf);
 176
 177         sprintf(env_buf, "0x%X", (uint) (gd->bd->bi_flashsize));
 178         linux_env_set("flash_size", env_buf);
 179
 180         cp = getenv("ethaddr");
 181         if (cp)
 182                 linux_env_set("ethaddr", cp);
 183
 184         cp = getenv("eth1addr");
 185         if (cp)
 186                 linux_env_set("eth1addr", cp);
 187 }
 188
 189 static void boot_jump_linux(bootm_headers_t *images)
 190 {
 191         typedef void __noreturn (*kernel_entry_t)(int, ulong, ulong, ulong);
 192         kernel_entry_t kernel = (kernel_entry_t) images->ep;
 193
 194         debug("## Transferring control to Linux (at address %p) ...\n", kernel);
 195
 196         bootstage_mark(BOOTSTAGE_ID_RUN_OS);
 197
 198         /* we assume that the kernel is in place */
 199         printf("\nStarting kernel ...\n\n");
 200
 201         kernel(linux_argc, (ulong)linux_argv, (ulong)linux_env, 0);
 202 }
 203
 204 int do_bootm_linux(int flag, int argc, char * const argv[],
 205                         bootm_headers_t *images)
 206 {
 207         /* No need for those on MIPS */
 208         if (flag & BOOTM_STATE_OS_BD_T)
 209                 return -1;
 210
 211         if (flag & BOOTM_STATE_OS_CMDLINE) {
 212                 boot_cmdline_linux(images);
 213                 return 0;
 214         }
 215
 216         if (flag & BOOTM_STATE_OS_PREP) {
 217                 boot_prep_linux(images);
 218                 return 0;
 219         }
 220
 221         if (flag & BOOTM_STATE_OS_GO) {
 222                 boot_jump_linux(images);
 223                 return 0;
 224         }
 225
 226         boot_cmdline_linux(images);
 227         boot_prep_linux(images);
 228         boot_jump_linux(images);
 229
 230         /* does not return */
 231         return 1;
 232 }