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/dma-map-ops.h>
   8 #include <linux/spinlock.h>
   9 #include <linux/shmem_fs.h>
  10 #include <linux/dma-buf.h>
  11 #include <linux/pfn_t.h>
  12
  13 #include <drm/drm_prime.h>
  14
  15 #include "msm_drv.h"
  16 #include "msm_fence.h"
  17 #include "msm_gem.h"
  18 #include "msm_gpu.h"
  19 #include "msm_mmu.h"
  20
  21 static void update_inactive(struct msm_gem_object *msm_obj);
  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         WARN_ON(!msm_gem_is_locked(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(obj->dev, 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         msm_gem_lock(obj);
 182
 183         if (WARN_ON(msm_obj->madv != MSM_MADV_WILLNEED)) {
 184                 msm_gem_unlock(obj);
 185                 return ERR_PTR(-EBUSY);
 186         }
 187
 188         p = get_pages(obj);
 189         msm_gem_unlock(obj);
 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 = msm_gem_lock_interruptible(obj);
 256         if (err) {
 257                 ret = VM_FAULT_NOPAGE;
 258                 goto out;
 259         }
 260
 261         if (WARN_ON(msm_obj->madv != MSM_MADV_WILLNEED)) {
 262                 msm_gem_unlock(obj);
 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         msm_gem_unlock(obj);
 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         int ret;
 293
 294         WARN_ON(!msm_gem_is_locked(obj));
 295
 296         /* Make it mmapable */
 297         ret = drm_gem_create_mmap_offset(obj);
 298
 299         if (ret) {
 300                 DRM_DEV_ERROR(dev->dev, "could not allocate mmap offset\n");
 301                 return 0;
 302         }
 303
 304         return drm_vma_node_offset_addr(&obj->vma_node);
 305 }
 306
 307 uint64_t msm_gem_mmap_offset(struct drm_gem_object *obj)
 308 {
 309         uint64_t offset;
 310
 311         msm_gem_lock(obj);
 312         offset = mmap_offset(obj);
 313         msm_gem_unlock(obj);
 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(!msm_gem_is_locked(obj));
 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(!msm_gem_is_locked(obj));
 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 locked */
 362 static void
 363 put_iova_spaces(struct drm_gem_object *obj)
 364 {
 365         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 366         struct msm_gem_vma *vma;
 367
 368         WARN_ON(!msm_gem_is_locked(obj));
 369
 370         list_for_each_entry(vma, &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         }
 376 }
 377
 378 /* Called with msm_obj locked */
 379 static void
 380 put_iova_vmas(struct drm_gem_object *obj)
 381 {
 382         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 383         struct msm_gem_vma *vma, *tmp;
 384
 385         WARN_ON(!msm_gem_is_locked(obj));
 386
 387         list_for_each_entry_safe(vma, tmp, &msm_obj->vmas, list) {
 388                 del_vma(vma);
 389         }
 390 }
 391
 392 static int get_iova_locked(struct drm_gem_object *obj,
 393                 struct msm_gem_address_space *aspace, uint64_t *iova,
 394                 u64 range_start, u64 range_end)
 395 {
 396         struct msm_gem_vma *vma;
 397         int ret = 0;
 398
 399         WARN_ON(!msm_gem_is_locked(obj));
 400
 401         vma = lookup_vma(obj, aspace);
 402
 403         if (!vma) {
 404                 vma = add_vma(obj, aspace);
 405                 if (IS_ERR(vma))
 406                         return PTR_ERR(vma);
 407
 408                 ret = msm_gem_init_vma(aspace, vma, obj->size >> PAGE_SHIFT,
 409                         range_start, range_end);
 410                 if (ret) {
 411                         del_vma(vma);
 412                         return ret;
 413                 }
 414         }
 415
 416         *iova = vma->iova;
 417         return 0;
 418 }
 419
 420 static int msm_gem_pin_iova(struct drm_gem_object *obj,
 421                 struct msm_gem_address_space *aspace)
 422 {
 423         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 424         struct msm_gem_vma *vma;
 425         struct page **pages;
 426         int prot = IOMMU_READ;
 427
 428         if (!(msm_obj->flags & MSM_BO_GPU_READONLY))
 429                 prot |= IOMMU_WRITE;
 430
 431         if (msm_obj->flags & MSM_BO_MAP_PRIV)
 432                 prot |= IOMMU_PRIV;
 433
 434         WARN_ON(!msm_gem_is_locked(obj));
 435
 436         if (WARN_ON(msm_obj->madv != MSM_MADV_WILLNEED))
 437                 return -EBUSY;
 438
 439         vma = lookup_vma(obj, aspace);
 440         if (WARN_ON(!vma))
 441                 return -EINVAL;
 442
 443         pages = get_pages(obj);
 444         if (IS_ERR(pages))
 445                 return PTR_ERR(pages);
 446
 447         return msm_gem_map_vma(aspace, vma, prot,
 448                         msm_obj->sgt, obj->size >> PAGE_SHIFT);
 449 }
 450
 451 static int get_and_pin_iova_range_locked(struct drm_gem_object *obj,
 452                 struct msm_gem_address_space *aspace, uint64_t *iova,
 453                 u64 range_start, u64 range_end)
 454 {
 455         u64 local;
 456         int ret;
 457
 458         WARN_ON(!msm_gem_is_locked(obj));
 459
 460         ret = get_iova_locked(obj, aspace, &local,
 461                 range_start, range_end);
 462
 463         if (!ret)
 464                 ret = msm_gem_pin_iova(obj, aspace);
 465
 466         if (!ret)
 467                 *iova = local;
 468
 469         return ret;
 470 }
 471
 472 /*
 473  * get iova and pin it. Should have a matching put
 474  * limits iova to specified range (in pages)
 475  */
 476 int msm_gem_get_and_pin_iova_range(struct drm_gem_object *obj,
 477                 struct msm_gem_address_space *aspace, uint64_t *iova,
 478                 u64 range_start, u64 range_end)
 479 {
 480         int ret;
 481
 482         msm_gem_lock(obj);
 483         ret = get_and_pin_iova_range_locked(obj, aspace, iova, range_start, range_end);
 484         msm_gem_unlock(obj);
 485
 486         return ret;
 487 }
 488
 489 int msm_gem_get_and_pin_iova_locked(struct drm_gem_object *obj,
 490                 struct msm_gem_address_space *aspace, uint64_t *iova)
 491 {
 492         return get_and_pin_iova_range_locked(obj, aspace, iova, 0, U64_MAX);
 493 }
 494
 495 /* get iova and pin it. Should have a matching put */
 496 int msm_gem_get_and_pin_iova(struct drm_gem_object *obj,
 497                 struct msm_gem_address_space *aspace, uint64_t *iova)
 498 {
 499         return msm_gem_get_and_pin_iova_range(obj, aspace, iova, 0, U64_MAX);
 500 }
 501
 502 /*
 503  * Get an iova but don't pin it. Doesn't need a put because iovas are currently
 504  * valid for the life of the object
 505  */
 506 int msm_gem_get_iova(struct drm_gem_object *obj,
 507                 struct msm_gem_address_space *aspace, uint64_t *iova)
 508 {
 509         int ret;
 510
 511         msm_gem_lock(obj);
 512         ret = get_iova_locked(obj, aspace, iova, 0, U64_MAX);
 513         msm_gem_unlock(obj);
 514
 515         return ret;
 516 }
 517
 518 /* get iova without taking a reference, used in places where you have
 519  * already done a 'msm_gem_get_and_pin_iova' or 'msm_gem_get_iova'
 520  */
 521 uint64_t msm_gem_iova(struct drm_gem_object *obj,
 522                 struct msm_gem_address_space *aspace)
 523 {
 524         struct msm_gem_vma *vma;
 525
 526         msm_gem_lock(obj);
 527         vma = lookup_vma(obj, aspace);
 528         msm_gem_unlock(obj);
 529         WARN_ON(!vma);
 530
 531         return vma ? vma->iova : 0;
 532 }
 533
 534 /*
 535  * Locked variant of msm_gem_unpin_iova()
 536  */
 537 void msm_gem_unpin_iova_locked(struct drm_gem_object *obj,
 538                 struct msm_gem_address_space *aspace)
 539 {
 540         struct msm_gem_vma *vma;
 541
 542         WARN_ON(!msm_gem_is_locked(obj));
 543
 544         vma = lookup_vma(obj, aspace);
 545
 546         if (!WARN_ON(!vma))
 547                 msm_gem_unmap_vma(aspace, vma);
 548 }
 549
 550 /*
 551  * Unpin a iova by updating the reference counts. The memory isn't actually
 552  * purged until something else (shrinker, mm_notifier, destroy, etc) decides
 553  * to get rid of it
 554  */
 555 void msm_gem_unpin_iova(struct drm_gem_object *obj,
 556                 struct msm_gem_address_space *aspace)
 557 {
 558         msm_gem_lock(obj);
 559         msm_gem_unpin_iova_locked(obj, aspace);
 560         msm_gem_unlock(obj);
 561 }
 562
 563 int msm_gem_dumb_create(struct drm_file *file, struct drm_device *dev,
 564                 struct drm_mode_create_dumb *args)
 565 {
 566         args->pitch = align_pitch(args->width, args->bpp);
 567         args->size  = PAGE_ALIGN(args->pitch * args->height);
 568         return msm_gem_new_handle(dev, file, args->size,
 569                         MSM_BO_SCANOUT | MSM_BO_WC, &args->handle, "dumb");
 570 }
 571
 572 int msm_gem_dumb_map_offset(struct drm_file *file, struct drm_device *dev,
 573                 uint32_t handle, uint64_t *offset)
 574 {
 575         struct drm_gem_object *obj;
 576         int ret = 0;
 577
 578         /* GEM does all our handle to object mapping */
 579         obj = drm_gem_object_lookup(file, handle);
 580         if (obj == NULL) {
 581                 ret = -ENOENT;
 582                 goto fail;
 583         }
 584
 585         *offset = msm_gem_mmap_offset(obj);
 586
 587         drm_gem_object_put(obj);
 588
 589 fail:
 590         return ret;
 591 }
 592
 593 static void *get_vaddr(struct drm_gem_object *obj, unsigned madv)
 594 {
 595         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 596         int ret = 0;
 597
 598         WARN_ON(!msm_gem_is_locked(obj));
 599
 600         if (obj->import_attach)
 601                 return ERR_PTR(-ENODEV);
 602
 603         if (WARN_ON(msm_obj->madv > madv)) {
 604                 DRM_DEV_ERROR(obj->dev->dev, "Invalid madv state: %u vs %u\n",
 605                         msm_obj->madv, madv);
 606                 return ERR_PTR(-EBUSY);
 607         }
 608
 609         /* increment vmap_count *before* vmap() call, so shrinker can
 610          * check vmap_count (is_vunmapable()) outside of msm_obj lock.
 611          * This guarantees that we won't try to msm_gem_vunmap() this
 612          * same object from within the vmap() call (while we already
 613          * hold msm_obj lock)
 614          */
 615         msm_obj->vmap_count++;
 616
 617         if (!msm_obj->vaddr) {
 618                 struct page **pages = get_pages(obj);
 619                 if (IS_ERR(pages)) {
 620                         ret = PTR_ERR(pages);
 621                         goto fail;
 622                 }
 623                 msm_obj->vaddr = vmap(pages, obj->size >> PAGE_SHIFT,
 624                                 VM_MAP, pgprot_writecombine(PAGE_KERNEL));
 625                 if (msm_obj->vaddr == NULL) {
 626                         ret = -ENOMEM;
 627                         goto fail;
 628                 }
 629         }
 630
 631         return msm_obj->vaddr;
 632
 633 fail:
 634         msm_obj->vmap_count--;
 635         return ERR_PTR(ret);
 636 }
 637
 638 void *msm_gem_get_vaddr_locked(struct drm_gem_object *obj)
 639 {
 640         return get_vaddr(obj, MSM_MADV_WILLNEED);
 641 }
 642
 643 void *msm_gem_get_vaddr(struct drm_gem_object *obj)
 644 {
 645         void *ret;
 646
 647         msm_gem_lock(obj);
 648         ret = msm_gem_get_vaddr_locked(obj);
 649         msm_gem_unlock(obj);
 650
 651         return ret;
 652 }
 653
 654 /*
 655  * Don't use this!  It is for the very special case of dumping
 656  * submits from GPU hangs or faults, were the bo may already
 657  * be MSM_MADV_DONTNEED, but we know the buffer is still on the
 658  * active list.
 659  */
 660 void *msm_gem_get_vaddr_active(struct drm_gem_object *obj)
 661 {
 662         return get_vaddr(obj, __MSM_MADV_PURGED);
 663 }
 664
 665 void msm_gem_put_vaddr_locked(struct drm_gem_object *obj)
 666 {
 667         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 668
 669         WARN_ON(!msm_gem_is_locked(obj));
 670         WARN_ON(msm_obj->vmap_count < 1);
 671
 672         msm_obj->vmap_count--;
 673 }
 674
 675 void msm_gem_put_vaddr(struct drm_gem_object *obj)
 676 {
 677         msm_gem_lock(obj);
 678         msm_gem_put_vaddr_locked(obj);
 679         msm_gem_unlock(obj);
 680 }
 681
 682 /* Update madvise status, returns true if not purged, else
 683  * false or -errno.
 684  */
 685 int msm_gem_madvise(struct drm_gem_object *obj, unsigned madv)
 686 {
 687         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 688
 689         msm_gem_lock(obj);
 690
 691         if (msm_obj->madv != __MSM_MADV_PURGED)
 692                 msm_obj->madv = madv;
 693
 694         madv = msm_obj->madv;
 695
 696         /* If the obj is inactive, we might need to move it
 697          * between inactive lists
 698          */
 699         if (msm_obj->active_count == 0)
 700                 update_inactive(msm_obj);
 701
 702         msm_gem_unlock(obj);
 703
 704         return (madv != __MSM_MADV_PURGED);
 705 }
 706
 707 void msm_gem_purge(struct drm_gem_object *obj)
 708 {
 709         struct drm_device *dev = obj->dev;
 710         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 711
 712         WARN_ON(!is_purgeable(msm_obj));
 713         WARN_ON(obj->import_attach);
 714
 715         put_iova_spaces(obj);
 716
 717         msm_gem_vunmap(obj);
 718
 719         put_pages(obj);
 720
 721         put_iova_vmas(obj);
 722
 723         msm_obj->madv = __MSM_MADV_PURGED;
 724
 725         drm_vma_node_unmap(&obj->vma_node, dev->anon_inode->i_mapping);
 726         drm_gem_free_mmap_offset(obj);
 727
 728         /* Our goal here is to return as much of the memory as
 729          * is possible back to the system as we are called from OOM.
 730          * To do this we must instruct the shmfs to drop all of its
 731          * backing pages, *now*.
 732          */
 733         shmem_truncate_range(file_inode(obj->filp), 0, (loff_t)-1);
 734
 735         invalidate_mapping_pages(file_inode(obj->filp)->i_mapping,
 736                         0, (loff_t)-1);
 737 }
 738
 739 void msm_gem_vunmap(struct drm_gem_object *obj)
 740 {
 741         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 742
 743         WARN_ON(!msm_gem_is_locked(obj));
 744
 745         if (!msm_obj->vaddr || WARN_ON(!is_vunmapable(msm_obj)))
 746                 return;
 747
 748         vunmap(msm_obj->vaddr);
 749         msm_obj->vaddr = NULL;
 750 }
 751
 752 /* must be called before _move_to_active().. */
 753 int msm_gem_sync_object(struct drm_gem_object *obj,
 754                 struct msm_fence_context *fctx, bool exclusive)
 755 {
 756         struct dma_resv_list *fobj;
 757         struct dma_fence *fence;
 758         int i, ret;
 759
 760         fobj = dma_resv_get_list(obj->resv);
 761         if (!fobj || (fobj->shared_count == 0)) {
 762                 fence = dma_resv_get_excl(obj->resv);
 763                 /* don't need to wait on our own fences, since ring is fifo */
 764                 if (fence && (fence->context != fctx->context)) {
 765                         ret = dma_fence_wait(fence, true);
 766                         if (ret)
 767                                 return ret;
 768                 }
 769         }
 770
 771         if (!exclusive || !fobj)
 772                 return 0;
 773
 774         for (i = 0; i < fobj->shared_count; i++) {
 775                 fence = rcu_dereference_protected(fobj->shared[i],
 776                                                 dma_resv_held(obj->resv));
 777                 if (fence->context != fctx->context) {
 778                         ret = dma_fence_wait(fence, true);
 779                         if (ret)
 780                                 return ret;
 781                 }
 782         }
 783
 784         return 0;
 785 }
 786
 787 void msm_gem_active_get(struct drm_gem_object *obj, struct msm_gpu *gpu)
 788 {
 789         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 790         struct msm_drm_private *priv = obj->dev->dev_private;
 791
 792         might_sleep();
 793         WARN_ON(!msm_gem_is_locked(obj));
 794         WARN_ON(msm_obj->madv != MSM_MADV_WILLNEED);
 795
 796         if (msm_obj->active_count++ == 0) {
 797                 mutex_lock(&priv->mm_lock);
 798                 list_del_init(&msm_obj->mm_list);
 799                 list_add_tail(&msm_obj->mm_list, &gpu->active_list);
 800                 mutex_unlock(&priv->mm_lock);
 801         }
 802 }
 803
 804 void msm_gem_active_put(struct drm_gem_object *obj)
 805 {
 806         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 807
 808         might_sleep();
 809         WARN_ON(!msm_gem_is_locked(obj));
 810
 811         if (--msm_obj->active_count == 0) {
 812                 update_inactive(msm_obj);
 813         }
 814 }
 815
 816 static void update_inactive(struct msm_gem_object *msm_obj)
 817 {
 818         struct msm_drm_private *priv = msm_obj->base.dev->dev_private;
 819
 820         mutex_lock(&priv->mm_lock);
 821         WARN_ON(msm_obj->active_count != 0);
 822
 823         list_del_init(&msm_obj->mm_list);
 824         if (msm_obj->madv == MSM_MADV_WILLNEED)
 825                 list_add_tail(&msm_obj->mm_list, &priv->inactive_willneed);
 826         else
 827                 list_add_tail(&msm_obj->mm_list, &priv->inactive_dontneed);
 828
 829         mutex_unlock(&priv->mm_lock);
 830 }
 831
 832 int msm_gem_cpu_prep(struct drm_gem_object *obj, uint32_t op, ktime_t *timeout)
 833 {
 834         bool write = !!(op & MSM_PREP_WRITE);
 835         unsigned long remain =
 836                 op & MSM_PREP_NOSYNC ? 0 : timeout_to_jiffies(timeout);
 837         long ret;
 838
 839         ret = dma_resv_wait_timeout_rcu(obj->resv, write,
 840                                                   true,  remain);
 841         if (ret == 0)
 842                 return remain == 0 ? -EBUSY : -ETIMEDOUT;
 843         else if (ret < 0)
 844                 return ret;
 845
 846         /* TODO cache maintenance */
 847
 848         return 0;
 849 }
 850
 851 int msm_gem_cpu_fini(struct drm_gem_object *obj)
 852 {
 853         /* TODO cache maintenance */
 854         return 0;
 855 }
 856
 857 #ifdef CONFIG_DEBUG_FS
 858 static void describe_fence(struct dma_fence *fence, const char *type,
 859                 struct seq_file *m)
 860 {
 861         if (!dma_fence_is_signaled(fence))
 862                 seq_printf(m, "\t%9s: %s %s seq %llu\n", type,
 863                                 fence->ops->get_driver_name(fence),
 864                                 fence->ops->get_timeline_name(fence),
 865                                 fence->seqno);
 866 }
 867
 868 void msm_gem_describe(struct drm_gem_object *obj, struct seq_file *m)
 869 {
 870         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 871         struct dma_resv *robj = obj->resv;
 872         struct dma_resv_list *fobj;
 873         struct dma_fence *fence;
 874         struct msm_gem_vma *vma;
 875         uint64_t off = drm_vma_node_start(&obj->vma_node);
 876         const char *madv;
 877
 878         msm_gem_lock(obj);
 879
 880         switch (msm_obj->madv) {
 881         case __MSM_MADV_PURGED:
 882                 madv = " purged";
 883                 break;
 884         case MSM_MADV_DONTNEED:
 885                 madv = " purgeable";
 886                 break;
 887         case MSM_MADV_WILLNEED:
 888         default:
 889                 madv = "";
 890                 break;
 891         }
 892
 893         seq_printf(m, "%08x: %c %2d (%2d) %08llx %p",
 894                         msm_obj->flags, is_active(msm_obj) ? 'A' : 'I',
 895                         obj->name, kref_read(&obj->refcount),
 896                         off, msm_obj->vaddr);
 897
 898         seq_printf(m, " %08zu %9s %-32s\n", obj->size, madv, msm_obj->name);
 899
 900         if (!list_empty(&msm_obj->vmas)) {
 901
 902                 seq_puts(m, "      vmas:");
 903
 904                 list_for_each_entry(vma, &msm_obj->vmas, list) {
 905                         const char *name, *comm;
 906                         if (vma->aspace) {
 907                                 struct msm_gem_address_space *aspace = vma->aspace;
 908                                 struct task_struct *task =
 909                                         get_pid_task(aspace->pid, PIDTYPE_PID);
 910                                 if (task) {
 911                                         comm = kstrdup(task->comm, GFP_KERNEL);
 912                                 } else {
 913                                         comm = NULL;
 914                                 }
 915                                 name = aspace->name;
 916                         } else {
 917                                 name = comm = NULL;
 918                         }
 919                         seq_printf(m, " [%s%s%s: aspace=%p, %08llx,%s,inuse=%d]",
 920                                 name, comm ? ":" : "", comm ? comm : "",
 921                                 vma->aspace, vma->iova,
 922                                 vma->mapped ? "mapped" : "unmapped",
 923                                 vma->inuse);
 924                         kfree(comm);
 925                 }
 926
 927                 seq_puts(m, "\n");
 928         }
 929
 930         rcu_read_lock();
 931         fobj = rcu_dereference(robj->fence);
 932         if (fobj) {
 933                 unsigned int i, shared_count = fobj->shared_count;
 934
 935                 for (i = 0; i < shared_count; i++) {
 936                         fence = rcu_dereference(fobj->shared[i]);
 937                         describe_fence(fence, "Shared", m);
 938                 }
 939         }
 940
 941         fence = rcu_dereference(robj->fence_excl);
 942         if (fence)
 943                 describe_fence(fence, "Exclusive", m);
 944         rcu_read_unlock();
 945
 946         msm_gem_unlock(obj);
 947 }
 948
 949 void msm_gem_describe_objects(struct list_head *list, struct seq_file *m)
 950 {
 951         struct msm_gem_object *msm_obj;
 952         int count = 0;
 953         size_t size = 0;
 954
 955         seq_puts(m, "   flags       id ref  offset   kaddr            size     madv      name\n");
 956         list_for_each_entry(msm_obj, list, mm_list) {
 957                 struct drm_gem_object *obj = &msm_obj->base;
 958                 seq_puts(m, "   ");
 959                 msm_gem_describe(obj, m);
 960                 count++;
 961                 size += obj->size;
 962         }
 963
 964         seq_printf(m, "Total %d objects, %zu bytes\n", count, size);
 965 }
 966 #endif
 967
 968 /* don't call directly!  Use drm_gem_object_put_locked() and friends */
 969 void msm_gem_free_object(struct drm_gem_object *obj)
 970 {
 971         struct msm_gem_object *msm_obj = to_msm_bo(obj);
 972         struct drm_device *dev = obj->dev;
 973         struct msm_drm_private *priv = dev->dev_private;
 974
 975         mutex_lock(&priv->mm_lock);
 976         list_del(&msm_obj->mm_list);
 977         mutex_unlock(&priv->mm_lock);
 978
 979         msm_gem_lock(obj);
 980
 981         /* object should not be on active list: */
 982         WARN_ON(is_active(msm_obj));
 983
 984         put_iova_spaces(obj);
 985
 986         if (obj->import_attach) {
 987                 WARN_ON(msm_obj->vaddr);
 988
 989                 /* Don't drop the pages for imported dmabuf, as they are not
 990                  * ours, just free the array we allocated:
 991                  */
 992                 if (msm_obj->pages)
 993                         kvfree(msm_obj->pages);
 994
 995                 put_iova_vmas(obj);
 996
 997                 /* dma_buf_detach() grabs resv lock, so we need to unlock
 998                  * prior to drm_prime_gem_destroy
 999                  */
1000                 msm_gem_unlock(obj);
1001
1002                 drm_prime_gem_destroy(obj, msm_obj->sgt);
1003         } else {
1004                 msm_gem_vunmap(obj);
1005                 put_pages(obj);
1006                 put_iova_vmas(obj);
1007                 msm_gem_unlock(obj);
1008         }
1009
1010         drm_gem_object_release(obj);
1011
1012         kfree(msm_obj);
1013 }
1014
1015 /* convenience method to construct a GEM buffer object, and userspace handle */
1016 int msm_gem_new_handle(struct drm_device *dev, struct drm_file *file,
1017                 uint32_t size, uint32_t flags, uint32_t *handle,
1018                 char *name)
1019 {
1020         struct drm_gem_object *obj;
1021         int ret;
1022
1023         obj = msm_gem_new(dev, size, flags);
1024
1025         if (IS_ERR(obj))
1026                 return PTR_ERR(obj);
1027
1028         if (name)
1029                 msm_gem_object_set_name(obj, "%s", name);
1030
1031         ret = drm_gem_handle_create(file, obj, handle);
1032
1033         /* drop reference from allocate - handle holds it now */
1034         drm_gem_object_put(obj);
1035
1036         return ret;
1037 }
1038
1039 static int msm_gem_new_impl(struct drm_device *dev,
1040                 uint32_t size, uint32_t flags,
1041                 struct drm_gem_object **obj)
1042 {
1043         struct msm_gem_object *msm_obj;
1044
1045         switch (flags & MSM_BO_CACHE_MASK) {
1046         case MSM_BO_UNCACHED:
1047         case MSM_BO_CACHED:
1048         case MSM_BO_WC:
1049                 break;
1050         default:
1051                 DRM_DEV_ERROR(dev->dev, "invalid cache flag: %x\n",
1052                                 (flags & MSM_BO_CACHE_MASK));
1053                 return -EINVAL;
1054         }
1055
1056         msm_obj = kzalloc(sizeof(*msm_obj), GFP_KERNEL);
1057         if (!msm_obj)
1058                 return -ENOMEM;
1059
1060         msm_obj->flags = flags;
1061         msm_obj->madv = MSM_MADV_WILLNEED;
1062
1063         INIT_LIST_HEAD(&msm_obj->submit_entry);
1064         INIT_LIST_HEAD(&msm_obj->vmas);
1065
1066         *obj = &msm_obj->base;
1067
1068         return 0;
1069 }
1070
1071 static struct drm_gem_object *_msm_gem_new(struct drm_device *dev,
1072                 uint32_t size, uint32_t flags, bool struct_mutex_locked)
1073 {
1074         struct msm_drm_private *priv = dev->dev_private;
1075         struct msm_gem_object *msm_obj;
1076         struct drm_gem_object *obj = NULL;
1077         bool use_vram = false;
1078         int ret;
1079
1080         size = PAGE_ALIGN(size);
1081
1082         if (!msm_use_mmu(dev))
1083                 use_vram = true;
1084         else if ((flags & (MSM_BO_STOLEN | MSM_BO_SCANOUT)) && priv->vram.size)
1085                 use_vram = true;
1086
1087         if (WARN_ON(use_vram && !priv->vram.size))
1088                 return ERR_PTR(-EINVAL);
1089
1090         /* Disallow zero sized objects as they make the underlying
1091          * infrastructure grumpy
1092          */
1093         if (size == 0)
1094                 return ERR_PTR(-EINVAL);
1095
1096         ret = msm_gem_new_impl(dev, size, flags, &obj);
1097         if (ret)
1098                 goto fail;
1099
1100         msm_obj = to_msm_bo(obj);
1101
1102         if (use_vram) {
1103                 struct msm_gem_vma *vma;
1104                 struct page **pages;
1105
1106                 drm_gem_private_object_init(dev, obj, size);
1107
1108                 msm_gem_lock(obj);
1109
1110                 vma = add_vma(obj, NULL);
1111                 msm_gem_unlock(obj);
1112                 if (IS_ERR(vma)) {
1113                         ret = PTR_ERR(vma);
1114                         goto fail;
1115                 }
1116
1117                 to_msm_bo(obj)->vram_node = &vma->node;
1118
1119                 msm_gem_lock(obj);
1120                 pages = get_pages(obj);
1121                 msm_gem_unlock(obj);
1122                 if (IS_ERR(pages)) {
1123                         ret = PTR_ERR(pages);
1124                         goto fail;
1125                 }
1126
1127                 vma->iova = physaddr(obj);
1128         } else {
1129                 ret = drm_gem_object_init(dev, obj, size);
1130                 if (ret)
1131                         goto fail;
1132                 /*
1133                  * Our buffers are kept pinned, so allocating them from the
1134                  * MOVABLE zone is a really bad idea, and conflicts with CMA.
1135                  * See comments above new_inode() why this is required _and_
1136                  * expected if you're going to pin these pages.
1137                  */
1138                 mapping_set_gfp_mask(obj->filp->f_mapping, GFP_HIGHUSER);
1139         }
1140
1141         mutex_lock(&priv->mm_lock);
1142         /* Initially obj is idle, obj->madv == WILLNEED: */
1143         list_add_tail(&msm_obj->mm_list, &priv->inactive_willneed);
1144         mutex_unlock(&priv->mm_lock);
1145
1146         return obj;
1147
1148 fail:
1149         if (struct_mutex_locked) {
1150                 drm_gem_object_put_locked(obj);
1151         } else {
1152                 drm_gem_object_put(obj);
1153         }
1154         return ERR_PTR(ret);
1155 }
1156
1157 struct drm_gem_object *msm_gem_new_locked(struct drm_device *dev,
1158                 uint32_t size, uint32_t flags)
1159 {
1160         return _msm_gem_new(dev, size, flags, true);
1161 }
1162
1163 struct drm_gem_object *msm_gem_new(struct drm_device *dev,
1164                 uint32_t size, uint32_t flags)
1165 {
1166         return _msm_gem_new(dev, size, flags, false);
1167 }
1168
1169 struct drm_gem_object *msm_gem_import(struct drm_device *dev,
1170                 struct dma_buf *dmabuf, struct sg_table *sgt)
1171 {
1172         struct msm_drm_private *priv = dev->dev_private;
1173         struct msm_gem_object *msm_obj;
1174         struct drm_gem_object *obj;
1175         uint32_t size;
1176         int ret, npages;
1177
1178         /* if we don't have IOMMU, don't bother pretending we can import: */
1179         if (!msm_use_mmu(dev)) {
1180                 DRM_DEV_ERROR(dev->dev, "cannot import without IOMMU\n");
1181                 return ERR_PTR(-EINVAL);
1182         }
1183
1184         size = PAGE_ALIGN(dmabuf->size);
1185
1186         ret = msm_gem_new_impl(dev, size, MSM_BO_WC, &obj);
1187         if (ret)
1188                 goto fail;
1189
1190         drm_gem_private_object_init(dev, obj, size);
1191
1192         npages = size / PAGE_SIZE;
1193
1194         msm_obj = to_msm_bo(obj);
1195         msm_gem_lock(obj);
1196         msm_obj->sgt = sgt;
1197         msm_obj->pages = kvmalloc_array(npages, sizeof(struct page *), GFP_KERNEL);
1198         if (!msm_obj->pages) {
1199                 msm_gem_unlock(obj);
1200                 ret = -ENOMEM;
1201                 goto fail;
1202         }
1203
1204         ret = drm_prime_sg_to_page_addr_arrays(sgt, msm_obj->pages, NULL, npages);
1205         if (ret) {
1206                 msm_gem_unlock(obj);
1207                 goto fail;
1208         }
1209
1210         msm_gem_unlock(obj);
1211
1212         mutex_lock(&priv->mm_lock);
1213         list_add_tail(&msm_obj->mm_list, &priv->inactive_willneed);
1214         mutex_unlock(&priv->mm_lock);
1215
1216         return obj;
1217
1218 fail:
1219         drm_gem_object_put(obj);
1220         return ERR_PTR(ret);
1221 }
1222
1223 static void *_msm_gem_kernel_new(struct drm_device *dev, uint32_t size,
1224                 uint32_t flags, struct msm_gem_address_space *aspace,
1225                 struct drm_gem_object **bo, uint64_t *iova, bool locked)
1226 {
1227         void *vaddr;
1228         struct drm_gem_object *obj = _msm_gem_new(dev, size, flags, locked);
1229         int ret;
1230
1231         if (IS_ERR(obj))
1232                 return ERR_CAST(obj);
1233
1234         if (iova) {
1235                 ret = msm_gem_get_and_pin_iova(obj, aspace, iova);
1236                 if (ret)
1237                         goto err;
1238         }
1239
1240         vaddr = msm_gem_get_vaddr(obj);
1241         if (IS_ERR(vaddr)) {
1242                 msm_gem_unpin_iova(obj, aspace);
1243                 ret = PTR_ERR(vaddr);
1244                 goto err;
1245         }
1246
1247         if (bo)
1248                 *bo = obj;
1249
1250         return vaddr;
1251 err:
1252         if (locked)
1253                 drm_gem_object_put_locked(obj);
1254         else
1255                 drm_gem_object_put(obj);
1256
1257         return ERR_PTR(ret);
1258
1259 }
1260
1261 void *msm_gem_kernel_new(struct drm_device *dev, uint32_t size,
1262                 uint32_t flags, struct msm_gem_address_space *aspace,
1263                 struct drm_gem_object **bo, uint64_t *iova)
1264 {
1265         return _msm_gem_kernel_new(dev, size, flags, aspace, bo, iova, false);
1266 }
1267
1268 void *msm_gem_kernel_new_locked(struct drm_device *dev, uint32_t size,
1269                 uint32_t flags, struct msm_gem_address_space *aspace,
1270                 struct drm_gem_object **bo, uint64_t *iova)
1271 {
1272         return _msm_gem_kernel_new(dev, size, flags, aspace, bo, iova, true);
1273 }
1274
1275 void msm_gem_kernel_put(struct drm_gem_object *bo,
1276                 struct msm_gem_address_space *aspace, bool locked)
1277 {
1278         if (IS_ERR_OR_NULL(bo))
1279                 return;
1280
1281         msm_gem_put_vaddr(bo);
1282         msm_gem_unpin_iova(bo, aspace);
1283
1284         if (locked)
1285                 drm_gem_object_put_locked(bo);
1286         else
1287                 drm_gem_object_put(bo);
1288 }
1289
1290 void msm_gem_object_set_name(struct drm_gem_object *bo, const char *fmt, ...)
1291 {
1292         struct msm_gem_object *msm_obj = to_msm_bo(bo);
1293         va_list ap;
1294
1295         if (!fmt)
1296                 return;
1297
1298         va_start(ap, fmt);
1299         vsnprintf(msm_obj->name, sizeof(msm_obj->name), fmt, ap);
1300         va_end(ap);
1301 }