Loading...
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
114static 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
121static void vfio_mdev_remove(struct device *dev)
122{
123 vfio_del_group_dev(dev);
124}
125
126static struct 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);
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
24static 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
43static 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
54static 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
66static 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
78static 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
90static 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
101static 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
111static 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
118static void vfio_mdev_remove(struct device *dev)
119{
120 vfio_del_group_dev(dev);
121}
122
123static struct mdev_driver vfio_mdev_driver = {
124 .name = "vfio_mdev",
125 .probe = vfio_mdev_probe,
126 .remove = vfio_mdev_remove,
127};
128
129static int __init vfio_mdev_init(void)
130{
131 return mdev_register_driver(&vfio_mdev_driver, THIS_MODULE);
132}
133
134static void __exit vfio_mdev_exit(void)
135{
136 mdev_unregister_driver(&vfio_mdev_driver);
137}
138
139module_init(vfio_mdev_init)
140module_exit(vfio_mdev_exit)
141
142MODULE_VERSION(DRIVER_VERSION);
143MODULE_LICENSE("GPL v2");
144MODULE_AUTHOR(DRIVER_AUTHOR);
145MODULE_DESCRIPTION(DRIVER_DESC);