2 * Mediated device Core Driver
4 * Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
5 * Author: Neo Jia <cjia@nvidia.com>
6 * Kirti Wankhede <kwankhede@nvidia.com>
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.
13 #include <linux/module.h>
14 #include <linux/device.h>
15 #include <linux/slab.h>
16 #include <linux/uuid.h>
17 #include <linux/sysfs.h>
18 #include <linux/mdev.h>
20 #include "mdev_private.h"
22 #define DRIVER_VERSION "0.1"
23 #define DRIVER_AUTHOR "NVIDIA Corporation"
24 #define DRIVER_DESC "Mediated device Core Driver"
26 static LIST_HEAD(parent_list
);
27 static DEFINE_MUTEX(parent_list_lock
);
28 static struct class_compat
*mdev_bus_compat_class
;
30 static LIST_HEAD(mdev_list
);
31 static DEFINE_MUTEX(mdev_list_lock
);
33 struct device
*mdev_parent_dev(struct mdev_device
*mdev
)
35 return mdev
->parent
->dev
;
37 EXPORT_SYMBOL(mdev_parent_dev
);
39 void *mdev_get_drvdata(struct mdev_device
*mdev
)
41 return mdev
->driver_data
;
43 EXPORT_SYMBOL(mdev_get_drvdata
);
45 void mdev_set_drvdata(struct mdev_device
*mdev
, void *data
)
47 mdev
->driver_data
= data
;
49 EXPORT_SYMBOL(mdev_set_drvdata
);
51 struct device
*mdev_dev(struct mdev_device
*mdev
)
55 EXPORT_SYMBOL(mdev_dev
);
57 struct mdev_device
*mdev_from_dev(struct device
*dev
)
59 return dev_is_mdev(dev
) ? to_mdev_device(dev
) : NULL
;
61 EXPORT_SYMBOL(mdev_from_dev
);
63 uuid_le
mdev_uuid(struct mdev_device
*mdev
)
67 EXPORT_SYMBOL(mdev_uuid
);
69 /* Should be called holding parent_list_lock */
70 static struct mdev_parent
*__find_parent_device(struct device
*dev
)
72 struct mdev_parent
*parent
;
74 list_for_each_entry(parent
, &parent_list
, next
) {
75 if (parent
->dev
== dev
)
81 static void mdev_release_parent(struct kref
*kref
)
83 struct mdev_parent
*parent
= container_of(kref
, struct mdev_parent
,
85 struct device
*dev
= parent
->dev
;
92 inline struct mdev_parent
*mdev_get_parent(struct mdev_parent
*parent
)
95 kref_get(&parent
->ref
);
100 static inline void mdev_put_parent(struct mdev_parent
*parent
)
103 kref_put(&parent
->ref
, mdev_release_parent
);
106 static int mdev_device_create_ops(struct kobject
*kobj
,
107 struct mdev_device
*mdev
)
109 struct mdev_parent
*parent
= mdev
->parent
;
112 ret
= parent
->ops
->create(kobj
, mdev
);
116 ret
= sysfs_create_groups(&mdev
->dev
.kobj
,
117 parent
->ops
->mdev_attr_groups
);
119 parent
->ops
->remove(mdev
);
125 * mdev_device_remove_ops gets called from sysfs's 'remove' and when parent
126 * device is being unregistered from mdev device framework.
127 * - 'force_remove' is set to 'false' when called from sysfs's 'remove' which
128 * indicates that if the mdev device is active, used by VMM or userspace
129 * application, vendor driver could return error then don't remove the device.
130 * - 'force_remove' is set to 'true' when called from mdev_unregister_device()
131 * which indicate that parent device is being removed from mdev device
132 * framework so remove mdev device forcefully.
134 static int mdev_device_remove_ops(struct mdev_device
*mdev
, bool force_remove
)
136 struct mdev_parent
*parent
= mdev
->parent
;
140 * Vendor driver can return error if VMM or userspace application is
141 * using this mdev device.
143 ret
= parent
->ops
->remove(mdev
);
144 if (ret
&& !force_remove
)
147 sysfs_remove_groups(&mdev
->dev
.kobj
, parent
->ops
->mdev_attr_groups
);
151 static int mdev_device_remove_cb(struct device
*dev
, void *data
)
153 if (!dev_is_mdev(dev
))
156 return mdev_device_remove(dev
, data
? *(bool *)data
: true);
160 * mdev_register_device : Register a device
161 * @dev: device structure representing parent device.
162 * @ops: Parent device operation structure to be registered.
164 * Add device to list of registered parent devices.
165 * Returns a negative value on error, otherwise 0.
167 int mdev_register_device(struct device
*dev
, const struct mdev_parent_ops
*ops
)
170 struct mdev_parent
*parent
;
172 /* check for mandatory ops */
173 if (!ops
|| !ops
->create
|| !ops
->remove
|| !ops
->supported_type_groups
)
176 dev
= get_device(dev
);
180 mutex_lock(&parent_list_lock
);
182 /* Check for duplicate */
183 parent
= __find_parent_device(dev
);
189 parent
= kzalloc(sizeof(*parent
), GFP_KERNEL
);
195 kref_init(&parent
->ref
);
200 if (!mdev_bus_compat_class
) {
201 mdev_bus_compat_class
= class_compat_register("mdev_bus");
202 if (!mdev_bus_compat_class
) {
208 ret
= parent_create_sysfs_files(parent
);
212 ret
= class_compat_create_link(mdev_bus_compat_class
, dev
, NULL
);
214 dev_warn(dev
, "Failed to create compatibility class link\n");
216 list_add(&parent
->next
, &parent_list
);
217 mutex_unlock(&parent_list_lock
);
219 dev_info(dev
, "MDEV: Registered\n");
223 mutex_unlock(&parent_list_lock
);
225 mdev_put_parent(parent
);
230 EXPORT_SYMBOL(mdev_register_device
);
233 * mdev_unregister_device : Unregister a parent device
234 * @dev: device structure representing parent device.
236 * Remove device from list of registered parent devices. Give a chance to free
237 * existing mediated devices for given device.
240 void mdev_unregister_device(struct device
*dev
)
242 struct mdev_parent
*parent
;
243 bool force_remove
= true;
245 mutex_lock(&parent_list_lock
);
246 parent
= __find_parent_device(dev
);
249 mutex_unlock(&parent_list_lock
);
252 dev_info(dev
, "MDEV: Unregistering\n");
254 list_del(&parent
->next
);
255 class_compat_remove_link(mdev_bus_compat_class
, dev
, NULL
);
257 device_for_each_child(dev
, (void *)&force_remove
,
258 mdev_device_remove_cb
);
260 parent_remove_sysfs_files(parent
);
262 mutex_unlock(&parent_list_lock
);
263 mdev_put_parent(parent
);
265 EXPORT_SYMBOL(mdev_unregister_device
);
267 static void mdev_device_release(struct device
*dev
)
269 struct mdev_device
*mdev
= to_mdev_device(dev
);
271 mutex_lock(&mdev_list_lock
);
272 list_del(&mdev
->next
);
273 mutex_unlock(&mdev_list_lock
);
275 dev_dbg(&mdev
->dev
, "MDEV: destroying\n");
279 int mdev_device_create(struct kobject
*kobj
, struct device
*dev
, uuid_le uuid
)
282 struct mdev_device
*mdev
, *tmp
;
283 struct mdev_parent
*parent
;
284 struct mdev_type
*type
= to_mdev_type(kobj
);
286 parent
= mdev_get_parent(type
->parent
);
290 mutex_lock(&mdev_list_lock
);
292 /* Check for duplicate */
293 list_for_each_entry(tmp
, &mdev_list
, next
) {
294 if (!uuid_le_cmp(tmp
->uuid
, uuid
)) {
295 mutex_unlock(&mdev_list_lock
);
301 mdev
= kzalloc(sizeof(*mdev
), GFP_KERNEL
);
303 mutex_unlock(&mdev_list_lock
);
308 memcpy(&mdev
->uuid
, &uuid
, sizeof(uuid_le
));
309 list_add(&mdev
->next
, &mdev_list
);
310 mutex_unlock(&mdev_list_lock
);
312 mdev
->parent
= parent
;
313 kref_init(&mdev
->ref
);
315 mdev
->dev
.parent
= dev
;
316 mdev
->dev
.bus
= &mdev_bus_type
;
317 mdev
->dev
.release
= mdev_device_release
;
318 dev_set_name(&mdev
->dev
, "%pUl", uuid
.b
);
320 ret
= device_register(&mdev
->dev
);
322 put_device(&mdev
->dev
);
326 ret
= mdev_device_create_ops(kobj
, mdev
);
330 ret
= mdev_create_sysfs_files(&mdev
->dev
, type
);
332 mdev_device_remove_ops(mdev
, true);
336 mdev
->type_kobj
= kobj
;
338 dev_dbg(&mdev
->dev
, "MDEV: created\n");
343 device_unregister(&mdev
->dev
);
345 mdev_put_parent(parent
);
349 int mdev_device_remove(struct device
*dev
, bool force_remove
)
351 struct mdev_device
*mdev
, *tmp
;
352 struct mdev_parent
*parent
;
353 struct mdev_type
*type
;
356 mdev
= to_mdev_device(dev
);
358 mutex_lock(&mdev_list_lock
);
359 list_for_each_entry(tmp
, &mdev_list
, next
) {
365 mutex_unlock(&mdev_list_lock
);
370 mutex_unlock(&mdev_list_lock
);
374 mdev
->active
= false;
375 mutex_unlock(&mdev_list_lock
);
377 type
= to_mdev_type(mdev
->type_kobj
);
378 parent
= mdev
->parent
;
380 ret
= mdev_device_remove_ops(mdev
, force_remove
);
386 mdev_remove_sysfs_files(dev
, type
);
387 device_unregister(dev
);
388 mdev_put_parent(parent
);
393 static int __init
mdev_init(void)
395 return mdev_bus_register();
398 static void __exit
mdev_exit(void)
400 if (mdev_bus_compat_class
)
401 class_compat_unregister(mdev_bus_compat_class
);
403 mdev_bus_unregister();
406 module_init(mdev_init
)
407 module_exit(mdev_exit
)
409 MODULE_VERSION(DRIVER_VERSION
);
410 MODULE_LICENSE("GPL v2");
411 MODULE_AUTHOR(DRIVER_AUTHOR
);
412 MODULE_DESCRIPTION(DRIVER_DESC
);
413 MODULE_SOFTDEP("post: vfio_mdev");