bus_to_virt/virt_to_bus are now illegal.

Kill 'address' member of scatterlist.
The 'bounce_buffers' member of the scsi command struct
is now never set, kill it.
Convert some ISA devices over to isa_virt_to_bus et al.
Start marking PCI drivers as broken if they reference
virt_to_bus or bus_to_virt.

96 files changed, 376 insertions, 488 deletions

diff --git a/arch/i386/kernel/pci-dma.c b/arch/i386/kernel/pci-dma.c
index 4bd1486fe..18a08ccba 100644
--- a/arch/i386/kernel/pci-dma.c
+++ b/arch/i386/kernel/pci-dma.c
@@ -25,7 +25,7 @@ void *pci_alloc_consistent(struct pci_dev *hwdev, size_t size,
 
 	if (ret != NULL) {
 		memset(ret, 0, size);
-		*dma_handle = virt_to_bus(ret);
+		*dma_handle = virt_to_phys(ret);
 	}
 	return ret;
 }
diff --git a/arch/i386/kernel/setup.c b/arch/i386/kernel/setup.c
index 4b6c92b34..c05ffe05d 100644
--- a/arch/i386/kernel/setup.c
+++ b/arch/i386/kernel/setup.c
@@ -356,7 +356,7 @@ static void __init probe_roms(void)
 
 	/* Video ROM is standard at C000:0000 - C7FF:0000, check signature */
 	for (base = 0xC0000; base < 0xE0000; base += 2048) {
-		romstart = bus_to_virt(base);
+		romstart = isa_bus_to_virt(base);
 		if (!romsignature(romstart))
 			continue;
 		request_resource(&iomem_resource, rom_resources + roms);
@@ -368,7 +368,7 @@ static void __init probe_roms(void)
 	for (base = 0xC8000; base < 0xE0000; base += 2048) {
 		unsigned long length;
 
-		romstart = bus_to_virt(base);
+		romstart = isa_bus_to_virt(base);
 		if (!romsignature(romstart))
 			continue;
 		length = romstart[2] * 512;
@@ -397,7 +397,7 @@ static void __init probe_roms(void)
 
 	/* Final check for motherboard extension rom at E000:0000 */
 	base = 0xE0000;
-	romstart = bus_to_virt(base);
+	romstart = isa_bus_to_virt(base);
 
 	if (romsignature(romstart)) {
 		rom_resources[roms].start = base;
@@ -816,10 +816,10 @@ void __init setup_arch(char **cmdline_p)
 	init_mm.end_data = (unsigned long) &_edata;
 	init_mm.brk = (unsigned long) &_end;
 
-	code_resource.start = virt_to_bus(&_text);
-	code_resource.end = virt_to_bus(&_etext)-1;
-	data_resource.start = virt_to_bus(&_etext);
-	data_resource.end = virt_to_bus(&_edata)-1;
+	code_resource.start = virt_to_phys(&_text);
+	code_resource.end = virt_to_phys(&_etext)-1;
+	data_resource.start = virt_to_phys(&_etext);
+	data_resource.end = virt_to_phys(&_edata)-1;
 
 	parse_mem_cmdline(cmdline_p);
 
diff --git a/arch/sparc/mm/io-unit.c b/arch/sparc/mm/io-unit.c
index f1b178180..12400a9ae 100644
--- a/arch/sparc/mm/io-unit.c
+++ b/arch/sparc/mm/io-unit.c
@@ -1,4 +1,4 @@
-/* $Id: io-unit.c,v 1.23 2001-02-13 01:16:43 davem Exp $
+/* $Id: io-unit.c,v 1.24 2001-12-17 07:05:09 davem Exp $
  * io-unit.c:  IO-UNIT specific routines for memory management.
  *
  * Copyright (C) 1997,1998 Jakub Jelinek    (jj@sunsite.mff.cuni.cz)
@@ -131,7 +131,7 @@ static void iounit_get_scsi_sgl(struct scatterlist *sg, int sz, struct sbus_bus
 	/* FIXME: Cache some resolved pages - often several sg entries are to the same page */
 	spin_lock_irqsave(&iounit->lock, flags);
 	for (; sz >= 0; sz--) {
-		sg[sz].dvma_address = iounit_get_area(iounit, (unsigned long)sg[sz].address, sg[sz].length);
+		sg[sz].dvma_address = iounit_get_area(iounit, (unsigned long)page_address(sg[sz].page) + sg[sz].offset, sg[sz].length);
 		sg[sz].dvma_length = sg[sz].length;
 	}
 	spin_unlock_irqrestore(&iounit->lock, flags);
diff --git a/arch/sparc/mm/iommu.c b/arch/sparc/mm/iommu.c
index 706e11319..ad25b6e05 100644
--- a/arch/sparc/mm/iommu.c
+++ b/arch/sparc/mm/iommu.c
@@ -1,4 +1,4 @@
-/* $Id: iommu.c,v 1.21 2001-02-13 01:16:43 davem Exp $
+/* $Id: iommu.c,v 1.22 2001-12-17 07:05:09 davem Exp $
  * iommu.c:  IOMMU specific routines for memory management.
  *
  * Copyright (C) 1995 David S. Miller  (davem@caip.rutgers.edu)
@@ -168,7 +168,7 @@ static __u32 iommu_get_scsi_one_pflush(char *vaddr, unsigned long len, struct sb
 static void iommu_get_scsi_sgl_noflush(struct scatterlist *sg, int sz, struct sbus_bus *sbus)
 {
 	for (; sz >= 0; sz--) {
-		sg[sz].dvma_address = (__u32) (sg[sz].address);
+		sg[sz].dvma_address = (__u32) (page_address(sg[sz].page) + sg[sz].offset);
 		sg[sz].dvma_length = (__u32) (sg[sz].length);
 	}
 }
@@ -177,7 +177,7 @@ static void iommu_get_scsi_sgl_gflush(struct scatterlist *sg, int sz, struct sbu
 {
 	flush_page_for_dma(0);
 	for (; sz >= 0; sz--) {
-		sg[sz].dvma_address = (__u32) (sg[sz].address);
+		sg[sz].dvma_address = (__u32) (page_address(sg[sz].page) + sg[sz].offset);
 		sg[sz].dvma_length = (__u32) (sg[sz].length);
 	}
 }
@@ -187,14 +187,14 @@ static void iommu_get_scsi_sgl_pflush(struct scatterlist *sg, int sz, struct sbu
 	unsigned long page, oldpage = 0;
 
 	while(sz >= 0) {
-		page = ((unsigned long) sg[sz].address) & PAGE_MASK;
+		page = ((unsigned long) sg[sz].offset) & PAGE_MASK;
 		if (oldpage == page)
 			page += PAGE_SIZE; /* We flushed that page already */
-		while(page < (unsigned long)(sg[sz].address + sg[sz].length)) {
+		while(page < (unsigned long)(page_address(sg[sz].page) + sg[sz].offset + sg[sz].length)) {
 			flush_page_for_dma(page);
 			page += PAGE_SIZE;
 		}
-		sg[sz].dvma_address = (__u32) (sg[sz].address);
+		sg[sz].dvma_address = (__u32) (page_address(sg[sz].page) + sg[sz].offset);
 		sg[sz].dvma_length = (__u32) (sg[sz].length);
 		sz--;
 		oldpage = page - PAGE_SIZE;
diff --git a/arch/sparc/mm/sun4c.c b/arch/sparc/mm/sun4c.c
index 19a50d642..0673df648 100644
--- a/arch/sparc/mm/sun4c.c
+++ b/arch/sparc/mm/sun4c.c
@@ -1,4 +1,4 @@
-/* $Id: sun4c.c,v 1.210 2001-11-13 03:27:47 davem Exp $
+/* $Id: sun4c.c,v 1.211 2001-12-17 07:05:09 davem Exp $
  * sun4c.c: Doing in software what should be done in hardware.
  *
  * Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
@@ -1337,7 +1337,7 @@ static __u32 sun4c_get_scsi_one(char *bufptr, unsigned long len, struct sbus_bus
 static void sun4c_get_scsi_sgl(struct scatterlist *sg, int sz, struct sbus_bus *sbus)
 {
 	while (sz >= 0) {
-		sg[sz].dvma_address = (__u32)sun4c_lockarea(sg[sz].address, sg[sz].length);
+		sg[sz].dvma_address = (__u32)sun4c_lockarea(page_address(sg[sz].page) + sg[sz].offset, sg[sz].length);
 		sg[sz].dvma_length = sg[sz].length;
 		sz--;
 	}
diff --git a/arch/sparc64/kernel/iommu_common.c b/arch/sparc64/kernel/iommu_common.c
index 4269e264c..844342858 100644
--- a/arch/sparc64/kernel/iommu_common.c
+++ b/arch/sparc64/kernel/iommu_common.c
@@ -1,4 +1,4 @@
-/* $Id: iommu_common.c,v 1.8 2001-12-11 11:13:06 davem Exp $
+/* $Id: iommu_common.c,v 1.9 2001-12-17 07:05:09 davem Exp $
  * iommu_common.c: UltraSparc SBUS/PCI common iommu code.
  *
  * Copyright (C) 1999 David S. Miller (davem@redhat.com)
@@ -66,9 +66,7 @@ static int verify_one_map(struct scatterlist *dma_sg, struct scatterlist **__sg,
 
 	daddr = dma_sg->dma_address;
 	sglen = sg->length;
-	sgaddr = (unsigned long) (sg->address ?
-				  sg->address :
-				  page_address(sg->page) + sg->offset);
+	sgaddr = (unsigned long) (page_address(sg->page) + sg->offset);
 	while (dlen > 0) {
 		unsigned long paddr;
 
@@ -118,9 +116,7 @@ static int verify_one_map(struct scatterlist *dma_sg, struct scatterlist **__sg,
 		sg++;
 		if (--nents <= 0)
 			break;
-		sgaddr = (unsigned long) (sg->address ?
-					  sg->address :
-					  page_address(sg->page) + sg->offset);
+		sgaddr = (unsigned long) (page_address(sg->page) + sg->offset);
 		sglen = sg->length;
 	}
 	if (dlen < 0) {
@@ -183,10 +179,11 @@ void verify_sglist(struct scatterlist *sg, int nents, iopte_t *iopte, int npages
 		printk("%016lx.\n", sg->dma_address & IO_PAGE_MASK);
 
 		for (i = 0; i < nents; i++) {
-			printk("sg(%d): address(%p) length(%x) "
+			printk("sg(%d): page_addr(%p) off(%x) length(%x) "
 			       "dma_address[%016lx] dma_length[%016lx]\n",
 			       i,
-			       sg[i].address, sg[i].length,
+			       page_address(sg[i].page), sg[i].offset,
+			       sg[i].length,
 			       sg[i].dma_address, sg[i].dma_length);
 		}
 	}
@@ -201,21 +198,15 @@ unsigned long prepare_sg(struct scatterlist *sg, int nents)
 	unsigned long prev;
 	u32 dent_addr, dent_len;
 
-	prev  = (unsigned long) (sg->address ?
-				 sg->address :
-				 page_address(sg->page) + sg->offset);
+	prev  = (unsigned long) (page_address(sg->page) + sg->offset);
 	prev += (unsigned long) (dent_len = sg->length);
-	dent_addr = (u32) ((unsigned long)(sg->address ?
-					   sg->address :
-					   page_address(sg->page) + sg->offset)
+	dent_addr = (u32) ((unsigned long)(page_address(sg->page) + sg->offset)
 			   & (IO_PAGE_SIZE - 1UL));
 	while (--nents) {
 		unsigned long addr;
 
 		sg++;
-		addr = (unsigned long) (sg->address ?
-					sg->address :
-					page_address(sg->page) + sg->offset);
+		addr = (unsigned long) (page_address(sg->page) + sg->offset);
 		if (! VCONTIG(prev, addr)) {
 			dma_sg->dma_address = dent_addr;
 			dma_sg->dma_length = dent_len;
diff --git a/arch/sparc64/kernel/pci_iommu.c b/arch/sparc64/kernel/pci_iommu.c
index afdcbba76..e5ab444e1 100644
--- a/arch/sparc64/kernel/pci_iommu.c
+++ b/arch/sparc64/kernel/pci_iommu.c
@@ -1,4 +1,4 @@
-/* $Id: pci_iommu.c,v 1.16 2001-10-09 02:24:33 davem Exp $
+/* $Id: pci_iommu.c,v 1.17 2001-12-17 07:05:09 davem Exp $
  * pci_iommu.c: UltraSparc PCI controller IOM/STC support.
  *
  * Copyright (C) 1999 David S. Miller (davem@redhat.com)
@@ -425,9 +425,7 @@ void pci_unmap_single(struct pci_dev *pdev, dma_addr_t bus_addr, size_t sz, int
 }
 
 #define SG_ENT_PHYS_ADDRESS(SG)	\
-	((SG)->address ? \
-	 __pa((SG)->address) : \
-	 (__pa(page_address((SG)->page)) + (SG)->offset))
+	(__pa(page_address((SG)->page)) + (SG)->offset)
 
 static inline void fill_sg(iopte_t *iopte, struct scatterlist *sg,
 			   int nused, int nelems, unsigned long iopte_protection)
@@ -522,9 +520,7 @@ int pci_map_sg(struct pci_dev *pdev, struct scatterlist *sglist, int nelems, int
 	if (nelems == 1) {
 		sglist->dma_address =
 			pci_map_single(pdev,
-				       (sglist->address ?
-					sglist->address :
-					(page_address(sglist->page) + sglist->offset)),
+				       (page_address(sglist->page) + sglist->offset),
 				       sglist->length, direction);
 		sglist->dma_length = sglist->length;
 		return 1;
diff --git a/arch/sparc64/kernel/sbus.c b/arch/sparc64/kernel/sbus.c
index f1c58c3f9..66e468c19 100644
--- a/arch/sparc64/kernel/sbus.c
+++ b/arch/sparc64/kernel/sbus.c
@@ -1,4 +1,4 @@
-/* $Id: sbus.c,v 1.17 2001-10-09 02:24:33 davem Exp $
+/* $Id: sbus.c,v 1.18 2001-12-17 07:05:09 davem Exp $
  * sbus.c: UltraSparc SBUS controller support.
  *
  * Copyright (C) 1999 David S. Miller (davem@redhat.com)
@@ -377,9 +377,7 @@ void sbus_unmap_single(struct sbus_dev *sdev, dma_addr_t dma_addr, size_t size,
 }
 
 #define SG_ENT_PHYS_ADDRESS(SG)	\
-	((SG)->address ? \
-	 __pa((SG)->address) : \
-	 (__pa(page_address((SG)->page)) + (SG)->offset))
+	(__pa(page_address((SG)->page)) + (SG)->offset)
 
 static inline void fill_sg(iopte_t *iopte, struct scatterlist *sg, int nused, int nelems, unsigned long iopte_bits)
 {
@@ -470,9 +468,7 @@ int sbus_map_sg(struct sbus_dev *sdev, struct scatterlist *sg, int nents, int di
 	if (nents == 1) {
 		sg->dma_address =
 			sbus_map_single(sdev,
-					(sg->address ?
-					 sg->address :
-					 (page_address(sg->page) + sg->offset)),
+					(page_address(sg->page) + sg->offset),
 					sg->length, dir);
 		sg->dma_length = sg->length;
 		return 1;
diff --git a/drivers/block/DAC960.h b/drivers/block/DAC960.h
index 71e7db452..760037053 100644
--- a/drivers/block/DAC960.h
+++ b/drivers/block/DAC960.h
@@ -2573,39 +2573,7 @@ void DAC960_ReleaseControllerLockIH(DAC960_Controller_T *Controller,
   spin_unlock_irqrestore(&Controller->RequestQueue->queue_lock, *ProcessorFlags);
 }
 
-
-/*
-  Virtual_to_Bus32 maps from Kernel Virtual Addresses to 32 Bit PCI Bus
-  Addresses.
-*/
-
-static inline DAC960_BusAddress32_T Virtual_to_Bus32(void *VirtualAddress)
-{
-  return (DAC960_BusAddress32_T) virt_to_bus(VirtualAddress);
-}
-
-
-/*
-  Bus32_to_Virtual maps from 32 Bit PCI Bus Addresses to Kernel Virtual
-  Addresses.
-*/
-
-static inline void *Bus32_to_Virtual(DAC960_BusAddress32_T BusAddress)
-{
-  return (void *) bus_to_virt(BusAddress);
-}
-
-
-/*
-  Virtual_to_Bus64 maps from Kernel Virtual Addresses to 64 Bit PCI Bus
-  Addresses.
-*/
-
-static inline DAC960_BusAddress64_T Virtual_to_Bus64(void *VirtualAddress)
-{
-  return (DAC960_BusAddress64_T) virt_to_bus(VirtualAddress);
-}
-
+#error I am a non-portable driver, please convert me to use the Documentation/DMA-mapping.txt interfaces
 
 /*
   Define the DAC960 BA Series Controller Interface Register Offsets.
diff --git a/drivers/block/ll_rw_blk.c b/drivers/block/ll_rw_blk.c
index e5c93889d..e1e1494fd 100644
--- a/drivers/block/ll_rw_blk.c
+++ b/drivers/block/ll_rw_blk.c
@@ -477,7 +477,6 @@ int blk_rq_map_sg(request_queue_t *q, struct request *rq, struct scatterlist *sg
 				sg[nsegs - 1].length += nbytes;
 			} else {
 new_segment:
-				sg[nsegs].address = NULL;
 				sg[nsegs].page = bvec->bv_page;
 				sg[nsegs].length = nbytes;
 				sg[nsegs].offset = bvec->bv_offset;
diff --git a/drivers/block/ps2esdi.c b/drivers/block/ps2esdi.c
index dec02f0f8..b4af9d7ec 100644
--- a/drivers/block/ps2esdi.c
+++ b/drivers/block/ps2esdi.c
@@ -478,7 +478,7 @@ static void do_ps2esdi_request(request_queue_t * q)
 	   list + sanity checks.                     */
 	INIT_REQUEST;
 
-	if (virt_to_bus(CURRENT->buffer + CURRENT->current_nr_sectors * 512) > 16 * MB) {
+	if (isa_virt_to_bus(CURRENT->buffer + CURRENT->current_nr_sectors * 512) > 16 * MB) {
 		printk("%s: DMA above 16MB not supported\n", DEVICE_NAME);
 		end_request(FAIL);
 	}			/* check for above 16Mb dmas */
@@ -666,7 +666,7 @@ static void ps2esdi_prep_dma(char *buffer, u_short length, u_char dma_xmode)
 
 	mca_disable_dma(dma_arb_level);
 
-	mca_set_dma_addr(dma_arb_level, virt_to_bus(buffer));
+	mca_set_dma_addr(dma_arb_level, isa_virt_to_bus(buffer));
 
 	mca_set_dma_count(dma_arb_level, length * 512 / 2);
 
diff --git a/drivers/block/smart1,2.h b/drivers/block/smart1,2.h
index 7db25b2a0..166956be0 100644
--- a/drivers/block/smart1,2.h
+++ b/drivers/block/smart1,2.h
@@ -252,6 +252,7 @@ static unsigned long smart1_completed(ctlr_info_t *h)
 
 		outb(CHANNEL_CLEAR, h->ioaddr + SMART1_LOCAL_DOORBELL);
 
+#error Please convert me to Documentation/DMA-mapping.txt
 		if (cmd) ((cmdlist_t*)bus_to_virt(cmd))->req.hdr.rcode = status;
 	} else {
 		cmd = 0;
diff --git a/drivers/char/esp.c b/drivers/char/esp.c
index 5560c565d..073b28078 100644
--- a/drivers/char/esp.c
+++ b/drivers/char/esp.c
@@ -393,7 +393,7 @@ static _INLINE_ void receive_chars_dma(struct esp_struct *info, int num_bytes)
         disable_dma(dma);
         clear_dma_ff(dma);
         set_dma_mode(dma, DMA_MODE_READ);
-        set_dma_addr(dma, virt_to_bus(dma_buffer));
+        set_dma_addr(dma, isa_virt_to_bus(dma_buffer));
         set_dma_count(dma, dma_bytes);
         enable_dma(dma);
         release_dma_lock(flags);
@@ -570,7 +570,7 @@ static _INLINE_ void transmit_chars_dma(struct esp_struct *info, int num_bytes)
         disable_dma(dma);
         clear_dma_ff(dma);
         set_dma_mode(dma, DMA_MODE_WRITE);
-        set_dma_addr(dma, virt_to_bus(dma_buffer));
+        set_dma_addr(dma, isa_virt_to_bus(dma_buffer));
         set_dma_count(dma, dma_bytes);
         enable_dma(dma);
         release_dma_lock(flags);
@@ -600,7 +600,7 @@ static _INLINE_ void transmit_chars_dma_done(struct esp_struct *info)
         	disable_dma(dma);
         	clear_dma_ff(dma);
         	set_dma_mode(dma, DMA_MODE_WRITE);
-        	set_dma_addr(dma, virt_to_bus(dma_buffer));
+        	set_dma_addr(dma, isa_virt_to_bus(dma_buffer));
         	set_dma_count(dma, dma_bytes);
         	enable_dma(dma);
         	release_dma_lock(flags);
diff --git a/drivers/char/synclink.c b/drivers/char/synclink.c
index 5c8d4f3fb..721271198 100644
--- a/drivers/char/synclink.c
+++ b/drivers/char/synclink.c
@@ -60,6 +60,8 @@
 #  define BREAKPOINT() { }
 #endif
 
+#error Please convert me to Documentation/DMA-mapping.txt
+
 #define MAX_ISA_DEVICES 10
 #define MAX_PCI_DEVICES 10
 #define MAX_TOTAL_DEVICES 20
diff --git a/drivers/char/tpqic02.c b/drivers/char/tpqic02.c
index 1bdc186d9..848e4da61 100644
--- a/drivers/char/tpqic02.c
+++ b/drivers/char/tpqic02.c
@@ -1408,7 +1408,7 @@ static inline void dma_transfer(void)
 	clear_dma_ff(QIC02_TAPE_DMA);
 	set_dma_mode(QIC02_TAPE_DMA, dma_mode);
 	set_dma_addr(QIC02_TAPE_DMA,
-		     virt_to_bus(buffaddr) + dma_bytes_done);
+		     isa_virt_to_bus(buffaddr) + dma_bytes_done);
 	set_dma_count(QIC02_TAPE_DMA, TAPE_BLKSIZE);
 
 	/* start tape DMA controller */
diff --git a/drivers/message/i2o/i2o_block.c b/drivers/message/i2o/i2o_block.c
index c64b7393b..84f135bd4 100644
--- a/drivers/message/i2o/i2o_block.c
+++ b/drivers/message/i2o/i2o_block.c
@@ -40,6 +40,8 @@
  *		Serial number scanning to find duplicates for FC multipathing
  */
 
+#error Please convert me to Documentation/DMA-mapping.txt
+
 #include <linux/major.h>
 
 #include <linux/module.h>
diff --git a/drivers/message/i2o/i2o_config.c b/drivers/message/i2o/i2o_config.c
index 2d6d6b539..9bea2535d 100644
--- a/drivers/message/i2o/i2o_config.c
+++ b/drivers/message/i2o/i2o_config.c
@@ -25,6 +25,8 @@
  * 2 of the License, or (at your option) any later version.
  */
 
+#error Please convert me to Documentation/DMA-mapping.txt
+
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/pci.h>
diff --git a/drivers/message/i2o/i2o_core.c b/drivers/message/i2o/i2o_core.c
index 801037a47..58465ff52 100644
--- a/drivers/message/i2o/i2o_core.c
+++ b/drivers/message/i2o/i2o_core.c
@@ -22,6 +22,8 @@
  * 
  */
 
+#error Please convert me to Documentation/DMA-mapping.txt
+
 #include <linux/config.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
diff --git a/drivers/message/i2o/i2o_lan.c b/drivers/message/i2o/i2o_lan.c
index 4c16aa854..856e5552a 100644
--- a/drivers/message/i2o/i2o_lan.c
+++ b/drivers/message/i2o/i2o_lan.c
@@ -25,6 +25,8 @@
  *	TODO:		tests for other LAN classes (Token Ring, Fibre Channel)
  */
 
+#error Please convert me to Documentation/DMA-mapping.txt
+
 #include <linux/config.h>
 #include <linux/module.h>
 
diff --git a/drivers/message/i2o/i2o_scsi.c b/drivers/message/i2o/i2o_scsi.c
index 49d80260a..a14399223 100644
--- a/drivers/message/i2o/i2o_scsi.c
+++ b/drivers/message/i2o/i2o_scsi.c
@@ -31,6 +31,8 @@
  *		Fix the resource management problems.
  */
 
+#error Please convert me to Documentation/DMA-mapping.txt
+
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
diff --git a/drivers/net/3c505.c b/drivers/net/3c505.c
index 7f91256e6..8386addb6 100644
--- a/drivers/net/3c505.c
+++ b/drivers/net/3c505.c
@@ -630,7 +630,7 @@ static void receive_packet(struct net_device *dev, int len)
 	disable_dma(dev->dma);
 	clear_dma_ff(dev->dma);
 	set_dma_mode(dev->dma, 0x04);	/* dma read */
-	set_dma_addr(dev->dma, virt_to_bus(target));
+	set_dma_addr(dev->dma, isa_virt_to_bus(target));
 	set_dma_count(dev->dma, rlen);
 	enable_dma(dev->dma);
 	release_dma_lock(flags);
@@ -1029,10 +1029,10 @@ static int send_packet(struct net_device *dev, struct sk_buff *skb)
 
 	if ((unsigned long)(skb->data + nlen) >= MAX_DMA_ADDRESS) {
 		memcpy(adapter->dma_buffer, skb->data, nlen);
-		target = virt_to_bus(adapter->dma_buffer);
+		target = isa_virt_to_bus(adapter->dma_buffer);
 	}
 	else {
-		target = virt_to_bus(skb->data);
+		target = isa_virt_to_bus(skb->data);
 	}
 	adapter->current_dma.skb = skb;
 
diff --git a/drivers/net/3c515.c b/drivers/net/3c515.c
index de2013540..83cecdc7e 100644
--- a/drivers/net/3c515.c
+++ b/drivers/net/3c515.c
@@ -844,7 +844,7 @@ static int corkscrew_open(struct net_device *dev)
 			struct sk_buff *skb;
 			if (i < (RX_RING_SIZE - 1))
 				vp->rx_ring[i].next =
-				    virt_to_bus(&vp->rx_ring[i + 1]);
+				    isa_virt_to_bus(&vp->rx_ring[i + 1]);
 			else
 				vp->rx_ring[i].next = 0;
 			vp->rx_ring[i].status = 0;	/* Clear complete bit. */
@@ -855,10 +855,10 @@ static int corkscrew_open(struct net_device *dev)
 				break;	/* Bad news!  */
 			skb->dev = dev;	/* Mark as being used by this device. */
 			skb_reserve(skb, 2);	/* Align IP on 16 byte boundaries */
-			vp->rx_ring[i].addr = virt_to_bus(skb->tail);
+			vp->rx_ring[i].addr = isa_virt_to_bus(skb->tail);
 		}
-		vp->rx_ring[i - 1].next = virt_to_bus(&vp->rx_ring[0]);	/* Wrap the ring. */
-		outl(virt_to_bus(&vp->rx_ring[0]), ioaddr + UpListPtr);
+		vp->rx_ring[i - 1].next = isa_virt_to_bus(&vp->rx_ring[0]);	/* Wrap the ring. */
+		outl(isa_virt_to_bus(&vp->rx_ring[0]), ioaddr + UpListPtr);
 	}
 	if (vp->full_bus_master_tx) {	/* Boomerang bus master Tx. */
 		vp->cur_tx = vp->dirty_tx = 0;
@@ -1053,7 +1053,7 @@ static int corkscrew_start_xmit(struct sk_buff *skb,
 		/* vp->tx_full = 1; */
 		vp->tx_skbuff[entry] = skb;
 		vp->tx_ring[entry].next = 0;
-		vp->tx_ring[entry].addr = virt_to_bus(skb->data);
+		vp->tx_ring[entry].addr = isa_virt_to_bus(skb->data);
 		vp->tx_ring[entry].length = skb->len | 0x80000000;
 		vp->tx_ring[entry].status = skb->len | 0x80000000;
 
@@ -1066,9 +1066,9 @@ static int corkscrew_start_xmit(struct sk_buff *skb,
 			    0) break;
 		if (prev_entry)
 			prev_entry->next =
-			    virt_to_bus(&vp->tx_ring[entry]);
+			    isa_virt_to_bus(&vp->tx_ring[entry]);
 		if (inl(ioaddr + DownListPtr) == 0) {
-			outl(virt_to_bus(&vp->tx_ring[entry]),
+			outl(isa_virt_to_bus(&vp->tx_ring[entry]),
 			     ioaddr + DownListPtr);
 			queued_packet++;
 		}
@@ -1205,7 +1205,7 @@ static void corkscrew_interrupt(int irq, void *dev_id,
 			while (lp->cur_tx - dirty_tx > 0) {
 				int entry = dirty_tx % TX_RING_SIZE;
 				if (inl(ioaddr + DownListPtr) ==
-				    virt_to_bus(&lp->tx_ring[entry]))
+				    isa_virt_to_bus(&lp->tx_ring[entry]))
 					break;	/* It still hasn't been processed. */
 				if (lp->tx_skbuff[entry]) {
 					dev_kfree_skb_irq(lp->
@@ -1414,7 +1414,7 @@ static int boomerang_rx(struct net_device *dev)
 				skb_reserve(skb, 2);	/* Align IP on 16 byte boundaries */
 				/* 'skb_put()' points to the start of sk_buff data area. */
 				memcpy(skb_put(skb, pkt_len),
-				       bus_to_virt(vp->rx_ring[entry].
+				       isa_bus_to_virt(vp->rx_ring[entry].
 						   addr), pkt_len);
 				rx_copy++;
 			} else {
@@ -1424,11 +1424,11 @@ static int boomerang_rx(struct net_device *dev)
 				vp->rx_skbuff[entry] = NULL;
 				temp = skb_put(skb, pkt_len);
 				/* Remove this checking code for final release. */
-				if (bus_to_virt(vp->rx_ring[entry].addr) != temp)
+				if (isa_bus_to_virt(vp->rx_ring[entry].addr) != temp)
 					    printk("%s: Warning -- the skbuff addresses do not match"
 					     " in boomerang_rx: %p vs. %p / %p.\n",
 					     dev->name,
-					     bus_to_virt(vp->
+					     isa_bus_to_virt(vp->
 							 rx_ring[entry].
 							 addr), skb->head,
 					     temp);
@@ -1451,7 +1451,7 @@ static int boomerang_rx(struct net_device *dev)
 				break;	/* Bad news!  */
 			skb->dev = dev;	/* Mark as being used by this device. */
 			skb_reserve(skb, 2);	/* Align IP on 16 byte boundaries */
-			vp->rx_ring[entry].addr = virt_to_bus(skb->tail);
+			vp->rx_ring[entry].addr = isa_virt_to_bus(skb->tail);
 			vp->rx_skbuff[entry] = skb;
 		}
 		vp->rx_ring[entry].status = 0;	/* Clear complete bit. */
diff --git a/drivers/net/3c523.c b/drivers/net/3c523.c
index 64d559cf2..eb2480f3a 100644
--- a/drivers/net/3c523.c
+++ b/drivers/net/3c523.c
@@ -304,13 +304,13 @@ static int __init check586(struct net_device *dev, unsigned long where, unsigned
 	char *iscp_addrs[2];
 	int i = 0;
 
-	p->base = (unsigned long) bus_to_virt((unsigned long)where) + size - 0x01000000;
-	p->memtop = bus_to_virt((unsigned long)where) + size;
+	p->base = (unsigned long) isa_bus_to_virt((unsigned long)where) + size - 0x01000000;
+	p->memtop = isa_bus_to_virt((unsigned long)where) + size;
 	p->scp = (struct scp_struct *)(p->base + SCP_DEFAULT_ADDRESS);
 	memset((char *) p->scp, 0, sizeof(struct scp_struct));
 	p->scp->sysbus = SYSBUSVAL;	/* 1 = 8Bit-Bus, 0 = 16 Bit */
 
-	iscp_addrs[0] = bus_to_virt((unsigned long)where);
+	iscp_addrs[0] = isa_bus_to_virt((unsigned long)where);
 	iscp_addrs[1] = (char *) p->scp - sizeof(struct iscp_struct);
 
 	for (i = 0; i < 2; i++) {
@@ -347,7 +347,7 @@ void alloc586(struct net_device *dev)
 	DELAY(2);
 
 	p->scp = (struct scp_struct *) (p->base + SCP_DEFAULT_ADDRESS);
-	p->scb = (struct scb_struct *) bus_to_virt(dev->mem_start);
+	p->scb = (struct scb_struct *) isa_bus_to_virt(dev->mem_start);
 	p->iscp = (struct iscp_struct *) ((char *) p->scp - sizeof(struct iscp_struct));
 
 	memset((char *) p->iscp, 0, sizeof(struct iscp_struct));
@@ -529,8 +529,8 @@ int __init elmc_probe(struct net_device *dev)
 	}
 	dev->mem_end = dev->mem_start + size;	/* set mem_end showed by 'ifconfig' */
 
-	pr->memtop = bus_to_virt(dev->mem_start) + size;
-	pr->base = (unsigned long) bus_to_virt(dev->mem_start) + size - 0x01000000;
+	pr->memtop = isa_bus_to_virt(dev->mem_start) + size;
+	pr->base = (unsigned long) isa_bus_to_virt(dev->mem_start) + size - 0x01000000;
 	alloc586(dev);
 
 	elmc_id_reset586();	/* make sure it doesn't generate spurious ints */
diff --git a/drivers/net/3c527.c b/drivers/net/3c527.c
index 7aa8c837e..75bd0aedb 100644
--- a/drivers/net/3c527.c
+++ b/drivers/net/3c527.c
@@ -470,16 +470,16 @@ static int __init mc32_probe1(struct net_device *dev, int slot)
 		base|=(inb(dev->base_addr)<<(8*i));
 	}
 	
-	lp->exec_box=bus_to_virt(dev->mem_start+base);
+	lp->exec_box=isa_bus_to_virt(dev->mem_start+base);
 	
 	base=lp->exec_box->data[1]<<16|lp->exec_box->data[0];  
 	
 	lp->base = dev->mem_start+base;
 	
-	lp->rx_box=bus_to_virt(lp->base + lp->exec_box->data[2]); 
-	lp->tx_box=bus_to_virt(lp->base + lp->exec_box->data[3]);
+	lp->rx_box=isa_bus_to_virt(lp->base + lp->exec_box->data[2]); 
+	lp->tx_box=isa_bus_to_virt(lp->base + lp->exec_box->data[3]);
 	
-	lp->stats = bus_to_virt(lp->base + lp->exec_box->data[5]);
+	lp->stats = isa_bus_to_virt(lp->base + lp->exec_box->data[5]);
 
 	/*
 	 *	Descriptor chains (card relative)
@@ -781,10 +781,10 @@ static int mc32_load_rx_ring(struct net_device *dev)
 			return -ENOBUFS;
 		}
 		
-		p=bus_to_virt(lp->base+rx_base);
+		p=isa_bus_to_virt(lp->base+rx_base);
 				
 		p->control=0;
-		p->data=virt_to_bus(lp->rx_ring[i].skb->data);
+		p->data=isa_virt_to_bus(lp->rx_ring[i].skb->data);
 		p->status=0;
 		p->length=1532;
 	
@@ -854,7 +854,7 @@ static void mc32_load_tx_ring(struct net_device *dev)
 
 	for(i=0;i<lp->tx_len;i++) 
 	{
-		p=bus_to_virt(lp->base+tx_base);
+		p=isa_bus_to_virt(lp->base+tx_base);
 		lp->tx_ring[i].p=p; 
 		lp->tx_ring[i].skb=NULL;
 
@@ -1080,7 +1080,7 @@ static int mc32_send_packet(struct sk_buff *skb, struct net_device *dev)
    	   
 	np->length = (skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len; 
 			
-	np->data	= virt_to_bus(skb->data);
+	np->data	= isa_virt_to_bus(skb->data);
 	np->status	= 0;
 	np->control     = CONTROL_EOP | CONTROL_EOL;     
 	wmb();
@@ -1197,7 +1197,7 @@ static void mc32_rx_ring(struct net_device *dev)
 				
 				skb_reserve(newskb,18); 
 				lp->rx_ring[rx_ring_tail].skb=newskb;  
-				p->data=virt_to_bus(newskb->data);  
+				p->data=isa_virt_to_bus(newskb->data);  
 			} 
 			else 
 			{
diff --git a/drivers/net/ac3200.c b/drivers/net/ac3200.c
index 2daff4189..7cac66793 100644
--- a/drivers/net/ac3200.c
+++ b/drivers/net/ac3200.c
@@ -205,10 +205,10 @@ static int __init ac_probe1(int ioaddr, struct net_device *dev)
 	 *  the card mem within the region covered by `normal' RAM  !!!
 	 */
 	if (dev->mem_start > 1024*1024) {	/* phys addr > 1MB */
-		if (dev->mem_start < virt_to_bus(high_memory)) {
+		if (dev->mem_start < virt_to_phys(high_memory)) {
 			printk(KERN_CRIT "ac3200.c: Card RAM overlaps with normal memory!!!\n");
 			printk(KERN_CRIT "ac3200.c: Use EISA SCU to set card memory below 1MB,\n");
-			printk(KERN_CRIT "ac3200.c: or to an address above 0x%lx.\n", virt_to_bus(high_memory));
+			printk(KERN_CRIT "ac3200.c: or to an address above 0x%lx.\n", virt_to_phys(high_memory));
 			printk(KERN_CRIT "ac3200.c: Driver NOT installed.\n");
 			retval = -EINVAL;
 			goto out2;
diff --git a/drivers/net/cs89x0.c b/drivers/net/cs89x0.c
index b21549c65..435b9105e 100644
--- a/drivers/net/cs89x0.c
+++ b/drivers/net/cs89x0.c
@@ -1109,7 +1109,7 @@ net_open(struct net_device *dev)
 				printk(	"%s: dma %lx %lx\n",
 					dev->name,
 					(unsigned long)lp->dma_buff,
-					(unsigned long)virt_to_bus(lp->dma_buff));
+					(unsigned long)isa_virt_to_bus(lp->dma_buff));
 			}
 			if ((unsigned long) lp->dma_buff >= MAX_DMA_ADDRESS ||
 			    !dma_page_eq(lp->dma_buff, lp->dma_buff+lp->dmasize*1024-1)) {
@@ -1128,7 +1128,7 @@ net_open(struct net_device *dev)
 			disable_dma(dev->dma);
 			clear_dma_ff(dev->dma);
 			set_dma_mode(dev->dma, 0x14); /* auto_init as well */
-			set_dma_addr(dev->dma, virt_to_bus(lp->dma_buff));
+			set_dma_addr(dev->dma, isa_virt_to_bus(lp->dma_buff));
 			set_dma_count(dev->dma, lp->dmasize*1024);
 			enable_dma(dev->dma);
 			spin_unlock_irqrestore(&lp->lock, flags);
diff --git a/drivers/net/defxx.c b/drivers/net/defxx.c
index d079bd417..d3f14dba1 100644
--- a/drivers/net/defxx.c
+++ b/drivers/net/defxx.c
@@ -199,6 +199,8 @@
  *		Feb 2001	davej		PCI enable cleanups.
  */
 
+#error I am non-portable, please convert me to Documentation/DMA-mapping.txt
+
 /* Include files */
 
 #include <linux/module.h>
diff --git a/drivers/net/dl2k.h b/drivers/net/dl2k.h
index fb1a8cd25..985468c60 100644
--- a/drivers/net/dl2k.h
+++ b/drivers/net/dl2k.h
@@ -791,6 +791,7 @@ debug_pkt_dump (struct netdev_private *np, int pkt_len)
 	}
 	if (np->rx_debug == 7) {
 
+#error Please convert me to Documentation/DMA-mapping.txt
 		phead =
 		    bus_to_virt (le64_to_cpu (desc->fraginfo & 0xffffffffff));
 		for (pchar = phead, i = 0; i < pkt_len; i++, pchar++) {
diff --git a/drivers/net/hp100.c b/drivers/net/hp100.c
index 0b25e65b9..20de7eefc 100644
--- a/drivers/net/hp100.c
+++ b/drivers/net/hp100.c
@@ -83,6 +83,8 @@
 **
 */
 
+#error I am non-portable, please convert me to Documentation/DMA-mapping.txt
+
 #define HP100_DEFAULT_PRIORITY_TX 0
 
 #undef HP100_DEBUG
diff --git a/drivers/net/lance.c b/drivers/net/lance.c
index ac7a07cb5..3122340f2 100644
--- a/drivers/net/lance.c
+++ b/drivers/net/lance.c
@@ -495,15 +495,15 @@ static int __init lance_probe1(struct net_device *dev, int ioaddr, int irq, int
 		lp->init_block.phys_addr[i] = dev->dev_addr[i];
 	lp->init_block.filter[0] = 0x00000000;
 	lp->init_block.filter[1] = 0x00000000;
-	lp->init_block.rx_ring = ((u32)virt_to_bus(lp->rx_ring) & 0xffffff) | RX_RING_LEN_BITS;
-	lp->init_block.tx_ring = ((u32)virt_to_bus(lp->tx_ring) & 0xffffff) | TX_RING_LEN_BITS;
+	lp->init_block.rx_ring = ((u32)isa_virt_to_bus(lp->rx_ring) & 0xffffff) | RX_RING_LEN_BITS;
+	lp->init_block.tx_ring = ((u32)isa_virt_to_bus(lp->tx_ring) & 0xffffff) | TX_RING_LEN_BITS;
 
 	outw(0x0001, ioaddr+LANCE_ADDR);
 	inw(ioaddr+LANCE_ADDR);
-	outw((short) (u32) virt_to_bus(&lp->init_block), ioaddr+LANCE_DATA);
+	outw((short) (u32) isa_virt_to_bus(&lp->init_block), ioaddr+LANCE_DATA);
 	outw(0x0002, ioaddr+LANCE_ADDR);
 	inw(ioaddr+LANCE_ADDR);
-	outw(((u32)virt_to_bus(&lp->init_block)) >> 16, ioaddr+LANCE_DATA);
+	outw(((u32)isa_virt_to_bus(&lp->init_block)) >> 16, ioaddr+LANCE_DATA);
 	outw(0x0000, ioaddr+LANCE_ADDR);
 	inw(ioaddr+LANCE_ADDR);
 
@@ -704,16 +704,16 @@ lance_open(struct net_device *dev)
 	if (lance_debug > 1)
 		printk("%s: lance_open() irq %d dma %d tx/rx rings %#x/%#x init %#x.\n",
 			   dev->name, dev->irq, dev->dma,
-		           (u32) virt_to_bus(lp->tx_ring),
-		           (u32) virt_to_bus(lp->rx_ring),
-			   (u32) virt_to_bus(&lp->init_block));
+		           (u32) isa_virt_to_bus(lp->tx_ring),
+		           (u32) isa_virt_to_bus(lp->rx_ring),
+			   (u32) isa_virt_to_bus(&lp->init_block));
 
 	lance_init_ring(dev, GFP_KERNEL);
 	/* Re-initialize the LANCE, and start it when done. */
 	outw(0x0001, ioaddr+LANCE_ADDR);
-	outw((short) (u32) virt_to_bus(&lp->init_block), ioaddr+LANCE_DATA);
+	outw((short) (u32) isa_virt_to_bus(&lp->init_block), ioaddr+LANCE_DATA);
 	outw(0x0002, ioaddr+LANCE_ADDR);
-	outw(((u32)virt_to_bus(&lp->init_block)) >> 16, ioaddr+LANCE_DATA);
+	outw(((u32)isa_virt_to_bus(&lp->init_block)) >> 16, ioaddr+LANCE_DATA);
 
 	outw(0x0004, ioaddr+LANCE_ADDR);
 	outw(0x0915, ioaddr+LANCE_DATA);
@@ -735,7 +735,7 @@ lance_open(struct net_device *dev)
 
 	if (lance_debug > 2)
 		printk("%s: LANCE open after %d ticks, init block %#x csr0 %4.4x.\n",
-			   dev->name, i, (u32) virt_to_bus(&lp->init_block), inw(ioaddr+LANCE_DATA));
+			   dev->name, i, (u32) isa_virt_to_bus(&lp->init_block), inw(ioaddr+LANCE_DATA));
 
 	return 0;					/* Always succeed */
 }
@@ -799,7 +799,7 @@ lance_init_ring(struct net_device *dev, int gfp)
 		if (rx_buff == NULL)
 			lp->rx_ring[i].base = 0;
 		else
-			lp->rx_ring[i].base = (u32)virt_to_bus(rx_buff) | 0x80000000;
+			lp->rx_ring[i].base = (u32)isa_virt_to_bus(rx_buff) | 0x80000000;
 		lp->rx_ring[i].buf_length = -PKT_BUF_SZ;
 	}
 	/* The Tx buffer address is filled in as needed, but we do need to clear
@@ -814,8 +814,8 @@ lance_init_ring(struct net_device *dev, int gfp)
 		lp->init_block.phys_addr[i] = dev->dev_addr[i];
 	lp->init_block.filter[0] = 0x00000000;
 	lp->init_block.filter[1] = 0x00000000;
-	lp->init_block.rx_ring = ((u32)virt_to_bus(lp->rx_ring) & 0xffffff) | RX_RING_LEN_BITS;
-	lp->init_block.tx_ring = ((u32)virt_to_bus(lp->tx_ring) & 0xffffff) | TX_RING_LEN_BITS;
+	lp->init_block.rx_ring = ((u32)isa_virt_to_bus(lp->rx_ring) & 0xffffff) | RX_RING_LEN_BITS;
+	lp->init_block.tx_ring = ((u32)isa_virt_to_bus(lp->tx_ring) & 0xffffff) | TX_RING_LEN_BITS;
 }
 
 static void
@@ -904,17 +904,17 @@ static int lance_start_xmit(struct sk_buff *skb, struct net_device *dev)
 
 	/* If any part of this buffer is >16M we must copy it to a low-memory
 	   buffer. */
-	if ((u32)virt_to_bus(skb->data) + skb->len > 0x01000000) {
+	if ((u32)isa_virt_to_bus(skb->data) + skb->len > 0x01000000) {
 		if (lance_debug > 5)
 			printk("%s: bouncing a high-memory packet (%#x).\n",
-				   dev->name, (u32)virt_to_bus(skb->data));
+				   dev->name, (u32)isa_virt_to_bus(skb->data));
 		memcpy(&lp->tx_bounce_buffs[entry], skb->data, skb->len);
 		lp->tx_ring[entry].base =
-			((u32)virt_to_bus((lp->tx_bounce_buffs + entry)) & 0xffffff) | 0x83000000;
+			((u32)isa_virt_to_bus((lp->tx_bounce_buffs + entry)) & 0xffffff) | 0x83000000;
 		dev_kfree_skb(skb);
 	} else {
 		lp->tx_skbuff[entry] = skb;
-		lp->tx_ring[entry].base = ((u32)virt_to_bus(skb->data) & 0xffffff) | 0x83000000;
+		lp->tx_ring[entry].base = ((u32)isa_virt_to_bus(skb->data) & 0xffffff) | 0x83000000;
 	}
 	lp->cur_tx++;
 
@@ -1112,7 +1112,7 @@ lance_rx(struct net_device *dev)
 				skb_reserve(skb,2);	/* 16 byte align */
 				skb_put(skb,pkt_len);	/* Make room */
 				eth_copy_and_sum(skb,
-					(unsigned char *)bus_to_virt((lp->rx_ring[entry].base & 0x00ffffff)),
+					(unsigned char *)isa_bus_to_virt((lp->rx_ring[entry].base & 0x00ffffff)),
 					pkt_len,0);
 				skb->protocol=eth_type_trans(skb,dev);
 				netif_rx(skb);
diff --git a/drivers/net/lasi_82596.c b/drivers/net/lasi_82596.c
index 54d5c958d..e93eb24ef 100644
--- a/drivers/net/lasi_82596.c
+++ b/drivers/net/lasi_82596.c
@@ -1184,7 +1184,7 @@ static int __init i82596_probe(struct net_device *dev, int options)
 			printk("%s: Couldn't get shared memory\n", dev->name);
 			return -ENOMEM;
 		}
-		dma_addr = virt_to_bus(dev->mem_start);
+		dma_addr = virt_to_phys(dev->mem_start);
 	}
 
 	ether_setup(dev);
diff --git a/drivers/net/lne390.c b/drivers/net/lne390.c
index b80f23916..c1e925d2f 100644
--- a/drivers/net/lne390.c
+++ b/drivers/net/lne390.c
@@ -226,10 +226,10 @@ static int __init lne390_probe1(struct net_device *dev, int ioaddr)
 	   the card mem within the region covered by `normal' RAM  !!!
 	*/
 	if (dev->mem_start > 1024*1024) {	/* phys addr > 1MB */
-		if (dev->mem_start < virt_to_bus(high_memory)) {
+		if (dev->mem_start < virt_to_phys(high_memory)) {
 			printk(KERN_CRIT "lne390.c: Card RAM overlaps with normal memory!!!\n");
 			printk(KERN_CRIT "lne390.c: Use EISA SCU to set card memory below 1MB,\n");
-			printk(KERN_CRIT "lne390.c: or to an address above 0x%lx.\n", virt_to_bus(high_memory));
+			printk(KERN_CRIT "lne390.c: or to an address above 0x%lx.\n", virt_to_phys(high_memory));
 			printk(KERN_CRIT "lne390.c: Driver NOT installed.\n");
 			ret = -EINVAL;
 			goto cleanup;
diff --git a/drivers/net/ne3210.c b/drivers/net/ne3210.c
index 6b408b118..b2a1f3a6c 100644
--- a/drivers/net/ne3210.c
+++ b/drivers/net/ne3210.c
@@ -213,10 +213,10 @@ static int __init ne3210_probe1(struct net_device *dev, int ioaddr)
 	   the card mem within the region covered by `normal' RAM  !!!
 	*/
 	if (dev->mem_start > 1024*1024) {	/* phys addr > 1MB */
-		if (dev->mem_start < virt_to_bus(high_memory)) {
+		if (dev->mem_start < virt_to_phys(high_memory)) {
 			printk(KERN_CRIT "ne3210.c: Card RAM overlaps with normal memory!!!\n");
 			printk(KERN_CRIT "ne3210.c: Use EISA SCU to set card memory below 1MB,\n");
-			printk(KERN_CRIT "ne3210.c: or to an address above 0x%lx.\n", virt_to_bus(high_memory));
+			printk(KERN_CRIT "ne3210.c: or to an address above 0x%lx.\n", virt_to_phys(high_memory));
 			printk(KERN_CRIT "ne3210.c: Driver NOT installed.\n");
 			retval = -EINVAL;
 			goto out2;
diff --git a/drivers/net/ni52.c b/drivers/net/ni52.c
index d222d5480..e89fae619 100644
--- a/drivers/net/ni52.c
+++ b/drivers/net/ni52.c
@@ -286,8 +286,8 @@ static int check586(struct net_device *dev,char *where,unsigned size)
 	char *iscp_addrs[2];
 	int i;
 
-	p->base = (unsigned long) bus_to_virt((unsigned long)where) + size - 0x01000000;
-	p->memtop = bus_to_virt((unsigned long)where) + size;
+	p->base = (unsigned long) isa_bus_to_virt((unsigned long)where) + size - 0x01000000;
+	p->memtop = isa_bus_to_virt((unsigned long)where) + size;
 	p->scp = (struct scp_struct *)(p->base + SCP_DEFAULT_ADDRESS);
 	memset((char *)p->scp,0, sizeof(struct scp_struct));
 	for(i=0;i<sizeof(struct scp_struct);i++) /* memory was writeable? */
@@ -297,7 +297,7 @@ static int check586(struct net_device *dev,char *where,unsigned size)
 	if(p->scp->sysbus != SYSBUSVAL)
 		return 0;
 
-	iscp_addrs[0] = bus_to_virt((unsigned long)where);
+	iscp_addrs[0] = isa_bus_to_virt((unsigned long)where);
 	iscp_addrs[1]= (char *) p->scp - sizeof(struct iscp_struct);
 
 	for(i=0;i<2;i++)
@@ -329,7 +329,7 @@ static void alloc586(struct net_device *dev)
 	DELAY(1);
 
 	p->scp	= (struct scp_struct *)	(p->base + SCP_DEFAULT_ADDRESS);
-	p->scb	= (struct scb_struct *)	bus_to_virt(dev->mem_start);
+	p->scb	= (struct scb_struct *)	isa_bus_to_virt(dev->mem_start);
 	p->iscp = (struct iscp_struct *) ((char *)p->scp - sizeof(struct iscp_struct));
 
 	memset((char *) p->iscp,0,sizeof(struct iscp_struct));
@@ -477,8 +477,8 @@ static int __init ni52_probe1(struct net_device *dev,int ioaddr)
 																	/* warning: we don't free it on errors */
 	memset((char *) dev->priv,0,sizeof(struct priv));
 
-	((struct priv *) (dev->priv))->memtop = bus_to_virt(dev->mem_start) + size;
-	((struct priv *) (dev->priv))->base =	(unsigned long) bus_to_virt(dev->mem_start) + size - 0x01000000;
+	((struct priv *) (dev->priv))->memtop = isa_bus_to_virt(dev->mem_start) + size;
+	((struct priv *) (dev->priv))->base =	(unsigned long) isa_bus_to_virt(dev->mem_start) + size - 0x01000000;
 	alloc586(dev);
 
 	/* set number of receive-buffs according to memsize */
diff --git a/drivers/net/ni65.c b/drivers/net/ni65.c
index 84f5a31ae..849b1852d 100644
--- a/drivers/net/ni65.c
+++ b/drivers/net/ni65.c
@@ -507,10 +507,10 @@ static void ni65_init_lance(struct priv *p,unsigned char *daddr,int filter,int m
 		p->ib.filter[i] = filter;
 	p->ib.mode = mode;
 
-	p->ib.trp = (u32) virt_to_bus(p->tmdhead) | TMDNUMMASK;
-	p->ib.rrp = (u32) virt_to_bus(p->rmdhead) | RMDNUMMASK;
+	p->ib.trp = (u32) isa_virt_to_bus(p->tmdhead) | TMDNUMMASK;
+	p->ib.rrp = (u32) isa_virt_to_bus(p->rmdhead) | RMDNUMMASK;
 	writereg(0,CSR3);	/* busmaster/no word-swap */
-	pib = (u32) virt_to_bus(&p->ib);
+	pib = (u32) isa_virt_to_bus(&p->ib);
 	writereg(pib & 0xffff,CSR1);
 	writereg(pib >> 16,CSR2);
 
@@ -551,7 +551,7 @@ static void *ni65_alloc_mem(struct net_device *dev,char *what,int size,int type)
 			return NULL;
 		}
 	}
-	if( (u32) virt_to_bus(ptr+size) > 0x1000000) {
+	if( (u32) virt_to_phys(ptr+size) > 0x1000000) {
 		printk("%s: unable to allocate %s memory in lower 16MB!\n",dev->name,what);
 		if(type)
 			kfree_skb(skb);
@@ -683,7 +683,7 @@ static void ni65_stop_start(struct net_device *dev,struct priv *p)
 #ifdef XMT_VIA_SKB
 			skb_save[i] = p->tmd_skb[i];
 #endif
-			buffer[i] = (u32) bus_to_virt(tmdp->u.buffer);
+			buffer[i] = (u32) isa_bus_to_virt(tmdp->u.buffer);
 			blen[i] = tmdp->blen;
 			tmdp->u.s.status = 0x0;
 		}
@@ -697,7 +697,7 @@ static void ni65_stop_start(struct net_device *dev,struct priv *p)
 
 		for(i=0;i<TMDNUM;i++) {
 			int num = (i + p->tmdlast) & (TMDNUM-1);
-			p->tmdhead[i].u.buffer = (u32) virt_to_bus((char *)buffer[num]); /* status is part of buffer field */
+			p->tmdhead[i].u.buffer = (u32) isa_virt_to_bus((char *)buffer[num]); /* status is part of buffer field */
 			p->tmdhead[i].blen = blen[num];
 			if(p->tmdhead[i].u.s.status & XMIT_OWN) {
 				 p->tmdnum = (p->tmdnum + 1) & (TMDNUM-1);
@@ -766,9 +766,9 @@ static int ni65_lance_reinit(struct net_device *dev)
 	 {
 		 struct rmd *rmdp = p->rmdhead + i;
 #ifdef RCV_VIA_SKB
-		 rmdp->u.buffer = (u32) virt_to_bus(p->recv_skb[i]->data);
+		 rmdp->u.buffer = (u32) isa_virt_to_bus(p->recv_skb[i]->data);
 #else
-		 rmdp->u.buffer = (u32) virt_to_bus(p->recvbounce[i]);
+		 rmdp->u.buffer = (u32) isa_virt_to_bus(p->recvbounce[i]);
 #endif
 		 rmdp->blen = -(R_BUF_SIZE-8);
 		 rmdp->mlen = 0;
@@ -1033,7 +1033,7 @@ static void ni65_recv_intr(struct net_device *dev,int csr0)
 					struct sk_buff *skb1 = p->recv_skb[p->rmdnum];
 					skb_put(skb,R_BUF_SIZE);
 					p->recv_skb[p->rmdnum] = skb;
-					rmdp->u.buffer = (u32) virt_to_bus(skb->data);
+					rmdp->u.buffer = (u32) isa_virt_to_bus(skb->data);
 					skb = skb1;
 					skb_trim(skb,len);
 				}
@@ -1115,7 +1115,7 @@ static int ni65_send_packet(struct sk_buff *skb, struct net_device *dev)
 			cli();
 
 			tmdp = p->tmdhead + p->tmdnum;
-			tmdp->u.buffer = (u32) virt_to_bus(p->tmdbounce[p->tmdbouncenum]);
+			tmdp->u.buffer = (u32) isa_virt_to_bus(p->tmdbounce[p->tmdbouncenum]);
 			p->tmdbouncenum = (p->tmdbouncenum + 1) & (TMDNUM - 1);
 
 #ifdef XMT_VIA_SKB
@@ -1125,7 +1125,7 @@ static int ni65_send_packet(struct sk_buff *skb, struct net_device *dev)
 			cli();
 
 			tmdp = p->tmdhead + p->tmdnum;
-			tmdp->u.buffer = (u32) virt_to_bus(skb->data);
+			tmdp->u.buffer = (u32) isa_virt_to_bus(skb->data);
 			p->tmd_skb[p->tmdnum] = skb;
 		}
 #endif
diff --git a/drivers/net/rcpci45.c b/drivers/net/rcpci45.c
index 0b5bcdcc1..4063c0e2c 100644
--- a/drivers/net/rcpci45.c
+++ b/drivers/net/rcpci45.c
@@ -44,6 +44,8 @@
 **
 ***************************************************************************/
 
+#error I am non-portable, please convert me to Documentation/DMA-mapping.txt
+
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
diff --git a/drivers/net/rrunner.c b/drivers/net/rrunner.c
index f476a5d48..3d3a4ace1 100644
--- a/drivers/net/rrunner.c
+++ b/drivers/net/rrunner.c
@@ -21,6 +21,8 @@
  * ODS/Essential.
  */
 
+#error I am non-portable, please convert me to Documentation/DMA-mapping.txt
+
 #define DEBUG 1
 #define RX_DMA_SKBUFF 1
 #define PKT_COPY_THRESHOLD 512
diff --git a/drivers/net/sk_g16.c b/drivers/net/sk_g16.c
index 21ab6e3af..3a7cf6ac9 100644
--- a/drivers/net/sk_g16.c
+++ b/drivers/net/sk_g16.c
@@ -810,7 +810,7 @@ int __init SK_probe(struct net_device *dev, short ioaddr)
     SK_print_pos(dev, "POS registers after ROM, RAM config");
 #endif
 
-    board = (SK_RAM *) bus_to_virt(rom_addr);
+    board = (SK_RAM *) isa_bus_to_virt(rom_addr);
 
     /* Read in station address */
     for (i = 0, j = 0; i < ETH_ALEN; i++, j+=2)
diff --git a/drivers/net/tlan.c b/drivers/net/tlan.c
index b948c40b0..9ba4c8678 100644
--- a/drivers/net/tlan.c
+++ b/drivers/net/tlan.c
@@ -160,6 +160,7 @@
  *
  *******************************************************************************/
 
+#error I am non-portable, please convert me to Documentation/DMA-mapping.txt
                                                                                 
 #include <linux/module.h>
 
diff --git a/drivers/scsi/3w-xxxx.c b/drivers/scsi/3w-xxxx.c
index c8aa338eb..9c1a2c6c9 100644
--- a/drivers/scsi/3w-xxxx.c
+++ b/drivers/scsi/3w-xxxx.c
@@ -108,6 +108,8 @@
                  Fix get_param for specific units.
 */
 
+#error I am non-portable, please convert me to Documentation/DMA-mapping.txt
+
 #include <linux/module.h>
 
 MODULE_AUTHOR ("3ware Inc.");
diff --git a/drivers/scsi/53c7,8xx.c b/drivers/scsi/53c7,8xx.c
index 81217c47e..f4db58cf1 100644
--- a/drivers/scsi/53c7,8xx.c
+++ b/drivers/scsi/53c7,8xx.c
@@ -62,6 +62,8 @@
  *  the fourth byte from 50 to 25.
  */
 
+#error I am non-portable, please convert me to Documentation/DMA-mapping.txt
+
 #include <linux/config.h>
 
 #ifdef CONFIG_SCSI_NCR53C7xx_sync
diff --git a/drivers/scsi/AM53C974.c b/drivers/scsi/AM53C974.c
index 5696214c7..f5d3790f4 100644
--- a/drivers/scsi/AM53C974.c
+++ b/drivers/scsi/AM53C974.c
@@ -1,3 +1,5 @@
+#error I am non-portable, please convert me to Documentation/DMA-mapping.txt
+
 #include <linux/module.h>
 #include <linux/delay.h>
 #include <linux/signal.h>
diff --git a/drivers/scsi/BusLogic.c b/drivers/scsi/BusLogic.c
index 85d61ad12..6f5032c5f 100644
--- a/drivers/scsi/BusLogic.c
+++ b/drivers/scsi/BusLogic.c
@@ -29,6 +29,8 @@
 #define BusLogic_DriverVersion		"2.1.15"
 #define BusLogic_DriverDate		"17 August 1998"
 
+#error I am non-portable, please convert me to Documentation/DMA-mapping.txt
+
 
 #include <linux/version.h>
 #include <linux/module.h>
diff --git a/drivers/scsi/advansys.c b/drivers/scsi/advansys.c
index 080847a4e..12b800af7 100644
--- a/drivers/scsi/advansys.c
+++ b/drivers/scsi/advansys.c
@@ -749,6 +749,7 @@
 
 */
 
+#error I am non-portable, please convert me to Documentation/DMA-mapping.txt
 
 /*
  * --- Linux Version
diff --git a/drivers/scsi/aha1542.c b/drivers/scsi/aha1542.c
index 24f98cccd..154777d99 100644
--- a/drivers/scsi/aha1542.c
+++ b/drivers/scsi/aha1542.c
@@ -51,13 +51,14 @@
 
 #include "aha1542.h"
 
-#define SCSI_PA(address) virt_to_bus(address)
+#define SCSI_BUF_PA(address)	isa_virt_to_bus(address)
+#define SCSI_SG_PA(sgent)	(isa_page_to_bus((sgent)->page) + (sgent)->offset)
 
 static void BAD_DMA(void *address, unsigned int length)
 {
 	printk(KERN_CRIT "buf vaddress %p paddress 0x%lx length %d\n",
 	       address,
-	       SCSI_PA(address),
+	       SCSI_BUS_PA(address),
 	       length);
 	panic("Buffer at physical address > 16Mb used for aha1542");
 }
@@ -69,8 +70,8 @@ static void BAD_SG_DMA(Scsi_Cmnd * SCpnt,
 {
 	printk(KERN_CRIT "sgpnt[%d:%d] addr %p/0x%lx length %d\n",
 	       badseg, nseg,
-	       sgpnt[badseg].address,
-	       SCSI_PA(sgpnt[badseg].address),
+	       page_address(sgpnt[badseg].page) + sgpnt[badseg].offset,
+	       SCSI_SG_PA(&sgpnt[badseg]),
 	       sgpnt[badseg].length);
 
 	/*
@@ -511,7 +512,7 @@ static void aha1542_intr_handle(int irq, void *dev_id, struct pt_regs *regs)
 			return;
 		};
 
-		mbo = (scsi2int(mb[mbi].ccbptr) - (SCSI_PA(&ccb[0]))) / sizeof(struct ccb);
+		mbo = (scsi2int(mb[mbi].ccbptr) - (SCSI_BUF_PA(&ccb[0]))) / sizeof(struct ccb);
 		mbistatus = mb[mbi].status;
 		mb[mbi].status = 0;
 		HOSTDATA(shost)->aha1542_last_mbi_used = mbi;
@@ -681,7 +682,7 @@ static int aha1542_queuecommand(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
 	printk(KERN_DEBUG "Sending command (%d %x)...", mbo, done);
 #endif
 
-	any2scsi(mb[mbo].ccbptr, SCSI_PA(&ccb[mbo]));	/* This gets trashed for some reason */
+	any2scsi(mb[mbo].ccbptr, SCSI_BUF_PA(&ccb[mbo]));	/* This gets trashed for some reason */
 
 	memset(&ccb[mbo], 0, sizeof(struct ccb));
 
@@ -710,11 +711,13 @@ static int aha1542_queuecommand(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
 			panic("aha1542.c: unable to allocate DMA memory\n");
 		for (i = 0; i < SCpnt->use_sg; i++) {
 			if (sgpnt[i].length == 0 || SCpnt->use_sg > 16 ||
-			    (((int) sgpnt[i].address) & 1) || (sgpnt[i].length & 1)) {
+			    (((int) sgpnt[i].offset) & 1) || (sgpnt[i].length & 1)) {
 				unsigned char *ptr;
 				printk(KERN_CRIT "Bad segment list supplied to aha1542.c (%d, %d)\n", SCpnt->use_sg, i);
 				for (i = 0; i < SCpnt->use_sg; i++) {
-					printk(KERN_CRIT "%d: %p %d\n", i, sgpnt[i].address,
+					printk(KERN_CRIT "%d: %p %d\n", i,
+					       (page_address(sgpnt[i].page) +
+						sgpnt[i].offset),
 					       sgpnt[i].length);
 				};
 				printk(KERN_CRIT "cptr %x: ", (unsigned int) cptr);
@@ -723,13 +726,13 @@ static int aha1542_queuecommand(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
 					printk("%02x ", ptr[i]);
 				panic("Foooooooood fight!");
 			};
-			any2scsi(cptr[i].dataptr, SCSI_PA(sgpnt[i].address));
-			if (SCSI_PA(sgpnt[i].address + sgpnt[i].length - 1) > ISA_DMA_THRESHOLD)
+			any2scsi(cptr[i].dataptr, SCSI_SG_PA(&sgpnt[i]));
+			if (SCSI_SG_PA(&sgpnt[i].page) + sgpnt[i].length - 1 > ISA_DMA_THRESHOLD)
 				BAD_SG_DMA(SCpnt, sgpnt, SCpnt->use_sg, i);
 			any2scsi(cptr[i].datalen, sgpnt[i].length);
 		};
 		any2scsi(ccb[mbo].datalen, SCpnt->use_sg * sizeof(struct chain));
-		any2scsi(ccb[mbo].dataptr, SCSI_PA(cptr));
+		any2scsi(ccb[mbo].dataptr, SCSI_BUF_PA(cptr));
 #ifdef DEBUG
 		printk("cptr %x: ", cptr);
 		ptr = (unsigned char *) cptr;
@@ -740,9 +743,9 @@ static int aha1542_queuecommand(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
 		ccb[mbo].op = 0;	/* SCSI Initiator Command */
 		SCpnt->host_scribble = NULL;
 		any2scsi(ccb[mbo].datalen, bufflen);
-		if (buff && SCSI_PA(buff + bufflen - 1) > ISA_DMA_THRESHOLD)
+		if (buff && SCSI_BUF_PA(buff + bufflen - 1) > ISA_DMA_THRESHOLD)
 			BAD_DMA(buff, bufflen);
-		any2scsi(ccb[mbo].dataptr, SCSI_PA(buff));
+		any2scsi(ccb[mbo].dataptr, SCSI_BUF_PA(buff));
 	};
 	ccb[mbo].idlun = (target & 7) << 5 | direction | (lun & 7);	/*SCSI Target Id */
 	ccb[mbo].rsalen = 16;
@@ -802,10 +805,10 @@ static void setup_mailboxes(int bse, struct Scsi_Host *shpnt)
 
 	for (i = 0; i < AHA1542_MAILBOXES; i++) {
 		mb[i].status = mb[AHA1542_MAILBOXES + i].status = 0;
-		any2scsi(mb[i].ccbptr, SCSI_PA(&ccb[i]));
+		any2scsi(mb[i].ccbptr, SCSI_BUF_PA(&ccb[i]));
 	};
 	aha1542_intr_reset(bse);	/* reset interrupts, so they don't block */
-	any2scsi((cmd + 2), SCSI_PA(mb));
+	any2scsi((cmd + 2), SCSI_BUF_PA(mb));
 	aha1542_out(bse, cmd, 5);
 	WAIT(INTRFLAGS(bse), INTRMASK, HACC, 0);
 	while (0) {
@@ -1185,7 +1188,7 @@ static int __init aha1542_detect(Scsi_Host_Template * tpnt)
 				continue;
 			/* For now we do this - until kmalloc is more intelligent
 			   we are resigned to stupid hacks like this */
-			if (SCSI_PA(shpnt) >= ISA_DMA_THRESHOLD) {
+			if (SCSI_BUF_PA(shpnt) >= ISA_DMA_THRESHOLD) {
 				printk(KERN_ERR "Invalid address for shpnt with 1542.\n");
 				goto unregister;
 			}
@@ -1398,7 +1401,7 @@ static int aha1542_dev_reset(Scsi_Cmnd * SCpnt)
 	HOSTDATA(SCpnt->host)->aha1542_last_mbo_used = mbo;
 	restore_flags(flags);
 
-	any2scsi(mb[mbo].ccbptr, SCSI_PA(&ccb[mbo]));	/* This gets trashed for some reason */
+	any2scsi(mb[mbo].ccbptr, SCSI_BUF_PA(&ccb[mbo]));	/* This gets trashed for some reason */
 
 	memset(&ccb[mbo], 0, sizeof(struct ccb));
 
diff --git a/drivers/scsi/aha1740.c b/drivers/scsi/aha1740.c
index 8e2609ab3..5258b8d77 100644
--- a/drivers/scsi/aha1740.c
+++ b/drivers/scsi/aha1740.c
@@ -232,7 +232,7 @@ void aha1740_intr_handle(int irq, void *dev_id, struct pt_regs * regs)
     {
 	DEB(printk("aha1740_intr top of loop.\n"));
 	adapstat = inb(G2INTST(base));
-	ecbptr = (struct ecb *) bus_to_virt(inl(MBOXIN0(base)));
+	ecbptr = (struct ecb *) isa_bus_to_virt(inl(MBOXIN0(base)));
 	outb(G2CNTRL_IRST,G2CNTRL(base)); /* interrupt reset */
       
 	switch ( adapstat & G2INTST_MASK )
@@ -397,10 +397,10 @@ int aha1740_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
 	for(i=0; i<SCpnt->use_sg; i++)
 	{
 	    cptr[i].datalen = sgpnt[i].length;
-	    cptr[i].dataptr = virt_to_bus(sgpnt[i].address);
+	    cptr[i].dataptr = isa_virt_to_bus(sgpnt[i].address);
 	}
 	host->ecb[ecbno].datalen = SCpnt->use_sg * sizeof(struct aha1740_chain);
-	host->ecb[ecbno].dataptr = virt_to_bus(cptr);
+	host->ecb[ecbno].dataptr = isa_virt_to_bus(cptr);
 #ifdef DEBUG
 	printk("cptr %x: ",cptr);
 	ptr = (unsigned char *) cptr;
@@ -411,15 +411,15 @@ int aha1740_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
     {
 	SCpnt->host_scribble = NULL;
 	host->ecb[ecbno].datalen = bufflen;
-	host->ecb[ecbno].dataptr = virt_to_bus(buff);
+	host->ecb[ecbno].dataptr = isa_virt_to_bus(buff);
     }
     host->ecb[ecbno].lun = SCpnt->lun;
     host->ecb[ecbno].ses = 1;	/* Suppress underrun errors */
     host->ecb[ecbno].dir = direction;
     host->ecb[ecbno].ars = 1;  /* Yes, get the sense on an error */
     host->ecb[ecbno].senselen = 12;
-    host->ecb[ecbno].senseptr = virt_to_bus(host->ecb[ecbno].sense);
-    host->ecb[ecbno].statusptr = virt_to_bus(host->ecb[ecbno].status);
+    host->ecb[ecbno].senseptr = isa_virt_to_bus(host->ecb[ecbno].sense);
+    host->ecb[ecbno].statusptr = isa_virt_to_bus(host->ecb[ecbno].status);
     host->ecb[ecbno].done = done;
     host->ecb[ecbno].SCpnt = SCpnt;
 #ifdef DEBUG
@@ -459,7 +459,7 @@ int aha1740_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
 	    if (loopcnt == LOOPCNT_MAX)
 		panic("aha1740.c: mbxout busy!\n");
 	}
-	outl(virt_to_bus(host->ecb + ecbno), MBOXOUT0(base));
+	outl(isa_virt_to_bus(host->ecb + ecbno), MBOXOUT0(base));
 	for (loopcnt = 0; ; loopcnt++) {
 	    if (! (inb(G2STAT(base)) & G2STAT_BUSY)) break;
 	    if (loopcnt == LOOPCNT_WARN) {
diff --git a/drivers/scsi/aic7xxx/aic7xxx_linux.c b/drivers/scsi/aic7xxx/aic7xxx_linux.c
index 2f5a22e3e..0fa747f22 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_linux.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_linux.c
@@ -1699,6 +1699,7 @@ ahc_linux_run_device_queue(struct ahc_softc *ahc, struct ahc_linux_device *dev)
 			       cmd->request_buffer,
 			       cmd->request_bufflen,
 			       scsi_to_pci_dma_dir(cmd->sc_data_direction));
+			scb->sg_count = 0;
 			scb->sg_count = ahc_linux_map_seg(ahc, scb,
 							  sg, addr,
 							  cmd->request_bufflen);
diff --git a/drivers/scsi/aic7xxx_old.c b/drivers/scsi/aic7xxx_old.c
index 9177efb73..013cefb85 100644
--- a/drivers/scsi/aic7xxx_old.c
+++ b/drivers/scsi/aic7xxx_old.c
@@ -254,12 +254,6 @@
 
 #include <linux/config.h>        /* for CONFIG_PCI */
 
-/*
- * To generate the correct addresses for the controller to issue
- * on the bus.  Originally added for DEC Alpha support.
- */
-#define VIRT_TO_BUS(a) (unsigned int)virt_to_bus((void *)(a))
-
 #define AIC7XXX_C_VERSION  "5.2.4"
 
 #define NUMBER(arr)     (sizeof(arr) / sizeof(arr[0]))
@@ -2845,7 +2839,10 @@ aic7xxx_done(struct aic7xxx_host *p, struct aic7xxx_scb *scb)
           struct scatterlist *sg;
 
           sg = (struct scatterlist *)cmd->request_buffer;
-          buffer = (char *)sg[0].address;
+
+          /* XXX Assumes not highmem page. XXX */
+          buffer = (char *) (page_address(sg[0].page) +
+                             sg[0].offset);
         }
         else
         {
diff --git a/drivers/scsi/atp870u.c b/drivers/scsi/atp870u.c
index aec2ad4c1..6e576336f 100644
--- a/drivers/scsi/atp870u.c
+++ b/drivers/scsi/atp870u.c
@@ -14,6 +14,8 @@
  *		   support atp880 chip lvd u160 2001/05/15 (7.1)
  */
 
+#error I am non-portable, please convert me to Documentation/DMA-mapping.txt
+
 #include <linux/module.h>
 
 #include <linux/kernel.h>
diff --git a/drivers/scsi/dpt_i2o.c b/drivers/scsi/dpt_i2o.c
index db4e6c8a1..4eeb7505c 100644
--- a/drivers/scsi/dpt_i2o.c
+++ b/drivers/scsi/dpt_i2o.c
@@ -28,6 +28,8 @@
 
 #define ADDR32 (0)
 
+#error I am non-portable, please convert me to Documentation/DMA-mapping.txt
+
 #include <linux/version.h>
 #include <linux/module.h>
 
diff --git a/drivers/scsi/eata.c b/drivers/scsi/eata.c
index fa97dfb7b..58fe35ab2 100644
--- a/drivers/scsi/eata.c
+++ b/drivers/scsi/eata.c
@@ -394,6 +394,8 @@
  *  the driver sets host->wish_block = TRUE for all ISA boards.
  */
 
+#error I am non-portable, please convert me to Documentation/DMA-mapping.txt
+
 #include <linux/version.h>
 
 #ifndef LinuxVersionCode
diff --git a/drivers/scsi/eata_dma.c b/drivers/scsi/eata_dma.c
index 6133d6301..df40d32ad 100644
--- a/drivers/scsi/eata_dma.c
+++ b/drivers/scsi/eata_dma.c
@@ -63,6 +63,8 @@
 
 /* Look in eata_dma.h for configuration and revision information */
 
+#error I am non-portable, please convert me to Documentation/DMA-mapping.txt
+
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
diff --git a/drivers/scsi/gdth.c b/drivers/scsi/gdth.c
index 8040de54c..5639aa4c4 100644
--- a/drivers/scsi/gdth.c
+++ b/drivers/scsi/gdth.c
@@ -295,6 +295,8 @@
  * phase:                       Service/parameter/return code special command
  */
 
+#error I am non-portable, please convert me to Documentation/DMA-mapping.txt
+
 #include <linux/module.h>
 
 #include <linux/version.h>
diff --git a/drivers/scsi/ibmmca.c b/drivers/scsi/ibmmca.c
index 43127b530..026669d82 100644
--- a/drivers/scsi/ibmmca.c
+++ b/drivers/scsi/ibmmca.c
@@ -766,12 +766,12 @@ static int device_inquiry(int host_index, int ldn)
       scb->enable = IM_REPORT_TSB_ONLY_ON_ERROR | IM_READ_CONTROL | IM_SUPRESS_EXCEPTION_SHORT | IM_RETRY_ENABLE | IM_BYPASS_BUFFER;
       last_scsi_command(host_index)[ldn] = IM_DEVICE_INQUIRY_CMD;
       last_scsi_type(host_index)[ldn] = IM_SCB;
-      scb->sys_buf_adr = virt_to_bus(buf);
+      scb->sys_buf_adr = isa_virt_to_bus(buf);
       scb->sys_buf_length = 255; /* maximum bufferlength gives max info */
-      scb->tsb_adr = virt_to_bus(tsb);
+      scb->tsb_adr = isa_virt_to_bus(tsb);
       /* issue scb to passed ldn, and busy wait for interrupt */
       got_interrupt(host_index) = 0;
-      issue_cmd (host_index, virt_to_bus(scb), IM_SCB | ldn);
+      issue_cmd (host_index, isa_virt_to_bus(scb), IM_SCB | ldn);
       while (!got_interrupt(host_index))
 	barrier ();
 
@@ -804,12 +804,12 @@ static int read_capacity(int host_index, int ldn)
       scb->enable = IM_REPORT_TSB_ONLY_ON_ERROR | IM_READ_CONTROL | IM_RETRY_ENABLE | IM_BYPASS_BUFFER;
       last_scsi_command(host_index)[ldn] = IM_READ_CAPACITY_CMD;
       last_scsi_type(host_index)[ldn] = IM_SCB;
-      scb->sys_buf_adr = virt_to_bus(buf);
+      scb->sys_buf_adr = isa_virt_to_bus(buf);
       scb->sys_buf_length = 8;
-      scb->tsb_adr = virt_to_bus(tsb);
+      scb->tsb_adr = isa_virt_to_bus(tsb);
       /*issue scb to passed ldn, and busy wait for interrupt */
       got_interrupt(host_index) = 0;
-      issue_cmd (host_index, virt_to_bus(scb), IM_SCB | ldn);
+      issue_cmd (host_index, isa_virt_to_bus(scb), IM_SCB | ldn);
       while (!got_interrupt(host_index))
 	barrier ();
 
@@ -842,15 +842,15 @@ static int get_pos_info(int host_index)
       scb->enable = IM_READ_CONTROL | IM_REPORT_TSB_ONLY_ON_ERROR | IM_RETRY_ENABLE | IM_BYPASS_BUFFER;
       last_scsi_command(host_index)[MAX_LOG_DEV] = IM_GET_POS_INFO_CMD;
       last_scsi_type(host_index)[MAX_LOG_DEV] = IM_SCB;
-      scb->sys_buf_adr = virt_to_bus(buf);
+      scb->sys_buf_adr = isa_virt_to_bus(buf);
       if (special(host_index)==IBM_SCSI2_FW)
 	scb->sys_buf_length = 256; /* get all info from F/W adapter */
       else
 	scb->sys_buf_length = 18; /* get exactly 18 bytes for other SCSI */
-      scb->tsb_adr = virt_to_bus(tsb);
+      scb->tsb_adr = isa_virt_to_bus(tsb);
       /*issue scb to ldn=15, and busy wait for interrupt */
       got_interrupt(host_index) = 0;
-      issue_cmd (host_index, virt_to_bus(scb), IM_SCB | MAX_LOG_DEV);
+      issue_cmd (host_index, isa_virt_to_bus(scb), IM_SCB | MAX_LOG_DEV);
       while (!got_interrupt(host_index))
 	barrier ();
 
@@ -1992,7 +1992,7 @@ int ibmmca_queuecommand (Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
    scb = &(ld(host_index)[ldn].scb);
    ld(host_index)[ldn].tsb.dev_status = 0;
    scb->enable = IM_REPORT_TSB_ONLY_ON_ERROR | IM_RETRY_ENABLE;
-   scb->tsb_adr = virt_to_bus(&(ld(host_index)[ldn].tsb));
+   scb->tsb_adr = isa_virt_to_bus(&(ld(host_index)[ldn].tsb));
    scsi_cmd = cmd->cmnd[0];
 
    if (cmd->use_sg) {
@@ -2001,14 +2001,14 @@ int ibmmca_queuecommand (Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
       if (i > 16)
 	panic ("IBM MCA SCSI: scatter-gather list too long.\n");
       while (--i >= 0) {
-	 ld(host_index)[ldn].sge[i].address = (void *)(virt_to_bus(sl[i].address));
+	 ld(host_index)[ldn].sge[i].address = (void *)(isa_page_to_bus(sl[i].page) + sl[i].offset);
 	 ld(host_index)[ldn].sge[i].byte_length = sl[i].length;
       }
       scb->enable |= IM_POINTER_TO_LIST;
-      scb->sys_buf_adr = virt_to_bus(&(ld(host_index)[ldn].sge[0]));
+      scb->sys_buf_adr = isa_virt_to_bus(&(ld(host_index)[ldn].sge[0]));
       scb->sys_buf_length = cmd->use_sg * sizeof (struct im_sge);
    } else {
-      scb->sys_buf_adr = virt_to_bus(cmd->request_buffer);
+      scb->sys_buf_adr = isa_virt_to_bus(cmd->request_buffer);
       /* recent Linux midlevel SCSI places 1024 byte for inquiry
        * command. Far too much for old PS/2 hardware. */
       switch (scsi_cmd) {
@@ -2165,10 +2165,10 @@ int ibmmca_queuecommand (Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
      PS2_DISK_LED_ON (shpnt->host_no, target);
 
    if (last_scsi_type(host_index)[ldn] == IM_LONG_SCB) {
-      issue_cmd (host_index, virt_to_bus(scb), IM_LONG_SCB | ldn);
+      issue_cmd (host_index, isa_virt_to_bus(scb), IM_LONG_SCB | ldn);
       IBM_DS(host_index).long_scbs++;
    } else {
-      issue_cmd (host_index, virt_to_bus(scb), IM_SCB | ldn);
+      issue_cmd (host_index, isa_virt_to_bus(scb), IM_SCB | ldn);
       IBM_DS(host_index).scbs++;
    }
    return 0;
diff --git a/drivers/scsi/ini9100u.c b/drivers/scsi/ini9100u.c
index 17ac962a8..6ceb7fa51 100644
--- a/drivers/scsi/ini9100u.c
+++ b/drivers/scsi/ini9100u.c
@@ -108,6 +108,8 @@
 
 #define CVT_LINUX_VERSION(V,P,S)        (V * 65536 + P * 256 + S)
 
+#error I am non-portable, please convert me to Documentation/DMA-mapping.txt
+
 #ifndef LINUX_VERSION_CODE
 #include <linux/version.h>
 #endif
diff --git a/drivers/scsi/inia100.c b/drivers/scsi/inia100.c
index 47cf2b4df..ceb86b89b 100644
--- a/drivers/scsi/inia100.c
+++ b/drivers/scsi/inia100.c
@@ -67,6 +67,8 @@
 #include <linux/version.h>
 #endif
 
+#error I am non-portable, please convert me to Documentation/DMA-mapping.txt
+
 #include <linux/module.h>
 
 #include <stdarg.h>
diff --git a/drivers/scsi/ips.c b/drivers/scsi/ips.c
index 04ffa14e6..429beabcb 100644
--- a/drivers/scsi/ips.c
+++ b/drivers/scsi/ips.c
@@ -140,6 +140,8 @@
  * ioctlsize            - Initial size of the IOCTL buffer
  */
  
+#error I am non-portable, please convert me to Documentation/DMA-mapping.txt
+
 #include <asm/io.h>
 #include <asm/byteorder.h>
 #include <asm/page.h>
diff --git a/drivers/scsi/mca_53c9x.c b/drivers/scsi/mca_53c9x.c
index 1ceb651fc..55ccc2d56 100644
--- a/drivers/scsi/mca_53c9x.c
+++ b/drivers/scsi/mca_53c9x.c
@@ -227,7 +227,7 @@ int mca_esp_detect(Scsi_Host_Template *tpnt)
 
 			esp->esp_command = (volatile unsigned char*)
 			  cmd_buffer;
-	 		esp->esp_command_dvma = virt_to_bus(cmd_buffer);
+	 		esp->esp_command_dvma = isa_virt_to_bus(cmd_buffer);
 
 			/* SCSI chip speed */
 
diff --git a/drivers/scsi/osst.c b/drivers/scsi/osst.c
index e959c2fda..289096b16 100644
--- a/drivers/scsi/osst.c
+++ b/drivers/scsi/osst.c
@@ -477,7 +477,8 @@ static int osst_verify_frame(OS_Scsi_Tape * STp, int frame_seq_number, int quiet
 	if (STp->raw) {
 		if (STp->buffer->syscall_result) {
 			for (i=0; i < STp->buffer->sg_segs; i++)
-				memset(STp->buffer->sg[i].address, 0, STp->buffer->sg[i].length);
+				memset(page_address(STp->buffer->sg[i].page),
+				       0, STp->buffer->sg[i].length);
 			strcpy(STp->buffer->b_data, "READ ERROR ON FRAME");
                 } else
 			STp->buffer->buffer_bytes = OS_FRAME_SIZE;
@@ -4448,12 +4449,12 @@ static int os_scsi_tape_open(struct inode * inode, struct file * filp)
 		for (i = 0, b_size = 0; 
 		     i < STp->buffer->sg_segs && (b_size + STp->buffer->sg[i].length) <= OS_DATA_SIZE; 
 		     b_size += STp->buffer->sg[i++].length);
-		STp->buffer->aux = (os_aux_t *) (STp->buffer->sg[i].address + OS_DATA_SIZE - b_size);
+		STp->buffer->aux = (os_aux_t *) (page_address(STp->buffer->sg[i].page) + OS_DATA_SIZE - b_size);
 #if DEBUG
 		printk(OSST_DEB_MSG "osst%d:D: b_data points to %p in segment 0 at %p\n", dev,
-			STp->buffer->b_data, STp->buffer->sg[0].address);
+			STp->buffer->b_data, page_address(STp->buffer->sg[0].page));
 		printk(OSST_DEB_MSG "osst%d:D: AUX points to %p in segment %d at %p\n", dev,
-			 STp->buffer->aux, i, STp->buffer->sg[i].address);
+			 STp->buffer->aux, i, page_address(STp->buffer->sg[i].page));
 #endif
 	} else
 		STp->buffer->aux = NULL; /* this had better never happen! */
@@ -5021,15 +5022,14 @@ static OSST_buffer * new_tape_buffer( int from_initialization, int need_dma )
 		     b_size *= 2,                 order++ );
 
 		for ( ; b_size >= PAGE_SIZE; order--, b_size /= 2) {
-			tb->sg[0].address =
-			    (unsigned char *)__get_free_pages(priority, order);
-			if (tb->sg[0].address != NULL) {
-			    tb->sg[0].page = NULL;
+			tb->sg[0].page = alloc_pages(priority, order);
+			tb->sg[0].offset = 0;
+			if (tb->sg[0].page != NULL) {
 			    tb->sg[0].length = b_size;
 			    break;
 			}
 		}
-		if (tb->sg[segs].address == NULL) {
+		if (tb->sg[segs].page == NULL) {
 			kfree(tb);
 			tb = NULL;
 		}
@@ -5041,9 +5041,9 @@ static OSST_buffer * new_tape_buffer( int from_initialization, int need_dma )
 
 			for (segs=1, got=tb->sg[0].length;
 			     got < osst_buffer_size && segs < OSST_FIRST_SG; ) {
-			    tb->sg[segs].address =
-				(unsigned char *)__get_free_pages(priority, order);
-			    if (tb->sg[segs].address == NULL) {
+			    tb->sg[segs].page = alloc_pages(priority, order);
+			    tb->sg[segs].offset = 0;
+			    if (tb->sg[segs].page == NULL) {
 				if (osst_buffer_size - got <=
 				    (OSST_FIRST_SG - segs) * b_size / 2) {
 				    b_size /= 2; /* Large enough for the rest of the buffers */
@@ -5073,7 +5073,7 @@ static OSST_buffer * new_tape_buffer( int from_initialization, int need_dma )
 		return NULL;
 	}
 	tb->sg_segs = tb->orig_sg_segs = segs;
-	tb->b_data = tb->sg[0].address;
+	tb->b_data = page_address(tb->sg[0].page);
 
 #if DEBUG
 	if (debugging) {
@@ -5118,9 +5118,9 @@ static int enlarge_buffer(OSST_buffer *STbuffer, int new_size, int need_dma)
 
 	for (segs=STbuffer->sg_segs, got=STbuffer->buffer_size;
 	     segs < max_segs && got < new_size; ) {
-		STbuffer->sg[segs].address =
-			  (unsigned char *)__get_free_pages(priority, order);
-		if (STbuffer->sg[segs].address == NULL) {
+		STbuffer->sg[segs].page = alloc_pages(priority, order);
+		STbuffer->sg[segs].offset = 0;
+		if (STbuffer->sg[segs].page == NULL) {
 			if (new_size - got <= (max_segs - segs) * b_size / 2) {
 				b_size /= 2;  /* Large enough for the rest of the buffers */
 				order--;
@@ -5168,7 +5168,7 @@ static void normalize_buffer(OSST_buffer *STbuffer)
 		     b_size < STbuffer->sg[i].length;
 		     b_size *= 2, order++);
 
-		free_pages((unsigned long)STbuffer->sg[i].address, order);
+		__free_pages(STbuffer->sg[i].page, order);
 		STbuffer->buffer_size -= STbuffer->sg[i].length;
 	}
 #if DEBUG
@@ -5196,7 +5196,7 @@ static int append_to_buffer(const char *ubp, OSST_buffer *st_bp, int do_count)
 	for ( ; i < st_bp->sg_segs && do_count > 0; i++) {
 		cnt = st_bp->sg[i].length - offset < do_count ?
 		      st_bp->sg[i].length - offset : do_count;
-		res = copy_from_user(st_bp->sg[i].address + offset, ubp, cnt);
+		res = copy_from_user(page_address(st_bp->sg[i].page) + offset, ubp, cnt);
 		if (res)
 			return (-EFAULT);
 		do_count -= cnt;
@@ -5229,7 +5229,7 @@ static int from_buffer(OSST_buffer *st_bp, char *ubp, int do_count)
 	for ( ; i < st_bp->sg_segs && do_count > 0; i++) {
 		cnt = st_bp->sg[i].length - offset < do_count ?
 		      st_bp->sg[i].length - offset : do_count;
-		res = copy_to_user(ubp, st_bp->sg[i].address + offset, cnt);
+		res = copy_to_user(ubp, page_address(st_bp->sg[i].page) + offset, cnt);
 		if (res)
 			return (-EFAULT);
 		do_count -= cnt;
@@ -5262,7 +5262,7 @@ static int osst_zero_buffer_tail(OSST_buffer *st_bp)
 	     i < st_bp->sg_segs && do_count > 0; i++) {
 		cnt = st_bp->sg[i].length - offset < do_count ?
 		      st_bp->sg[i].length - offset : do_count ;
-		memset(st_bp->sg[i].address + offset, 0, cnt);
+		memset(page_address(st_bp->sg[i].page) + offset, 0, cnt);
 		do_count -= cnt;
 		offset = 0;
 	}
@@ -5282,7 +5282,7 @@ static int osst_copy_to_buffer(OSST_buffer *st_bp, unsigned char *ptr)
 	for (i = 0; i < st_bp->sg_segs && do_count > 0; i++) {
 		cnt = st_bp->sg[i].length < do_count ?
 		      st_bp->sg[i].length : do_count ;
-		memcpy(st_bp->sg[i].address, ptr, cnt);
+		memcpy(page_address(st_bp->sg[i].page), ptr, cnt);
 		do_count -= cnt;
 		ptr      += cnt;
 	}
@@ -5303,7 +5303,7 @@ static int osst_copy_from_buffer(OSST_buffer *st_bp, unsigned char *ptr)
 	for (i = 0; i < st_bp->sg_segs && do_count > 0; i++) {
 		cnt = st_bp->sg[i].length < do_count ?
 		      st_bp->sg[i].length : do_count ;
-		memcpy(ptr, st_bp->sg[i].address, cnt);
+		memcpy(ptr, page_address(st_bp->sg[i].page), cnt);
 		do_count -= cnt;
 		ptr      += cnt;
 	}
diff --git a/drivers/scsi/pci2220i.c b/drivers/scsi/pci2220i.c
index 1dddd5004..8f5a892c6 100644
--- a/drivers/scsi/pci2220i.c
+++ b/drivers/scsi/pci2220i.c
@@ -34,6 +34,8 @@
  *
  ****************************************************************************/
 
+#error Convert me to understand page+offset based scatterlists
+
 //#define DEBUG 1
 
 #include <linux/module.h>
diff --git a/drivers/scsi/qla1280.c b/drivers/scsi/qla1280.c
index deec41610..9a04761cb 100644
--- a/drivers/scsi/qla1280.c
+++ b/drivers/scsi/qla1280.c
@@ -182,6 +182,7 @@ END OF TERMS AND CONDITIONS
     -   Initial Beta Release.  
 *****************************************************************************/
 
+#error I am non-portable, please convert me to Documentation/DMA-mapping.txt
 
 #ifdef MODULE
 #include <linux/module.h>
diff --git a/drivers/scsi/scsi.h b/drivers/scsi/scsi.h
index b8ad3f4aa..85b975119 100644
--- a/drivers/scsi/scsi.h
+++ b/drivers/scsi/scsi.h
@@ -743,7 +743,6 @@ struct scsi_cmnd {
 
 	struct timer_list eh_timeout;	/* Used to time out the command. */
 	void *request_buffer;		/* Actual requested buffer */
-        void **bounce_buffers;		/* Array of bounce buffers when using scatter-gather */
 
 	/* These elements define the operation we ultimately want to perform */
 	unsigned char data_cmnd[MAX_COMMAND_SIZE];
diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index fda3c6528..fd7222fbd 100644
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
@@ -145,16 +145,15 @@ static char sense_buffer[128] =
 static void scsi_dump(Scsi_Cmnd * SCpnt, int flag)
 {
 	int i;
-#if 0
-	unsigned char *pnt;
-#endif
 	unsigned int *lpnt;
 	struct scatterlist *sgpnt = NULL;
 	printk("use_sg: %d", SCpnt->use_sg);
 	if (SCpnt->use_sg) {
 		sgpnt = (struct scatterlist *) SCpnt->buffer;
 		for (i = 0; i < SCpnt->use_sg; i++) {
-			printk(":%p %d\n", sgpnt[i].address, sgpnt[i].length);
+			printk(":%p %d\n",
+			       (page_address(sgpnt[i].page) + sgpnt[i].offset),
+			       sgpnt[i].length);
 		};
 	} else {
 		printk("nosg: %p %p %d\n", SCpnt->request.buffer, SCpnt->buffer,
@@ -172,16 +171,6 @@ static void scsi_dump(Scsi_Cmnd * SCpnt, int flag)
 	printk("\n");
 	if (flag == 0)
 		return;
-#if 0
-	printk("\n");
-	lpnt = (unsigned int *) sgpnt[0].address;
-	for (i = 0; i < sizeof(Scsi_Cmnd) / 4 + 1; i++) {
-		if ((i & 7) == 0)
-			printk("\n");
-		printk("%x ", *lpnt++);
-	};
-	printk("\n");
-#endif
 }
 
 int scsi_debug_queuecommand(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
@@ -341,7 +330,8 @@ int scsi_debug_queuecommand(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
 		if (SCpnt->use_sg) {
 			sgcount = 0;
 			sgpnt = (struct scatterlist *) buff;
-			buff = sgpnt[sgcount].address;
+			buff = (page_address(sgpnt[sgcount].page) +
+                                sgpnt[sgcount].offset);
 			bufflen = sgpnt[sgcount].length;
 			bh = SCpnt->request.bh;
 		};
@@ -432,7 +422,8 @@ int scsi_debug_queuecommand(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
 				if (nbytes) {
 					if (!bh)
 						panic("Too few blocks for linked request.");
-					buff = sgpnt[sgcount].address;
+					buff = (page_address(sgpnt[sgcount].page) +
+                                                sgpnt[sgcount].offset);
 					bufflen = sgpnt[sgcount].length;
 				};
 			}
@@ -461,7 +452,8 @@ int scsi_debug_queuecommand(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
 			if ((bufflen >> 9) != SCpnt->request.nr_sectors)
 				panic("Trying to write wrong number of blocks\n");
 			sgpnt = (struct scatterlist *) buff;
-			buff = sgpnt[sgcount].address;
+			buff = (page_address(sgpnt[sgcount].page) +
+                                sgpnt[sgcount].offset);
 		};
 #if 0
 		if (block != *((unsigned long *) (buff + 60))) {
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 317f21858..4d4a6abc4 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -452,18 +452,8 @@ static void scsi_release_buffers(Scsi_Cmnd * SCpnt)
 	 */
 	if (SCpnt->use_sg) {
 		struct scatterlist *sgpnt;
-		void **bbpnt;
-		int i;
 
 		sgpnt = (struct scatterlist *) SCpnt->request_buffer;
-		bbpnt = SCpnt->bounce_buffers;
-
-		if (bbpnt) {
-			for (i = 0; i < SCpnt->use_sg; i++) {
-				if (bbpnt[i])
-					kfree(sgpnt[i].address);
-			}
-		}
 		scsi_free_sgtable(SCpnt->request_buffer, SCpnt->sglist_len);
 	} else {
 		if (SCpnt->request_buffer != req->buffer)
@@ -527,24 +517,8 @@ void scsi_io_completion(Scsi_Cmnd * SCpnt, int good_sectors,
 	 */
 	if (SCpnt->use_sg) {
 		struct scatterlist *sgpnt;
-		void **bbpnt;
-		int i;
 
 		sgpnt = (struct scatterlist *) SCpnt->buffer;
-		bbpnt = SCpnt->bounce_buffers;
-
-		if (bbpnt) {
-			for (i = 0; i < SCpnt->use_sg; i++) {
-				if (bbpnt[i]) {
-					if (rq_data_dir(req) == READ) {
-						memcpy(bbpnt[i],
-						       sgpnt[i].address,
-						       sgpnt[i].length);
-					}
-					kfree(sgpnt[i].address);
-				}
-			}
-		}
 		scsi_free_sgtable(SCpnt->buffer, SCpnt->sglist_len);
 	} else {
 		if (SCpnt->buffer != req->buffer) {
diff --git a/drivers/scsi/scsiiom.c b/drivers/scsi/scsiiom.c
index 5d0520234..886aa6e5c 100644
--- a/drivers/scsi/scsiiom.c
+++ b/drivers/scsi/scsiiom.c
@@ -6,6 +6,8 @@
  ***********************************************************************/
 /* $Id: scsiiom.c,v 2.55.2.17 2000/12/20 00:39:37 garloff Exp $ */
 
+#error I am non-portable, please convert me to Documentation/DMA-mapping.txt
+
 static void __inline__
 dc390_freetag (PDCB pDCB, PSRB pSRB)
 {
diff --git a/drivers/scsi/seagate.c b/drivers/scsi/seagate.c
index 2cf059b14..055d51c9a 100644
--- a/drivers/scsi/seagate.c
+++ b/drivers/scsi/seagate.c
@@ -1060,8 +1060,9 @@ static int internal_command (unsigned char target, unsigned char lun,
 				     hostno, nobuffs);
 				for (i = 0; i < nobuffs; ++i)
 					printk
-					    ("scsi%d : buffer %d address = %08x length = %d\n",
-					     hostno, i, buffer[i].address,
+					    ("scsi%d : buffer %d address = %p length = %d\n",
+					     hostno, i,
+					     page_address(buffer[i].page) + buffer[i].offset,
 					     buffer[i].length);
 			}
 #endif
diff --git a/drivers/scsi/sgiwd93.c b/drivers/scsi/sgiwd93.c
index a7b441d38..1ac2fcf1f 100644
--- a/drivers/scsi/sgiwd93.c
+++ b/drivers/scsi/sgiwd93.c
@@ -119,9 +119,13 @@ static int dma_setup(Scsi_Cmnd *cmd, int datainp)
 #endif
 		for(i = 0; i <= cmd->SCp.buffers_residual; i++) {
 #ifdef DEBUG_DMA
-			printk("[%p,%d]", slp[i].address, slp[i].length);
+			printk("[%p,%d]",
+			       page_address(slp[i].page) + slp[i].offset,
+			       slp[i].length);
 #endif
-			fill_hpc_entries (&hcp, slp[i].address, slp[i].length);
+			fill_hpc_entries (&hcp,
+					  page_address(slp[i].page) + slp[i].offset,
+					  slp[i].length);
 			totlen += slp[i].length;
 		}
 #ifdef DEBUG_DMA
@@ -226,7 +230,7 @@ static void dma_stop(struct Scsi_Host *instance, Scsi_Cmnd *SCpnt,
 		}
 		SCpnt->SCp.buffer = &slp[i];
 		SCpnt->SCp.buffers_residual = SCpnt->SCp.buffers_residual - i;
-		SCpnt->SCp.ptr = (char *) slp[i].address;
+		SCpnt->SCp.ptr = (char *) page_address(slp[i].page) + slp[i].offset;
 		SCpnt->SCp.this_residual = slp[i].length;
 	}
 #ifdef DEBUG_DMA
diff --git a/drivers/scsi/sim710.c b/drivers/scsi/sim710.c
index 085e97d6c..142b03a84 100644
--- a/drivers/scsi/sim710.c
+++ b/drivers/scsi/sim710.c
@@ -572,11 +572,11 @@ sim710_driver_init (struct Scsi_Host *host)
     hostdata->running = NULL;
     memcpy (hostdata->script, SCRIPT, sizeof(SCRIPT));
     for (i = 0; i < PATCHES; i++)
-	hostdata->script[LABELPATCHES[i]] += virt_to_bus(hostdata->script);
+	hostdata->script[LABELPATCHES[i]] += isa_virt_to_bus(hostdata->script);
     patch_abs_32 (hostdata->script, 0, reselected_identify, 
-    	virt_to_bus((void *)&(hostdata->reselected_identify)));
+    	isa_virt_to_bus((void *)&(hostdata->reselected_identify)));
     patch_abs_32 (hostdata->script, 0, msgin_buf, 
-    	virt_to_bus((void *)&(hostdata->msgin_buf[0])));
+    	isa_virt_to_bus((void *)&(hostdata->msgin_buf[0])));
     hostdata->state = STATE_INITIALISED;
     hostdata->negotiate = 0xff;
 }
@@ -670,7 +670,7 @@ handle_idd (struct Scsi_Host * host, Scsi_Cmnd * cmd)
     struct sim710_target *targdata = hostdata->target + cmd->target;
     u32 resume_offset = 0, index;
 
-    index = (u32)((u32 *)(bus_to_virt(NCR_read32(DSP_REG))) - hostdata->script);
+    index = (u32)((u32 *)(isa_bus_to_virt(NCR_read32(DSP_REG))) - hostdata->script);
 
     switch (index) {
     case Ent_wait_disc_complete/4 + 2:
@@ -717,7 +717,7 @@ handle_phase_mismatch (struct Scsi_Host * host, Scsi_Cmnd * cmd)
     unsigned char sbcl;
 
     sbcl = NCR_read8(SBCL_REG) & SBCL_PHASE_MASK;
-    index = (u32)((u32 *)(bus_to_virt(NCR_read32(DSP_REG))) - hostdata->script);
+    index = (u32)((u32 *)(isa_bus_to_virt(NCR_read32(DSP_REG))) - hostdata->script);
 
     DEB(DEB_PMM, printk("scsi%d: Phase mismatch, phase %s (%x) at script[0x%x]\n",
 	host->host_no, sbcl_to_phase(sbcl), sbcl, index));
@@ -754,7 +754,7 @@ handle_phase_mismatch (struct Scsi_Host * host, Scsi_Cmnd * cmd)
 
 	sg_id = (index - Ent_patch_input_data/4 - 4) / 2;
 	targdata->data_in_jump = hostdata->script[Ent_patch_input_data/4+1] =
-		virt_to_bus(hostdata->script + Ent_patch_input_data/4 + sg_id * 2 + 2);
+		isa_virt_to_bus(hostdata->script + Ent_patch_input_data/4 + sg_id * 2 + 2);
 	olen  = targdata->dsa[DSA_DATAIN + sg_id * 2];
 	oaddr = targdata->dsa[DSA_DATAIN + sg_id * 2 + 1];
 	residual = datapath_residual (host);
@@ -783,7 +783,7 @@ handle_phase_mismatch (struct Scsi_Host * host, Scsi_Cmnd * cmd)
 
 	sg_id = (index - Ent_patch_output_data/4 - 4) / 2;
 	targdata->data_out_jump = hostdata->script[Ent_patch_output_data/4+1] =
-		virt_to_bus(hostdata->script + Ent_patch_output_data/4 + sg_id * 2 + 2);
+		isa_virt_to_bus(hostdata->script + Ent_patch_output_data/4 + sg_id * 2 + 2);
 	olen  = targdata->dsa[DSA_DATAOUT + sg_id * 2];
 	oaddr = targdata->dsa[DSA_DATAOUT + sg_id * 2 + 1];
 	residual = datapath_residual (host);
@@ -860,7 +860,7 @@ handle_script_int(struct Scsi_Host * host, Scsi_Cmnd * cmd)
     case A_int_reselected:
 	hostdata->script[Ent_patch_output_data/4+1] = targdata->data_out_jump;
 	hostdata->script[Ent_patch_input_data/4+1] = targdata->data_in_jump;
-	NCR_write32(DSA_REG, virt_to_bus(targdata->dsa));
+	NCR_write32(DSA_REG, isa_virt_to_bus(targdata->dsa));
 	resume_offset = targdata->resume_offset;
 	break;
     case A_int_data_bad_phase:
@@ -943,7 +943,7 @@ sim710_intr_handle(int irq, void *dev_id, struct pt_regs *regs)
 	DEB(DEB_INTS, printk("scsi%d: Int %d, istat %02x, sstat0 %02x "
 		"dstat %02x, dsp [%04x], scratch %02x\n",
 	    host->host_no, sim710_intrs, istat, sstat0, dstat,
-	    (u32 *)(bus_to_virt(NCR_read32(DSP_REG))) - hostdata->script,
+	    (u32 *)(isa_bus_to_virt(NCR_read32(DSP_REG))) - hostdata->script,
 	    NCR_read32(SCRATCH_REG)));
 	if ((dstat & DSTAT_SIR) && dsps == A_int_reselected) {
 	    /* Reselected.  Identify the target from LCRC_REG, and
@@ -990,7 +990,7 @@ sim710_intr_handle(int irq, void *dev_id, struct pt_regs *regs)
 	    printk("scsi%d: Int %d, istat %02x, sstat0 %02x "
 		"dstat %02x, dsp [%04x], scratch %02x, dsps %08x\n",
 		host->host_no, sim710_intrs, istat, sstat0, dstat,
-		(u32 *)(bus_to_virt(NCR_read32(DSP_REG))) - hostdata->script,
+		(u32 *)(isa_bus_to_virt(NCR_read32(DSP_REG))) - hostdata->script,
 		NCR_read32(SCRATCH_REG), dsps);
 	    /* resume_offset is zero, which will cause a host reset */
 	}
@@ -1043,7 +1043,7 @@ sim710_intr_handle(int irq, void *dev_id, struct pt_regs *regs)
 #ifdef DEBUG_LIMIT_INTS
 	if (sim710_intrs < DEBUG_LIMIT_INTS)
 #endif
-	NCR_write32(DSP_REG, virt_to_bus(hostdata->script+resume_offset/4));
+	NCR_write32(DSP_REG, isa_virt_to_bus(hostdata->script+resume_offset/4));
 	if (resume_offset == Ent_reselect)
 	    run_process_issue_queue(hostdata);
     }
@@ -1121,48 +1121,47 @@ run_command (struct sim710_hostdata *hostdata, Scsi_Cmnd *cmd)
     targdata->dsa_status[0] = 0xff;
 
     targdata->dsa[DSA_SELECT]		= (1 << cmd->target) << 16;
-    targdata->dsa[DSA_MSGOUT+1]		= virt_to_bus(targdata->dsa_msgout);
+    targdata->dsa[DSA_MSGOUT+1]		= isa_virt_to_bus(targdata->dsa_msgout);
     targdata->dsa[DSA_CMND]		= cmd->cmd_len;
-    targdata->dsa[DSA_CMND+1]		= virt_to_bus(targdata->dsa_cdb);
+    targdata->dsa[DSA_CMND+1]		= isa_virt_to_bus(targdata->dsa_cdb);
     targdata->dsa[DSA_STATUS]		= 1;
-    targdata->dsa[DSA_STATUS+1]		= virt_to_bus(targdata->dsa_status);
+    targdata->dsa[DSA_STATUS+1]		= isa_virt_to_bus(targdata->dsa_status);
     targdata->dsa[DSA_MSGIN]		= 1;
-    targdata->dsa[DSA_MSGIN+1]		= virt_to_bus(targdata->dsa_msgin);
+    targdata->dsa[DSA_MSGIN+1]		= isa_virt_to_bus(targdata->dsa_msgin);
 
     sg_start = (MAX_SG - (cmd->use_sg ? cmd->use_sg : 1)) * 2;
     dip = targdata->dsa + DSA_DATAIN + sg_start;
     dop = targdata->dsa + DSA_DATAOUT + sg_start;
 
     for (i = 0; cmd->use_sg ? (i < cmd->use_sg) : !i; i++) {
-	u32 vbuf = cmd->use_sg ?
-		(u32)(((struct scatterlist *)cmd->buffer)[i].address) :
-		(u32)(cmd->request_buffer);
-	u32 bbuf = virt_to_bus((void *)vbuf);
-	u32 cnt = cmd->use_sg ?
-		((struct scatterlist *)cmd->buffer)[i].length :
-		cmd->request_bufflen;
+	struct scatterlist *sgl = &((struct scatterlist *)cmd->buffer)[i];
+	void *vbuf = cmd->use_sg ?
+		(page_address(sgl->page) + sgl->offset) :
+		(cmd->request_buffer);
+	u32 bbuf = isa_virt_to_bus(vbuf);
+	u32 cnt = cmd->use_sg ? sgl->length : cmd->request_bufflen;
 
 	if (datain) {
 #ifdef CONFIG_TP34V_SCSI
-	    cache_clear(virt_to_phys((void *)vbuf), cnt);
+	    cache_clear(virt_to_phys(vbuf, cnt);
 #endif
 	    *dip++	= cnt;
 	    *dip++	= bbuf;
 	}
 	if (dataout) {
 #ifdef CONFIG_TP34V_SCSI
-	    cache_push(virt_to_phys((void *)vbuf), cnt);
+	    cache_push(virt_to_phys(vbuf, cnt);
 #endif
 	    *dop++	= cnt;
 	    *dop++	= bbuf;
 	}
     }
     targdata->data_out_jump = hostdata->script[Ent_patch_output_data/4+1] =
-	virt_to_bus(hostdata->script + Ent_patch_output_data/4 + sg_start + 2);
+	isa_virt_to_bus(hostdata->script + Ent_patch_output_data/4 + sg_start + 2);
     targdata->data_in_jump = hostdata->script[Ent_patch_input_data/4+1] =
-	virt_to_bus(hostdata->script + Ent_patch_input_data/4 + sg_start + 2);
+	isa_virt_to_bus(hostdata->script + Ent_patch_input_data/4 + sg_start + 2);
 
-    for (i = 0, dsa = virt_to_bus(targdata->dsa); i < 4; i++) {
+    for (i = 0, dsa = isa_virt_to_bus(targdata->dsa); i < 4; i++) {
 	u32 v = hostdata->script[Ent_patch_new_dsa/4 + i * 2];
 
 	v &= ~0x0000ff00;
@@ -1507,7 +1506,7 @@ sim710_detect(Scsi_Host_Template * tpnt)
 #endif
 	    chips++;
 	}
-	NCR_write32(DSP_REG, virt_to_bus(hostdata->script+Ent_reselect/4));
+	NCR_write32(DSP_REG, isa_virt_to_bus(hostdata->script+Ent_reselect/4));
 	hostdata->state = STATE_IDLE;
     }
     return chips;
@@ -1561,7 +1560,7 @@ full_reset(struct Scsi_Host * host)
     ncr_halt(host);
     printk("scsi%d: dsp = %08x (script[0x%04x]), scratch = %08x\n",
 	host->host_no, NCR_read32(DSP_REG),
-	((u32)bus_to_virt(NCR_read32(DSP_REG)) - (u32)hostdata->script)/4,
+	((u32)isa_bus_to_virt(NCR_read32(DSP_REG)) - (u32)hostdata->script)/4,
 	NCR_read32(SCRATCH_REG));
 
     for (target = 0; target < 7; target++) {
@@ -1577,7 +1576,7 @@ full_reset(struct Scsi_Host * host)
     sim710_soft_reset(host);
     sim710_driver_init(host);
 
-    NCR_write32(DSP_REG, virt_to_bus(hostdata->script+Ent_reselect/4));
+    NCR_write32(DSP_REG, isa_virt_to_bus(hostdata->script+Ent_reselect/4));
     hostdata->state = STATE_IDLE;
 
     run_process_issue_queue(hostdata);
diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index 51eed48a4..ce4330c8e 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -3314,15 +3314,14 @@ static ST_buffer *
 		     order++, b_size *= 2)
 			;
 		for ( ; b_size >= PAGE_SIZE; order--, b_size /= 2) {
-			tb->sg[0].address =
-			    (unsigned char *) __get_free_pages(priority, order);
-			if (tb->sg[0].address != NULL) {
+			tb->sg[0].page = alloc_pages(priority, order);
+			tb->sg[0].offset = 0;
+			if (tb->sg[0].page != NULL) {
 				tb->sg[0].length = b_size;
 				break;
 			}
 		}
-		tb->sg[0].page = NULL;
-		if (tb->sg[segs].address == NULL) {
+		if (tb->sg[segs].page == NULL) {
 			kfree(tb);
 			tb = NULL;
 		} else {	/* Got something, continue */
@@ -3334,10 +3333,9 @@ static ST_buffer *
 				;
 			for (segs = 1, got = tb->sg[0].length;
 			     got < st_buffer_size && segs < ST_FIRST_SG;) {
-				tb->sg[segs].address =
-					(unsigned char *) __get_free_pages(priority,
-									   order);
-				if (tb->sg[segs].address == NULL) {
+				tb->sg[segs].page = alloc_pages(priority, order);
+				tb->sg[segs].offset = 0;
+				if (tb->sg[segs].page == NULL) {
 					if (st_buffer_size - got <=
 					    (ST_FIRST_SG - segs) * b_size / 2) {
 						b_size /= 2; /* Large enough for the
@@ -3353,7 +3351,6 @@ static ST_buffer *
 					tb = NULL;
 					break;
 				}
-				tb->sg[segs].page = NULL;
 				tb->sg[segs].length = b_size;
 				got += b_size;
 				segs++;
@@ -3367,7 +3364,7 @@ static ST_buffer *
 		return NULL;
 	}
 	tb->sg_segs = tb->orig_sg_segs = segs;
-	tb->b_data = tb->sg[0].address;
+	tb->b_data = page_address(tb->sg[0].page);
 
         DEBC(printk(ST_DEB_MSG
                     "st: Allocated tape buffer %d (%d bytes, %d segments, dma: %d, a: %p).\n",
@@ -3413,9 +3410,9 @@ static int enlarge_buffer(ST_buffer * STbuffer, int new_size, int need_dma)
 
 	for (segs = STbuffer->sg_segs, got = STbuffer->buffer_size;
 	     segs < max_segs && got < new_size;) {
-		STbuffer->sg[segs].address =
-			(unsigned char *) __get_free_pages(priority, order);
-		if (STbuffer->sg[segs].address == NULL) {
+		STbuffer->sg[segs].page = alloc_pages(priority, order);
+		STbuffer->sg[segs].offset = 0;
+		if (STbuffer->sg[segs].page == NULL) {
 			if (new_size - got <= (max_segs - segs) * b_size / 2) {
 				b_size /= 2; /* Large enough for the rest of the buffers */
 				order--;
@@ -3427,7 +3424,6 @@ static int enlarge_buffer(ST_buffer * STbuffer, int new_size, int need_dma)
 			normalize_buffer(STbuffer);
 			return FALSE;
 		}
-		STbuffer->sg[segs].page = NULL;
 		STbuffer->sg[segs].length = b_size;
 		STbuffer->sg_segs += 1;
 		got += b_size;
@@ -3451,13 +3447,13 @@ static void normalize_buffer(ST_buffer * STbuffer)
 		for (b_size=PAGE_SIZE, order=0; b_size < STbuffer->sg[i].length;
 		     order++, b_size *= 2)
 			; /* empty */
-		free_pages((unsigned long)(STbuffer->sg[i].address), order);
+		__free_pages(STbuffer->sg[i].page, order);
 		STbuffer->buffer_size -= STbuffer->sg[i].length;
 	}
         DEB(
 	if (debugging && STbuffer->orig_sg_segs < STbuffer->sg_segs)
 		printk(ST_DEB_MSG "st: Buffer at %p normalized to %d bytes (segs %d).\n",
-		       STbuffer->sg[0].address, STbuffer->buffer_size,
+		       page_address(STbuffer->sg[0].page), STbuffer->buffer_size,
 		       STbuffer->sg_segs);
         ) /* end DEB */
 	STbuffer->sg_segs = STbuffer->orig_sg_segs;
@@ -3480,7 +3476,7 @@ static int append_to_buffer(const char *ubp, ST_buffer * st_bp, int do_count)
 	for (; i < st_bp->sg_segs && do_count > 0; i++) {
 		cnt = st_bp->sg[i].length - offset < do_count ?
 		    st_bp->sg[i].length - offset : do_count;
-		res = copy_from_user(st_bp->sg[i].address + offset, ubp, cnt);
+		res = copy_from_user(page_address(st_bp->sg[i].page) + offset, ubp, cnt);
 		if (res)
 			return (-EFAULT);
 		do_count -= cnt;
@@ -3513,7 +3509,7 @@ static int from_buffer(ST_buffer * st_bp, char *ubp, int do_count)
 	for (; i < st_bp->sg_segs && do_count > 0; i++) {
 		cnt = st_bp->sg[i].length - offset < do_count ?
 		    st_bp->sg[i].length - offset : do_count;
-		res = copy_to_user(ubp, st_bp->sg[i].address + offset, cnt);
+		res = copy_to_user(ubp, page_address(st_bp->sg[i].page) + offset, cnt);
 		if (res)
 			return (-EFAULT);
 		do_count -= cnt;
diff --git a/drivers/scsi/u14-34f.c b/drivers/scsi/u14-34f.c
index adacf2fd4..bc30c95b5 100644
--- a/drivers/scsi/u14-34f.c
+++ b/drivers/scsi/u14-34f.c
@@ -550,8 +550,8 @@ static unsigned long io_port[] = {
 #endif
 
 #define DEV2H(x) H2DEV(x)
-#define V2DEV(addr) ((addr) ? H2DEV(virt_to_bus((void *)addr)) : 0)
-#define DEV2V(addr) ((addr) ? DEV2H(bus_to_virt((unsigned long)addr)) : 0)
+#define V2DEV(addr) ((addr) ? H2DEV(isa_virt_to_bus((void *)addr)) : 0)
+#define DEV2V(addr) ((addr) ? DEV2H(isa_bus_to_virt((unsigned long)addr)) : 0)
 
 static void do_interrupt_handler(int, void *, struct pt_regs *);
 static void flush_dev(Scsi_Device *, unsigned long, unsigned int, unsigned int);
@@ -985,7 +985,7 @@ static inline void build_sg_list(struct mscp *cpp, Scsi_Cmnd *SCpnt) {
    sgpnt = (struct scatterlist *) SCpnt->request_buffer;
 
    for (k = 0; k < SCpnt->use_sg; k++) {
-      cpp->sglist[k].address = V2DEV(sgpnt[k].address);
+      cpp->sglist[k].address = V2DEV(page_address(sgpnt[k].page)) + sgpnt[k].offset;
       cpp->sglist[k].num_bytes = H2DEV(sgpnt[k].length);
       data_len += sgpnt[k].length;
       }
diff --git a/drivers/scsi/ultrastor.c b/drivers/scsi/ultrastor.c
index a0104d6fe..b2ba4776e 100644
--- a/drivers/scsi/ultrastor.c
+++ b/drivers/scsi/ultrastor.c
@@ -661,12 +661,12 @@ static inline void build_sg_list(register struct mscp *mscp, Scsi_Cmnd *SCpnt)
 	sl = (struct scatterlist *) SCpnt->request_buffer;
 	max = SCpnt->use_sg;
 	for (i = 0; i < max; i++) {
-		mscp->sglist[i].address = virt_to_bus(sl[i].address);
+		mscp->sglist[i].address = isa_page_to_bus(sl[i].page) + sl[i].offset;
 		mscp->sglist[i].num_bytes = sl[i].length;
 		transfer_length += sl[i].length;
 	}
 	mscp->number_of_sg_list = max;
-	mscp->transfer_data = virt_to_bus(mscp->sglist);
+	mscp->transfer_data = isa_virt_to_bus(mscp->sglist);
 	/* ??? May not be necessary.  Docs are unclear as to whether transfer
 	   length field is ignored or whether it should be set to the total
 	   number of bytes of the transfer.  */
@@ -722,7 +722,7 @@ int ultrastor_queuecommand(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
     } else {
 	/* Unset scatter/gather flag in SCSI command packet */
 	my_mscp->sg = FALSE;
-	my_mscp->transfer_data = virt_to_bus(SCpnt->request_buffer);
+	my_mscp->transfer_data = isa_virt_to_bus(SCpnt->request_buffer);
 	my_mscp->transfer_data_length = SCpnt->request_bufflen;
     }
     my_mscp->command_link = 0;		/*???*/
@@ -732,7 +732,7 @@ int ultrastor_queuecommand(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
     memcpy(my_mscp->scsi_cdbs, SCpnt->cmnd, my_mscp->length_of_scsi_cdbs);
     my_mscp->adapter_status = 0;
     my_mscp->target_status = 0;
-    my_mscp->sense_data = virt_to_bus(&SCpnt->sense_buffer);
+    my_mscp->sense_data = isa_virt_to_bus(&SCpnt->sense_buffer);
     my_mscp->done = done;
     my_mscp->SCint = SCpnt;
     SCpnt->host_scribble = (unsigned char *)my_mscp;
@@ -790,7 +790,7 @@ int ultrastor_queuecommand(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
     }
 
     /* Store pointer in OGM address bytes */
-    outl(virt_to_bus(my_mscp), config.ogm_address);
+    outl(isa_virt_to_bus(my_mscp), config.ogm_address);
 
     /* Issue OGM interrupt */
     if (config.slot) {
@@ -866,9 +866,9 @@ int ultrastor_abort(Scsi_Cmnd *SCpnt)
 	out[28 + i * 3] = '\n';
 	out[29 + i * 3] = 0;
 	ogm_status = inb(port0 + 22);
-	ogm_addr = (unsigned int)bus_to_virt(inl(port0 + 23));
+	ogm_addr = (unsigned int)isa_bus_to_virt(inl(port0 + 23));
 	icm_status = inb(port0 + 27);
-	icm_addr = (unsigned int)bus_to_virt(inl(port0 + 28));
+	icm_addr = (unsigned int)isa_bus_to_virt(inl(port0 + 28));
 	restore_flags(flags);
       }
 
@@ -904,7 +904,7 @@ int ultrastor_abort(Scsi_Cmnd *SCpnt)
 
 	save_flags(flags);
 	cli();
-	outl(virt_to_bus(&config.mscp[mscp_index]), config.ogm_address);
+	outl(isa_virt_to_bus(&config.mscp[mscp_index]), config.ogm_address);
 	inb(0xc80);	/* delay */
 	outb(0x80, config.ogm_address - 1);
 	outb(0x2, LCL_DOORBELL_INTR(config.doorbell_address));
@@ -1037,7 +1037,7 @@ static void ultrastor_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 #if ULTRASTOR_MAX_CMDS == 1
     mscp = &config.mscp[0];
 #else
-    mscp = (struct mscp *)bus_to_virt(inl(config.icm_address));
+    mscp = (struct mscp *)isa_bus_to_virt(inl(config.icm_address));
     mscp_index = mscp - config.mscp;
     if (mscp_index >= ULTRASTOR_MAX_CMDS) {
 	printk("Ux4F interrupt: bad MSCP address %x\n", (unsigned int) mscp);
diff --git a/drivers/scsi/wd7000.c b/drivers/scsi/wd7000.c
index e8c91abe0..7ecb62ce1 100644
--- a/drivers/scsi/wd7000.c
+++ b/drivers/scsi/wd7000.c
@@ -1110,7 +1110,7 @@ void wd7000_intr_handle (int irq, void *dev_id, struct pt_regs *regs)
 		return;
 	    }
 	    /* Aaaargh! (Zaga) */
-	    scb = bus_to_virt(scsi2int ((unchar *) icmbs[icmb].scbptr));
+	    scb = isa_bus_to_virt(scsi2int ((unchar *) icmbs[icmb].scbptr));
 	    icmbs[icmb].status = 0;
 	    if (!(scb->op & ICB_OP_MASK)) {	/* an SCB is done */
 		SCpnt = scb->SCpnt;
@@ -1189,13 +1189,14 @@ int wd7000_queuecommand (Scsi_Cmnd *SCpnt, void (*done) (Scsi_Cmnd *))
 	any2scsi (scb->maxlen, SCpnt->use_sg * sizeof (Sgb));
 
 	for (i = 0; i < SCpnt->use_sg; i++) {
-	    any2scsi (sgb[i].ptr, (int) sg[i].address);
+	    any2scsi (sgb[i].ptr,
+		      isa_page_to_bus(sg[i].page) + sg[i].offset);
 	    any2scsi (sgb[i].len, sg[i].length);
 	}
     }
     else {
 	scb->op = 0;
-	any2scsi (scb->dataptr, (int) SCpnt->request_buffer);
+	any2scsi (scb->dataptr, isa_virt_to_bus(SCpnt->request_buffer));
 	any2scsi (scb->maxlen, SCpnt->request_bufflen);
     }
 
diff --git a/drivers/usb/usb-uhci-debug.h b/drivers/usb/usb-uhci-debug.h
index c10ac3146..0fa124d8b 100644
--- a/drivers/usb/usb-uhci-debug.h
+++ b/drivers/usb/usb-uhci-debug.h
@@ -78,60 +78,6 @@ static void uhci_show_td (puhci_desc_t td)
 #endif
 
 #ifdef DEBUG
-static void __attribute__((__unused__)) uhci_show_td_queue (puhci_desc_t td)
-{
-	//dbg("uhci_show_td_queue %p (%08lX):", td, td->dma_addr);
-#if 1
-	return;
-#else
-	while (1) {
-		uhci_show_td (td);
-		if (td->hw.td.link & UHCI_PTR_TERM)
-			break;
-		if (td != bus_to_virt (td->hw.td.link & ~UHCI_PTR_BITS))
-			td = bus_to_virt (td->hw.td.link & ~UHCI_PTR_BITS);
-		else {
-			dbg("td points to itself!");
-			break;
-		}
-	}
-#endif
-}
-
-static void __attribute__((__unused__)) uhci_show_queue (puhci_desc_t qh)
-{
-#if 0
-	uhci_desc_t *start_qh=qh;
-#endif
-
-	dbg("uhci_show_queue %p:", qh);
-#if 1
-	return;
-#else
-	while (1) {
-		uhci_show_qh (qh);
-
-		if (!(qh->hw.qh.element & UHCI_PTR_TERM))
-			uhci_show_td_queue (bus_to_virt (qh->hw.qh.element & ~UHCI_PTR_BITS));
-
-		if (qh->hw.qh.head & UHCI_PTR_TERM)
-			break;
-
-		if (qh != bus_to_virt (qh->hw.qh.head & ~UHCI_PTR_BITS))
-			qh = bus_to_virt (qh->hw.qh.head & ~UHCI_PTR_BITS);
-		else {
-			dbg("qh points to itself!");
-			break;
-		}
-		
-		if (qh==start_qh) { // avoid loop
-			dbg("Loop detect");
-			break;
-		}
-	}		
-#endif
-}
-
 static void __attribute__((__unused__)) uhci_show_sc (int port, unsigned short status)
 {
 	dbg("  stat%d     =     %04x   %s%s%s%s%s%s%s%s",
diff --git a/drivers/usb/usb-uhci.c b/drivers/usb/usb-uhci.c
index d753af20f..0dc842716 100644
--- a/drivers/usb/usb-uhci.c
+++ b/drivers/usb/usb-uhci.c
@@ -681,7 +681,6 @@ _static int init_skel (uhci_t *s)
 	insert_td_horizontal (s, s->int_chain[5], td);
 
 	mb();
-	//uhci_show_queue(s->control_chain);   
 	dbg("init_skel exit");
 	return 0;
 
@@ -793,7 +792,6 @@ _static int uhci_submit_control_urb (urb_t *urb)
 
 	qh->hw.qh.element &= cpu_to_le32(~UHCI_PTR_TERM);
 
-	//uhci_show_queue(qh);
 	/* Start it up... put low speed first */
 	if (urb->pipe & TD_CTRL_LS)
 		insert_qh (s, s->control_chain, qh, 0);
@@ -939,7 +937,6 @@ _static int uhci_submit_bulk_urb (urb_t *urb, urb_t *bulk_urb)
 			insert_qh (s, s->chain_end, qh, 0);
 	}
 	
-	//uhci_show_queue(s->bulk_chain);
 	//dbg("uhci_submit_bulk_urb: exit\n");
 	return 0;
 }
diff --git a/drivers/usb/usb-uhci.h b/drivers/usb/usb-uhci.h
index 5850f7f28..54499ec6a 100644
--- a/drivers/usb/usb-uhci.h
+++ b/drivers/usb/usb-uhci.h
@@ -100,7 +100,6 @@ static __inline__ void uhci_wait_ms(unsigned int ms)
 
 #define uhci_status_bits(ctrl_sts)	(ctrl_sts & 0xFE0000)
 #define uhci_actual_length(ctrl_sts)	((ctrl_sts + 1) & TD_CTRL_ACTLEN_MASK)	/* 1-based */
-#define uhci_ptr_to_virt(x)	bus_to_virt(x & ~UHCI_PTR_BITS)
 
 /*
  * for TD <flags>:
diff --git a/drivers/video/matrox/matroxfb_base.h b/drivers/video/matrox/matroxfb_base.h
index 75323dcab..d4d2df71f 100644
--- a/drivers/video/matrox/matroxfb_base.h
+++ b/drivers/video/matrox/matroxfb_base.h
@@ -124,10 +124,6 @@
 #endif
 #endif
 
-#ifdef __sparc__
-#error "Sorry, I have no idea how to do this on sparc... There is mapioaddr... With bus_type parameter..."
-#endif
-
 #if defined(__m68k__)
 #define MAP_BUSTOVIRT
 #else
diff --git a/drivers/video/vesafb.c b/drivers/video/vesafb.c
index 62897efab..81ad28b98 100644
--- a/drivers/video/vesafb.c
+++ b/drivers/video/vesafb.c
@@ -550,7 +550,7 @@ int __init vesafb_init(void)
 		ypan = pmi_setpal = 0; /* not available or some DOS TSR ... */
 
 	if (ypan || pmi_setpal) {
-		pmi_base  = (unsigned short*)bus_to_virt(((unsigned long)screen_info.vesapm_seg << 4) + screen_info.vesapm_off);
+		pmi_base  = (unsigned short*)isa_bus_to_virt(((unsigned long)screen_info.vesapm_seg << 4) + screen_info.vesapm_off);
 		pmi_start = (void*)((char*)pmi_base + pmi_base[1]);
 		pmi_pal   = (void*)((char*)pmi_base + pmi_base[2]);
 		printk(KERN_INFO "vesafb: pmi: set display start = %p, set palette = %p\n",pmi_start,pmi_pal);
diff --git a/include/asm-alpha/scatterlist.h b/include/asm-alpha/scatterlist.h
index 9745d69ba..6afb8bd3a 100644
--- a/include/asm-alpha/scatterlist.h
+++ b/include/asm-alpha/scatterlist.h
@@ -4,11 +4,6 @@
 #include <asm/page.h>
   
 struct scatterlist {
-	/* This will disappear in 2.5.x */
-	char *address;
-
-	/* These two are only valid if ADDRESS member of this
-	   struct is NULL.  */
 	struct page *page;
 	unsigned int offset;
 
diff --git a/include/asm-arm/scatterlist.h b/include/asm-arm/scatterlist.h
index ea8d1ab4d..8b3b67099 100644
--- a/include/asm-arm/scatterlist.h
+++ b/include/asm-arm/scatterlist.h
@@ -4,7 +4,8 @@
 #include <asm/types.h>
 
 struct scatterlist {
-	char		*address;	/* virtual address		 */
+	struct page	*page;
+	unsigned int	offset;
 	dma_addr_t	dma_address;	/* dma address			 */
 	unsigned int	length;		/* length			 */
 };
diff --git a/include/asm-i386/floppy.h b/include/asm-i386/floppy.h
index 0317b2f88..72f791154 100644
--- a/include/asm-i386/floppy.h
+++ b/include/asm-i386/floppy.h
@@ -216,7 +216,7 @@ static void _fd_chose_dma_mode(char *addr, unsigned long size)
 {
 	if(can_use_virtual_dma == 2) {
 		if((unsigned int) addr >= (unsigned int) high_memory ||
-		   virt_to_bus(addr) >= 0x1000000 ||
+		   isa_virt_to_bus(addr) >= 0x1000000 ||
 		   _CROSS_64KB(addr, size, 0))
 			use_virtual_dma = 1;
 		else
@@ -252,7 +252,7 @@ static int hard_dma_setup(char *addr, unsigned long size, int mode, int io)
 	doing_pdma = 0;
 	clear_dma_ff(FLOPPY_DMA);
 	set_dma_mode(FLOPPY_DMA,mode);
-	set_dma_addr(FLOPPY_DMA,virt_to_bus(addr));
+	set_dma_addr(FLOPPY_DMA,isa_virt_to_bus(addr));
 	set_dma_count(FLOPPY_DMA,size);
 	enable_dma(FLOPPY_DMA);
 	return 0;
diff --git a/include/asm-i386/io.h b/include/asm-i386/io.h
index a140326a5..d443efbd9 100644
--- a/include/asm-i386/io.h
+++ b/include/asm-i386/io.h
@@ -95,11 +95,20 @@ static inline void * ioremap_nocache (unsigned long offset, unsigned long size)
 extern void iounmap(void *addr);
 
 /*
- * IO bus memory addresses are also 1:1 with the physical address
+ * ISA I/O bus memory addresses are 1:1 with the physical address.
  */
-#define virt_to_bus virt_to_phys
-#define bus_to_virt phys_to_virt
-#define page_to_bus page_to_phys
+#define isa_virt_to_bus virt_to_phys
+#define isa_page_to_bus page_to_phys
+#define isa_bus_to_virt phys_to_virt
+
+/*
+ * However PCI ones are not necessarily 1:1 and therefore these interfaces
+ * are forbidden in portable PCI drivers.
+ */
+extern unsigned long virt_to_bus_not_defined_use_pci_map(volatile void *addr);
+#define virt_to_bus virt_to_bus_not_defined_use_pci_map
+extern unsigned long bus_to_virt_not_defined_use_pci_map(volatile void *addr);
+#define bus_to_virt bus_to_virt_not_defined_use_pci_map
 
 /*
  * readX/writeX() are used to access memory mapped devices. On some
diff --git a/include/asm-i386/pci.h b/include/asm-i386/pci.h
index 5a294a75d..5d69c0a4c 100644
--- a/include/asm-i386/pci.h
+++ b/include/asm-i386/pci.h
@@ -75,7 +75,7 @@ static inline dma_addr_t pci_map_single(struct pci_dev *hwdev, void *ptr,
 	if (direction == PCI_DMA_NONE)
 		BUG();
 	flush_write_buffers();
-	return virt_to_bus(ptr);
+	return virt_to_phys(ptr);
 }
 
 /* Unmap a single streaming mode DMA translation.  The dma_addr and size
@@ -144,22 +144,14 @@ static inline int pci_map_sg(struct pci_dev *hwdev, struct scatterlist *sg,
 
 	if (direction == PCI_DMA_NONE)
 		BUG();
- 
- 	/*
- 	 * temporary 2.4 hack
- 	 */
- 	for (i = 0; i < nents; i++ ) {
- 		if (sg[i].address && sg[i].page)
- 			BUG();
- 		else if (!sg[i].address && !sg[i].page)
- 			BUG();
- 
- 		if (sg[i].address)
- 			sg[i].dma_address = virt_to_bus(sg[i].address);
- 		else
- 			sg[i].dma_address = page_to_bus(sg[i].page) + sg[i].offset;
- 	}
- 
+
+	for (i = 0; i < nents; i++ ) {
+		if (!sg[i].page)
+			BUG();
+
+		sg[i].dma_address = page_to_phys(sg[i].page) + sg[i].offset;
+	}
+
 	flush_write_buffers();
 	return nents;
 }
@@ -233,7 +225,7 @@ static inline int pci_dma_supported(struct pci_dev *hwdev, u64 mask)
 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) +
+	return ((dma64_addr_t) page_to_phys(page) +
 		(dma64_addr_t) offset);
 }
 
diff --git a/include/asm-i386/scatterlist.h b/include/asm-i386/scatterlist.h
index 9e2614f23..b238c8d0b 100644
--- a/include/asm-i386/scatterlist.h
+++ b/include/asm-i386/scatterlist.h
@@ -2,13 +2,10 @@
 #define _I386_SCATTERLIST_H
 
 struct scatterlist {
-    char *  address;    /* Location data is to be transferred to, NULL for
-			 * highmem page */
-    struct page * page; /* Location for highmem page, if any */
-    unsigned int offset;/* for highmem, page offset */
-
-    dma_addr_t dma_address;
-    unsigned int length;
+    struct page		*page;
+    unsigned int	offset;
+    dma_addr_t		dma_address;
+    unsigned int	length;
 };
 
 #define ISA_DMA_THRESHOLD (0x00ffffff)
diff --git a/include/asm-ia64/scatterlist.h b/include/asm-ia64/scatterlist.h
index 8ab328670..76e9c5ec8 100644
--- a/include/asm-ia64/scatterlist.h
+++ b/include/asm-ia64/scatterlist.h
@@ -7,8 +7,6 @@
  */
 
 struct scatterlist {
-	/* This will disappear in 2.5.x: */
-	char *address;		/* location data is to be transferred to, NULL for highmem page */
 	char *orig_address;	/* for use by swiotlb */
 
 	/* These two are only valid if ADDRESS member of this struct is NULL.  */
diff --git a/include/asm-m68k/scatterlist.h b/include/asm-m68k/scatterlist.h
index f7eeb77f1..2a7bfa448 100644
--- a/include/asm-m68k/scatterlist.h
+++ b/include/asm-m68k/scatterlist.h
@@ -2,7 +2,8 @@
 #define _M68K_SCATTERLIST_H
 
 struct scatterlist {
-    char *  address;    /* Location data is to be transferred to */
+    struct page *page;
+    unsigned int offset;
     unsigned int length;
     unsigned long dvma_address;
 };
diff --git a/include/asm-mips/scatterlist.h b/include/asm-mips/scatterlist.h
index ca4ff3032..861c2247f 100644
--- a/include/asm-mips/scatterlist.h
+++ b/include/asm-mips/scatterlist.h
@@ -2,7 +2,8 @@
 #define __ASM_MIPS_SCATTERLIST_H
 
 struct scatterlist {
-    char *  address;    /* Location data is to be transferred to */
+    struct page *page;
+    unsigned int offset;
     unsigned int length;
     
     __u32 dvma_address;
diff --git a/include/asm-mips64/scatterlist.h b/include/asm-mips64/scatterlist.h
index a8dc98fe8..67353a180 100644
--- a/include/asm-mips64/scatterlist.h
+++ b/include/asm-mips64/scatterlist.h
@@ -2,7 +2,8 @@
 #define __ASM_MIPS64_SCATTERLIST_H
 
 struct scatterlist {
-    char *  address;    /* Location data is to be transferred to */
+    struct page *page;
+    unsigned int offset;
     unsigned int length;
     
     __u32 dvma_address;
diff --git a/include/asm-parisc/scatterlist.h b/include/asm-parisc/scatterlist.h
index 9ebf3172b..0d7812764 100644
--- a/include/asm-parisc/scatterlist.h
+++ b/include/asm-parisc/scatterlist.h
@@ -2,7 +2,8 @@
 #define _ASM_PARISC_SCATTERLIST_H
 
 struct scatterlist {
-	char *  address;    /* Location data is to be transferred to */
+	struct page *page;
+	unsigned int offset;
 	unsigned int length;
 
 	/* an IOVA can be 64-bits on some PA-Risc platforms. */
diff --git a/include/asm-ppc/pci.h b/include/asm-ppc/pci.h
index 9298bcded..bb8c992e6 100644
--- a/include/asm-ppc/pci.h
+++ b/include/asm-ppc/pci.h
@@ -157,15 +157,10 @@ static inline int pci_map_sg(struct pci_dev *hwdev, struct scatterlist *sg,
 	 * temporary 2.4 hack
 	 */
 	for (i = 0; i < nents; i++) {
-		if (sg[i].address && sg[i].page)
-			BUG();
-		else if (!sg[i].address && !sg[i].page)
+		if (!sg[i].page)
 			BUG();
 
-		if (sg[i].address)
-			sg[i].dma_address = virt_to_bus(sg[i].address);
-		else
-			sg[i].dma_address = page_to_bus(sg[i].page) + sg[i].offset;
+		sg[i].dma_address = page_to_bus(sg[i].page) + sg[i].offset;
 	}
 
 	return nents;
diff --git a/include/asm-ppc/scatterlist.h b/include/asm-ppc/scatterlist.h
index 392e89778..80be401b5 100644
--- a/include/asm-ppc/scatterlist.h
+++ b/include/asm-ppc/scatterlist.h
@@ -8,10 +8,8 @@
 #include <asm/dma.h>
 
 struct scatterlist {
-	char *address;		/* Location data is to be transferred to,
-				 * or NULL for highmem page */
-	struct page * page;	/* Location for highmem page, if any */
-	unsigned int offset;	/* for highmem, page offset */
+	struct page * page;
+	unsigned int offset;
 
 	dma_addr_t dma_address;	/* phys/bus dma address		 */
 	unsigned int length;	/* length			 */
diff --git a/include/asm-s390/scatterlist.h b/include/asm-s390/scatterlist.h
index 7d1276c45..114ceaf53 100644
--- a/include/asm-s390/scatterlist.h
+++ b/include/asm-s390/scatterlist.h
@@ -2,7 +2,8 @@
 #define _ASMS390X_SCATTERLIST_H
 
 struct scatterlist {
-    char *  address;    /* Location data is to be transferred to */
+    struct page *page;
+    unsigned int offset;
     unsigned int length;
 };
 
diff --git a/include/asm-s390x/scatterlist.h b/include/asm-s390x/scatterlist.h
index 7d1276c45..114ceaf53 100644
--- a/include/asm-s390x/scatterlist.h
+++ b/include/asm-s390x/scatterlist.h
@@ -2,7 +2,8 @@
 #define _ASMS390X_SCATTERLIST_H
 
 struct scatterlist {
-    char *  address;    /* Location data is to be transferred to */
+    struct page *page;
+    unsigned int offset;
     unsigned int length;
 };
 
diff --git a/include/asm-sh/pci.h b/include/asm-sh/pci.h
index c47bde5a3..a2110cbb0 100644
--- a/include/asm-sh/pci.h
+++ b/include/asm-sh/pci.h
@@ -149,7 +149,7 @@ static inline int pci_map_sg(struct pci_dev *hwdev, struct scatterlist *sg,
 	int i;
 
 	for (i=0; i<nents; i++)
-		dma_cache_wback_inv(sg[i].address, sg[i].length);
+		dma_cache_wback_inv(page_address(sg[i].page) + sg[i].offset, sg[i].length);
 #endif
 	if (direction == PCI_DMA_NONE)
                 BUG();
@@ -206,7 +206,7 @@ static inline void pci_dma_sync_sg(struct pci_dev *hwdev,
 	int i;
 
 	for (i=0; i<nelems; i++)
-		dma_cache_wback_inv(sg[i].address, sg[i].length);
+		dma_cache_wback_inv(page_address(sg[i].page) + sg[i].offset, sg[i].length);
 #endif
 }
 
diff --git a/include/asm-sh/scatterlist.h b/include/asm-sh/scatterlist.h
index fcd23eeb8..b580e05d0 100644
--- a/include/asm-sh/scatterlist.h
+++ b/include/asm-sh/scatterlist.h
@@ -2,7 +2,8 @@
 #define __ASM_SH_SCATTERLIST_H
 
 struct scatterlist {
-    char *  address;    /* Location data is to be transferred to */
+    struct page *page;
+    unsigned int offset;
     unsigned int length;
 };
 
diff --git a/include/asm-sparc/scatterlist.h b/include/asm-sparc/scatterlist.h
index 27c35f783..07a7f344c 100644
--- a/include/asm-sparc/scatterlist.h
+++ b/include/asm-sparc/scatterlist.h
@@ -1,16 +1,10 @@
-/* $Id: scatterlist.h,v 1.7 2001-10-30 04:34:57 davem Exp $ */
+/* $Id: scatterlist.h,v 1.8 2001-12-17 07:05:15 davem Exp $ */
 #ifndef _SPARC_SCATTERLIST_H
 #define _SPARC_SCATTERLIST_H
 
 #include <linux/types.h>
 
 struct scatterlist {
-	/* This will disappear in 2.5.x */
-	char *address;
-
-	/* These two are only valid if ADDRESS member of this
-	 * struct is NULL.
-	 */
 	struct page *page;
 	unsigned int offset;
 
diff --git a/include/asm-sparc64/scatterlist.h b/include/asm-sparc64/scatterlist.h
index 01d5eba05..0a3111128 100644
--- a/include/asm-sparc64/scatterlist.h
+++ b/include/asm-sparc64/scatterlist.h
@@ -1,23 +1,17 @@
-/* $Id: scatterlist.h,v 1.10 2001-10-09 02:24:35 davem Exp $ */
+/* $Id: scatterlist.h,v 1.11 2001-12-17 07:05:15 davem Exp $ */
 #ifndef _SPARC64_SCATTERLIST_H
 #define _SPARC64_SCATTERLIST_H
 
 #include <asm/page.h>
 
 struct scatterlist {
-	/* This will disappear in 2.5.x */
-	char *address;
+	struct page	*page;
+	unsigned int	offset;
 
-	/* These two are only valid if ADDRESS member of this
-	 * struct is NULL.
-	 */
-	struct page *page;
-	unsigned int offset;
+	unsigned int	length;
 
-	unsigned int length;
-
-	dma_addr_t dma_address;
-	__u32 dma_length;
+	dma_addr_t	dma_address;
+	__u32		dma_length;
 };
 
 #define sg_dma_address(sg)	((sg)->dma_address)