libfdt: move headers to <linux/libfdt.h> and <linux/libfdt_env.h>
[platform/kernel/u-boot.git] / common / image-fdt.c
1 /*
2  * Copyright (c) 2013, Google Inc.
3  *
4  * (C) Copyright 2008 Semihalf
5  *
6  * (C) Copyright 2000-2006
7  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
8  *
9  * SPDX-License-Identifier:     GPL-2.0+
10  */
11
12 #include <common.h>
13 #include <fdt_support.h>
14 #include <errno.h>
15 #include <image.h>
16 #include <linux/libfdt.h>
17 #include <mapmem.h>
18 #include <asm/io.h>
19
20 #ifndef CONFIG_SYS_FDT_PAD
21 #define CONFIG_SYS_FDT_PAD 0x3000
22 #endif
23
24 DECLARE_GLOBAL_DATA_PTR;
25
26 static void fdt_error(const char *msg)
27 {
28         puts("ERROR: ");
29         puts(msg);
30         puts(" - must RESET the board to recover.\n");
31 }
32
33 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
34 static const image_header_t *image_get_fdt(ulong fdt_addr)
35 {
36         const image_header_t *fdt_hdr = map_sysmem(fdt_addr, 0);
37
38         image_print_contents(fdt_hdr);
39
40         puts("   Verifying Checksum ... ");
41         if (!image_check_hcrc(fdt_hdr)) {
42                 fdt_error("fdt header checksum invalid");
43                 return NULL;
44         }
45
46         if (!image_check_dcrc(fdt_hdr)) {
47                 fdt_error("fdt checksum invalid");
48                 return NULL;
49         }
50         puts("OK\n");
51
52         if (!image_check_type(fdt_hdr, IH_TYPE_FLATDT)) {
53                 fdt_error("uImage is not a fdt");
54                 return NULL;
55         }
56         if (image_get_comp(fdt_hdr) != IH_COMP_NONE) {
57                 fdt_error("uImage is compressed");
58                 return NULL;
59         }
60         if (fdt_check_header((void *)image_get_data(fdt_hdr)) != 0) {
61                 fdt_error("uImage data is not a fdt");
62                 return NULL;
63         }
64         return fdt_hdr;
65 }
66 #endif
67
68 /**
69  * boot_fdt_add_mem_rsv_regions - Mark the memreserve sections as unusable
70  * @lmb: pointer to lmb handle, will be used for memory mgmt
71  * @fdt_blob: pointer to fdt blob base address
72  *
73  * Adds the memreserve regions in the dtb to the lmb block.  Adding the
74  * memreserve regions prevents u-boot from using them to store the initrd
75  * or the fdt blob.
76  */
77 void boot_fdt_add_mem_rsv_regions(struct lmb *lmb, void *fdt_blob)
78 {
79         uint64_t addr, size;
80         int i, total;
81
82         if (fdt_check_header(fdt_blob) != 0)
83                 return;
84
85         total = fdt_num_mem_rsv(fdt_blob);
86         for (i = 0; i < total; i++) {
87                 if (fdt_get_mem_rsv(fdt_blob, i, &addr, &size) != 0)
88                         continue;
89                 printf("   reserving fdt memory region: addr=%llx size=%llx\n",
90                        (unsigned long long)addr, (unsigned long long)size);
91                 lmb_reserve(lmb, addr, size);
92         }
93 }
94
95 /**
96  * boot_relocate_fdt - relocate flat device tree
97  * @lmb: pointer to lmb handle, will be used for memory mgmt
98  * @of_flat_tree: pointer to a char* variable, will hold fdt start address
99  * @of_size: pointer to a ulong variable, will hold fdt length
100  *
101  * boot_relocate_fdt() allocates a region of memory within the bootmap and
102  * relocates the of_flat_tree into that region, even if the fdt is already in
103  * the bootmap.  It also expands the size of the fdt by CONFIG_SYS_FDT_PAD
104  * bytes.
105  *
106  * of_flat_tree and of_size are set to final (after relocation) values
107  *
108  * returns:
109  *      0 - success
110  *      1 - failure
111  */
112 int boot_relocate_fdt(struct lmb *lmb, char **of_flat_tree, ulong *of_size)
113 {
114         void    *fdt_blob = *of_flat_tree;
115         void    *of_start = NULL;
116         char    *fdt_high;
117         ulong   of_len = 0;
118         int     err;
119         int     disable_relocation = 0;
120
121         /* nothing to do */
122         if (*of_size == 0)
123                 return 0;
124
125         if (fdt_check_header(fdt_blob) != 0) {
126                 fdt_error("image is not a fdt");
127                 goto error;
128         }
129
130         /* position on a 4K boundary before the alloc_current */
131         /* Pad the FDT by a specified amount */
132         of_len = *of_size + CONFIG_SYS_FDT_PAD;
133
134         /* If fdt_high is set use it to select the relocation address */
135         fdt_high = env_get("fdt_high");
136         if (fdt_high) {
137                 void *desired_addr = (void *)simple_strtoul(fdt_high, NULL, 16);
138
139                 if (((ulong) desired_addr) == ~0UL) {
140                         /* All ones means use fdt in place */
141                         of_start = fdt_blob;
142                         lmb_reserve(lmb, (ulong)of_start, of_len);
143                         disable_relocation = 1;
144                 } else if (desired_addr) {
145                         of_start =
146                             (void *)(ulong) lmb_alloc_base(lmb, of_len, 0x1000,
147                                                            (ulong)desired_addr);
148                         if (of_start == NULL) {
149                                 puts("Failed using fdt_high value for Device Tree");
150                                 goto error;
151                         }
152                 } else {
153                         of_start =
154                             (void *)(ulong) lmb_alloc(lmb, of_len, 0x1000);
155                 }
156         } else {
157                 of_start =
158                     (void *)(ulong) lmb_alloc_base(lmb, of_len, 0x1000,
159                                                    env_get_bootm_mapsize()
160                                                    + env_get_bootm_low());
161         }
162
163         if (of_start == NULL) {
164                 puts("device tree - allocation error\n");
165                 goto error;
166         }
167
168         if (disable_relocation) {
169                 /*
170                  * We assume there is space after the existing fdt to use
171                  * for padding
172                  */
173                 fdt_set_totalsize(of_start, of_len);
174                 printf("   Using Device Tree in place at %p, end %p\n",
175                        of_start, of_start + of_len - 1);
176         } else {
177                 debug("## device tree at %p ... %p (len=%ld [0x%lX])\n",
178                       fdt_blob, fdt_blob + *of_size - 1, of_len, of_len);
179
180                 printf("   Loading Device Tree to %p, end %p ... ",
181                        of_start, of_start + of_len - 1);
182
183                 err = fdt_open_into(fdt_blob, of_start, of_len);
184                 if (err != 0) {
185                         fdt_error("fdt move failed");
186                         goto error;
187                 }
188                 puts("OK\n");
189         }
190
191         *of_flat_tree = of_start;
192         *of_size = of_len;
193
194         set_working_fdt_addr((ulong)*of_flat_tree);
195         return 0;
196
197 error:
198         return 1;
199 }
200
201 /**
202  * boot_get_fdt - main fdt handling routine
203  * @argc: command argument count
204  * @argv: command argument list
205  * @arch: architecture (IH_ARCH_...)
206  * @images: pointer to the bootm images structure
207  * @of_flat_tree: pointer to a char* variable, will hold fdt start address
208  * @of_size: pointer to a ulong variable, will hold fdt length
209  *
210  * boot_get_fdt() is responsible for finding a valid flat device tree image.
211  * Curently supported are the following ramdisk sources:
212  *      - multicomponent kernel/ramdisk image,
213  *      - commandline provided address of decicated ramdisk image.
214  *
215  * returns:
216  *     0, if fdt image was found and valid, or skipped
217  *     of_flat_tree and of_size are set to fdt start address and length if
218  *     fdt image is found and valid
219  *
220  *     1, if fdt image is found but corrupted
221  *     of_flat_tree and of_size are set to 0 if no fdt exists
222  */
223 int boot_get_fdt(int flag, int argc, char * const argv[], uint8_t arch,
224                 bootm_headers_t *images, char **of_flat_tree, ulong *of_size)
225 {
226 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
227         const image_header_t *fdt_hdr;
228         ulong           load, load_end;
229         ulong           image_start, image_data, image_end;
230 #endif
231         ulong           fdt_addr;
232         char            *fdt_blob = NULL;
233         void            *buf;
234 #if CONFIG_IS_ENABLED(FIT)
235         const char      *fit_uname_config = images->fit_uname_cfg;
236         const char      *fit_uname_fdt = NULL;
237         ulong           default_addr;
238         int             fdt_noffset;
239 #endif
240         const char *select = NULL;
241         int             ok_no_fdt = 0;
242
243         *of_flat_tree = NULL;
244         *of_size = 0;
245
246         if (argc > 2)
247                 select = argv[2];
248         if (select || genimg_has_config(images)) {
249 #if CONFIG_IS_ENABLED(FIT)
250                 if (select) {
251                         /*
252                          * If the FDT blob comes from the FIT image and the
253                          * FIT image address is omitted in the command line
254                          * argument, try to use ramdisk or os FIT image
255                          * address or default load address.
256                          */
257                         if (images->fit_uname_rd)
258                                 default_addr = (ulong)images->fit_hdr_rd;
259                         else if (images->fit_uname_os)
260                                 default_addr = (ulong)images->fit_hdr_os;
261                         else
262                                 default_addr = load_addr;
263
264                         if (fit_parse_conf(select, default_addr,
265                                            &fdt_addr, &fit_uname_config)) {
266                                 debug("*  fdt: config '%s' from image at 0x%08lx\n",
267                                       fit_uname_config, fdt_addr);
268                         } else if (fit_parse_subimage(select, default_addr,
269                                    &fdt_addr, &fit_uname_fdt)) {
270                                 debug("*  fdt: subimage '%s' from image at 0x%08lx\n",
271                                       fit_uname_fdt, fdt_addr);
272                         } else
273 #endif
274                         {
275                                 fdt_addr = simple_strtoul(select, NULL, 16);
276                                 debug("*  fdt: cmdline image address = 0x%08lx\n",
277                                       fdt_addr);
278                         }
279 #if CONFIG_IS_ENABLED(FIT)
280                 } else {
281                         /* use FIT configuration provided in first bootm
282                          * command argument
283                          */
284                         fdt_addr = map_to_sysmem(images->fit_hdr_os);
285                         fdt_noffset = fit_get_node_from_config(images,
286                                                                FIT_FDT_PROP,
287                                                                fdt_addr);
288                         if (fdt_noffset == -ENOENT)
289                                 return 0;
290                         else if (fdt_noffset < 0)
291                                 return 1;
292                 }
293 #endif
294                 debug("## Checking for 'FDT'/'FDT Image' at %08lx\n",
295                       fdt_addr);
296
297                 /*
298                  * Check if there is an FDT image at the
299                  * address provided in the second bootm argument
300                  * check image type, for FIT images get a FIT node.
301                  */
302                 buf = map_sysmem(fdt_addr, 0);
303                 switch (genimg_get_format(buf)) {
304 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
305                 case IMAGE_FORMAT_LEGACY:
306                         /* verify fdt_addr points to a valid image header */
307                         printf("## Flattened Device Tree from Legacy Image at %08lx\n",
308                                fdt_addr);
309                         fdt_hdr = image_get_fdt(fdt_addr);
310                         if (!fdt_hdr)
311                                 goto no_fdt;
312
313                         /*
314                          * move image data to the load address,
315                          * make sure we don't overwrite initial image
316                          */
317                         image_start = (ulong)fdt_hdr;
318                         image_data = (ulong)image_get_data(fdt_hdr);
319                         image_end = image_get_image_end(fdt_hdr);
320
321                         load = image_get_load(fdt_hdr);
322                         load_end = load + image_get_data_size(fdt_hdr);
323
324                         if (load == image_start ||
325                             load == image_data) {
326                                 fdt_addr = load;
327                                 break;
328                         }
329
330                         if ((load < image_end) && (load_end > image_start)) {
331                                 fdt_error("fdt overwritten");
332                                 goto error;
333                         }
334
335                         debug("   Loading FDT from 0x%08lx to 0x%08lx\n",
336                               image_data, load);
337
338                         memmove((void *)load,
339                                 (void *)image_data,
340                                 image_get_data_size(fdt_hdr));
341
342                         fdt_addr = load;
343                         break;
344 #endif
345                 case IMAGE_FORMAT_FIT:
346                         /*
347                          * This case will catch both: new uImage format
348                          * (libfdt based) and raw FDT blob (also libfdt
349                          * based).
350                          */
351 #if CONFIG_IS_ENABLED(FIT)
352                         /* check FDT blob vs FIT blob */
353                         if (fit_check_format(buf)) {
354                                 ulong load, len;
355
356                                 fdt_noffset = boot_get_fdt_fit(images,
357                                         fdt_addr, &fit_uname_fdt,
358                                         &fit_uname_config,
359                                         arch, &load, &len);
360
361                                 images->fit_hdr_fdt = map_sysmem(fdt_addr, 0);
362                                 images->fit_uname_fdt = fit_uname_fdt;
363                                 images->fit_noffset_fdt = fdt_noffset;
364                                 fdt_addr = load;
365
366                                 break;
367                         } else
368 #endif
369                         {
370                                 /*
371                                  * FDT blob
372                                  */
373                                 debug("*  fdt: raw FDT blob\n");
374                                 printf("## Flattened Device Tree blob at %08lx\n",
375                                        (long)fdt_addr);
376                         }
377                         break;
378                 default:
379                         puts("ERROR: Did not find a cmdline Flattened Device Tree\n");
380                         goto no_fdt;
381                 }
382
383                 printf("   Booting using the fdt blob at %#08lx\n", fdt_addr);
384                 fdt_blob = map_sysmem(fdt_addr, 0);
385         } else if (images->legacy_hdr_valid &&
386                         image_check_type(&images->legacy_hdr_os_copy,
387                                          IH_TYPE_MULTI)) {
388                 ulong fdt_data, fdt_len;
389
390                 /*
391                  * Now check if we have a legacy multi-component image,
392                  * get second entry data start address and len.
393                  */
394                 printf("## Flattened Device Tree from multi component Image at %08lX\n",
395                        (ulong)images->legacy_hdr_os);
396
397                 image_multi_getimg(images->legacy_hdr_os, 2, &fdt_data,
398                                    &fdt_len);
399                 if (fdt_len) {
400                         fdt_blob = (char *)fdt_data;
401                         printf("   Booting using the fdt at 0x%p\n", fdt_blob);
402
403                         if (fdt_check_header(fdt_blob) != 0) {
404                                 fdt_error("image is not a fdt");
405                                 goto error;
406                         }
407
408                         if (fdt_totalsize(fdt_blob) != fdt_len) {
409                                 fdt_error("fdt size != image size");
410                                 goto error;
411                         }
412                 } else {
413                         debug("## No Flattened Device Tree\n");
414                         goto no_fdt;
415                 }
416         } else {
417                 debug("## No Flattened Device Tree\n");
418                 goto no_fdt;
419         }
420
421         *of_flat_tree = fdt_blob;
422         *of_size = fdt_totalsize(fdt_blob);
423         debug("   of_flat_tree at 0x%08lx size 0x%08lx\n",
424               (ulong)*of_flat_tree, *of_size);
425
426         return 0;
427
428 no_fdt:
429         ok_no_fdt = 1;
430 error:
431         *of_flat_tree = NULL;
432         *of_size = 0;
433         if (!select && ok_no_fdt) {
434                 debug("Continuing to boot without FDT\n");
435                 return 0;
436         }
437         return 1;
438 }
439
440 /*
441  * Verify the device tree.
442  *
443  * This function is called after all device tree fix-ups have been enacted,
444  * so that the final device tree can be verified.  The definition of "verified"
445  * is up to the specific implementation.  However, it generally means that the
446  * addresses of some of the devices in the device tree are compared with the
447  * actual addresses at which U-Boot has placed them.
448  *
449  * Returns 1 on success, 0 on failure.  If 0 is returned, U-Boot will halt the
450  * boot process.
451  */
452 __weak int ft_verify_fdt(void *fdt)
453 {
454         return 1;
455 }
456
457 __weak int arch_fixup_fdt(void *blob)
458 {
459         return 0;
460 }
461
462 int image_setup_libfdt(bootm_headers_t *images, void *blob,
463                        int of_size, struct lmb *lmb)
464 {
465         ulong *initrd_start = &images->initrd_start;
466         ulong *initrd_end = &images->initrd_end;
467         int ret = -EPERM;
468         int fdt_ret;
469
470         if (fdt_root(blob) < 0) {
471                 printf("ERROR: root node setup failed\n");
472                 goto err;
473         }
474         if (fdt_chosen(blob) < 0) {
475                 printf("ERROR: /chosen node create failed\n");
476                 goto err;
477         }
478         if (arch_fixup_fdt(blob) < 0) {
479                 printf("ERROR: arch-specific fdt fixup failed\n");
480                 goto err;
481         }
482         /* Update ethernet nodes */
483         fdt_fixup_ethernet(blob);
484         if (IMAGE_OF_BOARD_SETUP) {
485                 fdt_ret = ft_board_setup(blob, gd->bd);
486                 if (fdt_ret) {
487                         printf("ERROR: board-specific fdt fixup failed: %s\n",
488                                fdt_strerror(fdt_ret));
489                         goto err;
490                 }
491         }
492         if (IMAGE_OF_SYSTEM_SETUP) {
493                 fdt_ret = ft_system_setup(blob, gd->bd);
494                 if (fdt_ret) {
495                         printf("ERROR: system-specific fdt fixup failed: %s\n",
496                                fdt_strerror(fdt_ret));
497                         goto err;
498                 }
499         }
500
501         /* Delete the old LMB reservation */
502         if (lmb)
503                 lmb_free(lmb, (phys_addr_t)(u32)(uintptr_t)blob,
504                          (phys_size_t)fdt_totalsize(blob));
505
506         ret = fdt_shrink_to_minimum(blob, 0);
507         if (ret < 0)
508                 goto err;
509         of_size = ret;
510
511         if (*initrd_start && *initrd_end) {
512                 of_size += FDT_RAMDISK_OVERHEAD;
513                 fdt_set_totalsize(blob, of_size);
514         }
515         /* Create a new LMB reservation */
516         if (lmb)
517                 lmb_reserve(lmb, (ulong)blob, of_size);
518
519         fdt_initrd(blob, *initrd_start, *initrd_end);
520         if (!ft_verify_fdt(blob))
521                 goto err;
522
523 #if defined(CONFIG_SOC_KEYSTONE)
524         if (IMAGE_OF_BOARD_SETUP)
525                 ft_board_setup_ex(blob, gd->bd);
526 #endif
527
528         return 0;
529 err:
530         printf(" - must RESET the board to recover.\n\n");
531
532         return ret;
533 }