PCI: remove pci_dac_dma_... APIs (caa51716) · Commits · 戴 / test

Documentation/DMA-mapping.txt

+0 −103

Original line number	Diff line number	Diff line
		@@ -664,109 +664,6 @@ It is that simple.
		Well, not for some odd devices. See the next section for information
		about that.

		DAC Addressing for Address Space Hungry Devices

		There exists a class of devices which do not mesh well with the PCI
		DMA mapping API. By definition these "mappings" are a finite
		resource. The number of total available mappings per bus is platform
		specific, but there will always be a reasonable amount.

		What is "reasonable"? Reasonable means that networking and block I/O
		devices need not worry about using too many mappings.

		As an example of a problematic device, consider compute cluster cards.
		They can potentially need to access gigabytes of memory at once via
		DMA. Dynamic mappings are unsuitable for this kind of access pattern.

		To this end we've provided a small API by which a device driver
		may use DAC cycles to directly address all of physical memory.
		Not all platforms support this, but most do. It is easy to determine
		whether the platform will work properly at probe time.

		First, understand that there may be a SEVERE performance penalty for
		using these interfaces on some platforms. Therefore, you MUST only
		use these interfaces if it is absolutely required. %99 of devices can
		use the normal APIs without any problems.

		Note that for streaming type mappings you must either use these
		interfaces, or the dynamic mapping interfaces above. You may not mix
		usage of both for the same device. Such an act is illegal and is
		guaranteed to put a banana in your tailpipe.

		However, consistent mappings may in fact be used in conjunction with
		these interfaces. Remember that, as defined, consistent mappings are
		always going to be SAC addressable.

		The first thing your driver needs to do is query the PCI platform
		layer if it is capable of handling your devices DAC addressing
		capabilities:

		int pci_dac_dma_supported(struct pci_dev *hwdev, u64 mask);

		You may not use the following interfaces if this routine fails.

		Next, DMA addresses using this API are kept track of using the
		dma64_addr_t type. It is guaranteed to be big enough to hold any
		DAC address the platform layer will give to you from the following
		routines. If you have consistent mappings as well, you still
		use plain dma_addr_t to keep track of those.

		All mappings obtained here will be direct. The mappings are not
		translated, and this is the purpose of this dialect of the DMA API.

		All routines work with page/offset pairs. This is the _ONLY_ way to
		portably refer to any piece of memory. If you have a cpu pointer
		(which may be validly DMA'd too) you may easily obtain the page
		and offset using something like this:

		struct page *page = virt_to_page(ptr);
		unsigned long offset = offset_in_page(ptr);

		Here are the interfaces:

		dma64_addr_t pci_dac_page_to_dma(struct pci_dev *pdev,
		struct page *page,
		unsigned long offset,
		int direction);

		The DAC address for the tuple PAGE/OFFSET are returned. The direction
		argument is the same as for pci_{map,unmap}_single(). The same rules
		for cpu/device access apply here as for the streaming mapping
		interfaces. To reiterate:

		The cpu may touch the buffer before pci_dac_page_to_dma.
		The device may touch the buffer after pci_dac_page_to_dma
		is made, but the cpu may NOT.

		When the DMA transfer is complete, invoke:

		void pci_dac_dma_sync_single_for_cpu(struct pci_dev *pdev,
		dma64_addr_t dma_addr,
		size_t len, int direction);

		This must be done before the CPU looks at the buffer again.
		This interface behaves identically to pci_dma_sync_{single,sg}_for_cpu().

		And likewise, if you wish to let the device get back at the buffer after
		the cpu has read/written it, invoke:

		void pci_dac_dma_sync_single_for_device(struct pci_dev *pdev,
		dma64_addr_t dma_addr,
		size_t len, int direction);

		before letting the device access the DMA area again.

		If you need to get back to the PAGE/OFFSET tuple from a dma64_addr_t
		the following interfaces are provided:

		struct page pci_dac_dma_to_page(struct pci_dev pdev,
		dma64_addr_t dma_addr);
		unsigned long pci_dac_dma_to_offset(struct pci_dev *pdev,
		dma64_addr_t dma_addr);

		This is possible with the DAC interfaces purely because they are
		not translated in any way.

		Optimizing Unmap State Space Consumption

		On many platforms, pci_unmap_{single,page}() is simply a nop.

arch/alpha/kernel/pci_iommu.c

+5 −27

Original line number	Diff line number	Diff line
		@@ -207,6 +207,10 @@ iommu_arena_free(struct pci_iommu_arena *arena, long ofs, long n)
		p[i] = 0;
		}

		/* True if the machine supports DAC addressing, and DEV can
		make use of it given MASK. */
		static int pci_dac_dma_supported(struct pci_dev *hwdev, u64 mask);

		/* Map a single buffer of the indicated size for PCI DMA in streaming
		mode. The 32-bit PCI bus mastering address to use is returned.
		Once the device is given the dma address, the device owns this memory
		@@ -897,7 +901,7 @@ iommu_unbind(struct pci_iommu_arena *arena, long pg_start, long pg_count)
		/* True if the machine supports DAC addressing, and DEV can
		make use of it given MASK. */

		int
		static int
		pci_dac_dma_supported(struct pci_dev *dev, u64 mask)
		{
		dma64_addr_t dac_offset = alpha_mv.pci_dac_offset;
		@@ -917,32 +921,6 @@ pci_dac_dma_supported(struct pci_dev *dev, u64 mask)

		return ok;
		}
		EXPORT_SYMBOL(pci_dac_dma_supported);

		dma64_addr_t
		pci_dac_page_to_dma(struct pci_dev pdev, struct page page,
		unsigned long offset, int direction)
		{
		return (alpha_mv.pci_dac_offset
		+ __pa(page_address(page))
		+ (dma64_addr_t) offset);
		}
		EXPORT_SYMBOL(pci_dac_page_to_dma);

		struct page *
		pci_dac_dma_to_page(struct pci_dev *pdev, dma64_addr_t dma_addr)
		{
		unsigned long paddr = (dma_addr & PAGE_MASK) - alpha_mv.pci_dac_offset;
		return virt_to_page(__va(paddr));
		}
		EXPORT_SYMBOL(pci_dac_dma_to_page);

		unsigned long
		pci_dac_dma_to_offset(struct pci_dev *pdev, dma64_addr_t dma_addr)
		{
		return (dma_addr & ~PAGE_MASK);
		}
		EXPORT_SYMBOL(pci_dac_dma_to_offset);

		/* Helper for generic DMA-mapping functions. */

arch/mips/pci/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -2,7 +2,7 @@
		# Makefile for the PCI specific kernel interface routines under Linux.
		#

		obj-y += pci.o pci-dac.o
		obj-y += pci.o

		#
		# PCI bus host bridge specific code

arch/mips/pci/pci-dac.c

deleted100644 → 0

+0 −79

Original line number	Diff line number	Diff line
		/*
		* This file is subject to the terms and conditions of the GNU General Public
		* License. See the file "COPYING" in the main directory of this archive
		* for more details.
		*
		* Copyright (C) 2000 Ani Joshi <ajoshi@unixbox.com>
		* Copyright (C) 2000, 2001, 06 Ralf Baechle <ralf@linux-mips.org>
		* swiped from i386, and cloned for MIPS by Geert, polished by Ralf.
		*/

		#include <linux/types.h>
		#include <linux/dma-mapping.h>
		#include <linux/mm.h>
		#include <linux/module.h>
		#include <linux/string.h>

		#include <asm/cache.h>
		#include <asm/io.h>

		#include <dma-coherence.h>

		#include <linux/pci.h>

		dma64_addr_t pci_dac_page_to_dma(struct pci_dev *pdev,
		struct page *page, unsigned long offset, int direction)
		{
		struct device *dev = &pdev->dev;

		BUG_ON(direction == DMA_NONE);

		if (!plat_device_is_coherent(dev)) {
		unsigned long addr;

		addr = (unsigned long) page_address(page) + offset;
		dma_cache_wback_inv(addr, PAGE_SIZE);
		}

		return plat_map_dma_mem_page(dev, page) + offset;
		}

		EXPORT_SYMBOL(pci_dac_page_to_dma);

		struct page pci_dac_dma_to_page(struct pci_dev pdev,
		dma64_addr_t dma_addr)
		{
		return pfn_to_page(plat_dma_addr_to_phys(dma_addr) >> PAGE_SHIFT);
		}

		EXPORT_SYMBOL(pci_dac_dma_to_page);

		unsigned long pci_dac_dma_to_offset(struct pci_dev *pdev,
		dma64_addr_t dma_addr)
		{
		return dma_addr & ~PAGE_MASK;
		}

		EXPORT_SYMBOL(pci_dac_dma_to_offset);

		void pci_dac_dma_sync_single_for_cpu(struct pci_dev *pdev,
		dma64_addr_t dma_addr, size_t len, int direction)
		{
		BUG_ON(direction == PCI_DMA_NONE);

		if (!plat_device_is_coherent(&pdev->dev))
		dma_cache_wback_inv(dma_addr + PAGE_OFFSET, len);
		}

		EXPORT_SYMBOL(pci_dac_dma_sync_single_for_cpu);

		void pci_dac_dma_sync_single_for_device(struct pci_dev *pdev,
		dma64_addr_t dma_addr, size_t len, int direction)
		{
		BUG_ON(direction == PCI_DMA_NONE);

		if (!plat_device_is_coherent(&pdev->dev))
		dma_cache_wback_inv(dma_addr + PAGE_OFFSET, len);
		}

		EXPORT_SYMBOL(pci_dac_dma_sync_single_for_device);

arch/x86_64/kernel/pci-dma.c

+1 −2

Original line number	Diff line number	Diff line
		@@ -22,8 +22,7 @@ EXPORT_SYMBOL(bad_dma_address);
		int iommu_bio_merge __read_mostly = 0;
		EXPORT_SYMBOL(iommu_bio_merge);

		int iommu_sac_force __read_mostly = 0;
		EXPORT_SYMBOL(iommu_sac_force);
		static int iommu_sac_force __read_mostly = 0;

		int no_iommu __read_mostly;
		#ifdef CONFIG_IOMMU_DEBUG

Admin message