brcm47xx: update bgmac driver to the version in mainline kernel

SVN-Revision: 35083

1 files changed, 454 insertions, 156 deletions

diff --git a/target/linux/brcm47xx/patches-3.6/750-bgmac.patch b/target/linux/brcm47xx/patches-3.6/750-bgmac.patch
index 7668ad38b7..b8fd0bae28 100644
--- a/target/linux/brcm47xx/patches-3.6/750-bgmac.patch
+++ b/target/linux/brcm47xx/patches-3.6/750-bgmac.patch
@@ -1,6 +1,49 @@
+From dd4544f05469aaaeee891d7dc54d66430344321e Mon Sep 17 00:00:00 2001
+From: =?utf8?q?Rafa=C5=82=20Mi=C5=82ecki?= <zajec5@gmail.com>
+Date: Tue, 8 Jan 2013 20:06:23 +0000
+Subject: [PATCH] bgmac: driver for GBit MAC core on BCMA bus
+MIME-Version: 1.0
+Content-Type: text/plain; charset=utf8
+Content-Transfer-Encoding: 8bit
+
+BCMA is a Broadcom specific bus with devices AKA cores. All recent BCMA
+based SoCs have gigabit ethernet provided by the GBit MAC core. This
+patch adds driver for such a cores registering itself as a netdev. It
+has been tested on a BCM4706 and BCM4718 chipsets.
+
+In the kernel tree there is already b44 driver which has some common
+things with bgmac, however there are many differences that has led to
+the decision or writing a new driver:
+1) GBit MAC cores appear on BCMA bus (not SSB as in case of b44)
+2) There is 64bit DMA engine which differs from 32bit one
+3) There is no CAM (Content Addressable Memory) in GBit MAC
+4) We have 4 TX queues on GBit MAC devices (instead of 1)
+5) Many registers have different addresses/values
+6) RX header flags are also different
+
+The driver in it's state is functional how, however there is of course
+place for improvements:
+1) Supporting more net_device_ops
+2) SUpporting more ethtool_ops
+3) Unaligned addressing in DMA
+4) Writing separated PHY driver
+
+Signed-off-by: Rafał Miłecki <zajec5@gmail.com>
+Signed-off-by: David S. Miller <davem@davemloft.net>
+---
+ drivers/bcma/driver_chipcommon_pmu.c        |    3 +-
+ drivers/net/ethernet/broadcom/Kconfig       |    9 +
+ drivers/net/ethernet/broadcom/Makefile      |    1 +
+ drivers/net/ethernet/broadcom/bgmac.c       | 1422 +++++++++++++++++++++++++++
+ drivers/net/ethernet/broadcom/bgmac.h       |  456 +++++++++
+ include/linux/bcma/bcma_driver_chipcommon.h |    2 +
+ 6 files changed, 1892 insertions(+), 1 deletions(-)
+ create mode 100644 drivers/net/ethernet/broadcom/bgmac.c
+ create mode 100644 drivers/net/ethernet/broadcom/bgmac.h
+
 --- a/drivers/bcma/driver_chipcommon_pmu.c
 +++ b/drivers/bcma/driver_chipcommon_pmu.c
-@@ -263,7 +263,7 @@ static u32 bcma_pmu_pll_clock_bcm4706(st
+@@ -264,7 +264,7 @@ static u32 bcma_pmu_pll_clock_bcm4706(st
  }
  
  /* query bus clock frequency for PMU-enabled chipcommon */
@@ -9,7 +52,7 @@
  {
  	struct bcma_bus *bus = cc->core->bus;
  
-@@ -292,6 +292,7 @@ static u32 bcma_pmu_get_bus_clock(struct
+@@ -293,6 +293,7 @@ static u32 bcma_pmu_get_bus_clock(struct
  	}
  	return BCMA_CC_PMU_HT_CLOCK;
  }
@@ -19,15 +62,18 @@
  u32 bcma_pmu_get_cpu_clock(struct bcma_drv_cc *cc)
 --- a/drivers/net/ethernet/broadcom/Kconfig
 +++ b/drivers/net/ethernet/broadcom/Kconfig
-@@ -120,4 +120,10 @@ config BNX2X
+@@ -120,4 +120,13 @@ config BNX2X
  	  To compile this driver as a module, choose M here: the module
  	  will be called bnx2x.  This is recommended.
  
 +config BGMAC
-+	tristate "Broadcom Gigabit driver"
-+	depends on BCMA
++	tristate "BCMA bus GBit core support"
++	depends on BCMA_HOST_SOC && HAS_DMA
 +	---help---
-+	  This driver supports Broadcom Gigabit core found in some BCM47xx SoCs.
++	  This driver supports GBit MAC and BCM4706 GBit MAC cores on BCMA bus.
++	  They can be found on BCM47xx SoCs and provide gigabit ethernet.
++	  In case of using this driver on BCM4706 it's also requires to enable
++	  BCMA_DRIVER_GMAC_CMN to make it work.
 +
  endif # NET_VENDOR_BROADCOM
 --- a/drivers/net/ethernet/broadcom/Makefile
@@ -39,17 +85,16 @@
 +obj-$(CONFIG_BGMAC) += bgmac.o
 --- /dev/null
 +++ b/drivers/net/ethernet/broadcom/bgmac.c
-@@ -0,0 +1,1202 @@
-+#define pr_fmt(fmt)		KBUILD_MODNAME ": " fmt
+@@ -0,0 +1,1422 @@
++/*
++ * Driver for (BCM4706)? GBit MAC core on BCMA bus.
++ *
++ * Copyright (C) 2012 Rafał Miłecki <zajec5@gmail.com>
++ *
++ * Licensed under the GNU/GPL. See COPYING for details.
++ */
 +
-+#define bgmac_err(bgmac, fmt, ...) \
-+	pr_err("u%d: " fmt, (bgmac)->core->core_unit, ##__VA_ARGS__)
-+#define bgmac_warn(bgmac, fmt, ...) \
-+	pr_warn("u%d: " fmt, (bgmac)->core->core_unit, ##__VA_ARGS__)
-+#define bgmac_info(bgmac, fmt, ...) \
-+	pr_info("u%d: " fmt, (bgmac)->core->core_unit, ##__VA_ARGS__)
-+#define bgmac_debug(bgmac, fmt, ...) \
-+	pr_debug("u%d: " fmt, (bgmac)->core->core_unit, ##__VA_ARGS__)
++#include "bgmac.h"
 +
 +#include <linux/kernel.h>
 +#include <linux/module.h>
@@ -60,12 +105,6 @@
 +#include <linux/dma-mapping.h>
 +#include <bcm47xx_nvram.h>
 +
-+#include "bgmac.h"
-+
-+#define ETHER_MAX_LEN   1518
-+
-+MODULE_LICENSE("GPL");
-+
 +static const struct bcma_device_id bgmac_bcma_tbl[] = {
 +	BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_4706_MAC_GBIT, BCMA_ANY_REV, BCMA_ANY_CLASS),
 +	BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_MAC_GBIT, BCMA_ANY_REV, BCMA_ANY_CLASS),
@@ -101,7 +140,7 @@
 +	if (!ring->mmio_base)
 +		return;
 +
-+	/* Susend DMA TX ring first.
++	/* Suspend DMA TX ring first.
 +	 * bgmac_wait_value doesn't support waiting for any of few values, so
 +	 * implement whole loop here.
 +	 */
@@ -109,6 +148,7 @@
 +		    BGMAC_DMA_TX_SUSPEND);
 +	for (i = 0; i < 10000 / 10; i++) {
 +		val = bgmac_read(bgmac, ring->mmio_base + BGMAC_DMA_TX_STATUS);
++		val &= BGMAC_DMA_TX_STAT;
 +		if (val == BGMAC_DMA_TX_STAT_DISABLED ||
 +		    val == BGMAC_DMA_TX_STAT_IDLEWAIT ||
 +		    val == BGMAC_DMA_TX_STAT_STOPPED) {
@@ -118,7 +158,8 @@
 +		udelay(10);
 +	}
 +	if (i)
-+		bgmac_err(bgmac, "Timeout suspending DMA TX ring 0x%X\n", ring->mmio_base);
++		bgmac_err(bgmac, "Timeout suspending DMA TX ring 0x%X (BGMAC_DMA_TX_STAT: 0x%08X)\n",
++			  ring->mmio_base, val);
 +
 +	/* Remove SUSPEND bit */
 +	bgmac_write(bgmac, ring->mmio_base + BGMAC_DMA_TX_CTL, 0);
@@ -126,11 +167,13 @@
 +			      ring->mmio_base + BGMAC_DMA_TX_STATUS,
 +			      BGMAC_DMA_TX_STAT, BGMAC_DMA_TX_STAT_DISABLED,
 +			      10000)) {
-+		bgmac_warn(bgmac, "DMA TX ring 0x%X wasn't disabled on time, waiting additional 300us\n", ring->mmio_base);
++		bgmac_warn(bgmac, "DMA TX ring 0x%X wasn't disabled on time, waiting additional 300us\n",
++			   ring->mmio_base);
 +		udelay(300);
 +		val = bgmac_read(bgmac, ring->mmio_base + BGMAC_DMA_TX_STATUS);
 +		if ((val & BGMAC_DMA_TX_STAT) != BGMAC_DMA_TX_STAT_DISABLED)
-+			bgmac_err(bgmac, "Reset of DMA TX ring 0x%X failed\n", ring->mmio_base);
++			bgmac_err(bgmac, "Reset of DMA TX ring 0x%X failed\n",
++				  ring->mmio_base);
 +	}
 +}
 +
@@ -150,6 +193,7 @@
 +				    struct sk_buff *skb)
 +{
 +	struct device *dma_dev = bgmac->core->dma_dev;
++	struct net_device *net_dev = bgmac->net_dev;
 +	struct bgmac_dma_desc *dma_desc;
 +	struct bgmac_slot_info *slot;
 +	u32 ctl0, ctl1;
@@ -157,25 +201,27 @@
 +
 +	if (skb->len > BGMAC_DESC_CTL1_LEN) {
 +		bgmac_err(bgmac, "Too long skb (%d)\n", skb->len);
-+		return NETDEV_TX_BUSY;
++		goto err_stop_drop;
 +	}
 +
 +	if (ring->start <= ring->end)
 +		free_slots = ring->start - ring->end + BGMAC_TX_RING_SLOTS;
 +	else
 +		free_slots = ring->start - ring->end;
-+	if (free_slots <= 1) {
-+		bgmac_err(bgmac, "No free slots on ring 0x%X!\n", ring->mmio_base);
-+		netif_stop_queue(bgmac->net_dev);
++	if (free_slots == 1) {
++		bgmac_err(bgmac, "TX ring is full, queue should be stopped!\n");
++		netif_stop_queue(net_dev);
 +		return NETDEV_TX_BUSY;
 +	}
 +
 +	slot = &ring->slots[ring->end];
 +	slot->skb = skb;
-+	slot->dma_addr = dma_map_single(dma_dev, skb->data, skb->len, DMA_TO_DEVICE);
++	slot->dma_addr = dma_map_single(dma_dev, skb->data, skb->len,
++					DMA_TO_DEVICE);
 +	if (dma_mapping_error(dma_dev, slot->dma_addr)) {
-+		bgmac_err(bgmac, "Mapping error of skb on ring 0x%X\n", ring->mmio_base);
-+		return NETDEV_TX_BUSY;
++		bgmac_err(bgmac, "Mapping error of skb on ring 0x%X\n",
++			  ring->mmio_base);
++		goto err_stop_drop;
 +	}
 +
 +	ctl0 = BGMAC_DESC_CTL0_IOC | BGMAC_DESC_CTL0_SOF | BGMAC_DESC_CTL0_EOF;
@@ -193,13 +239,22 @@
 +	wmb();
 +
 +	/* Increase ring->end to point empty slot. We tell hardware the first
-+	 * slot it shold *not* read.
++	 * slot it should *not* read.
 +	 */
 +	if (++ring->end >= BGMAC_TX_RING_SLOTS)
 +		ring->end = 0;
 +	bgmac_write(bgmac, ring->mmio_base + BGMAC_DMA_TX_INDEX,
 +		    ring->end * sizeof(struct bgmac_dma_desc));
 +
++	/* Always keep one slot free to allow detecting bugged calls. */
++	if (--free_slots == 1)
++		netif_stop_queue(net_dev);
++
++	return NETDEV_TX_OK;
++
++err_stop_drop:
++	netif_stop_queue(net_dev);
++	dev_kfree_skb(skb);
 +	return NETDEV_TX_OK;
 +}
 +
@@ -207,9 +262,8 @@
 +static void bgmac_dma_tx_free(struct bgmac *bgmac, struct bgmac_dma_ring *ring)
 +{
 +	struct device *dma_dev = bgmac->core->dma_dev;
-+	struct bgmac_dma_desc *dma_desc;
-+	struct bgmac_slot_info *slot;
 +	int empty_slot;
++	bool freed = false;
 +
 +	/* The last slot that hardware didn't consume yet */
 +	empty_slot = bgmac_read(bgmac, ring->mmio_base + BGMAC_DMA_TX_STATUS);
@@ -217,10 +271,7 @@
 +	empty_slot /= sizeof(struct bgmac_dma_desc);
 +
 +	while (ring->start != empty_slot) {
-+		/* Set pointers */
-+		dma_desc = ring->cpu_base;
-+		dma_desc += ring->start;
-+		slot = &ring->slots[ring->start];
++		struct bgmac_slot_info *slot = &ring->slots[ring->start];
 +
 +		if (slot->skb) {
 +			/* Unmap no longer used buffer */
@@ -228,16 +279,21 @@
 +					 slot->skb->len, DMA_TO_DEVICE);
 +			slot->dma_addr = 0;
 +
-+			/* Free memory!  */
-+			dev_kfree_skb_any(slot->skb);
++			/* Free memory! :) */
++			dev_kfree_skb(slot->skb);
 +			slot->skb = NULL;
 +		} else {
-+			bgmac_err(bgmac, "Hardware reported transmission for empty TX ring slot %d! End of ring: %d", ring->start, ring->end);
++			bgmac_err(bgmac, "Hardware reported transmission for empty TX ring slot %d! End of ring: %d\n",
++				  ring->start, ring->end);
 +		}
 +
 +		if (++ring->start >= BGMAC_TX_RING_SLOTS)
 +			ring->start = 0;
++		freed = true;
 +	}
++
++	if (freed && netif_queue_stopped(bgmac->net_dev))
++		netif_wake_queue(bgmac->net_dev);
 +}
 +
 +static void bgmac_dma_rx_reset(struct bgmac *bgmac, struct bgmac_dma_ring *ring)
@@ -250,7 +306,8 @@
 +			      ring->mmio_base + BGMAC_DMA_RX_STATUS,
 +			      BGMAC_DMA_RX_STAT, BGMAC_DMA_RX_STAT_DISABLED,
 +			      10000))
-+		bgmac_err(bgmac, "Reset of ring 0x%X RX failed\n", ring->mmio_base);
++		bgmac_err(bgmac, "Reset of ring 0x%X RX failed\n",
++			  ring->mmio_base);
 +}
 +
 +static void bgmac_dma_rx_enable(struct bgmac *bgmac,
@@ -267,16 +324,18 @@
 +	bgmac_write(bgmac, ring->mmio_base + BGMAC_DMA_RX_CTL, ctl);
 +}
 +
-+static void bgmac_dma_rx_skb_for_slot(struct bgmac *bgmac,
-+				      struct bgmac_slot_info *slot)
++static int bgmac_dma_rx_skb_for_slot(struct bgmac *bgmac,
++				     struct bgmac_slot_info *slot)
 +{
 +	struct device *dma_dev = bgmac->core->dma_dev;
 +	struct bgmac_rx_header *rx;
 +
 +	/* Alloc skb */
 +	slot->skb = netdev_alloc_skb(bgmac->net_dev, BGMAC_RX_BUF_SIZE);
-+	if (!slot->skb)
++	if (!slot->skb) {
 +		bgmac_err(bgmac, "Allocation of skb failed!\n");
++		return -ENOMEM;
++	}
 +
 +	/* Poison - if everything goes fine, hardware will overwrite it */
 +	rx = (struct bgmac_rx_header *)slot->skb->data;
@@ -286,21 +345,21 @@
 +	/* Map skb for the DMA */
 +	slot->dma_addr = dma_map_single(dma_dev, slot->skb->data,
 +					BGMAC_RX_BUF_SIZE, DMA_FROM_DEVICE);
-+	if (dma_mapping_error(dma_dev, slot->dma_addr))
++	if (dma_mapping_error(dma_dev, slot->dma_addr)) {
 +		bgmac_err(bgmac, "DMA mapping error\n");
++		return -ENOMEM;
++	}
 +	if (slot->dma_addr & 0xC0000000)
 +		bgmac_warn(bgmac, "DMA address using 0xC0000000 bit(s), it may need translation trick\n");
++
++	return 0;
 +}
 +
-+static void bgmac_dma_rx_read(struct bgmac *bgmac, struct bgmac_dma_ring *ring)
++static int bgmac_dma_rx_read(struct bgmac *bgmac, struct bgmac_dma_ring *ring,
++			     int weight)
 +{
-+	struct device *dma_dev = bgmac->core->dma_dev;
-+	struct bgmac_dma_desc *dma_desc;
-+	struct bgmac_slot_info *slot;
-+	struct sk_buff *skb;
-+	struct bgmac_rx_header *rx;
 +	u32 end_slot;
-+	u16 len, flags;
++	int handled = 0;
 +
 +	end_slot = bgmac_read(bgmac, ring->mmio_base + BGMAC_DMA_RX_STATUS);
 +	end_slot &= BGMAC_DMA_RX_STATDPTR;
@@ -309,68 +368,127 @@
 +	ring->end = end_slot;
 +
 +	while (ring->start != ring->end) {
-+		/* Set pointers */
-+		dma_desc = ring->cpu_base;
-+		dma_desc += ring->start;
-+		slot = &ring->slots[ring->start];
-+		skb = slot->skb;
++		struct device *dma_dev = bgmac->core->dma_dev;
++		struct bgmac_slot_info *slot = &ring->slots[ring->start];
++		struct sk_buff *skb = slot->skb;
++		struct sk_buff *new_skb;
++		struct bgmac_rx_header *rx;
++		u16 len, flags;
 +
 +		/* Unmap buffer to make it accessible to the CPU */
-+		dma_unmap_single(dma_dev, slot->dma_addr, BGMAC_RX_BUF_SIZE,
-+				 DMA_FROM_DEVICE);
++		dma_sync_single_for_cpu(dma_dev, slot->dma_addr,
++					BGMAC_RX_BUF_SIZE, DMA_FROM_DEVICE);
 +
 +		/* Get info from the header */
 +		rx = (struct bgmac_rx_header *)skb->data;
 +		len = le16_to_cpu(rx->len);
 +		flags = le16_to_cpu(rx->flags);
 +
-+		/* Check for poison and drop or pass packet */
++		/* Check for poison and drop or pass the packet */
 +		if (len == 0xdead && flags == 0xbeef) {
-+			bgmac_err(bgmac, "Found poisoned packet at slot %d, DMA issue!\n", ring->start);
-+			dev_kfree_skb_any(skb);
++			bgmac_err(bgmac, "Found poisoned packet at slot %d, DMA issue!\n",
++				  ring->start);
 +		} else {
-+			/* Remove header from the skb and pass it to the net */
-+			skb_put(skb, BGMAC_RX_FRAME_OFFSET + len);
-+			skb_pull(skb, BGMAC_RX_FRAME_OFFSET);
-+			skb->protocol = eth_type_trans(skb, bgmac->net_dev);
-+			netif_receive_skb(skb);
++			new_skb = netdev_alloc_skb(bgmac->net_dev, len);
++			if (new_skb) {
++				skb_put(new_skb, len);
++				skb_copy_from_linear_data_offset(skb, BGMAC_RX_FRAME_OFFSET,
++								 new_skb->data,
++								 len);
++				new_skb->protocol =
++					eth_type_trans(new_skb, bgmac->net_dev);
++				netif_receive_skb(new_skb);
++				handled++;
++			} else {
++				bgmac->net_dev->stats.rx_dropped++;
++				bgmac_err(bgmac, "Allocation of skb for copying packet failed!\n");
++			}
++
++			/* Poison the old skb */
++			rx->len = cpu_to_le16(0xdead);
++			rx->flags = cpu_to_le16(0xbeef);
 +		}
 +
-+		/* Alloc new skb */
-+		bgmac_dma_rx_skb_for_slot(bgmac, slot);
-+		dma_desc->addr_low = cpu_to_le32(lower_32_bits(slot->dma_addr));
-+		dma_desc->addr_high = cpu_to_le32(upper_32_bits(slot->dma_addr));
++		/* Make it back accessible to the hardware */
++		dma_sync_single_for_device(dma_dev, slot->dma_addr,
++					   BGMAC_RX_BUF_SIZE, DMA_FROM_DEVICE);
 +
 +		if (++ring->start >= BGMAC_RX_RING_SLOTS)
 +			ring->start = 0;
++
++		if (handled >= weight) /* Should never be greater */
++			break;
 +	}
++
++	return handled;
 +}
 +
 +/* Does ring support unaligned addressing? */
 +static bool bgmac_dma_unaligned(struct bgmac *bgmac,
-+				struct bgmac_dma_ring *ring)
++				struct bgmac_dma_ring *ring,
++				enum bgmac_dma_ring_type ring_type)
 +{
-+	if (ring->tx) {
++	switch (ring_type) {
++	case BGMAC_DMA_RING_TX:
 +		bgmac_write(bgmac, ring->mmio_base + BGMAC_DMA_TX_RINGLO,
 +			    0xff0);
 +		if (bgmac_read(bgmac, ring->mmio_base + BGMAC_DMA_TX_RINGLO))
 +			return true;
-+	} else {
++		break;
++	case BGMAC_DMA_RING_RX:
 +		bgmac_write(bgmac, ring->mmio_base + BGMAC_DMA_RX_RINGLO,
 +			    0xff0);
 +		if (bgmac_read(bgmac, ring->mmio_base + BGMAC_DMA_RX_RINGLO))
 +			return true;
++		break;
 +	}
 +	return false;
 +}
 +
++static void bgmac_dma_ring_free(struct bgmac *bgmac,
++				struct bgmac_dma_ring *ring)
++{
++	struct device *dma_dev = bgmac->core->dma_dev;
++	struct bgmac_slot_info *slot;
++	int size;
++	int i;
++
++	for (i = 0; i < ring->num_slots; i++) {
++		slot = &ring->slots[i];
++		if (slot->skb) {
++			if (slot->dma_addr)
++				dma_unmap_single(dma_dev, slot->dma_addr,
++						 slot->skb->len, DMA_TO_DEVICE);
++			dev_kfree_skb(slot->skb);
++		}
++	}
++
++	if (ring->cpu_base) {
++		/* Free ring of descriptors */
++		size = ring->num_slots * sizeof(struct bgmac_dma_desc);
++		dma_free_coherent(dma_dev, size, ring->cpu_base,
++				  ring->dma_base);
++	}
++}
++
++static void bgmac_dma_free(struct bgmac *bgmac)
++{
++	int i;
++
++	for (i = 0; i < BGMAC_MAX_TX_RINGS; i++)
++		bgmac_dma_ring_free(bgmac, &bgmac->tx_ring[i]);
++	for (i = 0; i < BGMAC_MAX_RX_RINGS; i++)
++		bgmac_dma_ring_free(bgmac, &bgmac->rx_ring[i]);
++}
++
 +static int bgmac_dma_alloc(struct bgmac *bgmac)
 +{
 +	struct device *dma_dev = bgmac->core->dma_dev;
 +	struct bgmac_dma_ring *ring;
-+	u16 ring_base[] = { BGMAC_DMA_BASE0, BGMAC_DMA_BASE1, BGMAC_DMA_BASE2,
-+			    BGMAC_DMA_BASE3, };
++	static const u16 ring_base[] = { BGMAC_DMA_BASE0, BGMAC_DMA_BASE1,
++					 BGMAC_DMA_BASE2, BGMAC_DMA_BASE3, };
 +	int size; /* ring size: different for Tx and Rx */
++	int err;
 +	int i;
 +
 +	BUILD_BUG_ON(BGMAC_MAX_TX_RINGS > ARRAY_SIZE(ring_base));
@@ -383,19 +501,22 @@
 +
 +	for (i = 0; i < BGMAC_MAX_TX_RINGS; i++) {
 +		ring = &bgmac->tx_ring[i];
-+		ring->tx = true;
 +		ring->num_slots = BGMAC_TX_RING_SLOTS;
 +		ring->mmio_base = ring_base[i];
-+		if (bgmac_dma_unaligned(bgmac, ring))
-+			bgmac_warn(bgmac, "TX on ring 0x%X supports unaligned addressing but this feature is not implemented\n", ring->mmio_base);
++		if (bgmac_dma_unaligned(bgmac, ring, BGMAC_DMA_RING_TX))
++			bgmac_warn(bgmac, "TX on ring 0x%X supports unaligned addressing but this feature is not implemented\n",
++				   ring->mmio_base);
 +
 +		/* Alloc ring of descriptors */
 +		size = ring->num_slots * sizeof(struct bgmac_dma_desc);
 +		ring->cpu_base = dma_zalloc_coherent(dma_dev, size,
-+						     &(ring->dma_base),
++						     &ring->dma_base,
 +						     GFP_KERNEL);
-+		if (!ring->cpu_base)
-+			bgmac_err(bgmac, "Allocation of TX ring failed\n");
++		if (!ring->cpu_base) {
++			bgmac_err(bgmac, "Allocation of TX ring 0x%X failed\n",
++				  ring->mmio_base);
++			goto err_dma_free;
++		}
 +		if (ring->dma_base & 0xC0000000)
 +			bgmac_warn(bgmac, "DMA address using 0xC0000000 bit(s), it may need translation trick\n");
 +
@@ -404,28 +525,41 @@
 +
 +	for (i = 0; i < BGMAC_MAX_RX_RINGS; i++) {
 +		ring = &bgmac->rx_ring[i];
-+		ring->tx = false;
 +		ring->num_slots = BGMAC_RX_RING_SLOTS;
 +		ring->mmio_base = ring_base[i];
-+		if (bgmac_dma_unaligned(bgmac, ring))
-+			bgmac_warn(bgmac, "RX on ring 0x%X supports unaligned addressing but this feature is not implemented\n", ring->mmio_base);
++		if (bgmac_dma_unaligned(bgmac, ring, BGMAC_DMA_RING_RX))
++			bgmac_warn(bgmac, "RX on ring 0x%X supports unaligned addressing but this feature is not implemented\n",
++				   ring->mmio_base);
 +
 +		/* Alloc ring of descriptors */
 +		size = ring->num_slots * sizeof(struct bgmac_dma_desc);
 +		ring->cpu_base = dma_zalloc_coherent(dma_dev, size,
-+						     &(ring->dma_base),
++						     &ring->dma_base,
 +						     GFP_KERNEL);
-+		if (!ring->cpu_base)
-+			bgmac_err(bgmac, "Allocation of RX ring failed\n");
++		if (!ring->cpu_base) {
++			bgmac_err(bgmac, "Allocation of RX ring 0x%X failed\n",
++				  ring->mmio_base);
++			err = -ENOMEM;
++			goto err_dma_free;
++		}
 +		if (ring->dma_base & 0xC0000000)
 +			bgmac_warn(bgmac, "DMA address using 0xC0000000 bit(s), it may need translation trick\n");
 +
 +		/* Alloc RX slots */
-+		for (i = 0; i < ring->num_slots; i++)
-+			bgmac_dma_rx_skb_for_slot(bgmac, &ring->slots[i]);
++		for (i = 0; i < ring->num_slots; i++) {
++			err = bgmac_dma_rx_skb_for_slot(bgmac, &ring->slots[i]);
++			if (err) {
++				bgmac_err(bgmac, "Can't allocate skb for slot in RX ring\n");
++				goto err_dma_free;
++			}
++		}
 +	}
 +
 +	return 0;
++
++err_dma_free:
++	bgmac_dma_free(bgmac);
++	return -ENOMEM;
 +}
 +
 +static void bgmac_dma_init(struct bgmac *bgmac)
@@ -715,6 +849,7 @@
 +	udelay(2);
 +}
 +
++#if 0 /* We don't use that regs yet */
 +static void bgmac_chip_stats_update(struct bgmac *bgmac)
 +{
 +	int i;
@@ -730,8 +865,9 @@
 +					   BGMAC_RX_GOOD_OCTETS + (i * 4));
 +	}
 +
-+	/* TODO: what else? how to handle BCM4706? */
++	/* TODO: what else? how to handle BCM4706? Specs are needed */
 +}
++#endif
 +
 +static void bgmac_clear_mib(struct bgmac *bgmac)
 +{
@@ -788,7 +924,7 @@
 +
 +	if (bcma_core_is_enabled(core)) {
 +		if (!bgmac->stats_grabbed) {
-+			bgmac_chip_stats_update(bgmac);
++			/* bgmac_chip_stats_update(bgmac); */
 +			bgmac->stats_grabbed = true;
 +		}
 +
@@ -831,9 +967,11 @@
 +		u8 sw_type = BGMAC_CHIPCTL_1_SW_TYPE_EPHY |
 +			     BGMAC_CHIPCTL_1_IF_TYPE_RMII;
 +		char buf[2];
++
 +		if (bcm47xx_nvram_getenv("et_swtype", buf, 1) > 0) {
 +			if (kstrtou8(buf, 0, &et_swtype))
-+				bgmac_err(bgmac, "Failed to parse et_swtype (%s)\n", buf);
++				bgmac_err(bgmac, "Failed to parse et_swtype (%s)\n",
++					  buf);
 +			et_swtype &= 0x0f;
 +			et_swtype <<= 4;
 +			sw_type = et_swtype;
@@ -953,29 +1091,27 @@
 +/* http://bcm-v4.sipsolutions.net/mac-gbit/gmac/chipinit */
 +static void bgmac_chip_init(struct bgmac *bgmac, bool full_init)
 +{
-+	struct ssb_sprom *sprom = &bgmac->core->bus->sprom;
 +	struct bgmac_dma_ring *ring;
++	u8 *mac = bgmac->net_dev->dev_addr;
 +	u32 tmp;
-+	u8 *mac;
 +	int i;
 +
 +	/* 1 interrupt per received frame */
 +	bgmac_write(bgmac, BGMAC_INT_RECV_LAZY, 1 << BGMAC_IRL_FC_SHIFT);
 +
-+	/* enable 802.3x tx flow control (honor received PAUSE frames) */
++	/* Enable 802.3x tx flow control (honor received PAUSE frames) */
 +	bgmac_cmdcfg_maskset(bgmac, ~BGMAC_CMDCFG_RPI, 0, true);
 +
 +	if (bgmac->net_dev->flags & IFF_PROMISC)
 +		bgmac_cmdcfg_maskset(bgmac, ~0, BGMAC_CMDCFG_PROM, false);
 +	else
-+		bgmac_warn(bgmac, "Software filtering is not supported yet\n");
++		bgmac_cmdcfg_maskset(bgmac, ~BGMAC_CMDCFG_PROM, 0, false);
 +
-+	mac = bgmac->core->core_unit ? sprom->et1mac : sprom->et0mac;
++	/* Set MAC addr */
 +	tmp = (mac[0] << 24) | (mac[1] << 16) | (mac[2] << 8) | mac[3];
 +	bgmac_write(bgmac, BGMAC_MACADDR_HIGH, tmp);
 +	tmp = (mac[4] << 8) | mac[5];
 +	bgmac_write(bgmac, BGMAC_MACADDR_LOW, tmp);
-+	memcpy(bgmac->net_dev->dev_addr, mac, 6);
 +
 +	if (bgmac->loopback)
 +		bgmac_cmdcfg_maskset(bgmac, ~0, BGMAC_CMDCFG_ML, true);
@@ -1023,13 +1159,16 @@
 +
 +	bgmac->int_status = int_status;
 +
-+	return IRQ_WAKE_THREAD;
++	napi_schedule(&bgmac->napi);
++
++	return IRQ_HANDLED;
 +}
 +
-+static irqreturn_t bgmac_interrupt_thread(int irq, void *dev_id)
++static int bgmac_poll(struct napi_struct *napi, int weight)
 +{
-+	struct bgmac *bgmac = netdev_priv(dev_id);
++	struct bgmac *bgmac = container_of(napi, struct bgmac, napi);
 +	struct bgmac_dma_ring *ring;
++	int handled = 0;
 +
 +	if (bgmac->int_status & BGMAC_IS_TX0) {
 +		ring = &bgmac->tx_ring[0];
@@ -1039,7 +1178,7 @@
 +
 +	if (bgmac->int_status & BGMAC_IS_RX) {
 +		ring = &bgmac->rx_ring[0];
-+		bgmac_dma_rx_read(bgmac, ring);
++		handled += bgmac_dma_rx_read(bgmac, ring, weight);
 +		bgmac->int_status &= ~BGMAC_IS_RX;
 +	}
 +
@@ -1048,43 +1187,67 @@
 +		bgmac->int_status = 0;
 +	}
 +
++	if (handled < weight)
++		napi_complete(napi);
++
 +	bgmac_chip_intrs_on(bgmac);
-+	return IRQ_HANDLED;
++
++	return handled;
 +}
 +
 +/**************************************************
-+ * net_device ops
++ * net_device_ops
 + **************************************************/
 +
 +static int bgmac_open(struct net_device *net_dev)
 +{
 +	struct bgmac *bgmac = netdev_priv(net_dev);
++	int err = 0;
 +
 +	bgmac_chip_reset(bgmac);
 +	/* Specs say about reclaiming rings here, but we do that in DMA init */
 +	bgmac_chip_init(bgmac, true);
 +
-+	if (request_threaded_irq(bgmac->core->irq, bgmac_interrupt,
-+				 bgmac_interrupt_thread, IRQF_SHARED,
-+				 KBUILD_MODNAME, net_dev) < 0)
-+		bgmac_err(bgmac, "IRQ request error!\n");
++	err = request_irq(bgmac->core->irq, bgmac_interrupt, IRQF_SHARED,
++			  KBUILD_MODNAME, net_dev);
++	if (err < 0) {
++		bgmac_err(bgmac, "IRQ request error: %d!\n", err);
++		goto err_out;
++	}
++	napi_enable(&bgmac->napi);
++
++	netif_carrier_on(net_dev);
 +
-+	return 0;
++err_out:
++	return err;
 +}
 +
 +static int bgmac_stop(struct net_device *net_dev)
 +{
 +	struct bgmac *bgmac = netdev_priv(net_dev);
 +
-+	bgmac_chip_intrs_off(bgmac);
++	netif_carrier_off(net_dev);
 +
++	napi_disable(&bgmac->napi);
++	bgmac_chip_intrs_off(bgmac);
 +	free_irq(bgmac->core->irq, net_dev);
 +
-+	/* TODO */
++	bgmac_chip_reset(bgmac);
 +
 +	return 0;
 +}
 +
++static netdev_tx_t bgmac_start_xmit(struct sk_buff *skb,
++				    struct net_device *net_dev)
++{
++	struct bgmac *bgmac = netdev_priv(net_dev);
++	struct bgmac_dma_ring *ring;
++
++	/* No QOS support yet */
++	ring = &bgmac->tx_ring[0];
++	return bgmac_dma_tx_add(bgmac, ring, skb);
++}
++
 +static int bgmac_ioctl(struct net_device *net_dev, struct ifreq *ifr, int cmd)
 +{
 +	struct bgmac *bgmac = netdev_priv(net_dev);
@@ -1111,22 +1274,89 @@
 +	}
 +}
 +
-+static netdev_tx_t bgmac_start_xmit(struct sk_buff *skb,
-+				    struct net_device *net_dev)
++static const struct net_device_ops bgmac_netdev_ops = {
++	.ndo_open		= bgmac_open,
++	.ndo_stop		= bgmac_stop,
++	.ndo_start_xmit		= bgmac_start_xmit,
++	.ndo_set_mac_address	= eth_mac_addr, /* generic, sets dev_addr */
++	.ndo_do_ioctl           = bgmac_ioctl,
++};
++
++/**************************************************
++ * ethtool_ops
++ **************************************************/
++
++static int bgmac_get_settings(struct net_device *net_dev,
++			      struct ethtool_cmd *cmd)
 +{
 +	struct bgmac *bgmac = netdev_priv(net_dev);
-+	struct bgmac_dma_ring *ring;
 +
-+	/* No QOS support yet */
-+	ring = &bgmac->tx_ring[0];
-+	return bgmac_dma_tx_add(bgmac, ring, skb);
++	cmd->supported = SUPPORTED_10baseT_Half |
++			 SUPPORTED_10baseT_Full |
++			 SUPPORTED_100baseT_Half |
++			 SUPPORTED_100baseT_Full |
++			 SUPPORTED_1000baseT_Half |
++			 SUPPORTED_1000baseT_Full |
++			 SUPPORTED_Autoneg;
++
++	if (bgmac->autoneg) {
++		WARN_ON(cmd->advertising);
++		if (bgmac->full_duplex) {
++			if (bgmac->speed & BGMAC_SPEED_10)
++				cmd->advertising |= ADVERTISED_10baseT_Full;
++			if (bgmac->speed & BGMAC_SPEED_100)
++				cmd->advertising |= ADVERTISED_100baseT_Full;
++			if (bgmac->speed & BGMAC_SPEED_1000)
++				cmd->advertising |= ADVERTISED_1000baseT_Full;
++		} else {
++			if (bgmac->speed & BGMAC_SPEED_10)
++				cmd->advertising |= ADVERTISED_10baseT_Half;
++			if (bgmac->speed & BGMAC_SPEED_100)
++				cmd->advertising |= ADVERTISED_100baseT_Half;
++			if (bgmac->speed & BGMAC_SPEED_1000)
++				cmd->advertising |= ADVERTISED_1000baseT_Half;
++		}
++	} else {
++		switch (bgmac->speed) {
++		case BGMAC_SPEED_10:
++			ethtool_cmd_speed_set(cmd, SPEED_10);
++			break;
++		case BGMAC_SPEED_100:
++			ethtool_cmd_speed_set(cmd, SPEED_100);
++			break;
++		case BGMAC_SPEED_1000:
++			ethtool_cmd_speed_set(cmd, SPEED_1000);
++			break;
++		}
++	}
++
++	cmd->duplex = bgmac->full_duplex ? DUPLEX_FULL : DUPLEX_HALF;
++
++	cmd->autoneg = bgmac->autoneg;
++
++	return 0;
 +}
 +
-+static const struct net_device_ops bgmac_netdev_ops = {
-+	.ndo_open		= bgmac_open,
-+	.ndo_stop		= bgmac_stop,
-+	.ndo_do_ioctl           = bgmac_ioctl,
-+	.ndo_start_xmit		= bgmac_start_xmit,
++#if 0
++static int bgmac_set_settings(struct net_device *net_dev,
++			      struct ethtool_cmd *cmd)
++{
++	struct bgmac *bgmac = netdev_priv(net_dev);
++
++	return -1;
++}
++#endif
++
++static void bgmac_get_drvinfo(struct net_device *net_dev,
++			      struct ethtool_drvinfo *info)
++{
++	strlcpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
++	strlcpy(info->bus_info, "BCMA", sizeof(info->bus_info));
++}
++
++static const struct ethtool_ops bgmac_ethtool_ops = {
++	.get_settings		= bgmac_get_settings,
++	.get_drvinfo		= bgmac_get_drvinfo,
 +};
 +
 +/**************************************************
@@ -1139,14 +1369,22 @@
 +	struct net_device *net_dev;
 +	struct bgmac *bgmac;
 +	struct ssb_sprom *sprom = &core->bus->sprom;
++	u8 *mac = core->core_unit ? sprom->et1mac : sprom->et0mac;
 +	int err;
 +
++	/* We don't support 2nd, 3rd, ... units, SPROM has to be adjusted */
++	if (core->core_unit > 1) {
++		pr_err("Unsupported core_unit %d\n", core->core_unit);
++		return -ENOTSUPP;
++	}
++
 +	/* Allocation and references */
 +	net_dev = alloc_etherdev(sizeof(*bgmac));
 +	if (!net_dev)
 +		return -ENOMEM;
 +	net_dev->netdev_ops = &bgmac_netdev_ops;
 +	net_dev->irq = core->irq;
++	SET_ETHTOOL_OPS(net_dev, &bgmac_ethtool_ops);
 +	bgmac = netdev_priv(net_dev);
 +	bgmac->net_dev = net_dev;
 +	bgmac->core = core;
@@ -1156,12 +1394,14 @@
 +	bgmac->autoneg = true;
 +	bgmac->full_duplex = true;
 +	bgmac->speed = BGMAC_SPEED_10 | BGMAC_SPEED_100 | BGMAC_SPEED_1000;
++	memcpy(bgmac->net_dev->dev_addr, mac, ETH_ALEN);
 +
 +	/* On BCM4706 we need common core to access PHY */
 +	if (core->id.id == BCMA_CORE_4706_MAC_GBIT &&
 +	    !core->bus->drv_gmac_cmn.core) {
 +		bgmac_err(bgmac, "GMAC CMN core not found (required for BCM4706)\n");
-+		return -ENODEV;
++		err = -ENODEV;
++		goto err_netdev_free;
 +	}
 +	bgmac->cmn = core->bus->drv_gmac_cmn.core;
 +
@@ -1170,50 +1410,73 @@
 +	bgmac->phyaddr &= BGMAC_PHY_MASK;
 +	if (bgmac->phyaddr == BGMAC_PHY_MASK) {
 +		bgmac_err(bgmac, "No PHY found\n");
-+		return -ENODEV;
++		err = -ENODEV;
++		goto err_netdev_free;
 +	}
-+	bgmac_info(bgmac, "Found PHY addr: %d\n", bgmac->phyaddr);
++	bgmac_info(bgmac, "Found PHY addr: %d%s\n", bgmac->phyaddr,
++		   bgmac->phyaddr == BGMAC_PHY_NOREGS ? " (NOREGS)" : "");
 +
 +	if (core->bus->hosttype == BCMA_HOSTTYPE_PCI) {
 +		bgmac_err(bgmac, "PCI setup not implemented\n");
-+		return -ENOTSUPP;
++		err = -ENOTSUPP;
++		goto err_netdev_free;
 +	}
 +
 +	bgmac_chip_reset(bgmac);
 +
-+	bgmac_dma_alloc(bgmac);
++	err = bgmac_dma_alloc(bgmac);
++	if (err) {
++		bgmac_err(bgmac, "Unable to alloc memory for DMA\n");
++		goto err_netdev_free;
++	}
 +
 +	bgmac->int_mask = BGMAC_IS_ERRMASK | BGMAC_IS_RX | BGMAC_IS_TX_MASK;
-+	if (bcm47xx_nvram_getenv("et0_no_txint", NULL, 0) > 0)
++	if (bcm47xx_nvram_getenv("et0_no_txint", NULL, 0) == 0)
 +		bgmac->int_mask &= ~BGMAC_IS_TX_MASK;
 +
-+	/* TODO: reset the external phy */
++	/* TODO: reset the external phy. Specs are needed */
 +	bgmac_phy_reset(bgmac);
 +
 +	bgmac->has_robosw = !!(core->bus->sprom.boardflags_lo &
 +			       BGMAC_BFL_ENETROBO);
 +	if (bgmac->has_robosw)
-+		bgmac_err(bgmac, "Support for Roboswitch not implemented\n");
++		bgmac_warn(bgmac, "Support for Roboswitch not implemented\n");
 +
 +	if (core->bus->sprom.boardflags_lo & BGMAC_BFL_ENETADM)
-+		bgmac_err(bgmac, "Support for ADMtek ethernet switch not implemented\n");
++		bgmac_warn(bgmac, "Support for ADMtek ethernet switch not implemented\n");
 +
 +	err = register_netdev(bgmac->net_dev);
 +	if (err) {
 +		bgmac_err(bgmac, "Cannot register net device\n");
-+		return -ENOTSUPP;
++		err = -ENOTSUPP;
++		goto err_dma_free;
 +	}
 +
++	netif_carrier_off(net_dev);
++
++	netif_napi_add(net_dev, &bgmac->napi, bgmac_poll, BGMAC_WEIGHT);
++
 +	return 0;
++
++err_dma_free:
++	bgmac_dma_free(bgmac);
++
++err_netdev_free:
++	bcma_set_drvdata(core, NULL);
++	free_netdev(net_dev);
++
++	return err;
 +}
 +
 +static void bgmac_remove(struct bcma_device *core)
 +{
 +	struct bgmac *bgmac = bcma_get_drvdata(core);
 +
++	netif_napi_del(&bgmac->napi);
 +	unregister_netdev(bgmac->net_dev);
-+	free_netdev(bgmac->net_dev);
++	bgmac_dma_free(bgmac);
 +	bcma_set_drvdata(core, NULL);
++	free_netdev(bgmac->net_dev);
 +}
 +
 +static struct bcma_driver bgmac_bcma_driver = {
@@ -1230,7 +1493,7 @@
 +	err = bcma_driver_register(&bgmac_bcma_driver);
 +	if (err)
 +		return err;
-+	pr_info("Broadcom 47xx GMAC driver loaded\n");
++	pr_info("Broadcom 47xx GBit MAC driver loaded\n");
 +
 +	return 0;
 +}
@@ -1242,13 +1505,28 @@
 +
 +module_init(bgmac_init)
 +module_exit(bgmac_exit)
++
++MODULE_AUTHOR("Rafał Miłecki");
++MODULE_LICENSE("GPL");
 --- /dev/null
 +++ b/drivers/net/ethernet/broadcom/bgmac.h
-@@ -0,0 +1,424 @@
+@@ -0,0 +1,456 @@
 +#ifndef _BGMAC_H
 +#define _BGMAC_H
 +
++#define pr_fmt(fmt)		KBUILD_MODNAME ": " fmt
++
++#define bgmac_err(bgmac, fmt, ...) \
++	dev_err(&(bgmac)->core->dev, fmt, ##__VA_ARGS__)
++#define bgmac_warn(bgmac, fmt, ...) \
++	dev_warn(&(bgmac)->core->dev, fmt,  ##__VA_ARGS__)
++#define bgmac_info(bgmac, fmt, ...) \
++	dev_info(&(bgmac)->core->dev, fmt,  ##__VA_ARGS__)
++#define bgmac_dbg(bgmac, fmt, ...) \
++	dev_dbg(&(bgmac)->core->dev, fmt, ##__VA_ARGS__)
++
 +#include <linux/bcma/bcma.h>
++#include <linux/netdevice.h>
 +
 +#define BGMAC_DEV_CTL				0x000
 +#define  BGMAC_DC_TSM				0x00000002
@@ -1287,8 +1565,8 @@
 +#define  BGMAC_IS_DATA_ERR			0x00000800	/* Data error */
 +#define  BGMAC_IS_DESC_PROT_ERR			0x00001000	/* Descriptor protocol error */
 +#define  BGMAC_IS_RX_DESC_UNDERF		0x00002000	/* Receive descriptor underflow */
-+#define  BGMAC_IS_RX_F_OVERF			0x00004000	/* Receive fifi overflow */
-+#define  BGMAC_IS_TX_F_UNDERF			0x00008000	/* Transmit fifo underflow */
++#define  BGMAC_IS_RX_F_OVERF			0x00004000	/* Receive FIFO overflow */
++#define  BGMAC_IS_TX_F_UNDERF			0x00008000	/* Transmit FIFO underflow */
 +#define  BGMAC_IS_RX				0x00010000	/* Interrupt for RX queue 0 */
 +#define  BGMAC_IS_TX0				0x01000000	/* Interrupt for TX queue 0 */
 +#define  BGMAC_IS_TX1				0x02000000	/* Interrupt for TX queue 1 */
@@ -1581,6 +1859,10 @@
 +#define BGMAC_SPEED_100				0x0002
 +#define BGMAC_SPEED_1000			0x0004
 +
++#define BGMAC_WEIGHT	64
++
++#define ETHER_MAX_LEN   1518
++
 +struct bgmac_slot_info {
 +	struct sk_buff *skb;
 +	dma_addr_t dma_addr;
@@ -1593,14 +1875,27 @@
 +	__le32 addr_high;
 +} __packed;
 +
++enum bgmac_dma_ring_type {
++	BGMAC_DMA_RING_TX,
++	BGMAC_DMA_RING_RX,
++};
++
++/**
++ * bgmac_dma_ring - contains info about DMA ring (either TX or RX one)
++ * @start: index of the first slot containing data
++ * @end: index of a slot that can *not* be read (yet)
++ *
++ * Be really aware of the specific @end meaning. It's an index of a slot *after*
++ * the one containing data that can be read. If @start equals @end the ring is
++ * empty.
++ */
 +struct bgmac_dma_ring {
-+	bool tx;
 +	u16 num_slots;
 +	u16 start;
 +	u16 end;
 +
 +	u16 mmio_base;
-+	void *cpu_base;
++	struct bgmac_dma_desc *cpu_base;
 +	dma_addr_t dma_base;
 +
 +	struct bgmac_slot_info slots[BGMAC_RX_RING_SLOTS];
@@ -1616,18 +1911,7 @@
 +	struct bcma_device *core;
 +	struct bcma_device *cmn; /* Reference to CMN core for BCM4706 */
 +	struct net_device *net_dev;
-+
-+	u8 phyaddr;
-+	bool has_robosw;
-+
-+	u32 int_mask;
-+	u32 int_status;
-+
-+	bool loopback;
-+
-+	bool autoneg;
-+	bool full_duplex;
-+	int speed;
++	struct napi_struct napi;
 +
 +	/* DMA */
 +	struct bgmac_dma_ring tx_ring[BGMAC_MAX_TX_RINGS];
@@ -1637,6 +1921,20 @@
 +	bool stats_grabbed;
 +	u32 mib_tx_regs[BGMAC_NUM_MIB_TX_REGS];
 +	u32 mib_rx_regs[BGMAC_NUM_MIB_RX_REGS];
++
++	/* Int */
++	u32 int_mask;
++	u32 int_status;
++
++	/* Speed-related */
++	int speed;
++	bool autoneg;
++	bool full_duplex;
++
++	u8 phyaddr;
++	bool has_robosw;
++
++	bool loopback;
 +};
 +
 +static inline u32 bgmac_read(struct bgmac *bgmac, u16 offset)
@@ -1671,7 +1969,7 @@
 +#endif /* _BGMAC_H */
 --- a/include/linux/bcma/bcma_driver_chipcommon.h
 +++ b/include/linux/bcma/bcma_driver_chipcommon.h
-@@ -627,4 +627,6 @@ int bcma_nflash_erase(struct bcma_drv_cc
+@@ -624,4 +624,6 @@ int bcma_nflash_erase(struct bcma_drv_cc
  int bcma_nflash_commit(struct bcma_drv_cc *cc, u32 offset, u32 len, const u8 *buf);
  #endif