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

[deliverable/linux.git] / drivers / net / myri_sbus.c

diff --git a/drivers/net/myri_sbus.c b/drivers/net/myri_sbus.c
index c17462159d9d1c9ddd949cbe997928d484fa0679..858880b619ced8d4853118d5cf6f5eef710c1033 100644 (file)
--- a/drivers/net/myri_sbus.c
+++ b/drivers/net/myri_sbus.c
@@ -22,6 +22,7 @@ static char version[] =
 #include <linux/etherdevice.h>
 #include <linux/skbuff.h>
 #include <linux/bitops.h>
+#include <linux/dma-mapping.h>
 
 #include <net/dst.h>
 #include <net/arp.h>
@@ -243,8 +244,8 @@ static void myri_clean_rings(struct myri_eth *mp)
                        u32 dma_addr;
 
                        dma_addr = sbus_readl(&rxd->myri_scatters[0].addr);
-                       sbus_unmap_single(&mp->myri_sdev->ofdev.dev, dma_addr,
-                                         RX_ALLOC_SIZE, SBUS_DMA_FROMDEVICE);
+                       dma_unmap_single(&mp->myri_sdev->ofdev.dev, dma_addr,
+                                        RX_ALLOC_SIZE, DMA_FROM_DEVICE);
                        dev_kfree_skb(mp->rx_skbs[i]);
                        mp->rx_skbs[i] = NULL;
                }
@@ -260,9 +261,9 @@ static void myri_clean_rings(struct myri_eth *mp)
                        u32 dma_addr;
 
                        dma_addr = sbus_readl(&txd->myri_gathers[0].addr);
-                       sbus_unmap_single(&mp->myri_sdev->ofdev.dev, dma_addr,
-                                         (skb->len + 3) & ~3,
-                                         SBUS_DMA_TODEVICE);
+                       dma_unmap_single(&mp->myri_sdev->ofdev.dev, dma_addr,
+                                        (skb->len + 3) & ~3,
+                                        DMA_TO_DEVICE);
                        dev_kfree_skb(mp->tx_skbs[i]);
                        mp->tx_skbs[i] = NULL;
                }
@@ -291,9 +292,9 @@ static void myri_init_rings(struct myri_eth *mp, int from_irq)
                skb->dev = dev;
                skb_put(skb, RX_ALLOC_SIZE);
 
-               dma_addr = sbus_map_single(&mp->myri_sdev->ofdev.dev,
-                                          skb->data, RX_ALLOC_SIZE,
-                                          SBUS_DMA_FROMDEVICE);
+               dma_addr = dma_map_single(&mp->myri_sdev->ofdev.dev,
+                                         skb->data, RX_ALLOC_SIZE,
+                                         DMA_FROM_DEVICE);
                sbus_writel(dma_addr, &rxd[i].myri_scatters[0].addr);
                sbus_writel(RX_ALLOC_SIZE, &rxd[i].myri_scatters[0].len);
                sbus_writel(i, &rxd[i].ctx);
@@ -349,8 +350,8 @@ static void myri_tx(struct myri_eth *mp, struct net_device *dev)
 
                DTX(("SKB[%d] ", entry));
                dma_addr = sbus_readl(&sq->myri_txd[entry].myri_gathers[0].addr);
-               sbus_unmap_single(&mp->myri_sdev->ofdev.dev, dma_addr,
-                                 skb->len, SBUS_DMA_TODEVICE);
+               dma_unmap_single(&mp->myri_sdev->ofdev.dev, dma_addr,
+                                skb->len, DMA_TO_DEVICE);
                dev_kfree_skb(skb);
                mp->tx_skbs[entry] = NULL;
                dev->stats.tx_packets++;
@@ -429,9 +430,9 @@ static void myri_rx(struct myri_eth *mp, struct net_device *dev)
 
                /* Check for errors. */
                DRX(("rxd[%d]: %p len[%d] csum[%08x] ", entry, rxd, len, csum));
-               sbus_dma_sync_single_for_cpu(&mp->myri_sdev->ofdev.dev,
-                                            sbus_readl(&rxd->myri_scatters[0].addr),
-                                            RX_ALLOC_SIZE, SBUS_DMA_FROMDEVICE);
+               dma_sync_single_for_cpu(&mp->myri_sdev->ofdev.dev,
+                                       sbus_readl(&rxd->myri_scatters[0].addr),
+                                       RX_ALLOC_SIZE, DMA_FROM_DEVICE);
                if (len < (ETH_HLEN + MYRI_PAD_LEN) || (skb->data[0] != MYRI_PAD_LEN)) {
                        DRX(("ERROR["));
                        dev->stats.rx_errors++;
@@ -448,10 +449,10 @@ static void myri_rx(struct myri_eth *mp, struct net_device *dev)
                        drops++;
                        DRX(("DROP "));
                        dev->stats.rx_dropped++;
-                       sbus_dma_sync_single_for_device(&mp->myri_sdev->ofdev.dev,
-                                                       sbus_readl(&rxd->myri_scatters[0].addr),
-                                                       RX_ALLOC_SIZE,
-                                                       SBUS_DMA_FROMDEVICE);
+                       dma_sync_single_for_device(&mp->myri_sdev->ofdev.dev,
+                                                  sbus_readl(&rxd->myri_scatters[0].addr),
+                                                  RX_ALLOC_SIZE,
+                                                  DMA_FROM_DEVICE);
                        sbus_writel(RX_ALLOC_SIZE, &rxd->myri_scatters[0].len);
                        sbus_writel(index, &rxd->ctx);
                        sbus_writel(1, &rxd->num_sg);
@@ -470,17 +471,17 @@ static void myri_rx(struct myri_eth *mp, struct net_device *dev)
                                DRX(("skb_alloc(FAILED) "));
                                goto drop_it;
                        }
-                       sbus_unmap_single(&mp->myri_sdev->ofdev.dev,
-                                         sbus_readl(&rxd->myri_scatters[0].addr),
-                                         RX_ALLOC_SIZE,
-                                         SBUS_DMA_FROMDEVICE);
+                       dma_unmap_single(&mp->myri_sdev->ofdev.dev,
+                                        sbus_readl(&rxd->myri_scatters[0].addr),
+                                        RX_ALLOC_SIZE,
+                                        DMA_FROM_DEVICE);
                        mp->rx_skbs[index] = new_skb;
                        new_skb->dev = dev;
                        skb_put(new_skb, RX_ALLOC_SIZE);
-                       dma_addr = sbus_map_single(&mp->myri_sdev->ofdev.dev,
-                                                  new_skb->data,
-                                                  RX_ALLOC_SIZE,
-                                                  SBUS_DMA_FROMDEVICE);
+                       dma_addr = dma_map_single(&mp->myri_sdev->ofdev.dev,
+                                                 new_skb->data,
+                                                 RX_ALLOC_SIZE,
+                                                 DMA_FROM_DEVICE);
                        sbus_writel(dma_addr, &rxd->myri_scatters[0].addr);
                        sbus_writel(RX_ALLOC_SIZE, &rxd->myri_scatters[0].len);
                        sbus_writel(index, &rxd->ctx);
@@ -506,10 +507,10 @@ static void myri_rx(struct myri_eth *mp, struct net_device *dev)
 
                        /* Reuse original ring buffer. */
                        DRX(("reuse "));
-                       sbus_dma_sync_single_for_device(&mp->myri_sdev->ofdev.dev,
-                                                       sbus_readl(&rxd->myri_scatters[0].addr),
-                                                       RX_ALLOC_SIZE,
-                                                       SBUS_DMA_FROMDEVICE);
+                       dma_sync_single_for_device(&mp->myri_sdev->ofdev.dev,
+                                                  sbus_readl(&rxd->myri_scatters[0].addr),
+                                                  RX_ALLOC_SIZE,
+                                                  DMA_FROM_DEVICE);
                        sbus_writel(RX_ALLOC_SIZE, &rxd->myri_scatters[0].len);
                        sbus_writel(index, &rxd->ctx);
                        sbus_writel(1, &rxd->num_sg);
@@ -658,8 +659,8 @@ static int myri_start_xmit(struct sk_buff *skb, struct net_device *dev)
                sbus_writew((skb->data[4] << 8) | skb->data[5], &txd->addr[3]);
        }
 
-       dma_addr = sbus_map_single(&mp->myri_sdev->ofdev.dev, skb->data,
-                                  len, SBUS_DMA_TODEVICE);
+       dma_addr = dma_map_single(&mp->myri_sdev->ofdev.dev, skb->data,
+                                 len, DMA_TO_DEVICE);
        sbus_writel(dma_addr, &txd->myri_gathers[0].addr);
        sbus_writel(len, &txd->myri_gathers[0].len);
        sbus_writel(1, &txd->num_sg);