drivers/gpu/drm/rockchip/rockchip_drm_gem.c

   1 /*
   2  * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd
   3  * Author:Mark Yao <mark.yao@rock-chips.com>
   4  *
   5  * This software is licensed under the terms of the GNU General Public
   6  * License version 2, as published by the Free Software Foundation, and
   7  * may be copied, distributed, and modified under those terms.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  */
  14
  15 #include <drm/drm.h>
  16 #include <drm/drmP.h>
  17 #include <drm/drm_gem.h>
  18 #include <drm/drm_sync_helper.h>
  19 #include <drm/drm_vma_manager.h>
  20 #include <drm/rockchip_drm.h>
  21
  22 #include <linux/completion.h>
  23 #include <linux/dma-attrs.h>
  24 #include <linux/dma-buf.h>
  25 #include <linux/reservation.h>
  26 #include <linux/iommu.h>
  27
  28 #include "rockchip_drm_drv.h"
  29 #include "rockchip_drm_gem.h"
  30
  31 static int rockchip_gem_iommu_map(struct rockchip_gem_object *rk_obj)
  32 {
  33         struct drm_device *drm = rk_obj->base.dev;
  34         struct rockchip_drm_private *private = drm->dev_private;
  35         int prot = IOMMU_READ | IOMMU_WRITE;
  36         ssize_t ret;
  37
  38         mutex_lock(&private->mm_lock);
  39
  40         ret = drm_mm_insert_node_generic(&private->mm, &rk_obj->mm,
  41                                          rk_obj->base.size, PAGE_SIZE,
  42                                          0, 0, 0);
  43
  44         mutex_unlock(&private->mm_lock);
  45         if (ret < 0) {
  46                 DRM_ERROR("out of I/O virtual memory: %zd\n", ret);
  47                 return ret;
  48         }
  49
  50         rk_obj->dma_addr = rk_obj->mm.start;
  51
  52         ret = iommu_map_sg(private->domain, rk_obj->dma_addr, rk_obj->sgt->sgl,
  53                            rk_obj->sgt->nents, prot);
  54         if (ret < rk_obj->base.size) {
  55                 DRM_ERROR("failed to map buffer: %zd\n", ret);
  56                 goto err_remove_node;
  57         }
  58
  59         rk_obj->size = ret;
  60
  61         return 0;
  62
  63 err_remove_node:
  64         drm_mm_remove_node(&rk_obj->mm);
  65
  66         return ret;
  67 }
  68
  69 static int rockchip_gem_iommu_unmap(struct rockchip_gem_object *rk_obj)
  70 {
  71         struct drm_device *drm = rk_obj->base.dev;
  72         struct rockchip_drm_private *private = drm->dev_private;
  73
  74         iommu_unmap(private->domain, rk_obj->dma_addr, rk_obj->size);
  75
  76         mutex_lock(&private->mm_lock);
  77
  78         drm_mm_remove_node(&rk_obj->mm);
  79
  80         mutex_unlock(&private->mm_lock);
  81
  82         return 0;
  83 }
  84
  85 static int rockchip_gem_get_pages(struct rockchip_gem_object *rk_obj)
  86 {
  87         struct drm_device *drm = rk_obj->base.dev;
  88         int ret, i;
  89         struct scatterlist *s;
  90
  91         rk_obj->pages = drm_gem_get_pages(&rk_obj->base);
  92         if (IS_ERR(rk_obj->pages))
  93                 return PTR_ERR(rk_obj->pages);
  94
  95         rk_obj->num_pages = rk_obj->base.size >> PAGE_SHIFT;
  96
  97         rk_obj->sgt = drm_prime_pages_to_sg(rk_obj->pages, rk_obj->num_pages);
  98         if (IS_ERR(rk_obj->sgt)) {
  99                 ret = PTR_ERR(rk_obj->sgt);
 100                 goto err_put_pages;
 101         }
 102
 103         /*
 104          * Fake up the SG table so that dma_sync_sg_for_device() can be used
 105          * to flush the pages associated with it.
 106          *
 107          * TODO: Replace this by drm_clflush_sg() once it can be implemented
 108          * without relying on symbols that are not exported.
 109          */
 110         for_each_sg(rk_obj->sgt->sgl, s, rk_obj->sgt->nents, i)
 111                 sg_dma_address(s) = sg_phys(s);
 112
 113         dma_sync_sg_for_device(drm->dev, rk_obj->sgt->sgl, rk_obj->sgt->nents,
 114                                DMA_TO_DEVICE);
 115
 116         return 0;
 117
 118 err_put_pages:
 119         drm_gem_put_pages(&rk_obj->base, rk_obj->pages, false, false);
 120         return ret;
 121 }
 122
 123 static void rockchip_gem_put_pages(struct rockchip_gem_object *rk_obj)
 124 {
 125         sg_free_table(rk_obj->sgt);
 126         kfree(rk_obj->sgt);
 127         drm_gem_put_pages(&rk_obj->base, rk_obj->pages, true, true);
 128 }
 129
 130 static int rockchip_gem_alloc_iommu(struct rockchip_gem_object *rk_obj,
 131                                     bool alloc_kmap)
 132 {
 133         int ret;
 134
 135         ret = rockchip_gem_get_pages(rk_obj);
 136         if (ret < 0)
 137                 return ret;
 138
 139         ret = rockchip_gem_iommu_map(rk_obj);
 140         if (ret < 0)
 141                 goto err_free;
 142
 143         if (alloc_kmap) {
 144                 rk_obj->kvaddr = vmap(rk_obj->pages, rk_obj->num_pages, VM_MAP,
 145                                       pgprot_writecombine(PAGE_KERNEL));
 146                 if (!rk_obj->kvaddr) {
 147                         DRM_ERROR("failed to vmap() buffer\n");
 148                         ret = -ENOMEM;
 149                         goto err_unmap;
 150                 }
 151         }
 152
 153         return 0;
 154
 155 err_unmap:
 156         rockchip_gem_iommu_unmap(rk_obj);
 157 err_free:
 158         rockchip_gem_put_pages(rk_obj);
 159
 160         return ret;
 161 }
 162
 163 static int rockchip_gem_alloc_dma(struct rockchip_gem_object *rk_obj,
 164                                   bool alloc_kmap)
 165 {
 166         struct drm_gem_object *obj = &rk_obj->base;
 167         struct drm_device *drm = obj->dev;
 168
 169         init_dma_attrs(&rk_obj->dma_attrs);
 170         dma_set_attr(DMA_ATTR_WRITE_COMBINE, &rk_obj->dma_attrs);
 171
 172         if (!alloc_kmap)
 173                 dma_set_attr(DMA_ATTR_NO_KERNEL_MAPPING, &rk_obj->dma_attrs);
 174
 175         rk_obj->kvaddr = dma_alloc_attrs(drm->dev, obj->size,
 176                                          &rk_obj->dma_addr, GFP_KERNEL,
 177                                          &rk_obj->dma_attrs);
 178         if (!rk_obj->kvaddr) {
 179                 DRM_ERROR("failed to allocate %zu byte dma buffer", obj->size);
 180                 return -ENOMEM;
 181         }
 182
 183         return 0;
 184 }
 185
 186 static int rockchip_gem_alloc_buf(struct rockchip_gem_object *rk_obj,
 187                                   bool alloc_kmap)
 188 {
 189         struct drm_gem_object *obj = &rk_obj->base;
 190         struct drm_device *drm = obj->dev;
 191         struct rockchip_drm_private *private = drm->dev_private;
 192
 193         if (private->domain)
 194                 return rockchip_gem_alloc_iommu(rk_obj, alloc_kmap);
 195         else
 196                 return rockchip_gem_alloc_dma(rk_obj, alloc_kmap);
 197 }
 198
 199 static void rockchip_gem_free_iommu(struct rockchip_gem_object *rk_obj)
 200 {
 201         vunmap(rk_obj->kvaddr);
 202         rockchip_gem_iommu_unmap(rk_obj);
 203         rockchip_gem_put_pages(rk_obj);
 204 }
 205
 206 static void rockchip_gem_free_dma(struct rockchip_gem_object *rk_obj)
 207 {
 208         struct drm_gem_object *obj = &rk_obj->base;
 209         struct drm_device *drm = obj->dev;
 210
 211         dma_free_attrs(drm->dev, obj->size, rk_obj->kvaddr,
 212                        rk_obj->dma_addr, &rk_obj->dma_attrs);
 213 }
 214
 215 static void rockchip_gem_free_buf(struct rockchip_gem_object *rk_obj)
 216 {
 217         if (rk_obj->pages)
 218                 rockchip_gem_free_iommu(rk_obj);
 219         else
 220                 rockchip_gem_free_dma(rk_obj);
 221 }
 222
 223 static int rockchip_drm_gem_object_mmap_iommu(struct drm_gem_object *obj,
 224                                               struct vm_area_struct *vma)
 225 {
 226         struct rockchip_gem_object *rk_obj = to_rockchip_obj(obj);
 227         unsigned int i, count = obj->size >> PAGE_SHIFT;
 228         unsigned long user_count = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
 229         unsigned long uaddr = vma->vm_start;
 230         unsigned long offset = vma->vm_pgoff;
 231         unsigned long end = user_count + offset;
 232         int ret;
 233
 234         if (user_count == 0)
 235                 return -ENXIO;
 236         if (end > count)
 237                 return -ENXIO;
 238
 239         for (i = offset; i < end; i++) {
 240                 ret = vm_insert_page(vma, uaddr, rk_obj->pages[i]);
 241                 if (ret)
 242                         return ret;
 243                 uaddr += PAGE_SIZE;
 244         }
 245
 246         return 0;
 247 }
 248
 249 static int rockchip_drm_gem_object_mmap_dma(struct drm_gem_object *obj,
 250                                             struct vm_area_struct *vma)
 251 {
 252         struct rockchip_gem_object *rk_obj = to_rockchip_obj(obj);
 253         struct drm_device *drm = obj->dev;
 254
 255         return dma_mmap_attrs(drm->dev, vma, rk_obj->kvaddr, rk_obj->dma_addr,
 256                               obj->size, &rk_obj->dma_attrs);
 257 }
 258
 259 static int rockchip_drm_gem_object_mmap(struct drm_gem_object *obj,
 260                                         struct vm_area_struct *vma)
 261 {
 262         int ret;
 263         struct rockchip_gem_object *rk_obj = to_rockchip_obj(obj);
 264
 265         /*
 266          * We allocated a struct page table for rk_obj, so clear
 267          * VM_PFNMAP flag that was set by drm_gem_mmap_obj()/drm_gem_mmap().
 268          */
 269         vma->vm_flags &= ~VM_PFNMAP;
 270
 271         if (rk_obj->pages)
 272                 ret = rockchip_drm_gem_object_mmap_iommu(obj, vma);
 273         else
 274                 ret = rockchip_drm_gem_object_mmap_dma(obj, vma);
 275
 276         if (ret)
 277                 drm_gem_vm_close(vma);
 278
 279         return ret;
 280 }
 281
 282 int rockchip_gem_mmap_buf(struct drm_gem_object *obj,
 283                           struct vm_area_struct *vma)
 284 {
 285         int ret;
 286
 287         ret = drm_gem_mmap_obj(obj, obj->size, vma);
 288         if (ret)
 289                 return ret;
 290
 291         return rockchip_drm_gem_object_mmap(obj, vma);
 292 }
 293
 294 /* drm driver mmap file operations */
 295 int rockchip_gem_mmap(struct file *filp, struct vm_area_struct *vma)
 296 {
 297         struct drm_gem_object *obj;
 298         int ret;
 299
 300         ret = drm_gem_mmap(filp, vma);
 301         if (ret)
 302                 return ret;
 303
 304         /*
 305          * Set vm_pgoff (used as a fake buffer offset by DRM) to 0 and map the
 306          * whole buffer from the start.
 307          */
 308         vma->vm_pgoff = 0;
 309
 310         obj = vma->vm_private_data;
 311
 312         return rockchip_drm_gem_object_mmap(obj, vma);
 313 }
 314
 315 static struct rockchip_gem_object *
 316 rockchip_gem_alloc_object(struct drm_device *drm, unsigned int size)
 317 {
 318         struct rockchip_gem_object *rk_obj;
 319         struct drm_gem_object *obj;
 320
 321         size = round_up(size, PAGE_SIZE);
 322
 323         rk_obj = kzalloc(sizeof(*rk_obj), GFP_KERNEL);
 324         if (!rk_obj)
 325                 return ERR_PTR(-ENOMEM);
 326
 327         obj = &rk_obj->base;
 328
 329         drm_gem_object_init(drm, obj, size);
 330
 331         return rk_obj;
 332 }
 333
 334 static void rockchip_gem_release_object(struct rockchip_gem_object *rk_obj)
 335 {
 336         drm_gem_object_release(&rk_obj->base);
 337         kfree(rk_obj);
 338 }
 339
 340 struct rockchip_gem_object *
 341 rockchip_gem_create_object(struct drm_device *drm, unsigned int size,
 342                            bool alloc_kmap)
 343 {
 344         struct rockchip_gem_object *rk_obj;
 345         int ret;
 346
 347         rk_obj = rockchip_gem_alloc_object(drm, size);
 348         if (IS_ERR(rk_obj))
 349                 return rk_obj;
 350
 351         ret = rockchip_gem_alloc_buf(rk_obj, alloc_kmap);
 352         if (ret)
 353                 goto err_free_rk_obj;
 354
 355         return rk_obj;
 356
 357 err_free_rk_obj:
 358         rockchip_gem_release_object(rk_obj);
 359         return ERR_PTR(ret);
 360 }
 361
 362 /*
 363  * rockchip_gem_free_object - (struct drm_driver)->gem_free_object callback
 364  * function
 365  */
 366 void rockchip_gem_free_object(struct drm_gem_object *obj)
 367 {
 368         struct drm_device *drm = obj->dev;
 369         struct rockchip_drm_private *private = drm->dev_private;
 370         struct rockchip_gem_object *rk_obj = to_rockchip_obj(obj);
 371
 372         if (obj->import_attach) {
 373                 if (private->domain) {
 374                         rockchip_gem_iommu_unmap(rk_obj);
 375                 } else {
 376                         dma_unmap_sg(drm->dev, rk_obj->sgt->sgl,
 377                                      rk_obj->sgt->nents, DMA_BIDIRECTIONAL);
 378                 }
 379                 drm_prime_gem_destroy(obj, rk_obj->sgt);
 380         } else {
 381                 rockchip_gem_free_buf(rk_obj);
 382         }
 383
 384 #ifdef CONFIG_DRM_DMA_SYNC
 385         drm_fence_signal_and_put(&rk_obj->acquire_fence);
 386 #endif
 387
 388         rockchip_gem_release_object(rk_obj);
 389 }
 390
 391 /*
 392  * rockchip_gem_create_with_handle - allocate an object with the given
 393  * size and create a gem handle on it
 394  *
 395  * returns a struct rockchip_gem_object* on success or ERR_PTR values
 396  * on failure.
 397  */
 398 static struct rockchip_gem_object *
 399 rockchip_gem_create_with_handle(struct drm_file *file_priv,
 400                                 struct drm_device *drm, unsigned int size,
 401                                 unsigned int *handle)
 402 {
 403         struct rockchip_gem_object *rk_obj;
 404         struct drm_gem_object *obj;
 405         int ret;
 406
 407         rk_obj = rockchip_gem_create_object(drm, size, false);
 408         if (IS_ERR(rk_obj))
 409                 return ERR_CAST(rk_obj);
 410
 411         obj = &rk_obj->base;
 412
 413         /*
 414          * allocate a id of idr table where the obj is registered
 415          * and handle has the id what user can see.
 416          */
 417         ret = drm_gem_handle_create(file_priv, obj, handle);
 418         if (ret)
 419                 goto err_handle_create;
 420
 421         /* drop reference from allocate - handle holds it now. */
 422         drm_gem_object_unreference_unlocked(obj);
 423
 424         return rk_obj;
 425
 426 err_handle_create:
 427         rockchip_gem_free_object(obj);
 428
 429         return ERR_PTR(ret);
 430 }
 431
 432 int rockchip_gem_dumb_map_offset(struct drm_file *file_priv,
 433                                  struct drm_device *dev, uint32_t handle,
 434                                  uint64_t *offset)
 435 {
 436         struct drm_gem_object *obj;
 437         int ret;
 438
 439         obj = drm_gem_object_lookup(dev, file_priv, handle);
 440         if (!obj) {
 441                 DRM_ERROR("failed to lookup gem object.\n");
 442                 return -EINVAL;
 443         }
 444
 445         ret = drm_gem_create_mmap_offset(obj);
 446         if (ret)
 447                 goto out;
 448
 449         *offset = drm_vma_node_offset_addr(&obj->vma_node);
 450         DRM_DEBUG_KMS("offset = 0x%llx\n", *offset);
 451
 452 out:
 453         drm_gem_object_unreference_unlocked(obj);
 454
 455         return 0;
 456 }
 457
 458 /*
 459  * rockchip_gem_dumb_create - (struct drm_driver)->dumb_create callback
 460  * function
 461  *
 462  * This aligns the pitch and size arguments to the minimum required. wrap
 463  * this into your own function if you need bigger alignment.
 464  */
 465 int rockchip_gem_dumb_create(struct drm_file *file_priv,
 466                              struct drm_device *dev,
 467                              struct drm_mode_create_dumb *args)
 468 {
 469         struct rockchip_gem_object *rk_obj;
 470         int min_pitch = DIV_ROUND_UP(args->width * args->bpp, 8);
 471
 472         /*
 473          * align to 64 bytes since Mali requires it.
 474          */
 475         args->pitch = ALIGN(min_pitch, 64);
 476         args->size = args->pitch * args->height;
 477
 478         rk_obj = rockchip_gem_create_with_handle(file_priv, dev, args->size,
 479                                                  &args->handle);
 480
 481         return PTR_ERR_OR_ZERO(rk_obj);
 482 }
 483
 484 int rockchip_gem_map_offset_ioctl(struct drm_device *drm, void *data,
 485                                   struct drm_file *file_priv)
 486 {
 487         struct drm_rockchip_gem_map_off *args = data;
 488
 489         return rockchip_gem_dumb_map_offset(file_priv, drm, args->handle,
 490                                             &args->offset);
 491 }
 492
 493 int rockchip_gem_create_ioctl(struct drm_device *dev, void *data,
 494                               struct drm_file *file_priv)
 495 {
 496         struct drm_rockchip_gem_create *args = data;
 497         struct rockchip_gem_object *rk_obj;
 498
 499         rk_obj = rockchip_gem_create_with_handle(file_priv, dev, args->size,
 500                                                  &args->handle);
 501         return PTR_ERR_OR_ZERO(rk_obj);
 502 }
 503
 504 static struct reservation_object *drm_gem_get_resv(struct drm_gem_object *gem)
 505 {
 506         struct dma_buf *dma_buf = gem->dma_buf;
 507         return dma_buf ? dma_buf->resv : NULL;
 508 }
 509
 510 #ifdef CONFIG_DRM_DMA_SYNC
 511 static void rockchip_gem_acquire_complete(struct drm_reservation_cb *rcb,
 512                                         void *context)
 513 {
 514         struct completion *compl = context;
 515         complete(compl);
 516 }
 517
 518 static int rockchip_gem_acquire(struct drm_device *dev,
 519                                 struct rockchip_gem_object *rockchip_gem_obj,
 520                                 bool exclusive)
 521 {
 522         struct fence *fence;
 523         struct rockchip_drm_private *dev_priv = dev->dev_private;
 524         struct reservation_object *resv =
 525                 drm_gem_get_resv(&rockchip_gem_obj->base);
 526         int ret = 0;
 527         struct drm_reservation_cb rcb;
 528         DECLARE_COMPLETION_ONSTACK(compl);
 529
 530         if (!resv)
 531                 return ret;
 532
 533         if (!exclusive &&
 534             !rockchip_gem_obj->acquire_exclusive &&
 535             rockchip_gem_obj->acquire_fence) {
 536                 atomic_inc(&rockchip_gem_obj->acquire_shared_count);
 537                 return ret;
 538         }
 539
 540         fence = drm_sw_fence_new(dev_priv->cpu_fence_context,
 541                         atomic_add_return(1, &dev_priv->cpu_fence_seqno));
 542         if (IS_ERR(fence)) {
 543                 ret = PTR_ERR(fence);
 544                 DRM_ERROR("Failed to create acquire fence %d.\n", ret);
 545                 return ret;
 546         }
 547         ww_mutex_lock(&resv->lock, NULL);
 548         if (!exclusive) {
 549                 ret = reservation_object_reserve_shared(resv);
 550                 if (ret < 0) {
 551                         DRM_ERROR("Failed to reserve space for shared fence %d.\n",
 552                                   ret);
 553                         goto resv_unlock;
 554                 }
 555         }
 556         drm_reservation_cb_init(&rcb, rockchip_gem_acquire_complete, &compl);
 557         ret = drm_reservation_cb_add(&rcb, resv, exclusive);
 558         if (ret < 0) {
 559                 DRM_ERROR("Failed to add reservation to callback %d.\n", ret);
 560                 goto resv_unlock;
 561         }
 562         drm_reservation_cb_done(&rcb);
 563         if (exclusive)
 564                 reservation_object_add_excl_fence(resv, fence);
 565         else
 566                 reservation_object_add_shared_fence(resv, fence);
 567
 568         ww_mutex_unlock(&resv->lock);
 569         mutex_unlock(&dev->struct_mutex);
 570         ret = wait_for_completion_interruptible(&compl);
 571         mutex_lock(&dev->struct_mutex);
 572         if (ret < 0) {
 573                 DRM_ERROR("Failed wait for reservation callback %d.\n", ret);
 574                 drm_reservation_cb_fini(&rcb);
 575                 /* somebody else may be already waiting on it */
 576                 drm_fence_signal_and_put(&fence);
 577                 return ret;
 578         }
 579         rockchip_gem_obj->acquire_fence = fence;
 580         rockchip_gem_obj->acquire_exclusive = exclusive;
 581         atomic_set(&rockchip_gem_obj->acquire_shared_count, 1);
 582         return ret;
 583
 584 resv_unlock:
 585         ww_mutex_unlock(&resv->lock);
 586         fence_put(fence);
 587         return ret;
 588 }
 589
 590 static void rockchip_gem_release(struct rockchip_gem_object *rockchip_gem_obj)
 591 {
 592         BUG_ON(!rockchip_gem_obj->acquire_fence);
 593         if (atomic_sub_and_test(1,
 594                         &rockchip_gem_obj->acquire_shared_count))
 595                 drm_fence_signal_and_put(&rockchip_gem_obj->acquire_fence);
 596 }
 597 #endif
 598
 599 int rockchip_gem_cpu_acquire_ioctl(struct drm_device *dev, void *data,
 600                                    struct drm_file *file)
 601 {
 602         struct drm_rockchip_gem_cpu_acquire *args = data;
 603         struct rockchip_drm_file_private *file_priv = file->driver_priv;
 604         struct drm_gem_object *obj;
 605         struct rockchip_gem_object *rockchip_gem_obj;
 606         struct rockchip_gem_object_node *gem_node;
 607         int ret = 0;
 608
 609         DRM_DEBUG_KMS("[BO:%u] flags: 0x%x\n", args->handle, args->flags);
 610
 611         mutex_lock(&dev->struct_mutex);
 612
 613         obj = drm_gem_object_lookup(dev, file, args->handle);
 614         if (!obj) {
 615                 DRM_ERROR("failed to lookup gem object.\n");
 616                 ret = -EINVAL;
 617                 goto unlock;
 618         }
 619
 620         rockchip_gem_obj = to_rockchip_obj(obj);
 621
 622         if (!drm_gem_get_resv(&rockchip_gem_obj->base)) {
 623                 /* If there is no reservation object present, there is no
 624                  * cross-process/cross-device sharing and sync is unnecessary.
 625                  */
 626                 ret = 0;
 627                 goto unref_obj;
 628         }
 629
 630 #ifdef CONFIG_DRM_DMA_SYNC
 631         ret = rockchip_gem_acquire(dev, rockchip_gem_obj,
 632                         args->flags & DRM_ROCKCHIP_GEM_CPU_ACQUIRE_EXCLUSIVE);
 633         if (ret < 0)
 634                 goto unref_obj;
 635 #endif
 636
 637         gem_node = kzalloc(sizeof(*gem_node), GFP_KERNEL);
 638         if (!gem_node) {
 639                 DRM_ERROR("Failed to allocate rockchip_drm_gem_obj_node.\n");
 640                 ret = -ENOMEM;
 641                 goto release_sync;
 642         }
 643
 644         gem_node->rockchip_gem_obj = rockchip_gem_obj;
 645         list_add(&gem_node->list, &file_priv->gem_cpu_acquire_list);
 646         mutex_unlock(&dev->struct_mutex);
 647         return 0;
 648
 649 release_sync:
 650 #ifdef CONFIG_DRM_DMA_SYNC
 651         rockchip_gem_release(rockchip_gem_obj);
 652 #endif
 653 unref_obj:
 654         drm_gem_object_unreference(obj);
 655
 656 unlock:
 657         mutex_unlock(&dev->struct_mutex);
 658         return ret;
 659 }
 660
 661 int rockchip_gem_cpu_release_ioctl(struct drm_device *dev, void *data,
 662                                    struct drm_file *file)
 663 {
 664         struct drm_rockchip_gem_cpu_release *args = data;
 665         struct rockchip_drm_file_private *file_priv = file->driver_priv;
 666         struct drm_gem_object *obj;
 667         struct rockchip_gem_object *rockchip_gem_obj;
 668         struct list_head *cur;
 669         int ret = 0;
 670
 671         DRM_DEBUG_KMS("[BO:%u]\n", args->handle);
 672
 673         mutex_lock(&dev->struct_mutex);
 674
 675         obj = drm_gem_object_lookup(dev, file, args->handle);
 676         if (!obj) {
 677                 DRM_ERROR("failed to lookup gem object.\n");
 678                 ret = -EINVAL;
 679                 goto unlock;
 680         }
 681
 682         rockchip_gem_obj = to_rockchip_obj(obj);
 683
 684         if (!drm_gem_get_resv(&rockchip_gem_obj->base)) {
 685                 /* If there is no reservation object present, there is no
 686                  * cross-process/cross-device sharing and sync is unnecessary.
 687                  */
 688                 ret = 0;
 689                 goto unref_obj;
 690         }
 691
 692         list_for_each(cur, &file_priv->gem_cpu_acquire_list) {
 693                 struct rockchip_gem_object_node *node = list_entry(
 694                                 cur, struct rockchip_gem_object_node, list);
 695                 if (node->rockchip_gem_obj == rockchip_gem_obj)
 696                         break;
 697         }
 698         if (cur == &file_priv->gem_cpu_acquire_list) {
 699                 DRM_ERROR("gem object not acquired for current process.\n");
 700                 ret = -EINVAL;
 701                 goto unref_obj;
 702         }
 703
 704 #ifdef CONFIG_DRM_DMA_SYNC
 705         rockchip_gem_release(rockchip_gem_obj);
 706 #endif
 707
 708         list_del(cur);
 709         kfree(list_entry(cur, struct rockchip_gem_object_node, list));
 710         /* unreference for the reference held since cpu_acquire_ioctl */
 711         drm_gem_object_unreference(obj);
 712         ret = 0;
 713
 714 unref_obj:
 715         /* unreference for the reference from drm_gem_object_lookup() */
 716         drm_gem_object_unreference(obj);
 717
 718 unlock:
 719         mutex_unlock(&dev->struct_mutex);
 720         return ret;
 721 }
 722
 723 /*
 724  * Allocate a sg_table for this GEM object.
 725  * Note: Both the table's contents, and the sg_table itself must be freed by
 726  *       the caller.
 727  * Returns a pointer to the newly allocated sg_table, or an ERR_PTR() error.
 728  */
 729 struct sg_table *rockchip_gem_prime_get_sg_table(struct drm_gem_object *obj)
 730 {
 731         struct rockchip_gem_object *rk_obj = to_rockchip_obj(obj);
 732         struct drm_device *drm = obj->dev;
 733         struct sg_table *sgt;
 734         int ret;
 735
 736         if (rk_obj->pages)
 737                 return drm_prime_pages_to_sg(rk_obj->pages, rk_obj->num_pages);
 738
 739         sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
 740         if (!sgt)
 741                 return ERR_PTR(-ENOMEM);
 742
 743         ret = dma_get_sgtable_attrs(drm->dev, sgt, rk_obj->kvaddr,
 744                                     rk_obj->dma_addr, obj->size,
 745                                     &rk_obj->dma_attrs);
 746         if (ret) {
 747                 DRM_ERROR("failed to allocate sgt, %d\n", ret);
 748                 kfree(sgt);
 749                 return ERR_PTR(ret);
 750         }
 751
 752         return sgt;
 753 }
 754
 755 static unsigned long rockchip_sg_get_contiguous_size(struct sg_table *sgt,
 756                                                      int count)
 757 {
 758         struct scatterlist *s;
 759         dma_addr_t expected = sg_dma_address(sgt->sgl);
 760         unsigned int i;
 761         unsigned long size = 0;
 762
 763         for_each_sg(sgt->sgl, s, count, i) {
 764                 if (sg_dma_address(s) != expected)
 765                         break;
 766                 expected = sg_dma_address(s) + sg_dma_len(s);
 767                 size += sg_dma_len(s);
 768         }
 769         return size;
 770 }
 771
 772 static int
 773 rockchip_gem_iommu_map_sg(struct drm_device *drm,
 774                           struct dma_buf_attachment *attach,
 775                           struct sg_table *sg,
 776                           struct rockchip_gem_object *rk_obj)
 777 {
 778         rk_obj->sgt = sg;
 779         return rockchip_gem_iommu_map(rk_obj);
 780 }
 781
 782 static int
 783 rockchip_gem_dma_map_sg(struct drm_device *drm,
 784                         struct dma_buf_attachment *attach,
 785                         struct sg_table *sg,
 786                         struct rockchip_gem_object *rk_obj)
 787 {
 788         int count = dma_map_sg(drm->dev, sg->sgl, sg->nents,
 789                                DMA_BIDIRECTIONAL);
 790         if (!count)
 791                 return -EINVAL;
 792
 793         if (rockchip_sg_get_contiguous_size(sg, count) < attach->dmabuf->size) {
 794                 DRM_ERROR("failed to map sg_table to contiguous linear address.\n");
 795                 dma_unmap_sg(drm->dev, sg->sgl, sg->nents,
 796                              DMA_BIDIRECTIONAL);
 797                 return -EINVAL;
 798         }
 799
 800         rk_obj->dma_addr = sg_dma_address(sg->sgl);
 801         rk_obj->sgt = sg;
 802         return 0;
 803 }
 804
 805 struct drm_gem_object *
 806 rockchip_gem_prime_import_sg_table(struct drm_device *drm,
 807                                    struct dma_buf_attachment *attach,
 808                                    struct sg_table *sg)
 809 {
 810         struct rockchip_drm_private *private = drm->dev_private;
 811         struct rockchip_gem_object *rk_obj;
 812         int ret;
 813
 814         rk_obj = rockchip_gem_alloc_object(drm, attach->dmabuf->size);
 815         if (IS_ERR(rk_obj))
 816                 return ERR_CAST(rk_obj);
 817
 818         if (private->domain)
 819                 ret = rockchip_gem_iommu_map_sg(drm, attach, sg, rk_obj);
 820         else
 821                 ret = rockchip_gem_dma_map_sg(drm, attach, sg, rk_obj);
 822
 823         if (ret < 0) {
 824                 DRM_ERROR("failed to import sg table: %d\n", ret);
 825                 goto err_free_rk_obj;
 826         }
 827
 828         return &rk_obj->base;
 829
 830 err_free_rk_obj:
 831         rockchip_gem_release_object(rk_obj);
 832         return ERR_PTR(ret);
 833 }
 834
 835 void *rockchip_gem_prime_vmap(struct drm_gem_object *obj)
 836 {
 837         struct rockchip_gem_object *rk_obj = to_rockchip_obj(obj);
 838
 839         if (rk_obj->pages)
 840                 return vmap(rk_obj->pages, rk_obj->num_pages, VM_MAP,
 841                             pgprot_writecombine(PAGE_KERNEL));
 842
 843         if (dma_get_attr(DMA_ATTR_NO_KERNEL_MAPPING, &rk_obj->dma_attrs))
 844                 return NULL;
 845
 846         return rk_obj->kvaddr;
 847 }
 848
 849 void rockchip_gem_prime_vunmap(struct drm_gem_object *obj, void *vaddr)
 850 {
 851         struct rockchip_gem_object *rk_obj = to_rockchip_obj(obj);
 852
 853         if (rk_obj->pages) {
 854                 vunmap(vaddr);
 855                 return;
 856         }
 857
 858         /* Nothing to do if allocated by DMA mapping API. */
 859 }