// SPDX-License-Identifier: BSD-3-Clause
//
// Copyright(c) 2016 Intel Corporation. All rights reserved.
//
// Author: Liam Girdwood <liam.r.girdwood@linux.intel.com>

/*
 * Generic DSP initialisation. This calls architecture and platform specific
 * initialisation functions.
 */

#include <rtos/panic.h>
#include <rtos/init.h>
#include <rtos/interrupt.h>
#include <sof/init.h>
#include <sof/lib/cpu.h>
#include <sof/lib/cpu-clk-manager.h>
#include <sof/lib/memory.h>
#include <sof/lib/mm_heap.h>
#include <sof/lib/notifier.h>
#include <sof/lib/pm_runtime.h>
#include <rtos/wait.h>
#include <sof/platform.h>
#include <rtos/task.h>
#include <rtos/sof.h>
#include <sof/trace/trace.h>
#include <rtos/idc.h>
#include <rtos/string_macro.h>
#include <rtos/symbol.h>
#include <sof/schedule/schedule.h>
#include <sof/schedule/edf_schedule.h>
#include <sof/schedule/dp_schedule.h>
#include <sof/schedule/ll_schedule.h>
#include <sof/schedule/ll_schedule_domain.h>
#include <ipc/trace.h>
#if CONFIG_IPC_MAJOR_4
#include <ipc4/fw_reg.h>
#include <sof/lib/mailbox.h>
#endif
#ifdef CONFIG_ZEPHYR_LOG
#include <zephyr/logging/log_ctrl.h>
#include <user/abi_dbg.h>
#include <sof_versions.h>
#include <version.h>
#endif
#include <sof/lib/ams.h>

LOG_MODULE_REGISTER(init, CONFIG_SOF_LOG_LEVEL);

/* main firmware context */
static struct sof sof;

struct sof *sof_get(void)
{
	return &sof;
}
EXPORT_SYMBOL(sof_get);

#if CONFIG_NO_SECONDARY_CORE_ROM
/**
 * \brief This function will unpack lpsram text sections from AltBootManifest
	  created in linker script.
	  AltBootManifest structure:
	  - number of entries
	  and for each entry:
	  - source pointer
	  - destination pointer
	  - size
 */
static inline void lp_sram_unpack(void)
{
	extern uintptr_t _loader_storage_manifest_start;

	uint32_t *src, *dst;
	uint32_t size, i;

	uint32_t *ptr = (uint32_t *)&_loader_storage_manifest_start;
	uint32_t entries = *ptr++;

	for (i = 0; i < entries; i++) {
		src = (uint32_t *)*ptr++;
		dst = (uint32_t *)*ptr++;
		size = *ptr++;

		memcpy_s(dst, size, src, size);
		dcache_writeback_region((__sparse_force void __sparse_cache *)dst, size);
	}
}
#endif

#if CONFIG_MULTICORE

static bool check_restore(void)
{
	struct idc *idc = *idc_get();
	struct notify *notifier = *arch_notify_get();
	struct schedulers *schedulers = *arch_schedulers_get();

	/* check whether basic core structures has been already allocated. If they
	 * are available in memory, it means that this is not cold boot and memory
	 * has not been powered off.
	 */
	return !!idc && !!notifier && !!schedulers;
}

static inline int secondary_core_restore(void) { return 0; };

__cold int secondary_core_init(struct sof *sof)
{
	int err;
	struct ll_schedule_domain *dma_domain;

	/* check whether we are in a cold boot process or not (e.g. D0->D0ix
	 * flow when primary core disables all secondary cores). If not, we do
	 * not have allocate basic structures like e.g. schedulers, notifier,
	 * because they have been already allocated. In that case we have to
	 * register and enable required interrupts.
	 */
	if (check_restore())
		return secondary_core_restore();

	trace_point(TRACE_BOOT_SYS_NOTIFIER);
	init_system_notify(sof);

	trace_point(TRACE_BOOT_PLATFORM_SCHED);
	scheduler_init_ll(timer_domain_get());

	dma_domain = dma_domain_get();
	if (dma_domain)
		scheduler_init_ll(dma_domain);

#if CONFIG_ZEPHYR_DP_SCHEDULER
	err = scheduler_dp_init();
	if (err < 0)
		return err;
#endif /* CONFIG_ZEPHYR_DP_SCHEDULER */

	/* initialize IDC mechanism */
	trace_point(TRACE_BOOT_PLATFORM_IDC);
	err = idc_init();
	if (err < 0)
		return err;

#if CONFIG_AMS
	err = ams_init();
	if (err < 0)
		return err;
#endif
#if CONFIG_KCPS_DYNAMIC_CLOCK_CONTROL
	err = core_kcps_adjust(cpu_get_id(), SECONDARY_CORE_BASE_CPS_USAGE);
	if (err < 0)
		return err;
#endif

	trace_point(TRACE_BOOT_PLATFORM);

	return err;
}

#endif

__cold static void print_version_banner(void)
{
	/*
	 * Non-Zephyr builds emit the version banner in DMA-trace
	 * init and this is done at a later time as otherwise the
	 * banner would be lost. With Zephyr logging subsystem in use,
	 * we can simply print the banner at boot.
	 *
	 * STRINGIFY(SOF_SRC_HASH) is part of the format string so it
	 * is part of log dictionary meta data and does not go to
	 * the firmware binary (in case dictionary logging is used).
	 * The value printed to log will be different from
	 * SOF_SRC_HASH in case of mismatch.
	 */
#ifdef CONFIG_ZEPHYR_LOG
	LOG_INF("FW ABI 0x%x DBG ABI 0x%x tags SOF:" SOF_GIT_TAG " zephyr:" \
		STRINGIFY(BUILD_VERSION) " src hash 0x%08x (ref hash " \
		STRINGIFY(SOF_SRC_HASH) ")",
		SOF_ABI_VERSION, SOF_ABI_DBG_VERSION, SOF_SRC_HASH);
#endif
}

#ifdef CONFIG_ZEPHYR_LOG
static log_timestamp_t default_get_timestamp(void)
{
	return IS_ENABLED(CONFIG_LOG_TIMESTAMP_64BIT) ?
		sys_clock_tick_get() : k_cycle_get_32();
}
#endif

__cold static int primary_core_init(int argc, char *argv[], struct sof *sof)
{
	/* setup context */
	sof->argc = argc;
	sof->argv = argv;

#if defined(CONFIG_ZEPHYR_LOG) && !defined(CONFIG_LOG_MODE_MINIMAL)
	log_set_timestamp_func(default_get_timestamp,
			       sys_clock_hw_cycles_per_sec());
#endif

#if CONFIG_TRACE
	trace_point(TRACE_BOOT_SYS_TRACES);
	trace_init(sof);
#endif

	print_version_banner();

	trace_point(TRACE_BOOT_SYS_NOTIFIER);
	init_system_notify(sof);

	trace_point(TRACE_BOOT_SYS_POWER);
	pm_runtime_init(sof);

#ifdef CONFIG_SOF_TELEMETRY_IO_PERFORMANCE_MEASUREMENTS
	/* init I/O performance before any I/O interfaces */
	io_perf_monitor_init();
#endif

	/* init the platform */
	if (platform_init(sof) < 0)
		sof_panic(SOF_IPC_PANIC_PLATFORM);

#if CONFIG_AMS
	if (ams_init())
		LOG_ERR("AMS Init failed!");
#endif

#if CONFIG_IPC_MAJOR_4
	/* Set current abi version of the IPC4 FwRegisters layout */
	size_t ipc4_abi_ver_offset = offsetof(struct ipc4_fw_registers, abi_ver);

	mailbox_sw_reg_write(ipc4_abi_ver_offset, IPC4_FW_REGS_ABI_VER);

	k_spinlock_init(&sof->fw_reg_lock);
#endif

	trace_point(TRACE_BOOT_PLATFORM);

#if CONFIG_NO_SECONDARY_CORE_ROM
	lp_sram_unpack();
#endif

	/* should not return, except with Zephyr */
	return task_main_start(sof);
}

int sof_main(int argc, char *argv[])
{
	trace_point(TRACE_BOOT_START);

	return start_complete();
}

static int sof_init(void)
{
	return primary_core_init(0, NULL, &sof);
}

SYS_INIT(sof_init, POST_KERNEL, 99);