1 files changed, 94 insertions, 95 deletions

diff --git a/drivers/net/jme.c b/drivers/net/jme.c
index 1e3c63d67b91..e7068c7cd627 100644
--- a/drivers/net/jme.c
+++ b/drivers/net/jme.c
@@ -322,20 +322,6 @@ jme_stop_irq(struct jme_adapter *jme)
         jwrite32f(jme, JME_IENC, INTR_ENABLE);
 }
 
-static inline void
-jme_enable_shadow(struct jme_adapter *jme)
-{
-        jwrite32(jme,
-                 JME_SHBA_LO,
-                 ((u32)jme->shadow_dma & ~((u32)0x1F)) | SHBA_POSTEN);
-}
-
-static inline void
-jme_disable_shadow(struct jme_adapter *jme)
-{
-        jwrite32(jme, JME_SHBA_LO, 0x0);
-}
-
 static u32
 jme_linkstat_from_phy(struct jme_adapter *jme)
 {
@@ -522,12 +508,8 @@ jme_setup_tx_resources(struct jme_adapter *jme)
                                    &(txring->dmaalloc),
                                    GFP_ATOMIC);
 
-        if (!txring->alloc) {
-                txring->desc = NULL;
-                txring->dmaalloc = 0;
-                txring->dma = 0;
-                return -ENOMEM;
-        }
+        if (!txring->alloc)
+                goto err_set_null;
 
         /*
          * 16 Bytes align
@@ -539,6 +521,11 @@ jme_setup_tx_resources(struct jme_adapter *jme)
         atomic_set(&txring->next_to_clean, 0);
         atomic_set(&txring->nr_free, jme->tx_ring_size);
 
+        txring->bufinf          = kmalloc(sizeof(struct jme_buffer_info) *
+                                        jme->tx_ring_size, GFP_ATOMIC);
+        if (unlikely(!(txring->bufinf)))
+                goto err_free_txring;
+
         /*
          * Initialize Transmit Descriptors
          */
@@ -547,6 +534,20 @@ jme_setup_tx_resources(struct jme_adapter *jme)
                 sizeof(struct jme_buffer_info) * jme->tx_ring_size);
 
         return 0;
+
+err_free_txring:
+        dma_free_coherent(&(jme->pdev->dev),
+                          TX_RING_ALLOC_SIZE(jme->tx_ring_size),
+                          txring->alloc,
+                          txring->dmaalloc);
+
+err_set_null:
+        txring->desc = NULL;
+        txring->dmaalloc = 0;
+        txring->dma = 0;
+        txring->bufinf = NULL;
+
+        return -ENOMEM;
 }
 
 static void
@@ -554,19 +555,22 @@ jme_free_tx_resources(struct jme_adapter *jme)
 {
         int i;
         struct jme_ring *txring = &(jme->txring[0]);
-        struct jme_buffer_info *txbi = txring->bufinf;
+        struct jme_buffer_info *txbi;
 
         if (txring->alloc) {
-                for (i = 0 ; i < jme->tx_ring_size ; ++i) {
-                        txbi = txring->bufinf + i;
-                        if (txbi->skb) {
-                                dev_kfree_skb(txbi->skb);
-                                txbi->skb = NULL;
+                if (txring->bufinf) {
+                        for (i = 0 ; i < jme->tx_ring_size ; ++i) {
+                                txbi = txring->bufinf + i;
+                                if (txbi->skb) {
+                                        dev_kfree_skb(txbi->skb);
+                                        txbi->skb = NULL;
+                                }
+                                txbi->mapping           = 0;
+                                txbi->len               = 0;
+                                txbi->nr_desc           = 0;
+                                txbi->start_xmit        = 0;
                         }
-                        txbi->mapping           = 0;
-                        txbi->len               = 0;
-                        txbi->nr_desc           = 0;
-                        txbi->start_xmit        = 0;
+                        kfree(txring->bufinf);
                 }
 
                 dma_free_coherent(&(jme->pdev->dev),
@@ -578,11 +582,11 @@ jme_free_tx_resources(struct jme_adapter *jme)
                 txring->desc            = NULL;
                 txring->dmaalloc        = 0;
                 txring->dma             = 0;
+                txring->bufinf          = NULL;
         }
         txring->next_to_use     = 0;
         atomic_set(&txring->next_to_clean, 0);
         atomic_set(&txring->nr_free, 0);
-
 }
 
 static inline void
@@ -653,7 +657,7 @@ jme_disable_tx_engine(struct jme_adapter *jme)
 static void
 jme_set_clean_rxdesc(struct jme_adapter *jme, int i)
 {
-        struct jme_ring *rxring = jme->rxring;
+        struct jme_ring *rxring = &(jme->rxring[0]);
         register struct rxdesc *rxdesc = rxring->desc;
         struct jme_buffer_info *rxbi = rxring->bufinf;
         rxdesc += i;
@@ -720,8 +724,11 @@ jme_free_rx_resources(struct jme_adapter *jme)
         struct jme_ring *rxring = &(jme->rxring[0]);
 
         if (rxring->alloc) {
-                for (i = 0 ; i < jme->rx_ring_size ; ++i)
-                        jme_free_rx_buf(jme, i);
+                if (rxring->bufinf) {
+                        for (i = 0 ; i < jme->rx_ring_size ; ++i)
+                                jme_free_rx_buf(jme, i);
+                        kfree(rxring->bufinf);
+                }
 
                 dma_free_coherent(&(jme->pdev->dev),
                                   RX_RING_ALLOC_SIZE(jme->rx_ring_size),
@@ -731,6 +738,7 @@ jme_free_rx_resources(struct jme_adapter *jme)
                 rxring->desc     = NULL;
                 rxring->dmaalloc = 0;
                 rxring->dma      = 0;
+                rxring->bufinf   = NULL;
         }
         rxring->next_to_use   = 0;
         atomic_set(&rxring->next_to_clean, 0);
@@ -746,12 +754,8 @@ jme_setup_rx_resources(struct jme_adapter *jme)
                                    RX_RING_ALLOC_SIZE(jme->rx_ring_size),
                                    &(rxring->dmaalloc),
                                    GFP_ATOMIC);
-        if (!rxring->alloc) {
-                rxring->desc = NULL;
-                rxring->dmaalloc = 0;
-                rxring->dma = 0;
-                return -ENOMEM;
-        }
+        if (!rxring->alloc)
+                goto err_set_null;
 
         /*
          * 16 Bytes align
@@ -762,9 +766,16 @@ jme_setup_rx_resources(struct jme_adapter *jme)
         rxring->next_to_use     = 0;
         atomic_set(&rxring->next_to_clean, 0);
 
+        rxring->bufinf          = kmalloc(sizeof(struct jme_buffer_info) *
+                                        jme->rx_ring_size, GFP_ATOMIC);
+        if (unlikely(!(rxring->bufinf)))
+                goto err_free_rxring;
+
         /*
          * Initiallize Receive Descriptors
          */
+        memset(rxring->bufinf, 0,
+                sizeof(struct jme_buffer_info) * jme->rx_ring_size);
         for (i = 0 ; i < jme->rx_ring_size ; ++i) {
                 if (unlikely(jme_make_new_rx_buf(jme, i))) {
                         jme_free_rx_resources(jme);
@@ -775,6 +786,19 @@ jme_setup_rx_resources(struct jme_adapter *jme)
         }
 
         return 0;
+
+err_free_rxring:
+        dma_free_coherent(&(jme->pdev->dev),
+                          RX_RING_ALLOC_SIZE(jme->rx_ring_size),
+                          rxring->alloc,
+                          rxring->dmaalloc);
+err_set_null:
+        rxring->desc = NULL;
+        rxring->dmaalloc = 0;
+        rxring->dma = 0;
+        rxring->bufinf = NULL;
+
+        return -ENOMEM;
 }
 
 static inline void
@@ -790,9 +814,9 @@ jme_enable_rx_engine(struct jme_adapter *jme)
         /*
          * Setup RX DMA Bass Address
          */
-        jwrite32(jme, JME_RXDBA_LO, (__u64)jme->rxring[0].dma & 0xFFFFFFFFUL);
+        jwrite32(jme, JME_RXDBA_LO, (__u64)(jme->rxring[0].dma) & 0xFFFFFFFFUL);
         jwrite32(jme, JME_RXDBA_HI, (__u64)(jme->rxring[0].dma) >> 32);
-        jwrite32(jme, JME_RXNDA, (__u64)jme->rxring[0].dma & 0xFFFFFFFFUL);
+        jwrite32(jme, JME_RXNDA, (__u64)(jme->rxring[0].dma) & 0xFFFFFFFFUL);
 
         /*
          * Setup RX Descriptor Count
@@ -856,27 +880,27 @@ jme_rxsum_ok(struct jme_adapter *jme, u16 flags)
         if (!(flags & (RXWBFLAG_TCPON | RXWBFLAG_UDPON | RXWBFLAG_IPV4)))
                 return false;
 
-        if (unlikely(!(flags & RXWBFLAG_MF) &&
-        (flags & RXWBFLAG_TCPON) && !(flags & RXWBFLAG_TCPCS))) {
-                msg_rx_err(jme, "TCP Checksum error.\n");
-                goto out_sumerr;
+        if (unlikely((flags & (RXWBFLAG_MF | RXWBFLAG_TCPON | RXWBFLAG_TCPCS))
+                        == RXWBFLAG_TCPON)) {
+                if (flags & RXWBFLAG_IPV4)
+                        msg_rx_err(jme, "TCP Checksum error\n");
+                return false;
         }
 
-        if (unlikely(!(flags & RXWBFLAG_MF) &&
-        (flags & RXWBFLAG_UDPON) && !(flags & RXWBFLAG_UDPCS))) {
-                msg_rx_err(jme, "UDP Checksum error.\n");
-                goto out_sumerr;
+        if (unlikely((flags & (RXWBFLAG_MF | RXWBFLAG_UDPON | RXWBFLAG_UDPCS))
+                        == RXWBFLAG_UDPON)) {
+                if (flags & RXWBFLAG_IPV4)
+                        msg_rx_err(jme, "UDP Checksum error.\n");
+                return false;
         }
 
-        if (unlikely((flags & RXWBFLAG_IPV4) && !(flags & RXWBFLAG_IPCS))) {
+        if (unlikely((flags & (RXWBFLAG_IPV4 | RXWBFLAG_IPCS))
+                        == RXWBFLAG_IPV4)) {
                 msg_rx_err(jme, "IPv4 Checksum error.\n");
-                goto out_sumerr;
+                return false;
         }
 
         return true;
-
-out_sumerr:
-        return false;
 }
 
 static void
@@ -1296,7 +1320,7 @@ jme_rx_empty_tasklet(unsigned long arg)
 static void
 jme_wake_queue_if_stopped(struct jme_adapter *jme)
 {
-        struct jme_ring *txring = jme->txring;
+        struct jme_ring *txring = &(jme->txring[0]);
 
         smp_wmb();
         if (unlikely(netif_queue_stopped(jme->dev) &&
@@ -1483,12 +1507,7 @@ jme_msi(int irq, void *dev_id)
         struct jme_adapter *jme = netdev_priv(netdev);
         u32 intrstat;
 
-        pci_dma_sync_single_for_cpu(jme->pdev,
-                                    jme->shadow_dma,
-                                    sizeof(u32) * SHADOW_REG_NR,
-                                    PCI_DMA_FROMDEVICE);
-        intrstat = jme->shadow_regs[SHADOW_IEVE];
-        jme->shadow_regs[SHADOW_IEVE] = 0;
+        intrstat = jread32(jme, JME_IEVE);
 
         jme_intr_msi(jme, intrstat);
 
@@ -1566,6 +1585,7 @@ jme_open(struct net_device *netdev)
         jme_clear_pm(jme);
         JME_NAPI_ENABLE(jme);
 
+        tasklet_enable(&jme->linkch_task);
         tasklet_enable(&jme->txclean_task);
         tasklet_hi_enable(&jme->rxclean_task);
         tasklet_hi_enable(&jme->rxempty_task);
@@ -1574,7 +1594,6 @@ jme_open(struct net_device *netdev)
         if (rc)
                 goto err_out;
 
-        jme_enable_shadow(jme);
         jme_start_irq(jme);
 
         if (test_bit(JME_FLAG_SSET, &jme->flags))
@@ -1642,15 +1661,14 @@ jme_close(struct net_device *netdev)
         netif_carrier_off(netdev);
 
         jme_stop_irq(jme);
-        jme_disable_shadow(jme);
         jme_free_irq(jme);
 
         JME_NAPI_DISABLE(jme);
 
-        tasklet_kill(&jme->linkch_task);
-        tasklet_kill(&jme->txclean_task);
-        tasklet_kill(&jme->rxclean_task);
-        tasklet_kill(&jme->rxempty_task);
+        tasklet_disable(&jme->linkch_task);
+        tasklet_disable(&jme->txclean_task);
+        tasklet_disable(&jme->rxclean_task);
+        tasklet_disable(&jme->rxempty_task);
 
         jme_reset_ghc_speed(jme);
         jme_disable_rx_engine(jme);
@@ -1668,7 +1686,7 @@ static int
 jme_alloc_txdesc(struct jme_adapter *jme,
                         struct sk_buff *skb)
 {
-        struct jme_ring *txring = jme->txring;
+        struct jme_ring *txring = &(jme->txring[0]);
         int idx, nr_alloc, mask = jme->tx_ring_mask;
 
         idx = txring->next_to_use;
@@ -1722,7 +1740,7 @@ jme_fill_tx_map(struct pci_dev *pdev,
 static void
 jme_map_tx_skb(struct jme_adapter *jme, struct sk_buff *skb, int idx)
 {
-        struct jme_ring *txring = jme->txring;
+        struct jme_ring *txring = &(jme->txring[0]);
         struct txdesc *txdesc = txring->desc, *ctxdesc;
         struct jme_buffer_info *txbi = txring->bufinf, *ctxbi;
         u8 hidma = jme->dev->features & NETIF_F_HIGHDMA;
@@ -1835,7 +1853,7 @@ jme_tx_vlan(struct sk_buff *skb, __le16 *vlan, u8 *flags)
 static int
 jme_fill_tx_desc(struct jme_adapter *jme, struct sk_buff *skb, int idx)
 {
-        struct jme_ring *txring = jme->txring;
+        struct jme_ring *txring = &(jme->txring[0]);
         struct txdesc *txdesc;
         struct jme_buffer_info *txbi;
         u8 flags;
@@ -1883,7 +1901,7 @@ jme_fill_tx_desc(struct jme_adapter *jme, struct sk_buff *skb, int idx)
 static void
 jme_stop_queue_if_full(struct jme_adapter *jme)
 {
-        struct jme_ring *txring = jme->txring;
+        struct jme_ring *txring = &(jme->txring[0]);
         struct jme_buffer_info *txbi = txring->bufinf;
         int idx = atomic_read(&txring->next_to_clean);
 
@@ -2725,14 +2743,6 @@ jme_init_one(struct pci_dev *pdev,
                 rc = -ENOMEM;
                 goto err_out_free_netdev;
         }
-        jme->shadow_regs = pci_alloc_consistent(pdev,
-                                                sizeof(u32) * SHADOW_REG_NR,
-                                                &(jme->shadow_dma));
-        if (!(jme->shadow_regs)) {
-                jeprintk(pdev, "Allocating shadow register mapping error.\n");
-                rc = -ENOMEM;
-                goto err_out_unmap;
-        }
 
         if (no_pseudohp) {
                 apmc = jread32(jme, JME_APMC) & ~JME_APMC_PSEUDO_HP_EN;
@@ -2768,6 +2778,7 @@ jme_init_one(struct pci_dev *pdev,
         tasklet_init(&jme->rxempty_task,
                      &jme_rx_empty_tasklet,
                      (unsigned long) jme);
+        tasklet_disable_nosync(&jme->linkch_task);
         tasklet_disable_nosync(&jme->txclean_task);
         tasklet_disable_nosync(&jme->rxclean_task);
         tasklet_disable_nosync(&jme->rxempty_task);
@@ -2817,7 +2828,7 @@ jme_init_one(struct pci_dev *pdev,
                 if (!jme->mii_if.phy_id) {
                         rc = -EIO;
                         jeprintk(pdev, "Can not find phy_id.\n");
-                         goto err_out_free_shadow;
+                         goto err_out_unmap;
                 }
 
                 jme->reg_ghc |= GHC_LINK_POLL;
@@ -2846,7 +2857,7 @@ jme_init_one(struct pci_dev *pdev,
         if (rc) {
                 jeprintk(pdev,
                         "Reload eeprom for reading MAC Address error.\n");
-                goto err_out_free_shadow;
+                goto err_out_unmap;
         }
         jme_load_macaddr(netdev);
 
@@ -2862,7 +2873,7 @@ jme_init_one(struct pci_dev *pdev,
         rc = register_netdev(netdev);
         if (rc) {
                 jeprintk(pdev, "Cannot register net device.\n");
-                goto err_out_free_shadow;
+                goto err_out_unmap;
         }
 
         msg_probe(jme, "%s%s ver:%x rev:%x macaddr:%pM\n",
@@ -2876,11 +2887,6 @@ jme_init_one(struct pci_dev *pdev,
 
         return 0;
 
-err_out_free_shadow:
-        pci_free_consistent(pdev,
-                            sizeof(u32) * SHADOW_REG_NR,
-                            jme->shadow_regs,
-                            jme->shadow_dma);
 err_out_unmap:
         iounmap(jme->regs);
 err_out_free_netdev:
@@ -2901,10 +2907,6 @@ jme_remove_one(struct pci_dev *pdev)
         struct jme_adapter *jme = netdev_priv(netdev);
 
         unregister_netdev(netdev);
-        pci_free_consistent(pdev,
-                            sizeof(u32) * SHADOW_REG_NR,
-                            jme->shadow_regs,
-                            jme->shadow_dma);
         iounmap(jme->regs);
         pci_set_drvdata(pdev, NULL);
         free_netdev(netdev);
@@ -2930,8 +2932,6 @@ jme_suspend(struct pci_dev *pdev, pm_message_t state)
         tasklet_disable(&jme->rxclean_task);
         tasklet_disable(&jme->rxempty_task);
 
-        jme_disable_shadow(jme);
-
         if (netif_carrier_ok(netdev)) {
                 if (test_bit(JME_FLAG_POLL, &jme->flags))
                         jme_polling_mode(jme);
@@ -2983,7 +2983,6 @@ jme_resume(struct pci_dev *pdev)
         else
                 jme_reset_phy_processor(jme);
 
-        jme_enable_shadow(jme);
         jme_start_irq(jme);
         netif_device_attach(netdev);