drivers/gpu/drm/sprd/sprd_drm_gem.c

   1 /* sprd_drm_gem.c
   2  *
   3  * Copyright (c) 2014 Spreadtrum Communications, Inc.
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  */
  15
  16 #include "drmP.h"
  17 #include "drm.h"
  18
  19 #include <linux/shmem_fs.h>
  20 #include <drm/sprd_drm.h>
  21 #include <linux/sprd_iommu.h>
  22
  23 #include "video/ion_sprd.h"
  24 #include "sprd_drm_drv.h"
  25 #include "sprd_drm_gem.h"
  26 #include "sprd_drm_buf.h"
  27
  28 static unsigned int convert_to_vm_err_msg(int msg)
  29 {
  30         unsigned int out_msg;
  31
  32         switch (msg) {
  33         case 0:
  34         case -ERESTARTSYS:
  35         case -EINTR:
  36                 out_msg = VM_FAULT_NOPAGE;
  37                 break;
  38
  39         case -ENOMEM:
  40                 out_msg = VM_FAULT_OOM;
  41                 break;
  42
  43         default:
  44                 out_msg = VM_FAULT_SIGBUS;
  45                 break;
  46         }
  47
  48         return out_msg;
  49 }
  50
  51 static int check_gem_flags(unsigned int flags)
  52 {
  53         if (flags & ~(SPRD_BO_MASK | SPRD_BO_DEV_MASK))
  54                 goto err;
  55
  56 #ifdef CONFIG_SPRD_IOMMU
  57         if (IS_NONCONTIG_BUFFER(flags)) {
  58                  if (IS_DEV_OVERLAY_BUFFER(flags))
  59                         goto err;
  60         } else {
  61                  if (IS_DEV_SYSTEM_BUFFER(flags))
  62                         goto err;
  63         }
  64 #endif
  65
  66         return 0;
  67 err:
  68         DRM_ERROR("invalid flags[0x%x]\n", flags);
  69         return -EINVAL;
  70 }
  71
  72 static void update_vm_cache_attr(struct sprd_drm_gem_obj *obj,
  73                                         struct vm_area_struct *vma)
  74 {
  75         DRM_DEBUG_KMS("flags = 0x%x\n", obj->flags);
  76
  77         /* non-cachable as default. */
  78         if (obj->flags & SPRD_BO_CACHABLE)
  79                 vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
  80         else if (obj->flags & SPRD_BO_WC)
  81                 vma->vm_page_prot =
  82                         pgprot_writecombine(vm_get_page_prot(vma->vm_flags));
  83         else
  84                 vma->vm_page_prot =
  85                         pgprot_noncached(vm_get_page_prot(vma->vm_flags));
  86 }
  87
  88 static unsigned long roundup_gem_size(unsigned long size, unsigned int flags)
  89 {
  90         if (!IS_NONCONTIG_BUFFER(flags)) {
  91 #ifndef CONFIG_CMA_ALIGNMENT
  92                 if (size >= SZ_1M)
  93                         return roundup(size, SECTION_SIZE);
  94 #endif
  95                 /* ToDo: need to sync with additional align size */
  96                 if (size >= SZ_64K)
  97                         return roundup(size, SZ_64K);
  98                 else
  99                         goto out;
 100         }
 101 out:
 102         return roundup(size, PAGE_SIZE);
 103 }
 104
 105 struct page **sprd_gem_get_pages(struct drm_gem_object *obj,
 106                                                 gfp_t gfpmask)
 107 {
 108         struct inode *inode;
 109         struct address_space *mapping;
 110         struct page *p, **pages;
 111         int i, npages;
 112
 113         /* This is the shared memory object that backs the GEM resource */
 114         inode = obj->filp->f_path.dentry->d_inode;
 115         mapping = inode->i_mapping;
 116
 117         npages = obj->size >> PAGE_SHIFT;
 118
 119         pages = drm_malloc_ab(npages, sizeof(struct page *));
 120         if (pages == NULL)
 121                 return ERR_PTR(-ENOMEM);
 122
 123         gfpmask |= mapping_gfp_mask(mapping);
 124
 125         for (i = 0; i < npages; i++) {
 126                 p = shmem_read_mapping_page_gfp(mapping, i, gfpmask);
 127                 if (IS_ERR(p))
 128                         goto fail;
 129                 pages[i] = p;
 130         }
 131
 132         return pages;
 133
 134 fail:
 135         while (i--)
 136                 page_cache_release(pages[i]);
 137
 138         drm_free_large(pages);
 139         return ERR_PTR(PTR_ERR(p));
 140 }
 141
 142 static void sprd_gem_put_pages(struct drm_gem_object *obj,
 143                                         struct page **pages,
 144                                         bool dirty, bool accessed)
 145 {
 146         int i, npages;
 147
 148         npages = obj->size >> PAGE_SHIFT;
 149
 150         for (i = 0; i < npages; i++) {
 151                 if (dirty)
 152                         set_page_dirty(pages[i]);
 153
 154                 if (accessed)
 155                         mark_page_accessed(pages[i]);
 156
 157                 /* Undo the reference we took when populating the table */
 158                 page_cache_release(pages[i]);
 159         }
 160
 161         drm_free_large(pages);
 162 }
 163
 164 static int sprd_drm_gem_map_pages(struct drm_gem_object *obj,
 165                                         struct vm_area_struct *vma,
 166                                         unsigned long f_vaddr,
 167                                         pgoff_t page_offset)
 168 {
 169         struct sprd_drm_gem_obj *sprd_gem_obj = to_sprd_gem_obj(obj);
 170         struct sprd_drm_gem_buf *buf = sprd_gem_obj->buffer;
 171         unsigned long pfn;
 172
 173         if (sprd_gem_obj->flags & SPRD_BO_NONCONTIG) {
 174                 if (!buf->pages)
 175                         return -EINTR;
 176
 177                 pfn = page_to_pfn(buf->pages[page_offset++]);
 178         } else
 179                 pfn = (buf->dma_addr >> PAGE_SHIFT) + page_offset;
 180
 181         return vm_insert_mixed(vma, f_vaddr, pfn);
 182 }
 183
 184 static int sprd_drm_gem_get_pages(struct drm_gem_object *obj)
 185 {
 186         struct sprd_drm_gem_obj *sprd_gem_obj = to_sprd_gem_obj(obj);
 187         struct sprd_drm_gem_buf *buf = sprd_gem_obj->buffer;
 188         struct scatterlist *sgl;
 189         struct page **pages;
 190         unsigned int npages, i = 0;
 191         int ret;
 192
 193         if (buf->pages) {
 194                 DRM_DEBUG_KMS("already allocated.\n");
 195                 return -EINVAL;
 196         }
 197
 198         pages = sprd_gem_get_pages(obj, GFP_KERNEL);
 199         if (IS_ERR(pages)) {
 200                 DRM_ERROR("failed to get pages.\n");
 201                 return PTR_ERR(pages);
 202         }
 203
 204         npages = obj->size >> PAGE_SHIFT;
 205         buf->page_size = PAGE_SIZE;
 206
 207         buf->sgt = kzalloc(sizeof(struct sg_table), GFP_KERNEL);
 208         if (!buf->sgt) {
 209                 DRM_ERROR("failed to allocate sg table.\n");
 210                 ret = -ENOMEM;
 211                 goto err;
 212         }
 213
 214         ret = sg_alloc_table(buf->sgt, npages, GFP_KERNEL);
 215         if (ret < 0) {
 216                 DRM_ERROR("failed to initialize sg table.\n");
 217                 ret = -EFAULT;
 218                 goto err1;
 219         }
 220
 221         sgl = buf->sgt->sgl;
 222
 223         /* set all pages to sg list. */
 224         while (i < npages) {
 225                 sg_set_page(sgl, pages[i], PAGE_SIZE, 0);
 226                 sg_dma_address(sgl) = page_to_phys(pages[i]);
 227                 i++;
 228                 sgl = sg_next(sgl);
 229         }
 230
 231         /* add some codes for UNCACHED type here. TODO */
 232
 233         buf->pages = pages;
 234         return ret;
 235 err1:
 236         kfree(buf->sgt);
 237         buf->sgt = NULL;
 238 err:
 239         sprd_gem_put_pages(obj, pages, true, false);
 240         return ret;
 241
 242 }
 243
 244 static void sprd_drm_gem_put_pages(struct drm_gem_object *obj)
 245 {
 246         struct sprd_drm_gem_obj *sprd_gem_obj = to_sprd_gem_obj(obj);
 247         struct sprd_drm_gem_buf *buf = sprd_gem_obj->buffer;
 248
 249         /*
 250          * if buffer typs is SPRD_BO_NONCONTIG then release all pages
 251          * allocated at gem fault handler.
 252          */
 253         sg_free_table(buf->sgt);
 254         kfree(buf->sgt);
 255         buf->sgt = NULL;
 256
 257         sprd_gem_put_pages(obj, buf->pages, true, false);
 258         buf->pages = NULL;
 259
 260         /* add some codes for UNCACHED type here. TODO */
 261 }
 262
 263 static int sprd_drm_gem_handle_create(struct drm_gem_object *obj,
 264                                         struct drm_file *file_priv,
 265                                         unsigned int *handle)
 266 {
 267         int ret;
 268
 269         /*
 270          * allocate a id of idr table where the obj is registered
 271          * and handle has the id what user can see.
 272          */
 273         ret = drm_gem_handle_create(file_priv, obj, handle);
 274         if (ret)
 275                 return ret;
 276
 277         DRM_DEBUG_KMS("gem handle = 0x%x\n", *handle);
 278
 279         /* drop reference from allocate - handle holds it now. */
 280         drm_gem_object_unreference_unlocked(obj);
 281
 282         return 0;
 283 }
 284
 285 void sprd_drm_gem_destroy(struct sprd_drm_gem_obj *sprd_gem_obj)
 286 {
 287         struct drm_gem_object *obj;
 288         struct sprd_drm_gem_buf *buf;
 289
 290         obj = &sprd_gem_obj->base;
 291         buf = sprd_gem_obj->buffer;
 292
 293         if (!buf->pages)
 294                 return;
 295
 296         DRM_DEBUG("%s:o[0x%x]a[0x%x]\n", "gf",
 297                 (int)obj, (int)sprd_gem_obj->buffer->dma_addr);
 298
 299         sprd_drm_free_buf(obj->dev, sprd_gem_obj->flags, buf);
 300
 301         sprd_drm_fini_buf(obj->dev, buf);
 302         sprd_gem_obj->buffer = NULL;
 303
 304         if (obj->map_list.map)
 305                 drm_gem_free_mmap_offset(obj);
 306
 307         /* release file pointer to gem object. */
 308         drm_gem_object_release(obj);
 309
 310         kfree(sprd_gem_obj);
 311         sprd_gem_obj = NULL;
 312 }
 313
 314 struct sprd_drm_gem_obj *sprd_drm_gem_init(struct drm_device *dev,
 315                                                       unsigned long size)
 316 {
 317         struct sprd_drm_gem_obj *sprd_gem_obj;
 318         struct drm_gem_object *obj;
 319         int ret;
 320
 321         sprd_gem_obj = kzalloc(sizeof(*sprd_gem_obj), GFP_KERNEL);
 322         if (!sprd_gem_obj) {
 323                 DRM_ERROR("failed to allocate sprd gem object\n");
 324                 return NULL;
 325         }
 326
 327         sprd_gem_obj->size = size;
 328         obj = &sprd_gem_obj->base;
 329
 330         ret = drm_gem_object_init(dev, obj, size);
 331         if (ret < 0) {
 332                 DRM_ERROR("failed to initialize gem object\n");
 333                 kfree(sprd_gem_obj);
 334                 return NULL;
 335         }
 336
 337         sprd_gem_obj->pid = task_pid_nr(current);
 338         sprd_gem_obj->tgid = task_tgid_nr(current);
 339
 340         DRM_DEBUG_KMS("created file object = 0x%x\n", (unsigned int)obj->filp);
 341
 342         return sprd_gem_obj;
 343 }
 344
 345 struct sprd_drm_gem_obj *sprd_drm_gem_create(struct drm_device *dev,
 346                                                 struct sprd_drm_gem_index *args)
 347 {
 348         struct sprd_drm_gem_obj *sprd_gem_obj;
 349         struct sprd_drm_gem_buf *buf;
 350         int ret, i=0, j, tsize = 0;
 351
 352         ret = check_gem_flags(args->flags);
 353         if (ret)
 354                 return ERR_PTR(ret);
 355
 356         /* ToDo: need to check align */
 357         for (i = 0; i < args->bufcount; i++)
 358                 tsize += args->idx_size[i];
 359
 360         if (!tsize) {
 361                 DRM_ERROR("invalid size.\n");
 362                 return ERR_PTR(-EINVAL);
 363         }
 364
 365         tsize = roundup_gem_size(tsize, args->flags);
 366
 367         buf = sprd_drm_init_buf(dev, tsize);
 368         if (!buf)
 369                 return ERR_PTR(-ENOMEM);
 370
 371         sprd_gem_obj = sprd_drm_gem_init(dev, tsize);
 372         if (!sprd_gem_obj) {
 373                 ret = -ENOMEM;
 374                 goto err_fini_buf;
 375         }
 376
 377         sprd_gem_obj->buffer = buf;
 378
 379         /* set memory type and cache attribute from user side. */
 380         sprd_gem_obj->flags = args->flags;
 381
 382         buf->obj = &sprd_gem_obj->base;
 383
 384         ret = sprd_drm_alloc_buf(dev, buf, args->flags);
 385         if (ret < 0)
 386                 goto err_gem_fini;
 387
 388         memset(buf->idx_addr, 0x00, sizeof(buf->idx_addr));
 389         buf->idx_addr[0] = buf->dma_addr;
 390         buf->bufcount = args->bufcount;
 391
 392         for (i = 0; i < buf->bufcount; i++) {
 393                 j = i + 1;
 394                 if (buf->bufcount > j)
 395                         buf->idx_addr[j] = buf->idx_addr[i] + args->idx_size[i];
 396         }
 397
 398         sprd_gem_obj->lockpid=0;
 399         INIT_LIST_HEAD(&sprd_gem_obj->wait_list);
 400
 401         for (i = 0; i < DRM_SPRD_HANDLE_WAIT_ENTRIES; i++) {
 402                 INIT_LIST_HEAD((struct list_head *) &sprd_gem_obj->wait_entries[i]);
 403                 sprd_gem_obj->wait_entries[i].pid = 0;
 404                 init_waitqueue_head(&sprd_gem_obj->wait_entries[i].process_wait_q);
 405         }
 406
 407         return sprd_gem_obj;
 408
 409 err_gem_fini:
 410         drm_gem_object_release(&sprd_gem_obj->base);
 411         kfree(sprd_gem_obj);
 412 err_fini_buf:
 413         sprd_drm_fini_buf(dev, buf);
 414         return ERR_PTR(ret);
 415 }
 416
 417 int sprd_drm_gem_create_ioctl(struct drm_device *dev, void *data,
 418                                 struct drm_file *file_priv)
 419 {
 420         struct drm_sprd_gem_create *args = data;
 421         struct sprd_drm_gem_obj *sprd_gem_obj;
 422         struct sprd_drm_gem_index gem_idx;
 423         struct timeval val_start, val_end;
 424         uint64_t time_start, time_end;
 425         int ret;
 426
 427         do_gettimeofday(&val_start);
 428         time_start = (uint64_t)(val_start.tv_sec * 1000000 + val_start.tv_usec);
 429
 430         gem_idx.bufcount= 1;
 431         gem_idx.idx_size[0] = args->size;
 432         gem_idx.flags = args->flags;
 433
 434         sprd_gem_obj = sprd_drm_gem_create(dev, &gem_idx);
 435         if (IS_ERR(sprd_gem_obj)) {
 436                 DRM_ERROR("failed to sprd_drm_gem_create:s[%d]f[0x%x]\n",
 437                         (int)args->size, args->flags);
 438                 return PTR_ERR(sprd_gem_obj);
 439         }
 440
 441         ret = sprd_drm_gem_handle_create(&sprd_gem_obj->base, file_priv,
 442                         &args->handle);
 443         if (ret) {
 444                 DRM_ERROR("failed to sprd_drm_gem_handle_create:s[%d]f[0x%x]\n",
 445                         (int)args->size, args->flags);
 446                 sprd_drm_gem_destroy(sprd_gem_obj);
 447                 return ret;
 448         }
 449
 450         do_gettimeofday(&val_end);
 451         time_end = (uint64_t)(val_end.tv_sec * 1000000 + val_end.tv_usec);
 452
 453         DRM_DEBUG("%s:h[%d]s[%d]f[0x%x]o[0x%x]a[0x%x][%lld us]\n",
 454                 "ga",args->handle, (int)args->size, args->flags,
 455                 (int)&sprd_gem_obj->base,
 456                 (int)sprd_gem_obj->buffer->dma_addr, time_end - time_start);
 457
 458         return 0;
 459 }
 460
 461 int sprd_drm_gem_create_index_ioctl(struct drm_device *dev, void *data,
 462                                 struct drm_file *file_priv)
 463 {
 464         struct sprd_drm_gem_index *args = data;
 465         struct sprd_drm_gem_obj *sprd_gem_obj;
 466         int ret;
 467
 468         if (args->flags & SPRD_BO_NONCONTIG) {
 469                 DRM_ERROR("does not support non-contig memory\n");
 470                 return -EINVAL;
 471         }
 472
 473         sprd_gem_obj = sprd_drm_gem_create(dev, args);
 474         if (IS_ERR(sprd_gem_obj))
 475                 return PTR_ERR(sprd_gem_obj);
 476
 477         ret = sprd_drm_gem_handle_create(&sprd_gem_obj->base, file_priv,
 478                         &args->handle);
 479         if (ret) {
 480                 sprd_drm_gem_destroy(sprd_gem_obj);
 481                 return ret;
 482         }
 483
 484         DRM_INFO("%s:h[%d]cnt[%d]sz[%d %d %d]f[0x%x]o[0x%x]a[0x%x]\n",
 485                 __func__,args->handle, args->bufcount,
 486                 (int)args->idx_size[0], (int)args->idx_size[1], (int)args->idx_size[2],
 487                 args->flags, (int)&sprd_gem_obj->base,
 488                 (int)sprd_gem_obj->buffer->dma_addr);
 489
 490         return 0;
 491 }
 492
 493 struct dma_buf *sprd_prime_export(struct drm_device *dev,
 494                                   struct drm_gem_object *obj, int flags)
 495 {
 496         struct sprd_drm_private *private = dev->dev_private;
 497         struct sprd_drm_gem_obj *sprd_gem_obj = to_sprd_gem_obj(obj);
 498         struct sprd_drm_gem_buf *buf = sprd_gem_obj->buffer;
 499         struct dma_buf *dmabuf;
 500
 501         dmabuf = ion_share_dma_buf(private->sprd_drm_ion_client,
 502                                    buf->ion_handle);
 503         if (IS_ERR(dmabuf))
 504                 pr_err("%s: dmabuf is error and dmabuf is %p!\n",
 505                                 __func__, dmabuf);
 506
 507         return dmabuf;
 508 }
 509
 510 struct drm_gem_object *sprd_prime_import(struct drm_device *dev,
 511                                          struct dma_buf *dma_buf)
 512 {
 513         struct ion_handle *ion_handle;
 514         struct sprd_drm_gem_obj *sprd_gem_obj;
 515         unsigned long size;
 516         struct sprd_drm_gem_buf *buf = NULL;
 517         unsigned int i = 0, nr_pages = 0, heap_id;
 518         int ret = 0;
 519         struct sprd_drm_private *private;
 520         struct scatterlist *sg = NULL;
 521         struct drm_gem_object *obj;
 522         unsigned long sgt_size;
 523
 524         private = dev->dev_private;
 525         ion_handle = get_ion_handle_from_dmabuf(private->sprd_drm_ion_client, dma_buf);
 526         if (IS_ERR_OR_NULL(ion_handle)) {
 527                 DRM_ERROR("Unable to import dmabuf\n");
 528                 return ERR_PTR(-EINVAL);
 529         }
 530
 531         ion_handle_get_size(private->sprd_drm_ion_client,
 532                                         ion_handle, &size, &heap_id);
 533         if (size == 0) {
 534                 DRM_ERROR(
 535                         "cannot create GEM object from zero size ION buffer\n");
 536                 ret = -EINVAL;
 537                 goto err;
 538         }
 539
 540         obj = ion_get_gem(ion_handle);
 541         if (obj) {
 542                 sprd_gem_obj = to_sprd_gem_obj(obj);
 543                 if (sprd_gem_obj->buffer->ion_handle != ion_handle) {
 544                         DRM_ERROR("Unable get GEM object from ion\n");
 545                         ret = -EINVAL;
 546                         goto err;
 547                 }
 548
 549                 drm_gem_object_reference(obj);
 550                 ion_free(private->sprd_drm_ion_client, ion_handle);
 551
 552                 return obj;
 553         }
 554
 555         buf = sprd_drm_init_buf(dev, size);
 556         if (!buf) {
 557                 DRM_ERROR("Unable to allocate the GEM buffer\n");
 558                 ret = -ENOMEM;
 559                 goto err;
 560         }
 561
 562         sprd_gem_obj = sprd_drm_gem_init(dev, size);
 563         if (!sprd_gem_obj) {
 564                 DRM_ERROR("Unable to initialize GEM object\n");
 565                 ret = -ENOMEM;
 566                 goto err_fini_buf;
 567         }
 568         sprd_gem_obj->buffer = buf;
 569         obj = &sprd_gem_obj->base;
 570
 571         ret = ion_is_phys(private->sprd_drm_ion_client, ion_handle);
 572         if (ret == -1)
 573                 sprd_gem_obj->flags = SPRD_BO_NONCONTIG;
 574         else if (ret == 0)
 575                 sprd_gem_obj->flags = SPRD_BO_CONTIG;
 576         else {
 577                 DRM_ERROR("Unable to get flag, Invalid handle\n");
 578                 goto err_gem_obj;
 579         }
 580
 581         /* ion_handle is validated in ion_is_phys, no need to check again */
 582         ret = ion_is_cached(private->sprd_drm_ion_client, ion_handle);
 583         if (ret)
 584                 sprd_gem_obj->flags |= SPRD_BO_CACHABLE;
 585
 586         if ((heap_id == ION_HEAP_ID_MASK_GSP) || (heap_id == ION_HEAP_ID_MASK_GSP_IOMMU))
 587                 sprd_gem_obj->flags |= SPRD_BO_DEV_GSP;
 588         else if ((heap_id == ION_HEAP_ID_MASK_MM) || (heap_id == ION_HEAP_ID_MASK_MM_IOMMU))
 589                 sprd_gem_obj->flags |= SPRD_BO_DEV_MM;
 590         else if (heap_id == ION_HEAP_ID_MASK_OVERLAY)
 591                 sprd_gem_obj->flags |= SPRD_BO_DEV_OVERLAY;
 592         else if (heap_id == ION_HEAP_ID_MASK_SYSTEM)
 593                 sprd_gem_obj->flags |= SPRD_BO_DEV_SYSTEM;
 594         else {
 595                 DRM_ERROR("Heap id not supported\n");
 596                 ret = -ENOMEM;
 597                 goto err_gem_obj;
 598         }
 599
 600         buf->ion_handle = ion_handle;
 601         buf->sgt = ion_sg_table(private->sprd_drm_ion_client, buf->ion_handle);
 602         if (!buf->sgt) {
 603                 DRM_ERROR("failed to allocate sg table.\n");
 604                 ret = -EINVAL;
 605                 goto err_gem_obj;
 606         }
 607
 608         buf->dma_addr = sg_dma_address(buf->sgt->sgl);
 609         for_each_sg(buf->sgt->sgl, sg, buf->sgt->nents, i)
 610                 nr_pages++;
 611
 612         sgt_size = sizeof(struct page) * nr_pages;
 613         buf->pages = kzalloc(sgt_size, GFP_KERNEL | __GFP_NOWARN);
 614         if (!buf->pages) {
 615                 unsigned int order;
 616                 order = get_order(sgt_size);
 617                 DRM_ERROR("%s: kzalloc failed for sg list: order:%d\n",
 618                                         __func__, order);
 619                 buf->pages = vzalloc(sgt_size);
 620                 if (!buf->pages) {
 621                         DRM_ERROR("failed to allocate pages.\n");
 622                         ret = -ENOMEM;
 623                         goto err_buf;
 624                 }
 625         }
 626
 627         for_each_sg(buf->sgt->sgl, sg, buf->sgt->nents, i)
 628                 buf->pages[i] = phys_to_page(sg_dma_address(sg));
 629
 630         DRM_DEBUG_KMS("dma_addr(0x%lx), size(0x%lx)\n",
 631                 (unsigned long)buf->dma_addr, buf->size);
 632
 633         return obj;
 634
 635 err_buf:
 636         buf->dma_addr = (dma_addr_t)NULL;
 637         buf->sgt = NULL;
 638 err_gem_obj:
 639         sprd_gem_obj->buffer = NULL;
 640         /* release file pointer to gem object. */
 641         drm_gem_object_release(obj);
 642         kfree(sprd_gem_obj);
 643         sprd_gem_obj = NULL;
 644 err_fini_buf:
 645         sprd_drm_fini_buf(dev, buf);
 646 err:
 647         ion_free(private->sprd_drm_ion_client, ion_handle);
 648
 649         return ERR_PTR(ret);
 650 }
 651
 652 void *sprd_drm_gem_get_dma_addr(struct drm_device *dev,
 653                                         unsigned int gem_handle,
 654                                         struct drm_file *file_priv)
 655 {
 656         struct sprd_drm_gem_obj *sprd_gem_obj;
 657         struct drm_gem_object *obj;
 658         struct ion_handle *ion_handle;
 659         struct sprd_drm_gem_buf *buf;
 660         int domain_num = 0;
 661
 662         obj = drm_gem_object_lookup(dev, file_priv, gem_handle);
 663         if (!obj) {
 664                 DRM_ERROR("failed to lookup gem object:h[%d]\n", gem_handle);
 665                 return ERR_PTR(-EINVAL);
 666         }
 667
 668         sprd_gem_obj = to_sprd_gem_obj(obj);
 669
 670         if (sprd_gem_obj->flags & SPRD_BO_NONCONTIG) {
 671                 buf = sprd_gem_obj->buffer;
 672                 if (IS_DEV_MM_BUFFER(sprd_gem_obj->flags))
 673                         domain_num = IOMMU_MM;
 674                 else if (IS_DEV_GSP_BUFFER(sprd_gem_obj->flags))
 675                         domain_num = IOMMU_GSP;
 676
 677                 ion_handle = buf->ion_handle;
 678                 if (sprd_map_iommu(ion_handle, domain_num,
 679                                 (unsigned long *)&sprd_gem_obj->buffer->dma_addr)) {
 680                         DRM_ERROR("failed to map iommu:h[%d]o[0x%x]\n",
 681                                 gem_handle, (int)obj);
 682                         drm_gem_object_unreference_unlocked(obj);
 683                         return ERR_PTR(-EINVAL);
 684                 }
 685         }
 686
 687         DRM_DEBUG("%s:h[%d]o[0x%x]a[0x%x]\n",
 688                 __func__,gem_handle, (int)obj,
 689                 (int)sprd_gem_obj->buffer->dma_addr);
 690
 691         return &sprd_gem_obj->buffer->dma_addr;
 692 }
 693
 694 void sprd_drm_gem_put_dma_addr(struct drm_device *dev,
 695                                         unsigned int gem_handle,
 696                                         struct drm_file *file_priv)
 697 {
 698         struct sprd_drm_gem_obj *sprd_gem_obj;
 699         struct drm_gem_object *obj;
 700         struct ion_handle *ion_handle;
 701         struct sprd_drm_gem_buf *buf;
 702         int domain_num = 0;
 703
 704         obj = drm_gem_object_lookup(dev, file_priv, gem_handle);
 705         if (!obj) {
 706                 DRM_ERROR("failed to lookup gem object:h[%d]\n", gem_handle);
 707                 return;
 708         }
 709
 710         sprd_gem_obj = to_sprd_gem_obj(obj);
 711
 712         if (sprd_gem_obj->flags & SPRD_BO_NONCONTIG) {
 713                 buf = sprd_gem_obj->buffer;
 714                 if (IS_DEV_MM_BUFFER(sprd_gem_obj->flags))
 715                         domain_num = IOMMU_MM;
 716                 else if (IS_DEV_GSP_BUFFER(sprd_gem_obj->flags))
 717                         domain_num = IOMMU_GSP;
 718
 719                 ion_handle = buf->ion_handle;
 720                 if (sprd_unmap_iommu(ion_handle, domain_num))
 721                         DRM_ERROR("failed to unmap iommu:h[%d]o[0x%x]\n",
 722                                 gem_handle, (int)obj);
 723         }
 724
 725         drm_gem_object_unreference_unlocked(obj);
 726
 727         DRM_DEBUG("%s:h[%d]o[0x%x]\n",
 728                 __func__,gem_handle, (int)obj);
 729         /*
 730          * decrease obj->refcount one more time because we has already
 731          * increased it at sprd_drm_gem_get_dma_addr().
 732          */
 733         drm_gem_object_unreference_unlocked(obj);
 734 }
 735
 736 unsigned long sprd_drm_gem_get_size(struct drm_device *dev,
 737                                                 unsigned int gem_handle,
 738                                                 struct drm_file *file_priv)
 739 {
 740         struct sprd_drm_gem_obj *sprd_gem_obj;
 741         struct drm_gem_object *obj;
 742
 743         obj = drm_gem_object_lookup(dev, file_priv, gem_handle);
 744         if (!obj) {
 745                 DRM_ERROR("failed to lookup gem object:h[%d]\n", gem_handle);
 746                 return 0;
 747         }
 748
 749         sprd_gem_obj = to_sprd_gem_obj(obj);
 750
 751         drm_gem_object_unreference_unlocked(obj);
 752
 753         return sprd_gem_obj->buffer->size;
 754 }
 755
 756 void *sprd_drm_gem_get_obj_addr(unsigned int name, unsigned int index)
 757 {
 758         struct sprd_drm_gem_obj *sprd_gem_obj;
 759         struct drm_gem_object *obj;
 760         struct ion_handle *ion_handle;
 761         struct sprd_drm_gem_buf *buf;
 762         int domain_num = 0;
 763
 764         mutex_lock(&sprd_drm_dev->object_name_lock);
 765         obj = idr_find(&sprd_drm_dev->object_name_idr, (int) name);
 766         mutex_unlock(&sprd_drm_dev->object_name_lock);
 767
 768         if (!obj) {
 769                 DRM_ERROR("name[%d]failed to lookup gem object.\n", name);
 770                 return ERR_PTR(-EFAULT);
 771         }
 772
 773         sprd_gem_obj = to_sprd_gem_obj(obj);
 774         buf = sprd_gem_obj->buffer;
 775
 776         if (index >= buf->bufcount) {
 777                 DRM_ERROR("invalid index[%d],bufcount[%d]\n",
 778                         index, buf->bufcount);
 779                 return ERR_PTR(-EINVAL);
 780         }
 781
 782         if (sprd_gem_obj->flags & SPRD_BO_NONCONTIG) {
 783                 if (IS_DEV_MM_BUFFER(sprd_gem_obj->flags))
 784                         domain_num = IOMMU_MM;
 785                 else if (IS_DEV_GSP_BUFFER(sprd_gem_obj->flags))
 786                         domain_num = IOMMU_GSP;
 787
 788                 ion_handle = buf->ion_handle;
 789                 if (sprd_map_iommu(ion_handle, domain_num,
 790                                 (unsigned long *)&sprd_gem_obj->buffer->dma_addr)) {
 791                         DRM_ERROR("failed to map iommu\n");
 792                         return ERR_PTR(-EINVAL);
 793                 }
 794         }
 795
 796         DRM_DEBUG("%s:name[%d]o[0x%x]idx[%d]a[0x%x]\n",
 797                 __func__, name, (int)obj, index, (int)buf->idx_addr[index]);
 798
 799         return &buf->idx_addr[index];
 800 }
 801 EXPORT_SYMBOL(sprd_drm_gem_get_obj_addr);
 802
 803 int sprd_drm_gem_map_offset_ioctl(struct drm_device *dev, void *data,
 804                                     struct drm_file *file_priv)
 805 {
 806         struct drm_sprd_gem_map_off *args = data;
 807
 808         DRM_DEBUG_KMS("handle = 0x%x, offset = 0x%lx\n",
 809                         args->handle, (unsigned long)args->offset);
 810
 811         if (!(dev->driver->driver_features & DRIVER_GEM)) {
 812                 DRM_ERROR("does not support GEM.\n");
 813                 return -ENODEV;
 814         }
 815
 816         return sprd_drm_gem_dumb_map_offset(file_priv, dev, args->handle,
 817                         &args->offset);
 818 }
 819
 820 static int sprd_drm_gem_mmap_buffer(struct file *filp,
 821                                       struct vm_area_struct *vma)
 822 {
 823         struct drm_gem_object *obj = filp->private_data;
 824         struct sprd_drm_gem_obj *sprd_gem_obj = to_sprd_gem_obj(obj);
 825         struct sprd_drm_gem_buf *buffer;
 826         unsigned long pfn, vm_size;
 827
 828         vma->vm_flags |= (VM_IO | VM_DONTEXPAND | VM_DONTDUMP);
 829
 830         update_vm_cache_attr(sprd_gem_obj, vma);
 831
 832         vm_size = vma->vm_end - vma->vm_start;
 833
 834         /*
 835          * a buffer contains information to physically continuous memory
 836          * allocated by user request or at framebuffer creation.
 837          */
 838         buffer = sprd_gem_obj->buffer;
 839
 840         /* check if user-requested size is valid. */
 841         if (vm_size > buffer->size)
 842                 return -EINVAL;
 843
 844         if (sprd_gem_obj->flags & SPRD_BO_NONCONTIG) {
 845                 unsigned long addr = vma->vm_start;
 846                 unsigned long offset = vma->vm_pgoff * PAGE_SIZE;
 847                 struct scatterlist *sg;
 848                 int i;
 849
 850                 for_each_sg(buffer->sgt->sgl, sg, buffer->sgt->nents, i) {
 851                         struct page *page = sg_page(sg);
 852                         unsigned long remainder = vma->vm_end - addr;
 853                         unsigned long len = sg_dma_len(sg);
 854
 855                         if (offset >= sg_dma_len(sg)) {
 856                                 offset -= sg_dma_len(sg);
 857                                 continue;
 858                         } else if (offset) {
 859                                 page += offset / PAGE_SIZE;
 860                                 len = sg_dma_len(sg) - offset;
 861                                 offset = 0;
 862                         }
 863                         len = min(len, remainder);
 864                         remap_pfn_range(vma, addr, page_to_pfn(page), len,
 865                                         vma->vm_page_prot);
 866                         addr += len;
 867                         if (addr >= vma->vm_end) {
 868                                 break;
 869                         }
 870                 }
 871         } else {
 872                 /*
 873                  * get page frame number to physical memory to be mapped
 874                  * to user space.
 875                  */
 876                 pfn = ((unsigned long)sprd_gem_obj->buffer->dma_addr) >>
 877                                                                 PAGE_SHIFT;
 878
 879                 DRM_DEBUG_KMS("pfn = 0x%lx\n", pfn);
 880
 881                 if (remap_pfn_range(vma, vma->vm_start, pfn, vm_size,
 882                                         vma->vm_page_prot)) {
 883                         DRM_ERROR("failed to remap pfn range.\n");
 884                         return -EAGAIN;
 885                 }
 886         }
 887
 888         return 0;
 889 }
 890
 891 static const struct file_operations sprd_drm_gem_fops = {
 892         .mmap = sprd_drm_gem_mmap_buffer,
 893 };
 894
 895 int sprd_drm_gem_mmap_ioctl(struct drm_device *dev, void *data,
 896                               struct drm_file *file_priv)
 897 {
 898         struct drm_sprd_gem_mmap *args = data;
 899         struct drm_gem_object *obj;
 900         unsigned long addr;
 901
 902         if (!(dev->driver->driver_features & DRIVER_GEM)) {
 903                 DRM_ERROR("does not support GEM.\n");
 904                 return -ENODEV;
 905         }
 906
 907         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
 908         if (!obj) {
 909                 DRM_ERROR("failed to lookup gem object:h[%d]\n", args->handle);
 910                 return -EINVAL;
 911         }
 912
 913         obj->filp->f_op = &sprd_drm_gem_fops;
 914         obj->filp->private_data = obj;
 915
 916         addr = vm_mmap(obj->filp, 0, args->size,
 917                         PROT_READ | PROT_WRITE, MAP_SHARED, 0);
 918
 919         drm_gem_object_unreference_unlocked(obj);
 920
 921         if (IS_ERR_VALUE(addr))
 922                 return (int)addr;
 923
 924         args->mapped = addr;
 925
 926         DRM_DEBUG("%s:h[%d]s[%d]o[0x%x]mapped[0x%x]\n", __func__,
 927                 args->handle, (int)args->size, (int)obj, (int)args->mapped);
 928
 929         return 0;
 930 }
 931
 932 int sprd_drm_gem_mmap_iommu_ioctl(struct drm_device *dev, void *data,
 933                               struct drm_file *file_priv)
 934 {
 935         struct drm_sprd_gem_mmap *args = data;
 936         struct drm_gem_object *obj;
 937         struct ion_handle *ion_handle;
 938         unsigned long addr;
 939         struct sprd_drm_gem_obj *sprd_gem_obj;
 940         struct sprd_drm_gem_buf *buf;
 941         int domain_num = 0;
 942
 943         if (!(dev->driver->driver_features & DRIVER_GEM)) {
 944                 DRM_ERROR("does not support GEM.\n");
 945                 return -ENODEV;
 946         }
 947
 948         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
 949         if (!obj) {
 950                 DRM_ERROR("failed to lookup gem object.\n");
 951                 return -EINVAL;
 952         }
 953
 954         sprd_gem_obj = to_sprd_gem_obj(obj);
 955         buf = sprd_gem_obj->buffer;
 956         if (sprd_gem_obj->flags & SPRD_BO_NONCONTIG) {
 957                 if (IS_DEV_MM_BUFFER(sprd_gem_obj->flags))
 958                         domain_num = IOMMU_MM;
 959                 else if (IS_DEV_GSP_BUFFER(sprd_gem_obj->flags))
 960                         domain_num = IOMMU_GSP;
 961
 962                 ion_handle = buf->ion_handle;
 963                 sprd_map_iommu(ion_handle, domain_num, &addr);
 964         } else {
 965                 DRM_ERROR("MMAP_IOMMU not applicable on CONTIG HEAP\n");
 966                 drm_gem_object_unreference_unlocked(obj);
 967                 return -EINVAL;
 968         }
 969
 970         args->mapped = addr;
 971         return 0;
 972 }
 973
 974 int sprd_drm_gem_unmap_iommu_ioctl(struct drm_device *dev, void *data,
 975                                         struct drm_file *file_priv)
 976 {
 977         struct drm_sprd_gem_mmap *args = data;
 978         struct drm_gem_object *obj;
 979         struct ion_handle *ion_handle;
 980         struct sprd_drm_gem_obj *sprd_gem_obj;
 981         struct sprd_drm_gem_buf *buf;
 982         int ret = 0, domain_num = 0;
 983
 984         if (!(dev->driver->driver_features & DRIVER_GEM)) {
 985                 DRM_ERROR("does not support GEM.\n");
 986                 return -ENODEV;
 987         }
 988
 989         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
 990         if (!obj) {
 991                 DRM_ERROR("failed to lookup gem object.\n");
 992                 return -EINVAL;
 993         }
 994
 995         sprd_gem_obj = to_sprd_gem_obj(obj);
 996         buf = sprd_gem_obj->buffer;
 997         if (sprd_gem_obj->flags & SPRD_BO_NONCONTIG) {
 998                 if (IS_DEV_MM_BUFFER(sprd_gem_obj->flags))
 999                         domain_num = IOMMU_MM;
1000                 else if (IS_DEV_GSP_BUFFER(sprd_gem_obj->flags))
1001                         domain_num = IOMMU_GSP;
1002
1003                 ion_handle = buf->ion_handle;
1004                 sprd_unmap_iommu(ion_handle, domain_num);
1005         } else {
1006                 DRM_ERROR("UNMAP_IOMMU not applicable on CONTIG HEAP\n");
1007                 ret = -EINVAL;
1008         }
1009
1010         drm_gem_object_unreference_unlocked(obj);
1011         /*
1012          * decrease obj->refcount one more time because we has already
1013          * increased it at sprd_drm_gem_mmap_iommu_ioctl().
1014          */
1015         drm_gem_object_unreference_unlocked(obj);
1016         return ret;
1017 }
1018
1019 int sprd_drm_gem_get_ioctl(struct drm_device *dev, void *data,
1020                                       struct drm_file *file_priv)
1021 {       struct sprd_drm_gem_obj *sprd_gem_obj;
1022         struct drm_sprd_gem_info *args = data;
1023         struct drm_gem_object *obj;
1024
1025         mutex_lock(&dev->struct_mutex);
1026
1027         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
1028         if (!obj) {
1029                 DRM_ERROR("failed to lookup gem object.\n");
1030                 mutex_unlock(&dev->struct_mutex);
1031                 return -EINVAL;
1032         }
1033
1034         sprd_gem_obj = to_sprd_gem_obj(obj);
1035
1036         args->flags = sprd_gem_obj->flags;
1037         args->size = sprd_gem_obj->size;
1038
1039         drm_gem_object_unreference(obj);
1040         mutex_unlock(&dev->struct_mutex);
1041
1042         return 0;
1043 }
1044
1045 int sprd_drm_gem_init_object(struct drm_gem_object *obj)
1046 {
1047         return 0;
1048 }
1049
1050 void sprd_drm_gem_free_object(struct drm_gem_object *obj)
1051 {
1052         struct sprd_drm_gem_obj *sprd_gem_obj;
1053         struct sprd_drm_gem_buf *buf;
1054
1055         sprd_gem_obj = to_sprd_gem_obj(obj);
1056         buf = sprd_gem_obj->buffer;
1057
1058         if (obj->import_attach)
1059                 drm_prime_gem_destroy(obj, buf->sgt);
1060
1061         sprd_drm_gem_destroy(to_sprd_gem_obj(obj));
1062 }
1063
1064 int sprd_drm_gem_dumb_create(struct drm_file *file_priv,
1065                                struct drm_device *dev,
1066                                struct drm_mode_create_dumb *args)
1067 {
1068         struct sprd_drm_gem_obj *sprd_gem_obj;
1069         struct sprd_drm_gem_index gem_idx;
1070         int ret;
1071
1072         /*
1073          * alocate memory to be used for framebuffer.
1074          * - this callback would be called by user application
1075          *      with DRM_IOCTL_MODE_CREATE_DUMB command.
1076          */
1077
1078         args->pitch = args->width * args->bpp >> 3;
1079         args->size = PAGE_ALIGN(args->pitch * args->height);
1080
1081         gem_idx.bufcount= 1;
1082         gem_idx.idx_size[0] = args->size;
1083         gem_idx.flags = args->flags;
1084
1085         sprd_gem_obj = sprd_drm_gem_create(dev, &gem_idx);
1086         if (IS_ERR(sprd_gem_obj))
1087                 return PTR_ERR(sprd_gem_obj);
1088
1089         ret = sprd_drm_gem_handle_create(&sprd_gem_obj->base, file_priv,
1090                         &args->handle);
1091         if (ret) {
1092                 sprd_drm_gem_destroy(sprd_gem_obj);
1093                 return ret;
1094         }
1095
1096         return 0;
1097 }
1098
1099 int sprd_drm_gem_dumb_map_offset(struct drm_file *file_priv,
1100                                    struct drm_device *dev, uint32_t handle,
1101                                    uint64_t *offset)
1102 {
1103         struct drm_gem_object *obj;
1104         int ret = 0;
1105
1106         mutex_lock(&dev->struct_mutex);
1107
1108         /*
1109          * get offset of memory allocated for drm framebuffer.
1110          * - this callback would be called by user application
1111          *      with DRM_IOCTL_MODE_MAP_DUMB command.
1112          */
1113
1114         obj = drm_gem_object_lookup(dev, file_priv, handle);
1115         if (!obj) {
1116                 DRM_ERROR("failed to lookup gem object.\n");
1117                 ret = -EINVAL;
1118                 goto unlock;
1119         }
1120
1121         if (!obj->map_list.map) {
1122                 ret = drm_gem_create_mmap_offset(obj);
1123                 if (ret)
1124                         goto out;
1125         }
1126
1127         *offset = (u64)obj->map_list.hash.key << PAGE_SHIFT;
1128         DRM_DEBUG_KMS("offset = 0x%lx\n", (unsigned long)*offset);
1129
1130 out:
1131         drm_gem_object_unreference(obj);
1132 unlock:
1133         mutex_unlock(&dev->struct_mutex);
1134         return ret;
1135 }
1136
1137 int sprd_drm_gem_dumb_destroy(struct drm_file *file_priv,
1138                                 struct drm_device *dev,
1139                                 unsigned int handle)
1140 {
1141         int ret;
1142
1143         /*
1144          * obj->refcount and obj->handle_count are decreased and
1145          * if both them are 0 then sprd_drm_gem_free_object()
1146          * would be called by callback to release resources.
1147          */
1148         ret = drm_gem_handle_delete(file_priv, handle);
1149         if (ret < 0) {
1150                 DRM_ERROR("failed to delete drm_gem_handle.\n");
1151                 return ret;
1152         }
1153
1154         return 0;
1155 }
1156
1157 int sprd_drm_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
1158 {
1159         struct drm_gem_object *obj = vma->vm_private_data;
1160         struct drm_device *dev = obj->dev;
1161         unsigned long f_vaddr;
1162         pgoff_t page_offset;
1163         int ret;
1164
1165         page_offset = ((unsigned long)vmf->virtual_address -
1166                         vma->vm_start) >> PAGE_SHIFT;
1167         f_vaddr = (unsigned long)vmf->virtual_address;
1168
1169         mutex_lock(&dev->struct_mutex);
1170
1171         ret = sprd_drm_gem_map_pages(obj, vma, f_vaddr, page_offset);
1172         if (ret < 0)
1173                 DRM_ERROR("failed to map pages.\n");
1174
1175         mutex_unlock(&dev->struct_mutex);
1176
1177         return convert_to_vm_err_msg(ret);
1178 }
1179
1180 int sprd_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma)
1181 {
1182         struct sprd_drm_gem_obj *sprd_gem_obj;
1183         struct drm_gem_object *obj;
1184         int ret;
1185
1186         /* set vm_area_struct. */
1187         ret = drm_gem_mmap(filp, vma);
1188         if (ret < 0) {
1189                 DRM_ERROR("failed to mmap.\n");
1190                 return ret;
1191         }
1192
1193         obj = vma->vm_private_data;
1194         sprd_gem_obj = to_sprd_gem_obj(obj);
1195
1196         ret = check_gem_flags(sprd_gem_obj->flags);
1197         if (ret) {
1198                 drm_gem_vm_close(vma);
1199                 drm_gem_free_mmap_offset(obj);
1200                 return ret;
1201         }
1202
1203         vma->vm_flags &= ~VM_PFNMAP;
1204         vma->vm_flags |= VM_MIXEDMAP;
1205
1206         update_vm_cache_attr(sprd_gem_obj, vma);
1207
1208         return ret;
1209 }
1210
1211 int sprd_gem_lock_handle_ioctl(struct drm_device *dev, void *data,
1212                                       struct drm_file *file_priv)
1213 {
1214         struct drm_sprd_gem_lock_handle *args = data;
1215         struct drm_gem_object *obj;
1216         struct sprd_drm_gem_obj *sprd_gem_obj;
1217         struct drm_sprd_gem_object_wait_list_entry *lock_item;
1218         int i;
1219         int result = 0;
1220
1221         DRM_DEBUG_DRIVER("%s line:%d\n", __func__, __LINE__);
1222         mutex_lock(&dev->struct_mutex);
1223
1224         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
1225
1226         if (obj == NULL) {
1227                 DRM_ERROR("Invalid GEM handle %x\n", args->handle);
1228                 result = -EBADF;
1229                 goto out_unlock;
1230         }
1231
1232         sprd_gem_obj = to_sprd_gem_obj(obj);
1233
1234         if (sprd_gem_obj->lockpid) {
1235                 /* if a pid already had it locked */
1236                 /* create and add to wait list */
1237                 for (i = 0; i < DRM_SPRD_HANDLE_WAIT_ENTRIES; i++) {
1238                         if (sprd_gem_obj->wait_entries[i].in_use == 0) {
1239                                 /* this one is empty */
1240                                 lock_item = &sprd_gem_obj->wait_entries[i];
1241                                 lock_item->in_use = 1;
1242                                 lock_item->pid = args->pid;
1243                                 INIT_LIST_HEAD((struct list_head *)
1244                                                 &sprd_gem_obj->wait_entries[i]);
1245                                 break;
1246                         }
1247                 }
1248
1249                 if (i == DRM_SPRD_HANDLE_WAIT_ENTRIES) {
1250
1251                         result =  -EFAULT;
1252                         drm_gem_object_unreference(obj);
1253                         goto out_unlock;
1254                 }
1255                 list_add_tail((struct list_head *)&lock_item->list,
1256                                 &sprd_gem_obj->wait_list);
1257                 mutex_unlock(&dev->struct_mutex);
1258                 /* here we need to block */
1259                 wait_event_interruptible_timeout(
1260                                 sprd_gem_obj->wait_entries[i].process_wait_q,
1261                                 (sprd_gem_obj->lockpid == 0),
1262                                 msecs_to_jiffies(20000));
1263                 mutex_lock(&dev->struct_mutex);
1264                 lock_item->in_use = 0;
1265         }
1266         sprd_gem_obj->lockpid = args->pid;
1267         DRM_DEBUG_DRIVER("%s lockpid:%d\n", __func__, sprd_gem_obj->lockpid);
1268
1269 out_unlock:
1270         mutex_unlock(&dev->struct_mutex);
1271
1272         return result;
1273 }
1274
1275 int sprd_gem_unlock_handle_ioctl(struct drm_device *dev, void *data,
1276                                       struct drm_file *file_priv)
1277 {
1278
1279         struct drm_sprd_gem_unlock_handle *args = data;
1280         struct drm_gem_object *obj;
1281         struct sprd_drm_gem_obj *unlock_obj;
1282         struct drm_sprd_gem_object_wait_list_entry *lock_next;
1283         int result = 0;
1284
1285         DRM_DEBUG_DRIVER("%s line:%d\n", __func__, __LINE__);
1286         mutex_lock(&dev->struct_mutex);
1287
1288         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
1289
1290         if (obj == NULL) {
1291                 DRM_ERROR("Invalid GEM handle %x\n", args->handle);
1292                 result = -EBADF;
1293                 goto out_unlock;
1294         }
1295
1296         unlock_obj = to_sprd_gem_obj(obj);
1297         if (!list_empty(&unlock_obj->wait_list)) {
1298                 lock_next =
1299                         (struct drm_sprd_gem_object_wait_list_entry *)
1300                         unlock_obj->wait_list.prev;
1301
1302                 list_del((struct list_head *)&lock_next->list);
1303
1304                 unlock_obj->lockpid = 0;
1305                 wake_up_interruptible(
1306                                 &lock_next->process_wait_q);
1307                 lock_next->pid = 0;
1308
1309         } else {
1310                 /* List is empty so set pid to 0 */
1311                 unlock_obj->lockpid = 0;
1312         }
1313         drm_gem_object_unreference(obj);
1314
1315         drm_gem_object_unreference(obj);
1316 out_unlock:
1317         mutex_unlock(&dev->struct_mutex);
1318
1319         return result;
1320 }
1321
1322 int sprd_gem_cache_op_ioctl(struct drm_device *dev, void *data,
1323                                       struct drm_file *file_priv)
1324 {
1325         struct drm_sprd_gem_cache_op *args = data;
1326         int result = 0;
1327         struct drm_gem_object *obj;
1328         struct sprd_drm_gem_obj *sprd_gem_obj;
1329         struct sprd_drm_gem_buf *buf;
1330         struct sg_table         *sgt;
1331         unsigned int cache_op = args->flags &(~SPRD_DRM_ALL_CACHE);
1332
1333         mutex_lock(&dev->struct_mutex);
1334         obj = drm_gem_object_lookup(dev, file_priv, args->gem_handle);
1335
1336         if (obj == NULL) {
1337                 DRM_ERROR("invalid handle[%d]\n", args->gem_handle);
1338                 result = -EBADF;
1339                 goto err_invalid_handle;
1340         }
1341
1342         sprd_gem_obj = to_sprd_gem_obj(obj);
1343         buf = sprd_gem_obj->buffer;
1344         sgt = buf->sgt;
1345
1346         DRM_DEBUG("%s:h[%d]s[%d]f[0x%x]a[0x%x]o[0x%x]\n",
1347                 "gc",args->gem_handle, (int)args->size, args->flags,
1348                 (int)args->usr_addr, (int)obj);
1349
1350         if (!IS_CACHABLE_BUFFER(sprd_gem_obj->flags)) {
1351                 DRM_ERROR("invalid flags[0x%x]for h[%d]\n",
1352                         sprd_gem_obj->flags, args->gem_handle);
1353                 goto out;
1354         }
1355
1356         switch (cache_op) {
1357                 case SPRD_DRM_CACHE_INV:
1358                         dma_sync_sg_for_cpu(NULL, sgt->sgl, sgt->nents,
1359                                                         DMA_FROM_DEVICE);
1360                         break;
1361                 case SPRD_DRM_CACHE_CLN:
1362                         dma_sync_sg_for_device(NULL, sgt->sgl, sgt->nents,
1363                                                         DMA_TO_DEVICE);
1364                         break;
1365                 case SPRD_DRM_CACHE_FSH:
1366                         dma_sync_sg_for_device(NULL, sgt->sgl, sgt->nents,
1367                                                         DMA_TO_DEVICE);
1368                         dma_sync_sg_for_cpu(NULL, sgt->sgl, sgt->nents,
1369                                                         DMA_FROM_DEVICE);
1370                         break;
1371                 default:
1372                         DRM_ERROR("invalid op[0x%x]for h[%d]\n", cache_op, args->gem_handle);
1373                         result = -EINVAL;
1374                         goto out;
1375         }
1376
1377 out:
1378         drm_gem_object_unreference(obj);
1379
1380 err_invalid_handle:
1381         mutex_unlock(&dev->struct_mutex);
1382         return result;
1383 }