Commit a7405aa9 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'dma-mapping-6.19-2025-12-05' of... 

Merge tag 'dma-mapping-6.19-2025-12-05' of git://git.kernel.org/pub/scm/linux/kernel/git/mszyprowski/linux

Pull dma-mapping updates from Marek Szyprowski:

 - More DMA mapping API refactoring to physical addresses as the primary
   interface instead of page+offset parameters.

   This time dma_map_ops callbacks are converted to physical addresses,
   what in turn results also in some simplification of architecture
   specific code (Leon Romanovsky and Jason Gunthorpe)

 - Clarify that dma_map_benchmark is not a kernel self-test, but
   standalone tool (Qinxin Xia)

* tag 'dma-mapping-6.19-2025-12-05' of git://git.kernel.org/pub/scm/linux/kernel/git/mszyprowski/linux:
  dma-mapping: remove unused map_page callback
  xen: swiotlb: Convert mapping routine to rely on physical address
  x86: Use physical address for DMA mapping
  sparc: Use physical address DMA mapping
  powerpc: Convert to physical address DMA mapping
  parisc: Convert DMA map_page to map_phys interface
  MIPS/jazzdma: Provide physical address directly
  alpha: Convert mapping routine to rely on physical address
  dma-mapping: remove unused mapping resource callbacks
  xen: swiotlb: Switch to physical address mapping callbacks
  ARM: dma-mapping: Switch to physical address mapping callbacks
  ARM: dma-mapping: Reduce struct page exposure in arch_sync_dma*()
  dma-mapping: convert dummy ops to physical address mapping
  dma-mapping: prepare dma_map_ops to conversion to physical address
  tools/dma: move dma_map_benchmark from selftests to tools/dma
parents f468cf53 131971f6

arch/alpha/kernel/pci_iommu.c

+21 −27
Original line number Diff line number Diff line
@@ -224,28 +224,26 @@ static int pci_dac_dma_supported(struct pci_dev *dev, u64 mask) 
   until either pci_unmap_single or pci_dma_sync_single is performed.  */



static dma_addr_t

pci_map_single_1(struct pci_dev *pdev, void *cpu_addr, size_t size,

pci_map_single_1(struct pci_dev *pdev, phys_addr_t paddr, size_t size,

		 int dac_allowed)

{

	struct pci_controller *hose = pdev ? pdev->sysdata : pci_isa_hose;

	dma_addr_t max_dma = pdev ? pdev->dma_mask : ISA_DMA_MASK;

	unsigned long offset = offset_in_page(paddr);

	struct pci_iommu_arena *arena;

	long npages, dma_ofs, i;

	unsigned long paddr;

	dma_addr_t ret;

	unsigned int align = 0;

	struct device *dev = pdev ? &pdev->dev : NULL;



	paddr = __pa(cpu_addr);



#if !DEBUG_NODIRECT

	/* First check to see if we can use the direct map window.  */

	if (paddr + size + __direct_map_base - 1 <= max_dma

	    && paddr + size <= __direct_map_size) {

		ret = paddr + __direct_map_base;



		DBGA2("pci_map_single: [%p,%zx] -> direct %llx from %ps\n",

		      cpu_addr, size, ret, __builtin_return_address(0));

		DBGA2("pci_map_single: [%pa,%zx] -> direct %llx from %ps\n",

		      &paddr, size, ret, __builtin_return_address(0));



		return ret;

	}
@@ -255,8 +253,8 @@ pci_map_single_1(struct pci_dev *pdev, void *cpu_addr, size_t size, 
	if (dac_allowed) {

		ret = paddr + alpha_mv.pci_dac_offset;



		DBGA2("pci_map_single: [%p,%zx] -> DAC %llx from %ps\n",

		      cpu_addr, size, ret, __builtin_return_address(0));

		DBGA2("pci_map_single: [%pa,%zx] -> DAC %llx from %ps\n",

		      &paddr, size, ret, __builtin_return_address(0));



		return ret;

	}
@@ -290,10 +288,10 @@ pci_map_single_1(struct pci_dev *pdev, void *cpu_addr, size_t size, 
		arena->ptes[i + dma_ofs] = mk_iommu_pte(paddr);



	ret = arena->dma_base + dma_ofs * PAGE_SIZE;

	ret += (unsigned long)cpu_addr & ~PAGE_MASK;

	ret += offset;



	DBGA2("pci_map_single: [%p,%zx] np %ld -> sg %llx from %ps\n",

	      cpu_addr, size, npages, ret, __builtin_return_address(0));

	DBGA2("pci_map_single: [%pa,%zx] np %ld -> sg %llx from %ps\n",

	      &paddr, size, npages, ret, __builtin_return_address(0));



	return ret;

}
@@ -322,19 +320,18 @@ static struct pci_dev *alpha_gendev_to_pci(struct device *dev) 
	return NULL;

}



static dma_addr_t alpha_pci_map_page(struct device *dev, struct page *page,

				     unsigned long offset, size_t size,

				     enum dma_data_direction dir,

static dma_addr_t alpha_pci_map_phys(struct device *dev, phys_addr_t phys,

				     size_t size, enum dma_data_direction dir,

				     unsigned long attrs)

{

	struct pci_dev *pdev = alpha_gendev_to_pci(dev);

	int dac_allowed;



	BUG_ON(dir == DMA_NONE);

	if (unlikely(attrs & DMA_ATTR_MMIO))

		return DMA_MAPPING_ERROR;



	dac_allowed = pdev ? pci_dac_dma_supported(pdev, pdev->dma_mask) : 0;

	return pci_map_single_1(pdev, (char *)page_address(page) + offset, 

				size, dac_allowed);

	return pci_map_single_1(pdev, phys, size, dac_allowed);

}



/* Unmap a single streaming mode DMA translation.  The DMA_ADDR and
@@ -343,7 +340,7 @@ static dma_addr_t alpha_pci_map_page(struct device *dev, struct page *page, 
   the cpu to the buffer are guaranteed to see whatever the device

   wrote there.  */



static void alpha_pci_unmap_page(struct device *dev, dma_addr_t dma_addr,

static void alpha_pci_unmap_phys(struct device *dev, dma_addr_t dma_addr,

				 size_t size, enum dma_data_direction dir,

				 unsigned long attrs)

{
@@ -353,8 +350,6 @@ static void alpha_pci_unmap_page(struct device *dev, dma_addr_t dma_addr, 
	struct pci_iommu_arena *arena;

	long dma_ofs, npages;



	BUG_ON(dir == DMA_NONE);



	if (dma_addr >= __direct_map_base

	    && dma_addr < __direct_map_base + __direct_map_size) {

		/* Nothing to do.  */
@@ -429,7 +424,7 @@ static void *alpha_pci_alloc_coherent(struct device *dev, size_t size, 
	}

	memset(cpu_addr, 0, size);



	*dma_addrp = pci_map_single_1(pdev, cpu_addr, size, 0);

	*dma_addrp = pci_map_single_1(pdev, virt_to_phys(cpu_addr), size, 0);

	if (*dma_addrp == DMA_MAPPING_ERROR) {

		free_pages((unsigned long)cpu_addr, order);

		if (alpha_mv.mv_pci_tbi || (gfp & GFP_DMA))
@@ -643,8 +638,7 @@ static int alpha_pci_map_sg(struct device *dev, struct scatterlist *sg, 
	/* Fast path single entry scatterlists.  */

	if (nents == 1) {

		sg->dma_length = sg->length;

		sg->dma_address

		  = pci_map_single_1(pdev, SG_ENT_VIRT_ADDRESS(sg),

		sg->dma_address = pci_map_single_1(pdev, sg_phys(sg),

						   sg->length, dac_allowed);

		if (sg->dma_address == DMA_MAPPING_ERROR)

			return -EIO;
@@ -917,8 +911,8 @@ iommu_unbind(struct pci_iommu_arena *arena, long pg_start, long pg_count) 
const struct dma_map_ops alpha_pci_ops = {

	.alloc			= alpha_pci_alloc_coherent,

	.free			= alpha_pci_free_coherent,

	.map_page		= alpha_pci_map_page,

	.unmap_page		= alpha_pci_unmap_page,

	.map_phys		= alpha_pci_map_phys,

	.unmap_phys		= alpha_pci_unmap_phys,

	.map_sg			= alpha_pci_map_sg,

	.unmap_sg		= alpha_pci_unmap_sg,

	.dma_supported		= alpha_pci_supported,

arch/arm/mm/dma-mapping.c

+53 −127
Original line number Diff line number Diff line
@@ -624,16 +624,14 @@ static void __arm_dma_free(struct device *dev, size_t size, void *cpu_addr, 
	kfree(buf);

}



static void dma_cache_maint_page(struct page *page, unsigned long offset,

	size_t size, enum dma_data_direction dir,

static void dma_cache_maint_page(phys_addr_t phys, size_t size,

	enum dma_data_direction dir,

	void (*op)(const void *, size_t, int))

{

	unsigned long pfn;

	unsigned long offset = offset_in_page(phys);

	unsigned long pfn = __phys_to_pfn(phys);

	size_t left = size;



	pfn = page_to_pfn(page) + offset / PAGE_SIZE;

	offset %= PAGE_SIZE;



	/*

	 * A single sg entry may refer to multiple physically contiguous

	 * pages.  But we still need to process highmem pages individually.
@@ -644,17 +642,18 @@ static void dma_cache_maint_page(struct page *page, unsigned long offset, 
		size_t len = left;

		void *vaddr;



		page = pfn_to_page(pfn);



		if (PageHighMem(page)) {

		phys = __pfn_to_phys(pfn);

		if (PhysHighMem(phys)) {

			if (len + offset > PAGE_SIZE)

				len = PAGE_SIZE - offset;



			if (cache_is_vipt_nonaliasing()) {

				vaddr = kmap_atomic(page);

				vaddr = kmap_atomic_pfn(pfn);

				op(vaddr + offset, len, dir);

				kunmap_atomic(vaddr);

			} else {

				struct page *page = phys_to_page(phys);



				vaddr = kmap_high_get(page);

				if (vaddr) {

					op(vaddr + offset, len, dir);
@@ -662,7 +661,8 @@ static void dma_cache_maint_page(struct page *page, unsigned long offset, 
				}

			}

		} else {

			vaddr = page_address(page) + offset;

			phys += offset;

			vaddr = phys_to_virt(phys);

			op(vaddr, len, dir);

		}

		offset = 0;
@@ -676,14 +676,11 @@ static void dma_cache_maint_page(struct page *page, unsigned long offset, 
 * Note: Drivers should NOT use this function directly.

 * Use the driver DMA support - see dma-mapping.h (dma_sync_*)

 */

static void __dma_page_cpu_to_dev(struct page *page, unsigned long off,

	size_t size, enum dma_data_direction dir)

void arch_sync_dma_for_device(phys_addr_t paddr, size_t size,

			      enum dma_data_direction dir)

{

	phys_addr_t paddr;

	dma_cache_maint_page(paddr, size, dir, dmac_map_area);



	dma_cache_maint_page(page, off, size, dir, dmac_map_area);



	paddr = page_to_phys(page) + off;

	if (dir == DMA_FROM_DEVICE) {

		outer_inv_range(paddr, paddr + size);

	} else {
@@ -692,17 +689,15 @@ static void __dma_page_cpu_to_dev(struct page *page, unsigned long off, 
	/* FIXME: non-speculating: flush on bidirectional mappings? */

}



static void __dma_page_dev_to_cpu(struct page *page, unsigned long off,

	size_t size, enum dma_data_direction dir)

void arch_sync_dma_for_cpu(phys_addr_t paddr, size_t size,

			   enum dma_data_direction dir)

{

	phys_addr_t paddr = page_to_phys(page) + off;



	/* FIXME: non-speculating: not required */

	/* in any case, don't bother invalidating if DMA to device */

	if (dir != DMA_TO_DEVICE) {

		outer_inv_range(paddr, paddr + size);



		dma_cache_maint_page(page, off, size, dir, dmac_unmap_area);

		dma_cache_maint_page(paddr, size, dir, dmac_unmap_area);

	}



	/*
@@ -737,6 +732,9 @@ static int __dma_info_to_prot(enum dma_data_direction dir, unsigned long attrs) 
	if (attrs & DMA_ATTR_PRIVILEGED)

		prot |= IOMMU_PRIV;



	if (attrs & DMA_ATTR_MMIO)

		prot |= IOMMU_MMIO;



	switch (dir) {

	case DMA_BIDIRECTIONAL:

		return prot | IOMMU_READ | IOMMU_WRITE;
@@ -1205,7 +1203,7 @@ static int __map_sg_chunk(struct device *dev, struct scatterlist *sg, 
		unsigned int len = PAGE_ALIGN(s->offset + s->length);



		if (!dev->dma_coherent && !(attrs & DMA_ATTR_SKIP_CPU_SYNC))

			__dma_page_cpu_to_dev(sg_page(s), s->offset, s->length, dir);

			arch_sync_dma_for_device(sg_phys(s), s->length, dir);



		prot = __dma_info_to_prot(dir, attrs);
@@ -1307,8 +1305,7 @@ static void arm_iommu_unmap_sg(struct device *dev, 
			__iommu_remove_mapping(dev, sg_dma_address(s),

					       sg_dma_len(s));

		if (!dev->dma_coherent && !(attrs & DMA_ATTR_SKIP_CPU_SYNC))

			__dma_page_dev_to_cpu(sg_page(s), s->offset,

					      s->length, dir);

			arch_sync_dma_for_cpu(sg_phys(s), s->length, dir);

	}

}
@@ -1330,7 +1327,7 @@ static void arm_iommu_sync_sg_for_cpu(struct device *dev, 
		return;



	for_each_sg(sg, s, nents, i)

		__dma_page_dev_to_cpu(sg_page(s), s->offset, s->length, dir);

		arch_sync_dma_for_cpu(sg_phys(s), s->length, dir);



}
@@ -1352,29 +1349,31 @@ static void arm_iommu_sync_sg_for_device(struct device *dev, 
		return;



	for_each_sg(sg, s, nents, i)

		__dma_page_cpu_to_dev(sg_page(s), s->offset, s->length, dir);

		arch_sync_dma_for_device(sg_phys(s), s->length, dir);

}



/**

 * arm_iommu_map_page

 * arm_iommu_map_phys

 * @dev: valid struct device pointer

 * @page: page that buffer resides in

 * @offset: offset into page for start of buffer

 * @phys: physical address that buffer resides in

 * @size: size of buffer to map

 * @dir: DMA transfer direction

 * @attrs: DMA mapping attributes

 *

 * IOMMU aware version of arm_dma_map_page()

 */

static dma_addr_t arm_iommu_map_page(struct device *dev, struct page *page,

	     unsigned long offset, size_t size, enum dma_data_direction dir,

	     unsigned long attrs)

static dma_addr_t arm_iommu_map_phys(struct device *dev, phys_addr_t phys,

	     size_t size, enum dma_data_direction dir, unsigned long attrs)

{

	struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev);

	int len = PAGE_ALIGN(size + offset_in_page(phys));

	phys_addr_t addr = phys & PAGE_MASK;

	dma_addr_t dma_addr;

	int ret, prot, len = PAGE_ALIGN(size + offset);

	int ret, prot;



	if (!dev->dma_coherent && !(attrs & DMA_ATTR_SKIP_CPU_SYNC))

		__dma_page_cpu_to_dev(page, offset, size, dir);

	if (!dev->dma_coherent &&

	    !(attrs & (DMA_ATTR_SKIP_CPU_SYNC | DMA_ATTR_MMIO)))

		arch_sync_dma_for_device(phys, size, dir);



	dma_addr = __alloc_iova(mapping, len);

	if (dma_addr == DMA_MAPPING_ERROR)
@@ -1382,12 +1381,11 @@ static dma_addr_t arm_iommu_map_page(struct device *dev, struct page *page, 


	prot = __dma_info_to_prot(dir, attrs);



	ret = iommu_map(mapping->domain, dma_addr, page_to_phys(page), len,

			prot, GFP_KERNEL);

	ret = iommu_map(mapping->domain, dma_addr, addr, len, prot, GFP_KERNEL);

	if (ret < 0)

		goto fail;



	return dma_addr + offset;

	return dma_addr + offset_in_page(phys);

fail:

	__free_iova(mapping, dma_addr, len);

	return DMA_MAPPING_ERROR;
@@ -1399,83 +1397,28 @@ static dma_addr_t arm_iommu_map_page(struct device *dev, struct page *page, 
 * @handle: DMA address of buffer

 * @size: size of buffer (same as passed to dma_map_page)

 * @dir: DMA transfer direction (same as passed to dma_map_page)

 * @attrs: DMA mapping attributes

 *

 * IOMMU aware version of arm_dma_unmap_page()

 * IOMMU aware version of arm_dma_unmap_phys()

 */

static void arm_iommu_unmap_page(struct device *dev, dma_addr_t handle,

static void arm_iommu_unmap_phys(struct device *dev, dma_addr_t handle,

		size_t size, enum dma_data_direction dir, unsigned long attrs)

{

	struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev);

	dma_addr_t iova = handle & PAGE_MASK;

	struct page *page;

	int offset = handle & ~PAGE_MASK;

	int len = PAGE_ALIGN(size + offset);



	if (!iova)

		return;



	if (!dev->dma_coherent && !(attrs & DMA_ATTR_SKIP_CPU_SYNC)) {

		page = phys_to_page(iommu_iova_to_phys(mapping->domain, iova));

		__dma_page_dev_to_cpu(page, offset, size, dir);

	}

	if (!dev->dma_coherent &&

	    !(attrs & (DMA_ATTR_SKIP_CPU_SYNC | DMA_ATTR_MMIO))) {

		phys_addr_t phys = iommu_iova_to_phys(mapping->domain, iova);



	iommu_unmap(mapping->domain, iova, len);

	__free_iova(mapping, iova, len);

		arch_sync_dma_for_cpu(phys + offset, size, dir);

	}



/**

 * arm_iommu_map_resource - map a device resource for DMA

 * @dev: valid struct device pointer

 * @phys_addr: physical address of resource

 * @size: size of resource to map

 * @dir: DMA transfer direction

 */

static dma_addr_t arm_iommu_map_resource(struct device *dev,

		phys_addr_t phys_addr, size_t size,

		enum dma_data_direction dir, unsigned long attrs)

{

	struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev);

	dma_addr_t dma_addr;

	int ret, prot;

	phys_addr_t addr = phys_addr & PAGE_MASK;

	unsigned int offset = phys_addr & ~PAGE_MASK;

	size_t len = PAGE_ALIGN(size + offset);



	dma_addr = __alloc_iova(mapping, len);

	if (dma_addr == DMA_MAPPING_ERROR)

		return dma_addr;



	prot = __dma_info_to_prot(dir, attrs) | IOMMU_MMIO;



	ret = iommu_map(mapping->domain, dma_addr, addr, len, prot, GFP_KERNEL);

	if (ret < 0)

		goto fail;



	return dma_addr + offset;

fail:

	__free_iova(mapping, dma_addr, len);

	return DMA_MAPPING_ERROR;

}



/**

 * arm_iommu_unmap_resource - unmap a device DMA resource

 * @dev: valid struct device pointer

 * @dma_handle: DMA address to resource

 * @size: size of resource to map

 * @dir: DMA transfer direction

 */

static void arm_iommu_unmap_resource(struct device *dev, dma_addr_t dma_handle,

		size_t size, enum dma_data_direction dir,

		unsigned long attrs)

{

	struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev);

	dma_addr_t iova = dma_handle & PAGE_MASK;

	unsigned int offset = dma_handle & ~PAGE_MASK;

	size_t len = PAGE_ALIGN(size + offset);



	if (!iova)

		return;



	iommu_unmap(mapping->domain, iova, len);

	__free_iova(mapping, iova, len);

}
@@ -1485,14 +1428,14 @@ static void arm_iommu_sync_single_for_cpu(struct device *dev, 
{

	struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev);

	dma_addr_t iova = handle & PAGE_MASK;

	struct page *page;

	unsigned int offset = handle & ~PAGE_MASK;

	phys_addr_t phys;



	if (dev->dma_coherent || !iova)

		return;



	page = phys_to_page(iommu_iova_to_phys(mapping->domain, iova));

	__dma_page_dev_to_cpu(page, offset, size, dir);

	phys = iommu_iova_to_phys(mapping->domain, iova);

	arch_sync_dma_for_cpu(phys + offset, size, dir);

}



static void arm_iommu_sync_single_for_device(struct device *dev,
@@ -1500,14 +1443,14 @@ static void arm_iommu_sync_single_for_device(struct device *dev, 
{

	struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev);

	dma_addr_t iova = handle & PAGE_MASK;

	struct page *page;

	unsigned int offset = handle & ~PAGE_MASK;

	phys_addr_t phys;



	if (dev->dma_coherent || !iova)

		return;



	page = phys_to_page(iommu_iova_to_phys(mapping->domain, iova));

	__dma_page_cpu_to_dev(page, offset, size, dir);

	phys = iommu_iova_to_phys(mapping->domain, iova);

	arch_sync_dma_for_device(phys + offset, size, dir);

}



static const struct dma_map_ops iommu_ops = {
@@ -1516,8 +1459,8 @@ static const struct dma_map_ops iommu_ops = { 
	.mmap		= arm_iommu_mmap_attrs,

	.get_sgtable	= arm_iommu_get_sgtable,



	.map_page		= arm_iommu_map_page,

	.unmap_page		= arm_iommu_unmap_page,

	.map_phys		= arm_iommu_map_phys,

	.unmap_phys		= arm_iommu_unmap_phys,

	.sync_single_for_cpu	= arm_iommu_sync_single_for_cpu,

	.sync_single_for_device	= arm_iommu_sync_single_for_device,
@@ -1525,9 +1468,6 @@ static const struct dma_map_ops iommu_ops = { 
	.unmap_sg		= arm_iommu_unmap_sg,

	.sync_sg_for_cpu	= arm_iommu_sync_sg_for_cpu,

	.sync_sg_for_device	= arm_iommu_sync_sg_for_device,



	.map_resource		= arm_iommu_map_resource,

	.unmap_resource		= arm_iommu_unmap_resource,

};



/**
@@ -1794,20 +1734,6 @@ void arch_teardown_dma_ops(struct device *dev) 
	set_dma_ops(dev, NULL);

}



void arch_sync_dma_for_device(phys_addr_t paddr, size_t size,

		enum dma_data_direction dir)

{

	__dma_page_cpu_to_dev(phys_to_page(paddr), paddr & (PAGE_SIZE - 1),

			      size, dir);

}



void arch_sync_dma_for_cpu(phys_addr_t paddr, size_t size,

		enum dma_data_direction dir)

{

	__dma_page_dev_to_cpu(phys_to_page(paddr), paddr & (PAGE_SIZE - 1),

			      size, dir);

}



void *arch_dma_alloc(struct device *dev, size_t size, dma_addr_t *dma_handle,

		gfp_t gfp, unsigned long attrs)

{

arch/mips/jazz/jazzdma.c

+13 −7
Original line number Diff line number Diff line
@@ -521,18 +521,24 @@ static void jazz_dma_free(struct device *dev, size_t size, void *vaddr, 
	__free_pages(virt_to_page(vaddr), get_order(size));

}



static dma_addr_t jazz_dma_map_page(struct device *dev, struct page *page,

		unsigned long offset, size_t size, enum dma_data_direction dir,

		unsigned long attrs)

static dma_addr_t jazz_dma_map_phys(struct device *dev, phys_addr_t phys,

		size_t size, enum dma_data_direction dir, unsigned long attrs)

{

	phys_addr_t phys = page_to_phys(page) + offset;

	if (unlikely(attrs & DMA_ATTR_MMIO))

		/*

		 * This check is included because older versions of the code lacked

		 * MMIO path support, and my ability to test this path is limited.

		 * However, from a software technical standpoint, there is no restriction,

		 * as the following code operates solely on physical addresses.

		 */

		return DMA_MAPPING_ERROR;



	if (!(attrs & DMA_ATTR_SKIP_CPU_SYNC))

		arch_sync_dma_for_device(phys, size, dir);

	return vdma_alloc(phys, size);

}



static void jazz_dma_unmap_page(struct device *dev, dma_addr_t dma_addr,

static void jazz_dma_unmap_phys(struct device *dev, dma_addr_t dma_addr,

		size_t size, enum dma_data_direction dir, unsigned long attrs)

{

	if (!(attrs & DMA_ATTR_SKIP_CPU_SYNC))
@@ -607,8 +613,8 @@ static void jazz_dma_sync_sg_for_cpu(struct device *dev, 
const struct dma_map_ops jazz_dma_ops = {

	.alloc			= jazz_dma_alloc,

	.free			= jazz_dma_free,

	.map_page		= jazz_dma_map_page,

	.unmap_page		= jazz_dma_unmap_page,

	.map_phys		= jazz_dma_map_phys,

	.unmap_phys		= jazz_dma_unmap_phys,

	.map_sg			= jazz_dma_map_sg,

	.unmap_sg		= jazz_dma_unmap_sg,

	.sync_single_for_cpu	= jazz_dma_sync_single_for_cpu,

arch/powerpc/include/asm/iommu.h

+4 −4
Original line number Diff line number Diff line
@@ -274,12 +274,12 @@ extern void *iommu_alloc_coherent(struct device *dev, struct iommu_table *tbl, 
				  unsigned long mask, gfp_t flag, int node);

extern void iommu_free_coherent(struct iommu_table *tbl, size_t size,

				void *vaddr, dma_addr_t dma_handle);

extern dma_addr_t iommu_map_page(struct device *dev, struct iommu_table *tbl,

				 struct page *page, unsigned long offset,

				 size_t size, unsigned long mask,

extern dma_addr_t iommu_map_phys(struct device *dev, struct iommu_table *tbl,

				 phys_addr_t phys, size_t size,

				 unsigned long mask,

				 enum dma_data_direction direction,

				 unsigned long attrs);

extern void iommu_unmap_page(struct iommu_table *tbl, dma_addr_t dma_handle,

extern void iommu_unmap_phys(struct iommu_table *tbl, dma_addr_t dma_handle,

			     size_t size, enum dma_data_direction direction,

			     unsigned long attrs);

arch/powerpc/kernel/dma-iommu.c

+10 −12
Original line number Diff line number Diff line
@@ -93,28 +93,26 @@ static void dma_iommu_free_coherent(struct device *dev, size_t size, 


/* Creates TCEs for a user provided buffer.  The user buffer must be

 * contiguous real kernel storage (not vmalloc).  The address passed here

 * comprises a page address and offset into that page. The dma_addr_t

 * returned will point to the same byte within the page as was passed in.

 * is a physical address to that page. The dma_addr_t returned will point

 * to the same byte within the page as was passed in.

 */

static dma_addr_t dma_iommu_map_page(struct device *dev, struct page *page,

				     unsigned long offset, size_t size,

static dma_addr_t dma_iommu_map_phys(struct device *dev, phys_addr_t phys,

				     size_t size,

				     enum dma_data_direction direction,

				     unsigned long attrs)

{

	return iommu_map_page(dev, get_iommu_table_base(dev), page, offset,

			      size, dma_get_mask(dev), direction, attrs);

	return iommu_map_phys(dev, get_iommu_table_base(dev), phys, size,

			      dma_get_mask(dev), direction, attrs);

}





static void dma_iommu_unmap_page(struct device *dev, dma_addr_t dma_handle,

static void dma_iommu_unmap_phys(struct device *dev, dma_addr_t dma_handle,

				 size_t size, enum dma_data_direction direction,

				 unsigned long attrs)

{

	iommu_unmap_page(get_iommu_table_base(dev), dma_handle, size, direction,

	iommu_unmap_phys(get_iommu_table_base(dev), dma_handle, size, direction,

			 attrs);

}





static int dma_iommu_map_sg(struct device *dev, struct scatterlist *sglist,

			    int nelems, enum dma_data_direction direction,

			    unsigned long attrs)
@@ -211,8 +209,8 @@ const struct dma_map_ops dma_iommu_ops = { 
	.map_sg			= dma_iommu_map_sg,

	.unmap_sg		= dma_iommu_unmap_sg,

	.dma_supported		= dma_iommu_dma_supported,

	.map_page		= dma_iommu_map_page,

	.unmap_page		= dma_iommu_unmap_page,

	.map_phys		= dma_iommu_map_phys,

	.unmap_phys		= dma_iommu_unmap_phys,

	.get_required_mask	= dma_iommu_get_required_mask,

	.mmap			= dma_common_mmap,

	.get_sgtable		= dma_common_get_sgtable,