drm/exynos: cleanup name of gem object for exynos_drm
authorJoonyoung Shim <jy0922.shim@samsung.com>
Fri, 2 Oct 2015 00:33:47 +0000 (09:33 +0900)
committerInki Dae <daeinki@gmail.com>
Mon, 26 Oct 2015 06:10:34 +0000 (15:10 +0900)
Struct of gem object in exynos_drm driver is struct exynos_drm_gem_obj.
It's too long and we can know its meaning of name without _obj postfix.

We use several names to variable name of gem object for exynos_drm -
exynos_gem_obj, gem_obj and obj. Especially "obj" name can cause
misunderstanding with variable name "obj" of struct drm_gem_object.

This will clean about name of gem object for exynos_drm as follows.
s/struct exynos_drm_gem_obj/struct exynos_drm_gem
s/exynos_gem_obj or gem_obj or obj/exynos_gem

Signed-off-by: Joonyoung Shim <jy0922.shim@samsung.com>
Signed-off-by: Inki Dae <inki.dae@samsung.com>
drivers/gpu/drm/exynos/exynos_drm_fb.c
drivers/gpu/drm/exynos/exynos_drm_fb.h
drivers/gpu/drm/exynos/exynos_drm_fbdev.c
drivers/gpu/drm/exynos/exynos_drm_gem.c
drivers/gpu/drm/exynos/exynos_drm_gem.h
drivers/gpu/drm/exynos/exynos_drm_plane.c

index 084280859589669d17f5e3e04ac334f21710b4ac..fcea28bdbc42095244f2f08a5bafbb82ef43eeda 100644 (file)
  * 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 drm_framebuffer  fb;
+       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)
index 85e4445b920e30673bb7f3ae38591c5a29a5f902..726a2d44371ff09ccd39060e482913cdd059f4ae 100644 (file)
 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);
 
index a221f753ad9c7a971450b2cf2836dc43f63b3d1b..f6118baa8e3efad8732f8297ab6f6529d763171e 100644 (file)
@@ -30,8 +30,8 @@
                                drm_fb_helper)
 
 struct exynos_drm_fbdev {
-       struct drm_fb_helper            drm_fb_helper;
-       struct exynos_drm_gem_obj       *obj;
+       struct drm_fb_helper    drm_fb_helper;
+       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) {
index 407afedb60031a00f7f0cc5cb599cf7b3e57a9b8..f1dcdd086886d2fd6dc29bf73a0c54bd1a057030 100644 (file)
 #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,
-                                                     unsigned long size)
+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,
-                                               unsigned int flags,
-                                               unsigned long size)
+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,
-                       &args->handle);
+       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,
-                       &args->handle);
+       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,
-                       npages);
+       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);
 }
 
index b62d1007c0e05f88e4cfc38970bb7baa9a87fe7a..37ab8b282db6697c23a5f7832e009b0cccb0304b 100644 (file)
@@ -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,12 +58,12 @@ 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,
-                                               unsigned int flags,
-                                               unsigned long size);
+struct exynos_drm_gem *exynos_drm_gem_create(struct drm_device *dev,
+                                            unsigned int flags,
+                                            unsigned long size);
 
 /*
  * request gem object creation and buffer allocation as the 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,
index 80b2151bb7a868c3de94ffc1d9a65990f532772e..179311760bb7308795040b2a1584511efddfc3fa 100644 (file)
@@ -128,15 +128,14 @@ static int exynos_plane_atomic_check(struct drm_plane *plane,
 
        nr = drm_format_num_planes(state->fb->pixel_format);
        for (i = 0; i < nr; i++) {
-               struct exynos_drm_gem_obj *obj =
-                                       exynos_drm_fb_gem_obj(state->fb, i);
-
-               if (!obj) {
+               struct exynos_drm_gem *exynos_gem =
+                                       exynos_drm_fb_gem(state->fb, i);
+               if (!exynos_gem) {
                        DRM_DEBUG_KMS("gem object is null\n");
                        return -EFAULT;
                }
 
-               exynos_plane->dma_addr[i] = obj->dma_addr +
+               exynos_plane->dma_addr[i] = exynos_gem->dma_addr +
                                            state->fb->offsets[i];
 
                DRM_DEBUG_KMS("buffer: %d, dma_addr = 0x%lx\n",