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 * Eddie Dong <eddie.dong@intel.com>
25 * Kevin Tian <kevin.tian@intel.com>
28 * Ping Gao <ping.a.gao@intel.com>
29 * Zhi Wang <zhi.a.wang@intel.com>
30 * Bing Niu <bing.niu@intel.com>
36 #include "i915_pvinfo.h"
38 void populate_pvinfo_page(struct intel_vgpu
*vgpu
)
40 /* setup the ballooning information */
41 vgpu_vreg64(vgpu
, vgtif_reg(magic
)) = VGT_MAGIC
;
42 vgpu_vreg(vgpu
, vgtif_reg(version_major
)) = 1;
43 vgpu_vreg(vgpu
, vgtif_reg(version_minor
)) = 0;
44 vgpu_vreg(vgpu
, vgtif_reg(display_ready
)) = 0;
45 vgpu_vreg(vgpu
, vgtif_reg(vgt_id
)) = vgpu
->id
;
46 vgpu_vreg(vgpu
, vgtif_reg(avail_rs
.mappable_gmadr
.base
)) =
47 vgpu_aperture_gmadr_base(vgpu
);
48 vgpu_vreg(vgpu
, vgtif_reg(avail_rs
.mappable_gmadr
.size
)) =
49 vgpu_aperture_sz(vgpu
);
50 vgpu_vreg(vgpu
, vgtif_reg(avail_rs
.nonmappable_gmadr
.base
)) =
51 vgpu_hidden_gmadr_base(vgpu
);
52 vgpu_vreg(vgpu
, vgtif_reg(avail_rs
.nonmappable_gmadr
.size
)) =
55 vgpu_vreg(vgpu
, vgtif_reg(avail_rs
.fence_num
)) = vgpu_fence_sz(vgpu
);
57 gvt_dbg_core("Populate PVINFO PAGE for vGPU %d\n", vgpu
->id
);
58 gvt_dbg_core("aperture base [GMADR] 0x%llx size 0x%llx\n",
59 vgpu_aperture_gmadr_base(vgpu
), vgpu_aperture_sz(vgpu
));
60 gvt_dbg_core("hidden base [GMADR] 0x%llx size=0x%llx\n",
61 vgpu_hidden_gmadr_base(vgpu
), vgpu_hidden_sz(vgpu
));
62 gvt_dbg_core("fence size %d\n", vgpu_fence_sz(vgpu
));
64 WARN_ON(sizeof(struct vgt_if
) != VGT_PVINFO_SIZE
);
67 #define VGPU_MAX_WEIGHT 16
68 #define VGPU_WEIGHT(vgpu_num) \
69 (VGPU_MAX_WEIGHT / (vgpu_num))
76 /* A vGPU with a weight of 8 will get twice as much GPU as a vGPU
77 * with a weight of 4 on a contended host, different vGPU type has
78 * different weight set. Legal weights range from 1 to 16.
81 enum intel_vgpu_edid edid
;
84 /* Fixed vGPU type table */
85 { MB_TO_BYTES(64), MB_TO_BYTES(384), 4, VGPU_WEIGHT(8), GVT_EDID_1024_768
, "8" },
86 { MB_TO_BYTES(128), MB_TO_BYTES(512), 4, VGPU_WEIGHT(4), GVT_EDID_1920_1200
, "4" },
87 { MB_TO_BYTES(256), MB_TO_BYTES(1024), 4, VGPU_WEIGHT(2), GVT_EDID_1920_1200
, "2" },
88 { MB_TO_BYTES(512), MB_TO_BYTES(2048), 4, VGPU_WEIGHT(1), GVT_EDID_1920_1200
, "1" },
92 * intel_gvt_init_vgpu_types - initialize vGPU type list
95 * Initialize vGPU type list based on available resource.
98 int intel_gvt_init_vgpu_types(struct intel_gvt
*gvt
)
100 unsigned int num_types
;
101 unsigned int i
, low_avail
, high_avail
;
102 unsigned int min_low
;
104 /* vGPU type name is defined as GVTg_Vx_y which contains
105 * physical GPU generation type (e.g V4 as BDW server, V5 as
108 * Depend on physical SKU resource, might see vGPU types like
109 * GVTg_V4_8, GVTg_V4_4, GVTg_V4_2, etc. We can create
110 * different types of vGPU on same physical GPU depending on
111 * available resource. Each vGPU type will have "avail_instance"
112 * to indicate how many vGPU instance can be created for this
116 low_avail
= gvt_aperture_sz(gvt
) - HOST_LOW_GM_SIZE
;
117 high_avail
= gvt_hidden_sz(gvt
) - HOST_HIGH_GM_SIZE
;
118 num_types
= sizeof(vgpu_types
) / sizeof(vgpu_types
[0]);
120 gvt
->types
= kzalloc(num_types
* sizeof(struct intel_vgpu_type
),
125 min_low
= MB_TO_BYTES(32);
126 for (i
= 0; i
< num_types
; ++i
) {
127 if (low_avail
/ vgpu_types
[i
].low_mm
== 0)
130 gvt
->types
[i
].low_gm_size
= vgpu_types
[i
].low_mm
;
131 gvt
->types
[i
].high_gm_size
= vgpu_types
[i
].high_mm
;
132 gvt
->types
[i
].fence
= vgpu_types
[i
].fence
;
134 if (vgpu_types
[i
].weight
< 1 ||
135 vgpu_types
[i
].weight
> VGPU_MAX_WEIGHT
)
138 gvt
->types
[i
].weight
= vgpu_types
[i
].weight
;
139 gvt
->types
[i
].resolution
= vgpu_types
[i
].edid
;
140 gvt
->types
[i
].avail_instance
= min(low_avail
/ vgpu_types
[i
].low_mm
,
141 high_avail
/ vgpu_types
[i
].high_mm
);
143 if (IS_GEN8(gvt
->dev_priv
))
144 sprintf(gvt
->types
[i
].name
, "GVTg_V4_%s",
146 else if (IS_GEN9(gvt
->dev_priv
))
147 sprintf(gvt
->types
[i
].name
, "GVTg_V5_%s",
150 gvt_dbg_core("type[%d]: %s avail %u low %u high %u fence %u weight %u res %s\n",
151 i
, gvt
->types
[i
].name
,
152 gvt
->types
[i
].avail_instance
,
153 gvt
->types
[i
].low_gm_size
,
154 gvt
->types
[i
].high_gm_size
, gvt
->types
[i
].fence
,
155 gvt
->types
[i
].weight
,
156 vgpu_edid_str(gvt
->types
[i
].resolution
));
163 void intel_gvt_clean_vgpu_types(struct intel_gvt
*gvt
)
168 static void intel_gvt_update_vgpu_types(struct intel_gvt
*gvt
)
171 unsigned int low_gm_avail
, high_gm_avail
, fence_avail
;
172 unsigned int low_gm_min
, high_gm_min
, fence_min
;
174 /* Need to depend on maxium hw resource size but keep on
175 * static config for now.
177 low_gm_avail
= gvt_aperture_sz(gvt
) - HOST_LOW_GM_SIZE
-
178 gvt
->gm
.vgpu_allocated_low_gm_size
;
179 high_gm_avail
= gvt_hidden_sz(gvt
) - HOST_HIGH_GM_SIZE
-
180 gvt
->gm
.vgpu_allocated_high_gm_size
;
181 fence_avail
= gvt_fence_sz(gvt
) - HOST_FENCE
-
182 gvt
->fence
.vgpu_allocated_fence_num
;
184 for (i
= 0; i
< gvt
->num_types
; i
++) {
185 low_gm_min
= low_gm_avail
/ gvt
->types
[i
].low_gm_size
;
186 high_gm_min
= high_gm_avail
/ gvt
->types
[i
].high_gm_size
;
187 fence_min
= fence_avail
/ gvt
->types
[i
].fence
;
188 gvt
->types
[i
].avail_instance
= min(min(low_gm_min
, high_gm_min
),
191 gvt_dbg_core("update type[%d]: %s avail %u low %u high %u fence %u\n",
192 i
, gvt
->types
[i
].name
,
193 gvt
->types
[i
].avail_instance
, gvt
->types
[i
].low_gm_size
,
194 gvt
->types
[i
].high_gm_size
, gvt
->types
[i
].fence
);
199 * intel_gvt_active_vgpu - activate a virtual GPU
202 * This function is called when user wants to activate a virtual GPU.
205 void intel_gvt_activate_vgpu(struct intel_vgpu
*vgpu
)
207 mutex_lock(&vgpu
->gvt
->lock
);
209 mutex_unlock(&vgpu
->gvt
->lock
);
213 * intel_gvt_deactive_vgpu - deactivate a virtual GPU
216 * This function is called when user wants to deactivate a virtual GPU.
217 * All virtual GPU runtime information will be destroyed.
220 void intel_gvt_deactivate_vgpu(struct intel_vgpu
*vgpu
)
222 struct intel_gvt
*gvt
= vgpu
->gvt
;
224 mutex_lock(&gvt
->lock
);
226 vgpu
->active
= false;
228 if (atomic_read(&vgpu
->running_workload_num
)) {
229 mutex_unlock(&gvt
->lock
);
230 intel_gvt_wait_vgpu_idle(vgpu
);
231 mutex_lock(&gvt
->lock
);
234 intel_vgpu_stop_schedule(vgpu
);
236 mutex_unlock(&gvt
->lock
);
240 * intel_gvt_destroy_vgpu - destroy a virtual GPU
243 * This function is called when user wants to destroy a virtual GPU.
246 void intel_gvt_destroy_vgpu(struct intel_vgpu
*vgpu
)
248 struct intel_gvt
*gvt
= vgpu
->gvt
;
250 mutex_lock(&gvt
->lock
);
252 WARN(vgpu
->active
, "vGPU is still active!\n");
254 idr_remove(&gvt
->vgpu_idr
, vgpu
->id
);
255 intel_vgpu_clean_sched_policy(vgpu
);
256 intel_vgpu_clean_gvt_context(vgpu
);
257 intel_vgpu_clean_execlist(vgpu
);
258 intel_vgpu_clean_display(vgpu
);
259 intel_vgpu_clean_opregion(vgpu
);
260 intel_vgpu_clean_gtt(vgpu
);
261 intel_gvt_hypervisor_detach_vgpu(vgpu
);
262 intel_vgpu_free_resource(vgpu
);
263 intel_vgpu_clean_mmio(vgpu
);
266 intel_gvt_update_vgpu_types(gvt
);
267 mutex_unlock(&gvt
->lock
);
270 #define IDLE_VGPU_IDR 0
273 * intel_gvt_create_idle_vgpu - create an idle virtual GPU
276 * This function is called when user wants to create an idle virtual GPU.
279 * pointer to intel_vgpu, error pointer if failed.
281 struct intel_vgpu
*intel_gvt_create_idle_vgpu(struct intel_gvt
*gvt
)
283 struct intel_vgpu
*vgpu
;
284 enum intel_engine_id i
;
287 vgpu
= vzalloc(sizeof(*vgpu
));
289 return ERR_PTR(-ENOMEM
);
291 vgpu
->id
= IDLE_VGPU_IDR
;
294 for (i
= 0; i
< I915_NUM_ENGINES
; i
++)
295 INIT_LIST_HEAD(&vgpu
->workload_q_head
[i
]);
297 ret
= intel_vgpu_init_sched_policy(vgpu
);
301 vgpu
->active
= false;
311 * intel_gvt_destroy_vgpu - destroy an idle virtual GPU
314 * This function is called when user wants to destroy an idle virtual GPU.
317 void intel_gvt_destroy_idle_vgpu(struct intel_vgpu
*vgpu
)
319 intel_vgpu_clean_sched_policy(vgpu
);
323 static struct intel_vgpu
*__intel_gvt_create_vgpu(struct intel_gvt
*gvt
,
324 struct intel_vgpu_creation_params
*param
)
326 struct intel_vgpu
*vgpu
;
329 gvt_dbg_core("handle %llu low %llu MB high %llu MB fence %llu\n",
330 param
->handle
, param
->low_gm_sz
, param
->high_gm_sz
,
333 vgpu
= vzalloc(sizeof(*vgpu
));
335 return ERR_PTR(-ENOMEM
);
337 mutex_lock(&gvt
->lock
);
339 ret
= idr_alloc(&gvt
->vgpu_idr
, vgpu
, IDLE_VGPU_IDR
+ 1, GVT_MAX_VGPU
,
345 vgpu
->handle
= param
->handle
;
347 vgpu
->sched_ctl
.weight
= param
->weight
;
348 bitmap_zero(vgpu
->tlb_handle_pending
, I915_NUM_ENGINES
);
350 intel_vgpu_init_cfg_space(vgpu
, param
->primary
);
352 ret
= intel_vgpu_init_mmio(vgpu
);
356 ret
= intel_vgpu_alloc_resource(vgpu
, param
);
358 goto out_clean_vgpu_mmio
;
360 populate_pvinfo_page(vgpu
);
362 ret
= intel_gvt_hypervisor_attach_vgpu(vgpu
);
364 goto out_clean_vgpu_resource
;
366 ret
= intel_vgpu_init_gtt(vgpu
);
368 goto out_detach_hypervisor_vgpu
;
370 ret
= intel_vgpu_init_display(vgpu
, param
->resolution
);
374 ret
= intel_vgpu_init_execlist(vgpu
);
376 goto out_clean_display
;
378 ret
= intel_vgpu_init_gvt_context(vgpu
);
380 goto out_clean_execlist
;
382 ret
= intel_vgpu_init_sched_policy(vgpu
);
384 goto out_clean_shadow_ctx
;
386 mutex_unlock(&gvt
->lock
);
390 out_clean_shadow_ctx
:
391 intel_vgpu_clean_gvt_context(vgpu
);
393 intel_vgpu_clean_execlist(vgpu
);
395 intel_vgpu_clean_display(vgpu
);
397 intel_vgpu_clean_gtt(vgpu
);
398 out_detach_hypervisor_vgpu
:
399 intel_gvt_hypervisor_detach_vgpu(vgpu
);
400 out_clean_vgpu_resource
:
401 intel_vgpu_free_resource(vgpu
);
403 intel_vgpu_clean_mmio(vgpu
);
405 idr_remove(&gvt
->vgpu_idr
, vgpu
->id
);
408 mutex_unlock(&gvt
->lock
);
413 * intel_gvt_create_vgpu - create a virtual GPU
415 * @type: type of the vGPU to create
417 * This function is called when user wants to create a virtual GPU.
420 * pointer to intel_vgpu, error pointer if failed.
422 struct intel_vgpu
*intel_gvt_create_vgpu(struct intel_gvt
*gvt
,
423 struct intel_vgpu_type
*type
)
425 struct intel_vgpu_creation_params param
;
426 struct intel_vgpu
*vgpu
;
430 param
.low_gm_sz
= type
->low_gm_size
;
431 param
.high_gm_sz
= type
->high_gm_size
;
432 param
.fence_sz
= type
->fence
;
433 param
.weight
= type
->weight
;
434 param
.resolution
= type
->resolution
;
436 /* XXX current param based on MB */
437 param
.low_gm_sz
= BYTES_TO_MB(param
.low_gm_sz
);
438 param
.high_gm_sz
= BYTES_TO_MB(param
.high_gm_sz
);
440 vgpu
= __intel_gvt_create_vgpu(gvt
, ¶m
);
444 /* calculate left instance change for types */
445 intel_gvt_update_vgpu_types(gvt
);
451 * intel_gvt_reset_vgpu_locked - reset a virtual GPU by DMLR or GT reset
453 * @dmlr: vGPU Device Model Level Reset or GT Reset
454 * @engine_mask: engines to reset for GT reset
456 * This function is called when user wants to reset a virtual GPU through
457 * device model reset or GT reset. The caller should hold the gvt lock.
459 * vGPU Device Model Level Reset (DMLR) simulates the PCI level reset to reset
460 * the whole vGPU to default state as when it is created. This vGPU function
461 * is required both for functionary and security concerns.The ultimate goal
462 * of vGPU FLR is that reuse a vGPU instance by virtual machines. When we
463 * assign a vGPU to a virtual machine we must isse such reset first.
465 * Full GT Reset and Per-Engine GT Reset are soft reset flow for GPU engines
466 * (Render, Blitter, Video, Video Enhancement). It is defined by GPU Spec.
467 * Unlike the FLR, GT reset only reset particular resource of a vGPU per
468 * the reset request. Guest driver can issue a GT reset by programming the
469 * virtual GDRST register to reset specific virtual GPU engine or all
472 * The parameter dev_level is to identify if we will do DMLR or GT reset.
473 * The parameter engine_mask is to specific the engines that need to be
474 * resetted. If value ALL_ENGINES is given for engine_mask, it means
475 * the caller requests a full GT reset that we will reset all virtual
476 * GPU engines. For FLR, engine_mask is ignored.
478 void intel_gvt_reset_vgpu_locked(struct intel_vgpu
*vgpu
, bool dmlr
,
479 unsigned int engine_mask
)
481 struct intel_gvt
*gvt
= vgpu
->gvt
;
482 struct intel_gvt_workload_scheduler
*scheduler
= &gvt
->scheduler
;
483 unsigned int resetting_eng
= dmlr
? ALL_ENGINES
: engine_mask
;
485 gvt_dbg_core("------------------------------------------\n");
486 gvt_dbg_core("resseting vgpu%d, dmlr %d, engine_mask %08x\n",
487 vgpu
->id
, dmlr
, engine_mask
);
489 vgpu
->resetting_eng
= resetting_eng
;
491 intel_vgpu_stop_schedule(vgpu
);
493 * The current_vgpu will set to NULL after stopping the
494 * scheduler when the reset is triggered by current vgpu.
496 if (scheduler
->current_vgpu
== NULL
) {
497 mutex_unlock(&gvt
->lock
);
498 intel_gvt_wait_vgpu_idle(vgpu
);
499 mutex_lock(&gvt
->lock
);
502 intel_vgpu_reset_execlist(vgpu
, resetting_eng
);
504 /* full GPU reset or device model level reset */
505 if (engine_mask
== ALL_ENGINES
|| dmlr
) {
507 intel_vgpu_reset_gtt(vgpu
, dmlr
);
509 /*fence will not be reset during virtual reset */
511 intel_vgpu_reset_resource(vgpu
);
513 intel_vgpu_reset_mmio(vgpu
, dmlr
);
514 populate_pvinfo_page(vgpu
);
515 intel_vgpu_reset_display(vgpu
);
518 intel_vgpu_reset_cfg_space(vgpu
);
519 /* only reset the failsafe mode when dmlr reset */
520 vgpu
->failsafe
= false;
521 vgpu
->pv_notified
= false;
525 vgpu
->resetting_eng
= 0;
526 gvt_dbg_core("reset vgpu%d done\n", vgpu
->id
);
527 gvt_dbg_core("------------------------------------------\n");
531 * intel_gvt_reset_vgpu - reset a virtual GPU (Function Level)
534 * This function is called when user wants to reset a virtual GPU.
537 void intel_gvt_reset_vgpu(struct intel_vgpu
*vgpu
)
539 mutex_lock(&vgpu
->gvt
->lock
);
540 intel_gvt_reset_vgpu_locked(vgpu
, true, 0);
541 mutex_unlock(&vgpu
->gvt
->lock
);