Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1f31c829 authored by Zhenyu Wang's avatar Zhenyu Wang
Browse files

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: default avatarZhenyu Wang <zhenyuw@linux.intel.com>
Signed-off-by: default avatarJike Song <jike.song@intel.com>
parent c754936f

drivers/gpu/drm/i915/gvt/gvt.c

+10 −1
Original line number Diff line number Diff line
@@ -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:

drivers/gpu/drm/i915/gvt/gvt.h

+25 −3
Original line number Diff line number Diff line
@@ -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;
@@ -230,6 +242,14 @@ static inline void intel_gvt_request_service(struct intel_gvt *gvt, 
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)) && \

drivers/gpu/drm/i915/gvt/vgpu.c

+137 −11
Original line number Diff line number Diff line
@@ -132,6 +132,106 @@ void populate_pvinfo_page(struct intel_vgpu *vgpu) 
	WARN_ON(sizeof(struct vgt_if) != VGT_PVINFO_SIZE);

}



/**

 * 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 @@ struct intel_vgpu *intel_gvt_create_vgpu(struct intel_gvt *gvt, 
	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;

}