2 * Copyright © 2012 Red Hat
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
24 * Dave Airlie <airlied@redhat.com>
25 * Rob Clark <rob.clark@linaro.org>
29 #include <linux/export.h>
30 #include <linux/dma-buf.h>
31 #include <linux/rbtree.h>
32 #include <linux/module.h>
35 #include <drm/drm_drv.h>
36 #include <drm/drm_file.h>
37 #include <drm/drm_framebuffer.h>
38 #include <drm/drm_gem.h>
39 #include <drm/drm_prime.h>
41 #include "drm_internal.h"
43 MODULE_IMPORT_NS(DMA_BUF
);
46 * DOC: overview and lifetime rules
48 * Similar to GEM global names, PRIME file descriptors are also used to share
49 * buffer objects across processes. They offer additional security: as file
50 * descriptors must be explicitly sent over UNIX domain sockets to be shared
51 * between applications, they can't be guessed like the globally unique GEM
54 * Drivers that support the PRIME API implement the drm_gem_object_funcs.export
55 * and &drm_driver.gem_prime_import hooks. &dma_buf_ops implementations for
56 * drivers are all individually exported for drivers which need to overwrite
57 * or reimplement some of them.
59 * Reference Counting for GEM Drivers
60 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
62 * On the export the &dma_buf holds a reference to the exported buffer object,
63 * usually a &drm_gem_object. It takes this reference in the PRIME_HANDLE_TO_FD
64 * IOCTL, when it first calls &drm_gem_object_funcs.export
65 * and stores the exporting GEM object in the &dma_buf.priv field. This
66 * reference needs to be released when the final reference to the &dma_buf
67 * itself is dropped and its &dma_buf_ops.release function is called. For
68 * GEM-based drivers, the &dma_buf should be exported using
69 * drm_gem_dmabuf_export() and then released by drm_gem_dmabuf_release().
71 * Thus the chain of references always flows in one direction, avoiding loops:
72 * importing GEM object -> dma-buf -> exported GEM bo. A further complication
73 * are the lookup caches for import and export. These are required to guarantee
74 * that any given object will always have only one unique userspace handle. This
75 * is required to allow userspace to detect duplicated imports, since some GEM
76 * drivers do fail command submissions if a given buffer object is listed more
77 * than once. These import and export caches in &drm_prime_file_private only
78 * retain a weak reference, which is cleaned up when the corresponding object is
81 * Self-importing: If userspace is using PRIME as a replacement for flink then
82 * it will get a fd->handle request for a GEM object that it created. Drivers
83 * should detect this situation and return back the underlying object from the
84 * dma-buf private. For GEM based drivers this is handled in
85 * drm_gem_prime_import() already.
88 struct drm_prime_member
{
89 struct dma_buf
*dma_buf
;
92 struct rb_node dmabuf_rb
;
93 struct rb_node handle_rb
;
96 static int drm_prime_add_buf_handle(struct drm_prime_file_private
*prime_fpriv
,
97 struct dma_buf
*dma_buf
, uint32_t handle
)
99 struct drm_prime_member
*member
;
100 struct rb_node
**p
, *rb
;
102 member
= kmalloc(sizeof(*member
), GFP_KERNEL
);
106 get_dma_buf(dma_buf
);
107 member
->dma_buf
= dma_buf
;
108 member
->handle
= handle
;
111 p
= &prime_fpriv
->dmabufs
.rb_node
;
113 struct drm_prime_member
*pos
;
116 pos
= rb_entry(rb
, struct drm_prime_member
, dmabuf_rb
);
117 if (dma_buf
> pos
->dma_buf
)
122 rb_link_node(&member
->dmabuf_rb
, rb
, p
);
123 rb_insert_color(&member
->dmabuf_rb
, &prime_fpriv
->dmabufs
);
126 p
= &prime_fpriv
->handles
.rb_node
;
128 struct drm_prime_member
*pos
;
131 pos
= rb_entry(rb
, struct drm_prime_member
, handle_rb
);
132 if (handle
> pos
->handle
)
137 rb_link_node(&member
->handle_rb
, rb
, p
);
138 rb_insert_color(&member
->handle_rb
, &prime_fpriv
->handles
);
143 static struct dma_buf
*drm_prime_lookup_buf_by_handle(struct drm_prime_file_private
*prime_fpriv
,
148 rb
= prime_fpriv
->handles
.rb_node
;
150 struct drm_prime_member
*member
;
152 member
= rb_entry(rb
, struct drm_prime_member
, handle_rb
);
153 if (member
->handle
== handle
)
154 return member
->dma_buf
;
155 else if (member
->handle
< handle
)
164 static int drm_prime_lookup_buf_handle(struct drm_prime_file_private
*prime_fpriv
,
165 struct dma_buf
*dma_buf
,
170 rb
= prime_fpriv
->dmabufs
.rb_node
;
172 struct drm_prime_member
*member
;
174 member
= rb_entry(rb
, struct drm_prime_member
, dmabuf_rb
);
175 if (member
->dma_buf
== dma_buf
) {
176 *handle
= member
->handle
;
178 } else if (member
->dma_buf
< dma_buf
) {
188 void drm_prime_remove_buf_handle(struct drm_prime_file_private
*prime_fpriv
,
193 mutex_lock(&prime_fpriv
->lock
);
195 rb
= prime_fpriv
->handles
.rb_node
;
197 struct drm_prime_member
*member
;
199 member
= rb_entry(rb
, struct drm_prime_member
, handle_rb
);
200 if (member
->handle
== handle
) {
201 rb_erase(&member
->handle_rb
, &prime_fpriv
->handles
);
202 rb_erase(&member
->dmabuf_rb
, &prime_fpriv
->dmabufs
);
204 dma_buf_put(member
->dma_buf
);
207 } else if (member
->handle
< handle
) {
214 mutex_unlock(&prime_fpriv
->lock
);
217 void drm_prime_init_file_private(struct drm_prime_file_private
*prime_fpriv
)
219 mutex_init(&prime_fpriv
->lock
);
220 prime_fpriv
->dmabufs
= RB_ROOT
;
221 prime_fpriv
->handles
= RB_ROOT
;
224 void drm_prime_destroy_file_private(struct drm_prime_file_private
*prime_fpriv
)
226 /* by now drm_gem_release should've made sure the list is empty */
227 WARN_ON(!RB_EMPTY_ROOT(&prime_fpriv
->dmabufs
));
231 * drm_gem_dmabuf_export - &dma_buf export implementation for GEM
232 * @dev: parent device for the exported dmabuf
233 * @exp_info: the export information used by dma_buf_export()
235 * This wraps dma_buf_export() for use by generic GEM drivers that are using
236 * drm_gem_dmabuf_release(). In addition to calling dma_buf_export(), we take
237 * a reference to the &drm_device and the exported &drm_gem_object (stored in
238 * &dma_buf_export_info.priv) which is released by drm_gem_dmabuf_release().
240 * Returns the new dmabuf.
242 struct dma_buf
*drm_gem_dmabuf_export(struct drm_device
*dev
,
243 struct dma_buf_export_info
*exp_info
)
245 struct drm_gem_object
*obj
= exp_info
->priv
;
246 struct dma_buf
*dma_buf
;
248 dma_buf
= dma_buf_export(exp_info
);
253 drm_gem_object_get(obj
);
254 dma_buf
->file
->f_mapping
= obj
->dev
->anon_inode
->i_mapping
;
258 EXPORT_SYMBOL(drm_gem_dmabuf_export
);
261 * drm_gem_dmabuf_release - &dma_buf release implementation for GEM
262 * @dma_buf: buffer to be released
264 * Generic release function for dma_bufs exported as PRIME buffers. GEM drivers
265 * must use this in their &dma_buf_ops structure as the release callback.
266 * drm_gem_dmabuf_release() should be used in conjunction with
267 * drm_gem_dmabuf_export().
269 void drm_gem_dmabuf_release(struct dma_buf
*dma_buf
)
271 struct drm_gem_object
*obj
= dma_buf
->priv
;
272 struct drm_device
*dev
= obj
->dev
;
274 /* drop the reference on the export fd holds */
275 drm_gem_object_put(obj
);
279 EXPORT_SYMBOL(drm_gem_dmabuf_release
);
282 * drm_gem_prime_fd_to_handle - PRIME import function for GEM drivers
283 * @dev: drm_device to import into
284 * @file_priv: drm file-private structure
285 * @prime_fd: fd id of the dma-buf which should be imported
286 * @handle: pointer to storage for the handle of the imported buffer object
288 * This is the PRIME import function which must be used mandatorily by GEM
289 * drivers to ensure correct lifetime management of the underlying GEM object.
290 * The actual importing of GEM object from the dma-buf is done through the
291 * &drm_driver.gem_prime_import driver callback.
293 * Returns 0 on success or a negative error code on failure.
295 static int drm_gem_prime_fd_to_handle(struct drm_device
*dev
,
296 struct drm_file
*file_priv
, int prime_fd
,
299 struct dma_buf
*dma_buf
;
300 struct drm_gem_object
*obj
;
303 dma_buf
= dma_buf_get(prime_fd
);
305 return PTR_ERR(dma_buf
);
307 mutex_lock(&file_priv
->prime
.lock
);
309 ret
= drm_prime_lookup_buf_handle(&file_priv
->prime
,
314 /* never seen this one, need to import */
315 mutex_lock(&dev
->object_name_lock
);
316 if (dev
->driver
->gem_prime_import
)
317 obj
= dev
->driver
->gem_prime_import(dev
, dma_buf
);
319 obj
= drm_gem_prime_import(dev
, dma_buf
);
326 WARN_ON(obj
->dma_buf
!= dma_buf
);
328 obj
->dma_buf
= dma_buf
;
329 get_dma_buf(dma_buf
);
332 /* _handle_create_tail unconditionally unlocks dev->object_name_lock. */
333 ret
= drm_gem_handle_create_tail(file_priv
, obj
, handle
);
334 drm_gem_object_put(obj
);
338 ret
= drm_prime_add_buf_handle(&file_priv
->prime
,
340 mutex_unlock(&file_priv
->prime
.lock
);
344 dma_buf_put(dma_buf
);
349 /* hmm, if driver attached, we are relying on the free-object path
350 * to detach.. which seems ok..
352 drm_gem_handle_delete(file_priv
, *handle
);
353 dma_buf_put(dma_buf
);
357 mutex_unlock(&dev
->object_name_lock
);
359 mutex_unlock(&file_priv
->prime
.lock
);
360 dma_buf_put(dma_buf
);
364 int drm_prime_fd_to_handle_ioctl(struct drm_device
*dev
, void *data
,
365 struct drm_file
*file_priv
)
367 struct drm_prime_handle
*args
= data
;
369 if (dev
->driver
->prime_fd_to_handle
) {
370 return dev
->driver
->prime_fd_to_handle(dev
, file_priv
, args
->fd
,
374 return drm_gem_prime_fd_to_handle(dev
, file_priv
, args
->fd
, &args
->handle
);
377 static struct dma_buf
*export_and_register_object(struct drm_device
*dev
,
378 struct drm_gem_object
*obj
,
381 struct dma_buf
*dmabuf
;
383 /* prevent races with concurrent gem_close. */
384 if (obj
->handle_count
== 0) {
385 dmabuf
= ERR_PTR(-ENOENT
);
389 if (obj
->funcs
&& obj
->funcs
->export
)
390 dmabuf
= obj
->funcs
->export(obj
, flags
);
392 dmabuf
= drm_gem_prime_export(obj
, flags
);
393 if (IS_ERR(dmabuf
)) {
394 /* normally the created dma-buf takes ownership of the ref,
395 * but if that fails then drop the ref
401 * Note that callers do not need to clean up the export cache
402 * since the check for obj->handle_count guarantees that someone
405 obj
->dma_buf
= dmabuf
;
406 get_dma_buf(obj
->dma_buf
);
412 * drm_gem_prime_handle_to_fd - PRIME export function for GEM drivers
413 * @dev: dev to export the buffer from
414 * @file_priv: drm file-private structure
415 * @handle: buffer handle to export
416 * @flags: flags like DRM_CLOEXEC
417 * @prime_fd: pointer to storage for the fd id of the create dma-buf
419 * This is the PRIME export function which must be used mandatorily by GEM
420 * drivers to ensure correct lifetime management of the underlying GEM object.
421 * The actual exporting from GEM object to a dma-buf is done through the
422 * &drm_gem_object_funcs.export callback.
424 static int drm_gem_prime_handle_to_fd(struct drm_device
*dev
,
425 struct drm_file
*file_priv
, uint32_t handle
,
429 struct drm_gem_object
*obj
;
431 struct dma_buf
*dmabuf
;
433 mutex_lock(&file_priv
->prime
.lock
);
434 obj
= drm_gem_object_lookup(file_priv
, handle
);
440 dmabuf
= drm_prime_lookup_buf_by_handle(&file_priv
->prime
, handle
);
443 goto out_have_handle
;
446 mutex_lock(&dev
->object_name_lock
);
447 /* re-export the original imported object */
448 if (obj
->import_attach
) {
449 dmabuf
= obj
->import_attach
->dmabuf
;
455 get_dma_buf(obj
->dma_buf
);
456 dmabuf
= obj
->dma_buf
;
460 dmabuf
= export_and_register_object(dev
, obj
, flags
);
461 if (IS_ERR(dmabuf
)) {
462 /* normally the created dma-buf takes ownership of the ref,
463 * but if that fails then drop the ref
465 ret
= PTR_ERR(dmabuf
);
466 mutex_unlock(&dev
->object_name_lock
);
472 * If we've exported this buffer then cheat and add it to the import list
473 * so we get the correct handle back. We must do this under the
474 * protection of dev->object_name_lock to ensure that a racing gem close
475 * ioctl doesn't miss to remove this buffer handle from the cache.
477 ret
= drm_prime_add_buf_handle(&file_priv
->prime
,
479 mutex_unlock(&dev
->object_name_lock
);
481 goto fail_put_dmabuf
;
484 ret
= dma_buf_fd(dmabuf
, flags
);
486 * We must _not_ remove the buffer from the handle cache since the newly
487 * created dma buf is already linked in the global obj->dma_buf pointer,
488 * and that is invariant as long as a userspace gem handle exists.
489 * Closing the handle will clean out the cache anyway, so we don't leak.
492 goto fail_put_dmabuf
;
503 drm_gem_object_put(obj
);
505 mutex_unlock(&file_priv
->prime
.lock
);
510 int drm_prime_handle_to_fd_ioctl(struct drm_device
*dev
, void *data
,
511 struct drm_file
*file_priv
)
513 struct drm_prime_handle
*args
= data
;
515 /* check flags are valid */
516 if (args
->flags
& ~(DRM_CLOEXEC
| DRM_RDWR
))
519 if (dev
->driver
->prime_handle_to_fd
) {
520 return dev
->driver
->prime_handle_to_fd(dev
, file_priv
,
521 args
->handle
, args
->flags
,
524 return drm_gem_prime_handle_to_fd(dev
, file_priv
, args
->handle
,
525 args
->flags
, &args
->fd
);
531 * Drivers can implement &drm_gem_object_funcs.export and
532 * &drm_driver.gem_prime_import in terms of simpler APIs by using the helper
533 * functions drm_gem_prime_export() and drm_gem_prime_import(). These functions
534 * implement dma-buf support in terms of some lower-level helpers, which are
535 * again exported for drivers to use individually:
540 * Optional pinning of buffers is handled at dma-buf attach and detach time in
541 * drm_gem_map_attach() and drm_gem_map_detach(). Backing storage itself is
542 * handled by drm_gem_map_dma_buf() and drm_gem_unmap_dma_buf(), which relies on
543 * &drm_gem_object_funcs.get_sg_table. If &drm_gem_object_funcs.get_sg_table is
544 * unimplemented, exports into another device are rejected.
546 * For kernel-internal access there's drm_gem_dmabuf_vmap() and
547 * drm_gem_dmabuf_vunmap(). Userspace mmap support is provided by
548 * drm_gem_dmabuf_mmap().
550 * Note that these export helpers can only be used if the underlying backing
551 * storage is fully coherent and either permanently pinned, or it is safe to pin
554 * FIXME: The underlying helper functions are named rather inconsistently.
559 * Importing dma-bufs using drm_gem_prime_import() relies on
560 * &drm_driver.gem_prime_import_sg_table.
562 * Note that similarly to the export helpers this permanently pins the
563 * underlying backing storage. Which is ok for scanout, but is not the best
564 * option for sharing lots of buffers for rendering.
568 * drm_gem_map_attach - dma_buf attach implementation for GEM
569 * @dma_buf: buffer to attach device to
570 * @attach: buffer attachment data
572 * Calls &drm_gem_object_funcs.pin for device specific handling. This can be
573 * used as the &dma_buf_ops.attach callback. Must be used together with
574 * drm_gem_map_detach().
576 * Returns 0 on success, negative error code on failure.
578 int drm_gem_map_attach(struct dma_buf
*dma_buf
,
579 struct dma_buf_attachment
*attach
)
581 struct drm_gem_object
*obj
= dma_buf
->priv
;
583 if (!obj
->funcs
->get_sg_table
)
586 return drm_gem_pin(obj
);
588 EXPORT_SYMBOL(drm_gem_map_attach
);
591 * drm_gem_map_detach - dma_buf detach implementation for GEM
592 * @dma_buf: buffer to detach from
593 * @attach: attachment to be detached
595 * Calls &drm_gem_object_funcs.pin for device specific handling. Cleans up
596 * &dma_buf_attachment from drm_gem_map_attach(). This can be used as the
597 * &dma_buf_ops.detach callback.
599 void drm_gem_map_detach(struct dma_buf
*dma_buf
,
600 struct dma_buf_attachment
*attach
)
602 struct drm_gem_object
*obj
= dma_buf
->priv
;
606 EXPORT_SYMBOL(drm_gem_map_detach
);
609 * drm_gem_map_dma_buf - map_dma_buf implementation for GEM
610 * @attach: attachment whose scatterlist is to be returned
611 * @dir: direction of DMA transfer
613 * Calls &drm_gem_object_funcs.get_sg_table and then maps the scatterlist. This
614 * can be used as the &dma_buf_ops.map_dma_buf callback. Should be used together
615 * with drm_gem_unmap_dma_buf().
617 * Returns:sg_table containing the scatterlist to be returned; returns ERR_PTR
618 * on error. May return -EINTR if it is interrupted by a signal.
620 struct sg_table
*drm_gem_map_dma_buf(struct dma_buf_attachment
*attach
,
621 enum dma_data_direction dir
)
623 struct drm_gem_object
*obj
= attach
->dmabuf
->priv
;
624 struct sg_table
*sgt
;
627 if (WARN_ON(dir
== DMA_NONE
))
628 return ERR_PTR(-EINVAL
);
630 if (WARN_ON(!obj
->funcs
->get_sg_table
))
631 return ERR_PTR(-ENOSYS
);
633 sgt
= obj
->funcs
->get_sg_table(obj
);
637 ret
= dma_map_sgtable(attach
->dev
, sgt
, dir
,
638 DMA_ATTR_SKIP_CPU_SYNC
);
647 EXPORT_SYMBOL(drm_gem_map_dma_buf
);
650 * drm_gem_unmap_dma_buf - unmap_dma_buf implementation for GEM
651 * @attach: attachment to unmap buffer from
652 * @sgt: scatterlist info of the buffer to unmap
653 * @dir: direction of DMA transfer
655 * This can be used as the &dma_buf_ops.unmap_dma_buf callback.
657 void drm_gem_unmap_dma_buf(struct dma_buf_attachment
*attach
,
658 struct sg_table
*sgt
,
659 enum dma_data_direction dir
)
664 dma_unmap_sgtable(attach
->dev
, sgt
, dir
, DMA_ATTR_SKIP_CPU_SYNC
);
668 EXPORT_SYMBOL(drm_gem_unmap_dma_buf
);
671 * drm_gem_dmabuf_vmap - dma_buf vmap implementation for GEM
672 * @dma_buf: buffer to be mapped
673 * @map: the virtual address of the buffer
675 * Sets up a kernel virtual mapping. This can be used as the &dma_buf_ops.vmap
676 * callback. Calls into &drm_gem_object_funcs.vmap for device specific handling.
677 * The kernel virtual address is returned in map.
679 * Returns 0 on success or a negative errno code otherwise.
681 int drm_gem_dmabuf_vmap(struct dma_buf
*dma_buf
, struct iosys_map
*map
)
683 struct drm_gem_object
*obj
= dma_buf
->priv
;
685 return drm_gem_vmap(obj
, map
);
687 EXPORT_SYMBOL(drm_gem_dmabuf_vmap
);
690 * drm_gem_dmabuf_vunmap - dma_buf vunmap implementation for GEM
691 * @dma_buf: buffer to be unmapped
692 * @map: the virtual address of the buffer
694 * Releases a kernel virtual mapping. This can be used as the
695 * &dma_buf_ops.vunmap callback. Calls into &drm_gem_object_funcs.vunmap for device specific handling.
697 void drm_gem_dmabuf_vunmap(struct dma_buf
*dma_buf
, struct iosys_map
*map
)
699 struct drm_gem_object
*obj
= dma_buf
->priv
;
701 drm_gem_vunmap(obj
, map
);
703 EXPORT_SYMBOL(drm_gem_dmabuf_vunmap
);
706 * drm_gem_prime_mmap - PRIME mmap function for GEM drivers
708 * @vma: Virtual address range
710 * This function sets up a userspace mapping for PRIME exported buffers using
711 * the same codepath that is used for regular GEM buffer mapping on the DRM fd.
712 * The fake GEM offset is added to vma->vm_pgoff and &drm_driver->fops->mmap is
713 * called to set up the mapping.
715 int drm_gem_prime_mmap(struct drm_gem_object
*obj
, struct vm_area_struct
*vma
)
717 struct drm_file
*priv
;
721 /* Add the fake offset */
722 vma
->vm_pgoff
+= drm_vma_node_start(&obj
->vma_node
);
724 if (obj
->funcs
&& obj
->funcs
->mmap
) {
725 vma
->vm_ops
= obj
->funcs
->vm_ops
;
727 drm_gem_object_get(obj
);
728 ret
= obj
->funcs
->mmap(obj
, vma
);
730 drm_gem_object_put(obj
);
733 vma
->vm_private_data
= obj
;
737 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
738 fil
= kzalloc(sizeof(*fil
), GFP_KERNEL
);
744 /* Used by drm_gem_mmap() to lookup the GEM object */
745 priv
->minor
= obj
->dev
->primary
;
746 fil
->private_data
= priv
;
748 ret
= drm_vma_node_allow(&obj
->vma_node
, priv
);
752 ret
= obj
->dev
->driver
->fops
->mmap(fil
, vma
);
754 drm_vma_node_revoke(&obj
->vma_node
, priv
);
761 EXPORT_SYMBOL(drm_gem_prime_mmap
);
764 * drm_gem_dmabuf_mmap - dma_buf mmap implementation for GEM
765 * @dma_buf: buffer to be mapped
766 * @vma: virtual address range
768 * Provides memory mapping for the buffer. This can be used as the
769 * &dma_buf_ops.mmap callback. It just forwards to drm_gem_prime_mmap().
771 * Returns 0 on success or a negative error code on failure.
773 int drm_gem_dmabuf_mmap(struct dma_buf
*dma_buf
, struct vm_area_struct
*vma
)
775 struct drm_gem_object
*obj
= dma_buf
->priv
;
777 return drm_gem_prime_mmap(obj
, vma
);
779 EXPORT_SYMBOL(drm_gem_dmabuf_mmap
);
781 static const struct dma_buf_ops drm_gem_prime_dmabuf_ops
= {
782 .cache_sgt_mapping
= true,
783 .attach
= drm_gem_map_attach
,
784 .detach
= drm_gem_map_detach
,
785 .map_dma_buf
= drm_gem_map_dma_buf
,
786 .unmap_dma_buf
= drm_gem_unmap_dma_buf
,
787 .release
= drm_gem_dmabuf_release
,
788 .mmap
= drm_gem_dmabuf_mmap
,
789 .vmap
= drm_gem_dmabuf_vmap
,
790 .vunmap
= drm_gem_dmabuf_vunmap
,
794 * drm_prime_pages_to_sg - converts a page array into an sg list
796 * @pages: pointer to the array of page pointers to convert
797 * @nr_pages: length of the page vector
799 * This helper creates an sg table object from a set of pages
800 * the driver is responsible for mapping the pages into the
801 * importers address space for use with dma_buf itself.
803 * This is useful for implementing &drm_gem_object_funcs.get_sg_table.
805 struct sg_table
*drm_prime_pages_to_sg(struct drm_device
*dev
,
806 struct page
**pages
, unsigned int nr_pages
)
809 size_t max_segment
= 0;
812 sg
= kmalloc(sizeof(struct sg_table
), GFP_KERNEL
);
814 return ERR_PTR(-ENOMEM
);
817 max_segment
= dma_max_mapping_size(dev
->dev
);
818 if (max_segment
== 0)
819 max_segment
= UINT_MAX
;
820 err
= sg_alloc_table_from_pages_segment(sg
, pages
, nr_pages
, 0,
821 nr_pages
<< PAGE_SHIFT
,
822 max_segment
, GFP_KERNEL
);
829 EXPORT_SYMBOL(drm_prime_pages_to_sg
);
832 * drm_prime_get_contiguous_size - returns the contiguous size of the buffer
833 * @sgt: sg_table describing the buffer to check
835 * This helper calculates the contiguous size in the DMA address space
836 * of the buffer described by the provided sg_table.
838 * This is useful for implementing
839 * &drm_gem_object_funcs.gem_prime_import_sg_table.
841 unsigned long drm_prime_get_contiguous_size(struct sg_table
*sgt
)
843 dma_addr_t expected
= sg_dma_address(sgt
->sgl
);
844 struct scatterlist
*sg
;
845 unsigned long size
= 0;
848 for_each_sgtable_dma_sg(sgt
, sg
, i
) {
849 unsigned int len
= sg_dma_len(sg
);
853 if (sg_dma_address(sg
) != expected
)
860 EXPORT_SYMBOL(drm_prime_get_contiguous_size
);
863 * drm_gem_prime_export - helper library implementation of the export callback
864 * @obj: GEM object to export
865 * @flags: flags like DRM_CLOEXEC and DRM_RDWR
867 * This is the implementation of the &drm_gem_object_funcs.export functions
868 * for GEM drivers using the PRIME helpers. It is used as the default for
869 * drivers that do not set their own.
871 struct dma_buf
*drm_gem_prime_export(struct drm_gem_object
*obj
,
874 struct drm_device
*dev
= obj
->dev
;
875 struct dma_buf_export_info exp_info
= {
876 .exp_name
= KBUILD_MODNAME
, /* white lie for debug */
877 .owner
= dev
->driver
->fops
->owner
,
878 .ops
= &drm_gem_prime_dmabuf_ops
,
885 return drm_gem_dmabuf_export(dev
, &exp_info
);
887 EXPORT_SYMBOL(drm_gem_prime_export
);
890 * drm_gem_prime_import_dev - core implementation of the import callback
891 * @dev: drm_device to import into
892 * @dma_buf: dma-buf object to import
893 * @attach_dev: struct device to dma_buf attach
895 * This is the core of drm_gem_prime_import(). It's designed to be called by
896 * drivers who want to use a different device structure than &drm_device.dev for
897 * attaching via dma_buf. This function calls
898 * &drm_driver.gem_prime_import_sg_table internally.
900 * Drivers must arrange to call drm_prime_gem_destroy() from their
901 * &drm_gem_object_funcs.free hook when using this function.
903 struct drm_gem_object
*drm_gem_prime_import_dev(struct drm_device
*dev
,
904 struct dma_buf
*dma_buf
,
905 struct device
*attach_dev
)
907 struct dma_buf_attachment
*attach
;
908 struct sg_table
*sgt
;
909 struct drm_gem_object
*obj
;
912 if (dma_buf
->ops
== &drm_gem_prime_dmabuf_ops
) {
914 if (obj
->dev
== dev
) {
916 * Importing dmabuf exported from our own gem increases
917 * refcount on gem itself instead of f_count of dmabuf.
919 drm_gem_object_get(obj
);
924 if (!dev
->driver
->gem_prime_import_sg_table
)
925 return ERR_PTR(-EINVAL
);
927 attach
= dma_buf_attach(dma_buf
, attach_dev
);
929 return ERR_CAST(attach
);
931 get_dma_buf(dma_buf
);
933 sgt
= dma_buf_map_attachment_unlocked(attach
, DMA_BIDIRECTIONAL
);
939 obj
= dev
->driver
->gem_prime_import_sg_table(dev
, attach
, sgt
);
945 obj
->import_attach
= attach
;
946 obj
->resv
= dma_buf
->resv
;
951 dma_buf_unmap_attachment_unlocked(attach
, sgt
, DMA_BIDIRECTIONAL
);
953 dma_buf_detach(dma_buf
, attach
);
954 dma_buf_put(dma_buf
);
958 EXPORT_SYMBOL(drm_gem_prime_import_dev
);
961 * drm_gem_prime_import - helper library implementation of the import callback
962 * @dev: drm_device to import into
963 * @dma_buf: dma-buf object to import
965 * This is the implementation of the gem_prime_import functions for GEM
966 * drivers using the PRIME helpers. It is the default for drivers that do
967 * not set their own &drm_driver.gem_prime_import.
969 * Drivers must arrange to call drm_prime_gem_destroy() from their
970 * &drm_gem_object_funcs.free hook when using this function.
972 struct drm_gem_object
*drm_gem_prime_import(struct drm_device
*dev
,
973 struct dma_buf
*dma_buf
)
975 return drm_gem_prime_import_dev(dev
, dma_buf
, dev
->dev
);
977 EXPORT_SYMBOL(drm_gem_prime_import
);
980 * drm_prime_sg_to_page_array - convert an sg table into a page array
981 * @sgt: scatter-gather table to convert
982 * @pages: array of page pointers to store the pages in
983 * @max_entries: size of the passed-in array
985 * Exports an sg table into an array of pages.
987 * This function is deprecated and strongly discouraged to be used.
988 * The page array is only useful for page faults and those can corrupt fields
989 * in the struct page if they are not handled by the exporting driver.
991 int __deprecated
drm_prime_sg_to_page_array(struct sg_table
*sgt
,
995 struct sg_page_iter page_iter
;
996 struct page
**p
= pages
;
998 for_each_sgtable_page(sgt
, &page_iter
, 0) {
999 if (WARN_ON(p
- pages
>= max_entries
))
1001 *p
++ = sg_page_iter_page(&page_iter
);
1005 EXPORT_SYMBOL(drm_prime_sg_to_page_array
);
1008 * drm_prime_sg_to_dma_addr_array - convert an sg table into a dma addr array
1009 * @sgt: scatter-gather table to convert
1010 * @addrs: array to store the dma bus address of each page
1011 * @max_entries: size of both the passed-in arrays
1013 * Exports an sg table into an array of addresses.
1015 * Drivers should use this in their &drm_driver.gem_prime_import_sg_table
1018 int drm_prime_sg_to_dma_addr_array(struct sg_table
*sgt
, dma_addr_t
*addrs
,
1021 struct sg_dma_page_iter dma_iter
;
1022 dma_addr_t
*a
= addrs
;
1024 for_each_sgtable_dma_page(sgt
, &dma_iter
, 0) {
1025 if (WARN_ON(a
- addrs
>= max_entries
))
1027 *a
++ = sg_page_iter_dma_address(&dma_iter
);
1031 EXPORT_SYMBOL(drm_prime_sg_to_dma_addr_array
);
1034 * drm_prime_gem_destroy - helper to clean up a PRIME-imported GEM object
1035 * @obj: GEM object which was created from a dma-buf
1036 * @sg: the sg-table which was pinned at import time
1038 * This is the cleanup functions which GEM drivers need to call when they use
1039 * drm_gem_prime_import() or drm_gem_prime_import_dev() to import dma-bufs.
1041 void drm_prime_gem_destroy(struct drm_gem_object
*obj
, struct sg_table
*sg
)
1043 struct dma_buf_attachment
*attach
;
1044 struct dma_buf
*dma_buf
;
1046 attach
= obj
->import_attach
;
1048 dma_buf_unmap_attachment_unlocked(attach
, sg
, DMA_BIDIRECTIONAL
);
1049 dma_buf
= attach
->dmabuf
;
1050 dma_buf_detach(attach
->dmabuf
, attach
);
1051 /* remove the reference */
1052 dma_buf_put(dma_buf
);
1054 EXPORT_SYMBOL(drm_prime_gem_destroy
);