1 files changed, 44 insertions, 45 deletions

diff --git a/sound/sparc/dbri.c b/sound/sparc/dbri.c
index c534a2a849fa..c257ad8bdfbc 100644
--- a/sound/sparc/dbri.c
+++ b/sound/sparc/dbri.c
@@ -57,6 +57,7 @@
 #include <linux/delay.h>
 #include <linux/irq.h>
 #include <linux/io.h>
+#include <linux/dma-mapping.h>
 
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -66,7 +67,7 @@
 #include <sound/initval.h>
 
 #include <linux/of.h>
-#include <asm/sbus.h>
+#include <linux/of_device.h>
 #include <asm/atomic.h>
 
 MODULE_AUTHOR("Rudolf Koenig, Brent Baccala and Martin Habets");
@@ -297,7 +298,7 @@ struct dbri_streaminfo {
 /* This structure holds the information for both chips (DBRI & CS4215) */
 struct snd_dbri {
         int regs_size, irq;     /* Needed for unload */
-        struct sbus_dev *sdev;  /* SBUS device info */
+        struct of_device *op;   /* OF device info */
         spinlock_t lock;
 
         struct dbri_dma *dma;   /* Pointer to our DMA block */
@@ -2093,14 +2094,15 @@ static int snd_dbri_hw_params(struct snd_pcm_substream *substream,
          */
         if (info->dvma_buffer == 0) {
                 if (DBRI_STREAMNO(substream) == DBRI_PLAY)
-                        direction = SBUS_DMA_TODEVICE;
+                        direction = DMA_TO_DEVICE;
                 else
-                        direction = SBUS_DMA_FROMDEVICE;
+                        direction = DMA_FROM_DEVICE;
 
-                info->dvma_buffer = sbus_map_single(dbri->sdev,
-                                        runtime->dma_area,
-                                        params_buffer_bytes(hw_params),
-                                        direction);
+                info->dvma_buffer =
+                        dma_map_single(&dbri->op->dev,
+                                       runtime->dma_area,
+                                       params_buffer_bytes(hw_params),
+                                       direction);
         }
 
         direction = params_buffer_bytes(hw_params);
@@ -2121,12 +2123,12 @@ static int snd_dbri_hw_free(struct snd_pcm_substream *substream)
          */
         if (info->dvma_buffer) {
                 if (DBRI_STREAMNO(substream) == DBRI_PLAY)
-                        direction = SBUS_DMA_TODEVICE;
+                        direction = DMA_TO_DEVICE;
                 else
-                        direction = SBUS_DMA_FROMDEVICE;
+                        direction = DMA_FROM_DEVICE;
 
-                sbus_unmap_single(dbri->sdev, info->dvma_buffer,
-                                  substream->runtime->buffer_size, direction);
+                dma_unmap_single(&dbri->op->dev, info->dvma_buffer,
+                                 substream->runtime->buffer_size, direction);
                 info->dvma_buffer = 0;
         }
         if (info->pipe != -1) {
@@ -2519,31 +2521,32 @@ static void __devinit snd_dbri_proc(struct snd_card *card)
 static void snd_dbri_free(struct snd_dbri *dbri);
 
 static int __devinit snd_dbri_create(struct snd_card *card,
-                                  struct sbus_dev *sdev,
-                                  int irq, int dev)
+                                     struct of_device *op,
+                                     int irq, int dev)
 {
         struct snd_dbri *dbri = card->private_data;
         int err;
 
         spin_lock_init(&dbri->lock);
-        dbri->sdev = sdev;
+        dbri->op = op;
         dbri->irq = irq;
 
-        dbri->dma = sbus_alloc_consistent(sdev, sizeof(struct dbri_dma),
-                                          &dbri->dma_dvma);
+        dbri->dma = dma_alloc_coherent(&op->dev,
+                                       sizeof(struct dbri_dma),
+                                       &dbri->dma_dvma, GFP_ATOMIC);
         memset((void *)dbri->dma, 0, sizeof(struct dbri_dma));
 
         dprintk(D_GEN, "DMA Cmd Block 0x%p (0x%08x)\n",
                 dbri->dma, dbri->dma_dvma);
 
         /* Map the registers into memory. */
-        dbri->regs_size = sdev->reg_addrs[0].reg_size;
-        dbri->regs = sbus_ioremap(&sdev->resource[0], 0,
-                                  dbri->regs_size, "DBRI Registers");
+        dbri->regs_size = resource_size(&op->resource[0]);
+        dbri->regs = of_ioremap(&op->resource[0], 0,
+                                dbri->regs_size, "DBRI Registers");
         if (!dbri->regs) {
                 printk(KERN_ERR "DBRI: could not allocate registers\n");
-                sbus_free_consistent(sdev, sizeof(struct dbri_dma),
-                                     (void *)dbri->dma, dbri->dma_dvma);
+                dma_free_coherent(&op->dev, sizeof(struct dbri_dma),
+                                  (void *)dbri->dma, dbri->dma_dvma);
                 return -EIO;
         }
 
@@ -2551,9 +2554,9 @@ static int __devinit snd_dbri_create(struct snd_card *card,
                           "DBRI audio", dbri);
         if (err) {
                 printk(KERN_ERR "DBRI: Can't get irq %d\n", dbri->irq);
-                sbus_iounmap(dbri->regs, dbri->regs_size);
-                sbus_free_consistent(sdev, sizeof(struct dbri_dma),
-                                     (void *)dbri->dma, dbri->dma_dvma);
+                of_iounmap(&op->resource[0], dbri->regs, dbri->regs_size);
+                dma_free_coherent(&op->dev, sizeof(struct dbri_dma),
+                                  (void *)dbri->dma, dbri->dma_dvma);
                 return err;
         }
 
@@ -2577,27 +2580,23 @@ static void snd_dbri_free(struct snd_dbri *dbri)
                 free_irq(dbri->irq, dbri);
 
         if (dbri->regs)
-                sbus_iounmap(dbri->regs, dbri->regs_size);
+                of_iounmap(&dbri->op->resource[0], dbri->regs, dbri->regs_size);
 
         if (dbri->dma)
-                sbus_free_consistent(dbri->sdev, sizeof(struct dbri_dma),
-                                     (void *)dbri->dma, dbri->dma_dvma);
+                dma_free_coherent(&dbri->op->dev,
+                                  sizeof(struct dbri_dma),
+                                  (void *)dbri->dma, dbri->dma_dvma);
 }
 
-static int __devinit dbri_probe(struct of_device *of_dev,
-                                const struct of_device_id *match)
+static int __devinit dbri_probe(struct of_device *op, const struct of_device_id *match)
 {
-        struct sbus_dev *sdev = to_sbus_device(&of_dev->dev);
         struct snd_dbri *dbri;
-        int irq;
         struct resource *rp;
         struct snd_card *card;
         static int dev = 0;
+        int irq;
         int err;
 
-        dprintk(D_GEN, "DBRI: Found %s in SBUS slot %d\n",
-                sdev->prom_name, sdev->slot);
-
         if (dev >= SNDRV_CARDS)
                 return -ENODEV;
         if (!enable[dev]) {
@@ -2605,7 +2604,7 @@ static int __devinit dbri_probe(struct of_device *of_dev,
                 return -ENOENT;
         }
 
-        irq = sdev->irqs[0];
+        irq = op->irqs[0];
         if (irq <= 0) {
                 printk(KERN_ERR "DBRI-%d: No IRQ.\n", dev);
                 return -ENODEV;
@@ -2618,12 +2617,12 @@ static int __devinit dbri_probe(struct of_device *of_dev,
 
         strcpy(card->driver, "DBRI");
         strcpy(card->shortname, "Sun DBRI");
-        rp = &sdev->resource[0];
+        rp = &op->resource[0];
         sprintf(card->longname, "%s at 0x%02lx:0x%016Lx, irq %d",
                 card->shortname,
                 rp->flags & 0xffL, (unsigned long long)rp->start, irq);
 
-        err = snd_dbri_create(card, sdev, irq, dev);
+        err = snd_dbri_create(card, op, irq, dev);
         if (err < 0) {
                 snd_card_free(card);
                 return err;
@@ -2640,7 +2639,7 @@ static int __devinit dbri_probe(struct of_device *of_dev,
 
         /* /proc file handling */
         snd_dbri_proc(card);
-        dev_set_drvdata(&of_dev->dev, card);
+        dev_set_drvdata(&op->dev, card);
 
         err = snd_card_register(card);
         if (err < 0)
@@ -2648,7 +2647,7 @@ static int __devinit dbri_probe(struct of_device *of_dev,
 
         printk(KERN_INFO "audio%d at %p (irq %d) is DBRI(%c)+CS4215(%d)\n",
                dev, dbri->regs,
-               dbri->irq, sdev->prom_name[9], dbri->mm.version);
+               dbri->irq, op->node->name[9], dbri->mm.version);
         dev++;
 
         return 0;
@@ -2659,19 +2658,19 @@ _err:
         return err;
 }
 
-static int __devexit dbri_remove(struct of_device *dev)
+static int __devexit dbri_remove(struct of_device *op)
 {
-        struct snd_card *card = dev_get_drvdata(&dev->dev);
+        struct snd_card *card = dev_get_drvdata(&op->dev);
 
         snd_dbri_free(card->private_data);
         snd_card_free(card);
 
-        dev_set_drvdata(&dev->dev, NULL);
+        dev_set_drvdata(&op->dev, NULL);
 
         return 0;
 }
 
-static struct of_device_id dbri_match[] = {
+static const struct of_device_id dbri_match[] = {
         {
                 .name = "SUNW,DBRIe",
         },
@@ -2693,7 +2692,7 @@ static struct of_platform_driver dbri_sbus_driver = {
 /* Probe for the dbri chip and then attach the driver. */
 static int __init dbri_init(void)
 {
-        return of_register_driver(&dbri_sbus_driver, &sbus_bus_type);
+        return of_register_driver(&dbri_sbus_driver, &of_bus_type);
 }
 
 static void __exit dbri_exit(void)