/*
 * SPDX-License-Identifier: GPL-2.0
 */

#include <linux/interrupt.h>
#include <linux/irq_pipeline.h>
#include <linux/tick.h>
#include <cobalt/kernel/sched.h>
#include <cobalt/kernel/lock.h>
#include <cobalt/kernel/intr.h>

void xnintr_host_tick(struct xnsched *sched) /* hard irqs off */
{
	sched->lflags &= ~XNHTICK;
	tick_notify_proxy();
}

/*
 * Low-level core clock irq handler. This one forwards ticks from the
 * Xenomai platform timer to nkclock exclusively.
 */
void xnintr_core_clock_handler(void)
{
	struct xnsched *sched;

	xnlock_get(&nklock);
	xnclock_tick(&nkclock);
	xnlock_put(&nklock);

	/*
	 * If the core clock interrupt preempted a real-time thread,
	 * any transition to the root thread has already triggered a
	 * host tick propagation from xnsched_run(), so at this point,
	 * we only need to propagate the host tick in case the
	 * interrupt preempted the root thread.
	 */
	sched = xnsched_current();
	if ((sched->lflags & XNHTICK) &&
	    xnthread_test_state(sched->curr, XNROOT))
		xnintr_host_tick(sched);
}

static irqreturn_t xnintr_irq_handler(int irq, void *dev_id)
{
	struct xnintr *intr = dev_id;
	int ret;

	ret = intr->isr(intr);
	XENO_WARN_ON_ONCE(USER, (ret & XN_IRQ_STATMASK) == 0);

	if (ret & XN_IRQ_DISABLE)
		disable_irq(irq);
	else if (ret & XN_IRQ_PROPAGATE)
		irq_post_inband(irq);

	return ret & XN_IRQ_NONE ? IRQ_NONE : IRQ_HANDLED;
}

int xnintr_init(struct xnintr *intr, const char *name,
		unsigned int irq, xnisr_t isr, xniack_t iack,
		int flags)
{
	secondary_mode_only();

	intr->irq = irq;
	intr->isr = isr;
	intr->iack = NULL;	/* unused */
	intr->cookie = NULL;
	intr->name = name ? : "<unknown>";
	intr->flags = flags;
	intr->status = 0;
	intr->unhandled = 0;	/* unused */
	raw_spin_lock_init(&intr->lock); /* unused */

	return 0;
}
EXPORT_SYMBOL_GPL(xnintr_init);

void xnintr_destroy(struct xnintr *intr)
{
	secondary_mode_only();
	xnintr_detach(intr);
}
EXPORT_SYMBOL_GPL(xnintr_destroy);

int xnintr_attach(struct xnintr *intr, void *cookie, const cpumask_t *cpumask)
{
	cpumask_t tmp_mask, *effective_mask;
	int ret;

	secondary_mode_only();

	intr->cookie = cookie;

	if (!cpumask) {
		effective_mask = &xnsched_realtime_cpus;
	} else {
		effective_mask = &tmp_mask;
		cpumask_and(effective_mask, &xnsched_realtime_cpus, cpumask);
		if (cpumask_empty(effective_mask))
			return -EINVAL;
	}
#ifdef CONFIG_SMP
	ret = irq_set_affinity_hint(intr->irq, effective_mask);
	if (ret)
		return ret;
#endif

	return request_irq(intr->irq, xnintr_irq_handler, IRQF_OOB,
			intr->name, intr);
}
EXPORT_SYMBOL_GPL(xnintr_attach);

void xnintr_detach(struct xnintr *intr)
{
	secondary_mode_only();
#ifdef CONFIG_SMP
	irq_set_affinity_hint(intr->irq, NULL);
#endif
	free_irq(intr->irq, intr);
}
EXPORT_SYMBOL_GPL(xnintr_detach);

void xnintr_enable(struct xnintr *intr)
{
}
EXPORT_SYMBOL_GPL(xnintr_enable);

void xnintr_disable(struct xnintr *intr)
{
}
EXPORT_SYMBOL_GPL(xnintr_disable);

int xnintr_affinity(struct xnintr *intr, const cpumask_t *cpumask)
{
	cpumask_t effective_mask;

	secondary_mode_only();

	cpumask_and(&effective_mask, &xnsched_realtime_cpus, cpumask);
	if (cpumask_empty(&effective_mask))
		return -EINVAL;

	return irq_set_affinity_hint(intr->irq, &effective_mask);
}
EXPORT_SYMBOL_GPL(xnintr_affinity);