SYNOPSIS

struct dma_buf_ops {
int (* attach) (struct dma_buf *, struct device *,struct dma_buf_attachment *);
void (* detach) (struct dma_buf *, struct dma_buf_attachment *);
struct sg_table * (* map_dma_buf) (struct dma_buf_attachment *,enum dma_data_direction);
void (* unmap_dma_buf) (struct dma_buf_attachment *,struct sg_table *,enum dma_data_direction);
void (* release) (struct dma_buf *);
int (* begin_cpu_access) (struct dma_buf *, enum dma_data_direction);
int (* end_cpu_access) (struct dma_buf *, enum dma_data_direction);
void *(* kmap_atomic) (struct dma_buf *, unsigned long);
void (* kunmap_atomic) (struct dma_buf *, unsigned long, void *);
void *(* kmap) (struct dma_buf *, unsigned long);
void (* kunmap) (struct dma_buf *, unsigned long, void *);
int (* mmap) (struct dma_buf *, struct vm_area_struct *vma);
void *(* vmap) (struct dma_buf *);
void (* vunmap) (struct dma_buf *, void *vaddr);
};

MEMBERS

attach

[optional] allows different devices to 'attach' themselves to the given buffer. It might return -EBUSY to signal that backing storage is already allocated and incompatible with the requirements of requesting device.

detach

[optional] detach a given device from this buffer.

map_dma_buf

returns list of scatter pages allocated, increases usecount of the buffer. Requires atleast one attach to be called before. Returned sg list should already be mapped into _device_ address space. This call may sleep. May also return -EINTR. Should return -EINVAL if attach hasn't been called yet.

unmap_dma_buf

decreases usecount of buffer, might deallocate scatter pages.

release

release this buffer; to be called after the last dma_buf_put.

begin_cpu_access

[optional] called before cpu access to invalidate cpu caches and allocate backing storage (if not yet done) respectively pin the object into memory.

end_cpu_access

[optional] called after cpu access to flush caches.

kmap_atomic

maps a page from the buffer into kernel address space, users may not block until the subsequent unmap call. This callback must not sleep.

kunmap_atomic

[optional] unmaps a atomically mapped page from the buffer. This Callback must not sleep.

kmap

maps a page from the buffer into kernel address space.

kunmap

[optional] unmaps a page from the buffer.

mmap

used to expose the backing storage to userspace. Note that the mapping needs to be coherent - if the exporter doesn't directly support this, it needs to fake coherency by shooting down any ptes when transitioning away from the cpu domain.

vmap

[optional] creates a virtual mapping for the buffer into kernel address space. Same restrictions as for vmap and friends apply.

vunmap

[optional] unmaps a vmap from the buffer

COPYRIGHT