Merge tag 'dma-mapping-5.10-1' of git://git.infradead.org/users/hch/dma-mapping

Part II - Non-coherent DMA allocations

--------------------------------------

These APIs allow to allocate pages in the kernel direct mapping that are

guaranteed to be DMA addressable.  This means that unlike dma_alloc_coherent,

virt_to_page can be called on the resulting address, and the resulting

struct page can be used for everything a struct page is suitable for.

These APIs allow to allocate pages that are guaranteed to be DMA addressable

by the passed in device, but which need explicit management of memory ownership

for the kernel vs the device.

If you don't understand how cache line coherency works between a processor and

an I/O device, you should not be using this part of the API.

This routine allocates a region of <size> bytes of consistent memory.  It

returns a pointer to the allocated region (in the processor's virtual address

space) or NULL if the allocation failed.  The returned memory may or may not

be in the kernels direct mapping.  Drivers must not call virt_to_page on

be in the kernel direct mapping.  Drivers must not call virt_to_page on

the returned memory region.

It also returns a <dma_handle> which may be cast to an unsigned integer the

Free a region of memory previously allocated using dma_alloc_noncoherent().

dev, size and dma_handle and dir must all be the same as those passed into

dma_alloc_noncoherent().  cpu_addr must be the virtual address returned by

the dma_alloc_noncoherent().

dma_alloc_noncoherent().

::

	struct page *

	dma_alloc_pages(struct device *dev, size_t size, dma_addr_t *dma_handle,

			enum dma_data_direction dir, gfp_t gfp)

This routine allocates a region of <size> bytes of non-coherent memory.  It

returns a pointer to first struct page for the region, or NULL if the

allocation failed. The resulting struct page can be used for everything a

struct page is suitable for.

It also returns a <dma_handle> which may be cast to an unsigned integer the

same width as the bus and given to the device as the DMA address base of

the region.

The dir parameter specified if data is read and/or written by the device,

see dma_map_single() for details.

The gfp parameter allows the caller to specify the ``GFP_`` flags (see

kmalloc()) for the allocation, but rejects flags used to specify a memory

zone such as GFP_DMA or GFP_HIGHMEM.

Before giving the memory to the device, dma_sync_single_for_device() needs

to be called, and before reading memory written by the device,

dma_sync_single_for_cpu(), just like for streaming DMA mappings that are

reused.

::

	void

	dma_free_pages(struct device *dev, size_t size, struct page *page,

			dma_addr_t dma_handle, enum dma_data_direction dir)

Free a region of memory previously allocated using dma_alloc_pages().

dev, size and dma_handle and dir must all be the same as those passed into

dma_alloc_noncoherent().  page must be the pointer returned by

dma_alloc_pages().

::

#include <linux/platform_device.h>

#include <linux/slab.h>

#include <linux/spinlock.h>

#include <linux/dma-mapping.h>

#include <linux/dma-map-ops.h>

#include <linux/clk.h>

#include <linux/io.h>

}

#endif /* CONFIG_DMA_DECLARE_COHERENT */

int dma_common_get_sgtable(struct device *dev, struct sg_table *sgt,

		void *cpu_addr, dma_addr_t dma_addr, size_t size,

		unsigned long attrs);

int dma_common_mmap(struct device *dev, struct vm_area_struct *vma,

		void *cpu_addr, dma_addr_t dma_addr, size_t size,

		unsigned long attrs);

struct page *dma_common_alloc_pages(struct device *dev, size_t size,

		dma_addr_t *dma_handle, enum dma_data_direction dir, gfp_t gfp);

void dma_common_free_pages(struct device *dev, size_t size, struct page *vaddr,

		dma_addr_t dma_handle, enum dma_data_direction dir);

struct page **dma_common_find_pages(void *cpu_addr);

void *dma_common_contiguous_remap(struct page *page, size_t size, pgprot_t prot,

		const void *caller);

void *dma_common_pages_remap(struct page **pages, size_t size, pgprot_t prot,

		const void *caller);

void dma_common_free_remap(void *cpu_addr, size_t size);

struct page *dma_alloc_from_pool(struct device *dev, size_t size,

		void **cpu_addr, gfp_t flags,

		bool (*phys_addr_ok)(struct device *, phys_addr_t, size_t));

bool dma_free_from_pool(struct device *dev, void *start, size_t size);

#ifdef CONFIG_ARCH_HAS_DMA_COHERENCE_H

#include <asm/dma-coherence.h>

#elif defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_DEVICE) || \

#define dma_get_sgtable(d, t, v, h, s) dma_get_sgtable_attrs(d, t, v, h, s, 0)

#define dma_mmap_coherent(d, v, c, h, s) dma_mmap_attrs(d, v, c, h, s, 0)

extern int dma_common_mmap(struct device *dev, struct vm_area_struct *vma,

		void *cpu_addr, dma_addr_t dma_addr, size_t size,

		unsigned long attrs);

struct page *dma_common_alloc_pages(struct device *dev, size_t size,

		dma_addr_t *dma_handle, enum dma_data_direction dir, gfp_t gfp);

void dma_common_free_pages(struct device *dev, size_t size, struct page *vaddr,

		dma_addr_t dma_handle, enum dma_data_direction dir);

struct page **dma_common_find_pages(void *cpu_addr);

void *dma_common_contiguous_remap(struct page *page, size_t size,

			pgprot_t prot, const void *caller);

void *dma_common_pages_remap(struct page **pages, size_t size,

			pgprot_t prot, const void *caller);

void dma_common_free_remap(void *cpu_addr, size_t size);

struct page *dma_alloc_from_pool(struct device *dev, size_t size,

		void **cpu_addr, gfp_t flags,

		bool (*phys_addr_ok)(struct device *, phys_addr_t, size_t));

bool dma_free_from_pool(struct device *dev, void *start, size_t size);

int

dma_common_get_sgtable(struct device *dev, struct sg_table *sgt, void *cpu_addr,

		dma_addr_t dma_addr, size_t size, unsigned long attrs);

static inline void *dma_alloc_coherent(struct device *dev, size_t size,

		dma_addr_t *dma_handle, gfp_t gfp)

{

/*

 * Copyright (c) 2014 The Linux Foundation

 */

#include <linux/dma-mapping.h>

#include <linux/dma-map-ops.h>

#include <linux/slab.h>

#include <linux/vmalloc.h>