[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",
};

struct intel_gvt_io_emulation_ops intel_gvt_io_emulation_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,
};

/**
 * 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)
{
	int ret;

	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 {
		/* not in Xen. Try KVMGT */
		intel_gvt_host.mpt = try_then_request_module(
				symbol_get(kvmgt_mpt), "kvm");
		intel_gvt_host.hypervisor_type = INTEL_GVT_HYPERVISOR_KVM;
	}

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

	/* Try to detect if we're running in host instead of VM. */
	ret = intel_gvt_hypervisor_detect_host();
	if (ret)
		return -ENODEV;

	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_clean_vgpu_types(gvt);

	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");

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

	init_device_info(gvt);

	ret = intel_gvt_setup_mmio_info(gvt);
	if (ret)
		return ret;

	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;


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

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);
	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
4d60c5fd ZW	47	struct intel_gvt_io_emulation_ops intel_gvt_io_emulation_ops = {
	48	.emulate_cfg_read = intel_vgpu_emulate_cfg_read,
	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,
4d60c5fd ZW	52	};
4d60c5fd ZW	53
0ad35fed ZW	54	/**
	55	* intel_gvt_init_host - Load MPT modules and detect if we're running in host
	56	* @gvt: intel gvt device
	57	*
	58	* This function is called at the driver loading stage. If failed to find a
	59	* loadable MPT module or detect currently we're running in a VM, then GVT-g
	60	* will be disabled
	61	*
	62	* Returns:
	63	* Zero on success, negative error code if failed.
	64	*
	65	*/
	66	int intel_gvt_init_host(void)
	67	{
b0122f31 XC	68	int ret;
b0122f31 XC	69
0ad35fed ZW	70	if (intel_gvt_host.initialized)
	71	return 0;
	72
	73	/* Xen DOM U */
	74	if (xen_domain() && !xen_initial_domain())
	75	return -ENODEV;
	76
	77	/* Try to load MPT modules for hypervisors */
	78	if (xen_initial_domain()) {
	79	/* In Xen dom0 */
	80	intel_gvt_host.mpt = try_then_request_module(
	81	symbol_get(xengt_mpt), "xengt");
	82	intel_gvt_host.hypervisor_type = INTEL_GVT_HYPERVISOR_XEN;
	83	} else {
	84	/* not in Xen. Try KVMGT */
	85	intel_gvt_host.mpt = try_then_request_module(
	86	symbol_get(kvmgt_mpt), "kvm");
	87	intel_gvt_host.hypervisor_type = INTEL_GVT_HYPERVISOR_KVM;
	88	}
	89
	90	/* Fail to load MPT modules - bail out */
	91	if (!intel_gvt_host.mpt)
	92	return -EINVAL;
	93
	94	/* Try to detect if we're running in host instead of VM. */
b0122f31 XC	95	ret = intel_gvt_hypervisor_detect_host();
b0122f31 XC	96	if (ret)
0ad35fed ZW	97	return -ENODEV;
	98
	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
1f31c829 ZW	196	intel_gvt_clean_vgpu_types(gvt);
1f31c829 ZW	197
feddf6e8 ZW	198	kfree(dev_priv->gvt);
feddf6e8 ZW	199	dev_priv->gvt = NULL;
0ad35fed ZW	200	}
	201
	202	/**
	203	* intel_gvt_init_device - initialize a GVT device
	204	* @dev_priv: drm i915 private data
	205	*
	206	* This function is called at the initialization stage, to initialize
	207	* necessary GVT components.
	208	*
	209	* Returns:
	210	* Zero on success, negative error code if failed.
	211	*
	212	*/
	213	int intel_gvt_init_device(struct drm_i915_private *dev_priv)
	214	{
feddf6e8	215	struct intel_gvt *gvt;
12d14cc4 ZW	216	int ret;
12d14cc4 ZW	217
0ad35fed ZW	218	/*
	219	* Cannot initialize GVT device without intel_gvt_host gets
	220	* initialized first.
	221	*/
	222	if (WARN_ON(!intel_gvt_host.initialized))
	223	return -EINVAL;
	224
feddf6e8	225	if (WARN_ON(dev_priv->gvt))
0ad35fed ZW	226	return -EEXIST;
0ad35fed ZW	227
feddf6e8 ZW	228	gvt = kzalloc(sizeof(struct intel_gvt), GFP_KERNEL);
	229	if (!gvt)
	230	return -ENOMEM;
	231
0ad35fed ZW	232	gvt_dbg_core("init gvt device\n");
0ad35fed ZW	233
28a60dee ZW	234	mutex_init(&gvt->lock);
	235	gvt->dev_priv = dev_priv;
	236
0ad35fed	237	init_device_info(gvt);
12d14cc4 ZW	238
	239	ret = intel_gvt_setup_mmio_info(gvt);
	240	if (ret)
	241	return ret;
	242
579cea5f ZW	243	ret = intel_gvt_load_firmware(gvt);
	244	if (ret)
	245	goto out_clean_mmio_info;
	246
c8fe6a68 ZW	247	ret = intel_gvt_init_irq(gvt);
	248	if (ret)
	249	goto out_free_firmware;
	250
2707e444 ZW	251	ret = intel_gvt_init_gtt(gvt);
	252	if (ret)
	253	goto out_clean_irq;
	254
4d60c5fd ZW	255	ret = intel_gvt_init_opregion(gvt);
	256	if (ret)
	257	goto out_clean_gtt;
	258
e4734057	259	ret = intel_gvt_init_workload_scheduler(gvt);
04d348ae ZW	260	if (ret)
	261	goto out_clean_opregion;
	262
4b63960e	263	ret = intel_gvt_init_sched_policy(gvt);
e4734057 ZW	264	if (ret)
	265	goto out_clean_workload_scheduler;
	266
be1da707	267	ret = intel_gvt_init_cmd_parser(gvt);
4b63960e ZW	268	if (ret)
	269	goto out_clean_sched_policy;
	270
be1da707 ZW	271	ret = init_service_thread(gvt);
	272	if (ret)
	273	goto out_clean_cmd_parser;
	274
1f31c829 ZW	275	ret = intel_gvt_init_vgpu_types(gvt);
	276	if (ret)
	277	goto out_clean_thread;
	278
	279
	280	gvt_dbg_core("gvt device initialization is done\n");
feddf6e8	281	dev_priv->gvt = gvt;
0ad35fed	282	return 0;
579cea5f	283
1f31c829 ZW	284	out_clean_thread:
1f31c829 ZW	285	clean_service_thread(gvt);
be1da707 ZW	286	out_clean_cmd_parser:
be1da707 ZW	287	intel_gvt_clean_cmd_parser(gvt);
4b63960e ZW	288	out_clean_sched_policy:
4b63960e ZW	289	intel_gvt_clean_sched_policy(gvt);
e4734057 ZW	290	out_clean_workload_scheduler:
e4734057 ZW	291	intel_gvt_clean_workload_scheduler(gvt);
04d348ae ZW	292	out_clean_opregion:
04d348ae ZW	293	intel_gvt_clean_opregion(gvt);
4d60c5fd ZW	294	out_clean_gtt:
4d60c5fd ZW	295	intel_gvt_clean_gtt(gvt);
2707e444 ZW	296	out_clean_irq:
2707e444 ZW	297	intel_gvt_clean_irq(gvt);
c8fe6a68 ZW	298	out_free_firmware:
c8fe6a68 ZW	299	intel_gvt_free_firmware(gvt);
579cea5f ZW	300	out_clean_mmio_info:
579cea5f ZW	301	intel_gvt_clean_mmio_info(gvt);
feddf6e8	302	kfree(gvt);
579cea5f	303	return ret;
0ad35fed	304	}