35 files changed, 3439 insertions, 2235 deletions
diff --git a/drivers/net/sfc/Makefile b/drivers/net/sfc/Makefile
index 1047b19c60a5..ab31c7124db1 100644
--- a/drivers/net/sfc/Makefile
+++ b/drivers/net/sfc/Makefile
@@ -1,7 +1,8 @@
-sfc-y                   += efx.o nic.o falcon.o siena.o tx.o rx.o \
+sfc-y                   += efx.o nic.o falcon.o siena.o tx.o rx.o filter.o \
-                           falcon_gmac.o falcon_xmac.o mcdi_mac.o \
+                           falcon_xmac.o mcdi_mac.o \
                           selftest.o ethtool.o qt202x_phy.o mdio_10g.o \
-                           tenxpress.o falcon_boards.o mcdi.o mcdi_phy.o
+                           tenxpress.o txc43128_phy.o falcon_boards.o \
+                           mcdi.o mcdi_phy.o
 sfc-$(CONFIG_SFC_MTD)   += mtd.o
 obj-$(CONFIG_SFC)       += sfc.o
diff --git a/drivers/net/sfc/efx.c b/drivers/net/sfc/efx.c
index ba674c5ca29e..c914729f9554 100644
--- a/drivers/net/sfc/efx.c
+++ b/drivers/net/sfc/efx.c
@@ -1,7 +1,7 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
 * Copyright 2005-2006 Fen Systems Ltd.
- * Copyright 2005-2009 Solarflare Communications Inc.
+ * Copyright 2005-2011 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -21,9 +21,9 @@
 #include <linux/ethtool.h>
 #include <linux/topology.h>
 #include <linux/gfp.h>
+#include <linux/cpu_rmap.h>
 #include "net_driver.h"
 #include "efx.h"
-#include "mdio_10g.h"
 #include "nic.h"
 #include "mcdi.h"
@@ -68,14 +68,6 @@ const char *efx_loopback_mode_names[] = {
        [LOOPBACK_PHYXS_WS]     = "PHYXS_WS",
 };
-/* Interrupt mode names (see INT_MODE())) */
-const unsigned int efx_interrupt_mode_max = EFX_INT_MODE_MAX;
-const char *efx_interrupt_mode_names[] = {
-        [EFX_INT_MODE_MSIX]   = "MSI-X",
-        [EFX_INT_MODE_MSI]    = "MSI",
-        [EFX_INT_MODE_LEGACY] = "legacy",
-};
 const unsigned int efx_reset_type_max = RESET_TYPE_MAX;
 const char *efx_reset_type_names[] = {
        [RESET_TYPE_INVISIBLE]     = "INVISIBLE",
@@ -114,7 +106,7 @@ static struct workqueue_struct *reset_workqueue;
 * This is only used in MSI-X interrupt mode
 */
 static unsigned int separate_tx_channels;
-module_param(separate_tx_channels, uint, 0644);
+module_param(separate_tx_channels, uint, 0444);
 MODULE_PARM_DESC(separate_tx_channels,
                 "Use separate channels for TX and RX");
@@ -124,10 +116,11 @@ MODULE_PARM_DESC(separate_tx_channels,
 static int napi_weight = 64;
 /* This is the time (in jiffies) between invocations of the hardware
- * monitor, which checks for known hardware bugs and resets the
+ * monitor.  On Falcon-based NICs, this will:
- * hardware and driver as necessary.
+ * - Check the on-board hardware monitor;
+ * - Poll the link state and reconfigure the hardware as necessary.
 */
-unsigned int efx_monitor_interval = 1 * HZ;
+static unsigned int efx_monitor_interval = 1 * HZ;
 /* This controls whether or not the driver will initialise devices
 * with invalid MAC addresses stored in the EEPROM or flash.  If true,
@@ -201,10 +194,15 @@ MODULE_PARM_DESC(debug, "Bitmapped debugging message enable value");
 * Utility functions and prototypes
 *
 *************************************************************************/
-static void efx_remove_channel(struct efx_channel *channel);
+static void efx_remove_channels(struct efx_nic *efx);
 static void efx_remove_port(struct efx_nic *efx);
+static void efx_init_napi(struct efx_nic *efx);
 static void efx_fini_napi(struct efx_nic *efx);
-static void efx_fini_channels(struct efx_nic *efx);
+static void efx_fini_napi_channel(struct efx_channel *channel);
+static void efx_fini_struct(struct efx_nic *efx);
+static void efx_start_all(struct efx_nic *efx);
+static void efx_stop_all(struct efx_nic *efx);
 #define EFX_ASSERT_RESET_SERIALISED(efx)                \
        do {                                            \
@@ -248,7 +246,7 @@ static int efx_process_channel(struct efx_channel *channel, int budget)
        efx_rx_strategy(channel);
-        efx_fast_push_rx_descriptors(&efx->rx_queue[channel->channel]);
+        efx_fast_push_rx_descriptors(efx_channel_get_rx_queue(channel));
        return spent;
 }
@@ -310,6 +308,8 @@ static int efx_poll(struct napi_struct *napi, int budget)
                        channel->irq_mod_score = 0;
                }
+                efx_filter_rfs_expire(channel);
                /* There is no race here; although napi_disable() will
                 * only wait for napi_complete(), this isn't a problem
                 * since efx_channel_processed() will have no effect if
@@ -328,18 +328,23 @@ static int efx_poll(struct napi_struct *napi, int budget)
 * processing to finish, then directly poll (and ack ) the eventq.
 * Finally reenable NAPI and interrupts.
 *
- * Since we are touching interrupts the caller should hold the suspend lock
+ * This is for use only during a loopback self-test.  It must not
+ * deliver any packets up the stack as this can result in deadlock.
 */
 void efx_process_channel_now(struct efx_channel *channel)
 {
        struct efx_nic *efx = channel->efx;
+        BUG_ON(channel->channel >= efx->n_channels);
        BUG_ON(!channel->enabled);
+        BUG_ON(!efx->loopback_selftest);
        /* Disable interrupts and wait for ISRs to complete */
        efx_nic_disable_interrupts(efx);
-        if (efx->legacy_irq)
+        if (efx->legacy_irq) {
                synchronize_irq(efx->legacy_irq);
+                efx->legacy_irq_enabled = false;
+        }
        if (channel->irq)
                synchronize_irq(channel->irq);
@@ -347,13 +352,15 @@ void efx_process_channel_now(struct efx_channel *channel)
        napi_disable(&channel->napi_str);
        /* Poll the channel */
-        efx_process_channel(channel, EFX_EVQ_SIZE);
+        efx_process_channel(channel, channel->eventq_mask + 1);
        /* Ack the eventq. This may cause an interrupt to be generated
         * when they are reenabled */
        efx_channel_processed(channel);
        napi_enable(&channel->napi_str);
+        if (efx->legacy_irq)
+                efx->legacy_irq_enabled = true;
        efx_nic_enable_interrupts(efx);
 }
@@ -364,9 +371,18 @@ void efx_process_channel_now(struct efx_channel *channel)
 */
 static int efx_probe_eventq(struct efx_channel *channel)
 {
+        struct efx_nic *efx = channel->efx;
+        unsigned long entries;
        netif_dbg(channel->efx, probe, channel->efx->net_dev,
                  "chan %d create event queue\n", channel->channel);
+        /* Build an event queue with room for one event per tx and rx buffer,
+         * plus some extra for link state events and MCDI completions. */
+        entries = roundup_pow_of_two(efx->rxq_entries + efx->txq_entries + 128);
+        EFX_BUG_ON_PARANOID(entries > EFX_MAX_EVQ_SIZE);
+        channel->eventq_mask = max(entries, EFX_MIN_EVQ_SIZE) - 1;
        return efx_nic_probe_eventq(channel);
 }
@@ -403,6 +419,61 @@ static void efx_remove_eventq(struct efx_channel *channel)
 *
 *************************************************************************/
+/* Allocate and initialise a channel structure, optionally copying
+ * parameters (but not resources) from an old channel structure. */
+static struct efx_channel *
+efx_alloc_channel(struct efx_nic *efx, int i, struct efx_channel *old_channel)
+{
+        struct efx_channel *channel;
+        struct efx_rx_queue *rx_queue;
+        struct efx_tx_queue *tx_queue;
+        int j;
+        if (old_channel) {
+                channel = kmalloc(sizeof(*channel), GFP_KERNEL);
+                if (!channel)
+                        return NULL;
+                *channel = *old_channel;
+                channel->napi_dev = NULL;
+                memset(&channel->eventq, 0, sizeof(channel->eventq));
+                rx_queue = &channel->rx_queue;
+                rx_queue->buffer = NULL;
+                memset(&rx_queue->rxd, 0, sizeof(rx_queue->rxd));
+                for (j = 0; j < EFX_TXQ_TYPES; j++) {
+                        tx_queue = &channel->tx_queue[j];
+                        if (tx_queue->channel)
+                                tx_queue->channel = channel;
+                        tx_queue->buffer = NULL;
+                        memset(&tx_queue->txd, 0, sizeof(tx_queue->txd));
+                }
+        } else {
+                channel = kzalloc(sizeof(*channel), GFP_KERNEL);
+                if (!channel)
+                        return NULL;
+                channel->efx = efx;
+                channel->channel = i;
+                for (j = 0; j < EFX_TXQ_TYPES; j++) {
+                        tx_queue = &channel->tx_queue[j];
+                        tx_queue->efx = efx;
+                        tx_queue->queue = i * EFX_TXQ_TYPES + j;
+                        tx_queue->channel = channel;
+                }
+        }
+        rx_queue = &channel->rx_queue;
+        rx_queue->efx = efx;
+        setup_timer(&rx_queue->slow_fill, efx_rx_slow_fill,
+                    (unsigned long)rx_queue);
+        return channel;
+}
 static int efx_probe_channel(struct efx_channel *channel)
 {
        struct efx_tx_queue *tx_queue;
@@ -459,11 +530,38 @@ static void efx_set_channel_names(struct efx_nic *efx)
                                number -= efx->n_rx_channels;
                        }
                }
-                snprintf(channel->name, sizeof(channel->name),
+                snprintf(efx->channel_name[channel->channel],
+                         sizeof(efx->channel_name[0]),
                         "%s%s-%d", efx->name, type, number);
        }
 }
+static int efx_probe_channels(struct efx_nic *efx)
+{
+        struct efx_channel *channel;
+        int rc;
+        /* Restart special buffer allocation */
+        efx->next_buffer_table = 0;
+        efx_for_each_channel(channel, efx) {
+                rc = efx_probe_channel(channel);
+                if (rc) {
+                        netif_err(efx, probe, efx->net_dev,
+                                  "failed to create channel %d\n",
+                                  channel->channel);
+                        goto fail;
+                }
+        }
+        efx_set_channel_names(efx);
+        return 0;
+fail:
+        efx_remove_channels(efx);
+        return rc;
+}
 /* Channels are shutdown and reinitialised whilst the NIC is running
 * to propagate configuration changes (mtu, checksum offload), or
 * to clear hardware error conditions
@@ -580,7 +678,7 @@ static void efx_fini_channels(struct efx_nic *efx)
                efx_for_each_channel_rx_queue(rx_queue, channel)
                        efx_fini_rx_queue(rx_queue);
-                efx_for_each_channel_tx_queue(tx_queue, channel)
+                efx_for_each_possible_channel_tx_queue(tx_queue, channel)
                        efx_fini_tx_queue(tx_queue);
                efx_fini_eventq(channel);
        }
@@ -596,11 +694,84 @@ static void efx_remove_channel(struct efx_channel *channel)
        efx_for_each_channel_rx_queue(rx_queue, channel)
                efx_remove_rx_queue(rx_queue);
-        efx_for_each_channel_tx_queue(tx_queue, channel)
+        efx_for_each_possible_channel_tx_queue(tx_queue, channel)
                efx_remove_tx_queue(tx_queue);
        efx_remove_eventq(channel);
 }
+static void efx_remove_channels(struct efx_nic *efx)
+{
+        struct efx_channel *channel;
+        efx_for_each_channel(channel, efx)
+                efx_remove_channel(channel);
+}
+int
+efx_realloc_channels(struct efx_nic *efx, u32 rxq_entries, u32 txq_entries)
+{
+        struct efx_channel *other_channel[EFX_MAX_CHANNELS], *channel;
+        u32 old_rxq_entries, old_txq_entries;
+        unsigned i;
+        int rc;
+        efx_stop_all(efx);
+        efx_fini_channels(efx);
+        /* Clone channels */
+        memset(other_channel, 0, sizeof(other_channel));
+        for (i = 0; i < efx->n_channels; i++) {
+                channel = efx_alloc_channel(efx, i, efx->channel[i]);
+                if (!channel) {
+                        rc = -ENOMEM;
+                        goto out;
+                }
+                other_channel[i] = channel;
+        }
+        /* Swap entry counts and channel pointers */
+        old_rxq_entries = efx->rxq_entries;
+        old_txq_entries = efx->txq_entries;
+        efx->rxq_entries = rxq_entries;
+        efx->txq_entries = txq_entries;
+        for (i = 0; i < efx->n_channels; i++) {
+                channel = efx->channel[i];
+                efx->channel[i] = other_channel[i];
+                other_channel[i] = channel;
+        }
+        rc = efx_probe_channels(efx);
+        if (rc)
+                goto rollback;
+        efx_init_napi(efx);
+        /* Destroy old channels */
+        for (i = 0; i < efx->n_channels; i++) {
+                efx_fini_napi_channel(other_channel[i]);
+                efx_remove_channel(other_channel[i]);
+        }
+out:
+        /* Free unused channel structures */
+        for (i = 0; i < efx->n_channels; i++)
+                kfree(other_channel[i]);
+        efx_init_channels(efx);
+        efx_start_all(efx);
+        return rc;
+rollback:
+        /* Swap back */
+        efx->rxq_entries = old_rxq_entries;
+        efx->txq_entries = old_txq_entries;
+        for (i = 0; i < efx->n_channels; i++) {
+                channel = efx->channel[i];
+                efx->channel[i] = other_channel[i];
+                other_channel[i] = channel;
+        }
+        goto out;
+}
 void efx_schedule_slow_fill(struct efx_rx_queue *rx_queue)
 {
        mod_timer(&rx_queue->slow_fill, jiffies + msecs_to_jiffies(100));
@@ -627,11 +798,6 @@ void efx_link_status_changed(struct efx_nic *efx)
        if (!netif_running(efx->net_dev))
                return;
-        if (efx->port_inhibited) {
-                netif_carrier_off(efx->net_dev);
-                return;
-        }
        if (link_state->up != netif_carrier_ok(efx->net_dev)) {
                efx->n_link_state_changes++;
@@ -667,7 +833,7 @@ void efx_link_set_advertising(struct efx_nic *efx, u32 advertising)
        }
 }
-void efx_link_set_wanted_fc(struct efx_nic *efx, enum efx_fc_type wanted_fc)
+void efx_link_set_wanted_fc(struct efx_nic *efx, u8 wanted_fc)
 {
        efx->wanted_fc = wanted_fc;
        if (efx->link_advertising) {
@@ -751,6 +917,7 @@ static void efx_mac_work(struct work_struct *data)
 static int efx_probe_port(struct efx_nic *efx)
 {
+        unsigned char *perm_addr;
        int rc;
        netif_dbg(efx, probe, efx->net_dev, "create port\n");
@@ -761,14 +928,15 @@ static int efx_probe_port(struct efx_nic *efx)
        /* Connect up MAC/PHY operations table */
        rc = efx->type->probe_port(efx);
        if (rc)
-                goto err;
+                return rc;
        /* Sanity check MAC address */
-        if (is_valid_ether_addr(efx->mac_address)) {
+        perm_addr = efx->net_dev->perm_addr;
-                memcpy(efx->net_dev->dev_addr, efx->mac_address, ETH_ALEN);
+        if (is_valid_ether_addr(perm_addr)) {
+                memcpy(efx->net_dev->dev_addr, perm_addr, ETH_ALEN);
        } else {
                netif_err(efx, probe, efx->net_dev, "invalid MAC address %pM\n",
-                          efx->mac_address);
+                          perm_addr);
                if (!allow_bad_hwaddr) {
                        rc = -EINVAL;
                        goto err;
@@ -782,7 +950,7 @@ static int efx_probe_port(struct efx_nic *efx)
        return 0;
 err:
-        efx_remove_port(efx);
+        efx->type->remove_port(efx);
        return rc;
 }
@@ -883,6 +1051,7 @@ static int efx_init_io(struct efx_nic *efx)
 {
        struct pci_dev *pci_dev = efx->pci_dev;
        dma_addr_t dma_mask = efx->type->max_dma_mask;
+        bool use_wc;
        int rc;
        netif_dbg(efx, probe, efx->net_dev, "initialising I/O\n");
@@ -933,8 +1102,21 @@ static int efx_init_io(struct efx_nic *efx)
                rc = -EIO;
                goto fail3;
        }
-        efx->membase = ioremap_nocache(efx->membase_phys,
-                                       efx->type->mem_map_size);
+        /* bug22643: If SR-IOV is enabled then tx push over a write combined
+         * mapping is unsafe. We need to disable write combining in this case.
+         * MSI is unsupported when SR-IOV is enabled, and the firmware will
+         * have removed the MSI capability. So write combining is safe if
+         * there is an MSI capability.
+         */
+        use_wc = (!EFX_WORKAROUND_22643(efx) ||
+                  pci_find_capability(pci_dev, PCI_CAP_ID_MSI));
+        if (use_wc)
+                efx->membase = ioremap_wc(efx->membase_phys,
+                                          efx->type->mem_map_size);
+        else
+                efx->membase = ioremap_nocache(efx->membase_phys,
+                                               efx->type->mem_map_size);
        if (!efx->membase) {
                netif_err(efx, probe, efx->net_dev,
                          "could not map memory BAR at %llx+%x\n",
@@ -985,6 +1167,9 @@ static int efx_wanted_channels(void)
        int count;
        int cpu;
+        if (rss_cpus)
+                return rss_cpus;
        if (unlikely(!zalloc_cpumask_var(&core_mask, GFP_KERNEL))) {
                printk(KERN_WARNING
                       "sfc: RSS disabled due to allocation failure\n");
@@ -1004,10 +1189,32 @@ static int efx_wanted_channels(void)
        return count;
 }
+static int
+efx_init_rx_cpu_rmap(struct efx_nic *efx, struct msix_entry *xentries)
+{
+#ifdef CONFIG_RFS_ACCEL
+        int i, rc;
+        efx->net_dev->rx_cpu_rmap = alloc_irq_cpu_rmap(efx->n_rx_channels);
+        if (!efx->net_dev->rx_cpu_rmap)
+                return -ENOMEM;
+        for (i = 0; i < efx->n_rx_channels; i++) {
+                rc = irq_cpu_rmap_add(efx->net_dev->rx_cpu_rmap,
+                                      xentries[i].vector);
+                if (rc) {
+                        free_irq_cpu_rmap(efx->net_dev->rx_cpu_rmap);
+                        efx->net_dev->rx_cpu_rmap = NULL;
+                        return rc;
+                }
+        }
+#endif
+        return 0;
+}
 /* Probe the number and type of interrupts we are able to obtain, and
 * the resulting numbers of channels and RX queues.
 */
-static void efx_probe_interrupts(struct efx_nic *efx)
+static int efx_probe_interrupts(struct efx_nic *efx)
 {
        int max_channels =
                min_t(int, efx->type->phys_addr_channels, EFX_MAX_CHANNELS);
@@ -1049,8 +1256,14 @@ static void efx_probe_interrupts(struct efx_nic *efx)
                                efx->n_tx_channels = efx->n_channels;
                                efx->n_rx_channels = efx->n_channels;
                        }
+                        rc = efx_init_rx_cpu_rmap(efx, xentries);
+                        if (rc) {
+                                pci_disable_msix(efx->pci_dev);
+                                return rc;
+                        }
                        for (i = 0; i < n_channels; i++)
-                                efx->channel[i].irq = xentries[i].vector;
+                                efx_get_channel(efx, i)->irq =
+                                        xentries[i].vector;
                } else {
                        /* Fall back to single channel MSI */
                        efx->interrupt_mode = EFX_INT_MODE_MSI;
@@ -1066,7 +1279,7 @@ static void efx_probe_interrupts(struct efx_nic *efx)
                efx->n_tx_channels = 1;
                rc = pci_enable_msi(efx->pci_dev);
                if (rc == 0) {
-                        efx->channel[0].irq = efx->pci_dev->irq;
+                        efx_get_channel(efx, 0)->irq = efx->pci_dev->irq;
                } else {
                        netif_err(efx, drv, efx->net_dev,
                                  "could not enable MSI\n");
@@ -1081,6 +1294,8 @@ static void efx_probe_interrupts(struct efx_nic *efx)
                efx->n_tx_channels = 1;
                efx->legacy_irq = efx->pci_dev->irq;
        }
+        return 0;
 }
 static void efx_remove_interrupts(struct efx_nic *efx)
@@ -1101,22 +1316,18 @@ static void efx_set_channels(struct efx_nic *efx)
 {
        struct efx_channel *channel;
        struct efx_tx_queue *tx_queue;
-        struct efx_rx_queue *rx_queue;
-        unsigned tx_channel_offset =
+        efx->tx_channel_offset =
                separate_tx_channels ? efx->n_channels - efx->n_tx_channels : 0;
+        /* We need to adjust the TX queue numbers if we have separate
+         * RX-only and TX-only channels.
+         */
        efx_for_each_channel(channel, efx) {
-                if (channel->channel - tx_channel_offset < efx->n_tx_channels) {
+                efx_for_each_channel_tx_queue(tx_queue, channel)
-                        channel->tx_queue = &efx->tx_queue[
+                        tx_queue->queue -= (efx->tx_channel_offset *
-                                (channel->channel - tx_channel_offset) *
+                                            EFX_TXQ_TYPES);
-                                EFX_TXQ_TYPES];
-                        efx_for_each_channel_tx_queue(tx_queue, channel)
-                                tx_queue->channel = channel;
-                }
        }
-        efx_for_each_rx_queue(rx_queue, efx)
-                rx_queue->channel = &efx->channel[rx_queue->queue];
 }
 static int efx_probe_nic(struct efx_nic *efx)
@@ -1133,7 +1344,9 @@ static int efx_probe_nic(struct efx_nic *efx)
        /* Determine the number of channels and queues by trying to hook
         * in MSI-X interrupts. */
-        efx_probe_interrupts(efx);
+        rc = efx_probe_interrupts(efx);
+        if (rc)
+                goto fail;
        if (efx->n_channels > 1)
                get_random_bytes(&efx->rx_hash_key, sizeof(efx->rx_hash_key));
@@ -1141,12 +1354,17 @@ static int efx_probe_nic(struct efx_nic *efx)
                efx->rx_indir_table[i] = i % efx->n_rx_channels;
        efx_set_channels(efx);
-        efx->net_dev->real_num_tx_queues = efx->n_tx_channels;
+        netif_set_real_num_tx_queues(efx->net_dev, efx->n_tx_channels);
+        netif_set_real_num_rx_queues(efx->net_dev, efx->n_rx_channels);
        /* Initialise the interrupt moderation settings */
        efx_init_irq_moderation(efx, tx_irq_mod_usec, rx_irq_mod_usec, true);
        return 0;
+fail:
+        efx->type->remove(efx);
+        return rc;
 }
 static void efx_remove_nic(struct efx_nic *efx)
@@ -1165,40 +1383,37 @@ static void efx_remove_nic(struct efx_nic *efx)
 static int efx_probe_all(struct efx_nic *efx)
 {
-        struct efx_channel *channel;
        int rc;
-        /* Create NIC */
        rc = efx_probe_nic(efx);
        if (rc) {
                netif_err(efx, probe, efx->net_dev, "failed to create NIC\n");
                goto fail1;
        }
-        /* Create port */
        rc = efx_probe_port(efx);
        if (rc) {
                netif_err(efx, probe, efx->net_dev, "failed to create port\n");
                goto fail2;
        }
-        /* Create channels */
+        efx->rxq_entries = efx->txq_entries = EFX_DEFAULT_DMAQ_SIZE;
-        efx_for_each_channel(channel, efx) {
+        rc = efx_probe_channels(efx);
-                rc = efx_probe_channel(channel);
+        if (rc)
-                if (rc) {
+                goto fail3;
-                        netif_err(efx, probe, efx->net_dev,
-                                  "failed to create channel %d\n",
+        rc = efx_probe_filters(efx);
-                                  channel->channel);
+        if (rc) {
-                        goto fail3;
+                netif_err(efx, probe, efx->net_dev,
-                }
+                          "failed to create filter tables\n");
+                goto fail4;
        }
-        efx_set_channel_names(efx);
        return 0;
+ fail4:
+        efx_remove_channels(efx);
 fail3:
-        efx_for_each_channel(channel, efx)
-                efx_remove_channel(channel);
        efx_remove_port(efx);
 fail2:
        efx_remove_nic(efx);
@@ -1230,12 +1445,14 @@ static void efx_start_all(struct efx_nic *efx)
         * restart the transmit interface early so the watchdog timer stops */
        efx_start_port(efx);
-        efx_for_each_channel(channel, efx) {
+        if (efx_dev_registered(efx) && netif_device_present(efx->net_dev))
-                if (efx_dev_registered(efx))
+                netif_tx_wake_all_queues(efx->net_dev);
-                        efx_wake_queue(channel);
+        efx_for_each_channel(channel, efx)
                efx_start_channel(channel);
-        }
+        if (efx->legacy_irq)
+                efx->legacy_irq_enabled = true;
        efx_nic_enable_interrupts(efx);
        /* Switch to event based MCDI completions after enabling interrupts.
@@ -1296,8 +1513,10 @@ static void efx_stop_all(struct efx_nic *efx)
        /* Disable interrupts and wait for ISR to complete */
        efx_nic_disable_interrupts(efx);
-        if (efx->legacy_irq)
+        if (efx->legacy_irq) {
                synchronize_irq(efx->legacy_irq);
+                efx->legacy_irq_enabled = false;
+        }
        efx_for_each_channel(channel, efx) {
                if (channel->irq)
                        synchronize_irq(channel->irq);
@@ -1318,9 +1537,7 @@ static void efx_stop_all(struct efx_nic *efx)
        /* Stop the kernel transmit interface late, so the watchdog
         * timer isn't ticking over the flush */
        if (efx_dev_registered(efx)) {
-                struct efx_channel *channel;
+                netif_tx_stop_all_queues(efx->net_dev);
-                efx_for_each_channel(channel, efx)
-                        efx_stop_queue(channel);
                netif_tx_lock_bh(efx->net_dev);
                netif_tx_unlock_bh(efx->net_dev);
        }
@@ -1328,10 +1545,8 @@ static void efx_stop_all(struct efx_nic *efx)
 static void efx_remove_all(struct efx_nic *efx)
 {
-        struct efx_channel *channel;
+        efx_remove_filters(efx);
+        efx_remove_channels(efx);
-        efx_for_each_channel(channel, efx)
-                efx_remove_channel(channel);
        efx_remove_port(efx);
        efx_remove_nic(efx);
 }
@@ -1355,20 +1570,20 @@ static unsigned irq_mod_ticks(int usecs, int resolution)
 void efx_init_irq_moderation(struct efx_nic *efx, int tx_usecs, int rx_usecs,
                             bool rx_adaptive)
 {
-        struct efx_tx_queue *tx_queue;
+        struct efx_channel *channel;
-        struct efx_rx_queue *rx_queue;
        unsigned tx_ticks = irq_mod_ticks(tx_usecs, EFX_IRQ_MOD_RESOLUTION);
        unsigned rx_ticks = irq_mod_ticks(rx_usecs, EFX_IRQ_MOD_RESOLUTION);
        EFX_ASSERT_RESET_SERIALISED(efx);
-        efx_for_each_tx_queue(tx_queue, efx)
-                tx_queue->channel->irq_moderation = tx_ticks;
        efx->irq_rx_adaptive = rx_adaptive;
        efx->irq_rx_moderation = rx_ticks;
-        efx_for_each_rx_queue(rx_queue, efx)
+        efx_for_each_channel(channel, efx) {
-                rx_queue->channel->irq_moderation = rx_ticks;
+                if (efx_channel_has_rx_queue(channel))
+                        channel->irq_moderation = rx_ticks;
+                else if (efx_channel_has_tx_queues(channel))
+                        channel->irq_moderation = tx_ticks;
+        }
 }
 /**************************************************************************
@@ -1377,8 +1592,7 @@ void efx_init_irq_moderation(struct efx_nic *efx, int tx_usecs, int rx_usecs,
 *
 **************************************************************************/
-/* Run periodically off the general workqueue. Serialised against
+/* Run periodically off the general workqueue */
- * efx_reconfigure_port via the mac_lock */
 static void efx_monitor(struct work_struct *data)
 {
        struct efx_nic *efx = container_of(data, struct efx_nic,
@@ -1391,16 +1605,13 @@ static void efx_monitor(struct work_struct *data)
        /* If the mac_lock is already held then it is likely a port
         * reconfiguration is already in place, which will likely do
-         * most of the work of check_hw() anyway. */
+         * most of the work of monitor() anyway. */
-        if (!mutex_trylock(&efx->mac_lock))
+        if (mutex_trylock(&efx->mac_lock)) {
-                goto out_requeue;
+                if (efx->port_enabled)
-        if (!efx->port_enabled)
+                        efx->type->monitor(efx);
-                goto out_unlock;
+                mutex_unlock(&efx->mac_lock);
-        efx->type->monitor(efx);
+        }
-out_unlock:
-        mutex_unlock(&efx->mac_lock);
-out_requeue:
        queue_delayed_work(efx->workqueue, &efx->monitor_work,
                           efx_monitor_interval);
 }
@@ -1435,7 +1646,7 @@ static int efx_ioctl(struct net_device *net_dev, struct ifreq *ifr, int cmd)
 *
 **************************************************************************/
-static int efx_init_napi(struct efx_nic *efx)
+static void efx_init_napi(struct efx_nic *efx)
 {
        struct efx_channel *channel;
@@ -1444,18 +1655,21 @@ static int efx_init_napi(struct efx_nic *efx)
                netif_napi_add(channel->napi_dev, &channel->napi_str,
                               efx_poll, napi_weight);
        }
-        return 0;
+}
+static void efx_fini_napi_channel(struct efx_channel *channel)
+{
+        if (channel->napi_dev)
+                netif_napi_del(&channel->napi_str);
+        channel->napi_dev = NULL;
 }
 static void efx_fini_napi(struct efx_nic *efx)
 {
        struct efx_channel *channel;
-        efx_for_each_channel(channel, efx) {
+        efx_for_each_channel(channel, efx)
-                if (channel->napi_dev)
+                efx_fini_napi_channel(channel);
-                        netif_napi_del(&channel->napi_str);
-                channel->napi_dev = NULL;
-        }
 }
 /**************************************************************************
@@ -1546,11 +1760,11 @@ static struct rtnl_link_stats64 *efx_net_stats(struct net_device *net_dev, struc
        stats->tx_packets = mac_stats->tx_packets;
        stats->rx_bytes = mac_stats->rx_bytes;
        stats->tx_bytes = mac_stats->tx_bytes;
+        stats->rx_dropped = efx->n_rx_nodesc_drop_cnt;
        stats->multicast = mac_stats->rx_multicast;
        stats->collisions = mac_stats->tx_collision;
        stats->rx_length_errors = (mac_stats->rx_gtjumbo +
                                   mac_stats->rx_length_error);
-        stats->rx_over_errors = efx->n_rx_nodesc_drop_cnt;
        stats->rx_crc_errors = mac_stats->rx_bad;
        stats->rx_frame_errors = mac_stats->rx_align_error;
        stats->rx_fifo_errors = mac_stats->rx_overflow;
@@ -1669,6 +1883,17 @@ static void efx_set_multicast_list(struct net_device *net_dev)
        /* Otherwise efx_start_port() will do this */
 }
+static int efx_set_features(struct net_device *net_dev, u32 data)
+{
+        struct efx_nic *efx = netdev_priv(net_dev);
+        /* If disabling RX n-tuple filtering, clear existing filters */
+        if (net_dev->features & ~data & NETIF_F_NTUPLE)
+                efx_filter_clear_rx(efx, EFX_FILTER_PRI_MANUAL);
+        return 0;
+}
 static const struct net_device_ops efx_netdev_ops = {
        .ndo_open               = efx_net_open,
        .ndo_stop               = efx_net_stop,
@@ -1680,9 +1905,14 @@ static const struct net_device_ops efx_netdev_ops = {
        .ndo_change_mtu         = efx_change_mtu,
        .ndo_set_mac_address    = efx_set_mac_address,
        .ndo_set_multicast_list = efx_set_multicast_list,
+        .ndo_set_features       = efx_set_features,
 #ifdef CONFIG_NET_POLL_CONTROLLER
        .ndo_poll_controller = efx_netpoll,
 #endif
+        .ndo_setup_tc           = efx_setup_tc,
+#ifdef CONFIG_RFS_ACCEL
+        .ndo_rx_flow_steer      = efx_filter_rfs,
+#endif
 };
 static void efx_update_name(struct efx_nic *efx)
@@ -1719,6 +1949,7 @@ static DEVICE_ATTR(phy_type, 0644, show_phy_type, NULL);
 static int efx_register_netdev(struct efx_nic *efx)
 {
        struct net_device *net_dev = efx->net_dev;
+        struct efx_channel *channel;
        int rc;
        net_dev->watchdog_timeo = 5 * HZ;
@@ -1741,6 +1972,12 @@ static int efx_register_netdev(struct efx_nic *efx)
        if (rc)
                goto fail_locked;
+        efx_for_each_channel(channel, efx) {
+                struct efx_tx_queue *tx_queue;
+                efx_for_each_channel_tx_queue(tx_queue, channel)
+                        efx_init_tx_queue_core_txq(tx_queue);
+        }
        /* Always start with carrier off; PHY events will detect the link */
        netif_carrier_off(efx->net_dev);
@@ -1767,6 +2004,7 @@ fail_registered:
 static void efx_unregister_netdev(struct efx_nic *efx)
 {
+        struct efx_channel *channel;
        struct efx_tx_queue *tx_queue;
        if (!efx->net_dev)
@@ -1777,8 +2015,10 @@ static void efx_unregister_netdev(struct efx_nic *efx)
        /* Free up any skbs still remaining. This has to happen before
         * we try to unregister the netdev as running their destructors
         * may be needed to get the device ref. count to 0. */
-        efx_for_each_tx_queue(tx_queue, efx)
+        efx_for_each_channel(channel, efx) {
-                efx_release_tx_buffers(tx_queue);
+                efx_for_each_channel_tx_queue(tx_queue, channel)
+                        efx_release_tx_buffers(tx_queue);
+        }
        if (efx_dev_registered(efx)) {
                strlcpy(efx->name, pci_name(efx->pci_dev), sizeof(efx->name));
@@ -1801,7 +2041,6 @@ void efx_reset_down(struct efx_nic *efx, enum reset_type method)
        efx_stop_all(efx);
        mutex_lock(&efx->mac_lock);
-        mutex_lock(&efx->spi_lock);
        efx_fini_channels(efx);
        if (efx->port_initialized && method != RESET_TYPE_INVISIBLE)
@@ -1841,8 +2080,8 @@ int efx_reset_up(struct efx_nic *efx, enum reset_type method, bool ok)
        efx->mac_op->reconfigure(efx);
        efx_init_channels(efx);
+        efx_restore_filters(efx);
-        mutex_unlock(&efx->spi_lock);
        mutex_unlock(&efx->mac_lock);
        efx_start_all(efx);
@@ -1852,7 +2091,6 @@ int efx_reset_up(struct efx_nic *efx, enum reset_type method, bool ok)
 fail:
        efx->port_initialized = false;
-        mutex_unlock(&efx->spi_lock);
        mutex_unlock(&efx->mac_lock);
        return rc;
@@ -1871,6 +2109,7 @@ int efx_reset(struct efx_nic *efx, enum reset_type method)
        netif_info(efx, drv, efx->net_dev, "resetting (%s)\n",
                   RESET_TYPE(method));
+        netif_device_detach(efx->net_dev);
        efx_reset_down(efx, method);
        rc = efx->type->reset(efx, method);
@@ -1904,6 +2143,7 @@ out:
                efx->state = STATE_DISABLED;
        } else {
                netif_dbg(efx, drv, efx->net_dev, "reset complete\n");
+                netif_device_attach(efx->net_dev);
        }
        return rc;
 }
@@ -2010,15 +2250,13 @@ int efx_port_dummy_op_int(struct efx_nic *efx)
        return 0;
 }
 void efx_port_dummy_op_void(struct efx_nic *efx) {}
-void efx_port_dummy_op_set_id_led(struct efx_nic *efx, enum efx_led_mode mode)
-{
+static bool efx_port_dummy_op_poll(struct efx_nic *efx)
-}
-bool efx_port_dummy_op_poll(struct efx_nic *efx)
 {
        return false;
 }
-static struct efx_phy_operations efx_dummy_phy_operations = {
+static const struct efx_phy_operations efx_dummy_phy_operations = {
        .init            = efx_port_dummy_op_int,
        .reconfigure     = efx_port_dummy_op_int,
        .poll            = efx_port_dummy_op_poll,
@@ -2034,19 +2272,14 @@ static struct efx_phy_operations efx_dummy_phy_operations = {
 /* This zeroes out and then fills in the invariants in a struct
 * efx_nic (including all sub-structures).
 */
-static int efx_init_struct(struct efx_nic *efx, struct efx_nic_type *type,
+static int efx_init_struct(struct efx_nic *efx, const struct efx_nic_type *type,
                           struct pci_dev *pci_dev, struct net_device *net_dev)
 {
-        struct efx_channel *channel;
-        struct efx_tx_queue *tx_queue;
-        struct efx_rx_queue *rx_queue;
        int i;
        /* Initialise common structures */
        memset(efx, 0, sizeof(*efx));
        spin_lock_init(&efx->biu_lock);
-        mutex_init(&efx->mdio_lock);
-        mutex_init(&efx->spi_lock);
 #ifdef CONFIG_SFC_MTD
        INIT_LIST_HEAD(&efx->mtd_list);
 #endif
@@ -2059,7 +2292,6 @@ static int efx_init_struct(struct efx_nic *efx, struct efx_nic_type *type,
        strlcpy(efx->name, pci_name(pci_dev), sizeof(efx->name));
        efx->net_dev = net_dev;
-        efx->rx_checksum_enabled = true;
        spin_lock_init(&efx->stats_lock);
        mutex_init(&efx->mac_lock);
        efx->mac_op = type->default_mac_ops;
@@ -2068,36 +2300,13 @@ static int efx_init_struct(struct efx_nic *efx, struct efx_nic_type *type,
        INIT_WORK(&efx->mac_work, efx_mac_work);
        for (i = 0; i < EFX_MAX_CHANNELS; i++) {
-                channel = &efx->channel[i];
+                efx->channel[i] = efx_alloc_channel(efx, i, NULL);
-                channel->efx = efx;
+                if (!efx->channel[i])
-                channel->channel = i;
+                        goto fail;
-                channel->work_pending = false;
-                spin_lock_init(&channel->tx_stop_lock);
-                atomic_set(&channel->tx_stop_count, 1);
-        }
-        for (i = 0; i < EFX_MAX_TX_QUEUES; i++) {
-                tx_queue = &efx->tx_queue[i];
-                tx_queue->efx = efx;
-                tx_queue->queue = i;
-                tx_queue->buffer = NULL;
-                tx_queue->channel = &efx->channel[0]; /* for safety */
-                tx_queue->tso_headers_free = NULL;
-        }
-        for (i = 0; i < EFX_MAX_RX_QUEUES; i++) {
-                rx_queue = &efx->rx_queue[i];
-                rx_queue->efx = efx;
-                rx_queue->queue = i;
-                rx_queue->channel = &efx->channel[0]; /* for safety */
-                rx_queue->buffer = NULL;
-                setup_timer(&rx_queue->slow_fill, efx_rx_slow_fill,
-                            (unsigned long)rx_queue);
        }
        efx->type = type;
-        /* As close as we can get to guaranteeing that we don't overflow */
-        BUILD_BUG_ON(EFX_EVQ_SIZE < EFX_TXQ_SIZE + EFX_RXQ_SIZE);
        EFX_BUG_ON_PARANOID(efx->type->phys_addr_channels > EFX_MAX_CHANNELS);
        /* Higher numbered interrupt modes are less capable! */
@@ -2109,13 +2318,22 @@ static int efx_init_struct(struct efx_nic *efx, struct efx_nic_type *type,
                 pci_name(pci_dev));
        efx->workqueue = create_singlethread_workqueue(efx->workqueue_name);
        if (!efx->workqueue)
-                return -ENOMEM;
+                goto fail;
        return 0;
+fail:
+        efx_fini_struct(efx);
+        return -ENOMEM;
 }
 static void efx_fini_struct(struct efx_nic *efx)
 {
+        int i;
+        for (i = 0; i < EFX_MAX_CHANNELS; i++)
+                kfree(efx->channel[i]);
        if (efx->workqueue) {
                destroy_workqueue(efx->workqueue);
                efx->workqueue = NULL;
@@ -2133,6 +2351,10 @@ static void efx_fini_struct(struct efx_nic *efx)
 */
 static void efx_pci_remove_main(struct efx_nic *efx)
 {
+#ifdef CONFIG_RFS_ACCEL
+        free_irq_cpu_rmap(efx->net_dev->rx_cpu_rmap);
+        efx->net_dev->rx_cpu_rmap = NULL;
+#endif
        efx_nic_fini_interrupt(efx);
        efx_fini_channels(efx);
        efx_fini_port(efx);
@@ -2192,9 +2414,7 @@ static int efx_pci_probe_main(struct efx_nic *efx)
        if (rc)
                goto fail1;
-        rc = efx_init_napi(efx);
+        efx_init_napi(efx);
-        if (rc)
-                goto fail2;
        rc = efx->type->init(efx);
        if (rc) {
@@ -2225,7 +2445,6 @@ static int efx_pci_probe_main(struct efx_nic *efx)
        efx->type->fini(efx);
 fail3:
        efx_fini_napi(efx);
- fail2:
        efx_remove_all(efx);
 fail1:
        return rc;
@@ -2243,23 +2462,27 @@ static int efx_pci_probe_main(struct efx_nic *efx)
 static int __devinit efx_pci_probe(struct pci_dev *pci_dev,
                                   const struct pci_device_id *entry)
 {
-        struct efx_nic_type *type = (struct efx_nic_type *) entry->driver_data;
+        const struct efx_nic_type *type = (const struct efx_nic_type *) entry->driver_data;
        struct net_device *net_dev;
        struct efx_nic *efx;
        int i, rc;
        /* Allocate and initialise a struct net_device and struct efx_nic */
-        net_dev = alloc_etherdev_mq(sizeof(*efx), EFX_MAX_CORE_TX_QUEUES);
+        net_dev = alloc_etherdev_mqs(sizeof(*efx), EFX_MAX_CORE_TX_QUEUES,
+                                     EFX_MAX_RX_QUEUES);
        if (!net_dev)
                return -ENOMEM;
        net_dev->features |= (type->offload_features | NETIF_F_SG |
                              NETIF_F_HIGHDMA | NETIF_F_TSO |
-                              NETIF_F_GRO);
+                              NETIF_F_RXCSUM);
        if (type->offload_features & NETIF_F_V6_CSUM)
                net_dev->features |= NETIF_F_TSO6;
        /* Mask for features that also apply to VLAN devices */
        net_dev->vlan_features |= (NETIF_F_ALL_CSUM | NETIF_F_SG |
-                                   NETIF_F_HIGHDMA | NETIF_F_TSO);
+                                   NETIF_F_HIGHDMA | NETIF_F_ALL_TSO |
+                                   NETIF_F_RXCSUM);
+        /* All offloads can be toggled */
+        net_dev->hw_features = net_dev->features & ~NETIF_F_HIGHDMA;
        efx = netdev_priv(net_dev);
        pci_set_drvdata(pci_dev, efx);
        SET_NETDEV_DEV(net_dev, &pci_dev->dev);
diff --git a/drivers/net/sfc/efx.h b/drivers/net/sfc/efx.h
index 060dc952a0fd..b0d1209ea18d 100644
--- a/drivers/net/sfc/efx.h
+++ b/drivers/net/sfc/efx.h
@@ -1,7 +1,7 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
 * Copyright 2005-2006 Fen Systems Ltd.
- * Copyright 2006-2009 Solarflare Communications Inc.
+ * Copyright 2006-2010 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -12,6 +12,7 @@
 #define EFX_EFX_H
 #include "net_driver.h"
+#include "filter.h"
 /* PCI IDs */
 #define EFX_VENDID_SFC          0x1924
@@ -28,6 +29,7 @@
 extern int efx_probe_tx_queue(struct efx_tx_queue *tx_queue);
 extern void efx_remove_tx_queue(struct efx_tx_queue *tx_queue);
 extern void efx_init_tx_queue(struct efx_tx_queue *tx_queue);
+extern void efx_init_tx_queue_core_txq(struct efx_tx_queue *tx_queue);
 extern void efx_fini_tx_queue(struct efx_tx_queue *tx_queue);
 extern void efx_release_tx_buffers(struct efx_tx_queue *tx_queue);
 extern netdev_tx_t
@@ -35,10 +37,7 @@ efx_hard_start_xmit(struct sk_buff *skb, struct net_device *net_dev);
 extern netdev_tx_t
 efx_enqueue_skb(struct efx_tx_queue *tx_queue, struct sk_buff *skb);
 extern void efx_xmit_done(struct efx_tx_queue *tx_queue, unsigned int index);
-extern void efx_stop_queue(struct efx_channel *channel);
+extern int efx_setup_tc(struct net_device *net_dev, u8 num_tc);
-extern void efx_wake_queue(struct efx_channel *channel);
-#define EFX_TXQ_SIZE 1024
-#define EFX_TXQ_MASK (EFX_TXQ_SIZE - 1)
 /* RX */
 extern int efx_probe_rx_queue(struct efx_rx_queue *rx_queue);
@@ -53,23 +52,56 @@ extern void __efx_rx_packet(struct efx_channel *channel,
 extern void efx_rx_packet(struct efx_rx_queue *rx_queue, unsigned int index,
                          unsigned int len, bool checksummed, bool discard);
 extern void efx_schedule_slow_fill(struct efx_rx_queue *rx_queue);
-#define EFX_RXQ_SIZE 1024
-#define EFX_RXQ_MASK (EFX_RXQ_SIZE - 1)
+#define EFX_MAX_DMAQ_SIZE 4096UL
+#define EFX_DEFAULT_DMAQ_SIZE 1024UL
+#define EFX_MIN_DMAQ_SIZE 512UL
+#define EFX_MAX_EVQ_SIZE 16384UL
+#define EFX_MIN_EVQ_SIZE 512UL
+/* The smallest [rt]xq_entries that the driver supports. Callers of
+ * efx_wake_queue() assume that they can subsequently send at least one
+ * skb. Falcon/A1 may require up to three descriptors per skb_frag. */
+#define EFX_MIN_RING_SIZE (roundup_pow_of_two(2 * 3 * MAX_SKB_FRAGS))
+/* Filters */
+extern int efx_probe_filters(struct efx_nic *efx);
+extern void efx_restore_filters(struct efx_nic *efx);
+extern void efx_remove_filters(struct efx_nic *efx);
+extern int efx_filter_insert_filter(struct efx_nic *efx,
+                                    struct efx_filter_spec *spec,
+                                    bool replace);
+extern int efx_filter_remove_filter(struct efx_nic *efx,
+                                    struct efx_filter_spec *spec);
+extern void efx_filter_clear_rx(struct efx_nic *efx,
+                                enum efx_filter_priority priority);
+#ifdef CONFIG_RFS_ACCEL
+extern int efx_filter_rfs(struct net_device *net_dev, const struct sk_buff *skb,
+                          u16 rxq_index, u32 flow_id);
+extern bool __efx_filter_rfs_expire(struct efx_nic *efx, unsigned quota);
+static inline void efx_filter_rfs_expire(struct efx_channel *channel)
+{
+        if (channel->rfs_filters_added >= 60 &&
+            __efx_filter_rfs_expire(channel->efx, 100))
+                channel->rfs_filters_added -= 60;
+}
+#define efx_filter_rfs_enabled() 1
+#else
+static inline void efx_filter_rfs_expire(struct efx_channel *channel) {}
+#define efx_filter_rfs_enabled() 0
+#endif
 /* Channels */
 extern void efx_process_channel_now(struct efx_channel *channel);
-#define EFX_EVQ_SIZE 4096
+extern int
-#define EFX_EVQ_MASK (EFX_EVQ_SIZE - 1)
+efx_realloc_channels(struct efx_nic *efx, u32 rxq_entries, u32 txq_entries);
 /* Ports */
 extern int efx_reconfigure_port(struct efx_nic *efx);
 extern int __efx_reconfigure_port(struct efx_nic *efx);
 /* Ethtool support */
-extern int efx_ethtool_get_settings(struct net_device *net_dev,
-                                    struct ethtool_cmd *ecmd);
-extern int efx_ethtool_set_settings(struct net_device *net_dev,
-                                    struct ethtool_cmd *ecmd);
 extern const struct ethtool_ops efx_ethtool_ops;
 /* Reset handling */
@@ -81,15 +113,11 @@ extern int efx_reset_up(struct efx_nic *efx, enum reset_type method, bool ok);
 extern void efx_schedule_reset(struct efx_nic *efx, enum reset_type type);
 extern void efx_init_irq_moderation(struct efx_nic *efx, int tx_usecs,
                                    int rx_usecs, bool rx_adaptive);
-extern int efx_request_power(struct efx_nic *efx, int mw, const char *name);
-extern void efx_hex_dump(const u8 *, unsigned int, const char *);
 /* Dummy PHY ops for PHY drivers */
 extern int efx_port_dummy_op_int(struct efx_nic *efx);
 extern void efx_port_dummy_op_void(struct efx_nic *efx);
-extern void
-efx_port_dummy_op_set_id_led(struct efx_nic *efx, enum efx_led_mode mode);
-extern bool efx_port_dummy_op_poll(struct efx_nic *efx);
 /* MTD */
 #ifdef CONFIG_SFC_MTD
@@ -102,8 +130,6 @@ static inline void efx_mtd_rename(struct efx_nic *efx) {}
 static inline void efx_mtd_remove(struct efx_nic *efx) {}
 #endif
-extern unsigned int efx_monitor_interval;
 static inline void efx_schedule_channel(struct efx_channel *channel)
 {
        netif_vdbg(channel->efx, intr, channel->efx->net_dev,
@@ -116,6 +142,6 @@ static inline void efx_schedule_channel(struct efx_channel *channel)
 extern void efx_link_status_changed(struct efx_nic *efx);
 extern void efx_link_set_advertising(struct efx_nic *efx, u32);
-extern void efx_link_set_wanted_fc(struct efx_nic *efx, enum efx_fc_type);
+extern void efx_link_set_wanted_fc(struct efx_nic *efx, u8);
 #endif /* EFX_EFX_H */
diff --git a/drivers/net/sfc/ethtool.c b/drivers/net/sfc/ethtool.c
index fd19d6ab97a2..d229027dc363 100644
--- a/drivers/net/sfc/ethtool.c
+++ b/drivers/net/sfc/ethtool.c
@@ -1,7 +1,7 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
 * Copyright 2005-2006 Fen Systems Ltd.
- * Copyright 2006-2009 Solarflare Communications Inc.
+ * Copyright 2006-2010 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -11,13 +11,13 @@
 #include <linux/netdevice.h>
 #include <linux/ethtool.h>
 #include <linux/rtnetlink.h>
+#include <linux/in.h>
 #include "net_driver.h"
 #include "workarounds.h"
 #include "selftest.h"
 #include "efx.h"
+#include "filter.h"
 #include "nic.h"
-#include "spi.h"
-#include "mdio_10g.h"
 struct ethtool_string {
        char name[ETH_GSTRING_LEN];
@@ -28,7 +28,8 @@ struct efx_ethtool_stat {
        enum {
                EFX_ETHTOOL_STAT_SOURCE_mac_stats,
                EFX_ETHTOOL_STAT_SOURCE_nic,
-                EFX_ETHTOOL_STAT_SOURCE_channel
+                EFX_ETHTOOL_STAT_SOURCE_channel,
+                EFX_ETHTOOL_STAT_SOURCE_tx_queue
        } source;
        unsigned offset;
        u64(*get_stat) (void *field); /* Reader function */
@@ -86,6 +87,10 @@ static u64 efx_get_atomic_stat(void *field)
        EFX_ETHTOOL_STAT(field, channel, n_##field,             \
                         unsigned int, efx_get_uint_stat)
+#define EFX_ETHTOOL_UINT_TXQ_STAT(field)                        \
+        EFX_ETHTOOL_STAT(tx_##field, tx_queue, field,           \
+                         unsigned int, efx_get_uint_stat)
 static struct efx_ethtool_stat efx_ethtool_stats[] = {
        EFX_ETHTOOL_U64_MAC_STAT(tx_bytes),
        EFX_ETHTOOL_U64_MAC_STAT(tx_good_bytes),
@@ -116,6 +121,10 @@ static struct efx_ethtool_stat efx_ethtool_stats[] = {
        EFX_ETHTOOL_ULONG_MAC_STAT(tx_non_tcpudp),
        EFX_ETHTOOL_ULONG_MAC_STAT(tx_mac_src_error),
        EFX_ETHTOOL_ULONG_MAC_STAT(tx_ip_src_error),
+        EFX_ETHTOOL_UINT_TXQ_STAT(tso_bursts),
+        EFX_ETHTOOL_UINT_TXQ_STAT(tso_long_headers),
+        EFX_ETHTOOL_UINT_TXQ_STAT(tso_packets),
+        EFX_ETHTOOL_UINT_TXQ_STAT(pushes),
        EFX_ETHTOOL_U64_MAC_STAT(rx_bytes),
        EFX_ETHTOOL_U64_MAC_STAT(rx_good_bytes),
        EFX_ETHTOOL_U64_MAC_STAT(rx_bad_bytes),
@@ -169,25 +178,33 @@ static struct efx_ethtool_stat efx_ethtool_stats[] = {
 */
 /* Identify device by flashing LEDs */
-static int efx_ethtool_phys_id(struct net_device *net_dev, u32 count)
+static int efx_ethtool_phys_id(struct net_device *net_dev,
+                               enum ethtool_phys_id_state state)
 {
        struct efx_nic *efx = netdev_priv(net_dev);
+        enum efx_led_mode mode = EFX_LED_DEFAULT;
-        do {
+        switch (state) {
-                efx->type->set_id_led(efx, EFX_LED_ON);
+        case ETHTOOL_ID_ON:
-                schedule_timeout_interruptible(HZ / 2);
+                mode = EFX_LED_ON;
+                break;
-                efx->type->set_id_led(efx, EFX_LED_OFF);
+        case ETHTOOL_ID_OFF:
-                schedule_timeout_interruptible(HZ / 2);
+                mode = EFX_LED_OFF;
-        } while (!signal_pending(current) && --count != 0);
+                break;
+        case ETHTOOL_ID_INACTIVE:
+                mode = EFX_LED_DEFAULT;
+                break;
+        case ETHTOOL_ID_ACTIVE:
+                return 1;       /* cycle on/off once per second */
+        }
-        efx->type->set_id_led(efx, EFX_LED_DEFAULT);
+        efx->type->set_id_led(efx, mode);
        return 0;
 }
 /* This must be called with rtnl_lock held. */
-int efx_ethtool_get_settings(struct net_device *net_dev,
+static int efx_ethtool_get_settings(struct net_device *net_dev,
-                             struct ethtool_cmd *ecmd)
+                                    struct ethtool_cmd *ecmd)
 {
        struct efx_nic *efx = netdev_priv(net_dev);
        struct efx_link_state *link_state = &efx->link_state;
@@ -202,7 +219,7 @@ int efx_ethtool_get_settings(struct net_device *net_dev,
        ecmd->supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
        if (LOOPBACK_INTERNAL(efx)) {
-                ecmd->speed = link_state->speed;
+                ethtool_cmd_speed_set(ecmd, link_state->speed);
                ecmd->duplex = link_state->fd ? DUPLEX_FULL : DUPLEX_HALF;
        }
@@ -210,14 +227,15 @@ int efx_ethtool_get_settings(struct net_device *net_dev,
 }
 /* This must be called with rtnl_lock held. */
-int efx_ethtool_set_settings(struct net_device *net_dev,
+static int efx_ethtool_set_settings(struct net_device *net_dev,
-                             struct ethtool_cmd *ecmd)
+                                    struct ethtool_cmd *ecmd)
 {
        struct efx_nic *efx = netdev_priv(net_dev);
        int rc;
        /* GMAC does not support 1000Mbps HD */
-        if (ecmd->speed == SPEED_1000 && ecmd->duplex != DUPLEX_FULL) {
+        if ((ethtool_cmd_speed(ecmd) == SPEED_1000) &&
+            (ecmd->duplex != DUPLEX_FULL)) {
                netif_dbg(efx, drv, efx->net_dev,
                          "rejecting unsupported 1000Mbps HD setting\n");
                return -EINVAL;
@@ -237,8 +255,8 @@ static void efx_ethtool_get_drvinfo(struct net_device *net_dev,
        strlcpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
        strlcpy(info->version, EFX_DRIVER_VERSION, sizeof(info->version));
        if (efx_nic_rev(efx) >= EFX_REV_SIENA_A0)
-                siena_print_fwver(efx, info->fw_version,
+                efx_mcdi_print_fwver(efx, info->fw_version,
-                                  sizeof(info->fw_version));
+                                     sizeof(info->fw_version));
        strlcpy(info->bus_info, pci_name(efx->pci_dev), sizeof(info->bus_info));
 }
@@ -328,9 +346,10 @@ static int efx_fill_loopback_test(struct efx_nic *efx,
                                  unsigned int test_index,
                                  struct ethtool_string *strings, u64 *data)
 {
+        struct efx_channel *channel = efx_get_channel(efx, 0);
        struct efx_tx_queue *tx_queue;
-        efx_for_each_channel_tx_queue(tx_queue, &efx->channel[0]) {
+        efx_for_each_channel_tx_queue(tx_queue, channel) {
                efx_fill_test(test_index++, strings, data,
                              &lb_tests->tx_sent[tx_queue->queue],
                              EFX_TX_QUEUE_NAME(tx_queue),
@@ -469,6 +488,7 @@ static void efx_ethtool_get_stats(struct net_device *net_dev,
        struct efx_mac_stats *mac_stats = &efx->mac_stats;
        struct efx_ethtool_stat *stat;
        struct efx_channel *channel;
+        struct efx_tx_queue *tx_queue;
        struct rtnl_link_stats64 temp;
        int i;
@@ -494,74 +514,31 @@ static void efx_ethtool_get_stats(struct net_device *net_dev,
                                data[i] += stat->get_stat((void *)channel +
                                                          stat->offset);
                        break;
+                case EFX_ETHTOOL_STAT_SOURCE_tx_queue:
+                        data[i] = 0;
+                        efx_for_each_channel(channel, efx) {
+                                efx_for_each_channel_tx_queue(tx_queue, channel)
+                                        data[i] +=
+                                                stat->get_stat((void *)tx_queue
+                                                               + stat->offset);
+                        }
+                        break;
                }
        }
 }
-static int efx_ethtool_set_tso(struct net_device *net_dev, u32 enable)
-{
-        struct efx_nic *efx __attribute__ ((unused)) = netdev_priv(net_dev);
-        unsigned long features;
-        features = NETIF_F_TSO;
-        if (efx->type->offload_features & NETIF_F_V6_CSUM)
-                features |= NETIF_F_TSO6;
-        if (enable)
-                net_dev->features |= features;
-        else
-                net_dev->features &= ~features;
-        return 0;
-}
-static int efx_ethtool_set_tx_csum(struct net_device *net_dev, u32 enable)
-{
-        struct efx_nic *efx = netdev_priv(net_dev);
-        unsigned long features = efx->type->offload_features & NETIF_F_ALL_CSUM;
-        if (enable)
-                net_dev->features |= features;
-        else
-                net_dev->features &= ~features;
-        return 0;
-}
-static int efx_ethtool_set_rx_csum(struct net_device *net_dev, u32 enable)
-{
-        struct efx_nic *efx = netdev_priv(net_dev);
-        /* No way to stop the hardware doing the checks; we just
-         * ignore the result.
-         */
-        efx->rx_checksum_enabled = !!enable;
-        return 0;
-}
-static u32 efx_ethtool_get_rx_csum(struct net_device *net_dev)
-{
-        struct efx_nic *efx = netdev_priv(net_dev);
-        return efx->rx_checksum_enabled;
-}
-static int efx_ethtool_set_flags(struct net_device *net_dev, u32 data)
-{
-        struct efx_nic *efx = netdev_priv(net_dev);
-        u32 supported = efx->type->offload_features & ETH_FLAG_RXHASH;
-        return ethtool_op_set_flags(net_dev, data, supported);
-}
 static void efx_ethtool_self_test(struct net_device *net_dev,
                                  struct ethtool_test *test, u64 *data)
 {
        struct efx_nic *efx = netdev_priv(net_dev);
-        struct efx_self_tests efx_tests;
+        struct efx_self_tests *efx_tests;
        int already_up;
-        int rc;
+        int rc = -ENOMEM;
+        efx_tests = kzalloc(sizeof(*efx_tests), GFP_KERNEL);
+        if (!efx_tests)
+                goto fail;
        ASSERT_RTNL();
        if (efx->state != STATE_RUNNING) {
@@ -569,6 +546,9 @@ static void efx_ethtool_self_test(struct net_device *net_dev,
                goto fail1;
        }
+        netif_info(efx, drv, efx->net_dev, "starting %sline testing\n",
+                   (test->flags & ETH_TEST_FL_OFFLINE) ? "off" : "on");
        /* We need rx buffers and interrupts. */
        already_up = (efx->net_dev->flags & IFF_UP);
        if (!already_up) {
@@ -576,25 +556,24 @@ static void efx_ethtool_self_test(struct net_device *net_dev,
                if (rc) {
                        netif_err(efx, drv, efx->net_dev,
                                  "failed opening device.\n");
-                        goto fail2;
+                        goto fail1;
                }
        }
-        memset(&efx_tests, 0, sizeof(efx_tests));
+        rc = efx_selftest(efx, efx_tests, test->flags);
-        rc = efx_selftest(efx, &efx_tests, test->flags);
        if (!already_up)
                dev_close(efx->net_dev);
-        netif_dbg(efx, drv, efx->net_dev, "%s %sline self-tests\n",
+        netif_info(efx, drv, efx->net_dev, "%s %sline self-tests\n",
-                  rc == 0 ? "passed" : "failed",
+                   rc == 0 ? "passed" : "failed",
-                  (test->flags & ETH_TEST_FL_OFFLINE) ? "off" : "on");
+                   (test->flags & ETH_TEST_FL_OFFLINE) ? "off" : "on");
- fail2:
+fail1:
- fail1:
        /* Fill ethtool results structures */
-        efx_ethtool_fill_self_tests(efx, &efx_tests, NULL, data);
+        efx_ethtool_fill_self_tests(efx, efx_tests, NULL, data);
+        kfree(efx_tests);
+fail:
        if (rc)
                test->flags |= ETH_TEST_FL_FAILED;
 }
@@ -607,81 +586,19 @@ static int efx_ethtool_nway_reset(struct net_device *net_dev)
        return mdio45_nway_restart(&efx->mdio);
 }
-static u32 efx_ethtool_get_link(struct net_device *net_dev)
-{
-        struct efx_nic *efx = netdev_priv(net_dev);
-        return efx->link_state.up;
-}
-static int efx_ethtool_get_eeprom_len(struct net_device *net_dev)
-{
-        struct efx_nic *efx = netdev_priv(net_dev);
-        struct efx_spi_device *spi = efx->spi_eeprom;
-        if (!spi)
-                return 0;
-        return min(spi->size, EFX_EEPROM_BOOTCONFIG_END) -
-                min(spi->size, EFX_EEPROM_BOOTCONFIG_START);
-}
-static int efx_ethtool_get_eeprom(struct net_device *net_dev,
-                                  struct ethtool_eeprom *eeprom, u8 *buf)
-{
-        struct efx_nic *efx = netdev_priv(net_dev);
-        struct efx_spi_device *spi = efx->spi_eeprom;
-        size_t len;
-        int rc;
-        rc = mutex_lock_interruptible(&efx->spi_lock);
-        if (rc)
-                return rc;
-        rc = falcon_spi_read(efx, spi,
-                             eeprom->offset + EFX_EEPROM_BOOTCONFIG_START,
-                             eeprom->len, &len, buf);
-        mutex_unlock(&efx->spi_lock);
-        eeprom->magic = EFX_ETHTOOL_EEPROM_MAGIC;
-        eeprom->len = len;
-        return rc;
-}
-static int efx_ethtool_set_eeprom(struct net_device *net_dev,
-                                  struct ethtool_eeprom *eeprom, u8 *buf)
-{
-        struct efx_nic *efx = netdev_priv(net_dev);
-        struct efx_spi_device *spi = efx->spi_eeprom;
-        size_t len;
-        int rc;
-        if (eeprom->magic != EFX_ETHTOOL_EEPROM_MAGIC)
-                return -EINVAL;
-        rc = mutex_lock_interruptible(&efx->spi_lock);
-        if (rc)
-                return rc;
-        rc = falcon_spi_write(efx, spi,
-                              eeprom->offset + EFX_EEPROM_BOOTCONFIG_START,
-                              eeprom->len, &len, buf);
-        mutex_unlock(&efx->spi_lock);
-        eeprom->len = len;
-        return rc;
-}
 static int efx_ethtool_get_coalesce(struct net_device *net_dev,
                                    struct ethtool_coalesce *coalesce)
 {
        struct efx_nic *efx = netdev_priv(net_dev);
-        struct efx_tx_queue *tx_queue;
        struct efx_channel *channel;
        memset(coalesce, 0, sizeof(*coalesce));
        /* Find lowest IRQ moderation across all used TX queues */
        coalesce->tx_coalesce_usecs_irq = ~((u32) 0);
-        efx_for_each_tx_queue(tx_queue, efx) {
+        efx_for_each_channel(channel, efx) {
-                channel = tx_queue->channel;
+                if (!efx_channel_has_tx_queues(channel))
+                        continue;
                if (channel->irq_moderation < coalesce->tx_coalesce_usecs_irq) {
                        if (channel->channel < efx->n_rx_channels)
                                coalesce->tx_coalesce_usecs_irq =
@@ -708,7 +625,6 @@ static int efx_ethtool_set_coalesce(struct net_device *net_dev,
 {
        struct efx_nic *efx = netdev_priv(net_dev);
        struct efx_channel *channel;
-        struct efx_tx_queue *tx_queue;
        unsigned tx_usecs, rx_usecs, adaptive;
        if (coalesce->use_adaptive_tx_coalesce)
@@ -725,8 +641,9 @@ static int efx_ethtool_set_coalesce(struct net_device *net_dev,
        adaptive = coalesce->use_adaptive_rx_coalesce;
        /* If the channel is shared only allow RX parameters to be set */
-        efx_for_each_tx_queue(tx_queue, efx) {
+        efx_for_each_channel(channel, efx) {
-                if ((tx_queue->channel->channel < efx->n_rx_channels) &&
+                if (efx_channel_has_rx_queue(channel) &&
+                    efx_channel_has_tx_queues(channel) &&
                    tx_usecs) {
                        netif_err(efx, drv, efx->net_dev, "Channel is shared. "
                                  "Only RX coalescing may be set\n");
@@ -741,11 +658,47 @@ static int efx_ethtool_set_coalesce(struct net_device *net_dev,
        return 0;
 }
+static void efx_ethtool_get_ringparam(struct net_device *net_dev,
+                                      struct ethtool_ringparam *ring)
+{
+        struct efx_nic *efx = netdev_priv(net_dev);
+        ring->rx_max_pending = EFX_MAX_DMAQ_SIZE;
+        ring->tx_max_pending = EFX_MAX_DMAQ_SIZE;
+        ring->rx_mini_max_pending = 0;
+        ring->rx_jumbo_max_pending = 0;
+        ring->rx_pending = efx->rxq_entries;
+        ring->tx_pending = efx->txq_entries;
+        ring->rx_mini_pending = 0;
+        ring->rx_jumbo_pending = 0;
+}
+static int efx_ethtool_set_ringparam(struct net_device *net_dev,
+                                     struct ethtool_ringparam *ring)
+{
+        struct efx_nic *efx = netdev_priv(net_dev);
+        if (ring->rx_mini_pending || ring->rx_jumbo_pending ||
+            ring->rx_pending > EFX_MAX_DMAQ_SIZE ||
+            ring->tx_pending > EFX_MAX_DMAQ_SIZE)
+                return -EINVAL;
+        if (ring->rx_pending < EFX_MIN_RING_SIZE ||
+            ring->tx_pending < EFX_MIN_RING_SIZE) {
+                netif_err(efx, drv, efx->net_dev,
+                          "TX and RX queues cannot be smaller than %ld\n",
+                          EFX_MIN_RING_SIZE);
+                return -EINVAL;
+        }
+        return efx_realloc_channels(efx, ring->rx_pending, ring->tx_pending);
+}
 static int efx_ethtool_set_pauseparam(struct net_device *net_dev,
                                      struct ethtool_pauseparam *pause)
 {
        struct efx_nic *efx = netdev_priv(net_dev);
-        enum efx_fc_type wanted_fc, old_fc;
+        u8 wanted_fc, old_fc;
        u32 old_adv;
        bool reset;
        int rc = 0;
@@ -840,7 +793,7 @@ static int efx_ethtool_set_wol(struct net_device *net_dev,
        return efx->type->set_wol(efx, wol->wolopts);
 }
-extern int efx_ethtool_reset(struct net_device *net_dev, u32 *flags)
+static int efx_ethtool_reset(struct net_device *net_dev, u32 *flags)
 {
        struct efx_nic *efx = netdev_priv(net_dev);
        enum reset_type method;
@@ -918,6 +871,95 @@ efx_ethtool_get_rxnfc(struct net_device *net_dev,
        }
 }
+static int efx_ethtool_set_rx_ntuple(struct net_device *net_dev,
+                                     struct ethtool_rx_ntuple *ntuple)
+{
+        struct efx_nic *efx = netdev_priv(net_dev);
+        struct ethtool_tcpip4_spec *ip_entry = &ntuple->fs.h_u.tcp_ip4_spec;
+        struct ethtool_tcpip4_spec *ip_mask = &ntuple->fs.m_u.tcp_ip4_spec;
+        struct ethhdr *mac_entry = &ntuple->fs.h_u.ether_spec;
+        struct ethhdr *mac_mask = &ntuple->fs.m_u.ether_spec;
+        struct efx_filter_spec filter;
+        int rc;
+        /* Range-check action */
+        if (ntuple->fs.action < ETHTOOL_RXNTUPLE_ACTION_CLEAR ||
+            ntuple->fs.action >= (s32)efx->n_rx_channels)
+                return -EINVAL;
+        if (~ntuple->fs.data_mask)
+                return -EINVAL;
+        efx_filter_init_rx(&filter, EFX_FILTER_PRI_MANUAL, 0,
+                           (ntuple->fs.action == ETHTOOL_RXNTUPLE_ACTION_DROP) ?
+                           0xfff : ntuple->fs.action);
+        switch (ntuple->fs.flow_type) {
+        case TCP_V4_FLOW:
+        case UDP_V4_FLOW: {
+                u8 proto = (ntuple->fs.flow_type == TCP_V4_FLOW ?
+                            IPPROTO_TCP : IPPROTO_UDP);
+                /* Must match all of destination, */
+                if (ip_mask->ip4dst | ip_mask->pdst)
+                        return -EINVAL;
+                /* all or none of source, */
+                if ((ip_mask->ip4src | ip_mask->psrc) &&
+                    ((__force u32)~ip_mask->ip4src |
+                     (__force u16)~ip_mask->psrc))
+                        return -EINVAL;
+                /* and nothing else */
+                if ((u8)~ip_mask->tos | (u16)~ntuple->fs.vlan_tag_mask)
+                        return -EINVAL;
+                if (!ip_mask->ip4src)
+                        rc = efx_filter_set_ipv4_full(&filter, proto,
+                                                      ip_entry->ip4dst,
+                                                      ip_entry->pdst,
+                                                      ip_entry->ip4src,
+                                                      ip_entry->psrc);
+                else
+                        rc = efx_filter_set_ipv4_local(&filter, proto,
+                                                       ip_entry->ip4dst,
+                                                       ip_entry->pdst);
+                if (rc)
+                        return rc;
+                break;
+        }
+        case ETHER_FLOW:
+                /* Must match all of destination, */
+                if (!is_zero_ether_addr(mac_mask->h_dest))
+                        return -EINVAL;
+                /* all or none of VID, */
+                if (ntuple->fs.vlan_tag_mask != 0xf000 &&
+                    ntuple->fs.vlan_tag_mask != 0xffff)
+                        return -EINVAL;
+                /* and nothing else */
+                if (!is_broadcast_ether_addr(mac_mask->h_source) ||
+                    mac_mask->h_proto != htons(0xffff))
+                        return -EINVAL;
+                rc = efx_filter_set_eth_local(
+                        &filter,
+                        (ntuple->fs.vlan_tag_mask == 0xf000) ?
+                        ntuple->fs.vlan_tag : EFX_FILTER_VID_UNSPEC,
+                        mac_entry->h_dest);
+                if (rc)
+                        return rc;
+                break;
+        default:
+                return -EINVAL;
+        }
+        if (ntuple->fs.action == ETHTOOL_RXNTUPLE_ACTION_CLEAR)
+                return efx_filter_remove_filter(efx, &filter);
+        rc = efx_filter_insert_filter(efx, &filter, true);
+        return rc < 0 ? rc : 0;
+}
 static int efx_ethtool_get_rxfh_indir(struct net_device *net_dev,
                                      struct ethtool_rxfh_indir *indir)
 {
@@ -965,35 +1007,23 @@ const struct ethtool_ops efx_ethtool_ops = {
        .get_msglevel           = efx_ethtool_get_msglevel,
        .set_msglevel           = efx_ethtool_set_msglevel,
        .nway_reset             = efx_ethtool_nway_reset,
-        .get_link               = efx_ethtool_get_link,
+        .get_link               = ethtool_op_get_link,
-        .get_eeprom_len         = efx_ethtool_get_eeprom_len,
-        .get_eeprom             = efx_ethtool_get_eeprom,
-        .set_eeprom             = efx_ethtool_set_eeprom,
        .get_coalesce           = efx_ethtool_get_coalesce,
        .set_coalesce           = efx_ethtool_set_coalesce,
+        .get_ringparam          = efx_ethtool_get_ringparam,
+        .set_ringparam          = efx_ethtool_set_ringparam,
        .get_pauseparam         = efx_ethtool_get_pauseparam,
        .set_pauseparam         = efx_ethtool_set_pauseparam,
-        .get_rx_csum            = efx_ethtool_get_rx_csum,
-        .set_rx_csum            = efx_ethtool_set_rx_csum,
-        .get_tx_csum            = ethtool_op_get_tx_csum,
-        /* Need to enable/disable IPv6 too */
-        .set_tx_csum            = efx_ethtool_set_tx_csum,
-        .get_sg                 = ethtool_op_get_sg,
-        .set_sg                 = ethtool_op_set_sg,
-        .get_tso                = ethtool_op_get_tso,
-        /* Need to enable/disable TSO-IPv6 too */
-        .set_tso                = efx_ethtool_set_tso,
-        .get_flags              = ethtool_op_get_flags,
-        .set_flags              = efx_ethtool_set_flags,
        .get_sset_count         = efx_ethtool_get_sset_count,
        .self_test              = efx_ethtool_self_test,
        .get_strings            = efx_ethtool_get_strings,
-        .phys_id                = efx_ethtool_phys_id,
+        .set_phys_id            = efx_ethtool_phys_id,
        .get_ethtool_stats      = efx_ethtool_get_stats,
        .get_wol                = efx_ethtool_get_wol,
        .set_wol                = efx_ethtool_set_wol,
        .reset                  = efx_ethtool_reset,
        .get_rxnfc              = efx_ethtool_get_rxnfc,
+        .set_rx_ntuple          = efx_ethtool_set_rx_ntuple,
        .get_rxfh_indir         = efx_ethtool_get_rxfh_indir,
        .set_rxfh_indir         = efx_ethtool_set_rxfh_indir,
 };
diff --git a/drivers/net/sfc/falcon.c b/drivers/net/sfc/falcon.c
index 4f9d33f3cca1..60176e873d62 100644
--- a/drivers/net/sfc/falcon.c
+++ b/drivers/net/sfc/falcon.c
@@ -1,7 +1,7 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
 * Copyright 2005-2006 Fen Systems Ltd.
- * Copyright 2006-2009 Solarflare Communications Inc.
+ * Copyright 2006-2010 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -24,7 +24,6 @@
 #include "nic.h"
 #include "regs.h"
 #include "io.h"
-#include "mdio_10g.h"
 #include "phy.h"
 #include "workarounds.h"
@@ -159,7 +158,6 @@ irqreturn_t falcon_legacy_interrupt_a1(int irq, void *dev_id)
 {
        struct efx_nic *efx = dev_id;
        efx_oword_t *int_ker = efx->irq_status.addr;
-        struct efx_channel *channel;
        int syserr;
        int queues;
@@ -194,15 +192,10 @@ irqreturn_t falcon_legacy_interrupt_a1(int irq, void *dev_id)
        wmb(); /* Ensure the vector is cleared before interrupt ack */
        falcon_irq_ack_a1(efx);
-        /* Schedule processing of any interrupting queues */
+        if (queues & 1)
-        channel = &efx->channel[0];
+                efx_schedule_channel(efx_get_channel(efx, 0));
-        while (queues) {
+        if (queues & 2)
-                if (queues & 0x01)
+                efx_schedule_channel(efx_get_channel(efx, 1));
-                        efx_schedule_channel(channel);
-                channel++;
-                queues >>= 1;
-        }
        return IRQ_HANDLED;
 }
 /**************************************************************************
@@ -261,7 +254,6 @@ int falcon_spi_cmd(struct efx_nic *efx, const struct efx_spi_device *spi,
        /* Input validation */
        if (len > FALCON_SPI_MAX_LEN)
                return -EINVAL;
-        BUG_ON(!mutex_is_locked(&efx->spi_lock));
        /* Check that previous command is not still running */
        rc = falcon_spi_poll(efx);
@@ -452,30 +444,19 @@ static void falcon_reset_macs(struct efx_nic *efx)
                /* It's not safe to use GLB_CTL_REG to reset the
                 * macs, so instead use the internal MAC resets
                 */
-                if (!EFX_IS10G(efx)) {
+                EFX_POPULATE_OWORD_1(reg, FRF_AB_XM_CORE_RST, 1);
-                        EFX_POPULATE_OWORD_1(reg, FRF_AB_GM_SW_RST, 1);
+                efx_writeo(efx, &reg, FR_AB_XM_GLB_CFG);
-                        efx_writeo(efx, &reg, FR_AB_GM_CFG1);
-                        udelay(1000);
+                for (count = 0; count < 10000; count++) {
+                        efx_reado(efx, &reg, FR_AB_XM_GLB_CFG);
-                        EFX_POPULATE_OWORD_1(reg, FRF_AB_GM_SW_RST, 0);
+                        if (EFX_OWORD_FIELD(reg, FRF_AB_XM_CORE_RST) ==
-                        efx_writeo(efx, &reg, FR_AB_GM_CFG1);
+                            0)
-                        udelay(1000);
+                                return;
-                        return;
+                        udelay(10);
-                } else {
-                        EFX_POPULATE_OWORD_1(reg, FRF_AB_XM_CORE_RST, 1);
-                        efx_writeo(efx, &reg, FR_AB_XM_GLB_CFG);
-                        for (count = 0; count < 10000; count++) {
-                                efx_reado(efx, &reg, FR_AB_XM_GLB_CFG);
-                                if (EFX_OWORD_FIELD(reg, FRF_AB_XM_CORE_RST) ==
-                                    0)
-                                        return;
-                                udelay(10);
-                        }
-                        netif_err(efx, hw, efx->net_dev,
-                                  "timed out waiting for XMAC core reset\n");
                }
+                netif_err(efx, hw, efx->net_dev,
+                          "timed out waiting for XMAC core reset\n");
        }
        /* Mac stats will fail whist the TX fifo is draining */
@@ -514,7 +495,6 @@ static void falcon_reset_macs(struct efx_nic *efx)
         * are re-enabled by the caller */
        efx_writeo(efx, &mac_ctrl, FR_AB_MAC_CTRL);
-        /* This can run even when the GMAC is selected */
        falcon_setup_xaui(efx);
 }
@@ -652,8 +632,6 @@ static void falcon_stats_timer_func(unsigned long context)
        spin_unlock(&efx->stats_lock);
 }
-static void falcon_switch_mac(struct efx_nic *efx);
 static bool falcon_loopback_link_poll(struct efx_nic *efx)
 {
        struct efx_link_state old_state = efx->link_state;
@@ -664,11 +642,7 @@ static bool falcon_loopback_link_poll(struct efx_nic *efx)
        efx->link_state.fd = true;
        efx->link_state.fc = efx->wanted_fc;
        efx->link_state.up = true;
+        efx->link_state.speed = 10000;
-        if (efx->loopback_mode == LOOPBACK_GMAC)
-                efx->link_state.speed = 1000;
-        else
-                efx->link_state.speed = 10000;
        return !efx_link_state_equal(&efx->link_state, &old_state);
 }
@@ -691,7 +665,7 @@ static int falcon_reconfigure_port(struct efx_nic *efx)
        falcon_stop_nic_stats(efx);
        falcon_deconfigure_mac_wrapper(efx);
-        falcon_switch_mac(efx);
+        falcon_reset_macs(efx);
        efx->phy_op->reconfigure(efx);
        rc = efx->mac_op->reconfigure(efx);
@@ -718,7 +692,7 @@ static int falcon_gmii_wait(struct efx_nic *efx)
        efx_oword_t md_stat;
        int count;
-        /* wait upto 50ms - taken max from datasheet */
+        /* wait up to 50ms - taken max from datasheet */
        for (count = 0; count < 5000; count++) {
                efx_reado(efx, &md_stat, FR_AB_MD_STAT);
                if (EFX_OWORD_FIELD(md_stat, FRF_AB_MD_BSY) == 0) {
@@ -743,6 +717,7 @@ static int falcon_mdio_write(struct net_device *net_dev,
                             int prtad, int devad, u16 addr, u16 value)
 {
        struct efx_nic *efx = netdev_priv(net_dev);
+        struct falcon_nic_data *nic_data = efx->nic_data;
        efx_oword_t reg;
        int rc;
@@ -750,7 +725,7 @@ static int falcon_mdio_write(struct net_device *net_dev,
                   "writing MDIO %d register %d.%d with 0x%04x\n",
                    prtad, devad, addr, value);
-        mutex_lock(&efx->mdio_lock);
+        mutex_lock(&nic_data->mdio_lock);
        /* Check MDIO not currently being accessed */
        rc = falcon_gmii_wait(efx);
@@ -786,7 +761,7 @@ static int falcon_mdio_write(struct net_device *net_dev,
        }
 out:
-        mutex_unlock(&efx->mdio_lock);
+        mutex_unlock(&nic_data->mdio_lock);
        return rc;
 }
@@ -795,10 +770,11 @@ static int falcon_mdio_read(struct net_device *net_dev,
                            int prtad, int devad, u16 addr)
 {
        struct efx_nic *efx = netdev_priv(net_dev);
+        struct falcon_nic_data *nic_data = efx->nic_data;
        efx_oword_t reg;
        int rc;
-        mutex_lock(&efx->mdio_lock);
+        mutex_lock(&nic_data->mdio_lock);
        /* Check MDIO not currently being accessed */
        rc = falcon_gmii_wait(efx);
@@ -837,77 +813,27 @@ static int falcon_mdio_read(struct net_device *net_dev,
        }
 out:
-        mutex_unlock(&efx->mdio_lock);
+        mutex_unlock(&nic_data->mdio_lock);
        return rc;
 }
-static void falcon_clock_mac(struct efx_nic *efx)
-{
-        unsigned strap_val;
-        efx_oword_t nic_stat;
-        /* Configure the NIC generated MAC clock correctly */
-        efx_reado(efx, &nic_stat, FR_AB_NIC_STAT);
-        strap_val = EFX_IS10G(efx) ? 5 : 3;
-        if (efx_nic_rev(efx) >= EFX_REV_FALCON_B0) {
-                EFX_SET_OWORD_FIELD(nic_stat, FRF_BB_EE_STRAP_EN, 1);
-                EFX_SET_OWORD_FIELD(nic_stat, FRF_BB_EE_STRAP, strap_val);
-                efx_writeo(efx, &nic_stat, FR_AB_NIC_STAT);
-        } else {
-                /* Falcon A1 does not support 1G/10G speed switching
-                 * and must not be used with a PHY that does. */
-                BUG_ON(EFX_OWORD_FIELD(nic_stat, FRF_AB_STRAP_PINS) !=
-                       strap_val);
-        }
-}
-static void falcon_switch_mac(struct efx_nic *efx)
-{
-        struct efx_mac_operations *old_mac_op = efx->mac_op;
-        struct falcon_nic_data *nic_data = efx->nic_data;
-        unsigned int stats_done_offset;
-        WARN_ON(!mutex_is_locked(&efx->mac_lock));
-        WARN_ON(nic_data->stats_disable_count == 0);
-        efx->mac_op = (EFX_IS10G(efx) ?
-                       &falcon_xmac_operations : &falcon_gmac_operations);
-        if (EFX_IS10G(efx))
-                stats_done_offset = XgDmaDone_offset;
-        else
-                stats_done_offset = GDmaDone_offset;
-        nic_data->stats_dma_done = efx->stats_buffer.addr + stats_done_offset;
-        if (old_mac_op == efx->mac_op)
-                return;
-        falcon_clock_mac(efx);
-        netif_dbg(efx, hw, efx->net_dev, "selected %cMAC\n",
-                  EFX_IS10G(efx) ? 'X' : 'G');
-        /* Not all macs support a mac-level link state */
-        efx->xmac_poll_required = false;
-        falcon_reset_macs(efx);
-}
 /* This call is responsible for hooking in the MAC and PHY operations */
 static int falcon_probe_port(struct efx_nic *efx)
 {
+        struct falcon_nic_data *nic_data = efx->nic_data;
        int rc;
        switch (efx->phy_type) {
        case PHY_TYPE_SFX7101:
                efx->phy_op = &falcon_sfx7101_phy_ops;
                break;
-        case PHY_TYPE_SFT9001A:
-        case PHY_TYPE_SFT9001B:
-                efx->phy_op = &falcon_sft9001_phy_ops;
-                break;
        case PHY_TYPE_QT2022C2:
        case PHY_TYPE_QT2025C:
                efx->phy_op = &falcon_qt202x_phy_ops;
                break;
+        case PHY_TYPE_TXC43128:
+                efx->phy_op = &falcon_txc_phy_ops;
+                break;
        default:
                netif_err(efx, probe, efx->net_dev, "Unknown PHY type %d\n",
                          efx->phy_type);
@@ -915,6 +841,7 @@ static int falcon_probe_port(struct efx_nic *efx)
        }
        /* Fill out MDIO structure and loopback modes */
+        mutex_init(&nic_data->mdio_lock);
        efx->mdio.mdio_read = falcon_mdio_read;
        efx->mdio.mdio_write = falcon_mdio_write;
        rc = efx->phy_op->probe(efx);
@@ -943,6 +870,7 @@ static int falcon_probe_port(struct efx_nic *efx)
                  (u64)efx->stats_buffer.dma_addr,
                  efx->stats_buffer.addr,
                  (u64)virt_to_phys(efx->stats_buffer.addr));
+        nic_data->stats_dma_done = efx->stats_buffer.addr + XgDmaDone_offset;
        return 0;
 }
@@ -953,6 +881,41 @@ static void falcon_remove_port(struct efx_nic *efx)
        efx_nic_free_buffer(efx, &efx->stats_buffer);
 }
+/* Global events are basically PHY events */
+static bool
+falcon_handle_global_event(struct efx_channel *channel, efx_qword_t *event)
+{
+        struct efx_nic *efx = channel->efx;
+        struct falcon_nic_data *nic_data = efx->nic_data;
+        if (EFX_QWORD_FIELD(*event, FSF_AB_GLB_EV_G_PHY0_INTR) ||
+            EFX_QWORD_FIELD(*event, FSF_AB_GLB_EV_XG_PHY0_INTR) ||
+            EFX_QWORD_FIELD(*event, FSF_AB_GLB_EV_XFP_PHY0_INTR))
+                /* Ignored */
+                return true;
+        if ((efx_nic_rev(efx) == EFX_REV_FALCON_B0) &&
+            EFX_QWORD_FIELD(*event, FSF_BB_GLB_EV_XG_MGT_INTR)) {
+                nic_data->xmac_poll_required = true;
+                return true;
+        }
+        if (efx_nic_rev(efx) <= EFX_REV_FALCON_A1 ?
+            EFX_QWORD_FIELD(*event, FSF_AA_GLB_EV_RX_RECOVERY) :
+            EFX_QWORD_FIELD(*event, FSF_BB_GLB_EV_RX_RECOVERY)) {
+                netif_err(efx, rx_err, efx->net_dev,
+                          "channel %d seen global RX_RESET event. Resetting.\n",
+                          channel->channel);
+                atomic_inc(&efx->rx_reset);
+                efx_schedule_reset(efx, EFX_WORKAROUND_6555(efx) ?
+                                   RESET_TYPE_RX_RECOVERY : RESET_TYPE_DISABLE);
+                return true;
+        }
+        return false;
+}
 /**************************************************************************
 *
 * Falcon test code
@@ -962,6 +925,7 @@ static void falcon_remove_port(struct efx_nic *efx)
 static int
 falcon_read_nvram(struct efx_nic *efx, struct falcon_nvconfig *nvconfig_out)
 {
+        struct falcon_nic_data *nic_data = efx->nic_data;
        struct falcon_nvconfig *nvconfig;
        struct efx_spi_device *spi;
        void *region;
@@ -969,8 +933,11 @@ falcon_read_nvram(struct efx_nic *efx, struct falcon_nvconfig *nvconfig_out)
        __le16 *word, *limit;
        u32 csum;
-        spi = efx->spi_flash ? efx->spi_flash : efx->spi_eeprom;
+        if (efx_spi_present(&nic_data->spi_flash))
-        if (!spi)
+                spi = &nic_data->spi_flash;
+        else if (efx_spi_present(&nic_data->spi_eeprom))
+                spi = &nic_data->spi_eeprom;
+        else
                return -EINVAL;
        region = kmalloc(FALCON_NVCONFIG_END, GFP_KERNEL);
@@ -978,12 +945,13 @@ falcon_read_nvram(struct efx_nic *efx, struct falcon_nvconfig *nvconfig_out)
                return -ENOMEM;
        nvconfig = region + FALCON_NVCONFIG_OFFSET;
-        mutex_lock(&efx->spi_lock);
+        mutex_lock(&nic_data->spi_lock);
        rc = falcon_spi_read(efx, spi, 0, FALCON_NVCONFIG_END, NULL, region);
-        mutex_unlock(&efx->spi_lock);
+        mutex_unlock(&nic_data->spi_lock);
        if (rc) {
                netif_err(efx, hw, efx->net_dev, "Failed to read %s\n",
-                          efx->spi_flash ? "flash" : "EEPROM");
+                          efx_spi_present(&nic_data->spi_flash) ?
+                          "flash" : "EEPROM");
                rc = -EIO;
                goto out;
        }
@@ -1085,7 +1053,7 @@ static int falcon_b0_test_registers(struct efx_nic *efx)
 /* Resets NIC to known state.  This routine must be called in process
 * context and is allowed to sleep. */
-static int falcon_reset_hw(struct efx_nic *efx, enum reset_type method)
+static int __falcon_reset_hw(struct efx_nic *efx, enum reset_type method)
 {
        struct falcon_nic_data *nic_data = efx->nic_data;
        efx_oword_t glb_ctl_reg_ker;
@@ -1139,22 +1107,9 @@ static int falcon_reset_hw(struct efx_nic *efx, enum reset_type method)
        /* Restore PCI configuration if needed */
        if (method == RESET_TYPE_WORLD) {
-                if (efx_nic_is_dual_func(efx)) {
+                if (efx_nic_is_dual_func(efx))
-                        rc = pci_restore_state(nic_data->pci_dev2);
+                        pci_restore_state(nic_data->pci_dev2);
-                        if (rc) {
+                pci_restore_state(efx->pci_dev);
-                                netif_err(efx, drv, efx->net_dev,
-                                          "failed to restore PCI config for "
-                                          "the secondary function\n");
-                                goto fail3;
-                        }
-                }
-                rc = pci_restore_state(efx->pci_dev);
-                if (rc) {
-                        netif_err(efx, drv, efx->net_dev,
-                                  "failed to restore PCI config for the "
-                                  "primary function\n");
-                        goto fail4;
-                }
                netif_dbg(efx, drv, efx->net_dev,
                          "successfully restored PCI config\n");
        }
@@ -1165,7 +1120,7 @@ static int falcon_reset_hw(struct efx_nic *efx, enum reset_type method)
                rc = -ETIMEDOUT;
                netif_err(efx, hw, efx->net_dev,
                          "timed out waiting for hardware reset\n");
-                goto fail5;
+                goto fail3;
        }
        netif_dbg(efx, hw, efx->net_dev, "hardware reset complete\n");
@@ -1173,11 +1128,21 @@ static int falcon_reset_hw(struct efx_nic *efx, enum reset_type method)
        /* pci_save_state() and pci_restore_state() MUST be called in pairs */
 fail2:
-fail3:
        pci_restore_state(efx->pci_dev);
 fail1:
-fail4:
+fail3:
-fail5:
+        return rc;
+}
+static int falcon_reset_hw(struct efx_nic *efx, enum reset_type method)
+{
+        struct falcon_nic_data *nic_data = efx->nic_data;
+        int rc;
+        mutex_lock(&nic_data->spi_lock);
+        rc = __falcon_reset_hw(efx, method);
+        mutex_unlock(&nic_data->spi_lock);
        return rc;
 }
@@ -1207,7 +1172,7 @@ static void falcon_monitor(struct efx_nic *efx)
                falcon_stop_nic_stats(efx);
                falcon_deconfigure_mac_wrapper(efx);
-                falcon_switch_mac(efx);
+                falcon_reset_macs(efx);
                rc = efx->mac_op->reconfigure(efx);
                BUG_ON(rc);
@@ -1216,8 +1181,7 @@ static void falcon_monitor(struct efx_nic *efx)
                efx_link_status_changed(efx);
        }
-        if (EFX_IS10G(efx))
+        falcon_poll_xmac(efx);
-                falcon_poll_xmac(efx);
 }
 /* Zeroes out the SRAM contents.  This routine must be called in
@@ -1257,22 +1221,17 @@ static int falcon_reset_sram(struct efx_nic *efx)
                        return 0;
                }
-        } while (++count < 20); /* wait upto 0.4 sec */
+        } while (++count < 20); /* wait up to 0.4 sec */
        netif_err(efx, hw, efx->net_dev, "timed out waiting for SRAM reset\n");
        return -ETIMEDOUT;
 }
-static int falcon_spi_device_init(struct efx_nic *efx,
+static void falcon_spi_device_init(struct efx_nic *efx,
-                                  struct efx_spi_device **spi_device_ret,
+                                  struct efx_spi_device *spi_device,
                                  unsigned int device_id, u32 device_type)
 {
-        struct efx_spi_device *spi_device;
        if (device_type != 0) {
-                spi_device = kzalloc(sizeof(*spi_device), GFP_KERNEL);
-                if (!spi_device)
-                        return -ENOMEM;
                spi_device->device_id = device_id;
                spi_device->size =
                        1 << SPI_DEV_TYPE_FIELD(device_type, SPI_DEV_TYPE_SIZE);
@@ -1289,27 +1248,15 @@ static int falcon_spi_device_init(struct efx_nic *efx,
                        1 << SPI_DEV_TYPE_FIELD(device_type,
                                                SPI_DEV_TYPE_BLOCK_SIZE);
        } else {
-                spi_device = NULL;
+                spi_device->size = 0;
        }
-        kfree(*spi_device_ret);
-        *spi_device_ret = spi_device;
-        return 0;
-}
-static void falcon_remove_spi_devices(struct efx_nic *efx)
-{
-        kfree(efx->spi_eeprom);
-        efx->spi_eeprom = NULL;
-        kfree(efx->spi_flash);
-        efx->spi_flash = NULL;
 }
 /* Extract non-volatile configuration */
 static int falcon_probe_nvconfig(struct efx_nic *efx)
 {
+        struct falcon_nic_data *nic_data = efx->nic_data;
        struct falcon_nvconfig *nvconfig;
-        int board_rev;
        int rc;
        nvconfig = kmalloc(sizeof(*nvconfig), GFP_KERNEL);
@@ -1317,55 +1264,32 @@ static int falcon_probe_nvconfig(struct efx_nic *efx)
                return -ENOMEM;
        rc = falcon_read_nvram(efx, nvconfig);
-        if (rc == -EINVAL) {
+        if (rc)
-                netif_err(efx, probe, efx->net_dev,
+                goto out;
-                          "NVRAM is invalid therefore using defaults\n");
-                efx->phy_type = PHY_TYPE_NONE;
+        efx->phy_type = nvconfig->board_v2.port0_phy_type;
-                efx->mdio.prtad = MDIO_PRTAD_NONE;
+        efx->mdio.prtad = nvconfig->board_v2.port0_phy_addr;
-                board_rev = 0;
-                rc = 0;
+        if (le16_to_cpu(nvconfig->board_struct_ver) >= 3) {
-        } else if (rc) {
+                falcon_spi_device_init(
-                goto fail1;
+                        efx, &nic_data->spi_flash, FFE_AB_SPI_DEVICE_FLASH,
-        } else {
+                        le32_to_cpu(nvconfig->board_v3
-                struct falcon_nvconfig_board_v2 *v2 = &nvconfig->board_v2;
+                                    .spi_device_type[FFE_AB_SPI_DEVICE_FLASH]));
-                struct falcon_nvconfig_board_v3 *v3 = &nvconfig->board_v3;
+                falcon_spi_device_init(
+                        efx, &nic_data->spi_eeprom, FFE_AB_SPI_DEVICE_EEPROM,
-                efx->phy_type = v2->port0_phy_type;
+                        le32_to_cpu(nvconfig->board_v3
-                efx->mdio.prtad = v2->port0_phy_addr;
+                                    .spi_device_type[FFE_AB_SPI_DEVICE_EEPROM]));
-                board_rev = le16_to_cpu(v2->board_revision);
-                if (le16_to_cpu(nvconfig->board_struct_ver) >= 3) {
-                        rc = falcon_spi_device_init(
-                                efx, &efx->spi_flash, FFE_AB_SPI_DEVICE_FLASH,
-                                le32_to_cpu(v3->spi_device_type
-                                            [FFE_AB_SPI_DEVICE_FLASH]));
-                        if (rc)
-                                goto fail2;
-                        rc = falcon_spi_device_init(
-                                efx, &efx->spi_eeprom, FFE_AB_SPI_DEVICE_EEPROM,
-                                le32_to_cpu(v3->spi_device_type
-                                            [FFE_AB_SPI_DEVICE_EEPROM]));
-                        if (rc)
-                                goto fail2;
-                }
        }
        /* Read the MAC addresses */
-        memcpy(efx->mac_address, nvconfig->mac_address[0], ETH_ALEN);
+        memcpy(efx->net_dev->perm_addr, nvconfig->mac_address[0], ETH_ALEN);
        netif_dbg(efx, probe, efx->net_dev, "PHY is %d phy_id %d\n",
                  efx->phy_type, efx->mdio.prtad);
-        rc = falcon_probe_board(efx, board_rev);
+        rc = falcon_probe_board(efx,
-        if (rc)
+                                le16_to_cpu(nvconfig->board_v2.board_revision));
-                goto fail2;
+out:
-        kfree(nvconfig);
-        return 0;
- fail2:
-        falcon_remove_spi_devices(efx);
- fail1:
        kfree(nvconfig);
        return rc;
 }
@@ -1373,6 +1297,7 @@ static int falcon_probe_nvconfig(struct efx_nic *efx)
 /* Probe all SPI devices on the NIC */
 static void falcon_probe_spi_devices(struct efx_nic *efx)
 {
+        struct falcon_nic_data *nic_data = efx->nic_data;
        efx_oword_t nic_stat, gpio_ctl, ee_vpd_cfg;
        int boot_dev;
@@ -1401,12 +1326,14 @@ static void falcon_probe_spi_devices(struct efx_nic *efx)
                efx_writeo(efx, &ee_vpd_cfg, FR_AB_EE_VPD_CFG0);
        }
+        mutex_init(&nic_data->spi_lock);
        if (boot_dev == FFE_AB_SPI_DEVICE_FLASH)
-                falcon_spi_device_init(efx, &efx->spi_flash,
+                falcon_spi_device_init(efx, &nic_data->spi_flash,
                                       FFE_AB_SPI_DEVICE_FLASH,
                                       default_flash_type);
        if (boot_dev == FFE_AB_SPI_DEVICE_EEPROM)
-                falcon_spi_device_init(efx, &efx->spi_eeprom,
+                falcon_spi_device_init(efx, &nic_data->spi_eeprom,
                                       FFE_AB_SPI_DEVICE_EEPROM,
                                       large_eeprom_type);
 }
@@ -1471,7 +1398,7 @@ static int falcon_probe_nic(struct efx_nic *efx)
        }
        /* Now we can reset the NIC */
-        rc = falcon_reset_hw(efx, RESET_TYPE_ALL);
+        rc = __falcon_reset_hw(efx, RESET_TYPE_ALL);
        if (rc) {
                netif_err(efx, probe, efx->net_dev, "failed to reset NIC\n");
                goto fail3;
@@ -1493,8 +1420,11 @@ static int falcon_probe_nic(struct efx_nic *efx)
        /* Read in the non-volatile configuration */
        rc = falcon_probe_nvconfig(efx);
-        if (rc)
+        if (rc) {
+                if (rc == -EINVAL)
+                        netif_err(efx, probe, efx->net_dev, "NVRAM is invalid\n");
                goto fail5;
+        }
        /* Initialise I2C adapter */
        board = falcon_board(efx);
@@ -1526,7 +1456,6 @@ static int falcon_probe_nic(struct efx_nic *efx)
        BUG_ON(i2c_del_adapter(&board->i2c_adap));
        memset(&board->i2c_adap, 0, sizeof(board->i2c_adap));
 fail5:
-        falcon_remove_spi_devices(efx);
        efx_nic_free_buffer(efx, &efx->irq_status);
 fail4:
 fail3:
@@ -1549,36 +1478,26 @@ static void falcon_init_rx_cfg(struct efx_nic *efx)
        /* RX control FIFO thresholds (32 entries) */
        const unsigned ctrl_xon_thr = 20;
        const unsigned ctrl_xoff_thr = 25;
-        /* RX data FIFO thresholds (256-byte units; size varies) */
-        int data_xon_thr = efx_nic_rx_xon_thresh >> 8;
-        int data_xoff_thr = efx_nic_rx_xoff_thresh >> 8;
        efx_oword_t reg;
        efx_reado(efx, &reg, FR_AZ_RX_CFG);
        if (efx_nic_rev(efx) <= EFX_REV_FALCON_A1) {
                /* Data FIFO size is 5.5K */
-                if (data_xon_thr < 0)
-                        data_xon_thr = 512 >> 8;
-                if (data_xoff_thr < 0)
-                        data_xoff_thr = 2048 >> 8;
                EFX_SET_OWORD_FIELD(reg, FRF_AA_RX_DESC_PUSH_EN, 0);
                EFX_SET_OWORD_FIELD(reg, FRF_AA_RX_USR_BUF_SIZE,
                                    huge_buf_size);
-                EFX_SET_OWORD_FIELD(reg, FRF_AA_RX_XON_MAC_TH, data_xon_thr);
+                EFX_SET_OWORD_FIELD(reg, FRF_AA_RX_XON_MAC_TH, 512 >> 8);
-                EFX_SET_OWORD_FIELD(reg, FRF_AA_RX_XOFF_MAC_TH, data_xoff_thr);
+                EFX_SET_OWORD_FIELD(reg, FRF_AA_RX_XOFF_MAC_TH, 2048 >> 8);
                EFX_SET_OWORD_FIELD(reg, FRF_AA_RX_XON_TX_TH, ctrl_xon_thr);
                EFX_SET_OWORD_FIELD(reg, FRF_AA_RX_XOFF_TX_TH, ctrl_xoff_thr);
        } else {
                /* Data FIFO size is 80K; register fields moved */
-                if (data_xon_thr < 0)
-                        data_xon_thr = 27648 >> 8; /* ~3*max MTU */
-                if (data_xoff_thr < 0)
-                        data_xoff_thr = 54272 >> 8; /* ~80Kb - 3*max MTU */
                EFX_SET_OWORD_FIELD(reg, FRF_BZ_RX_DESC_PUSH_EN, 0);
                EFX_SET_OWORD_FIELD(reg, FRF_BZ_RX_USR_BUF_SIZE,
                                    huge_buf_size);
-                EFX_SET_OWORD_FIELD(reg, FRF_BZ_RX_XON_MAC_TH, data_xon_thr);
+                /* Send XON and XOFF at ~3 * max MTU away from empty/full */
-                EFX_SET_OWORD_FIELD(reg, FRF_BZ_RX_XOFF_MAC_TH, data_xoff_thr);
+                EFX_SET_OWORD_FIELD(reg, FRF_BZ_RX_XON_MAC_TH, 27648 >> 8);
+                EFX_SET_OWORD_FIELD(reg, FRF_BZ_RX_XOFF_MAC_TH, 54272 >> 8);
                EFX_SET_OWORD_FIELD(reg, FRF_BZ_RX_XON_TX_TH, ctrl_xon_thr);
                EFX_SET_OWORD_FIELD(reg, FRF_BZ_RX_XOFF_TX_TH, ctrl_xoff_thr);
                EFX_SET_OWORD_FIELD(reg, FRF_BZ_RX_INGR_EN, 1);
@@ -1610,16 +1529,6 @@ static int falcon_init_nic(struct efx_nic *efx)
        EFX_SET_OWORD_FIELD(temp, FRF_AB_ONCHIP_SRAM, 1);
        efx_writeo(efx, &temp, FR_AB_NIC_STAT);
-        /* Set the source of the GMAC clock */
-        if (efx_nic_rev(efx) == EFX_REV_FALCON_B0) {
-                efx_reado(efx, &temp, FR_AB_GPIO_CTL);
-                EFX_SET_OWORD_FIELD(temp, FRF_AB_USE_NIC_CLK, true);
-                efx_writeo(efx, &temp, FR_AB_GPIO_CTL);
-        }
-        /* Select the correct MAC */
-        falcon_clock_mac(efx);
        rc = falcon_reset_sram(efx);
        if (rc)
                return rc;
@@ -1690,10 +1599,9 @@ static void falcon_remove_nic(struct efx_nic *efx)
        BUG_ON(rc);
        memset(&board->i2c_adap, 0, sizeof(board->i2c_adap));
-        falcon_remove_spi_devices(efx);
        efx_nic_free_buffer(efx, &efx->irq_status);
-        falcon_reset_hw(efx, RESET_TYPE_ALL);
+        __falcon_reset_hw(efx, RESET_TYPE_ALL);
        /* Release the second function after the reset */
        if (nic_data->pci_dev2) {
@@ -1795,7 +1703,7 @@ static int falcon_set_wol(struct efx_nic *efx, u32 type)
 **************************************************************************
 */
-struct efx_nic_type falcon_a1_nic_type = {
+const struct efx_nic_type falcon_a1_nic_type = {
        .probe = falcon_probe_nic,
        .remove = falcon_remove_nic,
        .init = falcon_init_nic,
@@ -1804,6 +1712,7 @@ struct efx_nic_type falcon_a1_nic_type = {
        .reset = falcon_reset_hw,
        .probe_port = falcon_probe_port,
        .remove_port = falcon_remove_port,
+        .handle_global_event = falcon_handle_global_event,
        .prepare_flush = falcon_prepare_flush,
        .update_stats = falcon_update_nic_stats,
        .start_stats = falcon_start_nic_stats,
@@ -1835,7 +1744,7 @@ struct efx_nic_type falcon_a1_nic_type = {
        .reset_world_flags = ETH_RESET_IRQ,
 };
-struct efx_nic_type falcon_b0_nic_type = {
+const struct efx_nic_type falcon_b0_nic_type = {
        .probe = falcon_probe_nic,
        .remove = falcon_remove_nic,
        .init = falcon_init_nic,
@@ -1844,6 +1753,7 @@ struct efx_nic_type falcon_b0_nic_type = {
        .reset = falcon_reset_hw,
        .probe_port = falcon_probe_port,
        .remove_port = falcon_remove_port,
+        .handle_global_event = falcon_handle_global_event,
        .prepare_flush = falcon_prepare_flush,
        .update_stats = falcon_update_nic_stats,
        .start_stats = falcon_start_nic_stats,
@@ -1880,7 +1790,7 @@ struct efx_nic_type falcon_b0_nic_type = {
                                   * channels */
        .tx_dc_base = 0x130000,
        .rx_dc_base = 0x100000,
-        .offload_features = NETIF_F_IP_CSUM | NETIF_F_RXHASH,
+        .offload_features = NETIF_F_IP_CSUM | NETIF_F_RXHASH | NETIF_F_NTUPLE,
        .reset_world_flags = ETH_RESET_IRQ,
 };
diff --git a/drivers/net/sfc/falcon_boards.c b/drivers/net/sfc/falcon_boards.c
index 3d950c2cf205..b9cc846811d6 100644
--- a/drivers/net/sfc/falcon_boards.c
+++ b/drivers/net/sfc/falcon_boards.c
@@ -1,6 +1,6 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
- * Copyright 2007-2009 Solarflare Communications Inc.
+ * Copyright 2007-2010 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -13,8 +13,6 @@
 #include "phy.h"
 #include "efx.h"
 #include "nic.h"
-#include "regs.h"
-#include "io.h"
 #include "workarounds.h"
 /* Macros for unpacking the board revision */
@@ -26,21 +24,32 @@
 /* Board types */
 #define FALCON_BOARD_SFE4001 0x01
 #define FALCON_BOARD_SFE4002 0x02
-#define FALCON_BOARD_SFN4111T 0x51
+#define FALCON_BOARD_SFE4003 0x03
 #define FALCON_BOARD_SFN4112F 0x52
 /* Board temperature is about 15°C above ambient when air flow is
- * limited. */
+ * limited.  The maximum acceptable ambient temperature varies
+ * depending on the PHY specifications but the critical temperature
+ * above which we should shut down to avoid damage is 80°C. */
 #define FALCON_BOARD_TEMP_BIAS  15
+#define FALCON_BOARD_TEMP_CRIT  (80 + FALCON_BOARD_TEMP_BIAS)
 /* SFC4000 datasheet says: 'The maximum permitted junction temperature
 * is 125°C; the thermal design of the environment for the SFC4000
 * should aim to keep this well below 100°C.' */
+#define FALCON_JUNC_TEMP_MIN    0
 #define FALCON_JUNC_TEMP_MAX    90
+#define FALCON_JUNC_TEMP_CRIT   125
 /*****************************************************************************
 * Support for LM87 sensor chip used on several boards
 */
+#define LM87_REG_TEMP_HW_INT_LOCK       0x13
+#define LM87_REG_TEMP_HW_EXT_LOCK       0x14
+#define LM87_REG_TEMP_HW_INT            0x17
+#define LM87_REG_TEMP_HW_EXT            0x18
+#define LM87_REG_TEMP_EXT1              0x26
+#define LM87_REG_TEMP_INT               0x27
 #define LM87_REG_ALARMS1                0x41
 #define LM87_REG_ALARMS2                0x42
 #define LM87_IN_LIMITS(nr, _min, _max)                  \
@@ -57,6 +66,27 @@
 #if defined(CONFIG_SENSORS_LM87) || defined(CONFIG_SENSORS_LM87_MODULE)
+static int efx_poke_lm87(struct i2c_client *client, const u8 *reg_values)
+{
+        while (*reg_values) {
+                u8 reg = *reg_values++;
+                u8 value = *reg_values++;
+                int rc = i2c_smbus_write_byte_data(client, reg, value);
+                if (rc)
+                        return rc;
+        }
+        return 0;
+}
+static const u8 falcon_lm87_common_regs[] = {
+        LM87_REG_TEMP_HW_INT_LOCK, FALCON_BOARD_TEMP_CRIT,
+        LM87_REG_TEMP_HW_INT, FALCON_BOARD_TEMP_CRIT,
+        LM87_TEMP_EXT1_LIMITS(FALCON_JUNC_TEMP_MIN, FALCON_JUNC_TEMP_MAX),
+        LM87_REG_TEMP_HW_EXT_LOCK, FALCON_JUNC_TEMP_CRIT,
+        LM87_REG_TEMP_HW_EXT, FALCON_JUNC_TEMP_CRIT,
+        0
+};
 static int efx_init_lm87(struct efx_nic *efx, struct i2c_board_info *info,
                         const u8 *reg_values)
 {
@@ -67,13 +97,16 @@ static int efx_init_lm87(struct efx_nic *efx, struct i2c_board_info *info,
        if (!client)
                return -EIO;
-        while (*reg_values) {
+        /* Read-to-clear alarm/interrupt status */
-                u8 reg = *reg_values++;
+        i2c_smbus_read_byte_data(client, LM87_REG_ALARMS1);
-                u8 value = *reg_values++;
+        i2c_smbus_read_byte_data(client, LM87_REG_ALARMS2);
-                rc = i2c_smbus_write_byte_data(client, reg, value);
-                if (rc)
+        rc = efx_poke_lm87(client, reg_values);
-                        goto err;
+        if (rc)
-        }
+                goto err;
+        rc = efx_poke_lm87(client, falcon_lm87_common_regs);
+        if (rc)
+                goto err;
        board->hwmon_client = client;
        return 0;
@@ -91,36 +124,56 @@ static void efx_fini_lm87(struct efx_nic *efx)
 static int efx_check_lm87(struct efx_nic *efx, unsigned mask)
 {
        struct i2c_client *client = falcon_board(efx)->hwmon_client;
-        s32 alarms1, alarms2;
+        bool temp_crit, elec_fault, is_failure;
+        u16 alarms;
+        s32 reg;
        /* If link is up then do not monitor temperature */
        if (EFX_WORKAROUND_7884(efx) && efx->link_state.up)
                return 0;
-        alarms1 = i2c_smbus_read_byte_data(client, LM87_REG_ALARMS1);
+        reg = i2c_smbus_read_byte_data(client, LM87_REG_ALARMS1);
-        alarms2 = i2c_smbus_read_byte_data(client, LM87_REG_ALARMS2);
+        if (reg < 0)
-        if (alarms1 < 0)
+                return reg;
-                return alarms1;
+        alarms = reg;
-        if (alarms2 < 0)
+        reg = i2c_smbus_read_byte_data(client, LM87_REG_ALARMS2);
-                return alarms2;
+        if (reg < 0)
-        alarms1 &= mask;
+                return reg;
-        alarms2 &= mask >> 8;
+        alarms |= reg << 8;
-        if (alarms1 || alarms2) {
+        alarms &= mask;
+        temp_crit = false;
+        if (alarms & LM87_ALARM_TEMP_INT) {
+                reg = i2c_smbus_read_byte_data(client, LM87_REG_TEMP_INT);
+                if (reg < 0)
+                        return reg;
+                if (reg > FALCON_BOARD_TEMP_CRIT)
+                        temp_crit = true;
+        }
+        if (alarms & LM87_ALARM_TEMP_EXT1) {
+                reg = i2c_smbus_read_byte_data(client, LM87_REG_TEMP_EXT1);
+                if (reg < 0)
+                        return reg;
+                if (reg > FALCON_JUNC_TEMP_CRIT)
+                        temp_crit = true;
+        }
+        elec_fault = alarms & ~(LM87_ALARM_TEMP_INT | LM87_ALARM_TEMP_EXT1);
+        is_failure = temp_crit || elec_fault;
+        if (alarms)
                netif_err(efx, hw, efx->net_dev,
-                          "LM87 detected a hardware failure (status %02x:%02x)"
+                          "LM87 detected a hardware %s (status %02x:%02x)"
-                          "%s%s%s\n",
+                          "%s%s%s%s\n",
-                          alarms1, alarms2,
+                          is_failure ? "failure" : "problem",
-                          (alarms1 & LM87_ALARM_TEMP_INT) ?
+                          alarms & 0xff, alarms >> 8,
+                          (alarms & LM87_ALARM_TEMP_INT) ?
                          "; board is overheating" : "",
-                          (alarms1 & LM87_ALARM_TEMP_EXT1) ?
+                          (alarms & LM87_ALARM_TEMP_EXT1) ?
                          "; controller is overheating" : "",
-                          (alarms1 & ~(LM87_ALARM_TEMP_INT | LM87_ALARM_TEMP_EXT1)
+                          temp_crit ? "; reached critical temperature" : "",
-                           || alarms2) ?
+                          elec_fault ? "; electrical fault" : "");
-                          "; electrical fault" : "");
-                return -ERANGE;
-        }
-        return 0;
+        return is_failure ? -ERANGE : 0;
 }
 #else /* !CONFIG_SENSORS_LM87 */
@@ -142,17 +195,17 @@ static inline int efx_check_lm87(struct efx_nic *efx, unsigned mask)
 #endif /* CONFIG_SENSORS_LM87 */
 /*****************************************************************************
- * Support for the SFE4001 and SFN4111T NICs.
+ * Support for the SFE4001 NIC.
 *
 * The SFE4001 does not power-up fully at reset due to its high power
 * consumption.  We control its power via a PCA9539 I/O expander.
- * Both boards have a MAX6647 temperature monitor which we expose to
+ * It also has a MAX6647 temperature monitor which we expose to
 * the lm90 driver.
 *
 * This also provides minimal support for reflashing the PHY, which is
 * initiated by resetting it with the FLASH_CFG_1 pin pulled down.
 * On SFE4001 rev A2 and later this is connected to the 3V3X output of
- * the IO-expander; on the SFN4111T it is connected to Falcon's GPIO3.
+ * the IO-expander.
 * We represent reflash mode as PHY_MODE_SPECIAL and make it mutually
 * exclusive with the network device being open.
 */
@@ -304,34 +357,6 @@ fail_on:
        return rc;
 }
-static int sfn4111t_reset(struct efx_nic *efx)
-{
-        struct falcon_board *board = falcon_board(efx);
-        efx_oword_t reg;
-        /* GPIO 3 and the GPIO register are shared with I2C, so block that */
-        i2c_lock_adapter(&board->i2c_adap);
-        /* Pull RST_N (GPIO 2) low then let it up again, setting the
-         * FLASH_CFG_1 strap (GPIO 3) appropriately.  Only change the
-         * output enables; the output levels should always be 0 (low)
-         * and we rely on external pull-ups. */
-        efx_reado(efx, &reg, FR_AB_GPIO_CTL);
-        EFX_SET_OWORD_FIELD(reg, FRF_AB_GPIO2_OEN, true);
-        efx_writeo(efx, &reg, FR_AB_GPIO_CTL);
-        msleep(1000);
-        EFX_SET_OWORD_FIELD(reg, FRF_AB_GPIO2_OEN, false);
-        EFX_SET_OWORD_FIELD(reg, FRF_AB_GPIO3_OEN,
-                            !!(efx->phy_mode & PHY_MODE_SPECIAL));
-        efx_writeo(efx, &reg, FR_AB_GPIO_CTL);
-        msleep(1);
-        i2c_unlock_adapter(&board->i2c_adap);
-        ssleep(1);
-        return 0;
-}
 static ssize_t show_phy_flash_cfg(struct device *dev,
                                  struct device_attribute *attr, char *buf)
 {
@@ -353,7 +378,7 @@ static ssize_t set_phy_flash_cfg(struct device *dev,
                new_mode = old_mode & ~PHY_MODE_SPECIAL;
        else
                new_mode = PHY_MODE_SPECIAL;
-        if (old_mode == new_mode) {
+        if (!((old_mode ^ new_mode) & PHY_MODE_SPECIAL)) {
                err = 0;
        } else if (efx->state != STATE_RUNNING || netif_running(efx->net_dev)) {
                err = -EBUSY;
@@ -363,10 +388,7 @@ static ssize_t set_phy_flash_cfg(struct device *dev,
                efx->phy_mode = new_mode;
                if (new_mode & PHY_MODE_SPECIAL)
                        falcon_stop_nic_stats(efx);
-                if (falcon_board(efx)->type->id == FALCON_BOARD_SFE4001)
+                err = sfe4001_poweron(efx);
-                        err = sfe4001_poweron(efx);
-                else
-                        err = sfn4111t_reset(efx);
                if (!err)
                        err = efx_reconfigure_port(efx);
                if (!(new_mode & PHY_MODE_SPECIAL))
@@ -393,10 +415,11 @@ static void sfe4001_fini(struct efx_nic *efx)
 static int sfe4001_check_hw(struct efx_nic *efx)
 {
+        struct falcon_nic_data *nic_data = efx->nic_data;
        s32 status;
        /* If XAUI link is up then do not monitor */
-        if (EFX_WORKAROUND_7884(efx) && !efx->xmac_poll_required)
+        if (EFX_WORKAROUND_7884(efx) && !nic_data->xmac_poll_required)
                return 0;
        /* Check the powered status of the PHY. Lack of power implies that
@@ -479,83 +502,6 @@ fail_hwmon:
        return rc;
 }
-static int sfn4111t_check_hw(struct efx_nic *efx)
-{
-        s32 status;
-        /* If XAUI link is up then do not monitor */
-        if (EFX_WORKAROUND_7884(efx) && !efx->xmac_poll_required)
-                return 0;
-        /* Test LHIGH, RHIGH, FAULT, EOT and IOT alarms */
-        status = i2c_smbus_read_byte_data(falcon_board(efx)->hwmon_client,
-                                          MAX664X_REG_RSL);
-        if (status < 0)
-                return -EIO;
-        if (status & 0x57)
-                return -ERANGE;
-        return 0;
-}
-static void sfn4111t_fini(struct efx_nic *efx)
-{
-        netif_info(efx, drv, efx->net_dev, "%s\n", __func__);
-        device_remove_file(&efx->pci_dev->dev, &dev_attr_phy_flash_cfg);
-        i2c_unregister_device(falcon_board(efx)->hwmon_client);
-}
-static struct i2c_board_info sfn4111t_a0_hwmon_info = {
-        I2C_BOARD_INFO("max6647", 0x4e),
-};
-static struct i2c_board_info sfn4111t_r5_hwmon_info = {
-        I2C_BOARD_INFO("max6646", 0x4d),
-};
-static void sfn4111t_init_phy(struct efx_nic *efx)
-{
-        if (!(efx->phy_mode & PHY_MODE_SPECIAL)) {
-                if (sft9001_wait_boot(efx) != -EINVAL)
-                        return;
-                efx->phy_mode = PHY_MODE_SPECIAL;
-                falcon_stop_nic_stats(efx);
-        }
-        sfn4111t_reset(efx);
-        sft9001_wait_boot(efx);
-}
-static int sfn4111t_init(struct efx_nic *efx)
-{
-        struct falcon_board *board = falcon_board(efx);
-        int rc;
-        board->hwmon_client =
-                i2c_new_device(&board->i2c_adap,
-                               (board->minor < 5) ?
-                               &sfn4111t_a0_hwmon_info :
-                               &sfn4111t_r5_hwmon_info);
-        if (!board->hwmon_client)
-                return -EIO;
-        rc = device_create_file(&efx->pci_dev->dev, &dev_attr_phy_flash_cfg);
-        if (rc)
-                goto fail_hwmon;
-        if (efx->phy_mode & PHY_MODE_SPECIAL)
-                /* PHY may not generate a 156.25 MHz clock and MAC
-                 * stats fetch will fail. */
-                falcon_stop_nic_stats(efx);
-        return 0;
-fail_hwmon:
-        i2c_unregister_device(board->hwmon_client);
-        return rc;
-}
 /*****************************************************************************
 * Support for the SFE4002
 *
@@ -691,6 +637,75 @@ static int sfn4112f_init(struct efx_nic *efx)
        return efx_init_lm87(efx, &sfn4112f_hwmon_info, sfn4112f_lm87_regs);
 }
+/*****************************************************************************
+ * Support for the SFE4003
+ *
+ */
+static u8 sfe4003_lm87_channel = 0x03; /* use AIN not FAN inputs */
+static const u8 sfe4003_lm87_regs[] = {
+        LM87_IN_LIMITS(0, 0x67, 0x7f),          /* 2.5V:  1.5V +/- 10% */
+        LM87_IN_LIMITS(1, 0x4c, 0x5e),          /* Vccp1: 1.2V +/- 10% */
+        LM87_IN_LIMITS(2, 0xac, 0xd4),          /* 3.3V:  3.3V +/- 10% */
+        LM87_IN_LIMITS(4, 0xac, 0xe0),          /* 12V:   10.8-14V */
+        LM87_IN_LIMITS(5, 0x3f, 0x4f),          /* Vccp2: 1.0V +/- 10% */
+        LM87_TEMP_INT_LIMITS(0, 70 + FALCON_BOARD_TEMP_BIAS),
+        0
+};
+static struct i2c_board_info sfe4003_hwmon_info = {
+        I2C_BOARD_INFO("lm87", 0x2e),
+        .platform_data  = &sfe4003_lm87_channel,
+};
+/* Board-specific LED info. */
+#define SFE4003_RED_LED_GPIO    11
+#define SFE4003_LED_ON          1
+#define SFE4003_LED_OFF         0
+static void sfe4003_set_id_led(struct efx_nic *efx, enum efx_led_mode mode)
+{
+        struct falcon_board *board = falcon_board(efx);
+        /* The LEDs were not wired to GPIOs before A3 */
+        if (board->minor < 3 && board->major == 0)
+                return;
+        falcon_txc_set_gpio_val(
+                efx, SFE4003_RED_LED_GPIO,
+                (mode == EFX_LED_ON) ? SFE4003_LED_ON : SFE4003_LED_OFF);
+}
+static void sfe4003_init_phy(struct efx_nic *efx)
+{
+        struct falcon_board *board = falcon_board(efx);
+        /* The LEDs were not wired to GPIOs before A3 */
+        if (board->minor < 3 && board->major == 0)
+                return;
+        falcon_txc_set_gpio_dir(efx, SFE4003_RED_LED_GPIO, TXC_GPIO_DIR_OUTPUT);
+        falcon_txc_set_gpio_val(efx, SFE4003_RED_LED_GPIO, SFE4003_LED_OFF);
+}
+static int sfe4003_check_hw(struct efx_nic *efx)
+{
+        struct falcon_board *board = falcon_board(efx);
+        /* A0/A1/A2 board rev. 4003s  report a temperature fault the whole time
+         * (bad sensor) so we mask it out. */
+        unsigned alarm_mask =
+                (board->major == 0 && board->minor <= 2) ?
+                ~LM87_ALARM_TEMP_EXT1 : ~0;
+        return efx_check_lm87(efx, alarm_mask);
+}
+static int sfe4003_init(struct efx_nic *efx)
+{
+        return efx_init_lm87(efx, &sfe4003_hwmon_info, sfe4003_lm87_regs);
+}
 static const struct falcon_board_type board_types[] = {
        {
                .id             = FALCON_BOARD_SFE4001,
@@ -713,14 +728,14 @@ static const struct falcon_board_type board_types[] = {
                .monitor        = sfe4002_check_hw,
        },
        {
-                .id             = FALCON_BOARD_SFN4111T,
+                .id             = FALCON_BOARD_SFE4003,
-                .ref_model      = "SFN4111T",
+                .ref_model      = "SFE4003",
-                .gen_type       = "100/1000/10GBASE-T adapter",
+                .gen_type       = "10GBASE-CX4 adapter",
-                .init           = sfn4111t_init,
+                .init           = sfe4003_init,
-                .init_phy       = sfn4111t_init_phy,
+                .init_phy       = sfe4003_init_phy,
-                .fini           = sfn4111t_fini,
+                .fini           = efx_fini_lm87,
-                .set_id_led     = tenxpress_set_id_led,
+                .set_id_led     = sfe4003_set_id_led,
-                .monitor        = sfn4111t_check_hw,
+                .monitor        = sfe4003_check_hw,
        },
        {
                .id             = FALCON_BOARD_SFN4112F,
diff --git a/drivers/net/sfc/falcon_gmac.c b/drivers/net/sfc/falcon_gmac.c
deleted file mode 100644
index 7dadfcbd6ce7..000000000000
--- a/drivers/net/sfc/falcon_gmac.c
+++ /dev/null
@@ -1,230 +0,0 @@
-/****************************************************************************
- * Driver for Solarflare Solarstorm network controllers and boards
- * Copyright 2005-2006 Fen Systems Ltd.
- * Copyright 2006-2009 Solarflare Communications Inc.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 as published
- * by the Free Software Foundation, incorporated herein by reference.
- */
-#include <linux/delay.h>
-#include "net_driver.h"
-#include "efx.h"
-#include "nic.h"
-#include "mac.h"
-#include "regs.h"
-#include "io.h"
-/**************************************************************************
- *
- * MAC operations
- *
- *************************************************************************/
-static int falcon_reconfigure_gmac(struct efx_nic *efx)
-{
-        struct efx_link_state *link_state = &efx->link_state;
-        bool loopback, tx_fc, rx_fc, bytemode;
-        int if_mode;
-        unsigned int max_frame_len;
-        efx_oword_t reg;
-        /* Configuration register 1 */
-        tx_fc = (link_state->fc & EFX_FC_TX) || !link_state->fd;
-        rx_fc = !!(link_state->fc & EFX_FC_RX);
-        loopback = (efx->loopback_mode == LOOPBACK_GMAC);
-        bytemode = (link_state->speed == 1000);
-        EFX_POPULATE_OWORD_5(reg,
-                             FRF_AB_GM_LOOP, loopback,
-                             FRF_AB_GM_TX_EN, 1,
-                             FRF_AB_GM_TX_FC_EN, tx_fc,
-                             FRF_AB_GM_RX_EN, 1,
-                             FRF_AB_GM_RX_FC_EN, rx_fc);
-        efx_writeo(efx, &reg, FR_AB_GM_CFG1);
-        udelay(10);
-        /* Configuration register 2 */
-        if_mode = (bytemode) ? 2 : 1;
-        EFX_POPULATE_OWORD_5(reg,
-                             FRF_AB_GM_IF_MODE, if_mode,
-                             FRF_AB_GM_PAD_CRC_EN, 1,
-                             FRF_AB_GM_LEN_CHK, 1,
-                             FRF_AB_GM_FD, link_state->fd,
-                             FRF_AB_GM_PAMBL_LEN, 0x7/*datasheet recommended */);
-        efx_writeo(efx, &reg, FR_AB_GM_CFG2);
-        udelay(10);
-        /* Max frame len register */
-        max_frame_len = EFX_MAX_FRAME_LEN(efx->net_dev->mtu);
-        EFX_POPULATE_OWORD_1(reg, FRF_AB_GM_MAX_FLEN, max_frame_len);
-        efx_writeo(efx, &reg, FR_AB_GM_MAX_FLEN);
-        udelay(10);
-        /* FIFO configuration register 0 */
-        EFX_POPULATE_OWORD_5(reg,
-                             FRF_AB_GMF_FTFENREQ, 1,
-                             FRF_AB_GMF_STFENREQ, 1,
-                             FRF_AB_GMF_FRFENREQ, 1,
-                             FRF_AB_GMF_SRFENREQ, 1,
-                             FRF_AB_GMF_WTMENREQ, 1);
-        efx_writeo(efx, &reg, FR_AB_GMF_CFG0);
-        udelay(10);
-        /* FIFO configuration register 1 */
-        EFX_POPULATE_OWORD_2(reg,
-                             FRF_AB_GMF_CFGFRTH, 0x12,
-                             FRF_AB_GMF_CFGXOFFRTX, 0xffff);
-        efx_writeo(efx, &reg, FR_AB_GMF_CFG1);
-        udelay(10);
-        /* FIFO configuration register 2 */
-        EFX_POPULATE_OWORD_2(reg,
-                             FRF_AB_GMF_CFGHWM, 0x3f,
-                             FRF_AB_GMF_CFGLWM, 0xa);
-        efx_writeo(efx, &reg, FR_AB_GMF_CFG2);
-        udelay(10);
-        /* FIFO configuration register 3 */
-        EFX_POPULATE_OWORD_2(reg,
-                             FRF_AB_GMF_CFGHWMFT, 0x1c,
-                             FRF_AB_GMF_CFGFTTH, 0x08);
-        efx_writeo(efx, &reg, FR_AB_GMF_CFG3);
-        udelay(10);
-        /* FIFO configuration register 4 */
-        EFX_POPULATE_OWORD_1(reg, FRF_AB_GMF_HSTFLTRFRM_PAUSE, 1);
-        efx_writeo(efx, &reg, FR_AB_GMF_CFG4);
-        udelay(10);
-        /* FIFO configuration register 5 */
-        efx_reado(efx, &reg, FR_AB_GMF_CFG5);
-        EFX_SET_OWORD_FIELD(reg, FRF_AB_GMF_CFGBYTMODE, bytemode);
-        EFX_SET_OWORD_FIELD(reg, FRF_AB_GMF_CFGHDPLX, !link_state->fd);
-        EFX_SET_OWORD_FIELD(reg, FRF_AB_GMF_HSTDRPLT64, !link_state->fd);
-        EFX_SET_OWORD_FIELD(reg, FRF_AB_GMF_HSTFLTRFRMDC_PAUSE, 0);
-        efx_writeo(efx, &reg, FR_AB_GMF_CFG5);
-        udelay(10);
-        /* MAC address */
-        EFX_POPULATE_OWORD_4(reg,
-                             FRF_AB_GM_ADR_B0, efx->net_dev->dev_addr[5],
-                             FRF_AB_GM_ADR_B1, efx->net_dev->dev_addr[4],
-                             FRF_AB_GM_ADR_B2, efx->net_dev->dev_addr[3],
-                             FRF_AB_GM_ADR_B3, efx->net_dev->dev_addr[2]);
-        efx_writeo(efx, &reg, FR_AB_GM_ADR1);
-        udelay(10);
-        EFX_POPULATE_OWORD_2(reg,
-                             FRF_AB_GM_ADR_B4, efx->net_dev->dev_addr[1],
-                             FRF_AB_GM_ADR_B5, efx->net_dev->dev_addr[0]);
-        efx_writeo(efx, &reg, FR_AB_GM_ADR2);
-        udelay(10);
-        falcon_reconfigure_mac_wrapper(efx);
-        return 0;
-}
-static void falcon_update_stats_gmac(struct efx_nic *efx)
-{
-        struct efx_mac_stats *mac_stats = &efx->mac_stats;
-        unsigned long old_rx_pause, old_tx_pause;
-        unsigned long new_rx_pause, new_tx_pause;
-        /* Pause frames are erroneously counted as errors (SFC bug 3269) */
-        old_rx_pause = mac_stats->rx_pause;
-        old_tx_pause = mac_stats->tx_pause;
-        /* Update MAC stats from DMAed values */
-        FALCON_STAT(efx, GRxGoodOct, rx_good_bytes);
-        FALCON_STAT(efx, GRxBadOct, rx_bad_bytes);
-        FALCON_STAT(efx, GRxMissPkt, rx_missed);
-        FALCON_STAT(efx, GRxFalseCRS, rx_false_carrier);
-        FALCON_STAT(efx, GRxPausePkt, rx_pause);
-        FALCON_STAT(efx, GRxBadPkt, rx_bad);
-        FALCON_STAT(efx, GRxUcastPkt, rx_unicast);
-        FALCON_STAT(efx, GRxMcastPkt, rx_multicast);
-        FALCON_STAT(efx, GRxBcastPkt, rx_broadcast);
-        FALCON_STAT(efx, GRxGoodLt64Pkt, rx_good_lt64);
-        FALCON_STAT(efx, GRxBadLt64Pkt, rx_bad_lt64);
-        FALCON_STAT(efx, GRx64Pkt, rx_64);
-        FALCON_STAT(efx, GRx65to127Pkt, rx_65_to_127);
-        FALCON_STAT(efx, GRx128to255Pkt, rx_128_to_255);
-        FALCON_STAT(efx, GRx256to511Pkt, rx_256_to_511);
-        FALCON_STAT(efx, GRx512to1023Pkt, rx_512_to_1023);
-        FALCON_STAT(efx, GRx1024to15xxPkt, rx_1024_to_15xx);
-        FALCON_STAT(efx, GRx15xxtoJumboPkt, rx_15xx_to_jumbo);
-        FALCON_STAT(efx, GRxGtJumboPkt, rx_gtjumbo);
-        FALCON_STAT(efx, GRxFcsErr64to15xxPkt, rx_bad_64_to_15xx);
-        FALCON_STAT(efx, GRxFcsErr15xxtoJumboPkt, rx_bad_15xx_to_jumbo);
-        FALCON_STAT(efx, GRxFcsErrGtJumboPkt, rx_bad_gtjumbo);
-        FALCON_STAT(efx, GTxGoodBadOct, tx_bytes);
-        FALCON_STAT(efx, GTxGoodOct, tx_good_bytes);
-        FALCON_STAT(efx, GTxSglColPkt, tx_single_collision);
-        FALCON_STAT(efx, GTxMultColPkt, tx_multiple_collision);
-        FALCON_STAT(efx, GTxExColPkt, tx_excessive_collision);
-        FALCON_STAT(efx, GTxDefPkt, tx_deferred);
-        FALCON_STAT(efx, GTxLateCol, tx_late_collision);
-        FALCON_STAT(efx, GTxExDefPkt, tx_excessive_deferred);
-        FALCON_STAT(efx, GTxPausePkt, tx_pause);
-        FALCON_STAT(efx, GTxBadPkt, tx_bad);
-        FALCON_STAT(efx, GTxUcastPkt, tx_unicast);
-        FALCON_STAT(efx, GTxMcastPkt, tx_multicast);
-        FALCON_STAT(efx, GTxBcastPkt, tx_broadcast);
-        FALCON_STAT(efx, GTxLt64Pkt, tx_lt64);
-        FALCON_STAT(efx, GTx64Pkt, tx_64);
-        FALCON_STAT(efx, GTx65to127Pkt, tx_65_to_127);
-        FALCON_STAT(efx, GTx128to255Pkt, tx_128_to_255);
-        FALCON_STAT(efx, GTx256to511Pkt, tx_256_to_511);
-        FALCON_STAT(efx, GTx512to1023Pkt, tx_512_to_1023);
-        FALCON_STAT(efx, GTx1024to15xxPkt, tx_1024_to_15xx);
-        FALCON_STAT(efx, GTx15xxtoJumboPkt, tx_15xx_to_jumbo);
-        FALCON_STAT(efx, GTxGtJumboPkt, tx_gtjumbo);
-        FALCON_STAT(efx, GTxNonTcpUdpPkt, tx_non_tcpudp);
-        FALCON_STAT(efx, GTxMacSrcErrPkt, tx_mac_src_error);
-        FALCON_STAT(efx, GTxIpSrcErrPkt, tx_ip_src_error);
-        /* Pause frames are erroneously counted as errors (SFC bug 3269) */
-        new_rx_pause = mac_stats->rx_pause;
-        new_tx_pause = mac_stats->tx_pause;
-        mac_stats->rx_bad -= (new_rx_pause - old_rx_pause);
-        mac_stats->tx_bad -= (new_tx_pause - old_tx_pause);
-        /* Derive stats that the MAC doesn't provide directly */
-        mac_stats->tx_bad_bytes =
-                mac_stats->tx_bytes - mac_stats->tx_good_bytes;
-        mac_stats->tx_packets =
-                mac_stats->tx_lt64 + mac_stats->tx_64 +
-                mac_stats->tx_65_to_127 + mac_stats->tx_128_to_255 +
-                mac_stats->tx_256_to_511 + mac_stats->tx_512_to_1023 +
-                mac_stats->tx_1024_to_15xx + mac_stats->tx_15xx_to_jumbo +
-                mac_stats->tx_gtjumbo;
-        mac_stats->tx_collision =
-                mac_stats->tx_single_collision +
-                mac_stats->tx_multiple_collision +
-                mac_stats->tx_excessive_collision +
-                mac_stats->tx_late_collision;
-        mac_stats->rx_bytes =
-                mac_stats->rx_good_bytes + mac_stats->rx_bad_bytes;
-        mac_stats->rx_packets =
-                mac_stats->rx_good_lt64 + mac_stats->rx_bad_lt64 +
-                mac_stats->rx_64 + mac_stats->rx_65_to_127 +
-                mac_stats->rx_128_to_255 + mac_stats->rx_256_to_511 +
-                mac_stats->rx_512_to_1023 + mac_stats->rx_1024_to_15xx +
-                mac_stats->rx_15xx_to_jumbo + mac_stats->rx_gtjumbo;
-        mac_stats->rx_good = mac_stats->rx_packets - mac_stats->rx_bad;
-        mac_stats->rx_lt64 = mac_stats->rx_good_lt64 + mac_stats->rx_bad_lt64;
-}
-static bool falcon_gmac_check_fault(struct efx_nic *efx)
-{
-        return false;
-}
-struct efx_mac_operations falcon_gmac_operations = {
-        .reconfigure    = falcon_reconfigure_gmac,
-        .update_stats   = falcon_update_stats_gmac,
-        .check_fault    = falcon_gmac_check_fault,
-};
diff --git a/drivers/net/sfc/falcon_xmac.c b/drivers/net/sfc/falcon_xmac.c
index bae656dd2c4e..9516452c079c 100644
--- a/drivers/net/sfc/falcon_xmac.c
+++ b/drivers/net/sfc/falcon_xmac.c
@@ -1,7 +1,7 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
 * Copyright 2005-2006 Fen Systems Ltd.
- * Copyright 2006-2009 Solarflare Communications Inc.
+ * Copyright 2006-2010 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -16,7 +16,6 @@
 #include "io.h"
 #include "mac.h"
 #include "mdio_10g.h"
-#include "phy.h"
 #include "workarounds.h"
 /**************************************************************************
@@ -88,6 +87,7 @@ int falcon_reset_xaui(struct efx_nic *efx)
 static void falcon_ack_status_intr(struct efx_nic *efx)
 {
+        struct falcon_nic_data *nic_data = efx->nic_data;
        efx_oword_t reg;
        if ((efx_nic_rev(efx) != EFX_REV_FALCON_B0) || LOOPBACK_INTERNAL(efx))
@@ -99,7 +99,7 @@ static void falcon_ack_status_intr(struct efx_nic *efx)
        /* We can only use this interrupt to signal the negative edge of
         * xaui_align [we have to poll the positive edge]. */
-        if (efx->xmac_poll_required)
+        if (nic_data->xmac_poll_required)
                return;
        efx_reado(efx, &reg, FR_AB_XM_MGT_INT_MSK);
@@ -143,7 +143,7 @@ static bool falcon_xmac_link_ok(struct efx_nic *efx)
                 efx_mdio_phyxgxs_lane_sync(efx));
 }
-void falcon_reconfigure_xmac_core(struct efx_nic *efx)
+static void falcon_reconfigure_xmac_core(struct efx_nic *efx)
 {
        unsigned int max_frame_len;
        efx_oword_t reg;
@@ -277,12 +277,14 @@ static bool falcon_xmac_check_fault(struct efx_nic *efx)
 static int falcon_reconfigure_xmac(struct efx_nic *efx)
 {
+        struct falcon_nic_data *nic_data = efx->nic_data;
        falcon_reconfigure_xgxs_core(efx);
        falcon_reconfigure_xmac_core(efx);
        falcon_reconfigure_mac_wrapper(efx);
-        efx->xmac_poll_required = !falcon_xmac_link_ok_retry(efx, 5);
+        nic_data->xmac_poll_required = !falcon_xmac_link_ok_retry(efx, 5);
        falcon_ack_status_intr(efx);
        return 0;
@@ -350,15 +352,17 @@ static void falcon_update_stats_xmac(struct efx_nic *efx)
 void falcon_poll_xmac(struct efx_nic *efx)
 {
+        struct falcon_nic_data *nic_data = efx->nic_data;
        if (!EFX_WORKAROUND_5147(efx) || !efx->link_state.up ||
-            !efx->xmac_poll_required)
+            !nic_data->xmac_poll_required)
                return;
-        efx->xmac_poll_required = !falcon_xmac_link_ok_retry(efx, 1);
+        nic_data->xmac_poll_required = !falcon_xmac_link_ok_retry(efx, 1);
        falcon_ack_status_intr(efx);
 }
-struct efx_mac_operations falcon_xmac_operations = {
+const struct efx_mac_operations falcon_xmac_operations = {
        .reconfigure    = falcon_reconfigure_xmac,
        .update_stats   = falcon_update_stats_xmac,
        .check_fault    = falcon_xmac_check_fault,
diff --git a/drivers/net/sfc/filter.c b/drivers/net/sfc/filter.c
new file mode 100644
index 000000000000..95a980fd63d5
--- /dev/null
+++ b/drivers/net/sfc/filter.c
@@ -0,0 +1,720 @@
+/****************************************************************************
+ * Driver for Solarflare Solarstorm network controllers and boards
+ * Copyright 2005-2010 Solarflare Communications Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published
+ * by the Free Software Foundation, incorporated herein by reference.
+ */
+#include <linux/in.h>
+#include <net/ip.h>
+#include "efx.h"
+#include "filter.h"
+#include "io.h"
+#include "nic.h"
+#include "regs.h"
+/* "Fudge factors" - difference between programmed value and actual depth.
+ * Due to pipelined implementation we need to program H/W with a value that
+ * is larger than the hop limit we want.
+ */
+#define FILTER_CTL_SRCH_FUDGE_WILD 3
+#define FILTER_CTL_SRCH_FUDGE_FULL 1
+/* Hard maximum hop limit.  Hardware will time-out beyond 200-something.
+ * We also need to avoid infinite loops in efx_filter_search() when the
+ * table is full.
+ */
+#define FILTER_CTL_SRCH_MAX 200
+/* Don't try very hard to find space for performance hints, as this is
+ * counter-productive. */
+#define FILTER_CTL_SRCH_HINT_MAX 5
+enum efx_filter_table_id {
+        EFX_FILTER_TABLE_RX_IP = 0,
+        EFX_FILTER_TABLE_RX_MAC,
+        EFX_FILTER_TABLE_COUNT,
+};
+struct efx_filter_table {
+        enum efx_filter_table_id id;
+        u32             offset;         /* address of table relative to BAR */
+        unsigned        size;           /* number of entries */
+        unsigned        step;           /* step between entries */
+        unsigned        used;           /* number currently used */
+        unsigned long   *used_bitmap;
+        struct efx_filter_spec *spec;
+        unsigned        search_depth[EFX_FILTER_TYPE_COUNT];
+};
+struct efx_filter_state {
+        spinlock_t      lock;
+        struct efx_filter_table table[EFX_FILTER_TABLE_COUNT];
+#ifdef CONFIG_RFS_ACCEL
+        u32             *rps_flow_id;
+        unsigned        rps_expire_index;
+#endif
+};
+/* The filter hash function is LFSR polynomial x^16 + x^3 + 1 of a 32-bit
+ * key derived from the n-tuple.  The initial LFSR state is 0xffff. */
+static u16 efx_filter_hash(u32 key)
+{
+        u16 tmp;
+        /* First 16 rounds */
+        tmp = 0x1fff ^ key >> 16;
+        tmp = tmp ^ tmp >> 3 ^ tmp >> 6;
+        tmp = tmp ^ tmp >> 9;
+        /* Last 16 rounds */
+        tmp = tmp ^ tmp << 13 ^ key;
+        tmp = tmp ^ tmp >> 3 ^ tmp >> 6;
+        return tmp ^ tmp >> 9;
+}
+/* To allow for hash collisions, filter search continues at these
+ * increments from the first possible entry selected by the hash. */
+static u16 efx_filter_increment(u32 key)
+{
+        return key * 2 - 1;
+}
+static enum efx_filter_table_id
+efx_filter_spec_table_id(const struct efx_filter_spec *spec)
+{
+        BUILD_BUG_ON(EFX_FILTER_TABLE_RX_IP != (EFX_FILTER_TCP_FULL >> 2));
+        BUILD_BUG_ON(EFX_FILTER_TABLE_RX_IP != (EFX_FILTER_TCP_WILD >> 2));
+        BUILD_BUG_ON(EFX_FILTER_TABLE_RX_IP != (EFX_FILTER_UDP_FULL >> 2));
+        BUILD_BUG_ON(EFX_FILTER_TABLE_RX_IP != (EFX_FILTER_UDP_WILD >> 2));
+        BUILD_BUG_ON(EFX_FILTER_TABLE_RX_MAC != (EFX_FILTER_MAC_FULL >> 2));
+        BUILD_BUG_ON(EFX_FILTER_TABLE_RX_MAC != (EFX_FILTER_MAC_WILD >> 2));
+        EFX_BUG_ON_PARANOID(spec->type == EFX_FILTER_UNSPEC);
+        return spec->type >> 2;
+}
+static struct efx_filter_table *
+efx_filter_spec_table(struct efx_filter_state *state,
+                      const struct efx_filter_spec *spec)
+{
+        if (spec->type == EFX_FILTER_UNSPEC)
+                return NULL;
+        else
+                return &state->table[efx_filter_spec_table_id(spec)];
+}
+static void efx_filter_table_reset_search_depth(struct efx_filter_table *table)
+{
+        memset(table->search_depth, 0, sizeof(table->search_depth));
+}
+static void efx_filter_push_rx_limits(struct efx_nic *efx)
+{
+        struct efx_filter_state *state = efx->filter_state;
+        struct efx_filter_table *table;
+        efx_oword_t filter_ctl;
+        efx_reado(efx, &filter_ctl, FR_BZ_RX_FILTER_CTL);
+        table = &state->table[EFX_FILTER_TABLE_RX_IP];
+        EFX_SET_OWORD_FIELD(filter_ctl, FRF_BZ_TCP_FULL_SRCH_LIMIT,
+                            table->search_depth[EFX_FILTER_TCP_FULL] +
+                            FILTER_CTL_SRCH_FUDGE_FULL);
+        EFX_SET_OWORD_FIELD(filter_ctl, FRF_BZ_TCP_WILD_SRCH_LIMIT,
+                            table->search_depth[EFX_FILTER_TCP_WILD] +
+                            FILTER_CTL_SRCH_FUDGE_WILD);
+        EFX_SET_OWORD_FIELD(filter_ctl, FRF_BZ_UDP_FULL_SRCH_LIMIT,
+                            table->search_depth[EFX_FILTER_UDP_FULL] +
+                            FILTER_CTL_SRCH_FUDGE_FULL);
+        EFX_SET_OWORD_FIELD(filter_ctl, FRF_BZ_UDP_WILD_SRCH_LIMIT,
+                            table->search_depth[EFX_FILTER_UDP_WILD] +
+                            FILTER_CTL_SRCH_FUDGE_WILD);
+        table = &state->table[EFX_FILTER_TABLE_RX_MAC];
+        if (table->size) {
+                EFX_SET_OWORD_FIELD(
+                        filter_ctl, FRF_CZ_ETHERNET_FULL_SEARCH_LIMIT,
+                        table->search_depth[EFX_FILTER_MAC_FULL] +
+                        FILTER_CTL_SRCH_FUDGE_FULL);
+                EFX_SET_OWORD_FIELD(
+                        filter_ctl, FRF_CZ_ETHERNET_WILDCARD_SEARCH_LIMIT,
+                        table->search_depth[EFX_FILTER_MAC_WILD] +
+                        FILTER_CTL_SRCH_FUDGE_WILD);
+        }
+        efx_writeo(efx, &filter_ctl, FR_BZ_RX_FILTER_CTL);
+}
+static inline void __efx_filter_set_ipv4(struct efx_filter_spec *spec,
+                                         __be32 host1, __be16 port1,
+                                         __be32 host2, __be16 port2)
+{
+        spec->data[0] = ntohl(host1) << 16 | ntohs(port1);
+        spec->data[1] = ntohs(port2) << 16 | ntohl(host1) >> 16;
+        spec->data[2] = ntohl(host2);
+}
+/**
+ * efx_filter_set_ipv4_local - specify IPv4 host, transport protocol and port
+ * @spec: Specification to initialise
+ * @proto: Transport layer protocol number
+ * @host: Local host address (network byte order)
+ * @port: Local port (network byte order)
+ */
+int efx_filter_set_ipv4_local(struct efx_filter_spec *spec, u8 proto,
+                              __be32 host, __be16 port)
+{
+        __be32 host1;
+        __be16 port1;
+        EFX_BUG_ON_PARANOID(!(spec->flags & EFX_FILTER_FLAG_RX));
+        /* This cannot currently be combined with other filtering */
+        if (spec->type != EFX_FILTER_UNSPEC)
+                return -EPROTONOSUPPORT;
+        if (port == 0)
+                return -EINVAL;
+        switch (proto) {
+        case IPPROTO_TCP:
+                spec->type = EFX_FILTER_TCP_WILD;
+                break;
+        case IPPROTO_UDP:
+                spec->type = EFX_FILTER_UDP_WILD;
+                break;
+        default:
+                return -EPROTONOSUPPORT;
+        }
+        /* Filter is constructed in terms of source and destination,
+         * with the odd wrinkle that the ports are swapped in a UDP
+         * wildcard filter.  We need to convert from local and remote
+         * (= zero for wildcard) addresses.
+         */
+        host1 = 0;
+        if (proto != IPPROTO_UDP) {
+                port1 = 0;
+        } else {
+                port1 = port;
+                port = 0;
+        }
+        __efx_filter_set_ipv4(spec, host1, port1, host, port);
+        return 0;
+}
+/**
+ * efx_filter_set_ipv4_full - specify IPv4 hosts, transport protocol and ports
+ * @spec: Specification to initialise
+ * @proto: Transport layer protocol number
+ * @host: Local host address (network byte order)
+ * @port: Local port (network byte order)
+ * @rhost: Remote host address (network byte order)
+ * @rport: Remote port (network byte order)
+ */
+int efx_filter_set_ipv4_full(struct efx_filter_spec *spec, u8 proto,
+                             __be32 host, __be16 port,
+                             __be32 rhost, __be16 rport)
+{
+        EFX_BUG_ON_PARANOID(!(spec->flags & EFX_FILTER_FLAG_RX));
+        /* This cannot currently be combined with other filtering */
+        if (spec->type != EFX_FILTER_UNSPEC)
+                return -EPROTONOSUPPORT;
+        if (port == 0 || rport == 0)
+                return -EINVAL;
+        switch (proto) {
+        case IPPROTO_TCP:
+                spec->type = EFX_FILTER_TCP_FULL;
+                break;
+        case IPPROTO_UDP:
+                spec->type = EFX_FILTER_UDP_FULL;
+                break;
+        default:
+                return -EPROTONOSUPPORT;
+        }
+        __efx_filter_set_ipv4(spec, rhost, rport, host, port);
+        return 0;
+}
+/**
+ * efx_filter_set_eth_local - specify local Ethernet address and optional VID
+ * @spec: Specification to initialise
+ * @vid: VLAN ID to match, or %EFX_FILTER_VID_UNSPEC
+ * @addr: Local Ethernet MAC address
+ */
+int efx_filter_set_eth_local(struct efx_filter_spec *spec,
+                             u16 vid, const u8 *addr)
+{
+        EFX_BUG_ON_PARANOID(!(spec->flags & EFX_FILTER_FLAG_RX));
+        /* This cannot currently be combined with other filtering */
+        if (spec->type != EFX_FILTER_UNSPEC)
+                return -EPROTONOSUPPORT;
+        if (vid == EFX_FILTER_VID_UNSPEC) {
+                spec->type = EFX_FILTER_MAC_WILD;
+                spec->data[0] = 0;
+        } else {
+                spec->type = EFX_FILTER_MAC_FULL;
+                spec->data[0] = vid;
+        }
+        spec->data[1] = addr[2] << 24 | addr[3] << 16 | addr[4] << 8 | addr[5];
+        spec->data[2] = addr[0] << 8 | addr[1];
+        return 0;
+}
+/* Build a filter entry and return its n-tuple key. */
+static u32 efx_filter_build(efx_oword_t *filter, struct efx_filter_spec *spec)
+{
+        u32 data3;
+        switch (efx_filter_spec_table_id(spec)) {
+        case EFX_FILTER_TABLE_RX_IP: {
+                bool is_udp = (spec->type == EFX_FILTER_UDP_FULL ||
+                               spec->type == EFX_FILTER_UDP_WILD);
+                EFX_POPULATE_OWORD_7(
+                        *filter,
+                        FRF_BZ_RSS_EN,
+                        !!(spec->flags & EFX_FILTER_FLAG_RX_RSS),
+                        FRF_BZ_SCATTER_EN,
+                        !!(spec->flags & EFX_FILTER_FLAG_RX_SCATTER),
+                        FRF_BZ_TCP_UDP, is_udp,
+                        FRF_BZ_RXQ_ID, spec->dmaq_id,
+                        EFX_DWORD_2, spec->data[2],
+                        EFX_DWORD_1, spec->data[1],
+                        EFX_DWORD_0, spec->data[0]);
+                data3 = is_udp;
+                break;
+        }
+        case EFX_FILTER_TABLE_RX_MAC: {
+                bool is_wild = spec->type == EFX_FILTER_MAC_WILD;
+                EFX_POPULATE_OWORD_8(
+                        *filter,
+                        FRF_CZ_RMFT_RSS_EN,
+                        !!(spec->flags & EFX_FILTER_FLAG_RX_RSS),
+                        FRF_CZ_RMFT_SCATTER_EN,
+                        !!(spec->flags & EFX_FILTER_FLAG_RX_SCATTER),
+                        FRF_CZ_RMFT_IP_OVERRIDE,
+                        !!(spec->flags & EFX_FILTER_FLAG_RX_OVERRIDE_IP),
+                        FRF_CZ_RMFT_RXQ_ID, spec->dmaq_id,
+                        FRF_CZ_RMFT_WILDCARD_MATCH, is_wild,
+                        FRF_CZ_RMFT_DEST_MAC_HI, spec->data[2],
+                        FRF_CZ_RMFT_DEST_MAC_LO, spec->data[1],
+                        FRF_CZ_RMFT_VLAN_ID, spec->data[0]);
+                data3 = is_wild;
+                break;
+        }
+        default:
+                BUG();
+        }
+        return spec->data[0] ^ spec->data[1] ^ spec->data[2] ^ data3;
+}
+static bool efx_filter_equal(const struct efx_filter_spec *left,
+                             const struct efx_filter_spec *right)
+{
+        if (left->type != right->type ||
+            memcmp(left->data, right->data, sizeof(left->data)))
+                return false;
+        return true;
+}
+static int efx_filter_search(struct efx_filter_table *table,
+                             struct efx_filter_spec *spec, u32 key,
+                             bool for_insert, int *depth_required)
+{
+        unsigned hash, incr, filter_idx, depth, depth_max;
+        struct efx_filter_spec *cmp;
+        hash = efx_filter_hash(key);
+        incr = efx_filter_increment(key);
+        depth_max = (spec->priority <= EFX_FILTER_PRI_HINT ?
+                     FILTER_CTL_SRCH_HINT_MAX : FILTER_CTL_SRCH_MAX);
+        for (depth = 1, filter_idx = hash & (table->size - 1);
+             depth <= depth_max && test_bit(filter_idx, table->used_bitmap);
+             ++depth) {
+                cmp = &table->spec[filter_idx];
+                if (efx_filter_equal(spec, cmp))
+                        goto found;
+                filter_idx = (filter_idx + incr) & (table->size - 1);
+        }
+        if (!for_insert)
+                return -ENOENT;
+        if (depth > depth_max)
+                return -EBUSY;
+found:
+        *depth_required = depth;
+        return filter_idx;
+}
+/* Construct/deconstruct external filter IDs */
+static inline int
+efx_filter_make_id(enum efx_filter_table_id table_id, unsigned index)
+{
+        return table_id << 16 | index;
+}
+/**
+ * efx_filter_insert_filter - add or replace a filter
+ * @efx: NIC in which to insert the filter
+ * @spec: Specification for the filter
+ * @replace: Flag for whether the specified filter may replace a filter
+ *      with an identical match expression and equal or lower priority
+ *
+ * On success, return the filter ID.
+ * On failure, return a negative error code.
+ */
+int efx_filter_insert_filter(struct efx_nic *efx, struct efx_filter_spec *spec,
+                             bool replace)
+{
+        struct efx_filter_state *state = efx->filter_state;
+        struct efx_filter_table *table = efx_filter_spec_table(state, spec);
+        struct efx_filter_spec *saved_spec;
+        efx_oword_t filter;
+        int filter_idx, depth;
+        u32 key;
+        int rc;
+        if (!table || table->size == 0)
+                return -EINVAL;
+        key = efx_filter_build(&filter, spec);
+        netif_vdbg(efx, hw, efx->net_dev,
+                   "%s: type %d search_depth=%d", __func__, spec->type,
+                   table->search_depth[spec->type]);
+        spin_lock_bh(&state->lock);
+        rc = efx_filter_search(table, spec, key, true, &depth);
+        if (rc < 0)
+                goto out;
+        filter_idx = rc;
+        BUG_ON(filter_idx >= table->size);
+        saved_spec = &table->spec[filter_idx];
+        if (test_bit(filter_idx, table->used_bitmap)) {
+                /* Should we replace the existing filter? */
+                if (!replace) {
+                        rc = -EEXIST;
+                        goto out;
+                }
+                if (spec->priority < saved_spec->priority) {
+                        rc = -EPERM;
+                        goto out;
+                }
+        } else {
+                __set_bit(filter_idx, table->used_bitmap);
+                ++table->used;
+        }
+        *saved_spec = *spec;
+        if (table->search_depth[spec->type] < depth) {
+                table->search_depth[spec->type] = depth;
+                efx_filter_push_rx_limits(efx);
+        }
+        efx_writeo(efx, &filter, table->offset + table->step * filter_idx);
+        netif_vdbg(efx, hw, efx->net_dev,
+                   "%s: filter type %d index %d rxq %u set",
+                   __func__, spec->type, filter_idx, spec->dmaq_id);
+        rc = efx_filter_make_id(table->id, filter_idx);
+out:
+        spin_unlock_bh(&state->lock);
+        return rc;
+}
+static void efx_filter_table_clear_entry(struct efx_nic *efx,
+                                         struct efx_filter_table *table,
+                                         int filter_idx)
+{
+        static efx_oword_t filter;
+        if (test_bit(filter_idx, table->used_bitmap)) {
+                __clear_bit(filter_idx, table->used_bitmap);
+                --table->used;
+                memset(&table->spec[filter_idx], 0, sizeof(table->spec[0]));
+                efx_writeo(efx, &filter,
+                           table->offset + table->step * filter_idx);
+        }
+}
+/**
+ * efx_filter_remove_filter - remove a filter by specification
+ * @efx: NIC from which to remove the filter
+ * @spec: Specification for the filter
+ *
+ * On success, return zero.
+ * On failure, return a negative error code.
+ */
+int efx_filter_remove_filter(struct efx_nic *efx, struct efx_filter_spec *spec)
+{
+        struct efx_filter_state *state = efx->filter_state;
+        struct efx_filter_table *table = efx_filter_spec_table(state, spec);
+        struct efx_filter_spec *saved_spec;
+        efx_oword_t filter;
+        int filter_idx, depth;
+        u32 key;
+        int rc;
+        if (!table)
+                return -EINVAL;
+        key = efx_filter_build(&filter, spec);
+        spin_lock_bh(&state->lock);
+        rc = efx_filter_search(table, spec, key, false, &depth);
+        if (rc < 0)
+                goto out;
+        filter_idx = rc;
+        saved_spec = &table->spec[filter_idx];
+        if (spec->priority < saved_spec->priority) {
+                rc = -EPERM;
+                goto out;
+        }
+        efx_filter_table_clear_entry(efx, table, filter_idx);
+        if (table->used == 0)
+                efx_filter_table_reset_search_depth(table);
+        rc = 0;
+out:
+        spin_unlock_bh(&state->lock);
+        return rc;
+}
+static void efx_filter_table_clear(struct efx_nic *efx,
+                                   enum efx_filter_table_id table_id,
+                                   enum efx_filter_priority priority)
+{
+        struct efx_filter_state *state = efx->filter_state;
+        struct efx_filter_table *table = &state->table[table_id];
+        int filter_idx;
+        spin_lock_bh(&state->lock);
+        for (filter_idx = 0; filter_idx < table->size; ++filter_idx)
+                if (table->spec[filter_idx].priority <= priority)
+                        efx_filter_table_clear_entry(efx, table, filter_idx);
+        if (table->used == 0)
+                efx_filter_table_reset_search_depth(table);
+        spin_unlock_bh(&state->lock);
+}
+/**
+ * efx_filter_clear_rx - remove RX filters by priority
+ * @efx: NIC from which to remove the filters
+ * @priority: Maximum priority to remove
+ */
+void efx_filter_clear_rx(struct efx_nic *efx, enum efx_filter_priority priority)
+{
+        efx_filter_table_clear(efx, EFX_FILTER_TABLE_RX_IP, priority);
+        efx_filter_table_clear(efx, EFX_FILTER_TABLE_RX_MAC, priority);
+}
+/* Restore filter stater after reset */
+void efx_restore_filters(struct efx_nic *efx)
+{
+        struct efx_filter_state *state = efx->filter_state;
+        enum efx_filter_table_id table_id;
+        struct efx_filter_table *table;
+        efx_oword_t filter;
+        int filter_idx;
+        spin_lock_bh(&state->lock);
+        for (table_id = 0; table_id < EFX_FILTER_TABLE_COUNT; table_id++) {
+                table = &state->table[table_id];
+                for (filter_idx = 0; filter_idx < table->size; filter_idx++) {
+                        if (!test_bit(filter_idx, table->used_bitmap))
+                                continue;
+                        efx_filter_build(&filter, &table->spec[filter_idx]);
+                        efx_writeo(efx, &filter,
+                                   table->offset + table->step * filter_idx);
+                }
+        }
+        efx_filter_push_rx_limits(efx);
+        spin_unlock_bh(&state->lock);
+}
+int efx_probe_filters(struct efx_nic *efx)
+{
+        struct efx_filter_state *state;
+        struct efx_filter_table *table;
+        unsigned table_id;
+        state = kzalloc(sizeof(*efx->filter_state), GFP_KERNEL);
+        if (!state)
+                return -ENOMEM;
+        efx->filter_state = state;
+        spin_lock_init(&state->lock);
+        if (efx_nic_rev(efx) >= EFX_REV_FALCON_B0) {
+#ifdef CONFIG_RFS_ACCEL
+                state->rps_flow_id = kcalloc(FR_BZ_RX_FILTER_TBL0_ROWS,
+                                             sizeof(*state->rps_flow_id),
+                                             GFP_KERNEL);
+                if (!state->rps_flow_id)
+                        goto fail;
+#endif
+                table = &state->table[EFX_FILTER_TABLE_RX_IP];
+                table->id = EFX_FILTER_TABLE_RX_IP;
+                table->offset = FR_BZ_RX_FILTER_TBL0;
+                table->size = FR_BZ_RX_FILTER_TBL0_ROWS;
+                table->step = FR_BZ_RX_FILTER_TBL0_STEP;
+        }
+        if (efx_nic_rev(efx) >= EFX_REV_SIENA_A0) {
+                table = &state->table[EFX_FILTER_TABLE_RX_MAC];
+                table->id = EFX_FILTER_TABLE_RX_MAC;
+                table->offset = FR_CZ_RX_MAC_FILTER_TBL0;
+                table->size = FR_CZ_RX_MAC_FILTER_TBL0_ROWS;
+                table->step = FR_CZ_RX_MAC_FILTER_TBL0_STEP;
+        }
+        for (table_id = 0; table_id < EFX_FILTER_TABLE_COUNT; table_id++) {
+                table = &state->table[table_id];
+                if (table->size == 0)
+                        continue;
+                table->used_bitmap = kcalloc(BITS_TO_LONGS(table->size),
+                                             sizeof(unsigned long),
+                                             GFP_KERNEL);
+                if (!table->used_bitmap)
+                        goto fail;
+                table->spec = vzalloc(table->size * sizeof(*table->spec));
+                if (!table->spec)
+                        goto fail;
+        }
+        return 0;
+fail:
+        efx_remove_filters(efx);
+        return -ENOMEM;
+}
+void efx_remove_filters(struct efx_nic *efx)
+{
+        struct efx_filter_state *state = efx->filter_state;
+        enum efx_filter_table_id table_id;
+        for (table_id = 0; table_id < EFX_FILTER_TABLE_COUNT; table_id++) {
+                kfree(state->table[table_id].used_bitmap);
+                vfree(state->table[table_id].spec);
+        }
+#ifdef CONFIG_RFS_ACCEL
+        kfree(state->rps_flow_id);
+#endif
+        kfree(state);
+}
+#ifdef CONFIG_RFS_ACCEL
+int efx_filter_rfs(struct net_device *net_dev, const struct sk_buff *skb,
+                   u16 rxq_index, u32 flow_id)
+{
+        struct efx_nic *efx = netdev_priv(net_dev);
+        struct efx_channel *channel;
+        struct efx_filter_state *state = efx->filter_state;
+        struct efx_filter_spec spec;
+        const struct iphdr *ip;
+        const __be16 *ports;
+        int nhoff;
+        int rc;
+        nhoff = skb_network_offset(skb);
+        if (skb->protocol != htons(ETH_P_IP))
+                return -EPROTONOSUPPORT;
+        /* RFS must validate the IP header length before calling us */
+        EFX_BUG_ON_PARANOID(!pskb_may_pull(skb, nhoff + sizeof(*ip)));
+        ip = (const struct iphdr *)(skb->data + nhoff);
+        if (ip->frag_off & htons(IP_MF | IP_OFFSET))
+                return -EPROTONOSUPPORT;
+        EFX_BUG_ON_PARANOID(!pskb_may_pull(skb, nhoff + 4 * ip->ihl + 4));
+        ports = (const __be16 *)(skb->data + nhoff + 4 * ip->ihl);
+        efx_filter_init_rx(&spec, EFX_FILTER_PRI_HINT, 0, rxq_index);
+        rc = efx_filter_set_ipv4_full(&spec, ip->protocol,
+                                      ip->daddr, ports[1], ip->saddr, ports[0]);
+        if (rc)
+                return rc;
+        rc = efx_filter_insert_filter(efx, &spec, true);
+        if (rc < 0)
+                return rc;
+        /* Remember this so we can check whether to expire the filter later */
+        state->rps_flow_id[rc] = flow_id;
+        channel = efx_get_channel(efx, skb_get_rx_queue(skb));
+        ++channel->rfs_filters_added;
+        netif_info(efx, rx_status, efx->net_dev,
+                   "steering %s %pI4:%u:%pI4:%u to queue %u [flow %u filter %d]\n",
+                   (ip->protocol == IPPROTO_TCP) ? "TCP" : "UDP",
+                   &ip->saddr, ntohs(ports[0]), &ip->daddr, ntohs(ports[1]),
+                   rxq_index, flow_id, rc);
+        return rc;
+}
+bool __efx_filter_rfs_expire(struct efx_nic *efx, unsigned quota)
+{
+        struct efx_filter_state *state = efx->filter_state;
+        struct efx_filter_table *table = &state->table[EFX_FILTER_TABLE_RX_IP];
+        unsigned mask = table->size - 1;
+        unsigned index;
+        unsigned stop;
+        if (!spin_trylock_bh(&state->lock))
+                return false;
+        index = state->rps_expire_index;
+        stop = (index + quota) & mask;
+        while (index != stop) {
+                if (test_bit(index, table->used_bitmap) &&
+                    table->spec[index].priority == EFX_FILTER_PRI_HINT &&
+                    rps_may_expire_flow(efx->net_dev,
+                                        table->spec[index].dmaq_id,
+                                        state->rps_flow_id[index], index)) {
+                        netif_info(efx, rx_status, efx->net_dev,
+                                   "expiring filter %d [flow %u]\n",
+                                   index, state->rps_flow_id[index]);
+                        efx_filter_table_clear_entry(efx, table, index);
+                }
+                index = (index + 1) & mask;
+        }
+        state->rps_expire_index = stop;
+        if (table->used == 0)
+                efx_filter_table_reset_search_depth(table);
+        spin_unlock_bh(&state->lock);
+        return true;
+}
+#endif /* CONFIG_RFS_ACCEL */
diff --git a/drivers/net/sfc/filter.h b/drivers/net/sfc/filter.h
new file mode 100644
index 000000000000..872f2132a496
--- /dev/null
+++ b/drivers/net/sfc/filter.h
@@ -0,0 +1,112 @@
+/****************************************************************************
+ * Driver for Solarflare Solarstorm network controllers and boards
+ * Copyright 2005-2010 Solarflare Communications Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published
+ * by the Free Software Foundation, incorporated herein by reference.
+ */
+#ifndef EFX_FILTER_H
+#define EFX_FILTER_H
+#include <linux/types.h>
+/**
+ * enum efx_filter_type - type of hardware filter
+ * @EFX_FILTER_TCP_FULL: Matching TCP/IPv4 4-tuple
+ * @EFX_FILTER_TCP_WILD: Matching TCP/IPv4 destination (host, port)
+ * @EFX_FILTER_UDP_FULL: Matching UDP/IPv4 4-tuple
+ * @EFX_FILTER_UDP_WILD: Matching UDP/IPv4 destination (host, port)
+ * @EFX_FILTER_MAC_FULL: Matching Ethernet destination MAC address, VID
+ * @EFX_FILTER_MAC_WILD: Matching Ethernet destination MAC address
+ * @EFX_FILTER_UNSPEC: Match type is unspecified
+ *
+ * Falcon NICs only support the TCP/IPv4 and UDP/IPv4 filter types.
+ */
+enum efx_filter_type {
+        EFX_FILTER_TCP_FULL = 0,
+        EFX_FILTER_TCP_WILD,
+        EFX_FILTER_UDP_FULL,
+        EFX_FILTER_UDP_WILD,
+        EFX_FILTER_MAC_FULL = 4,
+        EFX_FILTER_MAC_WILD,
+        EFX_FILTER_TYPE_COUNT,          /* number of specific types */
+        EFX_FILTER_UNSPEC = 0xf,
+};
+/**
+ * enum efx_filter_priority - priority of a hardware filter specification
+ * @EFX_FILTER_PRI_HINT: Performance hint
+ * @EFX_FILTER_PRI_MANUAL: Manually configured filter
+ * @EFX_FILTER_PRI_REQUIRED: Required for correct behaviour
+ */
+enum efx_filter_priority {
+        EFX_FILTER_PRI_HINT = 0,
+        EFX_FILTER_PRI_MANUAL,
+        EFX_FILTER_PRI_REQUIRED,
+};
+/**
+ * enum efx_filter_flags - flags for hardware filter specifications
+ * @EFX_FILTER_FLAG_RX_RSS: Use RSS to spread across multiple queues.
+ *      By default, matching packets will be delivered only to the
+ *      specified queue. If this flag is set, they will be delivered
+ *      to a range of queues offset from the specified queue number
+ *      according to the indirection table.
+ * @EFX_FILTER_FLAG_RX_SCATTER: Enable DMA scatter on the receiving
+ *      queue.
+ * @EFX_FILTER_FLAG_RX_OVERRIDE_IP: Enables a MAC filter to override
+ *      any IP filter that matches the same packet.  By default, IP
+ *      filters take precedence.
+ * @EFX_FILTER_FLAG_RX: Filter is for RX
+ */
+enum efx_filter_flags {
+        EFX_FILTER_FLAG_RX_RSS = 0x01,
+        EFX_FILTER_FLAG_RX_SCATTER = 0x02,
+        EFX_FILTER_FLAG_RX_OVERRIDE_IP = 0x04,
+        EFX_FILTER_FLAG_RX = 0x08,
+};
+/**
+ * struct efx_filter_spec - specification for a hardware filter
+ * @type: Type of match to be performed, from &enum efx_filter_type
+ * @priority: Priority of the filter, from &enum efx_filter_priority
+ * @flags: Miscellaneous flags, from &enum efx_filter_flags
+ * @dmaq_id: Source/target queue index
+ * @data: Match data (type-dependent)
+ *
+ * Use the efx_filter_set_*() functions to initialise the @type and
+ * @data fields.
+ */
+struct efx_filter_spec {
+        u8      type:4;
+        u8      priority:4;
+        u8      flags;
+        u16     dmaq_id;
+        u32     data[3];
+};
+static inline void efx_filter_init_rx(struct efx_filter_spec *spec,
+                                      enum efx_filter_priority priority,
+                                      enum efx_filter_flags flags,
+                                      unsigned rxq_id)
+{
+        spec->type = EFX_FILTER_UNSPEC;
+        spec->priority = priority;
+        spec->flags = EFX_FILTER_FLAG_RX | flags;
+        spec->dmaq_id = rxq_id;
+}
+extern int efx_filter_set_ipv4_local(struct efx_filter_spec *spec, u8 proto,
+                                     __be32 host, __be16 port);
+extern int efx_filter_set_ipv4_full(struct efx_filter_spec *spec, u8 proto,
+                                    __be32 host, __be16 port,
+                                    __be32 rhost, __be16 rport);
+extern int efx_filter_set_eth_local(struct efx_filter_spec *spec,
+                                    u16 vid, const u8 *addr);
+enum {
+        EFX_FILTER_VID_UNSPEC = 0xffff,
+};
+#endif /* EFX_FILTER_H */
diff --git a/drivers/net/sfc/io.h b/drivers/net/sfc/io.h
index 85a99fe87437..cc978803d484 100644
--- a/drivers/net/sfc/io.h
+++ b/drivers/net/sfc/io.h
@@ -1,7 +1,7 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
 * Copyright 2005-2006 Fen Systems Ltd.
- * Copyright 2006-2009 Solarflare Communications Inc.
+ * Copyright 2006-2010 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -22,28 +22,39 @@
 *
 * Notes on locking strategy:
 *
- * Most NIC registers require 16-byte (or 8-byte, for SRAM) atomic writes
+ * Most CSRs are 128-bit (oword) and therefore cannot be read or
- * which necessitates locking.
+ * written atomically.  Access from the host is buffered by the Bus
- * Under normal operation few writes to NIC registers are made and these
+ * Interface Unit (BIU).  Whenever the host reads from the lowest
- * registers (EVQ_RPTR_REG, RX_DESC_UPD_REG and TX_DESC_UPD_REG) are special
+ * address of such a register, or from the address of a different such
- * cased to allow 4-byte (hence lockless) accesses.
+ * register, the BIU latches the register's value.  Subsequent reads
+ * from higher addresses of the same register will read the latched
+ * value.  Whenever the host writes part of such a register, the BIU
+ * collects the written value and does not write to the underlying
+ * register until all 4 dwords have been written.  A similar buffering
+ * scheme applies to host access to the NIC's 64-bit SRAM.
 *
- * It *is* safe to write to these 4-byte registers in the middle of an
+ * Access to different CSRs and 64-bit SRAM words must be serialised,
- * access to an 8-byte or 16-byte register.  We therefore use a
+ * since interleaved access can result in lost writes or lost
- * spinlock to protect accesses to the larger registers, but no locks
+ * information from read-to-clear fields.  We use efx_nic::biu_lock
- * for the 4-byte registers.
+ * for this.  (We could use separate locks for read and write, but
+ * this is not normally a performance bottleneck.)
 *
- * A write barrier is needed to ensure that DW3 is written after DW0/1/2
+ * The DMA descriptor pointers (RX_DESC_UPD and TX_DESC_UPD) are
- * due to the way the 16byte registers are "collected" in the BIU.
+ * 128-bit but are special-cased in the BIU to avoid the need for
+ * locking in the host:
 *
- * We also lock when carrying out reads, to ensure consistency of the
+ * - They are write-only.
- * data (made possible since the BIU reads all 128 bits into a cache).
+ * - The semantics of writing to these registers are such that
- * Reads are very rare, so this isn't a significant performance
+ *   replacing the low 96 bits with zero does not affect functionality.
- * impact.  (Most data transferred from NIC to host is DMAed directly
+ * - If the host writes to the last dword address of such a register
- * into host memory).
+ *   (i.e. the high 32 bits) the underlying register will always be
- *
+ *   written.  If the collector and the current write together do not
- * I/O BAR access uses locks for both reads and writes (but is only provided
+ *   provide values for all 128 bits of the register, the low 96 bits
- * for testing purposes).
+ *   will be written as zero.
+ * - If the host writes to the address of any other part of such a
+ *   register while the collector already holds values for some other
+ *   register, the write is discarded and the collector maintains its
+ *   current state.
 */
 #if BITS_PER_LONG == 64
@@ -72,7 +83,7 @@ static inline __le32 _efx_readd(struct efx_nic *efx, unsigned int reg)
        return (__force __le32)__raw_readl(efx->membase + reg);
 }
-/* Writes to a normal 16-byte Efx register, locking as appropriate. */
+/* Write a normal 128-bit CSR, locking as appropriate. */
 static inline void efx_writeo(struct efx_nic *efx, efx_oword_t *value,
                              unsigned int reg)
 {
@@ -85,21 +96,19 @@ static inline void efx_writeo(struct efx_nic *efx, efx_oword_t *value,
        spin_lock_irqsave(&efx->biu_lock, flags);
 #ifdef EFX_USE_QWORD_IO
        _efx_writeq(efx, value->u64[0], reg + 0);
-        wmb();
        _efx_writeq(efx, value->u64[1], reg + 8);
 #else
        _efx_writed(efx, value->u32[0], reg + 0);
        _efx_writed(efx, value->u32[1], reg + 4);
        _efx_writed(efx, value->u32[2], reg + 8);
-        wmb();
        _efx_writed(efx, value->u32[3], reg + 12);
 #endif
+        wmb();
        mmiowb();
        spin_unlock_irqrestore(&efx->biu_lock, flags);
 }
-/* Write an 8-byte NIC SRAM entry through the supplied mapping,
+/* Write 64-bit SRAM through the supplied mapping, locking as appropriate. */
- * locking as appropriate. */
 static inline void efx_sram_writeq(struct efx_nic *efx, void __iomem *membase,
                                   efx_qword_t *value, unsigned int index)
 {
@@ -115,36 +124,27 @@ static inline void efx_sram_writeq(struct efx_nic *efx, void __iomem *membase,
        __raw_writeq((__force u64)value->u64[0], membase + addr);
 #else
        __raw_writel((__force u32)value->u32[0], membase + addr);
-        wmb();
        __raw_writel((__force u32)value->u32[1], membase + addr + 4);
 #endif
+        wmb();
        mmiowb();
        spin_unlock_irqrestore(&efx->biu_lock, flags);
 }
-/* Write dword to NIC register that allows partial writes
+/* Write a 32-bit CSR or the last dword of a special 128-bit CSR */
- *
- * Some registers (EVQ_RPTR_REG, RX_DESC_UPD_REG and
- * TX_DESC_UPD_REG) can be written to as a single dword.  This allows
- * for lockless writes.
- */
 static inline void efx_writed(struct efx_nic *efx, efx_dword_t *value,
                              unsigned int reg)
 {
        netif_vdbg(efx, hw, efx->net_dev,
-                   "writing partial register %x with "EFX_DWORD_FMT"\n",
+                   "writing register %x with "EFX_DWORD_FMT"\n",
                   reg, EFX_DWORD_VAL(*value));
        /* No lock required */
        _efx_writed(efx, value->u32[0], reg);
+        wmb();
 }
-/* Read from a NIC register
+/* Read a 128-bit CSR, locking as appropriate. */
- *
- * This reads an entire 16-byte register in one go, locking as
- * appropriate.  It is essential to read the first dword first, as this
- * prompts the NIC to load the current value into the shadow register.
- */
 static inline void efx_reado(struct efx_nic *efx, efx_oword_t *value,
                             unsigned int reg)
 {
@@ -163,8 +163,7 @@ static inline void efx_reado(struct efx_nic *efx, efx_oword_t *value,
                   EFX_OWORD_VAL(*value));
 }
-/* Read an 8-byte SRAM entry through supplied mapping,
+/* Read 64-bit SRAM through the supplied mapping, locking as appropriate. */
- * locking as appropriate. */
 static inline void efx_sram_readq(struct efx_nic *efx, void __iomem *membase,
                                  efx_qword_t *value, unsigned int index)
 {
@@ -186,7 +185,7 @@ static inline void efx_sram_readq(struct efx_nic *efx, void __iomem *membase,
                   addr, EFX_QWORD_VAL(*value));
 }
-/* Read dword from register that allows partial writes (sic) */
+/* Read a 32-bit CSR or SRAM */
 static inline void efx_readd(struct efx_nic *efx, efx_dword_t *value,
                                unsigned int reg)
 {
@@ -196,28 +195,28 @@ static inline void efx_readd(struct efx_nic *efx, efx_dword_t *value,
                   reg, EFX_DWORD_VAL(*value));
 }
-/* Write to a register forming part of a table */
+/* Write a 128-bit CSR forming part of a table */
 static inline void efx_writeo_table(struct efx_nic *efx, efx_oword_t *value,
                                      unsigned int reg, unsigned int index)
 {
        efx_writeo(efx, value, reg + index * sizeof(efx_oword_t));
 }
-/* Read to a register forming part of a table */
+/* Read a 128-bit CSR forming part of a table */
 static inline void efx_reado_table(struct efx_nic *efx, efx_oword_t *value,
                                     unsigned int reg, unsigned int index)
 {
        efx_reado(efx, value, reg + index * sizeof(efx_oword_t));
 }
-/* Write to a dword register forming part of a table */
+/* Write a 32-bit CSR forming part of a table, or 32-bit SRAM */
 static inline void efx_writed_table(struct efx_nic *efx, efx_dword_t *value,
                                       unsigned int reg, unsigned int index)
 {
        efx_writed(efx, value, reg + index * sizeof(efx_oword_t));
 }
-/* Read from a dword register forming part of a table */
+/* Read a 32-bit CSR forming part of a table, or 32-bit SRAM */
 static inline void efx_readd_table(struct efx_nic *efx, efx_dword_t *value,
                                   unsigned int reg, unsigned int index)
 {
@@ -231,29 +230,56 @@ static inline void efx_readd_table(struct efx_nic *efx, efx_dword_t *value,
 #define EFX_PAGED_REG(page, reg) \
        ((page) * EFX_PAGE_BLOCK_SIZE + (reg))
-/* As for efx_writeo(), but for a page-mapped register. */
+/* Write the whole of RX_DESC_UPD or TX_DESC_UPD */
-static inline void efx_writeo_page(struct efx_nic *efx, efx_oword_t *value,
+static inline void _efx_writeo_page(struct efx_nic *efx, efx_oword_t *value,
-                                   unsigned int reg, unsigned int page)
+                                    unsigned int reg, unsigned int page)
 {
-        efx_writeo(efx, value, EFX_PAGED_REG(page, reg));
+        reg = EFX_PAGED_REG(page, reg);
-}
+        netif_vdbg(efx, hw, efx->net_dev,
+                   "writing register %x with " EFX_OWORD_FMT "\n", reg,
+                   EFX_OWORD_VAL(*value));
-/* As for efx_writed(), but for a page-mapped register. */
+#ifdef EFX_USE_QWORD_IO
-static inline void efx_writed_page(struct efx_nic *efx, efx_dword_t *value,
+        _efx_writeq(efx, value->u64[0], reg + 0);
-                                   unsigned int reg, unsigned int page)
+        _efx_writeq(efx, value->u64[1], reg + 8);
+#else
+        _efx_writed(efx, value->u32[0], reg + 0);
+        _efx_writed(efx, value->u32[1], reg + 4);
+        _efx_writed(efx, value->u32[2], reg + 8);
+        _efx_writed(efx, value->u32[3], reg + 12);
+#endif
+        wmb();
+}
+#define efx_writeo_page(efx, value, reg, page)                          \
+        _efx_writeo_page(efx, value,                                    \
+                         reg +                                          \
+                         BUILD_BUG_ON_ZERO((reg) != 0x830 && (reg) != 0xa10), \
+                         page)
+/* Write a page-mapped 32-bit CSR (EVQ_RPTR or the high bits of
+ * RX_DESC_UPD or TX_DESC_UPD)
+ */
+static inline void _efx_writed_page(struct efx_nic *efx, efx_dword_t *value,
+                                    unsigned int reg, unsigned int page)
 {
        efx_writed(efx, value, EFX_PAGED_REG(page, reg));
 }
+#define efx_writed_page(efx, value, reg, page)                          \
-/* Write dword to page-mapped register with an extra lock.
+        _efx_writed_page(efx, value,                                    \
- *
+                         reg +                                          \
- * As for efx_writed_page(), but for a register that suffers from
+                         BUILD_BUG_ON_ZERO((reg) != 0x400 && (reg) != 0x83c \
- * SFC bug 3181. Take out a lock so the BIU collector cannot be
+                                           && (reg) != 0xa1c),          \
- * confused. */
+                         page)
-static inline void efx_writed_page_locked(struct efx_nic *efx,
-                                          efx_dword_t *value,
+/* Write TIMER_COMMAND.  This is a page-mapped 32-bit CSR, but a bug
-                                          unsigned int reg,
+ * in the BIU means that writes to TIMER_COMMAND[0] invalidate the
-                                          unsigned int page)
+ * collector register.
+ */
+static inline void _efx_writed_page_locked(struct efx_nic *efx,
+                                           efx_dword_t *value,
+                                           unsigned int reg,
+                                           unsigned int page)
 {
        unsigned long flags __attribute__ ((unused));
@@ -265,5 +291,9 @@ static inline void efx_writed_page_locked(struct efx_nic *efx,
                efx_writed(efx, value, EFX_PAGED_REG(page, reg));
        }
 }
+#define efx_writed_page_locked(efx, value, reg, page)                   \
+        _efx_writed_page_locked(efx, value,                             \
+                                reg + BUILD_BUG_ON_ZERO((reg) != 0x420), \
+                                page)
 #endif /* EFX_IO_H */
diff --git a/drivers/net/sfc/mac.h b/drivers/net/sfc/mac.h
index f1aa5f374890..d6a255d0856b 100644
--- a/drivers/net/sfc/mac.h
+++ b/drivers/net/sfc/mac.h
@@ -13,10 +13,8 @@
 #include "net_driver.h"
-extern struct efx_mac_operations falcon_gmac_operations;
+extern const struct efx_mac_operations falcon_xmac_operations;
-extern struct efx_mac_operations falcon_xmac_operations;
+extern const struct efx_mac_operations efx_mcdi_mac_operations;
-extern struct efx_mac_operations efx_mcdi_mac_operations;
-extern void falcon_reconfigure_xmac_core(struct efx_nic *efx);
 extern int efx_mcdi_mac_stats(struct efx_nic *efx, dma_addr_t dma_addr,
                              u32 dma_len, int enable, int clear);
diff --git a/drivers/net/sfc/mcdi.c b/drivers/net/sfc/mcdi.c
index 3912b8fed912..3dd45ed61f0a 100644
--- a/drivers/net/sfc/mcdi.c
+++ b/drivers/net/sfc/mcdi.c
@@ -1,6 +1,6 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
- * Copyright 2008-2009 Solarflare Communications Inc.
+ * Copyright 2008-2011 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -50,6 +50,20 @@ static inline struct efx_mcdi_iface *efx_mcdi(struct efx_nic *efx)
        return &nic_data->mcdi;
 }
+static inline void
+efx_mcdi_readd(struct efx_nic *efx, efx_dword_t *value, unsigned reg)
+{
+        struct siena_nic_data *nic_data = efx->nic_data;
+        value->u32[0] = (__force __le32)__raw_readl(nic_data->mcdi_smem + reg);
+}
+static inline void
+efx_mcdi_writed(struct efx_nic *efx, const efx_dword_t *value, unsigned reg)
+{
+        struct siena_nic_data *nic_data = efx->nic_data;
+        __raw_writel((__force u32)value->u32[0], nic_data->mcdi_smem + reg);
+}
 void efx_mcdi_init(struct efx_nic *efx)
 {
        struct efx_mcdi_iface *mcdi;
@@ -70,8 +84,8 @@ static void efx_mcdi_copyin(struct efx_nic *efx, unsigned cmd,
                            const u8 *inbuf, size_t inlen)
 {
        struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
-        unsigned pdu = FR_CZ_MC_TREG_SMEM + MCDI_PDU(efx);
+        unsigned pdu = MCDI_PDU(efx);
-        unsigned doorbell = FR_CZ_MC_TREG_SMEM + MCDI_DOORBELL(efx);
+        unsigned doorbell = MCDI_DOORBELL(efx);
        unsigned int i;
        efx_dword_t hdr;
        u32 xflags, seqno;
@@ -92,29 +106,28 @@ static void efx_mcdi_copyin(struct efx_nic *efx, unsigned cmd,
                             MCDI_HEADER_SEQ, seqno,
                             MCDI_HEADER_XFLAGS, xflags);
-        efx_writed(efx, &hdr, pdu);
+        efx_mcdi_writed(efx, &hdr, pdu);
        for (i = 0; i < inlen; i += 4)
-                _efx_writed(efx, *((__le32 *)(inbuf + i)), pdu + 4 + i);
+                efx_mcdi_writed(efx, (const efx_dword_t *)(inbuf + i),
+                                pdu + 4 + i);
-        /* Ensure the payload is written out before the header */
-        wmb();
        /* ring the doorbell with a distinctive value */
-        _efx_writed(efx, (__force __le32) 0x45789abc, doorbell);
+        EFX_POPULATE_DWORD_1(hdr, EFX_DWORD_0, 0x45789abc);
+        efx_mcdi_writed(efx, &hdr, doorbell);
 }
 static void efx_mcdi_copyout(struct efx_nic *efx, u8 *outbuf, size_t outlen)
 {
        struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
-        unsigned int pdu = FR_CZ_MC_TREG_SMEM + MCDI_PDU(efx);
+        unsigned int pdu = MCDI_PDU(efx);
        int i;
        BUG_ON(atomic_read(&mcdi->state) == MCDI_STATE_QUIESCENT);
        BUG_ON(outlen & 3 || outlen >= 0x100);
        for (i = 0; i < outlen; i += 4)
-                *((__le32 *)(outbuf + i)) = _efx_readd(efx, pdu + 4 + i);
+                efx_mcdi_readd(efx, (efx_dword_t *)(outbuf + i), pdu + 4 + i);
 }
 static int efx_mcdi_poll(struct efx_nic *efx)
@@ -122,7 +135,7 @@ static int efx_mcdi_poll(struct efx_nic *efx)
        struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
        unsigned int time, finish;
        unsigned int respseq, respcmd, error;
-        unsigned int pdu = FR_CZ_MC_TREG_SMEM + MCDI_PDU(efx);
+        unsigned int pdu = MCDI_PDU(efx);
        unsigned int rc, spins;
        efx_dword_t reg;
@@ -148,8 +161,7 @@ static int efx_mcdi_poll(struct efx_nic *efx)
                time = get_seconds();
-                rmb();
+                efx_mcdi_readd(efx, &reg, pdu);
-                efx_readd(efx, &reg, pdu);
                /* All 1's indicates that shared memory is in reset (and is
                 * not a valid header). Wait for it to come out reset before
@@ -176,7 +188,7 @@ static int efx_mcdi_poll(struct efx_nic *efx)
                          respseq, mcdi->seqno);
                rc = EIO;
        } else if (error) {
-                efx_readd(efx, &reg, pdu + 4);
+                efx_mcdi_readd(efx, &reg, pdu + 4);
                switch (EFX_DWORD_FIELD(reg, EFX_DWORD_0)) {
 #define TRANSLATE_ERROR(name)                                   \
                case MC_CMD_ERR_ ## name:                       \
@@ -210,21 +222,21 @@ out:
 /* Test and clear MC-rebooted flag for this port/function */
 int efx_mcdi_poll_reboot(struct efx_nic *efx)
 {
-        unsigned int addr = FR_CZ_MC_TREG_SMEM + MCDI_REBOOT_FLAG(efx);
+        unsigned int addr = MCDI_REBOOT_FLAG(efx);
        efx_dword_t reg;
        uint32_t value;
        if (efx_nic_rev(efx) < EFX_REV_SIENA_A0)
                return false;
-        efx_readd(efx, &reg, addr);
+        efx_mcdi_readd(efx, &reg, addr);
        value = EFX_DWORD_FIELD(reg, EFX_DWORD_0);
        if (value == 0)
                return 0;
        EFX_ZERO_DWORD(reg);
-        efx_writed(efx, &reg, addr);
+        efx_mcdi_writed(efx, &reg, addr);
        if (value == MC_STATUS_DWORD_ASSERT)
                return -EINTR;
@@ -381,7 +393,7 @@ int efx_mcdi_rpc(struct efx_nic *efx, unsigned cmd,
                                  -rc);
                        efx_schedule_reset(efx, RESET_TYPE_MC_FAILURE);
                } else
-                        netif_err(efx, hw, efx->net_dev,
+                        netif_dbg(efx, hw, efx->net_dev,
                                  "MC command 0x%x inlen %d failed rc=%d\n",
                                  cmd, (int)inlen, -rc);
        }
@@ -452,7 +464,7 @@ static void efx_mcdi_ev_death(struct efx_nic *efx, int rc)
         *
         * There's a race here with efx_mcdi_rpc(), because we might receive
         * a REBOOT event *before* the request has been copied out. In polled
-         * mode (during startup) this is irrelevent, because efx_mcdi_complete()
+         * mode (during startup) this is irrelevant, because efx_mcdi_complete()
         * is ignored. In event mode, this condition is just an edge-case of
         * receiving a REBOOT event after posting the MCDI request. Did the mc
         * reboot before or after the copyout? The best we can do always is
@@ -463,6 +475,7 @@ static void efx_mcdi_ev_death(struct efx_nic *efx, int rc)
                if (mcdi->mode == MCDI_MODE_EVENTS) {
                        mcdi->resprc = rc;
                        mcdi->resplen = 0;
+                        ++mcdi->credits;
                }
        } else
                /* Nobody was waiting for an MCDI request, so trigger a reset */
@@ -601,7 +614,7 @@ void efx_mcdi_process_event(struct efx_channel *channel,
 **************************************************************************
 */
-int efx_mcdi_fwver(struct efx_nic *efx, u64 *version, u32 *build)
+void efx_mcdi_print_fwver(struct efx_nic *efx, char *buf, size_t len)
 {
        u8 outbuf[ALIGN(MC_CMD_GET_VERSION_V1_OUT_LEN, 4)];
        size_t outlength;
@@ -615,29 +628,20 @@ int efx_mcdi_fwver(struct efx_nic *efx, u64 *version, u32 *build)
        if (rc)
                goto fail;
-        if (outlength == MC_CMD_GET_VERSION_V0_OUT_LEN) {
-                *version = 0;
-                *build = MCDI_DWORD(outbuf, GET_VERSION_OUT_FIRMWARE);
-                return 0;
-        }
        if (outlength < MC_CMD_GET_VERSION_V1_OUT_LEN) {
                rc = -EIO;
                goto fail;
        }
        ver_words = (__le16 *)MCDI_PTR(outbuf, GET_VERSION_OUT_VERSION);
-        *version = (((u64)le16_to_cpu(ver_words[0]) << 48) |
+        snprintf(buf, len, "%u.%u.%u.%u",
-                    ((u64)le16_to_cpu(ver_words[1]) << 32) |
+                 le16_to_cpu(ver_words[0]), le16_to_cpu(ver_words[1]),
-                    ((u64)le16_to_cpu(ver_words[2]) << 16) |
+                 le16_to_cpu(ver_words[2]), le16_to_cpu(ver_words[3]));
-                    le16_to_cpu(ver_words[3]));
+        return;
-        *build = MCDI_DWORD(outbuf, GET_VERSION_OUT_FIRMWARE);
-        return 0;
 fail:
        netif_err(efx, probe, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
-        return rc;
+        buf[0] = 0;
 }
 int efx_mcdi_drv_attach(struct efx_nic *efx, bool driver_operating,
@@ -1093,8 +1097,8 @@ int efx_mcdi_reset_mc(struct efx_nic *efx)
        return rc;
 }
-int efx_mcdi_wol_filter_set(struct efx_nic *efx, u32 type,
+static int efx_mcdi_wol_filter_set(struct efx_nic *efx, u32 type,
-                            const u8 *mac, int *id_out)
+                                   const u8 *mac, int *id_out)
 {
        u8 inbuf[MC_CMD_WOL_FILTER_SET_IN_LEN];
        u8 outbuf[MC_CMD_WOL_FILTER_SET_OUT_LEN];
diff --git a/drivers/net/sfc/mcdi.h b/drivers/net/sfc/mcdi.h
index f1f89ad4075a..aced2a7856fc 100644
--- a/drivers/net/sfc/mcdi.h
+++ b/drivers/net/sfc/mcdi.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
- * Copyright 2008-2009 Solarflare Communications Inc.
+ * Copyright 2008-2010 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -93,7 +93,7 @@ extern void efx_mcdi_process_event(struct efx_channel *channel,
 #define MCDI_EVENT_FIELD(_ev, _field)                   \
        EFX_QWORD_FIELD(_ev, MCDI_EVENT_ ## _field)
-extern int efx_mcdi_fwver(struct efx_nic *efx, u64 *version, u32 *build);
+extern void efx_mcdi_print_fwver(struct efx_nic *efx, char *buf, size_t len);
 extern int efx_mcdi_drv_attach(struct efx_nic *efx, bool driver_operating,
                               bool *was_attached_out);
 extern int efx_mcdi_get_board_cfg(struct efx_nic *efx, u8 *mac_address,
@@ -121,8 +121,6 @@ extern int efx_mcdi_handle_assertion(struct efx_nic *efx);
 extern void efx_mcdi_set_id_led(struct efx_nic *efx, enum efx_led_mode mode);
 extern int efx_mcdi_reset_port(struct efx_nic *efx);
 extern int efx_mcdi_reset_mc(struct efx_nic *efx);
-extern int efx_mcdi_wol_filter_set(struct efx_nic *efx, u32 type,
-                                   const u8 *mac, int *id_out);
 extern int efx_mcdi_wol_filter_set_magic(struct efx_nic *efx,
                                         const u8 *mac, int *id_out);
 extern int efx_mcdi_wol_filter_get_magic(struct efx_nic *efx, int *id_out);
diff --git a/drivers/net/sfc/mcdi_mac.c b/drivers/net/sfc/mcdi_mac.c
index f88f4bf986ff..50c20777a564 100644
--- a/drivers/net/sfc/mcdi_mac.c
+++ b/drivers/net/sfc/mcdi_mac.c
@@ -1,6 +1,6 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
- * Copyright 2009 Solarflare Communications Inc.
+ * Copyright 2009-2010 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -138,7 +138,7 @@ static bool efx_mcdi_mac_check_fault(struct efx_nic *efx)
 }
-struct efx_mac_operations efx_mcdi_mac_operations = {
+const struct efx_mac_operations efx_mcdi_mac_operations = {
        .reconfigure    = efx_mcdi_mac_reconfigure,
        .update_stats   = efx_port_dummy_op_void,
        .check_fault    = efx_mcdi_mac_check_fault,
diff --git a/drivers/net/sfc/mcdi_pcol.h b/drivers/net/sfc/mcdi_pcol.h
index 90359e644006..41fe06fa0600 100644
--- a/drivers/net/sfc/mcdi_pcol.h
+++ b/drivers/net/sfc/mcdi_pcol.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
- * Copyright 2009 Solarflare Communications Inc.
+ * Copyright 2009-2011 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -103,7 +103,7 @@
 *
 * If Code==CMDDONE, then the fields are further interpreted as:
 *
- *   - LEVEL==INFO    Command succeded
+ *   - LEVEL==INFO    Command succeeded
 *   - LEVEL==ERR     Command failed
 *
 *    0     8         16      24     32
@@ -572,7 +572,7 @@
  (4*(_numwords))
 /* MC_CMD_SET_RAND_SEED:
- * Set the 16byte seed for the MC psuedo-random generator
+ * Set the 16byte seed for the MC pseudo-random generator
 */
 #define MC_CMD_SET_RAND_SEED 0x1a
 #define MC_CMD_SET_RAND_SEED_IN_LEN 16
@@ -1162,7 +1162,7 @@
 #define MC_CMD_MAC_STATS_CMD_CLEAR_WIDTH 1
 #define MC_CMD_MAC_STATS_CMD_PERIODIC_CHANGE_LBN 2
 #define MC_CMD_MAC_STATS_CMD_PERIODIC_CHANGE_WIDTH 1
-/* Remaining PERIOD* fields only relevent when PERIODIC_CHANGE is set */
+/* Remaining PERIOD* fields only relevant when PERIODIC_CHANGE is set */
 #define MC_CMD_MAC_STATS_CMD_PERIODIC_ENABLE_LBN 3
 #define MC_CMD_MAC_STATS_CMD_PERIODIC_ENABLE_WIDTH 1
 #define MC_CMD_MAC_STATS_CMD_PERIODIC_CLEAR_LBN 4
diff --git a/drivers/net/sfc/mcdi_phy.c b/drivers/net/sfc/mcdi_phy.c
index 0121e71702bf..6c63ab0710af 100644
--- a/drivers/net/sfc/mcdi_phy.c
+++ b/drivers/net/sfc/mcdi_phy.c
@@ -1,6 +1,6 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
- * Copyright 2009 Solarflare Communications Inc.
+ * Copyright 2009-2010 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -16,7 +16,6 @@
 #include "phy.h"
 #include "mcdi.h"
 #include "mcdi_pcol.h"
-#include "mdio_10g.h"
 #include "nic.h"
 #include "selftest.h"
@@ -450,7 +449,7 @@ void efx_mcdi_phy_check_fcntl(struct efx_nic *efx, u32 lpa)
        struct efx_mcdi_phy_data *phy_cfg = efx->phy_data;
        u32 rmtadv;
-        /* The link partner capabilities are only relevent if the
+        /* The link partner capabilities are only relevant if the
         * link supports flow control autonegotiation */
        if (~phy_cfg->supported_cap & (1 << MC_CMD_PHY_CAP_AN_LBN))
                return;
@@ -514,7 +513,7 @@ static void efx_mcdi_phy_get_settings(struct efx_nic *efx, struct ethtool_cmd *e
        ecmd->supported =
                mcdi_to_ethtool_cap(phy_cfg->media, phy_cfg->supported_cap);
        ecmd->advertising = efx->link_advertising;
-        ecmd->speed = efx->link_state.speed;
+        ethtool_cmd_speed_set(ecmd, efx->link_state.speed);
        ecmd->duplex = efx->link_state.fd;
        ecmd->port = mcdi_to_ethtool_media(phy_cfg->media);
        ecmd->phy_address = phy_cfg->port;
@@ -546,7 +545,7 @@ static int efx_mcdi_phy_set_settings(struct efx_nic *efx, struct ethtool_cmd *ec
                caps = (ethtool_to_mcdi_cap(ecmd->advertising) |
                         1 << MC_CMD_PHY_CAP_AN_LBN);
        } else if (ecmd->duplex) {
-                switch (ecmd->speed) {
+                switch (ethtool_cmd_speed(ecmd)) {
                case 10:    caps = 1 << MC_CMD_PHY_CAP_10FDX_LBN;    break;
                case 100:   caps = 1 << MC_CMD_PHY_CAP_100FDX_LBN;   break;
                case 1000:  caps = 1 << MC_CMD_PHY_CAP_1000FDX_LBN;  break;
@@ -554,7 +553,7 @@ static int efx_mcdi_phy_set_settings(struct efx_nic *efx, struct ethtool_cmd *ec
                default:    return -EINVAL;
                }
        } else {
-                switch (ecmd->speed) {
+                switch (ethtool_cmd_speed(ecmd)) {
                case 10:    caps = 1 << MC_CMD_PHY_CAP_10HDX_LBN;    break;
                case 100:   caps = 1 << MC_CMD_PHY_CAP_100HDX_LBN;   break;
                case 1000:  caps = 1 << MC_CMD_PHY_CAP_1000HDX_LBN;  break;
@@ -713,7 +712,8 @@ static int efx_mcdi_phy_run_tests(struct efx_nic *efx, int *results,
        return 0;
 }
-const char *efx_mcdi_phy_test_name(struct efx_nic *efx, unsigned int index)
+static const char *efx_mcdi_phy_test_name(struct efx_nic *efx,
+                                          unsigned int index)
 {
        struct efx_mcdi_phy_data *phy_cfg = efx->phy_data;
@@ -739,7 +739,7 @@ const char *efx_mcdi_phy_test_name(struct efx_nic *efx, unsigned int index)
        return NULL;
 }
-struct efx_phy_operations efx_mcdi_phy_ops = {
+const struct efx_phy_operations efx_mcdi_phy_ops = {
        .probe          = efx_mcdi_phy_probe,
        .init           = efx_port_dummy_op_int,
        .reconfigure    = efx_mcdi_phy_reconfigure,
diff --git a/drivers/net/sfc/mdio_10g.c b/drivers/net/sfc/mdio_10g.c
index eeaf0bd64bd3..7ab385c8136d 100644
--- a/drivers/net/sfc/mdio_10g.c
+++ b/drivers/net/sfc/mdio_10g.c
@@ -1,6 +1,6 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
- * Copyright 2006-2009 Solarflare Communications Inc.
+ * Copyright 2006-2011 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -15,7 +15,6 @@
 #include "net_driver.h"
 #include "mdio_10g.h"
 #include "workarounds.h"
-#include "nic.h"
 unsigned efx_mdio_id_oui(u32 id)
 {
@@ -52,13 +51,10 @@ int efx_mdio_reset_mmd(struct efx_nic *port, int mmd,
        return spins ? spins : -ETIMEDOUT;
 }
-static int efx_mdio_check_mmd(struct efx_nic *efx, int mmd, int fault_fatal)
+static int efx_mdio_check_mmd(struct efx_nic *efx, int mmd)
 {
        int status;
-        if (LOOPBACK_INTERNAL(efx))
-                return 0;
        if (mmd != MDIO_MMD_AN) {
                /* Read MMD STATUS2 to check it is responding. */
                status = efx_mdio_read(efx, mmd, MDIO_STAT2);
@@ -69,20 +65,6 @@ static int efx_mdio_check_mmd(struct efx_nic *efx, int mmd, int fault_fatal)
                }
        }
-        /* Read MMD STATUS 1 to check for fault. */
-        status = efx_mdio_read(efx, mmd, MDIO_STAT1);
-        if (status & MDIO_STAT1_FAULT) {
-                if (fault_fatal) {
-                        netif_err(efx, hw, efx->net_dev,
-                                  "PHY MMD %d reporting fatal"
-                                  " fault: status %x\n", mmd, status);
-                        return -EIO;
-                } else {
-                        netif_dbg(efx, hw, efx->net_dev,
-                                  "PHY MMD %d reporting status"
-                                  " %x (expected)\n", mmd, status);
-                }
-        }
        return 0;
 }
@@ -131,8 +113,7 @@ int efx_mdio_wait_reset_mmds(struct efx_nic *efx, unsigned int mmd_mask)
        return rc;
 }
-int efx_mdio_check_mmds(struct efx_nic *efx,
+int efx_mdio_check_mmds(struct efx_nic *efx, unsigned int mmd_mask)
-                        unsigned int mmd_mask, unsigned int fatal_mask)
 {
        int mmd = 0, probe_mmd, devs1, devs2;
        u32 devices;
@@ -162,13 +143,9 @@ int efx_mdio_check_mmds(struct efx_nic *efx,
        /* Check all required MMDs are responding and happy. */
        while (mmd_mask) {
-                if (mmd_mask & 1) {
+                if ((mmd_mask & 1) && efx_mdio_check_mmd(efx, mmd))
-                        int fault_fatal = fatal_mask & 1;
+                        return -EIO;
-                        if (efx_mdio_check_mmd(efx, mmd, fault_fatal))
-                                return -EIO;
-                }
                mmd_mask = mmd_mask >> 1;
-                fatal_mask = fatal_mask >> 1;
                mmd++;
        }
@@ -255,12 +232,12 @@ void efx_mdio_set_mmds_lpower(struct efx_nic *efx,
 */
 int efx_mdio_set_settings(struct efx_nic *efx, struct ethtool_cmd *ecmd)
 {
-        struct ethtool_cmd prev;
+        struct ethtool_cmd prev = { .cmd = ETHTOOL_GSET };
        efx->phy_op->get_settings(efx, &prev);
        if (ecmd->advertising == prev.advertising &&
-            ecmd->speed == prev.speed &&
+            ethtool_cmd_speed(ecmd) == ethtool_cmd_speed(&prev) &&
            ecmd->duplex == prev.duplex &&
            ecmd->port == prev.port &&
            ecmd->autoneg == prev.autoneg)
@@ -286,50 +263,28 @@ int efx_mdio_set_settings(struct efx_nic *efx, struct ethtool_cmd *ecmd)
 */
 void efx_mdio_an_reconfigure(struct efx_nic *efx)
 {
-        bool xnp = (efx->link_advertising & ADVERTISED_10000baseT_Full
-                    || EFX_WORKAROUND_13204(efx));
        int reg;
        WARN_ON(!(efx->mdio.mmds & MDIO_DEVS_AN));
        /* Set up the base page */
-        reg = ADVERTISE_CSMA;
+        reg = ADVERTISE_CSMA | ADVERTISE_RESV;
-        if (efx->link_advertising & ADVERTISED_10baseT_Half)
-                reg |= ADVERTISE_10HALF;
-        if (efx->link_advertising & ADVERTISED_10baseT_Full)
-                reg |= ADVERTISE_10FULL;
-        if (efx->link_advertising & ADVERTISED_100baseT_Half)
-                reg |= ADVERTISE_100HALF;
-        if (efx->link_advertising & ADVERTISED_100baseT_Full)
-                reg |= ADVERTISE_100FULL;
-        if (xnp)
-                reg |= ADVERTISE_RESV;
-        else if (efx->link_advertising & (ADVERTISED_1000baseT_Half |
-                                          ADVERTISED_1000baseT_Full))
-                reg |= ADVERTISE_NPAGE;
        if (efx->link_advertising & ADVERTISED_Pause)
                reg |= ADVERTISE_PAUSE_CAP;
        if (efx->link_advertising & ADVERTISED_Asym_Pause)
                reg |= ADVERTISE_PAUSE_ASYM;
        efx_mdio_write(efx, MDIO_MMD_AN, MDIO_AN_ADVERTISE, reg);
-        /* Set up the (extended) next page if necessary */
+        /* Set up the (extended) next page */
-        if (efx->phy_op->set_npage_adv)
+        efx->phy_op->set_npage_adv(efx, efx->link_advertising);
-                efx->phy_op->set_npage_adv(efx, efx->link_advertising);
        /* Enable and restart AN */
        reg = efx_mdio_read(efx, MDIO_MMD_AN, MDIO_CTRL1);
-        reg |= MDIO_AN_CTRL1_ENABLE;
+        reg |= MDIO_AN_CTRL1_ENABLE | MDIO_AN_CTRL1_RESTART | MDIO_AN_CTRL1_XNP;
-        if (!(EFX_WORKAROUND_15195(efx) && LOOPBACK_EXTERNAL(efx)))
-                reg |= MDIO_AN_CTRL1_RESTART;
-        if (xnp)
-                reg |= MDIO_AN_CTRL1_XNP;
-        else
-                reg &= ~MDIO_AN_CTRL1_XNP;
        efx_mdio_write(efx, MDIO_MMD_AN, MDIO_CTRL1, reg);
 }
-enum efx_fc_type efx_mdio_get_pause(struct efx_nic *efx)
+u8 efx_mdio_get_pause(struct efx_nic *efx)
 {
        BUILD_BUG_ON(EFX_FC_AUTO & (EFX_FC_RX | EFX_FC_TX));
@@ -360,7 +315,7 @@ int efx_mdio_test_alive(struct efx_nic *efx)
                          "no MDIO PHY present with ID %d\n", efx->mdio.prtad);
                rc = -EINVAL;
        } else {
-                rc = efx_mdio_check_mmds(efx, efx->mdio.mmds, 0);
+                rc = efx_mdio_check_mmds(efx, efx->mdio.mmds);
        }
        mutex_unlock(&efx->mac_lock);
diff --git a/drivers/net/sfc/mdio_10g.h b/drivers/net/sfc/mdio_10g.h
index 75791d3d4963..a97dbbd2de99 100644
--- a/drivers/net/sfc/mdio_10g.h
+++ b/drivers/net/sfc/mdio_10g.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
- * Copyright 2006-2009 Solarflare Communications Inc.
+ * Copyright 2006-2011 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -68,8 +68,7 @@ extern int efx_mdio_reset_mmd(struct efx_nic *efx, int mmd,
                              int spins, int spintime);
 /* As efx_mdio_check_mmd but for multiple MMDs */
-int efx_mdio_check_mmds(struct efx_nic *efx,
+int efx_mdio_check_mmds(struct efx_nic *efx, unsigned int mmd_mask);
-                        unsigned int mmd_mask, unsigned int fatal_mask);
 /* Check the link status of specified mmds in bit mask */
 extern bool efx_mdio_links_ok(struct efx_nic *efx, unsigned int mmd_mask);
@@ -93,7 +92,7 @@ extern void efx_mdio_an_reconfigure(struct efx_nic *efx);
 /* Get pause parameters from AN if available (otherwise return
 * requested pause parameters)
 */
-enum efx_fc_type efx_mdio_get_pause(struct efx_nic *efx);
+u8 efx_mdio_get_pause(struct efx_nic *efx);
 /* Wait for specified MMDs to exit reset within a timeout */
 extern int efx_mdio_wait_reset_mmds(struct efx_nic *efx,
diff --git a/drivers/net/sfc/mtd.c b/drivers/net/sfc/mtd.c
index 02e54b4f701f..b6304486f244 100644
--- a/drivers/net/sfc/mtd.c
+++ b/drivers/net/sfc/mtd.c
@@ -1,7 +1,7 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
 * Copyright 2005-2006 Fen Systems Ltd.
- * Copyright 2006-2009 Solarflare Communications Inc.
+ * Copyright 2006-2010 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -216,7 +216,7 @@ static void efx_mtd_remove_partition(struct efx_mtd_partition *part)
        int rc;
        for (;;) {
-                rc = del_mtd_device(&part->mtd);
+                rc = mtd_device_unregister(&part->mtd);
                if (rc != -EBUSY)
                        break;
                ssleep(1);
@@ -268,7 +268,7 @@ static int efx_mtd_probe_device(struct efx_nic *efx, struct efx_mtd *efx_mtd)
                part->mtd.write = efx_mtd->ops->write;
                part->mtd.sync = efx_mtd_sync;
-                if (add_mtd_device(&part->mtd))
+                if (mtd_device_register(&part->mtd, NULL, 0))
                        goto fail;
        }
@@ -280,7 +280,7 @@ fail:
                --part;
                efx_mtd_remove_partition(part);
        }
-        /* add_mtd_device() returns 1 if the MTD table is full */
+        /* mtd_device_register() returns 1 if the MTD table is full */
        return -ENOMEM;
 }
@@ -321,14 +321,15 @@ static int falcon_mtd_read(struct mtd_info *mtd, loff_t start,
        struct efx_mtd *efx_mtd = mtd->priv;
        const struct efx_spi_device *spi = efx_mtd->spi;
        struct efx_nic *efx = efx_mtd->efx;
+        struct falcon_nic_data *nic_data = efx->nic_data;
        int rc;
-        rc = mutex_lock_interruptible(&efx->spi_lock);
+        rc = mutex_lock_interruptible(&nic_data->spi_lock);
        if (rc)
                return rc;
        rc = falcon_spi_read(efx, spi, part->offset + start, len,
                             retlen, buffer);
-        mutex_unlock(&efx->spi_lock);
+        mutex_unlock(&nic_data->spi_lock);
        return rc;
 }
@@ -337,13 +338,14 @@ static int falcon_mtd_erase(struct mtd_info *mtd, loff_t start, size_t len)
        struct efx_mtd_partition *part = to_efx_mtd_partition(mtd);
        struct efx_mtd *efx_mtd = mtd->priv;
        struct efx_nic *efx = efx_mtd->efx;
+        struct falcon_nic_data *nic_data = efx->nic_data;
        int rc;
-        rc = mutex_lock_interruptible(&efx->spi_lock);
+        rc = mutex_lock_interruptible(&nic_data->spi_lock);
        if (rc)
                return rc;
        rc = efx_spi_erase(part, part->offset + start, len);
-        mutex_unlock(&efx->spi_lock);
+        mutex_unlock(&nic_data->spi_lock);
        return rc;
 }
@@ -354,14 +356,15 @@ static int falcon_mtd_write(struct mtd_info *mtd, loff_t start,
        struct efx_mtd *efx_mtd = mtd->priv;
        const struct efx_spi_device *spi = efx_mtd->spi;
        struct efx_nic *efx = efx_mtd->efx;
+        struct falcon_nic_data *nic_data = efx->nic_data;
        int rc;
-        rc = mutex_lock_interruptible(&efx->spi_lock);
+        rc = mutex_lock_interruptible(&nic_data->spi_lock);
        if (rc)
                return rc;
        rc = falcon_spi_write(efx, spi, part->offset + start, len,
                              retlen, buffer);
-        mutex_unlock(&efx->spi_lock);
+        mutex_unlock(&nic_data->spi_lock);
        return rc;
 }
@@ -370,11 +373,12 @@ static int falcon_mtd_sync(struct mtd_info *mtd)
        struct efx_mtd_partition *part = to_efx_mtd_partition(mtd);
        struct efx_mtd *efx_mtd = mtd->priv;
        struct efx_nic *efx = efx_mtd->efx;
+        struct falcon_nic_data *nic_data = efx->nic_data;
        int rc;
-        mutex_lock(&efx->spi_lock);
+        mutex_lock(&nic_data->spi_lock);
        rc = efx_spi_slow_wait(part, true);
-        mutex_unlock(&efx->spi_lock);
+        mutex_unlock(&nic_data->spi_lock);
        return rc;
 }
@@ -387,35 +391,67 @@ static struct efx_mtd_ops falcon_mtd_ops = {
 static int falcon_mtd_probe(struct efx_nic *efx)
 {
-        struct efx_spi_device *spi = efx->spi_flash;
+        struct falcon_nic_data *nic_data = efx->nic_data;
+        struct efx_spi_device *spi;
        struct efx_mtd *efx_mtd;
-        int rc;
+        int rc = -ENODEV;
        ASSERT_RTNL();
-        if (!spi || spi->size <= FALCON_FLASH_BOOTCODE_START)
+        spi = &nic_data->spi_flash;
-                return -ENODEV;
+        if (efx_spi_present(spi) && spi->size > FALCON_FLASH_BOOTCODE_START) {
+                efx_mtd = kzalloc(sizeof(*efx_mtd) + sizeof(efx_mtd->part[0]),
-        efx_mtd = kzalloc(sizeof(*efx_mtd) + sizeof(efx_mtd->part[0]),
+                                  GFP_KERNEL);
-                          GFP_KERNEL);
+                if (!efx_mtd)
-        if (!efx_mtd)
+                        return -ENOMEM;
-                return -ENOMEM;
+                efx_mtd->spi = spi;
-        efx_mtd->spi = spi;
+                efx_mtd->name = "flash";
-        efx_mtd->name = "flash";
+                efx_mtd->ops = &falcon_mtd_ops;
-        efx_mtd->ops = &falcon_mtd_ops;
+                efx_mtd->n_parts = 1;
+                efx_mtd->part[0].mtd.type = MTD_NORFLASH;
+                efx_mtd->part[0].mtd.flags = MTD_CAP_NORFLASH;
+                efx_mtd->part[0].mtd.size = spi->size - FALCON_FLASH_BOOTCODE_START;
+                efx_mtd->part[0].mtd.erasesize = spi->erase_size;
+                efx_mtd->part[0].offset = FALCON_FLASH_BOOTCODE_START;
+                efx_mtd->part[0].type_name = "sfc_flash_bootrom";
+                rc = efx_mtd_probe_device(efx, efx_mtd);
+                if (rc) {
+                        kfree(efx_mtd);
+                        return rc;
+                }
+        }
-        efx_mtd->n_parts = 1;
+        spi = &nic_data->spi_eeprom;
-        efx_mtd->part[0].mtd.type = MTD_NORFLASH;
+        if (efx_spi_present(spi) && spi->size > EFX_EEPROM_BOOTCONFIG_START) {
-        efx_mtd->part[0].mtd.flags = MTD_CAP_NORFLASH;
+                efx_mtd = kzalloc(sizeof(*efx_mtd) + sizeof(efx_mtd->part[0]),
-        efx_mtd->part[0].mtd.size = spi->size - FALCON_FLASH_BOOTCODE_START;
+                                  GFP_KERNEL);
-        efx_mtd->part[0].mtd.erasesize = spi->erase_size;
+                if (!efx_mtd)
-        efx_mtd->part[0].offset = FALCON_FLASH_BOOTCODE_START;
+                        return -ENOMEM;
-        efx_mtd->part[0].type_name = "sfc_flash_bootrom";
+                efx_mtd->spi = spi;
+                efx_mtd->name = "EEPROM";
+                efx_mtd->ops = &falcon_mtd_ops;
+                efx_mtd->n_parts = 1;
+                efx_mtd->part[0].mtd.type = MTD_RAM;
+                efx_mtd->part[0].mtd.flags = MTD_CAP_RAM;
+                efx_mtd->part[0].mtd.size =
+                        min(spi->size, EFX_EEPROM_BOOTCONFIG_END) -
+                        EFX_EEPROM_BOOTCONFIG_START;
+                efx_mtd->part[0].mtd.erasesize = spi->erase_size;
+                efx_mtd->part[0].offset = EFX_EEPROM_BOOTCONFIG_START;
+                efx_mtd->part[0].type_name = "sfc_bootconfig";
+                rc = efx_mtd_probe_device(efx, efx_mtd);
+                if (rc) {
+                        kfree(efx_mtd);
+                        return rc;
+                }
+        }
-        rc = efx_mtd_probe_device(efx, efx_mtd);
-        if (rc)
-                kfree(efx_mtd);
        return rc;
 }
diff --git a/drivers/net/sfc/net_driver.h b/drivers/net/sfc/net_driver.h
index 64e7caa4bbb5..e8d5f03a89fe 100644
--- a/drivers/net/sfc/net_driver.h
+++ b/drivers/net/sfc/net_driver.h
@@ -1,7 +1,7 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
 * Copyright 2005-2006 Fen Systems Ltd.
- * Copyright 2005-2009 Solarflare Communications Inc.
+ * Copyright 2005-2011 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -29,6 +29,7 @@
 #include <linux/device.h>
 #include <linux/highmem.h>
 #include <linux/workqueue.h>
+#include <linux/vmalloc.h>
 #include <linux/i2c.h>
 #include "enum.h"
@@ -40,7 +41,7 @@
 *
 **************************************************************************/
-#define EFX_DRIVER_VERSION      "3.0"
+#define EFX_DRIVER_VERSION      "3.1"
 #ifdef EFX_ENABLE_DEBUG
 #define EFX_BUG_ON_PARANOID(x) BUG_ON(x)
@@ -62,10 +63,12 @@
 /* Checksum generation is a per-queue option in hardware, so each
 * queue visible to the networking core is backed by two hardware TX
 * queues. */
-#define EFX_MAX_CORE_TX_QUEUES  EFX_MAX_CHANNELS
+#define EFX_MAX_TX_TC           2
-#define EFX_TXQ_TYPE_OFFLOAD    1
+#define EFX_MAX_CORE_TX_QUEUES  (EFX_MAX_TX_TC * EFX_MAX_CHANNELS)
-#define EFX_TXQ_TYPES           2
+#define EFX_TXQ_TYPE_OFFLOAD    1       /* flag */
-#define EFX_MAX_TX_QUEUES       (EFX_TXQ_TYPES * EFX_MAX_CORE_TX_QUEUES)
+#define EFX_TXQ_TYPE_HIGHPRI    2       /* flag */
+#define EFX_TXQ_TYPES           4
+#define EFX_MAX_TX_QUEUES       (EFX_TXQ_TYPES * EFX_MAX_CHANNELS)
 /**
 * struct efx_special_buffer - An Efx special buffer
@@ -135,13 +138,20 @@ struct efx_tx_buffer {
 * @efx: The associated Efx NIC
 * @queue: DMA queue number
 * @channel: The associated channel
+ * @core_txq: The networking core TX queue structure
 * @buffer: The software buffer ring
 * @txd: The hardware descriptor ring
+ * @ptr_mask: The size of the ring minus 1.
+ * @initialised: Has hardware queue been initialised?
 * @flushed: Used when handling queue flushing
 * @read_count: Current read pointer.
 *      This is the number of buffers that have been removed from both rings.
- * @stopped: Stopped count.
+ * @old_write_count: The value of @write_count when last checked.
- *      Set if this TX queue is currently stopping its port.
+ *      This is here for performance reasons.  The xmit path will
+ *      only get the up-to-date value of @write_count if this
+ *      variable indicates that the queue is empty.  This is to
+ *      avoid cache-line ping-pong between the xmit path and the
+ *      completion path.
 * @insert_count: Current insert pointer
 *      This is the number of buffers that have been added to the
 *      software ring.
@@ -161,20 +171,26 @@ struct efx_tx_buffer {
 * @tso_long_headers: Number of packets with headers too long for standard
 *      blocks
 * @tso_packets: Number of packets via the TSO xmit path
+ * @pushes: Number of times the TX push feature has been used
+ * @empty_read_count: If the completion path has seen the queue as empty
+ *      and the transmission path has not yet checked this, the value of
+ *      @read_count bitwise-added to %EFX_EMPTY_COUNT_VALID; otherwise 0.
 */
 struct efx_tx_queue {
        /* Members which don't change on the fast path */
        struct efx_nic *efx ____cacheline_aligned_in_smp;
        unsigned queue;
        struct efx_channel *channel;
-        struct efx_nic *nic;
+        struct netdev_queue *core_txq;
        struct efx_tx_buffer *buffer;
        struct efx_special_buffer txd;
+        unsigned int ptr_mask;
+        bool initialised;
        enum efx_flush_state flushed;
        /* Members used mainly on the completion path */
        unsigned int read_count ____cacheline_aligned_in_smp;
-        int stopped;
+        unsigned int old_write_count;
        /* Members used only on the xmit path */
        unsigned int insert_count ____cacheline_aligned_in_smp;
@@ -184,6 +200,11 @@ struct efx_tx_queue {
        unsigned int tso_bursts;
        unsigned int tso_long_headers;
        unsigned int tso_packets;
+        unsigned int pushes;
+        /* Members shared between paths and sometimes updated */
+        unsigned int empty_read_count ____cacheline_aligned_in_smp;
+#define EFX_EMPTY_COUNT_VALID 0x80000000
 };
 /**
@@ -193,15 +214,17 @@ struct efx_tx_queue {
 *      If both this and page are %NULL, the buffer slot is currently free.
 * @page: The associated page buffer, if any.
 *      If both this and skb are %NULL, the buffer slot is currently free.
- * @data: Pointer to ethernet header
 * @len: Buffer length, in bytes.
+ * @is_page: Indicates if @page is valid. If false, @skb is valid.
 */
 struct efx_rx_buffer {
        dma_addr_t dma_addr;
-        struct sk_buff *skb;
+        union {
-        struct page *page;
+                struct sk_buff *skb;
-        char *data;
+                struct page *page;
+        } u;
        unsigned int len;
+        bool is_page;
 };
 /**
@@ -225,10 +248,9 @@ struct efx_rx_page_state {
 /**
 * struct efx_rx_queue - An Efx RX queue
 * @efx: The associated Efx NIC
- * @queue: DMA queue number
- * @channel: The associated channel
 * @buffer: The software buffer ring
 * @rxd: The hardware descriptor ring
+ * @ptr_mask: The size of the ring minus 1.
 * @added_count: Number of buffers added to the receive queue.
 * @notified_count: Number of buffers given to NIC (<= @added_count).
 * @removed_count: Number of buffers removed from the receive queue.
@@ -240,9 +262,6 @@ struct efx_rx_page_state {
 * @min_fill: RX descriptor minimum non-zero fill level.
 *      This records the minimum fill level observed when a ring
 *      refill was triggered.
- * @min_overfill: RX descriptor minimum overflow fill level.
- *      This records the minimum fill level at which RX queue
- *      overflow was observed.  It should never be set.
 * @alloc_page_count: RX allocation strategy counter.
 * @alloc_skb_count: RX allocation strategy counter.
 * @slow_fill: Timer used to defer efx_nic_generate_fill_event().
@@ -250,10 +269,9 @@ struct efx_rx_page_state {
 */
 struct efx_rx_queue {
        struct efx_nic *efx;
-        int queue;
-        struct efx_channel *channel;
        struct efx_rx_buffer *buffer;
        struct efx_special_buffer rxd;
+        unsigned int ptr_mask;
        int added_count;
        int notified_count;
@@ -302,18 +320,16 @@ enum efx_rx_alloc_method {
 *
 * @efx: Associated Efx NIC
 * @channel: Channel instance number
- * @name: Name for channel and IRQ
 * @enabled: Channel enabled indicator
 * @irq: IRQ number (MSI and MSI-X only)
 * @irq_moderation: IRQ moderation value (in hardware ticks)
 * @napi_dev: Net device used with NAPI
 * @napi_str: NAPI control structure
- * @reset_work: Scheduled reset work thread
 * @work_pending: Is work pending via NAPI?
 * @eventq: Event queue buffer
+ * @eventq_mask: Event queue pointer mask
 * @eventq_read_ptr: Event queue read pointer
 * @last_eventq_read_ptr: Last event queue read pointer value.
- * @magic_count: Event queue test event count
 * @irq_count: Number of IRQs since last adaptive moderation decision
 * @irq_mod_score: IRQ moderation score
 * @rx_alloc_level: Watermark based heuristic counter for pushing descriptors
@@ -327,14 +343,12 @@ enum efx_rx_alloc_method {
 * @n_rx_frm_trunc: Count of RX_FRM_TRUNC errors
 * @n_rx_overlength: Count of RX_OVERLENGTH errors
 * @n_skbuff_leaks: Count of skbuffs leaked due to RX overrun
- * @tx_queue: Pointer to first TX queue, or %NULL if not used for TX
+ * @rx_queue: RX queue for this channel
- * @tx_stop_count: Core TX queue stop count
+ * @tx_queue: TX queues for this channel
- * @tx_stop_lock: Core TX queue stop lock
 */
 struct efx_channel {
        struct efx_nic *efx;
        int channel;
-        char name[IFNAMSIZ + 6];
        bool enabled;
        int irq;
        unsigned int irq_moderation;
@@ -342,12 +356,15 @@ struct efx_channel {
        struct napi_struct napi_str;
        bool work_pending;
        struct efx_special_buffer eventq;
+        unsigned int eventq_mask;
        unsigned int eventq_read_ptr;
        unsigned int last_eventq_read_ptr;
-        unsigned int magic_count;
        unsigned int irq_count;
        unsigned int irq_mod_score;
+#ifdef CONFIG_RFS_ACCEL
+        unsigned int rfs_filters_added;
+#endif
        int rx_alloc_level;
        int rx_alloc_push_pages;
@@ -366,9 +383,8 @@ struct efx_channel {
        struct efx_rx_buffer *rx_pkt;
        bool rx_pkt_csummed;
-        struct efx_tx_queue *tx_queue;
+        struct efx_rx_queue rx_queue;
-        atomic_t tx_stop_count;
+        struct efx_tx_queue tx_queue[EFX_TXQ_TYPES];
-        spinlock_t tx_stop_lock;
 };
 enum efx_led_mode {
@@ -385,11 +401,6 @@ extern const unsigned int efx_loopback_mode_max;
 #define LOOPBACK_MODE(efx) \
        STRING_TABLE_LOOKUP((efx)->loopback_mode, efx_loopback_mode)
-extern const char *efx_interrupt_mode_names[];
-extern const unsigned int efx_interrupt_mode_max;
-#define INT_MODE(efx) \
-        STRING_TABLE_LOOKUP(efx->interrupt_mode, efx_interrupt_mode)
 extern const char *efx_reset_type_names[];
 extern const unsigned int efx_reset_type_max;
 #define RESET_TYPE(type) \
@@ -404,8 +415,6 @@ enum efx_int_mode {
 };
 #define EFX_INT_MODE_USE_MSI(x) (((x)->interrupt_mode) <= EFX_INT_MODE_MSI)
-#define EFX_IS10G(efx) ((efx)->link_state.speed == 10000)
 enum nic_state {
        STATE_INIT = 0,
        STATE_RUNNING = 1,
@@ -440,11 +449,9 @@ enum nic_state {
 struct efx_nic;
 /* Pseudo bit-mask flow control field */
-enum efx_fc_type {
+#define EFX_FC_RX       FLOW_CTRL_RX
-        EFX_FC_RX = FLOW_CTRL_RX,
+#define EFX_FC_TX       FLOW_CTRL_TX
-        EFX_FC_TX = FLOW_CTRL_TX,
+#define EFX_FC_AUTO     4
-        EFX_FC_AUTO = 4,
-};
 /**
 * struct efx_link_state - Current state of the link
@@ -456,7 +463,7 @@ enum efx_fc_type {
 struct efx_link_state {
        bool up;
        bool fd;
-        enum efx_fc_type fc;
+        u8 fc;
        unsigned int speed;
 };
@@ -618,20 +625,21 @@ union efx_multicast_hash {
        efx_oword_t oword[EFX_MCAST_HASH_ENTRIES / sizeof(efx_oword_t) / 8];
 };
+struct efx_filter_state;
 /**
 * struct efx_nic - an Efx NIC
 * @name: Device name (net device name or bus id before net device registered)
 * @pci_dev: The PCI device
 * @type: Controller type attributes
 * @legacy_irq: IRQ number
+ * @legacy_irq_enabled: Are IRQs enabled on NIC (INT_EN_KER register)?
 * @workqueue: Workqueue for port reconfigures and the HW monitor.
 *      Work items do not hold and must not acquire RTNL.
 * @workqueue_name: Name of workqueue
 * @reset_work: Scheduled reset workitem
- * @monitor_work: Hardware monitor workitem
 * @membase_phys: Memory BAR value as physical address
 * @membase: Memory BAR value
- * @biu_lock: BIU (bus interface unit) lock
 * @interrupt_mode: Interrupt mode
 * @irq_rx_adaptive: Adaptive IRQ moderation enabled for RX event queues
 * @irq_rx_moderation: IRQ moderation time for RX event queues
@@ -641,56 +649,41 @@ union efx_multicast_hash {
 * @tx_queue: TX DMA queues
 * @rx_queue: RX DMA queues
 * @channel: Channels
+ * @channel_name: Names for channels and their IRQs
+ * @rxq_entries: Size of receive queues requested by user.
+ * @txq_entries: Size of transmit queues requested by user.
 * @next_buffer_table: First available buffer table id
 * @n_channels: Number of channels in use
 * @n_rx_channels: Number of channels used for RX (= number of RX queues)
 * @n_tx_channels: Number of channels used for TX
 * @rx_buffer_len: RX buffer length
 * @rx_buffer_order: Order (log2) of number of pages for each RX buffer
+ * @rx_hash_key: Toeplitz hash key for RSS
 * @rx_indir_table: Indirection table for RSS
 * @int_error_count: Number of internal errors seen recently
 * @int_error_expire: Time at which error count will be expired
 * @irq_status: Interrupt status buffer
- * @last_irq_cpu: Last CPU to handle interrupt.
- *      This register is written with the SMP processor ID whenever an
- *      interrupt is handled.  It is used by efx_nic_test_interrupt()
- *      to verify that an interrupt has occurred.
 * @irq_zero_count: Number of legacy IRQs seen with queue flags == 0
 * @fatal_irq_level: IRQ level (bit number) used for serious errors
- * @spi_flash: SPI flash device
- *      This field will be %NULL if no flash device is present (or for Siena).
- * @spi_eeprom: SPI EEPROM device
- *      This field will be %NULL if no EEPROM device is present (or for Siena).
- * @spi_lock: SPI bus lock
 * @mtd_list: List of MTDs attached to the NIC
- * @n_rx_nodesc_drop_cnt: RX no descriptor drop count
+ * @nic_data: Hardware dependent state
- * @nic_data: Hardware dependant state
 * @mac_lock: MAC access lock. Protects @port_enabled, @phy_mode,
- *      @port_inhibited, efx_monitor() and efx_reconfigure_port()
+ *      efx_monitor() and efx_reconfigure_port()
 * @port_enabled: Port enabled indicator.
 *      Serialises efx_stop_all(), efx_start_all(), efx_monitor() and
 *      efx_mac_work() with kernel interfaces. Safe to read under any
 *      one of the rtnl_lock, mac_lock, or netif_tx_lock, but all three must
 *      be held to modify it.
- * @port_inhibited: If set, the netif_carrier is always off. Hold the mac_lock
 * @port_initialized: Port initialized?
 * @net_dev: Operating system network device. Consider holding the rtnl lock
- * @rx_checksum_enabled: RX checksumming enabled
- * @mac_stats: MAC statistics. These include all statistics the MACs
- *      can provide.  Generic code converts these into a standard
- *      &struct net_device_stats.
 * @stats_buffer: DMA buffer for statistics
- * @stats_lock: Statistics update lock. Serialises statistics fetches
 * @mac_op: MAC interface
- * @mac_address: Permanent MAC address
 * @phy_type: PHY type
- * @mdio_lock: MDIO lock
 * @phy_op: PHY interface
 * @phy_data: PHY private data (including PHY-specific stats)
 * @mdio: PHY MDIO interface
 * @mdio_bus: PHY MDIO bus ID (only used by Siena)
 * @phy_mode: PHY operating mode. Serialised by @mac_lock.
- * @xmac_poll_required: XMAC link state needs polling
 * @link_advertising: Autonegotiation advertising flags
 * @link_state: Current state of the link
 * @n_link_state_changes: Number of times the link has changed state
@@ -701,21 +694,34 @@ union efx_multicast_hash {
 * @loopback_mode: Loopback status
 * @loopback_modes: Supported loopback mode bitmask
 * @loopback_selftest: Offline self-test private state
+ * @monitor_work: Hardware monitor workitem
+ * @biu_lock: BIU (bus interface unit) lock
+ * @last_irq_cpu: Last CPU to handle interrupt.
+ *      This register is written with the SMP processor ID whenever an
+ *      interrupt is handled.  It is used by efx_nic_test_interrupt()
+ *      to verify that an interrupt has occurred.
+ * @n_rx_nodesc_drop_cnt: RX no descriptor drop count
+ * @mac_stats: MAC statistics. These include all statistics the MACs
+ *      can provide.  Generic code converts these into a standard
+ *      &struct net_device_stats.
+ * @stats_lock: Statistics update lock. Serialises statistics fetches
 *
 * This is stored in the private area of the &struct net_device.
 */
 struct efx_nic {
+        /* The following fields should be written very rarely */
        char name[IFNAMSIZ];
        struct pci_dev *pci_dev;
        const struct efx_nic_type *type;
        int legacy_irq;
+        bool legacy_irq_enabled;
        struct workqueue_struct *workqueue;
        char workqueue_name[16];
        struct work_struct reset_work;
-        struct delayed_work monitor_work;
        resource_size_t membase_phys;
        void __iomem *membase;
-        spinlock_t biu_lock;
        enum efx_int_mode interrupt_mode;
        bool irq_rx_adaptive;
        unsigned int irq_rx_moderation;
@@ -724,13 +730,15 @@ struct efx_nic {
        enum nic_state state;
        enum reset_type reset_pending;
-        struct efx_tx_queue tx_queue[EFX_MAX_TX_QUEUES];
+        struct efx_channel *channel[EFX_MAX_CHANNELS];
-        struct efx_rx_queue rx_queue[EFX_MAX_RX_QUEUES];
+        char channel_name[EFX_MAX_CHANNELS][IFNAMSIZ + 6];
-        struct efx_channel channel[EFX_MAX_CHANNELS];
+        unsigned rxq_entries;
+        unsigned txq_entries;
        unsigned next_buffer_table;
        unsigned n_channels;
        unsigned n_rx_channels;
+        unsigned tx_channel_offset;
        unsigned n_tx_channels;
        unsigned int rx_buffer_len;
        unsigned int rx_buffer_order;
@@ -741,59 +749,57 @@ struct efx_nic {
        unsigned long int_error_expire;
        struct efx_buffer irq_status;
-        volatile signed int last_irq_cpu;
        unsigned irq_zero_count;
        unsigned fatal_irq_level;
-        struct efx_spi_device *spi_flash;
-        struct efx_spi_device *spi_eeprom;
-        struct mutex spi_lock;
 #ifdef CONFIG_SFC_MTD
        struct list_head mtd_list;
 #endif
-        unsigned n_rx_nodesc_drop_cnt;
        void *nic_data;
        struct mutex mac_lock;
        struct work_struct mac_work;
        bool port_enabled;
-        bool port_inhibited;
        bool port_initialized;
        struct net_device *net_dev;
-        bool rx_checksum_enabled;
-        struct efx_mac_stats mac_stats;
        struct efx_buffer stats_buffer;
-        spinlock_t stats_lock;
-        struct efx_mac_operations *mac_op;
+        const struct efx_mac_operations *mac_op;
-        unsigned char mac_address[ETH_ALEN];
        unsigned int phy_type;
-        struct mutex mdio_lock;
+        const struct efx_phy_operations *phy_op;
-        struct efx_phy_operations *phy_op;
        void *phy_data;
        struct mdio_if_info mdio;
        unsigned int mdio_bus;
        enum efx_phy_mode phy_mode;
-        bool xmac_poll_required;
        u32 link_advertising;
        struct efx_link_state link_state;
        unsigned int n_link_state_changes;
        bool promiscuous;
        union efx_multicast_hash multicast_hash;
-        enum efx_fc_type wanted_fc;
+        u8 wanted_fc;
        atomic_t rx_reset;
        enum efx_loopback_mode loopback_mode;
        u64 loopback_modes;
        void *loopback_selftest;
+        struct efx_filter_state *filter_state;
+        /* The following fields may be written more often */
+        struct delayed_work monitor_work ____cacheline_aligned_in_smp;
+        spinlock_t biu_lock;
+        volatile signed int last_irq_cpu;
+        unsigned n_rx_nodesc_drop_cnt;
+        struct efx_mac_stats mac_stats;
+        spinlock_t stats_lock;
 };
 static inline int efx_dev_registered(struct efx_nic *efx)
@@ -826,6 +832,7 @@ static inline unsigned int efx_port_num(struct efx_nic *efx)
 *      be called while the controller is uninitialised.
 * @probe_port: Probe the MAC and PHY
 * @remove_port: Free resources allocated by probe_port()
+ * @handle_global_event: Handle a "global" event (may be %NULL)
 * @prepare_flush: Prepare the hardware for flushing the DMA queues
 * @update_stats: Update statistics not provided by event handling
 * @start_stats: Start the regular fetching of statistics
@@ -870,6 +877,7 @@ struct efx_nic_type {
        int (*reset)(struct efx_nic *efx, enum reset_type method);
        int (*probe_port)(struct efx_nic *efx);
        void (*remove_port)(struct efx_nic *efx);
+        bool (*handle_global_event)(struct efx_channel *channel, efx_qword_t *);
        void (*prepare_flush)(struct efx_nic *efx);
        void (*update_stats)(struct efx_nic *efx);
        void (*start_stats)(struct efx_nic *efx);
@@ -883,7 +891,7 @@ struct efx_nic_type {
        void (*resume_wol)(struct efx_nic *efx);
        int (*test_registers)(struct efx_nic *efx);
        int (*test_nvram)(struct efx_nic *efx);
-        struct efx_mac_operations *default_mac_ops;
+        const struct efx_mac_operations *default_mac_ops;
        int revision;
        unsigned int mem_map_size;
@@ -899,7 +907,7 @@ struct efx_nic_type {
        unsigned int phys_addr_channels;
        unsigned int tx_dc_base;
        unsigned int rx_dc_base;
-        unsigned long offload_features;
+        u32 offload_features;
        u32 reset_world_flags;
 };
@@ -909,39 +917,102 @@ struct efx_nic_type {
 *
 *************************************************************************/
+static inline struct efx_channel *
+efx_get_channel(struct efx_nic *efx, unsigned index)
+{
+        EFX_BUG_ON_PARANOID(index >= efx->n_channels);
+        return efx->channel[index];
+}
 /* Iterate over all used channels */
 #define efx_for_each_channel(_channel, _efx)                            \
-        for (_channel = &((_efx)->channel[0]);                          \
+        for (_channel = (_efx)->channel[0];                             \
-             _channel < &((_efx)->channel[(efx)->n_channels]);          \
+             _channel;                                                  \
-             _channel++)
+             _channel = (_channel->channel + 1 < (_efx)->n_channels) ?  \
+                     (_efx)->channel[_channel->channel + 1] : NULL)
-/* Iterate over all used TX queues */
-#define efx_for_each_tx_queue(_tx_queue, _efx)                          \
+static inline struct efx_tx_queue *
-        for (_tx_queue = &((_efx)->tx_queue[0]);                        \
+efx_get_tx_queue(struct efx_nic *efx, unsigned index, unsigned type)
-             _tx_queue < &((_efx)->tx_queue[EFX_TXQ_TYPES *             \
+{
-                                            (_efx)->n_tx_channels]);    \
+        EFX_BUG_ON_PARANOID(index >= efx->n_tx_channels ||
-             _tx_queue++)
+                            type >= EFX_TXQ_TYPES);
+        return &efx->channel[efx->tx_channel_offset + index]->tx_queue[type];
+}
+static inline bool efx_channel_has_tx_queues(struct efx_channel *channel)
+{
+        return channel->channel - channel->efx->tx_channel_offset <
+                channel->efx->n_tx_channels;
+}
+static inline struct efx_tx_queue *
+efx_channel_get_tx_queue(struct efx_channel *channel, unsigned type)
+{
+        EFX_BUG_ON_PARANOID(!efx_channel_has_tx_queues(channel) ||
+                            type >= EFX_TXQ_TYPES);
+        return &channel->tx_queue[type];
+}
+static inline bool efx_tx_queue_used(struct efx_tx_queue *tx_queue)
+{
+        return !(tx_queue->efx->net_dev->num_tc < 2 &&
+                 tx_queue->queue & EFX_TXQ_TYPE_HIGHPRI);
+}
 /* Iterate over all TX queues belonging to a channel */
 #define efx_for_each_channel_tx_queue(_tx_queue, _channel)              \
+        if (!efx_channel_has_tx_queues(_channel))                       \
+                ;                                                       \
+        else                                                            \
+                for (_tx_queue = (_channel)->tx_queue;                  \
+                     _tx_queue < (_channel)->tx_queue + EFX_TXQ_TYPES && \
+                             efx_tx_queue_used(_tx_queue);              \
+                     _tx_queue++)
+/* Iterate over all possible TX queues belonging to a channel */
+#define efx_for_each_possible_channel_tx_queue(_tx_queue, _channel)     \
        for (_tx_queue = (_channel)->tx_queue;                          \
-             _tx_queue && _tx_queue < (_channel)->tx_queue + EFX_TXQ_TYPES; \
+             _tx_queue < (_channel)->tx_queue + EFX_TXQ_TYPES;          \
             _tx_queue++)
-/* Iterate over all used RX queues */
+static inline struct efx_rx_queue *
-#define efx_for_each_rx_queue(_rx_queue, _efx)                          \
+efx_get_rx_queue(struct efx_nic *efx, unsigned index)
-        for (_rx_queue = &((_efx)->rx_queue[0]);                        \
+{
-             _rx_queue < &((_efx)->rx_queue[(_efx)->n_rx_channels]);    \
+        EFX_BUG_ON_PARANOID(index >= efx->n_rx_channels);
-             _rx_queue++)
+        return &efx->channel[index]->rx_queue;
+}
+static inline bool efx_channel_has_rx_queue(struct efx_channel *channel)
+{
+        return channel->channel < channel->efx->n_rx_channels;
+}
+static inline struct efx_rx_queue *
+efx_channel_get_rx_queue(struct efx_channel *channel)
+{
+        EFX_BUG_ON_PARANOID(!efx_channel_has_rx_queue(channel));
+        return &channel->rx_queue;
+}
 /* Iterate over all RX queues belonging to a channel */
 #define efx_for_each_channel_rx_queue(_rx_queue, _channel)              \
-        for (_rx_queue = &((_channel)->efx->rx_queue[(_channel)->channel]); \
+        if (!efx_channel_has_rx_queue(_channel))                        \
-             _rx_queue;                                                 \
+                ;                                                       \
-             _rx_queue = NULL)                                          \
+        else                                                            \
-                if (_rx_queue->channel != (_channel))                   \
+                for (_rx_queue = &(_channel)->rx_queue;                 \
-                        continue;                                       \
+                     _rx_queue;                                         \
-                else
+                     _rx_queue = NULL)
+static inline struct efx_channel *
+efx_rx_queue_channel(struct efx_rx_queue *rx_queue)
+{
+        return container_of(rx_queue, struct efx_channel, rx_queue);
+}
+static inline int efx_rx_queue_index(struct efx_rx_queue *rx_queue)
+{
+        return efx_rx_queue_channel(rx_queue)->channel;
+}
 /* Returns a pointer to the specified receive buffer in the RX
 * descriptor queue.
@@ -949,7 +1020,7 @@ struct efx_nic_type {
 static inline struct efx_rx_buffer *efx_rx_buffer(struct efx_rx_queue *rx_queue,
                                                  unsigned int index)
 {
-        return (&rx_queue->buffer[index]);
+        return &rx_queue->buffer[index];
 }
 /* Set bit in a little-endian bitfield */
diff --git a/drivers/net/sfc/nic.c b/drivers/net/sfc/nic.c
index f595d920c7c4..f2a2b947f860 100644
--- a/drivers/net/sfc/nic.c
+++ b/drivers/net/sfc/nic.c
@@ -1,7 +1,7 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
 * Copyright 2005-2006 Fen Systems Ltd.
- * Copyright 2006-2009 Solarflare Communications Inc.
+ * Copyright 2006-2011 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -41,26 +41,6 @@
 #define RX_DC_ENTRIES 64
 #define RX_DC_ENTRIES_ORDER 3
-/* RX FIFO XOFF watermark
- *
- * When the amount of the RX FIFO increases used increases past this
- * watermark send XOFF. Only used if RX flow control is enabled (ethtool -A)
- * This also has an effect on RX/TX arbitration
- */
-int efx_nic_rx_xoff_thresh = -1;
-module_param_named(rx_xoff_thresh_bytes, efx_nic_rx_xoff_thresh, int, 0644);
-MODULE_PARM_DESC(rx_xoff_thresh_bytes, "RX fifo XOFF threshold");
-/* RX FIFO XON watermark
- *
- * When the amount of the RX FIFO used decreases below this
- * watermark send XON. Only used if TX flow control is enabled (ethtool -A)
- * This also has an effect on RX/TX arbitration
- */
-int efx_nic_rx_xon_thresh = -1;
-module_param_named(rx_xon_thresh_bytes, efx_nic_rx_xon_thresh, int, 0644);
-MODULE_PARM_DESC(rx_xon_thresh_bytes, "RX fifo XON threshold");
 /* If EFX_MAX_INT_ERRORS internal errors occur within
 * EFX_INT_ERROR_EXPIRE seconds, we consider the NIC broken and
 * disable it.
@@ -104,7 +84,8 @@ static inline void efx_write_buf_tbl(struct efx_nic *efx, efx_qword_t *value,
 static inline efx_qword_t *efx_event(struct efx_channel *channel,
                                     unsigned int index)
 {
-        return (((efx_qword_t *) (channel->eventq.addr)) + index);
+        return ((efx_qword_t *) (channel->eventq.addr)) +
+                (index & channel->eventq_mask);
 }
 /* See if an event is present
@@ -119,8 +100,8 @@ static inline efx_qword_t *efx_event(struct efx_channel *channel,
 */
 static inline int efx_event_present(efx_qword_t *event)
 {
-        return (!(EFX_DWORD_IS_ALL_ONES(event->dword[0]) |
+        return !(EFX_DWORD_IS_ALL_ONES(event->dword[0]) |
-                  EFX_DWORD_IS_ALL_ONES(event->dword[1])));
+                  EFX_DWORD_IS_ALL_ONES(event->dword[1]));
 }
 static bool efx_masked_compare_oword(const efx_oword_t *a, const efx_oword_t *b,
@@ -263,8 +244,8 @@ static int efx_alloc_special_buffer(struct efx_nic *efx,
 {
        len = ALIGN(len, EFX_BUF_SIZE);
-        buffer->addr = pci_alloc_consistent(efx->pci_dev, len,
+        buffer->addr = dma_alloc_coherent(&efx->pci_dev->dev, len,
-                                            &buffer->dma_addr);
+                                          &buffer->dma_addr, GFP_KERNEL);
        if (!buffer->addr)
                return -ENOMEM;
        buffer->len = len;
@@ -301,8 +282,8 @@ efx_free_special_buffer(struct efx_nic *efx, struct efx_special_buffer *buffer)
                  (u64)buffer->dma_addr, buffer->len,
                  buffer->addr, (u64)virt_to_phys(buffer->addr));
-        pci_free_consistent(efx->pci_dev, buffer->len, buffer->addr,
+        dma_free_coherent(&efx->pci_dev->dev, buffer->len, buffer->addr,
-                            buffer->dma_addr);
+                          buffer->dma_addr);
        buffer->addr = NULL;
        buffer->entries = 0;
 }
@@ -347,7 +328,7 @@ void efx_nic_free_buffer(struct efx_nic *efx, struct efx_buffer *buffer)
 static inline efx_qword_t *
 efx_tx_desc(struct efx_tx_queue *tx_queue, unsigned int index)
 {
-        return (((efx_qword_t *) (tx_queue->txd.addr)) + index);
+        return ((efx_qword_t *) (tx_queue->txd.addr)) + index;
 }
 /* This writes to the TX_DESC_WPTR; write pointer for TX descriptor ring */
@@ -356,12 +337,41 @@ static inline void efx_notify_tx_desc(struct efx_tx_queue *tx_queue)
        unsigned write_ptr;
        efx_dword_t reg;
-        write_ptr = tx_queue->write_count & EFX_TXQ_MASK;
+        write_ptr = tx_queue->write_count & tx_queue->ptr_mask;
        EFX_POPULATE_DWORD_1(reg, FRF_AZ_TX_DESC_WPTR_DWORD, write_ptr);
        efx_writed_page(tx_queue->efx, &reg,
                        FR_AZ_TX_DESC_UPD_DWORD_P0, tx_queue->queue);
 }
+/* Write pointer and first descriptor for TX descriptor ring */
+static inline void efx_push_tx_desc(struct efx_tx_queue *tx_queue,
+                                    const efx_qword_t *txd)
+{
+        unsigned write_ptr;
+        efx_oword_t reg;
+        BUILD_BUG_ON(FRF_AZ_TX_DESC_LBN != 0);
+        BUILD_BUG_ON(FR_AA_TX_DESC_UPD_KER != FR_BZ_TX_DESC_UPD_P0);
+        write_ptr = tx_queue->write_count & tx_queue->ptr_mask;
+        EFX_POPULATE_OWORD_2(reg, FRF_AZ_TX_DESC_PUSH_CMD, true,
+                             FRF_AZ_TX_DESC_WPTR, write_ptr);
+        reg.qword[0] = *txd;
+        efx_writeo_page(tx_queue->efx, &reg,
+                        FR_BZ_TX_DESC_UPD_P0, tx_queue->queue);
+}
+static inline bool
+efx_may_push_tx_desc(struct efx_tx_queue *tx_queue, unsigned int write_count)
+{
+        unsigned empty_read_count = ACCESS_ONCE(tx_queue->empty_read_count);
+        if (empty_read_count == 0)
+                return false;
+        tx_queue->empty_read_count = 0;
+        return ((empty_read_count ^ write_count) & ~EFX_EMPTY_COUNT_VALID) == 0;
+}
 /* For each entry inserted into the software descriptor ring, create a
 * descriptor in the hardware TX descriptor ring (in host memory), and
@@ -373,11 +383,12 @@ void efx_nic_push_buffers(struct efx_tx_queue *tx_queue)
        struct efx_tx_buffer *buffer;
        efx_qword_t *txd;
        unsigned write_ptr;
+        unsigned old_write_count = tx_queue->write_count;
        BUG_ON(tx_queue->write_count == tx_queue->insert_count);
        do {
-                write_ptr = tx_queue->write_count & EFX_TXQ_MASK;
+                write_ptr = tx_queue->write_count & tx_queue->ptr_mask;
                buffer = &tx_queue->buffer[write_ptr];
                txd = efx_tx_desc(tx_queue, write_ptr);
                ++tx_queue->write_count;
@@ -391,23 +402,32 @@ void efx_nic_push_buffers(struct efx_tx_queue *tx_queue)
        } while (tx_queue->write_count != tx_queue->insert_count);
        wmb(); /* Ensure descriptors are written before they are fetched */
-        efx_notify_tx_desc(tx_queue);
+        if (efx_may_push_tx_desc(tx_queue, old_write_count)) {
+                txd = efx_tx_desc(tx_queue,
+                                  old_write_count & tx_queue->ptr_mask);
+                efx_push_tx_desc(tx_queue, txd);
+                ++tx_queue->pushes;
+        } else {
+                efx_notify_tx_desc(tx_queue);
+        }
 }
 /* Allocate hardware resources for a TX queue */
 int efx_nic_probe_tx(struct efx_tx_queue *tx_queue)
 {
        struct efx_nic *efx = tx_queue->efx;
-        BUILD_BUG_ON(EFX_TXQ_SIZE < 512 || EFX_TXQ_SIZE > 4096 ||
+        unsigned entries;
-                     EFX_TXQ_SIZE & EFX_TXQ_MASK);
+        entries = tx_queue->ptr_mask + 1;
        return efx_alloc_special_buffer(efx, &tx_queue->txd,
-                                        EFX_TXQ_SIZE * sizeof(efx_qword_t));
+                                        entries * sizeof(efx_qword_t));
 }
 void efx_nic_init_tx(struct efx_tx_queue *tx_queue)
 {
-        efx_oword_t tx_desc_ptr;
        struct efx_nic *efx = tx_queue->efx;
+        efx_oword_t reg;
        tx_queue->flushed = FLUSH_NONE;
@@ -415,7 +435,7 @@ void efx_nic_init_tx(struct efx_tx_queue *tx_queue)
        efx_init_special_buffer(efx, &tx_queue->txd);
        /* Push TX descriptor ring to card */
-        EFX_POPULATE_OWORD_10(tx_desc_ptr,
+        EFX_POPULATE_OWORD_10(reg,
                              FRF_AZ_TX_DESCQ_EN, 1,
                              FRF_AZ_TX_ISCSI_DDIG_EN, 0,
                              FRF_AZ_TX_ISCSI_HDIG_EN, 0,
@@ -431,17 +451,15 @@ void efx_nic_init_tx(struct efx_tx_queue *tx_queue)
        if (efx_nic_rev(efx) >= EFX_REV_FALCON_B0) {
                int csum = tx_queue->queue & EFX_TXQ_TYPE_OFFLOAD;
-                EFX_SET_OWORD_FIELD(tx_desc_ptr, FRF_BZ_TX_IP_CHKSM_DIS, !csum);
+                EFX_SET_OWORD_FIELD(reg, FRF_BZ_TX_IP_CHKSM_DIS, !csum);
-                EFX_SET_OWORD_FIELD(tx_desc_ptr, FRF_BZ_TX_TCP_CHKSM_DIS,
+                EFX_SET_OWORD_FIELD(reg, FRF_BZ_TX_TCP_CHKSM_DIS,
                                    !csum);
        }
-        efx_writeo_table(efx, &tx_desc_ptr, efx->type->txd_ptr_tbl_base,
+        efx_writeo_table(efx, &reg, efx->type->txd_ptr_tbl_base,
                         tx_queue->queue);
        if (efx_nic_rev(efx) < EFX_REV_FALCON_B0) {
-                efx_oword_t reg;
                /* Only 128 bits in this register */
                BUILD_BUG_ON(EFX_MAX_TX_QUEUES > 128);
@@ -452,6 +470,16 @@ void efx_nic_init_tx(struct efx_tx_queue *tx_queue)
                        set_bit_le(tx_queue->queue, (void *)&reg);
                efx_writeo(efx, &reg, FR_AA_TX_CHKSM_CFG);
        }
+        if (efx_nic_rev(efx) >= EFX_REV_FALCON_B0) {
+                EFX_POPULATE_OWORD_1(reg,
+                                     FRF_BZ_TX_PACE,
+                                     (tx_queue->queue & EFX_TXQ_TYPE_HIGHPRI) ?
+                                     FFE_BZ_TX_PACE_OFF :
+                                     FFE_BZ_TX_PACE_RESERVED);
+                efx_writeo_table(efx, &reg, FR_BZ_TX_PACE_TBL,
+                                 tx_queue->queue);
+        }
 }
 static void efx_flush_tx_queue(struct efx_tx_queue *tx_queue)
@@ -501,7 +529,7 @@ void efx_nic_remove_tx(struct efx_tx_queue *tx_queue)
 static inline efx_qword_t *
 efx_rx_desc(struct efx_rx_queue *rx_queue, unsigned int index)
 {
-        return (((efx_qword_t *) (rx_queue->rxd.addr)) + index);
+        return ((efx_qword_t *) (rx_queue->rxd.addr)) + index;
 }
 /* This creates an entry in the RX descriptor queue */
@@ -526,30 +554,32 @@ efx_build_rx_desc(struct efx_rx_queue *rx_queue, unsigned index)
 */
 void efx_nic_notify_rx_desc(struct efx_rx_queue *rx_queue)
 {
+        struct efx_nic *efx = rx_queue->efx;
        efx_dword_t reg;
        unsigned write_ptr;
        while (rx_queue->notified_count != rx_queue->added_count) {
-                efx_build_rx_desc(rx_queue,
+                efx_build_rx_desc(
-                                  rx_queue->notified_count &
+                        rx_queue,
-                                  EFX_RXQ_MASK);
+                        rx_queue->notified_count & rx_queue->ptr_mask);
                ++rx_queue->notified_count;
        }
        wmb();
-        write_ptr = rx_queue->added_count & EFX_RXQ_MASK;
+        write_ptr = rx_queue->added_count & rx_queue->ptr_mask;
        EFX_POPULATE_DWORD_1(reg, FRF_AZ_RX_DESC_WPTR_DWORD, write_ptr);
-        efx_writed_page(rx_queue->efx, &reg,
+        efx_writed_page(efx, &reg, FR_AZ_RX_DESC_UPD_DWORD_P0,
-                        FR_AZ_RX_DESC_UPD_DWORD_P0, rx_queue->queue);
+                        efx_rx_queue_index(rx_queue));
 }
 int efx_nic_probe_rx(struct efx_rx_queue *rx_queue)
 {
        struct efx_nic *efx = rx_queue->efx;
-        BUILD_BUG_ON(EFX_RXQ_SIZE < 512 || EFX_RXQ_SIZE > 4096 ||
+        unsigned entries;
-                     EFX_RXQ_SIZE & EFX_RXQ_MASK);
+        entries = rx_queue->ptr_mask + 1;
        return efx_alloc_special_buffer(efx, &rx_queue->rxd,
-                                        EFX_RXQ_SIZE * sizeof(efx_qword_t));
+                                        entries * sizeof(efx_qword_t));
 }
 void efx_nic_init_rx(struct efx_rx_queue *rx_queue)
@@ -561,7 +591,7 @@ void efx_nic_init_rx(struct efx_rx_queue *rx_queue)
        netif_dbg(efx, hw, efx->net_dev,
                  "RX queue %d ring in special buffers %d-%d\n",
-                  rx_queue->queue, rx_queue->rxd.index,
+                  efx_rx_queue_index(rx_queue), rx_queue->rxd.index,
                  rx_queue->rxd.index + rx_queue->rxd.entries - 1);
        rx_queue->flushed = FLUSH_NONE;
@@ -575,9 +605,10 @@ void efx_nic_init_rx(struct efx_rx_queue *rx_queue)
                              FRF_AZ_RX_ISCSI_HDIG_EN, iscsi_digest_en,
                              FRF_AZ_RX_DESCQ_BUF_BASE_ID, rx_queue->rxd.index,
                              FRF_AZ_RX_DESCQ_EVQ_ID,
-                              rx_queue->channel->channel,
+                              efx_rx_queue_channel(rx_queue)->channel,
                              FRF_AZ_RX_DESCQ_OWNER_ID, 0,
-                              FRF_AZ_RX_DESCQ_LABEL, rx_queue->queue,
+                              FRF_AZ_RX_DESCQ_LABEL,
+                              efx_rx_queue_index(rx_queue),
                              FRF_AZ_RX_DESCQ_SIZE,
                              __ffs(rx_queue->rxd.entries),
                              FRF_AZ_RX_DESCQ_TYPE, 0 /* kernel queue */ ,
@@ -585,7 +616,7 @@ void efx_nic_init_rx(struct efx_rx_queue *rx_queue)
                              FRF_AZ_RX_DESCQ_JUMBO, !is_b0,
                              FRF_AZ_RX_DESCQ_EN, 1);
        efx_writeo_table(efx, &rx_desc_ptr, efx->type->rxd_ptr_tbl_base,
-                         rx_queue->queue);
+                         efx_rx_queue_index(rx_queue));
 }
 static void efx_flush_rx_queue(struct efx_rx_queue *rx_queue)
@@ -598,7 +629,8 @@ static void efx_flush_rx_queue(struct efx_rx_queue *rx_queue)
        /* Post a flush command */
        EFX_POPULATE_OWORD_2(rx_flush_descq,
                             FRF_AZ_RX_FLUSH_DESCQ_CMD, 1,
-                             FRF_AZ_RX_FLUSH_DESCQ, rx_queue->queue);
+                             FRF_AZ_RX_FLUSH_DESCQ,
+                             efx_rx_queue_index(rx_queue));
        efx_writeo(efx, &rx_flush_descq, FR_AZ_RX_FLUSH_DESCQ);
 }
@@ -613,7 +645,7 @@ void efx_nic_fini_rx(struct efx_rx_queue *rx_queue)
        /* Remove RX descriptor ring from card */
        EFX_ZERO_OWORD(rx_desc_ptr);
        efx_writeo_table(efx, &rx_desc_ptr, efx->type->rxd_ptr_tbl_base,
-                         rx_queue->queue);
+                         efx_rx_queue_index(rx_queue));
        /* Unpin RX descriptor ring */
        efx_fini_special_buffer(efx, &rx_queue->rxd);
@@ -642,13 +674,14 @@ void efx_nic_eventq_read_ack(struct efx_channel *channel)
        efx_dword_t reg;
        struct efx_nic *efx = channel->efx;
-        EFX_POPULATE_DWORD_1(reg, FRF_AZ_EVQ_RPTR, channel->eventq_read_ptr);
+        EFX_POPULATE_DWORD_1(reg, FRF_AZ_EVQ_RPTR,
+                             channel->eventq_read_ptr & channel->eventq_mask);
        efx_writed_table(efx, &reg, efx->type->evq_rptr_tbl_base,
                         channel->channel);
 }
 /* Use HW to insert a SW defined event */
-void efx_generate_event(struct efx_channel *channel, efx_qword_t *event)
+static void efx_generate_event(struct efx_channel *channel, efx_qword_t *event)
 {
        efx_oword_t drv_ev_reg;
@@ -680,15 +713,17 @@ efx_handle_tx_event(struct efx_channel *channel, efx_qword_t *event)
                /* Transmit completion */
                tx_ev_desc_ptr = EFX_QWORD_FIELD(*event, FSF_AZ_TX_EV_DESC_PTR);
                tx_ev_q_label = EFX_QWORD_FIELD(*event, FSF_AZ_TX_EV_Q_LABEL);
-                tx_queue = &efx->tx_queue[tx_ev_q_label];
+                tx_queue = efx_channel_get_tx_queue(
+                        channel, tx_ev_q_label % EFX_TXQ_TYPES);
                tx_packets = ((tx_ev_desc_ptr - tx_queue->read_count) &
-                              EFX_TXQ_MASK);
+                              tx_queue->ptr_mask);
                channel->irq_mod_score += tx_packets;
                efx_xmit_done(tx_queue, tx_ev_desc_ptr);
        } else if (EFX_QWORD_FIELD(*event, FSF_AZ_TX_EV_WQ_FF_FULL)) {
                /* Rewrite the FIFO write pointer */
                tx_ev_q_label = EFX_QWORD_FIELD(*event, FSF_AZ_TX_EV_Q_LABEL);
-                tx_queue = &efx->tx_queue[tx_ev_q_label];
+                tx_queue = efx_channel_get_tx_queue(
+                        channel, tx_ev_q_label % EFX_TXQ_TYPES);
                if (efx_dev_registered(efx))
                        netif_tx_lock(efx->net_dev);
@@ -714,6 +749,7 @@ static void efx_handle_rx_not_ok(struct efx_rx_queue *rx_queue,
                                 bool *rx_ev_pkt_ok,
                                 bool *discard)
 {
+        struct efx_channel *channel = efx_rx_queue_channel(rx_queue);
        struct efx_nic *efx = rx_queue->efx;
        bool rx_ev_buf_owner_id_err, rx_ev_ip_hdr_chksum_err;
        bool rx_ev_tcp_udp_chksum_err, rx_ev_eth_crc_err;
@@ -746,14 +782,14 @@ static void efx_handle_rx_not_ok(struct efx_rx_queue *rx_queue,
        /* Count errors that are not in MAC stats.  Ignore expected
         * checksum errors during self-test. */
        if (rx_ev_frm_trunc)
-                ++rx_queue->channel->n_rx_frm_trunc;
+                ++channel->n_rx_frm_trunc;
        else if (rx_ev_tobe_disc)
-                ++rx_queue->channel->n_rx_tobe_disc;
+                ++channel->n_rx_tobe_disc;
        else if (!efx->loopback_selftest) {
                if (rx_ev_ip_hdr_chksum_err)
-                        ++rx_queue->channel->n_rx_ip_hdr_chksum_err;
+                        ++channel->n_rx_ip_hdr_chksum_err;
                else if (rx_ev_tcp_udp_chksum_err)
-                        ++rx_queue->channel->n_rx_tcp_udp_chksum_err;
+                        ++channel->n_rx_tcp_udp_chksum_err;
        }
        /* The frame must be discarded if any of these are true. */
@@ -769,7 +805,7 @@ static void efx_handle_rx_not_ok(struct efx_rx_queue *rx_queue,
                netif_dbg(efx, rx_err, efx->net_dev,
                          " RX queue %d unexpected RX event "
                          EFX_QWORD_FMT "%s%s%s%s%s%s%s%s\n",
-                          rx_queue->queue, EFX_QWORD_VAL(*event),
+                          efx_rx_queue_index(rx_queue), EFX_QWORD_VAL(*event),
                          rx_ev_buf_owner_id_err ? " [OWNER_ID_ERR]" : "",
                          rx_ev_ip_hdr_chksum_err ?
                          " [IP_HDR_CHKSUM_ERR]" : "",
@@ -791,8 +827,8 @@ efx_handle_rx_bad_index(struct efx_rx_queue *rx_queue, unsigned index)
        struct efx_nic *efx = rx_queue->efx;
        unsigned expected, dropped;
-        expected = rx_queue->removed_count & EFX_RXQ_MASK;
+        expected = rx_queue->removed_count & rx_queue->ptr_mask;
-        dropped = (index - expected) & EFX_RXQ_MASK;
+        dropped = (index - expected) & rx_queue->ptr_mask;
        netif_info(efx, rx_err, efx->net_dev,
                   "dropped %d events (index=%d expected=%d)\n",
                   dropped, index, expected);
@@ -816,7 +852,6 @@ efx_handle_rx_event(struct efx_channel *channel, const efx_qword_t *event)
        unsigned expected_ptr;
        bool rx_ev_pkt_ok, discard = false, checksummed;
        struct efx_rx_queue *rx_queue;
-        struct efx_nic *efx = channel->efx;
        /* Basic packet information */
        rx_ev_byte_cnt = EFX_QWORD_FIELD(*event, FSF_AZ_RX_EV_BYTE_CNT);
@@ -827,10 +862,10 @@ efx_handle_rx_event(struct efx_channel *channel, const efx_qword_t *event)
        WARN_ON(EFX_QWORD_FIELD(*event, FSF_AZ_RX_EV_Q_LABEL) !=
                channel->channel);
-        rx_queue = &efx->rx_queue[channel->channel];
+        rx_queue = efx_channel_get_rx_queue(channel);
        rx_ev_desc_ptr = EFX_QWORD_FIELD(*event, FSF_AZ_RX_EV_DESC_PTR);
-        expected_ptr = rx_queue->removed_count & EFX_RXQ_MASK;
+        expected_ptr = rx_queue->removed_count & rx_queue->ptr_mask;
        if (unlikely(rx_ev_desc_ptr != expected_ptr))
                efx_handle_rx_bad_index(rx_queue, rx_ev_desc_ptr);
@@ -839,9 +874,8 @@ efx_handle_rx_event(struct efx_channel *channel, const efx_qword_t *event)
                 * UDP/IP, then we can rely on the hardware checksum.
                 */
                checksummed =
-                        likely(efx->rx_checksum_enabled) &&
+                        rx_ev_hdr_type == FSE_CZ_RX_EV_HDR_TYPE_IPV4V6_TCP ||
-                        (rx_ev_hdr_type == FSE_CZ_RX_EV_HDR_TYPE_IPV4V6_TCP ||
+                        rx_ev_hdr_type == FSE_CZ_RX_EV_HDR_TYPE_IPV4V6_UDP;
-                         rx_ev_hdr_type == FSE_CZ_RX_EV_HDR_TYPE_IPV4V6_UDP);
        } else {
                efx_handle_rx_not_ok(rx_queue, event, &rx_ev_pkt_ok, &discard);
                checksummed = false;
@@ -874,58 +908,18 @@ efx_handle_generated_event(struct efx_channel *channel, efx_qword_t *event)
        code = EFX_QWORD_FIELD(*event, FSF_AZ_DRV_GEN_EV_MAGIC);
        if (code == EFX_CHANNEL_MAGIC_TEST(channel))
-                ++channel->magic_count;
+                ; /* ignore */
        else if (code == EFX_CHANNEL_MAGIC_FILL(channel))
                /* The queue must be empty, so we won't receive any rx
                 * events, so efx_process_channel() won't refill the
                 * queue. Refill it here */
-                efx_fast_push_rx_descriptors(&efx->rx_queue[channel->channel]);
+                efx_fast_push_rx_descriptors(efx_channel_get_rx_queue(channel));
        else
                netif_dbg(efx, hw, efx->net_dev, "channel %d received "
                          "generated event "EFX_QWORD_FMT"\n",
                          channel->channel, EFX_QWORD_VAL(*event));
 }
-/* Global events are basically PHY events */
-static void
-efx_handle_global_event(struct efx_channel *channel, efx_qword_t *event)
-{
-        struct efx_nic *efx = channel->efx;
-        bool handled = false;
-        if (EFX_QWORD_FIELD(*event, FSF_AB_GLB_EV_G_PHY0_INTR) ||
-            EFX_QWORD_FIELD(*event, FSF_AB_GLB_EV_XG_PHY0_INTR) ||
-            EFX_QWORD_FIELD(*event, FSF_AB_GLB_EV_XFP_PHY0_INTR)) {
-                /* Ignored */
-                handled = true;
-        }
-        if ((efx_nic_rev(efx) >= EFX_REV_FALCON_B0) &&
-            EFX_QWORD_FIELD(*event, FSF_BB_GLB_EV_XG_MGT_INTR)) {
-                efx->xmac_poll_required = true;
-                handled = true;
-        }
-        if (efx_nic_rev(efx) <= EFX_REV_FALCON_A1 ?
-            EFX_QWORD_FIELD(*event, FSF_AA_GLB_EV_RX_RECOVERY) :
-            EFX_QWORD_FIELD(*event, FSF_BB_GLB_EV_RX_RECOVERY)) {
-                netif_err(efx, rx_err, efx->net_dev,
-                          "channel %d seen global RX_RESET event. Resetting.\n",
-                          channel->channel);
-                atomic_inc(&efx->rx_reset);
-                efx_schedule_reset(efx, EFX_WORKAROUND_6555(efx) ?
-                                   RESET_TYPE_RX_RECOVERY : RESET_TYPE_DISABLE);
-                handled = true;
-        }
-        if (!handled)
-                netif_err(efx, hw, efx->net_dev,
-                          "channel %d unknown global event "
-                          EFX_QWORD_FMT "\n", channel->channel,
-                          EFX_QWORD_VAL(*event));
-}
 static void
 efx_handle_driver_event(struct efx_channel *channel, efx_qword_t *event)
 {
@@ -997,6 +991,7 @@ efx_handle_driver_event(struct efx_channel *channel, efx_qword_t *event)
 int efx_nic_process_eventq(struct efx_channel *channel, int budget)
 {
+        struct efx_nic *efx = channel->efx;
        unsigned int read_ptr;
        efx_qword_t event, *p_event;
        int ev_code;
@@ -1020,8 +1015,7 @@ int efx_nic_process_eventq(struct efx_channel *channel, int budget)
                /* Clear this event by marking it all ones */
                EFX_SET_QWORD(*p_event);
-                /* Increment read pointer */
+                ++read_ptr;
-                read_ptr = (read_ptr + 1) & EFX_EVQ_MASK;
                ev_code = EFX_QWORD_FIELD(event, FSF_AZ_EV_CODE);
@@ -1033,7 +1027,7 @@ int efx_nic_process_eventq(struct efx_channel *channel, int budget)
                        break;
                case FSE_AZ_EV_CODE_TX_EV:
                        tx_packets += efx_handle_tx_event(channel, &event);
-                        if (tx_packets >= EFX_TXQ_SIZE) {
+                        if (tx_packets > efx->txq_entries) {
                                spent = budget;
                                goto out;
                        }
@@ -1041,15 +1035,17 @@ int efx_nic_process_eventq(struct efx_channel *channel, int budget)
                case FSE_AZ_EV_CODE_DRV_GEN_EV:
                        efx_handle_generated_event(channel, &event);
                        break;
-                case FSE_AZ_EV_CODE_GLOBAL_EV:
-                        efx_handle_global_event(channel, &event);
-                        break;
                case FSE_AZ_EV_CODE_DRIVER_EV:
                        efx_handle_driver_event(channel, &event);
                        break;
                case FSE_CZ_EV_CODE_MCDI_EV:
                        efx_mcdi_process_event(channel, &event);
                        break;
+                case FSE_AZ_EV_CODE_GLOBAL_EV:
+                        if (efx->type->handle_global_event &&
+                            efx->type->handle_global_event(channel, &event))
+                                break;
+                        /* else fall through */
                default:
                        netif_err(channel->efx, hw, channel->efx->net_dev,
                                  "channel %d unknown event type %d (data "
@@ -1063,15 +1059,23 @@ out:
        return spent;
 }
+/* Check whether an event is present in the eventq at the current
+ * read pointer.  Only useful for self-test.
+ */
+bool efx_nic_event_present(struct efx_channel *channel)
+{
+        return efx_event_present(efx_event(channel, channel->eventq_read_ptr));
+}
 /* Allocate buffer table entries for event queue */
 int efx_nic_probe_eventq(struct efx_channel *channel)
 {
        struct efx_nic *efx = channel->efx;
-        BUILD_BUG_ON(EFX_EVQ_SIZE < 512 || EFX_EVQ_SIZE > 32768 ||
+        unsigned entries;
-                     EFX_EVQ_SIZE & EFX_EVQ_MASK);
+        entries = channel->eventq_mask + 1;
        return efx_alloc_special_buffer(efx, &channel->eventq,
-                                        EFX_EVQ_SIZE * sizeof(efx_qword_t));
+                                        entries * sizeof(efx_qword_t));
 }
 void efx_nic_init_eventq(struct efx_channel *channel)
@@ -1163,11 +1167,11 @@ void efx_nic_generate_fill_event(struct efx_channel *channel)
 static void efx_poll_flush_events(struct efx_nic *efx)
 {
-        struct efx_channel *channel = &efx->channel[0];
+        struct efx_channel *channel = efx_get_channel(efx, 0);
        struct efx_tx_queue *tx_queue;
        struct efx_rx_queue *rx_queue;
        unsigned int read_ptr = channel->eventq_read_ptr;
-        unsigned int end_ptr = (read_ptr - 1) & EFX_EVQ_MASK;
+        unsigned int end_ptr = read_ptr + channel->eventq_mask - 1;
        do {
                efx_qword_t *event = efx_event(channel, read_ptr);
@@ -1185,7 +1189,9 @@ static void efx_poll_flush_events(struct efx_nic *efx)
                        ev_queue = EFX_QWORD_FIELD(*event,
                                                   FSF_AZ_DRIVER_EV_SUBDATA);
                        if (ev_queue < EFX_TXQ_TYPES * efx->n_tx_channels) {
-                                tx_queue = efx->tx_queue + ev_queue;
+                                tx_queue = efx_get_tx_queue(
+                                        efx, ev_queue / EFX_TXQ_TYPES,
+                                        ev_queue % EFX_TXQ_TYPES);
                                tx_queue->flushed = FLUSH_DONE;
                        }
                } else if (ev_code == FSE_AZ_EV_CODE_DRIVER_EV &&
@@ -1195,7 +1201,7 @@ static void efx_poll_flush_events(struct efx_nic *efx)
                        ev_failed = EFX_QWORD_FIELD(
                                *event, FSF_AZ_DRIVER_EV_RX_FLUSH_FAIL);
                        if (ev_queue < efx->n_rx_channels) {
-                                rx_queue = efx->rx_queue + ev_queue;
+                                rx_queue = efx_get_rx_queue(efx, ev_queue);
                                rx_queue->flushed =
                                        ev_failed ? FLUSH_FAILED : FLUSH_DONE;
                        }
@@ -1205,7 +1211,7 @@ static void efx_poll_flush_events(struct efx_nic *efx)
                 * it's ok to throw away every non-flush event */
                EFX_SET_QWORD(*event);
-                read_ptr = (read_ptr + 1) & EFX_EVQ_MASK;
+                ++read_ptr;
        } while (read_ptr != end_ptr);
        channel->eventq_read_ptr = read_ptr;
@@ -1216,6 +1222,7 @@ static void efx_poll_flush_events(struct efx_nic *efx)
 * serialise them */
 int efx_nic_flush_queues(struct efx_nic *efx)
 {
+        struct efx_channel *channel;
        struct efx_rx_queue *rx_queue;
        struct efx_tx_queue *tx_queue;
        int i, tx_pending, rx_pending;
@@ -1224,29 +1231,38 @@ int efx_nic_flush_queues(struct efx_nic *efx)
        efx->type->prepare_flush(efx);
        /* Flush all tx queues in parallel */
-        efx_for_each_tx_queue(tx_queue, efx)
+        efx_for_each_channel(channel, efx) {
-                efx_flush_tx_queue(tx_queue);
+                efx_for_each_possible_channel_tx_queue(tx_queue, channel) {
+                        if (tx_queue->initialised)
+                                efx_flush_tx_queue(tx_queue);
+                }
+        }
        /* The hardware supports four concurrent rx flushes, each of which may
         * need to be retried if there is an outstanding descriptor fetch */
        for (i = 0; i < EFX_FLUSH_POLL_COUNT; ++i) {
                rx_pending = tx_pending = 0;
-                efx_for_each_rx_queue(rx_queue, efx) {
+                efx_for_each_channel(channel, efx) {
-                        if (rx_queue->flushed == FLUSH_PENDING)
+                        efx_for_each_channel_rx_queue(rx_queue, channel) {
-                                ++rx_pending;
+                                if (rx_queue->flushed == FLUSH_PENDING)
-                }
+                                        ++rx_pending;
-                efx_for_each_rx_queue(rx_queue, efx) {
-                        if (rx_pending == EFX_RX_FLUSH_COUNT)
-                                break;
-                        if (rx_queue->flushed == FLUSH_FAILED ||
-                            rx_queue->flushed == FLUSH_NONE) {
-                                efx_flush_rx_queue(rx_queue);
-                                ++rx_pending;
                        }
                }
-                efx_for_each_tx_queue(tx_queue, efx) {
+                efx_for_each_channel(channel, efx) {
-                        if (tx_queue->flushed != FLUSH_DONE)
+                        efx_for_each_channel_rx_queue(rx_queue, channel) {
-                                ++tx_pending;
+                                if (rx_pending == EFX_RX_FLUSH_COUNT)
+                                        break;
+                                if (rx_queue->flushed == FLUSH_FAILED ||
+                                    rx_queue->flushed == FLUSH_NONE) {
+                                        efx_flush_rx_queue(rx_queue);
+                                        ++rx_pending;
+                                }
+                        }
+                        efx_for_each_possible_channel_tx_queue(tx_queue, channel) {
+                                if (tx_queue->initialised &&
+                                    tx_queue->flushed != FLUSH_DONE)
+                                        ++tx_pending;
+                        }
                }
                if (rx_pending == 0 && tx_pending == 0)
@@ -1258,19 +1274,22 @@ int efx_nic_flush_queues(struct efx_nic *efx)
        /* Mark the queues as all flushed. We're going to return failure
         * leading to a reset, or fake up success anyway */
-        efx_for_each_tx_queue(tx_queue, efx) {
+        efx_for_each_channel(channel, efx) {
-                if (tx_queue->flushed != FLUSH_DONE)
+                efx_for_each_possible_channel_tx_queue(tx_queue, channel) {
-                        netif_err(efx, hw, efx->net_dev,
+                        if (tx_queue->initialised &&
-                                  "tx queue %d flush command timed out\n",
+                            tx_queue->flushed != FLUSH_DONE)
-                                  tx_queue->queue);
+                                netif_err(efx, hw, efx->net_dev,
-                tx_queue->flushed = FLUSH_DONE;
+                                          "tx queue %d flush command timed out\n",
-        }
+                                          tx_queue->queue);
-        efx_for_each_rx_queue(rx_queue, efx) {
+                        tx_queue->flushed = FLUSH_DONE;
-                if (rx_queue->flushed != FLUSH_DONE)
+                }
-                        netif_err(efx, hw, efx->net_dev,
+                efx_for_each_channel_rx_queue(rx_queue, channel) {
-                                  "rx queue %d flush command timed out\n",
+                        if (rx_queue->flushed != FLUSH_DONE)
-                                  rx_queue->queue);
+                                netif_err(efx, hw, efx->net_dev,
-                rx_queue->flushed = FLUSH_DONE;
+                                          "rx queue %d flush command timed out\n",
+                                          efx_rx_queue_index(rx_queue));
+                        rx_queue->flushed = FLUSH_DONE;
+                }
        }
        return -ETIMEDOUT;
@@ -1397,6 +1416,12 @@ static irqreturn_t efx_legacy_interrupt(int irq, void *dev_id)
        u32 queues;
        int syserr;
+        /* Could this be ours?  If interrupts are disabled then the
+         * channel state may not be valid.
+         */
+        if (!efx->legacy_irq_enabled)
+                return result;
        /* Read the ISR which also ACKs the interrupts */
        efx_readd(efx, &reg, FR_BZ_INT_ISR0);
        queues = EFX_EXTRACT_DWORD(reg, 0, 31);
@@ -1457,7 +1482,7 @@ static irqreturn_t efx_legacy_interrupt(int irq, void *dev_id)
 */
 static irqreturn_t efx_msi_interrupt(int irq, void *dev_id)
 {
-        struct efx_channel *channel = dev_id;
+        struct efx_channel *channel = *(struct efx_channel **)dev_id;
        struct efx_nic *efx = channel->efx;
        efx_oword_t *int_ker = efx->irq_status.addr;
        int syserr;
@@ -1532,7 +1557,8 @@ int efx_nic_init_interrupt(struct efx_nic *efx)
        efx_for_each_channel(channel, efx) {
                rc = request_irq(channel->irq, efx_msi_interrupt,
                                 IRQF_PROBE_SHARED, /* Not shared */
-                                 channel->name, channel);
+                                 efx->channel_name[channel->channel],
+                                 &efx->channel[channel->channel]);
                if (rc) {
                        netif_err(efx, drv, efx->net_dev,
                                  "failed to hook IRQ %d\n", channel->irq);
@@ -1544,7 +1570,7 @@ int efx_nic_init_interrupt(struct efx_nic *efx)
 fail2:
        efx_for_each_channel(channel, efx)
-                free_irq(channel->irq, channel);
+                free_irq(channel->irq, &efx->channel[channel->channel]);
 fail1:
        return rc;
 }
@@ -1557,7 +1583,7 @@ void efx_nic_fini_interrupt(struct efx_nic *efx)
        /* Disable MSI/MSI-X interrupts */
        efx_for_each_channel(channel, efx) {
                if (channel->irq)
-                        free_irq(channel->irq, channel);
+                        free_irq(channel->irq, &efx->channel[channel->channel]);
        }
        /* ACK legacy interrupt */
@@ -1642,7 +1668,7 @@ void efx_nic_init_common(struct efx_nic *efx)
        EFX_SET_OWORD_FIELD(temp, FRF_AZ_TX_RX_SPACER, 0xfe);
        EFX_SET_OWORD_FIELD(temp, FRF_AZ_TX_RX_SPACER_EN, 1);
        EFX_SET_OWORD_FIELD(temp, FRF_AZ_TX_ONE_PKT_PER_Q, 1);
-        EFX_SET_OWORD_FIELD(temp, FRF_AZ_TX_PUSH_EN, 0);
+        EFX_SET_OWORD_FIELD(temp, FRF_AZ_TX_PUSH_EN, 1);
        EFX_SET_OWORD_FIELD(temp, FRF_AZ_TX_DIS_NON_IP_EV, 1);
        /* Enable SW_EV to inherit in char driver - assume harmless here */
        EFX_SET_OWORD_FIELD(temp, FRF_AZ_TX_SOFT_EVT_EN, 1);
@@ -1654,6 +1680,19 @@ void efx_nic_init_common(struct efx_nic *efx)
        if (efx_nic_rev(efx) >= EFX_REV_FALCON_B0)
                EFX_SET_OWORD_FIELD(temp, FRF_BZ_TX_FLUSH_MIN_LEN_EN, 1);
        efx_writeo(efx, &temp, FR_AZ_TX_RESERVED);
+        if (efx_nic_rev(efx) >= EFX_REV_FALCON_B0) {
+                EFX_POPULATE_OWORD_4(temp,
+                                     /* Default values */
+                                     FRF_BZ_TX_PACE_SB_NOT_AF, 0x15,
+                                     FRF_BZ_TX_PACE_SB_AF, 0xb,
+                                     FRF_BZ_TX_PACE_FB_BASE, 0,
+                                     /* Allow large pace values in the
+                                      * fast bin. */
+                                     FRF_BZ_TX_PACE_BIN_TH,
+                                     FFE_BZ_TX_PACE_RESERVED);
+                efx_writeo(efx, &temp, FR_BZ_TX_PACE);
+        }
 }
 /* Register dump */
@@ -1827,8 +1866,7 @@ static const struct efx_nic_reg_table efx_nic_reg_tables[] = {
        REGISTER_TABLE_BB_CZ(TX_DESC_PTR_TBL),
        REGISTER_TABLE_AA(EVQ_PTR_TBL_KER),
        REGISTER_TABLE_BB_CZ(EVQ_PTR_TBL),
-        /* The register buffer is allocated with slab, so we can't
+        /* We can't reasonably read all of the buffer table (up to 8MB!).
-         * reasonably read all of the buffer table (up to 8MB!).
         * However this driver will only use a few entries.  Reading
         * 1K entries allows for some expansion of queue count and
         * size before we need to change the version. */
@@ -1836,7 +1874,6 @@ static const struct efx_nic_reg_table efx_nic_reg_tables[] = {
                                  A, A, 8, 1024),
        REGISTER_TABLE_DIMENSIONS(BUF_FULL_TBL, FR_BZ_BUF_FULL_TBL,
                                  B, Z, 8, 1024),
-        /* RX_FILTER_TBL{0,1} is huge and not used by this driver */
        REGISTER_TABLE_CZ(RX_MAC_FILTER_TBL0),
        REGISTER_TABLE_BB_CZ(TIMER_TBL),
        REGISTER_TABLE_BB_CZ(TX_PACE_TBL),
@@ -1846,6 +1883,7 @@ static const struct efx_nic_reg_table efx_nic_reg_tables[] = {
        REGISTER_TABLE_CZ(MC_TREG_SMEM),
        /* MSIX_PBA_TABLE is not mapped */
        /* SRM_DBG is not mapped (and is redundant with BUF_FLL_TBL) */
+        REGISTER_TABLE_BZ(RX_FILTER_TBL0),
 };
 size_t efx_nic_get_regs_len(struct efx_nic *efx)
@@ -1897,6 +1935,13 @@ void efx_nic_get_regs(struct efx_nic *efx, void *buf)
                size = min_t(size_t, table->step, 16);
+                if (table->offset >= efx->type->mem_map_size) {
+                        /* No longer mapped; return dummy data */
+                        memcpy(buf, "\xde\xc0\xad\xde", 4);
+                        buf += table->rows * size;
+                        continue;
+                }
                for (i = 0; i < table->rows; i++) {
                        switch (table->step) {
                        case 4: /* 32-bit register or SRAM */
diff --git a/drivers/net/sfc/nic.h b/drivers/net/sfc/nic.h
index 0438dc98722d..4bd1f2839dfe 100644
--- a/drivers/net/sfc/nic.h
+++ b/drivers/net/sfc/nic.h
@@ -1,7 +1,7 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
 * Copyright 2005-2006 Fen Systems Ltd.
- * Copyright 2006-2009 Solarflare Communications Inc.
+ * Copyright 2006-2011 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -15,6 +15,7 @@
 #include "net_driver.h"
 #include "efx.h"
 #include "mcdi.h"
+#include "spi.h"
 /*
 * Falcon hardware control
@@ -113,6 +114,11 @@ struct falcon_board {
 * @stats_pending: Is there a pending DMA of MAC statistics.
 * @stats_timer: A timer for regularly fetching MAC statistics.
 * @stats_dma_done: Pointer to the flag which indicates DMA completion.
+ * @spi_flash: SPI flash device
+ * @spi_eeprom: SPI EEPROM device
+ * @spi_lock: SPI bus lock
+ * @mdio_lock: MDIO bus lock
+ * @xmac_poll_required: XMAC link state needs polling
 */
 struct falcon_nic_data {
        struct pci_dev *pci_dev2;
@@ -121,6 +127,11 @@ struct falcon_nic_data {
        bool stats_pending;
        struct timer_list stats_timer;
        u32 *stats_dma_done;
+        struct efx_spi_device spi_flash;
+        struct efx_spi_device spi_eeprom;
+        struct mutex spi_lock;
+        struct mutex mdio_lock;
+        bool xmac_poll_required;
 };
 static inline struct falcon_board *falcon_board(struct efx_nic *efx)
@@ -131,24 +142,19 @@ static inline struct falcon_board *falcon_board(struct efx_nic *efx)
 /**
 * struct siena_nic_data - Siena NIC state
- * @fw_version: Management controller firmware version
- * @fw_build: Firmware build number
 * @mcdi: Management-Controller-to-Driver Interface
+ * @mcdi_smem: MCDI shared memory mapping. The mapping is always uncacheable.
 * @wol_filter_id: Wake-on-LAN packet filter id
- * @ipv6_rss_key: Toeplitz hash key for IPv6 RSS
 */
 struct siena_nic_data {
-        u64 fw_version;
-        u32 fw_build;
        struct efx_mcdi_iface mcdi;
+        void __iomem *mcdi_smem;
        int wol_filter_id;
 };
-extern void siena_print_fwver(struct efx_nic *efx, char *buf, size_t len);
+extern const struct efx_nic_type falcon_a1_nic_type;
+extern const struct efx_nic_type falcon_b0_nic_type;
-extern struct efx_nic_type falcon_a1_nic_type;
+extern const struct efx_nic_type siena_a0_nic_type;
-extern struct efx_nic_type falcon_b0_nic_type;
-extern struct efx_nic_type siena_a0_nic_type;
 /**************************************************************************
 *
@@ -180,11 +186,11 @@ extern void efx_nic_fini_eventq(struct efx_channel *channel);
 extern void efx_nic_remove_eventq(struct efx_channel *channel);
 extern int efx_nic_process_eventq(struct efx_channel *channel, int rx_quota);
 extern void efx_nic_eventq_read_ack(struct efx_channel *channel);
+extern bool efx_nic_event_present(struct efx_channel *channel);
 /* MAC/PHY */
 extern void falcon_drain_tx_fifo(struct efx_nic *efx);
 extern void falcon_reconfigure_mac_wrapper(struct efx_nic *efx);
-extern int efx_nic_rx_xoff_thresh, efx_nic_rx_xon_thresh;
 /* Interrupts and test events */
 extern int efx_nic_init_interrupt(struct efx_nic *efx);
diff --git a/drivers/net/sfc/phy.h b/drivers/net/sfc/phy.h
index 5bc26137257b..11d148cd8441 100644
--- a/drivers/net/sfc/phy.h
+++ b/drivers/net/sfc/phy.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
- * Copyright 2007-2009 Solarflare Communications Inc.
+ * Copyright 2007-2010 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -11,21 +11,16 @@
 #define EFX_PHY_H
 /****************************************************************************
- * 10Xpress (SFX7101 and SFT9001) PHYs
+ * 10Xpress (SFX7101) PHY
 */
-extern struct efx_phy_operations falcon_sfx7101_phy_ops;
+extern const struct efx_phy_operations falcon_sfx7101_phy_ops;
-extern struct efx_phy_operations falcon_sft9001_phy_ops;
 extern void tenxpress_set_id_led(struct efx_nic *efx, enum efx_led_mode mode);
-/* Wait for the PHY to boot. Return 0 on success, -EINVAL if the PHY failed
- * to boot due to corrupt flash, or some other negative error code. */
-extern int sft9001_wait_boot(struct efx_nic *efx);
 /****************************************************************************
 * AMCC/Quake QT202x PHYs
 */
-extern struct efx_phy_operations falcon_qt202x_phy_ops;
+extern const struct efx_phy_operations falcon_qt202x_phy_ops;
 /* These PHYs provide various H/W control states for LEDs */
 #define QUAKE_LED_LINK_INVAL    (0)
@@ -42,9 +37,20 @@ extern struct efx_phy_operations falcon_qt202x_phy_ops;
 extern void falcon_qt202x_set_led(struct efx_nic *p, int led, int state);
 /****************************************************************************
+* Transwitch CX4 retimer
+*/
+extern const struct efx_phy_operations falcon_txc_phy_ops;
+#define TXC_GPIO_DIR_INPUT      0
+#define TXC_GPIO_DIR_OUTPUT     1
+extern void falcon_txc_set_gpio_dir(struct efx_nic *efx, int pin, int dir);
+extern void falcon_txc_set_gpio_val(struct efx_nic *efx, int pin, int val);
+/****************************************************************************
 * Siena managed PHYs
 */
-extern struct efx_phy_operations efx_mcdi_phy_ops;
+extern const struct efx_phy_operations efx_mcdi_phy_ops;
 extern int efx_mcdi_mdio_read(struct efx_nic *efx, unsigned int bus,
                              unsigned int prtad, unsigned int devad,
diff --git a/drivers/net/sfc/qt202x_phy.c b/drivers/net/sfc/qt202x_phy.c
index 68813d1d85f3..7ad97e397406 100644
--- a/drivers/net/sfc/qt202x_phy.c
+++ b/drivers/net/sfc/qt202x_phy.c
@@ -1,6 +1,6 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
- * Copyright 2006-2009 Solarflare Communications Inc.
+ * Copyright 2006-2010 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -41,6 +41,8 @@
 #define PCS_UC_STATUS_LBN       0
 #define PCS_UC_STATUS_WIDTH     8
 #define PCS_UC_STATUS_FW_SAVE   0x20
+#define PMA_PMD_MODE_REG        0xc301
+#define PMA_PMD_RXIN_SEL_LBN    6
 #define PMA_PMD_FTX_CTRL2_REG   0xc309
 #define PMA_PMD_FTX_STATIC_LBN  13
 #define PMA_PMD_VEND1_REG       0xc001
@@ -282,6 +284,10 @@ static int qt2025c_select_phy_mode(struct efx_nic *efx)
         * slow) reload of the firmware image (the microcontroller's code
         * memory is not affected by the microcontroller reset). */
        efx_mdio_write(efx, 1, 0xc317, 0x00ff);
+        /* PMA/PMD loopback sets RXIN to inverse polarity and the firmware
+         * restart doesn't reset it. We need to do that ourselves. */
+        efx_mdio_set_flag(efx, 1, PMA_PMD_MODE_REG,
+                          1 << PMA_PMD_RXIN_SEL_LBN, false);
        efx_mdio_write(efx, 1, 0xc300, 0x0002);
        msleep(20);
@@ -443,7 +449,7 @@ static void qt202x_phy_remove(struct efx_nic *efx)
        efx->phy_data = NULL;
 }
-struct efx_phy_operations falcon_qt202x_phy_ops = {
+const struct efx_phy_operations falcon_qt202x_phy_ops = {
        .probe           = qt202x_phy_probe,
        .init            = qt202x_phy_init,
        .reconfigure     = qt202x_phy_reconfigure,
diff --git a/drivers/net/sfc/regs.h b/drivers/net/sfc/regs.h
index 18a3be428348..cc2c86b76a7b 100644
--- a/drivers/net/sfc/regs.h
+++ b/drivers/net/sfc/regs.h
@@ -1,7 +1,7 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
 * Copyright 2005-2006 Fen Systems Ltd.
- * Copyright 2006-2009 Solarflare Communications Inc.
+ * Copyright 2006-2010 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -2893,6 +2893,26 @@
 #define FRF_AB_XX_FORCE_SIG_WIDTH 8
 #define FFE_AB_XX_FORCE_SIG_ALL_LANES 0xff
+/* RX_MAC_FILTER_TBL0 */
+/* RMFT_DEST_MAC is wider than 32 bits */
+#define FRF_CZ_RMFT_DEST_MAC_LO_LBN 12
+#define FRF_CZ_RMFT_DEST_MAC_LO_WIDTH 32
+#define FRF_CZ_RMFT_DEST_MAC_HI_LBN 44
+#define FRF_CZ_RMFT_DEST_MAC_HI_WIDTH 16
+/* TX_MAC_FILTER_TBL0 */
+/* TMFT_SRC_MAC is wider than 32 bits */
+#define FRF_CZ_TMFT_SRC_MAC_LO_LBN 12
+#define FRF_CZ_TMFT_SRC_MAC_LO_WIDTH 32
+#define FRF_CZ_TMFT_SRC_MAC_HI_LBN 44
+#define FRF_CZ_TMFT_SRC_MAC_HI_WIDTH 16
+/* TX_PACE_TBL */
+/* Values >20 are documented as reserved, but will result in a queue going
+ * into the fast bin with a pace value of zero. */
+#define FFE_BZ_TX_PACE_OFF 0
+#define FFE_BZ_TX_PACE_RESERVED 21
 /* DRIVER_EV */
 /* Sub-fields of an RX flush completion event */
 #define FSF_AZ_DRIVER_EV_RX_FLUSH_FAIL_LBN 12
diff --git a/drivers/net/sfc/rx.c b/drivers/net/sfc/rx.c
index 799c461ce7b8..62e43649466e 100644
--- a/drivers/net/sfc/rx.c
+++ b/drivers/net/sfc/rx.c
@@ -1,7 +1,7 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
 * Copyright 2005-2006 Fen Systems Ltd.
- * Copyright 2005-2009 Solarflare Communications Inc.
+ * Copyright 2005-2011 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -14,6 +14,7 @@
 #include <linux/ip.h>
 #include <linux/tcp.h>
 #include <linux/udp.h>
+#include <linux/prefetch.h>
 #include <net/ip.h>
 #include <net/checksum.h>
 #include "net_driver.h"
@@ -37,7 +38,7 @@
 * This driver supports two methods for allocating and using RX buffers:
 * each RX buffer may be backed by an skb or by an order-n page.
 *
- * When LRO is in use then the second method has a lower overhead,
+ * When GRO is in use then the second method has a lower overhead,
 * since we don't have to allocate then free skbs on reassembled frames.
 *
 * Values:
@@ -50,25 +51,25 @@
 *
 *   - Since pushing and popping descriptors are separated by the rx_queue
 *     size, so the watermarks should be ~rxd_size.
- *   - The performance win by using page-based allocation for LRO is less
+ *   - The performance win by using page-based allocation for GRO is less
- *     than the performance hit of using page-based allocation of non-LRO,
+ *     than the performance hit of using page-based allocation of non-GRO,
 *     so the watermarks should reflect this.
 *
 * Per channel we maintain a single variable, updated by each channel:
 *
- *   rx_alloc_level += (lro_performed ? RX_ALLOC_FACTOR_LRO :
+ *   rx_alloc_level += (gro_performed ? RX_ALLOC_FACTOR_GRO :
 *                      RX_ALLOC_FACTOR_SKB)
 * Per NAPI poll interval, we constrain rx_alloc_level to 0..MAX (which
 * limits the hysteresis), and update the allocation strategy:
 *
- *   rx_alloc_method = (rx_alloc_level > RX_ALLOC_LEVEL_LRO ?
+ *   rx_alloc_method = (rx_alloc_level > RX_ALLOC_LEVEL_GRO ?
 *                      RX_ALLOC_METHOD_PAGE : RX_ALLOC_METHOD_SKB)
 */
 static int rx_alloc_method = RX_ALLOC_METHOD_AUTO;
-#define RX_ALLOC_LEVEL_LRO 0x2000
+#define RX_ALLOC_LEVEL_GRO 0x2000
 #define RX_ALLOC_LEVEL_MAX 0x3000
-#define RX_ALLOC_FACTOR_LRO 1
+#define RX_ALLOC_FACTOR_GRO 1
 #define RX_ALLOC_FACTOR_SKB (-2)
 /* This is the percentage fill level below which new RX descriptors
@@ -89,24 +90,37 @@ static unsigned int rx_refill_limit = 95;
 */
 #define EFX_RXD_HEAD_ROOM 2
-static inline unsigned int efx_rx_buf_offset(struct efx_rx_buffer *buf)
+/* Offset of ethernet header within page */
+static inline unsigned int efx_rx_buf_offset(struct efx_nic *efx,
+                                             struct efx_rx_buffer *buf)
 {
        /* Offset is always within one page, so we don't need to consider
         * the page order.
         */
-        return (__force unsigned long) buf->data & (PAGE_SIZE - 1);
+        return (((__force unsigned long) buf->dma_addr & (PAGE_SIZE - 1)) +
+                efx->type->rx_buffer_hash_size);
 }
 static inline unsigned int efx_rx_buf_size(struct efx_nic *efx)
 {
        return PAGE_SIZE << efx->rx_buffer_order;
 }
-static inline u32 efx_rx_buf_hash(struct efx_rx_buffer *buf)
+static u8 *efx_rx_buf_eh(struct efx_nic *efx, struct efx_rx_buffer *buf)
 {
+        if (buf->is_page)
+                return page_address(buf->u.page) + efx_rx_buf_offset(efx, buf);
+        else
+                return ((u8 *)buf->u.skb->data +
+                        efx->type->rx_buffer_hash_size);
+}
+static inline u32 efx_rx_buf_hash(const u8 *eh)
+{
+        /* The ethernet header is always directly after any hash. */
 #if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) || NET_IP_ALIGN % 4 == 0
-        return __le32_to_cpup((const __le32 *)(buf->data - 4));
+        return __le32_to_cpup((const __le32 *)(eh - 4));
 #else
-        const u8 *data = (const u8 *)(buf->data - 4);
+        const u8 *data = eh - 4;
        return ((u32)data[0]       |
                (u32)data[1] << 8  |
                (u32)data[2] << 16 |
@@ -129,31 +143,31 @@ static int efx_init_rx_buffers_skb(struct efx_rx_queue *rx_queue)
        struct efx_nic *efx = rx_queue->efx;
        struct net_device *net_dev = efx->net_dev;
        struct efx_rx_buffer *rx_buf;
+        struct sk_buff *skb;
        int skb_len = efx->rx_buffer_len;
        unsigned index, count;
        for (count = 0; count < EFX_RX_BATCH; ++count) {
-                index = rx_queue->added_count & EFX_RXQ_MASK;
+                index = rx_queue->added_count & rx_queue->ptr_mask;
                rx_buf = efx_rx_buffer(rx_queue, index);
-                rx_buf->skb = netdev_alloc_skb(net_dev, skb_len);
+                rx_buf->u.skb = skb = netdev_alloc_skb(net_dev, skb_len);
-                if (unlikely(!rx_buf->skb))
+                if (unlikely(!skb))
                        return -ENOMEM;
-                rx_buf->page = NULL;
                /* Adjust the SKB for padding and checksum */
-                skb_reserve(rx_buf->skb, NET_IP_ALIGN);
+                skb_reserve(skb, NET_IP_ALIGN);
                rx_buf->len = skb_len - NET_IP_ALIGN;
-                rx_buf->data = (char *)rx_buf->skb->data;
+                rx_buf->is_page = false;
-                rx_buf->skb->ip_summed = CHECKSUM_UNNECESSARY;
+                skb->ip_summed = CHECKSUM_UNNECESSARY;
                rx_buf->dma_addr = pci_map_single(efx->pci_dev,
-                                                  rx_buf->data, rx_buf->len,
+                                                  skb->data, rx_buf->len,
                                                  PCI_DMA_FROMDEVICE);
                if (unlikely(pci_dma_mapping_error(efx->pci_dev,
                                                   rx_buf->dma_addr))) {
-                        dev_kfree_skb_any(rx_buf->skb);
+                        dev_kfree_skb_any(skb);
-                        rx_buf->skb = NULL;
+                        rx_buf->u.skb = NULL;
                        return -EIO;
                }
@@ -208,13 +222,12 @@ static int efx_init_rx_buffers_page(struct efx_rx_queue *rx_queue)
                dma_addr += sizeof(struct efx_rx_page_state);
        split:
-                index = rx_queue->added_count & EFX_RXQ_MASK;
+                index = rx_queue->added_count & rx_queue->ptr_mask;
                rx_buf = efx_rx_buffer(rx_queue, index);
                rx_buf->dma_addr = dma_addr + EFX_PAGE_IP_ALIGN;
-                rx_buf->skb = NULL;
+                rx_buf->u.page = page;
-                rx_buf->page = page;
-                rx_buf->data = page_addr + EFX_PAGE_IP_ALIGN;
                rx_buf->len = efx->rx_buffer_len - EFX_PAGE_IP_ALIGN;
+                rx_buf->is_page = true;
                ++rx_queue->added_count;
                ++rx_queue->alloc_page_count;
                ++state->refcnt;
@@ -235,19 +248,17 @@ static int efx_init_rx_buffers_page(struct efx_rx_queue *rx_queue)
 static void efx_unmap_rx_buffer(struct efx_nic *efx,
                                struct efx_rx_buffer *rx_buf)
 {
-        if (rx_buf->page) {
+        if (rx_buf->is_page && rx_buf->u.page) {
                struct efx_rx_page_state *state;
-                EFX_BUG_ON_PARANOID(rx_buf->skb);
+                state = page_address(rx_buf->u.page);
-                state = page_address(rx_buf->page);
                if (--state->refcnt == 0) {
                        pci_unmap_page(efx->pci_dev,
                                       state->dma_addr,
                                       efx_rx_buf_size(efx),
                                       PCI_DMA_FROMDEVICE);
                }
-        } else if (likely(rx_buf->skb)) {
+        } else if (!rx_buf->is_page && rx_buf->u.skb) {
                pci_unmap_single(efx->pci_dev, rx_buf->dma_addr,
                                 rx_buf->len, PCI_DMA_FROMDEVICE);
        }
@@ -256,12 +267,12 @@ static void efx_unmap_rx_buffer(struct efx_nic *efx,
 static void efx_free_rx_buffer(struct efx_nic *efx,
                               struct efx_rx_buffer *rx_buf)
 {
-        if (rx_buf->page) {
+        if (rx_buf->is_page && rx_buf->u.page) {
-                __free_pages(rx_buf->page, efx->rx_buffer_order);
+                __free_pages(rx_buf->u.page, efx->rx_buffer_order);
-                rx_buf->page = NULL;
+                rx_buf->u.page = NULL;
-        } else if (likely(rx_buf->skb)) {
+        } else if (!rx_buf->is_page && rx_buf->u.skb) {
-                dev_kfree_skb_any(rx_buf->skb);
+                dev_kfree_skb_any(rx_buf->u.skb);
-                rx_buf->skb = NULL;
+                rx_buf->u.skb = NULL;
        }
 }
@@ -277,7 +288,7 @@ static void efx_fini_rx_buffer(struct efx_rx_queue *rx_queue,
 static void efx_resurrect_rx_buffer(struct efx_rx_queue *rx_queue,
                                    struct efx_rx_buffer *rx_buf)
 {
-        struct efx_rx_page_state *state = page_address(rx_buf->page);
+        struct efx_rx_page_state *state = page_address(rx_buf->u.page);
        struct efx_rx_buffer *new_buf;
        unsigned fill_level, index;
@@ -285,23 +296,21 @@ static void efx_resurrect_rx_buffer(struct efx_rx_queue *rx_queue,
         * we'd like to insert an additional descriptor whilst leaving
         * EFX_RXD_HEAD_ROOM for the non-recycle path */
        fill_level = (rx_queue->added_count - rx_queue->removed_count + 2);
-        if (unlikely(fill_level >= EFX_RXQ_SIZE - EFX_RXD_HEAD_ROOM)) {
+        if (unlikely(fill_level > rx_queue->max_fill)) {
                /* We could place "state" on a list, and drain the list in
                 * efx_fast_push_rx_descriptors(). For now, this will do. */
                return;
        }
        ++state->refcnt;
-        get_page(rx_buf->page);
+        get_page(rx_buf->u.page);
-        index = rx_queue->added_count & EFX_RXQ_MASK;
+        index = rx_queue->added_count & rx_queue->ptr_mask;
        new_buf = efx_rx_buffer(rx_queue, index);
        new_buf->dma_addr = rx_buf->dma_addr ^ (PAGE_SIZE >> 1);
-        new_buf->skb = NULL;
+        new_buf->u.page = rx_buf->u.page;
-        new_buf->page = rx_buf->page;
-        new_buf->data = (void *)
-                ((__force unsigned long)rx_buf->data ^ (PAGE_SIZE >> 1));
        new_buf->len = rx_buf->len;
+        new_buf->is_page = true;
        ++rx_queue->added_count;
 }
@@ -311,20 +320,19 @@ static void efx_recycle_rx_buffer(struct efx_channel *channel,
                                  struct efx_rx_buffer *rx_buf)
 {
        struct efx_nic *efx = channel->efx;
-        struct efx_rx_queue *rx_queue = &efx->rx_queue[channel->channel];
+        struct efx_rx_queue *rx_queue = efx_channel_get_rx_queue(channel);
        struct efx_rx_buffer *new_buf;
        unsigned index;
-        if (rx_buf->page != NULL && efx->rx_buffer_len <= EFX_RX_HALF_PAGE &&
+        if (rx_buf->is_page && efx->rx_buffer_len <= EFX_RX_HALF_PAGE &&
-            page_count(rx_buf->page) == 1)
+            page_count(rx_buf->u.page) == 1)
                efx_resurrect_rx_buffer(rx_queue, rx_buf);
-        index = rx_queue->added_count & EFX_RXQ_MASK;
+        index = rx_queue->added_count & rx_queue->ptr_mask;
        new_buf = efx_rx_buffer(rx_queue, index);
        memcpy(new_buf, rx_buf, sizeof(*new_buf));
-        rx_buf->page = NULL;
+        rx_buf->u.page = NULL;
-        rx_buf->skb = NULL;
        ++rx_queue->added_count;
 }
@@ -341,13 +349,13 @@ static void efx_recycle_rx_buffer(struct efx_channel *channel,
 */
 void efx_fast_push_rx_descriptors(struct efx_rx_queue *rx_queue)
 {
-        struct efx_channel *channel = rx_queue->channel;
+        struct efx_channel *channel = efx_rx_queue_channel(rx_queue);
        unsigned fill_level;
        int space, rc = 0;
        /* Calculate current fill level, and exit if we don't need to fill */
        fill_level = (rx_queue->added_count - rx_queue->removed_count);
-        EFX_BUG_ON_PARANOID(fill_level > EFX_RXQ_SIZE);
+        EFX_BUG_ON_PARANOID(fill_level > rx_queue->efx->rxq_entries);
        if (fill_level >= rx_queue->fast_fill_trigger)
                goto out;
@@ -364,7 +372,8 @@ void efx_fast_push_rx_descriptors(struct efx_rx_queue *rx_queue)
        netif_vdbg(rx_queue->efx, rx_status, rx_queue->efx->net_dev,
                   "RX queue %d fast-filling descriptor ring from"
                   " level %d to level %d using %s allocation\n",
-                   rx_queue->queue, fill_level, rx_queue->fast_fill_limit,
+                   efx_rx_queue_index(rx_queue), fill_level,
+                   rx_queue->fast_fill_limit,
                   channel->rx_alloc_push_pages ? "page" : "skb");
        do {
@@ -382,7 +391,7 @@ void efx_fast_push_rx_descriptors(struct efx_rx_queue *rx_queue)
        netif_vdbg(rx_queue->efx, rx_status, rx_queue->efx->net_dev,
                   "RX queue %d fast-filled descriptor ring "
-                   "to level %d\n", rx_queue->queue,
+                   "to level %d\n", efx_rx_queue_index(rx_queue),
                   rx_queue->added_count - rx_queue->removed_count);
 out:
@@ -393,7 +402,7 @@ void efx_fast_push_rx_descriptors(struct efx_rx_queue *rx_queue)
 void efx_rx_slow_fill(unsigned long context)
 {
        struct efx_rx_queue *rx_queue = (struct efx_rx_queue *)context;
-        struct efx_channel *channel = rx_queue->channel;
+        struct efx_channel *channel = efx_rx_queue_channel(rx_queue);
        /* Post an event to cause NAPI to run and refill the queue */
        efx_nic_generate_fill_event(channel);
@@ -421,45 +430,44 @@ static void efx_rx_packet__check_len(struct efx_rx_queue *rx_queue,
                        netif_err(efx, rx_err, efx->net_dev,
                                  " RX queue %d seriously overlength "
                                  "RX event (0x%x > 0x%x+0x%x). Leaking\n",
-                                  rx_queue->queue, len, max_len,
+                                  efx_rx_queue_index(rx_queue), len, max_len,
                                  efx->type->rx_buffer_padding);
                /* If this buffer was skb-allocated, then the meta
                 * data at the end of the skb will be trashed. So
                 * we have no choice but to leak the fragment.
                 */
-                *leak_packet = (rx_buf->skb != NULL);
+                *leak_packet = !rx_buf->is_page;
                efx_schedule_reset(efx, RESET_TYPE_RX_RECOVERY);
        } else {
                if (net_ratelimit())
                        netif_err(efx, rx_err, efx->net_dev,
                                  " RX queue %d overlength RX event "
                                  "(0x%x > 0x%x)\n",
-                                  rx_queue->queue, len, max_len);
+                                  efx_rx_queue_index(rx_queue), len, max_len);
        }
-        rx_queue->channel->n_rx_overlength++;
+        efx_rx_queue_channel(rx_queue)->n_rx_overlength++;
 }
-/* Pass a received packet up through the generic LRO stack
+/* Pass a received packet up through the generic GRO stack
 *
 * Handles driverlink veto, and passes the fragment up via
- * the appropriate LRO method
+ * the appropriate GRO method
 */
-static void efx_rx_packet_lro(struct efx_channel *channel,
+static void efx_rx_packet_gro(struct efx_channel *channel,
                              struct efx_rx_buffer *rx_buf,
-                              bool checksummed)
+                              const u8 *eh, bool checksummed)
 {
        struct napi_struct *napi = &channel->napi_str;
        gro_result_t gro_result;
-        /* Pass the skb/page into the LRO engine */
+        /* Pass the skb/page into the GRO engine */
-        if (rx_buf->page) {
+        if (rx_buf->is_page) {
                struct efx_nic *efx = channel->efx;
-                struct page *page = rx_buf->page;
+                struct page *page = rx_buf->u.page;
                struct sk_buff *skb;
-                EFX_BUG_ON_PARANOID(rx_buf->skb);
+                rx_buf->u.page = NULL;
-                rx_buf->page = NULL;
                skb = napi_get_frags(napi);
                if (!skb) {
@@ -468,11 +476,11 @@ static void efx_rx_packet_lro(struct efx_channel *channel,
                }
                if (efx->net_dev->features & NETIF_F_RXHASH)
-                        skb->rxhash = efx_rx_buf_hash(rx_buf);
+                        skb->rxhash = efx_rx_buf_hash(eh);
                skb_shinfo(skb)->frags[0].page = page;
                skb_shinfo(skb)->frags[0].page_offset =
-                        efx_rx_buf_offset(rx_buf);
+                        efx_rx_buf_offset(efx, rx_buf);
                skb_shinfo(skb)->frags[0].size = rx_buf->len;
                skb_shinfo(skb)->nr_frags = 1;
@@ -486,11 +494,10 @@ static void efx_rx_packet_lro(struct efx_channel *channel,
                gro_result = napi_gro_frags(napi);
        } else {
-                struct sk_buff *skb = rx_buf->skb;
+                struct sk_buff *skb = rx_buf->u.skb;
-                EFX_BUG_ON_PARANOID(!skb);
                EFX_BUG_ON_PARANOID(!checksummed);
-                rx_buf->skb = NULL;
+                rx_buf->u.skb = NULL;
                gro_result = napi_gro_receive(napi, skb);
        }
@@ -498,7 +505,7 @@ static void efx_rx_packet_lro(struct efx_channel *channel,
        if (gro_result == GRO_NORMAL) {
                channel->rx_alloc_level += RX_ALLOC_FACTOR_SKB;
        } else if (gro_result != GRO_DROP) {
-                channel->rx_alloc_level += RX_ALLOC_FACTOR_LRO;
+                channel->rx_alloc_level += RX_ALLOC_FACTOR_GRO;
                channel->irq_mod_score += 2;
        }
 }
@@ -507,14 +514,11 @@ void efx_rx_packet(struct efx_rx_queue *rx_queue, unsigned int index,
                   unsigned int len, bool checksummed, bool discard)
 {
        struct efx_nic *efx = rx_queue->efx;
-        struct efx_channel *channel = rx_queue->channel;
+        struct efx_channel *channel = efx_rx_queue_channel(rx_queue);
        struct efx_rx_buffer *rx_buf;
        bool leak_packet = false;
        rx_buf = efx_rx_buffer(rx_queue, index);
-        EFX_BUG_ON_PARANOID(!rx_buf->data);
-        EFX_BUG_ON_PARANOID(rx_buf->skb && rx_buf->page);
-        EFX_BUG_ON_PARANOID(!(rx_buf->skb || rx_buf->page));
        /* This allows the refill path to post another buffer.
         * EFX_RXD_HEAD_ROOM ensures that the slot we are using
@@ -528,7 +532,7 @@ void efx_rx_packet(struct efx_rx_queue *rx_queue, unsigned int index,
        netif_vdbg(efx, rx_status, efx->net_dev,
                   "RX queue %d received id %x at %llx+%x %s%s\n",
-                   rx_queue->queue, index,
+                   efx_rx_queue_index(rx_queue), index,
                   (unsigned long long)rx_buf->dma_addr, len,
                   (checksummed ? " [SUMMED]" : ""),
                   (discard ? " [DISCARD]" : ""));
@@ -553,19 +557,18 @@ void efx_rx_packet(struct efx_rx_queue *rx_queue, unsigned int index,
        /* Prefetch nice and early so data will (hopefully) be in cache by
         * the time we look at it.
         */
-        prefetch(rx_buf->data);
+        prefetch(efx_rx_buf_eh(efx, rx_buf));
        /* Pipeline receives so that we give time for packet headers to be
         * prefetched into cache.
         */
-        rx_buf->len = len;
+        rx_buf->len = len - efx->type->rx_buffer_hash_size;
 out:
-        if (rx_queue->channel->rx_pkt)
+        if (channel->rx_pkt)
-                __efx_rx_packet(rx_queue->channel,
+                __efx_rx_packet(channel,
-                                rx_queue->channel->rx_pkt,
+                                channel->rx_pkt, channel->rx_pkt_csummed);
-                                rx_queue->channel->rx_pkt_csummed);
+        channel->rx_pkt = rx_buf;
-        rx_queue->channel->rx_pkt = rx_buf;
+        channel->rx_pkt_csummed = checksummed;
-        rx_queue->channel->rx_pkt_csummed = checksummed;
 }
 /* Handle a received packet.  Second half: Touches packet payload. */
@@ -574,48 +577,49 @@ void __efx_rx_packet(struct efx_channel *channel,
 {
        struct efx_nic *efx = channel->efx;
        struct sk_buff *skb;
+        u8 *eh = efx_rx_buf_eh(efx, rx_buf);
-        rx_buf->data += efx->type->rx_buffer_hash_size;
-        rx_buf->len -= efx->type->rx_buffer_hash_size;
        /* If we're in loopback test, then pass the packet directly to the
         * loopback layer, and free the rx_buf here
         */
        if (unlikely(efx->loopback_selftest)) {
-                efx_loopback_rx_packet(efx, rx_buf->data, rx_buf->len);
+                efx_loopback_rx_packet(efx, eh, rx_buf->len);
                efx_free_rx_buffer(efx, rx_buf);
                return;
        }
-        if (rx_buf->skb) {
+        if (!rx_buf->is_page) {
-                prefetch(skb_shinfo(rx_buf->skb));
+                skb = rx_buf->u.skb;
-                skb_reserve(rx_buf->skb, efx->type->rx_buffer_hash_size);
+                prefetch(skb_shinfo(skb));
-                skb_put(rx_buf->skb, rx_buf->len);
+                skb_reserve(skb, efx->type->rx_buffer_hash_size);
+                skb_put(skb, rx_buf->len);
                if (efx->net_dev->features & NETIF_F_RXHASH)
-                        rx_buf->skb->rxhash = efx_rx_buf_hash(rx_buf);
+                        skb->rxhash = efx_rx_buf_hash(eh);
                /* Move past the ethernet header. rx_buf->data still points
                 * at the ethernet header */
-                rx_buf->skb->protocol = eth_type_trans(rx_buf->skb,
+                skb->protocol = eth_type_trans(skb, efx->net_dev);
-                                                       efx->net_dev);
-                skb_record_rx_queue(rx_buf->skb, channel->channel);
+                skb_record_rx_queue(skb, channel->channel);
        }
-        if (likely(checksummed || rx_buf->page)) {
+        if (unlikely(!(efx->net_dev->features & NETIF_F_RXCSUM)))
-                efx_rx_packet_lro(channel, rx_buf, checksummed);
+                checksummed = false;
+        if (likely(checksummed || rx_buf->is_page)) {
+                efx_rx_packet_gro(channel, rx_buf, eh, checksummed);
                return;
        }
        /* We now own the SKB */
-        skb = rx_buf->skb;
+        skb = rx_buf->u.skb;
-        rx_buf->skb = NULL;
+        rx_buf->u.skb = NULL;
-        EFX_BUG_ON_PARANOID(!skb);
        /* Set the SKB flags */
-        skb->ip_summed = CHECKSUM_NONE;
+        skb_checksum_none_assert(skb);
        /* Pass the packet up */
        netif_receive_skb(skb);
@@ -628,7 +632,7 @@ void efx_rx_strategy(struct efx_channel *channel)
 {
        enum efx_rx_alloc_method method = rx_alloc_method;
-        /* Only makes sense to use page based allocation if LRO is enabled */
+        /* Only makes sense to use page based allocation if GRO is enabled */
        if (!(channel->efx->net_dev->features & NETIF_F_GRO)) {
                method = RX_ALLOC_METHOD_SKB;
        } else if (method == RX_ALLOC_METHOD_AUTO) {
@@ -639,7 +643,7 @@ void efx_rx_strategy(struct efx_channel *channel)
                        channel->rx_alloc_level = RX_ALLOC_LEVEL_MAX;
                /* Decide on the allocation method */
-                method = ((channel->rx_alloc_level > RX_ALLOC_LEVEL_LRO) ?
+                method = ((channel->rx_alloc_level > RX_ALLOC_LEVEL_GRO) ?
                          RX_ALLOC_METHOD_PAGE : RX_ALLOC_METHOD_SKB);
        }
@@ -650,15 +654,22 @@ void efx_rx_strategy(struct efx_channel *channel)
 int efx_probe_rx_queue(struct efx_rx_queue *rx_queue)
 {
        struct efx_nic *efx = rx_queue->efx;
-        unsigned int rxq_size;
+        unsigned int entries;
        int rc;
+        /* Create the smallest power-of-two aligned ring */
+        entries = max(roundup_pow_of_two(efx->rxq_entries), EFX_MIN_DMAQ_SIZE);
+        EFX_BUG_ON_PARANOID(entries > EFX_MAX_DMAQ_SIZE);
+        rx_queue->ptr_mask = entries - 1;
        netif_dbg(efx, probe, efx->net_dev,
-                  "creating RX queue %d\n", rx_queue->queue);
+                  "creating RX queue %d size %#x mask %#x\n",
+                  efx_rx_queue_index(rx_queue), efx->rxq_entries,
+                  rx_queue->ptr_mask);
        /* Allocate RX buffers */
-        rxq_size = EFX_RXQ_SIZE * sizeof(*rx_queue->buffer);
+        rx_queue->buffer = kzalloc(entries * sizeof(*rx_queue->buffer),
-        rx_queue->buffer = kzalloc(rxq_size, GFP_KERNEL);
+                                   GFP_KERNEL);
        if (!rx_queue->buffer)
                return -ENOMEM;
@@ -672,20 +683,20 @@ int efx_probe_rx_queue(struct efx_rx_queue *rx_queue)
 void efx_init_rx_queue(struct efx_rx_queue *rx_queue)
 {
+        struct efx_nic *efx = rx_queue->efx;
        unsigned int max_fill, trigger, limit;
        netif_dbg(rx_queue->efx, drv, rx_queue->efx->net_dev,
-                  "initialising RX queue %d\n", rx_queue->queue);
+                  "initialising RX queue %d\n", efx_rx_queue_index(rx_queue));
        /* Initialise ptr fields */
        rx_queue->added_count = 0;
        rx_queue->notified_count = 0;
        rx_queue->removed_count = 0;
        rx_queue->min_fill = -1U;
-        rx_queue->min_overfill = -1U;
        /* Initialise limit fields */
-        max_fill = EFX_RXQ_SIZE - EFX_RXD_HEAD_ROOM;
+        max_fill = efx->rxq_entries - EFX_RXD_HEAD_ROOM;
        trigger = max_fill * min(rx_refill_threshold, 100U) / 100U;
        limit = max_fill * min(rx_refill_limit, 100U) / 100U;
@@ -703,14 +714,14 @@ void efx_fini_rx_queue(struct efx_rx_queue *rx_queue)
        struct efx_rx_buffer *rx_buf;
        netif_dbg(rx_queue->efx, drv, rx_queue->efx->net_dev,
-                  "shutting down RX queue %d\n", rx_queue->queue);
+                  "shutting down RX queue %d\n", efx_rx_queue_index(rx_queue));
        del_timer_sync(&rx_queue->slow_fill);
        efx_nic_fini_rx(rx_queue);
        /* Release RX buffers NB start at index 0 not current HW ptr */
        if (rx_queue->buffer) {
-                for (i = 0; i <= EFX_RXQ_MASK; i++) {
+                for (i = 0; i <= rx_queue->ptr_mask; i++) {
                        rx_buf = efx_rx_buffer(rx_queue, i);
                        efx_fini_rx_buffer(rx_queue, rx_buf);
                }
@@ -720,7 +731,7 @@ void efx_fini_rx_queue(struct efx_rx_queue *rx_queue)
 void efx_remove_rx_queue(struct efx_rx_queue *rx_queue)
 {
        netif_dbg(rx_queue->efx, drv, rx_queue->efx->net_dev,
-                  "destroying RX queue %d\n", rx_queue->queue);
+                  "destroying RX queue %d\n", efx_rx_queue_index(rx_queue));
        efx_nic_remove_rx(rx_queue);
diff --git a/drivers/net/sfc/selftest.c b/drivers/net/sfc/selftest.c
index 85f015f005d5..822f6c2a6a7c 100644
--- a/drivers/net/sfc/selftest.c
+++ b/drivers/net/sfc/selftest.c
@@ -1,7 +1,7 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
 * Copyright 2005-2006 Fen Systems Ltd.
- * Copyright 2006-2009 Solarflare Communications Inc.
+ * Copyright 2006-2010 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -48,6 +48,16 @@ static const unsigned char payload_source[ETH_ALEN] = {
 static const char payload_msg[] =
        "Hello world! This is an Efx loopback test in progress!";
+/* Interrupt mode names */
+static const unsigned int efx_interrupt_mode_max = EFX_INT_MODE_MAX;
+static const char *efx_interrupt_mode_names[] = {
+        [EFX_INT_MODE_MSIX]   = "MSI-X",
+        [EFX_INT_MODE_MSI]    = "MSI",
+        [EFX_INT_MODE_LEGACY] = "legacy",
+};
+#define INT_MODE(efx) \
+        STRING_TABLE_LOOKUP(efx->interrupt_mode, efx_interrupt_mode)
 /**
 * efx_loopback_state - persistent state during a loopback selftest
 * @flush:              Drop all packets in efx_loopback_rx_packet
@@ -121,8 +131,6 @@ static int efx_test_chip(struct efx_nic *efx, struct efx_self_tests *tests)
 static int efx_test_interrupts(struct efx_nic *efx,
                               struct efx_self_tests *tests)
 {
-        struct efx_channel *channel;
        netif_dbg(efx, drv, efx->net_dev, "testing interrupts\n");
        tests->interrupt = -1;
@@ -130,15 +138,6 @@ static int efx_test_interrupts(struct efx_nic *efx,
        efx->last_irq_cpu = -1;
        smp_wmb();
-        /* ACK each interrupting event queue. Receiving an interrupt due to
-         * traffic before a test event is raised is considered a pass */
-        efx_for_each_channel(channel, efx) {
-                if (channel->work_pending)
-                        efx_process_channel_now(channel);
-                if (efx->last_irq_cpu >= 0)
-                        goto success;
-        }
        efx_nic_generate_interrupt(efx);
        /* Wait for arrival of test interrupt. */
@@ -163,13 +162,13 @@ static int efx_test_eventq_irq(struct efx_channel *channel,
                               struct efx_self_tests *tests)
 {
        struct efx_nic *efx = channel->efx;
-        unsigned int magic_count, count;
+        unsigned int read_ptr, count;
        tests->eventq_dma[channel->channel] = -1;
        tests->eventq_int[channel->channel] = -1;
        tests->eventq_poll[channel->channel] = -1;
-        magic_count = channel->magic_count;
+        read_ptr = channel->eventq_read_ptr;
        channel->efx->last_irq_cpu = -1;
        smp_wmb();
@@ -180,10 +179,7 @@ static int efx_test_eventq_irq(struct efx_channel *channel,
        do {
                schedule_timeout_uninterruptible(HZ / 100);
-                if (channel->work_pending)
+                if (ACCESS_ONCE(channel->eventq_read_ptr) != read_ptr)
-                        efx_process_channel_now(channel);
-                if (channel->magic_count != magic_count)
                        goto eventq_ok;
        } while (++count < 2);
@@ -201,8 +197,7 @@ static int efx_test_eventq_irq(struct efx_channel *channel,
        }
        /* Check to see if event was received even if interrupt wasn't */
-        efx_process_channel_now(channel);
+        if (efx_nic_event_present(channel)) {
-        if (channel->magic_count != magic_count) {
                netif_err(efx, drv, efx->net_dev,
                          "channel %d event was generated, but "
                          "failed to trigger an interrupt\n", channel->channel);
@@ -506,7 +501,7 @@ efx_test_loopback(struct efx_tx_queue *tx_queue,
        for (i = 0; i < 3; i++) {
                /* Determine how many packets to send */
-                state->packet_count = EFX_TXQ_SIZE / 3;
+                state->packet_count = efx->txq_entries / 3;
                state->packet_count = min(1 << (i << 2), state->packet_count);
                state->skbs = kzalloc(sizeof(state->skbs[0]) *
                                      state->packet_count, GFP_KERNEL);
@@ -567,7 +562,7 @@ static int efx_wait_for_link(struct efx_nic *efx)
                        efx->type->monitor(efx);
                        mutex_unlock(&efx->mac_lock);
                } else {
-                        struct efx_channel *channel = &efx->channel[0];
+                        struct efx_channel *channel = efx_get_channel(efx, 0);
                        if (channel->work_pending)
                                efx_process_channel_now(channel);
                }
@@ -594,6 +589,7 @@ static int efx_test_loopbacks(struct efx_nic *efx, struct efx_self_tests *tests,
 {
        enum efx_loopback_mode mode;
        struct efx_loopback_state *state;
+        struct efx_channel *channel = efx_get_channel(efx, 0);
        struct efx_tx_queue *tx_queue;
        int rc = 0;
@@ -633,8 +629,8 @@ static int efx_test_loopbacks(struct efx_nic *efx, struct efx_self_tests *tests,
                        goto out;
                }
-                /* Test both types of TX queue */
+                /* Test all enabled types of TX queue */
-                efx_for_each_channel_tx_queue(tx_queue, &efx->channel[0]) {
+                efx_for_each_channel_tx_queue(tx_queue, channel) {
                        state->offload_csum = (tx_queue->queue &
                                               EFX_TXQ_TYPE_OFFLOAD);
                        rc = efx_test_loopback(tx_queue,
@@ -699,12 +695,12 @@ int efx_selftest(struct efx_nic *efx, struct efx_self_tests *tests,
        /* Offline (i.e. disruptive) testing
         * This checks MAC and PHY loopback on the specified port. */
-        /* force the carrier state off so the kernel doesn't transmit during
+        /* Detach the device so the kernel doesn't transmit during the
-         * the loopback test, and the watchdog timeout doesn't fire. Also put
+         * loopback test and the watchdog timeout doesn't fire.
-         * falcon into loopback for the register test.
         */
+        netif_device_detach(efx->net_dev);
        mutex_lock(&efx->mac_lock);
-        efx->port_inhibited = true;
        if (efx->loopback_modes) {
                /* We need the 312 clock from the PHY to test the XMAC
                 * registers, so move into XGMII loopback if available */
@@ -754,11 +750,12 @@ int efx_selftest(struct efx_nic *efx, struct efx_self_tests *tests,
        /* restore the PHY to the previous state */
        mutex_lock(&efx->mac_lock);
        efx->phy_mode = phy_mode;
-        efx->port_inhibited = false;
        efx->loopback_mode = loopback_mode;
        __efx_reconfigure_port(efx);
        mutex_unlock(&efx->mac_lock);
+        netif_device_attach(efx->net_dev);
        return rc_test;
 }
diff --git a/drivers/net/sfc/selftest.h b/drivers/net/sfc/selftest.h
index aed495a4dad7..dba5456e70f3 100644
--- a/drivers/net/sfc/selftest.h
+++ b/drivers/net/sfc/selftest.h
@@ -1,7 +1,7 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
 * Copyright 2005-2006 Fen Systems Ltd.
- * Copyright 2006-2008 Solarflare Communications Inc.
+ * Copyright 2006-2010 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
diff --git a/drivers/net/sfc/siena.c b/drivers/net/sfc/siena.c
index 3fab030f8ab5..fb4721f780ff 100644
--- a/drivers/net/sfc/siena.c
+++ b/drivers/net/sfc/siena.c
@@ -1,7 +1,7 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
 * Copyright 2005-2006 Fen Systems Ltd.
- * Copyright 2006-2009 Solarflare Communications Inc.
+ * Copyright 2006-2010 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -129,7 +129,7 @@ static int siena_probe_port(struct efx_nic *efx)
        return 0;
 }
-void siena_remove_port(struct efx_nic *efx)
+static void siena_remove_port(struct efx_nic *efx)
 {
        efx->phy_op->remove(efx);
        efx_nic_free_buffer(efx, &efx->stats_buffer);
@@ -194,13 +194,7 @@ static int siena_reset_hw(struct efx_nic *efx, enum reset_type method)
 static int siena_probe_nvconfig(struct efx_nic *efx)
 {
-        int rc;
+        return efx_mcdi_get_board_cfg(efx, efx->net_dev->perm_addr, NULL);
-        rc = efx_mcdi_get_board_cfg(efx, efx->mac_address, NULL);
-        if (rc)
-                return rc;
-        return 0;
 }
 static int siena_probe_nic(struct efx_nic *efx)
@@ -226,19 +220,26 @@ static int siena_probe_nic(struct efx_nic *efx)
        efx_reado(efx, &reg, FR_AZ_CS_DEBUG);
        efx->net_dev->dev_id = EFX_OWORD_FIELD(reg, FRF_CZ_CS_PORT_NUM) - 1;
+        /* Initialise MCDI */
+        nic_data->mcdi_smem = ioremap_nocache(efx->membase_phys +
+                                              FR_CZ_MC_TREG_SMEM,
+                                              FR_CZ_MC_TREG_SMEM_STEP *
+                                              FR_CZ_MC_TREG_SMEM_ROWS);
+        if (!nic_data->mcdi_smem) {
+                netif_err(efx, probe, efx->net_dev,
+                          "could not map MCDI at %llx+%x\n",
+                          (unsigned long long)efx->membase_phys +
+                          FR_CZ_MC_TREG_SMEM,
+                          FR_CZ_MC_TREG_SMEM_STEP * FR_CZ_MC_TREG_SMEM_ROWS);
+                rc = -ENOMEM;
+                goto fail1;
+        }
        efx_mcdi_init(efx);
        /* Recover from a failed assertion before probing */
        rc = efx_mcdi_handle_assertion(efx);
        if (rc)
-                goto fail1;
+                goto fail2;
-        rc = efx_mcdi_fwver(efx, &nic_data->fw_version, &nic_data->fw_build);
-        if (rc) {
-                netif_err(efx, probe, efx->net_dev,
-                          "Failed to read MCPU firmware version - rc %d\n", rc);
-                goto fail1; /* MCPU absent? */
-        }
        /* Let the BMC know that the driver is now in charge of link and
         * filter settings. We must do this before we reset the NIC */
@@ -293,6 +294,7 @@ fail4:
 fail3:
        efx_mcdi_drv_attach(efx, false, NULL);
 fail2:
+        iounmap(nic_data->mcdi_smem);
 fail1:
        kfree(efx->nic_data);
        return rc;
@@ -354,11 +356,6 @@ static int siena_init_nic(struct efx_nic *efx)
               FRF_CZ_RX_RSS_IPV6_TKEY_HI_WIDTH / 8);
        efx_writeo(efx, &temp, FR_CZ_RX_RSS_IPV6_REG3);
-        if (efx_nic_rx_xoff_thresh >= 0 || efx_nic_rx_xon_thresh >= 0)
-                /* No MCDI operation has been defined to set thresholds */
-                netif_err(efx, hw, efx->net_dev,
-                          "ignoring RX flow control thresholds\n");
        /* Enable event logging */
        rc = efx_mcdi_log_ctrl(efx, true, false, 0);
        if (rc)
@@ -377,6 +374,8 @@ static int siena_init_nic(struct efx_nic *efx)
 static void siena_remove_nic(struct efx_nic *efx)
 {
+        struct siena_nic_data *nic_data = efx->nic_data;
        efx_nic_free_buffer(efx, &efx->irq_status);
        siena_reset_hw(efx, RESET_TYPE_ALL);
@@ -386,7 +385,8 @@ static void siena_remove_nic(struct efx_nic *efx)
                efx_mcdi_drv_attach(efx, false, NULL);
        /* Tear down the private nic state */
-        kfree(efx->nic_data);
+        iounmap(nic_data->mcdi_smem);
+        kfree(nic_data);
        efx->nic_data = NULL;
 }
@@ -450,7 +450,7 @@ static int siena_try_update_nic_stats(struct efx_nic *efx)
                                    mac_stats->rx_bad_bytes);
        MAC_STAT(rx_packets, RX_PKTS);
        MAC_STAT(rx_good, RX_GOOD_PKTS);
-        mac_stats->rx_bad = mac_stats->rx_packets - mac_stats->rx_good;
+        MAC_STAT(rx_bad, RX_BAD_FCS_PKTS);
        MAC_STAT(rx_pause, RX_PAUSE_PKTS);
        MAC_STAT(rx_control, RX_CONTROL_PKTS);
        MAC_STAT(rx_unicast, RX_UNICAST_PKTS);
@@ -520,16 +520,6 @@ static void siena_stop_nic_stats(struct efx_nic *efx)
        efx_mcdi_mac_stats(efx, efx->stats_buffer.dma_addr, 0, 0, 0);
 }
-void siena_print_fwver(struct efx_nic *efx, char *buf, size_t len)
-{
-        struct siena_nic_data *nic_data = efx->nic_data;
-        snprintf(buf, len, "%u.%u.%u.%u",
-                 (unsigned int)(nic_data->fw_version >> 48),
-                 (unsigned int)(nic_data->fw_version >> 32 & 0xffff),
-                 (unsigned int)(nic_data->fw_version >> 16 & 0xffff),
-                 (unsigned int)(nic_data->fw_version & 0xffff));
-}
 /**************************************************************************
 *
 * Wake on LAN
@@ -562,7 +552,7 @@ static int siena_set_wol(struct efx_nic *efx, u32 type)
                if (nic_data->wol_filter_id != -1)
                        efx_mcdi_wol_filter_remove(efx,
                                                   nic_data->wol_filter_id);
-                rc = efx_mcdi_wol_filter_set_magic(efx, efx->mac_address,
+                rc = efx_mcdi_wol_filter_set_magic(efx, efx->net_dev->dev_addr,
                                                   &nic_data->wol_filter_id);
                if (rc)
                        goto fail;
@@ -609,7 +599,7 @@ static void siena_init_wol(struct efx_nic *efx)
 **************************************************************************
 */
-struct efx_nic_type siena_a0_nic_type = {
+const struct efx_nic_type siena_a0_nic_type = {
        .probe = siena_probe_nic,
        .remove = siena_remove_nic,
        .init = siena_init_nic,
@@ -634,8 +624,7 @@ struct efx_nic_type siena_a0_nic_type = {
        .default_mac_ops = &efx_mcdi_mac_operations,
        .revision = EFX_REV_SIENA_A0,
-        .mem_map_size = (FR_CZ_MC_TREG_SMEM +
+        .mem_map_size = FR_CZ_MC_TREG_SMEM, /* MC_TREG_SMEM mapped separately */
-                         FR_CZ_MC_TREG_SMEM_STEP * FR_CZ_MC_TREG_SMEM_ROWS),
        .txd_ptr_tbl_base = FR_BZ_TX_DESC_PTR_TBL,
        .rxd_ptr_tbl_base = FR_BZ_RX_DESC_PTR_TBL,
        .buf_tbl_base = FR_BZ_BUF_FULL_TBL,
@@ -651,6 +640,6 @@ struct efx_nic_type siena_a0_nic_type = {
        .tx_dc_base = 0x88000,
        .rx_dc_base = 0x68000,
        .offload_features = (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
-                             NETIF_F_RXHASH),
+                             NETIF_F_RXHASH | NETIF_F_NTUPLE),
        .reset_world_flags = ETH_RESET_MGMT << ETH_RESET_SHARED_SHIFT,
 };
diff --git a/drivers/net/sfc/spi.h b/drivers/net/sfc/spi.h
index 8bf4fce0813a..71f2e3ebe1c7 100644
--- a/drivers/net/sfc/spi.h
+++ b/drivers/net/sfc/spi.h
@@ -1,7 +1,7 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
 * Copyright 2005 Fen Systems Ltd.
- * Copyright 2006 Solarflare Communications Inc.
+ * Copyright 2006-2010 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -61,6 +61,11 @@ struct efx_spi_device {
        unsigned int block_size;
 };
+static inline bool efx_spi_present(const struct efx_spi_device *spi)
+{
+        return spi->size != 0;
+}
 int falcon_spi_cmd(struct efx_nic *efx,
                   const struct efx_spi_device *spi, unsigned int command,
                   int address, const void* in, void *out, size_t len);
diff --git a/drivers/net/sfc/tenxpress.c b/drivers/net/sfc/tenxpress.c
index 6791be90c2fe..7b0fd89e7b85 100644
--- a/drivers/net/sfc/tenxpress.c
+++ b/drivers/net/sfc/tenxpress.c
@@ -1,6 +1,6 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
- * Copyright 2007-2009 Solarflare Communications Inc.
+ * Copyright 2007-2011 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -15,14 +15,9 @@
 #include "mdio_10g.h"
 #include "nic.h"
 #include "phy.h"
-#include "regs.h"
 #include "workarounds.h"
-#include "selftest.h"
-/* We expect these MMDs to be in the package.  SFT9001 also has a
+/* We expect these MMDs to be in the package. */
- * clause 22 extension MMD, but since it doesn't have all the generic
- * MMD registers it is pointless to include it here.
- */
 #define TENXPRESS_REQUIRED_DEVS (MDIO_DEVS_PMAPMD       | \
                                 MDIO_DEVS_PCS          | \
                                 MDIO_DEVS_PHYXS        | \
@@ -33,12 +28,6 @@
                           (1 << LOOPBACK_PMAPMD) |     \
                           (1 << LOOPBACK_PHYXS_WS))
-#define SFT9001_LOOPBACKS ((1 << LOOPBACK_GPHY) |       \
-                           (1 << LOOPBACK_PHYXS) |      \
-                           (1 << LOOPBACK_PCS) |        \
-                           (1 << LOOPBACK_PMAPMD) |     \
-                           (1 << LOOPBACK_PHYXS_WS))
 /* We complain if we fail to see the link partner as 10G capable this many
 * times in a row (must be > 1 as sampling the autoneg. registers is racy)
 */
@@ -50,9 +39,8 @@
 #define PMA_PMD_EXT_GMII_EN_WIDTH 1
 #define PMA_PMD_EXT_CLK_OUT_LBN 2
 #define PMA_PMD_EXT_CLK_OUT_WIDTH 1
-#define PMA_PMD_LNPGA_POWERDOWN_LBN 8   /* SFX7101 only */
+#define PMA_PMD_LNPGA_POWERDOWN_LBN 8
 #define PMA_PMD_LNPGA_POWERDOWN_WIDTH 1
-#define PMA_PMD_EXT_CLK312_LBN  8       /* SFT9001 only */
 #define PMA_PMD_EXT_CLK312_WIDTH 1
 #define PMA_PMD_EXT_LPOWER_LBN  12
 #define PMA_PMD_EXT_LPOWER_WIDTH 1
@@ -84,7 +72,6 @@
 #define PMA_PMD_LED_FLASH       (3)
 #define PMA_PMD_LED_MASK        3
 /* All LEDs under hardware control */
-#define SFT9001_PMA_PMD_LED_DEFAULT 0
 /* Green and Amber under hardware control, Red off */
 #define SFX7101_PMA_PMD_LED_DEFAULT (PMA_PMD_LED_OFF << PMA_PMD_LED_RX_LBN)
@@ -98,31 +85,7 @@
 #define PMA_PMD_SPEED_LBN        4
 #define PMA_PMD_SPEED_WIDTH      4
-/* Cable diagnostics - SFT9001 only */
+/* Misc register defines */
-#define PMA_PMD_CDIAG_CTRL_REG  49213
-#define CDIAG_CTRL_IMMED_LBN    15
-#define CDIAG_CTRL_BRK_LINK_LBN 12
-#define CDIAG_CTRL_IN_PROG_LBN  11
-#define CDIAG_CTRL_LEN_UNIT_LBN 10
-#define CDIAG_CTRL_LEN_METRES   1
-#define PMA_PMD_CDIAG_RES_REG   49174
-#define CDIAG_RES_A_LBN         12
-#define CDIAG_RES_B_LBN         8
-#define CDIAG_RES_C_LBN         4
-#define CDIAG_RES_D_LBN         0
-#define CDIAG_RES_WIDTH         4
-#define CDIAG_RES_OPEN          2
-#define CDIAG_RES_OK            1
-#define CDIAG_RES_INVALID       0
-/* Set of 4 registers for pairs A-D */
-#define PMA_PMD_CDIAG_LEN_REG   49175
-/* Serdes control registers - SFT9001 only */
-#define PMA_PMD_CSERDES_CTRL_REG 64258
-/* Set the 156.25 MHz output to 312.5 MHz to drive Falcon's XMAC */
-#define PMA_PMD_CSERDES_DEFAULT 0x000f
-/* Misc register defines - SFX7101 only */
 #define PCS_CLOCK_CTRL_REG      55297
 #define PLL312_RST_N_LBN 2
@@ -185,121 +148,17 @@ struct tenxpress_phy_data {
        int bad_lp_tries;
 };
-static ssize_t show_phy_short_reach(struct device *dev,
-                                    struct device_attribute *attr, char *buf)
-{
-        struct efx_nic *efx = pci_get_drvdata(to_pci_dev(dev));
-        int reg;
-        reg = efx_mdio_read(efx, MDIO_MMD_PMAPMD, MDIO_PMA_10GBT_TXPWR);
-        return sprintf(buf, "%d\n", !!(reg & MDIO_PMA_10GBT_TXPWR_SHORT));
-}
-static ssize_t set_phy_short_reach(struct device *dev,
-                                   struct device_attribute *attr,
-                                   const char *buf, size_t count)
-{
-        struct efx_nic *efx = pci_get_drvdata(to_pci_dev(dev));
-        int rc;
-        rtnl_lock();
-        if (efx->state != STATE_RUNNING) {
-                rc = -EBUSY;
-        } else {
-                efx_mdio_set_flag(efx, MDIO_MMD_PMAPMD, MDIO_PMA_10GBT_TXPWR,
-                                  MDIO_PMA_10GBT_TXPWR_SHORT,
-                                  count != 0 && *buf != '0');
-                rc = efx_reconfigure_port(efx);
-        }
-        rtnl_unlock();
-        return rc < 0 ? rc : (ssize_t)count;
-}
-static DEVICE_ATTR(phy_short_reach, 0644, show_phy_short_reach,
-                   set_phy_short_reach);
-int sft9001_wait_boot(struct efx_nic *efx)
-{
-        unsigned long timeout = jiffies + HZ + 1;
-        int boot_stat;
-        for (;;) {
-                boot_stat = efx_mdio_read(efx, MDIO_MMD_PCS,
-                                          PCS_BOOT_STATUS_REG);
-                if (boot_stat >= 0) {
-                        netif_dbg(efx, hw, efx->net_dev,
-                                  "PHY boot status = %#x\n", boot_stat);
-                        switch (boot_stat &
-                                ((1 << PCS_BOOT_FATAL_ERROR_LBN) |
-                                 (3 << PCS_BOOT_PROGRESS_LBN) |
-                                 (1 << PCS_BOOT_DOWNLOAD_WAIT_LBN) |
-                                 (1 << PCS_BOOT_CODE_STARTED_LBN))) {
-                        case ((1 << PCS_BOOT_FATAL_ERROR_LBN) |
-                              (PCS_BOOT_PROGRESS_CHECKSUM <<
-                               PCS_BOOT_PROGRESS_LBN)):
-                        case ((1 << PCS_BOOT_FATAL_ERROR_LBN) |
-                              (PCS_BOOT_PROGRESS_INIT <<
-                               PCS_BOOT_PROGRESS_LBN) |
-                              (1 << PCS_BOOT_DOWNLOAD_WAIT_LBN)):
-                                return -EINVAL;
-                        case ((PCS_BOOT_PROGRESS_WAIT_MDIO <<
-                               PCS_BOOT_PROGRESS_LBN) |
-                              (1 << PCS_BOOT_DOWNLOAD_WAIT_LBN)):
-                                return (efx->phy_mode & PHY_MODE_SPECIAL) ?
-                                        0 : -EIO;
-                        case ((PCS_BOOT_PROGRESS_JUMP <<
-                               PCS_BOOT_PROGRESS_LBN) |
-                              (1 << PCS_BOOT_CODE_STARTED_LBN)):
-                        case ((PCS_BOOT_PROGRESS_JUMP <<
-                               PCS_BOOT_PROGRESS_LBN) |
-                              (1 << PCS_BOOT_DOWNLOAD_WAIT_LBN) |
-                              (1 << PCS_BOOT_CODE_STARTED_LBN)):
-                                return (efx->phy_mode & PHY_MODE_SPECIAL) ?
-                                        -EIO : 0;
-                        default:
-                                if (boot_stat & (1 << PCS_BOOT_FATAL_ERROR_LBN))
-                                        return -EIO;
-                                break;
-                        }
-                }
-                if (time_after_eq(jiffies, timeout))
-                        return -ETIMEDOUT;
-                msleep(50);
-        }
-}
 static int tenxpress_init(struct efx_nic *efx)
 {
-        int reg;
+        /* Enable 312.5 MHz clock */
+        efx_mdio_write(efx, MDIO_MMD_PCS, PCS_TEST_SELECT_REG,
-        if (efx->phy_type == PHY_TYPE_SFX7101) {
+                       1 << CLK312_EN_LBN);
-                /* Enable 312.5 MHz clock */
-                efx_mdio_write(efx, MDIO_MMD_PCS, PCS_TEST_SELECT_REG,
-                               1 << CLK312_EN_LBN);
-        } else {
-                /* Enable 312.5 MHz clock and GMII */
-                reg = efx_mdio_read(efx, MDIO_MMD_PMAPMD, PMA_PMD_XCONTROL_REG);
-                reg |= ((1 << PMA_PMD_EXT_GMII_EN_LBN) |
-                        (1 << PMA_PMD_EXT_CLK_OUT_LBN) |
-                        (1 << PMA_PMD_EXT_CLK312_LBN) |
-                        (1 << PMA_PMD_EXT_ROBUST_LBN));
-                efx_mdio_write(efx, MDIO_MMD_PMAPMD, PMA_PMD_XCONTROL_REG, reg);
-                efx_mdio_set_flag(efx, MDIO_MMD_C22EXT,
-                              GPHY_XCONTROL_REG, 1 << GPHY_ISOLATE_LBN,
-                              false);
-        }
        /* Set the LEDs up as: Green = Link, Amber = Link/Act, Red = Off */
-        if (efx->phy_type == PHY_TYPE_SFX7101) {
+        efx_mdio_set_flag(efx, MDIO_MMD_PMAPMD, PMA_PMD_LED_CTRL_REG,
-                efx_mdio_set_flag(efx, MDIO_MMD_PMAPMD, PMA_PMD_LED_CTRL_REG,
+                          1 << PMA_PMA_LED_ACTIVITY_LBN, true);
-                                  1 << PMA_PMA_LED_ACTIVITY_LBN, true);
+        efx_mdio_write(efx, MDIO_MMD_PMAPMD, PMA_PMD_LED_OVERR_REG,
-                efx_mdio_write(efx, MDIO_MMD_PMAPMD, PMA_PMD_LED_OVERR_REG,
+                       SFX7101_PMA_PMD_LED_DEFAULT);
-                               SFX7101_PMA_PMD_LED_DEFAULT);
-        }
        return 0;
 }
@@ -307,7 +166,6 @@ static int tenxpress_init(struct efx_nic *efx)
 static int tenxpress_phy_probe(struct efx_nic *efx)
 {
        struct tenxpress_phy_data *phy_data;
-        int rc;
        /* Allocate phy private storage */
        phy_data = kzalloc(sizeof(*phy_data), GFP_KERNEL);
@@ -316,42 +174,15 @@ static int tenxpress_phy_probe(struct efx_nic *efx)
        efx->phy_data = phy_data;
        phy_data->phy_mode = efx->phy_mode;
-        /* Create any special files */
+        efx->mdio.mmds = TENXPRESS_REQUIRED_DEVS;
-        if (efx->phy_type == PHY_TYPE_SFT9001B) {
+        efx->mdio.mode_support = MDIO_SUPPORTS_C45;
-                rc = device_create_file(&efx->pci_dev->dev,
-                                        &dev_attr_phy_short_reach);
-                if (rc)
-                        goto fail;
-        }
-        if (efx->phy_type == PHY_TYPE_SFX7101) {
-                efx->mdio.mmds = TENXPRESS_REQUIRED_DEVS;
-                efx->mdio.mode_support = MDIO_SUPPORTS_C45;
-                efx->loopback_modes = SFX7101_LOOPBACKS | FALCON_XMAC_LOOPBACKS;
-                efx->link_advertising = (ADVERTISED_TP | ADVERTISED_Autoneg |
+        efx->loopback_modes = SFX7101_LOOPBACKS | FALCON_XMAC_LOOPBACKS;
-                                         ADVERTISED_10000baseT_Full);
-        } else {
-                efx->mdio.mmds = TENXPRESS_REQUIRED_DEVS;
-                efx->mdio.mode_support = MDIO_SUPPORTS_C45 | MDIO_EMULATE_C22;
-                efx->loopback_modes = (SFT9001_LOOPBACKS |
+        efx->link_advertising = (ADVERTISED_TP | ADVERTISED_Autoneg |
-                                       FALCON_XMAC_LOOPBACKS | 
+                                 ADVERTISED_10000baseT_Full);
-                                       FALCON_GMAC_LOOPBACKS);
-                efx->link_advertising = (ADVERTISED_TP | ADVERTISED_Autoneg |
-                                         ADVERTISED_10000baseT_Full |
-                                         ADVERTISED_1000baseT_Full |
-                                         ADVERTISED_100baseT_Full);
-        }
        return 0;
-fail:
-        kfree(efx->phy_data);
-        efx->phy_data = NULL;
-        return rc;
 }
 static int tenxpress_phy_init(struct efx_nic *efx)
@@ -361,21 +192,11 @@ static int tenxpress_phy_init(struct efx_nic *efx)
        falcon_board(efx)->type->init_phy(efx);
        if (!(efx->phy_mode & PHY_MODE_SPECIAL)) {
-                if (efx->phy_type == PHY_TYPE_SFT9001A) {
-                        int reg;
-                        reg = efx_mdio_read(efx, MDIO_MMD_PMAPMD,
-                                            PMA_PMD_XCONTROL_REG);
-                        reg |= (1 << PMA_PMD_EXT_SSR_LBN);
-                        efx_mdio_write(efx, MDIO_MMD_PMAPMD,
-                                       PMA_PMD_XCONTROL_REG, reg);
-                        mdelay(200);
-                }
                rc = efx_mdio_wait_reset_mmds(efx, TENXPRESS_REQUIRED_DEVS);
                if (rc < 0)
                        return rc;
-                rc = efx_mdio_check_mmds(efx, TENXPRESS_REQUIRED_DEVS, 0);
+                rc = efx_mdio_check_mmds(efx, TENXPRESS_REQUIRED_DEVS);
                if (rc < 0)
                        return rc;
        }
@@ -403,7 +224,7 @@ static int tenxpress_special_reset(struct efx_nic *efx)
 {
        int rc, reg;
-        /* The XGMAC clock is driven from the SFC7101/SFT9001 312MHz clock, so
+        /* The XGMAC clock is driven from the SFX7101 312MHz clock, so
         * a special software reset can glitch the XGMAC sufficiently for stats
         * requests to fail. */
        falcon_stop_nic_stats(efx);
@@ -484,53 +305,18 @@ static bool sfx7101_link_ok(struct efx_nic *efx)
                                 MDIO_DEVS_PHYXS);
 }
-static bool sft9001_link_ok(struct efx_nic *efx, struct ethtool_cmd *ecmd)
-{
-        u32 reg;
-        if (efx_phy_mode_disabled(efx->phy_mode))
-                return false;
-        else if (efx->loopback_mode == LOOPBACK_GPHY)
-                return true;
-        else if (efx->loopback_mode)
-                return efx_mdio_links_ok(efx,
-                                         MDIO_DEVS_PMAPMD |
-                                         MDIO_DEVS_PHYXS);
-        /* We must use the same definition of link state as LASI,
-         * otherwise we can miss a link state transition
-         */
-        if (ecmd->speed == 10000) {
-                reg = efx_mdio_read(efx, MDIO_MMD_PCS, MDIO_PCS_10GBRT_STAT1);
-                return reg & MDIO_PCS_10GBRT_STAT1_BLKLK;
-        } else {
-                reg = efx_mdio_read(efx, MDIO_MMD_C22EXT, C22EXT_STATUS_REG);
-                return reg & (1 << C22EXT_STATUS_LINK_LBN);
-        }
-}
 static void tenxpress_ext_loopback(struct efx_nic *efx)
 {
        efx_mdio_set_flag(efx, MDIO_MMD_PHYXS, PHYXS_TEST1,
                          1 << LOOPBACK_NEAR_LBN,
                          efx->loopback_mode == LOOPBACK_PHYXS);
-        if (efx->phy_type != PHY_TYPE_SFX7101)
-                efx_mdio_set_flag(efx, MDIO_MMD_C22EXT, GPHY_XCONTROL_REG,
-                                  1 << GPHY_LOOPBACK_NEAR_LBN,
-                                  efx->loopback_mode == LOOPBACK_GPHY);
 }
 static void tenxpress_low_power(struct efx_nic *efx)
 {
-        if (efx->phy_type == PHY_TYPE_SFX7101)
+        efx_mdio_set_mmds_lpower(
-                efx_mdio_set_mmds_lpower(
+                efx, !!(efx->phy_mode & PHY_MODE_LOW_POWER),
-                        efx, !!(efx->phy_mode & PHY_MODE_LOW_POWER),
+                TENXPRESS_REQUIRED_DEVS);
-                        TENXPRESS_REQUIRED_DEVS);
-        else
-                efx_mdio_set_flag(
-                        efx, MDIO_MMD_PMAPMD, PMA_PMD_XCONTROL_REG,
-                        1 << PMA_PMD_EXT_LPOWER_LBN,
-                        !!(efx->phy_mode & PHY_MODE_LOW_POWER));
 }
 static int tenxpress_phy_reconfigure(struct efx_nic *efx)
@@ -550,12 +336,7 @@ static int tenxpress_phy_reconfigure(struct efx_nic *efx)
        if (loop_reset || phy_mode_change) {
                tenxpress_special_reset(efx);
+                falcon_reset_xaui(efx);
-                /* Reset XAUI if we were in 10G, and are staying
-                 * in 10G. If we're moving into and out of 10G
-                 * then xaui will be reset anyway */
-                if (EFX_IS10G(efx))
-                        falcon_reset_xaui(efx);
        }
        tenxpress_low_power(efx);
@@ -578,29 +359,12 @@ static bool tenxpress_phy_poll(struct efx_nic *efx)
 {
        struct efx_link_state old_state = efx->link_state;
-        if (efx->phy_type == PHY_TYPE_SFX7101) {
+        efx->link_state.up = sfx7101_link_ok(efx);
-                efx->link_state.up = sfx7101_link_ok(efx);
+        efx->link_state.speed = 10000;
-                efx->link_state.speed = 10000;
+        efx->link_state.fd = true;
-                efx->link_state.fd = true;
+        efx->link_state.fc = efx_mdio_get_pause(efx);
-                efx->link_state.fc = efx_mdio_get_pause(efx);
-                sfx7101_check_bad_lp(efx, efx->link_state.up);
-        } else {
-                struct ethtool_cmd ecmd;
-                /* Check the LASI alarm first */
-                if (efx->loopback_mode == LOOPBACK_NONE &&
-                    !(efx_mdio_read(efx, MDIO_MMD_PMAPMD, MDIO_PMA_LASI_STAT) &
-                      MDIO_PMA_LASI_LSALARM))
-                        return false;
-                tenxpress_get_settings(efx, &ecmd);
+        sfx7101_check_bad_lp(efx, efx->link_state.up);
-                efx->link_state.up = sft9001_link_ok(efx, &ecmd);
-                efx->link_state.speed = ecmd.speed;
-                efx->link_state.fd = (ecmd.duplex == DUPLEX_FULL);
-                efx->link_state.fc = efx_mdio_get_pause(efx);
-        }
        return !efx_link_state_equal(&efx->link_state, &old_state);
 }
@@ -621,10 +385,6 @@ static void sfx7101_phy_fini(struct efx_nic *efx)
 static void tenxpress_phy_remove(struct efx_nic *efx)
 {
-        if (efx->phy_type == PHY_TYPE_SFT9001B)
-                device_remove_file(&efx->pci_dev->dev,
-                                   &dev_attr_phy_short_reach);
        kfree(efx->phy_data);
        efx->phy_data = NULL;
 }
@@ -647,10 +407,7 @@ void tenxpress_set_id_led(struct efx_nic *efx, enum efx_led_mode mode)
                        (PMA_PMD_LED_ON << PMA_PMD_LED_LINK_LBN);
                break;
        default:
-                if (efx->phy_type == PHY_TYPE_SFX7101)
+                reg = SFX7101_PMA_PMD_LED_DEFAULT;
-                        reg = SFX7101_PMA_PMD_LED_DEFAULT;
-                else
-                        reg = SFT9001_PMA_PMD_LED_DEFAULT;
                break;
        }
@@ -685,102 +442,12 @@ sfx7101_run_tests(struct efx_nic *efx, int *results, unsigned flags)
        return rc;
 }
-static const char *const sft9001_test_names[] = {
-        "bist",
-        "cable.pairA.status",
-        "cable.pairB.status",
-        "cable.pairC.status",
-        "cable.pairD.status",
-        "cable.pairA.length",
-        "cable.pairB.length",
-        "cable.pairC.length",
-        "cable.pairD.length",
-};
-static const char *sft9001_test_name(struct efx_nic *efx, unsigned int index)
-{
-        if (index < ARRAY_SIZE(sft9001_test_names))
-                return sft9001_test_names[index];
-        return NULL;
-}
-static int sft9001_run_tests(struct efx_nic *efx, int *results, unsigned flags)
-{
-        int rc = 0, rc2, i, ctrl_reg, res_reg;
-        /* Initialise cable diagnostic results to unknown failure */
-        for (i = 1; i < 9; ++i)
-                results[i] = -1;
-        /* Run cable diagnostics; wait up to 5 seconds for them to complete.
-         * A cable fault is not a self-test failure, but a timeout is. */
-        ctrl_reg = ((1 << CDIAG_CTRL_IMMED_LBN) |
-                    (CDIAG_CTRL_LEN_METRES << CDIAG_CTRL_LEN_UNIT_LBN));
-        if (flags & ETH_TEST_FL_OFFLINE) {
-                /* Break the link in order to run full diagnostics.  We
-                 * must reset the PHY to resume normal service. */
-                ctrl_reg |= (1 << CDIAG_CTRL_BRK_LINK_LBN);
-        }
-        efx_mdio_write(efx, MDIO_MMD_PMAPMD, PMA_PMD_CDIAG_CTRL_REG,
-                       ctrl_reg);
-        i = 0;
-        while (efx_mdio_read(efx, MDIO_MMD_PMAPMD, PMA_PMD_CDIAG_CTRL_REG) &
-               (1 << CDIAG_CTRL_IN_PROG_LBN)) {
-                if (++i == 50) {
-                        rc = -ETIMEDOUT;
-                        goto out;
-                }
-                msleep(100);
-        }
-        res_reg = efx_mdio_read(efx, MDIO_MMD_PMAPMD, PMA_PMD_CDIAG_RES_REG);
-        for (i = 0; i < 4; i++) {
-                int pair_res =
-                        (res_reg >> (CDIAG_RES_A_LBN - i * CDIAG_RES_WIDTH))
-                        & ((1 << CDIAG_RES_WIDTH) - 1);
-                int len_reg = efx_mdio_read(efx, MDIO_MMD_PMAPMD,
-                                            PMA_PMD_CDIAG_LEN_REG + i);
-                if (pair_res == CDIAG_RES_OK)
-                        results[1 + i] = 1;
-                else if (pair_res == CDIAG_RES_INVALID)
-                        results[1 + i] = -1;
-                else
-                        results[1 + i] = -pair_res;
-                if (pair_res != CDIAG_RES_INVALID &&
-                    pair_res != CDIAG_RES_OPEN &&
-                    len_reg != 0xffff)
-                        results[5 + i] = len_reg;
-        }
-out:
-        if (flags & ETH_TEST_FL_OFFLINE) {
-                /* Reset, running the BIST and then resuming normal service. */
-                rc2 = tenxpress_special_reset(efx);
-                results[0] = rc2 ? -1 : 1;
-                if (!rc)
-                        rc = rc2;
-                efx_mdio_an_reconfigure(efx);
-        }
-        return rc;
-}
 static void
 tenxpress_get_settings(struct efx_nic *efx, struct ethtool_cmd *ecmd)
 {
        u32 adv = 0, lpa = 0;
        int reg;
-        if (efx->phy_type != PHY_TYPE_SFX7101) {
-                reg = efx_mdio_read(efx, MDIO_MMD_C22EXT, C22EXT_MSTSLV_CTRL);
-                if (reg & (1 << C22EXT_MSTSLV_CTRL_ADV_1000_FD_LBN))
-                        adv |= ADVERTISED_1000baseT_Full;
-                reg = efx_mdio_read(efx, MDIO_MMD_C22EXT, C22EXT_MSTSLV_STATUS);
-                if (reg & (1 << C22EXT_MSTSLV_STATUS_LP_1000_HD_LBN))
-                        lpa |= ADVERTISED_1000baseT_Half;
-                if (reg & (1 << C22EXT_MSTSLV_STATUS_LP_1000_FD_LBN))
-                        lpa |= ADVERTISED_1000baseT_Full;
-        }
        reg = efx_mdio_read(efx, MDIO_MMD_AN, MDIO_AN_10GBT_CTRL);
        if (reg & MDIO_AN_10GBT_CTRL_ADV10G)
                adv |= ADVERTISED_10000baseT_Full;
@@ -790,24 +457,10 @@ tenxpress_get_settings(struct efx_nic *efx, struct ethtool_cmd *ecmd)
        mdio45_ethtool_gset_npage(&efx->mdio, ecmd, adv, lpa);
-        if (efx->phy_type != PHY_TYPE_SFX7101) {
-                ecmd->supported |= (SUPPORTED_100baseT_Full |
-                                    SUPPORTED_1000baseT_Full);
-                if (ecmd->speed != SPEED_10000) {
-                        ecmd->eth_tp_mdix =
-                                (efx_mdio_read(efx, MDIO_MMD_PMAPMD,
-                                               PMA_PMD_XSTATUS_REG) &
-                                 (1 << PMA_PMD_XSTAT_MDIX_LBN))
-                                ? ETH_TP_MDI_X : ETH_TP_MDI;
-                }
-        }
        /* In loopback, the PHY automatically brings up the correct interface,
         * but doesn't advertise the correct speed. So override it */
-        if (efx->loopback_mode == LOOPBACK_GPHY)
+        if (LOOPBACK_EXTERNAL(efx))
-                ecmd->speed = SPEED_1000;
+                ethtool_cmd_speed_set(ecmd, SPEED_10000);
-        else if (LOOPBACK_EXTERNAL(efx))
-                ecmd->speed = SPEED_10000;
 }
 static int tenxpress_set_settings(struct efx_nic *efx, struct ethtool_cmd *ecmd)
@@ -825,17 +478,7 @@ static void sfx7101_set_npage_adv(struct efx_nic *efx, u32 advertising)
                          advertising & ADVERTISED_10000baseT_Full);
 }
-static void sft9001_set_npage_adv(struct efx_nic *efx, u32 advertising)
+const struct efx_phy_operations falcon_sfx7101_phy_ops = {
-{
-        efx_mdio_set_flag(efx, MDIO_MMD_C22EXT, C22EXT_MSTSLV_CTRL,
-                          1 << C22EXT_MSTSLV_CTRL_ADV_1000_FD_LBN,
-                          advertising & ADVERTISED_1000baseT_Full);
-        efx_mdio_set_flag(efx, MDIO_MMD_AN, MDIO_AN_10GBT_CTRL,
-                          MDIO_AN_10GBT_CTRL_ADV10G,
-                          advertising & ADVERTISED_10000baseT_Full);
-}
-struct efx_phy_operations falcon_sfx7101_phy_ops = {
        .probe            = tenxpress_phy_probe,
        .init             = tenxpress_phy_init,
        .reconfigure      = tenxpress_phy_reconfigure,
@@ -849,18 +492,3 @@ struct efx_phy_operations falcon_sfx7101_phy_ops = {
        .test_name        = sfx7101_test_name,
        .run_tests        = sfx7101_run_tests,
 };
-struct efx_phy_operations falcon_sft9001_phy_ops = {
-        .probe            = tenxpress_phy_probe,
-        .init             = tenxpress_phy_init,
-        .reconfigure      = tenxpress_phy_reconfigure,
-        .poll             = tenxpress_phy_poll,
-        .fini             = efx_port_dummy_op_void,
-        .remove           = tenxpress_phy_remove,
-        .get_settings     = tenxpress_get_settings,
-        .set_settings     = tenxpress_set_settings,
-        .set_npage_adv    = sft9001_set_npage_adv,
-        .test_alive       = efx_mdio_test_alive,
-        .test_name        = sft9001_test_name,
-        .run_tests        = sft9001_run_tests,
-};
diff --git a/drivers/net/sfc/tx.c b/drivers/net/sfc/tx.c
index c6942da2c99a..84eb99e0f8d2 100644
--- a/drivers/net/sfc/tx.c
+++ b/drivers/net/sfc/tx.c
@@ -1,7 +1,7 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
 * Copyright 2005-2006 Fen Systems Ltd.
- * Copyright 2005-2009 Solarflare Communications Inc.
+ * Copyright 2005-2010 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -28,51 +28,7 @@
 * The tx_queue descriptor ring fill-level must fall below this value
 * before we restart the netif queue
 */
-#define EFX_TXQ_THRESHOLD (EFX_TXQ_MASK / 2u)
+#define EFX_TXQ_THRESHOLD(_efx) ((_efx)->txq_entries / 2u)
-/* We need to be able to nest calls to netif_tx_stop_queue(), partly
- * because of the 2 hardware queues associated with each core queue,
- * but also so that we can inhibit TX for reasons other than a full
- * hardware queue. */
-void efx_stop_queue(struct efx_channel *channel)
-{
-        struct efx_nic *efx = channel->efx;
-        if (!channel->tx_queue)
-                return;
-        spin_lock_bh(&channel->tx_stop_lock);
-        netif_vdbg(efx, tx_queued, efx->net_dev, "stop TX queue\n");
-        atomic_inc(&channel->tx_stop_count);
-        netif_tx_stop_queue(
-                netdev_get_tx_queue(
-                        efx->net_dev,
-                        channel->tx_queue->queue / EFX_TXQ_TYPES));
-        spin_unlock_bh(&channel->tx_stop_lock);
-}
-/* Decrement core TX queue stop count and wake it if the count is 0 */
-void efx_wake_queue(struct efx_channel *channel)
-{
-        struct efx_nic *efx = channel->efx;
-        if (!channel->tx_queue)
-                return;
-        local_bh_disable();
-        if (atomic_dec_and_lock(&channel->tx_stop_count,
-                                &channel->tx_stop_lock)) {
-                netif_vdbg(efx, tx_queued, efx->net_dev, "waking TX queue\n");
-                netif_tx_wake_queue(
-                        netdev_get_tx_queue(
-                                efx->net_dev,
-                                channel->tx_queue->queue / EFX_TXQ_TYPES));
-                spin_unlock(&channel->tx_stop_lock);
-        }
-        local_bh_enable();
-}
 static void efx_dequeue_buffer(struct efx_tx_queue *tx_queue,
                               struct efx_tx_buffer *buffer)
@@ -207,7 +163,7 @@ netdev_tx_t efx_enqueue_skb(struct efx_tx_queue *tx_queue, struct sk_buff *skb)
        }
        fill_level = tx_queue->insert_count - tx_queue->old_read_count;
-        q_space = EFX_TXQ_MASK - 1 - fill_level;
+        q_space = efx->txq_entries - 1 - fill_level;
        /* Map for DMA.  Use pci_map_single rather than pci_map_page
         * since this is more efficient on machines with sparse
@@ -234,24 +190,27 @@ netdev_tx_t efx_enqueue_skb(struct efx_tx_queue *tx_queue, struct sk_buff *skb)
                                 * checked.  Update the xmit path's
                                 * copy of read_count.
                                 */
-                                ++tx_queue->stopped;
+                                netif_tx_stop_queue(tx_queue->core_txq);
                                /* This memory barrier protects the
-                                 * change of stopped from the access
+                                 * change of queue state from the access
                                 * of read_count. */
                                smp_mb();
                                tx_queue->old_read_count =
-                                        *(volatile unsigned *)
+                                        ACCESS_ONCE(tx_queue->read_count);
-                                        &tx_queue->read_count;
                                fill_level = (tx_queue->insert_count
                                              - tx_queue->old_read_count);
-                                q_space = EFX_TXQ_MASK - 1 - fill_level;
+                                q_space = efx->txq_entries - 1 - fill_level;
-                                if (unlikely(q_space-- <= 0))
+                                if (unlikely(q_space-- <= 0)) {
-                                        goto stop;
+                                        rc = NETDEV_TX_BUSY;
+                                        goto unwind;
+                                }
                                smp_mb();
-                                --tx_queue->stopped;
+                                if (likely(!efx->loopback_selftest))
+                                        netif_tx_start_queue(
+                                                tx_queue->core_txq);
                        }
-                        insert_ptr = tx_queue->insert_count & EFX_TXQ_MASK;
+                        insert_ptr = tx_queue->insert_count & tx_queue->ptr_mask;
                        buffer = &tx_queue->buffer[insert_ptr];
                        efx_tsoh_free(tx_queue, buffer);
                        EFX_BUG_ON_PARANOID(buffer->tsoh);
@@ -308,19 +267,12 @@ netdev_tx_t efx_enqueue_skb(struct efx_tx_queue *tx_queue, struct sk_buff *skb)
        /* Mark the packet as transmitted, and free the SKB ourselves */
        dev_kfree_skb_any(skb);
-        goto unwind;
- stop:
-        rc = NETDEV_TX_BUSY;
-        if (tx_queue->stopped == 1)
-                efx_stop_queue(tx_queue->channel);
 unwind:
        /* Work backwards until we hit the original insert pointer value */
        while (tx_queue->insert_count != tx_queue->write_count) {
                --tx_queue->insert_count;
-                insert_ptr = tx_queue->insert_count & EFX_TXQ_MASK;
+                insert_ptr = tx_queue->insert_count & tx_queue->ptr_mask;
                buffer = &tx_queue->buffer[insert_ptr];
                efx_dequeue_buffer(tx_queue, buffer);
                buffer->len = 0;
@@ -350,8 +302,8 @@ static void efx_dequeue_buffers(struct efx_tx_queue *tx_queue,
        struct efx_nic *efx = tx_queue->efx;
        unsigned int stop_index, read_ptr;
-        stop_index = (index + 1) & EFX_TXQ_MASK;
+        stop_index = (index + 1) & tx_queue->ptr_mask;
-        read_ptr = tx_queue->read_count & EFX_TXQ_MASK;
+        read_ptr = tx_queue->read_count & tx_queue->ptr_mask;
        while (read_ptr != stop_index) {
                struct efx_tx_buffer *buffer = &tx_queue->buffer[read_ptr];
@@ -368,7 +320,7 @@ static void efx_dequeue_buffers(struct efx_tx_queue *tx_queue,
                buffer->len = 0;
                ++tx_queue->read_count;
-                read_ptr = tx_queue->read_count & EFX_TXQ_MASK;
+                read_ptr = tx_queue->read_count & tx_queue->ptr_mask;
        }
 }
@@ -386,43 +338,120 @@ netdev_tx_t efx_hard_start_xmit(struct sk_buff *skb,
 {
        struct efx_nic *efx = netdev_priv(net_dev);
        struct efx_tx_queue *tx_queue;
+        unsigned index, type;
-        if (unlikely(efx->port_inhibited))
+        EFX_WARN_ON_PARANOID(!netif_device_present(net_dev));
-                return NETDEV_TX_BUSY;
-        tx_queue = &efx->tx_queue[EFX_TXQ_TYPES * skb_get_queue_mapping(skb)];
+        index = skb_get_queue_mapping(skb);
-        if (likely(skb->ip_summed == CHECKSUM_PARTIAL))
+        type = skb->ip_summed == CHECKSUM_PARTIAL ? EFX_TXQ_TYPE_OFFLOAD : 0;
-                tx_queue += EFX_TXQ_TYPE_OFFLOAD;
+        if (index >= efx->n_tx_channels) {
+                index -= efx->n_tx_channels;
+                type |= EFX_TXQ_TYPE_HIGHPRI;
+        }
+        tx_queue = efx_get_tx_queue(efx, index, type);
        return efx_enqueue_skb(tx_queue, skb);
 }
+void efx_init_tx_queue_core_txq(struct efx_tx_queue *tx_queue)
+{
+        struct efx_nic *efx = tx_queue->efx;
+        /* Must be inverse of queue lookup in efx_hard_start_xmit() */
+        tx_queue->core_txq =
+                netdev_get_tx_queue(efx->net_dev,
+                                    tx_queue->queue / EFX_TXQ_TYPES +
+                                    ((tx_queue->queue & EFX_TXQ_TYPE_HIGHPRI) ?
+                                     efx->n_tx_channels : 0));
+}
+int efx_setup_tc(struct net_device *net_dev, u8 num_tc)
+{
+        struct efx_nic *efx = netdev_priv(net_dev);
+        struct efx_channel *channel;
+        struct efx_tx_queue *tx_queue;
+        unsigned tc;
+        int rc;
+        if (efx_nic_rev(efx) < EFX_REV_FALCON_B0 || num_tc > EFX_MAX_TX_TC)
+                return -EINVAL;
+        if (num_tc == net_dev->num_tc)
+                return 0;
+        for (tc = 0; tc < num_tc; tc++) {
+                net_dev->tc_to_txq[tc].offset = tc * efx->n_tx_channels;
+                net_dev->tc_to_txq[tc].count = efx->n_tx_channels;
+        }
+        if (num_tc > net_dev->num_tc) {
+                /* Initialise high-priority queues as necessary */
+                efx_for_each_channel(channel, efx) {
+                        efx_for_each_possible_channel_tx_queue(tx_queue,
+                                                               channel) {
+                                if (!(tx_queue->queue & EFX_TXQ_TYPE_HIGHPRI))
+                                        continue;
+                                if (!tx_queue->buffer) {
+                                        rc = efx_probe_tx_queue(tx_queue);
+                                        if (rc)
+                                                return rc;
+                                }
+                                if (!tx_queue->initialised)
+                                        efx_init_tx_queue(tx_queue);
+                                efx_init_tx_queue_core_txq(tx_queue);
+                        }
+                }
+        } else {
+                /* Reduce number of classes before number of queues */
+                net_dev->num_tc = num_tc;
+        }
+        rc = netif_set_real_num_tx_queues(net_dev,
+                                          max_t(int, num_tc, 1) *
+                                          efx->n_tx_channels);
+        if (rc)
+                return rc;
+        /* Do not destroy high-priority queues when they become
+         * unused.  We would have to flush them first, and it is
+         * fairly difficult to flush a subset of TX queues.  Leave
+         * it to efx_fini_channels().
+         */
+        net_dev->num_tc = num_tc;
+        return 0;
+}
 void efx_xmit_done(struct efx_tx_queue *tx_queue, unsigned int index)
 {
        unsigned fill_level;
        struct efx_nic *efx = tx_queue->efx;
-        EFX_BUG_ON_PARANOID(index > EFX_TXQ_MASK);
+        EFX_BUG_ON_PARANOID(index > tx_queue->ptr_mask);
        efx_dequeue_buffers(tx_queue, index);
        /* See if we need to restart the netif queue.  This barrier
-         * separates the update of read_count from the test of
+         * separates the update of read_count from the test of the
-         * stopped. */
+         * queue state. */
        smp_mb();
-        if (unlikely(tx_queue->stopped) && likely(efx->port_enabled)) {
+        if (unlikely(netif_tx_queue_stopped(tx_queue->core_txq)) &&
+            likely(efx->port_enabled) &&
+            likely(netif_device_present(efx->net_dev))) {
                fill_level = tx_queue->insert_count - tx_queue->read_count;
-                if (fill_level < EFX_TXQ_THRESHOLD) {
+                if (fill_level < EFX_TXQ_THRESHOLD(efx)) {
                        EFX_BUG_ON_PARANOID(!efx_dev_registered(efx));
+                        netif_tx_wake_queue(tx_queue->core_txq);
+                }
+        }
-                        /* Do this under netif_tx_lock(), to avoid racing
+        /* Check whether the hardware queue is now empty */
-                         * with efx_xmit(). */
+        if ((int)(tx_queue->read_count - tx_queue->old_write_count) >= 0) {
-                        netif_tx_lock(efx->net_dev);
+                tx_queue->old_write_count = ACCESS_ONCE(tx_queue->write_count);
-                        if (tx_queue->stopped) {
+                if (tx_queue->read_count == tx_queue->old_write_count) {
-                                tx_queue->stopped = 0;
+                        smp_mb();
-                                efx_wake_queue(tx_queue->channel);
+                        tx_queue->empty_read_count =
-                        }
+                                tx_queue->read_count | EFX_EMPTY_COUNT_VALID;
-                        netif_tx_unlock(efx->net_dev);
                }
        }
 }
@@ -430,18 +459,24 @@ void efx_xmit_done(struct efx_tx_queue *tx_queue, unsigned int index)
 int efx_probe_tx_queue(struct efx_tx_queue *tx_queue)
 {
        struct efx_nic *efx = tx_queue->efx;
-        unsigned int txq_size;
+        unsigned int entries;
        int i, rc;
-        netif_dbg(efx, probe, efx->net_dev, "creating TX queue %d\n",
+        /* Create the smallest power-of-two aligned ring */
-                  tx_queue->queue);
+        entries = max(roundup_pow_of_two(efx->txq_entries), EFX_MIN_DMAQ_SIZE);
+        EFX_BUG_ON_PARANOID(entries > EFX_MAX_DMAQ_SIZE);
+        tx_queue->ptr_mask = entries - 1;
+        netif_dbg(efx, probe, efx->net_dev,
+                  "creating TX queue %d size %#x mask %#x\n",
+                  tx_queue->queue, efx->txq_entries, tx_queue->ptr_mask);
        /* Allocate software ring */
-        txq_size = EFX_TXQ_SIZE * sizeof(*tx_queue->buffer);
+        tx_queue->buffer = kzalloc(entries * sizeof(*tx_queue->buffer),
-        tx_queue->buffer = kzalloc(txq_size, GFP_KERNEL);
+                                   GFP_KERNEL);
        if (!tx_queue->buffer)
                return -ENOMEM;
-        for (i = 0; i <= EFX_TXQ_MASK; ++i)
+        for (i = 0; i <= tx_queue->ptr_mask; ++i)
                tx_queue->buffer[i].continuation = true;
        /* Allocate hardware ring */
@@ -464,12 +499,15 @@ void efx_init_tx_queue(struct efx_tx_queue *tx_queue)
        tx_queue->insert_count = 0;
        tx_queue->write_count = 0;
+        tx_queue->old_write_count = 0;
        tx_queue->read_count = 0;
        tx_queue->old_read_count = 0;
-        BUG_ON(tx_queue->stopped);
+        tx_queue->empty_read_count = 0 | EFX_EMPTY_COUNT_VALID;
        /* Set up TX descriptor ring */
        efx_nic_init_tx(tx_queue);
+        tx_queue->initialised = true;
 }
 void efx_release_tx_buffers(struct efx_tx_queue *tx_queue)
@@ -481,7 +519,7 @@ void efx_release_tx_buffers(struct efx_tx_queue *tx_queue)
        /* Free any buffers left in the ring */
        while (tx_queue->read_count != tx_queue->write_count) {
-                buffer = &tx_queue->buffer[tx_queue->read_count & EFX_TXQ_MASK];
+                buffer = &tx_queue->buffer[tx_queue->read_count & tx_queue->ptr_mask];
                efx_dequeue_buffer(tx_queue, buffer);
                buffer->continuation = true;
                buffer->len = 0;
@@ -492,9 +530,14 @@ void efx_release_tx_buffers(struct efx_tx_queue *tx_queue)
 void efx_fini_tx_queue(struct efx_tx_queue *tx_queue)
 {
+        if (!tx_queue->initialised)
+                return;
        netif_dbg(tx_queue->efx, drv, tx_queue->efx->net_dev,
                  "shutting down TX queue %d\n", tx_queue->queue);
+        tx_queue->initialised = false;
        /* Flush TX queue, remove descriptor ring */
        efx_nic_fini_tx(tx_queue);
@@ -502,16 +545,13 @@ void efx_fini_tx_queue(struct efx_tx_queue *tx_queue)
        /* Free up TSO header cache */
        efx_fini_tso(tx_queue);
-        /* Release queue's stop on port, if any */
-        if (tx_queue->stopped) {
-                tx_queue->stopped = 0;
-                efx_wake_queue(tx_queue->channel);
-        }
 }
 void efx_remove_tx_queue(struct efx_tx_queue *tx_queue)
 {
+        if (!tx_queue->buffer)
+                return;
        netif_dbg(tx_queue->efx, drv, tx_queue->efx->net_dev,
                  "destroying TX queue %d\n", tx_queue->queue);
        efx_nic_remove_tx(tx_queue);
@@ -741,7 +781,7 @@ static int efx_tx_queue_insert(struct efx_tx_queue *tx_queue,
        fill_level = tx_queue->insert_count - tx_queue->old_read_count;
        /* -1 as there is no way to represent all descriptors used */
-        q_space = EFX_TXQ_MASK - 1 - fill_level;
+        q_space = efx->txq_entries - 1 - fill_level;
        while (1) {
                if (unlikely(q_space-- <= 0)) {
@@ -749,30 +789,30 @@ static int efx_tx_queue_insert(struct efx_tx_queue *tx_queue,
                         * since the xmit path last checked.  Update
                         * the xmit path's copy of read_count.
                         */
-                        ++tx_queue->stopped;
+                        netif_tx_stop_queue(tx_queue->core_txq);
                        /* This memory barrier protects the change of
-                         * stopped from the access of read_count. */
+                         * queue state from the access of read_count. */
                        smp_mb();
                        tx_queue->old_read_count =
-                                *(volatile unsigned *)&tx_queue->read_count;
+                                ACCESS_ONCE(tx_queue->read_count);
                        fill_level = (tx_queue->insert_count
                                      - tx_queue->old_read_count);
-                        q_space = EFX_TXQ_MASK - 1 - fill_level;
+                        q_space = efx->txq_entries - 1 - fill_level;
                        if (unlikely(q_space-- <= 0)) {
                                *final_buffer = NULL;
                                return 1;
                        }
                        smp_mb();
-                        --tx_queue->stopped;
+                        netif_tx_start_queue(tx_queue->core_txq);
                }
-                insert_ptr = tx_queue->insert_count & EFX_TXQ_MASK;
+                insert_ptr = tx_queue->insert_count & tx_queue->ptr_mask;
                buffer = &tx_queue->buffer[insert_ptr];
                ++tx_queue->insert_count;
                EFX_BUG_ON_PARANOID(tx_queue->insert_count -
-                                    tx_queue->read_count >
+                                    tx_queue->read_count >=
-                                    EFX_TXQ_MASK);
+                                    efx->txq_entries);
                efx_tsoh_free(tx_queue, buffer);
                EFX_BUG_ON_PARANOID(buffer->len);
@@ -813,7 +853,7 @@ static void efx_tso_put_header(struct efx_tx_queue *tx_queue,
 {
        struct efx_tx_buffer *buffer;
-        buffer = &tx_queue->buffer[tx_queue->insert_count & EFX_TXQ_MASK];
+        buffer = &tx_queue->buffer[tx_queue->insert_count & tx_queue->ptr_mask];
        efx_tsoh_free(tx_queue, buffer);
        EFX_BUG_ON_PARANOID(buffer->len);
        EFX_BUG_ON_PARANOID(buffer->unmap_len);
@@ -838,7 +878,7 @@ static void efx_enqueue_unwind(struct efx_tx_queue *tx_queue)
        while (tx_queue->insert_count != tx_queue->write_count) {
                --tx_queue->insert_count;
                buffer = &tx_queue->buffer[tx_queue->insert_count &
-                                           EFX_TXQ_MASK];
+                                           tx_queue->ptr_mask];
                efx_tsoh_free(tx_queue, buffer);
                EFX_BUG_ON_PARANOID(buffer->skb);
                if (buffer->unmap_len) {
@@ -1103,8 +1143,10 @@ static int efx_enqueue_skb_tso(struct efx_tx_queue *tx_queue,
        while (1) {
                rc = tso_fill_packet_with_fragment(tx_queue, skb, &state);
-                if (unlikely(rc))
+                if (unlikely(rc)) {
-                        goto stop;
+                        rc2 = NETDEV_TX_BUSY;
+                        goto unwind;
+                }
                /* Move onto the next fragment? */
                if (state.in_len == 0) {
@@ -1133,14 +1175,6 @@ static int efx_enqueue_skb_tso(struct efx_tx_queue *tx_queue,
        netif_err(efx, tx_err, efx->net_dev,
                  "Out of memory for TSO headers, or PCI mapping error\n");
        dev_kfree_skb_any(skb);
-        goto unwind;
- stop:
-        rc2 = NETDEV_TX_BUSY;
-        /* Stop the queue if it wasn't stopped before. */
-        if (tx_queue->stopped == 1)
-                efx_stop_queue(tx_queue->channel);
 unwind:
        /* Free the DMA mapping we were in the process of writing out */
@@ -1168,7 +1202,7 @@ static void efx_fini_tso(struct efx_tx_queue *tx_queue)
        unsigned i;
        if (tx_queue->buffer) {
-                for (i = 0; i <= EFX_TXQ_MASK; ++i)
+                for (i = 0; i <= tx_queue->ptr_mask; ++i)
                        efx_tsoh_free(tx_queue, &tx_queue->buffer[i]);
        }
diff --git a/drivers/net/sfc/txc43128_phy.c b/drivers/net/sfc/txc43128_phy.c
new file mode 100644
index 000000000000..7c21b334a75b
--- /dev/null
+++ b/drivers/net/sfc/txc43128_phy.c
@@ -0,0 +1,560 @@
+/****************************************************************************
+ * Driver for Solarflare Solarstorm network controllers and boards
+ * Copyright 2006-2011 Solarflare Communications Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published
+ * by the Free Software Foundation, incorporated herein by reference.
+ */
+/*
+ * Driver for Transwitch/Mysticom CX4 retimer
+ * see www.transwitch.com, part is TXC-43128
+ */
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include "efx.h"
+#include "mdio_10g.h"
+#include "phy.h"
+#include "nic.h"
+/* We expect these MMDs to be in the package */
+#define TXC_REQUIRED_DEVS (MDIO_DEVS_PCS |      \
+                           MDIO_DEVS_PMAPMD |   \
+                           MDIO_DEVS_PHYXS)
+#define TXC_LOOPBACKS ((1 << LOOPBACK_PCS) |    \
+                       (1 << LOOPBACK_PMAPMD) | \
+                       (1 << LOOPBACK_PHYXS_WS))
+/**************************************************************************
+ *
+ * Compile-time config
+ *
+ **************************************************************************
+ */
+#define TXCNAME "TXC43128"
+/* Total length of time we'll wait for the PHY to come out of reset (ms) */
+#define TXC_MAX_RESET_TIME      500
+/* Interval between checks (ms) */
+#define TXC_RESET_WAIT          10
+/* How long to run BIST (us) */
+#define TXC_BIST_DURATION       50
+/**************************************************************************
+ *
+ * Register definitions
+ *
+ **************************************************************************
+ */
+/* Command register */
+#define TXC_GLRGS_GLCMD         0xc004
+/* Useful bits in command register */
+/* Lane power-down */
+#define TXC_GLCMD_L01PD_LBN     5
+#define TXC_GLCMD_L23PD_LBN     6
+/* Limited SW reset: preserves configuration but
+ * initiates a logic reset. Self-clearing */
+#define TXC_GLCMD_LMTSWRST_LBN  14
+/* Signal Quality Control */
+#define TXC_GLRGS_GSGQLCTL      0xc01a
+/* Enable bit */
+#define TXC_GSGQLCT_SGQLEN_LBN  15
+/* Lane selection */
+#define TXC_GSGQLCT_LNSL_LBN    13
+#define TXC_GSGQLCT_LNSL_WIDTH  2
+/* Analog TX control */
+#define TXC_ALRGS_ATXCTL        0xc040
+/* Lane power-down */
+#define TXC_ATXCTL_TXPD3_LBN    15
+#define TXC_ATXCTL_TXPD2_LBN    14
+#define TXC_ATXCTL_TXPD1_LBN    13
+#define TXC_ATXCTL_TXPD0_LBN    12
+/* Amplitude on lanes 0, 1 */
+#define TXC_ALRGS_ATXAMP0       0xc041
+/* Amplitude on lanes 2, 3 */
+#define TXC_ALRGS_ATXAMP1       0xc042
+/* Bit position of value for lane 0 (or 2) */
+#define TXC_ATXAMP_LANE02_LBN   3
+/* Bit position of value for lane 1 (or 3) */
+#define TXC_ATXAMP_LANE13_LBN   11
+#define TXC_ATXAMP_1280_mV      0
+#define TXC_ATXAMP_1200_mV      8
+#define TXC_ATXAMP_1120_mV      12
+#define TXC_ATXAMP_1060_mV      14
+#define TXC_ATXAMP_0820_mV      25
+#define TXC_ATXAMP_0720_mV      26
+#define TXC_ATXAMP_0580_mV      27
+#define TXC_ATXAMP_0440_mV      28
+#define TXC_ATXAMP_0820_BOTH                                    \
+        ((TXC_ATXAMP_0820_mV << TXC_ATXAMP_LANE02_LBN)          \
+         | (TXC_ATXAMP_0820_mV << TXC_ATXAMP_LANE13_LBN))
+#define TXC_ATXAMP_DEFAULT      0x6060 /* From databook */
+/* Preemphasis on lanes 0, 1 */
+#define TXC_ALRGS_ATXPRE0       0xc043
+/* Preemphasis on lanes 2, 3 */
+#define TXC_ALRGS_ATXPRE1       0xc044
+#define TXC_ATXPRE_NONE 0
+#define TXC_ATXPRE_DEFAULT      0x1010 /* From databook */
+#define TXC_ALRGS_ARXCTL        0xc045
+/* Lane power-down */
+#define TXC_ARXCTL_RXPD3_LBN    15
+#define TXC_ARXCTL_RXPD2_LBN    14
+#define TXC_ARXCTL_RXPD1_LBN    13
+#define TXC_ARXCTL_RXPD0_LBN    12
+/* Main control */
+#define TXC_MRGS_CTL            0xc340
+/* Bits in main control */
+#define TXC_MCTL_RESET_LBN      15      /* Self clear */
+#define TXC_MCTL_TXLED_LBN      14      /* 1 to show align status */
+#define TXC_MCTL_RXLED_LBN      13      /* 1 to show align status */
+/* GPIO output */
+#define TXC_GPIO_OUTPUT         0xc346
+#define TXC_GPIO_DIR            0xc348
+/* Vendor-specific BIST registers */
+#define TXC_BIST_CTL            0xc280
+#define TXC_BIST_TXFRMCNT       0xc281
+#define TXC_BIST_RX0FRMCNT      0xc282
+#define TXC_BIST_RX1FRMCNT      0xc283
+#define TXC_BIST_RX2FRMCNT      0xc284
+#define TXC_BIST_RX3FRMCNT      0xc285
+#define TXC_BIST_RX0ERRCNT      0xc286
+#define TXC_BIST_RX1ERRCNT      0xc287
+#define TXC_BIST_RX2ERRCNT      0xc288
+#define TXC_BIST_RX3ERRCNT      0xc289
+/* BIST type (controls bit patter in test) */
+#define TXC_BIST_CTRL_TYPE_LBN  10
+#define TXC_BIST_CTRL_TYPE_TSD  0       /* TranSwitch Deterministic */
+#define TXC_BIST_CTRL_TYPE_CRP  1       /* CRPAT standard */
+#define TXC_BIST_CTRL_TYPE_CJP  2       /* CJPAT standard */
+#define TXC_BIST_CTRL_TYPE_TSR  3       /* TranSwitch pseudo-random */
+/* Set this to 1 for 10 bit and 0 for 8 bit */
+#define TXC_BIST_CTRL_B10EN_LBN 12
+/* Enable BIST (write 0 to disable) */
+#define TXC_BIST_CTRL_ENAB_LBN  13
+/* Stop BIST (self-clears when stop complete) */
+#define TXC_BIST_CTRL_STOP_LBN  14
+/* Start BIST (cleared by writing 1 to STOP) */
+#define TXC_BIST_CTRL_STRT_LBN  15
+/* Mt. Diablo test configuration */
+#define TXC_MTDIABLO_CTRL       0xc34f
+#define TXC_MTDIABLO_CTRL_PMA_LOOP_LBN  10
+struct txc43128_data {
+        unsigned long bug10934_timer;
+        enum efx_phy_mode phy_mode;
+        enum efx_loopback_mode loopback_mode;
+};
+/* The PHY sometimes needs a reset to bring the link back up.  So long as
+ * it reports link down, we reset it every 5 seconds.
+ */
+#define BUG10934_RESET_INTERVAL (5 * HZ)
+/* Perform a reset that doesn't clear configuration changes */
+static void txc_reset_logic(struct efx_nic *efx);
+/* Set the output value of a gpio */
+void falcon_txc_set_gpio_val(struct efx_nic *efx, int pin, int on)
+{
+        efx_mdio_set_flag(efx, MDIO_MMD_PHYXS, TXC_GPIO_OUTPUT, 1 << pin, on);
+}
+/* Set up the GPIO direction register */
+void falcon_txc_set_gpio_dir(struct efx_nic *efx, int pin, int dir)
+{
+        efx_mdio_set_flag(efx, MDIO_MMD_PHYXS, TXC_GPIO_DIR, 1 << pin, dir);
+}
+/* Reset the PMA/PMD MMD. The documentation is explicit that this does a
+ * global reset (it's less clear what reset of other MMDs does).*/
+static int txc_reset_phy(struct efx_nic *efx)
+{
+        int rc = efx_mdio_reset_mmd(efx, MDIO_MMD_PMAPMD,
+                                    TXC_MAX_RESET_TIME / TXC_RESET_WAIT,
+                                    TXC_RESET_WAIT);
+        if (rc < 0)
+                goto fail;
+        /* Check that all the MMDs we expect are present and responding. */
+        rc = efx_mdio_check_mmds(efx, TXC_REQUIRED_DEVS);
+        if (rc < 0)
+                goto fail;
+        return 0;
+fail:
+        netif_err(efx, hw, efx->net_dev, TXCNAME ": reset timed out!\n");
+        return rc;
+}
+/* Run a single BIST on one MMD */
+static int txc_bist_one(struct efx_nic *efx, int mmd, int test)
+{
+        int ctrl, bctl;
+        int lane;
+        int rc = 0;
+        /* Set PMA to test into loopback using Mt Diablo reg as per app note */
+        ctrl = efx_mdio_read(efx, MDIO_MMD_PCS, TXC_MTDIABLO_CTRL);
+        ctrl |= (1 << TXC_MTDIABLO_CTRL_PMA_LOOP_LBN);
+        efx_mdio_write(efx, MDIO_MMD_PCS, TXC_MTDIABLO_CTRL, ctrl);
+        /* The BIST app. note lists these  as 3 distinct steps. */
+        /* Set the BIST type */
+        bctl = (test << TXC_BIST_CTRL_TYPE_LBN);
+        efx_mdio_write(efx, mmd, TXC_BIST_CTL, bctl);
+        /* Set the BSTEN bit in the BIST Control register to enable */
+        bctl |= (1 << TXC_BIST_CTRL_ENAB_LBN);
+        efx_mdio_write(efx, mmd, TXC_BIST_CTL, bctl);
+        /* Set the BSTRT bit in the BIST Control register */
+        efx_mdio_write(efx, mmd, TXC_BIST_CTL,
+                       bctl | (1 << TXC_BIST_CTRL_STRT_LBN));
+        /* Wait. */
+        udelay(TXC_BIST_DURATION);
+        /* Set the BSTOP bit in the BIST Control register */
+        bctl |= (1 << TXC_BIST_CTRL_STOP_LBN);
+        efx_mdio_write(efx, mmd, TXC_BIST_CTL, bctl);
+        /* The STOP bit should go off when things have stopped */
+        while (bctl & (1 << TXC_BIST_CTRL_STOP_LBN))
+                bctl = efx_mdio_read(efx, mmd, TXC_BIST_CTL);
+        /* Check all the error counts are 0 and all the frame counts are
+           non-zero */
+        for (lane = 0; lane < 4; lane++) {
+                int count = efx_mdio_read(efx, mmd, TXC_BIST_RX0ERRCNT + lane);
+                if (count != 0) {
+                        netif_err(efx, hw, efx->net_dev, TXCNAME": BIST error. "
+                                  "Lane %d had %d errs\n", lane, count);
+                        rc = -EIO;
+                }
+                count = efx_mdio_read(efx, mmd, TXC_BIST_RX0FRMCNT + lane);
+                if (count == 0) {
+                        netif_err(efx, hw, efx->net_dev, TXCNAME": BIST error. "
+                                  "Lane %d got 0 frames\n", lane);
+                        rc = -EIO;
+                }
+        }
+        if (rc == 0)
+                netif_info(efx, hw, efx->net_dev, TXCNAME": BIST pass\n");
+        /* Disable BIST */
+        efx_mdio_write(efx, mmd, TXC_BIST_CTL, 0);
+        /* Turn off loopback */
+        ctrl &= ~(1 << TXC_MTDIABLO_CTRL_PMA_LOOP_LBN);
+        efx_mdio_write(efx, MDIO_MMD_PCS, TXC_MTDIABLO_CTRL, ctrl);
+        return rc;
+}
+static int txc_bist(struct efx_nic *efx)
+{
+        return txc_bist_one(efx, MDIO_MMD_PCS, TXC_BIST_CTRL_TYPE_TSD);
+}
+/* Push the non-configurable defaults into the PHY. This must be
+ * done after every full reset */
+static void txc_apply_defaults(struct efx_nic *efx)
+{
+        int mctrl;
+        /* Turn amplitude down and preemphasis off on the host side
+         * (PHY<->MAC) as this is believed less likely to upset Falcon
+         * and no adverse effects have been noted. It probably also
+         * saves a picowatt or two */
+        /* Turn off preemphasis */
+        efx_mdio_write(efx, MDIO_MMD_PHYXS, TXC_ALRGS_ATXPRE0, TXC_ATXPRE_NONE);
+        efx_mdio_write(efx, MDIO_MMD_PHYXS, TXC_ALRGS_ATXPRE1, TXC_ATXPRE_NONE);
+        /* Turn down the amplitude */
+        efx_mdio_write(efx, MDIO_MMD_PHYXS,
+                       TXC_ALRGS_ATXAMP0, TXC_ATXAMP_0820_BOTH);
+        efx_mdio_write(efx, MDIO_MMD_PHYXS,
+                       TXC_ALRGS_ATXAMP1, TXC_ATXAMP_0820_BOTH);
+        /* Set the line side amplitude and preemphasis to the databook
+         * defaults as an erratum causes them to be 0 on at least some
+         * PHY rev.s */
+        efx_mdio_write(efx, MDIO_MMD_PMAPMD,
+                       TXC_ALRGS_ATXPRE0, TXC_ATXPRE_DEFAULT);
+        efx_mdio_write(efx, MDIO_MMD_PMAPMD,
+                       TXC_ALRGS_ATXPRE1, TXC_ATXPRE_DEFAULT);
+        efx_mdio_write(efx, MDIO_MMD_PMAPMD,
+                       TXC_ALRGS_ATXAMP0, TXC_ATXAMP_DEFAULT);
+        efx_mdio_write(efx, MDIO_MMD_PMAPMD,
+                       TXC_ALRGS_ATXAMP1, TXC_ATXAMP_DEFAULT);
+        /* Set up the LEDs  */
+        mctrl = efx_mdio_read(efx, MDIO_MMD_PHYXS, TXC_MRGS_CTL);
+        /* Set the Green and Red LEDs to their default modes */
+        mctrl &= ~((1 << TXC_MCTL_TXLED_LBN) | (1 << TXC_MCTL_RXLED_LBN));
+        efx_mdio_write(efx, MDIO_MMD_PHYXS, TXC_MRGS_CTL, mctrl);
+        /* Databook recommends doing this after configuration changes */
+        txc_reset_logic(efx);
+        falcon_board(efx)->type->init_phy(efx);
+}
+static int txc43128_phy_probe(struct efx_nic *efx)
+{
+        struct txc43128_data *phy_data;
+        /* Allocate phy private storage */
+        phy_data = kzalloc(sizeof(*phy_data), GFP_KERNEL);
+        if (!phy_data)
+                return -ENOMEM;
+        efx->phy_data = phy_data;
+        phy_data->phy_mode = efx->phy_mode;
+        efx->mdio.mmds = TXC_REQUIRED_DEVS;
+        efx->mdio.mode_support = MDIO_SUPPORTS_C45 | MDIO_EMULATE_C22;
+        efx->loopback_modes = TXC_LOOPBACKS | FALCON_XMAC_LOOPBACKS;
+        return 0;
+}
+/* Initialisation entry point for this PHY driver */
+static int txc43128_phy_init(struct efx_nic *efx)
+{
+        int rc;
+        rc = txc_reset_phy(efx);
+        if (rc < 0)
+                return rc;
+        rc = txc_bist(efx);
+        if (rc < 0)
+                return rc;
+        txc_apply_defaults(efx);
+        return 0;
+}
+/* Set the lane power down state in the global registers */
+static void txc_glrgs_lane_power(struct efx_nic *efx, int mmd)
+{
+        int pd = (1 << TXC_GLCMD_L01PD_LBN) | (1 << TXC_GLCMD_L23PD_LBN);
+        int ctl = efx_mdio_read(efx, mmd, TXC_GLRGS_GLCMD);
+        if (!(efx->phy_mode & PHY_MODE_LOW_POWER))
+                ctl &= ~pd;
+        else
+                ctl |= pd;
+        efx_mdio_write(efx, mmd, TXC_GLRGS_GLCMD, ctl);
+}
+/* Set the lane power down state in the analog control registers */
+static void txc_analog_lane_power(struct efx_nic *efx, int mmd)
+{
+        int txpd = (1 << TXC_ATXCTL_TXPD3_LBN) | (1 << TXC_ATXCTL_TXPD2_LBN)
+                | (1 << TXC_ATXCTL_TXPD1_LBN) | (1 << TXC_ATXCTL_TXPD0_LBN);
+        int rxpd = (1 << TXC_ARXCTL_RXPD3_LBN) | (1 << TXC_ARXCTL_RXPD2_LBN)
+                | (1 << TXC_ARXCTL_RXPD1_LBN) | (1 << TXC_ARXCTL_RXPD0_LBN);
+        int txctl = efx_mdio_read(efx, mmd, TXC_ALRGS_ATXCTL);
+        int rxctl = efx_mdio_read(efx, mmd, TXC_ALRGS_ARXCTL);
+        if (!(efx->phy_mode & PHY_MODE_LOW_POWER)) {
+                txctl &= ~txpd;
+                rxctl &= ~rxpd;
+        } else {
+                txctl |= txpd;
+                rxctl |= rxpd;
+        }
+        efx_mdio_write(efx, mmd, TXC_ALRGS_ATXCTL, txctl);
+        efx_mdio_write(efx, mmd, TXC_ALRGS_ARXCTL, rxctl);
+}
+static void txc_set_power(struct efx_nic *efx)
+{
+        /* According to the data book, all the MMDs can do low power */
+        efx_mdio_set_mmds_lpower(efx,
+                                 !!(efx->phy_mode & PHY_MODE_LOW_POWER),
+                                 TXC_REQUIRED_DEVS);
+        /* Global register bank is in PCS, PHY XS. These control the host
+         * side and line side settings respectively. */
+        txc_glrgs_lane_power(efx, MDIO_MMD_PCS);
+        txc_glrgs_lane_power(efx, MDIO_MMD_PHYXS);
+        /* Analog register bank in PMA/PMD, PHY XS */
+        txc_analog_lane_power(efx, MDIO_MMD_PMAPMD);
+        txc_analog_lane_power(efx, MDIO_MMD_PHYXS);
+}
+static void txc_reset_logic_mmd(struct efx_nic *efx, int mmd)
+{
+        int val = efx_mdio_read(efx, mmd, TXC_GLRGS_GLCMD);
+        int tries = 50;
+        val |= (1 << TXC_GLCMD_LMTSWRST_LBN);
+        efx_mdio_write(efx, mmd, TXC_GLRGS_GLCMD, val);
+        while (tries--) {
+                val = efx_mdio_read(efx, mmd, TXC_GLRGS_GLCMD);
+                if (!(val & (1 << TXC_GLCMD_LMTSWRST_LBN)))
+                        break;
+                udelay(1);
+        }
+        if (!tries)
+                netif_info(efx, hw, efx->net_dev,
+                           TXCNAME " Logic reset timed out!\n");
+}
+/* Perform a logic reset. This preserves the configuration registers
+ * and is needed for some configuration changes to take effect */
+static void txc_reset_logic(struct efx_nic *efx)
+{
+        /* The data sheet claims we can do the logic reset on either the
+         * PCS or the PHYXS and the result is a reset of both host- and
+         * line-side logic. */
+        txc_reset_logic_mmd(efx, MDIO_MMD_PCS);
+}
+static bool txc43128_phy_read_link(struct efx_nic *efx)
+{
+        return efx_mdio_links_ok(efx, TXC_REQUIRED_DEVS);
+}
+static int txc43128_phy_reconfigure(struct efx_nic *efx)
+{
+        struct txc43128_data *phy_data = efx->phy_data;
+        enum efx_phy_mode mode_change = efx->phy_mode ^ phy_data->phy_mode;
+        bool loop_change = LOOPBACK_CHANGED(phy_data, efx, TXC_LOOPBACKS);
+        if (efx->phy_mode & mode_change & PHY_MODE_TX_DISABLED) {
+                txc_reset_phy(efx);
+                txc_apply_defaults(efx);
+                falcon_reset_xaui(efx);
+                mode_change &= ~PHY_MODE_TX_DISABLED;
+        }
+        efx_mdio_transmit_disable(efx);
+        efx_mdio_phy_reconfigure(efx);
+        if (mode_change & PHY_MODE_LOW_POWER)
+                txc_set_power(efx);
+        /* The data sheet claims this is required after every reconfiguration
+         * (note at end of 7.1), but we mustn't do it when nothing changes as
+         * it glitches the link, and reconfigure gets called on link change,
+         * so we get an IRQ storm on link up. */
+        if (loop_change || mode_change)
+                txc_reset_logic(efx);
+        phy_data->phy_mode = efx->phy_mode;
+        phy_data->loopback_mode = efx->loopback_mode;
+        return 0;
+}
+static void txc43128_phy_fini(struct efx_nic *efx)
+{
+        /* Disable link events */
+        efx_mdio_write(efx, MDIO_MMD_PMAPMD, MDIO_PMA_LASI_CTRL, 0);
+}
+static void txc43128_phy_remove(struct efx_nic *efx)
+{
+        kfree(efx->phy_data);
+        efx->phy_data = NULL;
+}
+/* Periodic callback: this exists mainly to poll link status as we
+ * don't use LASI interrupts */
+static bool txc43128_phy_poll(struct efx_nic *efx)
+{
+        struct txc43128_data *data = efx->phy_data;
+        bool was_up = efx->link_state.up;
+        efx->link_state.up = txc43128_phy_read_link(efx);
+        efx->link_state.speed = 10000;
+        efx->link_state.fd = true;
+        efx->link_state.fc = efx->wanted_fc;
+        if (efx->link_state.up || (efx->loopback_mode != LOOPBACK_NONE)) {
+                data->bug10934_timer = jiffies;
+        } else {
+                if (time_after_eq(jiffies, (data->bug10934_timer +
+                                            BUG10934_RESET_INTERVAL))) {
+                        data->bug10934_timer = jiffies;
+                        txc_reset_logic(efx);
+                }
+        }
+        return efx->link_state.up != was_up;
+}
+static const char *txc43128_test_names[] = {
+        "bist"
+};
+static const char *txc43128_test_name(struct efx_nic *efx, unsigned int index)
+{
+        if (index < ARRAY_SIZE(txc43128_test_names))
+                return txc43128_test_names[index];
+        return NULL;
+}
+static int txc43128_run_tests(struct efx_nic *efx, int *results, unsigned flags)
+{
+        int rc;
+        if (!(flags & ETH_TEST_FL_OFFLINE))
+                return 0;
+        rc = txc_reset_phy(efx);
+        if (rc < 0)
+                return rc;
+        rc = txc_bist(efx);
+        txc_apply_defaults(efx);
+        results[0] = rc ? -1 : 1;
+        return rc;
+}
+static void txc43128_get_settings(struct efx_nic *efx, struct ethtool_cmd *ecmd)
+{
+        mdio45_ethtool_gset(&efx->mdio, ecmd);
+}
+const struct efx_phy_operations falcon_txc_phy_ops = {
+        .probe          = txc43128_phy_probe,
+        .init           = txc43128_phy_init,
+        .reconfigure    = txc43128_phy_reconfigure,
+        .poll           = txc43128_phy_poll,
+        .fini           = txc43128_phy_fini,
+        .remove         = txc43128_phy_remove,
+        .get_settings   = txc43128_get_settings,
+        .set_settings   = efx_mdio_set_settings,
+        .test_alive     = efx_mdio_test_alive,
+        .run_tests      = txc43128_run_tests,
+        .test_name      = txc43128_test_name,
+};
diff --git a/drivers/net/sfc/workarounds.h b/drivers/net/sfc/workarounds.h
index 782e45a613d6..99ff11400cef 100644
--- a/drivers/net/sfc/workarounds.h
+++ b/drivers/net/sfc/workarounds.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
- * Copyright 2006-2009 Solarflare Communications Inc.
+ * Copyright 2006-2010 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
@@ -19,9 +19,7 @@
 #define EFX_WORKAROUND_FALCON_A(efx) (efx_nic_rev(efx) <= EFX_REV_FALCON_A1)
 #define EFX_WORKAROUND_FALCON_AB(efx) (efx_nic_rev(efx) <= EFX_REV_FALCON_B0)
 #define EFX_WORKAROUND_SIENA(efx) (efx_nic_rev(efx) == EFX_REV_SIENA_A0)
-#define EFX_WORKAROUND_10G(efx) EFX_IS10G(efx)
+#define EFX_WORKAROUND_10G(efx) 1
-#define EFX_WORKAROUND_SFT9001(efx) ((efx)->phy_type == PHY_TYPE_SFT9001A || \
-                                     (efx)->phy_type == PHY_TYPE_SFT9001B)
 /* XAUI resets if link not detected */
 #define EFX_WORKAROUND_5147 EFX_WORKAROUND_ALWAYS
@@ -40,6 +38,8 @@
 #define EFX_WORKAROUND_15783 EFX_WORKAROUND_ALWAYS
 /* Legacy interrupt storm when interrupt fifo fills */
 #define EFX_WORKAROUND_17213 EFX_WORKAROUND_SIENA
+/* Write combining and sriov=enabled are incompatible */
+#define EFX_WORKAROUND_22643 EFX_WORKAROUND_SIENA
 /* Spurious parity errors in TSORT buffers */
 #define EFX_WORKAROUND_5129 EFX_WORKAROUND_FALCON_A
@@ -58,9 +58,4 @@
 /* Leak overlength packets rather than free */
 #define EFX_WORKAROUND_8071 EFX_WORKAROUND_FALCON_A
-/* Need to send XNP pages for 100BaseT */
-#define EFX_WORKAROUND_13204 EFX_WORKAROUND_SFT9001
-/* Don't restart AN in near-side loopback */
-#define EFX_WORKAROUND_15195 EFX_WORKAROUND_SFT9001
 #endif /* EFX_WORKAROUNDS_H */