sparc: Convert all SBUS drivers to dma_*() interfaces.

And all the SBUS dma interfaces are deleted.

A private implementation remains inside of the 32-bit sparc port which
exists only for the sake of the implementation of dma_*().

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

1 files changed, 35 insertions, 33 deletions

diff --git a/drivers/net/sunbmac.c b/drivers/net/sunbmac.c
index b92218c2f76c..8fe4c49b0623 100644
--- a/drivers/net/sunbmac.c
+++ b/drivers/net/sunbmac.c
@@ -23,6 +23,7 @@
 #include <linux/etherdevice.h>
 #include <linux/skbuff.h>
 #include <linux/bitops.h>
+#include <linux/dma-mapping.h>
 
 #include <asm/auxio.h>
 #include <asm/byteorder.h>
@@ -239,9 +240,10 @@ static void bigmac_init_rings(struct bigmac *bp, int from_irq)
                 skb_reserve(skb, 34);
 
                 bb->be_rxd[i].rx_addr =
-                        sbus_map_single(&bp->bigmac_sdev->ofdev.dev, skb->data,
-                                        RX_BUF_ALLOC_SIZE - 34,
-                                        SBUS_DMA_FROMDEVICE);
+                        dma_map_single(&bp->bigmac_sdev->ofdev.dev,
+                                       skb->data,
+                                       RX_BUF_ALLOC_SIZE - 34,
+                                       DMA_FROM_DEVICE);
                 bb->be_rxd[i].rx_flags =
                         (RXD_OWN | ((RX_BUF_ALLOC_SIZE - 34) & RXD_LENGTH));
         }
@@ -776,9 +778,9 @@ static void bigmac_tx(struct bigmac *bp)
                 skb = bp->tx_skbs[elem];
                 bp->enet_stats.tx_packets++;
                 bp->enet_stats.tx_bytes += skb->len;
-                sbus_unmap_single(&bp->bigmac_sdev->ofdev.dev,
-                                  this->tx_addr, skb->len,
-                                  SBUS_DMA_TODEVICE);
+                dma_unmap_single(&bp->bigmac_sdev->ofdev.dev,
+                                 this->tx_addr, skb->len,
+                                 DMA_TO_DEVICE);
 
                 DTX(("skb(%p) ", skb));
                 bp->tx_skbs[elem] = NULL;
@@ -831,19 +833,19 @@ static void bigmac_rx(struct bigmac *bp)
                                 drops++;
                                 goto drop_it;
                         }
-                        sbus_unmap_single(&bp->bigmac_sdev->ofdev.dev,
-                                          this->rx_addr,
-                                          RX_BUF_ALLOC_SIZE - 34,
-                                          SBUS_DMA_FROMDEVICE);
+                        dma_unmap_single(&bp->bigmac_sdev->ofdev.dev,
+                                         this->rx_addr,
+                                         RX_BUF_ALLOC_SIZE - 34,
+                                         DMA_FROM_DEVICE);
                         bp->rx_skbs[elem] = new_skb;
                         new_skb->dev = bp->dev;
                         skb_put(new_skb, ETH_FRAME_LEN);
                         skb_reserve(new_skb, 34);
                         this->rx_addr =
-                                sbus_map_single(&bp->bigmac_sdev->ofdev.dev,
-                                                new_skb->data,
-                                                RX_BUF_ALLOC_SIZE - 34,
-                                                SBUS_DMA_FROMDEVICE);
+                                dma_map_single(&bp->bigmac_sdev->ofdev.dev,
+                                               new_skb->data,
+                                               RX_BUF_ALLOC_SIZE - 34,
+                                               DMA_FROM_DEVICE);
                         this->rx_flags =
                                 (RXD_OWN | ((RX_BUF_ALLOC_SIZE - 34) & RXD_LENGTH));
 
@@ -858,13 +860,13 @@ static void bigmac_rx(struct bigmac *bp)
                         }
                         skb_reserve(copy_skb, 2);
                         skb_put(copy_skb, len);
-                        sbus_dma_sync_single_for_cpu(&bp->bigmac_sdev->ofdev.dev,
-                                                     this->rx_addr, len,
-                                                     SBUS_DMA_FROMDEVICE);
+                        dma_sync_single_for_cpu(&bp->bigmac_sdev->ofdev.dev,
+                                                this->rx_addr, len,
+                                                DMA_FROM_DEVICE);
                         skb_copy_to_linear_data(copy_skb, (unsigned char *)skb->data, len);
-                        sbus_dma_sync_single_for_device(&bp->bigmac_sdev->ofdev.dev,
-                                                        this->rx_addr, len,
-                                                        SBUS_DMA_FROMDEVICE);
+                        dma_sync_single_for_device(&bp->bigmac_sdev->ofdev.dev,
+                                                   this->rx_addr, len,
+                                                   DMA_FROM_DEVICE);
 
                         /* Reuse original ring buffer. */
                         this->rx_flags =
@@ -960,8 +962,8 @@ static int bigmac_start_xmit(struct sk_buff *skb, struct net_device *dev)
         u32 mapping;
 
         len = skb->len;
-        mapping = sbus_map_single(&bp->bigmac_sdev->ofdev.dev, skb->data,
-                                  len, SBUS_DMA_TODEVICE);
+        mapping = dma_map_single(&bp->bigmac_sdev->ofdev.dev, skb->data,
+                                 len, DMA_TO_DEVICE);
 
         /* Avoid a race... */
         spin_lock_irq(&bp->lock);
@@ -1185,9 +1187,9 @@ static int __devinit bigmac_ether_init(struct sbus_dev *qec_sdev)
         bigmac_stop(bp);
 
         /* Allocate transmit/receive descriptor DVMA block. */
-        bp->bmac_block = sbus_alloc_consistent(&bp->bigmac_sdev->ofdev.dev,
-                                               PAGE_SIZE,
-                                               &bp->bblock_dvma);
+        bp->bmac_block = dma_alloc_coherent(&bp->bigmac_sdev->ofdev.dev,
+                                            PAGE_SIZE,
+                                            &bp->bblock_dvma, GFP_ATOMIC);
         if (bp->bmac_block == NULL || bp->bblock_dvma == 0) {
                 printk(KERN_ERR "BIGMAC: Cannot allocate consistent DMA.\n");
                 goto fail_and_cleanup;
@@ -1247,10 +1249,10 @@ fail_and_cleanup:
                 sbus_iounmap(bp->tregs, TCVR_REG_SIZE);
 
         if (bp->bmac_block)
-                sbus_free_consistent(&bp->bigmac_sdev->ofdev.dev,
-                                     PAGE_SIZE,
-                                     bp->bmac_block,
-                                     bp->bblock_dvma);
+                dma_free_coherent(&bp->bigmac_sdev->ofdev.dev,
+                                  PAGE_SIZE,
+                                  bp->bmac_block,
+                                  bp->bblock_dvma);
 
         /* This also frees the co-located 'dev->priv' */
         free_netdev(dev);
@@ -1282,10 +1284,10 @@ static int __devexit bigmac_sbus_remove(struct of_device *dev)
         sbus_iounmap(bp->creg, CREG_REG_SIZE);
         sbus_iounmap(bp->bregs, BMAC_REG_SIZE);
         sbus_iounmap(bp->tregs, TCVR_REG_SIZE);
-        sbus_free_consistent(&bp->bigmac_sdev->ofdev.dev,
-                             PAGE_SIZE,
-                             bp->bmac_block,
-                             bp->bblock_dvma);
+        dma_free_coherent(&bp->bigmac_sdev->ofdev.dev,
+                          PAGE_SIZE,
+                          bp->bmac_block,
+                          bp->bblock_dvma);
 
         free_netdev(net_dev);