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         DRM_DEBUG_KMS("created file object = 0x%x\n", (unsigned int)obj->filp);
 338
 339         return sprd_gem_obj;
 340 }
 341
 342 struct sprd_drm_gem_obj *sprd_drm_gem_create(struct drm_device *dev,
 343                                                 struct sprd_drm_gem_index *args)
 344 {
 345         struct sprd_drm_gem_obj *sprd_gem_obj;
 346         struct sprd_drm_gem_buf *buf;
 347         int ret, i=0, j, tsize = 0;
 348
 349         ret = check_gem_flags(args->flags);
 350         if (ret)
 351                 return ERR_PTR(ret);
 352
 353         /* ToDo: need to check align */
 354         for (i = 0; i < args->bufcount; i++)
 355                 tsize += args->idx_size[i];
 356
 357         if (!tsize) {
 358                 DRM_ERROR("invalid size.\n");
 359                 return ERR_PTR(-EINVAL);
 360         }
 361
 362         tsize = roundup_gem_size(tsize, args->flags);
 363
 364         buf = sprd_drm_init_buf(dev, tsize);
 365         if (!buf)
 366                 return ERR_PTR(-ENOMEM);
 367
 368         sprd_gem_obj = sprd_drm_gem_init(dev, tsize);
 369         if (!sprd_gem_obj) {
 370                 ret = -ENOMEM;
 371                 goto err_fini_buf;
 372         }
 373
 374         sprd_gem_obj->buffer = buf;
 375
 376         /* set memory type and cache attribute from user side. */
 377         sprd_gem_obj->flags = args->flags;
 378
 379         ret = sprd_drm_alloc_buf(dev, buf, args->flags);
 380         if (ret < 0)
 381                 goto err_gem_fini;
 382
 383         memset(buf->idx_addr, 0x00, sizeof(buf->idx_addr));
 384         buf->idx_addr[0] = buf->dma_addr;
 385         buf->bufcount = args->bufcount;
 386
 387         for (i = 0; i < buf->bufcount; i++) {
 388                 j = i + 1;
 389                 if (buf->bufcount > j)
 390                         buf->idx_addr[j] = buf->idx_addr[i] + args->idx_size[i];
 391         }
 392
 393         sprd_gem_obj->lockpid=0;
 394         INIT_LIST_HEAD(&sprd_gem_obj->wait_list);
 395
 396         for (i = 0; i < DRM_SPRD_HANDLE_WAIT_ENTRIES; i++) {
 397                 INIT_LIST_HEAD((struct list_head *) &sprd_gem_obj->wait_entries[i]);
 398                 sprd_gem_obj->wait_entries[i].pid = 0;
 399                 init_waitqueue_head(&sprd_gem_obj->wait_entries[i].process_wait_q);
 400         }
 401
 402         return sprd_gem_obj;
 403
 404 err_gem_fini:
 405         drm_gem_object_release(&sprd_gem_obj->base);
 406         kfree(sprd_gem_obj);
 407 err_fini_buf:
 408         sprd_drm_fini_buf(dev, buf);
 409         return ERR_PTR(ret);
 410 }
 411
 412 int sprd_drm_gem_create_ioctl(struct drm_device *dev, void *data,
 413                                 struct drm_file *file_priv)
 414 {
 415         struct drm_sprd_gem_create *args = data;
 416         struct sprd_drm_gem_obj *sprd_gem_obj;
 417         struct sprd_drm_gem_index gem_idx;
 418         struct timeval val_start, val_end;
 419         uint64_t time_start, time_end;
 420         int ret;
 421
 422         do_gettimeofday(&val_start);
 423         time_start = (uint64_t)(val_start.tv_sec * 1000000 + val_start.tv_usec);
 424
 425         gem_idx.bufcount= 1;
 426         gem_idx.idx_size[0] = args->size;
 427         gem_idx.flags = args->flags;
 428
 429         sprd_gem_obj = sprd_drm_gem_create(dev, &gem_idx);
 430         if (IS_ERR(sprd_gem_obj)) {
 431                 DRM_ERROR("failed to sprd_drm_gem_create:s[%d]f[0x%x]\n",
 432                         (int)args->size, args->flags);
 433                 return PTR_ERR(sprd_gem_obj);
 434         }
 435
 436         ret = sprd_drm_gem_handle_create(&sprd_gem_obj->base, file_priv,
 437                         &args->handle);
 438         if (ret) {
 439                 DRM_ERROR("failed to sprd_drm_gem_handle_create:s[%d]f[0x%x]\n",
 440                         (int)args->size, args->flags);
 441                 sprd_drm_gem_destroy(sprd_gem_obj);
 442                 return ret;
 443         }
 444
 445         do_gettimeofday(&val_end);
 446         time_end = (uint64_t)(val_end.tv_sec * 1000000 + val_end.tv_usec);
 447
 448         DRM_DEBUG("%s:h[%d]s[%d]f[0x%x]o[0x%x]a[0x%x][%lld us]\n",
 449                 "ga",args->handle, (int)args->size, args->flags,
 450                 (int)&sprd_gem_obj->base,
 451                 (int)sprd_gem_obj->buffer->dma_addr, time_end - time_start);
 452
 453         return 0;
 454 }
 455
 456 int sprd_drm_gem_create_index_ioctl(struct drm_device *dev, void *data,
 457                                 struct drm_file *file_priv)
 458 {
 459         struct sprd_drm_gem_index *args = data;
 460         struct sprd_drm_gem_obj *sprd_gem_obj;
 461         int ret;
 462
 463         if (args->flags & SPRD_BO_NONCONTIG) {
 464                 DRM_ERROR("does not support non-contig memory\n");
 465                 return -EINVAL;
 466         }
 467
 468         sprd_gem_obj = sprd_drm_gem_create(dev, args);
 469         if (IS_ERR(sprd_gem_obj))
 470                 return PTR_ERR(sprd_gem_obj);
 471
 472         ret = sprd_drm_gem_handle_create(&sprd_gem_obj->base, file_priv,
 473                         &args->handle);
 474         if (ret) {
 475                 sprd_drm_gem_destroy(sprd_gem_obj);
 476                 return ret;
 477         }
 478
 479         DRM_INFO("%s:h[%d]cnt[%d]sz[%d %d %d]f[0x%x]o[0x%x]a[0x%x]\n",
 480                 __func__,args->handle, args->bufcount,
 481                 (int)args->idx_size[0], (int)args->idx_size[1], (int)args->idx_size[2],
 482                 args->flags, (int)&sprd_gem_obj->base,
 483                 (int)sprd_gem_obj->buffer->dma_addr);
 484
 485         return 0;
 486 }
 487
 488 struct dma_buf *sprd_prime_export(struct drm_device *dev,
 489                                   struct drm_gem_object *obj, int flags)
 490 {
 491         struct sprd_drm_private *private = dev->dev_private;
 492         struct sprd_drm_gem_obj *sprd_gem_obj = to_sprd_gem_obj(obj);
 493         struct sprd_drm_gem_buf *buf = sprd_gem_obj->buffer;
 494         struct dma_buf *dmabuf;
 495
 496         dmabuf = ion_share_dma_buf(private->sprd_drm_ion_client,
 497                                    buf->ion_handle);
 498         if (IS_ERR(dmabuf))
 499                 pr_err("%s: dmabuf is error and dmabuf is %p!\n",
 500                                 __func__, dmabuf);
 501
 502         return dmabuf;
 503 }
 504
 505 struct drm_gem_object *sprd_prime_import(struct drm_device *dev,
 506                                          struct dma_buf *dma_buf)
 507 {
 508         struct ion_handle *ion_handle;
 509         struct sprd_drm_gem_obj *sprd_gem_obj;
 510         unsigned long size;
 511         struct sprd_drm_gem_buf *buf = NULL;
 512         unsigned int i = 0, nr_pages = 0, heap_id;
 513         int ret = 0;
 514         struct sprd_drm_private *private;
 515         struct scatterlist *sg = NULL;
 516         struct drm_gem_object *obj;
 517         unsigned long sgt_size;
 518
 519         private = dev->dev_private;
 520         ion_handle = get_ion_handle_from_dmabuf(private->sprd_drm_ion_client, dma_buf);
 521         if (IS_ERR_OR_NULL(ion_handle)) {
 522                 DRM_ERROR("Unable to import dmabuf\n");
 523                 return ERR_PTR(-EINVAL);
 524         }
 525
 526         ion_handle_get_size(private->sprd_drm_ion_client,
 527                                         ion_handle, &size, &heap_id);
 528         if (size == 0) {
 529                 DRM_ERROR(
 530                         "cannot create GEM object from zero size ION buffer\n");
 531                 ret = -EINVAL;
 532                 goto err;
 533         }
 534
 535         buf = sprd_drm_init_buf(dev, size);
 536         if (!buf) {
 537                 DRM_ERROR("Unable to allocate the GEM buffer\n");
 538                 ret = -ENOMEM;
 539                 goto err;
 540         }
 541
 542         sprd_gem_obj = sprd_drm_gem_init(dev, size);
 543         if (!sprd_gem_obj) {
 544                 DRM_ERROR("Unable to initialize GEM object\n");
 545                 ret = -ENOMEM;
 546                 goto err_fini_buf;
 547         }
 548         sprd_gem_obj->buffer = buf;
 549         obj = &sprd_gem_obj->base;
 550
 551         ret = ion_is_phys(private->sprd_drm_ion_client, ion_handle);
 552         if (ret == -1)
 553                 sprd_gem_obj->flags = SPRD_BO_NONCONTIG;
 554         else if (ret == 0)
 555                 sprd_gem_obj->flags = SPRD_BO_CONTIG;
 556         else {
 557                 DRM_ERROR("Unable to get flag, Invalid handle\n");
 558                 goto err_gem_obj;
 559         }
 560
 561         /* ion_handle is validated in ion_is_phys, no need to check again */
 562         ret = ion_is_cached(private->sprd_drm_ion_client, ion_handle);
 563         if (ret)
 564                 sprd_gem_obj->flags |= SPRD_BO_CACHABLE;
 565
 566         if ((heap_id == ION_HEAP_ID_MASK_GSP) || (heap_id == ION_HEAP_ID_MASK_GSP_IOMMU))
 567                 sprd_gem_obj->flags |= SPRD_BO_DEV_GSP;
 568         else if ((heap_id == ION_HEAP_ID_MASK_MM) || (heap_id == ION_HEAP_ID_MASK_MM_IOMMU))
 569                 sprd_gem_obj->flags |= SPRD_BO_DEV_MM;
 570         else if (heap_id == ION_HEAP_ID_MASK_OVERLAY)
 571                 sprd_gem_obj->flags |= SPRD_BO_DEV_OVERLAY;
 572         else if (heap_id == ION_HEAP_ID_MASK_SYSTEM)
 573                 sprd_gem_obj->flags |= SPRD_BO_DEV_SYSTEM;
 574         else {
 575                 DRM_ERROR("Heap id not supported\n");
 576                 ret = -ENOMEM;
 577                 goto err_gem_obj;
 578         }
 579
 580         buf->ion_handle = ion_handle;
 581         buf->sgt = ion_sg_table(private->sprd_drm_ion_client, buf->ion_handle);
 582         if (!buf->sgt) {
 583                 DRM_ERROR("failed to allocate sg table.\n");
 584                 ret = -EINVAL;
 585                 goto err_gem_obj;
 586         }
 587
 588         buf->dma_addr = sg_dma_address(buf->sgt->sgl);
 589         for_each_sg(buf->sgt->sgl, sg, buf->sgt->nents, i)
 590                 nr_pages++;
 591
 592         sgt_size = sizeof(struct page) * nr_pages;
 593         buf->pages = kzalloc(sgt_size, GFP_KERNEL | __GFP_NOWARN);
 594         if (!buf->pages) {
 595                 unsigned int order;
 596                 order = get_order(sgt_size);
 597                 DRM_ERROR("%s: kzalloc failed for sg list: order:%d\n",
 598                                         __func__, order);
 599                 buf->pages = vzalloc(sgt_size);
 600                 if (!buf->pages) {
 601                         DRM_ERROR("failed to allocate pages.\n");
 602                         ret = -ENOMEM;
 603                         goto err_buf;
 604                 }
 605         }
 606
 607         for_each_sg(buf->sgt->sgl, sg, buf->sgt->nents, i)
 608                 buf->pages[i] = phys_to_page(sg_dma_address(sg));
 609
 610         DRM_DEBUG_KMS("dma_addr(0x%lx), size(0x%lx)\n",
 611                 (unsigned long)buf->dma_addr, buf->size);
 612
 613         return obj;
 614
 615 err_buf:
 616         buf->dma_addr = (dma_addr_t)NULL;
 617         buf->sgt = NULL;
 618 err_gem_obj:
 619         sprd_gem_obj->buffer = NULL;
 620         /* release file pointer to gem object. */
 621         drm_gem_object_release(obj);
 622         kfree(sprd_gem_obj);
 623         sprd_gem_obj = NULL;
 624 err_fini_buf:
 625         sprd_drm_fini_buf(dev, buf);
 626 err:
 627         ion_free(private->sprd_drm_ion_client, ion_handle);
 628
 629         return ERR_PTR(ret);
 630 }
 631
 632 void *sprd_drm_gem_get_dma_addr(struct drm_device *dev,
 633                                         unsigned int gem_handle,
 634                                         struct drm_file *file_priv)
 635 {
 636         struct sprd_drm_gem_obj *sprd_gem_obj;
 637         struct drm_gem_object *obj;
 638         struct ion_handle *ion_handle;
 639         struct sprd_drm_gem_buf *buf;
 640         int domain_num = 0;
 641
 642         obj = drm_gem_object_lookup(dev, file_priv, gem_handle);
 643         if (!obj) {
 644                 DRM_ERROR("failed to lookup gem object:h[%d]\n", gem_handle);
 645                 return ERR_PTR(-EINVAL);
 646         }
 647
 648         sprd_gem_obj = to_sprd_gem_obj(obj);
 649
 650         if (sprd_gem_obj->flags & SPRD_BO_NONCONTIG) {
 651                 buf = sprd_gem_obj->buffer;
 652                 if (IS_DEV_MM_BUFFER(sprd_gem_obj->flags))
 653                         domain_num = IOMMU_MM;
 654                 else if (IS_DEV_GSP_BUFFER(sprd_gem_obj->flags))
 655                         domain_num = IOMMU_GSP;
 656
 657                 ion_handle = buf->ion_handle;
 658                 if (sprd_map_iommu(ion_handle, domain_num,
 659                                 (unsigned long *)&sprd_gem_obj->buffer->dma_addr)) {
 660                         DRM_ERROR("failed to map iommu:h[%d]o[0x%x]\n",
 661                                 gem_handle, (int)obj);
 662                         drm_gem_object_unreference_unlocked(obj);
 663                         return ERR_PTR(-EINVAL);
 664                 }
 665         }
 666
 667         DRM_DEBUG("%s:h[%d]o[0x%x]a[0x%x]\n",
 668                 __func__,gem_handle, (int)obj,
 669                 (int)sprd_gem_obj->buffer->dma_addr);
 670
 671         return &sprd_gem_obj->buffer->dma_addr;
 672 }
 673
 674 void sprd_drm_gem_put_dma_addr(struct drm_device *dev,
 675                                         unsigned int gem_handle,
 676                                         struct drm_file *file_priv)
 677 {
 678         struct sprd_drm_gem_obj *sprd_gem_obj;
 679         struct drm_gem_object *obj;
 680         struct ion_handle *ion_handle;
 681         struct sprd_drm_gem_buf *buf;
 682         int domain_num = 0;
 683
 684         obj = drm_gem_object_lookup(dev, file_priv, gem_handle);
 685         if (!obj) {
 686                 DRM_ERROR("failed to lookup gem object:h[%d]\n", gem_handle);
 687                 return;
 688         }
 689
 690         sprd_gem_obj = to_sprd_gem_obj(obj);
 691
 692         if (sprd_gem_obj->flags & SPRD_BO_NONCONTIG) {
 693                 buf = sprd_gem_obj->buffer;
 694                 if (IS_DEV_MM_BUFFER(sprd_gem_obj->flags))
 695                         domain_num = IOMMU_MM;
 696                 else if (IS_DEV_GSP_BUFFER(sprd_gem_obj->flags))
 697                         domain_num = IOMMU_GSP;
 698
 699                 ion_handle = buf->ion_handle;
 700                 if (sprd_unmap_iommu(ion_handle, domain_num))
 701                         DRM_ERROR("failed to unmap iommu:h[%d]o[0x%x]\n",
 702                                 gem_handle, (int)obj);
 703         }
 704
 705         drm_gem_object_unreference_unlocked(obj);
 706
 707         DRM_DEBUG("%s:h[%d]o[0x%x]\n",
 708                 __func__,gem_handle, (int)obj);
 709         /*
 710          * decrease obj->refcount one more time because we has already
 711          * increased it at sprd_drm_gem_get_dma_addr().
 712          */
 713         drm_gem_object_unreference_unlocked(obj);
 714 }
 715
 716 unsigned long sprd_drm_gem_get_size(struct drm_device *dev,
 717                                                 unsigned int gem_handle,
 718                                                 struct drm_file *file_priv)
 719 {
 720         struct sprd_drm_gem_obj *sprd_gem_obj;
 721         struct drm_gem_object *obj;
 722
 723         obj = drm_gem_object_lookup(dev, file_priv, gem_handle);
 724         if (!obj) {
 725                 DRM_ERROR("failed to lookup gem object:h[%d]\n", gem_handle);
 726                 return 0;
 727         }
 728
 729         sprd_gem_obj = to_sprd_gem_obj(obj);
 730
 731         drm_gem_object_unreference_unlocked(obj);
 732
 733         return sprd_gem_obj->buffer->size;
 734 }
 735
 736 void *sprd_drm_gem_get_obj_addr(unsigned int name, unsigned int index)
 737 {
 738         struct sprd_drm_gem_obj *sprd_gem_obj;
 739         struct drm_gem_object *obj;
 740         struct ion_handle *ion_handle;
 741         struct sprd_drm_gem_buf *buf;
 742         int domain_num = 0;
 743
 744         mutex_lock(&sprd_drm_dev->object_name_lock);
 745         obj = idr_find(&sprd_drm_dev->object_name_idr, (int) name);
 746         mutex_unlock(&sprd_drm_dev->object_name_lock);
 747
 748         if (!obj) {
 749                 DRM_ERROR("name[%d]failed to lookup gem object.\n", name);
 750                 return ERR_PTR(-EFAULT);
 751         }
 752
 753         sprd_gem_obj = to_sprd_gem_obj(obj);
 754         buf = sprd_gem_obj->buffer;
 755
 756         if (index >= buf->bufcount) {
 757                 DRM_ERROR("invalid index[%d],bufcount[%d]\n",
 758                         index, buf->bufcount);
 759                 return ERR_PTR(-EINVAL);
 760         }
 761
 762         if (sprd_gem_obj->flags & SPRD_BO_NONCONTIG) {
 763                 if (IS_DEV_MM_BUFFER(sprd_gem_obj->flags))
 764                         domain_num = IOMMU_MM;
 765                 else if (IS_DEV_GSP_BUFFER(sprd_gem_obj->flags))
 766                         domain_num = IOMMU_GSP;
 767
 768                 ion_handle = buf->ion_handle;
 769                 if (sprd_map_iommu(ion_handle, domain_num,
 770                                 (unsigned long *)&sprd_gem_obj->buffer->dma_addr)) {
 771                         DRM_ERROR("failed to map iommu\n");
 772                         return ERR_PTR(-EINVAL);
 773                 }
 774         }
 775
 776         DRM_DEBUG("%s:name[%d]o[0x%x]idx[%d]a[0x%x]\n",
 777                 __func__, name, (int)obj, index, (int)buf->idx_addr[index]);
 778
 779         return &buf->idx_addr[index];
 780 }
 781 EXPORT_SYMBOL(sprd_drm_gem_get_obj_addr);
 782
 783 int sprd_drm_gem_map_offset_ioctl(struct drm_device *dev, void *data,
 784                                     struct drm_file *file_priv)
 785 {
 786         struct drm_sprd_gem_map_off *args = data;
 787
 788         DRM_DEBUG_KMS("handle = 0x%x, offset = 0x%lx\n",
 789                         args->handle, (unsigned long)args->offset);
 790
 791         if (!(dev->driver->driver_features & DRIVER_GEM)) {
 792                 DRM_ERROR("does not support GEM.\n");
 793                 return -ENODEV;
 794         }
 795
 796         return sprd_drm_gem_dumb_map_offset(file_priv, dev, args->handle,
 797                         &args->offset);
 798 }
 799
 800 static int sprd_drm_gem_mmap_buffer(struct file *filp,
 801                                       struct vm_area_struct *vma)
 802 {
 803         struct drm_gem_object *obj = filp->private_data;
 804         struct sprd_drm_gem_obj *sprd_gem_obj = to_sprd_gem_obj(obj);
 805         struct sprd_drm_gem_buf *buffer;
 806         unsigned long pfn, vm_size;
 807
 808         vma->vm_flags |= (VM_IO | VM_DONTEXPAND | VM_DONTDUMP);
 809
 810         update_vm_cache_attr(sprd_gem_obj, vma);
 811
 812         vm_size = vma->vm_end - vma->vm_start;
 813
 814         /*
 815          * a buffer contains information to physically continuous memory
 816          * allocated by user request or at framebuffer creation.
 817          */
 818         buffer = sprd_gem_obj->buffer;
 819
 820         /* check if user-requested size is valid. */
 821         if (vm_size > buffer->size)
 822                 return -EINVAL;
 823
 824         if (sprd_gem_obj->flags & SPRD_BO_NONCONTIG) {
 825                 unsigned long addr = vma->vm_start;
 826                 unsigned long offset = vma->vm_pgoff * PAGE_SIZE;
 827                 struct scatterlist *sg;
 828                 int i;
 829
 830                 for_each_sg(buffer->sgt->sgl, sg, buffer->sgt->nents, i) {
 831                         struct page *page = sg_page(sg);
 832                         unsigned long remainder = vma->vm_end - addr;
 833                         unsigned long len = sg_dma_len(sg);
 834
 835                         if (offset >= sg_dma_len(sg)) {
 836                                 offset -= sg_dma_len(sg);
 837                                 continue;
 838                         } else if (offset) {
 839                                 page += offset / PAGE_SIZE;
 840                                 len = sg_dma_len(sg) - offset;
 841                                 offset = 0;
 842                         }
 843                         len = min(len, remainder);
 844                         remap_pfn_range(vma, addr, page_to_pfn(page), len,
 845                                         vma->vm_page_prot);
 846                         addr += len;
 847                         if (addr >= vma->vm_end) {
 848                                 break;
 849                         }
 850                 }
 851         } else {
 852                 /*
 853                  * get page frame number to physical memory to be mapped
 854                  * to user space.
 855                  */
 856                 pfn = ((unsigned long)sprd_gem_obj->buffer->dma_addr) >>
 857                                                                 PAGE_SHIFT;
 858
 859                 DRM_DEBUG_KMS("pfn = 0x%lx\n", pfn);
 860
 861                 if (remap_pfn_range(vma, vma->vm_start, pfn, vm_size,
 862                                         vma->vm_page_prot)) {
 863                         DRM_ERROR("failed to remap pfn range.\n");
 864                         return -EAGAIN;
 865                 }
 866         }
 867
 868         return 0;
 869 }
 870
 871 static const struct file_operations sprd_drm_gem_fops = {
 872         .mmap = sprd_drm_gem_mmap_buffer,
 873 };
 874
 875 int sprd_drm_gem_mmap_ioctl(struct drm_device *dev, void *data,
 876                               struct drm_file *file_priv)
 877 {
 878         struct drm_sprd_gem_mmap *args = data;
 879         struct drm_gem_object *obj;
 880         unsigned long addr;
 881
 882         if (!(dev->driver->driver_features & DRIVER_GEM)) {
 883                 DRM_ERROR("does not support GEM.\n");
 884                 return -ENODEV;
 885         }
 886
 887         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
 888         if (!obj) {
 889                 DRM_ERROR("failed to lookup gem object:h[%d]\n", args->handle);
 890                 return -EINVAL;
 891         }
 892
 893         obj->filp->f_op = &sprd_drm_gem_fops;
 894         obj->filp->private_data = obj;
 895
 896         addr = vm_mmap(obj->filp, 0, args->size,
 897                         PROT_READ | PROT_WRITE, MAP_SHARED, 0);
 898
 899         drm_gem_object_unreference_unlocked(obj);
 900
 901         if (IS_ERR_VALUE(addr))
 902                 return (int)addr;
 903
 904         args->mapped = addr;
 905
 906         DRM_DEBUG("%s:h[%d]s[%d]o[0x%x]mapped[0x%x]\n", __func__,
 907                 args->handle, (int)args->size, (int)obj, (int)args->mapped);
 908
 909         return 0;
 910 }
 911
 912 int sprd_drm_gem_mmap_iommu_ioctl(struct drm_device *dev, void *data,
 913                               struct drm_file *file_priv)
 914 {
 915         struct drm_sprd_gem_mmap *args = data;
 916         struct drm_gem_object *obj;
 917         struct ion_handle *ion_handle;
 918         unsigned long addr;
 919         struct sprd_drm_gem_obj *sprd_gem_obj;
 920         struct sprd_drm_gem_buf *buf;
 921         int domain_num = 0;
 922
 923         if (!(dev->driver->driver_features & DRIVER_GEM)) {
 924                 DRM_ERROR("does not support GEM.\n");
 925                 return -ENODEV;
 926         }
 927
 928         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
 929         if (!obj) {
 930                 DRM_ERROR("failed to lookup gem object.\n");
 931                 return -EINVAL;
 932         }
 933
 934         sprd_gem_obj = to_sprd_gem_obj(obj);
 935         buf = sprd_gem_obj->buffer;
 936         if (sprd_gem_obj->flags & SPRD_BO_NONCONTIG) {
 937                 if (IS_DEV_MM_BUFFER(sprd_gem_obj->flags))
 938                         domain_num = IOMMU_MM;
 939                 else if (IS_DEV_GSP_BUFFER(sprd_gem_obj->flags))
 940                         domain_num = IOMMU_GSP;
 941
 942                 ion_handle = buf->ion_handle;
 943                 sprd_map_iommu(ion_handle, domain_num, &addr);
 944         } else {
 945                 DRM_ERROR("MMAP_IOMMU not applicable on CONTIG HEAP\n");
 946                 drm_gem_object_unreference_unlocked(obj);
 947                 return -EINVAL;
 948         }
 949
 950         args->mapped = addr;
 951         return 0;
 952 }
 953
 954 int sprd_drm_gem_unmap_iommu_ioctl(struct drm_device *dev, void *data,
 955                                         struct drm_file *file_priv)
 956 {
 957         struct drm_sprd_gem_mmap *args = data;
 958         struct drm_gem_object *obj;
 959         struct ion_handle *ion_handle;
 960         struct sprd_drm_gem_obj *sprd_gem_obj;
 961         struct sprd_drm_gem_buf *buf;
 962         int ret = 0, domain_num = 0;
 963
 964         if (!(dev->driver->driver_features & DRIVER_GEM)) {
 965                 DRM_ERROR("does not support GEM.\n");
 966                 return -ENODEV;
 967         }
 968
 969         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
 970         if (!obj) {
 971                 DRM_ERROR("failed to lookup gem object.\n");
 972                 return -EINVAL;
 973         }
 974
 975         sprd_gem_obj = to_sprd_gem_obj(obj);
 976         buf = sprd_gem_obj->buffer;
 977         if (sprd_gem_obj->flags & SPRD_BO_NONCONTIG) {
 978                 if (IS_DEV_MM_BUFFER(sprd_gem_obj->flags))
 979                         domain_num = IOMMU_MM;
 980                 else if (IS_DEV_GSP_BUFFER(sprd_gem_obj->flags))
 981                         domain_num = IOMMU_GSP;
 982
 983                 ion_handle = buf->ion_handle;
 984                 sprd_unmap_iommu(ion_handle, domain_num);
 985         } else {
 986                 DRM_ERROR("UNMAP_IOMMU not applicable on CONTIG HEAP\n");
 987                 ret = -EINVAL;
 988         }
 989
 990         drm_gem_object_unreference_unlocked(obj);
 991         /*
 992          * decrease obj->refcount one more time because we has already
 993          * increased it at sprd_drm_gem_mmap_iommu_ioctl().
 994          */
 995         drm_gem_object_unreference_unlocked(obj);
 996         return ret;
 997 }
 998
 999 int sprd_drm_gem_get_ioctl(struct drm_device *dev, void *data,
1000                                       struct drm_file *file_priv)
1001 {       struct sprd_drm_gem_obj *sprd_gem_obj;
1002         struct drm_sprd_gem_info *args = data;
1003         struct drm_gem_object *obj;
1004
1005         mutex_lock(&dev->struct_mutex);
1006
1007         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
1008         if (!obj) {
1009                 DRM_ERROR("failed to lookup gem object.\n");
1010                 mutex_unlock(&dev->struct_mutex);
1011                 return -EINVAL;
1012         }
1013
1014         sprd_gem_obj = to_sprd_gem_obj(obj);
1015
1016         args->flags = sprd_gem_obj->flags;
1017         args->size = sprd_gem_obj->size;
1018
1019         drm_gem_object_unreference(obj);
1020         mutex_unlock(&dev->struct_mutex);
1021
1022         return 0;
1023 }
1024
1025 int sprd_drm_gem_init_object(struct drm_gem_object *obj)
1026 {
1027         return 0;
1028 }
1029
1030 void sprd_drm_gem_free_object(struct drm_gem_object *obj)
1031 {
1032         struct sprd_drm_gem_obj *sprd_gem_obj;
1033         struct sprd_drm_gem_buf *buf;
1034
1035         sprd_gem_obj = to_sprd_gem_obj(obj);
1036         buf = sprd_gem_obj->buffer;
1037
1038         if (obj->import_attach)
1039                 drm_prime_gem_destroy(obj, buf->sgt);
1040
1041         sprd_drm_gem_destroy(to_sprd_gem_obj(obj));
1042 }
1043
1044 int sprd_drm_gem_dumb_create(struct drm_file *file_priv,
1045                                struct drm_device *dev,
1046                                struct drm_mode_create_dumb *args)
1047 {
1048         struct sprd_drm_gem_obj *sprd_gem_obj;
1049         struct sprd_drm_gem_index gem_idx;
1050         int ret;
1051
1052         /*
1053          * alocate memory to be used for framebuffer.
1054          * - this callback would be called by user application
1055          *      with DRM_IOCTL_MODE_CREATE_DUMB command.
1056          */
1057
1058         args->pitch = args->width * args->bpp >> 3;
1059         args->size = PAGE_ALIGN(args->pitch * args->height);
1060
1061         gem_idx.bufcount= 1;
1062         gem_idx.idx_size[0] = args->size;
1063         gem_idx.flags = args->flags;
1064
1065         sprd_gem_obj = sprd_drm_gem_create(dev, &gem_idx);
1066         if (IS_ERR(sprd_gem_obj))
1067                 return PTR_ERR(sprd_gem_obj);
1068
1069         ret = sprd_drm_gem_handle_create(&sprd_gem_obj->base, file_priv,
1070                         &args->handle);
1071         if (ret) {
1072                 sprd_drm_gem_destroy(sprd_gem_obj);
1073                 return ret;
1074         }
1075
1076         return 0;
1077 }
1078
1079 int sprd_drm_gem_dumb_map_offset(struct drm_file *file_priv,
1080                                    struct drm_device *dev, uint32_t handle,
1081                                    uint64_t *offset)
1082 {
1083         struct drm_gem_object *obj;
1084         int ret = 0;
1085
1086         mutex_lock(&dev->struct_mutex);
1087
1088         /*
1089          * get offset of memory allocated for drm framebuffer.
1090          * - this callback would be called by user application
1091          *      with DRM_IOCTL_MODE_MAP_DUMB command.
1092          */
1093
1094         obj = drm_gem_object_lookup(dev, file_priv, handle);
1095         if (!obj) {
1096                 DRM_ERROR("failed to lookup gem object.\n");
1097                 ret = -EINVAL;
1098                 goto unlock;
1099         }
1100
1101         if (!obj->map_list.map) {
1102                 ret = drm_gem_create_mmap_offset(obj);
1103                 if (ret)
1104                         goto out;
1105         }
1106
1107         *offset = (u64)obj->map_list.hash.key << PAGE_SHIFT;
1108         DRM_DEBUG_KMS("offset = 0x%lx\n", (unsigned long)*offset);
1109
1110 out:
1111         drm_gem_object_unreference(obj);
1112 unlock:
1113         mutex_unlock(&dev->struct_mutex);
1114         return ret;
1115 }
1116
1117 int sprd_drm_gem_dumb_destroy(struct drm_file *file_priv,
1118                                 struct drm_device *dev,
1119                                 unsigned int handle)
1120 {
1121         int ret;
1122
1123         /*
1124          * obj->refcount and obj->handle_count are decreased and
1125          * if both them are 0 then sprd_drm_gem_free_object()
1126          * would be called by callback to release resources.
1127          */
1128         ret = drm_gem_handle_delete(file_priv, handle);
1129         if (ret < 0) {
1130                 DRM_ERROR("failed to delete drm_gem_handle.\n");
1131                 return ret;
1132         }
1133
1134         return 0;
1135 }
1136
1137 int sprd_drm_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
1138 {
1139         struct drm_gem_object *obj = vma->vm_private_data;
1140         struct drm_device *dev = obj->dev;
1141         unsigned long f_vaddr;
1142         pgoff_t page_offset;
1143         int ret;
1144
1145         page_offset = ((unsigned long)vmf->virtual_address -
1146                         vma->vm_start) >> PAGE_SHIFT;
1147         f_vaddr = (unsigned long)vmf->virtual_address;
1148
1149         mutex_lock(&dev->struct_mutex);
1150
1151         ret = sprd_drm_gem_map_pages(obj, vma, f_vaddr, page_offset);
1152         if (ret < 0)
1153                 DRM_ERROR("failed to map pages.\n");
1154
1155         mutex_unlock(&dev->struct_mutex);
1156
1157         return convert_to_vm_err_msg(ret);
1158 }
1159
1160 int sprd_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma)
1161 {
1162         struct sprd_drm_gem_obj *sprd_gem_obj;
1163         struct drm_gem_object *obj;
1164         int ret;
1165
1166         /* set vm_area_struct. */
1167         ret = drm_gem_mmap(filp, vma);
1168         if (ret < 0) {
1169                 DRM_ERROR("failed to mmap.\n");
1170                 return ret;
1171         }
1172
1173         obj = vma->vm_private_data;
1174         sprd_gem_obj = to_sprd_gem_obj(obj);
1175
1176         ret = check_gem_flags(sprd_gem_obj->flags);
1177         if (ret) {
1178                 drm_gem_vm_close(vma);
1179                 drm_gem_free_mmap_offset(obj);
1180                 return ret;
1181         }
1182
1183         vma->vm_flags &= ~VM_PFNMAP;
1184         vma->vm_flags |= VM_MIXEDMAP;
1185
1186         update_vm_cache_attr(sprd_gem_obj, vma);
1187
1188         return ret;
1189 }
1190
1191 int sprd_gem_lock_handle_ioctl(struct drm_device *dev, void *data,
1192                                       struct drm_file *file_priv)
1193 {
1194         struct drm_sprd_gem_lock_handle *args = data;
1195         struct drm_gem_object *obj;
1196         struct sprd_drm_gem_obj *sprd_gem_obj;
1197         struct drm_sprd_gem_object_wait_list_entry *lock_item;
1198         int i;
1199         int result = 0;
1200
1201         DRM_DEBUG_DRIVER("%s line:%d\n", __func__, __LINE__);
1202         mutex_lock(&dev->struct_mutex);
1203
1204         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
1205
1206         if (obj == NULL) {
1207                 DRM_ERROR("Invalid GEM handle %x\n", args->handle);
1208                 result = -EBADF;
1209                 goto out_unlock;
1210         }
1211
1212         sprd_gem_obj = to_sprd_gem_obj(obj);
1213
1214         if (sprd_gem_obj->lockpid) {
1215                 /* if a pid already had it locked */
1216                 /* create and add to wait list */
1217                 for (i = 0; i < DRM_SPRD_HANDLE_WAIT_ENTRIES; i++) {
1218                         if (sprd_gem_obj->wait_entries[i].in_use == 0) {
1219                                 /* this one is empty */
1220                                 lock_item = &sprd_gem_obj->wait_entries[i];
1221                                 lock_item->in_use = 1;
1222                                 lock_item->pid = args->pid;
1223                                 INIT_LIST_HEAD((struct list_head *)
1224                                                 &sprd_gem_obj->wait_entries[i]);
1225                                 break;
1226                         }
1227                 }
1228
1229                 if (i == DRM_SPRD_HANDLE_WAIT_ENTRIES) {
1230
1231                         result =  -EFAULT;
1232                         drm_gem_object_unreference(obj);
1233                         goto out_unlock;
1234                 }
1235                 list_add_tail((struct list_head *)&lock_item->list,
1236                                 &sprd_gem_obj->wait_list);
1237                 mutex_unlock(&dev->struct_mutex);
1238                 /* here we need to block */
1239                 wait_event_interruptible_timeout(
1240                                 sprd_gem_obj->wait_entries[i].process_wait_q,
1241                                 (sprd_gem_obj->lockpid == 0),
1242                                 msecs_to_jiffies(20000));
1243                 mutex_lock(&dev->struct_mutex);
1244                 lock_item->in_use = 0;
1245         }
1246         sprd_gem_obj->lockpid = args->pid;
1247         DRM_DEBUG_DRIVER("%s lockpid:%d\n", __func__, sprd_gem_obj->lockpid);
1248
1249 out_unlock:
1250         mutex_unlock(&dev->struct_mutex);
1251
1252         return result;
1253 }
1254
1255 int sprd_gem_unlock_handle_ioctl(struct drm_device *dev, void *data,
1256                                       struct drm_file *file_priv)
1257 {
1258
1259         struct drm_sprd_gem_unlock_handle *args = data;
1260         struct drm_gem_object *obj;
1261         struct sprd_drm_gem_obj *unlock_obj;
1262         struct drm_sprd_gem_object_wait_list_entry *lock_next;
1263         int result = 0;
1264
1265         DRM_DEBUG_DRIVER("%s line:%d\n", __func__, __LINE__);
1266         mutex_lock(&dev->struct_mutex);
1267
1268         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
1269
1270         if (obj == NULL) {
1271                 DRM_ERROR("Invalid GEM handle %x\n", args->handle);
1272                 result = -EBADF;
1273                 goto out_unlock;
1274         }
1275
1276         unlock_obj = to_sprd_gem_obj(obj);
1277         if (!list_empty(&unlock_obj->wait_list)) {
1278                 lock_next =
1279                         (struct drm_sprd_gem_object_wait_list_entry *)
1280                         unlock_obj->wait_list.prev;
1281
1282                 list_del((struct list_head *)&lock_next->list);
1283
1284                 unlock_obj->lockpid = 0;
1285                 wake_up_interruptible(
1286                                 &lock_next->process_wait_q);
1287                 lock_next->pid = 0;
1288
1289         } else {
1290                 /* List is empty so set pid to 0 */
1291                 unlock_obj->lockpid = 0;
1292         }
1293         drm_gem_object_unreference(obj);
1294
1295         drm_gem_object_unreference(obj);
1296 out_unlock:
1297         mutex_unlock(&dev->struct_mutex);
1298
1299         return result;
1300 }
1301
1302 int sprd_gem_cache_op_ioctl(struct drm_device *dev, void *data,
1303                                       struct drm_file *file_priv)
1304 {
1305         struct drm_sprd_gem_cache_op *args = data;
1306         int result = 0;
1307         struct drm_gem_object *obj;
1308         struct sprd_drm_gem_obj *sprd_gem_obj;
1309         struct sprd_drm_gem_buf *buf;
1310         struct sg_table         *sgt;
1311         unsigned int cache_op = args->flags &(~SPRD_DRM_ALL_CACHE);
1312
1313         mutex_lock(&dev->struct_mutex);
1314         obj = drm_gem_object_lookup(dev, file_priv, args->gem_handle);
1315
1316         if (obj == NULL) {
1317                 DRM_ERROR("invalid handle[%d]\n", args->gem_handle);
1318                 result = -EBADF;
1319                 goto err_invalid_handle;
1320         }
1321
1322         sprd_gem_obj = to_sprd_gem_obj(obj);
1323         buf = sprd_gem_obj->buffer;
1324         sgt = buf->sgt;
1325
1326         DRM_DEBUG("%s:h[%d]s[%d]f[0x%x]a[0x%x]o[0x%x]\n",
1327                 "gc",args->gem_handle, (int)args->size, args->flags,
1328                 (int)args->usr_addr, (int)obj);
1329
1330         if (!IS_CACHABLE_BUFFER(sprd_gem_obj->flags)) {
1331                 DRM_ERROR("invalid flags[0x%x]for h[%d]\n",
1332                         sprd_gem_obj->flags, args->gem_handle);
1333                 goto out;
1334         }
1335
1336         switch (cache_op) {
1337                 case SPRD_DRM_CACHE_INV:
1338                         dma_sync_sg_for_cpu(NULL, sgt->sgl, sgt->nents,
1339                                                         DMA_FROM_DEVICE);
1340                         break;
1341                 case SPRD_DRM_CACHE_CLN:
1342                         dma_sync_sg_for_device(NULL, sgt->sgl, sgt->nents,
1343                                                         DMA_TO_DEVICE);
1344                         break;
1345                 case SPRD_DRM_CACHE_FSH:
1346                         dma_sync_sg_for_device(NULL, sgt->sgl, sgt->nents,
1347                                                         DMA_TO_DEVICE);
1348                         dma_sync_sg_for_cpu(NULL, sgt->sgl, sgt->nents,
1349                                                         DMA_FROM_DEVICE);
1350                         break;
1351                 default:
1352                         DRM_ERROR("invalid op[0x%x]for h[%d]\n", cache_op, args->gem_handle);
1353                         result = -EINVAL;
1354                         goto out;
1355         }
1356
1357 out:
1358         drm_gem_object_unreference(obj);
1359
1360 err_invalid_handle:
1361         mutex_unlock(&dev->struct_mutex);
1362         return result;
1363 }