skge: deadlock on tx timeout

[powerpc.git] / drivers / net / skge.c

diff --git a/drivers/net/skge.c b/drivers/net/skge.c
index e482e7f..fad189e 100644 (file)
--- a/drivers/net/skge.c
+++ b/drivers/net/skge.c
@@ -77,13 +77,13 @@ static const struct pci_device_id skge_id_table[] = {
        { PCI_DEVICE(PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3C940B) },
        { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, PCI_DEVICE_ID_SYSKONNECT_GE) },
        { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, PCI_DEVICE_ID_SYSKONNECT_YU) },
-       { PCI_DEVICE(PCI_VENDOR_ID_DLINK, PCI_DEVICE_ID_DLINK_DGE510T), },
+       { PCI_DEVICE(PCI_VENDOR_ID_DLINK, PCI_DEVICE_ID_DLINK_DGE510T) },
        { PCI_DEVICE(PCI_VENDOR_ID_DLINK, 0x4b01) },    /* DGE-530T */
        { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4320) },
        { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x5005) }, /* Belkin */
        { PCI_DEVICE(PCI_VENDOR_ID_CNET, PCI_DEVICE_ID_CNET_GIGACARD) },
        { PCI_DEVICE(PCI_VENDOR_ID_LINKSYS, PCI_DEVICE_ID_LINKSYS_EG1064) },
-       { PCI_VENDOR_ID_LINKSYS, 0x1032, PCI_ANY_ID, 0x0015, },
+       { PCI_VENDOR_ID_LINKSYS, 0x1032, PCI_ANY_ID, 0x0015 },
        { 0 }
 };
 MODULE_DEVICE_TABLE(pci, skge_id_table);
@@ -1419,7 +1419,8 @@ static void xm_link_timer(struct work_struct *work)
        mutex_unlock(&hw->phy_mutex);
 
 nochange:
-       schedule_delayed_work(&skge->link_thread, LINK_HZ);
+       if (netif_running(dev))
+               schedule_delayed_work(&skge->link_thread, LINK_HZ);
 }
 
 static void genesis_mac_init(struct skge_hw *hw, int port)
@@ -2530,7 +2531,7 @@ static int skge_down(struct net_device *dev)
 
        netif_stop_queue(dev);
        if (hw->chip_id == CHIP_ID_GENESIS && hw->phy_type == SK_PHY_XMAC)
-               cancel_rearming_delayed_work(&skge->link_thread);
+               cancel_delayed_work(&skge->link_thread);
 
        skge_write8(skge->hw, SK_REG(skge->port, LNK_LED_REG), LED_OFF);
        if (hw->chip_id == CHIP_ID_GENESIS)
@@ -2575,7 +2576,11 @@ static int skge_down(struct net_device *dev)
        skge_led(skge, LED_MODE_OFF);
 
        netif_poll_disable(dev);
+
+       netif_tx_lock_bh(dev);
        skge_tx_clean(dev);
+       netif_tx_unlock_bh(dev);
+
        skge_rx_clean(skge);
 
        kfree(skge->rx_ring.start);
@@ -2720,7 +2725,6 @@ static void skge_tx_clean(struct net_device *dev)
        struct skge_port *skge = netdev_priv(dev);
        struct skge_element *e;
 
-       netif_tx_lock_bh(dev);
        for (e = skge->tx_ring.to_clean; e != skge->tx_ring.to_use; e = e->next) {
                struct skge_tx_desc *td = e->desc;
                skge_tx_free(skge, e, td->control);
@@ -2729,7 +2733,6 @@ static void skge_tx_clean(struct net_device *dev)
 
        skge->tx_ring.to_clean = e;
        netif_wake_queue(dev);
-       netif_tx_unlock_bh(dev);
 }
 
 static void skge_tx_timeout(struct net_device *dev)
@@ -2766,6 +2769,17 @@ static int skge_change_mtu(struct net_device *dev, int new_mtu)
        return err;
 }
 
+static const u8 pause_mc_addr[ETH_ALEN] = { 0x1, 0x80, 0xc2, 0x0, 0x0, 0x1 };
+
+static void genesis_add_filter(u8 filter[8], const u8 *addr)
+{
+       u32 crc, bit;
+
+       crc = ether_crc_le(ETH_ALEN, addr);
+       bit = ~crc & 0x3f;
+       filter[bit/8] |= 1 << (bit%8);
+}
+
 static void genesis_set_multicast(struct net_device *dev)
 {
        struct skge_port *skge = netdev_priv(dev);
@@ -2787,24 +2801,33 @@ static void genesis_set_multicast(struct net_device *dev)
                memset(filter, 0xff, sizeof(filter));
        else {
                memset(filter, 0, sizeof(filter));
-               for (i = 0; list && i < count; i++, list = list->next) {
-                       u32 crc, bit;
-                       crc = ether_crc_le(ETH_ALEN, list->dmi_addr);
-                       bit = ~crc & 0x3f;
-                       filter[bit/8] |= 1 << (bit%8);
-               }
+
+               if (skge->flow_status == FLOW_STAT_REM_SEND
+                   || skge->flow_status == FLOW_STAT_SYMMETRIC)
+                       genesis_add_filter(filter, pause_mc_addr);
+
+               for (i = 0; list && i < count; i++, list = list->next)
+                       genesis_add_filter(filter, list->dmi_addr);
        }
 
        xm_write32(hw, port, XM_MODE, mode);
        xm_outhash(hw, port, XM_HSM, filter);
 }
 
+static void yukon_add_filter(u8 filter[8], const u8 *addr)
+{
+        u32 bit = ether_crc(ETH_ALEN, addr) & 0x3f;
+        filter[bit/8] |= 1 << (bit%8);
+}
+
 static void yukon_set_multicast(struct net_device *dev)
 {
        struct skge_port *skge = netdev_priv(dev);
        struct skge_hw *hw = skge->hw;
        int port = skge->port;
        struct dev_mc_list *list = dev->mc_list;
+       int rx_pause = (skge->flow_status == FLOW_STAT_REM_SEND
+                       || skge->flow_status == FLOW_STAT_SYMMETRIC);
        u16 reg;
        u8 filter[8];
 
@@ -2817,16 +2840,17 @@ static void yukon_set_multicast(struct net_device *dev)
                reg &= ~(GM_RXCR_UCF_ENA | GM_RXCR_MCF_ENA);
        else if (dev->flags & IFF_ALLMULTI)     /* all multicast */
                memset(filter, 0xff, sizeof(filter));
-       else if (dev->mc_count == 0)            /* no multicast */
+       else if (dev->mc_count == 0 && !rx_pause)/* no multicast */
                reg &= ~GM_RXCR_MCF_ENA;
        else {
                int i;
                reg |= GM_RXCR_MCF_ENA;
 
-               for (i = 0; list && i < dev->mc_count; i++, list = list->next) {
-                       u32 bit = ether_crc(ETH_ALEN, list->dmi_addr) & 0x3f;
-                       filter[bit/8] |= 1 << (bit%8);
-               }
+               if (rx_pause)
+                       yukon_add_filter(filter, pause_mc_addr);
+
+               for (i = 0; list && i < dev->mc_count; i++, list = list->next)
+                       yukon_add_filter(filter, list->dmi_addr);
        }
 
 
@@ -3253,24 +3277,30 @@ static int skge_set_mac_address(struct net_device *dev, void *p)
        struct skge_hw *hw = skge->hw;
        unsigned port = skge->port;
        const struct sockaddr *addr = p;
+       u16 ctrl;
 
        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;
 
-       mutex_lock(&hw->phy_mutex);
        memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
-       memcpy_toio(hw->regs + B2_MAC_1 + port*8,
-                   dev->dev_addr, ETH_ALEN);
-       memcpy_toio(hw->regs + B2_MAC_2 + port*8,
-                   dev->dev_addr, ETH_ALEN);
 
-       if (hw->chip_id == CHIP_ID_GENESIS)
-               xm_outaddr(hw, port, XM_SA, dev->dev_addr);
-       else {
-               gma_set_addr(hw, port, GM_SRC_ADDR_1L, dev->dev_addr);
-               gma_set_addr(hw, port, GM_SRC_ADDR_2L, dev->dev_addr);
+       /* disable Rx */
+       ctrl = gma_read16(hw, port, GM_GP_CTRL);
+       gma_write16(hw, port, GM_GP_CTRL, ctrl & ~GM_GPCR_RX_ENA);
+
+       memcpy_toio(hw->regs + B2_MAC_1 + port*8, dev->dev_addr, ETH_ALEN);
+       memcpy_toio(hw->regs + B2_MAC_2 + port*8, dev->dev_addr, ETH_ALEN);
+
+       if (netif_running(dev)) {
+               if (hw->chip_id == CHIP_ID_GENESIS)
+                       xm_outaddr(hw, port, XM_SA, dev->dev_addr);
+               else {
+                       gma_set_addr(hw, port, GM_SRC_ADDR_1L, dev->dev_addr);
+                       gma_set_addr(hw, port, GM_SRC_ADDR_2L, dev->dev_addr);
+               }
        }
-       mutex_unlock(&hw->phy_mutex);
+
+       gma_write16(hw, port, GM_GP_CTRL, ctrl);
 
        return 0;
 }
@@ -3690,6 +3720,8 @@ static void __devexit skge_remove(struct pci_dev *pdev)
        if (!hw)
                return;
 
+       flush_scheduled_work();
+
        if ((dev1 = hw->dev[1]))
                unregister_netdev(dev1);
        dev0 = hw->dev[0];
@@ -3704,8 +3736,6 @@ static void __devexit skge_remove(struct pci_dev *pdev)
        skge_write16(hw, B0_LED, LED_STAT_OFF);
        skge_write8(hw, B0_CTST, CS_RST_SET);
 
-       flush_scheduled_work();
-
        free_irq(pdev->irq, hw);
        pci_release_regions(pdev);
        pci_disable_device(pdev);