drm/exynos: cleanup name of gem object for exynos_drm (813fd67b) · Commits · 戴 / test

drivers/gpu/drm/exynos/exynos_drm_fb.c

+22 −23

Original line number	Diff line number	Diff line
		@@ -32,15 +32,15 @@
		* exynos specific framebuffer structure.
		*
		* @fb: drm framebuffer obejct.
		* @exynos_gem_obj: array of exynos specific gem object containing a gem object.
		* @exynos_gem: array of exynos specific gem object containing a gem object.
		*/
		struct exynos_drm_fb {
		struct drm_framebuffer fb;
		struct exynos_drm_gem_obj *exynos_gem_obj[MAX_FB_BUFFER];
		struct exynos_drm_gem *exynos_gem[MAX_FB_BUFFER];
		};

		static int check_fb_gem_memory_type(struct drm_device *drm_dev,
		struct exynos_drm_gem_obj *exynos_gem_obj)
		struct exynos_drm_gem *exynos_gem)
		{
		unsigned int flags;

		@@ -51,7 +51,7 @@ static int check_fb_gem_memory_type(struct drm_device *drm_dev,
		if (is_drm_iommu_supported(drm_dev))
		return 0;

		flags = exynos_gem_obj->flags;
		flags = exynos_gem->flags;

		/*
		* without iommu support, not support physically non-continuous memory
		@@ -75,13 +75,13 @@ static void exynos_drm_fb_destroy(struct drm_framebuffer *fb)

		drm_framebuffer_cleanup(fb);

		for (i = 0; i < ARRAY_SIZE(exynos_fb->exynos_gem_obj); i++) {
		for (i = 0; i < ARRAY_SIZE(exynos_fb->exynos_gem); i++) {
		struct drm_gem_object *obj;

		if (exynos_fb->exynos_gem_obj[i] == NULL)
		if (exynos_fb->exynos_gem[i] == NULL)
		continue;

		obj = &exynos_fb->exynos_gem_obj[i]->base;
		obj = &exynos_fb->exynos_gem[i]->base;
		drm_gem_object_unreference_unlocked(obj);
		}

		@@ -96,7 +96,7 @@ static int exynos_drm_fb_create_handle(struct drm_framebuffer *fb,
		struct exynos_drm_fb *exynos_fb = to_exynos_fb(fb);

		return drm_gem_handle_create(file_priv,
		&exynos_fb->exynos_gem_obj[0]->base, handle);
		&exynos_fb->exynos_gem[0]->base, handle);
		}

		static int exynos_drm_fb_dirty(struct drm_framebuffer *fb,
		@@ -118,7 +118,7 @@ static struct drm_framebuffer_funcs exynos_drm_fb_funcs = {
		struct drm_framebuffer *
		exynos_drm_framebuffer_init(struct drm_device *dev,
		struct drm_mode_fb_cmd2 *mode_cmd,
		struct exynos_drm_gem_obj **gem_obj,
		struct exynos_drm_gem **exynos_gem,
		int count)
		{
		struct exynos_drm_fb *exynos_fb;
		@@ -130,11 +130,11 @@ exynos_drm_framebuffer_init(struct drm_device *dev,
		return ERR_PTR(-ENOMEM);

		for (i = 0; i < count; i++) {
		ret = check_fb_gem_memory_type(dev, gem_obj[i]);
		ret = check_fb_gem_memory_type(dev, exynos_gem[i]);
		if (ret < 0)
		goto err;

		exynos_fb->exynos_gem_obj[i] = gem_obj[i];
		exynos_fb->exynos_gem[i] = exynos_gem[i];
		}

		drm_helper_mode_fill_fb_struct(&exynos_fb->fb, mode_cmd);
		@@ -156,7 +156,7 @@ static struct drm_framebuffer *
		exynos_user_fb_create(struct drm_device dev, struct drm_file file_priv,
		struct drm_mode_fb_cmd2 *mode_cmd)
		{
		struct exynos_drm_gem_obj *gem_objs[MAX_FB_BUFFER];
		struct exynos_drm_gem *exynos_gem[MAX_FB_BUFFER];
		struct drm_gem_object *obj;
		struct drm_framebuffer *fb;
		int i;
		@@ -171,10 +171,10 @@ exynos_user_fb_create(struct drm_device dev, struct drm_file file_priv,
		goto err;
		}

		gem_objs[i] = to_exynos_gem_obj(obj);
		exynos_gem[i] = to_exynos_gem(obj);
		}

		fb = exynos_drm_framebuffer_init(dev, mode_cmd, gem_objs, i);
		fb = exynos_drm_framebuffer_init(dev, mode_cmd, exynos_gem, i);
		if (IS_ERR(fb)) {
		ret = PTR_ERR(fb);
		goto err;
		@@ -184,27 +184,26 @@ exynos_user_fb_create(struct drm_device dev, struct drm_file file_priv,

		err:
		while (i--)
		drm_gem_object_unreference_unlocked(&gem_objs[i]->base);
		drm_gem_object_unreference_unlocked(&exynos_gem[i]->base);

		return ERR_PTR(ret);
		}

		struct exynos_drm_gem_obj exynos_drm_fb_gem_obj(struct drm_framebuffer fb,
		int index)
		struct exynos_drm_gem exynos_drm_fb_gem(struct drm_framebuffer fb, int index)
		{
		struct exynos_drm_fb *exynos_fb = to_exynos_fb(fb);
		struct exynos_drm_gem_obj *obj;
		struct exynos_drm_gem *exynos_gem;

		if (index >= MAX_FB_BUFFER)
		return NULL;

		obj = exynos_fb->exynos_gem_obj[index];
		if (!obj)
		exynos_gem = exynos_fb->exynos_gem[index];
		if (!exynos_gem)
		return NULL;

		DRM_DEBUG_KMS("dma_addr = 0x%lx\n", (unsigned long)obj->dma_addr);
		DRM_DEBUG_KMS("dma_addr: 0x%lx\n", (unsigned long)exynos_gem->dma_addr);

		return obj;
		return exynos_gem;
		}

		static void exynos_drm_output_poll_changed(struct drm_device *dev)

drivers/gpu/drm/exynos/exynos_drm_fb.h

+2 −3

Original line number	Diff line number	Diff line
		@@ -19,12 +19,11 @@
		struct drm_framebuffer *
		exynos_drm_framebuffer_init(struct drm_device *dev,
		struct drm_mode_fb_cmd2 *mode_cmd,
		struct exynos_drm_gem_obj **gem_obj,
		struct exynos_drm_gem **exynos_gem,
		int count);

		/* get gem object of a drm framebuffer */
		struct exynos_drm_gem_obj exynos_drm_fb_gem_obj(struct drm_framebuffer fb,
		int index);
		struct exynos_drm_gem exynos_drm_fb_gem(struct drm_framebuffer fb, int index);

		void exynos_drm_mode_config_init(struct drm_device *dev);

drivers/gpu/drm/exynos/exynos_drm_fbdev.c

+28 −25

Original line number	Diff line number	Diff line
		@@ -31,7 +31,7 @@

		struct exynos_drm_fbdev {
		struct drm_fb_helper drm_fb_helper;
		struct exynos_drm_gem_obj *obj;
		struct exynos_drm_gem *exynos_gem;
		};

		static int exynos_drm_fb_mmap(struct fb_info *info,
		@@ -39,7 +39,7 @@ static int exynos_drm_fb_mmap(struct fb_info *info,
		{
		struct drm_fb_helper *helper = info->par;
		struct exynos_drm_fbdev *exynos_fbd = to_exynos_fbdev(helper);
		struct exynos_drm_gem_obj *obj = exynos_fbd->obj;
		struct exynos_drm_gem *exynos_gem = exynos_fbd->exynos_gem;
		unsigned long vm_size;
		int ret;

		@@ -47,11 +47,12 @@ static int exynos_drm_fb_mmap(struct fb_info *info,

		vm_size = vma->vm_end - vma->vm_start;

		if (vm_size > obj->size)
		if (vm_size > exynos_gem->size)
		return -EINVAL;

		ret = dma_mmap_attrs(helper->dev->dev, vma, obj->pages, obj->dma_addr,
		obj->size, &obj->dma_attrs);
		ret = dma_mmap_attrs(helper->dev->dev, vma, exynos_gem->pages,
		exynos_gem->dma_addr, exynos_gem->size,
		&exynos_gem->dma_attrs);
		if (ret < 0) {
		DRM_ERROR("failed to mmap.\n");
		return ret;
		@@ -75,7 +76,7 @@ static struct fb_ops exynos_drm_fb_ops = {

		static int exynos_drm_fbdev_update(struct drm_fb_helper *helper,
		struct drm_fb_helper_surface_size *sizes,
		struct exynos_drm_gem_obj *obj)
		struct exynos_drm_gem *exynos_gem)
		{
		struct fb_info *fbi;
		struct drm_framebuffer *fb = helper->fb;
		@@ -96,11 +97,11 @@ static int exynos_drm_fbdev_update(struct drm_fb_helper *helper,
		drm_fb_helper_fill_fix(fbi, fb->pitches[0], fb->depth);
		drm_fb_helper_fill_var(fbi, helper, sizes->fb_width, sizes->fb_height);

		nr_pages = obj->size >> PAGE_SHIFT;
		nr_pages = exynos_gem->size >> PAGE_SHIFT;

		obj->kvaddr = (void __iomem *) vmap(obj->pages, nr_pages, VM_MAP,
		pgprot_writecombine(PAGE_KERNEL));
		if (!obj->kvaddr) {
		exynos_gem->kvaddr = (void __iomem *) vmap(exynos_gem->pages, nr_pages,
		VM_MAP, pgprot_writecombine(PAGE_KERNEL));
		if (!exynos_gem->kvaddr) {
		DRM_ERROR("failed to map pages to kernel space.\n");
		drm_fb_helper_release_fbi(helper);
		return -EIO;
		@@ -109,7 +110,7 @@ static int exynos_drm_fbdev_update(struct drm_fb_helper *helper,
		offset = fbi->var.xoffset * (fb->bits_per_pixel >> 3);
		offset += fbi->var.yoffset * fb->pitches[0];

		fbi->screen_base = obj->kvaddr + offset;
		fbi->screen_base = exynos_gem->kvaddr + offset;
		fbi->screen_size = size;
		fbi->fix.smem_len = size;

		@@ -120,7 +121,7 @@ static int exynos_drm_fbdev_create(struct drm_fb_helper *helper,
		struct drm_fb_helper_surface_size *sizes)
		{
		struct exynos_drm_fbdev *exynos_fbdev = to_exynos_fbdev(helper);
		struct exynos_drm_gem_obj *obj;
		struct exynos_drm_gem *exynos_gem;
		struct drm_device *dev = helper->dev;
		struct drm_mode_fb_cmd2 mode_cmd = { 0 };
		struct platform_device *pdev = dev->platformdev;
		@@ -141,32 +142,34 @@ static int exynos_drm_fbdev_create(struct drm_fb_helper *helper,

		size = mode_cmd.pitches[0] * mode_cmd.height;

		obj = exynos_drm_gem_create(dev, EXYNOS_BO_CONTIG, size);
		exynos_gem = exynos_drm_gem_create(dev, EXYNOS_BO_CONTIG, size);
		/*
		* If physically contiguous memory allocation fails and if IOMMU is
		* supported then try to get buffer from non physically contiguous
		* memory area.
		*/
		if (IS_ERR(obj) && is_drm_iommu_supported(dev)) {
		if (IS_ERR(exynos_gem) && is_drm_iommu_supported(dev)) {
		dev_warn(&pdev->dev, "contiguous FB allocation failed, falling back to non-contiguous\n");
		obj = exynos_drm_gem_create(dev, EXYNOS_BO_NONCONTIG, size);
		exynos_gem = exynos_drm_gem_create(dev, EXYNOS_BO_NONCONTIG,
		size);
		}

		if (IS_ERR(obj)) {
		ret = PTR_ERR(obj);
		if (IS_ERR(exynos_gem)) {
		ret = PTR_ERR(exynos_gem);
		goto out;
		}

		exynos_fbdev->obj = obj;
		exynos_fbdev->exynos_gem = exynos_gem;

		helper->fb = exynos_drm_framebuffer_init(dev, &mode_cmd, &obj, 1);
		helper->fb =
		exynos_drm_framebuffer_init(dev, &mode_cmd, &exynos_gem, 1);
		if (IS_ERR(helper->fb)) {
		DRM_ERROR("failed to create drm framebuffer.\n");
		ret = PTR_ERR(helper->fb);
		goto err_destroy_gem;
		}

		ret = exynos_drm_fbdev_update(helper, sizes, obj);
		ret = exynos_drm_fbdev_update(helper, sizes, exynos_gem);
		if (ret < 0)
		goto err_destroy_framebuffer;

		@@ -176,7 +179,7 @@ static int exynos_drm_fbdev_create(struct drm_fb_helper *helper,
		err_destroy_framebuffer:
		drm_framebuffer_cleanup(helper->fb);
		err_destroy_gem:
		exynos_drm_gem_destroy(obj);
		exynos_drm_gem_destroy(exynos_gem);

		/*
		* if failed, all resources allocated above would be released by
		@@ -269,11 +272,11 @@ static void exynos_drm_fbdev_destroy(struct drm_device *dev,
		struct drm_fb_helper *fb_helper)
		{
		struct exynos_drm_fbdev *exynos_fbd = to_exynos_fbdev(fb_helper);
		struct exynos_drm_gem_obj *obj = exynos_fbd->obj;
		struct exynos_drm_gem *exynos_gem = exynos_fbd->exynos_gem;
		struct drm_framebuffer *fb;

		if (obj->kvaddr)
		vunmap(obj->kvaddr);
		if (exynos_gem->kvaddr)
		vunmap(exynos_gem->kvaddr);

		/* release drm framebuffer and real buffer */
		if (fb_helper->fb && fb_helper->fb->funcs) {

drivers/gpu/drm/exynos/exynos_drm_gem.c

+121 −118

Original line number	Diff line number	Diff line
		@@ -20,97 +20,100 @@
		#include "exynos_drm_gem.h"
		#include "exynos_drm_iommu.h"

		static int exynos_drm_alloc_buf(struct exynos_drm_gem_obj *obj)
		static int exynos_drm_alloc_buf(struct exynos_drm_gem *exynos_gem)
		{
		struct drm_device *dev = obj->base.dev;
		struct drm_device *dev = exynos_gem->base.dev;
		enum dma_attr attr;
		unsigned int nr_pages;

		if (obj->dma_addr) {
		if (exynos_gem->dma_addr) {
		DRM_DEBUG_KMS("already allocated.\n");
		return 0;
		}

		init_dma_attrs(&obj->dma_attrs);
		init_dma_attrs(&exynos_gem->dma_attrs);

		/*
		* if EXYNOS_BO_CONTIG, fully physically contiguous memory
		* region will be allocated else physically contiguous
		* as possible.
		*/
		if (!(obj->flags & EXYNOS_BO_NONCONTIG))
		dma_set_attr(DMA_ATTR_FORCE_CONTIGUOUS, &obj->dma_attrs);
		if (!(exynos_gem->flags & EXYNOS_BO_NONCONTIG))
		dma_set_attr(DMA_ATTR_FORCE_CONTIGUOUS, &exynos_gem->dma_attrs);

		/*
		* if EXYNOS_BO_WC or EXYNOS_BO_NONCACHABLE, writecombine mapping
		* else cachable mapping.
		*/
		if (obj->flags & EXYNOS_BO_WC \|\| !(obj->flags & EXYNOS_BO_CACHABLE))
		if (exynos_gem->flags & EXYNOS_BO_WC \|\|
		!(exynos_gem->flags & EXYNOS_BO_CACHABLE))
		attr = DMA_ATTR_WRITE_COMBINE;
		else
		attr = DMA_ATTR_NON_CONSISTENT;

		dma_set_attr(attr, &obj->dma_attrs);
		dma_set_attr(DMA_ATTR_NO_KERNEL_MAPPING, &obj->dma_attrs);
		dma_set_attr(attr, &exynos_gem->dma_attrs);
		dma_set_attr(DMA_ATTR_NO_KERNEL_MAPPING, &exynos_gem->dma_attrs);

		nr_pages = obj->size >> PAGE_SHIFT;
		nr_pages = exynos_gem->size >> PAGE_SHIFT;

		if (!is_drm_iommu_supported(dev)) {
		obj->pages = drm_calloc_large(nr_pages, sizeof(struct page *));
		if (!obj->pages) {
		exynos_gem->pages = drm_calloc_large(nr_pages,
		sizeof(struct page *));
		if (!exynos_gem->pages) {
		DRM_ERROR("failed to allocate pages.\n");
		return -ENOMEM;
		}
		}

		obj->cookie = dma_alloc_attrs(dev->dev, obj->size, &obj->dma_addr,
		GFP_KERNEL, &obj->dma_attrs);
		if (!obj->cookie) {
		exynos_gem->cookie = dma_alloc_attrs(dev->dev, exynos_gem->size,
		&exynos_gem->dma_addr, GFP_KERNEL,
		&exynos_gem->dma_attrs);
		if (!exynos_gem->cookie) {
		DRM_ERROR("failed to allocate buffer.\n");
		if (obj->pages)
		drm_free_large(obj->pages);
		if (exynos_gem->pages)
		drm_free_large(exynos_gem->pages);
		return -ENOMEM;
		}

		if (obj->pages) {
		if (exynos_gem->pages) {
		dma_addr_t start_addr;
		unsigned int i = 0;

		start_addr = obj->dma_addr;
		start_addr = exynos_gem->dma_addr;
		while (i < nr_pages) {
		obj->pages[i] = pfn_to_page(dma_to_pfn(dev->dev,
		start_addr));
		exynos_gem->pages[i] =
		pfn_to_page(dma_to_pfn(dev->dev, start_addr));
		start_addr += PAGE_SIZE;
		i++;
		}
		} else {
		obj->pages = obj->cookie;
		exynos_gem->pages = exynos_gem->cookie;
		}

		DRM_DEBUG_KMS("dma_addr(0x%lx), size(0x%lx)\n",
		(unsigned long)obj->dma_addr,
		obj->size);
		(unsigned long)exynos_gem->dma_addr, exynos_gem->size);

		return 0;
		}

		static void exynos_drm_free_buf(struct exynos_drm_gem_obj *obj)
		static void exynos_drm_free_buf(struct exynos_drm_gem *exynos_gem)
		{
		struct drm_device *dev = obj->base.dev;
		struct drm_device *dev = exynos_gem->base.dev;

		if (!obj->dma_addr) {
		if (!exynos_gem->dma_addr) {
		DRM_DEBUG_KMS("dma_addr is invalid.\n");
		return;
		}

		DRM_DEBUG_KMS("dma_addr(0x%lx), size(0x%lx)\n",
		(unsigned long)obj->dma_addr, obj->size);
		(unsigned long)exynos_gem->dma_addr, exynos_gem->size);

		dma_free_attrs(dev->dev, obj->size, obj->cookie,
		(dma_addr_t)obj->dma_addr, &obj->dma_attrs);
		dma_free_attrs(dev->dev, exynos_gem->size, exynos_gem->cookie,
		(dma_addr_t)exynos_gem->dma_addr,
		&exynos_gem->dma_attrs);

		if (!is_drm_iommu_supported(dev))
		drm_free_large(obj->pages);
		drm_free_large(exynos_gem->pages);
		}

		static int exynos_drm_gem_handle_create(struct drm_gem_object *obj,
		@@ -135,9 +138,9 @@ static int exynos_drm_gem_handle_create(struct drm_gem_object *obj,
		return 0;
		}

		void exynos_drm_gem_destroy(struct exynos_drm_gem_obj *exynos_gem_obj)
		void exynos_drm_gem_destroy(struct exynos_drm_gem *exynos_gem)
		{
		struct drm_gem_object *obj = &exynos_gem_obj->base;
		struct drm_gem_object *obj = &exynos_gem->base;

		DRM_DEBUG_KMS("handle count = %d\n", obj->handle_count);

		@@ -148,21 +151,21 @@ void exynos_drm_gem_destroy(struct exynos_drm_gem_obj *exynos_gem_obj)
		* once dmabuf's refcount becomes 0.
		*/
		if (obj->import_attach)
		drm_prime_gem_destroy(obj, exynos_gem_obj->sgt);
		drm_prime_gem_destroy(obj, exynos_gem->sgt);
		else
		exynos_drm_free_buf(exynos_gem_obj);
		exynos_drm_free_buf(exynos_gem);

		/* release file pointer to gem object. */
		drm_gem_object_release(obj);

		kfree(exynos_gem_obj);
		kfree(exynos_gem);
		}

		unsigned long exynos_drm_gem_get_size(struct drm_device *dev,
		unsigned int gem_handle,
		struct drm_file *file_priv)
		{
		struct exynos_drm_gem_obj *exynos_gem_obj;
		struct exynos_drm_gem *exynos_gem;
		struct drm_gem_object *obj;

		obj = drm_gem_object_lookup(dev, file_priv, gem_handle);
		@@ -171,51 +174,51 @@ unsigned long exynos_drm_gem_get_size(struct drm_device *dev,
		return 0;
		}

		exynos_gem_obj = to_exynos_gem_obj(obj);
		exynos_gem = to_exynos_gem(obj);

		drm_gem_object_unreference_unlocked(obj);

		return exynos_gem_obj->size;
		return exynos_gem->size;
		}

		static struct exynos_drm_gem_obj exynos_drm_gem_init(struct drm_device dev,
		static struct exynos_drm_gem exynos_drm_gem_init(struct drm_device dev,
		unsigned long size)
		{
		struct exynos_drm_gem_obj *exynos_gem_obj;
		struct exynos_drm_gem *exynos_gem;
		struct drm_gem_object *obj;
		int ret;

		exynos_gem_obj = kzalloc(sizeof(*exynos_gem_obj), GFP_KERNEL);
		if (!exynos_gem_obj)
		exynos_gem = kzalloc(sizeof(*exynos_gem), GFP_KERNEL);
		if (!exynos_gem)
		return ERR_PTR(-ENOMEM);

		exynos_gem_obj->size = size;
		obj = &exynos_gem_obj->base;
		exynos_gem->size = size;
		obj = &exynos_gem->base;

		ret = drm_gem_object_init(dev, obj, size);
		if (ret < 0) {
		DRM_ERROR("failed to initialize gem object\n");
		kfree(exynos_gem_obj);
		kfree(exynos_gem);
		return ERR_PTR(ret);
		}

		ret = drm_gem_create_mmap_offset(obj);
		if (ret < 0) {
		drm_gem_object_release(obj);
		kfree(exynos_gem_obj);
		kfree(exynos_gem);
		return ERR_PTR(ret);
		}

		DRM_DEBUG_KMS("created file object = 0x%x\n", (unsigned int)obj->filp);

		return exynos_gem_obj;
		return exynos_gem;
		}

		struct exynos_drm_gem_obj exynos_drm_gem_create(struct drm_device dev,
		struct exynos_drm_gem exynos_drm_gem_create(struct drm_device dev,
		unsigned int flags,
		unsigned long size)
		{
		struct exynos_drm_gem_obj *exynos_gem_obj;
		struct exynos_drm_gem *exynos_gem;
		int ret;

		if (flags & ~(EXYNOS_BO_MASK)) {
		@@ -230,38 +233,38 @@ struct exynos_drm_gem_obj exynos_drm_gem_create(struct drm_device dev,

		size = roundup(size, PAGE_SIZE);

		exynos_gem_obj = exynos_drm_gem_init(dev, size);
		if (IS_ERR(exynos_gem_obj))
		return exynos_gem_obj;
		exynos_gem = exynos_drm_gem_init(dev, size);
		if (IS_ERR(exynos_gem))
		return exynos_gem;

		/* set memory type and cache attribute from user side. */
		exynos_gem_obj->flags = flags;
		exynos_gem->flags = flags;

		ret = exynos_drm_alloc_buf(exynos_gem_obj);
		ret = exynos_drm_alloc_buf(exynos_gem);
		if (ret < 0) {
		drm_gem_object_release(&exynos_gem_obj->base);
		kfree(exynos_gem_obj);
		drm_gem_object_release(&exynos_gem->base);
		kfree(exynos_gem);
		return ERR_PTR(ret);
		}

		return exynos_gem_obj;
		return exynos_gem;
		}

		int exynos_drm_gem_create_ioctl(struct drm_device dev, void data,
		struct drm_file *file_priv)
		{
		struct drm_exynos_gem_create *args = data;
		struct exynos_drm_gem_obj *exynos_gem_obj;
		struct exynos_drm_gem *exynos_gem;
		int ret;

		exynos_gem_obj = exynos_drm_gem_create(dev, args->flags, args->size);
		if (IS_ERR(exynos_gem_obj))
		return PTR_ERR(exynos_gem_obj);
		exynos_gem = exynos_drm_gem_create(dev, args->flags, args->size);
		if (IS_ERR(exynos_gem))
		return PTR_ERR(exynos_gem);

		ret = exynos_drm_gem_handle_create(&exynos_gem_obj->base, file_priv,
		ret = exynos_drm_gem_handle_create(&exynos_gem->base, file_priv,
		&args->handle);
		if (ret) {
		exynos_drm_gem_destroy(exynos_gem_obj);
		exynos_drm_gem_destroy(exynos_gem);
		return ret;
		}

		@@ -272,7 +275,7 @@ dma_addr_t exynos_drm_gem_get_dma_addr(struct drm_device dev,
		unsigned int gem_handle,
		struct drm_file *filp)
		{
		struct exynos_drm_gem_obj *exynos_gem_obj;
		struct exynos_drm_gem *exynos_gem;
		struct drm_gem_object *obj;

		obj = drm_gem_object_lookup(dev, filp, gem_handle);
		@@ -281,9 +284,9 @@ dma_addr_t exynos_drm_gem_get_dma_addr(struct drm_device dev,
		return ERR_PTR(-EINVAL);
		}

		exynos_gem_obj = to_exynos_gem_obj(obj);
		exynos_gem = to_exynos_gem(obj);

		return &exynos_gem_obj->dma_addr;
		return &exynos_gem->dma_addr;
		}

		void exynos_drm_gem_put_dma_addr(struct drm_device *dev,
		@@ -307,10 +310,10 @@ void exynos_drm_gem_put_dma_addr(struct drm_device *dev,
		drm_gem_object_unreference_unlocked(obj);
		}

		static int exynos_drm_gem_mmap_buffer(struct exynos_drm_gem_obj *exynos_gem_obj,
		static int exynos_drm_gem_mmap_buffer(struct exynos_drm_gem *exynos_gem,
		struct vm_area_struct *vma)
		{
		struct drm_device *drm_dev = exynos_gem_obj->base.dev;
		struct drm_device *drm_dev = exynos_gem->base.dev;
		unsigned long vm_size;
		int ret;

		@@ -320,12 +323,12 @@ static int exynos_drm_gem_mmap_buffer(struct exynos_drm_gem_obj *exynos_gem_obj,
		vm_size = vma->vm_end - vma->vm_start;

		/* check if user-requested size is valid. */
		if (vm_size > exynos_gem_obj->size)
		if (vm_size > exynos_gem->size)
		return -EINVAL;

		ret = dma_mmap_attrs(drm_dev->dev, vma, exynos_gem_obj->pages,
		exynos_gem_obj->dma_addr, exynos_gem_obj->size,
		&exynos_gem_obj->dma_attrs);
		ret = dma_mmap_attrs(drm_dev->dev, vma, exynos_gem->pages,
		exynos_gem->dma_addr, exynos_gem->size,
		&exynos_gem->dma_attrs);
		if (ret < 0) {
		DRM_ERROR("failed to mmap.\n");
		return ret;
		@@ -337,7 +340,7 @@ static int exynos_drm_gem_mmap_buffer(struct exynos_drm_gem_obj *exynos_gem_obj,
		int exynos_drm_gem_get_ioctl(struct drm_device dev, void data,
		struct drm_file *file_priv)
		{
		struct exynos_drm_gem_obj *exynos_gem_obj;
		struct exynos_drm_gem *exynos_gem;
		struct drm_exynos_gem_info *args = data;
		struct drm_gem_object *obj;

		@@ -350,10 +353,10 @@ int exynos_drm_gem_get_ioctl(struct drm_device dev, void data,
		return -EINVAL;
		}

		exynos_gem_obj = to_exynos_gem_obj(obj);
		exynos_gem = to_exynos_gem(obj);

		args->flags = exynos_gem_obj->flags;
		args->size = exynos_gem_obj->size;
		args->flags = exynos_gem->flags;
		args->size = exynos_gem->size;

		drm_gem_object_unreference(obj);
		mutex_unlock(&dev->struct_mutex);
		@@ -389,14 +392,14 @@ void exynos_gem_unmap_sgt_from_dma(struct drm_device *drm_dev,

		void exynos_drm_gem_free_object(struct drm_gem_object *obj)
		{
		exynos_drm_gem_destroy(to_exynos_gem_obj(obj));
		exynos_drm_gem_destroy(to_exynos_gem(obj));
		}

		int exynos_drm_gem_dumb_create(struct drm_file *file_priv,
		struct drm_device *dev,
		struct drm_mode_create_dumb *args)
		{
		struct exynos_drm_gem_obj *exynos_gem_obj;
		struct exynos_drm_gem *exynos_gem;
		unsigned int flags;
		int ret;

		@@ -414,16 +417,16 @@ int exynos_drm_gem_dumb_create(struct drm_file *file_priv,
		else
		flags = EXYNOS_BO_CONTIG \| EXYNOS_BO_WC;

		exynos_gem_obj = exynos_drm_gem_create(dev, flags, args->size);
		if (IS_ERR(exynos_gem_obj)) {
		exynos_gem = exynos_drm_gem_create(dev, flags, args->size);
		if (IS_ERR(exynos_gem)) {
		dev_warn(dev->dev, "FB allocation failed.\n");
		return PTR_ERR(exynos_gem_obj);
		return PTR_ERR(exynos_gem);
		}

		ret = exynos_drm_gem_handle_create(&exynos_gem_obj->base, file_priv,
		ret = exynos_drm_gem_handle_create(&exynos_gem->base, file_priv,
		&args->handle);
		if (ret) {
		exynos_drm_gem_destroy(exynos_gem_obj);
		exynos_drm_gem_destroy(exynos_gem);
		return ret;
		}

		@@ -464,7 +467,7 @@ unlock:
		int exynos_drm_gem_fault(struct vm_area_struct vma, struct vm_fault vmf)
		{
		struct drm_gem_object *obj = vma->vm_private_data;
		struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj);
		struct exynos_drm_gem *exynos_gem = to_exynos_gem(obj);
		unsigned long pfn;
		pgoff_t page_offset;
		int ret;
		@@ -472,13 +475,13 @@ int exynos_drm_gem_fault(struct vm_area_struct vma, struct vm_fault vmf)
		page_offset = ((unsigned long)vmf->virtual_address -
		vma->vm_start) >> PAGE_SHIFT;

		if (page_offset >= (exynos_gem_obj->size >> PAGE_SHIFT)) {
		if (page_offset >= (exynos_gem->size >> PAGE_SHIFT)) {
		DRM_ERROR("invalid page offset\n");
		ret = -EINVAL;
		goto out;
		}

		pfn = page_to_pfn(exynos_gem_obj->pages[page_offset]);
		pfn = page_to_pfn(exynos_gem->pages[page_offset]);
		ret = vm_insert_mixed(vma, (unsigned long)vmf->virtual_address, pfn);

		out:
		@@ -496,7 +499,7 @@ out:

		int exynos_drm_gem_mmap(struct file filp, struct vm_area_struct vma)
		{
		struct exynos_drm_gem_obj *exynos_gem_obj;
		struct exynos_drm_gem *exynos_gem;
		struct drm_gem_object *obj;
		int ret;

		@@ -508,21 +511,21 @@ int exynos_drm_gem_mmap(struct file filp, struct vm_area_struct vma)
		}

		obj = vma->vm_private_data;
		exynos_gem_obj = to_exynos_gem_obj(obj);
		exynos_gem = to_exynos_gem(obj);

		DRM_DEBUG_KMS("flags = 0x%x\n", exynos_gem_obj->flags);
		DRM_DEBUG_KMS("flags = 0x%x\n", exynos_gem->flags);

		/* non-cachable as default. */
		if (exynos_gem_obj->flags & EXYNOS_BO_CACHABLE)
		if (exynos_gem->flags & EXYNOS_BO_CACHABLE)
		vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
		else if (exynos_gem_obj->flags & EXYNOS_BO_WC)
		else if (exynos_gem->flags & EXYNOS_BO_WC)
		vma->vm_page_prot =
		pgprot_writecombine(vm_get_page_prot(vma->vm_flags));
		else
		vma->vm_page_prot =
		pgprot_noncached(vm_get_page_prot(vma->vm_flags));

		ret = exynos_drm_gem_mmap_buffer(exynos_gem_obj, vma);
		ret = exynos_drm_gem_mmap_buffer(exynos_gem, vma);
		if (ret)
		goto err_close_vm;

		@@ -537,12 +540,12 @@ err_close_vm:
		/* low-level interface prime helpers */
		struct sg_table exynos_drm_gem_prime_get_sg_table(struct drm_gem_object obj)
		{
		struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj);
		struct exynos_drm_gem *exynos_gem = to_exynos_gem(obj);
		int npages;

		npages = exynos_gem_obj->size >> PAGE_SHIFT;
		npages = exynos_gem->size >> PAGE_SHIFT;

		return drm_prime_pages_to_sg(exynos_gem_obj->pages, npages);
		return drm_prime_pages_to_sg(exynos_gem->pages, npages);
		}

		struct drm_gem_object *
		@@ -550,35 +553,35 @@ exynos_drm_gem_prime_import_sg_table(struct drm_device *dev,
		struct dma_buf_attachment *attach,
		struct sg_table *sgt)
		{
		struct exynos_drm_gem_obj *exynos_gem_obj;
		struct exynos_drm_gem *exynos_gem;
		int npages;
		int ret;

		exynos_gem_obj = exynos_drm_gem_init(dev, attach->dmabuf->size);
		if (IS_ERR(exynos_gem_obj)) {
		ret = PTR_ERR(exynos_gem_obj);
		exynos_gem = exynos_drm_gem_init(dev, attach->dmabuf->size);
		if (IS_ERR(exynos_gem)) {
		ret = PTR_ERR(exynos_gem);
		return ERR_PTR(ret);
		}

		exynos_gem_obj->dma_addr = sg_dma_address(sgt->sgl);
		exynos_gem->dma_addr = sg_dma_address(sgt->sgl);

		npages = exynos_gem_obj->size >> PAGE_SHIFT;
		exynos_gem_obj->pages = drm_malloc_ab(npages, sizeof(struct page *));
		if (!exynos_gem_obj->pages) {
		npages = exynos_gem->size >> PAGE_SHIFT;
		exynos_gem->pages = drm_malloc_ab(npages, sizeof(struct page *));
		if (!exynos_gem->pages) {
		ret = -ENOMEM;
		goto err;
		}

		ret = drm_prime_sg_to_page_addr_arrays(sgt, exynos_gem_obj->pages, NULL,
		ret = drm_prime_sg_to_page_addr_arrays(sgt, exynos_gem->pages, NULL,
		npages);
		if (ret < 0)
		goto err_free_large;

		exynos_gem_obj->sgt = sgt;
		exynos_gem->sgt = sgt;

		if (sgt->nents == 1) {
		/* always physically continuous memory if sgt->nents is 1. */
		exynos_gem_obj->flags \|= EXYNOS_BO_CONTIG;
		exynos_gem->flags \|= EXYNOS_BO_CONTIG;
		} else {
		/*
		* this case could be CONTIG or NONCONTIG type but for now
		@@ -586,16 +589,16 @@ exynos_drm_gem_prime_import_sg_table(struct drm_device *dev,
		* TODO. we have to find a way that exporter can notify
		* the type of its own buffer to importer.
		*/
		exynos_gem_obj->flags \|= EXYNOS_BO_NONCONTIG;
		exynos_gem->flags \|= EXYNOS_BO_NONCONTIG;
		}

		return &exynos_gem_obj->base;
		return &exynos_gem->base;

		err_free_large:
		drm_free_large(exynos_gem_obj->pages);
		drm_free_large(exynos_gem->pages);
		err:
		drm_gem_object_release(&exynos_gem_obj->base);
		kfree(exynos_gem_obj);
		drm_gem_object_release(&exynos_gem->base);
		kfree(exynos_gem);
		return ERR_PTR(ret);
		}

drivers/gpu/drm/exynos/exynos_drm_gem.h

+7 −8

Original line number	Diff line number	Diff line
		@@ -14,8 +14,7 @@

		#include <drm/drm_gem.h>

		#define to_exynos_gem_obj(x) container_of(x,\
		struct exynos_drm_gem_obj, base)
		#define to_exynos_gem(x) container_of(x, struct exynos_drm_gem, base)

		#define IS_NONCONTIG_BUFFER(f) (f & EXYNOS_BO_NONCONTIG)

		@@ -44,7 +43,7 @@
		* P.S. this object would be transferred to user as kms_bo.handle so
		* user can access the buffer through kms_bo.handle.
		*/
		struct exynos_drm_gem_obj {
		struct exynos_drm_gem {
		struct drm_gem_object base;
		unsigned int flags;
		unsigned long size;
		@@ -59,10 +58,10 @@ struct exynos_drm_gem_obj {
		struct page *exynos_gem_get_pages(struct drm_gem_object obj, gfp_t gfpmask);

		/* destroy a buffer with gem object */
		void exynos_drm_gem_destroy(struct exynos_drm_gem_obj *exynos_gem_obj);
		void exynos_drm_gem_destroy(struct exynos_drm_gem *exynos_gem);

		/* create a new buffer with gem object */
		struct exynos_drm_gem_obj exynos_drm_gem_create(struct drm_device dev,
		struct exynos_drm_gem exynos_drm_gem_create(struct drm_device dev,
		unsigned int flags,
		unsigned long size);

		@@ -106,7 +105,7 @@ unsigned long exynos_drm_gem_get_size(struct drm_device *dev,
		struct drm_file *file_priv);

		/* free gem object. */
		void exynos_drm_gem_free_object(struct drm_gem_object *gem_obj);
		void exynos_drm_gem_free_object(struct drm_gem_object *obj);

		/* create memory region for drm framebuffer. */
		int exynos_drm_gem_dumb_create(struct drm_file *file_priv,

Admin message