Commit | Line | Data |
---|---|---|
caab277b | 1 | /* SPDX-License-Identifier: GPL-2.0-only */ |
d15bd7ee SS |
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. | |
d15bd7ee SS |
12 | */ |
13 | #ifndef __DMA_BUF_H__ | |
14 | #define __DMA_BUF_H__ | |
15 | ||
01fd30da | 16 | #include <linux/dma-buf-map.h> |
d15bd7ee SS |
17 | #include <linux/file.h> |
18 | #include <linux/err.h> | |
d15bd7ee SS |
19 | #include <linux/scatterlist.h> |
20 | #include <linux/list.h> | |
21 | #include <linux/dma-mapping.h> | |
f9a24d1a | 22 | #include <linux/fs.h> |
f54d1867 | 23 | #include <linux/dma-fence.h> |
9b495a58 | 24 | #include <linux/wait.h> |
d15bd7ee | 25 | |
313162d0 | 26 | struct device; |
d15bd7ee SS |
27 | struct dma_buf; |
28 | struct dma_buf_attachment; | |
29 | ||
30 | /** | |
31 | * struct dma_buf_ops - operations possible on struct dma_buf | |
12c4727e SS |
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 | |
d15bd7ee SS |
35 | */ |
36 | struct dma_buf_ops { | |
f13e143e CK |
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 | ||
2904a8c1 DV |
46 | /** |
47 | * @attach: | |
48 | * | |
49 | * This is called from dma_buf_attach() to make sure that a given | |
a19741e5 CK |
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. | |
2904a8c1 DV |
55 | * |
56 | * The exporter should also in general check whether the current | |
57 | * allocation fullfills 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 | * | |
e9b4d7b5 DV |
61 | * Any exporter-private housekeeping data can be stored in the |
62 | * &dma_buf_attachment.priv pointer. | |
2904a8c1 DV |
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 | */ | |
a19741e5 | 72 | int (*attach)(struct dma_buf *, struct dma_buf_attachment *); |
d15bd7ee | 73 | |
2904a8c1 DV |
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 | */ | |
d15bd7ee SS |
83 | void (*detach)(struct dma_buf *, struct dma_buf_attachment *); |
84 | ||
bb42df46 CK |
85 | /** |
86 | * @pin: | |
87 | * | |
85804b70 | 88 | * This is called by dma_buf_pin() and lets the exporter know that the |
c545781e DV |
89 | * DMA-buf can't be moved any more. The exporter should pin the buffer |
90 | * into system memory to make sure it is generally accessible by other | |
91 | * devices. | |
bb42df46 | 92 | * |
85804b70 | 93 | * This is called with the &dmabuf.resv object locked and is mutual |
bd2275ee | 94 | * exclusive with @cache_sgt_mapping. |
bb42df46 | 95 | * |
c545781e DV |
96 | * This is called automatically for non-dynamic importers from |
97 | * dma_buf_attach(). | |
bb42df46 | 98 | * |
89bcadc8 DV |
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 | * | |
bb42df46 CK |
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 | * | |
85804b70 | 114 | * This is called by dma_buf_unpin() and lets the exporter know that the |
bb42df46 CK |
115 | * DMA-buf can be moved again. |
116 | * | |
bd2275ee CK |
117 | * This is called with the dmabuf->resv object locked and is mutual |
118 | * exclusive with @cache_sgt_mapping. | |
bb42df46 CK |
119 | * |
120 | * This callback is optional. | |
121 | */ | |
122 | void (*unpin)(struct dma_buf_attachment *attach); | |
123 | ||
2904a8c1 DV |
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 | |
bb42df46 | 129 | * can only be called if @attach has been called successfully. |
2904a8c1 DV |
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 | |
e9b4d7b5 | 137 | * &device.dma_params from the &dma_buf_attachment. The @attach callback |
2904a8c1 DV |
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 | * | |
15fd552d CK |
150 | * This is always called with the dmabuf->resv object locked when |
151 | * the dynamic_mapping flag is true. | |
152 | * | |
89bcadc8 DV |
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 | * | |
2904a8c1 DV |
162 | * Returns: |
163 | * | |
164 | * A &sg_table scatter list of or the backing storage of the DMA buffer, | |
165 | * already mapped into the device address space of the &device attached | |
ac80cd17 JX |
166 | * with the provided &dma_buf_attachment. The addresses and lengths in |
167 | * the scatter list are PAGE_SIZE aligned. | |
2904a8c1 DV |
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. | |
84335675 DV |
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. | |
d15bd7ee SS |
178 | */ |
179 | struct sg_table * (*map_dma_buf)(struct dma_buf_attachment *, | |
2904a8c1 DV |
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. | |
bb42df46 CK |
186 | * For static dma_buf handling this might also unpins the backing |
187 | * storage if this is the last mapping of the DMA buffer. | |
2904a8c1 | 188 | */ |
d15bd7ee | 189 | void (*unmap_dma_buf)(struct dma_buf_attachment *, |
2904a8c1 DV |
190 | struct sg_table *, |
191 | enum dma_data_direction); | |
192 | ||
d15bd7ee SS |
193 | /* TODO: Add try_map_dma_buf version, to return immed with -EBUSY |
194 | * if the call would block. | |
195 | */ | |
196 | ||
2904a8c1 DV |
197 | /** |
198 | * @release: | |
199 | * | |
200 | * Called after the last dma_buf_put to release the &dma_buf, and | |
201 | * mandatory. | |
202 | */ | |
d15bd7ee SS |
203 | void (*release)(struct dma_buf *); |
204 | ||
0959a168 DV |
205 | /** |
206 | * @begin_cpu_access: | |
207 | * | |
208 | * This is called from dma_buf_begin_cpu_access() and allows the | |
de9114ec DV |
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 | |
0959a168 DV |
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 | * | |
de9114ec DV |
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. | |
0959a168 | 220 | * |
de9114ec | 221 | * This callback is optional. |
0959a168 DV |
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 | */ | |
831e9da7 | 230 | int (*begin_cpu_access)(struct dma_buf *, enum dma_data_direction); |
0959a168 DV |
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 | |
de9114ec | 237 | * undo anything else done in @begin_cpu_access. |
0959a168 DV |
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 | */ | |
18b862dc | 247 | int (*end_cpu_access)(struct dma_buf *, enum dma_data_direction); |
4c78513e | 248 | |
0959a168 DV |
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 braket 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 | */ | |
4c78513e | 284 | int (*mmap)(struct dma_buf *, struct vm_area_struct *vma); |
98f86c9e | 285 | |
6619ccf1 | 286 | int (*vmap)(struct dma_buf *dmabuf, struct dma_buf_map *map); |
20e76f1a | 287 | void (*vunmap)(struct dma_buf *dmabuf, struct dma_buf_map *map); |
d15bd7ee SS |
288 | }; |
289 | ||
290 | /** | |
291 | * struct dma_buf - shared buffer object | |
476b485b | 292 | * @size: size of the buffer; invariant over the lifetime of the buffer. |
d15bd7ee | 293 | * @file: file pointer used for sharing buffers across, and for refcounting. |
15fd552d CK |
294 | * @attachments: list of dma_buf_attachment that denotes all devices attached, |
295 | * protected by dma_resv lock. | |
d15bd7ee | 296 | * @ops: dma_buf_ops associated with this buffer object. |
bb2bb903 | 297 | * @lock: used internally to serialize list manipulation, attach/detach and |
15fd552d | 298 | * vmap/unmap |
e2082e3a RC |
299 | * @vmapping_counter: used internally to refcnt the vmaps |
300 | * @vmap_ptr: the current vmap ptr if vmapping_counter > 0 | |
78df9695 | 301 | * @exp_name: name of the exporter; useful for debugging. |
15fd552d CK |
302 | * @name: userspace-provided name; useful for accounting and debugging, |
303 | * protected by @resv. | |
0f50257f | 304 | * @name_lock: spinlock to protect name access |
9abdffe2 SS |
305 | * @owner: pointer to exporter module; used for refcounting when exporter is a |
306 | * kernel module. | |
b89e3563 | 307 | * @list_node: node for dma_buf accounting and debugging. |
d15bd7ee | 308 | * @priv: exporter specific private data for this buffer object. |
3aac4502 | 309 | * @resv: reservation object linked to this dma-buf |
e2082e3a RC |
310 | * @poll: for userspace poll support |
311 | * @cb_excl: for userspace poll support | |
312 | * @cb_shared: for userspace poll support | |
bdb8d06d HV |
313 | * @sysfs_entry: for exposing information about this buffer in sysfs. |
314 | * The attachment_uid member of @sysfs_entry is protected by dma_resv lock | |
315 | * and is incremented on each attach. | |
2904a8c1 DV |
316 | * |
317 | * This represents a shared buffer, created by calling dma_buf_export(). The | |
318 | * userspace representation is a normal file descriptor, which can be created by | |
319 | * calling dma_buf_fd(). | |
320 | * | |
321 | * Shared dma buffers are reference counted using dma_buf_put() and | |
322 | * get_dma_buf(). | |
323 | * | |
f641d3b5 | 324 | * Device DMA access is handled by the separate &struct dma_buf_attachment. |
d15bd7ee SS |
325 | */ |
326 | struct dma_buf { | |
327 | size_t size; | |
328 | struct file *file; | |
329 | struct list_head attachments; | |
330 | const struct dma_buf_ops *ops; | |
d15bd7ee | 331 | struct mutex lock; |
f00b4dad | 332 | unsigned vmapping_counter; |
01fd30da | 333 | struct dma_buf_map vmap_ptr; |
78df9695 | 334 | const char *exp_name; |
bb2bb903 | 335 | const char *name; |
0f50257f | 336 | spinlock_t name_lock; |
9abdffe2 | 337 | struct module *owner; |
b89e3563 | 338 | struct list_head list_node; |
d15bd7ee | 339 | void *priv; |
52791eee | 340 | struct dma_resv *resv; |
9b495a58 ML |
341 | |
342 | /* poll support */ | |
343 | wait_queue_head_t poll; | |
344 | ||
345 | struct dma_buf_poll_cb_t { | |
f54d1867 | 346 | struct dma_fence_cb cb; |
9b495a58 ML |
347 | wait_queue_head_t *poll; |
348 | ||
01e5d556 | 349 | __poll_t active; |
9b495a58 | 350 | } cb_excl, cb_shared; |
bdb8d06d HV |
351 | #ifdef CONFIG_DMABUF_SYSFS_STATS |
352 | /* for sysfs stats */ | |
353 | struct dma_buf_sysfs_entry { | |
354 | struct kobject kobj; | |
355 | struct dma_buf *dmabuf; | |
356 | unsigned int attachment_uid; | |
357 | struct kset *attach_stats_kset; | |
358 | } *sysfs_entry; | |
359 | #endif | |
d15bd7ee SS |
360 | }; |
361 | ||
bb42df46 CK |
362 | /** |
363 | * struct dma_buf_attach_ops - importer operations for an attachment | |
bb42df46 CK |
364 | * |
365 | * Attachment operations implemented by the importer. | |
366 | */ | |
367 | struct dma_buf_attach_ops { | |
09606b54 CK |
368 | /** |
369 | * @allow_peer2peer: | |
370 | * | |
371 | * If this is set to true the importer must be able to handle peer | |
372 | * resources without struct pages. | |
373 | */ | |
374 | bool allow_peer2peer; | |
375 | ||
bb42df46 | 376 | /** |
6f49c251 | 377 | * @move_notify: [optional] notification that the DMA-buf is moving |
bb42df46 CK |
378 | * |
379 | * If this callback is provided the framework can avoid pinning the | |
380 | * backing store while mappings exists. | |
381 | * | |
382 | * This callback is called with the lock of the reservation object | |
383 | * associated with the dma_buf held and the mapping function must be | |
384 | * called with this lock held as well. This makes sure that no mapping | |
385 | * is created concurrently with an ongoing move operation. | |
386 | * | |
387 | * Mappings stay valid and are not directly affected by this callback. | |
388 | * But the DMA-buf can now be in a different physical location, so all | |
389 | * mappings should be destroyed and re-created as soon as possible. | |
390 | * | |
391 | * New mappings can be created after this callback returns, and will | |
392 | * point to the new location of the DMA-buf. | |
393 | */ | |
394 | void (*move_notify)(struct dma_buf_attachment *attach); | |
395 | }; | |
396 | ||
d15bd7ee SS |
397 | /** |
398 | * struct dma_buf_attachment - holds device-buffer attachment data | |
399 | * @dmabuf: buffer for this attachment. | |
400 | * @dev: device attached to the buffer. | |
15fd552d | 401 | * @node: list of dma_buf_attachment, protected by dma_resv lock of the dmabuf. |
f13e143e CK |
402 | * @sgt: cached mapping. |
403 | * @dir: direction of cached mapping. | |
09606b54 | 404 | * @peer2peer: true if the importer can handle peer resources without pages. |
d15bd7ee | 405 | * @priv: exporter specific attachment data. |
bb42df46 CK |
406 | * @importer_ops: importer operations for this attachment, if provided |
407 | * dma_buf_map/unmap_attachment() must be called with the dma_resv lock held. | |
408 | * @importer_priv: importer specific attachment data. | |
bdb8d06d | 409 | * @sysfs_entry: For exposing information about this attachment in sysfs. |
d15bd7ee SS |
410 | * |
411 | * This structure holds the attachment information between the dma_buf buffer | |
412 | * and its user device(s). The list contains one attachment struct per device | |
413 | * attached to the buffer. | |
2904a8c1 DV |
414 | * |
415 | * An attachment is created by calling dma_buf_attach(), and released again by | |
416 | * calling dma_buf_detach(). The DMA mapping itself needed to initiate a | |
417 | * transfer is created by dma_buf_map_attachment() and freed again by calling | |
418 | * dma_buf_unmap_attachment(). | |
d15bd7ee SS |
419 | */ |
420 | struct dma_buf_attachment { | |
421 | struct dma_buf *dmabuf; | |
422 | struct device *dev; | |
423 | struct list_head node; | |
f13e143e CK |
424 | struct sg_table *sgt; |
425 | enum dma_data_direction dir; | |
09606b54 | 426 | bool peer2peer; |
bb42df46 CK |
427 | const struct dma_buf_attach_ops *importer_ops; |
428 | void *importer_priv; | |
d15bd7ee | 429 | void *priv; |
bdb8d06d HV |
430 | #ifdef CONFIG_DMABUF_SYSFS_STATS |
431 | /* for sysfs stats */ | |
432 | struct dma_buf_attach_sysfs_entry { | |
433 | struct kobject kobj; | |
434 | unsigned int map_counter; | |
435 | } *sysfs_entry; | |
436 | #endif | |
d15bd7ee SS |
437 | }; |
438 | ||
d8fbe341 SS |
439 | /** |
440 | * struct dma_buf_export_info - holds information needed to export a dma_buf | |
9abdffe2 SS |
441 | * @exp_name: name of the exporter - useful for debugging. |
442 | * @owner: pointer to exporter module - used for refcounting kernel module | |
d8fbe341 | 443 | * @ops: Attach allocator-defined dma buf ops to the new buffer |
476b485b | 444 | * @size: Size of the buffer - invariant over the lifetime of the buffer |
d8fbe341 SS |
445 | * @flags: mode flags for the file |
446 | * @resv: reservation-object, NULL to allocate default one | |
447 | * @priv: Attach private data of allocator to this buffer | |
448 | * | |
449 | * This structure holds the information required to export the buffer. Used | |
450 | * with dma_buf_export() only. | |
451 | */ | |
452 | struct dma_buf_export_info { | |
453 | const char *exp_name; | |
9abdffe2 | 454 | struct module *owner; |
d8fbe341 SS |
455 | const struct dma_buf_ops *ops; |
456 | size_t size; | |
457 | int flags; | |
52791eee | 458 | struct dma_resv *resv; |
d8fbe341 SS |
459 | void *priv; |
460 | }; | |
461 | ||
462 | /** | |
2904a8c1 | 463 | * DEFINE_DMA_BUF_EXPORT_INFO - helper macro for exporters |
e2082e3a | 464 | * @name: export-info name |
2904a8c1 | 465 | * |
f641d3b5 | 466 | * DEFINE_DMA_BUF_EXPORT_INFO macro defines the &struct dma_buf_export_info, |
2904a8c1 | 467 | * zeroes it out and pre-populates exp_name in it. |
d8fbe341 | 468 | */ |
e2082e3a RC |
469 | #define DEFINE_DMA_BUF_EXPORT_INFO(name) \ |
470 | struct dma_buf_export_info name = { .exp_name = KBUILD_MODNAME, \ | |
9abdffe2 | 471 | .owner = THIS_MODULE } |
d8fbe341 | 472 | |
f9a24d1a RC |
473 | /** |
474 | * get_dma_buf - convenience wrapper for get_file. | |
475 | * @dmabuf: [in] pointer to dma_buf | |
476 | * | |
477 | * Increments the reference count on the dma-buf, needed in case of drivers | |
478 | * that either need to create additional references to the dmabuf on the | |
479 | * kernel side. For example, an exporter that needs to keep a dmabuf ptr | |
480 | * so that subsequent exports don't create a new dmabuf. | |
481 | */ | |
482 | static inline void get_dma_buf(struct dma_buf *dmabuf) | |
483 | { | |
484 | get_file(dmabuf->file); | |
485 | } | |
486 | ||
15fd552d CK |
487 | /** |
488 | * dma_buf_is_dynamic - check if a DMA-buf uses dynamic mappings. | |
489 | * @dmabuf: the DMA-buf to check | |
490 | * | |
491 | * Returns true if a DMA-buf exporter wants to be called with the dma_resv | |
492 | * locked for the map/unmap callbacks, false if it doesn't wants to be called | |
493 | * with the lock held. | |
494 | */ | |
495 | static inline bool dma_buf_is_dynamic(struct dma_buf *dmabuf) | |
496 | { | |
bd2275ee | 497 | return !!dmabuf->ops->pin; |
15fd552d CK |
498 | } |
499 | ||
500 | /** | |
501 | * dma_buf_attachment_is_dynamic - check if a DMA-buf attachment uses dynamic | |
502 | * mappinsg | |
503 | * @attach: the DMA-buf attachment to check | |
504 | * | |
505 | * Returns true if a DMA-buf importer wants to call the map/unmap functions with | |
506 | * the dma_resv lock held. | |
507 | */ | |
508 | static inline bool | |
509 | dma_buf_attachment_is_dynamic(struct dma_buf_attachment *attach) | |
510 | { | |
bb42df46 | 511 | return !!attach->importer_ops; |
15fd552d CK |
512 | } |
513 | ||
d15bd7ee | 514 | struct dma_buf_attachment *dma_buf_attach(struct dma_buf *dmabuf, |
15fd552d CK |
515 | struct device *dev); |
516 | struct dma_buf_attachment * | |
517 | dma_buf_dynamic_attach(struct dma_buf *dmabuf, struct device *dev, | |
bb42df46 CK |
518 | const struct dma_buf_attach_ops *importer_ops, |
519 | void *importer_priv); | |
d15bd7ee | 520 | void dma_buf_detach(struct dma_buf *dmabuf, |
15fd552d | 521 | struct dma_buf_attachment *attach); |
bb42df46 CK |
522 | int dma_buf_pin(struct dma_buf_attachment *attach); |
523 | void dma_buf_unpin(struct dma_buf_attachment *attach); | |
78df9695 | 524 | |
d8fbe341 | 525 | struct dma_buf *dma_buf_export(const struct dma_buf_export_info *exp_info); |
78df9695 | 526 | |
55c1c4ca | 527 | int dma_buf_fd(struct dma_buf *dmabuf, int flags); |
d15bd7ee SS |
528 | struct dma_buf *dma_buf_get(int fd); |
529 | void dma_buf_put(struct dma_buf *dmabuf); | |
530 | ||
531 | struct sg_table *dma_buf_map_attachment(struct dma_buf_attachment *, | |
532 | enum dma_data_direction); | |
33ea2dcb SS |
533 | void dma_buf_unmap_attachment(struct dma_buf_attachment *, struct sg_table *, |
534 | enum dma_data_direction); | |
15fd552d | 535 | void dma_buf_move_notify(struct dma_buf *dma_buf); |
831e9da7 | 536 | int dma_buf_begin_cpu_access(struct dma_buf *dma_buf, |
fc13020e | 537 | enum dma_data_direction dir); |
18b862dc CW |
538 | int dma_buf_end_cpu_access(struct dma_buf *dma_buf, |
539 | enum dma_data_direction dir); | |
4c78513e DV |
540 | |
541 | int dma_buf_mmap(struct dma_buf *, struct vm_area_struct *, | |
542 | unsigned long); | |
6619ccf1 | 543 | int dma_buf_vmap(struct dma_buf *dmabuf, struct dma_buf_map *map); |
20e76f1a | 544 | void dma_buf_vunmap(struct dma_buf *dmabuf, struct dma_buf_map *map); |
d15bd7ee | 545 | #endif /* __DMA_BUF_H__ */ |