1 files changed, 142 insertions, 232 deletions

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 */
-        channel = &efx->channel[0];
-        while (queues) {
-                if (queues & 0x01)
-                        efx_schedule_channel(channel);
-                channel++;
-                queues >>= 1;
-        }
-
+        if (queues & 1)
+                efx_schedule_channel(efx_get_channel(efx, 0));
+        if (queues & 2)
+                efx_schedule_channel(efx_get_channel(efx, 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_GM_SW_RST, 1);
-                        efx_writeo(efx, &reg, FR_AB_GM_CFG1);
-                        udelay(1000);
-
-                        EFX_POPULATE_OWORD_1(reg, FRF_AB_GM_SW_RST, 0);
-                        efx_writeo(efx, &reg, FR_AB_GM_CFG1);
-                        udelay(1000);
-                        return;
-                } 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");
+                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");
         }
 
         /* 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;
-
-        if (efx->loopback_mode == LOOPBACK_GMAC)
-                efx->link_state.speed = 1000;
-        else
-                efx->link_state.speed = 10000;
+        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 (!spi)
+        if (efx_spi_present(&nic_data->spi_flash))
+                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)) {
-                        rc = pci_restore_state(nic_data->pci_dev2);
-                        if (rc) {
-                                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;
-                }
+                if (efx_nic_is_dual_func(efx))
+                        pci_restore_state(nic_data->pci_dev2);
+                pci_restore_state(efx->pci_dev);
                 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:
-fail5:
+fail3:
+        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,
-                                  struct efx_spi_device **spi_device_ret,
+static void falcon_spi_device_init(struct efx_nic *efx,
+                                  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) {
-                netif_err(efx, probe, efx->net_dev,
-                          "NVRAM is invalid therefore using defaults\n");
-                efx->phy_type = PHY_TYPE_NONE;
-                efx->mdio.prtad = MDIO_PRTAD_NONE;
-                board_rev = 0;
-                rc = 0;
-        } else if (rc) {
-                goto fail1;
-        } else {
-                struct falcon_nvconfig_board_v2 *v2 = &nvconfig->board_v2;
-                struct falcon_nvconfig_board_v3 *v3 = &nvconfig->board_v3;
-
-                efx->phy_type = v2->port0_phy_type;
-                efx->mdio.prtad = v2->port0_phy_addr;
-                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;
-                }
+        if (rc)
+                goto out;
+
+        efx->phy_type = nvconfig->board_v2.port0_phy_type;
+        efx->mdio.prtad = nvconfig->board_v2.port0_phy_addr;
+
+        if (le16_to_cpu(nvconfig->board_struct_ver) >= 3) {
+                falcon_spi_device_init(
+                        efx, &nic_data->spi_flash, FFE_AB_SPI_DEVICE_FLASH,
+                        le32_to_cpu(nvconfig->board_v3
+                                    .spi_device_type[FFE_AB_SPI_DEVICE_FLASH]));
+                falcon_spi_device_init(
+                        efx, &nic_data->spi_eeprom, FFE_AB_SPI_DEVICE_EEPROM,
+                        le32_to_cpu(nvconfig->board_v3
+                                    .spi_device_type[FFE_AB_SPI_DEVICE_EEPROM]));
         }
 
         /* 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);
-        if (rc)
-                goto fail2;
-
-        kfree(nvconfig);
-        return 0;
-
- fail2:
-        falcon_remove_spi_devices(efx);
- fail1:
+        rc = falcon_probe_board(efx,
+                                le16_to_cpu(nvconfig->board_v2.board_revision));
+out:
         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_XOFF_MAC_TH, data_xoff_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, 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);
-                EFX_SET_OWORD_FIELD(reg, FRF_BZ_RX_XOFF_MAC_TH, data_xoff_thr);
+                /* Send XON and XOFF at ~3 * max MTU away from empty/full */
+                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,
 };