drm/i915/gvt: add intel vgpu types support

By providing predefined vGPU types, users can choose which type a vgpu
to create and use, without specifying detailed parameters.

Signed-off-by: Zhenyu Wang <zhenyuw@linux.intel.com>
Signed-off-by: Jike Song <jike.song@intel.com>

diff --git a/drivers/gpu/drm/i915/gvt/gvt.c b/drivers/gpu/drm/i915/gvt/gvt.c
index 385969a..48a67d1 100644 (file)
--- a/drivers/gpu/drm/i915/gvt/gvt.c
+++ b/drivers/gpu/drm/i915/gvt/gvt.c
@@ -193,6 +193,8 @@ void intel_gvt_clean_device(struct drm_i915_private *dev_priv)
        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;
 }
@@ -270,10 +272,17 @@ int intel_gvt_init_device(struct drm_i915_private *dev_priv)
        if (ret)
                goto out_clean_cmd_parser;
 
-       gvt_dbg_core("gvt device creation is done\n");
+       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:

diff --git a/drivers/gpu/drm/i915/gvt/gvt.h b/drivers/gpu/drm/i915/gvt/gvt.h
index 62fc9e3..33e6a64 100644 (file)
--- a/drivers/gpu/drm/i915/gvt/gvt.h
+++ b/drivers/gpu/drm/i915/gvt/gvt.h
@@ -190,6 +190,16 @@ struct intel_gvt_opregion {
        u32 opregion_pa;
 };
 
+#define NR_MAX_INTEL_VGPU_TYPES 20
+struct intel_vgpu_type {
+       char name[16];
+       unsigned int max_instance;
+       unsigned int avail_instance;
+       unsigned int low_gm_size;
+       unsigned int high_gm_size;
+       unsigned int fence;
+};
+
 struct intel_gvt {
        struct mutex lock;
        struct drm_i915_private *dev_priv;
@@ -205,6 +215,8 @@ struct intel_gvt {
        struct intel_gvt_opregion opregion;
        struct intel_gvt_workload_scheduler scheduler;
        DECLARE_HASHTABLE(cmd_table, GVT_CMD_HASH_BITS);
+       struct intel_vgpu_type *types;
+       unsigned int num_types;
 
        struct task_struct *service_thread;
        wait_queue_head_t service_thread_wq;
@@ -231,6 +243,14 @@ void intel_gvt_free_firmware(struct intel_gvt *gvt);
 int intel_gvt_load_firmware(struct intel_gvt *gvt);
 
 /* Aperture/GM space definitions for GVT device */
+#define MB_TO_BYTES(mb) ((mb) << 20ULL)
+#define BYTES_TO_MB(b) ((b) >> 20ULL)
+
+#define HOST_LOW_GM_SIZE MB_TO_BYTES(128)
+#define HOST_HIGH_GM_SIZE MB_TO_BYTES(384)
+#define HOST_FENCE 4
+
+/* Aperture/GM space definitions for GVT device */
 #define gvt_aperture_sz(gvt)     (gvt->dev_priv->ggtt.mappable_end)
 #define gvt_aperture_pa_base(gvt) (gvt->dev_priv->ggtt.mappable_base)
 
@@ -330,12 +350,14 @@ static inline void intel_vgpu_write_pci_bar(struct intel_vgpu *vgpu,
        }
 }
 
-struct intel_vgpu *intel_gvt_create_vgpu(struct intel_gvt *gvt,
-                                        struct intel_vgpu_creation_params *
-                                        param);
+int intel_gvt_init_vgpu_types(struct intel_gvt *gvt);
+void intel_gvt_clean_vgpu_types(struct intel_gvt *gvt);
 
+struct intel_vgpu *intel_gvt_create_vgpu(struct intel_gvt *gvt,
+                                        struct intel_vgpu_type *type);
 void intel_gvt_destroy_vgpu(struct intel_vgpu *vgpu);
 
+
 /* validating GM functions */
 #define vgpu_gmadr_is_aperture(vgpu, gmadr) \
        ((gmadr >= vgpu_aperture_gmadr_base(vgpu)) && \

diff --git a/drivers/gpu/drm/i915/gvt/vgpu.c b/drivers/gpu/drm/i915/gvt/vgpu.c
index 4f54005..de3c187 100644 (file)
--- a/drivers/gpu/drm/i915/gvt/vgpu.c
+++ b/drivers/gpu/drm/i915/gvt/vgpu.c
@@ -133,6 +133,106 @@ void populate_pvinfo_page(struct intel_vgpu *vgpu)
 }
 
 /**
+ * intel_gvt_init_vgpu_types - initialize vGPU type list
+ * @gvt : GVT device
+ *
+ * Initialize vGPU type list based on available resource.
+ *
+ */
+int intel_gvt_init_vgpu_types(struct intel_gvt *gvt)
+{
+       unsigned int num_types;
+       unsigned int i, low_avail;
+       unsigned int min_low;
+
+       /* vGPU type name is defined as GVTg_Vx_y which contains
+        * physical GPU generation type and 'y' means maximum vGPU
+        * instances user can create on one physical GPU for this
+        * type.
+        *
+        * Depend on physical SKU resource, might see vGPU types like
+        * GVTg_V4_8, GVTg_V4_4, GVTg_V4_2, etc. We can create
+        * different types of vGPU on same physical GPU depending on
+        * available resource. Each vGPU type will have "avail_instance"
+        * to indicate how many vGPU instance can be created for this
+        * type.
+        *
+        * Currently use static size here as we init type earlier..
+        */
+       low_avail = MB_TO_BYTES(256) - HOST_LOW_GM_SIZE;
+       num_types = 4;
+
+       gvt->types = kzalloc(num_types * sizeof(struct intel_vgpu_type),
+                            GFP_KERNEL);
+       if (!gvt->types)
+               return -ENOMEM;
+
+       min_low = MB_TO_BYTES(32);
+       for (i = 0; i < num_types; ++i) {
+               if (low_avail / min_low == 0)
+                       break;
+               gvt->types[i].low_gm_size = min_low;
+               gvt->types[i].high_gm_size = 3 * gvt->types[i].low_gm_size;
+               gvt->types[i].fence = 4;
+               gvt->types[i].max_instance = low_avail / min_low;
+               gvt->types[i].avail_instance = gvt->types[i].max_instance;
+
+               if (IS_GEN8(gvt->dev_priv))
+                       sprintf(gvt->types[i].name, "GVTg_V4_%u",
+                                               gvt->types[i].max_instance);
+               else if (IS_GEN9(gvt->dev_priv))
+                       sprintf(gvt->types[i].name, "GVTg_V5_%u",
+                                               gvt->types[i].max_instance);
+
+               min_low <<= 1;
+               gvt_dbg_core("type[%d]: %s max %u avail %u low %u high %u fence %u\n",
+                            i, gvt->types[i].name, gvt->types[i].max_instance,
+                            gvt->types[i].avail_instance,
+                            gvt->types[i].low_gm_size,
+                            gvt->types[i].high_gm_size, gvt->types[i].fence);
+       }
+
+       gvt->num_types = i;
+       return 0;
+}
+
+void intel_gvt_clean_vgpu_types(struct intel_gvt *gvt)
+{
+       kfree(gvt->types);
+}
+
+static void intel_gvt_update_vgpu_types(struct intel_gvt *gvt)
+{
+       int i;
+       unsigned int low_gm_avail, high_gm_avail, fence_avail;
+       unsigned int low_gm_min, high_gm_min, fence_min, total_min;
+
+       /* Need to depend on maxium hw resource size but keep on
+        * static config for now.
+        */
+       low_gm_avail = MB_TO_BYTES(256) - HOST_LOW_GM_SIZE -
+               gvt->gm.vgpu_allocated_low_gm_size;
+       high_gm_avail = MB_TO_BYTES(256) * 3 - HOST_HIGH_GM_SIZE -
+               gvt->gm.vgpu_allocated_high_gm_size;
+       fence_avail = gvt_fence_sz(gvt) - HOST_FENCE -
+               gvt->fence.vgpu_allocated_fence_num;
+
+       for (i = 0; i < gvt->num_types; i++) {
+               low_gm_min = low_gm_avail / gvt->types[i].low_gm_size;
+               high_gm_min = high_gm_avail / gvt->types[i].high_gm_size;
+               fence_min = fence_avail / gvt->types[i].fence;
+               total_min = min(min(low_gm_min, high_gm_min), fence_min);
+               gvt->types[i].avail_instance = min(gvt->types[i].max_instance,
+                                                  total_min);
+
+               gvt_dbg_core("update type[%d]: %s max %u avail %u low %u high %u fence %u\n",
+                      i, gvt->types[i].name, gvt->types[i].max_instance,
+                      gvt->types[i].avail_instance, gvt->types[i].low_gm_size,
+                      gvt->types[i].high_gm_size, gvt->types[i].fence);
+       }
+}
+
+/**
  * intel_gvt_destroy_vgpu - destroy a virtual GPU
  * @vgpu: virtual GPU
  *
@@ -166,20 +266,11 @@ void intel_gvt_destroy_vgpu(struct intel_vgpu *vgpu)
        clean_vgpu_mmio(vgpu);
        vfree(vgpu);
 
+       intel_gvt_update_vgpu_types(gvt);
        mutex_unlock(&gvt->lock);
 }
 
-/**
- * intel_gvt_create_vgpu - create a virtual GPU
- * @gvt: GVT device
- * @param: vGPU creation parameters
- *
- * This function is called when user wants to create a virtual GPU.
- *
- * Returns:
- * pointer to intel_vgpu, error pointer if failed.
- */
-struct intel_vgpu *intel_gvt_create_vgpu(struct intel_gvt *gvt,
+static struct intel_vgpu *__intel_gvt_create_vgpu(struct intel_gvt *gvt,
                struct intel_vgpu_creation_params *param)
 {
        struct intel_vgpu *vgpu;
@@ -272,3 +363,38 @@ out_free_vgpu:
        mutex_unlock(&gvt->lock);
        return ERR_PTR(ret);
 }
+
+/**
+ * intel_gvt_create_vgpu - create a virtual GPU
+ * @gvt: GVT device
+ * @type: type of the vGPU to create
+ *
+ * This function is called when user wants to create a virtual GPU.
+ *
+ * Returns:
+ * pointer to intel_vgpu, error pointer if failed.
+ */
+struct intel_vgpu *intel_gvt_create_vgpu(struct intel_gvt *gvt,
+                               struct intel_vgpu_type *type)
+{
+       struct intel_vgpu_creation_params param;
+       struct intel_vgpu *vgpu;
+
+       param.handle = 0;
+       param.low_gm_sz = type->low_gm_size;
+       param.high_gm_sz = type->high_gm_size;
+       param.fence_sz = type->fence;
+
+       /* XXX current param based on MB */
+       param.low_gm_sz = BYTES_TO_MB(param.low_gm_sz);
+       param.high_gm_sz = BYTES_TO_MB(param.high_gm_sz);
+
+       vgpu = __intel_gvt_create_vgpu(gvt, &param);
+       if (IS_ERR(vgpu))
+               return vgpu;
+
+       /* calculate left instance change for types */
+       intel_gvt_update_vgpu_types(gvt);
+
+       return vgpu;
+}