drivers/gpu/drm/msm/msm_gem.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2013 Red Hat
   4  * Author: Rob Clark <[email protected]>
   5  */
   6
   7 #include <linux/spinlock.h>
   8 #include <linux/shmem_fs.h>
   9 #include <linux/dma-buf.h>
  10 #include <linux/pfn_t.h>
  11
  12 #include <drm/drm_prime.h>
  13
  14 #include "msm_drv.h"
  15 #include "msm_fence.h"
  16 #include "msm_gem.h"
  17 #include "msm_gpu.h"
  18 #include "msm_mmu.h"
  19
  20 static void msm_gem_vunmap_locked(struct drm_gem_object *obj);
  21
  22
  23 static dma_addr_t physaddr(struct drm_gem_object *obj)
  24 {
  25         struct msm_gem_object *msm_obj = to_msm_bo(obj);
  26         struct msm_drm_private *priv = obj->dev->dev_private;
  27         return (((dma_addr_t)msm_obj->vram_node->start) << PAGE_SHIFT) +
  28                         priv->vram.paddr;
  29 }
  30
  31 static bool use_pages(struct drm_gem_object *obj)
  32 {
  33         struct msm_gem_object *msm_obj = to_msm_bo(obj);
  34         return !msm_obj->vram_node;
  35 }
  36
  37 /*
  38  * Cache sync.. this is a bit over-complicated, to fit dma-mapping
  39  * API.  Really GPU cache is out of scope here (handled on cmdstream)
  40  * and all we need to do is invalidate newly allocated pages before
  41  * mapping to CPU as uncached/writecombine.
  42  *
  43  * On top of this, we have the added headache, that depending on
  44  * display generation, the display's iommu may be wired up to either
  45  * the toplevel drm device (mdss), or to the mdp sub-node, meaning
  46  * that here we either have dma-direct or iommu ops.
  47  *
  48  * Let this be a cautionary tail of abstraction gone wrong.
  49  */
  50
  51 static void sync_for_device(struct msm_gem_object *msm_obj)
  52 {
  53         struct device *dev = msm_obj->base.dev->dev;
  54
  55         dma_map_sg(dev, msm_obj->sgt->sgl,
  56                 msm_obj->sgt->nents, DMA_BIDIRECTIONAL);
  57 }
  58
  59 static void sync_for_cpu(struct msm_gem_object *msm_obj)
  60 {
  61         struct device *dev = msm_obj->base.dev->dev;
  62
  63         dma_unmap_sg(dev, msm_obj->sgt->sgl,
  64                 msm_obj->sgt->nents, DMA_BIDIRECTIONAL);
  65 }
  66
  67 /* allocate pages from VRAM carveout, used when no IOMMU: */
  68 static struct page **get_pages_vram(struct drm_gem_object *obj, int npages)
  69 {
  70         struct msm_gem_object *msm_obj = to_msm_bo(obj);
  71         struct msm_drm_private *priv = obj->dev->dev_private;
  72         dma_addr_t paddr;
  73         struct page **p;
  74         int ret, i;
  75
  76         p = kvmalloc_array(npages, sizeof(struct page *), GFP_KERNEL);
  77         if (!p)
  78                 return ERR_PTR(-ENOMEM);
  79
  80         spin_lock(&priv->vram.lock);
  81         ret = drm_mm_insert_node(&priv->vram.mm, msm_obj->vram_node, npages);
  82         spin_unlock(&priv->vram.lock);
  83         if (ret) {
  84                 kvfree(p);
  85                 return ERR_PTR(ret);
  86         }
  87
  88         paddr = physaddr(obj);
  89         for (i = 0; i < npages; i++) {
  90                 p[i] = phys_to_page(paddr);
  91                 paddr += PAGE_SIZE;
  92         }
  93
  94         return p;
  95 }
  96
  97 static struct page **get_pages(struct drm_gem_object *obj)
  98 {
  99         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 100
 101         if (!msm_obj->pages) {
 102                 struct drm_device *dev = obj->dev;
 103                 struct page **p;
 104                 int npages = obj->size >> PAGE_SHIFT;
 105
 106                 if (use_pages(obj))
 107                         p = drm_gem_get_pages(obj);
 108                 else
 109                         p = get_pages_vram(obj, npages);
 110
 111                 if (IS_ERR(p)) {
 112                         DRM_DEV_ERROR(dev->dev, "could not get pages: %ld\n",
 113                                         PTR_ERR(p));
 114                         return p;
 115                 }
 116
 117                 msm_obj->pages = p;
 118
 119                 msm_obj->sgt = drm_prime_pages_to_sg(p, npages);
 120                 if (IS_ERR(msm_obj->sgt)) {
 121                         void *ptr = ERR_CAST(msm_obj->sgt);
 122
 123                         DRM_DEV_ERROR(dev->dev, "failed to allocate sgt\n");
 124                         msm_obj->sgt = NULL;
 125                         return ptr;
 126                 }
 127
 128                 /* For non-cached buffers, ensure the new pages are clean
 129                  * because display controller, GPU, etc. are not coherent:
 130                  */
 131                 if (msm_obj->flags & (MSM_BO_WC|MSM_BO_UNCACHED))
 132                         sync_for_device(msm_obj);
 133         }
 134
 135         return msm_obj->pages;
 136 }
 137
 138 static void put_pages_vram(struct drm_gem_object *obj)
 139 {
 140         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 141         struct msm_drm_private *priv = obj->dev->dev_private;
 142
 143         spin_lock(&priv->vram.lock);
 144         drm_mm_remove_node(msm_obj->vram_node);
 145         spin_unlock(&priv->vram.lock);
 146
 147         kvfree(msm_obj->pages);
 148 }
 149
 150 static void put_pages(struct drm_gem_object *obj)
 151 {
 152         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 153
 154         if (msm_obj->pages) {
 155                 if (msm_obj->sgt) {
 156                         /* For non-cached buffers, ensure the new
 157                          * pages are clean because display controller,
 158                          * GPU, etc. are not coherent:
 159                          */
 160                         if (msm_obj->flags & (MSM_BO_WC|MSM_BO_UNCACHED))
 161                                 sync_for_cpu(msm_obj);
 162
 163                         sg_free_table(msm_obj->sgt);
 164                         kfree(msm_obj->sgt);
 165                 }
 166
 167                 if (use_pages(obj))
 168                         drm_gem_put_pages(obj, msm_obj->pages, true, false);
 169                 else
 170                         put_pages_vram(obj);
 171
 172                 msm_obj->pages = NULL;
 173         }
 174 }
 175
 176 struct page **msm_gem_get_pages(struct drm_gem_object *obj)
 177 {
 178         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 179         struct page **p;
 180
 181         mutex_lock(&msm_obj->lock);
 182
 183         if (WARN_ON(msm_obj->madv != MSM_MADV_WILLNEED)) {
 184                 mutex_unlock(&msm_obj->lock);
 185                 return ERR_PTR(-EBUSY);
 186         }
 187
 188         p = get_pages(obj);
 189         mutex_unlock(&msm_obj->lock);
 190         return p;
 191 }
 192
 193 void msm_gem_put_pages(struct drm_gem_object *obj)
 194 {
 195         /* when we start tracking the pin count, then do something here */
 196 }
 197
 198 int msm_gem_mmap_obj(struct drm_gem_object *obj,
 199                 struct vm_area_struct *vma)
 200 {
 201         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 202
 203         vma->vm_flags &= ~VM_PFNMAP;
 204         vma->vm_flags |= VM_MIXEDMAP;
 205
 206         if (msm_obj->flags & MSM_BO_WC) {
 207                 vma->vm_page_prot = pgprot_writecombine(vm_get_page_prot(vma->vm_flags));
 208         } else if (msm_obj->flags & MSM_BO_UNCACHED) {
 209                 vma->vm_page_prot = pgprot_noncached(vm_get_page_prot(vma->vm_flags));
 210         } else {
 211                 /*
 212                  * Shunt off cached objs to shmem file so they have their own
 213                  * address_space (so unmap_mapping_range does what we want,
 214                  * in particular in the case of mmap'd dmabufs)
 215                  */
 216                 fput(vma->vm_file);
 217                 get_file(obj->filp);
 218                 vma->vm_pgoff = 0;
 219                 vma->vm_file  = obj->filp;
 220
 221                 vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
 222         }
 223
 224         return 0;
 225 }
 226
 227 int msm_gem_mmap(struct file *filp, struct vm_area_struct *vma)
 228 {
 229         int ret;
 230
 231         ret = drm_gem_mmap(filp, vma);
 232         if (ret) {
 233                 DBG("mmap failed: %d", ret);
 234                 return ret;
 235         }
 236
 237         return msm_gem_mmap_obj(vma->vm_private_data, vma);
 238 }
 239
 240 vm_fault_t msm_gem_fault(struct vm_fault *vmf)
 241 {
 242         struct vm_area_struct *vma = vmf->vma;
 243         struct drm_gem_object *obj = vma->vm_private_data;
 244         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 245         struct page **pages;
 246         unsigned long pfn;
 247         pgoff_t pgoff;
 248         int err;
 249         vm_fault_t ret;
 250
 251         /*
 252          * vm_ops.open/drm_gem_mmap_obj and close get and put
 253          * a reference on obj. So, we dont need to hold one here.
 254          */
 255         err = mutex_lock_interruptible(&msm_obj->lock);
 256         if (err) {
 257                 ret = VM_FAULT_NOPAGE;
 258                 goto out;
 259         }
 260
 261         if (WARN_ON(msm_obj->madv != MSM_MADV_WILLNEED)) {
 262                 mutex_unlock(&msm_obj->lock);
 263                 return VM_FAULT_SIGBUS;
 264         }
 265
 266         /* make sure we have pages attached now */
 267         pages = get_pages(obj);
 268         if (IS_ERR(pages)) {
 269                 ret = vmf_error(PTR_ERR(pages));
 270                 goto out_unlock;
 271         }
 272
 273         /* We don't use vmf->pgoff since that has the fake offset: */
 274         pgoff = (vmf->address - vma->vm_start) >> PAGE_SHIFT;
 275
 276         pfn = page_to_pfn(pages[pgoff]);
 277
 278         VERB("Inserting %p pfn %lx, pa %lx", (void *)vmf->address,
 279                         pfn, pfn << PAGE_SHIFT);
 280
 281         ret = vmf_insert_mixed(vma, vmf->address, __pfn_to_pfn_t(pfn, PFN_DEV));
 282 out_unlock:
 283         mutex_unlock(&msm_obj->lock);
 284 out:
 285         return ret;
 286 }
 287
 288 /** get mmap offset */
 289 static uint64_t mmap_offset(struct drm_gem_object *obj)
 290 {
 291         struct drm_device *dev = obj->dev;
 292         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 293         int ret;
 294
 295         WARN_ON(!mutex_is_locked(&msm_obj->lock));
 296
 297         /* Make it mmapable */
 298         ret = drm_gem_create_mmap_offset(obj);
 299
 300         if (ret) {
 301                 DRM_DEV_ERROR(dev->dev, "could not allocate mmap offset\n");
 302                 return 0;
 303         }
 304
 305         return drm_vma_node_offset_addr(&obj->vma_node);
 306 }
 307
 308 uint64_t msm_gem_mmap_offset(struct drm_gem_object *obj)
 309 {
 310         uint64_t offset;
 311         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 312
 313         mutex_lock(&msm_obj->lock);
 314         offset = mmap_offset(obj);
 315         mutex_unlock(&msm_obj->lock);
 316         return offset;
 317 }
 318
 319 static struct msm_gem_vma *add_vma(struct drm_gem_object *obj,
 320                 struct msm_gem_address_space *aspace)
 321 {
 322         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 323         struct msm_gem_vma *vma;
 324
 325         WARN_ON(!mutex_is_locked(&msm_obj->lock));
 326
 327         vma = kzalloc(sizeof(*vma), GFP_KERNEL);
 328         if (!vma)
 329                 return ERR_PTR(-ENOMEM);
 330
 331         vma->aspace = aspace;
 332
 333         list_add_tail(&vma->list, &msm_obj->vmas);
 334
 335         return vma;
 336 }
 337
 338 static struct msm_gem_vma *lookup_vma(struct drm_gem_object *obj,
 339                 struct msm_gem_address_space *aspace)
 340 {
 341         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 342         struct msm_gem_vma *vma;
 343
 344         WARN_ON(!mutex_is_locked(&msm_obj->lock));
 345
 346         list_for_each_entry(vma, &msm_obj->vmas, list) {
 347                 if (vma->aspace == aspace)
 348                         return vma;
 349         }
 350
 351         return NULL;
 352 }
 353
 354 static void del_vma(struct msm_gem_vma *vma)
 355 {
 356         if (!vma)
 357                 return;
 358
 359         list_del(&vma->list);
 360         kfree(vma);
 361 }
 362
 363 /* Called with msm_obj->lock locked */
 364 static void
 365 put_iova(struct drm_gem_object *obj)
 366 {
 367         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 368         struct msm_gem_vma *vma, *tmp;
 369
 370         WARN_ON(!mutex_is_locked(&msm_obj->lock));
 371
 372         list_for_each_entry_safe(vma, tmp, &msm_obj->vmas, list) {
 373                 if (vma->aspace) {
 374                         msm_gem_purge_vma(vma->aspace, vma);
 375                         msm_gem_close_vma(vma->aspace, vma);
 376                 }
 377                 del_vma(vma);
 378         }
 379 }
 380
 381 static int msm_gem_get_iova_locked(struct drm_gem_object *obj,
 382                 struct msm_gem_address_space *aspace, uint64_t *iova,
 383                 u64 range_start, u64 range_end)
 384 {
 385         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 386         struct msm_gem_vma *vma;
 387         int ret = 0;
 388
 389         WARN_ON(!mutex_is_locked(&msm_obj->lock));
 390
 391         vma = lookup_vma(obj, aspace);
 392
 393         if (!vma) {
 394                 vma = add_vma(obj, aspace);
 395                 if (IS_ERR(vma))
 396                         return PTR_ERR(vma);
 397
 398                 ret = msm_gem_init_vma(aspace, vma, obj->size >> PAGE_SHIFT,
 399                         range_start, range_end);
 400                 if (ret) {
 401                         del_vma(vma);
 402                         return ret;
 403                 }
 404         }
 405
 406         *iova = vma->iova;
 407         return 0;
 408 }
 409
 410 static int msm_gem_pin_iova(struct drm_gem_object *obj,
 411                 struct msm_gem_address_space *aspace)
 412 {
 413         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 414         struct msm_gem_vma *vma;
 415         struct page **pages;
 416         int prot = IOMMU_READ;
 417
 418         if (!(msm_obj->flags & MSM_BO_GPU_READONLY))
 419                 prot |= IOMMU_WRITE;
 420
 421         if (msm_obj->flags & MSM_BO_MAP_PRIV)
 422                 prot |= IOMMU_PRIV;
 423
 424         WARN_ON(!mutex_is_locked(&msm_obj->lock));
 425
 426         if (WARN_ON(msm_obj->madv != MSM_MADV_WILLNEED))
 427                 return -EBUSY;
 428
 429         vma = lookup_vma(obj, aspace);
 430         if (WARN_ON(!vma))
 431                 return -EINVAL;
 432
 433         pages = get_pages(obj);
 434         if (IS_ERR(pages))
 435                 return PTR_ERR(pages);
 436
 437         return msm_gem_map_vma(aspace, vma, prot,
 438                         msm_obj->sgt, obj->size >> PAGE_SHIFT);
 439 }
 440
 441 /*
 442  * get iova and pin it. Should have a matching put
 443  * limits iova to specified range (in pages)
 444  */
 445 int msm_gem_get_and_pin_iova_range(struct drm_gem_object *obj,
 446                 struct msm_gem_address_space *aspace, uint64_t *iova,
 447                 u64 range_start, u64 range_end)
 448 {
 449         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 450         u64 local;
 451         int ret;
 452
 453         mutex_lock(&msm_obj->lock);
 454
 455         ret = msm_gem_get_iova_locked(obj, aspace, &local,
 456                 range_start, range_end);
 457
 458         if (!ret)
 459                 ret = msm_gem_pin_iova(obj, aspace);
 460
 461         if (!ret)
 462                 *iova = local;
 463
 464         mutex_unlock(&msm_obj->lock);
 465         return ret;
 466 }
 467
 468 /* get iova and pin it. Should have a matching put */
 469 int msm_gem_get_and_pin_iova(struct drm_gem_object *obj,
 470                 struct msm_gem_address_space *aspace, uint64_t *iova)
 471 {
 472         return msm_gem_get_and_pin_iova_range(obj, aspace, iova, 0, U64_MAX);
 473 }
 474
 475 /*
 476  * Get an iova but don't pin it. Doesn't need a put because iovas are currently
 477  * valid for the life of the object
 478  */
 479 int msm_gem_get_iova(struct drm_gem_object *obj,
 480                 struct msm_gem_address_space *aspace, uint64_t *iova)
 481 {
 482         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 483         int ret;
 484
 485         mutex_lock(&msm_obj->lock);
 486         ret = msm_gem_get_iova_locked(obj, aspace, iova, 0, U64_MAX);
 487         mutex_unlock(&msm_obj->lock);
 488
 489         return ret;
 490 }
 491
 492 /* get iova without taking a reference, used in places where you have
 493  * already done a 'msm_gem_get_and_pin_iova' or 'msm_gem_get_iova'
 494  */
 495 uint64_t msm_gem_iova(struct drm_gem_object *obj,
 496                 struct msm_gem_address_space *aspace)
 497 {
 498         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 499         struct msm_gem_vma *vma;
 500
 501         mutex_lock(&msm_obj->lock);
 502         vma = lookup_vma(obj, aspace);
 503         mutex_unlock(&msm_obj->lock);
 504         WARN_ON(!vma);
 505
 506         return vma ? vma->iova : 0;
 507 }
 508
 509 /*
 510  * Unpin a iova by updating the reference counts. The memory isn't actually
 511  * purged until something else (shrinker, mm_notifier, destroy, etc) decides
 512  * to get rid of it
 513  */
 514 void msm_gem_unpin_iova(struct drm_gem_object *obj,
 515                 struct msm_gem_address_space *aspace)
 516 {
 517         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 518         struct msm_gem_vma *vma;
 519
 520         mutex_lock(&msm_obj->lock);
 521         vma = lookup_vma(obj, aspace);
 522
 523         if (!WARN_ON(!vma))
 524                 msm_gem_unmap_vma(aspace, vma);
 525
 526         mutex_unlock(&msm_obj->lock);
 527 }
 528
 529 int msm_gem_dumb_create(struct drm_file *file, struct drm_device *dev,
 530                 struct drm_mode_create_dumb *args)
 531 {
 532         args->pitch = align_pitch(args->width, args->bpp);
 533         args->size  = PAGE_ALIGN(args->pitch * args->height);
 534         return msm_gem_new_handle(dev, file, args->size,
 535                         MSM_BO_SCANOUT | MSM_BO_WC, &args->handle, "dumb");
 536 }
 537
 538 int msm_gem_dumb_map_offset(struct drm_file *file, struct drm_device *dev,
 539                 uint32_t handle, uint64_t *offset)
 540 {
 541         struct drm_gem_object *obj;
 542         int ret = 0;
 543
 544         /* GEM does all our handle to object mapping */
 545         obj = drm_gem_object_lookup(file, handle);
 546         if (obj == NULL) {
 547                 ret = -ENOENT;
 548                 goto fail;
 549         }
 550
 551         *offset = msm_gem_mmap_offset(obj);
 552
 553         drm_gem_object_put(obj);
 554
 555 fail:
 556         return ret;
 557 }
 558
 559 static void *get_vaddr(struct drm_gem_object *obj, unsigned madv)
 560 {
 561         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 562         int ret = 0;
 563
 564         if (obj->import_attach)
 565                 return ERR_PTR(-ENODEV);
 566
 567         mutex_lock(&msm_obj->lock);
 568
 569         if (WARN_ON(msm_obj->madv > madv)) {
 570                 DRM_DEV_ERROR(obj->dev->dev, "Invalid madv state: %u vs %u\n",
 571                         msm_obj->madv, madv);
 572                 mutex_unlock(&msm_obj->lock);
 573                 return ERR_PTR(-EBUSY);
 574         }
 575
 576         /* increment vmap_count *before* vmap() call, so shrinker can
 577          * check vmap_count (is_vunmapable()) outside of msm_obj->lock.
 578          * This guarantees that we won't try to msm_gem_vunmap() this
 579          * same object from within the vmap() call (while we already
 580          * hold msm_obj->lock)
 581          */
 582         msm_obj->vmap_count++;
 583
 584         if (!msm_obj->vaddr) {
 585                 struct page **pages = get_pages(obj);
 586                 if (IS_ERR(pages)) {
 587                         ret = PTR_ERR(pages);
 588                         goto fail;
 589                 }
 590                 msm_obj->vaddr = vmap(pages, obj->size >> PAGE_SHIFT,
 591                                 VM_MAP, pgprot_writecombine(PAGE_KERNEL));
 592                 if (msm_obj->vaddr == NULL) {
 593                         ret = -ENOMEM;
 594                         goto fail;
 595                 }
 596         }
 597
 598         mutex_unlock(&msm_obj->lock);
 599         return msm_obj->vaddr;
 600
 601 fail:
 602         msm_obj->vmap_count--;
 603         mutex_unlock(&msm_obj->lock);
 604         return ERR_PTR(ret);
 605 }
 606
 607 void *msm_gem_get_vaddr(struct drm_gem_object *obj)
 608 {
 609         return get_vaddr(obj, MSM_MADV_WILLNEED);
 610 }
 611
 612 /*
 613  * Don't use this!  It is for the very special case of dumping
 614  * submits from GPU hangs or faults, were the bo may already
 615  * be MSM_MADV_DONTNEED, but we know the buffer is still on the
 616  * active list.
 617  */
 618 void *msm_gem_get_vaddr_active(struct drm_gem_object *obj)
 619 {
 620         return get_vaddr(obj, __MSM_MADV_PURGED);
 621 }
 622
 623 void msm_gem_put_vaddr(struct drm_gem_object *obj)
 624 {
 625         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 626
 627         mutex_lock(&msm_obj->lock);
 628         WARN_ON(msm_obj->vmap_count < 1);
 629         msm_obj->vmap_count--;
 630         mutex_unlock(&msm_obj->lock);
 631 }
 632
 633 /* Update madvise status, returns true if not purged, else
 634  * false or -errno.
 635  */
 636 int msm_gem_madvise(struct drm_gem_object *obj, unsigned madv)
 637 {
 638         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 639
 640         mutex_lock(&msm_obj->lock);
 641
 642         WARN_ON(!mutex_is_locked(&obj->dev->struct_mutex));
 643
 644         if (msm_obj->madv != __MSM_MADV_PURGED)
 645                 msm_obj->madv = madv;
 646
 647         madv = msm_obj->madv;
 648
 649         mutex_unlock(&msm_obj->lock);
 650
 651         return (madv != __MSM_MADV_PURGED);
 652 }
 653
 654 void msm_gem_purge(struct drm_gem_object *obj, enum msm_gem_lock subclass)
 655 {
 656         struct drm_device *dev = obj->dev;
 657         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 658
 659         WARN_ON(!mutex_is_locked(&dev->struct_mutex));
 660         WARN_ON(!is_purgeable(msm_obj));
 661         WARN_ON(obj->import_attach);
 662
 663         mutex_lock_nested(&msm_obj->lock, subclass);
 664
 665         put_iova(obj);
 666
 667         msm_gem_vunmap_locked(obj);
 668
 669         put_pages(obj);
 670
 671         msm_obj->madv = __MSM_MADV_PURGED;
 672
 673         drm_vma_node_unmap(&obj->vma_node, dev->anon_inode->i_mapping);
 674         drm_gem_free_mmap_offset(obj);
 675
 676         /* Our goal here is to return as much of the memory as
 677          * is possible back to the system as we are called from OOM.
 678          * To do this we must instruct the shmfs to drop all of its
 679          * backing pages, *now*.
 680          */
 681         shmem_truncate_range(file_inode(obj->filp), 0, (loff_t)-1);
 682
 683         invalidate_mapping_pages(file_inode(obj->filp)->i_mapping,
 684                         0, (loff_t)-1);
 685
 686         mutex_unlock(&msm_obj->lock);
 687 }
 688
 689 static void msm_gem_vunmap_locked(struct drm_gem_object *obj)
 690 {
 691         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 692
 693         WARN_ON(!mutex_is_locked(&msm_obj->lock));
 694
 695         if (!msm_obj->vaddr || WARN_ON(!is_vunmapable(msm_obj)))
 696                 return;
 697
 698         vunmap(msm_obj->vaddr);
 699         msm_obj->vaddr = NULL;
 700 }
 701
 702 void msm_gem_vunmap(struct drm_gem_object *obj, enum msm_gem_lock subclass)
 703 {
 704         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 705
 706         mutex_lock_nested(&msm_obj->lock, subclass);
 707         msm_gem_vunmap_locked(obj);
 708         mutex_unlock(&msm_obj->lock);
 709 }
 710
 711 /* must be called before _move_to_active().. */
 712 int msm_gem_sync_object(struct drm_gem_object *obj,
 713                 struct msm_fence_context *fctx, bool exclusive)
 714 {
 715         struct dma_resv_list *fobj;
 716         struct dma_fence *fence;
 717         int i, ret;
 718
 719         fobj = dma_resv_get_list(obj->resv);
 720         if (!fobj || (fobj->shared_count == 0)) {
 721                 fence = dma_resv_get_excl(obj->resv);
 722                 /* don't need to wait on our own fences, since ring is fifo */
 723                 if (fence && (fence->context != fctx->context)) {
 724                         ret = dma_fence_wait(fence, true);
 725                         if (ret)
 726                                 return ret;
 727                 }
 728         }
 729
 730         if (!exclusive || !fobj)
 731                 return 0;
 732
 733         for (i = 0; i < fobj->shared_count; i++) {
 734                 fence = rcu_dereference_protected(fobj->shared[i],
 735                                                 dma_resv_held(obj->resv));
 736                 if (fence->context != fctx->context) {
 737                         ret = dma_fence_wait(fence, true);
 738                         if (ret)
 739                                 return ret;
 740                 }
 741         }
 742
 743         return 0;
 744 }
 745
 746 void msm_gem_active_get(struct drm_gem_object *obj, struct msm_gpu *gpu)
 747 {
 748         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 749         WARN_ON(!mutex_is_locked(&obj->dev->struct_mutex));
 750         WARN_ON(msm_obj->madv != MSM_MADV_WILLNEED);
 751
 752         if (!atomic_fetch_inc(&msm_obj->active_count)) {
 753                 msm_obj->gpu = gpu;
 754                 list_del_init(&msm_obj->mm_list);
 755                 list_add_tail(&msm_obj->mm_list, &gpu->active_list);
 756         }
 757 }
 758
 759 void msm_gem_active_put(struct drm_gem_object *obj)
 760 {
 761         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 762         struct msm_drm_private *priv = obj->dev->dev_private;
 763
 764         WARN_ON(!mutex_is_locked(&obj->dev->struct_mutex));
 765
 766         if (!atomic_dec_return(&msm_obj->active_count)) {
 767                 msm_obj->gpu = NULL;
 768                 list_del_init(&msm_obj->mm_list);
 769                 list_add_tail(&msm_obj->mm_list, &priv->inactive_list);
 770         }
 771 }
 772
 773 int msm_gem_cpu_prep(struct drm_gem_object *obj, uint32_t op, ktime_t *timeout)
 774 {
 775         bool write = !!(op & MSM_PREP_WRITE);
 776         unsigned long remain =
 777                 op & MSM_PREP_NOSYNC ? 0 : timeout_to_jiffies(timeout);
 778         long ret;
 779
 780         ret = dma_resv_wait_timeout_rcu(obj->resv, write,
 781                                                   true,  remain);
 782         if (ret == 0)
 783                 return remain == 0 ? -EBUSY : -ETIMEDOUT;
 784         else if (ret < 0)
 785                 return ret;
 786
 787         /* TODO cache maintenance */
 788
 789         return 0;
 790 }
 791
 792 int msm_gem_cpu_fini(struct drm_gem_object *obj)
 793 {
 794         /* TODO cache maintenance */
 795         return 0;
 796 }
 797
 798 #ifdef CONFIG_DEBUG_FS
 799 static void describe_fence(struct dma_fence *fence, const char *type,
 800                 struct seq_file *m)
 801 {
 802         if (!dma_fence_is_signaled(fence))
 803                 seq_printf(m, "\t%9s: %s %s seq %llu\n", type,
 804                                 fence->ops->get_driver_name(fence),
 805                                 fence->ops->get_timeline_name(fence),
 806                                 fence->seqno);
 807 }
 808
 809 void msm_gem_describe(struct drm_gem_object *obj, struct seq_file *m)
 810 {
 811         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 812         struct dma_resv *robj = obj->resv;
 813         struct dma_resv_list *fobj;
 814         struct dma_fence *fence;
 815         struct msm_gem_vma *vma;
 816         uint64_t off = drm_vma_node_start(&obj->vma_node);
 817         const char *madv;
 818
 819         mutex_lock(&msm_obj->lock);
 820
 821         switch (msm_obj->madv) {
 822         case __MSM_MADV_PURGED:
 823                 madv = " purged";
 824                 break;
 825         case MSM_MADV_DONTNEED:
 826                 madv = " purgeable";
 827                 break;
 828         case MSM_MADV_WILLNEED:
 829         default:
 830                 madv = "";
 831                 break;
 832         }
 833
 834         seq_printf(m, "%08x: %c %2d (%2d) %08llx %p",
 835                         msm_obj->flags, is_active(msm_obj) ? 'A' : 'I',
 836                         obj->name, kref_read(&obj->refcount),
 837                         off, msm_obj->vaddr);
 838
 839         seq_printf(m, " %08zu %9s %-32s\n", obj->size, madv, msm_obj->name);
 840
 841         if (!list_empty(&msm_obj->vmas)) {
 842
 843                 seq_puts(m, "      vmas:");
 844
 845                 list_for_each_entry(vma, &msm_obj->vmas, list) {
 846                         const char *name, *comm;
 847                         if (vma->aspace) {
 848                                 struct msm_gem_address_space *aspace = vma->aspace;
 849                                 struct task_struct *task =
 850                                         get_pid_task(aspace->pid, PIDTYPE_PID);
 851                                 if (task) {
 852                                         comm = kstrdup(task->comm, GFP_KERNEL);
 853                                 } else {
 854                                         comm = NULL;
 855                                 }
 856                                 name = aspace->name;
 857                         } else {
 858                                 name = comm = NULL;
 859                         }
 860                         seq_printf(m, " [%s%s%s: aspace=%p, %08llx,%s,inuse=%d]",
 861                                 name, comm ? ":" : "", comm ? comm : "",
 862                                 vma->aspace, vma->iova,
 863                                 vma->mapped ? "mapped" : "unmapped",
 864                                 vma->inuse);
 865                         kfree(comm);
 866                 }
 867
 868                 seq_puts(m, "\n");
 869         }
 870
 871         rcu_read_lock();
 872         fobj = rcu_dereference(robj->fence);
 873         if (fobj) {
 874                 unsigned int i, shared_count = fobj->shared_count;
 875
 876                 for (i = 0; i < shared_count; i++) {
 877                         fence = rcu_dereference(fobj->shared[i]);
 878                         describe_fence(fence, "Shared", m);
 879                 }
 880         }
 881
 882         fence = rcu_dereference(robj->fence_excl);
 883         if (fence)
 884                 describe_fence(fence, "Exclusive", m);
 885         rcu_read_unlock();
 886
 887         mutex_unlock(&msm_obj->lock);
 888 }
 889
 890 void msm_gem_describe_objects(struct list_head *list, struct seq_file *m)
 891 {
 892         struct msm_gem_object *msm_obj;
 893         int count = 0;
 894         size_t size = 0;
 895
 896         seq_puts(m, "   flags       id ref  offset   kaddr            size     madv      name\n");
 897         list_for_each_entry(msm_obj, list, mm_list) {
 898                 struct drm_gem_object *obj = &msm_obj->base;
 899                 seq_puts(m, "   ");
 900                 msm_gem_describe(obj, m);
 901                 count++;
 902                 size += obj->size;
 903         }
 904
 905         seq_printf(m, "Total %d objects, %zu bytes\n", count, size);
 906 }
 907 #endif
 908
 909 /* don't call directly!  Use drm_gem_object_put_locked() and friends */
 910 void msm_gem_free_object(struct drm_gem_object *obj)
 911 {
 912         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 913         struct drm_device *dev = obj->dev;
 914         struct msm_drm_private *priv = dev->dev_private;
 915
 916         if (llist_add(&msm_obj->freed, &priv->free_list))
 917                 queue_work(priv->wq, &priv->free_work);
 918 }
 919
 920 static void free_object(struct msm_gem_object *msm_obj)
 921 {
 922         struct drm_gem_object *obj = &msm_obj->base;
 923         struct drm_device *dev = obj->dev;
 924
 925         WARN_ON(!mutex_is_locked(&dev->struct_mutex));
 926
 927         /* object should not be on active list: */
 928         WARN_ON(is_active(msm_obj));
 929
 930         list_del(&msm_obj->mm_list);
 931
 932         mutex_lock(&msm_obj->lock);
 933
 934         put_iova(obj);
 935
 936         if (obj->import_attach) {
 937                 WARN_ON(msm_obj->vaddr);
 938
 939                 /* Don't drop the pages for imported dmabuf, as they are not
 940                  * ours, just free the array we allocated:
 941                  */
 942                 if (msm_obj->pages)
 943                         kvfree(msm_obj->pages);
 944
 945                 drm_prime_gem_destroy(obj, msm_obj->sgt);
 946         } else {
 947                 msm_gem_vunmap_locked(obj);
 948                 put_pages(obj);
 949         }
 950
 951         drm_gem_object_release(obj);
 952
 953         mutex_unlock(&msm_obj->lock);
 954         kfree(msm_obj);
 955 }
 956
 957 void msm_gem_free_work(struct work_struct *work)
 958 {
 959         struct msm_drm_private *priv =
 960                 container_of(work, struct msm_drm_private, free_work);
 961         struct drm_device *dev = priv->dev;
 962         struct llist_node *freed;
 963         struct msm_gem_object *msm_obj, *next;
 964
 965         while ((freed = llist_del_all(&priv->free_list))) {
 966
 967                 mutex_lock(&dev->struct_mutex);
 968
 969                 llist_for_each_entry_safe(msm_obj, next,
 970                                           freed, freed)
 971                         free_object(msm_obj);
 972
 973                 mutex_unlock(&dev->struct_mutex);
 974
 975                 if (need_resched())
 976                         break;
 977         }
 978 }
 979
 980 /* convenience method to construct a GEM buffer object, and userspace handle */
 981 int msm_gem_new_handle(struct drm_device *dev, struct drm_file *file,
 982                 uint32_t size, uint32_t flags, uint32_t *handle,
 983                 char *name)
 984 {
 985         struct drm_gem_object *obj;
 986         int ret;
 987
 988         obj = msm_gem_new(dev, size, flags);
 989
 990         if (IS_ERR(obj))
 991                 return PTR_ERR(obj);
 992
 993         if (name)
 994                 msm_gem_object_set_name(obj, "%s", name);
 995
 996         ret = drm_gem_handle_create(file, obj, handle);
 997
 998         /* drop reference from allocate - handle holds it now */
 999         drm_gem_object_put(obj);
1000
1001         return ret;
1002 }
1003
1004 static int msm_gem_new_impl(struct drm_device *dev,
1005                 uint32_t size, uint32_t flags,
1006                 struct drm_gem_object **obj)
1007 {
1008         struct msm_gem_object *msm_obj;
1009
1010         switch (flags & MSM_BO_CACHE_MASK) {
1011         case MSM_BO_UNCACHED:
1012         case MSM_BO_CACHED:
1013         case MSM_BO_WC:
1014                 break;
1015         default:
1016                 DRM_DEV_ERROR(dev->dev, "invalid cache flag: %x\n",
1017                                 (flags & MSM_BO_CACHE_MASK));
1018                 return -EINVAL;
1019         }
1020
1021         msm_obj = kzalloc(sizeof(*msm_obj), GFP_KERNEL);
1022         if (!msm_obj)
1023                 return -ENOMEM;
1024
1025         mutex_init(&msm_obj->lock);
1026
1027         msm_obj->flags = flags;
1028         msm_obj->madv = MSM_MADV_WILLNEED;
1029
1030         INIT_LIST_HEAD(&msm_obj->submit_entry);
1031         INIT_LIST_HEAD(&msm_obj->vmas);
1032
1033         *obj = &msm_obj->base;
1034
1035         return 0;
1036 }
1037
1038 static struct drm_gem_object *_msm_gem_new(struct drm_device *dev,
1039                 uint32_t size, uint32_t flags, bool struct_mutex_locked)
1040 {
1041         struct msm_drm_private *priv = dev->dev_private;
1042         struct msm_gem_object *msm_obj;
1043         struct drm_gem_object *obj = NULL;
1044         bool use_vram = false;
1045         int ret;
1046
1047         size = PAGE_ALIGN(size);
1048
1049         if (!msm_use_mmu(dev))
1050                 use_vram = true;
1051         else if ((flags & (MSM_BO_STOLEN | MSM_BO_SCANOUT)) && priv->vram.size)
1052                 use_vram = true;
1053
1054         if (WARN_ON(use_vram && !priv->vram.size))
1055                 return ERR_PTR(-EINVAL);
1056
1057         /* Disallow zero sized objects as they make the underlying
1058          * infrastructure grumpy
1059          */
1060         if (size == 0)
1061                 return ERR_PTR(-EINVAL);
1062
1063         ret = msm_gem_new_impl(dev, size, flags, &obj);
1064         if (ret)
1065                 goto fail;
1066
1067         msm_obj = to_msm_bo(obj);
1068
1069         if (use_vram) {
1070                 struct msm_gem_vma *vma;
1071                 struct page **pages;
1072
1073                 mutex_lock(&msm_obj->lock);
1074
1075                 vma = add_vma(obj, NULL);
1076                 mutex_unlock(&msm_obj->lock);
1077                 if (IS_ERR(vma)) {
1078                         ret = PTR_ERR(vma);
1079                         goto fail;
1080                 }
1081
1082                 to_msm_bo(obj)->vram_node = &vma->node;
1083
1084                 drm_gem_private_object_init(dev, obj, size);
1085
1086                 pages = get_pages(obj);
1087                 if (IS_ERR(pages)) {
1088                         ret = PTR_ERR(pages);
1089                         goto fail;
1090                 }
1091
1092                 vma->iova = physaddr(obj);
1093         } else {
1094                 ret = drm_gem_object_init(dev, obj, size);
1095                 if (ret)
1096                         goto fail;
1097                 /*
1098                  * Our buffers are kept pinned, so allocating them from the
1099                  * MOVABLE zone is a really bad idea, and conflicts with CMA.
1100                  * See comments above new_inode() why this is required _and_
1101                  * expected if you're going to pin these pages.
1102                  */
1103                 mapping_set_gfp_mask(obj->filp->f_mapping, GFP_HIGHUSER);
1104         }
1105
1106         if (struct_mutex_locked) {
1107                 WARN_ON(!mutex_is_locked(&dev->struct_mutex));
1108                 list_add_tail(&msm_obj->mm_list, &priv->inactive_list);
1109         } else {
1110                 mutex_lock(&dev->struct_mutex);
1111                 list_add_tail(&msm_obj->mm_list, &priv->inactive_list);
1112                 mutex_unlock(&dev->struct_mutex);
1113         }
1114
1115         return obj;
1116
1117 fail:
1118         drm_gem_object_put(obj);
1119         return ERR_PTR(ret);
1120 }
1121
1122 struct drm_gem_object *msm_gem_new_locked(struct drm_device *dev,
1123                 uint32_t size, uint32_t flags)
1124 {
1125         return _msm_gem_new(dev, size, flags, true);
1126 }
1127
1128 struct drm_gem_object *msm_gem_new(struct drm_device *dev,
1129                 uint32_t size, uint32_t flags)
1130 {
1131         return _msm_gem_new(dev, size, flags, false);
1132 }
1133
1134 struct drm_gem_object *msm_gem_import(struct drm_device *dev,
1135                 struct dma_buf *dmabuf, struct sg_table *sgt)
1136 {
1137         struct msm_drm_private *priv = dev->dev_private;
1138         struct msm_gem_object *msm_obj;
1139         struct drm_gem_object *obj;
1140         uint32_t size;
1141         int ret, npages;
1142
1143         /* if we don't have IOMMU, don't bother pretending we can import: */
1144         if (!msm_use_mmu(dev)) {
1145                 DRM_DEV_ERROR(dev->dev, "cannot import without IOMMU\n");
1146                 return ERR_PTR(-EINVAL);
1147         }
1148
1149         size = PAGE_ALIGN(dmabuf->size);
1150
1151         ret = msm_gem_new_impl(dev, size, MSM_BO_WC, &obj);
1152         if (ret)
1153                 goto fail;
1154
1155         drm_gem_private_object_init(dev, obj, size);
1156
1157         npages = size / PAGE_SIZE;
1158
1159         msm_obj = to_msm_bo(obj);
1160         mutex_lock(&msm_obj->lock);
1161         msm_obj->sgt = sgt;
1162         msm_obj->pages = kvmalloc_array(npages, sizeof(struct page *), GFP_KERNEL);
1163         if (!msm_obj->pages) {
1164                 mutex_unlock(&msm_obj->lock);
1165                 ret = -ENOMEM;
1166                 goto fail;
1167         }
1168
1169         ret = drm_prime_sg_to_page_addr_arrays(sgt, msm_obj->pages, NULL, npages);
1170         if (ret) {
1171                 mutex_unlock(&msm_obj->lock);
1172                 goto fail;
1173         }
1174
1175         mutex_unlock(&msm_obj->lock);
1176
1177         mutex_lock(&dev->struct_mutex);
1178         list_add_tail(&msm_obj->mm_list, &priv->inactive_list);
1179         mutex_unlock(&dev->struct_mutex);
1180
1181         return obj;
1182
1183 fail:
1184         drm_gem_object_put(obj);
1185         return ERR_PTR(ret);
1186 }
1187
1188 static void *_msm_gem_kernel_new(struct drm_device *dev, uint32_t size,
1189                 uint32_t flags, struct msm_gem_address_space *aspace,
1190                 struct drm_gem_object **bo, uint64_t *iova, bool locked)
1191 {
1192         void *vaddr;
1193         struct drm_gem_object *obj = _msm_gem_new(dev, size, flags, locked);
1194         int ret;
1195
1196         if (IS_ERR(obj))
1197                 return ERR_CAST(obj);
1198
1199         if (iova) {
1200                 ret = msm_gem_get_and_pin_iova(obj, aspace, iova);
1201                 if (ret)
1202                         goto err;
1203         }
1204
1205         vaddr = msm_gem_get_vaddr(obj);
1206         if (IS_ERR(vaddr)) {
1207                 msm_gem_unpin_iova(obj, aspace);
1208                 ret = PTR_ERR(vaddr);
1209                 goto err;
1210         }
1211
1212         if (bo)
1213                 *bo = obj;
1214
1215         return vaddr;
1216 err:
1217         if (locked)
1218                 drm_gem_object_put_locked(obj);
1219         else
1220                 drm_gem_object_put(obj);
1221
1222         return ERR_PTR(ret);
1223
1224 }
1225
1226 void *msm_gem_kernel_new(struct drm_device *dev, uint32_t size,
1227                 uint32_t flags, struct msm_gem_address_space *aspace,
1228                 struct drm_gem_object **bo, uint64_t *iova)
1229 {
1230         return _msm_gem_kernel_new(dev, size, flags, aspace, bo, iova, false);
1231 }
1232
1233 void *msm_gem_kernel_new_locked(struct drm_device *dev, uint32_t size,
1234                 uint32_t flags, struct msm_gem_address_space *aspace,
1235                 struct drm_gem_object **bo, uint64_t *iova)
1236 {
1237         return _msm_gem_kernel_new(dev, size, flags, aspace, bo, iova, true);
1238 }
1239
1240 void msm_gem_kernel_put(struct drm_gem_object *bo,
1241                 struct msm_gem_address_space *aspace, bool locked)
1242 {
1243         if (IS_ERR_OR_NULL(bo))
1244                 return;
1245
1246         msm_gem_put_vaddr(bo);
1247         msm_gem_unpin_iova(bo, aspace);
1248
1249         if (locked)
1250                 drm_gem_object_put_locked(bo);
1251         else
1252                 drm_gem_object_put(bo);
1253 }
1254
1255 void msm_gem_object_set_name(struct drm_gem_object *bo, const char *fmt, ...)
1256 {
1257         struct msm_gem_object *msm_obj = to_msm_bo(bo);
1258         va_list ap;
1259
1260         if (!fmt)
1261                 return;
1262
1263         va_start(ap, fmt);
1264         vsnprintf(msm_obj->name, sizeof(msm_obj->name), fmt, ap);
1265         va_end(ap);
1266 }