ramips: raeth: unmap DMA memory when a packet is received

[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 812507328fa638bba168d4fb72781d1dd36514eb..17ef00bdcd621532a1afe4c9f57098375582595d 100644 (file)
--- a/target/linux/ramips/files/drivers/net/ramips.c
+++ b/target/linux/ramips/files/drivers/net/ramips.c
@@ -33,6 +33,9 @@
 
 #ifdef CONFIG_RALINK_RT305X
 #include "ramips_esw.c"
+#else
+static inline int rt305x_esw_init(void) { return 0; }
+static inline void rt305x_esw_exit(void) { }
 #endif
 
 #define phys_to_bus(a)  (a & 0x1FFFFFFF)
@@ -212,7 +215,6 @@ ramips_eth_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
        unsigned long tx;
        unsigned int tx_next;
        unsigned int mapped_addr;
-       unsigned long flags;
 
        if (priv->plat->min_pkt_len) {
                if (skb->len < priv->plat->min_pkt_len) {
@@ -230,7 +232,7 @@ ramips_eth_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
        mapped_addr = (unsigned int) dma_map_single(NULL, skb->data, skb->len,
                                                    DMA_TO_DEVICE);
        dma_sync_single_for_device(NULL, mapped_addr, skb->len, DMA_TO_DEVICE);
-       spin_lock_irqsave(&priv->page_lock, flags);
+       spin_lock(&priv->page_lock);
        tx = ramips_fe_rr(RAMIPS_TX_CTX_IDX0);
        tx_next = (tx + 1) % NUM_TX_DESC;
 
@@ -247,11 +249,11 @@ ramips_eth_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
        priv->tx_skb[tx] = skb;
        wmb();
        ramips_fe_wr(tx_next, RAMIPS_TX_CTX_IDX0);
-       spin_unlock_irqrestore(&priv->page_lock, flags);
+       spin_unlock(&priv->page_lock);
        return NETDEV_TX_OK;
 
  out:
-       spin_unlock_irqrestore(&priv->page_lock, flags);
+       spin_unlock(&priv->page_lock);
        dev->stats.tx_dropped++;
        kfree_skb(skb);
        return NETDEV_TX_OK;
@@ -267,22 +269,29 @@ 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));
+                       /* TODO: convert to use dma_address_t */
+                       dma_unmap_single(NULL, priv->rx[rx].rxd1, 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;
@@ -291,6 +300,8 @@ ramips_eth_rx_hw(unsigned long ptr)
                                                           new_skb->data,
                                                           MAX_RX_LENGTH,
                                                           DMA_FROM_DEVICE);
+               } else {
+                       dev->stats.rx_dropped++;
                }
 
                priv->rx[rx].rxd2 &= ~RX_DMA_DONE;
@@ -310,6 +321,7 @@ ramips_eth_tx_housekeeping(unsigned long ptr)
        struct net_device *dev = (struct net_device*)ptr;
        struct raeth_priv *priv = netdev_priv(dev);
 
+       spin_lock(&priv->page_lock);
        while ((priv->tx[priv->skb_free_idx].txd2 & TX_DMA_DONE) &&
               (priv->tx_skb[priv->skb_free_idx])) {
                dev_kfree_skb_irq(priv->tx_skb[priv->skb_free_idx]);
@@ -318,6 +330,7 @@ ramips_eth_tx_housekeeping(unsigned long ptr)
                if (priv->skb_free_idx >= NUM_TX_DESC)
                        priv->skb_free_idx = 0;
        }
+       spin_unlock(&priv->page_lock);
 
        ramips_fe_int_enable(RAMIPS_TX_DLY_INT);
 }
@@ -343,8 +356,10 @@ ramips_eth_irq(int irq, void *dev)
                tasklet_schedule(&priv->rx_tasklet);
        }
 
-       if (fe_int & RAMIPS_TX_DLY_INT)
-               ramips_eth_tx_housekeeping((unsigned long)dev);
+       if (fe_int & RAMIPS_TX_DLY_INT) {
+               ramips_fe_int_disable(RAMIPS_TX_DLY_INT);
+               tasklet_schedule(&priv->tx_housekeeping_tasklet);
+       }
 
        return IRQ_HANDLED;
 }
@@ -507,9 +522,6 @@ ramips_eth_plat_probe(struct platform_device *plat)
                goto err_free_dev;
        }
 
-#ifdef CONFIG_RALINK_RT305X
-       rt305x_esw_init();
-#endif
        printk(KERN_DEBUG "ramips_eth: loaded\n");
        return 0;
 
@@ -541,10 +553,23 @@ static struct platform_driver ramips_eth_driver = {
 static int __init
 ramips_eth_init(void)
 {
-       int ret = platform_driver_register(&ramips_eth_driver);
+       int ret;
+
+       ret = rt305x_esw_init();
        if (ret)
+               return ret;
+
+       ret = platform_driver_register(&ramips_eth_driver);
+       if (ret) {
                printk(KERN_ERR
                       "ramips_eth: Error registering platfom driver!\n");
+               goto esw_cleanup;
+       }
+
+       return 0;
+
+esw_cleanup:
+       rt305x_esw_exit();
        return ret;
 }
 
@@ -552,6 +577,7 @@ static void __exit
 ramips_eth_cleanup(void)
 {
        platform_driver_unregister(&ramips_eth_driver);
+       rt305x_esw_exit();
 }
 
 module_init(ramips_eth_init);