2 * Framework for buffer objects that can be shared across devices/subsystems.
4 * Copyright(C) 2011 Linaro Limited. All rights reserved.
5 * Author: Sumit Semwal <sumit.semwal@ti.com>
7 * Many thanks to linaro-mm-sig list, and specially
8 * Arnd Bergmann <arnd@arndb.de>, Rob Clark <rob@ti.com> and
9 * Daniel Vetter <daniel@ffwll.ch> for their support in creation and
10 * refining of this idea.
12 * This program is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU General Public License version 2 as published by
14 * the Free Software Foundation.
16 * This program is distributed in the hope that it will be useful, but WITHOUT
17 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
21 * You should have received a copy of the GNU General Public License along with
22 * this program. If not, see <http://www.gnu.org/licenses/>.
26 #include <linux/slab.h>
27 #include <linux/dma-buf.h>
28 #include <linux/anon_inodes.h>
29 #include <linux/export.h>
30 #include <linux/debugfs.h>
31 #include <linux/seq_file.h>
33 static inline int is_dma_buf_file(struct file
*);
36 struct list_head head
;
40 static struct dma_buf_list db_list
;
42 static int dma_buf_release(struct inode
*inode
, struct file
*file
)
44 struct dma_buf
*dmabuf
;
46 if (!is_dma_buf_file(file
))
49 dmabuf
= file
->private_data
;
51 BUG_ON(dmabuf
->vmapping_counter
);
53 dmabuf
->ops
->release(dmabuf
);
55 mutex_lock(&db_list
.lock
);
56 list_del(&dmabuf
->list_node
);
57 mutex_unlock(&db_list
.lock
);
63 static int dma_buf_mmap_internal(struct file
*file
, struct vm_area_struct
*vma
)
65 struct dma_buf
*dmabuf
;
67 if (!is_dma_buf_file(file
))
70 dmabuf
= file
->private_data
;
72 /* check for overflowing the buffer's size */
73 if (vma
->vm_pgoff
+ ((vma
->vm_end
- vma
->vm_start
) >> PAGE_SHIFT
) >
74 dmabuf
->size
>> PAGE_SHIFT
)
77 return dmabuf
->ops
->mmap(dmabuf
, vma
);
80 static loff_t
dma_buf_llseek(struct file
*file
, loff_t offset
, int whence
)
82 struct dma_buf
*dmabuf
;
85 if (!is_dma_buf_file(file
))
88 dmabuf
= file
->private_data
;
90 /* only support discovering the end of the buffer,
91 but also allow SEEK_SET to maintain the idiomatic
92 SEEK_END(0), SEEK_CUR(0) pattern */
93 if (whence
== SEEK_END
)
95 else if (whence
== SEEK_SET
)
103 return base
+ offset
;
106 static const struct file_operations dma_buf_fops
= {
107 .release
= dma_buf_release
,
108 .mmap
= dma_buf_mmap_internal
,
109 .llseek
= dma_buf_llseek
,
113 * is_dma_buf_file - Check if struct file* is associated with dma_buf
115 static inline int is_dma_buf_file(struct file
*file
)
117 return file
->f_op
== &dma_buf_fops
;
121 * dma_buf_export_named - Creates a new dma_buf, and associates an anon file
122 * with this buffer, so it can be exported.
123 * Also connect the allocator specific data and ops to the buffer.
124 * Additionally, provide a name string for exporter; useful in debugging.
126 * @priv: [in] Attach private data of allocator to this buffer
127 * @ops: [in] Attach allocator-defined dma buf ops to the new buffer.
128 * @size: [in] Size of the buffer
129 * @flags: [in] mode flags for the file.
130 * @exp_name: [in] name of the exporting module - useful for debugging.
132 * Returns, on success, a newly created dma_buf object, which wraps the
133 * supplied private data and operations for dma_buf_ops. On either missing
134 * ops, or error in allocating struct dma_buf, will return negative error.
137 struct dma_buf
*dma_buf_export_named(void *priv
, const struct dma_buf_ops
*ops
,
138 size_t size
, int flags
, const char *exp_name
)
140 struct dma_buf
*dmabuf
;
143 if (WARN_ON(!priv
|| !ops
145 || !ops
->unmap_dma_buf
150 return ERR_PTR(-EINVAL
);
153 dmabuf
= kzalloc(sizeof(struct dma_buf
), GFP_KERNEL
);
155 return ERR_PTR(-ENOMEM
);
160 dmabuf
->exp_name
= exp_name
;
162 file
= anon_inode_getfile("dmabuf", &dma_buf_fops
, dmabuf
, flags
);
165 return ERR_CAST(file
);
168 file
->f_mode
|= FMODE_LSEEK
;
171 mutex_init(&dmabuf
->lock
);
172 INIT_LIST_HEAD(&dmabuf
->attachments
);
174 mutex_lock(&db_list
.lock
);
175 list_add(&dmabuf
->list_node
, &db_list
.head
);
176 mutex_unlock(&db_list
.lock
);
180 EXPORT_SYMBOL_GPL(dma_buf_export_named
);
184 * dma_buf_fd - returns a file descriptor for the given dma_buf
185 * @dmabuf: [in] pointer to dma_buf for which fd is required.
186 * @flags: [in] flags to give to fd
188 * On success, returns an associated 'fd'. Else, returns error.
190 int dma_buf_fd(struct dma_buf
*dmabuf
, int flags
)
194 if (!dmabuf
|| !dmabuf
->file
)
197 fd
= get_unused_fd_flags(flags
);
201 fd_install(fd
, dmabuf
->file
);
205 EXPORT_SYMBOL_GPL(dma_buf_fd
);
208 * dma_buf_get - returns the dma_buf structure related to an fd
209 * @fd: [in] fd associated with the dma_buf to be returned
211 * On success, returns the dma_buf structure associated with an fd; uses
212 * file's refcounting done by fget to increase refcount. returns ERR_PTR
215 struct dma_buf
*dma_buf_get(int fd
)
222 return ERR_PTR(-EBADF
);
224 if (!is_dma_buf_file(file
)) {
226 return ERR_PTR(-EINVAL
);
229 return file
->private_data
;
231 EXPORT_SYMBOL_GPL(dma_buf_get
);
234 * dma_buf_put - decreases refcount of the buffer
235 * @dmabuf: [in] buffer to reduce refcount of
237 * Uses file's refcounting done implicitly by fput()
239 void dma_buf_put(struct dma_buf
*dmabuf
)
241 if (WARN_ON(!dmabuf
|| !dmabuf
->file
))
246 EXPORT_SYMBOL_GPL(dma_buf_put
);
249 * dma_buf_attach - Add the device to dma_buf's attachments list; optionally,
250 * calls attach() of dma_buf_ops to allow device-specific attach functionality
251 * @dmabuf: [in] buffer to attach device to.
252 * @dev: [in] device to be attached.
254 * Returns struct dma_buf_attachment * for this attachment; may return negative
258 struct dma_buf_attachment
*dma_buf_attach(struct dma_buf
*dmabuf
,
261 struct dma_buf_attachment
*attach
;
264 if (WARN_ON(!dmabuf
|| !dev
))
265 return ERR_PTR(-EINVAL
);
267 attach
= kzalloc(sizeof(struct dma_buf_attachment
), GFP_KERNEL
);
269 return ERR_PTR(-ENOMEM
);
272 attach
->dmabuf
= dmabuf
;
274 mutex_lock(&dmabuf
->lock
);
276 if (dmabuf
->ops
->attach
) {
277 ret
= dmabuf
->ops
->attach(dmabuf
, dev
, attach
);
281 list_add(&attach
->node
, &dmabuf
->attachments
);
283 mutex_unlock(&dmabuf
->lock
);
288 mutex_unlock(&dmabuf
->lock
);
291 EXPORT_SYMBOL_GPL(dma_buf_attach
);
294 * dma_buf_detach - Remove the given attachment from dmabuf's attachments list;
295 * optionally calls detach() of dma_buf_ops for device-specific detach
296 * @dmabuf: [in] buffer to detach from.
297 * @attach: [in] attachment to be detached; is free'd after this call.
300 void dma_buf_detach(struct dma_buf
*dmabuf
, struct dma_buf_attachment
*attach
)
302 if (WARN_ON(!dmabuf
|| !attach
))
305 mutex_lock(&dmabuf
->lock
);
306 list_del(&attach
->node
);
307 if (dmabuf
->ops
->detach
)
308 dmabuf
->ops
->detach(dmabuf
, attach
);
310 mutex_unlock(&dmabuf
->lock
);
313 EXPORT_SYMBOL_GPL(dma_buf_detach
);
316 * dma_buf_map_attachment - Returns the scatterlist table of the attachment;
317 * mapped into _device_ address space. Is a wrapper for map_dma_buf() of the
319 * @attach: [in] attachment whose scatterlist is to be returned
320 * @direction: [in] direction of DMA transfer
322 * Returns sg_table containing the scatterlist to be returned; may return NULL
326 struct sg_table
*dma_buf_map_attachment(struct dma_buf_attachment
*attach
,
327 enum dma_data_direction direction
)
329 struct sg_table
*sg_table
= ERR_PTR(-EINVAL
);
333 if (WARN_ON(!attach
|| !attach
->dmabuf
))
334 return ERR_PTR(-EINVAL
);
336 sg_table
= attach
->dmabuf
->ops
->map_dma_buf(attach
, direction
);
340 EXPORT_SYMBOL_GPL(dma_buf_map_attachment
);
343 * dma_buf_unmap_attachment - unmaps and decreases usecount of the buffer;might
344 * deallocate the scatterlist associated. Is a wrapper for unmap_dma_buf() of
346 * @attach: [in] attachment to unmap buffer from
347 * @sg_table: [in] scatterlist info of the buffer to unmap
348 * @direction: [in] direction of DMA transfer
351 void dma_buf_unmap_attachment(struct dma_buf_attachment
*attach
,
352 struct sg_table
*sg_table
,
353 enum dma_data_direction direction
)
357 if (WARN_ON(!attach
|| !attach
->dmabuf
|| !sg_table
))
360 attach
->dmabuf
->ops
->unmap_dma_buf(attach
, sg_table
,
363 EXPORT_SYMBOL_GPL(dma_buf_unmap_attachment
);
367 * dma_buf_begin_cpu_access - Must be called before accessing a dma_buf from the
368 * cpu in the kernel context. Calls begin_cpu_access to allow exporter-specific
369 * preparations. Coherency is only guaranteed in the specified range for the
370 * specified access direction.
371 * @dmabuf: [in] buffer to prepare cpu access for.
372 * @start: [in] start of range for cpu access.
373 * @len: [in] length of range for cpu access.
374 * @direction: [in] length of range for cpu access.
376 * Can return negative error values, returns 0 on success.
378 int dma_buf_begin_cpu_access(struct dma_buf
*dmabuf
, size_t start
, size_t len
,
379 enum dma_data_direction direction
)
383 if (WARN_ON(!dmabuf
))
386 if (dmabuf
->ops
->begin_cpu_access
)
387 ret
= dmabuf
->ops
->begin_cpu_access(dmabuf
, start
, len
, direction
);
391 EXPORT_SYMBOL_GPL(dma_buf_begin_cpu_access
);
394 * dma_buf_end_cpu_access - Must be called after accessing a dma_buf from the
395 * cpu in the kernel context. Calls end_cpu_access to allow exporter-specific
396 * actions. Coherency is only guaranteed in the specified range for the
397 * specified access direction.
398 * @dmabuf: [in] buffer to complete cpu access for.
399 * @start: [in] start of range for cpu access.
400 * @len: [in] length of range for cpu access.
401 * @direction: [in] length of range for cpu access.
403 * This call must always succeed.
405 void dma_buf_end_cpu_access(struct dma_buf
*dmabuf
, size_t start
, size_t len
,
406 enum dma_data_direction direction
)
410 if (dmabuf
->ops
->end_cpu_access
)
411 dmabuf
->ops
->end_cpu_access(dmabuf
, start
, len
, direction
);
413 EXPORT_SYMBOL_GPL(dma_buf_end_cpu_access
);
416 * dma_buf_kmap_atomic - Map a page of the buffer object into kernel address
417 * space. The same restrictions as for kmap_atomic and friends apply.
418 * @dmabuf: [in] buffer to map page from.
419 * @page_num: [in] page in PAGE_SIZE units to map.
421 * This call must always succeed, any necessary preparations that might fail
422 * need to be done in begin_cpu_access.
424 void *dma_buf_kmap_atomic(struct dma_buf
*dmabuf
, unsigned long page_num
)
428 return dmabuf
->ops
->kmap_atomic(dmabuf
, page_num
);
430 EXPORT_SYMBOL_GPL(dma_buf_kmap_atomic
);
433 * dma_buf_kunmap_atomic - Unmap a page obtained by dma_buf_kmap_atomic.
434 * @dmabuf: [in] buffer to unmap page from.
435 * @page_num: [in] page in PAGE_SIZE units to unmap.
436 * @vaddr: [in] kernel space pointer obtained from dma_buf_kmap_atomic.
438 * This call must always succeed.
440 void dma_buf_kunmap_atomic(struct dma_buf
*dmabuf
, unsigned long page_num
,
445 if (dmabuf
->ops
->kunmap_atomic
)
446 dmabuf
->ops
->kunmap_atomic(dmabuf
, page_num
, vaddr
);
448 EXPORT_SYMBOL_GPL(dma_buf_kunmap_atomic
);
451 * dma_buf_kmap - Map a page of the buffer object into kernel address space. The
452 * same restrictions as for kmap and friends apply.
453 * @dmabuf: [in] buffer to map page from.
454 * @page_num: [in] page in PAGE_SIZE units to map.
456 * This call must always succeed, any necessary preparations that might fail
457 * need to be done in begin_cpu_access.
459 void *dma_buf_kmap(struct dma_buf
*dmabuf
, unsigned long page_num
)
463 return dmabuf
->ops
->kmap(dmabuf
, page_num
);
465 EXPORT_SYMBOL_GPL(dma_buf_kmap
);
468 * dma_buf_kunmap - Unmap a page obtained by dma_buf_kmap.
469 * @dmabuf: [in] buffer to unmap page from.
470 * @page_num: [in] page in PAGE_SIZE units to unmap.
471 * @vaddr: [in] kernel space pointer obtained from dma_buf_kmap.
473 * This call must always succeed.
475 void dma_buf_kunmap(struct dma_buf
*dmabuf
, unsigned long page_num
,
480 if (dmabuf
->ops
->kunmap
)
481 dmabuf
->ops
->kunmap(dmabuf
, page_num
, vaddr
);
483 EXPORT_SYMBOL_GPL(dma_buf_kunmap
);
487 * dma_buf_mmap - Setup up a userspace mmap with the given vma
488 * @dmabuf: [in] buffer that should back the vma
489 * @vma: [in] vma for the mmap
490 * @pgoff: [in] offset in pages where this mmap should start within the
493 * This function adjusts the passed in vma so that it points at the file of the
494 * dma_buf operation. It alsog adjusts the starting pgoff and does bounds
495 * checking on the size of the vma. Then it calls the exporters mmap function to
496 * set up the mapping.
498 * Can return negative error values, returns 0 on success.
500 int dma_buf_mmap(struct dma_buf
*dmabuf
, struct vm_area_struct
*vma
,
503 struct file
*oldfile
;
506 if (WARN_ON(!dmabuf
|| !vma
))
509 /* check for offset overflow */
510 if (pgoff
+ ((vma
->vm_end
- vma
->vm_start
) >> PAGE_SHIFT
) < pgoff
)
513 /* check for overflowing the buffer's size */
514 if (pgoff
+ ((vma
->vm_end
- vma
->vm_start
) >> PAGE_SHIFT
) >
515 dmabuf
->size
>> PAGE_SHIFT
)
518 /* readjust the vma */
519 get_file(dmabuf
->file
);
520 oldfile
= vma
->vm_file
;
521 vma
->vm_file
= dmabuf
->file
;
522 vma
->vm_pgoff
= pgoff
;
524 ret
= dmabuf
->ops
->mmap(dmabuf
, vma
);
526 /* restore old parameters on failure */
527 vma
->vm_file
= oldfile
;
536 EXPORT_SYMBOL_GPL(dma_buf_mmap
);
539 * dma_buf_vmap - Create virtual mapping for the buffer object into kernel
540 * address space. Same restrictions as for vmap and friends apply.
541 * @dmabuf: [in] buffer to vmap
543 * This call may fail due to lack of virtual mapping address space.
544 * These calls are optional in drivers. The intended use for them
545 * is for mapping objects linear in kernel space for high use objects.
546 * Please attempt to use kmap/kunmap before thinking about these interfaces.
548 void *dma_buf_vmap(struct dma_buf
*dmabuf
)
552 if (WARN_ON(!dmabuf
))
555 if (!dmabuf
->ops
->vmap
)
558 mutex_lock(&dmabuf
->lock
);
559 if (dmabuf
->vmapping_counter
) {
560 dmabuf
->vmapping_counter
++;
561 BUG_ON(!dmabuf
->vmap_ptr
);
562 ptr
= dmabuf
->vmap_ptr
;
566 BUG_ON(dmabuf
->vmap_ptr
);
568 ptr
= dmabuf
->ops
->vmap(dmabuf
);
569 if (IS_ERR_OR_NULL(ptr
))
572 dmabuf
->vmap_ptr
= ptr
;
573 dmabuf
->vmapping_counter
= 1;
576 mutex_unlock(&dmabuf
->lock
);
579 EXPORT_SYMBOL_GPL(dma_buf_vmap
);
582 * dma_buf_vunmap - Unmap a vmap obtained by dma_buf_vmap.
583 * @dmabuf: [in] buffer to vunmap
584 * @vaddr: [in] vmap to vunmap
586 void dma_buf_vunmap(struct dma_buf
*dmabuf
, void *vaddr
)
588 if (WARN_ON(!dmabuf
))
591 BUG_ON(!dmabuf
->vmap_ptr
);
592 BUG_ON(dmabuf
->vmapping_counter
== 0);
593 BUG_ON(dmabuf
->vmap_ptr
!= vaddr
);
595 mutex_lock(&dmabuf
->lock
);
596 if (--dmabuf
->vmapping_counter
== 0) {
597 if (dmabuf
->ops
->vunmap
)
598 dmabuf
->ops
->vunmap(dmabuf
, vaddr
);
599 dmabuf
->vmap_ptr
= NULL
;
601 mutex_unlock(&dmabuf
->lock
);
603 EXPORT_SYMBOL_GPL(dma_buf_vunmap
);
605 #ifdef CONFIG_DEBUG_FS
606 static int dma_buf_describe(struct seq_file
*s
)
609 struct dma_buf
*buf_obj
;
610 struct dma_buf_attachment
*attach_obj
;
611 int count
= 0, attach_count
;
614 ret
= mutex_lock_interruptible(&db_list
.lock
);
619 seq_printf(s
, "\nDma-buf Objects:\n");
620 seq_printf(s
, "\texp_name\tsize\tflags\tmode\tcount\n");
622 list_for_each_entry(buf_obj
, &db_list
.head
, list_node
) {
623 ret
= mutex_lock_interruptible(&buf_obj
->lock
);
627 "\tERROR locking buffer object: skipping\n");
633 seq_printf(s
, "\t%s\t%08zu\t%08x\t%08x\t%08ld\n",
634 buf_obj
->exp_name
, buf_obj
->size
,
635 buf_obj
->file
->f_flags
, buf_obj
->file
->f_mode
,
636 (long)(buf_obj
->file
->f_count
.counter
));
638 seq_printf(s
, "\t\tAttached Devices:\n");
641 list_for_each_entry(attach_obj
, &buf_obj
->attachments
, node
) {
642 seq_printf(s
, "\t\t");
644 seq_printf(s
, "%s\n", attach_obj
->dev
->init_name
);
648 seq_printf(s
, "\n\t\tTotal %d devices attached\n",
652 size
+= buf_obj
->size
;
653 mutex_unlock(&buf_obj
->lock
);
656 seq_printf(s
, "\nTotal %d objects, %zu bytes\n", count
, size
);
658 mutex_unlock(&db_list
.lock
);
662 static int dma_buf_show(struct seq_file
*s
, void *unused
)
664 void (*func
)(struct seq_file
*) = s
->private;
669 static int dma_buf_debug_open(struct inode
*inode
, struct file
*file
)
671 return single_open(file
, dma_buf_show
, inode
->i_private
);
674 static const struct file_operations dma_buf_debug_fops
= {
675 .open
= dma_buf_debug_open
,
678 .release
= single_release
,
681 static struct dentry
*dma_buf_debugfs_dir
;
683 static int dma_buf_init_debugfs(void)
686 dma_buf_debugfs_dir
= debugfs_create_dir("dma_buf", NULL
);
687 if (IS_ERR(dma_buf_debugfs_dir
)) {
688 err
= PTR_ERR(dma_buf_debugfs_dir
);
689 dma_buf_debugfs_dir
= NULL
;
693 err
= dma_buf_debugfs_create_file("bufinfo", dma_buf_describe
);
696 pr_debug("dma_buf: debugfs: failed to create node bufinfo\n");
701 static void dma_buf_uninit_debugfs(void)
703 if (dma_buf_debugfs_dir
)
704 debugfs_remove_recursive(dma_buf_debugfs_dir
);
707 int dma_buf_debugfs_create_file(const char *name
,
708 int (*write
)(struct seq_file
*))
712 d
= debugfs_create_file(name
, S_IRUGO
, dma_buf_debugfs_dir
,
713 write
, &dma_buf_debug_fops
);
715 return PTR_ERR_OR_ZERO(d
);
718 static inline int dma_buf_init_debugfs(void)
722 static inline void dma_buf_uninit_debugfs(void)
727 static int __init
dma_buf_init(void)
729 mutex_init(&db_list
.lock
);
730 INIT_LIST_HEAD(&db_list
.head
);
731 dma_buf_init_debugfs();
734 subsys_initcall(dma_buf_init
);
736 static void __exit
dma_buf_deinit(void)
738 dma_buf_uninit_debugfs();
740 __exitcall(dma_buf_deinit
);