1 files changed, 57 insertions, 68 deletions

diff --git a/drivers/net/fec.c b/drivers/net/fec.c
index d7a3ea88edd..32a4f17d35f 100644
--- a/drivers/net/fec.c
+++ b/drivers/net/fec.c
@@ -67,6 +67,10 @@
 #define FEC_MAX_PORTS   1
 #endif
 
+#if defined(CONFIG_FADS) || defined(CONFIG_RPXCLASSIC) || defined(CONFIG_M5272)
+#define HAVE_mii_link_interrupt
+#endif
+
 /*
  * Define the fixed address of the FEC hardware.
  */
@@ -205,7 +209,10 @@ struct fec_enet_private {
         cbd_t   *cur_rx, *cur_tx;               /* The next free ring entry */
         cbd_t   *dirty_tx;      /* The ring entries to be free()ed. */
         uint    tx_full;
-        spinlock_t lock;
+        /* hold while accessing the HW like ringbuffer for tx/rx but not MAC */
+        spinlock_t hw_lock;
+        /* hold while accessing the mii_list_t() elements */
+        spinlock_t mii_lock;
 
         uint    phy_id;
         uint    phy_id_done;
@@ -309,6 +316,7 @@ fec_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
         volatile fec_t  *fecp;
         volatile cbd_t  *bdp;
         unsigned short  status;
+        unsigned long flags;
 
         fep = netdev_priv(dev);
         fecp = (volatile fec_t*)dev->base_addr;
@@ -318,6 +326,7 @@ fec_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 return 1;
         }
 
+        spin_lock_irqsave(&fep->hw_lock, flags);
         /* Fill in a Tx ring entry */
         bdp = fep->cur_tx;
 
@@ -328,6 +337,7 @@ fec_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
                  * This should not happen, since dev->tbusy should be set.
                  */
                 printk("%s: tx queue full!.\n", dev->name);
+                spin_unlock_irqrestore(&fep->hw_lock, flags);
                 return 1;
         }
 #endif
@@ -366,8 +376,6 @@ fec_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
         flush_dcache_range((unsigned long)skb->data,
                            (unsigned long)skb->data + skb->len);
 
-        spin_lock_irq(&fep->lock);
-
         /* Send it on its way.  Tell FEC it's ready, interrupt when done,
          * it's the last BD of the frame, and to put the CRC on the end.
          */
@@ -396,7 +404,7 @@ fec_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
 
         fep->cur_tx = (cbd_t *)bdp;
 
-        spin_unlock_irq(&fep->lock);
+        spin_unlock_irqrestore(&fep->hw_lock, flags);
 
         return 0;
 }
@@ -454,19 +462,20 @@ fec_enet_interrupt(int irq, void * dev_id)
         struct  net_device *dev = dev_id;
         volatile fec_t  *fecp;
         uint    int_events;
-        int handled = 0;
+        irqreturn_t ret = IRQ_NONE;
 
         fecp = (volatile fec_t*)dev->base_addr;
 
         /* Get the interrupt events that caused us to be here.
         */
-        while ((int_events = fecp->fec_ievent) != 0) {
+        do {
+                int_events = fecp->fec_ievent;
                 fecp->fec_ievent = int_events;
 
                 /* Handle receive event in its own function.
                  */
                 if (int_events & FEC_ENET_RXF) {
-                        handled = 1;
+                        ret = IRQ_HANDLED;
                         fec_enet_rx(dev);
                 }
 
@@ -475,17 +484,18 @@ fec_enet_interrupt(int irq, void * dev_id)
                    them as part of the transmit process.
                 */
                 if (int_events & FEC_ENET_TXF) {
-                        handled = 1;
+                        ret = IRQ_HANDLED;
                         fec_enet_tx(dev);
                 }
 
                 if (int_events & FEC_ENET_MII) {
-                        handled = 1;
+                        ret = IRQ_HANDLED;
                         fec_enet_mii(dev);
                 }
 
-        }
-        return IRQ_RETVAL(handled);
+        } while (int_events);
+
+        return ret;
 }
 
 
@@ -498,7 +508,7 @@ fec_enet_tx(struct net_device *dev)
         struct  sk_buff *skb;
 
         fep = netdev_priv(dev);
-        spin_lock(&fep->lock);
+        spin_lock_irq(&fep->hw_lock);
         bdp = fep->dirty_tx;
 
         while (((status = bdp->cbd_sc) & BD_ENET_TX_READY) == 0) {
@@ -557,7 +567,7 @@ fec_enet_tx(struct net_device *dev)
                 }
         }
         fep->dirty_tx = (cbd_t *)bdp;
-        spin_unlock(&fep->lock);
+        spin_unlock_irq(&fep->hw_lock);
 }
 
 
@@ -584,6 +594,8 @@ fec_enet_rx(struct net_device *dev)
         fep = netdev_priv(dev);
         fecp = (volatile fec_t*)dev->base_addr;
 
+        spin_lock_irq(&fep->hw_lock);
+
         /* First, grab all of the stats for the incoming packet.
          * These get messed up if we get called due to a busy condition.
          */
@@ -689,6 +701,8 @@ while (!((status = bdp->cbd_sc) & BD_ENET_RX_EMPTY)) {
          */
         fecp->fec_r_des_active = 0;
 #endif
+
+        spin_unlock_irq(&fep->hw_lock);
 }
 
 
@@ -702,11 +716,11 @@ fec_enet_mii(struct net_device *dev)
         uint            mii_reg;
 
         fep = netdev_priv(dev);
+        spin_lock_irq(&fep->mii_lock);
+
         ep = fep->hwp;
         mii_reg = ep->fec_mii_data;
 
-        spin_lock(&fep->lock);
-
         if ((mip = mii_head) == NULL) {
                 printk("MII and no head!\n");
                 goto unlock;
@@ -723,7 +737,7 @@ fec_enet_mii(struct net_device *dev)
                 ep->fec_mii_data = mip->mii_regval;
 
 unlock:
-        spin_unlock(&fep->lock);
+        spin_unlock_irq(&fep->mii_lock);
 }
 
 static int
@@ -737,12 +751,11 @@ mii_queue(struct net_device *dev, int regval, void (*func)(uint, struct net_devi
         /* Add PHY address to register command.
         */
         fep = netdev_priv(dev);
-        regval |= fep->phy_addr << 23;
+        spin_lock_irqsave(&fep->mii_lock, flags);
 
+        regval |= fep->phy_addr << 23;
         retval = 0;
 
-        spin_lock_irqsave(&fep->lock,flags);
-
         if ((mip = mii_free) != NULL) {
                 mii_free = mip->mii_next;
                 mip->mii_regval = regval;
@@ -759,9 +772,8 @@ mii_queue(struct net_device *dev, int regval, void (*func)(uint, struct net_devi
                 retval = 1;
         }
 
-        spin_unlock_irqrestore(&fep->lock,flags);
-
-        return(retval);
+        spin_unlock_irqrestore(&fep->mii_lock, flags);
+        return retval;
 }
 
 static void mii_do_cmd(struct net_device *dev, const phy_cmd_t *c)
@@ -1222,7 +1234,7 @@ static phy_info_t const * const phy_info[] = {
 };
 
 /* ------------------------------------------------------------------------- */
-#if !defined(CONFIG_M532x)
+#ifdef HAVE_mii_link_interrupt
 #ifdef CONFIG_RPXCLASSIC
 static void
 mii_link_interrupt(void *dev_id);
@@ -1362,18 +1374,8 @@ static void __inline__ fec_request_intrs(struct net_device *dev)
                 unsigned short irq;
         } *idp, id[] = {
                 { "fec(TXF)", 23 },
-                { "fec(TXB)", 24 },
-                { "fec(TXFIFO)", 25 },
-                { "fec(TXCR)", 26 },
                 { "fec(RXF)", 27 },
-                { "fec(RXB)", 28 },
                 { "fec(MII)", 29 },
-                { "fec(LC)", 30 },
-                { "fec(HBERR)", 31 },
-                { "fec(GRA)", 32 },
-                { "fec(EBERR)", 33 },
-                { "fec(BABT)", 34 },
-                { "fec(BABR)", 35 },
                 { NULL },
         };
 
@@ -1533,18 +1535,8 @@ static void __inline__ fec_request_intrs(struct net_device *dev)
                 unsigned short irq;
         } *idp, id[] = {
                 { "fec(TXF)", 23 },
-                { "fec(TXB)", 24 },
-                { "fec(TXFIFO)", 25 },
-                { "fec(TXCR)", 26 },
                 { "fec(RXF)", 27 },
-                { "fec(RXB)", 28 },
                 { "fec(MII)", 29 },
-                { "fec(LC)", 30 },
-                { "fec(HBERR)", 31 },
-                { "fec(GRA)", 32 },
-                { "fec(EBERR)", 33 },
-                { "fec(BABT)", 34 },
-                { "fec(BABR)", 35 },
                 { NULL },
         };
 
@@ -1660,18 +1652,8 @@ static void __inline__ fec_request_intrs(struct net_device *dev)
                 unsigned short irq;
         } *idp, id[] = {
             { "fec(TXF)", 36 },
-            { "fec(TXB)", 37 },
-            { "fec(TXFIFO)", 38 },
-            { "fec(TXCR)", 39 },
             { "fec(RXF)", 40 },
-            { "fec(RXB)", 41 },
             { "fec(MII)", 42 },
-            { "fec(LC)", 43 },
-            { "fec(HBERR)", 44 },
-            { "fec(GRA)", 45 },
-            { "fec(EBERR)", 46 },
-            { "fec(BABT)", 47 },
-            { "fec(BABR)", 48 },
             { NULL },
         };
 
@@ -2126,6 +2108,7 @@ mii_discover_phy(uint mii_reg, struct net_device *dev)
 
 /* This interrupt occurs when the PHY detects a link change.
 */
+#ifdef HAVE_mii_link_interrupt
 #ifdef CONFIG_RPXCLASSIC
 static void
 mii_link_interrupt(void *dev_id)
@@ -2148,6 +2131,7 @@ mii_link_interrupt(int irq, void * dev_id)
 
         return IRQ_HANDLED;
 }
+#endif
 
 static int
 fec_enet_open(struct net_device *dev)
@@ -2243,13 +2227,13 @@ static void set_multicast_list(struct net_device *dev)
                         /* Catch all multicast addresses, so set the
                          * filter to all 1's.
                          */
-                        ep->fec_hash_table_high = 0xffffffff;
-                        ep->fec_hash_table_low = 0xffffffff;
+                        ep->fec_grp_hash_table_high = 0xffffffff;
+                        ep->fec_grp_hash_table_low = 0xffffffff;
                 } else {
                         /* Clear filter and add the addresses in hash register.
                         */
-                        ep->fec_hash_table_high = 0;
-                        ep->fec_hash_table_low = 0;
+                        ep->fec_grp_hash_table_high = 0;
+                        ep->fec_grp_hash_table_low = 0;
 
                         dmi = dev->mc_list;
 
@@ -2280,9 +2264,9 @@ static void set_multicast_list(struct net_device *dev)
                                 hash = (crc >> (32 - HASH_BITS)) & 0x3f;
 
                                 if (hash > 31)
-                                        ep->fec_hash_table_high |= 1 << (hash - 32);
+                                        ep->fec_grp_hash_table_high |= 1 << (hash - 32);
                                 else
-                                        ep->fec_hash_table_low |= 1 << hash;
+                                        ep->fec_grp_hash_table_low |= 1 << hash;
                         }
                 }
         }
@@ -2332,6 +2316,9 @@ int __init fec_enet_init(struct net_device *dev)
                 return -ENOMEM;
         }
 
+        spin_lock_init(&fep->hw_lock);
+        spin_lock_init(&fep->mii_lock);
+
         /* Create an Ethernet device instance.
         */
         fecp = (volatile fec_t *) fec_hw[index];
@@ -2430,11 +2417,15 @@ int __init fec_enet_init(struct net_device *dev)
         */
         fec_request_intrs(dev);
 
-        fecp->fec_hash_table_high = 0;
-        fecp->fec_hash_table_low = 0;
+        fecp->fec_grp_hash_table_high = 0;
+        fecp->fec_grp_hash_table_low = 0;
         fecp->fec_r_buff_size = PKT_MAXBLR_SIZE;
         fecp->fec_ecntrl = 2;
         fecp->fec_r_des_active = 0;
+#ifndef CONFIG_M5272
+        fecp->fec_hash_table_high = 0;
+        fecp->fec_hash_table_low = 0;
+#endif
 
         dev->base_addr = (unsigned long)fecp;
 
@@ -2455,8 +2446,7 @@ int __init fec_enet_init(struct net_device *dev)
 
         /* Clear and enable interrupts */
         fecp->fec_ievent = 0xffc00000;
-        fecp->fec_imask = (FEC_ENET_TXF | FEC_ENET_TXB |
-                FEC_ENET_RXF | FEC_ENET_RXB | FEC_ENET_MII);
+        fecp->fec_imask = (FEC_ENET_TXF | FEC_ENET_RXF | FEC_ENET_MII);
 
         /* Queue up command to detect the PHY and initialize the
          * remainder of the interface.
@@ -2500,8 +2490,8 @@ fec_restart(struct net_device *dev, int duplex)
 
         /* Reset all multicast.
         */
-        fecp->fec_hash_table_high = 0;
-        fecp->fec_hash_table_low = 0;
+        fecp->fec_grp_hash_table_high = 0;
+        fecp->fec_grp_hash_table_low = 0;
 
         /* Set maximum receive buffer size.
         */
@@ -2583,8 +2573,7 @@ fec_restart(struct net_device *dev, int duplex)
 
         /* Enable interrupts we wish to service.
         */
-        fecp->fec_imask = (FEC_ENET_TXF | FEC_ENET_TXB |
-                FEC_ENET_RXF | FEC_ENET_RXB | FEC_ENET_MII);
+        fecp->fec_imask = (FEC_ENET_TXF | FEC_ENET_RXF | FEC_ENET_MII);
 }
 
 static void
@@ -2624,7 +2613,7 @@ fec_stop(struct net_device *dev)
 static int __init fec_enet_module_init(void)
 {
         struct net_device *dev;
-        int i, j, err;
+        int i, err;
         DECLARE_MAC_BUF(mac);
 
         printk("FEC ENET Version 0.2\n");