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