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