]>
Commit | Line | Data |
---|---|---|
5d3cc55e MB |
1 | /* |
2 | * (C) Copyright 2008 Semihalf | |
3 | * | |
4 | * (C) Copyright 2000-2006 | |
5 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. | |
6 | * | |
7 | * See file CREDITS for list of people who contributed to this | |
8 | * project. | |
9 | * | |
10 | * This program is free software; you can redistribute it and/or | |
11 | * modify it under the terms of the GNU General Public License as | |
12 | * published by the Free Software Foundation; either version 2 of | |
13 | * the License, or (at your option) any later version. | |
14 | * | |
15 | * This program is distributed in the hope that it will be useful, | |
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
18 | * GNU General Public License for more details. | |
19 | * | |
20 | * You should have received a copy of the GNU General Public License | |
21 | * along with this program; if not, write to the Free Software | |
22 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, | |
23 | * MA 02111-1307 USA | |
24 | */ | |
25 | ||
7582438c | 26 | |
5d3cc55e MB |
27 | #include <common.h> |
28 | #include <watchdog.h> | |
29 | #include <command.h> | |
30 | #include <image.h> | |
31 | #include <malloc.h> | |
a31e091a | 32 | #include <u-boot/zlib.h> |
5d3cc55e MB |
33 | #include <bzlib.h> |
34 | #include <environment.h> | |
35 | #include <asm/byteorder.h> | |
36 | ||
37 | #if defined(CONFIG_OF_LIBFDT) | |
38 | #include <fdt.h> | |
39 | #include <libfdt.h> | |
40 | #include <fdt_support.h> | |
9c67352f WD |
41 | |
42 | #endif | |
43 | ||
44 | #ifdef CONFIG_SYS_INIT_RAM_LOCK | |
45 | #include <asm/cache.h> | |
5d3cc55e MB |
46 | #endif |
47 | ||
5d3cc55e | 48 | DECLARE_GLOBAL_DATA_PTR; |
5d3cc55e | 49 | |
5a98127d | 50 | extern int do_reset (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]); |
e822d7fc | 51 | extern ulong get_effective_memsize(void); |
ceaed2b1 | 52 | static ulong get_sp (void); |
b6b0fe64 | 53 | static void set_clocks_in_mhz (bd_t *kbd); |
5d3cc55e | 54 | |
6d0f6bcf JCPV |
55 | #ifndef CONFIG_SYS_LINUX_LOWMEM_MAX_SIZE |
56 | #define CONFIG_SYS_LINUX_LOWMEM_MAX_SIZE (768*1024*1024) | |
d3f2fa0d KG |
57 | #endif |
58 | ||
5a98127d KG |
59 | static void boot_jump_linux(bootm_headers_t *images) |
60 | { | |
61 | void (*kernel)(bd_t *, ulong r4, ulong r5, ulong r6, | |
62 | ulong r7, ulong r8, ulong r9); | |
63 | #ifdef CONFIG_OF_LIBFDT | |
64 | char *of_flat_tree = images->ft_addr; | |
65 | #endif | |
66 | ||
67 | kernel = (void (*)(bd_t *, ulong, ulong, ulong, | |
68 | ulong, ulong, ulong))images->ep; | |
69 | debug ("## Transferring control to Linux (at address %08lx) ...\n", | |
70 | (ulong)kernel); | |
71 | ||
72 | show_boot_progress (15); | |
73 | ||
9c67352f WD |
74 | #if defined(CONFIG_SYS_INIT_RAM_LOCK) && !defined(CONFIG_E500) |
75 | unlock_ram_in_cache(); | |
76 | #endif | |
77 | ||
5a98127d KG |
78 | #if defined(CONFIG_OF_LIBFDT) |
79 | if (of_flat_tree) { /* device tree; boot new style */ | |
80 | /* | |
81 | * Linux Kernel Parameters (passing device tree): | |
82 | * r3: pointer to the fdt | |
83 | * r4: 0 | |
84 | * r5: 0 | |
85 | * r6: epapr magic | |
86 | * r7: size of IMA in bytes | |
87 | * r8: 0 | |
88 | * r9: 0 | |
89 | */ | |
90 | #if defined(CONFIG_85xx) || defined(CONFIG_440) | |
91 | #define EPAPR_MAGIC (0x45504150) | |
92 | #else | |
93 | #define EPAPR_MAGIC (0x65504150) | |
94 | #endif | |
95 | ||
96 | debug (" Booting using OF flat tree...\n"); | |
7ff66bb0 | 97 | WATCHDOG_RESET (); |
5a98127d KG |
98 | (*kernel) ((bd_t *)of_flat_tree, 0, 0, EPAPR_MAGIC, |
99 | CONFIG_SYS_BOOTMAPSZ, 0, 0); | |
100 | /* does not return */ | |
101 | } else | |
102 | #endif | |
103 | { | |
104 | /* | |
105 | * Linux Kernel Parameters (passing board info data): | |
106 | * r3: ptr to board info data | |
107 | * r4: initrd_start or 0 if no initrd | |
108 | * r5: initrd_end - unused if r4 is 0 | |
109 | * r6: Start of command line string | |
110 | * r7: End of command line string | |
111 | * r8: 0 | |
112 | * r9: 0 | |
113 | */ | |
114 | ulong cmd_start = images->cmdline_start; | |
115 | ulong cmd_end = images->cmdline_end; | |
116 | ulong initrd_start = images->initrd_start; | |
117 | ulong initrd_end = images->initrd_end; | |
118 | bd_t *kbd = images->kbd; | |
119 | ||
120 | debug (" Booting using board info...\n"); | |
7ff66bb0 | 121 | WATCHDOG_RESET (); |
5a98127d KG |
122 | (*kernel) (kbd, initrd_start, initrd_end, |
123 | cmd_start, cmd_end, 0, 0); | |
124 | /* does not return */ | |
125 | } | |
126 | return ; | |
127 | } | |
128 | ||
76da19df | 129 | void arch_lmb_reserve(struct lmb *lmb) |
5d3cc55e | 130 | { |
391fd93a | 131 | phys_size_t bootm_size; |
76da19df | 132 | ulong size, sp, bootmap_base; |
c160a954 | 133 | |
d3f2fa0d | 134 | bootmap_base = getenv_bootm_low(); |
391fd93a | 135 | bootm_size = getenv_bootm_size(); |
d3f2fa0d KG |
136 | |
137 | #ifdef DEBUG | |
391fd93a | 138 | if (((u64)bootmap_base + bootm_size) > |
6d0f6bcf | 139 | (CONFIG_SYS_SDRAM_BASE + (u64)gd->ram_size)) |
d3f2fa0d | 140 | puts("WARNING: bootm_low + bootm_size exceed total memory\n"); |
391fd93a | 141 | if ((bootmap_base + bootm_size) > get_effective_memsize()) |
d3f2fa0d KG |
142 | puts("WARNING: bootm_low + bootm_size exceed eff. memory\n"); |
143 | #endif | |
144 | ||
391fd93a | 145 | size = min(bootm_size, get_effective_memsize()); |
6d0f6bcf | 146 | size = min(size, CONFIG_SYS_LINUX_LOWMEM_MAX_SIZE); |
d3f2fa0d | 147 | |
391fd93a | 148 | if (size < bootm_size) { |
d3f2fa0d | 149 | ulong base = bootmap_base + size; |
dc4b0b38 | 150 | printf("WARNING: adjusting available memory to %lx\n", size); |
391fd93a | 151 | lmb_reserve(lmb, base, bootm_size - size); |
d3f2fa0d | 152 | } |
e822d7fc | 153 | |
5d3cc55e MB |
154 | /* |
155 | * Booting a (Linux) kernel image | |
156 | * | |
157 | * Allocate space for command line and board info - the | |
158 | * address should be as high as possible within the reach of | |
6d0f6bcf | 159 | * the kernel (see CONFIG_SYS_BOOTMAPSZ settings), but in unused |
5d3cc55e MB |
160 | * memory, which means far enough below the current stack |
161 | * pointer. | |
162 | */ | |
b6b0fe64 | 163 | sp = get_sp(); |
d3f2fa0d | 164 | debug ("## Current stack ends at 0x%08lx\n", sp); |
5d3cc55e | 165 | |
e822d7fc KG |
166 | /* adjust sp by 1K to be safe */ |
167 | sp -= 1024; | |
6d0f6bcf | 168 | lmb_reserve(lmb, sp, (CONFIG_SYS_SDRAM_BASE + get_effective_memsize() - sp)); |
5d3cc55e | 169 | |
76da19df KG |
170 | return ; |
171 | } | |
172 | ||
5a98127d | 173 | static void boot_prep_linux(void) |
76da19df | 174 | { |
0e870980 | 175 | #ifdef CONFIG_MP |
5a98127d KG |
176 | /* if we are MP make sure to flush the dcache() to any changes are made |
177 | * visibile to all other cores */ | |
3cbd8231 | 178 | flush_dcache(); |
76da19df | 179 | #endif |
5a98127d KG |
180 | return ; |
181 | } | |
76da19df | 182 | |
5a98127d KG |
183 | static int boot_cmdline_linux(bootm_headers_t *images) |
184 | { | |
185 | ulong bootmap_base = getenv_bootm_low(); | |
186 | ulong of_size = images->ft_len; | |
187 | struct lmb *lmb = &images->lmb; | |
188 | ulong *cmd_start = &images->cmdline_start; | |
189 | ulong *cmd_end = &images->cmdline_end; | |
76da19df | 190 | |
5a98127d | 191 | int ret = 0; |
76da19df | 192 | |
27953493 KG |
193 | if (!of_size) { |
194 | /* allocate space and init command line */ | |
5a98127d | 195 | ret = boot_get_cmdline (lmb, cmd_start, cmd_end, bootmap_base); |
e822d7fc KG |
196 | if (ret) { |
197 | puts("ERROR with allocation of cmdline\n"); | |
5a98127d | 198 | return ret; |
e822d7fc | 199 | } |
5a98127d KG |
200 | } |
201 | ||
202 | return ret; | |
203 | } | |
204 | ||
205 | static int boot_bd_t_linux(bootm_headers_t *images) | |
206 | { | |
207 | ulong bootmap_base = getenv_bootm_low(); | |
208 | ulong of_size = images->ft_len; | |
209 | struct lmb *lmb = &images->lmb; | |
210 | bd_t **kbd = &images->kbd; | |
211 | ||
212 | int ret = 0; | |
27953493 | 213 | |
5a98127d | 214 | if (!of_size) { |
27953493 | 215 | /* allocate space for kernel copy of board info */ |
5a98127d | 216 | ret = boot_get_kbd (lmb, kbd, bootmap_base); |
e822d7fc KG |
217 | if (ret) { |
218 | puts("ERROR with allocation of kernel bd\n"); | |
5a98127d | 219 | return ret; |
e822d7fc | 220 | } |
5a98127d | 221 | set_clocks_in_mhz(*kbd); |
27953493 | 222 | } |
5d3cc55e | 223 | |
5a98127d KG |
224 | return ret; |
225 | } | |
226 | ||
227 | static int boot_body_linux(bootm_headers_t *images) | |
228 | { | |
08293230 | 229 | ulong rd_len; |
5a98127d KG |
230 | struct lmb *lmb = &images->lmb; |
231 | ulong *initrd_start = &images->initrd_start; | |
232 | ulong *initrd_end = &images->initrd_end; | |
233 | #if defined(CONFIG_OF_LIBFDT) | |
08293230 PT |
234 | ulong bootmap_base = getenv_bootm_low(); |
235 | ulong of_size = images->ft_len; | |
5a98127d KG |
236 | char **of_flat_tree = &images->ft_addr; |
237 | #endif | |
238 | ||
239 | int ret; | |
240 | ||
241 | /* allocate space and init command line */ | |
242 | ret = boot_cmdline_linux(images); | |
243 | if (ret) | |
244 | return ret; | |
245 | ||
246 | /* allocate space for kernel copy of board info */ | |
247 | ret = boot_bd_t_linux(images); | |
248 | if (ret) | |
249 | return ret; | |
250 | ||
c4f9419c | 251 | rd_len = images->rd_end - images->rd_start; |
5a98127d KG |
252 | ret = boot_ramdisk_high (lmb, images->rd_start, rd_len, initrd_start, initrd_end); |
253 | if (ret) | |
254 | return ret; | |
5d3cc55e | 255 | |
4a2ad5ff | 256 | #if defined(CONFIG_OF_LIBFDT) |
5a98127d | 257 | ret = boot_relocate_fdt(lmb, bootmap_base, of_flat_tree, &of_size); |
06a09918 | 258 | if (ret) |
5a98127d | 259 | return ret; |
5d3cc55e | 260 | |
5d3cc55e MB |
261 | /* |
262 | * Add the chosen node if it doesn't exist, add the env and bd_t | |
263 | * if the user wants it (the logic is in the subroutines). | |
264 | */ | |
d2ced9eb | 265 | if (of_size) { |
5a98127d | 266 | if (fdt_chosen(*of_flat_tree, 1) < 0) { |
06a09918 KG |
267 | puts ("ERROR: "); |
268 | puts ("/chosen node create failed"); | |
269 | puts (" - must RESET the board to recover.\n"); | |
5a98127d | 270 | return -1; |
5d3cc55e | 271 | } |
5d3cc55e MB |
272 | #ifdef CONFIG_OF_BOARD_SETUP |
273 | /* Call the board-specific fixup routine */ | |
5a98127d | 274 | ft_board_setup(*of_flat_tree, gd->bd); |
5d3cc55e | 275 | #endif |
41c5eaa7 | 276 | |
41c5eaa7 | 277 | /* Delete the old LMB reservation */ |
5a98127d KG |
278 | lmb_free(lmb, (phys_addr_t)(u32)*of_flat_tree, |
279 | (phys_size_t)fdt_totalsize(*of_flat_tree)); | |
41c5eaa7 | 280 | |
5a98127d | 281 | ret = fdt_resize(*of_flat_tree); |
3082d234 | 282 | if (ret < 0) |
5a98127d | 283 | return ret; |
3082d234 | 284 | of_size = ret; |
41c5eaa7 | 285 | |
5a98127d | 286 | if (*initrd_start && *initrd_end) |
56844a22 | 287 | of_size += FDT_RAMDISK_OVERHEAD; |
41c5eaa7 | 288 | /* Create a new LMB reservation */ |
5a98127d KG |
289 | lmb_reserve(lmb, (ulong)*of_flat_tree, of_size); |
290 | ||
291 | /* fixup the initrd now that we know where it should be */ | |
292 | if (*initrd_start && *initrd_end) | |
293 | fdt_initrd(*of_flat_tree, *initrd_start, *initrd_end, 1); | |
41c5eaa7 | 294 | } |
4a2ad5ff | 295 | #endif /* CONFIG_OF_LIBFDT */ |
5a98127d KG |
296 | return 0; |
297 | } | |
d45d5a18 | 298 | |
5a98127d KG |
299 | __attribute__((noinline)) |
300 | int do_bootm_linux(int flag, int argc, char *argv[], bootm_headers_t *images) | |
301 | { | |
302 | int ret; | |
5d3cc55e | 303 | |
5a98127d KG |
304 | if (flag & BOOTM_STATE_OS_CMDLINE) { |
305 | boot_cmdline_linux(images); | |
306 | return 0; | |
307 | } | |
5d3cc55e | 308 | |
5a98127d KG |
309 | if (flag & BOOTM_STATE_OS_BD_T) { |
310 | boot_bd_t_linux(images); | |
311 | return 0; | |
312 | } | |
5d3cc55e | 313 | |
5a98127d KG |
314 | if (flag & BOOTM_STATE_OS_PREP) { |
315 | boot_prep_linux(); | |
316 | return 0; | |
317 | } | |
a15b0710 | 318 | |
5a98127d KG |
319 | if (flag & BOOTM_STATE_OS_GO) { |
320 | boot_jump_linux(images); | |
321 | return 0; | |
bc8ed486 | 322 | } |
274cea2b | 323 | |
5a98127d KG |
324 | boot_prep_linux(); |
325 | ret = boot_body_linux(images); | |
326 | if (ret) | |
327 | return ret; | |
328 | boot_jump_linux(images); | |
329 | ||
330 | return 0; | |
5d3cc55e | 331 | } |
d3c5eb6d | 332 | |
ceaed2b1 MB |
333 | static ulong get_sp (void) |
334 | { | |
335 | ulong sp; | |
336 | ||
337 | asm( "mr %0,1": "=r"(sp) : ); | |
338 | return sp; | |
339 | } | |
340 | ||
b6b0fe64 MB |
341 | static void set_clocks_in_mhz (bd_t *kbd) |
342 | { | |
343 | char *s; | |
344 | ||
345 | if ((s = getenv ("clocks_in_mhz")) != NULL) { | |
346 | /* convert all clock information to MHz */ | |
347 | kbd->bi_intfreq /= 1000000L; | |
348 | kbd->bi_busfreq /= 1000000L; | |
349 | #if defined(CONFIG_MPC8220) | |
350 | kbd->bi_inpfreq /= 1000000L; | |
351 | kbd->bi_pcifreq /= 1000000L; | |
352 | kbd->bi_pevfreq /= 1000000L; | |
353 | kbd->bi_flbfreq /= 1000000L; | |
354 | kbd->bi_vcofreq /= 1000000L; | |
355 | #endif | |
356 | #if defined(CONFIG_CPM2) | |
357 | kbd->bi_cpmfreq /= 1000000L; | |
358 | kbd->bi_brgfreq /= 1000000L; | |
359 | kbd->bi_sccfreq /= 1000000L; | |
438a4c11 | 360 | kbd->bi_vco /= 1000000L; |
b6b0fe64 MB |
361 | #endif |
362 | #if defined(CONFIG_MPC5xxx) | |
363 | kbd->bi_ipbfreq /= 1000000L; | |
364 | kbd->bi_pcifreq /= 1000000L; | |
365 | #endif /* CONFIG_MPC5xxx */ | |
366 | } | |
367 | } |