Merge branch 'core/generic-dma-coherent' of... (756f7bc6) · Commits · e / devices / android_kernel_xiaomi_nabu

arch/arm/Kconfig

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -17,6 +17,7 @@ config ARM
	select HAVE_KRETPROBES if (HAVE_KPROBES)		select HAVE_KRETPROBES if (HAVE_KPROBES)
	select HAVE_FTRACE if (!XIP_KERNEL)		select HAVE_FTRACE if (!XIP_KERNEL)
	select HAVE_DYNAMIC_FTRACE if (HAVE_FTRACE)		select HAVE_DYNAMIC_FTRACE if (HAVE_FTRACE)
			select HAVE_GENERIC_DMA_COHERENT
	help		help
	The ARM series is a line of low-power-consumption RISC chip designs		The ARM series is a line of low-power-consumption RISC chip designs
	licensed by ARM Ltd and targeted at embedded applications and		licensed by ARM Ltd and targeted at embedded applications and

arch/arm/mm/consistent.c

+8 −0

Original line number	Original line	Diff line number	Diff line
	@@ -274,6 +274,11 @@ __dma_alloc(struct device dev, size_t size, dma_addr_t handle, gfp_t gfp,
	void *		void *
	dma_alloc_coherent(struct device dev, size_t size, dma_addr_t handle, gfp_t gfp)		dma_alloc_coherent(struct device dev, size_t size, dma_addr_t handle, gfp_t gfp)
	{		{
			void *memory;

			if (dma_alloc_from_coherent(dev, size, handle, &memory))
			return memory;

	if (arch_is_coherent()) {		if (arch_is_coherent()) {
	void *virt;		void *virt;

	@@ -362,6 +367,9 @@ void dma_free_coherent(struct device dev, size_t size, void cpu_addr, dma_addr

	WARN_ON(irqs_disabled());		WARN_ON(irqs_disabled());

			if (dma_release_from_coherent(dev, get_order(size), cpu_addr))
			return;

	if (arch_is_coherent()) {		if (arch_is_coherent()) {
	kfree(cpu_addr);		kfree(cpu_addr);
	return;		return;

arch/cris/arch-v32/drivers/Kconfig

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -641,6 +641,7 @@ config PCI
	bool		bool
	depends on ETRAX_CARDBUS		depends on ETRAX_CARDBUS
	default y		default y
			select HAVE_GENERIC_DMA_COHERENT

	config ETRAX_IOP_FW_LOAD		config ETRAX_IOP_FW_LOAD
	tristate "IO-processor hotplug firmware loading support"		tristate "IO-processor hotplug firmware loading support"

arch/cris/arch-v32/drivers/pci/dma.c

+3 −103

Original line number	Original line	Diff line number	Diff line
	@@ -15,35 +15,16 @@
	#include <linux/pci.h>		#include <linux/pci.h>
	#include <asm/io.h>		#include <asm/io.h>

	struct dma_coherent_mem {
	void *virt_base;
	u32 device_base;
	int size;
	int flags;
	unsigned long *bitmap;
	};

	void dma_alloc_coherent(struct device dev, size_t size,		void dma_alloc_coherent(struct device dev, size_t size,
	dma_addr_t *dma_handle, gfp_t gfp)		dma_addr_t *dma_handle, gfp_t gfp)
	{		{
	void *ret;		void *ret;
	struct dma_coherent_mem *mem = dev ? dev->dma_mem : NULL;
	int order = get_order(size);		int order = get_order(size);
	/* ignore region specifiers */		/* ignore region specifiers */
	gfp &= ~(__GFP_DMA \| __GFP_HIGHMEM);		gfp &= ~(__GFP_DMA \| __GFP_HIGHMEM);

	if (mem) {		if (dma_alloc_from_coherent(dev, size, dma_handle, &ret))
	int page = bitmap_find_free_region(mem->bitmap, mem->size,
	order);
	if (page >= 0) {
	*dma_handle = mem->device_base + (page << PAGE_SHIFT);
	ret = mem->virt_base + (page << PAGE_SHIFT);
	memset(ret, 0, size);
	return ret;		return ret;
	}
	if (mem->flags & DMA_MEMORY_EXCLUSIVE)
	return NULL;
	}

	if (dev == NULL \|\| (dev->coherent_dma_mask < 0xffffffff))		if (dev == NULL \|\| (dev->coherent_dma_mask < 0xffffffff))
	gfp \|= GFP_DMA;		gfp \|= GFP_DMA;
	@@ -60,90 +41,9 @@ void dma_alloc_coherent(struct device dev, size_t size,
	void dma_free_coherent(struct device *dev, size_t size,		void dma_free_coherent(struct device *dev, size_t size,
	void *vaddr, dma_addr_t dma_handle)		void *vaddr, dma_addr_t dma_handle)
	{		{
	struct dma_coherent_mem *mem = dev ? dev->dma_mem : NULL;
	int order = get_order(size);		int order = get_order(size);

	if (mem && vaddr >= mem->virt_base && vaddr < (mem->virt_base + (mem->size << PAGE_SHIFT))) {		if (!dma_release_from_coherent(dev, order, vaddr))
	int page = (vaddr - mem->virt_base) >> PAGE_SHIFT;

	bitmap_release_region(mem->bitmap, page, order);
	} else
	free_pages((unsigned long)vaddr, order);		free_pages((unsigned long)vaddr, order);
	}		}

	int dma_declare_coherent_memory(struct device *dev, dma_addr_t bus_addr,
	dma_addr_t device_addr, size_t size, int flags)
	{
	void __iomem *mem_base;
	int pages = size >> PAGE_SHIFT;
	int bitmap_size = BITS_TO_LONGS(pages) * sizeof(long);

	if ((flags & (DMA_MEMORY_MAP \| DMA_MEMORY_IO)) == 0)
	goto out;
	if (!size)
	goto out;
	if (dev->dma_mem)
	goto out;

	/* FIXME: this routine just ignores DMA_MEMORY_INCLUDES_CHILDREN */

	mem_base = ioremap(bus_addr, size);
	if (!mem_base)
	goto out;

	dev->dma_mem = kzalloc(sizeof(struct dma_coherent_mem), GFP_KERNEL);
	if (!dev->dma_mem)
	goto iounmap_out;
	dev->dma_mem->bitmap = kzalloc(bitmap_size, GFP_KERNEL);
	if (!dev->dma_mem->bitmap)
	goto free1_out;

	dev->dma_mem->virt_base = mem_base;
	dev->dma_mem->device_base = device_addr;
	dev->dma_mem->size = pages;
	dev->dma_mem->flags = flags;

	if (flags & DMA_MEMORY_MAP)
	return DMA_MEMORY_MAP;

	return DMA_MEMORY_IO;

	free1_out:
	kfree(dev->dma_mem);
	iounmap_out:
	iounmap(mem_base);
	out:
	return 0;
	}
	EXPORT_SYMBOL(dma_declare_coherent_memory);

	void dma_release_declared_memory(struct device *dev)
	{
	struct dma_coherent_mem *mem = dev->dma_mem;

	if(!mem)
	return;
	dev->dma_mem = NULL;
	iounmap(mem->virt_base);
	kfree(mem->bitmap);
	kfree(mem);
	}
	EXPORT_SYMBOL(dma_release_declared_memory);

	void dma_mark_declared_memory_occupied(struct device dev,
	dma_addr_t device_addr, size_t size)
	{
	struct dma_coherent_mem *mem = dev->dma_mem;
	int pages = (size + (device_addr & ~PAGE_MASK) + PAGE_SIZE - 1) >> PAGE_SHIFT;
	int pos, err;

	if (!mem)
	return ERR_PTR(-EINVAL);

	pos = (device_addr - mem->device_base) >> PAGE_SHIFT;
	err = bitmap_allocate_region(mem->bitmap, pos, get_order(pages));
	if (err != 0)
	return ERR_PTR(err);
	return mem->virt_base + (pos << PAGE_SHIFT);
	}
	EXPORT_SYMBOL(dma_mark_declared_memory_occupied);

arch/sh/Kconfig

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -11,6 +11,7 @@ config SUPERH
	select HAVE_CLK		select HAVE_CLK
	select HAVE_IDE		select HAVE_IDE
	select HAVE_OPROFILE		select HAVE_OPROFILE
			select HAVE_GENERIC_DMA_COHERENT
	help		help
	The SuperH is a RISC processor targeted for use in embedded systems		The SuperH is a RISC processor targeted for use in embedded systems
	and consumer electronics; it was also used in the Sega Dreamcast		and consumer electronics; it was also used in the Sega Dreamcast