Weekly Edition
Return to the Kernel pageRecent Features
| |||||||||||||
DMA: Fill gaping hole in DMA API interfaces.
ChangeSet 1.1614.1.14, 2004/03/14 09:05:37-08:00, akpm@osdl.org
[PATCH] DMA: Fill gaping hole in DMA API interfaces.
From: "David S. Miller" <davem@redhat.com>
Currently, for an existing DMA mapping, there is a way to transfer buffer
ownership back to the cpu, yet there is no way to give it back to the device
again explicitly. The latter really is needed on platforms where the PCI
subsystem does not snoop the cpu caches, MIPS is one example.
Many drivers were expecting the existing DMA sync interface to handle both
directions, which was wrong.
Now, with this change, we have explicit interfaces for DMA syncing to/from
the device and the cpu.
# This patch includes the following deltas:
# ChangeSet 1.1614.1.13 -> 1.1614.1.14
# drivers/net/3c59x.c 1.48 -> 1.49
# drivers/scsi/megaraid.c 1.60 -> 1.61
# arch/arm/common/sa1111-pcibuf.c 1.11 -> 1.12
# include/asm-alpha/pci.h 1.19 -> 1.20
# include/asm-arm/dma-mapping.h 1.8 -> 1.9
# drivers/net/irda/vlsi_ir.c 1.29 -> 1.30
# drivers/net/natsemi.c 1.57 -> 1.58
# drivers/net/myri_sbus.c 1.18 -> 1.19
# arch/sparc/kernel/sparc_ksyms.c 1.26 -> 1.27
# include/asm-ia64/machvec_hpzx1.h 1.7 -> 1.8
# drivers/net/lasi_82596.c 1.24 -> 1.25
# drivers/ieee1394/sbp2.c 1.64 -> 1.65
# arch/sparc64/kernel/pci_iommu.c 1.9 -> 1.10
# drivers/scsi/dc395x.c 1.31 -> 1.32
# drivers/net/sk98lin/skge.c 1.36 -> 1.37
# drivers/scsi/53c700.c 1.47 -> 1.47.1.1
# include/asm-sparc64/pci.h 1.18 -> 1.19
# include/asm-sparc/sbus.h 1.5 -> 1.6
# drivers/parisc/ccio-dma.c 1.15 -> 1.16
# include/asm-generic/pci-dma-compat.h 1.3 -> 1.4
# include/asm-sparc64/sbus.h 1.3 -> 1.4
# drivers/net/tulip/winbond-840.c 1.39 -> 1.40
# arch/mips/mm/dma-noncoherent.c 1.1 -> 1.2
# drivers/ieee1394/ieee1394_core.c 1.53 -> 1.54
# drivers/parisc/ccio-rm-dma.c 1.6 -> 1.7
# drivers/net/rrunner.c 1.24 -> 1.25
# drivers/net/tulip/interrupt.c 1.24 -> 1.25
# drivers/net/wan/dscc4.c 1.59 -> 1.60
# drivers/net/starfire.c 1.34 -> 1.35
# arch/v850/kernel/rte_mb_a_pci.c 1.8 -> 1.9
# drivers/net/pcnet32.c 1.51 -> 1.52
# arch/ia64/sn/io/machvec/pci_dma.c 1.26 -> 1.27
# drivers/scsi/ncr53c8xx.c 1.37 -> 1.38
# drivers/scsi/u14-34f.c 1.30 -> 1.31
# include/asm-v850/pci.h 1.4 -> 1.5
# drivers/net/sunhme.c 1.44 -> 1.45
# include/asm-ia64/machvec_sn2.h 1.11 -> 1.12
# drivers/net/yellowfin.c 1.28 -> 1.29
# include/asm-ppc64/pci.h 1.19 -> 1.20
# arch/mips/mm/dma-coherent.c 1.1 -> 1.2
# include/asm-parisc/dma-mapping.h 1.5 -> 1.6
# drivers/net/dl2k.c 1.31 -> 1.32
# include/asm-x86_64/pci.h 1.15 -> 1.16
# include/asm-i386/pci.h 1.26 -> 1.27
# drivers/net/b44.c 1.14 -> 1.15
# drivers/net/sis900.c 1.49 -> 1.50
# include/linux/usb.h 1.95 -> 1.96
# include/linux/usb_gadget.h 1.7 -> 1.8
# drivers/net/sunhme.h 1.6 -> 1.7
# drivers/net/e1000/e1000_ethtool.c 1.39 -> 1.40
# drivers/net/epic100.c 1.36 -> 1.37
# include/linux/pci.h 1.119 -> 1.120
# drivers/atm/idt77252.c 1.22 -> 1.23
# drivers/media/video/video-buf.c 1.15 -> 1.16
# drivers/message/fusion/mptlan.c 1.15 -> 1.16
# drivers/usb/core/usb.c 1.152 -> 1.153
# drivers/ieee1394/dma.c 1.7 -> 1.8
# Documentation/DMA-mapping.txt 1.17 -> 1.18
# drivers/atm/fore200e.h 1.1 -> 1.2
# drivers/net/sunbmac.c 1.21 -> 1.22
# include/asm-ia64/machvec.h 1.18 -> 1.19
# drivers/scsi/sym53c8xx_comm.h 1.15 -> 1.16
# drivers/net/tg3.c 1.125 -> 1.126
# drivers/net/sundance.c 1.53 -> 1.54
# include/net/irda/vlsi_ir.h 1.12 -> 1.13
# include/asm-mips/dma-mapping.h 1.4 -> 1.5
# drivers/message/i2o/i2o_core.c 1.23 -> 1.24
# drivers/net/typhoon.c 1.13 -> 1.14
# drivers/net/eepro100.c 1.71 -> 1.72
# include/asm-sh/pci.h 1.16 -> 1.17
# include/asm-mips/pci.h 1.16 -> 1.17
# drivers/net/fealnx.c 1.33 -> 1.34
# arch/mips/mm/dma-ip27.c 1.1 -> 1.2
# drivers/ieee1394/dv1394.c 1.40 -> 1.41
# include/asm-ia64/dma-mapping.h 1.2 -> 1.3
# include/asm-ppc/pci.h 1.24 -> 1.25
# arch/ia64/lib/swiotlb.c 1.16 -> 1.17
# include/asm-sparc/pci.h 1.13 -> 1.14
# drivers/parisc/sba_iommu.c 1.12 -> 1.13
# drivers/net/tokenring/olympic.c 1.28 -> 1.29
# drivers/net/tulip/de2104x.c 1.26 -> 1.27
# arch/sparc64/kernel/sparc64_ksyms.c 1.63 -> 1.64
# drivers/ieee1394/dma.h 1.4 -> 1.5
# drivers/ieee1394/ohci1394.c 1.59 -> 1.60
# include/linux/dma-mapping.h 1.1 -> 1.2
# drivers/scsi/eata.c 1.35 -> 1.36
# include/asm-generic/dma-mapping.h 1.4 -> 1.5
# include/asm-ia64/pci.h 1.24 -> 1.25
# arch/parisc/kernel/pci-dma.c 1.7 -> 1.8
# drivers/net/sungem.c 1.52 -> 1.53
# drivers/net/via-rhine.c 1.50 -> 1.51
# drivers/net/tokenring/3c359.c 1.18 -> 1.19
# arch/sparc/kernel/ioport.c 1.13 -> 1.14
# drivers/net/e100.c 1.9 -> 1.10
# drivers/atm/fore200e.c 1.23 -> 1.24
# drivers/net/hamachi.c 1.31 -> 1.32
# arch/sparc64/kernel/sbus.c 1.14 -> 1.15
# include/asm-i386/dma-mapping.h 1.2 -> 1.3
# drivers/net/sis190.c 1.18 -> 1.19
# drivers/scsi/sym53c8xx_2/sym_glue.c 1.40 -> 1.40.1.1
#
Documentation/DMA-mapping.txt | 56 ++++++++++++++---
arch/arm/common/sa1111-pcibuf.c | 50 ++++++++++++++--
arch/ia64/lib/swiotlb.c | 44 +++++++++++---
arch/ia64/sn/io/machvec/pci_dma.c | 56 ++++++++++++++---
arch/mips/mm/dma-coherent.c | 49 +++++++++++++--
arch/mips/mm/dma-ip27.c | 49 +++++++++++++--
arch/mips/mm/dma-noncoherent.c | 67 ++++++++++++++++++---
arch/parisc/kernel/pci-dma.c | 36 +++++++++--
arch/sparc/kernel/ioport.c | 69 +++++++++++++++++++---
arch/sparc/kernel/sparc_ksyms.c | 11 ++-
arch/sparc64/kernel/pci_iommu.c | 4 -
arch/sparc64/kernel/sbus.c | 12 +++
arch/sparc64/kernel/sparc64_ksyms.c | 8 +-
arch/v850/kernel/rte_mb_a_pci.c | 37 +++++++++--
drivers/atm/fore200e.c | 42 ++++++++++---
drivers/atm/fore200e.h | 3
drivers/atm/idt77252.c | 7 +-
drivers/ieee1394/dma.c | 18 +++++
drivers/ieee1394/dma.h | 6 +
drivers/ieee1394/dv1394.c | 8 +-
drivers/ieee1394/ieee1394_core.c | 3
drivers/ieee1394/ohci1394.c | 6 -
drivers/ieee1394/sbp2.c | 58 +++++++++---------
drivers/media/video/video-buf.c | 2
drivers/message/fusion/mptlan.c | 30 +++++++--
drivers/message/i2o/i2o_core.c | 2
drivers/net/3c59x.c | 3
drivers/net/b44.c | 10 ++-
drivers/net/dl2k.c | 10 ++-
drivers/net/e100.c | 13 +---
drivers/net/e1000/e1000_ethtool.c | 10 +--
drivers/net/eepro100.c | 39 +++++++-----
drivers/net/epic100.c | 10 ++-
drivers/net/fealnx.c | 22 +++++--
drivers/net/hamachi.c | 18 ++++-
drivers/net/irda/vlsi_ir.c | 19 ++----
drivers/net/lasi_82596.c | 3
drivers/net/myri_sbus.c | 14 +++-
drivers/net/natsemi.c | 6 +
drivers/net/pcnet32.c | 12 ++-
drivers/net/rrunner.c | 16 +++--
drivers/net/sis190.c | 10 ++-
drivers/net/sis900.c | 3
drivers/net/sk98lin/skge.c | 18 ++---
drivers/net/starfire.c | 9 +-
drivers/net/sunbmac.c | 8 +-
drivers/net/sundance.c | 12 ++-
drivers/net/sungem.c | 3
drivers/net/sunhme.c | 31 +++++++--
drivers/net/sunhme.h | 3
drivers/net/tg3.c | 3
drivers/net/tokenring/3c359.c | 6 +
drivers/net/tokenring/olympic.c | 10 ++-
drivers/net/tulip/de2104x.c | 4 -
drivers/net/tulip/interrupt.c | 18 +++--
drivers/net/tulip/winbond-840.c | 9 +-
drivers/net/typhoon.c | 8 +-
drivers/net/via-rhine.c | 4 -
drivers/net/wan/dscc4.c | 1
drivers/net/yellowfin.c | 5 +
drivers/parisc/ccio-dma.c | 6 +
drivers/parisc/ccio-rm-dma.c | 6 +
drivers/parisc/sba_iommu.c | 6 +
drivers/scsi/53c700.c | 8 +-
drivers/scsi/dc395x.c | 6 -
drivers/scsi/eata.c | 6 -
drivers/scsi/megaraid.c | 32 ----------
drivers/scsi/ncr53c8xx.c | 3
drivers/scsi/sym53c8xx_2/sym_glue.c | 32 ++++++++--
drivers/scsi/sym53c8xx_comm.h | 30 +++++++--
drivers/scsi/u14-34f.c | 6 -
drivers/usb/core/usb.c | 20 ++++++
include/asm-alpha/pci.h | 46 ++++++++++----
include/asm-arm/dma-mapping.h | 70 ++++++++++++++++------
include/asm-generic/dma-mapping.h | 49 ++++++++++++---
include/asm-generic/pci-dma-compat.h | 22 +++++--
include/asm-i386/dma-mapping.h | 32 ++++++++--
include/asm-i386/pci.h | 15 +++-
include/asm-ia64/dma-mapping.h | 12 ++-
include/asm-ia64/machvec.h | 44 +++++++++-----
include/asm-ia64/machvec_hpzx1.h | 6 +
include/asm-ia64/machvec_sn2.h | 12 ++-
include/asm-ia64/pci.h | 3
include/asm-mips/dma-mapping.h | 12 ++-
include/asm-mips/pci.h | 4 -
include/asm-parisc/dma-mapping.h | 53 ++++++++++++-----
include/asm-ppc/pci.h | 65 +++++++++++++++-----
include/asm-ppc64/pci.h | 28 +++++++-
include/asm-sh/pci.h | 39 ++++++++----
include/asm-sparc/pci.h | 15 ++--
include/asm-sparc/sbus.h | 8 +-
include/asm-sparc64/pci.h | 47 +++++++++++----
include/asm-sparc64/sbus.h | 8 +-
include/asm-v850/pci.h | 13 ++--
include/asm-x86_64/pci.h | 109 ++++++++++++++++++++++++++---------
include/linux/dma-mapping.h | 4 +
include/linux/pci.h | 4 +
include/linux/usb.h | 4 +
include/linux/usb_gadget.h | 2
include/net/irda/vlsi_ir.h | 13 ----
100 files changed, 1458 insertions(+), 545 deletions(-)
diff -Nru a/Documentation/DMA-mapping.txt b/Documentation/DMA-mapping.txt
--- a/Documentation/DMA-mapping.txt Sun Mar 14 10:11:22 2004
+++ b/Documentation/DMA-mapping.txt Sun Mar 14 10:11:22 2004
@@ -283,7 +283,7 @@
in order to get correct behavior on all platforms.
- Streaming DMA mappings which are usually mapped for one DMA transfer,
- unmapped right after it (unless you use pci_dma_sync below) and for which
+ unmapped right after it (unless you use pci_dma_sync_* below) and for which
hardware can optimize for sequential accesses.
This of "streaming" as "asynchronous" or "outside the coherency
@@ -543,14 +543,30 @@
all bus addresses.
If you need to use the same streaming DMA region multiple times and touch
-the data in between the DMA transfers, just map it with
-pci_map_{single,sg}, and after each DMA transfer call either:
+the data in between the DMA transfers, the buffer needs to be synced
+properly in order for the cpu and device to see the most uptodate and
+correct copy of the DMA buffer.
- pci_dma_sync_single(dev, dma_handle, size, direction);
+So, firstly, just map it with pci_map_{single,sg}, and after each DMA
+transfer call either:
+
+ pci_dma_sync_single_for_cpu(dev, dma_handle, size, direction);
or:
- pci_dma_sync_sg(dev, sglist, nents, direction);
+ pci_dma_sync_sg_for_cpu(dev, sglist, nents, direction);
+
+as appropriate.
+
+Then, if you wish to let the device get at the DMA area again,
+finish accessing the data with the cpu, and then before actually
+giving the buffer to the hardware call either:
+
+ pci_dma_sync_single_for_device(dev, dma_handle, size, direction);
+
+or:
+
+ pci_dma_sync_sg_for_device(dev, sglist, nents, direction);
as appropriate.
@@ -590,8 +606,9 @@
* the DMA transfer with the CPU first
* so that we see updated contents.
*/
- pci_dma_sync_single(cp->pdev, cp->rx_dma, cp->rx_len,
- PCI_DMA_FROMDEVICE);
+ pci_dma_sync_single_for_cpu(cp->pdev, cp->rx_dma,
+ cp->rx_len,
+ PCI_DMA_FROMDEVICE);
/* Now it is safe to examine the buffer. */
hp = (struct my_card_header *) cp->rx_buf;
@@ -601,7 +618,13 @@
pass_to_upper_layers(cp->rx_buf);
make_and_setup_new_rx_buf(cp);
} else {
- /* Just give the buffer back to the card. */
+ /* Just sync the buffer and give it back
+ * to the card.
+ */
+ pci_dma_sync_single_for_device(cp->pdev,
+ cp->rx_dma,
+ cp->rx_len,
+ PCI_DMA_FROMDEVICE);
give_rx_buf_to_card(cp);
}
}
@@ -709,12 +732,21 @@
When the DMA transfer is complete, invoke:
- void pci_dac_dma_sync_single(struct pci_dev *pdev,
- dma64_addr_t dma_addr,
- size_t len, int direction);
+ 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}().
+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:
diff -Nru a/arch/arm/common/sa1111-pcibuf.c b/arch/arm/common/sa1111-pcibuf.c
--- a/arch/arm/common/sa1111-pcibuf.c Sun Mar 14 10:11:16 2004
+++ b/arch/arm/common/sa1111-pcibuf.c Sun Mar 14 10:11:16 2004
@@ -457,8 +457,8 @@
local_irq_restore(flags);
}
-void sa1111_dma_sync_single(struct device *dev, dma_addr_t dma_addr,
- size_t size, enum dma_data_direction dir)
+void sa1111_dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_addr,
+ size_t size, enum dma_data_direction dir)
{
unsigned long flags;
@@ -472,8 +472,44 @@
local_irq_restore(flags);
}
-void sa1111_dma_sync_sg(struct device *dev, struct scatterlist *sg,
- int nents, enum dma_data_direction dir)
+void sa1111_dma_sync_single_for_device(struct device *dev, dma_addr_t dma_addr,
+ size_t size, enum dma_data_direction dir)
+{
+ unsigned long flags;
+
+ dev_dbg(dev, "%s(ptr=%08lx,size=%d,dir=%x)\n",
+ __func__, dma_addr, size, dir);
+
+ local_irq_save(flags);
+
+ sync_single(dev, dma_addr, size, dir);
+
+ local_irq_restore(flags);
+}
+
+void sa1111_dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
+ int nents, enum dma_data_direction dir)
+{
+ unsigned long flags;
+ int i;
+
+ dev_dbg(dev, "%s(sg=%p,nents=%d,dir=%x)\n",
+ __func__, sg, nents, dir);
+
+ local_irq_save(flags);
+
+ for (i = 0; i < nents; i++, sg++) {
+ dma_addr_t dma_addr = sg->dma_address;
+ unsigned int length = sg->length;
+
+ sync_single(dev, dma_addr, length, dir);
+ }
+
+ local_irq_restore(flags);
+}
+
+void sa1111_dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
+ int nents, enum dma_data_direction dir)
{
unsigned long flags;
int i;
@@ -497,8 +533,10 @@
EXPORT_SYMBOL(sa1111_unmap_single);
EXPORT_SYMBOL(sa1111_map_sg);
EXPORT_SYMBOL(sa1111_unmap_sg);
-EXPORT_SYMBOL(sa1111_dma_sync_single);
-EXPORT_SYMBOL(sa1111_dma_sync_sg);
+EXPORT_SYMBOL(sa1111_dma_sync_single_for_cpu);
+EXPORT_SYMBOL(sa1111_dma_sync_single_for_device);
+EXPORT_SYMBOL(sa1111_dma_sync_sg_for_cpu);
+EXPORT_SYMBOL(sa1111_dma_sync_sg_for_device);
/* **************************************** */
diff -Nru a/arch/ia64/lib/swiotlb.c b/arch/ia64/lib/swiotlb.c
--- a/arch/ia64/lib/swiotlb.c Sun Mar 14 10:11:23 2004
+++ b/arch/ia64/lib/swiotlb.c Sun Mar 14 10:11:23 2004
@@ -47,7 +47,7 @@
#define IO_TLB_SHIFT 11
/*
- * Used to do a quick range check in swiotlb_unmap_single and swiotlb_sync_single, to see
+ * Used to do a quick range check in swiotlb_unmap_single and swiotlb_sync_single_*, to see
* if the memory was in fact allocated by this API.
*/
static char *io_tlb_start, *io_tlb_end;
@@ -381,11 +381,24 @@
*
* If you perform a swiotlb_map_single() but wish to interrogate the buffer using the cpu,
* yet do not wish to teardown the PCI dma mapping, you must call this function before
- * doing so. At the next point you give the PCI dma address back to the card, the device
- * again owns the buffer.
+ * doing so. At the next point you give the PCI dma address back to the card, you must
+ * first perform a swiotlb_dma_sync_for_device, and then the device again owns the buffer
*/
void
-swiotlb_sync_single (struct device *hwdev, dma_addr_t dev_addr, size_t size, int dir)
+swiotlb_sync_single_for_cpu (struct device *hwdev, dma_addr_t dev_addr, size_t size, int dir)
+{
+ char *dma_addr = phys_to_virt(dev_addr);
+
+ if (dir == DMA_NONE)
+ BUG();
+ if (dma_addr >= io_tlb_start && dma_addr < io_tlb_end)
+ sync_single(hwdev, dma_addr, size, dir);
+ else if (dir == DMA_FROM_DEVICE)
+ mark_clean(dma_addr, size);
+}
+
+void
+swiotlb_sync_single_for_device (struct device *hwdev, dma_addr_t dev_addr, size_t size, int dir)
{
char *dma_addr = phys_to_virt(dev_addr);
@@ -456,11 +469,24 @@
* Make physical memory consistent for a set of streaming mode DMA translations after a
* transfer.
*
- * The same as swiotlb_dma_sync_single but for a scatter-gather list, same rules and
+ * The same as swiotlb_sync_single_* but for a scatter-gather list, same rules and
* usage.
*/
void
-swiotlb_sync_sg (struct device *hwdev, struct scatterlist *sg, int nelems, int dir)
+swiotlb_sync_sg_for_cpu (struct device *hwdev, struct scatterlist *sg, int nelems, int dir)
+{
+ int i;
+
+ if (dir == DMA_NONE)
+ BUG();
+
+ for (i = 0; i < nelems; i++, sg++)
+ if (sg->dma_address != SG_ENT_PHYS_ADDRESS(sg))
+ sync_single(hwdev, (void *) sg->dma_address, sg->dma_length, dir);
+}
+
+void
+swiotlb_sync_sg_for_device (struct device *hwdev, struct scatterlist *sg, int nelems, int dir)
{
int i;
@@ -488,8 +514,10 @@
EXPORT_SYMBOL(swiotlb_unmap_single);
EXPORT_SYMBOL(swiotlb_map_sg);
EXPORT_SYMBOL(swiotlb_unmap_sg);
-EXPORT_SYMBOL(swiotlb_sync_single);
-EXPORT_SYMBOL(swiotlb_sync_sg);
+EXPORT_SYMBOL(swiotlb_sync_single_for_cpu);
+EXPORT_SYMBOL(swiotlb_sync_single_for_device);
+EXPORT_SYMBOL(swiotlb_sync_sg_for_cpu);
+EXPORT_SYMBOL(swiotlb_sync_sg_for_device);
EXPORT_SYMBOL(swiotlb_alloc_coherent);
EXPORT_SYMBOL(swiotlb_free_coherent);
EXPORT_SYMBOL(swiotlb_dma_supported);
diff -Nru a/arch/ia64/sn/io/machvec/pci_dma.c b/arch/ia64/sn/io/machvec/pci_dma.c
--- a/arch/ia64/sn/io/machvec/pci_dma.c Sun Mar 14 10:11:18 2004
+++ b/arch/ia64/sn/io/machvec/pci_dma.c Sun Mar 14 10:11:18 2004
@@ -437,7 +437,8 @@
}
/**
- * sn_pci_dma_sync_single - make sure all DMAs have completed
+ * sn_pci_dma_sync_single_* - make sure all DMAs or CPU accesses
+ * have completed
* @hwdev: device to sync
* @dma_handle: DMA address to sync
* @size: size of region
@@ -448,14 +449,19 @@
* anything on our platform.
*/
void
-sn_pci_dma_sync_single(struct pci_dev *hwdev, dma_addr_t dma_handle, size_t size, int direction)
+sn_pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, dma_addr_t dma_handle, size_t size, int direction)
{
return;
+}
+void
+sn_pci_dma_sync_single_for_device(struct pci_dev *hwdev, dma_addr_t dma_handle, size_t size, int direction)
+{
+ return;
}
/**
- * sn_pci_dma_sync_sg - make sure all DMAs have completed
+ * sn_pci_dma_sync_sg_* - make sure all DMAs or CPU accesses have completed
* @hwdev: device to sync
* @sg: scatterlist to sync
* @nents: number of entries in the scatterlist
@@ -466,10 +472,15 @@
* on our platform.
*/
void
-sn_pci_dma_sync_sg(struct pci_dev *hwdev, struct scatterlist *sg, int nents, int direction)
+sn_pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, struct scatterlist *sg, int nents, int direction)
{
return;
+}
+void
+sn_pci_dma_sync_sg_for_device(struct pci_dev *hwdev, struct scatterlist *sg, int nents, int direction)
+{
+ return;
}
/**
@@ -602,28 +613,51 @@
EXPORT_SYMBOL(sn_dma_unmap_sg);
void
-sn_dma_sync_single(struct device *dev, dma_addr_t dma_handle, size_t size,
+sn_dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
+ int direction)
+{
+ BUG_ON(dev->bus != &pci_bus_type);
+
+ sn_pci_dma_sync_single_for_cpu(to_pci_dev(dev), dma_handle, size, (int)direction);
+}
+EXPORT_SYMBOL(sn_dma_sync_single_for_cpu);
+
+void
+sn_dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
int direction)
{
BUG_ON(dev->bus != &pci_bus_type);
- sn_pci_dma_sync_single(to_pci_dev(dev), dma_handle, size, (int)direction);
+ sn_pci_dma_sync_single_for_device(to_pci_dev(dev), dma_handle, size, (int)direction);
+}
+EXPORT_SYMBOL(sn_dma_sync_single_for_device);
+
+void
+sn_dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
+ int direction)
+{
+ BUG_ON(dev->bus != &pci_bus_type);
+
+ sn_pci_dma_sync_sg_for_cpu(to_pci_dev(dev), sg, nelems, (int)direction);
}
-EXPORT_SYMBOL(sn_dma_sync_single);
+EXPORT_SYMBOL(sn_dma_sync_sg_for_cpu);
void
-sn_dma_sync_sg(struct device *dev, struct scatterlist *sg, int nelems,
+sn_dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
int direction)
{
BUG_ON(dev->bus != &pci_bus_type);
- sn_pci_dma_sync_sg(to_pci_dev(dev), sg, nelems, (int)direction);
+ sn_pci_dma_sync_sg_for_device(to_pci_dev(dev), sg, nelems, (int)direction);
}
-EXPORT_SYMBOL(sn_dma_sync_sg);
+EXPORT_SYMBOL(sn_dma_sync_sg_for_device);
EXPORT_SYMBOL(sn_pci_unmap_single);
EXPORT_SYMBOL(sn_pci_map_single);
-EXPORT_SYMBOL(sn_pci_dma_sync_single);
+EXPORT_SYMBOL(sn_pci_dma_sync_single_for_cpu);
+EXPORT_SYMBOL(sn_pci_dma_sync_single_for_device);
+EXPORT_SYMBOL(sn_pci_dma_sync_sg_for_cpu);
+EXPORT_SYMBOL(sn_pci_dma_sync_sg_for_device);
EXPORT_SYMBOL(sn_pci_map_sg);
EXPORT_SYMBOL(sn_pci_unmap_sg);
EXPORT_SYMBOL(sn_pci_alloc_consistent);
diff -Nru a/arch/mips/mm/dma-coherent.c b/arch/mips/mm/dma-coherent.c
--- a/arch/mips/mm/dma-coherent.c Sun Mar 14 10:11:18 2004
+++ b/arch/mips/mm/dma-coherent.c Sun Mar 14 10:11:18 2004
@@ -119,30 +119,55 @@
EXPORT_SYMBOL(dma_unmap_sg);
-void dma_sync_single(struct device *dev, dma_addr_t dma_handle, size_t size,
+void dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
enum dma_data_direction direction)
{
BUG_ON(direction == DMA_NONE);
}
-EXPORT_SYMBOL(dma_sync_single);
+EXPORT_SYMBOL(dma_sync_single_for_cpu);
-void dma_sync_single_range(struct device *dev, dma_addr_t dma_handle,
+void dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
+ enum dma_data_direction direction)
+{
+ BUG_ON(direction == DMA_NONE);
+}
+
+EXPORT_SYMBOL(dma_sync_single_for_device);
+
+void dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle,
+ unsigned long offset, size_t size,
+ enum dma_data_direction direction)
+{
+ BUG_ON(direction == DMA_NONE);
+}
+
+EXPORT_SYMBOL(dma_sync_single_range_for_cpu);
+
+void dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle,
unsigned long offset, size_t size,
enum dma_data_direction direction)
{
BUG_ON(direction == DMA_NONE);
}
-EXPORT_SYMBOL(dma_sync_single_range);
+EXPORT_SYMBOL(dma_sync_single_range_for_device);
-void dma_sync_sg(struct device *dev, struct scatterlist *sg, int nelems,
+void dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
enum dma_data_direction direction)
{
BUG_ON(direction == DMA_NONE);
}
-EXPORT_SYMBOL(dma_sync_sg);
+EXPORT_SYMBOL(dma_sync_sg_for_cpu);
+
+void dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
+ enum dma_data_direction direction)
+{
+ BUG_ON(direction == DMA_NONE);
+}
+
+EXPORT_SYMBOL(dma_sync_sg_for_device);
int dma_supported(struct device *dev, u64 mask)
{
@@ -204,12 +229,20 @@
EXPORT_SYMBOL(pci_dac_dma_to_offset);
-void pci_dac_dma_sync_single(struct pci_dev *pdev,
+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);
+}
+
+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);
}
-EXPORT_SYMBOL(pci_dac_dma_sync_single);
+EXPORT_SYMBOL(pci_dac_dma_sync_single_for_device);
#endif /* CONFIG_PCI */
diff -Nru a/arch/mips/mm/dma-ip27.c b/arch/mips/mm/dma-ip27.c
--- a/arch/mips/mm/dma-ip27.c Sun Mar 14 10:11:23 2004
+++ b/arch/mips/mm/dma-ip27.c Sun Mar 14 10:11:23 2004
@@ -125,30 +125,55 @@
EXPORT_SYMBOL(dma_unmap_sg);
-void dma_sync_single(struct device *dev, dma_addr_t dma_handle, size_t size,
+void dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
enum dma_data_direction direction)
{
BUG_ON(direction == DMA_NONE);
}
-EXPORT_SYMBOL(dma_sync_single);
+EXPORT_SYMBOL(dma_sync_single_for_cpu);
-void dma_sync_single_range(struct device *dev, dma_addr_t dma_handle,
+void dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
+ enum dma_data_direction direction)
+{
+ BUG_ON(direction == DMA_NONE);
+}
+
+EXPORT_SYMBOL(dma_sync_single_for_device);
+
+void dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle,
+ unsigned long offset, size_t size,
+ enum dma_data_direction direction)
+{
+ BUG_ON(direction == DMA_NONE);
+}
+
+EXPORT_SYMBOL(dma_sync_single_range_for_cpu);
+
+void dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle,
unsigned long offset, size_t size,
enum dma_data_direction direction)
{
BUG_ON(direction == DMA_NONE);
}
-EXPORT_SYMBOL(dma_sync_single_range);
+EXPORT_SYMBOL(dma_sync_single_range_for_device);
-void dma_sync_sg(struct device *dev, struct scatterlist *sg, int nelems,
+void dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
enum dma_data_direction direction)
{
BUG_ON(direction == DMA_NONE);
}
-EXPORT_SYMBOL(dma_sync_sg);
+EXPORT_SYMBOL(dma_sync_sg_for_cpu);
+
+void dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
+ enum dma_data_direction direction)
+{
+ BUG_ON(direction == DMA_NONE);
+}
+
+EXPORT_SYMBOL(dma_sync_sg_for_device);
int dma_supported(struct device *dev, u64 mask)
{
@@ -208,10 +233,18 @@
EXPORT_SYMBOL(pci_dac_dma_to_offset);
-void pci_dac_dma_sync_single(struct pci_dev *pdev,
+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);
+}
+
+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);
}
-EXPORT_SYMBOL(pci_dac_dma_sync_single);
+EXPORT_SYMBOL(pci_dac_dma_sync_single_for_device);
diff -Nru a/arch/mips/mm/dma-noncoherent.c b/arch/mips/mm/dma-noncoherent.c
--- a/arch/mips/mm/dma-noncoherent.c Sun Mar 14 10:11:17 2004
+++ b/arch/mips/mm/dma-noncoherent.c Sun Mar 14 10:11:17 2004
@@ -226,7 +226,7 @@
EXPORT_SYMBOL(dma_unmap_sg);
-void dma_sync_single(struct device *dev, dma_addr_t dma_handle, size_t size,
+void dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
enum dma_data_direction direction)
{
unsigned long addr;
@@ -237,9 +237,35 @@
__dma_sync(addr, size, direction);
}
-EXPORT_SYMBOL(dma_sync_single);
+EXPORT_SYMBOL(dma_sync_single_for_cpu);
-void dma_sync_single_range(struct device *dev, dma_addr_t dma_handle,
+void dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
+ enum dma_data_direction direction)
+{
+ unsigned long addr;
+
+ BUG_ON(direction == DMA_NONE);
+
+ addr = dma_handle + PAGE_OFFSET;
+ __dma_sync(addr, size, direction);
+}
+
+EXPORT_SYMBOL(dma_sync_single_for_device);
+
+void dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle,
+ unsigned long offset, size_t size, enum dma_data_direction direction)
+{
+ unsigned long addr;
+
+ BUG_ON(direction == DMA_NONE);
+
+ addr = dma_handle + offset + PAGE_OFFSET;
+ __dma_sync(addr, size, direction);
+}
+
+EXPORT_SYMBOL(dma_sync_single_range_for_cpu);
+
+void dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle,
unsigned long offset, size_t size, enum dma_data_direction direction)
{
unsigned long addr;
@@ -250,9 +276,9 @@
__dma_sync(addr, size, direction);
}
-EXPORT_SYMBOL(dma_sync_single_range);
+EXPORT_SYMBOL(dma_sync_single_range_for_device);
-void dma_sync_sg(struct device *dev, struct scatterlist *sg, int nelems,
+void dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
enum dma_data_direction direction)
{
int i;
@@ -265,7 +291,22 @@
sg->length, direction);
}
-EXPORT_SYMBOL(dma_sync_sg);
+EXPORT_SYMBOL(dma_sync_sg_for_cpu);
+
+void dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
+ enum dma_data_direction direction)
+{
+ int i;
+
+ BUG_ON(direction == DMA_NONE);
+
+ /* Make sure that gcc doesn't leave the empty loop body. */
+ for (i = 0; i < nelems; i++, sg++)
+ __dma_sync((unsigned long)page_address(sg->page),
+ sg->length, direction);
+}
+
+EXPORT_SYMBOL(dma_sync_sg_for_device);
int dma_supported(struct device *dev, u64 mask)
{
@@ -329,7 +370,17 @@
EXPORT_SYMBOL(pci_dac_dma_to_offset);
-void pci_dac_dma_sync_single(struct pci_dev *pdev,
+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);
+
+ 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);
@@ -337,6 +388,6 @@
dma_cache_wback_inv(dma_addr + PAGE_OFFSET, len);
}
-EXPORT_SYMBOL(pci_dac_dma_sync_single);
+EXPORT_SYMBOL(pci_dac_dma_sync_single_for_device);
#endif /* CONFIG_PCI */
diff -Nru a/arch/parisc/kernel/pci-dma.c b/arch/parisc/kernel/pci-dma.c
--- a/arch/parisc/kernel/pci-dma.c Sun Mar 14 10:11:23 2004
+++ b/arch/parisc/kernel/pci-dma.c Sun Mar 14 10:11:23 2004
@@ -413,7 +413,7 @@
/*
* For PCI_DMA_FROMDEVICE this flush is not necessary for the
* simple map/unmap case. However, it IS necessary if if
- * pci_dma_sync_single has been called and the buffer reused.
+ * pci_dma_sync_single_* has been called and the buffer reused.
*/
flush_kernel_dcache_range((unsigned long) phys_to_virt(dma_handle), size);
@@ -453,7 +453,7 @@
return;
}
-static void pa11_dma_sync_single(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, enum dma_data_direction direction)
+static void pa11_dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, enum dma_data_direction direction)
{
if (direction == DMA_NONE)
BUG();
@@ -461,7 +461,25 @@
flush_kernel_dcache_range((unsigned long) phys_to_virt(dma_handle) + offset, size);
}
-static void pa11_dma_sync_sg(struct device *dev, struct scatterlist *sglist, int nents, enum dma_data_direction direction)
+static void pa11_dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, enum dma_data_direction direction)
+{
+ if (direction == DMA_NONE)
+ BUG();
+
+ flush_kernel_dcache_range((unsigned long) phys_to_virt(dma_handle) + offset, size);
+}
+
+static void pa11_dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sglist, int nents, enum dma_data_direction direction)
+{
+ int i;
+
+ /* once we do combining we'll need to use phys_to_virt(sg_dma_address(sglist)) */
+
+ for (i = 0; i < nents; i++, sglist++ )
+ flush_kernel_dcache_range(sg_virt_addr(sglist), sglist->length);
+}
+
+static void pa11_dma_sync_sg_for_device(struct device *dev, struct scatterlist *sglist, int nents, enum dma_data_direction direction)
{
int i;
@@ -480,8 +498,10 @@
.unmap_single = pa11_dma_unmap_single,
.map_sg = pa11_dma_map_sg,
.unmap_sg = pa11_dma_unmap_sg,
- .dma_sync_single = pa11_dma_sync_single,
- .dma_sync_sg = pa11_dma_sync_sg,
+ .dma_sync_single_for_cpu = pa11_dma_sync_single_for_cpu,
+ .dma_sync_single_for_device = pa11_dma_sync_single_for_device,
+ .dma_sync_sg_for_cpu = pa11_dma_sync_sg_for_cpu,
+ .dma_sync_sg_for_device = pa11_dma_sync_sg_for_device,
};
static void *fail_alloc_consistent(struct device *dev, size_t size,
@@ -519,8 +539,10 @@
.unmap_single = pa11_dma_unmap_single,
.map_sg = pa11_dma_map_sg,
.unmap_sg = pa11_dma_unmap_sg,
- .dma_sync_single = pa11_dma_sync_single,
- .dma_sync_sg = pa11_dma_sync_sg,
+ .dma_sync_single_cpu = pa11_dma_sync_single_cpu,
+ .dma_sync_single_device = pa11_dma_sync_single_device,
+ .dma_sync_sg_cpu = pa11_dma_sync_sg_cpu,
+ .dma_sync_sg_device = pa11_dma_sync_sg_device,
};
diff -Nru a/arch/sparc/kernel/ioport.c b/arch/sparc/kernel/ioport.c
--- a/arch/sparc/kernel/ioport.c Sun Mar 14 10:11:24 2004
+++ b/arch/sparc/kernel/ioport.c Sun Mar 14 10:11:24 2004
@@ -360,7 +360,7 @@
/*
*/
-void sbus_dma_sync_single(struct sbus_dev *sdev, dma_addr_t ba, size_t size, int direction)
+void sbus_dma_sync_single_for_cpu(struct sbus_dev *sdev, dma_addr_t ba, size_t size, int direction)
{
#if 0
unsigned long va;
@@ -380,9 +380,34 @@
#endif
}
-void sbus_dma_sync_sg(struct sbus_dev *sdev, struct scatterlist *sg, int n, int direction)
+void sbus_dma_sync_single_for_device(struct sbus_dev *sdev, dma_addr_t ba, size_t size, int direction)
{
- printk("sbus_dma_sync_sg: not implemented yet\n");
+#if 0
+ unsigned long va;
+ struct resource *res;
+
+ /* We do not need the resource, just print a message if invalid. */
+ res = _sparc_find_resource(&_sparc_dvma, ba);
+ if (res == NULL)
+ panic("sbus_dma_sync_single: 0x%x\n", ba);
+
+ va = page_address(mmu_translate_dvma(ba)); /* XXX higmem */
+ /*
+ * XXX This bogosity will be fixed with the iommu rewrite coming soon
+ * to a kernel near you. - Anton
+ */
+ /* mmu_inval_dma_area(va, (size + PAGE_SIZE-1) & PAGE_MASK); */
+#endif
+}
+
+void sbus_dma_sync_sg_for_cpu(struct sbus_dev *sdev, struct scatterlist *sg, int n, int direction)
+{
+ printk("sbus_dma_sync_sg_for_cpu: not implemented yet\n");
+}
+
+void sbus_dma_sync_sg_for_device(struct sbus_dev *sdev, struct scatterlist *sg, int n, int direction)
+{
+ printk("sbus_dma_sync_sg_for_device: not implemented yet\n");
}
#endif /* CONFIG_SBUS */
@@ -482,7 +507,7 @@
* The 32-bit bus address to use is returned.
*
* Once the device is given the dma address, the device owns this memory
- * until either pci_unmap_single or pci_dma_sync_single is performed.
+ * until either pci_unmap_single or pci_dma_sync_single_* is performed.
*/
dma_addr_t pci_map_single(struct pci_dev *hwdev, void *ptr, size_t size,
int direction)
@@ -591,10 +616,21 @@
* If you perform a pci_map_single() but wish to interrogate the
* buffer using the cpu, yet do not wish to teardown the PCI dma
* mapping, you must call this function before doing so. At the
- * next point you give the PCI dma address back to the card, the
+ * next point you give the PCI dma address back to the card, you
+ * must first perform a pci_dma_sync_for_device, and then the
* device again owns the buffer.
*/
-void pci_dma_sync_single(struct pci_dev *hwdev, dma_addr_t ba, size_t size, int direction)
+void pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, dma_addr_t ba, size_t size, int direction)
+{
+ if (direction == PCI_DMA_NONE)
+ BUG();
+ if (direction != PCI_DMA_TODEVICE) {
+ mmu_inval_dma_area((unsigned long)phys_to_virt(ba),
+ (size + PAGE_SIZE-1) & PAGE_MASK);
+ }
+}
+
+void pci_dma_sync_single_for_device(struct pci_dev *hwdev, dma_addr_t ba, size_t size, int direction)
{
if (direction == PCI_DMA_NONE)
BUG();
@@ -607,10 +643,27 @@
/* Make physical memory consistent for a set of streaming
* mode DMA translations after a transfer.
*
- * The same as pci_dma_sync_single but for a scatter-gather list,
+ * The same as pci_dma_sync_single_* but for a scatter-gather list,
* same rules and usage.
*/
-void pci_dma_sync_sg(struct pci_dev *hwdev, struct scatterlist *sg, int nents, int direction)
+void pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, struct scatterlist *sg, int nents, int direction)
+{
+ int n;
+
+ if (direction == PCI_DMA_NONE)
+ BUG();
+ if (direction != PCI_DMA_TODEVICE) {
+ for (n = 0; n < nents; n++) {
+ if (page_address(sg->page) == NULL) BUG();
+ mmu_inval_dma_area(
+ (unsigned long) page_address(sg->page),
+ (sg->length + PAGE_SIZE-1) & PAGE_MASK);
+ sg++;
+ }
+ }
+}
+
+void pci_dma_sync_sg_for_device(struct pci_dev *hwdev, struct scatterlist *sg, int nents, int direction)
{
int n;
diff -Nru a/arch/sparc/kernel/sparc_ksyms.c b/arch/sparc/kernel/sparc_ksyms.c
--- a/arch/sparc/kernel/sparc_ksyms.c Sun Mar 14 10:11:16 2004
+++ b/arch/sparc/kernel/sparc_ksyms.c Sun Mar 14 10:11:16 2004
@@ -205,8 +205,10 @@
EXPORT_SYMBOL(sbus_unmap_single);
EXPORT_SYMBOL(sbus_map_sg);
EXPORT_SYMBOL(sbus_unmap_sg);
-EXPORT_SYMBOL(sbus_dma_sync_single);
-EXPORT_SYMBOL(sbus_dma_sync_sg);
+EXPORT_SYMBOL(sbus_dma_sync_single_for_cpu);
+EXPORT_SYMBOL(sbus_dma_sync_single_for_device);
+EXPORT_SYMBOL(sbus_dma_sync_sg_for_cpu);
+EXPORT_SYMBOL(sbus_dma_sync_sg_for_device);
EXPORT_SYMBOL(sbus_iounmap);
EXPORT_SYMBOL(sbus_ioremap);
#endif
@@ -218,7 +220,10 @@
EXPORT_SYMBOL(pci_free_consistent);
EXPORT_SYMBOL(pci_map_single);
EXPORT_SYMBOL(pci_unmap_single);
-EXPORT_SYMBOL(pci_dma_sync_single);
+EXPORT_SYMBOL(pci_dma_sync_single_for_cpu);
+EXPORT_SYMBOL(pci_dma_sync_single_for_device);
+EXPORT_SYMBOL(pci_dma_sync_sg_for_cpu);
+EXPORT_SYMBOL(pci_dma_sync_sg_for_device);
/* Actually, ioremap/iounmap are not PCI specific. But it is ok for drivers. */
EXPORT_SYMBOL(ioremap);
EXPORT_SYMBOL(iounmap);
diff -Nru a/arch/sparc64/kernel/pci_iommu.c b/arch/sparc64/kernel/pci_iommu.c
--- a/arch/sparc64/kernel/pci_iommu.c Sun Mar 14 10:11:16 2004
+++ b/arch/sparc64/kernel/pci_iommu.c Sun Mar 14 10:11:16 2004
@@ -661,7 +661,7 @@
/* Make physical memory consistent for a single
* streaming mode DMA translation after a transfer.
*/
-void pci_dma_sync_single(struct pci_dev *pdev, dma_addr_t bus_addr, size_t sz, int direction)
+void pci_dma_sync_single_for_cpu(struct pci_dev *pdev, dma_addr_t bus_addr, size_t sz, int direction)
{
struct pcidev_cookie *pcp;
struct pci_iommu *iommu;
@@ -722,7 +722,7 @@
/* Make physical memory consistent for a set of streaming
* mode DMA translations after a transfer.
*/
-void pci_dma_sync_sg(struct pci_dev *pdev, struct scatterlist *sglist, int nelems, int direction)
+void pci_dma_sync_sg_for_cpu(struct pci_dev *pdev, struct scatterlist *sglist, int nelems, int direction)
{
struct pcidev_cookie *pcp;
struct pci_iommu *iommu;
diff -Nru a/arch/sparc64/kernel/sbus.c b/arch/sparc64/kernel/sbus.c
--- a/arch/sparc64/kernel/sbus.c Sun Mar 14 10:11:24 2004
+++ b/arch/sparc64/kernel/sbus.c Sun Mar 14 10:11:24 2004
@@ -540,7 +540,7 @@
spin_unlock_irqrestore(&iommu->lock, flags);
}
-void sbus_dma_sync_single(struct sbus_dev *sdev, dma_addr_t base, size_t size, int direction)
+void sbus_dma_sync_single_for_cpu(struct sbus_dev *sdev, dma_addr_t base, size_t size, int direction)
{
struct sbus_iommu *iommu = sdev->bus->iommu;
unsigned long flags;
@@ -552,7 +552,11 @@
spin_unlock_irqrestore(&iommu->lock, flags);
}
-void sbus_dma_sync_sg(struct sbus_dev *sdev, struct scatterlist *sg, int nents, int direction)
+void sbus_dma_sync_single_for_device(struct sbus_dev *sdev, dma_addr_t base, size_t size, int direction)
+{
+}
+
+void sbus_dma_sync_sg_for_cpu(struct sbus_dev *sdev, struct scatterlist *sg, int nents, int direction)
{
struct sbus_iommu *iommu = sdev->bus->iommu;
unsigned long flags, size;
@@ -570,6 +574,10 @@
spin_lock_irqsave(&iommu->lock, flags);
strbuf_flush(iommu, base, size >> IO_PAGE_SHIFT);
spin_unlock_irqrestore(&iommu->lock, flags);
+}
+
+void sbus_dma_sync_sg_for_device(struct sbus_dev *sdev, struct scatterlist *sg, int nents, int direction)
+{
}
/* Enable 64-bit DVMA mode for the given device. */
diff -Nru a/arch/sparc64/kernel/sparc64_ksyms.c b/arch/sparc64/kernel/sparc64_ksyms.c
--- a/arch/sparc64/kernel/sparc64_ksyms.c Sun Mar 14 10:11:23 2004
+++ b/arch/sparc64/kernel/sparc64_ksyms.c Sun Mar 14 10:11:23 2004
@@ -213,8 +213,8 @@
EXPORT_SYMBOL(sbus_unmap_single);
EXPORT_SYMBOL(sbus_map_sg);
EXPORT_SYMBOL(sbus_unmap_sg);
-EXPORT_SYMBOL(sbus_dma_sync_single);
-EXPORT_SYMBOL(sbus_dma_sync_sg);
+EXPORT_SYMBOL(sbus_dma_sync_single_for_cpu);
+EXPORT_SYMBOL(sbus_dma_sync_sg_for_cpu);
#endif
EXPORT_SYMBOL(outsb);
EXPORT_SYMBOL(outsw);
@@ -232,8 +232,8 @@
EXPORT_SYMBOL(pci_unmap_single);
EXPORT_SYMBOL(pci_map_sg);
EXPORT_SYMBOL(pci_unmap_sg);
-EXPORT_SYMBOL(pci_dma_sync_single);
-EXPORT_SYMBOL(pci_dma_sync_sg);
+EXPORT_SYMBOL(pci_dma_sync_single_for_cpu);
+EXPORT_SYMBOL(pci_dma_sync_sg_for_cpu);
EXPORT_SYMBOL(pci_dma_supported);
#endif
diff -Nru a/arch/v850/kernel/rte_mb_a_pci.c b/arch/v850/kernel/rte_mb_a_pci.c
--- a/arch/v850/kernel/rte_mb_a_pci.c Sun Mar 14 10:11:17 2004
+++ b/arch/v850/kernel/rte_mb_a_pci.c Sun Mar 14 10:11:17 2004
@@ -687,10 +687,11 @@
If you perform a pci_map_single() but wish to interrogate the
buffer using the cpu, yet do not wish to teardown the PCI dma
mapping, you must call this function before doing so. At the next
- point you give the PCI dma address back to the card, the device
- again owns the buffer. */
+ point you give the PCI dma address back to the card, you must first
+ perform a pci_dma_sync_for_device, and then the device again owns
+ the buffer. */
void
-pci_dma_sync_single (struct pci_dev *pdev, dma_addr_t dma_addr, size_t size,
+pci_dma_sync_single_for_cpu (struct pci_dev *pdev, dma_addr_t dma_addr, size_t size,
int dir)
{
void *mb_sram_addr = PCI_TO_MB_SRAM (dma_addr);
@@ -700,6 +701,22 @@
if (dir == PCI_DMA_FROMDEVICE)
memcpy (mapping->cpu_addr, mb_sram_addr, size);
else if (dir == PCI_DMA_TODEVICE)
+ ; /* nothing to do */
+ else
+ panic("pci_dma_sync_single: unsupported sync dir: %d", dir);
+}
+
+void
+pci_dma_sync_single_for_device (struct pci_dev *pdev, dma_addr_t dma_addr, size_t size,
+ int dir)
+{
+ void *mb_sram_addr = PCI_TO_MB_SRAM (dma_addr);
+ struct dma_mapping *mapping = find_dma_mapping (mb_sram_addr);
+
+ /* Synchronize the DMA buffer with the CPU buffer if necessary. */
+ if (dir == PCI_DMA_FROMDEVICE)
+ ; /* nothing to do */
+ else if (dir == PCI_DMA_TODEVICE)
memcpy (mb_sram_addr, mapping->cpu_addr, size);
else
panic("pci_dma_sync_single: unsupported sync dir: %d", dir);
@@ -724,11 +741,18 @@
}
/* Make physical memory consistent for a set of streaming mode DMA
- translations after a transfer. The same as pci_dma_sync_single but
+ translations after a transfer. The same as pci_dma_sync_single_* but
for a scatter-gather list, same rules and usage. */
void
-pci_dma_sync_sg (struct pci_dev *dev, struct scatterlist *sg, int sg_len,
+pci_dma_sync_sg_for_cpu (struct pci_dev *dev, struct scatterlist *sg, int sg_len,
+ int dir)
+{
+ BUG ();
+}
+
+void
+pci_dma_sync_sg_for_device (struct pci_dev *dev, struct scatterlist *sg, int sg_len,
int dir)
{
BUG ();
@@ -770,4 +794,5 @@
EXPORT_SYMBOL (pci_unmap_single);
EXPORT_SYMBOL (pci_alloc_consistent);
EXPORT_SYMBOL (pci_free_consistent);
-EXPORT_SYMBOL (pci_dma_sync_single);
+EXPORT_SYMBOL (pci_dma_sync_single_for_cpu);
+EXPORT_SYMBOL (pci_dma_sync_single_for_device);
diff -Nru a/drivers/atm/fore200e.c b/drivers/atm/fore200e.c
--- a/drivers/atm/fore200e.c Sun Mar 14 10:11:24 2004
+++ b/drivers/atm/fore200e.c Sun Mar 14 10:11:24 2004
@@ -482,11 +482,19 @@
static void
-fore200e_pca_dma_sync(struct fore200e* fore200e, u32 dma_addr, int size, int direction)
+fore200e_pca_dma_sync_for_cpu(struct fore200e* fore200e, u32 dma_addr, int size, int direction)
{
DPRINTK(3, "PCI DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction);
- pci_dma_sync_single((struct pci_dev*)fore200e->bus_dev, dma_addr, size, direction);
+ pci_dma_sync_single_for_cpu((struct pci_dev*)fore200e->bus_dev, dma_addr, size, direction);
+}
+
+static void
+fore200e_pca_dma_sync_for_device(struct fore200e* fore200e, u32 dma_addr, int size, int direction)
+{
+ DPRINTK(3, "PCI DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction);
+
+ pci_dma_sync_single_for_device((struct pci_dev*)fore200e->bus_dev, dma_addr, size, direction);
}
@@ -761,11 +769,19 @@
static void
-fore200e_sba_dma_sync(struct fore200e* fore200e, u32 dma_addr, int size, int direction)
+fore200e_sba_dma_sync_for_cpu(struct fore200e* fore200e, u32 dma_addr, int size, int direction)
{
DPRINTK(3, "SBUS DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction);
- sbus_dma_sync_single((struct sbus_dev*)fore200e->bus_dev, dma_addr, size, direction);
+ sbus_dma_sync_single_for_cpu((struct sbus_dev*)fore200e->bus_dev, dma_addr, size, direction);
+}
+
+static void
+fore200e_sba_dma_sync_for_device(struct fore200e* fore200e, u32 dma_addr, int size, int direction)
+{
+ DPRINTK(3, "SBUS DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction);
+
+ sbus_dma_sync_single_for_device((struct sbus_dev*)fore200e->bus_dev, dma_addr, size, direction);
}
@@ -1149,10 +1165,13 @@
/* rebuild rx buffer address from rsd handle */
buffer = FORE200E_HDL2BUF(rpd->rsd[ i ].handle);
- /* ensure DMA synchronisation */
- fore200e->bus->dma_sync(fore200e, buffer->data.dma_addr, rpd->rsd[ i ].length, FORE200E_DMA_FROMDEVICE);
+ /* Make device DMA transfer visible to CPU. */
+ fore200e->bus->dma_sync_for_cpu(fore200e, buffer->data.dma_addr, rpd->rsd[ i ].length, FORE200E_DMA_FROMDEVICE);
memcpy(skb_put(skb, rpd->rsd[ i ].length), buffer->data.align_addr, rpd->rsd[ i ].length);
+
+ /* Now let the device get at it again. */
+ fore200e->bus->dma_sync_for_device(fore200e, buffer->data.dma_addr, rpd->rsd[ i ].length, FORE200E_DMA_FROMDEVICE);
}
DPRINTK(3, "rx skb: len = %d, truesize = %d\n", skb->len, skb->truesize);
@@ -1584,8 +1603,9 @@
tasklet_enable(&fore200e->tasklet);
- /* ensure DMA synchronisation */
- fore200e->bus->dma_sync(fore200e, tpd->tsd[ 0 ].buffer, tpd->tsd[ 0 ].length, FORE200E_DMA_TODEVICE);
+ /* The dma_map call above implies a dma_sync so the device can use it,
+ * thus no explicit dma_sync call is necessary here.
+ */
DPRINTK(3, "tx on %d.%d.%d:%d, len = %u (%u)\n",
vcc->itf, vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal),
@@ -2918,7 +2938,8 @@
fore200e_pca_write,
fore200e_pca_dma_map,
fore200e_pca_dma_unmap,
- fore200e_pca_dma_sync,
+ fore200e_pca_dma_sync_for_cpu,
+ fore200e_pca_dma_sync_for_device,
fore200e_pca_dma_chunk_alloc,
fore200e_pca_dma_chunk_free,
fore200e_pca_detect,
@@ -2940,7 +2961,8 @@
fore200e_sba_write,
fore200e_sba_dma_map,
fore200e_sba_dma_unmap,
- fore200e_sba_dma_sync,
+ fore200e_sba_dma_sync_for_cpu,
+ fore200e_sba_dma_sync_for_device,
fore200e_sba_dma_chunk_alloc,
fore200e_sba_dma_chunk_free,
fore200e_sba_detect,
diff -Nru a/drivers/atm/fore200e.h b/drivers/atm/fore200e.h
--- a/drivers/atm/fore200e.h Sun Mar 14 10:11:22 2004
+++ b/drivers/atm/fore200e.h Sun Mar 14 10:11:22 2004
@@ -801,7 +801,8 @@
void (*write)(u32, volatile u32*);
u32 (*dma_map)(struct fore200e*, void*, int, int);
void (*dma_unmap)(struct fore200e*, u32, int, int);
- void (*dma_sync)(struct fore200e*, u32, int, int);
+ void (*dma_sync_for_cpu)(struct fore200e*, u32, int, int);
+ void (*dma_sync_for_device)(struct fore200e*, u32, int, int);
int (*dma_chunk_alloc)(struct fore200e*, struct chunk*, int, int, int);
void (*dma_chunk_free)(struct fore200e*, struct chunk*);
struct fore200e* (*detect)(const struct fore200e_bus*, int);
diff -Nru a/drivers/atm/idt77252.c b/drivers/atm/idt77252.c
--- a/drivers/atm/idt77252.c Sun Mar 14 10:11:21 2004
+++ b/drivers/atm/idt77252.c Sun Mar 14 10:11:21 2004
@@ -1064,8 +1064,8 @@
vcc = vc->rx_vcc;
- pci_dma_sync_single(card->pcidev, IDT77252_PRV_PADDR(skb),
- skb->end - skb->data, PCI_DMA_FROMDEVICE);
+ pci_dma_sync_single_for_cpu(card->pcidev, IDT77252_PRV_PADDR(skb),
+ skb->end - skb->data, PCI_DMA_FROMDEVICE);
if ((vcc->qos.aal == ATM_AAL0) ||
(vcc->qos.aal == ATM_AAL34)) {
@@ -1902,6 +1902,9 @@
{
u32 handle = IDT77252_PRV_POOL(skb);
int err;
+
+ pci_dma_sync_single_for_device(card->pcidev, IDT77252_PRV_PADDR(skb),
+ skb->end - skb->data, PCI_DMA_FROMDEVICE);
err = push_rx_skb(card, skb, POOL_QUEUE(handle));
if (err) {
diff -Nru a/drivers/ieee1394/dma.c b/drivers/ieee1394/dma.c
--- a/drivers/ieee1394/dma.c Sun Mar 14 10:11:22 2004
+++ b/drivers/ieee1394/dma.c Sun Mar 14 10:11:22 2004
@@ -168,7 +168,7 @@
return sg_dma_address(sg) + rem;
}
-void dma_region_sync(struct dma_region *dma, unsigned long offset, unsigned long len)
+void dma_region_sync_for_cpu(struct dma_region *dma, unsigned long offset, unsigned long len)
{
int first, last;
unsigned long rem;
@@ -179,7 +179,21 @@
first = dma_region_find(dma, offset, &rem);
last = dma_region_find(dma, offset + len - 1, &rem);
- pci_dma_sync_sg(dma->dev, &dma->sglist[first], last - first + 1, dma->direction);
+ pci_dma_sync_sg_for_cpu(dma->dev, &dma->sglist[first], last - first + 1, dma->direction);
+}
+
+void dma_region_sync_for_device(struct dma_region *dma, unsigned long offset, unsigned long len)
+{
+ int first, last;
+ unsigned long rem;
+
+ if (!len)
+ len = 1;
+
+ first = dma_region_find(dma, offset, &rem);
+ last = dma_region_find(dma, offset + len - 1, &rem);
+
+ pci_dma_sync_sg_for_device(dma->dev, &dma->sglist[first], last - first + 1, dma->direction);
}
/* nopage() handler for mmap access */
diff -Nru a/drivers/ieee1394/dma.h b/drivers/ieee1394/dma.h
--- a/drivers/ieee1394/dma.h Sun Mar 14 10:11:23 2004
+++ b/drivers/ieee1394/dma.h Sun Mar 14 10:11:23 2004
@@ -60,8 +60,10 @@
/* unmap and free the buffer */
void dma_region_free(struct dma_region *dma);
-/* sync the IO bus' view of the buffer with the CPU's view */
-void dma_region_sync(struct dma_region *dma, unsigned long offset, unsigned long len);
+/* sync the CPU's view of the buffer */
+void dma_region_sync_for_cpu(struct dma_region *dma, unsigned long offset, unsigned long len);
+/* sync the IO bus' view of the buffer */
+void dma_region_sync_for_device(struct dma_region *dma, unsigned long offset, unsigned long len);
/* map the buffer into a user space process */
int dma_region_mmap(struct dma_region *dma, struct file *file, struct vm_area_struct *vma);
diff -Nru a/drivers/ieee1394/dv1394.c b/drivers/ieee1394/dv1394.c
--- a/drivers/ieee1394/dv1394.c Sun Mar 14 10:11:23 2004
+++ b/drivers/ieee1394/dv1394.c Sun Mar 14 10:11:23 2004
@@ -553,7 +553,7 @@
*(f->frame_end_branch) = cpu_to_le32(f->descriptor_pool_dma | f->first_n_descriptors);
/* make the latest version of this frame visible to the PCI card */
- dma_region_sync(&video->dv_buf, f->data - (unsigned long) video->dv_buf.kvirt, video->frame_size);
+ dma_region_sync_for_device(&video->dv_buf, f->data - (unsigned long) video->dv_buf.kvirt, video->frame_size);
/* lock against DMA interrupt */
spin_lock_irqsave(&video->spinlock, irq_flags);
@@ -2033,9 +2033,9 @@
struct packet *p = dma_region_i(&video->packet_buf, struct packet, video->current_packet);
/* make sure we are seeing the latest changes to p */
- dma_region_sync(&video->packet_buf,
- (unsigned long) p - (unsigned long) video->packet_buf.kvirt,
- sizeof(struct packet));
+ dma_region_sync_for_cpu(&video->packet_buf,
+ (unsigned long) p - (unsigned long) video->packet_buf.kvirt,
+ sizeof(struct packet));
packet_length = le16_to_cpu(p->data_length);
packet_time = le16_to_cpu(p->timestamp);
diff -Nru a/drivers/ieee1394/ieee1394_core.c b/drivers/ieee1394/ieee1394_core.c
--- a/drivers/ieee1394/ieee1394_core.c Sun Mar 14 10:11:17 2004
+++ b/drivers/ieee1394/ieee1394_core.c Sun Mar 14 10:11:17 2004
@@ -1201,7 +1201,8 @@
EXPORT_SYMBOL(dma_region_init);
EXPORT_SYMBOL(dma_region_alloc);
EXPORT_SYMBOL(dma_region_free);
-EXPORT_SYMBOL(dma_region_sync);
+EXPORT_SYMBOL(dma_region_sync_for_cpu);
+EXPORT_SYMBOL(dma_region_sync_for_device);
EXPORT_SYMBOL(dma_region_mmap);
EXPORT_SYMBOL(dma_region_offset_to_bus);
diff -Nru a/drivers/ieee1394/ohci1394.c b/drivers/ieee1394/ohci1394.c
--- a/drivers/ieee1394/ohci1394.c Sun Mar 14 10:11:23 2004
+++ b/drivers/ieee1394/ohci1394.c Sun Mar 14 10:11:23 2004
@@ -1732,7 +1732,7 @@
/* OK, the block is finished... */
/* sync our view of the block */
- dma_region_sync(&iso->data_buf, recv->block_dma*recv->buf_stride, recv->buf_stride);
+ dma_region_sync_for_cpu(&iso->data_buf, recv->block_dma*recv->buf_stride, recv->buf_stride);
/* reset the DMA descriptor */
im->status = recv->buf_stride;
@@ -1789,7 +1789,7 @@
}
/* sync our view of the buffer */
- dma_region_sync(&iso->data_buf, iso->pkt_dma * recv->buf_stride, recv->buf_stride);
+ dma_region_sync_for_cpu(&iso->data_buf, iso->pkt_dma * recv->buf_stride, recv->buf_stride);
/* record the per-packet info */
{
@@ -2016,7 +2016,7 @@
sy = info->sy;
/* sync up the card's view of the buffer */
- dma_region_sync(&iso->data_buf, offset, len);
+ dma_region_sync_for_device(&iso->data_buf, offset, len);
/* append first_packet to the DMA chain */
/* by linking the previous descriptor to it */
diff -Nru a/drivers/ieee1394/sbp2.c b/drivers/ieee1394/sbp2.c
--- a/drivers/ieee1394/sbp2.c Sun Mar 14 10:11:16 2004
+++ b/drivers/ieee1394/sbp2.c Sun Mar 14 10:11:16 2004
@@ -1948,12 +1948,12 @@
SBP2_ORB_DEBUG("sending command orb %p, total orbs = %x",
command_orb, global_outstanding_command_orbs);
- pci_dma_sync_single(hi->host->pdev, command->command_orb_dma,
- sizeof(struct sbp2_command_orb),
- PCI_DMA_BIDIRECTIONAL);
- pci_dma_sync_single(hi->host->pdev, command->sge_dma,
- sizeof(command->scatter_gather_element),
- PCI_DMA_BIDIRECTIONAL);
+ pci_dma_sync_single_for_device(hi->host->pdev, command->command_orb_dma,
+ sizeof(struct sbp2_command_orb),
+ PCI_DMA_BIDIRECTIONAL);
+ pci_dma_sync_single_for_device(hi->host->pdev, command->sge_dma,
+ sizeof(command->scatter_gather_element),
+ PCI_DMA_BIDIRECTIONAL);
/*
* Check to see if there are any previous orbs to use
*/
@@ -1994,9 +1994,9 @@
cpu_to_be32(command->command_orb_dma);
/* Tells hardware that this pointer is valid */
scsi_id->last_orb->next_ORB_hi = 0x0;
- pci_dma_sync_single(hi->host->pdev, scsi_id->last_orb_dma,
- sizeof(struct sbp2_command_orb),
- PCI_DMA_BIDIRECTIONAL);
+ pci_dma_sync_single_for_device(hi->host->pdev, scsi_id->last_orb_dma,
+ sizeof(struct sbp2_command_orb),
+ PCI_DMA_BIDIRECTIONAL);
/*
* Ring the doorbell
@@ -2358,12 +2358,12 @@
if (command) {
SBP2_DEBUG("Found status for command ORB");
- pci_dma_sync_single(hi->host->pdev, command->command_orb_dma,
- sizeof(struct sbp2_command_orb),
- PCI_DMA_BIDIRECTIONAL);
- pci_dma_sync_single(hi->host->pdev, command->sge_dma,
- sizeof(command->scatter_gather_element),
- PCI_DMA_BIDIRECTIONAL);
+ pci_dma_sync_single_for_cpu(hi->host->pdev, command->command_orb_dma,
+ sizeof(struct sbp2_command_orb),
+ PCI_DMA_BIDIRECTIONAL);
+ pci_dma_sync_single_for_cpu(hi->host->pdev, command->sge_dma,
+ sizeof(command->scatter_gather_element),
+ PCI_DMA_BIDIRECTIONAL);
SBP2_ORB_DEBUG("matched command orb %p", &command->command_orb);
outstanding_orb_decr;
@@ -2534,12 +2534,12 @@
SBP2_DEBUG("Found pending command to complete");
lh = scsi_id->sbp2_command_orb_inuse.next;
command = list_entry(lh, struct sbp2_command_info, list);
- pci_dma_sync_single(hi->host->pdev, command->command_orb_dma,
- sizeof(struct sbp2_command_orb),
- PCI_DMA_BIDIRECTIONAL);
- pci_dma_sync_single(hi->host->pdev, command->sge_dma,
- sizeof(command->scatter_gather_element),
- PCI_DMA_BIDIRECTIONAL);
+ pci_dma_sync_single_for_cpu(hi->host->pdev, command->command_orb_dma,
+ sizeof(struct sbp2_command_orb),
+ PCI_DMA_BIDIRECTIONAL);
+ pci_dma_sync_single_for_cpu(hi->host->pdev, command->sge_dma,
+ sizeof(command->scatter_gather_element),
+ PCI_DMA_BIDIRECTIONAL);
sbp2util_mark_command_completed(scsi_id, command);
if (command->Current_SCpnt) {
void (*done)(Scsi_Cmnd *) = command->Current_done;
@@ -2699,14 +2699,14 @@
command = sbp2util_find_command_for_SCpnt(scsi_id, SCpnt);
if (command) {
SBP2_DEBUG("Found command to abort");
- pci_dma_sync_single(hi->host->pdev,
- command->command_orb_dma,
- sizeof(struct sbp2_command_orb),
- PCI_DMA_BIDIRECTIONAL);
- pci_dma_sync_single(hi->host->pdev,
- command->sge_dma,
- sizeof(command->scatter_gather_element),
- PCI_DMA_BIDIRECTIONAL);
+ pci_dma_sync_single_for_cpu(hi->host->pdev,
+ command->command_orb_dma,
+ sizeof(struct sbp2_command_orb),
+ PCI_DMA_BIDIRECTIONAL);
+ pci_dma_sync_single_for_cpu(hi->host->pdev,
+ command->sge_dma,
+ sizeof(command->scatter_gather_element),
+ PCI_DMA_BIDIRECTIONAL);
sbp2util_mark_command_completed(scsi_id, command);
if (command->Current_SCpnt) {
void (*done)(Scsi_Cmnd *) = command->Current_done;
diff -Nru a/drivers/media/video/video-buf.c b/drivers/media/video/video-buf.c
--- a/drivers/media/video/video-buf.c Sun Mar 14 10:11:21 2004
+++ b/drivers/media/video/video-buf.c Sun Mar 14 10:11:21 2004
@@ -215,7 +215,7 @@
BUG();
if (!dma->bus_addr)
- pci_dma_sync_sg(dev,dma->sglist,dma->nr_pages,dma->direction);
+ pci_dma_sync_sg_for_cpu(dev,dma->sglist,dma->nr_pages,dma->direction);
return 0;
}
diff -Nru a/drivers/message/fusion/mptlan.c b/drivers/message/fusion/mptlan.c
--- a/drivers/message/fusion/mptlan.c Sun Mar 14 10:11:21 2004
+++ b/drivers/message/fusion/mptlan.c Sun Mar 14 10:11:21 2004
@@ -958,11 +958,13 @@
return -ENOMEM;
}
- pci_dma_sync_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
- priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
+ pci_dma_sync_single_for_cpu(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
+ priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
memcpy(skb_put(skb, len), old_skb->data, len);
+ pci_dma_sync_single_for_device(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
+ priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
goto out;
}
@@ -1116,12 +1118,17 @@
// IOC_AND_NETDEV_NAMES_s_s(dev),
// i, l));
- pci_dma_sync_single(mpt_dev->pcidev,
- priv->RcvCtl[ctx].dma,
- priv->RcvCtl[ctx].len,
- PCI_DMA_FROMDEVICE);
+ pci_dma_sync_single_for_cpu(mpt_dev->pcidev,
+ priv->RcvCtl[ctx].dma,
+ priv->RcvCtl[ctx].len,
+ PCI_DMA_FROMDEVICE);
memcpy(skb_put(skb, l), old_skb->data, l);
+ pci_dma_sync_single_for_device(mpt_dev->pcidev,
+ priv->RcvCtl[ctx].dma,
+ priv->RcvCtl[ctx].len,
+ PCI_DMA_FROMDEVICE);
+
priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
szrem -= l;
}
@@ -1139,10 +1146,17 @@
return -ENOMEM;
}
- pci_dma_sync_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
- priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
+ pci_dma_sync_single_for_cpu(mpt_dev->pcidev,
+ priv->RcvCtl[ctx].dma,
+ priv->RcvCtl[ctx].len,
+ PCI_DMA_FROMDEVICE);
memcpy(skb_put(skb, len), old_skb->data, len);
+
+ pci_dma_sync_single_for_device(mpt_dev->pcidev,
+ priv->RcvCtl[ctx].dma,
+ priv->RcvCtl[ctx].len,
+ PCI_DMA_FROMDEVICE);
spin_lock_irqsave(&priv->rxfidx_lock, flags);
priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
diff -Nru a/drivers/message/i2o/i2o_core.c b/drivers/message/i2o/i2o_core.c
--- a/drivers/message/i2o/i2o_core.c Sun Mar 14 10:11:23 2004
+++ b/drivers/message/i2o/i2o_core.c Sun Mar 14 10:11:23 2004
@@ -1179,7 +1179,7 @@
* the processor
*/
- pci_dma_sync_single(c->pdev, c->page_frame_map, MSG_FRAME_SIZE, PCI_DMA_FROMDEVICE);
+ pci_dma_sync_single_for_cpu(c->pdev, c->page_frame_map, MSG_FRAME_SIZE, PCI_DMA_FROMDEVICE);
/*
* Despatch it
diff -Nru a/drivers/net/3c59x.c b/drivers/net/3c59x.c
--- a/drivers/net/3c59x.c Sun Mar 14 10:11:16 2004
+++ b/drivers/net/3c59x.c Sun Mar 14 10:11:16 2004
@@ -2577,11 +2577,12 @@
if (pkt_len < rx_copybreak && (skb = dev_alloc_skb(pkt_len + 2)) != 0) {
skb->dev = dev;
skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
- pci_dma_sync_single(VORTEX_PCI(vp), dma, PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
+ pci_dma_sync_single_for_cpu(VORTEX_PCI(vp), dma, PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
/* 'skb_put()' points to the start of sk_buff data area. */
memcpy(skb_put(skb, pkt_len),
vp->rx_skbuff[entry]->tail,
pkt_len);
+ pci_dma_sync_single_for_device(VORTEX_PCI(vp), dma, PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
vp->rx_copy++;
} else {
/* Pass up the skbuff already on the Rx ring. */
diff -Nru a/drivers/net/b44.c b/drivers/net/b44.c
--- a/drivers/net/b44.c Sun Mar 14 10:11:18 2004
+++ b/drivers/net/b44.c Sun Mar 14 10:11:18 2004
@@ -667,6 +667,10 @@
dest_desc->ctrl = ctrl;
dest_desc->addr = src_desc->addr;
src_map->skb = NULL;
+
+ pci_dma_sync_single_for_device(bp->pdev, src_desc->addr,
+ RX_PKT_BUF_SZ,
+ PCI_DMA_FROMDEVICE);
}
static int b44_rx(struct b44 *bp, int budget)
@@ -686,9 +690,9 @@
struct rx_header *rh;
u16 len;
- pci_dma_sync_single(bp->pdev, map,
- RX_PKT_BUF_SZ,
- PCI_DMA_FROMDEVICE);
+ pci_dma_sync_single_for_cpu(bp->pdev, map,
+ RX_PKT_BUF_SZ,
+ PCI_DMA_FROMDEVICE);
rh = (struct rx_header *) skb->data;
len = cpu_to_le16(rh->len);
if ((len > (RX_PKT_BUF_SZ - bp->rx_offset)) ||
diff -Nru a/drivers/net/dl2k.c b/drivers/net/dl2k.c
--- a/drivers/net/dl2k.c Sun Mar 14 10:11:18 2004
+++ b/drivers/net/dl2k.c Sun Mar 14 10:11:18 2004
@@ -874,8 +874,6 @@
frame_status = le64_to_cpu (desc->status);
if (--cnt < 0)
break;
- pci_dma_sync_single (np->pdev, desc->fraginfo, np->rx_buf_sz,
- PCI_DMA_FROMDEVICE);
/* Update rx error statistics, drop packet. */
if (frame_status & RFS_Errors) {
np->stats.rx_errors++;
@@ -898,6 +896,10 @@
skb_put (skb = np->rx_skbuff[entry], pkt_len);
np->rx_skbuff[entry] = NULL;
} else if ((skb = dev_alloc_skb (pkt_len + 2)) != NULL) {
+ pci_dma_sync_single_for_cpu(np->pdev,
+ desc->fraginfo,
+ np->rx_buf_sz,
+ PCI_DMA_FROMDEVICE);
skb->dev = dev;
/* 16 byte align the IP header */
skb_reserve (skb, 2);
@@ -905,6 +907,10 @@
np->rx_skbuff[entry]->tail,
pkt_len, 0);
skb_put (skb, pkt_len);
+ pci_dma_sync_single_for_device(np->pdev,
+ desc->fraginfo,
+ np->rx_buf_sz,
+ PCI_DMA_FROMDEVICE);
}
skb->protocol = eth_type_trans (skb, dev);
#if 0
diff -Nru a/drivers/net/e100.c b/drivers/net/e100.c
--- a/drivers/net/e100.c Sun Mar 14 10:11:24 2004
+++ b/drivers/net/e100.c Sun Mar 14 10:11:24 2004
@@ -1389,8 +1389,8 @@
(u32 *)&prev_rfd->link);
wmb();
prev_rfd->command &= ~cpu_to_le16(cb_el);
- pci_dma_sync_single(nic->pdev, rx->prev->dma_addr,
- sizeof(struct rfd), PCI_DMA_TODEVICE);
+ pci_dma_sync_single_for_device(nic->pdev, rx->prev->dma_addr,
+ sizeof(struct rfd), PCI_DMA_TODEVICE);
}
return 0;
@@ -1407,8 +1407,8 @@
return -EAGAIN;
/* Need to sync before taking a peek at cb_complete bit */
- pci_dma_sync_single(nic->pdev, rx->dma_addr,
- sizeof(struct rfd), PCI_DMA_FROMDEVICE);
+ pci_dma_sync_single_for_cpu(nic->pdev, rx->dma_addr,
+ sizeof(struct rfd), PCI_DMA_FROMDEVICE);
rfd_status = le16_to_cpu(rfd->status);
DPRINTK(RX_STATUS, DEBUG, "status=0x%04X\n", rfd_status);
@@ -1423,11 +1423,8 @@
actual_size = RFD_BUF_LEN - sizeof(struct rfd);
/* Get data */
- pci_dma_sync_single(nic->pdev, rx->dma_addr,
- sizeof(struct rfd) + actual_size,
- PCI_DMA_FROMDEVICE);
pci_unmap_single(nic->pdev, rx->dma_addr,
- RFD_BUF_LEN, PCI_DMA_FROMDEVICE);
+ RFD_BUF_LEN, PCI_DMA_FROMDEVICE);
/* Pull off the RFD and put the actual data (minus eth hdr) */
skb_reserve(skb, sizeof(struct rfd));
diff -Nru a/drivers/net/e1000/e1000_ethtool.c b/drivers/net/e1000/e1000_ethtool.c
--- a/drivers/net/e1000/e1000_ethtool.c Sun Mar 14 10:11:21 2004
+++ b/drivers/net/e1000/e1000_ethtool.c Sun Mar 14 10:11:21 2004
@@ -1191,16 +1191,16 @@
for(i = 0; i < 64; i++) {
e1000_create_lbtest_frame(txdr->buffer_info[i].skb, 1024);
- pci_dma_sync_single(pdev, txdr->buffer_info[i].dma,
- txdr->buffer_info[i].length,
- PCI_DMA_TODEVICE);
+ pci_dma_sync_single_for_device(pdev, txdr->buffer_info[i].dma,
+ txdr->buffer_info[i].length,
+ PCI_DMA_TODEVICE);
}
E1000_WRITE_REG(&adapter->hw, TDT, i);
msec_delay(200);
- pci_dma_sync_single(pdev, rxdr->buffer_info[0].dma,
- rxdr->buffer_info[0].length, PCI_DMA_FROMDEVICE);
+ pci_dma_sync_single_for_cpu(pdev, rxdr->buffer_info[0].dma,
+ rxdr->buffer_info[0].length, PCI_DMA_FROMDEVICE);
return e1000_check_lbtest_frame(rxdr->buffer_info[0].skb, 1024);
}
diff -Nru a/drivers/net/eepro100.c b/drivers/net/eepro100.c
--- a/drivers/net/eepro100.c Sun Mar 14 10:11:23 2004
+++ b/drivers/net/eepro100.c Sun Mar 14 10:11:23 2004
@@ -1326,8 +1326,8 @@
skb_reserve(skb, sizeof(struct RxFD));
if (last_rxf) {
last_rxf->link = cpu_to_le32(sp->rx_ring_dma[i]);
- pci_dma_sync_single(sp->pdev, last_rxf_dma,
- sizeof(struct RxFD), PCI_DMA_TODEVICE);
+ pci_dma_sync_single_for_device(sp->pdev, last_rxf_dma,
+ sizeof(struct RxFD), PCI_DMA_TODEVICE);
}
last_rxf = rxf;
last_rxf_dma = sp->rx_ring_dma[i];
@@ -1336,14 +1336,14 @@
/* This field unused by i82557. */
rxf->rx_buf_addr = 0xffffffff;
rxf->count = cpu_to_le32(PKT_BUF_SZ << 16);
- pci_dma_sync_single(sp->pdev, sp->rx_ring_dma[i],
- sizeof(struct RxFD), PCI_DMA_TODEVICE);
+ pci_dma_sync_single_for_device(sp->pdev, sp->rx_ring_dma[i],
+ sizeof(struct RxFD), PCI_DMA_TODEVICE);
}
sp->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
/* Mark the last entry as end-of-list. */
last_rxf->status = cpu_to_le32(0xC0000002); /* '2' is flag value only. */
- pci_dma_sync_single(sp->pdev, sp->rx_ring_dma[RX_RING_SIZE-1],
- sizeof(struct RxFD), PCI_DMA_TODEVICE);
+ pci_dma_sync_single_for_device(sp->pdev, sp->rx_ring_dma[RX_RING_SIZE-1],
+ sizeof(struct RxFD), PCI_DMA_TODEVICE);
sp->last_rxf = last_rxf;
sp->last_rxf_dma = last_rxf_dma;
}
@@ -1716,8 +1716,8 @@
skb->dev = dev;
skb_reserve(skb, sizeof(struct RxFD));
rxf->rx_buf_addr = 0xffffffff;
- pci_dma_sync_single(sp->pdev, sp->rx_ring_dma[entry],
- sizeof(struct RxFD), PCI_DMA_TODEVICE);
+ pci_dma_sync_single_for_device(sp->pdev, sp->rx_ring_dma[entry],
+ sizeof(struct RxFD), PCI_DMA_TODEVICE);
return rxf;
}
@@ -1730,8 +1730,8 @@
rxf->count = cpu_to_le32(PKT_BUF_SZ << 16);
sp->last_rxf->link = cpu_to_le32(rxf_dma);
sp->last_rxf->status &= cpu_to_le32(~0xC0000000);
- pci_dma_sync_single(sp->pdev, sp->last_rxf_dma,
- sizeof(struct RxFD), PCI_DMA_TODEVICE);
+ pci_dma_sync_single_for_device(sp->pdev, sp->last_rxf_dma,
+ sizeof(struct RxFD), PCI_DMA_TODEVICE);
sp->last_rxf = rxf;
sp->last_rxf_dma = rxf_dma;
}
@@ -1803,8 +1803,8 @@
int status;
int pkt_len;
- pci_dma_sync_single(sp->pdev, sp->rx_ring_dma[entry],
- sizeof(struct RxFD), PCI_DMA_FROMDEVICE);
+ pci_dma_sync_single_for_cpu(sp->pdev, sp->rx_ring_dma[entry],
+ sizeof(struct RxFD), PCI_DMA_FROMDEVICE);
status = le32_to_cpu(sp->rx_ringp[entry]->status);
pkt_len = le32_to_cpu(sp->rx_ringp[entry]->count) & 0x3fff;
@@ -1850,8 +1850,9 @@
skb->dev = dev;
skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
/* 'skb_put()' points to the start of sk_buff data area. */
- pci_dma_sync_single(sp->pdev, sp->rx_ring_dma[entry],
- sizeof(struct RxFD) + pkt_len, PCI_DMA_FROMDEVICE);
+ pci_dma_sync_single_for_cpu(sp->pdev, sp->rx_ring_dma[entry],
+ sizeof(struct RxFD) + pkt_len,
+ PCI_DMA_FROMDEVICE);
#if 1 || USE_IP_CSUM
/* Packet is in one chunk -- we can copy + cksum. */
@@ -1861,6 +1862,9 @@
memcpy(skb_put(skb, pkt_len), sp->rx_skbuff[entry]->tail,
pkt_len);
#endif
+ pci_dma_sync_single_for_device(sp->pdev, sp->rx_ring_dma[entry],
+ sizeof(struct RxFD) + pkt_len,
+ PCI_DMA_FROMDEVICE);
npkts++;
} else {
/* Pass up the already-filled skbuff. */
@@ -1875,7 +1879,8 @@
npkts++;
sp->rx_ringp[entry] = NULL;
pci_unmap_single(sp->pdev, sp->rx_ring_dma[entry],
- PKT_BUF_SZ + sizeof(struct RxFD), PCI_DMA_FROMDEVICE);
+ PKT_BUF_SZ + sizeof(struct RxFD),
+ PCI_DMA_FROMDEVICE);
}
skb->protocol = eth_type_trans(skb, dev);
netif_rx(skb);
@@ -2307,8 +2312,8 @@
mc_setup_frm->link =
cpu_to_le32(TX_RING_ELEM_DMA(sp, (entry + 1) % TX_RING_SIZE));
- pci_dma_sync_single(sp->pdev, mc_blk->frame_dma,
- mc_blk->len, PCI_DMA_TODEVICE);
+ pci_dma_sync_single_for_device(sp->pdev, mc_blk->frame_dma,
+ mc_blk->len, PCI_DMA_TODEVICE);
wait_for_cmd_done(dev);
clear_suspend(last_cmd);
diff -Nru a/drivers/net/epic100.c b/drivers/net/epic100.c
--- a/drivers/net/epic100.c Sun Mar 14 10:11:21 2004
+++ b/drivers/net/epic100.c Sun Mar 14 10:11:21 2004
@@ -1199,8 +1199,6 @@
short pkt_len = (status >> 16) - 4;
struct sk_buff *skb;
- pci_dma_sync_single(ep->pci_dev, ep->rx_ring[entry].bufaddr,
- ep->rx_buf_sz, PCI_DMA_FROMDEVICE);
if (pkt_len > PKT_BUF_SZ - 4) {
printk(KERN_ERR "%s: Oversized Ethernet frame, status %x "
"%d bytes.\n",
@@ -1213,6 +1211,10 @@
&& (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
skb->dev = dev;
skb_reserve(skb, 2); /* 16 byte align the IP header */
+ pci_dma_sync_single_for_cpu(ep->pci_dev,
+ ep->rx_ring[entry].bufaddr,
+ ep->rx_buf_sz,
+ PCI_DMA_FROMDEVICE);
#if 1 /* HAS_IP_COPYSUM */
eth_copy_and_sum(skb, ep->rx_skbuff[entry]->tail, pkt_len, 0);
skb_put(skb, pkt_len);
@@ -1220,6 +1222,10 @@
memcpy(skb_put(skb, pkt_len), ep->rx_skbuff[entry]->tail,
pkt_len);
#endif
+ pci_dma_sync_single_for_device(ep->pci_dev,
+ ep->rx_ring[entry].bufaddr,
+ ep->rx_buf_sz,
+ PCI_DMA_FROMDEVICE);
} else {
pci_unmap_single(ep->pci_dev,
ep->rx_ring[entry].bufaddr,
diff -Nru a/drivers/net/fealnx.c b/drivers/net/fealnx.c
--- a/drivers/net/fealnx.c Sun Mar 14 10:11:23 2004
+++ b/drivers/net/fealnx.c Sun Mar 14 10:11:23 2004
@@ -1647,10 +1647,6 @@
printk(KERN_DEBUG " netdev_rx() normal Rx pkt length %d"
" status %x.\n", pkt_len, rx_status);
#endif
- pci_dma_sync_single(np->pci_dev, np->cur_rx->buffer,
- np->rx_buf_sz, PCI_DMA_FROMDEVICE);
- pci_unmap_single(np->pci_dev, np->cur_rx->buffer,
- np->rx_buf_sz, PCI_DMA_FROMDEVICE);
/* Check if the packet is long enough to accept without copying
to a minimally-sized skbuff. */
@@ -1658,6 +1654,10 @@
(skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
skb->dev = dev;
skb_reserve(skb, 2); /* 16 byte align the IP header */
+ pci_dma_sync_single_for_cpu(np->pci_dev,
+ np->cur_rx->buffer,
+ np->rx_buf_sz,
+ PCI_DMA_FROMDEVICE);
/* Call copy + cksum if available. */
#if ! defined(__alpha__)
@@ -1668,7 +1668,15 @@
memcpy(skb_put(skb, pkt_len),
np->cur_rx->skbuff->tail, pkt_len);
#endif
+ pci_dma_sync_single_for_device(np->pci_dev,
+ np->cur_rx->buffer,
+ np->rx_buf_sz,
+ PCI_DMA_FROMDEVICE);
} else {
+ pci_unmap_single(np->pci_dev,
+ np->cur_rx->buffer,
+ np->rx_buf_sz,
+ PCI_DMA_FROMDEVICE);
skb_put(skb = np->cur_rx->skbuff, pkt_len);
np->cur_rx->skbuff = NULL;
if (np->really_rx_count == RX_RING_SIZE)
@@ -1689,8 +1697,10 @@
if (skb != NULL) {
skb->dev = dev; /* Mark as being used by this device. */
- np->cur_rx->buffer = pci_map_single(np->pci_dev, skb->tail,
- np->rx_buf_sz, PCI_DMA_FROMDEVICE);
+ np->cur_rx->buffer = pci_map_single(np->pci_dev,
+ skb->tail,
+ np->rx_buf_sz,
+ PCI_DMA_FROMDEVICE);
np->cur_rx->skbuff = skb;
++np->really_rx_count;
}
diff -Nru a/drivers/net/hamachi.c b/drivers/net/hamachi.c
--- a/drivers/net/hamachi.c Sun Mar 14 10:11:24 2004
+++ b/drivers/net/hamachi.c Sun Mar 14 10:11:24 2004
@@ -1498,8 +1498,10 @@
if (desc_status & DescOwn)
break;
- pci_dma_sync_single(hmp->pci_dev, desc->addr, hmp->rx_buf_sz,
- PCI_DMA_FROMDEVICE);
+ pci_dma_sync_single_for_cpu(hmp->pci_dev,
+ desc->addr,
+ hmp->rx_buf_sz,
+ PCI_DMA_FROMDEVICE);
buf_addr = desc_to_virt(desc->addr);
frame_status = le32_to_cpu(get_unaligned((s32*)&(buf_addr[data_size - 12])));
if (hamachi_debug > 4)
@@ -1563,6 +1565,10 @@
#endif
skb->dev = dev;
skb_reserve(skb, 2); /* 16 byte align the IP header */
+ pci_dma_sync_single_for_cpu(hmp->pci_dev,
+ hmp->rx_ring[entry].addr,
+ hmp->rx_buf_sz,
+ PCI_DMA_FROMDEVICE);
/* Call copy + cksum if available. */
#if 1 || USE_IP_COPYSUM
eth_copy_and_sum(skb,
@@ -1572,10 +1578,14 @@
memcpy(skb_put(skb, pkt_len), hmp->rx_ring_dma
+ entry*sizeof(*desc), pkt_len);
#endif
+ pci_dma_sync_single_for_device(hmp->pci_dev,
+ hmp->rx_ring[entry].addr,
+ hmp->rx_buf_sz,
+ PCI_DMA_FROMDEVICE);
} else {
pci_unmap_single(hmp->pci_dev,
- hmp->rx_ring[entry].addr,
- hmp->rx_buf_sz, PCI_DMA_FROMDEVICE);
+ hmp->rx_ring[entry].addr,
+ hmp->rx_buf_sz, PCI_DMA_FROMDEVICE);
skb_put(skb = hmp->rx_skbuff[entry], pkt_len);
hmp->rx_skbuff[entry] = NULL;
}
diff -Nru a/drivers/net/irda/vlsi_ir.c b/drivers/net/irda/vlsi_ir.c
--- a/drivers/net/irda/vlsi_ir.c Sun Mar 14 10:11:16 2004
+++ b/drivers/net/irda/vlsi_ir.c Sun Mar 14 10:11:16 2004
@@ -173,7 +173,7 @@
PCIDEV_NAME(pdev), (int)pdev->vendor, (int)pdev->device);
out += sprintf(out, "pci-power-state: %u\n", (unsigned) pdev->current_state);
out += sprintf(out, "resources: irq=%u / io=0x%04x / dma_mask=0x%016Lx\n",
- pdev->irq, (unsigned)pci_resource_start(pdev, 0), (u64)pdev->dma_mask);
+ pdev->irq, (unsigned)pci_resource_start(pdev, 0), (unsigned long long)pdev->dma_mask);
out += sprintf(out, "hw registers: ");
for (i = 0; i < 0x20; i++)
out += sprintf(out, "%02x", (unsigned)inb((iobase+i)));
@@ -566,7 +566,6 @@
return NULL;
}
rd_set_addr_status(rd, busaddr, 0);
- pci_dma_sync_single(pdev, busaddr, len, dir);
/* initially, the dma buffer is owned by the CPU */
rd->skb = NULL;
}
@@ -660,7 +659,7 @@
struct net_device *ndev = (struct net_device *)pci_get_drvdata(r->pdev);
vlsi_irda_dev_t *idev = ndev->priv;
- pci_dma_sync_single(r->pdev, rd_get_addr(rd), r->len, r->dir);
+ pci_dma_sync_single_for_cpu(r->pdev, rd_get_addr(rd), r->len, r->dir);
/* dma buffer now owned by the CPU */
status = rd_get_status(rd);
if (status & RD_RX_ERROR) {
@@ -746,7 +745,7 @@
break; /* probably not worth logging? */
}
/* give dma buffer back to busmaster */
- pci_dma_prep_single(r->pdev, rd_get_addr(rd), r->len, r->dir);
+ pci_dma_sync_single_for_device(r->pdev, rd_get_addr(rd), r->len, r->dir);
rd_activate(rd);
}
}
@@ -816,7 +815,7 @@
ret = -VLSI_RX_DROP;
}
rd_set_count(rd, 0);
- pci_dma_sync_single(r->pdev, rd_get_addr(rd), r->len, r->dir);
+ pci_dma_sync_single_for_cpu(r->pdev, rd_get_addr(rd), r->len, r->dir);
if (rd->skb) {
dev_kfree_skb_any(rd->skb);
rd->skb = NULL;
@@ -854,7 +853,7 @@
int len;
int ret;
- pci_dma_sync_single(r->pdev, rd_get_addr(rd), r->len, r->dir);
+ pci_dma_sync_single_for_cpu(r->pdev, rd_get_addr(rd), r->len, r->dir);
/* dma buffer now owned by the CPU */
status = rd_get_status(rd);
if (status & RD_TX_UNDRN)
@@ -1077,8 +1076,8 @@
}
}
- /* tx buffer already owned by CPU due to pci_dma_sync_single() either
- * after initial pci_map_single or after subsequent tx-completion
+ /* tx buffer already owned by CPU due to pci_dma_sync_single_for_cpu()
+ * after subsequent tx-completion
*/
if (idev->mode == IFF_SIR) {
@@ -1120,7 +1119,7 @@
* CPU-driven changes visible from the pci bus).
*/
- pci_dma_prep_single(r->pdev, rd_get_addr(rd), r->len, r->dir);
+ pci_dma_sync_single_for_device(r->pdev, rd_get_addr(rd), r->len, r->dir);
/* Switching to TX mode here races with the controller
* which may stop TX at any time when fetching an inactive descriptor
@@ -1248,7 +1247,7 @@
if (rd_is_active(rd)) {
rd_set_status(rd, 0);
rd_set_count(rd, 0);
- pci_dma_sync_single(r->pdev, rd_get_addr(rd), r->len, r->dir);
+ pci_dma_sync_single_for_cpu(r->pdev, rd_get_addr(rd), r->len, r->dir);
if (rd->skb) {
dev_kfree_skb_any(rd->skb);
rd->skb = NULL;
diff -Nru a/drivers/net/lasi_82596.c b/drivers/net/lasi_82596.c
--- a/drivers/net/lasi_82596.c Sun Mar 14 10:11:16 2004
+++ b/drivers/net/lasi_82596.c Sun Mar 14 10:11:16 2004
@@ -802,9 +802,10 @@
skb->dev = dev;
if (!rx_in_place) {
/* 16 byte align the data fields */
- dma_sync_single(lp->dev, (dma_addr_t)WSWAPchar(rbd->b_data), PKT_BUF_SZ, DMA_FROM_DEVICE);
+ dma_sync_single_for_cpu(lp->dev, (dma_addr_t)WSWAPchar(rbd->b_data), PKT_BUF_SZ, DMA_FROM_DEVICE);
skb_reserve(skb, 2);
memcpy(skb_put(skb,pkt_len), rbd->v_data, pkt_len);
+ dma_sync_single_for_device(lp->dev, (dma_addr_t)WSWAPchar(rbd->b_data), PKT_BUF_SZ, DMA_FROM_DEVICE);
}
skb->len = pkt_len;
skb->protocol=eth_type_trans(skb,dev);
diff -Nru a/drivers/net/myri_sbus.c b/drivers/net/myri_sbus.c
--- a/drivers/net/myri_sbus.c Sun Mar 14 10:11:16 2004
+++ b/drivers/net/myri_sbus.c Sun Mar 14 10:11:16 2004
@@ -435,9 +435,9 @@
/* Check for errors. */
DRX(("rxd[%d]: %p len[%d] csum[%08x] ", entry, rxd, len, csum));
- sbus_dma_sync_single(mp->myri_sdev,
- sbus_readl(&rxd->myri_scatters[0].addr),
- RX_ALLOC_SIZE, SBUS_DMA_FROMDEVICE);
+ sbus_dma_sync_single_for_cpu(mp->myri_sdev,
+ sbus_readl(&rxd->myri_scatters[0].addr),
+ RX_ALLOC_SIZE, SBUS_DMA_FROMDEVICE);
if (len < (ETH_HLEN + MYRI_PAD_LEN) || (skb->data[0] != MYRI_PAD_LEN)) {
DRX(("ERROR["));
mp->enet_stats.rx_errors++;
@@ -454,6 +454,10 @@
drops++;
DRX(("DROP "));
mp->enet_stats.rx_dropped++;
+ sbus_dma_sync_single_for_device(mp->myri_sdev,
+ sbus_readl(&rxd->myri_scatters[0].addr),
+ RX_ALLOC_SIZE,
+ SBUS_DMA_FROMDEVICE);
sbus_writel(RX_ALLOC_SIZE, &rxd->myri_scatters[0].len);
sbus_writel(index, &rxd->ctx);
sbus_writel(1, &rxd->num_sg);
@@ -508,6 +512,10 @@
/* Reuse original ring buffer. */
DRX(("reuse "));
+ sbus_dma_sync_single_for_device(mp->myri_sdev,
+ sbus_readl(&rxd->myri_scatters[0].addr),
+ RX_ALLOC_SIZE,
+ SBUS_DMA_FROMDEVICE);
sbus_writel(RX_ALLOC_SIZE, &rxd->myri_scatters[0].len);
sbus_writel(index, &rxd->ctx);
sbus_writel(1, &rxd->num_sg);
diff -Nru a/drivers/net/natsemi.c b/drivers/net/natsemi.c
--- a/drivers/net/natsemi.c Sun Mar 14 10:11:16 2004
+++ b/drivers/net/natsemi.c Sun Mar 14 10:11:16 2004
@@ -1789,7 +1789,7 @@
skb->dev = dev;
/* 16 byte align the IP header */
skb_reserve(skb, 2);
- pci_dma_sync_single(np->pci_dev,
+ pci_dma_sync_single_for_cpu(np->pci_dev,
np->rx_dma[entry],
np->rx_skbuff[entry]->len,
PCI_DMA_FROMDEVICE);
@@ -1801,6 +1801,10 @@
memcpy(skb_put(skb, pkt_len),
np->rx_skbuff[entry]->tail, pkt_len);
#endif
+ pci_dma_sync_single_for_device(np->pci_dev,
+ np->rx_dma[entry],
+ np->rx_skbuff[entry]->len,
+ PCI_DMA_FROMDEVICE);
} else {
pci_unmap_single(np->pci_dev, np->rx_dma[entry],
np->rx_skbuff[entry]->len,
diff -Nru a/drivers/net/pcnet32.c b/drivers/net/pcnet32.c
--- a/drivers/net/pcnet32.c Sun Mar 14 10:11:18 2004
+++ b/drivers/net/pcnet32.c Sun Mar 14 10:11:18 2004
@@ -1747,13 +1747,17 @@
if (!rx_in_place) {
skb_reserve(skb,2); /* 16 byte align */
skb_put(skb,pkt_len); /* Make room */
- pci_dma_sync_single(lp->pci_dev,
- lp->rx_dma_addr[entry],
- PKT_BUF_SZ-2,
- PCI_DMA_FROMDEVICE);
+ pci_dma_sync_single_for_cpu(lp->pci_dev,
+ lp->rx_dma_addr[entry],
+ PKT_BUF_SZ-2,
+ PCI_DMA_FROMDEVICE);
eth_copy_and_sum(skb,
(unsigned char *)(lp->rx_skbuff[entry]->tail),
pkt_len,0);
+ pci_dma_sync_single_for_device(lp->pci_dev,
+ lp->rx_dma_addr[entry],
+ PKT_BUF_SZ-2,
+ PCI_DMA_FROMDEVICE);
}
lp->stats.rx_bytes += skb->len;
skb->protocol=eth_type_trans(skb,dev);
diff -Nru a/drivers/net/rrunner.c b/drivers/net/rrunner.c
--- a/drivers/net/rrunner.c Sun Mar 14 10:11:17 2004
+++ b/drivers/net/rrunner.c Sun Mar 14 10:11:17 2004
@@ -983,18 +983,26 @@
rx_skb = rrpriv->rx_skbuff[index];
- pci_dma_sync_single(rrpriv->pci_dev, desc->addr.addrlo,
- pkt_len, PCI_DMA_FROMDEVICE);
-
if (pkt_len < PKT_COPY_THRESHOLD) {
skb = alloc_skb(pkt_len, GFP_ATOMIC);
if (skb == NULL){
printk(KERN_WARNING "%s: Unable to allocate skb (%i bytes), deferring packet\n", dev->name, pkt_len);
rrpriv->stats.rx_dropped++;
goto defer;
- }else
+ } else {
+ pci_dma_sync_single_for_cpu(rrpriv->pci_dev,
+ desc->addr.addrlo,
+ pkt_len,
+ PCI_DMA_FROMDEVICE);
+
memcpy(skb_put(skb, pkt_len),
rx_skb->data, pkt_len);
+
+ pci_dma_sync_single_for_device(rrpriv->pci_dev,
+ desc->addr.addrlo,
+ pkt_len,
+ PCI_DMA_FROMDEVICE);
+ }
}else{
struct sk_buff *newskb;
diff -Nru a/drivers/net/sis190.c b/drivers/net/sis190.c
--- a/drivers/net/sis190.c Sun Mar 14 10:11:24 2004
+++ b/drivers/net/sis190.c Sun Mar 14 10:11:24 2004
@@ -1016,14 +1016,20 @@
int pkt_size;
pkt_size = (int) (desc->PSize & 0x0000FFFF) - 4;
- pci_dma_sync_single(tp->pci_dev, desc->buf_addr,
- RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
skb = dev_alloc_skb(pkt_size + 2);
if (skb != NULL) {
skb->dev = dev;
skb_reserve(skb, 2); // 16 byte align the IP fields. //
+ pci_dma_sync_single_for_cpu(tp->pci_dev,
+ desc->buf_addr,
+ RX_BUF_SIZE,
+ PCI_DMA_FROMDEVICE);
eth_copy_and_sum(skb, tp->RxBufferRing[cur_rx],
pkt_size, 0);
+ pci_dma_sync_single_for_device(tp->pci_dev,
+ desc->buf_addr,
+ RX_BUF_SIZE,
+ PCI_DMA_FROMDEVICE);
skb_put(skb, pkt_size);
skb->protocol = eth_type_trans(skb, dev);
netif_rx(skb);
diff -Nru a/drivers/net/sis900.c b/drivers/net/sis900.c
--- a/drivers/net/sis900.c Sun Mar 14 10:11:19 2004
+++ b/drivers/net/sis900.c Sun Mar 14 10:11:19 2004
@@ -1650,9 +1650,6 @@
break;
}
- pci_dma_sync_single(sis_priv->pci_dev,
- sis_priv->rx_ring[entry].bufptr, RX_BUF_SIZE,
- PCI_DMA_FROMDEVICE);
pci_unmap_single(sis_priv->pci_dev,
sis_priv->rx_ring[entry].bufptr, RX_BUF_SIZE,
PCI_DMA_FROMDEVICE);
diff -Nru a/drivers/net/sk98lin/skge.c b/drivers/net/sk98lin/skge.c
--- a/drivers/net/sk98lin/skge.c Sun Mar 14 10:11:17 2004
+++ b/drivers/net/sk98lin/skge.c Sun Mar 14 10:11:17 2004
@@ -2533,12 +2533,6 @@
"Control: %x\nRxStat: %x\n",
Control, FrameStat));
- PhysAddr = ((SK_U64) pRxd->VDataHigh) << (SK_U64)32;
- PhysAddr |= (SK_U64) pRxd->VDataLow;
- pci_dma_sync_single(pAC->PciDev,
- (dma_addr_t) PhysAddr,
- FrameLength,
- PCI_DMA_FROMDEVICE);
ReQueueRxBuffer(pAC, pRxPort, pMsg,
pRxd->VDataHigh, pRxd->VDataLow);
@@ -2559,12 +2553,16 @@
PhysAddr = ((SK_U64) pRxd->VDataHigh) << (SK_U64)32;
PhysAddr |= (SK_U64) pRxd->VDataLow;
- pci_dma_sync_single(pAC->PciDev,
- (dma_addr_t) PhysAddr,
- FrameLength,
- PCI_DMA_FROMDEVICE);
+ pci_dma_sync_single_for_cpu(pAC->PciDev,
+ (dma_addr_t) PhysAddr,
+ FrameLength,
+ PCI_DMA_FROMDEVICE);
eth_copy_and_sum(pNewMsg, pMsg->data,
FrameLength, 0);
+ pci_dma_sync_single_for_device(pAC->PciDev,
+ (dma_addr_t) PhysAddr,
+ FrameLength,
+ PCI_DMA_FROMDEVICE);
ReQueueRxBuffer(pAC, pRxPort, pMsg,
pRxd->VDataHigh, pRxd->VDataLow);
diff -Nru a/drivers/net/starfire.c b/drivers/net/starfire.c
--- a/drivers/net/starfire.c Sun Mar 14 10:11:17 2004
+++ b/drivers/net/starfire.c Sun Mar 14 10:11:17 2004
@@ -1637,10 +1637,13 @@
&& (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
skb->dev = dev;
skb_reserve(skb, 2); /* 16 byte align the IP header */
- pci_dma_sync_single(np->pci_dev,
- np->rx_info[entry].mapping,
- pkt_len, PCI_DMA_FROMDEVICE);
+ pci_dma_sync_single_for_cpu(np->pci_dev,
+ np->rx_info[entry].mapping,
+ pkt_len, PCI_DMA_FROMDEVICE);
eth_copy_and_sum(skb, np->rx_info[entry].skb->tail, pkt_len, 0);
+ pci_dma_sync_single_for_device(np->pci_dev,
+ np->rx_info[entry].mapping,
+ pkt_len, PCI_DMA_FROMDEVICE);
skb_put(skb, pkt_len);
} else {
pci_unmap_single(np->pci_dev, np->rx_info[entry].mapping, np->rx_buf_sz, PCI_DMA_FROMDEVICE);
diff -Nru a/drivers/net/sunbmac.c b/drivers/net/sunbmac.c
--- a/drivers/net/sunbmac.c Sun Mar 14 10:11:22 2004
+++ b/drivers/net/sunbmac.c Sun Mar 14 10:11:22 2004
@@ -849,9 +849,13 @@
copy_skb->dev = bp->dev;
skb_reserve(copy_skb, 2);
skb_put(copy_skb, len);
- sbus_dma_sync_single(bp->bigmac_sdev,
- this->rx_addr, len, SBUS_DMA_FROMDEVICE);
+ sbus_dma_sync_single_for_cpu(bp->bigmac_sdev,
+ this->rx_addr, len,
+ SBUS_DMA_FROMDEVICE);
eth_copy_and_sum(copy_skb, (unsigned char *)skb->data, len, 0);
+ sbus_dma_sync_single_for_device(bp->bigmac_sdev,
+ this->rx_addr, len,
+ SBUS_DMA_FROMDEVICE);
/* Reuse original ring buffer. */
this->rx_flags =
diff -Nru a/drivers/net/sundance.c b/drivers/net/sundance.c
--- a/drivers/net/sundance.c Sun Mar 14 10:11:22 2004
+++ b/drivers/net/sundance.c Sun Mar 14 10:11:22 2004
@@ -1331,9 +1331,6 @@
if (netif_msg_rx_status(np))
printk(KERN_DEBUG " netdev_rx() status was %8.8x.\n",
frame_status);
- pci_dma_sync_single(np->pci_dev, desc->frag[0].addr,
- np->rx_buf_sz, PCI_DMA_FROMDEVICE);
-
if (frame_status & 0x001f4000) {
/* There was a error. */
if (netif_msg_rx_err(np))
@@ -1363,7 +1360,16 @@
&& (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
skb->dev = dev;
skb_reserve(skb, 2); /* 16 byte align the IP header */
+ pci_dma_sync_single_for_cpu(np->pci_dev,
+ desc->frag[0].addr,
+ np->rx_buf_sz,
+ PCI_DMA_FROMDEVICE);
+
eth_copy_and_sum(skb, np->rx_skbuff[entry]->tail, pkt_len, 0);
+ pci_dma_sync_single_for_device(np->pci_dev,
+ desc->frag[0].addr,
+ np->rx_buf_sz,
+ PCI_DMA_FROMDEVICE);
skb_put(skb, pkt_len);
} else {
pci_unmap_single(np->pci_dev,
diff -Nru a/drivers/net/sungem.c b/drivers/net/sungem.c
--- a/drivers/net/sungem.c Sun Mar 14 10:11:24 2004
+++ b/drivers/net/sungem.c Sun Mar 14 10:11:24 2004
@@ -763,8 +763,9 @@
copy_skb->dev = gp->dev;
skb_reserve(copy_skb, 2);
skb_put(copy_skb, len);
- pci_dma_sync_single(gp->pdev, dma_addr, len, PCI_DMA_FROMDEVICE);
+ pci_dma_sync_single_for_cpu(gp->pdev, dma_addr, len, PCI_DMA_FROMDEVICE);
memcpy(copy_skb->data, skb->data, len);
+ pci_dma_sync_single_for_device(gp->pdev, dma_addr, len, PCI_DMA_FROMDEVICE);
/* We'll reuse the original ring buffer. */
skb = copy_skb;
diff -Nru a/drivers/net/sunhme.c b/drivers/net/sunhme.c
--- a/drivers/net/sunhme.c Sun Mar 14 10:11:18 2004
+++ b/drivers/net/sunhme.c Sun Mar 14 10:11:18 2004
@@ -273,8 +273,10 @@
((__hp)->dma_map((__hp)->happy_dev, (__ptr), (__size), (__dir)))
#define hme_dma_unmap(__hp, __addr, __size, __dir) \
((__hp)->dma_unmap((__hp)->happy_dev, (__addr), (__size), (__dir)))
-#define hme_dma_sync(__hp, __addr, __size, __dir) \
- ((__hp)->dma_sync((__hp)->happy_dev, (__addr), (__size), (__dir)))
+#define hme_dma_sync_for_cpu(__hp, __addr, __size, __dir) \
+ ((__hp)->dma_sync_for_cpu((__hp)->happy_dev, (__addr), (__size), (__dir)))
+#define hme_dma_sync_for_device(__hp, __addr, __size, __dir) \
+ ((__hp)->dma_sync_for_device((__hp)->happy_dev, (__addr), (__size), (__dir)))
#else
#ifdef CONFIG_SBUS
/* SBUS only compilation */
@@ -297,8 +299,10 @@
sbus_map_single((__hp)->happy_dev, (__ptr), (__size), (__dir))
#define hme_dma_unmap(__hp, __addr, __size, __dir) \
sbus_unmap_single((__hp)->happy_dev, (__addr), (__size), (__dir))
-#define hme_dma_sync(__hp, __addr, __size, __dir) \
- sbus_dma_sync_single((__hp)->happy_dev, (__addr), (__size), (__dir))
+#define hme_dma_sync_for_cpu(__hp, __addr, __size, __dir) \
+ sbus_dma_sync_single_for_cpu((__hp)->happy_dev, (__addr), (__size), (__dir))
+#define hme_dma_sync_for_device(__hp, __addr, __size, __dir) \
+ sbus_dma_sync_single_for_device((__hp)->happy_dev, (__addr), (__size), (__dir))
#else
/* PCI only compilation */
#define hme_write32(__hp, __reg, __val) \
@@ -320,8 +324,10 @@
pci_map_single((__hp)->happy_dev, (__ptr), (__size), (__dir))
#define hme_dma_unmap(__hp, __addr, __size, __dir) \
pci_unmap_single((__hp)->happy_dev, (__addr), (__size), (__dir))
-#define hme_dma_sync(__hp, __addr, __size, __dir) \
- pci_dma_sync_single((__hp)->happy_dev, (__addr), (__size), (__dir))
+#define hme_dma_sync_for_cpu(__hp, __addr, __size, __dir) \
+ pci_dma_sync_single_for_cpu((__hp)->happy_dev, (__addr), (__size), (__dir))
+#define hme_dma_sync_for_device(__hp, __addr, __size, __dir) \
+ pci_dma_sync_single_for_device((__hp)->happy_dev, (__addr), (__size), (__dir))
#endif
#endif
@@ -2069,8 +2075,9 @@
copy_skb->dev = dev;
skb_reserve(copy_skb, 2);
skb_put(copy_skb, len);
- hme_dma_sync(hp, dma_addr, len, DMA_FROMDEVICE);
+ hme_dma_sync_for_cpu(hp, dma_addr, len, DMA_FROMDEVICE);
memcpy(copy_skb->data, skb->data, len);
+ hme_dma_sync_for_device(hp, dma_addr, len, DMA_FROMDEVICE);
/* Reuse original ring buffer. */
hme_write_rxd(hp, this,
@@ -2838,7 +2845,10 @@
hp->write_rxd = sbus_hme_write_rxd;
hp->dma_map = (u32 (*)(void *, void *, long, int))sbus_map_single;
hp->dma_unmap = (void (*)(void *, u32, long, int))sbus_unmap_single;
- hp->dma_sync = (void (*)(void *, u32, long, int))sbus_dma_sync_single;
+ hp->dma_sync_for_cpu = (void (*)(void *, u32, long, int))
+ sbus_dma_sync_single_for_cpu;
+ hp->dma_sync_for_device = (void (*)(void *, u32, long, int))
+ sbus_dma_sync_single_for_device;
hp->read32 = sbus_hme_read32;
hp->write32 = sbus_hme_write32;
#endif
@@ -3182,7 +3192,10 @@
hp->write_rxd = pci_hme_write_rxd;
hp->dma_map = (u32 (*)(void *, void *, long, int))pci_map_single;
hp->dma_unmap = (void (*)(void *, u32, long, int))pci_unmap_single;
- hp->dma_sync = (void (*)(void *, u32, long, int))pci_dma_sync_single;
+ hp->dma_sync_for_cpu = (void (*)(void *, u32, long, int))
+ pci_dma_sync_single_for_cpu;
+ hp->dma_sync_for_device = (void (*)(void *, u32, long, int))
+ pci_dma_sync_single_for_device;
hp->read32 = pci_hme_read32;
hp->write32 = pci_hme_write32;
#endif
diff -Nru a/drivers/net/sunhme.h b/drivers/net/sunhme.h
--- a/drivers/net/sunhme.h Sun Mar 14 10:11:21 2004
+++ b/drivers/net/sunhme.h Sun Mar 14 10:11:21 2004
@@ -406,7 +406,8 @@
void (*write_rxd)(struct happy_meal_rxd *, u32, u32);
u32 (*dma_map)(void *, void *, long, int);
void (*dma_unmap)(void *, u32, long, int);
- void (*dma_sync)(void *, u32, long, int);
+ void (*dma_sync_for_cpu)(void *, u32, long, int);
+ void (*dma_sync_for_device)(void *, u32, long, int);
#endif
/* This is either a sbus_dev or a pci_dev. */
diff -Nru a/drivers/net/tg3.c b/drivers/net/tg3.c
--- a/drivers/net/tg3.c Sun Mar 14 10:11:22 2004
+++ b/drivers/net/tg3.c Sun Mar 14 10:11:22 2004
@@ -2280,8 +2280,9 @@
copy_skb->dev = tp->dev;
skb_reserve(copy_skb, 2);
skb_put(copy_skb, len);
- pci_dma_sync_single(tp->pdev, dma_addr, len, PCI_DMA_FROMDEVICE);
+ pci_dma_sync_single_for_cpu(tp->pdev, dma_addr, len, PCI_DMA_FROMDEVICE);
memcpy(copy_skb->data, skb->data, len);
+ pci_dma_sync_single_for_device(tp->pdev, dma_addr, len, PCI_DMA_FROMDEVICE);
/* We'll reuse the original ring buffer. */
skb = copy_skb;
diff -Nru a/drivers/net/tokenring/3c359.c b/drivers/net/tokenring/3c359.c
--- a/drivers/net/tokenring/3c359.c Sun Mar 14 10:11:24 2004
+++ b/drivers/net/tokenring/3c359.c Sun Mar 14 10:11:24 2004
@@ -937,15 +937,17 @@
while (xl_priv->rx_ring_tail != temp_ring_loc) {
copy_len = xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfraglen & 0x7FFF ;
frame_length -= copy_len ;
- pci_dma_sync_single(xl_priv->pdev,xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr,xl_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
+ pci_dma_sync_single_for_cpu(xl_priv->pdev,xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr,xl_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
memcpy(skb_put(skb,copy_len), xl_priv->rx_ring_skb[xl_priv->rx_ring_tail]->data, copy_len) ;
+ pci_dma_sync_single_for_device(xl_priv->pdev,xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr,xl_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
adv_rx_ring(dev) ;
}
/* Now we have found the last fragment */
- pci_dma_sync_single(xl_priv->pdev,xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr,xl_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
+ pci_dma_sync_single_for_cpu(xl_priv->pdev,xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr,xl_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
memcpy(skb_put(skb,copy_len), xl_priv->rx_ring_skb[xl_priv->rx_ring_tail]->data, frame_length) ;
/* memcpy(skb_put(skb,frame_length), bus_to_virt(xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr), frame_length) ; */
+ pci_dma_sync_single_for_device(xl_priv->pdev,xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr,xl_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
adv_rx_ring(dev) ;
skb->protocol = tr_type_trans(skb,dev) ;
netif_rx(skb) ;
diff -Nru a/drivers/net/tokenring/olympic.c b/drivers/net/tokenring/olympic.c
--- a/drivers/net/tokenring/olympic.c Sun Mar 14 10:11:23 2004
+++ b/drivers/net/tokenring/olympic.c Sun Mar 14 10:11:23 2004
@@ -842,10 +842,13 @@
olympic_priv->rx_ring_skb[rx_ring_last_received] = skb ;
netif_rx(skb2) ;
} else {
- pci_dma_sync_single(olympic_priv->pdev,
+ pci_dma_sync_single_for_cpu(olympic_priv->pdev,
le32_to_cpu(olympic_priv->olympic_rx_ring[rx_ring_last_received].buffer),
olympic_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
memcpy(skb_put(skb,length-4),olympic_priv->rx_ring_skb[rx_ring_last_received]->data,length-4) ;
+ pci_dma_sync_single_for_device(olympic_priv->pdev,
+ le32_to_cpu(olympic_priv->olympic_rx_ring[rx_ring_last_received].buffer),
+ olympic_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
skb->protocol = tr_type_trans(skb,dev) ;
netif_rx(skb) ;
}
@@ -854,12 +857,15 @@
olympic_priv->rx_ring_last_received++ ;
olympic_priv->rx_ring_last_received &= (OLYMPIC_RX_RING_SIZE -1);
rx_ring_last_received = olympic_priv->rx_ring_last_received ;
- pci_dma_sync_single(olympic_priv->pdev,
+ pci_dma_sync_single_for_cpu(olympic_priv->pdev,
le32_to_cpu(olympic_priv->olympic_rx_ring[rx_ring_last_received].buffer),
olympic_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
rx_desc = &(olympic_priv->olympic_rx_ring[rx_ring_last_received]);
cpy_length = (i == 1 ? frag_len : le32_to_cpu(rx_desc->res_length));
memcpy(skb_put(skb, cpy_length), olympic_priv->rx_ring_skb[rx_ring_last_received]->data, cpy_length) ;
+ pci_dma_sync_single_for_device(olympic_priv->pdev,
+ le32_to_cpu(olympic_priv->olympic_rx_ring[rx_ring_last_received].buffer),
+ olympic_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
} while (--i) ;
skb_trim(skb,skb->len-4) ;
skb->protocol = tr_type_trans(skb,dev);
diff -Nru a/drivers/net/tulip/de2104x.c b/drivers/net/tulip/de2104x.c
--- a/drivers/net/tulip/de2104x.c Sun Mar 14 10:11:23 2004
+++ b/drivers/net/tulip/de2104x.c Sun Mar 14 10:11:23 2004
@@ -457,9 +457,11 @@
buflen, PCI_DMA_FROMDEVICE);
de->rx_skb[rx_tail].skb = copy_skb;
} else {
- pci_dma_sync_single(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
+ pci_dma_sync_single_for_cpu(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
skb_reserve(copy_skb, RX_OFFSET);
memcpy(skb_put(copy_skb, len), skb->tail, len);
+
+ pci_dma_sync_single_for_device(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
/* We'll reuse the original ring buffer. */
skb = copy_skb;
diff -Nru a/drivers/net/tulip/interrupt.c b/drivers/net/tulip/interrupt.c
--- a/drivers/net/tulip/interrupt.c Sun Mar 14 10:11:17 2004
+++ b/drivers/net/tulip/interrupt.c Sun Mar 14 10:11:17 2004
@@ -191,9 +191,9 @@
&& (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
skb->dev = dev;
skb_reserve(skb, 2); /* 16 byte align the IP header */
- pci_dma_sync_single(tp->pdev,
- tp->rx_buffers[entry].mapping,
- pkt_len, PCI_DMA_FROMDEVICE);
+ pci_dma_sync_single_for_cpu(tp->pdev,
+ tp->rx_buffers[entry].mapping,
+ pkt_len, PCI_DMA_FROMDEVICE);
#if ! defined(__alpha__)
eth_copy_and_sum(skb, tp->rx_buffers[entry].skb->tail,
pkt_len, 0);
@@ -203,6 +203,9 @@
tp->rx_buffers[entry].skb->tail,
pkt_len);
#endif
+ pci_dma_sync_single_for_device(tp->pdev,
+ tp->rx_buffers[entry].mapping,
+ pkt_len, PCI_DMA_FROMDEVICE);
} else { /* Pass up the skb already on the Rx ring. */
char *temp = skb_put(skb = tp->rx_buffers[entry].skb,
pkt_len);
@@ -412,9 +415,9 @@
&& (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
skb->dev = dev;
skb_reserve(skb, 2); /* 16 byte align the IP header */
- pci_dma_sync_single(tp->pdev,
- tp->rx_buffers[entry].mapping,
- pkt_len, PCI_DMA_FROMDEVICE);
+ pci_dma_sync_single_for_cpu(tp->pdev,
+ tp->rx_buffers[entry].mapping,
+ pkt_len, PCI_DMA_FROMDEVICE);
#if ! defined(__alpha__)
eth_copy_and_sum(skb, tp->rx_buffers[entry].skb->tail,
pkt_len, 0);
@@ -424,6 +427,9 @@
tp->rx_buffers[entry].skb->tail,
pkt_len);
#endif
+ pci_dma_sync_single_for_device(tp->pdev,
+ tp->rx_buffers[entry].mapping,
+ pkt_len, PCI_DMA_FROMDEVICE);
} else { /* Pass up the skb already on the Rx ring. */
char *temp = skb_put(skb = tp->rx_buffers[entry].skb,
pkt_len);
diff -Nru a/drivers/net/tulip/winbond-840.c b/drivers/net/tulip/winbond-840.c
--- a/drivers/net/tulip/winbond-840.c Sun Mar 14 10:11:17 2004
+++ b/drivers/net/tulip/winbond-840.c Sun Mar 14 10:11:17 2004
@@ -1289,9 +1289,9 @@
&& (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
skb->dev = dev;
skb_reserve(skb, 2); /* 16 byte align the IP header */
- pci_dma_sync_single(np->pci_dev,np->rx_addr[entry],
- np->rx_skbuff[entry]->len,
- PCI_DMA_FROMDEVICE);
+ pci_dma_sync_single_for_cpu(np->pci_dev,np->rx_addr[entry],
+ np->rx_skbuff[entry]->len,
+ PCI_DMA_FROMDEVICE);
/* Call copy + cksum if available. */
#if HAS_IP_COPYSUM
eth_copy_and_sum(skb, np->rx_skbuff[entry]->tail, pkt_len, 0);
@@ -1300,6 +1300,9 @@
memcpy(skb_put(skb, pkt_len), np->rx_skbuff[entry]->tail,
pkt_len);
#endif
+ pci_dma_sync_single_for_device(np->pci_dev,np->rx_addr[entry],
+ np->rx_skbuff[entry]->len,
+ PCI_DMA_FROMDEVICE);
} else {
pci_unmap_single(np->pci_dev,np->rx_addr[entry],
np->rx_skbuff[entry]->len,
diff -Nru a/drivers/net/typhoon.c b/drivers/net/typhoon.c
--- a/drivers/net/typhoon.c Sun Mar 14 10:11:23 2004
+++ b/drivers/net/typhoon.c Sun Mar 14 10:11:23 2004
@@ -1701,9 +1701,13 @@
(new_skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
new_skb->dev = tp->dev;
skb_reserve(new_skb, 2);
- pci_dma_sync_single(tp->pdev, dma_addr, PKT_BUF_SZ,
- PCI_DMA_FROMDEVICE);
+ pci_dma_sync_single_for_cpu(tp->pdev, dma_addr,
+ PKT_BUF_SZ,
+ PCI_DMA_FROMDEVICE);
eth_copy_and_sum(new_skb, skb->tail, pkt_len, 0);
+ pci_dma_sync_single_for_device(tp->pdev, dma_addr,
+ PKT_BUF_SZ,
+ PCI_DMA_FROMDEVICE);
skb_put(new_skb, pkt_len);
typhoon_recycle_rx_skb(tp, idx);
} else {
diff -Nru a/drivers/net/via-rhine.c b/drivers/net/via-rhine.c
--- a/drivers/net/via-rhine.c Sun Mar 14 10:11:24 2004
+++ b/drivers/net/via-rhine.c Sun Mar 14 10:11:24 2004
@@ -1536,7 +1536,7 @@
(skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
skb->dev = dev;
skb_reserve(skb, 2); /* 16 byte align the IP header */
- pci_dma_sync_single(np->pdev, np->rx_skbuff_dma[entry],
+ pci_dma_sync_single_for_cpu(np->pdev, np->rx_skbuff_dma[entry],
np->rx_buf_sz, PCI_DMA_FROMDEVICE);
/* *_IP_COPYSUM isn't defined anywhere and eth_copy_and_sum
@@ -1549,6 +1549,8 @@
memcpy(skb_put(skb, pkt_len), np->rx_skbuff[entry]->tail,
pkt_len);
#endif
+ pci_dma_sync_single_for_device(np->pdev, np->rx_skbuff_dma[entry],
+ np->rx_buf_sz, PCI_DMA_FROMDEVICE);
} else {
skb = np->rx_skbuff[entry];
if (skb == NULL) {
diff -Nru a/drivers/net/wan/dscc4.c b/drivers/net/wan/dscc4.c
--- a/drivers/net/wan/dscc4.c Sun Mar 14 10:11:17 2004
+++ b/drivers/net/wan/dscc4.c Sun Mar 14 10:11:17 2004
@@ -652,7 +652,6 @@
goto refill;
}
pkt_len = TO_SIZE(rx_fd->state2);
- pci_dma_sync_single(pdev, rx_fd->data, pkt_len, PCI_DMA_FROMDEVICE);
pci_unmap_single(pdev, rx_fd->data, RX_MAX(HDLC_MAX_MRU), PCI_DMA_FROMDEVICE);
if ((skb->data[--pkt_len] & FrameOk) == FrameOk) {
stats->rx_packets++;
diff -Nru a/drivers/net/yellowfin.c b/drivers/net/yellowfin.c
--- a/drivers/net/yellowfin.c Sun Mar 14 10:11:18 2004
+++ b/drivers/net/yellowfin.c Sun Mar 14 10:11:18 2004
@@ -1124,7 +1124,7 @@
if(!desc->result_status)
break;
- pci_dma_sync_single(yp->pci_dev, desc->addr,
+ pci_dma_sync_single_for_cpu(yp->pci_dev, desc->addr,
yp->rx_buf_sz, PCI_DMA_FROMDEVICE);
desc_status = le32_to_cpu(desc->result_status) >> 16;
buf_addr = rx_skb->tail;
@@ -1208,6 +1208,9 @@
memcpy(skb_put(skb, pkt_len),
rx_skb->tail, pkt_len);
#endif
+ pci_dma_sync_single_for_device(yp->pci_dev, desc->addr,
+ yp->rx_buf_sz,
+ PCI_DMA_FROMDEVICE);
}
skb->protocol = eth_type_trans(skb, dev);
netif_rx(skb);
diff -Nru a/drivers/parisc/ccio-dma.c b/drivers/parisc/ccio-dma.c
--- a/drivers/parisc/ccio-dma.c Sun Mar 14 10:11:17 2004
+++ b/drivers/parisc/ccio-dma.c Sun Mar 14 10:11:17 2004
@@ -1149,8 +1149,10 @@
.unmap_single = ccio_unmap_single,
.map_sg = ccio_map_sg,
.unmap_sg = ccio_unmap_sg,
- .dma_sync_single = NULL, /* NOP for U2/Uturn */
- .dma_sync_sg = NULL, /* ditto */
+ .dma_sync_single_for_cpu = NULL, /* NOP for U2/Uturn */
+ .dma_sync_single_for_device = NULL, /* NOP for U2/Uturn */
+ .dma_sync_sg_for_cpu = NULL, /* ditto */
+ .dma_sync_sg_for_device = NULL, /* ditto */
};
#ifdef CONFIG_PROC_FS
diff -Nru a/drivers/parisc/ccio-rm-dma.c b/drivers/parisc/ccio-rm-dma.c
--- a/drivers/parisc/ccio-rm-dma.c Sun Mar 14 10:11:17 2004
+++ b/drivers/parisc/ccio-rm-dma.c Sun Mar 14 10:11:17 2004
@@ -151,8 +151,10 @@
ccio_unmap_single,
ccio_map_sg,
ccio_unmap_sg,
- NULL, /* dma_sync_single : NOP for U2 */
- NULL, /* dma_sync_sg : ditto */
+ NULL, /* dma_sync_single_for_cpu : NOP for U2 */
+ NULL, /* dma_sync_single_for_device : NOP for U2 */
+ NULL, /* dma_sync_sg_for_cpu : ditto */
+ NULL, /* dma_sync_sg_for_device : ditto */
};
diff -Nru a/drivers/parisc/sba_iommu.c b/drivers/parisc/sba_iommu.c
--- a/drivers/parisc/sba_iommu.c Sun Mar 14 10:11:23 2004
+++ b/drivers/parisc/sba_iommu.c Sun Mar 14 10:11:23 2004
@@ -1410,8 +1410,10 @@
.unmap_single = sba_unmap_single,
.map_sg = sba_map_sg,
.unmap_sg = sba_unmap_sg,
- .dma_sync_single = NULL,
- .dma_sync_sg = NULL,
+ .dma_sync_single_for_cpu = NULL,
+ .dma_sync_single_for_device = NULL,
+ .dma_sync_sg_for_cpu = NULL,
+ .dma_sync_sg_for_device = NULL,
};
diff -Nru a/drivers/scsi/53c700.c b/drivers/scsi/53c700.c
--- a/drivers/scsi/53c700.c Sun Mar 14 10:11:17 2004
+++ b/drivers/scsi/53c700.c Sun Mar 14 10:11:17 2004
@@ -373,7 +373,7 @@
hostdata->script = script;
hostdata->pScript = pScript;
- dma_sync_single(hostdata->dev, pScript, sizeof(SCRIPT), DMA_TO_DEVICE);
+ dma_sync_single_for_device(hostdata->dev, pScript, sizeof(SCRIPT), DMA_TO_DEVICE);
hostdata->state = NCR_700_HOST_FREE;
hostdata->cmd = NULL;
host->max_id = 7;
@@ -1005,8 +1005,8 @@
SCp->cmnd[7] = hostdata->status[0];
SCp->use_sg = 0;
SCp->sc_data_direction = SCSI_DATA_READ;
- dma_sync_single(hostdata->dev, slot->pCmd,
- SCp->cmd_len, DMA_TO_DEVICE);
+ dma_sync_single_for_device(hostdata->dev, slot->pCmd,
+ SCp->cmd_len, DMA_TO_DEVICE);
SCp->request_bufflen = sizeof(SCp->sense_buffer);
slot->dma_handle = dma_map_single(hostdata->dev, SCp->sense_buffer, sizeof(SCp->sense_buffer), DMA_FROM_DEVICE);
slot->SG[0].ins = bS_to_host(SCRIPT_MOVE_DATA_IN | sizeof(SCp->sense_buffer));
@@ -1030,7 +1030,7 @@
// SCp->cmnd[0] == INQUIRY && SCp->use_sg == 0) {
// /* Piggy back the tag queueing support
// * on this command */
- // dma_sync_single(hostdata->dev,
+ // dma_sync_single_for_cpu(hostdata->dev,
// slot->dma_handle,
// SCp->request_bufflen,
// DMA_FROM_DEVICE);
diff -Nru a/drivers/scsi/dc395x.c b/drivers/scsi/dc395x.c
--- a/drivers/scsi/dc395x.c Sun Mar 14 10:11:16 2004
+++ b/drivers/scsi/dc395x.c Sun Mar 14 10:11:16 2004
@@ -1963,7 +1963,7 @@
psge->length -= xferred;
psge->address += xferred;
srb->sg_index = idx;
- pci_dma_sync_single(srb->dcb->
+ pci_dma_sync_single_for_device(srb->dcb->
acb->dev,
srb->sg_bus_addr,
SEGMENTX_LEN,
@@ -3448,11 +3448,11 @@
if (dir != PCI_DMA_NONE) {
if (cmd->use_sg)
- pci_dma_sync_sg(acb->dev,
+ pci_dma_sync_sg_for_cpu(acb->dev,
(struct scatterlist *)cmd->
request_buffer, cmd->use_sg, dir);
else if (cmd->request_buffer)
- pci_dma_sync_single(acb->dev,
+ pci_dma_sync_single_for_cpu(acb->dev,
srb->segment_x[0].address,
cmd->request_bufflen, dir);
}
diff -Nru a/drivers/scsi/eata.c b/drivers/scsi/eata.c
--- a/drivers/scsi/eata.c Sun Mar 14 10:11:23 2004
+++ b/drivers/scsi/eata.c Sun Mar 14 10:11:23 2004
@@ -1598,17 +1598,17 @@
pci_dir = scsi_to_pci_dma_dir(SCpnt->sc_data_direction);
if (DEV2H(cpp->sense_addr))
- pci_dma_sync_single(HD(j)->pdev, DEV2H(cpp->sense_addr),
+ pci_dma_sync_single_for_cpu(HD(j)->pdev, DEV2H(cpp->sense_addr),
DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE);
if (SCpnt->use_sg)
- pci_dma_sync_sg(HD(j)->pdev, SCpnt->request_buffer,
+ pci_dma_sync_sg_for_cpu(HD(j)->pdev, SCpnt->request_buffer,
SCpnt->use_sg, pci_dir);
if (!DEV2H(cpp->data_len)) pci_dir = PCI_DMA_BIDIRECTIONAL;
if (DEV2H(cpp->data_address))
- pci_dma_sync_single(HD(j)->pdev, DEV2H(cpp->data_address),
+ pci_dma_sync_single_for_cpu(HD(j)->pdev, DEV2H(cpp->data_address),
DEV2H(cpp->data_len), pci_dir);
}
diff -Nru a/drivers/scsi/megaraid.c b/drivers/scsi/megaraid.c
--- a/drivers/scsi/megaraid.c Sun Mar 14 10:11:16 2004
+++ b/drivers/scsi/megaraid.c Sun Mar 14 10:11:16 2004
@@ -261,10 +261,6 @@
"megaraid: Product_info cmd failed with error: %d\n",
retval);
- pci_dma_sync_single(adapter->dev, prod_info_dma_handle,
- sizeof(mega_product_info),
- PCI_DMA_FROMDEVICE);
-
pci_unmap_single(adapter->dev, prod_info_dma_handle,
sizeof(mega_product_info), PCI_DMA_FROMDEVICE);
}
@@ -1651,26 +1647,11 @@
case MEGA_BULK_DATA:
pci_unmap_page(adapter->dev, scb->dma_h_bulkdata,
scb->cmd->request_bufflen, scb->dma_direction);
-
- if( scb->dma_direction == PCI_DMA_FROMDEVICE ) {
- pci_dma_sync_single(adapter->dev,
- scb->dma_h_bulkdata,
- scb->cmd->request_bufflen,
- PCI_DMA_FROMDEVICE);
- }
-
break;
case MEGA_SGLIST:
pci_unmap_sg(adapter->dev, scb->cmd->request_buffer,
scb->cmd->use_sg, scb->dma_direction);
-
- if( scb->dma_direction == PCI_DMA_FROMDEVICE ) {
- pci_dma_sync_sg(adapter->dev,
- scb->cmd->request_buffer,
- scb->cmd->use_sg, PCI_DMA_FROMDEVICE);
- }
-
break;
default:
@@ -1758,14 +1739,6 @@
*buf = (u32)scb->dma_h_bulkdata;
*len = (u32)cmd->request_bufflen;
}
-
- if( scb->dma_direction == PCI_DMA_TODEVICE ) {
- pci_dma_sync_single(adapter->dev,
- scb->dma_h_bulkdata,
- cmd->request_bufflen,
- PCI_DMA_TODEVICE);
- }
-
return 0;
}
@@ -1803,11 +1776,6 @@
* with a sg list
*/
*len = (u32)cmd->request_bufflen;
-
- if( scb->dma_direction == PCI_DMA_TODEVICE ) {
- pci_dma_sync_sg(adapter->dev, sgl, cmd->use_sg,
- PCI_DMA_TODEVICE);
- }
/* Return count of SG requests */
return sgcnt;
diff -Nru a/drivers/scsi/ncr53c8xx.c b/drivers/scsi/ncr53c8xx.c
--- a/drivers/scsi/ncr53c8xx.c Sun Mar 14 10:11:18 2004
+++ b/drivers/scsi/ncr53c8xx.c Sun Mar 14 10:11:18 2004
@@ -5140,9 +5140,10 @@
*/
if (cmd->cmnd[0] == 0x12 && !(cmd->cmnd[1] & 0x3) &&
cmd->cmnd[4] >= 7 && !cmd->use_sg) {
- sync_scsi_data(np, cmd); /* SYNC the data */
+ sync_scsi_data_for_cpu(np, cmd); /* SYNC the data */
ncr_setup_lcb (np, cmd->device->id, cmd->device->lun,
(char *) cmd->request_buffer);
+ sync_scsi_data_for_device(np, cmd); /* SYNC the data */
}
tp->bytes += cp->data_len;
diff -Nru a/drivers/scsi/sym53c8xx_2/sym_glue.c b/drivers/scsi/sym53c8xx_2/sym_glue.c
--- a/drivers/scsi/sym53c8xx_2/sym_glue.c Sun Mar 14 10:11:24 2004
+++ b/drivers/scsi/sym53c8xx_2/sym_glue.c Sun Mar 14 10:11:24 2004
@@ -212,17 +212,32 @@
return use_sg;
}
-static void __sync_scsi_data(struct pci_dev *pdev, struct scsi_cmnd *cmd)
+static void __sync_scsi_data_for_cpu(struct pci_dev *pdev, struct scsi_cmnd *cmd)
{
int dma_dir = scsi_to_pci_dma_dir(cmd->sc_data_direction);
switch(SYM_UCMD_PTR(cmd)->data_mapped) {
case 2:
- pci_dma_sync_sg(pdev, cmd->buffer, cmd->use_sg, dma_dir);
+ pci_dma_sync_sg_for_cpu(pdev, cmd->buffer, cmd->use_sg, dma_dir);
break;
case 1:
- pci_dma_sync_single(pdev, SYM_UCMD_PTR(cmd)->data_mapping,
- cmd->request_bufflen, dma_dir);
+ pci_dma_sync_single_for_cpu(pdev, SYM_UCMD_PTR(cmd)->data_mapping,
+ cmd->request_bufflen, dma_dir);
+ break;
+ }
+}
+
+static void __sync_scsi_data_for_device(struct pci_dev *pdev, struct scsi_cmnd *cmd)
+{
+ int dma_dir = scsi_to_pci_dma_dir(cmd->sc_data_direction);
+
+ switch(SYM_UCMD_PTR(cmd)->data_mapped) {
+ case 2:
+ pci_dma_sync_sg_for_device(pdev, cmd->buffer, cmd->use_sg, dma_dir);
+ break;
+ case 1:
+ pci_dma_sync_single_for_device(pdev, SYM_UCMD_PTR(cmd)->data_mapping,
+ cmd->request_bufflen, dma_dir);
break;
}
}
@@ -233,8 +248,10 @@
__map_scsi_single_data(np->s.device, cmd)
#define map_scsi_sg_data(np, cmd) \
__map_scsi_sg_data(np->s.device, cmd)
-#define sync_scsi_data(np, cmd) \
- __sync_scsi_data(np->s.device, cmd)
+#define sync_scsi_data_for_cpu(np, cmd) \
+ __sync_scsi_data_for_cpu(np->s.device, cmd)
+#define sync_scsi_data_for_device(np, cmd) \
+ __sync_scsi_data_for_device(np->s.device, cmd)
/*
* Complete a pending CAM CCB.
@@ -394,10 +411,11 @@
if (!cmd || cmd->use_sg)
return;
- sync_scsi_data(np, cmd);
+ sync_scsi_data_for_cpu(np, cmd);
retv = __sym_sniff_inquiry(np, cmd->device->id, cmd->device->lun,
(u_char *) cmd->request_buffer,
cmd->request_bufflen - resid);
+ sync_scsi_data_for_device(np, cmd);
if (retv < 0)
return;
else if (retv)
diff -Nru a/drivers/scsi/sym53c8xx_comm.h b/drivers/scsi/sym53c8xx_comm.h
--- a/drivers/scsi/sym53c8xx_comm.h Sun Mar 14 10:11:22 2004
+++ b/drivers/scsi/sym53c8xx_comm.h Sun Mar 14 10:11:22 2004
@@ -703,7 +703,8 @@
#define __unmap_scsi_data(dev, cmd) do {; } while (0)
#define __map_scsi_single_data(dev, cmd) (__vtobus(dev,(cmd)->request_buffer))
#define __map_scsi_sg_data(dev, cmd) ((cmd)->use_sg)
-#define __sync_scsi_data(dev, cmd) do {; } while (0)
+#define __sync_scsi_data_for_cpu(dev, cmd) do {; } while (0)
+#define __sync_scsi_data_for_device(dev, cmd) do {; } while (0)
#define scsi_sg_dma_address(sc) vtobus((sc)->address)
#define scsi_sg_dma_len(sc) ((sc)->length)
@@ -767,18 +768,34 @@
return use_sg;
}
-static void __sync_scsi_data(struct device *dev, Scsi_Cmnd *cmd)
+static void __sync_scsi_data_for_cpu(struct device *dev, Scsi_Cmnd *cmd)
{
enum dma_data_direction dma_dir =
(enum dma_data_direction)scsi_to_pci_dma_dir(cmd->sc_data_direction);
switch(cmd->__data_mapped) {
case 2:
- dma_sync_sg(dev, cmd->buffer, cmd->use_sg, dma_dir);
+ dma_sync_sg_for_cpu(dev, cmd->buffer, cmd->use_sg, dma_dir);
break;
case 1:
- dma_sync_single(dev, cmd->__data_mapping,
- cmd->request_bufflen, dma_dir);
+ dma_sync_single_for_cpu(dev, cmd->__data_mapping,
+ cmd->request_bufflen, dma_dir);
+ break;
+ }
+}
+
+static void __sync_scsi_data_for_device(struct device *dev, Scsi_Cmnd *cmd)
+{
+ enum dma_data_direction dma_dir =
+ (enum dma_data_direction)scsi_to_pci_dma_dir(cmd->sc_data_direction);
+
+ switch(cmd->__data_mapped) {
+ case 2:
+ dma_sync_sg_for_device(dev, cmd->buffer, cmd->use_sg, dma_dir);
+ break;
+ case 1:
+ dma_sync_single_for_device(dev, cmd->__data_mapping,
+ cmd->request_bufflen, dma_dir);
break;
}
}
@@ -791,7 +808,8 @@
#define unmap_scsi_data(np, cmd) __unmap_scsi_data(np->dev, cmd)
#define map_scsi_single_data(np, cmd) __map_scsi_single_data(np->dev, cmd)
#define map_scsi_sg_data(np, cmd) __map_scsi_sg_data(np->dev, cmd)
-#define sync_scsi_data(np, cmd) __sync_scsi_data(np->dev, cmd)
+#define sync_scsi_data_for_cpu(np, cmd) __sync_scsi_data_for_cpu(np->dev, cmd)
+#define sync_scsi_data_for_device(np, cmd) __sync_scsi_data_for_device(np->dev, cmd)
/*==========================================================
**
diff -Nru a/drivers/scsi/u14-34f.c b/drivers/scsi/u14-34f.c
--- a/drivers/scsi/u14-34f.c Sun Mar 14 10:11:18 2004
+++ b/drivers/scsi/u14-34f.c Sun Mar 14 10:11:18 2004
@@ -1184,17 +1184,17 @@
pci_dir = scsi_to_pci_dma_dir(SCpnt->sc_data_direction);
if (DEV2H(cpp->sense_addr))
- pci_dma_sync_single(HD(j)->pdev, DEV2H(cpp->sense_addr),
+ pci_dma_sync_single_for_cpu(HD(j)->pdev, DEV2H(cpp->sense_addr),
DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE);
if (SCpnt->use_sg)
- pci_dma_sync_sg(HD(j)->pdev, SCpnt->request_buffer,
+ pci_dma_sync_sg_for_cpu(HD(j)->pdev, SCpnt->request_buffer,
SCpnt->use_sg, pci_dir);
if (!DEV2H(cpp->data_len)) pci_dir = PCI_DMA_BIDIRECTIONAL;
if (DEV2H(cpp->data_address))
- pci_dma_sync_single(HD(j)->pdev, DEV2H(cpp->data_address),
+ pci_dma_sync_single_for_cpu(HD(j)->pdev, DEV2H(cpp->data_address),
DEV2H(cpp->data_len), pci_dir);
}
diff -Nru a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
--- a/drivers/usb/core/usb.c Sun Mar 14 10:11:22 2004
+++ b/drivers/usb/core/usb.c Sun Mar 14 10:11:22 2004
@@ -1297,6 +1297,13 @@
return urb;
}
+/* XXX DISABLED, no users currently. If you wish to re-enable this
+ * XXX please determine whether the sync is to transfer ownership of
+ * XXX the buffer from device to cpu or vice verse, and thusly use the
+ * XXX appropriate _for_{cpu,device}() method. -DaveM
+ */
+#if 0
+
/**
* usb_buffer_dmasync - synchronize DMA and CPU view of buffer(s)
* @urb: urb whose transfer_buffer/setup_packet will be synchronized
@@ -1325,6 +1332,7 @@
DMA_TO_DEVICE);
}
}
+#endif
/**
* usb_buffer_unmap - free DMA mapping(s) for an urb
@@ -1403,6 +1411,13 @@
usb_pipein (pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
}
+/* XXX DISABLED, no users currently. If you wish to re-enable this
+ * XXX please determine whether the sync is to transfer ownership of
+ * XXX the buffer from device to cpu or vice verse, and thusly use the
+ * XXX appropriate _for_{cpu,device}() method. -DaveM
+ */
+#if 0
+
/**
* usb_buffer_dmasync_sg - synchronize DMA and CPU view of scatterlist buffer(s)
* @dev: device to which the scatterlist will be mapped
@@ -1428,6 +1443,7 @@
dma_sync_sg (controller, sg, n_hw_ents,
usb_pipein (pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
}
+#endif
/**
* usb_buffer_unmap_sg - free DMA mapping(s) for a scatterlist
@@ -1595,11 +1611,15 @@
EXPORT_SYMBOL (usb_buffer_free);
EXPORT_SYMBOL (usb_buffer_map);
+#if 0
EXPORT_SYMBOL (usb_buffer_dmasync);
+#endif
EXPORT_SYMBOL (usb_buffer_unmap);
EXPORT_SYMBOL (usb_buffer_map_sg);
+#if 0
EXPORT_SYMBOL (usb_buffer_dmasync_sg);
+#endif
EXPORT_SYMBOL (usb_buffer_unmap_sg);
MODULE_LICENSE("GPL");
diff -Nru a/include/asm-alpha/pci.h b/include/asm-alpha/pci.h
--- a/include/asm-alpha/pci.h Sun Mar 14 10:11:16 2004
+++ b/include/asm-alpha/pci.h Sun Mar 14 10:11:16 2004
@@ -88,7 +88,7 @@
/* Map a single buffer of the indicate 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
- until either pci_unmap_single or pci_dma_sync_single is performed. */
+ until either pci_unmap_single or pci_dma_sync_single_for_cpu is performed. */
extern dma_addr_t pci_map_single(struct pci_dev *, void *, size_t, int);
@@ -142,28 +142,44 @@
extern void pci_unmap_sg(struct pci_dev *, struct scatterlist *, int, int);
/* Make physical memory consistent for a single streaming mode DMA
- translation after a transfer.
+ translation after a transfer and device currently has ownership
+ of the buffer.
If you perform a pci_map_single() but wish to interrogate the
buffer using the cpu, yet do not wish to teardown the PCI dma
mapping, you must call this function before doing so. At the next
- point you give the PCI dma address back to the card, the device
- again owns the buffer. */
+ point you give the PCI dma address back to the card, you must first
+ perform a pci_dma_sync_for_device, and then the device again owns
+ the buffer. */
static inline void
-pci_dma_sync_single(struct pci_dev *dev, dma_addr_t dma_addr, long size,
- int direction)
+pci_dma_sync_single_for_cpu(struct pci_dev *dev, dma_addr_t dma_addr, long size,
+ int direction)
+{
+ /* Nothing to do. */
+}
+
+static inline void
+pci_dma_sync_single_for_device(struct pci_dev *dev, dma_addr_t dma_addr, long size,
+ int direction)
{
/* Nothing to do. */
}
/* Make physical memory consistent for a set of streaming mode DMA
- translations after a transfer. The same as pci_dma_sync_single but
- for a scatter-gather list, same rules and usage. */
+ translations after a transfer. The same as pci_dma_sync_single_*
+ but for a scatter-gather list, same rules and usage. */
static inline void
-pci_dma_sync_sg(struct pci_dev *dev, struct scatterlist *sg, int nents,
- int direction)
+pci_dma_sync_sg_for_cpu(struct pci_dev *dev, struct scatterlist *sg, int nents,
+ int direction)
+{
+ /* Nothing to do. */
+}
+
+static inline void
+pci_dma_sync_sg_for_device(struct pci_dev *dev, struct scatterlist *sg, int nents,
+ int direction)
{
/* Nothing to do. */
}
@@ -184,8 +200,14 @@
extern struct page *pci_dac_dma_to_page(struct pci_dev *, dma64_addr_t);
extern unsigned long pci_dac_dma_to_offset(struct pci_dev *, dma64_addr_t);
-static __inline__ void
-pci_dac_dma_sync_single(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction)
+static inline void
+pci_dac_dma_sync_single_for_cpu(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction)
+{
+ /* Nothing to do. */
+}
+
+static inline void
+pci_dac_dma_sync_single_for_device(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction)
{
/* Nothing to do. */
}
diff -Nru a/include/asm-arm/dma-mapping.h b/include/asm-arm/dma-mapping.h
--- a/include/asm-arm/dma-mapping.h Sun Mar 14 10:11:16 2004
+++ b/include/asm-arm/dma-mapping.h Sun Mar 14 10:11:16 2004
@@ -26,8 +26,10 @@
void sa1111_unmap_single(struct device *dev, dma_addr_t, size_t, enum dma_data_direction);
int sa1111_map_sg(struct device *dev, struct scatterlist *, int, enum dma_data_direction);
void sa1111_unmap_sg(struct device *dev, struct scatterlist *, int, enum dma_data_direction);
-void sa1111_dma_sync_single(struct device *dev, dma_addr_t, size_t, enum dma_data_direction);
-void sa1111_dma_sync_sg(struct device *dev, struct scatterlist *, int, enum dma_data_direction);
+void sa1111_dma_sync_single_for_cpu(struct device *dev, dma_addr_t, size_t, enum dma_data_direction);
+void sa1111_dma_sync_single_for_device(struct device *dev, dma_addr_t, size_t, enum dma_data_direction);
+void sa1111_dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *, int, enum dma_data_direction);
+void sa1111_dma_sync_sg_for_device(struct device *dev, struct scatterlist *, int, enum dma_data_direction);
#ifdef CONFIG_SA1111
@@ -115,7 +117,8 @@
* or written back.
*
* The device owns this memory once this call has completed. The CPU
- * can regain ownership by calling dma_unmap_single() or dma_sync_single().
+ * can regain ownership by calling dma_unmap_single() or
+ * dma_sync_single_for_cpu().
*/
static inline dma_addr_t
dma_map_single(struct device *dev, void *cpu_addr, size_t size,
@@ -140,7 +143,8 @@
* or written back.
*
* The device owns this memory once this call has completed. The CPU
- * can regain ownership by calling dma_unmap_page() or dma_sync_single().
+ * can regain ownership by calling dma_unmap_page() or
+ * dma_sync_single_for_cpu().
*/
static inline dma_addr_t
dma_map_page(struct device *dev, struct page *page,
@@ -204,7 +208,7 @@
*
* Map a set of buffers described by scatterlist in streaming
* mode for DMA. This is the scatter-gather version of the
- * above pci_map_single interface. Here the scatter gather list
+ * above dma_map_single interface. Here the scatter gather list
* elements are each tagged with the appropriate dma address
* and length. They are obtained via sg_dma_{address,length}(SG).
*
@@ -214,7 +218,7 @@
* The routine returns the number of addr/length pairs actually
* used, at most nents.
*
- * Device ownership issues as mentioned above for pci_map_single are
+ * Device ownership issues as mentioned above for dma_map_single are
* the same here.
*/
static inline int
@@ -246,7 +250,7 @@
*
* Unmap a set of streaming mode DMA translations.
* Again, CPU read rules concerning calls here are the same as for
- * pci_unmap_single() above.
+ * dma_unmap_single() above.
*/
static inline void
dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nents,
@@ -261,7 +265,7 @@
}
/**
- * dma_sync_single
+ * dma_sync_single_for_cpu
* @dev: valid struct device pointer, or NULL for ISA and EISA-like devices
* @handle: DMA address of buffer
* @size: size of buffer to map
@@ -270,18 +274,31 @@
* Make physical memory consistent for a single streaming mode DMA
* translation after a transfer.
*
- * If you perform a pci_map_single() but wish to interrogate the
+ * If you perform a dma_map_single() but wish to interrogate the
* buffer using the cpu, yet do not wish to teardown the PCI dma
* mapping, you must call this function before doing so. At the
- * next point you give the PCI dma address back to the card, the
+ * next point you give the PCI dma address back to the card, you
+ * must first the perform a dma_sync_for_device, and then the
* device again owns the buffer.
*/
static inline void
-dma_sync_single(struct device *dev, dma_addr_t handle, size_t size,
- enum dma_data_direction dir)
+dma_sync_single_for_cpu(struct device *dev, dma_addr_t handle, size_t size,
+ enum dma_data_direction dir)
{
if (dmadev_is_sa1111(dev)) {
- sa1111_dma_sync_single(dev, handle, size, dir);
+ sa1111_dma_sync_single_for_cpu(dev, handle, size, dir);
+ return;
+ }
+
+ consistent_sync((void *)__bus_to_virt(handle), size, dir);
+}
+
+static inline void
+dma_sync_single_for_device(struct device *dev, dma_addr_t handle, size_t size,
+ enum dma_data_direction dir)
+{
+ if (dmadev_is_sa1111(dev)) {
+ sa1111_dma_sync_single_for_device(dev, handle, size, dir);
return;
}
@@ -289,7 +306,7 @@
}
/**
- * dma_sync_sg
+ * dma_sync_sg_for_cpu
* @dev: valid struct device pointer, or NULL for ISA and EISA-like devices
* @sg: list of buffers
* @nents: number of buffers to map
@@ -298,17 +315,34 @@
* Make physical memory consistent for a set of streaming
* mode DMA translations after a transfer.
*
- * The same as pci_dma_sync_single but for a scatter-gather list,
+ * The same as dma_sync_single_for_* but for a scatter-gather list,
* same rules and usage.
*/
static inline void
-dma_sync_sg(struct device *dev, struct scatterlist *sg, int nents,
- enum dma_data_direction dir)
+dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nents,
+ enum dma_data_direction dir)
+{
+ int i;
+
+ if (dmadev_is_sa1111(dev)) {
+ sa1111_dma_sync_sg_for_cpu(dev, sg, nents, dir);
+ return;
+ }
+
+ for (i = 0; i < nents; i++, sg++) {
+ char *virt = page_address(sg->page) + sg->offset;
+ consistent_sync(virt, sg->length, dir);
+ }
+}
+
+static inline void
+dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nents,
+ enum dma_data_direction dir)
{
int i;
if (dmadev_is_sa1111(dev)) {
- sa1111_dma_sync_sg(dev, sg, nents, dir);
+ sa1111_dma_sync_sg_for_device(dev, sg, nents, dir);
return;
}
diff -Nru a/include/asm-generic/dma-mapping.h b/include/asm-generic/dma-mapping.h
--- a/include/asm-generic/dma-mapping.h Sun Mar 14 10:11:23 2004
+++ b/include/asm-generic/dma-mapping.h Sun Mar 14 10:11:23 2004
@@ -103,21 +103,41 @@
}
static inline void
-dma_sync_single(struct device *dev, dma_addr_t dma_handle, size_t size,
- enum dma_data_direction direction)
+dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
+ enum dma_data_direction direction)
{
BUG_ON(dev->bus != &pci_bus_type);
- pci_dma_sync_single(to_pci_dev(dev), dma_handle, size, (int)direction);
+ pci_dma_sync_single_for_cpu(to_pci_dev(dev), dma_handle,
+ size, (int)direction);
}
static inline void
-dma_sync_sg(struct device *dev, struct scatterlist *sg, int nelems,
- enum dma_data_direction direction)
+dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
+ enum dma_data_direction direction)
{
BUG_ON(dev->bus != &pci_bus_type);
- pci_dma_sync_sg(to_pci_dev(dev), sg, nelems, (int)direction);
+ pci_dma_sync_single_for_device(to_pci_dev(dev), dma_handle,
+ size, (int)direction);
+}
+
+static inline void
+dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
+ enum dma_data_direction direction)
+{
+ BUG_ON(dev->bus != &pci_bus_type);
+
+ pci_dma_sync_sg_for_cpu(to_pci_dev(dev), sg, nelems, (int)direction);
+}
+
+static inline void
+dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
+ enum dma_data_direction direction)
+{
+ BUG_ON(dev->bus != &pci_bus_type);
+
+ pci_dma_sync_sg_for_device(to_pci_dev(dev), sg, nelems, (int)direction);
}
/* Now for the API extensions over the pci_ one */
@@ -135,12 +155,21 @@
}
static inline void
-dma_sync_single_range(struct device *dev, dma_addr_t dma_handle,
- unsigned long offset, size_t size,
- enum dma_data_direction direction)
+dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle,
+ unsigned long offset, size_t size,
+ enum dma_data_direction direction)
+{
+ /* just sync everything, that's all the pci API can do */
+ dma_sync_single_for_cpu(dev, dma_handle, offset+size, direction);
+}
+
+static inline void
+dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle,
+ unsigned long offset, size_t size,
+ enum dma_data_direction direction)
{
/* just sync everything, that's all the pci API can do */
- dma_sync_single(dev, dma_handle, offset+size, direction);
+ dma_sync_single_for_device(dev, dma_handle, offset+size, direction);
}
static inline void
diff -Nru a/include/asm-generic/pci-dma-compat.h b/include/asm-generic/pci-dma-compat.h
--- a/include/asm-generic/pci-dma-compat.h Sun Mar 14 10:11:17 2004
+++ b/include/asm-generic/pci-dma-compat.h Sun Mar 14 10:11:17 2004
@@ -71,17 +71,31 @@
}
static inline void
-pci_dma_sync_single(struct pci_dev *hwdev, dma_addr_t dma_handle,
+pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, dma_addr_t dma_handle,
size_t size, int direction)
{
- dma_sync_single(hwdev == NULL ? NULL : &hwdev->dev, dma_handle, size, (enum dma_data_direction)direction);
+ dma_sync_single_for_cpu(hwdev == NULL ? NULL : &hwdev->dev, dma_handle, size, (enum dma_data_direction)direction);
}
static inline void
-pci_dma_sync_sg(struct pci_dev *hwdev, struct scatterlist *sg,
+pci_dma_sync_single_for_device(struct pci_dev *hwdev, dma_addr_t dma_handle,
+ size_t size, int direction)
+{
+ dma_sync_single_for_device(hwdev == NULL ? NULL : &hwdev->dev, dma_handle, size, (enum dma_data_direction)direction);
+}
+
+static inline void
+pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, struct scatterlist *sg,
+ int nelems, int direction)
+{
+ dma_sync_sg_for_cpu(hwdev == NULL ? NULL : &hwdev->dev, sg, nelems, (enum dma_data_direction)direction);
+}
+
+static inline void
+pci_dma_sync_sg_for_device(struct pci_dev *hwdev, struct scatterlist *sg,
int nelems, int direction)
{
- dma_sync_sg(hwdev == NULL ? NULL : &hwdev->dev, sg, nelems, (enum dma_data_direction)direction);
+ dma_sync_sg_for_device(hwdev == NULL ? NULL : &hwdev->dev, sg, nelems, (enum dma_data_direction)direction);
}
#endif
diff -Nru a/include/asm-i386/dma-mapping.h b/include/asm-i386/dma-mapping.h
--- a/include/asm-i386/dma-mapping.h Sun Mar 14 10:11:24 2004
+++ b/include/asm-i386/dma-mapping.h Sun Mar 14 10:11:24 2004
@@ -70,24 +70,42 @@
}
static inline void
-dma_sync_single(struct device *dev, dma_addr_t dma_handle, size_t size,
- enum dma_data_direction direction)
+dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
+ enum dma_data_direction direction)
+{
+}
+
+static inline void
+dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
+ enum dma_data_direction direction)
{
flush_write_buffers();
}
static inline void
-dma_sync_single_range(struct device *dev, dma_addr_t dma_handle,
- unsigned long offset, size_t size,
- enum dma_data_direction direction)
+dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle,
+ unsigned long offset, size_t size,
+ enum dma_data_direction direction)
+{
+}
+
+static inline void
+dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle,
+ unsigned long offset, size_t size,
+ enum dma_data_direction direction)
{
flush_write_buffers();
}
+static inline void
+dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
+ enum dma_data_direction direction)
+{
+}
static inline void
-dma_sync_sg(struct device *dev, struct scatterlist *sg, int nelems,
- enum dma_data_direction direction)
+dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
+ enum dma_data_direction direction)
{
flush_write_buffers();
}
diff -Nru a/include/asm-i386/pci.h b/include/asm-i386/pci.h
--- a/include/asm-i386/pci.h Sun Mar 14 10:11:18 2004
+++ b/include/asm-i386/pci.h Sun Mar 14 10:11:18 2004
@@ -60,27 +60,32 @@
/* This is always fine. */
#define pci_dac_dma_supported(pci_dev, mask) (1)
-static __inline__ dma64_addr_t
+static inline dma64_addr_t
pci_dac_page_to_dma(struct pci_dev *pdev, struct page *page, unsigned long offset, int direction)
{
return ((dma64_addr_t) page_to_phys(page) +
(dma64_addr_t) offset);
}
-static __inline__ struct page *
+static inline struct page *
pci_dac_dma_to_page(struct pci_dev *pdev, dma64_addr_t dma_addr)
{
return pfn_to_page(dma_addr >> PAGE_SHIFT);
}
-static __inline__ unsigned long
+static inline unsigned long
pci_dac_dma_to_offset(struct pci_dev *pdev, dma64_addr_t dma_addr)
{
return (dma_addr & ~PAGE_MASK);
}
-static __inline__ void
-pci_dac_dma_sync_single(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction)
+static inline void
+pci_dac_dma_sync_single_for_cpu(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction)
+{
+}
+
+static inline void
+pci_dac_dma_sync_single_for_device(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction)
{
flush_write_buffers();
}
diff -Nru a/include/asm-ia64/dma-mapping.h b/include/asm-ia64/dma-mapping.h
--- a/include/asm-ia64/dma-mapping.h Sun Mar 14 10:11:23 2004
+++ b/include/asm-ia64/dma-mapping.h Sun Mar 14 10:11:23 2004
@@ -14,8 +14,10 @@
#define dma_map_sg platform_dma_map_sg
#define dma_unmap_single platform_dma_unmap_single
#define dma_unmap_sg platform_dma_unmap_sg
-#define dma_sync_single platform_dma_sync_single
-#define dma_sync_sg platform_dma_sync_sg
+#define dma_sync_single_for_cpu platform_dma_sync_single_for_cpu
+#define dma_sync_sg_for_cpu platform_dma_sync_sg_for_cpu
+#define dma_sync_single_for_device platform_dma_sync_single_for_device
+#define dma_sync_sg_for_device platform_dma_sync_sg_for_device
#define dma_map_page(dev, pg, off, size, dir) \
dma_map_single(dev, page_address(pg) + (off), (size), (dir))
@@ -27,8 +29,10 @@
* See Documentation/DMA-API.txt for details.
*/
-#define dma_sync_single_range(dev, dma_handle, offset, size, dir) \
- dma_sync_single(dev, dma_handle, size, dir)
+#define dma_sync_single_range_for_cpu(dev, dma_handle, offset, size, dir) \
+ dma_sync_single_for_cpu(dev, dma_handle, size, dir)
+#define dma_sync_single_range_for_device(dev, dma_handle, offset, size, dir) \
+ dma_sync_single_for_device(dev, dma_handle, size, dir)
#define dma_supported platform_dma_supported
diff -Nru a/include/asm-ia64/machvec.h b/include/asm-ia64/machvec.h
--- a/include/asm-ia64/machvec.h Sun Mar 14 10:11:22 2004
+++ b/include/asm-ia64/machvec.h Sun Mar 14 10:11:22 2004
@@ -42,8 +42,10 @@
typedef void ia64_mv_dma_unmap_single (struct device *, dma_addr_t, size_t, int);
typedef int ia64_mv_dma_map_sg (struct device *, struct scatterlist *, int, int);
typedef void ia64_mv_dma_unmap_sg (struct device *, struct scatterlist *, int, int);
-typedef void ia64_mv_dma_sync_single (struct device *, dma_addr_t, size_t, int);
-typedef void ia64_mv_dma_sync_sg (struct device *, struct scatterlist *, int, int);
+typedef void ia64_mv_dma_sync_single_for_cpu (struct device *, dma_addr_t, size_t, int);
+typedef void ia64_mv_dma_sync_sg_for_cpu (struct device *, struct scatterlist *, int, int);
+typedef void ia64_mv_dma_sync_single_for_device (struct device *, dma_addr_t, size_t, int);
+typedef void ia64_mv_dma_sync_sg_for_device (struct device *, struct scatterlist *, int, int);
typedef int ia64_mv_dma_supported (struct device *, u64);
/*
@@ -104,8 +106,10 @@
# define platform_dma_unmap_single ia64_mv.dma_unmap_single
# define platform_dma_map_sg ia64_mv.dma_map_sg
# define platform_dma_unmap_sg ia64_mv.dma_unmap_sg
-# define platform_dma_sync_single ia64_mv.dma_sync_single
-# define platform_dma_sync_sg ia64_mv.dma_sync_sg
+# define platform_dma_sync_single_for_cpu ia64_mv.dma_sync_single_for_cpu
+# define platform_dma_sync_sg_for_cpu ia64_mv.dma_sync_sg_for_cpu
+# define platform_dma_sync_single_for_device ia64_mv.dma_sync_single_for_device
+# define platform_dma_sync_sg_for_device ia64_mv.dma_sync_sg_for_device
# define platform_dma_supported ia64_mv.dma_supported
# define platform_irq_desc ia64_mv.irq_desc
# define platform_irq_to_vector ia64_mv.irq_to_vector
@@ -150,8 +154,10 @@
ia64_mv_dma_unmap_single *dma_unmap_single;
ia64_mv_dma_map_sg *dma_map_sg;
ia64_mv_dma_unmap_sg *dma_unmap_sg;
- ia64_mv_dma_sync_single *dma_sync_single;
- ia64_mv_dma_sync_sg *dma_sync_sg;
+ ia64_mv_dma_sync_single *dma_sync_single_for_cpu;
+ ia64_mv_dma_sync_sg *dma_sync_sg_for_cpu;
+ ia64_mv_dma_sync_single *dma_sync_single_for_device;
+ ia64_mv_dma_sync_sg *dma_sync_sg_for_device;
ia64_mv_dma_supported *dma_supported;
ia64_mv_irq_desc *irq_desc;
ia64_mv_irq_to_vector *irq_to_vector;
@@ -192,8 +198,10 @@
platform_dma_unmap_single, \
platform_dma_map_sg, \
platform_dma_unmap_sg, \
- platform_dma_sync_single, \
- platform_dma_sync_sg, \
+ platform_dma_sync_single_for_cpu, \
+ platform_dma_sync_sg_for_cpu, \
+ platform_dma_sync_single_for_device, \
+ platform_dma_sync_sg_for_device, \
platform_dma_supported, \
platform_irq_desc, \
platform_irq_to_vector, \
@@ -231,8 +239,10 @@
extern ia64_mv_dma_unmap_single swiotlb_unmap_single;
extern ia64_mv_dma_map_sg swiotlb_map_sg;
extern ia64_mv_dma_unmap_sg swiotlb_unmap_sg;
-extern ia64_mv_dma_sync_single swiotlb_sync_single;
-extern ia64_mv_dma_sync_sg swiotlb_sync_sg;
+extern ia64_mv_dma_sync_single_for_cpu swiotlb_sync_single_for_cpu;
+extern ia64_mv_dma_sync_sg_for_cpu swiotlb_sync_sg_for_cpu;
+extern ia64_mv_dma_sync_single_for_device swiotlb_sync_single_for_device;
+extern ia64_mv_dma_sync_sg_for_device swiotlb_sync_sg_for_device;
extern ia64_mv_dma_supported swiotlb_dma_supported;
/*
@@ -290,11 +300,17 @@
#ifndef platform_dma_unmap_sg
# define platform_dma_unmap_sg swiotlb_unmap_sg
#endif
-#ifndef platform_dma_sync_single
-# define platform_dma_sync_single swiotlb_sync_single
+#ifndef platform_dma_sync_single_for_cpu
+# define platform_dma_sync_single_for_cpu swiotlb_sync_single_for_cpu
#endif
-#ifndef platform_dma_sync_sg
-# define platform_dma_sync_sg swiotlb_sync_sg
+#ifndef platform_dma_sync_sg_for_cpu
+# define platform_dma_sync_sg_for_cpu swiotlb_sync_sg_for_cpu
+#endif
+#ifndef platform_dma_sync_single_for_device
+# define platform_dma_sync_single_for_device swiotlb_sync_single_for_device
+#endif
+#ifndef platform_dma_sync_sg_for_device
+# define platform_dma_sync_sg_for_device swiotlb_sync_sg_for_device
#endif
#ifndef platform_dma_supported
# define platform_dma_supported swiotlb_dma_supported
diff -Nru a/include/asm-ia64/machvec_hpzx1.h b/include/asm-ia64/machvec_hpzx1.h
--- a/include/asm-ia64/machvec_hpzx1.h Sun Mar 14 10:11:16 2004
+++ b/include/asm-ia64/machvec_hpzx1.h Sun Mar 14 10:11:16 2004
@@ -26,8 +26,10 @@
#define platform_dma_unmap_single sba_unmap_single
#define platform_dma_map_sg sba_map_sg
#define platform_dma_unmap_sg sba_unmap_sg
-#define platform_dma_sync_single ((ia64_mv_dma_sync_single *) machvec_memory_fence)
-#define platform_dma_sync_sg ((ia64_mv_dma_sync_sg *) machvec_memory_fence)
+#define platform_dma_sync_single_for_cpu ((ia64_mv_dma_sync_single_for_cpu *) machvec_memory_fence)
+#define platform_dma_sync_sg_for_cpu ((ia64_mv_dma_sync_sg_for_cpu *) machvec_memory_fence)
+#define platform_dma_sync_single_for_device ((ia64_mv_dma_sync_single_for_device *) machvec_memory_fence)
+#define platform_dma_sync_sg_for_device ((ia64_mv_dma_sync_sg_for_device *) machvec_memory_fence)
#define platform_dma_supported sba_dma_supported
#endif /* _ASM_IA64_MACHVEC_HPZX1_h */
diff -Nru a/include/asm-ia64/machvec_sn2.h b/include/asm-ia64/machvec_sn2.h
--- a/include/asm-ia64/machvec_sn2.h Sun Mar 14 10:11:18 2004
+++ b/include/asm-ia64/machvec_sn2.h Sun Mar 14 10:11:18 2004
@@ -62,8 +62,10 @@
extern ia64_mv_dma_unmap_single sn_dma_unmap_single;
extern ia64_mv_dma_map_sg sn_dma_map_sg;
extern ia64_mv_dma_unmap_sg sn_dma_unmap_sg;
-extern ia64_mv_dma_sync_single sn_dma_sync_single;
-extern ia64_mv_dma_sync_sg sn_dma_sync_sg;
+extern ia64_mv_dma_sync_single_for_cpu sn_dma_sync_single_for_cpu;
+extern ia64_mv_dma_sync_sg_for_cpu sn_dma_sync_sg_for_cpu;
+extern ia64_mv_dma_sync_single_for_device sn_dma_sync_single_for_device;
+extern ia64_mv_dma_sync_sg_for_device sn_dma_sync_sg_for_device;
extern ia64_mv_dma_supported sn_dma_supported;
/*
@@ -105,8 +107,10 @@
#define platform_dma_unmap_single sn_dma_unmap_single
#define platform_dma_map_sg sn_dma_map_sg
#define platform_dma_unmap_sg sn_dma_unmap_sg
-#define platform_dma_sync_single sn_dma_sync_single
-#define platform_dma_sync_sg sn_dma_sync_sg
+#define platform_dma_sync_single_for_cpu sn_dma_sync_single_for_cpu
+#define platform_dma_sync_sg_for_cpu sn_dma_sync_sg_for_cpu
+#define platform_dma_sync_single_for_device sn_dma_sync_single_for_device
+#define platform_dma_sync_sg_for_device sn_dma_sync_sg_for_device
#define platform_dma_supported sn_dma_supported
#include <asm/sn/sn2/io.h>
diff -Nru a/include/asm-ia64/pci.h b/include/asm-ia64/pci.h
--- a/include/asm-ia64/pci.h Sun Mar 14 10:11:23 2004
+++ b/include/asm-ia64/pci.h Sun Mar 14 10:11:23 2004
@@ -76,7 +76,8 @@
#define pci_dac_page_to_dma(dev,pg,off,dir) ((dma_addr_t) page_to_bus(pg) + (off))
#define pci_dac_dma_to_page(dev,dma_addr) (virt_to_page(bus_to_virt(dma_addr)))
#define pci_dac_dma_to_offset(dev,dma_addr) offset_in_page(dma_addr)
-#define pci_dac_dma_sync_single(dev,dma_addr,len,dir) do { mb(); } while (0)
+#define pci_dac_dma_sync_single_for_cpu(dev,dma_addr,len,dir) do { } while (0)
+#define pci_dac_dma_sync_single_for_device(dev,dma_addr,len,dir) do { mb(); } while (0)
#define sg_dma_len(sg) ((sg)->dma_length)
#define sg_dma_address(sg) ((sg)->dma_address)
diff -Nru a/include/asm-mips/dma-mapping.h b/include/asm-mips/dma-mapping.h
--- a/include/asm-mips/dma-mapping.h Sun Mar 14 10:11:22 2004
+++ b/include/asm-mips/dma-mapping.h Sun Mar 14 10:11:22 2004
@@ -29,11 +29,17 @@
size_t size, enum dma_data_direction direction);
extern void dma_unmap_sg(struct device *dev, struct scatterlist *sg,
int nhwentries, enum dma_data_direction direction);
-extern void dma_sync_single(struct device *dev, dma_addr_t dma_handle,
+extern void dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle,
size_t size, enum dma_data_direction direction);
-extern void dma_sync_single_range(struct device *dev, dma_addr_t dma_handle,
+extern void dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle,
+ size_t size, enum dma_data_direction direction);
+extern void dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle,
+ unsigned long offset, size_t size, enum dma_data_direction direction);
+extern void dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle,
unsigned long offset, size_t size, enum dma_data_direction direction);
-extern void dma_sync_sg(struct device *dev, struct scatterlist *sg, int nelems,
+extern void dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
+ enum dma_data_direction direction);
+extern void dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
enum dma_data_direction direction);
extern int dma_supported(struct device *dev, u64 mask);
diff -Nru a/include/asm-mips/pci.h b/include/asm-mips/pci.h
--- a/include/asm-mips/pci.h Sun Mar 14 10:11:23 2004
+++ b/include/asm-mips/pci.h Sun Mar 14 10:11:23 2004
@@ -82,7 +82,9 @@
dma64_addr_t dma_addr);
extern unsigned long pci_dac_dma_to_offset(struct pci_dev *pdev,
dma64_addr_t dma_addr);
-extern void pci_dac_dma_sync_single(struct pci_dev *pdev,
+extern void pci_dac_dma_sync_single_for_cpu(struct pci_dev *pdev,
+ dma64_addr_t dma_addr, size_t len, int direction);
+extern void pci_dac_dma_sync_single_for_device(struct pci_dev *pdev,
dma64_addr_t dma_addr, size_t len, int direction);
#endif /* __KERNEL__ */
diff -Nru a/include/asm-parisc/dma-mapping.h b/include/asm-parisc/dma-mapping.h
--- a/include/asm-parisc/dma-mapping.h Sun Mar 14 10:11:18 2004
+++ b/include/asm-parisc/dma-mapping.h Sun Mar 14 10:11:18 2004
@@ -15,8 +15,10 @@
void (*unmap_single)(struct device *dev, dma_addr_t iova, size_t size, enum dma_data_direction direction);
int (*map_sg)(struct device *dev, struct scatterlist *sg, int nents, enum dma_data_direction direction);
void (*unmap_sg)(struct device *dev, struct scatterlist *sg, int nhwents, enum dma_data_direction direction);
- void (*dma_sync_single)(struct device *dev, dma_addr_t iova, unsigned long offset, size_t size, enum dma_data_direction direction);
- void (*dma_sync_sg)(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction);
+ void (*dma_sync_single_for_cpu)(struct device *dev, dma_addr_t iova, unsigned long offset, size_t size, enum dma_data_direction direction);
+ void (*dma_sync_single_for_device)(struct device *dev, dma_addr_t iova, unsigned long offset, size_t size, enum dma_data_direction direction);
+ void (*dma_sync_sg_for_cpu)(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction);
+ void (*dma_sync_sg_for_device)(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction);
};
/*
@@ -116,28 +118,53 @@
static inline void
-dma_sync_single(struct device *dev, dma_addr_t dma_handle, size_t size,
+dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
enum dma_data_direction direction)
{
- if(hppa_dma_ops->dma_sync_single)
- hppa_dma_ops->dma_sync_single(dev, dma_handle, 0, size, direction);
+ if(hppa_dma_ops->dma_sync_single_for_cpu)
+ hppa_dma_ops->dma_sync_single_for_cpu(dev, dma_handle, 0, size, direction);
}
static inline void
-dma_sync_single_range(struct device *dev, dma_addr_t dma_handle,
+dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
+ enum dma_data_direction direction)
+{
+ if(hppa_dma_ops->dma_sync_single_for_device)
+ hppa_dma_ops->dma_sync_single_for_device(dev, dma_handle, 0, size, direction);
+}
+
+static inline void
+dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle,
+ unsigned long offset, size_t size,
+ enum dma_data_direction direction)
+{
+ if(hppa_dma_ops->dma_sync_single_for_cpu)
+ hppa_dma_ops->dma_sync_single_for_cpu(dev, dma_handle, offset, size, direction);
+}
+
+static inline void
+dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle,
unsigned long offset, size_t size,
enum dma_data_direction direction)
{
- if(hppa_dma_ops->dma_sync_single)
- hppa_dma_ops->dma_sync_single(dev, dma_handle, offset, size, direction);
+ if(hppa_dma_ops->dma_sync_single_for_device)
+ hppa_dma_ops->dma_sync_single_for_device(dev, dma_handle, offset, size, direction);
+}
+
+static inline void
+dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
+ enum dma_data_direction direction)
+{
+ if(hppa_dma_ops->dma_sync_sg_for_cpu)
+ hppa_dma_ops->dma_sync_sg_for_cpu(dev, sg, nelems, direction);
}
static inline void
-dma_sync_sg(struct device *dev, struct scatterlist *sg, int nelems,
+dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
enum dma_data_direction direction)
{
- if(hppa_dma_ops->dma_sync_sg)
- hppa_dma_ops->dma_sync_sg(dev, sg, nelems, direction);
+ if(hppa_dma_ops->dma_sync_sg_for_device)
+ hppa_dma_ops->dma_sync_sg_for_device(dev, sg, nelems, direction);
}
static inline int
@@ -166,14 +193,14 @@
static inline int
dma_is_consistent(dma_addr_t dma_addr)
{
- return (hppa_dma_ops->dma_sync_single == NULL);
+ return (hppa_dma_ops->dma_sync_single_for_cpu == NULL);
}
static inline void
dma_cache_sync(void *vaddr, size_t size,
enum dma_data_direction direction)
{
- if(hppa_dma_ops->dma_sync_single)
+ if(hppa_dma_ops->dma_sync_single_for_cpu)
flush_kernel_dcache_range((unsigned long)vaddr, size);
}
diff -Nru a/include/asm-ppc/pci.h b/include/asm-ppc/pci.h
--- a/include/asm-ppc/pci.h Sun Mar 14 10:11:23 2004
+++ b/include/asm-ppc/pci.h Sun Mar 14 10:11:23 2004
@@ -91,7 +91,7 @@
* The 32-bit bus address to use is returned.
*
* Once the device is given the dma address, the device owns this memory
- * until either pci_unmap_single or pci_dma_sync_single is performed.
+ * until either pci_unmap_single or pci_dma_sync_single_for_cpu is performed.
*/
static inline dma_addr_t pci_map_single(struct pci_dev *hwdev, void *ptr,
size_t size, int direction)
@@ -190,35 +190,58 @@
* If you perform a pci_map_single() but wish to interrogate the
* buffer using the cpu, yet do not wish to teardown the PCI dma
* mapping, you must call this function before doing so. At the
- * next point you give the PCI dma address back to the card, the
- * device again owns the buffer.
+ * next point you give the PCI dma address back to the card, you
+ * must first perform a pci_dma_sync_for_device, and then the device
+ * again owns the buffer.
*/
-static inline void pci_dma_sync_single(struct pci_dev *hwdev,
- dma_addr_t dma_handle,
- size_t size, int direction)
+static inline void pci_dma_sync_single_for_cpu(struct pci_dev *hwdev,
+ dma_addr_t dma_handle,
+ size_t size, int direction)
{
BUG_ON(direction == PCI_DMA_NONE);
- consistent_sync(bus_to_virt(dma_handle), size, direction);
+ consistent_sync_for_cpu(bus_to_virt(dma_handle), size, direction);
+}
+
+static inline void pci_dma_sync_single_for_device(struct pci_dev *hwdev,
+ dma_addr_t dma_handle,
+ size_t size, int direction)
+{
+ BUG_ON(direction == PCI_DMA_NONE);
+
+ consistent_sync_for_device(bus_to_virt(dma_handle), size, direction);
}
/* Make physical memory consistent for a set of streaming
* mode DMA translations after a transfer.
*
- * The same as pci_dma_sync_single but for a scatter-gather list,
+ * The same as pci_dma_sync_single_for_* but for a scatter-gather list,
* same rules and usage.
*/
-static inline void pci_dma_sync_sg(struct pci_dev *hwdev,
- struct scatterlist *sg,
- int nelems, int direction)
+static inline void pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev,
+ struct scatterlist *sg,
+ int nelems, int direction)
{
int i;
BUG_ON(direction == PCI_DMA_NONE);
for (i = 0; i < nelems; i++, sg++)
- consistent_sync_page(sg->page, sg->offset,
- sg->length, direction);
+ consistent_sync_page_for_cpu(sg->page, sg->offset,
+ sg->length, direction);
+}
+
+static inline void pci_dma_sync_sg_for_device(struct pci_dev *hwdev,
+ struct scatterlist *sg,
+ int nelems, int direction)
+{
+ int i;
+
+ BUG_ON(direction == PCI_DMA_NONE);
+
+ for (i = 0; i < nelems; i++, sg++)
+ consistent_sync_page_for_device(sg->page, sg->offset,
+ sg->length, direction);
}
/* Return whether the given PCI device DMA address mask can
@@ -237,26 +260,32 @@
*/
#define pci_dac_dma_supported(pci_dev, mask) (0)
-static __inline__ dma64_addr_t
+static inline dma64_addr_t
pci_dac_page_to_dma(struct pci_dev *pdev, struct page *page, unsigned long offset, int direction)
{
return (dma64_addr_t) page_to_bus(page) + offset;
}
-static __inline__ struct page *
+static inline struct page *
pci_dac_dma_to_page(struct pci_dev *pdev, dma64_addr_t dma_addr)
{
return mem_map + (unsigned long)(dma_addr >> PAGE_SHIFT);
}
-static __inline__ unsigned long
+static inline unsigned long
pci_dac_dma_to_offset(struct pci_dev *pdev, dma64_addr_t dma_addr)
{
return (dma_addr & ~PAGE_MASK);
}
-static __inline__ void
-pci_dac_dma_sync_single(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction)
+static inline void
+pci_dac_dma_sync_single_for_cpu(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction)
+{
+ /* Nothing to do. */
+}
+
+static inline void
+pci_dac_dma_sync_single_for_device(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction)
{
/* Nothing to do. */
}
diff -Nru a/include/asm-ppc64/pci.h b/include/asm-ppc64/pci.h
--- a/include/asm-ppc64/pci.h Sun Mar 14 10:11:18 2004
+++ b/include/asm-ppc64/pci.h Sun Mar 14 10:11:18 2004
@@ -112,17 +112,33 @@
pci_dma_ops.pci_unmap_sg(hwdev, sg, nents, direction);
}
-static inline void pci_dma_sync_single(struct pci_dev *hwdev,
- dma_addr_t dma_handle,
- size_t size, int direction)
+static inline void pci_dma_sync_single_for_cpu(struct pci_dev *hwdev,
+ dma_addr_t dma_handle,
+ size_t size, int direction)
{
BUG_ON(direction == PCI_DMA_NONE);
/* nothing to do */
}
-static inline void pci_dma_sync_sg(struct pci_dev *hwdev,
- struct scatterlist *sg,
- int nelems, int direction)
+static inline void pci_dma_sync_single_for_device(struct pci_dev *hwdev,
+ dma_addr_t dma_handle,
+ size_t size, int direction)
+{
+ BUG_ON(direction == PCI_DMA_NONE);
+ /* nothing to do */
+}
+
+static inline void pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev,
+ struct scatterlist *sg,
+ int nelems, int direction)
+{
+ BUG_ON(direction == PCI_DMA_NONE);
+ /* nothing to do */
+}
+
+static inline void pci_dma_sync_sg_for_device(struct pci_dev *hwdev,
+ struct scatterlist *sg,
+ int nelems, int direction)
{
BUG_ON(direction == PCI_DMA_NONE);
/* nothing to do */
diff -Nru a/include/asm-sh/pci.h b/include/asm-sh/pci.h
--- a/include/asm-sh/pci.h Sun Mar 14 10:11:23 2004
+++ b/include/asm-sh/pci.h Sun Mar 14 10:11:23 2004
@@ -84,7 +84,7 @@
* The 32-bit bus address to use is returned.
*
* Once the device is given the dma address, the device owns this memory
- * until either pci_unmap_single or pci_dma_sync_single is performed.
+ * until either pci_unmap_single or pci_dma_sync_single_for_cpu is performed.
*/
static inline dma_addr_t pci_map_single(struct pci_dev *hwdev, void *ptr,
size_t size, int direction)
@@ -184,12 +184,21 @@
* If you perform a pci_map_single() but wish to interrogate the
* buffer using the cpu, yet do not wish to teardown the PCI dma
* mapping, you must call this function before doing so. At the
- * next point you give the PCI dma address back to the card, the
- * device again owns the buffer.
- */
-static inline void pci_dma_sync_single(struct pci_dev *hwdev,
- dma_addr_t dma_handle,
- size_t size, int direction)
+ * next point you give the PCI dma address back to the card, you
+ * must first perform a pci_dma_sync_for_device, and then the device
+ * again owns the buffer.
+ */
+static inline void pci_dma_sync_single_for_cpu(struct pci_dev *hwdev,
+ dma_addr_t dma_handle,
+ size_t size, int direction)
+{
+ if (direction == PCI_DMA_NONE)
+ BUG();
+}
+
+static inline void pci_dma_sync_single_for_device(struct pci_dev *hwdev,
+ dma_addr_t dma_handle,
+ size_t size, int direction)
{
if (direction == PCI_DMA_NONE)
BUG();
@@ -203,12 +212,20 @@
/* Make physical memory consistent for a set of streaming
* mode DMA translations after a transfer.
*
- * The same as pci_dma_sync_single but for a scatter-gather list,
+ * The same as pci_dma_sync_single_* but for a scatter-gather list,
* same rules and usage.
*/
-static inline void pci_dma_sync_sg(struct pci_dev *hwdev,
- struct scatterlist *sg,
- int nelems, int direction)
+static inline void pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev,
+ struct scatterlist *sg,
+ int nelems, int direction)
+{
+ if (direction == PCI_DMA_NONE)
+ BUG();
+}
+
+static inline void pci_dma_sync_sg_for_device(struct pci_dev *hwdev,
+ struct scatterlist *sg,
+ int nelems, int direction)
{
if (direction == PCI_DMA_NONE)
BUG();
diff -Nru a/include/asm-sparc/pci.h b/include/asm-sparc/pci.h
--- a/include/asm-sparc/pci.h Sun Mar 14 10:11:23 2004
+++ b/include/asm-sparc/pci.h Sun Mar 14 10:11:23 2004
@@ -52,7 +52,7 @@
* The 32-bit bus address to use is returned.
*
* Once the device is given the dma address, the device owns this memory
- * until either pci_unmap_single or pci_dma_sync_single is performed.
+ * until either pci_unmap_single or pci_dma_sync_single_for_cpu is performed.
*/
extern dma_addr_t pci_map_single(struct pci_dev *hwdev, void *ptr, size_t size, int direction);
@@ -116,18 +116,21 @@
* If you perform a pci_map_single() but wish to interrogate the
* buffer using the cpu, yet do not wish to teardown the PCI dma
* mapping, you must call this function before doing so. At the
- * next point you give the PCI dma address back to the card, the
- * device again owns the buffer.
+ * next point you give the PCI dma address back to the card, you
+ * must first perform a pci_dma_sync_for_device, and then the device
+ * again owns the buffer.
*/
-extern void pci_dma_sync_single(struct pci_dev *hwdev, dma_addr_t dma_handle, size_t size, int direction);
+extern void pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, dma_addr_t dma_handle, size_t size, int direction);
+extern void pci_dma_sync_single_for_device(struct pci_dev *hwdev, dma_addr_t dma_handle, size_t size, int direction);
/* Make physical memory consistent for a set of streaming
* mode DMA translations after a transfer.
*
- * The same as pci_dma_sync_single but for a scatter-gather list,
+ * The same as pci_dma_sync_single_* but for a scatter-gather list,
* same rules and usage.
*/
-extern void pci_dma_sync_sg(struct pci_dev *hwdev, struct scatterlist *sg, int nelems, int direction);
+extern void pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, struct scatterlist *sg, int nelems, int direction);
+extern void pci_dma_sync_sg_for_device(struct pci_dev *hwdev, struct scatterlist *sg, int nelems, int direction);
/* Return whether the given PCI device DMA address mask can
* be supported properly. For example, if your device can
diff -Nru a/include/asm-sparc/sbus.h b/include/asm-sparc/sbus.h
--- a/include/asm-sparc/sbus.h Sun Mar 14 10:11:17 2004
+++ b/include/asm-sparc/sbus.h Sun Mar 14 10:11:17 2004
@@ -118,8 +118,12 @@
extern void sbus_unmap_sg(struct sbus_dev *, struct scatterlist *, int, int);
/* Finally, allow explicit synchronization of streamable mappings. */
-extern void sbus_dma_sync_single(struct sbus_dev *, dma_addr_t, size_t, int);
-extern void sbus_dma_sync_sg(struct sbus_dev *, struct scatterlist *, int, int);
+extern void sbus_dma_sync_single_for_cpu(struct sbus_dev *, dma_addr_t, size_t, int);
+#define sbus_dma_sync_single sbus_dma_sync_single_for_cpu
+extern void sbus_dma_sync_single_for_device(struct sbus_dev *, dma_addr_t, size_t, int);
+extern void sbus_dma_sync_sg_for_cpu(struct sbus_dev *, struct scatterlist *, int, int);
+#define sbus_dma_sync_sg sbus_dma_sync_sg_for_cpu
+extern void sbus_dma_sync_sg_for_device(struct sbus_dev *, struct scatterlist *, int, int);
/* Eric Brower (ebrower@usa.net)
* Translate SBus interrupt levels to ino values--
diff -Nru a/include/asm-sparc64/pci.h b/include/asm-sparc64/pci.h
--- a/include/asm-sparc64/pci.h Sun Mar 14 10:11:17 2004
+++ b/include/asm-sparc64/pci.h Sun Mar 14 10:11:17 2004
@@ -60,7 +60,7 @@
* The 32-bit bus address to use is returned.
*
* Once the device is given the dma address, the device owns this memory
- * until either pci_unmap_single or pci_dma_sync_single is performed.
+ * until either pci_unmap_single or pci_dma_sync_single_for_cpu is performed.
*/
extern dma_addr_t pci_map_single(struct pci_dev *hwdev, void *ptr, size_t size, int direction);
@@ -123,19 +123,36 @@
* If you perform a pci_map_single() but wish to interrogate the
* buffer using the cpu, yet do not wish to teardown the PCI dma
* mapping, you must call this function before doing so. At the
- * next point you give the PCI dma address back to the card, the
+ * next point you give the PCI dma address back to the card, you
+ * must first perform a pci_dma_sync_for_device, and then the
* device again owns the buffer.
*/
-extern void pci_dma_sync_single(struct pci_dev *hwdev, dma_addr_t dma_handle,
- size_t size, int direction);
+extern void pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, dma_addr_t dma_handle,
+ size_t size, int direction);
+
+static inline void
+pci_dma_sync_single_for_device(struct pci_dev *hwdev, dma_addr_t dma_handle,
+ size_t size, int direction)
+{
+ /* No flushing needed to sync cpu writes to the device. */
+ BUG_ON(direction == PCI_DMA_NONE);
+}
/* Make physical memory consistent for a set of streaming
* mode DMA translations after a transfer.
*
- * The same as pci_dma_sync_single but for a scatter-gather list,
+ * The same as pci_dma_sync_single_* but for a scatter-gather list,
* same rules and usage.
*/
-extern void pci_dma_sync_sg(struct pci_dev *hwdev, struct scatterlist *sg, int nelems, int direction);
+extern void pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, struct scatterlist *sg, int nelems, int direction);
+
+static inline void
+pci_dma_sync_sg_for_device(struct pci_dev *hwdev, struct scatterlist *sg,
+ int nelems, int direction)
+{
+ /* No flushing needed to sync cpu writes to the device. */
+ BUG_ON(direction == PCI_DMA_NONE);
+}
/* Return whether the given PCI device DMA address mask can
* be supported properly. For example, if your device can
@@ -159,14 +176,14 @@
#define pci_dac_dma_supported(pci_dev, mask) \
((((mask) & PCI64_REQUIRED_MASK) == PCI64_REQUIRED_MASK) ? 1 : 0)
-static __inline__ dma64_addr_t
+static inline dma64_addr_t
pci_dac_page_to_dma(struct pci_dev *pdev, struct page *page, unsigned long offset, int direction)
{
return (PCI64_ADDR_BASE +
__pa(page_address(page)) + offset);
}
-static __inline__ struct page *
+static inline struct page *
pci_dac_dma_to_page(struct pci_dev *pdev, dma64_addr_t dma_addr)
{
unsigned long paddr = (dma_addr & PAGE_MASK) - PCI64_ADDR_BASE;
@@ -174,14 +191,22 @@
return virt_to_page(__va(paddr));
}
-static __inline__ unsigned long
+static inline unsigned long
pci_dac_dma_to_offset(struct pci_dev *pdev, dma64_addr_t dma_addr)
{
return (dma_addr & ~PAGE_MASK);
}
-static __inline__ void
-pci_dac_dma_sync_single(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction)
+static inline void
+pci_dac_dma_sync_single_for_cpu(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction)
+{
+ /* DAC cycle addressing does not make use of the
+ * PCI controller's streaming cache, so nothing to do.
+ */
+}
+
+static inline void
+pci_dac_dma_sync_single_for_device(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction)
{
/* DAC cycle addressing does not make use of the
* PCI controller's streaming cache, so nothing to do.
diff -Nru a/include/asm-sparc64/sbus.h b/include/asm-sparc64/sbus.h
--- a/include/asm-sparc64/sbus.h Sun Mar 14 10:11:17 2004
+++ b/include/asm-sparc64/sbus.h Sun Mar 14 10:11:17 2004
@@ -111,7 +111,11 @@
extern void sbus_unmap_sg(struct sbus_dev *, struct scatterlist *, int, int);
/* Finally, allow explicit synchronization of streamable mappings. */
-extern void sbus_dma_sync_single(struct sbus_dev *, dma_addr_t, size_t, int);
-extern void sbus_dma_sync_sg(struct sbus_dev *, struct scatterlist *, int, int);
+extern void sbus_dma_sync_single_for_cpu(struct sbus_dev *, dma_addr_t, size_t, int);
+#define sbus_dma_sync_single sbus_dma_sync_single_for_cpu
+extern void sbus_dma_sync_single_for_device(struct sbus_dev *, dma_addr_t, size_t, int);
+extern void sbus_dma_sync_sg_for_cpu(struct sbus_dev *, struct scatterlist *, int, int);
+#define sbus_dma_sync_sg sbus_dma_sync_sg_for_cpu
+extern void sbus_dma_sync_sg_for_device(struct sbus_dev *, struct scatterlist *, int, int);
#endif /* !(_SPARC64_SBUS_H) */
diff -Nru a/include/asm-v850/pci.h b/include/asm-v850/pci.h
--- a/include/asm-v850/pci.h Sun Mar 14 10:11:18 2004
+++ b/include/asm-v850/pci.h Sun Mar 14 10:11:18 2004
@@ -27,7 +27,7 @@
/* `Grant' to PDEV the memory block at CPU_ADDR, for doing DMA. The
32-bit PCI bus mastering address to use is returned. the device owns
- this memory until either pci_unmap_single or pci_dma_sync_single is
+ this memory until either pci_unmap_single or pci_dma_sync_single_for_cpu is
performed. */
extern dma_addr_t
pci_map_single (struct pci_dev *pdev, void *cpu_addr, size_t size, int dir);
@@ -44,10 +44,15 @@
If you perform a pci_map_single() but wish to interrogate the
buffer using the cpu, yet do not wish to teardown the PCI dma
mapping, you must call this function before doing so. At the next
- point you give the PCI dma address back to the card, the device
- again owns the buffer. */
+ point you give the PCI dma address back to the card, you must first
+ perform a pci_dma_sync_for_device, and then the device again owns
+ the buffer. */
extern void
-pci_dma_sync_single (struct pci_dev *dev, dma_addr_t dma_addr, size_t size,
+pci_dma_sync_single_for_cpu (struct pci_dev *dev, dma_addr_t dma_addr, size_t size,
+ int dir);
+
+extern void
+pci_dma_sync_single_for_device (struct pci_dev *dev, dma_addr_t dma_addr, size_t size,
int dir);
diff -Nru a/include/asm-x86_64/pci.h b/include/asm-x86_64/pci.h
--- a/include/asm-x86_64/pci.h Sun Mar 14 10:11:18 2004
+++ b/include/asm-x86_64/pci.h Sun Mar 14 10:11:18 2004
@@ -78,10 +78,18 @@
int dir);
extern void swiotlb_unmap_single (struct device *hwdev, dma_addr_t dev_addr,
size_t size, int dir);
-extern void swiotlb_sync_single (struct device *hwdev, dma_addr_t dev_addr,
- size_t size, int dir);
-extern void swiotlb_sync_sg (struct device *hwdev, struct scatterlist *sg, int nelems,
- int dir);
+extern void swiotlb_sync_single_for_cpu (struct device *hwdev,
+ dma_addr_t dev_addr,
+ size_t size, int dir);
+extern void swiotlb_sync_single_for_device (struct device *hwdev,
+ dma_addr_t dev_addr,
+ size_t size, int dir);
+extern void swiotlb_sync_sg_for_cpu (struct device *hwdev,
+ struct scatterlist *sg, int nelems,
+ int dir);
+extern void swiotlb_sync_sg_for_device (struct device *hwdev,
+ struct scatterlist *sg, int nelems,
+ int dir);
extern int swiotlb_map_sg(struct device *hwdev, struct scatterlist *sg,
int nents, int direction);
extern void swiotlb_unmap_sg(struct device *hwdev, struct scatterlist *sg,
@@ -95,7 +103,7 @@
* The 32-bit bus address to use is returned.
*
* Once the device is given the dma address, the device owns this memory
- * until either pci_unmap_single or pci_dma_sync_single is performed.
+ * until either pci_unmap_single or pci_dma_sync_single_for_cpu is performed.
*/
extern dma_addr_t pci_map_single(struct pci_dev *hwdev, void *ptr, size_t size,
int direction);
@@ -125,29 +133,56 @@
#define pci_unmap_len_set(PTR, LEN_NAME, VAL) \
(((PTR)->LEN_NAME) = (VAL))
-static inline void pci_dma_sync_single(struct pci_dev *hwdev,
- dma_addr_t dma_handle,
- size_t size, int direction)
+static inline void pci_dma_sync_single_for_cpu(struct pci_dev *hwdev,
+ dma_addr_t dma_handle,
+ size_t size, int direction)
{
BUG_ON(direction == PCI_DMA_NONE);
#ifdef CONFIG_SWIOTLB
if (swiotlb)
- return swiotlb_sync_single(&hwdev->dev,dma_handle,size,direction);
+ return swiotlb_sync_single_for_cpu(&hwdev->dev,dma_handle,size,direction);
#endif
flush_write_buffers();
}
-static inline void pci_dma_sync_sg(struct pci_dev *hwdev,
- struct scatterlist *sg,
- int nelems, int direction)
+static inline void pci_dma_sync_single_for_device(struct pci_dev *hwdev,
+ dma_addr_t dma_handle,
+ size_t size, int direction)
+{
+ BUG_ON(direction == PCI_DMA_NONE);
+
+#ifdef CONFIG_SWIOTLB
+ if (swiotlb)
+ return swiotlb_sync_single_for_device(&hwdev->dev,dma_handle,size,direction);
+#endif
+
+ flush_write_buffers();
+}
+
+static inline void pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev,
+ struct scatterlist *sg,
+ int nelems, int direction)
+{
+ BUG_ON(direction == PCI_DMA_NONE);
+
+#ifdef CONFIG_SWIOTLB
+ if (swiotlb)
+ return swiotlb_sync_sg_for_cpu(&hwdev->dev,sg,nelems,direction);
+#endif
+ flush_write_buffers();
+}
+
+static inline void pci_dma_sync_sg_for_device(struct pci_dev *hwdev,
+ struct scatterlist *sg,
+ int nelems, int direction)
{
BUG_ON(direction == PCI_DMA_NONE);
#ifdef CONFIG_SWIOTLB
if (swiotlb)
- return swiotlb_sync_sg(&hwdev->dev,sg,nelems,direction);
+ return swiotlb_sync_sg_for_device(&hwdev->dev,sg,nelems,direction);
#endif
flush_write_buffers();
}
@@ -218,12 +253,21 @@
* If you perform a pci_map_single() but wish to interrogate the
* buffer using the cpu, yet do not wish to teardown the PCI dma
* mapping, you must call this function before doing so. At the
- * next point you give the PCI dma address back to the card, the
+ * next point you give the PCI dma address back to the card, you
+ * must first perform a pci_dma_sync_for_device, and then the
* device again owns the buffer.
*/
-static inline void pci_dma_sync_single(struct pci_dev *hwdev,
- dma_addr_t dma_handle,
- size_t size, int direction)
+static inline void pci_dma_sync_single_for_cpu(struct pci_dev *hwdev,
+ dma_addr_t dma_handle,
+ size_t size, int direction)
+{
+ if (direction == PCI_DMA_NONE)
+ out_of_line_bug();
+}
+
+static inline void pci_dma_sync_single_for_device(struct pci_dev *hwdev,
+ dma_addr_t dma_handle,
+ size_t size, int direction)
{
if (direction == PCI_DMA_NONE)
out_of_line_bug();
@@ -233,12 +277,20 @@
/* Make physical memory consistent for a set of streaming
* mode DMA translations after a transfer.
*
- * The same as pci_dma_sync_single but for a scatter-gather list,
+ * The same as pci_dma_sync_single_* but for a scatter-gather list,
* same rules and usage.
*/
-static inline void pci_dma_sync_sg(struct pci_dev *hwdev,
- struct scatterlist *sg,
- int nelems, int direction)
+static inline void pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev,
+ struct scatterlist *sg,
+ int nelems, int direction)
+{
+ if (direction == PCI_DMA_NONE)
+ out_of_line_bug();
+}
+
+static inline void pci_dma_sync_sg_for_device(struct pci_dev *hwdev,
+ struct scatterlist *sg,
+ int nelems, int direction)
{
if (direction == PCI_DMA_NONE)
out_of_line_bug();
@@ -264,27 +316,32 @@
*/
extern int pci_dma_supported(struct pci_dev *hwdev, u64 mask);
-static __inline__ dma64_addr_t
+static inline dma64_addr_t
pci_dac_page_to_dma(struct pci_dev *pdev, struct page *page, unsigned long offset, int direction)
{
return ((dma64_addr_t) page_to_phys(page) +
(dma64_addr_t) offset);
}
-static __inline__ struct page *
+static inline struct page *
pci_dac_dma_to_page(struct pci_dev *pdev, dma64_addr_t dma_addr)
{
return virt_to_page(__va(dma_addr));
}
-static __inline__ unsigned long
+static inline unsigned long
pci_dac_dma_to_offset(struct pci_dev *pdev, dma64_addr_t dma_addr)
{
return (dma_addr & ~PAGE_MASK);
}
-static __inline__ void
-pci_dac_dma_sync_single(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction)
+static inline void
+pci_dac_dma_sync_single_for_cpu(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction)
+{
+}
+
+static inline void
+pci_dac_dma_sync_single_for_device(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction)
{
flush_write_buffers();
}
diff -Nru a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h
--- a/include/linux/dma-mapping.h Sun Mar 14 10:11:23 2004
+++ b/include/linux/dma-mapping.h Sun Mar 14 10:11:23 2004
@@ -12,6 +12,10 @@
#include <asm/dma-mapping.h>
+/* Backwards compat, remove in 2.7.x */
+#define dma_sync_single dma_sync_single_for_cpu
+#define dma_sync_sg dma_sync_sg_for_cpu
+
#endif
diff -Nru a/include/linux/pci.h b/include/linux/pci.h
--- a/include/linux/pci.h Sun Mar 14 10:11:21 2004
+++ b/include/linux/pci.h Sun Mar 14 10:11:21 2004
@@ -724,6 +724,10 @@
#include <asm/pci.h>
+/* Backwards compat, remove in 2.7.x */
+#define pci_dma_sync_single pci_dma_sync_single_for_cpu
+#define pci_dma_sync_sg pci_dma_sync_sg_for_cpu
+
/*
* If the system does not have PCI, clearly these return errors. Define
* these as simple inline functions to avoid hair in drivers.
diff -Nru a/include/linux/usb.h b/include/linux/usb.h
--- a/include/linux/usb.h Sun Mar 14 10:11:21 2004
+++ b/include/linux/usb.h Sun Mar 14 10:11:21 2004
@@ -830,14 +830,18 @@
void *addr, dma_addr_t dma);
struct urb *usb_buffer_map (struct urb *urb);
+#if 0
void usb_buffer_dmasync (struct urb *urb);
+#endif
void usb_buffer_unmap (struct urb *urb);
struct scatterlist;
int usb_buffer_map_sg (struct usb_device *dev, unsigned pipe,
struct scatterlist *sg, int nents);
+#if 0
void usb_buffer_dmasync_sg (struct usb_device *dev, unsigned pipe,
struct scatterlist *sg, int n_hw_ents);
+#endif
void usb_buffer_unmap_sg (struct usb_device *dev, unsigned pipe,
struct scatterlist *sg, int n_hw_ents);
diff -Nru a/include/linux/usb_gadget.h b/include/linux/usb_gadget.h
--- a/include/linux/usb_gadget.h Sun Mar 14 10:11:21 2004
+++ b/include/linux/usb_gadget.h Sun Mar 14 10:11:21 2004
@@ -117,7 +117,7 @@
void (*free_buffer) (struct usb_ep *ep, void *buf, dma_addr_t dma,
unsigned bytes);
// NOTE: on 2.5, drivers may also use dma_map() and
- // dma_sync_single() to manage dma overhead.
+ // dma_sync_single_*() to manage dma overhead.
int (*queue) (struct usb_ep *ep, struct usb_request *req,
int gfp_flags);
diff -Nru a/include/net/irda/vlsi_ir.h b/include/net/irda/vlsi_ir.h
--- a/include/net/irda/vlsi_ir.h Sun Mar 14 10:11:22 2004
+++ b/include/net/irda/vlsi_ir.h Sun Mar 14 10:11:22 2004
@@ -41,19 +41,6 @@
#define PCI_CLASS_SUBCLASS_MASK 0xffff
#endif
-/* missing pci-dma api call to give streaming dma buffer back to hw
- * patch was floating on lkml around 2.5.2x and might be present later.
- * Defining it this way is ok, since the vlsi-ir is only
- * used on two oldish x86-based notebooks which are cache-coherent
- * (and flush_write_buffers also handles PPro errata and C3 OOstore)
- */
-#ifdef CONFIG_X86
-#include <asm-i386/io.h>
-#define pci_dma_prep_single(dev, addr, size, direction) flush_write_buffers()
-#else
-#error missing pci dma api call
-#endif
-
/* in recent 2.5 interrupt handlers have non-void return value */
#ifndef IRQ_RETVAL
typedef void irqreturn_t;
-
To unsubscribe from this list: send the line "unsubscribe bk-commits-head" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
|
|||||||||||||