Commit 5e6b9255 authored by Thomas Zimmermann's avatar Thomas Zimmermann Committed by Gerd Hoffmann
Browse files

drm/vboxvideo: Convert vboxvideo driver to |struct drm_gem_vram_object| 



This patch replaces |struct vbox_bo| and its helpers with the generic
implementation of |struct drm_gem_vram_object|. The only change in
semantics is that &ttm_bo_driver.verify_access() now does the actual
verification.

v4:
	* select config option DRM_VRAM_HELPER
v3:
	* remove forward declaration of struct vbox_gem_object
v2:
	nothing

Signed-off-by: default avatarThomas Zimmermann <tzimmermann@suse.de>
Reviewed-by: default avatarHans de Goede <hdegoede@redhat.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20190508082630.15116-18-tzimmermann@suse.de


Signed-off-by: default avatarGerd Hoffmann <kraxel@redhat.com>
parent a7581343

drivers/gpu/drm/vboxvideo/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -3,6 +3,7 @@ config DRM_VBOXVIDEO 
	depends on DRM && X86 && PCI

	select DRM_KMS_HELPER

	select DRM_TTM

	select DRM_VRAM_HELPER

	select GENERIC_ALLOCATOR

	help

	  This is a KMS driver for the virtual Graphics Card used in

drivers/gpu/drm/vboxvideo/vbox_drv.c

+3 −2
Original line number Diff line number Diff line
@@ -215,9 +215,10 @@ static struct drm_driver driver = { 
	.minor = DRIVER_MINOR,

	.patchlevel = DRIVER_PATCHLEVEL,



	.gem_free_object_unlocked = vbox_gem_free_object,

	.gem_free_object_unlocked =

		drm_gem_vram_driver_gem_free_object_unlocked,

	.dumb_create = vbox_dumb_create,

	.dumb_map_offset = vbox_dumb_mmap_offset,

	.dumb_map_offset = drm_gem_vram_driver_dumb_mmap_offset,

	.prime_handle_to_fd = drm_gem_prime_handle_to_fd,

	.prime_fd_to_handle = drm_gem_prime_fd_to_handle,

	.gem_prime_export = drm_gem_prime_export,

drivers/gpu/drm/vboxvideo/vbox_drv.h

+1 −59
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ 
#include <drm/drm_encoder.h>

#include <drm/drm_fb_helper.h>

#include <drm/drm_gem.h>

#include <drm/drm_gem_vram_helper.h>



#include <drm/ttm/ttm_bo_api.h>

#include <drm/ttm/ttm_bo_driver.h>
@@ -96,8 +97,6 @@ struct vbox_private { 
#undef CURSOR_PIXEL_COUNT

#undef CURSOR_DATA_SIZE



struct vbox_gem_object;



struct vbox_connector {

	struct drm_connector base;

	char name[32];
@@ -170,73 +169,16 @@ int vboxfb_create(struct drm_fb_helper *helper, 
		  struct drm_fb_helper_surface_size *sizes);

void vbox_fbdev_fini(struct vbox_private *vbox);



struct vbox_bo {

	struct ttm_buffer_object bo;

	struct ttm_placement placement;

	struct ttm_bo_kmap_obj kmap;

	struct drm_gem_object gem;

	struct ttm_place placements[3];

	int pin_count;

};



#define gem_to_vbox_bo(gobj) container_of((gobj), struct vbox_bo, gem)



static inline struct vbox_bo *vbox_bo(struct ttm_buffer_object *bo)

{

	return container_of(bo, struct vbox_bo, bo);

}



#define to_vbox_obj(x) container_of(x, struct vbox_gem_object, base)



static inline u64 vbox_bo_gpu_offset(struct vbox_bo *bo)

{

	return bo->bo.offset;

}



int vbox_dumb_create(struct drm_file *file,

		     struct drm_device *dev,

		     struct drm_mode_create_dumb *args);



void vbox_gem_free_object(struct drm_gem_object *obj);

int vbox_dumb_mmap_offset(struct drm_file *file,

			  struct drm_device *dev,

			  u32 handle, u64 *offset);



int vbox_mm_init(struct vbox_private *vbox);

void vbox_mm_fini(struct vbox_private *vbox);



int vbox_bo_create(struct vbox_private *vbox, int size, int align,

		   u32 flags, struct vbox_bo **pvboxbo);



int vbox_gem_create(struct vbox_private *vbox,

		    u32 size, bool iskernel, struct drm_gem_object **obj);



int vbox_bo_pin(struct vbox_bo *bo, u32 pl_flag);

int vbox_bo_unpin(struct vbox_bo *bo);



static inline int vbox_bo_reserve(struct vbox_bo *bo, bool no_wait)

{

	int ret;



	ret = ttm_bo_reserve(&bo->bo, true, no_wait, NULL);

	if (ret) {

		if (ret != -ERESTARTSYS && ret != -EBUSY)

			DRM_ERROR("reserve failed %p\n", bo);

		return ret;

	}

	return 0;

}



static inline void vbox_bo_unreserve(struct vbox_bo *bo)

{

	ttm_bo_unreserve(&bo->bo);

}



void vbox_ttm_placement(struct vbox_bo *bo, int domain);

int vbox_bo_push_sysram(struct vbox_bo *bo);

int vbox_mmap(struct file *filp, struct vm_area_struct *vma);

void *vbox_bo_kmap(struct vbox_bo *bo);

void vbox_bo_kunmap(struct vbox_bo *bo);



/* vbox_prime.c */

int vbox_gem_prime_pin(struct drm_gem_object *obj);

drivers/gpu/drm/vboxvideo/vbox_fb.c

+11 −11
Original line number Diff line number Diff line
@@ -51,9 +51,9 @@ int vboxfb_create(struct drm_fb_helper *helper, 
	struct drm_framebuffer *fb;

	struct fb_info *info;

	struct drm_gem_object *gobj;

	struct vbox_bo *bo;

	struct drm_gem_vram_object *gbo;

	int size, ret;

	u64 gpu_addr;

	s64 gpu_addr;

	u32 pitch;



	mode_cmd.width = sizes->surface_width;
@@ -75,9 +75,9 @@ int vboxfb_create(struct drm_fb_helper *helper, 
	if (ret)

		return ret;



	bo = gem_to_vbox_bo(gobj);

	gbo = drm_gem_vram_of_gem(gobj);



	ret = vbox_bo_pin(bo, TTM_PL_FLAG_VRAM);

	ret = drm_gem_vram_pin(gbo, DRM_GEM_VRAM_PL_FLAG_VRAM);

	if (ret)

		return ret;
@@ -86,7 +86,7 @@ int vboxfb_create(struct drm_fb_helper *helper, 
		return PTR_ERR(info);



	info->screen_size = size;

	info->screen_base = (char __iomem *)vbox_bo_kmap(bo);

	info->screen_base = (char __iomem *)drm_gem_vram_kmap(gbo, true, NULL);

	if (IS_ERR(info->screen_base))

		return PTR_ERR(info->screen_base);
@@ -104,7 +104,9 @@ int vboxfb_create(struct drm_fb_helper *helper, 


	drm_fb_helper_fill_info(info, helper, sizes);



	gpu_addr = vbox_bo_gpu_offset(bo);

	gpu_addr = drm_gem_vram_offset(gbo);

	if (gpu_addr < 0)

		return (int)gpu_addr;

	info->fix.smem_start = info->apertures->ranges[0].base + gpu_addr;

	info->fix.smem_len = vbox->available_vram_size - gpu_addr;
@@ -132,12 +134,10 @@ void vbox_fbdev_fini(struct vbox_private *vbox) 
	drm_fb_helper_unregister_fbi(&vbox->fb_helper);



	if (afb->obj) {

		struct vbox_bo *bo = gem_to_vbox_bo(afb->obj);

		struct drm_gem_vram_object *gbo = drm_gem_vram_of_gem(afb->obj);



		vbox_bo_kunmap(bo);



		if (bo->pin_count)

			vbox_bo_unpin(bo);

		drm_gem_vram_kunmap(gbo);

		drm_gem_vram_unpin(gbo);



		drm_gem_object_put_unlocked(afb->obj);

		afb->obj = NULL;

drivers/gpu/drm/vboxvideo/vbox_main.c

+8 −62
Original line number Diff line number Diff line
@@ -274,7 +274,7 @@ void vbox_hw_fini(struct vbox_private *vbox) 
int vbox_gem_create(struct vbox_private *vbox,

		    u32 size, bool iskernel, struct drm_gem_object **obj)

{

	struct vbox_bo *vboxbo;

	struct drm_gem_vram_object *gbo;

	int ret;



	*obj = NULL;
@@ -283,14 +283,15 @@ int vbox_gem_create(struct vbox_private *vbox, 
	if (size == 0)

		return -EINVAL;



	ret = vbox_bo_create(vbox, size, 0, 0, &vboxbo);

	if (ret) {

	gbo = drm_gem_vram_create(&vbox->ddev, &vbox->ttm.bdev, size, 0, false);

	if (IS_ERR(gbo)) {

		ret = PTR_ERR(gbo);

		if (ret != -ERESTARTSYS)

			DRM_ERROR("failed to allocate GEM object\n");

		return ret;

	}



	*obj = &vboxbo->gem;

	*obj = &gbo->gem;



	return 0;

}
@@ -298,64 +299,9 @@ int vbox_gem_create(struct vbox_private *vbox, 
int vbox_dumb_create(struct drm_file *file,

		     struct drm_device *dev, struct drm_mode_create_dumb *args)

{

	struct vbox_private *vbox =

		container_of(dev, struct vbox_private, ddev);

	struct drm_gem_object *gobj;

	u32 handle;

	int ret;



	args->pitch = args->width * ((args->bpp + 7) / 8);

	args->size = args->pitch * args->height;



	ret = vbox_gem_create(vbox, args->size, false, &gobj);

	if (ret)

		return ret;



	ret = drm_gem_handle_create(file, gobj, &handle);

	drm_gem_object_put_unlocked(gobj);

	if (ret)

		return ret;

	struct vbox_private *vbox = dev->dev_private;



	args->handle = handle;



	return 0;

}



void vbox_gem_free_object(struct drm_gem_object *obj)

{

	struct vbox_bo *vbox_bo = gem_to_vbox_bo(obj);

	return drm_gem_vram_fill_create_dumb(file, dev, &vbox->ttm.bdev, 0,

					    false, args);



	ttm_bo_put(&vbox_bo->bo);

}



static inline u64 vbox_bo_mmap_offset(struct vbox_bo *bo)

{

	return drm_vma_node_offset_addr(&bo->bo.vma_node);

}



int

vbox_dumb_mmap_offset(struct drm_file *file,

		      struct drm_device *dev,

		      u32 handle, u64 *offset)

{

	struct drm_gem_object *obj;

	int ret;

	struct vbox_bo *bo;



	mutex_lock(&dev->struct_mutex);

	obj = drm_gem_object_lookup(file, handle);

	if (!obj) {

		ret = -ENOENT;

		goto out_unlock;

	}



	bo = gem_to_vbox_bo(obj);

	*offset = vbox_bo_mmap_offset(bo);



	drm_gem_object_put(obj);

	ret = 0;



out_unlock:

	mutex_unlock(&dev->struct_mutex);

	return ret;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE