/*
 * Copyright (c) 2018-2019 François Tigeot <ftigeot@wolfpond.org>
 * All rights reserved.
 *
 * 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 unmodified, 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 AUTHOR ``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 AUTHOR 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 <linux/interrupt.h>
#include <linux/device.h>
#include <drm/drmP.h>

#include <sys/bus.h>
#include <bus/pci/pcivar.h>

struct irq_data {
	unsigned int		irq;
	void			*dev_id;
	irq_handler_t		handler;
	const char		*name;
	int			rid;
	struct resource		*resource;
	void			*cookiep;
	struct			lwkt_serialize irq_lock;
	SLIST_ENTRY(irq_data)	id_irq_entries;
};

struct lock irqdata_lock = LOCK_INITIALIZER("dlidl", 0, LK_CANRECURSE);

SLIST_HEAD(irq_data_list_head, irq_data) irq_list = SLIST_HEAD_INITIALIZER(irq_list);

/* DragonFly irq handler, used to invoke Linux ones */
static void
linux_irq_handler(void *arg)
{
	struct irq_data *irq_entry = arg;

	irq_entry->handler(irq_entry->irq, irq_entry->dev_id);
}

/*
 * dev is a struct drm_device*
 * returns: zero on success, non-zero on failure
 */
int
request_irq(unsigned int irq, irq_handler_t handler,
	    unsigned long flags, const char *name, void *dev)
{
	int error;
	struct irq_data *irq_entry;
	struct drm_device *ddev = dev;
	device_t bdev = ddev->dev->bsddev;

	irq_entry = kmalloc(sizeof(*irq_entry), M_DRM, M_WAITOK);

	/* From drm_init_pdev() */
	irq_entry->rid = ddev->pdev->_irqrid;
	irq_entry->resource = ddev->pdev->_irqr;

	irq_entry->irq = irq;
	irq_entry->dev_id = dev;
	irq_entry->handler = handler;
	irq_entry->name = name;
	lwkt_serialize_init(&irq_entry->irq_lock);

	error = bus_setup_intr(bdev, irq_entry->resource, INTR_MPSAFE,
	    linux_irq_handler, irq_entry, &irq_entry->cookiep,
	    &irq_entry->irq_lock);
	if (error) {
		kprintf("request_irq: failed in bus_setup_intr()\n");
		bus_release_resource(bdev, SYS_RES_IRQ,
		    irq_entry->rid, irq_entry->resource);
		if (ddev->pdev->_irq_type == PCI_INTR_TYPE_MSI) {
			pci_release_msi(bdev);
			ddev->pdev->_irq_type = 0;
		}
		ddev->pdev->_irqr = NULL;
		kfree(irq_entry);
		return -error;
	}
	lockmgr(&irqdata_lock, LK_EXCLUSIVE);
	SLIST_INSERT_HEAD(&irq_list, irq_entry, id_irq_entries);
	lockmgr(&irqdata_lock, LK_RELEASE);

	return 0;
}

/* dev_id is a struct drm_device* */
void
free_irq(unsigned int irq, void *dev_id)
{
	struct irq_data *irq_entry, *tmp_ie;
	struct drm_device *ddev = dev_id;
	device_t bsddev = ddev->dev->bsddev;
	struct resource *res = ddev->pdev->_irqr;
	int found = 0;

	SLIST_FOREACH_MUTABLE(irq_entry, &irq_list, id_irq_entries, tmp_ie) {
		if ((irq_entry->irq == irq) && (irq_entry->dev_id == dev_id)) {
			found = 1;
			break;
		}
	}

	if (!found) {
		kprintf("free_irq: irq %d for dev_id %p was not registered\n",
		    irq, dev_id);
		return;
	}

	bus_teardown_intr(bsddev, res, irq_entry->cookiep);
	bus_release_resource(bsddev, SYS_RES_IRQ, irq_entry->rid, res);
	if (ddev->pdev->_irq_type == PCI_INTR_TYPE_MSI) {
		pci_release_msi(bsddev);
		ddev->pdev->_irq_type = 0;
	}
	ddev->pdev->_irqr = NULL;

	lockmgr(&irqdata_lock, LK_EXCLUSIVE);
	SLIST_REMOVE(&irq_list, irq_entry, irq_data, id_irq_entries);
	lockmgr(&irqdata_lock, LK_RELEASE);
	kfree(irq_entry);
}

void
disable_irq(unsigned int irq)
{
	struct irq_data *irq_entry;
	struct drm_device *ddev;
	device_t bsddev;

	SLIST_FOREACH(irq_entry, &irq_list, id_irq_entries) {
		if (irq_entry->irq == irq)
			break;
	}

	kprintf("disabling irq %d\n", irq);

	ddev = irq_entry->dev_id;
	bsddev = ddev->dev->bsddev;
	bus_teardown_intr(bsddev, irq_entry->resource, irq_entry->cookiep);
}

void
enable_irq(unsigned int irq)
{
	struct irq_data *irq_entry;
	struct drm_device *ddev;
	device_t bsddev;

	SLIST_FOREACH(irq_entry, &irq_list, id_irq_entries) {
		if (irq_entry->irq == irq)
			break;
	}

	kprintf("enabling irq %d\n", irq);

	ddev = irq_entry->dev_id;
	bsddev = ddev->dev->bsddev;
	bus_setup_intr(bsddev, irq_entry->resource, INTR_MPSAFE,
	    linux_irq_handler, irq_entry, &irq_entry->cookiep,
	    &irq_entry->irq_lock);
}