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); 760