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