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