/*
 * Copyright (c) 2026 Abdelkader Boudih <freebsd@seuros.com>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

/*
 * coreboot(4) timestamp CBMEM reader
 *
 * Maps the timestamp CBMEM region on demand and formats boot stage
 * timing as a human-readable sysctl.  The mapping is transient —
 * created when the sysctl is read and released immediately after.
 */

#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/sbuf.h>
#include <sys/sysctl.h>

#include <vm/vm.h>
#include <vm/vm_param.h>
#include <vm/pmap.h>

#include <dev/coreboot/coreboot.h>

/*
 * Timestamp ID to name mapping.
 * IDs from coreboot's src/commonlib/include/commonlib/timestamp_serialized.h.
 */
static const struct cb_id_name ts_names[] = {
	{    1, "start of romstage" },
	{    2, "before RAM initialization" },
	{    3, "after RAM initialization" },
	{    4, "end of romstage" },
	{    5, "start of verified boot" },
	{    6, "end of verified boot" },
	{    8, "starting to load ramstage" },
	{    9, "finished loading ramstage" },
	{   10, "start of ramstage" },
	{   11, "start of bootblock" },
	{   12, "end of bootblock" },
	{   13, "starting to load romstage" },
	{   14, "finished loading romstage" },
	{   15, "starting LZMA decompress" },
	{   16, "finished LZMA decompress" },
	{   17, "starting LZ4 decompress" },
	{   18, "finished LZ4 decompress" },
	{   19, "starting ZSTD decompress" },
	{   20, "finished ZSTD decompress" },
	{   30, "early chipset initialization" },
	{   31, "device enumeration" },
	{   40, "device configure" },
	{   50, "device enable" },
	{   60, "device initialization" },
	{   65, "option ROM initialization" },
	{   66, "option ROM copy done" },
	{   67, "option ROM run done" },
	{   70, "device setup done" },
	{   75, "cbmem post" },
	{   80, "write tables" },
	{   85, "finalize chips" },
	{   90, "starting to load payload" },
	{   98, "acpi wake jump" },
	{   99, "selfboot jump" },
	{  100, "start of postcar" },
	{  101, "end of postcar" },
	{  110, "forced delay start" },
	{  111, "forced delay end" },
	{  112, "read microcode start" },
	{  113, "read microcode end" },
	{  114, "elog init start" },
	{  115, "elog init end" },
	{  950, "fsp memory init start" },
	{  951, "fsp memory init end" },
	{  952, "fsp temp RAM exit start" },
	{  953, "fsp temp RAM exit end" },
	{  954, "fsp silicon init start" },
	{  955, "fsp silicon init end" },
	{  956, "fsp enumerate start" },
	{  957, "fsp enumerate end" },
	{  958, "fsp finalize start" },
	{  959, "fsp finalize end" },
	{  960, "fsp end-of-firmware start" },
	{  961, "fsp end-of-firmware end" },
	{  962, "fsp multi-phase silicon init start" },
	{  963, "fsp multi-phase silicon init end" },
	{  964, "fsp multi-phase memory init start" },
	{  965, "fsp multi-phase memory init end" },
	{  970, "fsp memory init load" },
	{  971, "fsp silicon init load" },
	{ 1000, "depthcharge start" },
	{ 1100, "vboot done" },
	{ 1101, "kernel start" },
	{ 1102, "kernel decompression" },
	{ 0, NULL }
};

static const char *
ts_id_to_name(uint32_t id)
{

	return (cb_id_lookup(ts_names, id, NULL));
}

/*
 * Sysctl handler for hw.coreboot.timestamps.
 * Maps the CBMEM timestamp region, formats entries, and unmaps.
 */
static int
coreboot_timestamps_sysctl(SYSCTL_HANDLER_ARGS)
{
	struct coreboot_softc *sc = arg1;
	struct cb_timestamp_table *tst;
	struct sbuf *sb;
	void *va;
	vm_size_t map_size;
	uint32_t i, max, num;
	uint64_t base;
	uint64_t total;
	uint32_t freq;
	int error;

	if (sc->timestamps_paddr == 0)
		return (ENXIO);

	va = pmap_mapbios(sc->timestamps_paddr,
	    sizeof(struct cb_timestamp_table));
	if (va == NULL)
		return (ENOMEM);

	tst = (struct cb_timestamp_table *)va;
	max = tst->max_entries;
	num = tst->num_entries;
	freq = tst->tick_freq_mhz;
	base = tst->base_time;

	if (max > 1024)
		max = 1024;
	if (num > max)
		num = max;

	pmap_unmapbios(va, sizeof(struct cb_timestamp_table));

	total = (uint64_t)sizeof(struct cb_timestamp_table) +
	    (uint64_t)num * sizeof(struct cb_timestamp_entry);
	if (total > SIZE_MAX)
		return (EINVAL);
	map_size = (vm_size_t)total;
	va = pmap_mapbios(sc->timestamps_paddr, map_size);
	if (va == NULL)
		return (ENOMEM);

	tst = (struct cb_timestamp_table *)va;

	sb = sbuf_new_for_sysctl(NULL, NULL, 0, req);
	if (sb == NULL) {
		pmap_unmapbios(va, map_size);
		return (ENOMEM);
	}

	sbuf_printf(sb, "\n%-4s %-40s %12s %12s\n",
	    "ID", "Stage", "Stamp (us)", "Delta (us)");
	sbuf_printf(sb, "---- ----------------------------------------"
	    " ------------ ------------\n");

	for (i = 0; i < num; i++) {
		uint32_t eid = tst->entries[i].entry_id;
		int64_t stamp = tst->entries[i].entry_stamp;
		int64_t us, delta_us;
		const char *name;

		if (freq > 0)
			us = (stamp - (int64_t)base) / (int64_t)freq;
		else
			us = stamp;

		if (i > 0 && freq > 0) {
			int64_t prev = tst->entries[i - 1].entry_stamp;
			delta_us = (stamp - prev) / (int64_t)freq;
		} else {
			delta_us = 0;
		}

		name = ts_id_to_name(eid);
		if (name != NULL)
			sbuf_printf(sb, "%4u %-40s %12jd %12jd\n",
			    eid, name,
			    (intmax_t)us, (intmax_t)delta_us);
		else
			sbuf_printf(sb, "%4u %-40s %12jd %12jd\n",
			    eid, "(unknown)",
			    (intmax_t)us, (intmax_t)delta_us);
	}

	error = sbuf_finish(sb);
	sbuf_delete(sb);
	pmap_unmapbios(va, map_size);

	return (error);
}

int
coreboot_timestamps_register(struct coreboot_softc *sc,
    struct sysctl_oid *parent)
{

	SYSCTL_ADD_PROC(&sc->sysctl_ctx,
	    SYSCTL_CHILDREN(parent), OID_AUTO, "timestamps",
	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
	    sc, 0, coreboot_timestamps_sysctl, "A",
	    "Boot stage timing from coreboot timestamps");

	return (0);
}