*/
 #include <linux/ioport.h>
 #include <linux/init.h>
-#include <linux/pci.h>
+#include <linux/dma-mapping.h>
 
 #include <asm/dma.h>
 #include <asm/io.h>
 {
        if (dma->invalid) {
                unsigned long address, length;
-               unsigned int mode, direction;
+               unsigned int mode;
+               enum dma_data_direction direction;
 
                mode = channel & 3;
                switch (dma->dma_mode & DMA_MODE_MASK) {
                case DMA_MODE_READ:
                        mode |= ISA_DMA_MODE_READ;
-                       direction = PCI_DMA_FROMDEVICE;
+                       direction = DMA_FROM_DEVICE;
                        break;
 
                case DMA_MODE_WRITE:
                        mode |= ISA_DMA_MODE_WRITE;
-                       direction = PCI_DMA_TODEVICE;
+                       direction = DMA_TO_DEVICE;
                        break;
 
                case DMA_MODE_CASCADE:
                        mode |= ISA_DMA_MODE_CASCADE;
-                       direction = PCI_DMA_BIDIRECTIONAL;
+                       direction = DMA_BIDIRECTIONAL;
                        break;
 
                default:
-                       direction = PCI_DMA_NONE;
+                       direction = DMA_NONE;
                        break;
                }
 
-               if (!dma->using_sg) {
+               if (!dma->sg) {
                        /*
                         * Cope with ISA-style drivers which expect cache
                         * coherence.
                         */
-                       dma->buf.dma_address = pci_map_single(NULL,
-                               dma->buf.__address, dma->buf.length,
+                       dma->sg = &dma->buf;
+                       dma->sgcount = 1;
+                       dma->buf.length = dma->count;
+                       dma->buf.dma_address = dma_map_single(NULL,
+                               dma->addr, dma->count,
                                direction);
                }
 
 
 
        dma->sg = sg;
        dma->sgcount = nr_sg;
-       dma->using_sg = 1;
        dma->invalid = 1;
 }
 
                printk(KERN_ERR "dma%d: altering DMA address while "
                       "DMA active\n", channel);
 
-       dma->sg = &dma->buf;
-       dma->sgcount = 1;
-       dma->buf.__address = addr;
-       dma->using_sg = 0;
+       dma->sg = NULL;
+       dma->addr = addr;
        dma->invalid = 1;
 }
 
                printk(KERN_ERR "dma%d: altering DMA count while "
                       "DMA active\n", channel);
 
-       dma->sg = &dma->buf;
-       dma->sgcount = 1;
-       dma->buf.length = count;
-       dma->using_sg = 0;
+       dma->sg = NULL;
+       dma->count = count;
        dma->invalid = 1;
 }
 
 
 #include <linux/mman.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
-#include <linux/pci.h>
+#include <linux/dma-mapping.h>
 
 #include <asm/page.h>
 #include <asm/dma.h>
                 * Cope with ISA-style drivers which expect cache
                 * coherence.
                 */
-               if (!dma->using_sg) {
-                       dma->buf.dma_address = pci_map_single(NULL,
-                               dma->buf.__address, dma->buf.length,
+               if (!dma->sg) {
+                       dma->sg = &dma->buf;
+                       dma->sgcount = 1;
+                       dma->buf.length = dma->count;
+                       dma->buf.dma_address = dma_map_single(NULL,
+                               dma->addr, dma->count,
                                dma->dma_mode == DMA_MODE_READ ?
-                               PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE);
+                               DMA_FROM_DEVICE : DMA_TO_DEVICE);
                }
 
                iomd_writeb(DMA_CR_C, dma_base + CR);
        unsigned int fiqhandler_length;
        struct pt_regs regs;
 
-       if (dma->using_sg)
+       if (dma->sg)
                BUG();
 
        if (dma->dma_mode == DMA_MODE_READ) {
                fiqhandler_length = &floppy_fiqout_end - &floppy_fiqout_start;
        }
 
-       regs.ARM_r9  = dma->buf.length;
-       regs.ARM_r10 = (unsigned long)dma->buf.__address;
+       regs.ARM_r9  = dma->count;
+       regs.ARM_r10 = (unsigned long)dma->addr;
        regs.ARM_fp  = (unsigned long)FLOPPYDMA_BASE;
 
        if (claim_fiq(&fh)) {
 
 };
 
 struct dma_struct {
+       void            *addr;          /* single DMA address           */
+       unsigned long   count;          /* single DMA size              */
        struct scatterlist buf;         /* single DMA                   */
        int             sgcount;        /* number of DMA SG             */
        struct scatterlist *sg;         /* DMA Scatter-Gather List      */
 
        unsigned int    active:1;       /* Transfer active              */
        unsigned int    invalid:1;      /* Address/Count changed        */
-       unsigned int    using_sg:1;     /* using scatter list?          */
+
        dmamode_t       dma_mode;       /* DMA mode                     */
        int             speed;          /* DMA speed                    */
 
 
        unsigned int    offset;         /* buffer offset                 */
        dma_addr_t      dma_address;    /* dma address                   */
        unsigned int    length;         /* length                        */
-       char            *__address;     /* for set_dma_addr              */
 };
 
 /*