LXR linux/drivers/vfio/mdev/vfio

   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
  27static 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
  46static 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
  57static 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
  69static 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
  81static 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
  93static 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
 104static 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
 114int 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
 121void vfio_mdev_remove(struct device *dev)
 122{
 123        vfio_del_group_dev(dev);
 124}
 125
 126struct mdev_driver vfio_mdev_driver = {
 127        .name   = "vfio_mdev",
 128        .probe  = vfio_mdev_probe,
 129        .remove = vfio_mdev_remove,
 130};
 131
 132static int __init vfio_mdev_init(void)
 133{
 134        return mdev_register_driver(&vfio_mdev_driver, THIS_MODULE);
 135}
 136
 137static void __exit vfio_mdev_exit(void)
 138{
 139        mdev_unregister_driver(&vfio_mdev_driver);
 140}
 141
 142module_init(vfio_mdev_init)
 143module_exit(vfio_mdev_exit)
 144
 145MODULE_VERSION(DRIVER_VERSION);
 146MODULE_LICENSE("GPL v2");
 147MODULE_AUTHOR(DRIVER_AUTHOR);
 148MODULE_DESCRIPTION(DRIVER_DESC);
 149