[mirror_ubuntu-bionic-kernel.git] / drivers / gpu / drm / i915 / gvt / gvt.c

/*
 * Copyright(c) 2011-2016 Intel Corporation. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * Authors:
 *    Kevin Tian <kevin.tian@intel.com>
 *    Eddie Dong <eddie.dong@intel.com>
 *
 * Contributors:
 *    Niu Bing <bing.niu@intel.com>
 *    Zhi Wang <zhi.a.wang@intel.com>
 *
 */

#include <linux/types.h>
#include <xen/xen.h>
#include <linux/kthread.h>

#include "i915_drv.h"
#include "gvt.h"

struct intel_gvt_host intel_gvt_host;

static const char * const supported_hypervisors[] = {
	[INTEL_GVT_HYPERVISOR_XEN] = "XEN",
	[INTEL_GVT_HYPERVISOR_KVM] = "KVM",
};

static const struct intel_gvt_ops intel_gvt_ops = {
	.emulate_cfg_read = intel_vgpu_emulate_cfg_read,
	.emulate_cfg_write = intel_vgpu_emulate_cfg_write,
	.emulate_mmio_read = intel_vgpu_emulate_mmio_read,
	.emulate_mmio_write = intel_vgpu_emulate_mmio_write,
	.vgpu_create = intel_gvt_create_vgpu,
	.vgpu_destroy = intel_gvt_destroy_vgpu,
	.vgpu_reset = intel_gvt_reset_vgpu,
	.vgpu_activate = intel_gvt_activate_vgpu,
	.vgpu_deactivate = intel_gvt_deactivate_vgpu,
};

/**
 * intel_gvt_init_host - Load MPT modules and detect if we're running in host
 * @gvt: intel gvt device
 *
 * This function is called at the driver loading stage. If failed to find a
 * loadable MPT module or detect currently we're running in a VM, then GVT-g
 * will be disabled
 *
 * Returns:
 * Zero on success, negative error code if failed.
 *
 */
int intel_gvt_init_host(void)
{
	if (intel_gvt_host.initialized)
		return 0;

	/* Xen DOM U */
	if (xen_domain() && !xen_initial_domain())
		return -ENODEV;

	/* Try to load MPT modules for hypervisors */
	if (xen_initial_domain()) {
		/* In Xen dom0 */
		intel_gvt_host.mpt = try_then_request_module(
				symbol_get(xengt_mpt), "xengt");
		intel_gvt_host.hypervisor_type = INTEL_GVT_HYPERVISOR_XEN;
	} else {
#if IS_ENABLED(CONFIG_DRM_I915_GVT_KVMGT)
		/* not in Xen. Try KVMGT */
		intel_gvt_host.mpt = try_then_request_module(
				symbol_get(kvmgt_mpt), "kvmgt");
		intel_gvt_host.hypervisor_type = INTEL_GVT_HYPERVISOR_KVM;
#endif
	}

	/* Fail to load MPT modules - bail out */
	if (!intel_gvt_host.mpt)
		return -EINVAL;

	gvt_dbg_core("Running with hypervisor %s in host mode\n",
			supported_hypervisors[intel_gvt_host.hypervisor_type]);

	intel_gvt_host.initialized = true;
	return 0;
}

static void init_device_info(struct intel_gvt *gvt)
{
	struct intel_gvt_device_info *info = &gvt->device_info;
	struct pci_dev *pdev = gvt->dev_priv->drm.pdev;

	if (IS_BROADWELL(gvt->dev_priv) || IS_SKYLAKE(gvt->dev_priv)) {
		info->max_support_vgpus = 8;
		info->cfg_space_size = 256;
		info->mmio_size = 2 * 1024 * 1024;
		info->mmio_bar = 0;
		info->gtt_start_offset = 8 * 1024 * 1024;
		info->gtt_entry_size = 8;
		info->gtt_entry_size_shift = 3;
		info->gmadr_bytes_in_cmd = 8;
		info->max_surface_size = 36 * 1024 * 1024;
	}
	info->msi_cap_offset = pdev->msi_cap;
}

static int gvt_service_thread(void *data)
{
	struct intel_gvt *gvt = (struct intel_gvt *)data;
	int ret;

	gvt_dbg_core("service thread start\n");

	while (!kthread_should_stop()) {
		ret = wait_event_interruptible(gvt->service_thread_wq,
				kthread_should_stop() || gvt->service_request);

		if (kthread_should_stop())
			break;

		if (WARN_ONCE(ret, "service thread is waken up by signal.\n"))
			continue;

		if (test_and_clear_bit(INTEL_GVT_REQUEST_EMULATE_VBLANK,
					(void *)&gvt->service_request)) {
			mutex_lock(&gvt->lock);
			intel_gvt_emulate_vblank(gvt);
			mutex_unlock(&gvt->lock);
		}
	}

	return 0;
}

static void clean_service_thread(struct intel_gvt *gvt)
{
	kthread_stop(gvt->service_thread);
}

static int init_service_thread(struct intel_gvt *gvt)
{
	init_waitqueue_head(&gvt->service_thread_wq);

	gvt->service_thread = kthread_run(gvt_service_thread,
			gvt, "gvt_service_thread");
	if (IS_ERR(gvt->service_thread)) {
		gvt_err("fail to start service thread.\n");
		return PTR_ERR(gvt->service_thread);
	}
	return 0;
}

/**
 * intel_gvt_clean_device - clean a GVT device
 * @gvt: intel gvt device
 *
 * This function is called at the driver unloading stage, to free the
 * resources owned by a GVT device.
 *
 */
void intel_gvt_clean_device(struct drm_i915_private *dev_priv)
{
	struct intel_gvt *gvt = to_gvt(dev_priv);

	if (WARN_ON(!gvt))
		return;

	clean_service_thread(gvt);
	intel_gvt_clean_cmd_parser(gvt);
	intel_gvt_clean_sched_policy(gvt);
	intel_gvt_clean_workload_scheduler(gvt);
	intel_gvt_clean_opregion(gvt);
	intel_gvt_clean_gtt(gvt);
	intel_gvt_clean_irq(gvt);
	intel_gvt_clean_mmio_info(gvt);
	intel_gvt_free_firmware(gvt);

	intel_gvt_hypervisor_host_exit(&dev_priv->drm.pdev->dev, gvt);
	intel_gvt_clean_vgpu_types(gvt);

	idr_destroy(&gvt->vgpu_idr);

	kfree(dev_priv->gvt);
	dev_priv->gvt = NULL;
}

/**
 * intel_gvt_init_device - initialize a GVT device
 * @dev_priv: drm i915 private data
 *
 * This function is called at the initialization stage, to initialize
 * necessary GVT components.
 *
 * Returns:
 * Zero on success, negative error code if failed.
 *
 */
int intel_gvt_init_device(struct drm_i915_private *dev_priv)
{
	struct intel_gvt *gvt;
	int ret;

	/*
	 * Cannot initialize GVT device without intel_gvt_host gets
	 * initialized first.
	 */
	if (WARN_ON(!intel_gvt_host.initialized))
		return -EINVAL;

	if (WARN_ON(dev_priv->gvt))
		return -EEXIST;

	gvt = kzalloc(sizeof(struct intel_gvt), GFP_KERNEL);
	if (!gvt)
		return -ENOMEM;

	gvt_dbg_core("init gvt device\n");

	idr_init(&gvt->vgpu_idr);

	mutex_init(&gvt->lock);
	gvt->dev_priv = dev_priv;

	init_device_info(gvt);

	ret = intel_gvt_setup_mmio_info(gvt);
	if (ret)
		goto out_clean_idr;

	ret = intel_gvt_load_firmware(gvt);
	if (ret)
		goto out_clean_mmio_info;

	ret = intel_gvt_init_irq(gvt);
	if (ret)
		goto out_free_firmware;

	ret = intel_gvt_init_gtt(gvt);
	if (ret)
		goto out_clean_irq;

	ret = intel_gvt_init_opregion(gvt);
	if (ret)
		goto out_clean_gtt;

	ret = intel_gvt_init_workload_scheduler(gvt);
	if (ret)
		goto out_clean_opregion;

	ret = intel_gvt_init_sched_policy(gvt);
	if (ret)
		goto out_clean_workload_scheduler;

	ret = intel_gvt_init_cmd_parser(gvt);
	if (ret)
		goto out_clean_sched_policy;

	ret = init_service_thread(gvt);
	if (ret)
		goto out_clean_cmd_parser;

	ret = intel_gvt_init_vgpu_types(gvt);
	if (ret)
		goto out_clean_thread;

	ret = intel_gvt_hypervisor_host_init(&dev_priv->drm.pdev->dev, gvt,
				&intel_gvt_ops);
	if (ret) {
		gvt_err("failed to register gvt-g host device: %d\n", ret);
		goto out_clean_types;
	}

	gvt_dbg_core("gvt device initialization is done\n");
	dev_priv->gvt = gvt;
	return 0;

out_clean_types:
	intel_gvt_clean_vgpu_types(gvt);
out_clean_thread:
	clean_service_thread(gvt);
out_clean_cmd_parser:
	intel_gvt_clean_cmd_parser(gvt);
out_clean_sched_policy:
	intel_gvt_clean_sched_policy(gvt);
out_clean_workload_scheduler:
	intel_gvt_clean_workload_scheduler(gvt);
out_clean_opregion:
	intel_gvt_clean_opregion(gvt);
out_clean_gtt:
	intel_gvt_clean_gtt(gvt);
out_clean_irq:
	intel_gvt_clean_irq(gvt);
out_free_firmware:
	intel_gvt_free_firmware(gvt);
out_clean_mmio_info:
	intel_gvt_clean_mmio_info(gvt);
out_clean_idr:
	idr_destroy(&gvt->vgpu_idr);
	kfree(gvt);
	return ret;
}
Commit	Line	Data
0ad35fed ZW	1	/*
	2	* Copyright(c) 2011-2016 Intel Corporation. All rights reserved.
	3	*
	4	* Permission is hereby granted, free of charge, to any person obtaining a
	5	* copy of this software and associated documentation files (the "Software"),
	6	* to deal in the Software without restriction, including without limitation
	7	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	8	* and/or sell copies of the Software, and to permit persons to whom the
	9	* Software is furnished to do so, subject to the following conditions:
	10	*
	11	* The above copyright notice and this permission notice (including the next
	12	* paragraph) shall be included in all copies or substantial portions of the
	13	* Software.
	14	*
	15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	16	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	18	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	19	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	20	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	21	* SOFTWARE.
12d14cc4 ZW	22	*
	23	* Authors:
	24	* Kevin Tian <kevin.tian@intel.com>
	25	* Eddie Dong <eddie.dong@intel.com>
	26	*
	27	* Contributors:
	28	* Niu Bing <bing.niu@intel.com>
	29	* Zhi Wang <zhi.a.wang@intel.com>
	30	*
0ad35fed ZW	31	*/
	32
	33	#include <linux/types.h>
	34	#include <xen/xen.h>
04d348ae	35	#include <linux/kthread.h>
0ad35fed ZW	36
0ad35fed ZW	37	#include "i915_drv.h"
feddf6e8	38	#include "gvt.h"
0ad35fed ZW	39
	40	struct intel_gvt_host intel_gvt_host;
	41
	42	static const char * const supported_hypervisors[] = {
	43	[INTEL_GVT_HYPERVISOR_XEN] = "XEN",
	44	[INTEL_GVT_HYPERVISOR_KVM] = "KVM",
	45	};
	46
9ec1e66b	47	static const struct intel_gvt_ops intel_gvt_ops = {
4d60c5fd ZW	48	.emulate_cfg_read = intel_vgpu_emulate_cfg_read,
4d60c5fd ZW	49	.emulate_cfg_write = intel_vgpu_emulate_cfg_write,
e39c5add ZW	50	.emulate_mmio_read = intel_vgpu_emulate_mmio_read,
e39c5add ZW	51	.emulate_mmio_write = intel_vgpu_emulate_mmio_write,
9ec1e66b JS	52	.vgpu_create = intel_gvt_create_vgpu,
	53	.vgpu_destroy = intel_gvt_destroy_vgpu,
	54	.vgpu_reset = intel_gvt_reset_vgpu,
b79c52ae ZW	55	.vgpu_activate = intel_gvt_activate_vgpu,
b79c52ae ZW	56	.vgpu_deactivate = intel_gvt_deactivate_vgpu,
4d60c5fd ZW	57	};
4d60c5fd ZW	58
0ad35fed ZW	59	/**
	60	* intel_gvt_init_host - Load MPT modules and detect if we're running in host
	61	* @gvt: intel gvt device
	62	*
	63	* This function is called at the driver loading stage. If failed to find a
	64	* loadable MPT module or detect currently we're running in a VM, then GVT-g
	65	* will be disabled
	66	*
	67	* Returns:
	68	* Zero on success, negative error code if failed.
	69	*
	70	*/
	71	int intel_gvt_init_host(void)
	72	{
	73	if (intel_gvt_host.initialized)
	74	return 0;
	75
	76	/* Xen DOM U */
	77	if (xen_domain() && !xen_initial_domain())
	78	return -ENODEV;
	79
	80	/* Try to load MPT modules for hypervisors */
	81	if (xen_initial_domain()) {
	82	/* In Xen dom0 */
	83	intel_gvt_host.mpt = try_then_request_module(
	84	symbol_get(xengt_mpt), "xengt");
	85	intel_gvt_host.hypervisor_type = INTEL_GVT_HYPERVISOR_XEN;
	86	} else {
f30437c5	87	#if IS_ENABLED(CONFIG_DRM_I915_GVT_KVMGT)
0ad35fed ZW	88	/* not in Xen. Try KVMGT */
0ad35fed ZW	89	intel_gvt_host.mpt = try_then_request_module(
f30437c5	90	symbol_get(kvmgt_mpt), "kvmgt");
0ad35fed	91	intel_gvt_host.hypervisor_type = INTEL_GVT_HYPERVISOR_KVM;
f30437c5	92	#endif
0ad35fed ZW	93	}
	94
	95	/* Fail to load MPT modules - bail out */
	96	if (!intel_gvt_host.mpt)
	97	return -EINVAL;
	98
0ad35fed ZW	99	gvt_dbg_core("Running with hypervisor %s in host mode\n",
	100	supported_hypervisors[intel_gvt_host.hypervisor_type]);
	101
	102	intel_gvt_host.initialized = true;
	103	return 0;
	104	}
	105
	106	static void init_device_info(struct intel_gvt *gvt)
	107	{
12d14cc4	108	struct intel_gvt_device_info *info = &gvt->device_info;
49129204	109	struct pci_dev *pdev = gvt->dev_priv->drm.pdev;
12d14cc4 ZW	110
	111	if (IS_BROADWELL(gvt->dev_priv) \|\| IS_SKYLAKE(gvt->dev_priv)) {
	112	info->max_support_vgpus = 8;
579cea5f	113	info->cfg_space_size = 256;
c8fe6a68	114	info->mmio_size = 2 * 1024 * 1024;
579cea5f	115	info->mmio_bar = 0;
2707e444 ZW	116	info->gtt_start_offset = 8 * 1024 * 1024;
	117	info->gtt_entry_size = 8;
	118	info->gtt_entry_size_shift = 3;
be1da707 ZW	119	info->gmadr_bytes_in_cmd = 8;
be1da707 ZW	120	info->max_surface_size = 36 * 1024 * 1024;
12d14cc4	121	}
49129204	122	info->msi_cap_offset = pdev->msi_cap;
0ad35fed ZW	123	}
0ad35fed ZW	124
04d348ae ZW	125	static int gvt_service_thread(void *data)
	126	{
	127	struct intel_gvt gvt = (struct intel_gvt )data;
	128	int ret;
	129
	130	gvt_dbg_core("service thread start\n");
	131
	132	while (!kthread_should_stop()) {
	133	ret = wait_event_interruptible(gvt->service_thread_wq,
	134	kthread_should_stop() \|\| gvt->service_request);
	135
	136	if (kthread_should_stop())
	137	break;
	138
	139	if (WARN_ONCE(ret, "service thread is waken up by signal.\n"))
	140	continue;
	141
	142	if (test_and_clear_bit(INTEL_GVT_REQUEST_EMULATE_VBLANK,
	143	(void *)&gvt->service_request)) {
	144	mutex_lock(&gvt->lock);
	145	intel_gvt_emulate_vblank(gvt);
	146	mutex_unlock(&gvt->lock);
	147	}
	148	}
	149
	150	return 0;
	151	}
	152
	153	static void clean_service_thread(struct intel_gvt *gvt)
	154	{
	155	kthread_stop(gvt->service_thread);
	156	}
	157
	158	static int init_service_thread(struct intel_gvt *gvt)
	159	{
	160	init_waitqueue_head(&gvt->service_thread_wq);
	161
	162	gvt->service_thread = kthread_run(gvt_service_thread,
	163	gvt, "gvt_service_thread");
	164	if (IS_ERR(gvt->service_thread)) {
	165	gvt_err("fail to start service thread.\n");
	166	return PTR_ERR(gvt->service_thread);
	167	}
	168	return 0;
	169	}
	170
0ad35fed ZW	171	/**
	172	* intel_gvt_clean_device - clean a GVT device
	173	* @gvt: intel gvt device
	174	*
	175	* This function is called at the driver unloading stage, to free the
	176	* resources owned by a GVT device.
	177	*
	178	*/
	179	void intel_gvt_clean_device(struct drm_i915_private *dev_priv)
	180	{
feddf6e8	181	struct intel_gvt *gvt = to_gvt(dev_priv);
0ad35fed	182
feddf6e8	183	if (WARN_ON(!gvt))
0ad35fed ZW	184	return;
0ad35fed ZW	185
04d348ae	186	clean_service_thread(gvt);
be1da707	187	intel_gvt_clean_cmd_parser(gvt);
4b63960e	188	intel_gvt_clean_sched_policy(gvt);
e4734057	189	intel_gvt_clean_workload_scheduler(gvt);
4d60c5fd	190	intel_gvt_clean_opregion(gvt);
2707e444	191	intel_gvt_clean_gtt(gvt);
c8fe6a68	192	intel_gvt_clean_irq(gvt);
12d14cc4	193	intel_gvt_clean_mmio_info(gvt);
579cea5f	194	intel_gvt_free_firmware(gvt);
0ad35fed	195
40df6ea0	196	intel_gvt_hypervisor_host_exit(&dev_priv->drm.pdev->dev, gvt);
1f31c829 ZW	197	intel_gvt_clean_vgpu_types(gvt);
1f31c829 ZW	198
59c0573d JS	199	idr_destroy(&gvt->vgpu_idr);
59c0573d JS	200
feddf6e8 ZW	201	kfree(dev_priv->gvt);
feddf6e8 ZW	202	dev_priv->gvt = NULL;
0ad35fed ZW	203	}
	204
	205	/**
	206	* intel_gvt_init_device - initialize a GVT device
	207	* @dev_priv: drm i915 private data
	208	*
	209	* This function is called at the initialization stage, to initialize
	210	* necessary GVT components.
	211	*
	212	* Returns:
	213	* Zero on success, negative error code if failed.
	214	*
	215	*/
	216	int intel_gvt_init_device(struct drm_i915_private *dev_priv)
	217	{
feddf6e8	218	struct intel_gvt *gvt;
12d14cc4 ZW	219	int ret;
12d14cc4 ZW	220
0ad35fed ZW	221	/*
	222	* Cannot initialize GVT device without intel_gvt_host gets
	223	* initialized first.
	224	*/
	225	if (WARN_ON(!intel_gvt_host.initialized))
	226	return -EINVAL;
	227
feddf6e8	228	if (WARN_ON(dev_priv->gvt))
0ad35fed ZW	229	return -EEXIST;
0ad35fed ZW	230
feddf6e8 ZW	231	gvt = kzalloc(sizeof(struct intel_gvt), GFP_KERNEL);
	232	if (!gvt)
	233	return -ENOMEM;
	234
0ad35fed ZW	235	gvt_dbg_core("init gvt device\n");
0ad35fed ZW	236
59c0573d JS	237	idr_init(&gvt->vgpu_idr);
59c0573d JS	238
28a60dee ZW	239	mutex_init(&gvt->lock);
	240	gvt->dev_priv = dev_priv;
	241
0ad35fed	242	init_device_info(gvt);
12d14cc4 ZW	243
	244	ret = intel_gvt_setup_mmio_info(gvt);
	245	if (ret)
59c0573d	246	goto out_clean_idr;
12d14cc4	247
579cea5f ZW	248	ret = intel_gvt_load_firmware(gvt);
	249	if (ret)
	250	goto out_clean_mmio_info;
	251
c8fe6a68 ZW	252	ret = intel_gvt_init_irq(gvt);
	253	if (ret)
	254	goto out_free_firmware;
	255
2707e444 ZW	256	ret = intel_gvt_init_gtt(gvt);
	257	if (ret)
	258	goto out_clean_irq;
	259
4d60c5fd ZW	260	ret = intel_gvt_init_opregion(gvt);
	261	if (ret)
	262	goto out_clean_gtt;
	263
e4734057	264	ret = intel_gvt_init_workload_scheduler(gvt);
04d348ae ZW	265	if (ret)
	266	goto out_clean_opregion;
	267
4b63960e	268	ret = intel_gvt_init_sched_policy(gvt);
e4734057 ZW	269	if (ret)
	270	goto out_clean_workload_scheduler;
	271
be1da707	272	ret = intel_gvt_init_cmd_parser(gvt);
4b63960e ZW	273	if (ret)
	274	goto out_clean_sched_policy;
	275
be1da707 ZW	276	ret = init_service_thread(gvt);
	277	if (ret)
	278	goto out_clean_cmd_parser;
	279
1f31c829 ZW	280	ret = intel_gvt_init_vgpu_types(gvt);
	281	if (ret)
	282	goto out_clean_thread;
	283
40df6ea0	284	ret = intel_gvt_hypervisor_host_init(&dev_priv->drm.pdev->dev, gvt,
9ec1e66b	285	&intel_gvt_ops);
40df6ea0 JS	286	if (ret) {
	287	gvt_err("failed to register gvt-g host device: %d\n", ret);
	288	goto out_clean_types;
	289	}
1f31c829 ZW	290
1f31c829 ZW	291	gvt_dbg_core("gvt device initialization is done\n");
feddf6e8	292	dev_priv->gvt = gvt;
0ad35fed	293	return 0;
579cea5f	294
40df6ea0 JS	295	out_clean_types:
40df6ea0 JS	296	intel_gvt_clean_vgpu_types(gvt);
1f31c829 ZW	297	out_clean_thread:
1f31c829 ZW	298	clean_service_thread(gvt);
be1da707 ZW	299	out_clean_cmd_parser:
be1da707 ZW	300	intel_gvt_clean_cmd_parser(gvt);
4b63960e ZW	301	out_clean_sched_policy:
4b63960e ZW	302	intel_gvt_clean_sched_policy(gvt);
e4734057 ZW	303	out_clean_workload_scheduler:
e4734057 ZW	304	intel_gvt_clean_workload_scheduler(gvt);
04d348ae ZW	305	out_clean_opregion:
04d348ae ZW	306	intel_gvt_clean_opregion(gvt);
4d60c5fd ZW	307	out_clean_gtt:
4d60c5fd ZW	308	intel_gvt_clean_gtt(gvt);
2707e444 ZW	309	out_clean_irq:
2707e444 ZW	310	intel_gvt_clean_irq(gvt);
c8fe6a68 ZW	311	out_free_firmware:
c8fe6a68 ZW	312	intel_gvt_free_firmware(gvt);
579cea5f ZW	313	out_clean_mmio_info:
579cea5f ZW	314	intel_gvt_clean_mmio_info(gvt);
59c0573d JS	315	out_clean_idr:
59c0573d JS	316	idr_destroy(&gvt->vgpu_idr);
feddf6e8	317	kfree(gvt);
579cea5f	318	return ret;
0ad35fed	319	}