From: "David S. Miller" I audited %99 of the drivers, finding crap like: pci_dma_sync_*(); pci_unmap_*(); which makes the DMA sync a total NOP of course. Good cleanup overall and sanitization, so worth the leaf raking of it all :-) --- 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 | 18 ++--- 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, 1464 insertions(+), 551 deletions(-) diff -puN arch/arm/common/sa1111-pcibuf.c~dma_sync_for_device-cpu arch/arm/common/sa1111-pcibuf.c --- 25/arch/arm/common/sa1111-pcibuf.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/arch/arm/common/sa1111-pcibuf.c 2004-03-02 18:15:09.000000000 -0800 @@ -457,8 +457,8 @@ void sa1111_unmap_sg(struct device *dev, 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 @@ void sa1111_dma_sync_single(struct devic 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_map_single); 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 -puN arch/ia64/lib/swiotlb.c~dma_sync_for_device-cpu arch/ia64/lib/swiotlb.c --- 25/arch/ia64/lib/swiotlb.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/arch/ia64/lib/swiotlb.c 2004-03-02 18:15:09.000000000 -0800 @@ -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 @@ swiotlb_unmap_single (struct device *hwd * * 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 @@ swiotlb_unmap_sg (struct device *hwdev, * 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_map_single); 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 -puN arch/ia64/sn/io/machvec/pci_dma.c~dma_sync_for_device-cpu arch/ia64/sn/io/machvec/pci_dma.c --- 25/arch/ia64/sn/io/machvec/pci_dma.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/arch/ia64/sn/io/machvec/pci_dma.c 2004-03-02 18:15:09.000000000 -0800 @@ -437,7 +437,8 @@ sn_pci_unmap_single(struct pci_dev *hwde } /** - * 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 @@ sn_pci_unmap_single(struct pci_dev *hwde * 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 @@ sn_pci_dma_sync_single(struct pci_dev *h * 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 @@ sn_dma_unmap_sg(struct device *dev, stru 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 -puN arch/mips/mm/dma-coherent.c~dma_sync_for_device-cpu arch/mips/mm/dma-coherent.c --- 25/arch/mips/mm/dma-coherent.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/arch/mips/mm/dma-coherent.c 2004-03-02 18:15:09.000000000 -0800 @@ -119,30 +119,55 @@ void dma_unmap_sg(struct device *dev, st 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 @@ unsigned long pci_dac_dma_to_offset(stru 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 -puN arch/mips/mm/dma-ip27.c~dma_sync_for_device-cpu arch/mips/mm/dma-ip27.c --- 25/arch/mips/mm/dma-ip27.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/arch/mips/mm/dma-ip27.c 2004-03-02 18:15:09.000000000 -0800 @@ -125,30 +125,55 @@ void dma_unmap_sg(struct device *dev, st 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 @@ unsigned long pci_dac_dma_to_offset(stru 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 -puN arch/mips/mm/dma-noncoherent.c~dma_sync_for_device-cpu arch/mips/mm/dma-noncoherent.c --- 25/arch/mips/mm/dma-noncoherent.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/arch/mips/mm/dma-noncoherent.c 2004-03-02 18:15:09.000000000 -0800 @@ -226,7 +226,7 @@ void dma_unmap_sg(struct device *dev, st 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 @@ void dma_sync_single(struct device *dev, __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 @@ void dma_sync_single_range(struct device __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 @@ void dma_sync_sg(struct device *dev, str 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 @@ unsigned long pci_dac_dma_to_offset(stru 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 @@ void pci_dac_dma_sync_single(struct pci_ 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 -puN arch/parisc/kernel/pci-dma.c~dma_sync_for_device-cpu arch/parisc/kernel/pci-dma.c --- 25/arch/parisc/kernel/pci-dma.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/arch/parisc/kernel/pci-dma.c 2004-03-02 18:15:09.000000000 -0800 @@ -413,7 +413,7 @@ static void pa11_dma_unmap_single(struct /* * 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 @@ static void pa11_dma_unmap_sg(struct dev 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 @@ static void pa11_dma_sync_single(struct 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 @@ struct hppa_dma_ops pcxl_dma_ops = { .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 @@ struct hppa_dma_ops pcx_dma_ops = { .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 -puN arch/sparc64/kernel/pci_iommu.c~dma_sync_for_device-cpu arch/sparc64/kernel/pci_iommu.c --- 25/arch/sparc64/kernel/pci_iommu.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/arch/sparc64/kernel/pci_iommu.c 2004-03-02 18:15:09.000000000 -0800 @@ -661,7 +661,7 @@ void pci_unmap_sg(struct pci_dev *pdev, /* 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 @@ void pci_dma_sync_single(struct pci_dev /* 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 -puN arch/sparc64/kernel/sbus.c~dma_sync_for_device-cpu arch/sparc64/kernel/sbus.c --- 25/arch/sparc64/kernel/sbus.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/arch/sparc64/kernel/sbus.c 2004-03-02 18:15:09.000000000 -0800 @@ -540,7 +540,7 @@ void sbus_unmap_sg(struct sbus_dev *sdev 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 @@ void sbus_dma_sync_single(struct sbus_de 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; @@ -572,6 +576,10 @@ void sbus_dma_sync_sg(struct sbus_dev *s 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. */ void sbus_set_sbus64(struct sbus_dev *sdev, int bursts) { diff -puN arch/sparc64/kernel/sparc64_ksyms.c~dma_sync_for_device-cpu arch/sparc64/kernel/sparc64_ksyms.c --- 25/arch/sparc64/kernel/sparc64_ksyms.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/arch/sparc64/kernel/sparc64_ksyms.c 2004-03-02 18:15:09.000000000 -0800 @@ -214,8 +214,8 @@ EXPORT_SYMBOL(sbus_map_single); 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); @@ -233,8 +233,8 @@ EXPORT_SYMBOL(pci_map_single); 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 -puN arch/sparc/kernel/ioport.c~dma_sync_for_device-cpu arch/sparc/kernel/ioport.c --- 25/arch/sparc/kernel/ioport.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/arch/sparc/kernel/ioport.c 2004-03-02 18:15:09.000000000 -0800 @@ -360,7 +360,7 @@ void sbus_unmap_sg(struct sbus_dev *sdev /* */ -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 @@ void sbus_dma_sync_single(struct sbus_de #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 @@ void pci_free_consistent(struct pci_dev * 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 @@ void pci_unmap_sg(struct pci_dev *hwdev, * 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 @@ void pci_dma_sync_single(struct pci_dev /* 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 -puN arch/sparc/kernel/sparc_ksyms.c~dma_sync_for_device-cpu arch/sparc/kernel/sparc_ksyms.c --- 25/arch/sparc/kernel/sparc_ksyms.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/arch/sparc/kernel/sparc_ksyms.c 2004-03-02 18:15:09.000000000 -0800 @@ -206,8 +206,10 @@ EXPORT_SYMBOL(sbus_map_single); 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 @@ -219,7 +221,10 @@ EXPORT_SYMBOL(pci_alloc_consistent); 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 -puN arch/v850/kernel/rte_mb_a_pci.c~dma_sync_for_device-cpu arch/v850/kernel/rte_mb_a_pci.c --- 25/arch/v850/kernel/rte_mb_a_pci.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/arch/v850/kernel/rte_mb_a_pci.c 2004-03-02 18:15:09.000000000 -0800 @@ -687,10 +687,11 @@ void pci_unmap_single (struct pci_dev *p 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 @@ pci_dma_sync_single (struct pci_dev *pde 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 @@ pci_unmap_sg (struct pci_dev *pdev, stru } /* 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_map_single); 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 -puN Documentation/DMA-mapping.txt~dma_sync_for_device-cpu Documentation/DMA-mapping.txt --- 25/Documentation/DMA-mapping.txt~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/Documentation/DMA-mapping.txt 2004-03-02 18:15:09.000000000 -0800 @@ -283,7 +283,7 @@ There are two types of DMA mappings: 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 @@ same bus address space) and you could re 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 @@ to use the pci_dma_sync_*() interfaces. * 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 @@ to use the pci_dma_sync_*() interfaces. 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 @@ interfaces. To reiterate: 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 -puN drivers/atm/fore200e.c~dma_sync_for_device-cpu drivers/atm/fore200e.c --- 25/drivers/atm/fore200e.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/atm/fore200e.c 2004-03-02 18:15:09.000000000 -0800 @@ -482,11 +482,19 @@ fore200e_pca_dma_unmap(struct fore200e* 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 @@ fore200e_sba_dma_unmap(struct fore200e* 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 @@ fore200e_push_rpd(struct fore200e* fore2 /* 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 @@ fore200e_send(struct atm_vcc *vcc, struc 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 @@ static const struct fore200e_bus fore200 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 @@ static const struct fore200e_bus fore200 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 -puN drivers/atm/fore200e.h~dma_sync_for_device-cpu drivers/atm/fore200e.h --- 25/drivers/atm/fore200e.h~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/atm/fore200e.h 2004-03-02 18:15:09.000000000 -0800 @@ -801,7 +801,8 @@ typedef struct fore200e_bus { 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 -puN drivers/atm/idt77252.c~dma_sync_for_device-cpu drivers/atm/idt77252.c --- 25/drivers/atm/idt77252.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/atm/idt77252.c 2004-03-02 18:15:09.000000000 -0800 @@ -1064,8 +1064,8 @@ dequeue_rx(struct idt77252_dev *card, st 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)) { @@ -1903,6 +1903,9 @@ recycle_rx_skb(struct idt77252_dev *card 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) { pci_unmap_single(card->pcidev, IDT77252_PRV_PADDR(skb), diff -puN drivers/ieee1394/dma.c~dma_sync_for_device-cpu drivers/ieee1394/dma.c --- 25/drivers/ieee1394/dma.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/ieee1394/dma.c 2004-03-02 18:15:09.000000000 -0800 @@ -168,7 +168,7 @@ dma_addr_t dma_region_offset_to_bus(stru 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 @@ void dma_region_sync(struct dma_region * 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 -puN drivers/ieee1394/dma.h~dma_sync_for_device-cpu drivers/ieee1394/dma.h --- 25/drivers/ieee1394/dma.h~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/ieee1394/dma.h 2004-03-02 18:15:09.000000000 -0800 @@ -60,8 +60,10 @@ int dma_region_alloc(struct dma_region /* 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 -puN drivers/ieee1394/dv1394.c~dma_sync_for_device-cpu drivers/ieee1394/dv1394.c --- 25/drivers/ieee1394/dv1394.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/ieee1394/dv1394.c 2004-03-02 18:15:09.000000000 -0800 @@ -553,7 +553,7 @@ static void frame_prepare(struct video_c *(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 @@ static void ir_tasklet_func(unsigned lon 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 -puN drivers/ieee1394/ieee1394_core.c~dma_sync_for_device-cpu drivers/ieee1394/ieee1394_core.c --- 25/drivers/ieee1394/ieee1394_core.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/ieee1394/ieee1394_core.c 2004-03-02 18:15:09.000000000 -0800 @@ -1201,7 +1201,8 @@ EXPORT_SYMBOL(dma_prog_region_free); 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 -puN drivers/ieee1394/ohci1394.c~dma_sync_for_device-cpu drivers/ieee1394/ohci1394.c --- 25/drivers/ieee1394/ohci1394.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/ieee1394/ohci1394.c 2004-03-02 18:15:09.000000000 -0800 @@ -1732,7 +1732,7 @@ static void ohci_iso_recv_bufferfill_tas /* 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 @@ static void ohci_iso_recv_packetperbuf_t } /* 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 @@ static int ohci_iso_xmit_queue(struct hp 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 -puN drivers/ieee1394/sbp2.c~dma_sync_for_device-cpu drivers/ieee1394/sbp2.c --- 25/drivers/ieee1394/sbp2.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/ieee1394/sbp2.c 2004-03-02 18:15:09.000000000 -0800 @@ -1948,12 +1948,12 @@ static int sbp2_link_orb_command(struct 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 @@ static int sbp2_link_orb_command(struct 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 @@ static int sbp2_handle_status_write(stru 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 @@ static void sbp2scsi_complete_all_comman 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 @@ static int sbp2scsi_abort (Scsi_Cmnd *SC 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 -puN drivers/media/video/video-buf.c~dma_sync_for_device-cpu drivers/media/video/video-buf.c --- 25/drivers/media/video/video-buf.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/media/video/video-buf.c 2004-03-02 18:15:09.000000000 -0800 @@ -215,7 +215,7 @@ int videobuf_dma_pci_sync(struct pci_dev 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 -puN drivers/message/fusion/mptlan.c~dma_sync_for_device-cpu drivers/message/fusion/mptlan.c --- 25/drivers/message/fusion/mptlan.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/message/fusion/mptlan.c 2004-03-02 18:15:09.000000000 -0800 @@ -955,11 +955,13 @@ mpt_lan_receive_post_turbo(struct net_de 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; } @@ -1113,12 +1115,17 @@ mpt_lan_receive_post_reply(struct net_de // 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; } @@ -1136,11 +1143,18 @@ mpt_lan_receive_post_reply(struct net_de 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; spin_unlock_irqrestore(&priv->rxfidx_lock, flags); diff -puN drivers/message/i2o/i2o_core.c~dma_sync_for_device-cpu drivers/message/i2o/i2o_core.c --- 25/drivers/message/i2o/i2o_core.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/message/i2o/i2o_core.c 2004-03-02 18:15:09.000000000 -0800 @@ -1177,7 +1177,7 @@ void i2o_run_queue(struct i2o_controller * 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 -puN drivers/net/3c59x.c~dma_sync_for_device-cpu drivers/net/3c59x.c --- 25/drivers/net/3c59x.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/3c59x.c 2004-03-02 18:15:09.000000000 -0800 @@ -2577,11 +2577,12 @@ boomerang_rx(struct net_device *dev) 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 -puN drivers/net/b44.c~dma_sync_for_device-cpu drivers/net/b44.c --- 25/drivers/net/b44.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/b44.c 2004-03-02 18:15:09.000000000 -0800 @@ -667,6 +667,10 @@ static void b44_recycle_rx(struct b44 *b 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 @@ static int b44_rx(struct b44 *bp, int bu 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 -puN drivers/net/dl2k.c~dma_sync_for_device-cpu drivers/net/dl2k.c --- 25/drivers/net/dl2k.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/dl2k.c 2004-03-02 18:15:09.000000000 -0800 @@ -874,8 +874,6 @@ receive_packet (struct net_device *dev) 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 @@ receive_packet (struct net_device *dev) 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 @@ receive_packet (struct net_device *dev) 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 -puN drivers/net/e1000/e1000_ethtool.c~dma_sync_for_device-cpu drivers/net/e1000/e1000_ethtool.c --- 25/drivers/net/e1000/e1000_ethtool.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/e1000/e1000_ethtool.c 2004-03-02 18:15:09.000000000 -0800 @@ -1191,16 +1191,16 @@ e1000_run_loopback_test(struct e1000_ada 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 -puN drivers/net/e100.c~dma_sync_for_device-cpu drivers/net/e100.c --- 25/drivers/net/e100.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/e100.c 2004-03-02 18:15:09.000000000 -0800 @@ -1386,8 +1386,8 @@ static inline int e100_rx_alloc_skb(stru (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; @@ -1404,8 +1404,8 @@ static inline int e100_rx_indicate(struc 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); @@ -1420,11 +1420,8 @@ static inline int e100_rx_indicate(struc 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 -puN drivers/net/eepro100.c~dma_sync_for_device-cpu drivers/net/eepro100.c --- 25/drivers/net/eepro100.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/eepro100.c 2004-03-02 18:15:09.000000000 -0800 @@ -1326,8 +1326,8 @@ speedo_init_rx_ring(struct net_device *d 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 @@ speedo_init_rx_ring(struct net_device *d /* 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 @@ static inline struct RxFD *speedo_rx_all 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 @@ static inline void speedo_rx_link(struct 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 @@ speedo_rx(struct net_device *dev) 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 @@ speedo_rx(struct net_device *dev) 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 @@ speedo_rx(struct net_device *dev) 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 @@ speedo_rx(struct net_device *dev) 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 @@ static void set_rx_mode(struct net_devic 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 -puN drivers/net/epic100.c~dma_sync_for_device-cpu drivers/net/epic100.c --- 25/drivers/net/epic100.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/epic100.c 2004-03-02 18:15:09.000000000 -0800 @@ -1199,8 +1199,6 @@ static int epic_rx(struct net_device *de 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 @@ static int epic_rx(struct net_device *de && (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 @@ static int epic_rx(struct net_device *de 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 -puN drivers/net/fealnx.c~dma_sync_for_device-cpu drivers/net/fealnx.c --- 25/drivers/net/fealnx.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/fealnx.c 2004-03-02 18:15:09.000000000 -0800 @@ -1647,10 +1647,6 @@ static int netdev_rx(struct net_device * 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 @@ static int netdev_rx(struct net_device * (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 @@ static int netdev_rx(struct net_device * 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 @@ static int netdev_rx(struct net_device * 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 -puN drivers/net/hamachi.c~dma_sync_for_device-cpu drivers/net/hamachi.c --- 25/drivers/net/hamachi.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/hamachi.c 2004-03-02 18:15:09.000000000 -0800 @@ -1498,8 +1498,10 @@ static int hamachi_rx(struct net_device 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 @@ static int hamachi_rx(struct net_device #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 @@ static int hamachi_rx(struct net_device 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 -puN drivers/net/irda/vlsi_ir.c~dma_sync_for_device-cpu drivers/net/irda/vlsi_ir.c --- 25/drivers/net/irda/vlsi_ir.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/irda/vlsi_ir.c 2004-03-02 18:15:09.000000000 -0800 @@ -173,7 +173,7 @@ static int vlsi_proc_pdev(struct pci_dev 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 @@ static struct vlsi_ring *vlsi_alloc_ring 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 @@ static int vlsi_process_rx(struct vlsi_r 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 @@ static void vlsi_fill_rx(struct vlsi_rin 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 @@ static void vlsi_unarm_rx(vlsi_irda_dev_ 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 @@ static int vlsi_process_tx(struct vlsi_r 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 @@ static int vlsi_hard_start_xmit(struct s } } - /* 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 @@ static int vlsi_hard_start_xmit(struct s * 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 @@ static void vlsi_unarm_tx(vlsi_irda_dev_ 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 -puN drivers/net/lasi_82596.c~dma_sync_for_device-cpu drivers/net/lasi_82596.c --- 25/drivers/net/lasi_82596.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/lasi_82596.c 2004-03-02 18:15:09.000000000 -0800 @@ -802,9 +802,10 @@ memory_squeeze: 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 -puN drivers/net/myri_sbus.c~dma_sync_for_device-cpu drivers/net/myri_sbus.c --- 25/drivers/net/myri_sbus.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/myri_sbus.c 2004-03-02 18:15:09.000000000 -0800 @@ -435,9 +435,9 @@ static void myri_rx(struct myri_eth *mp, /* 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 @@ static void myri_rx(struct myri_eth *mp, 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 @@ static void myri_rx(struct myri_eth *mp, /* 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 -puN drivers/net/natsemi.c~dma_sync_for_device-cpu drivers/net/natsemi.c --- 25/drivers/net/natsemi.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/natsemi.c 2004-03-02 18:15:09.000000000 -0800 @@ -1789,7 +1789,7 @@ static void netdev_rx(struct net_device 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 @@ static void netdev_rx(struct net_device 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 -puN drivers/net/pcnet32.c~dma_sync_for_device-cpu drivers/net/pcnet32.c --- 25/drivers/net/pcnet32.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/pcnet32.c 2004-03-02 18:15:09.000000000 -0800 @@ -1744,13 +1744,17 @@ pcnet32_rx(struct net_device *dev) 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 -puN drivers/net/rrunner.c~dma_sync_for_device-cpu drivers/net/rrunner.c --- 25/drivers/net/rrunner.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/rrunner.c 2004-03-02 18:15:09.000000000 -0800 @@ -983,18 +983,26 @@ static void rx_int(struct net_device *de 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 -puN drivers/net/sis190.c~dma_sync_for_device-cpu drivers/net/sis190.c --- 25/drivers/net/sis190.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/sis190.c 2004-03-02 18:15:09.000000000 -0800 @@ -1016,14 +1016,20 @@ SiS190_rx_interrupt(struct net_device *d 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 -puN drivers/net/sis900.c~dma_sync_for_device-cpu drivers/net/sis900.c --- 25/drivers/net/sis900.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/sis900.c 2004-03-02 18:15:09.000000000 -0800 @@ -1650,9 +1650,6 @@ static int sis900_rx(struct net_device * 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 -puN drivers/net/sk98lin/skge.c~dma_sync_for_device-cpu drivers/net/sk98lin/skge.c --- 25/drivers/net/sk98lin/skge.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/sk98lin/skge.c 2004-03-02 18:15:09.000000000 -0800 @@ -2533,12 +2533,6 @@ rx_start: "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 @@ rx_start: 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 -puN drivers/net/starfire.c~dma_sync_for_device-cpu drivers/net/starfire.c --- 25/drivers/net/starfire.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/starfire.c 2004-03-02 18:15:09.000000000 -0800 @@ -1637,10 +1637,13 @@ static int __netdev_rx(struct net_device && (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 -puN drivers/net/sunbmac.c~dma_sync_for_device-cpu drivers/net/sunbmac.c --- 25/drivers/net/sunbmac.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/sunbmac.c 2004-03-02 18:15:09.000000000 -0800 @@ -849,9 +849,13 @@ static void bigmac_rx(struct bigmac *bp) 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 -puN drivers/net/sundance.c~dma_sync_for_device-cpu drivers/net/sundance.c --- 25/drivers/net/sundance.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/sundance.c 2004-03-02 18:15:09.000000000 -0800 @@ -1331,9 +1331,6 @@ static void rx_poll(unsigned long data) 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 @@ static void rx_poll(unsigned long data) && (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 -puN drivers/net/sungem.c~dma_sync_for_device-cpu drivers/net/sungem.c --- 25/drivers/net/sungem.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/sungem.c 2004-03-02 18:15:09.000000000 -0800 @@ -763,8 +763,9 @@ static void gem_rx(struct gem *gp) 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 -puN drivers/net/sunhme.c~dma_sync_for_device-cpu drivers/net/sunhme.c --- 25/drivers/net/sunhme.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/sunhme.c 2004-03-02 18:15:09.000000000 -0800 @@ -273,8 +273,10 @@ static u32 pci_hme_read_desc32(u32 *p) ((__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 @@ do { (__txd)->tx_addr = (__addr); \ 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 @@ do { (__txd)->tx_addr = cpu_to_le32(__ad 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 @@ static void happy_meal_rx(struct happy_m 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 @@ static int __init happy_meal_sbus_init(s 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 @@ static int __init happy_meal_pci_init(st 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 -puN drivers/net/sunhme.h~dma_sync_for_device-cpu drivers/net/sunhme.h --- 25/drivers/net/sunhme.h~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/sunhme.h 2004-03-02 18:15:09.000000000 -0800 @@ -406,7 +406,8 @@ struct happy_meal { 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 -puN drivers/net/tg3.c~dma_sync_for_device-cpu drivers/net/tg3.c --- 25/drivers/net/tg3.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/tg3.c 2004-03-02 18:15:09.000000000 -0800 @@ -2327,8 +2327,9 @@ static int tg3_rx(struct tg3 *tp, int bu 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 -puN drivers/net/tokenring/3c359.c~dma_sync_for_device-cpu drivers/net/tokenring/3c359.c --- 25/drivers/net/tokenring/3c359.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/tokenring/3c359.c 2004-03-02 18:15:09.000000000 -0800 @@ -937,15 +937,17 @@ static void xl_rx(struct net_device *dev 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 -puN drivers/net/tokenring/olympic.c~dma_sync_for_device-cpu drivers/net/tokenring/olympic.c --- 25/drivers/net/tokenring/olympic.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/tokenring/olympic.c 2004-03-02 18:15:09.000000000 -0800 @@ -842,10 +842,13 @@ static void olympic_rx(struct net_device 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 @@ static void olympic_rx(struct net_device 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 -puN drivers/net/tulip/de2104x.c~dma_sync_for_device-cpu drivers/net/tulip/de2104x.c --- 25/drivers/net/tulip/de2104x.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/tulip/de2104x.c 2004-03-02 18:15:09.000000000 -0800 @@ -457,10 +457,12 @@ static void de_rx (struct de_private *de 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 -puN drivers/net/tulip/interrupt.c~dma_sync_for_device-cpu drivers/net/tulip/interrupt.c --- 25/drivers/net/tulip/interrupt.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/tulip/interrupt.c 2004-03-02 18:15:09.000000000 -0800 @@ -191,9 +191,9 @@ int tulip_poll(struct net_device *dev, i && (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 @@ int tulip_poll(struct net_device *dev, i 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 @@ static int tulip_rx(struct net_device *d && (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 @@ static int tulip_rx(struct net_device *d 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 -puN drivers/net/tulip/winbond-840.c~dma_sync_for_device-cpu drivers/net/tulip/winbond-840.c --- 25/drivers/net/tulip/winbond-840.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/tulip/winbond-840.c 2004-03-02 18:15:09.000000000 -0800 @@ -1289,9 +1289,9 @@ static int netdev_rx(struct net_device * && (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 @@ static int netdev_rx(struct net_device * 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 -puN drivers/net/typhoon.c~dma_sync_for_device-cpu drivers/net/typhoon.c --- 25/drivers/net/typhoon.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/typhoon.c 2004-03-02 18:15:09.000000000 -0800 @@ -1701,9 +1701,13 @@ typhoon_rx(struct typhoon *tp, struct ba (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 -puN drivers/net/via-rhine.c~dma_sync_for_device-cpu drivers/net/via-rhine.c --- 25/drivers/net/via-rhine.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/via-rhine.c 2004-03-02 18:15:09.000000000 -0800 @@ -1536,7 +1536,7 @@ static void via_rhine_rx(struct net_devi (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 @@ static void via_rhine_rx(struct net_devi 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 -puN drivers/net/wan/dscc4.c~dma_sync_for_device-cpu drivers/net/wan/dscc4.c --- 25/drivers/net/wan/dscc4.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/wan/dscc4.c 2004-03-02 18:15:09.000000000 -0800 @@ -652,7 +652,6 @@ static inline void dscc4_rx_skb(struct d 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 -puN drivers/net/yellowfin.c~dma_sync_for_device-cpu drivers/net/yellowfin.c --- 25/drivers/net/yellowfin.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/net/yellowfin.c 2004-03-02 18:15:09.000000000 -0800 @@ -1124,7 +1124,7 @@ static int yellowfin_rx(struct net_devic 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 @@ static int yellowfin_rx(struct net_devic 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 -puN drivers/parisc/ccio-dma.c~dma_sync_for_device-cpu drivers/parisc/ccio-dma.c --- 25/drivers/parisc/ccio-dma.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/parisc/ccio-dma.c 2004-03-02 18:15:09.000000000 -0800 @@ -1149,8 +1149,10 @@ static struct hppa_dma_ops ccio_ops = { .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 -puN drivers/parisc/ccio-rm-dma.c~dma_sync_for_device-cpu drivers/parisc/ccio-rm-dma.c --- 25/drivers/parisc/ccio-rm-dma.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/parisc/ccio-rm-dma.c 2004-03-02 18:15:09.000000000 -0800 @@ -151,8 +151,10 @@ static struct pci_dma_ops ccio_ops = { 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 -puN drivers/parisc/sba_iommu.c~dma_sync_for_device-cpu drivers/parisc/sba_iommu.c --- 25/drivers/parisc/sba_iommu.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/parisc/sba_iommu.c 2004-03-02 18:15:09.000000000 -0800 @@ -1410,8 +1410,10 @@ static struct hppa_dma_ops sba_ops = { .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 -puN drivers/scsi/53c700.c~dma_sync_for_device-cpu drivers/scsi/53c700.c --- 25/drivers/scsi/53c700.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/scsi/53c700.c 2004-03-02 18:15:09.000000000 -0800 @@ -321,7 +321,7 @@ NCR_700_detect(Scsi_Host_Template *tpnt, 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; @@ -982,8 +982,8 @@ process_script_interrupt(__u32 dsps, __u 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)); @@ -1007,7 +1007,7 @@ process_script_interrupt(__u32 dsps, __u // 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 -puN drivers/scsi/dc395x.c~dma_sync_for_device-cpu drivers/scsi/dc395x.c --- 25/drivers/scsi/dc395x.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/scsi/dc395x.c 2004-03-02 18:15:09.000000000 -0800 @@ -2419,13 +2419,13 @@ static void update_sg_list(struct ScsiRe psge->length -= xferred; /* residue data length */ psge->address += xferred; /* residue data pointer */ srb->sg_index = idx; - pci_dma_sync_single(srb->dcb-> - acb->dev, - srb->sg_bus_addr, - sizeof(struct SGentry) - * - DC395x_MAX_SG_LISTENTRY, - PCI_DMA_TODEVICE); + pci_dma_sync_single_for_device(srb->dcb-> + acb->dev, + srb->sg_bus_addr, + sizeof(struct SGentry) + * + DC395x_MAX_SG_LISTENTRY, + PCI_DMA_TODEVICE); break; } psge++; @@ -4298,11 +4298,11 @@ void srb_done(struct AdapterCtlBlk *acb, 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 -puN drivers/scsi/eata.c~dma_sync_for_device-cpu drivers/scsi/eata.c --- 25/drivers/scsi/eata.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/scsi/eata.c 2004-03-02 18:15:09.000000000 -0800 @@ -1598,17 +1598,17 @@ static void sync_dma(unsigned int i, uns 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 -puN drivers/scsi/megaraid.c~dma_sync_for_device-cpu drivers/scsi/megaraid.c --- 25/drivers/scsi/megaraid.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/scsi/megaraid.c 2004-03-02 18:15:09.000000000 -0800 @@ -261,10 +261,6 @@ mega_query_adapter(adapter_t *adapter) "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 @@ mega_free_scb(adapter_t *adapter, scb_t 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 @@ mega_build_sglist(adapter_t *adapter, sc *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; } @@ -1804,11 +1777,6 @@ mega_build_sglist(adapter_t *adapter, sc */ *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 -puN drivers/scsi/ncr53c8xx.c~dma_sync_for_device-cpu drivers/scsi/ncr53c8xx.c --- 25/drivers/scsi/ncr53c8xx.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/scsi/ncr53c8xx.c 2004-03-02 18:15:09.000000000 -0800 @@ -5140,9 +5140,10 @@ void ncr_complete (ncb_p np, ccb_p cp) */ 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 -puN drivers/scsi/sym53c8xx_2/sym_glue.c~dma_sync_for_device-cpu drivers/scsi/sym53c8xx_2/sym_glue.c --- 25/drivers/scsi/sym53c8xx_2/sym_glue.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/scsi/sym53c8xx_2/sym_glue.c 2004-03-02 18:15:09.000000000 -0800 @@ -212,17 +212,32 @@ static int __map_scsi_sg_data(struct pci 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 @@ static void __sync_scsi_data(struct pci_ __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 @@ void sym_sniff_inquiry(struct sym_hcb *n 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 -puN drivers/scsi/sym53c8xx_comm.h~dma_sync_for_device-cpu drivers/scsi/sym53c8xx_comm.h --- 25/drivers/scsi/sym53c8xx_comm.h~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/scsi/sym53c8xx_comm.h 2004-03-02 18:15:09.000000000 -0800 @@ -703,7 +703,8 @@ static m_addr_t __vtobus(m_bush_t bush, #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 @@ static int __map_scsi_sg_data(struct dev 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 @@ static void __sync_scsi_data(struct devi #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 -puN drivers/scsi/u14-34f.c~dma_sync_for_device-cpu drivers/scsi/u14-34f.c --- 25/drivers/scsi/u14-34f.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/scsi/u14-34f.c 2004-03-02 18:15:09.000000000 -0800 @@ -1184,17 +1184,17 @@ static void sync_dma(unsigned int i, uns 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 -puN drivers/usb/core/usb.c~dma_sync_for_device-cpu drivers/usb/core/usb.c --- 25/drivers/usb/core/usb.c~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/drivers/usb/core/usb.c 2004-03-02 18:15:09.000000000 -0800 @@ -1297,6 +1297,13 @@ struct urb *usb_buffer_map (struct urb * 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 @@ void usb_buffer_dmasync (struct urb *urb DMA_TO_DEVICE); } } +#endif /** * usb_buffer_unmap - free DMA mapping(s) for an urb @@ -1403,6 +1411,13 @@ int usb_buffer_map_sg (struct usb_device 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 @@ void usb_buffer_dmasync_sg (struct usb_d 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_alloc); 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 -puN include/asm-alpha/pci.h~dma_sync_for_device-cpu include/asm-alpha/pci.h --- 25/include/asm-alpha/pci.h~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/include/asm-alpha/pci.h 2004-03-02 18:15:09.000000000 -0800 @@ -88,7 +88,7 @@ extern void pci_free_consistent(struct p /* 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 int pci_map_sg(struct pci_dev *, 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_for_cpu(struct pci_dev *dev, struct scatterlist *sg, int nents, + int direction) +{ + /* Nothing to do. */ +} static inline void -pci_dma_sync_sg(struct pci_dev *dev, struct scatterlist *sg, int nents, - int direction) +pci_dma_sync_sg_for_device(struct pci_dev *dev, struct scatterlist *sg, int nents, + int direction) { /* Nothing to do. */ } @@ -184,8 +200,14 @@ extern dma64_addr_t pci_dac_page_to_dma( extern struct page *pci_dac_dma_to_page(struct pci_dev *, dma64_addr_t); extern unsigned long pci_dac_dma_to_offset(struct pci_dev *, dma64_addr_t); -static __inline__ void -pci_dac_dma_sync_single(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction) +static inline void +pci_dac_dma_sync_single_for_cpu(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction) +{ + /* Nothing to do. */ +} + +static inline void +pci_dac_dma_sync_single_for_device(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction) { /* Nothing to do. */ } diff -puN include/asm-arm/dma-mapping.h~dma_sync_for_device-cpu include/asm-arm/dma-mapping.h --- 25/include/asm-arm/dma-mapping.h~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/include/asm-arm/dma-mapping.h 2004-03-02 18:15:09.000000000 -0800 @@ -26,8 +26,10 @@ dma_addr_t sa1111_map_single(struct devi void sa1111_unmap_single(struct device *dev, dma_addr_t, size_t, enum dma_data_direction); int sa1111_map_sg(struct device *dev, struct scatterlist *, int, enum dma_data_direction); void sa1111_unmap_sg(struct device *dev, struct scatterlist *, int, enum dma_data_direction); -void sa1111_dma_sync_single(struct device *dev, dma_addr_t, size_t, enum dma_data_direction); -void sa1111_dma_sync_sg(struct device *dev, struct scatterlist *, int, enum dma_data_direction); +void sa1111_dma_sync_single_for_cpu(struct device *dev, dma_addr_t, size_t, enum dma_data_direction); +void sa1111_dma_sync_single_for_device(struct device *dev, dma_addr_t, size_t, enum dma_data_direction); +void sa1111_dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *, int, enum dma_data_direction); +void sa1111_dma_sync_sg_for_device(struct device *dev, struct scatterlist *, int, enum dma_data_direction); #ifdef CONFIG_SA1111 @@ -115,7 +117,8 @@ dma_free_coherent(struct device *dev, si * or written back. * * The device owns this memory once this call has completed. The CPU - * can regain ownership by calling dma_unmap_single() or dma_sync_single(). + * can regain ownership by calling dma_unmap_single() or + * dma_sync_single_for_cpu(). */ static inline dma_addr_t dma_map_single(struct device *dev, void *cpu_addr, size_t size, @@ -140,7 +143,8 @@ dma_map_single(struct device *dev, void * or written back. * * The device owns this memory once this call has completed. The CPU - * can regain ownership by calling dma_unmap_page() or dma_sync_single(). + * can regain ownership by calling dma_unmap_page() or + * dma_sync_single_for_cpu(). */ static inline dma_addr_t dma_map_page(struct device *dev, struct page *page, @@ -204,7 +208,7 @@ dma_unmap_page(struct device *dev, dma_a * * Map a set of buffers described by scatterlist in streaming * mode for DMA. This is the scatter-gather version of the - * above pci_map_single interface. Here the scatter gather list + * above dma_map_single interface. Here the scatter gather list * elements are each tagged with the appropriate dma address * and length. They are obtained via sg_dma_{address,length}(SG). * @@ -214,7 +218,7 @@ dma_unmap_page(struct device *dev, dma_a * The routine returns the number of addr/length pairs actually * used, at most nents. * - * Device ownership issues as mentioned above for pci_map_single are + * Device ownership issues as mentioned above for dma_map_single are * the same here. */ static inline int @@ -246,7 +250,7 @@ dma_map_sg(struct device *dev, struct sc * * Unmap a set of streaming mode DMA translations. * Again, CPU read rules concerning calls here are the same as for - * pci_unmap_single() above. + * dma_unmap_single() above. */ static inline void dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nents, @@ -261,7 +265,7 @@ dma_unmap_sg(struct device *dev, struct } /** - * dma_sync_single + * dma_sync_single_for_cpu * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices * @handle: DMA address of buffer * @size: size of buffer to map @@ -270,18 +274,31 @@ dma_unmap_sg(struct device *dev, struct * Make physical memory consistent for a single streaming mode DMA * translation after a transfer. * - * If you perform a pci_map_single() but wish to interrogate the + * If you perform a dma_map_single() but wish to interrogate the * buffer using the cpu, yet do not wish to teardown the PCI dma * mapping, you must call this function before doing so. At the - * next point you give the PCI dma address back to the card, the + * next point you give the PCI dma address back to the card, you + * must first the perform a dma_sync_for_device, and then the * device again owns the buffer. */ static inline void -dma_sync_single(struct device *dev, dma_addr_t handle, size_t size, - enum dma_data_direction dir) +dma_sync_single_for_cpu(struct device *dev, dma_addr_t handle, size_t size, + enum dma_data_direction dir) { if (dmadev_is_sa1111(dev)) { - sa1111_dma_sync_single(dev, handle, size, dir); + sa1111_dma_sync_single_for_cpu(dev, handle, size, dir); + return; + } + + consistent_sync((void *)__bus_to_virt(handle), size, dir); +} + +static inline void +dma_sync_single_for_device(struct device *dev, dma_addr_t handle, size_t size, + enum dma_data_direction dir) +{ + if (dmadev_is_sa1111(dev)) { + sa1111_dma_sync_single_for_device(dev, handle, size, dir); return; } @@ -289,7 +306,7 @@ dma_sync_single(struct device *dev, dma_ } /** - * dma_sync_sg + * dma_sync_sg_for_cpu * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices * @sg: list of buffers * @nents: number of buffers to map @@ -298,17 +315,34 @@ dma_sync_single(struct device *dev, dma_ * Make physical memory consistent for a set of streaming * mode DMA translations after a transfer. * - * The same as pci_dma_sync_single but for a scatter-gather list, + * The same as dma_sync_single_for_* but for a scatter-gather list, * same rules and usage. */ static inline void -dma_sync_sg(struct device *dev, struct scatterlist *sg, int nents, - enum dma_data_direction dir) +dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nents, + enum dma_data_direction dir) +{ + int i; + + if (dmadev_is_sa1111(dev)) { + sa1111_dma_sync_sg_for_cpu(dev, sg, nents, dir); + return; + } + + for (i = 0; i < nents; i++, sg++) { + char *virt = page_address(sg->page) + sg->offset; + consistent_sync(virt, sg->length, dir); + } +} + +static inline void +dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nents, + enum dma_data_direction dir) { int i; if (dmadev_is_sa1111(dev)) { - sa1111_dma_sync_sg(dev, sg, nents, dir); + sa1111_dma_sync_sg_for_device(dev, sg, nents, dir); return; } diff -puN include/asm-generic/dma-mapping.h~dma_sync_for_device-cpu include/asm-generic/dma-mapping.h --- 25/include/asm-generic/dma-mapping.h~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/include/asm-generic/dma-mapping.h 2004-03-02 18:15:09.000000000 -0800 @@ -103,21 +103,41 @@ dma_unmap_sg(struct device *dev, struct } static inline void -dma_sync_single(struct device *dev, dma_addr_t dma_handle, size_t size, - enum dma_data_direction direction) +dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size, + enum dma_data_direction direction) { BUG_ON(dev->bus != &pci_bus_type); - pci_dma_sync_single(to_pci_dev(dev), dma_handle, size, (int)direction); + pci_dma_sync_single_for_cpu(to_pci_dev(dev), dma_handle, + size, (int)direction); } static inline void -dma_sync_sg(struct device *dev, struct scatterlist *sg, int nelems, - enum dma_data_direction direction) +dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size, + enum dma_data_direction direction) { BUG_ON(dev->bus != &pci_bus_type); - pci_dma_sync_sg(to_pci_dev(dev), sg, nelems, (int)direction); + pci_dma_sync_single_for_device(to_pci_dev(dev), dma_handle, + size, (int)direction); +} + +static inline void +dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems, + enum dma_data_direction direction) +{ + BUG_ON(dev->bus != &pci_bus_type); + + pci_dma_sync_sg_for_cpu(to_pci_dev(dev), sg, nelems, (int)direction); +} + +static inline void +dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems, + enum dma_data_direction direction) +{ + BUG_ON(dev->bus != &pci_bus_type); + + pci_dma_sync_sg_for_device(to_pci_dev(dev), sg, nelems, (int)direction); } /* Now for the API extensions over the pci_ one */ @@ -135,12 +155,21 @@ dma_get_cache_alignment(void) } static inline void -dma_sync_single_range(struct device *dev, dma_addr_t dma_handle, - unsigned long offset, size_t size, - enum dma_data_direction direction) +dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle, + unsigned long offset, size_t size, + enum dma_data_direction direction) +{ + /* just sync everything, that's all the pci API can do */ + dma_sync_single_for_cpu(dev, dma_handle, offset+size, direction); +} + +static inline void +dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle, + unsigned long offset, size_t size, + enum dma_data_direction direction) { /* just sync everything, that's all the pci API can do */ - dma_sync_single(dev, dma_handle, offset+size, direction); + dma_sync_single_for_device(dev, dma_handle, offset+size, direction); } static inline void diff -puN include/asm-generic/pci-dma-compat.h~dma_sync_for_device-cpu include/asm-generic/pci-dma-compat.h --- 25/include/asm-generic/pci-dma-compat.h~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/include/asm-generic/pci-dma-compat.h 2004-03-02 18:15:09.000000000 -0800 @@ -71,17 +71,31 @@ pci_unmap_sg(struct pci_dev *hwdev, stru } static inline void -pci_dma_sync_single(struct pci_dev *hwdev, dma_addr_t dma_handle, +pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, dma_addr_t dma_handle, size_t size, int direction) { - dma_sync_single(hwdev == NULL ? NULL : &hwdev->dev, dma_handle, size, (enum dma_data_direction)direction); + dma_sync_single_for_cpu(hwdev == NULL ? NULL : &hwdev->dev, dma_handle, size, (enum dma_data_direction)direction); } static inline void -pci_dma_sync_sg(struct pci_dev *hwdev, struct scatterlist *sg, +pci_dma_sync_single_for_device(struct pci_dev *hwdev, dma_addr_t dma_handle, + size_t size, int direction) +{ + dma_sync_single_for_device(hwdev == NULL ? NULL : &hwdev->dev, dma_handle, size, (enum dma_data_direction)direction); +} + +static inline void +pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, struct scatterlist *sg, + int nelems, int direction) +{ + dma_sync_sg_for_cpu(hwdev == NULL ? NULL : &hwdev->dev, sg, nelems, (enum dma_data_direction)direction); +} + +static inline void +pci_dma_sync_sg_for_device(struct pci_dev *hwdev, struct scatterlist *sg, int nelems, int direction) { - dma_sync_sg(hwdev == NULL ? NULL : &hwdev->dev, sg, nelems, (enum dma_data_direction)direction); + dma_sync_sg_for_device(hwdev == NULL ? NULL : &hwdev->dev, sg, nelems, (enum dma_data_direction)direction); } #endif diff -puN include/asm-i386/dma-mapping.h~dma_sync_for_device-cpu include/asm-i386/dma-mapping.h --- 25/include/asm-i386/dma-mapping.h~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/include/asm-i386/dma-mapping.h 2004-03-02 18:15:09.000000000 -0800 @@ -70,24 +70,42 @@ dma_unmap_sg(struct device *dev, struct } static inline void -dma_sync_single(struct device *dev, dma_addr_t dma_handle, size_t size, - enum dma_data_direction direction) +dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size, + enum dma_data_direction direction) +{ +} + +static inline void +dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size, + enum dma_data_direction direction) { flush_write_buffers(); } static inline void -dma_sync_single_range(struct device *dev, dma_addr_t dma_handle, - unsigned long offset, size_t size, - enum dma_data_direction direction) +dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle, + unsigned long offset, size_t size, + enum dma_data_direction direction) +{ +} + +static inline void +dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle, + unsigned long offset, size_t size, + enum dma_data_direction direction) { flush_write_buffers(); } +static inline void +dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems, + enum dma_data_direction direction) +{ +} static inline void -dma_sync_sg(struct device *dev, struct scatterlist *sg, int nelems, - enum dma_data_direction direction) +dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems, + enum dma_data_direction direction) { flush_write_buffers(); } diff -puN include/asm-i386/pci.h~dma_sync_for_device-cpu include/asm-i386/pci.h --- 25/include/asm-i386/pci.h~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/include/asm-i386/pci.h 2004-03-02 18:15:09.000000000 -0800 @@ -60,27 +60,32 @@ struct pci_dev; /* This is always fine. */ #define pci_dac_dma_supported(pci_dev, mask) (1) -static __inline__ dma64_addr_t +static inline dma64_addr_t pci_dac_page_to_dma(struct pci_dev *pdev, struct page *page, unsigned long offset, int direction) { return ((dma64_addr_t) page_to_phys(page) + (dma64_addr_t) offset); } -static __inline__ struct page * +static inline struct page * pci_dac_dma_to_page(struct pci_dev *pdev, dma64_addr_t dma_addr) { return pfn_to_page(dma_addr >> PAGE_SHIFT); } -static __inline__ unsigned long +static inline unsigned long pci_dac_dma_to_offset(struct pci_dev *pdev, dma64_addr_t dma_addr) { return (dma_addr & ~PAGE_MASK); } -static __inline__ void -pci_dac_dma_sync_single(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction) +static inline void +pci_dac_dma_sync_single_for_cpu(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction) +{ +} + +static inline void +pci_dac_dma_sync_single_for_device(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction) { flush_write_buffers(); } diff -puN include/asm-ia64/dma-mapping.h~dma_sync_for_device-cpu include/asm-ia64/dma-mapping.h --- 25/include/asm-ia64/dma-mapping.h~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/include/asm-ia64/dma-mapping.h 2004-03-02 18:15:09.000000000 -0800 @@ -14,8 +14,10 @@ #define dma_map_sg platform_dma_map_sg #define dma_unmap_single platform_dma_unmap_single #define dma_unmap_sg platform_dma_unmap_sg -#define dma_sync_single platform_dma_sync_single -#define dma_sync_sg platform_dma_sync_sg +#define dma_sync_single_for_cpu platform_dma_sync_single_for_cpu +#define dma_sync_sg_for_cpu platform_dma_sync_sg_for_cpu +#define dma_sync_single_for_device platform_dma_sync_single_for_device +#define dma_sync_sg_for_device platform_dma_sync_sg_for_device #define dma_map_page(dev, pg, off, size, dir) \ dma_map_single(dev, page_address(pg) + (off), (size), (dir)) @@ -27,8 +29,10 @@ * See Documentation/DMA-API.txt for details. */ -#define dma_sync_single_range(dev, dma_handle, offset, size, dir) \ - dma_sync_single(dev, dma_handle, size, dir) +#define dma_sync_single_range_for_cpu(dev, dma_handle, offset, size, dir) \ + dma_sync_single_for_cpu(dev, dma_handle, size, dir) +#define dma_sync_single_range_for_device(dev, dma_handle, offset, size, dir) \ + dma_sync_single_for_device(dev, dma_handle, size, dir) #define dma_supported platform_dma_supported diff -puN include/asm-ia64/machvec.h~dma_sync_for_device-cpu include/asm-ia64/machvec.h --- 25/include/asm-ia64/machvec.h~dma_sync_for_device-cpu 2004-03-02 18:15:08.000000000 -0800 +++ 25-akpm/include/asm-ia64/machvec.h 2004-03-02 18:15:09.000000000 -0800 @@ -42,8 +42,10 @@ typedef dma_addr_t ia64_mv_dma_map_singl typedef void ia64_mv_dma_unmap_single (struct device *, dma_addr_t, size_t, int); typedef int ia64_mv_dma_map_sg (struct device *, struct scatterlist *, int, int); typedef void ia64_mv_dma_unmap_sg (struct device *, struct scatterlist *, int, int); -typedef void ia64_mv_dma_sync_single (struct device *, dma_addr_t, size_t, int); -typedef void ia64_mv_dma_sync_sg (struct device *, struct scatterlist *, int, int); +typedef void ia64_mv_dma_sync_single_for_cpu (struct device *, dma_addr_t, size_t, int); +typedef void ia64_mv_dma_sync_sg_for_cpu (struct device *, struct scatterlist *, int, int); +typedef void ia64_mv_dma_sync_single_for_device (struct device *, dma_addr_t, size_t, int); +typedef void ia64_mv_dma_sync_sg_for_device (struct device *, struct scatterlist *, int, int); typedef int ia64_mv_dma_supported (struct device *, u64); /* @@ -104,8 +106,10 @@ extern void machvec_memory_fence (void); # define platform_dma_unmap_single ia64_mv.dma_unmap_single # define platform_dma_map_sg ia64_mv.dma_map_sg # define platform_dma_unmap_sg ia64_mv.dma_unmap_sg -# define platform_dma_sync_single ia64_mv.dma_sync_single -# define platform_dma_sync_sg ia64_mv.dma_sync_sg +# define platform_dma_sync_single_for_cpu ia64_mv.dma_sync_single_for_cpu +# define platform_dma_sync_sg_for_cpu ia64_mv.dma_sync_sg_for_cpu +# define platform_dma_sync_single_for_device ia64_mv.dma_sync_single_for_device +# define platform_dma_sync_sg_for_device ia64_mv.dma_sync_sg_for_device # define platform_dma_supported ia64_mv.dma_supported # define platform_irq_desc ia64_mv.irq_desc # define platform_irq_to_vector ia64_mv.irq_to_vector @@ -150,8 +154,10 @@ struct ia64_machine_vector { ia64_mv_dma_unmap_single *dma_unmap_single; ia64_mv_dma_map_sg *dma_map_sg; ia64_mv_dma_unmap_sg *dma_unmap_sg; - ia64_mv_dma_sync_single *dma_sync_single; - ia64_mv_dma_sync_sg *dma_sync_sg; + ia64_mv_dma_sync_single *dma_sync_single_for_cpu; + ia64_mv_dma_sync_sg *dma_sync_sg_for_cpu; + ia64_mv_dma_sync_single *dma_sync_single_for_device; + ia64_mv_dma_sync_sg *dma_sync_sg_for_device; ia64_mv_dma_supported *dma_supported; ia64_mv_irq_desc *irq_desc; ia64_mv_irq_to_vector *irq_to_vector; @@ -192,8 +198,10 @@ struct ia64_machine_vector { platform_dma_unmap_single, \ platform_dma_map_sg, \ platform_dma_unmap_sg, \ - platform_dma_sync_single, \ - platform_dma_sync_sg, \ + platform_dma_sync_single_for_cpu, \ + platform_dma_sync_sg_for_cpu, \ + platform_dma_sync_single_for_device, \ + platform_dma_sync_sg_for_device, \ platform_dma_supported, \ platform_irq_desc, \ platform_irq_to_vector, \ @@ -231,8 +239,10 @@ extern ia64_mv_dma_map_single swiotlb_m extern ia64_mv_dma_unmap_single swiotlb_unmap_single; extern ia64_mv_dma_map_sg swiotlb_map_sg; extern ia64_mv_dma_unmap_sg swiotlb_unmap_sg; -extern ia64_mv_dma_sync_single swiotlb_sync_single; -extern ia64_mv_dma_sync_sg swiotlb_sync_sg; +extern ia64_mv_dma_sync_single_for_cpu swiotlb_sync_single_for_cpu; +extern ia64_mv_dma_sync_sg_for_cpu swiotlb_sync_sg_for_cpu; +extern ia64_mv_dma_sync_single_for_device swiotlb_sync_single_for_device; +extern ia64_mv_dma_sync_sg_for_device swiotlb_sync_sg_for_device; extern ia64_mv_dma_supported swiotlb_dma_supported; /* @@ -290,11 +300,17 @@ extern ia64_mv_dma_supported swiotlb_dm #ifndef platform_dma_unmap_sg # define platform_dma_unmap_sg swiotlb_unmap_sg #endif -#ifndef platform_dma_sync_single -# define platform_dma_sync_single swiotlb_sync_single +#ifndef platform_dma_sync_single_for_cpu +# define platform_dma_sync_single_for_cpu swiotlb_sync_single_for_cpu #endif -#ifndef platform_dma_sync_sg -# define platform_dma_sync_sg swiotlb_sync_sg +#ifndef platform_dma_sync_sg_for_cpu +# define platform_dma_sync_sg_for_cpu swiotlb_sync_sg_for_cpu +#endif +#ifndef platform_dma_sync_single_for_device +# define platform_dma_sync_single_for_device swiotlb_sync_single_for_device +#endif +#ifndef platform_dma_sync_sg_for_device +# define platform_dma_sync_sg_for_device swiotlb_sync_sg_for_device #endif #ifndef platform_dma_supported # define platform_dma_supported swiotlb_dma_supported diff -puN include/asm-ia64/machvec_hpzx1.h~dma_sync_for_device-cpu include/asm-ia64/machvec_hpzx1.h --- 25/include/asm-ia64/machvec_hpzx1.h~dma_sync_for_device-cpu 2004-03-02 18:15:09.000000000 -0800 +++ 25-akpm/include/asm-ia64/machvec_hpzx1.h 2004-03-02 18:15:09.000000000 -0800 @@ -26,8 +26,10 @@ extern ia64_mv_dma_supported sba_dma_su #define platform_dma_unmap_single sba_unmap_single #define platform_dma_map_sg sba_map_sg #define platform_dma_unmap_sg sba_unmap_sg -#define platform_dma_sync_single ((ia64_mv_dma_sync_single *) machvec_memory_fence) -#define platform_dma_sync_sg ((ia64_mv_dma_sync_sg *) machvec_memory_fence) +#define platform_dma_sync_single_for_cpu ((ia64_mv_dma_sync_single_for_cpu *) machvec_memory_fence) +#define platform_dma_sync_sg_for_cpu ((ia64_mv_dma_sync_sg_for_cpu *) machvec_memory_fence) +#define platform_dma_sync_single_for_device ((ia64_mv_dma_sync_single_for_device *) machvec_memory_fence) +#define platform_dma_sync_sg_for_device ((ia64_mv_dma_sync_sg_for_device *) machvec_memory_fence) #define platform_dma_supported sba_dma_supported #endif /* _ASM_IA64_MACHVEC_HPZX1_h */ diff -puN include/asm-ia64/machvec_sn2.h~dma_sync_for_device-cpu include/asm-ia64/machvec_sn2.h --- 25/include/asm-ia64/machvec_sn2.h~dma_sync_for_device-cpu 2004-03-02 18:15:09.000000000 -0800 +++ 25-akpm/include/asm-ia64/machvec_sn2.h 2004-03-02 18:15:09.000000000 -0800 @@ -62,8 +62,10 @@ extern ia64_mv_dma_map_single sn_dma_ma extern ia64_mv_dma_unmap_single sn_dma_unmap_single; extern ia64_mv_dma_map_sg sn_dma_map_sg; extern ia64_mv_dma_unmap_sg sn_dma_unmap_sg; -extern ia64_mv_dma_sync_single sn_dma_sync_single; -extern ia64_mv_dma_sync_sg sn_dma_sync_sg; +extern ia64_mv_dma_sync_single_for_cpu sn_dma_sync_single_for_cpu; +extern ia64_mv_dma_sync_sg_for_cpu sn_dma_sync_sg_for_cpu; +extern ia64_mv_dma_sync_single_for_device sn_dma_sync_single_for_device; +extern ia64_mv_dma_sync_sg_for_device sn_dma_sync_sg_for_device; extern ia64_mv_dma_supported sn_dma_supported; /* @@ -105,8 +107,10 @@ extern ia64_mv_dma_supported sn_dma_sup #define platform_dma_unmap_single sn_dma_unmap_single #define platform_dma_map_sg sn_dma_map_sg #define platform_dma_unmap_sg sn_dma_unmap_sg -#define platform_dma_sync_single sn_dma_sync_single -#define platform_dma_sync_sg sn_dma_sync_sg +#define platform_dma_sync_single_for_cpu sn_dma_sync_single_for_cpu +#define platform_dma_sync_sg_for_cpu sn_dma_sync_sg_for_cpu +#define platform_dma_sync_single_for_device sn_dma_sync_single_for_device +#define platform_dma_sync_sg_for_device sn_dma_sync_sg_for_device #define platform_dma_supported sn_dma_supported #include diff -puN include/asm-ia64/pci.h~dma_sync_for_device-cpu include/asm-ia64/pci.h --- 25/include/asm-ia64/pci.h~dma_sync_for_device-cpu 2004-03-02 18:15:09.000000000 -0800 +++ 25-akpm/include/asm-ia64/pci.h 2004-03-02 18:15:09.000000000 -0800 @@ -76,7 +76,8 @@ extern int pcibios_prep_mwi (struct pci_ #define pci_dac_page_to_dma(dev,pg,off,dir) ((dma_addr_t) page_to_bus(pg) + (off)) #define pci_dac_dma_to_page(dev,dma_addr) (virt_to_page(bus_to_virt(dma_addr))) #define pci_dac_dma_to_offset(dev,dma_addr) offset_in_page(dma_addr) -#define pci_dac_dma_sync_single(dev,dma_addr,len,dir) do { mb(); } while (0) +#define pci_dac_dma_sync_single_for_cpu(dev,dma_addr,len,dir) do { } while (0) +#define pci_dac_dma_sync_single_for_device(dev,dma_addr,len,dir) do { mb(); } while (0) #define sg_dma_len(sg) ((sg)->dma_length) #define sg_dma_address(sg) ((sg)->dma_address) diff -puN include/asm-mips/dma-mapping.h~dma_sync_for_device-cpu include/asm-mips/dma-mapping.h --- 25/include/asm-mips/dma-mapping.h~dma_sync_for_device-cpu 2004-03-02 18:15:09.000000000 -0800 +++ 25-akpm/include/asm-mips/dma-mapping.h 2004-03-02 18:15:09.000000000 -0800 @@ -29,11 +29,17 @@ extern void dma_unmap_page(struct device size_t size, enum dma_data_direction direction); extern void dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries, enum dma_data_direction direction); -extern void dma_sync_single(struct device *dev, dma_addr_t dma_handle, +extern void dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction); -extern void dma_sync_single_range(struct device *dev, dma_addr_t dma_handle, +extern void dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, + size_t size, enum dma_data_direction direction); +extern void dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle, + unsigned long offset, size_t size, enum dma_data_direction direction); +extern void dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, enum dma_data_direction direction); -extern void dma_sync_sg(struct device *dev, struct scatterlist *sg, int nelems, +extern void dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems, + enum dma_data_direction direction); +extern void dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction); extern int dma_supported(struct device *dev, u64 mask); diff -puN include/asm-mips/pci.h~dma_sync_for_device-cpu include/asm-mips/pci.h --- 25/include/asm-mips/pci.h~dma_sync_for_device-cpu 2004-03-02 18:15:09.000000000 -0800 +++ 25-akpm/include/asm-mips/pci.h 2004-03-02 18:15:09.000000000 -0800 @@ -82,7 +82,9 @@ extern struct page *pci_dac_dma_to_page( dma64_addr_t dma_addr); extern unsigned long pci_dac_dma_to_offset(struct pci_dev *pdev, dma64_addr_t dma_addr); -extern void pci_dac_dma_sync_single(struct pci_dev *pdev, +extern void pci_dac_dma_sync_single_for_cpu(struct pci_dev *pdev, + dma64_addr_t dma_addr, size_t len, int direction); +extern void pci_dac_dma_sync_single_for_device(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction); #endif /* __KERNEL__ */ diff -puN include/asm-parisc/dma-mapping.h~dma_sync_for_device-cpu include/asm-parisc/dma-mapping.h --- 25/include/asm-parisc/dma-mapping.h~dma_sync_for_device-cpu 2004-03-02 18:15:09.000000000 -0800 +++ 25-akpm/include/asm-parisc/dma-mapping.h 2004-03-02 18:15:09.000000000 -0800 @@ -15,8 +15,10 @@ struct hppa_dma_ops { void (*unmap_single)(struct device *dev, dma_addr_t iova, size_t size, enum dma_data_direction direction); int (*map_sg)(struct device *dev, struct scatterlist *sg, int nents, enum dma_data_direction direction); void (*unmap_sg)(struct device *dev, struct scatterlist *sg, int nhwents, enum dma_data_direction direction); - void (*dma_sync_single)(struct device *dev, dma_addr_t iova, unsigned long offset, size_t size, enum dma_data_direction direction); - void (*dma_sync_sg)(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction); + void (*dma_sync_single_for_cpu)(struct device *dev, dma_addr_t iova, unsigned long offset, size_t size, enum dma_data_direction direction); + void (*dma_sync_single_for_device)(struct device *dev, dma_addr_t iova, unsigned long offset, size_t size, enum dma_data_direction direction); + void (*dma_sync_sg_for_cpu)(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction); + void (*dma_sync_sg_for_device)(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction); }; /* @@ -116,28 +118,53 @@ dma_unmap_page(struct device *dev, dma_a static inline void -dma_sync_single(struct device *dev, dma_addr_t dma_handle, size_t size, +dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) { - if(hppa_dma_ops->dma_sync_single) - hppa_dma_ops->dma_sync_single(dev, dma_handle, 0, size, direction); + if(hppa_dma_ops->dma_sync_single_for_cpu) + hppa_dma_ops->dma_sync_single_for_cpu(dev, dma_handle, 0, size, direction); } static inline void -dma_sync_single_range(struct device *dev, dma_addr_t dma_handle, +dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size, + enum dma_data_direction direction) +{ + if(hppa_dma_ops->dma_sync_single_for_device) + hppa_dma_ops->dma_sync_single_for_device(dev, dma_handle, 0, size, direction); +} + +static inline void +dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle, + unsigned long offset, size_t size, + enum dma_data_direction direction) +{ + if(hppa_dma_ops->dma_sync_single_for_cpu) + hppa_dma_ops->dma_sync_single_for_cpu(dev, dma_handle, offset, size, direction); +} + +static inline void +dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, enum dma_data_direction direction) { - if(hppa_dma_ops->dma_sync_single) - hppa_dma_ops->dma_sync_single(dev, dma_handle, offset, size, direction); + if(hppa_dma_ops->dma_sync_single_for_device) + hppa_dma_ops->dma_sync_single_for_device(dev, dma_handle, offset, size, direction); +} + +static inline void +dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems, + enum dma_data_direction direction) +{ + if(hppa_dma_ops->dma_sync_sg_for_cpu) + hppa_dma_ops->dma_sync_sg_for_cpu(dev, sg, nelems, direction); } static inline void -dma_sync_sg(struct device *dev, struct scatterlist *sg, int nelems, +dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction) { - if(hppa_dma_ops->dma_sync_sg) - hppa_dma_ops->dma_sync_sg(dev, sg, nelems, direction); + if(hppa_dma_ops->dma_sync_sg_for_device) + hppa_dma_ops->dma_sync_sg_for_device(dev, sg, nelems, direction); } static inline int @@ -166,14 +193,14 @@ dma_get_cache_alignment(void) static inline int dma_is_consistent(dma_addr_t dma_addr) { - return (hppa_dma_ops->dma_sync_single == NULL); + return (hppa_dma_ops->dma_sync_single_for_cpu == NULL); } static inline void dma_cache_sync(void *vaddr, size_t size, enum dma_data_direction direction) { - if(hppa_dma_ops->dma_sync_single) + if(hppa_dma_ops->dma_sync_single_for_cpu) flush_kernel_dcache_range((unsigned long)vaddr, size); } diff -puN include/asm-ppc64/pci.h~dma_sync_for_device-cpu include/asm-ppc64/pci.h --- 25/include/asm-ppc64/pci.h~dma_sync_for_device-cpu 2004-03-02 18:15:09.000000000 -0800 +++ 25-akpm/include/asm-ppc64/pci.h 2004-03-02 18:15:09.000000000 -0800 @@ -112,17 +112,33 @@ static inline void pci_unmap_sg(struct p pci_dma_ops.pci_unmap_sg(hwdev, sg, nents, direction); } -static inline void pci_dma_sync_single(struct pci_dev *hwdev, - dma_addr_t dma_handle, - size_t size, int direction) +static inline void pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, + dma_addr_t dma_handle, + size_t size, int direction) { BUG_ON(direction == PCI_DMA_NONE); /* nothing to do */ } -static inline void pci_dma_sync_sg(struct pci_dev *hwdev, - struct scatterlist *sg, - int nelems, int direction) +static inline void pci_dma_sync_single_for_device(struct pci_dev *hwdev, + dma_addr_t dma_handle, + size_t size, int direction) +{ + BUG_ON(direction == PCI_DMA_NONE); + /* nothing to do */ +} + +static inline void pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, + struct scatterlist *sg, + int nelems, int direction) +{ + BUG_ON(direction == PCI_DMA_NONE); + /* nothing to do */ +} + +static inline void pci_dma_sync_sg_for_device(struct pci_dev *hwdev, + struct scatterlist *sg, + int nelems, int direction) { BUG_ON(direction == PCI_DMA_NONE); /* nothing to do */ diff -puN include/asm-ppc/pci.h~dma_sync_for_device-cpu include/asm-ppc/pci.h --- 25/include/asm-ppc/pci.h~dma_sync_for_device-cpu 2004-03-02 18:15:09.000000000 -0800 +++ 25-akpm/include/asm-ppc/pci.h 2004-03-02 18:15:09.000000000 -0800 @@ -91,7 +91,7 @@ extern void pci_free_consistent(struct p * The 32-bit bus address to use is returned. * * Once the device is given the dma address, the device owns this memory - * until either pci_unmap_single or pci_dma_sync_single is performed. + * until either pci_unmap_single or pci_dma_sync_single_for_cpu is performed. */ static inline dma_addr_t pci_map_single(struct pci_dev *hwdev, void *ptr, size_t size, int direction) @@ -190,35 +190,58 @@ static inline void pci_unmap_sg(struct p * If you perform a pci_map_single() but wish to interrogate the * buffer using the cpu, yet do not wish to teardown the PCI dma * mapping, you must call this function before doing so. At the - * next point you give the PCI dma address back to the card, the - * device again owns the buffer. + * next point you give the PCI dma address back to the card, you + * must first perform a pci_dma_sync_for_device, and then the device + * again owns the buffer. */ -static inline void pci_dma_sync_single(struct pci_dev *hwdev, - dma_addr_t dma_handle, - size_t size, int direction) +static inline void pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, + dma_addr_t dma_handle, + size_t size, int direction) { BUG_ON(direction == PCI_DMA_NONE); - consistent_sync(bus_to_virt(dma_handle), size, direction); + consistent_sync_for_cpu(bus_to_virt(dma_handle), size, direction); +} + +static inline void pci_dma_sync_single_for_device(struct pci_dev *hwdev, + dma_addr_t dma_handle, + size_t size, int direction) +{ + BUG_ON(direction == PCI_DMA_NONE); + + consistent_sync_for_device(bus_to_virt(dma_handle), size, direction); } /* Make physical memory consistent for a set of streaming * mode DMA translations after a transfer. * - * The same as pci_dma_sync_single but for a scatter-gather list, + * The same as pci_dma_sync_single_for_* but for a scatter-gather list, * same rules and usage. */ -static inline void pci_dma_sync_sg(struct pci_dev *hwdev, - struct scatterlist *sg, - int nelems, int direction) +static inline void pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, + struct scatterlist *sg, + int nelems, int direction) { int i; BUG_ON(direction == PCI_DMA_NONE); for (i = 0; i < nelems; i++, sg++) - consistent_sync_page(sg->page, sg->offset, - sg->length, direction); + consistent_sync_page_for_cpu(sg->page, sg->offset, + sg->length, direction); +} + +static inline void pci_dma_sync_sg_for_device(struct pci_dev *hwdev, + struct scatterlist *sg, + int nelems, int direction) +{ + int i; + + BUG_ON(direction == PCI_DMA_NONE); + + for (i = 0; i < nelems; i++, sg++) + consistent_sync_page_for_device(sg->page, sg->offset, + sg->length, direction); } /* Return whether the given PCI device DMA address mask can @@ -237,26 +260,32 @@ static inline int pci_dma_supported(stru */ #define pci_dac_dma_supported(pci_dev, mask) (0) -static __inline__ dma64_addr_t +static inline dma64_addr_t pci_dac_page_to_dma(struct pci_dev *pdev, struct page *page, unsigned long offset, int direction) { return (dma64_addr_t) page_to_bus(page) + offset; } -static __inline__ struct page * +static inline struct page * pci_dac_dma_to_page(struct pci_dev *pdev, dma64_addr_t dma_addr) { return mem_map + (unsigned long)(dma_addr >> PAGE_SHIFT); } -static __inline__ unsigned long +static inline unsigned long pci_dac_dma_to_offset(struct pci_dev *pdev, dma64_addr_t dma_addr) { return (dma_addr & ~PAGE_MASK); } -static __inline__ void -pci_dac_dma_sync_single(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction) +static inline void +pci_dac_dma_sync_single_for_cpu(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction) +{ + /* Nothing to do. */ +} + +static inline void +pci_dac_dma_sync_single_for_device(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction) { /* Nothing to do. */ } diff -puN include/asm-sh/pci.h~dma_sync_for_device-cpu include/asm-sh/pci.h --- 25/include/asm-sh/pci.h~dma_sync_for_device-cpu 2004-03-02 18:15:09.000000000 -0800 +++ 25-akpm/include/asm-sh/pci.h 2004-03-02 18:15:09.000000000 -0800 @@ -84,7 +84,7 @@ extern void pci_free_consistent(struct p * The 32-bit bus address to use is returned. * * Once the device is given the dma address, the device owns this memory - * until either pci_unmap_single or pci_dma_sync_single is performed. + * until either pci_unmap_single or pci_dma_sync_single_for_cpu is performed. */ static inline dma_addr_t pci_map_single(struct pci_dev *hwdev, void *ptr, size_t size, int direction) @@ -184,12 +184,21 @@ static inline void pci_unmap_sg(struct p * If you perform a pci_map_single() but wish to interrogate the * buffer using the cpu, yet do not wish to teardown the PCI dma * mapping, you must call this function before doing so. At the - * next point you give the PCI dma address back to the card, the - * device again owns the buffer. - */ -static inline void pci_dma_sync_single(struct pci_dev *hwdev, - dma_addr_t dma_handle, - size_t size, int direction) + * next point you give the PCI dma address back to the card, you + * must first perform a pci_dma_sync_for_device, and then the device + * again owns the buffer. + */ +static inline void pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, + dma_addr_t dma_handle, + size_t size, int direction) +{ + if (direction == PCI_DMA_NONE) + BUG(); +} + +static inline void pci_dma_sync_single_for_device(struct pci_dev *hwdev, + dma_addr_t dma_handle, + size_t size, int direction) { if (direction == PCI_DMA_NONE) BUG(); @@ -203,12 +212,20 @@ static inline void pci_dma_sync_single(s /* Make physical memory consistent for a set of streaming * mode DMA translations after a transfer. * - * The same as pci_dma_sync_single but for a scatter-gather list, + * The same as pci_dma_sync_single_* but for a scatter-gather list, * same rules and usage. */ -static inline void pci_dma_sync_sg(struct pci_dev *hwdev, - struct scatterlist *sg, - int nelems, int direction) +static inline void pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, + struct scatterlist *sg, + int nelems, int direction) +{ + if (direction == PCI_DMA_NONE) + BUG(); +} + +static inline void pci_dma_sync_sg_for_device(struct pci_dev *hwdev, + struct scatterlist *sg, + int nelems, int direction) { if (direction == PCI_DMA_NONE) BUG(); diff -puN include/asm-sparc64/pci.h~dma_sync_for_device-cpu include/asm-sparc64/pci.h --- 25/include/asm-sparc64/pci.h~dma_sync_for_device-cpu 2004-03-02 18:15:09.000000000 -0800 +++ 25-akpm/include/asm-sparc64/pci.h 2004-03-02 18:15:09.000000000 -0800 @@ -60,7 +60,7 @@ extern void pci_free_consistent(struct p * The 32-bit bus address to use is returned. * * Once the device is given the dma address, the device owns this memory - * until either pci_unmap_single or pci_dma_sync_single is performed. + * until either pci_unmap_single or pci_dma_sync_single_for_cpu is performed. */ extern dma_addr_t pci_map_single(struct pci_dev *hwdev, void *ptr, size_t size, int direction); @@ -123,19 +123,36 @@ extern void pci_unmap_sg(struct pci_dev * If you perform a pci_map_single() but wish to interrogate the * buffer using the cpu, yet do not wish to teardown the PCI dma * mapping, you must call this function before doing so. At the - * next point you give the PCI dma address back to the card, the + * next point you give the PCI dma address back to the card, you + * must first perform a pci_dma_sync_for_device, and then the * device again owns the buffer. */ -extern void pci_dma_sync_single(struct pci_dev *hwdev, dma_addr_t dma_handle, - size_t size, int direction); +extern void pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, dma_addr_t dma_handle, + size_t size, int direction); + +static inline void +pci_dma_sync_single_for_device(struct pci_dev *hwdev, dma_addr_t dma_handle, + size_t size, int direction) +{ + /* No flushing needed to sync cpu writes to the device. */ + BUG_ON(direction == PCI_DMA_NONE); +} /* Make physical memory consistent for a set of streaming * mode DMA translations after a transfer. * - * The same as pci_dma_sync_single but for a scatter-gather list, + * The same as pci_dma_sync_single_* but for a scatter-gather list, * same rules and usage. */ -extern void pci_dma_sync_sg(struct pci_dev *hwdev, struct scatterlist *sg, int nelems, int direction); +extern void pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, struct scatterlist *sg, int nelems, int direction); + +static inline void +pci_dma_sync_sg_for_device(struct pci_dev *hwdev, struct scatterlist *sg, + int nelems, int direction) +{ + /* No flushing needed to sync cpu writes to the device. */ + BUG_ON(direction == PCI_DMA_NONE); +} /* Return whether the given PCI device DMA address mask can * be supported properly. For example, if your device can @@ -159,14 +176,14 @@ extern int pci_dma_supported(struct pci_ #define pci_dac_dma_supported(pci_dev, mask) \ ((((mask) & PCI64_REQUIRED_MASK) == PCI64_REQUIRED_MASK) ? 1 : 0) -static __inline__ dma64_addr_t +static inline dma64_addr_t pci_dac_page_to_dma(struct pci_dev *pdev, struct page *page, unsigned long offset, int direction) { return (PCI64_ADDR_BASE + __pa(page_address(page)) + offset); } -static __inline__ struct page * +static inline struct page * pci_dac_dma_to_page(struct pci_dev *pdev, dma64_addr_t dma_addr) { unsigned long paddr = (dma_addr & PAGE_MASK) - PCI64_ADDR_BASE; @@ -174,14 +191,22 @@ pci_dac_dma_to_page(struct pci_dev *pdev return virt_to_page(__va(paddr)); } -static __inline__ unsigned long +static inline unsigned long pci_dac_dma_to_offset(struct pci_dev *pdev, dma64_addr_t dma_addr) { return (dma_addr & ~PAGE_MASK); } -static __inline__ void -pci_dac_dma_sync_single(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction) +static inline void +pci_dac_dma_sync_single_for_cpu(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction) +{ + /* DAC cycle addressing does not make use of the + * PCI controller's streaming cache, so nothing to do. + */ +} + +static inline void +pci_dac_dma_sync_single_for_device(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction) { /* DAC cycle addressing does not make use of the * PCI controller's streaming cache, so nothing to do. diff -puN include/asm-sparc64/sbus.h~dma_sync_for_device-cpu include/asm-sparc64/sbus.h --- 25/include/asm-sparc64/sbus.h~dma_sync_for_device-cpu 2004-03-02 18:15:09.000000000 -0800 +++ 25-akpm/include/asm-sparc64/sbus.h 2004-03-02 18:15:09.000000000 -0800 @@ -111,7 +111,11 @@ extern int sbus_map_sg(struct sbus_dev * extern void sbus_unmap_sg(struct sbus_dev *, struct scatterlist *, int, int); /* Finally, allow explicit synchronization of streamable mappings. */ -extern void sbus_dma_sync_single(struct sbus_dev *, dma_addr_t, size_t, int); -extern void sbus_dma_sync_sg(struct sbus_dev *, struct scatterlist *, int, int); +extern void sbus_dma_sync_single_for_cpu(struct sbus_dev *, dma_addr_t, size_t, int); +#define sbus_dma_sync_single sbus_dma_sync_single_for_cpu +extern void sbus_dma_sync_single_for_device(struct sbus_dev *, dma_addr_t, size_t, int); +extern void sbus_dma_sync_sg_for_cpu(struct sbus_dev *, struct scatterlist *, int, int); +#define sbus_dma_sync_sg sbus_dma_sync_sg_for_cpu +extern void sbus_dma_sync_sg_for_device(struct sbus_dev *, struct scatterlist *, int, int); #endif /* !(_SPARC64_SBUS_H) */ diff -puN include/asm-sparc/pci.h~dma_sync_for_device-cpu include/asm-sparc/pci.h --- 25/include/asm-sparc/pci.h~dma_sync_for_device-cpu 2004-03-02 18:15:09.000000000 -0800 +++ 25-akpm/include/asm-sparc/pci.h 2004-03-02 18:15:09.000000000 -0800 @@ -52,7 +52,7 @@ extern void pci_free_consistent(struct p * The 32-bit bus address to use is returned. * * Once the device is given the dma address, the device owns this memory - * until either pci_unmap_single or pci_dma_sync_single is performed. + * until either pci_unmap_single or pci_dma_sync_single_for_cpu is performed. */ extern dma_addr_t pci_map_single(struct pci_dev *hwdev, void *ptr, size_t size, int direction); @@ -116,18 +116,21 @@ extern void pci_unmap_sg(struct pci_dev * If you perform a pci_map_single() but wish to interrogate the * buffer using the cpu, yet do not wish to teardown the PCI dma * mapping, you must call this function before doing so. At the - * next point you give the PCI dma address back to the card, the - * device again owns the buffer. + * next point you give the PCI dma address back to the card, you + * must first perform a pci_dma_sync_for_device, and then the device + * again owns the buffer. */ -extern void pci_dma_sync_single(struct pci_dev *hwdev, dma_addr_t dma_handle, size_t size, int direction); +extern void pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, dma_addr_t dma_handle, size_t size, int direction); +extern void pci_dma_sync_single_for_device(struct pci_dev *hwdev, dma_addr_t dma_handle, size_t size, int direction); /* Make physical memory consistent for a set of streaming * mode DMA translations after a transfer. * - * The same as pci_dma_sync_single but for a scatter-gather list, + * The same as pci_dma_sync_single_* but for a scatter-gather list, * same rules and usage. */ -extern void pci_dma_sync_sg(struct pci_dev *hwdev, struct scatterlist *sg, int nelems, int direction); +extern void pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, struct scatterlist *sg, int nelems, int direction); +extern void pci_dma_sync_sg_for_device(struct pci_dev *hwdev, struct scatterlist *sg, int nelems, int direction); /* Return whether the given PCI device DMA address mask can * be supported properly. For example, if your device can diff -puN include/asm-sparc/sbus.h~dma_sync_for_device-cpu include/asm-sparc/sbus.h --- 25/include/asm-sparc/sbus.h~dma_sync_for_device-cpu 2004-03-02 18:15:09.000000000 -0800 +++ 25-akpm/include/asm-sparc/sbus.h 2004-03-02 18:15:09.000000000 -0800 @@ -118,8 +118,12 @@ extern int sbus_map_sg(struct sbus_dev * extern void sbus_unmap_sg(struct sbus_dev *, struct scatterlist *, int, int); /* Finally, allow explicit synchronization of streamable mappings. */ -extern void sbus_dma_sync_single(struct sbus_dev *, dma_addr_t, size_t, int); -extern void sbus_dma_sync_sg(struct sbus_dev *, struct scatterlist *, int, int); +extern void sbus_dma_sync_single_for_cpu(struct sbus_dev *, dma_addr_t, size_t, int); +#define sbus_dma_sync_single sbus_dma_sync_single_for_cpu +extern void sbus_dma_sync_single_for_device(struct sbus_dev *, dma_addr_t, size_t, int); +extern void sbus_dma_sync_sg_for_cpu(struct sbus_dev *, struct scatterlist *, int, int); +#define sbus_dma_sync_sg sbus_dma_sync_sg_for_cpu +extern void sbus_dma_sync_sg_for_device(struct sbus_dev *, struct scatterlist *, int, int); /* Eric Brower (ebrower@usa.net) * Translate SBus interrupt levels to ino values-- diff -puN include/asm-v850/pci.h~dma_sync_for_device-cpu include/asm-v850/pci.h --- 25/include/asm-v850/pci.h~dma_sync_for_device-cpu 2004-03-02 18:15:09.000000000 -0800 +++ 25-akpm/include/asm-v850/pci.h 2004-03-02 18:15:09.000000000 -0800 @@ -27,7 +27,7 @@ extern void pcibios_set_master (struct p /* `Grant' to PDEV the memory block at CPU_ADDR, for doing DMA. The 32-bit PCI bus mastering address to use is returned. the device owns - this memory until either pci_unmap_single or pci_dma_sync_single is + this memory until either pci_unmap_single or pci_dma_sync_single_for_cpu is performed. */ extern dma_addr_t pci_map_single (struct pci_dev *pdev, void *cpu_addr, size_t size, int dir); @@ -44,10 +44,15 @@ pci_unmap_single (struct pci_dev *pdev, If you perform a pci_map_single() but wish to interrogate the buffer using the cpu, yet do not wish to teardown the PCI dma mapping, you must call this function before doing so. At the next - point you give the PCI dma address back to the card, the device - again owns the buffer. */ + point you give the PCI dma address back to the card, you must first + perform a pci_dma_sync_for_device, and then the device again owns + the buffer. */ extern void -pci_dma_sync_single (struct pci_dev *dev, dma_addr_t dma_addr, size_t size, +pci_dma_sync_single_for_cpu (struct pci_dev *dev, dma_addr_t dma_addr, size_t size, + int dir); + +extern void +pci_dma_sync_single_for_device (struct pci_dev *dev, dma_addr_t dma_addr, size_t size, int dir); diff -puN include/asm-x86_64/pci.h~dma_sync_for_device-cpu include/asm-x86_64/pci.h --- 25/include/asm-x86_64/pci.h~dma_sync_for_device-cpu 2004-03-02 18:15:09.000000000 -0800 +++ 25-akpm/include/asm-x86_64/pci.h 2004-03-02 18:15:09.000000000 -0800 @@ -78,10 +78,18 @@ extern dma_addr_t swiotlb_map_single (st int dir); extern void swiotlb_unmap_single (struct device *hwdev, dma_addr_t dev_addr, size_t size, int dir); -extern void swiotlb_sync_single (struct device *hwdev, dma_addr_t dev_addr, - size_t size, int dir); -extern void swiotlb_sync_sg (struct device *hwdev, struct scatterlist *sg, int nelems, - int dir); +extern void swiotlb_sync_single_for_cpu (struct device *hwdev, + dma_addr_t dev_addr, + size_t size, int dir); +extern void swiotlb_sync_single_for_device (struct device *hwdev, + dma_addr_t dev_addr, + size_t size, int dir); +extern void swiotlb_sync_sg_for_cpu (struct device *hwdev, + struct scatterlist *sg, int nelems, + int dir); +extern void swiotlb_sync_sg_for_device (struct device *hwdev, + struct scatterlist *sg, int nelems, + int dir); extern int swiotlb_map_sg(struct device *hwdev, struct scatterlist *sg, int nents, int direction); extern void swiotlb_unmap_sg(struct device *hwdev, struct scatterlist *sg, @@ -95,7 +103,7 @@ extern void swiotlb_unmap_sg(struct devi * The 32-bit bus address to use is returned. * * Once the device is given the dma address, the device owns this memory - * until either pci_unmap_single or pci_dma_sync_single is performed. + * until either pci_unmap_single or pci_dma_sync_single_for_cpu is performed. */ extern dma_addr_t pci_map_single(struct pci_dev *hwdev, void *ptr, size_t size, int direction); @@ -125,29 +133,56 @@ void pci_unmap_single(struct pci_dev *hw #define pci_unmap_len_set(PTR, LEN_NAME, VAL) \ (((PTR)->LEN_NAME) = (VAL)) -static inline void pci_dma_sync_single(struct pci_dev *hwdev, - dma_addr_t dma_handle, - size_t size, int direction) +static inline void pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, + dma_addr_t dma_handle, + size_t size, int direction) { BUG_ON(direction == PCI_DMA_NONE); #ifdef CONFIG_SWIOTLB if (swiotlb) - return swiotlb_sync_single(&hwdev->dev,dma_handle,size,direction); + return swiotlb_sync_single_for_cpu(&hwdev->dev,dma_handle,size,direction); #endif flush_write_buffers(); } -static inline void pci_dma_sync_sg(struct pci_dev *hwdev, - struct scatterlist *sg, - int nelems, int direction) +static inline void pci_dma_sync_single_for_device(struct pci_dev *hwdev, + dma_addr_t dma_handle, + size_t size, int direction) +{ + BUG_ON(direction == PCI_DMA_NONE); + +#ifdef CONFIG_SWIOTLB + if (swiotlb) + return swiotlb_sync_single_for_device(&hwdev->dev,dma_handle,size,direction); +#endif + + flush_write_buffers(); +} + +static inline void pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, + struct scatterlist *sg, + int nelems, int direction) +{ + BUG_ON(direction == PCI_DMA_NONE); + +#ifdef CONFIG_SWIOTLB + if (swiotlb) + return swiotlb_sync_sg_for_cpu(&hwdev->dev,sg,nelems,direction); +#endif + flush_write_buffers(); +} + +static inline void pci_dma_sync_sg_for_device(struct pci_dev *hwdev, + struct scatterlist *sg, + int nelems, int direction) { BUG_ON(direction == PCI_DMA_NONE); #ifdef CONFIG_SWIOTLB if (swiotlb) - return swiotlb_sync_sg(&hwdev->dev,sg,nelems,direction); + return swiotlb_sync_sg_for_device(&hwdev->dev,sg,nelems,direction); #endif flush_write_buffers(); } @@ -218,12 +253,21 @@ static inline dma_addr_t pci_map_page(st * If you perform a pci_map_single() but wish to interrogate the * buffer using the cpu, yet do not wish to teardown the PCI dma * mapping, you must call this function before doing so. At the - * next point you give the PCI dma address back to the card, the + * next point you give the PCI dma address back to the card, you + * must first perform a pci_dma_sync_for_device, and then the * device again owns the buffer. */ -static inline void pci_dma_sync_single(struct pci_dev *hwdev, - dma_addr_t dma_handle, - size_t size, int direction) +static inline void pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, + dma_addr_t dma_handle, + size_t size, int direction) +{ + if (direction == PCI_DMA_NONE) + out_of_line_bug(); +} + +static inline void pci_dma_sync_single_for_device(struct pci_dev *hwdev, + dma_addr_t dma_handle, + size_t size, int direction) { if (direction == PCI_DMA_NONE) out_of_line_bug(); @@ -233,12 +277,20 @@ static inline void pci_dma_sync_single(s /* Make physical memory consistent for a set of streaming * mode DMA translations after a transfer. * - * The same as pci_dma_sync_single but for a scatter-gather list, + * The same as pci_dma_sync_single_* but for a scatter-gather list, * same rules and usage. */ -static inline void pci_dma_sync_sg(struct pci_dev *hwdev, - struct scatterlist *sg, - int nelems, int direction) +static inline void pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, + struct scatterlist *sg, + int nelems, int direction) +{ + if (direction == PCI_DMA_NONE) + out_of_line_bug(); +} + +static inline void pci_dma_sync_sg_for_device(struct pci_dev *hwdev, + struct scatterlist *sg, + int nelems, int direction) { if (direction == PCI_DMA_NONE) out_of_line_bug(); @@ -264,27 +316,32 @@ extern void pci_unmap_sg(struct pci_dev */ extern int pci_dma_supported(struct pci_dev *hwdev, u64 mask); -static __inline__ dma64_addr_t +static inline dma64_addr_t pci_dac_page_to_dma(struct pci_dev *pdev, struct page *page, unsigned long offset, int direction) { return ((dma64_addr_t) page_to_phys(page) + (dma64_addr_t) offset); } -static __inline__ struct page * +static inline struct page * pci_dac_dma_to_page(struct pci_dev *pdev, dma64_addr_t dma_addr) { return virt_to_page(__va(dma_addr)); } -static __inline__ unsigned long +static inline unsigned long pci_dac_dma_to_offset(struct pci_dev *pdev, dma64_addr_t dma_addr) { return (dma_addr & ~PAGE_MASK); } -static __inline__ void -pci_dac_dma_sync_single(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction) +static inline void +pci_dac_dma_sync_single_for_cpu(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction) +{ +} + +static inline void +pci_dac_dma_sync_single_for_device(struct pci_dev *pdev, dma64_addr_t dma_addr, size_t len, int direction) { flush_write_buffers(); } diff -puN include/linux/dma-mapping.h~dma_sync_for_device-cpu include/linux/dma-mapping.h --- 25/include/linux/dma-mapping.h~dma_sync_for_device-cpu 2004-03-02 18:15:09.000000000 -0800 +++ 25-akpm/include/linux/dma-mapping.h 2004-03-02 18:15:09.000000000 -0800 @@ -12,6 +12,10 @@ enum dma_data_direction { #include +/* Backwards compat, remove in 2.7.x */ +#define dma_sync_single dma_sync_single_for_cpu +#define dma_sync_sg dma_sync_sg_for_cpu + #endif diff -puN include/linux/pci.h~dma_sync_for_device-cpu include/linux/pci.h --- 25/include/linux/pci.h~dma_sync_for_device-cpu 2004-03-02 18:15:09.000000000 -0800 +++ 25-akpm/include/linux/pci.h 2004-03-02 18:15:09.000000000 -0800 @@ -723,6 +723,10 @@ extern int msi_free_vectors(struct pci_d #include +/* Backwards compat, remove in 2.7.x */ +#define pci_dma_sync_single pci_dma_sync_single_for_cpu +#define pci_dma_sync_sg pci_dma_sync_sg_for_cpu + /* * If the system does not have PCI, clearly these return errors. Define * these as simple inline functions to avoid hair in drivers. diff -puN include/linux/usb_gadget.h~dma_sync_for_device-cpu include/linux/usb_gadget.h --- 25/include/linux/usb_gadget.h~dma_sync_for_device-cpu 2004-03-02 18:15:09.000000000 -0800 +++ 25-akpm/include/linux/usb_gadget.h 2004-03-02 18:15:09.000000000 -0800 @@ -117,7 +117,7 @@ struct usb_ep_ops { void (*free_buffer) (struct usb_ep *ep, void *buf, dma_addr_t dma, unsigned bytes); // NOTE: on 2.5, drivers may also use dma_map() and - // dma_sync_single() to manage dma overhead. + // dma_sync_single_*() to manage dma overhead. int (*queue) (struct usb_ep *ep, struct usb_request *req, int gfp_flags); diff -puN include/linux/usb.h~dma_sync_for_device-cpu include/linux/usb.h --- 25/include/linux/usb.h~dma_sync_for_device-cpu 2004-03-02 18:15:09.000000000 -0800 +++ 25-akpm/include/linux/usb.h 2004-03-02 18:15:09.000000000 -0800 @@ -830,14 +830,18 @@ void usb_buffer_free (struct usb_device void *addr, dma_addr_t dma); struct urb *usb_buffer_map (struct urb *urb); +#if 0 void usb_buffer_dmasync (struct urb *urb); +#endif void usb_buffer_unmap (struct urb *urb); struct scatterlist; int usb_buffer_map_sg (struct usb_device *dev, unsigned pipe, struct scatterlist *sg, int nents); +#if 0 void usb_buffer_dmasync_sg (struct usb_device *dev, unsigned pipe, struct scatterlist *sg, int n_hw_ents); +#endif void usb_buffer_unmap_sg (struct usb_device *dev, unsigned pipe, struct scatterlist *sg, int n_hw_ents); diff -puN include/net/irda/vlsi_ir.h~dma_sync_for_device-cpu include/net/irda/vlsi_ir.h --- 25/include/net/irda/vlsi_ir.h~dma_sync_for_device-cpu 2004-03-02 18:15:09.000000000 -0800 +++ 25-akpm/include/net/irda/vlsi_ir.h 2004-03-02 18:15:09.000000000 -0800 @@ -41,19 +41,6 @@ #define PCI_CLASS_SUBCLASS_MASK 0xffff #endif -/* missing pci-dma api call to give streaming dma buffer back to hw - * patch was floating on lkml around 2.5.2x and might be present later. - * Defining it this way is ok, since the vlsi-ir is only - * used on two oldish x86-based notebooks which are cache-coherent - * (and flush_write_buffers also handles PPro errata and C3 OOstore) - */ -#ifdef CONFIG_X86 -#include -#define pci_dma_prep_single(dev, addr, size, direction) flush_write_buffers() -#else -#error missing pci dma api call -#endif - /* in recent 2.5 interrupt handlers have non-void return value */ #ifndef IRQ_RETVAL typedef void irqreturn_t; _