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