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
);
71 enum intel_vgpu_edid edid
;
74 /* Fixed vGPU type table */
75 { MB_TO_BYTES(64), MB_TO_BYTES(512), 4, GVT_EDID_1024_768
, "8" },
76 { MB_TO_BYTES(128), MB_TO_BYTES(512), 4, GVT_EDID_1920_1200
, "4" },
77 { MB_TO_BYTES(256), MB_TO_BYTES(1024), 4, GVT_EDID_1920_1200
, "2" },
78 { MB_TO_BYTES(512), MB_TO_BYTES(2048), 4, GVT_EDID_1920_1200
, "1" },
82 * intel_gvt_init_vgpu_types - initialize vGPU type list
85 * Initialize vGPU type list based on available resource.
88 int intel_gvt_init_vgpu_types(struct intel_gvt
*gvt
)
90 unsigned int num_types
;
91 unsigned int i
, low_avail
, high_avail
;
94 /* vGPU type name is defined as GVTg_Vx_y which contains
95 * physical GPU generation type (e.g V4 as BDW server, V5 as
98 * Depend on physical SKU resource, might see vGPU types like
99 * GVTg_V4_8, GVTg_V4_4, GVTg_V4_2, etc. We can create
100 * different types of vGPU on same physical GPU depending on
101 * available resource. Each vGPU type will have "avail_instance"
102 * to indicate how many vGPU instance can be created for this
106 low_avail
= gvt_aperture_sz(gvt
) - HOST_LOW_GM_SIZE
;
107 high_avail
= gvt_hidden_sz(gvt
) - HOST_HIGH_GM_SIZE
;
108 num_types
= sizeof(vgpu_types
) / sizeof(vgpu_types
[0]);
110 gvt
->types
= kzalloc(num_types
* sizeof(struct intel_vgpu_type
),
115 min_low
= MB_TO_BYTES(32);
116 for (i
= 0; i
< num_types
; ++i
) {
117 if (low_avail
/ vgpu_types
[i
].low_mm
== 0)
120 gvt
->types
[i
].low_gm_size
= vgpu_types
[i
].low_mm
;
121 gvt
->types
[i
].high_gm_size
= vgpu_types
[i
].high_mm
;
122 gvt
->types
[i
].fence
= vgpu_types
[i
].fence
;
123 gvt
->types
[i
].resolution
= vgpu_types
[i
].edid
;
124 gvt
->types
[i
].avail_instance
= min(low_avail
/ vgpu_types
[i
].low_mm
,
125 high_avail
/ vgpu_types
[i
].high_mm
);
127 if (IS_GEN8(gvt
->dev_priv
))
128 sprintf(gvt
->types
[i
].name
, "GVTg_V4_%s",
130 else if (IS_GEN9(gvt
->dev_priv
))
131 sprintf(gvt
->types
[i
].name
, "GVTg_V5_%s",
134 gvt_dbg_core("type[%d]: %s avail %u low %u high %u fence %u res %s\n",
135 i
, gvt
->types
[i
].name
,
136 gvt
->types
[i
].avail_instance
,
137 gvt
->types
[i
].low_gm_size
,
138 gvt
->types
[i
].high_gm_size
, gvt
->types
[i
].fence
,
139 vgpu_edid_str(gvt
->types
[i
].resolution
));
146 void intel_gvt_clean_vgpu_types(struct intel_gvt
*gvt
)
151 static void intel_gvt_update_vgpu_types(struct intel_gvt
*gvt
)
154 unsigned int low_gm_avail
, high_gm_avail
, fence_avail
;
155 unsigned int low_gm_min
, high_gm_min
, fence_min
;
157 /* Need to depend on maxium hw resource size but keep on
158 * static config for now.
160 low_gm_avail
= gvt_aperture_sz(gvt
) - HOST_LOW_GM_SIZE
-
161 gvt
->gm
.vgpu_allocated_low_gm_size
;
162 high_gm_avail
= gvt_hidden_sz(gvt
) - HOST_HIGH_GM_SIZE
-
163 gvt
->gm
.vgpu_allocated_high_gm_size
;
164 fence_avail
= gvt_fence_sz(gvt
) - HOST_FENCE
-
165 gvt
->fence
.vgpu_allocated_fence_num
;
167 for (i
= 0; i
< gvt
->num_types
; i
++) {
168 low_gm_min
= low_gm_avail
/ gvt
->types
[i
].low_gm_size
;
169 high_gm_min
= high_gm_avail
/ gvt
->types
[i
].high_gm_size
;
170 fence_min
= fence_avail
/ gvt
->types
[i
].fence
;
171 gvt
->types
[i
].avail_instance
= min(min(low_gm_min
, high_gm_min
),
174 gvt_dbg_core("update type[%d]: %s avail %u low %u high %u fence %u\n",
175 i
, gvt
->types
[i
].name
,
176 gvt
->types
[i
].avail_instance
, gvt
->types
[i
].low_gm_size
,
177 gvt
->types
[i
].high_gm_size
, gvt
->types
[i
].fence
);
182 * intel_gvt_destroy_vgpu - destroy a virtual GPU
185 * This function is called when user wants to destroy a virtual GPU.
188 void intel_gvt_destroy_vgpu(struct intel_vgpu
*vgpu
)
190 struct intel_gvt
*gvt
= vgpu
->gvt
;
192 mutex_lock(&gvt
->lock
);
194 vgpu
->active
= false;
195 idr_remove(&gvt
->vgpu_idr
, vgpu
->id
);
197 if (atomic_read(&vgpu
->running_workload_num
)) {
198 mutex_unlock(&gvt
->lock
);
199 intel_gvt_wait_vgpu_idle(vgpu
);
200 mutex_lock(&gvt
->lock
);
203 intel_vgpu_stop_schedule(vgpu
);
204 intel_vgpu_clean_sched_policy(vgpu
);
205 intel_vgpu_clean_gvt_context(vgpu
);
206 intel_vgpu_clean_execlist(vgpu
);
207 intel_vgpu_clean_display(vgpu
);
208 intel_vgpu_clean_opregion(vgpu
);
209 intel_vgpu_clean_gtt(vgpu
);
210 intel_gvt_hypervisor_detach_vgpu(vgpu
);
211 intel_vgpu_free_resource(vgpu
);
212 intel_vgpu_clean_mmio(vgpu
);
215 intel_gvt_update_vgpu_types(gvt
);
216 mutex_unlock(&gvt
->lock
);
219 static struct intel_vgpu
*__intel_gvt_create_vgpu(struct intel_gvt
*gvt
,
220 struct intel_vgpu_creation_params
*param
)
222 struct intel_vgpu
*vgpu
;
225 gvt_dbg_core("handle %llu low %llu MB high %llu MB fence %llu\n",
226 param
->handle
, param
->low_gm_sz
, param
->high_gm_sz
,
229 vgpu
= vzalloc(sizeof(*vgpu
));
231 return ERR_PTR(-ENOMEM
);
233 mutex_lock(&gvt
->lock
);
235 ret
= idr_alloc(&gvt
->vgpu_idr
, vgpu
, 1, GVT_MAX_VGPU
, GFP_KERNEL
);
240 vgpu
->handle
= param
->handle
;
242 bitmap_zero(vgpu
->tlb_handle_pending
, I915_NUM_ENGINES
);
244 intel_vgpu_init_cfg_space(vgpu
, param
->primary
);
246 ret
= intel_vgpu_init_mmio(vgpu
);
250 ret
= intel_vgpu_alloc_resource(vgpu
, param
);
252 goto out_clean_vgpu_mmio
;
254 populate_pvinfo_page(vgpu
);
256 ret
= intel_gvt_hypervisor_attach_vgpu(vgpu
);
258 goto out_clean_vgpu_resource
;
260 ret
= intel_vgpu_init_gtt(vgpu
);
262 goto out_detach_hypervisor_vgpu
;
264 ret
= intel_vgpu_init_display(vgpu
, param
->resolution
);
268 ret
= intel_vgpu_init_execlist(vgpu
);
270 goto out_clean_display
;
272 ret
= intel_vgpu_init_gvt_context(vgpu
);
274 goto out_clean_execlist
;
276 ret
= intel_vgpu_init_sched_policy(vgpu
);
278 goto out_clean_shadow_ctx
;
281 mutex_unlock(&gvt
->lock
);
285 out_clean_shadow_ctx
:
286 intel_vgpu_clean_gvt_context(vgpu
);
288 intel_vgpu_clean_execlist(vgpu
);
290 intel_vgpu_clean_display(vgpu
);
292 intel_vgpu_clean_gtt(vgpu
);
293 out_detach_hypervisor_vgpu
:
294 intel_gvt_hypervisor_detach_vgpu(vgpu
);
295 out_clean_vgpu_resource
:
296 intel_vgpu_free_resource(vgpu
);
298 intel_vgpu_clean_mmio(vgpu
);
300 idr_remove(&gvt
->vgpu_idr
, vgpu
->id
);
303 mutex_unlock(&gvt
->lock
);
308 * intel_gvt_create_vgpu - create a virtual GPU
310 * @type: type of the vGPU to create
312 * This function is called when user wants to create a virtual GPU.
315 * pointer to intel_vgpu, error pointer if failed.
317 struct intel_vgpu
*intel_gvt_create_vgpu(struct intel_gvt
*gvt
,
318 struct intel_vgpu_type
*type
)
320 struct intel_vgpu_creation_params param
;
321 struct intel_vgpu
*vgpu
;
325 param
.low_gm_sz
= type
->low_gm_size
;
326 param
.high_gm_sz
= type
->high_gm_size
;
327 param
.fence_sz
= type
->fence
;
328 param
.resolution
= type
->resolution
;
330 /* XXX current param based on MB */
331 param
.low_gm_sz
= BYTES_TO_MB(param
.low_gm_sz
);
332 param
.high_gm_sz
= BYTES_TO_MB(param
.high_gm_sz
);
334 vgpu
= __intel_gvt_create_vgpu(gvt
, ¶m
);
338 /* calculate left instance change for types */
339 intel_gvt_update_vgpu_types(gvt
);
345 * intel_gvt_reset_vgpu_locked - reset a virtual GPU by DMLR or GT reset
347 * @dmlr: vGPU Device Model Level Reset or GT Reset
348 * @engine_mask: engines to reset for GT reset
350 * This function is called when user wants to reset a virtual GPU through
351 * device model reset or GT reset. The caller should hold the gvt lock.
353 * vGPU Device Model Level Reset (DMLR) simulates the PCI level reset to reset
354 * the whole vGPU to default state as when it is created. This vGPU function
355 * is required both for functionary and security concerns.The ultimate goal
356 * of vGPU FLR is that reuse a vGPU instance by virtual machines. When we
357 * assign a vGPU to a virtual machine we must isse such reset first.
359 * Full GT Reset and Per-Engine GT Reset are soft reset flow for GPU engines
360 * (Render, Blitter, Video, Video Enhancement). It is defined by GPU Spec.
361 * Unlike the FLR, GT reset only reset particular resource of a vGPU per
362 * the reset request. Guest driver can issue a GT reset by programming the
363 * virtual GDRST register to reset specific virtual GPU engine or all
366 * The parameter dev_level is to identify if we will do DMLR or GT reset.
367 * The parameter engine_mask is to specific the engines that need to be
368 * resetted. If value ALL_ENGINES is given for engine_mask, it means
369 * the caller requests a full GT reset that we will reset all virtual
370 * GPU engines. For FLR, engine_mask is ignored.
372 void intel_gvt_reset_vgpu_locked(struct intel_vgpu
*vgpu
, bool dmlr
,
373 unsigned int engine_mask
)
375 struct intel_gvt
*gvt
= vgpu
->gvt
;
376 struct intel_gvt_workload_scheduler
*scheduler
= &gvt
->scheduler
;
378 gvt_dbg_core("------------------------------------------\n");
379 gvt_dbg_core("resseting vgpu%d, dmlr %d, engine_mask %08x\n",
380 vgpu
->id
, dmlr
, engine_mask
);
381 vgpu
->resetting
= true;
383 intel_vgpu_stop_schedule(vgpu
);
385 * The current_vgpu will set to NULL after stopping the
386 * scheduler when the reset is triggered by current vgpu.
388 if (scheduler
->current_vgpu
== NULL
) {
389 mutex_unlock(&gvt
->lock
);
390 intel_gvt_wait_vgpu_idle(vgpu
);
391 mutex_lock(&gvt
->lock
);
394 intel_vgpu_reset_execlist(vgpu
, dmlr
? ALL_ENGINES
: engine_mask
);
396 /* full GPU reset or device model level reset */
397 if (engine_mask
== ALL_ENGINES
|| dmlr
) {
398 intel_vgpu_reset_gtt(vgpu
, dmlr
);
399 intel_vgpu_reset_resource(vgpu
);
400 intel_vgpu_reset_mmio(vgpu
);
401 populate_pvinfo_page(vgpu
);
402 intel_vgpu_reset_display(vgpu
);
405 intel_vgpu_reset_cfg_space(vgpu
);
406 /* only reset the failsafe mode when dmlr reset */
407 vgpu
->failsafe
= false;
408 vgpu
->pv_notified
= false;
412 vgpu
->resetting
= false;
413 gvt_dbg_core("reset vgpu%d done\n", vgpu
->id
);
414 gvt_dbg_core("------------------------------------------\n");
418 * intel_gvt_reset_vgpu - reset a virtual GPU (Function Level)
421 * This function is called when user wants to reset a virtual GPU.
424 void intel_gvt_reset_vgpu(struct intel_vgpu
*vgpu
)
426 mutex_lock(&vgpu
->gvt
->lock
);
427 intel_gvt_reset_vgpu_locked(vgpu
, true, 0);
428 mutex_unlock(&vgpu
->gvt
->lock
);