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>
34 * DMA-BUF/GEM Object references and lifetime overview:
36 * On the export the dma_buf holds a reference to the exporting GEM
37 * object. It takes this reference in handle_to_fd_ioctl, when it
38 * first calls .prime_export and stores the exporting GEM object in
39 * the dma_buf priv. This reference is released when the dma_buf
40 * object goes away in the driver .release function.
42 * On the import the importing GEM object holds a reference to the
43 * dma_buf (which in turn holds a ref to the exporting GEM object).
44 * It takes that reference in the fd_to_handle ioctl.
45 * It calls dma_buf_get, creates an attachment to it and stores the
46 * attachment in the GEM object. When this attachment is destroyed
47 * when the imported object is destroyed, we remove the attachment
48 * and drop the reference to the dma_buf.
50 * Thus the chain of references always flows in one direction
51 * (avoiding loops): importing_gem -> dmabuf -> exporting_gem
53 * Self-importing: if userspace is using PRIME as a replacement for flink
54 * then it will get a fd->handle request for a GEM object that it created.
55 * Drivers should detect this situation and return back the gem object
56 * from the dma-buf private. Prime will do this automatically for drivers that
57 * use the drm_gem_prime_{import,export} helpers.
60 struct drm_prime_member
{
61 struct list_head entry
;
62 struct dma_buf
*dma_buf
;
66 static struct sg_table
*drm_gem_map_dma_buf(struct dma_buf_attachment
*attach
,
67 enum dma_data_direction dir
)
69 struct drm_gem_object
*obj
= attach
->dmabuf
->priv
;
72 mutex_lock(&obj
->dev
->struct_mutex
);
74 sgt
= obj
->dev
->driver
->gem_prime_get_sg_table(obj
);
76 if (!IS_ERR_OR_NULL(sgt
))
77 dma_map_sg(attach
->dev
, sgt
->sgl
, sgt
->nents
, dir
);
79 mutex_unlock(&obj
->dev
->struct_mutex
);
83 static void drm_gem_unmap_dma_buf(struct dma_buf_attachment
*attach
,
84 struct sg_table
*sgt
, enum dma_data_direction dir
)
86 dma_unmap_sg(attach
->dev
, sgt
->sgl
, sgt
->nents
, dir
);
91 static void drm_gem_dmabuf_release(struct dma_buf
*dma_buf
)
93 struct drm_gem_object
*obj
= dma_buf
->priv
;
95 if (obj
->export_dma_buf
== dma_buf
) {
96 /* drop the reference on the export fd holds */
97 obj
->export_dma_buf
= NULL
;
98 drm_gem_object_unreference_unlocked(obj
);
102 static void *drm_gem_dmabuf_vmap(struct dma_buf
*dma_buf
)
104 struct drm_gem_object
*obj
= dma_buf
->priv
;
105 struct drm_device
*dev
= obj
->dev
;
107 return dev
->driver
->gem_prime_vmap(obj
);
110 static void drm_gem_dmabuf_vunmap(struct dma_buf
*dma_buf
, void *vaddr
)
112 struct drm_gem_object
*obj
= dma_buf
->priv
;
113 struct drm_device
*dev
= obj
->dev
;
115 dev
->driver
->gem_prime_vunmap(obj
, vaddr
);
118 static void *drm_gem_dmabuf_kmap_atomic(struct dma_buf
*dma_buf
,
119 unsigned long page_num
)
124 static void drm_gem_dmabuf_kunmap_atomic(struct dma_buf
*dma_buf
,
125 unsigned long page_num
, void *addr
)
129 static void *drm_gem_dmabuf_kmap(struct dma_buf
*dma_buf
,
130 unsigned long page_num
)
135 static void drm_gem_dmabuf_kunmap(struct dma_buf
*dma_buf
,
136 unsigned long page_num
, void *addr
)
141 static int drm_gem_dmabuf_mmap(struct dma_buf
*dma_buf
,
142 struct vm_area_struct
*vma
)
147 static const struct dma_buf_ops drm_gem_prime_dmabuf_ops
= {
148 .map_dma_buf
= drm_gem_map_dma_buf
,
149 .unmap_dma_buf
= drm_gem_unmap_dma_buf
,
150 .release
= drm_gem_dmabuf_release
,
151 .kmap
= drm_gem_dmabuf_kmap
,
152 .kmap_atomic
= drm_gem_dmabuf_kmap_atomic
,
153 .kunmap
= drm_gem_dmabuf_kunmap
,
154 .kunmap_atomic
= drm_gem_dmabuf_kunmap_atomic
,
155 .mmap
= drm_gem_dmabuf_mmap
,
156 .vmap
= drm_gem_dmabuf_vmap
,
157 .vunmap
= drm_gem_dmabuf_vunmap
,
163 * Drivers can implement @gem_prime_export and @gem_prime_import in terms of
164 * simpler APIs by using the helper functions @drm_gem_prime_export and
165 * @drm_gem_prime_import. These functions implement dma-buf support in terms of
166 * five lower-level driver callbacks:
170 * - @gem_prime_pin (optional): prepare a GEM object for exporting
172 * - @gem_prime_get_sg_table: provide a scatter/gather table of pinned pages
174 * - @gem_prime_vmap: vmap a buffer exported by your driver
176 * - @gem_prime_vunmap: vunmap a buffer exported by your driver
180 * - @gem_prime_import_sg_table (import): produce a GEM object from another
181 * driver's scatter/gather table
184 struct dma_buf
*drm_gem_prime_export(struct drm_device
*dev
,
185 struct drm_gem_object
*obj
, int flags
)
187 if (dev
->driver
->gem_prime_pin
) {
188 int ret
= dev
->driver
->gem_prime_pin(obj
);
192 return dma_buf_export(obj
, &drm_gem_prime_dmabuf_ops
, obj
->size
,
195 EXPORT_SYMBOL(drm_gem_prime_export
);
197 int drm_gem_prime_handle_to_fd(struct drm_device
*dev
,
198 struct drm_file
*file_priv
, uint32_t handle
, uint32_t flags
,
201 struct drm_gem_object
*obj
;
205 obj
= drm_gem_object_lookup(dev
, file_priv
, handle
);
209 mutex_lock(&file_priv
->prime
.lock
);
210 /* re-export the original imported object */
211 if (obj
->import_attach
) {
212 get_dma_buf(obj
->import_attach
->dmabuf
);
213 *prime_fd
= dma_buf_fd(obj
->import_attach
->dmabuf
, flags
);
214 drm_gem_object_unreference_unlocked(obj
);
215 mutex_unlock(&file_priv
->prime
.lock
);
219 if (obj
->export_dma_buf
) {
220 get_dma_buf(obj
->export_dma_buf
);
221 *prime_fd
= dma_buf_fd(obj
->export_dma_buf
, flags
);
222 drm_gem_object_unreference_unlocked(obj
);
224 buf
= dev
->driver
->gem_prime_export(dev
, obj
, flags
);
226 /* normally the created dma-buf takes ownership of the ref,
227 * but if that fails then drop the ref
229 drm_gem_object_unreference_unlocked(obj
);
230 mutex_unlock(&file_priv
->prime
.lock
);
233 obj
->export_dma_buf
= buf
;
234 *prime_fd
= dma_buf_fd(buf
, flags
);
236 /* if we've exported this buffer the cheat and add it to the import list
237 * so we get the correct handle back
239 ret
= drm_prime_add_imported_buf_handle(&file_priv
->prime
,
240 obj
->export_dma_buf
, handle
);
242 drm_gem_object_unreference_unlocked(obj
);
243 mutex_unlock(&file_priv
->prime
.lock
);
247 mutex_unlock(&file_priv
->prime
.lock
);
250 EXPORT_SYMBOL(drm_gem_prime_handle_to_fd
);
252 struct drm_gem_object
*drm_gem_prime_import(struct drm_device
*dev
,
253 struct dma_buf
*dma_buf
)
255 struct dma_buf_attachment
*attach
;
256 struct sg_table
*sgt
;
257 struct drm_gem_object
*obj
;
260 if (!dev
->driver
->gem_prime_import_sg_table
)
261 return ERR_PTR(-EINVAL
);
263 if (dma_buf
->ops
== &drm_gem_prime_dmabuf_ops
) {
265 if (obj
->dev
== dev
) {
267 * Importing dmabuf exported from out own gem increases
268 * refcount on gem itself instead of f_count of dmabuf.
270 drm_gem_object_reference(obj
);
271 dma_buf_put(dma_buf
);
276 attach
= dma_buf_attach(dma_buf
, dev
->dev
);
278 return ERR_PTR(PTR_ERR(attach
));
280 sgt
= dma_buf_map_attachment(attach
, DMA_BIDIRECTIONAL
);
281 if (IS_ERR_OR_NULL(sgt
)) {
286 obj
= dev
->driver
->gem_prime_import_sg_table(dev
, dma_buf
->size
, sgt
);
292 obj
->import_attach
= attach
;
297 dma_buf_unmap_attachment(attach
, sgt
, DMA_BIDIRECTIONAL
);
299 dma_buf_detach(dma_buf
, attach
);
302 EXPORT_SYMBOL(drm_gem_prime_import
);
304 int drm_gem_prime_fd_to_handle(struct drm_device
*dev
,
305 struct drm_file
*file_priv
, int prime_fd
, uint32_t *handle
)
307 struct dma_buf
*dma_buf
;
308 struct drm_gem_object
*obj
;
311 dma_buf
= dma_buf_get(prime_fd
);
313 return PTR_ERR(dma_buf
);
315 mutex_lock(&file_priv
->prime
.lock
);
317 ret
= drm_prime_lookup_imported_buf_handle(&file_priv
->prime
,
324 /* never seen this one, need to import */
325 obj
= dev
->driver
->gem_prime_import(dev
, dma_buf
);
331 ret
= drm_gem_handle_create(file_priv
, obj
, handle
);
332 drm_gem_object_unreference_unlocked(obj
);
336 ret
= drm_prime_add_imported_buf_handle(&file_priv
->prime
,
341 mutex_unlock(&file_priv
->prime
.lock
);
345 /* hmm, if driver attached, we are relying on the free-object path
346 * to detach.. which seems ok..
348 drm_gem_object_handle_unreference_unlocked(obj
);
350 dma_buf_put(dma_buf
);
351 mutex_unlock(&file_priv
->prime
.lock
);
354 EXPORT_SYMBOL(drm_gem_prime_fd_to_handle
);
356 int drm_prime_handle_to_fd_ioctl(struct drm_device
*dev
, void *data
,
357 struct drm_file
*file_priv
)
359 struct drm_prime_handle
*args
= data
;
362 if (!drm_core_check_feature(dev
, DRIVER_PRIME
))
365 if (!dev
->driver
->prime_handle_to_fd
)
368 /* check flags are valid */
369 if (args
->flags
& ~DRM_CLOEXEC
)
372 /* we only want to pass DRM_CLOEXEC which is == O_CLOEXEC */
373 flags
= args
->flags
& DRM_CLOEXEC
;
375 return dev
->driver
->prime_handle_to_fd(dev
, file_priv
,
376 args
->handle
, flags
, &args
->fd
);
379 int drm_prime_fd_to_handle_ioctl(struct drm_device
*dev
, void *data
,
380 struct drm_file
*file_priv
)
382 struct drm_prime_handle
*args
= data
;
384 if (!drm_core_check_feature(dev
, DRIVER_PRIME
))
387 if (!dev
->driver
->prime_fd_to_handle
)
390 return dev
->driver
->prime_fd_to_handle(dev
, file_priv
,
391 args
->fd
, &args
->handle
);
395 * drm_prime_pages_to_sg
397 * this helper creates an sg table object from a set of pages
398 * the driver is responsible for mapping the pages into the
399 * importers address space
401 struct sg_table
*drm_prime_pages_to_sg(struct page
**pages
, int nr_pages
)
403 struct sg_table
*sg
= NULL
;
406 sg
= kmalloc(sizeof(struct sg_table
), GFP_KERNEL
);
410 ret
= sg_alloc_table_from_pages(sg
, pages
, nr_pages
, 0,
411 nr_pages
<< PAGE_SHIFT
, GFP_KERNEL
);
420 EXPORT_SYMBOL(drm_prime_pages_to_sg
);
422 /* export an sg table into an array of pages and addresses
423 this is currently required by the TTM driver in order to do correct fault
425 int drm_prime_sg_to_page_addr_arrays(struct sg_table
*sgt
, struct page
**pages
,
426 dma_addr_t
*addrs
, int max_pages
)
429 struct scatterlist
*sg
;
436 for_each_sg(sgt
->sgl
, sg
, sgt
->nents
, count
) {
440 addr
= sg_dma_address(sg
);
443 if (WARN_ON(pg_index
>= max_pages
))
445 pages
[pg_index
] = page
;
447 addrs
[pg_index
] = addr
;
457 EXPORT_SYMBOL(drm_prime_sg_to_page_addr_arrays
);
458 /* helper function to cleanup a GEM/prime object */
459 void drm_prime_gem_destroy(struct drm_gem_object
*obj
, struct sg_table
*sg
)
461 struct dma_buf_attachment
*attach
;
462 struct dma_buf
*dma_buf
;
463 attach
= obj
->import_attach
;
465 dma_buf_unmap_attachment(attach
, sg
, DMA_BIDIRECTIONAL
);
466 dma_buf
= attach
->dmabuf
;
467 dma_buf_detach(attach
->dmabuf
, attach
);
468 /* remove the reference */
469 dma_buf_put(dma_buf
);
471 EXPORT_SYMBOL(drm_prime_gem_destroy
);
473 void drm_prime_init_file_private(struct drm_prime_file_private
*prime_fpriv
)
475 INIT_LIST_HEAD(&prime_fpriv
->head
);
476 mutex_init(&prime_fpriv
->lock
);
478 EXPORT_SYMBOL(drm_prime_init_file_private
);
480 void drm_prime_destroy_file_private(struct drm_prime_file_private
*prime_fpriv
)
482 struct drm_prime_member
*member
, *safe
;
483 list_for_each_entry_safe(member
, safe
, &prime_fpriv
->head
, entry
) {
484 list_del(&member
->entry
);
488 EXPORT_SYMBOL(drm_prime_destroy_file_private
);
490 int drm_prime_add_imported_buf_handle(struct drm_prime_file_private
*prime_fpriv
, struct dma_buf
*dma_buf
, uint32_t handle
)
492 struct drm_prime_member
*member
;
494 member
= kmalloc(sizeof(*member
), GFP_KERNEL
);
498 member
->dma_buf
= dma_buf
;
499 member
->handle
= handle
;
500 list_add(&member
->entry
, &prime_fpriv
->head
);
503 EXPORT_SYMBOL(drm_prime_add_imported_buf_handle
);
505 int drm_prime_lookup_imported_buf_handle(struct drm_prime_file_private
*prime_fpriv
, struct dma_buf
*dma_buf
, uint32_t *handle
)
507 struct drm_prime_member
*member
;
509 list_for_each_entry(member
, &prime_fpriv
->head
, entry
) {
510 if (member
->dma_buf
== dma_buf
) {
511 *handle
= member
->handle
;
517 EXPORT_SYMBOL(drm_prime_lookup_imported_buf_handle
);
519 void drm_prime_remove_imported_buf_handle(struct drm_prime_file_private
*prime_fpriv
, struct dma_buf
*dma_buf
)
521 struct drm_prime_member
*member
, *safe
;
523 mutex_lock(&prime_fpriv
->lock
);
524 list_for_each_entry_safe(member
, safe
, &prime_fpriv
->head
, entry
) {
525 if (member
->dma_buf
== dma_buf
) {
526 list_del(&member
->entry
);
530 mutex_unlock(&prime_fpriv
->lock
);
532 EXPORT_SYMBOL(drm_prime_remove_imported_buf_handle
);