/*
 * Copyright (c) 2010 Sascha Hauer <s.hauer@pengutronix.de>, Pengutronix
 *
 * See file CREDITS for list of people who contributed to this
 * project.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 */
#define pr_fmt(fmt) "start.c: " fmt

#include <common.h>
#include <init.h>
#include <linux/sizes.h>
#include <of.h>
#include <asm/barebox-arm.h>
#include <asm/barebox-arm-head.h>
#include <asm-generic/memory_layout.h>
#include <asm/sections.h>
#include <asm/unaligned.h>
#include <asm/cache.h>
#include <memory.h>
#include <uncompress.h>
#include <malloc.h>

#include <debug_ll.h>
#include "mmu-early.h"

unsigned long arm_stack_top;
static void *barebox_boarddata;

u32 barebox_arm_machine(void)
{
	struct barebox_arm_boarddata *bd;

	if (!barebox_boarddata)
		return 0;

	bd = barebox_boarddata;

	return bd->machine;
}

struct barebox_arm_boarddata *barebox_arm_get_boarddata(void)
{
	return barebox_boarddata;
}

static void *barebox_boot_dtb;
struct barebox_arm_boarddata_compressed_dtb *compressed_dtb;

void *barebox_arm_boot_dtb(void)
{
	void *dtb;
	void *data;
	int ret;

	if (barebox_boot_dtb) {
		pr_debug("%s: using barebox_boot_dtb\n", __func__);
		return barebox_boot_dtb;
	}

	if (!IS_ENABLED(CONFIG_ARM_USE_COMPRESSED_DTB) || !compressed_dtb)
		return NULL;

	pr_debug("%s: using compressed_dtb\n", __func__);

	dtb = malloc(compressed_dtb->datalen_uncompressed);
	if (!dtb)
		return NULL;

	data = compressed_dtb + 1;

	ret = uncompress(data, compressed_dtb->datalen, NULL, NULL,
			dtb, NULL, NULL);
	if (ret) {
		pr_err("uncompressing dtb failed\n");
		free(dtb);
		return NULL;
	}

	barebox_boot_dtb = dtb;

	return barebox_boot_dtb;
}

static noinline __noreturn void __start(unsigned long membase,
		unsigned long memsize, void *boarddata)
{
	unsigned long endmem = membase + memsize;
	unsigned long malloc_start, malloc_end;

	if (IS_ENABLED(CONFIG_RELOCATABLE)) {
		unsigned long barebox_base = arm_barebox_image_place(endmem);
		relocate_to_adr(barebox_base);
	}

	setup_c();

	barrier();

	pr_debug("memory at 0x%08lx, size 0x%08lx\n", membase, memsize);

	barebox_boarddata = boarddata;
	arm_stack_top = endmem;
	endmem -= STACK_SIZE; /* Stack */

	if (IS_ENABLED(CONFIG_MMU_EARLY)) {

		endmem &= ~0x3fff;
		endmem -= SZ_16K; /* ttb */

		if (IS_ENABLED(CONFIG_PBL_IMAGE)) {
			arm_set_cache_functions();
		} else {
			pr_debug("enabling MMU, ttb @ 0x%08lx\n", endmem);
			arm_early_mmu_cache_invalidate();
			mmu_early_enable(membase, memsize, endmem);
		}
	}

	if (boarddata) {
		if (get_unaligned_be32(boarddata) == FDT_MAGIC) {
			uint32_t totalsize = get_unaligned_be32(boarddata + 4);
			endmem -= ALIGN(totalsize, 64);
			barebox_boot_dtb = (void *)endmem;
			pr_debug("found DTB in boarddata, copying to 0x%p\n",
					barebox_boot_dtb);
			memcpy(barebox_boot_dtb, boarddata, totalsize);
		} else if (((struct barebox_arm_boarddata *)boarddata)->magic ==
				BAREBOX_ARM_BOARDDATA_MAGIC) {
			endmem -= ALIGN(sizeof(struct barebox_arm_boarddata), 64);
			barebox_boarddata = (void *)endmem;
			pr_debug("found machine type in boarddata, copying to 0x%p\n",
					barebox_boarddata);
			memcpy(barebox_boarddata, boarddata,
					sizeof(struct barebox_arm_boarddata));
		} else if (((struct barebox_arm_boarddata_compressed_dtb *)boarddata)->magic ==
				BAREBOX_ARM_BOARDDATA_COMPRESSED_DTB_MAGIC) {
			struct barebox_arm_boarddata_compressed_dtb *bd = boarddata;
			endmem -= ALIGN(sizeof(*bd) + bd->datalen, 64);
			compressed_dtb = (void *)endmem;
			pr_debug("found compressed DTB in boarddata, copying to 0x%p\n",
					compressed_dtb);
			memcpy(compressed_dtb, boarddata, sizeof(*bd) + bd->datalen);
		}
	}

	if ((unsigned long)_text > membase + memsize ||
			(unsigned long)_text < membase)
		/*
		 * barebox is either outside SDRAM or in another
		 * memory bank, so we can use the whole bank for
		 * malloc.
		 */
		malloc_end = endmem;
	else
		malloc_end = (unsigned long)_text;

	/*
	 * Maximum malloc space is the Kconfig value if given
	 * or 1GB.
	 */
	if (MALLOC_SIZE > 0) {
		malloc_start = malloc_end - MALLOC_SIZE;
		if (malloc_start < membase)
			malloc_start = membase;
	} else {
		malloc_start = malloc_end - (malloc_end - membase) / 2;
		if (malloc_end - malloc_start > SZ_1G)
			malloc_start = malloc_end - SZ_1G;
	}

	pr_debug("initializing malloc pool at 0x%08lx (size 0x%08lx)\n",
			malloc_start, malloc_end - malloc_start);

	mem_malloc_init((void *)malloc_start, (void *)malloc_end - 1);

	pr_debug("starting barebox...\n");

	start_barebox();
}

#ifndef CONFIG_PBL_IMAGE

void __naked __section(.text_entry) start(void)
{
	barebox_arm_head();
}

/*
 * Main ARM entry point in the uncompressed image. Call this with the memory
 * region you can spare for barebox. This doesn't necessarily have to be the
 * full SDRAM. The currently running binary can be inside or outside of this
 * region. TEXT_BASE can be inside or outside of this region. boarddata will
 * be preserved and can be accessed later with barebox_arm_boarddata().
 *
 * -> membase + memsize
 *   STACK_SIZE              - stack
 *   16KiB, aligned to 16KiB - First level page table if early MMU support
 *                             is enabled
 * -> maximum end of barebox binary
 *
 * Usually a TEXT_BASE of 1MiB below your lowest possible end of memory should
 * be fine.
 */
void __naked __noreturn barebox_arm_entry(unsigned long membase,
		unsigned long memsize, void *boarddata)
{
	arm_setup_stack(membase + memsize - 16);

	arm_early_mmu_cache_invalidate();

	__start(membase, memsize, boarddata);
}
#else
/*
 * First function in the uncompressed image. We get here from
 * the pbl. The stack already has been set up by the pbl.
 */
void __naked __section(.text_entry) start(unsigned long membase,
		unsigned long memsize, void *boarddata)
{
	__start(membase, memsize, boarddata);
}
#endif