if (ret != NULL) {
memset(ret, 0, size);
- *dma_handle = virt_to_bus(ret);
+ *dma_handle = virt_to_phys(ret);
}
return ret;
}
/* Video ROM is standard at C000:0000 - C7FF:0000, check signature */
for (base = 0xC0000; base < 0xE0000; base += 2048) {
- romstart = bus_to_virt(base);
+ romstart = isa_bus_to_virt(base);
if (!romsignature(romstart))
continue;
request_resource(&iomem_resource, rom_resources + roms);
for (base = 0xC8000; base < 0xE0000; base += 2048) {
unsigned long length;
- romstart = bus_to_virt(base);
+ romstart = isa_bus_to_virt(base);
if (!romsignature(romstart))
continue;
length = romstart[2] * 512;
/* Final check for motherboard extension rom at E000:0000 */
base = 0xE0000;
- romstart = bus_to_virt(base);
+ romstart = isa_bus_to_virt(base);
if (romsignature(romstart)) {
rom_resources[roms].start = base;
init_mm.end_data = (unsigned long) &_edata;
init_mm.brk = (unsigned long) &_end;
- code_resource.start = virt_to_bus(&_text);
- code_resource.end = virt_to_bus(&_etext)-1;
- data_resource.start = virt_to_bus(&_etext);
- data_resource.end = virt_to_bus(&_edata)-1;
+ code_resource.start = virt_to_phys(&_text);
+ code_resource.end = virt_to_phys(&_etext)-1;
+ data_resource.start = virt_to_phys(&_etext);
+ data_resource.end = virt_to_phys(&_edata)-1;
parse_mem_cmdline(cmdline_p);
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.
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 */
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);
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;
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);
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);
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);
# 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
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 */
* 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>
* 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>
*
*/
+#error Please convert me to Documentation/DMA-mapping.txt
+
#include <linux/config.h>
#include <linux/module.h>
#include <linux/kernel.h>
* 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>
* 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>
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);
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;
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. */
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;
/* 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;
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++;
}
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->
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 {
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);
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. */
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++) {
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));
}
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 */
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)
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;
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;
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();
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
{
* 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;
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)) {
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);
* Feb 2001 davej PCI enable cleanups.
*/
+#error Please convert me to Documentation/DMA-mapping.txt
+
/* Include files */
#include <linux/module.h>
}
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++) {
**
*/
+#error Please convert me to Documentation/DMA-mapping.txt
+
#define HP100_DEFAULT_PRIORITY_TX 0
#undef HP100_DEBUG
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);
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);
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 */
}
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
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
/* 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++;
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);
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);
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;
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;
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? */
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++)
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));
/* 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 */
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);
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);
#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;
}
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);
{
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;
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);
}
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
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
**
***************************************************************************/
+#error Please convert me to Documentation/DMA-mapping.txt
+
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/sched.h>
* ODS/Essential.
*/
+#error Please convert me to Documentation/DMA-mapping.txt
+
#define DEBUG 1
#define RX_DMA_SKBUFF 1
#define PKT_COPY_THRESHOLD 512
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)
*
*******************************************************************************/
+#error Please convert me to Documentation/DMA-mapping.txt
#include <linux/module.h>
Fix get_param for specific units.
*/
+#error Please convert me to Documentation/DMA-mapping.txt
+
#include <linux/module.h>
MODULE_AUTHOR ("3ware Inc.");
* 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
+#error Please convert me to Documentation/DMA-mapping.txt
+
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/signal.h>
#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>
*/
+#error Please convert me to Documentation/DMA-mapping.txt
/*
* --- Linux Version
#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");
}
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);
/*
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;
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));
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);
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;
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;
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) {
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;
}
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));
{
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 )
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;
{
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
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) {
#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]))
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) )
* 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>
#define ADDR32 (0)
+#error Please convert me to Documentation/DMA-mapping.txt
+
#include <linux/version.h>
#include <linux/module.h>
* 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
/* 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>
* phase: Service/parameter/return code special command
*/
+#error Please convert me to Documentation/DMA-mapping.txt
+
#include <linux/module.h>
#include <linux/version.h>
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 ();
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 ();
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 ();
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) {
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) {
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;
#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
#include <linux/version.h>
#endif
+#error Please convert me to Documentation/DMA-mapping.txt
+
#include <linux/module.h>
#include <stdarg.h>
* 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>
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 */
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;
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! */
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;
}
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 */
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) {
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--;
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
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;
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;
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;
}
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;
}
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;
}
*
****************************************************************************/
+#error Convert me to understand page+offset based scatterlists
+
//#define DEBUG 1
#include <linux/module.h>
- Initial Beta Release.
*****************************************************************************/
+#error Please convert me to Documentation/DMA-mapping.txt
#ifdef MODULE
#include <linux/module.h>
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];
*/
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)
*/
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) {
***********************************************************************/
/* $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)
{
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
#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
}
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
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;
}
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:
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));
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);
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);
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:
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
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 */
}
#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);
}
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;
#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;
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++) {
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);
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 */
;
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
tb = NULL;
break;
}
- tb->sg[segs].page = NULL;
tb->sg[segs].length = b_size;
got += b_size;
segs++;
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",
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--;
normalize_buffer(STbuffer);
return FALSE;
}
- STbuffer->sg[segs].page = NULL;
STbuffer->sg[segs].length = b_size;
STbuffer->sg_segs += 1;
got += b_size;
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;
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;
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;
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. */
} 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; /*???*/
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;
}
/* 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) {
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);
}
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));
#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);
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;
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);
}
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
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;
}
} 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;
}
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;
}
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 */
/* 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;
}
}
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;
}
/* 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 )
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 )
}
/* 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 )
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 )
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++;
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)
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;
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;
}
(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;
}
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;
}
// 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 = "
}
for (i=0; i<alloc_blocks; i++)
- kfree(sg[i].address);
+ kfree(page_address(sg[i].page)+sg[i].offset);
kfree(sg);
return 0;
}
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)
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;
}
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 */
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 {
#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",
insert_td_horizontal (s, s->int_chain[5], td);
mb();
- //uhci_show_queue(s->control_chain);
dbg("init_skel exit");
return 0;
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);
insert_qh (s, s->chain_end, qh, 0);
}
- //uhci_show_queue(s->bulk_chain);
//dbg("uhci_submit_bulk_urb: exit\n");
return 0;
}
#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>:
#include <asm/page.h>
struct scatterlist {
- /* This will disappear in 2.5.x */
- char *address;
-
- /* These two are only valid if ADDRESS member of this
- struct is NULL. */
struct page *page;
unsigned int offset;
#include <asm/types.h>
struct scatterlist {
- char *address; /* virtual address */
- struct page *page; /* Location for highmem page, if any */
- unsigned int offset; /* for highmem, page offset */
+ struct page *page; /* buffer page */
+ unsigned int offset; /* buffer offset */
dma_addr_t dma_address; /* dma address */
unsigned int length; /* length */
char *__address; /* for set_dma_addr */
{
if(can_use_virtual_dma == 2) {
if((unsigned int) addr >= (unsigned int) high_memory ||
- virt_to_bus(addr) >= 0x1000000 ||
+ isa_virt_to_bus(addr) >= 0x1000000 ||
_CROSS_64KB(addr, size, 0))
use_virtual_dma = 1;
else
doing_pdma = 0;
clear_dma_ff(FLOPPY_DMA);
set_dma_mode(FLOPPY_DMA,mode);
- set_dma_addr(FLOPPY_DMA,virt_to_bus(addr));
+ set_dma_addr(FLOPPY_DMA,isa_virt_to_bus(addr));
set_dma_count(FLOPPY_DMA,size);
enable_dma(FLOPPY_DMA);
return 0;
extern void iounmap(void *addr);
/*
- * IO bus memory addresses are also 1:1 with the physical address
+ * ISA I/O bus memory addresses are 1:1 with the physical address.
*/
-#define virt_to_bus virt_to_phys
-#define bus_to_virt phys_to_virt
-#define page_to_bus page_to_phys
+#define isa_virt_to_bus virt_to_phys
+#define isa_page_to_bus page_to_phys
+#define isa_bus_to_virt phys_to_virt
+
+/*
+ * However PCI ones are not necessarily 1:1 and therefore these interfaces
+ * are forbidden in portable PCI drivers.
+ */
+extern unsigned long virt_to_bus_not_defined_use_pci_map(volatile void *addr);
+#define virt_to_bus virt_to_bus_not_defined_use_pci_map
+extern unsigned long bus_to_virt_not_defined_use_pci_map(volatile void *addr);
+#define bus_to_virt bus_to_virt_not_defined_use_pci_map
/*
* readX/writeX() are used to access memory mapped devices. On some
if (direction == PCI_DMA_NONE)
BUG();
flush_write_buffers();
- return virt_to_bus(ptr);
+ return virt_to_phys(ptr);
}
/* Unmap a single streaming mode DMA translation. The dma_addr and size
if (direction == PCI_DMA_NONE)
BUG();
-
- /*
- * temporary 2.4 hack
- */
- for (i = 0; i < nents; i++ ) {
- if (sg[i].address && sg[i].page)
- BUG();
- else if (!sg[i].address && !sg[i].page)
- BUG();
-
- if (sg[i].address)
- sg[i].dma_address = virt_to_bus(sg[i].address);
- else
- sg[i].dma_address = page_to_bus(sg[i].page) + sg[i].offset;
- }
-
+
+ for (i = 0; i < nents; i++ ) {
+ if (!sg[i].page)
+ BUG();
+
+ sg[i].dma_address = page_to_phys(sg[i].page) + sg[i].offset;
+ }
+
flush_write_buffers();
return nents;
}
static __inline__ dma64_addr_t
pci_dac_page_to_dma(struct pci_dev *pdev, struct page *page, unsigned long offset, int direction)
{
- return ((dma64_addr_t) page_to_bus(page) +
+ return ((dma64_addr_t) page_to_phys(page) +
(dma64_addr_t) offset);
}
#define _I386_SCATTERLIST_H
struct scatterlist {
- char * address; /* Location data is to be transferred to, NULL for
- * highmem page */
- struct page * page; /* Location for highmem page, if any */
- unsigned int offset;/* for highmem, page offset */
-
- dma_addr_t dma_address;
- unsigned int length;
+ struct page *page;
+ unsigned int offset;
+ dma_addr_t dma_address;
+ unsigned int length;
};
#define ISA_DMA_THRESHOLD (0x00ffffff)
*/
struct scatterlist {
- /* This will disappear in 2.5.x: */
- char *address; /* location data is to be transferred to, NULL for highmem page */
char *orig_address; /* for use by swiotlb */
/* These two are only valid if ADDRESS member of this struct is NULL. */
#define _M68K_SCATTERLIST_H
struct scatterlist {
- char * address; /* Location data is to be transferred to */
+ struct page *page;
+ unsigned int offset;
unsigned int length;
unsigned long dvma_address;
};
#define __ASM_MIPS_SCATTERLIST_H
struct scatterlist {
- char * address; /* Location data is to be transferred to */
+ struct page *page;
+ unsigned int offset;
unsigned int length;
__u32 dvma_address;
#define __ASM_MIPS64_SCATTERLIST_H
struct scatterlist {
- char * address; /* Location data is to be transferred to */
+ struct page *page;
+ unsigned int offset;
unsigned int length;
__u32 dvma_address;
#define _ASM_PARISC_SCATTERLIST_H
struct scatterlist {
- char * address; /* Location data is to be transferred to */
+ struct page *page;
+ unsigned int offset;
unsigned int length;
/* an IOVA can be 64-bits on some PA-Risc platforms. */
* temporary 2.4 hack
*/
for (i = 0; i < nents; i++) {
- if (sg[i].address && sg[i].page)
- BUG();
- else if (!sg[i].address && !sg[i].page)
+ if (!sg[i].page)
BUG();
- if (sg[i].address)
- sg[i].dma_address = virt_to_bus(sg[i].address);
- else
- sg[i].dma_address = page_to_bus(sg[i].page) + sg[i].offset;
+ sg[i].dma_address = page_to_bus(sg[i].page) + sg[i].offset;
}
return nents;
#include <asm/dma.h>
struct scatterlist {
- char *address; /* Location data is to be transferred to,
- * or NULL for highmem page */
- struct page * page; /* Location for highmem page, if any */
- unsigned int offset; /* for highmem, page offset */
+ struct page * page;
+ unsigned int offset;
dma_addr_t dma_address; /* phys/bus dma address */
unsigned int length; /* length */
#define _ASMS390X_SCATTERLIST_H
struct scatterlist {
- char * address; /* Location data is to be transferred to */
+ struct page *page;
+ unsigned int offset;
unsigned int length;
};
#define _ASMS390X_SCATTERLIST_H
struct scatterlist {
- char * address; /* Location data is to be transferred to */
+ struct page *page;
+ unsigned int offset;
unsigned int length;
};
int i;
for (i=0; i<nents; i++)
- dma_cache_wback_inv(sg[i].address, sg[i].length);
+ dma_cache_wback_inv(page_address(sg[i].page) + sg[i].offset, sg[i].length);
#endif
if (direction == PCI_DMA_NONE)
BUG();
int i;
for (i=0; i<nelems; i++)
- dma_cache_wback_inv(sg[i].address, sg[i].length);
+ dma_cache_wback_inv(page_address(sg[i].page) + sg[i].offset, sg[i].length);
#endif
}
#define __ASM_SH_SCATTERLIST_H
struct scatterlist {
- char * address; /* Location data is to be transferred to, NULL for
- * highmem page */
struct page * page; /* Location for highmem page, if any */
unsigned int offset;/* for highmem, page offset */
dma_addr_t dma_address;
-/* $Id: scatterlist.h,v 1.7 2001/10/30 04:34:57 davem Exp $ */
+/* $Id: scatterlist.h,v 1.8 2001/12/17 07:05:15 davem Exp $ */
#ifndef _SPARC_SCATTERLIST_H
#define _SPARC_SCATTERLIST_H
#include <linux/types.h>
struct scatterlist {
- /* This will disappear in 2.5.x */
- char *address;
-
- /* These two are only valid if ADDRESS member of this
- * struct is NULL.
- */
struct page *page;
unsigned int offset;
-/* $Id: scatterlist.h,v 1.10 2001/10/09 02:24:35 davem Exp $ */
+/* $Id: scatterlist.h,v 1.11 2001/12/17 07:05:15 davem Exp $ */
#ifndef _SPARC64_SCATTERLIST_H
#define _SPARC64_SCATTERLIST_H
#include <asm/page.h>
struct scatterlist {
- /* This will disappear in 2.5.x */
- char *address;
+ struct page *page;
+ unsigned int offset;
- /* These two are only valid if ADDRESS member of this
- * struct is NULL.
- */
- struct page *page;
- unsigned int offset;
+ unsigned int length;
- unsigned int length;
-
- dma_addr_t dma_address;
- __u32 dma_length;
+ dma_addr_t dma_address;
+ __u32 dma_length;
};
#define sg_dma_address(sg) ((sg)->dma_address)
projects / linux / commitdiff