Weekly Edition
Return to the Kernel pageSponsored link
Vyatta –
Linux & Open Source
Alternative to Cisco –
Advanced Routing,
Firewall, VPN, QoS..
Free Download ->
| ||||||||||||
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_d | ||||||||||||