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, 135 insertions, 88 deletions

diff --git a/drivers/net/sfc/efx.c b/drivers/net/sfc/efx.c
index 8ad476a19d95..72514005c2a3 100644
--- a/drivers/net/sfc/efx.c
+++ b/drivers/net/sfc/efx.c
@@ -189,6 +189,13 @@ module_param(irq_adapt_high_thresh, uint, 0644);
 MODULE_PARM_DESC(irq_adapt_high_thresh,
                  "Threshold score for increasing IRQ moderation");
 
+static unsigned debug = (NETIF_MSG_DRV | NETIF_MSG_PROBE |
+                         NETIF_MSG_LINK | NETIF_MSG_IFDOWN |
+                         NETIF_MSG_IFUP | NETIF_MSG_RX_ERR |
+                         NETIF_MSG_TX_ERR | NETIF_MSG_HW);
+module_param(debug, uint, 0);
+MODULE_PARM_DESC(debug, "Bitmapped debugging message enable value");
+
 /**************************************************************************
  *
  * Utility functions and prototypes
@@ -272,16 +279,16 @@ static int efx_poll(struct napi_struct *napi, int budget)
 {
         struct efx_channel *channel =
                 container_of(napi, struct efx_channel, napi_str);
+        struct efx_nic *efx = channel->efx;
         int spent;
 
-        EFX_TRACE(channel->efx, "channel %d NAPI poll executing on CPU %d\n",
-                  channel->channel, raw_smp_processor_id());
+        netif_vdbg(efx, intr, efx->net_dev,
+                   "channel %d NAPI poll executing on CPU %d\n",
+                   channel->channel, raw_smp_processor_id());
 
         spent = efx_process_channel(channel, budget);
 
         if (spent < budget) {
-                struct efx_nic *efx = channel->efx;
-
                 if (channel->channel < efx->n_rx_channels &&
                     efx->irq_rx_adaptive &&
                     unlikely(++channel->irq_count == 1000)) {
@@ -357,7 +364,8 @@ void efx_process_channel_now(struct efx_channel *channel)
  */
 static int efx_probe_eventq(struct efx_channel *channel)
 {
-        EFX_LOG(channel->efx, "chan %d create event queue\n", channel->channel);
+        netif_dbg(channel->efx, probe, channel->efx->net_dev,
+                  "chan %d create event queue\n", channel->channel);
 
         return efx_nic_probe_eventq(channel);
 }
@@ -365,7 +373,8 @@ static int efx_probe_eventq(struct efx_channel *channel)
 /* Prepare channel's event queue */
 static void efx_init_eventq(struct efx_channel *channel)
 {
-        EFX_LOG(channel->efx, "chan %d init event queue\n", channel->channel);
+        netif_dbg(channel->efx, drv, channel->efx->net_dev,
+                  "chan %d init event queue\n", channel->channel);
 
         channel->eventq_read_ptr = 0;
 
@@ -374,14 +383,16 @@ static void efx_init_eventq(struct efx_channel *channel)
 
 static void efx_fini_eventq(struct efx_channel *channel)
 {
-        EFX_LOG(channel->efx, "chan %d fini event queue\n", channel->channel);
+        netif_dbg(channel->efx, drv, channel->efx->net_dev,
+                  "chan %d fini event queue\n", channel->channel);
 
         efx_nic_fini_eventq(channel);
 }
 
 static void efx_remove_eventq(struct efx_channel *channel)
 {
-        EFX_LOG(channel->efx, "chan %d remove event queue\n", channel->channel);
+        netif_dbg(channel->efx, drv, channel->efx->net_dev,
+                  "chan %d remove event queue\n", channel->channel);
 
         efx_nic_remove_eventq(channel);
 }
@@ -398,7 +409,8 @@ static int efx_probe_channel(struct efx_channel *channel)
         struct efx_rx_queue *rx_queue;
         int rc;
 
-        EFX_LOG(channel->efx, "creating channel %d\n", channel->channel);
+        netif_dbg(channel->efx, probe, channel->efx->net_dev,
+                  "creating channel %d\n", channel->channel);
 
         rc = efx_probe_eventq(channel);
         if (rc)
@@ -474,7 +486,8 @@ static void efx_init_channels(struct efx_nic *efx)
 
         /* Initialise the channels */
         efx_for_each_channel(channel, efx) {
-                EFX_LOG(channel->efx, "init chan %d\n", channel->channel);
+                netif_dbg(channel->efx, drv, channel->efx->net_dev,
+                          "init chan %d\n", channel->channel);
 
                 efx_init_eventq(channel);
 
@@ -501,7 +514,8 @@ static void efx_start_channel(struct efx_channel *channel)
 {
         struct efx_rx_queue *rx_queue;
 
-        EFX_LOG(channel->efx, "starting chan %d\n", channel->channel);
+        netif_dbg(channel->efx, ifup, channel->efx->net_dev,
+                  "starting chan %d\n", channel->channel);
 
         /* The interrupt handler for this channel may set work_pending
          * as soon as we enable it.  Make sure it's cleared before
@@ -526,7 +540,8 @@ static void efx_stop_channel(struct efx_channel *channel)
         if (!channel->enabled)
                 return;
 
-        EFX_LOG(channel->efx, "stop chan %d\n", channel->channel);
+        netif_dbg(channel->efx, ifdown, channel->efx->net_dev,
+                  "stop chan %d\n", channel->channel);
 
         channel->enabled = false;
         napi_disable(&channel->napi_str);
@@ -548,16 +563,19 @@ static void efx_fini_channels(struct efx_nic *efx)
                  * descriptor caches reference memory we're about to free,
                  * but falcon_reconfigure_mac_wrapper() won't reconnect
                  * the MACs because of the pending reset. */
-                EFX_ERR(efx, "Resetting to recover from flush failure\n");
+                netif_err(efx, drv, efx->net_dev,
+                          "Resetting to recover from flush failure\n");
                 efx_schedule_reset(efx, RESET_TYPE_ALL);
         } else if (rc) {
-                EFX_ERR(efx, "failed to flush queues\n");
+                netif_err(efx, drv, efx->net_dev, "failed to flush queues\n");
         } else {
-                EFX_LOG(efx, "successfully flushed all queues\n");
+                netif_dbg(efx, drv, efx->net_dev,
+                          "successfully flushed all queues\n");
         }
 
         efx_for_each_channel(channel, efx) {
-                EFX_LOG(channel->efx, "shut down chan %d\n", channel->channel);
+                netif_dbg(channel->efx, drv, channel->efx->net_dev,
+                          "shut down chan %d\n", channel->channel);
 
                 efx_for_each_channel_rx_queue(rx_queue, channel)
                         efx_fini_rx_queue(rx_queue);
@@ -572,7 +590,8 @@ static void efx_remove_channel(struct efx_channel *channel)
         struct efx_tx_queue *tx_queue;
         struct efx_rx_queue *rx_queue;
 
-        EFX_LOG(channel->efx, "destroy chan %d\n", channel->channel);
+        netif_dbg(channel->efx, drv, channel->efx->net_dev,
+                  "destroy chan %d\n", channel->channel);
 
         efx_for_each_channel_rx_queue(rx_queue, channel)
                 efx_remove_rx_queue(rx_queue);
@@ -623,12 +642,13 @@ void efx_link_status_changed(struct efx_nic *efx)
 
         /* Status message for kernel log */
         if (link_state->up) {
-                EFX_INFO(efx, "link up at %uMbps %s-duplex (MTU %d)%s\n",
-                         link_state->speed, link_state->fd ? "full" : "half",
-                         efx->net_dev->mtu,
-                         (efx->promiscuous ? " [PROMISC]" : ""));
+                netif_info(efx, link, efx->net_dev,
+                           "link up at %uMbps %s-duplex (MTU %d)%s\n",
+                           link_state->speed, link_state->fd ? "full" : "half",
+                           efx->net_dev->mtu,
+                           (efx->promiscuous ? " [PROMISC]" : ""));
         } else {
-                EFX_INFO(efx, "link down\n");
+                netif_info(efx, link, efx->net_dev, "link down\n");
         }
 
 }
@@ -732,7 +752,7 @@ static int efx_probe_port(struct efx_nic *efx)
 {
         int rc;
 
-        EFX_LOG(efx, "create port\n");
+        netif_dbg(efx, probe, efx->net_dev, "create port\n");
 
         if (phy_flash_cfg)
                 efx->phy_mode = PHY_MODE_SPECIAL;
@@ -746,15 +766,16 @@ static int efx_probe_port(struct efx_nic *efx)
         if (is_valid_ether_addr(efx->mac_address)) {
                 memcpy(efx->net_dev->dev_addr, efx->mac_address, ETH_ALEN);
         } else {
-                EFX_ERR(efx, "invalid MAC address %pM\n",
-                        efx->mac_address);
+                netif_err(efx, probe, efx->net_dev, "invalid MAC address %pM\n",
+                          efx->mac_address);
                 if (!allow_bad_hwaddr) {
                         rc = -EINVAL;
                         goto err;
                 }
                 random_ether_addr(efx->net_dev->dev_addr);
-                EFX_INFO(efx, "using locally-generated MAC %pM\n",
-                         efx->net_dev->dev_addr);
+                netif_info(efx, probe, efx->net_dev,
+                           "using locally-generated MAC %pM\n",
+                           efx->net_dev->dev_addr);
         }
 
         return 0;
@@ -768,7 +789,7 @@ static int efx_init_port(struct efx_nic *efx)
 {
         int rc;
 
-        EFX_LOG(efx, "init port\n");
+        netif_dbg(efx, drv, efx->net_dev, "init port\n");
 
         mutex_lock(&efx->mac_lock);
 
@@ -799,7 +820,7 @@ fail1:
 
 static void efx_start_port(struct efx_nic *efx)
 {
-        EFX_LOG(efx, "start port\n");
+        netif_dbg(efx, ifup, efx->net_dev, "start port\n");
         BUG_ON(efx->port_enabled);
 
         mutex_lock(&efx->mac_lock);
@@ -816,7 +837,7 @@ static void efx_start_port(struct efx_nic *efx)
 /* Prevent efx_mac_work() and efx_monitor() from working */
 static void efx_stop_port(struct efx_nic *efx)
 {
-        EFX_LOG(efx, "stop port\n");
+        netif_dbg(efx, ifdown, efx->net_dev, "stop port\n");
 
         mutex_lock(&efx->mac_lock);
         efx->port_enabled = false;
@@ -831,7 +852,7 @@ static void efx_stop_port(struct efx_nic *efx)
 
 static void efx_fini_port(struct efx_nic *efx)
 {
-        EFX_LOG(efx, "shut down port\n");
+        netif_dbg(efx, drv, efx->net_dev, "shut down port\n");
 
         if (!efx->port_initialized)
                 return;
@@ -845,7 +866,7 @@ static void efx_fini_port(struct efx_nic *efx)
 
 static void efx_remove_port(struct efx_nic *efx)
 {
-        EFX_LOG(efx, "destroying port\n");
+        netif_dbg(efx, drv, efx->net_dev, "destroying port\n");
 
         efx->type->remove_port(efx);
 }
@@ -863,11 +884,12 @@ static int efx_init_io(struct efx_nic *efx)
         dma_addr_t dma_mask = efx->type->max_dma_mask;
         int rc;
 
-        EFX_LOG(efx, "initialising I/O\n");
+        netif_dbg(efx, probe, efx->net_dev, "initialising I/O\n");
 
         rc = pci_enable_device(pci_dev);
         if (rc) {
-                EFX_ERR(efx, "failed to enable PCI device\n");
+                netif_err(efx, probe, efx->net_dev,
+                          "failed to enable PCI device\n");
                 goto fail1;
         }
 
@@ -885,39 +907,45 @@ static int efx_init_io(struct efx_nic *efx)
                 dma_mask >>= 1;
         }
         if (rc) {
-                EFX_ERR(efx, "could not find a suitable DMA mask\n");
+                netif_err(efx, probe, efx->net_dev,
+                          "could not find a suitable DMA mask\n");
                 goto fail2;
         }
-        EFX_LOG(efx, "using DMA mask %llx\n", (unsigned long long) dma_mask);
+        netif_dbg(efx, probe, efx->net_dev,
+                  "using DMA mask %llx\n", (unsigned long long) dma_mask);
         rc = pci_set_consistent_dma_mask(pci_dev, dma_mask);
         if (rc) {
                 /* pci_set_consistent_dma_mask() is not *allowed* to
                  * fail with a mask that pci_set_dma_mask() accepted,
                  * but just in case...
                  */
-                EFX_ERR(efx, "failed to set consistent DMA mask\n");
+                netif_err(efx, probe, efx->net_dev,
+                          "failed to set consistent DMA mask\n");
                 goto fail2;
         }
 
         efx->membase_phys = pci_resource_start(efx->pci_dev, EFX_MEM_BAR);
         rc = pci_request_region(pci_dev, EFX_MEM_BAR, "sfc");
         if (rc) {
-                EFX_ERR(efx, "request for memory BAR failed\n");
+                netif_err(efx, probe, efx->net_dev,
+                          "request for memory BAR failed\n");
                 rc = -EIO;
                 goto fail3;
         }
         efx->membase = ioremap_nocache(efx->membase_phys,
                                        efx->type->mem_map_size);
         if (!efx->membase) {
-                EFX_ERR(efx, "could not map memory BAR at %llx+%x\n",
-                        (unsigned long long)efx->membase_phys,
-                        efx->type->mem_map_size);
+                netif_err(efx, probe, efx->net_dev,
+                          "could not map memory BAR at %llx+%x\n",
+                          (unsigned long long)efx->membase_phys,
+                          efx->type->mem_map_size);
                 rc = -ENOMEM;
                 goto fail4;
         }
-        EFX_LOG(efx, "memory BAR at %llx+%x (virtual %p)\n",
-                (unsigned long long)efx->membase_phys,
-                efx->type->mem_map_size, efx->membase);
+        netif_dbg(efx, probe, efx->net_dev,
+                  "memory BAR at %llx+%x (virtual %p)\n",
+                  (unsigned long long)efx->membase_phys,
+                  efx->type->mem_map_size, efx->membase);
 
         return 0;
 
@@ -933,7 +961,7 @@ static int efx_init_io(struct efx_nic *efx)
 
 static void efx_fini_io(struct efx_nic *efx)
 {
-        EFX_LOG(efx, "shutting down I/O\n");
+        netif_dbg(efx, drv, efx->net_dev, "shutting down I/O\n");
 
         if (efx->membase) {
                 iounmap(efx->membase);
@@ -997,9 +1025,11 @@ static void efx_probe_interrupts(struct efx_nic *efx)
                         xentries[i].entry = i;
                 rc = pci_enable_msix(efx->pci_dev, xentries, n_channels);
                 if (rc > 0) {
-                        EFX_ERR(efx, "WARNING: Insufficient MSI-X vectors"
-                                " available (%d < %d).\n", rc, n_channels);
-                        EFX_ERR(efx, "WARNING: Performance may be reduced.\n");
+                        netif_err(efx, drv, efx->net_dev,
+                                  "WARNING: Insufficient MSI-X vectors"
+                                  " available (%d < %d).\n", rc, n_channels);
+                        netif_err(efx, drv, efx->net_dev,
+                                  "WARNING: Performance may be reduced.\n");
                         EFX_BUG_ON_PARANOID(rc >= n_channels);
                         n_channels = rc;
                         rc = pci_enable_msix(efx->pci_dev, xentries,
@@ -1023,7 +1053,8 @@ static void efx_probe_interrupts(struct efx_nic *efx)
                 } else {
                         /* Fall back to single channel MSI */
                         efx->interrupt_mode = EFX_INT_MODE_MSI;
-                        EFX_ERR(efx, "could not enable MSI-X\n");
+                        netif_err(efx, drv, efx->net_dev,
+                                  "could not enable MSI-X\n");
                 }
         }
 
@@ -1036,7 +1067,8 @@ static void efx_probe_interrupts(struct efx_nic *efx)
                 if (rc == 0) {
                         efx->channel[0].irq = efx->pci_dev->irq;
                 } else {
-                        EFX_ERR(efx, "could not enable MSI\n");
+                        netif_err(efx, drv, efx->net_dev,
+                                  "could not enable MSI\n");
                         efx->interrupt_mode = EFX_INT_MODE_LEGACY;
                 }
         }
@@ -1090,7 +1122,7 @@ static int efx_probe_nic(struct efx_nic *efx)
 {
         int rc;
 
-        EFX_LOG(efx, "creating NIC\n");
+        netif_dbg(efx, probe, efx->net_dev, "creating NIC\n");
 
         /* Carry out hardware-type specific initialisation */
         rc = efx->type->probe(efx);
@@ -1112,7 +1144,7 @@ static int efx_probe_nic(struct efx_nic *efx)
 
 static void efx_remove_nic(struct efx_nic *efx)
 {
-        EFX_LOG(efx, "destroying NIC\n");
+        netif_dbg(efx, drv, efx->net_dev, "destroying NIC\n");
 
         efx_remove_interrupts(efx);
         efx->type->remove(efx);
@@ -1132,14 +1164,14 @@ static int efx_probe_all(struct efx_nic *efx)
         /* Create NIC */
         rc = efx_probe_nic(efx);
         if (rc) {
-                EFX_ERR(efx, "failed to create NIC\n");
+                netif_err(efx, probe, efx->net_dev, "failed to create NIC\n");
                 goto fail1;
         }
 
         /* Create port */
         rc = efx_probe_port(efx);
         if (rc) {
-                EFX_ERR(efx, "failed to create port\n");
+                netif_err(efx, probe, efx->net_dev, "failed to create port\n");
                 goto fail2;
         }
 
@@ -1147,8 +1179,9 @@ static int efx_probe_all(struct efx_nic *efx)
         efx_for_each_channel(channel, efx) {
                 rc = efx_probe_channel(channel);
                 if (rc) {
-                        EFX_ERR(efx, "failed to create channel %d\n",
-                                channel->channel);
+                        netif_err(efx, probe, efx->net_dev,
+                                  "failed to create channel %d\n",
+                                  channel->channel);
                         goto fail3;
                 }
         }
@@ -1344,8 +1377,9 @@ static void efx_monitor(struct work_struct *data)
         struct efx_nic *efx = container_of(data, struct efx_nic,
                                            monitor_work.work);
 
-        EFX_TRACE(efx, "hardware monitor executing on CPU %d\n",
-                  raw_smp_processor_id());
+        netif_vdbg(efx, timer, efx->net_dev,
+                   "hardware monitor executing on CPU %d\n",
+                   raw_smp_processor_id());
         BUG_ON(efx->type->monitor == NULL);
 
         /* If the mac_lock is already held then it is likely a port
@@ -1452,8 +1486,8 @@ static int efx_net_open(struct net_device *net_dev)
         struct efx_nic *efx = netdev_priv(net_dev);
         EFX_ASSERT_RESET_SERIALISED(efx);
 
-        EFX_LOG(efx, "opening device %s on CPU %d\n", net_dev->name,
-                raw_smp_processor_id());
+        netif_dbg(efx, ifup, efx->net_dev, "opening device on CPU %d\n",
+                  raw_smp_processor_id());
 
         if (efx->state == STATE_DISABLED)
                 return -EIO;
@@ -1478,8 +1512,8 @@ static int efx_net_stop(struct net_device *net_dev)
 {
         struct efx_nic *efx = netdev_priv(net_dev);
 
-        EFX_LOG(efx, "closing %s on CPU %d\n", net_dev->name,
-                raw_smp_processor_id());
+        netif_dbg(efx, ifdown, efx->net_dev, "closing on CPU %d\n",
+                  raw_smp_processor_id());
 
         if (efx->state != STATE_DISABLED) {
                 /* Stop the device and flush all the channels */
@@ -1532,8 +1566,9 @@ static void efx_watchdog(struct net_device *net_dev)
 {
         struct efx_nic *efx = netdev_priv(net_dev);
 
-        EFX_ERR(efx, "TX stuck with port_enabled=%d: resetting channels\n",
-                efx->port_enabled);
+        netif_err(efx, tx_err, efx->net_dev,
+                  "TX stuck with port_enabled=%d: resetting channels\n",
+                  efx->port_enabled);
 
         efx_schedule_reset(efx, RESET_TYPE_TX_WATCHDOG);
 }
@@ -1552,7 +1587,7 @@ static int efx_change_mtu(struct net_device *net_dev, int new_mtu)
 
         efx_stop_all(efx);
 
-        EFX_LOG(efx, "changing MTU to %d\n", new_mtu);
+        netif_dbg(efx, drv, efx->net_dev, "changing MTU to %d\n", new_mtu);
 
         efx_fini_channels(efx);
 
@@ -1578,8 +1613,9 @@ static int efx_set_mac_address(struct net_device *net_dev, void *data)
         EFX_ASSERT_RESET_SERIALISED(efx);
 
         if (!is_valid_ether_addr(new_addr)) {
-                EFX_ERR(efx, "invalid ethernet MAC address requested: %pM\n",
-                        new_addr);
+                netif_err(efx, drv, efx->net_dev,
+                          "invalid ethernet MAC address requested: %pM\n",
+                          new_addr);
                 return -EINVAL;
         }
 
@@ -1682,7 +1718,6 @@ static int efx_register_netdev(struct efx_nic *efx)
         net_dev->watchdog_timeo = 5 * HZ;
         net_dev->irq = efx->pci_dev->irq;
         net_dev->netdev_ops = &efx_netdev_ops;
-        SET_NETDEV_DEV(net_dev, &efx->pci_dev->dev);
         SET_ETHTOOL_OPS(net_dev, &efx_ethtool_ops);
 
         /* Clear MAC statistics */
@@ -1707,7 +1742,8 @@ static int efx_register_netdev(struct efx_nic *efx)
 
         rc = device_create_file(&efx->pci_dev->dev, &dev_attr_phy_type);
         if (rc) {
-                EFX_ERR(efx, "failed to init net dev attributes\n");
+                netif_err(efx, drv, efx->net_dev,
+                          "failed to init net dev attributes\n");
                 goto fail_registered;
         }
 
@@ -1715,7 +1751,7 @@ static int efx_register_netdev(struct efx_nic *efx)
 
 fail_locked:
         rtnl_unlock();
-        EFX_ERR(efx, "could not register net dev\n");
+        netif_err(efx, drv, efx->net_dev, "could not register net dev\n");
         return rc;
 
 fail_registered:
@@ -1780,7 +1816,7 @@ int efx_reset_up(struct efx_nic *efx, enum reset_type method, bool ok)
 
         rc = efx->type->init(efx);
         if (rc) {
-                EFX_ERR(efx, "failed to initialise NIC\n");
+                netif_err(efx, drv, efx->net_dev, "failed to initialise NIC\n");
                 goto fail;
         }
 
@@ -1792,7 +1828,8 @@ int efx_reset_up(struct efx_nic *efx, enum reset_type method, bool ok)
                 if (rc)
                         goto fail;
                 if (efx->phy_op->reconfigure(efx))
-                        EFX_ERR(efx, "could not restore PHY settings\n");
+                        netif_err(efx, drv, efx->net_dev,
+                                  "could not restore PHY settings\n");
         }
 
         efx->mac_op->reconfigure(efx);
@@ -1825,13 +1862,14 @@ int efx_reset(struct efx_nic *efx, enum reset_type method)
         int rc, rc2;
         bool disabled;
 
-        EFX_INFO(efx, "resetting (%s)\n", RESET_TYPE(method));
+        netif_info(efx, drv, efx->net_dev, "resetting (%s)\n",
+                   RESET_TYPE(method));
 
         efx_reset_down(efx, method);
 
         rc = efx->type->reset(efx, method);
         if (rc) {
-                EFX_ERR(efx, "failed to reset hardware\n");
+                netif_err(efx, drv, efx->net_dev, "failed to reset hardware\n");
                 goto out;
         }
 
@@ -1856,10 +1894,10 @@ out:
 
         if (disabled) {
                 dev_close(efx->net_dev);
-                EFX_ERR(efx, "has been disabled\n");
+                netif_err(efx, drv, efx->net_dev, "has been disabled\n");
                 efx->state = STATE_DISABLED;
         } else {
-                EFX_LOG(efx, "reset complete\n");
+                netif_dbg(efx, drv, efx->net_dev, "reset complete\n");
         }
         return rc;
 }
@@ -1877,7 +1915,8 @@ static void efx_reset_work(struct work_struct *data)
         /* If we're not RUNNING then don't reset. Leave the reset_pending
          * flag set so that efx_pci_probe_main will be retried */
         if (efx->state != STATE_RUNNING) {
-                EFX_INFO(efx, "scheduled reset quenched. NIC not RUNNING\n");
+                netif_info(efx, drv, efx->net_dev,
+                           "scheduled reset quenched. NIC not RUNNING\n");
                 return;
         }
 
@@ -1891,7 +1930,8 @@ void efx_schedule_reset(struct efx_nic *efx, enum reset_type type)
         enum reset_type method;
 
         if (efx->reset_pending != RESET_TYPE_NONE) {
-                EFX_INFO(efx, "quenching already scheduled reset\n");
+                netif_info(efx, drv, efx->net_dev,
+                           "quenching already scheduled reset\n");
                 return;
         }
 
@@ -1915,10 +1955,12 @@ void efx_schedule_reset(struct efx_nic *efx, enum reset_type type)
         }
 
         if (method != type)
-                EFX_LOG(efx, "scheduling %s reset for %s\n",
-                        RESET_TYPE(method), RESET_TYPE(type));
+                netif_dbg(efx, drv, efx->net_dev,
+                          "scheduling %s reset for %s\n",
+                          RESET_TYPE(method), RESET_TYPE(type));
         else
-                EFX_LOG(efx, "scheduling %s reset\n", RESET_TYPE(method));
+                netif_dbg(efx, drv, efx->net_dev, "scheduling %s reset\n",
+                          RESET_TYPE(method));
 
         efx->reset_pending = method;
 
@@ -2005,6 +2047,7 @@ static int efx_init_struct(struct efx_nic *efx, struct efx_nic_type *type,
         INIT_WORK(&efx->reset_work, efx_reset_work);
         INIT_DELAYED_WORK(&efx->monitor_work, efx_monitor);
         efx->pci_dev = pci_dev;
+        efx->msg_enable = debug;
         efx->state = STATE_INIT;
         efx->reset_pending = RESET_TYPE_NONE;
         strlcpy(efx->name, pci_name(pci_dev), sizeof(efx->name));
@@ -2124,7 +2167,7 @@ static void efx_pci_remove(struct pci_dev *pci_dev)
         efx_pci_remove_main(efx);
 
         efx_fini_io(efx);
-        EFX_LOG(efx, "shutdown successful\n");
+        netif_dbg(efx, drv, efx->net_dev, "shutdown successful\n");
 
         pci_set_drvdata(pci_dev, NULL);
         efx_fini_struct(efx);
@@ -2149,13 +2192,15 @@ static int efx_pci_probe_main(struct efx_nic *efx)
 
         rc = efx->type->init(efx);
         if (rc) {
-                EFX_ERR(efx, "failed to initialise NIC\n");
+                netif_err(efx, probe, efx->net_dev,
+                          "failed to initialise NIC\n");
                 goto fail3;
         }
 
         rc = efx_init_port(efx);
         if (rc) {
-                EFX_ERR(efx, "failed to initialise port\n");
+                netif_err(efx, probe, efx->net_dev,
+                          "failed to initialise port\n");
                 goto fail4;
         }
 
@@ -2211,11 +2256,13 @@ static int __devinit efx_pci_probe(struct pci_dev *pci_dev,
                                    NETIF_F_HIGHDMA | NETIF_F_TSO);
         efx = netdev_priv(net_dev);
         pci_set_drvdata(pci_dev, efx);
+        SET_NETDEV_DEV(net_dev, &pci_dev->dev);
         rc = efx_init_struct(efx, type, pci_dev, net_dev);
         if (rc)
                 goto fail1;
 
-        EFX_INFO(efx, "Solarflare Communications NIC detected\n");
+        netif_info(efx, probe, efx->net_dev,
+                   "Solarflare Communications NIC detected\n");
 
         /* Set up basic I/O (BAR mappings etc) */
         rc = efx_init_io(efx);
@@ -2253,7 +2300,7 @@ static int __devinit efx_pci_probe(struct pci_dev *pci_dev,
         }
 
         if (rc) {
-                EFX_ERR(efx, "Could not reset NIC\n");
+                netif_err(efx, probe, efx->net_dev, "Could not reset NIC\n");
                 goto fail4;
         }
 
@@ -2265,7 +2312,7 @@ static int __devinit efx_pci_probe(struct pci_dev *pci_dev,
         if (rc)
                 goto fail5;
 
-        EFX_LOG(efx, "initialisation successful\n");
+        netif_dbg(efx, probe, efx->net_dev, "initialisation successful\n");
 
         rtnl_lock();
         efx_mtd_probe(efx); /* allowed to fail */
@@ -2281,7 +2328,7 @@ static int __devinit efx_pci_probe(struct pci_dev *pci_dev,
         efx_fini_struct(efx);
  fail1:
         WARN_ON(rc > 0);
-        EFX_LOG(efx, "initialisation failed. rc=%d\n", rc);
+        netif_dbg(efx, drv, efx->net_dev, "initialisation failed. rc=%d\n", rc);
         free_netdev(net_dev);
         return rc;
 }