/*	$NetBSD: kvm_m68k_gen.c,v 1.2 2025/12/24 20:37:04 andvar Exp $	*/

/*-
 * Copyright (c) 2025 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Jason R. Thorpe.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/cdefs.h>
#if defined(LIBC_SCCS) && !defined(lint)
__RCSID("$NetBSD: kvm_m68k_gen.c,v 1.2 2025/12/24 20:37:04 andvar Exp $");
#endif /* LIBC_SCCS and not lint */

/*
 * Generic m68k machine dependent routines for kvm.
 *
 * Note: This file has to build on ALL m68k machines,
 * so do NOT include any <machine / *.h> files here.
 */

#include <sys/param.h>
#include <sys/types.h>
#include <sys/kcore.h>

#include <unistd.h>
#include <limits.h>
#include <kvm.h>
#include <stdlib.h>

#include <m68k/cpu.h>
#include <m68k/kcore.h>
#include <m68k/mmu_51.h>
#include <m68k/mmu_30.h>
#include <m68k/mmu_40.h>

#include "kvm_private.h"
#include "kvm_m68k.h"

static int	_kvm_gen68k_initvtop(kvm_t *);
static void	_kvm_gen68k_freevtop(kvm_t *);
static int	_kvm_gen68k_kvatop(kvm_t *, vaddr_t, paddr_t *);
static off_t	_kvm_gen68k_pa2off(kvm_t *, u_long);

struct kvm_ops _kvm_ops_gen68k = {
	_kvm_gen68k_initvtop,
	_kvm_gen68k_freevtop,
	_kvm_gen68k_kvatop,
	_kvm_gen68k_pa2off
};

/*
 * For the table indices, shift first, then mask.  The ti_pa_mask
 * is computed from the number of entries the table indexes, which
 * in turn defines how precise the address field in each table
 * entry.
 */
struct table_index {
	uint32_t	ti_shift;
	uint32_t	ti_mask;
	uint32_t	ti_pa_mask;
};

#define	TABLE_INDEX_COUNT	4

struct kvm_gen68k_context {
	uint32_t	pg_frame;	/* page frame computed from mask */
	uint32_t	va_mask;	/* VA significant bits from IS */

	struct table_index ti[TABLE_INDEX_COUNT];
};

static inline uint32_t
table_entry_paddr(uint32_t table_pa, unsigned int idx)
{
	return table_pa + (idx * sizeof(uint32_t));
}

static int
read_table_entry(kvm_t *kd, int level, paddr_t table_pa, unsigned int idx,
    uint32_t *entry)
{
	uint32_t entry_pa = table_entry_paddr(table_pa, idx);

	if (_kvm_pread(kd, kd->pmfd, entry, sizeof(*entry),
		       _kvm_gen68k_pa2off(kd, entry_pa)) != sizeof(*entry)) {
		_kvm_err(kd, 0,
		    "failed to read level-%c entry @ pa=0x%08x",
		    'A' + level, entry_pa);
		return -1;
	}
	return 0;
}

static inline unsigned int
table_index(const struct kvm_gen68k_context * const ctx, int level,
    uint32_t va)
{
	return (va >> ctx->ti[level].ti_shift) & ctx->ti[level].ti_mask;
}

static inline uint32_t
table_entry_extract_pa(const struct kvm_gen68k_context * const ctx, int level,
    uint32_t entry)
{
	return entry & ctx->ti[level].ti_pa_mask;
}

static int
mmu_tree_walk(kvm_t *kd, uint32_t va, uint32_t *pap)
{
	const cpu_kcore_hdr_t * const h = kd->cpu_data;
	const struct gen68k_kcore_hdr * const gen = &h->un._gen68k;
	const struct vmstate * const vmst = kd->vmst;
	const struct kvm_gen68k_context * const ctx = vmst->private;
	uint32_t entry, type, table_pa;
	uint32_t adj_va = va & ctx->va_mask;
	unsigned int idx;
	int level;

	/* We only handle SHORT descriptors. */
	if (__SHIFTOUT(gen->srp[0], DT51_TYPE) != DT51_SHORT) {
		_kvm_err(kd, 0,
		    "SRP does not point to a SHORT descriptor");
		return -1;
	}

	table_pa = gen->srp[1];
	for (level = 0; level < TABLE_INDEX_COUNT; level++) {
		idx = table_index(ctx, level, adj_va);
		if (read_table_entry(kd, level, table_pa, idx, &entry) < 0) {
			return -1;
		}
		type = __SHIFTOUT(entry, DT51_TYPE);
		switch (type) {
		case DT51_INVALID:
			_kvm_err(kd, 0,
			    "INVALID level-%c entry @ table_pa=0x%08x idx=%d",
			    'A' + level, table_pa, idx);
			return -1;

		case DT51_PAGE:
			*pap = entry & ctx->pg_frame;
			return 0;

		case DT51_SHORT:
			table_pa = table_entry_extract_pa(ctx, level, entry);
			break;

		case DT51_LONG:
		default:
			/*
			 * Our kernel doesn't use DT51_LONG, but if it
			 * did, we could read the value at entry_pa+4
			 * to get the 32-bit Table Physical Address field.
			 */
			_kvm_err(kd, 0,
			    "LONG level-%c entry @ table_pa=0x%08x idx=%d",
			    'A' + level, table_pa, idx);
			return -1;
		}
	}
	_kvm_err(kd, 0,
	    "exhausted %d levels for kva=0x%08x\n",
	    TABLE_INDEX_COUNT, va);
	return -1;
}

static int
_kvm_gen68k_initvtop(kvm_t *kd)
{
	struct vmstate *vmst = kd->vmst;

	struct kvm_gen68k_context *ctx = calloc(1, sizeof(*ctx));
	if (ctx == NULL) {
		goto bad;
	}

	cpu_kcore_hdr_t *h = kd->cpu_data;
	struct gen68k_kcore_hdr *gen = &h->un._gen68k;

	vmst->pgshift = __SHIFTOUT(gen->tcr, TCR51_PS);
	if (vmst->pgshift < 8 || vmst->pgshift > 15) {
		/* Invalid PS field in TCR. */
		goto bad;
	}
	vmst->pgofset = (1U << vmst->pgshift) - 1;
	ctx->pg_frame = ~vmst->pgofset;

	unsigned int ti[TABLE_INDEX_COUNT];
	unsigned int is  = __SHIFTOUT(gen->tcr, TCR51_IS);
	ti[0] = __SHIFTOUT(gen->tcr, TCR51_TIA);
	ti[1] = __SHIFTOUT(gen->tcr, TCR51_TIB);
	ti[2] = __SHIFTOUT(gen->tcr, TCR51_TIC);
	ti[3] = __SHIFTOUT(gen->tcr, TCR51_TID);

	/* All of the shifts should add up to 32. */
	if (is + ti[0] + ti[1] + ti[2] + ti[3] + vmst->pgshift != 32) {
		/* This must add up to 32. */
		goto bad;
	}
	if (is > 15 || ti[0] > 15 || ti[1] > 15 || ti[2] > 15 || ti[3] > 15) {
		/* None of these values may exceed 15. */
		goto bad;
	}

	/*
	 * The MMU works by successively shifting the address to the
	 * left and using a mux to take the next field from bits 31-N
	 * as indicated by the TCR.  The initial shift is intended to
	 * lop off the upper N bits of the address, presumably so that
	 * software can use them for some other purpose (aaah, how fondly
	 * we remember the 24-bit addresses of the 68000/68010).  We sort
	 * of work successively the other direction because it's more
	 * convenient for software to do it that way, but we do need to
	 * pre-compute some shifts and masks first.
	 */

	ctx->va_mask = 0xffffffffU;
	int curshift = 32;
	unsigned int count;
	if (is) {
		ctx->va_mask = (ctx->va_mask << is) >> is;
		curshift -= is;
	}
	for (int i = 0; i < TABLE_INDEX_COUNT; i++) {
		/* MMU stops processing once it gets to a TIx == 0. */
		if (ti[i] == 0) {
			break;
		}
		curshift -= ti[i];
		count = 1U << ti[i];
		ctx->ti[i].ti_shift = curshift;
		ctx->ti[i].ti_mask = (count - 1);
		/*
		 * XXX Doesn't deal with entries that point to long
		 * XXX descriptors.
		 */
		ctx->ti[i].ti_pa_mask = 0xffffffffU &
		    ~((count * sizeof(uint32_t)) - 1);
	}

	/* At this point, what remains should be pgshift. */
	if (curshift != vmst->pgshift) {
		goto bad;
	}

	vmst->private = ctx;
	return 0;

 bad:
	if (ctx != NULL) {
		free(ctx);
	}
	return -1;
}

static void
_kvm_gen68k_freevtop(kvm_t *kd)
{
	struct kvm_gen68k_context *ctx = kd->vmst->private;
	kd->vmst->private = NULL;

	free(ctx);
}

static int
_kvm_gen68k_kvatop(kvm_t *kd, vaddr_t va, paddr_t *pa)
{
	cpu_kcore_hdr_t *h = kd->cpu_data;
	const struct gen68k_kcore_hdr * const gen = &h->un._gen68k;
	const struct vmstate * const vmst = kd->vmst;
	const struct kvm_gen68k_context * const ctx = vmst->private;
	uint32_t trans_pa;

	if (ISALIVE(kd)) {
		_kvm_err(kd, 0, "vatop called in live kernel!");
		return 0;
	}

	vaddr_t offset = va & vmst->pgofset;
	va &= ctx->pg_frame;

	/*
	 * We may be called before address translation is initialized.
	 * This is typically used to find the dump magic number.  This
	 * means we do not yet have the kernel page tables available,
	 * so we must to a simple relocation.
	 */
	if (va >= h->kernbase && va < gen->relocend) {
		trans_pa = (va - h->kernbase) + gen->reloc;
		goto out;
	}

	if (mmu_tree_walk(kd, va, &trans_pa) < 0) {
		/* _kvm_err() already set. */
		return 0;
	}
 out:
	*pa = trans_pa + offset;
	return h->page_size - offset;
}

/*
 * Translate a physical address to a file-offset in the crash dump.
 */
static off_t
_kvm_gen68k_pa2off(kvm_t *kd, u_long pa)
{
	cpu_kcore_hdr_t *h = kd->cpu_data;
	struct gen68k_kcore_hdr *gen = &h->un._gen68k;
	phys_ram_seg_t *rsp = gen->ram_segs;
	off_t off = 0;
	int i;

	for (i = 0; i < GEN68K_NPHYS_RAM_SEGS && rsp[i].size != 0; i++) {
		if (pa >= rsp[i].start &&
		    pa < (rsp[i].start + rsp[i].size)) {
			pa -= rsp[i].start;
			break;
		}
		off += rsp[i].size;
	}
	return (kd->dump_off + off + pa);
}