Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux

dma-mapping: split <linux/dma-mapping.h>

Split out all the bits that are purely for dma_map_ops implementations
and related code into a new <linux/dma-map-ops.h> header so that they
don't get pulled into all the drivers. That also means the architecture
specific <asm/dma-mapping.h> is not pulled in by <linux/dma-mapping.h>
any more, which leads to a missing includes that were pulled in by the
x86 or arm versions in a few not overly portable drivers.

Signed-off-by: Christoph Hellwig <hch@lst.de>

+223 -200
+1
MAINTAINERS
··· 5202 5202 F: include/asm-generic/dma-mapping.h 5203 5203 F: include/linux/dma-direct.h 5204 5204 F: include/linux/dma-mapping.h 5205 + F: include/linux/dma-map-ops.h 5205 5206 F: include/linux/dma-noncoherent.h 5206 5207 F: kernel/dma/ 5207 5208
+1 -1
arch/alpha/kernel/pci_iommu.c
··· 11 11 #include <linux/export.h> 12 12 #include <linux/scatterlist.h> 13 13 #include <linux/log2.h> 14 - #include <linux/dma-mapping.h> 14 + #include <linux/dma-map-ops.h> 15 15 #include <linux/iommu-helper.h> 16 16 17 17 #include <asm/io.h>
+1
arch/arc/mm/dma.c
··· 3 3 * Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com) 4 4 */ 5 5 6 + #include <linux/dma-map-ops.h> 6 7 #include <linux/dma-noncoherent.h> 7 8 #include <asm/cache.h> 8 9 #include <asm/cacheflush.h>
+1
arch/arm/common/dmabounce.c
··· 25 25 #include <linux/page-flags.h> 26 26 #include <linux/device.h> 27 27 #include <linux/dma-direct.h> 28 + #include <linux/dma-map-ops.h> 28 29 #include <linux/dmapool.h> 29 30 #include <linux/list.h> 30 31 #include <linux/scatterlist.h>
+1 -1
arch/arm/mach-highbank/highbank.c
··· 5 5 #include <linux/clk.h> 6 6 #include <linux/clkdev.h> 7 7 #include <linux/clocksource.h> 8 - #include <linux/dma-mapping.h> 8 + #include <linux/dma-map-ops.h> 9 9 #include <linux/input.h> 10 10 #include <linux/io.h> 11 11 #include <linux/irqchip.h>
+1 -1
arch/arm/mach-imx/mach-imx27_visstrim_m10.c
··· 16 16 #include <linux/input.h> 17 17 #include <linux/gpio.h> 18 18 #include <linux/delay.h> 19 - #include <linux/dma-mapping.h> 19 + #include <linux/dma-map-ops.h> 20 20 #include <linux/leds.h> 21 21 #include <linux/platform_data/asoc-mx27vis.h> 22 22 #include <sound/tlv320aic32x4.h>
+1 -1
arch/arm/mach-imx/mach-mx31moboard.c
··· 4 4 */ 5 5 6 6 #include <linux/delay.h> 7 - #include <linux/dma-mapping.h> 7 + #include <linux/dma-map-ops.h> 8 8 #include <linux/gfp.h> 9 9 #include <linux/gpio.h> 10 10 #include <linux/init.h>
+1 -1
arch/arm/mach-mvebu/coherency.c
··· 25 25 #include <linux/of_address.h> 26 26 #include <linux/io.h> 27 27 #include <linux/smp.h> 28 - #include <linux/dma-mapping.h> 28 + #include <linux/dma-map-ops.h> 29 29 #include <linux/platform_device.h> 30 30 #include <linux/slab.h> 31 31 #include <linux/mbus.h>
+1
arch/arm/mm/dma-mapping-nommu.c
··· 8 8 #include <linux/export.h> 9 9 #include <linux/mm.h> 10 10 #include <linux/dma-direct.h> 11 + #include <linux/dma-map-ops.h> 11 12 #include <linux/scatterlist.h> 12 13 13 14 #include <asm/cachetype.h>
+1 -1
arch/arm/mm/dma-mapping.c
··· 15 15 #include <linux/init.h> 16 16 #include <linux/device.h> 17 17 #include <linux/dma-direct.h> 18 - #include <linux/dma-mapping.h> 18 + #include <linux/dma-map-ops.h> 19 19 #include <linux/dma-noncoherent.h> 20 20 #include <linux/dma-contiguous.h> 21 21 #include <linux/highmem.h>
+1
arch/arm64/mm/dma-mapping.c
··· 6 6 7 7 #include <linux/gfp.h> 8 8 #include <linux/cache.h> 9 + #include <linux/dma-map-ops.h> 9 10 #include <linux/dma-noncoherent.h> 10 11 #include <linux/dma-iommu.h> 11 12 #include <xen/xen.h>
+1 -1
arch/ia64/hp/common/sba_iommu.c
··· 33 33 #include <linux/bitops.h> /* hweight64() */ 34 34 #include <linux/crash_dump.h> 35 35 #include <linux/iommu-helper.h> 36 - #include <linux/dma-mapping.h> 36 + #include <linux/dma-map-ops.h> 37 37 #include <linux/prefetch.h> 38 38 #include <linux/swiotlb.h> 39 39
+1 -1
arch/ia64/kernel/dma-mapping.c
··· 1 1 // SPDX-License-Identifier: GPL-2.0 2 - #include <linux/dma-mapping.h> 2 + #include <linux/dma-map-ops.h> 3 3 #include <linux/export.h> 4 4 5 5 /* Set this to 1 if there is a HW IOMMU in the system */
+1
arch/mips/jazz/jazzdma.c
··· 16 16 #include <linux/memblock.h> 17 17 #include <linux/spinlock.h> 18 18 #include <linux/gfp.h> 19 + #include <linux/dma-map-ops.h> 19 20 #include <linux/dma-noncoherent.h> 20 21 #include <asm/mipsregs.h> 21 22 #include <asm/jazz.h>
+1
arch/mips/mm/dma-noncoherent.c
··· 5 5 * swiped from i386, and cloned for MIPS by Geert, polished by Ralf. 6 6 */ 7 7 #include <linux/dma-direct.h> 8 + #include <linux/dma-map-ops.h> 8 9 #include <linux/dma-noncoherent.h> 9 10 #include <linux/dma-contiguous.h> 10 11 #include <linux/highmem.h>
+1
arch/parisc/kernel/drivers.c
··· 30 30 #include <linux/spinlock.h> 31 31 #include <linux/string.h> 32 32 #include <linux/export.h> 33 + #include <linux/dma-map-ops.h> 33 34 #include <asm/hardware.h> 34 35 #include <asm/io.h> 35 36 #include <asm/pdc.h>
+1 -1
arch/powerpc/include/asm/iommu.h
··· 12 12 #include <linux/compiler.h> 13 13 #include <linux/spinlock.h> 14 14 #include <linux/device.h> 15 - #include <linux/dma-mapping.h> 15 + #include <linux/dma-map-ops.h> 16 16 #include <linux/bitops.h> 17 17 #include <asm/machdep.h> 18 18 #include <asm/types.h>
+1 -1
arch/powerpc/include/asm/pci.h
··· 9 9 #include <linux/types.h> 10 10 #include <linux/slab.h> 11 11 #include <linux/string.h> 12 - #include <linux/dma-mapping.h> 12 + #include <linux/dma-map-ops.h> 13 13 #include <linux/scatterlist.h> 14 14 15 15 #include <asm/machdep.h>
+1 -1
arch/powerpc/platforms/ps3/system-bus.c
··· 9 9 #include <linux/kernel.h> 10 10 #include <linux/init.h> 11 11 #include <linux/export.h> 12 - #include <linux/dma-mapping.h> 12 + #include <linux/dma-map-ops.h> 13 13 #include <linux/err.h> 14 14 #include <linux/slab.h> 15 15
+1 -1
arch/powerpc/platforms/pseries/ibmebus.c
··· 40 40 #include <linux/export.h> 41 41 #include <linux/console.h> 42 42 #include <linux/kobject.h> 43 - #include <linux/dma-mapping.h> 43 + #include <linux/dma-map-ops.h> 44 44 #include <linux/interrupt.h> 45 45 #include <linux/of.h> 46 46 #include <linux/slab.h>
+1 -1
arch/powerpc/platforms/pseries/vio.c
··· 20 20 #include <linux/console.h> 21 21 #include <linux/export.h> 22 22 #include <linux/mm.h> 23 - #include <linux/dma-mapping.h> 23 + #include <linux/dma-map-ops.h> 24 24 #include <linux/kobject.h> 25 25 26 26 #include <asm/iommu.h>
+1 -1
arch/s390/pci/pci_dma.c
··· 10 10 #include <linux/slab.h> 11 11 #include <linux/export.h> 12 12 #include <linux/iommu-helper.h> 13 - #include <linux/dma-mapping.h> 13 + #include <linux/dma-map-ops.h> 14 14 #include <linux/vmalloc.h> 15 15 #include <linux/pci.h> 16 16 #include <asm/pci_dma.h>
+1
arch/sh/boards/mach-ap325rxa/setup.c
··· 13 13 14 14 #include <cpu/sh7723.h> 15 15 16 + #include <linux/dma-map-ops.h> 16 17 #include <linux/clkdev.h> 17 18 #include <linux/delay.h> 18 19 #include <linux/device.h>
+1
arch/sh/boards/mach-ecovec24/setup.c
··· 36 36 #include <linux/usb/r8a66597.h> 37 37 #include <linux/usb/renesas_usbhs.h> 38 38 #include <linux/videodev2.h> 39 + #include <linux/dma-map-ops.h> 39 40 40 41 #include <media/drv-intf/renesas-ceu.h> 41 42 #include <media/i2c/mt9t112.h>
+1 -1
arch/sh/boards/mach-kfr2r09/setup.c
··· 14 14 15 15 #include <linux/clkdev.h> 16 16 #include <linux/delay.h> 17 - #include <linux/dma-mapping.h> 18 17 #include <linux/gpio.h> 19 18 #include <linux/gpio/machine.h> 20 19 #include <linux/i2c.h> ··· 32 33 #include <linux/sh_intc.h> 33 34 #include <linux/usb/r8a66597.h> 34 35 #include <linux/videodev2.h> 36 + #include <linux/dma-map-ops.h> 35 37 36 38 #include <mach/kfr2r09.h> 37 39
+1 -1
arch/sh/boards/mach-migor/setup.c
··· 5 5 * Copyright (C) 2008 Magnus Damm 6 6 */ 7 7 #include <linux/clkdev.h> 8 - #include <linux/dma-mapping.h> 8 + #include <linux/dma-map-ops.h> 9 9 #include <linux/init.h> 10 10 #include <linux/platform_device.h> 11 11 #include <linux/interrupt.h>
+1
arch/sh/boards/mach-se/7724/setup.c
··· 32 32 #include <linux/smc91x.h> 33 33 #include <linux/usb/r8a66597.h> 34 34 #include <linux/videodev2.h> 35 + #include <linux/dma-map-ops.h> 35 36 36 37 #include <mach-se/mach/se7724.h> 37 38 #include <media/drv-intf/renesas-ceu.h>
+1 -1
arch/sh/drivers/pci/fixups-dreamcast.c
··· 19 19 #include <linux/init.h> 20 20 #include <linux/irq.h> 21 21 #include <linux/pci.h> 22 - #include <linux/dma-mapping.h> 22 + #include <linux/dma-map-ops.h> 23 23 24 24 #include <asm/io.h> 25 25 #include <asm/irq.h>
+1 -1
arch/sparc/kernel/iommu.c
··· 10 10 #include <linux/slab.h> 11 11 #include <linux/delay.h> 12 12 #include <linux/device.h> 13 - #include <linux/dma-mapping.h> 13 + #include <linux/dma-map-ops.h> 14 14 #include <linux/errno.h> 15 15 #include <linux/iommu-helper.h> 16 16 #include <linux/bitmap.h>
+1
arch/sparc/kernel/pci_sun4v.c
··· 16 16 #include <linux/export.h> 17 17 #include <linux/log2.h> 18 18 #include <linux/of_device.h> 19 + #include <linux/dma-map-ops.h> 19 20 #include <asm/iommu-common.h> 20 21 21 22 #include <asm/iommu.h>
+1 -1
arch/sparc/mm/io-unit.c
··· 11 11 #include <linux/spinlock.h> 12 12 #include <linux/mm.h> 13 13 #include <linux/bitops.h> 14 - #include <linux/dma-mapping.h> 14 + #include <linux/dma-map-ops.h> 15 15 #include <linux/of.h> 16 16 #include <linux/of_device.h> 17 17
+1 -1
arch/sparc/mm/iommu.c
··· 12 12 #include <linux/init.h> 13 13 #include <linux/mm.h> 14 14 #include <linux/slab.h> 15 - #include <linux/dma-mapping.h> 15 + #include <linux/dma-map-ops.h> 16 16 #include <linux/of.h> 17 17 #include <linux/of_device.h> 18 18
+1
arch/x86/kernel/amd_gart_64.c
··· 32 32 #include <linux/gfp.h> 33 33 #include <linux/atomic.h> 34 34 #include <linux/dma-direct.h> 35 + #include <linux/dma-map-ops.h> 35 36 #include <asm/mtrr.h> 36 37 #include <asm/proto.h> 37 38 #include <asm/iommu.h>
+1
arch/x86/kernel/pci-dma.c
··· 1 1 // SPDX-License-Identifier: GPL-2.0 2 + #include <linux/dma-map-ops.h> 2 3 #include <linux/dma-direct.h> 3 4 #include <linux/dma-debug.h> 4 5 #include <linux/iommu.h>
+2
arch/x86/kernel/setup.c
··· 7 7 */ 8 8 #include <linux/console.h> 9 9 #include <linux/crash_dump.h> 10 + #include <linux/dma-contiguous.h> 10 11 #include <linux/dmi.h> 11 12 #include <linux/efi.h> 12 13 #include <linux/init_ohci1394_dma.h> ··· 20 19 #include <linux/hugetlb.h> 21 20 #include <linux/tboot.h> 22 21 #include <linux/usb/xhci-dbgp.h> 22 + #include <linux/swiotlb.h> 23 23 24 24 #include <uapi/linux/mount.h> 25 25
+1 -1
arch/x86/xen/pci-swiotlb-xen.c
··· 2 2 3 3 /* Glue code to lib/swiotlb-xen.c */ 4 4 5 - #include <linux/dma-mapping.h> 5 + #include <linux/dma-map-ops.h> 6 6 #include <linux/pci.h> 7 7 #include <xen/swiotlb-xen.h> 8 8
+1 -1
drivers/acpi/arm64/iort.c
··· 18 18 #include <linux/pci.h> 19 19 #include <linux/platform_device.h> 20 20 #include <linux/slab.h> 21 - #include <linux/dma-mapping.h> 21 + #include <linux/dma-map-ops.h> 22 22 23 23 #define IORT_TYPE_MASK(type) (1 << (type)) 24 24 #define IORT_MSI_TYPE (1 << ACPI_IORT_NODE_ITS_GROUP)
+1 -1
drivers/acpi/scan.c
··· 13 13 #include <linux/kthread.h> 14 14 #include <linux/dmi.h> 15 15 #include <linux/nls.h> 16 - #include <linux/dma-mapping.h> 16 + #include <linux/dma-map-ops.h> 17 17 #include <linux/platform_data/x86/apple.h> 18 18 #include <linux/pgtable.h> 19 19
+1 -1
drivers/base/dd.c
··· 19 19 #include <linux/debugfs.h> 20 20 #include <linux/device.h> 21 21 #include <linux/delay.h> 22 - #include <linux/dma-mapping.h> 22 + #include <linux/dma-map-ops.h> 23 23 #include <linux/init.h> 24 24 #include <linux/module.h> 25 25 #include <linux/kthread.h>
+1 -1
drivers/gpu/drm/exynos/exynos_drm_dma.c
··· 5 5 // Author: Andrzej Hajda <a.hajda@samsung.com> 6 6 7 7 #include <linux/dma-iommu.h> 8 - #include <linux/dma-mapping.h> 8 + #include <linux/dma-map-ops.h> 9 9 #include <linux/iommu.h> 10 10 #include <linux/platform_device.h> 11 11
+1
drivers/gpu/drm/msm/msm_gem.c
··· 4 4 * Author: Rob Clark <robdclark@gmail.com> 5 5 */ 6 6 7 + #include <linux/dma-map-ops.h> 7 8 #include <linux/spinlock.h> 8 9 #include <linux/shmem_fs.h> 9 10 #include <linux/dma-buf.h>
+1
drivers/iommu/dma-iommu.c
··· 10 10 11 11 #include <linux/acpi_iort.h> 12 12 #include <linux/device.h> 13 + #include <linux/dma-map-ops.h> 13 14 #include <linux/dma-contiguous.h> 14 15 #include <linux/dma-iommu.h> 15 16 #include <linux/dma-noncoherent.h>
+1 -1
drivers/iommu/intel/iommu.c
··· 23 23 #include <linux/spinlock.h> 24 24 #include <linux/pci.h> 25 25 #include <linux/dmar.h> 26 - #include <linux/dma-mapping.h> 26 + #include <linux/dma-map-ops.h> 27 27 #include <linux/mempool.h> 28 28 #include <linux/memory.h> 29 29 #include <linux/cpu.h>
+1
drivers/misc/mic/bus/mic_bus.c
··· 9 9 * This implementation is very similar to the the virtio bus driver 10 10 * implementation @ drivers/virtio/virtio.c 11 11 */ 12 + #include <linux/dma-map-ops.h> 12 13 #include <linux/slab.h> 13 14 #include <linux/module.h> 14 15 #include <linux/idr.h>
+1 -1
drivers/misc/mic/bus/scif_bus.c
··· 9 9 #include <linux/slab.h> 10 10 #include <linux/module.h> 11 11 #include <linux/idr.h> 12 - #include <linux/dma-mapping.h> 12 + #include <linux/dma-map-ops.h> 13 13 14 14 #include "scif_bus.h" 15 15
+1 -1
drivers/misc/mic/bus/scif_bus.h
··· 12 12 * Everything a scif driver needs to work with any particular scif 13 13 * hardware abstraction layer. 14 14 */ 15 - #include <linux/dma-mapping.h> 15 + #include <linux/dma-map-ops.h> 16 16 17 17 #include <linux/mic_common.h> 18 18 #include "../common/mic_dev.h"
+1 -1
drivers/misc/mic/bus/vop_bus.c
··· 9 9 #include <linux/slab.h> 10 10 #include <linux/module.h> 11 11 #include <linux/idr.h> 12 - #include <linux/dma-mapping.h> 12 + #include <linux/dma-map-ops.h> 13 13 14 14 #include "vop_bus.h" 15 15
+1
drivers/misc/mic/host/mic_boot.c
··· 10 10 #include <linux/firmware.h> 11 11 #include <linux/pci.h> 12 12 #include <linux/kmod.h> 13 + #include <linux/dma-map-ops.h> 13 14 #include <linux/mic_common.h> 14 15 #include <linux/mic_bus.h> 15 16 #include "../bus/scif_bus.h"
+1
drivers/of/device.c
··· 6 6 #include <linux/of_address.h> 7 7 #include <linux/of_iommu.h> 8 8 #include <linux/dma-direct.h> /* for bus_dma_region */ 9 + #include <linux/dma-map-ops.h> 9 10 #include <linux/init.h> 10 11 #include <linux/module.h> 11 12 #include <linux/mod_devicetable.h>
+1
drivers/parisc/ccio-dma.c
··· 39 39 #include <linux/reboot.h> 40 40 #include <linux/proc_fs.h> 41 41 #include <linux/seq_file.h> 42 + #include <linux/dma-map-ops.h> 42 43 #include <linux/scatterlist.h> 43 44 #include <linux/iommu-helper.h> 44 45 #include <linux/export.h>
+1
drivers/parisc/sba_iommu.c
··· 25 25 #include <linux/mm.h> 26 26 #include <linux/string.h> 27 27 #include <linux/pci.h> 28 + #include <linux/dma-map-ops.h> 28 29 #include <linux/scatterlist.h> 29 30 #include <linux/iommu-helper.h> 30 31
+1
drivers/pci/xen-pcifront.c
··· 22 22 #include <linux/bitops.h> 23 23 #include <linux/time.h> 24 24 #include <linux/ktime.h> 25 + #include <linux/swiotlb.h> 25 26 #include <xen/platform_pci.h> 26 27 27 28 #include <asm/xen/swiotlb-xen.h>
+1
drivers/remoteproc/remoteproc_core.c
··· 22 22 #include <linux/device.h> 23 23 #include <linux/slab.h> 24 24 #include <linux/mutex.h> 25 + #include <linux/dma-map-ops.h> 25 26 #include <linux/dma-mapping.h> 26 27 #include <linux/dma-direct.h> /* XXX: pokes into bus_dma_range */ 27 28 #include <linux/firmware.h>
+1 -1
drivers/remoteproc/remoteproc_virtio.c
··· 9 9 * Brian Swetland <swetland@google.com> 10 10 */ 11 11 12 - #include <linux/dma-mapping.h> 12 + #include <linux/dma-map-ops.h> 13 13 #include <linux/export.h> 14 14 #include <linux/of_reserved_mem.h> 15 15 #include <linux/remoteproc.h>
+1 -1
drivers/vdpa/vdpa_sim/vdpa_sim.c
··· 18 18 #include <linux/wait.h> 19 19 #include <linux/uuid.h> 20 20 #include <linux/iommu.h> 21 - #include <linux/dma-mapping.h> 21 + #include <linux/dma-map-ops.h> 22 22 #include <linux/sysfs.h> 23 23 #include <linux/file.h> 24 24 #include <linux/etherdevice.h>
+1
drivers/xen/swiotlb-xen.c
··· 27 27 #define pr_fmt(fmt) "xen:" KBUILD_MODNAME ": " fmt 28 28 29 29 #include <linux/memblock.h> 30 + #include <linux/dma-map-ops.h> 30 31 #include <linux/dma-direct.h> 31 32 #include <linux/dma-noncoherent.h> 32 33 #include <linux/export.h>
+158
include/linux/dma-map-ops.h
··· 1 + /* SPDX-License-Identifier: GPL-2.0 */ 2 + /* 3 + * This header is for implementations of dma_map_ops and related code. 4 + * It should not be included in drivers just using the DMA API. 5 + */ 6 + #ifndef _LINUX_DMA_MAP_OPS_H 7 + #define _LINUX_DMA_MAP_OPS_H 8 + 9 + #include <linux/dma-mapping.h> 10 + 11 + struct dma_map_ops { 12 + void *(*alloc)(struct device *dev, size_t size, 13 + dma_addr_t *dma_handle, gfp_t gfp, 14 + unsigned long attrs); 15 + void (*free)(struct device *dev, size_t size, void *vaddr, 16 + dma_addr_t dma_handle, unsigned long attrs); 17 + struct page *(*alloc_pages)(struct device *dev, size_t size, 18 + dma_addr_t *dma_handle, enum dma_data_direction dir, 19 + gfp_t gfp); 20 + void (*free_pages)(struct device *dev, size_t size, struct page *vaddr, 21 + dma_addr_t dma_handle, enum dma_data_direction dir); 22 + void *(*alloc_noncoherent)(struct device *dev, size_t size, 23 + dma_addr_t *dma_handle, enum dma_data_direction dir, 24 + gfp_t gfp); 25 + void (*free_noncoherent)(struct device *dev, size_t size, void *vaddr, 26 + dma_addr_t dma_handle, enum dma_data_direction dir); 27 + int (*mmap)(struct device *, struct vm_area_struct *, 28 + void *, dma_addr_t, size_t, unsigned long attrs); 29 + 30 + int (*get_sgtable)(struct device *dev, struct sg_table *sgt, 31 + void *cpu_addr, dma_addr_t dma_addr, size_t size, 32 + unsigned long attrs); 33 + 34 + dma_addr_t (*map_page)(struct device *dev, struct page *page, 35 + unsigned long offset, size_t size, 36 + enum dma_data_direction dir, unsigned long attrs); 37 + void (*unmap_page)(struct device *dev, dma_addr_t dma_handle, 38 + size_t size, enum dma_data_direction dir, 39 + unsigned long attrs); 40 + /* 41 + * map_sg returns 0 on error and a value > 0 on success. 42 + * It should never return a value < 0. 43 + */ 44 + int (*map_sg)(struct device *dev, struct scatterlist *sg, int nents, 45 + enum dma_data_direction dir, unsigned long attrs); 46 + void (*unmap_sg)(struct device *dev, struct scatterlist *sg, int nents, 47 + enum dma_data_direction dir, unsigned long attrs); 48 + dma_addr_t (*map_resource)(struct device *dev, phys_addr_t phys_addr, 49 + size_t size, enum dma_data_direction dir, 50 + unsigned long attrs); 51 + void (*unmap_resource)(struct device *dev, dma_addr_t dma_handle, 52 + size_t size, enum dma_data_direction dir, 53 + unsigned long attrs); 54 + void (*sync_single_for_cpu)(struct device *dev, dma_addr_t dma_handle, 55 + size_t size, enum dma_data_direction dir); 56 + void (*sync_single_for_device)(struct device *dev, 57 + dma_addr_t dma_handle, size_t size, 58 + enum dma_data_direction dir); 59 + void (*sync_sg_for_cpu)(struct device *dev, struct scatterlist *sg, 60 + int nents, enum dma_data_direction dir); 61 + void (*sync_sg_for_device)(struct device *dev, struct scatterlist *sg, 62 + int nents, enum dma_data_direction dir); 63 + void (*cache_sync)(struct device *dev, void *vaddr, size_t size, 64 + enum dma_data_direction direction); 65 + int (*dma_supported)(struct device *dev, u64 mask); 66 + u64 (*get_required_mask)(struct device *dev); 67 + size_t (*max_mapping_size)(struct device *dev); 68 + unsigned long (*get_merge_boundary)(struct device *dev); 69 + }; 70 + 71 + #ifdef CONFIG_DMA_OPS 72 + #include <asm/dma-mapping.h> 73 + 74 + static inline const struct dma_map_ops *get_dma_ops(struct device *dev) 75 + { 76 + if (dev->dma_ops) 77 + return dev->dma_ops; 78 + return get_arch_dma_ops(dev->bus); 79 + } 80 + 81 + static inline void set_dma_ops(struct device *dev, 82 + const struct dma_map_ops *dma_ops) 83 + { 84 + dev->dma_ops = dma_ops; 85 + } 86 + #else /* CONFIG_DMA_OPS */ 87 + static inline const struct dma_map_ops *get_dma_ops(struct device *dev) 88 + { 89 + return NULL; 90 + } 91 + static inline void set_dma_ops(struct device *dev, 92 + const struct dma_map_ops *dma_ops) 93 + { 94 + } 95 + #endif /* CONFIG_DMA_OPS */ 96 + 97 + #ifdef CONFIG_DMA_DECLARE_COHERENT 98 + int dma_declare_coherent_memory(struct device *dev, phys_addr_t phys_addr, 99 + dma_addr_t device_addr, size_t size); 100 + int dma_alloc_from_dev_coherent(struct device *dev, ssize_t size, 101 + dma_addr_t *dma_handle, void **ret); 102 + int dma_release_from_dev_coherent(struct device *dev, int order, void *vaddr); 103 + int dma_mmap_from_dev_coherent(struct device *dev, struct vm_area_struct *vma, 104 + void *cpu_addr, size_t size, int *ret); 105 + 106 + void *dma_alloc_from_global_coherent(struct device *dev, ssize_t size, 107 + dma_addr_t *dma_handle); 108 + int dma_release_from_global_coherent(int order, void *vaddr); 109 + int dma_mmap_from_global_coherent(struct vm_area_struct *vma, void *cpu_addr, 110 + size_t size, int *ret); 111 + 112 + #else 113 + static inline int dma_declare_coherent_memory(struct device *dev, 114 + phys_addr_t phys_addr, dma_addr_t device_addr, size_t size) 115 + { 116 + return -ENOSYS; 117 + } 118 + #define dma_alloc_from_dev_coherent(dev, size, handle, ret) (0) 119 + #define dma_release_from_dev_coherent(dev, order, vaddr) (0) 120 + #define dma_mmap_from_dev_coherent(dev, vma, vaddr, order, ret) (0) 121 + 122 + static inline void *dma_alloc_from_global_coherent(struct device *dev, 123 + ssize_t size, dma_addr_t *dma_handle) 124 + { 125 + return NULL; 126 + } 127 + static inline int dma_release_from_global_coherent(int order, void *vaddr) 128 + { 129 + return 0; 130 + } 131 + static inline int dma_mmap_from_global_coherent(struct vm_area_struct *vma, 132 + void *cpu_addr, size_t size, int *ret) 133 + { 134 + return 0; 135 + } 136 + #endif /* CONFIG_DMA_DECLARE_COHERENT */ 137 + 138 + #ifdef CONFIG_ARCH_HAS_SETUP_DMA_OPS 139 + void arch_setup_dma_ops(struct device *dev, u64 dma_base, u64 size, 140 + const struct iommu_ops *iommu, bool coherent); 141 + #else 142 + static inline void arch_setup_dma_ops(struct device *dev, u64 dma_base, 143 + u64 size, const struct iommu_ops *iommu, bool coherent) 144 + { 145 + } 146 + #endif /* CONFIG_ARCH_HAS_SETUP_DMA_OPS */ 147 + 148 + #ifdef CONFIG_ARCH_HAS_TEARDOWN_DMA_OPS 149 + void arch_teardown_dma_ops(struct device *dev); 150 + #else 151 + static inline void arch_teardown_dma_ops(struct device *dev) 152 + { 153 + } 154 + #endif /* CONFIG_ARCH_HAS_TEARDOWN_DMA_OPS */ 155 + 156 + extern const struct dma_map_ops dma_dummy_ops; 157 + 158 + #endif /* _LINUX_DMA_MAP_OPS_H */
+2 -166
include/linux/dma-mapping.h
··· 62 62 */ 63 63 #define DMA_ATTR_PRIVILEGED (1UL << 9) 64 64 65 - struct dma_map_ops { 66 - void* (*alloc)(struct device *dev, size_t size, 67 - dma_addr_t *dma_handle, gfp_t gfp, 68 - unsigned long attrs); 69 - void (*free)(struct device *dev, size_t size, 70 - void *vaddr, dma_addr_t dma_handle, 71 - unsigned long attrs); 72 - struct page *(*alloc_pages)(struct device *dev, size_t size, 73 - dma_addr_t *dma_handle, enum dma_data_direction dir, 74 - gfp_t gfp); 75 - void (*free_pages)(struct device *dev, size_t size, struct page *vaddr, 76 - dma_addr_t dma_handle, enum dma_data_direction dir); 77 - void* (*alloc_noncoherent)(struct device *dev, size_t size, 78 - dma_addr_t *dma_handle, enum dma_data_direction dir, 79 - gfp_t gfp); 80 - void (*free_noncoherent)(struct device *dev, size_t size, void *vaddr, 81 - dma_addr_t dma_handle, enum dma_data_direction dir); 82 - int (*mmap)(struct device *, struct vm_area_struct *, 83 - void *, dma_addr_t, size_t, 84 - unsigned long attrs); 85 - 86 - int (*get_sgtable)(struct device *dev, struct sg_table *sgt, void *, 87 - dma_addr_t, size_t, unsigned long attrs); 88 - 89 - dma_addr_t (*map_page)(struct device *dev, struct page *page, 90 - unsigned long offset, size_t size, 91 - enum dma_data_direction dir, 92 - unsigned long attrs); 93 - void (*unmap_page)(struct device *dev, dma_addr_t dma_handle, 94 - size_t size, enum dma_data_direction dir, 95 - unsigned long attrs); 96 - /* 97 - * map_sg returns 0 on error and a value > 0 on success. 98 - * It should never return a value < 0. 99 - */ 100 - int (*map_sg)(struct device *dev, struct scatterlist *sg, 101 - int nents, enum dma_data_direction dir, 102 - unsigned long attrs); 103 - void (*unmap_sg)(struct device *dev, 104 - struct scatterlist *sg, int nents, 105 - enum dma_data_direction dir, 106 - unsigned long attrs); 107 - dma_addr_t (*map_resource)(struct device *dev, phys_addr_t phys_addr, 108 - size_t size, enum dma_data_direction dir, 109 - unsigned long attrs); 110 - void (*unmap_resource)(struct device *dev, dma_addr_t dma_handle, 111 - size_t size, enum dma_data_direction dir, 112 - unsigned long attrs); 113 - void (*sync_single_for_cpu)(struct device *dev, 114 - dma_addr_t dma_handle, size_t size, 115 - enum dma_data_direction dir); 116 - void (*sync_single_for_device)(struct device *dev, 117 - dma_addr_t dma_handle, size_t size, 118 - enum dma_data_direction dir); 119 - void (*sync_sg_for_cpu)(struct device *dev, 120 - struct scatterlist *sg, int nents, 121 - enum dma_data_direction dir); 122 - void (*sync_sg_for_device)(struct device *dev, 123 - struct scatterlist *sg, int nents, 124 - enum dma_data_direction dir); 125 - int (*dma_supported)(struct device *dev, u64 mask); 126 - u64 (*get_required_mask)(struct device *dev); 127 - size_t (*max_mapping_size)(struct device *dev); 128 - unsigned long (*get_merge_boundary)(struct device *dev); 129 - }; 130 - 131 65 /* 132 66 * A dma_addr_t can hold any valid DMA or bus address for the platform. It can 133 67 * be given to a device to use as a DMA source or target. It is specific to a ··· 74 140 */ 75 141 #define DMA_MAPPING_ERROR (~(dma_addr_t)0) 76 142 77 - extern const struct dma_map_ops dma_virt_ops; 78 - extern const struct dma_map_ops dma_dummy_ops; 79 - 80 143 #define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : ((1ULL<<(n))-1)) 81 144 82 - #ifdef CONFIG_DMA_DECLARE_COHERENT 83 - /* 84 - * These three functions are only for dma allocator. 85 - * Don't use them in device drivers. 86 - */ 87 - int dma_alloc_from_dev_coherent(struct device *dev, ssize_t size, 88 - dma_addr_t *dma_handle, void **ret); 89 - int dma_release_from_dev_coherent(struct device *dev, int order, void *vaddr); 90 - 91 - int dma_mmap_from_dev_coherent(struct device *dev, struct vm_area_struct *vma, 92 - void *cpu_addr, size_t size, int *ret); 93 - 94 - void *dma_alloc_from_global_coherent(struct device *dev, ssize_t size, dma_addr_t *dma_handle); 95 - int dma_release_from_global_coherent(int order, void *vaddr); 96 - int dma_mmap_from_global_coherent(struct vm_area_struct *vma, void *cpu_addr, 97 - size_t size, int *ret); 98 - 99 - #else 100 - #define dma_alloc_from_dev_coherent(dev, size, handle, ret) (0) 101 - #define dma_release_from_dev_coherent(dev, order, vaddr) (0) 102 - #define dma_mmap_from_dev_coherent(dev, vma, vaddr, order, ret) (0) 103 - 104 - static inline void *dma_alloc_from_global_coherent(struct device *dev, ssize_t size, 105 - dma_addr_t *dma_handle) 106 - { 107 - return NULL; 108 - } 109 - 110 - static inline int dma_release_from_global_coherent(int order, void *vaddr) 111 - { 112 - return 0; 113 - } 114 - 115 - static inline int dma_mmap_from_global_coherent(struct vm_area_struct *vma, 116 - void *cpu_addr, size_t size, 117 - int *ret) 118 - { 119 - return 0; 120 - } 121 - #endif /* CONFIG_DMA_DECLARE_COHERENT */ 122 - 123 145 #ifdef CONFIG_HAS_DMA 124 - #include <asm/dma-mapping.h> 125 - 126 - #ifdef CONFIG_DMA_OPS 127 - static inline const struct dma_map_ops *get_dma_ops(struct device *dev) 128 - { 129 - if (dev->dma_ops) 130 - return dev->dma_ops; 131 - return get_arch_dma_ops(dev->bus); 132 - } 133 - 134 - static inline void set_dma_ops(struct device *dev, 135 - const struct dma_map_ops *dma_ops) 136 - { 137 - dev->dma_ops = dma_ops; 138 - } 139 - #else /* CONFIG_DMA_OPS */ 140 - static inline const struct dma_map_ops *get_dma_ops(struct device *dev) 141 - { 142 - return NULL; 143 - } 144 - static inline void set_dma_ops(struct device *dev, 145 - const struct dma_map_ops *dma_ops) 146 - { 147 - } 148 - #endif /* CONFIG_DMA_OPS */ 149 - 150 146 static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr) 151 147 { 152 148 debug_dma_mapping_error(dev, dma_addr); ··· 459 595 dma_get_required_mask(dev); 460 596 } 461 597 462 - #ifdef CONFIG_ARCH_HAS_SETUP_DMA_OPS 463 - void arch_setup_dma_ops(struct device *dev, u64 dma_base, u64 size, 464 - const struct iommu_ops *iommu, bool coherent); 465 - #else 466 - static inline void arch_setup_dma_ops(struct device *dev, u64 dma_base, 467 - u64 size, const struct iommu_ops *iommu, bool coherent) 468 - { 469 - } 470 - #endif /* CONFIG_ARCH_HAS_SETUP_DMA_OPS */ 471 - 472 - #ifdef CONFIG_ARCH_HAS_TEARDOWN_DMA_OPS 473 - void arch_teardown_dma_ops(struct device *dev); 474 - #else 475 - static inline void arch_teardown_dma_ops(struct device *dev) 476 - { 477 - } 478 - #endif /* CONFIG_ARCH_HAS_TEARDOWN_DMA_OPS */ 479 - 480 598 static inline unsigned int dma_get_max_seg_size(struct device *dev) 481 599 { 482 600 if (dev->dma_parms && dev->dma_parms->max_segment_size) ··· 518 672 return 1; 519 673 } 520 674 521 - #ifdef CONFIG_DMA_DECLARE_COHERENT 522 - int dma_declare_coherent_memory(struct device *dev, phys_addr_t phys_addr, 523 - dma_addr_t device_addr, size_t size); 524 - #else 525 - static inline int 526 - dma_declare_coherent_memory(struct device *dev, phys_addr_t phys_addr, 527 - dma_addr_t device_addr, size_t size) 528 - { 529 - return -ENOSYS; 530 - } 531 - #endif /* CONFIG_DMA_DECLARE_COHERENT */ 532 - 533 675 static inline void *dmam_alloc_coherent(struct device *dev, size_t size, 534 676 dma_addr_t *dma_handle, gfp_t gfp) 535 677 { ··· 574 740 */ 575 741 int dma_direct_set_offset(struct device *dev, phys_addr_t cpu_start, 576 742 dma_addr_t dma_start, u64 size); 743 + 744 + extern const struct dma_map_ops dma_virt_ops; 577 745 578 746 #endif /* _LINUX_DMA_MAPPING_H */
+1
kernel/dma/coherent.c
··· 8 8 #include <linux/kernel.h> 9 9 #include <linux/module.h> 10 10 #include <linux/dma-direct.h> 11 + #include <linux/dma-map-ops.h> 11 12 12 13 struct dma_coherent_mem { 13 14 void *virt_base;
+1
kernel/dma/direct.c
··· 8 8 #include <linux/export.h> 9 9 #include <linux/mm.h> 10 10 #include <linux/dma-direct.h> 11 + #include <linux/dma-map-ops.h> 11 12 #include <linux/scatterlist.h> 12 13 #include <linux/dma-contiguous.h> 13 14 #include <linux/pfn.h>
+1 -1
kernel/dma/dummy.c
··· 2 2 /* 3 3 * Dummy DMA ops that always fail. 4 4 */ 5 - #include <linux/dma-mapping.h> 5 + #include <linux/dma-map-ops.h> 6 6 7 7 static int dma_dummy_mmap(struct device *dev, struct vm_area_struct *vma, 8 8 void *cpu_addr, dma_addr_t dma_addr, size_t size,
+1 -1
kernel/dma/mapping.c
··· 8 8 #include <linux/memblock.h> /* for max_pfn */ 9 9 #include <linux/acpi.h> 10 10 #include <linux/dma-direct.h> 11 - #include <linux/dma-mapping.h> 11 + #include <linux/dma-map-ops.h> 12 12 #include <linux/export.h> 13 13 #include <linux/gfp.h> 14 14 #include <linux/of_device.h>
+1
kernel/dma/ops_helpers.c
··· 4 4 * the allocated memory contains normal pages in the direct kernel mapping. 5 5 */ 6 6 #include <linux/dma-contiguous.h> 7 + #include <linux/dma-map-ops.h> 7 8 #include <linux/dma-noncoherent.h> 8 9 9 10 /*
+1 -1
kernel/dma/virt.c
··· 4 4 */ 5 5 #include <linux/export.h> 6 6 #include <linux/mm.h> 7 - #include <linux/dma-mapping.h> 7 + #include <linux/dma-map-ops.h> 8 8 #include <linux/scatterlist.h> 9 9 10 10 static void *dma_virt_alloc(struct device *dev, size_t size,