drivers/vfio/mdev/vfio_mdev.c

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