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