drivers/vfio/mdev/vfio_mdev.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * VFIO based driver for Mediated device
   4  *
   5  * Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
   6  *     Author: Neo Jia <cjia@nvidia.com>
   7  *             Kirti Wankhede <kwankhede@nvidia.com>
   8  */
   9
  10 #include <linux/init.h>
  11 #include <linux/module.h>
  12 #include <linux/device.h>
  13 #include <linux/kernel.h>
  14 #include <linux/slab.h>
  15 #include <linux/vfio.h>
  16 #include <linux/mdev.h>
  17
  18 #include "mdev_private.h"
  19
  20 #define DRIVER_VERSION  "0.1"
  21 #define DRIVER_AUTHOR   "NVIDIA Corporation"
  22 #define DRIVER_DESC     "VFIO based driver for Mediated device"
  23
  24 static int vfio_mdev_open(void *device_data)
  25 {
  26         struct mdev_device *mdev = device_data;
  27         struct mdev_parent *parent = mdev->parent;
  28         int ret;
  29
  30         if (unlikely(!parent->ops->open))
  31                 return -EINVAL;
  32
  33         if (!try_module_get(THIS_MODULE))
  34                 return -ENODEV;
  35
  36         ret = parent->ops->open(mdev);
  37         if (ret)
  38                 module_put(THIS_MODULE);
  39
  40         return ret;
  41 }
  42
  43 static void vfio_mdev_release(void *device_data)
  44 {
  45         struct mdev_device *mdev = device_data;
  46         struct mdev_parent *parent = mdev->parent;
  47
  48         if (likely(parent->ops->release))
  49                 parent->ops->release(mdev);
  50
  51         module_put(THIS_MODULE);
  52 }
  53
  54 static long vfio_mdev_unlocked_ioctl(void *device_data,
  55                                      unsigned int cmd, unsigned long arg)
  56 {
  57         struct mdev_device *mdev = device_data;
  58         struct mdev_parent *parent = mdev->parent;
  59
  60         if (unlikely(!parent->ops->ioctl))
  61                 return -EINVAL;
  62
  63         return parent->ops->ioctl(mdev, cmd, arg);
  64 }
  65
  66 static ssize_t vfio_mdev_read(void *device_data, char __user *buf,
  67                               size_t count, loff_t *ppos)
  68 {
  69         struct mdev_device *mdev = device_data;
  70         struct mdev_parent *parent = mdev->parent;
  71
  72         if (unlikely(!parent->ops->read))
  73                 return -EINVAL;
  74
  75         return parent->ops->read(mdev, buf, count, ppos);
  76 }
  77
  78 static ssize_t vfio_mdev_write(void *device_data, const char __user *buf,
  79                                size_t count, loff_t *ppos)
  80 {
  81         struct mdev_device *mdev = device_data;
  82         struct mdev_parent *parent = mdev->parent;
  83
  84         if (unlikely(!parent->ops->write))
  85                 return -EINVAL;
  86
  87         return parent->ops->write(mdev, buf, count, ppos);
  88 }
  89
  90 static int vfio_mdev_mmap(void *device_data, struct vm_area_struct *vma)
  91 {
  92         struct mdev_device *mdev = device_data;
  93         struct mdev_parent *parent = mdev->parent;
  94
  95         if (unlikely(!parent->ops->mmap))
  96                 return -EINVAL;
  97
  98         return parent->ops->mmap(mdev, vma);
  99 }
 100
 101 static const struct vfio_device_ops vfio_mdev_dev_ops = {
 102         .name           = "vfio-mdev",
 103         .open           = vfio_mdev_open,
 104         .release        = vfio_mdev_release,
 105         .ioctl          = vfio_mdev_unlocked_ioctl,
 106         .read           = vfio_mdev_read,
 107         .write          = vfio_mdev_write,
 108         .mmap           = vfio_mdev_mmap,
 109 };
 110
 111 static int vfio_mdev_probe(struct device *dev)
 112 {
 113         struct mdev_device *mdev = to_mdev_device(dev);
 114
 115         return vfio_add_group_dev(dev, &vfio_mdev_dev_ops, mdev);
 116 }
 117
 118 static void vfio_mdev_remove(struct device *dev)
 119 {
 120         vfio_del_group_dev(dev);
 121 }
 122
 123 static struct mdev_driver vfio_mdev_driver = {
 124         .name   = "vfio_mdev",
 125         .probe  = vfio_mdev_probe,
 126         .remove = vfio_mdev_remove,
 127 };
 128
 129 static int __init vfio_mdev_init(void)
 130 {
 131         return mdev_register_driver(&vfio_mdev_driver, THIS_MODULE);
 132 }
 133
 134 static void __exit vfio_mdev_exit(void)
 135 {
 136         mdev_unregister_driver(&vfio_mdev_driver);
 137 }
 138
 139 module_init(vfio_mdev_init)
 140 module_exit(vfio_mdev_exit)
 141
 142 MODULE_VERSION(DRIVER_VERSION);
 143 MODULE_LICENSE("GPL v2");
 144 MODULE_AUTHOR(DRIVER_AUTHOR);
 145 MODULE_DESCRIPTION(DRIVER_DESC);