X-Git-Url: http://bbs.cooldavid.org/git/?p=jme.git;a=blobdiff_plain;f=jme.c;h=f44a3cc8bb10459427beb6603a79f87ceb3a1555;hp=cc1d4191822e133eb74ac2b67afae12e0cf8c37c;hb=8d27293f4a6c7c2bfde177c16714956ba3764c96;hpb=29bdd92156c4614ed78d68d10882ea16746f04ed

diff --git a/jme.c b/jme.c
index cc1d419..f44a3cc 100644
--- a/jme.c
+++ b/jme.c
@@ -22,38 +22,7 @@
  */
 
 /*
- * Note:
- * 	Backdoor for changing "FIFO Threshold for processing next packet"
- * 	   Using:
- *		ethtool -C eth1 adaptive-rx on adaptive-tx on \
- *		rx-usecs 250 rx-frames-low N
- *	   N := 16 | 32 | 64 | 128
- */
-
-/*
- * Timeline before release:
- * 	Stage 5: Advanced offloading support.
- * 	0.8:
- * 	-  Implement VLAN offloading.
- * 	0.9:
- *	-  Implement scatter-gather offloading.
- *	   Use pci_map_page on scattered sk_buff for HIGHMEM support
- * 	-  Implement TCP Segement offloading.
- * 		Due to TX FIFO size, we should turn off tso when mtu > 1500.
- *
- * 	Stage 6: CPU Load balancing.
- * 	1.0:
- * 	-  Implement MSI-X.
- * 	   Along with multiple RX queue, for CPU load balancing.
- *
- * 	Stage 7:
- * 	-  Cleanup/re-orginize code, performence tuneing(alignment etc...).
- * 	-  Test and Release 1.0
- *
- * 	Non-Critical:
- *  	-  Use NAPI instead of rx_tasklet?
- * 		PCC Support Both Packet Counter and Timeout Interrupt for
- * 		receive and transmit complete, does NAPI really needed?
+ * TODO:
  *	-  Decode register dump for ethtool.
  */
 
@@ -73,6 +42,7 @@
 #include <linux/ipv6.h>
 #include <linux/tcp.h>
 #include <linux/udp.h>
+#include <linux/if_vlan.h>
 #include "jme.h"
 
 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,21)
@@ -88,24 +58,29 @@ static int
 jme_mdio_read(struct net_device *netdev, int phy, int reg)
 {
 	struct jme_adapter *jme = netdev_priv(netdev);
-	int i, val;
+	int i, val, again = (reg == MII_BMSR)?1:0;
 
+read_again:
         jwrite32(jme, JME_SMI, SMI_OP_REQ |
 				smi_phy_addr(phy) |
 				smi_reg_addr(reg));
 
 	wmb();
-        for (i = JME_PHY_TIMEOUT ; i > 0 ; --i) {
-		udelay(1);
-		if (((val = jread32(jme, JME_SMI)) & SMI_OP_REQ) == 0)
+        for (i = JME_PHY_TIMEOUT * 50 ; i > 0 ; --i) {
+		udelay(20);
+		val = jread32(jme, JME_SMI);
+		if ((val & SMI_OP_REQ) == 0)
 			break;
         }
 
         if (i == 0) {
-		jeprintk(netdev->name, "phy read timeout : %d\n", reg);
+		jeprintk("jme", "phy(%d) read timeout : %d\n", phy, reg);
 		return 0;
         }
 
+	if(again--)
+		goto read_again;
+
 	return ((val & SMI_DATA_MASK) >> SMI_DATA_SHIFT);
 }
 
@@ -121,14 +96,14 @@ jme_mdio_write(struct net_device *netdev,
 		smi_phy_addr(phy) | smi_reg_addr(reg));
 
 	wmb();
-	for (i = JME_PHY_TIMEOUT ; i > 0 ; --i) {
-		udelay(1);
-		if (((val = jread32(jme, JME_SMI)) & SMI_OP_REQ) == 0)
+	for (i = JME_PHY_TIMEOUT * 50 ; i > 0 ; --i) {
+		udelay(20);
+		if ((jread32(jme, JME_SMI) & SMI_OP_REQ) == 0)
 			break;
 	}
 
 	if (i == 0)
-		jeprintk(netdev->name, "phy write timeout : %d\n", reg);
+		jeprintk("jme", "phy(%d) write timeout : %d\n", phy, reg);
 
 	return;
 }
@@ -143,10 +118,11 @@ jme_reset_phy_processor(struct jme_adapter *jme)
 			MII_ADVERTISE, ADVERTISE_ALL |
 			ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM);
 
-	jme_mdio_write(jme->dev,
-			jme->mii_if.phy_id,
-			MII_CTRL1000,
-			ADVERTISE_1000FULL | ADVERTISE_1000HALF);
+	if(jme->pdev->device == JME_GE_DEVICE)
+		jme_mdio_write(jme->dev,
+				jme->mii_if.phy_id,
+				MII_CTRL1000,
+				ADVERTISE_1000FULL | ADVERTISE_1000HALF);
 
 	val = jme_mdio_read(jme->dev,
 				jme->mii_if.phy_id,
@@ -159,18 +135,53 @@ jme_reset_phy_processor(struct jme_adapter *jme)
 	return;
 }
 
+static void
+jme_setup_wakeup_frame(struct jme_adapter *jme,
+		__u32 *mask, __u32 crc, int fnr)
+{
+	int i;
+
+	/*
+	 * Setup CRC pattern
+	 */
+	jwrite32(jme, JME_WFOI, WFOI_CRC_SEL | (fnr & WFOI_FRAME_SEL));
+	wmb();
+	jwrite32(jme, JME_WFODP, crc);
+	wmb();
+
+	/*
+	 * Setup Mask
+	 */
+	for(i = 0 ; i < WAKEUP_FRAME_MASK_DWNR ; ++i) {
+		jwrite32(jme, JME_WFOI,
+				((i << WFOI_MASK_SHIFT) & WFOI_MASK_SEL) |
+				(fnr & WFOI_FRAME_SEL));
+		wmb();
+		jwrite32(jme, JME_WFODP, mask[i]);
+		wmb();
+	}
+}
 
 __always_inline static void
 jme_reset_mac_processor(struct jme_adapter *jme)
 {
+	__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);
 	jwrite32(jme, JME_RXMCHT_LO, 0x00000000);
 	jwrite32(jme, JME_RXMCHT_HI, 0x00000000);
-	jwrite32(jme, JME_WFODP, 0);
-	jwrite32(jme, JME_WFOI, 0);
-	jwrite32(jme, JME_GPREG0, GPREG0_DEFAULT);
+	for(i = 0 ; i < WAKEUP_FRAME_NR ; ++i)
+		jme_setup_wakeup_frame(jme, mask, crc, i);
+	if(jme->fpgaver)
+		gpreg0 = GPREG0_DEFAULT | GPREG0_LNKINTPOLL;
+	else
+		gpreg0 = GPREG0_DEFAULT;
+	jwrite32(jme, JME_GPREG0, gpreg0);
 	jwrite32(jme, JME_GPREG1, 0);
 }
 
@@ -179,7 +190,7 @@ jme_clear_pm(struct jme_adapter *jme)
 {
 	jwrite32(jme, JME_PMCS, 0xFFFF0000 | jme->reg_pmcs);
 	pci_set_power_state(jme->pdev, PCI_D0);
-	pci_enable_wake(jme->pdev, PCI_D0, 0);
+	pci_enable_wake(jme->pdev, PCI_D0, false);
 }
 
 static int
@@ -198,7 +209,7 @@ jme_reload_eeprom(struct jme_adapter *jme)
 		jwrite32(jme, JME_SMBCSR, val);
 		mdelay(12);
 
-		for (i = JME_SMB_TIMEOUT; i > 0; --i)
+		for (i = JME_EEPROM_RELOAD_TIMEOUT; i > 0; --i)
 		{
 			mdelay(1);
 			if ((jread32(jme, JME_SMBCSR) & SMBCSR_RELOAD) == 0)
@@ -206,12 +217,10 @@ jme_reload_eeprom(struct jme_adapter *jme)
 		}
 
 		if(i == 0) {
-			jeprintk(jme->dev->name, "eeprom reload timeout\n");
+			jeprintk("jme", "eeprom reload timeout\n");
 			return -EIO;
 		}
 	}
-	else
-		return -EIO;
 
 	return 0;
 }
@@ -240,6 +249,11 @@ __always_inline static void
 jme_set_rx_pcc(struct jme_adapter *jme, int p)
 {
 	switch(p) {
+	case PCC_OFF:
+		jwrite32(jme, JME_PCCRX0,
+			((PCC_OFF_TO << PCCRXTO_SHIFT) & PCCRXTO_MASK) |
+			((PCC_OFF_CNT << PCCRX_SHIFT) & PCCRX_MASK));
+		break;
 	case PCC_P1:
 		jwrite32(jme, JME_PCCRX0,
 			((PCC_P1_TO << PCCRXTO_SHIFT) & PCCRXTO_MASK) |
@@ -258,8 +272,10 @@ jme_set_rx_pcc(struct jme_adapter *jme, int p)
 	default:
 		break;
 	}
+	wmb();
 
-	dprintk(jme->dev->name, "Switched to PCC_P%d\n", p);
+	if(!(jme->flags & JME_FLAG_POLL))
+		dprintk(jme->dev->name, "Switched to PCC_P%d\n", p);
 }
 
 static void
@@ -308,6 +324,19 @@ jme_disable_shadow(struct jme_adapter *jme)
 	jwrite32(jme, JME_SHBA_LO, 0x0);
 }
 
+static __u32
+jme_linkstat_from_phy(struct jme_adapter *jme)
+{
+	__u32 phylink, bmsr;
+
+	phylink = jme_mdio_read(jme->dev, jme->mii_if.phy_id, 17);
+	bmsr = jme_mdio_read(jme->dev, jme->mii_if.phy_id, MII_BMSR);
+	if(bmsr & BMSR_ANCOMP)
+		phylink |= PHY_LINK_AUTONEG_COMPLETE;
+
+	return phylink;
+}
+
 static int
 jme_check_link(struct net_device *netdev, int testonly)
 {
@@ -316,7 +345,12 @@ jme_check_link(struct net_device *netdev, int testonly)
 	char linkmsg[64];
 	int rc = 0;
 
-	phylink = jread32(jme, JME_PHY_LINK);
+	linkmsg[0] = '\0';
+
+	if(jme->fpgaver)
+		phylink = jme_linkstat_from_phy(jme);
+	else
+		phylink = jread32(jme, JME_PHY_LINK);
 
         if (phylink & PHY_LINK_UP) {
 		if(!(phylink & PHY_LINK_AUTONEG_COMPLETE)) {
@@ -341,7 +375,7 @@ jme_check_link(struct net_device *netdev, int testonly)
 			phylink |= (bmcr & BMCR_FULLDPLX) ?
 					 PHY_LINK_DUPLEX : 0;
 
-			strcpy(linkmsg, "Forced: ");
+			strcat(linkmsg, "Forced: ");
 		}
 		else {
 			/*
@@ -351,15 +385,18 @@ jme_check_link(struct net_device *netdev, int testonly)
 				--cnt) {
 
 				udelay(1);
-				phylink = jread32(jme, JME_PHY_LINK);
 
+				if(jme->fpgaver)
+					phylink = jme_linkstat_from_phy(jme);
+				else
+					phylink = jread32(jme, JME_PHY_LINK);
 			}
 
 			if(!cnt)
 				jeprintk(netdev->name,
 					"Waiting speed resolve timeout.\n");
 
-			strcpy(linkmsg, "ANed: ");
+			strcat(linkmsg, "ANed: ");
 		}
 
 		if(jme->phylink == phylink) {
@@ -371,21 +408,24 @@ jme_check_link(struct net_device *netdev, int testonly)
 
 		jme->phylink = phylink;
 
+		ghc = jme->reg_ghc & ~(GHC_SPEED_10M |
+					GHC_SPEED_100M |
+					GHC_SPEED_1000M |
+					GHC_DPX);
 		switch(phylink & PHY_LINK_SPEED_MASK) {
 			case PHY_LINK_SPEED_10M:
-				ghc = GHC_SPEED_10M;
-				strcpy(linkmsg, "10 Mbps, ");
+				ghc |= GHC_SPEED_10M;
+				strcat(linkmsg, "10 Mbps, ");
 				break;
 			case PHY_LINK_SPEED_100M:
-				ghc = GHC_SPEED_100M;
-				strcpy(linkmsg, "100 Mbps, ");
+				ghc |= GHC_SPEED_100M;
+				strcat(linkmsg, "100 Mbps, ");
 				break;
 			case PHY_LINK_SPEED_1000M:
-				ghc = GHC_SPEED_1000M;
-				strcpy(linkmsg, "1000 Mbps, ");
+				ghc |= GHC_SPEED_1000M;
+				strcat(linkmsg, "1000 Mbps, ");
 				break;
 			default:
-				ghc = 0;
 				break;
 		}
                 ghc |= (phylink & PHY_LINK_DUPLEX) ? GHC_DPX : 0;
@@ -431,147 +471,15 @@ out:
 	return rc;
 }
 
-
-static int
-jme_alloc_txdesc(struct jme_adapter *jme,
-			int nr_alloc)
-{
-	struct jme_ring *txring = jme->txring;
-	int idx;
-
-	idx = txring->next_to_use;
-
-	if(unlikely(atomic_read(&txring->nr_free) < nr_alloc))
-		return -1;
-
-	atomic_sub(nr_alloc, &txring->nr_free);
-
-	if((txring->next_to_use += nr_alloc) >= RING_DESC_NR)
-		txring->next_to_use -= RING_DESC_NR;
-
-	return idx;
-}
-
-static void
-jme_tx_csum(struct sk_buff *skb, unsigned mtu, __u8 *flags)
-{
-	if(skb->ip_summed == CHECKSUM_PARTIAL) {
-		__u8 ip_proto;
-
-		switch (skb->protocol) {
-		case __constant_htons(ETH_P_IP):
-			ip_proto = ip_hdr(skb)->protocol;
-			break;
-		case __constant_htons(ETH_P_IPV6):
-			ip_proto = ipv6_hdr(skb)->nexthdr;
-			break;
-		default:
-			ip_proto = 0;
-			break;
-		}
-
-
-		switch(ip_proto) {
-		case IPPROTO_TCP:
-			*flags |= TXFLAG_TCPCS;
-			break;
-		case IPPROTO_UDP:
-			*flags |= TXFLAG_UDPCS;
-			break;
-		default:
-			jeprintk("jme", "Error upper layer protocol.\n");
-			break;
-		}
-	}
-}
-
-static int
-jme_set_new_txdesc(struct jme_adapter *jme,
-			struct sk_buff *skb)
-{
-	struct jme_ring *txring = jme->txring;
-	volatile struct txdesc *txdesc = txring->desc, *ctxdesc;
-	struct jme_buffer_info *txbi = txring->bufinf, *ctxbi;
-	dma_addr_t dmaaddr;
-	int i, idx, nr_desc;
-	__u8 flags;
-
-	nr_desc = 2;
-	idx = jme_alloc_txdesc(jme, nr_desc);
-
-	if(unlikely(idx<0))
-		return NETDEV_TX_BUSY;
-
-	for(i = 1 ; i < nr_desc  ; ++i) {
-		ctxdesc = txdesc + ((idx + i) & (RING_DESC_NR-1));
-		ctxbi = txbi + ((idx + i) & (RING_DESC_NR-1));
-
-		dmaaddr = pci_map_single(jme->pdev,
-					 skb->data,
-					 skb->len,
-					 PCI_DMA_TODEVICE);
-
-		pci_dma_sync_single_for_device(jme->pdev,
-					       dmaaddr,
-					       skb->len,
-					       PCI_DMA_TODEVICE);
-
-		ctxdesc->dw[0] = 0;
-		ctxdesc->dw[1] = 0;
-		ctxdesc->desc2.flags	= TXFLAG_OWN;
-		if(jme->dev->features & NETIF_F_HIGHDMA)
-			ctxdesc->desc2.flags |= TXFLAG_64BIT;
-		ctxdesc->desc2.datalen	= cpu_to_le16(skb->len);
-		ctxdesc->desc2.bufaddrh	= cpu_to_le32((__u64)dmaaddr >> 32);
-		ctxdesc->desc2.bufaddrl	= cpu_to_le32(
-						(__u64)dmaaddr & 0xFFFFFFFFUL);
-
-		ctxbi->mapping = dmaaddr;
-		ctxbi->len = skb->len;
-	}
-
-	ctxdesc = txdesc + idx;
-	ctxbi = txbi + idx;
-
-	ctxdesc->dw[0] = 0;
-	ctxdesc->dw[1] = 0;
-	ctxdesc->dw[2] = 0;
-	ctxdesc->dw[3] = 0;
-	ctxdesc->desc1.pktsize = cpu_to_le16(skb->len);
-	/*
-	 * Set OWN bit at final.
-	 * When kernel transmit faster than NIC.
-	 * And NIC trying to send this descriptor before we tell
-	 * it to start sending this TX queue.
-	 * Other fields are already filled correctly.
-	 */
-	wmb();
-	flags = TXFLAG_OWN | TXFLAG_INT; 
-	jme_tx_csum(skb, jme->dev->mtu, &flags);
-	ctxdesc->desc1.flags = flags;
-	/*
-	 * Set tx buffer info after telling NIC to send
-	 * For better tx_clean timing
-	 */
-	wmb();
-	ctxbi->nr_desc = nr_desc;
-	ctxbi->skb = skb;
-
-	tx_dbg(jme->dev->name, "Xmit: %d+%d\n", idx, nr_desc);
-
-	return 0;
-}
-
-
 static int
 jme_setup_tx_resources(struct jme_adapter *jme)
 {
 	struct jme_ring *txring = &(jme->txring[0]);
 
 	txring->alloc = dma_alloc_coherent(&(jme->pdev->dev),
-					   TX_RING_ALLOC_SIZE,
-					   &(txring->dmaalloc),
-					   GFP_ATOMIC);
+				   TX_RING_ALLOC_SIZE(jme->tx_ring_size),
+				   &(txring->dmaalloc),
+				   GFP_ATOMIC);
 
 	if(!txring->alloc) {
 		txring->desc = NULL;
@@ -587,15 +495,15 @@ jme_setup_tx_resources(struct jme_adapter *jme)
 						RING_DESC_ALIGN);
 	txring->dma		= ALIGN(txring->dmaalloc, RING_DESC_ALIGN);
 	txring->next_to_use	= 0;
-	txring->next_to_clean	= 0;
-	atomic_set(&txring->nr_free, RING_DESC_NR);
+	atomic_set(&txring->next_to_clean, 0);
+	atomic_set(&txring->nr_free, jme->tx_ring_size);
 
 	/*
-	 * Initiallize Transmit Descriptors
+	 * Initialize Transmit Descriptors
 	 */
-	memset(txring->alloc, 0, TX_RING_ALLOC_SIZE);
+	memset(txring->alloc, 0, TX_RING_ALLOC_SIZE(jme->tx_ring_size));
 	memset(txring->bufinf, 0,
-		sizeof(struct jme_buffer_info) * RING_DESC_NR);
+		sizeof(struct jme_buffer_info) * jme->tx_ring_size);
 
 	return 0;
 }
@@ -608,7 +516,7 @@ jme_free_tx_resources(struct jme_adapter *jme)
 	struct jme_buffer_info *txbi = txring->bufinf;
 
 	if(txring->alloc) {
-		for(i = 0 ; i < RING_DESC_NR ; ++i) {
+		for(i = 0 ; i < jme->tx_ring_size ; ++i) {
 			txbi = txring->bufinf + i;
 			if(txbi->skb) {
 				dev_kfree_skb(txbi->skb);
@@ -620,7 +528,7 @@ jme_free_tx_resources(struct jme_adapter *jme)
 		}
 
 		dma_free_coherent(&(jme->pdev->dev),
-				  TX_RING_ALLOC_SIZE,
+				  TX_RING_ALLOC_SIZE(jme->tx_ring_size),
 				  txring->alloc,
 				  txring->dmaalloc);
 
@@ -630,7 +538,7 @@ jme_free_tx_resources(struct jme_adapter *jme)
 		txring->dma		= 0;
 	}
 	txring->next_to_use	= 0;
-	txring->next_to_clean	= 0;
+	atomic_set(&txring->next_to_clean, 0);
 	atomic_set(&txring->nr_free, 0);
 
 }
@@ -653,7 +561,7 @@ jme_enable_tx_engine(struct jme_adapter *jme)
 	/*
 	 * Setup TX Descptor Count
 	 */
-	jwrite32(jme, JME_TXQDC, RING_DESC_NR);
+	jwrite32(jme, JME_TXQDC, jme->tx_ring_size);
 
 	/*
 	 * Enable TX Engine
@@ -727,7 +635,7 @@ static int
 jme_make_new_rx_buf(struct jme_adapter *jme, int i)
 {
 	struct jme_ring *rxring = &(jme->rxring[0]);
-	struct jme_buffer_info *rxbi = rxring->bufinf;
+	struct jme_buffer_info *rxbi = rxring->bufinf + i;
 	unsigned long offset;
 	struct sk_buff* skb;
 
@@ -736,26 +644,18 @@ jme_make_new_rx_buf(struct jme_adapter *jme, int i)
 	if(unlikely(!skb))
 		return -ENOMEM;
 
-	if(unlikely(skb_is_nonlinear(skb))) {
-		dprintk(jme->dev->name,
-			"Allocated skb fragged(%d).\n",
-			skb_shinfo(skb)->nr_frags);
-		dev_kfree_skb(skb);
-		return -ENOMEM;
-	}
-
 	if(unlikely(offset =
 			(unsigned long)(skb->data)
 			& ((unsigned long)RX_BUF_DMA_ALIGN - 1)))
 		skb_reserve(skb, RX_BUF_DMA_ALIGN - offset);
 
-	rxbi += i;
 	rxbi->skb = skb;
 	rxbi->len = skb_tailroom(skb);
-	rxbi->mapping = pci_map_single(jme->pdev,
-				       skb->data,
-				       rxbi->len,
-				       PCI_DMA_FROMDEVICE);
+	rxbi->mapping = pci_map_page(jme->pdev,
+					virt_to_page(skb->data),
+					offset_in_page(skb->data),
+					rxbi->len,
+					PCI_DMA_FROMDEVICE);
 
 	return 0;
 }
@@ -768,7 +668,7 @@ jme_free_rx_buf(struct jme_adapter *jme, int i)
 	rxbi += i;
 
 	if(rxbi->skb) {
-		pci_unmap_single(jme->pdev,
+		pci_unmap_page(jme->pdev,
 				 rxbi->mapping,
 				 rxbi->len,
 				 PCI_DMA_FROMDEVICE);
@@ -786,11 +686,11 @@ jme_free_rx_resources(struct jme_adapter *jme)
 	struct jme_ring *rxring = &(jme->rxring[0]);
 
 	if(rxring->alloc) {
-		for(i = 0 ; i < RING_DESC_NR ; ++i)
+		for(i = 0 ; i < jme->rx_ring_size ; ++i)
 			jme_free_rx_buf(jme, i);
 
 		dma_free_coherent(&(jme->pdev->dev),
-				  RX_RING_ALLOC_SIZE,
+				  RX_RING_ALLOC_SIZE(jme->rx_ring_size),
 				  rxring->alloc,
 				  rxring->dmaalloc);
 		rxring->alloc    = NULL;
@@ -799,7 +699,7 @@ jme_free_rx_resources(struct jme_adapter *jme)
 		rxring->dma      = 0;
 	}
 	rxring->next_to_use   = 0;
-	rxring->next_to_clean = 0;
+	atomic_set(&rxring->next_to_clean, 0);
 }
 
 static int
@@ -809,9 +709,9 @@ jme_setup_rx_resources(struct jme_adapter *jme)
 	struct jme_ring *rxring = &(jme->rxring[0]);
 
 	rxring->alloc = dma_alloc_coherent(&(jme->pdev->dev),
-					   RX_RING_ALLOC_SIZE,
-					   &(rxring->dmaalloc),
-					   GFP_ATOMIC);
+				   RX_RING_ALLOC_SIZE(jme->rx_ring_size),
+				   &(rxring->dmaalloc),
+				   GFP_ATOMIC);
 	if(!rxring->alloc) {
 		rxring->desc = NULL;
 		rxring->dmaalloc = 0;
@@ -826,12 +726,12 @@ jme_setup_rx_resources(struct jme_adapter *jme)
 						RING_DESC_ALIGN);
 	rxring->dma		= ALIGN(rxring->dmaalloc, RING_DESC_ALIGN);
 	rxring->next_to_use	= 0;
-	rxring->next_to_clean	= 0;
+	atomic_set(&rxring->next_to_clean, 0);
 
 	/*
 	 * Initiallize Receive Descriptors
 	 */
-	for(i = 0 ; i < RING_DESC_NR ; ++i) {
+	for(i = 0 ; i < jme->rx_ring_size ; ++i) {
 		if(unlikely(jme_make_new_rx_buf(jme, i))) {
 			jme_free_rx_resources(jme);
 			return -ENOMEM;
@@ -854,9 +754,9 @@ jme_enable_rx_engine(struct jme_adapter *jme)
 	jwrite32(jme, JME_RXNDA, (__u64)jme->rxring[0].dma & 0xFFFFFFFFUL);
 
 	/*
-	 * Setup RX Descptor Count
+	 * Setup RX Descriptor Count
 	 */
-	jwrite32(jme, JME_RXQDC, RING_DESC_NR);
+	jwrite32(jme, JME_RXQDC, jme->rx_ring_size);
 
 	/*
 	 * Setup Unicast Filter
@@ -909,8 +809,43 @@ jme_disable_rx_engine(struct jme_adapter *jme)
 
 }
 
+static int
+jme_rxsum_ok(struct jme_adapter *jme, __u16 flags)
+{
+	if(!(flags & (RXWBFLAG_TCPON | RXWBFLAG_UDPON | RXWBFLAG_IPV4)))
+		return false;
+
+	if(unlikely((flags & RXWBFLAG_TCPON) &&
+	!(flags & RXWBFLAG_TCPCS))) {
+		csum_dbg(jme->dev->name, "TCP Checksum error.\n");
+		goto out_sumerr;
+	}
+
+	if(unlikely((flags & RXWBFLAG_UDPON) &&
+	!(flags & RXWBFLAG_UDPCS))) {
+		csum_dbg(jme->dev->name, "UDP Checksum error.\n");
+		goto out_sumerr;
+	}
+
+	if(unlikely((flags & RXWBFLAG_IPV4) &&
+	!(flags & RXWBFLAG_IPCS))) {
+		csum_dbg(jme->dev->name, "IPv4 Checksum error.\n");
+		goto out_sumerr;
+	}
+
+	return true;
+
+out_sumerr:
+	csum_dbg(jme->dev->name, "%s%s%s%s\n",
+		(flags & RXWBFLAG_IPV4)?"IPv4 ":"",
+		(flags & RXWBFLAG_IPV6)?"IPv6 ":"",
+		(flags & RXWBFLAG_UDPON)?"UDP ":"",
+		(flags & RXWBFLAG_TCPON)?"TCP":"");
+	return false;
+}
+
 static void
-jme_alloc_and_feed_skb(struct jme_adapter *jme, int idx, int summed)
+jme_alloc_and_feed_skb(struct jme_adapter *jme, int idx)
 {
 	struct jme_ring *rxring = &(jme->rxring[0]);
 	volatile struct rxdesc *rxdesc = rxring->desc;
@@ -943,14 +878,29 @@ jme_alloc_and_feed_skb(struct jme_adapter *jme, int idx, int summed)
 		skb_put(skb, framesize);
 		skb->protocol = eth_type_trans(skb, jme->dev);
 
-		if(summed)
+		if(jme_rxsum_ok(jme, rxdesc->descwb.flags))
 			skb->ip_summed = CHECKSUM_UNNECESSARY;
 		else
 			skb->ip_summed = CHECKSUM_NONE;
 
-		netif_rx(skb);
 
-		if(le16_to_cpu(rxdesc->descwb.flags) & RXWBFLAG_DEST_MUL)
+		if(rxdesc->descwb.flags & RXWBFLAG_TAGON) {
+			vlan_dbg(jme->dev->name, "VLAN: %04x\n",
+					rxdesc->descwb.vlan);
+			if(jme->vlgrp) {
+				vlan_dbg(jme->dev->name,
+					"VLAN Passed to kernel.\n");
+				jme->jme_vlan_rx(skb, jme->vlgrp,
+					le32_to_cpu(rxdesc->descwb.vlan));
+				NET_STAT(jme).rx_bytes += 4;
+			}
+		}
+		else {
+			jme->jme_rx(skb);
+		}
+
+		if((le16_to_cpu(rxdesc->descwb.flags) & RXWBFLAG_DEST) ==
+				RXWBFLAG_DEST_MUL)
 			++(NET_STAT(jme).multicast);
 
 		jme->dev->last_rx = jiffies;
@@ -962,37 +912,25 @@ jme_alloc_and_feed_skb(struct jme_adapter *jme, int idx, int summed)
 
 }
 
-static int
-jme_rxsum_bad(struct jme_adapter *jme, __u16 flags)
-{
-	if(unlikely((flags & RXWBFLAG_TCPON) &&
-	!(flags & RXWBFLAG_TCPCS))) {
-		csum_dbg(jme->dev->name, "TCP Checksum error.\n");
-		return 1;
-	}
-	else if(unlikely((flags & RXWBFLAG_UDPON) &&
-	!(flags & RXWBFLAG_UDPCS))) {
-		csum_dbg(jme->dev->name, "UDP Checksum error.\n");
-		return 1;
-	}
-	else if(unlikely((flags & RXWBFLAG_IPV4) &&
-	!(flags & RXWBFLAG_IPCS))) {
-		csum_dbg(jme->dev->name, "IPV4 Checksum error.\n");
-		return 1;
-	}
-	else {
-		return 0;
-	}
-}
+
 
 static int
 jme_process_receive(struct jme_adapter *jme, int limit)
 {
 	struct jme_ring *rxring = &(jme->rxring[0]);
 	volatile struct rxdesc *rxdesc = rxring->desc;
-	int i, j, ccnt, desccnt;
+	int i, j, ccnt, desccnt, mask = jme->rx_ring_mask;
 
-	i = rxring->next_to_clean;
+	if(unlikely(!atomic_dec_and_test(&jme->rx_cleaning)))
+		goto out_inc;
+
+	if(unlikely(atomic_read(&jme->link_changing) != 1))
+		goto out_inc;
+
+	if(unlikely(!netif_carrier_ok(jme->dev)))
+		goto out_inc;
+
+	i = atomic_read(&rxring->next_to_clean);
 	while( limit-- > 0 )
 	{
 		rxdesc = rxring->desc;
@@ -1007,8 +945,7 @@ jme_process_receive(struct jme_adapter *jme, int limit)
 		rx_dbg(jme->dev->name, "RX: Cleaning %d\n", i);
 
 		if(unlikely(desccnt > 1 ||
-		rxdesc->descwb.errstat & RXWBERR_ALLERR ||
-		jme_rxsum_bad(jme, rxdesc->descwb.flags))) {
+		rxdesc->descwb.errstat & RXWBERR_ALLERR)) {
 
 			if(rxdesc->descwb.errstat & RXWBERR_CRCERR)
 				++(NET_STAT(jme).rx_crc_errors);
@@ -1027,31 +964,28 @@ jme_process_receive(struct jme_adapter *jme, int limit)
 
 			for(j = i, ccnt = desccnt ; ccnt-- ; ) {
 				jme_set_clean_rxdesc(jme, j);
-
-				if(unlikely(++j == RING_DESC_NR))
-					j = 0;
+				j = (j + 1) & (mask);
 			}
 
 		}
 		else {
-			jme_alloc_and_feed_skb(jme, i,
-				(rxdesc->descwb.flags &
-					(RXWBFLAG_TCPON |
-					RXWBFLAG_UDPON |
-					RXWBFLAG_IPV4)));
+			jme_alloc_and_feed_skb(jme, i);
 		}
 
-		if((i += desccnt) >= RING_DESC_NR)
-			i -= RING_DESC_NR;
+		i = (i + desccnt) & (mask);
 	}
 
+
 out:
 	rx_dbg(jme->dev->name, "RX: Stop at %d\n", i);
 	rx_dbg(jme->dev->name, "RX: RXNDA offset %d\n",
 		(jread32(jme, JME_RXNDA) - jread32(jme, JME_RXDBA_LO))
 			>> 4);
 
-	rxring->next_to_clean = i;
+	atomic_set(&rxring->next_to_clean, i);
+
+out_inc:
+	atomic_inc(&jme->rx_cleaning);
 
 	return limit > 0 ? limit : 0;
 
@@ -1060,8 +994,10 @@ out:
 static void
 jme_attempt_pcc(struct dynpcc_info *dpi, int atmp)
 {
-	if(likely(atmp == dpi->cur))
+	if(likely(atmp == dpi->cur)) {
+		dpi->cnt = 0;
 		return;
+	}
 
 	if(dpi->attempt == atmp) {
 		++(dpi->cnt);
@@ -1080,13 +1016,13 @@ jme_dynamic_pcc(struct jme_adapter *jme)
 
 	if((NET_STAT(jme).rx_bytes - dpi->last_bytes) > PCC_P3_THRESHOLD)
 		jme_attempt_pcc(dpi, PCC_P3);
-	else if((NET_STAT(jme).rx_bytes - dpi->last_bytes) > PCC_P2_THRESHOLD
+	else if((NET_STAT(jme).rx_packets - dpi->last_pkts) > PCC_P2_THRESHOLD
 	|| dpi->intr_cnt > PCC_INTR_THRESHOLD)
 		jme_attempt_pcc(dpi, PCC_P2);
 	else
 		jme_attempt_pcc(dpi, PCC_P1);
 
-	if(unlikely(dpi->attempt != dpi->cur && dpi->cnt > 20)) {
+	if(unlikely(dpi->attempt != dpi->cur && dpi->cnt > 5)) {
 		jme_set_rx_pcc(jme, dpi->attempt);
 		dpi->cur = dpi->attempt;
 		dpi->cnt = 0;
@@ -1104,7 +1040,7 @@ jme_start_pcc_timer(struct jme_adapter *jme)
 		TMCSR_EN | ((0xFFFFFF - PCC_INTERVAL_US) & TMCSR_CNT));
 }
 
-static void
+__always_inline static void
 jme_stop_pcc_timer(struct jme_adapter *jme)
 {
 	jwrite32(jme, JME_TMCSR, 0);
@@ -1117,17 +1053,31 @@ jme_pcc_tasklet(unsigned long arg)
 	struct net_device *netdev = jme->dev;
 
 
-	if(unlikely(netif_queue_stopped(netdev) ||
+	if(unlikely(!netif_carrier_ok(netdev) ||
 		(atomic_read(&jme->link_changing) != 1)
 	)) {
 		jme_stop_pcc_timer(jme);
 		return;
 	}
 
-	jme_dynamic_pcc(jme);
+	if(!(jme->flags & JME_FLAG_POLL))
+		jme_dynamic_pcc(jme);
+
 	jme_start_pcc_timer(jme);
 }
 
+__always_inline static void
+jme_polling_mode(struct jme_adapter *jme)
+{
+	jme_set_rx_pcc(jme, PCC_OFF);
+}
+
+__always_inline static void
+jme_interrupt_mode(struct jme_adapter *jme)
+{
+	jme_set_rx_pcc(jme, PCC_P1);
+}
+
 static void
 jme_link_change_tasklet(unsigned long arg)
 {
@@ -1159,6 +1109,9 @@ jme_link_change_tasklet(unsigned long arg)
 		jme_reset_mac_processor(jme);
 		jme_free_rx_resources(jme);
 		jme_free_tx_resources(jme);
+
+		if(jme->flags & JME_FLAG_POLL)
+			jme_polling_mode(jme);
 	}
 
 	jme_check_link(netdev, 0);
@@ -1184,6 +1137,10 @@ jme_link_change_tasklet(unsigned long arg)
 		jme_enable_tx_engine(jme);
 
 		netif_start_queue(netdev);
+
+		if(jme->flags & JME_FLAG_POLL)
+			jme_interrupt_mode(jme);
+
 		jme_start_pcc_timer(jme);
 	}
 
@@ -1201,20 +1158,34 @@ jme_rx_clean_tasklet(unsigned long arg)
 	struct jme_adapter *jme = (struct jme_adapter*)arg;
 	struct dynpcc_info *dpi = &(jme->dpi);
 
-	if(unlikely(!atomic_dec_and_test(&jme->rx_cleaning)))
-		goto out;
-	
-	if(unlikely(atomic_read(&jme->link_changing) != 1))
-		goto out;
+	jme_process_receive(jme, jme->rx_ring_size);
+	++(dpi->intr_cnt);
 
-	if(unlikely(netif_queue_stopped(jme->dev)))
-		goto out;
+}
 
-	jme_process_receive(jme, RING_DESC_NR);
-	++(dpi->intr_cnt);
+static int
+jme_poll(JME_NAPI_HOLDER(holder), JME_NAPI_WEIGHT(budget))
+{
+	struct jme_adapter *jme = jme_napi_priv(holder);
+	struct net_device *netdev = jme->dev;
+	int rest;
 
-out:
-	atomic_inc(&jme->rx_cleaning);
+	rest = jme_process_receive(jme, JME_NAPI_WEIGHT_VAL(budget));
+
+	while(atomic_read(&jme->rx_empty) > 0) {
+		atomic_dec(&jme->rx_empty);
+		++(NET_STAT(jme).rx_dropped);
+		jme_restart_rx_engine(jme);
+	}
+	atomic_inc(&jme->rx_empty);
+
+	if(rest) {
+		JME_RX_COMPLETE(netdev, holder);
+		jme_interrupt_mode(jme);
+	}
+
+	JME_NAPI_WEIGHT_SET(budget, rest);
+	return JME_NAPI_WEIGHT_VAL(budget) - rest;
 }
 
 static void
@@ -1225,13 +1196,35 @@ jme_rx_empty_tasklet(unsigned long arg)
 	if(unlikely(atomic_read(&jme->link_changing) != 1))
 		return;
 
-	if(unlikely(netif_queue_stopped(jme->dev)))
+	if(unlikely(!netif_carrier_ok(jme->dev)))
 		return;
 
-	queue_dbg(jme->dev->name, "RX Queue empty!\n");
+	queue_dbg(jme->dev->name, "RX Queue Full!\n");
 
 	jme_rx_clean_tasklet(arg);
-	jme_restart_rx_engine(jme);
+
+	while(atomic_read(&jme->rx_empty) > 0) {
+		atomic_dec(&jme->rx_empty);
+		++(NET_STAT(jme).rx_dropped);
+		jme_restart_rx_engine(jme);
+	}
+	atomic_inc(&jme->rx_empty);
+}
+
+static void
+jme_wake_queue_if_stopped(struct jme_adapter *jme)
+{
+	struct jme_ring *txring = jme->txring;
+
+	smp_wmb();
+	if(unlikely(netif_queue_stopped(jme->dev) &&
+	atomic_read(&txring->nr_free) >= (jme->tx_wake_threshold))) {
+
+		queue_dbg(jme->dev->name, "TX Queue Waked.\n");
+		netif_wake_queue(jme->dev);
+
+	}
+
 }
 
 static void
@@ -1241,7 +1234,7 @@ jme_tx_clean_tasklet(unsigned long arg)
 	struct jme_ring *txring = &(jme->txring[0]);
 	volatile struct txdesc *txdesc = txring->desc;
 	struct jme_buffer_info *txbi = txring->bufinf, *ctxbi, *ttxbi;
-	int i, j, cnt = 0, max, err;
+	int i, j, cnt = 0, max, err, mask;
 
 	if(unlikely(!atomic_dec_and_test(&jme->tx_cleaning)))
 		goto out;
@@ -1249,18 +1242,20 @@ jme_tx_clean_tasklet(unsigned long arg)
 	if(unlikely(atomic_read(&jme->link_changing) != 1))
 		goto out;
 
-	if(unlikely(netif_queue_stopped(jme->dev)))
+	if(unlikely(!netif_carrier_ok(jme->dev)))
 		goto out;
 
-	max = RING_DESC_NR - atomic_read(&txring->nr_free);
+	max = jme->tx_ring_size - atomic_read(&txring->nr_free);
+	mask = jme->tx_ring_mask;
 
 	tx_dbg(jme->dev->name, "Tx Tasklet: In\n");
 
-	for(i = txring->next_to_clean ; cnt < max ; ) {
+	for(i = atomic_read(&txring->next_to_clean) ; cnt < max ; ) {
 
 		ctxbi = txbi + i;
 
-		if(ctxbi->skb && !(txdesc[i].descwb.flags & TXWBFLAG_OWN)) {
+		if(likely(ctxbi->skb &&
+		!(txdesc[i].descwb.flags & TXWBFLAG_OWN))) {
 
 			err = txdesc[i].descwb.flags & TXWBFLAG_ALLERR;
 
@@ -1269,45 +1264,46 @@ jme_tx_clean_tasklet(unsigned long arg)
 				i, ctxbi->nr_desc);
 
 			for(j = 1 ; j < ctxbi->nr_desc ; ++j) {
-				ttxbi = txbi + ((i + j) & (RING_DESC_NR - 1));
-				txdesc[(i+j)&(RING_DESC_NR-1)].dw[0] = 0;
+				ttxbi = txbi + ((i + j) & (mask));
+				txdesc[(i + j) & (mask)].dw[0] = 0;
 
-				pci_unmap_single(jme->pdev,
+				pci_unmap_page(jme->pdev,
 						 ttxbi->mapping,
 						 ttxbi->len,
 						 PCI_DMA_TODEVICE);
 
-				if(likely(!err))
-					NET_STAT(jme).tx_bytes += ttxbi->len;
-
 				ttxbi->mapping = 0;
 				ttxbi->len = 0;
 			}
 
 			dev_kfree_skb(ctxbi->skb);
-			ctxbi->skb = NULL;
 
 			cnt += ctxbi->nr_desc;
 
 			if(unlikely(err))
 				++(NET_STAT(jme).tx_carrier_errors);
-			else
+			else {
 				++(NET_STAT(jme).tx_packets);
+				NET_STAT(jme).tx_bytes += ctxbi->len;
+			}
+
+			ctxbi->skb = NULL;
+			ctxbi->len = 0;
+			ctxbi->start_xmit = 0;
 		}
 		else {
 			if(!ctxbi->skb)
 				tx_dbg(jme->dev->name,
 					"Tx Tasklet:"
-					" Stoped due to no skb.\n");
+					" Stopped due to no skb.\n");
 			else
 				tx_dbg(jme->dev->name,
 					"Tx Tasklet:"
-					"Stoped due to not done.\n");
+					"Stopped due to not done.\n");
 			break;
 		}
 
-		if(unlikely((i += ctxbi->nr_desc) >= RING_DESC_NR))
-			i -= RING_DESC_NR;
+		i = (i + ctxbi->nr_desc) & mask;
 
 		ctxbi->nr_desc = 0;
 	}
@@ -1315,10 +1311,12 @@ jme_tx_clean_tasklet(unsigned long arg)
 	tx_dbg(jme->dev->name,
 		"Tx Tasklet: Stop %d Jiffies %lu\n",
 		i, jiffies);
-	txring->next_to_clean = i;
 
+	atomic_set(&txring->next_to_clean, i);
 	atomic_add(cnt, &txring->nr_free);
 
+	jme_wake_queue_if_stopped(jme);
+
 out:
 	atomic_inc(&jme->tx_cleaning);
 }
@@ -1344,20 +1342,28 @@ jme_intr_msi(struct jme_adapter *jme, __u32 intrstat)
 	if(intrstat & INTR_TMINTR)
 		tasklet_schedule(&jme->pcc_task);
 
-	if(intrstat & INTR_RX0EMP)
-		tasklet_schedule(&jme->rxempty_task);
-
-	if(intrstat & (INTR_PCCRX0TO | INTR_PCCRX0))
-		tasklet_schedule(&jme->rxclean_task);
-
 	if(intrstat & (INTR_PCCTXTO | INTR_PCCTX))
 		tasklet_schedule(&jme->txclean_task);
 
-        if((intrstat & ~INTR_ENABLE) != 0) {
-		/*
-		 * Some interrupt not handled
-		 * but not enabled also (for debug)
-		 */
+	if(jme->flags & JME_FLAG_POLL) {
+		if(intrstat & INTR_RX0EMP)
+			atomic_inc(&jme->rx_empty);
+
+		if((intrstat & (INTR_PCCRX0TO | INTR_PCCRX0 | INTR_RX0EMP))) {
+			if(likely(JME_RX_SCHEDULE_PREP(jme))) {
+				jme_polling_mode(jme);
+				JME_RX_SCHEDULE(jme);
+			}
+		}
+	}
+	else {
+		if(intrstat & INTR_RX0EMP) {
+			atomic_inc(&jme->rx_empty);
+			tasklet_schedule(&jme->rxempty_task);
+		}
+
+		if(intrstat & (INTR_PCCRX0TO | INTR_PCCRX0))
+			tasklet_schedule(&jme->rxclean_task);
 	}
 
 out_reenable:
@@ -1418,7 +1424,6 @@ jme_msi(int irq, void *dev_id)
 static void
 jme_reset_link(struct jme_adapter *jme)
 {
-	jme->phylink = 0;
 	jwrite32(jme, JME_TMCSR, TMCSR_SWIT);
 }
 
@@ -1453,7 +1458,7 @@ jme_request_irq(struct jme_adapter *jme)
                           netdev);
         if(rc) {
                 jeprintk(netdev->name,
-			"Unable to allocate %s interrupt (return: %d)\n",
+			"Unable to request %s interrupt (return: %d)\n",
 			jme->flags & JME_FLAG_MSI ? "MSI":"INTx", rc);
 
                 if(jme->flags & JME_FLAG_MSI) {
@@ -1483,7 +1488,7 @@ static int
 jme_open(struct net_device *netdev)
 {
 	struct jme_adapter *jme = netdev_priv(netdev);
-	int rc, timeout = 100;
+	int rc, timeout = 10;
 
 	while(
 		--timeout > 0 &&
@@ -1493,14 +1498,16 @@ jme_open(struct net_device *netdev)
 		atomic_read(&jme->tx_cleaning) != 1
 		)
 	)
-		msleep(10);
+		msleep(1);
 
 	if(!timeout) {
 		rc = -EBUSY;
 		goto err_out;
 	}
 
+	jme_clear_pm(jme);
 	jme_reset_mac_processor(jme);
+	JME_NAPI_ENABLE(jme);
 
 	rc = jme_request_irq(jme);
 	if(rc)
@@ -1508,6 +1515,12 @@ jme_open(struct net_device *netdev)
 
 	jme_enable_shadow(jme);
 	jme_start_irq(jme);
+
+	if(jme->flags & JME_FLAG_SSET)
+		jme_set_settings(netdev, &jme->old_ecmd);
+	else
+		jme_reset_phy_processor(jme);
+
 	jme_reset_link(jme);
 
 	return 0;
@@ -1518,10 +1531,36 @@ err_out:
 	return rc;
 }
 
-static int
-jme_close(struct net_device *netdev)
+static void
+jme_set_100m_half(struct jme_adapter *jme)
 {
-	struct jme_adapter *jme = netdev_priv(netdev);
+	__u32 bmcr, tmp;
+
+	bmcr = jme_mdio_read(jme->dev, jme->mii_if.phy_id, MII_BMCR);
+	tmp = bmcr & ~(BMCR_ANENABLE | BMCR_SPEED100 |
+		       BMCR_SPEED1000 | BMCR_FULLDPLX);
+	tmp |= BMCR_SPEED100;
+
+	if (bmcr != tmp)
+		jme_mdio_write(jme->dev, jme->mii_if.phy_id, MII_BMCR, tmp);
+
+	if(jme->fpgaver)
+		jwrite32(jme, JME_GHC, GHC_SPEED_100M | GHC_LINK_POLL);
+	else
+		jwrite32(jme, JME_GHC, GHC_SPEED_100M);
+}
+
+static void
+jme_phy_off(struct jme_adapter *jme)
+{
+	jme_mdio_write(jme->dev, jme->mii_if.phy_id, MII_BMCR, BMCR_PDOWN);
+}
+
+
+static int
+jme_close(struct net_device *netdev)
+{
+	struct jme_adapter *jme = netdev_priv(netdev);
 
 	netif_stop_queue(netdev);
 	netif_carrier_off(netdev);
@@ -1530,6 +1569,8 @@ jme_close(struct net_device *netdev)
 	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);
@@ -1538,10 +1579,252 @@ jme_close(struct net_device *netdev)
 	jme_reset_mac_processor(jme);
 	jme_free_rx_resources(jme);
 	jme_free_tx_resources(jme);
+	jme->phylink = 0;
+	jme_phy_off(jme);
+
+	return 0;
+}
+
+static int
+jme_alloc_txdesc(struct jme_adapter *jme,
+			struct sk_buff *skb)
+{
+	struct jme_ring *txring = jme->txring;
+	int idx, nr_alloc, mask = jme->tx_ring_mask;
+
+	idx = txring->next_to_use;
+	nr_alloc = skb_shinfo(skb)->nr_frags + 2;
+
+	if(unlikely(atomic_read(&txring->nr_free) < nr_alloc))
+		return -1;
+
+	atomic_sub(nr_alloc, &txring->nr_free);
+
+	txring->next_to_use = (txring->next_to_use + nr_alloc) & mask;
+
+	return idx;
+}
+
+static void
+jme_fill_tx_map(struct pci_dev *pdev,
+		volatile struct txdesc *txdesc,
+		struct jme_buffer_info *txbi,
+		struct page *page,
+		__u32 page_offset,
+		__u32 len,
+		__u8 hidma)
+{
+	dma_addr_t dmaaddr;
+
+	dmaaddr = pci_map_page(pdev,
+				page,
+				page_offset,
+				len,
+				PCI_DMA_TODEVICE);
+
+	pci_dma_sync_single_for_device(pdev,
+				       dmaaddr,
+				       len,
+				       PCI_DMA_TODEVICE);
+
+	txdesc->dw[0] = 0;
+	txdesc->dw[1] = 0;
+	txdesc->desc2.flags	= TXFLAG_OWN;
+	txdesc->desc2.flags	|= (hidma)?TXFLAG_64BIT:0;
+	txdesc->desc2.datalen	= cpu_to_le16(len);
+	txdesc->desc2.bufaddrh	= cpu_to_le32((__u64)dmaaddr >> 32);
+	txdesc->desc2.bufaddrl	= cpu_to_le32(
+					(__u64)dmaaddr & 0xFFFFFFFFUL);
+
+	txbi->mapping = dmaaddr;
+	txbi->len = len;
+}
+
+static void
+jme_map_tx_skb(struct jme_adapter *jme, struct sk_buff *skb, int idx)
+{
+	struct jme_ring *txring = jme->txring;
+	volatile struct txdesc *txdesc = txring->desc, *ctxdesc;
+	struct jme_buffer_info *txbi = txring->bufinf, *ctxbi;
+	__u8 hidma = jme->dev->features & NETIF_F_HIGHDMA;
+	int i, nr_frags = skb_shinfo(skb)->nr_frags;
+	int mask = jme->tx_ring_mask;
+	struct skb_frag_struct *frag;
+	__u32 len;
+
+	for(i = 0 ; i < nr_frags ; ++i) {
+                frag = &skb_shinfo(skb)->frags[i];
+		ctxdesc = txdesc + ((idx + i + 2) & (mask));
+		ctxbi = txbi + ((idx + i + 2) & (mask));
+
+		jme_fill_tx_map(jme->pdev, ctxdesc, ctxbi, frag->page,
+				 frag->page_offset, frag->size, hidma);
+	}
+
+	len = skb_is_nonlinear(skb)?skb_headlen(skb):skb->len;
+	ctxdesc = txdesc + ((idx + 1) & (mask));
+	ctxbi = txbi + ((idx + 1) & (mask));
+	jme_fill_tx_map(jme->pdev, ctxdesc, ctxbi, virt_to_page(skb->data),
+			offset_in_page(skb->data), len, hidma);
+
+}
+
+static int
+jme_expand_header(struct jme_adapter *jme, struct sk_buff *skb)
+{
+	if(unlikely(skb_shinfo(skb)->gso_size &&
+			skb_header_cloned(skb) &&
+			pskb_expand_head(skb, 0, 0, GFP_ATOMIC))) {
+		dev_kfree_skb(skb);
+		return -1;
+	}
+
+	return 0;
+}
+
+static int
+jme_tx_tso(struct sk_buff *skb,
+		volatile __u16 *mss, __u8 *flags)
+{
+	if((*mss = (skb_shinfo(skb)->gso_size << TXDESC_MSS_SHIFT))) {
+		*flags |= TXFLAG_LSEN;
+
+		if(skb->protocol == __constant_htons(ETH_P_IP)) {
+			struct iphdr *iph = ip_hdr(skb);
+
+			iph->check = 0;
+                        tcp_hdr(skb)->check = ~csum_tcpudp_magic(iph->saddr,
+								iph->daddr, 0,
+								IPPROTO_TCP,
+								0);
+		}
+		else {
+			struct ipv6hdr *ip6h = ipv6_hdr(skb);
+
+                        tcp_hdr(skb)->check = ~csum_ipv6_magic(&ip6h->saddr,
+								&ip6h->daddr, 0,
+								IPPROTO_TCP,
+								0);
+		}
+
+		return 0;
+	}
+
+	return 1;
+}
+
+static void
+jme_tx_csum(struct sk_buff *skb, __u8 *flags)
+{
+	if(skb->ip_summed == CHECKSUM_PARTIAL) {
+		__u8 ip_proto;
+
+		switch (skb->protocol) {
+		case __constant_htons(ETH_P_IP):
+			ip_proto = ip_hdr(skb)->protocol;
+			break;
+		case __constant_htons(ETH_P_IPV6):
+			ip_proto = ipv6_hdr(skb)->nexthdr;
+			break;
+		default:
+			ip_proto = 0;
+			break;
+		}
+
+		switch(ip_proto) {
+		case IPPROTO_TCP:
+			*flags |= TXFLAG_TCPCS;
+			break;
+		case IPPROTO_UDP:
+			*flags |= TXFLAG_UDPCS;
+			break;
+		default:
+			jeprintk("jme", "Error upper layer protocol.\n");
+			break;
+		}
+	}
+}
+
+__always_inline static void
+jme_tx_vlan(struct sk_buff *skb, volatile __u16 *vlan, __u8 *flags)
+{
+	if(vlan_tx_tag_present(skb)) {
+		vlan_dbg("jme", "Tag found!(%04x)\n", vlan_tx_tag_get(skb));
+		*flags |= TXFLAG_TAGON;
+		*vlan = vlan_tx_tag_get(skb);
+	}
+}
+
+static int
+jme_fill_first_tx_desc(struct jme_adapter *jme, struct sk_buff *skb, int idx)
+{
+	struct jme_ring *txring = jme->txring;
+	volatile struct txdesc *txdesc;
+	struct jme_buffer_info *txbi;
+	__u8 flags;
+
+	txdesc = (volatile struct txdesc*)txring->desc + idx;
+	txbi = txring->bufinf + idx;
+
+	txdesc->dw[0] = 0;
+	txdesc->dw[1] = 0;
+	txdesc->dw[2] = 0;
+	txdesc->dw[3] = 0;
+	txdesc->desc1.pktsize = cpu_to_le16(skb->len);
+	/*
+	 * Set OWN bit at final.
+	 * When kernel transmit faster than NIC.
+	 * And NIC trying to send this descriptor before we tell
+	 * it to start sending this TX queue.
+	 * Other fields are already filled correctly.
+	 */
+	wmb();
+	flags = TXFLAG_OWN | TXFLAG_INT;
+	//Set checksum flags while not tso
+	if(jme_tx_tso(skb, &txdesc->desc1.mss, &flags))
+		jme_tx_csum(skb, &flags);
+	jme_tx_vlan(skb, &txdesc->desc1.vlan, &flags);
+	txdesc->desc1.flags = flags;
+	/*
+	 * Set tx buffer info after telling NIC to send
+	 * For better tx_clean timing
+	 */
+	wmb();
+	txbi->nr_desc = skb_shinfo(skb)->nr_frags + 2;
+	txbi->skb = skb;
+	txbi->len = skb->len;
+	if(!(txbi->start_xmit = jiffies))
+		txbi->start_xmit = (0UL-1);
 
 	return 0;
 }
 
+static void
+jme_stop_queue_if_full(struct jme_adapter *jme)
+{
+	struct jme_ring *txring = jme->txring;
+        struct jme_buffer_info *txbi = txring->bufinf;
+
+	txbi += atomic_read(&txring->next_to_clean);
+
+	smp_wmb();
+	if(unlikely(atomic_read(&txring->nr_free) < (MAX_SKB_FRAGS+2))) {
+		netif_stop_queue(jme->dev);
+		queue_dbg(jme->dev->name, "TX Queue Paused.\n");
+		smp_wmb();
+		if (atomic_read(&txring->nr_free) >= (jme->tx_wake_threshold)) {
+			netif_wake_queue(jme->dev);
+			queue_dbg(jme->dev->name, "TX Queue Fast Waked.\n");
+		}
+	}
+
+	if(unlikely(	txbi->start_xmit &&
+			(jiffies - txbi->start_xmit) >= TX_TIMEOUT &&
+			txbi->skb)) {
+		netif_stop_queue(jme->dev);
+	}
+}
+
 /*
  * This function is already protected by netif_tx_lock()
  */
@@ -1549,25 +1832,36 @@ static int
 jme_start_xmit(struct sk_buff *skb, struct net_device *netdev)
 {
         struct jme_adapter *jme = netdev_priv(netdev);
-	int rc;
+	int idx;
 
-	if(unlikely(netif_queue_stopped(jme->dev)))
-		return NETDEV_TX_BUSY;
-
-#if 0
-/*Testing*/
-	("jme", "Frags: %d Headlen: %d Len: %d Sum:%d\n", 
-		skb_shinfo(skb)->nr_frags,
-		skb_headlen(skb),
-		skb->len,
-		skb->ip_summed);
-/*********/
-#endif
+	if(skb_shinfo(skb)->nr_frags) {
+		tx_dbg(netdev->name, "Frags: %d Headlen: %d Len: %d MSS: %d Sum:%d\n",
+			skb_shinfo(skb)->nr_frags,
+			skb_headlen(skb),
+			skb->len,
+			skb_shinfo(skb)->gso_size,
+			skb->ip_summed);
+	}
+
+	if(unlikely(jme_expand_header(jme, skb))) {
+		++(NET_STAT(jme).tx_dropped);
+		return NETDEV_TX_OK;
+	}
+
+	idx = jme_alloc_txdesc(jme, skb);
+
+	if(unlikely(idx<0)) {
+		netif_stop_queue(netdev);
+		jeprintk(netdev->name,
+				"BUG! Tx ring full when queue awake!\n");
+
+                return NETDEV_TX_BUSY;
+	}
 
-	rc = jme_set_new_txdesc(jme, skb);
+	jme_map_tx_skb(jme, skb, idx);
+	jme_fill_first_tx_desc(jme, skb, idx);
 
-	if(unlikely(rc != NETDEV_TX_OK))
-		return rc;
+	tx_dbg(jme->dev->name, "Xmit: %d+%d\n", idx, skb_shinfo(skb)->nr_frags + 2);
 
 	jwrite32(jme, JME_TXCS, jme->reg_txcs |
 				TXCS_SELECT_QUEUE0 |
@@ -1575,6 +1869,8 @@ jme_start_xmit(struct sk_buff *skb, struct net_device *netdev)
 				TXCS_ENABLE);
 	netdev->trans_start = jiffies;
 
+	jme_stop_queue_if_full(jme);
+
         return NETDEV_TX_OK;
 }
 
@@ -1591,13 +1887,13 @@ jme_set_macaddr(struct net_device *netdev, void *p)
 	spin_lock(&jme->macaddr_lock);
 	memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
 
-	val = addr->sa_data[3] << 24 |
-	      addr->sa_data[2] << 16 |
-	      addr->sa_data[1] <<  8 |
-	      addr->sa_data[0];
+	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] << 8 |
-	      addr->sa_data[4];
+	val = (addr->sa_data[5] & 0xff) << 8 |
+	      (addr->sa_data[4] & 0xff);
 	jwrite32(jme, JME_RXUMA_HI, val);
 	spin_unlock(&jme->macaddr_lock);
 
@@ -1654,7 +1950,7 @@ jme_change_mtu(struct net_device *netdev, int new_mtu)
 		return 0;
 
         if (((new_mtu + ETH_HLEN) > MAX_ETHERNET_JUMBO_PACKET_SIZE) ||
-                ((new_mtu + ETH_HLEN) < MIN_ETHERNET_PACKET_SIZE))
+                ((new_mtu) < IPV6_MIN_MTU))
                 return -EINVAL;
 
 	if(new_mtu > 4000) {
@@ -1669,10 +1965,15 @@ jme_change_mtu(struct net_device *netdev, int new_mtu)
 	}
 
 	if(new_mtu > 1900) {
-		netdev->features &= ~NETIF_F_HW_CSUM;
+		netdev->features &= ~(NETIF_F_HW_CSUM |
+				NETIF_F_TSO |
+				NETIF_F_TSO6);
 	}
 	else {
-		netdev->features |= NETIF_F_HW_CSUM;
+		if(jme->flags & JME_FLAG_TXCSUM)
+			netdev->features |= NETIF_F_HW_CSUM;
+		if(jme->flags & JME_FLAG_TSO)
+			netdev->features |= NETIF_F_TSO | NETIF_F_TSO6;
 	}
 
         netdev->mtu = new_mtu;
@@ -1686,13 +1987,25 @@ jme_tx_timeout(struct net_device *netdev)
 {
         struct jme_adapter *jme = netdev_priv(netdev);
 
+	jme->phylink = 0;
+	jme_reset_phy_processor(jme);
+	if(jme->flags & JME_FLAG_SSET)
+		jme_set_settings(netdev, &jme->old_ecmd);
+
 	/*
-	 * Reset the link
-	 * And the link change will reinitiallize all RX/TX resources
+	 * Force to Reset the link again
 	 */
 	jme_reset_link(jme);
 }
 
+static void
+jme_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp)
+{
+	struct jme_adapter *jme = netdev_priv(netdev);
+
+	jme->vlgrp = grp;
+}
+
 static void
 jme_get_drvinfo(struct net_device *netdev,
 		     struct ethtool_drvinfo *info)
@@ -1707,7 +2020,7 @@ jme_get_drvinfo(struct net_device *netdev,
 static int
 jme_get_regs_len(struct net_device *netdev)
 {
-	return 0x400;
+	return JME_REG_LEN; 
 }
 
 static void
@@ -1717,7 +2030,16 @@ mmapio_memcpy(struct jme_adapter *jme, __u32 *p, __u32 reg, int len)
 
 	for(i = 0 ; i < len ; i += 4)
 		p[i >> 2] = jread32(jme, reg + i);
+}
 
+static void
+mdio_memcpy(struct jme_adapter *jme, __u32 *p, int reg_nr)
+{
+	int i;
+	__u16 *p16 = (__u16*)p;
+
+	for(i = 0 ; i < reg_nr ; ++i)
+		p16[i] = jme_mdio_read(jme->dev, jme->mii_if.phy_id, i);
 }
 
 static void
@@ -1726,7 +2048,7 @@ jme_get_regs(struct net_device *netdev, struct ethtool_regs *regs, void *p)
         struct jme_adapter *jme = netdev_priv(netdev);
 	__u32 *p32 = (__u32*)p;
 
-	memset(p, 0, 0x400);
+	memset(p, 0xFF, JME_REG_LEN);
 
 	regs->version = 1;
 	mmapio_memcpy(jme, p32, JME_MAC, JME_MAC_LEN);
@@ -1740,6 +2062,8 @@ jme_get_regs(struct net_device *netdev, struct ethtool_regs *regs, void *p)
 	p32 += 0x100 >> 2;
 	mmapio_memcpy(jme, p32, JME_RSS, JME_RSS_LEN);
 
+	p32 += 0x100 >> 2;
+	mdio_memcpy(jme, p32, JME_PHY_REG_NR);
 }
 
 static int
@@ -1747,10 +2071,18 @@ jme_get_coalesce(struct net_device *netdev, struct ethtool_coalesce *ecmd)
 {
 	struct jme_adapter *jme = netdev_priv(netdev);
 
-	ecmd->use_adaptive_rx_coalesce = true;
 	ecmd->tx_coalesce_usecs = PCC_TX_TO;
 	ecmd->tx_max_coalesced_frames = PCC_TX_CNT;
 
+	if(jme->flags & JME_FLAG_POLL) {
+		ecmd->use_adaptive_rx_coalesce = false;
+		ecmd->rx_coalesce_usecs = 0;
+		ecmd->rx_max_coalesced_frames = 0;
+		return 0;
+	}
+
+	ecmd->use_adaptive_rx_coalesce = true;
+
 	switch(jme->dpi.cur) {
 	case PCC_P1:
 		ecmd->rx_coalesce_usecs = PCC_P1_TO;
@@ -1771,41 +2103,32 @@ jme_get_coalesce(struct net_device *netdev, struct ethtool_coalesce *ecmd)
 	return 0;
 }
 
-/*
- * It's not actually for coalesce.
- * It changes internell FIFO related setting for testing.
- */
 static int
 jme_set_coalesce(struct net_device *netdev, struct ethtool_coalesce *ecmd)
 {
 	struct jme_adapter *jme = netdev_priv(netdev);
+	struct dynpcc_info *dpi = &(jme->dpi);
 
-	if(ecmd->use_adaptive_rx_coalesce &&
-	ecmd->use_adaptive_tx_coalesce &&
-	ecmd->rx_coalesce_usecs == 250 &&
-	(ecmd->rx_max_coalesced_frames_low == 16 ||
-	ecmd->rx_max_coalesced_frames_low == 32 ||
-	ecmd->rx_max_coalesced_frames_low == 64 ||
-	ecmd->rx_max_coalesced_frames_low == 128)) {
-		jme->reg_rxcs &= ~RXCS_FIFOTHNP;
-		switch(ecmd->rx_max_coalesced_frames_low) {
-		case 16:
-			jme->reg_rxcs |= RXCS_FIFOTHNP_16QW;
-			break;
-		case 32:
-			jme->reg_rxcs |= RXCS_FIFOTHNP_32QW;
-			break;
-		case 64:
-			jme->reg_rxcs |= RXCS_FIFOTHNP_64QW;
-			break;
-		case 128:
-		default:
-			jme->reg_rxcs |= RXCS_FIFOTHNP_128QW;
-		}
-		jme_restart_rx_engine(jme);
-	}
-	else {
-		return -EINVAL;
+	if(netif_running(netdev))
+		return -EBUSY;
+
+	if(ecmd->use_adaptive_rx_coalesce
+	&& (jme->flags & JME_FLAG_POLL)) {
+		jme->flags &= ~JME_FLAG_POLL;
+		jme->jme_rx = netif_rx;
+		jme->jme_vlan_rx = vlan_hwaccel_rx;
+		dpi->cur		= PCC_P1;
+		dpi->attempt		= PCC_P1;
+		dpi->cnt		= 0;
+		jme_set_rx_pcc(jme, PCC_P1);
+		jme_interrupt_mode(jme);
+	}
+	else if(!(ecmd->use_adaptive_rx_coalesce)
+	&& !(jme->flags & JME_FLAG_POLL)) {
+		jme->flags |= JME_FLAG_POLL;
+		jme->jme_rx = netif_receive_skb;
+		jme->jme_vlan_rx = vlan_hwaccel_receive_skb;
+		jme_interrupt_mode(jme);
 	}
 
 	return 0;
@@ -1825,7 +2148,9 @@ jme_get_pauseparam(struct net_device *netdev,
 	spin_lock_irqsave(&jme->phy_lock, flags);
         val = jme_mdio_read(jme->dev, jme->mii_if.phy_id, MII_ADVERTISE);
 	spin_unlock_irqrestore(&jme->phy_lock, flags);
-	ecmd->autoneg = (val & (ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM)) != 0;
+
+	ecmd->autoneg =
+		(val & (ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM)) != 0;
 }
 
 static int
@@ -1862,7 +2187,7 @@ jme_set_pauseparam(struct net_device *netdev,
 
 	spin_lock_irqsave(&jme->phy_lock, flags);
         val = jme_mdio_read(jme->dev, jme->mii_if.phy_id, MII_ADVERTISE);
-	if( ((val & (ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM)) != 0) != 
+	if( ((val & (ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM)) != 0) !=
 		(ecmd->autoneg != 0)) {
 
 		if(ecmd->autoneg)
@@ -1870,7 +2195,8 @@ jme_set_pauseparam(struct net_device *netdev,
 		else
 			val &= ~(ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM);
 
-		jme_mdio_write(jme->dev, jme->mii_if.phy_id, MII_ADVERTISE, val);
+		jme_mdio_write(jme->dev, jme->mii_if.phy_id,
+				MII_ADVERTISE, val);
 	}
 	spin_unlock_irqrestore(&jme->phy_lock, flags);
 
@@ -1916,9 +2242,10 @@ jme_set_wol(struct net_device *netdev,
 	if(wol->wolopts & WAKE_MAGIC)
 		jme->reg_pmcs |= PMCS_MFEN;
 
+
 	return 0;
 }
- 
+
 static int
 jme_get_settings(struct net_device *netdev,
 		     struct ethtool_cmd *ecmd)
@@ -1984,7 +2311,7 @@ jme_set_rx_csum(struct net_device *netdev, u32 on)
 {
         struct jme_adapter *jme = netdev_priv(netdev);
 	unsigned long flags;
-	
+
 	spin_lock_irqsave(&jme->rxmcs_lock, flags);
 	if(on)
 		jme->reg_rxmcs |= RXMCS_CHECKSUM;
@@ -1999,14 +2326,39 @@ jme_set_rx_csum(struct net_device *netdev, u32 on)
 static int
 jme_set_tx_csum(struct net_device *netdev, u32 on)
 {
-	if(on)
-		netdev->features |= NETIF_F_HW_CSUM;
-	else
+        struct jme_adapter *jme = netdev_priv(netdev);
+
+	if(on) {
+		jme->flags |= JME_FLAG_TXCSUM;
+		if(netdev->mtu <= 1900)
+			netdev->features |= NETIF_F_HW_CSUM;
+	}
+	else {
+		jme->flags &= ~JME_FLAG_TXCSUM;
 		netdev->features &= ~NETIF_F_HW_CSUM;
+	}
 
 	return 0;
 }
 
+static int
+jme_set_tso(struct net_device *netdev, u32 on)
+{
+        struct jme_adapter *jme = netdev_priv(netdev);
+
+        if (on) {
+		jme->flags |= JME_FLAG_TSO;
+		if(netdev->mtu <= 1900)
+			netdev->features |= NETIF_F_TSO | NETIF_F_TSO6;
+	}
+        else {
+		jme->flags &= ~JME_FLAG_TSO;
+                netdev->features &= ~(NETIF_F_TSO | NETIF_F_TSO6);
+	}
+
+        return 0;
+}
+
 static int
 jme_nway_reset(struct net_device *netdev)
 {
@@ -2015,6 +2367,124 @@ jme_nway_reset(struct net_device *netdev)
 	return 0;
 }
 
+static __u8
+jme_smb_read(struct jme_adapter *jme, unsigned int addr)
+{
+	__u32 val;
+	int to;
+
+	val = jread32(jme, JME_SMBCSR);
+	to = JME_SMB_BUSY_TIMEOUT;
+	while((val & SMBCSR_BUSY) && --to) {
+		msleep(1);
+		val = jread32(jme, JME_SMBCSR);
+	}
+	if(!to) {
+		jeprintk(jme->dev->name, "SMB Bus Busy.\n");
+		return 0xFF;
+	}
+
+	jwrite32(jme, JME_SMBINTF,
+		((addr << SMBINTF_HWADDR_SHIFT) & SMBINTF_HWADDR) |
+		SMBINTF_HWRWN_READ |
+		SMBINTF_HWCMD);
+
+	val = jread32(jme, JME_SMBINTF);
+	to = JME_SMB_BUSY_TIMEOUT;
+	while((val & SMBINTF_HWCMD) && --to) {
+		msleep(1);
+		val = jread32(jme, JME_SMBINTF);
+	}
+	if(!to) {
+		jeprintk(jme->dev->name, "SMB Bus Busy.\n");
+		return 0xFF;
+	}
+
+	return (val & SMBINTF_HWDATR) >> SMBINTF_HWDATR_SHIFT;
+}
+
+static void
+jme_smb_write(struct jme_adapter *jme, unsigned int addr, __u8 data)
+{
+	__u32 val;
+	int to;
+
+	val = jread32(jme, JME_SMBCSR);
+	to = JME_SMB_BUSY_TIMEOUT;
+	while((val & SMBCSR_BUSY) && --to) {
+		msleep(1);
+		val = jread32(jme, JME_SMBCSR);
+	}
+	if(!to) {
+		jeprintk(jme->dev->name, "SMB Bus Busy.\n");
+		return;
+	}
+
+	jwrite32(jme, JME_SMBINTF,
+		((data << SMBINTF_HWDATW_SHIFT) & SMBINTF_HWDATW) |
+		((addr << SMBINTF_HWADDR_SHIFT) & SMBINTF_HWADDR) |
+		SMBINTF_HWRWN_WRITE |
+		SMBINTF_HWCMD);
+
+	val = jread32(jme, JME_SMBINTF);
+	to = JME_SMB_BUSY_TIMEOUT;
+	while((val & SMBINTF_HWCMD) && --to) {
+		msleep(1);
+		val = jread32(jme, JME_SMBINTF);
+	}
+	if(!to) {
+		jeprintk(jme->dev->name, "SMB Bus Busy.\n");
+		return;
+	}
+
+	mdelay(2);
+}
+
+static int
+jme_get_eeprom_len(struct net_device *netdev)
+{
+        struct jme_adapter *jme = netdev_priv(netdev);
+	__u32 val;
+	val = jread32(jme, JME_SMBCSR);
+	return (val & SMBCSR_EEPROMD)?JME_SMB_LEN:0;
+}
+
+static int
+jme_get_eeprom(struct net_device *netdev,
+		struct ethtool_eeprom *eeprom, u8 *data)
+{
+        struct jme_adapter *jme = netdev_priv(netdev);
+	int i, offset = eeprom->offset, len = eeprom->len;
+
+	/*
+	 * ethtool will check the boundary for us
+	 */
+	eeprom->magic = JME_EEPROM_MAGIC;
+	for(i = 0 ; i < len ; ++i)
+		data[i] = jme_smb_read(jme, i + offset);
+
+	return 0;
+}
+
+static int
+jme_set_eeprom(struct net_device *netdev,
+		struct ethtool_eeprom *eeprom, u8 *data)
+{
+        struct jme_adapter *jme = netdev_priv(netdev);
+	int i, offset = eeprom->offset, len = eeprom->len;
+
+	if (eeprom->magic != JME_EEPROM_MAGIC)
+		return -EINVAL;
+
+	/*
+	 * ethtool will check the boundary for us
+	 */
+	for(i = 0 ; i < len ; ++i)
+		jme_smb_write(jme, i + offset, data[i]);
+
+	return 0;
+}
+
 static const struct ethtool_ops jme_ethtool_ops = {
         .get_drvinfo            = jme_get_drvinfo,
 	.get_regs_len		= jme_get_regs_len,
@@ -2031,34 +2501,72 @@ static const struct ethtool_ops jme_ethtool_ops = {
 	.get_rx_csum		= jme_get_rx_csum,
 	.set_rx_csum		= jme_set_rx_csum,
 	.set_tx_csum		= jme_set_tx_csum,
+	.set_tso		= jme_set_tso,
+	.set_sg			= ethtool_op_set_sg,
 	.nway_reset             = jme_nway_reset,
+	.get_eeprom_len		= jme_get_eeprom_len,
+	.get_eeprom		= jme_get_eeprom,
+	.set_eeprom		= jme_set_eeprom,
 };
 
 static int
 jme_pci_dma64(struct pci_dev *pdev)
 {
         if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK))
-                if(!pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK))
+                if(!pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK)) {
+		    	dprintk("jme", "64Bit DMA Selected.\n");
 			return 1;
+		}
 
         if (!pci_set_dma_mask(pdev, DMA_40BIT_MASK))
-                if(!pci_set_consistent_dma_mask(pdev, DMA_40BIT_MASK))
+                if(!pci_set_consistent_dma_mask(pdev, DMA_40BIT_MASK)) {
+		    	dprintk("jme", "40Bit DMA Selected.\n");
 			return 1;
+		}
 
         if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK))
-                if(!pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK))
+                if(!pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) {
+		    	dprintk("jme", "32Bit DMA Selected.\n");
 			return 0;
+		}
 
 	return -1;
 }
 
+__always_inline static void
+jme_phy_init(struct jme_adapter *jme)
+{
+	__u16 reg26;
+
+	reg26 = jme_mdio_read(jme->dev, jme->mii_if.phy_id, 26);
+	jme_mdio_write(jme->dev, jme->mii_if.phy_id, 26, reg26 | 0x1000);
+}
+
+__always_inline static void
+jme_set_gmii(struct jme_adapter *jme)
+{
+	jme_mdio_write(jme->dev, jme->mii_if.phy_id, 27, 0x0004);
+}
+
+static void
+jme_check_hw_ver(struct jme_adapter *jme)
+{
+	__u32 chipmode;
+
+	chipmode = jread32(jme, JME_CHIPMODE);
+
+	jme->fpgaver = (chipmode & CM_FPGAVER_MASK) >> CM_FPGAVER_SHIFT;
+	jme->chipver = (chipmode & CM_CHIPVER_MASK) >> CM_CHIPVER_SHIFT;
+}
+
 static int __devinit
 jme_init_one(struct pci_dev *pdev,
 	     const struct pci_device_id *ent)
 {
-	int rc = 0, using_dac;
+	int rc = 0, using_dac, i;
 	struct net_device *netdev;
 	struct jme_adapter *jme;
+	__u16 bmcr, bmsr;
 
 	/*
 	 * set up PCI device basics
@@ -2095,6 +2603,7 @@ jme_init_one(struct pci_dev *pdev,
 	 */
 	netdev = alloc_etherdev(sizeof(*jme));
 	if(!netdev) {
+		printk(KERN_ERR PFX "Cannot allocate netdev structure.\n");
 		rc = -ENOMEM;
 		goto err_out_release_regions;
 	}
@@ -2107,8 +2616,14 @@ jme_init_one(struct pci_dev *pdev,
 	netdev->ethtool_ops		= &jme_ethtool_ops;
 	netdev->tx_timeout		= jme_tx_timeout;
 	netdev->watchdog_timeo		= TX_TIMEOUT;
+	netdev->vlan_rx_register	= jme_vlan_rx_register;
 	NETDEV_GET_STATS(netdev, &jme_get_stats);
-	netdev->features		=	NETIF_F_HW_CSUM;
+	netdev->features		=	NETIF_F_HW_CSUM |
+						NETIF_F_SG |
+						NETIF_F_TSO |
+						NETIF_F_TSO6 |
+						NETIF_F_HW_VLAN_TX |
+						NETIF_F_HW_VLAN_RX;
 	if(using_dac)
 		netdev->features	|=	NETIF_F_HIGHDMA;
 
@@ -2121,11 +2636,19 @@ jme_init_one(struct pci_dev *pdev,
 	jme = netdev_priv(netdev);
 	jme->pdev = pdev;
 	jme->dev = netdev;
+	jme->jme_rx = netif_rx;
+	jme->jme_vlan_rx = vlan_hwaccel_rx;
 	jme->old_mtu = netdev->mtu = 1500;
 	jme->phylink = 0;
+	jme->tx_ring_size = 1 << 10;
+	jme->tx_ring_mask = jme->tx_ring_size - 1;
+	jme->tx_wake_threshold = 1 << 9;
+	jme->rx_ring_size = 1 << 9;
+	jme->rx_ring_mask = jme->rx_ring_size - 1;
 	jme->regs = ioremap(pci_resource_start(pdev, 0),
 			     pci_resource_len(pdev, 0));
 	if (!(jme->regs)) {
+		printk(KERN_ERR PFX "Mapping PCI resource region error.\n");
 		rc = -ENOMEM;
 		goto err_out_free_netdev;
 	}
@@ -2133,10 +2656,13 @@ jme_init_one(struct pci_dev *pdev,
 					        sizeof(__u32) * SHADOW_REG_NR,
 					        &(jme->shadow_dma));
 	if (!(jme->shadow_regs)) {
+		printk(KERN_ERR PFX "Allocating shadow register mapping error.\n");
 		rc = -ENOMEM;
 		goto err_out_unmap;
 	}
 
+	NETIF_NAPI_SET(netdev, &jme->napi, jme_poll, jme->rx_ring_size >> 2)
+
 	spin_lock_init(&jme->phy_lock);
 	spin_lock_init(&jme->macaddr_lock);
 	spin_lock_init(&jme->rxmcs_lock);
@@ -2144,6 +2670,7 @@ jme_init_one(struct pci_dev *pdev,
 	atomic_set(&jme->link_changing, 1);
 	atomic_set(&jme->rx_cleaning, 1);
 	atomic_set(&jme->tx_cleaning, 1);
+	atomic_set(&jme->rx_empty, 1);
 
 	tasklet_init(&jme->pcc_task,
 		     &jme_pcc_tasklet,
@@ -2160,19 +2687,18 @@ jme_init_one(struct pci_dev *pdev,
 	tasklet_init(&jme->rxempty_task,
 		     &jme_rx_empty_tasklet,
 		     (unsigned long) jme);
-	jme->mii_if.dev = netdev;
-	jme->mii_if.phy_id = 1;
-	jme->mii_if.supports_gmii = 1;
-	jme->mii_if.mdio_read = jme_mdio_read;
-	jme->mii_if.mdio_write = jme_mdio_write;
-
 	jme->dpi.cur = PCC_P1;
 
-	jme->reg_ghc = GHC_DPX | GHC_SPEED_1000M;
+	if(pdev->device == JME_GE_DEVICE)
+		jme->reg_ghc = GHC_DPX | GHC_SPEED_1000M;
+	else
+		jme->reg_ghc = GHC_DPX | GHC_SPEED_100M;
 	jme->reg_rxcs = RXCS_DEFAULT;
 	jme->reg_rxmcs = RXMCS_DEFAULT;
 	jme->reg_txpfc = 0;
-	jme->reg_pmcs = 0;
+	jme->reg_pmcs = PMCS_LFEN | PMCS_LREN | PMCS_MFEN;
+	jme->flags = JME_FLAG_TXCSUM | JME_FLAG_TSO;
+
 	/*
 	 * Get Max Read Req Size from PCI Config Space
 	 */
@@ -2191,15 +2717,54 @@ jme_init_one(struct pci_dev *pdev,
 
 
 	/*
-	 * Reset MAC processor and reload EEPROM for MAC Address
+	 * Must check before reset_mac_processor
 	 */
+	jme_check_hw_ver(jme);
+	jme->mii_if.dev = netdev;
+	if(jme->fpgaver) {
+		jme->mii_if.phy_id = 0;
+		for(i = 1 ; i < 32 ; ++i) {
+			bmcr = jme_mdio_read(netdev, i, MII_BMCR);
+			bmsr = jme_mdio_read(netdev, i, MII_BMSR);
+			if(bmcr != 0xFFFFU && (bmcr != 0 || bmsr != 0)) {
+				jme->mii_if.phy_id = i;
+				break;
+			}
+		}
+
+		if(!jme->mii_if.phy_id) {
+			rc = -EIO;
+			printk(KERN_ERR PFX "Can not find phy_id.\n");
+			 goto err_out_free_shadow;
+		}
+
+		jme->reg_ghc |= GHC_LINK_POLL;
+	}
+	else {
+		jme->mii_if.phy_id = 1;
+	}
+	if(pdev->device == JME_GE_DEVICE)
+		jme->mii_if.supports_gmii = true;
+	else
+		jme->mii_if.supports_gmii = false;
+	jme->mii_if.mdio_read = jme_mdio_read;
+	jme->mii_if.mdio_write = jme_mdio_write;
+
 	jme_clear_pm(jme);
-	jme_reset_phy_processor(jme);
+	if(jme->fpgaver)
+		jme_set_gmii(jme);
+	else
+		jme_phy_init(jme);
+	jme_phy_off(jme);
+
+	/*
+	 * Reset MAC processor and reload EEPROM for MAC Address
+	 */
 	jme_reset_mac_processor(jme);
 	rc = jme_reload_eeprom(jme);
 	if(rc) {
 		printk(KERN_ERR PFX
-			"Rload eeprom for reading MAC Address error.\n");
+			"Reload eeprom for reading MAC Address error.\n");
 		goto err_out_free_shadow;
 	}
 	jme_load_macaddr(netdev);
@@ -2221,7 +2786,9 @@ jme_init_one(struct pci_dev *pdev,
 	}
 
 	jprintk(netdev->name,
-		"JMC250 gigabit eth %02x:%02x:%02x:%02x:%02x:%02x\n",
+		"JMC250 gigabit%s ver:%u eth %02x:%02x:%02x:%02x:%02x:%02x\n",
+		(jme->fpgaver != 0)?" (FPGA)":"",
+		(jme->fpgaver != 0)?jme->fpgaver:jme->chipver,
 	        netdev->dev_addr[0],
 	        netdev->dev_addr[1],
 	        netdev->dev_addr[2],
@@ -2268,21 +2835,6 @@ jme_remove_one(struct pci_dev *pdev)
 
 }
 
-static void
-jme_set_10m_half(struct jme_adapter *jme)
-{
-	__u32 bmcr, tmp;
-
-	bmcr = jme_mdio_read(jme->dev, jme->mii_if.phy_id, MII_BMCR);
-	tmp = bmcr & ~(BMCR_ANENABLE | BMCR_SPEED100 |
-		       BMCR_SPEED1000 | BMCR_FULLDPLX);
-
-	if (bmcr != tmp)
-		jme_mdio_write(jme->dev, jme->mii_if.phy_id, MII_BMCR, tmp);
-
-	jwrite32(jme, JME_GHC, GHC_SPEED_10M);
-}
-
 static int
 jme_suspend(struct pci_dev *pdev, pm_message_t state)
 {
@@ -2317,17 +2869,23 @@ jme_suspend(struct pci_dev *pdev, pm_message_t state)
 		jme_free_tx_resources(jme);
 		netif_carrier_off(netdev);
 		jme->phylink = 0;
+
+		if(jme->flags & JME_FLAG_POLL)
+			jme_polling_mode(jme);
 	}
 
-	jme_set_10m_half(jme);
 
 	pci_save_state(pdev);
 	if(jme->reg_pmcs) {
+		jme_set_100m_half(jme);
 		jwrite32(jme, JME_PMCS, jme->reg_pmcs);
-		pci_enable_wake(pdev, PCI_D3cold, 1);
+		pci_enable_wake(pdev, PCI_D3hot, true);
+		pci_enable_wake(pdev, PCI_D3cold, true);
 	}
 	else {
-		pci_enable_wake(pdev, PCI_D3cold, 0);
+		jme_phy_off(jme);
+		pci_enable_wake(pdev, PCI_D3hot, false);
+		pci_enable_wake(pdev, PCI_D3cold, false);
 	}
 	pci_set_power_state(pdev, pci_choose_state(pdev, state));
 
@@ -2362,7 +2920,8 @@ jme_resume(struct pci_dev *pdev)
 }
 
 static struct pci_device_id jme_pci_tbl[] = {
-	{ PCI_VDEVICE(JMICRON, 0x250) },
+	{ PCI_VDEVICE(JMICRON, JME_GE_DEVICE) },
+	{ PCI_VDEVICE(JMICRON, JME_FE_DEVICE) },
 	{ }
 };