diff --git a/[refs] b/[refs]
index 53c26459576f..dabc17a20281 100644
--- a/[refs]
+++ b/[refs]
@@ -1,2 +1,2 @@
 ---
-refs/heads/master: bb81b2ddfa194b6d12761a350b5b5985cecae0a9
+refs/heads/master: 2f19c287fecb958eb68b1c2199b4dd6e00ba4276
diff --git a/trunk/drivers/net/Kconfig b/trunk/drivers/net/Kconfig
index bbe77a065845..29935a9fb1a2 100644
--- a/trunk/drivers/net/Kconfig
+++ b/trunk/drivers/net/Kconfig
@@ -1926,12 +1926,6 @@ config ATL2
 	  To compile this driver as a module, choose M here.  The module
 	  will be called atl2.
 
-config XILINX_EMACLITE
-	tristate "Xilinx 10/100 Ethernet Lite support"
-	depends on PPC32 || MICROBLAZE
-	help
-	  This driver supports the 10/100 Ethernet Lite from Xilinx.
-
 source "drivers/net/fs_enet/Kconfig"
 
 endif # NET_ETHERNET
diff --git a/trunk/drivers/net/Makefile b/trunk/drivers/net/Makefile
index 99ae6d7fe6a9..ead8cab3cfe1 100644
--- a/trunk/drivers/net/Makefile
+++ b/trunk/drivers/net/Makefile
@@ -142,7 +142,6 @@ obj-$(CONFIG_TSI108_ETH) += tsi108_eth.o
 obj-$(CONFIG_MV643XX_ETH) += mv643xx_eth.o
 ll_temac-objs := ll_temac_main.o ll_temac_mdio.o
 obj-$(CONFIG_XILINX_LL_TEMAC) += ll_temac.o
-obj-$(CONFIG_XILINX_EMACLITE) += xilinx_emaclite.o
 obj-$(CONFIG_QLA3XXX) += qla3xxx.o
 obj-$(CONFIG_QLGE) += qlge/
 
diff --git a/trunk/drivers/net/benet/be_main.c b/trunk/drivers/net/benet/be_main.c
index 7b9efee890f8..45507d88e6a1 100644
--- a/trunk/drivers/net/benet/be_main.c
+++ b/trunk/drivers/net/benet/be_main.c
@@ -117,18 +117,23 @@ void be_cq_notify(struct be_adapter *adapter, u16 qid, bool arm, u16 num_popped)
 	iowrite32(val, adapter->db + DB_CQ_OFFSET);
 }
 
+
 static int be_mac_addr_set(struct net_device *netdev, void *p)
 {
 	struct be_adapter *adapter = netdev_priv(netdev);
 	struct sockaddr *addr = p;
 	int status = 0;
 
-	status = be_cmd_pmac_del(adapter, adapter->if_handle, adapter->pmac_id);
-	if (status)
-		return status;
+	if (netif_running(netdev)) {
+		status = be_cmd_pmac_del(adapter, adapter->if_handle,
+				adapter->pmac_id);
+		if (status)
+			return status;
+
+		status = be_cmd_pmac_add(adapter, (u8 *)addr->sa_data,
+				adapter->if_handle, &adapter->pmac_id);
+	}
 
-	status = be_cmd_pmac_add(adapter, (u8 *)addr->sa_data,
-			adapter->if_handle, &adapter->pmac_id);
 	if (!status)
 		memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
 
@@ -1303,12 +1308,6 @@ static int be_rx_queues_create(struct be_adapter *adapter)
 	return rc;
 }
 
-/* There are 8 evt ids per func. Retruns the evt id's bit number */
-static inline int be_evt_bit_get(struct be_adapter *adapter, u32 eq_id)
-{
-	return eq_id - 8 * be_pci_func(adapter);
-}
-
 static irqreturn_t be_intx(int irq, void *dev)
 {
 	struct be_adapter *adapter = dev;
@@ -1482,44 +1481,31 @@ static void be_msix_enable(struct be_adapter *adapter)
 
 static inline int be_msix_vec_get(struct be_adapter *adapter, u32 eq_id)
 {
-	return adapter->msix_entries[
-			be_evt_bit_get(adapter, eq_id)].vector;
-}
-
-static int be_request_irq(struct be_adapter *adapter,
-		struct be_eq_obj *eq_obj,
-		void *handler, char *desc)
-{
-	struct net_device *netdev = adapter->netdev;
-	int vec;
-
-	sprintf(eq_obj->desc, "%s-%s", netdev->name, desc);
-	vec = be_msix_vec_get(adapter, eq_obj->q.id);
-	return request_irq(vec, handler, 0, eq_obj->desc, adapter);
-}
-
-static void be_free_irq(struct be_adapter *adapter, struct be_eq_obj *eq_obj)
-{
-	int vec = be_msix_vec_get(adapter, eq_obj->q.id);
-	free_irq(vec, adapter);
+	return adapter->msix_entries[eq_id - 8 * be_pci_func(adapter)].vector;
 }
 
 static int be_msix_register(struct be_adapter *adapter)
 {
-	int status;
+	struct net_device *netdev = adapter->netdev;
+	struct be_eq_obj *tx_eq = &adapter->tx_eq;
+	struct be_eq_obj *rx_eq = &adapter->rx_eq;
+	int status, vec;
 
-	status = be_request_irq(adapter, &adapter->tx_eq, be_msix_tx_mcc, "tx");
+	sprintf(tx_eq->desc, "%s-tx", netdev->name);
+	vec = be_msix_vec_get(adapter, tx_eq->q.id);
+	status = request_irq(vec, be_msix_tx_mcc, 0, tx_eq->desc, adapter);
 	if (status)
 		goto err;
 
-	status = be_request_irq(adapter, &adapter->rx_eq, be_msix_rx, "rx");
-	if (status)
-		goto free_tx_irq;
-
+	sprintf(rx_eq->desc, "%s-rx", netdev->name);
+	vec = be_msix_vec_get(adapter, rx_eq->q.id);
+	status = request_irq(vec, be_msix_rx, 0, rx_eq->desc, adapter);
+	if (status) { /* Free TX IRQ */
+		vec = be_msix_vec_get(adapter, tx_eq->q.id);
+		free_irq(vec, adapter);
+		goto err;
+	}
 	return 0;
-
-free_tx_irq:
-	be_free_irq(adapter, &adapter->tx_eq);
 err:
 	dev_warn(&adapter->pdev->dev,
 		"MSIX Request IRQ failed - err %d\n", status);
@@ -1556,6 +1542,7 @@ static int be_irq_register(struct be_adapter *adapter)
 static void be_irq_unregister(struct be_adapter *adapter)
 {
 	struct net_device *netdev = adapter->netdev;
+	int vec;
 
 	if (!adapter->isr_registered)
 		return;
@@ -1567,8 +1554,10 @@ static void be_irq_unregister(struct be_adapter *adapter)
 	}
 
 	/* MSIx */
-	be_free_irq(adapter, &adapter->tx_eq);
-	be_free_irq(adapter, &adapter->rx_eq);
+	vec = be_msix_vec_get(adapter, adapter->tx_eq.q.id);
+	free_irq(vec, adapter);
+	vec = be_msix_vec_get(adapter, adapter->rx_eq.q.id);
+	free_irq(vec, adapter);
 done:
 	adapter->isr_registered = false;
 	return;
@@ -1655,12 +1644,12 @@ static int be_setup(struct be_adapter *adapter)
 
 static int be_clear(struct be_adapter *adapter)
 {
-	be_mcc_queues_destroy(adapter);
 	be_rx_queues_destroy(adapter);
 	be_tx_queues_destroy(adapter);
 
 	be_cmd_if_destroy(adapter, adapter->if_handle);
 
+	be_mcc_queues_destroy(adapter);
 	return 0;
 }
 
diff --git a/trunk/drivers/net/ppp_generic.c b/trunk/drivers/net/ppp_generic.c
index 35be2e8f0c98..7dd0868f983a 100644
--- a/trunk/drivers/net/ppp_generic.c
+++ b/trunk/drivers/net/ppp_generic.c
@@ -1431,7 +1431,6 @@ static int ppp_mp_explode(struct ppp *ppp, struct sk_buff *skb)
 		*otherwise divide it according to the speed
 		*of the channel we are going to transmit on
 		*/
-		flen = len;
 		if (nfree > 0) {
 			if (pch->speed == 0) {
 				flen = totlen/nfree	;
diff --git a/trunk/drivers/net/sky2.c b/trunk/drivers/net/sky2.c
index dd630cf18b4d..8a763f866614 100644
--- a/trunk/drivers/net/sky2.c
+++ b/trunk/drivers/net/sky2.c
@@ -50,7 +50,7 @@
 #include "sky2.h"
 
 #define DRV_NAME		"sky2"
-#define DRV_VERSION		"1.25"
+#define DRV_VERSION		"1.24"
 #define PFX			DRV_NAME " "
 
 /*
@@ -64,12 +64,10 @@
 #define RX_MAX_PENDING		(RX_LE_SIZE/6 - 2)
 #define RX_DEF_PENDING		RX_MAX_PENDING
 
-/* This is the worst case number of transmit list elements for a single skb:
-   VLAN + TSO + CKSUM + Data + skb_frags * DMA */
-#define MAX_SKB_TX_LE	(4 + (sizeof(dma_addr_t)/sizeof(u32))*MAX_SKB_FRAGS)
+#define TX_RING_SIZE		512
+#define TX_DEF_PENDING		128
+#define MAX_SKB_TX_LE		(4 + (sizeof(dma_addr_t)/sizeof(u32))*MAX_SKB_FRAGS)
 #define TX_MIN_PENDING		(MAX_SKB_TX_LE+1)
-#define TX_MAX_PENDING		4096
-#define TX_DEF_PENDING		127
 
 #define STATUS_RING_SIZE	2048	/* 2 ports * (TX + 2*RX) */
 #define STATUS_LE_BYTES		(STATUS_RING_SIZE*sizeof(struct sky2_status_le))
@@ -986,12 +984,12 @@ static void sky2_qset(struct sky2_hw *hw, u16 q)
  * hardware and driver list elements
  */
 static void sky2_prefetch_init(struct sky2_hw *hw, u32 qaddr,
-			       dma_addr_t addr, u32 last)
+				      u64 addr, u32 last)
 {
 	sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_CTRL), PREF_UNIT_RST_SET);
 	sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_CTRL), PREF_UNIT_RST_CLR);
-	sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_ADDR_HI), upper_32_bits(addr));
-	sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_ADDR_LO), lower_32_bits(addr));
+	sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_ADDR_HI), addr >> 32);
+	sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_ADDR_LO), (u32) addr);
 	sky2_write16(hw, Y2_QADDR(qaddr, PREF_UNIT_LAST_IDX), last);
 	sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_CTRL), PREF_UNIT_OP_ON);
 
@@ -1001,11 +999,8 @@ static void sky2_prefetch_init(struct sky2_hw *hw, u32 qaddr,
 static inline struct sky2_tx_le *get_tx_le(struct sky2_port *sky2, u16 *slot)
 {
 	struct sky2_tx_le *le = sky2->tx_le + *slot;
-	struct tx_ring_info *re = sky2->tx_ring + *slot;
 
-	*slot = RING_NEXT(*slot, sky2->tx_ring_size);
-	re->flags = 0;
-	re->skb = NULL;
+	*slot = RING_NEXT(*slot, TX_RING_SIZE);
 	le->ctrl = 0;
 	return le;
 }
@@ -1021,7 +1016,12 @@ static void tx_init(struct sky2_port *sky2)
 	le = get_tx_le(sky2, &sky2->tx_prod);
 	le->addr = 0;
 	le->opcode = OP_ADDR64 | HW_OWNER;
-	sky2->tx_last_upper = 0;
+}
+
+static inline struct tx_ring_info *tx_le_re(struct sky2_port *sky2,
+					    struct sky2_tx_le *le)
+{
+	return sky2->tx_ring + (le - sky2->tx_le);
 }
 
 /* Update chip's next pointer */
@@ -1057,7 +1057,7 @@ static void sky2_rx_add(struct sky2_port *sky2,  u8 op,
 	}
 
 	le = sky2_next_rx(sky2);
-	le->addr = cpu_to_le32(lower_32_bits(map));
+	le->addr = cpu_to_le32((u32) map);
 	le->length = cpu_to_le16(len);
 	le->opcode = op | HW_OWNER;
 }
@@ -1177,6 +1177,7 @@ static void sky2_rx_clean(struct sky2_port *sky2)
 			re->skb = NULL;
 		}
 	}
+	skb_queue_purge(&sky2->rx_recycle);
 }
 
 /* Basic MII support */
@@ -1268,8 +1269,10 @@ static struct sk_buff *sky2_rx_alloc(struct sky2_port *sky2)
 	struct sk_buff *skb;
 	int i;
 
-	skb = netdev_alloc_skb(sky2->netdev,
-			       sky2->rx_data_size + sky2_rx_pad(sky2->hw));
+	skb = __skb_dequeue(&sky2->rx_recycle);
+	if (!skb)
+		skb = netdev_alloc_skb(sky2->netdev, sky2->rx_data_size
+				       + sky2_rx_pad(sky2->hw));
 	if (!skb)
 		goto nomem;
 
@@ -1361,6 +1364,8 @@ static int sky2_rx_start(struct sky2_port *sky2)
 
 	sky2->rx_data_size = size;
 
+	skb_queue_head_init(&sky2->rx_recycle);
+
 	/* Fill Rx ring */
 	for (i = 0; i < sky2->rx_pending; i++) {
 		re = sky2->rx_ring + i;
@@ -1427,13 +1432,13 @@ static int sky2_up(struct net_device *dev)
 
 	/* must be power of 2 */
 	sky2->tx_le = pci_alloc_consistent(hw->pdev,
-					   sky2->tx_ring_size *
+					   TX_RING_SIZE *
 					   sizeof(struct sky2_tx_le),
 					   &sky2->tx_le_map);
 	if (!sky2->tx_le)
 		goto err_out;
 
-	sky2->tx_ring = kcalloc(sky2->tx_ring_size, sizeof(struct tx_ring_info),
+	sky2->tx_ring = kcalloc(TX_RING_SIZE, sizeof(struct tx_ring_info),
 				GFP_KERNEL);
 	if (!sky2->tx_ring)
 		goto err_out;
@@ -1485,7 +1490,7 @@ static int sky2_up(struct net_device *dev)
 		sky2_write16(hw, Q_ADDR(txqaddr[port], Q_AL), ECU_TXFF_LEV);
 
 	sky2_prefetch_init(hw, txqaddr[port], sky2->tx_le_map,
-			   sky2->tx_ring_size - 1);
+			   TX_RING_SIZE - 1);
 
 #ifdef SKY2_VLAN_TAG_USED
 	sky2_set_vlan_mode(hw, port, sky2->vlgrp != NULL);
@@ -1514,7 +1519,7 @@ static int sky2_up(struct net_device *dev)
 	}
 	if (sky2->tx_le) {
 		pci_free_consistent(hw->pdev,
-				    sky2->tx_ring_size * sizeof(struct sky2_tx_le),
+				    TX_RING_SIZE * sizeof(struct sky2_tx_le),
 				    sky2->tx_le, sky2->tx_le_map);
 		sky2->tx_le = NULL;
 	}
@@ -1527,15 +1532,15 @@ static int sky2_up(struct net_device *dev)
 }
 
 /* Modular subtraction in ring */
-static inline int tx_inuse(const struct sky2_port *sky2)
+static inline int tx_dist(unsigned tail, unsigned head)
 {
-	return (sky2->tx_prod - sky2->tx_cons) & (sky2->tx_ring_size - 1);
+	return (head - tail) & (TX_RING_SIZE - 1);
 }
 
 /* Number of list elements available for next tx */
 static inline int tx_avail(const struct sky2_port *sky2)
 {
-	return sky2->tx_pending - tx_inuse(sky2);
+	return sky2->tx_pending - tx_dist(sky2->tx_cons, sky2->tx_prod);
 }
 
 /* Estimate of number of transmit list elements required */
@@ -1555,19 +1560,6 @@ static unsigned tx_le_req(const struct sk_buff *skb)
 	return count;
 }
 
-static void sky2_tx_unmap(struct pci_dev *pdev,
-			  const struct tx_ring_info *re)
-{
-	if (re->flags & TX_MAP_SINGLE)
-		pci_unmap_single(pdev, pci_unmap_addr(re, mapaddr),
-				 pci_unmap_len(re, maplen),
-				 PCI_DMA_TODEVICE);
-	else if (re->flags & TX_MAP_PAGE)
-		pci_unmap_page(pdev, pci_unmap_addr(re, mapaddr),
-			       pci_unmap_len(re, maplen),
-			       PCI_DMA_TODEVICE);
-}
-
 /*
  * Put one packet in ring for transmit.
  * A single packet can generate multiple list elements, and
@@ -1581,9 +1573,8 @@ static int sky2_xmit_frame(struct sk_buff *skb, struct net_device *dev)
 	struct sky2_tx_le *le = NULL;
 	struct tx_ring_info *re;
 	unsigned i, len;
-	dma_addr_t mapping;
-	u32 upper;
 	u16 slot;
+	dma_addr_t mapping;
 	u16 mss;
 	u8 ctrl;
 
@@ -1602,11 +1593,9 @@ static int sky2_xmit_frame(struct sk_buff *skb, struct net_device *dev)
 		       dev->name, slot, skb->len);
 
 	/* Send high bits if needed */
-	upper = upper_32_bits(mapping);
-	if (upper != sky2->tx_last_upper) {
+	if (sizeof(dma_addr_t) > sizeof(u32)) {
 		le = get_tx_le(sky2, &slot);
-		le->addr = cpu_to_le32(upper);
-		sky2->tx_last_upper = upper;
+		le->addr = cpu_to_le32(upper_32_bits(mapping));
 		le->opcode = OP_ADDR64 | HW_OWNER;
 	}
 
@@ -1672,17 +1661,16 @@ static int sky2_xmit_frame(struct sk_buff *skb, struct net_device *dev)
 		}
 	}
 
-	re = sky2->tx_ring + slot;
-	re->flags = TX_MAP_SINGLE;
-	pci_unmap_addr_set(re, mapaddr, mapping);
-	pci_unmap_len_set(re, maplen, len);
-
 	le = get_tx_le(sky2, &slot);
-	le->addr = cpu_to_le32(lower_32_bits(mapping));
+	le->addr = cpu_to_le32((u32) mapping);
 	le->length = cpu_to_le16(len);
 	le->ctrl = ctrl;
 	le->opcode = mss ? (OP_LARGESEND | HW_OWNER) : (OP_PACKET | HW_OWNER);
 
+	re = tx_le_re(sky2, le);
+	re->skb = skb;
+	pci_unmap_addr_set(re, mapaddr, mapping);
+	pci_unmap_len_set(re, maplen, len);
 
 	for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
 		const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
@@ -1693,27 +1681,25 @@ static int sky2_xmit_frame(struct sk_buff *skb, struct net_device *dev)
 		if (pci_dma_mapping_error(hw->pdev, mapping))
 			goto mapping_unwind;
 
-		upper = upper_32_bits(mapping);
-		if (upper != sky2->tx_last_upper) {
+		if (sizeof(dma_addr_t) > sizeof(u32)) {
 			le = get_tx_le(sky2, &slot);
-			le->addr = cpu_to_le32(upper);
-			sky2->tx_last_upper = upper;
+			le->addr = cpu_to_le32(upper_32_bits(mapping));
+			le->ctrl = 0;
 			le->opcode = OP_ADDR64 | HW_OWNER;
 		}
 
-		re = sky2->tx_ring + slot;
-		re->flags = TX_MAP_PAGE;
-		pci_unmap_addr_set(re, mapaddr, mapping);
-		pci_unmap_len_set(re, maplen, frag->size);
-
 		le = get_tx_le(sky2, &slot);
-		le->addr = cpu_to_le32(lower_32_bits(mapping));
+		le->addr = cpu_to_le32((u32) mapping);
 		le->length = cpu_to_le16(frag->size);
 		le->ctrl = ctrl;
 		le->opcode = OP_BUFFER | HW_OWNER;
+
+		re = tx_le_re(sky2, le);
+		re->skb = skb;
+		pci_unmap_addr_set(re, mapaddr, mapping);
+		pci_unmap_len_set(re, maplen, frag->size);
 	}
 
-	re->skb = skb;
 	le->ctrl |= EOP;
 
 	sky2->tx_prod = slot;
@@ -1726,10 +1712,24 @@ static int sky2_xmit_frame(struct sk_buff *skb, struct net_device *dev)
 	return NETDEV_TX_OK;
 
 mapping_unwind:
-	for (i = sky2->tx_prod; i != slot; i = RING_NEXT(i, sky2->tx_ring_size)) {
+	for (i = sky2->tx_prod; i != slot; i = RING_NEXT(i, TX_RING_SIZE)) {
+		le = sky2->tx_le + i;
 		re = sky2->tx_ring + i;
 
-		sky2_tx_unmap(hw->pdev, re);
+		switch(le->opcode & ~HW_OWNER) {
+		case OP_LARGESEND:
+		case OP_PACKET:
+			pci_unmap_single(hw->pdev,
+					 pci_unmap_addr(re, mapaddr),
+					 pci_unmap_len(re, maplen),
+					 PCI_DMA_TODEVICE);
+			break;
+		case OP_BUFFER:
+			pci_unmap_page(hw->pdev, pci_unmap_addr(re, mapaddr),
+				       pci_unmap_len(re, maplen),
+				       PCI_DMA_TODEVICE);
+			break;
+		}
 	}
 
 mapping_error:
@@ -1752,18 +1752,34 @@ static int sky2_xmit_frame(struct sk_buff *skb, struct net_device *dev)
 static void sky2_tx_complete(struct sky2_port *sky2, u16 done)
 {
 	struct net_device *dev = sky2->netdev;
+	struct pci_dev *pdev = sky2->hw->pdev;
 	unsigned idx;
 
-	BUG_ON(done >= sky2->tx_ring_size);
+	BUG_ON(done >= TX_RING_SIZE);
 
 	for (idx = sky2->tx_cons; idx != done;
-	     idx = RING_NEXT(idx, sky2->tx_ring_size)) {
+	     idx = RING_NEXT(idx, TX_RING_SIZE)) {
+		struct sky2_tx_le *le = sky2->tx_le + idx;
 		struct tx_ring_info *re = sky2->tx_ring + idx;
-		struct sk_buff *skb = re->skb;
 
-		sky2_tx_unmap(sky2->hw->pdev, re);
+		switch(le->opcode & ~HW_OWNER) {
+		case OP_LARGESEND:
+		case OP_PACKET:
+			pci_unmap_single(pdev,
+					 pci_unmap_addr(re, mapaddr),
+					 pci_unmap_len(re, maplen),
+					 PCI_DMA_TODEVICE);
+			break;
+		case OP_BUFFER:
+			pci_unmap_page(pdev, pci_unmap_addr(re, mapaddr),
+				       pci_unmap_len(re, maplen),
+				       PCI_DMA_TODEVICE);
+			break;
+		}
+
+		if (le->ctrl & EOP) {
+			struct sk_buff *skb = re->skb;
 
-		if (skb) {
 			if (unlikely(netif_msg_tx_done(sky2)))
 				printk(KERN_DEBUG "%s: tx done %u\n",
 				       dev->name, idx);
@@ -1771,9 +1787,14 @@ static void sky2_tx_complete(struct sky2_port *sky2, u16 done)
 			dev->stats.tx_packets++;
 			dev->stats.tx_bytes += skb->len;
 
-			dev_kfree_skb_any(skb);
+			if (skb_queue_len(&sky2->rx_recycle) < sky2->rx_pending
+			    && skb_recycle_check(skb, sky2->rx_data_size
+						 + sky2_rx_pad(sky2->hw)))
+				__skb_queue_head(&sky2->rx_recycle, skb);
+			else
+				dev_kfree_skb_any(skb);
 
-			sky2->tx_next = RING_NEXT(idx, sky2->tx_ring_size);
+			sky2->tx_next = RING_NEXT(idx, TX_RING_SIZE);
 		}
 	}
 
@@ -1881,7 +1902,7 @@ static int sky2_down(struct net_device *dev)
 	kfree(sky2->rx_ring);
 
 	pci_free_consistent(hw->pdev,
-			    sky2->tx_ring_size * sizeof(struct sky2_tx_le),
+			    TX_RING_SIZE * sizeof(struct sky2_tx_le),
 			    sky2->tx_le, sky2->tx_le_map);
 	kfree(sky2->tx_ring);
 
@@ -2491,6 +2512,7 @@ static int sky2_status_intr(struct sky2_hw *hw, int to_do, u16 idx)
 
 		case OP_TXINDEXLE:
 			/* TX index reports status for both ports */
+			BUILD_BUG_ON(TX_RING_SIZE > 0x1000);
 			sky2_tx_done(hw->dev[0], status & 0xfff);
 			if (hw->dev[1])
 				sky2_tx_done(hw->dev[1],
@@ -2634,15 +2656,19 @@ static void sky2_mac_intr(struct sky2_hw *hw, unsigned port)
 }
 
 /* This should never happen it is a bug. */
-static void sky2_le_error(struct sky2_hw *hw, unsigned port, u16 q)
+static void sky2_le_error(struct sky2_hw *hw, unsigned port,
+			  u16 q, unsigned ring_size)
 {
 	struct net_device *dev = hw->dev[port];
-	u16 idx = sky2_read16(hw, Y2_QADDR(q, PREF_UNIT_GET_IDX));
+	struct sky2_port *sky2 = netdev_priv(dev);
+	unsigned idx;
+	const u64 *le = (q == Q_R1 || q == Q_R2)
+		? (u64 *) sky2->rx_le : (u64 *) sky2->tx_le;
 
-	dev_err(&hw->pdev->dev, PFX
-		"%s: descriptor error q=%#x get=%u put=%u\n",
-		dev->name, (unsigned) q, (unsigned) idx,
-		(unsigned) sky2_read16(hw, Y2_QADDR(q, PREF_UNIT_PUT_IDX)));
+	idx = sky2_read16(hw, Y2_QADDR(q, PREF_UNIT_GET_IDX));
+	printk(KERN_ERR PFX "%s: descriptor error q=%#x get=%u [%llx] put=%u\n",
+	       dev->name, (unsigned) q, idx, (unsigned long long) le[idx],
+	       (unsigned) sky2_read16(hw, Y2_QADDR(q, PREF_UNIT_PUT_IDX)));
 
 	sky2_write32(hw, Q_ADDR(q, Q_CSR), BMU_CLR_IRQ_CHK);
 }
@@ -2728,16 +2754,16 @@ static void sky2_err_intr(struct sky2_hw *hw, u32 status)
 		sky2_mac_intr(hw, 1);
 
 	if (status & Y2_IS_CHK_RX1)
-		sky2_le_error(hw, 0, Q_R1);
+		sky2_le_error(hw, 0, Q_R1, RX_LE_SIZE);
 
 	if (status & Y2_IS_CHK_RX2)
-		sky2_le_error(hw, 1, Q_R2);
+		sky2_le_error(hw, 1, Q_R2, RX_LE_SIZE);
 
 	if (status & Y2_IS_CHK_TXA1)
-		sky2_le_error(hw, 0, Q_XA1);
+		sky2_le_error(hw, 0, Q_XA1, TX_RING_SIZE);
 
 	if (status & Y2_IS_CHK_TXA2)
-		sky2_le_error(hw, 1, Q_XA2);
+		sky2_le_error(hw, 1, Q_XA2, TX_RING_SIZE);
 }
 
 static int sky2_poll(struct napi_struct *napi, int work_limit)
@@ -3642,7 +3668,7 @@ static int sky2_set_coalesce(struct net_device *dev,
 	    ecmd->rx_coalesce_usecs_irq > tmax)
 		return -EINVAL;
 
-	if (ecmd->tx_max_coalesced_frames >= sky2->tx_ring_size-1)
+	if (ecmd->tx_max_coalesced_frames >= TX_RING_SIZE-1)
 		return -EINVAL;
 	if (ecmd->rx_max_coalesced_frames > RX_MAX_PENDING)
 		return -EINVAL;
@@ -3686,7 +3712,7 @@ static void sky2_get_ringparam(struct net_device *dev,
 	ering->rx_max_pending = RX_MAX_PENDING;
 	ering->rx_mini_max_pending = 0;
 	ering->rx_jumbo_max_pending = 0;
-	ering->tx_max_pending = TX_MAX_PENDING;
+	ering->tx_max_pending = TX_RING_SIZE - 1;
 
 	ering->rx_pending = sky2->rx_pending;
 	ering->rx_mini_pending = 0;
@@ -3701,15 +3727,14 @@ static int sky2_set_ringparam(struct net_device *dev,
 
 	if (ering->rx_pending > RX_MAX_PENDING ||
 	    ering->rx_pending < 8 ||
-	    ering->tx_pending < TX_MIN_PENDING ||
-	    ering->tx_pending > TX_MAX_PENDING)
+	    ering->tx_pending < MAX_SKB_TX_LE ||
+	    ering->tx_pending > TX_RING_SIZE - 1)
 		return -EINVAL;
 
 	sky2_detach(dev);
 
 	sky2->rx_pending = ering->rx_pending;
 	sky2->tx_pending = ering->tx_pending;
-	sky2->tx_ring_size = roundup_pow_of_two(sky2->tx_pending+1);
 
 	return sky2_reattach(dev);
 }
@@ -4079,8 +4104,8 @@ static int sky2_debug_show(struct seq_file *seq, void *v)
 
 	/* Dump contents of tx ring */
 	sop = 1;
-	for (idx = sky2->tx_next; idx != sky2->tx_prod && idx < sky2->tx_ring_size;
-	     idx = RING_NEXT(idx, sky2->tx_ring_size)) {
+	for (idx = sky2->tx_next; idx != sky2->tx_prod && idx < TX_RING_SIZE;
+	     idx = RING_NEXT(idx, TX_RING_SIZE)) {
 		const struct sky2_tx_le *le = sky2->tx_le + idx;
 		u32 a = le32_to_cpu(le->addr);
 
@@ -4289,9 +4314,7 @@ static __devinit struct net_device *sky2_init_netdev(struct sky2_hw *hw,
 	sky2->wol = wol;
 
 	spin_lock_init(&sky2->phy_lock);
-
 	sky2->tx_pending = TX_DEF_PENDING;
-	sky2->tx_ring_size = roundup_pow_of_two(TX_DEF_PENDING+1);
 	sky2->rx_pending = RX_DEF_PENDING;
 
 	hw->dev[port] = dev;
diff --git a/trunk/drivers/net/sky2.h b/trunk/drivers/net/sky2.h
index 73c954712467..65b94c366fbc 100644
--- a/trunk/drivers/net/sky2.h
+++ b/trunk/drivers/net/sky2.h
@@ -1984,9 +1984,6 @@ struct sky2_status_le {
 
 struct tx_ring_info {
 	struct sk_buff	*skb;
-	unsigned long flags;
-#define TX_MAP_SINGLE   0x0001
-#define TX_MAP_PAGE     000002
 	DECLARE_PCI_UNMAP_ADDR(mapaddr);
 	DECLARE_PCI_UNMAP_LEN(maplen);
 };
@@ -2014,14 +2011,12 @@ struct sky2_port {
 
 	struct tx_ring_info  *tx_ring;
 	struct sky2_tx_le    *tx_le;
-	u16		     tx_ring_size;
 	u16		     tx_cons;		/* next le to check */
 	u16		     tx_prod;		/* next le to use */
 	u16		     tx_next;		/* debug only */
 
 	u16		     tx_pending;
 	u16		     tx_last_mss;
-	u32		     tx_last_upper;
 	u32		     tx_tcpsum;
 
 	struct rx_ring_info  *rx_ring ____cacheline_aligned_in_smp;
@@ -2032,6 +2027,7 @@ struct sky2_port {
 	u16		     rx_pending;
 	u16		     rx_data_size;
 	u16		     rx_nfrags;
+	struct sk_buff_head  rx_recycle;
 
 #ifdef SKY2_VLAN_TAG_USED
 	u16		     rx_tag;
diff --git a/trunk/drivers/net/wireless/b43/lo.c b/trunk/drivers/net/wireless/b43/lo.c
index 22d0fbd83a62..976104f634a1 100644
--- a/trunk/drivers/net/wireless/b43/lo.c
+++ b/trunk/drivers/net/wireless/b43/lo.c
@@ -477,7 +477,7 @@ static void lo_measure_setup(struct b43_wldev *dev,
 	} else
 		b43_phy_write(dev, B43_PHY_CCK(0x2B), 0x0802);
 	if (phy->rev >= 2)
-		b43_dummy_transmission(dev);
+		b43_dummy_transmission(dev, false, true);
 	b43_gphy_channel_switch(dev, 6, 0);
 	b43_radio_read16(dev, 0x51);	/* dummy read */
 	if (phy->type == B43_PHYTYPE_G)
diff --git a/trunk/drivers/net/wireless/b43/main.c b/trunk/drivers/net/wireless/b43/main.c
index 950beefbeaeb..f6d039e303f4 100644
--- a/trunk/drivers/net/wireless/b43/main.c
+++ b/trunk/drivers/net/wireless/b43/main.c
@@ -691,9 +691,9 @@ static void b43_synchronize_irq(struct b43_wldev *dev)
 }
 
 /* DummyTransmission function, as documented on
- * http://bcm-specs.sipsolutions.net/DummyTransmission
+ * http://bcm-v4.sipsolutions.net/802.11/DummyTransmission
  */
-void b43_dummy_transmission(struct b43_wldev *dev)
+void b43_dummy_transmission(struct b43_wldev *dev, bool ofdm, bool pa_on)
 {
 	struct b43_wl *wl = dev->wl;
 	struct b43_phy *phy = &dev->phy;
@@ -707,19 +707,12 @@ void b43_dummy_transmission(struct b43_wldev *dev)
 		0x00000000,
 	};
 
-	switch (phy->type) {
-	case B43_PHYTYPE_A:
+	if (ofdm) {
 		max_loop = 0x1E;
 		buffer[0] = 0x000201CC;
-		break;
-	case B43_PHYTYPE_B:
-	case B43_PHYTYPE_G:
+	} else {
 		max_loop = 0xFA;
 		buffer[0] = 0x000B846E;
-		break;
-	default:
-		B43_WARN_ON(1);
-		return;
 	}
 
 	spin_lock_irq(&wl->irq_lock);
@@ -728,20 +721,35 @@ void b43_dummy_transmission(struct b43_wldev *dev)
 	for (i = 0; i < 5; i++)
 		b43_ram_write(dev, i * 4, buffer[i]);
 
-	/* Commit writes */
-	b43_read32(dev, B43_MMIO_MACCTL);
-
 	b43_write16(dev, 0x0568, 0x0000);
-	b43_write16(dev, 0x07C0, 0x0000);
-	value = ((phy->type == B43_PHYTYPE_A) ? 1 : 0);
+	if (dev->dev->id.revision < 11)
+		b43_write16(dev, 0x07C0, 0x0000);
+	else
+		b43_write16(dev, 0x07C0, 0x0100);
+	value = (ofdm ? 0x41 : 0x40);
 	b43_write16(dev, 0x050C, value);
+	if ((phy->type == B43_PHYTYPE_N) || (phy->type == B43_PHYTYPE_LP))
+		b43_write16(dev, 0x0514, 0x1A02);
 	b43_write16(dev, 0x0508, 0x0000);
 	b43_write16(dev, 0x050A, 0x0000);
 	b43_write16(dev, 0x054C, 0x0000);
 	b43_write16(dev, 0x056A, 0x0014);
 	b43_write16(dev, 0x0568, 0x0826);
 	b43_write16(dev, 0x0500, 0x0000);
-	b43_write16(dev, 0x0502, 0x0030);
+	if (!pa_on && (phy->type == B43_PHYTYPE_N)) {
+		//SPEC TODO
+	}
+
+	switch (phy->type) {
+	case B43_PHYTYPE_N:
+		b43_write16(dev, 0x0502, 0x00D0);
+		break;
+	case B43_PHYTYPE_LP:
+		b43_write16(dev, 0x0502, 0x0050);
+		break;
+	default:
+		b43_write16(dev, 0x0502, 0x0030);
+	}
 
 	if (phy->radio_ver == 0x2050 && phy->radio_rev <= 0x5)
 		b43_radio_write16(dev, 0x0051, 0x0017);
diff --git a/trunk/drivers/net/wireless/b43/main.h b/trunk/drivers/net/wireless/b43/main.h
index 950fb1b0546d..0406e06781d4 100644
--- a/trunk/drivers/net/wireless/b43/main.h
+++ b/trunk/drivers/net/wireless/b43/main.h
@@ -123,7 +123,7 @@ void __b43_shm_write16(struct b43_wldev *dev, u16 routing, u16 offset, u16 value
 u64 b43_hf_read(struct b43_wldev *dev);
 void b43_hf_write(struct b43_wldev *dev, u64 value);
 
-void b43_dummy_transmission(struct b43_wldev *dev);
+void b43_dummy_transmission(struct b43_wldev *dev, bool ofdm, bool pa_on);
 
 void b43_wireless_core_reset(struct b43_wldev *dev, u32 flags);
 
diff --git a/trunk/drivers/net/wireless/b43/phy_g.c b/trunk/drivers/net/wireless/b43/phy_g.c
index 5300232449f6..e47131216a67 100644
--- a/trunk/drivers/net/wireless/b43/phy_g.c
+++ b/trunk/drivers/net/wireless/b43/phy_g.c
@@ -333,7 +333,7 @@ static void b43_set_all_gains(struct b43_wldev *dev,
 		b43_phy_maskset(dev, 0x04A1, 0xBFBF, tmp);
 		b43_phy_maskset(dev, 0x04A2, 0xBFBF, tmp);
 	}
-	b43_dummy_transmission(dev);
+	b43_dummy_transmission(dev, false, true);
 }
 
 static void b43_set_original_gains(struct b43_wldev *dev)
@@ -365,7 +365,7 @@ static void b43_set_original_gains(struct b43_wldev *dev)
 	b43_phy_maskset(dev, 0x04A0, 0xBFBF, 0x4040);
 	b43_phy_maskset(dev, 0x04A1, 0xBFBF, 0x4040);
 	b43_phy_maskset(dev, 0x04A2, 0xBFBF, 0x4000);
-	b43_dummy_transmission(dev);
+	b43_dummy_transmission(dev, false, true);
 }
 
 /* http://bcm-specs.sipsolutions.net/NRSSILookupTable */
@@ -1964,7 +1964,7 @@ static void b43_phy_init_pctl(struct b43_wldev *dev)
 			}
 			b43_set_txpower_g(dev, &bbatt, &rfatt, 0);
 		}
-		b43_dummy_transmission(dev);
+		b43_dummy_transmission(dev, false, true);
 		gphy->cur_idle_tssi = b43_phy_read(dev, B43_PHY_ITSSI);
 		if (B43_DEBUG) {
 			/* Current-Idle-TSSI sanity check. */
diff --git a/trunk/drivers/net/wireless/b43/wa.c b/trunk/drivers/net/wireless/b43/wa.c
index e1e20f69f6d7..73e97fa4ddf7 100644
--- a/trunk/drivers/net/wireless/b43/wa.c
+++ b/trunk/drivers/net/wireless/b43/wa.c
@@ -37,7 +37,7 @@ static void b43_wa_papd(struct b43_wldev *dev)
 	backup = b43_ofdmtab_read16(dev, B43_OFDMTAB_PWRDYN2, 0);
 	b43_ofdmtab_write16(dev, B43_OFDMTAB_PWRDYN2, 0, 7);
 	b43_ofdmtab_write16(dev, B43_OFDMTAB_UNKNOWN_APHY, 0, 0);
-	b43_dummy_transmission(dev);
+	b43_dummy_transmission(dev, true, true);
 	b43_ofdmtab_write16(dev, B43_OFDMTAB_PWRDYN2, 0, backup);
 }
 
diff --git a/trunk/drivers/net/xilinx_emaclite.c b/trunk/drivers/net/xilinx_emaclite.c
deleted file mode 100755
index 7e05b40ae36b..000000000000
--- a/trunk/drivers/net/xilinx_emaclite.c
+++ /dev/null
@@ -1,1041 +0,0 @@
-/*
- * Xilinx EmacLite Linux driver for the Xilinx Ethernet MAC Lite device.
- *
- * This is a new flat driver which is based on the original emac_lite
- * driver from John Williams <john.williams@petalogix.com>.
- *
- * 2007-2009 (c) Xilinx, Inc.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation; either version 2 of the License, or (at your
- * option) any later version.
- */
-
-#include <linux/module.h>
-#include <linux/uaccess.h>
-#include <linux/init.h>
-#include <linux/netdevice.h>
-#include <linux/etherdevice.h>
-#include <linux/skbuff.h>
-#include <linux/io.h>
-
-#include <linux/of_device.h>
-#include <linux/of_platform.h>
-
-#define DRIVER_NAME "xilinx_emaclite"
-
-/* Register offsets for the EmacLite Core */
-#define XEL_TXBUFF_OFFSET 	0x0		/* Transmit Buffer */
-#define XEL_GIER_OFFSET		0x07F8		/* GIE Register */
-#define XEL_TSR_OFFSET		0x07FC		/* Tx status */
-#define XEL_TPLR_OFFSET		0x07F4		/* Tx packet length */
-
-#define XEL_RXBUFF_OFFSET	0x1000		/* Receive Buffer */
-#define XEL_RPLR_OFFSET		0x100C		/* Rx packet length */
-#define XEL_RSR_OFFSET		0x17FC		/* Rx status */
-
-#define XEL_BUFFER_OFFSET	0x0800		/* Next Tx/Rx buffer's offset */
-
-/* Global Interrupt Enable Register (GIER) Bit Masks */
-#define XEL_GIER_GIE_MASK	0x80000000 	/* Global Enable */
-
-/* Transmit Status Register (TSR) Bit Masks */
-#define XEL_TSR_XMIT_BUSY_MASK	 0x00000001 	/* Tx complete */
-#define XEL_TSR_PROGRAM_MASK	 0x00000002 	/* Program the MAC address */
-#define XEL_TSR_XMIT_IE_MASK	 0x00000008 	/* Tx interrupt enable bit */
-#define XEL_TSR_XMIT_ACTIVE_MASK 0x80000000 	/* Buffer is active, SW bit
-						 * only. This is not documented
-						 * in the HW spec */
-
-/* Define for programming the MAC address into the EmacLite */
-#define XEL_TSR_PROG_MAC_ADDR	(XEL_TSR_XMIT_BUSY_MASK | XEL_TSR_PROGRAM_MASK)
-
-/* Receive Status Register (RSR) */
-#define XEL_RSR_RECV_DONE_MASK	0x00000001 	/* Rx complete */
-#define XEL_RSR_RECV_IE_MASK	0x00000008 	/* Rx interrupt enable bit */
-
-/* Transmit Packet Length Register (TPLR) */
-#define XEL_TPLR_LENGTH_MASK	0x0000FFFF 	/* Tx packet length */
-
-/* Receive Packet Length Register (RPLR) */
-#define XEL_RPLR_LENGTH_MASK	0x0000FFFF 	/* Rx packet length */
-
-#define XEL_HEADER_OFFSET	12 		/* Offset to length field */
-#define XEL_HEADER_SHIFT	16 		/* Shift value for length */
-
-/* General Ethernet Definitions */
-#define XEL_ARP_PACKET_SIZE		28 	/* Max ARP packet size */
-#define XEL_HEADER_IP_LENGTH_OFFSET	16 	/* IP Length Offset */
-
-
-
-#define TX_TIMEOUT		(60*HZ)		/* Tx timeout is 60 seconds. */
-#define ALIGNMENT		4
-
-/* BUFFER_ALIGN(adr) calculates the number of bytes to the next alignment. */
-#define BUFFER_ALIGN(adr) ((ALIGNMENT - ((u32) adr)) % ALIGNMENT)
-
-/**
- * struct net_local - Our private per device data
- * @ndev:		instance of the network device
- * @tx_ping_pong:	indicates whether Tx Pong buffer is configured in HW
- * @rx_ping_pong:	indicates whether Rx Pong buffer is configured in HW
- * @next_tx_buf_to_use:	next Tx buffer to write to
- * @next_rx_buf_to_use:	next Rx buffer to read from
- * @base_addr:		base address of the Emaclite device
- * @reset_lock:		lock used for synchronization
- * @deferred_skb:	holds an skb (for transmission at a later time) when the
- *			Tx buffer is not free
- */
-struct net_local {
-
-	struct net_device *ndev;
-
-	bool tx_ping_pong;
-	bool rx_ping_pong;
-	u32 next_tx_buf_to_use;
-	u32 next_rx_buf_to_use;
-	void __iomem *base_addr;
-
-	spinlock_t reset_lock;
-	struct sk_buff *deferred_skb;
-};
-
-
-/*************************/
-/* EmacLite driver calls */
-/*************************/
-
-/**
- * xemaclite_enable_interrupts - Enable the interrupts for the EmacLite device
- * @drvdata:	Pointer to the Emaclite device private data
- *
- * This function enables the Tx and Rx interrupts for the Emaclite device along
- * with the Global Interrupt Enable.
- */
-static void xemaclite_enable_interrupts(struct net_local *drvdata)
-{
-	u32 reg_data;
-
-	/* Enable the Tx interrupts for the first Buffer */
-	reg_data = in_be32(drvdata->base_addr + XEL_TSR_OFFSET);
-	out_be32(drvdata->base_addr + XEL_TSR_OFFSET,
-		 reg_data | XEL_TSR_XMIT_IE_MASK);
-
-	/* Enable the Tx interrupts for the second Buffer if
-	 * configured in HW */
-	if (drvdata->tx_ping_pong != 0) {
-		reg_data = in_be32(drvdata->base_addr +
-				   XEL_BUFFER_OFFSET + XEL_TSR_OFFSET);
-		out_be32(drvdata->base_addr + XEL_BUFFER_OFFSET +
-			 XEL_TSR_OFFSET,
-			 reg_data | XEL_TSR_XMIT_IE_MASK);
-	}
-
-	/* Enable the Rx interrupts for the first buffer */
-	reg_data = in_be32(drvdata->base_addr + XEL_RSR_OFFSET);
-	out_be32(drvdata->base_addr + XEL_RSR_OFFSET,
-		 reg_data | XEL_RSR_RECV_IE_MASK);
-
-	/* Enable the Rx interrupts for the second Buffer if
-	 * configured in HW */
-	if (drvdata->rx_ping_pong != 0) {
-		reg_data = in_be32(drvdata->base_addr + XEL_BUFFER_OFFSET +
-				   XEL_RSR_OFFSET);
-		out_be32(drvdata->base_addr + XEL_BUFFER_OFFSET +
-			 XEL_RSR_OFFSET,
-			 reg_data | XEL_RSR_RECV_IE_MASK);
-	}
-
-	/* Enable the Global Interrupt Enable */
-	out_be32(drvdata->base_addr + XEL_GIER_OFFSET, XEL_GIER_GIE_MASK);
-}
-
-/**
- * xemaclite_disable_interrupts - Disable the interrupts for the EmacLite device
- * @drvdata:	Pointer to the Emaclite device private data
- *
- * This function disables the Tx and Rx interrupts for the Emaclite device,
- * along with the Global Interrupt Enable.
- */
-static void xemaclite_disable_interrupts(struct net_local *drvdata)
-{
-	u32 reg_data;
-
-	/* Disable the Global Interrupt Enable */
-	out_be32(drvdata->base_addr + XEL_GIER_OFFSET, XEL_GIER_GIE_MASK);
-
-	/* Disable the Tx interrupts for the first buffer */
-	reg_data = in_be32(drvdata->base_addr + XEL_TSR_OFFSET);
-	out_be32(drvdata->base_addr + XEL_TSR_OFFSET,
-		 reg_data & (~XEL_TSR_XMIT_IE_MASK));
-
-	/* Disable the Tx interrupts for the second Buffer
-	 * if configured in HW */
-	if (drvdata->tx_ping_pong != 0) {
-		reg_data = in_be32(drvdata->base_addr + XEL_BUFFER_OFFSET +
-				   XEL_TSR_OFFSET);
-		out_be32(drvdata->base_addr + XEL_BUFFER_OFFSET +
-			 XEL_TSR_OFFSET,
-			 reg_data & (~XEL_TSR_XMIT_IE_MASK));
-	}
-
-	/* Disable the Rx interrupts for the first buffer */
-	reg_data = in_be32(drvdata->base_addr + XEL_RSR_OFFSET);
-	out_be32(drvdata->base_addr + XEL_RSR_OFFSET,
-		 reg_data & (~XEL_RSR_RECV_IE_MASK));
-
-	/* Disable the Rx interrupts for the second buffer
-	 * if configured in HW */
-	if (drvdata->rx_ping_pong != 0) {
-
-		reg_data = in_be32(drvdata->base_addr + XEL_BUFFER_OFFSET +
-				   XEL_RSR_OFFSET);
-		out_be32(drvdata->base_addr + XEL_BUFFER_OFFSET +
-			 XEL_RSR_OFFSET,
-			 reg_data & (~XEL_RSR_RECV_IE_MASK));
-	}
-}
-
-/**
- * xemaclite_aligned_write - Write from 16-bit aligned to 32-bit aligned address
- * @src_ptr:	Void pointer to the 16-bit aligned source address
- * @dest_ptr:	Pointer to the 32-bit aligned destination address
- * @length:	Number bytes to write from source to destination
- *
- * This function writes data from a 16-bit aligned buffer to a 32-bit aligned
- * address in the EmacLite device.
- */
-static void xemaclite_aligned_write(void *src_ptr, u32 *dest_ptr,
-				    unsigned length)
-{
-	u32 align_buffer;
-	u32 *to_u32_ptr;
-	u16 *from_u16_ptr, *to_u16_ptr;
-
-	to_u32_ptr = dest_ptr;
-	from_u16_ptr = (u16 *) src_ptr;
-	align_buffer = 0;
-
-	for (; length > 3; length -= 4) {
-		to_u16_ptr = (u16 *) ((void *) &align_buffer);
-		*to_u16_ptr++ = *from_u16_ptr++;
-		*to_u16_ptr++ = *from_u16_ptr++;
-
-		/* Output a word */
-		*to_u32_ptr++ = align_buffer;
-	}
-	if (length) {
-		u8 *from_u8_ptr, *to_u8_ptr;
-
-		/* Set up to output the remaining data */
-		align_buffer = 0;
-		to_u8_ptr = (u8 *) &align_buffer;
-		from_u8_ptr = (u8 *) from_u16_ptr;
-
-		/* Output the remaining data */
-		for (; length > 0; length--)
-			*to_u8_ptr++ = *from_u8_ptr++;
-
-		*to_u32_ptr = align_buffer;
-	}
-}
-
-/**
- * xemaclite_aligned_read - Read from 32-bit aligned to 16-bit aligned buffer
- * @src_ptr:	Pointer to the 32-bit aligned source address
- * @dest_ptr:	Pointer to the 16-bit aligned destination address
- * @length:	Number bytes to read from source to destination
- *
- * This function reads data from a 32-bit aligned address in the EmacLite device
- * to a 16-bit aligned buffer.
- */
-static void xemaclite_aligned_read(u32 *src_ptr, u8 *dest_ptr,
-				   unsigned length)
-{
-	u16 *to_u16_ptr, *from_u16_ptr;
-	u32 *from_u32_ptr;
-	u32 align_buffer;
-
-	from_u32_ptr = src_ptr;
-	to_u16_ptr = (u16 *) dest_ptr;
-
-	for (; length > 3; length -= 4) {
-		/* Copy each word into the temporary buffer */
-		align_buffer = *from_u32_ptr++;
-		from_u16_ptr = (u16 *)&align_buffer;
-
-		/* Read data from source */
-		*to_u16_ptr++ = *from_u16_ptr++;
-		*to_u16_ptr++ = *from_u16_ptr++;
-	}
-
-	if (length) {
-		u8 *to_u8_ptr, *from_u8_ptr;
-
-		/* Set up to read the remaining data */
-		to_u8_ptr = (u8 *) to_u16_ptr;
-		align_buffer = *from_u32_ptr++;
-		from_u8_ptr = (u8 *) &align_buffer;
-
-		/* Read the remaining data */
-		for (; length > 0; length--)
-			*to_u8_ptr = *from_u8_ptr;
-	}
-}
-
-/**
- * xemaclite_send_data - Send an Ethernet frame
- * @drvdata:	Pointer to the Emaclite device private data
- * @data:	Pointer to the data to be sent
- * @byte_count:	Total frame size, including header
- *
- * This function checks if the Tx buffer of the Emaclite device is free to send
- * data. If so, it fills the Tx buffer with data for transmission. Otherwise, it
- * returns an error.
- *
- * Return:	0 upon success or -1 if the buffer(s) are full.
- *
- * Note:	The maximum Tx packet size can not be more than Ethernet header
- *		(14 Bytes) + Maximum MTU (1500 bytes). This is excluding FCS.
- */
-static int xemaclite_send_data(struct net_local *drvdata, u8 *data,
-			       unsigned int byte_count)
-{
-	u32 reg_data;
-	void __iomem *addr;
-
-	/* Determine the expected Tx buffer address */
-	addr = drvdata->base_addr + drvdata->next_tx_buf_to_use;
-
-	/* If the length is too large, truncate it */
-	if (byte_count > ETH_FRAME_LEN)
-		byte_count = ETH_FRAME_LEN;
-
-	/* Check if the expected buffer is available */
-	reg_data = in_be32(addr + XEL_TSR_OFFSET);
-	if ((reg_data & (XEL_TSR_XMIT_BUSY_MASK |
-	     XEL_TSR_XMIT_ACTIVE_MASK)) == 0) {
-
-		/* Switch to next buffer if configured */
-		if (drvdata->tx_ping_pong != 0)
-			drvdata->next_tx_buf_to_use ^= XEL_BUFFER_OFFSET;
-	} else if (drvdata->tx_ping_pong != 0) {
-		/* If the expected buffer is full, try the other buffer,
-		 * if it is configured in HW */
-
-		addr = (void __iomem __force *)((u32 __force)addr ^
-						 XEL_BUFFER_OFFSET);
-		reg_data = in_be32(addr + XEL_TSR_OFFSET);
-
-		if ((reg_data & (XEL_TSR_XMIT_BUSY_MASK |
-		     XEL_TSR_XMIT_ACTIVE_MASK)) != 0)
-			return -1; /* Buffers were full, return failure */
-	} else
-		return -1; /* Buffer was full, return failure */
-
-	/* Write the frame to the buffer */
-	xemaclite_aligned_write(data, (u32 __force *) addr, byte_count);
-
-	out_be32(addr + XEL_TPLR_OFFSET, (byte_count & XEL_TPLR_LENGTH_MASK));
-
-	/* Update the Tx Status Register to indicate that there is a
-	 * frame to send. Set the XEL_TSR_XMIT_ACTIVE_MASK flag which
-	 * is used by the interrupt handler to check whether a frame
-	 * has been transmitted */
-	reg_data = in_be32(addr + XEL_TSR_OFFSET);
-	reg_data |= (XEL_TSR_XMIT_BUSY_MASK | XEL_TSR_XMIT_ACTIVE_MASK);
-	out_be32(addr + XEL_TSR_OFFSET, reg_data);
-
-	return 0;
-}
-
-/**
- * xemaclite_recv_data - Receive a frame
- * @drvdata:	Pointer to the Emaclite device private data
- * @data:	Address where the data is to be received
- *
- * This function is intended to be called from the interrupt context or
- * with a wrapper which waits for the receive frame to be available.
- *
- * Return:	Total number of bytes received
- */
-static u16 xemaclite_recv_data(struct net_local *drvdata, u8 *data)
-{
-	void __iomem *addr;
-	u16 length, proto_type;
-	u32 reg_data;
-
-	/* Determine the expected buffer address */
-	addr = (drvdata->base_addr + drvdata->next_rx_buf_to_use);
-
-	/* Verify which buffer has valid data */
-	reg_data = in_be32(addr + XEL_RSR_OFFSET);
-
-	if ((reg_data & XEL_RSR_RECV_DONE_MASK) == XEL_RSR_RECV_DONE_MASK) {
-		if (drvdata->rx_ping_pong != 0)
-			drvdata->next_rx_buf_to_use ^= XEL_BUFFER_OFFSET;
-	} else {
-		/* The instance is out of sync, try other buffer if other
-		 * buffer is configured, return 0 otherwise. If the instance is
-		 * out of sync, do not update the 'next_rx_buf_to_use' since it
-		 * will correct on subsequent calls */
-		if (drvdata->rx_ping_pong != 0)
-			addr = (void __iomem __force *)((u32 __force)addr ^
-							 XEL_BUFFER_OFFSET);
-		else
-			return 0;	/* No data was available */
-
-		/* Verify that buffer has valid data */
-		reg_data = in_be32(addr + XEL_RSR_OFFSET);
-		if ((reg_data & XEL_RSR_RECV_DONE_MASK) !=
-		     XEL_RSR_RECV_DONE_MASK)
-			return 0;	/* No data was available */
-	}
-
-	/* Get the protocol type of the ethernet frame that arrived */
-	proto_type = ((in_be32(addr + XEL_HEADER_OFFSET +
-			XEL_RXBUFF_OFFSET) >> XEL_HEADER_SHIFT) &
-			XEL_RPLR_LENGTH_MASK);
-
-	/* Check if received ethernet frame is a raw ethernet frame
-	 * or an IP packet or an ARP packet */
-	if (proto_type > (ETH_FRAME_LEN + ETH_FCS_LEN)) {
-
-		if (proto_type == ETH_P_IP) {
-			length = ((in_be32(addr +
-					XEL_HEADER_IP_LENGTH_OFFSET +
-					XEL_RXBUFF_OFFSET) >>
-					XEL_HEADER_SHIFT) &
-					XEL_RPLR_LENGTH_MASK);
-			length += ETH_HLEN + ETH_FCS_LEN;
-
-		} else if (proto_type == ETH_P_ARP)
-			length = XEL_ARP_PACKET_SIZE + ETH_HLEN + ETH_FCS_LEN;
-		else
-			/* Field contains type other than IP or ARP, use max
-			 * frame size and let user parse it */
-			length = ETH_FRAME_LEN + ETH_FCS_LEN;
-	} else
-		/* Use the length in the frame, plus the header and trailer */
-		length = proto_type + ETH_HLEN + ETH_FCS_LEN;
-
-	/* Read from the EmacLite device */
-	xemaclite_aligned_read((u32 __force *) (addr + XEL_RXBUFF_OFFSET),
-				data, length);
-
-	/* Acknowledge the frame */
-	reg_data = in_be32(addr + XEL_RSR_OFFSET);
-	reg_data &= ~XEL_RSR_RECV_DONE_MASK;
-	out_be32(addr + XEL_RSR_OFFSET, reg_data);
-
-	return length;
-}
-
-/**
- * xemaclite_set_mac_address - Set the MAC address for this device
- * @drvdata:	Pointer to the Emaclite device private data
- * @address_ptr:Pointer to the MAC address (MAC address is a 48-bit value)
- *
- * Tx must be idle and Rx should be idle for deterministic results.
- * It is recommended that this function should be called after the
- * initialization and before transmission of any packets from the device.
- * The MAC address can be programmed using any of the two transmit
- * buffers (if configured).
- */
-static void xemaclite_set_mac_address(struct net_local *drvdata,
-				      u8 *address_ptr)
-{
-	void __iomem *addr;
-	u32 reg_data;
-
-	/* Determine the expected Tx buffer address */
-	addr = drvdata->base_addr + drvdata->next_tx_buf_to_use;
-
-	xemaclite_aligned_write(address_ptr, (u32 __force *) addr, ETH_ALEN);
-
-	out_be32(addr + XEL_TPLR_OFFSET, ETH_ALEN);
-
-	/* Update the MAC address in the EmacLite */
-	reg_data = in_be32(addr + XEL_TSR_OFFSET);
-	out_be32(addr + XEL_TSR_OFFSET, reg_data | XEL_TSR_PROG_MAC_ADDR);
-
-	/* Wait for EmacLite to finish with the MAC address update */
-	while ((in_be32(addr + XEL_TSR_OFFSET) &
-		XEL_TSR_PROG_MAC_ADDR) != 0)
-		;
-}
-
-/**
- * xemaclite_tx_timeout - Callback for Tx Timeout
- * @dev:	Pointer to the network device
- *
- * This function is called when Tx time out occurs for Emaclite device.
- */
-static void xemaclite_tx_timeout(struct net_device *dev)
-{
-	struct net_local *lp = (struct net_local *) netdev_priv(dev);
-	unsigned long flags;
-
-	dev_err(&lp->ndev->dev, "Exceeded transmit timeout of %lu ms\n",
-		TX_TIMEOUT * 1000UL / HZ);
-
-	dev->stats.tx_errors++;
-
-	/* Reset the device */
-	spin_lock_irqsave(&lp->reset_lock, flags);
-
-	/* Shouldn't really be necessary, but shouldn't hurt */
-	netif_stop_queue(dev);
-
-	xemaclite_disable_interrupts(lp);
-	xemaclite_enable_interrupts(lp);
-
-	if (lp->deferred_skb) {
-		dev_kfree_skb(lp->deferred_skb);
-		lp->deferred_skb = NULL;
-		dev->stats.tx_errors++;
-	}
-
-	/* To exclude tx timeout */
-	dev->trans_start = 0xffffffff - TX_TIMEOUT - TX_TIMEOUT;
-
-	/* We're all ready to go. Start the queue */
-	netif_wake_queue(dev);
-	spin_unlock_irqrestore(&lp->reset_lock, flags);
-}
-
-/**********************/
-/* Interrupt Handlers */
-/**********************/
-
-/**
- * xemaclite_tx_handler - Interrupt handler for frames sent
- * @dev:	Pointer to the network device
- *
- * This function updates the number of packets transmitted and handles the
- * deferred skb, if there is one.
- */
-static void xemaclite_tx_handler(struct net_device *dev)
-{
-	struct net_local *lp = (struct net_local *) netdev_priv(dev);
-
-	dev->stats.tx_packets++;
-	if (lp->deferred_skb) {
-		if (xemaclite_send_data(lp,
-					(u8 *) lp->deferred_skb->data,
-					lp->deferred_skb->len) != 0)
-			return;
-		else {
-			dev->stats.tx_bytes += lp->deferred_skb->len;
-			dev_kfree_skb_irq(lp->deferred_skb);
-			lp->deferred_skb = NULL;
-			dev->trans_start = jiffies;
-			netif_wake_queue(dev);
-		}
-	}
-}
-
-/**
- * xemaclite_rx_handler- Interrupt handler for frames received
- * @dev:	Pointer to the network device
- *
- * This function allocates memory for a socket buffer, fills it with data
- * received and hands it over to the TCP/IP stack.
- */
-static void xemaclite_rx_handler(struct net_device *dev)
-{
-	struct net_local *lp = (struct net_local *) netdev_priv(dev);
-	struct sk_buff *skb;
-	unsigned int align;
-	u32 len;
-
-	len = ETH_FRAME_LEN + ETH_FCS_LEN;
-	skb = dev_alloc_skb(len + ALIGNMENT);
-	if (!skb) {
-		/* Couldn't get memory. */
-		dev->stats.rx_dropped++;
-		dev_err(&lp->ndev->dev, "Could not allocate receive buffer\n");
-		return;
-	}
-
-	/*
-	 * A new skb should have the data halfword aligned, but this code is
-	 * here just in case that isn't true. Calculate how many
-	 * bytes we should reserve to get the data to start on a word
-	 * boundary */
-	align = BUFFER_ALIGN(skb->data);
-	if (align)
-		skb_reserve(skb, align);
-
-	skb_reserve(skb, 2);
-
-	len = xemaclite_recv_data(lp, (u8 *) skb->data);
-
-	if (!len) {
-		dev->stats.rx_errors++;
-		dev_kfree_skb_irq(skb);
-		return;
-	}
-
-	skb_put(skb, len);	/* Tell the skb how much data we got */
-	skb->dev = dev;		/* Fill out required meta-data */
-
-	skb->protocol = eth_type_trans(skb, dev);
-	skb->ip_summed = CHECKSUM_NONE;
-
-	dev->stats.rx_packets++;
-	dev->stats.rx_bytes += len;
-	dev->last_rx = jiffies;
-
-	netif_rx(skb);		/* Send the packet upstream */
-}
-
-/**
- * xemaclite_interrupt - Interrupt handler for this driver
- * @irq:	Irq of the Emaclite device
- * @dev_id:	Void pointer to the network device instance used as callback
- *		reference
- *
- * This function handles the Tx and Rx interrupts of the EmacLite device.
- */
-static irqreturn_t xemaclite_interrupt(int irq, void *dev_id)
-{
-	bool tx_complete = 0;
-	struct net_device *dev = dev_id;
-	struct net_local *lp = (struct net_local *) netdev_priv(dev);
-	void __iomem *base_addr = lp->base_addr;
-	u32 tx_status;
-
-	/* Check if there is Rx Data available */
-	if ((in_be32(base_addr + XEL_RSR_OFFSET) & XEL_RSR_RECV_DONE_MASK) ||
-			(in_be32(base_addr + XEL_BUFFER_OFFSET + XEL_RSR_OFFSET)
-			 & XEL_RSR_RECV_DONE_MASK))
-
-		xemaclite_rx_handler(dev);
-
-	/* Check if the Transmission for the first buffer is completed */
-	tx_status = in_be32(base_addr + XEL_TSR_OFFSET);
-	if (((tx_status & XEL_TSR_XMIT_BUSY_MASK) == 0) &&
-		(tx_status & XEL_TSR_XMIT_ACTIVE_MASK) != 0) {
-
-		tx_status &= ~XEL_TSR_XMIT_ACTIVE_MASK;
-		out_be32(base_addr + XEL_TSR_OFFSET, tx_status);
-
-		tx_complete = 1;
-	}
-
-	/* Check if the Transmission for the second buffer is completed */
-	tx_status = in_be32(base_addr + XEL_BUFFER_OFFSET + XEL_TSR_OFFSET);
-	if (((tx_status & XEL_TSR_XMIT_BUSY_MASK) == 0) &&
-		(tx_status & XEL_TSR_XMIT_ACTIVE_MASK) != 0) {
-
-		tx_status &= ~XEL_TSR_XMIT_ACTIVE_MASK;
-		out_be32(base_addr + XEL_BUFFER_OFFSET + XEL_TSR_OFFSET,
-			 tx_status);
-
-		tx_complete = 1;
-	}
-
-	/* If there was a Tx interrupt, call the Tx Handler */
-	if (tx_complete != 0)
-		xemaclite_tx_handler(dev);
-
-	return IRQ_HANDLED;
-}
-
-/**
- * xemaclite_open - Open the network device
- * @dev:	Pointer to the network device
- *
- * This function sets the MAC address, requests an IRQ and enables interrupts
- * for the Emaclite device and starts the Tx queue.
- */
-static int xemaclite_open(struct net_device *dev)
-{
-	struct net_local *lp = (struct net_local *) netdev_priv(dev);
-	int retval;
-
-	/* Just to be safe, stop the device first */
-	xemaclite_disable_interrupts(lp);
-
-	/* Set the MAC address each time opened */
-	xemaclite_set_mac_address(lp, dev->dev_addr);
-
-	/* Grab the IRQ */
-	retval = request_irq(dev->irq, &xemaclite_interrupt, 0, dev->name, dev);
-	if (retval) {
-		dev_err(&lp->ndev->dev, "Could not allocate interrupt %d\n",
-			dev->irq);
-		return retval;
-	}
-
-	/* Enable Interrupts */
-	xemaclite_enable_interrupts(lp);
-
-	/* We're ready to go */
-	netif_start_queue(dev);
-
-	return 0;
-}
-
-/**
- * xemaclite_close - Close the network device
- * @dev:	Pointer to the network device
- *
- * This function stops the Tx queue, disables interrupts and frees the IRQ for
- * the Emaclite device.
- */
-static int xemaclite_close(struct net_device *dev)
-{
-	struct net_local *lp = (struct net_local *) netdev_priv(dev);
-
-	netif_stop_queue(dev);
-	xemaclite_disable_interrupts(lp);
-	free_irq(dev->irq, dev);
-
-	return 0;
-}
-
-/**
- * xemaclite_get_stats - Get the stats for the net_device
- * @dev:	Pointer to the network device
- *
- * This function returns the address of the 'net_device_stats' structure for the
- * given network device. This structure holds usage statistics for the network
- * device.
- *
- * Return:	Pointer to the net_device_stats structure.
- */
-static struct net_device_stats *xemaclite_get_stats(struct net_device *dev)
-{
-	return &dev->stats;
-}
-
-/**
- * xemaclite_send - Transmit a frame
- * @orig_skb:	Pointer to the socket buffer to be transmitted
- * @dev:	Pointer to the network device
- *
- * This function checks if the Tx buffer of the Emaclite device is free to send
- * data. If so, it fills the Tx buffer with data from socket buffer data,
- * updates the stats and frees the socket buffer. The Tx completion is signaled
- * by an interrupt. If the Tx buffer isn't free, then the socket buffer is
- * deferred and the Tx queue is stopped so that the deferred socket buffer can
- * be transmitted when the Emaclite device is free to transmit data.
- *
- * Return:	0, always.
- */
-static int xemaclite_send(struct sk_buff *orig_skb, struct net_device *dev)
-{
-	struct net_local *lp = (struct net_local *) netdev_priv(dev);
-	struct sk_buff *new_skb;
-	unsigned int len;
-	unsigned long flags;
-
-	len = orig_skb->len;
-
-	new_skb = orig_skb;
-
-	spin_lock_irqsave(&lp->reset_lock, flags);
-	if (xemaclite_send_data(lp, (u8 *) new_skb->data, len) != 0) {
-		/* If the Emaclite Tx buffer is busy, stop the Tx queue and
-		 * defer the skb for transmission at a later point when the
-		 * current transmission is complete */
-		netif_stop_queue(dev);
-		lp->deferred_skb = new_skb;
-		spin_unlock_irqrestore(&lp->reset_lock, flags);
-		return 0;
-	}
-	spin_unlock_irqrestore(&lp->reset_lock, flags);
-
-	dev->stats.tx_bytes += len;
-	dev_kfree_skb(new_skb);
-	dev->trans_start = jiffies;
-
-	return 0;
-}
-
-/**
- * xemaclite_ioctl - Perform IO Control operations on the network device
- * @dev:	Pointer to the network device
- * @rq:		Pointer to the interface request structure
- * @cmd:	IOCTL command
- *
- * The only IOCTL operation supported by this function is setting the MAC
- * address. An error is reported if any other operations are requested.
- *
- * Return:	0 to indicate success, or a negative error for failure.
- */
-static int xemaclite_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
-{
-	struct net_local *lp = (struct net_local *) netdev_priv(dev);
-	struct hw_addr_data *hw_addr = (struct hw_addr_data *) &rq->ifr_hwaddr;
-
-	switch (cmd) {
-	case SIOCETHTOOL:
-		return -EIO;
-
-	case SIOCSIFHWADDR:
-		dev_err(&lp->ndev->dev, "SIOCSIFHWADDR\n");
-
-		/* Copy MAC address in from user space */
-		copy_from_user((void __force *) dev->dev_addr,
-			       (void __user __force *) hw_addr,
-			       IFHWADDRLEN);
-		xemaclite_set_mac_address(lp, dev->dev_addr);
-		break;
-	default:
-		return -EOPNOTSUPP;
-	}
-
-	return 0;
-}
-
-/**
- * xemaclite_remove_ndev - Free the network device
- * @ndev:	Pointer to the network device to be freed
- *
- * This function un maps the IO region of the Emaclite device and frees the net
- * device.
- */
-static void xemaclite_remove_ndev(struct net_device *ndev)
-{
-	if (ndev) {
-		struct net_local *lp = (struct net_local *) netdev_priv(ndev);
-
-		if (lp->base_addr)
-			iounmap((void __iomem __force *) (lp->base_addr));
-		free_netdev(ndev);
-	}
-}
-
-/**
- * get_bool - Get a parameter from the OF device
- * @ofdev:	Pointer to OF device structure
- * @s:		Property to be retrieved
- *
- * This function looks for a property in the device node and returns the value
- * of the property if its found or 0 if the property is not found.
- *
- * Return:	Value of the parameter if the parameter is found, or 0 otherwise
- */
-static bool get_bool(struct of_device *ofdev, const char *s)
-{
-	u32 *p = (u32 *)of_get_property(ofdev->node, s, NULL);
-
-	if (p) {
-		return (bool)*p;
-	} else {
-		dev_warn(&ofdev->dev, "Parameter %s not found,"
-			"defaulting to false\n", s);
-		return 0;
-	}
-}
-
-static struct net_device_ops xemaclite_netdev_ops;
-
-/**
- * xemaclite_of_probe - Probe method for the Emaclite device.
- * @ofdev:	Pointer to OF device structure
- * @match:	Pointer to the structure used for matching a device
- *
- * This function probes for the Emaclite device in the device tree.
- * It initializes the driver data structure and the hardware, sets the MAC
- * address and registers the network device.
- *
- * Return:	0, if the driver is bound to the Emaclite device, or
- *		a negative error if there is failure.
- */
-static int __devinit xemaclite_of_probe(struct of_device *ofdev,
-					const struct of_device_id *match)
-{
-	struct resource r_irq; /* Interrupt resources */
-	struct resource r_mem; /* IO mem resources */
-	struct net_device *ndev = NULL;
-	struct net_local *lp = NULL;
-	struct device *dev = &ofdev->dev;
-	const void *mac_address;
-
-	int rc = 0;
-
-	dev_info(dev, "Device Tree Probing\n");
-
-	/* Get iospace for the device */
-	rc = of_address_to_resource(ofdev->node, 0, &r_mem);
-	if (rc) {
-		dev_err(dev, "invalid address\n");
-		return rc;
-	}
-
-	/* Get IRQ for the device */
-	rc = of_irq_to_resource(ofdev->node, 0, &r_irq);
-	if (rc == NO_IRQ) {
-		dev_err(dev, "no IRQ found\n");
-		return rc;
-	}
-
-	/* Create an ethernet device instance */
-	ndev = alloc_etherdev(sizeof(struct net_local));
-	if (!ndev) {
-		dev_err(dev, "Could not allocate network device\n");
-		return -ENOMEM;
-	}
-
-	dev_set_drvdata(dev, ndev);
-
-	ndev->irq = r_irq.start;
-	ndev->mem_start = r_mem.start;
-	ndev->mem_end = r_mem.end;
-
-	lp = netdev_priv(ndev);
-	lp->ndev = ndev;
-
-	if (!request_mem_region(ndev->mem_start,
-				ndev->mem_end - ndev->mem_start + 1,
-				DRIVER_NAME)) {
-		dev_err(dev, "Couldn't lock memory region at %p\n",
-			(void *)ndev->mem_start);
-		rc = -EBUSY;
-		goto error2;
-	}
-
-	/* Get the virtual base address for the device */
-	lp->base_addr = ioremap(r_mem.start, r_mem.end - r_mem.start + 1);
-	if (NULL == lp->base_addr) {
-		dev_err(dev, "EmacLite: Could not allocate iomem\n");
-		rc = -EIO;
-		goto error1;
-	}
-
-	spin_lock_init(&lp->reset_lock);
-	lp->next_tx_buf_to_use = 0x0;
-	lp->next_rx_buf_to_use = 0x0;
-	lp->tx_ping_pong = get_bool(ofdev, "xlnx,tx-ping-pong");
-	lp->rx_ping_pong = get_bool(ofdev, "xlnx,rx-ping-pong");
-	mac_address = of_get_mac_address(ofdev->node);
-
-	if (mac_address)
-		/* Set the MAC address. */
-		memcpy(ndev->dev_addr, mac_address, 6);
-	else
-		dev_warn(dev, "No MAC address found\n");
-
-	/* Clear the Tx CSR's in case this is a restart */
-	out_be32(lp->base_addr + XEL_TSR_OFFSET, 0);
-	out_be32(lp->base_addr + XEL_BUFFER_OFFSET + XEL_TSR_OFFSET, 0);
-
-	/* Set the MAC address in the EmacLite device */
-	xemaclite_set_mac_address(lp, ndev->dev_addr);
-
-	dev_info(dev,
-		 "MAC address is now %2x:%2x:%2x:%2x:%2x:%2x\n",
-		 ndev->dev_addr[0], ndev->dev_addr[1],
-		 ndev->dev_addr[2], ndev->dev_addr[3],
-		 ndev->dev_addr[4], ndev->dev_addr[5]);
-
-	ndev->netdev_ops = &xemaclite_netdev_ops;
-	ndev->flags &= ~IFF_MULTICAST;
-	ndev->watchdog_timeo = TX_TIMEOUT;
-
-	/* Finally, register the device */
-	rc = register_netdev(ndev);
-	if (rc) {
-		dev_err(dev,
-			"Cannot register network device, aborting\n");
-		goto error1;
-	}
-
-	dev_info(dev,
-		 "Xilinx EmacLite at 0x%08X mapped to 0x%08X, irq=%d\n",
-		 (unsigned int __force)ndev->mem_start,
-		 (unsigned int __force)lp->base_addr, ndev->irq);
-	return 0;
-
-error1:
-	release_mem_region(ndev->mem_start, r_mem.end - r_mem.start + 1);
-
-error2:
-	xemaclite_remove_ndev(ndev);
-	return rc;
-}
-
-/**
- * xemaclite_of_remove - Unbind the driver from the Emaclite device.
- * @of_dev:	Pointer to OF device structure
- *
- * This function is called if a device is physically removed from the system or
- * if the driver module is being unloaded. It frees any resources allocated to
- * the device.
- *
- * Return:	0, always.
- */
-static int __devexit xemaclite_of_remove(struct of_device *of_dev)
-{
-	struct device *dev = &of_dev->dev;
-	struct net_device *ndev = dev_get_drvdata(dev);
-
-	unregister_netdev(ndev);
-
-	release_mem_region(ndev->mem_start, ndev->mem_end-ndev->mem_start + 1);
-
-	xemaclite_remove_ndev(ndev);
-
-	dev_set_drvdata(dev, NULL);
-
-	return 0;
-}
-
-static struct net_device_ops xemaclite_netdev_ops = {
-	.ndo_open		= xemaclite_open,
-	.ndo_stop		= xemaclite_close,
-	.ndo_start_xmit		= xemaclite_send,
-	.ndo_do_ioctl		= xemaclite_ioctl,
-	.ndo_tx_timeout		= xemaclite_tx_timeout,
-	.ndo_get_stats		= xemaclite_get_stats,
-};
-
-/* Match table for OF platform binding */
-static struct of_device_id xemaclite_of_match[] __devinitdata = {
-	{ .compatible = "xlnx,opb-ethernetlite-1.01.a", },
-	{ .compatible = "xlnx,opb-ethernetlite-1.01.b", },
-	{ .compatible = "xlnx,xps-ethernetlite-1.00.a", },
-	{ .compatible = "xlnx,xps-ethernetlite-2.00.a", },
-	{ .compatible = "xlnx,xps-ethernetlite-2.01.a", },
-	{ /* end of list */ },
-};
-MODULE_DEVICE_TABLE(of, xemaclite_of_match);
-
-static struct of_platform_driver xemaclite_of_driver = {
-	.name		= DRIVER_NAME,
-	.match_table	= xemaclite_of_match,
-	.probe		= xemaclite_of_probe,
-	.remove		= __devexit_p(xemaclite_of_remove),
-};
-
-/**
- * xgpiopss_init - Initial driver registration call
- *
- * Return:	0 upon success, or a negative error upon failure.
- */
-static int __init xemaclite_init(void)
-{
-	/* No kernel boot options used, we just need to register the driver */
-	return of_register_platform_driver(&xemaclite_of_driver);
-}
-
-/**
- * xemaclite_cleanup - Driver un-registration call
- */
-static void __exit xemaclite_cleanup(void)
-{
-	of_unregister_platform_driver(&xemaclite_of_driver);
-}
-
-module_init(xemaclite_init);
-module_exit(xemaclite_cleanup);
-
-MODULE_AUTHOR("Xilinx, Inc.");
-MODULE_DESCRIPTION("Xilinx Ethernet MAC Lite driver");
-MODULE_LICENSE("GPL");
diff --git a/trunk/include/linux/mdio.h b/trunk/include/linux/mdio.h
index c779b49a1fda..cfdf1df2875e 100644
--- a/trunk/include/linux/mdio.h
+++ b/trunk/include/linux/mdio.h
@@ -304,7 +304,7 @@ static inline __u16 mdio_phy_id_devad(int phy_id)
  */
 struct mdio_if_info {
 	int prtad;
-	u32 mmds;
+	u32 __bitwise mmds;
 	unsigned mode_support;
 
 	struct net_device *dev;
diff --git a/trunk/kernel/trace/Kconfig b/trunk/kernel/trace/Kconfig
index 9a2f19bf0512..f09d7635c0e1 100644
--- a/trunk/kernel/trace/Kconfig
+++ b/trunk/kernel/trace/Kconfig
@@ -236,7 +236,6 @@ config BOOT_TRACER
 
 config SKB_SOURCES_TRACER
 	bool "Trace skb source information"
-	depends on NET
 	select GENERIC_TRACER
 	help
 	   This tracer helps developers/sysadmins correlate skb allocation and
diff --git a/trunk/net/phonet/socket.c b/trunk/net/phonet/socket.c
index 7a4ee397d2f7..5f26c3711a1e 100644
--- a/trunk/net/phonet/socket.c
+++ b/trunk/net/phonet/socket.c
@@ -413,7 +413,6 @@ int pn_sock_get_port(struct sock *sk, unsigned short sport)
 }
 EXPORT_SYMBOL(pn_sock_get_port);
 
-#ifdef CONFIG_PROC_FS
 static struct sock *pn_sock_get_idx(struct seq_file *seq, loff_t pos)
 {
 	struct net *net = seq_file_net(seq);
@@ -510,4 +509,3 @@ const struct file_operations pn_sock_seq_fops = {
 	.llseek = seq_lseek,
 	.release = seq_release_net,
 };
-#endif