]> bbs.cooldavid.org Git - jme.git/blobdiff - jme.c
net: use pci_dev->revision, again
[jme.git] / jme.c
diff --git a/jme.c b/jme.c
index 4e868eeac89ea0b915bfb7e25989314141b748d5..f690474f44092ae1cc1872053bf28bdd92669278 100644 (file)
--- a/jme.c
+++ b/jme.c
@@ -3,6 +3,7 @@
  *
  * Copyright 2008 JMicron Technology Corporation
  * http://www.jmicron.com/
+ * Copyright (c) 2009 - 2010 Guo-Fu Tseng <cooldavid@cooldavid.org>
  *
  * Author: Guo-Fu Tseng <cooldavid@cooldavid.org>
  *
@@ -21,6 +22,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/pci.h>
@@ -73,7 +76,7 @@ read_again:
        }
 
        if (i == 0) {
-               jeprintk(jme->pdev, "phy(%d) read timeout : %d\n", phy, reg);
+               pr_err("phy(%d) read timeout : %d\n", phy, reg);
                return 0;
        }
 
@@ -102,9 +105,7 @@ jme_mdio_write(struct net_device *netdev,
        }
 
        if (i == 0)
-               jeprintk(jme->pdev, "phy(%d) write timeout : %d\n", phy, reg);
-
-       return;
+               pr_err("phy(%d) write timeout : %d\n", phy, reg);
 }
 
 static inline void
@@ -130,13 +131,11 @@ jme_reset_phy_processor(struct jme_adapter *jme)
        jme_mdio_write(jme->dev,
                        jme->mii_if.phy_id,
                        MII_BMCR, val | BMCR_RESET);
-
-       return;
 }
 
 static void
 jme_setup_wakeup_frame(struct jme_adapter *jme,
-               u32 *mask, u32 crc, int fnr)
+                      const u32 *mask, u32 crc, int fnr)
 {
        int i;
 
@@ -161,17 +160,93 @@ jme_setup_wakeup_frame(struct jme_adapter *jme,
        }
 }
 
+static inline void
+jme_mac_rxclk_off(struct jme_adapter *jme)
+{
+       jme->reg_gpreg1 |= GPREG1_RXCLKOFF;
+       jwrite32f(jme, JME_GPREG1, jme->reg_gpreg1);
+}
+
+static inline void
+jme_mac_rxclk_on(struct jme_adapter *jme)
+{
+       jme->reg_gpreg1 &= ~GPREG1_RXCLKOFF;
+       jwrite32f(jme, JME_GPREG1, jme->reg_gpreg1);
+}
+
+static inline void
+jme_mac_txclk_off(struct jme_adapter *jme)
+{
+       jme->reg_ghc &= ~(GHC_TO_CLK_SRC | GHC_TXMAC_CLK_SRC);
+       jwrite32f(jme, JME_GHC, jme->reg_ghc);
+}
+
+static inline void
+jme_mac_txclk_on(struct jme_adapter *jme)
+{
+       u32 speed = jme->reg_ghc & GHC_SPEED;
+       if (speed == GHC_SPEED_1000M)
+               jme->reg_ghc |= GHC_TO_CLK_GPHY | GHC_TXMAC_CLK_GPHY;
+       else
+               jme->reg_ghc |= GHC_TO_CLK_PCIE | GHC_TXMAC_CLK_PCIE;
+       jwrite32f(jme, JME_GHC, jme->reg_ghc);
+}
+
+static inline void
+jme_reset_ghc_speed(struct jme_adapter *jme)
+{
+       jme->reg_ghc &= ~(GHC_SPEED | GHC_DPX);
+       jwrite32f(jme, JME_GHC, jme->reg_ghc);
+}
+
+static inline void
+jme_reset_250A2_workaround(struct jme_adapter *jme)
+{
+       jme->reg_gpreg1 &= ~(GPREG1_HALFMODEPATCH |
+                            GPREG1_RSSPATCH);
+       jwrite32(jme, JME_GPREG1, jme->reg_gpreg1);
+}
+
+static inline void
+jme_assert_ghc_reset(struct jme_adapter *jme)
+{
+       jme->reg_ghc |= GHC_SWRST;
+       jwrite32f(jme, JME_GHC, jme->reg_ghc);
+}
+
+static inline void
+jme_clear_ghc_reset(struct jme_adapter *jme)
+{
+       jme->reg_ghc &= ~GHC_SWRST;
+       jwrite32f(jme, JME_GHC, jme->reg_ghc);
+}
+
 static inline void
 jme_reset_mac_processor(struct jme_adapter *jme)
 {
-       u32 mask[WAKEUP_FRAME_MASK_DWNR] = {0, 0, 0, 0};
+       static const u32 mask[WAKEUP_FRAME_MASK_DWNR] = {0, 0, 0, 0};
        u32 crc = 0xCDCDCDCD;
        u32 gpreg0;
        int i;
 
-       jwrite32(jme, JME_GHC, jme->reg_ghc | GHC_SWRST);
-       udelay(2);
-       jwrite32(jme, JME_GHC, jme->reg_ghc);
+       jme_reset_ghc_speed(jme);
+       jme_reset_250A2_workaround(jme);
+
+       jme_mac_rxclk_on(jme);
+       jme_mac_txclk_on(jme);
+       udelay(1);
+       jme_assert_ghc_reset(jme);
+       udelay(1);
+       jme_mac_rxclk_off(jme);
+       jme_mac_txclk_off(jme);
+       udelay(1);
+       jme_clear_ghc_reset(jme);
+       udelay(1);
+       jme_mac_rxclk_on(jme);
+       jme_mac_txclk_on(jme);
+       udelay(1);
+       jme_mac_rxclk_off(jme);
+       jme_mac_txclk_off(jme);
 
        jwrite32(jme, JME_RXDBA_LO, 0x00000000);
        jwrite32(jme, JME_RXDBA_HI, 0x00000000);
@@ -191,14 +266,6 @@ jme_reset_mac_processor(struct jme_adapter *jme)
        else
                gpreg0 = GPREG0_DEFAULT;
        jwrite32(jme, JME_GPREG0, gpreg0);
-       jwrite32(jme, JME_GPREG1, GPREG1_DEFAULT);
-}
-
-static inline void
-jme_reset_ghc_speed(struct jme_adapter *jme)
-{
-       jme->reg_ghc &= ~(GHC_SPEED_1000M | GHC_DPX);
-       jwrite32(jme, JME_GHC, jme->reg_ghc);
 }
 
 static inline void
@@ -231,7 +298,7 @@ jme_reload_eeprom(struct jme_adapter *jme)
                }
 
                if (i == 0) {
-                       jeprintk(jme->pdev, "eeprom reload timeout\n");
+                       pr_err("eeprom reload timeout\n");
                        return -EIO;
                }
        }
@@ -337,13 +404,13 @@ jme_linkstat_from_phy(struct jme_adapter *jme)
 }
 
 static inline void
-jme_set_phyfifoa(struct jme_adapter *jme)
+jme_set_phyfifo_5level(struct jme_adapter *jme)
 {
        jme_mdio_write(jme->dev, jme->mii_if.phy_id, 27, 0x0004);
 }
 
 static inline void
-jme_set_phyfifob(struct jme_adapter *jme)
+jme_set_phyfifo_8level(struct jme_adapter *jme)
 {
        jme_mdio_write(jme->dev, jme->mii_if.phy_id, 27, 0x0000);
 }
@@ -352,7 +419,7 @@ static int
 jme_check_link(struct net_device *netdev, int testonly)
 {
        struct jme_adapter *jme = netdev_priv(netdev);
-       u32 phylink, ghc, cnt = JME_SPDRSV_TIMEOUT, bmcr, gpreg1;
+       u32 phylink, cnt = JME_SPDRSV_TIMEOUT, bmcr;
        char linkmsg[64];
        int rc = 0;
 
@@ -401,8 +468,7 @@ jme_check_link(struct net_device *netdev, int testonly)
                                        phylink = jread32(jme, JME_PHY_LINK);
                        }
                        if (!cnt)
-                               jeprintk(jme->pdev,
-                                       "Waiting speed resolve timeout.\n");
+                               pr_err("Waiting speed resolve timeout\n");
 
                        strcat(linkmsg, "ANed: ");
                }
@@ -416,23 +482,21 @@ jme_check_link(struct net_device *netdev, int testonly)
 
                jme->phylink = phylink;
 
-               ghc = jme->reg_ghc & ~(GHC_SPEED | GHC_DPX |
-                               GHC_TO_CLK_PCIE | GHC_TXMAC_CLK_PCIE |
-                               GHC_TO_CLK_GPHY | GHC_TXMAC_CLK_GPHY);
+               /*
+                * The speed/duplex setting of jme->reg_ghc already cleared
+                * by jme_reset_mac_processor()
+                */
                switch (phylink & PHY_LINK_SPEED_MASK) {
                case PHY_LINK_SPEED_10M:
-                       ghc |= GHC_SPEED_10M |
-                               GHC_TO_CLK_PCIE | GHC_TXMAC_CLK_PCIE;
+                       jme->reg_ghc |= GHC_SPEED_10M;
                        strcat(linkmsg, "10 Mbps, ");
                        break;
                case PHY_LINK_SPEED_100M:
-                       ghc |= GHC_SPEED_100M |
-                               GHC_TO_CLK_PCIE | GHC_TXMAC_CLK_PCIE;
+                       jme->reg_ghc |= GHC_SPEED_100M;
                        strcat(linkmsg, "100 Mbps, ");
                        break;
                case PHY_LINK_SPEED_1000M:
-                       ghc |= GHC_SPEED_1000M |
-                               GHC_TO_CLK_GPHY | GHC_TXMAC_CLK_GPHY;
+                       jme->reg_ghc |= GHC_SPEED_1000M;
                        strcat(linkmsg, "1000 Mbps, ");
                        break;
                default:
@@ -441,42 +505,40 @@ jme_check_link(struct net_device *netdev, int testonly)
 
                if (phylink & PHY_LINK_DUPLEX) {
                        jwrite32(jme, JME_TXMCS, TXMCS_DEFAULT);
-                       ghc |= GHC_DPX;
+                       jwrite32(jme, JME_TXTRHD, TXTRHD_FULLDUPLEX);
+                       jme->reg_ghc |= GHC_DPX;
                } else {
                        jwrite32(jme, JME_TXMCS, TXMCS_DEFAULT |
                                                TXMCS_BACKOFF |
                                                TXMCS_CARRIERSENSE |
                                                TXMCS_COLLISION);
-                       jwrite32(jme, JME_TXTRHD, TXTRHD_TXPEN |
-                               ((0x2000 << TXTRHD_TXP_SHIFT) & TXTRHD_TXP) |
-                               TXTRHD_TXREN |
-                               ((8 << TXTRHD_TXRL_SHIFT) & TXTRHD_TXRL));
+                       jwrite32(jme, JME_TXTRHD, TXTRHD_HALFDUPLEX);
                }
 
-               gpreg1 = GPREG1_DEFAULT;
+               jwrite32(jme, JME_GHC, jme->reg_ghc);
+
                if (is_buggy250(jme->pdev->device, jme->chiprev)) {
+                       jme->reg_gpreg1 &= ~(GPREG1_HALFMODEPATCH |
+                                            GPREG1_RSSPATCH);
                        if (!(phylink & PHY_LINK_DUPLEX))
-                               gpreg1 |= GPREG1_HALFMODEPATCH;
+                               jme->reg_gpreg1 |= GPREG1_HALFMODEPATCH;
                        switch (phylink & PHY_LINK_SPEED_MASK) {
                        case PHY_LINK_SPEED_10M:
-                               jme_set_phyfifoa(jme);
-                               gpreg1 |= GPREG1_RSSPATCH;
+                               jme_set_phyfifo_8level(jme);
+                               jme->reg_gpreg1 |= GPREG1_RSSPATCH;
                                break;
                        case PHY_LINK_SPEED_100M:
-                               jme_set_phyfifob(jme);
-                               gpreg1 |= GPREG1_RSSPATCH;
+                               jme_set_phyfifo_5level(jme);
+                               jme->reg_gpreg1 |= GPREG1_RSSPATCH;
                                break;
                        case PHY_LINK_SPEED_1000M:
-                               jme_set_phyfifoa(jme);
+                               jme_set_phyfifo_8level(jme);
                                break;
                        default:
                                break;
                        }
                }
-
-               jwrite32(jme, JME_GPREG1, gpreg1);
-               jwrite32(jme, JME_GHC, ghc);
-               jme->reg_ghc = ghc;
+               jwrite32(jme, JME_GPREG1, jme->reg_gpreg1);
 
                strcat(linkmsg, (phylink & PHY_LINK_DUPLEX) ?
                                        "Full-Duplex, " :
@@ -484,13 +546,13 @@ jme_check_link(struct net_device *netdev, int testonly)
                strcat(linkmsg, (phylink & PHY_LINK_MDI_STAT) ?
                                        "MDI-X" :
                                        "MDI");
-               netif_info(jme, link, jme->dev, "Link is up at %s.\n", linkmsg);
+               netif_info(jme, link, jme->dev, "Link is up at %s\n", linkmsg);
                netif_carrier_on(netdev);
        } else {
                if (testonly)
                        goto out;
 
-               netif_info(jme, link, jme->dev, "Link is down.\n");
+               netif_info(jme, link, jme->dev, "Link is down\n");
                jme->phylink = 0;
                netif_carrier_off(netdev);
        }
@@ -615,10 +677,14 @@ jme_enable_tx_engine(struct jme_adapter *jme)
         * Enable TX Engine
         */
        wmb();
-       jwrite32(jme, JME_TXCS, jme->reg_txcs |
+       jwrite32f(jme, JME_TXCS, jme->reg_txcs |
                                TXCS_SELECT_QUEUE0 |
                                TXCS_ENABLE);
 
+       /*
+        * Start clock for TX MAC Processor
+        */
+       jme_mac_txclk_on(jme);
 }
 
 static inline void
@@ -652,7 +718,12 @@ jme_disable_tx_engine(struct jme_adapter *jme)
        }
 
        if (!i)
-               jeprintk(jme->pdev, "Disable TX engine timeout.\n");
+               pr_err("Disable TX engine timeout\n");
+
+       /*
+        * Stop clock for TX MAC Processor
+        */
+       jme_mac_txclk_off(jme);
 }
 
 static void
@@ -827,16 +898,22 @@ jme_enable_rx_engine(struct jme_adapter *jme)
        /*
         * Setup Unicast Filter
         */
+       jme_set_unicastaddr(jme->dev);
        jme_set_multi(jme->dev);
 
        /*
         * Enable RX Engine
         */
        wmb();
-       jwrite32(jme, JME_RXCS, jme->reg_rxcs |
+       jwrite32f(jme, JME_RXCS, jme->reg_rxcs |
                                RXCS_QUEUESEL_Q0 |
                                RXCS_ENABLE |
                                RXCS_QST);
+
+       /*
+        * Start clock for RX MAC Processor
+        */
+       jme_mac_rxclk_on(jme);
 }
 
 static inline void
@@ -871,12 +948,42 @@ jme_disable_rx_engine(struct jme_adapter *jme)
        }
 
        if (!i)
-               jeprintk(jme->pdev, "Disable RX engine timeout.\n");
+               pr_err("Disable RX engine timeout\n");
+
+       /*
+        * Stop clock for RX MAC Processor
+        */
+       jme_mac_rxclk_off(jme);
+}
+
+static u16
+jme_udpsum(struct sk_buff *skb)
+{
+       u16 csum = 0xFFFFu;
+
+       if (skb->len < (ETH_HLEN + sizeof(struct iphdr)))
+               return csum;
+       if (skb->protocol != htons(ETH_P_IP))
+               return csum;
+       skb_set_network_header(skb, ETH_HLEN);
+       if ((ip_hdr(skb)->protocol != IPPROTO_UDP) ||
+           (skb->len < (ETH_HLEN +
+                       (ip_hdr(skb)->ihl << 2) +
+                       sizeof(struct udphdr)))) {
+               skb_reset_network_header(skb);
+               return csum;
+       }
+       skb_set_transport_header(skb,
+                       ETH_HLEN + (ip_hdr(skb)->ihl << 2));
+       csum = udp_hdr(skb)->check;
+       skb_reset_transport_header(skb);
+       skb_reset_network_header(skb);
 
+       return csum;
 }
 
 static int
-jme_rxsum_ok(struct jme_adapter *jme, u16 flags)
+jme_rxsum_ok(struct jme_adapter *jme, u16 flags, struct sk_buff *skb)
 {
        if (!(flags & (RXWBFLAG_TCPON | RXWBFLAG_UDPON | RXWBFLAG_IPV4)))
                return false;
@@ -889,15 +996,15 @@ jme_rxsum_ok(struct jme_adapter *jme, u16 flags)
        }
 
        if (unlikely((flags & (RXWBFLAG_MF | RXWBFLAG_UDPON | RXWBFLAG_UDPCS))
-                       == RXWBFLAG_UDPON)) {
+                       == RXWBFLAG_UDPON) && jme_udpsum(skb)) {
                if (flags & RXWBFLAG_IPV4)
-                       netif_err(jme, rx_err, jme->dev, "UDP Checksum error.\n");
+                       netif_err(jme, rx_err, jme->dev, "UDP Checksum error\n");
                return false;
        }
 
        if (unlikely((flags & (RXWBFLAG_IPV4 | RXWBFLAG_IPCS))
                        == RXWBFLAG_IPV4)) {
-               netif_err(jme, rx_err, jme->dev, "IPv4 Checksum error.\n");
+               netif_err(jme, rx_err, jme->dev, "IPv4 Checksum error\n");
                return false;
        }
 
@@ -937,10 +1044,10 @@ jme_alloc_and_feed_skb(struct jme_adapter *jme, int idx)
                skb_put(skb, framesize);
                skb->protocol = eth_type_trans(skb, jme->dev);
 
-               if (jme_rxsum_ok(jme, le16_to_cpu(rxdesc->descwb.flags)))
+               if (jme_rxsum_ok(jme, le16_to_cpu(rxdesc->descwb.flags), skb))
                        skb->ip_summed = CHECKSUM_UNNECESSARY;
                else
-                       skb->ip_summed = CHECKSUM_NONE;
+                       skb_checksum_none_assert(skb);
 
                if (rxdesc->descwb.flags & cpu_to_le16(RXWBFLAG_TAGON)) {
                        if (jme->vlgrp) {
@@ -992,6 +1099,7 @@ jme_process_receive(struct jme_adapter *jme, int limit)
                        goto out;
                --limit;
 
+               rmb();
                desccnt = rxdesc->descwb.desccnt & RXWBDCNT_DCNT;
 
                if (unlikely(desccnt > 1 ||
@@ -1189,9 +1297,9 @@ jme_link_change_tasklet(unsigned long arg)
 
        while (!atomic_dec_and_test(&jme->link_changing)) {
                atomic_inc(&jme->link_changing);
-               netif_info(jme, intr, jme->dev, "Get link change lock failed.\n");
+               netif_info(jme, intr, jme->dev, "Get link change lock failed\n");
                while (atomic_read(&jme->link_changing) != 1)
-                       netif_info(jme, intr, jme->dev, "Waiting link change lock.\n");
+                       netif_info(jme, intr, jme->dev, "Waiting link change lock\n");
        }
 
        if (jme_check_link(netdev, 1) && jme->old_mtu == netdev->mtu)
@@ -1208,7 +1316,6 @@ jme_link_change_tasklet(unsigned long arg)
        tasklet_disable(&jme->rxempty_task);
 
        if (netif_carrier_ok(netdev)) {
-               jme_reset_ghc_speed(jme);
                jme_disable_rx_engine(jme);
                jme_disable_tx_engine(jme);
                jme_reset_mac_processor(jme);
@@ -1225,15 +1332,13 @@ jme_link_change_tasklet(unsigned long arg)
        if (netif_carrier_ok(netdev)) {
                rc = jme_setup_rx_resources(jme);
                if (rc) {
-                       jeprintk(jme->pdev, "Allocating resources for RX error"
-                               ", Device STOPPED!\n");
+                       pr_err("Allocating resources for RX error, Device STOPPED!\n");
                        goto out_enable_tasklet;
                }
 
                rc = jme_setup_tx_resources(jme);
                if (rc) {
-                       jeprintk(jme->pdev, "Allocating resources for TX error"
-                               ", Device STOPPED!\n");
+                       pr_err("Allocating resources for TX error, Device STOPPED!\n");
                        goto err_out_free_rx_resources;
                }
 
@@ -1328,7 +1433,7 @@ jme_wake_queue_if_stopped(struct jme_adapter *jme)
        smp_wmb();
        if (unlikely(netif_queue_stopped(jme->dev) &&
        atomic_read(&txring->nr_free) >= (jme->tx_wake_threshold))) {
-               netif_info(jme, tx_done, jme->dev, "TX Queue Waked.\n");
+               netif_info(jme, tx_done, jme->dev, "TX Queue Waked\n");
                netif_wake_queue(jme->dev);
        }
 
@@ -1343,7 +1448,7 @@ jme_tx_clean_tasklet(unsigned long arg)
        struct jme_buffer_info *txbi = txring->bufinf, *ctxbi, *ttxbi;
        int i, j, cnt = 0, max, err, mask;
 
-       tx_dbg(jme, "Into txclean.\n");
+       tx_dbg(jme, "Into txclean\n");
 
        if (unlikely(!atomic_dec_and_test(&jme->tx_cleaning)))
                goto out;
@@ -1365,7 +1470,7 @@ jme_tx_clean_tasklet(unsigned long arg)
                !(txdesc[i].descwb.flags & TXWBFLAG_OWN))) {
 
                        tx_dbg(jme, "txclean: %d+%d@%lu\n",
-                                       i, ctxbi->nr_desc, jiffies);
+                              i, ctxbi->nr_desc, jiffies);
 
                        err = txdesc[i].descwb.flags & TXWBFLAG_ALLERR;
 
@@ -1406,7 +1511,7 @@ jme_tx_clean_tasklet(unsigned long arg)
                ctxbi->nr_desc = 0;
        }
 
-       tx_dbg(jme, "txclean: done %d@%lu.\n", i, jiffies);
+       tx_dbg(jme, "txclean: done %d@%lu\n", i, jiffies);
        atomic_set(&txring->next_to_clean, i);
        atomic_add(cnt, &txring->nr_free);
 
@@ -1552,10 +1657,10 @@ jme_request_irq(struct jme_adapter *jme)
        rc = request_irq(jme->pdev->irq, handler, irq_flags, netdev->name,
                          netdev);
        if (rc) {
-               jeprintk(jme->pdev,
-                       "Unable to request %s interrupt (return: %d)\n",
-                       test_bit(JME_FLAG_MSI, &jme->flags) ? "MSI" : "INTx",
-                       rc);
+               netdev_err(netdev,
+                          "Unable to request %s interrupt (return: %d)\n",
+                          test_bit(JME_FLAG_MSI, &jme->flags) ? "MSI" : "INTx",
+                          rc);
 
                if (test_bit(JME_FLAG_MSI, &jme->flags)) {
                        pci_disable_msi(jme->pdev);
@@ -1579,6 +1684,64 @@ jme_free_irq(struct jme_adapter *jme)
        }
 }
 
+static inline void
+jme_new_phy_on(struct jme_adapter *jme)
+{
+       u32 reg;
+
+       reg = jread32(jme, JME_PHY_PWR);
+       reg &= ~(PHY_PWR_DWN1SEL | PHY_PWR_DWN1SW |
+                PHY_PWR_DWN2 | PHY_PWR_CLKSEL);
+       jwrite32(jme, JME_PHY_PWR, reg);
+
+       pci_read_config_dword(jme->pdev, PCI_PRIV_PE1, &reg);
+       reg &= ~PE1_GPREG0_PBG;
+       reg |= PE1_GPREG0_ENBG;
+       pci_write_config_dword(jme->pdev, PCI_PRIV_PE1, reg);
+}
+
+static inline void
+jme_new_phy_off(struct jme_adapter *jme)
+{
+       u32 reg;
+
+       reg = jread32(jme, JME_PHY_PWR);
+       reg |= PHY_PWR_DWN1SEL | PHY_PWR_DWN1SW |
+              PHY_PWR_DWN2 | PHY_PWR_CLKSEL;
+       jwrite32(jme, JME_PHY_PWR, reg);
+
+       pci_read_config_dword(jme->pdev, PCI_PRIV_PE1, &reg);
+       reg &= ~PE1_GPREG0_PBG;
+       reg |= PE1_GPREG0_PDD3COLD;
+       pci_write_config_dword(jme->pdev, PCI_PRIV_PE1, reg);
+}
+
+static inline void
+jme_phy_on(struct jme_adapter *jme)
+{
+       u32 bmcr;
+
+       bmcr = jme_mdio_read(jme->dev, jme->mii_if.phy_id, MII_BMCR);
+       bmcr &= ~BMCR_PDOWN;
+       jme_mdio_write(jme->dev, jme->mii_if.phy_id, MII_BMCR, bmcr);
+
+       if (new_phy_power_ctrl(jme->chip_main_rev))
+               jme_new_phy_on(jme);
+}
+
+static inline void
+jme_phy_off(struct jme_adapter *jme)
+{
+       u32 bmcr;
+
+       bmcr = jme_mdio_read(jme->dev, jme->mii_if.phy_id, MII_BMCR);
+       bmcr |= BMCR_PDOWN;
+       jme_mdio_write(jme->dev, jme->mii_if.phy_id, MII_BMCR, bmcr);
+
+       if (new_phy_power_ctrl(jme->chip_main_rev))
+               jme_new_phy_off(jme);
+}
+
 static int
 jme_open(struct net_device *netdev)
 {
@@ -1599,6 +1762,7 @@ jme_open(struct net_device *netdev)
 
        jme_start_irq(jme);
 
+       jme_phy_on(jme);
        if (test_bit(JME_FLAG_SSET, &jme->flags))
                jme_set_settings(netdev, &jme->old_ecmd);
        else
@@ -1614,12 +1778,12 @@ err_out:
        return rc;
 }
 
-#ifdef CONFIG_PM
 static void
 jme_set_100m_half(struct jme_adapter *jme)
 {
        u32 bmcr, tmp;
 
+       jme_phy_on(jme);
        bmcr = jme_mdio_read(jme->dev, jme->mii_if.phy_id, MII_BMCR);
        tmp = bmcr & ~(BMCR_ANENABLE | BMCR_SPEED100 |
                       BMCR_SPEED1000 | BMCR_FULLDPLX);
@@ -1647,12 +1811,20 @@ jme_wait_link(struct jme_adapter *jme)
                phylink = jme_linkstat_from_phy(jme);
        }
 }
-#endif
 
-static inline void
-jme_phy_off(struct jme_adapter *jme)
+static void
+jme_powersave_phy(struct jme_adapter *jme)
 {
-       jme_mdio_write(jme->dev, jme->mii_if.phy_id, MII_BMCR, BMCR_PDOWN);
+       if (jme->reg_pmcs) {
+               jme_set_100m_half(jme);
+
+               if (jme->reg_pmcs & (PMCS_LFEN | PMCS_LREN))
+                       jme_wait_link(jme);
+
+               jwrite32(jme, JME_PMCS, jme->reg_pmcs);
+       } else {
+               jme_phy_off(jme);
+       }
 }
 
 static int
@@ -1673,7 +1845,6 @@ jme_close(struct net_device *netdev)
        tasklet_disable(&jme->rxclean_task);
        tasklet_disable(&jme->rxempty_task);
 
-       jme_reset_ghc_speed(jme);
        jme_disable_rx_engine(jme);
        jme_disable_tx_engine(jme);
        jme_reset_mac_processor(jme);
@@ -1838,7 +2009,7 @@ jme_tx_csum(struct jme_adapter *jme, struct sk_buff *skb, u8 *flags)
                        *flags |= TXFLAG_UDPCS;
                        break;
                default:
-                       netif_err(jme, tx_err, jme->dev, "Error upper layer protocol.\n");
+                       netif_err(jme, tx_err, jme->dev, "Error upper layer protocol\n");
                        break;
                }
        }
@@ -1913,12 +2084,12 @@ jme_stop_queue_if_full(struct jme_adapter *jme)
        smp_wmb();
        if (unlikely(atomic_read(&txring->nr_free) < (MAX_SKB_FRAGS+2))) {
                netif_stop_queue(jme->dev);
-               netif_info(jme, tx_queued, jme->dev, "TX Queue Paused.\n");
+               netif_info(jme, tx_queued, jme->dev, "TX Queue Paused\n");
                smp_wmb();
                if (atomic_read(&txring->nr_free)
                        >= (jme->tx_wake_threshold)) {
                        netif_wake_queue(jme->dev);
-                       netif_info(jme, tx_queued, jme->dev, "TX Queue Fast Waked.\n");
+                       netif_info(jme, tx_queued, jme->dev, "TX Queue Fast Waked\n");
                }
        }
 
@@ -1926,7 +2097,8 @@ jme_stop_queue_if_full(struct jme_adapter *jme)
                        (jiffies - txbi->start_xmit) >= TX_TIMEOUT &&
                        txbi->skb)) {
                netif_stop_queue(jme->dev);
-               netif_info(jme, tx_queued, jme->dev, "TX Queue Stopped %d@%lu.\n", idx, jiffies);
+               netif_info(jme, tx_queued, jme->dev,
+                          "TX Queue Stopped %d@%lu\n", idx, jiffies);
        }
 }
 
@@ -1949,7 +2121,8 @@ jme_start_xmit(struct sk_buff *skb, struct net_device *netdev)
 
        if (unlikely(idx < 0)) {
                netif_stop_queue(netdev);
-               netif_err(jme, tx_err, jme->dev, "BUG! Tx ring full when queue awake!\n");
+               netif_err(jme, tx_err, jme->dev,
+                         "BUG! Tx ring full when queue awake!\n");
 
                return NETDEV_TX_BUSY;
        }
@@ -1961,35 +2134,41 @@ jme_start_xmit(struct sk_buff *skb, struct net_device *netdev)
                                TXCS_QUEUE0S |
                                TXCS_ENABLE);
 
-       tx_dbg(jme, "xmit: %d+%d@%lu\n", idx,
-                       skb_shinfo(skb)->nr_frags + 2,
-                       jiffies);
+       tx_dbg(jme, "xmit: %d+%d@%lu\n",
+              idx, skb_shinfo(skb)->nr_frags + 2, jiffies);
        jme_stop_queue_if_full(jme);
 
        return NETDEV_TX_OK;
 }
 
+static void
+jme_set_unicastaddr(struct net_device *netdev)
+{
+       struct jme_adapter *jme = netdev_priv(netdev);
+       u32 val;
+
+       val = (netdev->dev_addr[3] & 0xff) << 24 |
+             (netdev->dev_addr[2] & 0xff) << 16 |
+             (netdev->dev_addr[1] & 0xff) <<  8 |
+             (netdev->dev_addr[0] & 0xff);
+       jwrite32(jme, JME_RXUMA_LO, val);
+       val = (netdev->dev_addr[5] & 0xff) << 8 |
+             (netdev->dev_addr[4] & 0xff);
+       jwrite32(jme, JME_RXUMA_HI, val);
+}
+
 static int
 jme_set_macaddr(struct net_device *netdev, void *p)
 {
        struct jme_adapter *jme = netdev_priv(netdev);
        struct sockaddr *addr = p;
-       u32 val;
 
        if (netif_running(netdev))
                return -EBUSY;
 
        spin_lock_bh(&jme->macaddr_lock);
        memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
-
-       val = (addr->sa_data[3] & 0xff) << 24 |
-             (addr->sa_data[2] & 0xff) << 16 |
-             (addr->sa_data[1] & 0xff) <<  8 |
-             (addr->sa_data[0] & 0xff);
-       jwrite32(jme, JME_RXUMA_LO, val);
-       val = (addr->sa_data[5] & 0xff) << 8 |
-             (addr->sa_data[4] & 0xff);
-       jwrite32(jme, JME_RXUMA_HI, val);
+       jme_set_unicastaddr(netdev);
        spin_unlock_bh(&jme->macaddr_lock);
 
        return 0;
@@ -2052,12 +2231,11 @@ jme_change_mtu(struct net_device *netdev, int new_mtu)
        }
 
        if (new_mtu > 1900) {
-               netdev->features &= ~(NETIF_F_HW_CSUM |
-                               NETIF_F_TSO |
-                               NETIF_F_TSO6);
+               netdev->features &= ~(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
+                               NETIF_F_TSO | NETIF_F_TSO6);
        } else {
                if (test_bit(JME_FLAG_TXCSUM, &jme->flags))
-                       netdev->features |= NETIF_F_HW_CSUM;
+                       netdev->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
                if (test_bit(JME_FLAG_TSO, &jme->flags))
                        netdev->features |= NETIF_F_TSO | NETIF_F_TSO6;
        }
@@ -2386,6 +2564,10 @@ jme_set_settings(struct net_device *netdev,
        if (ecmd->speed == SPEED_1000 && ecmd->autoneg != AUTONEG_ENABLE)
                return -EINVAL;
 
+       /*
+        * Check If user changed duplex only while force_media.
+        * Hardware would not generate link change interrupt.
+        */
        if (jme->mii_if.force_media &&
        ecmd->autoneg != AUTONEG_ENABLE &&
        (jme->mii_if.full_duplex != ecmd->duplex))
@@ -2395,12 +2577,40 @@ jme_set_settings(struct net_device *netdev,
        rc = mii_ethtool_sset(&(jme->mii_if), ecmd);
        spin_unlock_bh(&jme->phy_lock);
 
-       if (!rc && fdc)
-               jme_reset_link(jme);
-
        if (!rc) {
-               set_bit(JME_FLAG_SSET, &jme->flags);
+               if (fdc)
+                       jme_reset_link(jme);
                jme->old_ecmd = *ecmd;
+               set_bit(JME_FLAG_SSET, &jme->flags);
+       }
+
+       return rc;
+}
+
+static int
+jme_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
+{
+       int rc;
+       struct jme_adapter *jme = netdev_priv(netdev);
+       struct mii_ioctl_data *mii_data = if_mii(rq);
+       unsigned int duplex_chg;
+
+       if (cmd == SIOCSMIIREG) {
+               u16 val = mii_data->val_in;
+               if (!(val & (BMCR_RESET|BMCR_ANENABLE)) &&
+                   (val & BMCR_SPEED1000))
+                       return -EINVAL;
+       }
+
+       spin_lock_bh(&jme->phy_lock);
+       rc = generic_mii_ioctl(&jme->mii_if, mii_data, cmd, &duplex_chg);
+       spin_unlock_bh(&jme->phy_lock);
+
+       if (!rc && (cmd == SIOCSMIIREG)) {
+               if (duplex_chg)
+                       jme_reset_link(jme);
+               jme_get_settings(netdev, &jme->old_ecmd);
+               set_bit(JME_FLAG_SSET, &jme->flags);
        }
 
        return rc;
@@ -2458,10 +2668,12 @@ jme_set_tx_csum(struct net_device *netdev, u32 on)
        if (on) {
                set_bit(JME_FLAG_TXCSUM, &jme->flags);
                if (netdev->mtu <= 1900)
-                       netdev->features |= NETIF_F_HW_CSUM;
+                       netdev->features |=
+                               NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
        } else {
                clear_bit(JME_FLAG_TXCSUM, &jme->flags);
-               netdev->features &= ~NETIF_F_HW_CSUM;
+               netdev->features &=
+                               ~(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM);
        }
 
        return 0;
@@ -2505,7 +2717,7 @@ jme_smb_read(struct jme_adapter *jme, unsigned int addr)
                val = jread32(jme, JME_SMBCSR);
        }
        if (!to) {
-               netif_err(jme, hw, jme->dev, "SMB Bus Busy.\n");
+               netif_err(jme, hw, jme->dev, "SMB Bus Busy\n");
                return 0xFF;
        }
 
@@ -2521,7 +2733,7 @@ jme_smb_read(struct jme_adapter *jme, unsigned int addr)
                val = jread32(jme, JME_SMBINTF);
        }
        if (!to) {
-               netif_err(jme, hw, jme->dev, "SMB Bus Busy.\n");
+               netif_err(jme, hw, jme->dev, "SMB Bus Busy\n");
                return 0xFF;
        }
 
@@ -2541,7 +2753,7 @@ jme_smb_write(struct jme_adapter *jme, unsigned int addr, u8 data)
                val = jread32(jme, JME_SMBCSR);
        }
        if (!to) {
-               netif_err(jme, hw, jme->dev, "SMB Bus Busy.\n");
+               netif_err(jme, hw, jme->dev, "SMB Bus Busy\n");
                return;
        }
 
@@ -2558,7 +2770,7 @@ jme_smb_write(struct jme_adapter *jme, unsigned int addr, u8 data)
                val = jread32(jme, JME_SMBINTF);
        }
        if (!to) {
-               netif_err(jme, hw, jme->dev, "SMB Bus Busy.\n");
+               netif_err(jme, hw, jme->dev, "SMB Bus Busy\n");
                return;
        }
 
@@ -2674,12 +2886,15 @@ jme_check_hw_ver(struct jme_adapter *jme)
 
        jme->fpgaver = (chipmode & CM_FPGAVER_MASK) >> CM_FPGAVER_SHIFT;
        jme->chiprev = (chipmode & CM_CHIPREV_MASK) >> CM_CHIPREV_SHIFT;
+       jme->chip_main_rev = jme->chiprev & 0xF;
+       jme->chip_sub_rev = (jme->chiprev >> 4) & 0xF;
 }
 
 static const struct net_device_ops jme_netdev_ops = {
        .ndo_open               = jme_open,
        .ndo_stop               = jme_close,
        .ndo_validate_addr      = eth_validate_addr,
+       .ndo_do_ioctl           = jme_ioctl,
        .ndo_start_xmit         = jme_start_xmit,
        .ndo_set_mac_address    = jme_set_macaddr,
        .ndo_set_multicast_list = jme_set_multi,
@@ -2703,26 +2918,26 @@ jme_init_one(struct pci_dev *pdev,
         */
        rc = pci_enable_device(pdev);
        if (rc) {
-               jeprintk(pdev, "Cannot enable PCI device.\n");
+               pr_err("Cannot enable PCI device\n");
                goto err_out;
        }
 
        using_dac = jme_pci_dma64(pdev);
        if (using_dac < 0) {
-               jeprintk(pdev, "Cannot set PCI DMA Mask.\n");
+               pr_err("Cannot set PCI DMA Mask\n");
                rc = -EIO;
                goto err_out_disable_pdev;
        }
 
        if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
-               jeprintk(pdev, "No PCI resource region found.\n");
+               pr_err("No PCI resource region found\n");
                rc = -ENOMEM;
                goto err_out_disable_pdev;
        }
 
        rc = pci_request_regions(pdev, DRV_NAME);
        if (rc) {
-               jeprintk(pdev, "Cannot obtain PCI resource region.\n");
+               pr_err("Cannot obtain PCI resource region\n");
                goto err_out_disable_pdev;
        }
 
@@ -2733,14 +2948,15 @@ jme_init_one(struct pci_dev *pdev,
         */
        netdev = alloc_etherdev(sizeof(*jme));
        if (!netdev) {
-               jeprintk(pdev, "Cannot allocate netdev structure.\n");
+               pr_err("Cannot allocate netdev structure\n");
                rc = -ENOMEM;
                goto err_out_release_regions;
        }
        netdev->netdev_ops = &jme_netdev_ops;
        netdev->ethtool_ops             = &jme_ethtool_ops;
        netdev->watchdog_timeo          = TX_TIMEOUT;
-       netdev->features                =       NETIF_F_HW_CSUM |
+       netdev->features                =       NETIF_F_IP_CSUM |
+                                               NETIF_F_IPV6_CSUM |
                                                NETIF_F_SG |
                                                NETIF_F_TSO |
                                                NETIF_F_TSO6 |
@@ -2771,7 +2987,7 @@ jme_init_one(struct pci_dev *pdev,
        jme->regs = ioremap(pci_resource_start(pdev, 0),
                             pci_resource_len(pdev, 0));
        if (!(jme->regs)) {
-               jeprintk(pdev, "Mapping PCI resource region error.\n");
+               pr_err("Mapping PCI resource region error\n");
                rc = -ENOMEM;
                goto err_out_free_netdev;
        }
@@ -2821,6 +3037,7 @@ jme_init_one(struct pci_dev *pdev,
        jme->reg_rxmcs = RXMCS_DEFAULT;
        jme->reg_txpfc = 0;
        jme->reg_pmcs = PMCS_MFEN;
+       jme->reg_gpreg1 = GPREG1_DEFAULT;
        set_bit(JME_FLAG_TXCSUM, &jme->flags);
        set_bit(JME_FLAG_TSO, &jme->flags);
 
@@ -2839,7 +3056,7 @@ jme_init_one(struct pci_dev *pdev,
        default:
                jme->reg_txcs = TXCS_DEFAULT | TXCS_DMASIZE_512B;
                break;
-       };
+       }
 
        /*
         * Must check before reset_mac_processor
@@ -2859,8 +3076,8 @@ 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_unmap;
+                       pr_err("Can not find phy_id\n");
+                       goto err_out_unmap;
                }
 
                jme->reg_ghc |= GHC_LINK_POLL;
@@ -2871,12 +3088,14 @@ jme_init_one(struct pci_dev *pdev,
                jme->mii_if.supports_gmii = true;
        else
                jme->mii_if.supports_gmii = false;
+       jme->mii_if.phy_id_mask = 0x1F;
+       jme->mii_if.reg_num_mask = 0x1F;
        jme->mii_if.mdio_read = jme_mdio_read;
        jme->mii_if.mdio_write = jme_mdio_write;
 
        jme_clear_pm(jme);
-       jme_set_phyfifoa(jme);
-       pci_read_config_byte(pdev, PCI_REVISION_ID, &jme->rev);
+       jme_set_phyfifo_5level(jme);
+       jme->pcirev = pdev->revision;
        if (!jme->fpgaver)
                jme_phy_init(jme);
        jme_phy_off(jme);
@@ -2887,8 +3106,7 @@ jme_init_one(struct pci_dev *pdev,
        jme_reset_mac_processor(jme);
        rc = jme_reload_eeprom(jme);
        if (rc) {
-               jeprintk(pdev,
-                       "Reload eeprom for reading MAC Address error.\n");
+               pr_err("Reload eeprom for reading MAC Address error\n");
                goto err_out_unmap;
        }
        jme_load_macaddr(netdev);
@@ -2897,25 +3115,21 @@ jme_init_one(struct pci_dev *pdev,
         * Tell stack that we are not ready to work until open()
         */
        netif_carrier_off(netdev);
-       netif_stop_queue(netdev);
 
-       /*
-        * Register netdev
-        */
        rc = register_netdev(netdev);
        if (rc) {
-               jeprintk(pdev, "Cannot register net device.\n");
+               pr_err("Cannot register net device\n");
                goto err_out_unmap;
        }
 
-       netif_info(jme, probe, jme->dev, "%s%s ver:%x rev:%x macaddr:%pM\n",
+       netif_info(jme, probe, jme->dev, "%s%s chiprev:%x pcirev:%x macaddr:%pM\n",
                   (jme->pdev->device == PCI_DEVICE_ID_JMICRON_JMC250) ?
                   "JMC250 Gigabit Ethernet" :
                   (jme->pdev->device == PCI_DEVICE_ID_JMICRON_JMC260) ?
                   "JMC260 Fast Ethernet" : "Unknown",
                   (jme->fpgaver != 0) ? " (FPGA)" : "",
                   (jme->fpgaver != 0) ? jme->fpgaver : jme->chiprev,
-                  jme->rev, netdev->dev_addr);
+                  jme->pcirev, netdev->dev_addr);
 
        return 0;
 
@@ -2947,6 +3161,16 @@ jme_remove_one(struct pci_dev *pdev)
 
 }
 
+static void
+jme_shutdown(struct pci_dev *pdev)
+{
+       struct net_device *netdev = pci_get_drvdata(pdev);
+       struct jme_adapter *jme = netdev_priv(netdev);
+
+       jme_powersave_phy(jme);
+       pci_pme_active(pdev, true);
+}
+
 #ifdef CONFIG_PM
 static int
 jme_suspend(struct pci_dev *pdev, pm_message_t state)
@@ -2969,7 +3193,6 @@ jme_suspend(struct pci_dev *pdev, pm_message_t state)
                        jme_polling_mode(jme);
 
                jme_stop_pcc_timer(jme);
-               jme_reset_ghc_speed(jme);
                jme_disable_rx_engine(jme);
                jme_disable_tx_engine(jme);
                jme_reset_mac_processor(jme);
@@ -2984,19 +3207,9 @@ jme_suspend(struct pci_dev *pdev, pm_message_t state)
        tasklet_hi_enable(&jme->rxempty_task);
 
        pci_save_state(pdev);
-       if (jme->reg_pmcs) {
-               jme_set_100m_half(jme);
-
-               if (jme->reg_pmcs & (PMCS_LFEN | PMCS_LREN))
-                       jme_wait_link(jme);
-
-               jwrite32(jme, JME_PMCS, jme->reg_pmcs);
-
-               pci_enable_wake(pdev, PCI_D3cold, true);
-       } else {
-               jme_phy_off(jme);
-       }
-       pci_set_power_state(pdev, PCI_D3cold);
+       jme_powersave_phy(jme);
+       pci_enable_wake(jme->pdev, PCI_D3hot, true);
+       pci_set_power_state(pdev, PCI_D3hot);
 
        return 0;
 }
@@ -3010,6 +3223,7 @@ jme_resume(struct pci_dev *pdev)
        jme_clear_pm(jme);
        pci_restore_state(pdev);
 
+       jme_phy_on(jme);
        if (test_bit(JME_FLAG_SSET, &jme->flags))
                jme_set_settings(netdev, &jme->old_ecmd);
        else
@@ -3041,13 +3255,13 @@ static struct pci_driver jme_driver = {
        .suspend        = jme_suspend,
        .resume         = jme_resume,
 #endif /* CONFIG_PM */
+       .shutdown       = jme_shutdown,
 };
 
 static int __init
 jme_init_module(void)
 {
-       printk(KERN_INFO PFX "JMicron JMC2XX ethernet "
-              "driver version %s\n", DRV_VERSION);
+       pr_info("JMicron JMC2XX ethernet driver version %s\n", DRV_VERSION);
        return pci_register_driver(&jme_driver);
 }