sfc: Implement message level control

Replace EFX_ERR() with netif_err(), EFX_INFO() with netif_info(),
EFX_LOG() with netif_dbg() and EFX_TRACE() and EFX_REGDUMP() with
netif_vdbg().

Replace EFX_ERR_RL(), EFX_INFO_RL() and EFX_LOG_RL() using explicit
calls to net_ratelimit().

Implement the ethtool operations to get and set message level flags,
and add a 'debug' module parameter for the initial value.

Signed-off-by: Ben Hutchings <bhutchings@solarflare.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 107 insertions, 69 deletions

diff --git a/drivers/net/sfc/falcon.c b/drivers/net/sfc/falcon.c
index 8558865ff380..92d38ede6bef 100644
--- a/drivers/net/sfc/falcon.c
+++ b/drivers/net/sfc/falcon.c
@@ -167,13 +167,15 @@ irqreturn_t falcon_legacy_interrupt_a1(int irq, void *dev_id)
          * exit without having touched the hardware.
          */
         if (unlikely(EFX_OWORD_IS_ZERO(*int_ker))) {
-                EFX_TRACE(efx, "IRQ %d on CPU %d not for me\n", irq,
-                          raw_smp_processor_id());
+                netif_vdbg(efx, intr, efx->net_dev,
+                           "IRQ %d on CPU %d not for me\n", irq,
+                           raw_smp_processor_id());
                 return IRQ_NONE;
         }
         efx->last_irq_cpu = raw_smp_processor_id();
-        EFX_TRACE(efx, "IRQ %d on CPU %d status " EFX_OWORD_FMT "\n",
-                  irq, raw_smp_processor_id(), EFX_OWORD_VAL(*int_ker));
+        netif_vdbg(efx, intr, efx->net_dev,
+                   "IRQ %d on CPU %d status " EFX_OWORD_FMT "\n",
+                   irq, raw_smp_processor_id(), EFX_OWORD_VAL(*int_ker));
 
         /* Determine interrupting queues, clear interrupt status
          * register and acknowledge the device interrupt.
@@ -239,7 +241,8 @@ static int falcon_spi_wait(struct efx_nic *efx)
                 if (!falcon_spi_poll(efx))
                         return 0;
                 if (time_after_eq(jiffies, timeout)) {
-                        EFX_ERR(efx, "timed out waiting for SPI\n");
+                        netif_err(efx, hw, efx->net_dev,
+                                  "timed out waiting for SPI\n");
                         return -ETIMEDOUT;
                 }
                 schedule_timeout_uninterruptible(1);
@@ -333,9 +336,10 @@ falcon_spi_wait_write(struct efx_nic *efx, const struct efx_spi_device *spi)
                 if (!(status & SPI_STATUS_NRDY))
                         return 0;
                 if (time_after_eq(jiffies, timeout)) {
-                        EFX_ERR(efx, "SPI write timeout on device %d"
-                                " last status=0x%02x\n",
-                                spi->device_id, status);
+                        netif_err(efx, hw, efx->net_dev,
+                                  "SPI write timeout on device %d"
+                                  " last status=0x%02x\n",
+                                  spi->device_id, status);
                         return -ETIMEDOUT;
                 }
                 schedule_timeout_uninterruptible(1);
@@ -469,7 +473,8 @@ static void falcon_reset_macs(struct efx_nic *efx)
                                 udelay(10);
                         }
 
-                        EFX_ERR(efx, "timed out waiting for XMAC core reset\n");
+                        netif_err(efx, hw, efx->net_dev,
+                                  "timed out waiting for XMAC core reset\n");
                 }
         }
 
@@ -492,12 +497,13 @@ static void falcon_reset_macs(struct efx_nic *efx)
                 if (!EFX_OWORD_FIELD(reg, FRF_AB_RST_XGTX) &&
                     !EFX_OWORD_FIELD(reg, FRF_AB_RST_XGRX) &&
                     !EFX_OWORD_FIELD(reg, FRF_AB_RST_EM)) {
-                        EFX_LOG(efx, "Completed MAC reset after %d loops\n",
-                                count);
+                        netif_dbg(efx, hw, efx->net_dev,
+                                  "Completed MAC reset after %d loops\n",
+                                  count);
                         break;
                 }
                 if (count > 20) {
-                        EFX_ERR(efx, "MAC reset failed\n");
+                        netif_err(efx, hw, efx->net_dev, "MAC reset failed\n");
                         break;
                 }
                 count++;
@@ -627,7 +633,8 @@ static void falcon_stats_complete(struct efx_nic *efx)
                 rmb(); /* read the done flag before the stats */
                 efx->mac_op->update_stats(efx);
         } else {
-                EFX_ERR(efx, "timed out waiting for statistics\n");
+                netif_err(efx, hw, efx->net_dev,
+                          "timed out waiting for statistics\n");
         }
 }
 
@@ -717,16 +724,17 @@ static int falcon_gmii_wait(struct efx_nic *efx)
                 if (EFX_OWORD_FIELD(md_stat, FRF_AB_MD_BSY) == 0) {
                         if (EFX_OWORD_FIELD(md_stat, FRF_AB_MD_LNFL) != 0 ||
                             EFX_OWORD_FIELD(md_stat, FRF_AB_MD_BSERR) != 0) {
-                                EFX_ERR(efx, "error from GMII access "
-                                        EFX_OWORD_FMT"\n",
-                                        EFX_OWORD_VAL(md_stat));
+                                netif_err(efx, hw, efx->net_dev,
+                                          "error from GMII access "
+                                          EFX_OWORD_FMT"\n",
+                                          EFX_OWORD_VAL(md_stat));
                                 return -EIO;
                         }
                         return 0;
                 }
                 udelay(10);
         }
-        EFX_ERR(efx, "timed out waiting for GMII\n");
+        netif_err(efx, hw, efx->net_dev, "timed out waiting for GMII\n");
         return -ETIMEDOUT;
 }
 
@@ -738,7 +746,8 @@ static int falcon_mdio_write(struct net_device *net_dev,
         efx_oword_t reg;
         int rc;
 
-        EFX_REGDUMP(efx, "writing MDIO %d register %d.%d with 0x%04x\n",
+        netif_vdbg(efx, hw, efx->net_dev,
+                   "writing MDIO %d register %d.%d with 0x%04x\n",
                     prtad, devad, addr, value);
 
         mutex_lock(&efx->mdio_lock);
@@ -812,8 +821,9 @@ static int falcon_mdio_read(struct net_device *net_dev,
         if (rc == 0) {
                 efx_reado(efx, &reg, FR_AB_MD_RXD);
                 rc = EFX_OWORD_FIELD(reg, FRF_AB_MD_RXD);
-                EFX_REGDUMP(efx, "read from MDIO %d register %d.%d, got %04x\n",
-                            prtad, devad, addr, rc);
+                netif_vdbg(efx, hw, efx->net_dev,
+                           "read from MDIO %d register %d.%d, got %04x\n",
+                           prtad, devad, addr, rc);
         } else {
                 /* Abort the read operation */
                 EFX_POPULATE_OWORD_2(reg,
@@ -821,8 +831,9 @@ static int falcon_mdio_read(struct net_device *net_dev,
                                      FRF_AB_MD_GC, 1);
                 efx_writeo(efx, &reg, FR_AB_MD_CS);
 
-                EFX_LOG(efx, "read from MDIO %d register %d.%d, got error %d\n",
-                        prtad, devad, addr, rc);
+                netif_dbg(efx, hw, efx->net_dev,
+                          "read from MDIO %d register %d.%d, got error %d\n",
+                          prtad, devad, addr, rc);
         }
 
 out:
@@ -873,7 +884,8 @@ static void falcon_switch_mac(struct efx_nic *efx)
 
         falcon_clock_mac(efx);
 
-        EFX_LOG(efx, "selected %cMAC\n", EFX_IS10G(efx) ? 'X' : 'G');
+        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);
@@ -897,8 +909,8 @@ static int falcon_probe_port(struct efx_nic *efx)
                 efx->phy_op = &falcon_qt202x_phy_ops;
                 break;
         default:
-                EFX_ERR(efx, "Unknown PHY type %d\n",
-                        efx->phy_type);
+                netif_err(efx, probe, efx->net_dev, "Unknown PHY type %d\n",
+                          efx->phy_type);
                 return -ENODEV;
         }
 
@@ -926,10 +938,11 @@ static int falcon_probe_port(struct efx_nic *efx)
                                   FALCON_MAC_STATS_SIZE);
         if (rc)
                 return rc;
-        EFX_LOG(efx, "stats buffer at %llx (virt %p phys %llx)\n",
-                (u64)efx->stats_buffer.dma_addr,
-                efx->stats_buffer.addr,
-                (u64)virt_to_phys(efx->stats_buffer.addr));
+        netif_dbg(efx, probe, efx->net_dev,
+                  "stats buffer at %llx (virt %p phys %llx)\n",
+                  (u64)efx->stats_buffer.dma_addr,
+                  efx->stats_buffer.addr,
+                  (u64)virt_to_phys(efx->stats_buffer.addr));
 
         return 0;
 }
@@ -969,8 +982,8 @@ falcon_read_nvram(struct efx_nic *efx, struct falcon_nvconfig *nvconfig_out)
         rc = falcon_spi_read(efx, spi, 0, FALCON_NVCONFIG_END, NULL, region);
         mutex_unlock(&efx->spi_lock);
         if (rc) {
-                EFX_ERR(efx, "Failed to read %s\n",
-                        efx->spi_flash ? "flash" : "EEPROM");
+                netif_err(efx, hw, efx->net_dev, "Failed to read %s\n",
+                          efx->spi_flash ? "flash" : "EEPROM");
                 rc = -EIO;
                 goto out;
         }
@@ -980,11 +993,13 @@ falcon_read_nvram(struct efx_nic *efx, struct falcon_nvconfig *nvconfig_out)
 
         rc = -EINVAL;
         if (magic_num != FALCON_NVCONFIG_BOARD_MAGIC_NUM) {
-                EFX_ERR(efx, "NVRAM bad magic 0x%x\n", magic_num);
+                netif_err(efx, hw, efx->net_dev,
+                          "NVRAM bad magic 0x%x\n", magic_num);
                 goto out;
         }
         if (struct_ver < 2) {
-                EFX_ERR(efx, "NVRAM has ancient version 0x%x\n", struct_ver);
+                netif_err(efx, hw, efx->net_dev,
+                          "NVRAM has ancient version 0x%x\n", struct_ver);
                 goto out;
         } else if (struct_ver < 4) {
                 word = &nvconfig->board_magic_num;
@@ -997,7 +1012,8 @@ falcon_read_nvram(struct efx_nic *efx, struct falcon_nvconfig *nvconfig_out)
                 csum += le16_to_cpu(*word);
 
         if (~csum & 0xffff) {
-                EFX_ERR(efx, "NVRAM has incorrect checksum\n");
+                netif_err(efx, hw, efx->net_dev,
+                          "NVRAM has incorrect checksum\n");
                 goto out;
         }
 
@@ -1075,22 +1091,25 @@ static int falcon_reset_hw(struct efx_nic *efx, enum reset_type method)
         efx_oword_t glb_ctl_reg_ker;
         int rc;
 
-        EFX_LOG(efx, "performing %s hardware reset\n", RESET_TYPE(method));
+        netif_dbg(efx, hw, efx->net_dev, "performing %s hardware reset\n",
+                  RESET_TYPE(method));
 
         /* Initiate device reset */
         if (method == RESET_TYPE_WORLD) {
                 rc = pci_save_state(efx->pci_dev);
                 if (rc) {
-                        EFX_ERR(efx, "failed to backup PCI state of primary "
-                                "function prior to hardware reset\n");
+                        netif_err(efx, drv, efx->net_dev,
+                                  "failed to backup PCI state of primary "
+                                  "function prior to hardware reset\n");
                         goto fail1;
                 }
                 if (efx_nic_is_dual_func(efx)) {
                         rc = pci_save_state(nic_data->pci_dev2);
                         if (rc) {
-                                EFX_ERR(efx, "failed to backup PCI state of "
-                                        "secondary function prior to "
-                                        "hardware reset\n");
+                                netif_err(efx, drv, efx->net_dev,
+                                          "failed to backup PCI state of "
+                                          "secondary function prior to "
+                                          "hardware reset\n");
                                 goto fail2;
                         }
                 }
@@ -1115,7 +1134,7 @@ static int falcon_reset_hw(struct efx_nic *efx, enum reset_type method)
         }
         efx_writeo(efx, &glb_ctl_reg_ker, FR_AB_GLB_CTL);
 
-        EFX_LOG(efx, "waiting for hardware reset\n");
+        netif_dbg(efx, hw, efx->net_dev, "waiting for hardware reset\n");
         schedule_timeout_uninterruptible(HZ / 20);
 
         /* Restore PCI configuration if needed */
@@ -1123,28 +1142,32 @@ static int falcon_reset_hw(struct efx_nic *efx, enum reset_type method)
                 if (efx_nic_is_dual_func(efx)) {
                         rc = pci_restore_state(nic_data->pci_dev2);
                         if (rc) {
-                                EFX_ERR(efx, "failed to restore PCI config for "
-                                        "the secondary function\n");
+                                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) {
-                        EFX_ERR(efx, "failed to restore PCI config for the "
-                                "primary function\n");
+                        netif_err(efx, drv, efx->net_dev,
+                                  "failed to restore PCI config for the "
+                                  "primary function\n");
                         goto fail4;
                 }
-                EFX_LOG(efx, "successfully restored PCI config\n");
+                netif_dbg(efx, drv, efx->net_dev,
+                          "successfully restored PCI config\n");
         }
 
         /* Assert that reset complete */
         efx_reado(efx, &glb_ctl_reg_ker, FR_AB_GLB_CTL);
         if (EFX_OWORD_FIELD(glb_ctl_reg_ker, FRF_AB_SWRST) != 0) {
                 rc = -ETIMEDOUT;
-                EFX_ERR(efx, "timed out waiting for hardware reset\n");
+                netif_err(efx, hw, efx->net_dev,
+                          "timed out waiting for hardware reset\n");
                 goto fail5;
         }
-        EFX_LOG(efx, "hardware reset complete\n");
+        netif_dbg(efx, hw, efx->net_dev, "hardware reset complete\n");
 
         return 0;
 
@@ -1167,8 +1190,9 @@ static void falcon_monitor(struct efx_nic *efx)
 
         rc = falcon_board(efx)->type->monitor(efx);
         if (rc) {
-                EFX_ERR(efx, "Board sensor %s; shutting down PHY\n",
-                        (rc == -ERANGE) ? "reported fault" : "failed");
+                netif_err(efx, hw, efx->net_dev,
+                          "Board sensor %s; shutting down PHY\n",
+                          (rc == -ERANGE) ? "reported fault" : "failed");
                 efx->phy_mode |= PHY_MODE_LOW_POWER;
                 rc = __efx_reconfigure_port(efx);
                 WARN_ON(rc);
@@ -1219,7 +1243,8 @@ static int falcon_reset_sram(struct efx_nic *efx)
         /* Wait for SRAM reset to complete */
         count = 0;
         do {
-                EFX_LOG(efx, "waiting for SRAM reset (attempt %d)...\n", count);
+                netif_dbg(efx, hw, efx->net_dev,
+                          "waiting for SRAM reset (attempt %d)...\n", count);
 
                 /* SRAM reset is slow; expect around 16ms */
                 schedule_timeout_uninterruptible(HZ / 50);
@@ -1227,13 +1252,14 @@ static int falcon_reset_sram(struct efx_nic *efx)
                 /* Check for reset complete */
                 efx_reado(efx, &srm_cfg_reg_ker, FR_AZ_SRM_CFG);
                 if (!EFX_OWORD_FIELD(srm_cfg_reg_ker, FRF_AZ_SRM_INIT_EN)) {
-                        EFX_LOG(efx, "SRAM reset complete\n");
+                        netif_dbg(efx, hw, efx->net_dev,
+                                  "SRAM reset complete\n");
 
                         return 0;
                 }
         } while (++count < 20); /* wait upto 0.4 sec */
 
-        EFX_ERR(efx, "timed out waiting for SRAM reset\n");
+        netif_err(efx, hw, efx->net_dev, "timed out waiting for SRAM reset\n");
         return -ETIMEDOUT;
 }
 
@@ -1292,7 +1318,8 @@ static int falcon_probe_nvconfig(struct efx_nic *efx)
 
         rc = falcon_read_nvram(efx, nvconfig);
         if (rc == -EINVAL) {
-                EFX_ERR(efx, "NVRAM is invalid therefore using defaults\n");
+                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;
@@ -1326,7 +1353,8 @@ static int falcon_probe_nvconfig(struct efx_nic *efx)
         /* Read the MAC addresses */
         memcpy(efx->mac_address, nvconfig->mac_address[0], ETH_ALEN);
 
-        EFX_LOG(efx, "PHY is %d phy_id %d\n", efx->phy_type, efx->mdio.prtad);
+        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)
@@ -1355,14 +1383,16 @@ static void falcon_probe_spi_devices(struct efx_nic *efx)
         if (EFX_OWORD_FIELD(gpio_ctl, FRF_AB_GPIO3_PWRUP_VALUE)) {
                 boot_dev = (EFX_OWORD_FIELD(nic_stat, FRF_AB_SF_PRST) ?
                             FFE_AB_SPI_DEVICE_FLASH : FFE_AB_SPI_DEVICE_EEPROM);
-                EFX_LOG(efx, "Booted from %s\n",
-                        boot_dev == FFE_AB_SPI_DEVICE_FLASH ? "flash" : "EEPROM");
+                netif_dbg(efx, probe, efx->net_dev, "Booted from %s\n",
+                          boot_dev == FFE_AB_SPI_DEVICE_FLASH ?
+                          "flash" : "EEPROM");
         } else {
                 /* Disable VPD and set clock dividers to safe
                  * values for initial programming. */
                 boot_dev = -1;
-                EFX_LOG(efx, "Booted from internal ASIC settings;"
-                        " setting SPI config\n");
+                netif_dbg(efx, probe, efx->net_dev,
+                          "Booted from internal ASIC settings;"
+                          " setting SPI config\n");
                 EFX_POPULATE_OWORD_3(ee_vpd_cfg, FRF_AB_EE_VPD_EN, 0,
                                      /* 125 MHz / 7 ~= 20 MHz */
                                      FRF_AB_EE_SF_CLOCK_DIV, 7,
@@ -1396,7 +1426,8 @@ static int falcon_probe_nic(struct efx_nic *efx)
         rc = -ENODEV;
 
         if (efx_nic_fpga_ver(efx) != 0) {
-                EFX_ERR(efx, "Falcon FPGA not supported\n");
+                netif_err(efx, probe, efx->net_dev,
+                          "Falcon FPGA not supported\n");
                 goto fail1;
         }
 
@@ -1406,16 +1437,19 @@ static int falcon_probe_nic(struct efx_nic *efx)
                 u8 pci_rev = efx->pci_dev->revision;
 
                 if ((pci_rev == 0xff) || (pci_rev == 0)) {
-                        EFX_ERR(efx, "Falcon rev A0 not supported\n");
+                        netif_err(efx, probe, efx->net_dev,
+                                  "Falcon rev A0 not supported\n");
                         goto fail1;
                 }
                 efx_reado(efx, &nic_stat, FR_AB_NIC_STAT);
                 if (EFX_OWORD_FIELD(nic_stat, FRF_AB_STRAP_10G) == 0) {
-                        EFX_ERR(efx, "Falcon rev A1 1G not supported\n");
+                        netif_err(efx, probe, efx->net_dev,
+                                  "Falcon rev A1 1G not supported\n");
                         goto fail1;
                 }
                 if (EFX_OWORD_FIELD(nic_stat, FRF_AA_STRAP_PCIE) == 0) {
-                        EFX_ERR(efx, "Falcon rev A1 PCI-X not supported\n");
+                        netif_err(efx, probe, efx->net_dev,
+                                  "Falcon rev A1 PCI-X not supported\n");
                         goto fail1;
                 }
 
@@ -1429,7 +1463,8 @@ static int falcon_probe_nic(struct efx_nic *efx)
                         }
                 }
                 if (!nic_data->pci_dev2) {
-                        EFX_ERR(efx, "failed to find secondary function\n");
+                        netif_err(efx, probe, efx->net_dev,
+                                  "failed to find secondary function\n");
                         rc = -ENODEV;
                         goto fail2;
                 }
@@ -1438,7 +1473,7 @@ static int falcon_probe_nic(struct efx_nic *efx)
         /* Now we can reset the NIC */
         rc = falcon_reset_hw(efx, RESET_TYPE_ALL);
         if (rc) {
-                EFX_ERR(efx, "failed to reset NIC\n");
+                netif_err(efx, probe, efx->net_dev, "failed to reset NIC\n");
                 goto fail3;
         }
 
@@ -1448,9 +1483,11 @@ static int falcon_probe_nic(struct efx_nic *efx)
                 goto fail4;
         BUG_ON(efx->irq_status.dma_addr & 0x0f);
 
-        EFX_LOG(efx, "INT_KER at %llx (virt %p phys %llx)\n",
-                (u64)efx->irq_status.dma_addr,
-                efx->irq_status.addr, (u64)virt_to_phys(efx->irq_status.addr));
+        netif_dbg(efx, probe, efx->net_dev,
+                  "INT_KER at %llx (virt %p phys %llx)\n",
+                  (u64)efx->irq_status.dma_addr,
+                  efx->irq_status.addr,
+                  (u64)virt_to_phys(efx->irq_status.addr));
 
         falcon_probe_spi_devices(efx);
 
@@ -1474,7 +1511,8 @@ static int falcon_probe_nic(struct efx_nic *efx)
 
         rc = falcon_board(efx)->type->init(efx);
         if (rc) {
-                EFX_ERR(efx, "failed to initialise board\n");
+                netif_err(efx, probe, efx->net_dev,
+                          "failed to initialise board\n");
                 goto fail6;
         }