drm/i915/gvt: define weight according to vGPU type

The weight defines proportional control of physical GPU resource
shared between vGPUs. So far the weight is tied to a specific vGPU
type, i.e when creating multiple vGPUs with different types, they
will inherit different weights.

e.g. The weight of type GVTg_V5_2 is 8, the weight of type GVTg_V5_4
is 4, so vGPU of type GVTg_V5_2 has double vGPU resource of vGPU type
GVTg_V5_4.

TODO: allow user control the weight setting in the future.

Signed-off-by: Ping Gao <ping.a.gao@intel.com>
Reviewed-by: Kevin Tian <kevin.tian@intel.com>
Signed-off-by: Zhenyu Wang <zhenyuw@linux.intel.com>

4 files changed, 33 insertions, 7 deletions

diff --git a/drivers/gpu/drm/i915/gvt/gvt.h b/drivers/gpu/drm/i915/gvt/gvt.h
index fe7f5ae8884a..0631f64e06db 100644
--- a/drivers/gpu/drm/i915/gvt/gvt.h
+++ b/drivers/gpu/drm/i915/gvt/gvt.h
@@ -151,6 +151,7 @@ struct intel_vgpu {
         bool failsafe;
         bool resetting;
         void *sched_data;
+        struct vgpu_sched_ctl sched_ctl;
 
         struct intel_vgpu_fence fence;
         struct intel_vgpu_gm gm;
@@ -220,6 +221,7 @@ struct intel_vgpu_type {
         unsigned int low_gm_size;
         unsigned int high_gm_size;
         unsigned int fence;
+        unsigned int weight;
         enum intel_vgpu_edid resolution;
 };
 
@@ -328,6 +330,8 @@ struct intel_vgpu_creation_params {
         __u64 resolution;
         __s32 primary;
         __u64 vgpu_id;
+
+        __u32 weight;
 };
 
 int intel_vgpu_alloc_resource(struct intel_vgpu *vgpu,
diff --git a/drivers/gpu/drm/i915/gvt/kvmgt.c b/drivers/gpu/drm/i915/gvt/kvmgt.c
index 65bcf6096e5e..5f55d89a0959 100644
--- a/drivers/gpu/drm/i915/gvt/kvmgt.c
+++ b/drivers/gpu/drm/i915/gvt/kvmgt.c
@@ -295,10 +295,12 @@ static ssize_t description_show(struct kobject *kobj, struct device *dev,
                 return 0;
 
         return sprintf(buf, "low_gm_size: %dMB\nhigh_gm_size: %dMB\n"
-                       "fence: %d\nresolution: %s\n",
+                       "fence: %d\nresolution: %s\n"
+                       "weight: %d\n",
                        BYTES_TO_MB(type->low_gm_size),
                        BYTES_TO_MB(type->high_gm_size),
-                       type->fence, vgpu_edid_str(type->resolution));
+                       type->fence, vgpu_edid_str(type->resolution),
+                       type->weight);
 }
 
 static MDEV_TYPE_ATTR_RO(available_instances);
diff --git a/drivers/gpu/drm/i915/gvt/sched_policy.c b/drivers/gpu/drm/i915/gvt/sched_policy.c
index 15e0c3b53d93..5aa7a2539e4d 100644
--- a/drivers/gpu/drm/i915/gvt/sched_policy.c
+++ b/drivers/gpu/drm/i915/gvt/sched_policy.c
@@ -237,6 +237,7 @@ static int tbs_sched_init_vgpu(struct intel_vgpu *vgpu)
         if (!data)
                 return -ENOMEM;
 
+        data->sched_ctl.weight = vgpu->sched_ctl.weight;
         data->vgpu = vgpu;
         INIT_LIST_HEAD(&data->lru_list);
 
diff --git a/drivers/gpu/drm/i915/gvt/vgpu.c b/drivers/gpu/drm/i915/gvt/vgpu.c
index d8d128625331..36c107e2058a 100644
--- a/drivers/gpu/drm/i915/gvt/vgpu.c
+++ b/drivers/gpu/drm/i915/gvt/vgpu.c
@@ -64,18 +64,28 @@ void populate_pvinfo_page(struct intel_vgpu *vgpu)
         WARN_ON(sizeof(struct vgt_if) != VGT_PVINFO_SIZE);
 }
 
+#define VGPU_MAX_WEIGHT 16
+#define VGPU_WEIGHT(vgpu_num)   \
+        (VGPU_MAX_WEIGHT / (vgpu_num))
+
 static struct {
         unsigned int low_mm;
         unsigned int high_mm;
         unsigned int fence;
+
+        /* A vGPU with a weight of 8 will get twice as much GPU as a vGPU
+         * with a weight of 4 on a contended host, different vGPU type has
+         * different weight set. Legal weights range from 1 to 16.
+         */
+        unsigned int weight;
         enum intel_vgpu_edid edid;
         char *name;
 } vgpu_types[] = {
 /* Fixed vGPU type table */
-        { MB_TO_BYTES(64), MB_TO_BYTES(384), 4, GVT_EDID_1024_768, "8" },
-        { MB_TO_BYTES(128), MB_TO_BYTES(512), 4, GVT_EDID_1920_1200, "4" },
-        { MB_TO_BYTES(256), MB_TO_BYTES(1024), 4, GVT_EDID_1920_1200, "2" },
-        { MB_TO_BYTES(512), MB_TO_BYTES(2048), 4, GVT_EDID_1920_1200, "1" },
+        { MB_TO_BYTES(64), MB_TO_BYTES(384), 4, VGPU_WEIGHT(8), GVT_EDID_1024_768, "8" },
+        { MB_TO_BYTES(128), MB_TO_BYTES(512), 4, VGPU_WEIGHT(4), GVT_EDID_1920_1200, "4" },
+        { MB_TO_BYTES(256), MB_TO_BYTES(1024), 4, VGPU_WEIGHT(2), GVT_EDID_1920_1200, "2" },
+        { MB_TO_BYTES(512), MB_TO_BYTES(2048), 4, VGPU_WEIGHT(1), GVT_EDID_1920_1200, "1" },
 };
 
 /**
@@ -120,6 +130,12 @@ int intel_gvt_init_vgpu_types(struct intel_gvt *gvt)
                 gvt->types[i].low_gm_size = vgpu_types[i].low_mm;
                 gvt->types[i].high_gm_size = vgpu_types[i].high_mm;
                 gvt->types[i].fence = vgpu_types[i].fence;
+
+                if (vgpu_types[i].weight < 1 ||
+                                        vgpu_types[i].weight > VGPU_MAX_WEIGHT)
+                        return -EINVAL;
+
+                gvt->types[i].weight = vgpu_types[i].weight;
                 gvt->types[i].resolution = vgpu_types[i].edid;
                 gvt->types[i].avail_instance = min(low_avail / vgpu_types[i].low_mm,
                                                    high_avail / vgpu_types[i].high_mm);
@@ -131,11 +147,12 @@ int intel_gvt_init_vgpu_types(struct intel_gvt *gvt)
                         sprintf(gvt->types[i].name, "GVTg_V5_%s",
                                                 vgpu_types[i].name);
 
-                gvt_dbg_core("type[%d]: %s avail %u low %u high %u fence %u res %s\n",
+                gvt_dbg_core("type[%d]: %s avail %u low %u high %u fence %u weight %u res %s\n",
                              i, gvt->types[i].name,
                              gvt->types[i].avail_instance,
                              gvt->types[i].low_gm_size,
                              gvt->types[i].high_gm_size, gvt->types[i].fence,
+                             gvt->types[i].weight,
                              vgpu_edid_str(gvt->types[i].resolution));
         }
 
@@ -239,6 +256,7 @@ static struct intel_vgpu *__intel_gvt_create_vgpu(struct intel_gvt *gvt,
         vgpu->id = ret;
         vgpu->handle = param->handle;
         vgpu->gvt = gvt;
+        vgpu->sched_ctl.weight = param->weight;
         bitmap_zero(vgpu->tlb_handle_pending, I915_NUM_ENGINES);
 
         intel_vgpu_init_cfg_space(vgpu, param->primary);
@@ -325,6 +343,7 @@ struct intel_vgpu *intel_gvt_create_vgpu(struct intel_gvt *gvt,
         param.low_gm_sz = type->low_gm_size;
         param.high_gm_sz = type->high_gm_size;
         param.fence_sz = type->fence;
+        param.weight = type->weight;
         param.resolution = type->resolution;
 
         /* XXX current param based on MB */