Antonios Motakis | 682704c | 2015-03-16 14:08:48 -0600 | [diff] [blame] | 1 | /* |
| 2 | * VFIO platform devices interrupt handling |
| 3 | * |
| 4 | * Copyright (C) 2013 - Virtual Open Systems |
| 5 | * Author: Antonios Motakis <a.motakis@virtualopensystems.com> |
| 6 | * |
| 7 | * This program is free software; you can redistribute it and/or modify |
| 8 | * it under the terms of the GNU General Public License, version 2, as |
| 9 | * published by the Free Software Foundation. |
| 10 | * |
| 11 | * This program is distributed in the hope that it will be useful, |
| 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 | * GNU General Public License for more details. |
| 15 | */ |
| 16 | |
| 17 | #include <linux/eventfd.h> |
| 18 | #include <linux/interrupt.h> |
| 19 | #include <linux/slab.h> |
| 20 | #include <linux/types.h> |
| 21 | #include <linux/vfio.h> |
| 22 | #include <linux/irq.h> |
| 23 | |
| 24 | #include "vfio_platform_private.h" |
| 25 | |
Antonios Motakis | 06211b4 | 2015-03-16 14:08:50 -0600 | [diff] [blame] | 26 | static void vfio_platform_mask(struct vfio_platform_irq *irq_ctx) |
| 27 | { |
| 28 | unsigned long flags; |
| 29 | |
| 30 | spin_lock_irqsave(&irq_ctx->lock, flags); |
| 31 | |
| 32 | if (!irq_ctx->masked) { |
| 33 | disable_irq_nosync(irq_ctx->hwirq); |
| 34 | irq_ctx->masked = true; |
| 35 | } |
| 36 | |
| 37 | spin_unlock_irqrestore(&irq_ctx->lock, flags); |
| 38 | } |
| 39 | |
Antonios Motakis | a7fa7c7 | 2015-03-16 14:08:55 -0600 | [diff] [blame] | 40 | static int vfio_platform_mask_handler(void *opaque, void *unused) |
| 41 | { |
| 42 | struct vfio_platform_irq *irq_ctx = opaque; |
| 43 | |
| 44 | vfio_platform_mask(irq_ctx); |
| 45 | |
| 46 | return 0; |
| 47 | } |
| 48 | |
Antonios Motakis | 9a36321 | 2015-03-16 14:08:49 -0600 | [diff] [blame] | 49 | static int vfio_platform_set_irq_mask(struct vfio_platform_device *vdev, |
| 50 | unsigned index, unsigned start, |
| 51 | unsigned count, uint32_t flags, |
| 52 | void *data) |
| 53 | { |
Antonios Motakis | 06211b4 | 2015-03-16 14:08:50 -0600 | [diff] [blame] | 54 | if (start != 0 || count != 1) |
| 55 | return -EINVAL; |
| 56 | |
| 57 | if (!(vdev->irqs[index].flags & VFIO_IRQ_INFO_MASKABLE)) |
| 58 | return -EINVAL; |
| 59 | |
Antonios Motakis | a7fa7c7 | 2015-03-16 14:08:55 -0600 | [diff] [blame] | 60 | if (flags & VFIO_IRQ_SET_DATA_EVENTFD) { |
| 61 | int32_t fd = *(int32_t *)data; |
| 62 | |
| 63 | if (fd >= 0) |
| 64 | return vfio_virqfd_enable((void *) &vdev->irqs[index], |
| 65 | vfio_platform_mask_handler, |
| 66 | NULL, NULL, |
| 67 | &vdev->irqs[index].mask, fd); |
| 68 | |
| 69 | vfio_virqfd_disable(&vdev->irqs[index].mask); |
| 70 | return 0; |
| 71 | } |
Antonios Motakis | 06211b4 | 2015-03-16 14:08:50 -0600 | [diff] [blame] | 72 | |
| 73 | if (flags & VFIO_IRQ_SET_DATA_NONE) { |
| 74 | vfio_platform_mask(&vdev->irqs[index]); |
| 75 | |
| 76 | } else if (flags & VFIO_IRQ_SET_DATA_BOOL) { |
| 77 | uint8_t mask = *(uint8_t *)data; |
| 78 | |
| 79 | if (mask) |
| 80 | vfio_platform_mask(&vdev->irqs[index]); |
| 81 | } |
| 82 | |
| 83 | return 0; |
| 84 | } |
| 85 | |
| 86 | static void vfio_platform_unmask(struct vfio_platform_irq *irq_ctx) |
| 87 | { |
| 88 | unsigned long flags; |
| 89 | |
| 90 | spin_lock_irqsave(&irq_ctx->lock, flags); |
| 91 | |
| 92 | if (irq_ctx->masked) { |
| 93 | enable_irq(irq_ctx->hwirq); |
| 94 | irq_ctx->masked = false; |
| 95 | } |
| 96 | |
| 97 | spin_unlock_irqrestore(&irq_ctx->lock, flags); |
Antonios Motakis | 9a36321 | 2015-03-16 14:08:49 -0600 | [diff] [blame] | 98 | } |
| 99 | |
Antonios Motakis | a7fa7c7 | 2015-03-16 14:08:55 -0600 | [diff] [blame] | 100 | static int vfio_platform_unmask_handler(void *opaque, void *unused) |
| 101 | { |
| 102 | struct vfio_platform_irq *irq_ctx = opaque; |
| 103 | |
| 104 | vfio_platform_unmask(irq_ctx); |
| 105 | |
| 106 | return 0; |
| 107 | } |
| 108 | |
Antonios Motakis | 9a36321 | 2015-03-16 14:08:49 -0600 | [diff] [blame] | 109 | static int vfio_platform_set_irq_unmask(struct vfio_platform_device *vdev, |
| 110 | unsigned index, unsigned start, |
| 111 | unsigned count, uint32_t flags, |
| 112 | void *data) |
| 113 | { |
Antonios Motakis | 06211b4 | 2015-03-16 14:08:50 -0600 | [diff] [blame] | 114 | if (start != 0 || count != 1) |
| 115 | return -EINVAL; |
| 116 | |
| 117 | if (!(vdev->irqs[index].flags & VFIO_IRQ_INFO_MASKABLE)) |
| 118 | return -EINVAL; |
| 119 | |
Antonios Motakis | a7fa7c7 | 2015-03-16 14:08:55 -0600 | [diff] [blame] | 120 | if (flags & VFIO_IRQ_SET_DATA_EVENTFD) { |
| 121 | int32_t fd = *(int32_t *)data; |
| 122 | |
| 123 | if (fd >= 0) |
| 124 | return vfio_virqfd_enable((void *) &vdev->irqs[index], |
| 125 | vfio_platform_unmask_handler, |
| 126 | NULL, NULL, |
| 127 | &vdev->irqs[index].unmask, |
| 128 | fd); |
| 129 | |
| 130 | vfio_virqfd_disable(&vdev->irqs[index].unmask); |
| 131 | return 0; |
| 132 | } |
Antonios Motakis | 06211b4 | 2015-03-16 14:08:50 -0600 | [diff] [blame] | 133 | |
| 134 | if (flags & VFIO_IRQ_SET_DATA_NONE) { |
| 135 | vfio_platform_unmask(&vdev->irqs[index]); |
| 136 | |
| 137 | } else if (flags & VFIO_IRQ_SET_DATA_BOOL) { |
| 138 | uint8_t unmask = *(uint8_t *)data; |
| 139 | |
| 140 | if (unmask) |
| 141 | vfio_platform_unmask(&vdev->irqs[index]); |
| 142 | } |
| 143 | |
| 144 | return 0; |
| 145 | } |
| 146 | |
| 147 | static irqreturn_t vfio_automasked_irq_handler(int irq, void *dev_id) |
| 148 | { |
| 149 | struct vfio_platform_irq *irq_ctx = dev_id; |
| 150 | unsigned long flags; |
| 151 | int ret = IRQ_NONE; |
| 152 | |
| 153 | spin_lock_irqsave(&irq_ctx->lock, flags); |
| 154 | |
| 155 | if (!irq_ctx->masked) { |
| 156 | ret = IRQ_HANDLED; |
| 157 | |
| 158 | /* automask maskable interrupts */ |
| 159 | disable_irq_nosync(irq_ctx->hwirq); |
| 160 | irq_ctx->masked = true; |
| 161 | } |
| 162 | |
| 163 | spin_unlock_irqrestore(&irq_ctx->lock, flags); |
| 164 | |
| 165 | if (ret == IRQ_HANDLED) |
| 166 | eventfd_signal(irq_ctx->trigger, 1); |
| 167 | |
| 168 | return ret; |
Antonios Motakis | 9a36321 | 2015-03-16 14:08:49 -0600 | [diff] [blame] | 169 | } |
| 170 | |
Antonios Motakis | 57f972e | 2015-03-16 14:08:50 -0600 | [diff] [blame] | 171 | static irqreturn_t vfio_irq_handler(int irq, void *dev_id) |
| 172 | { |
| 173 | struct vfio_platform_irq *irq_ctx = dev_id; |
| 174 | |
| 175 | eventfd_signal(irq_ctx->trigger, 1); |
| 176 | |
| 177 | return IRQ_HANDLED; |
| 178 | } |
| 179 | |
| 180 | static int vfio_set_trigger(struct vfio_platform_device *vdev, int index, |
| 181 | int fd, irq_handler_t handler) |
| 182 | { |
| 183 | struct vfio_platform_irq *irq = &vdev->irqs[index]; |
| 184 | struct eventfd_ctx *trigger; |
| 185 | int ret; |
| 186 | |
| 187 | if (irq->trigger) { |
Eric Auger | 1276ece | 2015-10-14 15:32:56 +0000 | [diff] [blame] | 188 | irq_clear_status_flags(irq->hwirq, IRQ_NOAUTOEN); |
Antonios Motakis | 57f972e | 2015-03-16 14:08:50 -0600 | [diff] [blame] | 189 | free_irq(irq->hwirq, irq); |
| 190 | kfree(irq->name); |
| 191 | eventfd_ctx_put(irq->trigger); |
| 192 | irq->trigger = NULL; |
| 193 | } |
| 194 | |
| 195 | if (fd < 0) /* Disable only */ |
| 196 | return 0; |
| 197 | |
| 198 | irq->name = kasprintf(GFP_KERNEL, "vfio-irq[%d](%s)", |
| 199 | irq->hwirq, vdev->name); |
| 200 | if (!irq->name) |
| 201 | return -ENOMEM; |
| 202 | |
| 203 | trigger = eventfd_ctx_fdget(fd); |
| 204 | if (IS_ERR(trigger)) { |
| 205 | kfree(irq->name); |
| 206 | return PTR_ERR(trigger); |
| 207 | } |
| 208 | |
| 209 | irq->trigger = trigger; |
| 210 | |
Antonios Motakis | 06211b4 | 2015-03-16 14:08:50 -0600 | [diff] [blame] | 211 | irq_set_status_flags(irq->hwirq, IRQ_NOAUTOEN); |
Antonios Motakis | 57f972e | 2015-03-16 14:08:50 -0600 | [diff] [blame] | 212 | ret = request_irq(irq->hwirq, handler, 0, irq->name, irq); |
| 213 | if (ret) { |
| 214 | kfree(irq->name); |
| 215 | eventfd_ctx_put(trigger); |
| 216 | irq->trigger = NULL; |
| 217 | return ret; |
| 218 | } |
| 219 | |
Antonios Motakis | 06211b4 | 2015-03-16 14:08:50 -0600 | [diff] [blame] | 220 | if (!irq->masked) |
| 221 | enable_irq(irq->hwirq); |
| 222 | |
Antonios Motakis | 57f972e | 2015-03-16 14:08:50 -0600 | [diff] [blame] | 223 | return 0; |
| 224 | } |
| 225 | |
Antonios Motakis | 9a36321 | 2015-03-16 14:08:49 -0600 | [diff] [blame] | 226 | static int vfio_platform_set_irq_trigger(struct vfio_platform_device *vdev, |
| 227 | unsigned index, unsigned start, |
| 228 | unsigned count, uint32_t flags, |
| 229 | void *data) |
| 230 | { |
Antonios Motakis | 57f972e | 2015-03-16 14:08:50 -0600 | [diff] [blame] | 231 | struct vfio_platform_irq *irq = &vdev->irqs[index]; |
| 232 | irq_handler_t handler; |
| 233 | |
| 234 | if (vdev->irqs[index].flags & VFIO_IRQ_INFO_AUTOMASKED) |
Antonios Motakis | 06211b4 | 2015-03-16 14:08:50 -0600 | [diff] [blame] | 235 | handler = vfio_automasked_irq_handler; |
Antonios Motakis | 57f972e | 2015-03-16 14:08:50 -0600 | [diff] [blame] | 236 | else |
| 237 | handler = vfio_irq_handler; |
| 238 | |
| 239 | if (!count && (flags & VFIO_IRQ_SET_DATA_NONE)) |
| 240 | return vfio_set_trigger(vdev, index, -1, handler); |
| 241 | |
| 242 | if (start != 0 || count != 1) |
| 243 | return -EINVAL; |
| 244 | |
| 245 | if (flags & VFIO_IRQ_SET_DATA_EVENTFD) { |
| 246 | int32_t fd = *(int32_t *)data; |
| 247 | |
| 248 | return vfio_set_trigger(vdev, index, fd, handler); |
| 249 | } |
| 250 | |
| 251 | if (flags & VFIO_IRQ_SET_DATA_NONE) { |
| 252 | handler(irq->hwirq, irq); |
| 253 | |
| 254 | } else if (flags & VFIO_IRQ_SET_DATA_BOOL) { |
| 255 | uint8_t trigger = *(uint8_t *)data; |
| 256 | |
| 257 | if (trigger) |
| 258 | handler(irq->hwirq, irq); |
| 259 | } |
| 260 | |
| 261 | return 0; |
Antonios Motakis | 9a36321 | 2015-03-16 14:08:49 -0600 | [diff] [blame] | 262 | } |
| 263 | |
| 264 | int vfio_platform_set_irqs_ioctl(struct vfio_platform_device *vdev, |
| 265 | uint32_t flags, unsigned index, unsigned start, |
| 266 | unsigned count, void *data) |
| 267 | { |
| 268 | int (*func)(struct vfio_platform_device *vdev, unsigned index, |
| 269 | unsigned start, unsigned count, uint32_t flags, |
| 270 | void *data) = NULL; |
| 271 | |
| 272 | switch (flags & VFIO_IRQ_SET_ACTION_TYPE_MASK) { |
| 273 | case VFIO_IRQ_SET_ACTION_MASK: |
| 274 | func = vfio_platform_set_irq_mask; |
| 275 | break; |
| 276 | case VFIO_IRQ_SET_ACTION_UNMASK: |
| 277 | func = vfio_platform_set_irq_unmask; |
| 278 | break; |
| 279 | case VFIO_IRQ_SET_ACTION_TRIGGER: |
| 280 | func = vfio_platform_set_irq_trigger; |
| 281 | break; |
| 282 | } |
| 283 | |
| 284 | if (!func) |
| 285 | return -ENOTTY; |
| 286 | |
| 287 | return func(vdev, index, start, count, flags, data); |
| 288 | } |
| 289 | |
Antonios Motakis | 682704c | 2015-03-16 14:08:48 -0600 | [diff] [blame] | 290 | int vfio_platform_irq_init(struct vfio_platform_device *vdev) |
| 291 | { |
| 292 | int cnt = 0, i; |
| 293 | |
| 294 | while (vdev->get_irq(vdev, cnt) >= 0) |
| 295 | cnt++; |
| 296 | |
| 297 | vdev->irqs = kcalloc(cnt, sizeof(struct vfio_platform_irq), GFP_KERNEL); |
| 298 | if (!vdev->irqs) |
| 299 | return -ENOMEM; |
| 300 | |
| 301 | for (i = 0; i < cnt; i++) { |
Antonios Motakis | 9a36321 | 2015-03-16 14:08:49 -0600 | [diff] [blame] | 302 | int hwirq = vdev->get_irq(vdev, i); |
| 303 | |
| 304 | if (hwirq < 0) |
| 305 | goto err; |
| 306 | |
Antonios Motakis | 06211b4 | 2015-03-16 14:08:50 -0600 | [diff] [blame] | 307 | spin_lock_init(&vdev->irqs[i].lock); |
| 308 | |
Antonios Motakis | 57f972e | 2015-03-16 14:08:50 -0600 | [diff] [blame] | 309 | vdev->irqs[i].flags = VFIO_IRQ_INFO_EVENTFD; |
| 310 | |
| 311 | if (irq_get_trigger_type(hwirq) & IRQ_TYPE_LEVEL_MASK) |
| 312 | vdev->irqs[i].flags |= VFIO_IRQ_INFO_MASKABLE |
| 313 | | VFIO_IRQ_INFO_AUTOMASKED; |
| 314 | |
Antonios Motakis | 682704c | 2015-03-16 14:08:48 -0600 | [diff] [blame] | 315 | vdev->irqs[i].count = 1; |
Antonios Motakis | 9a36321 | 2015-03-16 14:08:49 -0600 | [diff] [blame] | 316 | vdev->irqs[i].hwirq = hwirq; |
Antonios Motakis | 06211b4 | 2015-03-16 14:08:50 -0600 | [diff] [blame] | 317 | vdev->irqs[i].masked = false; |
Antonios Motakis | 682704c | 2015-03-16 14:08:48 -0600 | [diff] [blame] | 318 | } |
| 319 | |
| 320 | vdev->num_irqs = cnt; |
| 321 | |
| 322 | return 0; |
Antonios Motakis | 9a36321 | 2015-03-16 14:08:49 -0600 | [diff] [blame] | 323 | err: |
| 324 | kfree(vdev->irqs); |
| 325 | return -EINVAL; |
Antonios Motakis | 682704c | 2015-03-16 14:08:48 -0600 | [diff] [blame] | 326 | } |
| 327 | |
| 328 | void vfio_platform_irq_cleanup(struct vfio_platform_device *vdev) |
| 329 | { |
Antonios Motakis | 57f972e | 2015-03-16 14:08:50 -0600 | [diff] [blame] | 330 | int i; |
| 331 | |
| 332 | for (i = 0; i < vdev->num_irqs; i++) |
| 333 | vfio_set_trigger(vdev, i, -1, NULL); |
| 334 | |
Antonios Motakis | 682704c | 2015-03-16 14:08:48 -0600 | [diff] [blame] | 335 | vdev->num_irqs = 0; |
| 336 | kfree(vdev->irqs); |
| 337 | } |