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

Commit 6aa23ced authored by fred gao's avatar fred gao Committed by Zhenyu Wang
Browse files

drm/i915/gvt: Refactor vGPU type code in kvmgt part 



all the vGPU type related code in kvmgt will be moved into
gvt.c/gvt.h files while the common vGPU type related interfaces
will be called.

v2:
- intel_gvt_{init,cleanup}_vgpu_type_groups are initialized in
  gvt part. (Wang, Zhi)

Signed-off-by: default avatarfred gao <fred.gao@intel.com>
Reviewed-by: default avatarZhi Wang <zhi.a.wang@intel.com>
Signed-off-by: default avatarZhi Wang <zhi.a.wang@intel.com>
parent c5d71cb3

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

+8 −120
Original line number Diff line number Diff line
@@ -248,120 +248,6 @@ static void gvt_cache_destroy(struct intel_vgpu *vgpu) 
	}

}



static struct intel_vgpu_type *intel_gvt_find_vgpu_type(struct intel_gvt *gvt,

		const char *name)

{

	int i;

	struct intel_vgpu_type *t;

	const char *driver_name = dev_driver_string(

			&gvt->dev_priv->drm.pdev->dev);



	for (i = 0; i < gvt->num_types; i++) {

		t = &gvt->types[i];

		if (!strncmp(t->name, name + strlen(driver_name) + 1,

			sizeof(t->name)))

			return t;

	}



	return NULL;

}



static ssize_t available_instances_show(struct kobject *kobj,

					struct device *dev, char *buf)

{

	struct intel_vgpu_type *type;

	unsigned int num = 0;

	void *gvt = kdev_to_i915(dev)->gvt;



	type = intel_gvt_find_vgpu_type(gvt, kobject_name(kobj));

	if (!type)

		num = 0;

	else

		num = type->avail_instance;



	return sprintf(buf, "%u\n", num);

}



static ssize_t device_api_show(struct kobject *kobj, struct device *dev,

		char *buf)

{

	return sprintf(buf, "%s\n", VFIO_DEVICE_API_PCI_STRING);

}



static ssize_t description_show(struct kobject *kobj, struct device *dev,

		char *buf)

{

	struct intel_vgpu_type *type;

	void *gvt = kdev_to_i915(dev)->gvt;



	type = intel_gvt_find_vgpu_type(gvt, kobject_name(kobj));

	if (!type)

		return 0;



	return sprintf(buf, "low_gm_size: %dMB\nhigh_gm_size: %dMB\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->weight);

}



static MDEV_TYPE_ATTR_RO(available_instances);

static MDEV_TYPE_ATTR_RO(device_api);

static MDEV_TYPE_ATTR_RO(description);



static struct attribute *type_attrs[] = {

	&mdev_type_attr_available_instances.attr,

	&mdev_type_attr_device_api.attr,

	&mdev_type_attr_description.attr,

	NULL,

};



static struct attribute_group *intel_vgpu_type_groups[] = {

	[0 ... NR_MAX_INTEL_VGPU_TYPES - 1] = NULL,

};



static bool intel_gvt_init_vgpu_type_groups(struct intel_gvt *gvt)

{

	int i, j;

	struct intel_vgpu_type *type;

	struct attribute_group *group;



	for (i = 0; i < gvt->num_types; i++) {

		type = &gvt->types[i];



		group = kzalloc(sizeof(struct attribute_group), GFP_KERNEL);

		if (WARN_ON(!group))

			goto unwind;



		group->name = type->name;

		group->attrs = type_attrs;

		intel_vgpu_type_groups[i] = group;

	}



	return true;



unwind:

	for (j = 0; j < i; j++) {

		group = intel_vgpu_type_groups[j];

		kfree(group);

	}



	return false;

}



static void intel_gvt_cleanup_vgpu_type_groups(struct intel_gvt *gvt)

{

	int i;

	struct attribute_group *group;



	for (i = 0; i < gvt->num_types; i++) {

		group = intel_vgpu_type_groups[i];

		kfree(group);

	}

}



static void kvmgt_protect_table_init(struct kvmgt_guest_info *info)

{

	hash_init(info->ptable);
@@ -441,7 +327,7 @@ static int intel_vgpu_create(struct kobject *kobj, struct mdev_device *mdev) 
	pdev = mdev_parent_dev(mdev);

	gvt = kdev_to_i915(pdev)->gvt;



	type = intel_gvt_find_vgpu_type(gvt, kobject_name(kobj));

	type = intel_gvt_ops->gvt_find_vgpu_type(gvt, kobject_name(kobj));

	if (!type) {

		gvt_vgpu_err("failed to find type %s to create\n",

						kobject_name(kobj));
@@ -1212,8 +1098,7 @@ static const struct attribute_group *intel_vgpu_groups[] = { 
	NULL,

};



static const struct mdev_parent_ops intel_vgpu_ops = {

	.supported_type_groups	= intel_vgpu_type_groups,

static struct mdev_parent_ops intel_vgpu_ops = {

	.mdev_attr_groups       = intel_vgpu_groups,

	.create			= intel_vgpu_create,

	.remove			= intel_vgpu_remove,
@@ -1229,17 +1114,20 @@ static const struct mdev_parent_ops intel_vgpu_ops = { 


static int kvmgt_host_init(struct device *dev, void *gvt, const void *ops)

{

	if (!intel_gvt_init_vgpu_type_groups(gvt))

		return -EFAULT;

	struct attribute **kvm_type_attrs;

	struct attribute_group **kvm_vgpu_type_groups;



	intel_gvt_ops = ops;

	if (!intel_gvt_ops->get_gvt_attrs(&kvm_type_attrs,

			&kvm_vgpu_type_groups))

		return -EFAULT;

	intel_vgpu_ops.supported_type_groups = kvm_vgpu_type_groups;



	return mdev_register_device(dev, &intel_vgpu_ops);

}



static void kvmgt_host_exit(struct device *dev, void *gvt)

{

	intel_gvt_cleanup_vgpu_type_groups(gvt);

	mdev_unregister_device(dev);

}