drivers/gpu/drm/exynos/exynos_drm_gem.c

   1 /* exynos_drm_gem.c
   2  *
   3  * Copyright (c) 2011 Samsung Electronics Co., Ltd.
   4  * Author: Inki Dae <inki.dae@samsung.com>
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the next
  14  * paragraph) shall be included in all copies or substantial portions of the
  15  * Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  21  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  22  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  23  * OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26 #include "drmP.h"
  27 #include "drm.h"
  28
  29 #include <linux/shmem_fs.h>
  30 #include <drm/exynos_drm.h>
  31
  32 #include "exynos_drm_drv.h"
  33 #include "exynos_drm_gem.h"
  34 #include "exynos_drm_buf.h"
  35
  36 static unsigned int convert_to_vm_err_msg(int msg)
  37 {
  38         unsigned int out_msg;
  39
  40         switch (msg) {
  41         case 0:
  42         case -ERESTARTSYS:
  43         case -EINTR:
  44                 out_msg = VM_FAULT_NOPAGE;
  45                 break;
  46
  47         case -ENOMEM:
  48                 out_msg = VM_FAULT_OOM;
  49                 break;
  50
  51         default:
  52                 out_msg = VM_FAULT_SIGBUS;
  53                 break;
  54         }
  55
  56         return out_msg;
  57 }
  58
  59 static int check_gem_flags(unsigned int flags)
  60 {
  61         if (flags & ~(EXYNOS_BO_MASK)) {
  62                 DRM_ERROR("invalid flags.\n");
  63                 return -EINVAL;
  64         }
  65
  66         return 0;
  67 }
  68
  69 static void update_vm_cache_attr(struct exynos_drm_gem_obj *obj,
  70                                         struct vm_area_struct *vma)
  71 {
  72         DRM_DEBUG_KMS("flags = 0x%x\n", obj->flags);
  73
  74         /* non-cachable as default. */
  75         if (obj->flags & EXYNOS_BO_CACHABLE)
  76                 vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
  77         else if (obj->flags & EXYNOS_BO_WC)
  78                 vma->vm_page_prot =
  79                         pgprot_writecombine(vm_get_page_prot(vma->vm_flags));
  80         else
  81                 vma->vm_page_prot =
  82                         pgprot_noncached(vm_get_page_prot(vma->vm_flags));
  83 }
  84
  85 static unsigned long roundup_gem_size(unsigned long size, unsigned int flags)
  86 {
  87         if (!IS_NONCONTIG_BUFFER(flags)) {
  88                 if (size >= SZ_1M)
  89                         return roundup(size, SECTION_SIZE);
  90                 else if (size >= SZ_64K)
  91                         return roundup(size, SZ_64K);
  92                 else
  93                         goto out;
  94         }
  95 out:
  96         return roundup(size, PAGE_SIZE);
  97 }
  98
  99 static struct page **exynos_gem_get_pages(struct drm_gem_object *obj,
 100                                                 gfp_t gfpmask)
 101 {
 102         struct inode *inode;
 103         struct address_space *mapping;
 104         struct page *p, **pages;
 105         int i, npages;
 106
 107         /* This is the shared memory object that backs the GEM resource */
 108         inode = obj->filp->f_path.dentry->d_inode;
 109         mapping = inode->i_mapping;
 110
 111         npages = obj->size >> PAGE_SHIFT;
 112
 113         pages = drm_malloc_ab(npages, sizeof(struct page *));
 114         if (pages == NULL)
 115                 return ERR_PTR(-ENOMEM);
 116
 117         gfpmask |= mapping_gfp_mask(mapping);
 118
 119         for (i = 0; i < npages; i++) {
 120                 p = shmem_read_mapping_page_gfp(mapping, i, gfpmask);
 121                 if (IS_ERR(p))
 122                         goto fail;
 123                 pages[i] = p;
 124         }
 125
 126         return pages;
 127
 128 fail:
 129         while (i--)
 130                 page_cache_release(pages[i]);
 131
 132         drm_free_large(pages);
 133         return ERR_PTR(PTR_ERR(p));
 134 }
 135
 136 static void exynos_gem_put_pages(struct drm_gem_object *obj,
 137                                         struct page **pages,
 138                                         bool dirty, bool accessed)
 139 {
 140         int i, npages;
 141
 142         npages = obj->size >> PAGE_SHIFT;
 143
 144         for (i = 0; i < npages; i++) {
 145                 if (dirty)
 146                         set_page_dirty(pages[i]);
 147
 148                 if (accessed)
 149                         mark_page_accessed(pages[i]);
 150
 151                 /* Undo the reference we took when populating the table */
 152                 page_cache_release(pages[i]);
 153         }
 154
 155         drm_free_large(pages);
 156 }
 157
 158 static int exynos_drm_gem_map_pages(struct drm_gem_object *obj,
 159                                         struct vm_area_struct *vma,
 160                                         unsigned long f_vaddr,
 161                                         pgoff_t page_offset)
 162 {
 163         struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj);
 164         struct exynos_drm_gem_buf *buf = exynos_gem_obj->buffer;
 165         unsigned long pfn;
 166
 167         if (exynos_gem_obj->flags & EXYNOS_BO_NONCONTIG) {
 168                 if (!buf->pages)
 169                         return -EINTR;
 170
 171                 pfn = page_to_pfn(buf->pages[page_offset++]);
 172         } else
 173                 pfn = (buf->dma_addr >> PAGE_SHIFT) + page_offset;
 174
 175         return vm_insert_mixed(vma, f_vaddr, pfn);
 176 }
 177
 178 static int exynos_drm_gem_get_pages(struct drm_gem_object *obj)
 179 {
 180         struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj);
 181         struct exynos_drm_gem_buf *buf = exynos_gem_obj->buffer;
 182         struct scatterlist *sgl;
 183         struct page **pages;
 184         unsigned int npages, i = 0;
 185         int ret;
 186
 187         if (buf->pages) {
 188                 DRM_DEBUG_KMS("already allocated.\n");
 189                 return -EINVAL;
 190         }
 191
 192         pages = exynos_gem_get_pages(obj, GFP_KERNEL);
 193         if (IS_ERR(pages)) {
 194                 DRM_ERROR("failed to get pages.\n");
 195                 return PTR_ERR(pages);
 196         }
 197
 198         npages = obj->size >> PAGE_SHIFT;
 199
 200         buf->sgt = kzalloc(sizeof(struct sg_table), GFP_KERNEL);
 201         if (!buf->sgt) {
 202                 DRM_ERROR("failed to allocate sg table.\n");
 203                 ret = -ENOMEM;
 204                 goto err;
 205         }
 206
 207         ret = sg_alloc_table(buf->sgt, npages, GFP_KERNEL);
 208         if (ret < 0) {
 209                 DRM_ERROR("failed to initialize sg table.\n");
 210                 ret = -EFAULT;
 211                 goto err1;
 212         }
 213
 214         sgl = buf->sgt->sgl;
 215
 216         /* set all pages to sg list. */
 217         while (i < npages) {
 218                 sg_set_page(sgl, pages[i], PAGE_SIZE, 0);
 219                 sg_dma_address(sgl) = page_to_phys(pages[i]);
 220                 i++;
 221                 sgl = sg_next(sgl);
 222         }
 223
 224         /* add some codes for UNCACHED type here. TODO */
 225
 226         buf->pages = pages;
 227         return ret;
 228 err1:
 229         kfree(buf->sgt);
 230         buf->sgt = NULL;
 231 err:
 232         exynos_gem_put_pages(obj, pages, true, false);
 233         return ret;
 234
 235 }
 236
 237 static void exynos_drm_gem_put_pages(struct drm_gem_object *obj)
 238 {
 239         struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj);
 240         struct exynos_drm_gem_buf *buf = exynos_gem_obj->buffer;
 241
 242         /*
 243          * if buffer typs is EXYNOS_BO_NONCONTIG then release all pages
 244          * allocated at gem fault handler.
 245          */
 246         sg_free_table(buf->sgt);
 247         kfree(buf->sgt);
 248         buf->sgt = NULL;
 249
 250         exynos_gem_put_pages(obj, buf->pages, true, false);
 251         buf->pages = NULL;
 252
 253         /* add some codes for UNCACHED type here. TODO */
 254 }
 255
 256 static int exynos_drm_gem_handle_create(struct drm_gem_object *obj,
 257                                         struct drm_file *file_priv,
 258                                         unsigned int *handle)
 259 {
 260         int ret;
 261
 262         /*
 263          * allocate a id of idr table where the obj is registered
 264          * and handle has the id what user can see.
 265          */
 266         ret = drm_gem_handle_create(file_priv, obj, handle);
 267         if (ret)
 268                 return ret;
 269
 270         DRM_DEBUG_KMS("gem handle = 0x%x\n", *handle);
 271
 272         /* drop reference from allocate - handle holds it now. */
 273         drm_gem_object_unreference_unlocked(obj);
 274
 275         return 0;
 276 }
 277
 278 void exynos_drm_gem_destroy(struct exynos_drm_gem_obj *exynos_gem_obj)
 279 {
 280         struct drm_gem_object *obj;
 281         struct exynos_drm_gem_buf *buf;
 282
 283         DRM_DEBUG_KMS("%s\n", __FILE__);
 284
 285         obj = &exynos_gem_obj->base;
 286         buf = exynos_gem_obj->buffer;
 287
 288         DRM_DEBUG_KMS("handle count = %d\n", atomic_read(&obj->handle_count));
 289
 290         if (!buf->pages)
 291                 return;
 292
 293         if (exynos_gem_obj->flags & EXYNOS_BO_NONCONTIG)
 294                 exynos_drm_gem_put_pages(obj);
 295         else
 296                 exynos_drm_free_buf(obj->dev, exynos_gem_obj->flags, buf);
 297
 298         exynos_drm_fini_buf(obj->dev, buf);
 299         exynos_gem_obj->buffer = NULL;
 300
 301         if (obj->map_list.map)
 302                 drm_gem_free_mmap_offset(obj);
 303
 304         /* release file pointer to gem object. */
 305         drm_gem_object_release(obj);
 306
 307         kfree(exynos_gem_obj);
 308         exynos_gem_obj = NULL;
 309 }
 310
 311 static struct exynos_drm_gem_obj *exynos_drm_gem_init(struct drm_device *dev,
 312                                                       unsigned long size)
 313 {
 314         struct exynos_drm_gem_obj *exynos_gem_obj;
 315         struct drm_gem_object *obj;
 316         int ret;
 317
 318         exynos_gem_obj = kzalloc(sizeof(*exynos_gem_obj), GFP_KERNEL);
 319         if (!exynos_gem_obj) {
 320                 DRM_ERROR("failed to allocate exynos gem object\n");
 321                 return NULL;
 322         }
 323
 324         exynos_gem_obj->size = size;
 325         obj = &exynos_gem_obj->base;
 326
 327         ret = drm_gem_object_init(dev, obj, size);
 328         if (ret < 0) {
 329                 DRM_ERROR("failed to initialize gem object\n");
 330                 kfree(exynos_gem_obj);
 331                 return NULL;
 332         }
 333
 334         DRM_DEBUG_KMS("created file object = 0x%x\n", (unsigned int)obj->filp);
 335
 336         return exynos_gem_obj;
 337 }
 338
 339 struct exynos_drm_gem_obj *exynos_drm_gem_create(struct drm_device *dev,
 340                                                 unsigned int flags,
 341                                                 unsigned long size)
 342 {
 343         struct exynos_drm_gem_obj *exynos_gem_obj;
 344         struct exynos_drm_gem_buf *buf;
 345         int ret;
 346
 347         if (!size) {
 348                 DRM_ERROR("invalid size.\n");
 349                 return ERR_PTR(-EINVAL);
 350         }
 351
 352         size = roundup_gem_size(size, flags);
 353         DRM_DEBUG_KMS("%s\n", __FILE__);
 354
 355         ret = check_gem_flags(flags);
 356         if (ret)
 357                 return ERR_PTR(ret);
 358
 359         buf = exynos_drm_init_buf(dev, size);
 360         if (!buf)
 361                 return ERR_PTR(-ENOMEM);
 362
 363         exynos_gem_obj = exynos_drm_gem_init(dev, size);
 364         if (!exynos_gem_obj) {
 365                 ret = -ENOMEM;
 366                 goto err_fini_buf;
 367         }
 368
 369         exynos_gem_obj->buffer = buf;
 370
 371         /* set memory type and cache attribute from user side. */
 372         exynos_gem_obj->flags = flags;
 373
 374         /*
 375          * allocate all pages as desired size if user wants to allocate
 376          * physically non-continuous memory.
 377          */
 378         if (flags & EXYNOS_BO_NONCONTIG) {
 379                 ret = exynos_drm_gem_get_pages(&exynos_gem_obj->base);
 380                 if (ret < 0) {
 381                         drm_gem_object_release(&exynos_gem_obj->base);
 382                         goto err_fini_buf;
 383                 }
 384         } else {
 385                 ret = exynos_drm_alloc_buf(dev, buf, flags);
 386                 if (ret < 0) {
 387                         drm_gem_object_release(&exynos_gem_obj->base);
 388                         goto err_fini_buf;
 389                 }
 390         }
 391
 392         return exynos_gem_obj;
 393
 394 err_fini_buf:
 395         exynos_drm_fini_buf(dev, buf);
 396         return ERR_PTR(ret);
 397 }
 398
 399 int exynos_drm_gem_create_ioctl(struct drm_device *dev, void *data,
 400                                 struct drm_file *file_priv)
 401 {
 402         struct drm_exynos_gem_create *args = data;
 403         struct exynos_drm_gem_obj *exynos_gem_obj;
 404         int ret;
 405
 406         DRM_DEBUG_KMS("%s\n", __FILE__);
 407
 408         exynos_gem_obj = exynos_drm_gem_create(dev, args->flags, args->size);
 409         if (IS_ERR(exynos_gem_obj))
 410                 return PTR_ERR(exynos_gem_obj);
 411
 412         ret = exynos_drm_gem_handle_create(&exynos_gem_obj->base, file_priv,
 413                         &args->handle);
 414         if (ret) {
 415                 exynos_drm_gem_destroy(exynos_gem_obj);
 416                 return ret;
 417         }
 418
 419         return 0;
 420 }
 421
 422 void *exynos_drm_gem_get_dma_addr(struct drm_device *dev,
 423                                         unsigned int gem_handle,
 424                                         struct drm_file *file_priv)
 425 {
 426         struct exynos_drm_gem_obj *exynos_gem_obj;
 427         struct drm_gem_object *obj;
 428
 429         obj = drm_gem_object_lookup(dev, file_priv, gem_handle);
 430         if (!obj) {
 431                 DRM_ERROR("failed to lookup gem object.\n");
 432                 return ERR_PTR(-EINVAL);
 433         }
 434
 435         exynos_gem_obj = to_exynos_gem_obj(obj);
 436
 437         if (exynos_gem_obj->flags & EXYNOS_BO_NONCONTIG) {
 438                 DRM_DEBUG_KMS("not support NONCONTIG type.\n");
 439                 drm_gem_object_unreference_unlocked(obj);
 440
 441                 /* TODO */
 442                 return ERR_PTR(-EINVAL);
 443         }
 444
 445         return &exynos_gem_obj->buffer->dma_addr;
 446 }
 447
 448 void exynos_drm_gem_put_dma_addr(struct drm_device *dev,
 449                                         unsigned int gem_handle,
 450                                         struct drm_file *file_priv)
 451 {
 452         struct exynos_drm_gem_obj *exynos_gem_obj;
 453         struct drm_gem_object *obj;
 454
 455         obj = drm_gem_object_lookup(dev, file_priv, gem_handle);
 456         if (!obj) {
 457                 DRM_ERROR("failed to lookup gem object.\n");
 458                 return;
 459         }
 460
 461         exynos_gem_obj = to_exynos_gem_obj(obj);
 462
 463         if (exynos_gem_obj->flags & EXYNOS_BO_NONCONTIG) {
 464                 DRM_DEBUG_KMS("not support NONCONTIG type.\n");
 465                 drm_gem_object_unreference_unlocked(obj);
 466
 467                 /* TODO */
 468                 return;
 469         }
 470
 471         drm_gem_object_unreference_unlocked(obj);
 472
 473         /*
 474          * decrease obj->refcount one more time because we has already
 475          * increased it at exynos_drm_gem_get_dma_addr().
 476          */
 477         drm_gem_object_unreference_unlocked(obj);
 478 }
 479
 480 int exynos_drm_gem_map_offset_ioctl(struct drm_device *dev, void *data,
 481                                     struct drm_file *file_priv)
 482 {
 483         struct drm_exynos_gem_map_off *args = data;
 484
 485         DRM_DEBUG_KMS("%s\n", __FILE__);
 486
 487         DRM_DEBUG_KMS("handle = 0x%x, offset = 0x%lx\n",
 488                         args->handle, (unsigned long)args->offset);
 489
 490         if (!(dev->driver->driver_features & DRIVER_GEM)) {
 491                 DRM_ERROR("does not support GEM.\n");
 492                 return -ENODEV;
 493         }
 494
 495         return exynos_drm_gem_dumb_map_offset(file_priv, dev, args->handle,
 496                         &args->offset);
 497 }
 498
 499 static int exynos_drm_gem_mmap_buffer(struct file *filp,
 500                                       struct vm_area_struct *vma)
 501 {
 502         struct drm_gem_object *obj = filp->private_data;
 503         struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj);
 504         struct exynos_drm_gem_buf *buffer;
 505         unsigned long pfn, vm_size, usize, uaddr = vma->vm_start;
 506         int ret;
 507
 508         DRM_DEBUG_KMS("%s\n", __FILE__);
 509
 510         vma->vm_flags |= (VM_IO | VM_RESERVED);
 511
 512         update_vm_cache_attr(exynos_gem_obj, vma);
 513
 514         vm_size = usize = vma->vm_end - vma->vm_start;
 515
 516         /*
 517          * a buffer contains information to physically continuous memory
 518          * allocated by user request or at framebuffer creation.
 519          */
 520         buffer = exynos_gem_obj->buffer;
 521
 522         /* check if user-requested size is valid. */
 523         if (vm_size > buffer->size)
 524                 return -EINVAL;
 525
 526         if (exynos_gem_obj->flags & EXYNOS_BO_NONCONTIG) {
 527                 int i = 0;
 528
 529                 if (!buffer->pages)
 530                         return -EINVAL;
 531
 532                 vma->vm_flags |= VM_MIXEDMAP;
 533
 534                 do {
 535                         ret = vm_insert_page(vma, uaddr, buffer->pages[i++]);
 536                         if (ret) {
 537                                 DRM_ERROR("failed to remap user space.\n");
 538                                 return ret;
 539                         }
 540
 541                         uaddr += PAGE_SIZE;
 542                         usize -= PAGE_SIZE;
 543                 } while (usize > 0);
 544         } else {
 545                 /*
 546                  * get page frame number to physical memory to be mapped
 547                  * to user space.
 548                  */
 549                 pfn = ((unsigned long)exynos_gem_obj->buffer->dma_addr) >>
 550                                                                 PAGE_SHIFT;
 551
 552                 DRM_DEBUG_KMS("pfn = 0x%lx\n", pfn);
 553
 554                 if (remap_pfn_range(vma, vma->vm_start, pfn, vm_size,
 555                                         vma->vm_page_prot)) {
 556                         DRM_ERROR("failed to remap pfn range.\n");
 557                         return -EAGAIN;
 558                 }
 559         }
 560
 561         return 0;
 562 }
 563
 564 static const struct file_operations exynos_drm_gem_fops = {
 565         .mmap = exynos_drm_gem_mmap_buffer,
 566 };
 567
 568 int exynos_drm_gem_mmap_ioctl(struct drm_device *dev, void *data,
 569                               struct drm_file *file_priv)
 570 {
 571         struct drm_exynos_gem_mmap *args = data;
 572         struct drm_gem_object *obj;
 573         unsigned int addr;
 574
 575         DRM_DEBUG_KMS("%s\n", __FILE__);
 576
 577         if (!(dev->driver->driver_features & DRIVER_GEM)) {
 578                 DRM_ERROR("does not support GEM.\n");
 579                 return -ENODEV;
 580         }
 581
 582         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
 583         if (!obj) {
 584                 DRM_ERROR("failed to lookup gem object.\n");
 585                 return -EINVAL;
 586         }
 587
 588         obj->filp->f_op = &exynos_drm_gem_fops;
 589         obj->filp->private_data = obj;
 590
 591         addr = vm_mmap(obj->filp, 0, args->size,
 592                         PROT_READ | PROT_WRITE, MAP_SHARED, 0);
 593
 594         drm_gem_object_unreference_unlocked(obj);
 595
 596         if (IS_ERR((void *)addr))
 597                 return PTR_ERR((void *)addr);
 598
 599         args->mapped = addr;
 600
 601         DRM_DEBUG_KMS("mapped = 0x%lx\n", (unsigned long)args->mapped);
 602
 603         return 0;
 604 }
 605
 606 int exynos_drm_gem_init_object(struct drm_gem_object *obj)
 607 {
 608         DRM_DEBUG_KMS("%s\n", __FILE__);
 609
 610         return 0;
 611 }
 612
 613 void exynos_drm_gem_free_object(struct drm_gem_object *obj)
 614 {
 615         DRM_DEBUG_KMS("%s\n", __FILE__);
 616
 617         exynos_drm_gem_destroy(to_exynos_gem_obj(obj));
 618 }
 619
 620 int exynos_drm_gem_dumb_create(struct drm_file *file_priv,
 621                                struct drm_device *dev,
 622                                struct drm_mode_create_dumb *args)
 623 {
 624         struct exynos_drm_gem_obj *exynos_gem_obj;
 625         int ret;
 626
 627         DRM_DEBUG_KMS("%s\n", __FILE__);
 628
 629         /*
 630          * alocate memory to be used for framebuffer.
 631          * - this callback would be called by user application
 632          *      with DRM_IOCTL_MODE_CREATE_DUMB command.
 633          */
 634
 635         args->pitch = args->width * args->bpp >> 3;
 636         args->size = PAGE_ALIGN(args->pitch * args->height);
 637
 638         exynos_gem_obj = exynos_drm_gem_create(dev, args->flags, args->size);
 639         if (IS_ERR(exynos_gem_obj))
 640                 return PTR_ERR(exynos_gem_obj);
 641
 642         ret = exynos_drm_gem_handle_create(&exynos_gem_obj->base, file_priv,
 643                         &args->handle);
 644         if (ret) {
 645                 exynos_drm_gem_destroy(exynos_gem_obj);
 646                 return ret;
 647         }
 648
 649         return 0;
 650 }
 651
 652 int exynos_drm_gem_dumb_map_offset(struct drm_file *file_priv,
 653                                    struct drm_device *dev, uint32_t handle,
 654                                    uint64_t *offset)
 655 {
 656         struct exynos_drm_gem_obj *exynos_gem_obj;
 657         struct drm_gem_object *obj;
 658         int ret = 0;
 659
 660         DRM_DEBUG_KMS("%s\n", __FILE__);
 661
 662         mutex_lock(&dev->struct_mutex);
 663
 664         /*
 665          * get offset of memory allocated for drm framebuffer.
 666          * - this callback would be called by user application
 667          *      with DRM_IOCTL_MODE_MAP_DUMB command.
 668          */
 669
 670         obj = drm_gem_object_lookup(dev, file_priv, handle);
 671         if (!obj) {
 672                 DRM_ERROR("failed to lookup gem object.\n");
 673                 ret = -EINVAL;
 674                 goto unlock;
 675         }
 676
 677         exynos_gem_obj = to_exynos_gem_obj(obj);
 678
 679         if (!exynos_gem_obj->base.map_list.map) {
 680                 ret = drm_gem_create_mmap_offset(&exynos_gem_obj->base);
 681                 if (ret)
 682                         goto out;
 683         }
 684
 685         *offset = (u64)exynos_gem_obj->base.map_list.hash.key << PAGE_SHIFT;
 686         DRM_DEBUG_KMS("offset = 0x%lx\n", (unsigned long)*offset);
 687
 688 out:
 689         drm_gem_object_unreference(obj);
 690 unlock:
 691         mutex_unlock(&dev->struct_mutex);
 692         return ret;
 693 }
 694
 695 int exynos_drm_gem_dumb_destroy(struct drm_file *file_priv,
 696                                 struct drm_device *dev,
 697                                 unsigned int handle)
 698 {
 699         int ret;
 700
 701         DRM_DEBUG_KMS("%s\n", __FILE__);
 702
 703         /*
 704          * obj->refcount and obj->handle_count are decreased and
 705          * if both them are 0 then exynos_drm_gem_free_object()
 706          * would be called by callback to release resources.
 707          */
 708         ret = drm_gem_handle_delete(file_priv, handle);
 709         if (ret < 0) {
 710                 DRM_ERROR("failed to delete drm_gem_handle.\n");
 711                 return ret;
 712         }
 713
 714         return 0;
 715 }
 716
 717 int exynos_drm_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 718 {
 719         struct drm_gem_object *obj = vma->vm_private_data;
 720         struct drm_device *dev = obj->dev;
 721         unsigned long f_vaddr;
 722         pgoff_t page_offset;
 723         int ret;
 724
 725         page_offset = ((unsigned long)vmf->virtual_address -
 726                         vma->vm_start) >> PAGE_SHIFT;
 727         f_vaddr = (unsigned long)vmf->virtual_address;
 728
 729         mutex_lock(&dev->struct_mutex);
 730
 731         ret = exynos_drm_gem_map_pages(obj, vma, f_vaddr, page_offset);
 732         if (ret < 0)
 733                 DRM_ERROR("failed to map pages.\n");
 734
 735         mutex_unlock(&dev->struct_mutex);
 736
 737         return convert_to_vm_err_msg(ret);
 738 }
 739
 740 int exynos_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma)
 741 {
 742         struct exynos_drm_gem_obj *exynos_gem_obj;
 743         struct drm_gem_object *obj;
 744         int ret;
 745
 746         DRM_DEBUG_KMS("%s\n", __FILE__);
 747
 748         /* set vm_area_struct. */
 749         ret = drm_gem_mmap(filp, vma);
 750         if (ret < 0) {
 751                 DRM_ERROR("failed to mmap.\n");
 752                 return ret;
 753         }
 754
 755         obj = vma->vm_private_data;
 756         exynos_gem_obj = to_exynos_gem_obj(obj);
 757
 758         ret = check_gem_flags(exynos_gem_obj->flags);
 759         if (ret) {
 760                 drm_gem_vm_close(vma);
 761                 drm_gem_free_mmap_offset(obj);
 762                 return ret;
 763         }
 764
 765         vma->vm_flags &= ~VM_PFNMAP;
 766         vma->vm_flags |= VM_MIXEDMAP;
 767
 768         update_vm_cache_attr(exynos_gem_obj, vma);
 769
 770         return ret;
 771 }