1 | /* SPDX-License-Identifier: GPL-2.0-only */ |
2 | /* |
3 | * Header file for dma buffer sharing framework. |
4 | * |
5 | * Copyright(C) 2011 Linaro Limited. All rights reserved. |
6 | * Author: Sumit Semwal <sumit.semwal@ti.com> |
7 | * |
8 | * Many thanks to linaro-mm-sig list, and specially |
9 | * Arnd Bergmann <arnd@arndb.de>, Rob Clark <rob@ti.com> and |
10 | * Daniel Vetter <daniel@ffwll.ch> for their support in creation and |
11 | * refining of this idea. |
12 | */ |
13 | #ifndef __DMA_BUF_H__ |
14 | #define __DMA_BUF_H__ |
15 | |
16 | #include <linux/iosys-map.h> |
17 | #include <linux/file.h> |
18 | #include <linux/err.h> |
19 | #include <linux/scatterlist.h> |
20 | #include <linux/list.h> |
21 | #include <linux/dma-mapping.h> |
22 | #include <linux/fs.h> |
23 | #include <linux/dma-fence.h> |
24 | #include <linux/wait.h> |
25 | |
26 | struct device; |
27 | struct dma_buf; |
28 | struct dma_buf_attachment; |
29 | |
30 | /** |
31 | * struct dma_buf_ops - operations possible on struct dma_buf |
32 | * @vmap: [optional] creates a virtual mapping for the buffer into kernel |
33 | * address space. Same restrictions as for vmap and friends apply. |
34 | * @vunmap: [optional] unmaps a vmap from the buffer |
35 | */ |
36 | struct dma_buf_ops { |
37 | /** |
38 | * @cache_sgt_mapping: |
39 | * |
40 | * If true the framework will cache the first mapping made for each |
41 | * attachment. This avoids creating mappings for attachments multiple |
42 | * times. |
43 | */ |
44 | bool cache_sgt_mapping; |
45 | |
46 | /** |
47 | * @attach: |
48 | * |
49 | * This is called from dma_buf_attach() to make sure that a given |
50 | * &dma_buf_attachment.dev can access the provided &dma_buf. Exporters |
51 | * which support buffer objects in special locations like VRAM or |
52 | * device-specific carveout areas should check whether the buffer could |
53 | * be move to system memory (or directly accessed by the provided |
54 | * device), and otherwise need to fail the attach operation. |
55 | * |
56 | * The exporter should also in general check whether the current |
57 | * allocation fulfills the DMA constraints of the new device. If this |
58 | * is not the case, and the allocation cannot be moved, it should also |
59 | * fail the attach operation. |
60 | * |
61 | * Any exporter-private housekeeping data can be stored in the |
62 | * &dma_buf_attachment.priv pointer. |
63 | * |
64 | * This callback is optional. |
65 | * |
66 | * Returns: |
67 | * |
68 | * 0 on success, negative error code on failure. It might return -EBUSY |
69 | * to signal that backing storage is already allocated and incompatible |
70 | * with the requirements of requesting device. |
71 | */ |
72 | int (*attach)(struct dma_buf *, struct dma_buf_attachment *); |
73 | |
74 | /** |
75 | * @detach: |
76 | * |
77 | * This is called by dma_buf_detach() to release a &dma_buf_attachment. |
78 | * Provided so that exporters can clean up any housekeeping for an |
79 | * &dma_buf_attachment. |
80 | * |
81 | * This callback is optional. |
82 | */ |
83 | void (*detach)(struct dma_buf *, struct dma_buf_attachment *); |
84 | |
85 | /** |
86 | * @pin: |
87 | * |
88 | * This is called by dma_buf_pin() and lets the exporter know that the |
89 | * DMA-buf can't be moved any more. Ideally, the exporter should |
90 | * pin the buffer so that it is generally accessible by all |
91 | * devices. |
92 | * |
93 | * This is called with the &dmabuf.resv object locked and is mutual |
94 | * exclusive with @cache_sgt_mapping. |
95 | * |
96 | * This is called automatically for non-dynamic importers from |
97 | * dma_buf_attach(). |
98 | * |
99 | * Note that similar to non-dynamic exporters in their @map_dma_buf |
100 | * callback the driver must guarantee that the memory is available for |
101 | * use and cleared of any old data by the time this function returns. |
102 | * Drivers which pipeline their buffer moves internally must wait for |
103 | * all moves and clears to complete. |
104 | * |
105 | * Returns: |
106 | * |
107 | * 0 on success, negative error code on failure. |
108 | */ |
109 | int (*pin)(struct dma_buf_attachment *attach); |
110 | |
111 | /** |
112 | * @unpin: |
113 | * |
114 | * This is called by dma_buf_unpin() and lets the exporter know that the |
115 | * DMA-buf can be moved again. |
116 | * |
117 | * This is called with the dmabuf->resv object locked and is mutual |
118 | * exclusive with @cache_sgt_mapping. |
119 | * |
120 | * This callback is optional. |
121 | */ |
122 | void (*unpin)(struct dma_buf_attachment *attach); |
123 | |
124 | /** |
125 | * @map_dma_buf: |
126 | * |
127 | * This is called by dma_buf_map_attachment() and is used to map a |
128 | * shared &dma_buf into device address space, and it is mandatory. It |
129 | * can only be called if @attach has been called successfully. |
130 | * |
131 | * This call may sleep, e.g. when the backing storage first needs to be |
132 | * allocated, or moved to a location suitable for all currently attached |
133 | * devices. |
134 | * |
135 | * Note that any specific buffer attributes required for this function |
136 | * should get added to device_dma_parameters accessible via |
137 | * &device.dma_params from the &dma_buf_attachment. The @attach callback |
138 | * should also check these constraints. |
139 | * |
140 | * If this is being called for the first time, the exporter can now |
141 | * choose to scan through the list of attachments for this buffer, |
142 | * collate the requirements of the attached devices, and choose an |
143 | * appropriate backing storage for the buffer. |
144 | * |
145 | * Based on enum dma_data_direction, it might be possible to have |
146 | * multiple users accessing at the same time (for reading, maybe), or |
147 | * any other kind of sharing that the exporter might wish to make |
148 | * available to buffer-users. |
149 | * |
150 | * This is always called with the dmabuf->resv object locked when |
151 | * the dynamic_mapping flag is true. |
152 | * |
153 | * Note that for non-dynamic exporters the driver must guarantee that |
154 | * that the memory is available for use and cleared of any old data by |
155 | * the time this function returns. Drivers which pipeline their buffer |
156 | * moves internally must wait for all moves and clears to complete. |
157 | * Dynamic exporters do not need to follow this rule: For non-dynamic |
158 | * importers the buffer is already pinned through @pin, which has the |
159 | * same requirements. Dynamic importers otoh are required to obey the |
160 | * dma_resv fences. |
161 | * |
162 | * Returns: |
163 | * |
164 | * A &sg_table scatter list of the backing storage of the DMA buffer, |
165 | * already mapped into the device address space of the &device attached |
166 | * with the provided &dma_buf_attachment. The addresses and lengths in |
167 | * the scatter list are PAGE_SIZE aligned. |
168 | * |
169 | * On failure, returns a negative error value wrapped into a pointer. |
170 | * May also return -EINTR when a signal was received while being |
171 | * blocked. |
172 | * |
173 | * Note that exporters should not try to cache the scatter list, or |
174 | * return the same one for multiple calls. Caching is done either by the |
175 | * DMA-BUF code (for non-dynamic importers) or the importer. Ownership |
176 | * of the scatter list is transferred to the caller, and returned by |
177 | * @unmap_dma_buf. |
178 | */ |
179 | struct sg_table * (*map_dma_buf)(struct dma_buf_attachment *, |
180 | enum dma_data_direction); |
181 | /** |
182 | * @unmap_dma_buf: |
183 | * |
184 | * This is called by dma_buf_unmap_attachment() and should unmap and |
185 | * release the &sg_table allocated in @map_dma_buf, and it is mandatory. |
186 | * For static dma_buf handling this might also unpin the backing |
187 | * storage if this is the last mapping of the DMA buffer. |
188 | */ |
189 | void (*unmap_dma_buf)(struct dma_buf_attachment *, |
190 | struct sg_table *, |
191 | enum dma_data_direction); |
192 | |
193 | /* TODO: Add try_map_dma_buf version, to return immed with -EBUSY |
194 | * if the call would block. |
195 | */ |
196 | |
197 | /** |
198 | * @release: |
199 | * |
200 | * Called after the last dma_buf_put to release the &dma_buf, and |
201 | * mandatory. |
202 | */ |
203 | void (*release)(struct dma_buf *); |
204 | |
205 | /** |
206 | * @begin_cpu_access: |
207 | * |
208 | * This is called from dma_buf_begin_cpu_access() and allows the |
209 | * exporter to ensure that the memory is actually coherent for cpu |
210 | * access. The exporter also needs to ensure that cpu access is coherent |
211 | * for the access direction. The direction can be used by the exporter |
212 | * to optimize the cache flushing, i.e. access with a different |
213 | * direction (read instead of write) might return stale or even bogus |
214 | * data (e.g. when the exporter needs to copy the data to temporary |
215 | * storage). |
216 | * |
217 | * Note that this is both called through the DMA_BUF_IOCTL_SYNC IOCTL |
218 | * command for userspace mappings established through @mmap, and also |
219 | * for kernel mappings established with @vmap. |
220 | * |
221 | * This callback is optional. |
222 | * |
223 | * Returns: |
224 | * |
225 | * 0 on success or a negative error code on failure. This can for |
226 | * example fail when the backing storage can't be allocated. Can also |
227 | * return -ERESTARTSYS or -EINTR when the call has been interrupted and |
228 | * needs to be restarted. |
229 | */ |
230 | int (*begin_cpu_access)(struct dma_buf *, enum dma_data_direction); |
231 | |
232 | /** |
233 | * @end_cpu_access: |
234 | * |
235 | * This is called from dma_buf_end_cpu_access() when the importer is |
236 | * done accessing the CPU. The exporter can use this to flush caches and |
237 | * undo anything else done in @begin_cpu_access. |
238 | * |
239 | * This callback is optional. |
240 | * |
241 | * Returns: |
242 | * |
243 | * 0 on success or a negative error code on failure. Can return |
244 | * -ERESTARTSYS or -EINTR when the call has been interrupted and needs |
245 | * to be restarted. |
246 | */ |
247 | int (*end_cpu_access)(struct dma_buf *, enum dma_data_direction); |
248 | |
249 | /** |
250 | * @mmap: |
251 | * |
252 | * This callback is used by the dma_buf_mmap() function |
253 | * |
254 | * Note that the mapping needs to be incoherent, userspace is expected |
255 | * to bracket CPU access using the DMA_BUF_IOCTL_SYNC interface. |
256 | * |
257 | * Because dma-buf buffers have invariant size over their lifetime, the |
258 | * dma-buf core checks whether a vma is too large and rejects such |
259 | * mappings. The exporter hence does not need to duplicate this check. |
260 | * Drivers do not need to check this themselves. |
261 | * |
262 | * If an exporter needs to manually flush caches and hence needs to fake |
263 | * coherency for mmap support, it needs to be able to zap all the ptes |
264 | * pointing at the backing storage. Now linux mm needs a struct |
265 | * address_space associated with the struct file stored in vma->vm_file |
266 | * to do that with the function unmap_mapping_range. But the dma_buf |
267 | * framework only backs every dma_buf fd with the anon_file struct file, |
268 | * i.e. all dma_bufs share the same file. |
269 | * |
270 | * Hence exporters need to setup their own file (and address_space) |
271 | * association by setting vma->vm_file and adjusting vma->vm_pgoff in |
272 | * the dma_buf mmap callback. In the specific case of a gem driver the |
273 | * exporter could use the shmem file already provided by gem (and set |
274 | * vm_pgoff = 0). Exporters can then zap ptes by unmapping the |
275 | * corresponding range of the struct address_space associated with their |
276 | * own file. |
277 | * |
278 | * This callback is optional. |
279 | * |
280 | * Returns: |
281 | * |
282 | * 0 on success or a negative error code on failure. |
283 | */ |
284 | int (*mmap)(struct dma_buf *, struct vm_area_struct *vma); |
285 | |
286 | int (*vmap)(struct dma_buf *dmabuf, struct iosys_map *map); |
287 | void (*vunmap)(struct dma_buf *dmabuf, struct iosys_map *map); |
288 | }; |
289 | |
290 | /** |
291 | * struct dma_buf - shared buffer object |
292 | * |
293 | * This represents a shared buffer, created by calling dma_buf_export(). The |
294 | * userspace representation is a normal file descriptor, which can be created by |
295 | * calling dma_buf_fd(). |
296 | * |
297 | * Shared dma buffers are reference counted using dma_buf_put() and |
298 | * get_dma_buf(). |
299 | * |
300 | * Device DMA access is handled by the separate &struct dma_buf_attachment. |
301 | */ |
302 | struct dma_buf { |
303 | /** |
304 | * @size: |
305 | * |
306 | * Size of the buffer; invariant over the lifetime of the buffer. |
307 | */ |
308 | size_t size; |
309 | |
310 | /** |
311 | * @file: |
312 | * |
313 | * File pointer used for sharing buffers across, and for refcounting. |
314 | * See dma_buf_get() and dma_buf_put(). |
315 | */ |
316 | struct file *file; |
317 | |
318 | /** |
319 | * @attachments: |
320 | * |
321 | * List of dma_buf_attachment that denotes all devices attached, |
322 | * protected by &dma_resv lock @resv. |
323 | */ |
324 | struct list_head attachments; |
325 | |
326 | /** @ops: dma_buf_ops associated with this buffer object. */ |
327 | const struct dma_buf_ops *ops; |
328 | |
329 | /** |
330 | * @vmapping_counter: |
331 | * |
332 | * Used internally to refcnt the vmaps returned by dma_buf_vmap(). |
333 | * Protected by @lock. |
334 | */ |
335 | unsigned vmapping_counter; |
336 | |
337 | /** |
338 | * @vmap_ptr: |
339 | * The current vmap ptr if @vmapping_counter > 0. Protected by @lock. |
340 | */ |
341 | struct iosys_map vmap_ptr; |
342 | |
343 | /** |
344 | * @exp_name: |
345 | * |
346 | * Name of the exporter; useful for debugging. See the |
347 | * DMA_BUF_SET_NAME IOCTL. |
348 | */ |
349 | const char *exp_name; |
350 | |
351 | /** |
352 | * @name: |
353 | * |
354 | * Userspace-provided name; useful for accounting and debugging, |
355 | * protected by dma_resv_lock() on @resv and @name_lock for read access. |
356 | */ |
357 | const char *name; |
358 | |
359 | /** @name_lock: Spinlock to protect name access for read access. */ |
360 | spinlock_t name_lock; |
361 | |
362 | /** |
363 | * @owner: |
364 | * |
365 | * Pointer to exporter module; used for refcounting when exporter is a |
366 | * kernel module. |
367 | */ |
368 | struct module *owner; |
369 | |
370 | /** @list_node: node for dma_buf accounting and debugging. */ |
371 | struct list_head list_node; |
372 | |
373 | /** @priv: exporter specific private data for this buffer object. */ |
374 | void *priv; |
375 | |
376 | /** |
377 | * @resv: |
378 | * |
379 | * Reservation object linked to this dma-buf. |
380 | * |
381 | * IMPLICIT SYNCHRONIZATION RULES: |
382 | * |
383 | * Drivers which support implicit synchronization of buffer access as |
384 | * e.g. exposed in `Implicit Fence Poll Support`_ must follow the |
385 | * below rules. |
386 | * |
387 | * - Drivers must add a read fence through dma_resv_add_fence() with the |
388 | * DMA_RESV_USAGE_READ flag for anything the userspace API considers a |
389 | * read access. This highly depends upon the API and window system. |
390 | * |
391 | * - Similarly drivers must add a write fence through |
392 | * dma_resv_add_fence() with the DMA_RESV_USAGE_WRITE flag for |
393 | * anything the userspace API considers write access. |
394 | * |
395 | * - Drivers may just always add a write fence, since that only |
396 | * causes unnecessary synchronization, but no correctness issues. |
397 | * |
398 | * - Some drivers only expose a synchronous userspace API with no |
399 | * pipelining across drivers. These do not set any fences for their |
400 | * access. An example here is v4l. |
401 | * |
402 | * - Driver should use dma_resv_usage_rw() when retrieving fences as |
403 | * dependency for implicit synchronization. |
404 | * |
405 | * DYNAMIC IMPORTER RULES: |
406 | * |
407 | * Dynamic importers, see dma_buf_attachment_is_dynamic(), have |
408 | * additional constraints on how they set up fences: |
409 | * |
410 | * - Dynamic importers must obey the write fences and wait for them to |
411 | * signal before allowing access to the buffer's underlying storage |
412 | * through the device. |
413 | * |
414 | * - Dynamic importers should set fences for any access that they can't |
415 | * disable immediately from their &dma_buf_attach_ops.move_notify |
416 | * callback. |
417 | * |
418 | * IMPORTANT: |
419 | * |
420 | * All drivers and memory management related functions must obey the |
421 | * struct dma_resv rules, specifically the rules for updating and |
422 | * obeying fences. See enum dma_resv_usage for further descriptions. |
423 | */ |
424 | struct dma_resv *resv; |
425 | |
426 | /** @poll: for userspace poll support */ |
427 | wait_queue_head_t poll; |
428 | |
429 | /** @cb_in: for userspace poll support */ |
430 | /** @cb_out: for userspace poll support */ |
431 | struct dma_buf_poll_cb_t { |
432 | struct dma_fence_cb cb; |
433 | wait_queue_head_t *poll; |
434 | |
435 | __poll_t active; |
436 | } cb_in, cb_out; |
437 | #ifdef CONFIG_DMABUF_SYSFS_STATS |
438 | /** |
439 | * @sysfs_entry: |
440 | * |
441 | * For exposing information about this buffer in sysfs. See also |
442 | * `DMA-BUF statistics`_ for the uapi this enables. |
443 | */ |
444 | struct dma_buf_sysfs_entry { |
445 | struct kobject kobj; |
446 | struct dma_buf *dmabuf; |
447 | } *sysfs_entry; |
448 | #endif |
449 | }; |
450 | |
451 | /** |
452 | * struct dma_buf_attach_ops - importer operations for an attachment |
453 | * |
454 | * Attachment operations implemented by the importer. |
455 | */ |
456 | struct dma_buf_attach_ops { |
457 | /** |
458 | * @allow_peer2peer: |
459 | * |
460 | * If this is set to true the importer must be able to handle peer |
461 | * resources without struct pages. |
462 | */ |
463 | bool allow_peer2peer; |
464 | |
465 | /** |
466 | * @move_notify: [optional] notification that the DMA-buf is moving |
467 | * |
468 | * If this callback is provided the framework can avoid pinning the |
469 | * backing store while mappings exists. |
470 | * |
471 | * This callback is called with the lock of the reservation object |
472 | * associated with the dma_buf held and the mapping function must be |
473 | * called with this lock held as well. This makes sure that no mapping |
474 | * is created concurrently with an ongoing move operation. |
475 | * |
476 | * Mappings stay valid and are not directly affected by this callback. |
477 | * But the DMA-buf can now be in a different physical location, so all |
478 | * mappings should be destroyed and re-created as soon as possible. |
479 | * |
480 | * New mappings can be created after this callback returns, and will |
481 | * point to the new location of the DMA-buf. |
482 | */ |
483 | void (*move_notify)(struct dma_buf_attachment *attach); |
484 | }; |
485 | |
486 | /** |
487 | * struct dma_buf_attachment - holds device-buffer attachment data |
488 | * @dmabuf: buffer for this attachment. |
489 | * @dev: device attached to the buffer. |
490 | * @node: list of dma_buf_attachment, protected by dma_resv lock of the dmabuf. |
491 | * @sgt: cached mapping. |
492 | * @dir: direction of cached mapping. |
493 | * @peer2peer: true if the importer can handle peer resources without pages. |
494 | * @priv: exporter specific attachment data. |
495 | * @importer_ops: importer operations for this attachment, if provided |
496 | * dma_buf_map/unmap_attachment() must be called with the dma_resv lock held. |
497 | * @importer_priv: importer specific attachment data. |
498 | * |
499 | * This structure holds the attachment information between the dma_buf buffer |
500 | * and its user device(s). The list contains one attachment struct per device |
501 | * attached to the buffer. |
502 | * |
503 | * An attachment is created by calling dma_buf_attach(), and released again by |
504 | * calling dma_buf_detach(). The DMA mapping itself needed to initiate a |
505 | * transfer is created by dma_buf_map_attachment() and freed again by calling |
506 | * dma_buf_unmap_attachment(). |
507 | */ |
508 | struct dma_buf_attachment { |
509 | struct dma_buf *dmabuf; |
510 | struct device *dev; |
511 | struct list_head node; |
512 | struct sg_table *sgt; |
513 | enum dma_data_direction dir; |
514 | bool peer2peer; |
515 | const struct dma_buf_attach_ops *importer_ops; |
516 | void *importer_priv; |
517 | void *priv; |
518 | }; |
519 | |
520 | /** |
521 | * struct dma_buf_export_info - holds information needed to export a dma_buf |
522 | * @exp_name: name of the exporter - useful for debugging. |
523 | * @owner: pointer to exporter module - used for refcounting kernel module |
524 | * @ops: Attach allocator-defined dma buf ops to the new buffer |
525 | * @size: Size of the buffer - invariant over the lifetime of the buffer |
526 | * @flags: mode flags for the file |
527 | * @resv: reservation-object, NULL to allocate default one |
528 | * @priv: Attach private data of allocator to this buffer |
529 | * |
530 | * This structure holds the information required to export the buffer. Used |
531 | * with dma_buf_export() only. |
532 | */ |
533 | struct dma_buf_export_info { |
534 | const char *exp_name; |
535 | struct module *owner; |
536 | const struct dma_buf_ops *ops; |
537 | size_t size; |
538 | int flags; |
539 | struct dma_resv *resv; |
540 | void *priv; |
541 | }; |
542 | |
543 | /** |
544 | * DEFINE_DMA_BUF_EXPORT_INFO - helper macro for exporters |
545 | * @name: export-info name |
546 | * |
547 | * DEFINE_DMA_BUF_EXPORT_INFO macro defines the &struct dma_buf_export_info, |
548 | * zeroes it out and pre-populates exp_name in it. |
549 | */ |
550 | #define DEFINE_DMA_BUF_EXPORT_INFO(name) \ |
551 | struct dma_buf_export_info name = { .exp_name = KBUILD_MODNAME, \ |
552 | .owner = THIS_MODULE } |
553 | |
554 | /** |
555 | * get_dma_buf - convenience wrapper for get_file. |
556 | * @dmabuf: [in] pointer to dma_buf |
557 | * |
558 | * Increments the reference count on the dma-buf, needed in case of drivers |
559 | * that either need to create additional references to the dmabuf on the |
560 | * kernel side. For example, an exporter that needs to keep a dmabuf ptr |
561 | * so that subsequent exports don't create a new dmabuf. |
562 | */ |
563 | static inline void get_dma_buf(struct dma_buf *dmabuf) |
564 | { |
565 | get_file(f: dmabuf->file); |
566 | } |
567 | |
568 | /** |
569 | * dma_buf_is_dynamic - check if a DMA-buf uses dynamic mappings. |
570 | * @dmabuf: the DMA-buf to check |
571 | * |
572 | * Returns true if a DMA-buf exporter wants to be called with the dma_resv |
573 | * locked for the map/unmap callbacks, false if it doesn't wants to be called |
574 | * with the lock held. |
575 | */ |
576 | static inline bool dma_buf_is_dynamic(struct dma_buf *dmabuf) |
577 | { |
578 | return !!dmabuf->ops->pin; |
579 | } |
580 | |
581 | /** |
582 | * dma_buf_attachment_is_dynamic - check if a DMA-buf attachment uses dynamic |
583 | * mappings |
584 | * @attach: the DMA-buf attachment to check |
585 | * |
586 | * Returns true if a DMA-buf importer wants to call the map/unmap functions with |
587 | * the dma_resv lock held. |
588 | */ |
589 | static inline bool |
590 | dma_buf_attachment_is_dynamic(struct dma_buf_attachment *attach) |
591 | { |
592 | return !!attach->importer_ops; |
593 | } |
594 | |
595 | struct dma_buf_attachment *dma_buf_attach(struct dma_buf *dmabuf, |
596 | struct device *dev); |
597 | struct dma_buf_attachment * |
598 | dma_buf_dynamic_attach(struct dma_buf *dmabuf, struct device *dev, |
599 | const struct dma_buf_attach_ops *importer_ops, |
600 | void *importer_priv); |
601 | void dma_buf_detach(struct dma_buf *dmabuf, |
602 | struct dma_buf_attachment *attach); |
603 | int dma_buf_pin(struct dma_buf_attachment *attach); |
604 | void dma_buf_unpin(struct dma_buf_attachment *attach); |
605 | |
606 | struct dma_buf *dma_buf_export(const struct dma_buf_export_info *exp_info); |
607 | |
608 | int dma_buf_fd(struct dma_buf *dmabuf, int flags); |
609 | struct dma_buf *dma_buf_get(int fd); |
610 | void dma_buf_put(struct dma_buf *dmabuf); |
611 | |
612 | struct sg_table *dma_buf_map_attachment(struct dma_buf_attachment *, |
613 | enum dma_data_direction); |
614 | void dma_buf_unmap_attachment(struct dma_buf_attachment *, struct sg_table *, |
615 | enum dma_data_direction); |
616 | void dma_buf_move_notify(struct dma_buf *dma_buf); |
617 | int dma_buf_begin_cpu_access(struct dma_buf *dma_buf, |
618 | enum dma_data_direction dir); |
619 | int dma_buf_end_cpu_access(struct dma_buf *dma_buf, |
620 | enum dma_data_direction dir); |
621 | struct sg_table * |
622 | dma_buf_map_attachment_unlocked(struct dma_buf_attachment *attach, |
623 | enum dma_data_direction direction); |
624 | void dma_buf_unmap_attachment_unlocked(struct dma_buf_attachment *attach, |
625 | struct sg_table *sg_table, |
626 | enum dma_data_direction direction); |
627 | |
628 | int dma_buf_mmap(struct dma_buf *, struct vm_area_struct *, |
629 | unsigned long); |
630 | int dma_buf_vmap(struct dma_buf *dmabuf, struct iosys_map *map); |
631 | void dma_buf_vunmap(struct dma_buf *dmabuf, struct iosys_map *map); |
632 | int dma_buf_vmap_unlocked(struct dma_buf *dmabuf, struct iosys_map *map); |
633 | void dma_buf_vunmap_unlocked(struct dma_buf *dmabuf, struct iosys_map *map); |
634 | #endif /* __DMA_BUF_H__ */ |
635 | |