[linux-block.git] / drivers / vfio / fsl-mc / vfio_fsl_mc_intr.c

// SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
/*
 * Copyright 2013-2016 Freescale Semiconductor Inc.
 * Copyright 2019 NXP
 */

#include <linux/vfio.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/eventfd.h>

#include "linux/fsl/mc.h"
#include "vfio_fsl_mc_private.h"

static int vfio_fsl_mc_irqs_allocate(struct vfio_fsl_mc_device *vdev)
{
	struct fsl_mc_device *mc_dev = vdev->mc_dev;
	struct vfio_fsl_mc_irq *mc_irq;
	int irq_count;
	int ret, i;

	/* Device does not support any interrupt */
	if (mc_dev->obj_desc.irq_count == 0)
		return 0;

	/* interrupts were already allocated for this device */
	if (vdev->mc_irqs)
		return 0;

	irq_count = mc_dev->obj_desc.irq_count;

	mc_irq = kcalloc(irq_count, sizeof(*mc_irq), GFP_KERNEL_ACCOUNT);
	if (!mc_irq)
		return -ENOMEM;

	/* Allocate IRQs */
	ret = fsl_mc_allocate_irqs(mc_dev);
	if (ret) {
		kfree(mc_irq);
		return ret;
	}

	for (i = 0; i < irq_count; i++) {
		mc_irq[i].count = 1;
		mc_irq[i].flags = VFIO_IRQ_INFO_EVENTFD;
	}

	vdev->mc_irqs = mc_irq;

	return 0;
}

static irqreturn_t vfio_fsl_mc_irq_handler(int irq_num, void *arg)
{
	struct vfio_fsl_mc_irq *mc_irq = (struct vfio_fsl_mc_irq *)arg;

	eventfd_signal(mc_irq->trigger, 1);
	return IRQ_HANDLED;
}

static int vfio_set_trigger(struct vfio_fsl_mc_device *vdev,
						   int index, int fd)
{
	struct vfio_fsl_mc_irq *irq = &vdev->mc_irqs[index];
	struct eventfd_ctx *trigger;
	int hwirq;
	int ret;

	hwirq = vdev->mc_dev->irqs[index]->virq;
	if (irq->trigger) {
		free_irq(hwirq, irq);
		kfree(irq->name);
		eventfd_ctx_put(irq->trigger);
		irq->trigger = NULL;
	}

	if (fd < 0) /* Disable only */
		return 0;

	irq->name = kasprintf(GFP_KERNEL_ACCOUNT, "vfio-irq[%d](%s)",
			    hwirq, dev_name(&vdev->mc_dev->dev));
	if (!irq->name)
		return -ENOMEM;

	trigger = eventfd_ctx_fdget(fd);
	if (IS_ERR(trigger)) {
		kfree(irq->name);
		return PTR_ERR(trigger);
	}

	irq->trigger = trigger;

	ret = request_irq(hwirq, vfio_fsl_mc_irq_handler, 0,
		  irq->name, irq);
	if (ret) {
		kfree(irq->name);
		eventfd_ctx_put(trigger);
		irq->trigger = NULL;
		return ret;
	}

	return 0;
}

static int vfio_fsl_mc_set_irq_trigger(struct vfio_fsl_mc_device *vdev,
				       unsigned int index, unsigned int start,
				       unsigned int count, u32 flags,
				       void *data)
{
	struct fsl_mc_device *mc_dev = vdev->mc_dev;
	int ret, hwirq;
	struct vfio_fsl_mc_irq *irq;
	struct device *cont_dev = fsl_mc_cont_dev(&mc_dev->dev);
	struct fsl_mc_device *mc_cont = to_fsl_mc_device(cont_dev);

	if (!count && (flags & VFIO_IRQ_SET_DATA_NONE))
		return vfio_set_trigger(vdev, index, -1);

	if (start != 0 || count != 1)
		return -EINVAL;

	mutex_lock(&vdev->vdev.dev_set->lock);
	ret = fsl_mc_populate_irq_pool(mc_cont,
			FSL_MC_IRQ_POOL_MAX_TOTAL_IRQS);
	if (ret)
		goto unlock;

	ret = vfio_fsl_mc_irqs_allocate(vdev);
	if (ret)
		goto unlock;
	mutex_unlock(&vdev->vdev.dev_set->lock);

	if (flags & VFIO_IRQ_SET_DATA_EVENTFD) {
		s32 fd = *(s32 *)data;

		return vfio_set_trigger(vdev, index, fd);
	}

	hwirq = vdev->mc_dev->irqs[index]->virq;

	irq = &vdev->mc_irqs[index];

	if (flags & VFIO_IRQ_SET_DATA_NONE) {
		vfio_fsl_mc_irq_handler(hwirq, irq);

	} else if (flags & VFIO_IRQ_SET_DATA_BOOL) {
		u8 trigger = *(u8 *)data;

		if (trigger)
			vfio_fsl_mc_irq_handler(hwirq, irq);
	}

	return 0;

unlock:
	mutex_unlock(&vdev->vdev.dev_set->lock);
	return ret;

}

int vfio_fsl_mc_set_irqs_ioctl(struct vfio_fsl_mc_device *vdev,
			       u32 flags, unsigned int index,
			       unsigned int start, unsigned int count,
			       void *data)
{
	if (flags & VFIO_IRQ_SET_ACTION_TRIGGER)
		return  vfio_fsl_mc_set_irq_trigger(vdev, index, start,
			  count, flags, data);
	else
		return -EINVAL;
}

/* Free All IRQs for the given MC object */
void vfio_fsl_mc_irqs_cleanup(struct vfio_fsl_mc_device *vdev)
{
	struct fsl_mc_device *mc_dev = vdev->mc_dev;
	int irq_count = mc_dev->obj_desc.irq_count;
	int i;

	/*
	 * Device does not support any interrupt or the interrupts
	 * were not configured
	 */
	if (!vdev->mc_irqs)
		return;

	for (i = 0; i < irq_count; i++)
		vfio_set_trigger(vdev, i, -1);

	fsl_mc_free_irqs(mc_dev);
	kfree(vdev->mc_irqs);
	vdev->mc_irqs = NULL;
}
Commit	Line	Data
2e0d2956 DC	1	// SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
	2	/*
	3	* Copyright 2013-2016 Freescale Semiconductor Inc.
	4	* Copyright 2019 NXP
	5	*/
	6
	7	#include <linux/vfio.h>
	8	#include <linux/slab.h>
	9	#include <linux/types.h>
	10	#include <linux/eventfd.h>
2e0d2956 DC	11
	12	#include "linux/fsl/mc.h"
	13	#include "vfio_fsl_mc_private.h"
	14
8e91cb38	15	static int vfio_fsl_mc_irqs_allocate(struct vfio_fsl_mc_device *vdev)
cc0ee20b DC	16	{
	17	struct fsl_mc_device *mc_dev = vdev->mc_dev;
	18	struct vfio_fsl_mc_irq *mc_irq;
	19	int irq_count;
	20	int ret, i;
	21
	22	/* Device does not support any interrupt */
	23	if (mc_dev->obj_desc.irq_count == 0)
	24	return 0;
	25
	26	/* interrupts were already allocated for this device */
	27	if (vdev->mc_irqs)
	28	return 0;
	29
	30	irq_count = mc_dev->obj_desc.irq_count;
	31
4a6c971a	32	mc_irq = kcalloc(irq_count, sizeof(*mc_irq), GFP_KERNEL_ACCOUNT);
cc0ee20b DC	33	if (!mc_irq)
	34	return -ENOMEM;
	35
	36	/* Allocate IRQs */
	37	ret = fsl_mc_allocate_irqs(mc_dev);
	38	if (ret) {
	39	kfree(mc_irq);
	40	return ret;
	41	}
	42
	43	for (i = 0; i < irq_count; i++) {
	44	mc_irq[i].count = 1;
	45	mc_irq[i].flags = VFIO_IRQ_INFO_EVENTFD;
	46	}
	47
	48	vdev->mc_irqs = mc_irq;
	49
	50	return 0;
	51	}
	52
	53	static irqreturn_t vfio_fsl_mc_irq_handler(int irq_num, void *arg)
	54	{
	55	struct vfio_fsl_mc_irq mc_irq = (struct vfio_fsl_mc_irq )arg;
	56
	57	eventfd_signal(mc_irq->trigger, 1);
	58	return IRQ_HANDLED;
	59	}
	60
	61	static int vfio_set_trigger(struct vfio_fsl_mc_device *vdev,
	62	int index, int fd)
	63	{
	64	struct vfio_fsl_mc_irq *irq = &vdev->mc_irqs[index];
	65	struct eventfd_ctx *trigger;
	66	int hwirq;
	67	int ret;
	68
d86a6d47	69	hwirq = vdev->mc_dev->irqs[index]->virq;
cc0ee20b DC	70	if (irq->trigger) {
	71	free_irq(hwirq, irq);
	72	kfree(irq->name);
	73	eventfd_ctx_put(irq->trigger);
	74	irq->trigger = NULL;
	75	}
	76
	77	if (fd < 0) /* Disable only */
	78	return 0;
	79
4a6c971a	80	irq->name = kasprintf(GFP_KERNEL_ACCOUNT, "vfio-irq[%d](%s)",
cc0ee20b DC	81	hwirq, dev_name(&vdev->mc_dev->dev));
	82	if (!irq->name)
	83	return -ENOMEM;
	84
	85	trigger = eventfd_ctx_fdget(fd);
	86	if (IS_ERR(trigger)) {
	87	kfree(irq->name);
	88	return PTR_ERR(trigger);
	89	}
	90
	91	irq->trigger = trigger;
	92
	93	ret = request_irq(hwirq, vfio_fsl_mc_irq_handler, 0,
	94	irq->name, irq);
	95	if (ret) {
	96	kfree(irq->name);
	97	eventfd_ctx_put(trigger);
	98	irq->trigger = NULL;
	99	return ret;
	100	}
	101
	102	return 0;
	103	}
	104
2e0d2956 DC	105	static int vfio_fsl_mc_set_irq_trigger(struct vfio_fsl_mc_device *vdev,
	106	unsigned int index, unsigned int start,
	107	unsigned int count, u32 flags,
	108	void *data)
	109	{
cc0ee20b DC	110	struct fsl_mc_device *mc_dev = vdev->mc_dev;
	111	int ret, hwirq;
	112	struct vfio_fsl_mc_irq *irq;
	113	struct device *cont_dev = fsl_mc_cont_dev(&mc_dev->dev);
	114	struct fsl_mc_device *mc_cont = to_fsl_mc_device(cont_dev);
	115
15924637 DC	116	if (!count && (flags & VFIO_IRQ_SET_DATA_NONE))
	117	return vfio_set_trigger(vdev, index, -1);
	118
cc0ee20b DC	119	if (start != 0 \|\| count != 1)
	120	return -EINVAL;
	121
da119f38	122	mutex_lock(&vdev->vdev.dev_set->lock);
cc0ee20b DC	123	ret = fsl_mc_populate_irq_pool(mc_cont,
	124	FSL_MC_IRQ_POOL_MAX_TOTAL_IRQS);
	125	if (ret)
	126	goto unlock;
	127
	128	ret = vfio_fsl_mc_irqs_allocate(vdev);
	129	if (ret)
	130	goto unlock;
da119f38	131	mutex_unlock(&vdev->vdev.dev_set->lock);
cc0ee20b	132
cc0ee20b DC	133	if (flags & VFIO_IRQ_SET_DATA_EVENTFD) {
	134	s32 fd = (s32 )data;
	135
	136	return vfio_set_trigger(vdev, index, fd);
	137	}
	138
d86a6d47	139	hwirq = vdev->mc_dev->irqs[index]->virq;
cc0ee20b DC	140
	141	irq = &vdev->mc_irqs[index];
	142
	143	if (flags & VFIO_IRQ_SET_DATA_NONE) {
	144	vfio_fsl_mc_irq_handler(hwirq, irq);
	145
	146	} else if (flags & VFIO_IRQ_SET_DATA_BOOL) {
	147	u8 trigger = (u8 )data;
	148
	149	if (trigger)
	150	vfio_fsl_mc_irq_handler(hwirq, irq);
	151	}
	152
	153	return 0;
	154
	155	unlock:
da119f38	156	mutex_unlock(&vdev->vdev.dev_set->lock);
cc0ee20b DC	157	return ret;
cc0ee20b DC	158
2e0d2956 DC	159	}
	160
	161	int vfio_fsl_mc_set_irqs_ioctl(struct vfio_fsl_mc_device *vdev,
	162	u32 flags, unsigned int index,
	163	unsigned int start, unsigned int count,
	164	void *data)
	165	{
	166	if (flags & VFIO_IRQ_SET_ACTION_TRIGGER)
	167	return vfio_fsl_mc_set_irq_trigger(vdev, index, start,
	168	count, flags, data);
	169	else
	170	return -EINVAL;
	171	}
cc0ee20b DC	172
	173	/* Free All IRQs for the given MC object */
	174	void vfio_fsl_mc_irqs_cleanup(struct vfio_fsl_mc_device *vdev)
	175	{
	176	struct fsl_mc_device *mc_dev = vdev->mc_dev;
	177	int irq_count = mc_dev->obj_desc.irq_count;
	178	int i;
	179
	180	/*
	181	* Device does not support any interrupt or the interrupts
	182	* were not configured
	183	*/
	184	if (!vdev->mc_irqs)
	185	return;
	186
	187	for (i = 0; i < irq_count; i++)
	188	vfio_set_trigger(vdev, i, -1);
	189
	190	fsl_mc_free_irqs(mc_dev);
	191	kfree(vdev->mc_irqs);
	192	vdev->mc_irqs = NULL;
	193	}