2 * Copyright(c) 2011-2016 Intel Corporation. All rights reserved.
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:
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
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
24 * Kevin Tian <kevin.tian@intel.com>
25 * Eddie Dong <eddie.dong@intel.com>
28 * Niu Bing <bing.niu@intel.com>
29 * Zhi Wang <zhi.a.wang@intel.com>
33 #include <linux/types.h>
35 #include <linux/kthread.h>
39 #include <linux/vfio.h>
40 #include <linux/mdev.h>
42 struct intel_gvt_host intel_gvt_host
;
44 static const char * const supported_hypervisors
[] = {
45 [INTEL_GVT_HYPERVISOR_XEN
] = "XEN",
46 [INTEL_GVT_HYPERVISOR_KVM
] = "KVM",
49 static struct intel_vgpu_type
*intel_gvt_find_vgpu_type(struct intel_gvt
*gvt
,
53 struct intel_vgpu_type
*t
;
54 const char *driver_name
= dev_driver_string(
55 &gvt
->dev_priv
->drm
.pdev
->dev
);
57 for (i
= 0; i
< gvt
->num_types
; i
++) {
59 if (!strncmp(t
->name
, name
+ strlen(driver_name
) + 1,
67 static ssize_t
available_instances_show(struct kobject
*kobj
,
68 struct device
*dev
, char *buf
)
70 struct intel_vgpu_type
*type
;
72 void *gvt
= kdev_to_i915(dev
)->gvt
;
74 type
= intel_gvt_find_vgpu_type(gvt
, kobject_name(kobj
));
78 num
= type
->avail_instance
;
80 return sprintf(buf
, "%u\n", num
);
83 static ssize_t
device_api_show(struct kobject
*kobj
, struct device
*dev
,
86 return sprintf(buf
, "%s\n", VFIO_DEVICE_API_PCI_STRING
);
89 static ssize_t
description_show(struct kobject
*kobj
, struct device
*dev
,
92 struct intel_vgpu_type
*type
;
93 void *gvt
= kdev_to_i915(dev
)->gvt
;
95 type
= intel_gvt_find_vgpu_type(gvt
, kobject_name(kobj
));
99 return sprintf(buf
, "low_gm_size: %dMB\nhigh_gm_size: %dMB\n"
100 "fence: %d\nresolution: %s\n"
102 BYTES_TO_MB(type
->low_gm_size
),
103 BYTES_TO_MB(type
->high_gm_size
),
104 type
->fence
, vgpu_edid_str(type
->resolution
),
108 static MDEV_TYPE_ATTR_RO(available_instances
);
109 static MDEV_TYPE_ATTR_RO(device_api
);
110 static MDEV_TYPE_ATTR_RO(description
);
112 static struct attribute
*gvt_type_attrs
[] = {
113 &mdev_type_attr_available_instances
.attr
,
114 &mdev_type_attr_device_api
.attr
,
115 &mdev_type_attr_description
.attr
,
119 static struct attribute_group
*gvt_vgpu_type_groups
[] = {
120 [0 ... NR_MAX_INTEL_VGPU_TYPES
- 1] = NULL
,
123 static bool intel_get_gvt_attrs(struct attribute
***type_attrs
,
124 struct attribute_group
***intel_vgpu_type_groups
)
126 *type_attrs
= gvt_type_attrs
;
127 *intel_vgpu_type_groups
= gvt_vgpu_type_groups
;
131 static bool intel_gvt_init_vgpu_type_groups(struct intel_gvt
*gvt
)
134 struct intel_vgpu_type
*type
;
135 struct attribute_group
*group
;
137 for (i
= 0; i
< gvt
->num_types
; i
++) {
138 type
= &gvt
->types
[i
];
140 group
= kzalloc(sizeof(struct attribute_group
), GFP_KERNEL
);
144 group
->name
= type
->name
;
145 group
->attrs
= gvt_type_attrs
;
146 gvt_vgpu_type_groups
[i
] = group
;
152 for (j
= 0; j
< i
; j
++) {
153 group
= gvt_vgpu_type_groups
[j
];
160 static void intel_gvt_cleanup_vgpu_type_groups(struct intel_gvt
*gvt
)
163 struct attribute_group
*group
;
165 for (i
= 0; i
< gvt
->num_types
; i
++) {
166 group
= gvt_vgpu_type_groups
[i
];
167 gvt_vgpu_type_groups
[i
] = NULL
;
172 static const struct intel_gvt_ops intel_gvt_ops
= {
173 .emulate_cfg_read
= intel_vgpu_emulate_cfg_read
,
174 .emulate_cfg_write
= intel_vgpu_emulate_cfg_write
,
175 .emulate_mmio_read
= intel_vgpu_emulate_mmio_read
,
176 .emulate_mmio_write
= intel_vgpu_emulate_mmio_write
,
177 .vgpu_create
= intel_gvt_create_vgpu
,
178 .vgpu_destroy
= intel_gvt_destroy_vgpu
,
179 .vgpu_release
= intel_gvt_release_vgpu
,
180 .vgpu_reset
= intel_gvt_reset_vgpu
,
181 .vgpu_activate
= intel_gvt_activate_vgpu
,
182 .vgpu_deactivate
= intel_gvt_deactivate_vgpu
,
183 .gvt_find_vgpu_type
= intel_gvt_find_vgpu_type
,
184 .get_gvt_attrs
= intel_get_gvt_attrs
,
185 .vgpu_query_plane
= intel_vgpu_query_plane
,
186 .vgpu_get_dmabuf
= intel_vgpu_get_dmabuf
,
187 .write_protect_handler
= intel_vgpu_page_track_handler
,
191 * intel_gvt_init_host - Load MPT modules and detect if we're running in host
193 * This function is called at the driver loading stage. If failed to find a
194 * loadable MPT module or detect currently we're running in a VM, then GVT-g
198 * Zero on success, negative error code if failed.
201 int intel_gvt_init_host(void)
203 if (intel_gvt_host
.initialized
)
207 if (xen_domain() && !xen_initial_domain())
210 /* Try to load MPT modules for hypervisors */
211 if (xen_initial_domain()) {
213 intel_gvt_host
.mpt
= try_then_request_module(
214 symbol_get(xengt_mpt
), "xengt");
215 intel_gvt_host
.hypervisor_type
= INTEL_GVT_HYPERVISOR_XEN
;
217 #if IS_ENABLED(CONFIG_DRM_I915_GVT_KVMGT)
218 /* not in Xen. Try KVMGT */
219 intel_gvt_host
.mpt
= try_then_request_module(
220 symbol_get(kvmgt_mpt
), "kvmgt");
221 intel_gvt_host
.hypervisor_type
= INTEL_GVT_HYPERVISOR_KVM
;
225 /* Fail to load MPT modules - bail out */
226 if (!intel_gvt_host
.mpt
)
229 gvt_dbg_core("Running with hypervisor %s in host mode\n",
230 supported_hypervisors
[intel_gvt_host
.hypervisor_type
]);
232 intel_gvt_host
.initialized
= true;
236 static void init_device_info(struct intel_gvt
*gvt
)
238 struct intel_gvt_device_info
*info
= &gvt
->device_info
;
239 struct pci_dev
*pdev
= gvt
->dev_priv
->drm
.pdev
;
241 info
->max_support_vgpus
= 8;
242 info
->cfg_space_size
= PCI_CFG_SPACE_EXP_SIZE
;
243 info
->mmio_size
= 2 * 1024 * 1024;
245 info
->gtt_start_offset
= 8 * 1024 * 1024;
246 info
->gtt_entry_size
= 8;
247 info
->gtt_entry_size_shift
= 3;
248 info
->gmadr_bytes_in_cmd
= 8;
249 info
->max_surface_size
= 36 * 1024 * 1024;
250 info
->msi_cap_offset
= pdev
->msi_cap
;
253 static int gvt_service_thread(void *data
)
255 struct intel_gvt
*gvt
= (struct intel_gvt
*)data
;
258 gvt_dbg_core("service thread start\n");
260 while (!kthread_should_stop()) {
261 ret
= wait_event_interruptible(gvt
->service_thread_wq
,
262 kthread_should_stop() || gvt
->service_request
);
264 if (kthread_should_stop())
267 if (WARN_ONCE(ret
, "service thread is waken up by signal.\n"))
270 if (test_and_clear_bit(INTEL_GVT_REQUEST_EMULATE_VBLANK
,
271 (void *)&gvt
->service_request
))
272 intel_gvt_emulate_vblank(gvt
);
274 if (test_bit(INTEL_GVT_REQUEST_SCHED
,
275 (void *)&gvt
->service_request
) ||
276 test_bit(INTEL_GVT_REQUEST_EVENT_SCHED
,
277 (void *)&gvt
->service_request
)) {
278 intel_gvt_schedule(gvt
);
285 static void clean_service_thread(struct intel_gvt
*gvt
)
287 kthread_stop(gvt
->service_thread
);
290 static int init_service_thread(struct intel_gvt
*gvt
)
292 init_waitqueue_head(&gvt
->service_thread_wq
);
294 gvt
->service_thread
= kthread_run(gvt_service_thread
,
295 gvt
, "gvt_service_thread");
296 if (IS_ERR(gvt
->service_thread
)) {
297 gvt_err("fail to start service thread.\n");
298 return PTR_ERR(gvt
->service_thread
);
304 * intel_gvt_clean_device - clean a GVT device
305 * @dev_priv: i915 private
307 * This function is called at the driver unloading stage, to free the
308 * resources owned by a GVT device.
311 void intel_gvt_clean_device(struct drm_i915_private
*dev_priv
)
313 struct intel_gvt
*gvt
= to_gvt(dev_priv
);
318 intel_gvt_destroy_idle_vgpu(gvt
->idle_vgpu
);
319 intel_gvt_hypervisor_host_exit(&dev_priv
->drm
.pdev
->dev
, gvt
);
320 intel_gvt_cleanup_vgpu_type_groups(gvt
);
321 intel_gvt_clean_vgpu_types(gvt
);
323 intel_gvt_debugfs_clean(gvt
);
324 clean_service_thread(gvt
);
325 intel_gvt_clean_cmd_parser(gvt
);
326 intel_gvt_clean_sched_policy(gvt
);
327 intel_gvt_clean_workload_scheduler(gvt
);
328 intel_gvt_clean_gtt(gvt
);
329 intel_gvt_clean_irq(gvt
);
330 intel_gvt_free_firmware(gvt
);
331 intel_gvt_clean_mmio_info(gvt
);
332 idr_destroy(&gvt
->vgpu_idr
);
334 kfree(dev_priv
->gvt
);
335 dev_priv
->gvt
= NULL
;
339 * intel_gvt_init_device - initialize a GVT device
340 * @dev_priv: drm i915 private data
342 * This function is called at the initialization stage, to initialize
343 * necessary GVT components.
346 * Zero on success, negative error code if failed.
349 int intel_gvt_init_device(struct drm_i915_private
*dev_priv
)
351 struct intel_gvt
*gvt
;
352 struct intel_vgpu
*vgpu
;
356 * Cannot initialize GVT device without intel_gvt_host gets
359 if (WARN_ON(!intel_gvt_host
.initialized
))
362 if (WARN_ON(dev_priv
->gvt
))
365 gvt
= kzalloc(sizeof(struct intel_gvt
), GFP_KERNEL
);
369 gvt_dbg_core("init gvt device\n");
371 idr_init(&gvt
->vgpu_idr
);
372 spin_lock_init(&gvt
->scheduler
.mmio_context_lock
);
373 mutex_init(&gvt
->lock
);
374 mutex_init(&gvt
->sched_lock
);
375 gvt
->dev_priv
= dev_priv
;
377 init_device_info(gvt
);
379 ret
= intel_gvt_setup_mmio_info(gvt
);
383 intel_gvt_init_engine_mmio_context(gvt
);
385 ret
= intel_gvt_load_firmware(gvt
);
387 goto out_clean_mmio_info
;
389 ret
= intel_gvt_init_irq(gvt
);
391 goto out_free_firmware
;
393 ret
= intel_gvt_init_gtt(gvt
);
397 ret
= intel_gvt_init_workload_scheduler(gvt
);
401 ret
= intel_gvt_init_sched_policy(gvt
);
403 goto out_clean_workload_scheduler
;
405 ret
= intel_gvt_init_cmd_parser(gvt
);
407 goto out_clean_sched_policy
;
409 ret
= init_service_thread(gvt
);
411 goto out_clean_cmd_parser
;
413 ret
= intel_gvt_init_vgpu_types(gvt
);
415 goto out_clean_thread
;
417 ret
= intel_gvt_init_vgpu_type_groups(gvt
);
419 gvt_err("failed to init vgpu type groups: %d\n", ret
);
420 goto out_clean_types
;
423 ret
= intel_gvt_hypervisor_host_init(&dev_priv
->drm
.pdev
->dev
, gvt
,
426 gvt_err("failed to register gvt-g host device: %d\n", ret
);
427 goto out_clean_types
;
430 vgpu
= intel_gvt_create_idle_vgpu(gvt
);
433 gvt_err("failed to create idle vgpu\n");
434 goto out_clean_types
;
436 gvt
->idle_vgpu
= vgpu
;
438 ret
= intel_gvt_debugfs_init(gvt
);
440 gvt_err("debugfs registration failed, go on.\n");
442 gvt_dbg_core("gvt device initialization is done\n");
447 intel_gvt_clean_vgpu_types(gvt
);
449 clean_service_thread(gvt
);
450 out_clean_cmd_parser
:
451 intel_gvt_clean_cmd_parser(gvt
);
452 out_clean_sched_policy
:
453 intel_gvt_clean_sched_policy(gvt
);
454 out_clean_workload_scheduler
:
455 intel_gvt_clean_workload_scheduler(gvt
);
457 intel_gvt_clean_gtt(gvt
);
459 intel_gvt_clean_irq(gvt
);
461 intel_gvt_free_firmware(gvt
);
463 intel_gvt_clean_mmio_info(gvt
);
465 idr_destroy(&gvt
->vgpu_idr
);
470 #if IS_ENABLED(CONFIG_DRM_I915_GVT_KVMGT)
471 MODULE_SOFTDEP("pre: kvmgt");