ramips: raeth: unmap rx DMA address in ramips_cleanup_dma

[openwrt/svn-archive/archive.git] / target / linux / ramips / files / drivers / net / ramips.c

diff --git a/target/linux/ramips/files/drivers/net/ramips.c b/target/linux/ramips/files/drivers/net/ramips.c
index 0bc6c0603c45d35a8c9f4a722b6b743107a8fd68..e44e6b654089c108c245c078fac4c6e76ce88257 100644 (file)
--- a/target/linux/ramips/files/drivers/net/ramips.c
+++ b/target/linux/ramips/files/drivers/net/ramips.c
@@ -128,18 +128,21 @@ ramips_cleanup_dma(struct raeth_priv *re)
        int i;
 
        for (i = 0; i < NUM_RX_DESC; i++)
-               if (re->rx_skb[i])
+               if (re->rx_skb[i]) {
+                       dma_unmap_single(NULL, re->rx_dma[i], MAX_RX_LENGTH,
+                                        DMA_FROM_DEVICE);
                        dev_kfree_skb_any(re->rx_skb[i]);
+               }
 
        if (re->rx)
                dma_free_coherent(NULL,
                                  NUM_RX_DESC * sizeof(struct ramips_rx_dma),
-                                 re->rx, re->phy_rx);
+                                 re->rx, re->rx_desc_dma);
 
        if (re->tx)
                dma_free_coherent(NULL,
                                  NUM_TX_DESC * sizeof(struct ramips_tx_dma),
-                                 re->tx, re->phy_tx);
+                                 re->tx, re->tx_desc_dma);
 }
 
 static int
@@ -153,7 +156,7 @@ ramips_alloc_dma(struct raeth_priv *re)
        /* setup tx ring */
        re->tx = dma_alloc_coherent(NULL,
                                    NUM_TX_DESC * sizeof(struct ramips_tx_dma),
-                                   &re->phy_tx, GFP_ATOMIC);
+                                   &re->tx_desc_dma, GFP_ATOMIC);
        if (!re->tx)
                goto err_cleanup;
 
@@ -166,12 +169,13 @@ ramips_alloc_dma(struct raeth_priv *re)
        /* setup rx ring */
        re->rx = dma_alloc_coherent(NULL,
                                    NUM_RX_DESC * sizeof(struct ramips_rx_dma),
-                                   &re->phy_rx, GFP_ATOMIC);
+                                   &re->rx_desc_dma, GFP_ATOMIC);
        if (!re->rx)
                goto err_cleanup;
 
        memset(re->rx, 0, sizeof(struct ramips_rx_dma) * NUM_RX_DESC);
        for (i = 0; i < NUM_RX_DESC; i++) {
+               dma_addr_t dma_addr;
                struct sk_buff *new_skb = dev_alloc_skb(MAX_RX_LENGTH +
                                                        NET_IP_ALIGN);
 
@@ -179,10 +183,11 @@ ramips_alloc_dma(struct raeth_priv *re)
                        goto err_cleanup;
 
                skb_reserve(new_skb, NET_IP_ALIGN);
-               re->rx[i].rxd1 = dma_map_single(NULL,
-                                               new_skb->data,
-                                               MAX_RX_LENGTH,
-                                               DMA_FROM_DEVICE);
+
+               dma_addr = dma_map_single(NULL, new_skb->data,
+                                         MAX_RX_LENGTH, DMA_FROM_DEVICE);
+               re->rx_dma[i] = dma_addr;
+               re->rx[i].rxd1 = (unsigned int) re->rx_dma[i];
                re->rx[i].rxd2 |= RX_DMA_LSO;
                re->rx_skb[i] = new_skb;
        }
@@ -197,12 +202,12 @@ ramips_alloc_dma(struct raeth_priv *re)
 static void
 ramips_setup_dma(struct raeth_priv *re)
 {
-       ramips_fe_wr(phys_to_bus(re->phy_tx), RAMIPS_TX_BASE_PTR0);
+       ramips_fe_wr(re->tx_desc_dma, RAMIPS_TX_BASE_PTR0);
        ramips_fe_wr(NUM_TX_DESC, RAMIPS_TX_MAX_CNT0);
        ramips_fe_wr(0, RAMIPS_TX_CTX_IDX0);
        ramips_fe_wr(RAMIPS_PST_DTX_IDX0, RAMIPS_PDMA_RST_CFG);
 
-       ramips_fe_wr(phys_to_bus(re->phy_rx), RAMIPS_RX_BASE_PTR0);
+       ramips_fe_wr(re->rx_desc_dma, RAMIPS_RX_BASE_PTR0);
        ramips_fe_wr(NUM_RX_DESC, RAMIPS_RX_MAX_CNT0);
        ramips_fe_wr((NUM_RX_DESC - 1), RAMIPS_RX_CALC_IDX0);
        ramips_fe_wr(RAMIPS_PST_DRX_IDX0, RAMIPS_PDMA_RST_CFG);
@@ -269,30 +274,43 @@ ramips_eth_rx_hw(unsigned long ptr)
 
        while (max_rx) {
                struct sk_buff *rx_skb, *new_skb;
+               int pktlen;
 
                rx = (ramips_fe_rr(RAMIPS_RX_CALC_IDX0) + 1) % NUM_RX_DESC;
                if (!(priv->rx[rx].rxd2 & RX_DMA_DONE))
                        break;
                max_rx--;
 
+               rx_skb = priv->rx_skb[rx];
+               pktlen = RX_DMA_PLEN0(priv->rx[rx].rxd2);
+
                new_skb = netdev_alloc_skb(dev, MAX_RX_LENGTH + NET_IP_ALIGN);
                /* Reuse the buffer on allocation failures */
                if (new_skb) {
-                       rx_skb = priv->rx_skb[rx];
-                       skb_put(rx_skb, RX_DMA_PLEN0(priv->rx[rx].rxd2));
+                       dma_addr_t dma_addr;
+
+                       dma_unmap_single(NULL, priv->rx_dma[rx], MAX_RX_LENGTH,
+                                        DMA_FROM_DEVICE);
+
+                       skb_put(rx_skb, pktlen);
                        rx_skb->dev = dev;
                        rx_skb->protocol = eth_type_trans(rx_skb, dev);
                        rx_skb->ip_summed = CHECKSUM_NONE;
                        dev->stats.rx_packets++;
-                       dev->stats.rx_bytes += rx_skb->len;
+                       dev->stats.rx_bytes += pktlen;
                        netif_rx(rx_skb);
 
                        priv->rx_skb[rx] = new_skb;
                        skb_reserve(new_skb, NET_IP_ALIGN);
-                       priv->rx[rx].rxd1 = dma_map_single(NULL,
-                                                          new_skb->data,
-                                                          MAX_RX_LENGTH,
-                                                          DMA_FROM_DEVICE);
+
+                       dma_addr = dma_map_single(NULL,
+                                                 new_skb->data,
+                                                 MAX_RX_LENGTH,
+                                                 DMA_FROM_DEVICE);
+                       priv->rx_dma[rx] = dma_addr;
+                       priv->rx[rx].rxd1 = (unsigned int) dma_addr;
+               } else {
+                       dev->stats.rx_dropped++;
                }
 
                priv->rx[rx].rxd2 &= ~RX_DMA_DONE;