]>
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> | |
32 | #include <zlib.h> | |
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> | |
d3c5eb6d MB |
41 | |
42 | static void fdt_error (const char *msg); | |
9a4daad0 | 43 | static int boot_get_fdt (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[], |
d2ced9eb | 44 | bootm_headers_t *images, char **of_flat_tree, ulong *of_size); |
9a4daad0 | 45 | static int boot_relocate_fdt (struct lmb *lmb, ulong bootmap_base, |
d2ced9eb MB |
46 | cmd_tbl_t *cmdtp, int flag, int argc, char *argv[], |
47 | char **of_flat_tree, ulong *of_size); | |
5d3cc55e MB |
48 | #endif |
49 | ||
5d3cc55e MB |
50 | #ifdef CFG_INIT_RAM_LOCK |
51 | #include <asm/cache.h> | |
52 | #endif | |
53 | ||
5d3cc55e | 54 | DECLARE_GLOBAL_DATA_PTR; |
5d3cc55e | 55 | |
5d3cc55e | 56 | extern int do_reset (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]); |
e822d7fc | 57 | extern ulong get_effective_memsize(void); |
ceaed2b1 | 58 | static ulong get_sp (void); |
b6b0fe64 | 59 | static void set_clocks_in_mhz (bd_t *kbd); |
5d3cc55e | 60 | |
d3f2fa0d KG |
61 | #ifndef CFG_LINUX_LOWMEM_MAX_SIZE |
62 | #define CFG_LINUX_LOWMEM_MAX_SIZE (768*1024*1024) | |
63 | #endif | |
64 | ||
5d3cc55e | 65 | void __attribute__((noinline)) |
8a5ea3e6 MB |
66 | do_bootm_linux(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[], |
67 | bootm_headers_t *images) | |
5d3cc55e | 68 | { |
e822d7fc | 69 | ulong sp; |
b6b0fe64 | 70 | |
f13e7b2e | 71 | ulong initrd_start, initrd_end; |
5ad03eb3 | 72 | ulong rd_data_start, rd_data_end, rd_len; |
d3f2fa0d | 73 | ulong size; |
f13e7b2e | 74 | |
e822d7fc | 75 | ulong cmd_start, cmd_end, bootmap_base; |
5d3cc55e | 76 | bd_t *kbd; |
d5934ad7 | 77 | ulong ep = 0; |
5d3cc55e | 78 | void (*kernel)(bd_t *, ulong, ulong, ulong, ulong); |
d2bc095a | 79 | int ret; |
27953493 | 80 | ulong of_size = 0; |
e822d7fc | 81 | struct lmb *lmb = images->lmb; |
f13e7b2e | 82 | |
4a2ad5ff | 83 | #if defined(CONFIG_OF_LIBFDT) |
d2ced9eb | 84 | char *of_flat_tree = NULL; |
5d3cc55e MB |
85 | #endif |
86 | ||
d3f2fa0d KG |
87 | bootmap_base = getenv_bootm_low(); |
88 | size = getenv_bootm_size(); | |
89 | ||
90 | #ifdef DEBUG | |
91 | if (((u64)bootmap_base + size) > (CFG_SDRAM_BASE + (u64)gd->ram_size)) | |
92 | puts("WARNING: bootm_low + bootm_size exceed total memory\n"); | |
93 | if ((bootmap_base + size) > get_effective_memsize()) | |
94 | puts("WARNING: bootm_low + bootm_size exceed eff. memory\n"); | |
95 | #endif | |
96 | ||
97 | size = min(size, get_effective_memsize()); | |
98 | size = min(size, CFG_LINUX_LOWMEM_MAX_SIZE); | |
99 | ||
100 | if (size < getenv_bootm_size()) { | |
101 | ulong base = bootmap_base + size; | |
102 | printf("WARNING: adjusting available memory to %x\n", size); | |
103 | lmb_reserve(lmb, base, getenv_bootm_size() - size); | |
104 | } | |
e822d7fc | 105 | |
5d3cc55e MB |
106 | /* |
107 | * Booting a (Linux) kernel image | |
108 | * | |
109 | * Allocate space for command line and board info - the | |
110 | * address should be as high as possible within the reach of | |
111 | * the kernel (see CFG_BOOTMAPSZ settings), but in unused | |
112 | * memory, which means far enough below the current stack | |
113 | * pointer. | |
114 | */ | |
b6b0fe64 | 115 | sp = get_sp(); |
d3f2fa0d | 116 | debug ("## Current stack ends at 0x%08lx\n", sp); |
5d3cc55e | 117 | |
e822d7fc KG |
118 | /* adjust sp by 1K to be safe */ |
119 | sp -= 1024; | |
120 | lmb_reserve(lmb, sp, (CFG_SDRAM_BASE + get_effective_memsize() - sp)); | |
5d3cc55e | 121 | |
27953493 KG |
122 | #if defined(CONFIG_OF_LIBFDT) |
123 | /* find flattened device tree */ | |
9a4daad0 | 124 | ret = boot_get_fdt (cmdtp, flag, argc, argv, images, &of_flat_tree, &of_size); |
274cea2b KG |
125 | |
126 | if (ret) | |
127 | goto error; | |
27953493 | 128 | #endif |
5d3cc55e | 129 | |
27953493 KG |
130 | if (!of_size) { |
131 | /* allocate space and init command line */ | |
9a4daad0 | 132 | ret = boot_get_cmdline (lmb, &cmd_start, &cmd_end, bootmap_base); |
e822d7fc KG |
133 | if (ret) { |
134 | puts("ERROR with allocation of cmdline\n"); | |
135 | goto error; | |
136 | } | |
27953493 KG |
137 | |
138 | /* allocate space for kernel copy of board info */ | |
9a4daad0 | 139 | ret = boot_get_kbd (lmb, &kbd, bootmap_base); |
e822d7fc KG |
140 | if (ret) { |
141 | puts("ERROR with allocation of kernel bd\n"); | |
142 | goto error; | |
143 | } | |
27953493 KG |
144 | set_clocks_in_mhz(kbd); |
145 | } | |
5d3cc55e | 146 | |
d5934ad7 MB |
147 | /* find kernel entry point */ |
148 | if (images->legacy_hdr_valid) { | |
149 | ep = image_get_ep (images->legacy_hdr_os); | |
150 | #if defined(CONFIG_FIT) | |
151 | } else if (images->fit_uname_os) { | |
cd7c596e MB |
152 | ret = fit_image_get_entry (images->fit_hdr_os, |
153 | images->fit_noffset_os, &ep); | |
154 | if (ret) { | |
155 | puts ("Can't get entry point property!\n"); | |
156 | goto error; | |
157 | } | |
d5934ad7 MB |
158 | #endif |
159 | } else { | |
160 | puts ("Could not find kernel entry point!\n"); | |
274cea2b | 161 | goto error; |
d5934ad7 MB |
162 | } |
163 | kernel = (void (*)(bd_t *, ulong, ulong, ulong, ulong))ep; | |
5d3cc55e | 164 | |
ceaed2b1 | 165 | /* find ramdisk */ |
d985c849 MB |
166 | ret = boot_get_ramdisk (argc, argv, images, IH_ARCH_PPC, |
167 | &rd_data_start, &rd_data_end); | |
274cea2b KG |
168 | if (ret) |
169 | goto error; | |
170 | ||
5ad03eb3 | 171 | rd_len = rd_data_end - rd_data_start; |
5d3cc55e | 172 | |
4a2ad5ff | 173 | #if defined(CONFIG_OF_LIBFDT) |
9a4daad0 | 174 | ret = boot_relocate_fdt (lmb, bootmap_base, |
e822d7fc | 175 | cmdtp, flag, argc, argv, &of_flat_tree, &of_size); |
5d3cc55e | 176 | |
5d3cc55e MB |
177 | /* |
178 | * Add the chosen node if it doesn't exist, add the env and bd_t | |
179 | * if the user wants it (the logic is in the subroutines). | |
180 | */ | |
d2ced9eb | 181 | if (of_size) { |
d2bc095a KG |
182 | /* pass in dummy initrd info, we'll fix up later */ |
183 | if (fdt_chosen(of_flat_tree, rd_data_start, rd_data_end, 0) < 0) { | |
d3c5eb6d | 184 | fdt_error ("/chosen node create failed"); |
274cea2b | 185 | goto error; |
5d3cc55e MB |
186 | } |
187 | #ifdef CONFIG_OF_HAS_UBOOT_ENV | |
188 | if (fdt_env(of_flat_tree) < 0) { | |
d3c5eb6d | 189 | fdt_error ("/u-boot-env node create failed"); |
274cea2b | 190 | goto error; |
5d3cc55e MB |
191 | } |
192 | #endif | |
193 | #ifdef CONFIG_OF_HAS_BD_T | |
194 | if (fdt_bd_t(of_flat_tree) < 0) { | |
d3c5eb6d | 195 | fdt_error ("/bd_t node create failed"); |
274cea2b | 196 | goto error; |
5d3cc55e MB |
197 | } |
198 | #endif | |
199 | #ifdef CONFIG_OF_BOARD_SETUP | |
200 | /* Call the board-specific fixup routine */ | |
201 | ft_board_setup(of_flat_tree, gd->bd); | |
202 | #endif | |
203 | } | |
4a2ad5ff | 204 | #endif /* CONFIG_OF_LIBFDT */ |
d45d5a18 | 205 | |
9a4daad0 | 206 | ret = boot_ramdisk_high (lmb, rd_data_start, rd_len, &initrd_start, &initrd_end); |
e822d7fc KG |
207 | if (ret) |
208 | goto error; | |
d2bc095a KG |
209 | |
210 | #if defined(CONFIG_OF_LIBFDT) | |
211 | /* fixup the initrd now that we know where it should be */ | |
212 | if ((of_flat_tree) && (initrd_start && initrd_end)) { | |
213 | uint64_t addr, size; | |
214 | int total = fdt_num_mem_rsv(of_flat_tree); | |
215 | int j; | |
216 | ||
217 | /* Look for the dummy entry and delete it */ | |
218 | for (j = 0; j < total; j++) { | |
219 | fdt_get_mem_rsv(of_flat_tree, j, &addr, &size); | |
220 | if (addr == rd_data_start) { | |
221 | fdt_del_mem_rsv(of_flat_tree, j); | |
222 | break; | |
223 | } | |
224 | } | |
225 | ||
226 | ret = fdt_add_mem_rsv(of_flat_tree, initrd_start, | |
227 | initrd_end - initrd_start + 1); | |
228 | if (ret < 0) { | |
229 | printf("fdt_chosen: %s\n", fdt_strerror(ret)); | |
274cea2b | 230 | goto error; |
d2bc095a KG |
231 | } |
232 | ||
233 | do_fixup_by_path_u32(of_flat_tree, "/chosen", | |
234 | "linux,initrd-start", initrd_start, 0); | |
235 | do_fixup_by_path_u32(of_flat_tree, "/chosen", | |
236 | "linux,initrd-end", initrd_end, 0); | |
237 | } | |
238 | #endif | |
5d3cc55e MB |
239 | debug ("## Transferring control to Linux (at address %08lx) ...\n", |
240 | (ulong)kernel); | |
241 | ||
242 | show_boot_progress (15); | |
243 | ||
244 | #if defined(CFG_INIT_RAM_LOCK) && !defined(CONFIG_E500) | |
245 | unlock_ram_in_cache(); | |
246 | #endif | |
75fa002c KG |
247 | if (!images->autostart) |
248 | return ; | |
5d3cc55e | 249 | |
4a2ad5ff | 250 | #if defined(CONFIG_OF_LIBFDT) |
5d3cc55e MB |
251 | if (of_flat_tree) { /* device tree; boot new style */ |
252 | /* | |
253 | * Linux Kernel Parameters (passing device tree): | |
254 | * r3: pointer to the fdt, followed by the board info data | |
255 | * r4: physical pointer to the kernel itself | |
256 | * r5: NULL | |
257 | * r6: NULL | |
258 | * r7: NULL | |
259 | */ | |
bc8ed486 | 260 | debug (" Booting using OF flat tree...\n"); |
5d3cc55e MB |
261 | (*kernel) ((bd_t *)of_flat_tree, (ulong)kernel, 0, 0, 0); |
262 | /* does not return */ | |
bc8ed486 | 263 | } else |
5d3cc55e | 264 | #endif |
bc8ed486 MB |
265 | { |
266 | /* | |
267 | * Linux Kernel Parameters (passing board info data): | |
268 | * r3: ptr to board info data | |
269 | * r4: initrd_start or 0 if no initrd | |
270 | * r5: initrd_end - unused if r4 is 0 | |
271 | * r6: Start of command line string | |
272 | * r7: End of command line string | |
273 | */ | |
274 | debug (" Booting using board info...\n"); | |
275 | (*kernel) (kbd, initrd_start, initrd_end, cmd_start, cmd_end); | |
276 | /* does not return */ | |
277 | } | |
274cea2b KG |
278 | return ; |
279 | ||
280 | error: | |
75fa002c KG |
281 | if (images->autostart) |
282 | do_reset (cmdtp, flag, argc, argv); | |
274cea2b | 283 | return ; |
5d3cc55e | 284 | } |
d3c5eb6d | 285 | |
ceaed2b1 MB |
286 | static ulong get_sp (void) |
287 | { | |
288 | ulong sp; | |
289 | ||
290 | asm( "mr %0,1": "=r"(sp) : ); | |
291 | return sp; | |
292 | } | |
293 | ||
b6b0fe64 MB |
294 | static void set_clocks_in_mhz (bd_t *kbd) |
295 | { | |
296 | char *s; | |
297 | ||
298 | if ((s = getenv ("clocks_in_mhz")) != NULL) { | |
299 | /* convert all clock information to MHz */ | |
300 | kbd->bi_intfreq /= 1000000L; | |
301 | kbd->bi_busfreq /= 1000000L; | |
302 | #if defined(CONFIG_MPC8220) | |
303 | kbd->bi_inpfreq /= 1000000L; | |
304 | kbd->bi_pcifreq /= 1000000L; | |
305 | kbd->bi_pevfreq /= 1000000L; | |
306 | kbd->bi_flbfreq /= 1000000L; | |
307 | kbd->bi_vcofreq /= 1000000L; | |
308 | #endif | |
309 | #if defined(CONFIG_CPM2) | |
310 | kbd->bi_cpmfreq /= 1000000L; | |
311 | kbd->bi_brgfreq /= 1000000L; | |
312 | kbd->bi_sccfreq /= 1000000L; | |
438a4c11 | 313 | kbd->bi_vco /= 1000000L; |
b6b0fe64 MB |
314 | #endif |
315 | #if defined(CONFIG_MPC5xxx) | |
316 | kbd->bi_ipbfreq /= 1000000L; | |
317 | kbd->bi_pcifreq /= 1000000L; | |
318 | #endif /* CONFIG_MPC5xxx */ | |
319 | } | |
320 | } | |
321 | ||
d3c5eb6d MB |
322 | #if defined(CONFIG_OF_LIBFDT) |
323 | static void fdt_error (const char *msg) | |
324 | { | |
325 | puts ("ERROR: "); | |
326 | puts (msg); | |
327 | puts (" - must RESET the board to recover.\n"); | |
328 | } | |
7b325454 | 329 | |
ff0734cf MB |
330 | static image_header_t *image_get_fdt (ulong fdt_addr) |
331 | { | |
332 | image_header_t *fdt_hdr = (image_header_t *)fdt_addr; | |
333 | ||
334 | image_print_contents (fdt_hdr); | |
335 | ||
336 | puts (" Verifying Checksum ... "); | |
337 | if (!image_check_hcrc (fdt_hdr)) { | |
338 | fdt_error ("fdt header checksum invalid"); | |
339 | return NULL; | |
340 | } | |
341 | ||
342 | if (!image_check_dcrc (fdt_hdr)) { | |
343 | fdt_error ("fdt checksum invalid"); | |
344 | return NULL; | |
345 | } | |
346 | puts ("OK\n"); | |
347 | ||
348 | if (!image_check_type (fdt_hdr, IH_TYPE_FLATDT)) { | |
349 | fdt_error ("uImage is not a fdt"); | |
350 | return NULL; | |
351 | } | |
352 | if (image_get_comp (fdt_hdr) != IH_COMP_NONE) { | |
353 | fdt_error ("uImage is compressed"); | |
354 | return NULL; | |
355 | } | |
356 | if (fdt_check_header ((char *)image_get_data (fdt_hdr)) != 0) { | |
357 | fdt_error ("uImage data is not a fdt"); | |
358 | return NULL; | |
359 | } | |
360 | return fdt_hdr; | |
361 | } | |
362 | ||
bc8ed486 MB |
363 | /** |
364 | * fit_check_fdt - verify FIT format FDT subimage | |
365 | * @fit_hdr: pointer to the FIT header | |
366 | * fdt_noffset: FDT subimage node offset within FIT image | |
367 | * @verify: data CRC verification flag | |
368 | * | |
369 | * fit_check_fdt() verifies integrity of the FDT subimage and from | |
370 | * specified FIT image. | |
371 | * | |
372 | * returns: | |
373 | * 1, on success | |
374 | * 0, on failure | |
375 | */ | |
376 | #if defined(CONFIG_FIT) | |
377 | static int fit_check_fdt (const void *fit, int fdt_noffset, int verify) | |
378 | { | |
379 | fit_image_print (fit, fdt_noffset, " "); | |
380 | ||
381 | if (verify) { | |
382 | puts (" Verifying Hash Integrity ... "); | |
383 | if (!fit_image_check_hashes (fit, fdt_noffset)) { | |
384 | fdt_error ("Bad Data Hash"); | |
385 | return 0; | |
386 | } | |
387 | puts ("OK\n"); | |
388 | } | |
389 | ||
390 | if (!fit_image_check_type (fit, fdt_noffset, IH_TYPE_FLATDT)) { | |
391 | fdt_error ("Not a FDT image"); | |
392 | return 0; | |
393 | } | |
394 | ||
395 | if (!fit_image_check_comp (fit, fdt_noffset, IH_COMP_NONE)) { | |
396 | fdt_error ("FDT image is compressed"); | |
397 | return 0; | |
398 | } | |
399 | ||
400 | return 1; | |
401 | } | |
402 | #endif /* CONFIG_FIT */ | |
403 | ||
9a4daad0 | 404 | static int boot_get_fdt (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[], |
d2ced9eb | 405 | bootm_headers_t *images, char **of_flat_tree, ulong *of_size) |
7b325454 | 406 | { |
d5934ad7 | 407 | ulong fdt_addr; |
7b325454 | 408 | image_header_t *fdt_hdr; |
d5934ad7 | 409 | char *fdt_blob = NULL; |
d5934ad7 MB |
410 | ulong image_start, image_end; |
411 | ulong load_start, load_end; | |
412 | #if defined(CONFIG_FIT) | |
438a4c11 WD |
413 | void *fit_hdr; |
414 | const char *fit_uname_config = NULL; | |
415 | const char *fit_uname_fdt = NULL; | |
d5934ad7 | 416 | ulong default_addr; |
f773bea8 | 417 | int cfg_noffset; |
bc8ed486 MB |
418 | int fdt_noffset; |
419 | const void *data; | |
420 | size_t size; | |
d5934ad7 | 421 | #endif |
7b325454 | 422 | |
bc8ed486 MB |
423 | *of_flat_tree = NULL; |
424 | *of_size = 0; | |
425 | ||
f773bea8 | 426 | if (argc > 3 || genimg_has_config (images)) { |
d5934ad7 | 427 | #if defined(CONFIG_FIT) |
f773bea8 MB |
428 | if (argc > 3) { |
429 | /* | |
430 | * If the FDT blob comes from the FIT image and the | |
431 | * FIT image address is omitted in the command line | |
432 | * argument, try to use ramdisk or os FIT image | |
433 | * address or default load address. | |
434 | */ | |
435 | if (images->fit_uname_rd) | |
436 | default_addr = (ulong)images->fit_hdr_rd; | |
437 | else if (images->fit_uname_os) | |
438 | default_addr = (ulong)images->fit_hdr_os; | |
439 | else | |
440 | default_addr = load_addr; | |
441 | ||
442 | if (fit_parse_conf (argv[3], default_addr, | |
443 | &fdt_addr, &fit_uname_config)) { | |
444 | debug ("* fdt: config '%s' from image at 0x%08lx\n", | |
445 | fit_uname_config, fdt_addr); | |
446 | } else if (fit_parse_subimage (argv[3], default_addr, | |
447 | &fdt_addr, &fit_uname_fdt)) { | |
448 | debug ("* fdt: subimage '%s' from image at 0x%08lx\n", | |
449 | fit_uname_fdt, fdt_addr); | |
450 | } else | |
d5934ad7 | 451 | #endif |
f773bea8 MB |
452 | { |
453 | fdt_addr = simple_strtoul(argv[3], NULL, 16); | |
454 | debug ("* fdt: cmdline image address = 0x%08lx\n", | |
455 | fdt_addr); | |
456 | } | |
457 | #if defined(CONFIG_FIT) | |
458 | } else { | |
459 | /* use FIT configuration provided in first bootm | |
460 | * command argument | |
461 | */ | |
462 | fdt_addr = (ulong)images->fit_hdr_os; | |
463 | fit_uname_config = images->fit_uname_cfg; | |
464 | debug ("* fdt: using config '%s' from image at 0x%08lx\n", | |
465 | fit_uname_config, fdt_addr); | |
466 | ||
467 | /* | |
468 | * Check whether configuration has FDT blob defined, | |
469 | * if not quit silently. | |
470 | */ | |
471 | fit_hdr = (void *)fdt_addr; | |
472 | cfg_noffset = fit_conf_get_node (fit_hdr, | |
473 | fit_uname_config); | |
474 | if (cfg_noffset < 0) { | |
475 | debug ("* fdt: no such config\n"); | |
476 | return 0; | |
477 | } | |
478 | ||
479 | fdt_noffset = fit_conf_get_fdt_node (fit_hdr, | |
480 | cfg_noffset); | |
481 | if (fdt_noffset < 0) { | |
482 | debug ("* fdt: no fdt in config\n"); | |
483 | return 0; | |
484 | } | |
d5934ad7 | 485 | } |
f773bea8 | 486 | #endif |
fff888a1 | 487 | |
bc8ed486 | 488 | debug ("## Checking for 'FDT'/'FDT Image' at %08lx\n", |
d5934ad7 | 489 | fdt_addr); |
fff888a1 MB |
490 | |
491 | /* copy from dataflash if needed */ | |
9a4daad0 | 492 | fdt_addr = genimg_get_image (fdt_addr); |
7b325454 | 493 | |
d5934ad7 MB |
494 | /* |
495 | * Check if there is an FDT image at the | |
496 | * address provided in the second bootm argument | |
497 | * check image type, for FIT images get a FIT node. | |
498 | */ | |
9a4daad0 | 499 | switch (genimg_get_format ((void *)fdt_addr)) { |
d5934ad7 | 500 | case IMAGE_FORMAT_LEGACY: |
ff0734cf | 501 | /* verify fdt_addr points to a valid image header */ |
bc8ed486 | 502 | printf ("## Flattened Device Tree from Legacy Image at %08lx\n", |
ff0734cf MB |
503 | fdt_addr); |
504 | fdt_hdr = image_get_fdt (fdt_addr); | |
505 | if (!fdt_hdr) | |
274cea2b | 506 | goto error; |
7b325454 | 507 | |
ff0734cf MB |
508 | /* |
509 | * move image data to the load address, | |
510 | * make sure we don't overwrite initial image | |
511 | */ | |
7b325454 MB |
512 | image_start = (ulong)fdt_hdr; |
513 | image_end = image_get_image_end (fdt_hdr); | |
514 | ||
515 | load_start = image_get_load (fdt_hdr); | |
516 | load_end = load_start + image_get_data_size (fdt_hdr); | |
517 | ||
518 | if ((load_start < image_end) && (load_end > image_start)) { | |
519 | fdt_error ("fdt overwritten"); | |
274cea2b | 520 | goto error; |
7b325454 | 521 | } |
bc8ed486 MB |
522 | |
523 | debug (" Loading FDT from 0x%08lx to 0x%08lx\n", | |
524 | image_get_data (fdt_hdr), load_start); | |
525 | ||
526 | memmove ((void *)load_start, | |
ff0734cf MB |
527 | (void *)image_get_data (fdt_hdr), |
528 | image_get_data_size (fdt_hdr)); | |
7b325454 | 529 | |
bc8ed486 | 530 | fdt_blob = (char *)load_start; |
d5934ad7 | 531 | break; |
d5934ad7 | 532 | case IMAGE_FORMAT_FIT: |
4efbe9db MB |
533 | /* |
534 | * This case will catch both: new uImage format | |
535 | * (libfdt based) and raw FDT blob (also libfdt | |
536 | * based). | |
537 | */ | |
538 | #if defined(CONFIG_FIT) | |
539 | /* check FDT blob vs FIT blob */ | |
bc8ed486 | 540 | if (fit_check_format ((const void *)fdt_addr)) { |
d5934ad7 MB |
541 | /* |
542 | * FIT image | |
543 | */ | |
544 | fit_hdr = (void *)fdt_addr; | |
bc8ed486 MB |
545 | printf ("## Flattened Device Tree from FIT Image at %08lx\n", |
546 | fdt_addr); | |
547 | ||
548 | if (!fit_uname_fdt) { | |
549 | /* | |
550 | * no FDT blob image node unit name, | |
551 | * try to get config node first. If | |
552 | * config unit node name is NULL | |
553 | * fit_conf_get_node() will try to | |
554 | * find default config node | |
555 | */ | |
f773bea8 | 556 | cfg_noffset = fit_conf_get_node (fit_hdr, |
bc8ed486 | 557 | fit_uname_config); |
f773bea8 MB |
558 | |
559 | if (cfg_noffset < 0) { | |
560 | fdt_error ("Could not find configuration node\n"); | |
bc8ed486 | 561 | goto error; |
f773bea8 MB |
562 | } |
563 | ||
564 | fit_uname_config = fdt_get_name (fit_hdr, | |
565 | cfg_noffset, NULL); | |
566 | printf (" Using '%s' configuration\n", | |
567 | fit_uname_config); | |
bc8ed486 MB |
568 | |
569 | fdt_noffset = fit_conf_get_fdt_node (fit_hdr, | |
f773bea8 | 570 | cfg_noffset); |
bc8ed486 MB |
571 | fit_uname_fdt = fit_get_name (fit_hdr, |
572 | fdt_noffset, NULL); | |
573 | } else { | |
574 | /* get FDT component image node offset */ | |
575 | fdt_noffset = fit_image_get_node (fit_hdr, | |
576 | fit_uname_fdt); | |
577 | } | |
f773bea8 MB |
578 | if (fdt_noffset < 0) { |
579 | fdt_error ("Could not find subimage node\n"); | |
bc8ed486 | 580 | goto error; |
f773bea8 | 581 | } |
bc8ed486 MB |
582 | |
583 | printf (" Trying '%s' FDT blob subimage\n", | |
584 | fit_uname_fdt); | |
585 | ||
586 | if (!fit_check_fdt (fit_hdr, fdt_noffset, | |
587 | images->verify)) | |
588 | goto error; | |
589 | ||
590 | /* get ramdisk image data address and length */ | |
591 | if (fit_image_get_data (fit_hdr, fdt_noffset, | |
592 | &data, &size)) { | |
593 | fdt_error ("Could not find FDT subimage data"); | |
594 | goto error; | |
595 | } | |
596 | ||
597 | /* verift that image data is a proper FDT blob */ | |
598 | if (fdt_check_header ((char *)data) != 0) { | |
599 | fdt_error ("Subimage data is not a FTD"); | |
600 | goto error; | |
601 | } | |
602 | ||
603 | /* | |
604 | * move image data to the load address, | |
605 | * make sure we don't overwrite initial image | |
606 | */ | |
607 | image_start = (ulong)fit_hdr; | |
608 | image_end = fit_get_end (fit_hdr); | |
609 | ||
610 | if (fit_image_get_load (fit_hdr, fdt_noffset, | |
611 | &load_start) == 0) { | |
612 | load_end = load_start + size; | |
613 | ||
614 | if ((load_start < image_end) && | |
615 | (load_end > image_start)) { | |
616 | fdt_error ("FDT overwritten"); | |
617 | goto error; | |
618 | } | |
619 | ||
620 | printf (" Loading FDT from 0x%08lx to 0x%08lx\n", | |
621 | (ulong)data, load_start); | |
622 | ||
623 | memmove ((void *)load_start, | |
624 | (void *)data, size); | |
625 | ||
626 | fdt_blob = (char *)load_start; | |
627 | } else { | |
628 | fdt_blob = (char *)data; | |
629 | } | |
630 | ||
631 | images->fit_hdr_fdt = fit_hdr; | |
632 | images->fit_uname_fdt = fit_uname_fdt; | |
3dfe1101 | 633 | images->fit_noffset_fdt = fdt_noffset; |
bc8ed486 | 634 | break; |
4efbe9db MB |
635 | } else |
636 | #endif | |
637 | { | |
d5934ad7 MB |
638 | /* |
639 | * FDT blob | |
640 | */ | |
4efbe9db | 641 | debug ("* fdt: raw FDT blob\n"); |
d5934ad7 MB |
642 | printf ("## Flattened Device Tree blob at %08lx\n", fdt_blob); |
643 | fdt_blob = (char *)fdt_addr; | |
644 | } | |
645 | break; | |
d5934ad7 MB |
646 | default: |
647 | fdt_error ("Did not find a cmdline Flattened Device Tree"); | |
274cea2b | 648 | goto error; |
7b325454 | 649 | } |
d5934ad7 MB |
650 | |
651 | printf (" Booting using the fdt blob at 0x%x\n", fdt_blob); | |
652 | ||
653 | } else if (images->legacy_hdr_valid && | |
654 | image_check_type (images->legacy_hdr_os, IH_TYPE_MULTI)) { | |
655 | ||
7b325454 MB |
656 | ulong fdt_data, fdt_len; |
657 | ||
d5934ad7 MB |
658 | /* |
659 | * Now check if we have a legacy multi-component image, | |
660 | * get second entry data start address and len. | |
661 | */ | |
7b325454 | 662 | printf ("## Flattened Device Tree from multi " |
d5934ad7 MB |
663 | "component Image at %08lX\n", |
664 | (ulong)images->legacy_hdr_os); | |
7b325454 | 665 | |
d5934ad7 | 666 | image_multi_getimg (images->legacy_hdr_os, 2, &fdt_data, &fdt_len); |
7b325454 MB |
667 | if (fdt_len) { |
668 | ||
d5934ad7 MB |
669 | fdt_blob = (char *)fdt_data; |
670 | printf (" Booting using the fdt at 0x%x\n", fdt_blob); | |
7b325454 | 671 | |
d5934ad7 | 672 | if (fdt_check_header (fdt_blob) != 0) { |
7b325454 | 673 | fdt_error ("image is not a fdt"); |
274cea2b | 674 | goto error; |
7b325454 MB |
675 | } |
676 | ||
d5934ad7 | 677 | if (be32_to_cpu (fdt_totalsize (fdt_blob)) != fdt_len) { |
7b325454 | 678 | fdt_error ("fdt size != image size"); |
274cea2b | 679 | goto error; |
7b325454 MB |
680 | } |
681 | } else { | |
d5934ad7 MB |
682 | fdt_error ("Did not find a Flattened Device Tree " |
683 | "in a legacy multi-component image"); | |
274cea2b | 684 | goto error; |
7b325454 | 685 | } |
d5934ad7 MB |
686 | } else { |
687 | debug ("## No Flattened Device Tree\n"); | |
274cea2b | 688 | return 0; |
d2ced9eb MB |
689 | } |
690 | ||
691 | *of_flat_tree = fdt_blob; | |
692 | *of_size = be32_to_cpu (fdt_totalsize (fdt_blob)); | |
693 | debug (" of_flat_tree at 0x%08lx size 0x%08lx\n", | |
694 | *of_flat_tree, *of_size); | |
274cea2b KG |
695 | |
696 | return 0; | |
697 | ||
698 | error: | |
699 | do_reset (cmdtp, flag, argc, argv); | |
700 | return 1; | |
d2ced9eb MB |
701 | } |
702 | ||
9a4daad0 | 703 | static int boot_relocate_fdt (struct lmb *lmb, ulong bootmap_base, |
d2ced9eb MB |
704 | cmd_tbl_t *cmdtp, int flag, int argc, char *argv[], |
705 | char **of_flat_tree, ulong *of_size) | |
706 | { | |
707 | char *fdt_blob = *of_flat_tree; | |
708 | ulong relocate = 0; | |
e822d7fc | 709 | ulong of_len = 0; |
d2ced9eb MB |
710 | |
711 | /* nothing to do */ | |
712 | if (*of_size == 0) | |
e822d7fc | 713 | return 0; |
d2ced9eb MB |
714 | |
715 | if (fdt_check_header (fdt_blob) != 0) { | |
716 | fdt_error ("image is not a fdt"); | |
274cea2b | 717 | goto error; |
7b325454 MB |
718 | } |
719 | ||
d5934ad7 | 720 | #ifndef CFG_NO_FLASH |
d2ced9eb | 721 | /* move the blob if it is in flash (set relocate) */ |
d5934ad7 | 722 | if (addr2info ((ulong)fdt_blob) != NULL) |
d2ced9eb | 723 | relocate = 1; |
d5934ad7 MB |
724 | #endif |
725 | ||
7b325454 MB |
726 | /* |
727 | * The blob must be within CFG_BOOTMAPSZ, | |
728 | * so we flag it to be copied if it is not. | |
729 | */ | |
d5934ad7 | 730 | if (fdt_blob >= (char *)CFG_BOOTMAPSZ) |
d2ced9eb | 731 | relocate = 1; |
e822d7fc | 732 | |
05e07b1e | 733 | of_len = be32_to_cpu (fdt_totalsize (fdt_blob)); |
7b325454 MB |
734 | |
735 | /* move flattend device tree if needed */ | |
d2ced9eb | 736 | if (relocate) { |
7b325454 | 737 | int err; |
e822d7fc | 738 | ulong of_start; |
7b325454 MB |
739 | |
740 | /* position on a 4K boundary before the alloc_current */ | |
e822d7fc KG |
741 | of_start = lmb_alloc_base(lmb, of_len, 0x1000, |
742 | (CFG_BOOTMAPSZ + bootmap_base)); | |
743 | ||
744 | if (of_start == 0) { | |
745 | puts("device tree - allocation error\n"); | |
746 | goto error; | |
747 | } | |
7b325454 MB |
748 | |
749 | debug ("## device tree at 0x%08lX ... 0x%08lX (len=%ld=0x%lX)\n", | |
d5934ad7 | 750 | (ulong)fdt_blob, (ulong)fdt_blob + of_len - 1, |
7b325454 MB |
751 | of_len, of_len); |
752 | ||
753 | printf (" Loading Device Tree to %08lx, end %08lx ... ", | |
754 | of_start, of_start + of_len - 1); | |
755 | ||
d5934ad7 | 756 | err = fdt_open_into (fdt_blob, (void *)of_start, of_len); |
7b325454 MB |
757 | if (err != 0) { |
758 | fdt_error ("fdt move failed"); | |
274cea2b | 759 | goto error; |
7b325454 MB |
760 | } |
761 | puts ("OK\n"); | |
762 | ||
763 | *of_flat_tree = (char *)of_start; | |
7b325454 | 764 | } else { |
d5934ad7 | 765 | *of_flat_tree = fdt_blob; |
e822d7fc | 766 | lmb_reserve(lmb, (ulong)fdt, of_len); |
7b325454 MB |
767 | } |
768 | ||
e822d7fc | 769 | return 0; |
274cea2b KG |
770 | |
771 | error: | |
274cea2b | 772 | return 1; |
7b325454 | 773 | } |
d3c5eb6d | 774 | #endif |