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_sg(obj->dev->dev, shmem->sgt->sgl, 130 shmem->sgt->nents, DMA_BIDIRECTIONAL); 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_sg(obj->dev->dev, shmem->sgt->sgl, 433 shmem->sgt->nents, DMA_BIDIRECTIONAL); 434 sg_free_table(shmem->sgt); 435 kfree(shmem->sgt); 436 shmem->sgt = NULL; 437 438 drm_gem_shmem_put_pages_locked(shmem); 439 440 shmem->madv = -1; 441 442 drm_vma_node_unmap(&obj->vma_node, dev->anon_inode->i_mapping); 443 drm_gem_free_mmap_offset(obj); 444 445 /* Our goal here is to return as much of the memory as 446 * is possible back to the system as we are called from OOM. 447 * To do this we must instruct the shmfs to drop all of its 448 * backing pages, *now*. 449 */ 450 shmem_truncate_range(file_inode(obj->filp), 0, (loff_t)-1); 451 452 invalidate_mapping_pages(file_inode(obj->filp)->i_mapping, 453 0, (loff_t)-1); 454 } 455 EXPORT_SYMBOL(drm_gem_shmem_purge_locked); 456 457 bool drm_gem_shmem_purge(struct drm_gem_object *obj) 458 { 459 struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj); 460 461 if (!mutex_trylock(&shmem->pages_lock)) 462 return false; 463 drm_gem_shmem_purge_locked(obj); 464 mutex_unlock(&shmem->pages_lock); 465 466 return true; 467 } 468 EXPORT_SYMBOL(drm_gem_shmem_purge); 469 470 /** 471 * drm_gem_shmem_create_object_cached - Create a shmem buffer object with 472 * cached mappings 473 * @dev: DRM device 474 * @size: Size of the object to allocate 475 * 476 * By default, shmem buffer objects use writecombine mappings. This 477 * function implements struct drm_driver.gem_create_object for shmem 478 * buffer objects with cached mappings. 479 * 480 * Returns: 481 * A struct drm_gem_shmem_object * on success or NULL negative on failure. 482 */ 483 struct drm_gem_object * 484 drm_gem_shmem_create_object_cached(struct drm_device *dev, size_t size) 485 { 486 struct drm_gem_shmem_object *shmem; 487 488 shmem = kzalloc(sizeof(*shmem), GFP_KERNEL); 489 if (!shmem) 490 return NULL; 491 shmem->map_cached = true; 492 493 return &shmem->base; 494 } 495 EXPORT_SYMBOL(drm_gem_shmem_create_object_cached); 496 497 /** 498 * drm_gem_shmem_dumb_create - Create a dumb shmem buffer object 499 * @file: DRM file structure to create the dumb buffer for 500 * @dev: DRM device 501 * @args: IOCTL data 502 * 503 * This function computes the pitch of the dumb buffer and rounds it up to an 504 * integer number of bytes per pixel. Drivers for hardware that doesn't have 505 * any additional restrictions on the pitch can directly use this function as 506 * their &drm_driver.dumb_create callback. 507 * 508 * For hardware with additional restrictions, drivers can adjust the fields 509 * set up by userspace before calling into this function. 510 * 511 * Returns: 512 * 0 on success or a negative error code on failure. 513 */ 514 int drm_gem_shmem_dumb_create(struct drm_file *file, struct drm_device *dev, 515 struct drm_mode_create_dumb *args) 516 { 517 u32 min_pitch = DIV_ROUND_UP(args->width * args->bpp, 8); 518 struct drm_gem_shmem_object *shmem; 519 520 if (!args->pitch || !args->size) { 521 args->pitch = min_pitch; 522 args->size = args->pitch * args->height; 523 } else { 524 /* ensure sane minimum values */ 525 if (args->pitch < min_pitch) 526 args->pitch = min_pitch; 527 if (args->size < args->pitch * args->height) 528 args->size = args->pitch * args->height; 529 } 530 531 shmem = drm_gem_shmem_create_with_handle(file, dev, args->size, &args->handle); 532 533 return PTR_ERR_OR_ZERO(shmem); 534 } 535 EXPORT_SYMBOL_GPL(drm_gem_shmem_dumb_create); 536 537 static vm_fault_t drm_gem_shmem_fault(struct vm_fault *vmf) 538 { 539 struct vm_area_struct *vma = vmf->vma; 540 struct drm_gem_object *obj = vma->vm_private_data; 541 struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj); 542 loff_t num_pages = obj->size >> PAGE_SHIFT; 543 struct page *page; 544 545 if (vmf->pgoff >= num_pages || WARN_ON_ONCE(!shmem->pages)) 546 return VM_FAULT_SIGBUS; 547 548 page = shmem->pages[vmf->pgoff]; 549 550 return vmf_insert_page(vma, vmf->address, page); 551 } 552 553 static void drm_gem_shmem_vm_open(struct vm_area_struct *vma) 554 { 555 struct drm_gem_object *obj = vma->vm_private_data; 556 struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj); 557 int ret; 558 559 WARN_ON(shmem->base.import_attach); 560 561 ret = drm_gem_shmem_get_pages(shmem); 562 WARN_ON_ONCE(ret != 0); 563 564 drm_gem_vm_open(vma); 565 } 566 567 static void drm_gem_shmem_vm_close(struct vm_area_struct *vma) 568 { 569 struct drm_gem_object *obj = vma->vm_private_data; 570 struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj); 571 572 drm_gem_shmem_put_pages(shmem); 573 drm_gem_vm_close(vma); 574 } 575 576 static const struct vm_operations_struct drm_gem_shmem_vm_ops = { 577 .fault = drm_gem_shmem_fault, 578 .open = drm_gem_shmem_vm_open, 579 .close = drm_gem_shmem_vm_close, 580 }; 581 582 /** 583 * drm_gem_shmem_mmap - Memory-map a shmem GEM object 584 * @obj: gem object 585 * @vma: VMA for the area to be mapped 586 * 587 * This function implements an augmented version of the GEM DRM file mmap 588 * operation for shmem objects. Drivers which employ the shmem helpers should 589 * use this function as their &drm_gem_object_funcs.mmap handler. 590 * 591 * Returns: 592 * 0 on success or a negative error code on failure. 593 */ 594 int drm_gem_shmem_mmap(struct drm_gem_object *obj, struct vm_area_struct *vma) 595 { 596 struct drm_gem_shmem_object *shmem; 597 int ret; 598 599 /* Remove the fake offset */ 600 vma->vm_pgoff -= drm_vma_node_start(&obj->vma_node); 601 602 if (obj->import_attach) 603 return dma_buf_mmap(obj->dma_buf, vma, 0); 604 605 shmem = to_drm_gem_shmem_obj(obj); 606 607 ret = drm_gem_shmem_get_pages(shmem); 608 if (ret) { 609 drm_gem_vm_close(vma); 610 return ret; 611 } 612 613 vma->vm_flags |= VM_MIXEDMAP | VM_DONTEXPAND; 614 vma->vm_page_prot = vm_get_page_prot(vma->vm_flags); 615 if (!shmem->map_cached) 616 vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot); 617 vma->vm_ops = &drm_gem_shmem_vm_ops; 618 619 return 0; 620 } 621 EXPORT_SYMBOL_GPL(drm_gem_shmem_mmap); 622 623 /** 624 * drm_gem_shmem_print_info() - Print &drm_gem_shmem_object info for debugfs 625 * @p: DRM printer 626 * @indent: Tab indentation level 627 * @obj: GEM object 628 * 629 * This implements the &drm_gem_object_funcs.info callback. 630 */ 631 void drm_gem_shmem_print_info(struct drm_printer *p, unsigned int indent, 632 const struct drm_gem_object *obj) 633 { 634 const struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj); 635 636 drm_printf_indent(p, indent, "pages_use_count=%u\n", shmem->pages_use_count); 637 drm_printf_indent(p, indent, "vmap_use_count=%u\n", shmem->vmap_use_count); 638 drm_printf_indent(p, indent, "vaddr=%p\n", shmem->vaddr); 639 } 640 EXPORT_SYMBOL(drm_gem_shmem_print_info); 641 642 /** 643 * drm_gem_shmem_get_sg_table - Provide a scatter/gather table of pinned 644 * pages for a shmem GEM object 645 * @obj: GEM object 646 * 647 * This function exports a scatter/gather table suitable for PRIME usage by 648 * calling the standard DMA mapping API. Drivers should not call this function 649 * directly, instead it should only be used as an implementation for 650 * &drm_gem_object_funcs.get_sg_table. 651 * 652 * Drivers who need to acquire an scatter/gather table for objects need to call 653 * drm_gem_shmem_get_pages_sgt() instead. 654 * 655 * Returns: 656 * A pointer to the scatter/gather table of pinned pages or NULL on failure. 657 */ 658 struct sg_table *drm_gem_shmem_get_sg_table(struct drm_gem_object *obj) 659 { 660 struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj); 661 662 WARN_ON(shmem->base.import_attach); 663 664 return drm_prime_pages_to_sg(obj->dev, shmem->pages, obj->size >> PAGE_SHIFT); 665 } 666 EXPORT_SYMBOL_GPL(drm_gem_shmem_get_sg_table); 667 668 /** 669 * drm_gem_shmem_get_pages_sgt - Pin pages, dma map them, and return a 670 * scatter/gather table for a shmem GEM object. 671 * @obj: GEM object 672 * 673 * This function returns a scatter/gather table suitable for driver usage. If 674 * the sg table doesn't exist, the pages are pinned, dma-mapped, and a sg 675 * table created. 676 * 677 * This is the main function for drivers to get at backing storage, and it hides 678 * and difference between dma-buf imported and natively allocated objects. 679 * drm_gem_shmem_get_sg_table() should not be directly called by drivers. 680 * 681 * Returns: 682 * A pointer to the scatter/gather table of pinned pages or errno on failure. 683 */ 684 struct sg_table *drm_gem_shmem_get_pages_sgt(struct drm_gem_object *obj) 685 { 686 int ret; 687 struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj); 688 struct sg_table *sgt; 689 690 if (shmem->sgt) 691 return shmem->sgt; 692 693 WARN_ON(obj->import_attach); 694 695 ret = drm_gem_shmem_get_pages(shmem); 696 if (ret) 697 return ERR_PTR(ret); 698 699 sgt = drm_gem_shmem_get_sg_table(&shmem->base); 700 if (IS_ERR(sgt)) { 701 ret = PTR_ERR(sgt); 702 goto err_put_pages; 703 } 704 /* Map the pages for use by the h/w. */ 705 dma_map_sg(obj->dev->dev, sgt->sgl, sgt->nents, DMA_BIDIRECTIONAL); 706 707 shmem->sgt = sgt; 708 709 return sgt; 710 711 err_put_pages: 712 drm_gem_shmem_put_pages(shmem); 713 return ERR_PTR(ret); 714 } 715 EXPORT_SYMBOL_GPL(drm_gem_shmem_get_pages_sgt); 716 717 /** 718 * drm_gem_shmem_prime_import_sg_table - Produce a shmem GEM object from 719 * another driver's scatter/gather table of pinned pages 720 * @dev: Device to import into 721 * @attach: DMA-BUF attachment 722 * @sgt: Scatter/gather table of pinned pages 723 * 724 * This function imports a scatter/gather table exported via DMA-BUF by 725 * another driver. Drivers that use the shmem helpers should set this as their 726 * &drm_driver.gem_prime_import_sg_table callback. 727 * 728 * Returns: 729 * A pointer to a newly created GEM object or an ERR_PTR-encoded negative 730 * error code on failure. 731 */ 732 struct drm_gem_object * 733 drm_gem_shmem_prime_import_sg_table(struct drm_device *dev, 734 struct dma_buf_attachment *attach, 735 struct sg_table *sgt) 736 { 737 size_t size = PAGE_ALIGN(attach->dmabuf->size); 738 struct drm_gem_shmem_object *shmem; 739 740 shmem = __drm_gem_shmem_create(dev, size, true); 741 if (IS_ERR(shmem)) 742 return ERR_CAST(shmem); 743 744 shmem->sgt = sgt; 745 746 DRM_DEBUG_PRIME("size = %zu\n", size); 747 748 return &shmem->base; 749 } 750 EXPORT_SYMBOL_GPL(drm_gem_shmem_prime_import_sg_table); 751