/*	$OpenBSD: kern_softintr.c,v 1.1 2025/04/23 15:07:00 visa Exp $	*/

/*
 * Copyright (c) 2021, 2025 Visa Hankala
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/malloc.h>
#include <sys/mutex.h>
#include <sys/queue.h>

#include <machine/intr.h>

#include <uvm/uvm_extern.h>

#ifdef __USE_MI_SOFTINTR

struct softintr_hand {
	TAILQ_ENTRY(softintr_hand) sih_q;
	void			(*sih_fn)(void *);
	void			*sih_arg;
	struct cpu_info		*sih_runner;
	int			sih_level;
	unsigned short		sih_flags;
	unsigned short		sih_state;
};

#define SIF_MPSAFE		0x0001

#define SIS_DYING		0x0001
#define SIS_PENDING		0x0002
#define SIS_RESTART		0x0004

TAILQ_HEAD(softintr_queue, softintr_hand);

struct softintr_queue softintr_queue[NSOFTINTR];
struct mutex softintr_lock = MUTEX_INITIALIZER(IPL_HIGH);

void
softintr_init(void)
{
	int i;

	for (i = 0; i < nitems(softintr_queue); i++)
		TAILQ_INIT(&softintr_queue[i]);
}

void
softintr_dispatch(int level)
{
	struct cpu_info *ci = curcpu();
	struct softintr_queue *queue = &softintr_queue[level];
	struct softintr_hand *sih;

	mtx_enter(&softintr_lock);
	while ((sih = TAILQ_FIRST(queue)) != NULL) {
		KASSERT((sih->sih_state & (SIS_PENDING | SIS_RESTART)) ==
		    SIS_PENDING);
		KASSERT(sih->sih_runner == NULL);

		sih->sih_state &= ~SIS_PENDING;
		TAILQ_REMOVE(queue, sih, sih_q);
		sih->sih_runner = ci;
		mtx_leave(&softintr_lock);

		if (sih->sih_flags & SIF_MPSAFE) {
			(*sih->sih_fn)(sih->sih_arg);
		} else {
			KERNEL_LOCK();
			(*sih->sih_fn)(sih->sih_arg);
			KERNEL_UNLOCK();
		}

		mtx_enter(&softintr_lock);
		KASSERT((sih->sih_state & SIS_PENDING) == 0);
		sih->sih_runner = NULL;
		if (sih->sih_state & SIS_RESTART) {
			TAILQ_INSERT_TAIL(queue, sih, sih_q);
			sih->sih_state |= SIS_PENDING;
			sih->sih_state &= ~SIS_RESTART;
		}

		uvmexp.softs++;
	}
	mtx_leave(&softintr_lock);
}

void *
softintr_establish(int ipl, void (*func)(void *), void *arg)
{
	struct softintr_hand *sih;
	int level;
	unsigned short flags = 0;

	if (ipl & IPL_MPSAFE)
		flags |= SIF_MPSAFE;
	ipl &= ~IPL_MPSAFE;

	switch (ipl) {
#ifdef IPL_SOFT
	case IPL_SOFT:
#endif
	case IPL_SOFTCLOCK:
		level = SOFTINTR_CLOCK;
		break;

	case IPL_SOFTNET:
		level = SOFTINTR_NET;
		break;

	case IPL_TTY:
	case IPL_SOFTTTY:
		level = SOFTINTR_TTY;
		break;

	default:
		panic("softintr_establish: unhandled ipl %d", ipl);
	}

	sih = malloc(sizeof(*sih), M_DEVBUF, M_NOWAIT);
	if (sih != NULL) {
		sih->sih_fn = func;
		sih->sih_arg = arg;
		sih->sih_runner = NULL;
		sih->sih_level = level;
		sih->sih_flags = flags;
		sih->sih_state = 0;
	}
	return (sih);
}

void
softintr_disestablish(void *arg)
{
	struct cpu_info *runner;
	struct softintr_hand *sih = arg;

	assertwaitok();

	mtx_enter(&softintr_lock);
	sih->sih_state |= SIS_DYING;
	sih->sih_state &= ~SIS_RESTART;
	if (sih->sih_state & SIS_PENDING) {
		sih->sih_state &= ~SIS_PENDING;
		TAILQ_REMOVE(&softintr_queue[sih->sih_level], sih, sih_q);
	}
	runner = sih->sih_runner;
	mtx_leave(&softintr_lock);

	if (runner != NULL)
		sched_barrier(runner);

	KASSERT((sih->sih_state & (SIS_PENDING | SIS_RESTART)) == 0);
	KASSERT(sih->sih_runner == NULL);

	free(sih, M_DEVBUF, sizeof(*sih));
}

void
softintr_schedule(void *arg)
{
	struct softintr_hand *sih = arg;
	struct softintr_queue *queue = &softintr_queue[sih->sih_level];

	mtx_enter(&softintr_lock);
	KASSERT((sih->sih_state & SIS_DYING) == 0);
	if (sih->sih_runner == NULL) {
		KASSERT((sih->sih_state & SIS_RESTART) == 0);
		if ((sih->sih_state & SIS_PENDING) == 0) {
			TAILQ_INSERT_TAIL(queue, sih, sih_q);
			sih->sih_state |= SIS_PENDING;
			/* Call softintr() while SPL is still at IPL_HIGH. */
			softintr(sih->sih_level);
		}
	} else {
		KASSERT((sih->sih_state & SIS_PENDING) == 0);
		sih->sih_state |= SIS_RESTART;
	}
	mtx_leave(&softintr_lock);
}

#endif /* __USE_MI_SOFTINTR */