drivers/gpu/drm/drm_gem_shmem_helper.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright 2018 Noralf Trønnes
   4  */
   5
   6 #include <linux/dma-buf.h>
   7 #include <linux/export.h>
   8 #include <linux/mutex.h>
   9 #include <linux/shmem_fs.h>
  10 #include <linux/slab.h>
  11 #include <linux/vmalloc.h>
  12
  13 #include <drm/drm.h>
  14 #include <drm/drm_device.h>
  15 #include <drm/drm_drv.h>
  16 #include <drm/drm_gem_shmem_helper.h>
  17 #include <drm/drm_prime.h>
  18 #include <drm/drm_print.h>
  19
  20 /**
  21  * DOC: overview
  22  *
  23  * This library provides helpers for GEM objects backed by shmem buffers
  24  * allocated using anonymous pageable memory.
  25  */
  26
  27 static const struct drm_gem_object_funcs drm_gem_shmem_funcs = {
  28         .free = drm_gem_shmem_free_object,
  29         .print_info = drm_gem_shmem_print_info,
  30         .pin = drm_gem_shmem_pin,
  31         .unpin = drm_gem_shmem_unpin,
  32         .get_sg_table = drm_gem_shmem_get_sg_table,
  33         .vmap = drm_gem_shmem_vmap,
  34         .vunmap = drm_gem_shmem_vunmap,
  35         .mmap = drm_gem_shmem_mmap,
  36 };
  37
  38 static struct drm_gem_shmem_object *
  39 __drm_gem_shmem_create(struct drm_device *dev, size_t size, bool private)
  40 {
  41         struct drm_gem_shmem_object *shmem;
  42         struct drm_gem_object *obj;
  43         int ret = 0;
  44
  45         size = PAGE_ALIGN(size);
  46
  47         if (dev->driver->gem_create_object)
  48                 obj = dev->driver->gem_create_object(dev, size);
  49         else
  50                 obj = kzalloc(sizeof(*shmem), GFP_KERNEL);
  51         if (!obj)
  52                 return ERR_PTR(-ENOMEM);
  53
  54         if (!obj->funcs)
  55                 obj->funcs = &drm_gem_shmem_funcs;
  56
  57         if (private)
  58                 drm_gem_private_object_init(dev, obj, size);
  59         else
  60                 ret = drm_gem_object_init(dev, obj, size);
  61         if (ret)
  62                 goto err_free;
  63
  64         ret = drm_gem_create_mmap_offset(obj);
  65         if (ret)
  66                 goto err_release;
  67
  68         shmem = to_drm_gem_shmem_obj(obj);
  69         mutex_init(&shmem->pages_lock);
  70         mutex_init(&shmem->vmap_lock);
  71         INIT_LIST_HEAD(&shmem->madv_list);
  72
  73         if (!private) {
  74                 /*
  75                  * Our buffers are kept pinned, so allocating them
  76                  * from the MOVABLE zone is a really bad idea, and
  77                  * conflicts with CMA. See comments above new_inode()
  78                  * why this is required _and_ expected if you're
  79                  * going to pin these pages.
  80                  */
  81                 mapping_set_gfp_mask(obj->filp->f_mapping, GFP_HIGHUSER |
  82                                      __GFP_RETRY_MAYFAIL | __GFP_NOWARN);
  83         }
  84
  85         return shmem;
  86
  87 err_release:
  88         drm_gem_object_release(obj);
  89 err_free:
  90         kfree(obj);
  91
  92         return ERR_PTR(ret);
  93 }
  94 /**
  95  * drm_gem_shmem_create - Allocate an object with the given size
  96  * @dev: DRM device
  97  * @size: Size of the object to allocate
  98  *
  99  * This function creates a shmem GEM object.
 100  *
 101  * Returns:
 102  * A struct drm_gem_shmem_object * on success or an ERR_PTR()-encoded negative
 103  * error code on failure.
 104  */
 105 struct drm_gem_shmem_object *drm_gem_shmem_create(struct drm_device *dev, size_t size)
 106 {
 107         return __drm_gem_shmem_create(dev, size, false);
 108 }
 109 EXPORT_SYMBOL_GPL(drm_gem_shmem_create);
 110
 111 /**
 112  * drm_gem_shmem_free_object - Free resources associated with a shmem GEM object
 113  * @obj: GEM object to free
 114  *
 115  * This function cleans up the GEM object state and frees the memory used to
 116  * store the object itself. It should be used to implement
 117  * &drm_gem_object_funcs.free.
 118  */
 119 void drm_gem_shmem_free_object(struct drm_gem_object *obj)
 120 {
 121         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 122
 123         WARN_ON(shmem->vmap_use_count);
 124
 125         if (obj->import_attach) {
 126                 drm_prime_gem_destroy(obj, shmem->sgt);
 127         } else {
 128                 if (shmem->sgt) {
 129                         dma_unmap_sgtable(obj->dev->dev, shmem->sgt,
 130                                           DMA_BIDIRECTIONAL, 0);
 131                         sg_free_table(shmem->sgt);
 132                         kfree(shmem->sgt);
 133                 }
 134                 if (shmem->pages)
 135                         drm_gem_shmem_put_pages(shmem);
 136         }
 137
 138         WARN_ON(shmem->pages_use_count);
 139
 140         drm_gem_object_release(obj);
 141         mutex_destroy(&shmem->pages_lock);
 142         mutex_destroy(&shmem->vmap_lock);
 143         kfree(shmem);
 144 }
 145 EXPORT_SYMBOL_GPL(drm_gem_shmem_free_object);
 146
 147 static int drm_gem_shmem_get_pages_locked(struct drm_gem_shmem_object *shmem)
 148 {
 149         struct drm_gem_object *obj = &shmem->base;
 150         struct page **pages;
 151
 152         if (shmem->pages_use_count++ > 0)
 153                 return 0;
 154
 155         pages = drm_gem_get_pages(obj);
 156         if (IS_ERR(pages)) {
 157                 DRM_DEBUG_KMS("Failed to get pages (%ld)\n", PTR_ERR(pages));
 158                 shmem->pages_use_count = 0;
 159                 return PTR_ERR(pages);
 160         }
 161
 162         shmem->pages = pages;
 163
 164         return 0;
 165 }
 166
 167 /*
 168  * drm_gem_shmem_get_pages - Allocate backing pages for a shmem GEM object
 169  * @shmem: shmem GEM object
 170  *
 171  * This function makes sure that backing pages exists for the shmem GEM object
 172  * and increases the use count.
 173  *
 174  * Returns:
 175  * 0 on success or a negative error code on failure.
 176  */
 177 int drm_gem_shmem_get_pages(struct drm_gem_shmem_object *shmem)
 178 {
 179         int ret;
 180
 181         WARN_ON(shmem->base.import_attach);
 182
 183         ret = mutex_lock_interruptible(&shmem->pages_lock);
 184         if (ret)
 185                 return ret;
 186         ret = drm_gem_shmem_get_pages_locked(shmem);
 187         mutex_unlock(&shmem->pages_lock);
 188
 189         return ret;
 190 }
 191 EXPORT_SYMBOL(drm_gem_shmem_get_pages);
 192
 193 static void drm_gem_shmem_put_pages_locked(struct drm_gem_shmem_object *shmem)
 194 {
 195         struct drm_gem_object *obj = &shmem->base;
 196
 197         if (WARN_ON_ONCE(!shmem->pages_use_count))
 198                 return;
 199
 200         if (--shmem->pages_use_count > 0)
 201                 return;
 202
 203         drm_gem_put_pages(obj, shmem->pages,
 204                           shmem->pages_mark_dirty_on_put,
 205                           shmem->pages_mark_accessed_on_put);
 206         shmem->pages = NULL;
 207 }
 208
 209 /*
 210  * drm_gem_shmem_put_pages - Decrease use count on the backing pages for a shmem GEM object
 211  * @shmem: shmem GEM object
 212  *
 213  * This function decreases the use count and puts the backing pages when use drops to zero.
 214  */
 215 void drm_gem_shmem_put_pages(struct drm_gem_shmem_object *shmem)
 216 {
 217         mutex_lock(&shmem->pages_lock);
 218         drm_gem_shmem_put_pages_locked(shmem);
 219         mutex_unlock(&shmem->pages_lock);
 220 }
 221 EXPORT_SYMBOL(drm_gem_shmem_put_pages);
 222
 223 /**
 224  * drm_gem_shmem_pin - Pin backing pages for a shmem GEM object
 225  * @obj: GEM object
 226  *
 227  * This function makes sure the backing pages are pinned in memory while the
 228  * buffer is exported. It should only be used to implement
 229  * &drm_gem_object_funcs.pin.
 230  *
 231  * Returns:
 232  * 0 on success or a negative error code on failure.
 233  */
 234 int drm_gem_shmem_pin(struct drm_gem_object *obj)
 235 {
 236         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 237
 238         WARN_ON(shmem->base.import_attach);
 239
 240         return drm_gem_shmem_get_pages(shmem);
 241 }
 242 EXPORT_SYMBOL(drm_gem_shmem_pin);
 243
 244 /**
 245  * drm_gem_shmem_unpin - Unpin backing pages for a shmem GEM object
 246  * @obj: GEM object
 247  *
 248  * This function removes the requirement that the backing pages are pinned in
 249  * memory. It should only be used to implement &drm_gem_object_funcs.unpin.
 250  */
 251 void drm_gem_shmem_unpin(struct drm_gem_object *obj)
 252 {
 253         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 254
 255         WARN_ON(shmem->base.import_attach);
 256
 257         drm_gem_shmem_put_pages(shmem);
 258 }
 259 EXPORT_SYMBOL(drm_gem_shmem_unpin);
 260
 261 static void *drm_gem_shmem_vmap_locked(struct drm_gem_shmem_object *shmem)
 262 {
 263         struct drm_gem_object *obj = &shmem->base;
 264         struct dma_buf_map map;
 265         int ret = 0;
 266
 267         if (shmem->vmap_use_count++ > 0)
 268                 return shmem->vaddr;
 269
 270         if (obj->import_attach) {
 271                 ret = dma_buf_vmap(obj->import_attach->dmabuf, &map);
 272                 if (!ret)
 273                         shmem->vaddr = map.vaddr;
 274         } else {
 275                 pgprot_t prot = PAGE_KERNEL;
 276
 277                 ret = drm_gem_shmem_get_pages(shmem);
 278                 if (ret)
 279                         goto err_zero_use;
 280
 281                 if (!shmem->map_cached)
 282                         prot = pgprot_writecombine(prot);
 283                 shmem->vaddr = vmap(shmem->pages, obj->size >> PAGE_SHIFT,
 284                                     VM_MAP, prot);
 285                 if (!shmem->vaddr)
 286                         ret = -ENOMEM;
 287         }
 288
 289         if (ret) {
 290                 DRM_DEBUG_KMS("Failed to vmap pages, error %d\n", ret);
 291                 goto err_put_pages;
 292         }
 293
 294         return shmem->vaddr;
 295
 296 err_put_pages:
 297         if (!obj->import_attach)
 298                 drm_gem_shmem_put_pages(shmem);
 299 err_zero_use:
 300         shmem->vmap_use_count = 0;
 301
 302         return ERR_PTR(ret);
 303 }
 304
 305 /*
 306  * drm_gem_shmem_vmap - Create a virtual mapping for a shmem GEM object
 307  * @shmem: shmem GEM object
 308  *
 309  * This function makes sure that a contiguous kernel virtual address mapping
 310  * exists for the buffer backing the shmem GEM object.
 311  *
 312  * This function can be used to implement &drm_gem_object_funcs.vmap. But it can
 313  * also be called by drivers directly, in which case it will hide the
 314  * differences between dma-buf imported and natively allocated objects.
 315  *
 316  * Acquired mappings should be cleaned up by calling drm_gem_shmem_vunmap().
 317  *
 318  * Returns:
 319  * 0 on success or a negative error code on failure.
 320  */
 321 void *drm_gem_shmem_vmap(struct drm_gem_object *obj)
 322 {
 323         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 324         void *vaddr;
 325         int ret;
 326
 327         ret = mutex_lock_interruptible(&shmem->vmap_lock);
 328         if (ret)
 329                 return ERR_PTR(ret);
 330         vaddr = drm_gem_shmem_vmap_locked(shmem);
 331         mutex_unlock(&shmem->vmap_lock);
 332
 333         return vaddr;
 334 }
 335 EXPORT_SYMBOL(drm_gem_shmem_vmap);
 336
 337 static void drm_gem_shmem_vunmap_locked(struct drm_gem_shmem_object *shmem)
 338 {
 339         struct drm_gem_object *obj = &shmem->base;
 340         struct dma_buf_map map = DMA_BUF_MAP_INIT_VADDR(shmem->vaddr);
 341
 342         if (WARN_ON_ONCE(!shmem->vmap_use_count))
 343                 return;
 344
 345         if (--shmem->vmap_use_count > 0)
 346                 return;
 347
 348         if (obj->import_attach)
 349                 dma_buf_vunmap(obj->import_attach->dmabuf, &map);
 350         else
 351                 vunmap(shmem->vaddr);
 352
 353         shmem->vaddr = NULL;
 354         drm_gem_shmem_put_pages(shmem);
 355 }
 356
 357 /*
 358  * drm_gem_shmem_vunmap - Unmap a virtual mapping fo a shmem GEM object
 359  * @shmem: shmem GEM object
 360  *
 361  * This function cleans up a kernel virtual address mapping acquired by
 362  * drm_gem_shmem_vmap(). The mapping is only removed when the use count drops to
 363  * zero.
 364  *
 365  * This function can be used to implement &drm_gem_object_funcs.vmap. But it can
 366  * also be called by drivers directly, in which case it will hide the
 367  * differences between dma-buf imported and natively allocated objects.
 368  */
 369 void drm_gem_shmem_vunmap(struct drm_gem_object *obj, void *vaddr)
 370 {
 371         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 372
 373         mutex_lock(&shmem->vmap_lock);
 374         drm_gem_shmem_vunmap_locked(shmem);
 375         mutex_unlock(&shmem->vmap_lock);
 376 }
 377 EXPORT_SYMBOL(drm_gem_shmem_vunmap);
 378
 379 struct drm_gem_shmem_object *
 380 drm_gem_shmem_create_with_handle(struct drm_file *file_priv,
 381                                  struct drm_device *dev, size_t size,
 382                                  uint32_t *handle)
 383 {
 384         struct drm_gem_shmem_object *shmem;
 385         int ret;
 386
 387         shmem = drm_gem_shmem_create(dev, size);
 388         if (IS_ERR(shmem))
 389                 return shmem;
 390
 391         /*
 392          * Allocate an id of idr table where the obj is registered
 393          * and handle has the id what user can see.
 394          */
 395         ret = drm_gem_handle_create(file_priv, &shmem->base, handle);
 396         /* drop reference from allocate - handle holds it now. */
 397         drm_gem_object_put(&shmem->base);
 398         if (ret)
 399                 return ERR_PTR(ret);
 400
 401         return shmem;
 402 }
 403 EXPORT_SYMBOL(drm_gem_shmem_create_with_handle);
 404
 405 /* Update madvise status, returns true if not purged, else
 406  * false or -errno.
 407  */
 408 int drm_gem_shmem_madvise(struct drm_gem_object *obj, int madv)
 409 {
 410         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 411
 412         mutex_lock(&shmem->pages_lock);
 413
 414         if (shmem->madv >= 0)
 415                 shmem->madv = madv;
 416
 417         madv = shmem->madv;
 418
 419         mutex_unlock(&shmem->pages_lock);
 420
 421         return (madv >= 0);
 422 }
 423 EXPORT_SYMBOL(drm_gem_shmem_madvise);
 424
 425 void drm_gem_shmem_purge_locked(struct drm_gem_object *obj)
 426 {
 427         struct drm_device *dev = obj->dev;
 428         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 429
 430         WARN_ON(!drm_gem_shmem_is_purgeable(shmem));
 431
 432         dma_unmap_sgtable(obj->dev->dev, shmem->sgt, DMA_BIDIRECTIONAL, 0);
 433         sg_free_table(shmem->sgt);
 434         kfree(shmem->sgt);
 435         shmem->sgt = NULL;
 436
 437         drm_gem_shmem_put_pages_locked(shmem);
 438
 439         shmem->madv = -1;
 440
 441         drm_vma_node_unmap(&obj->vma_node, dev->anon_inode->i_mapping);
 442         drm_gem_free_mmap_offset(obj);
 443
 444         /* Our goal here is to return as much of the memory as
 445          * is possible back to the system as we are called from OOM.
 446          * To do this we must instruct the shmfs to drop all of its
 447          * backing pages, *now*.
 448          */
 449         shmem_truncate_range(file_inode(obj->filp), 0, (loff_t)-1);
 450
 451         invalidate_mapping_pages(file_inode(obj->filp)->i_mapping,
 452                         0, (loff_t)-1);
 453 }
 454 EXPORT_SYMBOL(drm_gem_shmem_purge_locked);
 455
 456 bool drm_gem_shmem_purge(struct drm_gem_object *obj)
 457 {
 458         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 459
 460         if (!mutex_trylock(&shmem->pages_lock))
 461                 return false;
 462         drm_gem_shmem_purge_locked(obj);
 463         mutex_unlock(&shmem->pages_lock);
 464
 465         return true;
 466 }
 467 EXPORT_SYMBOL(drm_gem_shmem_purge);
 468
 469 /**
 470  * drm_gem_shmem_create_object_cached - Create a shmem buffer object with
 471  *                                      cached mappings
 472  * @dev: DRM device
 473  * @size: Size of the object to allocate
 474  *
 475  * By default, shmem buffer objects use writecombine mappings. This
 476  * function implements struct drm_driver.gem_create_object for shmem
 477  * buffer objects with cached mappings.
 478  *
 479  * Returns:
 480  * A struct drm_gem_shmem_object * on success or NULL negative on failure.
 481  */
 482 struct drm_gem_object *
 483 drm_gem_shmem_create_object_cached(struct drm_device *dev, size_t size)
 484 {
 485         struct drm_gem_shmem_object *shmem;
 486
 487         shmem = kzalloc(sizeof(*shmem), GFP_KERNEL);
 488         if (!shmem)
 489                 return NULL;
 490         shmem->map_cached = true;
 491
 492         return &shmem->base;
 493 }
 494 EXPORT_SYMBOL(drm_gem_shmem_create_object_cached);
 495
 496 /**
 497  * drm_gem_shmem_dumb_create - Create a dumb shmem buffer object
 498  * @file: DRM file structure to create the dumb buffer for
 499  * @dev: DRM device
 500  * @args: IOCTL data
 501  *
 502  * This function computes the pitch of the dumb buffer and rounds it up to an
 503  * integer number of bytes per pixel. Drivers for hardware that doesn't have
 504  * any additional restrictions on the pitch can directly use this function as
 505  * their &drm_driver.dumb_create callback.
 506  *
 507  * For hardware with additional restrictions, drivers can adjust the fields
 508  * set up by userspace before calling into this function.
 509  *
 510  * Returns:
 511  * 0 on success or a negative error code on failure.
 512  */
 513 int drm_gem_shmem_dumb_create(struct drm_file *file, struct drm_device *dev,
 514                               struct drm_mode_create_dumb *args)
 515 {
 516         u32 min_pitch = DIV_ROUND_UP(args->width * args->bpp, 8);
 517         struct drm_gem_shmem_object *shmem;
 518
 519         if (!args->pitch || !args->size) {
 520                 args->pitch = min_pitch;
 521                 args->size = args->pitch * args->height;
 522         } else {
 523                 /* ensure sane minimum values */
 524                 if (args->pitch < min_pitch)
 525                         args->pitch = min_pitch;
 526                 if (args->size < args->pitch * args->height)
 527                         args->size = args->pitch * args->height;
 528         }
 529
 530         shmem = drm_gem_shmem_create_with_handle(file, dev, args->size, &args->handle);
 531
 532         return PTR_ERR_OR_ZERO(shmem);
 533 }
 534 EXPORT_SYMBOL_GPL(drm_gem_shmem_dumb_create);
 535
 536 static vm_fault_t drm_gem_shmem_fault(struct vm_fault *vmf)
 537 {
 538         struct vm_area_struct *vma = vmf->vma;
 539         struct drm_gem_object *obj = vma->vm_private_data;
 540         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 541         loff_t num_pages = obj->size >> PAGE_SHIFT;
 542         struct page *page;
 543
 544         if (vmf->pgoff >= num_pages || WARN_ON_ONCE(!shmem->pages))
 545                 return VM_FAULT_SIGBUS;
 546
 547         page = shmem->pages[vmf->pgoff];
 548
 549         return vmf_insert_page(vma, vmf->address, page);
 550 }
 551
 552 static void drm_gem_shmem_vm_open(struct vm_area_struct *vma)
 553 {
 554         struct drm_gem_object *obj = vma->vm_private_data;
 555         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 556         int ret;
 557
 558         WARN_ON(shmem->base.import_attach);
 559
 560         ret = drm_gem_shmem_get_pages(shmem);
 561         WARN_ON_ONCE(ret != 0);
 562
 563         drm_gem_vm_open(vma);
 564 }
 565
 566 static void drm_gem_shmem_vm_close(struct vm_area_struct *vma)
 567 {
 568         struct drm_gem_object *obj = vma->vm_private_data;
 569         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 570
 571         drm_gem_shmem_put_pages(shmem);
 572         drm_gem_vm_close(vma);
 573 }
 574
 575 static const struct vm_operations_struct drm_gem_shmem_vm_ops = {
 576         .fault = drm_gem_shmem_fault,
 577         .open = drm_gem_shmem_vm_open,
 578         .close = drm_gem_shmem_vm_close,
 579 };
 580
 581 /**
 582  * drm_gem_shmem_mmap - Memory-map a shmem GEM object
 583  * @obj: gem object
 584  * @vma: VMA for the area to be mapped
 585  *
 586  * This function implements an augmented version of the GEM DRM file mmap
 587  * operation for shmem objects. Drivers which employ the shmem helpers should
 588  * use this function as their &drm_gem_object_funcs.mmap handler.
 589  *
 590  * Returns:
 591  * 0 on success or a negative error code on failure.
 592  */
 593 int drm_gem_shmem_mmap(struct drm_gem_object *obj, struct vm_area_struct *vma)
 594 {
 595         struct drm_gem_shmem_object *shmem;
 596         int ret;
 597
 598         /* Remove the fake offset */
 599         vma->vm_pgoff -= drm_vma_node_start(&obj->vma_node);
 600
 601         if (obj->import_attach) {
 602                 /* Drop the reference drm_gem_mmap_obj() acquired.*/
 603                 drm_gem_object_put(obj);
 604                 vma->vm_private_data = NULL;
 605
 606                 return dma_buf_mmap(obj->dma_buf, vma, 0);
 607         }
 608
 609         shmem = to_drm_gem_shmem_obj(obj);
 610
 611         ret = drm_gem_shmem_get_pages(shmem);
 612         if (ret) {
 613                 drm_gem_vm_close(vma);
 614                 return ret;
 615         }
 616
 617         vma->vm_flags |= VM_MIXEDMAP | VM_DONTEXPAND;
 618         vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
 619         if (!shmem->map_cached)
 620                 vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
 621         vma->vm_ops = &drm_gem_shmem_vm_ops;
 622
 623         return 0;
 624 }
 625 EXPORT_SYMBOL_GPL(drm_gem_shmem_mmap);
 626
 627 /**
 628  * drm_gem_shmem_print_info() - Print &drm_gem_shmem_object info for debugfs
 629  * @p: DRM printer
 630  * @indent: Tab indentation level
 631  * @obj: GEM object
 632  *
 633  * This implements the &drm_gem_object_funcs.info callback.
 634  */
 635 void drm_gem_shmem_print_info(struct drm_printer *p, unsigned int indent,
 636                               const struct drm_gem_object *obj)
 637 {
 638         const struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 639
 640         drm_printf_indent(p, indent, "pages_use_count=%u\n", shmem->pages_use_count);
 641         drm_printf_indent(p, indent, "vmap_use_count=%u\n", shmem->vmap_use_count);
 642         drm_printf_indent(p, indent, "vaddr=%p\n", shmem->vaddr);
 643 }
 644 EXPORT_SYMBOL(drm_gem_shmem_print_info);
 645
 646 /**
 647  * drm_gem_shmem_get_sg_table - Provide a scatter/gather table of pinned
 648  *                              pages for a shmem GEM object
 649  * @obj: GEM object
 650  *
 651  * This function exports a scatter/gather table suitable for PRIME usage by
 652  * calling the standard DMA mapping API. Drivers should not call this function
 653  * directly, instead it should only be used as an implementation for
 654  * &drm_gem_object_funcs.get_sg_table.
 655  *
 656  * Drivers who need to acquire an scatter/gather table for objects need to call
 657  * drm_gem_shmem_get_pages_sgt() instead.
 658  *
 659  * Returns:
 660  * A pointer to the scatter/gather table of pinned pages or NULL on failure.
 661  */
 662 struct sg_table *drm_gem_shmem_get_sg_table(struct drm_gem_object *obj)
 663 {
 664         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 665
 666         WARN_ON(shmem->base.import_attach);
 667
 668         return drm_prime_pages_to_sg(obj->dev, shmem->pages, obj->size >> PAGE_SHIFT);
 669 }
 670 EXPORT_SYMBOL_GPL(drm_gem_shmem_get_sg_table);
 671
 672 /**
 673  * drm_gem_shmem_get_pages_sgt - Pin pages, dma map them, and return a
 674  *                               scatter/gather table for a shmem GEM object.
 675  * @obj: GEM object
 676  *
 677  * This function returns a scatter/gather table suitable for driver usage. If
 678  * the sg table doesn't exist, the pages are pinned, dma-mapped, and a sg
 679  * table created.
 680  *
 681  * This is the main function for drivers to get at backing storage, and it hides
 682  * and difference between dma-buf imported and natively allocated objects.
 683  * drm_gem_shmem_get_sg_table() should not be directly called by drivers.
 684  *
 685  * Returns:
 686  * A pointer to the scatter/gather table of pinned pages or errno on failure.
 687  */
 688 struct sg_table *drm_gem_shmem_get_pages_sgt(struct drm_gem_object *obj)
 689 {
 690         int ret;
 691         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 692         struct sg_table *sgt;
 693
 694         if (shmem->sgt)
 695                 return shmem->sgt;
 696
 697         WARN_ON(obj->import_attach);
 698
 699         ret = drm_gem_shmem_get_pages(shmem);
 700         if (ret)
 701                 return ERR_PTR(ret);
 702
 703         sgt = drm_gem_shmem_get_sg_table(&shmem->base);
 704         if (IS_ERR(sgt)) {
 705                 ret = PTR_ERR(sgt);
 706                 goto err_put_pages;
 707         }
 708         /* Map the pages for use by the h/w. */
 709         ret = dma_map_sgtable(obj->dev->dev, sgt, DMA_BIDIRECTIONAL, 0);
 710         if (ret)
 711                 goto err_free_sgt;
 712
 713         shmem->sgt = sgt;
 714
 715         return sgt;
 716
 717 err_free_sgt:
 718         sg_free_table(sgt);
 719         kfree(sgt);
 720 err_put_pages:
 721         drm_gem_shmem_put_pages(shmem);
 722         return ERR_PTR(ret);
 723 }
 724 EXPORT_SYMBOL_GPL(drm_gem_shmem_get_pages_sgt);
 725
 726 /**
 727  * drm_gem_shmem_prime_import_sg_table - Produce a shmem GEM object from
 728  *                 another driver's scatter/gather table of pinned pages
 729  * @dev: Device to import into
 730  * @attach: DMA-BUF attachment
 731  * @sgt: Scatter/gather table of pinned pages
 732  *
 733  * This function imports a scatter/gather table exported via DMA-BUF by
 734  * another driver. Drivers that use the shmem helpers should set this as their
 735  * &drm_driver.gem_prime_import_sg_table callback.
 736  *
 737  * Returns:
 738  * A pointer to a newly created GEM object or an ERR_PTR-encoded negative
 739  * error code on failure.
 740  */
 741 struct drm_gem_object *
 742 drm_gem_shmem_prime_import_sg_table(struct drm_device *dev,
 743                                     struct dma_buf_attachment *attach,
 744                                     struct sg_table *sgt)
 745 {
 746         size_t size = PAGE_ALIGN(attach->dmabuf->size);
 747         struct drm_gem_shmem_object *shmem;
 748
 749         shmem = __drm_gem_shmem_create(dev, size, true);
 750         if (IS_ERR(shmem))
 751                 return ERR_CAST(shmem);
 752
 753         shmem->sgt = sgt;
 754
 755         DRM_DEBUG_PRIME("size = %zu\n", size);
 756
 757         return &shmem->base;
 758 }
 759 EXPORT_SYMBOL_GPL(drm_gem_shmem_prime_import_sg_table);