Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d09d815c authored by Glauber Costa's avatar Glauber Costa Committed by Ingo Molnar
Browse files

x86: isolate coherent mapping functions 



i386 implements the declare coherent memory API, and x86_64 does not
it is reflected in pieces of dma_alloc_coherent and dma_free_coherent.
Those pieces are isolated in separate functions, that are declared
as empty macros in x86_64. This way we can make the code the same.

Signed-off-by: default avatarGlauber Costa <gcosta@redhat.com>
Signed-off-by: default avatarIngo Molnar <mingo@elte.hu>
Signed-off-by: default avatarThomas Gleixner <tglx@linutronix.de>
parent 8e8edc64

arch/x86/kernel/pci-dma_32.c

+35 −16
Original line number Original line Diff line number Diff line
@@ -18,28 +18,51 @@ 
dma_addr_t bad_dma_address __read_mostly = 0x0;

dma_addr_t bad_dma_address __read_mostly = 0x0;

EXPORT_SYMBOL(bad_dma_address);

EXPORT_SYMBOL(bad_dma_address);





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

static int dma_alloc_from_coherent_mem(struct device *dev, ssize_t size,

			   dma_addr_t *dma_handle, gfp_t gfp)

				       dma_addr_t *dma_handle, void **ret)

{

{

	void *ret;

	struct dma_coherent_mem *mem = dev ? dev->dma_mem : NULL;

	struct dma_coherent_mem *mem = dev ? dev->dma_mem : NULL;

	int order = get_order(size);

	int order = get_order(size);

	/* ignore region specifiers */

	gfp &= ~(__GFP_DMA | __GFP_HIGHMEM);





	if (mem) {

	if (mem) {

		int page = bitmap_find_free_region(mem->bitmap, mem->size,

		int page = bitmap_find_free_region(mem->bitmap, mem->size,

						     order);

						     order);

		if (page >= 0) {

		if (page >= 0) {

			*dma_handle = mem->device_base + (page << PAGE_SHIFT);

			*dma_handle = mem->device_base + (page << PAGE_SHIFT);

			ret = mem->virt_base + (page << PAGE_SHIFT);

			*ret = mem->virt_base + (page << PAGE_SHIFT);

			memset(ret, 0, size);

			memset(*ret, 0, size);

			return ret;

		}

		}

		if (mem->flags & DMA_MEMORY_EXCLUSIVE)

		if (mem->flags & DMA_MEMORY_EXCLUSIVE)

			return NULL;

			*ret = NULL;

	}

	return (mem != NULL);

}

}





static int dma_release_coherent(struct device *dev, int order, void *vaddr)

{

	struct dma_coherent_mem *mem = dev ? dev->dma_mem : NULL;



	if (mem && vaddr >= mem->virt_base && vaddr <

		   (mem->virt_base + (mem->size << PAGE_SHIFT))) {

		int page = (vaddr - mem->virt_base) >> PAGE_SHIFT;



		bitmap_release_region(mem->bitmap, page, order);

		return 1;

	}

	return 0;

}



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

			   dma_addr_t *dma_handle, gfp_t gfp)

{

	void *ret = NULL;

	int order = get_order(size);

	/* ignore region specifiers */

	gfp &= ~(__GFP_DMA | __GFP_HIGHMEM);



	if (dma_alloc_from_coherent_mem(dev, size, dma_handle, &ret))

		return ret;



	if (dev == NULL || (dev->coherent_dma_mask < 0xffffffff))

	if (dev == NULL || (dev->coherent_dma_mask < 0xffffffff))

		gfp |= GFP_DMA;

		gfp |= GFP_DMA;
@@ -56,15 +79,11 @@ EXPORT_SYMBOL(dma_alloc_coherent); 
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);





	WARN_ON(irqs_disabled());	/* for portability */

	WARN_ON(irqs_disabled());	/* for portability */

	if (mem && vaddr >= mem->virt_base && vaddr < (mem->virt_base + (mem->size << PAGE_SHIFT))) {

	if (dma_release_coherent(dev, order, vaddr))

		int page = (vaddr - mem->virt_base) >> PAGE_SHIFT;

		return;



		bitmap_release_region(mem->bitmap, page, order);

	} else

	free_pages((unsigned long)vaddr, order);

	free_pages((unsigned long)vaddr, order);

}

}

EXPORT_SYMBOL(dma_free_coherent);
 
EXPORT_SYMBOL(dma_free_coherent);

arch/x86/kernel/pci-dma_64.c

+10 −1
Original line number Original line Diff line number Diff line
@@ -39,6 +39,8 @@ dma_alloc_pages(struct device *dev, gfp_t gfp, unsigned order) 
	return page ? page_address(page) : NULL;

	return page ? page_address(page) : NULL;

}

}





#define dma_alloc_from_coherent_mem(dev, size, handle, ret) (0)

#define dma_release_coherent(dev, order, vaddr) (0)

/*

/*

 * Allocate memory for a coherent mapping.

 * Allocate memory for a coherent mapping.

 */

 */
@@ -50,6 +52,10 @@ dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle, 
	unsigned long dma_mask = 0;

	unsigned long dma_mask = 0;

	u64 bus;

	u64 bus;







	if (dma_alloc_from_coherent_mem(dev, size, dma_handle, &memory))

		return memory;



	if (!dev)

	if (!dev)

		dev = &fallback_dev;

		dev = &fallback_dev;

	dma_mask = dev->coherent_dma_mask;

	dma_mask = dev->coherent_dma_mask;
@@ -141,9 +147,12 @@ EXPORT_SYMBOL(dma_alloc_coherent); 
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 bus)

			 void *vaddr, dma_addr_t bus)

{

{

	int order = get_order(size);

	WARN_ON(irqs_disabled());	/* for portability */

	WARN_ON(irqs_disabled());	/* for portability */

	if (dma_release_coherent(dev, order, vaddr))

		return;

	if (dma_ops->unmap_single)

	if (dma_ops->unmap_single)

		dma_ops->unmap_single(dev, bus, size, 0);

		dma_ops->unmap_single(dev, bus, size, 0);

	free_pages((unsigned long)vaddr, get_order(size));

	free_pages((unsigned long)vaddr, order);

}

}

EXPORT_SYMBOL(dma_free_coherent);
 
EXPORT_SYMBOL(dma_free_coherent);