]> git.sur5r.net Git - u-boot/blob - arch/mips/lib/bootm.c
MIPS: refactor L1 cache config reads to a macro
[u-boot] / 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 <image.h>
10 #include <fdt_support.h>
11 #include <asm/addrspace.h>
12
13 DECLARE_GLOBAL_DATA_PTR;
14
15 #define LINUX_MAX_ENVS          256
16 #define LINUX_MAX_ARGS          256
17
18 #if defined(CONFIG_MALTA)
19 #define mips_boot_malta         1
20 #else
21 #define mips_boot_malta         0
22 #endif
23
24 #if defined(CONFIG_MIPS_BOOT_CMDLINE_LEGACY)
25 #define mips_boot_cmdline_legacy        1
26 #else
27 #define mips_boot_cmdline_legacy        0
28 #endif
29
30 #if defined(CONFIG_MIPS_BOOT_ENV_LEGACY)
31 #define mips_boot_env_legacy    1
32 #else
33 #define mips_boot_env_legacy    0
34 #endif
35
36 static int linux_argc;
37 static char **linux_argv;
38 static char *linux_argp;
39
40 static char **linux_env;
41 static char *linux_env_p;
42 static int linux_env_idx;
43
44 static ulong arch_get_sp(void)
45 {
46         ulong ret;
47
48         __asm__ __volatile__("move %0, $sp" : "=r"(ret) : );
49
50         return ret;
51 }
52
53 void arch_lmb_reserve(struct lmb *lmb)
54 {
55         ulong sp;
56
57         sp = arch_get_sp();
58         debug("## Current stack ends at 0x%08lx\n", sp);
59
60         /* adjust sp by 4K to be safe */
61         sp -= 4096;
62         lmb_reserve(lmb, sp, CONFIG_SYS_SDRAM_BASE + gd->ram_size - sp);
63 }
64
65 static int boot_setup_linux(bootm_headers_t *images)
66 {
67         int ret;
68         ulong rd_len;
69
70         rd_len = images->rd_end - images->rd_start;
71         ret = boot_ramdisk_high(&images->lmb, images->rd_start,
72                 rd_len, &images->initrd_start, &images->initrd_end);
73         if (ret)
74                 return ret;
75
76 #if defined(CONFIG_MIPS_BOOT_FDT) && defined(CONFIG_OF_LIBFDT)
77         if (images->ft_len) {
78                 boot_fdt_add_mem_rsv_regions(&images->lmb, images->ft_addr);
79
80                 ret = boot_relocate_fdt(&images->lmb, &images->ft_addr,
81                         &images->ft_len);
82                 if (ret)
83                         return ret;
84         }
85 #endif
86
87         return 0;
88 }
89
90 static void boot_setup_fdt(bootm_headers_t *images)
91 {
92 #if defined(CONFIG_MIPS_BOOT_FDT) && defined(CONFIG_OF_LIBFDT)
93         u64 mem_start = 0;
94         u64 mem_size = gd->ram_size;
95
96         debug("## setup FDT\n");
97
98         fdt_chosen(images->ft_addr, 1);
99         fdt_fixup_memory_banks(images->ft_addr, &mem_start, &mem_size, 1);
100         fdt_fixup_ethernet(images->ft_addr);
101         fdt_initrd(images->ft_addr, images->initrd_start, images->initrd_end, 1);
102
103 #if defined(CONFIG_OF_BOARD_SETUP)
104         ft_board_setup(images->ft_addr, gd->bd);
105 #endif
106 #endif
107 }
108
109 static void linux_cmdline_init(void)
110 {
111         linux_argc = 1;
112         linux_argv = (char **)UNCACHED_SDRAM(gd->bd->bi_boot_params);
113         linux_argv[0] = 0;
114         linux_argp = (char *)(linux_argv + LINUX_MAX_ARGS);
115 }
116
117 static void linux_cmdline_set(const char *value, size_t len)
118 {
119         linux_argv[linux_argc] = linux_argp;
120         memcpy(linux_argp, value, len);
121         linux_argp[len] = 0;
122
123         linux_argp += len + 1;
124         linux_argc++;
125 }
126
127 static void linux_cmdline_dump(void)
128 {
129         int i;
130
131         debug("## cmdline argv at 0x%p, argp at 0x%p\n",
132               linux_argv, linux_argp);
133
134         for (i = 1; i < linux_argc; i++)
135                 debug("   arg %03d: %s\n", i, linux_argv[i]);
136 }
137
138 static void linux_cmdline_legacy(bootm_headers_t *images)
139 {
140         const char *bootargs, *next, *quote;
141
142         linux_cmdline_init();
143
144         bootargs = getenv("bootargs");
145         if (!bootargs)
146                 return;
147
148         next = bootargs;
149
150         while (bootargs && *bootargs && linux_argc < LINUX_MAX_ARGS) {
151                 quote = strchr(bootargs, '"');
152                 next = strchr(bootargs, ' ');
153
154                 while (next && quote && quote < next) {
155                         /*
156                          * we found a left quote before the next blank
157                          * now we have to find the matching right quote
158                          */
159                         next = strchr(quote + 1, '"');
160                         if (next) {
161                                 quote = strchr(next + 1, '"');
162                                 next = strchr(next + 1, ' ');
163                         }
164                 }
165
166                 if (!next)
167                         next = bootargs + strlen(bootargs);
168
169                 linux_cmdline_set(bootargs, next - bootargs);
170
171                 if (*next)
172                         next++;
173
174                 bootargs = next;
175         }
176 }
177
178 static void linux_cmdline_append(bootm_headers_t *images)
179 {
180         char buf[24];
181         ulong mem, rd_start, rd_size;
182
183         /* append mem */
184         mem = gd->ram_size >> 20;
185         sprintf(buf, "mem=%luM", mem);
186         linux_cmdline_set(buf, strlen(buf));
187
188         /* append rd_start and rd_size */
189         rd_start = images->initrd_start;
190         rd_size = images->initrd_end - images->initrd_start;
191
192         if (rd_size) {
193                 sprintf(buf, "rd_start=0x%08lX", rd_start);
194                 linux_cmdline_set(buf, strlen(buf));
195                 sprintf(buf, "rd_size=0x%lX", rd_size);
196                 linux_cmdline_set(buf, strlen(buf));
197         }
198 }
199
200 static void boot_cmdline_linux(bootm_headers_t *images)
201 {
202         if (mips_boot_cmdline_legacy && !images->ft_len) {
203                 linux_cmdline_legacy(images);
204
205                 if (!mips_boot_env_legacy)
206                         linux_cmdline_append(images);
207
208                 linux_cmdline_dump();
209         }
210 }
211
212 static void linux_env_init(void)
213 {
214         linux_env = (char **)(((ulong) linux_argp + 15) & ~15);
215         linux_env[0] = 0;
216         linux_env_p = (char *)(linux_env + LINUX_MAX_ENVS);
217         linux_env_idx = 0;
218 }
219
220 static void linux_env_set(const char *env_name, const char *env_val)
221 {
222         if (linux_env_idx < LINUX_MAX_ENVS - 1) {
223                 linux_env[linux_env_idx] = linux_env_p;
224
225                 strcpy(linux_env_p, env_name);
226                 linux_env_p += strlen(env_name);
227
228                 if (mips_boot_malta) {
229                         linux_env_p++;
230                         linux_env[++linux_env_idx] = linux_env_p;
231                 } else {
232                         *linux_env_p++ = '=';
233                 }
234
235                 strcpy(linux_env_p, env_val);
236                 linux_env_p += strlen(env_val);
237
238                 linux_env_p++;
239                 linux_env[++linux_env_idx] = 0;
240         }
241 }
242
243 static void linux_env_legacy(bootm_headers_t *images)
244 {
245         char env_buf[12];
246         const char *cp;
247         ulong rd_start, rd_size;
248
249 #ifdef CONFIG_MEMSIZE_IN_BYTES
250         sprintf(env_buf, "%lu", (ulong)gd->ram_size);
251         debug("## Giving linux memsize in bytes, %lu\n", (ulong)gd->ram_size);
252 #else
253         sprintf(env_buf, "%lu", (ulong)(gd->ram_size >> 20));
254         debug("## Giving linux memsize in MB, %lu\n",
255               (ulong)(gd->ram_size >> 20));
256 #endif /* CONFIG_MEMSIZE_IN_BYTES */
257
258         rd_start = UNCACHED_SDRAM(images->initrd_start);
259         rd_size = images->initrd_end - images->initrd_start;
260
261         linux_env_init();
262
263         linux_env_set("memsize", env_buf);
264
265         sprintf(env_buf, "0x%08lX", rd_start);
266         linux_env_set("initrd_start", env_buf);
267
268         sprintf(env_buf, "0x%lX", rd_size);
269         linux_env_set("initrd_size", env_buf);
270
271         sprintf(env_buf, "0x%08X", (uint) (gd->bd->bi_flashstart));
272         linux_env_set("flash_start", env_buf);
273
274         sprintf(env_buf, "0x%X", (uint) (gd->bd->bi_flashsize));
275         linux_env_set("flash_size", env_buf);
276
277         cp = getenv("ethaddr");
278         if (cp)
279                 linux_env_set("ethaddr", cp);
280
281         cp = getenv("eth1addr");
282         if (cp)
283                 linux_env_set("eth1addr", cp);
284
285         if (mips_boot_malta) {
286                 sprintf(env_buf, "%un8r", gd->baudrate);
287                 linux_env_set("modetty0", env_buf);
288         }
289 }
290
291 static void boot_prep_linux(bootm_headers_t *images)
292 {
293         if (mips_boot_env_legacy && !images->ft_len)
294                 linux_env_legacy(images);
295
296         if (images->ft_len)
297                 boot_setup_fdt(images);
298 }
299
300 static void boot_jump_linux(bootm_headers_t *images)
301 {
302         typedef void __noreturn (*kernel_entry_t)(int, ulong, ulong, ulong);
303         kernel_entry_t kernel = (kernel_entry_t) images->ep;
304         ulong linux_extra = 0;
305
306         debug("## Transferring control to Linux (at address %p) ...\n", kernel);
307
308         bootstage_mark(BOOTSTAGE_ID_RUN_OS);
309
310         if (mips_boot_malta)
311                 linux_extra = gd->ram_size;
312
313 #ifdef CONFIG_BOOTSTAGE_FDT
314         bootstage_fdt_add_report();
315 #endif
316 #ifdef CONFIG_BOOTSTAGE_REPORT
317         bootstage_report();
318 #endif
319
320         kernel(linux_argc, (ulong)linux_argv, (ulong)linux_env, linux_extra);
321 }
322
323 int do_bootm_linux(int flag, int argc, char * const argv[],
324                         bootm_headers_t *images)
325 {
326         int ret;
327
328         /* No need for those on MIPS */
329         if (flag & BOOTM_STATE_OS_BD_T)
330                 return -1;
331
332         if (flag & BOOTM_STATE_OS_CMDLINE) {
333                 boot_cmdline_linux(images);
334                 return 0;
335         }
336
337         if (flag & BOOTM_STATE_OS_PREP) {
338                 boot_prep_linux(images);
339                 return 0;
340         }
341
342         if (flag & BOOTM_STATE_OS_GO) {
343                 boot_jump_linux(images);
344                 return 0;
345         }
346
347         ret = boot_setup_linux(images);
348         if (ret)
349                 return ret;
350
351         boot_cmdline_linux(images);
352         boot_prep_linux(images);
353         boot_jump_linux(images);
354
355         /* does not return */
356         return 1;
357 }