dma-buf: Drop dma_buf_k(un)map

 *   with calls to dma_buf_begin_cpu_access() and dma_buf_end_cpu_access()

 *   access.

 *

 *   To support dma_buf objects residing in highmem cpu access is page-based

 *   using an api similar to kmap. Accessing a dma_buf is done in aligned chunks

 *   of PAGE_SIZE size. Before accessing a chunk it needs to be mapped, which

 *   returns a pointer in kernel virtual address space. Afterwards the chunk

 *   needs to be unmapped again. There is no limit on how often a given chunk

 *   can be mapped and unmapped, i.e. the importer does not need to call

 *   begin_cpu_access again before mapping the same chunk again.

 *

 *   Interfaces::

 *      void \*dma_buf_kmap(struct dma_buf \*, unsigned long);

 *      void dma_buf_kunmap(struct dma_buf \*, unsigned long, void \*);

 *

 *   Implementing the functions is optional for exporters and for importers all

 *   the restrictions of using kmap apply.

 *

 *   dma_buf kmap calls outside of the range specified in begin_cpu_access are

 *   undefined. If the range is not PAGE_SIZE aligned, kmap needs to succeed on

 *   the partial chunks at the beginning and end but may return stale or bogus

 *   data outside of the range (in these partial chunks).

 *

 *   For some cases the overhead of kmap can be too high, a vmap interface

 *   is introduced. This interface should be used very carefully, as vmalloc

 *   space is a limited resources on many architectures.

 *   Since for most kernel internal dma-buf accesses need the entire buffer, a

 *   vmap interface is introduced. Note that on very old 32-bit architectures

 *   vmalloc space might be limited and result in vmap calls failing.

 *

 *   Interfaces::

 *      void \*dma_buf_vmap(struct dma_buf \*dmabuf)

}

EXPORT_SYMBOL_GPL(dma_buf_end_cpu_access);

/**

 * dma_buf_kmap - Map a page of the buffer object into kernel address space. The

 * same restrictions as for kmap and friends apply.

 * @dmabuf:	[in]	buffer to map page from.

 * @page_num:	[in]	page in PAGE_SIZE units to map.

 *

 * This call must always succeed, any necessary preparations that might fail

 * need to be done in begin_cpu_access.

 */

void *dma_buf_kmap(struct dma_buf *dmabuf, unsigned long page_num)

{

	WARN_ON(!dmabuf);

	if (!dmabuf->ops->map)

		return NULL;

	return dmabuf->ops->map(dmabuf, page_num);

}

EXPORT_SYMBOL_GPL(dma_buf_kmap);

/**

 * dma_buf_kunmap - Unmap a page obtained by dma_buf_kmap.

 * @dmabuf:	[in]	buffer to unmap page from.

 * @page_num:	[in]	page in PAGE_SIZE units to unmap.

 * @vaddr:	[in]	kernel space pointer obtained from dma_buf_kmap.

 *

 * This call must always succeed.

 */

void dma_buf_kunmap(struct dma_buf *dmabuf, unsigned long page_num,

		    void *vaddr)

{

	WARN_ON(!dmabuf);

	if (dmabuf->ops->unmap)

		dmabuf->ops->unmap(dmabuf, page_num, vaddr);

}

EXPORT_SYMBOL_GPL(dma_buf_kunmap);

/**

 * dma_buf_mmap - Setup up a userspace mmap with the given vma

			     enum dma_data_direction dir);

int dma_buf_end_cpu_access(struct dma_buf *dma_buf,

			   enum dma_data_direction dir);

void *dma_buf_kmap(struct dma_buf *, unsigned long);

void dma_buf_kunmap(struct dma_buf *, unsigned long, void *);

int dma_buf_mmap(struct dma_buf *, struct vm_area_struct *,

		 unsigned long);