OpenGrok

/*	$NetBSD: m68k_intr.c,v 1.13 2024/01/19 20:55:42 thorpej Exp $	*/

/*-
 * Copyright (c) 1996, 2023, 2024 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Adam Glass, Gordon W. Ross, and 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.
 */

/*
 * Common interrupt handling for m68k platforms.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: m68k_intr.c,v 1.13 2024/01/19 20:55:42 thorpej Exp $");

#define	_M68K_INTR_PRIVATE

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kmem.h>
#include <sys/vmmeter.h>
#include <sys/device.h>
#include <sys/cpu.h>
#include <sys/bus.h>
#include <sys/once.h>
#include <sys/intr.h>

#include <machine/vectors.h>

#include <uvm/uvm_extern.h>

#ifdef __HAVE_M68K_INTR_VECTORED
#ifndef MACHINE_USERVEC_START
#define	MACHINE_USERVEC_START	VECI_USRVEC_START
#endif

#define	NVECHANDS	(NVECTORS - MACHINE_USERVEC_START)

#ifndef INTR_FREEVEC
#define	INTR_FREEVEC	badtrap
#endif

extern char INTR_FREEVEC[];
extern char intrstub_vectored[];
#endif /* __HAVE_M68K_INTR_VECTORED */

/* A dummy event counter where interrupt stats go to die. */
static struct evcnt bitbucket;

volatile unsigned int intr_depth;	/* updated in assembly glue */

static struct m68k_intrhand_list m68k_intrhands_autovec[NAUTOVECTORS];
#ifdef __HAVE_M68K_INTR_VECTORED
static struct m68k_intrhand *m68k_intrhands_vectored[NVECHANDS];
#endif

#ifndef __HAVE_LEGACY_INTRCNT
#ifndef MACHINE_INTREVCNT_NAMES
#define	MACHINE_INTREVCNT_NAMES						\
	{ "spur", "lev1", "lev2", "lev3", "lev4", "lev5", "lev6", "nmi" }
#endif
static const char * const m68k_intr_evcnt_names[] = MACHINE_INTREVCNT_NAMES;
__CTASSERT(__arraycount(m68k_intr_evcnt_names) == NAUTOVECTORS);
static const char m68k_intr_evcnt_group[] = "cpu";

#define	INTRCNT_INIT(x)							\
	EVCNT_INITIALIZER(EVCNT_TYPE_INTR, NULL, m68k_intr_evcnt_group,	\
			  m68k_intr_evcnt_names[(x)])

struct evcnt m68k_intr_evcnt[] = {
	INTRCNT_INIT(0), INTRCNT_INIT(1), INTRCNT_INIT(2), INTRCNT_INIT(3),
	INTRCNT_INIT(4), INTRCNT_INIT(5), INTRCNT_INIT(6), INTRCNT_INIT(7),
};
__CTASSERT(__arraycount(m68k_intr_evcnt) == NAUTOVECTORS);

#undef INTRCNT_INIT
#endif /* __HAVE_LEGACY_INTRCNT */

const uint16_t ipl2psl_table[NIPL] = {
	[IPL_NONE]	 = PSL_S | PSL_IPL0,
	[IPL_SOFTBIO]	 = PSL_S | MACHINE_PSL_IPL_SOFTBIO,
	[IPL_SOFTCLOCK]	 = PSL_S | MACHINE_PSL_IPL_SOFTCLOCK,
	[IPL_SOFTNET]	 = PSL_S | MACHINE_PSL_IPL_SOFTNET,
	[IPL_SOFTSERIAL] = PSL_S | MACHINE_PSL_IPL_SOFTSERIAL,
	[IPL_VM]	 = PSL_S | MACHINE_PSL_IPL_VM,
	[IPL_SCHED]	 = PSL_S | MACHINE_PSL_IPL_SCHED,
	[IPL_HIGH]	 = PSL_S | PSL_IPL7,
};

/*
 * m68k_spurintr --
 *	Interrupt handler for the "spurious interrupt" that comes in
 *	on auto-vector level 0.  All we do is claim it; it gets counted
 *	during the normal course of auto-vector interrupt handling.
 */
static int
m68k_spurintr(void *arg)
{
	return 1;
}

static struct m68k_intrhand m68k_spurintr_ih = {
	.ih_func  = m68k_spurintr,
	.ih_arg   = m68k_spurintr,
	.ih_evcnt = &bitbucket,
};

static struct m68k_intrhand *
m68k_ih_stdalloc(int km_flag)
{
	return kmem_zalloc(sizeof(struct m68k_intrhand), km_flag);
}

static void
m68k_ih_stdfree(struct m68k_intrhand *ih)
{
	kmem_free(ih, sizeof(*ih));
}

static const struct m68k_ih_allocfuncs m68k_ih_stdallocfuncs = {
	.alloc = m68k_ih_stdalloc,
	.free  = m68k_ih_stdfree,
};

static const struct m68k_ih_allocfuncs *ih_allocfuncs;

static struct m68k_intrhand *
m68k_ih_alloc(void)
{
	KASSERT(ih_allocfuncs != NULL);
	return ih_allocfuncs->alloc(KM_SLEEP);
}

static void
m68k_ih_free(struct m68k_intrhand *ih)
{
	KASSERT(ih_allocfuncs != NULL);
	if (__predict_true(ih != &m68k_spurintr_ih)) {
		ih_allocfuncs->free(ih);
	}
}

#ifdef __HAVE_M68K_INTR_VECTORED

#define	INTRVEC_SLOT(vec)	\
	(&m68k_intrhands_vectored[(vec) - MACHINE_USERVEC_START])

#define	m68k_intrvec_handler(vec)	(*INTRVEC_SLOT(vec))

static bool
m68k_intrvec_add(struct m68k_intrhand *ih)
{
	if (ih->ih_vec < MACHINE_USERVEC_START || ih->ih_vec >= NVECTORS) {
		aprint_error("%s: vector=0x%x (invalid)\n", __func__,
		    ih->ih_vec);
		return false;
	}

	struct m68k_intrhand **slot =
	    &m68k_intrhands_vectored[ih->ih_vec - MACHINE_USERVEC_START];

	if (*slot != NULL) {
		aprint_error("%s: vector=0x%x (in use)\n", __func__,
		    ih->ih_vec);
		return false;
	}

	if (vec_get_entry(ih->ih_vec) != INTR_FREEVEC) {
		aprint_error("%s: vector=0x%x (unavailable)\n", __func__,
		    ih->ih_vec);
		return false;
	}

	*slot = ih;
	vec_set_entry(ih->ih_vec, intrstub_vectored);
	return true;
}

static void
m68k_intrvec_remove(struct m68k_intrhand *ih)
{
	KASSERT(ih->ih_vec >= MACHINE_USERVEC_START);
	KASSERT(ih->ih_vec < NVECTORS);

	struct m68k_intrhand **slot =
	    &m68k_intrhands_vectored[ih->ih_vec - MACHINE_USERVEC_START];

	KASSERT(*slot == ih);
	KASSERT(vec_get_entry(ih->ih_vec) == intrstub_vectored);

	vec_set_entry(ih->ih_vec, INTR_FREEVEC);
	*slot = NULL;
}

/* XXX This is horrible and should burn to the ground. */
void *
m68k_intrvec_intrhand(int vec)
{
	KASSERT(vec >= MACHINE_USERVEC_START);
	KASSERT(vec < NVECTORS);

	return m68k_intrhands_vectored[vec - MACHINE_USERVEC_START];
}

#endif /* __HAVE_M68K_INTR_VECTORED */

/*
 * m68k_intr_init --
 *	Initialize the interrupt subsystem.
 */
void
m68k_intr_init(const struct m68k_ih_allocfuncs *allocfuncs)
{
	int i;

	KASSERT(ih_allocfuncs == NULL);
	if (allocfuncs == NULL) {
		ih_allocfuncs = &m68k_ih_stdallocfuncs;
	} else {
		ih_allocfuncs = allocfuncs;
	}

	for (i = 0; i < NAUTOVECTORS; i++) {
		LIST_INIT(&m68k_intrhands_autovec[i]);
#ifndef __HAVE_LEGACY_INTRCNT
		evcnt_attach_static(&m68k_intr_evcnt[i]);
#endif
	}
	LIST_INSERT_HEAD(&m68k_intrhands_autovec[0],
	    &m68k_spurintr_ih, ih_link);
}

/*
 * m68k_intr_establish --
 *	Establish an interrupt handler at the specified vector.
 *	XXX We don't do anything with the flags yet.
 */
void *
m68k_intr_establish(int (*func)(void *), void *arg, struct evcnt *ev,
    int vec, int ipl, int isrpri, int flags __unused)
{
	struct m68k_intrhand *ih;
	int s;

	/*
	 * If a platform doesn't want special behavior, we don't
	 * require them to call m68k_intr_init(); we just handle
	 * it here.
	 *
	 * XXX m68k_intr_init() might be called really early, so
	 * XXX can't use a once control.
	 */
	if (__predict_false(ih_allocfuncs == NULL)) {
		m68k_intr_init(NULL);
	}

	/* These are m68k IPLs, not IPL_* values. */
	if (ipl < 0 || ipl > 7) {
		return NULL;
	}

#ifdef __HAVE_M68K_INTR_VECTORED
	KASSERT(vec >= 0);
	KASSERT(vec < NVECTORS);
#else
	KASSERT(vec == 0);
#endif /* __HAVE_M68K_INTR_VECTORED */

	ih = m68k_ih_alloc();
	ih->ih_func = func;
	ih->ih_arg = arg;
	ih->ih_vec = vec;
	ih->ih_ipl = ipl;
	ih->ih_isrpri = isrpri;
	if ((ih->ih_evcnt = ev) == NULL) {
		ih->ih_evcnt = &bitbucket;
	}

#ifdef __HAVE_M68K_INTR_VECTORED
	if (vec != 0) {
		if (vec_get_entry(vec) != INTR_FREEVEC) {
			m68k_ih_free(ih);
			return NULL;
		}
		if (! m68k_intrvec_add(ih)) {
			m68k_ih_free(ih);
			return NULL;
		}
		return ih;
	}
#endif

	/*
	 * Some devices are particularly sensitive to interrupt
	 * handling latency.  Unbuffered serial ports, for example,
	 * can lose data if their interrupts aren't handled with
	 * reasonable speed.  For this reason, we sort interrupt
	 * handlers by an abstract "ISR" priority, inserting higher-
	 * priority interrupts before lower-priority interrupts.
	 */
	struct m68k_intrhand_list * const list = &m68k_intrhands_autovec[ipl];
	struct m68k_intrhand *curih;

	s = splhigh();
	if (LIST_EMPTY(list)) {
		LIST_INSERT_HEAD(list, ih, ih_link);
		goto done;
	}
	for (curih = LIST_FIRST(list);
	     LIST_NEXT(curih, ih_link) != NULL;
	     curih = LIST_NEXT(curih, ih_link)) {
		if (ih->ih_isrpri > curih->ih_isrpri) {
			LIST_INSERT_BEFORE(curih, ih, ih_link);
			goto done;
		}
	}
	LIST_INSERT_AFTER(curih, ih, ih_link);
 done:
	splx(s);

	return ih;
}

/*
 * m68k_intr_disestablish --
 *	Remove an interrupt handler.  Returns true if the handler
 *	list for this vector is now empty.
 */
bool
m68k_intr_disestablish(void *v)
{
	struct m68k_intrhand *ih = v;
	int s;
	bool empty;

#ifdef __HAVE_M68K_INTR_VECTORED
	if (ih->ih_vec != 0) {
		KASSERT(vec_get_entry(ih->ih_vec) == intrstub_vectored);
		m68k_intrvec_remove(ih);
		empty = true;
	} else
#endif
	{
		s = splhigh();
		LIST_REMOVE(ih, ih_link);
		empty = LIST_EMPTY(&m68k_intrhands_autovec[ih->ih_ipl]);
		splx(s);
	}

	m68k_ih_free(ih);

	return empty;
}

void	m68k_intr_autovec(struct clockframe);

#ifndef MACHINE_AUTOVEC_IGNORE_STRAY
#define	MACHINE_AUTOVEC_IGNORE_STRAY(ipl)	0
#endif

/*
 * m68k_intr_autovec --
 *	Run the interrupt handlers for an auto-vectored interrupt.
 *	Called from the assembly glue in m68k_intr_stubs.s
 */
void
m68k_intr_autovec(struct clockframe frame)
{
	const int ipl = VECO_TO_VECI(frame.cf_vo) - VECI_INTRAV0;
	struct m68k_intrhand *ih;
	bool rv = false;

	m68k_count_intr(ipl);

	LIST_FOREACH(ih, &m68k_intrhands_autovec[ipl], ih_link) {
		void *arg = ih->ih_arg ? ih->ih_arg : &frame;
		if (ih->ih_func(arg)) {
			ih->ih_evcnt->ev_count++;
			rv = true;
		}
	}
	if (!rv && !MACHINE_AUTOVEC_IGNORE_STRAY(ipl)) {
		printf("Stray level %d interrupt\n", ipl);
	}

	ATOMIC_CAS_CHECK(&frame);
}

#ifdef __HAVE_M68K_INTR_VECTORED
void	m68k_intr_vectored(struct clockframe);

/*
 * m68k_intr_vectored --
 *	Run a vectored interrupt handler.
 *	Called from the assembly glue in m68k_intr_stubs.s
 */
void
m68k_intr_vectored(struct clockframe frame)
{
	const int vec = VECO_TO_VECI(frame.cf_vo);
	const int ipl = (getsr() >> 8) & 7;
	struct m68k_intrhand *ih;

	m68k_count_intr(ipl);

#ifdef DIAGNOSTIC
	if (vec < MACHINE_USERVEC_START || vec >= NVECTORS) {
		printf("%s: vector=0x%x (invalid)\n", __func__, vec);
		goto out;
	}
#endif
	ih = m68k_intrvec_handler(vec);
	if (ih == NULL) {
		printf("%s: vector=0x%x (no handler?)\n", __func__, vec);
		vec_set_entry(vec, INTR_FREEVEC);
	}

	if (__predict_true((*ih->ih_func)(ih->ih_arg ? ih->ih_arg
						     : &frame) != 0)) {
		ih->ih_evcnt->ev_count++;
	} else {
		printf("Stray level %d interrupt vector=0x%x\n",
		    ipl, vec);
	}
#ifdef DIAGNOSTIC
 out:
#endif
	ATOMIC_CAS_CHECK(&frame);
}
#endif /* __HAVE_M68K_INTR_VECTORED */