X-Git-Url: https://bbs.cooldavid.org/git/?p=jme.git;a=blobdiff_plain;f=jme.c;h=44acc00f803bdc314d7564c15b98ac6e46690c27;hp=986db28b1cba3d5de79c558fe1c8b5ed97b78ba2;hb=192570e059855213a9e0010227fc6d1768be4a38;hpb=42b1055e2e1ef3ceba54535a95780dd90b8ddf5c

diff --git a/jme.c b/jme.c
index 986db28..44acc00 100644
--- a/jme.c
+++ b/jme.c
@@ -22,36 +22,9 @@
  */
 
 /*
- * 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.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:
+ * TODO:
  * 	-  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?
  *	-  Decode register dump for ethtool.
  */
 
@@ -96,7 +69,8 @@ jme_mdio_read(struct net_device *netdev, int phy, int reg)
 	wmb();
         for (i = JME_PHY_TIMEOUT ; i > 0 ; --i) {
 		udelay(1);
-		if (((val = jread32(jme, JME_SMI)) & SMI_OP_REQ) == 0)
+		val = jread32(jme, JME_SMI);
+		if ((val & SMI_OP_REQ) == 0)
 			break;
         }
 
@@ -122,7 +96,8 @@ jme_mdio_write(struct net_device *netdev,
 	wmb();
 	for (i = JME_PHY_TIMEOUT ; i > 0 ; --i) {
 		udelay(1);
-		if (((val = jread32(jme, JME_SMI)) & SMI_OP_REQ) == 0)
+		val = jread32(jme, JME_SMI);
+		if ((val & SMI_OP_REQ) == 0)
 			break;
 	}
 
@@ -158,17 +133,47 @@ 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;
+	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);
+	for(i = 0 ; i < WAKEUP_FRAME_NR ; ++i)
+		jme_setup_wakeup_frame(jme, mask, crc, i);
 	jwrite32(jme, JME_GPREG0, GPREG0_DEFAULT);
 	jwrite32(jme, JME_GPREG1, 0);
 }
@@ -239,6 +244,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) |
@@ -257,8 +267,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
@@ -315,6 +327,7 @@ jme_check_link(struct net_device *netdev, int testonly)
 	char linkmsg[64];
 	int rc = 0;
 
+	linkmsg[0] = '\0';
 	phylink = jread32(jme, JME_PHY_LINK);
 
         if (phylink & PHY_LINK_UP) {
@@ -340,7 +353,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 {
 			/*
@@ -358,7 +371,7 @@ jme_check_link(struct net_device *netdev, int testonly)
 				jeprintk(netdev->name,
 					"Waiting speed resolve timeout.\n");
 
-			strcpy(linkmsg, "ANed: ");
+			strcat(linkmsg, "ANed: ");
 		}
 
 		if(jme->phylink == phylink) {
@@ -373,15 +386,15 @@ jme_check_link(struct net_device *netdev, int testonly)
 		switch(phylink & PHY_LINK_SPEED_MASK) {
 			case PHY_LINK_SPEED_10M:
 				ghc = GHC_SPEED_10M;
-				strcpy(linkmsg, "10 Mbps, ");
+				strcat(linkmsg, "10 Mbps, ");
 				break;
 			case PHY_LINK_SPEED_100M:
 				ghc = GHC_SPEED_100M;
-				strcpy(linkmsg, "100 Mbps, ");
+				strcat(linkmsg, "100 Mbps, ");
 				break;
 			case PHY_LINK_SPEED_1000M:
 				ghc = GHC_SPEED_1000M;
-				strcpy(linkmsg, "1000 Mbps, ");
+				strcat(linkmsg, "1000 Mbps, ");
 				break;
 			default:
 				ghc = 0;
@@ -430,157 +443,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;
-		}
-	}
-}
-
-__always_inline static void
-jme_tx_vlan(struct sk_buff *skb, volatile __u16 *vlan, __u8 *flags)
-{
-	if(vlan_tx_tag_present(skb)) {
-		*flags |= TXFLAG_TAGON;
-		*vlan = vlan_tx_tag_get(skb);
-	}
-}
-
-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);
-	jme_tx_vlan(skb, &(ctxdesc->desc1.vlan), &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;
@@ -597,14 +468,14 @@ jme_setup_tx_resources(struct jme_adapter *jme)
 	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->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;
 }
@@ -617,7 +488,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);
@@ -629,7 +500,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);
 
@@ -662,7 +533,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
@@ -736,7 +607,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;
 
@@ -745,26 +616,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;
 }
@@ -777,7 +640,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);
@@ -795,11 +658,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;
@@ -818,9 +681,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;
@@ -840,7 +703,7 @@ jme_setup_rx_resources(struct jme_adapter *jme)
 	/*
 	 * 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;
@@ -863,9 +726,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
@@ -918,6 +781,33 @@ 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");
+		return false;
+	}
+
+	if(unlikely((flags & RXWBFLAG_UDPON) &&
+	!(flags & RXWBFLAG_UDPCS))) {
+		csum_dbg(jme->dev->name, "UDP Checksum error.\n");
+		return false;
+	}
+
+	if(unlikely((flags & RXWBFLAG_IPV4) &&
+	!(flags & RXWBFLAG_IPCS))) {
+		csum_dbg(jme->dev->name, "IPv4 Checksum error.\n");
+		return false;
+	}
+
+	return true;
+}
+
 static void
 jme_alloc_and_feed_skb(struct jme_adapter *jme, int idx)
 {
@@ -952,21 +842,29 @@ jme_alloc_and_feed_skb(struct jme_adapter *jme, int idx)
 		skb_put(skb, framesize);
 		skb->protocol = eth_type_trans(skb, jme->dev);
 
-		if((rxdesc->descwb.flags &
-					(RXWBFLAG_TCPON |
-					RXWBFLAG_UDPON |
-					RXWBFLAG_IPV4)))
+		if(jme_rxsum_ok(jme, rxdesc->descwb.flags))
 			skb->ip_summed = CHECKSUM_UNNECESSARY;
 		else
 			skb->ip_summed = CHECKSUM_NONE;
 
-		if(jme->vlgrp && (rxdesc->descwb.flags & RXWBFLAG_TAGON))
-			vlan_hwaccel_rx(skb, jme->vlgrp,
+
+		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");
+				vlan_hwaccel_rx(skb, jme->vlgrp,
 					le32_to_cpu(rxdesc->descwb.vlan));
-		else
+				NET_STAT(jme).rx_bytes += 4;
+			}
+		}
+		else {
 			netif_rx(skb);
+		}
 
-		if(le16_to_cpu(rxdesc->descwb.flags) & RXWBFLAG_DEST_MUL)
+		if((le16_to_cpu(rxdesc->descwb.flags) & RXWBFLAG_DEST) ==
+				RXWBFLAG_DEST_MUL)
 			++(NET_STAT(jme).multicast);
 
 		jme->dev->last_rx = jiffies;
@@ -978,35 +876,23 @@ jme_alloc_and_feed_skb(struct jme_adapter *jme, int idx)
 
 }
 
-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;
+
+	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 = rxring->next_to_clean;
 	while( limit-- > 0 )
@@ -1023,8 +909,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);
@@ -1043,9 +928,7 @@ 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);
 			}
 
 		}
@@ -1053,10 +936,10 @@ jme_process_receive(struct jme_adapter *jme, int limit)
 			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",
@@ -1065,6 +948,9 @@ out:
 
 	rxring->next_to_clean = i;
 
+out_inc:
+	atomic_inc(&jme->rx_cleaning);
+
 	return limit > 0 ? limit : 0;
 
 }
@@ -1072,8 +958,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);
@@ -1092,13 +980,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;
@@ -1116,7 +1004,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);
@@ -1129,17 +1017,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)
 {
@@ -1171,6 +1073,11 @@ 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);
+			napi_disable(&jme->napi);
+		}
 	}
 
 	jme_check_link(netdev, 0);
@@ -1196,6 +1103,12 @@ jme_link_change_tasklet(unsigned long arg)
 		jme_enable_tx_engine(jme);
 
 		netif_start_queue(netdev);
+
+		if(jme->flags & JME_FLAG_POLL) {
+			napi_enable(&jme->napi);
+			jme_interrupt_mode(jme);
+		}
+
 		jme_start_pcc_timer(jme);
 	}
 
@@ -1213,20 +1126,32 @@ 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;
+	jme_process_receive(jme, jme->rx_ring_size);
+	++(dpi->intr_cnt);
 
-	if(unlikely(atomic_read(&jme->link_changing) != 1))
-		goto out;
+}
 
-	if(unlikely(netif_queue_stopped(jme->dev)))
-		goto out;
+static int
+jme_poll(struct napi_struct *napi, int budget)
+{
+	struct jme_adapter *jme = container_of(napi, struct jme_adapter, napi);
+	struct net_device *netdev = jme->dev;
+	int rest;
 
-	jme_process_receive(jme, RING_DESC_NR);
-	++(dpi->intr_cnt);
+	rest = jme_process_receive(jme, budget);
 
-out:
-	atomic_inc(&jme->rx_cleaning);
+	while(!atomic_dec_and_test(&jme->rx_empty)) {
+		++(NET_STAT(jme).rx_dropped);
+		jme_restart_rx_engine(jme);
+	}
+	atomic_inc(&jme->rx_empty);
+
+	if(rest) {
+		netif_rx_complete(netdev, napi);
+		jme_interrupt_mode(jme);
+	}
+
+	return budget - rest;
 }
 
 static void
@@ -1237,15 +1162,31 @@ 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);
 }
 
+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
 jme_tx_clean_tasklet(unsigned long arg)
 {
@@ -1253,7 +1194,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;
@@ -1261,10 +1202,11 @@ 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");
 
@@ -1272,7 +1214,8 @@ jme_tx_clean_tasklet(unsigned long arg)
 
 		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;
 
@@ -1281,45 +1224,45 @@ 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;
 		}
 		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;
 	}
@@ -1331,6 +1274,8 @@ jme_tx_clean_tasklet(unsigned long arg)
 
 	atomic_add(cnt, &txring->nr_free);
 
+	jme_wake_queue_if_stopped(jme);
+
 out:
 	atomic_inc(&jme->tx_cleaning);
 }
@@ -1356,20 +1301,27 @@ 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(
+			netif_rx_schedule_prep(jme->dev, &jme->napi))) {
+				jme_polling_mode(jme);
+				__netif_rx_schedule(jme->dev, &jme->napi);
+			}
+		}
+	}
+	else {
+		if(intrstat & INTR_RX0EMP)
+			tasklet_schedule(&jme->rxempty_task);
+
+		if(intrstat & (INTR_PCCRX0TO | INTR_PCCRX0))
+			tasklet_schedule(&jme->rxclean_task);
 	}
 
 out_reenable:
@@ -1464,7 +1416,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) {
@@ -1571,6 +1523,9 @@ jme_close(struct net_device *netdev)
 	jme_disable_shadow(jme);
 	jme_free_irq(jme);
 
+	if(jme->flags & JME_FLAG_POLL)
+		napi_disable(&jme->napi);
+
 	tasklet_kill(&jme->linkch_task);
 	tasklet_kill(&jme->txclean_task);
 	tasklet_kill(&jme->rxclean_task);
@@ -1580,21 +1535,241 @@ jme_close(struct net_device *netdev)
 	jme_free_rx_resources(jme);
 	jme_free_tx_resources(jme);
 	jme->phylink = 0;
+	jme_phy_off(jme);
 
-	if(jme->reg_pmcs) {
-		jme_set_100m_half(jme);
-		pci_enable_wake(jme->pdev, PCI_D0, true);
-		pci_enable_wake(jme->pdev, PCI_D3hot, true);
-		pci_enable_wake(jme->pdev, PCI_D3cold, true);
-		jwrite32(jme, JME_PMCS, jme->reg_pmcs);
+	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);
 	}
-	else {
-		jme_phy_off(jme);
+
+	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;
+
+	return 0;
+}
+
+static void
+jme_stop_queue_if_full(struct jme_adapter *jme)
+{
+	struct jme_ring *txring = jme->txring;
+
+	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");
+		}
+	}
+
+}
+
 /*
  * This function is already protected by netif_tx_lock()
  */
@@ -1602,25 +1777,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);
+	}
 
-	rc = jme_set_new_txdesc(jme, skb);
+	if(unlikely(jme_expand_header(jme, skb))) {
+		++(NET_STAT(jme).tx_dropped);
+		return NETDEV_TX_OK;
+	}
 
-	if(unlikely(rc != NETDEV_TX_OK))
-		return rc;
+	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;
+	}
+
+	jme_map_tx_skb(jme, skb, idx);
+	jme_fill_first_tx_desc(jme, skb, idx);
+
+	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 |
@@ -1628,6 +1814,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;
 }
 
@@ -1722,10 +1910,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;
@@ -1741,7 +1934,7 @@ jme_tx_timeout(struct net_device *netdev)
 
 	/*
 	 * Reset the link
-	 * And the link change will reinitiallize all RX/TX resources
+	 * And the link change will reinitialize all RX/TX resources
 	 */
 	jme->phylink = 0;
 	jme_reset_link(jme);
@@ -1809,7 +2002,11 @@ jme_get_coalesce(struct net_device *netdev, struct ethtool_coalesce *ecmd)
 {
 	struct jme_adapter *jme = netdev_priv(netdev);
 
-	ecmd->use_adaptive_rx_coalesce = true;
+	if(jme->flags & JME_FLAG_POLL)
+		ecmd->use_adaptive_rx_coalesce = false;
+	else
+		ecmd->use_adaptive_rx_coalesce = true;
+
 	ecmd->tx_coalesce_usecs = PCC_TX_TO;
 	ecmd->tx_max_coalesced_frames = PCC_TX_CNT;
 
@@ -1833,41 +2030,27 @@ 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);
+	if(ecmd->use_adaptive_rx_coalesce
+	&& (jme->flags & JME_FLAG_POLL)) {
+		jme->flags &= ~JME_FLAG_POLL;
+		napi_disable(&jme->napi);
+		dpi->cur		= PCC_P1;
+		dpi->attempt		= PCC_P1;
+		dpi->cnt		= 0;
+		jme_set_rx_pcc(jme, PCC_P1);
+		jme_interrupt_mode(jme);
 	}
-	else {
-		return -EINVAL;
+	else if(!(ecmd->use_adaptive_rx_coalesce)
+	&& !(jme->flags & JME_FLAG_POLL)) {
+		jme->flags |= JME_FLAG_POLL;
+		napi_enable(&jme->napi);
+		jme_interrupt_mode(jme);
 	}
 
 	return 0;
@@ -1887,7 +2070,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
@@ -1924,7 +2109,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)
@@ -1932,7 +2117,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);
 
@@ -1981,7 +2167,7 @@ jme_set_wol(struct net_device *netdev,
 
 	return 0;
 }
- 
+
 static int
 jme_get_settings(struct net_device *netdev,
 		     struct ethtool_cmd *ecmd)
@@ -2047,7 +2233,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;
@@ -2062,14 +2248,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->mtu <= 1900)
-		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)
 {
@@ -2094,6 +2305,8 @@ 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,
 };
 
@@ -2186,6 +2399,9 @@ jme_init_one(struct pci_dev *pdev,
 	netdev->vlan_rx_register	= jme_vlan_rx_register;
 	NETDEV_GET_STATS(netdev, &jme_get_stats);
 	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)
@@ -2202,6 +2418,11 @@ jme_init_one(struct pci_dev *pdev,
 	jme->dev = netdev;
 	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)) {
@@ -2218,6 +2439,8 @@ jme_init_one(struct pci_dev *pdev,
 		goto err_out_unmap;
 	}
 
+	netif_napi_add(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);
@@ -2225,6 +2448,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,
@@ -2253,7 +2477,9 @@ jme_init_one(struct pci_dev *pdev,
 	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 | JME_FLAG_POLL;
+
 	/*
 	 * Get Max Read Req Size from PCI Config Space
 	 */
@@ -2281,7 +2507,7 @@ jme_init_one(struct pci_dev *pdev,
 	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);
@@ -2384,6 +2610,11 @@ 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);
+			napi_disable(&jme->napi);
+		}
 	}