sparc: Kill SBUS DVMA layer.

This thing was completely pointless.

Just find the OF device in the parent of drivers that want to program
this device, and map the DMA regs inside such drivers too.

This also moves the dummy claim_dma_lock() and release_dma_lock()
implementation to floppy_32.h, which makes it handle this issue
just like floppy_64.h does.

Signed-off-by: David S. Miller <davem@davemloft.net>

6 files changed, 99 insertions, 217 deletions

diff --git a/drivers/net/sunlance.c b/drivers/net/sunlance.c
index 4e994f87469e..24ffecb1ce23 100644
--- a/drivers/net/sunlance.c
+++ b/drivers/net/sunlance.c
@@ -248,7 +248,7 @@ struct lance_private {
         int             rx_new, tx_new;
         int             rx_old, tx_old;
 
-        struct sbus_dma *ledma; /* If set this points to ledma  */
+        struct of_device *ledma;        /* If set this points to ledma  */
         char            tpe;            /* cable-selection is TPE       */
         char            auto_select;    /* cable-selection by carrier   */
         char            burst_sizes;    /* ledma SBus burst sizes       */
@@ -1273,6 +1273,12 @@ static void lance_free_hwresources(struct lance_private *lp)
 {
         if (lp->lregs)
                 sbus_iounmap(lp->lregs, LANCE_REG_SIZE);
+        if (lp->dregs) {
+                struct of_device *ledma = lp->ledma;
+
+                of_iounmap(&ledma->resource[0], lp->dregs,
+                           resource_size(&ledma->resource[0]));
+        }
         if (lp->init_block_iomem) {
                 sbus_iounmap(lp->init_block_iomem,
                              sizeof(struct lance_init_block));
@@ -1309,7 +1315,7 @@ static const struct ethtool_ops sparc_lance_ethtool_ops = {
 };
 
 static int __devinit sparc_lance_probe_one(struct sbus_dev *sdev,
-                                           struct sbus_dma *ledma,
+                                           struct of_device *ledma,
                                            struct sbus_dev *lebuffer)
 {
         static unsigned version_printed;
@@ -1345,6 +1351,18 @@ static int __devinit sparc_lance_probe_one(struct sbus_dev *sdev,
                 goto fail;
         }
 
+        lp->ledma = ledma;
+        if (lp->ledma) {
+                lp->dregs = of_ioremap(&ledma->resource[0], 0,
+                                       resource_size(&ledma->resource[0]),
+                                       "ledma");
+                if (!lp->dregs) {
+                        printk(KERN_ERR "SunLance: Cannot map "
+                               "ledma registers.\n");
+                        goto fail;
+                }
+        }
+
         lp->sdev = sdev;
         if (lebuffer) {
                 /* sanity check */
@@ -1383,11 +1401,10 @@ static int __devinit sparc_lance_probe_one(struct sbus_dev *sdev,
                                                       LE_C3_BCON));
 
         lp->name = lancestr;
-        lp->ledma = ledma;
 
         lp->burst_sizes = 0;
         if (lp->ledma) {
-                struct device_node *ledma_dp = ledma->sdev->ofdev.node;
+                struct device_node *ledma_dp = ledma->node;
                 const char *prop;
                 unsigned int sbmask;
                 u32 csr;
@@ -1435,8 +1452,6 @@ no_link_test:
                         lp->tpe = 1;
                 }
 
-                lp->dregs = ledma->regs;
-
                 /* Reset ledma */
                 csr = sbus_readl(lp->dregs + DMA_CSR);
                 sbus_writel(csr | DMA_RST_ENET, lp->dregs + DMA_CSR);
@@ -1486,18 +1501,6 @@ fail:
         return -ENODEV;
 }
 
-/* On 4m, find the associated dma for the lance chip */
-static struct sbus_dma * __devinit find_ledma(struct sbus_dev *sdev)
-{
-        struct sbus_dma *p;
-
-        for_each_dvma(p) {
-                if (p->sdev == sdev)
-                        return p;
-        }
-        return NULL;
-}
-
 #ifdef CONFIG_SUN4
 
 #include <asm/sun4paddr.h>
@@ -1541,13 +1544,13 @@ static int __devinit sunlance_sbus_probe(struct of_device *dev, const struct of_
         int err;
 
         if (sdev->parent) {
-                struct of_device *parent = &sdev->parent->ofdev;
-
-                if (!strcmp(parent->node->name, "ledma")) {
-                        struct sbus_dma *ledma = find_ledma(to_sbus_device(&parent->dev));
+                struct device_node *parent_node = sdev->parent->ofdev.node;
+                struct of_device *parent;
 
-                        err = sparc_lance_probe_one(sdev, ledma, NULL);
-                } else if (!strcmp(parent->node->name, "lebuffer")) {
+                parent = of_find_device_by_node(parent_node);
+                if (parent && !strcmp(parent->node->name, "ledma")) {
+                        err = sparc_lance_probe_one(sdev, parent, NULL);
+                } else if (parent && !strcmp(parent->node->name, "lebuffer")) {
                         err = sparc_lance_probe_one(sdev, NULL, to_sbus_device(&parent->dev));
                 } else
                         err = sparc_lance_probe_one(sdev, NULL, NULL);
diff --git a/drivers/sbus/Makefile b/drivers/sbus/Makefile
index 7b1d24d95308..56f73318eba2 100644
--- a/drivers/sbus/Makefile
+++ b/drivers/sbus/Makefile
@@ -3,7 +3,7 @@
 #
 
 ifneq ($(ARCH),m68k)
-obj-y    := sbus.o dvma.o
+obj-y    := sbus.o
 endif
 
 obj-$(CONFIG_SBUSCHAR) += char/
diff --git a/drivers/sbus/dvma.c b/drivers/sbus/dvma.c
deleted file mode 100644
index ab0d2de3324c..000000000000
--- a/drivers/sbus/dvma.c
+++ /dev/null
@@ -1,136 +0,0 @@
-/* dvma.c:  Routines that are used to access DMA on the Sparc SBus.
- *
- * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
- */
-
-#include <linux/string.h>
-#include <linux/kernel.h>
-#include <linux/slab.h>
-#include <linux/init.h>
-#include <linux/delay.h>
-
-#include <asm/oplib.h>
-#include <asm/io.h>
-#include <asm/dma.h>
-#include <asm/sbus.h>
-
-struct sbus_dma *dma_chain;
-
-static void __init init_one_dvma(struct sbus_dma *dma, int num_dma)
-{
-        printk("dma%d: ", num_dma);
-        
-        dma->next = NULL;
-        dma->running = 0;      /* No transfers going on as of yet */
-        dma->allocated = 0;    /* No one has allocated us yet */
-        switch(sbus_readl(dma->regs + DMA_CSR)&DMA_DEVICE_ID) {
-        case DMA_VERS0:
-                dma->revision = dvmarev0;
-                printk("Revision 0 ");
-                break;
-        case DMA_ESCV1:
-                dma->revision = dvmaesc1;
-                printk("ESC Revision 1 ");
-                break;
-        case DMA_VERS1:
-                dma->revision = dvmarev1;
-                printk("Revision 1 ");
-                break;
-        case DMA_VERS2:
-                dma->revision = dvmarev2;
-                printk("Revision 2 ");
-                break;
-        case DMA_VERHME:
-                dma->revision = dvmahme;
-                printk("HME DVMA gate array ");
-                break;
-        case DMA_VERSPLUS:
-                dma->revision = dvmarevplus;
-                printk("Revision 1 PLUS ");
-                break;
-        default:
-                printk("unknown dma version %08x",
-                       sbus_readl(dma->regs + DMA_CSR) & DMA_DEVICE_ID);
-                dma->allocated = 1;
-                break;
-        }
-        printk("\n");
-}
-
-/* Probe this SBus DMA module(s) */
-void __init dvma_init(struct sbus_bus *sbus)
-{
-        struct sbus_dev *this_dev;
-        struct sbus_dma *dma;
-        struct sbus_dma *dchain;
-        static int num_dma = 0;
-
-        for_each_sbusdev(this_dev, sbus) {
-                char *name = this_dev->prom_name;
-                int hme = 0;
-
-                if(!strcmp(name, "SUNW,fas"))
-                        hme = 1;
-                else if(strcmp(name, "dma") &&
-                        strcmp(name, "ledma") &&
-                        strcmp(name, "espdma"))
-                        continue;
-
-                /* Found one... */
-                dma = kmalloc(sizeof(struct sbus_dma), GFP_ATOMIC);
-
-                dma->sdev = this_dev;
-
-                /* Put at end of dma chain */
-                dchain = dma_chain;
-                if(dchain) {
-                        while(dchain->next)
-                                dchain = dchain->next;
-                        dchain->next = dma;
-                } else {
-                        /* We're the first in line */
-                        dma_chain = dma;
-                }
-
-                dma->regs = sbus_ioremap(&dma->sdev->resource[0], 0,
-                                         dma->sdev->resource[0].end - dma->sdev->resource[0].start + 1,
-                                         "dma");
-
-                dma->node = dma->sdev->prom_node;
-                
-                init_one_dvma(dma, num_dma++);
-        }
-}
-
-#ifdef CONFIG_SUN4
-
-#include <asm/sun4paddr.h>
-
-void __init sun4_dvma_init(void)
-{
-        struct sbus_dma *dma;
-        struct resource r;
-
-        if(sun4_dma_physaddr) {
-                dma = kmalloc(sizeof(struct sbus_dma), GFP_ATOMIC);
-
-                /* No SBUS */
-                dma->sdev = NULL;
-
-                /* Only one DMA device */
-                dma_chain = dma;
-
-                memset(&r, 0, sizeof(r));
-                r.start = sun4_dma_physaddr;
-                dma->regs = sbus_ioremap(&r, 0, PAGE_SIZE, "dma");
-
-                /* No prom node */
-                dma->node = 0x0;
-
-                init_one_dvma(dma, 0);
-        } else {
-                dma_chain = NULL;
-        }
-}
-
-#endif
diff --git a/drivers/sbus/sbus.c b/drivers/sbus/sbus.c
index 53e5e7bf545c..69491625d869 100644
--- a/drivers/sbus/sbus.c
+++ b/drivers/sbus/sbus.c
@@ -285,8 +285,6 @@ static void __init build_one_sbus(struct device_node *dp, int num_sbus)
         }
 
         sbus_fixup_all_regs(sbus->devices);
-
-        dvma_init(sbus);
 }
 
 static int __init sbus_init(void)
diff --git a/drivers/scsi/esp_scsi.h b/drivers/scsi/esp_scsi.h
index bb43a1388188..28e22acf87ea 100644
--- a/drivers/scsi/esp_scsi.h
+++ b/drivers/scsi/esp_scsi.h
@@ -521,7 +521,8 @@ struct esp {
 
         struct completion       *eh_reset;
 
-        struct sbus_dma         *dma;
+        void                    *dma;
+        int                     dmarev;
 };
 
 /* A front-end driver for the ESP chip should do the following in
diff --git a/drivers/scsi/sun_esp.c b/drivers/scsi/sun_esp.c
index f9cf70151366..d110b94f111e 100644
--- a/drivers/scsi/sun_esp.c
+++ b/drivers/scsi/sun_esp.c
@@ -1,6 +1,6 @@
 /* sun_esp.c: ESP front-end for Sparc SBUS systems.
  *
- * Copyright (C) 2007 David S. Miller (davem@davemloft.net)
+ * Copyright (C) 2007, 2008 David S. Miller (davem@davemloft.net)
  */
 
 #include <linux/kernel.h>
@@ -30,39 +30,48 @@
 #define dma_write32(VAL, REG) \
         sbus_writel((VAL), esp->dma_regs + (REG))
 
-static int __devinit esp_sbus_find_dma(struct esp *esp, struct sbus_dev *dma_sdev)
-{
-        struct sbus_dev *sdev = esp->dev;
-        struct sbus_dma *dma;
+/* DVMA chip revisions */
+enum dvma_rev {
+        dvmarev0,
+        dvmaesc1,
+        dvmarev1,
+        dvmarev2,
+        dvmarev3,
+        dvmarevplus,
+        dvmahme
+};
 
-        if (dma_sdev != NULL) {
-                for_each_dvma(dma) {
-                        if (dma->sdev == dma_sdev)
-                                break;
-                }
-        } else {
-                for_each_dvma(dma) {
-                        if (dma->sdev == NULL)
-                                break;
+static int __devinit esp_sbus_setup_dma(struct esp *esp,
+                                        struct of_device *dma_of)
+{
+        esp->dma = dma_of;
 
-                        /* If bus + slot are the same and it has the
-                         * correct OBP name, it's ours.
-                         */
-                        if (sdev->bus == dma->sdev->bus &&
-                            sdev->slot == dma->sdev->slot &&
-                            (!strcmp(dma->sdev->prom_name, "dma") ||
-                             !strcmp(dma->sdev->prom_name, "espdma")))
-                                break;
-                }
-        }
+        esp->dma_regs = of_ioremap(&dma_of->resource[0], 0,
+                                   resource_size(&dma_of->resource[0]),
+                                   "espdma");
+        if (!esp->dma_regs)
+                return -ENOMEM;
 
-        if (dma == NULL) {
-                printk(KERN_ERR PFX "[%s] Cannot find dma.\n",
-                       sdev->ofdev.node->full_name);
-                return -ENODEV;
+        switch (dma_read32(DMA_CSR) & DMA_DEVICE_ID) {
+        case DMA_VERS0:
+                esp->dmarev = dvmarev0;
+                break;
+        case DMA_ESCV1:
+                esp->dmarev = dvmaesc1;
+                break;
+        case DMA_VERS1:
+                esp->dmarev = dvmarev1;
+                break;
+        case DMA_VERS2:
+                esp->dmarev = dvmarev2;
+                break;
+        case DMA_VERHME:
+                esp->dmarev = dvmahme;
+                break;
+        case DMA_VERSPLUS:
+                esp->dmarev = dvmarevplus;
+                break;
         }
-        esp->dma = dma;
-        esp->dma_regs = dma->regs;
 
         return 0;
 
@@ -165,19 +174,18 @@ static void __devinit esp_get_clock_params(struct esp *esp)
         esp->cfreq = fmhz;
 }
 
-static void __devinit esp_get_bursts(struct esp *esp, struct sbus_dev *dma)
+static void __devinit esp_get_bursts(struct esp *esp, struct of_device *dma_of)
 {
+        struct device_node *dma_dp = dma_of->node;
         struct sbus_dev *sdev = esp->dev;
-        struct device_node *dp = sdev->ofdev.node;
-        u8 bursts;
+        struct device_node *dp;
+        u8 bursts, val;
 
+        dp = sdev->ofdev.node;
         bursts = of_getintprop_default(dp, "burst-sizes", 0xff);
-        if (dma) {
-                struct device_node *dma_dp = dma->ofdev.node;
-                u8 val = of_getintprop_default(dma_dp, "burst-sizes", 0xff);
-                if (val != 0xff)
-                        bursts &= val;
-        }
+        val = of_getintprop_default(dma_dp, "burst-sizes", 0xff);
+        if (val != 0xff)
+                bursts &= val;
 
         if (sdev->bus) {
                 u8 val = of_getintprop_default(sdev->bus->ofdev.node,
@@ -194,7 +202,7 @@ static void __devinit esp_get_bursts(struct esp *esp, struct sbus_dev *dma)
         esp->bursts = bursts;
 }
 
-static void __devinit esp_sbus_get_props(struct esp *esp, struct sbus_dev *espdma)
+static void __devinit esp_sbus_get_props(struct esp *esp, struct of_device *espdma)
 {
         esp_get_scsi_id(esp);
         esp_get_differential(esp);
@@ -259,12 +267,12 @@ static void sbus_esp_reset_dma(struct esp *esp)
                 can_do_burst64 = (esp->bursts & DMA_BURST64) != 0;
 
         /* Put the DVMA into a known state. */
-        if (esp->dma->revision != dvmahme) {
+        if (esp->dmarev != dvmahme) {
                 val = dma_read32(DMA_CSR);
                 dma_write32(val | DMA_RST_SCSI, DMA_CSR);
                 dma_write32(val & ~DMA_RST_SCSI, DMA_CSR);
         }
-        switch (esp->dma->revision) {
+        switch (esp->dmarev) {
         case dvmahme:
                 dma_write32(DMA_RESET_FAS366, DMA_CSR);
                 dma_write32(DMA_RST_SCSI, DMA_CSR);
@@ -346,14 +354,14 @@ static void sbus_esp_dma_drain(struct esp *esp)
         u32 csr;
         int lim;
 
-        if (esp->dma->revision == dvmahme)
+        if (esp->dmarev == dvmahme)
                 return;
 
         csr = dma_read32(DMA_CSR);
         if (!(csr & DMA_FIFO_ISDRAIN))
                 return;
 
-        if (esp->dma->revision != dvmarev3 && esp->dma->revision != dvmaesc1)
+        if (esp->dmarev != dvmarev3 && esp->dmarev != dvmaesc1)
                 dma_write32(csr | DMA_FIFO_STDRAIN, DMA_CSR);
 
         lim = 1000;
@@ -369,7 +377,7 @@ static void sbus_esp_dma_drain(struct esp *esp)
 
 static void sbus_esp_dma_invalidate(struct esp *esp)
 {
-        if (esp->dma->revision == dvmahme) {
+        if (esp->dmarev == dvmahme) {
                 dma_write32(DMA_RST_SCSI, DMA_CSR);
 
                 esp->prev_hme_dmacsr = ((esp->prev_hme_dmacsr |
@@ -440,7 +448,7 @@ static void sbus_esp_send_dma_cmd(struct esp *esp, u32 addr, u32 esp_count,
                 else
                         csr &= ~DMA_ST_WRITE;
                 dma_write32(csr, DMA_CSR);
-                if (esp->dma->revision == dvmaesc1) {
+                if (esp->dmarev == dvmaesc1) {
                         u32 end = PAGE_ALIGN(addr + dma_count + 16U);
                         dma_write32(end - addr, DMA_COUNT);
                 }
@@ -478,7 +486,7 @@ static const struct esp_driver_ops sbus_esp_ops = {
 
 static int __devinit esp_sbus_probe_one(struct device *dev,
                                         struct sbus_dev *esp_dev,
-                                        struct sbus_dev *espdma,
+                                        struct of_device *espdma,
                                         struct sbus_bus *sbus,
                                         int hme)
 {
@@ -503,7 +511,7 @@ static int __devinit esp_sbus_probe_one(struct device *dev,
         if (hme)
                 esp->flags |= ESP_FLAG_WIDE_CAPABLE;
 
-        err = esp_sbus_find_dma(esp, espdma);
+        err = esp_sbus_setup_dma(esp, espdma);
         if (err < 0)
                 goto fail_unlink;
 
@@ -525,7 +533,7 @@ static int __devinit esp_sbus_probe_one(struct device *dev,
          * come up with the reset bit set, so make sure that
          * is clear first.
          */
-        if (esp->dma->revision == dvmaesc1) {
+        if (esp->dmarev == dvmaesc1) {
                 u32 val = dma_read32(DMA_CSR);
 
                 dma_write32(val & ~DMA_RST_SCSI, DMA_CSR);
@@ -556,26 +564,32 @@ fail:
 static int __devinit esp_sbus_probe(struct of_device *dev, const struct of_device_id *match)
 {
         struct sbus_dev *sdev = to_sbus_device(&dev->dev);
+        struct device_node *dma_node = NULL;
         struct device_node *dp = dev->node;
-        struct sbus_dev *dma_sdev = NULL;
+        struct of_device *dma_of = NULL;
         int hme = 0;
 
         if (dp->parent &&
             (!strcmp(dp->parent->name, "espdma") ||
              !strcmp(dp->parent->name, "dma")))
-                dma_sdev = sdev->parent;
+                dma_node = dp->parent;
         else if (!strcmp(dp->name, "SUNW,fas")) {
-                dma_sdev = sdev;
+                dma_node = sdev->ofdev.node;
                 hme = 1;
         }
+        if (dma_node)
+                dma_of = of_find_device_by_node(dma_node);
+        if (!dma_of)
+                return -ENODEV;
 
-        return esp_sbus_probe_one(&dev->dev, sdev, dma_sdev,
+        return esp_sbus_probe_one(&dev->dev, sdev, dma_of,
                                   sdev->bus, hme);
 }
 
 static int __devexit esp_sbus_remove(struct of_device *dev)
 {
         struct esp *esp = dev_get_drvdata(&dev->dev);
+        struct of_device *dma_of = esp->dma;
         unsigned int irq = esp->host->irq;
         u32 val;
 
@@ -590,6 +604,8 @@ static int __devexit esp_sbus_remove(struct of_device *dev)
                              esp->command_block,
                              esp->command_block_dma);
         sbus_iounmap(esp->regs, SBUS_ESP_REG_SIZE);
+        of_iounmap(&dma_of->resource[0], esp->dma_regs,
+                   resource_size(&dma_of->resource[0]));
 
         scsi_host_put(esp->host);