kill struct scatterlist address member

73 files changed, 338 insertions, 390 deletions

diff --git a/drivers/block/DAC960.h b/drivers/block/DAC960.h
index 9826533648eb..eb5c2027ab4d 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/ps2esdi.c b/drivers/block/ps2esdi.c
index f23918b051d8..37bb445878fc 100644
--- a/drivers/block/ps2esdi.c
+++ b/drivers/block/ps2esdi.c
@@ -475,7 +475,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 */
@@ -663,7 +663,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 7db25b2a0e54..166956be0f16 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 588c6467d125..97f842cb21ab 100644
--- a/drivers/char/esp.c
+++ b/drivers/char/esp.c
@@ -392,7 +392,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);
@@ -569,7 +569,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);
@@ -599,7 +599,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 792a8fdc23d7..f2afd4cf4db3 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 cc236dd7c277..4e5cfcf6a60f 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 bd57c42e61a0..ddf546d5d299 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 2d6d6b539f92..9bea2535d19d 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 801037a4730e..58465ff52a08 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 4c16aa854b9f..856e5552ac39 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 49d80260a285..a14399223c85 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 7f91256e65ab..8386addb6acc 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 de2013540e2d..83cecdc7e2a6 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 64d559cf253e..eb2480f3a253 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 7aa8c837e645..75bd0aedbf77 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 2daff418971b..7cac667930e3 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 cbe421d5f498..31f4f5a6bc81 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 c9f5f7f425c1..a54402308b84 100644
--- a/drivers/net/defxx.c
+++ b/drivers/net/defxx.c
@@ -199,6 +199,8 @@
  *		Feb 2001	davej		PCI enable cleanups.
  */
 
+#error 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 49ed98d4d878..62559339f083 100644
--- a/drivers/net/dl2k.h
+++ b/drivers/net/dl2k.h
@@ -792,6 +792,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 0b25e65b9cca..a299ee7a39ae 100644
--- a/drivers/net/hp100.c
+++ b/drivers/net/hp100.c
@@ -83,6 +83,8 @@
 **
 */
 
+#error 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 ac7a07cb5ebb..3122340f2876 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 54d5c958de0f..e93eb24efc7f 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 b80f239169ac..c1e925d2f57c 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 6b408b118cd1..b2a1f3a6c640 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 d222d5480bf8..e89fae619c60 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 84f5a31ae71d..849b1852d8c4 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 0b5bcdcc1eaa..f0a8fedaf8ba 100644
--- a/drivers/net/rcpci45.c
+++ b/drivers/net/rcpci45.c
@@ -44,6 +44,8 @@
 **
 ***************************************************************************/
 
+#error 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 f476a5d483b3..4192b5e7aa25 100644
--- a/drivers/net/rrunner.c
+++ b/drivers/net/rrunner.c
@@ -21,6 +21,8 @@
  * ODS/Essential.
  */
 
+#error 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 21ab6e3af3da..3a7cf6ac954b 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 7082e8877e45..1246f4308b15 100644
--- a/drivers/net/tlan.c
+++ b/drivers/net/tlan.c
@@ -160,6 +160,7 @@
  *
  *******************************************************************************/
 
+#error 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 5c26cb94f8c0..eaaedb980170 100644
--- a/drivers/scsi/3w-xxxx.c
+++ b/drivers/scsi/3w-xxxx.c
@@ -108,6 +108,8 @@
                  Fix get_param for specific units.
 */
 
+#error 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 2cd317cb8355..a944ae49708e 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 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 8381d13cb2a6..ee62d61330d8 100644
--- a/drivers/scsi/AM53C974.c
+++ b/drivers/scsi/AM53C974.c
@@ -1,3 +1,5 @@
+#error 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 1b8c292e6854..c6ceeda9c11b 100644
--- a/drivers/scsi/BusLogic.c
+++ b/drivers/scsi/BusLogic.c
@@ -29,6 +29,7 @@
 #define BusLogic_DriverVersion		"2.1.15"
 #define BusLogic_DriverDate		"17 August 1998"
 
+#error 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 6b75605b352a..b4568351d1e3 100644
--- a/drivers/scsi/advansys.c
+++ b/drivers/scsi/advansys.c
@@ -752,6 +752,7 @@
 
 */
 
+#error Please convert me to Documentation/DMA-mapping.txt
 
 /*
  * --- Linux Version
diff --git a/drivers/scsi/aha1542.c b/drivers/scsi/aha1542.c
index 2198459e2bbc..a93ff6dd3d6a 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");
 }
@@ -70,7 +71,7 @@ static void BAD_SG_DMA(Scsi_Cmnd * SCpnt,
 	printk(KERN_CRIT "sgpnt[%d:%d] page %p/0x%lx length %d\n",
 	       badseg, nseg,
 	       page_address(sgpnt[badseg].page) + sgpnt[badseg].offset,
-	       (unsigned long)page_to_bus(sgpnt[badseg].page) + sgpnt[badseg].offset,
+	       SCSI_SG_PA(&sgpnt[badseg]),
 	       sgpnt[badseg].length);
 
 	/*
@@ -511,7 +512,7 @@ static void aha1542_intr_handle(struct Scsi_Host *shost, void *dev_id, struct pt
 			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));
 
@@ -715,7 +716,8 @@ static int aha1542_queuecommand(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
 				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,
-					       page_address(sgpnt[i].page) + sgpnt[i].offset,
+					       (page_address(sgpnt[i].page) +
+						sgpnt[i].offset),
 					       sgpnt[i].length);
 				};
 				printk(KERN_CRIT "cptr %x: ", (unsigned int) cptr);
@@ -724,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, page_to_bus(sgpnt[i].page) + sgpnt[i].offset);
-			if (page_to_bus(sgpnt[i].page) + sgpnt[i].offset + 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;
@@ -741,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;
@@ -803,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) {
@@ -1186,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;
 			}
@@ -1399,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 44c9d83eaec7..ad043e6020c8 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_old.c b/drivers/scsi/aic7xxx_old.c
index 6af87bc47153..0c64cd55f048 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]))
@@ -2841,17 +2835,9 @@ aic7xxx_done(struct aic7xxx_host *p, struct aic7xxx_scb *scb)
         char *buffer;
 
         if(cmd->use_sg)
-        {
-          struct scatterlist *sg;
-
-          sg = (struct scatterlist *)cmd->request_buffer;
-          buffer = (char *)sg[0].address;
-        }
-        else
-        {
-          buffer = (char *)cmd->request_buffer;
-        }
+          BUG();
 
+        buffer = (char *)cmd->request_buffer;
 
         if ( (buffer[7] & WIDE_INQUIRY_BITS) &&
              (p->features & AHC_WIDE) )
diff --git a/drivers/scsi/atp870u.c b/drivers/scsi/atp870u.c
index 7cf724157498..5ba17a3bc2ff 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 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 fc1c90a0ae4c..1d5c5172ef96 100644
--- a/drivers/scsi/dpt_i2o.c
+++ b/drivers/scsi/dpt_i2o.c
@@ -28,6 +28,8 @@
 
 #define ADDR32 (0)
 
+#error 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 6b02eb9c97ec..50f1395efd95 100644
--- a/drivers/scsi/eata.c
+++ b/drivers/scsi/eata.c
@@ -401,6 +401,8 @@
  *  the driver sets host->wish_block = TRUE for all ISA boards.
  */
 
+#error 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 ca72457de7af..5fcd0b321b6c 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 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 28b8ea274682..8508b693f316 100644
--- a/drivers/scsi/gdth.c
+++ b/drivers/scsi/gdth.c
@@ -295,6 +295,8 @@
  * phase:                       Service/parameter/return code special command
  */
 
+#error 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 0153b018ecc9..1b034e4e4e7f 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 1fba128f8e5b..c6c53caf11d3 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 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 82ffd13ac384..d636682b6b52 100644
--- a/drivers/scsi/inia100.c
+++ b/drivers/scsi/inia100.c
@@ -67,6 +67,8 @@
 #include <linux/version.h>
 #endif
 
+#error 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 258af5f19516..d428ece2c82e 100644
--- a/drivers/scsi/ips.c
+++ b/drivers/scsi/ips.c
@@ -140,6 +140,8 @@
  * ioctlsize            - Initial size of the IOCTL buffer
  */
  
+#error 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 d6d0d39da3ec..3e4bcaec167f 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 47820a3effb4..4c8d0a95e34b 100644
--- a/drivers/scsi/osst.c
+++ b/drivers/scsi/osst.c
@@ -479,7 +479,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");
 		}
 		return 1;
@@ -4375,12 +4376,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! */
@@ -4933,15 +4934,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;
 		}
@@ -4953,9 +4953,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 */
@@ -4985,7 +4985,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) {
@@ -5030,9 +5030,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--;
@@ -5080,7 +5080,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
@@ -5108,7 +5108,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;
@@ -5141,7 +5141,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;
@@ -5174,7 +5174,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;
 	}
@@ -5194,7 +5194,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;
 	}
@@ -5215,7 +5215,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 27607cd040d1..77f007e9d85a 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 d1ceb1d5193d..f081655aa5ba 100644
--- a/drivers/scsi/qla1280.c
+++ b/drivers/scsi/qla1280.c
@@ -182,6 +182,7 @@ END OF TERMS AND CONDITIONS
     -   Initial Beta Release.  
 *****************************************************************************/
 
+#error 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 94940c0d670d..e45098075934 100644
--- a/drivers/scsi/scsi.h
+++ b/drivers/scsi/scsi.h
@@ -734,7 +734,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_lib.c b/drivers/scsi/scsi_lib.c
index b23f616592db..66f21a37291e 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -450,18 +450,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)
@@ -525,24 +515,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 5d052023478c..24a7e0c38017 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 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 761dfc562709..4b0019793624 100644
--- a/drivers/scsi/seagate.c
+++ b/drivers/scsi/seagate.c
@@ -1061,8 +1061,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 aaffa09a5bf6..5aedd68301f7 100644
--- a/drivers/scsi/sgiwd93.c
+++ b/drivers/scsi/sgiwd93.c
@@ -120,9 +120,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
@@ -227,7 +231,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 e3be22e06095..84723470e17d 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:
@@ -944,7 +944,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
@@ -991,7 +991,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 */
 	}
@@ -1044,7 +1044,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);
     }
@@ -1122,48 +1122,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;
@@ -1508,7 +1507,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;
@@ -1562,7 +1561,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++) {
@@ -1578,7 +1577,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 022f5caf1f8b..dde07870e33f 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -3404,15 +3404,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 */
@@ -3424,10 +3423,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
@@ -3443,7 +3441,6 @@ static ST_buffer *
 					tb = NULL;
 					break;
 				}
-				tb->sg[segs].page = NULL;
 				tb->sg[segs].length = b_size;
 				got += b_size;
 				segs++;
@@ -3457,7 +3454,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",
@@ -3503,9 +3500,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--;
@@ -3517,7 +3514,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;
@@ -3541,13 +3537,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;
@@ -3570,7 +3566,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;
@@ -3603,7 +3599,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/ultrastor.c b/drivers/scsi/ultrastor.c
index 64f088ef9a44..4ef6ee13dcaf 100644
--- a/drivers/scsi/ultrastor.c
+++ b/drivers/scsi/ultrastor.c
@@ -667,12 +667,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.  */
@@ -728,7 +728,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;		/*???*/
@@ -738,7 +738,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;
@@ -796,7 +796,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) {
@@ -872,9 +872,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);
       }
 
@@ -910,7 +910,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));
@@ -1043,7 +1043,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 d3a84ab0f6ad..3e1bafa68cb1 100644
--- a/drivers/scsi/wd7000.c
+++ b/drivers/scsi/wd7000.c
@@ -1111,7 +1111,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;
@@ -1187,13 +1187,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/hpusbscsi.c b/drivers/usb/hpusbscsi.c
index 37cae7f9ce42..71e60ef6aeeb 100644
--- a/drivers/usb/hpusbscsi.c
+++ b/drivers/usb/hpusbscsi.c
@@ -454,7 +454,8 @@ static void scatter_gather_callback(struct urb *u)
                 u,
                 hpusbscsi->dev,
                 hpusbscsi->current_data_pipe,
-                sg[hpusbscsi->fragment].address,
+                page_address(sg[hpusbscsi->fragment].page) +
+		sg[hpusbscsi->fragment].offset,
                 sg[hpusbscsi->fragment++].length,
                 callback,
                 hpusbscsi
diff --git a/drivers/usb/microtek.c b/drivers/usb/microtek.c
index 83d325608f57..ff190dcd76ba 100644
--- a/drivers/usb/microtek.c
+++ b/drivers/usb/microtek.c
@@ -609,10 +609,11 @@ static void mts_do_sg (struct urb* transfer)
 	sg = context->srb->buffer;
 	context->fragment++;
 	mts_int_submit_urb(transfer,
-			context->data_pipe,
-			sg[context->fragment].address,
-			sg[context->fragment].length,
-			context->fragment + 1 == context->srb->use_sg ? mts_data_done : mts_do_sg);
+			   context->data_pipe,
+			   page_address(sg[context->fragment].page) +
+			   sg[context->fragment].offset,
+			   sg[context->fragment].length,
+			   context->fragment + 1 == context->srb->use_sg ? mts_data_done : mts_do_sg);
 	return;
 }
 
@@ -654,7 +655,7 @@ mts_build_transfer_context( Scsi_Cmnd *srb, struct mts_desc* desc )
 	} else {
 		MTS_DEBUG("Using scatter/gather\n");
 		sg = srb->buffer;
-		desc->context.data = sg[0].address;
+		desc->context.data = page_address(sg[0].page) + sg[0].offset;
 		desc->context.data_length = sg[0].length;
 	}
 
diff --git a/drivers/usb/storage/freecom.c b/drivers/usb/storage/freecom.c
index 465af85d7b5f..f273ea54f635 100644
--- a/drivers/usb/storage/freecom.c
+++ b/drivers/usb/storage/freecom.c
@@ -144,11 +144,11 @@ static void us_transfer_freecom(Scsi_Cmnd *srb, struct us_data* us, int transfer
 			if (transfer_amount - total_transferred >= 
 					sg[i].length) {
 				result = usb_stor_transfer_partial(us,
-						sg[i].address, sg[i].length);
+						page_address(sg[i].page) + sg[i].offset, sg[i].length);
 				total_transferred += sg[i].length;
 			} else {
 				result = usb_stor_transfer_partial(us,
-						sg[i].address,
+						page_address(sg[i].page) + sg[i].offset,
 						transfer_amount - total_transferred);
 				total_transferred += transfer_amount - total_transferred;
 			}
diff --git a/drivers/usb/storage/isd200.c b/drivers/usb/storage/isd200.c
index baab4d50d916..d7840dc8f349 100644
--- a/drivers/usb/storage/isd200.c
+++ b/drivers/usb/storage/isd200.c
@@ -518,13 +518,13 @@ static void isd200_transfer( struct us_data *us, Scsi_Cmnd *srb )
                             sg[i].length) {
                                 result = isd200_transfer_partial(us, 
                                                                  srb->sc_data_direction,
-                                                                 sg[i].address, 
+                                                                 page_address(sg[i].page) + sg[i].offset, 
                                                                  sg[i].length);
                                 total_transferred += sg[i].length;
                         } else
                                 result = isd200_transfer_partial(us, 
                                                                  srb->sc_data_direction,                            
-                                                                 sg[i].address,
+                                                                 page_address(sg[i].page) + sg[i].offset,
                                                                  transfer_amount - total_transferred);
 
                         /* if we get an error, end the loop here */
@@ -1415,10 +1415,10 @@ void isd200_data_copy(Scsi_Cmnd *srb, char * src, int length)
 				/* transfer the lesser of the next buffer or the
 				 * remaining data */
 				if (len - total >= sg[i].length) {
-					memcpy(sg[i].address, src + total, sg[i].length);
+					memcpy(page_address(sg[i].page) + sg[i].offset, src + total, sg[i].length);
 					total += sg[i].length;
 				} else {
-					memcpy(sg[i].address, src + total, len - total);
+					memcpy(page_address(sg[i].page) + sg[i].offset, src + total, len - total);
 					total = len;
 				}
 			} 
diff --git a/drivers/usb/storage/protocol.c b/drivers/usb/storage/protocol.c
index c4e397cb970a..c2bc41be7357 100644
--- a/drivers/usb/storage/protocol.c
+++ b/drivers/usb/storage/protocol.c
@@ -67,13 +67,10 @@ void fix_inquiry_data(Scsi_Cmnd *srb)
 	US_DEBUGP("Fixing INQUIRY data to show SCSI rev 2\n");
 
 	/* find the location of the data */
-	if (srb->use_sg) {
-		struct scatterlist *sg;
+	if (srb->use_sg)
+		BUG();
 
-		sg = (struct scatterlist *) srb->request_buffer;
-		data_ptr = (unsigned char *) sg[0].address;
-	} else
-		data_ptr = (unsigned char *)srb->request_buffer;
+	data_ptr = (unsigned char *) srb->request_buffer;
 
 	/* Change the SCSI revision number */
 	data_ptr[2] = (data_ptr[2] & ~7) | 2;
diff --git a/drivers/usb/storage/scsiglue.c b/drivers/usb/storage/scsiglue.c
index 44e6cf0a9b7e..8611a366d937 100644
--- a/drivers/usb/storage/scsiglue.c
+++ b/drivers/usb/storage/scsiglue.c
@@ -564,7 +564,12 @@ int usb_stor_scsiSense10to6( Scsi_Cmnd* the10 )
 	    }
 
 	  /* copy one byte */
-	  sg[db].address[di] = sg[sb].address[si];
+	  {
+		  char *src = page_address(sg[sb].page) + sg[sb].offset + si;
+		  char *dst = page_address(sg[db].page) + sg[db].offset + di;
+
+		  *dst = *src;
+	  }
 
 	  /* get next destination */
 	  if ( sg[db].length-1 == di )
@@ -602,7 +607,7 @@ int usb_stor_scsiSense10to6( Scsi_Cmnd* the10 )
 	      break;
 	    }
 
-	  sg[db].address[di] = 0;
+	  *(char *)(page_address(sg[db].page) + sg[db].offset) = 0;
 
 	  /* get next destination */
 	  if ( sg[db].length-1 == di )
@@ -752,7 +757,12 @@ int usb_stor_scsiSense6to10( Scsi_Cmnd* the6 )
 	    }
 
 	  /* copy one byte */
-	  sg[db].address[di] = sg[sb].address[si];
+	  {
+		  char *src = page_address(sg[sb].page) + sg[sb].offset + si;
+		  char *dst = page_address(sg[db].page) + sg[db].offset + di;
+
+		  *dst = *src;
+	  }
 
 	  /* get next destination */
 	  if ( di == 0 )
@@ -789,7 +799,11 @@ int usb_stor_scsiSense6to10( Scsi_Cmnd* the6 )
 	      break;
 	    }
 
-	  sg[db].address[di] = tempBuffer[element-USB_STOR_SCSI_SENSE_HDRSZ];
+	  {
+		  char *dst = page_address(sg[db].page) + sg[db].offset + di;
+
+		  *dst = tempBuffer[element-USB_STOR_SCSI_SENSE_HDRSZ];
+	  }
 
 	  /* get next destination */
 	  if ( di == 0 )
@@ -839,13 +853,19 @@ void usb_stor_scsiSenseParseBuffer( Scsi_Cmnd* srb, Usb_Stor_Scsi_Sense_Hdr_u* t
 		  if ( element < USB_STOR_SCSI_SENSE_HDRSZ )
 		    {
 		      /* fill in the pointers for both header types */
-		      the6->array[element] = &(sg[i].address[j]);
-		      the10->array[element] = &(sg[i].address[j]);
+		      the6->array[element] =
+			      page_address(sg[i].page) +
+			      sg[i].offset + j;
+		      the10->array[element] =
+			      page_address(sg[i].page) +
+			      sg[i].offset + j;
 		    }
 		  else if ( element < USB_STOR_SCSI_SENSE_10_HDRSZ )
 		    {
 		      /* only the longer headers still cares now */
-		      the10->array[element] = &(sg[i].address[j]);
+		      the10->array[element] =
+			      page_address(sg[i].page) +
+			      sg[i].offset + j;
 		    }
 		  /* increase element counter */
 		  element++;
diff --git a/drivers/usb/storage/sddr09.c b/drivers/usb/storage/sddr09.c
index 10227ee44c16..bc14015ae97f 100644
--- a/drivers/usb/storage/sddr09.c
+++ b/drivers/usb/storage/sddr09.c
@@ -239,7 +239,7 @@ static int sddr09_bulk_transport(struct us_data *us,
 		sg = (struct scatterlist *)data;
 		for (i=0; i<use_sg && transferred<len; i++) {
 			result = sddr09_raw_bulk(us, direction,
-				sg[i].address, 
+				page_address(sg[i].page) + sg[i].offset, 
 				len-transferred > sg[i].length ?
 					sg[i].length : len-transferred);
 			if (result!=US_BULK_TRANSFER_GOOD)
@@ -384,7 +384,7 @@ int sddr09_read_data(struct us_data *us,
 	if (use_sg) {
 		transferred = 0;
 		for (i=0; i<use_sg && transferred<len; i++) {
-			memcpy(sg[i].address, buffer+transferred,
+			memcpy(page_address(sg[i].page) + sg[i].offset, buffer+transferred,
 				len-transferred > sg[i].length ?
 					sg[i].length : len-transferred);
 			transferred += sg[i].length;
@@ -636,21 +636,24 @@ int sddr09_read_map(struct us_data *us) {
 
 	for (i=0; i<alloc_blocks; i++) {
 		if (i<alloc_blocks-1) {
-			sg[i].address = kmalloc( (1<<17), GFP_NOIO );
-			sg[i].page = NULL;
+			char *vaddr = kmalloc(1 << 17, GFP_NOIO);
+			sg[i].page = virt_to_page(vaddr);
+			sg[i].offset = ((unsigned long)vaddr & ~PAGE_MASK);
 			sg[i].length = (1<<17);
 		} else {
-			sg[i].address = kmalloc(alloc_len, GFP_NOIO);
-			sg[i].page = NULL;
+			char *vaddr = kmalloc(alloc_len, GFP_NOIO);
+			sg[i].page = virt_to_page(vaddr);
+			sg[i].offset = ((unsigned long)vaddr & ~PAGE_MASK);
 			sg[i].length = alloc_len;
 		}
 		alloc_len -= sg[i].length;
 	}
+
 	for (i=0; i<alloc_blocks; i++)
-		if (sg[i].address == NULL) {
+		if (sg[i].page == NULL) {
 			for (i=0; i<alloc_blocks; i++)
-				if (sg[i].address != NULL)
-					kfree(sg[i].address);
+				if (sg[i].page != NULL)
+					kfree(page_address(sg[i].page) + sg[i].offset);
 			kfree(sg);
 			return 0;
 		}
@@ -661,7 +664,7 @@ int sddr09_read_map(struct us_data *us) {
 			(unsigned char *)sg, alloc_blocks)) !=
 			USB_STOR_TRANSPORT_GOOD) {
 		for (i=0; i<alloc_blocks; i++)
-			kfree(sg[i].address);
+			kfree(page_address(sg[i].page) + sg[i].offset);
 		kfree(sg);
 		return -1;
 	}
@@ -683,7 +686,7 @@ int sddr09_read_map(struct us_data *us) {
 		info->lba_to_pba = NULL;
 		info->pba_to_lba = NULL;
 		for (i=0; i<alloc_blocks; i++)
-			kfree(sg[i].address);
+			kfree(page_address(sg[i].page) + sg[i].offset);
 		kfree(sg);
 		return 0;
 	}
@@ -695,7 +698,7 @@ int sddr09_read_map(struct us_data *us) {
 	// scatterlist block i*64/128k = i*(2^6)*(2^-17) = i*(2^-11)
 
 	for (i=0; i<numblocks; i++) {
-		ptr = sg[i>>11].address+((i&0x7ff)<<6);
+		ptr = page_address(sg[i>>11].page)+sg[i>>11].offset+((i&0x7ff)<<6);
 		if (ptr[0]!=0xFF || ptr[1]!=0xFF || ptr[2]!=0xFF ||
 		    ptr[3]!=0xFF || ptr[4]!=0xFF || ptr[5]!=0xFF) {
 			US_DEBUGP("PBA %04X has no logical mapping: reserved area = "
@@ -748,7 +751,7 @@ int sddr09_read_map(struct us_data *us) {
 	}
 
 	for (i=0; i<alloc_blocks; i++)
-		kfree(sg[i].address);
+		kfree(page_address(sg[i].page)+sg[i].offset);
 	kfree(sg);
 	return 0;
 }
diff --git a/drivers/usb/storage/shuttle_usbat.c b/drivers/usb/storage/shuttle_usbat.c
index 602b0f75f7de..9770f9103210 100644
--- a/drivers/usb/storage/shuttle_usbat.c
+++ b/drivers/usb/storage/shuttle_usbat.c
@@ -214,7 +214,7 @@ static int usbat_bulk_transport(struct us_data *us,
 		sg = (struct scatterlist *)data;
 		for (i=0; i<use_sg && transferred<len; i++) {
 			result = usbat_raw_bulk(us, direction,
-				sg[i].address, 
+				page_address(sg[i].page) + sg[i].offset,
 				len-transferred > sg[i].length ?
 					sg[i].length : len-transferred);
 			if (result!=US_BULK_TRANSFER_GOOD)
@@ -733,17 +733,19 @@ int usbat_handle_read10(struct us_data *us,
 			while (amount<len) {
 				if (len - amount >= 
 					  sg[sg_segment].length-sg_offset) {
-				  memcpy(sg[sg_segment].address + sg_offset,
-					buffer + amount,
-					sg[sg_segment].length - sg_offset);
+				  memcpy(page_address(sg[sg_segment].page) +
+					 sg[sg_segment].offset + sg_offset,
+					 buffer + amount,
+					 sg[sg_segment].length - sg_offset);
 				  amount += 
 					  sg[sg_segment].length-sg_offset;
 				  sg_segment++;
 				  sg_offset=0;
 				} else {
-				  memcpy(sg[sg_segment].address + sg_offset,
-					buffer + amount,
-					len - amount);
+				  memcpy(page_address(sg[sg_segment].page) +
+					 sg[sg_segment].offset + sg_offset,
+					 buffer + amount,
+					 len - amount);
 				  sg_offset += (len - amount);
 				  amount = len;
 				}
diff --git a/drivers/usb/storage/transport.c b/drivers/usb/storage/transport.c
index 089672906f27..7b40983c7a99 100644
--- a/drivers/usb/storage/transport.c
+++ b/drivers/usb/storage/transport.c
@@ -584,11 +584,11 @@ void usb_stor_transfer(Scsi_Cmnd *srb, struct us_data* us)
 			if (transfer_amount - total_transferred >= 
 					sg[i].length) {
 				result = usb_stor_transfer_partial(us,
-						sg[i].address, sg[i].length);
+						page_address(sg[i].page) + sg[i].offset, sg[i].length);
 				total_transferred += sg[i].length;
 			} else
 				result = usb_stor_transfer_partial(us,
-						sg[i].address,
+						page_address(sg[i].page) + sg[i].offset,
 						transfer_amount - total_transferred);
 
 			/* if we get an error, end the loop here */
diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
index 6d93cbbe76bb..0932c1b27119 100644
--- a/drivers/usb/storage/usb.c
+++ b/drivers/usb/storage/usb.c
@@ -288,13 +288,13 @@ void fill_inquiry_response(struct us_data *us, unsigned char *data,
 	if (us->srb->use_sg) {
 		sg = (struct scatterlist *)us->srb->request_buffer;
 		for (i=0; i<us->srb->use_sg; i++)
-			memset(sg[i].address, 0, sg[i].length);
+			memset(page_address(sg[i].page) + sg[i].offset, 0, sg[i].length);
 		for (i=0, transferred=0; 
 				i<us->srb->use_sg && transferred < len;
 				i++) {
 			amt = sg[i].length > len-transferred ? 
 					len-transferred : sg[i].length;
-			memcpy(sg[i].address, data+transferred, amt);
+			memcpy(page_address(sg[i].page) + sg[i].offset, data+transferred, amt);
 			transferred -= amt;
 		}
 	} else {
diff --git a/drivers/usb/usb-uhci-debug.h b/drivers/usb/usb-uhci-debug.h
index c10ac3146c20..0fa124d8b020 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 71bb78350ef8..3c89ed98235c 100644
--- a/drivers/usb/usb-uhci.c
+++ b/drivers/usb/usb-uhci.c
@@ -685,7 +685,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;
 
@@ -800,7 +799,6 @@ _static int uhci_submit_control_urb (struct urb *urb)
 
 	qh->hw.qh.element &= cpu_to_le32(~UHCI_PTR_TERM);
 
-	//uhci_show_queue(qh);
 	/* Start it up... put low speed first */
 	if (urb->dev->speed == USB_SPEED_LOW)
 		insert_qh (s, s->control_chain, qh, 0);
@@ -949,7 +947,6 @@ _static int uhci_submit_bulk_urb (struct urb *urb, struct urb *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 2ae48765cee2..1278f3a0ebd8 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>: