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