/*
 * Simple driver for userspace access to inter-VM interrupts under the OKL4
 * Microvisor.
 *
 * Copyright (c) 2016 Cog Systems Pty Ltd.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 */
#include <linux/init.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/cdev.h>
#include <linux/of.h>
#include <linux/fs.h>
#include <linux/poll.h>
#include <linux/sched.h>
#include <linux/wait.h>
#include <linux/sysfs.h>
#include <linux/interrupt.h>
#include <linux/bitmap.h>
#include <linux/version.h>
#include <microvisor/microvisor.h>
#include <asm-generic/okl4_virq.h>

/* Linux version compatibility */
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,11,0)
#define DEVICE_ATTR_RO(_name) \
	struct device_attribute dev_attr_##_name = __ATTR_RO(_name)
#define OLD_ATTRS
#endif

#define VIRQ_MINORBITS	9

#define VIRQ_MINORS	(1 << VIRQ_MINORBITS)
#define VIRQ_MINOR_MAX	(VIRQ_MINORS - 1)

struct virq_data {
	wait_queue_head_t wq;

	int irqno;

	bool raised;
	unsigned long payload;
};

struct source_data {
	okl4_kcap_t kcap;
};

struct virq_device {
	struct device *dev;
	struct cdev cdev;

	int type;
	struct virq_data virq;
	struct source_data source;

	int minor;
	const char *label;
};

static irqreturn_t okl4_virq_handler(int irq, void *dev_id)
{
	struct virq_device *dev = dev_id;
	unsigned long payload = okl4_get_virq_payload(irq);

	dev->virq.payload |= payload;
	smp_wmb();
	dev->virq.raised = true;

	wake_up_interruptible(&dev->virq.wq);
	return IRQ_HANDLED;
}

static int virq_dev_open(struct inode *inode, struct file *file)
{
	struct virq_device *dev;

	dev = container_of(inode->i_cdev, struct virq_device, cdev);
	if (!dev)
		return -ENODEV;

	file->private_data = dev;

	return nonseekable_open(inode, file);
}

static int virq_dev_release(struct inode *inode, struct file *file)
{
	return 0;
}

static ssize_t virq_read(struct file *file, char __user *buf, size_t length,
			loff_t *off)
{
	struct virq_device *dev = file->private_data;
	unsigned long payload;
	int ret;

	if (!dev->virq.raised && (file->f_flags & O_NONBLOCK)) {
		ret = -EAGAIN;
		goto err_wait;
	}

	do {
		ret = wait_event_interruptible(dev->virq.wq, dev->virq.raised);
		if (ret < 0)
			goto err_wait;
	} while(!xchg(&dev->virq.raised, 0));

	smp_rmb();
	payload = xchg(&dev->virq.payload, 0);

	if (length >= sizeof(payload)) {
		if (copy_to_user(buf, &payload, sizeof(payload))) {
			dev_dbg(dev->dev, "failed to copy data to userland\n");
			return -EFAULT;
		}
		length = sizeof(payload);
	} else if (length != 0) {
		return -EIO;
	}

	return length;

err_wait:
	return ret;
}

static unsigned int virq_poll(struct file *file, poll_table *table)
{
	int mask = 0;
	struct virq_device *dev = file->private_data;

	poll_wait(file, &dev->virq.wq, table);

	if (dev->virq.raised)
		mask |= POLLIN | POLLRDNORM;

	return mask;
}

static ssize_t source_write(struct file *file, const char __user *ubuf,
			 size_t length, loff_t *offset)
{
	struct virq_device *dev = file->private_data;
	okl4_error_t err;
	unsigned long payload;

	if (length == 0)
		payload = 0;
	else if (length == sizeof(payload)) {
		if (copy_from_user(&payload, ubuf, length)) {
			dev_dbg(dev->dev, "failed to copy data from userland\n");
			return -EFAULT;
		}
	} else {
		return -EIO;
	}

	err =_okl4_sys_vinterrupt_raise(dev->source.kcap, payload);
	if (err != OKL4_OK) {
		dev_dbg(dev->dev, "failed to raise virtual interrupt\n");
		return  -EIO;
	}

	return length;
}

static ssize_t is_virq_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct virq_device *priv = dev_get_drvdata(dev);

	return scnprintf(buf, PAGE_SIZE, "%d\n", priv->virq.irqno >= 0);
}

static ssize_t is_source_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct virq_device *priv = dev_get_drvdata(dev);

	return scnprintf(buf, PAGE_SIZE, "%d\n",
			priv->source.kcap != OKL4_KCAP_INVALID);
}

static ssize_t label_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct virq_device *priv = dev_get_drvdata(dev);

	return scnprintf(buf, PAGE_SIZE, "%s\n", priv->label);
}

/* Device registration */

/*
 * file operations structure will be used for virq device.
 */
static const struct file_operations virq_r_fops = {
	.owner = THIS_MODULE,
	.open = virq_dev_open,
	.release = virq_dev_release,
	.read = virq_read,
	.poll = virq_poll,
};

/*
 * file operations structure will be used for virtual_interrupt_line device.
 */
static const struct file_operations virq_w_fops = {
	.owner = THIS_MODULE,
	.open = virq_dev_open,
	.release = virq_dev_release,
	.write = source_write,
};

/*
 * file operations structure will be used for combined virq+source device.
 */
static const struct file_operations virq_rw_fops = {
	.owner = THIS_MODULE,
	.open = virq_dev_open,
	.release = virq_dev_release,
	.read = virq_read,
	.poll = virq_poll,
	.write = source_write,
};

#ifndef OLD_ATTRS
static DEVICE_ATTR_RO(is_virq);
static DEVICE_ATTR_RO(is_source);
static DEVICE_ATTR_RO(label);

static struct attribute *virq_attrs[] = {
	&dev_attr_is_virq.attr,
	&dev_attr_is_source.attr,
	&dev_attr_label.attr,
	NULL
};
ATTRIBUTE_GROUPS(virq);
#else
static struct device_attribute virq_attrs[] = {
	__ATTR(is_virq, S_IRUGO, is_virq_show, NULL),
	__ATTR(is_source, S_IRUGO, is_source_show, NULL),
	__ATTR(label, S_IRUGO, label_show, NULL),
	__ATTR_NULL,
};
#endif

static struct class *virq_class;
static dev_t virq_devt;
static DEFINE_MUTEX(virq_minor_lock);
unsigned long virq_ids[BITS_TO_LONGS(VIRQ_MINORBITS)];

/**
 * virq_minor_get - obtain next free device minor number
 *
 * @dev:  device pointer
 *
 * Return: allocated minor, or -ENOSPC if no free minor left
 */
static int virq_minor_get(struct virq_device *dev)
{
	int ret;

	mutex_lock(&virq_minor_lock);

	ret = find_first_zero_bit(virq_ids, VIRQ_MINORS);

	if (ret >= VIRQ_MINORS) {
		dev_err(dev->dev, "too many virq devices\n");
		ret = -ENODEV;
	} else {
		dev->minor = ret;
		set_bit(ret, virq_ids);
		ret = 0;
	}
	mutex_unlock(&virq_minor_lock);
	return ret;
}

/**
 * virq_minor_free - mark device minor number as free
 *
 * @dev:  device pointer
 */
static void virq_minor_free(struct virq_device *dev)
{
	mutex_lock(&virq_minor_lock);
	clear_bit(dev->minor, virq_ids);
	mutex_unlock(&virq_minor_lock);
}

static void virq_dev_deregister(struct virq_device *dev)
{
	int devno;

	devno = dev->cdev.dev;
	cdev_del(&dev->cdev);

	device_destroy(virq_class, devno);

	virq_minor_free(dev);
}

static int okl4_virq_probe(struct platform_device *pdev)
{
	int ret, devno, irq;
	okl4_kcap_t kcap;
	struct virq_device *dev;
	struct device *parent;
	struct device *clsdev; /* class device */
	const struct file_operations *fops;
	struct device_node *node;
	char devname[32];

	parent = &pdev->dev;
	node = parent->of_node;

	dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
	if (!dev)
		return -ENOMEM;

	dev->virq.raised = false;
	dev->virq.payload = 0;

	irq = platform_get_irq(pdev, 0);
	dev->virq.irqno = irq;

	init_waitqueue_head(&dev->virq.wq);

	ret = virq_minor_get(dev);
	if (ret < 0)
		goto err;

	if (irq >= 0) {
		ret = devm_request_irq(parent, irq, okl4_virq_handler,
				IRQF_TRIGGER_RISING, dev_name(parent), dev);
		if (ret < 0)
			goto err_free_minor;
	}

	kcap = OKL4_KCAP_INVALID;
	if (of_device_is_compatible(node, "okl,microvisor-interrupt-line")) {
		ret = of_property_read_u32(node, "reg", &kcap);
		if (ret < 0)
			goto err_free_minor;
	}
	dev->source.kcap = kcap;

	ret = of_property_read_string(node, "label", &dev->label);
	if (ret)
		dev->label = NULL;

	/* Fill in the data structures */
	devno = MKDEV(MAJOR(virq_devt), dev->minor);

	ret = -ENODEV;
	if (irq >= 0 && kcap != OKL4_KCAP_INVALID)
		fops = &virq_rw_fops;
	else if (irq >= 0)
		fops = &virq_r_fops;
	else if (kcap != OKL4_KCAP_INVALID)
		fops = &virq_w_fops;
	else
		goto err_free_minor;

	cdev_init(&dev->cdev, fops);
	dev->cdev.owner = fops->owner;

	/* Add the device */
	ret = cdev_add(&dev->cdev, devno, 1);
	if (ret) {
		dev_err(parent, "unable to add device %d:%d\n",
			MAJOR(virq_devt), dev->minor);
		goto err_free_minor;
	}

	scnprintf(devname, sizeof(devname), "virq%d", dev->minor);
#ifndef OLD_ATTRS
	clsdev = device_create_with_groups(virq_class, parent, devno, dev,
			virq_groups, devname, dev->minor);
#else
	clsdev = device_create(virq_class, parent, devno, dev, devname,
			dev->minor);
#endif
	if (IS_ERR(clsdev)) {
		dev_err(parent, "unable to create device %d:%d\n",
			MAJOR(virq_devt), dev->minor);
		ret = PTR_ERR(clsdev);
		goto err_dev_create;
	}

	dev_set_drvdata(parent, dev);

	return 0;

err_dev_create:
	cdev_del(&dev->cdev);
err_free_minor:
	virq_minor_free(dev);
err:
	devm_kfree(&pdev->dev, dev);
	return ret;
}

static int okl4_virq_remove(struct platform_device *pdev)
{
	struct virq_device *priv = dev_get_drvdata(&pdev->dev);

	virq_dev_deregister(priv);

	return 0;
}

/* Driver registration */

static const struct of_device_id of_plat_virq_table[] = {
	{ .compatible = "okl,user-virq" },
	{ /* end */ },
};

static struct platform_driver of_plat_virq_driver = {
	.driver = {
		.name = "okl4_virq",
		.owner = THIS_MODULE,
		.of_match_table = of_plat_virq_table,
	},
	.probe = okl4_virq_probe,
	.remove = okl4_virq_remove,
};

static int __init okl4_virq_init(void)
{
	int ret;

	memset(virq_ids, 0, sizeof(virq_ids));

	virq_class = class_create(THIS_MODULE, "okl4_virq");
	if (IS_ERR(virq_class)) {
		pr_err("failed to create class\n");
		ret = PTR_ERR(virq_class);
		goto err;
	}
#ifdef OLD_ATTRS
	virq_class->dev_attrs = virq_attrs;
#endif

	ret = alloc_chrdev_region(&virq_devt, 0, MINORMASK, "okl4_virq");
	if (ret < 0) {
		pr_err("failed to allocate char dev region\n");
		goto err_class;
	}

	ret = platform_driver_register(&of_plat_virq_driver);
	if (ret)
		goto err_virq_driver;

	return 0;

err_virq_driver:
	unregister_chrdev_region(virq_devt, MINORMASK);
err_class:
	class_destroy(virq_class);
err:
	return ret;
}

static void __exit okl4_virq_exit(void)
{
	platform_driver_unregister(&of_plat_virq_driver);

	unregister_chrdev_region(virq_devt, MINORMASK);
	class_destroy(virq_class);
}

module_init(okl4_virq_init);
module_exit(okl4_virq_exit);

MODULE_AUTHOR("Cog Systems Pty Ltd");
MODULE_DESCRIPTION("OKL4 userspace VIRQ interface");