projects / openwrt / staging / mkresin.git / blob
? search:


c2424a41f007ed9b31a52ee7eb850410cd30f31c
[openwrt/staging/mkresin.git] / target / linux / layerscape / patches-4.14 / 808-vfio-support-layerscape.patch
1 From 03ce521cd071706f755e3d2304ab1b8c47fd4910 Mon Sep 17 00:00:00 2001
2 From: Biwen Li <biwen.li@nxp.com>
3 Date: Wed, 17 Apr 2019 18:59:09 +0800
4 Subject: [PATCH] vfio: support layerscape
5
6 This is an integrated patch of vfio for layerscape
7
8 Signed-off-by: Bharat Bhushan <Bharat.Bhushan@nxp.com>
9 Signed-off-by: Biwen Li <biwen.li@nxp.com>
10 Signed-off-by: Roy Pledge <roy.pledge@nxp.com>
11 Signed-off-by: Yangbo Lu <yangbo.lu@nxp.com>
12 ---
13 drivers/vfio/Kconfig | 1 +
14 drivers/vfio/Makefile | 1 +
15 drivers/vfio/fsl-mc/Kconfig | 9 +
16 drivers/vfio/fsl-mc/Makefile | 2 +
17 drivers/vfio/fsl-mc/vfio_fsl_mc.c | 759 ++++++++++++++++++++++
18 drivers/vfio/fsl-mc/vfio_fsl_mc_intr.c | 199 ++++++
19 drivers/vfio/fsl-mc/vfio_fsl_mc_private.h | 57 ++
20 include/uapi/linux/vfio.h | 1 +
21 8 files changed, 1029 insertions(+)
22 create mode 100644 drivers/vfio/fsl-mc/Kconfig
23 create mode 100644 drivers/vfio/fsl-mc/Makefile
24 create mode 100644 drivers/vfio/fsl-mc/vfio_fsl_mc.c
25 create mode 100644 drivers/vfio/fsl-mc/vfio_fsl_mc_intr.c
26 create mode 100644 drivers/vfio/fsl-mc/vfio_fsl_mc_private.h
27
28 --- a/drivers/vfio/Kconfig
29 +++ b/drivers/vfio/Kconfig
30 @@ -47,4 +47,5 @@ menuconfig VFIO_NOIOMMU
31 source "drivers/vfio/pci/Kconfig"
32 source "drivers/vfio/platform/Kconfig"
33 source "drivers/vfio/mdev/Kconfig"
34 +source "drivers/vfio/fsl-mc/Kconfig"
35 source "virt/lib/Kconfig"
36 --- a/drivers/vfio/Makefile
37 +++ b/drivers/vfio/Makefile
38 @@ -9,3 +9,4 @@ obj-$(CONFIG_VFIO_SPAPR_EEH) += vfio_spa
39 obj-$(CONFIG_VFIO_PCI) += pci/
40 obj-$(CONFIG_VFIO_PLATFORM) += platform/
41 obj-$(CONFIG_VFIO_MDEV) += mdev/
42 +obj-$(CONFIG_VFIO_FSL_MC) += fsl-mc/
43 --- /dev/null
44 +++ b/drivers/vfio/fsl-mc/Kconfig
45 @@ -0,0 +1,9 @@
46 +config VFIO_FSL_MC
47 + tristate "VFIO support for QorIQ DPAA2 fsl-mc bus devices"
48 + depends on VFIO && FSL_MC_BUS && EVENTFD
49 + help
50 + Driver to enable support for the VFIO QorIQ DPAA2 fsl-mc
51 + (Management Complex) devices. This is required to passthrough
52 + fsl-mc bus devices using the VFIO framework.
53 +
54 + If you don't know what to do here, say N.
55 --- /dev/null
56 +++ b/drivers/vfio/fsl-mc/Makefile
57 @@ -0,0 +1,2 @@
58 +vfio-fsl_mc-y := vfio_fsl_mc.o
59 +obj-$(CONFIG_VFIO_FSL_MC) += vfio_fsl_mc.o vfio_fsl_mc_intr.o
60 --- /dev/null
61 +++ b/drivers/vfio/fsl-mc/vfio_fsl_mc.c
62 @@ -0,0 +1,759 @@
63 +/*
64 + * Freescale Management Complex (MC) device passthrough using VFIO
65 + *
66 + * Copyright (C) 2013-2016 Freescale Semiconductor, Inc.
67 + * Copyright 2016-2017 NXP
68 + * Author: Bharat Bhushan <bharat.bhushan@nxp.com>
69 + *
70 + * This file is licensed under the terms of the GNU General Public
71 + * License version 2. This program is licensed "as is" without any
72 + * warranty of any kind, whether express or implied.
73 + */
74 +
75 +#include <linux/device.h>
76 +#include <linux/iommu.h>
77 +#include <linux/module.h>
78 +#include <linux/mutex.h>
79 +#include <linux/slab.h>
80 +#include <linux/types.h>
81 +#include <linux/vfio.h>
82 +#include <linux/delay.h>
83 +#include <linux/fsl/mc.h>
84 +
85 +#include "vfio_fsl_mc_private.h"
86 +
87 +#define DRIVER_VERSION "0.10"
88 +#define DRIVER_AUTHOR "Bharat Bhushan <bharat.bhushan@nxp.com>"
89 +#define DRIVER_DESC "VFIO for FSL-MC devices - User Level meta-driver"
90 +
91 +static DEFINE_MUTEX(driver_lock);
92 +
93 +/* FSl-MC device regions (address and size) are aligned to 64K.
94 + * While MC firmware reports size less than 64K for some objects (it actually
95 + * reports size which does not include reserved space beyond valid bytes).
96 + * Align the size to PAGE_SIZE for userspace to mmap.
97 + */
98 +static size_t aligned_region_size(struct fsl_mc_device *mc_dev, int index)
99 +{
100 + size_t size;
101 +
102 + size = resource_size(&mc_dev->regions[index]);
103 + return PAGE_ALIGN(size);
104 +}
105 +
106 +static int vfio_fsl_mc_regions_init(struct vfio_fsl_mc_device *vdev)
107 +{
108 + struct fsl_mc_device *mc_dev = vdev->mc_dev;
109 + int count = mc_dev->obj_desc.region_count;
110 + int i;
111 +
112 + vdev->regions = kcalloc(count, sizeof(struct vfio_fsl_mc_region),
113 + GFP_KERNEL);
114 + if (!vdev->regions)
115 + return -ENOMEM;
116 +
117 + for (i = 0; i < mc_dev->obj_desc.region_count; i++) {
118 + vdev->regions[i].addr = mc_dev->regions[i].start;
119 + vdev->regions[i].size = aligned_region_size(mc_dev, i);
120 + vdev->regions[i].type = VFIO_FSL_MC_REGION_TYPE_MMIO;
121 + if (mc_dev->regions[i].flags & IORESOURCE_CACHEABLE)
122 + vdev->regions[i].type |=
123 + VFIO_FSL_MC_REGION_TYPE_CACHEABLE;
124 + if (mc_dev->regions[i].flags & IORESOURCE_MEM)
125 + vdev->regions[i].type |=
126 + VFIO_FSL_MC_REGION_TYPE_SHAREABLE;
127 +
128 + vdev->regions[i].flags = VFIO_REGION_INFO_FLAG_MMAP;
129 + vdev->regions[i].flags |= VFIO_REGION_INFO_FLAG_READ;
130 + if (!(mc_dev->regions[i].flags & IORESOURCE_READONLY))
131 + vdev->regions[i].flags |= VFIO_REGION_INFO_FLAG_WRITE;
132 + }
133 +
134 + vdev->num_regions = mc_dev->obj_desc.region_count;
135 + return 0;
136 +}
137 +
138 +static void vfio_fsl_mc_regions_cleanup(struct vfio_fsl_mc_device *vdev)
139 +{
140 + int i;
141 +
142 + for (i = 0; i < vdev->num_regions; i++)
143 + iounmap(vdev->regions[i].ioaddr);
144 +
145 + vdev->num_regions = 0;
146 + kfree(vdev->regions);
147 +}
148 +
149 +static int vfio_fsl_mc_open(void *device_data)
150 +{
151 + struct vfio_fsl_mc_device *vdev = device_data;
152 + int ret;
153 +
154 + if (!try_module_get(THIS_MODULE))
155 + return -ENODEV;
156 +
157 + mutex_lock(&driver_lock);
158 + if (!vdev->refcnt) {
159 + ret = vfio_fsl_mc_regions_init(vdev);
160 + if (ret)
161 + goto error_region_init;
162 +
163 + ret = vfio_fsl_mc_irqs_init(vdev);
164 + if (ret)
165 + goto error_irq_init;
166 + }
167 +
168 + vdev->refcnt++;
169 + mutex_unlock(&driver_lock);
170 + return 0;
171 +
172 +error_irq_init:
173 + vfio_fsl_mc_regions_cleanup(vdev);
174 +error_region_init:
175 + mutex_unlock(&driver_lock);
176 + if (ret)
177 + module_put(THIS_MODULE);
178 +
179 + return ret;
180 +}
181 +
182 +static void vfio_fsl_mc_release(void *device_data)
183 +{
184 + struct vfio_fsl_mc_device *vdev = device_data;
185 + struct fsl_mc_device *mc_dev = vdev->mc_dev;
186 +
187 + mutex_lock(&driver_lock);
188 +
189 + if (!(--vdev->refcnt)) {
190 + vfio_fsl_mc_regions_cleanup(vdev);
191 + vfio_fsl_mc_irqs_cleanup(vdev);
192 + }
193 +
194 + if (strcmp(mc_dev->obj_desc.type, "dprc") == 0)
195 + dprc_reset_container(mc_dev->mc_io, 0, mc_dev->mc_handle,
196 + mc_dev->obj_desc.id);
197 +
198 + mutex_unlock(&driver_lock);
199 +
200 + module_put(THIS_MODULE);
201 +}
202 +
203 +static long vfio_fsl_mc_ioctl(void *device_data, unsigned int cmd,
204 + unsigned long arg)
205 +{
206 + struct vfio_fsl_mc_device *vdev = device_data;
207 + struct fsl_mc_device *mc_dev = vdev->mc_dev;
208 + unsigned long minsz;
209 +
210 + if (WARN_ON(!mc_dev))
211 + return -ENODEV;
212 +
213 + switch (cmd) {
214 + case VFIO_DEVICE_GET_INFO:
215 + {
216 + struct vfio_device_info info;
217 +
218 + minsz = offsetofend(struct vfio_device_info, num_irqs);
219 +
220 + if (copy_from_user(&info, (void __user *)arg, minsz))
221 + return -EFAULT;
222 +
223 + if (info.argsz < minsz)
224 + return -EINVAL;
225 +
226 + info.flags = VFIO_DEVICE_FLAGS_FSL_MC;
227 + info.num_regions = mc_dev->obj_desc.region_count;
228 + info.num_irqs = mc_dev->obj_desc.irq_count;
229 +
230 + return copy_to_user((void __user *)arg, &info, minsz);
231 + }
232 + case VFIO_DEVICE_GET_REGION_INFO:
233 + {
234 + struct vfio_region_info info;
235 +
236 + minsz = offsetofend(struct vfio_region_info, offset);
237 +
238 + if (copy_from_user(&info, (void __user *)arg, minsz))
239 + return -EFAULT;
240 +
241 + if (info.argsz < minsz)
242 + return -EINVAL;
243 +
244 + if (info.index >= vdev->num_regions)
245 + return -EINVAL;
246 +
247 + /* map offset to the physical address */
248 + info.offset = VFIO_FSL_MC_INDEX_TO_OFFSET(info.index);
249 + info.size = vdev->regions[info.index].size;
250 + info.flags = vdev->regions[info.index].flags;
251 +
252 + return copy_to_user((void __user *)arg, &info, minsz);
253 + }
254 + case VFIO_DEVICE_GET_IRQ_INFO:
255 + {
256 + struct vfio_irq_info info;
257 +
258 + minsz = offsetofend(struct vfio_irq_info, count);
259 + if (copy_from_user(&info, (void __user *)arg, minsz))
260 + return -EFAULT;
261 +
262 + if (info.argsz < minsz)
263 + return -EINVAL;
264 +
265 + if (info.index >= mc_dev->obj_desc.irq_count)
266 + return -EINVAL;
267 +
268 + if (vdev->mc_irqs != NULL) {
269 + info.flags = vdev->mc_irqs[info.index].flags;
270 + info.count = vdev->mc_irqs[info.index].count;
271 + } else {
272 + /*
273 + * If IRQs are not initialized then these can not
274 + * be configuted and used by user-space/
275 + */
276 + info.flags = 0;
277 + info.count = 0;
278 + }
279 +
280 + return copy_to_user((void __user *)arg, &info, minsz);
281 + }
282 + case VFIO_DEVICE_SET_IRQS:
283 + {
284 + struct vfio_irq_set hdr;
285 + u8 *data = NULL;
286 + int ret = 0;
287 +
288 + minsz = offsetofend(struct vfio_irq_set, count);
289 +
290 + if (copy_from_user(&hdr, (void __user *)arg, minsz))
291 + return -EFAULT;
292 +
293 + if (hdr.argsz < minsz)
294 + return -EINVAL;
295 +
296 + if (hdr.index >= mc_dev->obj_desc.irq_count)
297 + return -EINVAL;
298 +
299 + if (hdr.start != 0 || hdr.count > 1)
300 + return -EINVAL;
301 +
302 + if (hdr.count == 0 &&
303 + (!(hdr.flags & VFIO_IRQ_SET_DATA_NONE) ||
304 + !(hdr.flags & VFIO_IRQ_SET_ACTION_TRIGGER)))
305 + return -EINVAL;
306 +
307 + if (hdr.flags & ~(VFIO_IRQ_SET_DATA_TYPE_MASK |
308 + VFIO_IRQ_SET_ACTION_TYPE_MASK))
309 + return -EINVAL;
310 +
311 + if (!(hdr.flags & VFIO_IRQ_SET_DATA_NONE)) {
312 + size_t size;
313 +
314 + if (hdr.flags & VFIO_IRQ_SET_DATA_BOOL)
315 + size = sizeof(uint8_t);
316 + else if (hdr.flags & VFIO_IRQ_SET_DATA_EVENTFD)
317 + size = sizeof(int32_t);
318 + else
319 + return -EINVAL;
320 +
321 + if (hdr.argsz - minsz < hdr.count * size)
322 + return -EINVAL;
323 +
324 + data = memdup_user((void __user *)(arg + minsz),
325 + hdr.count * size);
326 + if (IS_ERR(data))
327 + return PTR_ERR(data);
328 + }
329 +
330 + ret = vfio_fsl_mc_set_irqs_ioctl(vdev, hdr.flags,
331 + hdr.index, hdr.start,
332 + hdr.count, data);
333 + return ret;
334 + }
335 + case VFIO_DEVICE_RESET:
336 + {
337 + return -EINVAL;
338 + }
339 + default:
340 + return -EINVAL;
341 + }
342 +}
343 +
344 +static ssize_t vfio_fsl_mc_read(void *device_data, char __user *buf,
345 + size_t count, loff_t *ppos)
346 +{
347 + struct vfio_fsl_mc_device *vdev = device_data;
348 + unsigned int index = VFIO_FSL_MC_OFFSET_TO_INDEX(*ppos);
349 + loff_t off = *ppos & VFIO_FSL_MC_OFFSET_MASK;
350 + struct vfio_fsl_mc_region *region;
351 + uint64_t data[8];
352 + int i;
353 +
354 + /* Read ioctl supported only for DPRC and DPMCP device */
355 + if (strcmp(vdev->mc_dev->obj_desc.type, "dprc") &&
356 + strcmp(vdev->mc_dev->obj_desc.type, "dpmcp"))
357 + return -EINVAL;
358 +
359 + if (index >= vdev->num_regions)
360 + return -EINVAL;
361 +
362 + region = &vdev->regions[index];
363 +
364 + if (!(region->flags & VFIO_REGION_INFO_FLAG_READ))
365 + return -EINVAL;
366 +
367 + if (!region->type & VFIO_FSL_MC_REGION_TYPE_MMIO)
368 + return -EINVAL;
369 +
370 + if (!region->ioaddr) {
371 + region->ioaddr = ioremap_nocache(region->addr, region->size);
372 + if (!region->ioaddr)
373 + return -ENOMEM;
374 + }
375 +
376 + if (count != 64 || off != 0)
377 + return -EINVAL;
378 +
379 + for (i = 7; i >= 0; i--)
380 + data[i] = readq(region->ioaddr + i * sizeof(uint64_t));
381 +
382 + if (copy_to_user(buf, data, 64))
383 + return -EFAULT;
384 +
385 + return count;
386 +}
387 +
388 +#define MC_CMD_COMPLETION_TIMEOUT_MS 5000
389 +#define MC_CMD_COMPLETION_POLLING_MAX_SLEEP_USECS 500
390 +
391 +static int vfio_fsl_mc_dprc_wait_for_response(void __iomem *ioaddr)
392 +{
393 + enum mc_cmd_status status;
394 + unsigned long timeout_usecs = MC_CMD_COMPLETION_TIMEOUT_MS * 1000;
395 +
396 + for (;;) {
397 + u64 header;
398 + struct mc_cmd_header *resp_hdr;
399 +
400 + header = cpu_to_le64(readq_relaxed(ioaddr));
401 +
402 + resp_hdr = (struct mc_cmd_header *)&header;
403 + status = (enum mc_cmd_status)resp_hdr->status;
404 + if (status != MC_CMD_STATUS_READY)
405 + break;
406 +
407 + udelay(MC_CMD_COMPLETION_POLLING_MAX_SLEEP_USECS);
408 + timeout_usecs -= MC_CMD_COMPLETION_POLLING_MAX_SLEEP_USECS;
409 + if (timeout_usecs == 0)
410 + return -ETIMEDOUT;
411 + }
412 +
413 + return 0;
414 +}
415 +
416 +static int vfio_fsl_mc_send_command(void __iomem *ioaddr, uint64_t *cmd_data)
417 +{
418 + int i;
419 +
420 + /* Write at command parameter into portal */
421 + for (i = 7; i >= 1; i--)
422 + writeq_relaxed(cmd_data[i], ioaddr + i * sizeof(uint64_t));
423 +
424 + /* Write command header in the end */
425 + writeq(cmd_data[0], ioaddr);
426 +
427 + /* Wait for response before returning to user-space
428 + * This can be optimized in future to even prepare response
429 + * before returning to user-space and avoid read ioctl.
430 + */
431 + return vfio_fsl_mc_dprc_wait_for_response(ioaddr);
432 +}
433 +
434 +static int vfio_handle_dprc_commands(void __iomem *ioaddr, uint64_t *cmd_data)
435 +{
436 + uint64_t cmd_hdr = cmd_data[0];
437 + int cmd = (cmd_hdr >> 52) & 0xfff;
438 +
439 + switch (cmd) {
440 + case DPRC_CMDID_OPEN:
441 + default:
442 + return vfio_fsl_mc_send_command(ioaddr, cmd_data);
443 + }
444 +
445 + return 0;
446 +}
447 +
448 +static ssize_t vfio_fsl_mc_write(void *device_data, const char __user *buf,
449 + size_t count, loff_t *ppos)
450 +{
451 + struct vfio_fsl_mc_device *vdev = device_data;
452 + unsigned int index = VFIO_FSL_MC_OFFSET_TO_INDEX(*ppos);
453 + loff_t off = *ppos & VFIO_FSL_MC_OFFSET_MASK;
454 + struct vfio_fsl_mc_region *region;
455 + uint64_t data[8];
456 + int ret;
457 +
458 + /* Write ioctl supported only for DPRC and DPMCP device */
459 + if (strcmp(vdev->mc_dev->obj_desc.type, "dprc") &&
460 + strcmp(vdev->mc_dev->obj_desc.type, "dpmcp"))
461 + return -EINVAL;
462 +
463 + if (index >= vdev->num_regions)
464 + return -EINVAL;
465 +
466 + region = &vdev->regions[index];
467 +
468 + if (!(region->flags & VFIO_REGION_INFO_FLAG_WRITE))
469 + return -EINVAL;
470 +
471 + if (!region->type & VFIO_FSL_MC_REGION_TYPE_MMIO)
472 + return -EINVAL;
473 +
474 + if (!region->ioaddr) {
475 + region->ioaddr = ioremap_nocache(region->addr, region->size);
476 + if (!region->ioaddr)
477 + return -ENOMEM;
478 + }
479 +
480 + if (count != 64 || off != 0)
481 + return -EINVAL;
482 +
483 + if (copy_from_user(&data, buf, 64))
484 + return -EFAULT;
485 +
486 + ret = vfio_handle_dprc_commands(region->ioaddr, data);
487 + if (ret)
488 + return ret;
489 +
490 + return count;
491 +}
492 +
493 +static int vfio_fsl_mc_mmap_mmio(struct vfio_fsl_mc_region region,
494 + struct vm_area_struct *vma)
495 +{
496 + u64 size = vma->vm_end - vma->vm_start;
497 + u64 pgoff, base;
498 +
499 + pgoff = vma->vm_pgoff &
500 + ((1U << (VFIO_FSL_MC_OFFSET_SHIFT - PAGE_SHIFT)) - 1);
501 + base = pgoff << PAGE_SHIFT;
502 +
503 + if (region.size < PAGE_SIZE || base + size > region.size)
504 + return -EINVAL;
505 + /*
506 + * Set the REGION_TYPE_CACHEABLE (QBman CENA regs) to be the
507 + * cache inhibited area of the portal to avoid coherency issues
508 + * if a user migrates to another core.
509 + */
510 + if (region.type & VFIO_FSL_MC_REGION_TYPE_CACHEABLE) {
511 + if (region.type & VFIO_FSL_MC_REGION_TYPE_SHAREABLE)
512 + vma->vm_page_prot = pgprot_cached(vma->vm_page_prot);
513 + else
514 + vma->vm_page_prot = pgprot_cached_ns(vma->vm_page_prot);
515 + } else
516 + vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
517 +
518 + vma->vm_pgoff = (region.addr >> PAGE_SHIFT) + pgoff;
519 +
520 + return remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff,
521 + size, vma->vm_page_prot);
522 +}
523 +
524 +/* Allows mmaping fsl_mc device regions in assigned DPRC */
525 +static int vfio_fsl_mc_mmap(void *device_data, struct vm_area_struct *vma)
526 +{
527 + struct vfio_fsl_mc_device *vdev = device_data;
528 + struct fsl_mc_device *mc_dev = vdev->mc_dev;
529 + unsigned long size, addr;
530 + int index;
531 +
532 + index = vma->vm_pgoff >> (VFIO_FSL_MC_OFFSET_SHIFT - PAGE_SHIFT);
533 +
534 + if (vma->vm_end < vma->vm_start)
535 + return -EINVAL;
536 + if (vma->vm_start & ~PAGE_MASK)
537 + return -EINVAL;
538 + if (vma->vm_end & ~PAGE_MASK)
539 + return -EINVAL;
540 + if (!(vma->vm_flags & VM_SHARED))
541 + return -EINVAL;
542 + if (index >= vdev->num_regions)
543 + return -EINVAL;
544 +
545 + if (!(vdev->regions[index].flags & VFIO_REGION_INFO_FLAG_MMAP))
546 + return -EINVAL;
547 +
548 + if (!(vdev->regions[index].flags & VFIO_REGION_INFO_FLAG_READ)
549 + && (vma->vm_flags & VM_READ))
550 + return -EINVAL;
551 +
552 + if (!(vdev->regions[index].flags & VFIO_REGION_INFO_FLAG_WRITE)
553 + && (vma->vm_flags & VM_WRITE))
554 + return -EINVAL;
555 +
556 + addr = vdev->regions[index].addr;
557 + size = vdev->regions[index].size;
558 +
559 + vma->vm_private_data = mc_dev;
560 +
561 + if (vdev->regions[index].type & VFIO_FSL_MC_REGION_TYPE_MMIO)
562 + return vfio_fsl_mc_mmap_mmio(vdev->regions[index], vma);
563 +
564 + return -EFAULT;
565 +}
566 +
567 +static const struct vfio_device_ops vfio_fsl_mc_ops = {
568 + .name = "vfio-fsl-mc",
569 + .open = vfio_fsl_mc_open,
570 + .release = vfio_fsl_mc_release,
571 + .ioctl = vfio_fsl_mc_ioctl,
572 + .read = vfio_fsl_mc_read,
573 + .write = vfio_fsl_mc_write,
574 + .mmap = vfio_fsl_mc_mmap,
575 +};
576 +
577 +static int vfio_fsl_mc_initialize_dprc(struct vfio_fsl_mc_device *vdev)
578 +{
579 + struct device *root_dprc_dev;
580 + struct fsl_mc_device *mc_dev = vdev->mc_dev;
581 + struct device *dev = &mc_dev->dev;
582 + struct fsl_mc_bus *mc_bus;
583 + struct irq_domain *mc_msi_domain;
584 + unsigned int irq_count;
585 + int ret;
586 +
587 + /* device must be DPRC */
588 + if (strcmp(mc_dev->obj_desc.type, "dprc"))
589 + return -EINVAL;
590 +
591 + /* mc_io must be un-initialized */
592 + WARN_ON(mc_dev->mc_io);
593 +
594 + /* allocate a portal from the root DPRC for vfio use */
595 + fsl_mc_get_root_dprc(dev, &root_dprc_dev);
596 + if (WARN_ON(!root_dprc_dev))
597 + return -EINVAL;
598 +
599 + ret = fsl_mc_portal_allocate(to_fsl_mc_device(root_dprc_dev),
600 + FSL_MC_IO_ATOMIC_CONTEXT_PORTAL,
601 + &mc_dev->mc_io);
602 + if (ret < 0)
603 + goto clean_msi_domain;
604 +
605 + /* Reset MCP before move on */
606 + ret = fsl_mc_portal_reset(mc_dev->mc_io);
607 + if (ret < 0) {
608 + dev_err(dev, "dprc portal reset failed: error = %d\n", ret);
609 + goto free_mc_portal;
610 + }
611 +
612 + /* MSI domain set up */
613 + ret = fsl_mc_find_msi_domain(root_dprc_dev->parent, &mc_msi_domain);
614 + if (ret < 0)
615 + goto free_mc_portal;
616 +
617 + dev_set_msi_domain(&mc_dev->dev, mc_msi_domain);
618 +
619 + ret = dprc_open(mc_dev->mc_io, 0, mc_dev->obj_desc.id,
620 + &mc_dev->mc_handle);
621 + if (ret) {
622 + dev_err(dev, "dprc_open() failed: error = %d\n", ret);
623 + goto free_mc_portal;
624 + }
625 +
626 + /* Initialize resource pool */
627 + fsl_mc_init_all_resource_pools(mc_dev);
628 +
629 + mc_bus = to_fsl_mc_bus(mc_dev);
630 +
631 + if (!mc_bus->irq_resources) {
632 + irq_count = FSL_MC_IRQ_POOL_MAX_TOTAL_IRQS;
633 + ret = fsl_mc_populate_irq_pool(mc_bus, irq_count);
634 + if (ret < 0) {
635 + dev_err(dev, "%s: Failed to init irq-pool\n", __func__);
636 + goto clean_resource_pool;
637 + }
638 + }
639 +
640 + mutex_init(&mc_bus->scan_mutex);
641 +
642 + mutex_lock(&mc_bus->scan_mutex);
643 + ret = dprc_scan_objects(mc_dev, mc_dev->driver_override,
644 + &irq_count);
645 + mutex_unlock(&mc_bus->scan_mutex);
646 + if (ret) {
647 + dev_err(dev, "dprc_scan_objects() fails (%d)\n", ret);
648 + goto clean_irq_pool;
649 + }
650 +
651 + if (irq_count > FSL_MC_IRQ_POOL_MAX_TOTAL_IRQS) {
652 + dev_warn(&mc_dev->dev,
653 + "IRQs needed (%u) exceed IRQs preallocated (%u)\n",
654 + irq_count, FSL_MC_IRQ_POOL_MAX_TOTAL_IRQS);
655 + }
656 +
657 + return 0;
658 +
659 +clean_irq_pool:
660 + fsl_mc_cleanup_irq_pool(mc_bus);
661 +
662 +clean_resource_pool:
663 + fsl_mc_cleanup_all_resource_pools(mc_dev);
664 + dprc_close(mc_dev->mc_io, 0, mc_dev->mc_handle);
665 +
666 +free_mc_portal:
667 + fsl_mc_portal_free(mc_dev->mc_io);
668 +
669 +clean_msi_domain:
670 + dev_set_msi_domain(&mc_dev->dev, NULL);
671 +
672 + return ret;
673 +}
674 +
675 +static int vfio_fsl_mc_device_remove(struct device *dev, void *data)
676 +{
677 + struct fsl_mc_device *mc_dev;
678 +
679 + WARN_ON(dev == NULL);
680 +
681 + mc_dev = to_fsl_mc_device(dev);
682 + if (WARN_ON(mc_dev == NULL))
683 + return -ENODEV;
684 +
685 + fsl_mc_device_remove(mc_dev);
686 + return 0;
687 +}
688 +
689 +static void vfio_fsl_mc_cleanup_dprc(struct vfio_fsl_mc_device *vdev)
690 +{
691 + struct fsl_mc_device *mc_dev = vdev->mc_dev;
692 + struct fsl_mc_bus *mc_bus;
693 +
694 + /* device must be DPRC */
695 + if (strcmp(mc_dev->obj_desc.type, "dprc"))
696 + return;
697 +
698 + device_for_each_child(&mc_dev->dev, NULL, vfio_fsl_mc_device_remove);
699 +
700 + mc_bus = to_fsl_mc_bus(mc_dev);
701 + if (dev_get_msi_domain(&mc_dev->dev))
702 + fsl_mc_cleanup_irq_pool(mc_bus);
703 +
704 + dev_set_msi_domain(&mc_dev->dev, NULL);
705 +
706 + fsl_mc_cleanup_all_resource_pools(mc_dev);
707 + dprc_close(mc_dev->mc_io, 0, mc_dev->mc_handle);
708 + fsl_mc_portal_free(mc_dev->mc_io);
709 +}
710 +
711 +static int vfio_fsl_mc_probe(struct fsl_mc_device *mc_dev)
712 +{
713 + struct iommu_group *group;
714 + struct vfio_fsl_mc_device *vdev;
715 + struct device *dev = &mc_dev->dev;
716 + int ret;
717 +
718 + group = vfio_iommu_group_get(dev);
719 + if (!group) {
720 + dev_err(dev, "%s: VFIO: No IOMMU group\n", __func__);
721 + return -EINVAL;
722 + }
723 +
724 + vdev = kzalloc(sizeof(*vdev), GFP_KERNEL);
725 + if (!vdev) {
726 + vfio_iommu_group_put(group, dev);
727 + return -ENOMEM;
728 + }
729 +
730 + vdev->mc_dev = mc_dev;
731 +
732 + ret = vfio_add_group_dev(dev, &vfio_fsl_mc_ops, vdev);
733 + if (ret) {
734 + dev_err(dev, "%s: Failed to add to vfio group\n", __func__);
735 + goto free_vfio_device;
736 + }
737 +
738 + /* DPRC container scanned and it's chilren bound with vfio driver */
739 + if (strcmp(mc_dev->obj_desc.type, "dprc") == 0) {
740 + ret = vfio_fsl_mc_initialize_dprc(vdev);
741 + if (ret) {
742 + vfio_del_group_dev(dev);
743 + goto free_vfio_device;
744 + }
745 + } else {
746 + struct fsl_mc_device *mc_bus_dev;
747 +
748 + /* Non-dprc devices share mc_io from the parent dprc */
749 + mc_bus_dev = to_fsl_mc_device(mc_dev->dev.parent);
750 + if (mc_bus_dev == NULL) {
751 + vfio_del_group_dev(dev);
752 + goto free_vfio_device;
753 + }
754 +
755 + mc_dev->mc_io = mc_bus_dev->mc_io;
756 +
757 + /* Inherit parent MSI domain */
758 + dev_set_msi_domain(&mc_dev->dev,
759 + dev_get_msi_domain(mc_dev->dev.parent));
760 + }
761 + return 0;
762 +
763 +free_vfio_device:
764 + kfree(vdev);
765 + vfio_iommu_group_put(group, dev);
766 + return ret;
767 +}
768 +
769 +static int vfio_fsl_mc_remove(struct fsl_mc_device *mc_dev)
770 +{
771 + struct vfio_fsl_mc_device *vdev;
772 + struct device *dev = &mc_dev->dev;
773 +
774 + vdev = vfio_del_group_dev(dev);
775 + if (!vdev)
776 + return -EINVAL;
777 +
778 + if (strcmp(mc_dev->obj_desc.type, "dprc") == 0)
779 + vfio_fsl_mc_cleanup_dprc(vdev);
780 + else
781 + dev_set_msi_domain(&mc_dev->dev, NULL);
782 +
783 + mc_dev->mc_io = NULL;
784 +
785 + vfio_iommu_group_put(mc_dev->dev.iommu_group, dev);
786 + kfree(vdev);
787 +
788 + return 0;
789 +}
790 +
791 +/*
792 + * vfio-fsl_mc is a meta-driver, so use driver_override interface to
793 + * bind a fsl_mc container with this driver and match_id_table is NULL.
794 + */
795 +static struct fsl_mc_driver vfio_fsl_mc_driver = {
796 + .probe = vfio_fsl_mc_probe,
797 + .remove = vfio_fsl_mc_remove,
798 + .match_id_table = NULL,
799 + .driver = {
800 + .name = "vfio-fsl-mc",
801 + .owner = THIS_MODULE,
802 + },
803 +};
804 +
805 +static int __init vfio_fsl_mc_driver_init(void)
806 +{
807 + return fsl_mc_driver_register(&vfio_fsl_mc_driver);
808 +}
809 +
810 +static void __exit vfio_fsl_mc_driver_exit(void)
811 +{
812 + fsl_mc_driver_unregister(&vfio_fsl_mc_driver);
813 +}
814 +
815 +module_init(vfio_fsl_mc_driver_init);
816 +module_exit(vfio_fsl_mc_driver_exit);
817 +
818 +MODULE_VERSION(DRIVER_VERSION);
819 +MODULE_LICENSE("GPL v2");
820 +MODULE_AUTHOR(DRIVER_AUTHOR);
821 +MODULE_DESCRIPTION(DRIVER_DESC);
822 --- /dev/null
823 +++ b/drivers/vfio/fsl-mc/vfio_fsl_mc_intr.c
824 @@ -0,0 +1,199 @@
825 +/*
826 + * Freescale Management Complex (MC) device passthrough using VFIO
827 + *
828 + * Copyright (C) 2013-2016 Freescale Semiconductor, Inc.
829 + * Author: Bharat Bhushan <bharat.bhushan@nxp.com>
830 + *
831 + * This file is licensed under the terms of the GNU General Public
832 + * License version 2. This program is licensed "as is" without any
833 + * warranty of any kind, whether express or implied.
834 + */
835 +
836 +#include <linux/vfio.h>
837 +#include <linux/slab.h>
838 +#include <linux/types.h>
839 +#include <linux/eventfd.h>
840 +#include <linux/msi.h>
841 +
842 +#include "linux/fsl/mc.h"
843 +#include "vfio_fsl_mc_private.h"
844 +
845 +static irqreturn_t vfio_fsl_mc_irq_handler(int irq_num, void *arg)
846 +{
847 + struct vfio_fsl_mc_irq *mc_irq = (struct vfio_fsl_mc_irq *)arg;
848 +
849 + eventfd_signal(mc_irq->trigger, 1);
850 + return IRQ_HANDLED;
851 +}
852 +
853 +static int vfio_fsl_mc_irq_mask(struct vfio_fsl_mc_device *vdev,
854 + unsigned int index, unsigned int start,
855 + unsigned int count, uint32_t flags,
856 + void *data)
857 +{
858 + return -EINVAL;
859 +}
860 +
861 +static int vfio_fsl_mc_irq_unmask(struct vfio_fsl_mc_device *vdev,
862 + unsigned int index, unsigned int start,
863 + unsigned int count, uint32_t flags,
864 + void *data)
865 +{
866 + return -EINVAL;
867 +}
868 +
869 +static int vfio_set_trigger(struct vfio_fsl_mc_device *vdev,
870 + int index, int fd)
871 +{
872 + struct vfio_fsl_mc_irq *irq = &vdev->mc_irqs[index];
873 + struct eventfd_ctx *trigger;
874 + int hwirq;
875 + int ret;
876 +
877 + hwirq = vdev->mc_dev->irqs[index]->msi_desc->irq;
878 + if (irq->trigger) {
879 + free_irq(hwirq, irq);
880 + kfree(irq->name);
881 + eventfd_ctx_put(irq->trigger);
882 + irq->trigger = NULL;
883 + }
884 +
885 + if (fd < 0) /* Disable only */
886 + return 0;
887 +
888 + irq->name = kasprintf(GFP_KERNEL, "vfio-irq[%d](%s)",
889 + hwirq, dev_name(&vdev->mc_dev->dev));
890 + if (!irq->name)
891 + return -ENOMEM;
892 +
893 + trigger = eventfd_ctx_fdget(fd);
894 + if (IS_ERR(trigger)) {
895 + kfree(irq->name);
896 + return PTR_ERR(trigger);
897 + }
898 +
899 + irq->trigger = trigger;
900 +
901 + ret = request_irq(hwirq, vfio_fsl_mc_irq_handler, 0,
902 + irq->name, irq);
903 + if (ret) {
904 + kfree(irq->name);
905 + eventfd_ctx_put(trigger);
906 + irq->trigger = NULL;
907 + return ret;
908 + }
909 +
910 + return 0;
911 +}
912 +
913 +int vfio_fsl_mc_irqs_init(struct vfio_fsl_mc_device *vdev)
914 +{
915 + struct fsl_mc_device *mc_dev = vdev->mc_dev;
916 + struct vfio_fsl_mc_irq *mc_irq;
917 + int irq_count;
918 + int ret, i;
919 +
920 + /* Device does not support any interrupt */
921 + if (mc_dev->obj_desc.irq_count == 0)
922 + return 0;
923 +
924 + irq_count = mc_dev->obj_desc.irq_count;
925 +
926 + mc_irq = kcalloc(irq_count, sizeof(*mc_irq), GFP_KERNEL);
927 + if (mc_irq == NULL)
928 + return -ENOMEM;
929 +
930 + /* Allocate IRQs */
931 + ret = fsl_mc_allocate_irqs(mc_dev);
932 + if (ret) {
933 + kfree(mc_irq);
934 + return ret;
935 + }
936 +
937 + for (i = 0; i < irq_count; i++) {
938 + mc_irq[i].count = 1;
939 + mc_irq[i].flags = VFIO_IRQ_INFO_EVENTFD;
940 + }
941 +
942 + vdev->mc_irqs = mc_irq;
943 +
944 + return 0;
945 +}
946 +
947 +/* Free All IRQs for the given MC object */
948 +void vfio_fsl_mc_irqs_cleanup(struct vfio_fsl_mc_device *vdev)
949 +{
950 + struct fsl_mc_device *mc_dev = vdev->mc_dev;
951 + int irq_count = mc_dev->obj_desc.irq_count;
952 + int i;
953 +
954 + /* Device does not support any interrupt */
955 + if (mc_dev->obj_desc.irq_count == 0)
956 + return;
957 +
958 + for (i = 0; i < irq_count; i++)
959 + vfio_set_trigger(vdev, i, -1);
960 +
961 + fsl_mc_free_irqs(mc_dev);
962 + kfree(vdev->mc_irqs);
963 +}
964 +
965 +static int vfio_fsl_mc_set_irq_trigger(struct vfio_fsl_mc_device *vdev,
966 + unsigned int index, unsigned int start,
967 + unsigned int count, uint32_t flags,
968 + void *data)
969 +{
970 + struct vfio_fsl_mc_irq *irq = &vdev->mc_irqs[index];
971 + int hwirq;
972 +
973 + if (!count && (flags & VFIO_IRQ_SET_DATA_NONE))
974 + return vfio_set_trigger(vdev, index, -1);
975 +
976 + if (start != 0 || count != 1)
977 + return -EINVAL;
978 +
979 + if (flags & VFIO_IRQ_SET_DATA_EVENTFD) {
980 + int32_t fd = *(int32_t *)data;
981 +
982 + return vfio_set_trigger(vdev, index, fd);
983 + }
984 +
985 + hwirq = vdev->mc_dev->irqs[index]->msi_desc->irq;
986 +
987 + if (flags & VFIO_IRQ_SET_DATA_NONE) {
988 + vfio_fsl_mc_irq_handler(hwirq, irq);
989 +
990 + } else if (flags & VFIO_IRQ_SET_DATA_BOOL) {
991 + uint8_t trigger = *(uint8_t *)data;
992 +
993 + if (trigger)
994 + vfio_fsl_mc_irq_handler(hwirq, irq);
995 + }
996 +
997 + return 0;
998 +}
999 +
1000 +int vfio_fsl_mc_set_irqs_ioctl(struct vfio_fsl_mc_device *vdev,
1001 + uint32_t flags, unsigned int index,
1002 + unsigned int start, unsigned int count,
1003 + void *data)
1004 +{
1005 + int ret = -ENOTTY;
1006 +
1007 + switch (flags & VFIO_IRQ_SET_ACTION_TYPE_MASK) {
1008 + case VFIO_IRQ_SET_ACTION_MASK:
1009 + ret = vfio_fsl_mc_irq_mask(vdev, index, start, count,
1010 + flags, data);
1011 + break;
1012 + case VFIO_IRQ_SET_ACTION_UNMASK:
1013 + ret = vfio_fsl_mc_irq_unmask(vdev, index, start, count,
1014 + flags, data);
1015 + break;
1016 + case VFIO_IRQ_SET_ACTION_TRIGGER:
1017 + ret = vfio_fsl_mc_set_irq_trigger(vdev, index, start,
1018 + count, flags, data);
1019 + break;
1020 + }
1021 +
1022 + return ret;
1023 +}
1024 --- /dev/null
1025 +++ b/drivers/vfio/fsl-mc/vfio_fsl_mc_private.h
1026 @@ -0,0 +1,57 @@
1027 +/*
1028 + * Freescale Management Complex VFIO private declarations
1029 + *
1030 + * Copyright (C) 2013-2016 Freescale Semiconductor, Inc.
1031 + * Copyright 2016 NXP
1032 + * Author: Bharat Bhushan <bharat.bhushan@nxp.com>
1033 + *
1034 + * This file is licensed under the terms of the GNU General Public
1035 + * License version 2. This program is licensed "as is" without any
1036 + * warranty of any kind, whether express or implied.
1037 + */
1038 +
1039 +#ifndef VFIO_FSL_MC_PRIVATE_H
1040 +#define VFIO_FSL_MC_PRIVATE_H
1041 +
1042 +#define VFIO_FSL_MC_OFFSET_SHIFT 40
1043 +#define VFIO_FSL_MC_OFFSET_MASK (((u64)(1) << VFIO_FSL_MC_OFFSET_SHIFT) - 1)
1044 +
1045 +#define VFIO_FSL_MC_OFFSET_TO_INDEX(off) (off >> VFIO_FSL_MC_OFFSET_SHIFT)
1046 +
1047 +#define VFIO_FSL_MC_INDEX_TO_OFFSET(index) \
1048 + ((u64)(index) << VFIO_FSL_MC_OFFSET_SHIFT)
1049 +
1050 +struct vfio_fsl_mc_irq {
1051 + u32 flags;
1052 + u32 count;
1053 + struct eventfd_ctx *trigger;
1054 + char *name;
1055 +};
1056 +
1057 +struct vfio_fsl_mc_region {
1058 + u32 flags;
1059 +#define VFIO_FSL_MC_REGION_TYPE_MMIO 1
1060 +#define VFIO_FSL_MC_REGION_TYPE_CACHEABLE 2
1061 +#define VFIO_FSL_MC_REGION_TYPE_SHAREABLE 4
1062 +
1063 + u32 type;
1064 + u64 addr;
1065 + resource_size_t size;
1066 + void __iomem *ioaddr;
1067 +};
1068 +
1069 +struct vfio_fsl_mc_device {
1070 + struct fsl_mc_device *mc_dev;
1071 + int refcnt;
1072 + u32 num_regions;
1073 + struct vfio_fsl_mc_region *regions;
1074 + struct vfio_fsl_mc_irq *mc_irqs;
1075 +};
1076 +
1077 +int vfio_fsl_mc_irqs_init(struct vfio_fsl_mc_device *vdev);
1078 +void vfio_fsl_mc_irqs_cleanup(struct vfio_fsl_mc_device *vdev);
1079 +int vfio_fsl_mc_set_irqs_ioctl(struct vfio_fsl_mc_device *vdev,
1080 + uint32_t flags, unsigned int index,
1081 + unsigned int start, unsigned int count,
1082 + void *data);
1083 +#endif /* VFIO_PCI_PRIVATE_H */
1084 --- a/include/uapi/linux/vfio.h
1085 +++ b/include/uapi/linux/vfio.h
1086 @@ -200,6 +200,7 @@ struct vfio_device_info {
1087 #define VFIO_DEVICE_FLAGS_PLATFORM (1 << 2) /* vfio-platform device */
1088 #define VFIO_DEVICE_FLAGS_AMBA (1 << 3) /* vfio-amba device */
1089 #define VFIO_DEVICE_FLAGS_CCW (1 << 4) /* vfio-ccw device */
1090 +#define VFIO_DEVICE_FLAGS_FSL_MC (1 << 5) /* vfio-fsl-mc device */
1091 __u32 num_regions; /* Max region index + 1 */
1092 __u32 num_irqs; /* Max IRQ index + 1 */
1093 };
Staging tree of Mathias Kresin