/*
   * Copyright (c) 2013, Google Inc.
   *
   * (C) Copyright 2008 Semihalf
   *
   * (C) Copyright 2000-2006
   * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   *

   * SPDX-License-Identifier:	GPL-2.0+

   */
  
  #include <common.h>
  #include <fdt_support.h>
  #include <errno.h>
  #include <image.h>
  #include <libfdt.h>
  #include <asm/io.h>
  
  #ifndef CONFIG_SYS_FDT_PAD
  #define CONFIG_SYS_FDT_PAD 0x3000
  #endif
  
  DECLARE_GLOBAL_DATA_PTR;
  
  static void fdt_error(const char *msg)
  {
  	puts("ERROR: ");
  	puts(msg);
  	puts(" - must RESET the board to recover.
  ");
  }
  
  static const image_header_t *image_get_fdt(ulong fdt_addr)
  {
  	const image_header_t *fdt_hdr = map_sysmem(fdt_addr, 0);
  
  	image_print_contents(fdt_hdr);
  
  	puts("   Verifying Checksum ... ");
  	if (!image_check_hcrc(fdt_hdr)) {
  		fdt_error("fdt header checksum invalid");
  		return NULL;
  	}
  
  	if (!image_check_dcrc(fdt_hdr)) {
  		fdt_error("fdt checksum invalid");
  		return NULL;
  	}
  	puts("OK
  ");
  
  	if (!image_check_type(fdt_hdr, IH_TYPE_FLATDT)) {
  		fdt_error("uImage is not a fdt");
  		return NULL;
  	}
  	if (image_get_comp(fdt_hdr) != IH_COMP_NONE) {
  		fdt_error("uImage is compressed");
  		return NULL;
  	}

  	if (fdt_check_header((void *)image_get_data(fdt_hdr)) != 0) {

  		fdt_error("uImage data is not a fdt");
  		return NULL;
  	}
  	return fdt_hdr;
  }
  
  /**
   * boot_fdt_add_mem_rsv_regions - Mark the memreserve sections as unusable
   * @lmb: pointer to lmb handle, will be used for memory mgmt
   * @fdt_blob: pointer to fdt blob base address
   *
   * Adds the memreserve regions in the dtb to the lmb block.  Adding the
   * memreserve regions prevents u-boot from using them to store the initrd
   * or the fdt blob.
   */
  void boot_fdt_add_mem_rsv_regions(struct lmb *lmb, void *fdt_blob)
  {
  	uint64_t addr, size;
  	int i, total;
  
  	if (fdt_check_header(fdt_blob) != 0)
  		return;
  
  	total = fdt_num_mem_rsv(fdt_blob);
  	for (i = 0; i < total; i++) {
  		if (fdt_get_mem_rsv(fdt_blob, i, &addr, &size) != 0)
  			continue;
  		printf("   reserving fdt memory region: addr=%llx size=%llx
  ",
  		       (unsigned long long)addr, (unsigned long long)size);
  		lmb_reserve(lmb, addr, size);
  	}
  }
  
  /**
   * boot_relocate_fdt - relocate flat device tree
   * @lmb: pointer to lmb handle, will be used for memory mgmt
   * @of_flat_tree: pointer to a char* variable, will hold fdt start address
   * @of_size: pointer to a ulong variable, will hold fdt length
   *
   * boot_relocate_fdt() allocates a region of memory within the bootmap and
   * relocates the of_flat_tree into that region, even if the fdt is already in
   * the bootmap.  It also expands the size of the fdt by CONFIG_SYS_FDT_PAD
   * bytes.
   *
   * of_flat_tree and of_size are set to final (after relocation) values
   *
   * returns:
   *      0 - success
   *      1 - failure
   */
  int boot_relocate_fdt(struct lmb *lmb, char **of_flat_tree, ulong *of_size)
  {
  	void	*fdt_blob = *of_flat_tree;
  	void	*of_start = NULL;
  	char	*fdt_high;
  	ulong	of_len = 0;
  	int	err;
  	int	disable_relocation = 0;
  
  	/* nothing to do */
  	if (*of_size == 0)
  		return 0;
  
  	if (fdt_check_header(fdt_blob) != 0) {
  		fdt_error("image is not a fdt");
  		goto error;
  	}
  
  	/* position on a 4K boundary before the alloc_current */
  	/* Pad the FDT by a specified amount */
  	of_len = *of_size + CONFIG_SYS_FDT_PAD;
  
  	/* If fdt_high is set use it to select the relocation address */
  	fdt_high = getenv("fdt_high");
  	if (fdt_high) {
  		void *desired_addr = (void *)simple_strtoul(fdt_high, NULL, 16);
  
  		if (((ulong) desired_addr) == ~0UL) {
  			/* All ones means use fdt in place */
  			of_start = fdt_blob;
  			lmb_reserve(lmb, (ulong)of_start, of_len);
  			disable_relocation = 1;
  		} else if (desired_addr) {
  			of_start =
  			    (void *)(ulong) lmb_alloc_base(lmb, of_len, 0x1000,
  							   (ulong)desired_addr);
  			if (of_start == NULL) {
  				puts("Failed using fdt_high value for Device Tree");
  				goto error;
  			}
  		} else {
  			of_start =
  			    (void *)(ulong) lmb_alloc(lmb, of_len, 0x1000);
  		}
  	} else {
  		of_start =
  		    (void *)(ulong) lmb_alloc_base(lmb, of_len, 0x1000,
  						   getenv_bootm_mapsize()
  						   + getenv_bootm_low());
  	}
  
  	if (of_start == NULL) {
  		puts("device tree - allocation error
  ");
  		goto error;
  	}
  
  	if (disable_relocation) {
  		/*
  		 * We assume there is space after the existing fdt to use
  		 * for padding
  		 */
  		fdt_set_totalsize(of_start, of_len);
  		printf("   Using Device Tree in place at %p, end %p
  ",
  		       of_start, of_start + of_len - 1);
  	} else {
  		debug("## device tree at %p ... %p (len=%ld [0x%lX])
  ",
  		      fdt_blob, fdt_blob + *of_size - 1, of_len, of_len);
  
  		printf("   Loading Device Tree to %p, end %p ... ",
  		       of_start, of_start + of_len - 1);
  
  		err = fdt_open_into(fdt_blob, of_start, of_len);
  		if (err != 0) {
  			fdt_error("fdt move failed");
  			goto error;
  		}
  		puts("OK
  ");
  	}
  
  	*of_flat_tree = of_start;
  	*of_size = of_len;
  
  	set_working_fdt_addr(*of_flat_tree);
  	return 0;
  
  error:
  	return 1;
  }

  /**
   * boot_get_fdt - main fdt handling routine
   * @argc: command argument count
   * @argv: command argument list

   * @arch: architecture (IH_ARCH_...)

   * @images: pointer to the bootm images structure
   * @of_flat_tree: pointer to a char* variable, will hold fdt start address
   * @of_size: pointer to a ulong variable, will hold fdt length
   *
   * boot_get_fdt() is responsible for finding a valid flat device tree image.
   * Curently supported are the following ramdisk sources:
   *      - multicomponent kernel/ramdisk image,
   *      - commandline provided address of decicated ramdisk image.
   *
   * returns:
   *     0, if fdt image was found and valid, or skipped
   *     of_flat_tree and of_size are set to fdt start address and length if
   *     fdt image is found and valid
   *
   *     1, if fdt image is found but corrupted
   *     of_flat_tree and of_size are set to 0 if no fdt exists
   */

  int boot_get_fdt(int flag, int argc, char * const argv[], uint8_t arch,

  		bootm_headers_t *images, char **of_flat_tree, ulong *of_size)
  {
  	const image_header_t *fdt_hdr;
  	ulong		fdt_addr;
  	char		*fdt_blob = NULL;
  	ulong		image_start, image_data, image_end;

  	ulong		load, load_end;

  	void		*buf;
  #if defined(CONFIG_FIT)

  	const char	*fit_uname_config = images->fit_uname_cfg;

  	const char	*fit_uname_fdt = NULL;
  	ulong		default_addr;

  	int		fdt_noffset;

  #endif

  	const char *select = NULL;

  
  	*of_flat_tree = NULL;
  	*of_size = 0;

  	if (argc > 2)
  		select = argv[2];
  	if (select || genimg_has_config(images)) {

  #if defined(CONFIG_FIT)

  		if (select) {

  			/*
  			 * If the FDT blob comes from the FIT image and the
  			 * FIT image address is omitted in the command line
  			 * argument, try to use ramdisk or os FIT image
  			 * address or default load address.
  			 */
  			if (images->fit_uname_rd)
  				default_addr = (ulong)images->fit_hdr_rd;
  			else if (images->fit_uname_os)
  				default_addr = (ulong)images->fit_hdr_os;
  			else
  				default_addr = load_addr;

  			if (fit_parse_conf(select, default_addr,

  					   &fdt_addr, &fit_uname_config)) {
  				debug("*  fdt: config '%s' from image at 0x%08lx
  ",
  				      fit_uname_config, fdt_addr);

  			} else if (fit_parse_subimage(select, default_addr,

  				   &fdt_addr, &fit_uname_fdt)) {
  				debug("*  fdt: subimage '%s' from image at 0x%08lx
  ",
  				      fit_uname_fdt, fdt_addr);
  			} else
  #endif
  			{

  				fdt_addr = simple_strtoul(select, NULL, 16);

  				debug("*  fdt: cmdline image address = 0x%08lx
  ",
  				      fdt_addr);
  			}
  #if defined(CONFIG_FIT)
  		} else {
  			/* use FIT configuration provided in first bootm
  			 * command argument
  			 */
  			fdt_addr = map_to_sysmem(images->fit_hdr_os);

  			fdt_noffset = fit_get_node_from_config(images,
  							       FIT_FDT_PROP,
  							       fdt_addr);
  			if (fdt_noffset == -ENOLINK)

  				return 0;

  			else if (fdt_noffset < 0)
  				return 1;

  		}
  #endif

  		debug("## Checking for 'FDT'/'FDT Image' at %08lx
  ",
  		      fdt_addr);
  
  		/* copy from dataflash if needed */
  		fdt_addr = genimg_get_image(fdt_addr);
  
  		/*
  		 * Check if there is an FDT image at the
  		 * address provided in the second bootm argument
  		 * check image type, for FIT images get a FIT node.
  		 */
  		buf = map_sysmem(fdt_addr, 0);
  		switch (genimg_get_format(buf)) {
  		case IMAGE_FORMAT_LEGACY:
  			/* verify fdt_addr points to a valid image header */
  			printf("## Flattened Device Tree from Legacy Image at %08lx
  ",
  			       fdt_addr);
  			fdt_hdr = image_get_fdt(fdt_addr);
  			if (!fdt_hdr)
  				goto error;
  
  			/*
  			 * move image data to the load address,
  			 * make sure we don't overwrite initial image
  			 */
  			image_start = (ulong)fdt_hdr;
  			image_data = (ulong)image_get_data(fdt_hdr);
  			image_end = image_get_image_end(fdt_hdr);

  			load = image_get_load(fdt_hdr);
  			load_end = load + image_get_data_size(fdt_hdr);

  			if (load == image_start ||
  			    load == image_data) {

  				fdt_blob = (char *)image_data;
  				break;
  			}

  			if ((load < image_end) && (load_end > image_start)) {

  				fdt_error("fdt overwritten");
  				goto error;
  			}
  
  			debug("   Loading FDT from 0x%08lx to 0x%08lx
  ",

  			      image_data, load);

  			memmove((void *)load,

  				(void *)image_data,
  				image_get_data_size(fdt_hdr));

  			fdt_addr = load;

  			break;
  		case IMAGE_FORMAT_FIT:
  			/*
  			 * This case will catch both: new uImage format
  			 * (libfdt based) and raw FDT blob (also libfdt
  			 * based).
  			 */
  #if defined(CONFIG_FIT)
  			/* check FDT blob vs FIT blob */
  			if (fit_check_format(buf)) {

  				ulong load, len;

  				fdt_noffset = fit_image_load(images,
  					FIT_FDT_PROP,
  					fdt_addr, &fit_uname_fdt,

  					&fit_uname_config,

  					arch, IH_TYPE_FLATDT,
  					BOOTSTAGE_ID_FIT_FDT_START,
  					FIT_LOAD_OPTIONAL, &load, &len);

  				images->fit_hdr_fdt = map_sysmem(fdt_addr, 0);

  				images->fit_uname_fdt = fit_uname_fdt;
  				images->fit_noffset_fdt = fdt_noffset;

  				fdt_addr = load;

  				break;
  			} else
  #endif
  			{
  				/*
  				 * FDT blob
  				 */

  				debug("*  fdt: raw FDT blob
  ");
  				printf("## Flattened Device Tree blob at %08lx
  ",
  				       (long)fdt_addr);
  			}
  			break;
  		default:
  			puts("ERROR: Did not find a cmdline Flattened Device Tree
  ");
  			goto error;
  		}

  		printf("   Booting using the fdt blob at %#08lx
  ", fdt_addr);
  		fdt_blob = map_sysmem(fdt_addr, 0);

  	} else if (images->legacy_hdr_valid &&
  			image_check_type(&images->legacy_hdr_os_copy,
  					 IH_TYPE_MULTI)) {
  		ulong fdt_data, fdt_len;
  
  		/*
  		 * Now check if we have a legacy multi-component image,
  		 * get second entry data start address and len.
  		 */
  		printf("## Flattened Device Tree from multi component Image at %08lX
  ",
  		       (ulong)images->legacy_hdr_os);
  
  		image_multi_getimg(images->legacy_hdr_os, 2, &fdt_data,
  				   &fdt_len);
  		if (fdt_len) {
  			fdt_blob = (char *)fdt_data;
  			printf("   Booting using the fdt at 0x%p
  ", fdt_blob);
  
  			if (fdt_check_header(fdt_blob) != 0) {
  				fdt_error("image is not a fdt");
  				goto error;
  			}
  
  			if (fdt_totalsize(fdt_blob) != fdt_len) {
  				fdt_error("fdt size != image size");
  				goto error;
  			}
  		} else {
  			debug("## No Flattened Device Tree
  ");
  			return 0;
  		}
  	} else {
  		debug("## No Flattened Device Tree
  ");
  		return 0;
  	}
  
  	*of_flat_tree = fdt_blob;
  	*of_size = fdt_totalsize(fdt_blob);
  	debug("   of_flat_tree at 0x%08lx size 0x%08lx
  ",
  	      (ulong)*of_flat_tree, *of_size);
  
  	return 0;
  
  error:
  	*of_flat_tree = NULL;
  	*of_size = 0;
  	return 1;
  }

  
  /*
   * Verify the device tree.
   *
   * This function is called after all device tree fix-ups have been enacted,
   * so that the final device tree can be verified.  The definition of "verified"
   * is up to the specific implementation.  However, it generally means that the
   * addresses of some of the devices in the device tree are compared with the
   * actual addresses at which U-Boot has placed them.
   *
   * Returns 1 on success, 0 on failure.  If 0 is returned, U-boot will halt the
   * boot process.
   */
  __weak int ft_verify_fdt(void *fdt)
  {
  	return 1;
  }
  
  __weak int arch_fixup_memory_node(void *blob)
  {
  	return 0;
  }
  
  int image_setup_libfdt(bootm_headers_t *images, void *blob,
  		       int of_size, struct lmb *lmb)
  {
  	ulong *initrd_start = &images->initrd_start;
  	ulong *initrd_end = &images->initrd_end;
  	int ret;
  
  	if (fdt_chosen(blob, 1) < 0) {
  		puts("ERROR: /chosen node create failed");
  		puts(" - must RESET the board to recover.
  ");
  		return -1;
  	}
  	arch_fixup_memory_node(blob);

  	if (IMAGE_OF_BOARD_SETUP)

  		ft_board_setup(blob, gd->bd);
  	fdt_fixup_ethernet(blob);
  
  	/* Delete the old LMB reservation */
  	lmb_free(lmb, (phys_addr_t)(u32)(uintptr_t)blob,
  		 (phys_size_t)fdt_totalsize(blob));
  
  	ret = fdt_resize(blob);
  	if (ret < 0)
  		return ret;
  	of_size = ret;
  
  	if (*initrd_start && *initrd_end) {
  		of_size += FDT_RAMDISK_OVERHEAD;
  		fdt_set_totalsize(blob, of_size);
  	}
  	/* Create a new LMB reservation */
  	lmb_reserve(lmb, (ulong)blob, of_size);
  
  	fdt_initrd(blob, *initrd_start, *initrd_end, 1);
  	if (!ft_verify_fdt(blob))
  		return -1;
  
  	return 0;
  }